这段代码的挑战将你计算的方法来达到多少 $n$ 从开始 $2$ 使用形式的地图 $x \mapsto x + x^j$ （与 $j$ 一个非负整数），并在最少的步骤数这么做。

例

因此，例如， $f(13) = 2$ 是因为需要三个映射，并且三个映射的两个不同序列将发送 $2$ 到 $13$ ：

\begin{matrix} x \mapsto x + x^{0} \\ x \mapsto x + x^{2} \\ x \mapsto x + x^{0} \end{matrix} or \begin{matrix} x \mapsto x + x^{2} \\ x \mapsto x + x^{1} \\ x \mapsto x + x^{0} \end{matrix}

$\begin{array}{c} x \mapsto x + x^0 \\ x \mapsto x + x^2 \\ x \mapsto x + x^0\end{array} \qquad \textrm{or} \qquad \begin{array}{c}x \mapsto x + x^2 \\ x \mapsto x + x^1 \\ x \mapsto x + x^0\end{array}$

结果为 $2 \to 3 \to 12 \to 13$ 或 $2 \to 6 \to 12 \to 13$ 。

值示例

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])

挑战

面临的挑战是产生一个程序来的整数 $n \ge 2$ 作为输入，并且输出从不同的路径的数目 $2$ 到 $n$ 经由形式的地图的最小数量的 $x \mapsto x + x^j$ 。

这是代码高尔夫球，因此最少的字节获胜。

code-golf sequence combinatorics

— 彼得·卡吉
source

1

我认为应该明确指出该^符号表示幂。也可以是XOR（例如C ^用于按位XOR）。

— 拉米利斯

1

@Ramillies也许应该将其更改为MathJax。即

而不是。

x = x + x^{j}

$x=x+x^j$ x -> x + x^j

— 凯文·克鲁伊森

@KevinCruijssen：好点，那肯定会有所帮助。

— 拉米利斯

我已将它作为A309997添加到OEIS中。（除非获得批准，否则将是草案。）

— Peter Kagey

2

果冻，16字节

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

在线尝试！

一个完整的程序，以 $n$ 为参数，并使用最小路径长度返回到达 $n$ 的方式数。对于较大的 $n$ 无效。

— 尼克·肯尼迪
source

5

JavaScript（ES6）， 111 ... 84 80字节

对于返回true而不是 $1$ $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)

在线尝试！

已评论

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

— Arnauld
source

4

哈斯克尔， 78 75字节

此实现在迭代所有必要映射的“树”中使用“呼吸优先”搜索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

在线尝试！

说明

-- 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

— 瑕疵
source

3

05AB1E，17个字节

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

在线尝试！

— 肮脏的
source

2

Python 2，72个字节

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

在线尝试！

— 异或
source

递归实现BFS的好方法。

— 乔尔

1

Perl 5（`-lp`），79字节

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

蒂奥

— 纳韦尔·福耶勒（Nahuel Fouilleul）
source

1

CJam（27字节）

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

在线演示

警告：这会非常占用大量内存。

解剖：

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

红利2s（用于处理input的特殊情况2，因为while循环比do-while循环更昂贵）意味着列表的大小增长非常快，使用指数最多n-1意味着列表中较大数字的值增长非常快。

— 彼得·泰勒
source

1

Haskell，65个字节

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

在线尝试！

高尔夫球手的广度优先搜索。我也尝试从倒退n，但时间更长：

73字节

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]

在线尝试！

— 异或
source

1

R，78 77字节

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

在线尝试！

使用简化的广度优先搜索

展开代码并提供说明：

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
}

具有较大内存分配的较短版本（在较大的情况下失败）：

R，70 69字节

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

在线尝试！

-1个字节感谢@RobinRyder

— 数字化
source

!(a<-sum(x==n))!{a=sum(x==n)}在两种情况下都可以为-1字节。

— 罗宾·赖德

0

Pyth，24个字节

VQIJ/mu+G^GHd2^U.lQ2NQJB

在线尝试！

这应该产生正确的输出，但是非常慢（TIO上的372测试用例超时）。我可以通过替换.lQ2为来使其更短Q，但这会使运行时变得可怕。

注意：对于不可达的数字不产生任何输出 $(n \leq 1)$

说明

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

— ar4093
source

计算到n的最短路径数

例

值示例

挑战

果冻，16字节

JavaScript（ES6）， 111 ... 84 80字节

已评论

哈斯克尔， 78 75字节

说明

05AB1E，17个字节

Python 2，72个字节

Perl 5（-lp），79字节

CJam（27字节）

解剖：

Haskell，65个字节

R，78 77字节

R，70 69字节

Pyth，24个字节

说明

Perl 5（`-lp`），79字节