Yönlendirilmiş bir Hamilton yolu 3 × 3 ızgarada düzenlenebilir 40 yol vardır : Bu grafik ( Sp3000 sayesinde ) sadece 20 yönlendirilmemiş yolu gösterir. Her bir renkli çizgiyi, 40 yönlendirilmiş yol için her iki yönde hareket ettirin.

Meydan okuma

Yalnızca yazdırılabilir ASCII kullanarak , 3 × 3 karakter ızgarasını yazın, örneğin:

ABC
DEF
GHI

40 yönlendirilmiş yolların her biri 40 tek hat, 9-karakter programları gibi bu ızgaradan okunduğunda amaç için bu Doing 40'a 1'den benzersiz tamsayı her program çıkışına sahip olmaktır tüm 40 yolları zor ve zor görünüyor, bu yüzden sadece olabildiğince çok yol için çalışmasını sağlamalısın.

40 yol programı 1 - 40 arasında en belirgin rakamları veren gönderim kazanacaktır. Tiebreaker daha önceki bildirime gidiyor.

Hata yapan veya 1 ile 40 arasında bir tam sayı çıkarmayan ya da daha önce kapsanan başka bir yol programının sayılmadığı bir tamsayı veren yol programları. özellikle:

• Derleme, çalıştırma veya çıkış sırasında hata yapan programlar sayılmaz. Uyarılar tamam.
• 1 ile 40 arasında bir tam sayı çıkarmayan -35veya 35 36sayıları gibi az hatalı biçimlendirilmiş bir şey çıkaran programlar .
• Çıktıyı üretmek için kullanıcı girişi gerektiren programlar sayılmaz.
• Hiç bitmeyen programlar sayılmaz.
• Bundan sonra , deterministik olmayan programlar sayılmaz.
• Aksi halde, 1'den 40'a kadar bir tamsayı çıkaran geçerli programlar, başka bir geçerli programın zaten çıktı verdiğini saymaz. (İlk program olan sayılır.)
• Yalnızca 1'den 40'a kadar olan sayıların tam sayı gösterimini veren programlar toplamınız için sayılır. Sayılar olağan olması bekleniyor 1, 2, ..., 39, 40o diliniz için norm olmadıkça biçimi. (Çıktıdaki takip eden yeni satır iyi.)
• Programlarınızın hangi sayıların çıktılarını ve hangi sırayla olduklarının önemi yoktur. Yalnızca geçerli programlardan gelen farklı tam sayıların sayısı önemlidir.

Tüm yol programları aynı dilde çalıştırılmalıdır. Bununla birlikte, "programlar" aslında hedefleri tamsayılarını basan ya da döndüren tam programların yanı sıra fonksiyonlar (gerekli argümanlar olmadan) veya REPL komutları olabilir. İşlevler, REPL komutları ve tüm programlar arasında karıştırabilir ve eşleştirebilirsiniz.

Yazdırılabilir 9 ASCII karakterinizin farklı olması gerekmez.

Örnek

Senin 3 × 3 ızgara olsaydı

ABC
DEF
GHI

40 programın ve çıktıların buna benziyordu.

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"

puanın 14 olacaktı, çünkü 1'den 40'a kadar geçerli 14 çıktı var 26 2 6 3 4 33 8 22 11 30 39 7 29 1.

PARI / GP - 24

1%1
 8
2+3

PARI / GP, rakamlar arasındaki boşlukları yok sayar, böylece 1 8 2örneğin olarak kabul edilir 182. Aynı boşlukları alt çizgi ile değiştirerek perl için işe yarayabilir. Tüm arama alanını tüketmedim, bu yüzden daha iyi adaylar olabilir.

Bir program repe olarak gp -q -f program.gpveya etkileşimli olarak gp'ye beslenebilir .

Çıktı

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

4 değer hariç tümü, 12 yinelenen giriş ile istenen aralık içindedir.

Güncelleme

Çatırdatmayı bitirdim, altı ayrı 23 ve sadece bir 24 var (satırların okuduğu gibi):

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]

Çatırdamak için kullandığım program aşağıda. PARI / GP dizge işlem yeteneklerinin sınırlı olmasına sahiptir, bu nedenle özellikle char dizileri (aka Vecsmall) ile ilgilenin . Test edilen operatörleri +, -, *, \(zemin div) %, ;(ifade ayırıcı, esas olarak atar daha önce her şeyi) ve (yukarıda tarif edildiği gibi alanı). Üs operatörü ^de eklenebilir, ancak ayrıntılı olarak test etmek için çok yavaş olur.

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

Ölü balık , 18

Bu aslında infix operatörleri olarak düşünmeden önce denediğim ilk dildi. Şimdi Deadfish'in bir şey için faydalı olabileceği fikrinin gerçekliği için gönderiyorum.

iii
ios
sii

Deadfish'i bilmeyenler için, iartış, skare ve sonuçtur, oakümülatör 0'dan başlar ( dburada kullanılmayan dördüncü bir talimat da vardır ). Otomatik baskıya sahip olmamak ve kullanmak zorunda olmamız gerçeği obüyük bir dezavantajdır, ancak şaşırtıcı bir şekilde Deadfish burada çok fazla şey yapmaz, her şeyi göz önünde bulundurur. Çıkış operatörünün en uygun yerleşiminin ortada olduğu ortaya çıktı.

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 ve daha fazlası, 22 23

6+7
*5%
6%4

Anahtar gözlem: Izgarayı bir dama tahtası gibi renklendirirseniz, yol ızgara renkleri ile gider ve aynı renkte başlar ve biter.

Hala daha iyi için zorla kaba. Denemek +*%(ve üstelliğin bile **olduğu diller için bile ^) maalesef daha iyi bir şey bulamadı. Ayrıca bitsel operatörleri atmaya çalıştım ve sadece ^(xor) hafifçe yardım ediyor gibiydi, ancak arama çok uzun sürüyordu, ben de pes ettim.

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

Bu, yalnızca geçerli sayıları çıkarır, ancak çoğu yinelenir. Eşsiz değerler 17 11 16 28 31 23 13 10 21 33 18 24 22 29 27. Operatörleri ve ilgili tamsayıları değiştirerek kesinlikle daha iyisini yapabilirsiniz.

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 *

Eğer yeterince şanslıysan!

x;x
lxl
xnx

Buradaki zorluk kodun deterministik olmasını gerektirmediği için sadece 36 sayı döndürmenin mümkün olduğunu (mümkün olmasa bile) ispatlamamız gerekiyor ve bitti. Sanırım sürdü iyiydi.

(> <> Aşina olmayanlar için bulunabilir büyük bir intro burada )

> <> yığın tabanlı bir 2B dilidir. Bu, talimatların çoğu geleneksel dilde olduğu gibi doğrusal olarak yürütülmediği anlamına gelir; program akışı yukarı, aşağı, sola veya sağa olabilir!

Komut işaretçilerinin yönünü rastgele yukarı, aşağı, sola veya sağa değiştiren> <> komutunda "x" komutunu kullanmaya karar verdim. Kodumuz yalnızca bir satır olacağından, işaretçi yukarı veya aşağı giderse sadece "x" komutuna tekrar basacağından, sadece sağa veya sola gittiğinde durumlara bakabileceğimiz anlamına gelir.

"N" komutu yığının en üstündeki sayıyı açar ve yazdırır. Ancak yığın boşsa ve açılacak bir şey yoksa, bir hata ortaya çıkar.

"L" komutu, yığının uzunluğunu yığının üzerine doğru iter (ve yığın boşsa bizim için bir hata göndermez.), Örneğin, yığın boşsa ve "l" denirse, 0'ı yığının üzerine itecektir. Şimdi tekrar "l" diyeceksek, o zaman yığının bir elemanı (0) olduğundan, 1'in yığının tepesine itilmesi gerekirdi ve şimdi bu, yığında iki şey olduğu anlamına gelir ve bunun anlamı eğer tekrar "l" diyeceksek, yığına vs. 2 basardık. Böylece daha önce gösterilen yöntemle yığına rasgele bir sayı itmek için "l" yi kullanabiliriz.

";" talimat programı sonlandırır.

"X" kullanma fikri, örneğin kodda yalnızca bir "x" varsa (A, B, C, D bazı talimatlardır):

ABCx;D

Program A'dan B'ye sonra C'yi uygular ve "x" e ulaştığımızda iki olasılık olur: kod ya doğru devam eder ve ";" ve çıkar veya sola gider ve C sonra B sonra A sonra D sonra sadece sonra çıkar. Eğer kodumuz bir "x" içeriyorsa, program en uygun programı seçebileceğimiz iki olası program akışı kazanır.

Ben iki veya daha fazla "x" var, o zaman sonsuz sayıda program akışı elde ediyoruz.

Kodumuzda beş "x" es vardır, bunlardan her biri Hamilton yollarının bir "başlangıç ​​hücresinde "dir, yani her bir program" x "ile başlayacaktır ve her program bu yapıya sahip olacaktır:

xAxBxCxDx

Burada A, B, C, D {; , n, l, l} Bu, yalnızca 12 benzersiz program olduğu anlamına gelir. Ayrıca, her zaman "x" ile başladığımızdan, programın ne zaman kaldığı durumuna bakabiliriz, böylece simetrik programlar da aynı şekilde kabul edilebilir. Simetriye kadar sadece 6 farklı program var. Bunlardan sadece 4 tanesi hamilton yolu olarak oluşturulan programlarda ortaya çıkmaktadır:

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

İlk programa bakalım "xnxlxlx; x" ilk adımda gidersek yığında hiçbir şey olmadığından hataya neden olan print komutuna basarız. Sola gidersek, program son komutuna basarız. Bu yüzden bu programlardan herhangi bir sayı çıkaramıyoruz.

İkinci program, "xlxnxlx; x", çok daha umut vericidir, çünkü hemen başlangıçta sıfıra yığının üzerine koyulur, eğer bir sonraki "x" de sola gidersek, yığımız bir tane kazanır, sonra Yine devam edersek, yazdırabilir ve programı sonlandırmaya devam etmeye devam edebileceğimiz bir 2 var. Gerçekten de herhangi bir sayıyı basabileceğimizi görebiliyoruz , çünkü başlangıçtaki "xlx" bölümünde, sağa, sonra sola ve tekrar tekrar belirli bir sayıda sola giderek bir dizi rasgele boyuta ulaşabiliyoruz.

Benzer şekilde, üçüncü programın xnxlx; xlx'in başlangıçta sola gidip sonra "xlx" rutini sadece bu sefer sola sonra sağa sola tekrarlayarak herhangi bir tuhaf sayı çıkartabildiği görülebilir .

Ve dördüncü program esas olarak ikinci programla aynıdır ve herhangi bir çift sayı verebilir .

Yani gerekli programlar için elimizde:

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)

Bu sayıların çıktısını alabilen 4 programdır, 20 herhangi bir çift sayıyı çıkarabilir, 16 herhangi bir tek sayıyı çıkarabilir. Tam olarak 20 çift sayı ve 1 ila 40 aralığında en az 16 tek sayı olduğundan, belirli bir olasılıkla, bu kod bloğu tarafından 1 ila 40 aralığında 36 farklı sayı olması olasılığı vardır.

GolfScript, 8

192
6#7
281

Şu anda en yüksek puanlama çözümü. : P Sürdüğü zaman hoştu.

Programlar

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

Çalışma programlarının altında:

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

Üretilen değerler: [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    $ **

20 tanesi farklı (32 ile işaretlenmiş $)

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