Introducción

A veces, mis cajas son demasiado pequeñas para caber en ellas. ¡Necesito que hagas un expansor de caja! Entonces, ¿qué hace que una caja sea una caja en este desafío?

 OOOO
O    O
O    O
O    O
 OOOO

Las esquinas de la caja son siempre espacios. La caja en sí puede estar hecha del mismo personaje. Ese personaje puede ser cualquier personaje ASCII imprimible , excepto un espacio. Entonces, esos son los personajes:

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

Las longitudes laterales del cuadro de arriba son 4, 3 . Puede suponer que la longitud del lado es siempre positiva . Eso significa que esta es la caja más pequeña que necesita manejar:

 #
# #
 #

Para expandir un cuadro, debe incrementar la longitud de cada lado. Veamos esto, paso a paso, con el ejemplo anterior. Primero tomamos el lado superior de la caja, que es:

 OOOO

Expandimos esto en uno, así obtenemos:

 OOOOO

Esta es la parte superior e inferior de la caja ahora. Después de eso, hacemos lo mismo con los lados a la izquierda y a la derecha:

O
O
O

Se convierte en:

O
O
O
O

Ahora volvemos a montar la caja, que da como resultado:

 OOOOO
O     O
O     O
O     O
O     O
 OOOOO

La tarea

Dado un cuadro, amplíelo en 1. El cuadro se puede dar en varias líneas o en una matriz.

Casos de prueba

 OOOO          OOOOO
O    O    >   O     O
 OOOO         O     O
               OOOOO

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

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

Este es el código de golf , por lo que gana el envío con la menor cantidad de bytes.

V , 6 5 bytes

yêpjÄ

Pruébalo en línea!

Esto es en realidad un byte más largo de lo que debería ser. Debería haber sido:

äêjÄ

Pero esto tiene un error desconocido. :(

Explicación:

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

Vim, 7 bytes

♥GYPjYp

donde ♥ es 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)

Explicación: La primera expresión regular duplica la segunda columna y la segunda expresión duplica la segunda fila, ampliando así el cuadro como se desee. Editar: Guardado 4 bytes gracias a MartinEnder ♦.

Python, 49 42 bytes

Lambda anónima:

-7 de xnor

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

Versión previa:

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

D es una función que duplica el segundo elemento de una secuencia.

Retina , 20 bytes

El recuento de bytes asume la codificación ISO 8859-1.

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

Pruébalo en línea! (Hay varias líneas adicionales que permiten un conjunto de pruebas donde los casos de prueba están separados por dos avances de línea).

Explicación

1`¶
¶$%'¶

1es un límite que restringe a Retina para aplicar la sustitución solo al primer partido que encuentre. ¶coincide con un salto de línea simple, por lo que solo debemos considerar reemplazar el salto de línea al final de la primera línea. Se reemplaza con ¶$%'¶, donde $%'inserta la línea completa después del partido (un elemento de sustitución específico de Retina). Por lo tanto, esto duplica la segunda línea.

%2=`.
$&$&

Aquí, %está el modo por línea, por lo que cada línea se procesa individualmente, y las líneas se unen nuevamente después. 2=También es un límite. Éste significa "aplicar la sustitución solo al segundo partido". La coincidencia en sí es simple, un solo carácter y la sustitución lo duplica. Por lo tanto, esta etapa duplica la segunda columna.

Haskell, 24 bytes

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

Utiliza la idea de RootTwo de duplicar la segunda fila y columna. El map fhace esto para cada fila, y el f.entonces hace esto para las filas.

PowerShell v2 +, 57 53 52 bytes

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

Ligeramente similar al de Neil respuesta JavaScript . El primer reemplazo coincide con el comienzo de la línea y los siguientes dos caracteres, y los reemplaza con el primer carácter y el segundo carácter dos veces. En lugar de un segundo reemplazo, se intercambia por indexación de matriz para duplicar la segunda línea. Toma la entrada como una matriz de cadenas. Los cortes de matriz resultantes se dejan en la tubería y la impresión es implícita.

Guardado 4 bytes gracias a Martin.

Algunos ejemplos:

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 gracias a Fatalize.

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

Pruébalo en línea!

MATL , 12 bytes

tZy"@:2hSY)!

La entrada es una matriz de caracteres 2D, con punto y coma como separador de filas. Por ejemplo, el primer caso de prueba tiene entrada

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

Pruébalo en línea! Casos de prueba 1 , 2 , 3 .

Explicación

El código hace lo siguiente dos veces: repita la segunda fila de la matriz y transponga.

Para repetir la segunda fila de una matriz m× n, el vector [1 2 2 3 ... m]se usa como índice de fila. Este vector se genera de la siguiente manera: rango [1 2 3 ... m], adjuntar otro 2, ordenar.

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

Pruébalo en línea!

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

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

CJam , 14 bytes

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

Similar a mi respuesta MATL , pero repite la penúltima fila en lugar de la segunda.

Pruébalo en línea!

Explicación

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

Toma la entrada como una matriz de caracteres:

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

Aplique una función dos veces ( 2{…}/) que proporciona la transposición ( +) del argumento correcto indexado ( x@) mediante la decodificación incremental de longitud de ejecución ( &) de uno más ( 1+) una lista de las ubicaciones igual a 1 (1= ) en el rango de 0 a (! ) el tamaño de la dimensión exterior del argumento correcto (#x ).

Paso a paso,

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

Pruébalo aquí con OK.

APL, 17 15 bytes

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

Prueba:

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

Explicación:

             ⍣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

yo definitivamente que añadir el anidamiento de funciones, pero esto funciona muy bien

comenta si quieres una explicación

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

1↓ un elemento caído de

⍳ los índices

)¨ de cada

∘ de

⍴ el {conteo de filas, conteo de columnas}

⌷ índices en

⊢ el argumento

Por ejemplo para

 XX
X  X
 XX

encontramos los índices; {1, 2, 3} para las filas y {1, 2, 3, 4} para las columnas. Ahora soltamos los elementos iniciales para obtener {2, 3} y {2, 3, 4}, y luego anteponemos con {1, 2}, dando {1, 2, 2, 3} y {1, 2, 2, 3, 4}. Finalmente, usamos esto para seleccionar filas y columnas, duplicando simultáneamente la fila 2 y la columna 2.

TryAPL en línea!

Ruby, 46 bytes

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

Solución muy sencilla, tomando la entrada como un conjunto de líneas. No me gustan los inserts duplicados , así que intentaré jugarlo.

C #, 127124 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 a un Func<List<string>, List<string>> .

Versión formateada:

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