Eu vim com uma série de números no outro dia e decidi verificar qual era o número OEIS. Para minha surpresa, a sequência não parecia estar no banco de dados da OEIS, então decidi nomear a sequência depois de mim mesmo (observe que alguém que é muito mais inteligente do que eu provavelmente já sugeriu isso, e se alguém encontrar o nome real dessa sequência, comente e alterarei o título da pergunta). Como não consegui encontrar a sequência em nenhum lugar, decidi dar um nome a ela mesma, daí "Gryphon Numbers". EDIT: Obrigado a @Surb por trazer à minha atenção o fato de que essa sequência é igual à sequência OEIS A053696 - 1.

Um número Gryphon é um número da forma $a+a^2+...+a^x$ , em que $a$ e $x$ são números inteiros maiores ou iguais a dois, e a sequência Gryphon é o conjunto de todos os números Gryphon em ordem crescente. Se houver várias maneiras de formar um número Gryphon (o primeiro exemplo é $30$ , que é $2+2^2+2^3+2^4$ e $5+5^2$ ), o número é contado apenas uma vez na sequência. Os primeiros números da Gryphon são:$6, 12, 14, 20, 30, 39, 42, 56, 62, 72$ .

Sua tarefa:

Escrever um programa ou função que recebe um número inteiro $n$ como entrada e emite o $n$ th número de Gryphon.

Entrada:

Um número inteiro entre 0 e 10000 (inclusive). Você pode tratar a sequência como indexada 0 ou 1, conforme sua preferência. Indique qual sistema de indexação você usa em sua resposta para evitar confusão.

Saída:

O número do Gryphon correspondente à entrada.

Casos de teste:

Observe que isso pressupõe que a sequência seja indexada em 0. Se o seu programa assume uma sequência indexada em 1, não se esqueça de incrementar todos os números de entrada.

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

Pontuação:

Isso é código-golfe , então a pontuação mais baixa em bytes vence.

Geléia , 9 bytes

bṖ’ḅi-µ#Ṫ

Um programa completo que lê um número inteiro (1-indexado) de STDIN e imprime o resultado.

Experimente online!

Quão?

Um número Gryphon é um número que é expressável em uma base inferior a si mesmo, de modo que todos os dígitos sejam um, exceto o menos significativo, que é zero. Por exemplo:

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

Este programa pega n, depois inicia v=0e testa essa propriedade e incrementa vaté encontrar nesses números, e emite o último.

Para testar um bnúmero base , subtrai um de cada dígito, converte da base ve depois verifica se o resultado é $-1$ . (Observe que bé menor que 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 bytes

:Qtt!^Ys+uSG)

Baseado em 1.

Experimente online!

Explicação

Considere a entrada n = 3como um exemplo.

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

A matriz obtida na etapa (*) contém possivelmente números repetidos de Gryphon. Em particular, ele contém nnúmeros Gryphon distintos em sua primeira linha. Estes não são necessariamente os nmenores números de Grifos. No entanto, a entrada inferior esquerda 2+2^+···+2^n excede a entrada superior direita n+n^2e, portanto, todos os números na última linha excedem os da primeira linha. Isso implica que estender a matriz para a direita ou para baixo não contribuiria com nenhum número de Gryphon menor que os nnúmeros mais baixos da matriz. Portanto, é garantido que a matriz contenha os nmenores números de Grifos. Conseqüentemente, seu nmenor elemento exclusivo mais baixo é a solução.

Haskell , 53 bytes

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

Experimente online!

$\newcommand{\ta}{{a}}\newcommand{\ti}{{i}}\newcommand{\tx}{{x}}\newcommand{\tn}{{n}}\newcommand{\ty}{{y}}$Um número é Gryphon se existirem números inteiros e tais que .$\tn$$\ta \geq 2$$\tx \geq 2$$\tn=\sum_{i=1}^\tx \ta^i$

Geramos uma lista infinita de todos os , modo que uma pesquisa de força bruta mostre que este é o caso.$\tn \geq 6$

A resposta é uma função de índice (indexada a zero) nesta lista, indicada em Haskell como (list!!).

Por que está a^y+n==n*a+acorreto?

Da fórmula para somar uma progressão geométrica :

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

Está pesquisando até o nsuficiente?

• $\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}{{}^{*}}$$2^{n-1}>n+1$$n \geq 6$}

Python 3.8 (pré-lançamento) , 98 92 89 78 71 bytes

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

Experimente online!

Indexado a 0. A divisão de números inteiros deve ser usada aqui porque o excesso de f (10000) flutua.

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

-6 bytes graças a Jonathan Allan

-3 bytes graças ao ArBo. Eu quase fiz como ele me sugeriu, mas tentei usar o {*(...)}que não economizava espaço de qualquer maneira

-11 bytes graças a mathmandan

-7 bytes graças ao ArBo

Prova matemática de validade

Utilizando a indexação 0 para fins desta prova, mesmo que a convenção matemática seja indexada 1.

• $G_n$$n$
• $g(a,x) = a + a^2 + ... + a^x$$a$$x$
• $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 bytes

-3 bytes graças ao FrownyFrog

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

Experimente online!

A explicação é igual ao original. Simplesmente usa forma explícita para salvar bytes e remover o múltiplo @.

resposta original, tácita, com explicação: 35 bytes

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

Experimente online!

Semelhante à abordagem de Luis Mendo, criamos uma "tabela de poder" (como uma tabela de tempos) com a linha superior 2 3 ... ne a coluna esquerda 1 2 ... nresultando em:

 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

^~/ >:cria a tabela, 1+i.@+&2cria as 1... nseqüências e adicionamos 2 ( +&2) à entrada para garantir que sempre tenhamos elementos suficientes para criar uma tabela, mesmo para as entradas 0 ou 1.

Depois de termos a tabela acima, a solução é trivial. Apenas digitalizamos a soma das linhas +/\e, em seguida, removemos a primeira linha, achatamos, assumimos uma classificação exclusiva e classificamos /:~@~.@,@}.. Finalmente, {usa a entrada original para indexar esse resultado, produzindo a resposta.

Gaia , 18 bytes

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

Experimente online!

Índice baseado em 1.

Esta é uma resposta bastante triste, com um nariz comprido: )┅:provavelmente deseja que ele possa ser jogado mais longe.

Copia o algoritmo dado pela resposta de Luis Mendo

R , 65 bytes 62

-1 byte graças a Giuseppe.

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

Experimente online!

1 indexado.

$a^i$$x=1$

Observe que sort(unique(...))não funcionaria, pois uniquedaria linhas únicas da matriz e não entradas exclusivas. Usar unique(sort(...))funciona porque sortconverte em vetor.

JavaScript (ES7), 76 bytes

1 indexado.

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

Experimente online!

JavaScript (ES7), 89 bytes

1 indexado.

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

Experimente online!

Wolfram Language (Mathematica) , 51 bytes

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

Experimente online!

Indexado 1

-8 bytes de @attinat

Carvão , 36 bytes

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

Experimente online! Link é a versão detalhada do código. 1 indexado. Usa o algoritmo de Luis Mendo. Explicação:

Ｎθ

$n$

ＦθＦθ⊞υ

$n$$n$

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

$\sum_1^x a^i = \frac{a^{x+1}-a}{a-1}$

Ｆ⊖θ≔Φυ›κ⌊υυ

$n-1$

Ｉ⌊υ

Imprima o número Gryphon restante mais baixo.

Japonês , 23 bytes

Caro Jebus! Ou eu realmente esqueci como jogar golfe ou a bebida finalmente está cobrando seu preço!

Não é um porto direto da solução de Jonathan, mas muito inspirado por sua observação.

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

Tente

05AB1E , 12 bytes

L¦ãε`LmO}êIè

Indexado a 0

$n$

Explicação:

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)