在Yahtzee游戏中，玩家掷出五个六面骰子，并尝试制造某些手以得分。这样的一手牌是小顺子：四个连续的数字，不一定是顺序的。三种可能的小直道是1, 2, 3, 4，2, 3, 4, 5和3, 4, 5, 6。

例如，[3, 5, 6, 1, 4]包含小笔直[3, 4, 5, 6]。

输入项

五个整数的未排序列表，每个整数在1到6之间（包括1和6），表示Yahtzee手。

输出量

如果手牌有小笔直则为真值，否则为假值。

测试用例

真相：

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

虚假：

[[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个月后恢复健康。iZgarb的想法是只检查集合中的起始值，因此我们不需要检查是否在集合中。我们现在也可以将其<用于严格的子集，因为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)。按位或结果，然后检查1111（二进制）。幂运算需要在迷宫中手动实现。

详细说明

常用底漆：

• 迷宫是一种基于堆栈的2D编程语言。对于内存，有一个主堆栈和一个辅助堆栈，从空堆栈弹出会产生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

由于这是一个do-while循环，因此要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 为止。这使我们向前移动而不是转向，从而导致...

桥：一些额外的设置

在30后?匝从0到EOF 30，其经由推到辅助堆栈}。重要的是，对于每个输入数字，我们将30推入辅助堆栈，因此现在辅助堆栈包含5 + 1 = 6数字30的副本。

同时，主堆栈包含2^(n+1)每个input 的按位OR n。我们称其为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仍然为正：还记得我们如何将6个30s放入辅助堆栈中吗？由于每次迭代都使用两个，因此在第四次迭代中，我们开始从辅助堆栈的底部拉零。当我们这样做时{/，这将导致被零除，并且程序终止。

• 在为小直线输出1之后，我们执行!了该操作，然后在无操作"交界处右转。然后我们开始过山车，因为我们再次开始在左半边爬网：

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.

在指数运算器中运行了几次之后，堆栈看起来像[12 | 30 30]，它在右循环中再经过两次迭代后被零除以错误。

• 在b在某个点变为零之后：这里的关键是:右循环中的in在一个结点。如果输入的是，比如说1 1 1 1 1，然后b会4，然后2，然后1，然后0第三次迭代后。:现在，IP不再向右转，而是直接向前移动，并且像前一种情况一样会导致最终终止。

总而言之，程序如何终止真是一团糟，但是嘿，要节省那几个字节！

Mathematica，39 43 44 31 39 44字节

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

哈斯克尔， 39 34字节

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

用法示例：f [1,2,3,3,4]-> True。

类似于@xnor的答案，即检查输入列表中是否有任何小直线。实际上，我正在从输入列表中的任何数字开始测试所有“小平直”（即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岁

与其尝试像第一个Ruby答案那样变得聪明，不如通过整数数组进行遍历，对于每个整数，请查看输入中是否存在以该整数开头的小笔直。不必担心可能的值或唯一性。

这似乎使用了与Sherlock的答案相同的算法。

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

Ruby，58 55 50 47 43 33字节

我刚才看到，保罗的露比回答使我受挫。但是我并没有因此而感到沮丧，因为我认为如果再打些高尔夫球，这仍然是一个不错的答案。部分基于xnor的Python答案。

编辑：打高尔夫球和纠正三元条件中的混淆。

编辑：我现在用.any?像这并不是说查尔斯确实在他们的Ruby的答案，但仅仅是因为我需要一个简单的方法来去除a，并仅返回一个truthy并用falsey !([*i..i+3]-l)[0]因为.map将返回数组true和false。

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

返回true或false。

取消高尔夫：

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?代码确定a2in的所有元素是否在in中的人a1，请注意，例如，如果您要确保[2,1,2]in包含[1,2,3,3]多个元素，则需要其他代码。有关这个问题的讨论在这里。

Japt，13个12字节

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。如果找到任何一条小直线，则其其余元素将在字符串中。否则，所有列表都是空的，因此字符串也为空。

05AB1E，9 8 10字节

Truthy由含有在输出阵列，falsy是当产生任何输出。码：

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

取消高尔夫：

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}

使用lambda语法定义函数。（感谢竞争的Ruby高尔夫球手@ Sherlock9提出了这个想法。）

要使用lambda调用进行测试，请执行以下操作：

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

测试人员：

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

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

使用重复数据删除（uniq函数）加上集合交集（＆运算符）来测试是否有任何良好序列与给定序列匹配。无需排序。

Pyth， 13 11

@.PQ4.:S6 4

感谢Jakube 2个字节！

返回真值的非空列表，假值的空列表。

在线尝试或运行测试套件（由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Σ

在线尝试！

为true输出一个正值，为false输出一个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 54字节

输入是一个整数字符串，例如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

请注意，重复项的删除只需进行一次，因为只有五个数字。需要删除一个以上的数字意味着无论如何都不会有小的顺子。

在线尝试

感谢Martin提出的在捕获组中移动逗号的想法，节省了多达16个字节。

Pyth，11个字节

f!-TQ.:S6 4

测试套件

生成长度为[1..6]的4个子字符串，然后在除去输入的元素时，在没有剩余元素的情况下对其进行过滤。

果冻，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ḟ€ċ“

在线尝试！或验证真实测试用例和虚假测试用例。

怎么运行的

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

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

测试人员：

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（100000）

TI-BASIC，25个字节

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

您可以测试一个等效的（解开的）Python表达式：

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。等。如果它是整除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，但我不知道也不希望散布错误信息。）