Вызов:

Ваша задача - написать столько программ / функций / фрагментов, сколько вы можете, где каждая из них выводит / печатает / возвращает целое число. Первая программа должна вывести целое число 1, вторая 2и так далее.

Вы не можете повторно использовать любые символы между программами. Итак, если первая программа:, x==xто вы не можете использовать символы xи =снова ни в одной из других программ. Примечание: разрешено использовать один и тот же символ много раз в одной программе.

Подсчет очков:

Победителем будет представление, которое считается самым высоким. В случае ничьей победителем будет представление, в котором использовалось наименьшее количество байтов.

Правила:

• Вы можете использовать только один язык для всех целых чисел
• Фрагменты разрешены!
• Чтобы это было справедливо, все символы должны быть закодированы с использованием одного байта на выбранном вами языке.
• Выходные данные должны быть в десятичном формате. Вы не можете выводить его с научной нотацией или другим альтернативным форматом. Вывод чисел с плавающей точкой в ​​порядке, если все цифры , которые отображаются за десятичной точкой 0. Итак, 4.000принято. Неточности из-за FPA допускаются, если они не отображаются в выходных данных.
• ans =разрешены пробелы в начале и в конце, а также переводы строк и т. д.
• Вы можете игнорировать STDERR, если правильный вывод возвращается в STDOUT
• Вы можете выбрать вывод целого числа в STDERR, но только если STDOUT пусто.
• Символо- независимые языки (такие как Lenguage ) запрещены
• Буквы чувствительны к регистру a != A.
• Программы должны быть независимыми
• Пробелы нельзя использовать повторно
• Вы должны использовать ASCII-цифры в выводе

Пояснения приветствуются!

JavaScript (ES7), оценка 17, 176 байт

Они сказали, что это невозможно, поэтому я сделал это: D (благодаря большой помощи @FullDecent)

""**""
~(~/~//~/~/)/~/~/
3
4
!NaN- -!NaN- -!NaN- -!NaN- -!NaN
6
7
8
9
++[[]][+[]]+[+[]]
11
'lengthlength'.length
222>>2>>2
`${``^``}xE`^``
0XF
C=CSS==CSS;C<<C<<C<<C<<C
555555555555555555555%55

Неиспользуемые символы:

#&,:?@ABDGHIJKLMOPQRTUVWYZ\_bcdfijkmopqrsuvwyz|

Я не думаю, что 18 возможно, но я сказал то же самое о 17 ...

объяснение

JavaScript очень слабо типизированный язык; если вы попытаетесь выполнить математическую операцию с нечисловым значением, JS постарается сначала преобразовать его в число. Это позволяет много интересных решений. Я старался избегать максимально возможного использования цифр, чтобы их можно было использовать позже.

1. **является оператором возведения в степень в ES7. Пустая строка, когда приводится к числу, становится 0, так что это вычисляет 0 ** 0, что в 1соответствии с JavaScript.
2. Немного смешно, но это работает. /~/является литералом регулярного выражения и ~/~/возвращает -1, так что это ~(-1 / -1) / -1= ~(1) / -1= -2 / -1= 2. (кредиты @ GOTO0 за идею)
3. Просто 3.
4. Сейчас просто 4.
5. NaNэто ложь, так !NaNчто true, что эквивалентно 1. Таким образом, выражение становится 1 - -1 - -1 - -1 - -1= 1 + 1 + 1 + 1 + 1= 5.
6. Просто 6.
7. Просто 7.
8. Просто 8.
9. Просто 9.
10. Это использует немного магии JSF *** . +[]is 0, поэтому [[]][+[]]возвращает первый элемент [[]](то есть []) и ++увеличивает его до 1. Затем +[+[]]добавляет массив [0], который приводится к строке и делает "10".
11. Просто 11. Первоначально я использовал 11&1111для 3 и 33/3для 11, пока я еще раз не понял, насколько я тупой ...
12. Эта стратегия будет работать на любое число: создать строку длины 12и использовать .length.
13. Я просто порылся с 2s и >s на некоторое время, чтобы получить это. Мне снова повезло: 222 >> 2есть 55и 55 >> 2есть 13.
14. Это довольно сложно. Основная идея - создать 14в hex ( 0xE), но нам нужна цифра в 0другом месте. Поэтому вместо этого мы добавляем результат ``^``к строке xE; пустая строка, приведенная к числу, равна 0, так что это возвращает 0 ^ 0= 0. Затем результат XORed с пустой строкой, которая преобразует оба значения в числа; "0xE" ^ ""есть 14.
15. Теперь это довольно просто: 0XFэто шестнадцатеричный литерал со значением 15.
16. Самый хитрый из всех? Во- первых , мы устанавливаем переменную Cв CSS == CSS(то есть true). Затем мы берем результат и выполняем << Cчетыре раза, что в основном умножается 1на 2 ** 4.
17. JavaScript начинает терять целочисленную точность в 2 ⁵³ , что позволяет 555...555%55возвращать число, которое не является 0или 5. Мне очень повезло, когда я играл здесь.

Стратегии, которые будут работать на многих числах:

• -!NaNбудет работать на любое число (в настоящее время 5), хотя он становится большим очень быстро.
• ~/~/будет работать на любое число (в настоящее время 2), хотя он становится очень большим очень быстро.
• +[]будет работать на любое число (в настоящее время 10), хотя это гораздо проще 10или 11.
• .length будет работать на любом номере.
• `${-``}xE`-`` будет работать практически на любое число, если вы сделаете это правильно.
• C<<Cбудет работать с любой степенью двойки (в настоящее время 16) или с любым целым числом, если вы включите |.

Желе , 47 целых чисел, 519 байт

e
BI$⁼#
⁾⁾⁾Ụ^/
ı***ıḞḞ
5
6
7
.::::
9
EȮ<
⁻GṘ
=`p`VV×`DQV
~A~A~A~A~A~A~A~A~A~A~A~A~A
⁷ṾṾṾw
⁴ḟ€⁴Ṁ
mmmmċ
ṭṭṭṭṭṭṭṭḍḄḄḄḄḄḄḄḄḄ
+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ
CNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNC
ĖḌĖḌ
ṫṣȦJṫȦ⁸ȦJ
22
“@ṃ»
!ḤḤ!
³HH
ØaM
;;;;;;;;;;;;;;;;;;;;;;;;;;;¬¬ḅ¬
irið8c
⁶ḲĠṂ°İṂĊ
œṡ¹ẆẆTUṖṖṖṖP
ȷ½RṪ
LµdddddµFL
33
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWŒḊ
ẇɓæ«æ«æ«æ«æ«|æ«|
⁹ṚḢ²
‘‘‘0‘‘‘‘‘‘‘
’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’ạ
-____---__________
”(O
⁵ḶxḶ⁵ị⁵ḶxḶḣṢ
⁽{ʂ%⁽{}
ẊẠżv©żvżvżvọ®®Ạżvżvżvọ®
44
111111l11&K1111111Kl11&
,SS¶ỊỊ,ÇS¶ÇÑÇÇÇÑ
ÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆn

Каждая строка - это отдельная, полная программа.

Попробуйте онлайн! (включает набор тестов и проверку пересечения)

Как это устроено

Каждая полная программа без аргументов командной строки выполняет свою основную ссылку (определенную в последней строке) неформально, то есть без ввода. Если первая ссылка в цепочке является nilad, она используется, вызывается, и в качестве аргумента и возвращаемого значения основной ссылки устанавливаются результат; Если первое звено в цепочке является монадой или диадой, оно не используется и вместо него используется неявный аргумент и возвращаемое значение 0 . В обоих случаях остаток цепочки выполняется монадически.

Желе калечит свою продукцию в нескольких случаях. Примечательно, что одноэлементный массив печатается без окружающих скобок, поэтому 42 и [42] и неразличимы после печати. Мы будем использовать это несколько раз.

1 - 10

e

Существует тесты атома , если возвращаемое значение 0 принадлежит к аргументу 0 . Это так, поэтому eвозвращает 1 .

BI$⁼#

BI$является быстрой связью, в частности, монадической цепью, образованной быстрой $группировкой двоичного атома Bи атома приращенийI . В совокупности они преобразуют целое число в массив его цифр в базе 2, а затем вычисляют прямую разницу получаемых цифр. Если в массиве есть только один элемент, то нет прямых различий, и он Iвозвращает пустой массив (ложь); если есть хотя бы две цифры, Iвозвращает непустой массив (правда).

Быстрый #использует предыдущую быструю ссылку и применяет ее к 0 , 1, 2,… до тех пор, пока не будет найдено достаточно совпадений, и не возвращает массив совпадений. Требуемая сумма рассчитывается с помощью ⁼, которая сравнивает возвращаемое значение / аргумент 0 с собой, получая 1 . Таким образом, вся программа возвращает [2] , первое неотрицательное целое число с двумя цифрами в базе 2.

⁾⁾⁾Ụ^/

⁾⁾⁾строковый литерал, в частности, строка ⁾⁾ . Сравняться атом Ụсортирует свои показатели их соответствующих значения; так как оба символа равны, это приводит к [1, 2] . Полученный массив уменьшается с помощью битового XOR ^/, поэтому вся программа возвращает 3 .

ı***ıḞḞ

ıинициализирует аргумент и возвращает значение мнимой единице i . *является диадой возведения в степень , правый аргумент которой по умолчанию соответствует аргументу главной ссылки. Таким образом, ***ıвычисляет ((i ⁱ ) ⁱ ) ⁱ ≈ 4.81 + 0i , Ḟатом ( пол для вещественных аргументов, действительная часть для сложных) вычисляет действительную часть ( 4.81 ), а затем Ḟэтажи, получая 4 .

5
6
7

Эти три программы состоят из одного литерала и делают именно то, что вы ожидаете.

.::::

Литерал .является сокращением для 0.5 и инициализирует аргумент и возвращаемое значение. В целочисленное деление диады ( в :) правый аргумент по умолчанию основных звеньев аргумента, так ::::вычисляет 0,5 / 0,5 / 0,5 / 0,5 / 0,5 , получая 8 .

9

Еще один буквальный.

EȮ<

Полностью равный атом Eвозвращает 1, если все элементы в его аргументе равны, и 0, если нет. Целочисленный аргумент z повышен до [z] , поэтому Eон возвращает 1 для неявного аргумента 0 .

Теперь выходной атом Ȯвыводит 1 в STDOUT. Затем мы сравниваем 1 с неявным аргументом 0, используя атом меньше< . Результат (1 <0) = 0 , и он печатается неявно, когда программа заканчивается.

11 - 20

⁻GṘ

Сетка атом Gпытается сделать визуально приятную таблицу из своего аргумента. Для простого целочисленного аргумента (здесь: 0 ) он просто оборачивает его в массив. Плоский не равно атом ⁻сравнивает неявный аргумент 0 в результате вправо ( [0] ), что дает 1 , поскольку ее аргументы не равны. В представительских атом Ṙпечатает 1 к STDOUT и возвращает его результат. В конце программы, окончательное возвращаемое значение печатается неявно, так что в итоге мы получим 11 .

=`p`VV×`DQV

Сам быстро `превращается диада в монады, вызвав его с одинаковыми левыми и правыми аргументами. Сначала =`сравнивается неявный аргумент 0 с самим собой, давая 1 .

Декартово произведение атом pожидает списки в качестве аргументов, так что способствует целому числу 1 в диапазоне [1, ..., 1] = [1] . p`берет декартово произведение [1] и себя, получая [[1, 1]] .

Eval атом Vпревращает все плоские массивы (содержащие только цифры и символы) в строки, а затем оценивает результирующие строки как niladic программ желе. [[1, 1]] сначала превращается в [«11»] , затем Vудаляет строку, давая [11] . Еще раз, Vпревращает этот массив в «11» , а затем обнуляет его, чтобы получить 11 .

Теперь ×`умножает 11 на себя, получая 121 . Десятичного атом превращается 121 в [1, 2, 1] , то уникальный атом Qотбрасывает второй 1 , и Vеще раз получается список цифр в целое число , которое является результатом конкатенации их возвращения 12 .

~A~A~A~A~A~A~A~A~A~A~A~A~A

~это побитовый атом НЕ . С арифметикой дополнения до двух он отображает аргумент z в ~ z = - (z + 1) . Aявляется атомом абсолютного значения , поэтому он отображает - (z + 1) = z + 1 . При начальном возвращаемом значении 0 тринадцать ~Aвозвращают 13 .

⁷ṾṾṾw

Константа ⁷содержит символ новой строки '\ n' и инициализирует аргумент и возвращаемое значение.

Uneval атом Ṿпытается создать строковое представление его аргумент г такого , что программа Jelly , состоящая из этого кода будет возвращать г .

Первый вызов покорно возвращает строку «» \ n » , которая является символьным литералом. Следующий вызов возвращает «» »,« \ n » - пару символьных литералов. Третий и последний вызов возвращает "” ”,” ”,” ,, ””, ”\ n" - пятерку символьных литералов.

Наконец, атом индекса окнаw переводит свой правый аргумент '\ n' в строку "\ n" и находит первый индекс подстроки, начинающейся с "\ n" . Это возвращает 14 .

⁴ḟ€⁴Ṁ

⁴константа 16 . Quicklink filterfalse each ( ḟ€) переводит свой левый аргумент 16 в диапазон [1,…, 16] , затем перебирает его элементы.

Для каждого элемента г , ḟ⁴выполняется, сначала продвижение г в [г] , то удаление всех (если таковые имеются) вхождения 16 . Это дает массив [[1], [2],…, [14], [15], []] , где последний массив пуст, потому что он содержал 16 .

Наконец, максимальный атом Ṁвыбирает [15] .

mmmmċ

Модульное атом m- вызывается с аргументами х (массив) и у (целое число) , как правило , принимает все | у | ^th-й элемент x , начиная с первого, если y> 0 , с последним, если y <0 . Однако, когда y = 0 , он возвращает x, соединенный с его обратным.

Левый целочисленный аргумент 0 сначала переводится в [0] . Первая копия mобъединяет [0] с собой, давая [0, 0] . Оставшиеся копии превращают этот результат в [0, 0, 0, 0] , затем [0, 0, 0, 0, 0, 0, 0, 0] и, наконец, [0, 0, 0, 0, 0, 0 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] .

Наконец, счетчик атом ċподсчитывает количество раз неявного аргумента 0 появляется в результирующем массиве, возвращающиеся 16 .

ṭṭṭṭṭṭṭṭḍḄḄḄḄḄḄḄḄḄ

ṭявляется липкость атома и присоединяет его левый аргумент в его правом. Поскольку ṭи следующие ḍявляются двоичными, все вызовы для ṭпередачи неявного аргумента 0 в качестве правильного аргумента ṭ. Первый вызов возвращает [0, 0] , второй [0, [0, 0] , а восьмой и последний [0, [0, [0, [0, [0, [0, [0, [0, 0]]]]]]]] .

ḍявляется атомом делимости ; для аргументов x и y возвращается 1 , если x делится на y , 0 если нет. Ḅне используется для целых чисел, поэтому ḍḄпроверяет 0 на делимость на каждое целое число в построенном массиве. 0 делится само по себе, поэтому мы получаем [1, [1, [1, [1, [1, [1, [1, [1, 1]]]]]]]]] .

Теперь небинарный атом Ḅработает на плоских массивах. Для пары [a, b] он просто возвращает 2a + b . Как упомянуто ранее, Ḅэто неоперативный для целых чисел: целочисленный аргумент c повышен до [c] , а [c] в любой базе просто c .

Первый вызов Ḅуменьшает [1, 1] до 3 , что приводит к [1, [1, [1, [1, [1, [1, [1, 3]]]]]]]] . Следующий вызов уменьшает [1, 3] до 5 , следующий [1, 5] до 7 и так далее, пока девятый не Ḅвернет 17 .

+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ

Ṇявляется плоским логическим атомом NOT и отображает неявный аргумент от 0 до 1 . +является атомом сложения, поэтому каждая из восемнадцати копий +Ṇувеличивает предыдущее возвращаемое значение (изначально 0 ). Вся программа, таким образом, возвращает 18 .

CNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNC

Cявляется атомом дополнения и отображает его аргумент z в 1-z . Nявляется атомом отрицания и отображает его аргумент z в -z . Вместе они CNсопоставляют z с - (1-z) = z-1 , поэтому восемнадцать копий превращают неявный аргумент 0 в -18 . Окончательное применение Cурожайности 1 - (-18) = 19.

ĖḌĖḌ

Перечисление атом Ėперечисляет элементы в массиве, создавая пар индекс-значение. Неявный аргумент 0 переводится в [0] , а затем Ėприводит к [[1, 0]] . Undecimal атом преобразует плоский массив от основания 10 к целому числу, получ [10] , в данном конкретном случае.

Второй вызов Ėпреобразует [10] в [[1, 10]] , а второй Ḍокончательно преобразует в [20] .

21 - 30

ṫṣȦJṫȦ⁸ȦJ

Хвост атом ṫ(диада) выберите постфикс его левый аргумент , который начинается с индексом ( на основе 1 и модульный) , указанная в его правом аргументе, продвигая левый целочисленный аргумент х к [х] . При вызове с обоими аргументами, установленными в 0 , ṫвозвращает [0] .

Любой и все атом Ȧвозвращает 1 , если ее аргумент truthy и не содержит нулей на любой глубине, 0 в противном случае. Здесь мы просто используем его как функцию тождественности для возврата неявного аргумента 0 . Раскол в атоме ṣразделяет его левый аргумент [0] при появлениях его правого аргумента 0 , поэтому она возвращает [[], []] здесь.

Индексы атом Jотбрасывает элементы возвращаемого значения и заменяет их с индексами, получая диапазон [1, 2] , в этом конкретном случае. Ȧи ṫоба работают как прежде, поэтому они уменьшают [1, 2] до постфикса, который начинается с последнего индекса, приводя к [2] .

В ниладических ссылках константа ⁸имеет место [] . Это неразборчивая нилада, то есть она никак не вписывается в цепочку. В результате предыдущее возвращаемое значение ( [2] ) печатается в STDOUT, а затем заменяется значением nilad ( [] ).

Поскольку [] ложно, Ȧпреобразует его в 0 . JАтом способствует 0 до [0] , а затем возвращает список своих индексов ( [1] ), который печатается неявно , когда программа заканчивается.

22

Еще один буквальный. Repdigits, кажется, лучшее место, чтобы использовать их.

“@ṃ»

Это использует встроенное сжатие строки Jelly. Индексы @ и ṃ в кодовой странице Jelly равны 64 и 220, а строковые литералы могут содержать 250 различных символов, поэтому сначала вычисляется целое число 250 × 65 + 220 = 16470 .

16470 делится на 3, поэтому частное 16470/3 = 5490 кодирует печатный символ ASCII или перевод строки. Их 96, и 5490 = 96 × 57 + 18 , что означает, что мы декодировали печатный символ ASCII с индексом 18 на основе 0 , который равен «2» .

Нам осталось 57 , что также делится на 3 , поэтому частное 57/3 = 19 = 96 × 0 + 19 кодирует печатаемый символ ASCII с индексом 18 на основе 0 , который равен «3» .

Это оставляет 0 ; процесс декодирования останавливается. Сгенерированные символы объединяются в форму "23"

!ḤḤ!

Факторный атом !превращает неявный аргумент 0 в 1 . Два вызова unhalve атома Ḥпревращают 1 в 2 , затем 2 в 4 . Наконец, !вычисляет 4! = 24 .

³HH

В отсутствие аргументов командной строки константа ³содержит 100 . Два вызова Hпревращают 100 в 50 , затем 50 в 25 .

ØaM

Константа Øaсодержит строчный алфавит. Максимальный атом Mдает все индексы максимальных элементов, а так как г является крупнейшей строчной буквой, результат [26] .

;;;;;;;;;;;;;;;;;;;;;;;;;;;¬¬ḅ¬

Двадцать шесть копий объединенного атома ;объединяют начальное возвращаемое значение 0 и двадцать шесть экземпляров аргумента по умолчанию 0 , создавая массив из 27 нулей.

¬является логическим атомом НЕ , поэтому ;¬добавляет 1 к массиву нулей. Следующий ¬отменяет все элементы в массиве, оставляя нам массив из 27 единиц и 1 ноль.

ḅявляется необоснованным атомом и преобразует массив цифр из его левого аргумента из базы, указанной в его правом аргументе, в целое число. ḅ¬преобразует из одинарного в целое число, поэтому он просто выполняет сумму. Для массива из 27 это возвращает 27 .

irið8c

Индекс атома iспособствует его левый аргументу 0 до [0] , а затем найти индекс его правого аргумента 0 в этом массиве, получая 1 .

Диапазон атом rсоздает восходящий или нисходящий диапазон от него остался аргумент его правого. Правильный аргумент - это неявный аргумент 0 , так что это приводит к [1, 0] . Второй вызов iнаходит индекс 0 в [1, 0] , давая 2 .

ðначинается новая, диадическая цепь. Поскольку предыдущая цепочка была niladic, левый и правый аргументы этой цепочки будут равны возвращаемому значению первой цепочки ( 2 ). cв комбинации атом. С левым аргументом 8 и правым аргументом 2 он считает все уникальные неупорядоченные 2-комбинации набора из 8 элементов, возвращая 8C2 = 8! / (6! 2!) = 28 .

⁶ḲĠṂ°İṂĊ

Константа ⁶содержит пробел и устанавливает аргумент и возвращаемое значение в '' . Слова атом Ḳспособствует характер «» к одноплодной строке «» и делит его на пространствах, уступая [[], []] .

Группа атомов Ġгруппы все показатели равных элементов. Поскольку оба элемента последнего возвращаемого значения равны, он возвращает [[1, 2]] здесь. Минимальное атом извлекает минимальный (единственный) элемент этого массива, получая [1, 2] .

Степени атом °преобразует оба целые числа от шестидесятеричных градусов в радианы, получая 1 ° × 2π / 360 ° = p / 180 и 2 ° × 2π / 360 ° = π / 90 . Обратное атом принимает мультипликативные инверсии, получая 180 / л ≈ 57,3 и 90 / П ≈ 28,6 .

Затем Ṃеще раз берет минимум, уступая 28,6 . Наконец, атом ceilĊ превращает 28.6 в 29 .

œṡ¹ẆẆTUṖṖṖṖP

Идентичность атом ¹возвращает 0 для неявного аргумента 0 . Раскол вокруг атома œṡспособствует обоих аргументов (как 0 ) до [0] , а затем расщепляется [0] вокруг смежных подрешетки , равным [0] . Это дает [[], []] .

Раздвижное окно атом Ẇстроит весь смежный подмассив своего аргумента. Первый экземпляр преобразует [[], []] в [[[]], [[]], [[], []]] , второй экземпляр преобразует [[[]], [[]], [[] , []]] в
[[[[]]], [[[]]], [[[], []]], [[[]], [[]]], [[[]], [ [], []]], [[[]], [[]], [[], []]]] .

Правда атом Tперечисляет все показатели truthy элементов. Ни один из массивов на первом уровне не является пустым, поэтому это приводит к [1, 2, 3, 4, 5, 6] . Вверх ногами атом Uизменяет этот массив, получая [6, 5, 4, 3, 2, 1] .

Четыре копии атома popṖ удаляют последние четыре элемента, оставляя нас с [6, 5] . Наконец, атом продуктаP превращает этот массив в 30 .

31 - 40

ȷ½RṪ

ȷявляется сокращением для 1 × 10 ³ = 1000 . Квадратный корень атом ½дает 31.6 , которой диапазон атом Rпреобразует в [1, ..., 31] . Наконец, хвостовой атом Ṫизвлекает последний элемент, возвращая 31 .

LµdddddµFL

Длина атома Lспособствует неявный аргумент 0 до [0] , а затем принимает длину с получением 1 . µзапускает новую монадическую цепочку, а результат 1 становится ее аргументом.

Для аргументов х и у , то divmod атом dвыходов [х / у, х% г] . Каждый вызов будет иметь y = 1 , поэтому результат всегда будет [x, 0] .

Первый вызов начинается с x = 1 , что приводит к [1, 0] . dработает только с целыми числами, поэтому он векторизуется при последующих вызовах. Второй вызов дает [[1, 0], [0, 0]] , третий [[[1, 0], [0, 0]], [[0, 0], [0, 0]]] , и пятый и последний массив глубины 5, который содержит один и 31 ноль.

µеще раз запускает новую, монадическую цепочку, а массив до этого становится ее аргументом. Плоский атом Funnests этого массива, получая плоский массив одного одного и 31 нулей. Наконец, Lберет длину полученного результата, возвращая 32 .

33

Еще один repdigit, еще один буквальный.

WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWŒḊ

Каждый экземпляр атома переноса преобразует свой аргумент z в [z] . При начальном возвращаемом значении 0 все 34 экземпляра вместе дают [[[[[[[[[[[[[[[[[[[[[[[[[[[[0]] ]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] . Наконец, атом глубиныŒḊ вычисляет максимальную глубину результирующего массива, возвращая 34 .

ẇɓæ«æ«æ«æ«æ«|æ«|

Окно существует атом ẇспособствует обоих аргументов (как по умолчанию до 0 ) на [0] , затем проверяет, ** [0] ** происходит как непрерывный подмассива [0] . Это так, поэтому ẇвозвращает 1 .

ɓначинается новая, диадическая цепь. Поскольку предыдущая цепочка была niladic, левый и правый аргументы этой цепочки будут равны возвращаемому значению первой цепочки ( 1 ). Цепочка использует два разных диадических атома: битовое смещение влево ( æ«) и побитовое ИЛИ ( |).

Диадическая цепочка, которая начинается с трех или более диад, первоначально вызывает первую диаду с аргументами цепочки. Здесь это дает 1 << 1 = 2 . Шесть последующих диад сгруппированы в пары (так называемые вилки ), где самая правая диада вызывается сначала с аргументами цепочки, затем самая левая вызывается с предыдущими возвращаемыми значениями в обе стороны.

Для æ«æ«, мы получаем 2 << (1 << 1) = 2 << 2 = 8 . Затем æ«æ«вычисляет 8 << (1 << 1) = 8 << 2 = 32 . Теперь |æ«получает нас 32 | (1 << 1) = 32 | 2 = 34 .

Наконец, трейлинг |действует как ловушка и вызывается с предыдущим возвращаемым значением в качестве левого аргумента и правым аргументом цепочки в качестве правого. Это возвращает 34 | 1 = 35 .

⁹ṚḢ²

При отсутствии второго аргумента константа ⁹содержит 256 . Обратный атом способствует 256 в массив [2, 5, 6] и переворачивает ее с получением [6, 5, 2] . Затем атом головыḢ извлекает первый элемент, а квадратный атом ²возвращает ** 6² = 36 *.

‘‘‘0‘‘‘‘‘‘‘

Приращение атом ‘увеличивает свой аргумент на 1 , так что ‘‘‘повернуть начальное значение , возвращаемых 0 в 3 . Следующий 0 - это неразборчивая нилада, то есть он никак не вписывается в цепочку. В результате предыдущее возвращаемое значение ( 3 ) печатается в STDOUT, а затем заменяется значением nilad ( 0 ).

Следующие 7 копий ‘превращают этот 0 в 7 , который неявно печатается после завершения программы.

’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’ạ

Декремент атом ’декрементирует свой аргумент на 1 , так что тридцать восемь экземпляров провернуть начальное возвращаемое значение 0 в -38 . Абсолютная разница атом ạвычисляет без знака разности между -38 и неявным аргументом 0 , возвращающимися 38 .

-____---__________

-является сокращением для -1 и устанавливает аргумент ссылки и возвращаемое значение равным -1 . Каждый из _них является экземпляром двоичного атома вычитания , правый аргумент которого по умолчанию будет равен -1, если отсутствует.

Сначала -____-вычисляется (-1) - (-1) - (-1) - (-1) - (-1) = 3 . Нижеследующее -1 - это неразборчивая нилада, поэтому предыдущее возвращаемое значение ( 3 ) печатается в STDOUT, а затем заменяется значением нилида ( -1 ).

Затем -_вычисляет (-1) - (-1) = 0 , где литерал -устанавливает левый аргумент _и использует возвращаемое значение в качестве правого. Следующие девять копий _вычитают аргумент по умолчанию -1 из возвращаемого значения, получая 9 , которое выводится неявно по окончании программы.

”(O

”(является символьным литералом, и порядковый атом Oищет свою кодовую точку Unicode, получая 40 .

41 - 47

⁵ḶxḶ⁵ị⁵ḶxḶḣṢ

В отсутствие третьего аргумента командной строки константа ⁵имеет значение 10 . Unlength атом Ḷсоздает диапазон 0 на основе, в частности [0, ..., 9] для аргумента 10 , с обеих сторон повторе в месте атома x. Последний сопоставляет элементы своего левого аргумента с повторениями своего правого аргумента и повторяет каждый из элементов соответствующее количество раз. Используя [0,…, 9] в качестве левого и правого аргумента, мы получаем ноль нулей, один, два, два и т. Д.

Индекс в атоме ịизвлекает элемент его правого аргумента по индексу , указанному в его левом. С левым аргументом 10 ( ⁵слева) и правым аргументом [1, 2, 2, 3, 3, 3, 4, 4, 4, 4,…, 9] (предыдущий результат) это дает 4 .

За цепочкой до этой точки следует непарсируемая нилада ⁵, поэтому предыдущее возвращаемое значение ( 4 ) печатается в STDOUT, возвращаемое значение устанавливается равным 10 , а остальная часть цепочки анализируется как обычно.

Как и прежде, ⁵ḶxḶбудет давать массив [1, 2, 2, 3, 3, 3, 4, 4, 4, 4,…, 9] . На этот раз мы вызываем отсортированный атом Ṣв аргументе 10 , который переводит 10 в [1, 0] , а затем сортирует его для получения [0, 1] . Диадическая головка атом Теперь извлекает префиксы длины 0 и 1 из результата влево, оставляя нас с [[], [1]] . При печати ничего кроме 1 не останется видимым.

⁽{ʂ%⁽{}

⁽и его два следующих символа составляют числовой литерал. Если j и k являются их кодовыми точками в кодовой странице Jelly и (j, k) <(124, 250) , мы получаем целое число 1001 + 250j + k . Кодовые точки '{' , '}' и 'ʂ' - 123 , 125 и 167 , поэтому левый литерал оценивается в 1001 + 250 × 123 + 167 (= 31918) , а правый - в 1001 + 250 × 123 + 125 (= 31876) .

Поскольку левое целое число менее чем в два раза больше правого, результат составляет (… + 167)% (… + 125) = (… + 167) - (… + 125) = 167–125 = 42 .

ẊẠżv©żvżvżvọ®®Ạżvżvżvọ®

Перетасовка атом Ẋрандомизирует порядок элементов своего аргумента; числовой аргумент z заранее повышается до диапазона [1,…, z] . Для неявного аргумента 0 этот диапазон пуст и Ẋприводит к [] . Все атом Ạвозвращает 1 , если все элементы ее аргумента являются truthy, 0 , если нет. Поскольку пустой массив не содержит ложных элементов, здесь Ạвозвращается 1 .

Индекс с атомом ż(диада) принимает аргументы x и y и транспонирует пару [x, y] . Для целых чисел x и y это просто возвращает [[ x, y]] , поэтому этот конкретный объект ż, вызываемый с аргументами 1 и 0 (неявный аргумент), возвращает [[1, 0]] . Диадический Eval атом vпревращает все плоские массивы (содержащие только цифру и символы) Я левый аргумент в строки, а затем оценивает результирующие строки как монадическая программа Желе с правым аргументом в качестве аргументов программ. С ["10"]состоит только из литералов, это игнорирует правильный аргумент vи просто приводит к [10] .

Копия быстро ©присоединяет к vи копирует его результат в регистр. Более поздние вхождения атома отзыва® (nilad) будут извлекать [10] из регистра.

Следующие три экземпляра żvработы, как и прежде, отображают [10] в [[10, 0] в [100] в… в [10000] . На заказ атомных ọиспытаний , сколько раз его левый аргумент делится на его правой, так вот, он вычисляет порядок 10 (сгружен с ®) в 10000 = 10 ⁴ , получая [4] .

Ниже ®приведена неразборчивая nilad, поэтому предыдущее возвращаемое значение ( [4] ) печатается в STDOUT, а затем заменяется значением nilad ( 10 ). Применяем Ạдалее, получая 1 . (Это необходимо, так как на этом этапе будет разбираться нилада, за которым следует диада.)

Как и прежде, żvżvżvдобавляет три нуля к текущему возвращаемому значению, превращая 1 в [1000] . И, наконец, ọ®вычисляет порядок 10 в 1000 = 10 ³ , и 3 выводится на STDOUT , когда программа заканчивается.

44

Еще один репигит, еще один буквальный.

111111l11&K1111111Kl11&

Прежде всего, литерал 111111устанавливает аргумент и начальное возвращаемое значение равным 111111 . Другие серии 1также являются литералами.

lявляется логарифмическим атомом, который вычисляет логарифм левого аргумента с основанием, указанным в правом. При вызове 111111 с правильным аргументом 11 мы получаем журнал ₁₁ 111111 ≈ 4.85 .

Слова атом Kприсоединяется список аргументов в пространствах, после продвижения числового / символа г в [г] . Здесь мы просто используем его, чтобы превратить аргумент ссылки 111111 в [111111] . (Здесь нам не требуется массив, но у нас закончились атомы идентичности.) Побитовый атом AND& принимает возвращаемые значения в обе стороны, при необходимости возвращает их к целому числу и вычисляет их побитовое AND. В этом конкретном случае он возвращает [4.85 & 111111] = [4 & 111111] = [4] .

Ниже 1111111приведена неразборчивая nilad, поэтому предыдущее возвращаемое значение ( [4] ) печатается в STDOUT, а затем заменяется значением nilad ( 1111111 ). Kзатем превращает это целое число в [1111111] . (Это опять-таки не обязательно, но на этом этапе можно разобрать ниладу, за которой следует диада.)

Как и прежде, l11вычисляет log ₁₁ 1111111 ≈ 5.81 , затем &возвращает [5.81 & 111111] = [5 & 111111] = [5] .

,SS
ỊỊ,ÇS
ÇÑÇÇÇÑ

Это единственная программа, которая состоит из нескольких пользовательских ссылок. Последняя ссылка является основной и выполняется при запуске программы, остальные - вспомогательные. Быстрый Çвсегда ссылается на ссылку выше текущей и выполняет ее монадически. Аналогично, быстрое Ñвсегда ссылается на ссылку под текущей (обтекание), а также выполняет ее монадически.

Верхняя ссылка состоит из парного атома ,- диады, которая превращает аргументы x и y в [x, y] - и атома суммыS - монады, которая переводит целочисленный аргумент z в [z] и уменьшает аргумент массива путем сложения. Когда ссылка ,SSвызывается с целочисленным аргументом n , она вычисляет Σ [n, Σn] = Σ [n, n] = 2n .

Средняя связь состоит из вышеуказанных атомов, вышеупомянутого быстрого Çи незначительного атома Ị- монады, которая дает 1 для числовых аргументов z с -1 ≤ z ≤ 1 , но 0 для всех остальных. Применение Ịдважды к целочисленному аргументу n по существу заменяет его на 1 , так как вывод первого Ị( ввод второго) всегда незначителен. Этот результат затем соединяется с возвращаемым значением Ç( вызывается с аргументом n ), и результирующая пара уменьшается на S. В общей сложности мы вычисляемΣ [(| n | ≤ 1) ≤ 1, 2n] = Σ [1, 2n] = 2n + 1 .

С этими двумя вспомогательными ссылками основная ссылка теперь может создавать любое неотрицательное целое число, просматривая его двоичные цифры. При начальном возвращаемом значении 0 цепочка ÇÑÇÇÇÑвычисляет конечный результат ((((((× × 2 + 1) × 2) × 2 + 1) × 2 + 1) × 2 + 1) × 2 = ((5 × 2 + 1) × 2 + 1) × 2 = 46 .

ÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆn

Следующий простой атом находит наименьшее положительное простое число, которое строго больше , чем ее аргумент. С начальным возвращаемым значением 0 пятнадцать вызовов Ænвычисляют пятнадцатое простое число, которое равно 47 .

брейкфак , оценка 2, 255 144 10 байт

... Да, не самая лучшая идея, так как у меня есть только 8 персонажей (тарпиты, которые будут тарпить), но давайте посмотрим, сколько это возможно. Я думаю, что это все, что возможно. : P Этот ответ демонстрирует шесть из восьми символов, которые использует brainfuck, два других ,- это вход и .выход.

+
>--[<->-]

Визуализируйте это онлайн!

объяснение

Каждый номер создается и сохраняется в начальной ячейке на ленте. Сильно полагается на обертывающие ячейки, которые не реализованы в нескольких интерпретаторах.

1 :

[ 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

+  increment the current cell

[ 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

2 :

[ 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

>  move to the next cell
-- decrement the current cell twice

[ 0 |254| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
      ^

[  while the current cell is not 0
<  move to the previous cell
-  decrement the current cell

[255|254| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

>  move to the next cell
-  decrement the current cell

[255|253| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
      ^

]  repeat while the current cell is not 0

...

[ 3 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
      ^

[ 2 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

[ 2 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
      ^

Нейм , оценка 38, 327 байт

1: 𝔼
2: 2
3: 3
4: 4
5: 5
6: 6
7: 7
8: 8
9: 9
10: β
11: γ
12: δ
13: ε
14: ζ
15: η
16: θ
17: ι
18: κ
19: λ
20: μ
21: ν
22: ξ
23: π
24: ρ
25: σ
26: ς
27: τ
28: υ
29: φ
30: χ
31: ψ
32: ω
33: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
34: <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<𝐀
35: 𝐓0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻
36: ℂ𝐋𝐠𝐋𝐠𝐋𝐠𝐋𝐝𝐬𝕏𝐬
37: α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊
38: 𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝐥

Объяснение:

• Для 1 мы используем токен «проверка на равенство», используя здесь, когда Neim пытается выдвинуть пустой ввод, он получает 0. Поскольку 0 и 0 эквивалентны, это выталкивает 1, который неявно печатается
• Со 2 по 9 мы просто используем числовые литералы.
• С 10 по 32 у Нейма есть константы одного байта для всех (да, это безумие).
• Для 33 мы используем только команду увеличения. На первом байте Neim пытается вытолкнуть что-то, чтобы он мог увеличить его, но так как ввод пуст, по умолчанию он выталкивает 0.
• Для 34 мы используем тот же подход, но уменьшая и принимая абсолютное значение.
• Для 35 мы используем тот факт, что нулевой факториал равен единице, и мы используем его, дублируя один и многократно добавляя
• Для 36 мы используем, ℂчтобы проверить 0 и 0 для взаимной простоты, которой они являются. Это нажимает 1. Затем мы получаем первое простое использование 𝐋, в результате чего получается одноэлементный список, содержащий всего 2. Затем мы получаем наибольший элемент ( 𝐠), который нажимает 2 как число. Затем мы повторяем этот процесс, пока не получим список [2 3 5 7 11]. После этого мы используем 𝐝для вычисления дельты, в результате чего список [1 2 2 4]. Далее мы используем, 𝐬чтобы получить сумму - которая равна 9 - затем мы вычисляем исключительный диапазон от 0 до 9, в результате чего [0 1 2 3 4 5 6 7 8]. Наконец, 𝐬используется снова, чтобы получить 37.
• Для 37 α- это константа, которая представляет отрицательную единицу, и мы неоднократно нажимаем на нее и вычитаем (снова используя тот факт, что, когда мы пытаемся вытолкнуть пустой вход, 0 толкается)
• Для 38, снова используя значение по умолчанию 0 для пустого ввода, мы продолжаем добавлять 0 к себе, создавая длинный список, а затем вычисляя длину.

Можно попробовать здесь

Python 2, 15

Вот начало, ищем больше

Спасибо Лео, чей совет помог мне добраться до 15

[[[]]>[]][[]>[]]>>[[]>[]][[]>[]]

---

2

---

import math
print'%i'%math.pi

---

((()<())<())<<((()<())<())<<((()<())<())

---

5

---

6

---

7

---

8

---

9

---

11^1 

---

33/3

---

4--4--4

---

__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__

---

q=""=="";qq=q=="";qqq=~q*~q*~q;~qqq*~q*~qq

---

0xF

Japt , 448 байт, оценка 42

Большое сотрудничество между Shaggy , ETHproductions и Oliver .

v
y
Íà
Qiiii)iiii)âQ
ÂHq
LÁL
´Vn´VnVnVn
8
9
A
B
C
D
E
F
G
J-----J---J---J---J
[¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾]x
;Iìw
~~½e½e½e½e~½e½
++T+++T+++T+++T+++T+++T
22
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
4á
5²
°UU°°°U°°U°°U°°U°°U
»³³
7/¼
$'_____________________________b'$bb
ZµÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉ
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"aa
Sc
33
Mg011
##
6p
Rí í í í í è.
`¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥`l
¨N|N¹òò¹m···m|¹mò¹m···m|¹mò¹m···m|¹o
º¤¤*º¤*º¤
(Å<<(Å<<(Å<<(Å<<(Å<<(Å^(Å<<(Å<<(Å<<(Å^(Å
Y±Y¶YY±YY±Y±Y¶YY±YY±Y±Y¶YY±Y

Эти (полезные) символы остаются:

!%&,:=>?@OPWX\dfhjkrstuz{}¡¢£¦§©ª«¬®¯¸ÀÃÆÇÈÐßãäåæçéêëîïñóôõö×øÿ

---

Пояснения

Несколько вещей, которые нужно знать о Джапте, прежде чем мы начнем, которыми я часто пользовался. Во-первых, у Japt есть 6 переменных, зарезервированных для ввода, которые являются заглавными буквами U-Z. Если никакие входные данные не передаются через эти переменные, они все по умолчанию 0. Вторая вещь покрыта в этом наконечнике .

Нажмите на любой фрагмент, чтобы попробовать его в онлайн-переводчике .

---

v

При применении к числу vметод принимает целое число n в качестве аргумента и возвращает 1, если число делится на n , 0, если нет. Если н не указано, то по умолчанию оно равно 2 . 0 (значение по умолчанию U) является делится на 2 , так что это дает нам 1 .

---

y

Очень похоже на первый. При применении к числу yметод принимает целое число n в качестве аргумента и возвращает GCD двух чисел. Если n не указано, то по умолчанию оно равно 2 . Поскольку 0 делится на 2 , GCD (0, 2) дает нам 2 .

---

Íà

Íэто ярлык для n(2)или 2- this. Поскольку у нас нет ввода, мы используем значение thisпо умолчанию 0, что приводит к 2-0 = 2.

àвозвращает количество комбинаций [1...this], которое возвращает 3

---

Qiiii)iiii)âQ

Qпо умолчанию используется одна кавычка. iв строку вставляет еще одну строку в начале; как объяснено в # 3 , каждыйiiii) эквивалентен .i("i".i("i"))в JS, таким образом вставляя две копии iв начале строки. Сделайте это дважды, и у вас есть строка iiii". âQзатем моделирует .search(Q), давая индекс первого "в строке, который равен 4 .

---

ÂHq

Hконстанта для 32 . При применении к числу qметод, который принимает целое число n в качестве аргумента, возвращает n- ^й корень этого числа. Если n не указано, по умолчанию используется значение 2 поэтому Hqмы получаем квадратный корень из 32, что составляет приблизительно 5,6568 . Âэто ярлык ~~, который дает результат, давая нам 5 .

---

LÁL

Lпо умолчанию 100 и Áявляется ярлыком для >>>(с нулевым заполнением битового сдвига вправо). 100>>>100такой же, как 100>>>4(правый операнд обертывает мод 32), то есть 6 .

---

´Vn´VnVnVn

Как отмечалось ранее, по Vумолчанию 0 . ´это ярлык для --оператора, поэтому код эквивалентен следующему JS:

(--V).n((--V).n(V.n(V.n())))

X.n(Y)эквивалентно Y - X или -X + Y ; первое --Vвозвращение -1 , а второй -2 , так что это примерно эквивалентно - (- 1) + (- (- 2) + (- (- 2) + - (- 2))) . Упрощая, мы получаем 1 + 2 + 2 + 2 = 7 .

---

8
9

Буквально 8 и 9 .

---

A
B
C
D
E
F
G

Это константы для 10 - 16 включительно.

---

J-----J---J---J---J

Jпо умолчанию установлено -1 . Интерпретатору Japt как-то удается правильно разобрать это, как (J--) - (--J) - (--J) - (--J) - (--J). Делая еще немного математики, мы находим, что это эквивалентно (-1) - (-3) - (-4) - (-5) - (-6) или -1 + 3 + 4 + 5 + 6 = 17 ,

---

[¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾]x

¾это, как вы можете догадаться, ярлык для .75. Мы помещаем в массив 24 копии по 0,75 , а затем суммируемx , давая 0,75 * 24 = 18 .

---

;Iìw

Я думаю, что это мой любимый. ;в начале программы изменяются значения некоторых констант Джапта; без него Iэто 64 , но с ним, Iэто 91 .ìwпреобразует его в список цифр и выполняет wпо списку, обращая массив, а затем преобразует обратно в число, чтобы получить 19 .

---

~~½e½e½e½e~½e½

½это ярлык для .5. eна номер x принимает аргумент y и возвращает x * 10 ^y . Таким образом, цепочка расчетов, которая происходит:

           ½e½     1.5811  (.5 * sqrt(10))
          ~       -2
        ½e         0.005  (.5 * (10 ** -2))
      ½e           0.5058
    ½e             1.6024
  ½e              20.0138

И финал ~~ служит для определения целого числа, что дает результат 20 .

---

++T+++T+++T+++T+++T+++T

Tпо умолчанию 0 . ++является оператором приращения в JS, а также в Japt; T+++Tанализируется как (T++) + T, но ++T+++Tанализируется как (++T) + (++T), так что это эквивалентно коду JS

(++T) + (++T) + (++T) + (++T) + (++T) + (++T)

Результат равен 1 + 2 + 3 + 4 + 5 + 6 , что составляет 21 .

---

22

Буква 22 .

---

ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ

Äэто ярлык для +1, так что это просто сумма 23 1 с.

---

4á

Это находит количество перестановок [1, 2, 3, 4], которое составляет 4! = 24 .

---

5²

²это сокращение для p2, которое поднимает число до степени двух. 5 ** 2 составляет 25 .

---

°UU°°°U°°U°°U°°U°°U

°ярлык для ++оператора, или если он не может быть проанализирован как таковой, + +. Как отмечалось ранее, когда нет ввода, по Uумолчанию используется 0 . Таким образом, код эквивалентен (++U), (U++) + + (++U) + + (++U) + + (++U) + + (++U) + + (++U), что очень похоже на # 17 : Uсначала увеличивается 1, затем многократно увеличивается и добавляется так, что конечный результат 1 + 3 + 4 + 5 + 6 + 7 = 26 .

---

»³³

³является ярлыком для pметода с аргументом 3 . Однако, если строчная буква появляется непосредственно после левой круглой скобки ( »это ярлык для ((), она становится строкой. Это позволяет ему быть переданным методу и вызываться как функция (то есть m³будет отображаться .p(3)). В этом случае, однако, ("p",3)возвращает наш 3, а затем мы возводим его в степень 3( pметод степени применительно к числу), что дает нам 27 .

---

7/¼

¼, как вы, наверное, уже знаете, является ярлыком для .25, так что это вычисляет 7 / 0,25 = 28 .

---

$'_____________________________b'$bb

Все, что обернуто в $символы, рассматривается как чистый JavaScript, поэтому у нас есть строка из 29 символов подчеркивания, за которой следует символ b. (Без $, 'это будет односимвольная строка.) bМетод, примененный к строке, возвращает первый индекс своего аргумента в этой строке. Как объяснено в # 3 , последний bпреобразуется в строку, поэтому мы берем первый индекс bв нашей строке, который 29 .

---

ZµÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉ

µэто ярлык для -=и Éдля -1. Эффект вычитает 30 копий -1 из 0 , что дает 30 .

---

"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"aa

Очень похоже на # 29. При применении aметода к строке метод возвращает последний индекс своего аргумента в этой строке. Используя 0-индексирование, последний индекс aв строке 32 aс 31 .

---

Sc

S предопределено для одного пробела, и c для строки с одним символом возвращает свой код, давая 32 .

---

33

буквальный 33 .

---

Mg011

MgNвозвращает N-е число Фибоначчи. 011это 9 в восьмеричной системе ; 9-е число Фибоначчи 34 .

---

##

#возвращает код символа следующего символа. Чарс-код самого #себя бывает 35 , что делает нашу работу здесь особенно легко.

---

6p

pэто возведение в степень, и без второго аргумента по умолчанию оно равно 2 ; таким образом, это печатает 6 ** 2 = 36 .

---

Rí í í í í è.

Это довольно сложно. Rпо умолчанию используется один символ новой строки (то, что это новая строка, становится важным позже). íв строке, без каких-либо аргументов, берет каждый символ и добавляет его индекс: довольно бесполезное преобразование, но результат через 5 итераций таков: (используя Rвместо буквального перевода строки)

R
R0
R001
R0010213
R001021304251637
R0010213042516370849210511112613314715

Интересно, что каждая запись является просто префиксом следующей ... Но в любом случае последняя часть è.подсчитывает, сколько совпадений /./gнайдено в результате. В строке 38 символов; однако, поскольку /./gсопоставляются только символы без перевода строки, результат равен 37 .

---

¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥l

Обратные пометки отмечают сжатую строку и ¥распаковывают в ll. lна строке дает length, поэтому после декомпрессии это дает 38 .

---

¨N|N¹òò¹m···m|¹mò¹m···m|¹mò¹m···m|¹o

Ооо, мальчик, это чокнутый. Во-первых, мы генерируем trueс ¨N( ¨обозначает>= , а Nбез входных данных - пустой массив), затем преобразуем это в 1с |N. С этого момента это становится довольно сумасшедшим:

ò    Inclusive range [0..1],            [0, 1]
 ò   making each an inclusive range.    [[0], [0, 1]]
m·   Join each on newlines.             ["0", "0\n1"]
·    Join on newlines.                  "0\n0\n1"
·    Split on newlines.                 ["0", "0", "1"]
m    Map each item X and index Y to     
 |     X | Y.                           ["0" | 0, "0" | 1, "1" | 2] -> [0, 1, 3]
m    Map each by 
 ò     inclusive range.                 [[0], [0, 1], [0, 1, 2, 3]]
m··· Same as before.                    ["0", "0", "1", "0", "1", "2", "3"]
m|   Bitwise OR thing again.            [0, 1, 3, 3, 5, 7, 7]
mò   Map each by inclusive range.       [[0], [0, 1], ..., [0, 1, 2, 3, 4, 5, 6, 7]]
m··· Same as before.                    ["0", "0", ..., "5", "6", "7"]
m|   Bitwise OR again.                  ["0"|0, "0"|1, ..., "5"|30, "6"|31, "7"|32]
                                        -> [0, 1, ..., 31, 31, 39]

(Символы ¹s просто заменяют близкие паренны и были опущены.) oЗатем всплывает финал и возвращает последний элемент в массиве, давая 39 .

---

º¤¤*º¤

В основном тот же трюк, что и с # 3 . ¤является ярлыком для sметода с аргументом 2 . В этом случае, однако, передаваемый код является (("s", 2).s(2) * (("s", 2) * (("s", 2))))или упрощен (2).s(2) * (2 * 2). .s(2)возвращает число в виде строки base-2, что дает "10"; * (2 * 2)неявно преобразует это в число и умножает на 4 , давая 40 .

---

(Å<<(Å<<(Å<<(Å<<(Å<<(Å^(Å<<(Å<<(Å<<(Å^(Å

Похож на предыдущий. Åявляется ярлыком для sметода с аргументом 1 . В этом случае, однако, каждый (Åпереносится в ("s", 1), что просто возвращает 1 . 1<<1<<1<<1<<1<<1это 32 , а 1<<1<<1<<1это 8 ; это XORed вместе с, 1чтобы получить 41 .

---

Y±Y¶YY±YY±Y±Y¶YY±YY±Y±Y¶YY±Y

±это ярлык для +=и ¶для ===. Это означает, что код на самом деле

Y+=Y===Y,Y+=Y,Y+=Y+=Y===Y,Y+=Y,Y+=Y+=Y===Y,Y+=Y

Y===Y всегда верно, поэтому мы можем упростить это немного:

Y+=1,Y+=Y,Y+=Y+=1,Y+=Y,Y+=Y+=1,Y+=Y

0 + 1 = 1 ; 1 + 1 = 2 ; 2 + (2 + 1) = 5 ; 5 + 5 = 10 ; 10 + (10 + 1) = 21 ; 21 + 21 = 42 .

PHP, оценка 17, 130 байт

используемые символы ADEFGIKLMOPRSTVXYZ=_![]()<>'"#$,;/-+*|^&0123456789afhnprstwx

Z==Z
FTP_MOREDATA
';'&w
![]<<![]<<![]
5
6
"#"|"$"|"1"
8
SIGKILL
333333>>3>>3>>3>>3>>3
99/9
22-2-2-2-2-2
strspn(XXXXXXXXXXXXXX,X)
7+7
0xf
4*4
ha^YV

1 Булева константа Z (не установлена) равна константе Z

2 FTP_MOREDATA - это константа в PHP со значением 2

3 поразрядно и символы; и ж

4 поразрядное смещение влево и логический не приведенный пустой массив к логическому значению true с приведением к целому числу 1 с помощью оператора сдвига влево

7 побитовых или символов # и $ и 1

9 SIGKILL - константа в PHP со значением 9

10 бит по сдвигу вправо, каждый шаг - целочисленное деление с 8, поэтому у нас есть шаги 333333, 41666, 5208, 651, 81, 10

13 считать символ X в строке X ... с начала

15 шестнадцатеричное значение f = 15

17 битный Xor со строками ха и YV

Все фрагменты являются элементами в массиве

Попробуйте онлайн!

PHP, оценка 16, 94 байта

используемые символы AEIMPRTUZeflnrstvwx^_&|()[]=!.*+/-<>$":0123456789

Z==Z
":"&"w"    
M_PI|[]
TRUE<<TRUE<<TRUE
5
6
A^v    
8
9
!$s.strlen($s)    
77/7
3+3+3+3
111>>1>>1>>1    
22-2-2-2-2
0xf
4*4

1 Булева константа Z (не установлена) равна константе Z

2 поразрядно и символы: и ш

3 Pi приведено к целочисленному значению через пустой массив, приведенный к нулю

7 битовых xor символов A и V

10 переменная $ s не установлена! $ S = один конкат с длиной строки переменной $ s

13 111/2 = 55/2 = 27/2 = 13 Целочисленное деление по битам

15 шестнадцатеричное значение f = 15

Все фрагменты являются элементами в массиве

Попробуйте онлайн!

PHP, оценка 14, 84 байта

используемые символы $!_^[]()%/+~-=AEILMNPRUZ0123456789delnrstx

Z==Z
2
M_PI^[]
4
5
6
ERA%11
8
9
!$s.strlen($s)
77/7
3+3+3+3
0xd    
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-NULL

1 Булева константа Z (не установлена) равна константе Z

3 Pi приведено к целочисленному значению через пустой массив, приведенный к нулю

7 ЭРА является константой со значением 131116 мод 11 = 7

10 переменная $ s не установлена! $ S = один конкат с длиной строки переменной $ s равен нулю

13 шестнадцатеричное значение d = 13 14 поразрядно нет и знак минус поднимает NULL до 14

Все фрагменты являются элементами в массиве

Попробуйте онлайн!

R, оценка 13 14

F^F                       # F==0 in R
q=""=="";q--q             # ""=="" is TRUE, TRUE == 1 (Thanks WheatWizard)
3
4
5
6
7
8
9
1e1                       # scientific notation for 10
22/2
T+T+T+T+T+T+T+T+T+T+T+T   # T == 1
0xD                       
sum(mtcars$vs)            # mtcars is a built-in dataset, summing the $vs column gives 14

Получил дополнительный благодаря пользователю 2390246.

Используемые символы:

0123456789acemqrstuvxDFT^=";-/+()$

MATL , оценка 21 22 23 номера (273 байта)

Спасибо J Doe за расширение с 22 до 23 номеров!

0~
'bd'd
{P}gk
HH^
5
6
7
8
9
3 3.333333333333333*
11
IEE
[B]Yq
llllllllllllllNwxwxwxwxwxwxwxwxwxwxwxwxwxwx
KUKUa-
4W
FFFFFFFFFFFFFFFFFn
TTTTTTTTTTTTTTTTTTs
rrrrrrrrrrrrrrrrrrrhhhhhhhhhhhhhhhhhhz
OOOOOOOOOOOOOOOOOOOOvZyX>
JJJJJJJJJJJJJJJJJJJJJ++++++++++++++++++++J/
22
`@QQQQQQQQQQQQQQQQQQQQQQ@@<

Попробуйте онлайн! Каждый фрагмент в ссылке заканчивается либоD(отображение), либо]D(явное закрытие цикла и отображение), чтобы очистить стек и таким образом изолировать от следующего фрагмента.

объяснение

0~

Нажмите 0. Отрицание. Дает true, что отображается как 1.

'bd'd

Нажмите строку 'bd'. Последовательная разница между кодами символов.

{P}gk

Нажмите массив ячеек, содержащий номер pi. Преобразовать в числовой массив (т.е. в одно число). Округлить вниз.

HH^

Нажмите 2дважды. Сила.

5

Числовой литерал.

6

Числовой литерал.

7

Числовой литерал.

8

Числовой литерал.

9

Числовой литерал.

3 3.333333333333333*

Нажмите 3. Нажмите 3.333333333333333. Multiply. Благодаря точности с плавающей запятой это дает 10.

11

Числовой литерал.

IEE

Нажмите 3. Умножьте в 2два раза.

[B]Yq

Нажмите [6](что так же, как 6). Вычислить n-е простое число.

llllllllllllllNwxwxwxwxwxwxwxwxwxwxwxwxwxwx

Нажмите 114 раз. Количество элементов в стеке. Очистите остальную часть стека.

KUKUa-

Нажмите 4. Площадь. Делать то же самое. Любой: дает 1. Вычитание.

4W

Нажмите 4. 2поднят к этому.

FFFFFFFFFFFFFFFFFn

Толкай массив [false false ... false](17 раз). Количество элементов в массиве.

TTTTTTTTTTTTTTTTTTs

Нажмите массив [true true ... true](18 раз). Сумма массива.

rrrrrrrrrrrrrrrrrrrhhhhhhhhhhhhhhhhhhz

Нажмите 19 случайных чисел, взятых из интервала (0,1). Объединить горизонтально в 18 раз. Количество ненулевых элементов в массиве.

OOOOOOOOOOOOOOOOOOOOvZyX>

Нажмите 020 раз. Объединить содержимое стека по вертикали (задает вектор столбца). Размер: дает массив [20 1]. Максимум массива.

JJJJJJJJJJJJJJJJJJJJJ++++++++++++++++++++J/

Толчок 1j(мнимая единица) 21 раз. Добавить 20 раз. Разделите на 1j.

22

Числовой литерал

`@QQQQQQQQQQQQQQQQQQQQQQ@@<

Do ... while loop ( `) с неявным концом. В первой итерации он @увеличивает индекс итерации ( ) и увеличивает его ( Q) в 22 раза, что дает 23. Условие цикла ( @@<) ложно, поэтому цикл завершается.

Некоторые идеи для дальнейшего улучшения

• (пробел) в фрагменте 10 может быть заменен на |
• X>в сниппете 20 можно было бы заменить p, тем самым освободив префикс X.
• В настоящее время не используется и потенциально полезным: :,A

Vim 8 на Windows, оценка 13, 104 байта

1
2
3
4
5
6
7
^R=&ts^@
9
8^O^A^O^A
0^[^X^X^X^X^X^X^X^X^X^X^X0x
:h<CR>wwwwwwwwwwwy$:q<CR>p
grgKjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjYZZvPWWWllld|llD

^{keystroke}представляет <C-{keystroke}>, так что ^Xесть <C-x>, за исключением того, ^@что есть <C-j>. Я все еще пытаюсь добавить больше номеров в этот список и <CR>представляет перевод строки.

Примечание: чтобы запустить эти команды, запустите vim используя -u NONE -U NONE. Это делается для того, чтобы ваши конфиги не мешали коду.

Фрагменты с 1 по 10 начинаются в режиме вставки. В то время как фрагменты 12 и 13 запускаются в обычном режиме.

Пояснения

Фрагмент 8 есть :^R=&ts^@. Я должен поблагодарить @ L3viathan за то, что он придумал это, и @ nmjcman101 за предложение ^@в качестве замены для перевода строки и @ ØrjanJohansen за сокращение &tabstopдо &ts. &tsзатем оценивается размер вкладки, который по умолчанию равен 8, и это значение вставляется в редактор.

Фрагмент 10 есть 8^O^A^O^A. Мы вставляем 8, а затем увеличиваем его дважды, чтобы получить 10.

Фрагмент 11 есть 0^[^X^X^X^X^X^X^X^X^X^X^X0x. Мы записываем 0 и уменьшаем его 11 раз, чтобы получить -11. Затем убираем минус, чтобы получить 11.

Фрагмент 12 есть :h<CR>wwwwwwwwwwwy$:q<CR>p. Это открывает меню справки Vim 8, которое содержит следующую информацию:

*help.txt*  For Vim version 8.0.  Last change: 2016 Sep 12

И последовательность ws переходит к 12, в этот момент y$копирует число. Затем он вставляется в редактор с помощью p.

Snippet 13 - grgKjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjYZZvPWWWllld|llDспасибо @DJMcMayhem за его разработку. Это работает только на Windows. Фрагмент ищет в меню справки команды, начинающиеся с g. Затем он движется вниз, используя, jчтобы добраться до этой строки:

|g?|        g?      2  Rot13 encoding operator

после чего он копирует его и вставляет в буфер. После этого все, кроме 13, удаляется из буфера.

Математика, оценка 13

x~D~x
⌊E⌋
3
⌈Pi⌉
5
6
LucasL@4
8
9
0!+0!+0!+0!+0!+0!+0!+0!+0!+0!
77/7
Tr[{11,1}]
-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I

05AB1E , счет 18, 67 байт

X     Variable is initialized to 1
Y     Variable is initialized to 2
2>     2 + 1
4
5
6
7
8
9
T     Constant 10
3b     3 in binary
•C     Ascii code of 'C'
11Ì     11 in hex
A'ok     Index of 'o' in the alphabet
žz¨¤x+     Middle character of '256' times 2, plus itself
¾<<<<n     Variable initialized to 0, 4 times -1, squared
‘c‘‘c‘QDJH     'c' equals itself (true = 1), duplicated, converted from hex to dec
тD÷·±D*·     Constant 100, divided by itself, * 2, bitwise not, times itself, * 2
"d"aÐÐÐÐÐÐÐÐÐ)O     "d" is_alpha (true = 1), triplicated 9 times, total sum

Попробуйте онлайн!

Пинг-понг , оценка 127

В PingPong у каждого персонажа есть свое собственное числовое значение, что делает подсчет вплоть до 127 тривиальной задачей. Язык работает, читая значение каждого символа и помещая его в верхнюю часть стека, где выполняются все операции. PingPong теоретически может пройти дальше 127, но для этого потребуется передать блок символов, которые просто отображаются в текстовом редакторе как пробелы, поэтому я оставил их вне своего решения.

1: 1
2: 2
3: 3
4: 4
5: 5
6: 6
7: 7
8: 8
9: 9
10: A
11: B
12: C
13: D
14: E
15: F
16: G
17: H
18: I
19: J
20: K
21: L
22: M
23: N
24: O
25: P
26: Q
27: R
28: S
29: T
30: U
31: V
32: W
33: X
34: Y
35: Z
36: a
37: b
38: c
39: d
40: e
41: f
42: g
43: h
44: i
45: j
46: k
47: l
48: m
49: n
50: o
51: p
52: q
53: r
54: s
55: t
56: u
57: v
58: w
59: x
60: y
61: z
62: ©
63: ®
64: À
65: Á
66: Â
67: Ã
68: Ä
69: Å
70: Æ
71: Ç
72: È
73: É
74: Ê
75: Ë
76: Ì
77: Í
78: Î
79: Ï
80: Ð
81: Ñ
82: Ò
83: Ó
84: Ô
85: Õ
86: Ö
87: ×
88: Ø
89: Ù
90: Ú
91: Û
92: Ü
93: Ý
94: Þ
95: ß
96: à
97: á
98: â
99: ã
100: ä
101: å
102: æ
103: ç
104: è
105: é
106: ê
107: ë
108: ì
109: í
110: î
111: ï
112: ð
113: ñ
114: ò
115: ó
116: ô
117: õ
118: ö
119: ÷
120: ø
121: ù
122: ú
123: û
124: ü
125: ý
126: þ
127: ÿ

Октава, счет 14, 74 байта

Уверен, я сейчас близок к пределу.

1:  ~0                        % Not 0 == 1
2:  "H"/"$"                   % "H" = 72, "$" = 36. H/$ = 2
3:  3                         % Literal
4:  4                         % Literal
5:  5                         % Literal
6:  6                         % Literal
7:  7                         % Literal
8:  8                         % Literal
9:  9                         % Literal
10: ceil(pi*pi)               % pi*pi = 9.87. ceil(9.87) = 10
11: 11                        % Literal
12: 2+2+2+2+2+2               % Well, not much to say
13: ['','RT'-'!']             % 'RT' = [82,84]. Subtract '!' (33) to get ['',49,51]=13
14: nnz...                    % Number of non-zero elements in the string...
    nnnnnnnnnnnnnn            % on this line. (This is an awesome trick by the way!)

Пришлось удалить , strchrтак как у меня уже есть cв количестве 10. Я до сих пор j, ^, =, !, пространство и горизонтальная табуляция (ASCII-9) влево, так что можно было бы выжать еще один в.

Горизонтальная табуляция может быть использована в качестве пробела, поэтому трюк можно использовать strchrи nnzможно использовать еще раз. Остались только строчные буквы abdfgjkmoquvwxy. Из них не так много функций. modможет работать, но не может принимать строковый ввод.

Легко использовать оставшиеся символы, чтобы получить 1, но я не знаю, как я могу получить что-нибудь еще.

Проверьте все .

Возможно, полезно: так fun aже, как fun('a'), так fun a bже, как fun('a','b')и так далее. Это может быть использовано в нескольких местах:

gt t g    % Equivalent to 't'>'g'. Returns 1. Uses space (available)
or o r    % Equivalent to 'o' | 'r'. Returns 1. 

Использование этого сделает 0доступным, но я пока не вижу, как сделать это полезным.

e (2.71828...)и jдо сих пор не используются. Должен удалить, ceilчтобы использовать eхотя.

Альтернативы (вдохновение):

1:  ~0             % Not 0 = 1
2:  2              % Numeral
3:  3              % Numeral
4:  fix(i^i^i^i)   % Numeral
5:  5              % Numeral
6:  6              % Numeral
7:  7              % Numeral
8:  8              % Numeral
9:  9              % Numeral 
10: 1+1+1+1+1+1+1+1+1+1   % Well, not much to explain
11: ['','RR'-'!']  % RR are [82,82] in ASCII, subtract 33 (!) to get
                   % [49,49], and concatenate with the empty string to convert [49,49] to 11 
12: nnz nnnnnnnnnnnn   % Number of non-zero elements in the string containing 12 n
13: "4"/4          % "4" = 52. Divide it by 4 to get 13.

JavaScript (ES7), 16 целых чисел, 137 130 128 байтов

Я взял ответ @ETHproductions и побежал с ним некоторое время; это настолько изменилось, что я публикую это отдельно. Идеи приветствуются. :)

""**""
-~-~{}
3
C=CSS==CSS;C<<C<<C
5
6
7
8
9
++[[]][+[]]+[+[]]
11
4444444444444444444%44
222>>2>>2
`..............i`.indexOf`i`
0XF
atob('MTY')

Осталось:
$_@#!^&|/?:, ABDEGHIJKLNPQRUVWZcghjklmpqrsuvwyz

Или, если фрагмент для 1 заменен на !!/!//!!/!/:
$_@#^&|*?:", ABDEGHIJKLNPQRUVWZcghjklmpqrsuvwyz

---

JavaScript (ES7), 16 целых чисел, 127 байт

Один байт короче. :П

""**""
-~-~{}
3
4
5
6
7
C=CSS==CSS;C<<C<<C<<C
9
++[[]][+[]]+[+[]]
11
`............i`.indexOf`i`
222>>2>>2
0XE
atob('MTU')
88888888888888888%88

Осталось: $_@#!/^&|?:,ABDFGHIJKLNPQRVWYZcghjklmpqrsuvwyz

Дьялог АПЛ, оценка 15, 89 байт

≡''
≢###
3
4
⍴⍬⍬⍬⍬⍬
6
⌈○2
8
9
1E1
⎕D⍳⊂⎕D











l:l
7--7-×7
(~0 0 0 0 0 0 0 0 0 0 0 0 0 0)⊥~0
5+5+5

_{Новые строки перед l:lявляются частью 12.}

_{Пробелы в 14 представляют вкладки.}

> <> , оценка 20, 93 90 74 65 байт

(3 байта сохранены Teal Pelican, много байтов сохранены Джо Кингом!)

iii((
2
3
ll{lll{[
5
6
7
8
!   00=0g
a
b
c
d
e
f
44*
'RA'%
999-9--
"&F#",,
1::+:++:+:+

Попробуйте их на рыбной площадке! Вы можете заставить фрагменты печатать свои результаты, добавляя n;в конец каждого из них. Обратите внимание, что 9-й фрагмент содержит вкладку, которая используется обменом стека.

Объяснение:

• В iii((каждый iпытается получить входные данные, но поскольку их нет, -1вместо этого они нажимают EOF = . Тогда (это менее чем инструкция, и, поскольку -1она не меньше -1, она толкает фальшивку 0; но вторая (спрашивает, -1меньше ли это, чем 0оно есть, поэтому оно выдвигает правду 1.
• 2и 3очевидны.
• Так ll{lll{[как первый lтолкает длину стека, то есть 0второй толкает новую длину, приводя к стеку 0, 1. В {вращает стек слева, поменять местами , 1и 0. Еще трое lприносят стек 1, 0, 2, 3, 4. Затем {вращается 1вперед и [откачивает первое, 1что есть в стеке 4.
• 5, 6, 7И 8очевидны тоже.
• В !\t00=0g(где \tпредставляет вкладку), !пропускает вкладку, затем 00=выталкивает два нуля и проверяет, равны ли они - они есть, так что мы получаем правду 1. После нажатия другой 0, gсимвол получает позицию в позиции 1,0кода, которая является вкладкой с кодом символа 9.
• aдо fкаждого толчка 10к 15соответственно (предположительно, чтобы сделать шестнадцатеричное значение хорошим).
• 44*толкает два 4с и умножает их вместе, для 16.
• 'RA'выталкивает коды символов Rи A(82 и 65 соответственно) в стек, затем %вычисляет 82 mod 65 = 17.
• 999-9--оценивает до 9 - ((9 - 9) - 9) = 18.
• "&F#"толкает коды символов &, Fи #, которые есть 38, 70и 35соответственно. Затем ,происходит разделение, поэтому мы получаем 38 / (70 / 35) = 19.
• Наконец, 1::нажимает a 1и дублирует его дважды, +добавляет два из них вместе, чтобы получить 2; :+дублирует 2и добавляет его к себе, чтобы получить 4; +добавляет остаток, 1чтобы получить 5; затем :+:+дублирует и добавляет дважды, что приводит к 20.

Это максимальная оценка возможная с> <>. Любой фрагмент код должен включать в себя инструкцию где - то , что превращает пустой стек в непустой стек, и есть только 18> <> инструкции , которые могут сделать это (а именно i, lи цифра 0–9и a–f), а также режим строки. (Любая другая инструкция либо ничего не делает с пустым стеком, ><v^/\|_#x!{}rлибо пытается выдать что-то и выдать ошибки ?.+-*,%=():~$@[]on&gp.) При вводе строкового режима используется либо "либо ', либо , таким образом, возможны не более 18 + 2 = 20фрагментов кода.

---

Если вам удобнее работать с печатными изданиями, чем я, это возможно в 53 байта, благодаря Джо Кингу:, 00=, iii((i-, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f, 2222***, !Xll$g, 11+::+:+:++, 'Y', "Z"гдеX , Yи Zзаменяются символами с кодами 17, 19и 20соответственно.

MathGolf , 48 51 53 целых числа, 324 байта

î
ª∞~
c±b±+
φⁿ_¥-
5
6
7
○¢i♀/
d²
♂
A
B
C
D
E
☻
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
♥
U
V
W
X
Y
Z
♫¼¼¼¼
88888]Σ
41
╔½½½½½½½½½½½
π░3§3
22#22#
τ╥└
♦⌡⌡⌡⌡⌡⌡⌡⌡⌡
!⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠
'0$
ÿ@@@@£9
))))))))))))))))))))))))))))))))))))))))))))))))))
►◄╠•╠
"hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"h 
♣(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((

+2 балла (и -2 различных байта, используемых для 40) благодаря @maxb .

Каждая строка - это отдельная программа.

Используемые байты (92 байта): îª∞~c±b+φⁿ_¥-567○¢i♀/d²♂ABCDE☻FGHIJKLMNOPQRST♥UVWXYZ♫¼8]Σ41╔½π░3§2#τ╥└♦⌡!⌠'0$ÿ@£9)►◄╠•╠"h ♣(

Пояснения и TIO-ссылки:

MathGolf - новый язык игры в гольф, специализирующийся на задачах математического гольфа. Он имеет множество однобайтовых встроенных функций для чисел, что делает его идеальным испытанием для него.

1) î: нажмите 1-индексированное значение цикла, которое по умолчанию равно 1: попробуйте онлайн.
2) ª∞~: нажмите [1]; удвоить его ([2]); всплывающий список и поместите его содержимое в стек: попробуйте онлайн.
3) c±b±+: нажать -2; затем нажмите и нажмите его абсолютное значение; нажать -1; затем нажмите и нажмите его абсолютное значение; и сложите их вместе. Попробуйте онлайн.
4) φⁿ_¥-: нажмите золотое сечение (1,618033988749895); куб это (4.23606797749979); дублировать вершину стека; взять по модулю 2 (0,23606797749979); вычтите их друг из друга: попробуйте онлайн.
5,6,7) Сами цифры: попробуйте онлайн. Попробуйте онлайн. 9) : нажать -3; квадрат:
8) ○¢i♀/: толчок 2048; преобразовать в шестнадцатеричную строку (800); приведение к целому числу; нажать 100; делить:
d² попробуйте онлайн. 10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33, 34,35,36,37,38) Вставьте встроенные функции для самих чисел ( ♂ABCDE☻FGHIJKLMNOPQRST♥UVWXYZ): попробуйте онлайн.
39) ♫¼¼¼¼: нажать 10000; целое число делится на 4 четыре раза: попробуйте онлайн.
40) 88888]Σ: нажать 8 пять раз; оберните их в список; Суммируйте этот список: попробуйте онлайн.
41) Сам номер: попробуйте онлайн.
42) ╔½½½½½½½½½½½: толчок 86400; целое число делится на 2 одиннадцать раз: попробуйте онлайн.
43) π░3§3: нажать пи ( 3.141592653589793); приведение к строке; вытолкните и нажмите на его третий 0-индексированный символ (4); нажмите 3; вывод всего стека, объединенного неявно:Попробуйте онлайн. : Нажать 2 два раза; взять власть двоих (4); сделай это снова; вывод всего стека, объединенного неявно: попробуйте это онлайн. 45) : Push 2 * PI (6,283185307179586); вытолкните и нажмите на 2 под ним, что ближе всего (4); нажмите на верх стопки + 1, не нажимая (5); вывод всего стека, объединенного неявно: попробуйте это онлайн. 46) : толчок 64; уменьшить в 2 раза: попробуйте онлайн. 47) : Push-гамма (n + 1) (по умолчанию 1); увеличить на 2 двадцать три раза: попробуйте онлайн. 48) : нажимная строка
44)22#22#
τ╥└
♦⌡⌡⌡⌡⌡⌡⌡⌡⌡
!⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠
'0$: Нажмите порядковый номер символа '0': попробуйте онлайн.
49) ; вытолкните и протолкните его длину (4); нажмите 9; вывод всего стека, объединенного неявно: попробуйте это онлайн. 50) : увеличение в 1 пятьдесят раз: попробуйте онлайн. 51)ÿ@@@@£9"@@@@"
))))))))))))))))))))))))))))))))))))))))))))))))))
►◄╠•╠: Толчок 1 000 000; Толчок 10 000 000; вытолкнуть оба и целочисленно разделить их друг с другом (10); нажмите 512; совать оба и целочисленно делить их друг с другом: попробуйте онлайн.
52) "hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"h : нажимная струна "hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"; протолкнуть его длину (не вставляя строку); удалить все из стека, кроме последнего: попробуйте онлайн.
53) ♣(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((: толчок 128; уменьшено на 1 семьдесят пять раз: попробуйте онлайн.

Попробую добавить еще немного позже. У меня остались некоторые полезные вещи, в том числе по модулю %и умножению *.

Java 8, 11 12 13, 39 байт

В Java только 10 символов для чисел (0-9), и для всех вызовов методов и констант требуется точка, поэтому я не уверен, что смогу получить результат выше 11

Видимо, символы применяются к целым числам по умолчанию, когда применяются операции

+1 с помощью @ OlivierGrégoire

i->-~i
2
3
4
5
6
7
8
9
'P'^'Z'
11
"::::::::::::"::length
0xD

Пояснения:

i->-~i

целое число лямбда, которое не принимает никаких входных данных и возвращает 1. Когда параметр не принимает никаких входных данных, используется значение по умолчанию в соответствии с вышеуказанным мета-сообщением, которое для целых чисел равно 0

2
3
4
5
6
7
8
9

целые буквальные числа

'P'^'Z'

XOR двух символов, чтобы вернуть 10

11

буквальное целое число

":::::::::::"::length

лямбда-выражение, которое возвращает длину строки из 12 символов

0xD

Шестнадцатеричное 13

Ссылка TIO, если вы хотите проверить.

Gaia , оценка 25, 203 байта

§‼
..⌉+⌉
₵P~~
4
5
6
∂Ql
8
9
¶c
11
'¡ċ⌋u⌋
--⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻
7:,Σ
Ø!))))))))))))))
øøw<øøw<«øøw<«øøw<«øøw<«
⟩‘
₸ḣ₸K$₸ḣ₸/S₸₸/=$
]]]]]]]]]]]]]]]]]]]n
⇑’e
0(((((((((((((((((((((_
22
“B”“↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺B”B
3₈×
ℍḥḥ

Я считаю, что это идеальный результат, так как больше нельзя использовать нилад с учетом ограничений персонажа.

Пояснения

1. §‼

§является символом пробела, ‼приводится к логическому значению, поэтому результат равен 1.

2. ..⌉+⌉

.это ярлык для 0.5, так что это ceil(0.5+ceil(0.5)).

3. ₵P~~

₵Pэто пи, ~побитовое отрицание. Двойное побитовое отрицание - это просто усечение.

4. 4

5. 5

6. 6

7. ∂Ql

∂Qэто список, содержащий названия дней недели, lэто длина.

8. 8

9. 9

10. ¶c

Кодовая точка cперевода строки ¶.

11. 11

12. '¡ċ⌋u⌋

'¡  The string "¡"
ċ   Turn it into a list of code points: [161]
⌋   Minimum: 161
u⌋  Floored square root: 12

13. --⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻

-это сокращение для -1, ⁻является вычитанием. Так что это -1 - -1 - -1...достаточно раз, чтобы сделать 13.

14. 7:,Σ

Нажмите 7, продублируйте :, объедините ,две семерки в список и суммируйте Σ.

15. Ø!))))))))))))))

Øпустая строка, Ø!равно 1. Увеличьте )1 в 14 раз.

16. øøw<øøw<«øøw<«øøw<«øøw<«

øø    Push two empty lists
w     Wrap one of them
<     [] < [[]]? (it is, so push 1)
øøw<  Do the same thing again to push another 1
«     Bitshift 1 left by 1
      Do that same thing again 3 more times to get 16

17. ⟩‘

Закрытие строки с помощью ‘делает его буквальным числом base-250. ⟩находится в значении байта 17 в кодовой странице Gaia.

18. ₸ḣ₸K$₸ḣ₸/S₸₸/=$

₸     10
ḣ     doubled
₸     10
K     20 choose 10 (184756)
$     Digit list
₸ḣ₸/  20/10 (2)
S     Split the digit list at index 2 ([[1 8][4 7 5 6]])
₸₸/   10/10 (1)
=     Get the first element of that split ([1 8])
$     Join together and print 18

19. ]]]]]]]]]]]]]]]]]]]n

Каждый ]упаковывает стек в список. Сделайте это 19 раз и получите глубину nсписка.

20. ⇑’e

Закрытие строки с помощью ’делает список кодовых точек кодовой страницы. eвыводит список в стек ⇑имеет кодовую точку 20 в кодовой странице.

21. 0(((((((((((((((((((((_

Уменьшение (0 21 раз, затем отрицание _.

22. 22

23. “B”“↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺B”B

Преобразуйте строку “B”из базы-24, где цифры от 0 до 23 ↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺B. Результат есть 23.

24. 3₈×

3 × 8.

25. ℍḥḥ

100 ℍвдвое ḥи снова наполовину.

С, оценка 13

Это просто набор целочисленных констант.

0==0
__LINE__
3
4
5
6
7
8
9
1+1+1+1+1+1+1+1+1+1
'o'/'.' 
2*2*2*2-2-2
strlen("strlenstrlens")

1. 0==0оценивается в 1
2. Предполагается, что код находится в строке 2. __LINE__= 2
3. Целочисленная константа
4. Целочисленная константа
5. Целочисленная константа
6. Целочисленная константа
7. Целочисленная константа
8. Целочисленная константа
9. Целочисленная константа
10. 1+1+1...= 1*10= 10
11. 'o'111, '.'представляет непечатаемый ASCII 0x10. 111/10 = 11
12. (2<<2)= 8, 8*2= 16, 16-2-2= 12
13. длина строки "strlenstrlens"= 13

Ом , оценка 21 22, всего 160 байт

╓S@Ri
ΓΓ-Γ-Γ-
αê⌠
¡¡¡¡¼
5
▀lll▀l
ÑÑÑÑÑÑÑÿWÿk
ü`½½
9
..≥°
$$J
3dd
7ƒ
2≡≡≡Σ
║F
4º
0ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~
6DD++
8π
τ╛hτ*
"≤"≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤A
1111 11v11%L1111 11v11%L

Попробуйте онлайн!

Пояснения

1. ╓S@Ri

Нажмите секунды текущей даты / времени ( ╓S). Получите включающий диапазон от 1 до секунд ( @), измените его ( R), получите последний элемент ( i), который всегда равен 1.

2. ΓΓ-Γ-Γ-

Γ равно -1, так что это (-1) - (-1) - (-1) - (-1), что равно 2.

3. αê⌠

αêэто число Эйлера (2.71828 ...), ⌠это потолок. 3 является результатом.

4. ¡¡¡¡¼

¡увеличивает счетчик, ¼толкает счетчик.

5. 5

Просто буквально.

6. ▀lll▀l

▀lll▀является сжатым строковым литералом, который эквивалентен "of >ic". lберет длину, поэтому результат равен 6.

7. ÑÑÑÑÑÑÑÿWÿk

Сначала мы нажимаем 7 символов новой строки chars ( Ñ), а затем пустую строку ( ÿ). Стек упакован в array ( W), и затем найден индекс пустой строки в этом массиве.

8. ü`½½

üэто космический персонаж. `толкает его значение ASCII (32), затем он удваивается вдвое ( ½½).

9. 9

Просто буквально.

10. ..≥°

..это буквальный .персонаж. Он получает incremental ( ≥), который анализирует строку как число, по умолчанию принимает значение 0, поскольку это недопустимое число, и увеличивает его до 1. Затем мы вычисляем 10 ¹ ( °).

11. $$J

$ выталкивает текущее значение регистра, изначально 1. Итак, дважды нажмите 1, объедините стек и напечатайте.

12. 3dd

Нажмите 3 и удвойте его дважды.

13. 7ƒ

Толкает 7-е число Фибоначчи.

14. 2≡≡≡Σ

Нажмите 2, трижды продублируйте его, оставив 7 2 на стеке. Затем возьмите сумму стека ( Σ).

15. ║F

║является разделителем для литералов базы 220. Так как это в конце строки, его не нужно завершать.

16. 4º

Вычислить 2 ⁴ .

17. 0ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~

òявляется побитовым отрицанием, ~является арифметическим отрицанием. Комбинируя эти операторы, мы можем увеличить 0 в 17 раз.

18. 6DD++

Нажмите 6, продублируйте дважды и вычислите 6 + 6 + 6.

19. 8π

Нажмите 8-е простое число.

20. τ╛hτ*

Нажмите 10 ( τ), получите первый элемент ( h) из его простых множителей ( ╛), умножьте это на 10.

21. "≤"≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤A

Как и в предыдущих фрагментах, строка "≤"анализируется как 0. Мы уменьшаем ее 21 раз, а затем принимаем абсолютное значение.

22. 1111 11v11%L1111 11v11%L

Здесь мы вычисляем 1111 div 11 mod 11, который равен 2, затем выводим 2. Затем делаем это снова.

PowerShell, оценка 12, 91 байт. 14, 176 байт

[byte]!![byte]                    # type gets cast to bool false, inverted, to int = 1
-   -$?-shl$?                   # -bool true is -1, shift left, negative. (Tab not space)
3
4
5
6
7
8
9
1+1+1+1+1+1+1+1+1+1
22/2                                           # use the 2
'uuuuuuuuuuuu'.LENGTH                          # string length
0xd
@{z=@{};Y=@{};YY=@{};w=@{};v=@{};U=@{};zz=@{};S=@{};r=@{};q=@{};p=@{};J=@{};K=@{};m=@{}}|% COU*             # count items in hashtable (space)

Редактировать:

• Спасибо Орджану Йохансену за предложенный шестнадцатеричный литерал 0xd для 13 и перестановку 5 для освобождения 1 + 1 + 1 + 1 .. в качестве опции.
• Изменена длина массива на длину строки, с [int] на [byte] и hashtable для использования хеш-таблиц в качестве значений, освобождая (),""Pondering 15 с чем-то вроде, "ZZZZZZZZZZZZZZZA".InDeXof("A")но не может повторно использовать точку или 'e' ..

PowerShell не может делать переменные без $, не может возводить в степень, сдвигать биты, Pi, ceil () и т. Д. С базовыми символами и в основном вводит коэрциан в / из bool и в / из чисел-как-строк, поэтому относительно мало возможностей для генерации номеров с низким синтаксисом.

TI-Basic (серия 83), оценка 21 22 23 24 25 (1003 байта)

1:  A=A
2:  int(tan(tan(cos(cos(cos(B
3:  tanh⁻¹(√(√(√(√(√(√(√(√(√(√(C!°√(√(C!°
        √(√(√(√(√(√(C!°√(√(√(√(√(√(C!°√(
        C!°√(√(√(C!°√(C!°√(C!°√(√(√(√(√(
        √(C!°√(C!°√(C!°√(C!°
4:  4
5:  cosh(sinh⁻¹(cosh(sinh⁻¹(...sinh⁻¹(cosh(D    with 25 repetitions of cosh(
6:  6
7:  7
8:  8
9:  9
10: ₁₀^(₁₀^(E
11: 11
12: F nPr F/sin(tan⁻¹(...(sin(tan⁻¹(F nPr F     with 143 repetitions of sin(tan⁻¹(
13: det([[G≤G]...[G≤G]]ᵀ[[G≤G]...[G≤G           with 26 repetitions of G≤G
14: ln(tanh(not(H))...tanh(not(H)))
        ln(tanh(not(H)))^⁻not(H                 with 14+1 repetitions of tanh(not(H))
15: iPart(e^(e^(e^(I
16: sum(dim(identity(sum(dim(identity(sum(
        dim(identity(sum(dim(identity(J≥J
17: K nCr K+K nCr K+...+K nCr K                 with 17 repetitions of K nCr K
18: abs(i-i-...-i                               with 20 repetitions of i
19: rand→L:log(LL...LL→M:log(L→N:N⁻¹M           with 19 L's inside the log
20: mean(seq(OOO,O,O,sinh(sinh(cos⁻¹(O
21: ππ³√(π³√(ππ³√(ππ³√(ππ³√(π³√(³√(ππ³√(π³
        √(π³√(ππ³√(π³√(ππ³√(ππ³√(ππ³√(π³√(
        π³√(³√(ππ³√(ππ
22: 22
23: 3(3(3×√(3(3(3×√(3(3×√(3(3(3×√(3×√(3×√(
        3(3×√(3(3×√(3(3(3×√(3(3×√(3×√(3(3(
        3×√(3(3×√(3×√(3×√(3(3(3×√(3(3×√(3(
        3(3×√(3×√(3(3(3×√3
24: Fix 0
    sin⁻¹(ᴇ0
    AnsAnsAnsAnsAnsAnsAns
25: 5*5

См. Http://tibasicdev.wikidot.com/one-byte-tokens для получения списка того, что задача делает и не разрешает здесь.

Все это могут быть законченные программы, поскольку последняя строка программы печатается автоматически. Но (за исключением 17, который состоит из нескольких строк), они также могут быть фрагментами на домашнем экране.

На данный момент я не вижу другого способа получить какой-либо ненулевое значение из оставшихся маркеров доступны. Если нужно что-то улучшить, сначала потребуется сделать некоторые из приведенных выше решений более консервативными.

Пояснения

• A=A является логическим 1, потому что переменная A равна себе.
• B по умолчанию 0 tan(tan(cos(cos(cos(B примерно 2.21, а потом мы берем слово.
• C!°составляет 1 градус в радианах, около 0,017. Некоторой положительной силой этого является tanh (2), около 0,964. Мы кодируем эту мощность в двоичном виде, используя подразумеваемое умножение и√( , а затемtanh⁻¹( .
• 4 проста
• cosh(sinh⁻¹(X$\sqrt{1+X^2}$
• 6-9 просты
• ₁₀^( является однобайтовым встроенным для степеней 10 и 10 ^ 10 ^ 0 = 10 ^ 1 = 10.
• 11 - это 11.
• F nPr Fsin(tan⁻¹(X$\frac{1}{\sqrt{1+1/X^2}}$
• G≤Gравно 1, то [[G≤G]...[G≤G]]есть вектор столбца 13x1. Взятие продукта его транспонирования с собой дает матрицу [[13]], детерминант которой 13.
• not(H)is 1. tanh(not(H))это просто некоторое число, не равное 0 или 1, и оно ln(XXX....X)ln(X)^⁻1будет упрощено до числа Xs в первом журнале, еслиX это не 0 (так что журнал существует) и не 1 (так что мы не делим на 0).
• e^(e^(e^(F оценивается примерно в 15.15, а затем мы берем слово.
• J≥Jis 1. identity(создает единичную матрицу 1x1, dim(находит размеры ее строк и столбцов и sum(добавляет их для получения 2. Затем мы делаем это снова, добавляя размеры матрицы 2x2 для получения 4, и снова добавляя размеры матрицы 4x4 чтобы получить 8, и снова, добавив размеры матрицы 8x8, чтобы получить 16.
• K nCr K является биномиальным коэффициентом 0, выберите 0 или 1. Сложение 17 1 дает 17.
• i-i-...-iупрощается до i18i, а взятие abs(дает 18.
• rand→Lсохраняет случайное действительное число в L, но нам все равно, что это такое. Мы вычисляемlog(L)⁻¹log(L^19) , что упрощает до 19.
• sinh(sinh(cos⁻¹(Iнемного больше 4, поэтому seq(III,I,I,sinh(sinh(cos⁻¹(Iдает список {0 1 8 27 64}, среднее арифметическое которого равно 20.
• Другой пример трюка, использованного для получения 3. Здесь некоторая сила πдолжна давать 21; мы закодируем эту мощность в троичной форме, используя подразумеваемое умножение и ³√(.
• 22 - это 22.
• Другой пример уловки, использованной для получения 3 и 21. Мы кодируем степень 3, равную 23 в троичной форме, используя в 3×√(качестве корня куба и (для умножения.
• Fix 0это настройка для отображения 0 цифр после десятичной дроби, округляя все значения в целые числа. sin⁻¹(ᴇ0оценивается как π / 2, а π / 2, умноженное на себя 7 раз, дает примерно 23,59, что округляет до 24.
• 5*5равно 25. (Было бы более консервативно использовать, 5чтобы получить 5 и адаптировать решение, используемое там для 25. Но этот способ экономит много места и *не очень полезен, потому что подразумевается умножение.)

SOGL , оценка 16 18 20, 109 байтов, 47 используемых символов

=                    push ""=""
ρ:¾/U                ceil(isPalindrome("")/(isPalindrome("")*(3/4))) -> ceil(1/(3/4)) -> ceil(4/3)
3                    push 3
MM¼÷                 100/(100*1/4)
æ⁄                   length of "aeiou"
6                    push 6
7                    push 7
Nτ                   log2(256)
9                    push 9
L                    push 10
⁹’                   byte with the 11th SOGL code point
Ιζrkk"⁸              `⁸`s UTF-8 codepoint to string, take off 1st 2 chars
'⁰                   messy compression
īuHHHHHHHHHHHHHH±    floor(0.1) `-1` 14 times, then change sign
aIIIIIIIIIIIIIII     A `+1` 15 times, A = 0
4²                   4^2
lllllllllllllllll”l  length of "lllllllllllllllll"
222222222++++++++    2+2+2+2+2+2+2+2+2
δ“○“-                429-420
Μ℮‘                  compressed string of "2ŗ" where ŗ defaults to 0

Брахилог , 16 целых, 86 байт

1
2
3
4
5
6
7
8
9
ℕ<<<<<<<<<<
≜+₁₁
Ịbkkkkkkkị
Ḥl
ℤ₇×₂ṅ
"____**"pᶜ¹
⟦h>>>>>>>>>>>>>>>>ȧ

Попробуйте онлайн! (Ввод определяет, какая программа запускается, от 1 до N)

объяснение

                       The output is...

1                      1
2                      2
3                      3
4                      4
5                      5
6                      6
7                      7
8                      8
9                      9
ℕ<<<<<<<<<<            Strictly bigger than ... strictly bigger than 0
≜+₁₁                   0 + 11
Ịbkkkkkkkị             "12" converted to an integer
Ḥl                     The length of "Hello, World!"
ℤ₇×₂ṅ                  -(-7 × 2)
"____**"pᶜ¹            The number of unique permutations of "____**"
⟦h>>>>>>>>>>>>>>>>ȧ    The absolute value of stricly less than ... stricly less than 0

Желе , оценка 22, 177 байт

1: Ṇ  : logical NOT. When there is no input, 0 is assumed, so this returns NOT(0)=1
2: ~A~A  : ~ is bitwise NOT and A is absolute value, implicit 0 input
         : 0~ = -1;   0~A = 1;   0~A~ = -2;  0~A~A = 2.
3: 3  : literal 3
4: -ı-²²×-Ḟ:
   -ı-     : literal complex number -1-1j
   ²²×-    : square (2j), then square(-4), then multiply by (×) negative 1 (-) to get 4+0i
   Ḟ       : get the real component, which is 4
5: 5  : literal 5
6: 6  : literal 6
7: 7  : literal 7
8: 8  : literal 8
9: ØDṪ : tail(Ṫ) of list of digits (ØD) to return 9
10: ⁵  : literal 10
11: 11 : literal 11
12: CNCNCNCNCNCNCNCNCNCNCNC : again, 0 is taken as input because there is no input
                            : C is complement and N is negate
                            : so each NC returns 1-(-n)=n+1 and is equivalent to increment, returning 12
13: “>>>>>»L    : encodes "#GlomAbducens" with “>>>>>» then returns the length in characters (13) with L
14: ‘‘‘‘‘‘‘‘‘‘‘‘‘‘   : default input is 0 again, and each ‘ increments it to get 14
15: Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;ỊS : default input is 0 again.
                                   : each Ị returns abs(0)<1 = 1
                                   : these are concatenated together with ; then summed with S to get 15
16: ⁴  : builtin literal 16
17: ,,,,,,,,,,,,,,,,,ŒḂŒḊ : Each , is the pair dyad: x,y = [x,y] and x,[y,z] = [x,[y,z]]. 
                          : Thus each , increased the depth by 1, then ŒḊ returns the depth: 17
18: 9Ḥ : 9 doubled = 18
19: E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E : each E returns areallelementsidentical([0]) = 1
                                          : 19 of these are summed with +
20: 44440b44ạ/ : 44440 base 44 = [22,42,0].
               : ạ/ takes the absolute difference of terms: ||22-42|-0| = 20
21: ”TOHH : ”T is the character literal "T". OHH returns its ascii value 84 (O) halved twice (HH) = 21
22: literal 22

Попробуйте все сразу или попробуйте по одному (аргумент - это какой вывод вы хотите).

Неиспользуемые символы:

¡¢£¤¥¦©¬®µ½¿€ÆÇÐÑÞßæçðȷñ÷øœþ !"#$%&'()*.:<=?@BFGIJKMPQRUVWXYZ[\]^_`acdefghijklmnopqrstuvwxyz{|}¶°¹³⁶⁷⁸⁹⁺⁻⁼⁽⁾ƁƇƊƑƓƘⱮƝƤƬƲȤɓƈɗƒɠɦƙɱɲƥʠɼʂƭʋȥẠḄḌẸḲḶṂỌṚṢṬỤṾẈỴẒȦĊĖḞĠḢİĿṀṄȮṖṘṠẆẊẎŻḅḍẹḥịḳḷṃṇọṛṣṭụṿẉỵẓȧḃċḋėḟġḣŀṁṅȯṗṙṡṫẇẋẏż«’

Reng, оценка 40, 149 байт

Попробуй это здесь!

1.  e
2.  2
3.  ::l
4.  4
5.  5
6.  i`i`i`i`i`i`+++++
7.  7
8.  8
9.  9
10. A
11. ÇÇÇǹ
12. C
13* [[[[[[[[[[[[[mn~
14. E
15. F
16. G
17. H
18. I
19. J
20. K
21. L
22. M
23. N
24. O
25. P
26. Q
27. R
28. S
29. T
30. U
31. V
32. W
33. X
34. Y
35. Z
36. 6²
37. "%"
38* &fæ¦
39. D3*
40. 11±$1±±±±±±±±$11±$1±±±±$±$

Все заглавные буквы цифры, так что это приятно. Все, кроме двух, являются фрагментами. Два, которые являются программами:

13. [[[[[[[[[[[[[mn~
38. &fæ¦

Предоставленная ссылка позволяет увидеть стек во время работы. Я напишу объяснение позже.

CJam, оценка 27, 168 байт

1-3: X , Y,Z

Переменные X, YиZ инициализируются в 1, 2 и 3, соответственно.

4: ",,,,",

Нажмите на строку ,,,,и возьмите длину.

5-9: 5 , 6, 7, 8,9

Числовые литералы.

10-20 : A-K

Преинициализированные переменные.

21: U)))))))))))))))))))))

Переменная Uинициализируется в 0. Нажмите Uи увеличьте его в 22 раза.

22: 22

Числовой литерал.

23: ';(((((((((';((((((((

Нажмите символ ;и уменьшите его 9 раз, чтобы получить 2, затем нажмите ;снова и уменьшите его 8 раз, чтобы получить 3.

24: 4m!

Возьмите факториал 4.

25: TT=TT=+TT=TT=TT=TT=TT=++++

TT=выталкивает 1. Этот код эквивалентен 1 1+1 1 1 1 1++++.

26: N:i~W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-

Nтолкает строку, содержащую новую строку. :iпреобразует его в список кодов символов, уступая [10]. ~распаковывает, даёт 10. W-является эквивалентом добавления одного. Увеличение 10 в шестнадцать раз дает 26.

27: LLLLLLLLLLLLLLLLLLLLLLLLLLL0]0#

Найдите индекс 0 в списке, где 0 находится на 27-м индексе.

Персонажи по-прежнему доступны: $%&*./1<>?@MOPQRSV[\^_`abcdefghjklmnopqrstuvwxyz{|}

Несколько замечаний для потенциального расширения:

• Возможно, мне придется изменить 10-20, чтобы использовать переменные для чего-то еще. Если я получу числа больше 1, я смогу использовать *(и, возможно, побитовые операторы, но я не думаю, что они сильно помогут).

• У меня все еще есть S, все хорошее, что принесет мне пользу.

• Если я поменяю 26 на N{}/iW-W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-, то :будет доступно.

• Я могу выдвинуть несколько пустых списков и получить больше нулей с существующими переменными. Я также могу получить π, но это не кажется очень полезным, если я не могу как-то привести его к целому числу, и m(для m[) и iуже занято.

• С точки зрения манипулирования массивами, я могу:

  • Используйте карту с %илиf
  • Используйте сгиб с *
  • Выполните некоторые операции
  • Базовое преобразование (кажется многообещающим, но я не знаю, как получить базовое число)
  • Создайте массивы, используя |:M1|2|3|

Haskell , оценка 13, 86 байт

pi/pi
sum[sum[]^sum[],sum[]^sum[]]
3
4
5
6
7
8
9
length"eeeeeeeeee"
11
2+2+2+2+2+2
0xD

Попробуйте онлайн!

Спасибо Эрджану Йохансену за то, что он нашел способ исправить совпадение моего письма, сохранив счет тринадцать. (Также за то, что старались изо всех сил, чтобы уведомить меня об этом, пока этот ответ был удален.)

pi/piесть 1.0.
sum[]оценивает к 0, 0^0к 1и sum[1,1]к 2. 3чтобы 9просто расшифровать себя.
length"eeeeeeeeee"дает длину строки, которая является 10.
2+2+2+2+2+2есть 12.
0xDявляется шестнадцатеричным для 13.