Dato un array di numeri interi positivi Acome input, genera un programma che, se ripetuto per ktempi, emette il valore kth (1 indice) dell'array.

Ad esempio, se l'array lo è [1,11], l'output dovrebbe essere un programma che emette 1e, se ripetuto due volte, l'output 11. Codice come print(end="1");nelle opere di Python 3: print(end="1");stampe 1 e print(end="1");print(end="1");stampe 11

Vincono la somma minima di lunghezze di codice per risolvere tutti i casi di test. Il tuo meta-codice dovrebbe risolvere 500 casi di test negli anni '60 e ciascuno dei tuoi codici della soluzione dovrebbe tornare in 10 secondi. Il meta-codice e il codice soluzione non devono necessariamente essere nella stessa lingua, ma tutte le soluzioni generate dal meta-programma devono essere nella stessa lingua.

I dati e il generatore di prova possono essere visualizzati qui . 7 giorni dopo utilizzerà la somma del tempo di presentazione (ad esempio 12:34 significa 1234) come seme casuale e genererà un altro caso di test come caso di test finale.

Il seme finale è 7335 in GMT + 8, quindi i dati del test finale sono qui

Python 3 , genera Stax

Questo utilizza una varietà di strategie. La maggior parte delle strategie si applica solo a determinate condizioni, ma esiste una strategia di fallback che è sempre utilizzabile. Alla fine, viene selezionato il programma candidato più piccolo.

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)

Provalo online!

Aggiornamento: convalida Ci vorrà del tempo per eseguire separatamente ogni molteplicità di ciascun programma. È possibile eseguirli tutti contemporaneamente. Per fare ciò, è necessario utilizzare una piccola parte di codice. È responsabile di alcune cose.

1. Esegui output implicito se presente. Normalmente, alla fine di un programma stax, la parte superiore dello stack viene stampata se non c'è stato altro output. Quando si eseguono più programmi nello stesso file di origine, questo deve essere fatto in modo esplicito.

2. Cancella entrambe le pile.

3. Ripristina registri. Per questi programmi viene utilizzato solo il registro x.

Questa piastra di caldaia deve essere applicata dopo ogni singolo programma da eseguire.

|d{P}{zP}?0XLd

Ad esempio, l'input [5,2,7,3]produce il programma stax 3527E|X@. Tutte e quattro le molteplicità possono essere testate contemporaneamente.

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

Provalo online!

In questo modo, è possibile testare tutte le molteplicità di tutto il programma nella stessa esecuzione, supponendo che nulla si rompa. Sarebbe probabilmente il più grande programma stax mai eseguito se tutti e 500 fossero stati eseguiti.

Perl 5 -p , genera Perl 5 -p , spese generali 19 17 13

-1 grazie a @Dom Hastings

Il punteggio per un input sarà length of the input + 13. Ovviamente può essere migliorato generando programmi di auto-decompressione per input più grandi, ma non mi preoccuperò.

Assegna l'array di input separato da virgole su una riga su STDIN.

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

Provalo online!

Esegue i ntempi concatenati dell'output senza input (ad es. Reindirizzamento da / dev / null)

Esempio di modo per eseguirlo per l'input 2,6,4,7e il programma risultante ripetuto 4 volte:

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

Provalo online!

Se non ti piace il programma risultante che prova a leggere da STDIN, usa questa versione con il sovraccarico 17:

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

Provalo online!

Esempio di modo per eseguirlo per l'input 2,6,4,7e il programma risultante ripetuto 4 volte:

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)[$-++],'

Provalo online!

Questa versione si arresta in modo anomalo dopo aver stampato l'output richiesto

05AB1E , genera 05AB1E

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

Provalo online!

Il programma generato per l'ingresso [5,17,7,13,2]è "5 17 7 13 2"#.g<è.

Suite di test per [5,17,7,13,2]

La lunghezza del programma generato è len(input) + 5

APL (Dyalog Unicode)

Prefisso anonimo lambda. Restituisce un corpo del programma.

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

Provalo online!

metodi

Questo esplora vari metodi e restituisce il primo utilizzabile, ricadendo infine su un metodo universalmente applicabile.

Singolo elemento

Se l'elenco ha solo un elemento, viene restituito così com'è.

2, 22 ecc.

Una sola cifra può essere ripetuta per generare il numero 11 volte più grande,

Lo stesso

Restituiamo solo il ⊢numero più a destra ( ).

Lineare

f (n) = k × n le sequenze devono solo inserire un segno più prima del primo termine.

Fattoriale seguito da tutti gli 1 secondi

Quando il primo numero n =! M e i numeri successivi sono 1, allora !mè una soluzione perché !mè n em!m è 1 e!1 è 1.

b ab ab ab

Poiché tutti i numeri a due cifre sono più grandi di tutti i numeri a una cifra, un massimo corrente, in cui la parte anteriore del primo numero è incollata sul retro del secondo numero, è una soluzione.

Il codice a tre righe

Controlla se esiste una formula del tipo +a×b è valida.

Fallback delle stringhe

Le sequenze lunghe senza numeri inferiori a 5 (poiché 4 è un'interruzione di riga) possono essere codificate come caratteri dell'SBCS.

Fallback della stringa di offset

Se ci sono numeri inferiori a 5, aumentiamo di 9 per evitarli.

Ricaderci

"{⍺←⊃⋄1⌽⍺⊢⍵}"Concatenazione di stringhe semplice della stringa e dell'input stringified ( ⍕). Ad esempio, [3,1,4]restituisce il corpo del programma {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4.

La parte tra parentesi graffe è una funzione ambivalente, il che significa che può essere una funzione prefisso o una funzione infisso. Pertanto l'istanza più a sinistra verrà eseguita in modalità prefisso e tutte le altre in modalità infisso. La differenza tra le modalità è se ⍺, a significare l'argomento sinistro, ha un valore. In caso contrario, verrà assegnata la funzione ⊃(prima).

Spiegazione del metodo di fallback

{... } lambda anonimo:

 ⍺←⊃ Se non è presente alcun argomento sinistro ( ⍺), assegnare la funzione ⊃(prima) a⍺

 ⋄ poi:

A questo punto, il codice seguente significa due cose diverse a seconda che ⍺ si un elenco di numeri (chiamata infisso) o della funzione "prima" (chiamata prefisso).

 Se ⍺è un elenco di numeri:

  ⍺⊢⍵ scartare l'argomento sinistro a favore dell'argomento giusto

  1⌽ ruota quel passo a sinistra

 Se ⍺la funzione è "prima":

  ⊢⍵ cedere l'argomento giusto

  ⍺ scegli il primo elemento

  1⌽ ruotalo di un passo (una no-op su uno scalare)

Esempio di esecuzione del metodo di fallback

3 1 4Il codice di esecuzione {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4, assegna la "prima" funzione ⍺e quindi restituisce il primo elemento; 3.

L'esecuzione {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4consente alla lambda più a destra di "catturare" la sinistra 3 1 4come argomento sinistro, quindi ⍺ha un valore che viene scartato a favore del 3 1 4quale viene quindi ruotato di un passo a sinistra e produce 1 4 3come risultato. Questo viene quindi usato come unico argomento per la lambda più a sinistra, dove ⍺diventa la "prima" funzione, facendo sì che il risultato sia il primo elemento;1.

L'esecuzione {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4consente alla lambda più a destra di "catturare" il mezzo 3 1 4come argomento di sinistra, che viene quindi scartato a favore dell'argomento di destra 3 1 4, che quando viene ruotato di un passo a sinistra è 1 4 3. Questo viene quindi usato come argomento destro del lambda medio insieme 3 1 4all'argomento più a sinistra come argomento di sinistra. L'argomento sinistro viene scartato per quello destro, che ruotava di un passo a sinistra 4 3 1. Questo diventa quindi il solo argomento della lambda più a sinistra, quindi ⍺diventa la "prima funzione", restituendo il primo elemento; 4.

punteggio

Quando diventa il momento di testare utilizzando i dati effettivi, utilizzare questo cablaggio di test (collegato popolato con dati preliminari). I casi di test vanno nel campo Input e l'output sarà il conteggio totale dei byte di tutti i 500 programmi insieme. (Inoltre genererà un errore, ma è solo perché in seguito tenta di valutare l'input così com'è.)

Carbone

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

´⎚´§´⪪

Emette la stringa letterale ⎚§⪪.

⪫ＩＡ 

Trasmetti l'array di input su stringa, unisci con spazi e stampa.

”y¦ Ｌυ⊞υω

Emette la stringa letterale ¦ Ｌυ⊞υω.

L'output di per esempio 5,17,7,13,2è ⎚§⪪5 17 7 13 2¦ Ｌυ⊞υω. Provalo online! Spiegazione:

⎚

Cancella la tela, in modo che sia visibile solo l'ultimo output.

§⪪5 17 7 13 2¦ Ｌυ

Prendi la lunghezza dell'elenco predefinito u. Usalo per indicizzare l'elenco di numeri interi che sono stati divisi in spazi e produrre l'elemento selezionato.

⊞υω

Inserire una variabile fittizia nell'elenco predefinito u, in modo che la copia successiva produca l'elemento successivo dell'elenco.

Lunghezza totale output = (lunghezza di tutti i numeri interi in tutti gli elenchi) + (numero di numeri interi in tutti gli elenchi) + (numero di elenchi * 9) caratteri (SBCS).

Haskell , genera Haskell

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

Provalo online! Per il primo testcase [5,2,7,3,2,3,15,10,7,2,14,11,16,16,3,3,4,3,8,4]produce il seguente programma:

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

Provalo una volta , raddoppiato e triplicato . Questo utilizza lo stesso approccio della mia risposta Haskell per raddoppiare la fonte, raddoppiare l'output .

La lunghezza di ciascun programma generato è la lunghezza dell'elenco di input come stringa più 25, quindi il punteggio per le prove attualmente disponibili è 12266 + 500 * 25 = 24766. Ciò dimostra che il rapporto tra codice e dati è sostanzialmente uguale e dubito che sia possibile scrivere un codice di decompressione abbastanza piccolo da ridurre il punteggio. Potrebbe essere possibile se le liste fossero molto più grandi.

Python 2 , genera Python 2

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

Provalo online!

Per l'input

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

il programma generato è

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

che è di 98 byte.

Adattato da questa soluzione in "Raddoppio la fonte, raddoppi l'output!".

Accidenti, sono arrivate due risposte più brevi prima che finissi di scrivere questa risposta.

Java 8, genera 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())+"]#");}}

Provalo online.

Cioè [3,4,5,6,7]genera questo programma Python 2:

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

Provalo online una volta ; Provalo online due volte ; Provalo online tre volte .

Il programma Python generato si basa sulla risposta di @ Mr.Xcoder per la terza volta la sfida del fascino .

Spiegazione:

Codice 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 "]#"

Codice 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, genera programmi in Perl 5

Il programma Bash può essere chiamato come script.sh 1,2,3.

Il programma Perl dovrebbe essere chiamato con il -Eflag.

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

Il perlcodice generato per un input di 4,7,8è:

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

Forza piuttosto bruta. Rimuove un elemento dell'array ( perlnon importa che l'array non esista inizialmente), lo imposta se non è già impostato. Fa quindi eco al primo elemento dell'array alla fine. (Il ENDblocco viene eseguito per ultimo). Il exec 'true'chiude il programma, in modo che le ulteriori ENDblocchi non vengono eseguiti.

Esempio:

#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, genera C ++

Questo non batterà nessun record, ero principalmente interessato a pensare se potevo capire come farlo :) Usa il fatto che le variabili globali vengono eseguite prima di main e quindi può incrementare una variabile globale, quindi utilizzare un #ifdef per garantire che main sia definito una sola volta.

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

Incantesimi runici , genera runico

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

Provalo online!

Accetta l'input come un elenco di valori separato da spazi.

Uscita eseguita una volta
Uscita eseguita due volte
Uscita eseguita quattro volte

Utilizza il comando numerico continuo in modalità lettura, ´che è stato eseguito il 12 gennaio e ho trovato questa domanda il 14. Questo comando consente di codificare valori di lunghezza arbitrari poiché senza questa funzione sarebbe molto difficile farlo (ad es. 1392Dovrebbe essere rappresentato come1X3+X9+X2+ , richiedendo almeno un loop aggiuntivo); proprio il problema che volevo risolvere quando ho creato il ´comando.

Nel codice originale, il |nelle corde "{Zs$;|1|l;|y"e "UwR'10<|I+}"vengono sostituiti con \n(che siede nella griglia e non modificarlo, come farebbero normalmente) con wcomandi rito: 74akw, 94/Rakw, c4akw, e 85akw. I personaggi originali possono essere letteralmente qualsiasi cosa. |è stato scelto per essere un segnaposto simbolico che rappresentava visivamente ciò che volevo. Diversi byte salvati (se non un punteggio) non devono aggiungere in modo riflettente un punto di ingresso, poiché wR'10<scrive un Rin una posizione dove già esiste (posizione0,1 ), quindi procede a riempire il suo stack con junk prima di esaurire il mana, seguendo un ciclo sequenza U"'i34.

Il codice di output risultante funziona utilizzando il wcomando rite per modificare il primo carattere sulla seconda riga in un Rreindirizzamento elevato (quindi solo un IP esegue un'istruzione di stampa), con un uso intelligente della lunghezza dello stack risultante da programmi sempre più alti per determinare quale indice leggere. Ogni altro IP cambia la stessa posizione nella stessa istruzione e termina. Tutto il resto rimane inutilizzato.

_{L'immagine non è aggiornata, ma è sufficiente per la spiegazione del flusso.}

Ogni esecuzione di 1Iymantiene la capacità dell'IP di gestire uno stack sempre più grande (causato dal lcomando), la cui dimensione consente al programma di determinare quante copie del codice sorgente di base ci sono. Il finale 1viene utilizzato per incrementare il precedentel al numero richiesto quando si ruota lo stack (creato dopo) per arrivare al valore corretto. Il Zcomando annulla questo valore in modo che lo stack ruoti nella direzione corretta.

L'array di input originale viene quindi codificato utilizzando la modalità di lettura continua, innescato con uno 0 per evitare di modificare in modo incrementale lo stesso valore, per leggere gli input originali. Lo spazio NOP è necessario per uscire dalla modalità di lettura continua e consentire allo 0 successivo di adescare nuovamente lo stack.

Il punteggio dovrebbe essere approssimativamente uguale 3+v.toString().length, per ogni voce dell'array v, +23per ciascun array. Circa(2.55*total length of input) o 33837per l'input del campione, se ho fatto le cose bene.

Piccole modifiche sono state introdotte nel mio programma finale previsto a causa degli effetti collaterali introdotti nella stessa build per quanto riguarda il scomando, tuttavia ha portato a un punteggio migliore allo stesso tempo.