Vincitore: la risposta CJam di Aditsu ! 25 byte enormi! Bello!

Puoi continuare a inviare la tua risposta, tuttavia non puoi più vincere. Posta originale conservata per i posteri:

Il gioco "Bzzt" è un gioco in cui devi contare per un numero (in questo caso 500). Tuttavia, se il numero contiene un 3 o è divisibile per 3, non devi pronunciare il numero. Invece, dici "Bzzt".

Regole:

• Non è possibile codificare i numeri.
• Il numero deve soddisfare solo 1 dei seguenti requisiti
  • Divisibile per 3
  • Il numero contiene un 3
• Un certo tipo di separatore è obbligatorio (12bzzt14 non conta)
• Il punteggio viene misurato in byte.
• Devi contare esattamente fino a 500, a partire da 1 o 0 (hai scelto).
• I numeri devono essere emessi, ma non importa come (es. Stdout, scrivere su un file di testo, ecc.).
• 0 può essere divisibile per 3 o non divisibile. Puoi scegliere.
• È possibile emettere i numeri uno alla volta (es. Uscita 1, quindi 2, quindi bzzt, quindi 4, ecc.) O tutti contemporaneamente (ad es. Uscita 1 2 bzzt 4 5).
• È necessario sostituire la lettera 3 con la parola "bzzt". Questo non fa distinzione tra maiuscole e minuscole (bZzt, Bzzt, bzzt vanno bene).

• Questa è una sfida di code-golf , quindi vince il codice più corto.
• Questo concorso termina il 30 giugno 2014 (7 giorni dalla pubblicazione).

CJam - 25

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

Grazie Howard :)

Provalo su http://cjam.aditsu.net/

Spiegazione:

501{…}fIfondamentalmente for(int I=0; I<501; ++I) {…}
3sconverte 3 in stringa, ovvero "3"
I3%è I% 3
<ottiene la sottostringa sinistra - "3".substring(0, I % 3)- che è "" per I% 3 == 0 e "3" altrimenti
Isconverte Iin stringa
-con 2 stringhe fa una differenza impostata, risultando in un vuoto stringa iff I% 3 == 0 (la prima stringa era vuota) o Iha una cifra di 3
…I"bzzt"?è simile … ? I : "bzzt"; la stringa precedente viene considerata come un valore booleano, dove "" è falso e qualsiasi altra stringa è vera
Naggiunge una nuova riga

Ruby, 43

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

Abbastanza diretto.

Modifica: salvato un byte, grazie Howard!

seq e GNU sed - 42 33 31 30

Funziona direttamente in dash, potrebbe essere necessario disabilitare l'espansione della cronologia per alcune altre shell, ad esempio con bash set +H:

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

codice macchina x86 su DOS (file .com) - 71 byte

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

Stampa l'output richiesto su stdout con spazio come delimitatore; può essere eseguito senza problemi in DosBox.

Assemblaggio commentato:

    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, nessun separatore - 62, 61,59,58,52,49 47

Non dice che ci dovrebbe essere uno spazio / newline / separatore tra di loro, senza:

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

Con il separatore, 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

• Ho appena trovato un piccolo "trucco", non ho bisogno di spazio dopo echo, mi ha salvato un po '.
• Il ~õcrea una nuova riga
• Un altro piccolo 'cheat', il bzzt non ha bisogno di virgolette (testato). Non è la strada da percorrere, ma funziona.

Javascript - 54,51 50

Stesso principio, ma funzioni javascript:

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

Javascript 50 49

-1 byte grazie a core1024

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

GolfScript, 30 29 caratteri

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

L'implementazione non così semplice in GolfScript può essere testata qui .

Perl, 36

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

Modifica: non sono un monaco Perl, quindi core1024 sembra essere riuscito a golfare un altro byte fuori da questo nella sua risposta .

C # (71)

Può essere eseguito direttamente in LinqPad.

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

Python (52)

Grazie grc!

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

Vecchia versione:

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)

Grazie a edc65 per il suggerimento di usare l'array. L'output verrà ora separato da virgola.

Vecchie versioni

Versione 1a - 66

Stampa da 1 a 500 in una casella di avviso in base alla regola. L'output è separato dallo spazio.

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

Versione 1b - 65

Se consideriamo 0 non divisibile per 3, possiamo accorciare la soluzione a 65 caratteri:

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

Versione 2 - 63

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

Grazie a grc per il suggerimento di ridurre la lunghezza.

PowerShell, 42

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

Principalmente il lavoro di Ventero, con un piccolo aiuto sulla sintassi da parte mia ;-)

R, 49 caratteri

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

Ha spiegato:

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)

Lotto - 222

Perché amo davvero questa lingua ... per qualche 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

Si noti che la maggior parte dei comandi su TI-BASIC sono rappresentati come entità a byte singolo.

Il codice richiede che X sia inizializzato a 0 in anticipo (altrimenti, sono 3 byte extra).

Ho fatto diversi tentativi di radere diversi byte, quindi non sto descrivendo tutto ciò che ho fatto qui, per non ingombrare il post. Sono stati principalmente diretti ad accorciare il ciclo, cosa che ho fatto in questa versione da un ciclo While e accorciando la condizione If con l'aiuto della Ansvariabile.

C, 93

Solo per l'inferno ...

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 byte

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

... perché perché usare un file batch quando esiste un one-liner perfettamente semplice ... :-)

groovy - 51

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

modifica: l'utilizzo timesdella versione di stampa ora è breve quanto la "visualizzazione". grazie @ will-p

C, 80

Utilizzo di spazi come separatori anziché interruzioni di riga.

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

Mathematica, 54 personaggi

Sembra troppo semplice. Devono essere possibili soluzioni più brevi.

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

T-SQL 2008 - 80

Non vinceremo o altro ma divertiremo comunque: ottimizzato grazie a @domager:

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

Un fatto poco noto, @ è un nome valido per una variabile. Sembra strano perché il codice basato su set è la variante più SQL, ma più breve è più corto! Questa versione funziona su qualsiasi database. Modifica: sono stato in grado di rimuovere due semifinali in quanto non erano necessarie. Sono abbastanza sicuro che sia ottimale.

Edit2: non dire mai mai. Qui ora è ancora più grossolano usare goto, ma ci consente di evitare il blocco. Possiamo sostituire mentre, per cominciare, finiamo con il più breve se, t:, vai a salvare 6 caratteri. Riorganizziamo anche l'affermazione riscrivendo il ciclo come uno pseudo do-while, semanticamente equivalente. Edit3: Sì, in qualche modo se ora è più corto. Originale:

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

Deve essere eseguito sul database principale. Adoro T-SQL nonostante i suoi modi rumorosi e brutti. Potrebbe esserci un modo per renderlo più semplice, ma sfortunatamente, il iifbuilt-in richiede che entrambe le parti siano d'accordo sui tipi. Le regole di precedenza dei server SQL danno una precedenza maggiore rispetto alle stringhe. Anche il numero è davvero lungo, ma l'aliasing è più caratteri di quanto valga la pena. Potrebbe esserci un modo migliore per convertire il numero in una stringa. Modifica: funziona anche str. 2 personaggi in meno di ltrim

VBA: 54

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

Apri il tuo programma Office preferito, premi alt + F11 per aprire l'IDE VBA e incolla il codice nel riquadro immediato e premi Invio.

In VBA: è il separatore di riga,? è una scorciatoia per la stampa, iif significa inline if (think x? "Y": "N"), x / 3 fa divisione in virgola mobile e x \ 3 fa divisione in numero intero, instr restituisce la posizione di un carattere in una stringa, oppure 0 altrimenti, true = -1 e false = 0.

Il codice sostanzialmente incrementa x e genera x se x / 3 = x \ 3 = instr (1, x, 3) è vero e "Bzzt" altrimenti. x / 3 = x \ 3 confronta (float) (x / 3) con (int) (x / 3) e restituisce un valore booleano (0 è falso e -1 è vero). instr (1, x, 3) restituisce 0 se "3" non è presente nel numero e un numero intero positivo altrimenti. L'unica volta in cui l'espressione restituisce true è quando (x / 3 = x \ 3) è false (0) e instr (1, x, 3) è 0, o in altre parole, quando x non è divisibile per 3 e non lo è contiene la cifra "3", che è esattamente quello che stiamo cercando.

k4 (37) (35)

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

k4manca un comando modulo integrato e l'utilizzo di qquello richiederebbe un carattere aggiuntivo; questa versione (ab) utilizza il formato di output incorporato per verificare se la stringa del risultato della divisione xper 3 contiene un punto decimale.

MODIFICARE:

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

Per quanto intelligente possa essere la corrispondenza del punto decimale, posso radere due byte controllando che 3*floor x%3sia fermo x.

bash, 53 52 48 46

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

Richiede GNU sed (usa l' cestensione).

Java, 142 131 grazie al suggerimento di 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)

Questa è sostanzialmente una risposta plannapus un po 'abbreviata, ma non posso ancora commentare

Aggiornamento: -4 caratteri (vedi il commento di plannapus)

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

Produzione:

  [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 irrimediabilmente improbabile, sebbene originariamente sviluppato per adattarsi alle schede perforate. Utilizzando tutti gli oscuri costrutti del passato, è ancora possibile scrivere un codice breve:

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

Il "goto calcolato" si goto(L1,L2,...,Ln) xdirama verso una delle etichette L se e solo se 1 <= x <= n.

Modifica: gestito per radere 4 byte riorganizzando il ciclo che controlla la cifra 3. Come bonus, il codice ora contiene anche l'istruzione if aritmetica if(x) a,b,c, che si ramifica sempre su una delle tre etichette: a if x <0, b se x == 0 oc se x> 0.

Sfortunatamente, le prime due versioni non hanno prodotto l'output corretto. Il ciclo digit-3 ora funziona correttamente e il codice ora include anche un'istruzione if logica moderna. Altri tre byte sono spariti, perché chi ha bisogno di una enddodichiarazione? L'output può essere verificato qui .