Thử thách mã này sẽ giúp bạn tính toán số cách để đạt $n$ bắt đầu từ $2$ bằng cách sử dụng bản đồ có dạng $x \mapsto x + x^j$ (với $j$ là số nguyên không âm) và thực hiện theo số bước tối thiểu.

(Lưu ý, điều này có liên quan đến trình tự OEIS A307092 .)

Thí dụ

Vì vậy, ví dụ, $f(13) = 2$ vì cần có ba bản đồ và có hai chuỗi riêng biệt của ba bản đồ sẽ gửi từ $2$ đến $13$ :

Kết quả là $2 \to 3 \to 12 \to 13$ hoặc $2 \to 6 \to 12 \to 13$ .

Giá trị mẫu

f(2)   = 1 (via [])
f(3)   = 1 (via [0])
f(4)   = 1 (via [1])
f(5)   = 1 (via [1,0])
f(12)  = 2 (via [0,2] or [2,1])
f(13)  = 2 (via [0,2,0] or [2,1,0], shown above)
f(19)  = 1 (via [4,0])
f(20)  = 2 (via [1,2] or [3,1])
f(226) = 3 (via [2,0,2,1,0,1], [3,2,0,0,0,1], or [2,3,0,0,0,0])
f(372) = 4 (via [3,0,1,0,1,1,0,1,1], [1,1,0,2,0,0,0,1,1], [0,2,0,2,0,0,0,0,1], or [2,1,0,2,0,0,0,0,1])

Thử thách

Thách thức là tạo ra một chương trình lấy số nguyên $n \ge 2$ làm đầu vào và xuất số lượng đường dẫn riêng biệt từ $2$ đến $n$ thông qua số lượng bản đồ tối thiểu có dạng $x \mapsto x + x^j$ .

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

Thạch , 16 byte

2+*¥þ³Ḷ¤F$n³Ạ$¿ċ

Hãy thử trực tuyến!

Một chương trình đầy đủ lấy tham số $n$ và trả về số cách để đạt $n$ bằng cách sử dụng độ dài đường dẫn tối thiểu. Không hiệu quả cho $n$ lớn hơn .

JavaScript (ES6),  111 ... 84  80 byte

Trả về true chứ không phải $1$ cho $n=2$ .

f=(n,j)=>(g=(i,x,e=1)=>i?e>n?g(i-1,x):g(i-1,x+e)+g(i,x,e*x):x==n)(j,2)||f(n,-~j)

Hãy thử trực tuyến!

Đã bình luận

f = (                     // f is the main recursive function taking:
  n,                      //   n = input
  j                       //   j = maximum number of steps
) => (                    //
  g = (                   // g is another recursive function taking:
    i,                    //   i = number of remaining steps
    x,                    //   x = current sum
    e = 1                 //   e = current exponentiated part
  ) =>                    //
    i ?                   // if there's still at least one step to go:
      e > n ?             //   if e is greater than n:
                          //     add the result of a recursive call with:
        g(i - 1, x)       //       i - 1, x unchanged and e = 1
      :                   //   else:
                          //     add the sum of recursive calls with:
        g(i - 1, x + e) + //       i - 1, x + e and e = 1
        g(i, x, e * x)    //       i unchanged, x unchanged and e = e * x
    :                     // else:
      x == n              //   stop recursion; return 1 if x = n
)(j, 2)                   // initial call to g with i = j and x = 2
|| f(n, -~j)              // if it fails, try again with j + 1

Haskell , 78 75 byte

Việc thực hiện này sử dụng một tìm kiếm đầu tiên trong "cây" lặp đi lặp lại tất cả các ánh xạ cần thiết x -> x + x^j.

j#x=x+x^j
f n=[sum[1|x<-l,x==n]|l<-iterate((#)<$>[0..n]<*>)[2],n`elem`l]!!0

Hãy thử trực tuyến!

Giải trình

-- computes the mapping x -> x + x^j
j#x=x+x^j                          
--iteratively apply this function for all exponents [0,1,...,n] (for all previous values, starting with the only value [2])
                            iterate((#)<$>[0..n]<*>)[2] 
-- find each iteration where our target number occurs
    [                   |l<-...........................,n`elem`l] 
-- find how many times it occurs
     sum   [1|x<-l,x==n] 
-- pick the first entry
f n=.............................................................!!0

05AB1E , 17 byte

2¸[˜DIå#εIÝmy+]I¢

Hãy thử trực tuyến!

Python 2 , 72 byte

f=lambda n,l=[2]:l.count(n)or f(n,[x+x**j for x in l for j in range(n)])

Hãy thử trực tuyến!

Perl 5 ( -lp), 79 byte

$e=$_;@,=(2);@,=map{$x=$_;map$x+$x**$_,0..log($e)/log$x}@,until$_=grep$_==$e,@,

TIO

CJam (27 byte)

qi2a{{_W$,f#f+~2}%_W$&!}ge=

Bản demo trực tuyến

Cảnh báo: điều này sẽ rất tốn bộ nhớ rất nhanh.

Mổ xẻ

qi            e# Read input and parse to int n (accessed from the bottom of the stack as W$)
2a            e# Start with [2]
{             e# Loop
  {           e#   Map each integer x in the current list
    _W$,f#f+~ e#     to x+x^i for 0 <= i < n
    2         e#   and add a bonus 2 for the special case
  }%          e#   Gather these in the new list
  _W$&!       e#   Until the list contains an n
}g
e=            e# Count occurrences

Các phần thưởng 2(để xử lý trường hợp đặc biệt của đầu vào 2, vì whilecác vòng lặp đắt hơn do-whilecác vòng lặp) có nghĩa là kích thước của danh sách tăng rất nhanh và việc sử dụng số mũ lên đến n-1có nghĩa là các giá trị của các số lớn hơn trong danh sách tăng lên rất nhanh.

Haskell , 65 byte

([2]%)
l%n|elem n l=sum[1|x<-l,x==n]|1>0=[x+x^k|x<-l,k<-[0..n]]%n

Hãy thử trực tuyến!

Đánh gôn lần đầu tiên tìm kiếm . Tôi cũng đã thử đi ngược từ đó n, nhưng nó dài hơn:

73 byte

q.pure
q l|elem 2l=sum[1|2<-l]|1>0=q[x|n<-l,x<-[0..n],i<-[0..n],x+x^i==n]

Hãy thử trực tuyến!

R , 78 77 byte

function(n,x=2){while(!{a=sum(x==n)})x=rep(D<-x[x<n],n+1)+outer(D,0:n,'^')
a}

Hãy thử trực tuyến!

Sử dụng Tìm kiếm đầu tiên được đơn giản hóa

Mã không được kiểm soát với lời giải thích:

function(n){                              # function taking the target value n

  x=2                                     # initialize vector of x's with 2

  while(!(a<-sum(x==n))) {                # count how many x's are equal to n and store in a
                                          # loop while a == 0

    x=rep(D<-x[x<n],n+1)+outer(D,0:n,'^') # recreate the vector of x's 
                                          # with the next values: x + x^0:n
  }
a                                         # return a
}   

Phiên bản ngắn hơn với phân bổ bộ nhớ lớn (không thành công cho các trường hợp lớn hơn):

R , 70 69 byte

function(n,x=2){while(!{a=sum(x==n)})x=rep(x,n+1)+outer(x,0:n,'^')
a}

Hãy thử trực tuyến!

-1 byte nhờ @RobinRyder

Bình thường , 24 byte

VQIJ/mu+G^GHd2^U.lQ2NQJB

Hãy thử trực tuyến!

Điều này sẽ tạo ra đầu ra chính xác, nhưng rất chậm (trường hợp kiểm tra 372 lần trên TIO). Tôi có thể làm cho nó ngắn hơn bằng cách thay thế .lQ2bằngQ , nhưng điều này sẽ làm cho thời gian chạy khủng khiếp.

Lưu ý: Không tạo đầu ra cho các số không thể truy cập $(n \leq 1)$

Giải trình

VQ                        # for N in range(Q (=input)):
   J                      #   J =
     m                    #     map(lambda d:
      u                   #       reduce(lambda G,H:
       +G^GH              #         G + G^H,
            d2            #         d (list), 2 (starting value) ),
              ^U.lQ2N     #       cartesian_product(range(log(Q, 2)), N)
    /                Q    #     .count(Q)
  IJ                  JB  #   if J: print(J); break