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

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

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

Таким образом, в идеале ваша первая перестановка будет выводить 1следующую 2, следующую 3, вплоть до 120. Но этот идеал, вероятно, невозможен для большинства языков и символов.

Строки из 5 символов могут быть выполнены как:

• программа без ввода
• функция без аргументов
• РЕПЛ команда

При желании разные строки можно запускать разными способами.

Чтобы выходные данные учитывались, они должны быть обычным целочисленным выходом , например:

• печатается на стандартный вывод
• возвращается функцией
• результат выражения REPL

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

Представление, которое генерирует наиболее четкие числа от 1 до 120 побед. Более раннее представление выигрывает в случае ничьей.

Примечания

• Ваши 5 символов не обязательно должны быть разными, но, разумеется, наличие дублированных символов уменьшает эффективное количество перестановок.
• Выводы с плавающей запятой, такие как 32.0count, а также plain 32. (Но 32.01не будет.)
• Ведущие нули, такие как 032число, а также обычные 32.
• Допустимые результаты должны быть детерминированными и инвариантными по времени.
• Мы имеем дело с символами , а не байтами.

пример

Символы 123+*являются разумным первым выбором для REPL 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

РЕДАКТИРОВАТЬ: Я могу засвидетельствовать, что решение 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.

Java 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будет бесконечно зацикливаться из-за ошибки (Brachylog пытается найти список подсписков, результат которых в 3, что невозможно).

Вим, 16 номеров

i1234

Распечатать

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

МА-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].

Brain-Flak 1

(())#

Brain-Flak требует сбалансированных фигурных скобок, поэтому программа из 5 символов действительна, только если один из символов начинает комментарий. Это оставляет нам 4 персонажа для работы. Из них 2 должны быть (и в )противном случае ничего не будет получить в стек. Те, кто должен идти первым и четвертым с комментарием last ( (..)#). Теперь мы можем поставить (), {}, <>или []внутри. {}, <>и []каждый оценивается как 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 номеров

Не много хвастаться, но это лучшее, что я могу получить в Octave:

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

Cubix , 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 никогда не слышал об «ошибках»). Это дает нам 3 символа, с которыми можно поиграть, чтобы получить наибольшую отдачу. Кроме того, из-за того, что Cubix размещает код на кубе, первый символ будет бесполезен, если только один из них не является направленным символом.

Я обнаружил, что наиболее эффективный способ генерирования нескольких чисел - "это поместить строку символов в стек. Тщательно переставив, мы можем разместить несколько символов в последнем месте и просто вывести их коды символов. Используя )для увеличения верхнего элемента, мы можем создать дополнительные выходные данные из нескольких из этих соглашений.

Здесь используются два основных типа программ. Первое это:

"2)O@

который расширяется до

  "
2 ) O @
  .

Результирующая программа помещает 2в стек, увеличивает его на ), выводит с помощью Oи завершает с помощью @.

Второе это:

2")O@

который расширяется до

  2
" ) O @
  .

Результате программа толкает полукокс-коду ), Oи @, увеличивает последнюю с ), с выходами O, и заканчивается @.

> <> , 6 номеров

Получил 2 номера благодаря Тил Пеликан

1ln";

Производит уникальные номера [1, 4, 5, 49, 59, 108]

Нам нужно nнапечатать номер.
Нам нужно ;прекратить.

Это оставляет нам только 3 символа для работы.

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

Groovy, 10 номеров

Решения Man 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();​

МАТЛ, 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

Находятся в диапазоне [1120].

Протестировано с

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

Япт , 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

Python, 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+.

Smalltalk, 26 номеров

1235r

Пояснение: 12r35 является обозначением для использования radix 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, потому что он распознает незаконченное число с помощью radix, а не сообщение 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$