Деталі

Напишіть функцію або програму, яка, задавши масив (або список), що містить лише цілі числа, повертає або виводить масив із переверненими всіма елементами. Тобто поверніть всі елементи найглибшого масиву, потім другого найглибшого тощо. Розміри не потрібно вказувати, але функція або програма повинні працювати для нерівних масивів у рідному форматі мови програмування.

Приклади

Це:

[[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% Bytecount Якщо ваша програма може взяти за вхід масив (або список) з різними типами своїх членів (вони можуть бути у вигляді об'єктів) і успішно повернути всі масиви.

Це:

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

Діалог APL , 14 - 50% = 7 байт

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

⌽⍵зворотний аргумент,
⍣(×|≡⍵)якщо аргумент не є атомом (знак [абсолютної] глибини) ...
∇¨... застосувати функцію до кожного елемента (аргументованого звороту).

Якщо ⎕ML←3(стиль IBM), що стосується систем, які мігрували з APL2, один байт можна зберегти, видаливши |.

Спробуйте APL в Інтернеті.

Для цікавості запропонований int та float реверс:

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

Внутрішня функція:

0::⌽⍵якщо трапляється якась помилка, просто поверніть розкритий аргумент
⍎⌽⍕у рядок, зворотній, зробіть у число

Пролог, 40 - 50% = 20 байт

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

Цей рекурсивно викликає предикат a/2з maplist/3кожним членом списку, поки reverse/2не виходить з ладу (тобто останній елемент не був списком).

Пітон 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, то це стає (31 - 50% = 15,5), завдяки dev-null:

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

Або, якщо припустити, що об’єкт має здорову reverseвластивість, ми могли б зробити це також (35 - 50% = 17,5):

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

Луа, 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який може бути застосований до масиву вгорі стека (або будь-що інше; у такому випадку це неоперативний варіант).

Тестуйте це тут.

Брахілог , 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.

Оскільки ↔також можуть бути зворотні рядки та цілі числа, ми маємо явно не мати списків ċ.

Мова Вольфрама (Mathematica) , 23 -50% = 11,5 байт

#/.List->Reverse@*List&

Спробуйте в Інтернеті!

Lists у Mathematica ( {...}) еквівалентні List[...]. @*є оператор композиції, таким чином замінюючи кожне входження Listз Reverse@*Listневдачами кожен список , який відбувається на вході ( Reverse@*List[...]= Reverse[{...}]).

24 -50% = 12 байт

#~Reverse~Range@Depth@#&

Спробуйте в Інтернеті!

Працює не лише на Lists.

Clojure, 38 байт

(і я думаю, що бонус, але Clojure - це динамічна мова, тому це безкоштовно)

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

Це вдалий старт, але не використовував ці оптимізації:

• Визначте анонімну функцію з fnзамість іменної з defn. Але fдля рекурсії нам все-таки потрібне ім'я "обширного"
• Візьміть введення як список, а не векторний, тоді ми можемо використовувати його seq?замістьcoll?
• Використовуйте (into () ...)замістьreverse
• Зворотний xперед картографуванням нам тоді не потрібно стільки пробілів

Рубін , 32 - 50% = 16 байт

Рекурсивна функція. Використовуючи rescueдля того, NoMethodErrorщоб зафіксувати те, що спрацьовує при спробі reverseвведення числа або mapрядка, виявляється на 2 байти коротше, ніж перевірка, чи вхід є масивом через a==[*a].

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

Спробуйте в Інтернеті!