Hướng

Viết chương trình, cho một số nguyên đầu vào n ( n >= 0), xuất ra số nguyên dương m nhỏ nhất trong đó:

• n = a[1]^b[1] + a[2]^b[2] + a[3]^b[3] + ... + a[k]^b[k]
• avà blà các chuỗi hữu hạn có cùng độ dài
• tất cả các yếu tố của aít hơnm
• tất cả các yếu tố của bít hơnm
• tất cả các yếu tố alà khác nhau và số nguyêna[x] >= 0
• tất cả các yếu tố blà khác nhau và số nguyênb[x] >= 0
• a[x]và b[x]không phải là cả 0 (vì 0 ^ 0 là không xác định)

Đây là mã golf , vì vậy ít byte nhất sẽ thắng.

Ví dụ

In 0 -> Out 1
Possible Sum: 

In 1 -> Out 2
Possible Sum: 1^0

In 2 -> Out 3
Possible Sum: 2^1

In 3 -> Out 3
Possible Sum: 2^1 + 1^0

In 6 -> Out 4
Possible Sum: 2^2 + 3^0 + 1^1

In 16 -> Out 5
Possible Sum: 2^4

In 17 -> Out 4
Possible Sum: 3^2 + 2^3

In 23 -> Out 6
Possible Sum: 5^1 + 3^0 + 2^4 + 1^3

In 24 -> Out 5
Possible Sum: 4^2 + 2^3

In 27 -> Out 4
Possible Sum: 3^3

In 330 -> Out 7
Possible Sum: 6^1 + 4^3 + 3^5 + 2^4 + 1^0

GolfScript (59 ký tự)

~:T),{),.0{2$0-{2${{4$2$^}2*@3$\?4$+f~}%\;~}%+\;\;}:f~T&}?)

Bản demo trực tuyến

Điều này sử dụng đệ quy để liệt kê các giá trị có thể đạt được cho một cái đã cho mvà tìm kiếm cái đầu tiên mhoạt động. Nó lấy cảm hứng nhẹ từ câu trả lời của xnor nhưng khá khác biệt trong cách thực hiện.

Mổ xẻ

~:T                  # Evaluate input and store in T (for Target)
),{                  # Search [0 1 ... T] for the first m which matches a predicate
  ),.0               #   Push [0 ... m] to the stack twice and then 0
                     #   Stack holds: possibleAs possibleBs sum
  {                  #   Define the recursive function f
    2$0-{            #     Map over A in possibleAs (except 0)
      2${            #       Map over B in possibleBs (except 0)
        {4$2$^}2*    #         Duplicate respective possibles and remove selected values
        @3$\?4$+     #         Compute sum' = sum + A^B
        f            #         Recursive call gives an array [sums]
        ~            #         Push the sums to the stack individually
        }%           #       End map: this collects the sums into a combined array
      \;             #       Pop A, leaving just the combined [sums] inside the map
      ~              #       Repeat the trick: push to the stack individually
    }%               #     End map, collecting into a combined array
                     #     Stack now holds: possibleAs possibleBs sum [sums]
    +                #     Include the original sum in the array of reachable sums
    \;\;             #     Pop possibleAs and possibleBs
  }:f                #   End function definition
  ~                  #   Evaluate the function
  T&                 #   Test whether the sums contain T
}?                   # End search
)                    # Increment to get m

Con trăn, 120

f=lambda n,A,B:n*all(f(n-a**b,A-{a},B-{b})for a in A for b in B)
g=lambda n,m=1,M={0}:f(n,M-{0},M)and g(n,m+1,M|{m})or m

Chức năng flà một chức năng phụ trợ mà kiểm tra xem ncó thể không được diễn tả như một khoản quyền hạn với các căn cứ khác biệt từ Avà số mũ từ B. Nó sử dụng một chiến lược đệ quy tự nhiên: nphải là khác không, và chúng tôi thử mọi lựa chọn cơ bản và số mũ có thể và tất cả chúng đều cần phải thất bại. Chúng tôi loại bỏ chúng khỏi danh sách được phép và giảm ntheo số tiền tương ứng.

Chức năng glà chức năng chính. Nó tìm kiếm một mhoạt động. Mlà tập hợp các giá trị được phép lên đến m-1. Chúng tôi xóa 0khỏi số mũ được phép dừng lại 0**0(mà Python ước tính là 1) không được sử dụng. Điều này không làm tổn thương bất cứ điều gì Bởi vì 0**xnó là vô dụng 0cho tất cả những người khác x.

Python 2, 138 byte

from itertools import*
S=lambda n,m=0,R=[]:m*any(n==sum(map(pow,*C))for k in R for C in product(*tee(permutations(R,k))))or S(n,m+1,R+[m])

(Cảm ơn @Jakube vì tất cả các mẹo)

Tôi chưa bao giờ học được nhiều về itertoolsmô-đun như tôi có từ câu hỏi này. Trường hợp cuối cùng mất khoảng một phút.

Chúng tôi bắt đầu bằng cách tìm kiếm từ m = 1và tăng dần cho đến khi chúng tôi có được giải pháp. Để kiểm tra một giải pháp, chúng tôi lặp lại:

• k = 0 to m-1, ksố lượng các điều khoản trong giải pháp là ở đâu
• Tất cả sự kết hợp có thể của các thuật ngữ (bằng cách kết hợp hai hoán vị của các tập hợp con [0, 1, ... m-1]có kích thước k), sau đó tổng hợp và kiểm tra xem chúng ta cón

Lưu ý rằng chúng tôi lặp lại ktối đa m-1- mặc dù về mặt kỹ thuật mhoàn toàn có thể, nhưng luôn có một giải pháp với m-1các điều khoản 0^0không được phép và 0^bkhông đóng góp gì. Điều này thực sự quan trọng vì 0^0được xử lý như 1 bởi Python, có vẻ như là một vấn đề, nhưng hóa ra nó không quan trọng!

Đây là lý do tại sao.

Giả sử một giải pháp được tìm thấy sử dụng sai 0^0là 1, ví dụ 3^2 + 1^1 + 0^0 = 11. Vì chúng tôi chỉ tạo ra m-1theo các điều khoản, nên phải có một số jchúng tôi không sử dụng làm cơ sở (ở đây j = 2). Chúng ta có thể trao đổi cơ sở 0 jđể có được một giải pháp hợp lệ, tại đây 3^2 + 1^1 + 2^0 = 11.

Nếu chúng tôi lặp đi lặp lại tất cả các mđiều khoản, thì chúng tôi có thể đã nhận được các giải pháp không chính xác như m = 2cho n = 2, thông qua 0^0 + 1^1 = 2.

GolfScript ( 90 84 byte)

[0.,.]](~:T),(+{:x;{:|2,{:c)|=x),^{c[1$x]=:A^x^:-;[|~-+@A-?+@A+@]}%}/+~}%.[]*T&}?)\;

Bản demo trực tuyến

Mổ xẻ

[0.,.]             # Base case: [sum As Bs] is [0 [] []]
](~:T              # Collect it in an array of cases; fetch parameter, eval, store in T.
),(+               # Create array [1 2 ... T 0]. Putting 0 at the end means that it won't
                   # be reached except when T is 0, and nicely handles that special case.
{                  # Loop over the values from that array...
  :x;              #   ...assigning each in turn to x (and popping it from the stack)
  {                #   Stack holds array of [sum As Bs] cases; map them...

    :|             #     Store [sum As Bs] in |
    2,{:c          #     For c in [0 1]...
      )|=x),^      #       Get [0 1 ... x]^ either As or Bs, depending on c
      {            #       Map these legal new As or Bs respectively...
        c[1$x]=:A  #         Work out which of that value or x is the new A
        ^x^:-;     #         And the other one is the new B
        [          #         Begin gathering in an array
          |~       #           Push sum As Bs to the stack
          -+       #           Add - to Bs to get Bs'
          @A-?+    #           Rotate sum to top and add A^- to get sum'
          @A+      #           Rotate As to top and add A to get As'
          @        #           Final rotation to put elements in the right order
        ]          #         Gather in array [sum' As' Bs']
      }%           #       End map
    }/             #     End for
    +~             #     Push all the elements corresponding to x^B and A^x on to the stack
  }%               #   End map, collecting the untouched [sum As Bs] and all the new
                   #   [sum' As' Bs'] arrays into a new array of reached cases.
  .[]*T&           #   Flatten a copy of that array and filter to values equal to T.
                   #   This gives a truthy value iff we've found a way to make T.
}?                 # Loop until we get a truthy value, and push the corresponding x
)\;                # Increment to get the value of m and discard the array of cases

Thủ thuật tao nhã nhất là xử lý trường hợp đặc biệt cho 0.

Haskell, 143 130

import Data.List
p n=head$[1..]>>=(\m->[m|let x=permutations[0..m-1]>>=inits,a<-x,b<-x,sum(zipWith(\x y->x^y*signum(x+y))a b)==n])

Ví dụ sử dụng: p 23-> 6.

Đây là một tìm kiếm vũ phu đơn giản. Đối với mọi danh sách, [0..0], [0..1], [0..2] ... [0..∞]hãy lấy tất cả các phân đoạn ban đầu của hoán vị (ví dụ: [0..2]: hoán vị : [012], [102], [210], [120], [201], [021], các phân đoạn ban đầu cho hoán vị thứ nhất : [0], [01], [012], 2 : [1], [10], [102], v.v.). Đối với mỗi kết hợp của 2 trong số các danh sách đó, tính tổng các quyền hạn. Dừng lại khi lần đầu tiên bằng n.

Python: 166 ký tự

from itertools import*;p=permutations
f=lambda n,r=[0]:any(n==sum(map(lambda x,y:(x+y>0)*x**y,a,b))for j in r for a,b in product(p(r,j),p(r,j)))*1or 1+f(n,r+[len(r)])

Giải trình

Hàm ftạo ra tất cả các số nguyên có thể, có thể được biểu thị dưới dạng tổng lũy ​​thừa của các số trong r. Nếu bắt đầu với r = [0]. Nếu bất kỳ số nguyên nào trong số đó bằng n, nó sẽ trả về độ dài r, nếu không, nó tự gọi đệ quy với phần mở rộng r.

Tính toán của tất cả các số nguyên, có thể được biểu thị dưới dạng tổng được thực hiện với hai vòng. Vòng lặp đầu tiên là for j in r, cho chúng ta biết độ dài của biểu thức (2 ^ 3 + 1 ^ 2 có độ dài 2). Vòng lặp bên trong lặp lại trên tất cả các kết hợp hoán vị rcủa chiều dài j. Đối với mỗi tôi tính tổng sức mạnh.

JavaScript (ES6) 219 224

Hàm đệ quy. Bắt đầu với m = 1, tôi thử tất cả các kết hợp của số nguyên 1..m cho các cơ sở và 0..m cho các số mũ (0 cơ sở là vô dụng khi đưa ra 0 ^ 0 == không xác định).
Nếu không tìm thấy giải pháp, tăng m và thử lại.
Trường hợp đặc biệt cho đầu vào 0 (theo tôi dù sao đó cũng là một lỗi trong thông số kỹ thuật)

Hàm C tạo đệ quy tất cả các kết hợp từ một mảng có độ dài cho trước, sao cho

C(3, [1,2,3]) --> [[3,2,1], [3,1,2], [2,3,1], [2,1,3], [1,3,2], [1,2,3]]

Cấp độ thứ ba everyđược sử dụng để nén các mảng a của cơ sở và b của số mũ (không có zipchức năng nào trong JavaScript). Sử dụng everyđể dừng sớm khi có một giải pháp không sử dụng tất cả các yếu tố trong hai mảng.

F=(n,j=1,k=[],
  C=(l,a,o=[],P=(l,a,i=l)=>{
    for(l||o.push(a);i--;)
      e=[...a],P(l-1,e.concat(e.splice(i,1)))
  })=>P(l,a)||o
)=>n&&C(k.push(j++),k)[E='every'](a=>C(j,[0,...k])[E](b=>a[E](x=>t-=Math.pow(x,b.pop()),t=n)))
?F(n,j,k):j

Kiểm tra trong bảng điều khiển FireFox / FireBug

;[0,1,2,3,6,16,17,23,24,27,330].map(x=>[x,F(x)])

Đầu ra

[[0, 1], [1, 2], [2, 3], [3, 3], [6, 4], [16, 5], [17, 4], [23, 6], [ 24, 5], [27, 4], [330, 7]]