Ich habe mir neulich eine Reihe von Nummern ausgedacht und mich entschlossen, die OEIS-Nummer zu überprüfen. Zu meiner großen Überraschung befand sich die Sequenz anscheinend nicht in der OEIS-Datenbank, daher habe ich beschlossen, die Sequenz nach mir zu benennen (beachten Sie, dass sich jemand anderes, der viel schlauer als ich ist, dies wahrscheinlich bereits ausgedacht hat und falls jemand das findet) Tatsächlicher Name dieser Sequenz, bitte kommentieren und ich ändere den Fragentitel). Da ich die Sequenz nirgendwo finden konnte, beschloss ich, sie nach mir zu benennen, daher "Gryphon Numbers". EDIT: Vielen Dank an @Surb, der mich darauf aufmerksam gemacht hat, dass diese Sequenz der OEIS-Sequenz A053696-1 entspricht .

Eine Gryphon-Zahl ist eine Zahl der Form , wobei sowohl als auch ganze Zahlen größer oder gleich zwei sind und die Gryphon-Folge die Menge aller Gryphon-Zahlen in aufsteigender Reihenfolge ist bestellen. Wenn es mehrere Möglichkeiten gibt, eine Gryphon-Nummer zu bilden (das erste Beispiel ist , was sowohl als auch ), wird die Nummer in der Sequenz nur einmal gezählt. Die ersten paar Gryphon-Zahlen sind: .$a+a^2+...+a^x$$a$$x$$30$$2+2^2+2^3+2^4$$5+5^2$$6, 12, 14, 20, 30, 39, 42, 56, 62, 72$

Deine Aufgabe:

Schreiben Sie ein Programm oder eine Funktion, die eine Ganzzahl als Eingabe empfängt und die te Gryphon-Nummer ausgibt . $n$$n$

Eingang:

Eine ganze Zahl zwischen 0 und 10000 (einschließlich). Sie können die Sequenz entweder als 0-indexiert oder als 1-indexiert behandeln, je nachdem, was Sie bevorzugen. Bitte geben Sie an, welches Indexsystem Sie in Ihrer Antwort verwenden, um Verwirrung zu vermeiden.

Ausgabe:

Die der Eingabe entsprechende Gryphon-Nummer.

Testfälle:

Bitte beachten Sie, dass davon ausgegangen wird, dass die Sequenz 0-indiziert ist. Wenn Ihr Programm eine 1-indizierte Sequenz annimmt, vergessen Sie nicht, alle eingegebenen Zahlen zu erhöhen.

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

Wertung:

Das ist Code-Golf , also gewinnt die niedrigste Punktzahl in Bytes.

Gelee , 9 Bytes

bṖ’ḅi-µ#Ṫ

Ein vollständiges Programm, das eine (1-indizierte) Ganzzahl aus STDIN liest und das Ergebnis ausgibt.

Probieren Sie es online!

Wie?

Eine Gryphon-Zahl ist eine Zahl, die in einer Basis ausgedrückt werden kann, die kleiner ist als sie selbst, so dass alle Ziffern Einsen sind, mit Ausnahme der niedrigstwertigen Ziffer, die eine Null ist. Beispielsweise:

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

Dieses Programm nimmt n, startet v=0und testet diese Eigenschaft und erhöht sie, vbis es nsolche Zahlen findet, und gibt dann die letzte aus.

Um eine Basiszahl zu testen b, subtrahiert sie eine von jeder Ziffer, konvertiert von der Basis vund prüft dann, ob das Ergebnis $-1$ . (Beachten Sie, dass bweniger als 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)

1-basiert.

Probieren Sie es online!

Erläuterung

Betrachten Sie die Eingabe n = 3als Beispiel.

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

Die in Schritt (*) erhaltene Matrix enthält möglicherweise wiederholte Gryphon-Zahlen. Insbesondere enthält es nverschiedene Gryphon-Nummern in seiner ersten Reihe. Dies sind nicht unbedingt die nkleinsten Gryphon-Zahlen. Der linke untere Eintrag 2+2^+···+2^n überschreitet jedoch den rechten oberen Eintrag n+n^2und daher überschreiten alle Nummern in der letzten Zeile die in der ersten Zeile. Dies impliziert, dass das Erweitern der Matrix nach rechts oder unten keine Gryphon-Zahl beitragen würde, die niedriger ist als die niedrigsten nZahlen in der Matrix. Daher enthält die Matrix garantiert die nkleinsten Gryphon-Zahlen. Folglich ist das nniedrigste eindeutige Element die Lösung.

Haskell , 53 Bytes

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

Probieren Sie es online!

$\newcommand{\ta}{{a}}\newcommand{\ti}{{i}}\newcommand{\tx}{{x}}\newcommand{\tn}{{n}}\newcommand{\ty}{{y}}$$\tn$$\ta \geq 2$$\tx \geq 2$$\tn=\sum_{i=1}^\tx \ta^i$

$\tn \geq 6$

Die Antwort ist eine (nullindexierte) Indexfunktion in dieser Liste, die in Haskell als bezeichnet wird (list!!).

Warum ist das a^y+n==n*a+arichtig?

Aus der Formel zur Summierung eines geometrischen Verlaufs :

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

Sucht bis ngenug?

• $\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 (Vorabversion) , 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]

Probieren Sie es online!

0-indiziert. Hier muss eine Ganzzahldivision verwendet werden, da f (10000) überläuft.

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

-6 Bytes dank Jonathan Allan

-3 Bytes dank ArBo. Ich hätte fast getan, was er mir vorschlug, aber ich habe versucht, etwas zu verwenden, {*(...)}was sowieso keinen Platz sparte

-11 bytes dank mathmandan

-7 Bytes dank ArBo

Mathematischer Gültigkeitsnachweis

Verwenden der 0-Indizierung für diesen Beweis, obwohl die mathematische Konvention 1-indiziert ist.

• $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 dank FrownyFrog

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

Probieren Sie es online!

Erklärung ist die gleiche wie im Original. Verwendet einfach eine explizite Form, um Bytes zu speichern, indem das Mehrfache entfernt wird @.

Originalantwort, stillschweigend, mit Erklärung: 35 Bytes

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

Probieren Sie es online!

Ähnlich wie Luis Mendo Ansatz haben wir eine „Power - Tabelle“ (wie ein mal Tabelle) mit oberen Reihe erstellen 2 3 ... nund linke Spalte 1 2 ... nergibt:

 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

^~/ >:erstellt die Tabelle und 1+i.@+&2erstellt die 1... nSequenzen, und wir fügen +&2der Eingabe 2 ( ) hinzu, um sicherzustellen, dass immer genügend Elemente vorhanden sind, um eine Tabelle auch für 0- oder 1-Eingaben zu erstellen.

Nachdem wir die Tabelle oben haben, ist die Lösung trivial. Wir scannen einfach die Zeilen +/\und entfernen dann die erste Zeile, reduzieren, nehmen eindeutige und sortieren /:~@~.@,@}.. Schließlich {verwendet den ursprünglichen Eingang Index in dieses Ergebnis die Antwort zu erzeugen.

Gaia , 18 Bytes

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

Probieren Sie es online!

1-basierter Index.

Dies ist eine ziemlich traurige Antwort mit einer langen Nase: )┅:Es wünscht sich wahrscheinlich, es könnte weiter abgespielt werden.

Kopiert den von Luis Mendo angegebenen Algorithmus

R , 65 62 Bytes

-1 Byte danke an Giuseppe.

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

Probieren Sie es online!

1-indiziert.

$a^i$$x=1$

Beachten Sie, dass sort(unique(...))dies nicht funktionieren würde, da uniquees eindeutige Zeilen der Matrix und keine eindeutigen Einträge geben würde. Mit unique(sort(...))funktioniert , weil sortKonvertiten zum Vektor.

JavaScript (ES7), 76 Byte

1-indiziert.

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

Probieren Sie es online!

JavaScript (ES7), 89 Byte

1-indiziert.

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

Probieren Sie es online!

Wolfram Language (Mathematica) , 51 Byte

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

Probieren Sie es online!

1-indiziert

-8 Bytes von @attinat

Kohle , 36 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. 1-indiziert. Verwendet den Algorithmus von Luis Mendo. Erläuterung:

Ｎθ

$n$

ＦθＦθ⊞υ

Erstelle ein $n$$n$

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

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

Ｆ⊖θ≔Φυ›κ⌊υυ

$n-1$

Ｉ⌊υ

Drucken Sie die niedrigste verbleibende Gryphon-Nummer.

Japt , 23 Bytes

Lieber Jebus! Entweder habe ich das Golfen wirklich vergessen oder der Alkohol fordert endlich seinen Tribut!

Kein direkter Hafen von Jonathans Lösung, aber sehr inspiriert von seiner Beobachtung.

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

Versuch es

05AB1E , 12 Bytes

L¦ãε`LmO}êIè

0-indiziert

$n$ .

Erläuterung:

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)