Якщо вам це подобається, подумайте про участь у:

• Офіційний 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()) тому що більшість людей не використовують "Адміністратора" як логін :-)
9: LOG10(SYSTEMMEMORY()) тому що він працює лише в системах з рівно 1 ГБ пам'яті
42: CODE("*") тому що він містить літеральний рядок / символ

Результат кожного фрагмента повинен призвести до фактичного числа (значення, int, float тощо), яке можна використовувати для подальших обчислень, використовуючи ту саму мову, що і фрагмент, тобто не текстову рядок, що представляє це число.

Дозволені лише мови на основі символів.

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

Зауважте, що вищезазначені правила можуть перешкоджати участі деяких мов, навіть якщо вони є Тьюрінгом завершеними.

FAQ

Q Чи можуть програми приймати будь-які дані? Так, але ви не можете просто попросити введення і введіть відповідний номер.

Q Чи допускаються фізичні (не дані) цифри?
А так, наприклад LOG10().

Q Чи символи в Ruby вважаються буквальними?
A Так.

Q Чи враховує оцінка між новими фрагментами нові рядки?
А Ні.

Q Чи достатньо TI-BASIC "на основі символів", щоб бути дійсним?
A Так.

Q Чи рахуються помилкові та істинні літерали чисел? Ні, вони є прийнятними.

Q Чи можемо ми використовувати цифровий чисел для виклику функції, якщо це єдиний спосіб, і число не впливає на вихід функції? Так, якщо це нормальний спосіб , щоб написати код на вашій мові.

Q Моя мова передбачає, що на початку кожної програми / виразу є [щось]. Повинен я включити його, чи повинні мої фрагменти просто працювати, якщо вони розміщені в середині програми / виразу?
A Вони повинні просто працювати посеред програми / виразу.

Q Що з літерами регулярного виразів? Заборонено, для мов , які тільки роблять регулярні вирази , за винятком.

Q Чи прийнятний один фрагмент коду, який міг би надрукувати всі вказані номери? Ні, вони повинні бути розділені і незалежні один від одного.

Q Чи можу я припустити, як котлован, подібний int main() {}...або еквівалент?
A Так.

Q Які типи вихідних даних дозволені?
A Будь-який числовий тип даних, наприклад, int, float тощо.

Q Чи потрібно надрукувати результат кожного фрагмента?
А Ні, зробити результат доступним для подальшого використання.

Q Чи дозволені попередньо встановлені змінні?
A Так, і вони скидаються (якщо вони змінені) для кожного фрагмента.

Q чи я і е вважається число літералів? Ні, ви можете використовувати їх.

Q Чи можу я повернути 4 та 2 в різних клітинках за 42?
А Ні, вони повинні бути з'єднані як одне число.

Q Байти чи символи? Bytes, але ви можете вибрати будь-який бажаний кодову.

Q Чи можуть бути використані постійні функції та задані змінні, такі як J 9:, Actual's 9і Pretzel 9?
A Так, якщо словниковий запас обмежений (19 для J, 10 - Насправді та Кредзель).

Шестикутник , 13 байт

1
2
3
4
5
6
7
8
9
10
42

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

У шестикутнику 0наскрізь 9є функції, що множать поточну пам'ять на 10, а потім додають число, представлене іменем функції. Тому перший фрагмент порожній, коли починаються спогади 0.

Наприклад, якщо поточна пам'ять є 65, виконання функції 3зробить поточну пам'ять 653.

(Керівникам: знищую все, що ти хочеш; я готовий.)

Funciton , 1222 байт

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

Усі використані тут функції бібліотеки існували до опублікування виклику.

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

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

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

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

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

⌑повертає ледачу послідовність, що містить один елемент, і ɕрахує кількість елементів. (Послідовність лінива досить ледача, що цей фрагмент насправді зовсім не оцінює stdin!)

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) або одиниць ( l), розмір за замовчуванням - 1х1. :робить вектор і sпідсумовує його, тому K:sробить вектор від 1 до 4 і підсумовує його, щоб отримати 10. Yq- це п-я проста функція, так 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 Якщо ви побачите явні (для вас) плями, де я міг би зберегти персонажів, дайте мені знати.

EDIT: Зрозуміло, мені не потрібні крапки з комою, оскільки це просто фрагменти.

EDIT2: Дякую 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

Пітон 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 байт

Вони використовують +для неявного відтворення речей до цілих чисел. Більш пізні номери використовують Enums з .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)

• константи e і Pi - важкі для символів [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

Math ++, всього 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 (Browser 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))

Шестнадцяткові програми:

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

Завдяки кінтопії на 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[@]}"

Математика, 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
°    ++
´    --

Марбельний , 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 (для "-").

EDIT: Видалено рівні знаки з числа байтів (-12!) - як зазначено в коментарях Nᴮᶻ, вони не повинні включатися.

EDIT 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
• Натисніть 10/2
• Натисніть (10/2) +1
• Натисніть (10/2) +2
• Натисніть 10-2
• Натисніть 10-1
• Натисніть 10
• Натисніть 32, 10, додайте

D1ffe7e45e , 112

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

Кожен рядок - інший фрагмент.

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

Завершальний напевно можна більше пограти в гольф.

EDIT: У мене перекладач працює, і всі фрагменти працюють. Якщо ви хочете перевірити себе, додайте 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

Усі вони включають або основні подвійні ( y), +1 ( h) і -1 ( t) команди, або l(довжина рядка). Змінна Z ініціалізується до нуля.

Для 5 bініціалізується символ нового рядка. Backtick дає"\n" (включаючи цитати, а довжина цього рядка - 4.

Спробуйте їх тут !