Inspiriert von Ziffern in ihren Gassen und 1, 2, Fizz, 4, Buzz

Einführung

Ihre Aufgabe ist es, genau die folgende Ausgabe zu generieren:

1
2
Fizz
4
  Buzz
    Fizz
7
8
      Fizz
        Buzz
 11
          Fizz
   13
    14
            FizzBuzz
     16
      17
              Fizz
       19
                  Buzz
                    Fizz
 22
    23
                      Fizz
                        Buzz
   26
                          Fizz
     28
      29
                            FizzBuzz
       31
      32
                              Fizz
34
                                  Buzz
                                    Fizz
 37
  38
                                      Fizz
                                        Buzz
        41
                                          Fizz
  43
   44
                                            FizzBuzz
      46
       47
                                              Fizz
         49
                                                  Buzz

Herausforderung

Diese Herausforderung basiert auf der Fizz Buzz-Herausforderung. Hier ist eine Zusammenfassung: Geben Sie die Zahlen von 1 bis einschließlich 100 aus, wobei jede Zahl in einer eigenen Zeile steht. Wenn die Zahl jedoch ein Vielfaches von 3 ist, sollten Sie statt "Fizz" ausgeben Wenn die ursprüngliche Nummer ein Vielfaches von 5 ist, sollten Sie "Buzz" anstelle der ursprünglichen Nummer ausgeben. Wenn die Zahl ein Vielfaches von 15 ist, sollten Sie "FizzBuzz" anstelle der ursprünglichen Zahl ausgeben.

Zusätzlich zu der obigen Anforderung sollten Sie jedoch jede Zeile mit Leerzeichen einrücken, damit jede Spalte nur eindeutige Zeichen enthält (mit Ausnahme von Leerzeichen und Zeilenumbrüchen). Die Leerzeichen vor jeder Zeile stellen das Minimum dar, das erforderlich ist, damit alle Zeilen angezeigt werden, bevor sie (einschließlich) eindeutige Zeichen in jeder Spalte enthalten.

Zum Beispiel 1,2,Fizz,4braucht keine Vertiefung , weil sie bereits eindeutige Zeichen in jeder Spalte (Spalte 1: 12F4, column2: i, column3: z, Column4: z), aber beim Hinzufügen Buzzmüssen wir Gedankenstrich durch zwei Räume , weil sonst hätten wir zwei haben z‚s in der 3. und 4. Spalte. Da zwei Leerzeichen ausreichen, um das Ziel zu erreichen, sollten Sie es nicht um drei Leerzeichen einrücken. 7und 8benötigt keine Einrückung, aber bei der Ausgabe müssen 11wir um ein Leerzeichen einrücken, da die erste Spalte bereits eine hat 1. 13muss dann um drei Leerzeichen eingerückt werden, da nun die 1., 2. und 3. Spalte alle ein1 . Einrückungen für die restlichen Zeilen folgen der gleichen Regel.

Um die Herausforderung zu vereinfachen, wurde die Obergrenze auf 50 geändert.

Technische Daten

• Sie können ein Programm oder eine Funktion schreiben. Keiner von beiden sollte eine nicht leere Eingabe annehmen. Leere Eingaben sind in Ordnung.

• Da dies eine KC-Herausforderung ist, müssen Sie die im Abschnitt Einführung angegebene Ausgabe erstellen. Eine einzelne nachgestellte Zeile ist in Ordnung. Keine Zeilenumbrüche oder zusätzliche Leerzeichen. Keine zusätzlichen Leerzeichen für jede Zeile.

• Ihr Programm kann mit einem Fehler beendet werden oder eine nicht leere STDERR-Ausgabe haben, solange STDOUT der Spezifikation entspricht.

• Dies ist Intra-Language- Code-Golf , das Programm mit der niedrigsten Anzahl von Bytes gewinnt in seiner Sprache.

• Es gelten Standardlücken .

Python 2 , 127 Bytes

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

Probieren Sie es online!

Eine 50-Byte-Nachschlagetabelle scheint die Codegröße weniger zu beeinträchtigen als die Logik, die erforderlich ist, um zu verfolgen, welche Zeichen in jeder Spalte aufgetreten sind.

Python 2 , 167 166 163 161 157 Bytes

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

Probieren Sie es online!

Bearbeitungen:

• whileist kürzer als for..range()1 Byte.
• Vielen Dank an @ovs für das Abschneiden von 3 Bytes. ich vergesse immerexec ...
• Angepasst i%3/2 Trick aus Lynns Antwort (-2 Bytes).
• @Lynn vorgeschlagen a=map(set,[[]]*99), aber ich fand einen anderen Weg mit evalund reprmit den gleichen Bytes (-4 Bytes).

Verwenden Sie eine Liste von Sätzen, um die Zeichen zu verfolgen, die für jede Spalte verwendet werden, und legen Sie die Ungleichheit für die Mitgliedschaft fest. Der Rest folgt der genauen Spezifikation.

C (gcc) , 145 144 Bytes (143 für hex)

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

Probieren Sie es 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));}

Ruby , 129 Bytes

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

Probieren Sie es online!

Lynn erhält hier eine doppelte Gutschrift für den Lookup-Table-Ansatz und den Fizzbuzz-Algorithmus .

Der FizzBuzz-Algorithmus ist sehr interessant und hängt von dem bemerkenswerten Zufall ab, dass alle positiven, nicht zusammengesetzten Zahlen unter 15 (außer 3 und 5), wenn sie auf die 4. Potenz angehoben werden, 1 mehr als ein Vielfaches von 15 sind Tatsache:

 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

Die Werte 3**4%15und 5**4%15sind genau 4 auseinander: die Länge der Zeichenfolge "Fizz". Wir können dies ausnutzen, indem wir sie verwenden, um ab dem Ende einer Zeichenfolge mit einer Länge von mindestens 9 Zeichen zu indizieren. Ein Vielfaches von 3 indiziert ab dem Anfang der Zeichenfolge und ein Vielfaches von 5 indiziert ab dem Ende ab 5 Zeichen. Jede andere Zahl wird versuchen, vor dem Anfang der Zeichenfolge zu indizieren, und schlägt fehl, und kehrt zurück nil. Dann indiziert 15 natürlich ab dem 0. Zeichen. Die Tatsache, dass "FizzBuzz" nur 8 Zeichen lang ist, ist ein kleines Hindernis. Wir verwenden ein Newline-Zeichen, um es aufzufüllen, das später von ignoriert wird puts.

Es ist möglich, dass die Nachschlagetabelle durch einen prozeduralen Ansatz ausgelagert werden kann, aber mein Versuch lag in der Nähe von 190 Bytes.

[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`

`

Probieren Sie es online!

Das Warnprogramm selbst führt eine inakzeptable Zeit aus

JavaScript (Node.js) , 132 Bytes von 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])

Probieren Sie es online!

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

Probieren Sie es online!

Credits

• Geobits für ihren kurzen FizzBuzz-Code
• -1 Byte dank Kevin Cruijssen (obwohl ich es getan habe, als er den Kommentar gepostet hat ;-))

Haskell , 190 187 186 178 176 Bytes

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

Probieren Sie es online!

Die etwas besser lesbare (und kommentierte) Version:

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

Bearbeiten: Ich habe einige Funktionen in der Golf-Version eingefügt, um mehr Bytes zu sparen.

Jstx , 122 Bytes

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

Probieren Sie es online!