Chọn bất kỳ năm ký tự mà ngôn ngữ của bạn hỗ trợ. Có 5! = 5 × 4 × 3 × 2 × 1 = 120 cách có thể được sắp xếp thành một chuỗi 5 ký tự chứa mỗi ký tự một lần; 120 hoán vị .

Chọn các ký tự của bạn sao cho mỗi chuỗi trong số 120 chuỗi được chạy bằng ngôn ngữ của bạn, 120 đầu ra được tạo sẽ có càng nhiều số nguyên duy nhất từ ​​1 đến 120 (bao gồm) càng tốt.

Nghĩa là, với mỗi trong số 120 hoán vị của 5 ký tự của bạn tạo mã có thể chạy được tạo ra một số duy nhất, bạn muốn tập hợp tất cả các số đó khớp với nhau nhất có thể với bộ số nguyên từ 1 đến 120.

Vì vậy, lý tưởng, hoán vị đầu tiên của bạn sẽ xuất ra 1, tiếp theo 2, tiếp theo 3, tất cả các cách lên đến 120. Nhưng lý tưởng đó dường như là không thể đối với hầu hết các ngôn ngữ và nhân vật.

Chuỗi 5 ký tự có thể được chạy dưới dạng:

• một chương trình không có đầu vào
• một hàm không có đối số
• một REPL lệnh

Các chuỗi khác nhau có thể được chạy theo những cách khác nhau nếu muốn

Để đầu ra được tính, nó phải là một đầu ra số nguyên theo cách thông thường , chẳng hạn như:

• được in ra thiết bị xuất chuẩn
• trả về bởi hàm
• kết quả của biểu thức REPL

Mã sẽ chấm dứt bình thường ( có thể liên quan đến lỗi miễn là số đã được xuất ra đầu tiên). Mã hoàn toàn không chạy, chỉ có đầu ra (không tồn tại) không được tính. Đầu ra số phải ở dạng thập phân trừ khi một cơ sở khác là tiêu chuẩn cho ngôn ngữ của bạn.

Bài nộp tạo ra các số khác biệt nhất từ ​​1 đến 120 thắng. Trình trước đó chiến thắng trong trường hợp hòa.

Ghi chú

• Tất cả 5 ký tự của bạn không cần phải khác nhau, nhưng tất nhiên việc có các ký tự trùng lặp sẽ làm giảm số lượng hoán vị hiệu quả.
• Đầu ra nổi như 32.0đếm cũng như đồng bằng 32. (Nhưng 32.01sẽ không.)
• Các số 0 đứng đầu như 032đếm cũng như đơn giản 32.
• Đầu ra hợp lệ nên được xác định và bất biến thời gian.
• Chúng tôi đang xử lý các ký tự , không phải byte.

Thí dụ

Các ký tự 123+*là lựa chọn đầu tiên hợp lý cho REPL (hoặc nhiều ngôn ngữ) của Python. Kết quả 120 hoán vị và đầu ra là:

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

Có 36 số được tạo, tất cả may mắn trong vòng 1 đến 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

Tuy nhiên, chỉ có 8 trong số đó là duy nhất:

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

Vì vậy, một bài nộp như vậy sẽ chỉ đạt 8 trên 120 điểm tối đa.

Python3, 21 27 giá trị

Nhân vật: 3479%

Số duy nhất: [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]

Như đã yêu cầu, đây là những hoán vị nằm trong phạm vi [1, 120] . Hãy thử trực tuyến!

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 số

4·>Ìn

Tạo các số duy nhất:

[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]

Sử dụng liên tục 4với các hoạt động +1, +2, *2và ^2.

Con trăn, 18 số

237#-

Sản xuất như kết quả hợp lệ:

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

EDIT: Tôi có thể chứng thực rằng giải pháp của TuukkaX là tối ưu cho Python. Tôi đã chạy đoạn mã sau đây bruteforcing tất cả các kết hợp có thể có của 5 ký tự ASCII có thể in:

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')

Các kết quả (sau khi chạy trong gần 7 tiếng đồng hồ) cho thấy các giải pháp tối ưu là trong thực tế 27 số khác nhau, được sản xuất bởi ba giải pháp khác nhau tất cả bằng bốn số và mod ( %): %3479, %5679và %5789.

Java 8, 2 4 số

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

Bạn không mong đợi một câu trả lời Java, phải không?

Đây là một lambda chỉ có thể được sắp xếp theo một trong hai cách (và với bất kỳ hai chữ số khác nhau!) Cho tổng số hai số duy nhất. Mọi thứ khác không phải là lambda hợp lệ.

Thực tế đã cải thiện câu trả lời, nhờ một số trợ giúp từ ý kiến! Không thấy rằng 0 không hợp lệ và quên rằng các biến có thể, nhiều hơn một ký tự. Chúng tôi đã có 4!

Một giải pháp thậm chí còn tồi tệ hơn

()->1

Nhưng, về mặt tươi sáng, hai câu trả lời độc đáo trong Java!

Thạch, 26 30 32 số

‘’3²Ḥ

Đây (và đảo chữ cái của nó) là các chương trình đầy đủ, không có đầu vào và tạo đầu ra trên đầu ra tiêu chuẩn.

Các đầu ra từ 120 chương trình, theo thứ tự Jelly tạo ra chúng nếu bạn yêu cầu nó tạo ra hoán vị của chương trình:

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

Nếu bạn chỉ lấy các đầu ra duy nhất theo thứ tự số, bạn sẽ nhận được:

-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

Nhiều trong số này quá nhỏ và 135 quá lớn, nhưng vẫn còn 32 trong phạm vi.

Ý tưởng cơ bản là sử dụng các hướng dẫn chủ yếu là đơn âm (trong một chương trình chỉ có các đơn vị và nilad, mỗi lệnh này chỉ biến đổi đầu ra trước đó) và các hướng dẫn cho phép giá trị phân kỳ nhanh chóng. Ngoại lệ là với 3, đó là một nilad (giá trị không đổi 3). Nếu nó xuất hiện khi bắt đầu chương trình, tất cả các thao tác sẽ được thực hiện từ 3. Nếu nó xuất hiện ở giữa, nó sẽ chia chương trình thành hai nửa, mỗi nửa sẽ xuất một số nguyên (và mỗi lần in ra một đầu ra tiêu chuẩn, kết quả cuối cùng được nối, do đó cung cấp cho chúng tôi "nối" như một thao tác bổ sung để tạo số).

Các hoạt động chúng ta có ở đây, trong bối cảnh chương trình tạo ra chúng, là: gia tăng; giảm giá; hằng số 3; Quảng trường; và gấp đôi. Không may tăng và giảm là không đối lập, và giảm có xu hướng đáng tiếc để tạo -1 hoặc -2 trong phần đầu tiên (do đó dẫn đến một số âm tổng thể), nhưng điều này vẫn cho kết quả đầu ra lớn hơn so với những thứ khác tôi đã thử . Đặc biệt, chúng ta có được một mức chênh lệch khá tốt của cả nửa đầu và nửa thứ hai của số (lưu ý rằng nửa đầu có thể là chuỗi null, nếu3 là ký tự đầu tiên trong chương trình).

JavaScript, 27 số

Rất giống với câu trả lời của TuukkaX , với một bộ chữ số khác.

5789%

27 giá trị riêng biệt là:

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

Brachylog , 26 số

3+*^-

Điều này xuất ra các số sau: [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]

Giải trình

• 3 là số nguyên 3, rõ ràng.
• + là gia tăng
• * là gấp đôi
• ^ là hình vuông
• - là giảm

Có rất nhiều tình huống mà chương trình chỉ đơn giản là lỗi: ví dụ *+^3-lỗi vì nó yêu cầu Hãy lấy 0, nhân đôi, tăng, bình phương, kết quả của hình vuông đó là 3, giảm giá trị rõ ràng là sai.

Bất kỳ chương trình kết thúc với 3sẽ đầu ra 3hoặc không hoạt động.

Bất kỳ chương trình nào bắt đầu *3sẽ lặp lại vô hạn vì lỗi (Brachylog đang cố gắng tìm danh sách các danh sách phụ mà sản phẩm dẫn đến 3 không thể thực hiện được).

Vim, 16 số

i1234

in

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

Mã máy IA-32, 8 số

Giá trị byte thập lục phân:

2c 40 48 b0 c3

Mã được chạy như một hàm trả về giá trị trong al.

Hoán vị hợp lệ:

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)

Tôi đã thực hiện một tìm kiếm vũ phu, với các ràng buộc sau:

• Byte đầu tiên là b0- để khởi tạo althanh ghi
• Byte cuối cùng là c3- return; các byte sau bị loại bỏ
• Các byte opcode có thể là:
  • 0x04 - add
  • 0x0c - or
  • 0x24 - and
  • 0x2c - sub
  • 0x34 - xor
  • 0xd4 - aad
  • 0x40 - inc
  • 0x48 - dec

Điều này chỉ để lại 3 byte có thể thay đổi với tối đa 15 kết quả có thể. Trong số này, tối đa là 9 có thể là khác biệt (trên thực tế, điều này chỉ xảy ra với một bộ byte!). Một trong các giá trị nằm ngoài phạm vi, do đó, giá trị này để lại 8 giá trị. Có một tập hợp byte khác

34 40 48 b0 c3

cũng cung cấp 8 giá trị riêng biệt - các chương trình là như nhau, ngoại trừ được subthay thế bởi xor, điều này làm cho hai trong số các đầu ra có thể giống hệt nhau.

Tất cả các bộ byte khác cho 7 hoặc ít hơn kết quả có thể.

Thạch , 33 số

Ḥ23+c

Ḥgấp đôi (trái);
2nghĩa đen 2;
3nghĩa đen 3;
+thêm (trái, phải); và
c chọn (trái, phải), tức là số cách chọn đối tượng phải từ bộ sưu tập các đối tượng bên trái.

Các số mang lại với một chương trình ví dụ:

 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

Tôi đã cố gắng chọn những cái dễ phân tích, nhưng một số rất hiếm và hơi lạ để phân tích, ví dụ 23là:

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

... và 72và 13sử dụng in ấn ngầm:

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)

Lưu ý rằng Ḥ34+ccũng tạo ra 33các giá trị duy nhất trong [1,120].

Brain-Flak 1

(())#

Brain-Flak yêu cầu niềng răng cân bằng, vì vậy chương trình 5 ký tự chỉ có giá trị nếu một trong các nhân vật bắt đầu nhận xét. Điều đó khiến chúng tôi có 4 nhân vật để làm việc. Trong số đó, 2 phải (và )nếu không sẽ không có gì được đẩy lên ngăn xếp. Những người phải đi đầu tiên và thứ 4 với nhận xét cuối cùng ( (..)#). Bây giờ chúng ta có thể đặt (), {}, <>, hoặc []bên trong. {}, <>và []mỗi đánh giá về 0, nhưng ()là 1. Điều đó có nghĩa (())#là chuỗi 5 ký tự duy nhất tạo ra chương trình Brain-Flak hợp lệ.

Hãy thử trực tuyến!

Nếu câu hỏi thay vào đó là " 6 nhân vật mạnh nhất" là gì, thì câu trả lời sẽ (){}[]là Brain-Flak hoàn toàn an toàn khi chỉ sử dụng tập hợp con này.

Lục giác , 13 số

)24!@

Đây là 13 số có thể in được với một chương trình có thể có cho mỗi số đó:

)!@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

Các chương trình nên khá tự giải thích. @chấm dứt chương trình, !in giá trị hiện tại, )tăng giá trị 2và 4tự thêm vào giá trị hiện tại (trong đó giá trị ban đầu là 0). Bố cục hình lục giác thực tế của mã nguồn không liên quan ở đây, các chương trình có thể được đọc từ trái sang phải.

Điều này nên tối ưu, mặc dù thay vì 2và 4bạn có thể chọn bất kỳ chữ số cặp nào xvà ynhư vậy 2 ≤ x ≤ y-2.

Giải pháp trên được tìm thấy bởi lực lượng vũ phu (gần như toàn diện), yêu cầu một !(nếu không nó sẽ không in bất cứ thứ gì), một @(nếu không chương trình sẽ không chấm dứt) và điền vào ba ký tự còn lại bằng bất kỳ kết hợp (lặp lại) nào từ bộ ký tự sau:

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

Tôi không thể thấy bất kỳ lệnh nào khác có thể tạo ra sự đa dạng hơn.

Perl, 27 số

3479%

Perl không có REPL tích hợp, vì vậy bạn có thể sử dụng re.pltừ Devel :: REPL .

Các kết quả:

%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

Bắt buộc sử dụng chương trình sau đây:

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 số

Không phải là một con số khổng lồ nhưng nó có thể là số tốt nhất có thể được thực hiện với R. Tôi đã tìm kiếm tất cả các kết hợp chữ số 0..9, toán tử + - * / ^và char bình luận #, và tám số sau đây đều xuất ra 18 số nguyên duy nhất trong khoảng từ 1 đến 120.

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

Ví dụ, chúng ta hãy lấy -#146. Dưới đây là 18 số nguyên chúng ta có thể nhận được:

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

Nếu bạn tò mò về mã (xấu) được sử dụng để kiểm tra tất cả các kết hợp có thể, thì đây là. Nó xuất ra số lượng số nguyên duy nhất trong khoảng từ 1 đến 120 cho mỗi tổ hợp ký tự có độ dài 5 đến một tệp có tên là "datafile" trong thư mục làm việc hiện tại.

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)
      }
)

Tháng mười, 18

Điều này đã được tìm thấy bằng cách sử dụng một tìm kiếm bruteforce trên các biểu tượng *+-/0123456789:;<\^|~%. Nhưng nó đã mất quá nhiều thời gian để tính toán ...

-139%

Đầu ra có thể:

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

Octave, 15 số

Không có nhiều điều để khoe khoang, nhưng đây là điều tốt nhất tôi có thể nhận được trong Octave:

124+%

Nó đưa ra những con số:

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

Tôi cũng nhận được 16, nhưng có vẻ như nó giống hệt câu trả lời của Sefa ...

1234%

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

PHP, 15 số

1230\r

Sử dụng thực tế là php in bất cứ thứ gì bên ngoài các thẻ của nó nguyên văn (không sử dụng cái này bạn có thể thực hiện chính xác 1 số với một cái gì đó như <?=1;). Cũng sử dụng một nhân vật trở lại vận chuyển thực tế chứ không phải \r.

Tạo (sắp xếp, loại bỏ hàng đầu 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

trong đó các số duy nhất hợp lệ là:

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

Hình khối , 7 số

"2)@O

Xuất ra những con số này:

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

Bất kỳ chương trình Cubix hợp lệ nào cho thử thách này đều phải có Ođầu ra một số nguyên và @chấm dứt chương trình (Cubix thậm chí chưa bao giờ nghe về "lỗi"). Điều này cho chúng ta 3 ký tự để chơi xung quanh để tạo ra nhiều kết quả đầu ra nhất. Hơn nữa, do cách Cubix sắp xếp mã trên một khối lập phương, char đầu tiên sẽ vô dụng trừ khi một trong những char khác là char định hướng.

Cách hiệu quả nhất mà tôi đã tìm thấy để tạo ra nhiều số là sử dụng "để đẩy một chuỗi mã char vào ngăn xếp. Với sự sắp xếp lại cẩn thận, chúng ta có thể sắp xếp một vài ký tự ở vị trí cuối cùng và chỉ cần xuất mã char của chúng. Bằng cách sử dụng )để tăng mục hàng đầu, chúng tôi có thể tạo đầu ra bổ sung từ một số sắp xếp này.

Có hai loại chương trình cơ bản được sử dụng ở đây. Đầu tiên là đây:

"2)O@

mở rộng ra

  "
2 ) O @
  .

Chương trình kết quả sẽ đẩy 2đến ngăn xếp, tăng nó với ), xuất ra Ovà kết thúc bằng @.

Thứ hai là đây:

2")O@

mở rộng ra

  2
" ) O @
  .

Chương trình kết quả đẩy char-mã của ), Ovà @, increments người cuối cùng với ), kết quả đầu ra với O, và kết thúc với @.

> <> , 6 số

Đạt được 2 số nhờ Teal Pelican

1ln";

Tạo số duy nhất [1, 4, 5, 49, 59, 108]

Chúng tôi cần nin một số.
Chúng ta cần ;chấm dứt.

Điều đó khiến chúng tôi chỉ có 3 ký tự để làm việc.

Một vài kết hợp khác nhau của value& operatorcùng với "xác nhận sẽ tạo ra 6 giá trị duy nhất, nhưng tôi không tìm thấy gì tốt hơn thế.

Groovy, 10 số

Man giải pháp JVM là BAD cho điều này ... Ai biết?

1200+

Kết quả trong:

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

Đợi đã, cái gì? Làm thế quái nào mà nó làm 17 bạn hỏi?

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.

Bí mật thương mại, trong các số nguyên Groovy / Java có trước 0 là các quãng tám. Mã tôi đã sử dụng để kiểm tra các câu trả lời Groovy trong trường hợp ai đó muốn đánh bại tôi:

("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 số

0123%

% là toán tử nhận xét, do đó, nó sẽ "cắt" ở tất cả các vị trí có thể một lần, giúp tạo ra tất cả các kết hợp có thể có của các chữ số và tập con đã cho của chúng:

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

J, 16 số

1234]

Không có gì lạ mắt, chỉ cần thử nghiệm 1234với tất cả các động từ 1 ký tự là hợp lý. ]chọn đối số đúng của nó.

Các số duy nhất được sản xuất là

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

trong đó 16:

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

Có trong phạm vi [1.120].

Đã thử nghiệm với

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

Japt , 41 số

Khá nhiều chỉ là thử nghiệm và lỗi vì vậy có thể có một giải pháp tốt hơn. Sử dụng số nguyên 3& 4và các phím tắt Japt để bình phương, thêm 1và nhân với 2. Tất cả 120 chương trình xuất ra một số nguyên >0nhưng chỉ có 78 <=120và chỉ có 41 chương trình là duy nhất.

34²ÄÑ

Tạo các số:

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

Xem danh sách các số hoặc bộ sưu tập các chương trình hợp lệ

Giải trình

Một vài điều cần lưu ý về Japt có liên quan ở đây là:

1. Nếu một chương trình không bắt đầu bằng (trong trường hợp này) một trong các chữ số thì biến đầu vào đầu tiên U, mặc định 0là, sẽ tự động được chèn vào lúc bắt đầu,
2. Nếu một hoặc cả hai chữ số ngay lập tức theo một trong các phím tắt cho một phép toán thì chúng sẽ được thêm vào nó (ví dụ 3Ä4 = 3+14 = 17và, tương tự,4Ѳ = 4*2**2 = 16 ), và,
3. Nếu một trong các chữ số ngay sau ²đó thì ²và mọi thứ trước đó, về cơ bản, bị bỏ qua.

Giải thích cho một vài trong số các chương trình (sản xuất 1, 3, 37và 93, tương ứng):

²Ñ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 số

Befunge bị giới hạn một chút vì nó chỉ hỗ trợ các chữ số đơn. Vì vậy, số tốt nhất tôi có thể đưa ra là 11 số, giả sử phép tính phải để lại cho chúng tôi một và chỉ một số trên ngăn xếp.

Nhân vật hay nhất: 358*%

Các số được tạo: (chỉ một ví dụ về mỗi số)

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

Con trăn, 16 số

1234#

Sử dụng # để nhận xét tất cả các số không cần thiết.

đc, 19 số

*3zO+

Đầu ra nằm trên cùng của ngăn xếp và các lỗi (bao gồm cả ngăn xếp ngăn xếp) bị bỏ qua. Các hoán vị hợp lệ là:

+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

Đây là chương trình Python tôi đã sử dụng để hiển thị các kết quả đó:

#!/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))

Hai chuỗi khác cho cùng số điểm là 19 32d+*và *4zO+.

Smalltalk, 26 số

1235r

Giải thích: 12r35 là ký hiệu cho việc sử dụng cơ số 12, và do đó là 3 * 12 + 5.
Điều này có thể được xác minh trong 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

cho:

#(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)

Nếu chúng ta thay thế dòng cuối cùng bằng:

    sorted: #value ascending)

sau đó chúng tôi nhận được các biểu thức:

'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

Tôi muốn gian lận và định nghĩa một phương thức r trong Integer là

Integer>>r
    ^self \\ 120 + 1

Thật không may, trình biên dịch chọn trên 1235r vì nó nhận ra một số chưa hoàn thành với radix chứ không phải là tin nhắn r gửi đến 1235 ...
Tôi cũng có thể dễ dàng thay đổi trình biên dịch, nhưng nó hơi quá so với sở thích của tôi.

Toán học, 16 số

;1234

Không thú vị lắm, nhưng tôi dường như không thể tìm thấy bất cứ điều gì tốt hơn bằng cách sử dụng số học. Điều duy nhất có thể hoạt động là sử dụng !cho giai thừa hoặc nhân đôi, nhưng điều này rất dễ tạo ra số lượng lớn đến mức không thể vũ trang.

16 số (trong phạm vi) có thể được tạo từ 5 ký tự trên là:

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

Bùa mê, 19 số

234p@

Về cơ bản 3 chữ, toán tử pow và lệnh "in toàn bộ ngăn xếp và chấm dứt". 234p@in 812 (3 ^ 4 kết hợp với 2). Danh sách hoán vị đầy đủ , lưu ý @đã được thay thế ak@để tạo dòng mới giữa mỗi kết quả và >đã được thêm vào để đảm bảo rằng mỗi dòng thực hiện độc lập. Cũng lưu ý rằng các đầu ra không theo thứ tự như các chương trình đã tạo ra chúng (vì một số chương trình có thể chấm dứt nhanh hơn).

Nhiều hoán vị không in gì (ví dụ: @234phoặc p234@), nhưng 19 không dẫn đến kết quả đầu ra trong phạm vi cho phép.

Các số có thể (và một chương trình có thể có kết quả trong đó; .chỉ ra rằng các vị trí đó có thể là bất kỳ ký tự nào còn lại vì nó không được thực thi):

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 số

23+4!

Có khả năng là một sự kết hợp tốt hơn, nhưng tôi không thể tìm thấy nó.

$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$