वैराग्य दुविधा

डिसेरियम को एक संख्या के रूप में परिभाषित किया गया है:

अपने संबंधित स्थिति के साथ संचालित इसके अंकों का योग मूल संख्या के बराबर है

आपका कार्य :

आपके पास एक अजीब तरह का जुनून है जिसे एक शुल्क के रूप में वर्गीकृत किया गया है। डिसेरियम के तरीकों का पालन करने की आवश्यकता आप में इतनी महान है कि आप किसी भी बुक में किसी भी गैर-डिसलाइक नंबरों को पढ़ने से इनकार कर देते हैं। आपको दो बड़ी समस्याएं हैं:

आपके प्रोफेसर ने आपको अपनी पाठ्यपुस्तक को पृष्ठ से पृष्ठ nपर पढ़ने के लिए सौंपा हैm
आपने पिछले हफ्ते अपने सिर को बहुत मुश्किल से मारा और यह याद रखना संभव नहीं है कि प्रोग्राम को यह निर्धारित करने के लिए कि क्या एक संख्या को डिसेरियम माना जाता है।

समय सार का है इसलिए कोड को उन पृष्ठों को निर्धारित करने के लिए जिन्हें आपको पढ़ने की आवश्यकता होगी जितना संभव हो उतना कम होना चाहिए।

आप की एक समावेशी सीमा के भीतर disarium के सभी की पहचान करने की जरूरत है nके माध्यम से m।

एक शुल्क के उदाहरण :

89 = 8 ¹ + 9 ²

135 = 1 ¹ + 3 ² + 5 ³

518 = 5 ¹ + 1 ² + 8 ³

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

यहाँ A032799 का पूर्ण अनुक्रम है ।

code-golf sequence

— CraigR8806
स्रोत

@Fatalize सीमा समावेशी है, मैं इसे प्रतिबिंबित करने के लिए प्रश्न को संपादित करूंगा।

— क्रेग आर 8806

क्या कोई गारंटीशुदा सीमाएँ हैं nऔर m? एक बहुत बड़ा शुल्क है (12157692622039623539), क्या इसका उत्तर देने में सक्षम होना चाहिए?

— लिन

@ लियन ने यह देखते हुए कि पहले से ही कई समाधान हैं, मैं कहूंगा कि सीमा पर कोई सीमा नहीं होनी चाहिए।

— क्रेगR8806

2

@Lynn। कोई डिसेर्वरी> 22 अंक नहीं है, इसलिए एक तरह से सीमा पहले से ही बंधी हुई है।

— मैड

3

@MistahFiggins कृपया सवाल के निचले भाग में OEIS लिंक पर जाएँ। आपको एक प्रमाण मिलेगा जो दिखाता है कि डिस्कवरी अनुक्रम वास्तव में परिमित है।

— क्रेगR8806

11

पर्ल 6 , 40 39 बाइट्स

{grep {$_==sum .comb Z**1..*},$^a..$^b}

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

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

{                                     }  # A lambda.
                              $^a..$^b   # Range between the two lambda arguments.
 grep {                     },           # Return numbers from that range which satisfy:
               .comb Z  1..*             #  Digits zipped with the sequence 1,2,3,...,
                      **                 #  with exponentiation operator applied to each pair,
           sum                           #  and those exponents summed,
       $_==                              #  equals the number.

— SMLS
स्रोत

8

पायथन 2, 98 89 88 84 बाइट्स

lambda n,m:[x for x in range(n,m+1)if sum(int(m)**-~p for p,m in enumerate(`x`))==x]

~~भयानक। छोटी हो जाएगी।~~ बेहतर देखने के लिए शुरू

यहाँ मेरा पुनरावर्ती प्रयास है (86 बाइट्स):

f=lambda n,m:[]if n>m else[n]*(sum(int(m)**-~p for p,m in enumerate(`n`))==n)+f(n+1,m)

4 बाइट बचाने के लिए @Rod को धन्यवाद ! rangeको enumerateऔर इतने पर।

— Yytsi
स्रोत

स्विच करने के लिए enumerate, आप int(n)इसके बजाय उपयोग कर सकते हैंint(`x`[p])

— रॉड

7

पर्ल, 43 बाइट्स

map{say if$_==eval s/./+$&**$+[0]/gr}<>..<>

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

रेगेक्स वास्तव में शक्तिशाली है, तुम लोग।

व्याख्या

पहली चीज़ जो कोड करती है <>, उसे इनपुट के रूप में दो पूर्णांकों को पढ़ा जाता है , और पहले से दूसरे तक एक सीमा बनाता है ..। यह तब mapइस श्रेणी के माध्यम से पुनरावृति करने के लिए मानक फ़ंक्शन का उपयोग करता है , और प्रत्येक मान के लिए निम्न कोड लागू करता है say if$_==eval s/./+$&**$+[0]/gr:। यह जिबरिश जैसा दिखता है, और यह इस तरह का है, लेकिन यहां वास्तव में क्या हो रहा है।

mapनिहित रूप से चर में इसके वर्तमान मूल्य को संग्रहीत करता है $_। कई पर्ल फ़ंक्शंस और ऑपरेशन इस वैल्यू का उपयोग करते हैं जब कोई नहीं दिया जाता है। इसमें नियमित अभिव्यक्तियाँ शामिल हैं, जैसे s///प्रतिस्थापन संचालक।

प्रतिस्थापन रेगेक्स के चार भाग हैं:

हेरफेर करने के लिए स्ट्रिंग। आमतौर पर, ऑपरेटर =~को एक स्ट्रिंग में रेगेक्स लागू करने के लिए उपयोग किया जाता है, लेकिन यदि यह ऑपरेटर अनुपस्थित है, तो रेगेक्स को निहित चर पर लागू किया जाता है $_, जिसमें mapफ़ंक्शन के माध्यम से हमारा वर्तमान नंबर होता है।
खोज करने के लिए स्ट्रिंग। इस स्थिति में, हम वाइल्डकार्ड द्वारा निरूपित किसी एकल गैर-नई वर्ण रेखा को खोज रहे हैं .। वास्तव में, हम प्रत्येक व्यक्तिगत अंक को कैप्चर कर रहे हैं।
साथ बदलने के लिए स्ट्रिंग। हम +एक गणितीय चिह्न के बाद एक प्लस चिन्ह का प्रतिस्थापन कर रहे हैं , जो कुछ जादुई पर्ल चर के साथ मिश्रित है जो सब कुछ काफी आसान बना देता है।

विशेष स्केलर वैरिएबल में $&हमेशा अंतिम सफल रेगेक्स कैप्चर की संपूर्णता होती है, जो इस मामले में एकल अंक है। विशेष सरणी चर में @+हमेशा अंतिम सफल मैच के लिए पोस्टमैच ऑफसेट की सूची होती है , अर्थात मैच के बाद पाठ का सूचकांक । पाठ का $+[0]सूचकांक $_तुरंत निम्नलिखित है $&। के मामले में 135, हम अंक को कैप्चर करते हैं 1, और 135पाठ के सूचकांक को तुरंत बाद में (अर्थात् 35) 1 है, जो हमारा प्रतिपादक है। इसलिए, हम $&(1) की शक्ति $+[0](1) को उठाना चाहते हैं और 1. प्राप्त करना चाहते हैं। हम 3 को 2 की शक्ति तक बढ़ाना चाहते हैं और 9. प्राप्त करना चाहते हैं। हम 5 को 3 की शक्ति तक बढ़ाना चाहते हैं और 125 प्राप्त करना चाहते हैं।

यदि इनपुट था 135, तो परिणामी स्ट्रिंग है +1**1+3**2+5**3।

रेगेक्स-संशोधित झंडे। यहां हम दो रेगेक्स झंडे का उपयोग कर रहे हैं - /gऔर /r। /gदुभाषिया को पहले मिलने के बाद प्रतिस्थापन जारी रखने के लिए कहता है (अन्यथा हम साथ समाप्त हो जाएंगे +1**135)। /rदुभाषिया को मूल स्ट्रिंग को संशोधित नहीं करने के लिए कहता है , और बदले में स्ट्रिंग को प्रतिस्थापन के बाद क्या होगा। यह महत्वपूर्ण है, क्योंकि अन्यथा, यह अधिलेखित हो जाएगा $_, और हमें इसकी तुलना उद्देश्यों के लिए करने की आवश्यकता है।

एक बार संपूर्ण प्रतिस्थापन हो जाने के बाद, हमें एक गणितीय अभिव्यक्ति मिलती है, जिसका मूल्यांकन evalफ़ंक्शन के साथ किया जाता है। +1**1+3**2+5**3में मूल्यांकन किया जाता है 1 + 9 + 125 = 135, जिसकी तुलना मूल संख्या से की जाती है 135। चूंकि ये दोनों समान हैं, कोड संख्या को प्रिंट करता है।

— गेब्रियल बेनामी
स्रोत

सुंदर समाधान। (ध्यान दें कि यह काम नहीं करेगा पहला इनपुट 0 है, लेकिन मुझे यकीन नहीं है कि यह मायने रखता है)। गोल्फ के लिए कुछ बाइट्स:map$_-eval s/./+$&**$+[0]/gr||say,<>..<>

— दादा

और "@+"1 बाइट से छोटा है $+[0]:)

— दादा

7

जावास्क्रिप्ट (ईएस 7), 105 91 89 88 83 79 82 81 बाइट्स

20B को बचाने के लिए Arnauld और 6B को बचाने के लिए ETHProductions का धन्यवाद!

a=>b=>[...Array(b).keys()].filter(c=>c>=a&([...c+''].map(d=>c-=d**++e,e=0),!c))

प्रयोग

फ़ंक्शन को एक चर पर असाइन करें, और इसे तर्कों के रूप में न्यूनतम और अधिकतम दें। उदाहरण:

f=a=>b=>[...Array(b).keys()].filter(c=>c>=a&([...c+''].map(d=>c-=d**++e,e=0),!c))
f(0)(90)

उत्पादन

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 89]

आगे गोल्फिंग

यह बहुत अच्छी तरह से गोल्फ है, लेकिन हमेशा सुधार के लिए जगह है ... मुझे लगता है।

— ल्यूक
स्रोत

हाँ, यह वास्तव में थोड़ा छोटा है। धन्यवाद!

— ल्यूक

1

आप दो बाइट्स को बचाने के d**(e+1)लिए बदल सकते हैं d**-~e।

— ETHproductions

टिप के लिए धन्यवाद, इसे जोड़ा। केवल 2 और बाइट्स इससे पहले कि हम पायथन को हरा चुके हैं ...

— ल्यूक

आप उपयोग कर सकते हैं &के बजाय &&। जाने के लिए एक और बाइट ...

— अरनौल्ड

मैंने अभी-अभी अपनी स्थानीय प्रति में परिवर्तन किया है ... लगता है कि आप तेज थे।

— ल्यूक

6

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 52+), 68 बाइट्स

f=(n,m)=>(e=0,[for(d of t=n+'')t-=d**++e],t||alert(n),n-m&&f(n+1,m))

पुनरावर्ती फ़ंक्शन जो आउटपुट के माध्यम से होता है alert। फ़ायरफ़ॉक्स के डेवलपर संस्करण में काम करता है, जिसे आप इस पृष्ठ पर डाउनलोड कर सकते हैं । फ़ायरफ़ॉक्स के पिछले संस्करण **ऑपरेटर का समर्थन नहीं करते हैं , और कोई अन्य ब्राउज़र [for(a of b)c]सिंटैक्स का समर्थन नहीं करता है।

टेस्ट स्निपेट

यह .mapएक सरणी समझ के Math.powबजाय , और इसके बजाय का उपयोग करता है **, इसलिए इसे उन सभी ब्राउज़रों में काम करना चाहिए जो ES6 का समर्थन करते हैं।

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

f=(n,m)=>(e=0,[...t=n+''].map(d=>t-=Math.pow(d,++e)),t||alert(n),n-m&&f(n+1,m))

f(0,100)

Expand snippet

— ETHproductions
स्रोत

6

05AB1E , 12 बाइट्स

Emigna के लिए धन्यवाद 2 बाइट्स सहेजे गए

ŸvygLySmOyQ—

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

Ÿ            # push [a .. b]
 vy          # for each
   gL        # push [1 .. num digits]
     yS      # push [individual digits]
       m     # push [list of digits to the power of [1..num digits] ]
        O    # sum
         yQ— # print this value if equal

— रिले
स्रोत

ŸvygLySmOyQ—12 बाइट्स के लिए काम करना चाहिए।

— एमिग्ना

5

पायथन 3, 100 बाइट्स

lambda n,m:{*range(10),89,135,175,518,598,1306,1676,2427,2646798,0xa8b8cd06890f2773}&{*range(n,m+1)}

कम से कम दृष्टिकोण नहीं है, लेकिन एक बहुत प्यारा है। सूक्ष्मता से बहुत सारे शुल्क हैं; एक अच्छा सबूत के लिए OEIS पृष्ठ देखें। ये सभी हैं।

— लिन
स्रोत

यह हार्ड-कोडिंग का उपयोग है, जो एक खामियों से भरा है। metg.codegolf.stackexchange.com/a/1063/55243 मैं आपको मानक नियमों के साथ फिट होने के लिए अपना जवाब बदलने की सिफारिश करूंगा

— जॉर्ज

5

मुझे नहीं लगता कि यह हार्ड-कोडिंग नियम का उल्लंघन करता है, क्योंकि कार्यक्रम अभी भी "काम करता है" और आउटपुट हार्ड-कोडेड नहीं है।

— एलेक्स हॉवान्स्की

4

आर, 100 बाइट्स

function(n,m,x=n:m)x[sapply(x,function(y)sum(as.integer(el(strsplit(c(y,""),"")))^(1:nchar(y)))==y)]

फ़ंक्शन जो लेता है nऔर m। हमेशा की तरह R में, पूर्णांक को अंकीय अंक वेक्टर में विभाजित करना थकाऊ होता है और बहुत सारे बाइट्स खाता है। यह फ़ंक्शन को अपेक्षाकृत धीमा बनाता है और केवल 32-बिट पूर्णांक के लिए काम करता है।

— Billywob
स्रोत

4

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

D*J$S⁼
rÇÐf

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

16 से 11 से नीचे, @miles से कुछ मदद मिली!

स्पष्टीकरण:

rÇÐf    Main link, arguments are m and n
r       Generate a list from m to n
 Ç      Invoke the helper link
  Ðf    And filter out all that don't return 1 on that link

D*J$S⁼  Helper link, determines if item is Disarium
D       Break input (the current item of our list in Main) into digits (135 --> [1, 3, 5])
  J$    Create a range from 1 to x, where x is the number of digits             [1, 2, 3]
 *      Raise each digit to the power of their respective index 
    S⁼  And return a 1 if the sum of powers is equal to the helper-link's input

— steenbergh
स्रोत

आप Jसूचकांक प्राप्त करने के लिए उपयोग कर सकते हैं । एक छोटा तरीका हो सकता D*J$S⁼है कि आप अपने दो लिंक को एक

— मील

लगभग 20 सेकंड पहले इस निष्कर्ष पर पहुंचे। Thnx!

— स्टीनबेरग

3

सीजेएम , 23 बाइट्स

q~),\>{_Ab_,,:).#:+=},p

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

व्याख्या

q~                      Get and eval all input
  ),\>                  Get the range between m and n, inclusive
      {                 For each number in the range...
       _Ab               Duplicate and get the list of digits
          _,,:)          Duplicate the list, take its length, make the range from 1 to length
               .#        Vectorize with exponentiation; computes first digit^1, second^2, etc
                 :+      Sum the results
                   =     Compare to the original number
                    },  Filter the range to only numbers for which the above block is true
                      p Print nicely

— बिजनेस कैट
स्रोत

3

05AB1E , 18 बाइट्स

Ÿvy©SDgLsmO®Qi®}})

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

— जादू ऑक्टोपस Urn
स्रोत

3

पायथन 2.X, 92 बाइट्स

lambda m,n:[k for k in range(m,n+1)if sum(int(j)**(i+1) for i,j in enumerate(list(`k`)))==k]

— hashcode55
स्रोत

बेकार व्हाट्सएप के बाद (i+1), लेकिन यह कोई समस्या नहीं है, जब आप कोष्ठक से छुटकारा पा लेते हैं -~i।

— यति

कि मेरी कोशिश तुम्हारी तरह ही सटीक होगा!

— हैशकोड 55

लगभग। आपके पास है list('k'), जो मेरे पास नहीं है। हालाँकि, आप अभी भी

— व्हॉट्सएप

3

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

एक पूर्ण कार्यक्रम दृष्टिकोण, वर्तमान में लंबोदर समाधान के समान लंबाई है।

a,b=input()
while a<=b:
 t=p=0
 for x in`a`:p+=1;t+=int(x)**p
 if t==a:print a
 a+=1

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

— फ्लिपटैक
स्रोत

हम्म। मैंने लगभग सटीक उत्तर के बारे में सोचा, लेकिन भ्रम के कारण त्याग दिया input()। बहुत अच्छा! +1।

— यति

3

जाप, 15 बाइट्स

òV f_¥Zì £XpYÄÃx

इसे ऑनलाइन टेस्ट करें!यह @obarakon और मेरे बीच एक सहयोग था।

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

òV f_¥Zì £XpYÄÃx   // Implicit: U, V = input integers
òV                 // Create the inclusive range [U...V].
   f_              // Filter to only the items Z where...
               x   //   the sum of
      Zì           //   the decimal digits of Z,
         £XpYÄÃ    //   where each is raised to the power of (index + 1),
     ¥             //   is equal to Z.
                   // Implicit: output result of last expression

Japt के नवीनतम संस्करण में, xएक फ़ंक्शन को एक तर्क के रूप में स्वीकार करता है, जो हमें एक और बाइट गोल्फ करने की अनुमति देता है:

òV f_¥Zì x@XpYÄ

इसे ऑनलाइन टेस्ट करें!

— ETHproductions
स्रोत

2

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

#(for[i(range %(inc %2)):when(=(int(apply +(map(fn[i v](Math/pow(-(int v)48)(inc i)))(range)(str i))))i)]i)

समीकरण को लागू करना बहुत लंबा है।

— निकोनिरह
स्रोत

कुछ बाइट्स करके बचा सकता है (.pow(-(int v)48M)

— क्लिफरॉट

2

टीआई-बेसिक, 85 बाइट्स

Input 
For(I,X,Y
If I<=9 or sum(I={89,135,175,518,598,1306,1676,2427,2646798,12157692622039623539
Disp I
End

— Timtech
स्रोत

मुझे नहीं पता था कि हार्ड-कोडिंग की अनुमति थी। :)

— एबेल टॉम

@AbelTom खैर, यह वास्तव में मदद करता है कि इस श्रृंखला में केवल 20 शब्द हैं। इसके अलावा, टीआई-बेसिक में स्ट्रिंग को संख्या में परिवर्तित करने से बहुत सारे बाइट्स होते हैं। केवल अन्य समाधान int(log(हर संख्या के लिए होगा और फिर शक्तियों को करना होगा। शायद यह कम है, लेकिन मुझे इसमें संदेह है।

— टिमटेक

वह इनपुट मेथड बहुत चालाक है लेकिन स्केच का है। आपको FUNCमोड में होना चाहिए और विंडो को आपके इनपुट बिंदु को शामिल करने के लिए सेट करना होगा। मुझे पर्याप्त पोर्टेबल नहीं लगता है।

— जकॉब

@JakobCornell डिफ़ॉल्ट रूप से कैल्क FUNCमोड में है, हालांकि मैं देख रहा हूं कि आप इनपुट रिज़ॉल्यूशन के बारे में क्या कह रहे हैं। लेकिन, गोल्फिंग में यह तरीका बहुत सामान्य है। आप हमेशा के Prompt X,Yबजाय कर सकते हैं ।

— टाइमटेक

2

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

n#m=[i|i<-[n..m],i==sum(zipWith(^)(read.pure<$>show i)[1..])]

उदाहरण का उपयोग करें 5 # 600 ->[5,6,7,8,9,89,135,175,518,598]।

iरेंज में प्रत्येक संख्या की जाँच करें [n..m]। अंकों iको एक स्ट्रिंग ( show) में बदलकर और प्रत्येक चार को एक तत्व स्ट्रिंग ( pure) बनाकर निकाला जाता है जिसे फिर से पूर्णांक में बदल दिया जाता है ( read)। [1..]फंक्शन के माध्यम से उन नंबरों को जिप कर ^लें और ले जाएं sum।

— nimi
स्रोत

2

PHP, 92 91 88 बाइट्स

3 बाइट्स धन्यवाद @AlexHowansky

for([,$n,$m]=$argv;$n<=$m;$s-$n++?:print"$s,")for($i=$s=0;_>$b=($n._)[$i++];)$s+=$b**$i;

कमांड लाइन तर्कों से इनपुट लेता है; एक अनुगामी अल्पविराम छापता है। साथ चलाना -r।

— टाइटस
स्रोत

1

तीनों को बचाएंfor([,$n,$m]=$argv;$n<=$m;

— एलेक्स हॉवान्स्की

अजीब है कि प्रिंट वहाँ काम करता है लेकिन गूंज नहीं करता है। मुझे लगता है क्योंकि गूंज कुछ भी नहीं लौटाता है - अशक्त भी नहीं, अजीब तरह से।

— एलेक्स हॉवान्स्की

@AlexHowansky: यह भी अजीब है "$n"[index]और "_$n"[index]पार्स त्रुटियों का उत्पादन करते हैं "89"[index]और $s="$n";$s[index]पूरी तरह से ठीक हैं।

— टाइटस

हम्म हाँ, यह पहली बार में अजीब लगता है, लेकिन डॉक्स की जाँच करने के बाद, ऐसा प्रतीत होता है कि वे स्पष्ट रूप से कहते हैं कि यह सुविधा केवल स्ट्रिंग शाब्दिकों के लिए काम करती है।

— एलेक्स हॉवान्स्की

हे हे यह अच्छी तरह से काम करता है, लेकिन यह शायद आपको किसी भी बाइट को नहीं बचाता है: ("_$n")[index]

— एलेक्स हॉवान्स्की

2

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

Select[Range@##,Tr[(d=IntegerDigits@#)^Range@Length@d]==#&]&

दो पूर्णांक तर्क देने और पूर्णांकों की सूची लौटाने का कार्य करें। (d=IntegerDigits@#)^Range@Length@dउपयुक्त शक्तियों के लिए एक संख्या के अंकों की सूची तैयार करता है; Tr[...]==#यह पता लगाता है कि क्या उन अंकों-शक्तियों का योग मूल संख्या के बराबर है।

— ग्रेग मार्टिन
स्रोत

2

MATLAB, 88 73 बाइट्स

@(n,m)find(arrayfun(@(n)n==sum((num2str(n)-48).^(1:log10(n)+1)),n:m))+n-1

मूल उत्तर:

function g(n,m);a=n:m;a(arrayfun(@(n)n==sum((num2str(n)-'0').^(1:floor(log10(n))+1)),a))

num2str(n)-'0'nअपने अंकों के सदिश में विभाजित होता है , और 1:floor(log10(n))+1एक सदिश होता है जो अंकों की संख्या में एक होता है n। एक गुमनाम समारोह में गोल्फ के लिए लॉग इन करने के लिए धन्यवाद , 15 बाइट्स की बचत।

— MattWH
स्रोत

1

हास्केल , 82 76 75 बाइट्स

n!m=[x|x<-[n..m],x==x#(length.show)x]
0#i=0
n#i=(div n 10)#(i-1)+mod n 10^i

इसे ऑनलाइन आज़माएं! उपयोग:5 ! 175

यह जाँच करता है सीमा में प्रत्येक संख्या nके लिए mहै, तो इसकी एक disarium संख्या और इसलिए काफी बड़ा के लिए धीमी है m।

तेजी से संस्करण: (93 बाइट्स)

n!m=[x|x<-[0..9]++[89,135,175,518,598,1306,1676,2427,2646798,12157692622039623539],x>=n,x<=m]

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

— Laikoni
स्रोत

1

सी (जीसीसी) , 136 बाइट्स

r[]={0,0};f(n){if(n)f(n/10),r[1]=pow((n%10),*r)+r[1]+.5,r[0]++;else*r=1,r[1]=0;}g(m,x){for(;m<=x;m++){f(m);if(m==r[1])printf("%d,",m);}}

टीआईओ पर हेडर को परिभाषित करने वाले पाउडर क्योंकि किसी कारण से इसमें ऑटो शामिल नहीं था। मेरे कंप्यूटर ने किया, इसलिए मैं इसके साथ रोल करने जा रहा हूं।

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

— nmjcman101
स्रोत

1

MATL , 16 बाइट्स

&:"@tFYAtn:^s=?@

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

&:        % Input two n, m implicitly. Push array [n n+1 ... m]
"         % For each k in that array
  @       %   Push k
  tFYA    %   Duplicate. Convert to decimal digits
  tn:     %   Duplicate. Push [1 2 ... d], where d is the number of digits
  ^       %   Element-wise power
  s       %   Sum of array
  =       %   Compare with previous copy of k: is it equal?
  ?       %   If so
    @     %     Push k
          %   End, implicit
          % End, implicit
          % Display stack, implicit

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

1

बैच, 115 बाइट्स

@for %%d in (0 1 2 3 4 5 6 7 8 9 89 135 175 518 598 1306 1676 2427 2646798)do @if %%d geq %1 if %%d leq %2 echo %%d

बैच में केवल 32-बिट अंकगणित होता है, जिसमें अंतिम शुल्क संख्या की तुलना करने का कोई तरीका नहीं होता है, लेकिन यदि आप स्ट्रिंग तुलना पर जोर देते हैं, तो 402 बाइट्स के लिए:

@echo off
for %%d in (0 1 2 3 4 5 6 7 8 9 89 135 175 518 598 1306 1676 2427 2646798 12157692622039623539)do call:c %1 %%d&&call:c %%d %2&&echo %%d
exit/b
:c
call:p %1 %2
set r=%s%
call:p %2 %1
:g
if %r:~,1% lss %s:~,1% exit/b0
if %r:~,1% gtr %s:~,1% exit/b1
if %r%==%s% exit/b0
set r=%r:~1%
set s=%s:~1%
goto g
:p
set s=%1
set t=%2
:l
set s=0%s%
set t=%t:~1%
if not "%t%"=="" goto l

— नील
स्रोत

1

अजगर 2, 100 बाइट्स

for i in range(input(),input()+1):x=sum(int(`i`[n])**-~n for n in range(len(`i`)));print("",x)[x==i]

मुझे अभी तक इसे चलाने का मौका नहीं मिला है (अपने फोन पर ऐसा कर रहा हूं)।

— डैनियल
स्रोत

यह काम नहीं करता है। गलत सिंटैक्स और सही होने पर, केवल बूलियन मान मुद्रित करेगा। एक्सपोनेंट 0 से शुरू होता है, जो गलत भी है। इसके अलावा, आपको वर्ग कोष्ठक के अंदर की आवश्यकता नहीं है sum।

— यति

यह डिस्फ़ॉर्म संख्या के लिए जाँच नहीं कर रहा है।

— हैशकोड 55

@ हैशकोड 55, निश्चित (?)

— डैनियल

@ तुकुक्का, अब मुझे लगता है कि यह काम करना चाहिए

— डैनियल

मैं कंप्यूटर पर नहीं हूं, लेकिन यह प्रत्येक पुनरावृत्ति पर एक नई iरूपरेखा मुद्रित करना चाहिए, जहां एक शुल्क है। मुझे इस बात की कोई जानकारी नहीं है कि क्या इसकी अनुमति है, लेकिन मैं नहीं कहूंगा, क्योंकि आउटपुट बहुत खाली है।

— यत्सी

1

स्काला, 132 129 बाइट्स

(% :Int,^ :Int)=>for(i<- %to^)if(((0/:(i+"").zipWithIndex)((z,f)=>{z+BigInt(f._1.toInt-48).pow(f._2+1).intValue}))==i)println(i)

129 संपादित करें: लूप के परिवर्तनशील नाम के &लिए iतीन स्थानों से सहेजा गया।

व्याख्या

इनपुट रेंज में प्रत्येक मान के लिए:

इसे स्ट्रिंग में बदलें +""
zipWithIndexअंक और इसके सूचकांक के आकर्षण से युक्त टुपल्स की सूची का उपयोग करने के लिए
अपनी सूची सूचकांक प्लस एक की शक्ति (^ 1 पर शुरू करने के लिए) में प्रत्येक चार के इंट वैल्यू माइनस 48 (0-9 तक की लाइनें) को वापस करके सूची को मोड़ो।
यदि परिणाम इनपुट से मेल खाता है, तो इसे प्रिंट करें

अंत में सीखने foldऔर कैसे zipWithIndexकाम करने के लिए चारों ओर हो गया । मैं intरूपांतरणों से नाखुश हूँ , लेकिन मैं foldऔर की सफलता से प्रसन्न हूँ zipWithIndex।

— आर्कमेज मोनिका के साथ खड़ा है
स्रोत

1

ऑक्टेव, 88 87 बाइट्स

एक बाइट (f (x) -48 बनाम f (x) - '0' बचाने के लिए MattWH का धन्यवाद

@(n,m,f=@num2str,a=n:m)a(a==cell2mat(arrayfun(@(x){sum((f(x)-48).^(1:nnz(f(x))))},a)))

चलाने के लिए:

>> f=@(n,m,f=@num2str,a=n:m)a(a==cell2mat(arrayfun(@(x){sum((f(x)-'0').^(1:nnz(f(x))))},a))) 
>> f(0,1000)
ans = 
      1     2     3     4     5     6     7     8     9    89   135   175   518   598

व्याख्या

@(n,m,                                              % Create an anonymous function and pass it n and m as paramteres
    f=@num2str,                                     % Will be using the num2str mehtod twice, set the variable f to the handle to save on bytes
        a=n:m)                                      % Create a vector 'a' and populate it with the numbers n through m
            a(a==                                   % Logically index into a, where the values of a match Disarium numbers
                cell2mat(                           % Convert the cell array returned by arrayfun into a matrix, so we can use it in the logical index
                    arrayfun(@(x){                  % Call the following function on every element of a, using the index named 'x'
                        sum(                        % Sum the matrix that results from the following computation
                            (f(x)-'0')              % Convert the value at index x into a string, then break it into a matrix by subtracting the string '0'.
                                                    % This results in the matrix [1 3 5] for the number 135.
                                .^                  % Compute the element-wise power with the following matrix
                                    (1:nnz(f(x)))   % Create a matrix with the range 1 to the length of the number at index x. This results in the matrix 
                                                    % [1 2 3] for the number 135.
                        )                           % Closes the sum statement
                    },a)                            % Closes the arrayfun statement, passing the matrix a to be operated on
                )
            )

— lsnare
स्रोत

1

C 175 169 बाइट्स

f(a,b){for(j=a;j<b;j++){n,i=0,x=0;s=0;n=j;while(n!=0){n/=10;i++;}a[i];n=j;while(n!=0){a[i-x-1]=n%10;n/=10;x++;}for(x=0;x<i;x++)s+=(int)pow(a[x],x+1);if(j==s)printf("%d ",s);}}

Ungolfed संस्करण:

void f(int a, int b)
{

  for(int j=a; j<b;j++)
  {
    int n,i=0,x=0;
    int s=0;
    n=j;

   //Convert each number from 'n' to 'm' and store it in an int array 
   while(n)
   {
     n/=10;
     i++;     
   }
   int a[i]; 

   n=j;       
   while(n)
   {
    a[i-x-1]=n%10;
    n/=10;
    x++;     
   }

  //Calculate sum of digits powered with their respective position
  for(x=0;x<i;x++)
   s+=(int)pow(a[x], x+1);

   //Print Desarium
   if(j==s)
    printf("%d ", sum);     
 }

}

किसी तरह से छोटा किया जा सकता है, लेकिन मैं इसे फिलहाल नहीं देखता।

@TuukkaX 6 बाइट बचाने के लिए धन्यवाद।

— हाबिल टॉम
स्रोत

दोनों n!=0को बदला जा सकता है n।

— यति

तुम सही हो, यह समझ में आता है!

— हाबिल टॉम

0

जावा

s->{long i=0,j=0,c,d;for(;j!=s;){String []f=Long.toString(i).split("");for(d=0,c=0;d<f.length;)c+=Math.pow(Long.valueOf(f[d]),++d);if(i==c)j++;}return i;}

व्याख्या

s    - index
i    - iteration variable
j    - matches
c    - sum of each digit^its index
d    - index of digit in i

— रोमन ग्रैफ़
स्रोत

0

पायथन 3: 131 बाइट्स

n=int(input())
m=int(input())
R=[x for x in range(n,m+1)]
O=[sum(map(int,str(x)))for x in R]
F=[(x**(O.index(x)))for x in O]
L=[x for x in F for w in R if x==w]
print(list(set(L)))

इस कोड को बनाने के बाद, यह स्पष्ट हो गया है कि सीमित संख्या में शुल्क हैं, इसलिए हो सकता है कि यह सूची समाधानों का उपयोग करने के बजाय इन समाधानों के लिए जांचने के लिए अधिक संभव हो, जो इस समाधान के लिए बड़े इनपुट पर कठिन है।

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

— MildCorma
स्रोत

वैराग्य दुविधा

वैराग्य दुविधा

पर्ल 6 , 40 39 बाइट्स

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

पायथन 2, 98 89 88 84 बाइट्स

पर्ल, 43 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 7), 105 91 89 88 83 79 82 81 बाइट्स

प्रयोग

उत्पादन

आगे गोल्फिंग

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 52+), 68 बाइट्स

टेस्ट स्निपेट

05AB1E , 12 बाइट्स

पायथन 3, 100 बाइट्स

आर, 100 बाइट्स

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

सीजेएम , 23 बाइट्स

05AB1E , 18 बाइट्स

पायथन 2.X, 92 बाइट्स

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

जाप, 15 बाइट्स

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

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

टीआई-बेसिक, 85 बाइट्स

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

PHP, 92 91 88 बाइट्स

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

MATLAB, 88 73 बाइट्स

हास्केल , 82 76 75 बाइट्स

सी (जीसीसी) , 136 बाइट्स

MATL , 16 बाइट्स

बैच, 115 बाइट्स

अजगर 2, 100 बाइट्स

स्काला, 132 129 बाइट्स

व्याख्या

टिप्पणियाँ

ऑक्टेव, 88 87 बाइट्स

व्याख्या

C 175 169 बाइट्स

जावा

व्याख्या

पायथन 3: 131 बाइट्स