Étant donné un tableau d'entiers positifs Aen entrée, générez un programme qui, lorsqu'il est répété plusieurs kfois, génère la kth (1-index) valeur du tableau.

Par exemple, si le tableau est [1,11], la sortie doit être un programme qui sort 1et, si répété deux fois, sort 11. Code comme print(end="1");dans les travaux Python 3: print(end="1");imprime 1 et print(end="1");print(end="1");imprime 11

La plus petite somme de longueurs de code pour résoudre tous les cas de test gagne. Votre méta-code devrait résoudre 500 cas de test en 60s, et chacun de vos codes de solution devrait revenir en 10s. Le méta-code et le code de solution n'ont pas besoin d'être dans la même langue, mais toutes les solutions générées par votre méta-programme doivent être dans la même langue.

Les données de prétest et le générateur peuvent être consultés ici . 7 jours plus tard, la somme du temps de soumission (par exemple 12:34 signifie 1234) sera la graine aléatoire et générera un autre cas de test comme cas de test final.

La graine finale est 7335 en GMT + 8, donc les données de test finales sont ici

Python 3 , génère Stax

Cela utilise une variété de stratégies. La plupart des stratégies ne s'appliquent que sous certaines conditions, mais il existe une stratégie de secours qui est toujours utilisable. À la fin, le plus petit programme candidat est sélectionné.

from functools import reduce
from math import sqrt

symbols = " !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_abcdefghijklmnopqrstuvwxyz{|}"

def uncycle(arr):
    for size in range(1, len(arr)):
        if all(e == arr[i % size] for (i, e) in enumerate(arr)):
            return arr[:size]
    return arr

def constant(val):
    return "A" if val == 10 else str(val)

def shift(val):
    if not val: return ""
    return constant(abs(val)) + "+-"[val < 0]

def encode(a, offsetMode):
    result = "";
    if offsetMode:
        for i in range(len(a) - 1, 0, -1):
            a[i] -= a[i - 1]
    for i in range(len(a)):
        parts = []
        signBit = (a[i] < 0) * 2
        continuing = (offsetMode and i == len(a) - 1) * 1
        remain = abs(a[i])
        while remain > 22:
            parts.insert(0, remain % 46 * 2 + continuing);
            remain //= 46
            continuing = 1

        parts.insert(0, remain * 4 + signBit + continuing)
        result += "".join(symbols[p] for p in parts)
    
    return result

def cram(arr):
    flat = encode(arr, False)
    offset = encode(arr, True)
    return offset if len(offset) < len(flat) else flat;

def issquare(num):
    root = int(sqrt(num))
    return root * root == num

def isgeometric(arr):
    r = arr[0]
    return all(r ** (i + 1) == e for (i,e) in enumerate(arr))

def generateProgram(arr):
    candidates = []
    rotated = uncycle(arr)
    rotated = rotated[-1:] + rotated[:-1]

    deltas = [b - a for a,b in zip(arr, arr[1:])]

    # single constant strategy
    if len(arr) == 1:
        candidates.append(constant(arr[0]))

    # repeated constant
    elif len(set(arr)) == 1:
        num = arr[0]
        if num == 10: candidates.append("A")
        if num % 2 == 0: candidates.append(constant(num // 2) + "H")
        if issquare(num): candidates.append(str(int(sqrt(num))) + "J")
        candidates.append(constant(num - 1) +  "^")

    # repdigit
    if len(arr) == 2 and 10 < arr[1] == arr[0] * 11 < 100:
        candidates.append(str(arr[0]) + "p")

    # single digits
    if max(arr) < 10:
        candidates.append("".join(map(str, rotated)) + "E|X@")

    # max 10
    if max(arr) == 10 and rotated[0] != 1:
        candidates.append("".join(str(e - 1) for e in rotated) + "E|X@^")

    fns = [
        ("", lambda x: x),
        ("H", lambda x: 2 * x),
        ("^", lambda x: x + 1),
        ("J", lambda x: x * x),
        ("Hv", lambda x: 2 * x - 1),
        ("H^", lambda x: 2 * x + 1),
        ("^H", lambda x: 2 * x + 2),
        ("HJ", lambda x: 4 * x * x),
        ("JH", lambda x: 2 * x * x),
        (":T", lambda x: x * (x + 1) / 2),
        ("|F", lambda x: reduce(lambda a, b: a*b, range(1, x+1))),
        ("J^", lambda x: x * x + 1),
        ("^J", lambda x: x * x + 2 * x + 1),
    ]
    for (stax, fn) in fns:
        if all(fn(i + 1) == e for (i,e) in enumerate(arr)):
            candidates.append("|X" + stax)

    # fixed delta
    if len(set(deltas)) == 1:
        delta = deltas[0]
        start = arr[0] - delta
        if start == 0:
            candidates.append(shift(delta))
        if delta == 1:
            candidates.append("|X" + shift(start))
        elif delta == -1:
            candidates.append("|x" + shift(start))
        elif delta > 1:
            candidates.append("|X" + constant(delta) + "*" + shift(start))
        elif delta < -1:
            candidates.append("|x" + constant(-delta) + "*" + shift(start))

    # geometric series
    if isgeometric(arr):
        candidates.append(constant(arr[0]) + "*")

    # prefix
    if len(arr) == 2 and arr[1] // 10 == arr[0] < 10:
        candidates.append("." + str(arr[1]) + "|X(")

    # suffix
    if len(arr) == 2 and arr[0] % 10 == arr[1] < 10:
        candidates.append("." + "".join(map(str, arr)) + "|X)")

    # uncycled cram
    candidates.append('"' + cram(rotated) + '"!|X@')
    
    candidates.sort(key=len)
    return candidates[0]

while True:
    arr = eval(input())
    prog = generateProgram(arr)
    print(prog)

Essayez-le en ligne!

Mise à jour: validation Il faudra du temps pour exécuter chaque multiplicité de chaque programme séparément. Il est possible de les exécuter tous en même temps. Pour ce faire, un petit morceau de code doit être utilisé. Il est responsable de plusieurs choses.

1. Faites une sortie implicite le cas échéant. Normalement, à la fin d'un programme stax, le haut de la pile est imprimé s'il n'y a pas eu d'autre sortie. Lorsque vous exécutez plusieurs programmes dans le même fichier source, cela doit être fait explicitement.

2. Effacez les deux piles.

3. Réinitialiser les registres. Pour ces programmes, seul le registre x est utilisé.

Ce passe-partout doit être appliqué après chaque programme individuel à exécuter.

|d{P}{zP}?0XLd

Par exemple, l'entrée [5,2,7,3]produit le programme stax 3527E|X@. Les quatre multiplicités peuvent être testées simultanément.

3527E|X@
|d{P}{zP}?0XLd

3527E|X@3527E|X@
|d{P}{zP}?0XLd

3527E|X@3527E|X@3527E|X@
|d{P}{zP}?0XLd

3527E|X@3527E|X@3527E|X@3527E|X@
|d{P}{zP}?0XLd

Essayez-le en ligne!

De cette façon, il est possible de tester toutes les multiplicités de tout le programme dans la même exécution, en supposant que rien ne casse. Ce serait probablement le plus grand programme stax jamais exécuté si les 500 étaient terminés.

Perl 5 -p , génère Perl 5 -p , frais généraux 19 17 13

-1 grâce à @Dom Hastings

Le score pour une entrée sera length of the input + 13. Peut évidemment être amélioré en générant des programmes d'auto-décompression pour des entrées plus importantes, mais je ne m'en préoccuperai pas.

Donnez le tableau d'entrée séparé par des virgules sur une ligne sur STDIN.

#!/usr/bin/perl -p
chomp;$_="}{\$_=($_)[\$%++]"

Essayez-le en ligne!

Exécutez la sortie concaténée nfois sans entrée (par exemple, rediriger depuis / dev / null)

Exemple de façon de l'exécuter pour la saisie 2,6,4,7et le programme résultant répété 4 fois:

perl -p '}{$_=(3,6,4,7)[$%++]}{$_=(3,6,4,7)[$%++]}{$_=(3,6,4,7)[$%++]}{$_=(3,6,4,7)[$%++]' < /dev/null

Essayez-le en ligne!

Si vous n'aimez pas que le programme résultant essaie de lire à partir de STDIN, utilisez cette version avec la surcharge 17:

#!/usr/bin/perl -p
chomp;$_="1/!say+($_)[\$-++],"

Essayez-le en ligne!

Exemple de façon de l'exécuter pour la saisie 2,6,4,7et le programme résultant répété 4 fois:

perl -E '1/!say+(2,6,4,7)[$-++],1/!say+(2,6,4,7)[$-++],1/!say+(2,6,4,7)[$-++],1/!say+(2,6,4,7)[$-++],'

Essayez-le en ligne!

Cette version se bloque après l'impression de la sortie requise

05AB1E , génère 05AB1E

¸»“"ÿ"#.g<“ƵƒçJ

Essayez-le en ligne!

Le programme généré pour l'entrée [5,17,7,13,2]est "5 17 7 13 2"#.g<è.

Suite de tests pour [5,17,7,13,2]

La longueur du programme généré est len(input) + 5

APL (Dyalog Unicode)

Préfixe anonyme lambda. Renvoie un corps de programme.

 {
     1=≢⍵:⍕⍵ ⍝ single element

     (2=≢⍵)∧(⍵[2]=11×⍵[1]):⍕⍵[1] ⍝ 2, 22 etc.

     1=≢∪⍵:'⊢',⍕⊃⍵ ⍝ all the same

     (⊢≡⊃×⍳∘≢)⍵:'+',⍕⊃⍵ ⍝ linear

     ((⌊=⊢)!⍣¯1⊢⊃⍵)∧(1∧.=1↓⍵):'!',⍕!⍣¯1⊃⍵ ⍝ factorial followed by all 1s

     (⍵[2]∧.=1↓⍵)∧(⍵[1]=10|2⊃⍵):(⍕⊃⍵),'⌈',(⊃⍕2⊃⍵) ⍝ b ab ab ab

     e←{∊⍉2 2⍴'+×',⍕¨⍵}¨⍸(⊃⍵)=∘.×⍨⍳10
     b←⍵∘≡¨e(({0::⍬ ⋄ ⍎⍵}¨,\)⍴∘⊂)¨⍨(≢⍵)
     ∨/b:⊃b/e

     Q←{'''',⍨⍵/⍨1+''''=⍵}
     (5∧.≤⍵)∧(≢⍕⍵)>6+(+/14=⍵)+≢⍵:'{⍺←⎕AV⍳⊃⋄1⌽⍺⊢⍵}''',Q ⎕AV[⍵] ⍝ string fallback

     (≢⍕⍵)>9+(+/5=⍵)+≢⍵:'{⍺←¯4+⎕AV⍳⊃⋄1⌽⍺⊢⍵}''',Q ⎕AV[4+⍵] ⍝ offset string fallback

     '{⍺←⊃⋄1⌽⍺⊢⍵}',⍕⍵ ⍝ fallback
 }

Essayez-le en ligne!

Les méthodes

Cela explore diverses méthodes et renvoie la première utilisable, pour finalement retomber sur une méthode universellement applicable.

Élément unique

Si la liste ne contient qu'un seul élément, il est renvoyé tel quel.

2, 22 etc.

Un seul chiffre peut simplement être répété pour générer le nombre 11 fois plus grand,

Tous les mêmes

Nous retournons simplement le ⊢numéro le plus à droite ( ).

Linéaire

f (n) = k × n séquences insérez simplement un plus avant le premier terme.

Factorielle suivie de tous les 1

Lorsque le premier nombre n =! M et les nombres suivants sont 1, alors !mest une solution car !mest n et m!mest 1 et !1est 1.

b ab ab ab

Étant donné que tous les nombres à deux chiffres sont plus grands que tous les nombres à un chiffre, un maximum courant, où l'avant du premier numéro est collé à l'arrière du deuxième numéro, est une solution.

Le code à trois lignes

Vérifiez si une formule du type +a×best valide.

Remplacement de chaîne

Les séquences longues sans numéro inférieur à 5 (car 4 est un saut de ligne) peuvent être codées en tant que caractères du SBCS.

Remplacement de chaîne de décalage

S'il y a des nombres inférieurs à 5, nous augmentons de 9 pour éviter ceux-ci.

Se retirer

Concaténation de chaîne simple de la chaîne "{⍺←⊃⋄1⌽⍺⊢⍵}"et de l' ⍕entrée stringified ( ). Par exemple, [3,1,4]renvoie le corps du programme {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4.

La partie entre accolades est une fonction ambivalente, ce qui signifie qu'elle peut être soit une fonction préfixe, soit une fonction infixe. Ainsi, l'instance la plus à gauche s'exécutera en mode préfixe, et toutes les autres en mode infixe. La différence entre les modes est de savoir si ⍺, signifiant l'argument de gauche, a une valeur. Si ce n'est pas le cas, la fonction lui sera attribuée ⊃(en premier).

Explication de la méthode de secours

{… } Lambda anonyme:

 ⍺←⊃ S'il n'y a pas d'argument gauche ( ⍺), affectez la fonction ⊃(en premier) à⍺

 ⋄ puis:

À ce stade, le code suivant signifie deux choses différentes selon qu'il ⍺s'agit d'une liste de numéros (appel infixe) ou de la fonction "premier" (appel préfixe).

 Si ⍺est une liste de nombres:

  ⍺⊢⍵ jeter l'argument de gauche en faveur de l'argument de droite

  1⌽ faire pivoter cette étape vers la gauche

 Si ⍺est la fonction "première":

  ⊢⍵ donner le bon argument

  ⍺ choisir le premier élément de cette

  1⌽ faites-le pivoter d'un pas (pas d'opération sur un scalaire)

Exemple d'exécution de la méthode de secours

En exécutant 3 1 4le code {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4,, assigne la "première" fonction ⍺et renvoie donc le premier élément; 3.

L'exécution {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4permet au lambda le plus à droite de "capturer" la gauche 3 1 4comme argument gauche, donc ⍺a une valeur qui est rejetée en faveur de 3 1 4laquelle est ensuite tournée d'un pas vers la gauche et donne 1 4 3le résultat. Ceci est ensuite utilisé comme seul argument pour le lambda le plus à gauche, où ⍺devient la "première" fonction, faisant du résultat le premier élément; 1.

L'exécution {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4permet au lambda le plus à droite de "capturer" le milieu 3 1 4comme son argument de gauche qui est ensuite rejeté en faveur de l'argument de droite 3 1 4, qui, une fois tourné d'un pas vers la gauche, l'est 1 4 3. Il est ensuite utilisé comme argument de droite du lambda du milieu avec l' 3 1 4argument de gauche comme argument de gauche. L'argument de gauche est ignoré pour la droite, qui tourne d'un pas vers la gauche donne 4 3 1. Cela devient alors le seul argument de la lambda la plus à gauche, ⍺devient ainsi la "première fonction", renvoyant le premier élément; 4.

Notation

Lorsqu'il est temps de tester à l'aide de données réelles, utilisez ce faisceau de test (lié rempli de données de prétest). Les cas de test vont dans le champ d'entrée et la sortie sera le nombre total d'octets des 500 programmes ensemble. (Il générera également une erreur, mais c'est simplement parce qu'il essaie ensuite d'évaluer l'entrée telle quelle.)

charbon

´⎚´§´⪪⪫ＩＡ ”y¦ Ｌυ⊞υω

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

´⎚´§´⪪

Sortez la chaîne littérale ⎚§⪪.

⪫ＩＡ 

Convertissez le tableau d'entrée en chaîne, joignez-y des espaces et imprimez.

”y¦ Ｌυ⊞υω

Sortez la chaîne littérale ¦ Ｌυ⊞υω.

La sortie de par exemple 5,17,7,13,2est ⎚§⪪5 17 7 13 2¦ Ｌυ⊞υω. Essayez-le en ligne! Explication:

⎚

Effacez le canevas afin que seule la dernière sortie soit visible.

§⪪5 17 7 13 2¦ Ｌυ

Prenez la longueur de la liste prédéfinie u. Utilisez-le pour indexer dans la liste des entiers qui ont été divisés sur des espaces et produire l'élément sélectionné.

⊞υω

Poussez une variable fictive dans la liste prédéfinie u, de sorte que la copie suivante produise l'élément suivant de la liste.

Longueur totale de sortie = (longueur de tous les entiers dans toutes les listes) + (nombre d'entiers dans toutes les listes) + (nombre de listes * 9) caractères (SBCS).

Haskell , génère Haskell

main = interact $ ("main=print$("++) . (++"!!)$ -1\n +1--")

Essayez-le en ligne! Pour le premier test, [5,2,7,3,2,3,15,10,7,2,14,11,16,16,3,3,4,3,8,4]il produit le programme suivant:

main=print$([5,2,7,3,2,3,15,10,7,2,14,11,16,16,3,3,4,3,8,4]!!)$ -1
 +1--

Essayez-le une fois , doublé et triplé . Cela utilise la même approche que ma réponse Haskell: je double la source, vous doublez la sortie .

La longueur de chaque programme généré est la longueur de la liste d'entrée sous forme de chaîne plus 25, ainsi le score pour les tests actuellement disponibles est 12266 + 500 * 25 = 24766. Cela montre que le rapport code / données est fondamentalement égal, et je doute qu'il soit possible d'écrire un code de décompression suffisamment petit qui diminuera le score. Cela pourrait être possible si les listes étaient beaucoup plus grandes.

Python 2 , génère Python 2

import sys
a=`input()[::-1]`.replace(' ','')
sys.stdout.write('print%s[-open(__file__,"a").tell()/%s]#'%(a,len(a)+37))

Essayez-le en ligne!

Pour l'entrée

[10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29]

le programme généré est

print[29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10][-open(__file__,"a").tell()/98]#

qui est de 98 octets.

Adapté de cette solution dans "Je double la source, tu double la sortie!".

Bon sang, deux réponses plus courtes sont apparues avant que j'aie fini d'écrire cette réponse.

Java 8, génère Python 2

interface M{static void main(String[]a){int l=a[0].length();System.out.print("print"+a[0]+"[open(__file__,'a').tell()/"+(l+35+(l+"").length())+"]#");}}

Essayez-le en ligne.

C'est à dire [3,4,5,6,7]génère ce programme Python 2:

print[3,4,5,6,7][open(__file__,'a').tell()/48]#

Essayez-le en ligne une fois ; Essayez-le en ligne deux fois ; Essayez-le en ligne trois fois .

Le programme Python généré est basé sur la réponse de @ Mr.Xcoder pour la troisième fois le défi du charme .

Explication:

Code Java 8:

interface M{                    // Class
  static void main(String[]a){  //  Mandatory main-method
    int l=a[0].length();        //   The length of the first argument
                                //   (Note that this is the length of the input as String,
                                //   not the size of the array)
    System.out.print(           //   Print:
      "print"                   //    Literal "print"
      +a[0]                     //    Appended with the argument
      +"[open(__file__,'a').tell()/"
                                //    Appended with literal "[open(__file__,'a').tell()/"
      +                         //    Appended with an integer that is formed by:
       (l                       //     Getting the length we got earlier
       +35                      //     +34 for the rest of the Python 2 code + 1
       +(l+"").length())        //     + the length of the length (<10→1; 10-99→2; etc.)
       +"]#");}}                //    Appended with literal "]#"

Code Python 2:

print                        # Print
 [3,4,5,6,7]                 #  From this array
 [                           #   The `k`'th item,
  open(__file__,'a').tell()  #   where `k` is the length of its own source code
  /                          #   divided by
  48                         #   the length of its own source code (once) + 1
 ]#                          # With a trailing comment, so we can repeat the program

Bash, sort des programmes en Perl 5

Le programme Bash peut être appelé comme script.sh 1,2,3.

Le programme Perl doit être appelé avec le -Edrapeau.

echo "shift@a;@a=($1)unless@a;END{say\$a[0];exec'true'}"

Le perlcode généré pour une entrée de 4,7,8est:

shift@a;@a=(4,7,8)unless@a;END{say$a[0];exec'true'}

Jolie force brute. Supprime un élément du tableau ( perlpeu importe que le tableau n'existe pas au début), le définit s'il n'est pas déjà défini. Il fait ensuite écho au premier élément du tableau à la fin. (Le ENDbloc est exécuté en dernier). Le exec 'true'quitte le programme, afin que les autres ENDblocs ne soient pas exécutés.

Exemple:

#Once
$ perl -E "$(bash script.sh 4,7,8)"
4

#Duplicated twice
$ perl -E "$(bash script.sh 4,7,8)$(bash script.sh 4,7,8)"
7

#Duplicated thrice
$ perl -E "$(bash script.sh 4,7,8)$(bash script.sh 4,7,8)$(bash script.sh 4,7,8)"
8

Python 2, génère C ++

Cela ne battra aucun record, j'étais principalement intéressé à savoir si je pouvais comprendre comment le faire :) Utilisez le fait que les variables globales sont exécutées avant main, et ainsi pouvez incrémenter une variable globale, puis utiliser un #ifdef pour s'assurer que main n'est défini qu'une seule fois.

import sys
print("""#include <stdio.h>
#ifndef A
#define A
int v;
int d[]={""" + sys.argv[1] + """};
struct C{C(){v++;}};
int main(void){ printf("%d",d[v]); }
#else
C c1;
#endif
""")

Enchantements runiques , génère runique

74akw94/85akw
R32B~~?US' Sqq1Ky1Ky
\i<{1[lil1-{S{)]{{1KyB
D'0$'´$$' $     Rl0) ?
R"{Zs$;|1|l;|y"@
"UwR'10<|I+}"$~ /' Su0
       Rakwc4akw/

Essayez-le en ligne!

Prend l'entrée comme une liste de valeurs séparées par des espaces.

Sortie effectuée une fois
Sortie effectuée deux fois
Sortie effectuée quatre fois

Utilise la commande de mode de lecture numérique continue, ´qui a été validée le 12 janvier et j'ai trouvé cette question le 14. Cette commande permet de coder des valeurs de longueur arbitraires car sans cette fonctionnalité, il serait très difficile de le faire (par exemple, il 1392faudrait qu'il soit représenté comme 1X3+X9+X2+, nécessitant une boucle supplémentaire au minimum); précisément le problème que je voulais résoudre lorsque j'ai créé la ´commande.

Dans le code original, le |dans les chaînes "{Zs$;|1|l;|y"et "UwR'10<|I+}"sont remplacés par \n(qui sont assis dans la grille et non pas le modifier, comme ils le feraient normalement) avec des wcommandes de rite: 74akw, 94/Rakw, c4akw, et 85akw. Les personnages originaux peuvent être n'importe quoi. |a été choisi pour être un espace réservé symbolique qui représentait visuellement ce que je voulais. Plusieurs octets enregistrés (si ceux qui ne sont pas marqués) en n'ayant pas à ajouter de manière réfléchie un point d'entrée, comme wR'10<écrit un Rdans un emplacement où il existe déjà (position 0,1), puis procède à remplir sa pile de déchets avant de manquer de mana, après un bouclage séquence U"'i34.

Le code de sortie résultant fonctionne en utilisant la wcommande rite pour changer le premier caractère de la deuxième ligne en une Rredirection droite (donc une seule IP exécute une instruction d'impression), avec une utilisation intelligente de la longueur de pile résultant de programmes de plus en plus grands pour déterminer quel index lire. Chaque autre IP change ce même emplacement pour la même instruction et se termine. Tout le reste n'est pas utilisé.

_{L'image est obsolète, mais suffisante pour l'explication du flux.}

Chaque exécution de 1Iyconserve la capacité de l'IP à gérer une pile de plus en plus grande (causée par la lcommande), dont la taille permet au programme de déterminer le nombre de copies du code source de base. La finale 1est utilisée pour incrémenter le précédent lau nombre requis lors de la rotation de la pile (créée ensuite) afin d'arriver à la valeur correcte. La Zcommande annule cette valeur afin que la pile tourne dans le bon sens.

Le tableau d'entrées d'origine est ensuite codé en mode de lecture continue, amorcé avec un 0 pour éviter de modifier progressivement la même valeur, pour lire les entrées d'origine. L'espace NOP est requis pour quitter le mode de lecture continue et permettre au 0 suivant d'amorcer à nouveau la pile.

Le score doit être égal approximativement 3+v.toString().length, pour chaque entrée de tableau v, +23pour chaque tableau. Environ (2.55*total length of input)ou 33837pour l'entrée d'échantillon, si j'ai bien fait les choses.

Des changements mineurs ont été introduits dans mon programme final attendu en raison d'effets secondaires introduits dans la même version en ce qui concerne la scommande, mais cela a abouti à un meilleur score en même temps.