Aufgabe

Bei einem Wrapper-Element und einem nicht gezackten 3D-Array müssen Sie das Array oben, unten und ringsum umschließen. Sie müssen sowohl mit Zeichen als auch mit numerischen Daten umgehen, aber der Wrapper und das Present haben denselben Datentyp.

Zeichen Beispiel

Für Zeichendaten können Sie entweder 3D-Arrays aus einzelnen Zeichen oder 2D-Arrays aus Zeichenfolgen auswählen:

Angesichts des Zeichenarrays mit 2 Ebenen, 2 Zeilen und 4 Spalten

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

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

"."Beantworten Sie für das Zeichen das 4-Ebenen-, 4-Zeilen- und 6-Spalten-Zeichen-Array

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

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

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

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

oder mit dem Array aus 2 Zeilen und 2 Spalten mit 4 Zeichen

[["Your",
  "gift"],

 ["goes",
  "here"]]

"."Beantworten Sie für das Zeichen das 4-Zeilen- und 4-Spalten-Array mit 6-Zeichen-Zeichenfolgen

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

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

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

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

Numerisches Beispiel

Angesichts des numerischen Arrays mit 2 Ebenen, 2 Zeilen und 2 Spalten

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

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

und die Zahl 0, beantworten Sie das numerische Array mit 4 Ebenen, 4 Zeilen und 4 Spalten

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

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

Dies ist ein anonymes Verb. Probieren Sie es online!

Danke an Adám für 1 Byte!

Erläuterung

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

Wo aist das dreidimensionale Array und eist der Wrapper. Konvertiert automatisch ein zweidimensionales Array von Zeichenfolgen in ein dreidimensionales Array von Zeichen. Alternative Version für when aist ein zweidimensionales Array von Zeichenfolgen und eist ein Zeichen und Sie möchten ein zweidimensionales Array von Zeichenfolgen zurückgeben:

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

Oktave, 23 27 Bytes

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

array: a
padval:p

Es kann genannt werden als:

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

versuchen Sie es auf Octave Online (Einfügen!)

Hinweis: Bei der vorherigen Antwort wurde die Standardeinstellung padval angenommen

Python, 106 104 126 Bytes

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

Genannt als w(gift, wrapping character). Kann die Zeichenfolge und die Array-Notation verwenden. Probieren Sie es online!

Perl 6, 86 Bytes

->\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}

Ein Lambda, das das 3D-Array und das Umhüllungszeichen als Argumente verwendet.

• Zunächst wird ein 3D-Ausgabearray der richtigen Größe erstellt, das mit dem Umbruchzeichen gefüllt ist.
• Anschließend wird die Array-Slice-Syntax verwendet, um die Werte des ursprünglichen Arrays auf einen Schlag den richtigen Slots des neuen Arrays zuzuweisen.

Dyalog APL , 31 19 13 12 Bytes

Fast eine Transliteration (31 Byte) von @ Zgarbs Lösung .

Eine anonyme Funktion. Das linke Argument wird umbrochen, das rechte Argument ist ein Geschenk.

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

⊣h⍤1 h wird mit dem linken Argument der anonymen Funktion auf die Spalten von angewendet

⊣h⍤2 h wird mit dem linken Argument der anonymen Funktion auf die Zeilen von angewendet

h← h wird auf die Hauptzellen angewendet, dh auf die Ebenen der Argumente der anonymen Funktion, wobei h ist

 ⍪ das linke Argument steht vor dem rechten Argument

 ⍪ vorangestellt

 ⊣ das linke Argument

Mit anderen Worten, h ist eine Funktion, die ihr rechtes Argument (das Geschenk) mit ihrem linken Argument (der Hülle) umgibt. h wird dann auf die Ebenen des Geschenks angewendet, dann auf die Zeilen davon und schließlich auf die Spalten davon.

TryAPL online!

Diese Dyalog APL Version 16.0-Lösung (19 Byte - mit freundlicher Genehmigung von @ngn ) verarbeitet eine beliebige Anzahl von Dimensionen:

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

⍵ das Geschenk

@( platziert bei

 1+ eins plus

 ⍳ Alle Indizes von

 ⍴⍵ die Form des Geschenks

)⊢ im Array bestehend aus

⍺⍴⍨ Die Hülle nahm die Form an

2+ zwei hinzugefügt

⍴⍵ die Form des Geschenks

Mit anderen Worten, wir erstellen ein Array vollständig aus Wrapper-Elementen, die in jeder Dimension zwei Elemente größer sind als das Geschenk. Anschließend platzieren wir das Geschenk in diesem Array und ersetzen die Wrapper-Elemente in diesen Positionen Kanten, dh in der Mitte.

Meine eigene Erfindung (-1 dank @ngn ):

(⌽2 3 1⍉,)⍣6

Dies wendet einen anonymen Funktionszug sechsmal an, jedes Mal mit dem Wrapper als linkem Argument und dem Ergebnis der vorherigen Anwendung als rechtem Argument (obwohl es sich beim ersten Mal um das unveränderte Geschenk handelt):

( ein anonymer Funktionszug

 ⌽ umgekehrte Spalten von

 2 3 1⍉ die Zeilen-zu-Ebenen-, Spalten-zu-Zeilen-, Ebenen-zu-Spalten-Transposition von

 , der Umschlag, gefolgt von dem Geschenk

)⍣6 sechsmal angewendet

Mit anderen Worten, wir fügen eine Wrapper-Schicht oben auf dem Array hinzu und verziehen sie dann, sodass die nächste Seite in die oberste Layer-Position gedreht wird und für eine weitere Wrapper-Runde bereit ist. Dies wird sechsmal wiederholt, wobei das endgültige Verziehen alle Achsen in die ursprüngliche Reihenfolge versetzt.

TryAPL online!

05AB1E , 34 33 31 Bytes

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

Probieren Sie es online! (String) oder Online ausprobieren! (numerisch)

Ruby, 89 Bytes

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

Habe ich dir jemals gesagt, dass ich nur hier bin, um Rubin zu lernen? :-)