细节

编写一个函数或程序，给定一个仅包含整数的数组（或列表），该函数或程序将返回或输出一个反转了所有子元素的数组。也就是说，颠倒最深数组的所有元素，然后颠倒第二个最深的数组，依此类推。不必指定维度，但是函数或程序必须适用于编程语言本机格式的锯齿状数组。

例子

这个：

[[1,2], [3,4]]

会变成这样：

[[4,3], [2,1]]

这个：

[[[ 1, 2, 3], [ 4, 5, 6], [ 7, 8, 9]],
 [[10,11,12], [13,14,15], [16,17,18]],
 [[19,20,21], [22,23,24], [25,26,27]],
 [[28,29,30], [31,32,33], [34,35,36]],
 [[37,38,39], [40,41,42], [43,44,45]],
 [[46,47,48], [49,50,51], [52,53,54]]]

会变成这样：

[[[54,53,52], [51,50,49], [48,47,46]],
 [[45,44,43], [42,41,40], [39,38,37]],
 [[36,35,34], [33,32,31], [30,29,28]],
 [[27,26,25], [24,23,22], [21,20,19]],
 [[18,17,16], [15,14,13], [12,11,10]],
 [[ 9, 8, 7], [ 6, 5, 4], [ 3, 2, 1]]]

这个：

[[[1,2]],
 [[3,4], [5]],
 [[6,7,8], [9], [10,11]],
 [[[12,13], [14,15]], [16], [17,18,19,20]],
 [21]]

会变成这样：

[[21],
 [[20,19,18,17], [16], [[15,14], [13,12]]],
 [[11,10], [9], [8,7,6]],
 [[5], [4,3]],
 [[2,1]]]

奖金

希望这会鼓励一些面向对象的编程语言的答案...

-50％字节数如果您的程序可以将数组（或列表）及其各种类型的成员（这些对象可以是对象的形式）作为输入并成功地反转所有数组。

这个：

[["Foo",["Bar",1]],
  2,
 ["Baz"],
 [[["Qux"],3],3.14]]

会变成这样：

[[3.14,[3,["Qux"]]],
 ["Baz"],
  2,
 [[1,"Bar"],"Foo"]]

Pyth，11-50％= 5.5字节

L?+IbY_yMbb

在线尝试：演示或测试套件。

这定义了一个功能y。额外的3个字节<newline>yQ仅用输入列表调用该函数，因此不需要计入总字节数。

说明：

L?+IbY_yMbb
L             define a function y(b), that returns:
 ?+IbY           if b + [] == b (test if b is a list):
      _yMb           recursively call y on all elements in b, then reverse the list
          b      else: b

Dyalog APL，14-50％= 7字节

{∇¨⍣(×|≡⍵)⌽⍵}

⌽⍵
⍣(×|≡⍵)如果参数不是原子（[绝对]深度的符号），则为反向参数...
∇¨...将函数应用于（反向参数的）每个元素。

如果是⎕ML←3（IBM风格）（在从APL2迁移的系统上就是这种情况），则可以通过删除来保存一个字节|。

在线尝试APL。

出于好奇，建议将 int和float反转：

{∇¨⍣(×≡⍵){0::⌽⍵⋄⍎⌽⍕⍵}⍵}

内部功能：

0::⌽⍵如果发生任何错误，只需将revesed参数
⍎⌽⍕make转换为字符串，反之，将其转换为number

Prolog，40-50％= 20字节

a(X,Y):-reverse(X,Z),maplist(a,Z,Y);X=Y.

对于列表的每个成员，此操作递归调用predicate a/2with maplist/3，直到reverse/2失败（即，最后一个元素不是列表）。

Python 2，40-50％= 20

f=lambda x:map(f,x)[::-1]if"">x>[]else x

获得基本奖励只需要对基本方法进行一些小的修改。使用所有列表均小于空字符串且所有数字均小于空列表的事实。

所有测试用例

Emacs Lisp，46个字节* 0.5 = 23

(defun g(x)(if(atom x)x(mapcar'g(reverse x))))

用法示例：(g '((1 2) 3 (four 5)))->((5 four) 3 (2 1))

经典的递归方法：如果参数不是列表，则将其保持不变；如果参数是列表，则将函数映射到列表的反面。

Mathematica，34/2 = 17个字节

Quiet[Reverse//@#]/.Reverse->(#&)&

或者只是Reverse//@#&如果您想要Reverse到处都有大量错误和错误。

Clojure 43/2 = 21.5字节

(defn f[x](if(coll? x)(reverse(map f x))x))

JavaScript ES6，42-50％= 21字节

我的分数在很多方面都很完美。实现一个函数r，将其递归地应用于其输入的成员。

r=a=>Array.isArray(a)?a.reverse().map(r):a

如果我们假设没有对象具有属性pop，那么由于dev-null的关系，它变为（31-50％= 15.5）：

r=a=>a.pop?a.reverse().map(r):a

或者，如果我们假设对象具有健全的reverse属性，我们也可以这样做（35％-50％= 17.5）：

r=a=>a[R="reverse"]?a[R]().map(r):a

Lua 111 99 * .5 = 55.5 49.5字节

function r(a)local t={}for i,v in next,a do t[#a+1-i]=type(v)=="table"and r(v)or v end return t end

很好的递归

CJam，20个字节* 50％= 10

{_`0='[={W%{F}%}&}:F

定义F可应用于堆栈顶部数组的命名块（或其他任何情况，在这种情况下为无操作）。

在这里测试。

Brachylog，5-50％= 2.5字节

ċ↔↰ᵐ|

在线尝试！

         The input
ċ        which is a list
 ↔       reversed
   ᵐ     with each element
  ↰      passed through this same predicate
    |    is the output. If the input isn't a list,
         it is the output.

由于↔还可以反转字符串和整数，因此我们必须使用显式地使非列表失败ċ。

Wolfram语言（Mathematica），23 -50％= 11.5字节

#/.List->Reverse@*List&

在线尝试！

ListMathematica（{...}）中的s 等价于List[...]。@*是该组合物操作，所以替换的每次出现时List与Reverse@*List反转发生的每一个输入端（列表Reverse@*List[...]= Reverse[{...}]）。

24 -50％= 12字节

#~Reverse~Range@Depth@#&

在线尝试！

不仅适用于List。

Clojure，38个字节

（我猜这是一个奖励，但是Clojure是一种动态语言，因此它是免费提供的）

(fn f[x](if(seq? x)(map f(into()x))x))

这是一个很好的开始，但未采用以下优化：

• 定义一个匿名函数，fn而不是使用命名函数defn。但是我们仍然需要一个“作用域”名称f进行递归
• 以输入作为一个列表，而不是载体，那么我们就可以用seq?的，而不是coll?
• 使用(into () ...)代替reverse
• x映射前先反转，然后我们不需要那么多空格

Ruby，32-50％= 16字节

递归函数。在尝试输入数字或字符串时，使用rescuecatch NoMethodError触发的结果要比通过检查输入是否为数组短2个字节。reversemapa==[*a]

f=->a{a.reverse.map(&f)rescue a}

在线尝试！