Es gibt 40 Möglichkeiten, wie ein gerichteter Hamilton-Pfad in einem 3 × 3-Raster angeordnet werden kann:

Diese Grafik ( danke Sp3000! ) Zeigt nur die 20 ungerichteten Pfade. Überquere jede farbige Linie in beide Richtungen für die 40 gerichteten Pfade.

Herausforderung

Schreiben Sie unter Verwendung von ausschließlich druckbarem ASCII ein 3 × 3-Zeichenraster, z.

ABC
DEF
GHI

Wenn jeder der 40 gerichteten Pfade als 40 einzeilige Programme mit 9 Zeichen aus diesem Raster gelesen wird, ist es das Ziel, dass jedes Programm eine eindeutige Ganzzahl von 1 bis 40 ausgibt. Dies für alle 40 Pfade zu tun, erscheint schwierig und unwahrscheinlich. Sie müssen es also nur für so viele Pfade wie möglich zum Laufen bringen.

Die Einsendung, deren 40 Pfadprogramme die deutlichsten Zahlen von 1 bis 40 ausgeben, wird der Gewinner sein. Tiebreaker geht auf die frühere Vorlage.

Pfadprogramme, bei denen ein Fehler auftritt oder die keine Ganzzahl von 1 bis 40 ausgeben, oder die eine Ganzzahl ausgeben, die bereits von einem anderen Pfadprogramm behandelt wurde, werden nicht gezählt. Speziell:

• Programme, die beim Kompilieren, Ausführen oder Beenden fehlerhaft sind, werden nicht gezählt. Warnungen sind in Ordnung.
• Programme, die keine Ganzzahl von 1 bis 40 ausgeben oder etwas leicht Missgebildetes ausgeben, wie z. B. -35oder, 35 36werden nicht gezählt.
• Programme, für deren Ausgabe Benutzereingaben erforderlich sind, werden nicht gezählt.
• Programme, die niemals enden, werden nicht gezählt.
• Von nun an werden Programme, die nicht deterministisch sind, nicht mehr gezählt.
• Andernfalls werden gültige Programme, die eine Ganzzahl von 1 bis 40 ausgeben, die bereits von einem anderen gültigen Programm ausgegeben wurden, nicht gezählt. (Das erste Programm wird gezählt.)
• Nur Programme, die ganzzahlige Darstellungen von Zahlen von 1 bis 40 (einschließlich) ausgeben, werden auf Ihre Gesamtsumme angerechnet. Die Zahlen werden voraussichtlich in der üblichen sein 1, 2, ..., 39, 40Form, sofern dies nicht die Norm für Ihre Sprache ist. (Eine nachgestellte Zeile in der Ausgabe ist in Ordnung.)
• Welche Zahlen Ihre Programme ausgeben und in welcher Reihenfolge sie sich befinden, spielt keine Rolle. Nur die Anzahl der verschiedenen Ganzzahlen aus gültigen Programmen ist von Bedeutung.

Alle Pfadprogramme müssen in derselben Sprache ausgeführt werden. Die "Programme" können jedoch Funktionen (ohne erforderliche Argumente) oder REPL- Befehle sowie vollständige Programme sein, die ihre Ziel-Ganzzahl ausgeben oder zurückgeben. Sie können Funktionen, REPL-Befehle und vollständige Programme mischen und abgleichen.

Ihre 9 druckbaren ASCII-Zeichen müssen nicht eindeutig sein.

Beispiel

Wenn dein 3 × 3 Raster wäre

ABC
DEF
GHI

und Ihre 40 Programme und Ausgaben sahen so aus

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"

Ihre Punktzahl wäre 14, da es 14 verschiedene Ganzzahlen von 1 bis 40 gibt, die gültig ausgegeben werden, nämlich 26 2 6 3 4 33 8 22 11 30 39 7 29 1.

PARI / GP - 24

1%1
 8
2+3

PARI / GP ignoriert Leerzeichen zwischen Ziffern, so dass 1 8 2beispielsweise als behandelt wird 182. Dasselbe könnte für Perl funktionieren, indem die Leerzeichen durch Unterstriche ersetzt werden. Ich habe nicht den gesamten Suchraum ausgeschöpft, daher gibt es möglicherweise bessere Kandidaten.

Ein Programm kann als gp gp -q -f program.gpoder interaktiv in der Repl eingegeben werden.

Ausgabe

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

Alle bis auf 4 Werte liegen innerhalb des erforderlichen Bereichs mit 12 doppelten Einträgen.

Aktualisieren

Ich bin mit dem Knirschen fertig, es gibt sechs verschiedene 23er und nur eine 24er (wie von Zeilen gelesen):

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]

Das Programm, das ich für das Knirschen verwendete, ist unten. PARI / GP verfügt nur über eingeschränkte Funktionen zur Verarbeitung von Zeichenfolgen. Behandeln Sie daher hauptsächlich Char-Arrays (auch bekannt als Vecsmall). Die Betreiber getestet sind +, -, *, \(Boden div) %, ;(Ausdruck Separator, im Wesentlichen verwirft alles , bevor es), und (Raum, wie oben beschrieben). Der Exponentenoperator ^könnte ebenfalls hinzugefügt werden, wird jedoch zu langsam, um ausführlich getestet zu werden.

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

Toter Fisch , 18

Dies war tatsächlich die erste Sprache, die ich ausprobierte, bevor ich über Infix-Operatoren nachdachte. Ich poste es jetzt wegen der schieren Komik der Idee, dass Deadfish für etwas nützlich sein könnte.

iii
ios
sii

Für diejenigen, die Deadfish nicht kennen, iist Inkrement, sist Quadrat und owird ausgegeben, wobei der Akkumulator bei 0 beginnt (es gibt auch eine vierte Anweisung dzur Dekrementierung, die hier nicht verwendet wird). Die Tatsache, dass wir kein automatisches Drucken haben und verwenden müssen, oist ein großer Nachteil, aber überraschenderweise macht Deadfish diesbezüglich nicht allzu schrecklich. Es stellt sich heraus, dass die optimale Platzierung des Ausgabeoperators in der Mitte liegt.

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 und viele mehr, 22 23

6+7
*5%
6%4

Wichtigste Beobachtung: Wenn Sie das Raster wie ein Schachbrettmuster einfärben, wechselt der Pfad zwischen den Rasterfarben und beginnt und endet mit derselben Farbe.

Immer noch brachial zum Besseren zwingen. Das Ausprobieren +*%(und auch **bei Sprachen, bei denen ^es um Potenzierung geht) ist leider nicht besser gelaufen. Ich habe auch versucht, bitweise Operatoren einzuwerfen, und nur ^(xor) schien ein wenig zu helfen, aber die Suche dauerte zu lange, sodass ich aufgegeben habe.

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

Dies gibt nur gültige Zahlen aus, aber viele sind Duplikate. Die eindeutigen Werte sind 17 11 16 28 31 23 13 10 21 33 18 24 22 29 27. Sie können definitiv bessere Ergebnisse erzielen, indem Sie die Operatoren und die beteiligten ganzen Zahlen ändern.

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 *

Wenn du Glück hast!

x;x
lxl
xnx

Da für die Abfrage kein deterministischer Code erforderlich ist, müssen wir nur beweisen, dass es möglich (auch wenn unwahrscheinlich) ist, 36 Zahlen zurückzugeben, und wir sind fertig. Es war gut, solange es dauerte, denke ich.

(Für diejenigen, die nicht mit> <> vertraut sind, finden Sie hier eine großartige Einführung. )

> <> ist eine stapelbasierte 2D-Sprache. Dies bedeutet, dass Anweisungen nicht wie bei den meisten herkömmlichen Sprachen linear ausgeführt werden - der Programmfluss kann nach oben, unten, links oder rechts erfolgen!

Ich habe mich für die Anweisung "x" in> <> entschieden, die die Richtung der Anweisungszeiger nach dem Zufallsprinzip nach oben, unten, links oder rechts ändert. Da unser Code nur aus einer Zeile besteht, können wir die Fälle nur betrachten, wenn sie nach rechts oder links gehen. Wenn der Zeiger nach oben oder unten geht, wird nur die Anweisung "x" erneut getroffen.

Die Anweisung "n" fügt die Nummer oben im Stapel ein und druckt sie aus. Wenn der Stapel jedoch leer ist und nichts zu öffnen ist, wird ein Fehler ausgegeben.

Die "l" -Anweisung schiebt einfach die Länge des Stapels auf den Stapel (und glücklicherweise sendet sie keinen Fehler, wenn der Stapel leer ist), also zum Beispiel, wenn der Stapel leer wäre und "l" aufgerufen würde würde 0 auf den Stapel schieben. Wenn wir jetzt wieder "l" aufrufen würden, würde der Stapel, da er ein Element (0) hat, 1 an die Spitze des Stapels schieben, und dies würde bedeuten, dass sich zwei Dinge auf dem Stapel befinden würden, und das würde bedeuten, dass Wenn wir noch einmal "l" rufen würden, würden wir 2 auf den Stapel schieben usw. Wir können also "l" verwenden, um eine beliebige Zahl auf den Stapel zu schieben, wie oben gezeigt.

Das ";" Anweisung beendet das Programm.

Die Idee bei der Verwendung von "x" ist, dass beispielsweise nur ein "x" im Code vorhanden ist (wobei A, B, C, D Anweisungen sind):

ABCx;D

Das Programm würde A, dann B, dann C ausführen, und bei Erreichen von "x" hätten wir zwei Möglichkeiten: Der Code geht entweder weiter nach rechts und drückt das ";" und verlässt oder es geht nach links und führt C, dann B, dann A, dann D aus und verlässt erst dann. Wenn unser Code also ein "x" enthält, erhält das Programm zwei mögliche Programmabläufe, aus denen wir das am besten geeignete Programm auswählen können.

Wenn es zwei oder mehr "x" gibt, erhalten wir unendlich viele mögliche Programmabläufe.

Unser Code hat fünf "x", außerdem befindet sich jedes von ihnen in einer "Startzelle" der Hamilton-Pfade, was bedeutet, dass jedes einzelne Programm mit einem "x" beginnt und jedes Programm die folgende Struktur hat:

xAxBxCxDx

Wobei A, B, C, D zu {gehören; , n, l, l} Dies bedeutet, dass es nur 12 eindeutige Programme gibt. Da wir außerdem immer mit einem "x" beginnen, können wir uns den Fall ansehen, wenn das Programm nach links geht, sodass symmetrische Programme auch als gleich angesehen werden können. Bis zur Symmetrie gibt es nur 6 verschiedene mögliche Programme. Nur 4 davon kommen in den Programmen vor, die als Hamilton-Pfade generiert wurden:

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

Schauen wir uns das erste Programm "xnxlxlx; x" an. Wenn wir beim ersten Schritt nach rechts gehen, drücken wir den Druckbefehl, der einen Fehler auslöst, da wir nichts auf dem Stapel haben. Wenn wir nach links gehen, drücken wir den Befehl zum Beenden des Programms. Daher können wir von diesen Programmen keine Zahlen ausgeben .

Das zweite Programm, "xlxnxlx; x", ist viel hoffnungsvoller, da beim Beginnen eine Null auf den Stapel gelegt wird. Wenn wir dann beim nächsten "x" nach links gehen, erhält unser Stapel eine Eins Wenn wir wieder nach rechts gehen, haben wir eine 2, die wir dann drucken können und die wir fortsetzen können, um das Programm zu beenden. Wir können beobachten, dass wir tatsächlich jede gerade Zahl drucken können , da wir im "xlx" -Teil am Anfang eine Anzahl von willkürlichen Größen erreichen können, indem wir eine bestimmte Anzahl von Malen nach rechts, nach links und wieder nach rechts gehen.

Ähnlich ist zu sehen, dass das dritte Programm xnxlx; xlx eine beliebige ungerade Zahl ausgeben kann , indem es am Anfang nach links geht und dann die Routine "xlx" nur dieses Mal nach links, dann nach rechts und dann nach links wiederholt.

Und das vierte Programm ist im Wesentlichen dasselbe wie das zweite Programm und kann eine beliebige gerade Zahl ausgeben .

Für die benötigten Programme haben wir also:

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)

Das sind 4 Programme, die keine Zahlen ausgeben können, 20, die eine gerade Zahl ausgeben können, 16, die eine ungerade Zahl ausgeben können. Da es genau 20 gerade Zahlen und mindestens 16 ungerade Zahlen im Bereich von 1 bis 40 gibt, besteht mit einer bestimmten Wahrscheinlichkeit die Möglichkeit, dass von diesem Codeblock 36 verschiedene Zahlen im Bereich von 1 bis 40 ausgegeben werden.

GolfScript, 8

192
6#7
281

Derzeit die Lösung mit der höchsten Punktzahl. : P War schön, solange es dauerte.

Programme

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

Nachfolgend die Arbeitsprogramme:

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

Die generierten Werte sind: [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 Ausgänge, davon 20 unterschiedliche (mit einem gekennzeichnet $)

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