Bài tập

Đưa ra một yếu tố bao bọc và một mảng 3D không bị lởm chởm, bọc các mảng trên cùng, dưới cùng và xung quanh. Bạn phải xử lý cả dữ liệu ký tự và số, nhưng trình bao bọc và hiện tại sẽ có cùng kiểu dữ liệu.

Ví dụ nhân vật

Đối với dữ liệu ký tự, bạn có thể chọn xử lý các mảng 3D của các ký tự đơn hoặc mảng 2D của chuỗi:

Cho mảng ký tự 2 lớp, 2 hàng, 4 cột

[[["Y","o","u","r"],
  ["g","i","f","t"]],

  [["g","o","e","s"],
  ["h","e","r","e"]]]

và ký tự ".", trả lời mảng ký tự 4 lớp, 4 hàng, 6 cột

[[[".",".",".",".",".","."],
  [".",".",".",".",".","."],
  [".",".",".",".",".","."],
  [".",".",".",".",".","."]],

 [[".",".",".",".",".","."],
  [".","Y","o","u","r","."],
  [".","g","i","f","t","."],
  [".",".",".",".",".","."]],

 [[".",".",".",".",".","."],
  [".","g","o","e","s","."],
  [".","h","e","r","e","."],
  [".",".",".",".",".","."]],

 [[".",".",".",".",".","."],
  [".",".",".",".",".","."],
  [".",".",".",".",".","."],
  [".",".",".",".",".","."]]]

hoặc đưa ra mảng 2 hàng, 2 cột của chuỗi 4 ký tự

[["Your",
  "gift"],

 ["goes",
  "here"]]

và ký tự ".", trả lời dãy 4 hàng, 4 cột của chuỗi 6 ký tự

[["......",
  "......",
  "......",
  "......"],

 ["......",
  ".Your.",
  ".gift.",
  "......"],

 ["......",
  ".goes.",
  ".here.",
  "......"],

 ["......",
  "......",
  "......",
  "......"]]

Ví dụ số

Cho mảng số 2 lớp, 2 hàng, 2 cột

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

 [[5,6],
  [7,8]]]`

và số 0, trả lời mảng số 4 lớp, 4 hàng, 4 cột

[[[0,0,0,0],
   [0,0,0,0],
   [0,0,0,0],
   [0,0,0,0]],

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

  [[0,0,0,0],
   [0,5,6,0],
   [0,7,8,0],
   [0,0,0,0]],

  [[0,0,0,0],
   [0,0,0,0],
   [0,0,0,0],
   [0,0,0,0]]]

J , 16 15 byte

[h"2[h"1 h=.,,[

Đây là một động từ ẩn danh. Hãy thử trực tuyến!

Cảm ơn Adám cho 1 byte!

Giải trình

[h"2[h"1 h=.,,[  Wrapper is x, present is y.
            ,    Prepend x to y
             ,   then append
              [  x.
                 This gives x y x, and the wrapper automatically spreads to form 2D slices.
         h=.     Save the above operation (not its result) to h.
    [h"1         Apply h to x and every 2D slice of the previous result.
[h"2             Apply h to x and every 1D slice of the result of that.

JavaScript (ES6), 97 byte

(a,e)=>[c=[,,...b=a[0]].fill(d=[,,...b[0]].fill(e)),...a.map(a=>[d,...a.map(a=>[e,...a,e]),d]),c]

Đâu alà mảng ba chiều và elà trình bao bọc. Tự động chuyển đổi một chuỗi hai chiều thành một chuỗi các ký tự ba chiều. Phiên bản thay thế cho khi nào alà một chuỗi hai chiều và elà một ký tự và bạn muốn trả về một chuỗi hai chiều:

(a,e)=>[c=[,,...a[0]].fill(d=e.repeat(a[0][0].length+2)),...a.map(b=>[c,...b.map(s=>e+s+e),d]),c]

Octave, 23 27 byte

@(a,p)padarray(a,[1 1 1],p)

mảng: a
padval:p

Nó có thể được gọi là:

(@(a,p)padarray(a,[1 1 1],p))([1 2;3 4],40)

thử (dán!) nó trên Octave Online

lưu ý: câu trả lời trước giả định padval mặc định

Python, 106 104 126 byte

def w(g,c):x=len(g[0][0])+2;k=[[c*x]*(len(g[0])+2)];return k+[[c*x,*[c+"".join(str(k)for k in j)+c for j in i],c*x]for i in g]+k

Gọi là w(gift, wrapping character). Có thể sử dụng chuỗi và ký hiệu mảng. Hãy thử trực tuyến!

Perl 6, 86 byte

->\a,\w{my @z=[[w xx a[0;0]+2]xx a[0]+2]xx a+2;@z[1..a;1..a[0];1..a[0;0]]=a[*;*;*];@z}

Một lambda lấy mảng 3D và ký tự gói làm đối số.

• Đầu tiên, nó tạo ra một mảng đầu ra 3D có kích thước chính xác, chứa đầy ký tự gói.
• Sau đó, nó sử dụng cú pháp lát mảng để gán các giá trị của mảng ban đầu vào các vị trí chính xác của mảng mới, trong một cú trượt.

APL Dyalog , 31 19 13 12 byte

Gần như là phiên âm (31 byte) của giải pháp @ Zgarb .

Một chức năng ẩn danh. Đối số trái là gói, đối số phải là quà tặng.

⊣h⍤1⊣h⍤2(h←⍪⍪⊣)

⊣h⍤1 h được áp dụng, với đối số bên trái của hàm ẩn danh, cho các cột của

⊣h⍤2 h được áp dụng, với đối số bên trái của hàm ẩn danh, cho các hàng của

h← h áp dụng cho các ô chính, tức là các lớp của các đối số của hàm ẩn danh, trong đó h là

 ⍪ đối số bên trái chuẩn bị cho đối số bên phải

 ⍪ dự kiến

 ⊣ đối số bên trái

Nói cách khác, h là một hàm bao quanh đối số bên phải của nó (quà tặng) với đối số bên trái của nó (trình bao bọc). h sau đó được áp dụng cho các lớp của món quà, sau đó là các hàng của đó và cuối cùng là các cột của đó.

Dùng thử trực tuyến!

Giải pháp Dyalog APL phiên bản 16.0 này (19 byte - lịch sự của @ngn ) xử lý bất kỳ số lượng kích thước nào:

{⍵@(1+⍳⍴⍵)⊢⍺⍴⍨2+⍴⍵}

⍵ món quà

@( đặt tại

 1+ một cộng

 ⍳ tất cả các chỉ số của

 ⍴⍵ hình dạng của món quà

)⊢ trong mảng bao gồm

⍺⍴⍨ cái bọc được định hình lại thành hình

2+ hai thêm vào

⍴⍵ hình dạng của món quà

Nói cách khác, chúng ta tạo một mảng hoàn toàn bằng các phần tử bao bọc, trong mỗi chiều là hai phần tử lớn hơn quà tặng, sau đó chúng ta đặt món quà vào mảng đó (do đó thay thế các phần tử gói trong các vị trí đó) ở phần bù của một phần từ các cạnh, tức là ở trung tâm.

Phát minh của riêng tôi (-1 nhờ @ngn ):

(⌽2 3 1⍉,)⍣6

Điều này áp dụng một hàm ẩn danh - huấn luyện 6 lần, mỗi lần với trình bao bọc là đối số bên trái và kết quả của ứng dụng trước đó là đối số bên phải (mặc dù lần đầu tiên xung quanh nó sẽ là quà tặng không được sửa đổi):

( một tàu chức năng ẩn danh

 ⌽ cột ngược của

 2 3 1⍉ chuyển đổi từ hàng sang lớp, cột sang hàng, chuyển đổi từ lớp này sang cột khác

 , giấy gói tiếp theo là quà tặng

)⍣6 áp dụng sáu lần

Nói cách khác, chúng ta thêm một lớp bao bọc trên đầu của mảng, sau đó làm cong nó để bên tiếp theo được xoay vào vị trí lớp trên cùng, sẵn sàng cho một vòng bọc khác. Điều này được lặp lại sáu lần, với sự cong vênh cuối cùng định vị lại tất cả các trục theo thứ tự ban đầu.

Dùng thử trực tuyến!

05AB1E , 34 33 31 byte

vy¬g̲s×S©svy².ø¼}®)ˆ}¾F®})¯s.ø

Hãy thử trực tuyến! (chuỗi) hoặc Thử trực tuyến! (số)

Ruby, 89 byte

->a,b{(w=[[z=b*2+a[0][0].tr('^|',b)]*(2+a[0].size)])+a.map{|x|[z]+x.map{|y|b+y+b}+[z]}+w}

Tôi đã bao giờ nói với bạn rằng tôi chỉ ở đây để học ruby? :-)