Il tuo compito è quello di costruire un numero naturale usando il minor numero di quelli e solo gli operatori +o -. Ad esempio, il numero sette può essere scritto 1+1+1+1+1+1+1=7, ma può anche essere scritto come 11-1-1-1-1=7. Il primo usa 7quelli, mentre il secondo usa solo 6. Il vostro compito è quello di riportare il numero minimo di quelli che possono essere utilizzati dato l'ingresso di qualche numero naturale, n.

Questo è il codice golf, quindi vince il codice valido più breve in byte.

Casi test

Input => Output

0 => 2 (since 1-1=0)
7 => 6
121 => 6
72 => 15
1000 => 7
2016 => 21

JavaScript (ES6), 127 126 87 byte

f=(n,z=2,m=n*9+'',r=m.replace(/./g,1))=>n?m.length+(m<'55'?f(n- --r/10,0)-1:f(r-n,0)):z

Input: <input type="number" oninput="result.textContent=f(this.value)"> Result: <span id="result"></span>

Dovrebbe funzionare a circa 10 ^{14 15} a quel punto si inizia a correre nei limiti interi di JavaScript. Spiegazione:

f=(                             Recursive function
 n,                             Parameter
 z=2,                           Zero workaround
 m=n*9+'',                      Magic
 r=m.replace(/./g,1)            Find repunit not less than than n
)=>n?                           Nothing to do if n is zero
 m.length+                      Assume subtracting from repunit
 (m<'55'?                       Should we subtract from repunit?
  f(n- --r/10,0)                No, so subtract previous repuint
   -1:                          Which is one 1 shorter
  f(r-n,0)):                    Subtract from repunit
 z                              Return special case if n is zero

Questo usa la n*9magia due volte; in primo luogo, mi dà la lunghezza della repunit successiva, in secondo luogo, se le prime due cifre n*9sono 55o più alte, allora dobbiamo sottrarre nda quella repunit successiva, altrimenti dobbiamo sottrarre la repunit precedente (che viene calcolata sottraendo 1 e dividendo per 10). Questo dovrebbe funzionare fino a 10 ¹⁵ .

Pyth, 19 16 byte

ffqQvs+R1Y^c3"+-

Suite di test

Algoritmo di forza bruta. Le stringhe necessarie vengono generate prendendo tutte le liste i cui elementi sono ['+', '-', '']di lunghezza uguale al numero di 1 testati, aggiungendo un 1 a ciascuno e concatenando una singola stringa. Queste stringhe vengono quindi valutate e confrontate con l'input. Questo viene ripetuto fino a quando non viene trovata una stringa corretta.

Alcune stringhe con un inizio +o -sono testate, ma questo non è un problema. Sarebbe se l'input fosse negativo però.

Può durare fino a 9 prima di diventare troppo lento.

Spiegazione:

ffqQvs+R1Y^c3"+-
ffqQvs+R1Y^c3"+-"T    Implicit variable introduction
                      Q = eval(input())
f                     Starting with T = 1 and counting upwards, repeat until true.
                      The value of T where the result is first true is output.
           c3"+-"     Chop "+-" into thirds, giving ['+', '-', '']
          ^      T    Form every list with those elements of length T.
 f                    Filter over those lists, lambda var Y.
      +R1Y            Append a 1 to each element of the list.
     s                Concatenate.
    v                 Eval.
  qQ                  Compare for equality with the input.
                      The inner filter will let through the successful cases.
                      The outer filter will stop when there is a successful case.

JavaScript (ES6), 92 byte

f=(n,i=3)=>eval([...s=i.toString(3)].map(d=>"-+"[d]||"").join`1`+".0")-n?f(n,i+1):s.length-1

n = <input type="number" oninput="R.textContent=f(this.value)" /><pre id="R"></pre>

Spiegazione

Funzione ricorsiva. Questo genera tutte le possibili permutazioni di 1s separate da +, -o niente. Lo fa incrementando un numero di base 3, trasformandolo in una matrice di cifre, convertendo ogni cifra 0in -, 1in +e 2in una stringa vuota, quindi unendoli a 1s. La stringa risultante è evald come un'istruzione JavaScript che restituisce il risultato dell'equazione.

Poiché gli operatori sono uniti con 1s tra (like +1+1+1+), ci sono length - 1 1s. Il primo operatore viene ignorato (perché +1= 1, <nothing>1= 1ed è un numero così ci sarà mai un leader 0per -) e l'operatore finale è anche ignorato (aggiungendo .0all'equazione).

Versione di output superiore, 96 byte

L'altra versione non può restituire output superiori a ~ 10 a causa del limite dello stack di chiamate di ricorsione. Questa versione utilizza un ciclo for invece della ricorsione, quindi può restituire output fino a ~ 33. La quantità di tempo richiesta aumenta esponenzialmente, quindi non consiglio di provarlo.

n=>eval('for(a=3;eval([...s=a.toString(3)].map(d=>"-+"[d]||"").join`1`+".0")-n;)a++;s.length-1')