I came up with a series of numbers the other day and decided to check what the OEIS number for it was. Much to my surprise, the sequence did not appear to be in the OEIS database, so I decided to name the sequence after myself (note that someone else who's a lot smarter than me has probably already come up with this, and if someone finds the actual name of this sequence, please comment and I'll change the question title). As I couldn't find the sequence anywhere, I decided to name it after myself, hence "Gryphon Numbers".

A Gryphon number is a number of the form $a+a^2+...+a^x$, where both $a$ and $x$ are integers greater than or equal to two, and the Gryphon sequence is the set of all Gryphon numbers in ascending order. If there are multiple ways of forming a Gryphon number (the first example is $30$, which is both $2+2^2+2^3+2^4$ and $5+5^2$) the number is only counted once in the sequence. The first few Gryphon numbers are: $6, 12, 14, 20, 30, 39, 42, 56, 62, 72$.

Your Task:

Write a program or function that receives an integer $n$ as input and outputs the $n$th Gryphon number.

Input:

An integer between 0 and 10000 (inclusive). You may treat the sequence as either 0-indexed or 1-indexed, whichever you prefer. Please state which indexing system you use in your answer to avoid confusion.

Output:

The Gryphon number corresponding to the input.

Test Cases:

Please note that this assumes the sequence is 0-indexed. If your program assumes a 1-indexed sequence, don't forget to increment all the input numbers.

Input: Output:
0 ---> 6
3 ---> 20
4 ---> 30
10 ---> 84

Scoring:

This is code-golf, so the lowest score in bytes wins.

MATL, 16 13 bytes

:Qtt!^Ys+uSG)

1-based.

Try it online!

Explanation

Consider input n = 3 as an example.

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

The matrix obtained in step (*) contains possibly repeated Gryphon numbers. In particular, it contains n distinct Gryphon numbers in its first row. These are not necessarily the n smallest Gryphon numbers. However, the lower-left entry 2+2^+···+2^n exceeds the upper-right entry n+n^2, and thus all the numbers in the last row exceed those in the first row. This implies that extending the matrix rightward or downward would not contribute any Gryphon number lower than the lowest n numbers in the matrix. Therefore, the matrix is guaranteed to contain the n smallest Gryphon numbers. Consequently, its n-th lowest unique element is the solution.

Wolfram Language (Mathematica), 59 bytes

Union[Join@@Table[Sum[n^k,k,j],j,2,30,n,2,7!2]][[#]]&

Try it online!

1-indexed

Jelly, 9 bytes

bṖ’ḅi-µ#Ṫ

A full program which reads a (1-indexed) integer from STDIN and prints the result.

Try it online!

How?

A Gryphon number is a number which is expressible in a base less than itself such that all the digits are ones except the least significant, which is a zero. For example:

$30=1times 2^4+1times 2^3+1times2^2+1times2^1+0times2^0$

$84=1times 4^3+1times 4^2+1times 4^1+0times 4^0$

This program takes n, then starts at v=0 and tests for this property and increments v until it finds n such numbers, then outputs the final one:

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

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!

R, 65 bytes

n=scan();unique(sort(apply(outer(2:n,1:n,"^"),1,cumsum)[-1,]))[n]

Try it online!

1-indexed.

Generates a matrix of all values of the form $a^i$, takes the cumulative sum, removes the entries corresponding to $x=1$ (first row), 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.