introduction

Parfois, mes boîtes sont trop petites pour y contenir quoi que ce soit. J'ai besoin de toi pour faire un expander de boîte! Alors, qu'est-ce qui fait d'une boîte une boîte dans ce défi.

 OOOO
O    O
O    O
O    O
 OOOO

Les coins de la boîte sont toujours des espaces. La boîte elle-même peut être constituée du même personnage. Ce caractère peut être n'importe quel caractère ASCII imprimable , à l'exception d'un espace. Voilà donc ces personnages:

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

Les longueurs latérales de la boîte ci-dessus sont 4, 3 . Vous pouvez supposer que la longueur du côté est toujours positive . Cela signifie que c'est la plus petite boîte que vous devez gérer:

 #
# #
 #

Pour agrandir une boîte, vous devez incrémenter chaque longueur de côté. Passons en revue, étape par étape, avec l'exemple ci-dessus. Nous prenons d'abord le côté supérieur de la boîte, qui est:

 OOOO

Nous élargissons cela d'un point, nous obtenons donc:

 OOOOO

C'est maintenant la partie supérieure et inférieure de la boîte. Après cela, nous faisons de même avec les côtés gauche et droit:

O
O
O

Devient:

O
O
O
O

Maintenant, nous remontons la boîte, ce qui se traduit par:

 OOOOO
O     O
O     O
O     O
O     O
 OOOOO

La tâche

Étant donné une boîte, agrandissez-la de 1. La boîte peut être donnée sur plusieurs lignes ou dans un tableau.

Cas de 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

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

C'est du code-golf , donc la soumission avec le moins d'octets gagne!

V , 6 5 octets

yêpjÄ

Essayez-le en ligne!

Il s'agit en fait d'un octet plus long qu'il ne devrait l'être. Cela aurait dû être:

äêjÄ

Mais cela a un bug inconnu. :(

Explication:

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

Vim, 7 octets

♥GYPjYp

où ♥ est 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 octets

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

Explication: Le premier regexp duplique la deuxième colonne et le deuxième regexp duplique la deuxième ligne, agrandissant ainsi la boîte comme vous le souhaitez. Edit: 4 octets enregistrés grâce à MartinEnder ♦.

Python, 49 42 octets

Lambda anonyme:

-7 de xnor

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

La version précédente:

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

D est une fonction qui duplique le deuxième élément d'une séquence.

Rétine , 20 octets

Le nombre d'octets suppose un codage ISO 8859-1.

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

Essayez-le en ligne! (Il existe plusieurs lignes supplémentaires qui permettent une suite de tests où les cas de test sont séparés par deux sauts de ligne.)

Explication

1`¶
¶$%'¶

1est une limite qui empêche Retina d'appliquer la substitution uniquement à la première correspondance trouvée. ¶correspond à un seul saut de ligne, nous devons donc seulement envisager de remplacer le saut de ligne à la fin de la première ligne. Il est remplacé par ¶$%'¶, où $%'insère la ligne entière après la correspondance (un élément de substitution spécifique à Retina). Par conséquent, cela duplique la deuxième ligne.

%2=`.
$&$&

Ici, %c'est le mode par ligne, donc chaque ligne est traitée individuellement, et les lignes sont à nouveau jointes par la suite. 2=est aussi une limite. Celui-ci signifie "n'appliquer la substitution qu'à la deuxième correspondance". La correspondance elle-même est un simple caractère unique et la substitution le duplique. Par conséquent, cette étape duplique la deuxième colonne.

Haskell, 24 octets

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

Utilise l' idée de RootTwo de dupliquer la deuxième ligne et la deuxième colonne. Le map ffait cela pour chaque ligne, puis le f.fait pour les lignes.

PowerShell v2 +, 57 53 52 octets

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

Légèrement similaire à la réponse JavaScript de Neil . Le premier remplacement correspond au début de la ligne et aux deux caractères suivants, et les remplace par le premier caractère et le deuxième caractère deux fois. Au lieu d'un deuxième remplacement, il est remplacé par l'indexation de tableau pour dupliquer la deuxième ligne. Prend l'entrée comme un tableau de chaînes. Les tranches de tableau résultantes sont laissées sur le pipeline et l'impression est implicite.

Sauvegardé 4 octets grâce à Martin.

Quelques exemples:

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 octets

2 octets grâce à Fatalize.

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

Essayez-le en ligne!

MATL , 12 octets

tZy"@:2hSY)!

L'entrée est un tableau de caractères 2D, avec un point-virgule comme séparateur de ligne. Par exemple, le premier cas de test a une entrée

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

Essayez-le en ligne! Cas de test 1 , 2 , 3 .

Explication

Le code effectue les opérations suivantes deux fois: répétez la deuxième ligne du tableau et transposez.

Pour répéter la deuxième ligne d'un tableau m× n, le vecteur [1 2 2 3 ... m]est utilisé comme index de ligne. Ce vecteur est généré comme suit: plage [1 2 3 ... m], attacher un autre 2, trier.

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 octets

L+<b2tbyMy

Essayez-le en ligne!

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

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

CJam , 14 octets

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

Similaire à ma réponse MATL , mais répète l'avant-dernière ligne au lieu de la seconde.

Essayez-le en ligne!

Explication

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 octets

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

Prend l'entrée comme une matrice de caractères:

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

Appliquez une fonction deux fois ( 2{…}/) qui donne la transposition ( +) de l'argument de droite indexé ( x@) par le décodage incrémental de la longueur d'exécution ( &) de un plus ( 1+) une liste des emplacements égaux à 1 ( 1=) dans la plage de 0 à ( !) la taille de la dimension extérieure de l'argument de droite (#x ).

Pas à pas,

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

Essayez-le ici avec oK.

APL, 17 15 octets

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

Tester:

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

Explication:

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

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

J'ai vraiment besoin d'ajouter l'imbrication des fonctions, mais cela fonctionne très bien

commentez si vous voulez une explication

JavaScript, 160 146 141 octets

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 octets

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

(

1 2, {1, 2} ajouté à

1↓ un élément abandonné

⍳ les indices

)¨ de chaque

∘ de

⍴ le {nombre de lignes, nombre de colonnes}

⌷ index dans

⊢ l'argument

Par exemple pour

 XX
X  X
 XX

on trouve les indices; {1, 2, 3} pour les lignes et {1, 2, 3, 4} pour les colonnes. Maintenant, nous supprimons les éléments initiaux pour obtenir {2, 3} et {2, 3, 4}, puis ajoutons {1, 2}, donnant {1, 2, 2, 3} et {1, 2, 2, 3, 4}. Enfin, nous l'utilisons pour sélectionner des lignes et des colonnes, doublant simultanément la ligne 2 et la colonne 2.

TryAPL en ligne!

Rubis, 46 octets

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

Solution très simple, prenant l'entrée comme un tableau de lignes. Je n'aime pas les doublons insert, alors j'essaierai de jouer au golf.

C #, 127 124 octets

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

Compile en un Func<List<string>, List<string>> .

Version formatée:

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