53

एक Narcissistic संख्या एक संख्या है जो अपने स्वयं के अंकों का योग है, प्रत्येक को अंकों की संख्या की शक्ति तक बढ़ाया जाता है।

उदाहरण के लिए, 153 (3 अंक) लें:

1 ³ + 5 ³ + 3 ³ = 1 + 125 + 27 = 153

1634:

1 ⁴ + 6 ⁴ + 3 ⁴ + 4 ⁴ = 1 + 1296 + 81 + 256 = 1634

चुनौती:

आपके कोड को उपयोगकर्ता से इनपुट लेना चाहिए और दिए गए नंबर एक Narcissistic नंबर है या नहीं, इस पर निर्भर करते हुए True या False का इनपुट लेना चाहिए।

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

OEIS A005188

code-golf math decision-problem

— Iszi
स्रोत

3

क्या यह ठीक है अगर मैं Trueइस तरह के एक नंबर पर आउटपुट करता हूं , लेकिन कुछ और (इस मामले में नंबर ही) अगर नहीं?

— 21

39

एपीएल (15)

∆≡⍕+/(⍎¨∆)*⍴∆←⍞

आउटपुट 1यदि सत्य है और 0यदि गलत है।

स्पष्टीकरण:

∆←⍞: एक पंक्ति (वर्णों के रूप में), स्टोर में पढ़ें ∆
(⍎¨∆)*⍴∆: प्रत्येक चरित्र का मूल्यांकन करें ∆और उसे शक्ति में बढ़ाएं⍴∆
∆≡⍕+/: देखें कि क्या इनपुट इनमें से राशि के स्ट्रिंग प्रतिनिधित्व के बराबर है

— मारीनस
स्रोत

9

मैंने अभी क्या पढ़ा

— Jbwilliams1

4

@ लैग्वैगन भगवान की भाषा

— tomsmeding

21

GolfScript, 16 अक्षर

~.`:s{48-s,?-}/!

इनपुट STDIN पर दिया जाना चाहिए, आउटपुट 0 या 1 गैर-मादक / नशीली संख्या को दर्शाता है।

कोड की व्याख्या:

~              # Evaluate the input to get a number
.              # Accumulator (initially the number itself)
`:s            # Convert number to string and assign to variable s
{              # Loop over characters of the string
  48-          # Reduce character value by 48
  s,           # Push length of input number
  ?            # Power
  -            # Subtract result from accumulator
}/
!              # Not! (i.e. iff accumulator was zero it was a narcissistic number)

— हावर्ड
स्रोत

मैंने `` ~ .` `` पर डबल-लिया लेकिन इसमें सुधार करना असंभव लगता है। अच्छा है।

— पीटर टेलर

15

गणितज्ञ, ४३ वर्ण

Tr[#^Length@#&@IntegerDigits@#]==#&@Input[]

— alephalpha
स्रोत

14

पर्ल, 38 अक्षर

perl -lpe '$@=y///c;$s+=$_**$@for/./g;$_=$_==$s'

एक बहुत ही सरल कार्यान्वयन।

यहाँ थोड़ा अलग संस्करण है जो 35 वर्णों में फिट बैठता है:

perl -lpe '$@=y///c;$s+=$_**$@for/./g;$_-=$s'

यदि इनपुट मादक है, तो यह संस्करण एक गलत मान देता है, अन्यथा यह एक (पर्ल-एक्सेप्टेड) सच्चे मूल्य को आउटपुट करता है। कोई यह तर्क दे सकता है कि यह पीछे का संस्करण चुनौती विवरण की सीमा के भीतर है, लेकिन प्रतिबिंब पर मैंने निर्णय नहीं लिया। मैं अपना स्कोर सुधारने के लिए बेताब नहीं हूं। फिर भी।

— रोटी का डिब्बा
स्रोत

"टेक्स्ट स्ट्रिंग्स या अन्य अमान्य इनपुट्स के लिए त्रुटि जांच की आवश्यकता नहीं है।" - तो क्यों न मानें कि इनपुट वैध संख्या होगी, बिना नई रूपरेखा के? echo -n 153 | perl -pe '…'बिना काम करेंगे -l।

— मैनटवर्क

मुझे लगता है कि जब तक आप परिभाषित करते हैं कि आपके सच्चे और झूठे आउटपुट क्या हैं, यह कानूनी होना चाहिए

— Cruncher

कड़ाई से बोलते हुए, चुनौती पाठ का शब्दांकन थोड़ी अस्पष्टता को छोड़ देता है जैसे कि ट्रू / फाल्स या 0/1 का क्या मतलब होना चाहिए, इसलिए मैं इसे पास कर दूंगा। समान लंबाई की एक अलग स्क्रिप्ट जो मादक मूल्यों के लिए सही रिटर्न देती है, हालांकि इसका फायदा होगा।

— इस्ति

एक ही विचार लेकिन कम:perl -pe'map$s+=$_**@y,@y=/./g;$_=$_==$s'

— msh210

13

जे, 23 वर्ण

(".=+/@("."0^#))(1!:1)1

(1!:1)1 कीबोर्ड इनपुट है (एक स्ट्रिंग लौटाते हुए)।

".एक नंबर के लिए इनपुट धर्मान्तरित; "00 के एक रैंक (आयाम) को निर्दिष्ट करता है, दूसरे शब्दों में, प्रत्येक वर्ण को लेने और इसे एक संख्या में परिवर्तित करने के लिए।

^पावर फ़ंक्शन है और #लंबाई फ़ंक्शन है, इस प्रकार प्रत्येक अंक को स्ट्रिंग की लंबाई की शक्ति (समकक्ष, अंकों की संख्या) तक ले जाता है।

+/सिर्फ राशि है, और =योग और संख्या की तुलना कर रहा है।

— rationalis
स्रोत

2

"आपके कोड को उपयोगकर्ता से इनपुट लेना चाहिए और सही या गलत होने के आधार पर आउटपुट देना चाहिए कि क्या दी गई संख्या एक Narcissistic नंबर है।" (जोर मेरा)

— जॉन ड्वोरक

@JanDvorak मेरा बुरा जोड़ा कीबोर्ड इनपुट।

— रासलीला

12

रूबी, 34 + 5 = 39

कमांड-लाइन झंडे के साथ

ruby -nlaF|

Daud

p eval [$F,0]*"**#{~/$/}+"+"==#$_"

सच या गलत आउटपुट।

— histocrat
स्रोत

3

पी: यह सबसे रूबी झंडे मैंने कभी एक वैध कोड गोल्फ में देखा है हो सकता है

— दरवाज़े

11

आर, 71 69 66 56 48

8 बाइट्स से घटाकर @Giuseppe को धन्यवाद ! मॉडुलो ऑपरेशन से पहले पूर्णांक विभाजन करने का विचार था।

i=nchar(a<-scan()):0;a==sum((a%/%10^i%%10)^i[1])

(3-वर्ष) संबंधित विवरण के साथ पुराना संस्करण:

i=nchar(a<-scan()):1;a==sum(((a%%10^i)%/%10^(i-1))^i[1])

a<-scan()इनपुट के रूप में एक संख्या (पूर्णांक, वास्तविक, ...) लेता है ( 153उदाहरण के लिए कहें )।
iएक वेक्टर बन जाता है जिसमें 3 से 1 ( a3 होने के वर्णों की संख्या ) होता है। इसलिए इसे 1000, 100 और 10 के माध्यम
%%से वेक्टर किया जाता a%%10^iहै a: इसलिए यह देता है 153, 53, 3।
(a%%10^i)%/%10^(i-1)100, 10, 1 द्वारा उस वेक्टर का पूर्णांक विभाजन है: इसलिए 1, 5, 3,।
हम उसे बढ़ाते हैं, जिसके पहले तत्व के साथ i( aयानी अंक) वर्णों की संख्या होती है , यानी 3इस प्रकार एक सदिश जिसमें 1, 125, 27हम होते हैं sumऔर जिसकी तुलना करते हैं a।

— plannapus
स्रोत

क्या पूर्णांक विभाजन हमेशा गोल होता है? अन्यथा, आप समस्याओं में भाग ले सकते हैं जैसे कि 370 (एक नशीली संख्या) जो 4,7,0 (जो कि झूठी होगी) या 270 (गैर-मादक) में बदलकर 3,7,0 में बदल जाएगी (सच लौटेगी)।

— इज़ी

पूर्णांक विभाजन गोल नहीं होता ... 100 से 370 का पूर्णांक विभाजन 70 के शेष के साथ 3 है और 3.70 नहीं है।

— प्लेनैपस

1

48 बाइट्स ... किसी ने इसे मुखपृष्ठ पर टक्कर दी!

— ग्यूसेप

9

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

बहुत मोटे नहीं हैं, लेकिन एक सरल समाधान है।

s = input()
print(int(s)==sum(int(c)**len(s)for c in s))

— danmcardle
स्रोत

1

[और ]अनावश्यक हैं, और आप के सामने अंतरिक्ष ड्रॉप कर सकते हैं forभी, तो:sum(int(c)**len(s)for c in s)

— मारीनस

वह तो कमाल है! पारितोषिक के लिए धन्यवाद।

— danmcardle

1

आप रिक्त स्थान को हटाकर दो पात्रों को बचा सकते हैं s = input()और इसे 2.7 में स्थानांतरित कर सकते हैं जहां printफ़ंक्शन नहीं है।

— बेन

अच्छी बात है, संपादित।

— danmcardle

मुझे लगता है कि आपको संकेत देना चाहिए कि ब्रेसेस को जोड़ना print(इसलिए एक वर्ण अधिक) यह एक वैध पायथन 2.x और पायथन 3.x समाधान बना देगा।

— मार्टिन थोमा

8

PHP, 80 74 66 वर्ण

बहुत सीधा PHP समाधान:

<?for(;$i<$l=strlen($a=$argv[1]);)$s+=pow($a[$i++],$l);echo$s==$a;

यह error_reportingमाना जाता है कि इसमें नोटिस शामिल नहीं हैं, अन्यथा काफी कुछ अतिरिक्त पात्रों को शुरू करने $s=0;और करने की आवश्यकता होगी $i=0।

कई वर्णों को छोटा करने के लिए Thx @manatwork।

— व्लाद प्रेडा
स्रोत

अलग बयानों में $ और $ l असाइन न करें। <?for($i=0;$i<$l=strlen($a=$argv[1]);$i++){$s+=pow($a[$i],$l);}echo$s==$a;छोटा है।

— मैनटवर्क

जैसा कि आपके पास पहले से ही एक बयान है जो एक नोटिस उत्पन्न करता है, बस एक और जोड़ें: लूप नियंत्रण चर आरंभीकरण को हटा दें। लूप नियंत्रण चर को बढ़ाने के लिए भी एक स्टैंडअलोन स्टेटमेंट होने की आवश्यकता नहीं है। और ब्रेसिज़ निश्चित रूप से आवश्यक नहीं हैं <?for(;$i<$l=strlen($a=$argv[1]);)$s+=pow($a[$i++],$l);echo$s==$a;:।

— 15

@manatwork: कोडगॉल्फ के गर्मजोशी से स्वागत के लिए धन्यवाद :)

— व्लाद प्रेडा

इसे गोल्फ किया जा सकता हैfor(;$i<$l=strlen($a=$argn);)$s+=$a[$i++]**$l;echo$s==$a;

— जोर्ज हल्सरमैन

8

डीसी: 48 अक्षर

[1pq]Sr?d0rdZSz[d10/r10%lz^rSh+Lhd0!=c]dScx+=r0p

नमूना रन:

bash-4.1$ dc -e '[1pq]Sr?d0rdZSz[d10/r10%lz^rSh+Lhd0!=c]dScx+=r0p' <<< '153'
1

bash-4.1$ dc -e '[1pq]Sr?d0rdZSz[d10/r10%lz^rSh+Lhd0!=c]dScx+=r0p' <<< '1634'
1

bash-4.1$ dc -e '[1pq]Sr?d0rdZSz[d10/r10%lz^rSh+Lhd0!=c]dScx+=r0p' <<< '2013'
0

— आदमी काम पर है
स्रोत

वास्तव में कभी भी इस्तेमाल नहीं किया गया dc, लिखने के प्रयास में उन्मत्त टाइपोस के लिए बचाओcd

— स्टेन स्ट्रम

8

के, २४ २३

{x=+/xexp["I"$'a]@#a:$x}

रीवार्डिंग के साथ शेव किया हुआ 1

{x=+/{x xexp#x}"I"$'$x}

— tmartin
स्रोत

8

आर, 53 बाइट्स

sum(scan(t=gsub("(.)","\\1 ",x<-scan()))^nchar(x))==x

gsubRegex, वर्णों के बीच में रिक्त स्थान सम्मिलित करता है ताकि scanसमारोह अंकों के एक वेक्टर में संख्या को पढ़ने के लिए सक्षम हो जाएगा।

— flodel
स्रोत

+1 मैंने ऐसा करने के बारे में कभी नहीं सोचा होगा, यह शानदार है।

— प्लेनैपस

6

कोना, १ 18

...

{x=+/(0$'u)^#u:$x}

— tmartin
स्रोत

6

पॉवर्सशेल, 75 63 62 60 58

संपादित करें: प्रति @ Iszi टिप्पणी के अपडेट ~~(नोट: यह मायने रखता है$x मौजूदा नहीं है)~~

संपादित करें: @ Danko के परिवर्तन जोड़े गए।

[char[]]($x=$n=read-host)|%{$x-="$_*"*$n.length+1|iex};!$x

58 ५६ चरस

यदि इनपुट 10 अंकों तक सीमित है (सभी इंट 32 शामिल हैं)

($x=$n=read-host)[0..9]|%{$x-="$_*"*$n.length+1|iex};!$x

— Rynant
स्रोत

मैं सोच रहा था कि क्या इससे पहले कि कोई PowerShell करने जा रहा है।

— इज़्ज़ी

अन्य चर जोड़कर 12 अक्षर सहेजें $xऔर का उपयोग कर +=अपने बजाय संक्षेप करने के लिए measure -sumफिर परीक्षण $x-eq$n।

— इज़्ज़ी

1

61 वर्ण:($x=$n=read-host)-split''|%{$x-=[math]::pow($_,$n.length)};!$x

— डैंको डर्बिएक

1

@ DankoDurbić, अच्छा लगा! PoSh कोड गोल्फिंग के साथ अक्सर टाइप क्यूरेशन काम आता है। मुझे केवल 62 मिलते हैं, जब मैं दौड़ता हूं'($x=$n=read-host)-split""|%{$x-=[math]::pow($_,$n.length)};!$x'.length

— रेनेंट

1

@ राइनेंट गुड पॉइंट। मैंने पॉवरशेल में आपकी लंबाई की जाँच की और 62 के साथ आया। वास्तविक स्क्रिप्ट के विपरीत लंबाई की जांच करते समय , यह 61 तक आता है। यह संभवत: इस वजह से है कि पावरशेल ''आपको किस तरह से संभालता है ''। मैंने एक्सेल में डबल-चेक करने के लिए ओरिजनल स्क्रिप्ट ली =LEN("($x=$n=read-host)-split''|%{$x-=[math]::pow($_,$n.length)};!$x")और 62 भी हासिल किए। बेशक, हम हमेशा इसे मैन्युअल रूप से गिन सकते हैं - लेकिन वास्तव में कौन ऐसा करता है?

— Iszi

5

पायथन 2.x - 51

अजगर 3.x के लिए crazedgremlin के समाधान के रूप में एक ही अवधारणा:

s=input();print s==sum(int(c)**len(`s`)for c in`s`)

— user1354557
स्रोत

4

सी - 97 93 वर्ण

a,b;main(c){scanf("%d",&c);b=c;for(;c;c/=10)a+=pow(c%10,(int)log10(b)+1);printf("%d",a==b);}

इंडेंटेशन के साथ:

a,b;
main(c) { 
  scanf("%d",&c);
  b=c;
  for(;c;c/=10)
    a+=pow(c%10,(int)log10(b)+1);
  printf("%d",a==b);
}

— हंसी मजाक करना
स्रोत

2

आपको intवैश्विक चर के लिए परिभाषित करने की आवश्यकता नहीं है ।

— कोनराड बोरोव्स्की

ओह। में इनपुट पढ़ रहे हैं argc।

— SIGSTACKFAULT

इसके अलावा, -lmसंकलन-टाइम गणना +1 बाइट पर नहीं करना चाहिए ?

— SIGSTACKFAULT

@Blacksilver -lmध्वज को C89 संकलक के लिए आवश्यक नहीं है।

— जोश

अहा। हर दिन एक नई चीज सीखें।

— SIGSTACKFAULT

4

डेल्फी - 166

uses System.SysUtils,math;var i,r,l:integer;s:string;begin r:=0;readln(s);l:=length(s);for I:=1to l do r:=round(r+power(strtoint(s[i]),l));writeln(inttostr(r)=s);end.

इंडेंट के साथ

uses System.SysUtils,math;
var
  i,r,l:integer;
  s:string;
begin
  r:=0;
  readln(s);
  l:=length(s);
  for I:=1to l do
    r:=round(r+power(strtoint(s[i]),l));
  writeln(inttostr(r)=s);
end.

— तेन प्रून
स्रोत

4

05AB1E , 7 बाइट्स (गैर-प्रतिस्पर्धात्मक)

DSDgmOQ

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

-2 बाइट्स @daHugLenny को धन्यवाद

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

3

आप बदल सकते हैं §1ôके साथS

— acrolith

3

हास्केल 2010 - 76 वर्ण

main=do x<-getLine;print$(==x)$show$sum$map((^length x).(+(-48)).fromEnum)x

— नाथन बौम
स्रोत

1

आपको कोड चलाने के लिए एमएस की संख्या पोस्ट नहीं करनी चाहिए, लेकिन आपके द्वारा उपयोग किए जाने वाले चार्ट की संख्या। ;)

— उपयोगकर्ता अज्ञात 4

3

Awk: 40 39 अक्षर

{for(;i<NF;)s+=$(i+++1)**NF;$0=$0==s}1

नमूना रन:

bash-4.1$ awk -F '' '{for(;i<NF;)s+=$(i+++1)**NF;$0=$0==s}1' <<< '153'
1

bash-4.1$ awk -F '' '{for(;i<NF;)s+=$(i+++1)**NF;$0=$0==s}1' <<< '1634'
1

bash-4.1$ awk -F '' '{for(;i<NF;)s+=$(i+++1)**NF;$0=$0==s}1' <<< '2013'
0

— आदमी काम पर है
स्रोत

3

बैश, 64 वर्ण

for((a=$1;a>0;s+=(a%10)**${#1},a/=10));do :; done;echo $[s==$1]

~~a = $ 1; p = $ {# a; के लिए ((, (a> 0; a / = 10)); s = $ ((s + (a% 10) ** p)); किया; गूंज $ ( (रों == $ 1))~~

— अज्ञात उपयोगकर्ता
स्रोत

1

आप एक ही स्थान पर चर पी का उपयोग कर रहे हैं, इसलिए इसकी कोई आवश्यकता नहीं है। आप में चर एक का आरंभीकरण स्थानांतरित कर सकते हैं forअपनी अलग अतिरिक्त ;: for((a=$1;a>0;a/=10));do s=$[s+(a%10)**${#1}];done;echo $[s==$1]।

— 11

1

मूल्यांकन को आगे बढ़ाकर forएक और चरित्र को छोटा किया जा सकता है for((a=$1;a>0;s+=(a%10)**${#1},a/=10));do :; done;echo $[s==$1]:।

— मैनटवर्क

ओह, उत्सुक! मैंने ऐसा कुछ करने की कोशिश की, लेकिन यह काम नहीं किया। जिज्ञासु क्या गलत हो गया।

— उपयोगकर्ता अज्ञात 1

3

लुआ (101 वर्ण)

लुआ संक्षिप्त होने के लिए नहीं जाना जाता है, लेकिन यह वैसे भी कोशिश करने के लिए मजेदार था।

for n in io.lines()do l,s=n:len(),0 for i=1,l do d=n:byte(i)s=s+(d-48)^l end print(s==tonumber(n))end

सुधार का स्वागत करते हैं।

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

जैसा कि यह आवश्यक नहीं है कि आपका कार्यक्रम संख्याओं की सूची को संभाल और संसाधित कर सकता है, मैं उस कार्यक्षमता को लागू करने के लिए बाइट्स का उपयोग नहीं करूंगा। लूप for n in io.lines()do [...]endको n=io.read()कुछ बाइट्स ( TIO ) से बचाता है ।

— जोनाथन फ्रीच

3

जावास्क्रिप्ट - 70 58 अक्षर

for(i in a=b=prompt())b-=Math.pow(a[i],a.length)
alert(!b)

ध्यान दें:

यदि आप स्टैक एक्सचेंज में अपने देव कंसोल में इसका परीक्षण कर रहे हैं, तो ध्यान रखें कि इसमें कई गैर-मानक गुण जोड़े गए हैं String.prototypeजो इस समाधान को तोड़ देंगे, जैसे कि String.prototype.formatUnicorn। कृपया स्वच्छ वातावरण में परीक्षण करना सुनिश्चित करें, जैसे कि about:blank।

— zzzzBov
स्रोत

मैं वहां 70 कैरेक्टर गिनता हूं।

— manatwork

@manatwork, वूप्स, न्यूलाइन को गिनना भूल गया।

— zzzzBov

महान चाल है कि क्षय!

— मैनटवर्क

2

यह हमेशा trueमेरे लिए लौटता है, इनपुट की परवाह किए बिना

— कोको

@ कोको, मैंने यह बताने के लिए एक नोट जोड़ा है कि आप गलत परिणाम क्यों प्राप्त कर रहे हैं।

— zzzzBov

3

जावा - 84 बाइट्स

(a,l)->{int s=0;for(byte c:a.getBytes())s+=Math.pow(c-48,l);return a.equals(""+s);};

नॉन-लैम्ब्डा संस्करण: 101 बाइट्स:

boolean n(String a,int l){int s=0;for(byte c:a.getBytes())s+=Math.pow(c-48,l);return a.equals(""+s);}

इस तरह कहा जाता है:

interface X {
    boolean n(String a, int l);
}

static X x = (a,l)->{int s=0;for(byte c:a.getBytes())s+=Math.pow(c-48,l);return a.equals(""+s);};

public static void main(String[] args) {
    System.out.println(n("153",3));
    System.out.println(n("1634",4));
    System.out.println(n("123",3));
    System.out.println(n("654",3));
}

यह दिखाता है:

true
true
false
false

— Hypino
स्रोत

आप लंबोदर तर्कों के आसपास कोष्ठक को हटा सकते हैं, a,l->ठीक उसी तरह काम करते हैं।

— FlipTack

मुझे पता है कि आप इसका उत्तर लगभग एक साल पहले दे चुके हैं, लेकिन आप दो बाइट्स को (a,l)->a->l->byteinta->l->{int s=0;for(int c:a.getBytes())s+=Math.pow(c-48,l);return a.equals(""+s);}

— गोल

3

जाप , 14 9 7 बाइट्स

¶ì_xpZÊ

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

व्याख्या

पूर्णांक का निहित इनपुट U।

ì_

Uअंकों की एक सरणी में परिवर्तित करें ( ì), इसे एक फ़ंक्शन के माध्यम से पास करें और बाद में पूर्णांक में परिवर्तित करें।

xpZÊ

इसके अलावा घटाना ( x), प्रत्येक तत्व को प्रक्रिया में pलंबाई के ( Ê) लंबाई की शक्ति ( ) तक बढ़ाता है।

¶

जांचें कि क्या परिणाम सख्ती से बराबर है U।

— झबरा
स्रोत

मुझे लगता है कि ¥U¬®n pUlÃx11 बाइट्स के लिए काम करेगा;)

— ओलिवर

2

एफ # - 92 चार्ट

let n=stdin.ReadLine()
n|>Seq.map(fun x->pown(int x-48)n.Length)|>Seq.sum=int n|>printf"%b"

— स्मिताड अनारकिस्ट
स्रोत

2

आम लिस्प - 116 102 वर्ण

(defun f(m)(labels((l(n)(if(> n 0)(+(expt(mod n 10)(ceiling(log m 10)))(l(floor n 10)))0)))(= m(l m))))

प्रारूपित:

(defun f(m)
  (labels((l(n)
            (if(> n 0)
               (+(expt(mod n 10)(ceiling(log m 10)))
                 (l(floor n 10)))
               0)))
    (=(l m)m)))

— पॉल रिक्टर
स्रोत

2

स्मालटाक - 102 99 वर्ण

[:n|a:=n asString collect:[:e|e digitValue]as:Array.^n=(a collect:[:each|each raisedTo:a size])sum]

कार्यस्थान पर, value:संख्या के साथ भेजें , और इसे प्रिंट करें।

— पॉल रिक्टर
स्रोत

2

सी #, 117

using System.Linq;class A{int Main(string[] a){return a[0].Select(c=>c-'0'^a[0].Length).Sum()==int.Parse(a[0])?1:0;}}

— It'sNotALie।
स्रोत

2

हास्केल, 68 66 बाइट्स

d 0=[]
d n=mod n 10:d(div n 10)
sum.(\a->map(^length a)a).d>>=(==)

उपयोग:

*Main> sum.(\a->map(^length a)a).d>>=(==) $ 1634
True

— Angs
स्रोत

मादकता के लिए एक संख्या का परीक्षण करें

एपीएल (15)

GolfScript, 16 अक्षर

गणितज्ञ, ४३ वर्ण

पर्ल, 38 अक्षर

जे, 23 वर्ण

रूबी, 34 + 5 = 39

आर, 71 69 66 56 48

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

PHP, 80 74 66 वर्ण

डीसी: 48 अक्षर

के, २४ २३

आर, 53 बाइट्स

कोना, १ 18

पायथन 2.x - 51

सी - 97 93 वर्ण

डेल्फी - 166

इंडेंट के साथ

05AB1E , 7 बाइट्स (गैर-प्रतिस्पर्धात्मक)

हास्केल 2010 - 76 वर्ण

Awk: 40 39 अक्षर

बैश, 64 वर्ण

लुआ (101 वर्ण)

जावास्क्रिप्ट - 70 58 अक्षर

जावा - 84 बाइट्स

जाप , 14 9 7 बाइट्स

व्याख्या

एफ # - 92 चार्ट

आम लिस्प - 116 102 वर्ण

स्मालटाक - 102 99 वर्ण

सी #, 117

हास्केल, 68 66 बाइट्स