द Nth Gryphon नंबर

Question

मैं दूसरे दिन संख्याओं की एक श्रृंखला के साथ आया और यह जांचने का निर्णय लिया कि इसके लिए OEIS संख्या क्या थी। मेरे आश्चर्य से बहुत कुछ, अनुक्रम OEIS डेटाबेस में प्रकट नहीं हुआ था, इसलिए मैंने खुद के बाद अनुक्रम का नाम देने का निर्णय लिया (ध्यान दें कि कोई और जो मुझसे बहुत अधिक चालाक है वह शायद पहले से ही इस के साथ आया है, और यदि कोई उत्कृष्ट पाता है इस क्रम का वास्तविक नाम, कृपया टिप्पणी करें और मैं प्रश्न शीर्षक बदल दूंगा)। जैसा कि मुझे कहीं भी अनुक्रम नहीं मिला, मैंने इसे अपने नाम पर रखने का फैसला किया, इसलिए "ग्रिफ़ॉन नंबर"। संपादित करें: मेरा ध्यान इस तथ्य पर लाने के लिए @Surb के लिए धन्यवाद कि यह अनुक्रम OEIS अनुक्रम A053696 - 1 के बराबर है ।

एक Gryphon संख्या प्रपत्र की एक संख्या है $a+a^2+...+a^x$ , जहां दोनों $a$ और $x$ से बड़ा पूर्णांक हैं या दो के बराबर है, और Gryphon अनुक्रम आरोही क्रम में सभी Gryphon संख्या का सेट है। यदि Gryphon नंबर बनाने के कई तरीके हैं (पहला उदाहरण $30$ , जो $2+2^2+2^3+2^4$ और $5+5^2$ ) तो संख्या को केवल अनुक्रम में एक बार गिना जाता है। पहले कुछ Gryphon नंबर हैं:$6, 12, 14, 20, 30, 39, 42, 56, 62, 72$ ।

आपका कार्य:

एक प्रोग्राम या फ़ंक्शन लिखें जो एक पूर्णांक $n$ इनपुट के रूप में प्राप्त करता है और $n$ th Gryphon नंबर आउटपुट करता है ।

इनपुट:

0 और 10000 (सम्मिलित) के बीच एक पूर्णांक। आप अनुक्रम को 0-अनुक्रमित या 1-अनुक्रमित के रूप में मान सकते हैं, जो भी आप चाहें। कृपया बताएं कि भ्रम से बचने के लिए आप अपने जवाब में किस इंडेक्सिंग सिस्टम का उपयोग करते हैं।

आउटपुट:

इनपुट के अनुरूप Gryphon नंबर।

परीक्षण के मामलों:

कृपया ध्यान दें कि यह अनुक्रम 0-अनुक्रमित है। यदि आपका प्रोग्राम 1-अनुक्रमित अनुक्रम मानता है, तो सभी इनपुट संख्याओं को बढ़ाना न भूलें।

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

स्कोरिंग:

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम स्कोर जीतता है।

Comments

Gryphon अनुक्रम A053696 है - 1. दूसरे शब्दों में, A053696 के रूप की संख्या का बढ़ता क्रम है । $\color{red}{a^0}+a^1+\ldots+a^x$

— सर्ब

@ सुर, आह, इसीलिए मैं इसे खोज नहीं पाया। उस स्थिति में, मैं उस जानकारी को एक संपादन में डालूंगा, लेकिन शेष प्रश्न को उसी तरह से रखूंगा जब तक अनुक्रम के लिए एक बेहतर नाम नहीं लगता।

— ग्रिफ़ॉन -

Answer 1

जेली , 9 बाइट्स

bṖ’ḅi-µ#Ṫ

एक पूर्ण कार्यक्रम जो STDIN से एक (1-अनुक्रमित) पूर्णांक पढ़ता है और परिणाम प्रिंट करता है।

इसे ऑनलाइन आज़माएं!

कैसे?

एक ग्रिफ़ॉन संख्या एक संख्या है जो एक आधार से कम में व्यक्त होती है जैसे कि सभी अंक कम से कम महत्वपूर्ण को छोड़कर सभी हैं, जो एक शून्य है। उदाहरण के लिए:

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

यह कार्यक्रम लेता है n, फिर शुरू होता है v=0और इस संपत्ति और वेतन वृद्धि के लिए परीक्षण करता है vजब तक कि nइस तरह के नंबर नहीं मिलते हैं, तब अंतिम एक को आउटपुट करता है।

आधार bसंख्या का परीक्षण करने के लिए यह प्रत्येक अंक से एक घटाता है, आधार से परिवर्तित होता है v, और फिर जाँचता है कि क्या परिणाम है $-1$ । (ध्यान दें जो bइससे कम है 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

Answer 2

MATL , 16 13 बाइट्स

:Qtt!^Ys+uSG)

1 के आधार पर।

इसे ऑनलाइन आज़माएं!

व्याख्या

n = 3उदाहरण के रूप में इनपुट पर विचार करें ।

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

चरण (*) में प्राप्त मैट्रिक्स में संभवतः दोहराए गए ग्रिफ़ॉन नंबर होते हैं। विशेष रूप से, nइसकी पहली पंक्ति में अलग Gryphon नंबर होते हैं । ये जरूरी नहीं कि सबसे nछोटे ग्रिफ़ॉन नंबर हों। हालाँकि, निचली-बाईं प्रविष्टि 2+2^+···+2^n ऊपरी-दाएँ प्रविष्टि से अधिक है n+n^2, और इस प्रकार अंतिम पंक्ति की सभी संख्याएँ पहली पंक्ति में हैं। इसका तात्पर्य यह है कि मैट्रिक्स को दाहिने या नीचे की तरफ निकालने से nमैट्रिक्स में सबसे कम संख्या की तुलना में किसी भी ग्रिपफॉन नंबर का योगदान नहीं होगा । इसलिए, मैट्रिक्स को nसबसे छोटी ग्रिफ़ॉन संख्याओं को शामिल करने की गारंटी है । नतीजतन, इसका n-सबसे न्यूनतम अद्वितीय तत्व समाधान है।

Comments

क्या नर्क है, यह अद्भुत है!

— 143

Answer 3

हास्केल , 53 बाइट्स

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

इसे ऑनलाइन आज़माएं!

$\newcommand{\ta}{{a}}\newcommand{\ti}{{i}}\newcommand{\tx}{{x}}\newcommand{\tn}{{n}}\newcommand{\ty}{{y}}$अनेक $\tn$ Gryphon अगर वहाँ मौजूद पूर्णांक है $\ta \geq 2$ और $\tx \geq 2$ ऐसी है कि $\tn=\sum_{i=1}^\tx \ta^i$ ।

हम सब की एक अनंत सूची उत्पन्न $\tn \geq 6$ इस तरह के एक जानवर बल खोज से पता चलता है यह मामला है कि।

उत्तर इस सूची में एक (शून्य-अनुक्रमित) सूचकांक कार्य है, जिसे हास्केल में दर्शाया गया है (list!!)।

क्यों a^y+n==n*a+aसही है?

ज्यामितीय प्रगति के योग के सूत्र से :

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

हमारे पास है, दे $(\alpha, \rho, \nu) = (\ta, \ta, \tx)$ :

$$\tn = \sum_{\ti=1}^\tx \ta^\ti = \frac{\ta(1-\ta^\tx)}{1-\ta} = \frac{\ta-\ta^{\tx+1}}{1-\ta}.$$

समीकरण को फिर से व्यवस्थित करते हुए, हम $n(1-a) = a - a^{x+1}$ ।

फिर भी आगे बढ़ते हुए, हमें $\ta^{\tx+1}+n = \tn \ta + \ta$ ।

ब्रूट-बल खोज में एक प्रतिस्थापन $\ty = \tx+1$ अंतिम अभिव्यक्ति देता है a^y+n=n*a+a।

nपर्याप्त तक खोज कर रहा है?

• यदि $\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}{{}^{*}}$We can assume $2^{n-1}>n+1$ because we know $n \geq 6$, the smallest Gryphon number.}

Answer 4

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

Try it online!

0-indexed. Integer division must be used here because f(10000) overflows floats.

Generates all Gryphon numbers where $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)$ अगर $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$ सबसे छोटे से लेकर सबसे बड़े तक का ऑर्डर दिया जाता है

Comments

f= is unnecessary, and lambda n,r=range: will save 4 more (like so)

— Jonathan Allan

You can drop the set() and replace it by a set comprehension to get to 89

— ArBo

Also, you can remove the f= from the TIO link by putting it in the header, as in the TIO of my 89-byter

— ArBo

86 bytes with Python 3.8 and assignment expressions

— ovs

At the line "Therefore Gn+1≠(a+1,x+1) if Gn=g(a,x)" is a mistake, it should be Gn+1≠g(a+1,x+1) if ...

— IQuick 143

Answer 5

जे , ³⁵ 32 बाइट्स

-3 बाइट्स FrownyFrog के लिए धन्यवाद

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

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण मूल के समान है। बाइट को बचाने के लिए बस स्पष्ट रूप का उपयोग करता है कई को हटा रहा है @।

मूल उत्तर, टैसिट, स्पष्टीकरण के साथ: 35 बाइट्स

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

इसे ऑनलाइन आज़माएं!

लुइस मेंडो के दृष्टिकोण के समान, हम शीर्ष पंक्ति 2 3 ... nऔर बाएं कॉलम के साथ एक "पावर टेबल" (जैसे टाइम टेबल) बनाते 1 2 ... nहैं:

 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

^~/ >:तालिका बनाता है, और अनुक्रम 1+i.@+&2बनाता है 1... n, और हम +&2इनपुट को 2 ( ) जोड़ते हैं यह सुनिश्चित करने के लिए कि हमारे पास हमेशा 0 या 1 इनपुट के लिए तालिका बनाने के लिए पर्याप्त तत्व हैं।

हमारे पास समाधान के ऊपर की तालिका तुच्छ होने के बाद। हम बस पंक्तियों को स्कैन करते हैं +/\, और फिर पहली पंक्ति को हटाते हैं, समतल करते हैं, अद्वितीय लेते हैं, और सॉर्ट करते हैं /:~@~.@,@}.। अंत {में मूल इनपुट का उपयोग उस परिणाम में अनुक्रमित करने के लिए किया जाता है, जो उत्तर का निर्माण करता है।

Comments

स्पष्ट संकेतन 3 बचाता है

— FrownyFrog

धन्यवाद, अच्छा कैच।

— योना

Answer 6

गैया , 18 बाइट्स

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

इसे ऑनलाइन आज़माएं!

1-आधारित सूचकांक।

यह एक लंबी नाक के साथ एक बल्कि दु: खद जवाब है: )┅:यह शायद इच्छा है कि इसे और नीचे गिराया जा सकता है।

लुइस मेंडो के जवाब द्वारा दिए गए एल्गोरिदम की नकल करता है

Answer 7

आर , 65 62 बाइट्स

Giuseppe के लिए -1 बाइट धन्यवाद।

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

इसे ऑनलाइन आज़माएं!

1 अनुक्रमित।

प्रपत्र के सभी मानों का एक मैट्रिक्स बनाता है $a^i$, संचयी योग लेता है, पहली पंक्ति (0s) और दूसरी पंक्ति (इसके अनुरूप प्रविष्टियाँ) निकालता है $x=1$), तब अद्वितीय सॉर्ट किए गए मान लेता है।

ध्यान दें कि sort(unique(...))यह काम नहीं करेगा, क्योंकि uniqueमैट्रिक्स की अनूठी पंक्तियाँ, और अद्वितीय प्रविष्टियाँ नहीं होंगी। unique(sort(...))काम का उपयोग करना क्योंकि sortवेक्टर में कनवर्ट करता है ।

Comments

यह थोड़ा अधिक काम लेता है, लेकिन का उपयोग कर tऔर diffinvहै 64 बाइट्स

— ग्यूसेप

@Giuseppe धन्यवाद! मुझे नहीं पता था diffinv। मैं एक और 2 बाइट्स के [-1:-2,]साथ बदलकर नीचे गिरा दिया [3:n,]।

— रॉबिन राइडर

Answer 8

जावास्क्रिप्ट (ईएस 7), 76 बाइट्स

1 अनुक्रमित।

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

इसे ऑनलाइन आज़माएं!

---

जावास्क्रिप्ट (ईएस 7), 89 बाइट्स

1 अनुक्रमित।

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

इसे ऑनलाइन आज़माएं!

Answer 9

वोल्फ्राम भाषा (गणितज्ञ) , 51 बाइट्स

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

इसे ऑनलाइन आज़माएं!

1 अनुक्रमित

-8 बाइट्स @attinat से

Comments

51 बाइट्स

— attinat

एक स्पष्टीकरण अच्छा होगा।

— dfeuer

Answer 10

चारकोल , 36 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। 1 अनुक्रमित। लुइस मेन्डो के एल्गोरिथ्म का उपयोग करता है। स्पष्टीकरण:

Ｎθ

इनपुट $n$।

ＦθＦθ⊞υ

बनाओ $n$-द्वारा-$n$ ग्रीफॉन नंबरों की ग्रिड और प्रत्येक को पूर्वनिर्धारित सूची में धकेलें।

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

इस तथ्य का उपयोग करके ग्रिफ़ॉन संख्या की गणना करें कि $\sum_1^x a^i = \frac{a^{x+1}-a}{a-1}$।

Ｆ⊖θ≔Φυ›κ⌊υυ

निम्नतम निकालें $n-1$ Gryphon नंबर।

Ｉ⌊υ

शेष शेष ग्रिपफॉन संख्या को प्रिंट करें।

Answer 11

जाप , 23 बाइट्स

प्रिय जेबस! या तो मैं वास्तव में भूल गया हूँ कि गोल्फ या बूज़ आखिर कैसे टोल ले रहा है!

जोनाथन के समाधान का प्रत्यक्ष बंदरगाह नहीं, लेकिन उनके अवलोकन से बहुत प्रेरित है।

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

कोशिश करो

Answer 12

05AB1E , 12 बाइट्स

L¦ãε`LmO}êIè

0 अनुक्रमित

इसे ऑनलाइन आज़माएं या पहले सत्यापित करें$n$आइटम ।

स्पष्टीकरण:

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)