Quels sont les cinq personnages les plus puissants de votre langue?

101

Choisissez cinq caractères que votre langue prend en charge. Il y en a 5! = 5 × 4 × 3 × 2 × 1 = 120 façons de les organiser en une chaîne de 5 caractères contenant chaque caractère une fois; 120 permutations .

Choisissez vos caractères de telle sorte que, lorsque chacune des 120 chaînes est exécutée dans votre langue, les 120 sorties générées seront autant d'entiers uniques que possible, allant de 1 à 120 inclus.

Autrement dit, pour chacune des 120 permutations de vos 5 caractères produisant du code exécutable produisant un seul nombre, vous voulez que l'ensemble de tous ces nombres corresponde autant que possible à l'ensemble des entiers compris entre 1 et 120.

Donc, idéalement, votre première permutation produirait 1, la suivante 2, la suivante 3, jusqu’à 120. Mais cet idéal est probablement impossible pour la plupart des langues et des personnages.

Les chaînes de 5 caractères peuvent être exécutées comme suit:

  • un programme sans entrée
  • une fonction sans argument
  • une commande REPL

Différentes chaînes peuvent être exécutées de différentes manières si vous le souhaitez

Pour que la sortie compte, il doit s'agir d'une sortie entière unique de manière normale , telle que:

  • en cours d'impression sur la sortie standard
  • retourné par la fonction
  • le résultat de l'expression REPL

Le code doit se terminer normalement (ce qui peut impliquer une erreur tant que le numéro a été sorti en premier). Le code qui ne fonctionne pas du tout va bien, juste la sortie (inexistante) ne compte pas. La sortie numérique doit être en décimal, sauf si une base différente est la norme pour votre langue.

La soumission qui génère les nombres les plus distincts de 1 à 120 gagne. La soumission précédente l'emporte en cas d'égalité.

Remarques

  • Vos 5 caractères ne doivent pas tous être différents, mais le fait de dupliquer les caractères réduit bien entendu le nombre de permutations.
  • Les sorties float telles que 32.0count et plain 32. (Mais 32.01ne serait pas.)
  • Les zéros non significatifs tels que 032count et plain 32.
  • Les sorties valides doivent être déterministes et invariantes dans le temps.
  • Nous traitons avec des caractères , pas des octets.

Exemple

Les caractères 123+*sont un premier choix raisonnable pour le REPL de Python (ou de nombreux langages). Les 120 permutations et sorties résultantes sont:

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

Il y a 36 numéros générés, tous heureusement entre 1 et 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

Cependant, seuls 8 d'entre eux sont uniques:

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

Donc, une telle soumission ne marquerait que 8 sur un maximum de 120.

Les passe-temps de Calvin
la source
21
Je veux relever ce défi mais il me semble IMPOSSIBLE dans des clangages similaires !!!
Mukul Kumar
3
@MukulKumar Je pense qu'il existe également des REPL en langage similaire à C (par exemple, gdb peut être utilisé - dans une certaine mesure - en tant que REPL pour C), de sorte que l'approche démontrée pour Python reste une option.
Martin Ender
1
Connexes (lien fixe).
Fataliser
3
@ ETH Non à la vraie chose. C'est comme autoriser une autre base.
Hobbies de Calvin
3
@ OldBunny2800 Les sorties valides doivent être déterministes et invariantes dans le temps.
Dennis

Réponses:

41

Python3, 21 27 valeurs

Personnages: 3479%

Numéros uniques: [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]

Comme il était demandé, voici les permutations qui se situent dans la plage [1, 120] . Essayez-le en ligne!

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
la source
2
Ne pourriez-vous pas obtenir de meilleurs résultats en Python 2, où se /trouve la division entière?
Neil
@Kade Me aussi. La plus grande que j'ai essayée était quelque chose dans les lignes de "0123456789 * - + & |% ^ 0123456789"
Yytsi
Il y a 2 autres choix à cela: le même nombre de valeurs: 5679%et5789%
Gábor Fekete
FYI - Ceci (ou le 5679%et 5789%ceux) est probablement aussi optimal pour PowerShell.
AdmBorkBork
J'ai eu cette réponse (avec 5679%et 5798%) également grâce à une recherche exhaustive de toutes les combinaisons de 0123456789+-*/&|^#%remplacement. Je conviens que ce sont probablement optimales.
JaredL
34

05AB1E , 27 38 41 numéros

4·>Ìn

Génère les numéros uniques:

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

Utilise la constante 4avec les opérations +1, +2, *2et ^2.

Emigna
la source
N'a pas été testé, mais utiliserait-il -au lieu de +produire une plus grande variété de résultats basés sur sa propriété non commutative?
Osable
@Osable: J'ai aussi testé avec -, mais jamais plus de 30 numéros uniques. L'un des problèmes est que vous obtenez également des valeurs négatives qui sont en dehors de la plage. Peut-être qu'avec des opérateurs remplacés, cela pourrait être mieux, mais je n'ai pas trouvé d'amélioration à ce jour.
Emigna
D'accord, j'ai sauté la partie (bien que dans un style gras) en disant que la sortie doit être dans la plage [1 120]. Mon mauvais
Osable
J'ai essayé pendant un moment et plafonné à ~ 35 sur tout le reste.
Magic Octopus Urn
32

Python, 18 chiffres

237#-

Produit des résultats valides:

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

EDIT: Je peux attester que la solution de TuukkaX est optimale pour Python. J'ai exécuté le code suivant pour renforcer toutes les combinaisons possibles de 5 caractères ASCII imprimables:

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

Les résultats (après avoir fonctionné pendant près de 7 heures) ont montré que la solution est en fait 27 numéros différents, produits par trois solutions différentes tout en utilisant quatre chiffres et mod ( %): %3479, %5679et %5789.

Leo
la source
25
@ TùxCräftîñg En réalité, un ensemble est une collection non ordonnée.
Leo
2
@ TùxCräftîñg https://repl.it/El9V/0 bien que les ensembles de cours utilisent un tri interne pour garder une trace des éléments, le fait est que vous ne pouvez pas vous fier à ce tri, car les éléments ne sont pas nécessairement triés dans l'ordre attendez-vous à ce qu'ils soient
Leo
1
@TuukkaX Je vois que c'est un comportement inattendu et cause plus de problèmes qu'il n'en résout, alors je l'ai édité. Désolé pour le désagrément :)
Leo
1
@ hBy2Py Si vous ne faites aucune autre opération sur le plateau entre les deux itérations, je pense que vous pouvez supposer que les deux itérations suivront le même ordre. En règle générale, cependant, la règle veut que les ensembles soient des collections non ordonnées. Vous ne devez donc jamais vous fier à un ordre quelconque.
Leo
3
@Leo Got it: les sets sont en nitroglycérine. Raisonnablement stable à moins de les cogner.
hBy2Py
23

Java 8, 2 4 chiffres

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

Vous n'attendiez pas de réponse Java, n'est-ce pas?

C'est un lambda qui ne peut être arrangé que de deux manières (et avec deux chiffres différents!) Pour un total de deux numéros uniques. Tout le reste n'est pas un lambda valide.

En fait, la réponse a été améliorée grâce à l'aide de commentaires! Je n'ai pas vu que 0 n'était pas valide et j'ai oublié que les variables pouvaient, vous savez, être plus d'un caractère. Nous en avons 4!

Une solution encore pire

()->1

Mais du côté positif, deux réponses uniques en Java!

Xanderhall
la source
2
Est-ce que Java a un REPL? Tu peux peut-être utiliser plus de symboles de cette façon
Arturo Torres Sánchez
Je n'ai aucune idée. Je suis enclin à dire non. En outre, ma réponse deviendrait fondamentalement un copypaste des autres réponses REPL: P
Xanderhall
3
Java 9 aura un REPL vanille !! Mais pour l'instant nous sommes coincés avec des trucs de tiers .
NonlinearFruit
17
Je pense que vous pouvez faire mieux avec n->12. Cela vous donne quatre réponses distinctes qui sont toutes dans la plage: n->12, n->21, n1->2, n2->1.
2
Java 9 et son REPL sont disponibles dans une version à accès anticipé aujourd'hui. En fait, j'ai soumis des réponses à d'autres questions ici en l'utilisant.
David Conrad
18

Gelée, 26 30 32 numéros

‘’3²Ḥ

Ceci (et ses anagrammes) sont des programmes complets, qui ne prennent aucune entrée et produisent une sortie sur une sortie standard.

Les résultats des 120 programmes sont, dans l'ordre que Jelly les génère si vous lui demandez de générer des permutations du programme:

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

Si vous prenez simplement les sorties uniques dans l'ordre numérique, vous obtenez:

-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

Beaucoup d'entre eux sont trop petits et 135 sont trop grands, mais il en reste 32 qui sont dans la gamme.

L'idée de base est d'utiliser principalement des instructions monadiques (dans un programme contenant uniquement des monades et des nilads, celles-ci ne faisant que transformer la sortie précédente), ainsi que celles permettant à la valeur de diverger rapidement. L'exception est avec 3, qui est un nilad (la valeur constante 3). S'il apparaît au début du programme, toutes les opérations seront effectuées à partir de 3. S'il apparaît au milieu, le programme est divisé en deux moitiés, chacune générant un entier (et imprimant chacune sur une sortie standard, les résultats finissent par être concaténés, nous donnant ainsi la "concaténation" en tant qu’opération supplémentaire pour générer des nombres).

Les opérations que nous avons ici, dans le contexte dans lequel le programme les génère, sont les suivantes: incrémentation; décrémenter; constante 3; carré; et double. Incrémenter et décrémenter sont malheureusement des opposés, et décrémenter a une fâcheuse tendance à produire -1 ou -2 dans la première section (conduisant ainsi à un nombre global négatif), mais cela a tout de même donné une plus grande étendue de sorties que les autres choses que j'ai essayées . En particulier, nous obtenons une assez bonne dispersion des première et deuxième moitiés du nombre (notez que la première moitié peut être la chaîne vide, si 3est le premier caractère du programme).


la source
@TuukkaX c'est le cas, j'ai implémenté le monadique Œ¿et le dyadique œ¿(voir au bas de la page des atomes du wiki ), mais ce sont deux dyades à deux octets qui réduiront les permutations de code qui font ce que vous voulez, plus vous aurez besoin toutes vos entrées sont des listes ( 12n'est pas une liste).
Jonathan Allan
16

JavaScript, 27 chiffres

Très similaire à la réponse de TuukkaX , avec un autre ensemble de chiffres.

5789%

Les 27 valeurs distinctes sont:

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
la source
utiliserait-il pas bitwise ~, aider du tout? C'est une opération unaire qui peut être utile.
JollyJoker
1
@JollyJoker Eh bien, le meilleur que je puisse trouver jusqu'à présent ~est celui 257&~qui produit onze valeurs distinctes.
Arnauld
Je suis un peu surpris, mais je suppose que mon intuition n'est pas très bonne ici.
JollyJoker
15

Brachylog , 26 chiffres

3+*^-

Cela génère les nombres suivants: [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]

Explication

  • 3 est le nombre entier 3, évidemment.
  • + est incrément
  • * est double
  • ^ est carré
  • - est décrément

Il y a beaucoup de situations où le programme commet simplement des erreurs: par exemple *+^3-, parce qu'il demande «Prends 0, double-le, incrément, carré, le résultat de ce carré est 3, décrément», ce qui est évidemment faux.

Tout programme qui se termine avec 3soit sortie 3ou ne fonctionne pas.

Tout programme qui commence par *3sera bouclé indéfiniment à cause d’un bogue (Brachylog tente de trouver une liste de sous-listes dont le produit produit 3, ce qui n’est pas possible).

Fataliser
la source
1
Bonne réponse et rien au sujet du golf, mais en mathématiques, vous pouvez obtenir n’importe quel nombre jusqu’à 121 en ajoutant ou en diminuant les cinq premières puissances de 3, 1,3,9,27 et 81. Espérons que cela aide.
Timide
11

Vim, 16 chiffres

i1234

impression

1, 2, 3, 4, 12, 13, 14, 21, 23, 24, 31, 32, 34, 41, 42, 43
Sefa
la source
1
@ymbirtt Où est passé le 3et le 4va? Vous avez besoin de toutes les permutations de longueur 5.
Kade
i1234imprime "1234", est-ce une sorte de script ou de frappe? Si vous appuyez sur les touches, cela ne fonctionne pas.
Captain Man
En développant le point de @Captain Man, le moyen évident d’exécuter les permutations en tant que script serait avec: norm. Cela n'imprime cependant aucun nombre dans la plage 1-120. Aviez-vous une autre méthode en tête?
Simon
Vous pouvez les mettre dans l'interpréteur en ligne pour V qui est plus ou moins compatible avec Vim
nmjcman101
4
@ nmjcman101 Dans ce cas, il tombe dans le trou de "la plupart du temps" puisque 12i34 en V résulte en 12 occurrences de 34 où, comme si vous le tapiez dans vim, il vous en donnait simplement 34 (je suppose que V suppose une escale finale)
Voir le
11

IA-32 code machine, 8 chiffres

Valeurs d'octet hexadécimales:

2c 40 48 b0 c3

Le code est exécuté en tant que fonction renvoyant la valeur dans al.

Permutations valables:

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)

J'ai effectué une recherche en force brute, avec les contraintes suivantes:

  • Le premier octet est b0- pour initialiser le alregistre
  • Le dernier octet est c3- return; les octets suivants sont supprimés
  • Les octets d'opcode possibles sont:
    • 0x04 - add
    • 0x0c - or
    • 0x24 - and
    • 0x2c - sub
    • 0x34 - xor
    • 0xd4 - aad
    • 0x40 - inc
    • 0x48 - dec

Cela ne laisse que 3 octets modifiables avec un maximum de 15 résultats possibles. Parmi ceux-ci, un maximum de 9 peut être distinct (en fait, cela se produit pour un seul jeu d'octets!). Une des valeurs est en dehors des limites, il reste donc 8 valeurs. Il y a une autre série d'octets

34 40 48 b0 c3

qui donne également 8 valeurs distinctes - les programmes sont les mêmes, à l’exception de ceux qui sont subremplacés par xor, ce qui rend deux des sorties possibles identiques.

Tous les autres ensembles d'octets donnent 7 résultats possibles ou moins.

anatolyg
la source
10

Gelée , 33 numéros

Ḥ23+c

double (gauche);
2littéral 2;
3littéral 3;
+ajouter (gauche, droite); et
cchoisissez (gauche, droite), c’est-à-dire le nombre de façons de choisir les objets de droite dans une collection d’objets de gauche.

Nombre de résultats fournis avec un exemple de programme:

 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

J'ai essayé de choisir facile à analyser ceux, mais certains sont rares et un peu étrange à analyser, par exemple 23est:

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

... et 72et 13utiliser l' impression implicite:

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)

Notez que Ḥ34+cproduit également des 33valeurs uniques dans [1,120].

Jonathan Allan
la source
10

Brain-Flak 1

(())#

Brain-Flak nécessite des accolades équilibrées, de sorte qu'un programme de 5 caractères n'est valide que si l'un des caractères commence un commentaire. Cela nous laisse avec 4 personnages avec qui travailler. Parmi ceux-ci, 2 doivent être (et )sinon rien ne serait mis sur la pile. Ceux-ci doivent aller en premier et 4ème avec le commentaire last ( (..)#). Maintenant , nous pouvons mettre (), {}, <>ou à l' []intérieur. {}, <>et []chaque valeur est évaluée à 0, mais ()vaut 1. Cela signifie que (())#c'est la seule chaîne de 5 caractères qui produit un programme Brain-Flak valide.

Essayez-le en ligne!

Si la question était plutôt "quels sont les 6 personnages les plus puissants", la réponse serait (){}[]que Brain-Flak est complètement terminé en utilisant uniquement ce sous-ensemble.

Riley
la source
Fonctionnalité mal documentée: l' @ijindicateur de mise au point met le programme en pause et permet à l'utilisateur de saisir le code de la flak-brain à exécuter là où l' @ijindicateur est apparu dans le code. Assez puissant, mais nécessite malheureusement une intervention de l'utilisateur et n'est donc pas utile ici.
0 '15
Légère correction: (){}[]marquerait 0. Vous avez oublié la règle des permutations;)
CalculatorFeline
8

Hexagonie , 13 chiffres

)24!@

Ce sont les 13 numéros imprimables avec un programme possible pour chacun d'eux:

)!@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

Les programmes devraient être assez explicites. @termine le programme, !affiche la valeur actuelle, l’ )incrémente 2et 4s’ajoute à la valeur actuelle (où la valeur initiale est 0). La disposition hexagonale réelle du code source est sans importance ici, les programmes peuvent simplement être lus de gauche à droite.

Cela devrait être optimal, bien qu'au lieu de 2et que 4vous puissiez choisir n'importe quelle paire de chiffres xet ytelle que 2 ≤ x ≤ y-2.

La solution ci-dessus a été trouvée par force brute (presque exhaustive), en exigeant une !(sinon elle n’imprimerait rien), une @(sinon le programme ne se terminera pas) et en remplissant les trois caractères restants avec toute combinaison (répétée) du ensemble de caractères suivant:

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

Je ne vois pas comment les autres commandes pourraient éventuellement générer plus de variété.

Martin Ender
la source
J'allais aussi poster une réponse dans Labyrinth, mais le même ensemble de solutions semble être optimal là aussi (avec effectivement la même sémantique).
Martin Ender
7

Perl, 27 chiffres

3479%

Perl n'a pas de REPL intégré, vous pouvez donc utiliser à re.plpartir de Devel :: REPL .

Résultats:

%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-forcé en utilisant le programme suivant:

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
la source
Perl a effectivement quelque chose de très proche d'un REPL intégré. Essayez de courir un perl -de 1peu de temps. Techniquement, cela ouvre le débogueur sur un programme vide, mais le débogueur a une structure similaire à celle de REPL. Malheureusement, vous devez écrire p au début de chaque ligne pour que le résultat soit réellement imprimé.
@ ais523 C'est pourquoi je ne l'ai pas mentionné; vous ne pouvez pas simplement taper la chaîne elle-même et obtenir une sortie, ce qui est l'une des exigences.
ThisSuitIsBlackNot
7

R, 15 18 numéros

Ce n’est pas un nombre énorme, mais c’est peut-être ce qui se fait de mieux avec R. J’ai recherché toutes les combinaisons de chiffres 0..9, d’opérateurs + - * / ^et de caractères de commentaire #, et les huit suivants ont tous généré 18 entiers uniques compris entre 1 et 120.

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

À titre d'exemple, prenons -#146. Voici les 18 entiers que nous pouvons obtenir:

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

Si vous êtes curieux de connaître le code (laid) utilisé pour tester toutes les combinaisons possibles, le voici. Il génère le nombre d'entiers uniques compris entre 1 et 120 pour chaque combinaison de caractères de longueur 5 dans un fichier appelé "fichier de données" dans le répertoire de travail en cours.

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)
      }
)
tourbull
la source
Vous dites que c'est du code laid ... Je pense que c'est beau! Les nombreuses utilisations de apply ne cessent de m'étonner!
Sumner18
6

Octave, 18

Cela a été trouvé en utilisant une recherche bruteforce sur les symboles *+-/0123456789:;<\^|~%. Mais il a fallu beaucoup trop de temps pour calculer ...

-139%

Sorties possibles:

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

Octave, 15 numéros

Pas grand chose à se vanter, mais c'est le meilleur que je puisse avoir dans Octave:

124+%

Il donne les chiffres:

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

J'ai aussi 16 ans, mais il semble que cela soit identique à la réponse de Sefa ...

1234%

1    2    3    4   12   13   14   21   23   24   31   32   34   41   42   43
Stewie Griffin
la source
D' après mes tests, le choix optimal à partir 0123456789+-*.%d'octave est 139-%, qui produit un tableau de 18: 1 2 3 4 6 8 9 13 16 19 22 31 38 39 88 91 92 93. Vous pouvez donc gagner 3 autres chiffres :)
2
force brute très brutale que j'ai utilisé pour obtenir la solution à 18 chiffres: pastebin.com/umckG0VS
2
J'ai trouvé cette solution aussi, mais c'était après avoir vu la soumission de Python et c'est essentiellement la même chose. Beau travail de faire un script de force brute. 😊
Stewie Griffin
4

PHP, 15 chiffres

1230\r

Utilise le fait que php imprime quoi que ce soit en dehors de ses balises verbatim (sans l'utiliser, vous pouvez faire exactement 1 chiffre avec quelque chose comme <?=1;). Utilise également un caractère de retour chariot réel plutôt que \r.

Crée (trie, supprime les 0 premiers):

 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

dont les numéros uniques valides sont:

1 2 3 10 12 13 20 21 23 30 31 32 102 103 120
utilisateur59178
la source
3
Cela n'imprime pas vraiment ces chiffres cependant. 12\r30impressions 12\r30, le terminal écrase simplement les deux premiers caractères.
Dennis
@Dennis C'est comme dire que dans tout défi qui requiert la technique des caractères de contrôle pour écraser du texte, le résultat n'est pas ce qui est vu à la fin, mais la somme des octets écrits. Puisque \rn'est pas imprimable, le résultat de 12\r30est 30.
chat
3
@cat Nous en avons discuté sur la méta ; L'utilisation de caractères de contrôle n'est autorisée que si le défi est lié à l'art ASCII.
Dennis
4

Cubix , 7 chiffres

"2)@O

Sorties ces nombres:

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

Tout programme Cubix valide pour ce défi doit avoir la possibilité Ode générer un entier et @de terminer le programme (Cubix n'a jamais entendu parler d '"erreurs"). Cela nous donne 3 caractères à jouer pour générer le plus grand nombre de sorties. De plus, en raison de la manière dont Cubix organise le code sur un cube, le premier caractère sera inutile si l'un des autres n'est pas un caractère directionnel.

Le moyen le plus efficace que j'ai trouvé pour générer plusieurs nombres consiste à utiliser "une chaîne de codes de caractères dans la pile. Avec un réarrangement soigneux, nous pouvons insérer plusieurs caractères dans la dernière position et simplement sortir leurs codes. En utilisant )pour incrémenter le premier élément, nous pouvons créer des sorties supplémentaires à partir de plusieurs de ces arrangements.

Deux types de programmes de base sont utilisés ici. La première est la suivante:

"2)O@

qui s'étend à

  "
2 ) O @
  .

Le programme résultant pousse 2dans la pile, l'incrémente avec ), affiche avec Oet se termine avec @.

La seconde est la suivante:

2")O@

qui s'étend à

  2
" ) O @
  .

Le programme résultant pousse les codes de caractères de ), Oet @incrémente le dernier avec ), sort avec O, et termine avec @.

ETHproductions
la source
3

> <> , 6 chiffres

Gagné 2 numéros grâce à Teal Pelican

1ln";

Produit les numéros uniques [1, 4, 5, 49, 59, 108]

Nous devons nimprimer un numéro.
Nous devons ;terminer.

Cela ne nous laisse que 3 personnages avec lesquels travailler.

Quelques combinaisons différentes de value& operatoravec ont "confirmé produire 6 valeurs uniques, mais je n'ai rien trouvé de mieux que ça.

Emigna
la source
J'ai essayé de résoudre ce problème, mais cela ne produit-il pas seulement 4 chiffres? comme la gamme est 1-120 pas 0-120?
Pélican sarcelle
@Tealpelican: Correct. Je m'en suis rendu compte en rentrant du travail et j'étais sur le point de le réparer.
Emigna
J'ai examiné un peu plus certains programmes de pêche comme les quines et hello world, etc., et j'ai eu une idée. Quelque chose utilisant les personnages comme ceci; 1n; + "générerait 6+ à partir d'un calcul rapide (en utilisant la fonction de boucle et les chaînes à notre avantage) - cela pourrait valoir la peine de vérifier avec des valeurs différentes pour 1 et opérations.
Teal pélican,
@Tealpelican: C'est une bonne idée.
Emigna
3

Groovy, 10 numéros

Les solutions JVM Man sont BAD pour cela ... Qui le savait?

1200+

Résulte en:

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

Attends quoi? Comment diable cela vous fait-il demander?

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.

Le secret commercial, dans les entiers Groovy / Java précédés d'un 0 sont des octaux. Code que j'ai utilisé pour tester les réponses Groovy au cas où quelqu'un voudrait me battre:

("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();​
Urne Magique De Pieuvre
la source
Je suppose que la même réponse fonctionnerait également pour Java.
Paŭlo Ebermann
3

MATL, 15 numéros

0123%

% est l'opérateur de commentaires, donc il "coupera" à tous les endroits possibles une fois, contribuant ainsi à créer toutes les combinaisons possibles des chiffres donnés et de leurs sous-ensembles:

1
2
3
10
12
13
20
21
23
30
31
32
102
103
120
Cedric Reichenbach
la source
3

J, 16 numéros

1234]

Rien d'extraordinaire, juste testé 1234avec tous les verbes à un caractère qui étaient raisonnables. ]sélectionne son bon argument.

Les numéros uniques produits sont

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

dont 16:

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

Sont dans la gamme [1.120].

Testé avec

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

Japt , 41 numéros

Pratiquement des essais et des erreurs, il pourrait donc y avoir une meilleure solution. Utilise les entiers 3& 4et les raccourcis Japt pour la quadrature, l’ajout 1et la multiplication par 2. Les 120 programmes affichent tous un entier, >0mais seulement 78 le sont <=120et 41 seulement sont uniques.

34²ÄÑ

Génère les nombres:

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

Afficher la liste des numéros ou la collection de programmes valides


Explication

Quelques points à noter à propos de Japt qui sont pertinents ici sont:

  1. Si un programme ne commence pas (dans ce cas) par l’un des chiffres, la première variable d’entrée U, définie par défaut 0, est automatiquement insérée au début,
  2. Si l'un des chiffres ou les deux suivent immédiatement l'un des raccourcis d'une opération mathématique, ils y sont ajoutés (par exemple, 3Ä4 = 3+14 = 17et de la même manière 4Ѳ = 4*2**2 = 16), et
  3. Si l'un des chiffres suit immédiatement le, ²alors le ²et tout ce qui le précède est essentiellement ignoré.

Explications pour quelques programmes (production 1, 3, 37et 93, respectivement):

²Ñ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
Hirsute
la source
2

Befunge, 11 chiffres

Befunge est un peu limité car il ne supporte que les littéraux à un chiffre. Donc, le mieux que j'ai pu trouver était 11 chiffres, en supposant que le calcul doit nous laisser un et un seul nombre sur la pile.

Meilleurs personnages: 358*%

Nombre généré: (juste un exemple de chaque)

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
la source
2

Python, 16 chiffres

1234#

Utilise # pour mettre en commentaire tous les nombres inutiles.

OldBunny2800
la source
2

dc, 19 numéros

*3zO+

La sortie se trouve en haut de la pile et les erreurs (y compris le dépassement de capacité de la pile) sont ignorées. Les permutations valables sont:

+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

Voici le programme Python que j'ai utilisé pour montrer ces résultats:

#!/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))

Deux autres chaînes qui donnent le même score de 19 sont 32d+*et *4zO+.

Toby Speight
la source
2

Smalltalk, 26 chiffres

1235r

Explication: 12r35 est une notation pour utiliser la base 12, et est donc 3 * 12 + 5.
Cela peut être vérifié dans Squeak:

((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

donne:

#(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)

Si nous remplaçons la dernière ligne par:

    sorted: #value ascending)

on obtient alors les expressions:

'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

Je voulais tricher et définir une méthode r dans Integer comme

Integer>>r
    ^self \\ 120 + 1

Malheureusement, le compilateur opte pour 1235r car il reconnaît un nombre inachevé avec radix plutôt qu'un message envoyé à 1235 ...
Je pourrais facilement changer de compilateur aussi, mais c'est un peu trop un tricheur à mon goût.

aka.nice
la source
1

Mathematica, 16 chiffres

;1234

Pas très intéressant, mais je n'arrive pas à trouver quoi que ce soit de mieux en arithmétique. La seule chose qui pourrait fonctionner est d'utiliser !factorielle ou double factorielle, mais cela est tellement enclin à générer des nombres énormes qu'il est impossible de recourir à la force brutale.

Les 16 chiffres (dans la plage) pouvant être générés à partir des 5 caractères ci-dessus sont:

1, 2, 3, 4, 12, 13, 14, 21, 23, 24, 31, 32, 34, 41, 42, 43
Martin Ender
la source
Pourquoi pas; 6789?
David G. Stork
1

Enchantements runiques, 19 numéros

234p@

Essentiellement 3 littéraux, l'opérateur pow et une commande "imprimer toute la pile et se terminer". 234p@estampes 812 (3 ^ 4 jointes avec un 2). Liste de permutation complète , note qui @a été remplacée par ak@afin de générer une nouvelle ligne entre chaque résultat et >a été ajoutée pour assurer que chaque ligne s'exécute indépendamment. Notez également que les sorties ne sont pas dans le même ordre que les programmes qui les ont générées (certains programmes pouvant se terminer plus rapidement).

Beaucoup de permutations n'impriment rien (par exemple @234pou p234@), mais 19 aboutissent à une sortie dans la plage autorisée.

Nombres possibles (et un programme possible qui en résulte; .indique que ces positions peuvent être n'importe quel caractère restant car elles ne sont pas exécutées):

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
la source
1

TI-BASIC, 12 chiffres

23+4!

Il y a probablement une meilleure combinaison, mais je n'ai pas réussi à la trouver.

24

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

12

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

Tau
la source