ในเกมYahtzeeผู้เล่นกลิ้งลูกเต๋าหกด้านห้าลูกและพยายามสร้างมือที่แน่นอนเพื่อทำคะแนน มือข้างหนึ่งเป็นเส้นตรงเล็ก ๆ : สี่หมายเลขติดต่อกันไม่จำเป็นต้องเรียงตามลำดับ สาม straights ขนาดเล็กที่เป็นไปได้1, 2, 3, 4, และ2, 3, 4, 53, 4, 5, 6

ตัวอย่างเช่นมีตรงขนาดเล็ก[3, 5, 6, 1, 4][3, 4, 5, 6]

อินพุต

รายการที่ไม่เรียงลำดับของจำนวนเต็มห้าตัวแต่ละค่ามีค่าระหว่าง 1 ถึง 6 รวมถึงมือ Yahtzee

เอาท์พุต

ค่าจริงถ้ามือมีขนาดเล็กและตรงค่าเป็นเท็จอย่างอื่น

กรณีทดสอบ

Truthy:

[[1, 2, 3, 3, 4], [1, 2, 3, 4, 5], [3, 5, 6, 1, 4], [1, 5, 3, 4, 6], [4, 5, 2, 3, 5], [1, 4, 3, 2, 2], [5, 4, 3, 6, 3], [5, 3, 5, 4, 6], [2, 4, 5, 1, 3], [3, 6, 4, 5, 3], [5, 6, 4, 3, 5], [4, 5, 3, 6, 3], [4, 5, 5, 3, 2], [4, 5, 2, 3, 5], [4, 6, 5, 3, 6], [4, 2, 3, 1, 5], [3, 6, 4, 6, 5], [5, 2, 1, 3, 4], [4, 4, 1, 2, 3], [4, 1, 4, 2, 3], [5, 1, 4, 3, 6], [5, 2, 2, 3, 4], [4, 4, 6, 5, 3], [2, 4, 3, 5, 1], [5, 4, 2, 5, 3], [2, 3, 5, 5, 4], [1, 6, 3, 4, 5], [4, 5, 3, 3, 6], [6, 4, 3, 6, 5], [4, 6, 6, 5, 3], [4, 3, 5, 2, 2], [2, 3, 2, 1, 4], [4, 2, 6, 1, 3], [4, 4, 5, 3, 6], [4, 5, 6, 3, 6]]

Falsy:

[[1, 2, 3, 5, 6], [5, 1, 1, 6, 6], [4, 6, 4, 1, 1], [6, 4, 1, 6, 4], [4, 6, 3, 6, 6], [2, 1, 4, 6, 4], [2, 6, 1, 5, 6], [2, 6, 1, 5, 6], [3, 6, 5, 3, 2], [3, 2, 3, 5, 3], [5, 5, 6, 2, 3], [3, 4, 6, 4, 3], [1, 4, 5, 5, 1], [1, 4, 4, 4, 1], [1, 6, 5, 1, 4], [6, 6, 4, 5, 4], [5, 3, 3, 3, 2], [5, 2, 1, 5, 3], [3, 5, 1, 6, 2], [6, 4, 2, 1, 2], [1, 3, 1, 3, 2], [3, 1, 3, 4, 3], [4, 3, 1, 6, 3], [4, 6, 3, 3, 6], [3, 6, 3, 6, 4], [1, 1, 3, 1, 3], [5, 5, 1, 3, 2], [3, 4, 2, 6, 6], [5, 4, 2, 6, 1], [2, 4, 4, 5, 4], [3, 6, 2, 5, 5], [2, 5, 3, 5, 1], [3, 2, 2, 3, 4], [5, 2, 2, 6, 2], [5, 6, 2, 5, 6]]

_{แรงบันดาลใจจากสิ่งนี้}

แค็ตตาล็อก

var QUESTION_ID=74997;var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk";var OVERRIDE_USER=30525;var answers=[],answers_hash,answer_ids,answer_page=1,more_answers=true,comment_page;function answersUrl(index){return"http://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"http://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)}}

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:700}table td{padding:5px}

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

MATL , 7 12 11 9 8 6 ไบต์

ขอบคุณมากที่ @lirtosiast สำหรับการลบ 2 ไบต์

ud7BXf

Truthy คืออาร์เรย์ของค่าที่ไม่ใช่ศูนย์ Falsy เป็นอาร์เรย์ว่างเปล่า (ไม่มีการแสดงผล)

ตั้งแต่วันที่ 16.2.0 uมีเสถียรภาพโดยค่าเริ่มต้น ดังนั้นรหัสต้องการพิเศษSในการเรียงลำดับผลลัพธ์: uSd7BXf( 7 ไบต์ ) ลิงค์นี้มีการดัดแปลง

ลองออนไลน์!

u     % input array implicitly. Transform into array of unique elements sorted
d     % array of differences between consecutive elements
7B    % push arrray [1 1 1] (number 7 converted to binary)
Xf    % indices of occurrences of the second array within the first

Python ขนาด 44 ไบต์

lambda l:any({i+1,i+2,i+3}<set(l)for i in l)

ย้อนกลับไปหลังจาก 9 เดือนพร้อมการปรับปรุง เราไม่จำเป็นต้องตรวจสอบว่าiอยู่ในชุดด้วยความคิดของ Zgarb ในการตรวจสอบเฉพาะค่าเริ่มต้นในชุด ตอนนี้เราสามารถใช้<สำหรับเซ็ตย่อยที่เข้มงวดได้เพราะiต้องรวมอยู่ด้วย

47 ไบต์:

lambda l:any({i,i+1,i+2,i+3}<=set(l)for i in l)

ตรวจสอบว่ามวนโรลใด ๆ เป็นจุดเริ่มต้นของเซ็ตเล็กตรงหรือไม่ ขอบคุณ Zgarb สำหรับแนวคิดในการตรวจสอบเฉพาะค่าเริ่มต้นในรายการซึ่งช่วยประหยัด 5 ไบต์

Python 3.5 มีชุดการแปลงที่สั้นกว่าสำหรับ 45 ไบต์

lambda l:any({i,i+1,i+2,i+3}<={*l}for i in l)

มันเป็นระยะเวลาเดียวกันที่จะทำตามที่{*range(i,i+4)}{i,i+1,i+2,i+3}

เขาวงกต 41 ไบต์

=|?30
0 _ }:/2
3 1  { "!
({(  &{/
} )
+:"

คำตอบที่ทำงานร่วมกันกับ @ MartinBüttner ฉันคิดว่าเราบีบมันเกินความคาดหวังครั้งแรกของฉัน

เอาท์พุท1สำหรับความจริงที่ว่างเปล่าสำหรับเท็จ ลองออนไลน์!

คำอธิบายด่วน

แปลงแต่ละหมายเลขnจะเป็นจำนวนเต็มไบนารี 1 ตามด้วยเลขศูนย์คือn+1 2^(n+1)Bitwise หรือผลลัพธ์และตรวจสอบ1111(เป็นเลขฐานสอง) การยกกำลังจะต้องดำเนินการด้วยตนเองในเขาวงกต

คำอธิบายโดยละเอียด

ไพรเมอร์ปกติ:

• Labyrinth เป็นภาษาโปรแกรมสองมิติแบบกองซ้อน สำหรับหน่วยความจำมีสแต็กหลักและสแต็กเสริมและการ popping จากสแต็กเปล่าก่อให้เกิด 0 แทนที่จะเกิดข้อผิดพลาด
• ที่แต่ละทางแยกที่ตัวชี้คำสั่งสามารถเลื่อนเส้นทางที่เป็นไปได้สองทางขึ้นไปด้านบนของสแต็กจะถูกตรวจสอบเพื่อตัดสินใจว่าจะไปทางไหนต่อไป ลบทิ้งเหลือศูนย์อยู่ข้างหน้าบวกเป็นบวก
• ตัวเลขในเขาวงกตไม่ได้ผลักดันหลักที่สอดคล้องกับสแต็ค - ค่อนข้างพวกเขาปรากฏและผลักดันn n*10 + <digit>ในการเริ่มหมายเลขใหม่ให้_กดศูนย์

ติดตั้ง

การดำเนินการเริ่มต้นที่มุมซ้ายบนโดยหันตัวชี้คำแนะนำไปทางขวา เราดำเนินการ:

=        Swap tops of main and auxiliary stacks
|        Bitwise OR

นอกเหนือจากการกดศูนย์ได้อย่างมีประสิทธิภาพแล้วคำแนะนำเหล่านี้จะไม่เปลี่ยนสแต็ค

วนซ้าย: ยกกำลังและบิตหรือ

เขาวงกตไม่มีการยกกำลังดังนั้นเราต้องดำเนินการด้วยตนเอง ก่อนอื่นเราอ่านจำนวนเต็มด้วย?และเนื่องจากนี่เป็นหลักประกันว่าเป็นบวกเราจึงเลี้ยวขวา _1กด 1 และเราเข้าไปในวงด้านใน

วงในทำสิ่งต่อไปนี้:

(       Decrement. For the first iteration this turns 1 into 0 so we move straight ahead
        downwards; for other iterations when we're coming from the left this turns 2^k into
        2^k-1 > 0, making us turn right (also downwards)
)       Increment again
"       No-op
:+      Duplicate and add, i.e. double
}       Move result to aux
(       Decrement input n. Since this is at a junction, we turn right and continue the
        loop if n is still positive, else we exit the loop by going forwards if n is 0
{       Move result from aux to main

ตั้งแต่นี้เป็นทำในขณะที่ห่วงสำหรับการป้อนข้อมูลคำนวณนี้n 2^(n+1)เราลงท้ายด้วยอินพุตที่มีค่าศูนย์บนสแต็กและ30เปลี่ยนค่าศูนย์นี้เป็น 30 จากนั้นเราจะทำตามคำแนะนำเดียวกันจากการตั้งค่า แต่คราวนี้พวกเขามีประโยชน์จริง ๆ

=       Swap tops of main and aux, moving 30 to aux and 2^(n+1) to main
|       Bitwise OR (for the first input, this is bitwise OR with an implicit zero at
        the bottom of the stack)

การวนซ้ำนี้จะดำเนินต่อไปสำหรับแต่ละหมายเลขในอินพุตจนกระทั่ง EOF เมื่อ?ส่งกลับ 0 นี่ทำให้เราเลื่อนไปข้างหน้าแทนการเลี้ยวนำไปสู่ ​​...

Bridge: ตั้งค่าพิเศษบางอย่าง

30หลังจากที่?ผลัด 0 จาก EOF ลงในวันที่ 30 }ซึ่งจะถูกผลักไปกองเสริมผ่าน ความสำคัญคือความจริงที่ว่าเราผลัก 30 ถึงกองเสริมสำหรับหมายเลขทุกท่านดังนั้นตอนนี้กองเสริมมี5 + 1 = 6สำเนาของหมายเลข 30

ในขณะเดียวกันกองหลักประกอบด้วยค่าบิตหรือของแต่ละการป้อนข้อมูล2^(n+1) nลองเรียก bitwise OR อันbนี้เพราะมันได้รับการแก้ไขในลูปด้านขวา

วนขวา: ตรวจสอบผลลัพธ์และเอาท์พุท

นี่คือสิ่งที่เกิดขึ้นในลูปด้านขวา:

:     Duplicate top of stack. This makes us turn right for the first iteration, since
      b is positive. For later iterations, when we're coming in from the
      right, we usually take the same turn (but see below)
{&    Bitwise AND with a 30 pulled from aux
{/    Integer division by a 30 pulled from aux. This returns 1 or 0 depending on whether
      we have found a small straight.
"     No-op at a junction. Turn right if small straight, else go forward.

[If small straight found]
!     Output the previous 1. This is at a dead end, so we turn around.
"     No-op at junction. Turn right since top of stack is positive.
      (stuff happens - see below)

[If small straight not found]
2     Turn 0 into 2
/     Divide b by said 2
      (continue loop)

ตอนนี้การเลิกจ้างนั้นค่อนข้างยุ่งยากกับโปรแกรมนี้ นี่เป็นวิธีที่เป็นไปได้ที่โปรแกรมสามารถยกเลิกได้:

• หลังจาก 3 การวนซ้ำของลูปที่ถูกต้องและbยังคงเป็นบวก:จำได้อย่างไรว่าเราใส่หกสิบวินาทีลงในสแต็กเสริม? เนื่องจากเราใช้สองการทำซ้ำแต่ละครั้งในการทำซ้ำครั้งที่สี่เราเริ่มดึงศูนย์จากด้านล่างของกองซ้อนเสริม สิ่งนี้ทำให้การหารด้วยศูนย์เมื่อเราทำ{/และโปรแกรมหยุดทำงาน

• หลังจากเอาท์พุท 1 ไปเป็นเส้นตรงเล็ก ๆ : ดังนั้นเราจึงดำเนินการ!แล้วเลี้ยวขวาที่"ทางแยกno-op จากนั้นเราก็เข้ามาเพื่อรถไฟเหาะตีลังกาเมื่อเราเริ่มคลานไปทางซ้ายอีกครึ่ง:

2     Pops b, pushes 10*b + 2
/}    Divide bottom zero by b, giving zero, pushing to aux
03    Zero at bottom of stack becomes 3
?     Push 0 due to EOF, main stack [3 0]. Go straight.
|=    Bitwise OR then swap tops of main and aux
03    Zero at bottom of stack becomes 3, stacks [3 | 3]
({(   Dec, shift dec. Stacks [2 2 | ], and we're in the exponentiator again.

หลังจากทริปสองสามครั้งใน exponentiator สแต็กจะมีลักษณะคล้าย[12 | 30 30]กันซึ่งข้อผิดพลาดโดยการหารด้วยศูนย์หลังจากการทำซ้ำอีกสองครั้งในลูปด้านขวา

• หลังจาก b กลายเป็นศูนย์ในบางจุด : ที่นี่คือกุญแจสำคัญ:ในการวนรอบที่เหมาะสมอยู่ที่ทางแยก ถ้าใส่ก็พูด1 1 1 1 1แล้วbจะ4แล้ว2แล้ว1แล้ว0หลังจากที่ซ้ำสาม แทนที่จะหันมาที่:IP ตอนนี้จะย้ายไปข้างหน้าตรงและบางสิ่งเช่นกรณีก่อนหน้านี้เกิดขึ้นเพื่อทำให้เกิดการยกเลิกในที่สุด

สรุปแล้วมันเป็นระเบียบว่าโปรแกรมหยุดทำงานอย่างไร แต่ช่วยอะไรได้บ้างที่จะช่วยชีวิตไม่กี่ไบต์!

Mathematica, 39 43 44 31 39 44 ไบต์

Differences@Union@#~MatchQ~{___,1,1,1,___} &

Haskell, 39 34 ไบต์

f x=any(\y->all(`elem`x)[y..y+3])x

ตัวอย่างการใช้งาน: ->f [1,2,3,3,4]True

คล้ายกับคำตอบของ @ xnorเช่นตรวจสอบว่ามี straights ขนาดเล็กอยู่ในรายการอินพุตหรือไม่ อันที่จริงผมทดสอบทุกคน "straights ขนาดเล็ก" (คือหมายเลข 4 ติดต่อกัน) เริ่มต้นด้วยตัวเลขใด ๆ จากรายการการป้อนข้อมูลบางส่วนของพวกเขาเป็นที่ไม่ถูกต้องและดังนั้นจึงมักจะล้มเหลวallการทดสอบและไม่บิดเบือนการทดสอบเช่นany[5,6,7,8]

แก้ไข: @Zgarb บันทึก 5 ไบต์ ขอบคุณ!

MATL 11 ไบต์

udY'w1=)2>a

ลองออนไลน์

u           unique (implicit sort)
d           diff
Y'          run-length-encode
w1=)        exract the length of all runs of ones
2>          check whether they are longer than two
a           any (any non-zero element)

JavaScript (ES6), 55 53 ไบต์

a=>(z=[0,1,2,3]).some(b=>z.every(c=>a.includes(c+b)))

ผลตอบแทนtrueสำหรับความจริงและความfalseเท็จ

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

ส่งคืนถ้าค่าใน [0, 1, 2, 3] เป็นไปตามเงื่อนไขที่ทุกค่าใน [0, 1, 2, 3] ผลรวมของค่าทั้งสองนี้อยู่ในอาร์เรย์อินพุต

ดังนั้นกลับถ้าอาร์เรย์มีค่าทุกค่าใน [0, 1, 2, 3] (เป็นไปไม่ได้), [1, 2, 3, 4], [2, 3, 4, 5] หรือ [3, 4, 5 , 6].

ทับทิม, 31

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

นี้ดูเหมือนว่าจะใช้วิธีเดียวกับคำตอบของเชอร์ล็อก

->x{x.any?{|d|[*d..d+3]-x==[]}}

Ruby, 58 55 50 47 43 33 ไบต์

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

แก้ไข: การตีกอล์ฟและแก้ไขการปะปนในเงื่อนไขที่ประกอบไปด้วยสามส่วน

แก้ไข:ตอนนี้ผมใช้.any?เช่นไม่ว่าชาร์ลส์ไม่อยู่ในคำตอบทับทิมของพวกเขาแต่เพียงเพราะผมจำเป็นต้องมีวิธีง่ายๆในการลบaและจะกลับมาเพียง truthy และ falsey มี!([*i..i+3]-l)[0]ตั้งแต่.mapจะกลับอาร์เรย์ของและtruefalse

->l{l.any?{|i|!([*i..i+3]-l)[0]}}

ผลตอบแทนอย่างใดอย่างหนึ่งหรือtruefalse

Ungolfed:

def f(l)
  a = p
  l.any? do |i|
    if ( (i..i+3).to_a - l )[0]     # if (i..i+3) in l
      a = false                     # a[0] is equivalent to !a.empty?
    else
      a = true
    end
  end
  puts a
end

หมายเหตุสำคัญ: สำหรับผู้ที่ต้องการใช้(a2 - a1).empty?รหัสเพื่อตรวจสอบว่าองค์ประกอบทั้งหมดa2อยู่ในa1นั้นหรือไม่โปรดทราบว่าหากคุณต้องการตรวจสอบให้แน่ใจว่าตัวอย่างเช่น[2,1,2]อยู่ใน[1,2,3,3]องค์ประกอบหลายหลากคุณต้องมีรหัสอื่น การอภิปรายที่เกี่ยวข้องของปัญหานี้ที่นี่

Japt 13 13ไบต์

Uá4 d@7o ¬fX

ทดสอบออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

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

       // Implicit: U = input array
Uá4    // Take all permutations of U of length 4.
d@     // Return whether any item X returns truthily to this function:
7o ¬   //  Take the range [0..7) and join. Produces "0123456".
fX     //  Match X in this string.
       //  This returns null if X is not a subset of [0..7), and a (truthy) array otherwise.
       // Implicit output

Perl, 47 43 42 39 37 29 ไบต์

รวม +1 สำหรับ -p

ทำงานด้วยลำดับบน STDIN เช่น

perl -p smallstraight.pl <<< "1 2 3 3 4"

smallstraight.pl:

s//$_|=1x$'.w/reg;$_=/.w{4}/

คำอธิบาย

s//          / eg             Each possible postfix string (including the
                              empty string) is assigned to $' in turn
                              So each input digit will be the start of $'
                              at least once
       1x$'.w                 Put a w at position $'.
                              e.g. digit 4 becomes 1111w
   $_|=                       Or into existing $_.
                                w        is binary 0111 0111
                                space    is binary 0010 0000
                                digit<=7 is binary 0011 0xxx
                              So an "or" with "w" is always w again:
                                                   0111 0111
                              And no other way can you get a w since w is the
                              only thing that can set the high bits. So the
                              already existing string in $_ has no effect on
                              the number of w's in the result
              r               The $_ that has been "or"ed several times is
                              exfiltrated out of the substitution. It will
                              have a w in every position that the original
                              string had a digit with an extra w at position
                              0 since the s///g will also have matched the
                              empty string at the end
                              So e.g. "1 2 3 5 6" will become "wwww3ww 6"
                  $_=/.w{4}/  We have a small straight if there were 4
                              consecutive numbers, now 4 consecutive w's. But
                              the w we always get at the start of the string
                              doesn't count. Notice that the string cannot 
                              have a newline since bit "0010 0000" is always
                              set. So "." to skip one character is safe

CJam, 16 15 12 ไบต์

7,4ewl~f&3f>

ให้ผลลัพธ์สตริงที่ไม่ว่างเปล่าสำหรับกรณีทดสอบจริงและสตริงว่างสำหรับสตริงเท็จ

ชุดทดสอบ

คำอธิบาย

7,      e# Push [0 1 2 3 4 5 6].
4ew     e# Get all length-4 sublists. This gives:
        e#   [[0 1 2 3]
        e#    [1 2 3 4]
        e#    [2 3 4 5]
        e#    [3 4 5 6]]
        e# i.e. all possible small straights (and an impossible one).
l~      e# Read and evaluate input.
f&      e# Set intersection of each small straight with the full list.
        e# If any small straight is contained in the list, all 4 of its
        e# elements will be retained.
3f>     e# Discard the first three elements of each intersection. If a 
        e# small straight was not in the list, this will give an empty 
        e# list. Otherwise, one element will remain.

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

05AB1E , 9 8 10 ไบต์

Truthyบรรจุอาเรย์ในเอาต์พุตความผิดพลาดคือเมื่อไม่มีการสร้างเอาท์พุต รหัส:

œvy¦¥1QPiy

คำอธิบายล้าสมัย :

œ          # Compute all permutations
 vy        # Map over each permutation
   ¦       # Head, leaves [1:]
    ¥      # Delta, computes the differences between the elements
     P     # Product, which computes the product of the array
      iy   # If equal to 1, push the array again
           # Implicit, if there is a match, an array will be displayed.

ลองออนไลน์!

ใช้การเข้ารหัสCP-1252

Javascript ES6 47 ไบต์

q=>/12+3+4|23+4+5|34+5+6/.test(q.sort().join``)

Javascript ES6 52 ไบต์

q=>/1,+1,+1/.test(q.sort().map((a,i)=>a-q[i-1]||``))

//sort the array
//map each element to the difference from the last element
//Look for three 'increment by ones' (ignore increment by 0s)

Javascript ES6 64 ไบต์

ขอบคุณ ETHproductions ที่ช่วยประหยัดหลายไบต์

q=>q.sort().map(o=>(o-s?o-s<2?t++:t=t>3?t:1:0,s=o),t=1,s=-1)|t>3

q=>              //take an input
q.sort()         //sort it
.map(            //for each number
  o=>
    s=           //set current value = 
      !(o-s) ?   //if it's a duplicate
        o :      //just keep the current state (set s to s again)
        (  
         o-s < 2 ?  //if the current values is one more than the next one
           t++ :    //increment the total
           t=t>4?t:1 //otherwise, set the total back to 1, unless we've hit 4 total already
         )&&o  //set the current value to the current token
   ,t=1,s=-1)  //init the total, and the current value (set it to -1 since we won't hit that anyways

|t>3 //return total > 3 (so 1 if we get a run of 4 or 5)

การทดสอบ

//true and false test cases from OP
tr = [[1, 2, 3, 3, 4], [1, 2, 3, 4, 5], [3, 5, 6, 1, 4], [1, 5, 3, 4, 6], [4, 5, 2, 3, 5], [1, 4, 3, 2, 2], [5, 4, 3, 6, 3], [5, 3, 5, 4, 6], [2, 4, 5, 1, 3], [3, 6, 4, 5, 3], [5, 6, 4, 3, 5], [4, 5, 3, 6, 3], [4, 5, 5, 3, 2], [4, 5, 2, 3, 5], [4, 6, 5, 3, 6], [4, 2, 3, 1, 5], [3, 6, 4, 6, 5], [5, 2, 1, 3, 4], [4, 4, 1, 2, 3], [4, 1, 4, 2, 3], [5, 1, 4, 3, 6], [5, 2, 2, 3, 4], [4, 4, 6, 5, 3], [2, 4, 3, 5, 1], [5, 4, 2, 5, 3], [2, 3, 5, 5, 4], [1, 6, 3, 4, 5], [4, 5, 3, 3, 6], [6, 4, 3, 6, 5], [4, 6, 6, 5, 3], [4, 3, 5, 2, 2], [2, 3, 2, 1, 4], [4, 2, 6, 1, 3], [4, 4, 5, 3, 6], [4, 5, 6, 3, 6]]

fa = [[1, 2, 3, 5, 6], [5, 1, 1, 6, 6], [4, 6, 4, 1, 1], [6, 4, 1, 6, 4], [4, 6, 3, 6, 6], [2, 1, 4, 6, 4], [2, 6, 1, 5, 6], [2, 6, 1, 5, 6], [3, 6, 5, 3, 2], [3, 2, 3, 5, 3], [5, 5, 6, 2, 3], [3, 4, 6, 4, 3], [1, 4, 5, 5, 1], [1, 4, 4, 4, 1], [1, 6, 5, 1, 4], [6, 6, 4, 5, 4], [5, 3, 3, 3, 2], [5, 2, 1, 5, 3], [3, 5, 1, 6, 2], [6, 4, 2, 1, 2], [1, 3, 1, 3, 2], [3, 1, 3, 4, 3], [4, 3, 1, 6, 3], [4, 6, 3, 3, 6], [3, 6, 3, 6, 4], [1, 1, 3, 1, 3], [5, 5, 1, 3, 2], [3, 4, 2, 6, 6], [5, 4, 2, 6, 1], [2, 4, 4, 5, 4], [3, 6, 2, 5, 5], [2, 5, 3, 5, 1], [3, 2, 2, 3, 4], [5, 2, 2, 6, 2], [5, 6, 2, 5, 6]]

f=q=>q.sort().map(o=>(o-s?o-s<2?t++:t=t>3?t:1:0,s=o),t=1,s=-1)|t>3


tr.map(f)   //just look to make sure every value is true
fa.map(f)  //just look to make sure every value is false

C #, 156 151 150 131 121 93 92 90 ไบต์

int l;bool f(int[]a){foreach(var v in a)l|=1<<v-1;return(l&15)>14||(l&30)>29||(l&60)>59;}

หรือ: (จำนวนไบต์เดียวกัน)

int l;bool f(int[]a){foreach(var v in a)l|=1<<v;return(l&30)>29||(l&60)>59||(l&120)>119;}

Ungolfed:

int l;
bool f(int[] a)
{
    foreach (var v in a)
        l |= 1 << v - 1;
    return (l & 15) > 14 ||   //Bits 1-4 are set OR
           (l & 30) > 29 ||   //Bits 2-5 are set OR
           (l & 60) > 59;     //Bits 3-6 are set
}

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

Ruby - 80 -> 79 -> 76 -> 54 -> 48 -> 40 ไบต์

ลองครั้งที่ห้า (40 ไบต์):

->x{/1234|2345|3456/===x.uniq.sort.join}

ใช้แลมบ์ดาไวยากรณ์เพื่อกำหนดฟังก์ชั่น (ต้องขอบคุณนักแข่ง Ruby Ruby ที่ Sherlock9 สำหรับไอเดียนี้)

วิธีทดสอบโดยใช้แลมบ์ดาโทร:

s = ->x{/1234|2345|3456/===x.uniq.sort.join}
s.call([1,3,5,4,4])
s.call([1,3,5,4,2])

ความพยายามครั้งที่สี่:

def s?(x)/1234|2345|3456/===x.uniq.sort.join end

แทนที่ศูนย์หรือไม่ และการปฏิเสธด้วยตัวดำเนินการ ===

ลองครั้งที่สาม:

def s?(x)!(/1234|2345|3456/=~x.uniq.sort.join).nil?end

ใช้การแสดงออกปกติ

ลองครั้งที่สอง:

def s?(x)[1234,2345,3456].select{|a|x.uniq.sort.join.include?a.to_s}.any?end

วิธีการใหม่ใช้ dedup (uniq) เรียงลำดับและเข้าร่วมรวมถึง? เพื่อค้นหาโซลูชันที่ตรงกันในอินพุตที่เรนเดอร์เป็นสตริง

ลองครั้งแรก: 79 ไบต์

def s?(x)[[1,2,3,4],[2,3,4,5],[3,4,5,6]].select{|a|(a&x.uniq).length>3}.any?end

Tester:

x = [1,4,3,3,6]
s?(x)

x = [2,4,5,1,3]
s?(x)

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

Pyth, 13 11

@.PQ4.:S6 4

2 ไบต์ขอบคุณ Jakube!

ส่งคืนรายการที่ไม่ว่างสำหรับความจริงและรายการที่ว่างเปล่าสำหรับเท็จ

ลองออนไลน์หรือเรียกใช้ชุดทดสอบ (แยกจากข้อผิดพลาดทางไวยากรณ์สำหรับ Readability ™)

PHP, 95 ไบต์

function s($d){$a=array_diff;$r=range;return!($a($r(1,4),$d)&&$a($r(2,5),$d)&&$a($r(3,6),$d));}

function s($d){
  $a = array_diff;
  $r = range;
  return !($a($r(1,4),$d)
        && $a($r(2,5),$d)
        && $a($r(3,6),$d));
}

s(Array[int, int, int, int, int]);

bool

อย่างจริงจัง 21 ไบต์

3R`;4+@x`M4,╨╗`╜íu`MΣ

ลองออนไลน์!

ส่งออกค่าบวกสำหรับความจริงและ 0 สำหรับเท็จ

คำอธิบาย:

3R`;4+@x`M4,╨╗`╜íu`MΣ
3R`;4+@x`M             push [[1,2,3,4], [2,3,4,5], [3,4,5,6]
          4,╨╗         push all 4-length permutations of input to register 0
              `   `M   map:
               ╜íu       push 1-based index of list in permutations, 0 if not found
                    Σ  sum

PARI / GP , 71 ไบต์

นี่อาจจะเป็นสนามกอล์ฟต่อไป แต่เป็นการเริ่มต้น:

s=setminus;v->t=s([1..6],Set(v));!#s(t,[1,2])+!#s(t,[5,6])+!#s(t,[1,6])

ฉันไม่เห็นวิธีการลดความซ้ำซ้อนโดยไม่ต้องใช้พื้นที่มากขึ้น รุ่นนี้คือ 75 ไบต์:

s=setminus;v->t=s([1..6],Set(v));z=(u->!#s(t,u));z([1,2])+z([5,6])+z([1,6])

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

13342การป้อนข้อมูลเป็นสายเดียวของจำนวนเต็มเช่น ผลลัพธ์คือ1ถ้าพบหรือ0ถ้าไม่

.                       # Replace integer digits with unary
$*x,
+`(x+(x+,))\2           # Sorts the list by repeated swapping
$2$1
(x+,)\1                 # Removes adjacent duplicates
$1
(x+,)x\1xx\1xxx\1       # Matches a small straight

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

ลองออนไลน์

ขอบคุณมาร์ตินสำหรับแนวคิดในการย้ายเครื่องหมายจุลภาคภายในกลุ่มการดักบันทึก 16 ไบต์ที่ใหญ่โต

Pyth, 11 ไบต์

f!-TQ.:S6 4

ชุดทดสอบ

สร้างสตริงย่อยความยาว 4 ของ [1..6] จากนั้นกรองพวกมันบนองค์ประกอบที่ไม่เหลืออยู่เมื่อองค์ประกอบของอินพุตถูกลบออก

เยลลี่ขนาด 9 ไบต์

จะต้องมีการแก้ปัญหา 8 ไบต์จะค้นหาต่อไป ... รหัส:

Œ!Ḋ€Iµ7Be

นี้เป็นเช่นเดียวกับฉัน05AB1Eวิธีการแก้ปัญหา

คำอธิบาย:

Œ!         # Compute all permutations
  Ḋ€       # Dequeue each, leaving [1:]
    I      # Delta function
     µ     # Start a new monadic chain
      7B   # 7 in binary, which is [1, 1, 1]
        e  # Return 1 if this array exists

ลองออนไลน์!

เยลลี่ขนาด 8 ไบต์

6Rṡ4ḟ€ċ“

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบ truthyและกรณีทดสอบ falsy

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

6Rṡ4ḟ€ċ“  Main link. Argument: A (list)

6R        Yield [1, 2, 3, 4, 5, 6].
  ṡ4      Split it into overlapping slices of length 4, yielding
          [[1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5, 6]].
    ḟ€    Remove all occurrences of A's elements from each slice.
      ċ“  Count the resulting number of empty list.
          This returns the number of distinct small straights in A (0, 1 or 2).

สกาลา, 76 70 61 60 ไบต์

(s:Seq[Int])=>(1 to 6)sliding(4)exists(t=>(s diff t).size<2)

Tester:

val f = <code here>
val truthy = Seq(Seq(1, 2, 3, 3, 4), Seq(1, 2, 3, 4, 5), Seq(3, 5, 6, 1, 4), Seq(1, 5, 3, 4, 6), Seq(4, 5, 2, 3, 5), Seq(1, 4, 3, 2, 2), Seq(5, 4, 3, 6, 3), Seq(5, 3, 5, 4, 6), Seq(2, 4, 5, 1, 3), Seq(3, 6, 4, 5, 3), Seq(5, 6, 4, 3, 5), Seq(4, 5, 3, 6, 3), Seq(4, 5, 5, 3, 2), Seq(4, 5, 2, 3, 5), Seq(4, 6, 5, 3, 6), Seq(4, 2, 3, 1, 5), Seq(3, 6, 4, 6, 5), Seq(5, 2, 1, 3, 4), Seq(4, 4, 1, 2, 3), Seq(4, 1, 4, 2, 3), Seq(5, 1, 4, 3, 6), Seq(5, 2, 2, 3, 4), Seq(4, 4, 6, 5, 3), Seq(2, 4, 3, 5, 1), Seq(5, 4, 2, 5, 3), Seq(2, 3, 5, 5, 4), Seq(1, 6, 3, 4, 5), Seq(4, 5, 3, 3, 6), Seq(6, 4, 3, 6, 5), Seq(4, 6, 6, 5, 3), Seq(4, 3, 5, 2, 2), Seq(2, 3, 2, 1, 4), Seq(4, 2, 6, 1, 3), Seq(4, 4, 5, 3, 6), Seq(4, 5, 6, 3, 6))
val falsy = Seq(Seq(1, 2, 3, 5, 6), Seq(5, 1, 1, 6, 6), Seq(4, 6, 4, 1, 1), Seq(6, 4, 1, 6, 4), Seq(4, 6, 3, 6, 6), Seq(2, 1, 4, 6, 4), Seq(2, 6, 1, 5, 6), Seq(2, 6, 1, 5, 6), Seq(3, 6, 5, 3, 2), Seq(3, 2, 3, 5, 3), Seq(5, 5, 6, 2, 3), Seq(3, 4, 6, 4, 3), Seq(1, 4, 5, 5, 1), Seq(1, 4, 4, 4, 1), Seq(1, 6, 5, 1, 4), Seq(6, 6, 4, 5, 4), Seq(5, 3, 3, 3, 2), Seq(5, 2, 1, 5, 3), Seq(3, 5, 1, 6, 2), Seq(6, 4, 2, 1, 2), Seq(1, 3, 1, 3, 2), Seq(3, 1, 3, 4, 3), Seq(4, 3, 1, 6, 3), Seq(4, 6, 3, 3, 6), Seq(3, 6, 3, 6, 4), Seq(1, 1, 3, 1, 3), Seq(5, 5, 1, 3, 2), Seq(3, 4, 2, 6, 6), Seq(5, 4, 2, 6, 1), Seq(2, 4, 4, 5, 4), Seq(3, 6, 2, 5, 5), Seq(2, 5, 3, 5, 1), Seq(3, 2, 2, 3, 4), Seq(5, 2, 2, 6, 2), Seq(5, 6, 2, 5, 6))
println("Failed truthy: " + truthy.filterNot(f))
println("Failed falsy: " + falsy.filter(f))

Javascript ES6 43 ไบต์

q=>/1,1,1,1/.test(q.map(a=>l[a]=1,l=[])&&l)

q=>q.map(a=>l&=~(1<<a),l=62)&&l<7||l==32

ใช้จำนวน 62 (111110 ในรูปของเลขฐานสอง) สำหรับแต่ละหมายเลขในอาร์เรย์อินพุตนั้นจะลบบิตนั้น

หมายเลขผลลัพธ์ควรเป็น

100000 or
000000 or
000010 or
000110 or
000100

ดังนั้นฉันตรวจสอบว่าผลลัพธ์น้อยกว่า 7 (0000111) หรือถ้ามันเท่ากับ 32 (100,000)

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

not(min(fPart(prod(Ans+36)/(65{703,779,287

การแสดงออกของงูหลามเทียบเท่า (ไม่ได้เสริม) ซึ่งคุณสามารถทดสอบ :

def has_small_straight(l):
    product = reduce(lambda x,y: x*y, [x + 36 for x in l], 1)
    numbers = [37*19*13*5, 19*13*5*41, 13*5*41*7]
    return not(all([product%x for x in numbers]))

แนวคิดเบื้องหลังคือการแบ่งแยก หากต้องการตรวจสอบว่า1, 2, 3, 4, 2, 3, 4, 5หรือ3, 4, 5, 6เกิดขึ้นเราสามารถแมหมายเลข 1-6 เพื่อ 37-42 และจากนั้นคูณตัวเลขที่ถูกต้องร่วมกัน

ตัวเลขแต่ละตัวใน [37,42] มีปัจจัยหลักที่ตัวเลขอื่น ๆ ขาด

n             |  1 |  2 |  3 |  4 |  5 |  6 |
n + 36        | 37 | 38 | 39 | 40 | 41 | 42 |
Factor        | 37 | 19 | 13 |  5 | 41 |  7 |

ดังนั้นหากผลิตภัณฑ์ของตัวเลขทั้งห้าหารด้วย 37 รายการเดิมจะมี 1 หาก 19 จะมี 2 ฯลฯ ถ้าเป็นหารด้วย37*19*13*5= 65*703มันมี1, 2, 3และ4และในทำนองเดียวกันอื่น ๆ สำหรับสองหมายเลข

การแก้ปัญหานี้คือการปรับปรุงในหนึ่งที่@Weregooseโพสต์ในปี 2009

คางทูม, 113 78 ไบต์

Mumps ที่ฉันใช้อยู่คือ InterSystems Cache

ฉันไม่สามารถคิดวิธีตีกอล์ฟเทคนิคนี้สั้นกว่านี้ ด้วยเทคนิคที่แตกต่างมันอาจเป็นไปได้ แต่สำหรับตอนนี้สิ่งนี้จะทำและอย่างน้อยก็สั้นกว่า C ++ ... แต่ไม่มากนัก อย่างไรก็ตาม...

ตกลงนี่เป็นวิธีที่สั้นกว่า แทนที่จะมี 3 ตัวแปรแยกกันสำหรับการวิ่งระยะสั้นให้ใช้ตัวแปรเดี่ยวสำหรับ 'ลูกเต๋า' ทั้ง 6 ตัวและแยกส่วนในภายหลัง:

R R S Y=111111 F F=1:1:5{S $E(Y,$E(R,F))=0} W '$E(Y,1,4)!'$E(Y,2,5)!'$E(Y,3,6)

มากสำหรับฉันไม่พบวิธีที่ดีกว่าด้วยเทคนิคเดียวกัน ... ฉันควรมองก่อนที่ฉันจะกระโดดใช่มั้ย? ;-)

ฉันจะทิ้งคำตอบดั้งเดิมไว้ด้านล่างเพื่อจุดประสงค์ทางประวัติศาสตร์ ...

R R S (G,H,I)=1111 F F=1:1:5{S Q=$E(R,F) S:1234[Q $E(G,Q)=0 S:2345[Q $E(H,Q-1)=0 S:3456[Q $E(I,Q-2)=0} W 'G!'H!'I

และนี่คือคำอธิบายว่าเกิดอะไรขึ้นกับรหัส:

R R                   ; read from STDIN to variable R
S (G,H,I)=1111        ; set our 3 possible short straights
F F=1:1:5{            ; For loop from 1 to 5
S Q=$E(R,F)           ; get each digit from the input and save in Q
S:1234[Q $E(G,Q)=0    ; If Q is either 1,2,3 or 4, zero out that position in G.
S:2345[Q $E(H,Q-1)=0  ; if Q is either 2,3,4 or 5, zero out that position (-1) in H.
S:3456[Q $E(I,Q-2)=0  ; if Q is either 3,4,5 or 6, zero out that position (-2) in I.
}                     ; and end the loop.
W 'G!'H!'I            ; If G,H, or I are all zeroes (indicating a full straight),
                      ; taking the not of each will make (at least one) of the
                      ; values true. OR-ing all three values will let us know if
                      ; at least one short straight was complete.
                      ; Output is 1 for truthy, 0 for falsy.

ฉันไม่ได้ทดสอบการป้อนข้อมูลที่เป็นจริง & เท็จทุก ๆ ครั้งที่เกี่ยวข้องกับการพิมพ์ด้วยตนเองทั้งหมดใน; แต่ฉันทำการทดสอบประมาณครึ่งแรกของแต่ละการตรวจสอบความยาวที่ตรงยังคงแสดงความจริงและการวิ่งจำนวนมากที่สังเกตเห็นว่าไม่จำเป็นต้องทำงานอย่างถูกต้อง ([4,2,5,3,4], [1,2,3,3 [4] ฯลฯ ) และดูเหมือนว่าจะทำงานอย่างถูกต้อง

Dyalog APL ขนาด 15 ไบต์

{∨/∧/⍵∊⍨⍵∘.+⍳4}

การใช้งาน ⎕IO=0

⍳4 คือ 0 1 2 3

⍵∘.+⍳4 เป็น 5 × 4 เมทริกซ์ของแต่ละตายเพิ่มขึ้นโดยแต่ละ ⍳4

⍵∊⍨ ตรวจสอบว่าองค์ประกอบของเมทริกซ์อยู่ในมือผลลัพธ์คือเมทริกบูลีน (0 หรือหรือ 1) เราต้องหาแถวทั้งหมด 1 วินาที

∧/ คือและลดลงตามแถวผลที่ได้คือเวกเตอร์บูลีน

∨/ คือหรือลดขนาดของเวกเตอร์นั้น

เยลลี่, 11

QṢṡ4ðfø6Rṡ4

ลองออนไลน์!

นี่เป็นสำเนาของคำตอบ Pyth ของฉันสวยมากเพียงแค่พยายามหาวิธีโยงโซ่สิ่งต่างๆ รู้สึกว่าควรจะเล่นกอล์ฟได้

การขยายตัว:

QṢṡ4ðfø6Rṡ4  ##  1, 2, 0 chain, 1 argument from command line
QṢṡ4         ##  first chain, uniQue and Sort the input, then
             ##  get overlapping lists of length 4 (ṡ)
    ð        ##  separator
     f       ##  filter left argument on being a member of right argument
      ø      ##  separator
       6Rṡ4  ##  all overlapping lists of length 4, from 1-indexed range of 6
             ##  generates [1,2,3,4],[2,3,4,5],[3,4,5,6]

หากคุณต้องการถามคำถามยาก ๆ เช่นทำไมตัวแยกต่างกันคำตอบของฉันคือ: "ฉันจะตอบภายใน 6-8 สัปดาห์": P (จริงจังมากขึ้นฉันคิดว่ามันเป็นการจับคู่รูปแบบ monad-dyad vs nilad-dyad แต่ฉันไม่รู้และไม่ต้องการกระจายข้อมูลที่ผิด)