कार्य

दो सख्ती से सकारात्मक पूर्णांक एन और डी को इनपुट के रूप में देखते हुए , निर्धारित करें कि क्या एन डी से समान रूप से विभाज्य है , अर्थात, यदि कोई पूर्णांक क्यू मौजूद है जैसे कि ।n = qd

आप एक प्रोग्राम या फ़ंक्शन लिख सकते हैं और इनपुट प्राप्त करने और आउटपुट प्रदान करने के हमारे किसी भी मानक तरीके का उपयोग कर सकते हैं।

आउटपुट एक सत्य या मिथ्या मूल्य होना चाहिए ; सत्य यदि n , d से विभाज्य है , और मिथ्या है अन्यथा।

आपके कोड को केवल पूर्णांकों को संभालना है यह मूल रूप से प्रतिनिधित्व कर सकता है, जब तक कि यह सभी हस्ताक्षरित 8-बिट पूर्णांक के लिए काम करता है। हालांकि, आपके एल्गोरिथ्म को मनमाने ढंग से बड़े पूर्णांक के लिए काम करना है।

आप किसी भी प्रोग्रामिंग भाषा का उपयोग कर सकते हैं , लेकिन ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है।

यह कोड-गोल्फ है , इसलिए सबसे छोटा वैध उत्तर - बाइट्स में मापा जाता है - जीतता है।

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

 n,  d    output

 1,  1    truthy
 2,  1    truthy
 6,  3    truthy
17, 17    truthy
22,  2    truthy
 1,  2    falsy
 2,  3    falsy
 2,  4    falsy
 3,  9    falsy
15, 16    falsy

लीडरबोर्ड

इस पोस्ट के निचले हिस्से में स्टैक स्निपेट उत्तर से सूची बनाता है) क) प्रति भाषा में सबसे छोटे समाधान की सूची के रूप में और बी) एक समग्र लीडरबोर्ड के रूप में।

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

## Language Name, N bytes

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

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

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

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

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

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

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

<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table><script>var QUESTION_ID = 86149; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 48934; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "https://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>

स्निपेट का विस्तार करें

— लीक नन
स्रोत

इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।

— डेनिस

41

जेली , 1 बाइट

ḍ

इस गोल्फ में मुझे घंटों लग गए।

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

— DJMcMayhem
स्रोत

12

वाह यह बहुत जटिल है!

@MatthewRoh हां। जैसा मैंने कहा, मुझे आने में घंटों लग गए। : पी

— DJMcMayhem

29

ब्रेन-फ्लैक , 72 70 64 62 58 46 बाइट्स

{({}[()]{(<()>)}{}<({}[()]<({}())>)>)}{}{{}}{}

लाभांश और भाजक (उस क्रम में) इनपुट के रूप में लेता है और भाजक (सत्य) या कुछ भी नहीं छापता है। चूंकि प्रत्येक स्टैक में एक अंतर्निहित, अनंत राशि का शून्य है, इसलिए खाली आउटपुट को झूठा माना जाना चाहिए।

जबकि स्टैक-क्लीन नहीं है, यह समाधान केवल एक स्टैक का उपयोग करता है।

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

2 बाइट्स बंद करने के लिए @WheatWizard को धन्यवाद!

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

                INPUT: a (dividend), b (divisor)
                INITIAL STACK: n = a, d = b, r = 0
                               An infinite amount of zeroes follows.

{               While n is non-zero:
  (
    {}              Pop n from the stack.
    [()]            Yield -1.
    {               While the top of the stack (initially, d) is non-zero:
      (<()>)          Push 0.
    }
    {}              Pop 0. This will remove d from the stack if d = 0, leaving r
                    on top. We can think of this as performing the assignment
                    (d, r) = (r, d) if d = 0.
    <
      (
        {}              Pop d.
        [()]            Yield -1.
        <
          (
            {}              Pop r.
            ()              Yield 1.
          )               Push r + 1.
        >               Yield 0.
      )               Push d + (-1) + 0 = d - 1.
    >               Yield 0.
  )               Push n + (-1) + 0 + 0 + 0 = n - 1.
}               Each iteration decrements n, swaps d and r if d = 0, decrements d,
                and increments r.
                FINAL VALUES: n = 0
                              d = b - r
                              r = a % b if a % b > 0 else b
{}              Pop n.
{               While the top of the stack is non-zero:
  {}              Pop it.
}               This pops d and r if d > 0 (and, thus, a % b > 0) or noting at all.
{}              Pop d or a 0, leaving r if r = b and, thus, a % b = 0.

मापांक गणना, 42 बाइट्स

उपर्युक्त पूर्ण कार्यक्रम को इसके बजाय मापांक की गणना करने के लिए एक तुच्छ तरीके से संशोधित किया जा सकता है।

{({}[()]<({}[()]<({}())>)>{(<()>)}{})}{}{}

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

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

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

विभाज्यता परीक्षक और मापांक कैलकुलेटर के दो छोरों की तुलना करें।

{({}[()]{(<()>)}{}<({}[()]<({}())>)>)}
{({}[()]<({}[()]<({}())>)>{(<()>)}{})}

एकमात्र अंतर का स्थान है {(<()>)}{}, जो d और r स्वैप करता है यदि d = 0 । मापांक गणना करने के लिए, हम इस स्वैप प्रदर्शन के बाद decrementing घ और बढ़ाने आर ।

यह परिवर्तन % b> 0 पर परिणाम को प्रभावित नहीं करता है , लेकिन यदि % b = 0 है , तो यह छोड़ देता है (n, d, r) = (0, b, 0) - बजाय (n, d, r) = (0, 0, बी) - स्टैक पर।

इस प्रकार, मापांक प्राप्त करने के लिए, हमें केवल n और d को पॉप करना है {}{}।

स्टैक-साफ मापांक गणना, 64 बाइट्स

42-बाइट मापांक एल्गोरिथ्म स्टैक-क्लीन नहीं है, इसलिए इसका उपयोग नहीं किया जा सकता है जैसा कि सभी कार्यक्रमों में है। निम्न संस्करण सक्रिय स्टैक से लाभांश और भाजक (उस क्रम में) को पॉप करता है और बदले में मापांक को धक्का देता है। इसका कोई अन्य दुष्प्रभाव नहीं है।

({}(<()>)){({}[()]<(({}()[({})])){{}(<({}({}))>)}{}>)}({}{}<{}>)

यह समाधान काफी हद तक @ WheatWizard के पिछले 72-बाइट रिकॉर्ड पर आधारित है, लेकिन यह 6 बाइट्स को कभी भी स्विच नहीं करने से बचाता है।

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

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

             INPUT: a (dividend), b (divisor)
             INITIAL STACK: n = a, b

(
  {}         Pop and yield n = a.
  (<()>)       Push d = 0.
)              Push n + 0 = n.
             STACK: n, d = 0, b
{(           While n in non-zero:
  {}           Pop and yield n.
  [()]         Yield -1.
  <
   ((
     {}         Pop and yield d.
     ()         Yield 1.
     [({})]     Pop b, push it back on the stack, and yield -b.
   ))         Push d + 1 + -b = d + 1 - b twice.
   {          While/if d + 1 - b is non-zero, i.e., if d < b - 1
     {}         Pop d + 1 - b (second copy).
     (<(
       {}         Pop d + 1 - b (first copy).
       ({})       Pop b and push it back on the stack.
     )>)        Push d + 1 - b + b = d + 1, then 0.
   }          If the loop wasn't skipped entirely, pushing 0 breaks out.
              If d < b - 1, it essentially performs the assignment d = d + 1.
              However, if d = b - 1, we get d = d + 1 - b = b - 1 + 1 - b = 0.
              In all cases, we wind up with d = (d + 1) % b.
   {}         Pop 0.
  >         Yield 0.
)}        Push n + -1 + 0 = n - 1. Break if n - 1 = 0.
          STACK: n = 0, d = a % b, b
(
  {}        Pop and yield n = 0.
  {}        Pop and d = a % b.
  <{}>      Pop b, but yield 0.
)         Push 0 + a % b + 0 = a % b.

— डेनिस
स्रोत

20

x86_32 मशीन कोड, 8 बाइट्स

08048550 <div7>:
 8048550:   99                      cdq   
 8048551:   f7 f9                   idiv   %ecx
 8048553:   85 d2                   test   %edx,%edx
 8048555:   0f 94 c0                sete   %al

यह मेरा पहला कोड गोल्फ उत्तर है, इसलिए उम्मीद है कि मैं सभी नियमों का पालन कर रहा हूं।

यह पहले edx रजिस्टर को खाली करने के लिए cdq कहता है, फिर ecx रजिस्टर पर हस्ताक्षरित विभाजन करता है, जो edx में शेष को संग्रहीत करता है। अगर edx शून्य है, तो टेस्ट edx, edx लाइन शून्य ध्वज सेट कर देगी, और setx 0 के लिए झूठा डालता है यदि edx शून्य नहीं था, और edx 0 था, तो सत्य के लिए 1 डालता है।

यह सिर्फ कोड स्निपेट है जो बाइट काउंट में योगदान देता है, लेकिन परीक्षण के लिए, यहाँ C कोड है जिसे मैंने इनलाइन असेंबली के साथ लिखा है क्योंकि I / O को हैंडल करने का यह तरीका आसान है।

— डेवी
स्रोत

2

PPCG में आपका स्वागत है, अच्छा पहला जवाब!

— लीक नून

क्या यह एक पूर्ण कार्यक्रम होने की आवश्यकता है? मैं इस जवाब से अपनी प्रतिक्रिया थोड़े प्रारूपित कर रहा था । और धन्यवाद! मैं और अधिक कोड गोल्फ के लिए विधानसभा / मशीन कोड में बेहतर होने की उम्मीद कर रहा हूँ!

— davey

1

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

— मेगो

बहुत खुबस! धन्यवाद!

— davey

17

हेक्सागोनी, 15, 13, 12 10 बाइट्स

हर किसी की पसंदीदा षट्भुज-आधारित भाषा! : डी

टीएल; डीआर जादू का उपयोग करते हुए काम करता है, घटती हुई बाइट काउंट में अनियोजित समाधान:

?{?..>1'%<.@!'/
?{?!1\.'%<@.>
?{?\!1@'%\!(
?{?!1\@'%<

सहेजे गए 2 बाइट @ मार्टिनएंडर लेआउट विज़ार्ड के लिए धन्यवाद।

@FryAmTheEggman ने अधिक रचनात्मक रूप से कोनों का उपयोग करके 1 बाइट को बचाया

@MartinEnder और @FryAmTheEggman दोनों एक 10 बाइट समाधान के साथ आए जो झूठे मूल्यों के लिए कुछ भी प्रिंट नहीं करता है।

मेरा समाधान (15):

अस्वरूपित:

?{?..>1'%<.@!'/

प्रारूपित:

  ? { ?
 . . > 1
' % < . @
 ! ' / .
  . . .

@ मर्टिन एंडर का समाधान (13):

अस्वरूपित:

?{?!1\.'%<@.>

प्रारूपित:

  ? { ?
 ! 1 \ .
' % < @ .
 > . . .
  . . .

स्पष्टीकरण:

सबसे पहले, हम इनपुट प्राप्त करते हैं और मापांक लेते हैं।

  ? { ?
 . . . .
' % . . .
 . . . .
  . . .

फिर, यह जाँचता है कि मापांक 0 है या नहीं। यदि यह है, तो आईपी 60 डिग्री छोड़ दिया जाता है, दर्पण से उछलता है, सेल को 1 और प्रिंट सेट करता है।

फिर, IP चौथी पंक्ति पर जारी रहती है। जब यह पहुंचता है >, तो इसके बजाय दाईं ओर मुड़ जाता है (क्योंकि सेल का मान अब 1 है)। यह ऊब जाता है, और नीचे दाएं कोने में NW पर वापस आता है। आईपी हिट को हिट करता है <, शीर्ष पंक्ति के साथ जाता है, और @प्रोग्राम को रोककर, हिट करने के लिए दाएं कोने में वापस आता है ।

  . . .
 ! 1 \ .
. . < @ .
 > . . .
  . . .

यदि मापांक सकारात्मक निकलता है, तो आईपी 60 डिग्री दाईं ओर मुड़ता है। एक बार जब यह नीचे दाएं कोने से बाहर निकल जाता है, तो यह हेक्सागोनी के रैपिंग नियमों के कारण निचले बाएं किनारे पर जारी रहता है। 'आईपी उस में 0 के साथ एक सेल करने के लिए जाना बनाने के लिए पुन: उपयोग किया जाता है। आईपी फिर चौथी पंक्ति के साथ यात्रा करता है, दूसरे के चारों ओर घूमता है, प्रिंट को हिट करता है, और इसमें परिलक्षित होता है <। बाकी रास्ता @वही है।

  . . .
 ! . \ .
' . < @ .
 > . . .
  . . .

यह कुछ गंभीर है।

@ FryAmTheEggman का समाधान (12):

अस्वरूपित:

?{?\!1@'%\!(

प्रारूपित:

  ? { ?
 \ ! 1 @
' % \ ! (
 . . . .
  . . .

स्पष्टीकरण:

अन्य समाधानों की तरह, यह इनपुट प्राप्त करता है और मापांक लेता है।

  ? { ?
 . . . .
' % . . .
 . . . .
  . . .

फिर, आईपी नीचे कोने में विक्षेपित हो जाता है। यदि मापांक सकारात्मक है, तो यह शीर्ष बाएं किनारे पर जाता है। ?कोई और अधिक इनपुट तो यह 0 पर सेल सेट है, !तो 0 प्रिंट, और @कार्यक्रम समाप्त हो जाता है।

  ? . .
 \ ! . @
. . \ . .
 . . . .
  . . .

जब मापांक 0. होता है, तब चीजें बहुत पेचीदा हो जाती हैं, सबसे पहले, यह घट जाती है, फिर 0 पर रीसेट हो जाती है, फिर 1 पर सेट हो जाती है, फिर मुद्रित होती है। फिर, 1 को 0. घटाया जाता है। उसके बाद, प्रोग्राम तब तक चलता है, जब तक वह शुरुआत में ऐसा नहीं करता 0%0। यह एक मौन त्रुटि फेंक और छोड़ देता है।

  ? { ?
 . . 1 .
' % \ ! (
 . . . .
  . . .

मुझे वास्तव में मूक त्रुटि चाल पसंद है, लेकिन एक सरल तरीका यह होगा कि आईपी को पहली बार से गुजरने के (साथ बदल दिया /जाए, लेकिन @दूसरे में परिलक्षित होता है ।

सहयोगात्मक समाधान (10):

अस्वरूपित:

?{?!1\@'%<

प्रारूपित:

  ? { ?
 ! 1 \ @
' % < . .
 . . . .
  . . .

यह कार्यक्रम अन्य सभी कार्यक्रमों की तरह ही शुरू होता है, इनपुट प्राप्त करना और इसे संशोधित करना।

यदि इनपुट 0 है, तो हिट होने पर आईपी बाएं हो जाता है <। इसमें विक्षेपित हो जाता है 1!@, जो 1 प्रिंट करता है और क्विट करता है।

  . . .
 ! 1 \ @
. . < . .
 . . . .
  . . .

यदि इनपुट सकारात्मक है, तो हिट होने पर आईपी सही हो जाता है <। यह कोने के माध्यम से बाहर निकलता है, और बिना मुद्रण के @ के ऊपर दाएं किनारे से ऊपर जाता है।

  . . ?
 . . . @
. . < . .
 . . . .
  . . .

— नीला
स्रोत

6

मुझे लगता है कि आपको अपने उत्तर को अलग तरीके से प्रारूपित करना चाहिए। एक एकल कोड ब्लॉक में चार उत्तर होने से ऐसा प्रतीत होता है जैसे कि आपकी बाइट गिनती गलत है।

— mbomb007 20

17

ब्रेन-फ्लैक 102, 98, 96 बाइट्स

(({}<>))<>{({}[()])<>(({}[()])){{}(<({}[({})])>)}{}({}({}))<>}{}<>([{}]{}){<>(([()])())}({}{}())

Eww। कुल। मैं एक स्पष्टीकरण पोस्ट कर सकता हूं, लेकिन मैं मुश्किल से खुद को समझता हूं। यह भाषा मेरे मस्तिष्क को आहत करती है।

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

Modulus उदाहरण के साथ आने के लिए github उपयोगकर्ता @Wheatwizard को धन्यवाद । मैं शायद यह पता नहीं लगा सकता था कि मैं खुद बाहर हूँ!

इसके अलावा, कम जवाब यहाँ है ।

संभवतः गलत व्याख्या:

(({}<>))                    #Push this element onto the other stack
<>                          #Move back to stack one.
{                           #While the top element is non-zero:
 ({}[()])                   #  Decrement the number on top
 <>                         #  Move to the other stack
 (({}[()]))                 #  Push the top element minus one twice
 {                          #  While the top element is non-zero:
  {}                        #    Pop the top element
  (<          >)            #    Push a zero
        ({})                #    Push the second from top element
       [    ]               #    Evalue this second from top element as negative
    ({}      )              #    And push that negative plus the top element
 }
 {}                         #  Pop the top element
 ({}({}))                   #  Push the top element plus the second from the top, AND push the second from top
 <>                         #  Switch stacks
}

{}                          #Pop the stack
<>                          #Switch to the other stack
([{}]{})                    #And push the top element minus the second element.

बाकी सब बहुत सीधा है।

{              }            #While the top element is non-zero:
 <>                         #Move to the other stack
   (([()])  )               #Push a negative one
          ()                #AND push the previously pushed value + 1 (e.g. 0)

                 (      )   #Push:
                  {}{}      #The top two elements added together
                      ()    #Plus one

— DJMcMayhem
स्रोत

The rest is pretty straightforward.हाँ, ऐसा लगता है।

— 15

24 बाइट्स यदि आप प्रत्येक ब्रेनफ्लक निर्देश को बाइट के रूप में गिनते हैं।

— noɥʇʎԀʎzɐɹƆ 12

12

जावास्क्रिप्ट (ईएस 6 ) 17 12 11 बाइट्स

a=>b=>a%b<1

EDIT: 5 बाइट्स निकाले गए क्योंकि 'a> 0' अपेक्षित है।
EDIT2: डाउनगेट के लिए 1 बाइट को हटा दिया गया ।

— ETHproductions
स्रोत

एक बाइट को बचाने के लिए क्युरिंग का उपयोग करें: a => b =>

— डाउनगेट

तो मैं इसे कैसे निष्पादित करूं? जब मैं जेएस कंसोल में d=a=>b=>a%b<1पीछा करने की कोशिश करता हूं d(32,2)... मुझे बस प्रतिक्रिया मिलती हैfunction b=>a%b<1

— वैलीवेस्ट

@WallyWest यह करी का उपयोग करता है, इसलिए आप टाइप करेंगे d(32)(2)। क्योंकि d(32)देता है function b=>a%b<1, तो आपको उस फ़ंक्शन को अपने bमूल्य के साथ कॉल करना होगा

— साइओस

9

विम, 11 कीस्ट्रोक्स

C<C-r>=<C-r>"<C-Left>%<C-Right><1<cr>

ऐसी भाषा के लिए बुरा नहीं है जो केवल तारों को संभालती है। : डी

— DJMcMayhem
स्रोत

क्या करता <C-Left>है? इसका परीक्षण नहीं कर सकते क्योंकि यह मैक> _>

— डाउनगोट

1

@Downgoat आप ctrl या कमांड का उपयोग कर रहे हैं? किसी भी तरह से, यह "बी" के बराबर है, सिवाय इसके कि यह इन्सर्ट मोड में भी काम करता है।

— डीजेएमकेमहेम

पांडित्यपूर्ण होने के Bबजाय , यह b(और Ctrl+ Rightके बराबर W) के बराबर है - अंतर गैर-शब्द वर्णों के साथ है, लेकिन इस मामले में यह ठीक वही काम कर रहा है :) vimdoc.sourceforge.net/htmldoc.motion। html # <C-Left >

— क्रिश्चियन Rondeau

9

गणितज्ञ - १ 3 १३ ३ बाइट्स

∣

एक टन बाइट बचाने के लिए @MartinEnder को धन्यवाद!

— Yytsi
स्रोत

वह कौन सा चरित्र है?

— साइओस

@ मुझे लगता है कि मैं इसका यूनिकोड-कोड (फिलहाल फोन पर) नहीं जानता, लेकिन यह इसके लिए एक छोटा ऑपरेटर है Divisible[]।

— यति

@ मुझे लगता है कि यह पाइप प्रतीक है, जिसे शिफ्ट + बैकस्लैश के रूप में भी जाना जाता है।

— पावेल

@ पावेल अगर यह पाइप का प्रतीक होता, तो यह तीन बाइट्स नहीं होता।

— साइओस

@ यह केवल U + 2223 चरित्र है: fileformat.info/info/unicode/char/2223/index.htm

— क्रमांक

8

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

^(1+)\1* \1$

अंतरिक्ष-पृथक इनपुट को एकात्मक में ले जाता है, जैसे 111111111111 1111कि यदि 12 को 4 से विभाज्य है, तो जांचना । प्रिंट 1 (सत्य) या 0 (गलत)।

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

~~FryAmTheEggman ने दो बाइट्स बचाए।~~ ओह, सही क्रम में तर्क लेने के लिए मेरे जवाब को फिर से लिखना। (तब फ्राई ने मुझे टिप्पणियों में इसे हरा दिया। मैं regex पर धीमा हूँ!)

— लिन
स्रोत

आदेश को ठीक करने के लिए, यदि यह आवश्यक हो जाता है, तो मुझे लगता है कि ^(1+)\1* \1$काम करेगा।

— FryAmTheEggman

मुझे लगता है कि नई कल्पना के साथ, विपरीत इनपुट आदेश फिर से ठीक है।

— मार्टिन एंडर

8

बैच, 20 बाइट्स

@cmd/cset/a!(%1%%%2)

1सफलता पर आउटपुट , 0असफलता पर।

— नील
स्रोत

8

सी #, 27 13 12 बाइट्स

a=>b=>a%b<1;

अनाम लँबदास को इंगित करने के लिए तुक्काक्स के लिए धन्यवाद स्वीकार्य हैं। डेविड कॉनरैड का शुक्रिया जो मुझे इस बात की ओर इशारा करता है कि मुझे भी इस बात की जानकारी नहीं थी।

लघु और मिठाई, क्योंकि हम केवल पूर्णांकों साथ काम कर रहे हम उपयोग कर सकते हैं <1के बजाय ==0और एक पूरी बाइट सहेजें।

— जस्टिनएम - मोनिका को बहाल करें
स्रोत

मुझे यकीन नहीं है, लेकिन मुझे लगता है कि आप सिर्फ एक लैम्ब्डा का उपयोग कर सकते हैं (a,b)=>a%b<1;:। +1।

— यति जूल

@TuukkaX, धन्यवाद मुझे यकीन नहीं था, यह सिर्फ इतना धोखा लगता है।

— जस्टिनएम -

इस के जेएस संस्करण ने इसे एक बाइट को कम करने के लिए क्युरिंग का इस्तेमाल किया, और यह कि सी # के लिए काम करना चाहिए, भी: a=>b=>a%b<1;(ध्यान दें: आपको इसके f(a)(b)बजाय इसे कॉल करना होगा f(a,b))

— डेविड कॉनराड

1

@DavidConrad oo वह साफ-सुथरा है, धन्यवाद।

— जस्टिनएम -

7

ब्रेनफक, 53 बाइट्स

इनपुट को बाइट्स के रूप में लेता है, आउटपुट बाइट मान है 0x00या 0x01। यह बूलियन नकार के बाद DivMod एल्गोरिथ्म है ।

,>,<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>,>[<+>,]+<[>-<-]>.

इसे ऑनलाइन आज़माएं -+अंत के पासअतिरिक्त का एक गुच्छा हैताकि आप ASCII में आउटपुट देख सकें।

— mbomb007
स्रोत

क्या आप बाइट को बचाने के लिए "div" चीज को हटा सकते हैं?

— लीक नून

1

@LeakyNun यह सबसे छोटा ज्ञात एल्गोरिथम है जो मापांक देता है। इसका एक हिस्सा निकालने से वास्तव में इसे लंबा हो जाता है, क्योंकि आपको अधिक अस्थायी कोशिकाओं की आवश्यकता होती है। आप विभाजन के बिना एक मापांक नहीं पा सकते हैं।

— mbomb007

मैं देखता हूं, धन्यवाद।

— लीक नून

@LeakyNun सिर्फ यह देखें कि डिवीजन एल्गोरिदम कितना लंबा है।

— mbomb007

शायद कम ही लोग हैं, लेकिन यदि ऐसा है, तो किसी ने उन्हें ढूंढ या पोस्ट नहीं किया है।

— mbomb007

7

ब्रेन-फ्लैक , 88 86 बाइट्स

(<({}<>)>)<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}<>(({}<{}>)){{}{}(<(())>)}{}

यह ~~डॉ। ग्रीन एग्स और आयरन मैन~~ डीजेमैकेम द्वारा लिखित मूल ब्रेन-फ्लैक डिविजिबिलिटी टेस्ट एल्गोरिथ्म का एक सघन संस्करण है और मैं स्वयं।

यह कैसे काम करता है इसकी संक्षिप्त (ईश) व्याख्या है:

  ({}<>)        #Move the top of the stack to the other stack #Start Mod
(<      >)      #Push zero
<>              #Switch stacks
{               #While the top of the stack is not zero
 ({}[()])       #Subtract one from the top of the stack
 <>             #Switch stacks
   {}()         #Pop the top, add one and ...
       [({})]   #Subtract the second element on the stack
 ((          )) #Push twice
 {              #If the top is not zero
  {}            #Pop the duplicate
    ({}({}))    #Add the second element to the first
  (<        >)  #Push zero
 }              #End if
 {}             #Pop the zero
 <>             #Switch back
}               #End While
<>              #Switch to the other stack
 ({}<{}>)       #Remove the second value on the stack         #End Mod
(        )      #Duplicate the result of modulation
{               #If the top is not zero
 {}{}           #Pop the top two elements
 (<(())>)       #Push a one and a zero
}               #End if
{}              #Pop the zero

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

— गेहूं का जादूगर
स्रोत

ऑनलाइन दुभाषिया से लिंक?

— लीक नन

अच्छा काम! साइट पर भी आपका स्वागत है! मुझे उम्मीद है कि आप यहाँ मज़े करेंगे। (मैं निश्चित रूप से है)

— DJMcMayhem

अच्छा पहला जवाब, पीपीसीजी में आपका स्वागत है!

— लीक नन

6

LOLCODE, 74 64 बाइट्स

HOW IZ I f YR a AN YR b
BOTH SAEM MOD OF a AN b AN 0
IF U SAY SO

— OldBunny2800
स्रोत

यह एक पूर्ण कार्यक्रम है, वर्तमान कार्यान्वयनों को HAI और

— KTHXBYE की

ठीक है मैं कोशिश करूँगा। एक सेकंड ...

— ओल्डबुननी 2800

नहीं, यह दो बाइट्स लंबा है।

— OldBunny2800

O RLY?मुझे नहीं पता था कि! बदल रहा है।

— OldBunny2800

BTW यहाँ गोल्फ युक्तियाँ है।

— लीक नन

6

सी, 60 बाइट्स

#include <stdio.h>
main(){int a,b;scanf("%d %d",&a,&b);a%b==0;}

— Ronronner
स्रोत

1

क्यों -1 मुझे समझाएं

— 22-22 बजे रॉननर

3

यह संभव है कि किसी ने नीचा न देखा हो। यह एक छोटा जवाब है इसलिए इसे कम गुणवत्ता वाले ऑटो-फ्लैग किया गया, और फिर आपने इसे संपादित किया। किसी कारण के लिए, यह एक स्वचालित डाउनवोट कास्ट करता है । उसके लिए माफ़ करना। +1मुझ से। इसके अलावा, हम फ़ंक्शन की अनुमति देते हैं, इसलिए आप इसे आसानी से छोटा int f(a,b){return !(a%b);}या संभव भी छोटा कर सकते हैं।

— DJMcMayhem

3

नहीं, मेरा कहना यह है कि इसका पूरा कार्यक्रम होना जरूरी नहीं है। आप इसके बजाय केवल एक फ़ंक्शन सबमिट कर सकते हैं। int f(a,b){return!(a%b);}25 बाइट्स है, और यदि आप सही संकलक का उपयोग करते हैं तो आप f(a,b){return!(a%b);}21 बाइट्स के लिए भी कर सकते हैं ।

— DJMcMayhem

3

यहां तक कि छोटे समारोह प्रस्तुत: #define f(a,b)!(a%b)( ideone लिंक )

— Mego

2

आपको एक फंक्शन या प्रोग्राम को परिभाषित करने की आवश्यकता है, न कि केवल एक स्निपेट की।

— लीक नून

5

Dyalog एपीएल , 3 बाइट्स

0=|

क्या शून्य विभाजन के बराबर है?

— एडम
स्रोत

3

यह J में भी काम करता है।

— मील

5

आर, 22 20 बाइट्स

a=scan();!a[1]%%a[2]

जैसा कि आमतौर पर, इनपुट से दो नंबर पढ़ता है जिसे खाली लाइन द्वारा समाप्त किया जाता है।

अपडेट: 2 बाइट्स को शेविंग करने के लिए जारको डबेलडैम के लिए धन्यवाद (इस तथ्य के बावजूद कि उनका संपादन अस्वीकार कर दिया गया था, यह बहुत मददगार था!)।

— आंद्रे कोस्टीर्का
स्रोत

5

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

a->b->a%b<1

क्या बिल्ली, इस के जेएस और सी # संस्करण हैं, तो जावा संस्करण भी क्यों नहीं?

उपयोग:

import java.util.function.Function;

public class Program {
    public static void main(String[] args) {
        System.out.printf("%d, %d %b%n", 9, 3, divides(9, 3, a->b->a%b<1));
        System.out.printf("%d, %d %b%n", 3, 9, divides(3, 9, a->b->a%b<1));
    }

    public static boolean divides(int a, int b,
            Function<Integer, Function<Integer, Boolean>> f) {
        return f.apply(a).apply(b);
    }
}

— डेविड कोनराड
स्रोत

a->b->a%b<1यह एक सिंटैक्स त्रुटि उठाता है, है ना?

— दोरुखान, मोनिका

2

नहीं, यह वैध है जावा 8.

— डेविड कॉनराड

कभी-कभी जावा भी पर्ल की तरह दिख रहा है ...

— मेगा मैन

हाँ, मैं इसमें जोड़ूंगा कि यह केवल जावा 8 है;)।

— मैजिक ऑक्टोपस उर्फ़

इसलिए जावा 8 के साथ हमें केवल लैम्ब्डा एक्सप्रेशन बाइट्स गिनना है न कि पूरी क्लास और फंक्शन बॉयलरप्लेट, कूल!

— सिकोरस्की

4

पायथन, 16 बाइट्स

lambda D,d:D%d<1

— डेनिस
स्रोत

1

ध्यान दें कि यदि नकारात्मक पूर्णांक की अनुमति दी गई थी तो यह काम नहीं करेगा। सौभाग्य से, इनपुट सख्ती से सकारात्मक हैं।

— TLW

मैंने किया था lambda a,b:1.*a/b==a/b, लेकिन काफी प्रभावित था। यह कोड का एक बहुत ही जटिल टुकड़ा है ...

— आउटगॉल्फर

4

GolfScript, 3 बाइट्स

~%!

स्पष्टीकरण:

~    # Evaluate the input
 %   # Take the first modulus the second
  !  # Boolean not

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

— Loovjo
स्रोत

4

सीजाम, 6 4 बाइट्स

डेनिस की बदौलत 2 बाइट्स बचाए

q~%!

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

q    e# Take in the input
 ~   e# Dump the individual values to the stack
  %  e# Modulus
   ! e# Boolean NOT

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

4

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

%0

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

— Fatalize
स्रोत

3

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

D\d=D%d<1

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

— डेनिस
स्रोत

3

फोरट्रान 95, 78 बाइट्स

function f(i,j)result(k)
integer::i,j,k
k=merge(1,0,MOD(i,j)<1)
end function f

— जेरेमी
स्रोत

3

मारियोलैंग, 121 109 107 बाइट्स

मार्टिन एंडर के लिए धन्यवाद 14 बाइट्स बचाए

;>(-)-)+(([!)
)"=========#[
; +(![-)< )<!+
  ==#==="  "#:
>!< >(+ !![(<
=#"="===##=:"
  !      <
  #======"

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

व्याख्या

एल्गोरिथ्म बस घटाकर रखना है dसे nयदि आप इसे समय की एक पूर्णांक संख्या करते हैं और कोई शेष हो सकता है देखने के लिए।

;
)
;

>
=

सबसे पहले, इनपुट एकत्र किया जाता है। nपहली सेल dमें है, दूसरे में।

 >(-)-)+(([!
 "=========#
          )<
           "
 !
 #"="===##=

यह मूल रूप से मुख्य लूप है। यह पहली और दूसरी कोशिकाओं को घटाता है, और तीसरे को बढ़ाता है।

यह अंतिम आउटपुट है। अगर वेतन वृद्धि / कमी के बाद, पहली सेल 0 है, तो हमने समाप्त कर दिया है n। यदि इसके बाद, दूसरा सेल ( d) है 0, तो समान रूप से dचला गया n। हम वेतन वृद्धि और प्रिंट करते हैं ( 1)। अन्यथा, पहले सेल (जो है 0) पर वापस जाएं और इसे प्रिंट करें।

 
 
  +(![-)<  
  ==#==="  
 !< >(+ !![
 #"="===##=
  !      <
  #======"

यह लूप तब होता है जब दूसरा सेल 0बढ़ने और घटने के बाद होता है । यह तीसरे सेल को दूसरी सेल में कॉपी करता है। यदि सेल नहीं है, तो नीचे का हिस्सा लूप को बायपास करना है 0।

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

3

Tcl, 34 बाइट्स

ge stdin a
ge stdin b
exp $a%$b<1

कोडगुल्फ़ में मेरा पहला / * सफल * / प्रयास! इस कोड को Tcl शेल में निष्पादित किया जाना चाहिए, अन्यथा यह काम नहीं करेगा।

@Lynn को एक बाइट धन्यवाद।

चार बाइट्स @Lynn और @LeakyNun के लिए धन्यवाद (अब मुझे समझ में आया कि उनका क्या मतलब था)!

क्या आप छोड़ सकते हैं ?1:0?

— लीकेई नून

@LeakyNun यह टर्नरी ऑपरेशन है। आप इसका मतलब है कि sth लौटने के लिए जब यह अदृश्य है?

क्या $a%$b==0लौटेगा?

— लीक नन

1

मेरा मतलब है, क्या आपकी तीसरी लाइन बस हो सकती है exp $a%$b==0?

— लीकी नून

1

या exp $a%$b<1, शायद?

— लिन

3

PHP, 23 22 बाइट्स

<?=$argv[1]%$argv[2]<1

झूठे के लिए सच्चे, खाली स्ट्रिंग (= कुछ भी नहीं) के लिए 1 प्रिंट

तर्कों के साथ nऔर dतर्क के रूप में कॉल करें

प्राचीन PHP के लिए 10 बाइट्स: <?=$n%$d<1

— टाइटस
स्रोत

अगर आपको PHP4.1 का उपयोग करने में कोई आपत्ति नहीं है <?=!($A%$B):। मूल्यों अपने हिस्से के रूप में पारित किया जा सकता $_SESSION, $_COOKIE, $_POST, $_GETया (अगर मैं गलत नहीं हूँ) से अधिक $_ENV।

— इस्माईल मिगुएल

@ इस्माइल मिगुएल: वास्तव में मैं नहीं करता, लेकिन मैं प्राचीन PHP संस्करणों के लिए पोस्ट करने और जोड़ने से थक गया हूं for PHP<5.4 with register_globals=On। लेकिन मैं इसे संदर्भ के लिए जोड़ूंगा।

— टाइटस

वास्तव में, आप " for PHP<5.4 with register_globals=On" नहीं कह सकते , क्योंकि आपको अपनी php.iniफ़ाइल के बाइट्स को गिनना है register_globals=On। हालाँकि, PHP4.1 एक विशेष मामला है। यह अंतिम संस्करण है जहां register_globals=Onडिफ़ॉल्ट मान है, और अधिकांश फ़ंक्शन PHP4.1 और ऊपर से उपलब्ध हैं। यह संस्करण अन्य कार्यों के उपयोग की भी अनुमति देता है, जैसे eregऔर splitचेतावनी के बिना।

— इस्माईल मिगुएल

3

जे, 3 बाइट्स

0=|

उपयोग:

2 (0=|) 10

लौट आएंगे 1। और स्यूडोकोड के बराबर है10 MOD 2 EQ 0

ध्यान दें कि यह एपीएल उत्तर के समान है , क्योंकि जे एपीएल से प्रेरित है

— emiflake
स्रोत

अच्छा पहला जवाब, पीपीसीजी में आपका स्वागत है!

— लीक नून

@LeakyNun धन्यवाद, मैं हमेशा के लिए तैयार है, अंत में जवाब देने के लिए अच्छा है।

— ईमलीकेक

3

PowerShell v2 +, 20 बाइट्स

!($args-join'%'|iex)

दो कमांड-लाइन तर्कों के रूप में इनपुट लेता है $args, -joinउन्हें %विभाजक के रूप में एक स्ट्रिंग में जोड़ देता है , जो पाइप को iex(कम Invoke-Expressionऔर समान eval)। परिणाम या तो है 0, या गैर शून्य तो हम बूलियन नहीं ले !कि परिणाम की है, जो साधन या तो $TRUEया $FALSE(गैर शून्य PowerShell में पूर्णांक हैं truthy)। उस बूलियन को पाइपलाइन पर छोड़ दिया गया है और आउटपुट निहित है।

वैकल्पिक संस्करण, प्रत्येक 20 बाइट्स भी

param($a,$b)!($a%$b)
!($args[0]%$args[1])

एक ही अवधारणा, इनपुट को संरचित करने के थोड़े अलग तरीके। इन्हें प्रदान करने के लिए @DarthTwon को धन्यवाद।

उदाहरण

PS C:\Tools\Scripts\golfing> .\divisibility-test.ps1 24 12
True

PS C:\Tools\Scripts\golfing> .\divisibility-test.ps1 24 13
False

PS C:\Tools\Scripts\golfing> .\divisibility-test.ps1 12 24
False

— AdmBorkBork
स्रोत

अन्य दोनों विधियों में मैंने इस प्रश्न को param($a,$b)!($a%$b)!($args[0]%$args[1])

— टटोलने

@DarthTwon वास्तव में। जब छोटी मात्रा के संचालन से निपटते हैं, तो आमतौर पर इनपुट तर्कों को लेने के विभिन्न तरीकों में से एक या दो बाइट्स अंतर होते हैं।

— AdmBorkBork

मैं कुछ छोटे के साथ आने की उम्मीद कर रहा था: पी लेकिन हाँ, बिल्ली को त्वचा करने के कई तरीके हैं, खासकर पीएस में।

— thePoShWolf

3

हास्केल, 13 11 बाइट्स

((1>).).mod

यह एक नया कार्य परिभाषित करता है (!) :: Integral n => n -> n -> Bool। चूँकि mod n mकेवल सकारात्मक संख्याएँ लौटती हैं nऔर यदि mसकारात्मक हैं, तो हम 1>इसके बजाय का उपयोग करके एक बाइट बचा सकते हैं 0==।

उपयोग:

ghci> let n!d=1>mod n d
ghci> 100 ! 2
True
ghci> 100 ! 3
False

— जीटा
स्रोत

आप pointfree जाने के लिए और 2 बाइट्स बचा सकते हैं: ((1>).).mod।

— ०४:१०

विभाज्यता परीक्षण

कार्य

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

लीडरबोर्ड

जेली , 1 बाइट

ब्रेन-फ्लैक , 72 70 64 62 58 46 बाइट्स

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

मापांक गणना, 42 बाइट्स

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

स्टैक-साफ मापांक गणना, 64 बाइट्स

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

x86_32 मशीन कोड, 8 बाइट्स

हेक्सागोनी, 15, 13, 12 10 बाइट्स

ब्रेन-फ्लैक 102, 98, 96 बाइट्स

जावास्क्रिप्ट (ईएस 6 ) 17 12 11 बाइट्स

विम, 11 कीस्ट्रोक्स

गणितज्ञ - १ 3 १३ ३ बाइट्स

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

बैच, 20 बाइट्स

सी #, 27 13 12 बाइट्स

ब्रेनफक, 53 बाइट्स

ब्रेन-फ्लैक , 88 86 बाइट्स

LOLCODE, 74 64 बाइट्स

सी, 60 बाइट्स

Dyalog एपीएल , 3 बाइट्स

आर, 22 20 बाइट्स

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

पायथन, 16 बाइट्स

GolfScript, 3 बाइट्स

सीजाम, 6 4 बाइट्स

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

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

फोरट्रान 95, 78 बाइट्स

मारियोलैंग, 121 109 107 बाइट्स

Tcl, 34 बाइट्स

PHP, 23 22 बाइट्स

जे, 3 बाइट्स

PowerShell v2 +, 20 बाइट्स

वैकल्पिक संस्करण, प्रत्येक 20 बाइट्स भी

उदाहरण

हास्केल, 13 11 बाइट्स