เชื่อหรือไม่ว่าเรายังไม่มีความท้าทายกอล์ฟสำหรับการทดสอบเบื้องต้น แม้ว่ามันอาจจะไม่ใช่สิ่งที่ท้าทายที่สุดโดยเฉพาะอย่างยิ่งสำหรับภาษา "ปกติ" แต่มันก็ไม่ใช่เรื่องแปลกใหม่ในหลายภาษา

รหัส Rosetta มีรายชื่อตามภาษาของวิธีการที่จะเป็นสำนวน primality ทดสอบหนึ่งโดยใช้การทดสอบมิลเลอร์ราบินโดยเฉพาะและอื่นโดยใช้ส่วนการพิจารณาคดี อย่างไรก็ตาม "สำนวนส่วนใหญ่" มักจะไม่ตรงกับ "สั้นที่สุด" ในความพยายามที่จะทำให้การเขียนโปรแกรมปริศนาและโค้ดกอล์ฟเป็นสถานที่สำหรับการแข่งขันกอล์ฟรหัสความท้าทายนี้พยายามที่จะรวบรวมแคตตาล็อกของแนวทางที่สั้นที่สุดในทุกภาษาคล้ายกับ"Hello, World!" และตีกอล์ฟให้คุณอย่างดีเยี่ยม! .

นอกจากนี้ความสามารถในการใช้การทดสอบแบบดั้งเดิมนั้นเป็นส่วนหนึ่งของคำจำกัดความของภาษาโปรแกรมดังนั้นความท้าทายนี้จะทำหน้าที่เป็นไดเรกทอรีของภาษาโปรแกรมที่ได้รับการพิสูจน์แล้ว

งาน

เขียนโปรแกรมเต็มรูปแบบที่ให้ค่าจำนวนเต็มบวกnอย่างเคร่งครัดเป็นอินพุตพิจารณาว่าnเป็นจำนวนเฉพาะและพิมพ์ค่าจริงหรือค่าเท็จตามนั้น

สำหรับจุดประสงค์ของการท้าทายนี้จำนวนเต็มจะเป็นจำนวนเฉพาะถ้ามีตัวหารที่เป็นบวกสองตัว โปรดทราบว่าสิ่งนี้ไม่รวม1ซึ่งเป็นตัวหารเชิงบวกอย่างเคร่งครัดเท่านั้น

อัลกอริทึมของคุณจะต้องถูกกำหนดไว้ (เช่นสร้างผลลัพธ์ที่ถูกต้องด้วยความน่าจะเป็น 1) และในทางทฤษฎีควรทำงานกับจำนวนเต็มขนาดใหญ่โดยพลการ ในทางปฏิบัติคุณอาจสมมติว่าอินพุตสามารถเก็บไว้ในชนิดข้อมูลของคุณได้ตราบใดที่โปรแกรมทำงานสำหรับจำนวนเต็มตั้งแต่ 1 ถึง 255

อินพุต

• หากภาษาของคุณสามารถอ่านได้จาก STDIN ยอมรับอาร์กิวเมนต์บรรทัดคำสั่งหรือรูปแบบอื่น ๆ ของการป้อนข้อมูลผู้ใช้คุณสามารถอ่านจำนวนเต็มเป็นการแทนทศนิยมการแสดงแบบ unary (ใช้อักขระที่คุณเลือก) อาร์เรย์ไบต์ (ใหญ่หรือใหญ่) little endian) หรือไบต์เดียว (หากนี่เป็นประเภทข้อมูลที่ใหญ่ที่สุดในภาษาของคุณ)

• หาก (และเฉพาะในกรณี) ภาษาของคุณไม่สามารถยอมรับการป้อนข้อมูลของผู้ใช้ใด ๆ คุณอาจเข้ารหัสรหัสในโปรแกรมของคุณได้

  ในกรณีนี้จำนวนเต็มฮาร์ดโค้ดต้องสามารถแลกเปลี่ยนได้ง่าย โดยเฉพาะมันอาจปรากฏในที่เดียวในโปรแกรมทั้งหมด

  เพื่อวัตถุประสงค์ในการให้คะแนนส่งโปรแกรมที่สอดคล้องกับการป้อนข้อมูล1

เอาท์พุต

ต้องเขียนเอาต์พุตไปที่ STDOUT หรือใกล้เคียงที่สุด

หากเป็นไปได้ผลลัพธ์ควรประกอบด้วยค่าจริงหรือค่าเท็จเท่านั้น (หรือการแสดงสตริงของมัน) ตามด้วยทางเลือกขึ้นบรรทัดใหม่เดียว

ข้อยกเว้นสำหรับกฎนี้เท่านั้นคือเอาต์พุตแบบคงที่ของล่ามภาษาของคุณที่ไม่สามารถระงับได้เช่นคำทักทายรหัสสี ANSI หรือการเยื้อง

กฎเพิ่มเติม

• นี่ไม่ใช่เกี่ยวกับการค้นหาภาษาด้วยวิธีที่สั้นที่สุดสำหรับการทดสอบที่สำคัญนี่คือเกี่ยวกับการค้นหาวิธีที่สั้นที่สุดในทุกภาษา ดังนั้นจะไม่มีการทำเครื่องหมายคำตอบว่าเป็นที่ยอมรับ

• การส่งในภาษาส่วนใหญ่จะได้คะแนนเป็นไบต์ในการเข้ารหัสที่มีมาก่อนโดยทั่วไป (แต่ไม่จำเป็น) UTF-8

  ยกตัวอย่างเช่นภาษาPietจะได้คะแนนเป็นโคเดลซึ่งเป็นตัวเลือกที่เป็นธรรมชาติสำหรับภาษานี้

  บางภาษาเช่นโฟลเดอร์นั้นค่อนข้างยากที่จะทำคะแนน หากมีข้อสงสัยกรุณาสอบถามในMeta

• แตกต่างจากกฎทั่วไปของเราอย่าลังเลที่จะใช้ภาษา (หรือรุ่นภาษา) แม้ว่าจะใหม่กว่าความท้าทายนี้ หากใครต้องการที่จะทำสิ่งนี้โดยการสร้างภาษาที่โปรแกรมว่างทำการทดสอบแบบดั้งเดิมแล้วขอแสดงความยินดีสำหรับการปูทางสำหรับคำตอบที่น่าเบื่อมาก

  โปรดทราบว่าจะต้องมีล่ามเพื่อให้สามารถส่งการทดสอบได้ ได้รับอนุญาต (และสนับสนุนให้) เขียนล่ามนี้ด้วยตัวคุณเองสำหรับภาษาที่ยังไม่ได้ใช้งานมาก่อน

• หากภาษาที่คุณเลือกนั้นแตกต่างจากภาษาอื่น (อาจเป็นที่นิยมมากกว่า) ซึ่งมีคำตอบอยู่แล้ว (คิดว่าภาษาเบสิกหรือภาษา SQL, เชลล์ Unix หรืออนุพันธ์ Brainfuck ที่น่าสนใจเช่น Headsecks หรือ Unary) ให้เพิ่มบันทึกย่อลงในคำตอบที่มีอยู่ว่า วิธีการแก้ปัญหาที่เหมือนกันหรือคล้ายกันมากนั้นก็เป็นทางสั้นที่สุด

• Built-in ฟังก์ชั่นสำหรับการทดสอบ primality จะได้รับอนุญาต ความท้าทายนี้มีวัตถุประสงค์เพื่อจัดทำแคตตาล็อกโซลูชันที่สั้นที่สุดที่เป็นไปได้ในแต่ละภาษาดังนั้นหากการใช้งานบิวท์อินในภาษาของคุณสั้นลง

• จนกว่าพวกเขาจะได้รับการตกไปก่อนหน้านี้ทุกมาตรฐานรหัสกอล์ฟกฎรวมทั้งhttp://meta.codegolf.stackexchange.com/q/1061

โปรดอย่าลดคำตอบที่น่าเบื่อ (แต่ใช้ได้) ในภาษาที่มีกอล์ฟไม่มากนัก สิ่งเหล่านี้ยังคงมีประโยชน์สำหรับคำถามนี้เนื่องจากพยายามรวบรวมแค็ตตาล็อกให้เสร็จสมบูรณ์ที่สุด อย่างไรก็ตามให้ตอบคำถามเป็นหลักในภาษาที่ผู้เขียนต้องใช้ความพยายามในการเล่นกอล์ฟ

แค็ตตาล็อก

สแต็คส่วนย่อยที่ด้านล่างของโพสต์นี้สร้างแคตตาล็อกจากคำตอบ a) เป็นรายการคำตอบสั้นที่สุดต่อภาษาและ b) เป็นลีดเดอร์บอร์ดโดยรวม

เพื่อให้แน่ใจว่าคำตอบของคุณปรากฏขึ้นโปรดเริ่มคำตอบด้วยหัวข้อโดยใช้เทมเพลต Markdown ต่อไปนี้:

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

สวัสดีชาวโลก! , 13

hello, world!

Hexagony , 29 ไบต์

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

รหัสนี้รุ่นที่อ่านได้คือ:

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

คำอธิบาย: มันทดสอบว่ามีจำนวนตั้งแต่ 2 ถึง n-1 ที่หาร n

การเริ่มต้น:

เขียน n ในเซลล์หน่วยความจำหนึ่งและ n-1 ในอีกเซลล์หนึ่ง:

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

กรณีพิเศษ n = 1:

พิมพ์ 0 และยุติ

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

วงวน

คำนวณ n% a และลด a ยุติถ้า a = 1 หรือ n% a = 0

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

กรณี a = 1:

เพิ่ม 0 เป็น 1 พิมพ์และยุติ (ตัวชี้คำสั่งทำงานในทิศทาง NE และลูปจากมุมตะวันออกไปยังมุมตะวันตกเฉียงใต้และ $ ทำให้แน่ใจว่ามันละเว้นคำสั่งถัดไป)

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

กรณี a% n = 0:

พิมพ์ 0 และยุติ (ตัวชี้คำสั่งกำลังทำงาน SW และวนไปด้านบนไปที่ @

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

Hexagony , 218 92 58 55 ไบต์

แจ้งให้ทราบล่วงหน้า:คำตอบนี้ได้รับการตีอย่างแน่นหนาด้วยโซลูชั่น 4 ความยาวด้านโดย Etoplay

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

โปรแกรม Hexagony (เช่นไม่ใช่เชิงเส้น) แรกที่ไม่สำคัญ! มันขึ้นอยู่กับวิธีการยกกำลังสองปัจจัยเดียวกับคำตอบที่เขาวงกตของ SP3000 หลังจากเริ่มด้วยขนาดหกเหลี่ยมของขนาด 10 ฉันสามารถบีบอัดให้มีขนาด 5 ลงไปได้อย่างไรก็ตามฉันสามารถนำรหัสที่ซ้ำกันมาใช้ซ้ำได้และยังคงไม่มีรหัสในเครือดังนั้นขนาด 4 อาจเพียงเป็นไปได้

คำอธิบาย

เพื่อให้เข้าใจถึงโค้ดอันดับแรกเราต้องแฉมัน Hexagony แผ่นรหัสแหล่งใดไปยังหมายเลขที่อยู่ถัดจากศูนย์กลางหกเหลี่ยมไม่มี-Ops ( .) 61ซึ่งเป็น จากนั้นจะจัดเรียงรหัสใหม่เป็นรูปหกเหลี่ยมปกติของขนาดที่สอดคล้องกัน:

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

นี่เป็นเกมที่ค่อนข้างหนักด้วยการข้ามและทับซ้อนเส้นทางการดำเนินการและตัวชี้คำแนะนำ (IPs) หลายตัว เพื่ออธิบายวิธีการทำงานให้ดูที่รุ่นที่ไม่ได้รับการควบคุมโดยที่โฟลว์การควบคุมไม่ผ่านขอบใช้ IP เพียงอันเดียวเท่านั้นและพา ธ การดำเนินการนั้นง่ายที่สุดเท่าที่จะทำได้:

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

^{หมายเหตุด้านข้าง: โค้ดด้านบนเริ่มต้นด้วยการดำเนินการบรรทัดแรกซึ่งเต็มไปด้วยไม่มีตัวเลือก จากนั้นเมื่อ IP ชนกับขอบตะวันออกเฉียงเหนือมันจะไปที่มุมซ้ายสุด ( )) ที่ซึ่งรหัสจริงเริ่มต้น}

ก่อนที่เราจะเริ่มคำเกี่ยวกับรูปแบบหน่วยความจำของ Hexagony มันเหมือนกับเทปของ Brainfuck บนเตียรอยด์ ในความเป็นจริงมันไม่ใช่เทป แต่เป็นตารางหกเหลี่ยมตัวเอง (ไม่มีที่สิ้นสุด) โดยที่แต่ละขอบมีค่าจำนวนเต็มซึ่งเริ่มต้นที่ 0 (และเมื่อเทียบกับ Brainfuck มาตรฐานค่าจะลงนามจำนวนเต็มความแม่นยำโดยพลการ) สำหรับโปรแกรมนี้เราจะใช้สี่ขอบ:

เราจะคำนวณปัจจัยบนขอบ, นับถอยหลังป้อนข้อมูลของเราบนขอบCและจัดเก็บสำเนาของการป้อนข้อมูลอื่น (โมดูโล) ที่อยู่บนขอบD Bใช้เป็นขอบชั่วคราวสำหรับการคำนวณ

ตัวชี้หน่วยความจำ (MP) เริ่มต้นที่ขอบAและทิศเหนือ (นี่เป็นสิ่งสำคัญสำหรับการเลื่อน MP ไปรอบ ๆ ) ตอนนี้ที่นี่เป็นบิตแรกของรหัส:

)}?}=&{

)เพิ่มขอบเพื่อเป็นพื้นฐานของปัจจัยที่ ทำให้ MP เลี้ยวขวาเช่นเลื่อนไปที่ขอบC (ชี้ทิศตะวันออกเฉียงเหนือ) ที่นี่เราอ่านเข้าเป็นจำนวนเต็มกับ จากนั้นเราก็ใช้เวลาอีกเลี้ยวขวาไปที่ขอบDด้วย ฝืน MP ที่ดังกล่าวว่าจุดที่จุดสุดยอดที่ใช้ร่วมกันกับC คัดลอกค่าจากC (อินพุต) ไปยังD - ค่าจะถูกคัดลอกจากทางซ้ายเนื่องจากค่าปัจจุบันไม่ใช่ค่าบวก (ศูนย์) สุดท้ายเราทำให้ MP ใช้ซ้ายหันกลับไปที่Cกับ1}?}=&{

ถัดไป<เป็นเทคนิคสาขา แต่เรารู้ว่าค่าปัจจุบันเป็นบวกดังนั้น IP >มักจะเลี้ยวขวาไปทาง สาขาตีจากด้านข้างทำหน้าที่เป็นกระจกเช่นว่า IP ย้ายแนวนอนอีกครั้งต่อ(ซึ่ง decrements ค่าในC

สาขาต่อไป<คือจริงสาขาในขณะนี้ นี่คือวิธีการที่เราห่วงจากลงไปn-1 1ในขณะที่ค่าปัจจุบันในCเป็นบวก IP จะเลี้ยวขวา (เพื่อดำเนินการวนรอบ) เมื่อเราไปถึงศูนย์มันจะเลี้ยวซ้ายแทน

ลองดูที่ "ร่างกาย" วนรอบ |เป็นกระจกที่เรียบง่าย>และ<ยังใช้เป็นกระจกอีกครั้ง นั่นหมายถึงร่างกายที่แท้จริงของห่วงเดือดลงไป

}=)&}=*}=

}ย้ายไปที่ขอบ MP B , =ฝืนทิศทางที่จะเผชิญกับจุดสุดยอดเอบีซี )เพิ่มค่า: นี่เป็นเพียงที่เกี่ยวข้องกับการทำซ้ำครั้งแรกที่มูลค่าของBยังคงเป็นศูนย์: เราต้องการให้แน่ใจว่ามันเป็นบวกเช่นที่คำสั่งต่อไป&คัดลอกเพื่อนบ้านที่ถูกต้องคือAคือมูลค่าปัจจุบันของแฟคทอเรียล การคำนวณลงในB

}แล้วย้ายไป MP , ฝืนมันอีกครั้งที่จะเผชิญกับจุดสุดยอดที่พบบ่อย คูณทั้งเพื่อนบ้านเช่นขอบBและCและร้านค้าผลใน สุดท้ายเรามีอีกจะกลับไปที่Cยังคงหันหน้าไปทางจุดสุดยอดเอบีซี=*}=

ฉันหวังว่าคุณสามารถดูวิธีการคำนวณนี้ปัจจัยของn-1ใน

ตอนนี้เราทำเสร็จแล้วตัวนับลูปในCคือศูนย์ เราต้องการตัดแฟกทอเรียลจากนั้นนำโมดูโลเข้ากับอินพุต นั่นคือสิ่งที่รหัสนี้ทำ:

&}=*{&'%!@

ตั้งแต่Cเป็นศูนย์&สำเนาเพื่อนบ้านซ้ายคือปัจจัยใน ย้ายไปBและเก็บสินค้าของทั้งสองสำเนาของปัจจัย (เช่นตาราง) ในB ย้ายกลับไปที่Cแต่ไม่ย้อนกลับ MP เรารู้ว่ามูลค่าปัจจุบันอยู่ในขณะนี้ในเชิงบวกเพื่อให้การป้อนข้อมูลสำเนาจากDลงในC MP ที่ย้อนกลับไปทางขวาคือบน โปรดจำไว้ว่าตารางของปัจจัยที่อยู่ในBและใส่อยู่ในC ดังนั้นคำนวณสิ่งที่เรากำลังมองหา}=*{&'%(n-1)!^2 % n!พิมพ์ผลลัพธ์เป็นจำนวนเต็ม (0 หรือ 1) และ@ยกเลิกโปรแกรม

โอเค แต่นั่นเป็นเวอร์ชั่นที่ไม่ดี แล้วเวอร์ชั่นกอล์ฟล่ะ? คุณจำเป็นต้องรู้สองสิ่งเพิ่มเติมเกี่ยวกับ Hexagony:

1. ขอบล้อมรอบ หาก IP ชนขอบของรูปหกเหลี่ยมมันจะกระโดดไปที่ขอบตรงข้าม สิ่งนี้คลุมเครือเมื่อ IP เข้ามุมตรงดังนั้นการกดที่มุมก็ทำหน้าที่เป็นสาขา: ถ้าค่าปัจจุบันเป็นบวก IP จะข้ามไปที่ขอบกริดไปทางขวามิฉะนั้นจะอยู่ทางซ้าย
2. มี6 IP จริงๆ แต่ละคนเริ่มต้นในมุมที่แตกต่างย้ายไปตามขอบในทิศทางตามเข็มนาฬิกา มีเพียงหนึ่งรายการเท่านั้นที่ใช้งานได้ในแต่ละครั้งซึ่งหมายความว่าคุณสามารถละเว้น 5 IP อื่น ๆ หากคุณไม่ต้องการ คุณสามารถสลับไป IP ถัดไป (ในการสั่งซื้อตามเข็มนาฬิกา) ด้วยและก่อนหน้านี้หนึ่งด้วย] [(คุณสามารถเลือกอันใดอันหนึ่งด้วย#แต่นั่นเป็นอีกครั้ง)

นอกจากนี้ยังมีคำสั่งใหม่ไม่กี่ในมัน\และ/เป็นกระจกเหมือน|และคูณค่าปัจจุบันโดย~-1

ดังนั้นเวอร์ชั่นที่ไม่ได้แปลจึงแปลไปยังรุ่นที่ตีกอล์ฟได้อย่างไร รหัสการตั้งค่าเชิงเส้น)}?}=&{และโครงสร้างลูปพื้นฐานสามารถพบได้ที่นี่:

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

ทีนี้ร่างกายวนรอบข้ามขอบสองสามครั้ง แต่ที่สำคัญที่สุดการคำนวณที่แท้จริงถูกส่งไปยัง IP ก่อนหน้า (ซึ่งเริ่มต้นที่มุมซ้ายเคลื่อนไปทางตะวันออกเฉียงเหนือ):

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

หลังจากกระดอนออกจากกิ่งไม้ไปทางตะวันออกเฉียงใต้ IP ก็ล้อมรอบขอบทั้งสอง=ที่มุมบนซ้าย (ซึ่งรวมกันเป็นแบบไม่มี op) จากนั้นก็กระเด้งออก/มา ~ตีความสัญลักษณ์ของมูลค่าปัจจุบันซึ่งเป็นสิ่งสำคัญสำหรับการทำซ้ำที่ตามมา IP ล้อมรอบขอบเดียวกันอีกครั้งและในที่สุดก็ถึง[จุดที่การควบคุมมอบให้กับ IP อื่น

ตอนนี้อันนี้ทำการประมวลผล~}=)&}=*}ซึ่งจะยกเลิกการปฏิเสธและจากนั้นก็วิ่งร่างลูปที่ไม่ได้รับการแก้ไข (ลบด้วย=) ในที่สุดมันก็จะกระทบกับ]ที่มือควบคุมกลับไปที่ IP ดั้งเดิม (โปรดทราบว่าในครั้งต่อไปเราเรียกใช้งาน IP นี้มันจะเริ่มจากจุดที่มันค้างเอาไว้ดังนั้นมันจะเข้ามุมครั้งแรกเราต้องการค่าปัจจุบันเป็นลบเพื่อให้ IP กระโดดกลับไปที่ขอบตะวันตกเฉียงเหนือ แทนที่จะเป็นทางตะวันออกเฉียงใต้)

เมื่อ IP ดั้งเดิมกลับมาทำงานต่อการควบคุมก็จะเด้งออก\มาดำเนินการส่วนที่เหลือ=จากนั้น>กดปุ่มเพื่อเข้าสู่การวนซ้ำครั้งถัดไป

ตอนนี้ส่วนที่บ้าจริงๆ: เกิดอะไรขึ้นเมื่อลูปสิ้นสุดลง?

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

IP เคลื่อนไปทางตะวันออกเฉียงเหนือเป็นรูปแบบ<และล้อมรอบไปทางทิศตะวันออกเฉียงเหนือ ดังนั้นมันจะจบลงบนพา ธ การประมวลผลเดียวกับลูปบอดี้ ( &}=*}]) ซึ่งจริง ๆ แล้วค่อนข้างเย็นเพราะนั่นเป็นรหัสที่เราต้องการเรียกใช้ ณ จุดนี้อย่างน้อยถ้าเราเพิ่มอีกอัน=}(เพราะ}=}เทียบเท่า{) แต่วิธีนี้ไม่ได้เข้าสู่วงก่อนหน้าอีกครั้งได้อย่างไร เนื่องจาก]การเปลี่ยนแปลง IP ถัดไปซึ่งตอนนี้เป็น IP (ยังไม่ได้ใช้จนถึงตอนนี้) ซึ่งเริ่มต้นที่มุมขวาบนเคลื่อนไปทางตะวันตกเฉียงใต้ จากนั้น IP จะดำเนินต่อไปตามขอบตัดไปที่มุมบนซ้ายเลื่อนลงไปตามแนวทแยงมุมกระดอนออก|และสิ้นสุดลงใน@ขณะที่ดำเนินการบิตสุดท้ายของรหัสเชิงเส้น:

=}&)('%!@

( )(แน่นอนว่าไม่มี op - ฉันต้องเพิ่ม(เพราะ)มันมีอยู่แล้ว)

วุ้ย ... เป็นเรื่องยุ่งเหยิง ...

Pyth, 4 ไบต์

}QPQ

พิมพ์หรือTrueFalse

เรติน่า 16 ไบต์

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

ลองออนไลน์!

เริ่มต้นให้กับคลาสสิก: เฉพาะการตรวจสอบกับนิพจน์ทั่วไป อินพุตควรได้รับในรูปแบบunaryโดยใช้อักขระที่พิมพ์ซ้ำได้ ชุดการทดสอบประกอบด้วยการแปลงจากทศนิยมเป็น unary เพื่อความสะดวก

โปรแกรม Retina ประกอบด้วยบรรทัดเดียวถือว่าบรรทัดนั้นเป็น regex และพิมพ์จำนวนการจับคู่ที่พบในอินพุตซึ่งจะเป็น0ตัวเลขคอมโพสิตและ1สำหรับช่วงเวลา

lookahead ช่วยให้มั่นใจได้ว่าอินพุตไม่ได้ประกอบกัน: การย้อนรอยจะลองทุกสตริงย่อยที่เป็นไปได้ (อย่างน้อย 2 ตัวอักษร) สำหรับ(..+)lookahead จากนั้นจะพยายามจับคู่ส่วนที่เหลือของอินพุตด้วยการทำซ้ำสิ่งที่ถูกจับที่นี่ หากเป็นไปได้นั่นหมายถึงอินพุตมีตัวหารมากกว่า 1 แต่น้อยกว่านั้น หากเป็นกรณีนี้การมองเชิงลบจะทำให้การแข่งขันล้มเหลว สำหรับจำนวนเฉพาะไม่มีความเป็นไปได้ดังกล่าวและการแข่งขันดำเนินต่อไป

ปัญหาเดียวก็คือว่า lookahead นี้ยังยอมรับดังนั้นเราจึงกฎที่ออกโดยการจับคู่อย่างน้อยสองตัวอักษรที่มี1..

CJam, 4 ไบต์

qimp

CJam มีผู้ปฏิบัติงานในตัวสำหรับการทดสอบเบื้องต้น

HTML + CSS, _{สูงสุด} 254 + n _{สูงสุด} * 28 ไบต์

เราสามารถตรวจสอบสภาพดั้งเดิมโดยใช้การแสดงออกปกติ Mozilla มี@documentซึ่งถูกกำหนดเป็น:

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

เพื่อกรององค์ประกอบผ่าน CSS ตาม URL ปัจจุบัน นี่คือการผ่านครั้งเดียวดังนั้นเราต้องทำสองขั้นตอน:

1. รับข้อมูลจากผู้ใช้ ข้อมูลนี้จะต้องสะท้อนให้เห็นอย่างใดใน URL ปัจจุบัน
2. ตอบกลับผู้ใช้ในรหัสน้อยที่สุด

1. การรับอินพุต

วิธีที่สั้นที่สุดที่ฉันสามารถคิดเพื่อรับอินพุตและถ่ายโอนไปยัง URL คือGETฟอร์มที่มีช่องทำเครื่องหมาย สำหรับ regex เราแค่ต้องการสตริงที่ไม่ซ้ำกันเพื่อนับจำนวนที่ปรากฏ

ดังนั้นเราเริ่มต้นด้วยสิ่งนี้ (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. แสดงคำตอบ

เราต้องการ CSS (159 ไบต์) เพื่อเลือกการ<p>แสดง (1 หรือ 0):

#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 (Firefox เท่านั้น)

ช่วยเหลือ WarDoq! 1 ไบต์

P

เอาท์พุท 1 ถ้าอินพุทเป็นจำนวนเฉพาะมิฉะนั้นจะเป็น 0

Hexagony , 28 ไบต์

ตั้งแต่Etoplayอย่างคู่แข่งขันฉันในคำถามนี้ผมรู้สึกว่าผมต้อง outgolf เฉพาะอื่น ๆ ของเขาคำตอบ

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

ลองออนไลน์!

ฉันใช้ทฤษฎีบทของวิลสันเหมือนมาร์ตินในคำตอบของเขา: ให้nฉันเอาท์พุท(n-1!)² mod n

นี่คือโปรแกรมที่กางออก:

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

และนี่คือเวอร์ชันที่อ่านได้ :

คำอธิบาย:

โปรแกรมที่มีสามขั้นตอนหลัก: initialisation , ปัจจัยและเอาท์พุท

โมเดลหน่วยความจำของ Hexagony เป็นกริดหกเหลี่ยมที่ไม่มีที่สิ้นสุด ฉันใช้ตำแหน่งหน่วยความจำ 5 แห่งดังที่แสดงในแผนภาพนี้:

ฉันจะอ้างอิงตำแหน่งเหล่านี้ (และจำนวนเต็มที่จัดเก็บในพวกเขา) โดยป้ายกำกับของพวกเขาในแผนภาพนั้น

initialisation:

ตัวชี้คำสั่ง ( IP ) เริ่มต้นที่มุมซ้ายบนไปทางตะวันออก ตัวชี้หน่วยความจำ ( MP ) เริ่มต้นที่ใน

ครั้งแรกที่?อ่านตัวเลขจากการป้อนข้อมูลและเก็บไว้ในIN IP\อยู่บนเส้นทางสีฟ้าสะท้อนจาก ลำดับ"&(ย้ายMPกลับไปทางซ้าย (ไปยังA ) คัดลอกค่าจากINไปยังAและลดค่าลง

IPแล้วออกจากด้านหนึ่งของรูปหกเหลี่ยมและใหม่เข้ามาในด้านอื่น ๆ (บนเส้นทางสีเขียว) มันรัน'+ซึ่งย้ายMPเพื่อBและสำเนาสิ่งที่อยู่ใน เปลี่ยนเส้นทางIPไปทางทิศตะวันตก<

factorial:

ฉันคำนวณแฟคทอเรียลในวิธีเฉพาะเพื่อให้การยกกำลังสองนั้นเป็นเรื่องง่าย ฉันเก็บn-1!ทั้งในBและCดังนี้

ตัวชี้คำสั่งเริ่มต้นบนเส้นทางสีน้ำเงินมุ่งหน้าไปทางตะวันออก

='กลับทิศทางของMPและย้ายมันไปข้างหลังเพื่อC สิ่งนี้เทียบเท่ากับ{=การมี=ประโยชน์ในภายหลัง

&{สำเนาค่าจากเพื่อCแล้วย้ายMPกลับไป IPแล้วตามเส้นทางสีเขียวทำอะไรก่อนที่จะถึงเส้นทางสีแดงตีและจะเข้าสู่เส้นทางสีส้ม\

ด้วย(>เราลดค่าAและเปลี่ยนเส้นทางIP East ที่นี่มันกระทบสาขา: <. สำหรับบวกAเราดำเนินการตามเส้นทางสีส้ม ไม่เช่นนั้นIPจะได้รับการมุ่งไปทางตะวันออกเฉียงเหนือ

'*ย้ายMPเพื่อBและเก็บ* CในB นี้เป็นที่แรกคือการป้อนข้อมูล IPจากนั้นก็เข้าไปกลับเข้ามาในวงเริ่มต้นและยังคง decrementing และคูณจนกว่าต้นน้ำ (คำนวณ)(n-1)*(n-2)n0n-1!

หมายเหตุ : ในลูปต่อไปนี้&เก็บค่าจากBในCเนื่องจากCมีค่าเป็นบวกเก็บไว้ในตอนนี้ สิ่งนี้มีความสำคัญต่อการคำนวณแบบแฟคทอเรียล

เอาท์พุท:

เมื่อต้นน้ำ สาขานำIPไปตามเส้นทางสีน้ำเงินแทน0

=*ฝืนMPและร้านค้าค่าของB * Cใน จากนั้นIPจะออกจากรูปหกเหลี่ยมและกลับเข้าสู่เส้นทางสีเขียวอีกครั้ง การดำเนินการ นี้ย้ายMPที่จะออกและคำนวณmod ในหรือ"%(n-1!)² mod n

ต่อไปนี้{"ทำหน้าที่เป็นแบบไม่ op, เป็นพวกเขายกเลิกกันออก !พิมพ์ผลลัพธ์สุดท้ายและจะดำเนินการก่อนที่จะเลิกจ้าง:*+'(@

หลังจากดำเนินการ (มีอินพุต5) หน่วยความจำจะมีลักษณะดังนี้:

_{ภาพที่สวยงามของการควบคุมการไหลที่ถูกสร้างขึ้นโดยใช้Timwi ของ Hexagony Coloror}

^{ขอบคุณMartin Ender ที่สร้างภาพทั้งหมดเพราะฉันทำไม่ได้บนพีซี}

Mornington Crescent , 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ในEsoteric IDEรวมถึงการเพิ่มอินพุตและการแจงจำนวนเต็มในการกำหนดภาษา

อันนี้น่าจะดีกว่า "Hello, World!" เพราะครั้งนี้ฉันเขียนสคริปต์ CJam เพื่อช่วยฉันค้นหาเส้นทางที่สั้นที่สุดระหว่างสองสถานี หากคุณต้องการใช้ (แม้ว่าฉันไม่รู้ว่าทำไมใครต้องการ ... ) คุณสามารถใช้ล่ามออนไลน์ได้ วางรหัสนี้:

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

ที่นี่สองบรรทัดแรกคือสถานีที่คุณต้องการตรวจสอบ รวมทั้งวางเนื้อหาของpastebin นี้ลงในหน้าต่างการป้อนข้อมูล

ผลลัพธ์จะแสดงให้คุณเห็นว่าสายใดบ้างที่มีอยู่ในสองสถานีจากนั้นรายการของสถานีทั้งหมดที่เชื่อมต่อทั้งสองโดยเรียงตามความยาวของชื่อสถานี มันแสดงให้เห็นทั้งหมดของพวกเขาเพราะบางครั้งมันจะดีกว่าถ้าใช้ชื่อที่ยาวกว่านั้นเพราะมันยอมให้มีบรรทัดที่สั้นกว่าหรือเพราะสถานีนั้นพิเศษ (เช่น Bank หรือ Temple) เพื่อให้คุณต้องการหลีกเลี่ยง มีกรณีขอบบางกรณีที่สถานีสองสถานีไม่ได้เชื่อมต่อกันด้วยสถานีอื่น ๆ (โดยเฉพาะอย่างยิ่งสายนครหลวงและเขตไม่เคยข้าม) ซึ่งในกรณีนี้คุณจะต้องหาวิธีอื่นอย่างอื่น ;)

สำหรับรหัส MC ที่เกิดขึ้นจริงนั้นขึ้นอยู่กับวิธี squared-factorial เช่นเดียวกับคำตอบอื่น ๆ อีกมากมายเนื่องจาก MC มีการคูณการหารและโมดูโล นอกจากนี้ฉันคิดว่าการวนรอบเดียวจะสะดวก

ปัญหาหนึ่งคือลูปนั้นทำในขณะที่ลูปและการลดและการเพิ่มมีราคาแพงดังนั้นฉันจึงไม่สามารถคำนวณได้ง่าย(n-1)!(สำหรับn > 0) แต่ฉันคำนวณn!แล้วหารด้วยnตอนท้าย ฉันแน่ใจว่ามีทางออกที่ดีกว่าสำหรับเรื่องนี้

เมื่อฉันเริ่มเขียนสิ่งนี้ฉันคิดว่าการจัดเก็บ-1ในแฮมเมอร์สมิ ธ เป็นความคิดที่ดีดังนั้นฉันจึงสามารถลดราคาถูกลงได้ แต่ท้ายที่สุดสิ่งนี้อาจมีค่าใช้จ่ายมากกว่าที่บันทึกไว้ หากฉันพบว่ามีความอดทนที่จะทำสิ่งนี้ซ้ำฉันอาจลองแค่เดิน-1ไปรอบ ๆ ใน Upminster แทนเพื่อที่ฉันจะได้ใช้ Hammersmith เพื่อสิ่งที่มีประโยชน์มากกว่า

Brachylog (V2), 1 ไบต์

ṗ

ลองออนไลน์!

Brachylog (V1), 2 ไบต์

#p

สิ่งนี้ใช้เพรดิเคตในตัว#p - Primeซึ่ง จำกัด อินพุตให้เป็นจำนวนเฉพาะ

Brachylog เป็นความพยายามของฉันในการสร้าง Prolog รุ่นของ Golf Golf ซึ่งเป็นภาษาของรหัส Golf ที่ใช้ backtracking และ unification

โซลูชันสำรองที่ไม่มีในตัว: 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
)

Haskell, 49 ไบต์

การใช้xnor's Corollary กับทฤษฎีของ Wilson :

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

เขาวงกต , 29 ไบต์

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

อ่านจำนวนเต็มจาก STDIN ((n-1)!)^2 mod nและเอาท์พุท ทฤษฎีบทของ Wilsonค่อนข้างมีประโยชน์สำหรับความท้าทายนี้

โปรแกรมเริ่มต้นที่มุมบนซ้ายเริ่มต้น1ที่คูณด้านบนของสแต็คด้วย 10 และเพิ่ม 1 นี่คือวิธีของเขาวงกตในการสร้างจำนวนมาก แต่เนื่องจากสแต็คของเขาวงกตเต็มไปด้วยเลขศูนย์ผลสุดท้ายคือราวกับว่าเรา เพิ่งผลัก 1

?จากนั้นอ่านnจาก STDIN และ:ทำซ้ำ }เลื่อนnไปที่สแต็กเสริมที่จะใช้ในตอนท้ายสำหรับโมดูโล (จากนั้นลดลงnและเราพร้อมที่จะเริ่มคำนวณแฟคทอเรียลกำลังสอง

ที่สองของเรา:(ซ้ำ) อยู่ที่ทางแยกและที่นี่คุณสมบัติการไหลของการควบคุมเขาวงกตเข้ามาเล่น ที่ทางแยกหลังจากคำสั่งถูกดำเนินการถ้าด้านบนของสแต็คเป็นบวกเราเลี้ยวขวาสำหรับลบเราเลี้ยวซ้ายและเป็นศูนย์เราไปข้างหน้า หากคุณพยายามเลี้ยว แต่ชนกำแพงเขาวงกตจะทำให้คุณหันไปในทิศทางอื่นแทน

สำหรับn = 1เนื่องจากส่วนบนของสแต็กnลดลงหรือ0เราไปข้างหน้า จากนั้นเราจะตีไม่มี-op 'ตามการลดลงอีกซึ่งทำให้เราได้ที่( -1นี่เป็นเชิงลบดังนั้นเราเลี้ยวซ้ายดำเนินการ+บวก ( -1 + 0 = -1) {เพื่อเปลี่ยนnกลับจากสแต็คเสริมเป็นเมนและ%โมดูโล ( -1 % 1 = 0) จากนั้นเราจะส่งออกด้วยและยุติด้วย!@

สำหรับn > 1ในวินาทีที่:เราเลี้ยวขวา จากนั้นเราเลื่อนตัว}นับลูปที่คัดลอกไปยังสแต็คเสริมทำซ้ำ:และคูณสองครั้ง**ก่อนที่จะเลื่อนตัวนับถอยหลัง{และลด(ระดับ หากเรายังคงเป็นบวกเราพยายามเลี้ยวขวา แต่ทำไม่ได้ดังนั้นเขาวงกตทำให้เราเลี้ยวซ้ายแทนไปเรื่อย ๆ มิฉะนั้นด้านบนของสแต็คเป็นวงเคาน์เตอร์ของเราซึ่งได้รับการลดลงถึง 0 ซึ่งเราเพิ่มการคำนวณของเรา+ ((n-1)!)^2สุดท้ายเราเปลี่ยนnกลับมาพร้อมกับ{แล้ว modulo %การส่งออกและยุติ!@

ฉันบอกว่านั่น'ไม่ใช่ตัวเลือก แต่ก็สามารถใช้สำหรับการดีบักได้ วิ่งด้วย-dธงเพื่อดูสถานะของกองซ้อนทุกครั้งที่'ผ่านไป!

ยูทิลิตี Bash + GNU, 16

• บันทึกได้ 4 ไบต์ด้วย @Dennis

• บันทึก 2 ไบต์ด้วย @Lekensteyn

factor|awk NF==2

อินพุตเป็นหนึ่งบรรทัดที่นำมาจาก STDIN เอาท์พุทเป็นสตริงที่ว่างเปล่าสำหรับความเท็จและสตริงที่ไม่ว่างสำหรับความจริง เช่น:

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

Java, 126 121 ไบต์

ฉันเดาว่าเราต้องการคำตอบ Java สำหรับกระดานคะแนน ... ดังนั้นนี่คือการแบ่งการทดลองอย่างง่าย:

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);}}

ตามปกติสำหรับ Java ข้อกำหนด "full program" จะทำให้มีขนาดใหญ่กว่านั้นถ้าเป็นฟังก์ชันเนื่องจากส่วนใหญ่เป็น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);
    }
}

แก้ไข:แก้ไขและ regolfed โดย Peter ในความคิดเห็น ขอบคุณ!

Brain-Flak , 112 108 ไบต์

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

ลองออนไลน์!

มันทำงานอย่างไร

เริ่มแรกสแต็กแรกจะมีจำนวนเต็มบวกnสแต็กที่สองจะว่างเปล่า

เราเริ่มต้นด้วยการลดค่าnดังนี้

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

n = 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.

R, 37 29 ไบต์

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

ใช้แผนกทดลอง scan()อ่านจำนวนเต็มจาก STDIN และcat()เขียนไปยัง STDOUT

เราสร้างเวกเตอร์ของความยาวnประกอบด้วยเลข 1 ถึงโมดูโลn nเราทดสอบว่าแต่ละรายการเป็น 0 โดยการลบ ( !) ซึ่งจะส่งกลับค่าตรรกะที่เป็นจริงเมื่อจำนวนเป็น 0 และเท็จเมื่อมันมากกว่า 0 ผลรวมของเวกเตอร์เชิงตรรกะคือจำนวนองค์ประกอบที่แท้จริงและสำหรับจำนวนเฉพาะที่เราคาดหวัง เฉพาะโมดูลัสที่ไม่ใช่ศูนย์เท่านั้นที่จะเป็น 1 และnดังนั้นเราคาดว่าผลรวมจะเป็น 2

บันทึก 8 ไบต์ด้วย flodel!

TI-BASIC ขนาด 12 ไบต์

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

ตรงไปตรงมาสวย randIntNoRep(จะช่วยให้การเปลี่ยนแปลงแบบสุ่มของจำนวนเต็มทั้งหมดตั้งแต่ 1 Ansถึง

นี่ก้มกฏเล็กน้อย เนื่องจากรายการใน TI-BASIC ถูก จำกัด ที่ 999 องค์ประกอบที่ฉันตีความ

สมมติว่าอินพุตสามารถเก็บไว้ในชนิดข้อมูลของคุณ

ตามความหมายที่ประเภทข้อมูลทั้งหมดสามารถสันนิษฐานว่าจะรองรับการป้อนข้อมูล OP เห็นด้วยกับการตีความนี้

แก้ปัญหา 17 ไบต์ซึ่งใช้งานได้จริงถึง 10 ^ 12 หรือดังนั้น:

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

PARI / GP ขนาด 21 ไบต์

print(isprime(input))

ใช้งานได้กับอินพุตขนาดใหญ่ที่น่าขันเพราะสิ่งนี้เป็นสิ่งที่ PARI / GP ทำขึ้น

TI-BASIC ขนาด 24 ไบต์

โปรดทราบว่าโปรแกรม TI-Basic ใช้ระบบโทเค็นดังนั้นจำนวนตัวอักษรจะไม่ส่งกลับค่าไบต์ที่แท้จริงของโปรแกรม

คำตอบของ Upvote Thomas Kwaนั้นยอดเยี่ยม

: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ถ้าเป็น

Stack Cats , 62 + 4 = 66 bytes

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

จำเป็นต้องรันด้วย-lnแฟล็กบรรทัดคำสั่ง (ด้วยเหตุนี้จึงมีความยาว +4 ไบต์) พิมพ์0สำหรับหมายเลขคอมโพสิตและ1สำหรับช่วงเวลา

ลองออนไลน์!

ฉันคิดว่านี่เป็นโปรแกรม Stack Cats ที่ไม่ใช่เรื่องแรก

คำอธิบาย

การแนะนำ Stack Stack ด่วน:

• Stack Cats ทำงานบนเทปที่ไม่มีที่สิ้นสุดของสแต็กโดยมีหัวเทปที่ชี้ไปที่สแต็กปัจจุบัน สแต็กทุกครั้งจะถูกเติมด้วยจำนวนศูนย์ที่ไม่ จำกัด ฉันมักจะไม่สนใจค่าศูนย์เหล่านี้ในถ้อยคำของฉันดังนั้นเมื่อฉันพูดว่า "ด้านล่างของสแต็ค" ฉันหมายถึงค่าต่ำสุดที่ไม่เป็นศูนย์และถ้าฉันบอกว่า "สแต็กว่างเปล่า" ฉันหมายความว่ามีศูนย์อยู่
• ก่อนที่โปรแกรมจะเริ่มทำงาน a -1จะถูกพุชไปยังสแต็กเริ่มต้นจากนั้นอินพุตทั้งหมดจะถูกผลักไปที่ด้านบนของรายการนั้น ในกรณีนี้เนื่องจาก-nแฟล็กอินพุตจะถูกอ่านเป็นจำนวนเต็มฐานสิบ
• ในตอนท้ายของโปรแกรมสแต็กปัจจุบันจะใช้สำหรับการส่งออก หากมี-1ด้านล่างก็จะถูกละเว้น อีกครั้งเนื่องจากการ-nตั้งค่าสถานะค่าจากสแต็กจะพิมพ์เป็นจำนวนเต็มทศนิยมที่แยกบรรทัดด้วยตัวป้อนบรรทัด
• Stack Cats เป็นภาษาโปรแกรมที่สามารถย้อนกลับได้: โค้ดทุกชิ้นสามารถยกเลิกได้ (โดยไม่มี Stack Cats คอยติดตามประวัติที่ชัดเจน) โดยเฉพาะอย่างยิ่งที่จะย้อนกลับชิ้นส่วนของรหัสใด ๆ คุณก็สะท้อนมันเช่นกลายเป็น<<(\-_) (_-/)>>เป้าหมายการออกแบบนี้วางข้อ จำกัด ที่ค่อนข้างรุนแรงเกี่ยวกับชนิดของตัวดำเนินการและโครงสร้างการไหลของการควบคุมที่มีอยู่ในภาษา

• ยิ่งไปกว่านั้นทุกโปรแกรม Stack Cats จะต้องมีความสมมาตรด้วยตนเอง คุณอาจสังเกตเห็นว่านี่ไม่ใช่กรณีของซอร์สโค้ดด้านบน นี่คือสิ่งที่-lธงมีไว้สำหรับ: โดยปริยายสะท้อนรหัสไปทางซ้ายโดยใช้อักขระตัวแรกสำหรับกึ่งกลาง ดังนั้นโปรแกรมจริงคือ:

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

การเขียนโปรแกรมอย่างมีประสิทธิภาพด้วยรหัสทั้งหมดนั้นไม่สำคัญและไม่ได้ใช้งานง่ายและยังไม่สามารถเข้าใจได้ว่ามนุษย์สามารถทำมันได้อย่างไร เรากำลังบังคับให้โปรแกรมดังกล่าวทำงานได้ง่ายขึ้น แต่จะไม่สามารถเข้าถึงได้ด้วยมือ โชคดีที่เราพบรูปแบบพื้นฐานซึ่งช่วยให้คุณไม่ต้องสนใจโปรแกรมครึ่งหนึ่ง ขณะนี้เป็นสิ่งที่ไม่ดีอย่างแน่นอนปัจจุบันเป็นวิธีเดียวที่รู้จักในการเขียนโปรแกรมอย่างมีประสิทธิภาพใน Stack Cats

ดังนั้นในคำตอบนี้เทมเพลตของรูปแบบที่กล่าวมานี้คือ (มีความแปรปรวนบางอย่างในวิธีการใช้งาน):

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

เมื่อโปรแกรมเริ่มต้นเทปสแต็กจะมีลักษณะเช่นนี้ (สำหรับอินพุต4พูด):

     4    
... -1 ...
     0
     ^

[ย้ายด้านบนของสแต็คไปทางซ้าย (และหัวเทปพร้อม) - เราเรียกสิ่งนี้ว่า "ผลักดัน" และ<ย้ายหัวเทปเพียงอย่างเดียว ดังนั้นหลังจากคำสั่งสองคำแรกเราก็มีสถานการณ์เช่นนี้:

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

ตอนนี้(...)คือลูปที่สามารถใช้งานได้ง่ายตามเงื่อนไข: ลูปจะถูกป้อนและปล่อยให้ต่อเมื่อด้านบนของสแต็กปัจจุบันเป็นบวก เนื่องจากปัจจุบันเป็นศูนย์เราจึงข้ามโปรแกรมครึ่งแรกไปทั้งหมด *ตอนนี้คำสั่งศูนย์เป็น นี่คือง่ายๆXOR 1คือมันสลับบิตที่สำคัญน้อยที่สุดของสแต็คและในกรณีนี้จะเปลี่ยน0เป็น1:

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

(...)ตอนนี้เราพบภาพสะท้อนของ คราวนี้ด้านบนของสแต็คเป็นบวกและเราทำใส่รหัส ก่อนที่เราจะดูว่าเกิดอะไรขึ้นในวงเล็บให้ฉันอธิบายว่าเราจะสรุปได้อย่างไร: เราต้องการให้แน่ใจว่าในตอนท้ายของบล็อกนี้เรามีหัวเทปในค่าบวกอีกครั้ง (เพื่อ ห่วงยุติหลังจากย้ำเดียวและถูกนำมาใช้เพียงเป็นเชิงเส้นเงื่อนไข) ที่สแต็คไปทางขวาถือเอาท์พุทและสแต็คขวาของที่-1ถือ หากเป็นเช่นนั้นเราจะปล่อยให้ลูป>เคลื่อนที่ไปยังค่าเอาต์พุตและ]ดันเข้าไปที่-1ดังนั้นเราจึงมีสแต็กที่สะอาดสำหรับเอาต์พุต

นั่นคือที่ ตอนนี้ในวงเล็บเราสามารถทำทุกอย่างที่เราต้องการตรวจสอบไพรเมอร์ได้ตราบใดที่เรามั่นใจว่าเราตั้งสิ่งต่าง ๆ ตามที่อธิบายไว้ในย่อหน้าก่อนหน้าในตอนท้าย (ซึ่งสามารถทำได้อย่างง่ายดายด้วยการกดและเคลื่อนหัวเทป) ครั้งแรกที่ฉันพยายามแก้ปัญหาด้วยทฤษฎีบทของ Wilsonแต่จบลงด้วยดีกว่า 100 ไบต์เนื่องจากการคำนวณแฟคทอเรียลกำลังสองนั้นค่อนข้างแพงใน Stack Cats (อย่างน้อยฉันก็ไม่ได้หาทางลัด) ดังนั้นฉันจึงไปกับแผนกทดลองแทนและมันก็ง่ายกว่ามาก ลองดูที่บิตเชิงเส้นแรก:

>:^]

คุณเห็นคำสั่งเหล่านั้นสองคำแล้ว นอกจากนี้:แลกเปลี่ยนค่าสองค่าสูงสุดของสแต็กปัจจุบันและ^XORs ค่าที่สองเป็นค่าสูงสุด สิ่งนี้ทำให้:^รูปแบบทั่วไปเพื่อทำซ้ำค่าในสแต็กเปล่า (เราดึงศูนย์ที่ด้านบนของค่าแล้วเปลี่ยนค่าศูนย์ให้เป็น0 XOR x = x) ดังนั้นหลังจากนี้หมวดเทปของเราจะเป็นดังนี้:

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

อัลกอริทึมการแบ่งรุ่นทดลองใช้ที่ฉันนำมาใช้ไม่ได้ผลสำหรับอินพุต1ดังนั้นเราควรข้ามโค้ดในกรณีนี้ เราสามารถ map 1ไป0และทุกอย่างอื่นไปเป็นค่าบวกด้วย*ดังนั้นนี่คือวิธีที่เราทำว่า

*(*...)

นั่นคือเรากลาย1เป็น0ข้ามส่วนใหญ่ของรหัสถ้าเราได้รับแน่นอน0แต่ภายในเราทันทีเลิกทำ*เพื่อให้เราได้รับค่าอินพุตของเรากลับมา เราแค่ต้องทำให้แน่ใจอีกครั้งว่าเราจบด้วยค่าบวกที่จุดสิ้นสุดของวงเล็บเพื่อที่พวกเขาจะไม่เริ่มวนซ้ำ ภายในเงื่อนไขเราย้ายหนึ่งสแต็คไปทางขวาด้วย>แล้วเริ่มวนรอบการแบ่งการทดลองหลัก:

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

การจัดฟัน (ตรงข้ามกับวงเล็บ) กำหนดการวนซ้ำที่แตกต่าง: มันเป็นการวนรอบขณะทำซึ่งหมายความว่ามันจะวนซ้ำอย่างน้อยหนึ่งครั้ง ข้อแตกต่างอื่น ๆ คือเงื่อนไขการเลิกจ้าง: เมื่อเข้าสู่ Loop Stack Cat จะจดจำค่าสูงสุดของ stack ปัจจุบัน ( 0ในกรณีของเรา) ลูปจะทำงานจนกว่าจะเห็นค่าเดียวกันนี้อีกครั้งเมื่อสิ้นสุดการวนซ้ำ สิ่งนี้สะดวกสำหรับเรา: ในการคำนวณซ้ำแต่ละครั้งเราเพียงคำนวณส่วนที่เหลือของตัวหารที่เป็นไปได้ถัดไปและย้ายไปยังสแต็กนี้เราจะเริ่มวนรอบ เมื่อเราพบตัวหารส่วนที่เหลือคือ0และลูปหยุด เราจะพยายามเริ่มต้นที่ตัวหารแล้วพร่องพวกเขาลงไปn-1 1นั่นหมายถึงก) เรารู้ว่าสิ่งนี้จะยุติลงเมื่อเราไปถึง1ที่ล่าสุดและ b) จากนั้นเราจะสามารถระบุได้ว่าเป็นจำนวนที่สำคัญหรือไม่โดยการตรวจสอบตัวหารที่ผ่านมาเราพยายาม (ถ้ามัน1ก็เป็นสำคัญมิฉะนั้นจะไม่ได้)

ไปกันเถอะ มีส่วนเส้นตรงสั้น ๆ ที่จุดเริ่มต้น:

<-!<:^>[:

คุณรู้แล้วว่าสิ่งเหล่านี้ส่วนใหญ่ทำอะไรในตอนนี้ คำสั่งใหม่และ- !Stack Cats ไม่มีตัวดำเนินการเพิ่มหรือลด อย่างไรก็ตามมันมี-(การปฏิเสธคือการคูณด้วย-1) และ!(bitwise NOT คือการคูณด้วย-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
    ^

เงื่อนไขถัดไปรวมเส้นทางเหล่านี้อีกครั้ง:

(<!-)

ในการทำซ้ำครั้งแรกหัวเทปชี้ไปที่ศูนย์ดังนั้นสิ่งนี้จะถูกข้ามทั้งหมด ในการทำซ้ำเพิ่มเติมหัวเทปชี้ไปที่หนึ่งดังนั้นเราจะดำเนินการนี้ย้ายไปทางซ้ายและเพิ่มเซลล์ที่นั่น เนื่องจากเรารู้ว่าเซลล์เริ่มจากศูนย์ตอนนี้มันจะเป็นค่าบวกเสมอเพื่อให้เราสามารถออกจากลูปได้ สิ่งนี้ทำให้เรามั่นใจได้ว่าจะมีสแต็กสองตัวที่เหลืออยู่ของสแต็กหลัก>>เสมอ -_จากนั้นในตอนท้ายของวงโมดูโลที่เราทำ -คุณรู้อยู่แล้วว่า _คือการลบสิ่ง^คือการแฮคเกอร์: ถ้าด้านบนของสแต็คเป็น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คอมโพสิตและ1สำหรับช่วงเวลา - เพียงสองค่าที่แตกต่าง แน่นอนพวกเขาอยู่ตรงข้ามของสิ่งที่เราต้องการที่จะส่งออก *แต่ที่ได้รับการแก้ไขได้อย่างง่ายดายอีกด้วย

ตอนนี้ทั้งหมดที่เหลือคือการเรียกคืนรูปแบบของกองโดยคาดว่ากรอบโดยรอบของเรา: หัวเทปเป็นค่าบวกส่งผลให้ด้านบนของสแต็คไปทางขวาและเป็นหนึ่งเดียว-1บนสแต็คขวาของที่ นี่คือสิ่งที่=<*มีไว้เพื่อ =สลับยอดของทั้งสองกองที่อยู่ติดกันดังนั้นเลื่อน-1ไปทางขวาของผลลัพธ์เช่นเพื่อป้อน4อีกครั้ง:

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

จากนั้นเราก็เลื่อนไปทางซ้ายด้วยและเปิดที่ศูนย์เป็นหนึ่งด้วย< *และนั่นคือสิ่งที่

หากคุณต้องการเจาะลึกลงไปถึงวิธีการทำงานของโปรแกรมคุณสามารถใช้ประโยชน์จากตัวเลือกการดีบัก ทั้งเพิ่ม-dธงและใส่"ทุกที่ที่คุณต้องการที่จะเห็นสถานะหน่วยความจำในปัจจุบันเช่นเช่นนี้หรือใช้-Dธงที่จะได้รับการติดตามที่สมบูรณ์ของโปรแกรมทั้งหมด หรือคุณสามารถใช้EsotericIDE ของ Timwiซึ่งรวมล่าม Stack Cats พร้อมดีบักเกอร์แบบเป็นขั้นตอน

Haskell, 54 ไบต์

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

ไม่มีอะไรมากที่จะอธิบาย

Ruby, 15 + 8 = 23 ไบต์

p$_.to_i.prime?

วิ่งตัวอย่าง:

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

JavaScript, 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 ไบต์เท่านั้นเพราะคำตอบ JavaScript ที่ดีที่สุดคือ 40 ไบต์แล้ว

หอยทาก 122

อินพุตควรถูกกำหนดใน unary ตัวเลขอาจเป็นอักขระผสมกันยกเว้นขึ้นบรรทัดใหม่

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

ในภาษาที่จับคู่รูปแบบ 2D นี้สถานะของโปรแกรมประกอบด้วยตำแหน่งกริดปัจจุบันเพียงอย่างเดียวชุดของเซลล์ที่ถูกจับคู่และตำแหน่งในโค้ดรูปแบบ นอกจากนี้ยังผิดกฎหมายในการเดินทางไปยังจตุรัสที่ตรงกัน มันเป็นเรื่องยุ่งยาก แต่เป็นไปได้ในการจัดเก็บและดึงข้อมูล ข้อ จำกัด ในการเดินทางไปยังเซลล์ที่จับคู่สามารถเอาชนะได้โดยการย้อนรอย, การเคลื่อนย้ายทางไกล ( 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 . !.
    }
  }
}

C, 67 ไบต์

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

พิมพ์!1(ค่าเท็จโดยคำจำกัดความของ Peter Taylor ) 0หาก(n-1)!^2 == 0 (mod n)และ1อย่างอื่น

แก้ไข : หลังจากการสนทนาบางอย่างในการแชทputs("!1"+p%n)ดูเหมือนว่าจะมีการโกงเล็กน้อยดังนั้นฉันจึงเข้ามาแทนที่ ผลลัพธ์จะยาวกว่าหนึ่งไบต์

แก้ไข : แก้ไขสำหรับอินพุตขนาดใหญ่

โซลูชันที่สั้นกว่า

56 ไบต์ : ตามที่แนะนำในความคิดเห็นโดย pawel.boczarski ฉันสามารถรับอินพุตเป็น unary โดยการอ่านจำนวนอาร์กิวเมนต์บรรทัดคำสั่ง:

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;}

Python 3, 59 ไบต์

ตอนนี้ใช้input()แทนอาร์กิวเมนต์บรรทัดคำสั่ง ขอบคุณ @Beta Decay

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

APL, 40 13 ไบต์

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

ส่วนการทดลองที่มีขั้นตอนวิธีการเช่นเดียวกับคำตอบของฉัน R เรากำหนดxที่จะป้อนข้อมูลจาก STDIN (คน⎕) และได้รับส่วนที่เหลือสำหรับการxแบ่งตามแต่ละจำนวนเต็มตั้งแต่ 1 xถึง แต่ละคนที่เหลือจะถูกเปรียบเทียบกับ 0 xซึ่งจะช่วยให้เราเวกเตอร์ของคนและศูนย์ระบุว่าจำนวนเต็มหาร นี่คือผลรวมการใช้+/เพื่อให้ได้จำนวนตัวหาร หากตัวเลขนี้เท่ากับ 2 หมายความว่าตัวหารเท่านั้นคือ 1 และxและดังนั้นจึงxเป็นจำนวนเฉพาะ

Python 2, 44

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

เช่นเดียวกับคำตอบ Python ของ Sp3000แต่หลีกเลี่ยงการเก็บอินพุตโดยการนับตัวแปรnขึ้นจาก1ค่าอินพุต

เทมเพลตการเขียนโปรแกรม C ++ 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 ++

ค่าที่จะทดสอบเป็นจำนวนเต็มใน "บรรทัดสุดท้าย"

ตัวอย่างเช่นการถ่ายทอดสด