Yahtzee 게임 에서 플레이어는 6 면체 주사위 5 개를 굴려 점수를 얻기 위해 특정 손을 만듭니다. 그러한 손 중 하나는 작은 직선입니다 . 4 개의 연속 된 숫자는 반드시 순서대로는 아닙니다. 세 가지 가능한 작은 스트레이트는 1, 2, 3, 4, 2, 3, 4, 5및 3, 4, 5, 6.

예를 들어, [3, 5, 6, 1, 4]작은 straight를 포함합니다 [3, 4, 5, 6].

입력

Yahtzee 핸드를 나타내는 각각 1에서 6까지의 5 개의 정수로 구성된 정렬되지 않은 목록.

산출

손에 작고 똑 바른 값이 포함되어 있으면 진실한 가치.

테스트 사례

진실한 :

[[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 바이트

2 바이트를 제거 한 @lirtosiast에게 감사드립니다.

ud7BXf

Truthy는 0이 아닌 값의 배열입니다. Falsy는 빈 배열입니다 (출력이 표시되지 않음).

릴리스 16.2.0부터는 u기본적으로 안정적입니다. 따라서 코드 S는 출력을 정렬하기 위해 추가 로 필요합니다 : uSd7BXf( 7 bytes ). 링크에는이 수정 사항이 포함되어 있습니다.

온라인으로 사용해보십시오!

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

파이썬, 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)

다이 롤이 작은 직선 세트의 시작인지 확인합니다. 목록에서 시작 값만 확인하고 5 바이트를 절약 할 수있는 Zgarb에게 감사드립니다.

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+10을 씁니다 2^(n+1). 결과를 비트 단위로 OR하고 1111(이진수로) 확인하십시오 . Labyrinth에서 지수를 수동으로 구현해야합니다.

상해

일반적인 프라이머 :

• Labyrinth는 스택 기반 2D 프로그래밍 언어입니다. 메모리에는 주 스택과 보조 스택이 있으며 빈 스택에서 팝업하면 오류가 아닌 0이 생성됩니다.
• 명령 포인터가 두 개 이상의 가능한 경로를 아래로 이동할 수있는 각 접점에서 스택의 맨 위를 확인하여 다음에 갈 곳을 결정합니다. 음수는 남아 있고, 0은 앞으로, 양수는 오른쪽입니다.
• Labyrinth의 자릿수는 해당 자릿수를 스택으로 푸시하지 않고 팝 n및 푸시 n*10 + <digit>합니다. 새로운 숫자를 시작하려면 _0 을 누릅니다 .

설정

명령 포인터가 오른쪽을 향한 상태로 왼쪽 상단에서 실행이 시작됩니다. 우리는 다음을 실행합니다.

=        Swap tops of main and auxiliary stacks
|        Bitwise OR

효과적으로 0을 밀어내는 것 외에도,이 명령어는 스택을 변경하지 않습니다.

왼쪽 루프 : 지수 및 비트 OR

Labyrinth에는 지수가 없으므로 수동으로 구현해야합니다. 먼저 우리는로 정수를 읽습니다. ?이것이 긍정적이기 때문에 우회전합니다. _11을 누르면 내부 루프로 들어갑니다.

내부 루프는 다음을 수행합니다.

(       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애프터 ?통해 보조 스택으로 푸시 (30)에 회전 EOF에서 0 }. 중요한 것은 모든 입력 번호에 대해 30을 보조 스택으로 푸시 했으므로 이제 보조 스택 5 + 1 = 6에 번호 30의 사본이 포함 됩니다.

한편, 메인 스택에는 2^(n+1)각 입력 에 대한 비트 단위 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 개의 30을 어떻게 넣었는지 기억하십니까? 각 반복마다 두 가지를 사용하기 때문에 네 번째 반복에서 보조 스택의 맨 아래에서 0을 가져 오기 시작합니다. 우리가 할 때 0으로 나누고 {/프로그램이 종료됩니다.

• 작은 직선에 대해 1을 출력 한 후 : 우리는 !no-op "junction 에서 오른쪽으로 돌았습니다 . 그런 다음 왼쪽 절반을 다시 크롤링하기 시작하면 롤러 코스터가 시작됩니다.

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가 0이 된 후 : 여기서 핵심 :은 오른쪽 루프의 교차점에 있다는 것입니다. 입력이 있었다면, 말하자면, 1 1 1 1 1다음 b이 될 것입니다 4, 다음 2, 다음 1, 다음 0세 번째 반복 후. :IP 를 돌리는 대신 이제 IP가 곧바로 이동하고 이전의 경우와 같은 상황이 발생하여 결국 종료됩니다.

결국 프로그램이 어떻게 종료되는지 엉망이지만 몇 바이트를 절약 할 수있는 것은 아무것도 없습니다!

매스 매 티카, 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 's answer 와 유사 합니다. 입력 목록에 작은 직선이 있는지 확인하십시오. 사실 나는 모든 "작은 스트레이트"(즉, 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)

자바 스크립트 (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==[]}}

루비, 58 55 50 47 43 33 바이트

나는 방금 Paul의 Ruby 답변으로 펀치에 맞았다는 것을 알았습니다 . 그러나 이것이 여전히 골프에 대한 적절한 대답이 될 수 있다고 생각하기 때문에 나는 억제되지 않습니다. xnor 's Python answer 에 부분적으로 기초 합니다.

편집 : 일부 골프 및 삼진 조건부에서 믹스 업 수정.

편집 : 내가 지금 사용 .any?처럼 하지 찰스는 자신의 루비 대답한다는 것을 하지만 난 간단한 방법이 필요 때문에 만 제거 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?코드 를 사용하여의 모든 요소 a2가에 있는지 판별 a1하려는 경우, 예를 들어 여러 요소 [2,1,2]에 있는지 확인 [1,2,3,3]하려면 다른 코드가 필요합니다. 여기에서이 문제에 대한 관련 토론 .

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

펄, 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 는 출력에 배열을 포함하고, 거짓 은 출력이 생성되지 않을 때입니다. 암호:

œ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 인코딩을 사용합니다 .

자바 스크립트 ES6 47 바이트

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

자바 스크립트 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)

자바 스크립트 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
}

Big Edit : 방금 프로그램 전체가 아니라 함수 만 게시하면된다는 것을 깨달았습니다. 그것은 많은 것을 절약합니다. 상용구도없고 문자열 입력을 숫자 등으로 변환 할 필요가 없습니다. 이제 우리는 실제로 상당한 양의 바이트에 접근하고 있습니다 (어쨌든 골프가 아닌 언어의 경우).

루비-80-> 79-> 76-> 54-> 48-> 40 바이트

다섯 번째 시도 (40 바이트) :

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

람다 구문을 사용하여 함수를 정의합니다. (이 아이디어에 대해 경쟁하는 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

nil로 교체 되었습니까? === 연산자로 부정.

세 번째 시도 :

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 함수)와 설정 교차 (& 연산자)를 사용하여 올바른 시퀀스가 ​​주어진 시퀀스와 일치하는지 테스트합니다. 정렬이 필요하지 않습니다.

피스, 13 11

@.PQ4.:S6 4

Jakube 덕분에 2 바이트!

허위에 대한 진실하고 빈 목록에 대해서는 비어 있지 않은 목록을 반환합니다.

온라인으로 시도 하거나 Test Suite를 실행하십시오 (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

5 개의 숫자 만 있기 때문에 중복 제거는 한 번만 수행하면됩니다. 둘 이상의 숫자를 제거해야한다는 것은 어쨌든 작은 숫자가 없다는 것을 의미합니다.

온라인으로 사용해보십시오

캡처 그룹 내에서 쉼표를 이동하여 엄청난 16 바이트를 절약 할 수있는 아이디어를 제공 한 Martin에게 감사합니다.

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

온라인으로 사용해보십시오! 또는 확인 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)

시험 장치:

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

자바 스크립트 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

테스트 할 수있는 동등한 (비합법적 인) 파이썬 표현식 :

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발생, 우리는 함께 곱 다음 올바른 번호를 37-42로 번호를 1-6 매핑 할 수 있습니다.

[37,42]의 각 숫자에는 다른 숫자가없는 주요 요소가 있습니다.

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

따라서 5 개 숫자의 곱을 37로 나눌 수 있으면 원래 목록에 1이 포함되고 19이면 2가 포함됩니다. 등이로 나누어 경우 37*19*13*5= 65*703, 포함 된 1, 2, 3, 및 4유사하게 다른 두 숫자.

이 솔루션은 @Weregoose 가 2009 년에 게시 한 솔루션을 개선 한 것 입니다 .

볼거리, 113 78 바이트

내가 사용하는 유행성 이하선염의 버전은 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의 행을 찾아야합니다.

∧/ 행에 의한 and-reduction이고, 결과는 부울 벡터입니다

∨/ 그 벡터의 or- 감소입니다

젤리, 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 (더 심각하게 말하면 패턴 일치라고 생각합니다. vs nilad-dyad, 그러나 나는 잘못된 정보를 퍼 뜨리고 싶지 않습니다.)