Einführung

Manchmal sind meine Boxen zu klein, um irgendetwas hinein zu passen. Du musst einen Box Expander bauen! Also, was macht eine Box eine Box in dieser Herausforderung.

 OOOO
O    O
O    O
O    O
 OOOO

Die Ecken der Box sind immer Leerzeichen. Die Box selbst kann aus dem gleichen Zeichen bestehen. Dieses Zeichen kann ein beliebiges druckbares ASCII-Zeichen sein , mit Ausnahme eines Leerzeichens. Das sind also diese Charaktere:

!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Die Seitenlängen des obigen Kastens betragen 4, 3 . Sie können davon ausgehen, dass die Seitenlänge immer positiv ist . Das bedeutet, dass dies die kleinste Box ist, die Sie handhaben müssen:

 #
# #
 #

Um ein Feld zu erweitern, müssen Sie jede Seitenlänge erhöhen. Lassen Sie uns dies Schritt für Schritt anhand des obigen Beispiels durchgehen. Wir nehmen zuerst die Oberseite der Schachtel:

 OOOO

Wir erweitern dies um eins, also erhalten wir:

 OOOOO

Dies ist jetzt der obere und untere Teil der Box. Danach machen wir dasselbe mit den Seiten links und rechts:

O
O
O

Wird:

O
O
O
O

Nun bauen wir die Box wieder zusammen, was ergibt:

 OOOOO
O     O
O     O
O     O
O     O
 OOOOO

Die Aufgabe

Erweitern Sie ein gegebenes Kästchen um 1. Das Kästchen kann in mehreren Zeilen oder in einem Array angegeben werden.

Testfälle

 OOOO          OOOOO
O    O    >   O     O
 OOOO         O     O
               OOOOO

 XXXXXX        XXXXXXX
X      X  >   X       X
X      X      X       X
 XXXXXX       X       X
               XXXXXXX

 ~             ~~
~ ~       >   ~  ~
 ~            ~  ~
               ~~

Das ist Code-Golf , also gewinnt die Einsendung mit der geringsten Anzahl von Bytes!

V , 6 5 Bytes

yêpjÄ

Probieren Sie es online!

Das ist eigentlich ein Byte länger als es sein sollte. Es hätte sein sollen:

äêjÄ

Das hat aber einen unbekannten Bug. :(

Erläuterung:

yê     "yank this colum
  p    "paste what we just yanked
   j   "move down to line 2
    Ä  "and duplicate this line

Vim, 7 Bytes

♥GYPjYp

wo ♥ ist Control-V.

           The cursor starts on the first non-whitespace character of the first line.
♥G         Enter visual block mode and go to bottom of document.
  YP       Duplicate this column.
    j      Move down to the second line of the file.
     Yp    Duplicate this line.

JavaScript (ES6), 57 53 52 Bytes

s=>s.replace(/^.(.)/gm,s="$&$1").replace(/(\n.*)/,s)

Erläuterung: Der erste reguläre Ausdruck dupliziert die zweite Spalte und der zweite reguläre Ausdruck dupliziert die zweite Zeile, wodurch das Feld wie gewünscht vergrößert wird. Edit: 4 Bytes gespeichert dank MartinEnder ♦.

Python, 49 42 Bytes

Anonymes Lambda:

-7 von xnor

lambda s:[t[:2]+t[1:]for t in s[:2]+s[1:]]

Vorherige Version:

D=lambda s:s[:2]+s[1:]
lambda s:D(list(map(D,s)))

D ist eine Funktion, die das zweite Element einer Sequenz dupliziert.

Netzhaut , 20 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

1`¶
¶$%'¶
%2=`.
$&$&

Probieren Sie es online! (Es gibt mehrere zusätzliche Zeilen, die eine Testsuite ermöglichen, bei der die Testfälle durch zwei Zeilenvorschübe getrennt sind.)

Erläuterung

1`¶
¶$%'¶

1a Grenze , die Retina , die Substitution nur auf das erste Spiel anzuwenden schränkt es findet. ¶passt zu einem einzelnen Zeilenvorschub, daher müssen wir nur den Zeilenvorschub am Ende der ersten Zeile ersetzen. Es wird ersetzt durch ¶$%'¶, wobei $%'die gesamte Zeile nach der Übereinstimmung eingefügt wird (ein Retina-spezifisches Substitutionselement). Daher dupliziert dies die zweite Zeile.

%2=`.
$&$&

In diesem %Modus wird jede Zeile einzeln verarbeitet, und die Zeilen werden anschließend erneut verbunden. 2=ist auch eine Grenze. Dies bedeutet "Wende die Auswechslung nur auf das zweite Spiel an". Die Übereinstimmung selbst ist einfach ein einzelnes Zeichen und die Ersetzung dupliziert es. Daher dupliziert diese Stufe die zweite Spalte.

Haskell, 24 Bytes

f(a:b:c)=a:b:b:c
f.map f

Verwendet die Idee von RootTwo, die zweite Zeile und Spalte zu duplizieren. Das map fmacht das mit jeder Zeile und das f.macht das dann mit den Zeilen.

PowerShell v2 +, 57 53 52 Bytes

param($n)($n-replace'^.(.)','$&$1')[0,1+1..$n.count]

Etwas ähnlich wie Neils JavaScript-Antwort . Das erste Ersetzen stimmt mit dem Zeilenanfang und den nächsten beiden Zeichen überein und ersetzt sie durch das erste Zeichen und das zweite Zeichen zweimal. Anstelle einer zweiten Ersetzung wird sie für die Array-Indizierung ausgetauscht, um die zweite Zeile zu duplizieren. Nimmt Eingaben als ein Array von Zeichenfolgen. Die resultierenden Array-Slices verbleiben in der Pipeline und das Drucken ist implizit.

4 Bytes gespart dank Martin.

Einige Beispiele:

PS C:\Tools\Scripts\golfing> .\automatic-box-expander.ps1 ' oooo ','o    o',' oooo '
 ooooo 
o     o
o     o
 ooooo 

PS C:\Tools\Scripts\golfing> .\automatic-box-expander.ps1 ' # ','# #',' # '
 ## 
#  #
#  #
 ## 

Brachylog , 28 26 Bytes

2 Bytes dank Fatalize.

{bB,?~c[A:C]hl2,A:Bc.}:1a.

Probieren Sie es online!

MATL , 12 Bytes

tZy"@:2hSY)!

Die Eingabe ist ein 2D-Zeichen-Array mit einem Semikolon als Zeilentrennzeichen. Beispielsweise hat der erste Testfall eine Eingabe

[' OOOO ';'O    O';' OOOO ']

Probieren Sie es online! Testfälle 1 , 2 , 3 .

Erläuterung

Der Code macht zweimal Folgendes: Wiederholen Sie die zweite Zeile des Arrays und transponieren Sie.

Um die zweite Zeile eines m× n-Arrays zu wiederholen , wird der Vektor [1 2 2 3 ... m]als Zeilenindex verwendet. Dieser Vektor wird wie folgt generiert: range [1 2 3 ... m], attach another 2, sort.

t       % Take input implicitly. Duplicate
Zy      % Size of input as a two-element array [r, c]
"       % For each of r and c
  @     %   Push r in first iteration (or c in the second)
  :     %   Generate range [1 2 3 ... r] (or [1 2 3 ... c])
  2hS   %   Append another 2 and sort
  Y)    %   Apply as row index
  !     %   Transpose
        % End for. Display implicitly

Pyth , 10 Bytes

L+<b2tbyMy

Probieren Sie es online!

SED 69 19 (14 + 1 für -r) 15

s/.(.)/&\1/;2p   

CJam , 14 Bytes

q~{~\_@]z}2*N*

Ähnlich wie meine MATL-Antwort , wiederholt jedoch die vorletzte Zeile anstelle der zweiten.

Probieren Sie es online!

Erläuterung

q                e# Read input
 ~               e# Interpret as an array
  {      }2*     e# Do this twice
   ~             e# Dump array contents onto the stack
    \            e# Swap top two elements
     _           e# Duplicate
      @          e# Rotate
       ]         e# Pack into an array again
        z        e# Zip
            N*   e# Join by newlines. Implicitly display

K, 15 Bytes

2{+x@&1+1=!#x}/

Nimmt die Eingabe als eine Matrix von Zeichen:

  b: (" OOOO ";"O    O";" OOOO ")
(" OOOO "
 "O    O"
 " OOOO ")

Wenden Sie zweimal ( 2{…}/) eine Funktion an, die der Transponierung ( +) des rechten Arguments, die x@durch die inkrementelle Lauflängendekodierung ( &) von eins plus ( 1+) indiziert ist, eine Liste der Positionen gleich 1 ( 1=) im Bereich von 0 bis zu gibt (! ) die Größe der äußeren Dimension des richtigen Arguments ( #x).

Schritt für Schritt,

  #b
3
  !#b
0 1 2
  1=!#b
0 1 0
  1+1=!#b
1 2 1
  &1+1=!#b
0 1 1 2
  b@&1+1=!#b
(" OOOO "
 "O    O"
 "O    O"
 " OOOO ")
  +b@&1+1=!#b
(" OO "
 "O  O"
 "O  O"
 "O  O"
 "O  O"
 " OO ")
  2{+x@&1+1=!#x}/b
(" OOOOO "
 "O     O"
 "O     O"
 " OOOOO ")

Probieren Sie es hier mit OK.

APL, 17-15 Bytes

{⍉⍵⌿⍨1+2=⍳≢⍵}⍣2

Prüfung:

      smallbox largebox
┌───┬──────┐
│ # │ OOOO │
│# #│O    O│
│ # │O    O│
│   │O    O│
│   │ OOOO │
└───┴──────┘
      {⍉⍵⌿⍨1+2=⍳≢⍵}⍣2 ¨ smallbox largebox
┌────┬───────┐
│ ## │ OOOOO │
│#  #│O     O│
│#  #│O     O│
│ ## │O     O│
│    │O     O│
│    │ OOOOO │
└────┴───────┘

Erläuterung:

             ⍣2   run the following function 2 times:
{           }     stretch the box vertically and transpose
         ⍳≢⍵      indices of rows of box
       2=         bit-vector marking the 2nd row
  ⍵/⍨1+           replicate the 2nd row twice, all other rows once
 ⍉                transpose

ListSharp , 326 Bytes

STRG a=READ[<here>+"\\a.txt"]
ROWS p=ROWSPLIT a BY ["\r\n"]
ROWS p=GETLINES p [1 TO p LENGTH-1]
ROWS p=p+p[1]+p[0]
STRG o=p[0]
ROWS y=EXTRACT COLLUM[2] FROM p SPLIT BY [""]
ROWS x=EXTRACT COLLUM[3] FROM p SPLIT BY [""]
[FOREACH NUMB IN 1 TO o LENGTH-1 AS i]
ROWS m=COMBINE[m,x] WITH [""]
ROWS m=COMBINE[y,m,y] WITH [""]
SHOW=m

ich definitiv die Verschachtelung von Funktionen hinzufügen, aber das funktioniert sehr gut

Kommentar, wenn Sie eine Erklärung wünschen

JavaScript, 160 146 141 Bytes

s=>{a=s[1];r="";l=s.split("\n");m=l.length;n=l[0].length;for(i=0;i<=m;i++){for(j=0;j<=n;j++)r+=!(i%m)&&j%n||i%m&&!(j%n)?a:" ";r+="\n"}return r}

Dyalog APL , 14 Bytes

(1 2,1↓⍳)¨∘⍴⌷⊢

(

1 2, {1, 2} vorangestellt

1↓ ein Element fiel aus

⍳ die Indizes

)¨ von jedem

∘ von

⍴ die {Zeilenanzahl, Spaltenanzahl}

⌷ Indizes in

⊢ das Argument

ZB für

 XX
X  X
 XX

wir finden die Indizes; {1, 2, 3} für die Zeilen und {1, 2, 3, 4} für die Spalten. Jetzt lassen wir die Anfangselemente fallen, um {2, 3} und {2, 3, 4} zu erhalten, und stellen dann {1, 2} voran und geben {1, 2, 2, 3} und {1, 2, 2, 3, 4}. Schließlich verwenden wir dies, um Zeilen und Spalten auszuwählen und gleichzeitig Zeile 2 und Spalte 2 zu verdoppeln.

TryAPL online!

Ruby, 46 Bytes

->a{a.map{|r|r.insert(2,r[1])}.insert(2,a[1])}

Sehr unkomplizierte Lösung, die Eingaben als Array von Zeilen aufnimmt. Ich mag keine duplizierten inserts, also werde ich versuchen, Golf zu spielen.

C #, 127 124 Bytes

s=>{int n=s.Count-1,i=0;s[0]=s[n]=s[0].Insert(1,s[0][1]+"");s.Insert(1,s[1]);for(;i++<n;)s[i]=s[i].Insert(1," ");return s;};

Kompiliert zu a Func<List<string>, List<string>>.

Formatierte Version:

s =>
{
    int n = s.Count - 1, i = 0;

    s[0] = s[n] = s[0].Insert(1, s[0][1] + "");

    s.Insert(1, s[1]);

    for (; i++ < n;)
        s[i] = s[i].Insert(1, " ");

    return s;
};