Compito

Dato un elemento wrapper e un array 3D non frastagliato, avvolgi l'array in alto, in basso e tutto intorno. È necessario gestire sia i dati di carattere che numerici, ma il wrapper e il presente avranno lo stesso tipo di dati.

Esempio di carattere

Per i dati dei caratteri, puoi scegliere di gestire matrici 3D di singoli caratteri o matrici 2D di stringhe:

Dato l'array di caratteri a 2 strati, 2 righe, 4 colonne

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

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

e il personaggio ".", rispondere alla matrice di caratteri a 4 strati, 4 righe, 6 colonne

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

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

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

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

o dato l'array a 2 righe e 2 colonne di stringhe di 4 caratteri

[["Your",
  "gift"],

 ["goes",
  "here"]]

e il carattere ".", rispondere alla matrice di 4 righe e 4 colonne di stringhe di 6 caratteri

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

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

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

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

Esempio numerico

Dato l'array numerico a 2 strati, 2 righe, 2 colonne

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

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

e il numero 0, rispondere alla matrice numerica a 4 strati, 4 righe, 4 colonne

[[[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=.,,[

Questo è un verbo anonimo. Provalo online!

Grazie ad Adám per 1 byte!

Spiegazione

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

Dov'è al'array tridimensionale ed eè il wrapper. Converte automaticamente una matrice bidimensionale di stringhe in una matrice tridimensionale di caratteri. Versione alternativa per quando aè una matrice bidimensionale di stringhe ed eè un carattere e si desidera restituire una matrice bidimensionale di stringhe:

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

Ottava, 23 27 byte

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

array: a
padval:p

Può essere chiamato come:

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

provalo (incollalo!) su Octave Online

nota: la risposta precedente presupponeva padval predefinito

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

Chiamato come w(gift, wrapping character). Può usare la stringa e la notazione dell'array. Provalo online!

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}

Un lambda che prende l'array 3D e il carattere di avvolgimento come argomenti.

• Crea innanzitutto un array di output 3D della dimensione corretta, riempito con il carattere di avvolgimento.
• Quindi utilizza la sintassi della sezione di matrice per assegnare i valori della matrice originale negli slot corretti della nuova matrice, in un colpo solo.

Dyalog APL , 31 19 13 12 byte

Quasi una traslitterazione (31 byte) della soluzione di @ Zgarb .

Una funzione anonima. L'argomentazione di sinistra è a capo, l'argomentazione di destra è un dono.

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

⊣h⍤1 h applicato, con l'argomento sinistro della funzione anonima, alle colonne di

⊣h⍤2 h applicato, con l'argomento sinistro della funzione anonima, alle righe di

h← h applicato alle celle principali, ovvero i livelli degli argomenti della funzione anonima, dove h è

 ⍪ l'argomento sinistro anteposto all'argomento destro

 ⍪ anteposto a

 ⊣ l'argomento sinistro

In altre parole, h è una funzione che circonda il suo argomento destro (il dono) con il suo argomento sinistro (il wrapper). h viene quindi applicato ai livelli del regalo, quindi alle righe di quello e infine alle colonne di quello.

ProvaAPL online!

Questa soluzione Dyalog APL versione 16.0 (19 byte - per gentile concessione di @ngn ) gestisce un numero qualsiasi di dimensioni:

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

⍵ il regalo

@( collocato a

 1+ uno in più

 ⍳ tutti gli indici di

 ⍴⍵ la forma del dono

)⊢ nella matrice composta da

⍺⍴⍨ l'involucro rimodellato alla forma

2+ due aggiunti a

⍴⍵ la forma del dono

In altre parole, creiamo un array interamente di elementi wrapper, che in ogni dimensione è due elementi più grandi del regalo, quindi posizioniamo il regalo in quell'array (sostituendo così gli elementi avvolgenti in quelle posizioni) ad un offset di uno dal bordi, cioè al centro.

La mia invenzione (-1 grazie a @ngn ):

(⌽2 3 1⍉,)⍣6

Questo applica un treno di funzioni anonimo 6 volte, ogni volta con il wrapper come argomento sinistro e il risultato della precedente applicazione come argomento giusto (anche se la prima volta sarà il dono non modificato):

( un treno di funzioni anonimo

 ⌽ colonne inverse di

 2 3 1⍉ la trasposizione da file a strati, da colonne a file, da strati a colonne

 , la confezione seguita dal regalo

)⍣6 applicato sei volte

In altre parole, aggiungiamo uno strato di wrapper nella parte superiore dell'array, quindi lo deformiamo in modo che il lato successivo venga ruotato nella posizione dello strato superiore, pronto per un altro giro di avvolgimento. Questo viene ripetuto sei volte, con la deformazione finale che riposiziona tutti gli assi nell'ordine originale.

ProvaAPL online!

05AB1E , 34 33 31 byte

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

Provalo online! (stringa) o provalo online! (numerico)

Rubino, 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}

Ti ho mai detto che sono qui solo per imparare il rubino? :-)