Dalam permainan Yahtzee , pemain melempar lima dadu enam sisi, dan berusaha menciptakan tangan tertentu untuk mencetak poin. Satu tangan semacam itu adalah lurus kecil : empat angka berurutan, tidak harus berurutan. Tiga lurus kecil yang mungkin adalah 1, 2, 3, 4, 2, 3, 4, 5, dan 3, 4, 5, 6.

Misalnya, [3, 5, 6, 1, 4]berisi straight kecil [3, 4, 5, 6].

Memasukkan

Daftar lima bilangan bulat yang tidak disortir, masing-masing antara 1 dan 6 inklusif, mewakili tangan Yahtzee.

Keluaran

Nilai kebenaran jika tangan berisi nilai lurus kecil dan nilai falsy sebaliknya.

Uji kasus

Benar:

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

Falsy:

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

_{Terinspirasi oleh ini}

Katalog

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

Terima kasih banyak kepada @ lirtosiast karena telah menghapus 2 byte

ud7BXf

Truthy adalah array nilai bukan nol. Falsy adalah array kosong (tidak ada output yang ditampilkan).

Pada rilis 16.2.0, ustabil secara default. Jadi kode membutuhkan ekstra Suntuk mengurutkan output: uSd7BXf( 7 byte ). Tautan ini menyertakan modifikasi ini.

Cobalah online!

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)

Kembali setelah 9 bulan dengan peningkatan. Kita tidak perlu memeriksa apakah iada di set dengan ide Zgarb untuk memeriksa hanya nilai awal di set. Kita sekarang dapat juga menggunakan <subset ketat karena ijuga harus disertakan.

47 byte:

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

Memeriksa apakah ada gulungan mati adalah awal dari set kecil lurus. Terima kasih kepada Zgarb untuk gagasan hanya memeriksa nilai awal dalam daftar, menghemat 5 byte.

Python 3.5 memiliki konversi konversi yang lebih pendek, untuk 45 byte

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

Ini panjang yang sama untuk melakukan {*range(i,i+4)}seperti {i,i+1,i+2,i+3}.

Labirin, 41 byte

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

Jawaban collab dengan @ MartinBüttner. Saya pikir kami telah meremas yang satu ini jauh melampaui harapan awal saya.

Keluaran adalah 1untuk kebenaran, kosong untuk kepalsuan. Cobalah online!

Penjelasan cepat

Ubah setiap angka nmenjadi bilangan bulat biner 1 diikuti oleh n+1nol, yaitu 2^(n+1). Bitwise ATAU hasilnya dan periksa 1111(dalam biner). Eksponensial perlu diimplementasikan secara manual di Labirin.

Penjelasan detail

Primer yang biasa:

• Labyrinth adalah bahasa pemrograman 2D berbasis stack. Untuk memori ada tumpukan utama dan tumpukan pembantu, dan muncul dari tumpukan kosong menghasilkan 0 daripada kesalahan.
• Di setiap persimpangan, tempat penunjuk instruksi dapat bergerak ke bawah dua atau lebih jalur yang mungkin, bagian atas tumpukan diperiksa untuk memutuskan ke mana harus pergi berikutnya. Negatif dibiarkan, nol di depan, positif di kanan.
• Digit di Labyrinth tidak mendorong digit yang sesuai ke stack - melainkan, mereka meletus ndan mendorong n*10 + <digit>. Untuk memulai nomor baru, _tekan nol.

Mendirikan

Eksekusi dimulai di kiri atas, dengan penunjuk instruksi menghadap ke kanan. Kami melaksanakan:

=        Swap tops of main and auxiliary stacks
|        Bitwise OR

Selain mendorong angka nol secara efektif, petunjuk ini tidak mengubah tumpukan.

Loop kiri: eksponensial dan bitwise ATAU

Labyrinth tidak memiliki eksponensial, jadi kita perlu mengimplementasikannya secara manual. Pertama kita membaca bilangan bulat dengan ?, dan karena ini dijamin positif kita berbelok ke kanan. _1mendorong 1 dan kami memasuki lingkaran dalam.

Loop dalam melakukan hal berikut:

(       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

Karena ini adalah do-while, untuk input nini menghitung 2^(n+1). Kita akhiri dengan input nol pada stack, dan 30mengubah nol ini menjadi 30. Kita kemudian melakukan instruksi yang sama dari setup, tetapi kali ini mereka sebenarnya berguna.

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

Loop ini berlanjut untuk setiap angka dalam input sampai EOF, ketika ?mengembalikan 0. Ini membuat kita bergerak maju daripada berputar, mengarah ke ...

Bridge: beberapa pengaturan tambahan

The 30setelah ?bergantian 0 dari EOF ke 30, yang didorong ke stack tambahan melalui }. Yang paling penting adalah fakta bahwa kami mendorong 30 ke tumpukan tambahan untuk setiap nomor input, jadi sekarang tumpukan tambahan berisi 5 + 1 = 6salinan dari nomor 30 .

Sementara itu, tumpukan utama berisi ATAU bitwise 2^(n+1)untuk setiap input n. Mari kita sebut bitwise ini ATAU b, karena akan dimodifikasi di loop kanan.

Lingkaran kanan: periksa hasil dan keluaran

Inilah yang terjadi di loop sisi kanan:

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

Sekarang, penghentian sedikit rumit dengan program ini. Berikut adalah beberapa cara yang mungkin dilakukan oleh program:

• Setelah 3 iterasi dari loop kanan, dan bmasih positif: Ingat bagaimana kita menempatkan enam 30-an ke stack tambahan? Karena kami menggunakan dua dari mereka setiap iterasi, pada iterasi keempat kami mulai menarik nol dari bagian bawah tumpukan tambahan. Ini menyebabkan pembagian dengan nol ketika kita lakukan {/, dan program berakhir.

• Setelah menghasilkan 1 untuk straight kecil : Jadi kita telah mengeksekusi !kemudian berbelok ke kanan di "persimpangan no-op . Lalu, kami akan bermain rollercoaster saat kami mulai merangkak di seluruh bagian kiri lagi:

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.

Setelah beberapa perjalanan di eksponentiator, tumpukan terlihat seperti [12 | 30 30], yang kesalahan keluar dengan pembagian dengan nol setelah dua iterasi lain di loop kanan.

• Setelah b menjadi nol di beberapa titik : Kuncinya di sini adalah bahwa :di loop kanan ada di persimpangan. Jika inputnya adalah, katakanlah, 1 1 1 1 1maka bakan menjadi 4, lalu 2, kemudian 1, kemudian 0setelah iterasi ketiga. Alih-alih berbalik pada :, IP sekarang bergerak lurus ke depan, dan sesuatu seperti kasus sebelumnya terjadi menyebabkan penghentian akhirnya.

Semua dalam semua itu berantakan bagaimana program berakhir, tapi hei apa pun untuk menyimpan beberapa byte itu!

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

Contoh penggunaan: f [1,2,3,3,4]-> True.

Mirip dengan jawaban xnor , yaitu memeriksa apakah ada jalan lurus kecil dalam daftar input. Sebenarnya saya sedang menguji semua "small straights" (yaitu 4 angka berurutan) yang dimulai dengan angka apa saja dari daftar input, beberapa di antaranya tidak valid dan karena itu selalu gagal dalam alltes dan tidak mengubah anytes, mis [5,6,7,8].

Sunting: @Zgarb menyimpan 5 byte. Terima kasih!

MATL, 11 byte

udY'w1=)2>a

Cobalah online

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

kembali trueuntuk yang benar dan yang salah false.

Bagaimana itu bekerja

Kembali jika beberapa nilai dalam [0, 1, 2, 3] memenuhi syarat bahwa untuk setiap nilai dalam [0, 1, 2, 3] jumlah kedua nilai ini ada di dalam array input.

Jadi, kembali jika array memiliki setiap nilai dalam [0, 1, 2, 3] (tidak mungkin), [1, 2, 3, 4], [2, 3, 4, 5], atau [3, 4, 5 , 6].

Ruby, 31

Alih-alih mencoba menjadi pintar seperti jawaban Ruby pertama , ini hanya melewati array bilangan bulat, dan untuk setiap bilangan bulat, melihat apakah ada sedikit lurus pada input yang dimulai dengan bilangan bulat itu. Tidak khawatir tentang kemungkinan nilai atau keunikan.

Ini tampaknya menggunakan algoritma yang sama dengan jawaban Sherlock .

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

Ruby, 58 55 50 47 43 33 byte

Saya baru saja melihat bahwa saya telah dipukuli oleh pukulan oleh jawaban Ruby Paul . Namun saya tidak tergoyahkan karena saya pikir ini masih bisa menjadi jawaban yang layak dengan bermain golf lagi. Didasarkan, sebagian, pada jawaban Python xnor .

Sunting: Beberapa bermain golf dan memperbaiki kesalahan dalam kondisi ternary.

Sunting: Saya sekarang menggunakan .any?seperti Bukan yang Charles lakukan dalam jawaban Ruby mereka, tetapi hanya karena saya membutuhkan cara sederhana untuk menghapus adan mengembalikan hanya kebenaran dan kesalahan dengan !([*i..i+3]-l)[0]karena .mapakan mengembalikan array truedan false.

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

Mengembalikan salah satu trueatau false.

Tidak Disatukan:

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

Catatan penting: Bagi mereka yang ingin menggunakan (a2 - a1).empty?kode untuk menentukan apakah semua elemen a2dalam a1, perhatikan bahwa jika Anda ingin memastikan bahwa, misalnya, [2,1,2]ada dalam [1,2,3,3]multiplisitas elemen, Anda memerlukan kode lain. Diskusi yang relevan tentang masalah ini di sini .

Japt, 13 12 byte

Uá4 d@7o ¬fX

Uji secara online! atau Verifikasi semua kasus uji .

Bagaimana itu bekerja

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

Termasuk +1 untuk -p

Jalankan dengan urutan pada STDIN, mis

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

smallstraight.pl:

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

Penjelasan

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>

Menghasilkan string yang tidak kosong untuk kasus uji yang benar dan string kosong untuk yang palsu.

Suite uji.

Penjelasan

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.

Pada akhir program, daftar ini diratakan menjadi string tunggal dan dicetak ke STDOUT. Jika ada jalan kecil yang ditemukan, elemen yang tersisa akan berada di string. Kalau tidak, semua daftar itu kosong, dan string juga kosong.

05AB1E , 9 8 10 byte

Truthy berisi array dalam output, falsy adalah ketika tidak ada output yang dihasilkan. Kode:

œvy¦¥1QPiy

Penjelasan kedaluwarsa :

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

Cobalah online!

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

terima kasih kepada produk ETH untuk membantu menghemat beberapa 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)

Pengujian

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

atau: (jumlah byte yang sama)

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

Tidak Disatukan:

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
}

Sunting Besar: Baru sadar saya hanya perlu memposting fungsi, bukan keseluruhan program. Itu menghemat banyak. Tidak ada boilerplate, tidak perlu mengubah input string menjadi angka, dll. Sekarang kita benar-benar mendekati jumlah byte yang terhormat (bagaimanapun juga untuk bahasa non-golf).

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

Coba Kelima (40 byte):

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

Menggunakan sintaks lambda untuk mendefinisikan fungsi. (Terima kasih untuk bersaing pegolf Ruby @ Sherlock9 untuk ide ini.)

Untuk menguji menggunakan panggilan lambda:

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

Coba Keempat:

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

Diganti nihil? dan negasi dengan operator ===.

Coba ketiga:

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

Menggunakan ekspresi reguler.

Coba Kedua:

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

Pendekatan baru menggunakan dedup (uniq), sortir dan gabung, plus sertakan? untuk mencari kecocokan dari setiap solusi di input yang diberikan sebagai string.

Coba Pertama: 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

Penguji:

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

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

Menggunakan deduping (fungsi uniq) ditambah set persimpangan (& operator) untuk menguji apakah ada urutan yang cocok dengan urutan yang diberikan. Tidak diperlukan penyortiran.

Pyth, 13 11

@.PQ4.:S6 4

2 byte berkat Jakube!

Mengembalikan daftar yang tidak kosong untuk yang benar, daftar kosong untuk yang salah.

Cobalah secara online atau jalankan Test Suite (dibagi dengan kesalahan sintaks untuk 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

Serius, 21 byte

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

Cobalah online!

Menghasilkan nilai positif untuk true, dan 0 untuk false.

Penjelasan:

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

Ini mungkin bisa diagendakan lebih jauh, tetapi sebagai permulaan:

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

Saya tidak melihat cara mengurangi duplikasi tanpa menggunakan lebih banyak ruang; versi ini adalah 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])

Retina , 70 54 byte

Input adalah string tunggal dari bilangan bulat seperti 13342. Output adalah 1jika ditemukan, atau 0jika tidak.

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

Perhatikan bahwa penghapusan duplikat hanya perlu terjadi sekali, karena hanya ada lima angka. Perlu menghapus lebih dari satu angka berarti tidak ada lurus kecil pula.

Cobalah online

Terima kasih kepada Martin untuk ide untuk memindahkan koma di dalam kelompok tangkap, menghemat 16 byte kekalahan.

Pyth, 11 byte

f!-TQ.:S6 4

Suite uji

Hasilkan substring panjang 4 dari [1..6], lalu filter pada tidak ada elemen yang tersisa ketika elemen input dihapus.

Jelly, 9 byte

Harus ada solusi 8-byte, akan terus mencari ... Kode:

Œ!Ḋ€Iµ7Be

Ini sama dengan solusi 05AB1E saya .

Penjelasan:

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

Cobalah online!

Jelly, 8 byte

6Rṡ4ḟ€ċ“

Cobalah online! atau memverifikasi kasus uji kebenaran dan kasus uji palsu .

Bagaimana itu bekerja

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)

Penguji:

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

Ini mengambil angka 62 (111110 dalam biner) Untuk setiap angka dalam larik input, ia menghilangkan bit itu

Jumlah yang dihasilkan harus

100000 or
000000 or
000010 or
000110 or
000100

jadi saya memeriksa apakah hasilnya kurang dari 7 (0000111) atau apakah itu sama dengan 32 (100000)

TI-BASIC, 25 byte

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

Ekspresi Python ekuivalen (ungolfed) yang dapat Anda uji :

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

Gagasan di balik ini adalah sifat bisa dibagi. Untuk memeriksa apakah a 1, 2, 3, 4,, 2, 3, 4, 5atau 3, 4, 5, 6terjadi, kita dapat memetakan angka 1-6 hingga 37-42, lalu mengalikan angka yang benar menjadi satu.

Masing-masing angka dalam [37,42] memiliki faktor utama yang tidak dimiliki oleh angka lainnya.

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

Oleh karena itu, jika produk dari lima angka dapat dibagi oleh 37, daftar asli berisi 1. Jika pada 19, itu berisi 2; dll Jika habis dibagi 37*19*13*5= 65*703, berisi 1, 2, 3, dan 4demikian pula dengan dua nomor lainnya.

Solusi ini merupakan peningkatan pada salah satu yang diposting @Weregoose pada tahun 2009.

Mumps, 113 78 Bytes

Versi Mumps yang saya gunakan adalah InterSystems Cache.

Saya tidak bisa memikirkan cara bermain golf teknik ini lebih pendek; dengan teknik berbeda mungkin saja dilakukan, tetapi untuk saat ini ini akan dilakukan dan setidaknya lebih pendek dari C ++ ... tetapi tidak banyak. Bagaimanapun...

Oke, ini cara yang lebih singkat. Alih-alih memiliki 3 variabel terpisah untuk jangka pendek, gunakan variabel tunggal untuk semua 6 'dadu' dan ekstrak bagian nanti:

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)

sangat banyak bagi saya tidak menemukan cara yang lebih baik dengan teknik yang sama ... saya harus melihat sebelum saya melompat, eh? ;-)

Saya akan meninggalkan jawaban asli saya di bawah ini untuk tujuan historis ...

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

dan inilah penjelasan tentang apa yang terjadi dengan kode:

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.

Saya tidak menguji setiap input benar & salah karena itu melibatkan mengetik semuanya secara manual; tetapi saya melakukan pengujian kira-kira setengah bagian pertama dari masing-masing, memverifikasi jalan lurus yang panjang masih menunjukkan kebenaran dan beberapa jalan tercatat tidak selalu bekerja dengan benar ([4,2,5,3,4], [1,2,3,3 , 4] dll.) Dan tampaknya berfungsi dengan benar.

Dyalog APL , 15 byte

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

menggunakan ⎕IO=0

⍳4 aku s 0 1 2 3

⍵∘.+⍳4 adalah 5 × 4 sebuah matriks dari setiap die yang ditambahkan oleh masing-masing ⍳4

⍵∊⍨ memeriksa apakah elemen-elemen dari matriks ada di tangan, hasilnya adalah matriks boolean (0-atau-1), kita perlu menemukan deretan semua 1s

∧/ adalah dan-reduksi dengan baris, hasilnya adalah vektor boolean

∨/ adalah atau-reduksi dari vektor itu

Jelly, 11

QṢṡ4ðfø6Rṡ4

Cobalah online!

Ini cukup banyak salinan jawaban Pyth saya, hanya mencoba mencari cara untuk rantai barang. Rasanya seperti itu harus golf.

Ekspansi:

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]

Jika Anda ingin mengajukan pertanyaan sulit, seperti mengapa pemisah berbeda, maka jawaban saya kepada Anda adalah: "Saya akan menjawab dalam 6-8 minggu": P (Lebih serius, saya pikir itu adalah pencocokan pola, monad-diad vs nilad-dyad, tapi saya tidak tahu dan tidak ingin menyebarkan informasi yang salah.)