Wählen Sie fünf beliebige Zeichen aus, die Ihre Sprache unterstützt. Es gibt 5! = 5 × 4 × 3 × 2 × 1 = 120 Arten, wie diese in einer 5-stelligen Zeichenkette angeordnet werden können, die jedes Zeichen einmal enthält; 120 Permutationen .

Wählen Sie Ihre Zeichen so, dass, wenn jede der 120 Zeichenfolgen in Ihrer Sprache ausgeführt wird, die 120 erzeugten Ausgaben so viele eindeutige Ganzzahlen von 1 bis 120 (einschließlich) wie möglich enthalten.

Das heißt, für jede der 120 Permutationen Ihrer 5 Zeichen, die einen ausführbaren Code erzeugen, der eine einzelne Zahl ausgibt, soll die Menge all dieser Zahlen so nah wie möglich an der Menge der ganzen Zahlen von 1 bis 120 liegen.

Im Idealfall wird Ihre erste Permutation also ausgegeben 1, die nächste 2, die nächste 3, bis hinauf zu 120. Aber dieses Ideal ist wahrscheinlich für die meisten Sprachen und Charaktere unmöglich.

Die 5-stelligen Zeichenfolgen können wie folgt ausgeführt werden:

• ein Programm ohne Eingabe
• eine Funktion ohne Argumente
• ein REPL- Befehl

Falls gewünscht, können verschiedene Zeichenfolgen auf unterschiedliche Weise ausgeführt werden

Für die Ausgabe zu zählen, muss es eine einzige ganze Zahl sein Ausgang in einer normalen Art und Weise, wie zum Beispiel:

• Wird nach Standard gedruckt
• von der Funktion zurückgegeben
• das Ergebnis des REPL-Ausdrucks

Der Code sollte normal beenden (was beinhalten kann , so lange erroring geführt , wie die Zahl zuerst ausgegeben worden ist). Code, der überhaupt nicht ausgeführt wird, ist in Ordnung, nur die (nicht vorhandene) Ausgabe zählt nicht. Die Zahlenausgabe sollte dezimal erfolgen, es sei denn, für Ihre Sprache ist eine andere Basis die Norm.

Die Einsendung, die die deutlichsten Zahlen von 1 bis 120 generiert, gewinnt. Die frühere Vorlage gewinnt im Falle eines Gleichstands.

Anmerkungen

• Ihre 5 Zeichen müssen nicht alle unterschiedlich sein, aber wenn Sie doppelte Zeichen haben, verringert sich natürlich die effektive Anzahl der Permutationen.
• Float-Ausgänge wie 32.0count oder plain 32. (Wäre 32.01aber nicht.)
• Führende Nullen wie 032count sowie plain 32.
• Gültige Ausgaben sollten deterministisch und zeitinvariant sein.
• Wir haben es mit Zeichen zu tun , nicht mit Bytes.

Beispiel

Die Zeichen 123+*sind eine vernünftige erste Wahl für Pythons (oder vieler Sprachen) REPL. Die resultierenden 120 Permutationen und Ausgaben sind:

123+* n/a
123*+ n/a
12+3* n/a
12+*3 n/a
12*3+ n/a
12*+3 36
132+* n/a
132*+ n/a
13+2* n/a
13+*2 n/a
13*2+ n/a
13*+2 26
1+23* n/a
1+2*3 7
1+32* n/a
1+3*2 7
1+*23 n/a
1+*32 n/a
1*23+ n/a
1*2+3 5
1*32+ n/a
1*3+2 5
1*+23 23
1*+32 32
213+* n/a
213*+ n/a
21+3* n/a
21+*3 n/a
21*3+ n/a
21*+3 63
231+* n/a
231*+ n/a
23+1* n/a
23+*1 n/a
23*1+ n/a
23*+1 23
2+13* n/a
2+1*3 5
2+31* n/a
2+3*1 5
2+*13 n/a
2+*31 n/a
2*13+ n/a
2*1+3 5
2*31+ n/a
2*3+1 7
2*+13 26
2*+31 62
312+* n/a
312*+ n/a
31+2* n/a
31+*2 n/a
31*2+ n/a
31*+2 62
321+* n/a
321*+ n/a
32+1* n/a
32+*1 n/a
32*1+ n/a
32*+1 32
3+12* n/a
3+1*2 5
3+21* n/a
3+2*1 5
3+*12 n/a
3+*21 n/a
3*12+ n/a
3*1+2 5
3*21+ n/a
3*2+1 7
3*+12 36
3*+21 63
+123* n/a
+12*3 36
+132* n/a
+13*2 26
+1*23 23
+1*32 32
+213* n/a
+21*3 63
+231* n/a
+23*1 23
+2*13 26
+2*31 62
+312* n/a
+31*2 62
+321* n/a
+32*1 32
+3*12 36
+3*21 63
+*123 n/a
+*132 n/a
+*213 n/a
+*231 n/a
+*312 n/a
+*321 n/a
*123+ n/a
*12+3 n/a
*132+ n/a
*13+2 n/a
*1+23 n/a
*1+32 n/a
*213+ n/a
*21+3 n/a
*231+ n/a
*23+1 n/a
*2+13 n/a
*2+31 n/a
*312+ n/a
*31+2 n/a
*321+ n/a
*32+1 n/a
*3+12 n/a
*3+21 n/a
*+123 n/a
*+132 n/a
*+213 n/a
*+231 n/a
*+312 n/a
*+321 n/a

Es werden 36 Zahlen generiert, alle zum Glück innerhalb von 1 bis 120:

36, 26, 7, 7, 5, 5, 23, 32, 63, 23, 5, 5, 5, 7, 26, 62, 62, 32, 5, 5, 5, 7, 36, 63, 36, 26, 23, 32, 63, 23, 26, 62, 62, 32, 36, 63

Allerdings sind nur 8 davon einzigartig:

36, 26, 7, 5, 23, 32, 63, 62

Eine solche Einreichung würde also nur 8 von maximal 120 Punkten erzielen.

Python3, 21 27 Werte

Figuren: 3479%

Eindeutige Nummern: [1,2,3,4,5,6,7,8,9,11,12,19,20,21,24,29,34,35,36,37,39,43,46,47,49,73,74]

Wie angefordert, sind hier die Permutationen, die in den Bereich [1, 120] fielen . Probieren Sie es online!

347%9   5
349%7   6
34%79   34
34%97   34
374%9   5
379%4   3
37%49   37
37%94   37
394%7   2
397%4   1
39%47   39
39%74   39
3%479   3
3%497   3
3%749   3
3%794   3
3%947   3
3%974   3
437%9   5
439%7   5
43%79   43
43%97   43
473%9   5
479%3   2
47%39   8
47%93   47
493%7   3
497%3   2
49%37   12
49%73   49
4%379   4
4%397   4
4%739   4
4%793   4
4%937   4
4%973   4
734%9   5
739%4   3
73%49   24
73%94   73
743%9   5
749%3   2
74%39   35
74%93   74
793%4   1
794%3   2
79%34   11
79%43   36
7%349   7
7%394   7
7%439   7
7%493   7
7%934   7
7%943   7
934%7   3
937%4   1
93%47   46
93%74   19
943%7   5
947%3   2
94%37   20
94%73   21
973%4   1
974%3   2
97%34   29
97%43   11
9%347   9
9%374   9
9%437   9
9%473   9
9%734   9
9%743   9

05AB1E , 27 38 41 Nummern

4·>Ìn

Erzeugt die eindeutigen Zahlen:

[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 18, 19, 25, 27, 32, 33, 34, 35, 36, 37, 38, 49, 50, 52, 54, 64, 65, 66, 67, 72, 73, 74, 81, 83, 98, 100, 101, 102]

Verwendet die Konstante 4mit den Operationen +1, +2, *2und ^2.

Python, 18 Zahlen

237#-

Erzeugt als gültige Ergebnisse:

1, 2, 3, 4, 5, 7, 16, 23, 24, 25, 27, 32, 35, 37, 69, 71, 72, 73

EDIT: Ich kann bestätigen, dass die TuukkaX-Lösung für Python optimal ist. Ich habe den folgenden Code ausgeführt, der alle möglichen Kombinationen von 5 druckbaren ASCII-Zeichen erzwingt:

from itertools import permutations,combinations_with_replacement

def perms(chars):
  result=set()
  for permut in permutations(chars):
    try:
      current=eval(''.join(permut))
      assert str(int(current))==str(current)
      result.add(int(current))
    except:
      pass
  return sum([1 for x in result if 1<=x<=120])

best=1
for c in combinations_with_replacement(' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~',5):
    string=''.join(c)
    r=perms(string)
    if r>=best:
        best=r
        print(r,string,end='\n')

Die Ergebnisse (nach fast 7 Stunden ausgeführt wird ) zeigten , dass die optimale Lösung in der Tat 27 verschiedene Zahlen, die durch drei verschiedene Lösungen alle vier Zahlen verwenden und mod ( %) %3479, %5679und %5789.

Java 8, 2 4 Zahlen

n->12  // returns 12
n->21  // returns 21
n1->2  // returns 2
n2->1  // returns 1

Hatten Sie keine Java-Antwort erwartet?

Dies ist ein Lambda, das nur auf zwei Arten (und mit jeweils zwei verschiedenen Ziffern!) Für insgesamt zwei eindeutige Zahlen angeordnet werden kann. Alles andere ist kein gültiges Lambda.

Wirklich verbessert die Antwort, dank etwas Hilfe von Kommentaren! Ich habe nicht gesehen, dass 0 nicht gültig ist, und habe vergessen, dass Variablen, wie Sie wissen, mehr als ein Zeichen sein können. Wir haben 4!

Eine noch schlechtere Lösung

()->1

Aber auf der positiven Seite, zwei einzigartige Antworten in Java!

Jelly, 26 30 32 Zahlen

‘’3²Ḥ

Dies (und seine Anagramme) sind vollständige Programme, die keine Eingabe benötigen und eine Ausgabe auf der Standardausgabe erzeugen.

Die Ausgaben der 120 Programme lauten in der Reihenfolge, in der Jelly sie generiert, wenn Sie aufgefordert werden, Permutationen des Programms zu generieren:

018 036 06 03 09 03 18 116 116 117 125 135 06 03 14 15 13 22 19 13 24
28 33 42 018 036 06 03 09 03 -132 -164 -120 -119 -149 -137 26 43 18 17 
33 24 -19 13 -216 -210 53 44 18 36 30 31 49 63 18 36 10 9 25 17 18 19
18 17 18 18 36 48 36 26 36 36 06 03 14 15 13 22 06 03 -18 -17 -13 -24
06 07 06 05 06 06 03 12 03 -14 03 03 09 03 14 18 03 12 09 03 -116 -110 
23 14 09 015 09 05 09 09 03 12 03 -14 03 03

Wenn Sie nur die eindeutigen Ausgaben in numerischer Reihenfolge nehmen, erhalten Sie:

-216 -210 -164 -149 -137 -132 -120 -119 -116 -110 -24 -19 -18 -17 -14 -13
03 05 06 07 09 10 12 13 14 15 17 018 19 22 23 24 25 26 28 30 31 33 036 42
43 44 48 49 53 63 116 117 125 135

Viele davon sind zu klein und 135 zu groß, aber es gibt immer noch 32, die sich in Reichweite befinden.

Die Grundidee besteht darin, hauptsächlich monadische Anweisungen zu verwenden (in einem Programm mit nur Monaden und Niladen transformieren diese jeweils nur die vorherige Ausgabe) und solche, bei denen der Wert schnell divergiert. Die Ausnahme ist mit 3, was eine Null ist (der konstante Wert 3). Wenn es zu Beginn des Programms angezeigt wird, werden alle Vorgänge ab Schritt 3 ausgeführt. Wenn es in der Mitte angezeigt wird, wird das Programm in zwei Hälften aufgeteilt, von denen jede eine Ganzzahl ausgibt (und bei jedem Ausdruck auf die Standardausgabe Die Ergebnisse werden schließlich verkettet, sodass wir als zusätzliche Operation zum Generieren von Zahlen "verketten" können.

Die Operationen, die wir hier haben, im Kontext, in dem das Programm sie generiert, sind: increment; Dekrement; konstant 3; Quadrat; und doppelt. Inkrementieren und Dekrementieren sind leider gegensätzlich, und Dekrementieren hat eine unglückliche Tendenz, im ersten Abschnitt ein -1 oder -2 zu erzeugen (was insgesamt zu einer negativen Zahl führt), aber dies ergab immer noch eine größere Streuung der Ergebnisse als die anderen Dinge, die ich versucht habe . Insbesondere erhalten wir eine ziemlich gute Streuung sowohl der ersten als auch der zweiten Hälfte der Zahl (beachten Sie, dass die erste Hälfte die Nullzeichenfolge sein kann, wenn 3es sich um das erste Zeichen im Programm handelt).

JavaScript, 27 Zahlen

Sehr ähnlich zu die Antwort TuukkaX mit einer anderen Ziffernfolge.

5789%

Die 27 unterschiedlichen Werte sind:

589 %   7 -> 1
987 %   5 -> 2
978 %   5 -> 3
879 %   5 -> 4
985 %   7 -> 5
958 %   7 -> 6
975 %   8 -> 7
 95 %  87 -> 8
  9 % 875 -> 9
 97 %  85 -> 12
 89 %  75 -> 14
 95 %  78 -> 17
 78 %  59 -> 19
 79 %  58 -> 21
 98 %  75 -> 23
 87 %  59 -> 28
 89 %  57 -> 32
 97 %  58 -> 39
 98 %  57 -> 41
 57 %  98 -> 57
 58 %  97 -> 58
 59 %  87 -> 59
 75 %  98 -> 75
 78 %  95 -> 78
 79 %  85 -> 79
 85 %  97 -> 85
 87 %  95 -> 87

Brachylog , 26 Nummern

3+*^-

Dies gibt die folgenden Zahlen aus: [2,3,4,5,6,7,8,9,10,16,17,18,19,20,25,26,30,31,32,35,36,37,48,49,63,64]

Erläuterung

• 3 ist natürlich die ganze Zahl 3.
• + ist inkrement
• * ist doppelt
• ^ ist quadratisch
• - ist Dekrement

Es gibt viele Situationen, in denen das Programm einfach Fehler macht: Zum Beispiel *+^3-Fehler, weil es fragt "Nehmen Sie 0, verdoppeln Sie es, erhöhen Sie es, quadrieren Sie, das Ergebnis dieses Quadrats ist 3, dekrementieren Sie", was offensichtlich falsch ist.

Jedes Programm, das mit endet 3 wird entweder ausgegeben 3oder funktioniert nicht.

Jedes Programm, das mit beginnt, *3wird aufgrund eines Fehlers eine Endlosschleife durchlaufen (Brachylog versucht, eine Liste von Unterlisten zu finden, deren Produkt zu 3 führt, was nicht möglich ist).

Vim, 16 Nummern

i1234

drucken

1, 2, 3, 4, 12, 13, 14, 21, 23, 24, 31, 32, 34, 41, 42, 43

IA-32 Maschinencode, 8 Ziffern

Hexadezimale Bytewerte:

2c 40 48 b0 c3

Der Code wird als Funktion ausgeführt, die den Wert in zurückgibt al .

Gültige Permutationen:

b0 2c c3 xx xx => 2c (mov al, 2c)

b0 40 c3 xx xx => 40 (mov al, 40)

b0 48 c3 xx xx => 48 (mov al, 48)

b0 2c 40 c3 48 => 2d (mov al, 2c; inc eax)

b0 2c 48 c3 40 => 2b (mov al, 2c; dec eax)

b0 40 48 c3 2c => 3f (mov al, 40; dec eax)

b0 48 40 c3 2c => 49 (mov al, 48; inc eax)

b0 48 2c 40 c3 => 8 (mov al, 48; sub al, 40)

Ich habe eine Brute-Force-Suche mit den folgenden Einschränkungen durchgeführt:

• Das erste Byte ist b0- das zu initialisierenal Register
• Das letzte Byte ist c3 - return; Folgende Bytes werden verworfen
• Mögliche Opcode-Bytes sind:
  • 0x04 - add
  • 0x0c - or
  • 0x24 - and
  • 0x2c - sub
  • 0x34 - xor
  • 0xd4 - aad
  • 0x40 - inc
  • 0x48 - dec

Es bleiben nur 3 änderbare Bytes mit maximal 15 möglichen Ergebnissen. Davon können maximal 9 unterschieden werden (tatsächlich geschieht dies nur für einen Satz von Bytes!). Einer der Werte liegt außerhalb des zulässigen Bereichs, sodass 8 Werte übrig bleiben. Es gibt eine andere Menge von Bytes

34 40 48 b0 c3

Dies ergibt auch 8 verschiedene Werte - die Programme sind die gleichen, außer dass subsie durch ersetzt werden xor, wodurch zwei der möglichen Ausgaben identisch werden.

Alle anderen Sätze von Bytes ergeben 7 oder weniger mögliche Ergebnisse.

Gelee , 33 Zahlen

Ḥ23+c

Ḥdoppelt (links);
2wörtlich 2;
3wörtlich 3;
+addieren (links, rechts); und
c wähle (links, rechts), dh die Anzahl der Möglichkeiten, rechte Objekte aus einer Sammlung von linken Objekten auszuwählen.

Mit einem Beispielprogramm ermittelte Zahlen:

 1 +32Ḥc   18 3Ḥc2+    45 2+3Ḥc
 2 c3Ḥ+2   20 2+Ḥc3    47 23c+Ḥ
 3 c2Ḥ+3   21 2Ḥ+3c    48 c+23Ḥ
 4 +2Ḥc3   22 3Ḥc+2    53 2c+Ḥ3
 5 2+3cḤ   23 23cḤ+    56 3Ḥ+2c
 6 3c+2Ḥ   24 cḤ+23    63 c+2Ḥ3
 8 2c+3Ḥ   30 3+c2Ḥ    65 32c+Ḥ
 9 3c2+Ḥ   32 32cḤ+    66 c+32Ḥ
12 +3cḤ2   33 cḤ+32    72 3c+Ḥ2
13 +2cḤ3   36 3+Ḥc2    82 c+3Ḥ2
15 +3Ḥc2   42 cḤ3+2   120 3+2Ḥc

Ich habe versucht, einfach zu analysieren, aber einige sind selten und etwas seltsam zu analysieren, zum Beispiel 23:

23cḤ+: (23 c (2 * 23)) + 23 = (23 c 46) + 23 = 0 + 23 = 23

... und 72und 13implizites Drucken verwenden:

3c+Ḥ2: z = (3 c 0) + (3 * 2); print(z); z = 2; print(z)
       z =    1    +    6   ; print(z); z = 2; print(z)

+2cḤ3: z = (0 + 2) c (2 * 0); print(z); z = 3; print(z)
       z =    2    c    0   ; print(z); z = 3; print(z)
       z =         1        ; print(z); z = 3; print(z)

Beachten Sie, dass Ḥ34+cauch 33eindeutige Werte in erzeugt [1,120].

Brain-Flak 1

(())#

Brain-Flak erfordert ausgeglichene Klammern, daher ist ein 5-Zeichen-Programm nur gültig, wenn eines der Zeichen einen Kommentar beginnt. Das lässt uns mit 4 Charakteren arbeiten. Davon müssen 2 sein (und )sonst würde nichts auf den Stapel geschoben. Diese müssen mit dem Kommentar last ( (..)#) an erster und vierter Stelle stehen . Jetzt können wir setzen (), {}, <>, oder nach []innen. {}, <>Und []jeweils 0, bewerten , sondern ()ist 1. Das bedeutet , dass (())#die einzigen 5 - Zeichenfolge , die ein gültiges Brain-Flak - Programm erzeugt.

Probieren Sie es online!

Wenn stattdessen die Frage "Was sind die 6 mächtigsten Charaktere?" Gestellt würde, wäre die Antwort, dass (){}[]Brain-Flak nur mit dieser Teilmenge vollständig ist.

Hexagony , 13 Zahlen

)24!@

Dies sind die 13 druckbaren Nummern mit jeweils einem möglichen Programm:

)!@24 1
2!@)4 2
2)!@4 3
4!@)2 4
4)!@2 5
)2!@4 12
)4!@2 14
24!@) 24
24)!@ 25
2)4!@ 34
42!@) 42
42)!@ 43
4)2!@ 52

Die Programme sollten ziemlich selbsterklärend sein. @Beendet das Programm, !druckt den aktuellen Wert, )erhöht ihn 2und 4hängt sich an den aktuellen Wert an (wobei der Anfangswert ist 0). Dabei spielt das tatsächliche hexagonale Layout des Quellcodes keine Rolle, die Programme können einfach von links nach rechts gelesen werden.

Dies sollte optimal sein, obwohl anstelle von 2und 4Sie jedes Paar Ziffern xund ysolche auswählen können 2 ≤ x ≤ y-2.

Die obige Lösung wurde durch (fast erschöpfende) Gewaltanwendung gefunden, bei der eine !(andernfalls würde nichts gedruckt), eine @(andernfalls wird das Programm nicht beendet) und die verbleibenden drei Zeichen mit einer (wiederholten) Kombination aus der Zeichenfolge gefüllt wurden folgenden Zeichensatz:

#[]\/_|<>)!0123456789$

Ich kann nicht sehen, wie die anderen Befehle möglicherweise mehr Abwechslung erzeugen könnten.

Perl, 27 Nummern

3479%

Perl verfügt nicht über eine eingebaute REPL, daher können Sie diese re.plvon Devel :: REPL aus verwenden .

Ergebnisse:

%9743 -> N/A
9%743 -> 9
97%43 -> 11
974%3 -> 2
9743% -> N/A
%7943 -> N/A
7%943 -> 7
79%43 -> 36
794%3 -> 2
7943% -> N/A
%7493 -> N/A
7%493 -> 7
74%93 -> 74
749%3 -> 2
7493% -> N/A
%7439 -> N/A
7%439 -> 7
74%39 -> 35
743%9 -> 5
7439% -> N/A
%9473 -> N/A
9%473 -> 9
94%73 -> 21
947%3 -> 2
9473% -> N/A
%4973 -> N/A
4%973 -> 4
49%73 -> 49
497%3 -> 2
4973% -> N/A
%4793 -> N/A
4%793 -> 4
47%93 -> 47
479%3 -> 2
4793% -> N/A
%4739 -> N/A
4%739 -> 4
47%39 -> 8
473%9 -> 5
4739% -> N/A
%9437 -> N/A
9%437 -> 9
94%37 -> 20
943%7 -> 5
9437% -> N/A
%4937 -> N/A
4%937 -> 4
49%37 -> 12
493%7 -> 3
4937% -> N/A
%4397 -> N/A
4%397 -> 4
43%97 -> 43
439%7 -> 5
4397% -> N/A
%4379 -> N/A
4%379 -> 4
43%79 -> 43
437%9 -> 5
4379% -> N/A
%9734 -> N/A
9%734 -> 9
97%34 -> 29
973%4 -> 1
9734% -> N/A
%7934 -> N/A
7%934 -> 7
79%34 -> 11
793%4 -> 1
7934% -> N/A
%7394 -> N/A
7%394 -> 7
73%94 -> 73
739%4 -> 3
7394% -> N/A
%7349 -> N/A
7%349 -> 7
73%49 -> 24
734%9 -> 5
7349% -> N/A
%9374 -> N/A
9%374 -> 9
93%74 -> 19
937%4 -> 1
9374% -> N/A
%3974 -> N/A
3%974 -> 3
39%74 -> 39
397%4 -> 1
3974% -> N/A
%3794 -> N/A
3%794 -> 3
37%94 -> 37
379%4 -> 3
3794% -> N/A
%3749 -> N/A
3%749 -> 3
37%49 -> 37
374%9 -> 5
3749% -> N/A
%9347 -> N/A
9%347 -> 9
93%47 -> 46
934%7 -> 3
9347% -> N/A
%3947 -> N/A
3%947 -> 3
39%47 -> 39
394%7 -> 2
3947% -> N/A
%3497 -> N/A
3%497 -> 3
34%97 -> 34
349%7 -> 6
3497% -> N/A
%3479 -> N/A
3%479 -> 3
34%79 -> 34
347%9 -> 5
3479% -> N/A

Brute-Forced mit folgendem Programm:

use strict;
use warnings 'all';
use 5.010;

use Algorithm::Combinatorics qw(combinations);
use Algorithm::Permute;
use Scalar::Util::Numeric qw(isint);

my @chars = ( 0..9, qw(+ - * / . ; ' " \ @ $ # ! % ^ & ( ) { } =) );
my $iter  = combinations(\@chars, 5);
my $max   = 0;
my @best;

while (my $combo = $iter->next) {
    my $count = count_valid([@$combo]);

    if ($count > $max) {
        $max  = $count;
        @best = @$combo;
    }
}

say "$max -> @best";

sub count_valid {
    my ($chars) = @_;

    my $iter = Algorithm::Permute->new($chars);
    my %results;

    while (my @perm = $iter->next) {
        no warnings;
        my $val = eval join '', @perm;
        use warnings 'all';

        $results{$val} = 1 if isint($val) && $val > 0 && $val <= 120;
    }

    return scalar keys %results;
}

R, 15 18 Zahlen

Keine große Zahl, aber vielleicht die beste, die mit R erreicht werden kann. Ich habe alle Kombinationen von Ziffern 0..9, Operatoren + - * / ^und dem Kommentarzeichen durchsucht #, und die folgenden acht geben alle 18 eindeutige Ganzzahlen zwischen 1 und 120 aus.

-#146
-#157
-#237
-#238
-#256
-#267
-#278
-#378
-#467
-#568

Nehmen wir als Beispiel -#146. Hier sind die 18 ganzen Zahlen, die wir bekommen können:

1#-46      = 1
6-4#1      = 2
4-1#6      = 3
4#-16      = 4
6-1#4      = 5
6#-14      = 6
14-6#      = 8
16-4#      = 12
14#-6      = 14
16#-4      = 16
41-6#      = 35
41#-6      = 41
46-1#      = 45
46#-1      = 46
61-4#      = 57
61#-4      = 61
64-1#      = 63
64#-1      = 64

Wenn Sie neugierig auf den (hässlichen) Code sind, der zum Testen aller möglichen Kombinationen verwendet wird, finden Sie ihn hier. Es gibt die Anzahl der eindeutigen Ganzzahlen zwischen 1 und 120 für jede Zeichenkombination der Länge 5 in eine Datei mit dem Namen "datafile" im aktuellen Arbeitsverzeichnis aus.

allchars = c("1","2","3","4","5","6","7","8","9","0","+","-","*","/","^")
apply(gtools::combinations(n=15, r=5, v=allchars, repeats.allowed=TRUE),
      1,
      function(chars) {
        x = apply(apply(e1071::permutations(length(chars)), 
                        1,
                        function(i) chars[i]
                        ),
                  2,
                  paste, collapse=""
            )
        u = unique(x)
        o = as.numeric(unlist(sapply(u, function(i) eval(try(parse(t=i),TRUE)))))

        f = factor(unique(o[o<=120 & o>=1 & o%%1==0]))
        write(paste(nlevels(f), paste(chars, collapse="")), "datafile", append=TRUE)
      }
)

Oktave, 18

Dies wurde mithilfe einer Bruteforce-Suche nach Symbolen gefunden *+-/0123456789:;<\^|~%. Aber die Berechnung hat viel zu lange gedauert ...

-139%

Mögliche Ausgaben:

1, 2, 3, 4, 6, 8, 9,13,16,19,22,31,38,39,88,91,92,93

Oktave, 15 Zahlen

Nicht viel zu prahlen, aber das ist das Beste, was ich in Octave bekommen kann:

124+%

Es gibt die Zahlen:

1    2    3    4    5    6   12   14   16   21   24   25   41   42   43

Ich habe auch 16, aber es scheint identisch mit Sefas Antwort zu sein ...

1234%

1    2    3    4   12   13   14   21   23   24   31   32   34   41   42   43

PHP, 15 Zahlen

1230\r

Verwendet die Tatsache, dass PHP alles außerhalb seiner Tags wörtlich ausgibt (ohne dies zu verwenden, können Sie genau 1 Zahl mit so etwas machen <?=1;). Verwendet auch ein tatsächliches Wagenrücklaufzeichen anstelle von\r .

Erstellt (sortierte, entfernte führende Nullen):

 1 1 2 2 3 3 10 10 12 12 12 12 13 13 13 13 20 20 21 21 21 21 23 23 23 23 30 30 31 31 31 31 32 32 32 32 102 102 103 103 120 120 123 123 123  123  130  130  132  132  132  132  201  201  203  203  210  210  213  213  213  213  230  230  231  231  231  231  301  301  302  302  310  310  312  312  312  312  320  320  321  321  321  321  1023  1023  1032  1032  1203  1203  1230  1230  1302  1302  1320  1320  2013  2013  2031  2031  2103  2103  2130  2130  2301  2301  2310  2310  3012  3012  3021  3021  3102  3102  3120  3120  3201  3201  3210  3210

Davon sind die gültigen eindeutigen Nummern:

1 2 3 10 12 13 20 21 23 30 31 32 102 103 120

Cubix , 7 Zahlen

"2)@O

Gibt diese Zahlen aus:

")O2@ ->  1
")2O@ ->  2
"2)O@ ->  3
2"O@) -> 41
)"O@2 -> 50
2"O)@ -> 64
2")O@ -> 65

Jedes gültige Cubix-Programm für diese Herausforderung muss ein, Oum eine Ganzzahl auszugeben, und ein@ um das Programm zu beenden (Cubix hat noch nie von "Fehlern" gehört). Dies gibt uns 3 Zeichen zum Herumspielen, um die meisten Ergebnisse zu erzielen. Aufgrund der Art und Weise, wie Cubix Code auf einem Cube anordnet, ist das erste Zeichen nutzlos, es sei denn, eines der anderen Zeichen ist ein direktionales Zeichen.

Die effizienteste Möglichkeit, mehrere Zahlen zu generieren, besteht "darin, eine Folge von Zeichencodes auf den Stapel zu schieben. Bei sorgfältiger Neuanordnung können wir mehrere Zeichen an die letzte Stelle setzen und einfach ihre Zeichencodes ausgeben. Durch die Nutzung) Inkrementieren des obersten Elements können aus mehreren dieser Arrangements zusätzliche Ausgaben erstellt werden.

Hier werden zwei grundlegende Programmtypen verwendet. Das erste ist das:

"2)O@

das erweitert sich zu

  "
2 ) O @
  .

Das resultierende Programm schiebt 2auf den Stapel, inkrementiert ihn mit ), gibt mit aus Ound endet mit @.

Der zweite ist dieser:

2")O@

das erweitert sich zu

  2
" ) O @
  .

Das sich ergebende Programm schiebt die char-Codes ), Ound @inkrementiert die letzte mit ), mit Ausgängen Ound endet mit @.

> <> , 6 Ziffern

Dank Teal Pelican 2 Nummern gewonnen

1ln";

Erzeugt die eindeutigen Zahlen [1, 4, 5, 49, 59, 108]

Wir müssen neine Nummer drucken.
Wir brauchen; kündigen.

Damit haben wir nur noch 3 Zeichen zur Verfügung.

Ein paar verschiedene Kombinationen von valueund operatorzusammen mit haben "bestätigt, dass sie 6 eindeutige Werte ergeben, aber ich habe nichts Besseres gefunden.

Groovy, 10 Zahlen

Man JVM-Lösungen sind schlecht für diese ... Wer wusste?

1200+

Ergebnisse in:

[3, 10, 12, 17, 21, 30, 66, 80, 102, 120]

Warte was? Wie zum Teufel bringt es dich dazu, zu fragen?

20+10 is 30.
0120+ is invalid.
2+001 is 3.
201+0 is 201.
2+100 is 102.
0+012 is 10.
21+00 is 21.
02+01 is 3.
0210+ is invalid.
10+20 is 30.
200+1 is 201.
0+210 is 210.
1200+ is invalid.
0201+ is invalid.
+0021 is 17.
1+002 is 3.
210+0 is 210.
100+2 is 102.
010+2 is 10.
00+12 is 12.
20+01 is 21.
01+20 is 21.
0+120 is 120.
+0120 is 80.
0+021 is 17.
+1020 is 1020.
0012+ is invalid.
02+10 is 12.
102+0 is 102.
012+0 is 10.
+2100 is 2100.
12+00 is 12.
00+21 is 21.
+2001 is 2001.
+0210 is 136.
+1200 is 1200.
1020+ is invalid.
0102+ is invalid.
2001+ is invalid.
001+2 is 3.
+0012 is 10.
2+010 is 10.
0021+ is invalid.
10+02 is 12.
2100+ is invalid.
+0201 is 129.
2010+ is invalid.
020+1 is 17.
1002+ is invalid.
+2010 is 2010.
1+020 is 17.
1+200 is 201.
01+02 is 3.
+1002 is 1002.
120+0 is 120.
0+102 is 102.
+0102 is 66.
002+1 is 3.
0+201 is 201.
021+0 is 17.

Geschäftsgeheimnis: Bei Groovy / Java-Ganzzahlen, denen eine 0 vorangestellt ist, handelt es sich um Oktale. Code, den ich zum Testen von Groovy-Antworten verwendet habe, falls mich jemand schlagen möchte:

("1200+" as List).permutations().collect{
    it.join()
}.collect {
    print "$it is "
    x=-1;
    try {
        x=Eval.me(it);
        println "$x."
    } catch(Exception e) {
        println "invalid."
    }
    x<=120?x:-1;
}.unique().sort();​

MATL, 15 Nummern

0123%

% ist der Kommentaroperator, daher wird er an allen möglichen Stellen einmal "abgeschnitten" und dabei geholfen, alle möglichen Kombinationen der angegebenen Ziffern und Teilmengen davon zu erstellen:

1
2
3
10
12
13
20
21
23
30
31
32
102
103
120

J, 16 Zahlen

1234]

Nichts Besonderes, nur getestet 1234 Besonderes mit all den 1-Zeichen-Verben, die vernünftig waren. ]wählt das richtige Argument aus.

Die produzierten eindeutigen Zahlen sind

0 4 3 34 43 2 24 42 23 32 234 243 324 342 423 432 1 14 41 13 31 134 143 314 341 413 431 12 21 124 142 214 241 412 421 123 132 213 231 312 321 1234 1243 1324 1342 1423 1432 2134 2143 2314 2341 2413 2431 3124 3142 3214 3241 3412 3421 4123 4132 4213 4231 4312 4321

davon 16:

4 3 34 43 2 24 42 23 32 1 14 41 13 31 12 21

Sind im Bereich [1.120].

Getestet mit

# (#~e.&(>:i.120)) ~. (". :: 0:)"1 (A.~ i.@!@#) '1234]'

Japt , 41 Nummern

Ziemlich nur Versuch und Irrtum, also könnte es eine bessere Lösung geben. Verwendet ganze Zahlen 3& 4und die Japt Verknüpfungen für quadrieren, das Hinzufügen 1und Multiplikation mit 2. Alle 120 Programme geben eine ganze Zahl aus, >0aber nur 78 <=120und nur 41 davon sind eindeutig.

34²ÄÑ

Generiert die Zahlen:

1,3,4,5,6,7,8,9,13,14,17,20,21,26,27,29,30,31,32,33,34,35,36,37,38,39,42,43,44,45,47,56,59,68,69,72,73,86,87,92,93

Zeigen Sie die Liste der Nummern oder die Sammlung gültiger Programme an

Erläuterung

Einige wichtige Dinge zu Japt sind:

1. Wenn ein Programm (in diesem Fall) nicht mit einer der Ziffern beginnt, wird die erste Eingangsvariable verwendet U, die standardmäßig verwendet wird0 beginnt, wird wird, automatisch am Anfang eingefügt.
2. Wenn eine oder beide Ziffern unmittelbar auf eine der Tastenkombinationen für eine mathematische Operation folgen, werden sie an diese angefügt (z. B. 3Ä4 = 3+14 = 17und in ähnlicher Weise4Ѳ = 4*2**2 = 16 ).
3. Wenn eine der Ziffern unmittelbar auf die folgt, ²wird das ²und alles, was davor steht, im Wesentlichen ignoriert.

Erläuterungen zu einigen der Programme (Herstellung 1, 3, 37und 93jeweils):

²Ñ34Ä  :Square 0, multiply by 234 and add 1
4ÄѲ3  :Add 1 multiplied by 2 squared to 4, ignore that and return the 3
3²Ä4Ñ  :Square 3 and add 14 multiplied by 2
4Ñ3IJ  :Multiply 4 by 23 and add 1 squared

Befunge, 11 Nummern

Befunge ist etwas eingeschränkt, da es nur einstellige Literale unterstützt. Das Beste, was ich finden konnte, waren also 11 Zahlen, vorausgesetzt, die Berechnung muss uns eine und nur eine Zahl auf dem Stapel lassen.

Beste Charaktere: 358*%

Generierte Zahlen: (jeweils nur ein Beispiel)

58*3% => 1
358*% => 3
38*5% => 4
538*% => 5
35*8% => 7
835*% => 8
385%* => 9
583%* => 10
358%* => 15
53%8* => 16
35%8* => 24

Python, 16 Zahlen

1234#

Mit # können Sie alle unnötigen Nummern auskommentieren.

dc, 19 zahlen

*3zO+

Die Ausgabe erfolgt über dem Stapel, und Fehler (einschließlich Stapelunterlauf) werden ignoriert. Die gültigen Permutationen sind:

+O3*z:   1
+O*3z:   2
+Oz3*:   3
O*z3+:   4
O*3z+:   5
+O3z*:   6
+z3*O:  10
3*zO+:  11
3*Oz+:  12
Oz3*+:  13
O3z*+:  16
+3Oz*:  20
3Oz*+:  23
+zO3*:  30
O3*z+:  31
Oz+3*:  33
3Oz+*:  36
Oz3+*:  40
O3z+*:  50
TOTAL COUNT = 19 numbers

Hier ist das Python-Programm, mit dem ich diese Ergebnisse gezeigt habe:

#!/usr/bin/python

import sys
import itertools
import subprocess

if len(sys.argv[1]) != 5:
    print("Invalid input")
    sys.exit(1)

devnull = open("/dev/null", 'w');

r = dict()
for s in itertools.permutations(sys.argv[1]):
    p = "".join(s)
    try:
        e = (subprocess.check_output(['dc', '-e', p, '-e', 'p'], stderr=devnull))
        e = int(e)
        if 0 < e <= 120:
            r[e] = p
    except e:
        pass

for i in sorted(r):
    print("%5s: %3d" % (r[i], i))

print("TOTAL COUNT = %d numbers" % len(r))

Zwei weitere Strings , die die gleiche Punktzahl von 19 geben sind 32d+*und *4zO+.

Smalltalk, 26 Nummern

1235r

Erklärung: 12r35 ist eine Notation für die Verwendung von Radix 12 und ist daher 3 * 12 + 5.
Dies kann in Squeak überprüft werden:

((Array streamContents: [:s |
    '1235r'  permutationsDo: [:each | 
        | eval |
        eval := [Compiler evaluate: each] ifError: [nil].
        (eval isInteger and: [eval >=1 and: [eval <= 120]]) ifTrue: [s nextPut: each copy -> eval]]])
  collect: #value as: Set) sorted

gibt:

#(1 2 3 5 28 31 33 37 38 41 42 47 55 58 63 66 67 68 71 76 82 86 105 107 108 116)

Wenn wir die letzte Zeile ersetzen durch:

    sorted: #value ascending)

Wir erhalten dann die Ausdrücke:

'235r1' -> 1
'253r1' -> 1
'325r1' -> 1
'352r1' -> 1
'523r1' -> 1
'532r1' -> 1
'135r2' -> 2
'153r2' -> 2
'315r2' -> 2
'351r2' -> 2
'531r2' -> 2
'513r2' -> 2
'125r3' -> 3
'152r3' -> 3
'215r3' -> 3
'251r3' -> 3
'521r3' -> 3
'512r3' -> 3
'123r5' -> 5
'132r5' -> 5
'213r5' -> 5
'231r5' -> 5
'321r5' -> 5
'312r5' -> 5
'23r15' -> 28
'25r13' -> 28
'13r25' -> 31
'15r23' -> 33
'32r15' -> 37
'35r12' -> 37
'5r123' -> 38
'12r35' -> 41
'5r132' -> 42
'15r32' -> 47
'52r13' -> 55
'53r12' -> 55
'5r213' -> 58
'12r53' -> 63
'5r231' -> 66
'13r52' -> 67
'31r25' -> 67
'21r35' -> 68
'35r21' -> 71
'25r31' -> 76
'5r312' -> 82
'5r321' -> 86
'51r23' -> 105
'53r21' -> 107
'21r53' -> 108
'23r51' -> 116

Ich wollte eine Methode r in Integer als betrügen und definieren

Integer>>r
    ^self \\ 120 + 1

Leider hackt der Compiler auf 1235r, weil er eine unvollendete Zahl mit dem Radix erkennt, anstatt eine Nachricht an 1235 zu senden ...
Ich könnte den Compiler auch leicht ändern, aber es ist ein bisschen zu viel Cheat für meinen Geschmack.

Mathematica, 16 Zahlen

;1234

Nicht sehr interessant, aber ich kann mit Arithmetik anscheinend nichts Besseres finden. Das Einzige, was das könnte funktionieren , ist die Verwendung! von faktoriellen oder doppelten faktoriellen Werten. Dies ist jedoch so anfällig für die Erzeugung massiver Zahlen, dass es unmöglich ist, Gewalt anzuwenden.

Die 16 Zahlen (im Bereich), die aus den obigen 5 Zeichen generiert werden können, sind:

1, 2, 3, 4, 12, 13, 14, 21, 23, 24, 31, 32, 34, 41, 42, 43

Runenverzauberungen, 19 Nummern

234p@

Im Wesentlichen 3 Liter, der pow-Operator und ein Befehl "Den gesamten Stapel drucken und beenden". 234p@druckt 812 (3 ^ 4 verbunden mit einer 2). Vollständige Permutationsliste , Notiz, @die durch ersetzt wurdeak@ , um eine neue Zeile zwischen jedem Ergebnis und a zu erzeugen> wurde hinzugefügt, um sicherzustellen, dass jede Zeile unabhängig ausgeführt wird. Beachten Sie auch, dass die Ausgaben nicht in derselben Reihenfolge wie die Programme sind, die sie generiert haben (da einige Programme möglicherweise schneller beendet werden).

Viele Permutationen geben nichts aus (z. B. @234poderp234@ ), aber 19 führen zur Ausgabe innerhalb des zulässigen Bereichs.

Mögliche Zahlen (und ein mögliches Programm, das dazu führt; .gibt an, dass diese Positionen eines der verbleibenden Zeichen sein können, da es nicht ausgeführt wird):

2@...        2
3@...        3
4@...        4
23p@.        8
32p@.        9
42p@.       16
32@..       23
42@..       24
23@..       32
43@..       34
24@..       42
34@..       43
23p4@       48
32p4@       49
43p@.       64
34p@.       81
423p@       84
432p@       94

TI-BASIC, 12 Nummern

23+4!

Es gibt höchstwahrscheinlich eine bessere Kombination, aber ich konnte sie nicht finden.

Alle $24$ Gültige Permutationen sind wie folgt:

23+4!   -> 47
24+3!   -> 30
2+4!3   -> 74
2+3!4   -> 26
2!4+3   -> 11
2!+43   -> 45
2!+34   -> 36
2!3+4   -> 10
32+4!   -> 56
34+2!   -> 36
3+4!2   -> 51
3+2!4   -> 11
3!4+2   -> 26
3!+42   -> 48
3!+24   -> 30
3!2+4   -> 16
43+2!   -> 45
42+3!   -> 48
4+2!3   -> 10
4+3!2   -> 16
4!2+3   -> 51
4!+23   -> 47
4!+32   -> 56
4!3+2   -> 74

Davon gibt es $12$ eindeutige Werte:

$10,11,16,26,30,36,45,47,48,51,56,74$