परिभाषा

यदि आप सकारात्मक पूर्णांक वर्गों का अनुक्रम लेते हैं, और उन्हें अंकों (यानी 149162536496481100...) की एक स्ट्रिंग में समेटते हैं , तो एक "प्रारंभिक पक्षी" वर्ग वह है जो इस स्ट्रिंग में अपनी प्राकृतिक स्थिति से आगे पाया जा सकता है।

उदाहरण के लिए, 7 ² (संख्या 49), स्ट्रिंग में 2 की ऑफसेट पर पाया जा सकता है, हालांकि प्राकृतिक स्थिति ऑफसेट 10 पर है। इस प्रकार 7 पहला "प्रारंभिक पक्षी" वर्ग है।

ध्यान दें कि इसे "प्रारंभिक पक्षी" वर्ग माना जाता है, प्राकृतिक स्थिति की शुरुआत से पहले वर्ग के सभी अंक होने चाहिए। एक मैच जो प्राकृतिक स्थिति को आंशिक रूप से ओवरलैप करता है, वह गिनती नहीं करता है।

a(n)nth धनात्मक पूर्णांक k है जैसे कि k ² एक "प्रारंभिक पक्षी" वर्ग है।

कार्य

एक सकारात्मक पूर्णांक n, आउटपुट दिया a(n)।

आप 1-आधारित या 0-आधारित अनुक्रमण का उपयोग कर सकते हैं, लेकिन यदि आप 0-आधारित अनुक्रमण का उपयोग करते हैं, तो कृपया अपने उत्तर में ऐसा कहें।

आप समाधान को कम से कम जितना संभव हो सके संभालना चाहिए a(53)(या यदि आप 0-आधारित अनुक्रमणिका का उपयोग कर रहे हैं, तो a(52))।

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

n     a(n)
1     7
2     8
3     21
4     25
5     46
6     97
7     129
8     161
9     196
10    221
...
13    277
...
50    30015
51    35000
52    39250
53    46111

संदर्भ

OEIS A181585

code-golf number sequence

— जेम्स होल्डरनेस
स्रोत

क्या आधार 0 या 1 का उपयोग कर परीक्षण मामलों की तालिका है?

— मूर्तिमान

1

क्या nअनुक्रम के पहले तत्वों को आउटपुट देना स्वीकार किया जा सकता है? यह ओपी पर निर्भर है लेकिन बहुत से लोग इसे अनुमति देने के लिए चुनते हैं।

— हाइपरन्यूट्रिनो 13

@idrougge परीक्षण मामले 1-आधारित हैं।

— जेम्स होल्डरनेस

@HyperNeutrino मैं सभी उत्तरों के लिए परिणामों का एक सुसंगत सेट रखना पसंद करूंगा, इसलिए कृपया केवल एकल मान लौटाएं a(n)।

— जेम्स होल्डरनेस

79 तक परीक्षण के मामले ।

— user202729

5

05AB1E , 10 9 बाइट्स

अदनान को 1 बाइट दिया ।

µNL<nJNnå

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

व्याख्या

µ           # loop until counter equals the input
 NL         # push the range [1 ... iteration_no]
   <        # decrement each
    n       # square each
     J      # join to string
      Nnå   # is iteration_no in the string?
            # if true, increase counter

— Emigna
स्रोत

आप छोड़ सकते हैं ½जब याद आ रही है कि के रूप में स्वचालित रूप से पाश में जोड़ दिया जाएगा।

— अदनान

@ अदनान: सच। इस चुनौती को नोट करने से ठीक पहले मैंने एक ट्रेन पर छलांग लगाई थी (या अगर इसमें देरी नहीं हुई थी), तो मैं पूरी तरह से चूक गया। धन्यवाद :)

— Emigna

7

जावास्क्रिप्ट (ईएस 6), 51 49 45 बाइट्स

1 अनुक्रमित।

f=(n,s=k='')=>n?f(n-!!s.match(++k*k),s+k*k):k

डेमो

कोड स्निपेट दिखाएं

f=(n,s=k='')=>n?f(n-!!s.match(++k*k),s+k*k):k

for(n = 1; n <= 20; n++) {
  console.log('a(' + n + ') = ' + f(n))
}

Expand snippet

प्रारूपित और टिप्पणी की गई

f = (                         // f = recursive function taking:
  n,                          //   n = input
  s = k = ''                  //   s = string of concatenated squares, k = counter
) =>                          //
  n ?                         // if we haven't reached the n-th term yet:
    f(                        //   do a recursive call with:
      n - !!s.match(++k * k), //     n decremented if k² is an early bird square
      s + k * k               //     s updated
    )                         //   end of recursive call
  :                           // else:
    k                         //   return k

गैर-पुनरावर्ती संस्करण, 53 बाइट्स

यह आपके इंजन स्टैक आकार पर निर्भर नहीं करता है।

n=>{for(k=s='';n-=!!(s+=k*k).match(++k*k););return k}

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

— Arnauld
स्रोत

6

पायथ , 12 बाइट्स

e.f/jk^R2Z`*

यहाँ यह कोशिश करो!

यह काम किस प्रकार करता है

ef / jk ^ R2Z` * ~ पूर्ण कार्यक्रम। चलिए क्यू हमारा इनपुट है।

 सत्य परिणामों के साथ .f ~ पहला क्यू पॉजिटिव पूर्णांक। चर Z का उपयोग करता है।
      ^ R2Z ~ श्रेणी में प्रत्येक पूर्णांक को वर्ग [0, Z)।
    jk ~ एकल स्ट्रिंग में सम्‍मिलित करें।
   / ~ की घटनाओं की गणना करें ...
          `* ~ Z वर्ग का स्ट्रिंग प्रतिनिधित्व।
               उपज ० यदि मिथ्या हो और 0 १ यदि सत्य हो।
e ~ अंतिम तत्व (Qth सच्चाई पूर्णांक) प्राप्त करें। आउटपुट निहित है।

— मिस्टर एक्सकोडर
स्रोत

4

पर्ल 5 , 34 बाइट्स

के लिए 33 बाइट्स कोड + 1 -p।

$s.=$\*$\while$_-=$s=~(++$\*$\)}{

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

— डोम हेस्टिंग्स
स्रोत

4

एपीएल (डायलॉग) , 53 42 बाइट्स

{{0<+/(⍕×⍨⍵+1)⍷' '~⍨⍕×⍨⍳⍵:⍵+1⋄∇⍵+1}⍣⍵⊢0}

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

कैसे?

⍷ - की घटनाओं का पता लगाएं

⍕×⍨⍵+1- कठोर वर्ग x+1in

⍕×⍨⍳⍵ - वर्गों की कठोर सीमा x

' '~⍨ - जगह के बिना

+/ - राशि

0<- यदि राशि सकारात्मक है (घटना मौजूद है), तो यह वापस आ जाता है x+1, अन्यथा,

∇⍵+1- के साथ पुनरावृत्ति x+1।

⍣⍵- nसमय लागू करें ।

— Uriel
स्रोत

3

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

import Data.List
([n|n<-[7..],isInfixOf(g n)$g=<<[1..n-1]]!!)
g=show.(^2)

इसे ऑनलाइन आज़माएं!शून्य अनुक्रमित।

व्याख्या

सहायक:

import Data.List -- import needed for isInfixOf
g=show.(^2)      -- function short cut to square an int and get the string representation

मुख्य कार्य:

(                                 !!) -- Index into the infinite sequence
 [n|n<-[7..],                    ]    -- of all numbers n greater equal 7
      isInfixOf(g n)$                 -- whose square appears in the string
                     g=<<[1..n-1]     -- of all squares from 1 up to n-1 concatenated.

— Laikoni
स्रोत

2

जेली , 13 11 बाइट्स

R²DµṪẇF
Ç#Ṫ

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

वैकल्पिक रूप से यह एक 10 बाइट्स समाधान है जो nअनुक्रम के पहले मूल्यों को प्रिंट करता है: इसे ऑनलाइन आज़माएं!

— user202729
स्रोत

lol तुम मुझे इस के लिए हरा; मैं आपके समाधान (गोल्फ के बाद) के समान ही था: P

— HyperNeutrino

@HyperNeutrino, दुर्भाग्य से गलत लगता है।

— user202729

क्या सचमे? यह दुर्भाग्यपूर्ण है :( ओह सही बात को संपादित करेंnfind : ((

— हाइपरनेट्रो

@ HyperNeutrino कोई समस्या नहीं है, स्टड कार्यों से पढ़ना।

— user202729

2

पायथन 2 , 62 61 बाइट्स

n=input();i=0;s=''
while n:i+=1;n-=`i*i`in s;s+=`i*i`
print i

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

— OVS
स्रोत

2

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

Ḷ²DFɓ²ẇ
Ç#Ṫ

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

User202729 के समाधान के लिए एक विकल्प ।

यह काम किस प्रकार करता है

C#Ṫ ~ Main Link.

Ç#  ~ First N positive integers with truthy results.
  Ṫ ~ Tail. Take the last one.

-----------------------------------------------------------

Ḷ²DFɓ²ẇ ~ Helper link. This is the filtering condition.

Ḷ       ~ Lowered range. Yields {x | x ∊ Z and x ∊ [0, N)}.
 ²      ~ Square each.
  D     ~ Convert each to decimal (this gets the list of digits).
   F    ~ Flatten.
    ɓ   ~ Starts a new monadic chain with swapped arguments.
     ²  ~ N²; Yields N squared.
      ẇ ~ Is ^ sublist of ^^^?

— मिस्टर एक्सकोडर
स्रोत

वाह, ẇस्वचालित संशोधन है।

— user202729

2

ऐलिस , 32 बाइट्स

/
\io/&wd.*\@! d ? ~ ? F $ /WKdt

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

ऑर्डिनल मोड के उस खंड का बेकार लेआउट वास्तव में मुझे परेशान कर रहा है, लेकिन मैं जो कुछ बाइट्स बचाने की कोशिश करता हूं, वह लंबे समय तक बाहर आता है ...

व्याख्या

/
\io/...@...

बस सामान्य दशमलव आई / ओ ढांचा, साथ oऔर @थोड़ा असामान्य स्थितियों में। कार्यक्रम का मांस यह है:

&w    Push the current IP address to the return address stack n times.
      This gives us an easy way to write a loop which repeats until we
      explicitly decrement the loop counter n times.

  d     Push the stack depth, which acts as our running iterator through
        the natural numbers.
  .*    Square it.
  \     Switch to Ordinal mode.
  !     Store the square (as a string) on the tape.
  d     Push the concatenation of the entire stack (i.e. of all squares before
        the current one).
  ?~    Retrieve a copy of the current square and put it underneath.
  ?     Retrieve another copy.
  F     Find. If the current square is a substring of the previous squares,
        this results in the current square. Otherwise, this gives an empty
        string.
  $     If the previous string was empty (not an early bird) skip the next
        command.
  /     Switch back to Cardinal. This is NOT a command.
  W     Discard one address from the return address stack, decrementing our
        main loop counter if we've encountered an early bird.
K     Jump back to the beginning of the loop if any copies of the return
      address are left. Otherwise do nothing and exit the loop.

dt    Push the stack depth and decrement it, to get the final result.

— मार्टिन एंडर
स्रोत

मैं इस भाषा को नहीं जानता, लेकिन क्या आप यह जाँचने से पहले किसी भी बाइट को बचा सकते हैं कि वर्तमान वर्ग स्ट्रिंग में है या नहीं?

— WGroleau 16

@Groleau मुझे ऐसा नहीं लगता। मुख्य चेक अभी भी एक बाइट (के Fबजाय z) है, लेकिन स्टैक हेरफेर कोई भी सरल नहीं होगा, संभवतः एक या दो कमांड भी बदतर हैं।

— मार्टिन एंडर

@JamesHolderness यह क्यों नहीं होना चाहिए? 69696 अपनी प्राकृतिक स्थिति (इसके साथ ओवरलैपिंग) से पहले दो स्थिति दिखाई देता है। यदि इसकी प्राकृतिक स्थिति के साथ ओवरलैप किया जाना चाहिए, तो आपको चुनौती में ऐसा कहना चाहिए।

— मार्टिन एंडर

@JamesHolderness संबंधित परीक्षण मामलों की जांच करने में बहुत लंबा समय लग रहा था, इसलिए मैंने सिर्फ 10 तक किया। मध्यवर्ती परीक्षण मामले में मदद करनी चाहिए।

— मार्टिन एंडर

यह निश्चित रूप से चुनौती बढ़ाता है। क्या आप पिछले उत्तरों पर टिप्पणी करेंगे जो उसी तरह विफल होते हैं? नोट: मुझे ये मनोरंजक लगते हैं, लेकिन कभी जवाब नहीं देते, क्योंकि मेरी सभी भाषाओं को आवश्यकता के रूप में पठनीयता के साथ डिजाइन किया गया था। :-) कोडांतरक और FORTH को छोड़कर। :-)

— WGroleau

1

भूसी , 13 बाइट्स

!f§€oṁ₁ŀ₁N
d□

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

व्याख्या

दूसरी पंक्ति एक सहायक कार्य है जो हमें किसी संख्या के वर्ग के दशमलव अंक देता है:

 □    Square.
d     Base-10 digits.

हम इस फंक्शन का उपयोग मुख्य कार्यक्रम पर कर सकते हैं ₁।

!f§€oṁ₁ŀ₁N
 f§      N    Filter the list of natural numbers by the following fork g(n).
       ŀ        Get [0, 1, ... n-1]
     ṁ₁         Get the decimal digits of each value's square and concatenate
                them into one list. (A)
        ₁       And get the decimal digits of n² itself. (B)
    €           Check whether (A) contains (B) as a sublist.
!             Use the programs input as an index into this filtered list.

— मार्टिन एंडर
स्रोत

1

कोटलिन , 79 बाइट्स

{n->var m=n;var i=0;var s="";while(m>0){val k="${++i*i}";if(k in s)m--;s+=k};i}

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

— OVS
स्रोत

1

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

(n=k=0;s="";While[n<#,If[!StringFreeQ[s,t=ToString[++k^2]],n++];s=s<>t];k)&

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

यह काम किस प्रकार करता है

nअब तक पाए गए शुरुआती पक्षियों की संख्या, kअंतिम संख्या की जाँच की, sस्ट्रिंग "1491625..."। जबकि nबहुत छोटा है, अगर sअगला वर्ग शामिल है , तो एक और प्रारंभिक पक्षी पाया गया है, इसलिए हम वृद्धि करते हैं n। किसी भी मामले में, हम विस्तार करते हैं s।

एक बार nइनपुट पर पहुंचने के बाद #, हम वापस लौटते हैं k, अंतिम संख्या की जाँच की जाती है और इसलिए अंतिम प्रारंभिक पक्षी पाया जाता है।

मेरे लैपटॉप पर, अनुक्रम के 53 वें कार्यकाल की गणना करने में लगभग 53 सेकंड लगते हैं।

— मिशा लावरोव
स्रोत

1

आरईएक्सएक्स , 66 बाइट्स

arg n,a
k=0
do i=1 until k=n
  k=k+(pos(i*i,a)>0)
  a=a||i*i
  end
say i

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

— idrougge
स्रोत

1

बैश, 76 69 बाइट्स

मान nचर (यानी n=10 foo.sh) में दिया जाता है । पैकेज का उपयोग करता है grep। कोई भी मध्य मान आउटपुट है (यदि अनुमत है, -3 बाइट्स)।

while((n));do((b=++a*a));grep -q $b<<<$s&&((n--));s=$s$b;done;echo $a

यह कैसे काम करता है?

while ((n)); do  # while n != 0 (C-style arithmetic)
  ((b = ++a*a))  # Increment a and let b = a*a
    # Non-existent value is treated as zero
  grep $b<<<$s   # Search for b in s
    && ((n--))   # If found, decrement n
  s=$s$b         # Append b to s
done
echo $a

— iBug
स्रोत

@ जेम्स यहाँ जाता है।

— 17