परिचय

नंबर लेते हैं 180। यह एक दिलचस्प संख्या है क्योंकि इस संख्या के अंकों का योग इसके बराबर है:

1 + 8 + 0 = 9

और इस संख्या का चुकता संस्करण, या:

180² = 32400 > 3 + 2 + 4 + 0 + 0 = 9

ये दोनों 9 हैं । मूल संख्या और वर्ग संख्या के अंकों का योग समान होता है। बेशक, यह OEIS: A058369 पर भी पाया जाता है ।

कार्य

एक गैर नकारात्मक पूर्णांक को देखते हुए n, उत्पादन nवें सकारात्मक इस शर्त के साथ संख्या।

परीक्षण के मामले ( शून्य-अनुक्रमित )

Input > Output

0 > 1
1 > 9
2 > 10
3 > 18
4 > 19
5 > 45
6 > 46
7 > 55
8 > 90
9 > 99
10 > 100
11 > 145
12 > 180
13 > 189
14 > 190
15 > 198
16 > 199
17 > 289
18 > 351
19 > 361

इनपुट 1-अनुक्रमित भी हो सकता है अगर वह आपको बेहतर तरीके से फिट बैठता है।

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

code-golf number sequence

— अदनान
स्रोत

यदि किसी ने इसे अभी तक नहीं देखा है, तो केवल वे संख्याएँ जो 0 या 1 (mod 9) के समतुल्य हैं, सूची में दिखाई दे सकती हैं।

— नील

@ ममफुनरॉल उम ... नहीं। माफ़ कीजिये। 5 की डिजिटल जड़ों वाली संख्याओं में वर्ग होते हैं जिनकी डिजिटल जड़ 7.

— नील

@ नील ओवैत एनवीएम

— मामा फन रोल

मैंने यह निर्धारित करने के लिए कि क्या इस इनपुट का एक शब्द है या नहीं, यह निर्धारित करने के लिए मैंने एक Brachylog लिख दिया था, लेकिन खोज-एनएच बॉयलरप्लेट काम नहीं कर सका, इसलिए मैं इसे एक टिप्पणी में छोड़ दूँगा:^₂;?{ẹ+}ᵛ

— असंबंधित स्ट्रिंग

5

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

,²DS€=/
1Ç³#Ṫ

इनपुट 1-अनुक्रमित है। इसे ऑनलाइन आज़माएं!

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

1Ç³#Ṫ    Main link. Argument: n (index)

1        Set the return value to 1.
   #     Execute ... until ... matches have been found.
 Ç         the helper link
  ³        n
    Ṫ    Extract the last match.


,²DS€=/  Helper link. Argument: k (integer)

,²       Pair k with k².
  D      Convert each to decimal.
   S€    Compute the sum of each list of base 10 digits.
     =/  Reduce by equality.

— डेनिस
स्रोत

4

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

s=sum.map(read.pure).show
([x|x<-[1..],s x==s(x^2)]!!)

प्रयोग उदाहरण: ([x|x<-[1..],s x==s(x^2)]!!) 17-> 289।

s calculates the digit sum:

                    show     -- turn number into a string
     map(read.pure)          -- turn every character (the digits) in to a
                             -- one element string and convert back to integer
sum                          -- sum those integers

main function:

[x|x<-[1..]            ]     -- make a list of all x starting from 1
           ,s x==s(x^2)      -- where s x == s (x^2)
                        !!   -- pick nth element from that list

— nimi
स्रोत

4

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

n=>eval("for(q=s=>eval([...s+''].join`+`),i=1;q(i)!=q(i*i)||n--;i++);i")

जब तक मुझे एहसास हुआ कि मैं गलत चर का उत्पादन कर रहा था, तब तक मैंने इसे पाने के लिए 30 मिनट का समय बिताया

यह शून्य-अनुक्रमित है।

— Downgoat
स्रोत

1

मुझे लगता है कि इसे एक पुनरावर्ती समारोह में बदलना बहुत छोटा कर देगा ...

— मामा फन रोल

4

पर्ल 6, 47 46 बाइट्स

{(grep {$_.comb.sum==$_².comb.sum},1..*)[$_]}

— हॉटकी
स्रोत

4

05AB1E , 10 9 8 बाइट्स

µNÐn‚1öË

1 अनुक्रमित।

-1 बाइट के लिए धन्यवाद @Emigna के अंत में निहितार्थ ½( counter_variableहर पुनरावृत्ति के बाद वृद्धि )
को हटाकर - 1 बाइट के लिए धन्यवाद @SO उपयोग करने से डुप्लिकेट को हटाने के लिए धन्यवाद‚1ö

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

स्पष्टीकरण:

µ         # Loop while the counter_variable is not equal to the (implicit) input yet:
 NÐ       #  Push the 0-based loop index three times
   n      #  Take the square of this index
          #   i.e. 180 → 32400
    ‚     #  Pair it with the index
          #   i.e. 180 and 32400 → [180,32400]
     1ö   #  Convert both numbers from base-1 to base-10, which basically sums the digits
          #   i.e. [180,32400] → [9,9]
       Ë  #  Check if both sums are equal
          #   i.e. [9,9] → 1 (truthy)
          #  (if they are: implicitly increase the counter_variable by 1)
          # (after the loop: implicitly print the top of the stack, which is the remaining
          #  copy of the index from the triplicate we've used)

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

2

यहाँ आपको इसकी आवश्यकता नहीं ½है क्योंकि यह अंतर्निहित है

— एमिगा

1

-1: µNDn‚1öË। 1öऐसा है, SOलेकिन वेक्टराइज़ करता है, जो हमें कोड दोहराव से बचने की सुविधा देता है।

— ग्रैमी

@Grimy फिर से धन्यवाद। मैंने यह भी जोड़ा है कि मेरी छोटी युक्तियाँ पोस्ट करने के लिए एक टिप के रूप में। :)

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

3

मैथेमेटिका, 64 बाइट्स

a=Tr@*IntegerDigits;Nest[NestWhile[#+1&,#+1,a@#!=a[#^2]&]&,1,#]&

साधारण अनाम फ़ंक्शन। शून्य अनुक्रमित।

— LegionMammal978
स्रोत

3

अजगर, १५

e.fqsjZTsj^Z2TQ

DenteAffe के लिए 1 बाइट धन्यवाद!

इसे यहां आज़माएं या टेस्ट सूट चलाएं ।

1-अनुक्रमित विकल्प का उपयोग करता है।

Naive कार्यान्वयन का उपयोग करके .fपहले nनंबर दिए गए हैं जो दी गई स्थिति से मेल खाते हैं।

— FryAmTheEggman
स्रोत

hयदि आप स्पष्ट रूप से अनुमति दी जाती है, तो आप 1-इंडेक्सिंग का उपयोग करके एक बाइट को बचा सकते हैं ।

— डेनकर

@DenkerAffe ओह, धन्यवाद मुझे और अधिक बारीकी से पढ़ना चाहिए: P

— FryAmTheEggman

2

MATL , 24 23 बाइट्स

x`@2:^"@V!Us]=?@]NG<]1$

1-आधारित इनपुट का उपयोग करता है।

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

x        % take inpout and delete it (gets copied into clipboard G)
`        %   do...while
  @      %   push loop iteration index: candidate number, n
  2:^    %   array [n n^2]
  "      %   for each element of that array 
    @    %     push that element 
    V!U  %     get its digits (to string, transpose, to number)
    Xs   %     compute their sum
  ]      %   end for each
  =      %   are the two sums equal?
  ?      %   if so
    @    %     the candidate number is valid: push it
  ]      %   end if
  NG<    %   is number of elements in stack less than input?
]        % if so, proceed with next iteration. End do...while. 
1$       % specify 1 input for implicit display: only top of stack

— लुइस मेंडो
स्रोत

1

बहुत अच्छा है कि MATL अंत में दूर संकलक के बीच सूचीबद्ध है!

— अब्रीराम

1

जूलिया, 79 66 बाइट्स

f(n,x=0,i=1,s=c->sum(digits(c)))=x<n?f(n,x+(s(i)==s(i^2)),i+1):i-1

यह एक पुनरावर्ती कार्य है जो पूर्णांक को स्वीकार करता है और पूर्णांक देता है। यह 1-आधारित अनुक्रमण का उपयोग करता है।

हम फ़ंक्शन तर्क के रूप में कुछ चीजें संग्रहीत करते हैं:

n : इनपुट
x : इस शर्त के साथ कि हमें कितनी संख्या मिली है, इसके लिए एक काउंटर
i : स्थिति की जांच के लिए एक नंबर
s : इसके इनपुट के अंकों की गणना करने के लिए एक फ़ंक्शन

जबकि xइनपुट से कम है, हम पुनरावृत्ति करते हैं, xअगर iहालत और वेतन वृद्धि को पूरा करते हैं i। एक बार x == n, हम वापस लौट आते हैं i, लेकिन हमें 1 को घटाना पड़ता है, क्योंकि यह एक बार कई बार बढ़ चुका होता है।

— एलेक्स ए।
स्रोत

1

उत्तल 0.2, 36 35 बाइट्स

उत्तल एक नई भाषा है जिसे मैं विकसित कर रहा हूं जो कि सीजेएम और गोल्फस्क्रिप्ट पर आधारित है। दुभाषिया और आईडीई यहां पाया जा सकता है । इनपुट कमांड लाइन के तर्कों में एक पूर्णांक है। सूचकांक एक-आधारित हैं। CP-1252 एन्कोडिंग का उपयोग करता है ।

1\{\__2#¶{s:~:+}%:={\(\)\}{)\}?}h;(

— GamrCorps
स्रोत

1

गणितज्ञ, 63 60 61 59 बाइट्स

Select[Range[9^#],Equal@@Tr/@IntegerDigits/@{#,#^2}&][[#]]&

इसे बनाते समय दूसरा जवाब पॉप अप हुआ, लेकिन मैं उन्हें एक ही बाइट से मार रहा हूं और इससे पहले कि मैं इसे पोस्ट कर रहा हूं, एक गोल्फ हो जाता है। एक अनुक्रमित।

— CalculatorFeline
स्रोत

इनपुट के लिए विफल >2457। बस आपकी Rangeमदद करने से वृद्धि नहीं होगी, क्योंकि A058369[n]/nयह अभिसरण नहीं लगता है।

— मर्फी

बेहतर? फिलर +

— कैलक्यूलेटरफेलीन

10^#से छोटा होगा 2^#*9। बेशक यह बहुत धीमी हो जाती है क्योंकि n लगभग 6 से बड़ा होता है ...

— feersum

क्यों नहीं 9^#? फिल्म

— कैल्क्युलेटरलाइन

क्या आपके पास प्रमाण है कि f (n) <= 9 ^ n है? (10 स्पष्ट है क्योंकि 10 ^ एन हमेशा एक समाधान है)।

— feersum

1

रेटिना, 103 बाइट्स

\d+
$*1 x
{`x+
$.0$*x¶$.0$*a¶$.0$*b
%`b
$_
a+|b+
$.0
\d
$*
+`1¶1
¶
1(.*)¶¶$|¶[^d]+
$1x
}`^ ?x

x

निश्चित रूप से गोल्फ।

स्क्वेरिंग के लिए नई रेटिना सुविधा का% उपयोग करता है (इसलिए अभी तक ऑनलाइन संस्करण के साथ काम नहीं कर रहा है)।

— randomra
स्रोत

1

MathCad, 70 50 बाइट्स

Mathcad ने किसी संख्या को उसके अंक स्ट्रिंग में बदलने के लिए नहीं बनाया है, इसलिए उपयोगकर्ता कार्य d (a) यह कार्य करता है। एक प्रोग्राम तब धनात्मक पूर्णांक के माध्यम से पुनरावृत्ति करता है, जब तक वह वेक्टर v में n संख्या संचित नहीं करता है तब तक sums की समानता के लिए परीक्षण किया जाता है। कार्यक्रम का मूल्यांकन = ऑपरेटर का उपयोग करके किया जाता है, जो परिणाम वेक्टर को प्रदर्शित करता है। ( ध्यान दें कि पूरा कार्यक्रम ठीक उसी तरह दिखाई देता है जैसा कि मैथेकड वर्कशीट पर नीचे प्रदर्शित होता है )

अद्यतित कार्यक्रम: ए के शून्य को डिफ़ॉल्ट आरंभीकरण मान लेता है और इस तथ्य का उपयोग करता है कि मैथकाद एक कार्यक्रम में अंतिम मूल्यांकन किए गए बयान का मूल्य लौटाता है।
पहली बार समन में परिवर्तन करने के लिए भावों के मूल्यांकन क्रम का उपयोग करता है (और फिर योग की राशि में उपयोग के लिए उपलब्ध है)

मूल कार्यक्रम: सभी संख्याओं के एक वेक्टर को n तक लौटाता है।

— स्टुअर्ट ब्रुफ़
स्रोत

0

जाप , 15 बाइट्स

1 अनुक्रमित

_ìx ¶Z²ìx «U´}a

कोशिश करो

— झबरा
स्रोत

0

जावा 8, 113 बाइट्स

n->{int r=0;for(;n>=0;)if((++r+"").chars().map(c->c-48).sum()==(r*r+"").chars().map(c->c-48).sum())n--;return r;}

0 अनुक्रमित

स्पष्टीकरण:

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

n->{           // Method with integer as both parameter and return-type
  int r=0;     //  Result-integer, starting at 0
  for(;n>=0;)  //  Loop as long as `n` is zero or positive
    if((++r    //   Increase `r` by 1 first
       +"").chars().map(c->c-48).sum()
               //   And if the sum of its digits
       ==(r*r+"").chars().map(c->c-48).sum())
               //   equals the sum of the digit of its square
      n--;     //    Decrease `n` by 1
  return r;}   //  Return the result

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

0

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

के लिए शामिल +1है-p

1 आधारित

#!/usr/bin/perl -p
$.++while$_-=!eval+("-($.) ".$.**2)=~s/\B/+/gr;$_=$.

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

— टन हास्पेल
स्रोत

0

टीआई-बेसिक 66 62 बाइट्स

Ans→N:While X<N:IS>(A,A::A:prgmA:Ans→B:A²:prgmA:If B=Ans:IS>(X,N:End:A
sum(int(10fPart(Ans₁₀^(seq(⁻X-1,X,0,log(Ans

$n$ Ans
$n$

हेल्पर फ़ंक्शन में मान के अंकों का योग उत्पन्न करता है Ans।

उदाहरण:

3:prgmCDGF1E
             10
5:prgmCDGF1E
             19
8:prgmCDGF1E
             55
10:prgmCDGF1E
             99

स्पष्टीकरण:

Ans→N:While X<N:IS>(A,A::A:prgmA:Ans→B:A²:prgmA:If B=Ans:IS>(X,N:End:A ;prgmCDGF1E

Ans→N            ;store the input in N
While X<N        ;loop until the Nth term has been reached
IS>(A,A:         ;add 1 to A
                 ; (Increment A and skip the next statement if A>A)
A                ;leave A in Ans
prgmA            ;call the helper program below
Ans→B            ;store the result of the helper program in B
A²               ;square A and leave the result in Ans
prgmA            ;call the helper program below
                 ; (result is in Ans)
If B=Ans         ;if the two results are equal
IS>(X,N          ;add 1 to X
                 ; (Increment X and skip the next statement if X>N)
End
A                ;leave A in Ans
                 ;implicit print of Ans

sum(int(10fPart(Ans₁₀^(seq(⁻X-1,X,0,log(Ans   ;prgmA

                      seq(⁻X-1,X,0,log(Ans    ;generate a list...
                                              ; using X as the variable,
                                              ; starting at 0,
                                              ; ending at the log of Ans,
                                              ; and evaluating "⁻X-1" for each element
                                              ; (implicit increment of 1)
                   ₁₀^(                       ;raise 10 to the power of each element
                Ans                           ;multiply each element by the input
          fPart(                              ;remove the integer part from each element
        10                                    ;multiply each element by 10
    int(                                      ;round each element to the nearest integer
sum(                                          ;then sum the resulting list

नोट: TI-BASIC एक टोकन भाषा है। कैरेक्टर काउंट बाइट काउंट नहीं के बराबर होता है ।

— ताउ
स्रोत

0

जे , 62 बाइट्स

[:{:({.@](>:@[,],[#~(=&(1#."."0@":)*:)@[)}.@])^:(#@]<1+[)^:_&1

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

1 अनुक्रमित। जे एक बार फिर इन "एनटीटी" कार्यों पर अच्छा प्रदर्शन नहीं कर रहा है, क्योंकि अत्यधिक बुक करने वाले यांत्रिकी के कारण।

— जोनाह
स्रोत

0

एपीएल (एनएआरएस), 49 चार्ट, 98 बाइट्स

r←h w;c
c←r←0
→2×⍳∼=/+/¨(⍎¨⍕)¨r,r×r+←1⋄→2×⍳w>c+←1

1-अनुक्रमित, परीक्षण:

  h¨⍳20
1 9 10 18 19 45 46 55 90 99 100 145 180 189 190 198 199 289 351 361

— RosLuP
स्रोत

0

मैथॉल्फ , 10 बाइट्स

♪╒gÆ‼Σ²Σ=§

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

व्याख्या

ú $10^n$

♪            push 1000
 ╒           range(1,n+1)
  gÆ         filter list using the next 5 operators
    ‼        apply next two commands to TOS
     Σ       sum(list), digit sum(int)
      ²      pop a : push(a*a) (square)
       Σ     sum(list), digit sum(int) (pushes the digit sum of the square)
        =    pop(a, b), push(a==b) (compares the two)
         §   get from array (returns the <input>th item from the filtered list

— maxb
स्रोत

हो सकता है कि मुझे सिर्फ मैथॉल्फ के लिए एक चैट तैयार करनी चाहिए .. वैसे भी, मेरे पास एक सवाल है: क्या प्रतिस्थापन के लिए कोई निर्माण, विभाजन और इस तरह के तार हैं? मुझे लगता है कि संपीड़न यहाँ बाइट्स को बचा सकता है, लेकिन यह सुनिश्चित करने के लिए कि बिल्डिंस इसे पूरा करने के लिए मौजूद नहीं हैं।

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

एक बंद मठगॉल्फ चैट है। मैंने इसे जीवित रखने की कोशिश की, लेकिन हाल ही में मुझे काम से हाथ धोना पड़ा है, और यह बंद हो रहा है। मैं हर बार mods को परेशान नहीं करना चाहता। आपके प्रश्न का उत्तर देने के लिए, MathGolf वास्तव में स्ट्रिंग संचालन को संभालने के लिए नहीं था, लेकिन मैंने कुछ बुनियादी चुनौतियों को संभालने के लिए स्ट्रिंग हैंडलिंग के लिए कार्यक्षमता को लागू किया है। जैसा कि आपने देखा है, अभी भी बहुत कुछ करने की इच्छा है। अगर मैं कुछ भी जोड़ता हूं, तो यह संभवत: 05AB1E के समान होगा, लेकिन मैंने पिछले महीनों में MathGolf के विकास के लिए कोई अतिरिक्त समय नहीं दिया है।

— अधिकतम

अंकों के योग में समानता

परिचय

कार्य

परीक्षण के मामले ( शून्य-अनुक्रमित )

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

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

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

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

पर्ल 6, 47 46 बाइट्स

05AB1E , 10 9 8 बाइट्स

मैथेमेटिका, 64 बाइट्स

अजगर, १५

MATL , 24 23 बाइट्स

जूलिया, 79 66 बाइट्स

उत्तल 0.2, 36 35 बाइट्स

गणितज्ञ, 63 60 61 59 बाइट्स

रेटिना, 103 बाइट्स

MathCad, 70 50 बाइट्स

जाप , 15 बाइट्स

जावा 8, 113 बाइट्स

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

टीआई-बेसिक 66 62 बाइट्स

जे , 62 बाइट्स

एपीएल (एनएआरएस), 49 चार्ट, 98 बाइट्स

मैथॉल्फ , 10 बाइट्स

व्याख्या

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