Ispirato da Cifre nelle loro corsie e 1, 2, Fizz, 4, Buzz

introduzione

Il tuo compito è generare esattamente il seguente output:

Sfida

Questa sfida si basa sulla sfida Fizz Buzz ed ecco un riepilogo: genera i numeri da 1 a 100 inclusi, ogni numero sulla propria riga, ma se il numero è un multiplo di 3, dovresti generare "Fizz" invece di il numero originale, se il numero è un multiplo di 5, dovresti emettere "Buzz" invece del numero originale. Se il numero è un multiplo di 15, dovresti generare "FizzBuzz" invece del numero originale.

Tuttavia, oltre al requisito precedente, è necessario rientrare in ciascuna riga utilizzando gli spazi per fare in modo che ogni colonna contenga solo caratteri univoci (esclusi spazi e nuove righe). Gli spazi anteposti ad ogni riga sono il minimo richiesto per far apparire tutte le righe prima che (incluso) abbia caratteri univoci in ogni colonna.

Ad esempio, 1,2,Fizz,4non ha bisogno di alcun rientro, perché hanno già personaggi unici in ogni colonna (colonna 1: 12F4, column2: i, column3: z, column4: z), ma quando si aggiungono Buzzdobbiamo trattino da due spazi perché altrimenti avremmo due zs' sia nella terza che nella quarta colonna. Dal momento che due spazi sono sufficienti per raggiungere l'obiettivo, non devi rientrare di tre spazi. 7e 8non ha bisogno di alcun rientro ma quando viene emesso 11dobbiamo rientrare di uno spazio perché la prima colonna ha già un 1. 13quindi deve essere rientrato di tre spazi perché ora la 1a, 2a e 3a colonna hanno tutte a 1. Il rientro per le righe rimanenti segue la stessa regola.

Per semplificare la sfida, il limite superiore è stato modificato in 50.

Specifiche

È possibile scrivere un programma o una funzione. Nessuno dei due dovrebbe accettare input non vuoti. Prendere un input vuoto va bene.
Poiché si tratta di una sfida KC, è necessario produrre l'output come specificato nella sezione Introduzione. Va bene una sola riga finale. Nessuna nuova riga di intestazione o spazi di intestazione aggiuntivi. Non ci sono spazi finali aggiuntivi per ogni riga.
Il programma può uscire con errori o avere output STDERR non vuoto purché STDOUT sia conforme alle specifiche.
Questo è il golf-code intra-lingua , il programma con il minor numero di byte vince nella sua lingua.
Si applicano scappatoie predefinite .

code-golf kolmogorov-complexity

— Weijun Zhou
fonte

2

L'output fornito non corrisponde esattamente alle specifiche, ad esempio le righe 12, 20, 35 e 50.

— Gorgogliatore

1

Ma il secondo carattere nelle prime due righe è il ritorno a capo.

— Accumulo

Ho escluso gli spazi, ora dovrei escludere anche le nuove righe.

— Weijun Zhou,

9

Python 2 , 127 byte

i=0;exec"print ord('<<<<>@<<BD=F?@HABJCNP=@RT?VABXCBZ<^`=>bdDf>?hBCjEn'[i])%60*' '+(i%3/2*'Fizz'+i%5/4*'Buzz'or`-~i`);i+=1;"*50

Provalo online!

Una tabella di ricerca di cinquanta byte sembra danneggiare la dimensione del codice in meno della logica necessaria per tenere traccia dei caratteri che si sono verificati in ciascuna colonna.

— Lynn
fonte

1

La logica sarebbe stata migliore se ci fosse stato richiesto di stampare fino a 100 invece ...

— Bubbler,

5

Python 2 , 167 166 163 161 157 byte

a=eval(`[{0}]*99`);i=0
exec"f=i%3/2*'Fizz'+i%5/4*'Buzz'or`i+1`;i+=1;g=0\nwhile any(b>{c}for b,c in zip(a[g:],f)):g+=1\nmap(set.add,a[g:],f);print' '*g+f;"*50

Provalo online!

modifiche:

whileè più corto di for..range()1 byte.
Grazie a @ovs per la rasatura di 3 byte. Dimentico sempre exec...
i%3/2Trucco adattato dalla risposta di Lynn (-2 byte).
@Lynn ha suggerito a=map(set,[[]]*99), ma ho trovato un altro modo usando evale reprcon gli stessi byte (-4 byte).

Utilizzare un elenco di set per tenere traccia dei caratteri utilizzati per ciascuna colonna e impostare la disuguaglianza per l'appartenenza. Il resto segue le specifiche esatte fornite.

— bubbler
fonte

4

C (gcc) , 145 144 byte (143 per esadecimale)

i;main(){for(;i++<50;printf("%*s%s%.d\n","000402800:81>34@56B7BH14JH3N56P76R0RX12ZX8^23`67b9b"[i]-48,i%3?"":"Fizz",i%5?"":"Buzz",i%3*i%5?i:0));}

Provalo online!

0000h: 69 3B 6D 61 69 6E 28 29 7B 66 6F 72 28 3B 69 2B ; i;main(){for(;i+
0010h: 2B 3C 35 30 3B 70 72 69 6E 74 66 28 22 25 2A 73 ; +<50;printf("%*s
0020h: 25 73 25 2E 64 5C 6E 22 2C 22 FE FE FE 02 FE 00 ; %s%.d\n","......
0030h: 06 FE FE 08 06 FF 0C 01 02 0E 03 04 10 05 10 16 ; ................
0040h: FF 02 18 16 01 1C 03 04 1E 05 04 20 FE 20 26 FF ; ........... . &.
0050h: 63 28 26 06 2C 00 01 2E 04 05 30 07 30 22 5B 69 ; c(&.,.....0.0"[i
0060h: 5D 2B 32 2C 69 25 33 3F 22 22 3A 22 46 69 7A 7A ; ]+2,i%3?"":"Fizz
0070h: 22 2C 69 25 35 3F 22 22 3A 22 42 75 7A 7A 22 2C ; ",i%5?"":"Buzz",
0080h: 69 25 33 2A 69 25 35 3F 69 3A 30 29 29 3B 7D    ; i%3*i%5?i:0));}

— l4m2
fonte

3

Rubino , 129 byte

puts (1..50).map{|n|" "*(".<<<<>@<<BD=F?@HABJCNP=@RT?VABXCBZ<^`=>bdDf>?hBCjEn"[n].ord%60)+("FizzBuzz
"[i=n**4%-15,i+13]||n.to_s)}

Provalo online!

Il doppio credito va a Lynn qui, per l' approccio della tabella di ricerca e l' algoritmo fizzbuzz .

L'algoritmo FizzBuzz è molto interessante e dipende dalla straordinaria coincidenza che tutti i numeri positivi, non composti, inferiori a 15 (diversi da 3 e 5), se portati alla 4a potenza, sono 1 in più di un multiplo di 15. In fatto:

 n     n**4  n**4%15  n**4%-15
 1        1     1       -14
 2       16     1       -14
 3       81     6        -9
 4      256     1       -14
 5      625    10        -5
 6     1296     6        -9
 7     2401     1       -14
 8     4096     1       -14
 9     6561     6        -9
10    10000    10        -5
11    14641     1       -14
12    20736     6        -9
13    28561     1       -14
14    38416     1       -14
15    50625     0         0

I valori 3**4%15e 5**4%15sono esattamente 4 a parte: la lunghezza della stringa "Fizz". Possiamo sfruttarlo usandoli per indicizzare dalla fine di una stringa, lunga almeno 9 caratteri. I multipli di 3 indicizzeranno dall'inizio della stringa e i multipli di 5 indicizzeranno da 5 caratteri dalla fine. Ogni altro numero tenterà di indicizzare prima dell'inizio della stringa e non riuscirà, ritornando nil. Quindi 15, ovviamente, indici dal 0 ° carattere. Il fatto che "FizzBuzz" sia lungo solo 8 caratteri è un piccolo ostacolo; usiamo un carattere newline per riempirlo, che verrà successivamente ignorato puts.

È possibile che la tabella di ricerca possa essere superata da un approccio più procedurale, ma il mio tentativo è stato di circa 190 byte.

— benj2240
fonte

2

Interessante. Va notato che il fatto che tutti i numeri si coprono a 15 quando elevato alla 4a potenza pari a 1 modulo 15 può essere derivato dal piccolo teorema di Fermat.

— Weijun Zhou,

2

[JavaScript (Node.js) REPL], 144 byte

(f=(i,s=[['Fizz'][i%3]]+[['Buzz'][i%5]]||i+[],b=i>1?f(i-1):[])=>[...s].some((p,j)=>b.some(w=>w[j]==p&0!=p))?f(i,' '+s):b.push(s)&&b)(50).join`

`

Provalo online!

Lo stesso programma di avviso esegue un tempo inaccettabile

JavaScript (Node.js) , 132 byte di Arnauld

f=(a=n=[],s=`${b=++n%5?'':'Buzz',n%3?b||n:'Fizz'+b}
`)=>n>50?'':a.some(x=>[...x].some((c,i)=>c!=0&c==s[i]))?f(a,' '+s):s+f([s,...a])

Provalo online!

— l4m2
fonte

La tua risposta non sembra essere la stessa del link TIO

— Jo King,

@JoKing TIO emette array e non so se sia consentito

— l4m2

2

Java (JDK 10) , 185 byte

v->{for(int n=0,l;n<50;System.out.printf((l>0?"%"+l:"%")+"s%s%n","",(n%3<1?"Fizz":"")+(n%5<1?"Buzz":n%3<1?"":n)))l="####%'##)+$-&'/()1*57$'9;&=()?*)A#EG$%IK+M%&O)*Q,U#".charAt(n++)-35;}

Provalo online!

Crediti

Geobit per il loro breve codice FizzBuzz
-1 byte grazie a Kevin Cruijssen (anche se lo stavo facendo quando ha pubblicato il commento ;-))

— Olivier Grégoire
fonte

1

Haskell , 190 187 186 178 176 byte

unlines$foldl(\a x->a++[[z|z<-iterate(' ':)x,all(\m->null[p|(p,q)<-m`zip`z,p==q&&p>' '])a]!!0])[]$h<$>[1..50]
a%b=a`mod`b<1
h n|n%15="FizzBuzz"|n%3="Fizz"|n%5="Buzz"|1<2=show n

Provalo online!

La versione leggermente più leggibile (e annotata):

-- check if a is evenly divisible by b
a%b=a`mod`b<1
-- produce correct FizzBuzz output for a number
h n|n%15="FizzBuzz"|n%3="Fizz"|n%5="Buzz"|1<2=show n
-- test if all chars distinct between two strings
x#y=null[a|(a,b)<-x`zip`y,a==b&&a>' ']
-- given a new string and all previous strings
-- shift the new string to the right until all
-- chars are distinct
x!y=[z|z<-iterate(' ':)y,all(z#)x]!!0
g=h<$>[1..50]
f'=foldl step[]g
  where step acc x = acc++[acc!x]

Modifica: ho finito per integrare alcune funzioni nella versione golfata per salvare più byte.

— Cristian Lupascu
fonte

@Laikoni Right. Fisso.

— Cristian Lupascu,

1

Jstx , 122 byte

◄50-☺6*ø($♥:ø↕♂Fizz♀☺(◙$♣:ø↕♂Buzz♀6☺(◙"ø↕$6◙♂<<<<>@<<BD=F?@HABJCNP=@RT?VABXCBZ<^`=>bdDf>?hBCjEn'[i])%60*♀&P◄59▼ö,► 7.☻a0.2

Provalo online!

— Quantum64
fonte

Fizz Buzz con caratteri unici in colonne

introduzione

Sfida

Specifiche

Python 2 , 127 byte

Python 2 , 167 166 163 161 157 byte

C (gcc) , 145 144 byte (143 per esadecimale)

Rubino , 129 byte

[JavaScript (Node.js) REPL], 144 byte

JavaScript (Node.js) , 132 byte di Arnauld

Java (JDK 10) , 185 byte

Crediti

Haskell , 190 187 186 178 176 byte

Jstx , 122 byte