Vencedor: Resposta CJam do Aditsu ! Uns 25 bytes impressionantes! Agradável!

Você pode continuar enviando sua resposta, mas não poderá mais vencer. Post original mantido para a posteridade:

O jogo "Bzzt" é um jogo em que você deve contar até um número (neste caso, 500). No entanto, se o número tiver um 3 ou for divisível por 3, você não diz o número. Em vez disso, você diz "Bzzt".

Regras:

• Você não pode codificar os números.
• O número deve atender apenas a pelo menos um dos seguintes requisitos
  • Divisível por 3
  • Número contém um 3
• Algum tipo de separador é obrigatório (12bzzt14 não conta)
• A pontuação é medida em bytes.
• Você deve contar exatamente até 500, começando em 1 ou 0 (você escolheu).
• Os números devem ser impressos, mas não importa como (por exemplo, stdout, gravação em um arquivo de texto, etc.).
• 0 pode ser divisível por 3 ou não divisível. Você pode escolher.
• Você pode imprimir os números um de cada vez (ex: saída 1, depois 2, depois bzzt, depois 4, etc.) ou todos de uma vez (por exemplo, saída 1 2 bzzt 4 5).
• Você deve substituir a letra 3 pela palavra "bzzt". Isso não diferencia maiúsculas de minúsculas (bZzt, Bzzt, bzzt estão todos bem).

• Este é um desafio do código-golfe , portanto o código mais curto vence.
• Este concurso termina em 30 de junho de 2014 (7 dias após a publicação).

CJam - 25

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

Obrigado Howard :)

Experimente em http://cjam.aditsu.net/

Explicação:

501{…}fIé basicamente for(int I=0; I<501; ++I) {…}
3sconverte 3 em sequência, ou seja, "3"
I3%é I% 3
<obtém a substring esquerda - "3".substring(0, I % 3)- que é "" para I% 3 == 0 e "3", caso contrário,
Isconverte Iem sequência
-com 2 strings, faz uma diferença definida, resultando em um vazio cadeia sse I% 3 == 0 (a primeira cadeia foi vazio) ou Item um dígito 3 em que
…I"bzzt"?é como … ? I : "bzzt"; a cadeia anterior é tratada como um valor booleano, em que "" é falso e qualquer outra cadeia é verdadeira
Nadiciona uma nova linha

Ruby, 43

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

Bem direto.

Edit: Salvo um byte, obrigado Howard!

seq e GNU sed - 42 33 31 30

Funciona diretamente no painel, alguns outros shells podem precisar ter a expansão do histórico desativada, por exemplo, com o bash set +H:

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

código de máquina x86 no DOS (arquivo .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 a saída necessária para stdout com espaço como delimitador; pode ser executado sem problemas no DosBox.

Montagem 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, sem separador - 62, 61,59,58,52,49 47

Não diz que deve haver um espaço / nova linha / separador entre eles, sem:

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

Com o 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

• Só encontrei um pequeno truque, não preciso de espaço depois echo, me salvou um pouco.
• O ~õcria uma nova linha
• Outro pequeno truque, o bzzt não precisa de aspas (testado). Não é o caminho a seguir, mas funciona.

Javascript - 54,51 50

Mesmo princípio, mas funções javascript:

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

Javascript 50 49

-1 byte graças 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}/

A implementação não tão direta no GolfScript pode ser testada aqui .

Perl, 36

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

Edit: Eu não sou um monge Perl, então core1024 parece ter conseguido tirar outro byte disso em sua resposta .

C # (71)

Pode ser executado diretamente no LinqPad.

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

Python (52)

Graças grc!

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

Versão antiga:

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)

Obrigado a edc65 pela sugestão de usar array. A saída agora será separada por vírgula.

Versões antigas

Versão 1a - 66

Imprima de 1 a 500 em uma caixa de alerta de acordo com a regra. A saída é separada por espaço.

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

Versão 1b - 65

Se considerarmos que 0 não é divisível por 3, podemos reduzir a solução para 65 caracteres:

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

Versão 2 - 63

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

Obrigado ao grc pela sugestão de reduzir o comprimento.

PowerShell, 42

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

Principalmente o trabalho de Ventero, com uma pequena ajuda em sintaxe minha ;-)

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 eu realmente amo esse idioma ... por algum motivo ...

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

Observe que a maioria dos comandos no TI-BASIC são representados como entidades de byte único.

O código requer que o X seja inicializado com 0 de antemão (caso contrário, são 3 bytes adicionais).

Fiz várias tentativas de barbear vários bytes, por isso não estou detalhando tudo o que fiz aqui, para não bagunçar a postagem. Eles foram principalmente direcionados para encurtar o loop, o que fiz nesta versão por um loop While e encurtando a condição If com a ajuda da Ansvariável.

C, 93

Só pra caramba ...

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 que usar um arquivo em lotes quando existe uma única linha perfeitamente direta ... :-)

groovy - 51

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

editar: timesagora, a versão impressa é tão curta quanto a "exibição". obrigado @ will-p

C, 80

Usando espaços como separadores em vez de quebras de linha.

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

Mathematica, 54 caracteres

Isso parece muito simples. Soluções mais curtas devem ser possíveis.

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

T-SQL 2008-80

Não vai ganhar nem nada além de divertido: Tweaked graças a @domager:

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

Um fato pouco conhecido, @ é um nome válido para uma variável. Parece estranho, pois o código baseado em conjunto é a variante mais SQL, mas mais curto é mais curto! Esta versão funciona em qualquer banco de dados. Edit: Consegui remover duas das semifinais porque elas não eram necessárias. Tenho certeza de que isso é o melhor possível.

Edit2: Nunca diga nunca. Aqui está agora ainda mais grosseiro usando goto, mas nos permite evitar o bloqueio. Podemos substituir enquanto, começar, terminar com o menor se, t:, for salvar 6 caracteres. Também reorganizamos a declaração reescrevendo o loop como um pseudo do-while, semanticamente equivalente. Edit3: Sim, de alguma forma, se agora é mais curto. Original:

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

Deve ser executado no banco de dados mestre. Eu amo o T-SQL, apesar de suas maneiras barulhentas e feias. Pode haver uma maneira de simplificar isso, mas, infelizmente, o iifbuilt-in exige que ambos os lados concordem com os tipos. As regras de precedência dos servidores sql fornecem int precedência mais alta que as strings. O número também é muito longo, mas o alias é mais caracteres do que vale a pena. Pode haver uma maneira melhor de transformar o número em uma string. Edit: str também funciona. 2 caracteres a menos que ltrim

VBA: 54

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

Abra seu programa favorito do Office, pressione alt + F11 para abrir o VBA IDE e cole o código no painel imediato e pressione enter.

No VBA,: é o separador de linhas? é abreviação para print, se significa inline se (pense x? "Y": "N"), x / 3 faz divisão de ponto flutuante ex \ 3 faz divisão inteira, instr retorna a posição de um caractere em uma string ou 0 caso contrário, verdadeiro = -1 e falso = 0.

O código basicamente incrementa x e gera x se x / 3 = x \ 3 = instr (1, x, 3) for verdadeiro e "Bzzt", caso contrário. x / 3 = x \ 3 compara (flutua) (x / 3) a (int) (x / 3) e retorna um booleano (0 é falso e -1 é verdadeiro). instr (1, x, 3) retorna 0 se "3" não estiver no número e um número inteiro positivo caso contrário. O único momento em que a expressão retorna true é quando (x / 3 = x \ 3) é false (0) e instr (1, x, 3) é 0 ou, em outras palavras, quando x não é divisível por 3 e não é contém o dígito "3", que é exatamente o que estamos procurando.

k4 (37) (35)

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

k4não possui um comando de módulo embutido e o uso desse qrequer um caractere extra; esta versão (ab) usa o formato de saída interno para verificar se a sequência do resultado da divisão xpor 3 possui um ponto decimal.

EDITAR:

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

Por mais inteligente que possa ser o ponto decimal, posso raspar dois bytes verificando 3*floor x%3se ainda está x.

Bater, 53 52 48 46.

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

Requer GNU sed (usa a cextensão).

Java, 142 131 obrigado a sugestão 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)

Isso é basicamente a resposta do plannapus um pouco mais curta, mas ainda não posso comentar

Atualização: -4 caracteres (veja o comentário de plannapus)

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

Resultado:

  [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

Um candidato irremediavelmente improvável, embora originalmente desenvolvido para caber em cartões perfurados. Usando todas as construções obscuras do passado, ainda é possível escrever algum código curto:

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

O "goto computado" goto(L1,L2,...,Ln) xramifica para um dos rótulos L se e somente se 1 <= x <= n.

Edit: Conseguiu cortar 4 bytes reorganizando o loop que verifica o dígito 3. Como bônus, o código agora também contém a instrução if aritmética if(x) a,b,c, que sempre se ramifica em um dos três rótulos: a if x <0, b se x == 0 ou c se x> 0.

Infelizmente, as duas primeiras versões não produziram a saída correta. O loop de dígito 3 agora funciona corretamente, e o código agora também inclui uma instrução if lógica moderna. Mais três bytes se foram, porque quem precisa de uma enddodeclaração? A saída pode ser verificada aqui .