求助各位大神, 如何将(a,(b,(c,(d,(e,(f))))))转换为(f,(e,(d,(c,(b,(a))))))

一个笨办法，但是能实现你的要求

def flatten(l):
ret = []
for elem in l:
if isinstance(elem, list):
ret.extend(flatten(elem))
else:
ret.append(elem)
return ret


def reconstruct(l):
inner = [l[0]]

for elem in l[1:]:
inner = [elem, inner]

return inner


if __name__ == '__main__':
print(reconstruct(flatten(['a', ['b', ['c', ['d', ['e', ['f']]]]]])))

排版乱了…看这里吧 https://paste.ubuntu.com/p/5F27Gybh4F/

source = ('a',('b',('c',('d',('e',('f'))))))
target = None
while True:
target = (source[0],) if target is None else (source[0], target)
if len(source) == 2:
source = source[1]
else:
break

print(target)

替换掉字符串包含的括号,按字符串内字母(a,b,c,d,e,f)的字典顺序倒排,再按字符串长度加上括号,可以么

感谢各位大佬,学习了

前后一起搜索，找到一对字符进行交换，然后继续搜索

双栈运算了解一下

import re
a = '(a,(b,(c,(d,(e,(f))))))'
re.sub(r'\((.*?),\((.*?),\((.*?),\((.*?),\((.*?),\((.*?)\)\)\)\)\)\)',r'(\6,(\5,(\4,(\3,(\2,(\1))))))',a)

@summerwar #8 万一不是 6 个呢

@ballshapesdsd 以此类推即可。

解决问题的关键是解决当下的，如果想写一个函数适用于所有情况，那是不可能的

let a = '(a,(b,(c,(d,(e,(f))))))';
rst = a.substr(0,a.indexOf(')')).split(',').reverse().join(',') + a.substr(a.indexOf(')'));
console.log(rst);
这样呢

ast.parse 了解一下？

不是双栈，是一个队列的事儿

当作一个字符串，从头开始遍历，用数组 arr 记下字母的值。 再次遍历，判断是字母则反向插入 arr 各个值。

楼上正解

入栈的时候去掉括号，再出栈配上括号就行了。

任何函数式语言都自带这个操作：reverse


谁教教我插图片啊 ><

<img src="https://i.loli.net/2018/03/17/5aad2b85743e9.png">

<img src="https://i.loli.net/2018/03/17/5aad2b85743e9.png" class="embedded_image">

然后再用 Python 写一个 lisp 解释器就可以了；）

这个就是一个单链表反转, 不用栈操作, 直接把字母全都提取出来, 倒序, 然后加括号就行了, 你看你的输出, 除了最后的右括号, 左边的实际上就是一个简单的循环结构, 一个 for loop 完成
(f,(e,(d,(c,(b,(a,
去掉最后一个逗号, 然后加上对应数量的右括号就行了;

用快排的思想？
https://i.loli.net/2018/03/17/5aad35af8af2a.png

@whileFalse 求详解，get 不到重点。

为什么你们都把输入当做字符串，不是 tuple 吗？如果允许稍微改一下题目，在最后加一个 nil 就很简单了：

l = ('a', ('b', ('c', ('d', ('e', ('f', ()))))))
acc = ()
while l:
　　 acc, l = (l[0], acc), l[1]

@contmonad
不用改题目
看 3l 回答，是一样的方法

@contmonad 完美

1.正则提取->列表 A
2.A 倒序->B
3.AB zip ->二维列表 C
4.替换 C （有需要的话用正则）
有需要的 escape 一下

数据源非字符串的话，可以借用 json 过渡

import re
def wtf(s):
return re.sub('\w', '{}', s).format(*[i for i in s[::-1] if i.isalpha()])

"Life is short"

这个不是二叉树么！

我怎么觉得应该把这串字符转换成树形结构，用中序或者后序遍历

递归就可以吧

two pointer ？

>>> def reverse(a):
... f = (lambda x, y : (x[0],y) if len(x)==1 else f(x[1], (x[0],y)))
... return f(a[1], (a[0],))
...
>>> reverse(('a',('b',('c',('d',('e',('f',)))))))
('f', ('e', ('d', ('c', ('b', ('a',))))))

>>> n=ord('f')-ord('a')
>>> for x in s:
... if x in string.ascii_letters:
... print(chr(ord(x)+n), end=''); n-=2
... else: print(x,end='')
... print()

@contmonad #28
@qq529633582 #37

老师，这题太难了，我自己换了个题啊

差一点，

print(reduce(lambda a, b: "({},({}))".format(str(b), str(a)), "(a,(b,(c,(d,(e,(f))))))".replace("(", "").replace(")", "").split(",")))

print("({})".format(reduce(lambda a, b: "{},({})".format(b, a), "(a,(b,(c,(d,(e,(f))))))".replace("(", "").replace(")", "").split(","))))

写个有可读性的。

```
const source = '(a,(b,(c,(d,(e,(f))))))';
const sourceList = source.split('');

const charList = [];
const keyList = [];

// Find Char & Key
sourceList.map((char, i) => {
if (/[a-z]/i.test(char)) {
charList.push(char);
keyList.push(i);
}
});

// Replace sourceList String
keyList.map((key, i) => {
sourceList[key] = charList.reverse()[i];
});

// (a,(b,(c,(d,(e,(f))))))
console.log(source);

// (f,(b,(d,(d,(b,(f))))))
console.log(sourceList.join(''));
```

https://gist.github.com/SolidZORO/d30fdac96fd00af1be9b77e2c64ab9fa

♂ 看了下节点，JS 代码误入。

from functools import reduce

def f(ys,s=[]):
x,xs = ys
if type(xs) != tuple:
return reduce(lambda x,y: (y,(x)), s+[x,xs])
return f(xs,s+[x])

-from functools import reduce
-
-def f(ys,s=[]):
-----x,xs = ys
-----if type(xs) != tuple:
---------return reduce(lambda x,y: (y,(x)), s+[x,xs])
-----return f(xs,s+[x])

a = ('a', ('b', ('c', ('d', ('e', ('f'))))))
from functools import reduce


def reverse(T):
ret = []
while len(T) != 1:
ret.append(T[0])
T = T[-1]
ret.append(T[0])
return reduce(lambda x, y: (y, x), ret)


x = reverse(a)
print(x)

https://i.loli.net/2018/03/18/5aadf54a54966.png https://i.loli.net/2018/03/18/5aadf5511eaea.png

大神真多。

乱入一个 Javascript 的 版本..

```js
const str = '(a,(b,(c,(d,(e,(f))))))'
const tmp = str.match(/\w/g)

str.replace(/\w/g, $1 => tmp.pop())
```

大佬们秀的我头晕

感觉歪了啊, 这题考的应该是 lexer 方面的知识吧?

当成链表
<script src="https://gist.github.com/3vilive/f1ee3e138a121e7d203ed827c67caf4c.js"></script>

如果没有特殊规定一般情况怎么处理的话， 我觉得是递归查找最内侧的括号，然后一层一层往外翻，每翻一层，然后把原来内部括号外侧的的元素括起来,替换掉递归层...
这样改过顺序的
((((((f),e),d),c),b),a) 大概会翻成 ((((((a),b),c),d),e),f)
不知猜的对不对...
上面代码比较多，有可能有满足这个的代码没看到，提前抱歉

我其实就想知道问题到底是什么。
输入 /输出 的到底是 字符串 /多层列表？
另外，中间有一处出现 3 个的话怎么办？换句话说 (a,b,(c))=>?

如果是按考试风格题目，输入输出均为多层列表，无异常情况，不就是个 reverse 么（把 list 看作 cons ）

def mdreverse(inp, sav=[]):
if len(inp) == 0:
return sav
car, cdr, *_ = inp+[[]]
return multireverse(cdr, [car, sav] if sav else [car])

mdreverse([1,[2,[3]]]) # [3, [2, [1]]]
mdreverse([1]) # [1]
mdreverse([1,[2,[3,[4,[5,[6]]]]]]) # [6, [5, [4, [3, [2, [1]]]]]]
mdreverse([]) # []

@gowl #24 用 imgur 的图可以，你这个好像经常不行

正则表达式的平衡组专门用于解决这种 nested 结构的解析等问题，了解一下

正则：\([^\)]*[^\(\)]*(((?'Open'\([^\(]*)[^\(\)]*)+((?'-Open'\)))+)*(?(Open)(?!))
源文本：(a,(b,(c,(d,(e,(f))))))
匹配结果：(a,(b,(c,(d,(e,(f

拿到匹配结果再处理、reverse

前提是你的运行环境的正则引擎支持平衡组

@think2011 awesome ! Give u ten B.

str1 = '(a,(b,(c,(d,(e,(f,g)))))))'
str1 = str1.replace(')', ' ').replace('(', ' ').replace(',', ' ')
str1 = str1[::-1].split()
str1 = '(' + ',('.join(str1) + ')' * len(str1)
print(str1)

@Antidictator 多谢～

@param 请问手机上使用 ipython 是什么软件？

@dizzy termux

def get_elements(s):
q = []
while len(s) != 1:
q.append(s[0])
s = s[1]
q.append(s)

return q


def nested_list(l):
res = ()
ele0 = l[0]
res += (ele0, )
l.remove(ele0)
if len(l) > 0:
res += ((nested_list(l), ))

return res


def main():
s = ('a', ('b', ('c', ('d', ('e', ('f'))))))
l = get_elements(s)
l = l[::-1]
ll = nested_list(l)
print(ll)


if __name__ == '__main__':
main()

最简单的思路…一个队列一个栈
```
def main(source_str):
el = []
ret = []
for i in source_str:
if i not in ('(', ',', ')'):
el.append(i)
ret.append("#")
else:
ret.append(i)

for index, value in enumerate(ret):
if value == "#":
ret[index] = el.pop()

return "".join(ret)


if __name__ == "__main__":
result = main("(a,(b,(c,(d,(e,(f))))))")
print(result)
```