Ваше завдання - створити натуральне число, використовуючи найменшу кількість одиниць і лише операторів +або -. Наприклад, число сім може бути записане 1+1+1+1+1+1+1=7, але воно також може бути записане як 11-1-1-1-1=7. Перший використовує 7ті, в той час як останній лише використовує 6. Ваше завдання - повернути мінімальну кількість тих, які можуть бути використані, враховуючи введення якогось натурального числа n,.

Це код гольфу, тому виграє найкоротший дійсний код у байтах.

Тестові справи

Вхід => Вихід

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

JavaScript (ES6), 127 126 87 байт

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>

Потрібно працювати приблизно до 10 ^{14 15,} коли ви почнете працювати з цілими межами JavaScript. Пояснення:

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

Для цього використовується n*9магія двічі; у - перших, це дає мені довжину наступного репьюнітом, по- друге, якщо перші дві цифри n*9є 55або вище, то ми повинні відняти nз цього наступного репьюнітом, в іншому випадку ми повинні відняти попереднє репьюнітом (який розраховується шляхом вирахування 1 і ділення на 10). Це має працювати до 10 ¹⁵ .

Pyth, 19 16 байт

ffqQvs+R1Y^c3"+-

Тестовий набір

Алгоритм грубої сили. Необхідні рядки генеруються, беручи всі списки, елементи яких ['+', '-', '']мають довжину, рівну кількості тестів, що перевіряються, додаючи 1 до кожного та поєднуючись у один рядок. Потім ці рядки оцінюються та порівнюються із вхідними. Це повторюється, поки не буде знайдена успішна рядок.

Деякі рядки з ведучим +або -тестуються, але це не проблема. Було б, якби вхід був негативним.

Він може працювати до 9-ти завдовжки, перш ніж він стане занадто повільним.

Пояснення:

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 байти

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>

Пояснення

Рекурсивна функція. Це генерує всі можливі перестановки 1s, розділених або +, -або нічого. Це робиться, збільшуючи число базового-3, перетворюючи його на масив цифр, перетворюючи кожну цифру 0в -, 1до +і 2в порожній рядок, а потім з'єднуючи їх разом із 1s. Отриманий рядок evald являє собою оператор JavaScript, який повертає результат рівняння.

Оскільки оператори з'єднуються з 1s між ними (як +1+1+1+), є length - 1 1s. Перший оператор ігнорується (бо +1= 1, <nothing>1= , 1і це число , так що ніколи не буде провідним 0для -) і останній оператор також ігнорується (шляхом додавання .0до рівняння).

Більш висока вихідна версія, 96 байт

Інша версія не може повернути виходи, що перевищують ~ 10 через ліміт стеку викликів рекурсії. Ця версія використовує цикл for замість рекурсії, тому він може повертати результати до ~ 33. Кількість необхідного часу збільшується експоненціально, хоча тому не рекомендую тестувати його.

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