क्या मैं सेल्फ नंबर हूं?

31

एक सेल्फ नंबर (जिसे कोलम्बियन या देवलाली नंबर भी कहा जाता है) एक प्राकृतिक संख्या है x, जहाँ समीकरण n + <digit sum of n> = xका किसी भी प्राकृतिक संख्या के लिए कोई समाधान नहीं है n। उदाहरण के लिए, 21n = 15 परिणाम के रूप में एक आत्म संख्या नहीं है 15 + 1 + 5 = 21। दूसरी ओर, 20 है एक आत्म संख्या, के रूप में नहीं nदेखा जा सकता है संतुष्ट करता है इस तरह के एक समानता।

जैसा कि यह परिभाषा अंक योग का संदर्भ देती है, यह आधार पर निर्भर है। इस चुनौती के उद्देश्यों के लिए, हम केवल आधार 10 स्वयं संख्याओं पर विचार करेंगे, जो कि OEIS में अनुक्रम A003052 हैं । बाइनरी ( A010061 ) और आधार 100 ( A283002 ) सेल्फ नंबर को भी कैलॉग किया गया है।

चुनौती

xइनपुट के रूप में एक सकारात्मक पूर्णांक को देखते हुए , xआधार 10 में एक स्वयं संख्या और एक गलत मूल्य होने पर एक सत्य मान का उत्पादन होता है। सत्य और गलत मूल्यों के स्पष्टीकरण के लिए, विषय पर इस मेटा पोस्ट को देखें ।

आप एक पूर्ण कार्यक्रम या फ़ंक्शन लिख सकते हैं, और इनपुट और आउटपुट किसी भी सामान्य चैनल पर प्रदान किया जा सकता है। मानक खामियां निश्चित रूप से प्रतिबंधित हैं।

यह कोड-गोल्फ है , इसलिए आपका उत्तर (बाइट्स में) जितना बेहतर होगा उतना कम होगा!

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

Truthy:

1
3
5
7
9
20
31
86
154
525

Falsey:

2
4
6
8
10
15
21
50
100
500

सैंडबॉक्स लिंक

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

# Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

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

code-golf  math  decision-problem 
— सोक
स्रोत
ऐसा लगता है कि वैध आउटपुट के बारे में कुछ चर्चा / असहमति है, इसलिए मुझे लगता है कि जो मैं इरादा कर रहा था उस पर मैं स्पष्ट नहीं हूं। मैंने एक वाक्य जोड़ा है जो इस मेटा पोस्ट का जिक्र करते हुए उम्मीद से स्पष्ट कर देना चाहिए । क्षमा करें, यदि मैंने इस बारे में कोई भ्रम पैदा किया है!
— सोक
अधिक भ्रम का कारण नहीं है, लेकिन मुझे लगता है यह चर्चा प्रासंगिक है कि कुछ भ्रम क्यों था। कृपया भविष्य की चुनौतियों का सामना करते समय इस पर विचार करें, क्योंकि ऐसी भाषाओं में पोस्ट करना मुश्किल हो सकता है जिनके पास पुरानी सहमति का उपयोग करने पर / नहीं होती है।
— FryAmTheEggman
@FryAmTheEggman मुझे एहसास नहीं था कि आम सहमति स्थानांतरित हो गई थी, मुझे अब एक ख़ालीपन जैसा महसूस हो रहा है: / फिर भी, मैंने पहले ही एक स्पष्टीकरण अब जोड़ दिया है, इसे फिर से बदलना गलत है। मैं इसे अगली चुनौती के लिए ध्यान में रखूंगा। धन्यवाद
— सोक
2
मैं किसी भी तरह की संख्या नहीं हूँ! मैं एक आजाद आदमी हूँ!
— डेविड रिचेर्बी
1
@DavidRicherby * आपके बाद सफेद गेंद भेजता है *
— सोक

जवाबों:

7

जावा (JDK 10) , 84 बाइट्स

i->{for(int n=i;i-->1;)i|=((""+i).chars().map(x->x-48).sum()+i^n)-1>>-1;return~i<0;}

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

व्याख्या

i->{                                    // IntPredicate
  for(int n=i;i-->1;)                   //  for each number below n
    i|=(                                //   keep the sign of
      (""+i).chars().map(x->x-48).sum() //    sum of digits
      +i                                //    plus the number
      ^n                                //    xor n (hoping for a zero)
     )-1>>-1;                           //    changing that into a negative number if equals to zero
  return~i<0;                           //  return i>=0
}

क्रेडिट

— ओलिवियर ग्रेजायर
स्रोत
1
-1 बाइट:n->{int i=n,r=0;for(;i-->0;)r=(""+i).chars().map(x->x-48).sum()+i==n?1:r;return r<1;}
— केविन क्रूजेसेन
2
84 बाइट्स:i->{for(int n=i;i-->1;)i|=((""+i).chars().map(x->x-48).sum()+i^n)-1>>-1;return~i<0;}
— नेवय
5

ब्रेकीलॉग , 12 बाइट्स

¬{⟦∋Iẹ+;I+?}

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

व्याख्या

¬{         }    Fails if succeeds, suceeds if fails:
  ⟦∋I             I ∈ [0, ..., Input]
    Iẹ+           The sum of the elements (i.e. digits) of I...
       ;I+?       ... with I itself results in the Input
— Fatalize
स्रोत
1
है false.एक तरीका है कि किसी भी उद्देश्य विधि द्वारा एक truthy मूल्य true.नहीं है? मैं एक के लिए ऐसा नहीं सोचता, और ऐसा लगता है कि मेटा सर्वसम्मति
— सोक
1
@ Sok मैंने आपकी चिंताओं को स्वीकार करने के लिए 3 निर्बाध बाइट्स जोड़े।
— घातक
4

ऑक्टेव , 49 47 44 बाइट्स

@(x)arrayfun(@(k)k+sum(num2str(k)-48)-x,1:x)

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

स्पष्टीकरण:

एक सीमा पर ऑपरेशन करने की कोशिश करना बोझिल और लंबा है, क्योंकि num2strइनपुट संख्या से अधिक होने पर विभाजक के रूप में रिक्त स्थान के साथ एक स्ट्रिंग लौटाता है। इसलिए घटाना 48 इसलिए कुछ देना होगा: 1 -16 -16 2 -16 -16 3 -16 -16 4एक इनपुट रेंज 1 के लिए ... 4 । सभी से छुटकारा पाने के लिए -16बहुत सारे बाइट्स मिलते हैं।

इसलिए, हम इसका उपयोग लूप के साथ करेंगे arrayfun। प्रत्येक संख्या के लिए k = 1 .. x , जहां x इनपुट है, हम जोड़ते हैं kऔर उसका अंक योग, और घटाते हैं x। यह कश्मीर में प्रत्येक संख्या के लिए उस ऑपरेशन के परिणाम के साथ एक सरणी लौटाएगा । यदि सरणी में कोई भी संख्या शून्य है, तो संख्या स्वयं संख्या नहीं है।

इनपुट्स के लिए 20और 21, आउटपुट हैं:

20:  -18, -16, -14, -12, -10, -8, -6, -4, -2, -9, -7, -5, -3, -1, 1, 3, 5, 7, 9, 2
21:  -19, -17, -15, -13, -11, -9, -7, -5, -3, -10, -8, -6, -4, -2, 0, 2, 4, 6, 8, 1, 3

इनपुट के लिए केवल गैर-शून्य तत्व हैं 20, और इनपुट के लिए कम से कम एक गैर-शून्य तत्व हैं 21। इसका मतलब है कि 20एक आत्म संख्या है, और 21नहीं है।

ऑक्टेव कम से कम एक शून्य के साथ एक सरणी को गलत मानता है, जैसा कि टीआईओ-लिंक में देखा जा सकता है।

— स्टीवी ग्रिफिन
स्रोत
4

MATL , 11 बाइट्स

t:tFYA!Xs+-

आउटपुट एक गैर-रिक्त सरणी है, जो सत्य है यदि इसकी सभी प्रविष्टियाँ गैर-शून्य हैं, और गलत है यदि इसमें एक या अधिक शून्य हैं।

इसे ऑनलाइन आज़माएं! या सत्यता / मिथ्या परीक्षा सहित सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

n = 10उदाहरण के रूप में इनपुट पर विचार करें ।

t       % Implicit input, n. Duplicate
        % STACK: 10, 10
:       % Range
        % STACK: 10, [1 2 3 4 5 6 7 8 9 10]
t       % Duplicate
        % STACK: 10, [1 2 3 4 5 6 7 8 9 10], [1 2 3 4 5 6 7 8 9 10]
FYA!    % Convert to base 10 digits and transpose
        % STACK: 10, [1 2 3 4 5 6 7 8 9 10], [0 0 0 0 0 0 0 0 0 1
                                              1 2 3 4 5 6 7 8 9 0]
Xs      % Sum of each column
        % STACK: 10, [1 2 3 4 5 6 7 8 9 10], [1 2 3 4 5 6 7 8 9 1]
+       % Add, element-wise
        % STACK: 10, [2 4 6 8 10 12 14 16 18 11]
-       % Subtract, element-wise
        % STACK: [8 6 4 2 0 -2 -4 -6 -8 -1]
        % Implicit display
— लुइस मेंडो
स्रोत
3

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

ḟDS+Ɗ€

इनपुट n के लिए , यह रिटर्न [n] यदि n एक स्व संख्या है, [] यदि नहीं।

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

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

ḟDS+Ɗ€  Main link. Argument: n

     €  Call the link to the left for each k in [1, ..., n].
    Ɗ     Drei; combine the three links to the left into a monadic chain.
 D          Decimal; map k to the array of its digits in base 10.
  S         Take the sum.
   +        Add k to the sum of the k's digits.
ḟ       Filterfalse; promote n to [n], then remove all elements that appear in the
        array to the right.
        This returns [n] if the array doesn't contain n, [] if it does.
— डेनिस
स्रोत
क्या एन्कोडिंग इन छह अक्षरों को केवल छह बाइट्स में पैक करता है?
— WGroleau
1
जेली एक कस्टम कोड पेज का उपयोग करता है ।
— डेनिस
3

जे , 28, 24, 22 21 बाइट्स

-1 बाइट का धन्यवाद कोनोर ओ ब्रायन को

-2 नग धन्यवाद के लिए धन्यवाद

$@-.(+1#.,.&.":)"+@i.

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

स्पष्टीकरण:

i. एक सूची 0 .. n-1

( )"+ सूची में प्रत्येक आइटम के लिए

.,.&.": इसे अंकों की सूची में परिवर्तित करें,

1# उनकी राशि खोजें

+ और इसे आइटम में जोड़ें

$@-. सूची को तर्क से अलग करें और आकार ढूंढें

— गैलेन इवानोव
स्रोत
1
मुझे पता है यह एक पुरानी पोस्ट है, लेकिन "0 i.हो सकता है "+i.(-1 बाइट)।
— कॉनर ओ'ब्रायन
1
@ ConorO'Brien धन्यवाद! मुझे लगता है कि मैं इस तरह के गोल्फ को वापस नहीं जानता था; अब मैं इसका उपयोग करता हूं (जब मुझे याद है :))
— गैलेन इवानोव
1
-.@e.->$@-.
— ngn
@ngn धन्यवाद, वास्तव में अच्छा है!
— गैलन इवानोव
1
@GalenIvanov भी [:( )"+i.->( )"+@i.
— ngn
2

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

lambda x:[i for i in range(x)if i+sum([int(j)for j in`i`])==x]==[]

EDIT: -4 @ user56656 को धन्यवाद

— sonrad10
स्रोत
1
python2 में आप 4 बाइट्स को बचाने के `i`बजाय उपयोग कर सकते हैं str(i)।
— गेहूं जादूगर
@ user56656 धन्यवाद, मुझे इसके बारे में पता नहीं था
— sonrad10
1
आप []sum
— श्री एक्सकोडर
lambda x:[i for i in range(x)if i+sum(map(int,`i`))==x]==[]
— बी। ईकल्स
lambda x:all(i+sum(map(int,`i`))-x for i in range(x))
— बी। ईकल्स
2

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

!/m+sjdT

परीक्षण सूट।

यदि स्वैपिंग सत्य / मिथ्या मूल्यों की अनुमति है, तो हम ड्रॉप कर सकते हैं !और इसके बजाय 7 बाइट्स प्राप्त कर सकते हैं । में से एक सोक के सुझाव मुझे गोल्फ 2 बाइट्स में मदद की।

व्याख्या

/ / एम + sjdT - पूर्ण कार्यक्रम। एसटीडीआईएन से एक इनपुट क्यू लेता है, या तो ट्रू या गलत आउटपुट देता है।
  m - एक चर d के साथ रेंज [0 ... Q) पर नक्शा।
     jdT - d को आधार 10 में बदलें।
    s - सम।
   + - और योग को d से जोड़ें।
 / - परिणाम में Q की घटनाओं को गिनें।
! - नेगेट। परिणाम को लागू करें।
— मिस्टर एक्सकोडर
स्रोत
मेरे पास था .AmnQ+dsjdT, मुझे इसके बारे में कोई पता नहीं था /। मैंने लंबे समय से ठीक से पाइथ का उपयोग नहीं किया है ऐसा लगता है! +1
— सोक
@ सोक /मूल रूप से एक सूची में एक तत्व की घटनाओं को गिनता है। मैं भी उपयोग कर सकता हूं }, जो परीक्षण करता है कि क्या कोई वस्तु किसी सूची में दिखाई देती है, लेकिन मुझे लगता है कि यह एक ही बाइट गिनती है।
— श्री Xcoder
मुझे लगता Sहै कि आवश्यक नहीं है - इनपुट एक सकारात्मक पूर्णांक होगा, इसलिए 0मैपिंग सूची में समस्या नहीं होगी? कम से कम, यह दिए गए परीक्षण मामलों के लिए काम करने लगता है।
— सोक
@ ग्रेट, आप सही कह रहे हैं! मैं इस के लिए एक और बाइट धन्यवाद मुंडा।
— मिस्टर एक्सकोडर
कैसे +sjdTजोड़ता sjdTहै d? मैंने कभी ऐसा कुछ नहीं देखा
— आर.के.
2

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

{!grep $_,map {$_+[+] .comb},^$_}

कोशिश करके देखो!

अंतर्निहित एकल पैरामीटर के साथ एक नंगे ब्लॉक, इस प्रकार कहा जाता है:

say {!grep $_,map {$_+[+] .comb},^$_}(500);
> False
say {!grep $_,map {$_+[+] .comb},^$_}(525);
> True

चूंकि n + digits(n) >= n, हम अपने क्वेरी मान तक सभी संख्याओं के लिए कोलम्बियाई संख्या की गणना कर सकते हैं और देख सकते हैं कि उनमें से कोई भी मेल खाता है या नहीं। तो यह दिए गए इनपुट के लिए कोलम्बियाई संख्या की गणना करता है:

{$_ + [+] .comb}

जिसे हम अपने लक्ष्य तक सभी मूल्यों पर लागू करते हैं:

(^$_).map({$_+[+] .comb})

लेकिन हम केवल इस बात की परवाह करते हैं कि उनमें से कोई भी मेल खाता है, न कि वे मूल्य क्या हैं, इसलिए @nwellenhof द्वारा बताया गया है, हम इसे रद्द कर सकते हैं:

grep $_, map {$_+[+] .comb}, ^$_

बाकी बस एक ब्लॉक में बूल और लपेटने के लिए ज़बरदस्ती है।

39 बाइट्स

{!((^$_).map({$_+[+] .comb}).any==$_)}

TIO परीक्षण लिंक @Emigna द्वारा प्रदान किया गया

@nwellenhof ने बताया कि grep के उपयोग से 6 बाइट बचेंगे!

— फिल एच
स्रोत
1
शांत समाधान! आप परीक्षण उद्देश्यों के लिए एक TIO लिंक जोड़ सकते हैं ।
— एमिग्ना
1
{!grep $_,map {$_+[+] .comb},^$_}33 बाइट्स के लिए।
— nwellnhof
— जो किंग
2

जाप -d! , 6 बाइट्स

N¥U+ìx

कोशिश करो

मूल, 8 बाइट्स

0सच्चाई के लिए या फ़ॉसी के लिए इनपुट नंबर देता है । यदि जावास्क्रिप्ट में केवल खाली सरणी गलत थी, तो यह 7 बाइट्स हो सकती है।

ÂNkUÇ+ìx

कोशिश करो

व्याख्या

             :Implicit input of integer U
   UÇ        :Generate the range [0,U) and pass each Z through a function
      ì      :  Digits of Z
       x     :  Reduce by addition
     +       :  Add to Z
  k          :Remove the elements in that array
 N           :From the array of inputs
            :Bitwise NOT NOT (~~), casts an empty array to 0 or a single element array to an integer

विकल्प

Ç+ìxÃe¦U

कोशिश करो

             :Implicit input of integer U
Ç            :Generate the range [0,U) and pass each Z through a function
  ì          :  Digits of Z
   x         :  Reduce by addition
 +           :  Add to Z
    Ã        :End function
     e       :Every
      ¦U     :  Does not equal U
— झबरा
स्रोत
1

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

.+
*
Lv`_+
_+
$&$.&
^_+
$&¶$&
\d
*
Cms`^(_+)\b.*¶\1\b
0

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

.+
*

इनपुट xको यूनीरी में बदलें ।

Lv`_+

xनीचे से एक सीमा बनाएँ 1।

_+
$&$.&

प्रत्येक के दशमलव मूल्य nको उसके एकात्मक मूल्य से प्रत्यय दें ।

^_+
$&¶$&

की प्रति उपलब्ध करावें x।

\d
*

प्रत्येक दशमलव अंक nको एकरी में बदलें , इस प्रकार अंकों को मौजूदा कॉपी में जोड़ दें n।

Cms`^(_+)\b.*¶\1\b

जाँच करें कि क्या xकिसी भी परिणाम में प्रकट होता है।

0

परिणाम उलटा।

— नील
स्रोत
1

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

.+
*

$.`¶$`
\d
*
D`
.\z

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

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

व्याख्या

.+
*

इनपुट को unary में बदलें, unary digit के _रूप में उपयोग करते हुए ।


$.`¶$`

स्ट्रिंग में प्रत्येक स्थिति में (यानी शुरुआत, अंत, और हर जोड़ी पात्रों के बीच), सम्मिलित करें: $.`उपसर्ग की लंबाई (या मैच की शून्य-अनुक्रमित स्थिति) ,, एक लाइनफीड, $`(उपसर्ग ही) (यानी शून्य-अनुक्रमित स्थिति का एक एकीकृत प्रतिनिधित्व)। उदाहरण के लिए यदि इनपुट था 3और हमारे पास एकात्मक प्रतिनिधित्व होगा ___, तो इसका परिणाम यह होगा:

0
_1
__2
___3
___

दूसरे शब्दों में, हम प्रत्येक संख्या के लिए 0 से इनपुट (समावेशी) के लिए एक पंक्ति प्राप्त करते हैं, जो उस संख्या का एक और एक दशमलव प्रतिनिधित्व दोनों रखता है।

\d
*

हम प्रत्येक अंक को एकात्मक में परिवर्तित करते हैं, जो प्रत्येक पंक्ति पर अंक योग को प्रभावी ढंग से गणना करता है और इसे स्वयं संख्या में जोड़ता है (सभी एकात्मक में)।

D`

डेडुप्लिकेट लाइनें। यह वास्तव में डुप्लिकेट लाइनों को नष्ट नहीं करता है, लेकिन बस उन्हें खाली लाइनों को साफ करता है। इसलिए यदि कोई संख्या 0 से इनपुट के साथ-साथ उसकी अंक राशि इनपुट के बराबर है, तो अंतिम पंक्ति साफ हो जाएगी। अन्यथा, अंतिम पंक्ति जगह पर बनी हुई है।

.\z

जांचें कि क्या अंतिम पंक्ति में अभी भी एक चरित्र है। हम उपयोग नहीं कर सकते $, क्योंकि यह भी एक अनुगामी लाइनफीड के सामने मेल खाता है (जो कि ठीक उसी जगह है जहां हम देखना नहीं चाहते हैं)।

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

बैश + जीएनयू कोरुटिल्स, 91 बाइट्स

सत्य या मिथ्या लौटाता है।

e=1;for((i=1;i<=$1;i++));{ [ $(bc<<<`grep -o . <<<$i|tr '\n' +`$i) -eq $1 ]&&e=0; };exit $e
— rexkogitans
स्रोत
1

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

x->(1..x).all{v->"$v".sumBy{it.toInt()-48}+v!=x}

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

स्पष्टीकरण:

(1..x)      // Range of numbers from 1 to x
.all{v->    // Function expression that checks if ALL values evaluate to tru
"$v"        // Convert the value into a string
.sumBy{it.toInt()-48} // For each character, get the ASCII char value, subtract 48 in order to get it back to the numerical value, and then sum it up
+v          // Add the original number
!=x}        // Ensure that it does not equal the input
— Makotosan
स्रोत
1

++ , 27 बाइट्स जोड़ें

D,g,@,BDB+A+BK=
L,RbUABkºg!

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

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

D,g,@,		; Create a monadic function 'g'
		; Example argument:		[15]
	BD	; Digits;		STACK = [[1 5]]
	B+	; Sum;			STACK = [6]
	A+	; Add argument;		STACK = [21]
	BK=	; Equals input;		STACK = [1]

L,		; Create a lambda function
		; Example argument:		[21]
	RbUABk	; Push range;		STACK = [1 2 3 ... 19 20 21]
	ºg	; Any true from 'g';	STACK = [1]
	!	; Logical NOT;		STACK = [0]
— केर्ड सिक्काहिरिंग
स्रोत
1

स्टैक्स , 8 बाइट्स

Å8avj╒Éπ

इसे चलाएं और डीबग करें

व्याख्या

ASCII समकक्ष:

{cE+|+x=f!
{       f     Filter [1..input] with block
 cE           Decimal digits of current value
   +|+        Sum of digits and the current value
      x=      Equals input
         !    Logical not, maps empty array to 1 and non-empty array to 0

fcE+|+x=एक स्टैक्स प्रोग्राम है जो सभी नंबरों को आउटपुट करता है जिनके अंकों का योग खुद इनपुट के बराबर होता है। उदाहरण के 101लिए आउटपुट होगा 91और100 प्रत्येक एक अलग लाइन पर होगा।

इसे चलाएं और डीबग करें

— वीजुन झोउ
स्रोत
1

Pyt , 7 बाइट्स

ĐřĐŚ+∈¬

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

यदि स्वैपिंग सत्य / मिथ्या मूल्यों की अनुमति है, तो ¬ अंत में 6 बाइट्स के लिए छोड़ दिया जा सकता है।

स्पष्टीकरण:

        Implicit input
Đ       Duplicate input
ř       Get [1,2,...,input]
Đ       Duplicate the top of the stack
Ś       Get the sum of the digits of each element in the array
+       Add the top two items on the stack element-wise
∈       Is the input in the list?
¬       Negate the top of the stack
        Implicit print
— mudkip201
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.