Sua tarefa é criar um número natural usando o menor número possível de números e apenas os operadores +ou -. Por exemplo, o número sete pode ser escrito 1+1+1+1+1+1+1=7, mas também pode ser escrito como 11-1-1-1-1=7. O primeiro usa 7uns, enquanto o último usa apenas 6. Sua tarefa é retornar o número mínimo de unidades que podem ser usadas, dada a entrada de algum número natural n,.

Este é o código golf, portanto o código válido mais curto em bytes vence.

Casos de teste

Entrada => Saída

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

JavaScript (ES6), 127 126 87 bytes

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>

Deve funcionar para cerca de 10 ^{14 15} , altura em que você começa a executar os limites inteiros do JavaScript. Explicação:

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

Isso usa a n*9magia duas vezes; em primeiro lugar, fornece o comprimento da próxima repunit; em segundo lugar, se os dois primeiros dígitos de n*9são 55ou mais altos, precisamos subtrair a npartir da próxima repunit; caso contrário, precisamos subtrair a repunit anterior (que é calculada subtraindo 1 e dividindo por 10). Isso deve funcionar até 10 ¹⁵ .

Pitão, 19 16 bytes

ffqQvs+R1Y^c3"+-

Suíte de teste

Algoritmo de força bruta. As seqüências necessárias são geradas usando todas as listas cujos elementos têm ['+', '-', '']comprimento igual ao número de 1s sendo testados, acrescentando um 1 a cada um e concatenando uma única sequência. Essas cadeias são então avaliadas e comparadas com a entrada. Isso é repetido até que uma sequência bem-sucedida seja encontrada.

Algumas seqüências de caracteres com um líder +ou -são testadas, mas isso não é um problema. Seria se a entrada fosse negativa.

Pode atingir o comprimento 9 antes de ficar muito lento.

Explicação:

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 bytes

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>

Explicação

Função recursiva. Isto gera todas as permutações possíveis de 1s separados por um ou outro +, -ou nada. Isso é feito incrementando um número base-3, transformando-o em uma matriz de dígitos, convertendo cada dígito 0em -, 1para +e 2para uma sequência vazia, juntando-os com 1s. A sequência resultante é evald como uma instrução JavaScript que retorna o resultado da equação.

Como os operadores são unidos a 1s no meio (como +1+1+1+), existem length - 1 1s. O primeiro operador é ignorado (porque +1= 1, <nothing>1= 1e é um número, portanto nunca haverá um líder 0para -) e o operador final também é ignorado (anexando .0à equação).

Versão de saída superior, 96 bytes

A outra versão não pode retornar saídas superiores a ~ 10 devido ao limite da pilha de chamadas de recursão. Esta versão usa um loop for em vez de recursão, para que possa retornar saídas até ~ 33. A quantidade de tempo necessária aumenta exponencialmente, portanto, não recomendo testá-lo.

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