Trong trò chơi Yahtzee , người chơi tung năm con xúc xắc sáu mặt và cố gắng tạo ra những bàn tay nhất định để ghi điểm. Một tay như vậy là một đường thẳng nhỏ : bốn số liên tiếp, không nhất thiết phải theo thứ tự. Ba đoạn thẳng nhỏ có thể là 1, 2, 3, 4, 2, 3, 4, 5, và 3, 4, 5, 6.

Ví dụ, [3, 5, 6, 1, 4]chứa thẳng nhỏ [3, 4, 5, 6].

Đầu vào

Một danh sách chưa được sắp xếp gồm năm số nguyên, mỗi số từ 1 đến 6, bao gồm một bàn tay Yahtzee.

Đầu ra

Một giá trị trung thực nếu bàn tay chứa một giá trị thẳng nhỏ và sai giá trị khác.

Các trường hợp thử nghiệm

Sự thật:

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

Giả mạo:

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

_{Lấy cảm hứng từ điều này}

Mục lục

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 byte

Cảm ơn rất nhiều đến @lirtosiast vì đã xóa 2 byte

ud7BXf

Truthy là một mảng các giá trị khác không. Falsy là mảng trống (không hiển thị đầu ra).

Kể từ phiên bản 16.2.0, uổn định theo mặc định. Vì vậy, mã cần thêm Sđể sắp xếp đầu ra: uSd7BXf( 7 byte ). Liên kết bao gồm sửa đổi này.

Hãy thử trực tuyến!

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 byte

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

Trở lại sau 9 tháng với một sự cải thiện. Chúng tôi không cần kiểm tra nếui có trong tập hợp với ý tưởng của Zgarb chỉ kiểm tra các giá trị bắt đầu trong tập hợp. Bây giờ chúng tôi cũng có thể sử dụng <cho các tập hợp con nghiêm ngặt bởi vì icũng phải được bao gồm.

47 byte:

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

Kiểm tra nếu bất kỳ cuộn chết là bắt đầu của một bộ thẳng nhỏ. Cảm ơn Zgarb vì ý tưởng chỉ kiểm tra giá trị bắt đầu trong danh sách, tiết kiệm 5 byte.

Python 3.5 có chuyển đổi tập ngắn hơn, cho 45 byte

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

Đó là cùng một chiều dài để làm {*range(i,i+4)}như {i,i+1,i+2,i+3}.

Mê cung, 41 byte

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

Câu trả lời collab với @ MartinBüttner. Tôi nghĩ rằng chúng tôi đã vắt kiệt thứ này vượt xa mong đợi ban đầu của tôi.

Đầu ra là 1cho sự thật, trống rỗng cho giả. Hãy thử trực tuyến!

Giải thích nhanh

Chuyển đổi mỗi số nthành số nguyên nhị phân 1 theo sau là n+1số 0, nghĩa là 2^(n+1). Bitwise HOẶC kết quả và kiểm tra 1111(trong nhị phân). Việc lũy thừa cần được thực hiện thủ công trong Labyrinth.

Giải thích chi tiết

Các mồi thông thường:

• Labyrinth là ngôn ngữ lập trình 2D dựa trên ngăn xếp. Đối với bộ nhớ, có ngăn xếp chính và ngăn xếp phụ và xuất hiện từ ngăn xếp trống tạo ra 0 thay vì lỗi.
• Tại mỗi ngã ba, nơi con trỏ lệnh có thể di chuyển xuống hai hoặc nhiều đường dẫn có thể, đỉnh của ngăn xếp được kiểm tra để quyết định nơi tiếp theo. Tiêu cực là trái, không là tiến, dương là phải.
• Các chữ số trong Labyrinth không đẩy chữ số tương ứng vào ngăn xếp - thay vào đó, chúng bật nvà đẩy n*10 + <digit>. Để bắt đầu một số mới, _đẩy số không.

Thiết lập

Thực thi bắt đầu ở phía trên bên trái, với con trỏ lệnh hướng sang phải. Chúng tôi thực hiện:

=        Swap tops of main and auxiliary stacks
|        Bitwise OR

Ngoài việc đẩy số 0 một cách hiệu quả, các hướng dẫn này không thay đổi ngăn xếp.

Vòng lặp bên trái: lũy thừa và bitwise OR

Mê cung không có lũy thừa, vì vậy chúng ta cần thực hiện thủ công. Đầu tiên chúng tôi đọc một số nguyên với ?, và vì điều này được đảm bảo là dương nên chúng tôi rẽ phải._1đẩy 1 và chúng ta vào vòng lặp bên trong.

Vòng lặp bên trong thực hiện như sau:

(       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

Vì đây là một vòng lặp do-while, cho đầu vào nnày tính toán 2^(n+1). Chúng tôi kết thúc với đầu vào bằng 0 trên ngăn xếp và 30biến số 0 này thành 30. Sau đó, chúng tôi thực hiện các hướng dẫn tương tự từ thiết lập, nhưng lần này chúng thực sự hữu ích.

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

Vòng lặp này tiếp tục cho mỗi số trong đầu vào cho đến khi EOF, khi ?trả về 0. Điều này khiến chúng ta di chuyển về phía trước thay vì rẽ, dẫn đến ...

Cầu: một số thiết lập thêm

Sau 30khi ?biến 0 từ EOF thành 30, được đẩy sang ngăn phụ trợ thông qua }. Điều quan trọng là thực tế là chúng ta đã đẩy 30 đến ngăn phụ cho mỗi số đầu vào, vì vậy bây giờ ngăn phụ có chứa các 5 + 1 = 6bản sao của số 30 .

Trong khi đó, ngăn xếp chính chứa bit OR OR 2^(n+1)cho mỗi đầu vào n. Hãy gọi nó theo chiều bit HOẶCb vì nó được sửa đổi trong vòng lặp bên phải.

Vòng lặp bên phải: kiểm tra kết quả và đầu ra

Đây là những gì xảy ra trong vòng lặp bên phải:

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

Bây giờ, chấm dứt là một chút khó khăn với chương trình này. Dưới đây là những cách có thể mà chương trình có thể chấm dứt:

• Sau 3 lần lặp của vòng lặp bên phải và bvẫn tích cực: Hãy nhớ cách chúng ta đặt sáu 30 giây vào ngăn xếp phụ trợ? Vì chúng tôi sử dụng hai trong số chúng mỗi lần lặp, nên ở lần lặp thứ tư, chúng tôi bắt đầu kéo các số 0 từ dưới cùng của ngăn xếp phụ trợ. Điều này gây ra sự phân chia bằng 0 khi chúng ta làm {/và chương trình kết thúc.

• Sau khi xuất 1 cho một đường thẳng nhỏ : Vì vậy, chúng tôi đã thực hiện !sau đó rẽ phải tại "ngã ba không. Sau đó, chúng tôi sẽ tham gia một tàu lượn siêu tốc khi chúng tôi bắt đầu bò khắp nửa bên trái một lần nữa:

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.

Sau một vài chuyến đi trong bộ lũy thừa, ngăn xếp trông giống như [12 | 30 30], lỗi này được chia cho số 0 sau hai lần lặp khác trong vòng lặp bên phải.

• Sau khi b trở thành số 0 tại một số điểm : Chìa khóa ở đây là :vòng lặp bên phải nằm ở một điểm nối. Nếu đầu vào là, thì, 1 1 1 1 1sau đó bsẽ là 4, sau 2đó 1, sau 0lần lặp thứ ba. Thay vì quay đầu :, IP bây giờ di chuyển thẳng về phía trước và một cái gì đó giống như trường hợp trước xảy ra để gây ra sự chấm dứt cuối cùng.

Tất cả trong tất cả đó là một mớ hỗn độn làm thế nào chương trình chấm dứt, nhưng hey bất cứ điều gì để tiết kiệm vài byte!

Toán học, 39 43 44 31 39 44 byte

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

Haskell, 39 34 byte

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

Ví dụ sử dụng: f [1,2,3,3,4]-> True.

Tương tự như câu trả lời của @ xnor , tức là kiểm tra xem có bất kỳ điểm căng thẳng nhỏ nào trong danh sách đầu vào không. Thật sự tôi đang thử nghiệm tất cả "straights nhỏ" (tức là 4 số liên tiếp) bắt đầu với bất kỳ số điện thoại từ danh sách đầu vào, một số trong số đó là không hợp lệ và do đó luôn luôn thất bại trong allthử nghiệm và không làm méo mó các anykiểm tra, ví dụ [5,6,7,8].

Chỉnh sửa: @Zgarb lưu 5 byte. Cảm ơn!

MATL, 11 byte

udY'w1=)2>a

Dùng thử trực tuyến

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 byte

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

trả lại truecho sự thật và falsecho sự giả dối

Làm thế nào nó hoạt động

Trả về nếu một số giá trị trong [0, 1, 2, 3] đáp ứng điều kiện là với mọi giá trị trong [0, 1, 2, 3] tổng của hai giá trị này nằm trong mảng đầu vào.

Vì vậy, trả về nếu mảng có mọi giá trị trong [0, 1, 2, 3] (không thể), [1, 2, 3, 4], [2, 3, 4, 5] hoặc [3, 4, 5 , 6].

Ruby, 31

Thay vì cố gắng thông minh như câu trả lời đầu tiên của Ruby , điều này chỉ đi qua mảng số nguyên và với mỗi số nguyên, hãy xem liệu có một đường thẳng nhỏ trong đầu vào bắt đầu bằng số nguyên đó không. Không lo lắng về các giá trị có thể hoặc tính duy nhất.

Điều này dường như đang sử dụng cùng một thuật toán như câu trả lời của Sherlock .

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

Ruby, 58 55 50 47 43 33 byte

Bây giờ tôi mới thấy rằng tôi đã bị đánh bởi cú đấm bởi câu trả lời Ruby của Paul . Tuy nhiên tôi không bị ngăn cản vì tôi nghĩ rằng đây vẫn có thể là một câu trả lời đúng đắn với một số môn đánh gôn hơn. Dựa trên một phần, dựa trên câu trả lời Python của xnor .

Chỉnh sửa: Một số chơi golf và sửa chữa một hỗn hợp trong điều kiện ternary.

Chỉnh sửa: Bây giờ tôi sử dụng .any?như Không phải Charles làm trong câu trả lời Ruby của họ mà chỉ bởi vì tôi cần một cách đơn giản để loại bỏ avà chỉ trả lại một sự thật và một chú chim ưng !([*i..i+3]-l)[0]từ đó .mapsẽ trả lại một mảng truevà false.

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

Trả về truehoặc false.

Ung dung:

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

Lưu ý quan trọng: Đối với những người muốn sử dụng (a2 - a1).empty?mã để xác định xem tất cả các yếu tố a2có trong hay không a1, lưu ý rằng nếu bạn muốn đảm bảo rằng, ví dụ, [2,1,2]là trong [1,2,3,3]bội số của các yếu tố, bạn cần mã khác. Thảo luận có liên quan về vấn đề này ở đây .

Japt, 13 12 byte

Uá4 d@7o ¬fX

Kiểm tra nó trực tuyến!hoặc Xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

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

Bao gồm +1 cho -p

Chạy với chuỗi trên STDIN, vd

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

smallstraight.pl:

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

Giải trình

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 byte

7,4ewl~f&3f>

Mang lại một chuỗi không trống cho các trường hợp kiểm tra trung thực và một chuỗi trống cho các chuỗi giả.

Bộ thử nghiệm.

Giải trình

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.

Vào cuối chương trình, danh sách này được làm phẳng thành một chuỗi duy nhất và được in thành STDOUT. Nếu bất kỳ dây đai nhỏ nào được tìm thấy, các phần tử còn lại của chúng sẽ nằm trong chuỗi. Mặt khác, tất cả các danh sách đều trống và do đó chuỗi cũng trống.

05AB1E , 9 8 10 byte

Truthy là có chứa một mảng trong đầu ra, falsy là khi không có đầu ra được sản xuất. Mã số:

œvy¦¥1QPiy

Giải thích lỗi thời :

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

Hãy thử trực tuyến!

Sử dụng mã hóa CP-1252 .

Javascript ES6 47 byte

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

Javascript ES6 52 byte

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 byte

cảm ơn ETHproductions đã giúp lưu vài byte

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)

Kiểm tra

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

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

hoặc: (cùng số byte)

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

Ung dung:

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
}

Chỉnh sửa lớn: Chỉ cần nhận ra tôi chỉ cần đăng một chức năng, không phải toàn bộ chương trình. Điều đó tiết kiệm rất nhiều. Không có bản tóm tắt, không cần phải chuyển đổi đầu vào chuỗi thành số, v.v ... Bây giờ chúng ta thực sự đang tiếp cận một số byte đáng nể (dù sao đối với một ngôn ngữ không chơi gôn).

Ruby - 80 -> 79 -> 76 -> 54 -> 48 -> 40 byte

Lần thử thứ năm (40 byte):

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

Sử dụng cú pháp lambda để xác định hàm. (Nhờ thi đấu với golfer Ruby @ Sherlock9 cho ý tưởng này.)

Để kiểm tra bằng lambda, hãy gọi:

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

Thử lần thứ tư:

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

Thay thế con số không? và phủ định với toán tử ===.

Lần thử thứ ba:

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

Sử dụng biểu thức chính quy.

Thử lần thứ hai:

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

Cách tiếp cận mới sử dụng khấu trừ (uniq), sắp xếp và tham gia, cộng với bao gồm? để tìm kiếm sự phù hợp của bất kỳ giải pháp nào trong đầu vào được hiển thị dưới dạng chuỗi.

Lần thử đầu tiên: 79 byte

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

Người kiểm tra:

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

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

Sử dụng suy luận (hàm uniq) cộng với giao điểm (& toán tử) để kiểm tra xem có bất kỳ chuỗi tốt nào khớp với chuỗi đã cho hay không. Không cần phân loại.

Bình thường 13 11

@.PQ4.:S6 4

2 byte nhờ Jakube!

Trả về một danh sách không trống cho danh sách trung thực, trống cho giả.

Dùng thử trực tuyến hoặc chạy Test Suite (chia theo lỗi cú pháp cho Readability ™).

PHP, 95 byte

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

Nghiêm túc, 21 byte

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

Hãy thử trực tuyến!

Xuất ra giá trị dương cho true và 0 cho false.

Giải trình:

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 byte

Điều này có thể có thể được đánh gôn hơn nữa, nhưng như một khởi đầu:

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

Tôi không thấy cách giảm trùng lặp mà không sử dụng nhiều không gian hơn; phiên bản này là 75 byte:

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

Võng mạc , 70 54 byte

Đầu vào là một chuỗi số nguyên như thế nào 13342. Đầu ra là một 1nếu tìm thấy, hoặc 0nếu không.

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

Lưu ý rằng việc loại bỏ trùng lặp chỉ cần xảy ra một lần, vì chỉ có năm số. Cần phải xóa nhiều hơn một số có nghĩa là không có một đường thẳng nhỏ nào.

Dùng thử trực tuyến

Cảm ơn Martin vì ý tưởng di chuyển dấu phẩy bên trong các nhóm chụp, tiết kiệm được 16 byte.

Bình thường, 11 byte

f!-TQ.:S6 4

Bộ kiểm tra

Tạo độ dài 4 chuỗi con của [1..6], sau đó lọc chúng trên các phần tử còn lại khi các phần tử của đầu vào bị loại bỏ.

Thạch, 9 byte

Phải có một giải pháp 8 byte, sẽ tiếp tục tìm kiếm ... Mã:

Œ!Ḋ€Iµ7Be

Điều này giống như giải pháp 05AB1E của tôi .

Giải trình:

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

Hãy thử trực tuyến!

Thạch, 8 byte

6Rṡ4ḟ€ċ“

Hãy thử trực tuyến! hoặc xác minh các trường hợp kiểm tra trung thực và các trường hợp kiểm tra giả .

Làm thế nào nó hoạt động

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

Scala, 76 70 61 60 byte

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

Người kiểm tra:

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 byte

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

Cái này lấy số 62 (111110 ở dạng nhị phân) Với mỗi số trong mảng đầu vào, nó sẽ loại bỏ bit đó

Số kết quả phải là

100000 or
000000 or
000010 or
000110 or
000100

vì vậy tôi kiểm tra xem kết quả có nhỏ hơn 7 (0000111) hay không nếu nó bằng 32 (100000)

TI-BASIC, 25 byte

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

Một biểu thức Python tương đương (không được mã hóa) mà bạn có thể kiểm tra :

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

Ý tưởng đằng sau điều này là sự chia rẽ. Để kiểm tra xem một 1, 2, 3, 4, 2, 3, 4, 5hoặc3, 4, 5, 6 xảy ra, chúng ta có thể ánh xạ các số từ 1-6 đến 37-42, sau đó nhân các số chính xác với nhau.

Mỗi số trong [37,42] có một thừa số nguyên tố mà các số khác thiếu.

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

Do đó, nếu tích của năm số chia hết cho 37, thì danh sách ban đầu chứa 1. Nếu bằng 19, nó chứa 2; v.v ... Nếu nó chia hết cho 37*19*13*5=65*703 , nó chứa 1, 2, 3, và4 và tương tự cho hai số khác.

Giải pháp này là một cải tiến trên một cái mà @Weregoose đã đăng trong năm 2009.

Quai bị, 113 78 byte

Phiên bản Quai bị tôi đang sử dụng là InterSystems Cache.

Tôi không thể nghĩ ra cách chơi golf kỹ thuật này ngắn hơn nữa; với một kỹ thuật khác có thể là có thể, nhưng bây giờ điều này sẽ làm được và ít nhất là nó ngắn hơn C ++ ... nhưng không nhiều. Dù sao...

OK, đây là một cách ngắn hơn. Thay vì có 3 biến riêng biệt cho các lần chạy ngắn, hãy sử dụng một biến duy nhất cho tất cả 6 'xúc xắc' và trích xuất các phần sau:

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ất nhiều cho tôi không tìm thấy một cách tốt hơn với cùng một kỹ thuật ... Tôi nên tìm kiếm trước khi tôi nhảy, eh? ;-)

Tôi sẽ để lại câu trả lời ban đầu của tôi dưới đây cho mục đích lịch sử ...

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

và đây là lời giải thích về những gì đang xảy ra với mã:

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.

Tôi đã không kiểm tra mọi đầu vào trung thực & giả mạo vì liên quan đến việc nhập tất cả chúng vào; nhưng tôi đã kiểm tra khoảng nửa đầu của mỗi lần, xác minh các căng thẳng dài vẫn cho thấy sự thật và một số lần chạy được ghi nhận là không nhất thiết phải hoạt động chính xác ([4.2,5,3,4], [1,2,3,3 , 4] vv) và dường như đang hoạt động chính xác.

APL Dyalog , 15 byte

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

sử dụng ⎕IO=0

⍳4 Là 0 1 2 3

⍵∘.+⍳4 là 5 × 4 một ma trận của mỗi khuôn được tăng lên theo từng ⍳4

⍵∊⍨ kiểm tra xem các phần tử của ma trận có trong tay không, kết quả là ma trận boolean (0 hoặc 1), chúng ta cần tìm một hàng của tất cả 1 giây

∧/ là và giảm theo hàng, kết quả là một vectơ boolean

∨/ là sự giảm bớt của vectơ đó

Thạch, 11

QṢṡ4ðfø6Rṡ4

Hãy thử trực tuyến!

Đây là khá nhiều bản sao câu trả lời Pyth của tôi, chỉ cố gắng tìm ra cách xâu chuỗi các thứ. Cảm thấy như nó nên chơi golf.

Sự bành trướng:

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]

Nếu bạn muốn hỏi bất kỳ câu hỏi khó nào, như tại sao các dải phân cách khác nhau, thì câu trả lời của tôi cho bạn là: "Tôi sẽ trả lời trong 6-8 tuần": P (Nghiêm trọng hơn, tôi nghĩ đó là mẫu phù hợp, đơn sắc vs nilad-dyad, nhưng tôi không biết và không muốn truyền bá thông tin sai lệch.)