Tôi đã đưa ra một loạt các số vào ngày khác và quyết định kiểm tra số OEIS cho nó là gì. Thật ngạc nhiên, chuỗi này dường như không có trong cơ sở dữ liệu của OEIS, vì vậy tôi đã quyết định đặt tên cho chuỗi đó theo mình (lưu ý rằng một người khác thông minh hơn tôi có lẽ đã nghĩ ra điều này và nếu ai đó tìm thấy tên thực tế của chuỗi này, xin vui lòng bình luận và tôi sẽ thay đổi tiêu đề câu hỏi). Vì tôi không thể tìm thấy chuỗi ở bất cứ đâu, tôi quyết định đặt tên theo tên của mình, do đó là "Số Gryphon". EDIT: Cảm ơn @Surb đã mang đến cho tôi sự chú ý rằng thực tế là chuỗi này bằng với chuỗi OEIS A053696 - 1.

Số Gryphon là số có dạng $a+a^2+...+a^x$ , trong đó cả $a$ và $x$ là các số nguyên lớn hơn hoặc bằng hai và chuỗi Gryphon là tập hợp của tất cả các số Gryphon theo thứ tự tăng dần. Nếu có nhiều cách để tạo thành một số Gryphon (ví dụ đầu tiên là $30$ , đó là cả $2+2^2+2^3+2^4$ và $5+5^2$ ) con số này chỉ tính một lần trong chuỗi. Một số số Gryphon đầu tiên là:$6, 12, 14, 20, 30, 39, 42, 56, 62, 72$ .

Nhiệm vụ của bạn:

Viết chương trình hoặc hàm nhận số nguyên $n$ làm đầu vào và xuất số Gryphon thứ $n$ .

Đầu vào:

Một số nguyên từ 0 đến 10000 (đã bao gồm). Bạn có thể coi chuỗi là 0-index hoặc 1-index, tùy theo bạn thích. Vui lòng cho biết hệ thống lập chỉ mục nào bạn sử dụng trong câu trả lời của mình để tránh nhầm lẫn.

Đầu ra:

Số Gryphon tương ứng với đầu vào.

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

Xin lưu ý rằng điều này giả sử chuỗi là 0-index. Nếu chương trình của bạn giả sử chuỗi 1 chỉ mục, đừng quên tăng tất cả các số đầu vào.

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

Ghi điểm:

Đây là môn đánh gôn , vì vậy điểm số thấp nhất tính bằng byte sẽ thắng.

Thạch , 9 byte

bṖ’ḅi-µ#Ṫ

Một chương trình đầy đủ đọc số nguyên (1 chỉ mục) từ STDIN và in kết quả.

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

Làm sao?

Số Gryphon là một số có thể biểu thị trong một cơ sở nhỏ hơn chính nó sao cho tất cả các chữ số là số trừ số ít có ý nghĩa nhất, là số không. Ví dụ:

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

Chương trình này thực hiện n, sau đó bắt đầu v=0và kiểm tra thuộc tính này và tăng dần vcho đến khi tìm thấy nsố đó, sau đó xuất ra số cuối cùng.

Để kiểm tra một bsố cơ sở, nó trừ một từ mỗi chữ số, chuyển đổi từ cơ sở vvà sau đó kiểm tra xem kết quả có phải là $-1$ . (Lưu ý blà ít hơn 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 byte

:Qtt!^Ys+uSG)

1 dựa.

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

Giải trình

Hãy xem xét đầu vào n = 3là một ví dụ.

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

Ma trận thu được trong bước (*) chứa các số Gryphon có thể lặp lại. Đặc biệt, nó chứa ncác số Gryphon riêng biệt trong hàng đầu tiên. Đây không nhất thiết là nsố Gryphon nhỏ nhất. Tuy nhiên, mục dưới bên trái 2+2^+···+2^n vượt quá mục trên bên phải n+n^2và do đó, tất cả các số ở hàng cuối cùng vượt quá các mục trong hàng đầu tiên. Điều này ngụ ý rằng việc mở rộng ma trận sang phải hoặc xuống sẽ không đóng góp bất kỳ số Gryphon nào thấp hơn các nsố thấp nhất trong ma trận. Do đó, ma trận được đảm bảo chứa các nsố Gryphon nhỏ nhất. Do đó, nyếu tố duy nhất thấp nhất của nó là giải pháp.

Haskell , 53 byte

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

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

$\newcommand{\ta}{{a}}\newcommand{\ti}{{i}}\newcommand{\tx}{{x}}\newcommand{\tn}{{n}}\newcommand{\ty}{{y}}$Một số $\tn$ là Gryphon nếu tồn tại các số nguyên $\ta \geq 2$ và $\tx \geq 2$ sao cho $\tn=\sum_{i=1}^\tx \ta^i$ .

Chúng tôi tạo ra một danh sách vô hạn của tất cả $\tn \geq 6$ sao cho một tìm kiếm vũ phu cho thấy đây là trường hợp.

Câu trả lời là hàm chỉ mục (không có chỉ mục) trong danh sách này, được ký hiệu là Haskell là (list!!) .

Tại sao lại a^y+n==n*a+ađúng?

Từ công thức tính tổng tiến trình hình học :

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

chúng ta có, cho $(\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

Là tìm kiếm cho đến khi nđủ?

• Nếu $\ta > \tn$ (nói cách khác, $\ta \geq \tn+1$ ), sau đó

  $$\ta^\ty + \tn > \ta^2 \geq (\tn+1)\ta = \tn\ta + \ta$$ trong đó chứng minh $\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}{{}^{*}}$$2^{n-1}>n+1$$n \geq 6$}

Python 3.8 (Phát hành trước) , 98 92 89 78 71 byte

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

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

Chỉ số 0. Phân chia số nguyên phải được sử dụng ở đây vì f (10000) tràn ra.

$2 \leq a \leq n+2$$2 \leq x \leq n+2$$n$

-6 byte nhờ Jonathan Allan

-3 byte nhờ ArBo. Tôi gần như đã làm như anh ấy đề nghị, nhưng cố gắng sử dụng {*(...)}mà không tiết kiệm không gian

-11 byte nhờ mathmandan

-7 byte nhờ ArBo

Bằng chứng toán học về tính hợp lệ

Sử dụng lập chỉ mục 0 cho mục đích chứng minh này, mặc dù quy ước toán học là 1 chỉ mục.

• Để cho $G_n$ là $n$số Gryphon
• Để cho $g(a,x) = a + a^2 + ... + a^x$ (The Gryphon number from $a$ and $x$)
• Let $A_n$ be the set of all Gryphon numbers where $2 \leq a \leq n+2$ and $2 \leq x \leq n+2$
• We know that $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)$ for all $a$ and $x$
• $g(a, x+1) < g(a+1, x+1)$ for all $a$ and $x$
• Therefore $G_{n+1} \neq g(a+1, x+1)$ if $G_n = g(a, x)$
• $g(a+1, x) < g(a+2, x)$ for all $a$ and $x$
• $g(a, x+1) < g(a, x+2)$ for all $a$ and $x$
• Therefore $G_{n+1}$ must either be $g(a+1, x)$ or $g(a, x+1)$ if $G_n = g(a, x)$ since no other possibilities exist.
• We can use this information to conclude that $G_{n+1} \in A_{n+1}$ if $G_n \in A_n$
• Since we know that $G_0 \in A_0$, we can use this rule to induce that $G_n \in A_n$ for all $n$
• Since this can be applied from $G_0$ to $G_n$, then $G_n$ must be at index $n$ of $A_n$ if $A_n$ is ordered from smallest to largest

J, ³⁵ 32 bytes

-3 bytes thanks to FrownyFrog

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

Try it online!

Explanation is same as original. Simply uses explicit form to save bytes be removing the multiple @.

original answer, tacit, with explanation: 35 bytes

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

Try it online!

Similar to Luis Mendo's approach, we create a "power table" (like a times table) with top row 2 3 ... n and left column 1 2 ... n resulting in:

 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

^~/ >: creates the table, and 1+i.@+&2 creates the 1... n sequences, and we add 2 (+&2) to the input to ensure we always have enough elements to create a table even for 0 or 1 inputs.

After we have the table above the solution is trivial. We just scan sum the rows +/\, and then remove the first row, flatten, take unique, and sort /:~@~.@,@}.. Finally { uses the original input to index into that result, producing the answer.

Gaia, 18 bytes

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

Try it online!

1-based index.

This is a rather sad answer with a long nose: )┅: It probably wishes it could be golfed down further.

Copies the algorithm given by Luis Mendo's answer

R, 65 62 bytes

-1 byte thanks to Giuseppe.

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

Try it online!

1-indexed.

Generates a matrix of all values of the form $a^i$, takes the cumulative sum, removes the first row (0s) and the second row (entries corresponding to $x=1$), then takes the unique sorted values.

Note that sort(unique(...)) would not work, as unique would give unique rows of the matrix, and not unique entries. Using unique(sort(...)) works because sort converts to vector.

JavaScript (ES7), 76 bytes

1-indexed.

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

Try it online!

JavaScript (ES7), 89 bytes

1-indexed.

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

Try it online!

Wolfram Language (Mathematica), 51 bytes

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

Try it online!

1-indexed

-8 bytes from @attinat

Charcoal, 36 bytes

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

Try it online! Link is to verbose version of code. 1-indexed. Uses Luis Mendo's algorithm. Explanation:

Ｎθ

Input $n$.

ＦθＦθ⊞υ

Create an $n$-by-$n$ grid of Gryphon numbers and push each one to the predefined list.

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

Calculate the Gryphon number using the fact that $\sum_1^x a^i = \frac{a^{x+1}-a}{a-1}$.

Ｆ⊖θ≔Φυ›κ⌊υυ

Remove the lowest $n-1$ Gryphon numbers.

Ｉ⌊υ

Print the lowest remaining Gryphon number.

Japt, 23 bytes

Dear Jebus! Either I really have forgotten how to golf or the booze is finally taking its toll!

Not a direct port of Jonathan's solution but very much inspired by his observation.

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

Try it

05AB1E, 12 bytes

L¦ãε`LmO}êIè

0-indexed

Try it online or verify the first $n$ items.

Explanation:

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)