Inspirado por este valor predeterminado para IO .

La tarea

Escriba un programa que, dado un entero de entrada xentre 0 y 255, se bloquea con el código de salida x.

Restricciones

• No puede llamar a nada que esté destinado directamente a la salida del código de salida ( System.exit(x), regresar main, etc.). En cambio, su programa debe causar un error o bloqueo que causará, con una probabilidad de 1, que el programa salga con el entero de entrada.
  • En este caso, las palabras "error" y "bloqueo" significan que el programa causó alguna excepción fatal no deseada, en la que un método, operación o de otra manera se usó incorrectamente y causó una falla irreversible.
  • No puede causar el error directamente al lanzarlo directamente. Debe causarlo utilizando un método, una función u otro cuyo propósito tenga una función diferente (es decir, intentar ejecutar una escritura de archivo en un directorio de solo lectura).
• Debe tener al menos dos códigos de salida en su programa.
• La terminación del proceso con el uso de señales está prohibida. (El razonamiento se puede encontrar en esta discusión )

Puntuación

La puntuación de su programa está determinada por la cantidad de códigos de salida admitidos, donde la concisión del código es desempate. ¡El mayor número de códigos de salida admitidos gana!

Shell de Unix (+ ncurses + utilidades BSD), 36, 26 bytes, 256 códigos de salida

Golfed

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

Si se usa la opción -S, tput busca errores en cada línea y, si se encuentra algún error, establecerá el código de salida en 4 más el número de líneas con errores. Si no se encuentran errores, el código de salida es 0. No se puede indicar qué línea falló, por lo que el código de salida 1 nunca aparecerá. Los códigos de salida 2, 3 y 4 conservan su interpretación habitual.

Una vez que el código de salida de tput supera 255, simplemente se desborda, por lo que 253 (errores en la entrada) dará como resultado el código de salida de 1, etc., produciendo así el estado de salida deseado para todo el rango de entradas.

Nota : si tput fallará o no, al configurar / obtener una capacidad particular, depende del tipo de terminal, he usado:xterm with 256 colors

jot es una utilidad BSD , que imprime datos secuenciales o aleatorios, y (AFAIK) también está disponible de fábrica en los sistemas OSX.

Si su sistema no tiene jotdisponible, puede usar una versión un poco más larga (29 bytes):

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

¡Pruébelo en línea! (la versión de 29 bytes)

Bash 4.2 + extras, 24 códigos de salida

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

Gracias a @ KenY-N por 3 códigos de salida. Gracias a @ el.pescado por 1 código de salida.

Verificación

Todas las pruebas se han realizado en 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 códigos, 313 + 2 = 315 bytes

        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

Pruébalo en línea!

Todo el espacio en blanco aquí es irrelevante. (El programa original contenía pestañas, pero las convertí en espacios para que se alinearan correctamente en SE; es convencional usar un ancho de pestaña de 8 para INTERCAL. He probado una versión del programa con todas las pestañas, espacios , y las nuevas líneas eliminadas, sin embargo, y funciona bien).

Compilar con -abm(penalización de 2 bytes, porque -bse requiere que el compilador sea determinista).

Como de costumbre para INTERCAL, esto toma la entrada numérica en el formato, por ejemplo, ONE TWO THREEpara 123.

Explicación

Cuando un programa C-INTERCAL falla, el estado de salida es el código de error módulo 256. Como resultado, podemos apuntar a escribir un programa que sea capaz de producir tantos errores de tiempo de ejecución como sea posible. Este programa solo omite dos errores de tiempo de ejecución que no indican problemas internos del compilador: ICL200I, porque su reproducción requiere el uso de bibliotecas externas que solo son compatibles con un programa de subproceso único (y los programas multiproceso tienen más errores disponibles); e ICL533I, porque 533 tiene el mismo módulo de valor 256 que 277, y el programa es capaz de producir ICL277I.

El programa siempre comienza de la misma manera. Primero, ingresamos ( WRITE IN) un valor para la variable .1. Luego, usamos una CREATEdeclaración calculada para crear una nueva sintaxis (aquí, A); pero debido a que se calcula, la definición de la sintaxis varía según el valor de .1. Finalmente, en la mayoría de los casos ejecutamos nuestra nueva Adeclaración, que se ha definido para producir un error; La tabla de posibles definiciones que tenemos contiene una definición para cada posible error de tiempo de ejecución (que no sean las excepciones enumeradas anteriormente).

Primero, hay dos excepciones a este esquema general. (0)no es un número de línea válido, por lo que si el usuario ingresa ZERO, saltamos de la segunda línea (numerada (8)) a la cuarta línea por medio de una COME FROMdeclaración calculada . Esto luego cae en un error de sintaxis DO X, que produce un error ICL000I. (En INTERCAL, los errores de sintaxis ocurren en tiempo de ejecución, debido a la tendencia de los comandos a deshabilitarse, a redefinirse la sintaxis, etc.). La COME FROMdeclaración también tiene un efecto secundario, incluso si no hay real COME FROMocurre, la creación de una sobrecarga operando a partir .1de #1cada vez que se ejecuta una línea con un número de línea; esto se usa más adelante cuando se produce la salida 21. (Los efectos secundarios globales aleatorios son bastante idiomáticos en INTERCAL).

La otra excepción es con entrada ONE TWO NINE. No hay un número de línea (129)en el programa, por lo que obtenemos un error para un número de línea faltante, que es ICL129I. Así que no tuve que escribir ningún código para cubrir ese caso en absoluto.

Aquí están los otros errores y lo que los causa:

• 123 es un NEXTdesbordamiento de pila ( DO (123) NEXT). La NEXTdeclaración necesita otros modificadores ( FORGETo RESUME) para determinar retroactivamente qué tipo de declaración de control era. No tener esas causas causa el error ICL123I una vez que hay 80 sentencias `NEXT 'sin resolver.
• 222 es un desbordamiento de alijo ( DO STASH .2en un COME FROMbucle). Las reservas están limitadas solo por la memoria disponible, pero eventualmente se agotará, causando el error ICL222I.
• 240 es dimensiones de una matriz a tamaño cero. Eso es exactamente lo que DO ,1 <- #0significa, y causa el error ICL240I.
• 241 es causado por la asignación fuera de los límites de una matriz. En este caso, ,1no se ha asignado ( ,se usa para variables de tipo matriz en INTERCAL), por lo que la indexación causa el error ICL241I.
• 19 asigna 65536 ( #256 $ #0) a una variable de 16 bits .2. No encaja, causando el error ICL275I.
• 21 asigna #2a .1. Puede parecer una tarea lo suficientemente simple, pero sobrecargamos .1para significar #1antes, e intentar cambiar el valor de 1 sin -vopción en la línea de comando causa el error ICL277I.
• 148 intenta regresar a la entrada superior de la pila de puntos de elección ( GO BACK), que no existe en este punto del programa (no hemos ejecutado ningún comando para manipular la pila de puntos de elección, por lo que todavía está vacía). Eso causa el error ICL404I.
• 180 intentos RETRIEVE .2de un alijo inexistente (porque no escondimos nada allí en esta rama del programa), causando el error ICL436I.
• 50 solicitudes input ( WRITE IN) para siempre en un COME FROMbucle. Eventualmente terminaremos leyendo más allá de EOF, causando el error ICL562I.
• 109 ejecuta la declaración DO RESUME #0, que no tiene sentido y está documentada específicamente como causante de un error (ICL621I).
• 120 ejecuta la declaración DO RESUME #9. Todavía no hemos ejecutado tantas NEXTdeclaraciones y, por lo tanto, tenemos el error ICL120I. (Curiosamente, este error particular se define en la documentación de INTERCAL como salir del programa normalmente y luego causar el error, en lugar de salir del programa con un error. Sin embargo, no creo que estos dos casos sean notablemente diferentes).
• 223 es básicamente una maraña compleja de primitivas de subprocesos múltiples que apuntan de nuevo a la línea 223, causando un bucle infinito que explota la memoria. Finalmente, hay agotamiento de memoria en el subsistema de subprocesos múltiples, lo que lleva al error ICL991I.
• 121 es en realidad una declaración válida (es un comentario), pero aparece al final del programa. Como tal, la ejecución se cae al final del programa inmediatamente después de que se ejecuta, causando el error ICL633I.

Verificación

Algunos de los errores implican ejecutar intencionalmente el programa sin memoria, por lo que sugiero establecer límites de memoria bastante pequeños. Aquí está el comando de shell que usé para probar el programa (con nuevas líneas agregadas para facilitar la lectura; elimínelas si lo ejecuta usted mismo):

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

Y aquí está la salida (con los números de línea y los mensajes "POR FAVOR CORREGIR FUENTE" eliminados para ahorrar espacio), que agregué en parte para demostrar que el programa funciona pero principalmente para mostrar los tontos mensajes de error de 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 bytes, 256 códigos de salida

Este programa (ab) utiliza Test :: Más módulo. Intenta abrir un archivo llamado "" n veces donde n se proporciona como argumento de línea de comando. Falla cada vez, y cada invocación se trata como una prueba. Prueba :: Más número devuelto de pruebas fallidas como código de salida. plan tests => $ARGV[0]%255es necesario para obtener el código de salida 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 códigos de salida, 28 27 18 bytes

main(){getchar();}

No estoy seguro si esto es inteligente o cheaty, pero yo no creo que viola las reglas como por escrito: técnicamente no utiliza exit, returno cualquier error de tiro mecanismo, sino que simplemente se basa en un comportamiento indefinido y el hecho de que gcc hace algo bastante conveniente en lo que respecta a este desafío.

Pruébalo en línea!

Cómo funciona

Esto simplemente se usa getcharpara leer un byte de STDIN. Por sí solo, esto no hace nada.

Sin embargo, un programa C90 compatible debe terminar con una returndeclaración o algo equivalente; todo lo demás es comportamiento indefinido. gcc finaliza el ensamblado generado con un de rettodos modos, por lo que cualquier valor que se encuentre casualmente en el registro EAX será devuelto por el programa. Afortunadamente, glibc's getcharalmacena el byte que lee de STDIN en EAX, por lo que el valor de ese byte es el código de salida de nuestro programa.

C (gcc) bajo shell bash en x86, 230 bytes, 8 códigos de salida

Se agregaron nuevas líneas para facilitar la lectura. Comentarios ignorados en la puntuación.

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 */
}
}

Una característica del bash shell:

Cuando un comando termina en una señal fatal N, bash usa el valor de 128 + N como el estado de salida.

Entonces, todo lo que tenemos que hacer es activar varias señales desde el programa de CA. En este punto, supongo que simplemente kill(n-128);está prohibido hacerlo . Entonces, en su lugar, ejecutamos código que activa varias señales, lo que hace que los códigos de error correspondientes estén disponibles en el shell de llamada.

Los códigos de salida son 0, 130, 133, 134, 136, 139, 141, 142.

Pruébalo en línea . Expanda la sección "Depurar" para ver el código de retorno.

Esto ciertamente se puede jugar más profundo. Pero estaría más interesado en agregar más señales.

Python 2, 13 Bytes, 2 códigos de salida

1/(input()-1)

Si ingresa 0, intenta imprimir 1/-1cuál es -1, que está perfectamente bien, por lo tanto, salga del código 0. Si ingresa 1, obtiene el 1/0que eleva un ZeroDivisionErroren el que hay un código de salida de 1. Con mi IDE, solo hay 0 y 1 para los códigos de salida ...

Salidas:

PHP, 15 bytes, 2 códigos de salida

Sin die/ exit, PHP no puede devolver nada más que 0o 255(afaik; probablemente ~1), así que ...

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

Si el argumento de la línea de comando es falso, se evalúa 1y sale con 0. Si no, intenta llamar a una función y sale con <b>Fatal error</b>: Uncaught Error: Call to undefined function p().

Corre con -r.

Excel VBA, _{414 514} 533 + 3 bytes, 14 códigos de salida

Toma de entrada como una Conditional Compilation Argument, n=[input value]y produce código de error asociado de ese número.

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 para n=[Value]llamada de compilación condicional

Maneja entradas donde n=

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

Nota: VBA no tiene códigos de salida 0o 1. He incluido las soluciones para 3y 5, que son los dos códigos de salida con el número más bajo disponibles para VBA en su lugar

Turtlèd, 4 bytes, 2 códigos de salida

No sé si hay alguna forma de obtener más códigos de salida ... ¿hay incluso más formas en el idioma del intérprete?

Encontré algunas respuestas de cuatro

' ?;

Pruébalo en línea!

!.(0

Pruébalo en línea!

?;(*

Pruébalo en línea!

Cómo funcionan estos:

' ?;

en mi intérprete, hay una función de error que causa errores cuando la cuadrícula en la memoria tiene más de una línea y no tiene caracteres que no sean espacios. este programa borra el * en la celda de origen '[space], toma una entrada entera no negativa ?(0 o 1 realmente) y se mueve hacia abajo esa cantidad ;, si es cero, la cuadrícula solo tendrá una línea y no error, de lo contrario se moverá hacia abajo y ocurrirá el error

!.(0

los paréntesis y demás no se analizan, simplemente se ejecutan en tiempo de ejecución para significar: "salte al par coincidente, si el símbolo de celda no es correcto". en este programa, ingresar ( !) uno hace que el programa lo escriba en la celda ( .), ejecute el par, que verifica si el símbolo de celda es 0, intenta saltar al par correspondiente, pero en su lugar arroja un error ya que no hay ninguno . si es cero, lo anota, comprueba los paréntesis, se encuentra en un 0 y luego lo ignora, y el programa termina

?;(*

tiene elementos de la respuesta anterior y la primera. toma una entrada entera no negativa, baja esa cantidad y comprueba si la celda es '*', buscando un par extra no existente si no lo es. si la entrada es 1, se moverá fuera del espacio inicial, y encontrará que la celda es un espacio, y error, si es cero, permanecerá en el espacio inicial e ignorará el par.

Javascript (nodo), 19 bytes, 2 códigos de salida

Programa completo:

+process.argv[2]&&a

Función:

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

process.argves una matriz que contiene la ruta al ejecutable del nodo, la ruta al archivo javascript ejecutado y los argumentos de la línea de comandos. En este caso, esto será "1"o "0". La cadena se convierte en un número con el +operador unario . Si el número es cero, el &&operador diferido no evaluará el lado derecho, si el número es verdadero (no cero), se evalúa el lado derecho y se genera &&un error porque hace referencia a una variable indefinida, y el programa existe con código de salida 1.

La función espera la entrada como un número. Si la entrada es verdadera, la función se llama a sí misma y bloquea el tiempo de ejecución del nodo con un desbordamiento de pila. Si la entrada es 0, el &&operador diferido devuelve 0 sin evaluar el lado derecho.

Perl 6 , 57 bytes, 256 códigos de salida

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

Pruébelo
Esta es una traducción del ejemplo Perl 5.

Expandido

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 bytes, 2 códigos de salida

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

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

La JVM solo admite 1 y 0 como códigos de salida si no llama System.exit.

El primer programa intenta calcular 1/0si el primer argumento es 1, lo que bloqueará la JVM con un código de salida de 1. Si el argumento es 0, saldrá con éxito.

El segundo programa para convertir el argumento a entero, resta uno e intenta dividir 1 entre ese número. Si el argumento es 1, se calcula 1/0, por lo que la JVM se bloqueará; si el argumento es 0, calcula 1/-1y sale.

Python 3 , 15 bytes, 2 códigos de salida

Obviamente, esto es más largo que la solución Python 2 , porque en Python 3 no podemos tomar una entrada literal sin llamar eval. Sin embargo, podemos usar técnicas de comparación de cadenas de manera interesante ...

1/(input()<'1')

La entrada será la cadena 0o 1, si es 1, la condición se evalúa a 0 (falso), lo que resulta en un intento de cálculo 1 / 0que obviamente falla (código de salida 1). De lo contrario, no pasa nada y Python sale con el código de salida regular 0.

Que yo sepa, Python es incapaz de chocar con otros códigos de salida.

Java, 71 66 bytes, 2 códigos de salida

4 bytes guardados gracias a Holger

Programa completo:

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

Función tomando un int como argumento:

i->1/(i-1)

El programa toma el primer carácter del primer argumento (o '0'o '1'y resta 48 (valor ascii de '0') para obtener un número entero (0 o 1). Luego intenta establecer el argumento en la posición de ese número entero en la cadena vacía. la entrada es 1, el programa se bloquea con un ArrayIndexOutOfBoundsException, porque la matriz de argumentos solo tiene un elemento en la posición 0 (indexado a cero).

Python 2, 11 bytes, 2 códigos de salida

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

¡Tres soluciones diferentes de 11 bytes para tres errores diferentes! (Solo por diversión, esto no da puntos). Por defecto, Python solo tiene códigos de salida 0 para una salida exitosa y 1 para un error. Las ejecuciones exitosas no generan nada.

 1>>-input()

En la entrada 1, aparece "ValueError: conteo de desplazamiento negativo". En la entrada 0, un conteo de desplazamiento cero tiene éxito y da 1.

1/~-input()

En la entrada 1, aparece "ZeroDivisionError: división entera o módulo por cero" debido a ~-input(), también conocido input()-1como 0. En la entrada 1, 1/-1da -1. 0**-input()También funcionaría.

0<input()<x

En la entrada 1, aparece "NameError: el nombre 'x' no está definido". En la entrada 0, esta primera desigualdad 0<0se evalúa como False, por lo que el resto no se evalúa y el resultado es simplemente False.

Node.js (ES6), 77 bytes, 2 códigos de salida

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

Jelly , 4 códigos de salida, 18 bytes

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

Admite los códigos de salida 0 , 1 , 137 (muertos) y 139 (error de segmentación).

Pruébalo en línea!

Cómo funciona

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 bytes, 39 códigos de salida (de 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

Esto definitivamente podría hacerse más corto. SB solo tiene códigos de error de 0 a 51, y algunos son imposibles de activar.

ZX81 BASIC> 255 códigos de salida - 52 bytes (listado)

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

Técnicamente, Npodría ser cualquier número de coma flotante de 24 bits dentro del rango, pero aquí asumiremos números enteros. La línea 2 es equivalente a IF N>0 AND N <=255 THEN GOTO 3: ELSE GOTO 1si ZX81 BASIC tuviera IF/ELSEen sus instrucciones simbólicas.