Có 40 cách mà một đường dẫn Hamilton được định hướng có thể được sắp xếp trên lưới 3 × 3:

Đồ họa này ( cảm ơn Sp3000! ) Chỉ hiển thị 20 đường dẫn không mong muốn. Di chuyển từng đường màu theo cả hai hướng cho 40 đường dẫn.

Thử thách

Chỉ sử dụng ASCII có thể in , viết một lưới các ký tự 3 × 3, chẳng hạn như:

ABC
DEF
GHI

Khi mỗi trong số 40 đường dẫn được đọc từ lưới này là 40 chương trình một dòng, 9 ký tự, mục tiêu là để mỗi chương trình xuất ra một số nguyên duy nhất từ ​​1 đến 40. Làm điều này cho tất cả 40 đường dẫn có vẻ khó khăn và khó xảy ra, vì vậy bạn chỉ cần làm cho nó hoạt động cho càng nhiều đường càng tốt.

Bài nộp có 40 chương trình đường dẫn xuất ra các số khác biệt nhất từ ​​1 đến 40 sẽ là người chiến thắng. Tiebreaker đi đến trình trước đó.

Các chương trình đường dẫn có lỗi hoặc không xuất ra một số nguyên từ 1 đến 40 hoặc xuất ra một số nguyên mà một chương trình đường dẫn khác đã được bảo hiểm không được tính. Đặc biệt:

• Các chương trình bị lỗi trong khi biên dịch, chạy hoặc thoát không được tính. Cảnh báo là ok.
• Các chương trình không xuất ra số nguyên từ 1 đến 40 hoặc xuất ra thứ gì đó không đúng định dạng, chẳng hạn như -35hoặc 35 36không được tính.
• Các chương trình yêu cầu đầu vào của người dùng để tạo đầu ra không được tính.
• Các chương trình không bao giờ kết thúc không được tính.
• Từ giờ trở đi , các chương trình không mang tính quyết định sẽ không được tính.
• Mặt khác, các chương trình hợp lệ xuất ra một số nguyên từ 1 đến 40 mà một chương trình hợp lệ khác đã xuất không được tính. (Chương trình đầu tiên được tính.)
• Chỉ các chương trình xuất đại diện số nguyên của các số từ 1 đến 40 (đã bao gồm) được tính vào tổng số của bạn. Các con số này được dự kiến sẽ được trong thông thường 1, 2, ..., 39, 40định dạng, trừ khi đó không phải là bình thường đối với ngôn ngữ của bạn. (Một dòng mới ở đầu ra là tốt.)
• Số lượng chương trình của bạn đầu ra và thứ tự chúng là gì không quan trọng. Chỉ có số lượng số nguyên khác nhau từ các chương trình hợp lệ mới quan trọng.

Tất cả các chương trình đường dẫn phải được chạy trong cùng một ngôn ngữ. Tuy nhiên, trên thực tế, "chương trình" có thể là các hàm (không có đối số bắt buộc) hoặc lệnh REPL , cũng như các chương trình đầy đủ, in hoặc trả về số nguyên đích của chúng. Bạn có thể trộn và kết hợp giữa các chức năng, lệnh REPL và các chương trình đầy đủ.

9 ký tự ASCII có thể in của bạn không cần phải khác biệt.

Thí dụ

Nếu lưới 3 × 3 của bạn là

ABC
DEF
GHI

và 40 chương trình và đầu ra của bạn trông như thế này

ABCFEDGHI -> 26
ABCFIHEDG -> 90
ABCFIHGDE -> 2
ABEDGHIFC -> syntax error
ADEBCFIHG -> prints 40 but then errors
ADGHEBCFI -> 6
ADGHIFCBE -> 6
ADGHIFEBC -> 6
CBADEFIHG -> runtime error
CBADGHEFI -> 3
CBADGHIFE -> 4
CFEBADGHI -> -32
CFIHEBADG -> 38.0
CFIHGDABE -> "36"
EDABCFIHG -> 33
EFCBADGHI -> no output
EHGDABCFI -> compilation error
EHIFCBADG -> 8
GDABCFEHI -> 22
GHEDABCFI -> 41
IHGDEFCBA -> 0
GDEHIFCBA -> '9'
EDGHIFCBA -> +10
CFIHGDEBA -> 11
GHIFCBEDA -> error
IFCBEHGDA -> error
EBCFIHGDA -> prints 23 but then loops infinitely
CBEFIHGDA -> randomly prints either 24 or 44
GHIFEDABC -> error
IFEHGDABC -> 30
EFIHGDABC -> 39
IHGDABEFC -> 7
GDABEHIFC -> 29
EBADGHIFC -> -1
GHIFCBADE -> 26
IHGDABCFE -> 1
IFCBADGHE -> error
GDABCFIHE -> no output
IHEFCBADG -> no output
IFCBADEHG -> "quack"

điểm của bạn sẽ là 14, vì có 14 số nguyên khác nhau từ 1 đến 40 đầu ra hợp lệ, cụ thể là 26 2 6 3 4 33 8 22 11 30 39 7 29 1.

PARI / GP - 24

1%1
 8
2+3

PARI / GP bỏ qua khoảng trắng giữa các chữ số, do đó 1 8 2, ví dụ, được coi là 182. Điều tương tự có thể làm việc cho perl bằng cách thay thế khoảng trắng bằng dấu gạch dưới. Tôi đã không sử dụng hết toàn bộ không gian tìm kiếm, vì vậy có thể có những ứng cử viên tốt hơn.

Một chương trình có thể được cung cấp cho gp như gp -q -f program.gp, hoặc tương tác trong thay thế.

Đầu ra

1%1 8 2+3 -> 4
1%1 3+8 2 -> 83 # invalid
1%1 3+2 8 -> 29
1%8 2+3 1 -> 32
1 8%1 3+2 -> 7
1 2+8%1 3 -> 20
1 2+3 1%8 -> 19
1 2+3 8%1 -> 12
1%1 8 3+2 -> 3
1%1 2+8 3 -> 84 # invalid
1%1 2+3 8 -> 39
1 8%1 2+3 -> 9
1 3+8%1 2 -> 21
1 3+2 1%8 -> 18
8 1%1 3+2 -> 5
8 1%1 2+3 -> 12 # dup
8+2 1%1 3 -> 16
8+3 1%1 2 -> 15
2 1%1 8+3 -> 6
2+8 1%1 3 -> 5  # dup
3+2 8 1%1 -> 3  # dup
2 8+3 1%1 -> 28
8 2+3 1%1 -> 82 # invalid
1 3+2 8%1 -> 13
2+3 1%8 1 -> 33
3 1%8+2 1 -> 28 # dup
8%1 3+2 1 -> 29 # dup
1%8 3+2 1 -> 22
2+3 8 1%1 -> 2
3 8+2 1%1 -> 38
8 3+2 1%1 -> 83 # invalid
3+2 1%8 1 -> 24
2 1%8+3 1 -> 36
8%1 2+3 1 -> 39 # dup
2+3 1%1 8 -> 15 # dup
3+2 1%1 8 -> 6  # dup
3 1%1 2+8 -> 15 # dup
2 1%1 3+8 -> 16 # dup
3+8 1%1 2 -> 12 # dup
3 1%1 8+2 -> 15 # dup

Tất cả trừ 4 giá trị nằm trong phạm vi yêu cầu, với 12 mục trùng lặp.

Cập nhật

Tôi đã hoàn thành crunching, có sáu 23 khác biệt, và chỉ có một 24 (như đọc theo hàng):

23 1%1 6 2+3 [2, 3, 4, 5, 7, 8, 11, 12, 13, 14, 16, 17, 18, 19, 22, 24, 26, 27, 32, 33, 34, 36, 37]
23 1 2%3+2*8 [2, 5, 7, 8, 10, 11, 12, 13, 14, 16, 17, 18, 19, 20, 22, 23, 25, 26, 29, 31, 32, 37, 40]
23 2 3%1+8 2 [2, 4, 6, 7, 10, 11, 12, 13, 14, 15, 16, 20, 21, 23, 24, 28, 29, 30, 31, 32, 33, 34, 40]
23 4%6%5*7+6 [2, 4, 5, 6, 7, 8, 9, 12, 13, 19, 21, 23, 24, 26, 29, 31, 32, 33, 34, 37, 38, 39, 40]
23 5%6%4*7+6 [2, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 16, 18, 25, 26, 29, 31, 33, 34, 37, 38, 39, 40]
23 5%6%4*8+6 [1, 3, 5, 6, 8, 9, 10, 12, 14, 15, 18, 22, 24, 25, 27, 29, 30, 32, 34, 36, 37, 39, 40]

24 1%1 8 2+3 [2, 3, 4, 5, 6, 7, 9, 12, 13, 15, 16, 18, 19, 20, 21, 22, 24, 28, 29, 32, 33, 36, 38, 39]

Chương trình tôi sử dụng để crunching là dưới đây. PARI / GP có khả năng xử lý chuỗi hạn chế, do đó, chủ yếu xử lý các mảng char (aka Vecsmall). Các nhà khai thác thử nghiệm là +, -, *, \(sàn div), %, ;(biểu hiện tách, về cơ bản vứt bỏ tất cả mọi thứ trước khi nó), và (không gian, như mô tả ở trên). Toán tử số mũ ^cũng có thể được thêm vào, nhưng nó trở nên quá chậm để kiểm tra toàn diện.

perms = {[
  [1, 2, 3, 6, 5, 4, 7, 8, 9], [1, 2, 3, 6, 9, 8, 5, 4, 7], [1, 2, 3, 6, 9, 8, 7, 4, 5], [1, 2, 5, 4, 7, 8, 9, 6, 3],
  [1, 4, 5, 2, 3, 6, 9, 8, 7], [1, 4, 7, 8, 5, 2, 3, 6, 9], [1, 4, 7, 8, 9, 6, 3, 2, 5], [1, 4, 7, 8, 9, 6, 5, 2, 3],
  [3, 2, 1, 4, 5, 6, 9, 8, 7], [3, 2, 1, 4, 7, 8, 5, 6, 9], [3, 2, 1, 4, 7, 8, 9, 6, 5], [3, 6, 5, 2, 1, 4, 7, 8, 9],
  [3, 6, 9, 8, 5, 2, 1, 4, 7], [3, 6, 9, 8, 7, 4, 1, 2, 5], [5, 4, 1, 2, 3, 6, 9, 8, 7], [5, 6, 3, 2, 1, 4, 7, 8, 9],
  [5, 8, 7, 4, 1, 2, 3, 6, 9], [5, 8, 9, 6, 3, 2, 1, 4, 7], [7, 4, 1, 2, 3, 6, 5, 8, 9], [7, 8, 5, 4, 1, 2, 3, 6, 9],
  [9, 8, 7, 4, 5, 6, 3, 2, 1], [7, 4, 5, 8, 9, 6, 3, 2, 1], [5, 4, 7, 8, 9, 6, 3, 2, 1], [3, 6, 9, 8, 7, 4, 5, 2, 1],
  [7, 8, 9, 6, 3, 2, 5, 4, 1], [9, 6, 3, 2, 5, 8, 7, 4, 1], [5, 2, 3, 6, 9, 8, 7, 4, 1], [3, 2, 5, 6, 9, 8, 7, 4, 1],
  [7, 8, 9, 6, 5, 4, 1, 2, 3], [9, 6, 5, 8, 7, 4, 1, 2, 3], [5, 6, 9, 8, 7, 4, 1, 2, 3], [9, 8, 7, 4, 1, 2, 5, 6, 3],
  [7, 4, 1, 2, 5, 8, 9, 6, 3], [5, 2, 1, 4, 7, 8, 9, 6, 3], [7, 8, 9, 6, 3, 2, 1, 4, 5], [9, 8, 7, 4, 1, 2, 3, 6, 5],
  [9, 6, 3, 2, 1, 4, 7, 8, 5], [7, 4, 1, 2, 3, 6, 9, 8, 5], [9, 8, 5, 6, 3, 2, 1, 4, 7], [9, 6, 3, 2, 1, 4, 5, 8, 7]
]}

ops = Vecsmall("+-*\\%; ")

ms = 1

for(c = 48, 57, {
 for(d = c, 57,
  for(f = d, 57,
   for(g = c, 57,
    for(e = 48, 57,
     print1(Strchr([c,d,e,f,g,13]));
     for(h = 1, #ops,
      for(i = 1, #ops,
       for(j = 1, #ops,
        for(k = 1, #ops,
         a = Vecsmall([c, ops[h], d, ops[i], e, ops[j], f, ops[k], g]);
         s = Set();
         for(m = 1, #perms,
          v = Strchr(vecextract(a, perms[m]));
          iferr(b = eval(v), E, b = 0);
          if(b >= 1 && b <= 40, s = setunion(s, [b]))
         );
         if(#s >= ms, ms = min(23, #s); print(#s, " ", Strchr(a), " ", s));
        )
       )
      )
     )
    )
   )
  )
 )
})

Cá chết , 18

Đây thực sự là ngôn ngữ đầu tiên tôi đã thử trước khi tôi xem xét các toán tử infix. Bây giờ tôi đang đăng nó vì sự vui nhộn của ý tưởng rằng Deadfish có thể hữu ích cho việc gì đó.

iii
ios
sii

Đối với những người không biết Deadfish, ilà gia tăng, slà hình vuông và olà đầu ra, với bộ tích lũy bắt đầu từ 0 (cũng có một hướng dẫn thứ 4 dvề giảm giá không được sử dụng ở đây). Thực tế là chúng tôi không có in tự động và cần sử dụng olà một nhược điểm lớn, nhưng đáng ngạc nhiên là Deadfish không làm quá khủng khiếp ở đây, tất cả mọi thứ được xem xét. Nó chỉ ra rằng vị trí tối ưu của toán tử đầu ra là ở giữa.

iiisoisii 9
iiisiiois 11
iiisiisio 122
iioisiisi 2
iioiisiis 2
iisioiisi 5
iisiisiio 38
iisiisoii 36
iiiiosiis 4
iiiisiosi 17
iiiisiiso 324
isoiiisii 1
isiioiiis 3
isiisiiio 12
oiiiisiis 0
osiiiisii 0
oisiiiisi 0
oiisiiiis 0
siiiisoii 16
sioiiiisi 1
iisiosiii 5
sioiisiii 1
oisiisiii 0
isiisioii 10
siisiioii 6
isiioisii 3
oiisiisii 0
iiosiisii 2
siisoiiii 4
isoisiiii 1
osiisiiii 0
iisiiiosi 7
siiioiisi 3
oiiisiisi 0
siisiiiio 8
iisiiiiso 64
isiiiisio 26
siiiisiio 18
iiosiiiis 2
isiiiiois 5

Python REPL và nhiều hơn nữa, 22 23

6+7
*5%
6%4

Quan sát chính: Nếu bạn tô màu lưới giống như bàn cờ, đường dẫn sẽ xen kẽ màu lưới khi nó đi và bắt đầu và kết thúc trên cùng một màu.

Vẫn vũ phu buộc cho tốt hơn. Cố gắng với +*%(và ngay cả **đối với các ngôn ngữ ^là lũy thừa), không có gì tốt hơn, thật không may. Tôi cũng đã thử ném vào các toán tử bitwise và chỉ ^(xor) có vẻ giúp đỡ nhẹ, nhưng việc tìm kiếm mất quá nhiều thời gian nên tôi đã bỏ cuộc.

6+7%5*6%4 6
6+7%4%5*6 24
6+7%4%6*5 21
6+5*6%4%7 8
6*5+7%4%6 33
6*6%5+7%4 4
6*6%4%7+5 5
6*6%4%5+7 7
7+6*5%4%6 9
7+6*6%5%4 8
7+6*6%4%5 7
7%5+6*6%4 2
7%4%5+6*6 39
7%4%6*6+5 23
5*6+7%4%6 33
5%7+6*6%4 5
5%6*6+7%4 33
5%4%7+6*6 37
6*6+7%5%4 38
6%5*6+7%4 9
4%6*5%7+6 12
6*5%4%7+6 8
5*6%4%7+6 8
7%4%6*5+6 21
6%4%7+5*6 32
4%7+5%6*6 34
5+7%4%6*6 23
7+5%4%6*6 13
6%4%5*6+7 19
4%5%6*6+7 31
5%4%6*6+7 13
4%6*6+5%7 29
6*6+5%4%7 37
5+6*6%4%7 5
6%4%7+6*5 32
4%6*6+7%5 26
4%7+6*6%5 5
6*6+7%4%5 39
4%5%7+6*6 40
4%7+6*5%6 4

J, 15

2 + 1
* 3 *
2 + 3

Kết quả này chỉ là số hợp lệ, nhưng rất nhiều là trùng lặp. Các giá trị duy nhất là 17 11 16 28 31 23 13 10 21 33 18 24 22 29 27. Bạn chắc chắn có thể làm tốt hơn bằng cách thay đổi toán tử và các số nguyên liên quan.

2+1*3*2+3 -> 17
2+1*3+3*2 -> 11
2+1*3+2*3 -> 11
2+3*2+3*1 -> 17
2*3+1*3+2 -> 16
2*2+3+1*3 -> 16
2*2+3*1+3 -> 28
2*2+3*3+1 -> 28
1+2*3*3+2 -> 31
1+2*2+3*3 -> 23
1+2*2+3*3 -> 23
1*3+2*2+3 -> 13
1*3+3+2*2 -> 10
1*3+2*2+3 -> 13
3*2+1*3+2 -> 21
3*1+2*2+3 -> 33
3+2*2+1*3 -> 13
3+3*1+2*2 -> 18
2*2+1*3+3 -> 16
2+3*2+1*3 -> 17
3+2*3*1+2 -> 21
2*3+3*1+2 -> 24
3*2+3*1+2 -> 33
1*3+2*3+2 -> 13
2+3*1+3*2 -> 23
3*1+3+2*2 -> 24
3+1*3+2*2 -> 10
1+3*3+2*2 -> 22
2+3*3*2+1 -> 29
3*3+2*2+1 -> 27
3*3+2*2+1 -> 27
3+2*2+3*1 -> 13
2*2+3+3*1 -> 16
3+2*2+3*1 -> 13
2+3*1+2*3 -> 23
3+2*2+1*3 -> 13
3*1+2*2+3 -> 33
2*2+1*3+3 -> 16
3+3*1+2*2 -> 18
3*1+2*3+2 -> 33

> <>, 36 *

Nếu bạn đủ may mắn!

x;x
lxl
xnx

Vì thách thức không yêu cầu mã phải có tính xác định, chúng tôi chỉ phải chứng minh rằng có thể (ngay cả khi không thể thực hiện được) để trả về 36 số và chúng tôi đã hoàn tất. Nó là tốt trong khi nó kéo dài tôi đoán.

(Đối với những người không quen thuộc với> <>, một phần giới thiệu tuyệt vời có thể được tìm thấy ở đây )

> <> là ngôn ngữ 2D dựa trên ngăn xếp. Điều này có nghĩa là các lệnh không được thực thi tuyến tính như hầu hết các ngôn ngữ truyền thống - luồng chương trình có thể lên, xuống, trái hoặc phải!

Tôi quyết định sử dụng lệnh "x" trong> <>, thay đổi hướng con trỏ lệnh thành hướng lên, xuống, trái hoặc phải một cách ngẫu nhiên. Vì mã của chúng tôi sẽ chỉ là một dòng, điều đó có nghĩa là chúng tôi chỉ có thể xem xét các trường hợp khi nó đi sang phải hoặc trái, vì nếu con trỏ đi lên hoặc xuống, nó sẽ lại nhấn vào lệnh "x".

Lệnh "n" bật số ở đầu ngăn xếp và in nó. Tuy nhiên, nếu ngăn xếp trống và không có gì để bật, một lỗi sẽ xuất hiện.

Lệnh "l" chỉ đơn giản là đẩy chiều dài của ngăn xếp lên ngăn xếp (và may mắn cho chúng tôi là nó không gửi lỗi nếu ngăn xếp trống), vì vậy, ví dụ nếu ngăn xếp trống và "l" sẽ được gọi, nó sẽ được gọi sẽ đẩy 0 lên ngăn xếp. Nếu bây giờ chúng ta lại gọi "l", thì vì ngăn xếp có một phần tử (0), nó sẽ đẩy 1 lên trên cùng của ngăn xếp và điều đó có nghĩa là sẽ có hai thứ trên ngăn xếp và điều đó có nghĩa là nếu chúng ta gọi lại "l", chúng ta sẽ đẩy 2 lên ngăn xếp, v.v. Vì vậy, chúng ta có thể sử dụng "l" để đẩy một số tùy ý lên ngăn xếp thông qua phương thức được hiển thị trước đó.

Các ";" hướng dẫn kết thúc chương trình.

Ý tưởng với việc sử dụng "x" là, ví dụ nếu chỉ có một "x" trong mã (trong đó A, B, C, D là một số hướng dẫn):

ABCx;D

Chương trình sẽ thực thi A rồi B ​​rồi C và khi đạt đến "x", chúng ta sẽ có hai khả năng: mã tiếp tục đi đúng và chạm vào ";" và thoát hoặc nó đi bên trái và thực hiện C rồi B ​​rồi A rồi D và chỉ sau đó thoát. Vì vậy, nếu mã của chúng tôi chứa một "x", chương trình sẽ nhận được hai luồng chương trình có thể từ đó chúng tôi có thể chọn chương trình phù hợp nhất.

Tôi có hai hoặc nhiều "x" es sau đó chúng ta thu được vô số luồng chương trình có thể.

Mã của chúng tôi có năm "x" es, hơn nữa mỗi trong số chúng nằm trong một "ô bắt đầu" của các đường dẫn Hamilton, có nghĩa là mọi chương trình sẽ bắt đầu bằng "x" và mọi chương trình sẽ có cấu trúc:

xAxBxCxDx

Trong đó A, B, C, D thuộc về {; , n, l, l} Điều này có nghĩa là chỉ có 12 chương trình duy nhất. Hơn nữa, vì chúng tôi luôn bắt đầu bằng "x", chúng tôi có thể xem xét trường hợp khi chương trình đi bên trái, do đó các chương trình đối xứng cũng có thể được coi là như nhau. Tính đối xứng chỉ có 6 chương trình rõ ràng khác nhau. Chỉ có 4 trong số chúng xảy ra trong các chương trình được tạo theo đường dẫn hamiltonian:

xnxlxlx;x
xlxnxlx;x
xnxlx;xlx
xlxnx;xlx

Chúng ta hãy xem chương trình đầu tiên "xnxlxlx; x" nếu chúng ta đi đúng ở bước đầu tiên, chúng ta nhấn lệnh in sẽ gây ra lỗi vì chúng ta không có gì trên ngăn xếp. Nếu chúng ta đi bên trái, chúng ta nhấn lệnh kết thúc chương trình. Vì vậy, chúng tôi không thể xuất bất kỳ số nào từ các chương trình này.

Chương trình thứ hai, "xlxnxlx; x", có nhiều hy vọng hơn, vì khi đi đúng vào lúc bắt đầu, số 0 được đặt vào ngăn xếp, nếu sau đó chúng ta rẽ trái vào "x" tiếp theo, ngăn xếp của chúng ta sẽ đạt được một, sau đó đi đúng một lần nữa chúng ta có 2 cái mà sau đó chúng ta có thể in và tiếp tục đi ngay để kết thúc chương trình. Chúng ta có thể quan sát rằng chúng ta thực sự có thể in bất kỳ số chẵn nào , vì trong phần "xlx" lúc đầu, chúng ta có thể đạt đến một số kích thước tùy ý bằng cách đi sang phải rồi sang trái sau đó lại một số lần nhất định.

Một cách tương tự có thể thấy rằng chương trình thứ ba xnxlx; xlx có thể xuất bất kỳ số lẻ nào , bằng cách rẽ trái ở đầu và sau đó lặp lại thói quen "xlx" chỉ lần này sang trái rồi phải sang trái.

Và chương trình thứ tư về cơ bản giống như chương trình thứ hai và có thể xuất bất kỳ số chẵn nào .

Vì vậy, đối với các chương trình cần thiết, chúng tôi có:

x;xlxlxnx (none)
x;xlxnxlx (any even number)
x;xlxnxlx (any even number)
x;xlxnxlx (any even number)
xlx;xlxnx (any odd number)
xlxnx;xlx (any even number)
xlxnxlx;x (any even number)
xlxnxlx;x (any even number)
x;xlxlxnx (none)
x;xlxnxlx (any even number)
x;xlxnxlx (any even number)
xlx;xlxnx (any odd number)
xlxnx;xlx (any even number)
xlxnxlx;x (any even number)
xlx;xlxnx (any odd number)
xlx;xlxnx (any odd number)
xnxlx;xlx (any odd number)
xnxlx;xlx (any odd number)
xlx;xlxnx (any odd number)
xnxlx;xlx (any odd number)
xnxlxlx;x (none)
xlxnxlx;x (any even number)
xlxnxlx;x (any even number)
xlxnxlx;x (any even number)
xnxlx;xlx (any odd number)
xlx;xnxlx (any even number)
x;xlxnxlx (any even number)
x;xlxnxlx (any even number)
xnxlxlx;x (none)
xlxnxlx;x (any even number)
xlxnxlx;x (any even number)
xnxlx;xlx (any odd number)
xlx;xnxlx (any even number)
x;xlxnxlx (any even number)
xnxlx;xlx (any odd number)
xnxlx;xlx (any odd number)
xlx;xlxnx (any odd number)
xlx;xlxnx (any odd number)
xnxlx;xlx (any odd number)
xlx;xlxnx (any odd number)

Đó là 4 chương trình không thể xuất số, 20 có thể xuất bất kỳ số chẵn nào, 16 có thể xuất bất kỳ số lẻ nào. Vì có chính xác 20 số chẵn và ít nhất 16 số lẻ trong phạm vi từ 1 đến 40, nên với một xác suất nhất định có khả năng sẽ có 36 số khác nhau trong phạm vi 1 đến 40 của khối mã này.

GolfScript, 8

192
6#7
281

Hiện tại giải pháp cho điểm cao nhất. : P Đã tốt đẹp trong khi nó kéo dài.

Chương trình

1927#6281 1927
192718#62 192718
19271826# 19271826
19#628172 19
16#927182 16
1628#9271 1628
16281729# 16281729
162817#92 162817
2916#7182 2916
291628#71 291628
29162817# 29162817
27#916281 27
2718#9162 2718
27182619# 27182619
#61927182 
#72916281 
#82619271 
#81729162 
261927#81 261927
28#619271 28
1826#7291 1826
26#817291 26
#62817291 
271826#91 271826
281729#61 281729
1729#8261 1729
#92718261 
29#718261 29
2817#6192 2817
17#826192 17
#71826192 
182619#72 182619
2619#8172 2619
#91628172 
28172916# 28172916
18261927# 18261927
17291628# 17291628
26192718# 26192718
18#729162 18
172916#82 172916

CJam, 14

3(4
;];
0)1

Bên dưới các chương trình làm việc:

3(4;];0)1 = 11
3(4;1)0;] = 22
3(];0)1;4 = 14
3;0)](4;1 = 11
3;0)1;4(] = 13
3;0)1;](4 = 14
4(3;];1)0 = 20
4(3;0)];1 = 1
4(3;0)1;] = 31
4;1)](3;0 = 20
4;1)0;3(] = 22
0;3(4;])1 = 21
0)];3(4;1 = 21
1)0;];4(3 = 33
4;1)0;](3 = 23
0)1;4(];3 = 3
1;4(])0;3 = 33
4(];1)0;3 = 23
0)1;];3(4 = 24
1)0;3(];4 = 4
0;3(])1;4 = 24
0)1;4(3;] = 13
1)0;3(4;] = 22
1;4(3;0)] = 31
0;3(4;1)] = 22
1)];4(3;0 = 30
1;4(3;])0 = 30

Các giá trị được tạo là: [1, 3, 4, 11, 13, 14, 20, 21, 22, 23, 24, 30, 31, 33]

đc (20)

2+3
*p+
4+5

ABCFEDGHI -> 2+3+p*4+5 -> 5     $ **
ABCFIHEDG -> 2+3+5+p*4 -> 10    $ **
ABCFIHGDE -> 2+3+5+4*p -> 40    $ **
ABEDGHIFC -> 2+p*4+5+3 -> 2     $ **
ADEBCFIHG -> 2*p+3+5+4 -> 2       **
ADGHEBCFI -> 2*4+p+3+5 -> 6     $ **
ADGHIFCBE -> 2*4+5+3+p -> 14    $ **
ADGHIFEBC -> 2*4+5+p+3 -> 11    $ **
CBADEFIHG -> 3+2*p+5+4 -> 6       **
CBADGHEFI -> 3+2*4+p+5 -> 10      **
CBADGHIFE -> 3+2*4+5+p -> 15    $ **
CFEBADGHI -> 3+p+2*4+5 -> 3     $ **
CFIHEBADG -> 3+5+p+2*4 -> 8     $ **
CFIHGDABE -> 3+5+4*2+p -> 34    $ **
EDABCFIHG -> p*2+3+5+4 -> 
EFCBADGHI -> p+3+2*4+5 -> 
EHGDABCFI -> p+4*2+3+5 -> 
EHIFCBADG -> p+5+3+2*4 -> 
GDABCFEHI -> 4*2+3+p+5 -> 9     $ **
GHEDABCFI -> 4+p*2+3+5 -> 4     $ **
IHGDEFCBA -> 5+4*p+3+2 -> 20    $ **
GDEHIFCBA -> 4*p+5+3+2 -> 4       **
EDGHIFCBA -> p*4+5+3+2 -> 
CFIHGDEBA -> 3+5+4*p+2 -> 32    $ **
GHIFCBEDA -> 4+5+3+p*2 -> 12    $ **
IFCBEHGDA -> 5+3+p+4*2 -> 8       **
EBCFIHGDA -> p+3+5+4*2 -> 
CBEFIHGDA -> 3+p+5+4*2 -> 3       **
GHIFEDABC -> 4+5+p*2+3 -> 9       **
IFEHGDABC -> 5+p+4*2+3 -> 5       **
EFIHGDABC -> p+5+4*2+3 -> 
IHGDABEFC -> 5+4*2+p+3 -> 22    $ **
GDABEHIFC -> 4*2+p+5+3 -> 6       **
EBADGHIFC -> p+2*4+5+3 -> 
GHIFCBADE -> 4+5+3+2*p -> 24    $ **
IHGDABCFE -> 5+4*2+3+p -> 25    $ **
IFCBADGHE -> 5+3+2*4+p -> 20      **
GDABCFIHE -> 4*2+3+5+p -> 14      **
IHEFCBADG -> 5+p+3+2*4 -> 5       **
IFCBADEHG -> 5+3+2*p+4 -> 16    $ **

32 đầu ra, 20 trong số đó khác biệt (được đánh dấu bằng a $)

2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 14, 15, 16, 20, 22, 24, 25, 32, 34, 40