Essayez de faire un carré!

20

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.

code-golf  string  ascii-art 
— Luc H
source
2
Le fait que la taille soit fixe permet une certaine optimisation. Les réponses du défi lié ne seront probablement pas compétitives ici. Donc je ne pense pas que ce soit un doublon
— Luis Mendo
12
J'étais celui qui a rétrogradé, car c'était un défi simple et ennuyeux. Je suis normalement un fan de défis faciles, car ils sont un bon endroit pour commencer de nouveaux golfeurs, mais cela semble trop facile.
— Shaggy
32
@Ayoungcoder C'est une raison parfaitement valable pour voter contre un défi.
— Wheat Wizard
2
@Shaggy: En termes de difficulté, il est difficile d'écrire le programme et de jouer au golf. Ce programme est facile à écrire, mais je ne suis pas sûr qu'il soit facile à jouer au golf.
5
À mon avis, c'est un bon défi pour les personnes qui commencent tout juste à jouer au golf avec code. C'est bien d'avoir un mélange de difficultés. La surcharge sur n'importe quel type sera au détriment d'une partie de la communauté. Donc, je suis content que ce défi ait été écrit.
— isaacg

Réponses:

30

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
— Neil
source
3
J'ai l'impression que c'est de la triche ...> _>
— HyperNeutrino
14
Ensuite, bien sûr, Ｂ³Ｓpour tromper la merde vivante.
— Urne Magic Octopus
1
Pourquoi serait-ce de la triche? @carusocomputing et neil sa réponse me semble juste
— Luc H
1
@Ayoungcoder "tricher" comme dans "semble bon marché" pas comme dans "tricherie littérale"; le code a une fonction intégrée pour «imprimer une boîte de dimensions n en utilisant le caractère s», le code le plus court pour ce défi étant: 1. Lire l'entrée. 2. Définissez la dimension. 3. Boîte d'impression. La réponse à ce défi ne sera logiquement pas inférieure à 2 octets si l'entrée est implicite.
— Magic Octopus Urn
2
@carusocomputing Ah, l'ironie - le comportement carré implicite m'a énervé dans ma réponse pour Visualiser à nouveau l'algorithme euclidien .
— Neil
19

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

— Barre
source
Comment cela ajoute-t-il les caractères à la ligne médiane? Pourriez-vous expliquer la réponse s'il vous plaît?
— Notts90
1
@ Notts90 a ajouté une explication c:
— Rod
merci, je ne savais pas que .join pouvait parcourir une chaîne.
— Notts90
Cela fonctionne également en Python 3. BTW très cool. (En outre, en utilisant la même méthode, les 3*c+c.join('\n \n')+3*cliens sont à 32.)
— Jonathan Allan
15

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
— Luis Mendo
source
1
c'était rapide! Je ne m'attendais pas à ce qu'un 5 octets vienne aussi vite.
— Luc H
2
Langues de golf de code, vous savez ... ¯ \ _ (ツ) _ / ¯
— Luis Mendo
11
Bien sûr, parce que pourquoi n'auriez-vous pas un littéral prédéfini pour [vrai vrai vrai; vrai faux vrai; vrai vrai vrai]
— PunPun1000
11
@ PunPun1000 C'est en fait beaucoup utilisé (avec convolution) car c'est le masque standard à 8 connectivités (quartier de Moore )
— Luis Mendo
3
@LuisMendo C'est génial, apprenez quelque chose de nouveau ici tous les jours, pas toujours sur le golf à code
— PunPun1000
13

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!

— Urne de poulpe magique
source
— Oliver Ni
11

Python 3.6 , 33 octets

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

Essayez-le en ligne!

— Jonathan Allan
source
Aucun problème. Il semble qu'il s'agisse en fait de la version 3.6.1; si vous essayez import sys, puis sys.versiondans la réplique, elle renvoie 3.6.1 plutôt que 3.5.2. Aucune idée pourquoi il est dit 3.5.2 en haut alors, il semble qu'ils y aient fait une erreur!
— numbermaniac
2
Oh, haha, un cas de "ne croyez pas toujours ce que vous lisez" - merci!
— Jonathan Allan
9

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.

Entrée (peut être n'importe quoi, n'a pas besoin d'être une chaîne) Code saisi Résultat

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.
— Golar Ramblar
source
7

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>
Développer l'extrait

— Hirsute
source
Je pense que vous pourriez être en mesure d'enregistrer un octet ou deux en stockant le résultat de c+'\n'+cdans un temporaire.
— Neil
Tant pis, je me suis trompé, c'est toujours 28 octets.
— Neil
@Neil: Oui, il y a quelques options pour assigner des choses à une variable, mais elles arrivent toutes à 28 octets ou plus.
— Shaggy
6

Gelée , 8 octets

1 octet merci à Erik l'Outgolfer.

x4,`Ks3Y

Essayez-le en ligne!

— Leaky Nun
source
Je me demandais comment faire ça ... J'en avais x4µ©;⁶;®œs3Ypour 12 octets car je n'arrivais pas à comprendre comment éviter que la répétition multiplie toute mon étape intermédiaire mais sympa!
— HyperNeutrino
1
Vous savez, il y a une fonction intégrée Kpour faire j⁶. Oh, et il y a un rapide, `pour convertir une dyade en monade en utilisant le même argument des deux côtés.
— Erik the Outgolfer
5

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!

— PunPun1000
source
5

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
— Erik le Outgolfer
source
4

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
)))
— DJMcMayhem
source
3

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).

— Luis Mendo
source
3

Rubis , 27 25 octets

Sauvegardé 2 octets grâce à Level River St

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

Essayez-le en ligne!

— Alex
source
lorsque vous faites des réponses comme celle-ci, veuillez également inclure le pied de page comme code car cela ne fonctionne pas sans
— Luc H
@Ayoungcoder, il s'agit d'une fonction anonyme. vous pouvez l'affecter à une variable ( f=...) puis l'appeler avecf.call(...)
— Cyoce
1
Vous pouvez utiliser un saut de ligne littéral entre guillemets au lieu de "\n"pour économiser 1 octet. Encore une meilleure utilisation $/qui est une variable spéciale définie par défaut sur la nouvelle ligne - économisant 2 octets.
— Level River St
1 octet de moins que la trsolution. beau travail
— Cyoce
3

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 '+'):

+++
+ +
+++
— Zack C.
source
3

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!

— Oliver Ni
source
Oooo ... Intelligent, je ne pense jamais à la façon dont palindromize fonctionne sur les nouvelles lignes.
— Urne Magic Octopus
ж¹ðJûpour 6 octets.
— Urne Magic Octopus
3

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
— ChromaticiT
source
Bienvenue chez PPCG!
— Stephen
2

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

— Martyav
source
2

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("#");
— CHENGLIANG YE
source
Vous devez entièrement qualifier le ConsoleieSystem.Console..
— TheLethalCoder
2

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!

— algmyr
source
Je suis sûr que c'est aussi court que possible. Bonne réponse!
— DJMcMayhem
2

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.

— Dan Howell
source
Bienvenue sur Codegolf.stackexchange, bien qu'il semble que vous ayez tout sous contrôle, veuillez lire le centre d'aide et la liste des FAQ. Bon premier post
— Rohan Jhunjhunwala
Pouvez-vous fournir un vidage hexadécimal de votre code?
— CalculatriceFeline
Les octets hexadécimaux sont dans la première colonne, mais si vous voulez un vidage hexadécimal "pur", je l'ai ajouté.
— Dan Howell
2

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

— Cyoce
source
Fonctionnerait :traussi bien :gsubqu'ici?
— Jordanie
@Jordan oui, merci!
— Cyoce
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.