Ganador: ¡La respuesta CJam de Aditsu ! ¡La friolera de 25 bytes! ¡Agradable!

Puede continuar enviando su respuesta, sin embargo, ya no puede ganar. Publicación original mantenida para la posteridad:

El juego "Bzzt" es un juego en el que debes contar hasta un número (en este caso 500). Sin embargo, si el número tiene un 3 o es divisible por 3, no dice el número. En cambio, dices "Bzzt".

Reglas:

• No puedes codificar los números.
• El número solo debe cumplir al menos 1 de los siguientes requisitos
  • Divisible por 3
  • El número contiene un 3
• Algún tipo de separador es obligatorio (12bzzt14 no cuenta)
• La puntuación se mide en bytes.
• Debe contar exactamente hasta 500, comenzando en 1 o 0 (usted eligió).
• Los números deben enviarse, pero no importa cómo (por ejemplo, stdout, escribir en un archivo de texto, etc.).
• 0 puede ser divisible por 3 o no divisible. Tu puedes elegir.
• Puede generar los números de uno en uno (por ejemplo, salida 1, luego 2, luego bzzt, luego 4, etc.) o todos a la vez (por ejemplo, salida 1 2 bzzt 4 5).
• Debe reemplazar la letra 3 con la palabra "bzzt". Esto no distingue entre mayúsculas y minúsculas (bZzt, Bzzt, bzzt están bien).

• Este es un desafío de código de golf , por lo que gana el código más corto.
• Este concurso finaliza el 30 de junio de 2014 (7 días desde su publicación).

CJam - 25

501{3sI3%<Is-I"bzzt"?N}fI

Gracias Howard :)

Pruébalo en http://cjam.aditsu.net/

Explicación:

501{…}fIbásicamente for(int I=0; I<501; ++I) {…}
3sconvierte 3 en cadena, es decir, "3"
I3%es I% 3
<obtiene la subcadena izquierda "3".substring(0, I % 3)- que es "" para I% 3 == 0 y "3" de lo contrario, se
Isconvierte Ien cadena
-con 2 cadenas hace una diferencia establecida, lo que resulta en un vacío string iff I% 3 == 0 (la primera cadena estaba vacía) o Itiene 3 dígitos,
…I"bzzt"?es como … ? I : "bzzt"; la cadena anterior se trata como un valor booleano, donde "" es falso y cualquier otra cadena es verdadera
Nagrega una nueva línea

Rubí, 43

501.times{|a|puts"#{a}"[?3]||a%3<1?:Bzzt:a}

Muy claro.

Editar: guardado un byte, gracias Howard!

seq y GNU sed - 42 33 31 30

Funciona directamente en el tablero, algunos otros shells pueden necesitar deshabilitar la expansión del historial, por ejemplo, con bash set +H:

seq 500|sed 0~3!{/3/!b}\;cbzzt

Código de máquina x86 en DOS (archivo .com) - 71 bytes

00000000  31 c9 68 20 24 89 e5 89  c8 bb 03 00 31 d2 f7 f3  |1.h $.......1...|
00000010  85 d2 74 1a 89 c8 b3 0a  31 d2 f7 f3 80 fa 03 74  |..t.....1......t|
00000020  0d 80 c2 30 86 d6 52 44  85 c0 75 ea eb 08 89 ec  |...0..RD..u.....|
00000030  68 7a 74 68 62 7a 89 e2  b4 09 cd 21 89 ec 41 81  |hzthbz.....!..A.|
00000040  f9 f4 01 7e c2 59 c3                              |...~.Y.|

Imprime la salida requerida en stdout con espacio como delimitador; se puede ejecutar sin problemas en DosBox.

Asamblea comentada:

    org 100h

start:
    ; 0 - 500 counter
    xor cx,cx
    ; we'll use the stack as scratch space to build the strings to print
    ; first of all, push ' $' on the stack (in reverse order); this will be
    ; the end of each string we'll print
    push 2420h
    ; save the stack pointer, to get back to this position after each print
    mov bp,sp
mainloop:
    ; first try to divide by three
    mov ax,cx
    mov bx,3
    xor dx,dx
    div bx
    test dx,dx
    ; no remainder => bzzt
    jz bzzt
    ; otherwise, go into the decimal-print loop
    mov ax,cx
divloop:
    ; bh is already at zero due to the mov bx,3 above
    mov bl,10
    xor dx,dx
    ; divide by 10
    div bx
    ; remainder is 3 => bzzt
    cmp dl,3
    je bzzt
    ; convert number to digit
    add dl,'0'
    ; trick: we move the digit to the upper byte of dx: this allows us to
    ; push the whole dx (you cannot do push dl) but to easily kill the
    ; undesidered byte by touching the stack pointer (it will be overwritten
    ; by the next stack operation/ignored by the print)
    xchg dl,dh
    push dx
    inc sp
    ; check is there anything left to print, rinse & repeat
    test ax,ax
    jnz divloop
    ; skip straight to print
    jmp print
bzzt:
    ; since we may be here from inside divloop, reset the stack pointer to
    ; where we left ' $'
    mov sp,bp
    ; push 'bzzt'
    push 747ah
    push 7a62h
print:
    ; print what is on the stack
    mov dx,sp
    mov ah,9h
    int 21h
    ; move us back to ' $'
    mov sp,bp

    ; increment cx and repeat while we are <=500
    inc cx
    cmp cx,500
    jle mainloop
end:
    ; fix back the stack pointer to the original value (=kill the first push)
    pop cx
    ; quit
    ret

Perl - 35 40 42

print$_*!/3/%3?$_:bzzt,$/for 1..500

PHP, sin separador - 62, 61,59,58,52,49 47

No dice que debería haber un espacio / nueva línea / separador entre ellos, sin:

while(++$i<501)echo$i%3*!strpbrk($i,3)?$i:bzzt;

Con el separador, 68,67,65,64,58 / 55,53 / 52 51/50

while(++$i<501)echo$i%3*!strpbrk($i,3)?$i:bzzt,' '; // 51
while(++$i<501)echo$i%3*!strpbrk($i,3)?$i:bzzt,~õ; // 50

• Acabo de encontrar un pequeño "truco", no necesito un espacio después echo, me salvó un poco.
• El ~õcrea una nueva línea
• Otro pequeño 'truco', el bzzt no necesita comillas (lo probó). No es el camino a seguir, pero funciona.

Javascript - 54,51 50

El mismo principio, pero las funciones de JavaScript:

for(i=0;i++<500;)alert(i%3<1|/3/.test(i)?'bzzt':i)

Javascript 50 49

-1 byte gracias a core1024

for(i=0;i++<500;)alert(i%3*!/3/.test(i)?i:'bzzt')

GolfScript, 30 29 caracteres

501,{:^`3`^3%<?)'bzzt'^if n}/

La implementación no tan sencilla en GolfScript se puede probar aquí .

Perl, 36

print$_%3&&!/3/?$_:Bzzt,$/for 1..500

Editar: no soy un monje Perl, por lo que core1024 parece haber logrado jugar otro byte en su respuesta .

C # (71)

Se puede ejecutar directamente en LinqPad.

for(var i=0;++i<501;)(i%3<1|(i+"").Contains("3")?"buzz":i+"").Dump();

Pitón (52)

Gracias grc!

for i in range(501):print[i,'Bzzt'][i%3<1or'3'in`i`]

Versión antigua:

print['Bzzt'if'3'in`i`or i%3<1 else`i`for i in range(501)]

Haskell: 88 82 80 79

main=mapM_ f[1..500]
f n|n`mod`3<1||'3'`elem`show n=putStrLn"bzzt"
f n=print n

JavaScript 66 63 60

for(a=i=[];i<500;)a[i++]=i%3&&!/3/.test(i)?i:'bzzt';alert(a)

Gracias a edc65 por la sugerencia de usar array. La salida ahora estará separada por comas.

versiones antiguas

Versión 1a - 66

Imprima de 1 a 500 en un cuadro de alerta de acuerdo con la regla. La salida está separada por espacios.

a="";for(i=1;i<501;i++)a+=i%3&&!/3/.test(i)?i+" ":"bzzt ";alert(a)

Versión 1b - 65

Si consideramos que 0 no es divisible por 3, podemos acortar la solución a 65 caracteres:

a=0;for(i=1;i<501;i++)a+=i%3&&!/3/.test(i)?" "+i:" bzzt";alert(a)

Versión 2 - 63

for(a=i="";i<501;)a+=++i%3&&!/3/.test(i)?i+" ":"bzzt ";alert(a)

Gracias a grc por la sugerencia de reducir la longitud.

PowerShell, 42

1..500|%{($_,'bzzt')[$_-match3-or!($_%3)]}

Principalmente el trabajo de Ventero, con un poco de ayuda en la sintaxis de mi parte ;-)

R, 49 caracteres

a=1:500;b='bzzt';a[!a%%3]=b;a[grep(3,a)]=b;cat(a)

Explicado:

a=1:500 #Creates a vector with all integers from 1 to 500
b='bzzt'
a[!a%%3]=b #Replace all multiples of 3 by 'bzzt', thus coercing all other integers to character strings
a[grep(3,a)]=b #Replaces the character strings containing 3 by 'bzzt'
cat(a) #Print to stdout

Uso:

> a=1:500;b='bzzt';a[!a%%3]=b;a[grep(3,a)]=b;cat(a)
1 2 bzzt 4 5 bzzt 7 8 bzzt 10 11 bzzt bzzt 14 bzzt 16 17 bzzt 19 20 bzzt 22 bzzt bzzt 25 26 bzzt 28 29 bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt 40 41 bzzt bzzt 44 bzzt 46 47 bzzt 49 50 bzzt 52 bzzt bzzt 55 56 bzzt 58 59 bzzt 61 62 bzzt 64 65 bzzt 67 68 bzzt 70 71 bzzt bzzt 74 bzzt 76 77 bzzt 79 80 bzzt 82 bzzt bzzt 85 86 bzzt 88 89 bzzt 91 92 bzzt 94 95 bzzt 97 98 bzzt 100 101 bzzt bzzt 104 bzzt 106 107 bzzt 109 110 bzzt 112 bzzt bzzt 115 116 bzzt 118 119 bzzt 121 122 bzzt 124 125 bzzt 127 128 bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt 140 bzzt 142 bzzt bzzt 145 146 bzzt 148 149 bzzt 151 152 bzzt 154 155 bzzt 157 158 bzzt 160 161 bzzt bzzt 164 bzzt 166 167 bzzt 169 170 bzzt 172 bzzt bzzt 175 176 bzzt 178 179 bzzt 181 182 bzzt 184 185 bzzt 187 188 bzzt 190 191 bzzt bzzt 194 bzzt 196 197 bzzt 199 200 bzzt 202 bzzt bzzt 205 206 bzzt 208 209 bzzt 211 212 bzzt 214 215 bzzt 217 218 bzzt 220 221 bzzt bzzt 224 bzzt 226 227 bzzt 229 bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt 241 242 bzzt 244 245 bzzt 247 248 bzzt 250 251 bzzt bzzt 254 bzzt 256 257 bzzt 259 260 bzzt 262 bzzt bzzt 265 266 bzzt 268 269 bzzt 271 272 bzzt 274 275 bzzt 277 278 bzzt 280 281 bzzt bzzt 284 bzzt 286 287 bzzt 289 290 bzzt 292 bzzt bzzt 295 296 bzzt 298 299 bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt 400 401 bzzt bzzt 404 bzzt 406 407 bzzt 409 410 bzzt 412 bzzt bzzt 415 416 bzzt 418 419 bzzt 421 422 bzzt 424 425 bzzt 427 428 bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt bzzt 440 bzzt 442 bzzt bzzt 445 446 bzzt 448 449 bzzt 451 452 bzzt 454 455 bzzt 457 458 bzzt 460 461 bzzt bzzt 464 bzzt 466 467 bzzt 469 470 bzzt 472 bzzt bzzt 475 476 bzzt 478 479 bzzt 481 482 bzzt 484 485 bzzt 487 488 bzzt 490 491 bzzt bzzt 494 bzzt 496 497 bzzt 499 500

Cobra - 70

class P
    def main
        for i in 501,print if('3'in'[i]'or i%3<1,'Bzzt',i)

Lote - 222

Porque realmente amo este idioma ... por alguna razón ...

SETLOCAL ENABLEDELAYEDEXPANSION
for /l %%n in (1,1,500) do (
    set a=%%n&set /ai=!a!%%3
    if "!a:~0,1!"=="3" set a=Bzzt
    if "!a:~1,2!"=="3" set a=Bzzt
    if "!a:~2,3!"=="3" set a=Bzzt
    if !i!==0 set a=Bzzt
    echo !a!>>x)

TI-BASIC - 31 (32) (34) (35) (36) (43)

:While X<500
:X+1→X
:If not(fPart(X/3
:"bzzt
:Disp Ans
:End

Total: 25 + 6 lines = 31

Tenga en cuenta que la mayoría de los comandos en TI-BASIC se representan como entidades de un solo byte.

El código requiere que X se inicialice a 0 de antemano (de lo contrario, son 3 bytes adicionales).

He hecho varios intentos para reducir varios bytes, por lo que no detallo todo lo que he hecho aquí para no saturar la publicación. Se han dirigido principalmente a acortar el ciclo, lo que he hecho en esta versión mediante un ciclo While y acortar la condición If con la ayuda de la Ansvariable.

C, 93

Sólo por el placer de hacerlo...

main(i){char s[9]="bzzt";while(i<498+sprintf(s+5,"%d",i))puts(s+5*(i++%3&&!strchr(s+5,51)));}

Julia 64 bytes

map(x->x%3==0||contains(string(x),"3")?"Bzzt":string(x),[1:500])

cmd.exe - 91

for /l %x in (1,1,500)do @set/a %x%3|find "0">nul&&echo bzzt||echo %x|find/v"3"||echo bzzt

... porque ¿por qué usar un archivo por lotes cuando existe una línea directa perfectamente sencilla ... :-)

maravilloso - 51

500.times{println"$it".find('3')||it%3<1?'bzzt':it}

editar: usar timesla versión de impresión ahora es tan corto como "mostrar". gracias @ will-p

C, 80

Usar espacios como separadores en lugar de saltos de línea.

n;main(){for(;n++<500;)printf(n%10^3&&n/10%10^3&&n/100^3&&n%3?"%d ":"bzzt ",n);}

Mathematica, 54 Personajes

Esto se siente demasiado sencillo. Soluciones más cortas deben ser posibles.

If[DigitCount[#][[3]] > 0 || #~Mod~3 < 1, Bzzt, #] & /@ Range@500

T-SQL 2008 - 80

No va a ganar ni nada, pero divertido, no obstante: gracias gracias a @domager:

declare @ int=0t:if(@)like'%3%'or @%3=0print'bzzt'print @;set @+=1if @<501goto t

Un hecho poco conocido, @ es un nombre válido para una variable. Se siente extraño ya que el código basado en el conjunto es la variante más SQL, ¡pero más corto es más corto! Esta versión funciona en cualquier base de datos. Editar: pude eliminar dos de las semifinales ya que no eran necesarias. Estoy bastante seguro de que esto es lo más óptimo posible.

Edit2: nunca digas nunca. Aquí ahora es aún más asqueroso usar goto, pero nos permite evitar el bloqueo. Podemos Reemplazar mientras, comenzar, terminar con el más corto si, t:, salta 6 caracteres. También reorganizamos la declaración reescribiendo el ciclo como un pseudo do-while, semánticamente equivalente. Edit3: Sí, de alguna manera si ahora es más corto. Original:

select top 501iif(number like'%3%'or number%3=0,'bzzt',str(number))from spt_values where'p'=type

Debe ejecutarse en la base de datos maestra. Me encanta T-SQL a pesar de sus formas ruidosas y feas. Puede haber una manera de simplificar esto, pero desafortunadamente, la función iifintegrada requiere que ambas partes acuerden los tipos. Las reglas de precedencia de los servidores SQL dan una precedencia int más alta que las cadenas. El número también es realmente largo, pero el alias tiene más caracteres de lo que vale. Puede haber una mejor manera de convertir el número en una cadena. Editar: str también funciona. 2 caracteres menos que ltrim

VBA: 54

for x=0to 500:?iif(x/3=x\3=instr(1,x,3),x,"Bzzt"):next

Abra su programa de Office favorito, presione alt + F11 para abrir el IDE de VBA y pegue el código en el panel inmediato y presione Entrar.

En VBA,: ¿el separador de línea es? es una forma abreviada de impresión, iif significa en línea si (piensa x? "Y": "N"), x / 3 hace la división de coma flotante y x \ 3 hace la división entera, instr devuelve la posición de un carácter en una cadena, o 0 de lo contrario, verdadero = -1 y falso = 0.

Básicamente, el código incrementa xy genera x si x / 3 = x \ 3 = instr (1, x, 3) es verdadero y "Bzzt" de lo contrario. x / 3 = x \ 3 compara (flotante) (x / 3) con (int) (x / 3) y devuelve un valor booleano (0 es falso y -1 es verdadero). instr (1, x, 3) devuelve 0 si "3" no está en el número, y un entero positivo de lo contrario. El único momento en que la expresión devuelve verdadero es cuando (x / 3 = x \ 3) es falso (0) e instr (1, x, 3) es 0, o en otras palabras, cuando x no es divisible por 3 y no contiene el dígito "3", que es exactamente lo que estamos buscando.

k4 (37) (35)

{$(x;`bzzt)(|/51=$x)|~"."in$x%3}'!501

k4carece de un comando de módulo incorporado, y usar quno tomaría un carácter adicional; esta versión (ab) usa el formato de salida incorporado para verificar si la cadena del resultado de dividir xentre 3 tiene un punto decimal.

EDITAR:

{$(x;`bzzt)(|/51=$x)|x=3*_x%3}'!501

Por inteligente que pueda ser la coincidencia del punto decimal, puedo afeitar dos bytes comprobando que 3*floor x%3todavía está x.

Golpetazo, 53 52 48 46

seq 500|factor|sed '/3.*:\| 3 */cBzzt
s/:.*//'

Requiere GNU sed (usa la cextensión).

Java, 142 131 gracias a la sugerencia de WozzeC

public class a{public static void main(String[]a){for(int i=1;i<501;i++)System.out.println(i%3>0&(""+i).indexOf(51)<0?i:"bzzt");}}

R (40) (36)

Esto es básicamente una respuesta plannapus un poco acortada, pero aún no puedo comentar

Actualización: -4 caracteres (ver comentario de plannapus)

a=1:500;a[grepl(3,a)|!a%%3]='bzzt';a

Salida:

  [1] "1"    "2"    "bzzt" "4"    "5"    "bzzt" "7"    "8"    "bzzt" "10"   "11"   "bzzt" "bzzt" "14"   "bzzt" "16"   "17"   "bzzt" "19"   "20"   "bzzt" "22"   "bzzt" "bzzt" "25"   "26"   "bzzt" "28"   "29"   "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "40"   "41"   "bzzt" "bzzt" "44"   "bzzt" "46"   "47"   "bzzt" "49"   "50"   "bzzt" "52"   "bzzt" "bzzt" "55"   "56"   "bzzt" "58"   "59"   "bzzt" "61"   "62"   "bzzt" "64"   "65"   "bzzt" "67"   "68"   "bzzt" "70"   "71"   "bzzt" "bzzt" "74"   "bzzt" "76"   "77"   "bzzt" "79"   "80"   "bzzt" "82"   "bzzt" "bzzt" "85"   "86"   "bzzt" "88"   "89"   "bzzt" "91"   "92"   "bzzt" "94"   "95"   "bzzt" "97"   "98"   "bzzt" "100"  "101"  "bzzt" "bzzt" "104"  "bzzt" "106"  "107"  "bzzt" "109"  "110"  "bzzt" "112"  "bzzt" "bzzt" "115"  "116"  "bzzt" "118"  "119"  "bzzt" "121"  "122"  "bzzt" "124"  "125"  "bzzt" "127"  "128"  "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "140"  "bzzt" "142"  "bzzt" "bzzt" "145"  "146"  "bzzt" "148"  "149"  "bzzt" "151"  "152"  "bzzt" "154"  "155"  "bzzt" "157"  "158"  "bzzt" "160"  "161"  "bzzt" "bzzt" "164"  "bzzt" "166"  "167"  "bzzt" "169"  "170"  "bzzt" "172"  "bzzt" "bzzt" "175"  "176"  "bzzt" "178"  "179"  "bzzt" "181"  "182"  "bzzt" "184"  "185"  "bzzt" "187"  "188"  "bzzt" "190"  "191"  "bzzt" "bzzt" "194"  "bzzt" "196"  "197"  "bzzt" "199"  "200"  "bzzt" "202"  "bzzt" "bzzt" "205"  "206"  "bzzt" "208"  "209"  "bzzt" "211"  "212"  "bzzt" "214"  "215"  "bzzt" "217"  "218"  "bzzt" "220"  "221"  "bzzt" "bzzt" "224"  "bzzt" "226"  "227"  "bzzt" "229"  "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "241"  "242"  "bzzt" "244"  "245"  "bzzt" "247"  "248"  "bzzt" "250"  "251"  "bzzt" "bzzt" "254"  "bzzt" "256"  "257"  "bzzt" "259"  "260"  "bzzt" "262"  "bzzt" "bzzt" "265"  "266"  "bzzt" "268"  "269"  "bzzt" "271"  "272"  "bzzt" "274"  "275"  "bzzt" "277"  "278"  "bzzt" "280"  "281"  "bzzt" "bzzt" "284"  "bzzt" "286"  "287"  "bzzt" "289"  "290"  "bzzt" "292"  "bzzt" "bzzt" "295"  "296"  "bzzt" "298"  "299"  "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "400"  "401"  "bzzt" "bzzt" "404"  "bzzt" "406"  "407"  "bzzt" "409"  "410"  "bzzt" "412"  "bzzt" "bzzt" "415"  "416"  "bzzt" "418"  "419"  "bzzt" "421"  "422"  "bzzt" "424"  "425"  "bzzt" "427"  "428"  "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "bzzt" "440"  "bzzt" "442"  "bzzt" "bzzt" "445"  "446"  "bzzt" "448"  "449"  "bzzt" "451"  "452"  "bzzt" "454"  "455"  "bzzt" "457"  "458"  "bzzt" "460"  "461"  "bzzt" "bzzt" "464"  "bzzt" "466"  "467"  "bzzt" "469"  "470"  "bzzt" "472"  "bzzt" "bzzt" "475"  "476"  "bzzt" "478"  "479"  "bzzt" "481"  "482"  "bzzt" "484"  "485"  "bzzt" "487"  "488"  "bzzt" "490"  "491"  "bzzt" "bzzt" "494"  "bzzt" "496"  "497"  "bzzt" "499"  "500"

Fortran - 118 114 111

Un candidato irremediablemente improbable, aunque originalmente desarrollado para adaptarse a las tarjetas perforadas. Usando todas las construcciones oscuras del pasado, aún se puede escribir algún código corto:

do3 i=1,500
j=i
if(mod(i,3))2,1,2
1 print*,'bzzt'
cycle
2 goto(1)mod(j,10)-2
j=j/10
if(j>0)goto2
3 print*,i
end

El "goto calculado" se goto(L1,L2,...,Ln) xramifica a una de las etiquetas L si y solo si 1 <= x <= n.

Editar: logró reducir 4 bytes reorganizando el bucle que verifica el dígito 3. Como beneficio adicional, el código ahora también contiene la declaración aritmética if if(x) a,b,c, que siempre se ramifica a una de tres etiquetas: a if x <0, b si x == 0 o c si x> 0.

Desafortunadamente, las dos primeras versiones no produjeron el resultado correcto. El bucle digit-3 ahora funciona correctamente, y el código ahora también incluye una sentencia if lógica moderna. Tres bytes más se han ido, porque ¿quién necesita una enddodeclaración? La salida se puede verificar aquí .