Prova a creare un cubo!


16

Sulla base di questo: fammi un quadrato!

È necessario generare questo:

  ####
 # # #
###  #
# # #
####

Dove "#" viene sostituito con l'input.

Se inserisci "A", dovresti ottenere

  AAAA
 A A A
AAA  A
A A A
AAAA

Se inserisci "&", dovresti ottenere

  &&&&
 & & &
&&&  &
& & &
&&&&

Classifica

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.


5
Bene, questo è in qualche modo simile, anche se almeno non è una risposta a 3 byte in Charcoal questa volta ...
— Neil

1
Le ultime due righe possono avere spazi iniziali e il risultato può avere nuove righe iniziali?
— dzaima,

3
B³S‖O↗potrebbe essere molto vicino a una risposta di 10 byte in carbone però ... Non conosco abbastanza bene la lingua per farlo, c'è davvero bisogno di una pagina come questa, ma per carbone.
— Magic Octopus Urn

5
@AAlex Sandbox
— xnor

6
Non vedo come questo sia un inganno di quello quadrato
— Luis Mendo,

Risposte:


19

Carota , 31 byte

  ####
 # # #
###  #
# # #
####

#gli s sono sostituiti dall'input.

Fondamentalmente una porta di questa risposta , a questo problema.


40
sembra che ci siano volute ore per giocare a golf ...
— Cyoce,

@KritixiLithos 200 rep perché hai fatto un bel linguaggio, questo non sembra giusto xD
— Stephen

13

05AB1E , 16 15 byte

ð‚•nxвΛ•2вèJ6ô»

Provalo online!

Spiegazione

ð‚                # push the list [<input>,<space>]
  •nxвΛ•          # push the number 816342339
        2в        # convert to list of base 2 digits
          è       # index into the the 2-char string with this list
           J      # join to string
            6ô    # split into pieces of length 6
              »   # join on newlines

1
È possibile codificare la nuova riga nell'elenco / numero per salvare gli ultimi 3 byte?
— Rod,

@Rod Sarebbe un numero molto più grande, almeno 6 byte, più uno o due byte extra per includere la nuova riga nell'elenco ...
— ETHproductions

@Rod: Si potrebbe fare qualcosa di simile a questo . Purtroppo questo risulta un po 'più lungo. Buona idea però.
— Emigna,

1
•nxвΛ•bTRð¹ì‡6ô»... i tuoi battiti si traslitterano leggermente, solo a causa dei requisiti di ordinazione; se potessi capire un modo per prendere implicitamente l'input e generare la stringa 01in 1 byte, questa sarebbe una soluzione da 13/14 byte.
— Magic Octopus Urn

1
@carusocomputing •nxвΛ•bT𹫇6ô»o ha la ð«T•nxвΛ•br‡6ô»stessa lunghezza.
— Emigna,

10

Cubix , 62 byte

./v<.o;.@?/;w.w;i:::::NrSs::SrSuUS::sN::rS:r:srNr:SrSsNs:::SSv

Provalo online! e guarda l'interprete!

Questo si adatta a un cubo 4:

        . / v <
        . o ; .
        @ ? / ;
        . . w ;
i : : : : : N r S s : : S r S u
U S : : s N : : r S : r : s r N
r : S r S s N s : : : S S v . .
. . . . . . . . . . . . . . . .
        . . . .
        . . . .
        . . . .
        . . . .

Non sono molto bravo a manipolare la direzione del puntatore dell'istruzione, quindi continuerò a provare a giocare a golf. Sia questa che la mia risposta qui si basano sul "Ciao, mondo!" programma di esempio usando ./v.o;@?/(su un cubo 3) per stampare ricorsivamente e far apparire i caratteri nello stack, quindi il resto del codice sta semplicemente spingendo i caratteri nello stack nell'ordine giusto.

Ora ho creato un cubo su un cubo, quindi posso riposare facilmente (e fare il mio lavoro effettivo).


9

SOGL , 13 10 byte

Βū&⁵'r⁹‘6n

Spiegazione:

Βū&⁵'r⁹‘    push "  ŗŗŗŗ ŗ ŗ ŗŗŗŗ  ŗŗ ŗ ŗ ŗŗŗŗ", where "ŗ" is replaced with input
        6n  split into lines of length 6

1
Com'è questa seduta a 0? Probabilmente a causa della mancanza di un TIO ._. +1
— Magic Octopus Urn

Penso che ci sarà (si spera) la maggior parte degli altri aggiornamenti di aggiornamento e poi penserò a qualcosa di in esecuzione online
— dzaima,

6
Figlio di una lingua da golf?
— ETHproductions

@ETHproductions lol
— dzaima,

String Oriented Golfing Language
— a'_ '23

9

MATL , 13 10 byte

Grazie a Conor O'Brien per aver rimosso 3 byte e per avermi mostrato che in Octave è possibile utilizzare non stampabili.

Il codice contiene caratteri non stampabili. Provalo online!

Spiegazione

'....'   % Push 5-char string (contains unprintables). Each char encodes a row
         % of the desired pattern
B        % Convert to binary. Gives a 5×6 binary matrix with the pattern
*        % Implicit input. Multiply element-wise (converts input to ASCII code)
c        % Convert to char. Implicitly display. Char 0 is shown as space

Puoi fare questo 10 byte se stai bene con gli stampabili. Provalo online!
— Conor O'Brien,

@ ConorO'Brien Ehi, grazie! Non ero sicuro che Octave fosse d'accordo con quelli ... come li hai digitati?
— Luis Mendo,

Bene, onestamente ho preso i numeri, li ho convertiti in esadecimali, poi l'ho fatto echo 0f15392a3c|xxd -r -p|clip. Su Windows, clipè negli Appunti. Poi li ho appena incollati: P (Se sei su una riga di comando, lo è ^O^Uanche)
— Conor O'Brien,

@ ConorO'Brien Questo è molto oltre la mia testa. Dovresti davvero pubblicarlo come risposta
— Luis Mendo,

Usa la stessa tattica della tua, semplicemente rimuovendo la necessità di modulo 64 usando direttamente i valori.
— Conor O'Brien,


6

Japt , 20 byte

"OUyj|"®c ¤Åd0S1U +R

Provalo online!

Non male per una lingua senza compressione incorporata (beh, tranne la compressione di stringhe di lettere minuscole) ...

Spiegazione

In binario, i cinque caratteri nella stringa sono:

O 1001111
U 1010101
y 1111001
j 1101010
| 1111100

Tagliare l'iniziale 1da ciascuno e si ottiene il modello per il cubo.

"OUyj|"®   c ¤  Å  d0S1U +R
"OUyj|"mZ{Zc s2 s1 d0S1U +R}  // Expanded
                              // Implicit: U = input string
"OUyj|"mZ{                 }  // Replace each character Z in this string with this function:
          Zc                  //   Take the char-code of Z.
             s2               //   Convert to a binary string.
                s1            //   Slice off the first character (always a "1").
                   d0S1U      //   Replace "0"s with spaces and "1"s with the input.
                         +R   //   Append a newline.
                              // Implicit: output result of last expression

Ho provato un approccio basato su template ( llpuò essere compresso), ma è più lungo di 11 byte.
— Luca,

Bello. Ero giù a 23 byte prima che mi rendessi conto di averne fatto una palla!
— Shaggy,

6

LOLCODE, 202 170 byte

I HAS A c
GIMMEH c
VISIBLE"  "AN c AN c AN c AN c AN":) "AN c AN" "AN c AN" "AN c AN":)"AN c AN c AN c AN"  "AN c AN":)"AN c AN" "AN c AN" "AN c AN":)"AN c AN c AN c AN c

In LOLCODE, non molto da golf ...

Questo imposta la variabile cnell'input e crea una stringa concatenata gigante che include :)newline. Questo è tutto.


expected HAI at: I tio.run/nexus/…
— eush77

Inoltre, VISIBLEconcatena implicitamente, quindi puoi rimuovere SMOOSH tio.run/nexus/lolcode#@@/…
— eush77

Per prima cosa, ci sono alcuni interpreti che non richiedono HAI o KTHXBYE, ad esempio REPL.it. Per la tua seconda cosa, grazie!
— OldBunny2800,

5

Sed, 40 personaggi

s/./  &&&&\
 & & &\
&&&  &\
& & &\
&&&&/

Quasi barare perché la descrizione della sfida la conteneva quasi letteralmente.

Esecuzione di esempio:

bash-4.4$ sed 's/./  &&&&\
 & & &\
&&&  &\
& & &\
&&&&/' <<< 'C'
  CCCC
 C C C
CCC  C
C C C
CCCC

Provalo online!



5

Z80 Assembly, 37 byte code machine

Supponiamo che un dispositivo I / O mappato in memoria:

; NON INSERIRE UNO SPAZIO o andrà in spazi di stampa a ciclo infinito e newline!

3A xx xx ld a, (input); ottenere il carattere di input
11 0A 20 ld de, 200ah; spazio e newline
21 yy yy ld hl, output; ottenere l'indirizzo di uscita
4F ld c, a; metti il ​​personaggio in c
ciclo continuo:
72 ld (hl), d; spazio di uscita * 2 | carattere di output * 2
72 ld (hl), d
77 ld (hl), a; carattere di output | carattere di output
71 ld (hl), c; carattere di output * 2 | spazio di uscita * 2
71 ld (hl), c
77 ld (hl), a; carattere di output | carattere di output
73 ld (hl), e; uscita newline | uscita newline
72 ld (hl), d; spazio di uscita | carattere di output
71 ld (hl), c; carattere di output | spazio di uscita
72 ld (hl), d; spazio di uscita | carattere di output
71 ld (hl), c; carattere di output | spazio di uscita
72 ld (hl), d; spazio di uscita | carattere di output
B9 cp c; imposta lo zero flag per la prima volta | cancella la seconda volta
20 06 jr nz, fine; saltare alla fine
77 ld (hl), a; carattere di output
73 ld (hl), e; uscita newline
4A ld c, d; mettere spazio in c
57 ld d, a; metti il ​​carattere in d
28 FB jr z, loop; passa alla seconda volta
fine:
73 ld (hl), e; uscita newline
77 ld (hl), a; carattere di output * 4
77 ld (hl), a
77 ld (hl), a
77 ld (hl), a
76 stop; o C9 ret

4

V , 27 byte

4äl2>>Äyvho3pÄÙ3älWx<<3Îd^

Provalo online!

hexdump:

00000000: 34e4 6c32 3e3e c479 7668 6f1b 3370 c4d9  4.l2>>.yvho.3p..
00000010: 33e4 6c57 783c 3c33 ce64 5e              3.lWx<<3.d^

Sono abbastanza sicuro che puoi sostituirlo o<esc>con soloï
— Kritixi Lithos,

4

PHP, 72 byte

L'ho creato solo per divertimento, dal momento che esiste già una risposta PHP migliore.

for($i=0;$i<27;)echo('00'.decbin(64349871))[$i]?$argn:' ',++$i%6?'':'
';

Il cubo viene disegnato ottenendo il valore binario di 64349871, concatenato da '00'.
Ciò restituisce quanto segue:

0011110101011110011010101111

Ogni sesto personaggio, sto emettendo una nuova riga, risultante in questo:

001111
010101
111001
101010
1111

E, invece di visualizzare 0, mostra uno spazio, che sarà simile a:

  1111
 1 1 1
111  1
1 1 1 
1111

4

Carbone , 17 16 byte

SβGH7+↗→³β→G↓↙³β

Provalo online! Il collegamento è alla versione dettagliata del codice. Più lungo di quanto volessi, perché il "cubo" è leggermente più largo di quanto sia alto o profondo. Fortunatamente alcuni dei personaggi multidirezionali funzionano con PolygonHollow, il che mi fa risparmiare 3 byte. Modifica: salvato un ulteriore byte usando + invece di T ↑. Spiegazione:

Sβ          Input the character
GH7+↗→³β    Draw the left half. 7 becomes ←↙ and + becomes →↓←↑.
→           Move right one character.
G↓↙³β       Draw the right half.

Al momento della sfida, la qvariabile non funzionava in modalità dettagliata, altrimenti avrei potuto creare questa versione a 14 byte:

GH7+↗→³θ→G↓↙³θ

Provalo online!


3

Impilato , 31 byte

' '\+$'9*<'#.2 tb[6 dpad]map#

Provalo online!

Ecco un hexdump:

λ xxd try-to-make-a-cube.stk
00000000: 2720 275c 2b24 270f 1539 2a3c 2723 2e32  ' '\+$'..9*<'#.2
00000010: 2074 625b 3620 6470 6164 5d6d 6170 23     tb[6 dpad]map#

Ciò converte un array di caratteri in binario, sposta ogni riga in lunghezza 6e lo indicizza in base alla stringa' ' input +



2

JS (ES6), 64 60 52 byte

i=>`  ####
 # # #
###  #
# # #
####`.replace(/#/g,i)

Questo può essere migliorato:

i=>`  ${y=i+i+i+i}
 # # #
###  #
# # #
${y}`.replace(/#/g,i)

1
y=i+i+i+iè più breve diy=i.repeat(4)
— Stephen,

2
... ed ####è ancora più breve.
— Arnauld,

1
In realtà il tutto è più corto senza modelli: Fiddle
— Stephen,

1

C (gcc) , 90 84 byte

i;v;f(g){for(i=32;i--;)putchar((v="####*@#@#@#*#@@###*#@#@#@*####@@"[i])&1?g:v-32);}

Provalo online! Definisce una funzione fche accetta un personaggiog . Peccato che la codifica della tabella direttamente sia più breve ...

Vecchia versione, 90 byte

(Sto ancora cercando di giocare a golf)

Prova di avere solo un singolo putchar, ma idk. Ci sono non stampabili, quindi ecco il hexdump:

λ xxd try-to-make-a-cube.c
00000000: 693b 6a3b 6628 6729 7b63 6861 722a 6b3d  i;j;f(g){char*k=
00000010: 220f 1539 2a3c 223b 666f 7228 693d 303b  "..9*<";for(i=0;
00000020: 693c 353b 7075 7463 6861 7228 3130 292c  i<5;putchar(10),
00000030: 692b 2b29 666f 7228 6a3d 3332 3b6a 3b6a  i++)for(j=32;j;j
00000040: 2f3d 3229 7075 7463 6861 7228 6b5b 695d  /=2)putchar(k[i]
00000050: 266a 3f67 3a33 3229 3b7d                 &j?g:32);}

Questo codifica il cubo in una tabella di ricerca binaria, in cui un 1bit rappresenta l'input e un 0bit rappresenta uno spazio. Provalo online!


Può radere alcuni byte per 81 byte .
— Gastropner

Quello non stampabile può essere compresso a 73 byte .
— Gastropner

1

Brain-Flak , 217 byte

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

Provalo online!

Waaaaay troppo a lungo.


1

Swift - 82 byte + Foundation (18 byte)?

var f={"  ####\n # # #\n###  #\n# # #\n####".replacingOccurrences(of:"#",with:$0)}

Per impostazione predefinita, i progetti Xcode-Swift hanno Whole-Module Optimization, quindi import Foundationnon è necessario per questa semplice funzione simile a lambda. Tuttavia, eseguirlo in ambienti online lo richiede, che può aggiungere 18 byte.

Controlla!



0

CJam, 23 byte

"pjFUC"{i2b(;}%rS+ff=N*

Sento che posso ancora giocare a golf.

"pjFUC" e# String literal:          │ "pjFUC"
{       e# For each:                │ 'p
  i     e#   Get code point:        │ 112
  2b    e#   To binary:             │ [1 1 1 0 0 0 0]
  (;    e#   Delete first:          │ [1 1 0 0 0 0]
}%      e# End                      │ [[1 1 0 0 0 0] [1 0 1 0 1 0] [0 0 0 1 1 0] [0 1 0 1 0 1] [0 0 0 0 1 1]]
r       e# Read token:              │ [[1 1 0 0 0 0] [1 0 1 0 1 0] [0 0 0 1 1 0] [0 1 0 1 0 1] [0 0 0 0 1 1]] "&"
S       e# Push space:              │ [[1 1 0 0 0 0] [1 0 1 0 1 0] [0 0 0 1 1 0] [0 1 0 1 0 1] [0 0 0 0 1 1]] "&" " "
+       e# Concatenate:             │ [[1 1 0 0 0 0] [1 0 1 0 1 0] [0 0 0 1 1 0] [0 1 0 1 0 1] [0 0 0 0 1 1]] "& "
ff=     e# Vectorized array lookup: │ ["  &&&&" " & & &" "&&&  &" "& & & " "&&&&  "]
N*      e# Join with newlines       │ "  &&&&
        e#                          │   & & &
        e#                          │  &&&  &
        e#                          │  & & & 
        e#                          │  &&&&  "
e# Implicit output

0

dc , 70 byte

Codifica la sequenza piuttosto direttamente, con un'ottimizzazione minore:

8224PdPdPdPdP10Pd8192+ddPPP10PdPdPdP8224PdP10Pd256*32+ddPPP10PdPdPdPdP

Provalo online!


Portato a un estremo (non molto golfistico), 145 byte:

27065671941896667324298575455432398417474802390765222440949482848513*56759961956005660143530475805610581704254588701249011343446231795984498688+P

Provalo online!

Questo calcola A*x+B, dove Acodifica le posizioni del carattere di input e Bcodifica tutto il resto:

A = 256 0 + 256 1 + 256 2 + 256 3 + 256 5 + 256 7 + 256 9 + 256 11 + 256 14 + 256 15 + 256 16 + 256 18 + 256 20 + 256 22 + 256 25 + 256 26 + 256 27 + 256 28

B = 10 × 256 4 + 32 × 256 6 + 32 × 256 8 + 10 × 256 10 + 32 × 256 12 + 32 × 256 13 + 10 × 256 17 + 32 × 256 19 + 32 × 256 21 + 32 × 256 23 + 10 × 256 24 + 32 × 256 29 + 32 × 256 30

P comando stampa il numero risultante come flusso di byte.



0

Lotto di Windows, 79 byte

@echo   %1%1%1%1
@echo  %1 %1 %1
@echo %1%1%1  %1
@echo %1 %1 %1
@echo %1%1%1%1

Char speciale. sicuro, 97 byte:

@echo   ^%1^%1^%1^%1
@echo  ^%1 ^%1 ^%1
@echo ^%1^%1^%1  ^%1
@echo ^%1 ^%1 ^%1
@echo ^%1^%1^%1^%1

Puoi usare i feed di linea, ad esempio.. %1%1%1%1\n %1 %1 %1...
— TheLethalCoder

I feed di riga non sono supportati in batch
— stevefestl

Non riuscivo a ricordare se fossero o no e non fossero in grado di testare :)
— TheLethalCoder

Scusa, sono confuso, puoi ripetere?
— stevefestl,

Non riuscivo a ricordare se potevi usarli o meno e non potevo testare al momento in cui ho commentato, quindi ho lasciato il commento in modo da avere ancora l'idea
— TheLethalCoder

0

Tcl, 60 byte

proc c x {regsub . $x "  &&&&\n & & &\n&&&  &\n& & &\n&&&&"}
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.