Wprowadzenie

W naszym ostatnim wysiłku zebrania katalogów najkrótszych rozwiązań dla standardowych ćwiczeń programistycznych, oto pierwsze w historii waniliowe wyzwanie PPCG FizzBuzz. Jeśli chcesz zobaczyć inne wyzwania katalogu, jest „Hello World!” i „Czy ta liczba jest liczbą pierwszą?” .

Wyzwanie

Napisz program, który drukuje liczby dziesiętne od 1 do 100 włącznie. Ale dla wielokrotności trzech drukowanych liter „Fizz” zamiast liczby i dla wielokrotności pięciu drukowanych liter „Buzz”. W przypadku liczb będących wielokrotnością zarówno trzech, jak i pięciu drukuj „FizzBuzz”.

Wynik

Wynikiem będzie lista liczb (i Fizzes, Buzzes i FizzBuzzes) oddzielonych znakiem nowej linii (albo \nlub \r\n). Końcowy znak nowej linii jest dopuszczalny, ale wiodący znak nowej linii nie. Oprócz wyboru nowej linii wynik powinien wyglądać dokładnie tak:

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
Fizz
52
53
Fizz
Buzz
56
Fizz
58
59
FizzBuzz
61
62
Fizz
64
Buzz
Fizz
67
68
Fizz
Buzz
71
Fizz
73
74
FizzBuzz
76
77
Fizz
79
Buzz
Fizz
82
83
Fizz
Buzz
86
Fizz
88
89
FizzBuzz
91
92
Fizz
94
Buzz
Fizz
97
98
Fizz
Buzz

Jedynym wyjątkiem od tej reguły jest stałe wyjście interpretera twojego języka, którego nie można stłumić, takie jak powitanie, kody kolorów ANSI lub wcięcia.

Dalsze zasady

• Nie chodzi o znalezienie języka z najkrótszym podejściem do grania w FizzBuzz, chodzi o znalezienie najkrótszego podejścia w każdym języku. Dlatego żadna odpowiedź nie zostanie oznaczona jako zaakceptowana.

• Zgłoszenia są oceniane w bajtach w odpowiednim wcześniej istniejącym kodowaniu, zwykle (ale niekoniecznie) UTF-8. Niektóre języki, takie jak Foldery, są trudne do zdobycia - w razie wątpliwości zapytaj na Meta.

• Nic nie można wydrukować do STDERR.

• W przeciwieństwie do naszych zwykłych zasad, możesz swobodnie używać języka (lub wersji językowej), nawet jeśli jest nowszy niż to wyzwanie. Jeśli ktoś chce to nadużyć, tworząc język, w którym pusty program generuje dane wyjściowe FizzBuzz, gratuluje utorowania drogi dla bardzo nudnej odpowiedzi.

  Pamiętaj, że musi być tłumacz, aby można było przetestować zgłoszenie. Dozwolone jest (a nawet zachęcane) samodzielne pisanie tego tłumacza dla wcześniej niewdrożonego języka.

• Jeśli twój wybrany język jest trywialną odmianą innego (potencjalnie bardziej popularnego) języka, który ma już odpowiedź (pomyśl dialekty BASIC lub SQL, powłoki uniksowe lub trywialne pochodne Brainfuck, takie jak Alphuck i ???), rozważ dodanie notatki do istniejącego odpowiedz, że to samo lub bardzo podobne rozwiązanie jest również najkrótsze w innym języku.

• Ponieważ dane wyjściowe są stałe, możesz zakodować dane wyjściowe na stałe (ale może to nie być najkrótsza opcja).

• Możesz korzystać z istniejących rozwiązań, pod warunkiem uznania oryginalnego autora programu.

• Standardowe luki są w przeciwnym razie niedozwolone.

Na marginesie, proszę nie głosować nudnych (ale ważnych) odpowiedzi w językach, w których nie ma wiele do golfa; są one nadal przydatne w tym pytaniu, ponieważ próbuje skompilować katalog tak kompletny, jak to możliwe. Jednak przede wszystkim oceniaj odpowiedzi w językach, w których autorzy musieli włożyć wysiłek w grę w golfa.

Katalog

var QUESTION_ID=58615;var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk";var OVERRIDE_USER=30525;var answers=[],answers_hash,answer_ids,answer_page=1,more_answers=true,comment_page;function answersUrl(index){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(index,answers){return"https://api.stackexchange.com/2.2/answers/"+answers.join(';')+"/comments?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:true,success:function(data){answers.push.apply(answers,data.items);answers_hash=[];answer_ids=[];data.items.forEach(function(a){a.comments=[];var id=+a.share_link.match(/\d+/);answer_ids.push(id);answers_hash[id]=a});if(!data.has_more)more_answers=false;comment_page=1;getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:true,success:function(data){data.items.forEach(function(c){if(c.owner.user_id===OVERRIDE_USER)answers_hash[c.post_id].comments.push(c)});if(data.has_more)getComments();else if(more_answers)getAnswers();else process()}})}getAnswers();var SCORE_REG=/<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;var OVERRIDE_REG=/^Override\s*header:\s*/i;function getAuthorName(a){return a.owner.display_name}function process(){var valid=[];answers.forEach(function(a){var body=a.body;a.comments.forEach(function(c){if(OVERRIDE_REG.test(c.body))body='<h1>'+c.body.replace(OVERRIDE_REG,'')+'</h1>'});var match=body.match(SCORE_REG);if(match)valid.push({user:getAuthorName(a),size:+match[2],language:match[1],link:a.share_link,});else console.log(body)});valid.sort(function(a,b){var aB=a.size,bB=b.size;return aB-bB});var languages={};var place=1;var lastSize=null;var lastPlace=1;valid.forEach(function(a){if(a.size!=lastSize)lastPlace=place;lastSize=a.size;++place;var answer=jQuery("#answer-template").html();answer=answer.replace("{{PLACE}}",lastPlace+".").replace("{{NAME}}",a.user).replace("{{LANGUAGE}}",a.language).replace("{{SIZE}}",a.size).replace("{{LINK}}",a.link);answer=jQuery(answer);jQuery("#answers").append(answer);var lang=a.language;lang=jQuery('<a>'+lang+'</a>').text();languages[lang]=languages[lang]||{lang:a.language,lang_raw:lang.toLowerCase(),user:a.user,size:a.size,link:a.link}});var langs=[];for(var lang in languages)if(languages.hasOwnProperty(lang))langs.push(languages[lang]);langs.sort(function(a,b){if(a.lang_raw>b.lang_raw)return 1;if(a.lang_raw<b.lang_raw)return-1;return 0});for(var i=0;i<langs.length;++i){var language=jQuery("#language-template").html();var lang=langs[i];language=language.replace("{{LANGUAGE}}",lang.lang).replace("{{NAME}}",lang.user).replace("{{SIZE}}",lang.size).replace("{{LINK}}",lang.link);language=jQuery(language);jQuery("#languages").append(language)}}

body{text-align:left!important}#answer-list{padding:10px;width:290px;float:left}#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table>

Python 2, 56

i=0;exec"print i%3/2*'Fizz'+i%5/4*'Buzz'or-~i;i+=1;"*100

Sześciokąt , 91 bajtów

Dzięki za nagrodę :)

Wow, nigdy bym nie pomyślał, że uda mi się pokonać rozwiązanie sześciokątne Martina . Ale - kto by to pomyślał - załatwiłem sprawę. Po kilku dniach awarii, ponieważ nie miałem ani heksagonu, ani testera EsotericIDE, aby sprawdzić moje rozwiązanie. Pomyliłem kilka aspektów specyfikacji, więc stworzyłem kilka niewłaściwych „rozwiązań”, używając tylko długopisu i papieru oraz edytora tekstu. No cóż, w końcu pokonałem lenistwo i sklonowałem oba repozytoria, pobrałem VisualStudio i skompilowałem je. Wow, jakie to przydatne narzędzia! Jak widać, jestem daleki od bycia kimś, kogo nazwałbyś programistą (to znaczy, daj spokój! Nie miałem nawet zainstalowanego VisualStudio i prawie nie mam pojęcia, jak skompilować program);)

Znalezienie działającego rozwiązania zajęło mi jeszcze trochę czasu i jest dość zatłoczone i chaotyczne, ale tutaj jest w pełnej krasie:

Fizzbuzz w sześciokącie wielkości 6:

3}1"$.!$>)}g4_.{$'))\<$\.\.@\}F\$/;z;u;<%<_>_..$>B/<>}))'%<>{>;e"-</_%;\/{}/>.\;.z;i;..>(('

Układ sześciokątny:

      3 } 1 " $ .
     ! $ > ) } g 4
    _ . { $ ' ) ) \
   < $ \ . \ . @ \ }
  F \ $ / ; z ; u ; <
 % < _ > _ . . $ > B /
  < > } ) ) ' % < > {
   > ; e " - < / _ %
    ; \ / { } / > .
     \ ; . z ; i ;
      . . > ( ( '

I piękne wykonanie, dzięki Hexagony Colorer Timwi :

Oto animacja GIF o długości 110 sekund z szybkością 2 klatek na sekundę, pokazująca przebieg programu podczas pierwszych 6 liczb 1, 2, Fizz, 4, Buzz, Fizz, pierwszych 220 tyknięć programu (kliknij obraz, aby wyświetlić pełny rozmiar):

O mój Boże, dzięki oprogramowaniu do komponowania Natron animacja wskaźnika była wciąż nużąca, ale możliwa do zarządzania. Zapisanie 260 zdjęć pamięci było mniej zabawne. Niestety EsotericIDE nie może tego zrobić automatycznie. Tak czy inaczej, ciesz się animacją!

W końcu po owinięciu głowy wokół modelu pamięci i raczej sprzecznym z intuicją owijaniu ścieżek, które przekraczają granice sześciokąta, nie jest tak trudno pracować z Sześciokątem. Ale gra w golfa może być uciążliwa. ;)

To była zabawa!

Labirynt , 94 bajty

"):_1
\ } 01/3%70.105
" :   @ "     .
"  =";_""..:221
+  _
"! 5%66.117
_:= "     .
="*{"..:221

Sub-100! To było zabawne.

Wyjaśnienie

Zacznijmy od krótkiego podkładu w Labiryncie - możesz go pominąć, jeśli znasz już podstawy:

• Labirynt ma dwa stosy - główny i pomocniczy. Oba stosy mają na dole nieskończoną liczbę zer, np. +Na pustym stosie dodaje dwa zera, w ten sposób wypychając zero.

• O sterowaniu przepływem w Labiryncie decydują skrzyżowania, które spoglądają na górę stosu, aby ustalić, gdzie iść dalej. Negatyw oznacza skręt w lewo, zero oznacza bieg prosto, a dodatni oznacza skręt w prawo ... ale jeśli uderzymy w ścianę, odwrócimy kierunek. Na przykład, jeśli możliwy jest tylko ruch prosto i skręt w lewo, ale górna część stosu jest dodatnia, to skoro nie możemy skręcić w prawo, skręcamy w lewo.

• Cyfry w labiryncie pop xi push 10*x + <digit>, co ułatwia budowanie dużych liczb. Oznacza to jednak, że potrzebujemy instrukcji, aby nacisnąć 0, aby rozpocząć nowy numer, który znajduje się _w Labiryncie.

Przejdźmy teraz do właściwego kodu!

Czerwony

Wykonanie rozpoczyna się od "lewego górnego rogu, który jest NOP. Dalej jest ), która zwiększa górę stosu, przesuwając 1 w pierwszym przejściu i zwiększając nw każdym kolejnym przejściu.

Następnie powielać nz :. Ponieważ njest pozytywna, skręcamy w prawo, wykonując }(przesuwamy górę głównego stosu na pomocniczy) i :. Uderzamy w ślepy zaułek, więc odwracamy się, wykonujemy }i :jeszcze raz, pozostawiając stosy jak

Main [ n n | n n ] Aux

Po raz kolejny njest pozytywny i skręcamy w prawo, wykonując, _101/który dzieli nprzez 101. Jeśli njest to 101, to n/101 = 1skręcamy w @, który kończy program. W przeciwnym razie nasza obecna sytuacja to

Main [ n 0 | n n ] Aux

Orange 1 (mod 3)

3zamienia górne zero na 3 ( 10*0 + 3 = 3) i %wykonuje modulo. Jeśli n%3jest pozytywny, skręcamy w prawo w żółty ". W przeciwnym razie wykonujemy 70.105.122:.., które wyjścia Fizz. Zauważ, że nie musimy naciskać nowych zer, _ponieważ n%3w tym przypadku było zero, więc możemy wykorzystać nieskończone zera na dole stosu. Obie ścieżki spotykają się ponownie w kolorze jasnoniebieskim.

Jasny niebieski

Górna część stosu jest obecnie n%3, co może być dodatnie, więc _;popycha zero i natychmiast je wyskakuje, aby upewnić się, że idziemy prosto, zamiast skręcać w @. Następnie używamy =do zamiany górnych stosów głównych i pomocniczych, dając:

Main [ n | n%3 n ] Aux

Orange 2 (mod 5)

Jest to sytuacja podobna do poprzedniej, z tym wyjątkiem, że 66.117.122:..wyprowadza, Buzzjeśli n%5wynosi zero.

Ciemny niebieski

Poprzednia sekcja pozostawia stosy jak

Main [ n%5 | n%3 n ] Aux

{przesuwa się z n%3powrotem do głównego stosu i *mnoży dwa moduły.

Jeśli któryś z modułów jest równy zero, iloczyn wynosi zero, więc przechodzimy prosto w żółty. =zamienia wierzch stosów i _przesuwa zero, aby upewnić się, że idziemy prosto, dając

Main [ n 0 | 0 ] Aux

W przeciwnym razie, jeśli oba moduły są niezerowe, to produkt jest niezerowy i zmieniamy kolor na zielony. =zamienia szczyty stosów, dając

Main [ n | (n%5)*(n%3) ] Aux

po czym używamy :do powielania n, skręcamy w prawo, a następnie używamy !do wyjścia n.

Purpurowy

W tym momencie główny stos zawiera jeden lub dwa przedmioty, w zależności od wybranej ścieżki. Musimy pozbyć się zera z żółtej ścieżki, a do tego używamy +, co n + 0w obu przypadkach działa w określonej kolejności. W końcu \wypisuje nowy wiersz i wracamy do początku.

Każda iteracja przesuwa dodatkową wartość (n%5)*(n%3)na stos pomocniczy, ale w przeciwnym razie robimy to samo od nowa.

Perl 5, 49 bajtów

46 bajtów skryptu + 3 bajty -E"..."

Użycie say(co wymaga -E"...") może zmniejszyć to do 46 bajtów, ponieważ sayautomatycznie zawiera nowy wiersz (Dzięki @Dennis !):

say'Fizz'x!($_%3).Buzz x!($_%5)||$_ for 1..100

Perl 5, 50 bajtów

print'Fizz'x!($_%3).Buzz x!($_%5)||$_,$/for 1..100

Rubinowy, 50 bajtów

Wymaga wersji 1.8, która wydaje się być popularna wśród golfistów:

1.upto(?d){|n|puts'FizzBuzz
'[i=n**4%-15,i+13]||n}

We współczesnym języku Ruby, wymienić ?dz 100rozwiązania 51-bajtowy.

To wydaje się być rekordem świata.

Java, 130 bajtów

Dotyczy to najnowszych wersji Java (7+). W starszych możesz trochę się ogolić za pomocą tej enumsztuczki, ale nie sądzę, żeby logika stała się krótsza (86 w środku main).

class F{public static void main(String[]a){for(int i=0;i++<100;)System.out.println((i%3<1?"Fizz":"")+(i%5<1?"Buzz":i%3<1?"":i));}}

Pyth, 30

VS100|+*!%N3"Fizz"*!%N5"Buzz"N

Wypróbuj tutaj

Wyjaśnienie:

VS100|+*!%N3"Fizz"*!%N5"Buzz"N
VS100                            : for N in range(1,101)
     |                           : logical short-circuiting or
      +*!%N3"Fizz"               : add "Fizz" * not(N % 3)
                                 : Since not gives True/False this is either "" or "Fizz"
                  *!%N5"Buzz"    : Same but with 5 and Buzz
                             N   : Otherwise N
                                 : The output of the | is implicitly printed with a newline

Retina , 317 139 134 132 70 63 60 55 bajtów

.100{`^
_
*\(a`(___)+
Fi;$&
\b(_{5})+$
Bu;
;_*
zz
'_&`.

Wypróbuj online!

Wyjaśnienie

.100{`^
_

Jest .to globalna cicha flaga, która wyłącza niejawne dane wyjściowe na końcu programu. 100{opakowuje resztę programu w pętlę, która jest wykonywana dla 100 iteracji. Na koniec sam etap wstawia tylko _na początku łańcucha, co skutecznie zwiększa jednostronny licznik pętli.

*\(a`(___)+
Fi;$&

Więcej konfiguracji. *\(opakowuje pozostałą część programu w grupę, drukuje wynik końcowym przesuwem linii, ale także umieszcza całą grupę w suchym biegu, co oznacza, że ​​jego wynik zostanie odrzucony po wydrukowaniu, dzięki czemu nasz licznik pętli nie zostanie faktycznie zmodyfikowany . ajest niestandardowym modyfikatorem wyrażenia regularnego, który zakotwicza wyrażenie regularne w całym ciągu znaków (co oszczędza bajt przy użyciu ^i $jawnie).

Zajmuje się sam etap atomowy Fizz. Podzielność według 3można łatwo sprawdzić jednostronnie: wystarczy sprawdzić, czy liczbę można zapisać jako powtórzenie ___. W takim przypadku poprzedzamy Fi;ciąg. Średnik jest taki, że przed liczbą nadal znajduje się granica słowa przed liczbą. Gdybyśmy zmienili linię na Fizz___...pozycję pomiędzy zi _nie bylibyśmy uważani za granicę, ponieważ regex traktuje zarówno litery, jak i podkreślenia jako znaki słowne. Jednak średnik pozwala także usunąć zzpowielania z Fizzi Buzz.

\b(_{5})+$
Bu;

Robimy dokładnie to samo, jeśli chodzi o podzielność przez 5i Bu;, chociaż nie musimy _tym razem utrzymywać wartości s. Więc uzyskalibyśmy wyniki takie jak

_
__
Fi;___
____
Bu;
Fi;______
...
Fi;Bu;
...

To sprawia, że ​​bardzo łatwo jest usunąć podkreślenia tylko w tych wierszach, które zawierają Fizz, jednocześnie wypełniając zzs:

;_*
zz

Oznacza to, że przekształcamy każdy średnik w, zzale _zaraz po nim konsumujemy wszystkie . W tym momencie skończyliśmy z FizzBuzz w jednym. Ale wyzwanie wymaga wyniku dziesiętnego.

'_&`.

&wskazuje warunek: ten etap jest wykonywany tylko wtedy, gdy ciąg zawiera znak podkreślenia. W związku z tym Fizz, Buzzi FizzBuzziteracje pozostają nietknięte. We wszystkich innych iteracjach (tj. Tych, których nie można podzielić przez 3 ani 5), po prostu liczymy liczbę znaków, konwertując wynik na dziesiętny.

gs2 , 1

f

Cytat z Mauris, twórca GS2:

Chciałem jednego-up goruby „s 1-bajtowego Hello, world!, więc ... to wydruki "1\n2\nFizz\n4\nBuzz\n...". :)

Aktualizacja : Dodano 27-bajtową odpowiedź , która nie jest używana f.

Perl 5, 45 bajtów

say((Fizz)[$_%3].(Buzz)[$_%5]or$_)for+1..100

Wymaga -Eopcji, liczonej jako jedna. Należy to uruchomić z wiersza poleceń, tj .:

perl -Esay((Fizz)[$_%3].(Buzz)[$_%5]or$_)for+1..100

Cytaty z całego polecenia są zbędne, jeśli ktoś unika za pomocą spacji, ani innych znaków, które mogą działać jako separatory wiersza poleceń ( |, <, >, &, itd.).

Perl 5, 48 bajtów

print+(Fizz)[$_%3].(Buzz)[$_%5]||$_,$/for 1..100

Jeśli opcje wiersza poleceń są liczone jako jeden, każdy -lzapisuje jeden bajt (przez zastąpienie $/). Jednak według klasycznych zasad Perlgolfa liczy się to 3: jeden za -, jeden za li jeden za niezbędną przestrzeń.

wosk pszczeli ,104 89 81 bajtów

Gęstsze pakowanie pozwoliło na odcięcie 8 kolejnych bajtów.

Najkrótsze rozwiązanie (81 bajtów), ten sam przebieg programu, różne pakowanie.

p?@<
p?{@b'gA<
p@`zzuB`d'%~5F@<f`z`<
 >~P"#"_"1F3~%'d`Fiz`b
 d;"-~@~.<
>?N@9P~0+d

Zmiana koncepcji pozwoliła mi zmniejszyć kod o 15 bajtów. Chciałem pozbyć się testu podwójnego mod 5 w rozwiązaniu, więc zaimplementowałem flagę.

Krótkie wyjaśnienie:

jeśli n%3=0Fizz zostanie wydrukowany, a flaga ustawiona. Flaga jest realizowana po prostu przez wypchnięcie najwyższej wartości lstack na gstack (instrukcja f).

Jeśli n%5=0, to albo n%3=0(przypadek FizzBuzz) albo n%3>0(przypadek Buzz). W obu przypadkach Buzz zostaje wydrukowany, a flaga resetuje się, przesuwając stos, aż będzie pusty (instrukcja ?).

Teraz interesujące przypadki:

Jeśli n%5>0, to albo mieliśmy n%3=0(drukowanie skrzynki Fizz, n nie może być wydrukowane) lub n%3>0(Fizz nie został wydrukowany, więc n należy wydrukować). Czas sprawdzić flagę. Uzyskuje się to poprzez przesunięcie długości gstacka na gstack (instrukcja A). Jeśli n%3 was 0wtedy długość gstack wynosi> 0. Jeśli n%3 was >0długość gstacka wynosi 0. Prosty skok warunkowy gwarantuje, że n zostanie wydrukowane tylko wtedy, gdy długość gstacka wynosiła 0.

Ponownie, po wydrukowaniu dowolnego z n, Fizz i / lub Buzz i nowej linii, gstack jest dwukrotnie otwierany, aby upewnić się, że jest pusty. gstack jest albo pusty [], co prowadzi do [0]instrukcji po A(wypchnięcie długości gstacka na gstack), albo zawiera jedno zero ( [0]wynik n% 3), co prowadzi do [0 1], ponieważ [0] ma długość 1. Wyskakiwanie z pusty stos nie zmienia stosu, więc można bezpiecznie pop dwukrotnie.

Jeśli przyjrzysz się bliżej, zobaczysz, że w zasadzie spasowałem

>      q
d`Fizz`f>

w

<f`z`<
d`Fiz`b

co pomaga pozbyć się całej zmarnowanej przestrzeni pomiędzy Ai <na końcu następnego rzędu w starszym rozwiązaniu poniżej:

q?{@b'gA<       p      <

Nowe rozwiązanie koncepcyjne (89 bajtów), w tym animowane objaśnienie:

q?@ <
 q?{@b'gA<       p      <
p?<@`zzuB`b'%~5F@<f`zziF`b'<
>N@9P~0+.~@~-";~P"#"_"1F3~%d

Układ sześciokątny:

   q ? @   <
    q ? { @ b ' g A <               p             <
 p ? < @ ` z z u B ` b ' % ~ 5 F @ < f ` z z i F ` b ' <
> N @ 9 P ~ 0 + . ~ @ ~ - " ; ~ P " # " _ " 1 F 3 ~ % d

Animacja pierwszych 326 tyknięć przy 2 fps, z lokalnymi i globalnymi stosami i wysyłana do STDOUT.

Dla porównania poniżej znajdują się nakładki ścieżkowe starszego, bardziej złożonego rozwiązania. Może to również ładniejsze rozwiązanie, z wizualnego punktu widzenia;)

> <> , 68 66 65 64 bajtów

1\2+2foooo "Buzz"<
o>:::3%:?!\$5%:?!/*?n1+:aa*)?;a
o.!o"Fizz"/oo

Jedyną sztuczką jest pomnożenie reszty jako warunku drukowania liczb. W ten sposób, jeśli jeden z nich ma wartość 0, nie wydrukujemy numeru.

Możesz spróbować tutaj .

Zapisano jeden bajt dzięki Sp3000, a drugi dzięki randomra. Wielkie dzięki!

gs2 , 28 27 (bez f)

Klątwa:

1b 2f fe cc 04 46 69 7a 7a 09 07 42 75 7a 7a 19 06 27 2d d8 62 32 ec 99 dc 61 0a

Wyjaśnienie:

1b    100
2f    range1 (1..n)
fe    m: (map rest of program)

cc    put0 (pop and store in register 0)
04    string-begin
Fizz
09    9
07    string-separator
Buzz
19    25
06    string-end-array (result: ["Fizz"+chr(9) "Buzz"+chr(25)])

27    right-uncons
2d    sqrt
d8    tuck0 (insert value of register 0 under top of stack)
62    divides
32    times (string multiplication)
ec    m5 (create block from previous 5 tokens, then call map)

99    flatten
dc    show0 (convert register 0 to string and push it)
61    logical-or
0a    newline

Osadzanie 3 i 5 w stałej łańcucha nie działa, ponieważ \x05kończy literały łańcucha.

Uwaga: Ten problem można rozwiązać za pomocą wbudowanego gs2 w 1 bajcief .

C, 85 bajtów

i;main(){for(;i++<=99;printf("%s%s%.d\n",i%3?"":"Fizz",i%5?"":"Buzz",(i%3&&i%5)*i));}

-2 dzięki wrażliwym.

CJam, 35 bajtów

100{)_[Z5]f%:!"FizzBuzz"4/.*s\e|N}/

Wypróbuj online w interpretatorze CJam .

Jak to działa

100{)_[Z5]f%:!"FizzBuzz"4/.*s\e|N}/
100{                             }/  For each integer I between 0 and 99:
    )_                                 Increment I and push a copy.
      [Z5]                             Push [3 5].
          f%                           Map % to push [(I+1)%3 (I+1)%5].
            :!                         Apply logical NOT to each remainder.
              "FizzBuzz"4/             Push ["Fizz" "Buzz"].
                          .*           Vectorized string repetition.
                            s\         Flatten the result and swap it with I+1.
                              e|       Logical OR; if `s' pushed an empty string,
                                       replace it with I+1.
                                N      Push a linefeed.

MUMPS, 56 54 bajtów

f i=1:1:100 w:i#5=0 "Fizz" w:i#3=0 "Buzz" w:$X<3 i w !

O co w:$X<3 ichodzi, pytasz? $Xjest magiczną zmienną („wewnętrzną”), która przechowuje poziomą pozycję kursora wyjściowego (jako liczbę znaków od lewej krawędzi terminala). wto skrócona forma WRITEpolecenia. Składnia command:condition argsjest warunkowa - „jeśli condition, to zrób command args”.

Więc jesteśmy sprawdzeniu, czy kursor wyjściowa została przesunięta więcej niż dwa znaki (co oznaczałoby, że co najmniej jedna "Fizz"lub "Buzz"został napisany do terminala), a jeśli nie, pisząc ido terminalu. $XZmienna - i stąd ten rodzaj głębokiego nierozłączności z terminala - to funkcja pierwszej klasy świnki. Yikes.

Galaretka , 24 20 bajtów

³µ3,5ḍTị“¡Ṭ4“Ụp»ȯµ€G

Wypróbuj online!

Jak to działa

³µ3,5ḍTị“¡Ṭ4“Ụp»ȯµ€G  Main link. No input.

³                     Yield 100.
 µ                    Begin a new, monadic chain.
                 µ€   Apply the preceding chain to all integers n in [1, ..., 100].
  3,5ḍ                Test n for divisibility by 3 and 5.
      T               Get all truthy indices.
                      This yields [1] (mult. of 3, not 5), [2] (mult. of 5, not 3),
                      [1, 2] (mult. of 15) or [].
        “¡Ṭ4“Ụp»      Yield ['Fizz', 'Buzz'] by indexing in a dictionary.
       ị              Retrieve the strings at the corr. indices.
                ȯ     Logical OR hook; replace an empty list with n.
                   G  Grid; join the list, separating by linefeeds.

pieprzenie mózgu, 206 bajtów

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

Sformatowany:

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

Wypróbuj online

Układ pamięci to

0 a 122 105 70 b f 0 t d1 s d2 c d 10 0

gdzie fcykle po 3, bcykle po 5, d1to cyfra jedności, d2to dziesiątka cyfry, sto flaga określająca, czy drukować dziesiątka cyfra, dcykle po 10, cto miejsce kopiowania d, tto przestrzeń robocza, która zawiera 0 lub niepotrzebne dane, lub flaga oznaczająca brak -divisible-by-3, i aokreśla zakończenie programu przez przesunięcie wskaźnika po wydrukowaniu Buzz 20 razy.

C #, 128 126 125 124 bajtów

class A{static void Main(){for(var i=0;i++<100;)System.Console.Write("{0:#}{1:;;Fizz}{2:;;Buzz}\n",i%3*i%5>0?i:0,i%3,i%5);}}

89 bajtów bez kodu tablicy kontrolnej.

Wykonano przy użyciu formatowania warunkowego C # .

Przy dwóch separatorach sekcji ;Fizz lub Buzz są drukowane, jeśli ich wartość wynosi zero.

Zaoszczędź w sumie 4 bajty dzięki @RubberDuck, @Timwi i @Riokmij.

Clojure, 113 106 101 100 91 bajtów

Mój pierwszy golf!

(dotimes[i 100](println(str({2'Fizz}(mod i 3))({4'Buzz}(mod i 5)({2""}(mod i 3)(inc i))))))

Nie golfowany:

(dotimes [i 100] ; account for off-by-one later
  (println (str ({2 'Fizz} ; str converts symbols to strings
                 (mod i 3))
                ({4 'Buzz} ; 4 instead of 0 because of off-by-one
                 (mod i 5)
                 ({2 ""} ; shortest way to write when-not
                  (mod i 3)
                  (inc i))))))

pieprzenie mózgu , 411 350 277 258 bajtów

Edycje:

• -61 bajtów, przechowując wartości „Fizz Buzz” jako „BuziF” „BuziG” i powtarzając sekcję drukowania liczb.

• -71 bajtów poprzez ponowne wykonanie sekcji drukowania liczb modulo, podział licznika pętli i licznika oraz ponowne użycie komórki nowej linii jako wartości mod, między innymi

• -19 bajtów, wiedząc, że nie ma żadnych zer w żadnym numerze FizzBuzz. Dodano także wyjaśnienie

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

Wypróbuj online!

Zamiast sprawdzać, czy sama liczba jest podzielna przez 5 lub 3, miałem dwa liczniki śledzące moduł liczby, zmniejszające je dla każdej liczby i drukujące odpowiednie słowo, gdy osiągnęły 0.

Jak to działa:

+[-[>+<<]>-]>--  Generate the number 61
[>+>++>++>++++++>+>>>++++++[<<<]>-] Set the tape to multiples of 61
TAPE: 0 0' 61  122 122 110 61  0 0 110
           "=" "z" "z" "n" "="
<+++++[>+>+>->>->++>>>-->>>++[<<<]>>>-]>[>]+++>> Modify values by multiples of 5
TAPE: 0' 5 66  117 122 105 71  3 0 100' 0 0 10
           "B" "u" "z" "i" "G"
Some info:
  5     - Buzz counter
  "Buz" - Buzz printing
  "ziG" - Fizz printing. Modifying the G in the loop is shorter than modifying it outside
  3     - Fizz counter
  0     - This is where the Fizz|Buzz check will be located
  100   - Loop counter
  0     - Number counter. It's not worth it to reuse the loop counter as this.
  0     - Sometimes a zero is just a zero
  10    - Value as a newline and to mod the number by

[ Loop 100 times
  >+<<<  Increment number counter
  -[<]<  Decrement Fizz counter
  [ If Fizz counter is 0
    >+++ Reset the Fizz counter to 3
    >+<< Set the Fizz|Buzz check to true
    -.+<.<.. Print "Fizz"
  [<]<] Sync pointers
  >>-[<<]> Decrement Buzz counter
  [ If Buzz counter is 0
    .>.>.. Print "Buzz"
    >>>>+  Set the Fizz|Buzz check to true
    [<]+++++< Reset the Buzz counter to 5
  ]
  >[>]>> Go to Fizz|Buzz check
  [ If there was no Fizz or Buzz for this number
    TAPE: 3% BuziG 5% 0 Loop Num' 0 10
    [->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]  Mod the number counter by 10
    TAPE: 3% BuziG 5% 0 Loop 0' Num 10-Num%10 Num%10 Num/10
    >[-<+>] Move Num back in place
    >,>[>]< Reset 10-Num%10
    [ For both Num/10 (if it exists) and Num%10
      >-[<+>-----]<--- Add 48 to the number to turn it into the ASCII equivilent
      .,< Print and remove
    ]
    ++++++++++> Add the 10 back
  ]
  <. Print the newline
  <<<<, Remove Fizz|Buzz check
  >- Decrement Loop counter
]

PowerShell, 78 68 61 54 bajtów

1..100|%{(($t="Fizz"*!($_%3)+"Buzz"*!($_%5)),$_)[!$t]}

_{Edycja: Zapisane 10 bajtów dzięki feersum}

_{Edit2: Zrozumiałem, że dzięki sztuczce feersum nie muszę już formułować $ t jako ciągu bloków kodu}

_{Edycja3: Zaoszczędź kolejne 7 bajtów dzięki Danko Durbićowi}

Podobny w duchu do standardowej odpowiedzi Kod Rosetta , ale trochę pograł w golfa.

Wyjaśnienie

1..100|%{...} Utwórz kolekcję od 1 do 100, a następnie dla każdego obiektu w tej kolekcji

(...,$_)utwórz nową kolekcję dwóch elementów: 0) $t=...ustaw zmienną $trówną łańcuchowi; 1) $_nasz bieżący numer pętli

"Fizz"*!($_%3)weź nasz aktualny numer, zmodyfikuj go o 3, a następnie NIE wynik. Pomnóż przez to „Fizz” i dodaj go do ciągu (i podobnie dla 5). Program PowerShell traktuje dowolną niezerową liczbę jako $TRUE, a zatem NIE dla niezerowej liczby wynosi 0, co oznacza, że ​​tylko jeśli nasza bieżąca liczba jest wielokrotnością 3, „Fizz” zostanie dodany do łańcucha.

[!$t]indeksuje do właśnie utworzonej kolekcji na podstawie wartości ciągu $t- niepuste, wydrukuj go, w przeciwnym razie wydrukuj nasz aktualny numer

Alternatywnie również 54 bajty

1..100|%{'Fizz'*!($_%3)+'Buzz'*!($_%5)-replace'^$',$_}

_{Dzięki TesselatingHeckler}

Podobna koncepcja używa -replaceoperatora inline i wyrażenia regularnego do zamiany pustego ciągu na ^$nasz aktualny numer. Jeśli ciąg nie jest pusty, nie jest zamieniany.

Alternatywnie również 54 bajty

1..100|%{($_,('Fizz'*!($_%3)+'Buzz'*!($_%5))|sort)[1]}

Jest to ta sama struktura pętli jak powyżej, ale wewnątrz niej sortuje parę (n, ciąg) i opiera się na fakcie, że pusty ciąg sortuje przed liczbą, ale ciąg FizzBuzz sortuje po liczbie. Następnie indeksuje wynik drugiego sortowania.

JavaScript, 62 bajty

for(i=0;++i<101;console.log(i%5?f||i:f+'Buzz'))f=i%3?'':'Fizz'

Myślę, że teraz jest to najkrótsze rozwiązanie Javascript.

C, 74 bajty

main(i){for(;i<101;puts(i++%5?"":"Buzz"))printf(i%3?i%5?"%d":0:"Fizz",i);}

0Argument printfzamiast ""jest podejrzany, ale wydaje się działać na większości platform próbuję go włączyć. putssegfaults, gdy próbujesz tego samego. Bez niego otrzymujesz 75 bajtów.

Istnieją 73-bajtowe rozwiązania, które działają na anarchii golfa , i znalazłem jeden, który szuka w odpowiednich miejscach w Internecie, ale polegają one na zachowaniu specyficznym dla platformy. (Jak można się domyślić, jest to coś w rodzaju puts("Buzz"±...).)

Scratch, 203 185 bajtów

Liczba bajtów liczona od golfowej reprezentacji tekstowej według tego meta postu . Scratch nie zajmuje dużo miejsca.

sayScratch jest najbardziej zbliżony do standardowego: duszek wyświetla dymek zawierający to, co mówi. W praktyce wait n secsdo odczytania tego wyniku potrzebny byłby blok, ale do celów tego wyzwania kod ten spełnia wymagania.

R, 88 83 77 71 70 bajtów

Jestem pewien, że można to poprawić ... i to dzięki kredytowi @flodel. Kolejne kilka bajtów zaoszczędzonych dzięki sugestii @njnnja i kolejnej @ J.Doe

x=y=1:100;y[3*x]='Fizz';y[5*x]='Buzz';y[15*x]='FizzBuzz';write(y[x],1)

Haskell, 84 bajty

main=mapM f[1..100]
f n|d<-drop.(*4).mod n=putStrLn$max(show n)$d 3"Fizz"++d 5"Buzz"

Zbliżają się do henkma za 81 bajtów , ale nie całkiem tam jeszcze.

d = drop.(*4).mod njest kluczem tutaj: d 3 "Fizz"jest drop (n`mod`3 * 4) "Fizz". To jest, "Fizz"gdy n `mod` 3wynosi 0 i ""inaczej.

PHP, 54 bajty

<?for(;$i++<100;)echo[Fizz][$i%3].[Buzz][$i%5]?:$i,~õ;

Obowiązuje od wersji 5.5. Jest õto znak 245, nieco odwrócony \n.

Zakładam domyślne ustawienia interpretera, ponieważ są one bez ini. Jeśli nie masz pewności, możesz wyłączyć lokalne ini za pomocą -njak w php -n fizzbuzz.php.

Wersja, która będzie działać bezbłędnie z absolutnie dowolnym plikiem konfiguracyjnym, ma 62 bajty :

<?php
for(;$i++<100;)echo@([Fizz][$i%3].[Buzz][$i%5]?:$i),"
";

Kod maszynowy 80386 + DOS, 75 bajtów

Hexdump kodu:

0D 0A 24 B1 64 33 C0 BA-03 05 BB 00 01 40 50 FE
CE 75 0C 83 EB 04 66 C7-07 42 75 7A 7A B6 05 FE
CA 75 0C 83 EB 04 66 C7-07 46 69 7A 7A B2 03 84
FF 74 0C D4 0A 04 30 4B-88 07 C1 E8 08 75 F4 52
8B D3 B4 09 CD 21 5A 58-E2 C0 C3

Kod źródłowy (składnia TASM):

    .MODEL TINY

    .CODE
    .386
    org 100h

MAIN PROC
    db 13, 10, '$'
    mov cl, 100
    xor ax, ax
    mov dx, 503h

main_loop:
    mov bx, 100h
    inc ax
    push ax

    dec dh
    jnz short buzz_done
    sub bx, 4
    mov dword ptr [bx], 'zzuB'
    mov dh, 5
buzz_done:

    dec dl
    jnz short fizz_done
    sub bx, 4
    mov dword ptr [bx], 'zziF'
    mov dl, 3
fizz_done:

    test bh, bh
    jz short num_done

decimal_loop:
    aam;
    add al, '0'
    dec bx
    mov [bx], al
    shr ax, 8
    jnz decimal_loop

num_done:
    push dx
    mov dx, bx;
    mov ah, 9
    int 21h
    pop dx
    pop ax

    loop main_loop
    ret

MAIN ENDP
    END MAIN

Ten kod liczy od 1 do 100 cali ax, budując komunikat wyjściowy od końca do początku. Koniec wiadomości (nowa linia i $znak, którego DOS używa do flagi końca wiadomości) pojawia się na początku kodu:

db 10, 10, '$'

Jest wykonywany jako nieszkodliwa instrukcja ( or ax, 240ah). Mógłbym umieścić go w bardziej konwencjonalnym miejscu, na przykład po zakończeniu kodu, ale posiadanie go pod adresem 0x100 ma tę zaletę.

Kod wykorzystuje również 2 dodatkowe liczniki:

• Licząc od 3 do 0 cali dl
• Licząc od 5 do 0 cali dh

Kiedy licznik osiągnie 0, wypycha ciąg Fizzlub Buzzdo końca komunikatu wyjściowego. Jeśli tak się stanie, bxzostanie zmniejszona i bhwyniesie zero. Jest to używane jako warunek wyprowadzenia liczby w postaci dziesiętnej.

Uwaga: używam tutaj danych 32-bitowych. To nie zadziała na komputerze wcześniejszym niż 386.

dc 64 62 bajty

[[Fizz]P]sI[[Buzz]P]sU[dn]sNz[zdd3%d0=Ir5%d0=U*0<NAPz9B>L]dsLx

Nie golfowany:

[[Fizz]P]sI  # macro I: print "Fizz"
[[Buzz]P]sU  # macro U: print "Buzz"
[dn]sN       # macro N: print current stack depth

z            # increase stack depth

[            # Begin macro
  zdd           # Get current stack depth and ducplicate it twice
  3%d0=I        # Check modulo 3 and leave a duplicate. If it's 0, run macro I
  r             # Rotate top two elements, bringing up the stack depth again
  5%d0=U        # Check modulo 5 and leave a duplicate. It it's 0, run macro U
  *             # Multiply the duplicates of modulos of 3 and 5 ...
  0<N           # ... if it's not 0, run macro N
  AP            # Print a newline (`A` is 10)
                # The macro leaves the stack with one more element each time
  z9B>L      # Run macro L if stack depth is less than "ninety eleven" (101)
]         # End macro

dsLx  # store the macro in register L and execute it