Introdução

Às vezes, minhas caixas são pequenas demais para caber em qualquer coisa. Eu preciso que você faça um expansor de caixa! Então, o que faz de uma caixa uma caixa nesse desafio.

 OOOO
O    O
O    O
O    O
 OOOO

Os cantos da caixa são sempre espaços. A própria caixa pode ser feita com o mesmo caractere. Esse caractere pode ser qualquer caractere ASCII imprimível , exceto um espaço. Então, esses são os caracteres:

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

Os comprimentos laterais da caixa acima são 4, 3 . Você pode assumir que o comprimento do lado é sempre positivo . Isso significa que esta é a menor caixa que você precisa manusear:

 #
# #
 #

Para expandir uma caixa, você precisa incrementar o comprimento de cada lado. Vamos passar por isso, passo a passo, com o exemplo acima. Primeiro, pegamos o lado superior da caixa, que é:

 OOOO

Expandimos isso em um, obtendo:

 OOOOO

Esta é a parte superior e inferior da caixa agora. Depois disso, fazemos o mesmo com os lados à esquerda e à direita:

O
O
O

Torna-se:

O
O
O
O

Agora montamos novamente a caixa, que resulta em:

 OOOOO
O     O
O     O
O     O
O     O
 OOOOO

A tarefa

Dada uma caixa, expanda-a por 1. A caixa pode ser fornecida em várias linhas ou em uma matriz.

Casos de teste

 OOOO          OOOOO
O    O    >   O     O
 OOOO         O     O
               OOOOO

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

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

Isso é código-golfe , então a submissão com a menor quantidade de bytes ganha!

V , 6 5 bytes

yêpjÄ

Experimente online!

Na verdade, é um byte mais longo do que deveria. Deveria ter sido:

äêjÄ

Mas isso tem um erro desconhecido. :(

Explicação:

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

Vim, 7 bytes

♥GYPjYp

onde ♥ é 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)

Explicação: O primeiro regexp duplica a segunda coluna e o segundo regexp duplica a segunda linha, ampliando a caixa conforme desejado. Editar: salvou 4 bytes graças ao MartinEnder ♦.

Python, 49 42 bytes

Lambda anônima:

-7 de xnor

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

Versão anterior:

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

D é uma função que duplica o segundo item de uma sequência.

Retina , 20 bytes

A contagem de bytes assume a codificação ISO 8859-1.

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

Experimente online! (Existem várias linhas adicionais que permitem um conjunto de testes em que os casos de teste são separados por dois feeds de linha.)

Explicação

1`¶
¶$%'¶

1é um limite que restringe a Retina a aplicar a substituição apenas na primeira correspondência encontrada. ¶corresponde a um único avanço de linha, portanto, precisamos considerar apenas a substituição do avanço de linha no final da primeira linha. É substituído por ¶$%'¶, onde $%'insere toda a linha após a correspondência (um elemento de substituição específico da Retina). Portanto, isso duplica a segunda linha.

%2=`.
$&$&

Aqui, %é o modo por linha, para que cada linha seja processada individualmente e as linhas sejam unidas novamente depois. 2=também é um limite. Este significa "aplicar a substituição apenas ao segundo jogo". A partida em si é simples, um único caractere e a substituição a duplica. Portanto, esse estágio duplica a segunda coluna.

Haskell, 24 bytes

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

Usa a idéia do RootTwo de duplicar a segunda linha e coluna. O map ffaz isso para cada linha e o f.faz para as linhas.

PowerShell v2 +, 57 53 52 bytes

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

Um pouco semelhante à resposta JavaScript de Neil . A primeira substituição corresponde ao início da linha e aos próximos dois caracteres e os substitui pelo primeiro caractere e pelo segundo caractere duas vezes. Em vez de uma segunda substituição, ela foi trocada pela indexação de matriz para duplicar a segunda linha. Recebe entrada como uma matriz de seqüências de caracteres. As fatias da matriz resultantes são deixadas no pipeline e a impressão é implícita.

Economizou 4 bytes graças a Martin.

Alguns exemplos:

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 ' # ','# #',' # '
 ## 
#  #
#  #
 ## 

Braquilog , 28 26 bytes

2 bytes graças a Fatalize.

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

Experimente online!

MATL , 12 bytes

tZy"@:2hSY)!

A entrada é uma matriz de caracteres 2D, com ponto e vírgula como separador de linhas. Por exemplo, o primeiro caso de teste tem entrada

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

Experimente online! Casos de teste 1 , 2 , 3 .

Explicação

O código faz o seguinte duas vezes: repita a segunda linha da matriz e transponha.

Para repetir a segunda linha de uma matriz m× n, o vetor [1 2 2 3 ... m]é usado como índice de linha. Esse vetor é gerado da seguinte maneira: range [1 2 3 ... m], anexar outro 2, classificar.

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

Pitão , 10 bytes

L+<b2tbyMy

Experimente online!

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

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

CJam , 14 bytes

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

Semelhante à minha resposta MATL , mas repete a segunda e última linha em vez da segunda.

Experimente online!

Explicação

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

Recebe entrada como uma matriz de caracteres:

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

Aplique uma função duas vezes ( 2{…}/) que forneça a transposição ( +) do argumento correto indexado ( x@) pela decodificação incremental do comprimento de execução ( &) de um mais ( 1+) uma lista dos locais iguais a 1 ( 1=) no intervalo de 0 a ( !) o tamanho da dimensão externa do argumento correto ( #x).

Passo a 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 ")

Experimente aqui com oK.

APL, 17 15 bytes

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

Teste:

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

Explicação:

             ⍣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

Eu definitivamente preciso adicionar o aninhamento de funções, mas isso funciona muito bem

comente se você quiser uma explicação

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

1↓ um elemento caiu de

⍳ os índices

)¨ De cada

∘ do

⍴ o {número de linhas, número de colunas}

⌷ índices em

⊢ o argumento

Por exemplo, para

 XX
X  X
 XX

nós encontramos os índices; {1, 2, 3} para as linhas e {1, 2, 3, 4} para as colunas. Agora, eliminamos os elementos iniciais para obter {2, 3} e {2, 3, 4} e, em seguida, acrescentamos com {1, 2}, fornecendo {1, 2, 2, 3} e {1, 2, 2, 3, 4}. Por fim, usamos isso para selecionar linhas e colunas, duplicando simultaneamente as linhas 2 e 2.

TryAPL online!

Ruby, 46 bytes

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

Solução muito simples, tendo como entrada uma matriz de linhas. Eu não gosto de inserts duplicados , então vou tentar jogar golfe.

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

Compila para um Func<List<string>, List<string>>.

Versão formatada:

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