Introducción

En nuestro reciente esfuerzo por recopilar catálogos de las soluciones más cortas para ejercicios de programación estándar, este es el primer desafío FizzBuzz de vainilla de PPCG. Si desea ver otros desafíos del catálogo, hay "¡Hola mundo!" y "¿Es este número un primo?" .

Desafío

Escriba un programa que imprima los números decimales del 1 al 100 inclusive. Pero para los múltiplos de tres imprime "Fizz" en lugar del número y para los múltiplos de cinco imprime "Buzz". Para números que son múltiplos de tres y cinco, imprima "FizzBuzz".

Salida

La salida será una lista de números (y Fizzes, Buzzes y FizzBuzzes) separados por una nueva línea (ya sea \no \r\n). Una nueva línea final es aceptable, pero una nueva línea principal no lo es. Además de su elección de nueva línea, la salida debería verse exactamente así:

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

La única excepción a esta regla es la salida constante del intérprete de su idioma que no se puede suprimir, como un saludo, códigos de color ANSI o sangría.

Reglas adicionales

• No se trata de encontrar el idioma con el enfoque más corto para jugar FizzBuzz, se trata de encontrar el enfoque más corto en cada idioma. Por lo tanto, ninguna respuesta se marcará como aceptada.

• Las presentaciones se puntúan en bytes en una codificación preexistente apropiada, generalmente (pero no necesariamente) UTF-8. Algunos idiomas, como las carpetas, son un poco difíciles de puntuar; si tiene dudas, pregunte por Meta.

• No se puede imprimir nada en STDERR.

• A diferencia de nuestras reglas habituales, siéntase libre de usar un idioma (o versión de idioma) incluso si es más nuevo que este desafío. Si alguien quiere abusar de esto creando un lenguaje en el que el programa vacío genere la salida de FizzBuzz, felicidades por allanar el camino para una respuesta muy aburrida.

  Tenga en cuenta que debe haber un intérprete para que se pueda probar el envío. Se permite (e incluso se recomienda) escribir este intérprete usted mismo para un idioma previamente no implementado.

• Si su idioma de elección es una variante trivial de otro lenguaje (potencialmente más popular) que ya tiene una respuesta (piense en dialectos BASIC o SQL, shells Unix o derivados triviales de Brainfuck como Alphuck y ???), considere agregar una nota al existente responda que la misma solución o una muy similar también es la más corta en el otro idioma.

• Debido a que la salida es fija, puede codificar la salida (pero esta puede no ser la opción más corta).

• Puede usar soluciones preexistentes, siempre y cuando acredite al autor original del programa.

• Las lagunas estándar no están permitidas.

Como nota al margen, no desestime las respuestas aburridas (pero válidas) en idiomas donde no hay mucho para jugar golf; todavía son útiles para esta pregunta, ya que trata de compilar un catálogo lo más completo posible. Sin embargo, vota principalmente sobre las respuestas en idiomas en los que los autores realmente tuvieron que esforzarse para jugar golf en el código.

Catálogo

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>

Pitón 2, 56

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

Hexagonía , 91 bytes.

Gracias por la generosidad :)

Wow, nunca hubiera imaginado que podría vencer a la solución Hexagony de Martin . Pero, quién lo habría pensado, lo logré. Después de varios días de fracaso porque no tenía el coloreador Hexagony ni el EsotericIDE para verificar mi solución. Me equivoqué en varios aspectos de la especificación, así que produje algunas "soluciones" incorrectas simplemente usando lápiz y papel y un editor de texto. Bueno, finalmente superé mi pereza y cloné ambos repositorios, descargué VisualStudio y los compilé. ¡Guau, qué herramientas útiles son! Como puede ver, estoy lejos de ser alguien a quien llamaría un programador (quiero decir, ¡vamos! Ni siquiera tenía instalado VisualStudio, y no tengo ni idea de cómo compilar un programa);)

Todavía me tomó un tiempo encontrar una solución que funcione, y es bastante abarrotado y caótico, pero aquí está en todo su esplendor:

Fizzbuzz en un hexágono de tamaño 6:

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

Diseño hexagonal:

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

Y la hermosa interpretación, gracias al Coloreador de Hexagonía de Timwi :

Entonces, aquí hay una animación GIF de 110 segundos de duración a 2 fps, que muestra el flujo del programa durante los primeros 6 números 1, 2, Fizz, 4, Buzz, Fizz, los primeros 220 tics del programa (haga clic en la imagen para verla a tamaño completo):

Dios mío, gracias al software de composición Natron, la animación del puntero aún era tediosa de crear, pero manejable. Guardar 260 imágenes de la memoria fue menos divertido. Lamentablemente, EsotericIDE no puede hacer eso automáticamente. De todos modos, ¡disfruta de la animación!

Después de todo, una vez que comprende el modelo de memoria y la envoltura bastante intuitiva de los caminos que cruzan los bordes del hexágono, no es tan difícil trabajar con la Hexagonía. Pero jugar al golf puede ser un dolor de cabeza. ;)

¡Fue divertido!

Laberinto , 94 bytes

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

Sub-100! Esto fue divertido.

Explicación

Comencemos con una breve introducción sobre Labyrinth: siéntase libre de omitir esto si ya está familiarizado con los conceptos básicos:

• Labyrinth tiene dos pilas: una pila principal y una pila auxiliar. Ambas pilas tienen un número infinito de ceros en la parte inferior, por ejemplo, +en una pila vacía se agregan dos ceros, empujando así a cero.

• El flujo de control en Labyrinth se decide por las uniones, que miran en la parte superior de la pila para determinar a dónde ir después. Negativo significa girar a la izquierda, cero significa seguir recto y positivo significa girar a la derecha ... pero si golpeamos una pared, invertimos la dirección. Por ejemplo, si solo es posible hacia adelante y girar a la izquierda, pero la parte superior de la pila es positiva, entonces, como no podemos girar a la derecha, giramos a la izquierda.

• Los dígitos en Labyrinth aparecen xy empujan 10*x + <digit>, lo que facilita la acumulación de grandes números. Sin embargo, esto significa que necesitamos una instrucción para presionar 0 para comenzar un nuevo número, que está _en Labyrinth.

¡Ahora vamos al código real!

rojo

La ejecución comienza "en la esquina superior izquierda, que es un NOP. El siguiente es ), que incrementa la parte superior de la pila, empujando 1 en la primera pasada e incrementando nen cada pasada siguiente.

Luego duplicamos ncon :. Como nes positivo, giramos a la derecha, ejecutándonos }(desplazamos la parte superior de la pila principal a auxiliar) y :. Llegamos a un callejón sin salida, así que nos damos la vuelta y ejecutamos }y :una vez más, dejando las pilas como

Main [ n n | n n ] Aux

Una vez más, nes positivo y giramos a la derecha, ejecutando _101/cuál se divide npor 101. Si nes 101, entonces n/101 = 1nos convertimos en @, que termina el programa. De lo contrario, nuestra situación actual es

Main [ n 0 | n n ] Aux

Naranja 1 (mod 3)

3convierte el cero superior en un 3 ( 10*0 + 3 = 3) y %realiza un módulo. Si n%3es positivo, giramos a la derecha hacia el amarillo ". De lo contrario, realizamos 70.105.122:.., que salidas Fizz. Tenga en cuenta que no necesitamos empujar nuevos ceros _ya que n%3era cero en este caso, por lo que podemos explotar los ceros infinitos en la parte inferior de la pila. Ambos caminos se encuentran nuevamente en azul claro.

Azul claro

La parte superior de la pila está actualmente n%3, lo que podría ser positivo, por lo que _;simplemente empuja un cero e inmediatamente lo hace estallar para asegurarse de que seguimos adelante, en lugar de girar hacia el @. Luego usamos =para intercambiar la parte superior de las pilas principales y auxiliares, dando:

Main [ n | n%3 n ] Aux

Naranja 2 (mod 5)

Esta es una situación similar a la anterior, excepto que 66.117.122:..genera Buzzsi n%5es cero.

Azul oscuro

La sección anterior deja las pilas como

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

{desplaza la n%3espalda a la pila principal y *multiplica los dos módulos.

Si cualquiera de los módulos es cero, el producto es cero, así que vamos directamente al amarillo. =intercambia la parte superior de las pilas y _empuja un cero para asegurarse de que seguimos adelante, dando

Main [ n 0 | 0 ] Aux

De lo contrario, si ambos módulos son distintos de cero, entonces el producto es distinto de cero y giramos a la derecha en verde. =intercambia la parte superior de las pilas, dando

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

después de lo cual usamos :para duplicar n, giramos a la derecha, luego usamos !para dar salida n.

Púrpura

En este punto, la pila principal tiene uno o dos elementos, según la ruta que se haya tomado. Necesitamos deshacernos del cero de la ruta amarilla, y para ello usamos +, que funciona n + 0en algún orden para ambos casos. Finalmente, \genera una nueva línea y volvemos al inicio.

Cada iteración empuja un extra (n%5)*(n%3)a la pila auxiliar, pero de lo contrario hacemos lo mismo de nuevo.

Perl 5, 49 bytes

Script de 46 bytes + 3 bytes -E"..."

El uso say(que requiere -E"...") puede reducir esto aún más a 46 bytes, ya que sayincluye automáticamente una nueva línea (¡Gracias @Dennis !):

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

Perl 5, 50 bytes

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

Ruby, 50 bytes.

Requiere la versión 1.8, que parece ser popular entre los golfistas:

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

En Rubí moderna, se reemplaza ?dcon 100una solución de 51 bytes.

Este parece ser el récord mundial.

Java, 130 bytes

Esto es para versiones recientes de Java (7+). En los más antiguos, puede reducir un poco más el uso del enumtruco, pero no creo que la lógica sea más corta que esto (86 adentro 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

Pruébalo aquí

Explicación:

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 bytes

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

Pruébalo en línea!

Explicación

.100{`^
_

El .es el indicador de silencio global que desactiva la salida implícita al final del programa. 100{envuelve el resto del programa en un bucle que se ejecuta durante 100 iteraciones. Finalmente, la etapa misma simplemente inserta un _al comienzo de la cadena, lo que efectivamente incrementa un contador de bucle unario.

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

Más configuración *\(envuelve el resto del programa en un grupo, imprime su resultado con un salto de línea final, pero también coloca a todo el grupo en una ejecución en seco, lo que significa que su resultado se descartará después de la impresión, de modo que nuestro contador de bucle no se modifique realmente . aes un modificador de expresiones regulares personalizado que ancla la expresión regular a toda la cadena (que ahorra un byte al usar ^y $explícitamente).

La etapa atómica misma se ocupa Fizz. La divisibilidad por 3puede verificarse fácilmente en unario: solo pruebe si el número se puede escribir como una repetición de ___. Si este es el caso, anteponemos Fi;la cadena. El punto y coma es para que todavía haya un límite de palabras delante del número para la siguiente etapa. Si convertimos la línea en Fizz___...la posición entre zy _no se consideraría un límite, porque regex trata las letras y los guiones bajos como caracteres de palabras. Sin embargo, el punto y coma también nos permite eliminar la zzduplicación de Fizzy Buzz.

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

Hacemos exactamente lo mismo para la divisibilidad por 5y Bu;, aunque no necesitamos mantener el _s alrededor esta vez. Entonces obtendríamos resultados como

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

Esto hace que sea muy fácil deshacerse de los guiones bajos solo en las líneas que contienen Fizz, al tiempo que completa los zzs:

;_*
zz

Es decir, convertimos cada punto y coma, zzpero también consumimos todos los _s justo después. En este punto, hemos terminado con FizzBuzz en unario. Pero el desafío quiere salida decimal.

'_&`.

&indica un condicional: esta etapa solo se ejecuta si la cadena contiene un guión bajo. Por lo tanto, Fizz, Buzzy FizzBuzzlas iteraciones se dejan sin tocar. En todas las demás iteraciones (es decir, aquellas que no son divisibles por 3 ni 5), solo contamos el número de caracteres, convirtiendo el resultado a decimal.

gs2 , 1

f

Una cita de Mauris, el creador de gs2:

Quería subir el byte de 1 gorubyHello, world! , así que ... Esto se imprime "1\n2\nFizz\n4\nBuzz\n...". :)

Actualización : se agregó una respuesta de 27 bytes que no se usa f.

Perl 5, 45 bytes

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

Requiere la -Eopción, contada como una. Esto debe ejecutarse desde la línea de comando, es decir:

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

Comillas en el comando no son necesarias, si se evita el uso de espacios en blanco u otros caracteres que pueden actuar como separadores de línea de comandos ( |, <, >, &, etc.).

Perl 5, 48 bytes

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

Si las opciones de línea de comando se cuentan como una cada una, -lse ahorraría un byte (al reemplazar $/). Por Clásico Reglas Perlgolf , sin embargo, esto contaría 3: una para el -, uno para el ly otro para el espacio necesario.

cera de abeja ,104 89 81 bytes

El embalaje más denso permite cortar 8 bytes más.

La solución más corta (81 bytes), el mismo flujo de programa, empaque diferente.

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

Cambiar el concepto me permitió reducir el código en 15 bytes. Quería deshacerme de la prueba doble mod 5 en la solución, así que implementé una bandera.

Breve explicación:

si n%3=0se imprime Fizz y se establece la bandera. La bandera se realiza simplemente presionando el valor superior de lstack en el gstack (instrucción f).

Si n%5=0, entonces n%3=0(caso FizzBuzz) o n%3>0(caso Buzz). En ambos casos, Buzz se imprime y la bandera se restablece haciendo estallar la pila hasta que esté vacía (instrucción ?).

Ahora los casos interesantes:

Si n%5>0, entonces tuvimos n%3=0(imprimiendo el estuche Fizz, n no debe imprimirse) o n%3>0(Fizz no se imprimió, entonces n tiene que imprimirse). Hora de revisar la bandera. Esto se realiza presionando la longitud de gstack sobre gstack (instrucción A). Si n%3 was 0entonces la longitud de gstack es> 0. Si n%3 was >0, la longitud de gstack es 0. Un salto condicional simple asegura que n solo se imprima si la longitud de gstack fue 0.

Nuevamente, después de imprimir n, Fizz y / o Buzz y la nueva línea, el gstack aparece dos veces para asegurarse de que esté vacío. gstack está vacío [], lo que conduce a [0]después de la instrucción A(empujar la longitud de gstack en gstack), o contiene un cero ( [0], el resultado de n% 3), lo que conduce a [0 1], ya que [0] tiene la longitud 1. Hacer estallar desde un la pila vacía no cambia la pila, por lo que es seguro explotar dos veces.

Si miras más de cerca puedes ver que, en principio, doblé

>      q
d`Fizz`f>

dentro

<f`z`<
d`Fiz`b

que ayuda a eliminar todo el espacio desperdiciado entre Ay <al final de la siguiente fila en la solución anterior a continuación:

q?{@b'gA<       p      <

Nueva solución conceptual (89 bytes) que incluye una explicación animada:

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

Diseño hexagonal:

   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

Animación de los primeros 326 ticks a 2 fps, con pilas locales y globales, y salida a STDOUT.

A modo de comparación, a continuación se muestran las superposiciones de ruta de la solución más antigua y compleja. Quizás también sea la solución más bonita, desde un punto de vista visual;)

> <> , 68 66 65 64 bytes

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

El único truco es multiplicar los residuos como condición para la impresión de números. De esa manera, si uno de ellos es 0, no imprimiremos el número.

Puedes probarlo aquí .

Guardado un byte gracias a Sp3000 y otro gracias a randomra. ¡Muchas gracias!

gs2 , 28 27 (sin f)

Maleficio:

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

Explicación:

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

Incrustar 3 y 5 en la constante de cadena no funciona porque \x05termina los literales de cadena.

Nota: Este problema se puede resolver en 1 byte con gs2 utilizando el incorporado f.

C, 85 bytes

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

-2 gracias a aprensivo.

CJam, 35 bytes

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

Pruébelo en línea en el intérprete de CJam .

Cómo funciona

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 bytes

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

¿Qué es esto w:$X<3 i, preguntas? $Xes una variable mágica (una "intrínseca") que almacena la posición horizontal del cursor de salida (como un número de caracteres desde el borde izquierdo del terminal). wes la forma abreviada del WRITEcomando. La sintaxis command:condition argses un postcondicional: "if condition, then do command args".

Así que estamos verificando si el cursor de salida ha avanzado más de dos caracteres (lo que significaría que al menos uno de "Fizz"o "Buzz"ha sido escrito en el terminal), y si no, escribiendo ien el terminal. La $Xvariable, y por lo tanto, este tipo de inseparabilidad profunda desde el terminal, es una característica de primera clase de MUMPS. Yikes

Jalea , 24 20 bytes

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

Pruébalo en línea!

Cómo funciona

³µ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.

brainfuck, 206 bytes

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

Formateado:

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

Pruébalo en línea

El diseño de la memoria es

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

donde fciclos por 3, bciclos por 5, d1es un dígito, d2es decenas dígitos, ses un indicador para imprimir diez dígitos, dciclos por 10, ces espacio de copia d, tes espacio de trabajo que contiene 0 o datos basura o un indicador para no -divisible-by-3, y adetermina la terminación del programa compensando el puntero después de que Buzz se haya impreso 20 veces.

C #, 128 126 125 124 bytes

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 bytes sin el código repetitivo alrededor.

Hecho con el uso del formato condicional de C # .

Con dos separadores de sección ;, se imprimen Fizz o Buzz si el valor de su condición es cero.

Guardado un total de 4 bytes gracias a @RubberDuck, @Timwi y @Riokmij.

Clojure, 113 106 101 100 91 bytes

Mi primer golf!

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

Sin golf:

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

brainfuck , 411 350 277 258 bytes

Ediciones:

• -61 bytes almacenando los valores de "Fizz Buzz" como "BuziF" "BuziG" y rehaciendo la sección de impresión de números.

• -71 bytes rehaciendo la sección de impresión del número de módulo, dividiendo el contador de bucle y el contador de números, y reutilizando la celda de nueva línea como el valor de mod, entre otras cosas

• -19 bytes al darse cuenta de que no hay ningún 0 en ningún número de FizzBuzz. También se agregó explicación

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

Pruébalo en línea!

En lugar de verificar si el número en sí era divisible por 5 o 3, tuve dos contadores que realizaban un seguimiento del módulo del número, decrementándolos para cada número e imprimiendo la palabra correspondiente cuando llegaban a 0.

Cómo funciona:

+[-[>+<<]>-]>--  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 Bytes

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

_{Editar: guardado 10 bytes gracias a feersum}

_{Edit2: me di cuenta de que con el truco de feersum, ya no necesito formular $ t como una cadena de bloques de código}

_{Edit3: guardó otros 7 bytes gracias a Danko Durbić}

De espíritu similar al de la respuesta estándar del Código de Rosetta , pero bajó bastante.

Explicación

1..100|%{...} Cree una colección de 1 a 100, luego, para cada objeto de esa colección, haga

(...,$_)cree una nueva colección de dos elementos: 0) $t=...establezca la variable $tigual a una cadena; 1) $_nuestro número actual del bucle

"Fizz"*!($_%3)tome nuestro número actual, modifíquelo por 3, luego NO el resultado. Multiplique "Fizz" por eso y agréguelo a la cadena (y similar para 5). PowerShell trata cualquier número que no sea cero $TRUEy, por lo tanto, el NOT de un número que no sea cero es 0, lo que significa que solo si nuestro número actual es un múltiplo de 3, "Fizz" se agregará a la cadena.

[!$t]índices en la colección que acabamos de crear, en función del valor de la cadena $t: no vacía, imprímala, de lo contrario imprima nuestro número actual

Alternativamente, también 54 bytes

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

_{Gracias a TesselatingHeckler}

De concepto similar, utiliza el -replaceoperador en línea y una expresión regular para intercambiar una cadena vacía ^$con nuestro número actual. Si la cadena no está vacía, no se intercambia.

Alternativamente, también 54 bytes

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

Esta es la misma estructura de bucle que la anterior, pero en su interior ordena el par (n, cadena) y se basa en el hecho de que una cadena vacía se ordena antes de un número, pero una cadena FizzBuzz se ordena después de un número. Luego indexa el segundo resultado de clasificación.

JavaScript, 62 bytes

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

Creo que esta es la solución Javascript más corta ahora.

C, 74 bytes

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

El 0argumento de en printflugar de ""es sospechoso, pero parece funcionar en la mayoría de las plataformas en las que lo pruebo. putssin embargo, se daña cuando intentas lo mismo. Sin ella, obtienes 75 bytes.

Hay soluciones de 73 bytes que funcionan en el golf de anarquía , y encontré una buscando en los lugares correctos en Internet, pero se basan en el comportamiento específico de la plataforma. (Como habrás adivinado, es algo así como la forma puts("Buzz"±...)).

Scratch, 203 185 bytes

Bytes contados a partir de la representación textual de golf , según esta meta publicación . Scratch no es muy eficiente en espacio.

sayes lo más parecido a un stdout Scratch: el sprite muestra una burbuja de diálogo que contiene todo lo que dice. En la práctica, wait n secsse necesitaría un bloque para leer realmente esta salida, pero a los efectos de este desafío, este código cumple los requisitos.

R, 88 83 77 71 70 bytes

Estoy seguro de que esto se puede mejorar ... y fue con crédito a @flodel. Un par de bytes más guardados gracias a una sugerencia de @njnnja y otra de @ J.Doe

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

Haskell, 84 bytes

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

Acercarse a los 81 bytes de henkma , pero aún no está allí.

d = drop.(*4).mod nes clave aquí: d 3 "Fizz"es drop (n`mod`3 * 4) "Fizz". Esto es "Fizz"cuando n `mod` 3es 0 y de lo ""contrario.

PHP, 54 bytes

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

Válido para v5.5 en adelante. El ões el carácter 245, un poco invertido \n.

Asumo la configuración predeterminada del intérprete, ya que no tienen ini. Si no está seguro, puede deshabilitar su ini local -ncomo en php -n fizzbuzz.php.

Una versión que se ejecutará sin errores con absolutamente cualquier archivo de configuración es de 62 bytes :

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

80386 código máquina + DOS, 75 bytes

Hexdump del código:

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

Código fuente (sintaxis 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

Este código cuenta de 1 a 100 pulgadas ax, construyendo el mensaje de salida desde el final hasta el principio. El final del mensaje (nueva línea y el $carácter que usa DOS para el indicador de fin de mensaje) aparece al principio del código:

db 10, 10, '$'

Se ejecuta como una instrucción inofensiva ( or ax, 240ah). Podría ponerlo en un lugar más convencional, como después del final del código, pero tenerlo en la dirección 0x100 tiene un beneficio.

El código también usa 2 contadores adicionales:

• Contando de 3 a 0 en dl
• Contando de 5 a 0 en dh

Cuando un contador llega a 0, empuja la cadena Fizzo Buzzal final del mensaje de salida. Si esto sucede, bxse reducirá y bhserá cero. Esto se usa como condición para generar el número en forma decimal.

Nota: estoy usando datos de 32 bits aquí. Esto no funcionará en una computadora anterior a 386.

corriente continua, 64 62 bytes

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

Sin golf:

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