Inspirado por este padrão para IO .

A tarefa

Escreva um programa que, dado um número inteiro de entrada xentre 0 e 255, trava com o código de saída x.

Restrições

• Você não pode chamar nada que seja destinado diretamente à saída do código de saída ( System.exit(x), retornando de mainetc.). Em vez disso, seu programa deve causar um erro ou falha que fará com que, com uma probabilidade de 1, o programa saia com o número inteiro de entrada.
  • Nesse caso, as palavras "erro" e "falha" significam que o programa causou alguma exceção fatal não intencional, em que um método, operação ou outro foi usado incorretamente que causou uma falha irreversível.
  • Você não pode causar o erro diretamente, lançando-o diretamente. Você deve causá-lo usando um método, função ou outro objeto cuja finalidade atenda a uma função diferente (por exemplo, tentar executar uma gravação de arquivo em um diretório somente leitura).
• Você deve ter pelo menos dois códigos de saída contabilizados em seu programa.
• O término do processo com o uso de sinais é proibido. (O raciocínio pode ser encontrado nesta discussão )

Pontuação

A pontuação do seu programa é determinada pelo número de códigos de saída suportados, nos quais a concisão do código é desempatador. O maior número de códigos de saída suportados vence!

Shell Unix (+ ncurses + utilitários BSD), 36., 26 bytes, 256 códigos de saída

Golfe

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

Se a opção -S for usada, o tput verificará erros de cada linha e, se houver algum erro, definirá o código de saída como 4 mais o número de linhas com erros. Se nenhum erro for encontrado, o código de saída é 0. Nenhuma indicação de qual linha falhou pode ser fornecida, portanto o código de saída 1 nunca será exibido. Os códigos de saída 2, 3 e 4 mantêm sua interpretação usual.

Uma vez que o código de saída do tput ultrapassa 255, ele simplesmente transborda, então 253 (erros na entrada) resultará no código de saída de 1 etc., produzindo assim o status de saída desejado para todo o intervalo de entradas.

Nota : se o tput falhará, ao definir / obter um recurso específico, depende do tipo de terminal, usei:xterm with 256 colors

jot é um utilitário BSD , que imprime dados seqüenciais ou aleatórios e (AFAIK) também está disponível imediatamente nos sistemas OSX.

Se o seu sistema não tiver jotdisponível, você poderá usar uma versão ligeiramente mais longa (29 bytes):

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

Experimente Online! (a versão de 29 bytes)

Bash 4.2 + extras, 24 códigos de saída

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

Obrigado a @ KenY-N por 3 códigos de saída. Obrigado a @ el.pescado por 1 código de saída.

Verificação

Todos os testes foram realizados no 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

Experimente online!

Todo espaço em branco aqui é irrelevante. (O programa original continha guias, mas eu as converti em espaços para que se alinhassem corretamente no SE; é convencional usar uma largura de guia 8 para INTERCAL. Testei uma versão do programa com todas as guias, espaços , e novas linhas excluídas, e funciona bem.)

Compile com -abm(penalidade de 2 bytes, porque -bé necessário para o compilador ser determinístico).

Como de costume para INTERCAL, isso requer entrada numérica no formato, por exemplo, ONE TWO THREEpara 123.

Explicação

Quando um programa C-INTERCAL erra, o status de saída é o código de erro módulo 256. Como resultado, podemos ter como objetivo escrever um programa capaz de produzir o maior número possível de erros de tempo de execução. Este programa omite apenas dois erros de tempo de execução que não indicam problemas internos do compilador: ICL200I, porque sua reprodução requer o uso de bibliotecas externas que são compatíveis apenas com um programa de thread único (e os programas multithread têm mais erros disponíveis); e ICL533I, porque 533 tem o mesmo valor de módulo 256 que 277 e o programa é capaz de produzir ICL277I.

O programa sempre começa da mesma maneira. Primeiro, inserimos ( WRITE IN) um valor para a variável .1. Então, usamos uma CREATEdeclaração computada para criar nova sintaxe (aqui, A); mas, como é calculado, a definição da sintaxe varia com base no valor de .1. Finalmente, na maioria dos casos, executamos nossa nova Ainstrução, que foi definida para produzir um erro; a tabela de definições possíveis que temos contém uma definição para cada possível erro de tempo de execução (além das exceções listadas acima).

Primeiro, existem duas exceções a esse esquema geral. (0)não é um número de linha válido; portanto, se o usuário inserir ZERO, passamos da segunda linha (numerada (8)) para a quarta linha por meio de uma COME FROMinstrução computada . Isso então cai em um erro de sintaxe DO X, que produz um erro ICL000I. (No INTERCAL, os erros de sintaxe ocorrem no tempo de execução, devido à tendência de os comandos serem desabilitados, a sintaxe ser redefinida sob você, etc.). A COME FROMinstrução também tem um efeito colateral, mesmo que nada real COME FROMaconteça, criando uma sobrecarga de operando de .1para #1sempre que uma linha com um número de linha for executada; isso é usado posteriormente ao produzir a saída 21. (Efeitos colaterais globais aleatórios são bastante idiomáticos em INTERCAL.)

A outra exceção é com entrada ONE TWO NINE. Como não há número de linha (129)no programa, obtemos um erro para um número de linha ausente ICL129I. Portanto, não precisei escrever nenhum código para cobrir esse caso.

Aqui estão os outros erros e o que os causa:

• 123 é um NEXTestouro de pilha ( DO (123) NEXT). A NEXTinstrução precisa de outros modificadores ( FORGETou RESUME) para determinar retroativamente que tipo de instrução de controle era. Não ter o erro ICL123I dessas causas, uma vez que existem 80 instruções `NEXT não resolvidas.
• 222 é um estouro de estoque ( DO STASH .2em um COME FROMloop). Os stashes são limitados apenas pela memória disponível, mas isso acabará eventualmente, causando o erro ICL222I.
• 240 é dimensões de uma matriz para o tamanho zero. É exatamente isso que DO ,1 <- #0significa e causa o erro ICL240I.
• 241 é causado pela atribuição fora dos limites de uma matriz. Nesse caso, ,1não foi alocado ( ,é usado para variáveis ​​do tipo matriz em INTERCAL), portanto, a indexação causa o erro ICL241I.
• 19 atribui 65536 ( #256 $ #0) a uma variável de 16 bits .2. Não se encaixa, causando o erro ICL275I.
• 21 atribui #2a .1. Isso pode parecer uma atribuição bastante simples, mas sobrecarregamos .1para significar #1mais cedo, e tentar alterar o valor de 1 sem -vopção na linha de comandos causa o erro ICL277I.
• 148 tentativas de retornar à entrada superior da pilha do ponto de escolha ( GO BACK), que não existe neste momento no programa (não executamos nenhum comando para manipular a pilha do ponto de escolha, portanto ela ainda está vazia). Isso causa o erro ICL404I.
• 180 tentativas de RETRIEVE .2partir de um stash inexistente (porque não escondemos nada nesse ramo do programa), causando o erro ICL436I.
• 50 solicita input ( WRITE IN) para sempre em um COME FROMloop. Eventualmente, acabaremos lendo EOF passado, causando o erro ICL562I.
• 109 executa a instrução DO RESUME #0, que não tem sentido e está especificamente documentada como causando um erro (ICL621I).
• 120 executa a declaração DO RESUME #9. Ainda não executamos tantas NEXTinstruções e, portanto, obtemos o erro ICL120I. (Curiosamente, esse erro específico é definido na documentação INTERCAL como sair do programa normalmente e depois causar o erro, em vez de sair do programa com um erro. Porém, não acredito que esses dois casos sejam notavelmente diferentes.)
• 223 é basicamente um emaranhado complexo de primitivas multithreading que apontam para a linha 223, causando um loop infinito que explode memória. Eventualmente, há exaustão de memória no subsistema multithreading, levando ao erro ICL991I.
• 121 é realmente uma declaração válida (é um comentário), mas aparece no final do programa. Como tal, a execução cai no final do programa imediatamente após a execução, causando o erro ICL633I.

Verificação

Alguns dos erros envolvem a execução intencional da memória do programa, por isso sugiro definir limites de memória bastante pequenos. Aqui está o comando shell que eu usei para testar o programa (com novas linhas adicionadas para facilitar a leitura; exclua-as se você executá-lo):

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

E aqui está a saída (com os números de linha e as mensagens "POR FAVOR CORRETA SOURCE" excluídas para economizar espaço), que adicionei parcialmente para demonstrar o funcionamento do programa, mas principalmente para mostrar as mensagens de erro tolas da 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 saída

Este programa (ab) usa o módulo Test :: More . Ele tenta abrir o arquivo chamado "" n vezes em que n é fornecido como argumento da linha de comando. Ele falha sempre e cada chamada é tratada como um teste. Teste :: Mais número de retorno de testes com falha como código de saída. plan tests => $ARGV[0]%255é necessário para obter o código de saída 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 saída, 28 27 18 bytes

main(){getchar();}

Eu não tenho certeza se isso é inteligente ou cheaty, mas eu não acho que isso viola as regras como escrito: tecnicamente não usa exit, returnou qualquer erro mecanismo jogando, mas simplesmente depende de um comportamento indefinido eo fato de que gcc faz algo bastante conveniente no que diz respeito a esse desafio.

Experimente online!

Como funciona

Isso simplesmente usa getcharpara ler um byte do STDIN. Por si só, isso não faz nada.

No entanto, um programa C90 compatível deve terminar com uma returndeclaração ou algo equivalente; tudo o resto é comportamento indefinido. O gcc encerra a montagem gerada com um de retqualquer maneira, portanto, qualquer valor que tenha sido casual no registro EAX será retornado pelo programa. Felizmente, a glibc's getchararmazena o byte que lê de STDIN no EAX, então o valor desse byte é o código de saída do nosso programa.

C (gcc) no shell bash em x86, 230 bytes, 8 códigos de saída

Novas linhas adicionadas para facilitar a legibilidade. Comentários ignorados na pontuação.

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

Um recurso do shell bash:

Quando um comando termina em um sinal fatal N, o bash usa o valor de 128 + N como status de saída.

Então, tudo o que precisamos fazer é acionar vários sinais do programa CA. Neste ponto, suponho que simplesmente fazer kill(n-128);é banido. Então, em vez disso, executamos um código que aciona vários sinais, o que faz com que os códigos de erro correspondentes sejam disponibilizados no shell de chamada.

Os códigos de saída são 0, 130, 133, 134, 136, 139, 141, 142.

Experimente online . Expanda a seção "Debug" para ver o código de retorno.

Isso certamente pode ser jogado mais fundo. Mas eu estaria mais interessado em adicionar mais sinais.

Python 2, 13 bytes, 2 códigos de saída

1/(input()-1)

Se você digitar 0, ele tenta imprimir 1/-1qual é -1, o que é perfeitamente adequado, portanto, sai o código 0. Se você digitar 1, obtém o 1/0que aumenta a ZeroDivisionErrorno qual existe um código de saída 1. No meu IDE, há apenas 0 e 1 para os códigos de saída ...

Saídas:

PHP, 15 bytes, 2 códigos de saída

Sem die/ exit, o PHP não pode retornar nada, exceto 0ou 255(afaik; provavelmente ~1), então ...

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

Se o argumento da linha de comando for falso, ele avalia 1e sai com 0. Caso contrário, ele tenta chamar uma função e sai com <b>Fatal error</b>: Uncaught Error: Call to undefined function p().

Corra com -r.

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

Toma entrada como uma Conditional Compilation Argument, n=[input value]e produz código de erro associado desse 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]chamada de compilação condicional

Lida com entradas onde n=

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

Nota: O VBA não possui códigos de saída 0ou 1. Incluí as soluções para 3e 5, que são os dois códigos de saída numerados mais baixos disponíveis para o VBA

Turtlèd, 4 bytes, 2 códigos de saída

Não sei se existem maneiras de obter mais códigos de saída ... existem ainda outras formas no idioma do intérprete

Encontrei algumas respostas de quatro comprimento

' ?;

Experimente online!

!.(0

Experimente online!

?;(*

Experimente online!

Como estes funcionam:

' ?;

no meu intérprete, há um recurso de erro que causa erros quando a grade na memória possui mais de uma linha e não possui caracteres não espaciais. este programa apaga o * na célula de origem '[space], recebe uma entrada inteira não negativa ?(0 ou 1 realmente) e diminui a quantidade de ;zero, se for zero, a grade terá apenas uma linha e não haverá erro, caso contrário, será movida para baixo e o erro irá ocorrer

!.(0

parênteses e outras coisas não são analisados, eles são executados no tempo de execução para significar: "pule para o parêntese correspondente, se o símbolo da célula não estiver certo". Nesse programa, ao inserir ( !), o programa é gravado na célula ( .), executa o paren, que verifica se o símbolo da célula é 0, tenta pular para o paren correspondente, mas gera um erro, pois não há nenhum. . se for zero, anota, verifica os parênteses, se encontra em um 0 e depois o ignora, e o programa termina

?;(*

possui elementos da resposta anterior e a primeira. ele pega uma entrada inteira não negativa, diminui a quantidade e verifica se a célula é '*', procurando por um paren extra inexistente, caso contrário. se a entrada for 1, ela sairá do espaço inicial e descobrirá que a célula é um espaço e, se for zero, o erro permanecerá no espaço inicial e ignorará o parêntese.

Javascript (nó), 19 bytes, 2 códigos de saída

Programa completo:

+process.argv[2]&&a

Função:

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

process.argvé uma matriz que contém o caminho para o nó executável, o caminho para o arquivo javascript executado e os argumentos da linha de comando. Nesse caso, será "1"ou"0" . A sequência é convertida em um número com o unário+ operador . Se o número for zero, o &&operador preguiçoso não avaliará o lado direito, se o número for verdadeiro (não zero), o lado direito &&é avaliado e um erro é gerado porque faz referência a uma variável indefinida e o programa existe com o código de saída 1.

A função espera a entrada como um número. Se a entrada for verdadeira, a função se chamará e trava o tempo de execução do nó com um estouro de pilha. Se a entrada for 0, o &&operador lento retornará 0 sem avaliar o lado direito.

Perl 6 , 57 bytes, 256 códigos de saída

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

Tente
Esta é uma tradução do exemplo do 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 saída

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

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

A JVM suporta apenas 1 e 0 como códigos de saída, se você não ligar System.exit.

O primeiro programa tenta calcular 1/0se o primeiro argumento é1 , o que travará a JVM com um código de saída 1. Se o argumento for 0, ele será encerrado com êxito.

O segundo programa para converter o argumento em número inteiro, subtrai um e tenta dividir 1 por esse número. Se o argumento for 1, ele calcula 1/0, então a JVM falhará; se o argumento for 0, ele calcula 1/-1e sai.

Python 3 , 15 bytes, 2 códigos de saída

Obviamente, isso é mais longo que a solução Python 2 , porque no Python 3 não podemos receber uma entrada literal sem chamar eval. No entanto, podemos usar técnicas de comparação de seqüências de forma interessante ...

1/(input()<'1')

A entrada será a string 0ou 1- se for 1, a condição será avaliada como 0 (false), resultando em uma tentativa de computação 1 / 0que obviamente trava (código de saída 1). Caso contrário, nada acontece, e o Python sai com o código de saída regular 0.

Tanto quanto sei, o Python é incapaz de falhar com outros códigos de saída.

Java, 71 66 bytes, 2 códigos de saída

4 bytes economizados graças ao Holger

Programa completo:

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

Função assumindo um int como argumento:

i->1/(i-1)

O programa pega o primeiro caractere do primeiro argumentador ( '0'ou '1'e subtrai 48 (valor ASCII de '0') para obter um número inteiro (0 ou 1) e, em seguida, tenta definir o argumento na posição desse número inteiro para a sequência vazia. a entrada é 1, o programa trava com um ArrayIndexOutOfBoundsException, porque a matriz de argumentos possui apenas um elemento na posição 0 (indexado a zero).

Python 2, 11 bytes, 2 códigos de saída

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

Três soluções diferentes de 11 bytes para três erros diferentes! (Apenas por diversão, isso não dá pontos.) Por padrão, o Python só possui códigos de saída 0 para saída bem-sucedida e 1 para erro. As execuções bem-sucedidas não produzem nada.

 1>>-input()

Na entrada 1, fornece "ValueError: contagem de turnos negativos". Na entrada 0, uma contagem de turno zero é bem-sucedida e fornece 1.

1/~-input()

Na entrada 1, fornece "ZeroDivisionError: divisão inteira ou módulo por zero" devido a ~-input(), também conhecido input()-1como 0. Na entrada 1, 1/-1fornece -1. 0**-input()também funcionaria.

0<input()<x

Na entrada 1, fornece "NameError: o nome 'x' não está definido". Na entrada 0, essas primeiras desigualdades 0<0são avaliadas como Falso, portanto, o restante não é avaliado e o resultado é apenas Falso.

Node.js (ES6), 77 bytes, 2 códigos de saída

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

Gelatina , 4 códigos de saída, 18 bytes

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

Oferece suporte aos códigos de saída 0 , 1 , 137 (eliminados) e 139 (falha de segmentação).

Experimente online!

Como 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 saída (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

Definitivamente, isso poderia ser reduzido. O SB possui apenas códigos de erro de 0 a 51, e alguns são impossíveis de disparar.

ZX81 BASIC> 255 códigos de saída - 52 bytes (listagem)

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

Tecnicamente, Npode ser qualquer número de ponto flutuante de 24 bits dentro do intervalo, mas assumiremos números inteiros aqui. A linha 2 é equivalente a IF N>0 AND N <=255 THEN GOTO 3: ELSE GOTO 1se o ZX81 BASIC tivesse IF/ELSEem suas instruções simbólicas.