क्या यह संख्या एक प्रमुख है?

Question

मानो या न मानो, हमारे पास अभी तक एक सरल प्राचीर परीक्षण के लिए एक कोड गोल्फ चुनौती नहीं है । हालांकि यह सबसे दिलचस्प चुनौती नहीं हो सकती है, विशेष रूप से "सामान्य" भाषाओं के लिए, यह कई भाषाओं में अनौपचारिक हो सकती है।

रोसेटा कोड में प्रायोगिक परीक्षण के लिए मुहावरेदार दृष्टिकोण की भाषा द्वारा सूचियों की सुविधा है, एक मिलर-राबिन परीक्षण का उपयोग करके विशेष रूप से और दूसरा परीक्षण प्रभाग का उपयोग करके । हालांकि, "सबसे मुहावरेदार" अक्सर "सबसे छोटा" के साथ मेल नहीं खाता है। प्रोग्रामिंग पजल्स और कोड गोल्फ को कोड गोल्फ के लिए गो-टू साइट बनाने के प्रयास में, यह चुनौती "हैलो, वर्ल्ड!" के समान ही हर भाषा में सबसे छोटे दृष्टिकोण के कैटलॉग को संकलित करने का प्रयास करती है । और आप महान अच्छे के लिए एक रानी गोल्फ! ।

इसके अलावा, एक मौलिक परीक्षण को लागू करने की क्षमता प्रोग्रामिंग भाषा की हमारी परिभाषा का हिस्सा है , इसलिए यह चुनौती साबित प्रोग्रामिंग भाषाओं की एक निर्देशिका के रूप में भी काम करेगी।

कार्य

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

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

आपका एल्गोरिथ्म निर्धारक होना चाहिए (यानी, संभावना 1 के साथ सही आउटपुट का उत्पादन करें) और, सिद्धांत रूप में, मनमाने ढंग से पूर्ण पूर्णांक के लिए काम करना चाहिए। व्यवहार में, आप मान सकते हैं कि इनपुट आपके डेटा प्रकार में संग्रहीत किया जा सकता है, जब तक कि प्रोग्राम 1 से 255 तक पूर्णांक के लिए काम करता है।

इनपुट

• यदि आपकी भाषा STDIN से पढ़ने में सक्षम है, तो कमांड-लाइन तर्क या उपयोगकर्ता इनपुट के किसी अन्य वैकल्पिक रूप को स्वीकार करें, आप पूर्णांक को इसके दशमलव प्रतिनिधित्व, एकात्मक प्रतिनिधित्व (अपनी पसंद के चरित्र का उपयोग करके), बाइट सरणी (बड़ा) के रूप में पढ़ सकते हैं थोड़ा एंडियन) या सिंगल बाइट (यदि यह आपकी भाषाओं का सबसे बड़ा डेटा प्रकार है)।

• यदि (और केवल अगर) आपकी भाषा किसी भी प्रकार के उपयोगकर्ता इनपुट को स्वीकार करने में असमर्थ है, तो आप अपने प्रोग्राम में इनपुट को हार्डकोड कर सकते हैं।

  इस मामले में, हार्डकोडेड पूर्णांक आसानी से विनिमेय होना चाहिए। विशेष रूप से, यह पूरे कार्यक्रम में केवल एक ही स्थान पर दिखाई दे सकता है।

  स्कोरिंग उद्देश्यों के लिए, उस प्रोग्राम को सबमिट करें जो इनपुट 1 से मेल खाता है ।

उत्पादन

आउटपुट को STDOUT या निकटतम विकल्प के लिए लिखा जाना है।

यदि संभव हो तो, आउटपुट में केवल एक सत्य या मिथ्या मूल्य (या एक स्ट्रिंग प्रतिनिधित्व) होना चाहिए, वैकल्पिक रूप से एक एकल नई पंक्ति।

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

अतिरिक्त नियम

• यह प्राइम टेस्टिंग के लिए सबसे छोटी एप्रोच वाली भाषा को खोजने के बारे में नहीं है, यह हर भाषा में सबसे छोटा तरीका खोजने के बारे में है। इसलिए, कोई जवाब स्वीकार के रूप में चिह्नित नहीं किया जाएगा।

• अधिकांश भाषाओं में प्रस्तुतियाँ बाइट्स में एक उपयुक्त preexisting एन्कोडिंग में बनाई जाएंगी , आमतौर पर (लेकिन जरूरी नहीं) UTF-8।

  उदाहरण के लिए, Piet भाषा , कोडल्स में बनाई जाएगी, जो इस भाषा के लिए स्वाभाविक पसंद है।

  कुछ भाषाएं, जैसे फ़ोल्डर , स्कोर करने के लिए थोड़ा मुश्किल हैं। यदि संदेह हो तो कृपया मेटा पर पूछें ।

• हमारे सामान्य नियमों के विपरीत, एक भाषा (या भाषा संस्करण) का उपयोग करने के लिए स्वतंत्र महसूस करें, भले ही यह इस चुनौती से नया हो। अगर कोई ऐसी भाषा का निर्माण करके इसका दुरुपयोग करना चाहता है, जहां खाली कार्यक्रम एक मौलिकता का परीक्षण करता है, तो बहुत ही उबाऊ उत्तर के लिए मार्ग प्रशस्त करने के लिए बधाई देता है।

  ध्यान दें कि एक दुभाषिया होना चाहिए ताकि सबमिशन का परीक्षण किया जा सके। यह अनुमति दी जाती है (और यहां तक ​​कि प्रोत्साहित किया जाता है) कि इस दुभाषिया को पहले से बिना पढ़ी हुई भाषा के लिए स्वयं लिखें।

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

• परीक्षण के लिए primality में निर्मित कार्यों कर रहे हैं की अनुमति दी। यह चुनौती प्रत्येक भाषा में सबसे कम संभव समाधान को सूचीबद्ध करने के लिए है, इसलिए यदि यह आपकी भाषा में अंतर्निहित उपयोग करने के लिए कम है, तो इसके लिए जाएं।

• जब तक कि उन्हें पहले से अधिलेखित नहीं किया गया है, सभी मानक कोड-गोल्फ नियम लागू होते हैं, जिसमें http://meta.codegolf.stackexchange.com/q/1061 शामिल है ।

एक साइड नोट के रूप में, कृपया उन भाषाओं में उबाऊ (लेकिन मान्य) उत्तर न दें जहां गोल्फ के लिए बहुत कुछ नहीं है; ये अभी भी इस प्रश्न के लिए उपयोगी हैं क्योंकि यह एक कैटलॉग को यथासंभव पूरा करने का प्रयास करता है। हालांकि, मुख्य रूप से उन भाषाओं में जवाब देते हैं जहां लेखक को वास्तव में कोड को गोल करने में प्रयास करना था।

सूची

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

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

## 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

<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 = 57617; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 12012; 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>

Comments

क्या मैं इनपुट को ऋणात्मक संख्याओं के रूप में ले सकता हूं, जहां एब्स (इनपुट) वह संख्या होगी जिसका मैं परीक्षण कर रहा हूं?

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

नहीं, इनपुट एक सख्ती से सकारात्मक पूर्णांक है।

— डेनिस

@LyndonWhite यह एक सूची के रूप में इरादा किया गया था (जैसे कि "हैलो, वर्ल्ड!" ) मौलिकता परीक्षण, इसलिए एक एकीकृत प्रस्तुत प्रारूप बेहतर लग रहा था। यह इस चुनौती के बारे में दो फैसलों में से एक है जो मुझे खेद है, अन्य केवल निर्धारक मौलिकता परीक्षण की अनुमति देता है।

— डेनिस

@ शैगी मेटा के लिए एक सवाल की तरह लगता है।

— डेनिस

हाँ, यही मैं सोच रहा था। मैं आपको सम्मान देने देता हूं, यह देखते हुए कि यह आपकी चुनौती है।

— शैगी

Answer 1

नमस्ते दुनिया! , १३

hello, world!

Comments

आप की तरह, था बस इस भाषा बनाने के लिए, बस इस प्रस्तुत करने के लिए? ;)

— ETHproductions

@ETHproductions लगता है कि 10 दिन पहले नवीनतम प्रतिबद्ध था।

— Geobits

मैं इसे कहीं भी लिंक करने से पहले भाषा को थोड़ा बेहतर आकार में लेने की उम्मीद कर रहा था, लेकिन यह चुनौती पोस्ट की गई और मैं विरोध नहीं कर सका।

— हिस्टोक्रेट

मैं लगभग यह कहूंगा कि 1 के इनपुट पर लटकना सही कार्यक्षमता है।

— Inotnotayaynard

इसके बारे में सबसे अच्छी बात यह है कि कार्यक्रम सिर्फ एक अंतर्निहित नहीं है, प्रत्येक चरित्र सही परिणाम प्राप्त करने में अपना हिस्सा निभाता है।

— ETHproductions

Answer 2

हेक्सागोनी , 29 बाइट्स

.?'.).@@/'/.!.>+=(<.!)}($>(<%

इस कोड का पठनीय संस्करण है:

   . ? ' .
  ) . @ @ /
 ' / . ! . >
+ = ( < . ! )
 } ( $ > ( <
  % . . . .
   . . . .

स्पष्टीकरण: यह परीक्षण करता है कि क्या 2 से n-1 तक की संख्या है जो n को विभाजित करता है।

प्रारंभ:

एक मेमोरी सेल में n और दूसरे में n-1 लिखें:

   . ? ' .
  . . . . .
 . . . . . .
+ = ( . . . .
 . . . . . .
  . . . . .
   . . . .

विशेष मामला n = 1:

0 प्रिंट करें और समाप्त करें

   . . . .
  . . . @ .
 . . . ! . .
. . . < . . .
 . . . . . .
  . . . . .
   . . . .

सूचित करते रहना

N% a की गणना करें और a को घटाएं। समाप्त करें यदि a = 1 या n% a = 0।

   . . . .
  ) . . . /
 ' / . . . >
. . . . . . .
 } ( $ > ( <
  % . . . .
   . . . .

केस ए = 1:

0 से 1 तक बढ़ाएं, इसे प्रिंट करें और समाप्त करें। (निर्देश सूचक NE दिशा में चलता है और पूर्वी कोने से दक्षिण पश्चिमी कोने तक जाता है। और $ यह सुनिश्चित करता है कि यह अगले आदेश की अनदेखी करता है)

   . . . .
  . . . @ .
 . . . ! . .
. . . < . . )
 . . $ . . <
  . . . . .
   . . . .

मामला% n = 0:

0 प्रिंट करें और समाप्त करें (अनुदेश सूचक SW चल रहा है और शीर्ष पर @ पर लूप करता है

   . . . .
  . . @ . .
 . . . . . >
. . . . . ! .
 . . . . . .
  . . . . .
   . . . .

Comments

पवित्र बकवास, यह एक प्रभावशाली पहली पोस्ट है। :) मैं अभी इनाम रखूंगा (मैं इसे 7 दिनों में पुरस्कृत करूंगा, अपने उत्तर पर कुछ और ध्यान आकर्षित करने के लिए)। PPCG में आपका स्वागत है!

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

बहुत बढ़िया जवाब! +1 के लिए " इस कोड का पठनीय संस्करण है: <...> " :-)

— 7

Answer 3

हेक्सागोनी , 218 92 58 55 बाइट्स

सूचना: इस उत्तर को Etoplay द्वारा एक साइड-लंबाई 4 समाधान के साथ ठोस रूप से पीटा गया है ।

)}?}.=(..]=}='.}.}~./%*..&.=&{.<......=|>(<..}!=...&@\[

पहले गैर-तुच्छ (यानी गैर-रैखिक) हेक्सागोनी कार्यक्रम! यह उसी वर्ग-तथ्यात्मक दृष्टिकोण पर आधारित है जो Sp3000 के भूलभुलैया उत्तर के रूप में है । आकार 10 के एक षट्भुज के साथ शुरू करने के बाद, मैंने इसे आकार 5 में संपीड़ित करने में कामयाब रहा। हालांकि, मैं कुछ डुप्लिकेट कोड का पुन: उपयोग करने में सक्षम था और कोड में अभी भी काफी ऑप्स नहीं हैं, इसलिए आकार 4 बस हो सकता है संभव है।

व्याख्या

कोड की समझ बनाने के लिए, हमें पहले इसे प्रकट करना होगा। हेक्सागोनी अगले स्रोत वाले हेक्सागोनल संख्या के लिए किसी भी स्रोत कोड को बिना ऑप्स ( .) के साथ पैड करता है, जो है 61। इसके बाद कोड को इसी आकार के एक नियमित षट्भुज में बदल दिया जाता है:

     ) } ? } .
    = ( . . ] =
   } = ' . } . }
  ~ . / % * . . &
 . = & { . < . . .
  . . . = | > ( <
   . . } ! = . .
    . & @ \ [ .
     . . . . .

यह क्रॉसिंग और ओवरलैपिंग निष्पादन पथ और कई अनुदेश बिंदुओं (आईपी) के साथ काफी भारी है। यह समझने के लिए कि यह कैसे काम करता है, आइए पहले एक अनगुल्ड संस्करण देखें जहां नियंत्रण प्रवाह किनारों से नहीं जाता है, केवल एक आईपी का उपयोग किया जाता है और निष्पादन पथ यथासंभव सरल हैं:

             . . . . . . . . . . . . .
            . . . . . . . . . . . . . .
           . . . . . . . . . . . . . . .
          . . . . . . . . . . @ . . . . .
         . . . . . . . . . . ! . . . . . .
        . . . . . . . . . . % . . . . . . .
       . . . . . . . . . . ' . . . . . . . .
      . . . . . . . . . . & . . . . . . . . .
     . . . . . . . . . . { . . . . . . . . . .
    . . . . . . . . . . * . . . . . . . . . . .
   . . . . . . . . . . = . . . . . . . . . . . .
  . . . . . . . . . . } . . . . . . . . . . . . .
 ) } ? } = & { < . . & . . . . . . . . . . . . . .
  . . . . . . . > ( < . . . . . . . . . . . . . .
   . . . . . . = . . } . . . . . . . . . . . . .
    . . . . . } . . . = . . . . . . . . . . . .
     . . . . | . . . . | . . . . . . . . . . .
      . . . . * . . . ) . . . . . . . . . . .
       . . . . = . . & . . . . . . . . . . .
        . . . . > } < . . . . . . . . . . .
         . . . . . . . . . . . . . . . . .
          . . . . . . . . . . . . . . . .
           . . . . . . . . . . . . . . .
            . . . . . . . . . . . . . .
             . . . . . . . . . . . . .

^{साइड नोट: उपरोक्त कोड पहली पंक्ति को निष्पादित करने से शुरू होता है, जो बिना ऑप्स से भरा होता है। फिर, जब आईपी उत्तर पूर्व किनारे से टकराता है, तो यह बाएं-सबसे कोने ( )) पर जाता है, जहां वास्तविक कोड शुरू होता है।}

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

हम किनारे A पर भाज्य की गणना करेंगे , किनारे C पर हमारे इनपुट की गणना करेंगे और किनारे D पर इनपुट (मॉडुलो के लिए) की एक और प्रतिलिपि संग्रहीत करेंगे । बी का उपयोग कम्प्यूटेशन के लिए एक अस्थायी किनारे के रूप में किया जाता है।

मेमोरी पॉइंटर (MP) किनारे A पर शुरू होता है और उत्तर की ओर (यह MP को घूमने के लिए महत्वपूर्ण है)। अब यहाँ कोड का पहला बिट है:

)}?}=&{

)किनारे की वृद्धि कर एक को 1भाज्य के आधार के रूप में। }एमपी को राइट-टर्न लेते हैं, यानी किनारे पर जाते हैं सी (उत्तर-पूर्व की ओर इशारा करते हुए)। यहां हम इनपुट को पूर्णांक के रूप में पढ़ते हैं ?। फिर हम एक और किनारे करने के लिए राइट बारी बारी से विकास के साथ }। =एमपी को उलट देता है, जैसे कि यह सी के साथ साझा किए गए शीर्ष पर इंगित करता है । &मूल्य को C (इनपुट) से D में कॉपी करता है - मान को बाईं ओर से कॉपी किया जाता है क्योंकि वर्तमान मान गैर-धनात्मक (शून्य) है। अंत में, हम सांसद को C के साथ एक बाएं-मुड़ते हैं {।

अगला, <तकनीकी रूप से एक शाखा है, लेकिन हम जानते हैं कि वर्तमान मूल्य सकारात्मक है, इसलिए आईपी हमेशा सही दिशा में बदल जाएगा >। पक्ष से एक शाखा दर्पण के रूप में कार्य करती है, जैसे कि आईपी क्षैतिज रूप से फिर से आगे बढ़ता है (, जो C में मान को घटाता है ।

अगले शाखा, <है वास्तव में अब एक शाखा। यह है कि हम n-1नीचे से कैसे लूप करते हैं 1। जबकि C में वर्तमान मान धनात्मक है, IP एक राइट-टर्न लेता है (लूप निष्पादित करने के लिए)। एक बार जब हम शून्य से टकराते हैं, तो यह बायीं ओर मुड़ जाएगा।

चलो लूप "बॉडी" को देखें। |सरल दर्पण हैं, >और <भी फिर से दर्पण के रूप में उपयोग किया जाता है। इसका मतलब है कि वास्तविक लूप बॉडी को फोड़ा जाता है

}=)&}=*}=

}बी को किनारे करने के लिए एमपी को स्थानांतरित करता है , =शीर्ष एबीसी का सामना करने के लिए अपनी दिशा को उलट देता है । )मूल्य में वृद्धि: यह केवल पहले पुनरावृत्ति के लिए प्रासंगिक है, जहां B का मूल्य अभी भी शून्य है: हम यह सुनिश्चित करना चाहते हैं कि यह सकारात्मक हो, जैसे कि अगला निर्देश सही पड़ोसी को &कॉपी करता है, यानी A , यानी वर्तमान मान संगणना, बी में ।

}इसके बाद MP को A पर ले जाता है , =सामान्य वर्टेक्स का सामना करने के लिए इसे फिर से उलट देता है। *दोनों पड़ोसी अर्थात किनारों B और C को गुणा करता है और परिणाम को A में संग्रहीत करता है । अंत में, हमारे पास सी}= पर लौटने के लिए एक और है , अभी भी शीर्ष पर एबीसी का सामना करना पड़ रहा है ।

मुझे आशा है कि आप देख सकते हैं कि यह एn-1 में फैक्टरियल की गणना कैसे करता है ।

तो अब हमने किया है कि, C में लूप काउंटर शून्य है। हम फैक्टरियल को वर्गाकार करना चाहते हैं और फिर इनपुट के साथ मोड्यूलो लेना चाहते हैं। यही कोड करता है:

&}=*{&'%!@

चूंकि सी शून्य है, &बाएं पड़ोसी को कॉपी करता है, अर्थात ए में फैक्टरियल । }=*करने के लिए ले जाता है बी और में भाज्य (यानी वर्ग) की दो प्रतियों में उत्पाद संग्रहीत करता है बी । C पर{ वापस जाता है , लेकिन MP को उलट नहीं करता है। हम जानते हैं कि वर्तमान मूल्य अब सकारात्मक है, इसलिए D से C में &इनपुट की प्रतिलिपि बनाता है । MP पीछे की तरफ यानी की A पर है । याद रखें, भाज्य का वर्ग B में है और इनपुट C में है । तो गणना करता है , वास्तव में हम क्या देख रहे हैं।'%(n-1)!^2 % n!परिणाम को पूर्णांक (0 या 1) के रूप में प्रिंट करता है और @प्रोग्राम को समाप्त करता है।

---

ठीक है, लेकिन वह अनगढ़ संस्करण था। गोल्फ संस्करण के बारे में क्या? आपको हेक्सागोनी के बारे में दो और बातें जानने की जरूरत है:

1. किनारों के चारों ओर लपेटते हैं। यदि आईपी षट्भुज के एक किनारे से टकराता है, तो यह विपरीत किनारे पर कूदता है। यह तब अस्पष्ट होता है जब आईपी एक कोने पर सीधा टकराता है, इसलिए एक कोने से टकराना भी एक शाखा के रूप में कार्य करता है: यदि वर्तमान मूल्य सकारात्मक है, तो आईपी ग्रिड के किनारे पर अपने दाईं ओर कूदता है, अन्यथा उसके बाईं ओर।
2. वास्तव में 6 आईपी ​​हैं। उनमें से प्रत्येक एक अलग कोने में शुरू होता है, जो घड़ी की दिशा में किनारे के साथ आगे बढ़ता है। उनमें से केवल एक ही समय में सक्रिय है, जिसका अर्थ है कि आप अन्य 5 आईपी को अनदेखा कर सकते हैं यदि आप उन्हें नहीं चाहते हैं। आप अगले आईपी (घड़ी की दिशा में) के साथ ]और पिछले एक के साथ स्विच कर सकते हैं [। (आप किसी विशिष्ट व्यक्ति को भी चुन सकते हैं #, लेकिन वह दूसरी बार है।)

इसमें कुछ नए कमांड भी हैं: \और /जैसे दर्पण हैं |, और ~वर्तमान मूल्य को गुणा करता है -1।

तो कैसे ungolfed संस्करण गोल्फ वाले के लिए अनुवाद करता है? रैखिक सेट अप कोड )}?}=&{और बुनियादी लूप संरचना यहां पाई जा सकती है:

        ) } ? } .  ->
       . . . . . .
      . . . . . . .
     . . . . . . . .
->  . = & { . < . . .
     . . . . . > ( <
      . . . . . . .
       . . . . . .
        . . . . .

अब लूप बॉडी किनारों को कुछ बार पार करता है, लेकिन सबसे महत्वपूर्ण बात, वास्तविक गणना पिछले आईपी (जो बाएं कोने से शुरू होती है, उत्तर पूर्व की ओर चलती है) को सौंप दिया जाता है:

        ) . . . .
       = . . . ] .
      } = . . } . .
     ~ . / . * . . .
    . . . . . . . . .
     . . . = . > ( <
      . . } . = . .
       . & . \ [ .
        . . . . .

दक्षिण पूर्व की ओर शाखा को उछाल देने के बाद, आईपी ऊपरी किनारे =पर बाएं कोने में दो के लिए घूमता है (जो, एक साथ, एक नो-ऑप हैं), फिर बंद हो जाता है /। ~वर्तमान मूल्य है, जो बाद पुनरावृत्तियों के लिए महत्वपूर्ण है के हस्ताक्षर उलट। आईपी ​​फिर से एक ही किनारे पर घूमता है और अंत में हिट होता है [जहां नियंत्रण दूसरे आईपी को सौंप दिया जाता है।

यह एक अब क्रियान्वित करता है ~}=)&}=*}जो नकार को उजागर करता है और फिर सिर्फ अनप्लग्ड लूप बॉडी (माइनस =) चलाता है । अंत में यह हिट करता है ]जो मूल आईपी पर वापस नियंत्रण करता है। (ध्यान दें कि अगली बार, हम इसे इस आईपी को निष्पादित करते हैं, यह वहीं से शुरू होगा जहां से छोड़ा था, इसलिए यह पहली बार कोने से टकराएगा। हमें आईपी के लिए उत्तर पश्चिम किनारे पर वापस जाने के लिए वर्तमान मूल्य नकारात्मक होने की आवश्यकता है। दक्षिण पूर्व की बजाय।)

एक बार जब मूल आईपी नियंत्रण को फिर से शुरू करता है, तो यह बंद हो जाता है \, शेष को निष्पादित करता है =और फिर >अगले लूप पुनरावृत्ति में खिलाता है।

अब वास्तव में पागल हिस्सा: क्या होता है जब लूप समाप्त हो जाता है?

        ) . . . .
       . ( . . ] =
      . . ' . } . }
     . . . % * . . &
    . . . . . . . . .
     . . . = | . . <
      . . } ! . . .
       . & @ . . .
        . . . . .

आईपी ​​उत्तर पूर्व की ओर बढ़ता है <और उत्तर पूर्वी विकर्ण के चारों ओर घूमता है। तो यह लूप बॉडी ( &}=*}]) के समान निष्पादन पथ पर समाप्त होता है । जो वास्तव में बहुत अच्छा है, क्योंकि यही वह कोड है जिसे हम इस बिंदु पर निष्पादित करना चाहते हैं, कम से कम अगर हम एक और जोड़ते हैं =}(क्योंकि }=}बराबर है {)। लेकिन यह वास्तव में पहले लूप में फिर से कैसे प्रवेश नहीं करता है? क्योंकि ]अगले आईपी में परिवर्तन जो अब (अब तक अप्रयुक्त) आईपी है जो दक्षिण पश्चिम की ओर बढ़ते हुए दाएं कोने में शुरू होता है। वहां से, आईपी किनारे के साथ जारी रहता है, शीर्ष बाएं कोने में लपेटता है, विकर्ण को नीचे ले जाता है, बंद होता है |और @अंतिम बिट रैखिक कोड निष्पादित करते समय समाप्त होता है :

=}&)('%!@

( )(निश्चित रूप से एक नो-ऑप है - मुझे इसमें जोड़ना था (क्योंकि )पहले से ही था।)

काहे ... क्या गड़बड़ ...

Comments

अच्छा! यह कितना नया है? इसके अलावा, जब भी आपको एक स्थिर रिलीज़

— मिले

@ mbomb007 मैंने दो दिन पहले भाषा को लागू किया (और इसे दो या तीन दिन पहले डिज़ाइन किया गया था)। और हाँ, मैं निश्चित रूप से एक esolangs पृष्ठ जोड़ूंगा, लेकिन मुझे लगता है कि कल्पना अभी भी 100% स्थिर नहीं है (उदाहरण के लिए अभी भी 3 अनसाइनड कमांड हैं)। एक बार जब मुझे लगता है कि यह अधिक स्थिर है, तो मैं इसे esolangs और हमारे मेटा पोस्ट दोनों में जोड़ दूँगा।

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

विस्तारित हेक्स के तहत यह बाएं-सबसे कोने ( 1) के लिए लपेटता है । 1आप वहां क्या बात कर रहे हैं?

— mbomb007

@ mbomb007 तय की। हुआ करता था )a 1।

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

यह कैसे काम करता है, इसकी व्याख्या में केवल विस्तार के स्तर के लिए +1। यदि अधिक भाषाएँ एक उदाहरण के साथ आईं जो कि अधिक से अधिक लोग उनका उपयोग कर सकते थे: D

— jdarling

Answer 4

अजगर, 4 बाइट्स

}QPQ

प्रिंटों Trueया False।

Comments

मुझे पता है कि यह पुराना है लेकिन अब आप ऐसा भी कर सकते हैं: P_Q और 1 बाइट बचाएं।

— drobilc

अब यह संभव हैP_

— ब्लू

@drobilc आप Q को काट सकते हैं, एक EOF के रूप में जब फ़ंक्शन एक तर्क की उम्मीद कर रहा है, तो यह इनपुट का उपयोग करता है

— Stan Strum

Answer 5

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

^(?!(..+)\1+$)..

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

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

एक एकल लाइन से मिलकर रेटिना प्रोग्राम उस रेखा को एक रेक्सैक्स के रूप में मानता है और इनपुट में पाए जाने वाले मिलानों की संख्या को प्रिंट करता है, जो कि 0समग्र संख्याओं और 1primes के लिए होगा।

लुकहेड सुनिश्चित करता है कि इनपुट समग्र नहीं है: बैकट्रैकिंग हर संभव विकल्प (कम से कम 2 वर्णों के लिए) की कोशिश करेगी (..+), लुकहेड फिर बाकी इनपुट से मिलान करने का प्रयास करता है जो यहां कैप्चर किया गया था। यदि यह संभव है, तो इसका मतलब है कि इनपुट में 1 से अधिक भाजक है, लेकिन जो स्वयं से कम है। अगर ऐसा है तो नकारात्मक लुकहेड मैच के विफल होने का कारण बनता है। Primes के लिए ऐसी कोई संभावना नहीं है, और मैच जारी है।

एकमात्र मुद्दा यह है कि यह लुकहैड भी स्वीकार करता है 1, इसलिए हम इस पर शासन करते हैं कि कम से कम दो पात्रों के साथ मेल खाते हैं ..।

Comments

यह वास्तव में एक अनियमित अभिव्यक्ति है, क्योंकि प्राइम नियमित भाषा नहीं बनाते हैं।

— PyRulez

@PyRulez अधिकांश वास्तविक-विश्व regex जायके नियमित अभिव्यक्तियों की सैद्धांतिक अवधारणा से बहुत अधिक शक्तिशाली हैं। मैंने हालांकि शब्दांकन में सुधार किया।

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

सबसे शक्तिशाली "रेगेक्स" इंजन अभी बाहर खुले में है, जिसमें एक लीनियर बाउंड ऑटोमेटा के बराबर मान्यता शक्ति है। स्टैंडर्ड इश्यू रेगेक्स, पैटर्न रिकर्सन, अनलिमिटेड लुकहैड और अनलिमिटेड लुकबाइंड आप सभी को संदर्भ-संवेदनशील पार्सिंग (हालांकि बैकरेफरेंस और आमतौर पर कुशल पार्सिंग को जटिल बनाने में मदद करते हैं) की आवश्यकता होती है, और कुछ में यह सब होता है। यहां तक ​​कि मुझे उन इंजनों पर भी शुरू न करें, जो आपको regex में कोड एम्बेड करने देते हैं।

— eaglgenes101

Answer 6

CJam, 4 बाइट्स

qimp

CJam में एक परिचालक है, जो परिक्षण परीक्षण के लिए है।

Comments

वैकल्पिक रूप से:limp

— 15

pimpमेरा सीजेएम

— 18

pimpउद्देश्यपूर्ण रूप से अधिक दलाल है

— मिकेल

आप यह भी कर सकते हैंl~mp

— गायों ने

@ कोको, qइनपुट की एक पंक्ति पढ़ता है, iइसे पूर्णांक के रूप में पार्स करता है, और mpअंतर्निहित है। CJam में दो-चार बिल्ट-इन के दो समूह हैं: "विस्तारित" वाले शुरू होते हैं eऔर "गणितीय" शुरू होते हैंm

— पीटर टेलर

Answer 7

HTML + CSS, 254 + n _{अधिकतम} * 28 बाइट्स

हम नियमित भावों का उपयोग करके प्राणशक्ति की जाँच कर सकते हैं। मोज़िला के @documentरूप में परिभाषित किया गया है:

@document [ <url> | url-prefix(<string>) | domain(<string>) | regexp(<string>) ]# {
  <group-rule-body>
}

वर्तमान URL के आधार पर CSS के माध्यम से तत्वों को फ़िल्टर करने के लिए। यह एक एकल पास है, इसलिए हमें दो चरण करने होंगे:

1. उपयोगकर्ता से इनपुट प्राप्त करें। यह इनपुट किसी तरह वर्तमान URL में परिलक्षित होना चाहिए।
2. उपयोगकर्ता को यथासंभव कम कोड का उत्तर दें।

1. इनपुट प्राप्त करना

सबसे छोटा तरीका है कि मैं इनपुट प्राप्त कर सकता हूं और उसे URL में स्थानांतरित कर सकता हूं जो GETचेकबॉक्स के साथ एक रूप है। रेगेक्स के लिए, हमें दिखावे को गिनने के लिए कुछ अद्वितीय स्ट्रिंग की आवश्यकता है।

तो हम इसके साथ शुरू करते हैं (61 बाइट्स):

<div id=q><p id=r>1<p id=s>0</div><form method=GET action=#q>

हमें <p>यह इंगित करने के लिए दो अद्वितीय एस मिले कि क्या दर्ज संख्या एक प्राइम (1) है या नहीं (0)। हम फॉर्म को भी परिभाषित करते हैं और यह कार्रवाई है।

समान नाम वाले n _{अधिकतम} चेकबॉक्स द्वारा अनुसरण किया गया (n _{अधिकतम} * 28 बाइट्स):

<input type=checkbox name=i>

प्रस्तुत तत्व (34 बाइट्स) के बाद:

<input name=d value=d type=submit>

2. उत्तर प्रदर्शित करें

<p>प्रदर्शन (1 या 0) का चयन करने के लिए हमें CSS (159 बाइट्स) की आवश्यकता है :

#q,#s,#q:target{display:none}#q:target{display:block}@-moz-document regexp(".*\\?((i=on&)?|(((i=on&)(i=on&)+?)\\4+))d=d#q$"){#s{display:block}#r{display:none}}

---

»इसे codepen.io (केवल फ़ायरफ़ॉक्स) पर आज़माएँ

Comments

+1: यह HTML का मेरा सर्वकालिक पसंदीदा दुरुपयोग है, और उस तरह का सामान जो मुझे कोडगोल्फ से प्यार करता है।

— बिल्ली

यह निश्चित रूप से दिलचस्प है, लेकिन मुझे यकीन नहीं है कि यह इस चुनौती के नियमों को संतुष्ट करता है। विशेष रूप से, मुझे नहीं लगता कि यह आपके एल्गोरिथ्म का अनुपालन करता है [...], सिद्धांत रूप में, मनमाने ढंग से बड़े पूर्णांकों के लिए काम करना चाहिए। क्या आप इनपुट क्षेत्र के मूल्य पर भी रेगेक्स का उपयोग नहीं कर सकते थे?

— डेनिस

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

— mınxomaτ

क्यों नहीं? यदि आपके पास इनपुट क्षेत्र में एक नंबर नहीं है, तो आपका कोड अब अधिकतम संख्या पर निर्भर नहीं करेगा।

— डेनिस

हम्म, मैंने इस बारे में थोड़ा और सोचा, और वास्तव में केवल एक्स चेकबॉक्स और एक दुभाषिया के बीच कोई अंतर नहीं है जिसमें केवल वाई-बिट संख्या है। मेरी पिछली टिप्पणी की अवहेलना करें।

— डेनिस

Answer 8

मदद, WarDoq! , 1 बाइट

P

आउटपुट 1 यदि इनपुट प्रधान है, तो अन्यथा।

Answer 9

हेक्सागोनी , 28 बाइट्स

चूँकि Etoplay ने मुझे इस प्रश्न पर पूरी तरह से रौंद दिया था , इसलिए मुझे लगा कि मुझे उसका केवल एक और उत्तर देना है ।

?\.">"!*+{&'=<\%(><.*.'(@>'/

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

मैं विल्सन के प्रमेय का उपयोग करता हूं, जैसे मार्टिन ने अपने उत्तर में दिया : दिया n, आई आउटपुट(n-1!)² mod n

यहाँ यह कार्यक्रम सामने आया:

   ? \ . "
  > " ! * +
 { & ' = < \
% ( > < . * .
 ' ( @ > ' /
  . . . . .
   . . . .

और यहाँ पठनीय संस्करण है:

स्पष्टीकरण:

कार्यक्रम के तीन मुख्य चरण हैं: प्रारंभिककरण , कारक और आउटपुट ।

हेक्सागोनी का मेमोरी मॉडल एक अनंत हेक्सागोनल ग्रिड है। मैं 5 स्मृति स्थानों का उपयोग कर रहा हूं, जैसा कि इस चित्र में दिखाया गया है:

मैं उस आरेख पर उनके लेबल द्वारा इन स्थानों (और उन में संग्रहीत इंजीगरों) का जिक्र करूंगा।

initialisation:

इंस्ट्रक्शन पॉइंटर ( आईपी ) पूर्व बाएं कोने पर शुरू होता है, पूर्व की ओर। मेमोरी पॉइंटर ( MP ) IN पर शुरू होता है ।

सबसे पहले, ?इनपुट से संख्या पढ़ता है और इसे IN में संग्रहीत करता है । आईपी नीले पथ, से परिलक्षित पर रहता है \। अनुक्रम "&(चाल सांसद पीठ और (करने के लिए बाईं ओर एक ), प्रतियां से मूल्य में करने के लिए एक और यह decrements।

आईपी तो षट्भुज के एक तरफ बाहर निकल जाता है और दूसरी तरफ (हरा पथ पर) फिर से प्रवेश करती है। यह निष्पादित करता है '+जो एमपी को बी में ले जाता है और जो ए में था उसे कॉपी करता है । आईपी को पश्चिम में <पुनर्निर्देशित करता है ।

क्रमगुणित:

मैं एक विशिष्ट तरीके से भाज्य की गणना करता हूं, ताकि यह आसान हो जाए। मैं बी और सीn-1! दोनों में स्टोर करता हूं ।

अनुदेश सूचक पूर्व की ओर बढ़ते हुए नीले रास्ते पर शुरू होता है।

='एमपी की दिशा को उलट देता है और इसे सी की ओर पीछे ले जाता है । यह बराबर है, {=लेकिन बाद में =यह मददगार था।

&{A से C के मान की प्रतिलिपि बनाता है , फिर MP को A में वापस ले जाता है । आईपी तो कुछ नहीं कर रहे, लाल, पथ तक पहुँचने से टकराने से पहले हरी पथ का अनुसरण, \और नारंगी मार्ग पर जा रहा है।

इसके साथ (>, हम A को घटाते हैं और IP East को रीडायरेक्ट करते हैं । यहाँ यह एक शाखा को हिट करता है <:। सकारात्मक ए के लिए , हम नारंगी पथ के साथ जारी रखते हैं। अन्यथा आईपी को नॉर्थ-ईस्ट का निर्देशन मिलता है।

'*MP को B में ले जाता है और A * C को B में संग्रहीत करता है । यह वह (n-1)*(n-2)जगह है जहां प्रारंभिक इनपुट था n। आईपी तो प्रारंभिक पाश में वापस प्रवेश करती है और decrementing और जब तक गुणा जारी है एक पहुँच 0। (कंप्यूटिंग n-1!)

नायब : निम्नलिखित छोरों पर, &से मूल्य संग्रहीत करता है बी में सी , के रूप में सी अब यह में संग्रहीत एक सकारात्मक मूल्य है। यह तथ्यात्मक कंप्यूटिंग के लिए महत्वपूर्ण है।

आउटपुट:

जब ए पहुंचता है 0। शाखा इसके बजाय नीले रास्ते के साथ आईपी ​​को निर्देशित करती है ।

=*MP को उलट देता है और A में B * C का मान संग्रहीत करता है । फिर आईपी षट्भुज से बाहर निकलता है और हरे रास्ते पर फिर से प्रवेश करता है; अमल करना । यह MP को OUT में ले जाता है और A mod IN , या की गणना करता है ।"%(n-1!)² mod n

निम्नलिखित {"एक नो-ऑप के रूप में कार्य करता है, क्योंकि वे एक-दूसरे को रद्द करते हैं। !अंतिम आउटपुट प्रिंट करता है और *+'(समाप्ति से पहले निष्पादित किया जाता है @:।

निष्पादन के बाद, (इनपुट के साथ 5) मेमोरी इस तरह दिखती है:

_{टिमवी के हेक्सागोनी कलरोर का उपयोग करके नियंत्रण प्रवाह की सुंदर छवियां बनाई गई थीं ।}

^{सभी चित्रों को बनाने के लिए मार्टिन एंडर को धन्यवाद , क्योंकि मैं इसे अपने पीसी पर नहीं कर सका।}

Comments

आप इन मेमोरी आरेखों के लिए क्या उपयोग कर रहे हैं? मैंने Esoteric IDE देखा है, लेकिन मैं इसे चलाने के लिए नहीं मिला ...

— NieDzejkob

@NieDzejkob आप मार्टिन से चैट में पूछना बेहतर समझते हैं, क्योंकि उसने उन्हें मेरे लिए वैसे भी बनाया है।

— H.PWiz

@NieDzejkob हाँ, मेमोरी आरेख को EsoIDE से निर्यात किया जा सकता है। अगर आप इस बारे में कुछ और चैट करना चाहते हैं, तो chat.stackexchange.com/rooms/27364/… ।

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

Answer 10

मॉर्निंगटन क्रिसेंट , 2448 बाइट्स

हम लंदन में वापस आ गए हैं!

Take Northern Line to Bank
Take Circle Line to Bank
Take District Line to Parsons Green
Take District Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upney
Take District Line to Hammersmith
Take Circle Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Aldgate
Take Circle Line to Aldgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Aldgate
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take Circle Line to Notting Hill Gate
Take Circle Line to Hammersmith
Take Circle Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Victoria
Take Circle Line to Temple
Take Circle Line to Aldgate
Take Circle Line to Aldgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Pinner
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Pinner
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Pinner
Take Metropolitan Line to Aldgate
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Victoria
Take Circle Line to Aldgate
Take Circle Line to Victoria
Take Circle Line to Victoria
Take District Line to Upminster
Take District Line to Embankment
Take Circle Line to Embankment
Take Northern Line to Angel
Take Northern Line to Moorgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Aldgate
Take Circle Line to Aldgate
Take Circle Line to Cannon Street
Take District Line to Upney
Take District Line to Cannon Street
Take District Line to Acton Town
Take District Line to Acton Town
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Hammersmith
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Ruislip
Take Piccadilly Line to Ruislip
Take Metropolitan Line to Preston Road
Take Metropolitan Line to Aldgate
Take Circle Line to Aldgate
Take Circle Line to Cannon Street
Take Circle Line to Aldgate
Take Circle Line to Aldgate
Take Metropolitan Line to Preston Road
Take Metropolitan Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Mornington Crescent

Timwi तो नियंत्रण प्रवाह स्टेशनों को लागू करने की तरह था Templeऔर Angelमें गूढ़ आईडीई के साथ-साथ भाषा विनिर्देश के इनपुट और पूर्णांक पार्स जोड़ें।

यह "हेलो, वर्ल्ड!" की तुलना में शायद बेहतर है, क्योंकि इस बार मैंने किसी भी दो स्टेशनों के बीच सबसे छोटा रास्ता खोजने में मदद करने के लिए सीजेएम स्क्रिप्ट लिखी। यदि आप इसका उपयोग करना चाहते हैं (हालांकि मुझे नहीं पता कि कोई भी क्यों करना चाहेगा ...), आप ऑनलाइन दुभाषिया का उपयोग कर सकते हैं । इस कोड को चिपकाएँ:

"Mornington Crescent"
"Cannon Street"
]qN/{'[/0=,}$:Q;{Q{1$#!}=\;_oNo'[/1>{']/0="[]"\*}%}%:R;NoQ{R\f{f{\#)}:+}:*},N*

यहां पहली दो लाइनें वे स्टेशन हैं जिनकी आप जांच करना चाहते हैं। इसके अलावा, इस पेस्टबिन की सामग्री को इनपुट विंडो में पेस्ट करें ।

आउटपुट आपको दिखाएगा कि कौन सी लाइनें दो स्टेशनों पर उपलब्ध हैं, और फिर सभी स्टेशनों की एक सूची जो स्टेशन के नामों की लंबाई के आधार पर दोनों को जोड़ती है। यह उन सभी को दिखाता है, क्योंकि कभी-कभी एक लंबे नाम का उपयोग करना बेहतर होता है, या तो क्योंकि यह एक छोटी रेखा की अनुमति देता है, या क्योंकि स्टेशन विशेष है (जैसे बैंक या मंदिर) ताकि आप इससे बचना चाहते हैं। कुछ किनारे मामले हैं जहां दो स्टेशन किसी अन्य स्टेशन (विशेष रूप से, मेट्रोपॉलिटन और जिला लाइनों को कभी भी पार नहीं करते) से जुड़े हुए हैं, ऐसे मामले में आपको कुछ और पता लगाना होगा। ;)

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

एक मुद्दा यह है कि छोरों करते हैं, जबकि छोरों, और decrementing और वेतन वृद्धि महंगी है, इसलिए मैं आसानी से गणना नहीं कर सकता (n-1)!(के लिए n > 0)। इसके बजाय, मैं कंप्यूटिंग कर रहा हूं n!और फिर nअंत में विभाजित करता हूं । मुझे यकीन है कि इसके लिए एक बेहतर समाधान है।

जब मैंने यह लिखना शुरू किया, तो मुझे लगा कि -1हैमरस्मिथ में भंडारण एक अच्छा विचार होगा, इसलिए मैं और अधिक सस्ते में वेतन वृद्धि कर सकता हूं, लेकिन अंत में इससे अधिक लागत बच सकती है। अगर मुझे इसे फिर से तैयार करने का धैर्य मिल जाए, -1तो मैं इसके बजाय सिर्फ उपमिनस्टर में आस-पास रखने की कोशिश कर सकता हूं ताकि मैं हैमरस्मिथ का उपयोग कुछ और उपयोगी के लिए कर सकूं।

Comments

क्या लंदन पूरा हो गया है?

— रोहन झुनझुनवाला

@ रोहन झुनझुनवाला शायद

— मार्टिन

वाह! मैं अच्छी तरह से सोचा सवालों को देखकर प्यार करता हूँ। मुझे विशेष रूप से उन प्रश्नों को देखकर बहुत अच्छा लगता है जहाँ आपको प्रोग्राम लिखने के लिए प्रोग्राम लिखना है।

— रोहन झुनझुनवाला

Answer 11

ब्रेकीलॉग (V2), 1 बाइट

ṗ

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

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

#p

यह अंतर्निहित विधेय का उपयोग करता है #p - Prime, जो इसके इनपुट को एक प्रमुख संख्या बनाता है।

Brachylog, Prolog का एक कोड गोल्फ संस्करण बनाने का मेरा प्रयास है, जो कि एक घोषणात्मक कोड गोल्फ भाषा है जो बैकट्रैकिंग और एकीकरण का उपयोग करता है।

बिना बिल्ट-इन: 14 बाइट्स के साथ वैकल्पिक समाधान

ybbrb'(e:?r%0)

यहाँ ऊपर दिए गए कोड का विराम है:

y            The list [0, …, Input]
bbrb         The list [2, …, Input - 1]
'(           True if what's in the parentheses cannot be proven; else false
     e           Take an element from the list [2, …, Input - 1]
     :?r%0       The remainder of the division of the Input but that element is 0
)

Comments

आप इस के Brachylog 2 संस्करण को पोस्ट में संपादित करना चाह सकते हैं, यह भी कि अब सिंटैक्स एक बाइट कम है।

@ ais523 सच, किया।

— घातक

क्या ब्रेकीलॉग 2 जवाब चुनौती को स्थगित करता है?

— स्कॉट मिलनर

@ScottMilner हां, लेकिन यह इस चुनौती में स्पष्ट रूप से अनुमति दी गई है: "हमारे सामान्य नियमों के विपरीत, एक भाषा (या भाषा संस्करण) का उपयोग करने के लिए स्वतंत्र महसूस करें, भले ही यह इस चुनौती से नया हो"

— 16:17 पर घातक

Answer 12

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

विल्सन के प्रमेय के लिए xnor की कोरोलरी का उपयोग करना :

main=do n<-readLn;print$mod(product[1..n-1]^2)n>0

Comments

क्या ऐसा करना कम नहीं होगा main=interact$\n-> ...?

— जॉन ड्वोरक

प्रतिहिंसा, नहीं! इस बात पर विचार करें कि आपको interact...readवहां कहीं और की आवश्यकता होगी , जो इसे बस से अधिक लंबा बनाता है readLn। अक्सर doनोटेशन आपकी अपेक्षा से अधिक संक्षिप्त हो सकता है, खासकर जब विकल्प एक लैम्ब्डा है।

— लिन

Answer 13

भूलभुलैया , 29 बाइट्स

1
?
:
}  +{%!@
(:'(
 } {
 :**

STDIN और आउटपुट से एक पूर्णांक पढ़ता है ((n-1)!)^2 mod n। इस चुनौती के लिए विल्सन का प्रमेय काफी उपयोगी है।

कार्यक्रम शीर्ष-बाएं कोने से शुरू होता है, 1जिसके साथ स्टैक के शीर्ष को 10 से गुणा करता है और जोड़ता है 1. यह भूलभुलैया है बड़ी संख्या में निर्माण का तरीका, लेकिन चूंकि भूलभुलैया के ढेर शून्य से भरे हुए हैं, इसलिए अंतिम प्रभाव हम जैसा है सिर्फ एक धक्का दिया।

?फिर nSTDIN से पढ़ता है और :इसे डुप्लिकेट करता है। }मोडुलो के nलिए अंत में उपयोग किए जाने वाले सहायक स्टैक में बदलाव । (तब घटता है n, और हम चुकता गुट की गणना शुरू करने के लिए तैयार हैं।

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

के लिए n = 1, के बाद से ढेर के शीर्ष है nकम कर, या 0हम सीधे आगे जाना है। हम फिर एक 'और गिरावट के बाद नो-ऑप मारा (जो हमें डालता है -1। यह नकारात्मक है, तो हम, बाएं मुड़ें को क्रियान्वित करने +के साथ साथ ( -1 + 0 = -1), {शिफ्ट करने के लिए nमुख्य और के लिए सहायक ढेर से वापस %सापेक्ष ( -1 % 1 = 0)। फिर हम साथ उत्पादन करते हैं !और समाप्त करते हैं @।

n > 1दूसरे के लिए , :हम दाईं ओर मुड़ते हैं। फिर हम }अपने कॉपी किए गए लूप काउंटर को सहायक स्टैक, डुप्लिकेट :और दो बार गुणा करें **, वापस काउंटर को शिफ्ट करने {और डीक्रिमेंट करने से पहले (। यदि हम अभी भी सकारात्मक हैं तो हम सही मोड़ की कोशिश कर सकते हैं लेकिन ऐसा नहीं कर सकते, इसलिए भूलभुलैया हमें लूप को जारी रखने के बजाय छोड़ दिया जाता है। अन्यथा, स्टैक के ऊपर हमारा लूप काउंटर है जिसे घटाकर 0 कर दिया गया है, जिसे हम +अपनी गणना में जोड़ते हैं ((n-1)!)^2। अंत में, हम फिर मॉडुलो , आउटपुट और समाप्त के nसाथ वापस आते हैं ।{%!@

मैंने कहा कि 'यह एक नो-ऑप है, लेकिन इसका उपयोग डिबगिंग के लिए भी किया जा सकता है। -dहर बार पास होने के बाद स्टैक की स्थिति को देखने के लिए ध्वज के साथ भागो '!

Comments

इस तथ्य को बढ़ाते हुए एक बहुत अच्छी चाल है :)

— लिन

@ मोरिस धन्यवाद! मुझे यह श्रेय देने की आवश्यकता है कि यह कहाँ है - हालाँकि मैंने पहली बार यहाँ

— Sp3000

हाँ, मेरे द्वारा लिखित पहला भूलभुलैया उत्तर नहीं! :)

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

Answer 14

बैश + जीएनयू उपयोगिताओं, 16

• 4 बाइट्स @ डेनिस की बदौलत बच गए

• 2 बाइट्स @Lekensteyn की बदौलत बच गए

factor|awk NF==2

इनपुट STDIN से ली गई एक लाइन है। आउटपुट फालसे के लिए खाली स्ट्रिंग है और सत्य के लिए गैर-रिक्त स्ट्रिंग है। उदाहरण के लिए:

$ ./pr.sh <<< 1
$ ./pr.sh <<< 2
2: 2
$ ./pr.sh <<< 3
3: 3
$ ./pr.sh <<< 4
$

Comments

कूल, एक और कोरुतिल के बारे में सीखा। खेतों की संख्या की गिनती करके आपके दो चरित्रों को factor|awk NF==2

— छीन सकते हैं

@Lekensteyn - धन्यवाद - किसी कारण से मैं आपकी टिप्पणी से पहले चूक गया :)

— डिजिटल ट्रॉमा

मैं कुछ समान पोस्ट करने जा रहा था, केवल लंबे समय तक और बिना AWK के। अच्छी तरह से किया।

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

Answer 15

जावा, 126 121 बाइट्स

मुझे लगता है कि हमें स्कोरबोर्ड के लिए जावा उत्तर की आवश्यकता है ... इसलिए यहां एक सरल परीक्षण विभाजन लूप है:

class P{public static void main(String[]a){int i=2,n=Short.valueOf(a[0]);for(;i<n;)n=n%i++<1?0:n;System.out.print(n>1);}}

जावा के लिए हमेशा की तरह, "पूर्ण कार्यक्रम" आवश्यकता इसे बहुत बड़ा बना देती है, अगर यह एक फ़ंक्शन होता, तो ज्यादातर mainहस्ताक्षर के कारण ।

विस्तारित रूप में:

class P{
    public static void main(String[]a){
        int i=2,n=Short.valueOf(a[0]);
        for(;i<n;)
            n=n%i++<1?0:n;
        System.out.print(n>1);
    }
}

संपादित करें: टिप्पणियों में पीटर द्वारा निश्चित और पुनर्निर्मित। धन्यवाद!

Comments

छोटी गाड़ी: यह रिपोर्ट करता 1है कि प्रमुख है। अन्यथा हटाने pऔर कहने से एक 4-चार बचत होगीfor(;i<n;)n=n%i++<1?0:n;System.out.print(n>0);

— पीटर टेलर

OTOH class P{public static void main(String[]a){int i=2,n=Short.valueOf(a[0]);for(;i<n;)n=n%i++<1?0:n;System.out.print(n>1);}}काम करता है

— पीटर टेलर

लाइन 3 को 'लॉन्ग i = 2, n = Long.valueOf ([[0)) में बदलकर; `लंबाई में कोई बदलाव नहीं बल्कि वैध इनपुट की व्यापक श्रेणी के परिणामस्वरूप।

— जेम्स के पोल्क

के बजाय .valueOfआप का उपयोग कर सकते हैं new, के रूप में new Short(a[0]), या new Long(a[0]), जो थोड़ा छोटा है।

— ईसीएस

आप एक इंटरफ़ेस का उपयोग करके और publicसंशोधक को गिराकर 4 बाइट्स बचा सकते हैं ।

— रामेनशेफ

Answer 16

ब्रेन-फ्लैक , 112 108 बाइट्स

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

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

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

प्रारंभ में, पहले स्टैक में एक धनात्मक पूर्णांक n होगा , दूसरा स्टैक खाली होगा।

हम निम्नानुसार एन घटाकर शुरू करते हैं।

(
  {}      Pop n.
  [()]    Yield -1.
)       Push n - 1.

एन = 1

यदि n = 1 शून्य है, जबकि लूप है

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

पूरी तरह से छोड़ दिया जाता है। अंत में, शेष कोड निष्पादित किया जाता है।

<>    Switch to the second stack (empty).
{}    Pop one of the infinite zeroes at the bottom.
{<>}  Switch stacks while the top on the active stack is non-zero. Does nothing.
(
  []    Get the length of the active stack (0).
  {}    Pop another zero.
)     Push 0 + 0 = 0.

n> 1

यदि n - 1 गैर-शून्य है, तो हम लूप में प्रवेश करते हैं जो n = 1 स्किप करता है। यह "वास्तविक" लूप नहीं है; कोड को केवल एक बार निष्पादित किया जाता है। यह निम्नलिखित प्राप्त करता है।

{                   While the top of the active stack is non-zero:
  (
    (
      ({})                Pop and push n - 1.
      ()                  Yield 1.
    )                   Push n - 1 + 1 = n.
    <>                  Switch to the second stack. Yields 0.
  )                   Push n + 0 = n.
                      We now have n and k = n - 1 on the first stack, and n on
                      the second one. The setup stage is complete and we start
                      employing trial division to determine n's primality.
  {                   While the top of the second stack is non-zero:
    {}                  Pop n (first run) or the last modulus (subsequent runs),
                        leaving the second stack empty.
    <>                  Switch to the first stack.
    (
      (
        {}                  Pop n from the first stack.
        <
          (
            (
              {}              Pop k (initially n - 1) from the first stack.
              [()]            Yield -1.
            )               Push k - 1 to the first stack.
            ()              Yield 1.
            <>              Switch to the second stack.
          )               Push k - 1 + 1 = k on the second stack.
        >               Yield 0.
      )               Push n + 0 = n on the second stack.
      <>              Switch to the first stack.
    )               Push n on the first stack.
    <>              Switch to the second stack, which contains n and k.
                    The first stack contains n and k - 1, so it is ready for
                    the next iteration.
    {({}[()]<({}[()]<({}())>)>{(<()>)}{})}{}{}  Compute and push n % k.
  }               Stop if n % k = 0.
}               Ditto.

n% k की गणना मेरी विभाज्यता परीक्षण उत्तर से 42-बाइट मापांक एल्गोरिथ्म का उपयोग करके की जाती है ।

अंत में, हम परिणामों की व्याख्या करने के लिए n की प्रधानता निर्धारित करते हैं ।

<>    Switch to the first stack, which contains n and k - 1, where k is the
      largest integer that is smaller than n and divides n evenly.
      If (and only if) n > 1 is prime, k = 1 and (thus) k - 1 = 0.
{     While the top of the first stack is non-zero:
  {}    Pop it.
}     This pops n if n is prime, n and k - 1 if n is composite.
(
  []    Yield the height h of the stack. h = 1 iff n is prime).
  {}    Pop 0.
)     Push h + 0 = h.

Comments

आपको स्टैक पर अंतिम 0 पॉप करने की आवश्यकता नहीं है, क्योंकि शीर्ष पर सत्य 1 पर्याप्त है; आप आखिरी को हटाकर दो बाइट्स बचा सकते हैं {}।

— स्टीवन एच।

हम्म, मैं फटा हुआ हूँ। एक तरफ, सवाल का कहना है कि उत्पादन केवल एक truthy या falsy मूल्य होने चाहिए और 1 0है दो मूल्यों। दूसरी ओर, हम सरणियों को तब तक स्वीकार करेंगे जब तक भाषा उन्हें सत्य या मिथ्या मानती है और कई स्टैक आइटम निकटतम चीज़ है ब्रेन-फ्लैक को सरणियाँ देना है। मेटा तक ले जाने लायक हो सकता है।

— डेनिस

मैंने ब्रेन-फ्लैक के निर्माता के साथ सत्यापन किया है जो 1 0सत्य है। chat.stackexchange.com/transcript/message/32746241#32746241

— स्टीवन एच।

प्रासंगिक मेटा चर्चा: ब्रेन-फ्लैक और इसी तरह की स्टैक-आधारित भाषाओं में सत्यता

— डेनिस

Answer 17

आर, 37 29 बाइट्स

n=scan();cat(sum(!n%%1:n)==2)

परीक्षण विभाजन का उपयोग करता है। scan()STDIN से एक पूर्णांक पढ़ता है और cat()STDOUT को लिखता है।

हम nपूर्णांक 1 से nmodulo से मिलकर लंबाई की एक वेक्टर उत्पन्न करते हैं n। हम परीक्षण करते हैं कि क्या प्रत्येक 0 को नकारा जा रहा है ( !), जो एक तार्किक मान लौटाता है, जब संख्या 0 और झूठी होने पर सच होती है, जब यह 0. से अधिक होता है। तार्किक वेक्टर का योग सच्चे तत्वों की संख्या है, और अभाज्य संख्याओं के लिए हम उम्मीद करते हैं केवल नॉनजरो मोडुली 1 और n, इस प्रकार हम 2 होने की उम्मीद करते हैं।

Flodel के लिए धन्यवाद 8 बाइट्स सहेजे गए!

Comments

साथ f=function(x)sum(!x%%1:x)==2आप इसे 28 बाइट्स में कर सकते हैं।

— म्यूटाडर

@ AndréMuta इस चुनौती के लिए, सभी प्रस्तुतियाँ सिर्फ कार्यों के बजाय पूर्ण कार्यक्रम होनी चाहिए। फिर भी सुझाव के लिए धन्यवाद।

— एलेक्स ए।

Answer 18

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

2=sum(not(fPart(Ans/randIntNoRep(1,Ans

बहुत सीधा। randIntNoRep(1 से सभी पूर्णांकों की क्रमिक क्रमबद्धता देता है Ans।

यह नियमों को थोड़ा झुकता है; क्योंकि TI-BASIC में सूचियाँ मेरे द्वारा व्याख्या किए गए 999 तत्वों तक सीमित हैं

मान लें कि इनपुट आपके डेटा प्रकार में संग्रहीत किया जा सकता है

जिसका अर्थ है कि इनपुट को समायोजित करने के लिए सभी डेटाटिप्स को माना जा सकता है। ओपी इस व्याख्या से सहमत है।

एक 17-बाइट समाधान जो वास्तव में 10 ^ 12 या तो अप करने के लिए काम करता है:

2=Σ(not(fPart(Ans/A)),A,1,Ans

Comments

@toothbrush TI-BASIC एक टोकन भाषा है, इसलिए यहां हर टोकन एक बाइट है, randIntNoRep(जिसे छोड़कर दो है।

— lirtosiast

+1 आह, मैंने पहले कभी टीएल-बेसिक नहीं देखा है। मुझे बताने के लिए धन्यवाद

— टूथब्रश

हालांकि, यह है एक सा अनुचित यह है, नहीं ...? मुझे एक गोल्फ भाषा लिखनी चाहिए जिसके लिए केवल 1-4 बाइट्स (प्रश्न आईडी), और फिर मापदंडों की आवश्यकता होती है। यह उस भाषा में शीर्ष उत्तर को चुन लेगा जिसे वह समझता है, इसे निष्पादित करता है (किसी भी पैरामीटर को पारित कर रहा है), और परिणाम लौटाता है ... मुझे आश्चर्य है कि क्या यह नियम तोड़ रहा है? :-)

— टूथब्रश

@toothbrush TI-BASIC के बचाव में: दुभाषिया के लिए, यह Pyth और CJam के एक-वर्ण कमांड की तुलना में अधिक अनुचित नहीं है, और TI-BASIC अधिक पठनीय है।

— lirtosiast

सच। मैं उन प्रकार की भाषाओं को नापसंद करता हूं, क्योंकि लगभग हर दूसरी भाषा में समाधान लंबे समय तक हैं ... हालांकि मैंने हाल ही में सीजेएम को वीबी 6 से हराया है ! : -]

— टूथब्रश

Answer 19

PARI / GP, 21 बाइट्स

print(isprime(input))

हास्यास्पद रूप से बड़े इनपुट के लिए काम करता है, क्योंकि इस तरह की चीज PARI / GP के लिए बनाई गई है।

Comments

isprimeएपीआर-सीएल प्राॅमिलिटी प्रूफ देता है, इसलिए थोड़ा बहुत धीमा हो जाता है क्योंकि इनपुट बहुत बड़े हो जाते हैं। ispseudoprime(input)एईएस बीपीएसडब्ल्यू संभावित प्राइम टेस्ट करता है, जो 100 अंकों से अधिक के लिए बहुत तेज होगा। अभी भी 35 वर्षों के बाद कोई ज्ञात प्रतिपक्ष नहीं है। संस्करण २.१ और २००२ से पहले, इससे पहले, एक अलग विधि का उपयोग करता है जो आसानी से गलत परिणाम दे सकता है, लेकिन किसी को भी इसका उपयोग नहीं करना चाहिए।

— दनाज

Answer 20

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

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

अपवोट थॉमस क्वा का जवाब , यह श्रेष्ठ है।

:Prompt N
:2
:While N≠1 and fPart(N/Ans
:Ans+1
:End
:N=Ans

नमूना:

N=?1009
                         1
N=?17
                         1
N=?1008
                         0
N=?16
                         0

अब देता है 0एक प्रमुख यदि नहीं, या 1अगर यह होता है।

Comments

क्या वर्गमूल केवल एक अनुकूलन नहीं है जिसे आपको वास्तव में कार्यक्रम के सही होने की आवश्यकता नहीं है?

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

आपको दो से विभाजित करने की आवश्यकता क्यों होगी?

— Geobits

मुझे हमेशा TI-BASIC जवाब पसंद हैं।

— ग्रांट मिलर

Answer 21

स्टैक कैट्स , 62 + 4 = 66 बाइट्स

*(>:^]*(*>{<-!<:^>[:((-<)<(<!-)>>-_)_<<]>:]<]]}*<)]*(:)*=<*)>]

-lnकमांड-लाइन झंडे (इसलिए +4 बाइट्स) के साथ चलाने की आवश्यकता है । 0समग्र संख्या के लिए और 1primes के लिए प्रिंट ।

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

मुझे लगता है कि यह पहला गैर-तुच्छ ढेर बिल्लियाँ कार्यक्रम है।

व्याख्या

एक त्वरित ढेर बिल्लियों परिचय:

• स्टैक कैट्स ढेर के एक अनंत टेप पर चल रही है, एक टेप सिर के साथ एक मौजूदा ढेर पर इंगित करता है। प्रत्येक स्टैक को शुरू में शून्य की अनंत राशि से भरा जाता है। मैं आमतौर पर अपने शब्दों में इन शून्य को अनदेखा करूंगा, इसलिए जब मैं कहता हूं "स्टैक के नीचे" मेरा मतलब सबसे कम गैर-शून्य मान है और अगर मैं कहता हूं "स्टैक खाली है" तो मेरा मतलब है कि इस पर केवल शून्य है।
• कार्यक्रम शुरू होने से पहले, एक -1प्रारंभिक स्टैक पर धकेल दिया जाता है, और फिर पूरे इनपुट को उसी के ऊपर धकेल दिया जाता है। इस स्थिति में, -nध्वज के कारण , इनपुट को दशमलव पूर्णांक के रूप में पढ़ा जाता है।
• कार्यक्रम के अंत में, आउटपुट के लिए वर्तमान स्टैक का उपयोग किया जाता है। यदि -1तल पर है, तो इसे नजरअंदाज कर दिया जाएगा। फिर से, -nध्वज के कारण , स्टैक से मानों को लाइनफीड-अलग दशमलव पूर्णांक के रूप में मुद्रित किया जाता है।
• स्टैक कैट्स एक प्रतिवर्ती कार्यक्रम भाषा है: कोड का हर टुकड़ा पूर्ववत किया जा सकता है (स्टैक बिल्लियों के बिना एक स्पष्ट जानकारी का ट्रैक रखना)। विशेष रूप से, कोड के किसी भी भाग को उल्टा करने के लिए, आप बस यह दर्पण, जैसे <<(\-_)हो जाता है (_-/)>>। यह डिज़ाइन लक्ष्य भाषा में किस प्रकार के ऑपरेटरों और नियंत्रण प्रवाह निर्माण पर काफी गंभीर प्रतिबंध लगाता है, और आप किस प्रकार के कार्यों को वैश्विक मेमोरी स्थिति पर गणना कर सकते हैं।

• यह सब बंद करने के लिए, प्रत्येक स्टैक कैट्स प्रोग्राम को आत्म-सममित होना होगा। आप देख सकते हैं कि उपरोक्त स्रोत कोड के मामले में ऐसा नहीं है। यह वह -lझंडा है जिसके लिए यह है: यह केंद्र के लिए पहले वर्ण का उपयोग करते हुए, कोड को बाईं ओर दर्पण को दिखाता है। इसलिए वास्तविक कार्यक्रम है:

  [<(*>=*(:)*[(>*{[[>[:<[>>_(_-<<(-!>)>(>-)):]<^:>!->}<*)*[^:<)*(>:^]*(*>{<-!<:^>[:((-<)<(<!-)>>-_)_<<]>:]<]]}*<)]*(:)*=<*)>]
  

पूरे कोड के साथ प्रभावी ढंग से प्रोग्रामिंग अत्यधिक गैर-तुच्छ और अचिंत्य है और वास्तव में अभी तक पता नहीं चला है कि एक मानव संभवतः कैसे कर सकता है। हम सरल कार्यों के लिए इस तरह के कार्यक्रम को मजबूर कर चुके हैं, लेकिन हाथ से कहीं भी नहीं जा सकते। सौभाग्य से, हमने एक मूल पैटर्न पाया है जो आपको कार्यक्रम के एक आधे हिस्से को अनदेखा करने की अनुमति देता है। हालांकि, यह निश्चित रूप से सबप्टिमल है, यह वर्तमान में स्टैक कैट्स में प्रभावी ढंग से प्रोग्राम करने का एकमात्र ज्ञात तरीका है।

तो इस उत्तर में, उक्त पैटर्न का टेम्प्लेट यह है (इसमें कुछ परिवर्तनशीलता है कि इसे कैसे निष्पादित किया जाता है):

[<(...)*(...)>]

जब प्रोग्राम शुरू होता है, तो स्टैक टेप इस तरह दिखता है (इनपुट के लिए 4, कहें):

     4    
... -1 ...
     0
     ^

[चाल बाईं ओर ढेर के शीर्ष (और साथ टेप सिर) - हम फोन इस "धक्का"। और <टेप हेड को अकेले घुमाता है। इसलिए पहले दो आदेशों के बाद, हमें यह स्थिति मिली है:

...   4 -1 ...
    0 0  0
    ^

अब (...)एक लूप है जिसे सशर्त के रूप में काफी आसानी से उपयोग किया जा सकता है: लूप में प्रवेश किया जाता है और केवल तब छोड़ा जाता है जब वर्तमान स्टैक के शीर्ष सकारात्मक होता है। चूंकि, यह वर्तमान में शून्य है, हम कार्यक्रम के पूरे पहले आधे हिस्से को छोड़ देते हैं। अब सेंटर कमांड है *। यह बस है XOR 1, यानी यह स्टैक के शीर्ष का सबसे कम महत्वपूर्ण बिट टॉगल करता है, और इस मामले 0में एक में बदल जाता है 1:

... 1 4 -1 ...
    0 0  0
    ^

अब हम दर्पण छवि का सामना करते हैं (...)। इस बार ढेर के शीर्ष सकारात्मक है और हम कर कोड दर्ज करें। इससे पहले कि हम देखते हैं कि कोष्ठक के अंदर क्या चल रहा है, मुझे समझाएं कि हम आखिर में कैसे लपेटेंगे: हम यह सुनिश्चित करना चाहते हैं कि इस ब्लॉक के अंत में, हमारे पास एक सकारात्मक मूल्य पर फिर से टेप सिर हो (ताकि पाश एक एकल पुनरावृत्ति के बाद समाप्त हो जाता है और एक रेखीय सशर्त के रूप में बस प्रयोग किया जाता है), यह सही करने के लिए ढेर उत्पादन रखती है और के ढेर सही है कि कि एक रखती है -1। यदि ऐसा है, तो हम लूप छोड़ते हैं, >आउटपुट वैल्यू पर जाते हैं और ]इसे पुश करते हैं -1ताकि हमारे पास आउटपुट के लिए एक साफ स्टैक हो।

वह यह है कि। अब कोष्ठक के अंदर हम जो कुछ भी करना चाहते हैं, हम प्राणशक्ति की जाँच कर सकते हैं जब तक हम यह सुनिश्चित करते हैं कि हम अंत में पिछले पैराग्राफ में वर्णित चीजों को सेट करें (जो आसानी से कुछ धक्का और टेप सिर हिलाने के साथ किया जा सकता है)। मैंने पहली बार विल्सन के प्रमेय के साथ समस्या को हल करने की कोशिश की, लेकिन 100 बाइट्स में अच्छी तरह से समाप्त हो गया, क्योंकि स्क्वैर्ड फैक्टरियल कम्प्यूटेशन वास्तव में स्टैक कैट्स में काफी महंगा है (कम से कम मुझे एक छोटा रास्ता नहीं मिला है)। इसलिए मैं ट्रायल डिवीजन के बजाय गया और यह वास्तव में बहुत सरल निकला। आइए पहले रेखीय बिट को देखें:

>:^]

आप उनमें से दो कमांड देख चुके हैं। इसके अलावा, :वर्तमान स्टैक के शीर्ष दो मानों को स्वैप करता है और ^XORs को दूसरा मान शीर्ष मूल्य में देता है। यह :^एक खाली स्टैक पर एक मूल्य को डुप्लिकेट करने के लिए एक सामान्य पैटर्न बनाता है (हम मूल्य के शीर्ष पर एक शून्य खींचते हैं और फिर शून्य को चालू करते हैं 0 XOR x = x)। तो इसके बाद, हमारा टेप इस तरह दिखता है:

         4    
... 1 4 -1 ...
    0 0  0
         ^

ट्रायल डिवीजन एल्गोरिथ्म जो मैंने लागू किया है वह इनपुट के लिए काम नहीं करता है 1, इसलिए हमें उस मामले में कोड को छोड़ देना चाहिए। हम आसानी 1से 0और अन्य सभी चीजों के साथ सकारात्मक मूल्यों के लिए मैप कर सकते हैं *, इसलिए यहां बताया गया है कि हम यह कैसे करते हैं:

*(*...)

यही कारण है कि हम बारी है 1में 0, कोड का एक बड़ा हिस्सा छोड़ अगर हम वास्तव में मिलता है 0, लेकिन अंदर हम तुरंत पूर्ववत *ताकि हम अपने इनपुट मूल्य वापस मिलता है। हमें बस फिर से यह सुनिश्चित करने की आवश्यकता है कि हम कोष्ठक के अंत में एक सकारात्मक मूल्य पर समाप्त हो जाएं ताकि वे लूपिंग शुरू न करें। सशर्त के अंदर, हम एक स्टैक को दाईं ओर घुमाते हैं >और फिर मुख्य ट्रायल डिवीजन लूप शुरू करते हैं:

{<-!<:^>[:((-<)<(<!-)>>-_)_<<]>:]<]]}

ब्रेसिज़ (कोष्ठकों के विपरीत) एक अलग प्रकार के लूप को परिभाषित करते हैं: यह एक डू-टाइम लूप है, जिसका अर्थ है कि यह हमेशा कम से कम एक चलना के लिए चलता है। अन्य अंतर समाप्ति की स्थिति है: लूप में प्रवेश करते समय स्टैक कैट को वर्तमान स्टैक के शीर्ष मूल्य ( 0हमारे मामले में) याद है। लूप तब तक चलेगा जब तक कि एक ही मूल्य पुनरावृत्ति के अंत में दिखाई नहीं देता। यह हमारे लिए सुविधाजनक है: प्रत्येक पुनरावृत्ति में हम बस अगले संभावित विभाजक के शेष भाग की गणना करते हैं और इसे इस स्टैक पर स्थानांतरित करते हैं जिसे हम लूप शुरू कर रहे हैं। जब हम एक भाजक पाते हैं, तो शेष भाग 0बंद हो जाता है। हम शुरू होने वाले विभाजकों को आजमाएंगे n-1और फिर उन्हें घटाएंगे 1। इसका मतलब है कि क) हम जानते हैं कि जब हम पहुंचेंगे तो यह समाप्त हो जाएगा1नवीनतम और बी पर) हम तब निर्धारित कर सकते हैं कि नंबर प्राइम है या नहीं, हमने जो आखिरी डिविज़र का निरीक्षण किया है (यदि यह 1, यह एक प्राइम है, अन्यथा यह नहीं है)।

चलो उसे करें। शुरुआत में एक छोटा रैखिक खंड है:

<-!<:^>[:

आप जानते हैं कि उनमें से अधिकांश अब तक क्या करते हैं। नए आदेश हैं -और !। स्टैक कैट्स में इंक्रीमेंट या डिक्रीमेंट ऑपरेटर्स नहीं होते हैं। हालाँकि -, इसमें (नकार, यानी गुणा से -1) और !(बिटवाइस नहीं, यानी गुणा -1और घटाव) है। इन्हें या तो वेतन वृद्धि !-, या वेतन वृद्धि में जोड़ा जा सकता है -!। तो हम nशीर्ष पर की प्रतिलिपि को घटाते हैं -1, फिर nबाईं ओर स्टैक पर एक और प्रतिलिपि बनाते हैं , फिर नए परीक्षण विभाजक को लाते हैं और इसे नीचे रखते हैं n। तो पहली पुनरावृत्ति पर, हमें यह मिलता है:

      4       
      3       
... 1 4 -1 ...
    0 0  0
      ^

आगे पुनरावृत्तियों पर, 3अगले परीक्षण विभाजक के साथ बदल दिया जाएगा और इसी तरह (जबकि nइस बिंदु पर हमेशा की दो प्रतियां एक ही मूल्य होगी)।

((-<)<(<!-)>>-_)

यह मोडुलो गणना है। चूंकि लूप सकारात्मक मूल्यों पर समाप्त हो जाते हैं, इसलिए विचार शुरू करना है -nऔर बार-बार ट्रायल डिवीजन dको इसमें जोड़ना है जब तक कि हमें सकारात्मक मूल्य नहीं मिलता है। एक बार जब हम करते हैं, तो हम परिणाम को घटा देते हैं dऔर यह हमें शेष देता है। यहाँ मुश्किल सा यह है कि हम बस -nस्टैक के ऊपर नहीं डाल सकते हैं और एक लूप शुरू कर सकते हैं जो जोड़ता है d: यदि स्टैक के शीर्ष नकारात्मक है, तो लूप दर्ज नहीं किया जाएगा। ऐसी एक प्रतिवर्ती प्रोग्रामिंग भाषा की सीमाएं हैं।

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

(-<)

जब स्टैक का शीर्ष सकारात्मक होता है (केवल पहली पुनरावृत्ति पर), तो हम इसके साथ नकारात्मक करते हैं -। हालांकि, हम अभी ऐसा नहीं कर सकते (-)क्योंकि तब हम नहीं किया जाएगा छोड़ने पाश जब तक -दो बार लागू किया गया था। इसलिए हम एक सेल को छोड़ <देते हैं क्योंकि हम जानते हैं कि वहाँ एक सकारात्मक मूल्य है ( 1)। ठीक है, इसलिए अब हमने nपहले पुनरावृत्ति पर भरोसा किया । लेकिन हमारे पास एक नई समस्या है: टेप हेड अब पहले पुनरावृति पर हर दूसरे की तुलना में एक अलग स्थिति में है। इससे पहले कि हम आगे बढ़ें, हमें इसे मजबूत करना होगा। अगले <टेप सिर छोड़ दिया है। पहली यात्रा पर स्थिति:

        -4       
         3       
...   1  4 -1 ...
    0 0  0  0
    ^

और दूसरा पुनरावृत्ति पर (याद रखें कि हमने अब dएक बार जोड़ा है -n):

      -1       
       3       
... 1  4 -1 ...
    0  0  0
    ^

अगली सशर्त इन रास्तों को फिर से मिला देती है:

(<!-)

पहले पुनरावृत्ति पर टेप सिर एक शून्य पर इंगित करता है, इसलिए यह पूरी तरह से छोड़ दिया जाता है। आगे पुनरावृत्तियों पर, टेप हेड एक पर इंगित करता है, इसलिए हम इसे निष्पादित करते हैं, बाईं ओर जाते हैं और वहां सेल बढ़ाते हैं। चूंकि हम जानते हैं कि सेल शून्य से शुरू होती है, यह अब हमेशा सकारात्मक होगी ताकि हम लूप छोड़ सकें। यह सुनिश्चित करता है कि हम हमेशा मुख्य स्टैक के बचे दो स्टैक को समाप्त करते हैं और अब वापस आ सकते हैं >>। फिर मोडुलो लूप के अंत में हम करते हैं -_। आप पहले से ही जानते हैं -। XOR के लिए _क्या घटाना ^है: यदि स्टैक के ऊपर है aऔर नीचे मूल्य है, bतो वह इसके aसाथ बदल देता है b-a। चूँकि हमने पहले नकारा aथा, फिर भी -_बदल aजाता है b+a, जिससे जुड़ जाता हैd हमारे कुल में चल रहा है।

लूप समाप्त होने के बाद (हम सकारात्मक रूप से पहुंच गए हैं) मान, टेप इस तरह दिखता है:

        2       
        3       
... 1 1 4 -1 ...
    0 0 0  0
        ^

बाएं-सबसे अधिक मूल्य कोई भी सकारात्मक संख्या हो सकती है। वास्तव में, यह पुनरावृत्तियों की संख्या शून्य से एक है। अब एक और छोटी रैखिक बिट है:

_<<]>:]<]]

जैसा कि मैंने पहले कहा था कि हमें dवास्तविक शेष ( 3-2 = 1 = 4 % 3) प्राप्त करने के लिए परिणाम को घटाना होगा , इसलिए हम सिर्फ _एक बार और करते हैं। अगला, हमें उस स्टैक को साफ करने की आवश्यकता है जिसे हम बाईं ओर बढ़ रहे हैं: जब हम अगले भाजक की कोशिश करते हैं, तो काम करने के लिए पहले पुनरावृत्ति के लिए इसे फिर से शून्य होना चाहिए। इसलिए हम वहां जाते हैं और उस पॉजिटिव वैल्यू को दूसरे हेल्पर स्टैक से धक्का देते हैं <<]और फिर दूसरे के साथ हमारे ऑपरेशनल स्टैक पर वापस जाते हैं >। हम dसाथ खींचते हैं :और इसे पीछे के -1साथ धक्का ]देते हैं और फिर हम शेष को अपने सशर्त स्टैक पर ले जाते हैं <]]। यह ट्रायल डिवीजन लूप का अंत है: यह तब तक जारी रहता है जब तक कि हमें एक शून्य शेष नहीं मिलता है, जिस स्थिति में बाईं ओर स्टैक होता हैnका सबसे बड़ा भाजक (के अलावा n)।

लूप के समाप्त होने के बाद, *<इनपुट के साथ पथ जुड़ने से ठीक पहले हम वहाँ हैं 1। *बस एक में शून्य हो जाता है 1, जो हम कुछ देर में की आवश्यकता होगी, और फिर हम साथ भाजक में ले जाएँ <(ताकि हम इनपुट के लिए के रूप में ही ढेर पर हैं 1)।

इस बिंदु पर यह तीन विभिन्न प्रकार के आदानों की तुलना करने में मदद करता है। सबसे पहले, विशेष मामला n = 1जहां हमने उस ट्रायल डिवीजन सामान में से कोई भी नहीं किया है:

         0    
... 1 1 -1 ...
    0 0  0
         ^

फिर, हमारा पिछला उदाहरण n = 4, एक समग्र संख्या:

    2           
    1    2 1    
... 1 4 -1 1 ...
    0 0  0 0
         ^

और अंत में n = 3, एक अभाज्य संख्या:

    3           
    1    1 1    
... 1 3 -1 1 ...
    0 0  0 0
         ^

इसलिए प्राइम नंबरों के लिए, हमारे पास 1इस स्टैक पर है, और कंपोजिट नंबरों के लिए हमारे पास या तो 0पॉजिटिव नंबर है 2। हम इस स्थिति को चालू करते हैं 0या 1हमें निम्नलिखित अंतिम कोड कोड की आवश्यकता होती है:

]*(:)*=<*

]बस इस मूल्य को दाईं ओर धकेलता है। तब *सशर्त स्थिति को बहुत सरल बनाने के लिए उपयोग किया जाता है: कम से कम महत्वपूर्ण बिट को टॉगल करके, हम 1(प्राइम) को 0, 0(समग्र) सकारात्मक मूल्य में बदल देते हैं 1, और अन्य सभी सकारात्मक मूल्य अभी भी सकारात्मक बने रहेंगे। अब हमें केवल 0और केवल सकारात्मक के बीच अंतर करने की जरूरत है । वहीं हम दूसरे का उपयोग करते हैं (:)। यदि स्टैक का शीर्ष है 0(और इनपुट एक प्रमुख था), तो यह बस छोड़ दिया जाता है। लेकिन अगर स्टैक के शीर्ष सकारात्मक है (और इनपुट एक समग्र संख्या थी) यह इसके साथ स्वैप करता है 1, ताकि हम अब इसके 0विपरीत और1primes के लिए - केवल दो अलग-अलग मूल्य। बेशक, वे इसके विपरीत हैं जो हम आउटपुट करना चाहते हैं, लेकिन यह आसानी से दूसरे के साथ तय हो गया है *।

अब सभी अब सिर्फ़ हमारे आसपास के ढांचे से उम्मीद के ढेर के पैटर्न को बहाल करना है: एक सकारात्मक मूल्य पर टेप सिर सही करने के लिए ढेर के शीर्ष पर परिणाम, और एक एकल -1के ढेर सही पर है कि । यह वही =<*है जिसके लिए है =दो आसन्न ढेर के शीर्ष स्वैप, जिससे -1परिणाम के दाईं ओर बढ़ रहा है , जैसे इनपुट के लिए 4फिर से:

    2     0       
    1     3       
... 1 4   1 -1 ...
    0 0 0 0  0
          ^

फिर हम बस बाएं से चलते हैं <और उस शून्य को एक में बदल देते हैं *। और वही जो है।

यदि आप प्रोग्राम को कैसे काम करते हैं, इसके बारे में गहराई से खुदाई करना चाहते हैं, तो आप डिबग विकल्पों का उपयोग कर सकते हैं। या तो -dझंडा जोड़ें और "जहाँ भी आप इस तरह की वर्तमान मेमोरी स्थिति देखना चाहते हैं सम्मिलित करें , या पूरे कार्यक्रम का पूरा पता लगाने के लिए-D ध्वज का उपयोग करें । वैकल्पिक रूप से, आप टिमवी के एसोटेरिकैड का उपयोग कर सकते हैं जिसमें स्टेप-बाय-स्टेप डिबगर के साथ एक स्टैक कैट्स दुभाषिया शामिल है।

Comments

>:^]आधिकारिक स्टैक कैट्स लोगो होना चाहिए

— एलेक्स ए।

Answer 22

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

import Data.Numbers.Primes
main=readLn>>=print.isPrime

समझाने के लिए ज्यादा कुछ नहीं।

Comments

विल्सन की प्रमेय का उपयोग करते हुए, बाहरी पुस्तकालयों के बिना एक ही स्कोर प्राप्त किया जा सकता है (हालांकि बहुत अक्षम रूप से):main=do n<-readLn;print$n>1&&mod(product[1..n-1]+1)n<1

— लिन

हम भी कम कर सकते हैं: main=do n<-readLn;print$mod(product[1..n-1]^2)n>049 बाइट्स है।

— लिन

@ मौरिस: अच्छा। कृपया इसे एक अलग उत्तर के रूप में पोस्ट करें।

— निकमी

Answer 23

रूबी, 15 + 8 = 23 बाइट्स

p$_.to_i.prime?

नमूना रन:

bash-4.3$ ruby -rprime -ne 'p$_.to_i.prime?' <<< 2015
false

Comments

हेह, मुझे पता था कि रूबी में कहीं एक बिल्डर होगा, लेकिन मैं इसे देखने के लिए परेशान नहीं हो सकता, इसलिए मैंने सी। +1 में जवाब दिया।

— लेवल रिवर सेंट

@steveverrill, मुझे यह पता था क्योंकि प्रोजेक्ट यूलर के लिए एक बड़ी मदद थी।

— मैनटवर्क

Answer 24

जावास्क्रिप्ट, 39 36 बाइट्स

सहेजे गए 3 बाइट्स ETHproductions के लिए धन्यवाद:

for(i=n=prompt();n%--i;);alert(1==i)

एक प्रमुख के लिए सच दिखाता है, अन्यथा गलत।

के लिए पाश हर संख्या का परीक्षण करती है मैं से n-1 जब तक मैं एक भाजक है। यदि पाया गया पहला विभाजक 1 है तो यह एक प्रमुख संख्या है।

---

पिछला समाधान (39 बाइट्स):

for(i=n=prompt();n%--i&&i;);alert(1==i)

कैसे एक अनावश्यक परीक्षण छोड़ दिया गया था:

for(i=2,n=prompt();n%i>0&&i*i<n;i++);alert(n%i>0) //49: Simple implementation: loop from 2 to sqrt(n) to test the modulo.
for(i=2,n=prompt();n%i>0&&i<n;i++);alert(n==i)    //46: Replace i*i<n by i<n (loop from 2 to n) and replace n%i>0 by n==i
for(i=2,n=prompt();n%i&&i<n;i++);alert(n==i)      //44: Replace n%i>0 by n%i
for(i=2,n=prompt();n%i&&i++<n;);alert(n==i)       //43: Shorten loop increment
for(i=n=prompt();n%--i&&i>0;);alert(1==i)         //41: Loop from n to 1. Better variable initialization.
for(i=n=prompt();n%--i&&i;);alert(1==i)           //39: \o/ Replace i>0 by i

मैंने केवल 39 बाइट्स समाधान पोस्ट किया है क्योंकि सबसे अच्छा जावास्क्रिप्ट उत्तर पहले से ही 40 बाइट्स था।

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है!

— डेनिस

बहुत बढ़िया जवाब! &&iवास्तव में इस कार्यक्रम में कुछ भी नहीं है, तो आप इसे हटा सकते हैं।

— ETHproductions

n>1हालांकि, यदि आप 1प्राइम होना चाहते हैं, तो अंतिम स्थिति में जोड़ना चाहिए ।

— टाइटस

@ टिट्स यदि इनपुट 1लूप के लिए है तो n%--iएक बार करेंगे : 1%0लौटाता है NaNऔर लूप को रोकता है। जब alertकहा जाता है iपहले से ही के बराबर है 0तो 1==iरिटर्न false।

— हेदी

i <२ (और कुछ पाठ)

— २he पर स्कीथोड

Answer 25

घोंघे, १२२

इनपुट यूनीरी में दिया जाना चाहिए। अंक नई वर्णमालाओं को छोड़कर किसी भी वर्ण का हो सकते हैं।

^
..~|!(.2+~).!~!{{t.l=.r=.}+!{t.!.!~!{{r!~u~`+(d!~!.r~)+d~,.r.=.(l!~u~)+(d!~l~)+d~,.l.},l=(.!.)(r!~u~)+(d!~!.r~)+d~,.r.!.

इस 2 डी पैटर्न मिलान भाषा में, कार्यक्रम राज्य में केवल वर्तमान ग्रिड स्थान, कोशिकाओं का सेट जो मिलान किया गया है, और पैटर्न कोड में स्थिति शामिल है। एक मिलान किए गए वर्ग पर यात्रा करना भी अवैध है। यह मुश्किल है, लेकिन जानकारी संग्रहीत और पुनर्प्राप्त करना संभव है। एक मिलान किए गए सेल पर यात्रा करने के खिलाफ प्रतिबंध को पीछे हटाकर, टेलीपोर्टिंग ( t) और जोर ( =, !) द्वारा पूरा किया जा सकता है , जो पूरा होने के बाद अनमॉडिफाइड ग्रिड को छोड़ देते हैं।

एक विषम सम्मिश्र संख्या के लिए गुणन परस्पर गैर-आसन्न कोशिकाओं (आरेख में नीला) के कुछ सेट को चिह्नित करके शुरू होता है। फिर, प्रत्येक येलो सेल से, प्रोग्राम यह सत्यापित करता है कि दोनों पक्षों के बीच आगे और पीछे की तरफ एक समान संख्या में नॉन-ब्लू सेल हैं। आरेख चार पीले कोशिकाओं में से एक के लिए इस पैटर्न को दिखाता है जिसे जांचना आवश्यक है।

एनोटेट कोड:

^                         Match only at the first character
..~ |                     Special case to return true for n=2
!(.2 + ~)                 Fail for even numbers
. !~                      Match 1st character and fail for n=1
!{                        If the bracketed pattern matches, it's composite.
  (t. l=. r=. =(.,~) )+   Teleport to 1 or more chars and match them (blue in graphic)
                          Only teleport to ones that have an unmatched char on each side.
                          The =(.,~) is removed in the golfed code. It forces the
                          teleports to proceed from left to right, reducing the
                          time from factorial to exponential.
  !{                      If bracketed pattern matches, factorization has failed.
    t . !. !~             Teleport to a square to the left of a blue square (yellow in diagram)
    !{                    Bracketed pattern verifies equal number of spaces to
                          the left or right of a blue square.
      {              
        (r!~ u~)+         Up...
        (d!~!. r~)+       Right...
        d~,               Down...
        . r . =.          Move 1 to the right, and check that we are not on the edge;
                          otherwise d~, can fall off next iteration and create and infinite loop
        (l!~ u~)+         Up...
        (d!~ l~)+         Left...
        d ~,              Down...
        . l .             Left 1
      } ,                 Repeat 0 or more times
      l  =(. !.)          Check for exactly 1 unused char to the left
      (r!~ u~)+           Up...
      (d!~!. r~)+         Right...
      d ~,                Down...
      . r . !.
    }
  }
}

Answer 26

सी, 67 बाइट्स

i,n;main(p){for(scanf("%d",&i),n=i;--i;p=p*i*i%n);putchar(48+p%n);}

प्रिंट्स !1(एक झूठी मूल्य, पीटर टेलर की परिभाषा द्वारा ) 0 यदि (n-1)!^2 == 0 (mod n), और 1अन्यथा।

संपादित करें : चैट में कुछ चर्चा के बाद, puts("!1"+p%n)यह थोड़ा धोखा माना जाता है, इसलिए मैंने इसे बदल दिया है। परिणाम एक बाइट लंबा है।

EDIT : बड़े इनपुट के लिए निश्चित।

छोटा हल

56 बाइट्स : pawel.boczarski द्वारा टिप्पणियों में अनुशंसित के रूप में, मैं कमांड लाइन तर्कों की संख्या को पढ़कर एकतरफा इनपुट ले सकता हूं:

p=1,n;main(i){for(n=--i;--i;p=p*i*i%n);putchar(48+p%n);}

जैसे कार्यक्रम का आयोजन

$ ./a.out 1 1 1 1 1
1                        <-- as 5 is prime

51 बाइट्स : यदि आप रिटर्न कोड के माध्यम से "आउटपुट" की अनुमति देते हैं:

p=1,n;main(i){for(n=--i;--i;p=p*i*i%n);return p%n;}

Comments

मेरे समाधान के रूप में आपके समाधान को एकीकृत प्रतिनिधित्व (कमांडलाइन तर्कों की संख्या) का उपयोग करके कम किया जा सकता है। आप स्कैनफ कॉल पर कुछ बाइट्स शेव कर सकते हैं।

— pawel.boczarski

puts("!1"+p%n)आप कभी भी मूल्यों के a+bलिए कैसे कर सकते हैं char*?

— एग आउटफोलर जूल

यदि स्ट्रिंग "!1"पते पर शुरू होती है a, तो a+1आपको स्ट्रिंग मिल जाएगी "1"।

— लिन

@ लियोन ओह, मुझे लगा कि यह कॉन्टैक्शन के लिए है (हाँ, बेहतर है कि इसे छोड़ दो strcat(const char*,const char*)।)

— एरिक आउटगॉल्फ जूल

आप को बदल सकता है p=p*i*i%nके लिएp*=i*i%n

— अल्बर्ट रेंशाव

Answer 27

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

अब input()कमांड लाइन के तर्कों के बजाय उपयोग करता है। @Beta Decay को धन्यवाद

n=int(input())
print([i for i in range(1,n)if n%i==0]==[1])

Comments

ले लो इनपुट का उपयोग input()बहुत कम होगा

— बीटा डिके

धन्यवाद, मैंने पहले ही इनपुट () का उपयोग करके लिखा है, लेकिन मैं अपने उत्तर को ताज़ा करना भूल गया। एक बार फिर धन्यवाद!

— uno20001

52 बाइट्स: n=m=int(input()),print(all(n%m for m in range(2,n)))

— जॉन ल्यों

क्या आप गंभीर हैं। एक लंगड़ा द्विघात गति के लिए 25 अतिरिक्त वर्ण खर्च करें? यहाँ हम बाइट्स से नफरत करते हैं । हम हर घंटे, मिनट और हमारे जीवन के दूसरे को उन्नीसवीं बाइट से छुटकारा दिलाते हैं। (बस मजाक कर रहे हैं। लेकिन हम कार्यक्रम की लंबाई बढ़ाने वाले समय का अनुकूलन नहीं करते हैं।)

— कैलकुलेटरफ्लीन

n%i<1इसके बजाय उपयोग करें ।

— को आउटगोल्फर

Answer 28

एपीएल, 40 13 बाइट्स

2=+/0=x|⍨⍳x←⎕

मेरे आर उत्तर के समान एल्गोरिथ्म के साथ परीक्षण विभाजन । हम xएसटीडीआईएन ( ⎕) से इनपुट को असाइन करते हैं और xप्रत्येक पूर्णांक से विभाजित के लिए शेष 1 से प्राप्त करते हैं x। प्रत्येक शेष की तुलना 0 से की जाती है, जो हमें एक सदिश राशि देता है और यह दर्शाता है कि कौन से पूर्णांक विभाजित हैं x। यह +/विभेदकों की संख्या प्राप्त करने के लिए उपयोग किया जाता है । यदि यह संख्या ठीक 2 है, तो इसका अर्थ है कि केवल भाजक 1 और x, और इस प्रकार xअभाज्य है।

Answer 29

अजगर 2, 44

P=n=1
exec"P*=n*n;n+=1;"*~-input()
print P%n

जैसा Sp3000 के अजगर जवाब है, लेकिन चर की गणना के द्वारा इनपुट भंडारण से बचा जाता है nसे 1इनपुट मूल्य के लिए।

Answer 30

सी ++ टेम्पलेट मेटाप्रोग्रामिंग। 166 131 119 बाइट्स।

कोड संकलित करता है यदि स्थिरांक एक प्रधान है, और संकलित या 1 संकलित नहीं करता है।

template<int a,int b=a>struct t{enum{x=t<a,~-b>::x+!(a%b)};};
template<int b>struct t<b,0>{enum{x};};
int _[t<1>::x==2];

(अंतिम एक को छोड़कर, सभी नए समाचारों को "वास्तविक" संस्करण में समाप्त कर दिया जाता है)।

मुझे लगता है कि "संकलन में विफलता" एक मेटाप्रोग्रामिंग भाषा के लिए एक गलत रिटर्न मान है। ध्यान दें कि यह लिंक नहीं करता है (इसलिए यदि आप इसे प्रमुख फ़ीड करते हैं, तो आपको पूर्ण C ++ प्रोग्राम के रूप में लिंकिंग त्रुटियां मिलेंगी)।

परीक्षण करने का मूल्य अंतिम "लाइन" पर पूर्णांक है।

जीवंत उदाहरण ।