Inspiré par cette valeur par défaut pour IO .

La tâche

Ecrivez un programme qui, avec un nombre entier xcompris entre 0 et 255, plante avec le code de sortie x.

Restrictions

• Vous ne pouvez pas appeler quoi que ce soit qui est directement destiné à la sortie du code de sortie ( System.exit(x)retour main, etc.). Au lieu de cela, votre programme doit provoquer une erreur ou un crash qui entraînera, avec une probabilité de 1, la fermeture du programme avec le nombre entier saisi.
  • Dans ce cas, les mots "erreur" et "crash" signifient que le programme a provoqué une exception non intentionnelle fatale, dans laquelle une méthode, une opération ou une autre utilisation a été utilisée de manière incorrecte et a entraîné une défaillance irréversible.
  • Vous ne pouvez pas directement causer l'erreur en la lançant directement. Vous devez le provoquer en utilisant une méthode, une fonction ou toute autre fonction dont le but est de servir une fonction différente (par exemple, en essayant d'exécuter un fichier en écriture dans un répertoire en lecture seule).
• Vous devez avoir au moins deux codes de sortie comptabilisés dans votre programme.
• L'arrêt du processus avec l'utilisation de signaux est interdit. (Le raisonnement peut être trouvé dans cette discussion )

Notation

Le score de votre programme est déterminé par le nombre de codes de sortie pris en charge, où la concision de code est une égalité. Le plus grand nombre de codes de sortie pris en charge gagne!

Unix Shell (+ ncurses + BSD), 36, 26 octets, 256 codes de sortie

Golfé

jot -bu0 $[252+$1]|tput -S

Si l'option -S est utilisée, tput vérifie les erreurs de chaque ligne et, si des erreurs sont détectées, définira le code de sortie sur 4 plus le nombre de lignes contenant des erreurs. Si aucune erreur n'est trouvée, le code de sortie est 0. Aucune indication de la ligne ayant échoué ne peut être donnée, le code de sortie 1 n'apparaîtra jamais. Les codes de sortie 2, 3 et 4 conservent leur interprétation habituelle.

Une fois que le code de sortie tput dépasse 255, il ne fait que déborder, de sorte que 253 (erreurs sur les entrées) génèrera le code de sortie de 1, etc., donnant ainsi le statut de sortie souhaité pour toute la plage d'entrées.

Remarque : si le débit échouera ou non, lors du paramétrage / obtention d'une capacité particulière, cela dépend du type de terminal que j'ai utilisé:xterm with 256 colors

jot est un utilitaire BSD , qui imprime des données séquentielles ou aléatoires, et (autant que je sache) est également disponible tel quel sur les systèmes OSX.

Si votre système n'est pas jotdisponible, vous pouvez utiliser une version légèrement plus longue (29 octets):

yes u0|sed $[252+$1]q|tput -S

Essayez-le en ligne! (la version 29 octets)

Bash 4.2 + extras, 24 codes de sortie

grep \#$1$ $0|sed 's:#.*::;s:T:tcc -run -<<<main=:;s:C:curl -L x.org/! :'|sh;exit
man#1
C-#2
C/#3
sed#4
C-x/#5
C_#6
C0#7
man /#16
C-f#22
C-o/#23
C-L3#35
C--capath /#60
C--max-filesize 1#63
C--cacert /#77
timeout 1e-9 w#124
/#126
-#127
T6\;#132
T204\;#133
$[2**63%-1]#136
{0..1000000000}#137
T0\;#139
exit _#255

Merci à @ KenY-N pour 3 codes de sortie. Merci à @ el.pescado pour 1 code de sortie.

Vérification

Tous les tests ont été effectués sur openSUSE 13.2.

$ for n in {0..255}; do bash exit.sh $n; (($? == $n)) && echo $n >&0; done &> /dev/null
0
1
2
3
4
6
7
16
22
23
35
60
63
77
124
126
127
132
133
136
137
139
255

INTERCAL (C-INTERCAL), 15 codes, 313 + 2 = 315 octets

        PLEASE WRITE IN .1
(8)     PLEASE CREATE .1 A
        PLEASE A
        PLEASE COME FROM #2$!1/#1'

        DO X
(123)   DO (123) NEXT
        DO COME FROM (222)
(222)   DO STASH .2
(240)   DO ,1 <- #0
(241)   DO ,1 SUB #0 <- #1
(19)    DO .2 <- #256 $ #0
(21)    DO .1 <- #2
(148)   DO GO BACK
(180)   DO RETRIEVE .2
        DO COME FROM (50)
(50)    DO WRITE IN .2
(109)   DO RESUME #0
(120)   DO RESUME #9
        MAYBE COME FROM (223)
(223)   DO COME FROM (223)
(121)   PLEASE NOT X

Essayez-le en ligne!

Tous les espaces sont sans importance. (Le programme d'origine contenait des onglets, mais je les ai convertis en espaces pour qu'il s'aligne correctement sur SE. Il est classique d'utiliser une largeur de tabulation de 8 pour INTERCAL. J'ai testé une version du programme avec tous les onglets, espaces et les nouvelles lignes supprimées, cependant, et cela fonctionne bien.)

Compiler avec -abm(pénalité de 2 octets, car il -best nécessaire pour que le compilateur soit déterministe).

Comme d'habitude pour INTERCAL, ceci prend une entrée numérique dans le format, par exemple, ONE TWO THREEpour 123.

Explication

En cas d'erreur de sortie d'un programme C-INTERCAL, l'état de sortie est le code d'erreur modulo 256. Par conséquent, nous pouvons essayer d'écrire un programme capable de générer autant d'erreurs d'exécution que possible. Ce programme n'omet que deux erreurs d'exécution qui n'indiquent pas d'incident interne du compilateur: ICL200I, car sa reproduction nécessite l'utilisation de bibliothèques externes compatibles uniquement avec un programme à un seul thread (et les programmes multithreads ayant davantage d'erreurs disponibles); et ICL533I, car 533 a la même valeur modulo 256 que 277, et le programme est capable de produire ICL277I.

Le programme commence toujours de la même manière. Tout d'abord, nous entrons ( WRITE IN) une valeur pour la variable .1. Ensuite, nous utilisons une CREATEinstruction calculée pour créer une nouvelle syntaxe (ici, A); mais comme il est calculé, la définition de la syntaxe varie en fonction de la valeur de .1. Enfin, dans la plupart des cas, nous exécutons notre nouvelle Ainstruction, qui a été définie pour produire une erreur. Le tableau des définitions possibles que nous avons contient une définition pour chaque erreur d'exécution possible (autres que les exceptions énumérées ci-dessus).

Premièrement, il y a deux exceptions à ce régime général. (0)n’est pas un numéro de ligne valide. Par conséquent, si l’utilisateur saisit ZERO, nous passons de la deuxième ligne (numérotée (8)) à la quatrième à l’aide d’une COME FROMinstruction calculée . Cela tombe ensuite dans une erreur de syntaxe DO X, qui produit une erreur ICL000I. (Dans INTERCAL, les erreurs de syntaxe se produisent lors de l'exécution, du fait que les commandes ont tendance à être désactivées, la syntaxe à être redéfinie sous vous, etc.). L' COME FROMinstruction a également un effet secondaire, même si rien ne COME FROMse passe réellement , en créant une surcharge d'opérande de .1à #1chaque fois qu'une ligne avec un numéro de ligne est exécutée; ceci est utilisé plus tard lors de la production de la sortie 21. (Les effets secondaires globaux aléatoires sont assez idiomatiques dans INTERCAL.)

L'autre exception est avec entrée ONE TWO NINE. Il n'y a pas de numéro de ligne (129)dans le programme, nous obtenons donc une erreur pour un numéro de ligne manquant, qui est ICL129I. Donc, je n'ai pas eu à écrire de code pour couvrir ce cas du tout.

Voici les autres erreurs et leurs causes:

• 123 est un NEXTdébordement de pile ( DO (123) NEXT). L' NEXTinstruction a besoin d'autres modificateurs ( FORGETou RESUME) afin de déterminer de manière rétroactive de quel type d'instruction de contrôle il s'agissait. N'ayant pas ces causes, l'erreur ICL123I une fois qu'il existe 80 instructions `NEXT non résolues.
• 222 est un débordement de mémoire ( DO STASH .2en COME FROMboucle). Les caches ne sont limités que par la mémoire disponible, mais celle-ci finira par s'épuiser, provoquant l'erreur ICL222I.
• 240 est dimensions un tableau à la taille zéro. C’est exactement ce que cela DO ,1 <- #0signifie, et cela provoque l’erreur ICL240I.
• 241 est causée par l’affectation en dehors des limites d’un tableau. Dans ce cas, ,1n'a pas été alloué ( ,est utilisé pour les variables de type tableau dans INTERCAL), son indexation génère donc l'erreur ICL241I.
• 19 affecte 65536 ( #256 $ #0) à une variable de 16 bits .2. Cela ne convient pas, provoquant l'erreur ICL275I.
• 21 attribue #2à .1. Cela peut sembler être une tâche assez simple, mais nous avons surchargé .1le sens #1précédent, et tenter de modifier la valeur de 1 sans -voption sur la ligne de commande provoque l’erreur ICL277I.
• 148 tentatives pour revenir à l'entrée supérieure de la pile de choix ( GO BACK), qui n'existe pas à ce stade du programme (nous n'avons exécuté aucune commande pour manipuler la pile de choix, elle est donc toujours vide). Cela provoque l'erreur ICL404I.
• 180 tentatives à RETRIEVE .2partir d'une réserve inexistante (car nous n'avons rien caché dans cette branche du programme), provoquant l'erreur ICL436I.
• 50 requêtes input ( WRITE IN) pour toujours dans une COME FROMboucle. Finalement, nous finirons par lire après EOF, provoquant l'erreur ICL562I.
• 109 exécute l'instruction DO RESUME #0, qui n'a pas de sens et est spécifiquement documentée comme provoquant une erreur (ICL621I).
• 120 exécute la déclaration DO RESUME #9. Nous n'avons pas encore exécuté beaucoup d' NEXTénoncés et nous avons donc l'erreur ICL120I. (Curieusement, cette erreur particulière est définie dans la documentation INTERCAL comme quittant le programme normalement puis causant l'erreur, plutôt que de quitter le programme avec une erreur. Je ne crois cependant pas que ces deux cas soient différents.)
• 223 est fondamentalement un enchevêtrement complexe de primitives multithreading qui pointent toutes vers la ligne 223, provoquant une boucle infinie qui gonfle la mémoire. Éventuellement, le sous-système multithreading s’épuise en mémoire, ce qui entraîne l’erreur ICL991I.
• 121 est en fait une déclaration valide (c'est un commentaire), mais elle apparaît à la fin du programme. En tant que tel, l'exécution tombe à la fin du programme immédiatement après son exécution, ce qui provoque l'erreur ICL633I.

Vérification

Certaines des erreurs impliquent d'exécuter intentionnellement le programme avec peu de mémoire. Je suggère donc de définir des limites de mémoire assez petites. Voici la commande shell que j'ai utilisée pour tester le programme (avec de nouvelles lignes ajoutées pour la lisibilité; supprimez-les si vous l'exécutez vous-même):

for x in "ZERO" "ONE NINE" "TWO ONE" "FIVE ZERO" "ONE ZERO NINE"
         "ONE TWO ZERO" "ONE TWO ONE" "ONE TWO THREE" "ONE TWO NINE"
         "ONE FOUR EIGHT" "ONE EIGHT ZERO" "TWO TWO TWO"
         "TWO TWO THREE" "TWO FOUR ZERO" "TWO FOUR ONE";
do  echo;
    echo $x;
    echo $x | (ulimit -Sd 40000; ulimit -Sv 40000; ulimit -Ss 40000;
               ./errors; echo $?);
done

Et voici le résultat (avec les numéros de ligne et les messages "VEUILLEZ CORRIGER LA SOURCE" supprimés pour économiser de l'espace), que j'ai ajouté en partie pour montrer que le programme fonctionne, mais surtout pour afficher les messages d'erreur stupides d'INTERCAL:

ZERO
ICL000I PLEASEWRITEIN.1(8)PLEASECREATE.1APLEASEAPLEASECOMEFROM#2$!1/#1'DOX(123)DO(123)NEXTDOCOMEFROM(222)(222)DOSTASH.2(240)DO,1<-#0(241)DO,1SUB#0<-#1(19)DO.2<-#256$#0(21)DO.1<-#2(148)DOGOBACK(180)DORETRIEVE.2DOCOMEFROM(50)(50)DOWRITEIN.2(109)DORESUME#0(120)DORESUME#9MAYBECOMEFROM(223)(223)DOCOMEFROM(223)(121)PLEASENOTX
0

ONE NINE
ICL275I DON'T BYTE OFF MORE THAN YOU CAN CHEW
19

TWO ONE
ICL277I YOU CAN ONLY DISTORT THE LAWS OF MATHEMATICS SO FAR
21

FIVE ZERO
ICL562I I DO NOT COMPUTE
50

ONE ZERO NINE
ICL621I ERROR TYPE 621 ENCOUNTERED
109

ONE TWO ZERO
ICL632I THE NEXT STACK RUPTURES.  ALL DIE.  OH, THE EMBARRASSMENT!
120

ONE TWO ONE
ICL633I PROGRAM FELL OFF THE EDGE
121

ONE TWO THREE
ICL123I PROGRAM HAS DISAPPEARED INTO THE BLACK LAGOON
123

ONE TWO NINE
ICL129I PROGRAM HAS GOTTEN LOST
129

ONE FOUR EIGHT
ICL404I I'M ALL OUT OF CHOICES!
148

ONE EIGHT ZERO
ICL436I THROW STICK BEFORE RETRIEVING!
180

TWO TWO TWO
ICL222I BUMMER, DUDE!
222

TWO TWO THREE
ICL991I YOU HAVE TOO MUCH ROPE TO HANG YOURSELF
223

TWO FOUR ZERO
ICL240I ERROR HANDLER PRINTED SNIDE REMARK
240

TWO FOUR ONE
ICL241I VARIABLES MAY NOT BE STORED IN WEST HYPERSPACE
241

Perl, 108 octets, 256 codes de sortie

Ce programme (ab) utilise le module Test :: More . Il essaie d'ouvrir le fichier nommé "" n fois où n est donné comme argument de ligne de commande. Il échoue à chaque fois et chaque appel est traité comme un test. Test :: More renvoie le nombre de tests ayant échoué comme code de sortie. plan tests => $ARGV[0]%255est nécessaire pour obtenir le code de sortie 255.

#!/usr/bin/perl
use Test::More;
plan tests => $ARGV[0]%255 if($ARGV[0]>0);
ok(open(F,"")) for (1..$ARGV[0])

C90 (gcc), 256 codes de sortie, 28 27 18 octets

main(){getchar();}

Je ne sais pas si cela est intelligent ou cheaty, mais je ne pense pas qu'il viole les règles que par écrit: il ne techniquement utilise pas exit, returnou tout mécanisme lancer erreur, mais simplement sur le comportement repose non défini et le fait que gcc fait quelque chose d'assez pratique en ce qui concerne ce défi.

Essayez-le en ligne!

Comment ça fonctionne

Cela utilise simplement getcharpour lire un octet de STDIN. En soi, cela ne fait rien.

Cependant, un programme C90 conforme doit se terminer par une returndéclaration ou quelque chose d’équivalent; tout le reste est un comportement indéfini. gcc termine l'assembly généré avec un retanyway, donc quelle que soit la valeur trouvée dans le registre, EAX sera renvoyé par le programme. Heureusement, glibc's getcharstocke l'octet lu à partir de STDIN dans EAX. La valeur de cet octet est donc le code de sortie de notre programme.

C (gcc) sous shell bash sur x86, 230 octets, 8 codes de sortie

Ajout de nouvelles lignes pour améliorer la lisibilité. Commentaires ignorés dans le score.

main(int c, char **v){
int p[2];
switch(atoi(v[1])-128){
case 2:__asm("UD2");        /* SIGILL: x86 undefined instruction */
case 5:__asm("int $3");     /* SIGTRAP: x86 breakpoint instruction */
case 6:abort();             /* SIGABRT: raise() is called under the covers */
case 8:c/=c-2;              /* SIGFPE: divide by 0 (c-2) */
case 11:c=*(int *)c;        /* SIGSEGV: dereference of invalid pointer */
                            /* SIGPIPE: write() to a pipe closed at the other end */
case 13:socketpair(1,1,0,p);close(p[1]);write(p[0],v,1);
case 14:alarm(1);sleep(2);  /* SIGALRM: kernel will send alarm signal after 1 sec */
}
}

Une caractéristique du shell bash:

Lorsqu'une commande se termine sur un signal fatal N, bash utilise la valeur 128 + N comme état de sortie.

Il suffit donc de déclencher divers signaux dans le programme ca À ce stade, je suppose que faire simplement kill(n-128);est interdit. Donc, au lieu de cela, nous exécutons du code qui déclenche divers signaux, ce qui entraîne la mise à disposition des codes d'erreur correspondants sur le shell appelant.

Les codes de sortie sont 0, 130, 133, 134, 136, 139, 141, 142.

Essayez-le en ligne . Développez la section "Débogage" pour voir le code de retour.

Cela peut certainement être joué plus profondément. Mais je serais plus intéressé à ajouter plus de signaux.

Python 2, 13 octets, 2 codes de sortie

1/(input()-1)

Si vous entrez 0, il essaie d’imprimer 1/-1ce qui est -1, ce qui est parfaitement correct, ainsi le code de sortie 0. Si vous entrez 1, vous obtenez 1/0ce qui soulève un ZeroDivisionErrordans lequel il y a un code de sortie de 1. Avec mon IDE, il n’ya que 0 et 1 pour les codes de sortie ...

Les sorties:

PHP, 15 octets, 2 codes de sortie

Sans die/ exit, PHP ne peut rien retourner d'autre que 0ou 255(autant que je sache, probablement ~1), alors ...

!$argv[1]?:p();

Si l'argument de ligne de commande est faux, il est évalué à 1et se ferme avec 0. Sinon, il essaie d'appeler une fonction et quitte avec <b>Fatal error</b>: Uncaught Error: Call to undefined function p().

Courez avec -r.

Excel VBA, _{414 514} 533 + 3 octets, 14 codes de sortie

Prend entrée en tant que Conditional Compilation Argument, n=[input value]et produit le code d'erreur associé de ce nombre.

Sub e()
Dim a As Application, b As Byte, s As String, v(), x
Set a=Application
#If n=3 Then
Return
#ElseIf n=5 Then
b=a.CommandBars("")
#ElseIf n=6 Then
b=2^8
#ElseIf n=7 Then
ReDim v(9^9)
#ElseIf n=9 Then
v=Sheets("")
#ElseIf n=10 Then
v=Array(1)
For Each x In v
ReDim v(9)
Next
#ElseIf n=11 Then
b=1/0
#ElseIf n=13 Then
Debug.?Int("X")
#ElseIf n=14 Then
Debug.?String(9E8,1)
#ElseIf n=20 Then
Resume
#ElseIf n=28 Then
f 256
#ElseIf n=35 Then
Call c
#ElseIf n=92 Then
For Each x In v
ReDim v(9)
Next
#ElseIf n=94 Then
b=Null
#End If
End Sub

Sub f(n):DoEvents:f n-1:End Sub

+3 pour l' n=[Value]appel de compilation conditionnelle

Gère les entrées où n=

3
5
6
7
9
10
11
13
14
20
28
35
92
94    

Remarque: VBA n’a pas de code de sortie 0ou 1. J'ai inclus les solutions pour 3et 5, qui sont les deux codes de sortie numérotés les plus bas disponibles pour VBA à leur place

Tourtèdre, 4 octets, 2 codes de sortie

Je ne sais pas s'il existe un moyen d'obtenir plus de codes de sortie ... existe-t-il encore d'autres moyens dans la langue de l'interprète?

J'ai trouvé quelques réponses de quatre longueurs

' ?;

Essayez-le en ligne!

!.(0

Essayez-le en ligne!

?;(*

Essayez-le en ligne!

Comment ça marche:

' ?;

dans mon interprète, il existe une fonctionnalité de bogue qui provoque des erreurs lorsque la grille en mémoire a plus d'une ligne et ne contient pas de caractères non-espace. ce programme efface le * de la cellule d'origine '[space], prend une entrée entière non négative ?(0 ou 1 en réalité), et descend de ce nombre ;, si elle est nulle, la grille n'aura qu'une seule ligne et pas d'erreur, sinon elle descendra et l'erreur se produira

!.(0

les parenthèses et les éléments ne sont pas analysés, ils sont simplement exécutés au moment de l’exécution pour signifier: "passez au paren correspondant, si le symbole de la cellule n’est pas correct". dans ce programme, inputting ( !) amène le programme à l'écrire dans la cellule ( .), exécute le paren, qui vérifie si le symbole de la cellule est 0, essaie de passer au paren correspondant, mais renvoie une erreur car il n'y en a pas. . s'il est égal à zéro, il l'écrit, vérifie les parenthèses, se retrouve sur un 0, puis l'ignore et le programme se termine

?;(*

a des éléments de la réponse précédente, et le premier. il prend une entrée entière non négative, décale ce nombre et vérifie si la cellule est '*', en recherchant un parent supplémentaire non existant s'il ne l'est pas. si l'entrée est 1, il se déplacera hors de l'espace de départ et trouvera que la cellule est un espace. Si elle est égale à zéro, la cellule restera dans l'espace de début et ignorera le paren.

Javascript (noeud), 19 octets, 2 codes de sortie

Programme complet:

+process.argv[2]&&a

Une fonction:

f=i=>i&&f(i)

process.argvest un tableau contenant le chemin d'accès à l'exécutable du noeud, le chemin d'accès au fichier javascript exécuté et les arguments de ligne de commande. Dans ce cas, ce sera soit "1"ou "0". La chaîne est convertie en un nombre avec l' +opérateur unaire . Si le nombre est égal à zéro, l' &&opérateur lazy n'évaluera pas le côté droit. Si le nombre est vrai (et non zéro), le côté droit de &&est évalué et une erreur est générée car il fait référence à une variable non définie et le programme existe. avec le code de sortie 1.

La fonction attend l'entrée sous forme de nombre. Si l'entrée est véridique, la fonction s'appelle elle-même et bloque l'exécution du noeud avec un débordement de pile. Si l'entrée est 0, l' &&opérateur différé renvoie 0 sans évaluer le côté droit.

Perl 6 , 57 octets, 256 codes de sortie

use Test;plan $_=@*ARGS[0];ok try {open ""} for ^($_%255)

Essayez-le
Ceci est une traduction de l'exemple Perl 5.

Étendu

use Test;  # bring in ｢plan｣ and ｢ok｣

plan $_ = @*ARGS[0]; # plan on having the input number of tests
                     # only actually needed for the 255 case
                     # if the plan is greater than the number of tests
                     # it fails with exitcode 255


  ok                 # increment the failure counter if the following is False
    try {            # don't let this kill the whole program
      open ""        # fails to open a file
    }

for                  # repeatedly do that

  ^(                 # upto Range
    $_ % 255         # either the input number of times, or 0 times for 255
  )

Scala, 19 octets, 2 codes de sortie

if(args(0)=="1")1/0

1/(args(0).toInt-1)

La JVM ne prend en charge que les codes de sortie 1 et 0 si vous n'appelez pas System.exit.

Le premier programme essaie de calculer 1/0si le premier argument est 1, ce qui plantera la JVM avec un code de sortie de 1. Si l'argument est 0, il se terminera avec succès.

Le second programme convertit l'argument en entier, en soustrait un et tente de diviser 1 par ce nombre. Si l'argument est égal à 1, 1/0la machine virtuelle Java se bloque; si l'argument est 0, il calcule 1/-1et quitte.

Python 3 , 15 octets, 2 codes de sortie

Évidemment, c'est plus long que la solution Python 2 , car dans Python 3, nous ne pouvons pas prendre une entrée littérale sans appeler eval. Cependant, nous pouvons utiliser des techniques de comparaison de chaînes de manière intéressante ...

1/(input()<'1')

L'entrée sera soit la chaîne, 0soit 1- si elle vaut 1, la condition est évaluée à 0 (faux), ce qui entraîne une tentative de calcul 1 / 0qui se bloque évidemment (code de sortie 1). Sinon, rien ne se passe et Python se ferme avec le code de sortie normal 0.

Autant que je sache, Python est incapable de planter avec d'autres codes de sortie.

Java, 71 66 octets, 2 codes de sortie

4 octets économisés grâce à Holger

Programme complet:

interface I{static void main(String[]a){a[a[0].charAt(0)-48]="";}}

Fonction prenant un int comme argument:

i->1/(i-1)

Le programme utilise le premier caractère du premier argument (ou '0'ou '1'et soustrait 48 (valeur ascii de '0') pour obtenir un entier (0 ou 1). Il tente ensuite de définir l'argument situé à l'emplacement de cet entier sur la chaîne vide. l'entrée est 1, le programme se bloque avec un ArrayIndexOutOfBoundsException, parce que le tableau d'arguments n'a qu'un seul élément à la position 0 (index zéro).

Python 2, 11 octets, 2 codes de sortie

1>>-input()
1/~-input()
0<input()<x

Trois solutions différentes à 11 octets pour trois erreurs différentes! (Juste pour le plaisir, cela ne donne pas de points.) Par défaut, Python n'a que les codes de sortie 0 pour une sortie réussie et 1 pour une erreur. Les exécutions réussies ne produisent rien.

 1>>-input()

Sur l'entrée 1, donne "ValueError: compte de décalage négatif". Sur l'entrée 0, un décalage de zéro réussit et donne 1.

1/~-input()

Sur l'entrée 1, donne "ZeroDivisionError: division entière ou modulo par zéro" en raison de ~-input(), alias input()-10. Dans l'entrée 1, 1/-1donne -1. 0**-input()fonctionnerait aussi.

0<input()<x

Sur l'entrée 1, donne "NameError: le nom 'x' n'est pas défini". Sur l'entrée 0, cette première inégalité 0<0est évaluée à False, le reste n'est pas évalué et le résultat est simplement False.

Node.js (ES6), 77 octets, 2 codes de sortie

require('readline').createInterface({input:process.stdin}).prompt("",i=>i&&x)

Gelée , 4 codes de sortie, 18 octets

߀
2*
Ṁ¹Ŀ
RÇĿỌḊ?R

Prend en charge les codes de sortie 0 , 1 , 137 (tué) et 139 (erreur de segmentation).

Essayez-le en ligne!

Comment ça fonctionne

RÇĿỌḊ?R  Main link. Argument: n (integer)

R        Range; yield [1, ..., n] if n > 1 or [] if n = 0.
    Ḋ?   If the dequeued range, i.e., [2, ..., n] is non-empty:
 Ç         Call the third helper link.
  Ŀ        Execute the k-th helper link, where k is the the integer returned by Ç.
         Else, i.e., if n is 0 or 1:
   Ọ       Unordinal; yield [] for n = 0 and "\x01" for n = 1.
      R  Range. This maps [] to [] and causes and error (exit code 1) for "\x01".


Ṁ¹Ŀ      Third helper link. Argument: r (range)

Ṁ        Maximum; retrieve n from r = [1, ..., n].
 ¹Ŀ      Call the n-th helper link (modular).
         When n = 139, since 139 % 3 = 1, this calls the first helper link.
         When n = 137, since 137 % 3 = 2, this calls the second helper link.


2*       Second helper link. Argument: k

2*       Return 2**k.
         Since 2**137 % 3 = 174224571863520493293247799005065324265472 % 3 = 2,
         ÇĿ in the main link will once again call the second helper link.
         Trying to compute 2**2**137, a 174224571863520493293247799005065324265472-
         bit number, will get the program killed for excessive memory usage.


߀       First helper link. Argument: k

߀       Recursively map the first helper link over [1, ..., k].
         This creates infinite recursion. Due to Jelly's high recursion limit,
         a segmentation fault will be triggered.

SmileBASIC, 640 octets, 39 codes de sortie (sur 52)

SPSET.,0INPUT C$GOTO"@"+C$@0
STOP@3
A
@4
CLS.@5@A
GOSUB@A@7?1/A@8
X$=3@9
A%=POW(2,31)@10
BEEP-1@11
DIM B[#ZL*#R]@13
READ A
@15
V"OPTION STRICT?X
@16
CALL@D@17
V@A*2
@18
V"VAR A,A
@19
V"DEF A:END:DEF A
@20
V"FOR I=0TO
@21
V"NEXT
@22
V"REPEAT
@23
V"UNTIL
@24
V"WHILE.
@25
V"WEND
@26
V"IF.THEN
@27
V"IF.THEN"+CHR$(10)+"ELSE
@28
V"ENDIF
@29
V"DEF X
@30
RETURN@31
DIM E[-1]@32
V"DEF A:DEF
@34
GOTO"|
@36
XOFF MIC
MICSTOP
@37
XOFF MOTION
GYROSYNC
@38
PRGDEL
@39
DIM F[66]SPANIM.,1,F
@40
DIM G[2]SPANIM.,1,G
@42
MPSTART 2,@A@L
MPSEND"A"GOTO@L@44
PROJECT
@46
USE"PRG1:A
@47
BGMPLAY"`
@48
X=
@51
DLCOPEN"
DEF V C
PRGEDIT 1PRGDEL-1PRGSET C
EXEC 1
END

Cela pourrait certainement être raccourci. SB n'a que des codes d'erreur de 0 à 51, et certains sont impossibles à déclencher.

ZX81 BASIC> 255 codes de sortie - 52 octets (liste)

1 INPUT N
2 GOTO 1+(2*(N>0 AND N <=255))
3 PRINT "EXIT CODE ";N
4 RAND USR N

Techniquement, il Npourrait s'agir d'un nombre à 24 bits dans la plage, mais nous supposerons ici des entiers. La ligne 2 est équivalente à IF N>0 AND N <=255 THEN GOTO 3: ELSE GOTO 1si ZX81 BASIC avait IF/ELSEdans ses instructions symboliques.