Gagnant: La réponse CJam d'Aditsu ! Un énorme 25 octets! Agréable!

Vous pouvez continuer à envoyer votre réponse, mais vous ne pouvez plus gagner. Poste originale conservée pour la postérité:

Le jeu "Bzzt" est un jeu dans lequel vous devez compter jusqu'à un nombre (dans ce cas 500). Cependant, si le nombre contient un 3 ou est divisible par 3, vous ne dites pas le nombre. Au lieu de cela, vous dites "Bzzt".

Règles:

• Vous ne pouvez pas coder les chiffres en dur.
• Le numéro doit seulement satisfaire au moins une des exigences suivantes
  • Divisible par 3
  • Le nombre contient un 3
• Certains types de séparateurs sont obligatoires (12bzzt14 ne compte pas)
• Le score est mesuré en octets.
• Vous devez compter exactement à 500, à partir de 1 ou 0 (à vous de choisir).
• Les nombres doivent être sortis, mais peu importe comment (par exemple, stdout, écrire dans un fichier texte, etc.).
• 0 peut être divisible par 3 ou non divisible. Tu peux choisir.
• Vous pouvez sortir les numéros un à un (ex, sortie 1, puis 2, puis bzzt, puis 4, etc.) ou tous en même temps (par exemple, sortie 1 2 bzzt 4 5).
• Vous devez remplacer la lettre 3 par le mot "bzzt". Ce n'est pas sensible à la casse (bZzt, Bzzt, bzzt, ça va).

• Ceci est un défi de code-golf , donc le code le plus court gagne.
• Ce concours se termine le 30 juin 2014 (7 jours après l'envoi).

CJam - 25

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

Merci Howard :)

Essayez-le sur http://cjam.aditsu.net/

Explication:

501{…}fIest fondamentalement for(int I=0; I<501; ++I) {…}
3sconvertit 3 en chaîne, c'est-à-dire que "3"
I3%est I% 3
<obtient la sous-chaîne de gauche - "3".substring(0, I % 3)- qui est "" pour I% 3 == 0 et "3" sinon
Isconvertit Ien chaîne
-avec 2 chaînes fait une différence définie, résultant en un vide Chaîne si I% 3 == 0 (la première chaîne était vide) ou Icontient 3 chiffres, c'est
…I"bzzt"?comme … ? I : "bzzt"; la chaîne précédente est traitée comme une valeur booléenne, où "" est faux et toute autre chaîne est vraie,
Najoute une nouvelle ligne

Ruby, 43 ans

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

Assez simple.

Edit: Un octet enregistré, merci Howard!

seq et GNU sed - 42 33 31 30

Fonctionne directement au tiret, il peut être nécessaire de désactiver l’extension d’historique, par exemple avec bash set +H:

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

Code machine x86 sous DOS (fichier .com) - 71 octets

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 sortie requise sur stdout avec l’espace comme délimiteur; peut être exécuté sans problèmes dans DosBox.

Assemblée commentée:

    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, pas de séparateur - 62, 61,59,58,52,49 47

Il ne dit pas qu'il devrait y avoir un espace / nouvelle ligne / séparateur entre eux, sans:

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

Avec le séparateur, 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

• Je viens de trouver un petit "tricheur", pas besoin d'espace après echo, m'a sauvé un peu.
• Le ~õcrée une nouvelle ligne
• Un autre petit "tricheur", le bzzt n'a pas besoin de guillemets (testé). Pas la voie à suivre, mais ça marche.

Javascript - 54,51 50

Même principe, mais fonctions javascript:

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

Javascript 50 49

-1 octet grâce à core1024

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

GolfScript, 30 à 29 caractères

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

Une implémentation pas si simple dans GolfScript, peut être testée ici .

Perl, 36

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

Edit: Je ne suis pas un moine Perl, donc core1024 semble avoir réussi à jouer un autre octet dans sa réponse .

C # (71)

Peut être exécuté directement dans LinqPad.

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

Python (52)

Merci grc!

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

Ancienne version:

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)

Merci à edc65 pour la suggestion d’utiliser array. La sortie sera maintenant séparée par des virgules.

anciennes versions

Version 1a - 66

Imprimez de 1 à 500 dans une boîte d’alerte conformément à la règle. La sortie est séparée par des espaces.

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

Version 1b - 65

Si nous considérons que 0 n'est pas divisible par 3, nous pouvons raccourcir la solution à 65 caractères:

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

Version 2 - 63

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

Merci à grc pour la suggestion de réduire la longueur.

PowerShell, 42 ans

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

Principalement le travail de Ventero, avec un peu d'aide sur la syntaxe de ma part ;-)

R, 49 caractères

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

A expliqué:

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

Usage:

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

Lot - 222

Parce que j'aime vraiment cette langue ... pour une raison quelconque ...

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

Notez que la plupart des commandes sur TI-BASIC sont représentées sous forme d'entités à un octet.

Le code nécessite que X soit initialisé à 0 à l’avance (sinon, c’est 3 octets supplémentaires).

J'ai fait plusieurs tentatives pour supprimer plusieurs octets, je ne détaille donc pas tout ce que j'ai fait ici, pour ne pas encombrer le message. Elles visaient principalement à raccourcir la boucle, ce que j'ai fait dans cette version par une boucle While et en raccourcissant la condition If à l'aide de la Ansvariable.

C, 93

Juste pour l'enfer ...

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 octets

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

... parce que pourquoi utiliser un fichier batch alors qu’il existe un one-liner parfaitement simple ... :-)

groovy - 51

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

edit: l'utilisation de timesla version d'impression est maintenant aussi courte que "l'affichage". merci @ will-p

C, 80

Utiliser des espaces comme séparateurs au lieu de sauts de ligne.

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

Mathematica, 54 caractères

Cela semble trop simple. Des solutions plus courtes doivent être possibles.

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

T-SQL 2008 - 80

Ne va pas gagner ou quoi que ce soit d’amusant néanmoins: Tweaked grâce à @domager:

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

Un fait peu connu, @ est un nom valide pour une variable. Cela fait bizarre car le code basé sur le set est la variante la plus SQL, mais plus court est court! Cette version fonctionne sur n'importe quelle base de données. Edit: J'ai réussi à enlever deux des demi-finales car elles n'étaient pas nécessaires. Je suis sûr que c'est aussi optimal que possible.

Edit2: Ne dites jamais jamais. Ici, c'est encore plus brutal que d'utiliser goto, mais cela nous permet d'éviter le blocage. Nous pouvons remplacer en commençant, commencer par le plus court si, t:, allez sauvegarder 6 caractères. Nous réarrangons également une instruction en réécrivant la boucle comme un pseudo-do-while, sémantiquement équivalent. Edit3: Oui, en quelque sorte, si est maintenant plus court. Original:

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

Doit être exécuté sur la base de données master. J'adore T-SQL malgré ses manières bruyantes et laides. Il y aurait peut-être un moyen de simplifier cela, mais malheureusement, la fonction iifintégrée nécessite que les deux parties se mettent d' accord sur les types. Les règles de priorité des serveurs SQL donnent une priorité supérieure à celle des chaînes. Le nombre est également très long, mais l'aliasing est plus de caractères qu'il ne vaut. Il pourrait y avoir un meilleur moyen de transformer un nombre en chaîne. Edit: str fonctionne aussi. 2 caractères de moins que ltrim

VBA: 54

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

Ouvrez votre programme Office préféré, appuyez sur alt + F11 pour ouvrir l'EDI VBA, collez le code dans le volet immédiat et appuyez sur Entrée.

En VBA, le séparateur de lignes est-il? est un raccourci pour print, iif signifie inline si (pensez x? "Y": "N"), x / 3 divise en virgule flottante et x \ 3 divise un nombre entier, instr renvoie la position d'un caractère dans une chaîne, ou 0 sinon, true = -1 et false = 0.

Le code incrémente fondamentalement x et génère x si x / 3 = x \ 3 = instr (1, x, 3) est vrai et "Bzzt" sinon. x / 3 = x \ 3 compare (float) (x / 3) à (int) (x / 3) et renvoie un booléen (0 est faux et -1 vrai). instr (1, x, 3) renvoie 0 si "3" n'est pas dans le nombre et un entier positif dans le cas contraire. La seule fois où l'expression renvoie vrai, c'est quand (x / 3 = x \ 3) est faux (0) et instr (1, x, 3) est égal à 0 ou, en d'autres termes, lorsque x n'est pas divisible par 3 et qu'il ne l'est pas. contient le chiffre "3", ce qui est exactement ce que nous recherchons.

k4 (37) (35)

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

k4il manque une commande intégrée modulo et son utilisation qprendrait un caractère supplémentaire; cette version (ab) utilise le format de sortie intégré pour vérifier si la chaîne du résultat de la division xpar 3 contient un point décimal.

MODIFIER:

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

Aussi intelligent que puisse correspondre la virgule décimale, je peux raser deux octets en vérifiant que cela 3*floor x%3est toujours x.

Frapper, 53 52 48 46

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

Nécessite GNU sed (utilise l’ cextension).

Java, 142 131 grâce à la suggestion 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)

Ceci est essentiellement la réponse plannapus un peu raccourcie, mais je ne peux pas commenter encore

Mise à jour: -4 caractères (voir le commentaire de plannapus)

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

Sortie:

  [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 candidat désespérément improbable, bien que développé à l’origine pour les cartes perforées. En utilisant toutes les constructions obscures du passé, certains codes courts peuvent encore être écrits:

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

Le "goto calculé" se goto(L1,L2,...,Ln) xbranche sur l'une des étiquettes L si et seulement si 1 <= x <= n.

Éditer: Il a été possible de supprimer 4 octets en réorganisant la boucle qui recherche le chiffre 3. En bonus, le code contient désormais également l'instruction if arithmétique if(x) a,b,c, qui renvoie toujours à l'une des trois étiquettes suivantes: a if x <0, b si x == 0 ou c si x> 0.

Malheureusement, les deux premières versions n’ont pas produit le bon résultat. La boucle digit-3 fonctionne maintenant correctement et le code inclut également une instruction if moderne et logique. Trois octets supplémentaires ont disparu, car qui a besoin d'une enddodéclaration? La sortie peut être vérifiée ici .