L'altro giorno ho inventato una serie di numeri e ho deciso di verificare quale fosse il numero OEIS. Con mia grande sorpresa, la sequenza non sembrava essere nel database OEIS, quindi ho deciso di nominare la sequenza come me stessa (nota che qualcun altro che è molto più intelligente di me probabilmente ha già trovato questo, e se qualcuno trova il nome effettivo di questa sequenza, si prega di commentare e cambierò il titolo della domanda). Dato che non riuscivo a trovare la sequenza da nessuna parte, ho deciso di chiamarla come me, da cui "Gryphon Numbers". EDIT: Grazie a @Surb per avermi segnalato che questa sequenza è uguale alla sequenza OEIS A053696 - 1.

Un numero di Gryphon è un numero della forma $a+a^2+...+a^x$ , dove sia $a$ che $x$ sono numeri interi maggiori o uguali a due e la sequenza di Gryphon è l'insieme di tutti i numeri di Gryphon in ordine crescente. Se ci sono diversi modi per formare un numero di Grifone (il primo esempio è $30$ , che è sia che ) il numero viene conteggiato una sola volta nella sequenza. I primi pochi numeri di Gryphon sono: .$2+2^2+2^3+2^4$$5+5^2$$6, 12, 14, 20, 30, 39, 42, 56, 62, 72$

Il tuo compito:

Scrivere un programma o una funzione che riceve un numero intero in ingresso ed emette il -esimo numero Gryphon. $n$$n$

Ingresso:

Un numero intero compreso tra 0 e 10000 (incluso). Puoi considerare la sequenza come 0-indicizzata o 1-indicizzata, come preferisci. Indica quale sistema di indicizzazione usi nella tua risposta per evitare confusione.

Produzione:

Il numero di Gryphon corrispondente all'ingresso.

Casi test:

Si noti che ciò presuppone che la sequenza sia indicizzata a 0. Se il tuo programma assume una sequenza con 1 indice, non dimenticare di incrementare tutti i numeri di input.

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

punteggio:

Questo è code-golf , quindi vince il punteggio più basso in byte.

Gelatina , 9 byte

bṖ’ḅi-µ#Ṫ

Un programma completo che legge un numero intero (1-indicizzato) da STDIN e stampa il risultato.

Provalo online!

Come?

Un numero di Gryphon è un numero che è espressibile in una base inferiore a se stesso in modo tale che tutte le cifre siano una tranne la meno significativa, che è uno zero. Per esempio:

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

Questo programma accetta n, quindi inizia v=0e verifica questa proprietà e aumenta vfino a trovare ntali numeri, quindi emette quello finale.

Per verificare un bnumero di base, ne sottrae uno da ogni cifra, converte dalla base ve quindi controlla se il risultato è $-1$ . (Nota che bè inferiore a 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-based.

Provalo online!

Spiegazione

Considera l'input n = 3come esempio.

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

La matrice ottenuta nel passaggio (*) contiene numeri di Gryphon eventualmente ripetuti. In particolare, contiene nnumeri Gryphon distinti nella sua prima riga. Questi non sono necessariamente i nnumeri Gryphon più piccoli. Tuttavia, la voce in basso a sinistra 2+2^+···+2^n supera quella in alto a destra n+n^2, e quindi tutti i numeri nell'ultima riga superano quelli nella prima riga. Ciò implica che l'estensione della matrice verso destra o verso il basso non contribuirebbe con un numero di Gryphon inferiore ai nnumeri più bassi nella matrice. Pertanto, è garantito che la matrice contenga i nnumeri Gryphon più piccoli. Di conseguenza, il suo nelemento univoco più basso è la soluzione.

Haskell , 53 byte

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

Provalo online!

$\newcommand{\ta}{{a}}\newcommand{\ti}{{i}}\newcommand{\tx}{{x}}\newcommand{\tn}{{n}}\newcommand{\ty}{{y}}$Un numero $\tn$ è Gryphon se esistono numeri interi $\ta \geq 2$ e $\tx \geq 2$ tali che $\tn=\sum_{i=1}^\tx \ta^i$ .

Generiamo un elenco infinito di tutti $\tn \geq 6$ tale che una ricerca di forza bruta mostri che è così.

La risposta è una funzione di indice (a zero) in questo elenco, indicata in Haskell come (list!!).

Perché è a^y+n==n*a+acorretto?

Dalla formula per sommare una progressione geometrica :

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

abbiamo, lasciando $(\alpha, \rho, \nu) = (\ta, \ta, \tx)$ :

Riorganizzando l'equazione, otteniamo $n(1-a) = a - a^{x+1}$ .

Riorganizzando ulteriormente ciò, otteniamo $\ta^{\tx+1}+n = \tn \ta + \ta$ .

Una sostituzione $\ty = \tx+1$ nella ricerca della forza bruta produce l'espressione finale a^y+n=n*a+a.

La ricerca è nabbastanza?

• Se $\ta > \tn$ (in altre parole, $\ta \geq \tn+1$ ), quindi

  $$\ta^\ty + \tn > \ta^2 \geq (\tn+1)\ta = \tn\ta + \ta$$ che risulta $\ta^\ty+\tn \neq \tn\ta+\ta$ . Quindi non ha senso controllare nessuno dei valori $\ta > \tn$ .

• Allo stesso modo: se $\ty > \tn$ , quindi

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

  ^{$\color{red}{{}^{*}}$ Possiamo assumere$2^{n-1}>n+1$perché conosciamo$n \geq 6$}

Python 3.8 (pre-release) , 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]

Provalo online!

0-indicizzati. La divisione intera deve essere utilizzata qui perché f (10000) trabocca float.

$2 \leq a \leq n+2$ and $2 \leq x \leq n+2$, sorts them, and selects the $n$th element.

-6 bytes thanks to Jonathan Allan

-3 bytes thanks to ArBo. I almost did as he suggested myself, but tried to use {*(...)} which didn't save space anyway

-11 bytes thanks to mathmandan

-7 bytes thanks to ArBo

Mathematical Proof of Validity

Using 0-indexing for the sake of this proof, even though mathematical convention is 1-indexed.

• Let $G_n$ be the $n$th Gryphon number
• Let $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 byte

-3 byte grazie a FrownyFrog

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

Provalo online!

La spiegazione è uguale all'originale. Utilizza semplicemente il modulo esplicito per salvare i byte rimuovendo il multiplo @.

risposta originale, tacita, con spiegazione: 35 byte

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

Provalo online!

Simile all'approccio di Luis Mendo, creiamo una "tabella di potenza" (come una tabella dei tempi) con la riga superiore 2 3 ... ne la colonna di sinistra che 1 2 ... nrisulta 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

^~/ >:crea la tabella e 1+i.@+&2crea le 1... nsequenze e aggiungiamo 2 ( +&2) all'input per assicurarci di avere sempre abbastanza elementi per creare una tabella anche per 0 o 1 input.

Dopo che abbiamo la tabella sopra la soluzione è banale. Scansioniamo semplicemente la somma delle righe +/\, quindi rimuoviamo la prima riga, appiattiamo, prendiamo univoco e ordiniamo /:~@~.@,@}.. Infine {utilizza l'input originale per indicizzare quel risultato, producendo la risposta.

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 byte

1-indicizzati.

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

Provalo online!

JavaScript (ES7), 89 byte

1-indicizzati.

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

Provalo online!

Wolfram Language (Mathematica), 51 bytes

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

Try it online!

1-indexed

-8 bytes from @attinat

Carbone , 36 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. 1-indicizzati. Utilizza l'algoritmo di Luis Mendo. Spiegazione:

Ｎθ

Ingresso $n$.

ＦθＦθ⊞υ

Creare un $n$-di-$n$ griglia di numeri Gryphon e spingere ognuno nella lista predefinita.

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

Calcola il numero di Gryphon usando il fatto che $\sum_1^x a^i = \frac{a^{x+1}-a}{a-1}$.

Ｆ⊖θ≔Φυ›κ⌊υυ

Rimuovi il più basso $n-1$ Numeri di Grifone.

Ｉ⌊υ

Stampa il numero Gryphon rimanente più basso.

Japt , 23 byte

Caro Jebus! O ho davvero dimenticato come giocare a golf o l'alcol sta finalmente prendendo piede!

Non è un porto diretto della soluzione di Jonathan ma molto ispirato alla sua osservazione.

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

Provalo

05AB1E , 12 byte

L¦ãε`LmO}êIè

0-indicizzato

Provalo online o verifica il primo$n$articoli .

Spiegazione:

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)