Ada 40 cara jalur Hamiltonian terarah dapat diatur pada kisi 3 × 3:

Grafik ini ( terima kasih Sp3000! ) Hanya menampilkan 20 jalur yang tidak diarahkan. Lintasi setiap garis berwarna di kedua arah untuk 40 jalur yang diarahkan.

Tantangan

Hanya menggunakan ASCII yang dapat dicetak , tulis kisi-kisi karakter 3 × 3, seperti:

ABC
DEF
GHI

Ketika masing-masing dari 40 jalur diarahkan dibaca dari kisi ini sebagai 40 baris tunggal, program 9-karakter, tujuannya adalah agar setiap program menghasilkan bilangan bulat unik dari 1 hingga 40. Melakukan ini untuk semua 40 jalur tampaknya sulit dan tidak mungkin, jadi Anda hanya perlu membuatnya bekerja untuk jalur sebanyak mungkin.

Kiriman yang program jalur 40-nya menampilkan angka paling berbeda dari 1 hingga 40 akan menjadi pemenang. Tiebreaker pergi ke pengiriman sebelumnya.

Program jalur yang kesalahan atau tidak menghasilkan bilangan bulat dari 1 hingga 40 atau menghasilkan bilangan bulat yang sudah dicakup program jalur lain tidak dihitung. Secara khusus:

• Program yang kesalahan saat mengkompilasi, menjalankan, atau keluar tidak dihitung. Peringatan tidak apa-apa.
• Program yang tidak menghasilkan bilangan bulat dari 1 hingga 40 atau menghasilkan sesuatu yang sedikit cacat seperti -35atau 35 36tidak dihitung.
• Program yang membutuhkan input pengguna untuk menghasilkan output tidak dihitung.
• Program yang tidak pernah berakhir tidak dihitung.
• Mulai sekarang , program yang tidak deterministik tidak dihitung.
• Jika tidak, program-program yang valid yang menghasilkan bilangan bulat dari 1 hingga 40 yang tidak pernah dihitung oleh program lain yang valid. (Program pertama adalah dihitung.)
• Hanya program yang menampilkan representasi bilangan bulat dari 1 hingga 40 (inklusif) yang dihitung terhadap total Anda. Jumlahnya diperkirakan berada di biasa 1, 2, ..., 39, 40Format, kecuali yang tidak norma untuk bahasa Anda. (Baris baru yang tertinggal di output baik-baik saja.)
• Angka mana yang dihasilkan oleh program Anda dan urutannya tidak penting. Hanya jumlah bilangan bulat yang berbeda dari program yang valid yang penting.

Semua program jalur harus dijalankan dalam bahasa yang sama. Namun, "program" mungkin sebenarnya adalah fungsi (tanpa argumen yang diperlukan) atau perintah REPL , serta program lengkap, yang mencetak atau mengembalikan target integer mereka. Anda dapat mencampur dan mencocokkan antara fungsi, perintah REPL, dan program lengkap.

9 karakter ASCII Anda yang dapat dicetak tidak perlu berbeda.

Contoh

Jika kisi 3 × 3 Anda adalah

ABC
DEF
GHI

dan 40 program dan output Anda terlihat seperti ini

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"

skor Anda akan menjadi 14, karena ada 14 bilangan bulat yang berbeda dari 1 hingga 40 output yang valid, yaitu 26 2 6 3 4 33 8 22 11 30 39 7 29 1.

PARI / GP - 24

1%1
 8
2+3

PARI / GP mengabaikan spasi antar digit, sehingga 1 8 2, misalnya diperlakukan sebagai 182. Hal yang sama dapat bekerja untuk perl dengan mengganti spasi dengan garis bawah. Saya belum kehabisan seluruh ruang pencarian, jadi mungkin ada kandidat yang lebih baik.

Suatu program dapat diumpankan ke gp as gp -q -f program.gp, atau secara interaktif di repl.

Keluaran

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

Semua kecuali 4 nilai berada dalam rentang yang diperlukan, dengan 12 entri rangkap.

Memperbarui

Saya sudah selesai mengunyah, ada enam 23 berbeda, dan hanya satu 24 (seperti yang dibaca oleh baris):

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]

Program yang saya gunakan untuk menguraikan adalah di bawah ini. PARI / GP memiliki kemampuan pemrosesan string yang terbatas, jadi berurusanlah terutama dengan array char (alias Vecsmall). Operator diuji adalah +, -, *, \(lantai div), %, ;(ekspresi pemisah, pada dasarnya membuang segala sesuatu sebelum itu), dan (ruang, seperti dijelaskan di atas). Operator eksponen ^juga dapat ditambahkan, tetapi menjadi terlalu lambat untuk menguji secara mendalam.

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

Deadfish , 18

Ini sebenarnya bahasa pertama yang saya coba sebelum saya mempertimbangkan operator infiks. Saya mempostingnya sekarang untuk kegembiraan belaka dari gagasan bahwa Deadfish dapat berguna untuk sesuatu.

iii
ios
sii

Bagi mereka yang tidak tahu Deadfish, iadalah increment, sadalah square dan ooutput, dengan akumulator mulai dari 0 (ada juga instruksi ke-4 duntuk decrement yang tidak digunakan di sini). Fakta bahwa kami tidak memiliki pencetakan otomatis dan perlu digunakan oadalah kelemahan utama, tetapi yang mengejutkan Deadfish tidak terlalu banyak melakukan hal ini, semua hal dipertimbangkan. Ternyata penempatan optimal dari operator output di tengah.

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 dan banyak lagi, 22 23

6+7
*5%
6%4

Pengamatan kunci: Jika Anda mewarnai kisi-kisi seperti kotak-kotak, jalur akan berganti warna kisi saat berjalan dan dimulai dan berakhir pada warna yang sama.

Masih dengan kekerasan memaksa untuk lebih baik. Mencoba dengan +*%(dan bahkan **untuk bahasa di mana ^eksponensial) sayangnya tidak menghasilkan sesuatu yang lebih baik. Saya juga mencoba melempar operator bitwise dan hanya ^(xor) yang agak membantu, tetapi pencarian terlalu lama sehingga saya menyerah.

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

Ini hanya menghasilkan angka yang valid, tetapi banyak yang merupakan duplikat. Nilai uniknya adalah 17 11 16 28 31 23 13 10 21 33 18 24 22 29 27. Anda pasti dapat melakukan yang lebih baik dengan mengganti operator dan bilangan bulat yang terlibat.

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 *

Jika Anda cukup beruntung!

x;x
lxl
xnx

Karena tantangan tidak memerlukan kode untuk menjadi deterministik, kita hanya perlu membuktikan bahwa adalah mungkin (bahkan jika tidak mungkin) untuk mengembalikan 36 angka dan kita selesai. Kurasa bagus saat itu berlangsung.

(Bagi mereka yang tidak terbiasa dengan> <>, intro yang hebat dapat ditemukan di sini )

> <> adalah bahasa 2D berbasis stack. Ini berarti bahwa instruksi tidak dijalankan secara linear seperti kebanyakan bahasa tradisional - aliran program dapat naik, turun, kiri atau kanan!

Saya memutuskan untuk menggunakan instruksi "x" di> <>, yang mengubah arah petunjuk petunjuk ke atas, bawah, kiri atau kanan secara acak. Karena kode kita hanya akan menjadi satu baris, itu berarti bahwa kita hanya dapat melihat kasing-kasing ketika ia bergerak ke kanan atau ke kiri, karena jika penunjuknya naik atau turun, itu hanya akan mengenai instruksi "x" lagi.

Instruksi "n" mengeluarkan nomor di bagian atas tumpukan dan mencetaknya. Namun jika tumpukan kosong dan tidak ada yang muncul, kesalahan muncul.

Instruksi "l" hanya mendorong panjang tumpukan ke tumpukan (dan beruntung bagi kita itu tidak mengirim kesalahan jika tumpukan kosong), jadi misalnya jika tumpukan kosong dan "l" akan dipanggil, itu akan mendorong 0 ke tumpukan. Jika sekarang kita akan memanggil lagi "l", maka karena stack memiliki satu elemen (0), itu akan mendorong 1 ke atas stack dan sekarang itu berarti bahwa akan ada dua hal di stack dan itu berarti bahwa jika kita memanggil "l" lagi, kita akan mendorong 2 ke stack dll. Jadi kita bisa menggunakan "l" untuk mendorong nomor sewenang-wenang ke stack melalui metode yang ditunjukkan sebelumnya.

";" instruksi mengakhiri program.

Gagasan dengan menggunakan "x" adalah bahwa, misalnya jika hanya ada satu "x" dalam kode (di mana A, B, C, D adalah beberapa instruksi):

ABCx;D

Program akan menjalankan A lalu B lalu C, dan setelah mencapai "x" kita akan memiliki dua kemungkinan: kode terus berjalan ke kanan dan tekan ";" dan keluar atau ke kiri dan mengeksekusi C lalu B lalu A lalu D dan hanya kemudian keluar. Jadi jika kode kita mengandung satu "x", program mendapatkan dua aliran program yang memungkinkan dari mana kita dapat memilih program yang paling cocok.

Saya ada dua atau lebih "x" maka kita mendapatkan jumlah tak terbatas dari kemungkinan aliran program.

Kode kita memiliki lima "x", lebih lanjut masing-masing dari mereka berada dalam "sel awal" dari jalur Hamilton, yang berarti setiap program tunggal akan dimulai dengan "x", dan setiap program akan memiliki struktur:

xAxBxCxDx

Di mana A, B, C, D milik {; , n, l, l} Ini berarti hanya ada 12 program unik. Lebih jauh lagi karena kita selalu memulai dengan "x", kita dapat melihat kasus ketika program berjalan ke kiri, sehingga program simetris juga dapat dianggap sama. Hingga simetri hanya ada 6 program yang berbeda. Hanya 4 dari mereka muncul dalam program yang dihasilkan sebagai jalur hamiltonian:

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

Mari kita lihat program pertama "xnxlxlx; x" jika kita langsung ke langkah pertama kita menekan perintah cetak yang akan menimbulkan kesalahan karena kita tidak memiliki apa-apa di stack. Jika kita ke kiri, kita tekan perintah program akhir. Jadi kami tidak dapat menampilkan nomor apa pun dari program ini.

Program kedua, "xlxnxlx; x", jauh lebih penuh harapan, karena setelah mulai dari awal, nol diletakkan di tumpukan, jika kita pergi ke kiri di "x" berikutnya, tumpukan kita naik satu, kemudian berjalan dengan benar lagi kami memiliki 2 yang kemudian dapat kami cetak dan teruskan untuk mengakhiri program. Kita dapat mengamati bahwa kita benar-benar dapat mencetak angka genap , karena pada bagian "xlx" di awal kita dapat mencapai sejumlah ukuran acak dengan pergi ke kanan lalu ke kiri lalu ke kanan lagi beberapa kali.

Serupa dengan itu dapat dilihat bahwa program ketiga xnxlx; xlx dapat menampilkan angka ganjil , dengan pergi ke kiri di awal dan kemudian mengulangi rutin "xlx" hanya kali ini ke kiri lalu ke kanan lalu ke kiri.

Dan program keempat pada dasarnya sama dengan program kedua dan dapat menampilkan angka genap .

Jadi untuk program yang diperlukan kami memiliki:

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)

Itu adalah 4 program yang tidak dapat menghasilkan angka, 20 yang dapat menghasilkan angka genap, 16 yang dapat menghasilkan angka ganjil. Karena ada persis 20 angka genap dan setidaknya 16 angka ganjil dalam kisaran 1 hingga 40, maka dengan probabilitas tertentu terdapat kemungkinan bahwa akan ada 36 angka berbeda dalam kisaran 1 hingga 40 yang dihasilkan oleh blok kode ini.

GolfScript, 8

192
6#7
281

Saat ini solusi skor tertinggi. : P Baik saat itu berlangsung.

Program

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

Di bawah program kerja:

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

Nilai yang dihasilkan adalah: [1, 3, 4, 11, 13, 14, 20, 21, 22, 23, 24, 30, 31, 33]

dc (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 output, 20 di antaranya berbeda (ditandai dengan a $)

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