Виберіть будь-які п'ять символів, які підтримує ваша мова. Є 5! = 5 × 4 × 3 × 2 × 1 = 120 способів їх можна впорядкувати в 5-символьний рядок, який містить кожен символ один раз; 120 перестановок .

Виберіть своїх символів таким чином, що коли кожен з 120 рядків запускається вашою мовою, 120 отриманих результатів матимуть стільки унікальних цілих чисел від 1 до 120 (включно).

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

Отже, в ідеалі, ваша перша перестановка виведе 1, наступна 2, наступна 3, аж до 120. Але цей ідеал, ймовірно, неможливий для більшості мов та символів.

5-символьні рядки можуть бути запущені як:

• програма без введення
• функція без аргументів
• реплєї команда

При бажанні різні рядки можна виконувати різними способами

Щоб результат підраховувався, це повинен бути єдиний цілий вихід нормальним способом, наприклад:

• друкується до stdout
• повернута функцією
• результат виразу REPL

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

Представлення, що генерує найвиразніші числа від 1 до 120, виграє. Раніше подання виграє у разі нічиєї.

Примітки

• Ваші 5 символів не повинні бути різними, але, звичайно, наявність дублікатів символів зменшує ефективну кількість перестановок.
• Поплавкові виходи, такі як 32.0лічильник, а також звичайний 32. (Але 32.01не хотів би.)
• Провідні нулі, такі як 032підрахунок, а також звичайний 32.
• Дійсні результати повинні бути детермінованими та інваріантними за часом.
• Ми маємо справу з символами , а не байтами.

Приклад

Персонажі 123+*є розумним першим вибором для відповіді Python (або багатьох мов). Отриманими 120 перестановками та виходами є:

123+* n/a
123*+ n/a
12+3* n/a
12+*3 n/a
12*3+ n/a
12*+3 36
132+* n/a
132*+ n/a
13+2* n/a
13+*2 n/a
13*2+ n/a
13*+2 26
1+23* n/a
1+2*3 7
1+32* n/a
1+3*2 7
1+*23 n/a
1+*32 n/a
1*23+ n/a
1*2+3 5
1*32+ n/a
1*3+2 5
1*+23 23
1*+32 32
213+* n/a
213*+ n/a
21+3* n/a
21+*3 n/a
21*3+ n/a
21*+3 63
231+* n/a
231*+ n/a
23+1* n/a
23+*1 n/a
23*1+ n/a
23*+1 23
2+13* n/a
2+1*3 5
2+31* n/a
2+3*1 5
2+*13 n/a
2+*31 n/a
2*13+ n/a
2*1+3 5
2*31+ n/a
2*3+1 7
2*+13 26
2*+31 62
312+* n/a
312*+ n/a
31+2* n/a
31+*2 n/a
31*2+ n/a
31*+2 62
321+* n/a
321*+ n/a
32+1* n/a
32+*1 n/a
32*1+ n/a
32*+1 32
3+12* n/a
3+1*2 5
3+21* n/a
3+2*1 5
3+*12 n/a
3+*21 n/a
3*12+ n/a
3*1+2 5
3*21+ n/a
3*2+1 7
3*+12 36
3*+21 63
+123* n/a
+12*3 36
+132* n/a
+13*2 26
+1*23 23
+1*32 32
+213* n/a
+21*3 63
+231* n/a
+23*1 23
+2*13 26
+2*31 62
+312* n/a
+31*2 62
+321* n/a
+32*1 32
+3*12 36
+3*21 63
+*123 n/a
+*132 n/a
+*213 n/a
+*231 n/a
+*312 n/a
+*321 n/a
*123+ n/a
*12+3 n/a
*132+ n/a
*13+2 n/a
*1+23 n/a
*1+32 n/a
*213+ n/a
*21+3 n/a
*231+ n/a
*23+1 n/a
*2+13 n/a
*2+31 n/a
*312+ n/a
*31+2 n/a
*321+ n/a
*32+1 n/a
*3+12 n/a
*3+21 n/a
*+123 n/a
*+132 n/a
*+213 n/a
*+231 n/a
*+312 n/a
*+321 n/a

Створено 36 номерів, на щастя в межах від 1 до 120:

36, 26, 7, 7, 5, 5, 23, 32, 63, 23, 5, 5, 5, 7, 26, 62, 62, 32, 5, 5, 5, 7, 36, 63, 36, 26, 23, 32, 63, 23, 26, 62, 62, 32, 36, 63

Однак лише 8 з них унікальні:

36, 26, 7, 5, 23, 32, 63, 62

Таким чином, таке подання набрало б лише 8 з максимальних 120.

Python3, 21 27 значень

Персонажі: 3479%

Унікальні номери: [1,2,3,4,5,6,7,8,9,11,12,19,20,21,24,29,34,35,36,37,39,43,46,47,49,73,74]

Як цього вимагали, ось перестановки, що потрапили в діапазон [1, 120] . Спробуйте в Інтернеті!

347%9   5
349%7   6
34%79   34
34%97   34
374%9   5
379%4   3
37%49   37
37%94   37
394%7   2
397%4   1
39%47   39
39%74   39
3%479   3
3%497   3
3%749   3
3%794   3
3%947   3
3%974   3
437%9   5
439%7   5
43%79   43
43%97   43
473%9   5
479%3   2
47%39   8
47%93   47
493%7   3
497%3   2
49%37   12
49%73   49
4%379   4
4%397   4
4%739   4
4%793   4
4%937   4
4%973   4
734%9   5
739%4   3
73%49   24
73%94   73
743%9   5
749%3   2
74%39   35
74%93   74
793%4   1
794%3   2
79%34   11
79%43   36
7%349   7
7%394   7
7%439   7
7%493   7
7%934   7
7%943   7
934%7   3
937%4   1
93%47   46
93%74   19
943%7   5
947%3   2
94%37   20
94%73   21
973%4   1
974%3   2
97%34   29
97%43   11
9%347   9
9%374   9
9%437   9
9%473   9
9%734   9
9%743   9

05AB1E , 27 38 41 номери

4·>Ìn

Створює унікальні числа:

[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 18, 19, 25, 27, 32, 33, 34, 35, 36, 37, 38, 49, 50, 52, 54, 64, 65, 66, 67, 72, 73, 74, 81, 83, 98, 100, 101, 102]

Використовує константу 4з операціями +1, +2, *2і ^2.

Пітон, 18 чисел

237#-

Виходить як дійсні результати:

1, 2, 3, 4, 5, 7, 16, 23, 24, 25, 27, 32, 35, 37, 69, 71, 72, 73

EDIT: Я можу засвідчити, що рішення TuukkaX є оптимальним для Python. Я застосував наступний код, який підтримує всі можливі комбінації 5 друкованих символів ASCII:

from itertools import permutations,combinations_with_replacement

def perms(chars):
  result=set()
  for permut in permutations(chars):
    try:
      current=eval(''.join(permut))
      assert str(int(current))==str(current)
      result.add(int(current))
    except:
      pass
  return sum([1 for x in result if 1<=x<=120])

best=1
for c in combinations_with_replacement(' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~',5):
    string=''.join(c)
    r=perms(string)
    if r>=best:
        best=r
        print(r,string,end='\n')

Результати (після запуску в протягом майже 7 годин) показали , що оптимальне рішення, насправді 27 різних чисел, отриманих три різних розчинів з використанням все чотири числа і модами ( %): %3479, %5679і %5789.

Ява 8, 2 4 числа

n->12  // returns 12
n->21  // returns 21
n1->2  // returns 2
n2->1  // returns 1

Ви не очікували відповіді на Java, чи не так?

Це лямбда, яка може бути розташована лише одним із двох способів (і з будь-якими двома різними цифрами!) Для загальної кількості двох унікальних чисел. Все інше не є дійсною лямбда.

Фактично покращили відповідь, завдяки допомозі у коментарях! Не бачив, що 0 недійсний, і забув, що змінні можуть бути більше одного символу. У нас 4!

Ще гірше рішення

()->1

Але, з яскравого боку, два унікальних відповіді на Java!

Желе, 26 30 32 числа

‘’3²Ḥ

Це (та його анаграми) - це повні програми, які не беруть ніяких даних і дають вихід на стандартному рівні.

Виходи з 120 програм - у порядку, який Jelly генерує їх, якщо ви попросите генерувати перестановки програми:

018 036 06 03 09 03 18 116 116 117 125 135 06 03 14 15 13 22 19 13 24
28 33 42 018 036 06 03 09 03 -132 -164 -120 -119 -149 -137 26 43 18 17 
33 24 -19 13 -216 -210 53 44 18 36 30 31 49 63 18 36 10 9 25 17 18 19
18 17 18 18 36 48 36 26 36 36 06 03 14 15 13 22 06 03 -18 -17 -13 -24
06 07 06 05 06 06 03 12 03 -14 03 03 09 03 14 18 03 12 09 03 -116 -110 
23 14 09 015 09 05 09 09 03 12 03 -14 03 03

Якщо ви просто приймете унікальні результати в числовому порядку, ви отримаєте:

-216 -210 -164 -149 -137 -132 -120 -119 -116 -110 -24 -19 -18 -17 -14 -13
03 05 06 07 09 10 12 13 14 15 17 018 19 22 23 24 25 26 28 30 31 33 036 42
43 44 48 49 53 63 116 117 125 135

Багато з них занадто малі, а 135 - занадто великі, але є ще 32, які знаходяться в діапазоні.

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

Операції, які ми маємо тут, в контексті, в якому програма їх породжує, - це: збільшення; декремент; константа 3; Майдан; і подвійний. Збільшення та зменшення, на жаль, є протилежністю, і декремент має невдалу тенденцію до отримання -1 або -2 у першому розділі (що призводить до загального від’ємного числа), але це все-таки дало більше поширення результатів, ніж інші речі, які я намагався . Зокрема, ми отримуємо досить гарне поширення як першої, так і другої половинок числа (зауважте, що перша половина може бути нульовим рядком, якщо 3це перший символ у програмі).

JavaScript, 27 номерів

Дуже схожа на відповідь TuukkaX , з іншим набором цифр.

5789%

27 різних значень:

589 %   7 -> 1
987 %   5 -> 2
978 %   5 -> 3
879 %   5 -> 4
985 %   7 -> 5
958 %   7 -> 6
975 %   8 -> 7
 95 %  87 -> 8
  9 % 875 -> 9
 97 %  85 -> 12
 89 %  75 -> 14
 95 %  78 -> 17
 78 %  59 -> 19
 79 %  58 -> 21
 98 %  75 -> 23
 87 %  59 -> 28
 89 %  57 -> 32
 97 %  58 -> 39
 98 %  57 -> 41
 57 %  98 -> 57
 58 %  97 -> 58
 59 %  87 -> 59
 75 %  98 -> 75
 78 %  95 -> 78
 79 %  85 -> 79
 85 %  97 -> 85
 87 %  95 -> 87

Брахілог , 26 номерів

3+*^-

Це виводить такі числа: [2,3,4,5,6,7,8,9,10,16,17,18,19,20,25,26,30,31,32,35,36,37,48,49,63,64]

Пояснення

• 3 очевидно, це ціле число 3.
• + приріст
• * подвійний
• ^ є квадратною
• - є декремент

Існує маса ситуацій, коли програма просто помиляється: наприклад, *+^3-помилки, оскільки вона запитує "Взяти 0, подвоїти його, приріст, квадрат, результат цього квадрата - 3, декремент", що, очевидно, неправильно.

Будь-яка програма, яка закінчується, 3буде або виведена3 або не працює.

Будь-яка програма, яка починається з, *3буде нескінченно циклічна через помилку (Брахілог намагається знайти список підспісок, продукти яких приводять до 3, що неможливо).

Вим, 16 чисел

i1234

друк

1, 2, 3, 4, 12, 13, 14, 21, 23, 24, 31, 32, 34, 41, 42, 43

IA-32 машинний код, 8 номерів

Шістнадцяткові значення байтів:

2c 40 48 b0 c3

Код запускається як функція, що повертає значення в al.

Дійсні перестановки:

b0 2c c3 xx xx => 2c (mov al, 2c)

b0 40 c3 xx xx => 40 (mov al, 40)

b0 48 c3 xx xx => 48 (mov al, 48)

b0 2c 40 c3 48 => 2d (mov al, 2c; inc eax)

b0 2c 48 c3 40 => 2b (mov al, 2c; dec eax)

b0 40 48 c3 2c => 3f (mov al, 40; dec eax)

b0 48 40 c3 2c => 49 (mov al, 48; inc eax)

b0 48 2c 40 c3 => 8 (mov al, 48; sub al, 40)

Я здійснив жорстокий пошук з такими обмеженнями:

• Перший байт b0- ініціалізація alрегістра
• Останній байт c3- повернення; наступні байти відкидаються
• Можливими байтами коду є:
  • 0x04 - add
  • 0x0c - or
  • 0x24 - and
  • 0x2c - sub
  • 0x34 - xor
  • 0xd4 - aad
  • 0x40 - inc
  • 0x48 - dec

Це залишає лише 3 змінні байти з максимум 15 можливими результатами. З них можна виділити максимум 9 (насправді це відбувається лише для одного набору байтів!). Одне із значень знаходиться поза діапазоном, тому це залишає 8 значень. Є ще один набір байтів

34 40 48 b0 c3

що також дає 8 різних значень - програми однакові, за винятком subзамінених на xor, що робить два можливих виходи однаковими.

Усі інші набори байтів дають 7 або менше можливих результатів.

Желе , 33 номери

Ḥ23+c

Ḥподвійний (зліва);
2буквальний 2;
3буквальне 3;
+додати (зліва, справа); і
c виберіть (ліворуч, праворуч), тобто кількість способів вибору правильних об'єктів із колекції лівих об’єктів.

Числа, отримані за прикладом програми:

 1 +32Ḥc   18 3Ḥc2+    45 2+3Ḥc
 2 c3Ḥ+2   20 2+Ḥc3    47 23c+Ḥ
 3 c2Ḥ+3   21 2Ḥ+3c    48 c+23Ḥ
 4 +2Ḥc3   22 3Ḥc+2    53 2c+Ḥ3
 5 2+3cḤ   23 23cḤ+    56 3Ḥ+2c
 6 3c+2Ḥ   24 cḤ+23    63 c+2Ḥ3
 8 2c+3Ḥ   30 3+c2Ḥ    65 32c+Ḥ
 9 3c2+Ḥ   32 32cḤ+    66 c+32Ḥ
12 +3cḤ2   33 cḤ+32    72 3c+Ḥ2
13 +2cḤ3   36 3+Ḥc2    82 c+3Ḥ2
15 +3Ḥc2   42 cḤ3+2   120 3+2Ḥc

Я намагався вибрати простий для розбору, але деякі з них рідкісні і трохи дивні для розбору, наприклад 23:

23cḤ+: (23 c (2 * 23)) + 23 = (23 c 46) + 23 = 0 + 23 = 23

... і 72та 13використовувати неявну друк:

3c+Ḥ2: z = (3 c 0) + (3 * 2); print(z); z = 2; print(z)
       z =    1    +    6   ; print(z); z = 2; print(z)

+2cḤ3: z = (0 + 2) c (2 * 0); print(z); z = 3; print(z)
       z =    2    c    0   ; print(z); z = 3; print(z)
       z =         1        ; print(z); z = 3; print(z)

Зауважте, що Ḥ34+cтакож створюються 33унікальні значення в [1,120].

Мозок-Флак 1

(())#

Brain-Flak вимагає збалансованих дужок, тому програма з 5 символів діє лише в тому випадку, якщо хтось із персонажів починає коментар. Це залишає нам 4 символи для роботи. З них 2 повинні бути (і в )іншому випадку нічого не буде отримати в стек. Вони мають пройти перше та четверте, а коментар останній ( (..)#). Тепер ми можемо поставити (), {}, <>або []всередині. {}, <>і []кожен оцінюють до 0, але ()це 1. Це означає, що (())#це єдиний рядок із 5 символів, який створює дійсну програму Brain-Flak.

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

Якби замість цього було питання "які 6 найпотужніших символів", відповідь була б такою, (){}[]як Brain-Flak закінчує використання лише цього підмножини.

Гексагонія , 13 номерів

)24!@

Це 13 номерів для друку з однією можливою програмою для кожного з них:

)!@24 1
2!@)4 2
2)!@4 3
4!@)2 4
4)!@2 5
)2!@4 12
)4!@2 14
24!@) 24
24)!@ 25
2)4!@ 34
42!@) 42
42)!@ 43
4)2!@ 52

Програми повинні бути досить зрозумілими. @завершує програму, !роздруковує поточне значення, )збільшує його 2та 4додає себе до поточного значення (де початкове значення 0). Фактична шестикутна розкладка вихідного коду тут не має значення, програми можна просто читати зліва направо.

Це повинно бути оптимальним, хоча замість того , щоб 2і 4ви можете вибрати будь-яку пару цифр xі yтакі , що 2 ≤ x ≤ y-2.

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

#[]\/_|<>)!0123456789$

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

Perl, 27 чисел

3479%

У Perl немає вбудованої REPL, тому ви можете використовувати re.pl від Devel :: REPL .

Результати:

%9743 -> N/A
9%743 -> 9
97%43 -> 11
974%3 -> 2
9743% -> N/A
%7943 -> N/A
7%943 -> 7
79%43 -> 36
794%3 -> 2
7943% -> N/A
%7493 -> N/A
7%493 -> 7
74%93 -> 74
749%3 -> 2
7493% -> N/A
%7439 -> N/A
7%439 -> 7
74%39 -> 35
743%9 -> 5
7439% -> N/A
%9473 -> N/A
9%473 -> 9
94%73 -> 21
947%3 -> 2
9473% -> N/A
%4973 -> N/A
4%973 -> 4
49%73 -> 49
497%3 -> 2
4973% -> N/A
%4793 -> N/A
4%793 -> 4
47%93 -> 47
479%3 -> 2
4793% -> N/A
%4739 -> N/A
4%739 -> 4
47%39 -> 8
473%9 -> 5
4739% -> N/A
%9437 -> N/A
9%437 -> 9
94%37 -> 20
943%7 -> 5
9437% -> N/A
%4937 -> N/A
4%937 -> 4
49%37 -> 12
493%7 -> 3
4937% -> N/A
%4397 -> N/A
4%397 -> 4
43%97 -> 43
439%7 -> 5
4397% -> N/A
%4379 -> N/A
4%379 -> 4
43%79 -> 43
437%9 -> 5
4379% -> N/A
%9734 -> N/A
9%734 -> 9
97%34 -> 29
973%4 -> 1
9734% -> N/A
%7934 -> N/A
7%934 -> 7
79%34 -> 11
793%4 -> 1
7934% -> N/A
%7394 -> N/A
7%394 -> 7
73%94 -> 73
739%4 -> 3
7394% -> N/A
%7349 -> N/A
7%349 -> 7
73%49 -> 24
734%9 -> 5
7349% -> N/A
%9374 -> N/A
9%374 -> 9
93%74 -> 19
937%4 -> 1
9374% -> N/A
%3974 -> N/A
3%974 -> 3
39%74 -> 39
397%4 -> 1
3974% -> N/A
%3794 -> N/A
3%794 -> 3
37%94 -> 37
379%4 -> 3
3794% -> N/A
%3749 -> N/A
3%749 -> 3
37%49 -> 37
374%9 -> 5
3749% -> N/A
%9347 -> N/A
9%347 -> 9
93%47 -> 46
934%7 -> 3
9347% -> N/A
%3947 -> N/A
3%947 -> 3
39%47 -> 39
394%7 -> 2
3947% -> N/A
%3497 -> N/A
3%497 -> 3
34%97 -> 34
349%7 -> 6
3497% -> N/A
%3479 -> N/A
3%479 -> 3
34%79 -> 34
347%9 -> 5
3479% -> N/A

Бруто вимушене користуватися такою програмою:

use strict;
use warnings 'all';
use 5.010;

use Algorithm::Combinatorics qw(combinations);
use Algorithm::Permute;
use Scalar::Util::Numeric qw(isint);

my @chars = ( 0..9, qw(+ - * / . ; ' " \ @ $ # ! % ^ & ( ) { } =) );
my $iter  = combinations(\@chars, 5);
my $max   = 0;
my @best;

while (my $combo = $iter->next) {
    my $count = count_valid([@$combo]);

    if ($count > $max) {
        $max  = $count;
        @best = @$combo;
    }
}

say "$max -> @best";

sub count_valid {
    my ($chars) = @_;

    my $iter = Algorithm::Permute->new($chars);
    my %results;

    while (my @perm = $iter->next) {
        no warnings;
        my $val = eval join '', @perm;
        use warnings 'all';

        $results{$val} = 1 if isint($val) && $val > 0 && $val <= 120;
    }

    return scalar keys %results;
}

R, 15 18 чисел

Не величезна кількість, але це може бути найкраще, що можна зробити з R. Я шукав усі комбінації цифр 0..9, операторів+ - * / ^ та таблиці коментарів #, а наступні вісім всіх виводили 18 унікальних цілих чисел між 1 і 120.

-#146
-#157
-#237
-#238
-#256
-#267
-#278
-#378
-#467
-#568

В якості прикладу візьмемо -#146 . Ось 18 цілих чисел, які ми можемо отримати:

1#-46      = 1
6-4#1      = 2
4-1#6      = 3
4#-16      = 4
6-1#4      = 5
6#-14      = 6
14-6#      = 8
16-4#      = 12
14#-6      = 14
16#-4      = 16
41-6#      = 35
41#-6      = 41
46-1#      = 45
46#-1      = 46
61-4#      = 57
61#-4      = 61
64-1#      = 63
64#-1      = 64

Якщо вам цікаво (потворний) код, який використовується для перевірки всіх можливих комбінацій, ось він. Він виводить кількість унікальних цілих чисел від 1 до 120 для кожної комбінації символів довжиною 5 до файлу під назвою "файл даних" у поточному робочому каталозі.

allchars = c("1","2","3","4","5","6","7","8","9","0","+","-","*","/","^")
apply(gtools::combinations(n=15, r=5, v=allchars, repeats.allowed=TRUE),
      1,
      function(chars) {
        x = apply(apply(e1071::permutations(length(chars)), 
                        1,
                        function(i) chars[i]
                        ),
                  2,
                  paste, collapse=""
            )
        u = unique(x)
        o = as.numeric(unlist(sapply(u, function(i) eval(try(parse(t=i),TRUE)))))

        f = factor(unique(o[o<=120 & o>=1 & o%%1==0]))
        write(paste(nlevels(f), paste(chars, collapse="")), "datafile", append=TRUE)
      }
)

Октава, 18

Це було виявлено за допомогою жорстокого пошуку символів *+-/0123456789:;<\^|~%. Але для обчислення це зайняло занадто багато часу ...

-139%

Можливі виходи:

1, 2, 3, 4, 6, 8, 9,13,16,19,22,31,38,39,88,91,92,93

Октава, 15 чисел

Не надто похвалитися, але це найкраще, що я можу отримати в Октаві:

124+%

Він дає цифри:

1    2    3    4    5    6   12   14   16   21   24   25   41   42   43

У мене теж 16, але, схоже, це ідентично відповіді Сефи ...

1234%

1    2    3    4   12   13   14   21   23   24   31   32   34   41   42   43

PHP, 15 номерів

1230\r

Використовує той факт, що php друкує що-небудь за межами своїх тегів дослівно (не використовуючи це, ви можете зробити рівно 1 число з чимось подібним <?=1;). Також використовує фактичний символ повернення каретки, а не\r .

Створює (сортував, видаляв провідні 0):

 1 1 2 2 3 3 10 10 12 12 12 12 13 13 13 13 20 20 21 21 21 21 23 23 23 23 30 30 31 31 31 31 32 32 32 32 102 102 103 103 120 120 123 123 123  123  130  130  132  132  132  132  201  201  203  203  210  210  213  213  213  213  230  230  231  231  231  231  301  301  302  302  310  310  312  312  312  312  320  320  321  321  321  321  1023  1023  1032  1032  1203  1203  1230  1230  1302  1302  1320  1320  2013  2013  2031  2031  2103  2103  2130  2130  2301  2301  2310  2310  3012  3012  3021  3021  3102  3102  3120  3120  3201  3201  3210  3210

з яких дійсні унікальні номери:

1 2 3 10 12 13 20 21 23 30 31 32 102 103 120

Кубікс , 7 номерів

"2)@O

Виводить ці числа:

")O2@ ->  1
")2O@ ->  2
"2)O@ ->  3
2"O@) -> 41
)"O@2 -> 50
2"O)@ -> 64
2")O@ -> 65

Будь-яка дійсна програма Cubix для цього виклику повинна мати Oвихід для цілого числа та@ завершення програми (Cubix ніколи навіть не чув про "помилки"). Це дає нам три рази пограти, щоб отримати максимальну кількість результатів. Крім того, через те, як Cubix впорядковує код на кубі, перший char буде марний, якщо один з інших не буде спрямованим знаком.

Найефективніший спосіб, який я знайшов для отримання декількох чисел, - це використовувати "для натискання рядка char-кодів до стеку. Ретельно переставляючи, ми можемо помістити кілька символів на останнє місце і просто вивести їх чар-коди. За допомогою) для збільшення верхній елемент, ми можемо створити додаткові результати з декількох з цих домовленостей.

Тут використовуються два основних типи програм. Перше:

"2)O@

який розширюється до

  "
2 ) O @
  .

Отримана програма натискає 2на стек, збільшує його ), виводить Oі закінчує @.

Друга така:

2")O@

який розширюється до

  2
" ) O @
  .

Внаслідок програма штовхає напівкокс-коду ), Oі @, збільшує останню з ), з виходами O, і закінчується @.

> <> , 6 чисел

Здобув 2 числа завдяки Teal Pelican

1ln";

Випускає унікальні номери [1, 4, 5, 49, 59, 108]

Нам потрібно nнадрукувати номер.
Нам потрібно; припинити.

Це залишає нам лише 3 символи для роботи.

Кілька різних комбінацій value& operatorразом із "підтвердженим дають 6 унікальних значень, але я не знайшов нічого кращого за це.

Гроовий, 10 чисел

Рішення людини JVM - це БАДЕ для цього ... Хто знав?

1200+

Призводить до:

[3, 10, 12, 17, 21, 30, 66, 80, 102, 120]

Чекати, що? Як, чорт забирає, ви запитуєте 17?

20+10 is 30.
0120+ is invalid.
2+001 is 3.
201+0 is 201.
2+100 is 102.
0+012 is 10.
21+00 is 21.
02+01 is 3.
0210+ is invalid.
10+20 is 30.
200+1 is 201.
0+210 is 210.
1200+ is invalid.
0201+ is invalid.
+0021 is 17.
1+002 is 3.
210+0 is 210.
100+2 is 102.
010+2 is 10.
00+12 is 12.
20+01 is 21.
01+20 is 21.
0+120 is 120.
+0120 is 80.
0+021 is 17.
+1020 is 1020.
0012+ is invalid.
02+10 is 12.
102+0 is 102.
012+0 is 10.
+2100 is 2100.
12+00 is 12.
00+21 is 21.
+2001 is 2001.
+0210 is 136.
+1200 is 1200.
1020+ is invalid.
0102+ is invalid.
2001+ is invalid.
001+2 is 3.
+0012 is 10.
2+010 is 10.
0021+ is invalid.
10+02 is 12.
2100+ is invalid.
+0201 is 129.
2010+ is invalid.
020+1 is 17.
1002+ is invalid.
+2010 is 2010.
1+020 is 17.
1+200 is 201.
01+02 is 3.
+1002 is 1002.
120+0 is 120.
0+102 is 102.
+0102 is 66.
002+1 is 3.
0+201 is 201.
021+0 is 17.

Комерційна таємниця у цілих числах Groovy / Java, перед якими 0 - восьмери. Код, який я використовував для тестування відповідей Groovy, якщо хтось хоче мене перемогти:

("1200+" as List).permutations().collect{
    it.join()
}.collect {
    print "$it is "
    x=-1;
    try {
        x=Eval.me(it);
        println "$x."
    } catch(Exception e) {
        println "invalid."
    }
    x<=120?x:-1;
}.unique().sort();​

MATL, 15 номерів

0123%

% є оператором коментарів, тож він "вирізатиме" у всіх можливих місцях один раз, допомагаючи створити всі можливі комбінації заданих цифр і підмножини з них:

1
2
3
10
12
13
20
21
23
30
31
32
102
103
120

J, 16 чисел

1234]

Нічого фантазійного, просто перевірено 1234усіма дієсловами з 1 символом, які були розумними. ]вибирає правильний аргумент.

Унікальні цифри виробляються

0 4 3 34 43 2 24 42 23 32 234 243 324 342 423 432 1 14 41 13 31 134 143 314 341 413 431 12 21 124 142 214 241 412 421 123 132 213 231 312 321 1234 1243 1324 1342 1423 1432 2134 2143 2314 2341 2413 2431 3124 3142 3214 3241 3412 3421 4123 4132 4213 4231 4312 4321

з яких 16:

4 3 34 43 2 24 42 23 32 1 14 41 13 31 12 21

Знаходяться в діапазоні [1,120].

Тестували с

# (#~e.&(>:i.120)) ~. (". :: 0:)"1 (A.~ i.@!@#) '1234]'

Japt , 41 число

Насправді просто проб і помилок, тому може бути краще рішення. Використовує цілі числа 3& 4та ярлики Japt для відбору, додавання 1та множення на 2. Всі 120 програм видають ціле число, >0але лише 78 є, <=120і лише 41 з них є унікальними.

34²ÄÑ

Згенерує числа:

1,3,4,5,6,7,8,9,13,14,17,20,21,26,27,29,30,31,32,33,34,35,36,37,38,39,42,43,44,45,47,56,59,68,69,72,73,86,87,92,93

Переглянути список номерів або колекцію дійсних програм

Пояснення

Кілька речей, які слід зазначити про Japt, які тут є актуальними:

1. Якщо програма не починається з (у цьому випадку) однієї з цифр, то перша вхідна змінна U, для якої за замовчуванням0 , автоматично вставляється на початку,
2. Якщо одна чи обидві цифри негайно слідують за одним із ярликів математичної операції, вони додаються до неї (наприклад, 3Ä4 = 3+14 = 17і, аналогічно,4Ѳ = 4*2**2 = 16 ), і,
3. Якщо одна з цифр одразу слідує за ²тодішньою, ²і все, що перебуває перед нею, по суті, ігнорується.

Пояснення декількох програм (що виробляють 1, 3, 37і 93, відповідно):

²Ñ34Ä  :Square 0, multiply by 234 and add 1
4ÄѲ3  :Add 1 multiplied by 2 squared to 4, ignore that and return the 3
3²Ä4Ñ  :Square 3 and add 14 multiplied by 2
4Ñ3IJ  :Multiply 4 by 23 and add 1 squared

Befunge, 11 номерів

Befunge трохи обмежений, оскільки він підтримує лише одноцифрові літерали. Тож найкраще, що я міг придумати, - це 11 чисел, якщо припустити, що обчислення повинно залишати нам одне і лише одне число на стеці.

Найкращі персонажі: 358*%

Згенеровані числа: (лише один приклад кожного)

58*3% => 1
358*% => 3
38*5% => 4
538*% => 5
35*8% => 7
835*% => 8
385%* => 9
583%* => 10
358%* => 15
53%8* => 16
35%8* => 24

Пітон, 16 чисел

1234#

Використовує #, щоб прокоментувати всі непотрібні номери.

постійного струму, 19 чисел

*3zO+

Вихід знаходиться на вершині стека, а помилки (включаючи підтік стека) ігноруються. Дійсні перестановки:

+O3*z:   1
+O*3z:   2
+Oz3*:   3
O*z3+:   4
O*3z+:   5
+O3z*:   6
+z3*O:  10
3*zO+:  11
3*Oz+:  12
Oz3*+:  13
O3z*+:  16
+3Oz*:  20
3Oz*+:  23
+zO3*:  30
O3*z+:  31
Oz+3*:  33
3Oz+*:  36
Oz3+*:  40
O3z+*:  50
TOTAL COUNT = 19 numbers

Ось програма Python, яку я використовував для показу цих результатів:

#!/usr/bin/python

import sys
import itertools
import subprocess

if len(sys.argv[1]) != 5:
    print("Invalid input")
    sys.exit(1)

devnull = open("/dev/null", 'w');

r = dict()
for s in itertools.permutations(sys.argv[1]):
    p = "".join(s)
    try:
        e = (subprocess.check_output(['dc', '-e', p, '-e', 'p'], stderr=devnull))
        e = int(e)
        if 0 < e <= 120:
            r[e] = p
    except e:
        pass

for i in sorted(r):
    print("%5s: %3d" % (r[i], i))

print("TOTAL COUNT = %d numbers" % len(r))

Дві інші струни, які дають однакову оцінку 19, - 32d+*і *4zO+.

Малий розмова, 26 номерів

1235r

Пояснення: 12r35 є позначенням для використання радіусу 12, і, таким чином, 3 * 12 + 5.
Це можна перевірити в Squeak:

((Array streamContents: [:s |
    '1235r'  permutationsDo: [:each | 
        | eval |
        eval := [Compiler evaluate: each] ifError: [nil].
        (eval isInteger and: [eval >=1 and: [eval <= 120]]) ifTrue: [s nextPut: each copy -> eval]]])
  collect: #value as: Set) sorted

дає:

#(1 2 3 5 28 31 33 37 38 41 42 47 55 58 63 66 67 68 71 76 82 86 105 107 108 116)

Якщо ми замінимо останній рядок на:

    sorted: #value ascending)

Тоді ми отримуємо вирази:

'235r1' -> 1
'253r1' -> 1
'325r1' -> 1
'352r1' -> 1
'523r1' -> 1
'532r1' -> 1
'135r2' -> 2
'153r2' -> 2
'315r2' -> 2
'351r2' -> 2
'531r2' -> 2
'513r2' -> 2
'125r3' -> 3
'152r3' -> 3
'215r3' -> 3
'251r3' -> 3
'521r3' -> 3
'512r3' -> 3
'123r5' -> 5
'132r5' -> 5
'213r5' -> 5
'231r5' -> 5
'321r5' -> 5
'312r5' -> 5
'23r15' -> 28
'25r13' -> 28
'13r25' -> 31
'15r23' -> 33
'32r15' -> 37
'35r12' -> 37
'5r123' -> 38
'12r35' -> 41
'5r132' -> 42
'15r32' -> 47
'52r13' -> 55
'53r12' -> 55
'5r213' -> 58
'12r53' -> 63
'5r231' -> 66
'13r52' -> 67
'31r25' -> 67
'21r35' -> 68
'35r21' -> 71
'25r31' -> 76
'5r312' -> 82
'5r321' -> 86
'51r23' -> 105
'53r21' -> 107
'21r53' -> 108
'23r51' -> 116

Я хотів обдурити і визначити метод r в Integer як

Integer>>r
    ^self \\ 120 + 1

На жаль, компілятор розбивається на 1235r, оскільки він розпізнає незакінчене число з радіусом, а не повідомленням r, що надсилається на 1235 ...
Я міг би легко змінити і компілятор, але це трохи забагато накрутки на мій смак.

Математика, 16 чисел

;1234

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

16 чисел (в діапазоні), які можна створити з вищезгаданих 5 символів, це:

1, 2, 3, 4, 12, 13, 14, 21, 23, 24, 31, 32, 34, 41, 42, 43

Рунічні чари, 19 номерів

234p@

По суті, 3 літерали, оператор pow та команда «надрукувати весь стек та завершити». 234p@відбитки 812 (3 ^ 4 у поєднанні з 2). Повний список перестановок , зауважте, що @його було замінено ak@, щоб генерувати новий рядок між кожним результатом та a> , додано, щоб гарантувати, що кожен рядок виконується незалежно. Зауважте також, що результати не в тому ж порядку, що і програми, що їх створили (оскільки деякі програми можуть швидше закінчуватися).

У багатьох перестановках нічого не друкується (наприклад, @234pабо p234@), але 19 призводять до виведення в межах допустимого діапазону.

Можливі числа (і одна можлива програма, яка призводить до цього; .вказує, що ці позиції можуть бути будь-якими з інших символів, оскільки вони не виконуються):

2@...        2
3@...        3
4@...        4
23p@.        8
32p@.        9
42p@.       16
32@..       23
42@..       24
23@..       32
43@..       34
24@..       42
34@..       43
23p4@       48
32p4@       49
43p@.       64
34p@.       81
423p@       84
432p@       94

TI-BASIC, 12 номерів

23+4!

Найімовірніше, є краща комбінація, але я не зміг її знайти.

Усі $24$ дійсні перестановки такі:

23+4!   -> 47
24+3!   -> 30
2+4!3   -> 74
2+3!4   -> 26
2!4+3   -> 11
2!+43   -> 45
2!+34   -> 36
2!3+4   -> 10
32+4!   -> 56
34+2!   -> 36
3+4!2   -> 51
3+2!4   -> 11
3!4+2   -> 26
3!+42   -> 48
3!+24   -> 30
3!2+4   -> 16
43+2!   -> 45
42+3!   -> 48
4+2!3   -> 10
4+3!2   -> 16
4!2+3   -> 51
4!+23   -> 47
4!+32   -> 56
4!3+2   -> 74

З яких є $12$ унікальні цінності:

$10,11,16,26,30,36,45,47,48,51,56,74$