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.

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

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.

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.

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!

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

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

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

Vim, 16 chiffres

i1234

impression

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

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.

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

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.

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

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

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

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

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

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

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

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

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();​

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

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

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

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

Python, 16 chiffres

1234#

Utilise # pour mettre en commentaire tous les nombres inutiles.

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

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.

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

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

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$

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