क्या मैं अपने अंकों के योग को दोगुना कर सकता हूं?

40

एक को देखते हुए सकारात्मक पूर्णांक इनपुट के रूप में, अपने काम के लिए एक truthy मूल्य अगर संख्या है उत्पादन के लिए है विभाज्य अपने अंकों का योग के दोहरे से, और एक falsy मूल्य अन्यथा ( OEIS A134516 )। दूसरे शब्दों में:

(sum_of_digits)*2 | number

  • सत्य और झूठे मामलों के लिए सत्य / झूठे मूल्यों के बजाय, आप सच / झूठे मामले के लिए मूल्यों के किसी भी सीमित सेट को निर्दिष्ट कर सकते हैं, और उनके अन्य मूल्यों को पूरक कर सकते हैं। एक साधारण उदाहरण के लिए, आप 0सच्चे मामले के लिए और अन्य सभी नंबरों के लिए झूठे मामले (या यदि आप चाहें तो इसके विपरीत) का उपयोग कर सकते हैं।

  • मानक इनपुट और आउटपुट नियम लागू होते हैं। डिफ़ॉल्ट लूपोल्स भी लागू होते हैं।

  • आप एक पूर्णांक के रूप में या उस पूर्णांक के स्ट्रिंग प्रतिनिधित्व के रूप में इनपुट ले सकते हैं।

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

  • मैं PPCG के लिए नया हूं, इसलिए मैं चाहूंगा कि यदि संभव हो तो आप एक स्पष्टीकरण पोस्ट करें।

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

इनपुट - आउटपुट - (कारण)

80 - सत्य - (16 भाग 80)
100 - सत्य - (2 विभाजित 100)
60 - सत्य - (12 भाग 60)
18 - सत्य - (18 भाग 18)
12 - सत्य - (6 भाग 12)

4 - मिथ्या - (4 का विभाजन नहीं होता है)
8 - मिथ्या - (16 का विभाजन नहीं होता है 8)
16 - मिथ्या - (14 को विभाजित नहीं करता है 16)
21 - मिथ्या - (6 का विभाजन 21 नहीं होता)
78 - झूठे - (३० का विभाजन नहीं होता है -)
११० - मिथ्या - (११० नहीं होता है)
१११ - मिथ्या - (१११ विभाजन नहीं करता है)
३ ९ ० - मिथ्या - (२४० में विभाजित नहीं है ३६०)
code-golf  number  number-theory  decision-problem  division 
अच्छी चुनौती, पीपीसीजी में आपका स्वागत है!
— स्किड्सदेव
@ माय्यूब धन्यवाद, यह मेरी दूसरी चुनौती है, लेकिन पहले वाला बंद हो गया: P
क्या हमें इंटेगर की सूची के रूप में अंक लेने की अनुमति है?
— हेनरी
4
1
वास्तव में, "सत्य और झूठे मामलों के लिए सत्य / झूठे मूल्यों के बजाय, आप सच्चे मामले के लिए मूल्यों के किसी भी सीमित सेट को निर्दिष्ट कर सकते हैं, और झूठे लोगों के लिए उनके पूरक। एक सरल उदाहरण के लिए, आप उपयोग कर सकते हैं। 0 सच्चे मामले के लिए और झूठे मामले के लिए अन्य सभी संख्याएं (या इसके विपरीत, यदि आपको पसंद है) "एक दूसरे के विपरीत (विशेष रूप से," परिमित "और" या इसके विपरीत ") लगते हैं।
— ग्रेग मार्टिन

जवाबों:

7

नीम , 3 बाइट्स

𝐬ᚫ𝕞

स्पष्टीकरण:

𝐬      Implicitly convert to int array and sum the digits
 ᚫ     Double
  𝕞   Is it a divisor of the input?

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

विस्तृत संस्करण

— Okx
स्रोत
उम्म ... आपको जांचना चाहिए कि इनपुट अंकों के दोगुने से अधिक है या नहीं, इसके विपरीत।
— निकोलस
@EriktheOutgolfer क्या मतलब है? मैं जाँचता हूँ कि क्या इनपुट अंकों के योग से कई गुना अधिक है। शायद मैंने इसे सही तरीके से नहीं समझाया।
— ओकेक्स
4
नीम को भी गोल्फर की जरूरत है - जब सबमिशन बहुत लंबा हो जाता है, तो मेरा ब्राउज़र पिछड़ने लगता है।
— १२:१२ पर फलों के जूल
1
@ चैलेंजर 5 मैं गंभीरता से गोल्फ की कमी के लिए माफी माँगता हूँ। मैं अगली बार फिर कोशिश करूंगा। फिर, इसके बारे में क्षमा करें।
— ओकेक्स
@ ओएक्सएक्स और मैं ईमानदारी से माफी मांगता हूं कि वह एक नीम उत्तर खोजने के लिए बहुत आलसी है जो मैं जिस बारे में बात कर रहा था उसका बेहतर प्रदर्शन था।
— फल
16

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

एक स्ट्रिंग के रूप में इनपुट लेता है। सत्य के लिए शून्य और मिथ्या के लिए गैर शून्य।

n=>n%eval([...n+n].join`+`)

टिप्पणी की गई

n => n % eval([...n + n].join`+`)
n =>                                   // take input string n  -> e.g. "80"
                  n + n                // double the input     -> "8080"
              [...     ]               // split                -> ["8", "0", "8", "0"]
                        .join`+`       // join with '+'        -> "8+0+8+0"
         eval(                  )      // evaluate as JS       -> 16
     n %                               // compute n % result   -> 80 % 16 -> 0

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

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

— Arnauld
स्रोत
मैंने पहले कभी नहीं देखा [... x] को विभाजित करने की विधि, क्या इसके लिए कोई नाम है?
— जैकब पर्शी
— Arnauld
7

सी #, 46 बाइट्स

using System.Linq;n=>n%(n+"").Sum(c=>c-48)*2<1

पूर्ण / प्रारूपित संस्करण:

using System;
using System.Linq;

class P
{
    static void Main()
    {
        Func<int, bool> f = n => n % (n + "").Sum(c => c - 48) * 2 < 1;

        Console.WriteLine(f(80));
        Console.WriteLine(f(100));
        Console.WriteLine(f(60));

        Console.WriteLine();

        Console.WriteLine(f(16));
        Console.WriteLine(f(78));
        Console.WriteLine(f(390));

        Console.ReadLine();
    }
}
— TheLethalCoder
स्रोत
4

रेटिना , 38 27 बाइट्स

-11 बाइट्स और @MartinEnder के लिए कोड धन्यवाद के साथ एक त्रुटि तय की

$
$_¶$_
.+$|.
$*
^(.+)¶\1+$

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

प्रिंट 1 यदि विभाज्य, 0 अन्यथा

स्पष्टीकरण (आशा है कि मुझे यह अधिकार मिला है)

$
$_¶$_

संपूर्ण इनपुट, साथ ही एक नई पंक्ति, और इनपुट को फिर से लागू करता है

.+$|.
$*

प्रत्येक मैच को एकरी में कनवर्ट करता है (या तो पूरी दूसरी पंक्ति जो मूल इनपुट है, या पहली पंक्ति में प्रत्येक अंक है)

^(.+)¶\1+$

जांचें कि क्या पहली पंक्ति (दोगुनी अंक राशि) दूसरी पंक्ति की विभाजक है

— PunPun1000
स्रोत
4

MATL , 7 बाइट्स

tV!UsE\

आउटपुट 0यदि विभाज्य, सकारात्मक पूर्णांक अन्यथा। विशेष रूप से, यह संख्या को उसके अंकों के दोगुने से विभाजित करने के शेष को आउटपुट करता है।

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

व्याख्या

t   % Implicit input. Duplicate
V!U % Convert to string, transpose, convert to number: gives column vector of digits
s   % Sum
E   % Times 2
\   % Modulus. Implicit display
— लुइस मेंडो
स्रोत
4

05AB1E , 5 4 बाइट्स

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

SO·Ö

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

आप सत्य के लिए 0 पाने के लिए अंतिम truth को भी हटा सकते हैं और केवल 3 बाइट्स के परिणामस्वरूप गलत तरीके से कुछ और प्राप्त कर सकते हैं, लेकिन मेरे लिए यह केवल उचित रूप से फिट नहीं लगता है।

व्याख्या

SO·Ö
SO    # Separate the digits and sum them
  ·   # Multiply the result by two
   Ö  # Is the input divisible by the result?
— Datboi
स्रोत
आप की जगह 4 बाइट के लिए यह गोल्फ कर सकते हैं %_के साथ Ö।
— ओकेक्स
4

x86-64 मशीन कोड, 24 बाइट्स

6A 0A 5E 31 C9 89 F8 99 F7 F6 01 D1 85 C0 75 F7 8D 04 09 99 F7 F7 92 C3

उपरोक्त कोड 64-बिट x86 मशीन कोड में एक फ़ंक्शन को परिभाषित करता है जो यह निर्धारित करता है कि इनपुट मान उसके अंकों के योग से दोगुना है या नहीं। फ़ंक्शन सिस्टम V AMD64 कॉलिंग कन्वेंशन के अनुरूप है, ताकि यह लगभग किसी भी भाषा से कॉल करने योग्य हो, जैसे कि यह एक सी फ़ंक्शन था।

यह EDIकॉलिंग कन्वेंशन के अनुसार, रजिस्टर के माध्यम से इनपुट के रूप में एकल पैरामीटर लेता है , जो परीक्षण करने के लिए पूर्णांक है। (यह एक सकारात्मक पूर्णांक माना जाता है , जो चुनौती के नियमों के अनुरूप है, और जो CDQनिर्देश हम सही ढंग से काम करने के लिए उपयोग करते हैं , उसके लिए आवश्यक है।)

यह EAXकॉलिंग कन्वेंशन के अनुसार, फिर से, रजिस्टर में अपना परिणाम देता है । परिणाम 0 होगा यदि इनपुट मान उसके अंकों के योग से विभाज्य था , और अन्यथा शून्य नहीं। (मूल रूप से, उलटा बूलियन, बिल्कुल चुनौती के नियमों में दिए गए उदाहरण की तरह।)

इसका सी प्रोटोटाइप होगा:

int DivisibleByDoubleSumOfDigits(int value);

यहाँ असंबद्ध असेंबली भाषा निर्देश दिए गए हैं, प्रत्येक निर्देश के उद्देश्य की संक्षिप्त व्याख्या के साथ एनोटेट किया गया है:

; EDI == input value
DivisibleByDoubleSumOfDigits:
   push 10
   pop  rsi             ; ESI <= 10
   xor  ecx, ecx        ; ECX <= 0
   mov  eax, edi        ; EAX <= EDI (make copy of input)

SumDigits:
   cdq                  ; EDX <= 0
   div  esi             ; EDX:EAX / 10
   add  ecx, edx        ; ECX += remainder (EDX)
   test eax, eax
   jnz  SumDigits       ; loop while EAX != 0

   lea  eax, [rcx+rcx]  ; EAX <= (ECX * 2)
   cdq                  ; EDX <= 0
   div  edi             ; EDX:EAX / input
   xchg edx, eax        ; put remainder (EDX) in EAX
   ret                  ; return, with result in EAX

पहले ब्लॉक में, हम रजिस्टरों के कुछ प्रारंभिक आरंभ करते हैं:

  • PUSH+ POPनिर्देशों का उपयोग धीमी लेकिन संक्षिप्त विधि के रूप में किया जाता है ESI। इसे शुरू करने के लिए 10. यह आवश्यक है क्योंकि DIVx86 पर निर्देश के लिए एक रजिस्टर ऑपरेंड की आवश्यकता होती है। (कोई ऐसा रूप नहीं है, जो तत्काल मान से विभाजित हो, कहते हैं, 10.)
  • XORECXरजिस्टर को खाली करने के लिए एक छोटे और तेज तरीके के रूप में उपयोग किया जाता है । यह रजिस्टर आगामी लूप के अंदर "संचायक" के रूप में काम करेगा।
  • अंत में, इनपुट मूल्य (से EDI) की एक प्रति बनाई जाती है, और इसमें संग्रहीत किया जाता है EAX, जिसे हम लूप के माध्यम से जाने के रूप में देखा जाएगा।

फिर, हम लूपिंग शुरू करते हैं और इनपुट मूल्य में अंकों को जोड़ते हैं। यह x86 DIVइंस्ट्रक्शन पर आधारित है , जो EDX:EAXअपने ऑपरेंड से विभाजित होता है, और भागफल में EAXऔर शेष में रिटर्न करता है EDX। हम यहां क्या करेंगे इनपुट मान को 10 से विभाजित करते हैं, जैसे कि शेष अंतिम स्थान में अंक है (जो हम अपने संचायक रजिस्टर में जोड़ देंगे ECX), और भागफल शेष अंक है।

  • CDQशिक्षा की स्थापना की एक छोटी तरीका है EDX0. यह वास्तव में करने के लिए साइन-फैली में मूल्य EAXके लिए EDX:EAXहै, जो क्या है DIVलाभांश के रूप में उपयोग करता है। हमें वास्तव में यहां साइन-एक्सटेंशन की आवश्यकता नहीं है, क्योंकि इनपुट वैल्यू अहस्ताक्षरित है, लेकिन CDQ1 बाइट है, जैसा कि XORस्पष्ट उपयोग करने के लिए विरोध है EDX, जो 2 बाइट्स होगा।
  • फिर हम DIVआईडीई EDX:EAXद्वारा ESI(10)।
  • शेष ( EDX) संचयकर्ता ( ECX) में जोड़ा जाता है ।
  • EAXरजिस्टर (भागफल) अगर यह 0. के बराबर है तो, हम इसे अंकों के सभी के माध्यम से किया है और हम के माध्यम से आता है तो यह देखने के लिए परीक्षण किया जाता है। यदि नहीं, तो हमारे पास योग करने के लिए अभी भी अधिक अंक हैं, इसलिए हम लूप के शीर्ष पर वापस जाते हैं।

अंत में, लूप समाप्त होने के बाद, हम लागू करते हैं number % ((sum_of_digits)*2):

  • LEAअनुदेश एक छोटी तरीके के रूप में प्रयोग किया जाता है गुणा करने के लिए ECX2 से (या, समतुल्य रूप, जोड़ने ECX(इस मामले में खुद के लिए), और परिणाम की दुकान एक अलग रजिस्टर में EAX)।

    (हम भी कर सकते थे add ecx, ecx+ xchg ecx, eax, दोनों 3 बाइट्स हैं, लेकिन LEAनिर्देश तेज और अधिक विशिष्ट है।)

  • फिर, हम CDQफिर से विभाजन की तैयारी करते हैं। क्योंकि EAXसकारात्मक होगा (यानी, अहस्ताक्षरित), इस पर EDXपहले की तरह ही शून्यकरण का प्रभाव है ।
  • अगला विभाजन है, इस बार EDX:EAXइनपुट मान से विभाजित (एक अनमोल कॉपी जिसमें अभी भी रहता है EDI)। यह मोडुलो के बराबर है, जिसमें शेष है EDX। (भागफल भी डाला गया है EAX, लेकिन हमें इसकी आवश्यकता नहीं है।)
  • अंत में, हम XCHG(विनिमय) की सामग्री EAXऔर EDX। आम तौर पर, आप यहां करेंगे MOV, लेकिन XCHGकेवल 1 बाइट (यद्यपि धीमी) है। क्योंकि EDXविभाजन के बाद शेष रहता है, यह 0 होगा यदि मान समान रूप से विभाज्य या गैर-शून्य था अन्यथा। इस प्रकार, जब हम RETकलश करते हैं, EAX(परिणाम) 0 है यदि इनपुट मान को उसके अंकों के योग से दोगुना या गैर-शून्य से अन्यथा विभाजित किया गया था।

उम्मीद है कि स्पष्टीकरण के लिए पर्याप्त है।
यह सबसे छोटी प्रविष्टि नहीं है, लेकिन हे, ऐसा लग रहा है कि यह लगभग सभी गैर-गोल्फ भाषाओं में धड़कता है! :-)

— कोडी ग्रे
स्रोत
3

जाप , 7 4 बाइट्स

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

%²¬x

झसे आज़माओ

व्याख्या

स्ट्रिंग का निहित इनपुट U।
"390"

²

Uदो बार दोहराएं ।
"390390"

¬

अलग-अलग वर्णों की सरणी में विभाजित करें।
["3","9","0","3","9","0"]

x

संक्षेप में कम करें, प्रक्रिया में प्रत्येक वर्ण को पूर्णांक में स्वचालित रूप से कास्टिंग करें।
24

%

Uपरिणाम से विभाजन का शेष भाग प्राप्त करें , स्वचालित रूप Uसे प्रक्रिया में पूर्णांक तक कास्टिंग । परिणामी पूर्णांक का उत्पादन आउटपुट।
6 (=false)

— झबरा
स्रोत
2
आपके स्पष्टीकरण आमतौर पर बहुत सारे ऊर्ध्वाधर स्थान का उपयोग करते हैं, जो मुझे लगता है कि इसकी आवश्यकता नहीं है। किसी भी तरह से, यह आपका जवाब है।
— ओकेक्स
@Okx; मुझे नहीं पता कि "सामान्य" यह कैसे हो सकता है जब मैं केवल कुछ दिनों पहले इस प्रारूप में स्विच करता हूं।
— झबरा
4
मुझे स्पष्टीकरण प्रारूप पसंद आया। पालन ​​करना आसान था, विशेष रूप से इस समस्या के लिए, क्योंकि यह एक रेखीय कमी थी और गणित समस्या की तरह पृष्ठ को नीचे ले गई। केवल मेरे दो सेंट्स।
— हेनरी
3
यह स्पष्टीकरण प्रारूप सामान्य प्रारूप की तुलना में बहुत बेहतर है, खासकर उन लोगों के लिए जो भाषाओं से परिचित नहीं हैं। मेरी इच्छा है कि इन गोल्फिंग भाषाओं का उपयोग करने वाले अन्य गोल्फर भी ऐसा करेंगे।
— 14:
3

C89, 55 53 बाइट्स

(Steadybox के लिए धन्यवाद!

s,t;f(x){for(t=x,s=0;t;t/=10)s+=t%10;return x%(s*2);}

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

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

Ungolfed:

/* int */ s, t;
/*int */ f(/* int */ x)
{
    for (t = x, s = 0; t /* != 0 */; t /= 10)
        s += (t % 10);
    return x % (s * 2);
}

जैसा कि आप देख सकते हैं, यह C89 के अंतर्निहित-अंतर नियमों का लाभ उठाता है। वैश्विक चर sऔर tस्पष्ट रूप से intएस के रूप में घोषित किए जाते हैं । (वे भी अनुमानित रूप से 0 से आरंभिक हैं क्योंकि वे ग्लोबल्स हैं, लेकिन हम इसका लाभ नहीं उठा सकते हैं यदि हम चाहते हैं कि फ़ंक्शन कई बार कॉल करने योग्य हो।)

इसी तरह, फंक्शन, fएक एकल पैरामीटर लेता है, x,जो कि एक है int, और यह एक रिटर्न देता है int।

फ़ंक्शन के अंदर कोड काफी सीधा है, हालांकि forआप वाक्यविन्यास से अपरिचित हैं तो लूप अजीब लगेगा। मूल रूप से, forC में एक लूप हैडर में तीन भाग होते हैं:

for (initialization; loop condition; increment)

"इनिशियलाइज़ेशन" सेक्शन में, हमने अपने ग्लोबल वैरिएबल्स को इनिशियलाइज़ किया है। लूप में प्रवेश करने से पहले यह एक बार चलेगा।

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

"वेतन वृद्धि" अनुभाग में, हमने मूल रूप से मनमाना कोड डाला है, क्योंकि यह प्रत्येक लूप के अंत में चलेगा।

लूप का बड़ा उद्देश्य इनपुट मूल्य में प्रत्येक अंक के माध्यम से पुनरावृति करना है, उन्हें जोड़ना है s। अंत में, लूप समाप्त होने के बाद, sदोगुना हो जाता है और xयह देखने के लिए मोडुलो लिया जाता है कि क्या यह समान रूप से विभाज्य है। (यहां तर्क का एक बेहतर, अधिक विस्तृत विवरण मेरे अन्य उत्तर में पाया जा सकता है , जिस पर यह आधारित है।)

मानव-पठनीय संस्करण:

int f(int x)
{
    int temp = x;
    int sum  = 0;
    while (temp > 0)
    {
        sum  += temp % 10;
        temp /= 10;
    }
    return x % (sum * 2);
}
— कोडी ग्रे
स्रोत
आप दो बाइट्स बचा सकते हैं, अगर आप लूप की स्थिति के tबजायt>0 उपयोग करते हैं ।
— स्टीडायबॉक्स
आह, बिल्कुल! अच्छा पकड़, @Steadybox। निश्चित नहीं है कि मैं कैसे चूक गया, क्योंकि 0 के खिलाफ परीक्षण वास्तव में मेरा asm कार्यान्वयन क्या था, जिस पर यह उत्तर भारी आधारित था।
— कोडी ग्रे
— प्रिंसपोल्का २ ''
2

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

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

lambda n:n%sum(map(int,`n`)*2)<1

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

— OVS
स्रोत
6
प्रश्न में प्रदान किए गए "स्पष्ट रूप से भिन्न" के उदाहरण के आधार पर, मेरा मानना ​​है कि आप इसे हटा सकते हैं <1।
— गेहूं जादूगर
2

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

(2Tr@IntegerDigits@#)∣#&

कोई सुराग क्यों ∣गुणन की तुलना में अधिक पूर्वता है ...

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

PHP , 41 बाइट्स

यदि विभाज्य, सकारात्मक पूर्णांक अन्यथा शून्य प्रिंट करता है। 

<?=$argn%(2*array_sum(str_split($argn)));

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

— जार्ग हुल्सरमन
स्रोत
आप हेडर ब्लॉक में असाइनमेंट डालते हैं। साथ ही आप का उपयोग कर सकते $a=10हैं, लेकिन आपको लगता है कि गिनती करने के लिए अपने बाइट गिनती की ओर भूल गया
— aross
@ मुझे अपनी बाइट गिनती की ओर इनपुट क्यों गिनना चाहिए। (इस मामले में) या विकल्प के $argnसाथ उपलब्ध है-F-R
— जार्ग हल्सरमैन
हम्म, दिलचस्प। मैं इसके बारे में नहीं जानता था -F। लेकिन यह आपके TIO में परिलक्षित नहीं होता (क्या यह STDIN से गूँजने का समर्थन करता है?)।
— बजे
@ यदि यह आपके दृष्टिकोण की तरह काम करता है तो कोड के बजाय केवल एक फ़ाइल का उपयोग करें और php.net/manual/en/features.commandline.options.php के-F बजाय विकल्प। यदि आपको -R कमोड में tio में समान बनाने का एक बेहतर तरीका मिल गया है लाइन मुझे बताएं
— Jörg Hülsermann
2

एक्सेल, 63 बाइट्स

=MOD(A1,2*SUMPRODUCT(--MID(A1,ROW(OFFSET(A$1,,,LEN(A1))),1)))=0

सूमिंग अंक लंबा सा होता है।

— Wernisch
स्रोत
2

भूसी , ९ by बाइट्स

1 बाइट बचाने के लिए लियो को धन्यवाद।

Ṡ¦ȯ*2ṁis

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

व्याख्या

Ṡ¦ȯ         Test whether f(x) divides x, where f is the function obtained by
            composing the next 4 functions.
       s    Convert x to a string.
     ṁi     Convert each character to an integer and sum the result.
   *2       Double the result.
— मार्टिन एंडर
स्रोत
आप
— लियो
2

हास्केल , 38 37 42 बाइट्स

1 बाइट को बंद करने के लिए ज़गारब को धन्यवाद

f x=read x`mod`foldr((+).(*2).read.pure)0x

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

एक स्ट्रिंग के रूप में इनपुट लेता है; रिटर्न 0 अगर विभाज्य और नॉनज़रो अन्यथा।

— जूलियन वुल्फ
स्रोत
(:[])हो सकता है pure।
— जगरब
आप फंक्शन डिक्लेरेशन द्वारा लैम्ब्डा को बदलकर 1 बाइट
— बचाएंगे
@ कर्ता: यकीन है कि यह एक धोने है। उदाहरण?
— जूलियन वुल्फ
आप सही कह रहे हैं, यह ठीक उसी लंबाई की है। यकीन नहीं होता कि कैसे मेरे दिमाग को पार कर गया: /
— bartvelle
2

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

lambda a:a%(sum(map(int,str(a)))*2)
— wrymug
स्रोत
नमस्कार और साइट पर आपका स्वागत है। आप यहां कुछ व्हाट्सएप हटा सकते हैं। विशेष रूप से चारों ओर =और के बाद )में int(c)। इसके अलावा चूंकि sumएक जनरेटर को एक तर्क के रूप में ले सकते हैं आप [..]इसे अंदर निकाल सकते हैं । यदि आपके पास कोई अतिरिक्त प्रश्न है तो मुझे पिंग करने के लिए स्वतंत्र महसूस करें।
— गेहूं जादूगर
int(c)for c in amap(int,a)कुछ बाइट्स को बचाने के लिए भी हो सकता है ।
— गेहूं जादूगर
यह काम नहीं करता है - या बल्कि, पीछे की ओर काम करता है। आसानी से 4 अतिरिक्त बाइट्स के साथ तय:lambda a:not a%(sum(map(int,str(a)))*2)
— osuka_
@osuka_ प्रश्न विवरण में बुलेट पॉइंट एक देखें
— wrymug
2

टीआई-बेसिक, 27 26 21 बाइट्स

-5 @ ओकी के लिए धन्यवाद

:fPart(Ans/sum(2int(10fPart(Ans10^(~randIntNoRep(1,1+int(log(Ans

यह इस तथ्य से पेचीदा बना है कि TI-BASIC में पूर्णांक अंकों का योग करने का कोई संक्षिप्त तरीका नहीं है । रिटर्न 0के लिए True, और के लिए एक अलग संख्या False।

स्पष्टीकरण:

:fPart(Ans/sum(2int(10fPart(Ans10^(-randIntNoRep(1,1+int(log(Ans
                               10^(-randIntNoRep(1,1+int(log(Ans #Create a list of negative powers of ten, based off the length of the input, i.e. {1,0.1,0.01}
                            Ans                                  #Scalar multiply the input into the list
                    10fPart(                                     #Remove everything left of the decimal point and multiply by 10
               2int(                                             #Remove everything right of the decimal point and multiply by 2
           sum(                                                  #Sum the resulting list
       Ans/                                                      #Divide the input by the sum
:fPart(                                                          #Remove everything left of the decimal, implicit print
— स्कॉट मिलनर
स्रोत
2
10^-randIntNoRep(1,1+int(log(Ansके रूप seq(10^(~A-1),A,0,log(Ansमें कम बाइट्स में आदेश के रूप में एक ही बात नहीं करता है (मान 2. संस्करण 2.55MP)
— Oki
1

ब्रिंगोल्फ , 13 12 बाइट्स

VR.Mvd&+2*c%

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

सत्य के लिए आउटपुट 0, फाल्सी के लिए कोई अन्य संख्या।

व्याख्या

VR.Mvd&+2*c%  Implicit input from command-line args
VR            Create stack2, return to stack1
  .M          Duplicate input to stack2
    vd        Switch to stack2, split into digits
      &+      Sum up all digits
        2*    Double
          c   Collapse stack2 back into stack1
           %  Modulus
              Implicit output of last item on stack
— Skidsdev
स्रोत
1

जाप , 7 बाइट्स

vUì x*2

रिटर्न 1के लिए true, 0के लिएfalse

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

व्याख्या

vUì x*2
v        // Return 1 if the input is divisible by:
 Uì      //   Input split into a base-10 array
    x    //   Sum the array
     *2  //   While mapped by *2
— ओलिवर
स्रोत
मैं इसके लिए कुछ अन्य 7 बाइट समाधानों के साथ आया, भी (हालांकि, मुझे नहीं लगता कि यह उनमें से एक था) - मुझे यकीन है कि एक छोटा समाधान है, हालांकि।
— झबरा
1

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

f x=(==) 0.mod x.(*)2.sum.map(read.return).show$x

प्रयोग

f 80

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

— हेनरी
स्रोत
3
युक्तियाँ: एक अतिरिक्त स्थान है, == शुद्ध, सूची बोध अक्सर बहुत कॉम्पैक्ट होते हैं: इसे ऑनलाइन आज़माएं!
— बर्तवेल्ले
1

जावा , 66 बाइट्स

-1 बाइट ऑलिवियर को धन्यवाद

a->{int i=0;for(int b:(""+a).getBytes())i+=b-48;return a%(i*2)<1;}

असम्बद्ध और स्पष्टीकरण:

a -> {
    int i = 0;

    for(int b : (""+a).getBytes()) { // Loop through each byte of the input converted to a string
        i += b-48; // Subtract 48 from the byte and add it to i
    }

    return a % (i*2) < 1 // Check if a % (i*2) is equal to one
    // I use <1 here for golfing, as the result of a modulus operation should never be less than 0
}
— Okx
स्रोत
बचाने के intबजाय उपयोग करें byte... एक बाइट।
— ओलिवियर ग्राएगोयर
@ ओलिवियरग्रेगायर धन्यवाद। उस पर ध्यान नहीं दिया।
— ओकेक्स
@ ऑक्स को गोल्फ कोड को भी बदलना होगा।
— हेनरी
आपका (गॉल्फर्ड) कोड 110, 111 के लिए गलत मान देता है। संभवतः यह a%i*2पार्स किया गया है (a%i)*2क्योंकि मापांक और गुणन में समान क्रम है।
— ओलिवर ग्राएगोइरे
@ ओलिविएरग्रेयर आह, कि बेकार है।
— ओकेक्स
1

जे, 15 बाइट्स

0 सत्य इंगित करता है, नॉनजरो मिथ्या इंगित करता है।

|~[:+/2#"."0@":

व्याख्या

        "."0@":  convert to list of digits
  [:+/2#         sum 2 copies of the list ([: forces monadic phrase)
|~               residue of sum divided by argument?
— hoosierEE
स्रोत
Parens या कई @या से बचने के लिए बहुत चालाक तरीका [:!
— जोनाह
1
मैंने इसे अपने उत्तर के रूप में पोस्ट करने पर बहस की, लेकिन यह वास्तव में बहुत अलग नहीं है। |~2*1#.,.&.":13 बाइट्स के लिए।
— कोल
मुझे अपने J Qt IDE पर इसके लिए 'डोमेन त्रुटि' मिलती है। (- ~ [: + / 2 # "।" 0 @ ": 112) फिर कोल कोड के लिए मुझे मिलता है! - ~ 2 * 1 # #।;।": 112) = 0 | : / संभवतः मेरे अंत में कुछ गलत है।
— DrQuarius
1

हास्केल , 35 34 बाइट्स

f x=mod x$2*sum[read[c]|c<-show x]

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

सही मामले में '0' देता है, शेष अन्यथा।

हास्केल , नेमी द्वारा पॉइंटफ्री संस्करण, 34 बाइट्स

mod<*>(2*).sum.map(read.pure).show

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

— bartavelle
स्रोत
अगर आप पॉइंटफ्री जाते हैं तो एक ही बाइट काउंट:mod<*>(2*).sum.map(read.pure).show
— nimi
अच्छा लग रहा है, मैंने इसे अपने सबमिशन में जोड़ा।
— बर्तवेल्ले
1

PHP, 44 बाइट्स

for(;~$d=$argn[$i++];)$t+=2*$d;echo$argn%$t;

इस तरह से चलाएं:

echo 80 | php -nR 'for(;~$d=$argn[$i++];)$t+=2*$d;echo$argn%$t;'

व्याख्या

कुल गणना करने के लिए अंकों पर फेरबदल करता है, फिर अधिकांश उत्तरों की तरह मोडुलो को आउटपुट करता है।

— aross
स्रोत
1

जावा (ओपनजेडके 8) , 55 53 बाइट्स

a->{int i=0,x=a;for(;x>0;x/=10)i+=x%10*2;return a%i;}

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

0सत्य का वापसी मूल्य , सत्य और कुछ भी, मिथ्या है।

चूंकि ओक्स के उत्तर में मेरी टिप्पणी ने कोई लहर नहीं बनाई, इसलिए मैंने इसे हटा दिया और इसे इस उत्तर के रूप में पोस्ट किया, और भी थोड़ा और अधिक।

इसके अलावा @KrzysztofCichocki और @ Laikoni का आभारी हूं जिन्होंने मुझे दिखाया कि मुझे सच्चाई / झूठे मूल्य का जवाब देने की आवश्यकता नहीं है, लेकिन जब तक मैं परिणाम का वर्णन करता हूं, तब तक कोई भी मूल्य नहीं।

— ओलिवियर ग्रेजायर
स्रोत
आप अंत में <1 भाग को हटा सकते हैं, इसलिए परिणाम 0 के लिए सच और> 0 के लिए गलत होगा, जो कि एसेबल है, इसके परिणामस्वरूप अतिरिक्त -2 बाइट्स होंगे, इसलिए आप जवाब देते हैं कि कोइलड 53 बाइट्स की तरह होगा।
— Krzysztof Cichocki
@KrzysztofCichoki नहीं मैं नहीं कर सकता: यह जावा है। केवल सत्य मूल्य है true।
— ओलिवियर ग्रेगोइरे
@ OlivierGrégoire यह सच है जबकि कुछ और निर्दिष्ट नहीं है, यह चुनौती विशेष रूप से बताती है Instead of truthy / falsy values for the true and false cases, you may instead specify any finite set of values for the true/false case, and their complement the other values.।
— लैकोनी
@KrzysztofCichocki और Laikoni क्षमा करें, मैंने उस भाग को गलत समझा, मैंने इसे ठीक कर लिया है! आप दोनों को धन्यवाद :) इसके अलावा, इस मामले में जो वास्तव में उपयुक्त था उस संपादन को अस्वीकार करने के लिए खेद है ।
— ओलिवियर ग्रेगोइरे
1

मिनी-फ्लैक, 296 292 बाइट्स

({}((()[()]))){(({}[((((()()()){}){}){}){}])({}(((({})){}){}{}){})[({})])(({}({})))({}(({}[{}]))[{}])({}[({})](({}{})(({}({})))({}(({}[{}]))[{}])({}[({})]))[{}])(({}({})))({}(({}[{}]))[{}])({}[({})])}{}({}(((({}){})))[{}]){({}((({}[()]))([{(({})[{}])()}{}]()){{}{}(({}))(()[()])}{})[{}][()])}

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

TIO लिंक में मुझसे अधिक टिप्पणियां हैं, इसलिए इसे पढ़ना आसान है।

सत्य / मिथ्या: सत्य (विभाज्य) यदि दूसरी संख्या तीसरी संख्या के बराबर है, तो मिथ्या अन्यथा। इसलिए सत्य और झूठ दोनों सेट अनंत हैं, लेकिन मुझे लगता है कि अनुमति दी जानी चाहिए। +10 बाइट अगर वह नहीं है।

नोट: लीडिंग / ट्रेलिंग न्यूलाइन्स / व्हाट्सएप को इनपुट में अनुमति नहीं है।

— user202729
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.