前几天我想出了一系列数字，决定检查它的OEIS编号是多少。令我惊讶的是，这个序列似乎没有出现在OEIS数据库中，因此我决定以我自己的名字命名（请注意，比我聪明得多的其他人可能已经提出了这个建议，如果有人找到了此序列的实际名称，请发表评论，我将更改问题标题）。由于我在任何地方都找不到该序列，因此决定以我自己的名字命名，因此命名为“狮ry编号”。编辑：感谢@Surb引起我注意这个序列等于OEIS序列A053696-1的事实。

甲狮鹫号是一个数字形式的$a+a^2+...+a^x$，其中$a$和$x$都是大于或等于2的整数，而Gryphon序列是所有Gryphon编号按升序排列的集合。如果有多种方式来形成狮number号（第一个例子是$30$，它们都是$2+2^2+2^3+2^4$和$5+5^2$），则该数字仅在序列中计数一次。前几个狮ry编号是：$6, 12, 14, 20, 30, 39, 42, 56, 62, 72$。

你的任务：

编写一个程序或函数，该程序或函数接收整数$n$作为输入并输出第$n$个狮ry号。

输入：

0到10000（含）之间的整数。您可以将序列视作0索引或1索引，以您喜欢的任何一个为准。请说明您在答案中使用的索引系统，以避免造成混淆。

输出：

与输入对应的狮ry号。

测试用例：

请注意，这假设序列是0索引的。如果您的程序采用1索引序列，请不要忘记增加所有输入数字。

Input:    Output:
0   --->  6
3   --->  20
4   --->  30
10  --->  84
99  --->  4692
9999 -->  87525380

得分：

这是代码高尔夫球，因此以字节为单位的最低分数获胜。

果冻，9 字节

bṖ’ḅi-µ#Ṫ

一个完整的程序，该程序从STDIN读取（1索​​引）整数，并打印结果。

在线尝试！

怎么样？

狮ry号是一个以小于其自身的底数表示的数字，因此除最低有效位（为零）外，所有数字均为1。例如：

$30=1\times 2^4+1\times 2^3+1\times2^2+1\times2^1+0\times2^0 \rightarrow 30_2 = 11110$

$84=1\times 4^3+1\times 4^2+1\times 4^1+0\times 4^0 \rightarrow 84_4 = 1110$

该程序采用n，然后从开始于v=0并测试该属性，并递增v直到找到n此类数字，然后输出最后一个数字。

要测试一个底数，b它从每个数字中减去一个，从底数转换v，然后检查结果是否为$-1$。（请注意，b小于v）

$30_2 \rightarrow 0\times 30^4+0\times 30^3+0\times30^2+0\times30^1+(-1)\times30^0 = -1$

$84_4 \rightarrow 0\times 84^3+0\times 84^2+0\times 84^1+(-1)\times 84^0 = -1$

bṖ’ḅi-µ#Ṫ - Main Link: no arguments
       #  - set v=0 then count up collecting n=STDIN matches of:
      µ   -  the monadic link -- i.e. f(v):  e.g. v=6
 Ṗ        -    pop (implicit range of v)            [1,2,3,4,5]
b         -    to base (vectorises)                 [[1,1,1,1,1,1],[1,1,0],[2,0],[1,2],[1,1]]
  ’       -    decrement (vectorises)               [[0,0,0,0,0,0],[0,0,-1],[1,-1],[0,1],[0,0]]
   ḅ      -    from base (v) (vectorises)           [0,-1,5,1,0]
     -    -    literal -1                           -1
    i     -    first index of (zero if not found)   2
          - }  e.g. n=11 -> [6,12,14,20,30,39,42,56,62,72,84]
        Ṫ - tail         -> 84
          - implicit print

MATL，16 13字节

:Qtt!^Ys+uSG)

基于1。

在线尝试！

说明

以输入n = 3为例。

:    % Implicit input: n. Range
     % STACK: [1 2 3]
Q    % Add 1, element-wise
     % STACK: [2 3 4]
tt   % Duplicate twice, transpose
     % STACK: [2 3 4], [2 3 4], [2;
                                 3;
                                 4]
^    % Power, element-wise with broadcast
     % STACK: [2 3 4], [ 4   9  16;
                         8  27  64;
                        16  81 256]
Ys   % Cumulative sum of each column
     % STACK: [2 3 4], [ 4    9  16;
                         12  36  80;
                         28 117 336]
+    % Add, element-wise with broadcast (*)
     % STACK: [ 6  12  20;
               14  39  84
               30 120 340]
u    % Unique elements. Gives a column vector
     % STACK: [  6;
                14;
                30;
                12;
               ···
               340]
S    % Sort
     % STACK: [  6;
                12
                14;
                20;
               ···
               340]
G)   % Push input again, index. This gets the n-th element. Implicit display
     % STACK: 14

在步骤（*）中获得的矩阵可能包含重复的狮ry编号。特别是，它n的第一行包含不同的狮ry编号。这些不一定是n最小的狮ry编号。但是，左下条目2+2^+···+2^n 超过右上条目n+n^2，因此最后一行中的所有数字都超过第一行中的数字。这意味着向右或向下扩展矩阵不会贡献任何低于n矩阵中最低数的狮ry数。因此，保证矩阵包含n最小的狮ry数。因此，其n最低的唯一元素是解决方案。

Haskell，53个字节

([n|n<-[6..],or[a^y+n==n*a+a|a<-[2..n],y<-[3..n]]]!!)

在线尝试！

$\newcommand{\ta}{{a}}\newcommand{\ti}{{i}}\newcommand{\tx}{{x}}\newcommand{\tn}{{n}}\newcommand{\ty}{{y}}$如果存在整数和使得则数字为狮ry 。$\tn$$\ta \geq 2$$\tx \geq 2$$\tn=\sum_{i=1}^\tx \ta^i$

我们生成所有的无限列表，以致于蛮力搜索显示情况确实如此。$\tn \geq 6$

答案是此列表中的索引索引（零索引），在Haskell中用表示(list!!)。

为什么是a^y+n==n*a+a正确的？

从用于总结几何级数的公式中：

$$\sum_{i=1}^\nu \alpha \rho^{i-1} = \frac{\alpha(1-\rho^\nu)}{1-\rho}$$

我们让：$(\alpha, \rho, \nu) = (\ta, \ta, \tx)$

重新排列方程式，我们得到。$n(1-a) = a - a^{x+1}$

重新整理，得到。$\ta^{\tx+1}+n = \tn \ta + \ta$

蛮力搜索中的替换产生最终表达式。$\ty = \tx+1$a^y+n=n*a+a

搜索是否n足够？

• 如果（换句话说就是），则 证明。因此，检查任何值是没有意义的。$\ta > \tn$$\ta \geq \tn+1$

  $$\ta^\ty + \tn > \ta^2 \geq (\tn+1)\ta = \tn\ta + \ta$$ $\ta^\ty+\tn \neq \tn\ta+\ta$$\ta > \tn$

• 同样：如果，则 再次证明。$\ty > \tn$

  $$\ta^\ty + \tn > \ta^\tn = \ta^{\tn-1}\ta \geq 2^{\tn-1}\ta \stackrel{\color{red}*}> (\tn+1)\ta = \tn\ta + \ta,$$ $\ta^\ty + \tn \neq \tn\ta + \ta$

  ^{$\color{red}{{}^{*}}$我们可以假设因为我们知道，这是最小的狮ry数。$2^{n-1}>n+1$$n \geq 6$}

Python 3.8（预发布），98 92 89 78 71字节

lambda n:sorted({a*~-a**x//~-a for a in(r:=range(2,n+3))for x in r})[n]

在线尝试！

0索引。在此必须使用整数除法，因为f（10000）会溢出浮点数。

生成所有Gryphon编号，其中和排序，然后选择第个元素。$2 \leq a \leq n+2$$2 \leq x \leq n+2$$n$

-6个字节，感谢Jonathan Allan

-3字节感谢ArBo。我几乎按照他的建议做了，但是尝试使用{*(...)}它并不能节省空间

-11字节的感谢mathmandan

-7字节归功于ArBo

有效性的数学证明

为了证明这一点，即使数学约定为1索引，也要使用0索引。

• 令为第个狮号$G_n$$n$
• 令（和的狮ry数）$g(a,x) = a + a^2 + ... + a^x$$a$$x$
• 令为所有狮ry编号的集合，其中和$A_n$$2 \leq a \leq n+2$$2 \leq x \leq n+2$
• 我们知道$A_0 = \{ g(2,2) \} = \{ 6 \} = \{ G_0 \}$
• $A_{n+1} = \{ g(a, x), g(a+1, x), g(a, x+1), g(a+1, x+1) | g(a, x) \in A_n \}$
• $g(a+1, x) < g(a+1, x+1)$对于所有和$a$$x$
• $g(a, x+1) < g(a+1, x+1)$对于所有和$a$$x$
• 因此如果则$G_{n+1} \neq g(a+1, x+1)$$G_n = g(a, x)$
• $g(a+1, x) < g(a+2, x)$对于所有和$a$$x$
• $g(a, x+1) < g(a, x+2)$对于所有和$a$$x$
• 因此如果则必须为或因为不存在其他可能性。$G_{n+1}$$g(a+1, x)$$g(a, x+1)$$G_n = g(a, x)$
• 我们可以使用此信息得出结论：如果，则$G_{n+1} \in A_{n+1}$$G_n \in A_n$
• 由于我们知道中的，我们可以使用此规则为所有$G_0 \in A_0$$G_n \in A_n$$n$
• 由于这可以从应用于，因此，如果从最小到最大排序，则必须在索引处$G_0$$G_n$$G_n$$n$$A_n$$A_n$

J，³⁵ 32字节

-3字节归功于FrownyFrog

3 :'y{/:~~.,}.+/\(^~/>:)1+i.y+2'

在线尝试！

说明与原文相同。只需使用显式形式保存字节即可将其删除@。

原始答案，默认，带说明：35个字节

{[:/:~@~.@,@}.[:+/\@(^~/>:)1+i.@+&2

在线尝试！

类似于路易斯·门多（Luis Mendo）的方法，我们创建了一个“功率表”（如时间表），其顶部2 3 ... n和左侧均1 2 ... n产生：

 2   3    4     5     6      7
 4   9   16    25    36     49
 8  27   64   125   216    343
16  81  256   625  1296   2401
32 243 1024  3125  7776  16807
64 729 4096 15625 46656 117649

^~/ >:创建表并1+i.@+&2创建1... n序列，然后+&2在输入中添加2（），以确保即使有0或1个输入，我们也总是有足够的元素来创建表。

在上面的表格之后，解决方案变得微不足道了。我们只对行进行汇总+/\，然后删除第一行，展平，取唯一，然后排序/:~@~.@,@}.。最后，{使用原始输入将结果索引，从而产生答案。

盖亚 18字节

)┅:1D¤*‡+⊣¦tv<_uȯE

在线尝试！

从1开始的索引。

长鼻子这是一个相当可悲的答案：)┅:它可能希望它可以进一步打下去。

复制路易斯·门多答案给出的算法

R，65 62字节

-1个字节，感谢Giuseppe。

n=scan();unique(sort(diffinv(t(outer(2:n,1:n,"^")))[3:n,]))[n]

在线尝试！

1个索引。

生成形式为的所有值的矩阵，获取累积和，删除第一行（0s）和第二行（对应于条目），然后获取唯一的排序值。$a^i$$x=1$

请注意，这sort(unique(...))将不起作用，因为unique将给出矩阵的唯一行，而不是唯一条目。使用unique(sort(...))作品是因为sort转换为矢量。

JavaScript（ES7），76个字节

1个索引。

f=(n,a=[i=2])=>(n-=a.some(j=>a.some(k=>(s+=j**k)==i,s=j)))?f(n,[...a,++i]):i

在线尝试！

JavaScript（ES7），89个字节

1个索引。

n=>eval('for(a=[i=1e4];--i>1;)for(s=1e8+i,x=1;a[s+=i**++x]=x<26;);Object.keys(a)[n]-1e8')

在线尝试！

Wolfram语言（Mathematica），51个字节

(Union@@Array[Sum[(#2+1)^k,{k,#+1}]&,{30,#}])[[#]]&

在线尝试！

1索引

@attinat的-8个字节

木炭，36字节

ＮθＦθＦθ⊞υ÷⁻Ｘ⁺²ι⁺³κ⁺²ι⊕ιＦ⊖θ≔Φυ›κ⌊υυＩ⌊υ

在线尝试！链接是详细版本的代码。1个索引。使用Luis Mendo的算法。说明：

Ｎθ

输入。$n$

ＦθＦθ⊞υ

创建一个由Gryphon编号组成的 ×网格，并将每个网格都推到预定义的列表中。$n$$n$

÷⁻Ｘ⁺²ι⁺³κ⁺²ι⊕ι

使用的事实来计算Gryphon数。$\sum_1^x a^i = \frac{a^{x+1}-a}{a-1}$

Ｆ⊖θ≔Φυ›κ⌊υυ

删除最低的狮ry编号。$n-1$

Ｉ⌊υ

打印剩余的最低狮ry编号。

Japt，23个字节

亲爱的杰布斯！要么我真的忘记了打高尔夫，要么酒终于要付出代价了！

不是乔纳森解决方案的直接体现，而是他观察的启发。

@ÈÇXìZ mÉ ìZÃeÄ}fXÄ}gNÅ

试试吧

05AB1E，12 个字节

L¦ãε`LmO}êIè

0索引

在线尝试或验证前项目$n$。

说明：

L             # Create a list in the range [1, (implicit) input-integer]
              #  i.e. 4 → [1,2,3,4]
 ¦            # Remove the first item to make the range [2, input-integer]
              #  i.e. [1,2,3,4] → [2,3,4]
  ã           # Create each possible pair of this list by using the cartesian product
              #  i.e. [2,3,4] → [[2,2],[2,3],[2,4],[3,2],[3,3],[3,4],[4,2],[4,3],[4,4]]
   ε          # Map each pair to:
    `         #  Push the values of the pair separately to the stack
              #   i.e. [4,3] → 4 and 3
     L        #  Take the list [1, value] for the second value of the two
              #   i.e. 3 → [1,2,3]
      m       #  And then take the first value to the power of each integer in this list
              #   i.e. 4 and [1,2,3] → [4,16,64]
       O      #  After which we sum the list
              #   i.e. [4,16,64] → 84
        }ê    # After the map: uniquify and sort the values
              #  i.e. [6,14,30,12,39,120,20,84,340] → [6,12,14,20,30,39,84,120,340]
          Iè  # And index the input-integer into it
              #  i.e. [6,12,14,20,30,39,84,120,340] and 4 → 30
              # (after which the result is output implicitly)