Was sind die fünf mächtigsten Charaktere in deiner Sprache?

101

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.

Calvins Hobbys
quelle
21
Ich möchte diese Herausforderung machen, aber es scheint UNMÖGLICH in cähnlichen Sprachen !!!
Mukul Kumar
3
@MukulKumar Ich glaube, es gibt auch REPLs in C-ähnlicher Sprache (zB kann gdb - bis zu einem gewissen Grad - als REPL für C verwendet werden), so dass der für Python demonstrierte Ansatz immer noch eine Option wäre.
Martin Ender
1
Verwandte (feste Verbindung).
Fatalize
3
@ETH Nein zur wahren Sache. Das ist, als würde man eine andere Basis zulassen.
Calvins Hobbys
3
@ OldBunny2800 Gültige Ausgaben sollten deterministisch und zeitinvariant sein.
Dennis

Antworten:

41

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
Yytsi
quelle
2
Würden Sie in Python 2, wo /Integer Division ist, nicht bessere Ergebnisse erzielen?
Neil
@Kade Me auch. Das größte, was ich ausprobiert habe, war etwas in den Zeilen "0123456789 * - + & |% ^ 0123456789"
Yytsi
Es gibt 2 weitere Alternativen, die die gleiche Anzahl von Werten ergeben: 5679%und5789%
Gábor Fekete
Zu Ihrer Information: Dies (oder die 5679%und 5789%) sind wahrscheinlich auch für PowerShell das Optimum.
AdmBorkBork
Ich habe diese Antwort (zusammen mit 5679%und 5798%) auch durch eine umfassende Suche nach allen Kombinationen 0123456789+-*/&|^#%mit Ersatz erhalten. Ich bin damit einverstanden, dass diese wahrscheinlich optimal sind.
JaredL
34

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.

Emigna
quelle
Noch nicht getestet, aber würde die Verwendung einer breiteren Auswahl von Ergebnissen aufgrund ihrer nicht kommutativen Eigenschaft -anstelle von +Ergebnissen führen?
Osable
@Osable: Ich habe auch mit getestet -, aber nie über 30 eindeutige Zahlen erhalten. Ein Problem ist, dass Sie auch negative Werte erhalten, die außerhalb des Bereichs liegen. Vielleicht ist es mit einigen anderen Operatoren besser, aber ich habe bisher keine Verbesserung gefunden.
Emigna
Richtig, ich habe den Teil übersprungen (obwohl fett gedruckt) und gesagt, dass die Ausgabe im Bereich [1.120] liegen muss. Mein schlechtes
Osable
Ich habe es eine Weile versucht und alles andere auf ~ 35 begrenzt.
Magic Octopus Urn
32

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.

Löwe
quelle
25
@ TùxCräftîñg Eigentlich ist es nicht, ein Set ist eine ungeordnete Sammlung.
Leo
2
@ TùxCräftîñg https://repl.it/El9V/0 Natürlich verwenden Sets eine interne Sortierung, um die Elemente im Auge zu behalten. Der Punkt ist, dass Sie sich nicht auf diese Sortierung verlassen können, da die Elemente nicht notwendigerweise in der Reihenfolge sortiert werden, in der Sie würden erwarten sie zu sein
Leo
1
@TuukkaX Ich sehe, dass dies ein unerwartetes Verhalten ist und mehr Probleme verursacht als es löst, also habe ich es herausgeschnitten. Entschuldigen Sie die Unannehmlichkeiten :)
Leo
1
@ hBy2Py Wenn Sie keine andere Operation für den Satz zwischen den beiden Iterationen ausführen, können Sie davon ausgehen, dass die beiden Iterationen in derselben Reihenfolge ablaufen. Im Allgemeinen gilt jedoch die Regel, dass Mengen ungeordnete Auflistungen sind. Sie sollten sich also niemals darauf verlassen, dass sie eine bestimmte Reihenfolge haben.
Leo
3
@Leo Verstanden: Sets sind Nitroglycerin. Einigermaßen stabil, es sei denn, Sie stoßen sie.
hBy2Py
23

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!

Xanderhall
quelle
2
Hat Java eine REPL? Vielleicht können Sie auf diese Weise mehr Symbole verwenden
Arturo Torres Sánchez
Ich habe keine Ahnung. Ich neige dazu, nein zu sagen. Außerdem würde meine Antwort im Grunde ein Copypaste des anderen REPL wird beantwortet dann: P
Xanderhall
3
Java 9 wird eine Vanille REPL haben !! Aber im Moment stecken wir mit Sachen von Drittanbietern fest .
NonlinearFruit
17
Ich denke, du kannst es besser machen n->12. Dies gibt Ihnen vier verschiedene Antworten , die alle innerhalb des Bereichs sind: n->12, n->21, n1->2, n2->1.
2
Java 9 und dessen REPL sind ab sofort in einer Early Access- Version verfügbar . Tatsächlich habe ich hier Antworten auf andere Fragen gegeben, die damit zusammenhängen.
David Conrad
18

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


quelle
@TuukkaX ja, ich implementiert sowohl die monadische Œ¿und dyadische œ¿(siehe in der Nähe der Unterseite des Wiki - Atome Seite ), aber sie sind beide 2-Byte - Dyaden , die die Code - Permutationen reduzieren , die das tun , was Sie wollen, und Sie bräuchten Alle Ihre Eingaben sollen Listen sein ( 12ist keine Liste).
Jonathan Allan
16

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
Arnauld
quelle
Würde die Verwendung von bitweise überhaupt nicht ~helfen? Es ist eine unäre Operation, die nützlich sein kann.
JollyJoker
1
@JollyJoker Nun, das Beste, was ich bisher finden kann, ~ist 257&~, dass es 11 verschiedene Werte erzeugt.
Arnauld
Ich bin ein bisschen überrascht, aber ich denke, dass meine Intuition hier nicht sehr gut ist.
JollyJoker
15

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

Tödlich
quelle
1
Gute Antwort und alles, was mit Golf zu tun hat, aber auf der mathematischen Seite können Sie eine beliebige Zahl bis zu 121 erreichen, indem Sie einfach die ersten fünf Potenzen von 3, 1,3, 9, 27 und 81 addieren oder streichen. Ich hoffe, das hilft.
Shyos
11

Vim, 16 Nummern

i1234

drucken

1, 2, 3, 4, 12, 13, 14, 21, 23, 24, 31, 32, 34, 41, 42, 43
Sefa
quelle
1
@ymbirtt Wo sind die 3und die geblieben 4? Sie benötigen alle Permutationen der Länge 5.
Kade
i1234druckt "1234", ist das eine Art Skript oder Tastendruck? Wenn es ein Tastendruck ist, funktioniert es nicht.
Captain Man
Erweitert man den Punkt von @Captain Man, wäre die naheliegende Möglichkeit, die Permutationen als Skript auszuführen: norm. Dabei werden jedoch keine Zahlen im Bereich von 1 bis 120 gedruckt. Hatten Sie eine andere Methode im Sinn?
Simon
Sie können sie
Uhr
4
@ nmjcman101 In diesem Fall fällt es in das Loch von "meistens", da 12i34 in V zu 12 Vorkommen von 34 führt, wobei, als ob Sie es in vim eingeben, es Ihnen nur 34 gibt (ich vermute, V nimmt ein endgültiges Esc an)
Sefa
11

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.

anatolyg
quelle
10

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

Jonathan Allan
quelle
10

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.

Riley
quelle
Eine schlecht dokumentierte Funktion: Das @ijDebug-Flag unterbricht das Programm und ermöglicht es dem Benutzer, Brain-Flak-Code einzugeben, der dort ausgeführt wird, wo das @ijFlag im Code enthalten ist. Ziemlich mächtig, erfordert aber leider Benutzereingaben und ist daher hier nicht nützlich.
0 '
Leichte Korrektur: (){}[]würde 0 Punkte bringen. Du hast die Permutationsregel vergessen;)
CalculatorFeline
8

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.

Martin Ender
quelle
Ich wollte auch eine Labyrinth-Antwort posten, aber genau die gleichen Lösungen scheinen auch dort optimal zu sein (mit praktisch der gleichen Semantik auch).
Martin Ender
7

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;
}
ThisSuitIsBlackNot
quelle
Perl hat tatsächlich etwas, das einem eingebauten REPL sehr nahe kommt. Versuche eine Weile zu rennen perl -de 1. Dadurch wird der Debugger technisch in einem leeren Programm geöffnet, der Debugger verfügt jedoch über eine integrierte REPL-Funktion. Leider müssen Sie p am Anfang jeder Zeile schreiben , damit das Ergebnis tatsächlich gedruckt wird.
@ ais523 Deshalb habe ich es nicht erwähnt; Sie können nicht einfach die Zeichenfolge selbst eingeben und die Ausgabe abrufen, was eine der Anforderungen ist.
ThisSuitIsBlackNot
7

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)
      }
)
rturnbull
quelle
Du sagst, es ist hässlicher Code ... Ich finde es wunderschön! Die vielen Verwendungsmöglichkeiten von apply lassen mich immer wieder in Erstaunen versetzen!
Sumner18
6

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
Fehler
quelle
5

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
Stewie Griffin
quelle
Nach meinen Tests, die optimale Wahl von 0123456789+-*.%für Oktave ist 139-%, die eine Anordnung von 18 erzeugt: 1 2 3 4 6 8 9 13 16 19 22 31 38 39 88 91 92 93. So können Sie weitere 3 Zahlen gewinnen :)
2
sehr grobe Brute-Force , dass ich die 18-Nummer Lösung zu erhalten verwendet: pastebin.com/umckG0VS
2
Ich habe diese Lösung auch gefunden, aber das war, nachdem ich die Python-Einreichung gesehen habe und es ist im Wesentlichen dasselbe. Netter Job, der sich die Mühe macht, ein Brute-Force-Skript zu erstellen. 😊
Stewie Griffin
4

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
user59178
quelle
3
Das gibt diese Zahlen aber nicht wirklich aus. 12\r30druckt 12\r30, überschreibt das Terminal nur die ersten beiden Zeichen.
Dennis
@Dennis Das heißt, dass bei jeder Herausforderung, bei der Steuerzeichen zum Überschreiben von Text erforderlich sind, nicht das ausgegeben wird, was am Ende angezeigt wird, sondern die Summe der geschriebenen Bytes. Da \rnicht druckbar ist, der Ausgang des 12\r30ist 30.
Katze
3
@cat Wir haben dies tatsächlich auf Meta diskutiert . Die Verwendung von Steuerzeichen ist nur zulässig, wenn sich die Herausforderung auf ASCII-Grafik bezieht.
Dennis
4

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

ETHproductions
quelle
3

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

Emigna
quelle
Ich habe versucht, das herauszufinden, aber ergibt das nicht nur 4 Zahlen? wie ist der bereich 1-120 nicht 0-120?
Teal
@Tealpelican: Richtig. Ich bemerkte dies auf dem Heimweg von der Arbeit und wollte es gerade reparieren.
Emigna
Ich habe mir ein bisschen mehr Fischprogramme wie die Quines und die Hello World usw. angesehen und hatte eine Idee. Etwas, das diese Zeichen verwendet; 1n; + "würde aus einer schnellen Berechnung 6+ generieren (unter Verwendung der Schleifenfunktion und von Zeichenfolgen zu unserem Vorteil) - könnte eine Überprüfung mit unterschiedlichen Werten für 1 und Operationen wert sein.
Teal
@Tealpelican: Das ist eine gute Idee.
Emigna
3

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();​
Magische Kraken-Urne
quelle
Ich denke, die gleiche Antwort würde auch für Java funktionieren.
Paŭlo Ebermann
3

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
Cedric Reichenbach
quelle
3

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]'
Bolce Bussiere
quelle
3

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
Zottelig
quelle
2

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
James Holderness
quelle
2

Python, 16 Zahlen

1234#

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

OldBunny2800
quelle
2

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

Toby Speight
quelle
2

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.

aka.nice
quelle
1

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
Martin Ender
quelle
Warum nicht, 6789?
David G. Stork
1

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
Draco18s
quelle
1

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

Tau
quelle