包含trains的显式化APL表达式

Question

相关：明确括号内的APL列车

背景

在最基本的形式中，APL有两种标记:数组和函数。对于这个挑战，我们将使用小写字母a-z作为数组，大写字母A-Z用于函数。此外，我们将假设每个字符都是自己的令牌；Fx等同于F x。

APL有两种调用函数的方法:一元(取一个参数)和并进(使用两个参数)。一元应用程序是用前缀F x编写的，而二进位应用程序是用infix x F y编写的。没有什么像“操作符优先级”那样；APL表达式总是从右到左计算，可以用括号()覆盖它。

x F G y -> x F (G y)
F x G y -> F (x G y)
x F y G z -> x F (y G z)
(F x) G H y -> (F x) G (H y)

训练是合成函数的一种方法，可以导出更复杂的函数。本质上，当最右边的记号是一个函数时，就形成了一列火车。以下是2和3代币列车的规则：

(F G H) x -> (F x) G (H x)
(u G H) x -> u G (H x)
(G H) x -> G (H x)

x (F G H) y -> (x F y) G (x H y)
x (u G H) y -> u G (x H y)
x (G H) y -> G (x H y)

对于4-令牌和更长的列车，最右边的3个令牌被递归地分组，形成一个派生函数，直到2或3个令牌仍然存在。从总体上看，可以认为如下：

Odd-length trains
(V D V D ... V D V) x -> (V x) D (V x) D ... (V x) D (V x)
x (V D V D ... V D V) y -> (x V y) D (x V y) D ... (x V y) D (x V y)

Even-length trains
(M V D V D ... V D V) x -> M (V x) D (V x) D ... (V x) D (V x)
x (M V D V D ... V D V) y -> M (x V y) D (x V y) D ... (x V y) D (x V y)

如果数组u出现在V位置(最后一个位置除外)，则只需用u替换Coresponse(V x)或(x V y)。出现在M或D位置的数组是语法错误。

请注意，trains还可能有计算数组或函数的子表达式：

x ((D a) F G (u H J) K) y
   Expand 5(odd)-token train, leftmost V position being an array (D a)
-> (D a) F (x G y) (u H J) (x K y)
   Expand 3(odd)-token train (u H J)
-> (D a) F (u H (x G y) J (x K y))

挑战

给定计算为数组(可能包括或不包括一个或多个trains)的APL表达式行，将其转换为没有列的等效表达式。

您可以假设输入在上述规则下是有效的，并且不包含任何空格。您不需要过多地担心输出中的括号或空格；如果缺少或多余的括号/空格，只要它们表示等效的表达式，就可以了。

适用标准的密码-高尔夫规则。以字节为单位的最短代码获胜。

测试用例

x(XY)y -> X(xYy)
uKKKv -> uKKKv
U(xVW)yZa -> UxVWyZa
MnP(QRsTU)VWx -> MnP(QVWx)RsTUVWx
x(XXxYYYdDD)y -> (xXy)XxY(xYy)YdDxDy
a((DEF)GHJ)Kb -> (D(aGKb)HaJKb)EF(aGKb)HaJKb
c((k(PQRSTU)m)(VW)(XY)(ZA)BCD)n -> V(P(kQm)R(kSm)T(kUm))WZ(XcYn)A(cBn)C(cDn)

Answer 1

Python3,887字节：

def p(s):
 r=[]
 while s and(S:=s[0])!=')':
  if S.isalpha():r+=[s[0]]
  if'('==S:r+=[(K:=p(s[1:]))[0]];s=K[1]
  s=s[1:]
 return r,s
F=lambda x:(O:=ord(str(x)[0]))<=91 and(64<O<91 or all(F(i)for i in x[-2:]))
R=lambda x:[i for i in x if i]
def f(s,l=0,r=0):
 if F(s):
  J=[]
  while s:
   if F(S:=s.pop(0))==0:J+=[S]
   else:
    if len(s)>1 and F(s[0])==0:J+=[[S,s.pop(0)]]
    else:J+=[S]
  s=J
  c,s=[f([*s[0]])]if(t:=F(s[0])==0)else[],s[t:]
  c+=[f(R([l,s[0],r]))]if(S:=sum(map(F,s))%2)else[];s=s[S:]
  while s:
   if F(s[0])==0:c+=[s[0]];s=s[1:];continue
   a,b=s[:2];c+=[a,f(R([l,b,r]))if F(b) else f(b)];s=s[2:]
  return f(c)
 c=[]
 while s:
  if F(j:=s.pop(0)) and type(j)==list:
   c+=[f(j,l=c and not F(c[-1])and c.pop(),r=f(s))]
  else:c+=[j]
 return c
P=lambda e,l=0:e if str==type(e)else '('*(Y:=(l>0 and len(e)>1))+''.join(P(i,l+1)for i in e)+')'*Y
M=lambda s:P(f(p(s)[0]))

在网上试试！

这最终比我原先预期的要长，但这是一个很有趣的问题，我想我应该添加一个非APL的、基于解析的解决方案。