Scegli cinque caratteri supportati dalla tua lingua. Ce ne sono 5! = 5 × 4 × 3 × 2 × 1 = 120 modi in cui questi possono essere disposti in una stringa di 5 caratteri che contiene ogni carattere una volta; 120 permutazioni .

Scegli i tuoi caratteri in modo tale che, quando ciascuna delle 120 stringhe viene eseguita nella tua lingua, le 120 uscite prodotte saranno quanti più numeri interi unici compresi tra 1 e 120 (inclusi).

Cioè, per ciascuna delle 120 permutazioni dei tuoi 5 caratteri che producono codice eseguibile che genera un singolo numero, vuoi che l'insieme di tutti quei numeri corrisponda il più vicino possibile all'insieme di numeri interi da 1 a 120.

Quindi, idealmente, la tua prima permutazione sarebbe in uscita 1, la successiva 2, la successiva 3, fino a 120. Ma l'ideale è probabilmente impossibile per la maggior parte delle lingue e dei caratteri.

Le stringhe di 5 caratteri possono essere eseguite come:

• un programma senza input
• una funzione senza argomenti
• un comando REPL

Se lo si desidera, è possibile eseguire stringhe diverse in modi diversi

Affinché l'output venga conteggiato, deve essere un singolo output intero in modo normale , ad esempio:

• in fase di stampa su stdout
• restituito dalla funzione
• il risultato dell'espressione REPL

Il codice dovrebbe terminare normalmente (il che può comportare errori fino a quando il numero è stato emesso per primo). Il codice che non funziona affatto va bene, solo l'output (inesistente) non conta. L'output dei numeri dovrebbe essere in decimali a meno che una base diversa non sia la norma per la tua lingua.

La proposta che genera i numeri più distinti da 1 a 120 vince. La presentazione precedente vince in caso di pareggio.

Appunti

• I tuoi 5 personaggi non devono essere tutti diversi, ma ovviamente avere caratteri duplicati riduce il numero effettivo di permutazioni.
• Uscite float come 32.0count e pure 32. (Ma 32.01non lo farebbe.)
• Zeri iniziali come 032count e pure 32.
• I risultati validi dovrebbero essere deterministici e invarianti nel tempo.
• Abbiamo a che fare con personaggi , non byte.

Esempio

I personaggi 123+*sono una prima scelta ragionevole per il REPL di Python (o di molte lingue). Le 120 permutazioni e uscite risultanti sono:

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

Ci sono 36 numeri generati, tutti fortunatamente tra 1 e 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

Tuttavia, solo 8 di loro sono unici:

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

Quindi una tale presentazione otterrebbe solo un punteggio di 8 su un massimo di 120.

Python3, 21 27 valori

Personaggi: 3479%

Numeri univoci: [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]

Come è stato richiesto, ecco le permutazioni che rientrano nell'intervallo [1, 120] . Provalo online!

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

05AB1E , 27 38 41 numeri

4·>Ìn

Genera i numeri univoci:

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

Utilizza la costante 4con le operazioni +1, +2, *2e ^2.

Python, 18 numeri

237#-

Produce come risultati validi:

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

EDIT: posso attestare che la soluzione di TuukkaX è ottimale per Python. Ho eseguito il seguente codice bruteforcing tutte le possibili combinazioni di 5 caratteri ASCII stampabili:

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

I risultati (dopo l'esecuzione per quasi 7 ore) hanno mostrato che la soluzione ottimale è infatti 27 numeri diversi, prodotti da tre diverse soluzioni tutto utilizzando quattro numeri e mod ( %): %3479, %5679e %5789.

Java 8, 2 4 numeri

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

Non ti aspettavi una risposta Java, vero?

Questo è un lambda che può essere organizzato solo in due modi (e con due cifre diverse!) Per un totale di due numeri univoci. Tutto il resto non è un lambda valido.

In realtà ha migliorato la risposta, grazie ad un aiuto dai commenti! Non ho visto che 0 non era valido e ho dimenticato che le variabili potrebbero essere più di un carattere. Ne abbiamo 4!

Una soluzione ancora peggiore

()->1

Ma, il lato positivo, due risposte uniche in Java!

Gelatina, 26 30 32 numeri

‘’3²Ḥ

Questo (e i suoi anagrammi) sono programmi completi, che non accettano input e producono output su output standard.

Gli output dei 120 programmi sono, nell'ordine in cui Jelly li genera se gli chiedi di generare permutazioni del programma:

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

Se prendi semplicemente gli output unici in ordine numerico, otterrai:

-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

Molti di questi sono troppo piccoli e 135 è troppo grande, ma ci sono ancora 32 che sono nel raggio.

L'idea di base è usare principalmente le istruzioni monadiche (in un programma con solo monadi e nilad, ognuna delle quali trasforma l'output precedente) e quelle che permettono al valore di divergere rapidamente. L'eccezione è con 3, che è un nilad (il valore costante 3). Se appare all'avvio del programma, tutte le operazioni verranno eseguite da 3. Se appare nel mezzo, divide il programma in due metà, ognuna delle quali genera un numero intero (e mentre stampano ciascuna sull'output standard, i risultati finiscono per essere concatenati, dandoci così "concatenare" come operazione aggiuntiva per generare numeri).

Le operazioni che abbiamo qui, nel contesto in cui il programma le genera, sono: incremento; decremento; costante 3; piazza; e doppio. L'incremento e il decremento sono purtroppo opposti e il decremento ha una sfortunata tendenza a produrre un -1 o -2 nella prima sezione (portando quindi a un numero negativo complessivo), ma ciò ha comunque dato una maggiore diffusione di output rispetto alle altre cose che ho provato . In particolare, otteniamo una diffusione abbastanza buona della prima e della seconda metà del numero (si noti che la prima metà può essere la stringa nulla, se 3è il primo carattere nel programma).

JavaScript, 27 numeri

Molto simile alla risposta di TuukkaX , con un'altra serie di cifre.

5789%

I 27 valori distinti sono:

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 numeri

3+*^-

Questo genera i seguenti numeri: [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]

Spiegazione

• 3 è il numero intero 3, ovviamente.
• + è incremento
• * è doppio
• ^ è quadrato
• - è decremento

Ci sono molte situazioni in cui il programma si limita ad errori: ad esempio *+^3-errori perché chiede "Prendi 0, raddoppialo, incrementa, quadrato, il risultato di quel quadrato è 3, decrementa" che è ovviamente sbagliato.

Qualsiasi programma che termina 3verrà emesso 3o non funzionerà.

Qualsiasi programma che inizia con un *3ciclo infinito a causa di un bug (Brachylog sta tentando di trovare un elenco di elenchi secondari il cui prodotto risulta in 3 che non è possibile).

Vim, 16 numeri

i1234

Stampa

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

Codice macchina IA-32, 8 numeri

Valori byte esadecimali:

2c 40 48 b0 c3

Il codice viene eseguito come funzione che restituisce il valore al.

Permutazioni valide:

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)

Ho fatto una ricerca di forza bruta, con i seguenti vincoli:

• Il primo byte è b0- per inizializzare il alregistro
• L'ultimo byte è c3- return; i byte seguenti vengono eliminati
• I byte opcode possibili sono:
  • 0x04 - add
  • 0x0c - or
  • 0x24 - and
  • 0x2c - sub
  • 0x34 - xor
  • 0xd4 - aad
  • 0x40 - inc
  • 0x48 - dec

Ciò lascia solo 3 byte modificabili con un massimo di 15 possibili risultati. Di questi, è possibile distinguere un massimo di 9 (in effetti, ciò accade solo per un set di byte!). Uno dei valori non è compreso nell'intervallo, quindi rimangono 8 valori. C'è un altro set di byte

34 40 48 b0 c3

che fornisce anche 8 valori distinti: i programmi sono gli stessi, tranne quelli subsostituiti da xor, il che rende identici due dei possibili output.

Tutti gli altri insiemi di byte danno 7 o meno risultati possibili.

Gelatina , 33 numeri

Ḥ23+c

Ḥdoppio (sinistra);
2letterale 2;
3letterale 3;
+aggiungi (sinistra, destra); e
cscegli (sinistra, destra), ovvero il numero di modi per scegliere gli oggetti giusti da una raccolta di oggetti sinistri.

Numeri ottenuti con un programma di esempio:

 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

Ho provato a scegliere quelli facili da analizzare, ma alcuni sono rari e leggermente strani da analizzare, ad esempio 23è:

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

... e 72e 13utilizzare la stampa implicita:

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)

Si noti che Ḥ34+cproduce anche 33valori univoci in [1,120].

Brain-Flak 1

(())#

Brain-Flak richiede parentesi graffe bilanciate, quindi un programma a 5 caratteri è valido solo se uno dei personaggi inizia un commento. Questo ci lascia con 4 personaggi con cui lavorare. Di questi, 2 devono essere (e )altrimenti nulla verrebbe inserito nello stack. Quelli devono andare primo e quarto con il commento last ( (..)#). Ora siamo in grado di mettere (), {}, <>, o []dentro. {}, <>e []valutano ciascuno a 0, ma ()è 1. Ciò significa che (())#è l'unica stringa di 5 caratteri che produce un programma Brain-Flak valido.

Provalo online!

Se la domanda fosse invece "quali sono i 6 personaggi più potenti", la risposta sarebbe (){}[]come Brain-Flak sta diventando completo usando solo questo sottoinsieme.

Esagonia , 13 numeri

)24!@

Questi sono i 13 numeri stampabili con un possibile programma per ciascuno di essi:

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

I programmi dovrebbero essere abbastanza esplicativi. @termina il programma, !stampa il valore corrente, lo )incrementa 2e si 4aggiunge al valore corrente (dove si trova il valore iniziale 0). Il layout esagonale effettivo del codice sorgente è irrilevante qui, i programmi possono essere semplicemente letti da sinistra a destra.

Questo dovrebbe essere ottimale, anche se invece di 2e 4puoi scegliere qualsiasi coppia di cifre xe ytale 2 ≤ x ≤ y-2.

La soluzione di cui sopra è stata trovata da una forza bruta (quasi esaustiva), che richiede uno !(altrimenti non stamperebbe nulla), uno @(altrimenti il ​​programma non terminerà) e riempiendo i rimanenti tre caratteri con qualsiasi combinazione (ripetuta) dal seguente set di caratteri:

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

Non riesco a vedere come nessuno degli altri comandi possa generare più varietà.

Perl, 27 numeri

3479%

Perl non ha un REPL integrato, quindi puoi usarlo re.plda Devel :: REPL .

risultati:

%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-force usando il seguente programma:

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 numeri

Non è un numero enorme, ma potrebbe essere il migliore che si possa fare con R. Ho cercato tutte le combinazioni di cifre 0..9, operatori + - * / ^e il carattere di commento #, e gli otto seguenti hanno tutti emesso 18 numeri interi unici tra 1 e 120.

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

Ad esempio, prendiamo -#146. Ecco i 18 numeri interi che possiamo ottenere:

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

Se sei curioso del codice (brutto) usato per testare tutte le possibili combinazioni, eccolo qui. Emette il numero di numeri interi univoci compresi tra 1 e 120 per ogni combinazione di caratteri di lunghezza 5 in un file chiamato "file di dati" nella directory di lavoro corrente.

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

Ottava, 18

Questo è stato trovato usando una ricerca di forza bruta sui simboli *+-/0123456789:;<\^|~%. Ma ci è voluto troppo tempo per calcolare ...

-139%

Possibili uscite:

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

Ottava, 15 numeri

Non c'è molto di cui vantarsi, ma questo è il migliore che posso ottenere in Octave:

124+%

Dà i numeri:

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

Ne ho anche 16, ma sembra identico alla risposta della Sefa ...

1234%

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

PHP, 15 numeri

1230\r

Usa il fatto che php stampa qualcosa al di fuori dei suoi tag alla lettera (senza usare questo puoi fare esattamente 1 numero con qualcosa del genere <?=1;). Utilizza anche un carattere di ritorno a capo reale anziché \r.

Crea (ordinati, rimossi 0 iniziali):

 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

di cui i numeri univoci validi sono:

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

Cubix , 7 numeri

"2)@O

Emette questi numeri:

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

Qualsiasi programma Cubix valido per questa sfida deve avere un Ooutput di un numero intero e un @per terminare il programma (Cubix non ha mai nemmeno sentito parlare di "errori"). Questo ci dà 3 caratteri con cui giocare per generare il maggior numero di output. Inoltre, a causa del modo in cui Cubix organizza il codice su un cubo, il primo carattere sarà inutile a meno che uno degli altri non sia un carattere direzionale.

Il modo più efficiente che ho trovato per generare più numeri è utilizzare "per inviare una serie di codici a caratteri nello stack. Con un attento riarrangiamento, possiamo inserire diversi caratteri nell'ultimo punto e semplicemente generare i loro codici caratteri. Usando )per aumentare l'elemento in alto, possiamo creare output extra da diverse di queste disposizioni.

Ci sono due tipi di programmi di base in uso qui. Il primo è questo:

"2)O@

che si espande a

  "
2 ) O @
  .

Il programma risultante spinge 2nello stack, lo incrementa con ), emette con Oe termina con @.

Il secondo è questo:

2")O@

che si espande a

  2
" ) O @
  .

Il programma risultante invia i codici carattere di ), Oe @, incrementa l'ultimo con ), emette con Oe termina con @.

> <> , 6 numeri

Hai ottenuto 2 numeri grazie a Teal Pelican

1ln";

Produce i numeri univoci [1, 4, 5, 49, 59, 108]

Dobbiamo nstampare un numero.
Dobbiamo ;terminare.

Questo ci lascia solo 3 caratteri con cui lavorare.

Alcune diverse combinazioni di valuee operatorinsieme hanno "confermato di produrre 6 valori unici, ma non ho trovato niente di meglio di così.

Groovy, 10 numeri

Le soluzioni Man JVM sono CATTIVE per questo ... Chi lo sapeva?

1200+

Risultati in:

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

Aspetta cosa? Come diavolo ti fa chiedere?

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.

Segreto commerciale, in numeri interi Groovy / Java preceduti da uno 0 sono ottali. Codice che ho usato per testare le risposte di Groovy in caso qualcuno volesse battermi:

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

0123%

% è l'operatore di commento, quindi "taglierà" in tutti i posti possibili una volta, contribuendo a creare tutte le possibili combinazioni delle cifre e dei sottoinsiemi dati:

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

J, 16 numeri

1234]

Niente di speciale, appena testato 1234con tutti i verbi a 1 carattere che erano ragionevoli.]seleziona il suo argomento giusto.

I numeri univoci prodotti sono

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

di cui 16:

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

Sono nell'intervallo [1,120].

Testato con

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

Japt , 41 numeri

Praticamente solo tentativi ed errori, quindi potrebbe esserci una soluzione migliore. Utilizza interi 3& 4e le scorciatoie Japt per squadratura, l'aggiunta 1e moltiplicando per 2. Tutti i 120 programmi generano un numero intero >0ma solo 78 sono <=120e solo 41 di questi sono unici.

34²ÄÑ

Genera i numeri:

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

Visualizza l'elenco dei numeri o la raccolta di programmi validi

Spiegazione

Alcune cose da notare su Japt che sono rilevanti qui sono:

1. Se un programma non inizia con (in questo caso) una delle cifre, la prima variabile di input U, che per impostazione predefinita 0è, viene automaticamente inserita all'inizio,
2. Se una o entrambe le cifre seguono immediatamente una delle scorciatoie per un'operazione matematica, vengono aggiunte ad essa (ad es. 3Ä4 = 3+14 = 17E, similmente, 4Ѳ = 4*2**2 = 16), e,
3. Se una delle cifre segue immediatamente il, ²allora ²e tutto ciò che lo precede vengono, sostanzialmente, ignorati.

Spiegazioni per alcuni dei programmi (che producono 1, 3, 37e 93, rispettivamente):

²Ñ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 numeri

Befunge è un po 'limitato perché supporta solo valori letterali a una cifra. Quindi il migliore che ho potuto inventare era di 11 numeri, supponendo che il calcolo dovesse lasciarci con un solo numero nello stack.

I migliori personaggi: 358*%

Numeri generati: (solo un esempio di ciascuno)

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 numeri

1234#

Usa # per commentare tutti i numeri non necessari.

dc, 19 numeri

*3zO+

L'output è in cima allo stack e gli errori (incluso il underflow dello stack) vengono ignorati. Le permutazioni valide sono:

+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

Ecco il programma Python che ho usato per mostrare quei risultati:

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

Altre due stringhe che danno lo stesso punteggio di 19 sono 32d+*e *4zO+.

Smalltalk, 26 numeri

1235r

Spiegazione: 12r35 è una notazione per l'utilizzo di radix 12, ed è quindi 3 * 12 + 5.
Questo può essere verificato in 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

dà:

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

Se sostituiamo l'ultima riga con:

    sorted: #value ascending)

otteniamo quindi le espressioni:

'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

Volevo imbrogliare e definire un metodo r in Integer come

Integer>>r
    ^self \\ 120 + 1

Sfortunatamente, il compilatore taglia su 1235r perché riconosce un numero incompiuto con radix piuttosto che un messaggio inviato a 1235 ...
Potrei facilmente cambiare anche il compilatore, ma è un po 'troppo un trucco per i miei gusti.

Mathematica, 16 numeri

;1234

Non molto interessante, ma non riesco a trovare niente di meglio usando l'aritmetica. L'unica cosa che potrebbe funzionare è l'uso !per fattoriale o doppio fattoriale, ma questo è così incline a generare numeri enormi che è impossibile forzare la forza.

I 16 numeri (nell'intervallo) che possono essere generati dai 5 caratteri precedenti sono:

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

Incantesimi runici, 19 numeri

234p@

Essenzialmente 3 letterali, l'operatore pow e un comando "stampa l'intero stack e termina". 234p@stampa 812 (3 ^ 4 conxatenated con un 2). Elenco di permutazione completo , nota che @è stato sostituito da ak@al fine di generare una nuova riga tra ogni risultato e un> è stato aggiunto per assicurare che ogni riga venga eseguita in modo indipendente. Si noti inoltre che gli output non sono nello stesso ordine dei programmi che li hanno generati (poiché alcuni programmi potrebbero terminare più rapidamente).

Molte permutazioni non stampano nulla (ad es. @234pO p234@), ma 19 generano un output all'interno dell'intervallo consentito.

Numeri possibili (e un possibile programma che ne risulta; .indica che quelle posizioni possono essere uno dei caratteri rimanenti in quanto non eseguito):

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 numeri

23+4!

Probabilmente esiste una combinazione migliore, ma non sono riuscito a trovarla.

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