Chi tiết

Viết hàm hoặc chương trình, cho một mảng (hoặc danh sách), chỉ chứa số nguyên, trả về hoặc xuất ra một mảng với tất cả các thành phần phụ được đảo ngược. Nghĩa là, đảo ngược tất cả các phần tử của mảng sâu nhất, sau đó sâu nhất thứ hai, v.v. Không cần chỉ định kích thước, nhưng chức năng hoặc chương trình phải hoạt động cho các mảng lởm chởm trong định dạng gốc của ngôn ngữ lập trình của bạn.

Ví dụ

Điều này:

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

Sẽ trở thành thế này:

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

Điều này:

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

Sẽ trở thành thế này:

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

Điều này:

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

Sẽ trở thành thế này:

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

Tặng kem

Điều này hy vọng sẽ khuyến khích câu trả lời trong một số ngôn ngữ lập trình hướng đối tượng ...

-50% Bytecount Nếu chương trình của bạn có thể lấy đầu vào là một mảng (hoặc danh sách) với các loại thành viên khác nhau (chúng có thể ở dạng đối tượng) và đảo ngược thành công tất cả các mảng.

Điều này:

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

Sẽ trở thành thế này:

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

Pyth, 11 - 50% = 5,5 byte

L?+IbY_yMbb

Dùng thử trực tuyến: Trình diễn hoặc Test Suite .

Điều này xác định một chức năng y. 3 byte bổ sung <newline>yQchỉ đơn giản gọi hàm với danh sách đầu vào và do đó không cần phải tính vào tổng số byte.

Giải trình:

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 Dyalog , 14 - 50% = 7 byte

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

⌽⍵đối số ngược lại
⍣(×|≡⍵)nếu đối số không phải là nguyên tử (dấu của độ sâu [tuyệt đối]) ...
∇¨... áp dụng hàm cho từng phần tử (của đối số đảo ngược).

Nếu ⎕ML←3(kiểu IBM), đó là trường hợp trên các hệ thống di chuyển từ APL2, một byte có thể được lưu bằng cách xóa |.

Hãy thử APL trực tuyến.

Đối với sự tò mò, đề xuất đảo ngược int và float:

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

Chức năng bên trong:

0::⌽⍵nếu có lỗi xảy ra, chỉ cần trả về đối số đã sửa
⍎⌽⍕thành chuỗi, đảo ngược, tạo thành số

Prolog, 40 - 50% = 20 byte

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

Điều này gọi đệ quy vị ngữ a/2với maplist/3, cho mỗi thành viên trong danh sách, cho đến khi reverse/2thất bại (tức là phần tử cuối cùng không phải là danh sách).

Con trăn 2, 40 - 50% = 20

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

Chỉ một số sửa đổi nhỏ cần thiết từ cách cơ bản để làm điều đó là cần thiết để nhận được tiền thưởng. Sử dụng thực tế là tất cả các danh sách đều nhỏ hơn chuỗi trống và tất cả các số đều nhỏ hơn danh sách trống.

Tất cả các trường hợp thử nghiệm

Emacs Lisp, 46 byte * 0,5 = 23

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

Ví dụ sử dụng: (g '((1 2) 3 (four 5)))->((5 four) 3 (2 1))

Cách tiếp cận đệ quy cổ điển: nếu đối số không phải là danh sách, hãy thay đổi nó, nếu đó là danh sách, ánh xạ hàm qua mặt trái của danh sách.

Toán học, 34/2 = 17 byte

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

Hoặc chỉ Reverse//@#&khi bạn muốn một tấn lỗi và Reverses ở khắp mọi nơi.

Clojure 43/2 = 21,5 byte

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

JavaScript ES6, 42 - 50% = 21 byte

Điểm của tôi là hoàn hảo theo nhiều cách. Thực hiện một chức năng rtự áp dụng đệ quy cho các thành viên đầu vào của nó.

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

Nếu chúng ta giả sử không có đối tượng nào có thuộc tính pop, thì điều này trở thành (31 - 50% = 15,5), nhờ dev-null:

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

Hoặc, nếu chúng ta giả sử đối tượng có thuộc tính lành mạnh reverse, chúng ta cũng có thể làm điều đó (35 - 50% = 17,5):

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

Lua, 111 99 * .5 = 55,5 49,5 byte

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

Một chút đệ quy

CJam, 20 byte * 50% = 10

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

Xác định khối được đặt tên Fcó thể được áp dụng cho một mảng trên đỉnh của ngăn xếp (hoặc bất cứ thứ gì khác, trong trường hợp đó là không có op).

Kiểm tra nó ở đây.

Brachylog , 5 - 50% = 2,5 byte

ċ↔↰ᵐ|

Hãy thử trực tuyến!

         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.

Vì ↔cũng có thể đảo ngược chuỗi và số nguyên, chúng tôi phải thất bại rõ ràng với các danh sách không có ċ.

Ngôn ngữ Wolfram (Mathicala) , 23 -50% = 11,5 byte

#/.List->Reverse@*List&

Hãy thử trực tuyến!

Lists trong Mathicala ( {...}) tương đương với List[...]. @*là toán tử thành phần, vì vậy thay thế mỗi lần xuất hiện Listbằng Reverse@*Listđảo ngược mọi danh sách xảy ra trong đầu vào ( Reverse@*List[...]= Reverse[{...}]).

24 -50% = 12 byte

#~Reverse~Range@Depth@#&

Hãy thử trực tuyến!

Không chỉ làm việc trên Lists.

Clojure, 38 byte

(và một phần thưởng tôi đoán, nhưng Clojure là một ngôn ngữ năng động nên nó miễn phí)

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

Đây là một khởi đầu tốt nhưng không sử dụng những tối ưu hóa này:

• Xác định hàm ẩn danh fnthay vì hàm có tên defn. Nhưng chúng ta vẫn cần một tên "phạm vi" fcho đệ quy
• Lấy đầu vào dưới dạng danh sách thay vì vector, sau đó chúng ta có thể sử dụng seq?thay vìcoll?
• Sử dụng (into () ...)thay vìreverse
• Đảo ngược xtrước khi ánh xạ, chúng ta không cần nhiều khoảng trống sau đó

Ruby , 32 - 50% = 16 byte

Hàm đệ quy. Sử dụng rescueđể bắt các NoMethodErrorkích hoạt khi cố gắng reversemột số hoặc mapmột chuỗi hóa ra ngắn hơn 2 byte so với kiểm tra xem đầu vào có phải là một mảng thông qua hay không a==[*a].

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

Hãy thử trực tuyến!