Prova a fare un quadrato!

20

Compito

Dato un carattere stampabile non bianco, crea una rappresentazione quadrata 3x3 di quell'input. Ad esempio, se l'input è #, allora l'output è:

###
# #
###

Regole

  • Il formato di output è rigoroso, sebbene sia consentita una nuova riga finale. Significa che è richiesto lo spazio nel mezzo e anche i due caratteri di nuova riga che separano le tre linee.

Casi test

Ingresso: #

Produzione:

###
# #
###

Ingresso: A

Produzione:

AAA
A A
AAA

Ingresso: 0

Produzione:

000
0 0
000

punteggio

Questo è code-golf . Vince la risposta più breve in byte.

code-golf  string  ascii-art 
— Luc H
fonte
2
Il fatto che la dimensione sia fissa consente una certa ottimizzazione. Le risposte dalla sfida collegata probabilmente non saranno competitive qui. Quindi non penso che sia un duplicato
— Luis Mendo
12
Sono stato io a votare verso il basso, perché è stata una sfida semplice e noiosa. Di solito sono un fan delle sfide facili, in quanto sono un buon posto per iniziare i nuovi giocatori di golf, ma questo è semplicemente troppo facile.
— Shaggy,
32
@Ayoungcoder È un motivo perfettamente valido per votare una sfida.
— Wheat Wizard
2
@Shaggy: in termini di difficoltà, c'è difficoltà a scrivere il programma e difficoltà a giocare a golf. Questo programma è facile da scrivere, ma non sono così sicuro che sia facile da golf.
5
Secondo me, questa è una bella sfida per le persone che stanno appena iniziando a giocare a golf con il codice. È bello avere un mix di difficoltà. Il sovraccarico su qualsiasi tipo sarà a scapito di una parte della comunità. Quindi, sono contento che questa sfida sia stata scritta.
— isaacg,

Risposte:

30

Carbone , 5 3 byte

Ｂ³Ｓ

Provalo online! Modifica: risparmiato il 40% grazie a @carusocomputing. Spiegazione:

Ｂ   Draw a box
³   3×3 (second dimension is implicit if omitted)
Ｓ   Using the input character
— Neil
fonte
3
Sento che questo è barare ...> _>
— HyperNeutrino,
14
Quindi, ovviamente, Ｂ³Ｓper ingannare la merda vivente da questo.
— Magic Octopus Urn,
1
Perché questo sarebbe barare? @carusocomputing e neil la sua risposta mi sembra giusta
— Luc H,
1
@Ayoungcoder "barare" come in "sembra economico" non come in "barare letterale"; il codice ha un built-in per "stampare una scatola di dimensioni n usando il carattere s", il codice più breve per questa sfida è: 1. Leggi input. 2. Definire la dimensione. 3. Casella di stampa. La risposta a questa sfida logicamente non sarà inferiore a 2 byte se l'input è implicito.
— Magic Octopus Urn,
2
@carusocomputing Ah, l'ironia: il comportamento quadrato implicito mi ha infastidito nella mia risposta a visualizzare di nuovo l'algoritmo euclideo .
— Neil,
19

Python 2 , 32 byte

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

Provalo online!
Per s='a': il centro lo s+'\n \n'+sgenera a\n \nae lo s.jointrasforma (grassetto sono quelli che aggiunge), perché accetta una stringa come iterabile, quindi è circondata dai due caratteri mancantiaa\na a\naaa.join.join

— asta
fonte
In che modo questo aggiunge i personaggi alla linea di mezzo? Potresti spiegare la risposta per favore?
— Notts90,
1
@ Notts90 ha aggiunto una spiegazione c:
— Rod,
grazie non lo sapevo .join poteva iterare una stringa.
— Notts90,
Funziona anche con Python 3. A proposito, molto bello. (Inoltre, usando lo stesso metodo si 3*c+c.join('\n \n')+3*clega a 32.)
— Jonathan Allan
15

MATL , 5 byte

3Y6*c

Provalo online!

Spiegazione

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
fonte
1
è stato veloce! non mi aspettavo che un 5 byte arrivasse così velocemente.
— Luc H,
2
Lingue per giocare a golf, sai ... ¯ \ _ (ツ) _ / ¯
— Luis Mendo,
11
Certo, perché non dovresti avere un valore letterale predefinito per [vero vero vero; vero falso vero; true true true]
— PunPun1000,
11
@ PunPun1000 In realtà è molto usato (insieme alla convoluzione) in quanto è la maschera standard a 8 connettività ( Moore neighboorhood )
— Luis Mendo,
3
@LuisMendo È fantastico, impara qualcosa di nuovo ogni giorno qui, non sempre sul golf del codice
— PunPun1000,
13

05AB1E , 8 byte

4×ð«û3ô»

Provalo online!

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                   |

Idea originale che usa 30 come numero binario (incompiuto, qualcun altro prova questo in un'altra lingua):

05AB1E , 12 byte

30bûTIð«‡3ô»

Provalo online!

— Urna di polpo magico
fonte
— Oliver Ni,
11

Python 3.6 , 33 byte

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

Provalo online!

— Jonathan Allan
fonte
Nessun problema. Sembra che sia effettivamente in esecuzione 3.6.1; se provi import syse poi sys.versionnel sostitu, restituisce 3.6.1 anziché 3.5.2. Non ho idea del motivo per cui si dice 3.5.2 all'inizio, sembra che abbiano fatto un errore lì!
— numbermaniac,
2
Oh, haha, un caso di "non credere sempre a quello che leggi" - grazie!
— Jonathan Allan,
9

RPL (Reverse Polish Lisp) , 60 caratteri

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

(Notare che "→" è un singolo carattere sull'HP48 e calcolatori compatibili)

Rappresenterebbe visivamente ciò che vuoi avendo tre oggetti in pila:

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

Se insisti a restituirlo come una stringa, devi aggiungere anche i caratteri di nuova riga e combinare le stringhe, lasciate come esercizio al prossimo tester.

Input (può essere qualsiasi cosa, non è necessario che sia una stringa) Codice inserito Risultato

Spiegazione:

  • →STR: Trasforma l'ultimo oggetto nello stack in una stringa. (Quindi l'input può essere qualsiasi cosa, ad esempio un numero.)
  • 1 4: Spingere il numero 1e 4nello stack.
  • START [...] NEXT: Come un ciclo for ma senza accesso alla variabile counter. Prende due numeri dallo stack (qui, abbiamo appena premuto 1e 4) ed esegue il codice [...]i tempi corrispondenti (qui, quattro volte).
  • DUP: Duplica l'ultima voce nello stack.
  • " ": Inserire la stringa (ovvero la stringa con uno spazio bianco) nello stack.
  • +: Prende due oggetti dallo stack e restituiscili aggiunti insieme, per le stringhe: concatenati.
  • 4: Spingere il numero 4nello stack.
  • ROLLD: Prende l'ultimo elemento (qui: 4che abbiamo appena spinto) dallo stack e lancia l'elemento successivo fino allo stack come specificato dal numero che abbiamo appena preso dallo stack.
  • SWAP: Scambia gli ultimi due elementi dello stack.
  • 2: Spingere 2verso la pila.
  • PICK: Prende un elemento (qui: 2abbiamo appena inserito nello stack), lo interpreta come un numero n e copia l'ennesimo elemento dallo stack.
— Golar Ramblar
fonte
7

JavaScript, 28 byte

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

Provalo

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>
Espandi frammento

— ispido
fonte
Penso che potresti essere in grado di salvare un byte o due memorizzando il risultato c+'\n'+cin un temporaneo.
— Neil,
Non importa, ho contato male, è ancora 28 byte.
— Neil,
@Neil: Sì, ci sono un paio di opzioni per assegnare elementi a una variabile, ma arrivano tutti a 28 byte o più.
— Shaggy,
6

Gelatina , 8 byte

1 byte grazie a Erik the Outgolfer.

x4,`Ks3Y

Provalo online!

— Perdente Suora
fonte
Mi stavo chiedendo come fare ... Avevo x4µ©;⁶;®œs3Y12 byte perché non riuscivo a capire come evitare che la ripetizione moltiplicasse il mio intero passaggio intermedio ma bello!
— HyperNeutrino,
1
Sai, c'è un incorporato Kper fare j⁶. Oh, e c'è un veloce, `per convertire una diade in una monade usando lo stesso argomento su entrambi i lati.
— Erik the Outgolfer,
5

Java 7, 56 55 byte

-1 Grazie a Leaky Nun per aver indicato lo spazio che mi mancava

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

Sostituisce semplicemente i punti con il carattere specificato, per input #: 

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

Provalo online!

— PunPun1000
fonte
5

PHP, 32 byte

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

Provalo online!

— Jörg Hülsermann
fonte
Abbastanza interessante <?=$a=$argn,"$a$a\n$a $a\n$a$a$a";(l'interruzione di riga reale invece di \ n ovviamente) ha esattamente lo stesso numero di byte.
— Christoph,
@Christoph rendilo il tuo approccio. non ho provato questo modo alternativo
— Jörg Hülsermann,
5

Pyth, 7 byte

jc3.[9d

Prova questo online.

Spiegazione:

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 the Outgolfer
fonte
4

Brain-Flak , 61 , 59 byte

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

Provalo online!

Si tratta di 58 byte di byte di codice +1per il -cflag che abilita input e output ASCII.

Spiegazione:

(((
   (
    (
     (

      #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
fonte
3

Ottava , 36 byte

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

Provalo online!

Spiegazione

Questo crea una matrice di caratteri 3x3 con il carattere di input ripetuto e imposta la sua 5a voce nell'ordine della colonna maggiore (cioè il suo centro) su 32(ASCII per lo spazio).

— Luis Mendo
fonte
3

Rubino , 27 25 byte

Salvato 2 byte grazie a Level River St

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

Provalo online!

— alex
fonte
quando stai rispondendo in questo modo, includi anche il piè di pagina come codice perché non funziona senza
— Luc H,
@Ayoungcoder questa è una funzione anonima. puoi assegnarlo a una variabile ( f=...) quindi chiamarlo conf.call(...)
— Cyoce
1
È possibile utilizzare una nuova riga letterale tra virgolette anziché "\n"per un risparmio di 1 byte. Uso ancora migliore, $/che è una variabile speciale impostata su newline per impostazione predefinita, risparmiando 2 byte.
— Level River St,
1 byte in meno rispetto alla trsoluzione. bel lavoro
— Cyoce,
3

Brainfuck, 40 byte

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

Provalo online! Richiede un'implementazione che può accedere a sinistra della posizione iniziale.

Vedi anche: la risposta brainfuck di Graviton che adotta un approccio diverso (ma è più lungo).

Spiegazione:

Brainfuck può fare molti trucchi interessanti con il suo set di istruzioni limitato. Sfortunatamente, questa risposta non ne usa nessuna, perché è più economico (in termini di byte) codificare tutto.

+++++[->++<<++++++>]                         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| ###

# = carattere di input, _ = spazio (ASCII 32), \ n = newline (ASCII 10)

Risultati in questo bellissimo riquadro (per input '+'):

+++
+ +
+++
— Zack C.
fonte
3

05AB1E , 7 6 byte

-1 byte grazie al carusocomputing.

ж¹ðJû

Spiegazione:

         # 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                 # []

Utilizza la codifica CP-1252 . Provalo online!

— Oliver Ni
fonte
Oooo ... Intelligente, non penso mai a come funziona palindromize su newline.
— Magic Octopus Urn
ж¹ðJûper 6 byte.
— Magic Octopus Urn
3

Pyth , 11 byte

jc++K*z4dK3

Provalo online!

Spiegazione:

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
fonte
Benvenuti in PPCG!
— Stephen,
2

Swift3, 50 byte

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

Questo utilizza l'operatore ternario per stampare stringhe diverse, a seconda della riga.

Provalo online

— Martyav
fonte
2

C #, 50 byte

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

Caso di prova:

var f = new Action<string>(
a=>Console.Write(a+a+a+"\n"+a+" "+a+"\n"+a+a+a);
);
f("#");
— CHENGLIANG YE
fonte
È necessario qualificare pienamente ConsoleieSystem.Console..
— TheLethalCoder
2

Vim, 9 battute

Supponendo che il carattere di input sia presente in un buffer, vim lo rende semplice

x3pY2plr<space>

Probabilmente ci sono alcuni comandi magici d'uso di Vim qui (sembrano essercene sempre alcuni) quindi i suggerimenti per il miglioramento sono ben accetti. Solo una sequenza di tasti dietro V!

— algmyr
fonte
Sono abbastanza sicuro che sia il più breve possibile. Bella risposta!
— DJMcMayhem
2

Gruppo Z80 o 8080, codice macchina 21 byte

Supponiamo che un dispositivo I / O mappato in memoria:

              Z80 8080
3A xx xx ld a, (input) ingresso lda; ottenere il carattere di input
11 0A 20 ld de, 200ah lxi d, 200ah; spazio e newline
21 yy yy ld hl, output lxi h, output; ottenere l'indirizzo di uscita
77 ld (hl), a mov m, a; carattere di output * 3
77 ld (hl), a mov m, a
77 ld (hl), a mov m, a
73 ld (hl), e mov m, e; uscita newline
77 ld (hl), a mov m, a; carattere di output
72 ld (hl), d mov m, d; spazio di uscita
77 ld (hl), a mov m, a; carattere di output
73 ld (hl), e mov m, e; uscita newline
77 ld (hl), a mov m, a; carattere di output * 3
77 ld (hl), a mov m, a
77 ld (hl), a mov m, a
76 stop hlt; o C9 ret

Nessun interprete necessario!

hexdump:

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

dove l'indirizzo di input è su FF00h e l'indirizzo di output è mappato su FF01h. Gli indirizzi effettivi dipenderanno dall'hardware effettivo. Ovviamente ciò presuppone che l'I / O sia mappato in memoria. Se è mappato I / O, occorrerebbero diversi byte extra poiché le istruzioni I / O Z80 e 8080 sono due byte ciascuna. Ciò presuppone anche che il dispositivo di output interpreti 0Ah come una nuova riga e non richieda un CR (0Dh) che aggiungerebbe altri 4 byte al programma.

— Dan Howell
fonte
Benvenuto in Codegolf.stackexchange, mentre sembra che tu abbia tutto sotto controllo, ti preghiamo di leggere il centro assistenza e l'elenco delle domande frequenti. Buon primo post
— Rohan Jhunjhunwala,
Puoi fornire un hexdump del tuo codice?
— CalculatorFeline
I byte esadecimali si trovano nella prima colonna, ma se vuoi un hexdump "puro", l'ho aggiunto.
— Dan Howell,
2

J-uby , 22 20 byte

-2 byte grazie a @Jordan 

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

Spiegazione

String#trè il metodo di sostituzione del personaggio di Ruby. Il primo &si lega :tra "...\n. .\n...", e la seconda parte si applica '.'ad esso. In effetti, questo è->s{"...\n. .\n...".tr('.',s)}

— Cyoce
fonte
Funzionerebbe :trcosì come :gsubqui?
— Giordania,
@Jordan sì, grazie!
— Cyoce,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.