Reverse an N-Dimensional array

Question

Details

Write a function or program that, given an array (or list), containing only integers, returns or output an array with all sub-elements reversed. That is, reverse all elements of the deepest array, then the second deepest, etc. The dimensions need not be specified, but the function or program must work for jagged arrays in your programming language's native format.

---

Examples

This:

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

Would become this:

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

---

This:

[[[ 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]]]

Would become this:

[[[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]]]

---

This:

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

Would become this:

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

---

Bonus

This will hopefully encourage answers in some object-oriented programming languages...

-50% Bytecount If your program can take as input an array (or list) with its member's of various types (these can be in the form of objects) and successfully reverse all arrays.

This:

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

Would become this:

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

Answer 1

Pyth, 11 - 50% = 5.5 bytes

L?+IbY_yMbb

Try it online: Demonstration or Test Suite.

This defines a function y. The additional 3 bytes <newline>yQ simply call the function with the input list and therefore doesn't need to be counted towards the bytes total.

Explanation:

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

Answer 2

Dyalog APL, 14 - 50% = 7 bytes

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

⌽⍵ reverse argument
⍣(×|≡⍵) if the argument is not an atom (sign of the [absolute] depth)...
∇¨ ... apply the function to each element (of the reversed argument).

If ⎕ML←3 (IBM style), which is the case on systems that migrated from APL2, one byte can be saved by removing |.

Try APL online.

For curiosity, the proposed int and float reversing:

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

The inner function:

0::⌽⍵ if any error occurs, just return the revesed argument
⍎⌽⍕ make into string, reverse, make into number

Answer 3

Prolog, 40 - 50% = 20 bytes

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

This recursively calls predicate a/2 with maplist/3, for each member of the list, until reverse/2 fails (i.e. last element wasn't a list).

Answer 4

Python 2, 40 - 50% = 20

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

Only some minor modifications needed from the basic way to do it are needed to get the bonus. Uses the fact that all lists are less than the empty string, and all numbers are less than the empty list.

All test cases

Answer 5

Emacs Lisp, 46 bytes * 0.5 = 23

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

Usage example: (g '((1 2) 3 (four 5))) -> ((5 four) 3 (2 1))

Classic recursive approach: if the argument isn't a list, take it unchanged, if it's a list, map the function over the reverse of the list.

Answer 6

Mathematica, 34/2=17 bytes

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

Or just Reverse//@#& if you want a ton of errors and Reverses everywhere.

Answer 7

Clojure 43/2=21.5 bytes

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

Answer 8

Brachylog, 5 - 50% = 2.5 bytes

ċ↔↰ᵐ|

Try it online!

         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.

Since ↔ can also reverse strings and integers, we have to explicitly fail non-lists with ċ.

Answer 9

Wolfram Language (Mathematica), 23 22 21 bytes

-50% bonus

#0/@Reverse@*List@@#&

Try it online!

Only works on nested Lists of atoms. Reverse a list, then reverse its elements. @@ and /@ are no-ops on atoms.

Answer 10

JavaScript ES6, 42 - 50% = 21 bytes

My score is perfect in so many ways. Implements a function r which recursively applies itself to the members of its input.

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

If we assume no object has the property pop, then this becomes (31 - 50% = 15.5), thanks to dev-null:

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

Or, if we assume the object has a sane reverse property, we could do that as well (35 - 50% = 17.5):

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

Answer 11

Lua, 111 99 * .5 = 55.5 49.5 bytes

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

Good bit of recursion

Answer 12

CJam, 20 bytes * 50% = 10

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

Defines the named block F which can be applied to an array on top of the stack (or anything else, in which case it's a no-op).

Test it here.

Answer 13

Clojure, 38 bytes

(and a bonus I guess, but Clojure is a dynamic language so it comes for free)

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

This is a good start but didn't employ these optimizations:

• Define an anonymous function with fn instead of a named one with defn. But we still need a "scoped" name f for recursion
• Take input as a list instead of vector, then we can use seq? instead of coll?
• Use (into () ...) instead of reverse
• Reverse x before mapping, we don't need as many spaces then

Answer 14

Clojure, 40 38 -50% = 19 bytes

(fn r[s](if(coll? s)(map r(rseq s))s))

Try it online!

A translation of the JavaScript answer. Matched the score with the best Clojure answer ;)

Answer 15

Haskell + free, 8.5 bytes (17 bytes -50% bonus)

In order to represent a ragged list in Haskell we use a free monad of lists. We use the free library to get these free monads.

hoistFree reverse

Try it online!

Explanation

hoistFree takes a natural transformation from some functor \$F\$ to another functor \$G\$ and makes a natural transformation from \$\mathrm{Free}(F)\$ to \$\mathrm{Free}(G)\$. Here the natural transformation is reverse, from lists to lists.

Because hoistFree must work with any natural transformation we know it must apply reverse exactly once to every sublist. For example imagine we had a natural transformation:

newtype Reversed f a
  = Reversed (f a)

reverse' :: [a] -> Reversed [] a
reverse' =
  Reversed . reverse

This is functionally identical to reverse but the types prove it must be applied exactly once to every list.

Answer 16

Ruby, 32 - 50% = 16 bytes

Recursive function. Using rescue to catch the NoMethodError that triggers when trying to reverse a number or map a string turns out to be 2 bytes shorter than checking if the input is an array via a==[*a].

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

Try it online!

Answer 17

Julia 1.0, 27 -50% = 13.5

!x=x
!x::Array=reverse(.!x)

Try it online!