ヤッツィースモールストレート検出


34

ゲームYahtzeeでは、プレイヤーは6つのサイコロを5つ振り、ポイントを獲得するために特定の手を作成しようとします。そのようなハンドの1つは小さなストレートです。4つの連続した数字で、必ずしも順番に並んでいるとは限りません。三つの可能な小型のストレートがあり1, 2, 3, 42, 3, 4, 53, 4, 5, 6

たとえば[3, 5, 6, 1, 4]、小さな直線が含まれてい[3, 4, 5, 6]ます。

入力

ヤッツィーハンドを表す、それぞれ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>


真理値は一貫している必要がありますか?真実の結果には(一定でない)正の整数を、偽の結果には0を出力できますか?
マーティンエンダー

@MartinBüttner一貫している必要はありません。
リルトシアスト

9
動作するかどうかを確認してください[1,2,3,3,4]。このため、多くの回答が死にます。
電卓

配列にゼロが埋め込まれていると想定できますか?
電卓

5
@CatsAreFluffy "die"
ダスティンレイズナー

回答:


28

MATL7 12 11 9 8 6バイト

2バイトを削除してくれた@lirtosiastに感謝します。

ud7BXf

Truthyは、ゼロ以外の値の配列です。Falsyは空の配列です(出力は表示されません)。

リリース16.2.0では、uデフォルトで安定しています。そのため、コードSは出力をソートするために追加が必要です:uSd7BXf7バイト)。リンクにはこの変更が含まれます。

オンラインでお試しください!

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

4
6バイト?!これは信じられない!
アドナン

3
@AandN \ o / \ o / \ o /
ルイスメンドー

8
他のユーザーが行うように、バイトカウントの履歴を保持する場合、私はそれを望みます。進行状況を示しています。
mbomb007

1
少なくとも8から6への進行は正しかった...
コナーオブライエン

5
@DonMuesli FWIW私はあなたに同意し、mbomb007に反対します。動作していなかったバージョンは無意味であり、履歴に含めるべきではありません。通常、作業バージョンのバイトカウントのみを含めるため、これは間違いなく厳密に減少するシーケンスです。
マーティンエンダー

12

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)

サイコロが小さなストレートセットの開始点かどうかを確認します。リスト内の開始値のみをチェックし、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}


10

ラビリンス、41バイト

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

@MartinBüttnerとの共同回答。当初の予想をはるかに超えてこれを絞り込んだと思います。

出力は1真実の場合で、偽の場合は空です。オンラインでお試しください!

簡単な説明

各数値nを1の後にn+1ゼロが続く2進整数に変換します2^(n+1)。結果をビット単位でORし、1111(バイナリで)チェックします。べき乗は、ラビリンスに手動で実装する必要があります。

詳細な説明

通常の入門書:

  • Labyrinthは、スタックベースの2Dプログラミング言語です。メモリにはメインスタックと補助スタックがあり、空のスタックからポップするとエラーではなく0が生成されます。
  • 命令ポインタが2つ以上の可能なパスを下に移動できる各ジャンクションで、スタックの最上部がチェックされ、次に進むべき場所が決定されます。負の値は左、ゼロは順方向、正の値は右です。
  • Labyrinthの数字は、対応する数字をスタックにプッシュしません。むしろ、ポップnしてプッシュしn*10 + <digit>ます。新しい番号を開始するには、_ゼロを押します。

セットアップ

実行は左上から始まり、命令ポインターは右向きになります。実行します:

=        Swap tops of main and auxiliary stacks
|        Bitwise OR

ゼロを効果的にプッシュする以外に、これらの命令はスタックを変更しません。

左ループ:指数およびビット単位のOR

ラビリンスにはべき乗がないため、手動で実装する必要があります。まず、で整数を読み取ります。?これは正であることが保証されているため、右に曲がります。_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を補助スタックに配置したことを覚えていますか?反復ごとに2つを使用するため、4番目の反復で、補助スタックの下部からゼロをプルし始めます。すると、ゼロによる除算が行われ{/、プログラムは終了します。

  • 小さなストレートに対して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]になります。右ループでさらに2回繰り返した後、ゼロで除算することでエラーが発生します。

  • ある時点でbがゼロになった後:ここで重要なの:は、右側のループがジャンクションにあることです。入力が、たとえば、1 1 1 1 1であるb場合4、次に21、それから03回目の繰り返しの後。で回るのではなく:、IPは直進し、前の例のようなものがたまたま終了します。

全体として、プログラムがどのように終了するかは混乱していますが、それらの数バイトを節約するために何でもしてください!



7

Haskell、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バイトを節約しました。ありがとう!


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)

5

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]のすべての値について、これら2つの値の合計が入力配列にあるという条件を満たす場合に戻ります。

そのため、配列に[0、1、2、3](不可能)、[1、2、3、4]、[2、3、4、5]、または[3、4、5のすべての値がある場合に戻ります、6]。


5

ルビー、31

Rubyの最初の答えのように賢くしようとする代わりに、これは整数の配列をただ通過し、各整数について、その整数で始まる入力に小さな直線があるかどうかを確認します。可能な値や一意性について心配しません。

これは、Sherlockのanswerと同じアルゴリズムを使用しているようです。

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

5

ルビー、58 55 50 47 43 33バイト

私は今、ポールのルビーの答えによってパンチに打ちのめされているのを見ました。しかし、私はこれがいくつかのより多くのゴ​​ルフでまだまともな答えであると思うので、私は阻止しません。一部は、xnorのPython answerに基づいています

編集:いくつかのゴルフと三項条件の混乱を修正。

編集:私は今、使用.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?コードを使用してのすべての要素a2がin a1であるかどうかを判断する場合、たとえば、要素の多重度を確認する場合[2,1,2]は、[1,2,3,3]他のコードが必要です。ここでこの問題の関連議論


ユーザーの代わりに回答にリンクできますか?
コナーオブライエン

@CᴏɴᴏʀO'Bʀɪᴇɴ修正済み。
Sherlock9

誤って同じアルゴリズムを使用したと思います。ごめんなさい! codegolf.stackexchange.com/a/75273 投稿する前に気づいたなら投稿しなかったでしょう。
チャールズチャールズ

@NotthatCharlesまあ、あなたの答えは私のものより良かったので、私はあなたに賛成票を差し上げました。
Sherlock9

また、ちょうどメモとして、0Rubyでは真実であるため、あなたの答えは無効だと思います。 pは1文字の偽の値です。
チャールズ

4

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

3
素敵なアプローチ!!
ルイスメンドー

4

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

3

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に出力されます。小さな直線のいずれかが見つかった場合、残りの要素は文字列に含まれます。それ以外の場合、すべてのリストが空だったため、文字列も空になります。


@ mbomb007「つまり、考えられるすべての小さなストレート(および不可能なストレート)」入力にはゼロが含まれないため、小さなストレートは検出されず、結果に影響しません。
マーティンエンダー

@ mbomb007ええ、取り除くに[0 1 2 3]は2バイトかかります。
マーティンエンダー

3

05AB1E9 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エンコードを使用します。


3

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

1
かっこはから削除できると思いますt=(t>4)?t:1
ETHproductions

いくつかのマイナーな改善点を次に示します。q=>q.sort().map(o=>(o-s?o-s<2?t++:t=t>4?t:1:0,s=o),t=1,s=9)|t>3このバージョンは1、真実と0偽物のために戻ります。
-ETHproductions

3

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
}

大きな編集:プログラム全体ではなく、関数を投稿するだけでよいことに気付きました。それは全体を大幅に節約します。決まり文句なし、文字列入力を数値に変換する必要などはありません。実際、かなりのバイト数に近づいています(とにかく非ゴルフ言語の場合)。


3バイトを節約するためにブール値を返します。
ティンボ

@Timbo-ええ、昨日家に帰った後、それを修正したと思いました。それは完全なプログラムであるために残っていました(mainC#ではどちらvoidかを返す必要がありintます)残念ながら、1-6ではなく0-5を期待していたため、2バイトも獲得しました。とにかく1バイトの純損失。
ダレル・ホフマン

3

Ruby-80-> 79-> 76-> 54-> 48-> 40バイト

5回目の試行(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])

4回目の試行:

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

nilを置き換えましたか?および===演算子による否定。

3回目の試行:

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

正規表現を使用します。

2回目の試行:

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

新しいアプローチでは、dedup(uniq)、並べ替え、結合、さらにincludeを使用しますか?文字列としてレンダリングされた入力内のソリューションの一致を検索します。

最初の試行: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関数)と集合交差(&演算子)を使用して、適切なシーケンスのいずれかが指定されたシーケンスと一致するかどうかをテストします。ソートは必要ありません。



2

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

2

真剣に、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

2

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

2

網膜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つの数字しかないため、重複の削除は1回だけで済みます。複数の番号を削除する必要がある場合は、とにかく小さなストレートがないことを意味します。

オンラインで試す

キャプチャグループ内でコンマを移動し、なんと16バイトを節約するというアイデアを提供してくれたMartinに感謝します。


どのように機能しますか?
電卓

. $*x Replace numbers with n x's, where n is the number. +` Repeat the following until the string stabilizes (x+(x+,))\2 $2$1 Replace n*xm*x,m*x, with m*x,n*xm*x (x+,)\1 $1 Replace x*n,x*n, with x*n, (x+,)x\1xx\1xxx\1 Match n*x,xn*x,xxn*x,xxxn*x更新
CalculatorFeline

@CatsAreFluffy説明として使用していません。参考までに。Retina githubページを一度も読んだことがある人なら誰でもそれを手に入れるべきです。達成されていることに関するコメント(並べ替え、重複の削除など)は、それぞれが置換であるという説明よりも重要です。
mbomb007

2

Pyth、11バイト

f!-TQ.:S6 4

テストスイート

[1..6]の長さ4の部分文字列を生成し、入力の要素が削除されるときに要素が残っていない状態でフィルタリングします。


2

ゼリー、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

オンラインでお試しください!


別の代替案9:Œ!I=1ZS3e...
FryAmTheEggman

では機能しません[1, 2, 1, 2, 1]。また、残念ながらあなたの他の回答も機能しません。私の代替案は動作するようです(しかし、私は以前に間違っていました...それもテストしてください:))、それを自由に使用してください。
FryAmTheEggman

2

ゼリー、8バイト

6Rṡ4ḟ€ċ“

オンラインでお試しください!または真実のテストケース 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).

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

2

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(2進数で111110)を取ります。入力配列の各数値に対して、そのビットを削除します

結果の数は

100000 or
000000 or
000010 or
000110 or
000100

結果が7(0000111)より小さいか、32(100000)であるかを確認します


2,3,4,5,2のようなリストで34にならないでしょうか?
リルトシアスト

それでも、これが機能しないという事実は変わりません[3, 4, 5, 4, 3]。62ではなく126を使用する必要があると思う
-Sp3000

2

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、1〜6の数字を37〜42にマッピングしてから、正しい数字を乗算します。2, 3, 4, 53, 4, 5, 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、それが含まれている123、および4他の二つの数字についても同様と。

このソリューションは、2009年に@Weregooseが投稿したものを改良したものです。


これは素晴らしいです!
チャールズ

2

おたふく風邪、113 78バイト

私が使用しているおたふく風邪のバージョンはインターシステムズキャッシュです。

このテクニックをもっと短くゴルフする方法は考えられません。別の手法では可能かもしれませんが、今のところはこれで十分です。少なくともC ++よりは短いですが、それほどではありません。とにかく...

OK、もっと簡単な方法です。短期間の実行に3つの変数を使用する代わりに、6つの「ダイス」すべてに1つの変数を使用し、後でその部分を抽出します。

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.

私がテストしていないすべてのシングルでそれらのすべてを入力して手動で関与とtruthy&falsy入力を。しかし、私はそれぞれの前半をテストし、長いストレートがまだ真実であることを確認し、いくつかの実行が必ずしも正しく動作しないことを確認しました([4,2,5,3,4]、[1,2,3,3 、4]など)および正常に動作しているようです。


2

Dyalog APL、15バイト

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

使用する ⎕IO=0

⍳40 1 2 3

⍵∘.+⍳4 5×4は、各ダイが増加したマトリックス ⍳4

⍵∊⍨ 行列の要素が手元にあるかどうかをチェックします。結果はブール(0または1)行列です。すべて1の行を見つける必要があります

∧/ 行によるand-reductionです。結果はブールベクトルです

∨/ そのベクトルのor-reductionです


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、しかし、私は知らないし、誤報を広めたくない。)


説明:Q Unique elements Ṣ sort the list ṡ4 all slices of length 4 ðf filter by { 6R range form 1 to 6 ṡ4 all slices of length 4 from that
CalculatorFeline

何らかの理由Qで、ドキュメントの大文字のオーバードット演算子を使用しています。たぶん、それはかつて過大評価だったのですか?
電卓

@CatsAreFluffy私は見当がつかない、私は、コード・ページから1を使用する原子ページ
FryAmTheEggman
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.