Geçen gün bir dizi numara buldum ve bunun için OEIS numarasının ne olduğunu kontrol etmeye karar verdim. Sürprizimden ötürü, dizi OEIS veritabanında görünmüyordu, bu yüzden diziyi kendimden sonra isimlendirmeye karar verdim (benden çok daha zeki bir başkasının muhtemelen çoktan bu konuyu gündeme getirdiğini ve eğer birisini bulduğunu unutmayın) Bu dizinin asıl adı, lütfen yorum yapın ve soru başlığını değiştireceğim). Diziyi hiçbir yerde bulamadığım için kendimden sonra “Gryphon Numbers” olarak adlandırmaya karar verdim. EDIT: Bu sekansın OEIS sekansı A053696 - 1'e eşit olduğu gerçeğini dikkatimi çektiğim için @Surb sayesinde .

Bir Gryphon numarası, $a+a^2+...+a^x$ formunun bir numarasıdır . . . + Bir x , hem de $a$ ve $x$ daha büyük tamsayılardır veya iki eşit ve Gryphon dizisi artan tüm Gryphon sayı dizisidir. Bir Gryphon numarası oluşturmanın birden fazla yolu varsa (ilk örnek $30$ , bu her ikisi de $2+2^2+2^3+2^4$ ve $5+5^2$ ), sayı yalnızca sekansta bir kez sayılır. İlk birkaç Gryphon numarası:$6, 12, 14, 20, 30, 39, 42, 56, 62, 72$ .

Senin görevin:

Bir tamsayıdır alan bir program ya da işlev Yazın $n$ girdi olarak alır ve çıktı olarak $n$ Gryphon sayıda inci.

Giriş:

0 ile 10000 arasında bir tam sayı (dahil). Diziyi, hangisini tercih ederseniz, 0 indeksli veya 1 indeksli olarak kabul edebilirsiniz. Lütfen karışıklığı önlemek için cevabınızda hangi indeksleme sistemini kullandığınızı belirtin.

Çıktı:

Girdiye karşılık gelen Gryphon numarası.

Test Durumları:

Lütfen, dizinin 0 indeksli olduğunu varsaydığını unutmayın. Programınız 1 indeksli bir dizilişe geçerse, tüm giriş numaralarını arttırmayı unutmayın.

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

puanlama:

Bu kod golf , yani bayt cinsinden en düşük puan kazanır.

Jöle , 9 bayt

bṖ’ḅi-µ#Ṫ

STDIN'den (1 indeksli) bir tam sayı okuyan ve sonucu basan tam bir program.

Çevrimiçi deneyin!

Nasıl?

Bir Gryphon numarası, bir bazda kendisinden daha az açık olan bir rakamdır, öyle ki tüm rakamlar, en az anlamlı olan hariçtir, sıfırdır. Örneğin:

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

Bu program nbaşlar, daha sonra başlar v=0ve bu özelliği test eder ve bu sayıları vbulana kadar artırır n, sonra sonunu çıkarır.

Bir temel bsayıyı test etmek için , her basamaktan bir tane çıkarır, tabandan dönüştürür vve sonucun $-1$ olup olmadığını kontrol eder . ( bDaha küçük olduğuna dikkat edin 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 bayt

:Qtt!^Ys+uSG)

1 tabanlı.

Çevrimiçi deneyin!

açıklama

n = 3Bir örnek olarak girişi düşünün .

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

(*) Adımında elde edilen matris muhtemelen tekrarlanan Gryphon numaralarını içerir. Özellikle, nilk satırında farklı Gryphon numaraları içerir . Bunlar mutlaka en nküçük Gryphon sayıları değildir. Ancak, sol alt giriş2+2^+···+2^n sağ üst aşıyor n+n^2ve bu nedenle son satırdaki tüm sayılar ilk satırdakileri aşıyor. Bu, matrisi sağa veya aşağıya uzatmanın, matristeki en düşük nsayılardan daha düşük herhangi bir Gryphon numarasına katkıda bulunmayacağı anlamına gelir . Bu nedenle, matrisin en nküçük Gryphon numaralarını içereceği garanti edilir . Sonuç olarak, nen düşük tekil benzersiz elemanı çözümdür.

Haskell , 53 bayt

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

Çevrimiçi deneyin!

$\newcommand{\ta}{{a}}\newcommand{\ti}{{i}}\newcommand{\tx}{{x}}\newcommand{\tn}{{n}}\newcommand{\ty}{{y}}$Bir dizi $\tn$ tamsayı var ise Gryphon olan $\ta \geq 2$ ve $\tx \geq 2$ , öyle ki $\tn=\sum_{i=1}^\tx \ta^i$ .

Sonsuz bir liste oluştururuz $\tn \geq 6$Bir kaba kuvvet araştırmasının durumun böyle olduğunu gösterecek şekilde n ≥ 6'nın.

Cevap, Haskell'de olduğu gibi bu listeye (sıfır indeksli) bir indeks fonksiyonudur (list!!).

Neden a^y+n==n*a+adoğru?

Kaynaktan bir geometrik ilerlemesi toplanmasıyla formül :

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

$(\alpha, \rho, \nu) = (\ta, \ta, \tx)$ izin verdik :

Denklemi yeniden düzenleyerek n ( 1 - a ) = a - a x + 1 elde ederiz.$n(1-a) = a - a^{x+1}$ .

Daha da ileri, biz olsun o yeniden düzenleme $\ta^{\tx+1}+n = \tn \ta + \ta$ .

Kaba kuvvet arayışındaki $\ty = \tx+1$ ikamesi son ifadeyi verir a^y+n=n*a+a.

Kadar aramaya mı n, yeterli uzunlukta?

• Eğer $\ta > \tn$ (diğer bir deyişle $\ta \geq \tn+1$ ) ise, o zaman

  $$\ta^\ty + \tn > \ta^2 \geq (\tn+1)\ta = \tn\ta + \ta$$ bu da $\ta^\ty+\tn \neq \tn\ta+\ta$ . Yani $\ta > \tn$ değerlerinden herhangi birini kontrol etmenin bir anlamı yoktur .

• Benzer şekilde: eğer $\ty > \tn$ , o zaman

  $$\ta^\ty + \tn > \ta^\tn = \ta^{\tn-1}\ta \geq 2^{\tn-1}\ta \stackrel{\color{red}*}> (\tn+1)\ta = \tn\ta + \ta,$$ tekrar $\ta^\ty + \tn \neq \tn\ta + \ta$ kanıtlayın + a .

  ^{$\color{red}{{}^{*}}$ Biz varsayabiliriz$2^{n-1}>n+1$Bildiğimiz çünkü$n \geq 6$, en küçük Gryphon numarası.}

Python 3.8 (Yayın öncesi) , 98 92 89 78 71 bayt

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

Çevrimiçi deneyin!

0 endeksli. Tam sayı bölümü burada kullanılmalıdır çünkü f (10000) taşması yüzer.

$2 \leq a \leq n+2$ ve $2 \leq x \leq n+2$ aldığı tüm Gryphon numaralarını oluşturur ve n'yi seçer.$n$ . Öğeyi .

Jonathan Allan sayesinde -6 bayt

ArBo sayesinde -3 bayt. Neredeyse kendimi önerdiği gibi yaptım ama kullanmaya çalıştım{*(...)} yine de yerden tasarruf etmedi

Mathmandan sayesinde -11 bayt

ArBo sayesinde -7 bayt

Matematiksel Geçerlilik Kanıtı

Matematiksel konvansiyon 1 indeksli olsa bile, bu ispat uğruna 0 indekslemenin kullanılması.

• Let $G_n$ olması $n$ Gryphon'un sayıda inci
• Let $g(a,x) = a + a^2 + ... + a^x$ den (Gryphon'un numarası $a$ ve $x$ )
• olsun$A_n$$2 \leq a \leq n+2$$2 \leq x \leq n+2$
• olduğunu biliyoruz.$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)