Oyunda Yahtzee , oyuncular altı yüzlü beş zar atıyor ve puan kazanmak için belirli eller yaratmaya çalışıyorlar. Böyle bir el küçük bir düzdür : zorunlu olarak sırayla değil dört ardışık sayı. Üç olası küçük düzlük vardır 1, 2, 3, 4, 2, 3, 4, 5ve 3, 4, 5, 6.

Örneğin [3, 5, 6, 1, 4], küçük düz içerir [3, 4, 5, 6].

Giriş

Yahtzee'nin elini temsil eden, her biri 1 ila 6 arasında olmak üzere beş tam sayıdan oluşan sıralanmamış bir liste.

Çıktı

Eğer el küçük bir düz, aksi takdirde sahte bir değer içeriyorsa, bir gerçeğe uygun değer.

Test durumları

Truthy:

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

_{Bu ilham}

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 bayt

@Lirtosiast'a 2 baytı kaldırdığınız için çok teşekkür ederiz

ud7BXf

Gerçek, sıfır olmayan değerlerin bir dizisidir. Falsy, boş bir dizidir (görüntülenen çıktı yok).

16.2.0 sürümü itibariyle, uvarsayılan olarak kararlıdır. Yani kod bir ekstra ihtiyacı S: çıkışını sıralamak için uSd7BXf( 7 bayt ). Bağlantı bu değişikliği içerir.

Çevrimiçi deneyin!

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 bayt

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

Bir iyileşme ile 9 ay sonra geri döndü. iSette olup olmadığını Zgarb'ın yalnızca setteki başlangıç ​​değerlerini kontrol etme fikrine sahip olup olmadığını kontrol etmemize gerek yoktur . Artık <katı altkümeler için de kullanabiliriz , çünkü idahil edilmelidir.

47 bayt:

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

Herhangi bir kalıp rulosunun küçük bir düz setin başlangıcı olup olmadığını kontrol eder. Listedeki sadece başlangıç ​​değerlerini kontrol etme fikri için Zgarb'a teşekkürler.

Python 3.5, 45 bayt için daha kısa küme dönüşümüne sahiptir

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

Bunu yapmak aynı boyda {*range(i,i+4)}olarak {i,i+1,i+2,i+3}.

Labirent, 41 bayt

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

@ MartinBüttner ile bir collab cevabı. Sanırım bunu, beklentilerimin çok ötesinde sıktık.

Çıktı 1gerçeğe uygun, sahte için boş. Çevrimiçi deneyin!

Hızlı açıklama

Her sayıyı nbir ikili tamsayıya 1 dönüştürün n+1, ardından sıfırlar, örn 2^(n+1). Bitsel olarak VEYA sonuçları ve kontrol edin 1111(ikili olarak). Üsluplama labirentte manuel olarak uygulanmalıdır.

Detaylı açıklama

Her zamanki astar:

• Labirent, yığın tabanlı bir 2B programlama dilidir. Bellek için bir ana yığın ve bir yardımcı yığın vardır ve boş bir yığından atmak bir hata yerine 0 üretir.
• Talimat göstergesinin iki veya daha fazla yolu aşağıya taşıyabildiği her kavşakta, yığının tepesi, nereye gidileceğine karar vermek için kontrol edilir. Negatif sol, sıfır ileri, pozitif doğru.
• Labirent'teki rakamlar karşılık gelen rakamı yığına itmez - yerine açılır nve bastırırlar n*10 + <digit>. Yeni bir numara başlatmak için _sıfıra basar.

Kurmak

Yürütme işlemi sol üstte başlar, talimat işaretçisi sağa bakar. Çalıştırıyoruz:

=        Swap tops of main and auxiliary stacks
|        Bitwise OR

Sıfırları etkili bir şekilde itmenin yanı sıra, bu talimatlar yığını değiştirmez.

Sol döngü: üstel ve bit yönünde VEYA

Labirentin üstelleşmesi yoktur, bu yüzden manuel olarak uygulamamız gerekiyor. Öncelikle ile bir tamsayı okuduk ?ve bunun olumlu olması garanti edildiğinden sağa dönüyoruz. _11 iter ve biz iç döngüye gireriz.

İç döngü aşağıdakileri yapar:

(       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

Bu bir do-while döngüsü olduğundan, giriş için nbunu hesaplar 2^(n+1). Yığındaki sıfırlanmış girdiyle sona ereriz ve 30bu sıfırı 30'a çeviririz. Daha sonra kurulumdan aynı talimatları uygularız, ancak bu sefer gerçekten işe yararlar.

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

Bu döngü girişteki her sayı için EOF'a kadar ?0 döndürdüğünde devam eder. Bu bizi döndürmek yerine ileriye doğru hareket ettirir ...

Köprü: bazı ekstra kurulum

30Sonra ?üzerinden yardımcı yığınına itilir dönüşler 30 içine EOF 0, }. Önemli olan, her giriş numarası için 30'a yardımcı yığına ittiğimiz gerçeğidir, bu nedenle şimdi yardımcı yığın 5 + 1 = 630 numarasının kopyalarını içerir .

Bu arada, ana yığın, 2^(n+1)her giriş için bit yönünde OR içerir n. Bu bit biti OR diyelim b, çünkü doğru döngüde değiştirildi.

Sağ döngü: sonucu ve çıktıyı kontrol edin

İşte sağ taraftaki döngüde olanlar:

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

Şimdi, fesih bu program ile biraz zor. Programın sonlandırmasının olası yolları:

• Doğru döngünün 3 tekrarından sonra ve bhala pozitif: Yardımcı ekime altı 30'umu nasıl koyduğumuzu hatırlıyor musunuz? Bunlardan her birini yinelemeden iki tane kullandığımız için, dördüncü yinelemede yardımcı yığının tabanından sıfırlar almaya başlarız. Bu yaptığımızda sıfıra bölünmeye neden olur {/ve program sonlandırılır.

• Küçük bir düz için 1 çıktıktan sonra : Bu yüzden ilerledik !ve no-op "kavşağından sağa döndük . Sonra tekrar sol yarıda sürünmeye başladığımızdan beri bir rollercoaster içerisindeyiz:

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.

Üst üste birkaç geziden sonra, yığın [12 | 30 30]doğru bir döngüde iki yinelemenin ardından sıfıra bölünen hatalar gibi görünür .

• B bir noktada sıfırdan sonra : Buradaki anahtar :, sağdaki döngünün bir kavşakta olmasıdır. Giriş olsaydı, diyelim ki, 1 1 1 1 1daha sonra bolurdu 4, o zaman 2, o zaman 1, o zaman 0üçüncü yineleme sonra. :IP'yi açmak yerine , IP şimdi dümdüz ilerliyor ve önceki dava gibi bir şey nihai bir sonlandırmaya neden oluyor.

Sonuç olarak, programın nasıl sonlandırıldığı bir karışıklıktır, ancak hey bu birkaç byte'ı kurtarmak için bir şey!

Mathematica, 39 43 44 31 39 44 bayt

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

Haskell, 39 34 bayt

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

Kullanım örneği: f [1,2,3,3,4]-> True.

@ Xnor'ın cevabına benzer şekilde , yani küçük boşluklardan herhangi birinin giriş listesinde olup olmadığını kontrol edin. Aslında, giriş listesindeki sayılardan herhangi biriyle başlayarak tüm "küçük ağırlıkları" (yani 4 ardışık sayı) test ediyorum, bazıları geçersiz ve bu nedenle alltesti her zaman başarısız kılıyor ve anytesti bozmuyor , ör [5,6,7,8].

Düzenleme: @ Zgarb 5 bayt kaydetti. Teşekkürler!

MATL, 11 bayt

udY'w1=)2>a

Çevrimiçi deneyin

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 bayt

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

döner truetruthy için ve falsefalsy için.

Nasıl çalışır

[0, 1, 2, 3] içindeki bir değerin, [0, 1, 2, 3] 'deki her değer için bu iki değerin toplamının giriş dizisinde olması koşulunu yerine getirmesi durumunda döner.

Öyleyse, dizinin [0, 1, 2, 3] (imkansız), [1, 2, 3, 4], [2, 3, 4, 5] veya [3, 4, 5'te her değeri varsa döndürün. , 6].

Ruby, 31

İlk Ruby cevabı gibi akıllı olmaya çalışmak yerine , bu tamsayı dizisinden geçer ve her bir tamsayı için, tamsayı ile başlayan girdilerde küçük bir düz olup olmadığını görür. Olası değerler veya benzersizlik hakkında endişelenmez.

Bu Sherlock'un cevabıyla aynı algoritmayı kullanıyor gibi görünüyor .

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

Ruby, 58 55 50 47 43 33 bayt

Az önce Paul’un Ruby cevabıyla yumruk attığımı gördüm . Ancak hala biraz daha golf oynamak için iyi bir cevap olabileceğini düşündüğüm için caydırılmıyorum. Kısmen, xnor'ın Python cevabı üzerine kurulu .

Düzenleme: Bazıları golf oynamak ve üçüncül şartlı bir karışımı telafi etmek.

Düzenleme: Ben artık kullanıma .any?gibi değil Charles onların Yakut cevap yapar ama basit bir yol gerekli çünkü kaldırmak ave sadece truthy ve bir Falsey dönmek !([*i..i+3]-l)[0]beri .mapbir dizi döneceğini trueve false.

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

trueVeya birini döndürür false.

Ungolfed:

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

Önemli not: kullanmak isteyenler için (a2 - a1).empty?tüm unsurları belirlemek için kodu a2vardır a1örneğin, emin olmak istiyorsanız o notta, [2,1,2]olduğu [1,2,3,3]elemanların çokluğu ile, diğer kodu gerekir. Burada bu sorunun ilgili tartışması .

Japt, 13 12 bayt

Uá4 d@7o ¬fX

Çevrimiçi test edin! veya Tüm test durumlarını doğrulayın .

Nasıl çalışır

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

İçin +1 içerir -p

STDIN'deki diziyle koş, örn.

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

smallstraight.pl:

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

açıklama

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 bayt

7,4ewl~f&3f>

Gerçeği test durumları için boş olmayan bir dize ve sahte olanlar için boş bir dize verir.

Test odası.

açıklama

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.

Program sonunda, bu liste tek bir dizgeye basılır ve STDOUT'a basılır. Küçük boylardan herhangi biri bulunursa, kalan elementleri telde olacaktır. Aksi halde tüm listeler boştu ve dolayısıyla dize de boştu.

05AB1E , 9 8 10 bayt

Truthy çıktıda bir dizi içeriyor , sahte çıktı üretilmediğinde olur. Kod:

œvy¦¥1QPiy

Açıklama modası geçmiş :

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

Çevrimiçi deneyin!

CP-1252 kodlamasını kullanır .

Javascript ES6 47 bayt

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

Javascript ES6 52 bayt

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 bayt

Birkaç byte'tan tasarruf edilmesine yardımcı olan ETHproductions sayesinde

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)

Test yapmak

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

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

veya: (aynı bayt sayısı)

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

Ungolfed:

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
}

Büyük Düzenleme: Yeni bir program yazmam gerekecek, sadece bir işlev göndermem gerekebileceğini fark ettim. Bu çok tasarruf sağlar. Kazan plakası yok, string girişini sayılara vb. Dönüştürmeye gerek yok. Şimdi aslında saygın bir bayt sayısına yaklaşıyoruz (zaten golf oynamayan bir dil için).

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

Beşinci Deneme (40 bayt):

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

Fonksiyonu tanımlamak için lambda sözdizimini kullanır. (Bu fikir için yarışan Ruby golfçü @ Sherlock9'a teşekkürler.)

Lambda çağrısını kullanarak test etmek için:

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

Dördüncü deneyin:

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

Sıfır nil değiştirildi? ve === operatörü ile olumsuzlama.

Üçüncü deneyin:

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

Düzenli ifade kullanır.

İkinci deneme:

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

Yeni yaklaşım, dedup (uniq), sırala ve katıl, artı dahil et seçeneklerini kullanır. Bir dizge olarak verilen girdideki herhangi bir çözümün eşleşmesini aramak için.

İlk Deneme: 79 bayt

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

Tester:

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

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

Herhangi bir iyi diziden herhangi birinin verilen dizilim ile uyuşup uyuşmadığını test etmek için, tekilleştirme (uniq işlevi) artı ayar kesişimini (& operatör) kullanır. Sıralama gerekli değil.

Pyth, 13 11

@.PQ4.:S6 4

Jakube sayesinde 2 bayt!

Hakikat için boş olmayan bir liste, sahtekarlık için boş bir liste döndürür.

Çevrimiçi deneyin veya Test Suite'i çalıştırın (Readability ™ için bir sözdizimi hatasıyla bölün).

PHP, 95 bayt

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

Cidden, 21 bayt

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

Çevrimiçi deneyin!

True için pozitif, false için 0 değerini verir.

Açıklama:

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 bayt

Bu muhtemelen daha fazla golf oynayabilir, ancak başlangıç ​​olarak:

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

Daha fazla alan kullanmadan çoğaltmayı azaltmanın bir yolunu görmüyorum; bu sürüm 75 bayttır:

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 bayt

Giriş, gibi tam sayıların tek bir dizesidir 13342. Çıktı bir 1bulunursa veya 0değilse.

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

Yinelenenlerin kaldırılmasının sadece bir sayı olması gerektiğine dikkat edin, çünkü yalnızca beş sayı vardır. Birden fazla numara çıkarmanız gerektiğinde küçük bir yol olmadığı anlamına gelir.

Çevrimiçi deneyin

Martin'e virgülleri yakalama gruplarının içinde hareket ettirme fikriyle, bir boğucu 16 bayt tasarrufu sağladı.

Pyth, 11 bayt

f!-TQ.:S6 4

Test odası

[1..6] 'nın 4 alt uzunluğunu oluşturun, daha sonra girişin elemanları kaldırıldığında kalanlar üzerinde süzmeyin.

Jöle, 9 bayt

8 baytlık bir çözüm olmalı, aramaya devam edecek ... Kod:

Œ!Ḋ€Iµ7Be

Bu benim 05AB1E çözümüm ile aynı .

Açıklama:

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

Çevrimiçi deneyin!

Jöle, 8 bayt

6Rṡ4ḟ€ċ“

Çevrimiçi deneyin! veya doğrulamak truthy test durumları ve falsy test durumları .

Nasıl çalışır

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 bayt

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

Tester:

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 bayt

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

Bu 62 sayısını alır (ikili olarak 111110). Giriş dizisindeki her sayı için bu biti kaldırır.

Ortaya çıkan numara ya

100000 or
000000 or
000010 or
000110 or
000100

bu yüzden sonucun 7'den (0000111) düşük olup olmadığını veya 32'ye (100000) eşit olup olmadığını kontrol ediyorum.

TI-BASIC, 25 bayt

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

Test edebileceğiniz eşdeğer (asılsız) bir Python ifadesi :

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

Bunun arkasındaki fikir bölünebilirlik. Bir kontrol etmek 1, 2, 3, 4, 2, 3, 4, 5ya da3, 4, 5, 6 meydana, birlikte çarpın sonra doğru sayıları 37-42 numaralar 1-6 map ve edebilirsiniz.

[37,42] 'deki sayıların her biri, diğer sayıların bulunmadığı bir ana faktöre sahiptir.

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

Bu nedenle, beş sayının çarpımı 37 ile bölünebilirse, orijinal liste 1 içerir. 19 ise, 2; vs o bölünebilir ise 37*19*13*5= 65*703, içerdiği 1, 2, 3ve 4ve benzer diğer iki numaraları için.

Bu çözüm üzerinde bir gelişme biri olduğunu @Weregoose 2009 yılında yayınlanmıştır.

Kabakulak, 113 78 Bayt

Kullandığım Kabakulak sürümü InterSystems Cache.

Daha kısa sürede bu tekniğe golf atmanın bir yolunu düşünemiyorum; farklı bir teknikle mümkün olabilir, ama şimdilik bu işe yarayacak ve en azından C ++ 'dan daha kısa. Neyse ...

Tamam, işte daha kısa bir yol. Kısa çalıştırmalar için 3 ayrı değişken kullanmak yerine, 6 'zarın tamamı için tek bir değişken kullanın ve kısımları daha sonra çıkarın:

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)

benim için aynı teknikle daha iyi bir yol bulamıyorum ... Atlamadan önce bakmalıyım, ha? ;-)

Asıl cevabımı tarihsel amaçlar için aşağıya bırakacağım ...

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

ve işte kodda neler olup bittiğinin açıklaması:

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.

Her bir truthy & falsy girdisini, hepsini elle yazmayı içeren şekilde test etmedim ; ancak her birinin yaklaşık ilk yarısını test ettim, uzun boyluların hala hakikaten gösterdiğini doğruladım ve koşuların birçoğunun mutlaka doğru şekilde çalışmadığını belirtti ([4,2,5,3,4], [1,2,3,3]. , 4] vb.) Ve doğru çalışıyor gibi görünüyor.

Dyalog APL , 15 bayt

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

kullanımları ⎕IO=0

⍳4 olduğu 0 1 2 3

⍵∘.+⍳4 5 x 4'dür, her biri tarafından artan her bir kalıbın matrisidir ⍳4

⍵∊⍨ matris öğelerinin el altında olup olmadığını kontrol eder, sonuç bir boole (0 veya 1) matris olup olmadığını kontrol eder, hepsinde bir satır bulmamız gerekir.

∧/ ve satırların azaltılması, sonuç bir boolean vektörüdür

∨/ bu vektörün azaltılması

Jöle, 11

QṢṡ4ðfø6Rṡ4

Çevrimiçi deneyin!

Bu Pyth cevabımın bir kopyası, sadece nasıl zincir yapılacağını bulmaya çalışıyorum. Golf edilebilir olmalı gibi geliyor.

Genişleme:

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]

Ayırıcıların neden farklı olduğu gibi zor sorular sormak istiyorsan, sana cevabım şu: "6-8 hafta sonra cevap vereceğim": P (Daha da ciddiyim, bence bu eşleştirme, monad-dyad vs nilad-dyad, ama bilmiyorum ve yanlış bilgi yaymak istemiyorum.)