Tâche

Étant donné un caractère imprimable non blanc, faites une représentation carrée 3x3 de cette entrée. Par exemple, si l'entrée est #, alors la sortie est:

###
# #
###

Règles

• Le format de sortie est strict, bien qu'une nouvelle ligne de fin soit autorisée. Cela signifie que l'espace au milieu est requis, et aussi que les deux caractères de nouvelle ligne séparant les trois lignes sont requis.

Cas de test

Contribution: #

Sortie:

###
# #
###

Contribution: A

Sortie:

AAA
A A
AAA

Contribution: 0

Sortie:

000
0 0
000

Notation

C'est du code-golf . La réponse la plus courte en octets l'emporte.

Fusain , 5 3 octets

Ｂ³Ｓ

Essayez-le en ligne! Edit: Économisez 40% grâce à @carusocomputing. Explication:

Ｂ   Draw a box
³   3×3 (second dimension is implicit if omitted)
Ｓ   Using the input character

Carotte , 11 octets

###
# #
###

Essayez-le en ligne!

Le programme est en mode curseur, où #s sont remplacés par l'entrée.

Python 2 , 32 octets

lambda s:s+s.join(s+'\n \n'+s)+s

Essayez-le en ligne!
Pour s='a': le milieu le s+'\n \n'+sgénère a\n \naet le s.jointransforme (les caractères gras sont ceux qui ajoutent), car accepte une chaîne comme itérable, puis elle est entourée des deux caractères manquantsaa\na a\naaa.join.join

MATL , 5 octets

3Y6*c

Essayez-le en ligne!

Explication

3Y6   % Push predefined literal: [true true true; true false true; true true true]
*     % Implicitly input a character. Multiply element-wise by its code point
c     % Convert to char. Implicitly display. Char 0 is displayed as space

05AB1E , 8 octets

4×ð«û3ô»

Essayez-le en ligne!

INPUT    # ['R']                 | Implicit Input: 'R'
---------#-----------------------+-------------------------------
4×       # ['RRRR']              | Repeat string 4 times.     
  ð      # ['RRRR',' ']          | Push space onto top of stack.
   «     # ['RRRR ']             | Concatenate last 2 items.
    û    # ['RRRR RRRR']         | Palindromize.
     3ô  # [['RRR','R R','RRR']] | Split into 3 pieces.
       » # ['RRR\nR R\nRRR']     | Join with newlines
---------#-----------------------+-------------------------------
OUTPUT   # RRR                   | Implicitly print the top
         # R R                   | of the stack on exit.
         # RRR                   |

Idée originale utilisant 30 comme nombre binaire (inachevé, quelqu'un d'autre essaie ceci dans une autre langue):

05AB1E , 12 octets

30bûTIð«‡3ô»

Essayez-le en ligne!

Python 3.6 , 33 octets

lambda c:f'{3*c}\n{c} {c}\n{3*c}'

Essayez-le en ligne!

RPL (Reverse Polish Lisp) , 60 caractères

→STR 1 4 START DUP NEXT " " + SWAP + 4 ROLLD + + SWAP 2 PICK

(Notez que "→" est un seul caractère sur le HP48 et les calculatrices compatibles)

Représenterait visuellement ce que vous voulez en ayant trois éléments sur la pile:

3.: "###"
2.: "# #"
1.: "###"

Si vous insistez pour le renvoyer en une seule chaîne, vous devez également ajouter les caractères de nouvelle ligne et combiner les chaînes, laissées en exercice au testeur suivant.

Explication:

• →STR: Transformez le dernier objet de la pile en chaîne. (Ainsi, l'entrée peut être n'importe quoi, par exemple un nombre.)
• 1 4: Poussez le numéro 1et 4vers la pile.
• START [...] NEXT: Comme une boucle for mais sans accès à la variable counter. Prend deux nombres de la pile (ici, nous venons de pousser 1et 4) et exécute le code [...]les temps correspondants (ici, quatre fois).
• DUP: Dupliquez la dernière entrée de la pile.
• " ": Poussez la chaîne (c'est-à-dire la chaîne avec un espace) dans la pile.
• +: Prenez deux objets de la pile et renvoyez-les ensemble, pour les chaînes: Concaténées.
• 4: Poussez le numéro 4sur la pile.
• ROLLD: Prend le dernier élément (ici: 4que nous venons de pousser) de la pile et fait rouler l'élément suivant aussi bas dans la pile que le nombre que nous venons de prendre de la pile spécifie.
• SWAP: Échange les deux derniers éléments de la pile.
• 2: Poussez 2vers la pile.
• PICK: Prend un élément (ici: le 2nous venons de pousser vers la pile), l'interprète comme un nombre n et copie le nième élément de la pile.

JavaScript, 28 octets

c=>c+c+c+`
${c} ${c}
`+c+c+c

Essayez-le

f=
c=>c+c+c+`
${c} ${c}
`+c+c+c
o.innerText=f(i.value="#")
i.oninput=_=>o.innerText=f(i.value)

<input id=i maxlength=1><pre id=o>

Gelée , 8 octets

1 octet merci à Erik l'Outgolfer.

x4,`Ks3Y

Essayez-le en ligne!

Java 7, 56 55 octets

-1 Merci à Leaky Nun d'avoir souligné l'espace qui m'a manqué

String a(char s){return"...\n. .\n...".replace('.',s);}

Remplace simplement les points par le caractère donné, pour l'entrée #:

...       ###
. .  =>   # #
...       ###

Essayez-le en ligne!

PHP, 32 octets

<?=strtr("000
0 0
000",0,$argn);

Essayez-le en ligne!

sed, 28 18 octets

s:.:&&&\n& &\n&&&:

Essayez-le en ligne!

Brain-Flak , 76 70 + 1 = 71 octets

Nécessite le -cdrapeau

(((((((({})))<((([])[]{}<>)<>)>)<(<>({})({}){}()()<>)>)<([]()()())>)))

Essayez-le en ligne!

Pyth, 7 octets

jc3.[9d

Essayez ceci en ligne.

Explication:

jc3.[9d Expects quoted input.
  3     3
     9  9
      d ' '
        Q (eval'd input) as implicit argument
   .[   Pad B on both sides with C until its length is a multiple of A
 c      Split B to chunks of length A, last chunk may be shorter
j       Join A on newlines

Brain-Flak , 61 , 59 octets

(((((((({})))<([][][]())>)<(([][][]()){})>)<([]()()())>)))

Essayez-le en ligne!

Il s'agit de 58 octets de code +1pour l' -cindicateur qui permet l'entrée et la sortie ASCII.

Explication:

(((
   (
    (
     (

      #Duplicate the input 3 times
      ((({})))

#Push 10 (newline)
<([][][]())>

     #Push the input again
     )

#Push 32 (space)
<(([][][]()){})>

    #Push the input again
    )

#Push 10 (newline)
<([]()()())>)

#Push input 3 times
)))

C (gcc) , 49 47 octets

Enregistré 2 octets grâce à 2501!

j;f(i){for(j=12;j;)putchar(--j%4?j-6?i:32:10);}

Essayez-le en ligne! a une nouvelle ligne de fin

Python 3 , 34 octets

lambda s:s*3+"\n"+s+" "+s+"\n"+s*3

Essayez-le en ligne!

Octave , 36 octets

x=repmat(input(0),3);x(5)=32;disp(x)

Essayez-le en ligne!

Explication

Cela crée une matrice de 3x3 caractères avec le caractère d'entrée répété et définit sa 5ème entrée dans l'ordre des colonnes principales (c'est-à-dire son centre) sur 32(ASCII pour l'espace).

Pyke , 5 octets

dQA.X

Essayez-le en ligne!

Rubis , 27 25 octets

Sauvegardé 2 octets grâce à Level River St

->x{[s=x*3,x+" "+x,s]*$/}

Essayez-le en ligne!

Brainfuck, 40 octets

+++++[->++<<++++++>],...>.<.<++.>.>.<...

Essayez-le en ligne! Nécessite une implémentation qui peut accéder à gauche de la position de départ.

Voir aussi: la réponse du cerveau de Graviton qui adopte une approche différente (mais est plus longue).

Explication:

Brainfuck peut faire beaucoup de trucs sympas avec son jeu d'instructions limité. Malheureusement, cette réponse n'en utilise aucun, car il est moins cher (en termes d'octets) de tout coder en dur.

+++++[->++<<++++++>]                         Sets the cells to |5*6|>0<|5*2|
,                   Takes input character into the middle cell | 30|>#<| 10|
...                                Print the top of the square | 30|>#<| 10| ###
>.                                   Print a newline character | 30| # |>10|    \n
<.                               Print another input character | 30|>#<| 10| #
<++.                  Add 30+2 for a space character and print |>32| # | 10|  _
>.                   And just print the 5 remaining characters | 32|>#<| 10|   #
>.                                                             | 32| # |>10|    \n
<...                                                           | 32|>#<| 10| ###

# = caractère saisi, _ = espace (ASCII 32), \ n = nouvelle ligne (ASCII 10)

Résultats dans cette belle boîte (pour l'entrée '+'):

+++
+ +
+++

05AB1E , 7 6 octets

-1 octet grâce à carusocomputing.

ж¹ðJû

Explication:

         # Implicit input                  # ['R']
 Ð       # Repeat string three times       # ['R', 'R', 'R']
  ¶      # Push newline character          # ['R', 'R', 'R', '\n']
   ¹     # Push first input                # ['R', 'R', 'R', '\n', 'R']
    ð    # Push space                      # ['R', 'R', 'R', '\n', 'R', ' ']
     J   # Join stack                      # ['RRR\nR ']
      û  # Palindromize ("abc" -> "abcba") # ['RRR\nR R\nRRR']
         # Implicit output                 # []

Utilise l' encodage CP-1252 . Essayez-le en ligne!

Pyth , 11 octets

jc++K*z4dK3

Essayez-le en ligne!

Explication:

jc++K*z4dK3    expects a single char as input

j              joins on new line
 c        3    chops array into 3 sized pieces
  +            joins +K*z4d and K
   +           joins K*z4 and d
    K          initialize variable K as *z4
     *z4       duplicate the input 4 times
        d      variable initialized to string " "
         K     calls variable K, in this case *z4

> <> , 24 23 octets

i:o:o:oao:o84*o:a0!.<o$

Essayez-le en ligne!

Swift3, 50 octets

[1,2,3].map{$0==2 ? print(c+" "+c) : print(c+c+c)}

Cela utilise l'opérateur ternaire pour imprimer différentes chaînes, selon la ligne.

Essayez-le en ligne

V , 8 octets

x3p2Ùlr 

Essayez-le en ligne!

C #, 50 octets

a=>Console.Write(a+a+a+"\n"+a+" "+a+"\n"+a+a+a);

Cas de test:

var f = new Action<string>(
a=>Console.Write(a+a+a+"\n"+a+" "+a+"\n"+a+a+a);
);
f("#");

Vim, 9 frappes

En supposant que le caractère d'entrée est présent dans un tampon, vim rend cela simple

x3pY2plr<space>

Il y a probablement quelques commandes Magic Vim utiles ici (il semble toujours y en avoir), donc les suggestions d'amélioration sont les bienvenues. Une seule touche derrière V!

Assemblage Z80 ou 8080, code machine 21 octets

Supposons un périphérique d'E / S mappé en mémoire:

              Z80 8080
3A xx xx ld a, (entrée) entrée lda; obtenir le caractère d'entrée
11 0A 20 ld de, 200ah lxi d, 200ah; espace et nouvelle ligne
21 aa aa aa hl, sortie lxi h, sortie; obtenir l'adresse de sortie
77 ld (hl), a mov m, a; caractère de sortie * 3
77 ld (hl), a mov m, a
77 ld (hl), a mov m, a
73 ld (hl), e mov m, e; sortie nouvelle ligne
77 ld (hl), a mov m, a; caractère de sortie
72 ld (hl), d mov m, d; espace de sortie
77 ld (hl), a mov m, a; caractère de sortie
73 ld (hl), e mov m, e; sortie nouvelle ligne
77 ld (hl), a mov m, a; caractère de sortie * 3
77 ld (hl), a mov m, a
77 ld (hl), a mov m, a
76 halte hlt; ou C9 ret

Aucun interprète nécessaire!

Hexdump:

0000: 3A 00 FF 11 0A 20 21 01 FF 77 77 77 73 77 72 77
0010: 73 77 77 77 76

où l'adresse d'entrée est à FF00h et l'adresse de sortie est mappée à FF01h. Les adresses réelles dépendront du matériel réel. Bien sûr, cela suppose que les E / S sont mappées en mémoire. S'il s'agit d'E / S mappées, cela prendrait plusieurs octets supplémentaires car les instructions d'E / S Z80 et 8080 sont de deux octets chacune. Cela suppose également que le périphérique de sortie interprète 0Ah comme une nouvelle ligne et ne nécessite pas de CR (0Dh) qui ajouterait 4 octets supplémentaires au programme.

J-uby , 22 20 octets

-2 octets grâce à @Jordan

:tr&"...
. .
..."&?.

Explication

String#trest la méthode de remplacement par caractère de Ruby. La première &se lie :trà "...\n. .\n...", et le second applique partiellement '.'à elle. En fait, c'est->s{"...\n. .\n...".tr('.',s)}