संख्या-वर्ग में संख्या

Question

प्राकृतिक संख्याओं के अनुक्रम पर विचार करें जिसके लिए N, N ^ 2 में एक विकल्प के रूप में दिखाई देता है। A018834

nइस क्रम के वें तत्व को आउटपुट करें ।

नियम

कार्यक्रम केवल nइनपुट के रूप में लेता है और केवल एक नंबर आउटपुट करता है - N।

अनुक्रम 0-अनुक्रमित या 1-अनुक्रमित हो सकता है।

Sequence: 1 5 6 10 25 50 60 76 100 250 376 500 600 625 760 ...
Squares:  1 25 36 100 625 2500 3600 5776 10000 62500 141376 250000 360000 390625 577600 ...

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

Comments

बहुत सारे कार्यान्वयन समस्याओं में चलेंगे (मेरे लिए यह 2 से अधिक ^ 32 मानों के साथ सरणियों का निर्माण करने में सक्षम नहीं होने के कारण), जो कि अधिकांश समाधानों को डिफ़ॉल्ट रूप से अधिकतम आकार तक सीमित कर देगा। क्या इन समाधानों को अयोग्य घोषित किया जाना चाहिए?

— अधिकतम

@ मैक्सब मुझे लगता है कि सैद्धांतिक रूप से इसका मतलब था कि व्यावहारिक रूप से जरूरी नहीं है ।

— अरनुलड

@ मुझे पता है कि यह वास्तव में कम है, इसलिए मुझे अपना समाधान पसंद नहीं है। मैं एक बाइट जोड़ सकता हूं और यह बहुत बड़े इनपुट के लिए काम कर सकता है, इसलिए मैं इसे एक विकल्प के रूप में

— जोड़ूंगा

"N, N ^ 2 में दिखाई देता है" बेहतर होगा क्योंकि "N का दशमलव अंक एक [सन्निहित] है जो N वर्ग के दशमलव अंकों का विकल्प है" (11 "121 में दिखाई नहीं देता")। [कड़ाई से "सन्निहित" निरर्थक है, लेकिन इसे जोड़ना स्पष्ट है।]

— जोनाथन एलन

@JonathanAllan अल्टरनेटिव ने रिवाइडिंग का सुझाव दिया: "N is lexicographically present in N ^ 2"

— Οurous

Answer 1

05AB1E , 6 बाइट्स

1 अनुक्रमित

µNNnNå

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

व्याख्या

µ         # loop over increasing N until counter equals input
 N        # push N (for the output)
  Nn      # push N^2
    N     # push N
     å    # push N in N^2
          # if true, increase counter

Comments

यह µआज्ञा सिर्फ है ... काश मैं ऐसा होता।

— अधिकतम

@ मैक्सब: यह उन चुनौतियों के लिए काफी व्यावहारिक है जहां आपको Nthएक विशिष्ट स्थिति को पूरा करने वाली संख्या को खोजने की आवश्यकता होती है ।

— एमिगा

" अगर सच है , काउंटर बढ़ाएँ"?

— जोनाथन एलन

@JonathanAllan: जैसा कि, "यदि N, N ^ 2 में सम्‍मिलित है, तो काउंटर का मान 1 से बढ़ाएं"। मुझे शायद "वेतन वृद्धि काउंटर" लिखना चाहिए था।

— एमिग्ना

मैं वास्तव में स्पष्टीकरण को समझ नहीं पाया; ऐसा प्रतीत होता है कि यदि åपैदावार सही है तो हमारे पास Nस्टैक (इंक्रीमेंट काउंटर और इंक्रीमेंट N) के शीर्ष पर करंट है , लेकिन यदि हम जारी नहीं रखते हैं (इंक्रीमेंट N)। हो सकता है Nकि " " के अलावा कुछ का उपयोग करें क्योंकि यह प्रश्न शरीर में अंतिम परिणाम है: पी

— जोनाथन एलन

Answer 2

पर्ल 6 , 33 31 बाइट्स

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

{(grep {$^a²~~/$a/},1..*)[$_]}

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

स्पष्टीकरण:

{                            }  # Anonymous code block that returns
 (                      )[$_]   # The nth index of
  grep {          },1..*        # Filtering from the natural numbers
        $^a²                    # If the square of the number
            ~~/$a/              # Contains the number

Answer 3

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

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

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

---

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

n=>eval("for(k=0;n-=!!(++k*k+'').match(k););k")

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

Comments

यह n=23केवल देता है ?

— वेदांत कंडोई

$a(n)$$a(n)$$7600$$n=23$

Answer 4

मैथॉल्फ , 8 बाइट्स (सिद्धांत में किसी भी इनपुट के लिए काम करता है, लेकिन केवल n<10अभ्यास के लिए)

úrgɲï╧§

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

वैकल्पिक ( n<49अभ्यास और सिद्धांत में काम करता है)

►rgɲï╧§

फर्क सिर्फ इतना है कि 10^(input)मैं मूल्यों के साथ एक सूची बनाने के बजाय , 10^6आइटमों के साथ एक सूची बनाता हूं । इसे चलाने में थोड़ा समय लगता है, इसलिए आप इसे परीक्षण करने के लिए किसी अन्य 1-बाइट शाब्दिक को पहली बाइट स्वैप कर सकते हैं।

व्याख्या

ú          pop(a), push(10**a)
 r         range(0, n)
  g        filter array by...
   É       start block of length 3
    ²      pop a : push(a*a)
     ï     index of current loop
      ╧    pop a, b, a.contains(b)
           Block ends here
       §   get from array

इस कारण से यह समाधान बड़े इनपुट को संभाल नहीं पाता है कि मैंने देखा है कि अनुक्रम तेजी से कम बढ़ता है, लेकिन किसी भी बहुपद से अधिक है। इसलिए मैंने 10**nऑपरेटर का उपयोग किया (मैं उपयोग करना चाहता था 2**nलेकिन यह इनपुट 1 के लिए विफल रहा)। इसका मतलब है कि मैं छोटे इनपुट के लिए भी एक बहुत बड़ी सरणी बनाता हूं, बस इसके अधिकांश हिस्से को छानने के लिए, और फिर पहले तत्वों में से एक ले लो। यह बहुत ही बेकार है, लेकिन मैं बाइट की गिनती को बढ़ाए बिना इसे करने का दूसरा तरीका नहीं खोज सका।

Answer 5

आम लिस्प, 95 बाइट्स

(lambda(n)(do((i 0))((= n 0)i)(if(search(format()"~d"(incf i))(format()"~d"(* i i)))(decf n))))

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

Answer 6

क्लीन , 83 बाइट्स

import StdEnv,Text

(!!)[i\\i<-[1..]|indexOf(""<+i)(""<+i^2)>=0]

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

(!!)                               // index into the list of
 [ i                               // i for every
  \\ i <- [1..]                    // i from 1 upwards
  | indexOf (""<+i) (""<+i^2) >= 0 // where i is in the square of i
 ]

Answer 7

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

1ẇ²$#Ṫ

1 अनुक्रमित।

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

कैसे?

nअनुक्रम के पहले को सूची के रूप में ढूँढता है और फिर पूंछ को आगे बढ़ाता है N।

1ẇ²$#Ṫ - Link: integer, n (>0)
1      - initialise x to 1
    #  - collect the first n matches, incrementing x, where:
   $   -   last two links as a monad:
  ²    -     square x
 ẇ     -     is (x) a substring of (x²)?
       -     (implicitly gets digits for both left & right arguments when integers)
     Ṫ - tail

---

यदि 0एक प्राकृतिक संख्या मानी जाती है तो हम ẇ²$#Ṫ5 के लिए 1-अनुक्रमित पूर्ण-कार्यक्रम का उपयोग कर सकते हैं ।

Answer 8

जाप, 12 11 बाइट्स

@aJ±X²søY}f

कोशिश करो

ȲsøY «U´}a

कोशिश करो

Answer 9

रूबी , 45 बाइट्स

->n,i=1{/#{i+=1}/=~"#{i*i}"&&n-=1while n>0;i}

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

Answer 10

जावा 8, 66 65 63 बाइट्स

n->{int r=0;for(;!(++r*r+"").contains(r+"")||--n>0;);return r;}

-1 बाइट @ शुगी को धन्यवाद ।
-2 बाइट्स @Arnauld को धन्यवाद ।

1 अनुक्रमित।

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

स्पष्टीकरण:

n->{                // Method with integer as both parameter and return-type
  int r=0;          //  Result-integer, starting at 0
  for(;             //  Loop as long as:
       !(++r*r+"")  //    (increase result `r` by 1 first with `++r`)
                    //    If the square of the result `r` (as String) 
        .contains(  //    does not contain
          r+"")||   //    the result `r` itself (as String):
       --n>0;);     //     (decrease input `n` by 1 first with `--n`)
                    //     And continue looping if input `n` is not 0 yet
  return r;}        //  Return the result `r`

Comments

65 बाइट्स

— झबरा

@ शैगी आह, बिल्कुल। धन्यवाद!

— केविन क्रूज़सेन

@ अर्नुलद आह, लूप के संयोजन का स्मार्ट तरीका और अगर! धन्यवाद।

— केविन क्रूज़सेन

Answer 11

क्लोजर , 81 बाइट्स

(fn[n](nth(filter #(clojure.string/includes?(str(* % %))(str %))(range))n))

इसे ऑनलाइन आज़माएं! (दुर्भाग्य से, टीआईओ क्लूजुर के मानक स्ट्रिंग लाइब्रेरी का समर्थन नहीं करता है)

अगर क्लोजर में सिंटैक्स आयात करना कम था, या includes?कोर लाइब्रेरी में एक विधि थी , तो यह वास्तव में कुछ प्रतिस्पर्धी हो सकता है। clojure.string/includes?अकेला यहाँ कुछ उत्तरों से अधिक लंबा है, हालांकि: /

(defn nth-sq-subs [n]
  (-> ; Filter from an infinite range of numbers the ones where the square of
      ;  the number contains the number itself
    (filter #(clojure.string/includes? (str (* % %)) (str %))
            (range))

    ; Then grab the "nth" result. Inc(rementing) n so 0 is skipped, since apparently
    ;  that isn't in the sequence
    (nth (inc n))))

चूंकि TIO लिंक टूट गया है, इसलिए यहां एक परीक्षण चलाया गया है। बाईं ओर संख्या सूचकांक ( n) है, और परिणाम ( N) दाईं ओर है:

(mapv #(vector % (nth-sq-subs %)) (range 100))
=>
[[0 1]
 [1 5]
 [2 6]
 [3 10]
 [4 25]
 [5 50]
 [6 60]
 [7 76]
 [8 100]
 [9 250]
 [10 376]
 [11 500]
 [12 600]
 [13 625]
 [14 760]
 [15 1000]
 [16 2500]
 [17 3760]
 [18 3792]
 [19 5000]
 [20 6000]
 [21 6250]
 [22 7600]
 [23 9376]
 [24 10000]
 [25 14651]
 [26 25000]
 [27 37600]
 [28 50000]
 [29 60000]
 [30 62500]
 [31 76000]
 [32 90625]
 [33 93760]
 [34 100000]
 [35 109376]
 [36 250000]
 [37 376000]
 [38 495475]
 [39 500000]
 [40 505025]
 [41 600000]
 [42 625000]
 [43 760000]
 [44 890625]
 [45 906250]
 [46 937600]
 [47 971582]
 [48 1000000]
 [49 1093760]
 [50 1713526]
 [51 2500000]
 [52 2890625]
 [53 3760000]
 [54 4115964]
 [55 5000000]
 [56 5050250]
 [57 5133355]
 [58 6000000]
 [59 6250000]
 [60 6933808]
 [61 7109376]
 [62 7600000]
 [63 8906250]
 [64 9062500]
 [65 9376000]
 [66 10000000]
 [67 10050125]
 [68 10937600]
 [69 12890625]
 [70 25000000]
 [71 28906250]
 [72 37600000]
 [73 48588526]
 [74 50000000]
 [75 50050025]
 [76 60000000]
 [77 62500000]
 [78 66952741]
 [79 71093760]
 [80 76000000]
 [81 87109376]
 [82 88027284]
 [83 88819024]
 [84 89062500]
 [85 90625000]
 [86 93760000]
 [87 100000000]
 [88 105124922]
 [89 109376000]
 [90 128906250]
 [91 146509717]
 [92 177656344]
 [93 200500625]
 [94 212890625]
 [95 250000000]
 [96 250050005]
 [97 289062500]
 [98 370156212]
 [99 376000000]]

यह किसी भी मूल्य का समर्थन करने में सक्षम होना चाहिए n; आप इसे समाप्त करने के लिए प्रतीक्षा करने के लिए तैयार हैं (क्रम में 50 वें से 100 वें पूर्णांकों को खोजने में 15 मिनट लगते हैं)। क्लोजर मनमाने ढंग से बड़े पूर्णांक अंकगणित का समर्थन करता है, इसलिए एक बार जब संख्याएं विशाल होने लगती हैं, तो यह BigIntएस का उपयोग करना शुरू कर देता है ।

Answer 12

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

Ｎθ≔¹ηＷθ«≦⊕η¿№Ｉ×ηηＩη≦⊖θ»Ｉη

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

Ｎθ

इनपुट n।

≔¹η

N1. पर शुरू करें (या, यह गिनती शुरू कर सकता है 0जिस पर इनपुट 1-अनुक्रमित होगा।)

Ｗθ«

तब तक दोहराएं जब तक कि हमें nअनुक्रम में संख्याएं न मिलें ।

≦⊕η

वृद्धि N।

¿№Ｉ×ηηＩη

यदि N*Nशामिल है N, तो ...

≦⊖θ»

... क्षय n।

Ｉη

प्रिंट करें N।

चारकोल द्वारा इसे आगे बढ़ाने के मेरे प्रयासों को एक चरण if..thenके अंत में छोड़कर (जिसमें 2 बाइट्स खर्च होते हैं) ख) एक Containsऑपरेटर नहीं होने ( एक Findया Countबूलियन में आउटपुट को परिवर्तित करना ) नहीं था, जिसे मैं nफिर से लागतों में घटा सकता था। 2 बाइट्स)।

Answer 13

संपादित करें (टिप्पणियों पर प्रतिक्रिया): पायथन 2, 76 बाइट्स

एक गैर पुनरावर्ती विधि के लिए प्रयास करना चाहता था। (गोल्फ के लिए नया, कोई भी सुझाव बहुत अच्छा होगा!)

def f(c,n=0):
    while 1:
        if`n`in`n*n`:
            if c<2:return n
            c-=1
        n+=1

बीएमओ और वेदांत कंडोई दोनों को धन्यवाद!

Comments

आपको print(f(13))कोड में गणना करने की आवश्यकता नहीं है । इसके अलावा while 1:, if c==1:return n,c==1 can be c<2

— वेदांत Kandoi

आह, मैंने नहीं देखा कि आप एक गैर-पुनरावर्ती संस्करण चाहते थे, nvm .. वैसे भी, मैं वर्तमान में 76 बाइट्स 79 नहीं

— गिनता हूं

और आप कुछ और बचा सकते हैं: पहले और बाद के रिक्त स्थान `निरर्थक हैं और एक के बाद c<2:भी, अगले आप इंडेंटेशन के लिए टैब और रिक्त स्थान मिश्रण कर सकते हैं (जैसा कि यहां दिखाया गया है ): 69 बाइट्स Btw। अपने पुराने संस्करण को रखने की आवश्यकता नहीं है (यह उन लोगों के लिए संपादन इतिहास में है) और जो TIO (या समान) से लिंक नहीं हैं या वहां से टेम्पलेट का उपयोग क्यों नहीं करते हैं?

— ბიმო

Answer 14

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

([n^2|n<-[1..],elem(show n)$words=<<mapM(:" ")(show$n^2)]!!)

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

      n<-[1..]              -- loop n through all numbers starting with 1
 [n^2|        ,    ]        -- collect the n^2 in a list where
     elem(show n)           -- the string representation of 'n' is in the list
       words ... (show$n^2) -- which is constructed as follows:

            show$n^2        -- turn n^2 into a string, i.e. a list of characters
          (:" ")            -- a point free functions that appends a space
                            -- to a character, e.g.  (:" ") '1' -> "1 "
        mapM                -- replace each char 'c' in the string (n^2) with
                            -- each char from (:" ") c and make a list of all
                            -- combinations thereof.
                            -- e.g. mapM (:" ") "123" -> ["123","12 ","1 3","1  "," 23"," 2 ","  3","   "]
      words=<<              -- split each element into words and flatten to a single list
                            -- example above -> ["123","12","1","3","1","23","2","3"]

(                      !!)  -- pick the element at the given index

Answer 15

पायथन 2 , 47 43 बाइट्स

^{डेनिस के लिए -4 बाइट्स धन्यवाद (वापसी के बजाय पुनरावर्ती कॉल में 1 जोड़ना n-1)}

f=lambda c,n=1:c and-~f(c-(`n`in`n*n`),n+1)

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

Explantion / Ungolfed

$c,n$$n$$1,2,3\dots$$n \texttt{ in } n^2$$c$$c = 0$

# Enumerating elements of A018834 in reverse starting with 1
def f(counter, number=1):
    # Stop counting
    if counter == 0:
        return 0
    # Number is in A018834 -> count 1, decrement counter & continue
    elif `number` in `number ** 2`:
        return f(counter-1, number+1) + 1
    # Number is not in A018834 -> count 1, continue
    else:
        return f(counter, number+1) + 1

Answer 16

APL (Dyalog Extended) , 31 30 बाइट्स

1∘{>⍵:⍺-1⋄(⍺+1)∇⍵-∨/(⍕⍺)⍷⍕⍺×⍺}

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

0 अनुक्रमित।

Comments

(⍕⍺)⍷⍕→⍺⍷⍥⍕

— आदम

मुझे पता था कि मेरे साथ ऐसा कुछ हो सकता है ...

— Zacharý

Answer 17

पर्ल 5 -p , 33 बाइट्स

map{1while++$\**2!~/${\}/}1..$_}{

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

Answer 18

लुआ , 137 123 79 बाइट्स

-थैंक @ जू किंग 44 बाइट्स के लिए

n=io.read()i=0j=0while(i-n<0)do j=j+1i=i+(n.find(j*j,j)and 1or 0)end
print(j*j)

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

Comments

79 बाइट्स । कुछ सामान्य सुझाव; false/trueहो सकता है 0>1/ 0<1, कोष्ठक ifs और whiles के लिए आवश्यक नहीं हैं , आप संख्याओं के बाद भी व्हाट्सएप को हटा सकते हैं (यहां तक ​​कि नईलाइन भी)।

— जो राजा

Answer 19

Tcl , 82 बाइट्स

proc S n {while 1 {if {[regexp [incr i] [expr $i**2]]&&[incr j]==$n} {return $i}}}

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

Comments

मुझे लगता है कि आप समय और अगर को मिला सकते हैं:proc S n {while {[incr j [regexp [incr i] [expr $i**2]]]-$n} {};return $i}

— david

Answer 20

साफ , 24 बाइट्स

{x:str(x)in'~.x^2}from N

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

एक आलसी सूची देता है, जिसे फ़ंक्शन की तरह कहा जाता है, nश्रृंखला में वें तत्व को वापस लौटाता है ।

व्याख्या

{x:str(x)in'~.x^2}from N
{x:              }from N       select all natural numbers `x` such that
   str(x)                      the string representation of `x`
         in                    is contained in
           '~.x^2              "~" + str(x^2)