Если вам это нравится, рассмотрите возможность участия в:

• Официальный Dyalog APL 2016 года игра

• Ежемесячный Dyalog APL 2017 Code Golf Challenge

Создайте 12 фрагментов / выражений на одном языке, которые приводят к числам от 0 до 10 и 42 соответственно, но без записи каких-либо буквенных числовых, строковых или символьных данных.

Встраиваемые данные, такие как PI()и ALPHABET(), хороши, как, например, константы CJam U, X, Y, Z и A, а также обработка BLEND, CHORD, CENTER, BREAK и LINES.

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

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

Примеры допустимых фрагментов

3: INT(LOG10(YEAR(TODAY()))) потому что это остается верным в обозримом будущем
4: CUBICROOT(LEN(CHARACTERSET())) потому что набор символов из 256 букв очень распространен
8: SQRT(SYSTEMTYPE()) потому что 64-битные системы очень распространены

Примеры неверных фрагментов

5: LEN(USERNAME()) потому что большинство людей не используют «Admin» для входа в систему :-)
9: LOG10(SYSTEMMEMORY()) потому что он работает только в системах с ровно 1 ГБ памяти
42: CODE("*") потому что он содержит строковый / символьный литерал

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

Разрешены только языки символов.

Оценка - это общее количество байтов всех 12 объединенных фрагментов. Новые строки, разделяющие фрагменты, не учитываются.

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

Вопросы-Ответы

В Могут ли программы принять любой ввод?
О Да, но вы можете не просто запросить ввод и ввести соответствующий номер.

Q Разрешены ли физические цифры (не данные)? Да, например .
LOG10()

Q Символы в Ruby считаются литералами?
А да.

Q Включает ли оценка новые строки между каждым фрагментом? No.

Q Достаточно ли TI-BASIC «на основе символов», чтобы быть действительным?
А да.

Q Ложь и истина считаются числовыми литералами? Нет, они являются приемлемыми.

В Можем ли мы использовать числовой литерал для вызова функции, если это единственный способ, и число не влияет на вывод функции?
О Да, если это нормальный способ написания кода на вашем языке.

Q Мой язык предполагает, что в начале каждой программы / выражения есть [что-то]. Должен ли я включить его, или мои фрагменты должны просто работать, если они помещены в середину программы / выражения? Они просто должны работать в середине программы / выражения.

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

В Является ли приемлемым один фрагмент кода, который может печатать все указанные числа?
О Нет, они должны быть отдельными и взаимно независимыми.

Q Могу ли я предположить, что шаблон int main() {}...или аналог?
А да.

Q Какие выходные типы данных разрешены?
A Любой числовой тип данных, например, int, float и т. Д.

Q Нужно ли печатать результат каждого фрагмента?
A Нет, достаточно сделать результат доступным для последующего использования.

В Допустимы ли предварительно установленные переменные? Да, и они становятся сброса (если он был изменен) для каждого фрагмента.

Q π и e считаются числовыми литералами? Нет, вы можете использовать их.

Q Могу ли я вернуть 4 и 2 в разные ячейки для 42?
О Нет, они должны быть связаны как один номер.

Q байтов или символов? Bytes, но вы можете выбрать любой желаемый кодовую.

Q Могут ли использоваться постоянные функции и заданные переменные, такие как J 9:, Actually 9и Pretzel 9?
A Да, если словарный запас конечен (19 для J, 10 для Actual и Pretzel).

Гексагония , 13 байт

1
2
3
4
5
6
7
8
9
10
42

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

В Hexagony 0сквозными 9являются функции, которые умножают текущую память на 10, а затем добавляют число, представленное именем функции. Следовательно, первый фрагмент пуст, поскольку воспоминания начинаются как 0.

Например, если текущая память есть 65, выполнение функции 3создаст текущую память 653.

(Для downvoters: downvote все, что вы хотите; я готов.)

Функцион , 1222 байта

Помимо числовых литералов, есть два способа, которыми я могу создать значение (любое значение вообще) в Funciton: выражения stdin и lambda. Stdin - это одно поле, в то время как для полного лямбда-выражения требуется больше синтаксиса, поэтому я собираюсь использовать stdin. Однако, несмотря на то, что stdin может быть чем угодно, все следующие операции работают независимо от того, какой ввод предоставляется.

Все используемые здесь библиотечные функции существовали до публикации заявки.

0 (40 байт в UTF-16)

╔╗┌┐
║╟┤└┼┬┐
╚╝└─┘└┘

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

1 (52 байта в UTF-16)

╔╗┌─╖┌─╖
║╟┤⌑╟┤ɕ╟
╚╝╘═╝╘═╝

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

2 (70 байт в UTF-16)

╔╗┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ɕ╟
╚╝╘═╝╘═╝╘═╝

= 2¹. ʂгенерирует все подпоследовательности последовательности и, таким образом, превращает последовательность из n элементов в последовательность с 2ⁿ.

3 (88 байт в UTF-16)

╔╗┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ɕ╟┤♯╟
╚╝╘═╝╘═╝╘═╝╘═╝

= 2 + 1. ♯увеличивает значение на 1.

4 (88 байт в UTF-16)

╔╗┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ʂ╟┤ɕ╟
╚╝╘═╝╘═╝╘═╝╘═╝

= 2².

5 (106 байтов в UTF-16)

╔╗┌─╖┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ʂ╟┤ɕ╟┤♯╟
╚╝╘═╝╘═╝╘═╝╘═╝╘═╝

= 4 + 1.

6 (106 байт в UTF-16)

╔╗┌─╖┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ɕ╟┤♯╟┤!╟
╚╝╘═╝╘═╝╘═╝╘═╝╘═╝

= 3 факториала.

7 (110 байт в UTF-16)

┌───┐┌─╖┌─╖┌─╖╔╗
│┌─╖├┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤A╟┘╘═╝╘═╝╘═╝╚╝
 ╘╤╝

= A (2, 2) (функция Аккермана).

8 (118 байт в UTF-16)

┌────┐┌─╖┌─╖┌─╖╔╗
│┌──╖├┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤<<╟┘╘═╝╘═╝╘═╝╚╝
 ╘╤═╝

= 2 << 2 (сдвиг влево).

9 (128 байт в UTF-16)

┌───┐┌─╖┌─╖┌─╖┌─╖╔╗
│┌─╖├┤♯╟┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤×╟┘╘═╝╘═╝╘═╝╘═╝╚╝
 ╘╤╝

= 3 × 3.

10 (146 байт в UTF-16)

┌───┐┌─╖┌─╖┌─╖┌─╖┌─╖╔╗
│┌─╖├┤♯╟┤ɕ╟┤ʂ╟┤ʂ╟┤⌑╟╢║
└┤+╟┘╘═╝╘═╝╘═╝╘═╝╘═╝╚╝
 ╘╤╝

= 5 + 5.

42 (170 байт в UTF-16)

┌──────┐┌─╖┌─╖┌─╖┌─╖┌─╖╔╗
│┌─╖┌─╖├┤!╟┤♯╟┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤♯╟┤×╟┘╘═╝╘═╝╘═╝╘═╝╘═╝╚╝
 ╘═╝╘╤╝

= 6 × (6 + 1).

JavaScript, 144 141 140 138 132 125 123 байта

С помощью @ edc65 , @Sjoerd Job Postmus , @DocMax , @usandfriends , @Charlie Wynn и @ Mwr247 !

result.textContent = [

+[]                          ,// 0  (3 bytes)
-~[]                         ,// 1  (4 bytes)
-~-~[]                       ,// 2  (6 bytes)
-~-~-~[]                     ,// 3  (8 bytes)
-~Math.PI                    ,// 4  (9 bytes)
-~-~Math.PI                  ,// 5  (11 bytes)
-~-~-~Math.PI                ,// 6  (13 bytes)
Date.length                  ,// 7  (11 bytes)
(a=-~-~[])<<a                ,// 8  (13 bytes) = (2 << 2)
(a=~Math.E)*a                ,// 9  (13 bytes) = (-3 * -3)
(a=-~-~[])<<a|a              ,// 10 (15 bytes) = ((2 << 2) | 2)
(a=Date.length)*--a           // 42 (19 bytes) = (7 * 6)

];

<pre id="result"></pre>

Мышь-2002 , 27 26 17 14 байт

Первые фрагменты нажимают 0-10, а ZR+толкает 25тогда 17и 25 17 + 42 =есть 1.

A
B
C
D
E
F
G
H
I
J
K
ZR+

CJam, 27 24 байта

U    e# 0
X    e# 1
Y    e# 2
Z    e# 3
Z)   e# 3 + 1
YZ+  e# 2 + 3
ZZ+  e# 3 + 3
AZ-  e# 10 - 3
YZ#  e# 2³
A(   e# 10 - 1
A    e# 10
EZ*  e# 14 × 3

Спасибо @ MartinBüttner за -1 байт!

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

Brainfuck, 70 байт

+
++
+++
++++
+++++
++++++
+++++++
++++++++
+++++++++
++++++++++
--[>+<++++++]>-

Каждая строка должна быть запущена индивидуально.

Первые 10 говорят сами за себя: мы увеличиваем значение ячейки через каждый плюс.

42 намного сложнее. Он основан на том факте, что большинство интерпретаторов «мозгового пота» используют 8-битные ячейки, а это означает, что все операции над ним выполняются по модулю 256. --Устанавливает ячейку от 0 до 254. Затем мы вводим цикл, который выполняется до тех пор, пока ячейка # 0 не станет 0. Каждая итерация добавляет 1 к ячейке # 1 и добавляет 6 к ячейке # 0. Этот цикл выполняется 43 раза, поэтому ячейка № 1 равна 43. Наконец, мы вычитаем 1 из ячейки № 1, чтобы сделать ее 42.

Я получил самые эффективные 42 из когда-либо найденных на http://esolangs.org/wiki/Brainfuck_constants

Тьма , 339 303 байта

Вот где действительно светит тьма . Возьми? : ~)!

Без печати (замените пробел \sв первой строке, так как иначе не будет отображаться):

\s

█ 

██ 

███ 

████ 

█████ 

██████ 

███████ 

████████ 

█████████ 

██████████ 

██████████████████████████████████████████ 

С печатью:

■ 

█■ 

██■ 

███■ 

████■ 

█████■ 

██████■ 

███████■ 

████████■ 

█████████■ 

██████████■ 

██████████████████████████████████████████■ 

В этом случае каждая строка должна запускаться индивидуально, так как программа заканчивается на свету (пробел). Однако это можно записать в одну или несколько строк в одной и той же программе.

Обычная темнота (█) увеличивает регистр на 1, а инструкция ■ (своего рода мини-тьма) выводит содержимое регистра.

Perl 5, 86 75 71 66 байт

Все ^Fs являются буквенными управляющими символами (0x06 в ASCII) и, следовательно, одним байтом.

$[          # array start index, defaults to 0                                  2
!$[         # !0 is 1                                                           3
$^F         # max sys file descriptor number, 2 on all sane systems             2
++$^F       # 2 + 1                                                             4
~-$]        # 5 - 1                                                             4
int$]       # $] is Perl version, int truncates                                 5
length$~    # 1 + 5                                                             8
~~exp$^F    # floor(e^2)                                                        7
$^F<<$^F    # 2 bitshift-right 2                                                6
-!$[+ord$/  # -1 + 10                                                          10
ord$/       # input record separator, newline by default, ord gets ASCII val    5
ord($"^$/)  # 32 + 10                                                          10

Спасибо msh210 за сохранение 11 байтов и Dom Hastings за 9 байтов!

MATL, 30 байт

O
l
H
I
K
Kl+
HI*
KYq
HK*
IH^
K:s
IH^:sI-

H, IИ Kпредопределенные константы для 2, 3 и 4 (например pi). Oи lявляются функциями, которые возвращают матрицу нулей ( O) или ones ( l), размер по умолчанию - 1x1. :делает вектор и sсуммирует его, поэтому K:sделает вектор от 1 до 4 и суммирует его, чтобы получить 10. Yqявляется n-й простой функцией, KYqравно как и 4-е простое число, 7.

Пролог, 113 99 байт

Отрывки:

e-e              % 0.0
e/e              % 1.0
e/e+e/e          % 2.0
ceil(e)          % 3
ceil(pi)         % 4
ceil(e*e-e)      % 5
ceil(e+e)        % 6
floor(e*e)       % 7
ceil(e*e)        % 8
ceil(pi*e)       % 9
ceil(pi*pi)      % 10
ceil(e^e*e)      % 42

Объединяет математические константы e и pi различными способами, преобразованными в int.

Редактировать: Сохранено 14 байтов с использованием поплавков для 0-2.

PHP, 157 145 91 байт

Первый раз, когда я писал на Code Golf, решил, что я попробую. Я поправлюсь в конце концов: P Если вы видите какие-либо очевидные (для вас) места, где я могу сохранять персонажей, дайте мне знать.

РЕДАКТИРОВАТЬ: понял, что мне не нужны точки с запятой, так как это всего лишь фрагменты.

РЕДАКТИРОВАТЬ 2: Спасибо Blackhole за много предложений!

LC_ALL
DNS_A
~~M_E
~~M_PI
LOCK_NB 
LC_TIME
LOG_INFO
INI_ALL
IMG_WBMP
SQL_DATE
SQL_TIME
LOG_INFO*INI_ALL

Python 2, 191 159 158 157 156 149 146 байт

Моя первая подача, надеюсь, я все правильно понял! Исходя из того, сколько времени я потратил на это, я думаю, что для некоторых из них наверняка найдется лучший.

# 0 | Bytes : 5
int()

# 1 | Bytes : 5
+True

# 2 | Bytes : 6
-~True

# 3 | Bytes : 8
-~-~True

# 4 | Bytes : 10
-~-~-~True

# 5 | Bytes : 12
-~-~-~-~True

# 6 | Bytes : 14
-~-~-~-~-~True

# 7 | Bytes : 16
-~-~-~-~-~-~True

# 8 | Bytes : 15
a=True;a<<a+a+a

# 9 | Bytes : 19
a=True;(a<<a+a+a)+a

# 10 | Bytes : 20
int(`+True`+`int()`)

# 42 | Bytes : 16
~-len(`license`)
# Especially proud of this one !

Total byte count: 146

Большое спасибо FryAmTheEggman!

C #, без использования, 234 байта

new int()                       // 0
-~new int()                     // 1
-~-~new int()                   // 2
-~-~-~new int()                 // 3
-~-~-~-~new int()               // 4
-~-~-~-~-~new int()             // 5
-~-~-~-~-~-~new int()           // 6
-~-~-~-~-~-~-~new int()         // 7
-~-~-~-~-~-~-~-~new int()       // 8
(int)System.ConsoleKey.Tab      // 9
(int)System.TypeCode.UInt32     // 10
(int)System.ConsoleKey.Print    // 42

Это гораздо скучнее, чем я думал вначале. У меня были довольно разнообразные идеи, такие как new[]{true}.Lengthи true.GetHashCode()и typeof(int).Name.Lengthи и uint.MinValueт. Д., Но я new int()победил их всех.

PowerShell, 147 байт

Они используют +для неявного приведения вещей к целым числам. В более поздних числах используются перечисления .Net Framework из PowerShell, которые имеют правильные значения.

+$a                          #0, 3 bytes (unset vars are $null, +$null == 0)
+$?                          #1, 3 bytes (bool previous result, default $true, +$true == 1)
$?+$?                        #2, 5 bytes (same as #1, twice)
$?+$?+$?                     #3, 8 bytes (beats [Int][Math]::E)
$?+$?-shl$?                  #4, 11 bytes (-shl is shift-left)
$?+$?+$?+$?+$?               #5, 14 bytes
$?+$?+$?-shl$?               #6, 14 bytes (enum value, + casts to integer)
+[TypeCode]::Int16           #7, 18 bytes
$?+$?-shl$?+$?               #8, 14 bytes
+[consolekey]::tab           #9, 18 bytes
+[TypeCode]::UInt32          #10, 19 bytes
+[consolekey]::Print         #42, 20 bytes

#Total:                      147 bytes

• -~-~-~используемые в JavaScript, C # и PHP ответы будут - -bnot - -bnot - -bnotв PowerShell.

• x^yвозведение в степень, используемое в ответах Perl, или x**yв Python или JavaScript ES7, будет[Math]::Pow($x,$y)

• константы е и пи тяжелые [Math]::Eи[Math]::PI

DC , 35 байт

K
KZ
IZ
Iv
EI-
FI-
IZd*
IIZ/
Ivd+
IIv-
IIZ-
IKZ-
I
EdE++

Чтобы проверить фрагменты, добавьте a, fчтобы напечатать стек и передать эту строку dc:

$ echo 'EdE++f' | dc
42

TI-BASIC, 41 байт

0 ~ 10:

X
cosh(X
int(e
int(π
-int(-π
int(√(π³
int(π+π
int(e²
int(eπ
int(π²
Xmax

42:

int(π²/ecosh(π

В TI-BASIC все неинициализированные однобуквенные переменные начинаются с 0, а Xmax(правая граница окна экрана графика) начинается с 10.

Математическая константа πсоставляет один байт , но eсоставляет два байта.

Python 2, 306 275 274 байта

Я использовал тот факт, что для любого x (целое число, а не 0) выражение x/xравно 1 и играл с некоторыми побитовыми операциями.

Я настроил фрагменты так, чтобы они все еще соответствовали требованиям (спасибо @nimi, это сэкономило мне 24 байта), но вы должны вручную протестировать их. Вот код и количество отдельных байтов:

zero.py Bytes: 7
len({})
--------------------------
one.py  Bytes: 12
r=id(id)
r/r
--------------------------
two.py  Bytes: 17
r=id(id)
-(~r/r)
--------------------------
three.py    Bytes: 20
r=id(id)
-(~r/r)|r/r
--------------------------
four.py Bytes: 20
r=~id(id)/id(id)
r*r
--------------------------
five.py Bytes: 26
r=~id(id)/id(id)
(r*r)|r/r
--------------------------
six.py  Bytes: 25
r=~id(id)/id(id)
(r*r)|-r
--------------------------
seven.py    Bytes: 27
r=~id(id)/id(id)
-~(r*r|-r)
--------------------------
eight.py    Bytes: 24
r=-(~id(id)/id(id))
r<<r
--------------------------
nine.py Bytes: 29
r=-(~id(id)/id(id))
r-~(r<<r)
--------------------------
ten.py  Bytes: 31
r=~id(id)/id(id)
-r*((r*r)|r/r)
--------------------------
answer.py   Bytes: 37
r=-(~id(id)/id(id))
(r<<r*r)|(r<<r)|r
--------------------------
Total byte count: 274

Математика ++, всего 92 байта

0 (1 байт): a

1 (2 байта):!a

2 (3 байта):_$e

3 (4 байта): _$pi

4 (7 байт): _$e+_$e

5 (8 байт): _($e+$e)

6 (9 байт): _$pi+_$pi

7 (8 байт): _($e*$e)

8 (9 байт): _($e*$pi)

9 (10 байт): _($pi*$pi)

10 (12 байт): _$e*_($e+$e)

42 (19 байт): _($pi+$pi)*_($e*$e)

Javascript (Env браузера), 155 136 130 байт

+[]
-~[]
-~-~[]
-~-~-~[]
-~-~-~-~[]
-~-~-~-~-~[]
-~-~-~[]<<-~[]
-~-~-~-~-~-~-~[]
-~[]<<-~-~-~[]
~(~[]+[]+-[])
-~[]+[]+-[]
-~(top+top.s).length // Requires browser environment

Спасибо:
@Ismael Miguel : 155 -> 136 -> 130 байтов

Серьезно, 39 33 байта

Материал в скобках это объяснения:

 (single space, pushes size of stack, which is 0 at program start)
 u (space pushes 0, u adds 1 (1))
 ⌐ (space pushes 0, ⌐ adds 2 (2))
 u⌐ (space pushes 0, u adds 1 (1), ⌐ adds 2 (3))
 ⌐⌐ (space pushes 0, ⌐⌐ adds 2 twice (4))
 ⌐P (space pushes 0, ⌐ adds 2 (2), P pushes the 2nd prime (5))
Hl▓ (H pushes "Hello, World!", l pushes length (13), ▓ pushes pi(13) (6))
QlP (Q pushes "QlP", l pushes length (3), P pushes the 3rd prime (7))
Ql╙ (Q pushes "QlP", l pushes length (3), ╙ pushes 2**3 (8))
úl▓ (ú pushes the lowercase English alphabet, l pushes length (26), ▓ pushes pi(26) (9))
 u╤ (space pushes 0, u adds 1 (1), ╤ pushes 10**1 (10))
HlPD (H pushes "Hello, World!", l pushes length (13), P pushes the 13th prime (43), D subtracts 1 (42))

Hexdumps программ:

20
2075
20a9
2075a9
20a9a9
20a950
486cb2
516c50
516cd3
a36cb2
2075d1
486c5044

Спасибо Quintopia за 6 байтов!

постоянный ток, 42 байта

K
zz
OZ
zzz+
OZd*
OdZ/
zzzz*
Ozz+-
OdZ-
Oz-
O
Od+dz++

Результаты

0
1
2
3
4
5
6
7
8
9
10
42

Существует не так много способов генерировать новые числа с помощью DC. Я использую O: выходная база, изначально 10; K: точность, изначально 0; zглубина стека, изначально 0; Zзначащие цифры операнда. Мы объединяем их с обычными арифметическими операторами.

Тестовая программа

#!/bin/bash

progs=(                                         \
    "K"                                         \
    "zz"                                        \
    "OZ"                                        \
    "zzz+"                                      \
    "OZd*"                                      \
    "OdZ/"                                      \
    "zzzz*"                                     \
    "Ozz+-"                                     \
    "OdZ-"                                      \
    "Oz-"                                       \
    "O"                                         \
    "Od+dz++"                                   \
)

a=0
results=()
for i in "${progs[@]}"
do
    results+=($(dc -e "${i}p"))
    (( a+=${#i} ))
done

echo "#dc, $a bytes"
echo
printf '    %s\n' "${progs[@]}"
echo
echo '##Results'
echo
printf '    %s\n' "${results[@]}"

Mathematica, 101 байт

a-a
a/a
⌊E⌋
⌈E⌉
⌈π⌉
⌊E+E⌋
⌈E+E⌉
⌊E*E⌋
⌈E*E⌉
⌈E*π⌉
⌈π*π⌉
⌊π*π^π/E⌋

Я уверен, что некоторые из них неоптимальны. Эти круглые скобки действительно дороги.

Для согласованности первые два также могут быть E-Eи, E/Eконечно, но я подумал, что это довольно изящно получить 0и 1вычислить с неопределенными переменными.

Japt , 34 33 30 байт

1 байт сохранен благодаря @ThomasKwa

T
°T
C-A
D-A
E-A
F-A
G-A
°G-A
Iq
´A
A
H+A

Вот что означает каждый из этих символов:

T    0
A    10
B    11
C    12
D    13
E    14
F    15
G    16
H    32
I    64
q    sqrt on numbers
°    ++
´    --

Marbelous , 98 байт

Не очень интересно, он опирается на ?nустройства, которые превращают любой мрамор в случайное значение в диапазоне 0..n (включительно), побочным эффектом которого является то, что ?0любой мрамор превращается в 0 независимо от входных данных. Я думаю, что использование литералов разрешено, потому что значение не влияет на результат, и нет другого способа вызвать функцию один раз в Marbelous.

0:

00  # A hexadicemal literal: value 0
?0  # Turn any marble into a random value from the range 0..0 (inclusive)

1:

00
?0
+1  # increment by one

...

9:

00
?0
+9

10:

00
?0
+A  # increment by 10

42:

00
?0
+L  # increment by 21
+L

> <> , 86 байт

• 0: ln;
• 1: lln;
• 2: llln;
• 3: lll+n;
• 4: lll:+n;
• 5: llll+n;
• 6: llll++n;илиllll:+n;
• 7: lllll+n;
• 8: lllll:+n;
• 9: lllll++n;илиllllll+n;
• 10: llll+:+n;илиlll:l+*n;
• 42: llll*ll+*n;

Полагается на размер стека, чтобы получить его литералы.

Формулы MS Excel, 163 151 150 143 байта

Не совсем язык программирования, но здесь это идет ...

0:  -Z9                         (03 bytes)
1:  N(TRUE)                     (07 bytes)
2:  TYPE(T(Z9))                 (11 bytes)
3:  TRUNC(PI())                 (11 bytes)
4:  TYPE(TRUE)                  (10 bytes)
5:  ODD(PI())                   (09 bytes)
6:  FACT(PI())                  (10 bytes)
7:  ODD(PI()+PI())              (14 bytes)
8:  EVEN(PI()+PI())             (15 bytes)
9:  TRUNC(PI()*PI())            (16 bytes)
10: EVEN(PI()*PI())             (15 bytes)
42: EVEN(CODE(-PI())-PI())      (22 bytes)

PI()используется в большинстве случаев, так как это более короткий (насколько мне известно) способ ввода числового значения без использования числового или строкового литерала. Nпреобразует различные вещи (включая логические) в числа и Tпреобразует различные вещи в текст. TYPEвозвращает 2 для текстового аргумента и 4 для логического аргумента. TRUNCотбрасывает дробную часть (т.е. округляет положительные числа вниз), EVENокругляет до следующего четного числа и ODDокругляет до следующего нечетного числа. CODE(-PI())это код ASCII первого символа преобразования в текст -π, т.е. 45 (для «-»).

РЕДАКТИРОВАТЬ: Удалены знаки равенства из числа байтов (-12!) - как указано Nᴮᶻ в комментариях, они не должны быть включены.

РЕДАКТИРОВАТЬ 2: Предполагая, что остальная часть листа пуста, можно использовать ссылку на пустую ячейку как ноль (опять же, предложенный Nᴮᶻ), при условии, что мы добавляем знак минус (или используем его в другом числовом выражении) для разрешения типа двусмысленность.

DUP , 68 байт

[
 [
  [
[)]!
[ )]!
[  )]!
[)~_]!
[ )~_]!
[  )~_]!
[   )~_]!
[)$+]!
[ )$+~_$+]!

Try it here.

Есть много способов сделать это, но я злоупотребляю стеком возврата для этого.

объяснение

Чтобы полностью понять это, вам нужно понять поведение DUP в отношении лямбд. Вместо того, чтобы помещать лямбду в стек, она фактически выталкивает текущий IP в стек при обнаружении лямбды. Это может объяснить первые 3 фрагмента, которые включают лямбды.

Следующие фрагменты используют возвращаемый стек. Когда !выполняется, текущий IP передается в стек возврата, а вершина стека устанавливается в качестве нового IP для запуска лямбда-выполнения. )выталкивает число из стека возврата в стек данных.

Этого достаточно, чтобы объяснить остальные фрагменты. Если вы все еще не получаете его, имейте в виду, что Stepкнопка довольно удобна!

05AB1E, 40 38 24 байта

¾
X
Y
XÌ
Y·
T;
T;>
T;Ì
TÍ
T<
T
žwT+

• Push counter_variable
• Нажмите 1
• Нажмите 2
• Нажмите 1 + 2
• Нажмите 2 * 2
• Push 10/2
• Push (10/2) +1
• Нажмите (10/2) +2
• Пуш 10-2
• Пуш 10-1
• Нажмите 10
• Push 32, 10, добавить

D1ffe7e45e , 112

0
02
020
0202
02020
020202
0202020
02020202
020202020
0202020202
02020202020
202020202020202020202020202020202020202020

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

Числа в программе не считаются числовыми литералами, поскольку они используются только в качестве команд.

Финал определенно может быть больше в гольфе.

РЕДАКТИРОВАТЬ: у меня работает переводчик и все фрагменты работают. Если вы хотите проверить себя, добавьте 0f0fв конец фрагмента, чтобы программа завершилась.

Pyth, 35 34 33 байта

-1 байт @Mimarik

Есть несколько возможностей для некоторых программ.

0, 1 байт

Z

1, 2 байта

hZ
!Z

2,3 байта

hhZ
eCG
eCd
lyd
lyb
lyN

3, 3 байта

l`d

4, 3 байта

l`b
eCN

5, 4 байта

hl`b
telG

6, 3 байта

elG

7, 4 байта

tttT
helG

8, 3 байта

ttT

9,2 байта

tT

10, 1 байт

T

42, 4 байта

yhyT

Все они включают в себя либо базовые команды double ( y), +1 ( h) и -1 ( t), либо l(длина строки). Переменная Z инициализируется нулем.

Для 5 bинициализируется символом новой строки. Backtick дает "\n"(включая кавычки, и длина этой строки 4.

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