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.