40 Zahlen in 9 Bytes

40

Es gibt 40 Möglichkeiten, wie ein gerichteter Hamilton-Pfad in einem 3 × 3-Raster angeordnet werden kann:
alle 20 ungerichteten Hamilton-Pfade eines 3 & times3;  Gitter
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.

Calvins Hobbys
quelle
14
-1, Herausforderung enthält keinen Hinweis auf Flaggen
Alex A.
@ Sp3000 Ist die Anordnung im Bild in einer bestimmten Reihenfolge? (Ich nehme für die Herausforderung an, dass die Reihenfolge nicht wichtig ist, aber ich sterbe vor Neugier für das Bild. Insbesondere, wenn diese als Keime in einem L-System für eine Hilbert-Raumkurve verwendet wurden, gibt es eine natürliche Kodierung für die eingestellt?)
luser droog
@Luserdroog Nun, machte Sp das Bild , am besten, ihn zu fragen.
Calvins Hobbys
@luserdroog Wenn Sie die Zellen 1 bis 9 nummerieren, sollten sie in lexikografischer Reihenfolge 123654789
vorliegen
@luserdroog (Das heißt, wählen Sie den lexikografisch früheren Repräsentanten für jedes Paar gerichteter Pfade aus und sortieren Sie dann diese 20 Repräsentanten lexikografisch.)
mathmandan

Antworten:

27

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));
        )
       )
      )
     )
    )
   )
  )
 )
})
primo
quelle
Leider gibt ein Perl-Programm nicht seinen letzten Wert aus. Eine Perl-Subroutine tut es, aber eine Subroutine hat geschweifte Klammern. ( "Die Signatur ist Teil des Rumpfs einer Unterroutine. Normalerweise besteht der Rumpf einer Unterroutine nur aus einem geschweiften Codeblock." ) Ich halte das für nicht machbar in Perl.
msh210
29

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
Sp3000
quelle
25

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
Sp3000
quelle
5
Nächste Aufgabe: Schreiben Sie ein Programm, das das Programm mit den eindeutigsten Werten generiert. Dann golfen Sie dieses Programm. :)
Reto Koradi
@RetoKoradi Der erste Teil ist, was ich getan habe. Der zweite ... später: P
Sp3000 08.07.15
@ Sp3000 Ich habe das brachiale Forcen dieses Lösungsstils beendet. Es gibt 6+7*5%6%4, 6+7*4%6%5und 6+8*4%6%5( von links nach rechts, von oben nach unten), und sonst nichts.
isaacg
1
@isaacg es gibt mehr 23-Punkte-Lösungen, wenn Sie mehr Operatoren einwerfen, wie & | ^
Sparr
Nur ein zufälliger Gedanke: Haben Sie versucht, +und -in den Ecken / in der Mitte zuzulassen ? Da es sich sowohl um unäre als auch um binäre Operatoren handelt, sollte dies dennoch zu allen gültigen Ausdrücken führen. Es ist unwahrscheinlich, dass es zu einer besseren Lösung führt, aber es erweitert zumindest den Suchraum. Hmm, eigentlich könnte es ein Problem sein, weil Sie mit Folgen von Operatoren enden könnten.
Reto Koradi
13

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
Tödlich
quelle
Übrigens, herzlichen Glückwunsch zu 1k rep! :)
Alex A.
@AlexA. Schlag 1k auf eine J-Antwort, nachdem nichts anderes als Prolog antwortet. Untreu ...
Fatalize
8
Es ist okay, ich bin sicher, dass Prolog es verstehen wird.
Alex A.
3
@AlexA. Yes.
John Dvorak
@ JanDvorak Sprechen Sie im Namen von Prolog?
Alex A.
11

> <>, 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.

Cirpis
quelle
11
36 fühlt sich furchtbar suboptimal für eine Antwort, die effektiv
Lückenmissbrauch
Manchmal wünschte ich mir, Fisch hätte eine Anweisung zum "Drucken des letzten Dings auf Stapel und Beenden", die sehr hilfreich wäre. Ich könnte jedoch bald eine vollständig optimale
Lückenantwort haben
Ich habe ehrlich gesagt vergessen, eine Regel über das Nichtzählen nicht deterministischer Programme hinzuzufügen. Ich habe es jetzt hinzugefügt. Sie können gerne weitermachen, da es klug und gut erklärt ist, aber ich werde diese Antwort nicht akzeptieren.
Calvins Hobbys
1
Klar, diese Antwort war sowieso nicht als konkurrierende Antwort gedacht, es war eher eine Knie-Ruck-Reaktion, als ich diese Herausforderung las und daran dachte, eine Fisch-Antwort zu haben.
Cirpis
9

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
Dennis
quelle
1
während es dauerte ... für 30 Minuten ..
Optimierer
2
Das Beste, was ich für GolfScript finden konnte, ist 0)1#2#3(4bei 15. Schöne Symmetrie auch.
Primo
1
@primo: Das ist schlau. Ich hätte nicht gedacht, dass mehr Kommentare die Punktzahl verbessern würden.
Dennis
8

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]

Arnaud
quelle
Haben Sie diesen Code manuell geschrieben? Oder haben Sie Codevariationen systematisch aufgezählt und ausgewertet? Ich habe mich gefragt, ob eine Sprache mit Infix-Notation inhärent besser dafür ist oder ob es möglich ist, den Ansatz von @ Sp3000 mit einer Stack-basierten Golf-Sprache zu übertreffen.
Reto Koradi
@Reto Ich habe ein Programm geschrieben, das alle Werte 0..9 für die 4 numerischen Parameter ausprobiert hat. Ich habe auch versucht, einige Operatoren manuell zu ändern. Das Problem bei einer Stack-basierten Sprache ist, dass die meisten Operatoren 2 Parameter auf dem Stack benötigen, sodass wir viele Fehler haben. Infix-Sprachen profitieren von der von Sp3000 in seinem Beitrag beschriebenen Prüferstruktur.
Arnaud
Ja, das war genau mein Gefühl, als ich den grundlegenden Ansatz sah. Ein einfaches Layout, das garantiert alle gültigen Ausdrücke generiert, ist ein großer Vorteil. Der einzige Vorteil von CJam ist, dass es viel mehr Ein-Buchstaben-Operatoren gibt.
Reto Koradi
5

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


quelle