Nhiệm vụ của bạn là xây dựng một số tự nhiên bằng cách sử dụng số lượng ít nhất và chỉ các toán tử +hoặc -. Ví dụ, số bảy có thể được viết 1+1+1+1+1+1+1=7, nhưng nó cũng có thể được viết là 11-1-1-1-1=7. Cái đầu tiên sử dụng 7cái kia, trong khi cái sau chỉ sử dụng 6. Nhiệm vụ của bạn là trả về số lượng tối thiểu có thể được sử dụng với đầu vào của một số số tự nhiên , n.

Đây là mã golf, vì vậy mã hợp lệ ngắn nhất tính bằng byte sẽ thắng.

Các trường hợp thử nghiệm

Đầu vào => Đầu ra

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>

Sẽ hoạt động đến khoảng 10 ^{14 15} tại thời điểm bạn bắt đầu chạy vào giới hạn số nguyên của JavaScript. Giải trình:

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

Cái này dùng n*9 phép thuật hai lần; Thứ nhất, nó cho tôi độ dài của lần trả tiền tiếp theo, thứ hai, nếu hai chữ số đầu tiên n*9là 55hoặc cao hơn, thì chúng ta cần phải trừ đi nkhoản tiền thưởng tiếp theo đó, nếu không, chúng ta cần phải trừ đi khoản tiền thưởng trước đó (được tính bằng cách trừ đi 1 và chia cho 10). Điều này sẽ làm việc lên đến 10 ¹⁵ .

Bình thường 19 16 byte

ffqQvs+R1Y^c3"+-

Bộ kiểm tra

Thuật toán vét cạn. Các chuỗi cần thiết được tạo bằng cách lấy tất cả các danh sách có các phần tử có ['+', '-', '']độ dài bằng với số 1 được kiểm tra, nối thêm 1 cho mỗi chuỗi và nối với một chuỗi. Các chuỗi này sau đó được đánh giá và so sánh với đầu vào. Điều này được lặp lại cho đến khi một chuỗi thành công được tìm thấy.

Một số chuỗi có hàng đầu +hoặc- được kiểm tra, nhưng đây không phải là vấn đề. Nó sẽ là nếu đầu vào là tiêu cực mặc dù.

Nó có thể chạy đến chiều dài 9 trước khi nó trở nên quá chậm.

Giải trình:

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>

Giải trình

Hàm đệ quy. Điều này tạo ra tất cả các hoán vị có thể của 1s tách ra bởi một trong hai +, -hoặc không có gì. Nó làm điều này bằng cách tăng một số cơ sở-3, biến nó thành một loạt các chữ số, chuyển đổi từng chữ số 0để -, 1đến +và 2để một chuỗi rỗng, sau đó gia nhập chúng lại với nhau với 1s. Chuỗi kết quả là evald dưới dạng một câu lệnh JavaScript trả về kết quả của phương trình.

Bởi vì các toán tử được nối với 1s ở giữa (như +1+1+1+), có length - 1 1s. Các nhà điều hành đầu tiên được bỏ qua (vì +1= 1, <nothing>1= 1và đó là một số do đó sẽ không bao giờ trở thành một lãnh đạo 0cho -) và các nhà điều hành cuối cùng cũng bị bỏ qua (bằng cách thêm .0vào phương trình).

Phiên bản đầu ra cao hơn, 96 byte

Phiên bản khác không thể trả lại kết quả đầu ra cao hơn ~ 10 do giới hạn ngăn xếp cuộc gọi đệ quy. Phiên bản này sử dụng vòng lặp for thay vì đệ quy, vì vậy nó có thể trả về kết quả đầu ra lên tới ~ 33. Lượng thời gian cần thiết tăng theo cấp số nhân mặc dù vậy tôi không khuyên bạn nên thử nghiệm nó.

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