introduzione

A volte, le mie scatole sono troppo piccole per adattarsi a qualsiasi cosa. Ho bisogno che tu faccia un espansore per scatole! Quindi, ciò che rende una scatola una scatola in questa sfida.

 OOOO
O    O
O    O
O    O
 OOOO

Gli angoli della scatola sono sempre spazi. La scatola stessa può essere fatta con lo stesso personaggio. Quel personaggio può essere qualsiasi carattere ASCII stampabile , tranne uno spazio. Quindi, questi sono questi personaggi:

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

Le lunghezze laterali della casella in alto sono 4, 3 . Puoi presumere che la lunghezza del lato sia sempre positiva . Ciò significa che questa è la scatola più piccola che devi gestire:

 #
# #
 #

Per espandere una casella, è necessario incrementare ogni lunghezza laterale. Esaminiamo questo passo per passo con l'esempio sopra. Innanzitutto prendiamo il lato superiore della scatola, che è:

 OOOO

Lo espandiamo di uno, quindi otteniamo:

 OOOOO

Questa è la parte superiore e inferiore della scatola ora. Dopodiché, facciamo lo stesso con i lati a sinistra e a destra:

O
O
O

diventa:

O
O
O
O

Ora riassembliamo la scatola, che si traduce in:

 OOOOO
O     O
O     O
O     O
O     O
 OOOOO

L'obiettivo

Dato un riquadro, espanderlo di 1. Il riquadro può essere indicato in più righe o in un array.

Casi test

 OOOO          OOOOO
O    O    >   O     O
 OOOO         O     O
               OOOOO

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

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

Questo è code-golf , quindi vince l'invio con il minor numero di byte!

V , 6 5 byte

yêpjÄ

Provalo online!

Questo è in realtà un byte più lungo di quanto dovrebbe essere. Sarebbe dovuto essere:

äêjÄ

Ma questo ha un bug sconosciuto. :(

Spiegazione:

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

Vim, 7 byte

♥GYPjYp

dove ♥ è 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 byte

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

Spiegazione: Il primo regexp duplica la seconda colonna e il secondo regexp duplica la seconda riga, allargando così la casella come desiderato. Modifica: salvato 4 byte grazie a MartinEnder ♦.

Python, 49 42 byte

Lambda anonimo:

-7 da xnor

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

Versione precedente:

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

D è una funzione che duplica il secondo elemento di una sequenza.

Retina , 20 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

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

Provalo online! (Esistono diverse linee aggiuntive che abilitano una suite di test in cui i casi di test sono separati da due avanzamenti di riga.)

Spiegazione

1`¶
¶$%'¶

1è un limite che limita Retina ad applicare la sostituzione solo alla prima partita trovata. ¶corrisponde a un singolo avanzamento riga, quindi dobbiamo solo considerare di sostituire l'alimentatore alla fine della prima riga. Viene sostituito con ¶$%'¶, dove $%'inserisce l'intera riga dopo la corrispondenza (un elemento di sostituzione specifico di Retina). Quindi, questo duplica la seconda riga.

%2=`.
$&$&

Qui, %è la modalità per riga, quindi ogni riga viene elaborata singolarmente e le righe vengono nuovamente unite successivamente. 2=è anche un limite. Questo significa "applica la sostituzione solo alla seconda partita". La partita stessa è semplice un singolo personaggio e la sostituzione lo duplica. Quindi, questa fase duplica la seconda colonna.

Haskell, 24 byte

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

Usa l' idea di RootTwo di duplicare la seconda riga e colonna. Lo map ffa ad ogni riga e f.poi lo fa alle righe.

PowerShell v2 +, 57 53 52 byte

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

Leggermente simile alla risposta JavaScript di Neil . Il primo rimpiazzo corrisponde all'inizio della riga e ai due caratteri successivi e li sostituisce due volte con il primo carattere e il secondo carattere. Invece di una seconda sostituzione, viene sostituito per l'indicizzazione di array per duplicare la seconda riga. Accetta input come una matrice di stringhe. Le sezioni di array risultanti vengono lasciate sulla pipeline e la stampa è implicita.

Risparmiato 4 byte grazie a Martin.

Qualche esempio:

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 byte

2 byte grazie a Fatalize.

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

Provalo online!

MATL , 12 byte

tZy"@:2hSY)!

L'input è un array di caratteri 2D, con punto e virgola come separatore di riga. Ad esempio, il primo caso di test ha input

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

Provalo online! Casi di test 1 , 2 , 3 .

Spiegazione

Il codice esegue due volte le seguenti operazioni: ripetere la seconda riga dell'array e trasporre.

Per ripetere la seconda riga di un array m× n, il vettore [1 2 2 3 ... m]viene utilizzato come indice di riga. Questo vettore viene generato come segue: intervallo [1 2 3 ... m], allega un altro 2, ordina.

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 byte

L+<b2tbyMy

Provalo online!

SED 69 19 (14 + 1 per -r) 15

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

CJam , 14 byte

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

Simile a mia risposta MATL , ma ripete la penultima riga invece della seconda.

Provalo online!

Spiegazione

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 byte

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

Prende input come una matrice di caratteri:

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

Applicare due volte una funzione ( 2{…}/) che fornisce al transpose ( +) dell'argomento destro indicizzato ( x@) dalla decodifica incrementale della lunghezza ( &) di uno più ( 1+) un elenco delle posizioni pari a 1 (1= ) nell'intervallo da 0 a ( !) la dimensione della dimensione esterna dell'argomento giusto ( #x).

Passo dopo passo,

  #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 ")

Provalo qui con oK.

APL, 17 15 byte

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

Test:

      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 │
└────┴───────┘

Spiegazione:

             ⍣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 byte

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

Devo assolutamente aggiungere l'annidamento di funzioni, ma funziona molto bene

commenta se vuoi una spiegazione

JavaScript, 160 146 141 byte

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 byte

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

(

1 2, {1, 2} anteposto a

1↓ un elemento è caduto da

⍳ gli indici

)¨ di ogni

∘ di

⍴ il {conteggio righe, conteggio colonne}

⌷ indicizza in

⊢ l'argomento

Ad esempio per

 XX
X  X
 XX

troviamo gli indici; {1, 2, 3} per le righe e {1, 2, 3, 4} per le colonne. Ora lasciamo cadere gli elementi iniziali per ottenere {2, 3} e {2, 3, 4}, e quindi anteporre con {1, 2}, dando {1, 2, 2, 3} e {1, 2, 2, 3, 4}. Infine, lo usiamo per selezionare righe e colonne, raddoppiando contemporaneamente la riga 2 e la colonna 2.

ProvaAPL online!

Rubino, 46 ​​byte

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

Soluzione molto semplice, prendendo input come matrice di linee. Non mi piacciono i duplicati insert, quindi proverò a giocare a golf.

C #, 127 124 byte

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

Compila per a Func<List<string>, List<string>> .

Versione formattata:

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