Натхненний цим замовчуванням для IO .

Задача

Напишіть програму, яка з урахуванням цілого вхідного числа xміж 0 і 255 збивається з кодом виходу x.

Обмеження

• Ви не можете зателефонувати нічим, що призначено безпосередньо для виведення коду виходу ( System.exit(x)повернення з mainтощо). Натомість ваша програма повинна спричинити помилку або збій, що призведе до виходу програми з імовірністю 1.
  • У цьому випадку слова "помилка" та "збій" означають, що програма спричинила якийсь фатальний непередбачуваний виняток, де метод, операція чи іншим чином використовувався неправильно, що спричинило незворотний збій.
  • Ви не можете безпосередньо спричинити помилку, кинувши її безпосередньо. Ви повинні викликати це, використовуючи метод, функцію чи іншим способом, метою якого є інша функція (тобто спроба виконати запис файлу в каталог, доступний лише для читання).
• У вашій програмі має бути принаймні два коди виходу.
• Припинення процесу із застосуванням сигналів заборонено. (Обґрунтування може бути знайдено в цій дискусії )

Оцінка балів

Оцінка вашої програми визначається кількістю підтримуваних кодів виходу, де узгодженість коду є краваткою. Перемагає найбільша кількість підтримуваних кодів виходу!

Unix Shell (+ ncurses + утиліти BSD), 36, 26 байт, 256 кодів виходу

Гольф

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

Якщо використовується опція -S, tput перевіряє помилки з кожного рядка, і якщо виявлені помилки, встановить код виходу на 4 плюс кількість рядків з помилками. Якщо помилок не знайдено, код виходу становить 0. Не можна вказати, який рядок не вдався, тому код виходу 1 ніколи не з’явиться. Вихідні коди 2, 3 і 4 зберігають своє звичне тлумачення.

Як тільки код виходу tput перевищить 255, він просто переповнюється, тому 253 (помилки при введенні) призведе до коду виходу 1 тощо, таким чином, отримавши бажаний статус виходу для всього діапазону входів.

Примітка : чи не вдасться tput , якщо налаштування / отримання певної можливості залежить від типу терміналу, я використовував:xterm with 256 colors

jot - це утиліта BSD , яка друкує послідовні або випадкові дані, а (AFAIK) також доступна поза коробкою в системах OSX.

Якщо ваша система не jotдоступна, ви можете використовувати трохи більшу (29 байт) версію:

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

Спробуйте в Інтернеті! (версія 29 байт)

Bash 4.2 + додаткові елементи, 24 коди виходу

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

Завдяки @ KenY-N за 3 коди виходу. Завдяки @ el.pescado за 1 вихідний код.

Перевірка

Усі тести були виконані на 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 кодів, 313 + 2 = 315 байт

        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

Спробуйте в Інтернеті!

Весь пробіл тут не має значення. (Оригінальна програма містила вкладки, але я перетворив їх на пробіли, щоб вона правильно вибудовувалася в SE; звичайно використовувати ширину вкладок 8 для INTERCAL. Я протестував версію програми з усіма вкладками, пробілами , але нові рядки видалені, але це працює чудово.)

Компілюйте з -abm(2 байтовим штрафом, тому -bщо компілятор повинен бути детермінованим).

Як зазвичай для INTERCAL, для цього потрібно ввести числовий формат, наприклад, ONE TWO THREEдля 123.

Пояснення

Коли програма C-INTERCAL помиляється, статусом виходу є код помилки за модулем 256. В результаті ми можемо поставити за мету написати програму, яка здатна створювати якомога більше помилок виконання. Ця програма упускає лише дві помилки виконання, які не вказують на проблеми внутрішнього компілятора: ICL200I, оскільки для її відтворення потрібне використання зовнішніх бібліотек, сумісних лише з однопотоковою програмою (а багатопотокові програми мають більше помилок); і ICL533I, оскільки 533 має таке ж значення по модулю 256, як і 277, і програма здатна виробляти ICL277I.

Програма завжди починається однаково. Спочатку ми вводимо ( WRITE IN) значення для змінної .1. Потім ми використовуємо обчислений CREATEоператор для створення нового синтаксису (тут, A); але оскільки він обчислюється, визначення синтаксису змінюється залежно від значення .1. Нарешті, у більшості випадків ми запускаємо наше нове Aтвердження, яке було визначено для помилки; таблиця можливих визначень, яку ми маємо, містить визначення для кожної можливої ​​помилки виконання (крім винятків, перелічених вище).

По-перше, є дві винятки із цієї загальної схеми. (0)не є дійсним номером рядка, тому, якщо користувач вводить ZERO, ми переходимо з другого рядка (пронумерованого (8)) до четвертого рядка за допомогою обчисленого COME FROMоператора. Потім це потрапляє в синтаксичну помилку DO X, яка призводить до помилки ICL000I. (У системі INTERCAL помилки синтаксису трапляються під час виконання, через тенденцію відключення команд, переопределення синтаксису під вами тощо). COME FROMЗатвердження також має побічний ефект, навіть якщо фактична COME FROMне відбувається, створюючи перевантаження операнда з .1до #1всякий раз , коли рядок з номером рядка виконується; це використовується пізніше, коли виробляється вихід 21. (Випадкові глобальні побічні ефекти є досить ідіоматичними в INTERCAL.)

Інший виняток - із введенням даних ONE TWO NINE. У програмі немає номера рядка (129), тому ми отримуємо помилку щодо відсутнього номера рядка, який є ICL129I. Тож мені взагалі не довелося писати жодного коду, щоб висвітлити цю справу.

Ось інші помилки, і що їх викликає:

• 123 - NEXTпереповнення стека ( DO (123) NEXT). Оператору NEXTпотрібні інші модифікатори ( FORGETабо RESUME) для того, щоб заднім числом визначити, що це за оператор управління. Якщо не виникає цих причин помилка ICL123I, як тільки є 80 невирішених `NEXT-операцій.
• 222 - прихований перелив ( DO STASH .2у COME FROMциклі). Сховища обмежені лише наявною пам’яттю, але ця кількість закінчиться, що призведе до помилки ICL222I.
• 240 - розміри масиву до нуля. Саме це DO ,1 <- #0означає, і це викликає помилку ICL240I.
• 241 викликається призначенням поза межами масиву. У цьому випадку ,1не було виділено ( ,використовується для змінних типу масиву в INTERCAL), тому індексація викликає помилку ICL241I.
• 19 призначає 65536 ( #256 $ #0) 16-бітній змінній .2. Він не підходить, викликаючи помилку ICL275I.
• 21 призначає #2на .1. Це може виглядати як досить просте завдання, але ми перевантажені, .1щоб мати на увазі #1раніше, і спроба змінити значення 1 без жодної -vопції в командному рядку викликає помилку ICL277I.
• 148 спроб повернутися до верхнього запису стеку selectpoint ( GO BACK), який не існує на даний момент у програмі (ми не виконали жодних команд для маніпулювання стеком selectpoint, тому він все ще порожній). Це викликає помилку ICL404I.
• 180 спроб RETRIEVE .2з неіснуючого сховища (тому що ми нічого не зберігали там у цій гілці програми), викликаючи помилку ICL436I.
• 50 запитів введення ( WRITE IN) назавжди у COME FROMцикл. Врешті-решт ми закінчимо читання минулого EOF, викликаючи помилку ICL562I.
• 109 запускає твердження DO RESUME #0, яке безглуздо і спеціально задокументовано як спричинення помилки (ICL621I).
• 120 запускає твердження DO RESUME #9. Ми ще не виконали так багато NEXTтверджень, і таким чином ми отримуємо помилку ICL120I. (Цікаво, що ця конкретна помилка визначена в документації INTERCAL як нормально виходить із програми, а потім викликає помилку, а не виходить із програми з помилкою. Я не вважаю, що ці два випадки помітно відрізняються.)
• 223 - це в основному складний клубок багатопотокових примітивів, які всі вказують на лінію 223, викликаючи нескінченну петлю, яка підірває пам'ять. Зрештою, в багатопотоковій підсистемі відбувається виснаження пам'яті, що призводить до помилки ICL991I.
• 121 насправді є дійсним твердженням (це коментар), але воно з’являється в кінці програми. Таким чином, виконання відпадає від кінця програми відразу після її виконання, викликаючи помилку ICL633I.

Перевірка

Деякі помилки пов'язані з навмисним запуском програми з пам’яті, тому я пропоную встановити досить невеликі межі пам’яті. Ось команда оболонки, яку я використав для тестування програми (додано нові рядки для читабельності; видаліть їх, якщо запустити її самостійно):

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

І ось результат (з номерами рядків та повідомленнями "BLEASE CORRECT SOURCE" видалено, щоб заощадити місце), який я частково додав, щоб продемонструвати роботу програми, але, здебільшого, щоб показати нерозумні повідомлення про помилки 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 байт, 256 кодів виходу

Ця програма (ab) використовує модуль Test :: More . Він намагається відкрити файл, названий "" n разів, де n задається як аргумент командного рядка. Він виходить з ладу щоразу, і кожне виклик трактується як тест. Тест :: Більше повернення кількості невдалих тестів як код виходу. plan tests => $ARGV[0]%255потрібен для отримання вихідного коду 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 кодів виходу, 28 27 18 байт

main(){getchar();}

Я не впевнений , якщо це розумний або cheaty, але я не думаю , що він порушує правила , як написано: це технічно не використовується exit, returnабо будь-яка помилка метальні механізм, а просто спирається на невизначений поведінка , і той факт , що РСАДПЗ робить щось досить зручне, що стосується цього завдання.

Спробуйте в Інтернеті!

Як це працює

Це просто використовується getcharдля читання одного байту від STDIN. Саме по собі це нічого не робить.

Однак сумісна програма C90 повинна закінчуватися returnзаявою або чимось рівноцінним; все інше - невизначена поведінка. gcc retтак чи інакше закінчує генеровану збірку , тож яке б значення було випадково в реєстрі, EAX буде повернуто програмою. На щастя, glibc getcharзберігає байт, який він читає зі STDIN в EAX, тому значення цього байту є вихідним кодом нашої програми.

C (gcc) під bash shell на x86, 230 байт, 8 кодів виходу

Нові рядки додаються для сприяння читанню. Коментарі проігноровані в балах.

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

Особливість оболонки bash:

Коли команда закінчується на фатальному сигналі N, bash використовує значення 128 + N як статус виходу.

Отже, все, що нам потрібно зробити, це запустити різні сигнали всередині програми змінного струму. На даний момент я припускаю, що просто робити kill(n-128);заборонено. Тому замість цього ми виконуємо код, який запускає різні сигнали, через що відповідні коди помилок стають доступними в оболонці виклику.

Вихідні коди - 0, 130, 133, 134, 136, 139, 141, 142.

Спробуйте в Інтернеті . Розгорніть розділ «Налагодження», щоб побачити код повернення.

Це, звичайно, можна пограти в гольф глибше. Але мені було б цікавіше додавати більше сигналів.

Python 2, 13 байт, 2 вихідні коди

1/(input()-1)

Якщо ви вводите 0, він намагається надрукувати 1/-1значення -1, що прекрасно, таким чином, вийти з коду 0. Якщо ви введете 1, ви отримаєте, 1/0який піднімає a, ZeroDivisionErrorу якому є вихідний код 1. З мого IDE є лише 0 і 1 для вихідних кодів ...

Виходи:

PHP, 15 байт, 2 вихідних коду

Без die/ exitPHP не може повернути нічого, але 0або 255(afaik; можливо ~1), так що ...

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

Якщо аргумент командного рядка є хибним, він оцінює 1та виходить із 0. Якщо ні, то він намагається викликати функцію і завершує роботу <b>Fatal error</b>: Uncaught Error: Call to undefined function p().

Бігайте з -r.

Excel VBA, _{414 514} 533 + 3 байти, 14 кодів виходу

Приймає вхідний сигнал , як Conditional Compilation Argument, n=[input value]і виробляє пов'язаний код помилки для номера.

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 для n=[Value]умовного компіляційного дзвінка

Обробляє введення куди n=

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

Примітка: VBA не має кодів виходу 0або 1. Я включив рішення для 3та 5, які є двома найменшими кодами виходу, доступними VBA на їх місці

Turtlèd, 4 байти, 2 вихідні коди

Я не знаю, чи є якісь способи отримати більше вихідних кодів ... чи є ще якісь способи в мові перекладача

Я знайшов кілька чотирьох відповідей по довжині

' ?;

Спробуйте в Інтернеті!

!.(0

Спробуйте в Інтернеті!

?;(*

Спробуйте в Інтернеті!

Як це працює:

' ?;

в моєму інтерпретаторі є функція помилок, яка викликає помилки, коли сітка в пам’яті має більше одного рядка, і на ній немає пробілів. ця програма стирає * у початковій комірці '[space], приймає невід'ємне ціле введення ?(дійсно 0 або 1) і рухається вниз, що багато ;, якщо воно дорівнює нулю, сітка матиме лише один рядок, а не помилка, інакше вона рухатиметься вниз і станеться помилка

!.(0

круглі дужки та інше не розбираються, вони просто виконуються під час виконання, щоб означати: "перейти до відповідного батька, якщо символ комірки невірний". в цій програмі, вводячи ( !), викликає програму записати її у комірку ( .), виконати paren, який перевіряє, чи є символ комірки 0, спробуйте перейти до відповідного батька, але замість цього викиньте помилку, оскільки такої немає . якщо він дорівнює нулю, він записує його, перевіряє круглі дужки, опиняється на 0, а потім ігнорує його, і програма закінчує

?;(*

має елементи попередньої відповіді, і першої. він приймає невід'ємний цілий вхід, переміщує вниз стільки і перевіряє, чи є комірка "*", шукаючи неіснуючий додатковий батьків, якщо його немає. якщо вхід дорівнює 1, він переміститься з початкового простору, і знайде клітинку пробілом, а помилка, якщо вона дорівнює нулю, вона залишиться на стартовому просторі та ігнорує батьків.

Javascript (вузол), 19 байт, 2 коди виходу

Повна програма:

+process.argv[2]&&a

Функція:

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

process.argvце масив, який містить шлях до виконуваного вузла, шлях до файлу javascript, який виконується, та аргументи командного рядка. У цьому випадку це буде "1"або "0". Рядок перетворюється в число з одинарним +оператором. Якщо число дорівнює нулю, ледачий &&оператор не буде оцінювати праву частину, якщо число є правдоподібним (не нульовим), правою стороною &&оцінюється і помилка викидається, оскільки вона посилається на невизначену змінну, і програма існує з кодом виходу 1.

Функція очікує введення як число. Якщо вхід є truthy, функція викликає себе і припиняє час виконання вузла із переповненням стека. Якщо вхід 0, лінивий &&оператор повертає 0, не оцінюючи праву частину.

Perl 6 , 57 байт, 256 кодів виходу

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

Спробуйте це
переклад прикладу Perl 5.

Розширено

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 байт, 2 вихідні коди

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

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

JVM підтримує лише 1 і 0 як вихідні коди, якщо ви не дзвоните System.exit.

Перша програма намагається обчислити, 1/0чи є перший аргумент 1, який зірве JVM з кодом виходу 1. Якщо аргумент 0, він вийде успішно.

Друга програма, яка перетворює аргумент на ціле число, віднімає один і намагається ділити 1 на це число. Якщо аргумент, якщо 1, він обчислює 1/0, тому JVM вийде з ладу; якщо аргумент 0, він обчислює 1/-1і виходить.

Python 3 , 15 байт, 2 вихідних коду

Очевидно, це довше рішення Python 2 , тому що в Python 3 ми не можемо взяти буквальний вхід без виклику eval. Однак ми можемо цікаво використати методи порівняння рядків ...

1/(input()<'1')

Введенням буде або рядок, 0або 1- якщо він дорівнює 1, умова оцінюється на 0 (помилково), що призводить до спроби обчислити, 1 / 0що очевидно виходить з ладу (вихідний код 1). В іншому випадку нічого не відбувається, і Python виходить із звичайним кодом виходу 0.

Наскільки мені відомо, Python не здатний зіткнутися з іншими кодами виходу.

Java, 71 66 байт, 2 вихідні коди

4 байти збережено завдяки Холгеру

Повна програма:

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

Функція, що приймає int як аргумент:

i->1/(i-1)

Програма бере перший знак першого аргумента (або '0'або '1'віднімає 48 (значення ascii of '0'), щоб отримати ціле число (0 або 1), а потім намагається встановити аргумент у позиції цього цілого числа до порожнього рядка. вхід 1, програма виходить з ладу ArrayIndexOutOfBoundsException, оскільки масив аргументів має лише один елемент у позиції 0 (нульове індексування).

Python 2, 11 байт, 2 вихідних коду

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

Три різні 11-байтові рішення для трьох різних помилок! (Для задоволення це не дає балів.) За замовчуванням Python має лише вихідні коди 0 для успішного виходу та 1 для помилки. Вдалі запуски нічого не виводять.

 1>>-input()

На вході 1 видається "ValueError: кількість негативних зрушень". На вході 0 підрахунок нульового зсуву вдається і дає 1.

1/~-input()

На вході 1 видається "ZeroDivisionError: ціле ділення або модуль на нуль" через ~-input(), aka input()-1дорівнює 0. У вхід 1 1/-1дає -1. 0**-input()також працював би.

0<input()<x

На вході 1 вказується "NameError: ім'я" x "не визначено". На вході 0 ці перші нерівності 0<0оцінюються як Неправильно, тому решта не оцінюється, а результат - просто Неправильний.

Node.js (ES6), 77 байт, 2 коди виходу

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

Желе , 4 вихідні коди, 18 байт

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

Підтримує вихідні коди 0 , 1 , 137 (вбитий) та 139 (помилка сегментації).

Спробуйте в Інтернеті!

Як це працює

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 байт, 39 кодів виходу (із 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

Це однозначно можна було скоротити. SB має лише коди помилок від 0 до 51, а деякі неможливо запустити.

ZX81 BASIC> 255 кодів виходу - 52 байти (список)

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

Технічно Nможе бути будь-яке 24-бітове число з плаваючою точкою в межах діапазону, але ми припустимо цілі числа тут. Рядок 2 еквівалентний тому, IF N>0 AND N <=255 THEN GOTO 3: ELSE GOTO 1якщо ZX81 BASIC мав IF/ELSEу своїх символічних інструкціях.