W grze Yahtzee gracze rzucają pięcioma sześciokątnymi kostkami i próbują stworzyć określone ręce, aby zdobyć punkty. Jedna taka ręka to mała prosta : cztery kolejne liczby, niekoniecznie w kolejności. Trzy możliwe są niewielkie prostych 1, 2, 3, 4, 2, 3, 4, 5oraz 3, 4, 5, 6.

Na przykład [3, 5, 6, 1, 4]zawiera małą prostą [3, 4, 5, 6].

Wkład

Nieposortowana lista pięciu liczb całkowitych, każda od 1 do 6 włącznie, reprezentujących rękę Yahtzee.

Wydajność

Prawdziwa wartość, jeśli ręka zawiera małą strit, a w przeciwnym razie wartość falsy.

Przypadki testowe

Prawda:

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

_{Zainspirowany tym}

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 bajtów

Bardzo dziękuję @lirtosiast za usunięcie 2 bajtów

ud7BXf

Truthy to tablica niezerowych wartości. Falsy jest pustą tablicą (brak wyświetlania danych wyjściowych).

Od wersji 16.2.0 ujest domyślnie stabilny. Zatem kod wymaga dodatkowego Ssortowania danych wyjściowych: uSd7BXf( 7 bajtów ). Link zawiera tę modyfikację.

Wypróbuj 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 bajty

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

Powrót po 9 miesiącach z poprawą. Nie musimy sprawdzać, czy ijest w zestawie, z pomysłem Zgarba, by sprawdzać tylko wartości początkowe w zestawie. Możemy teraz używać również w <przypadku ścisłych podzbiorów, ponieważ inależy je również uwzględnić.

47 bajtów:

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

Sprawdza, czy rzuty kostką są początkiem małego prostego zestawu. Dzięki Zgarbowi za pomysł sprawdzania tylko wartości początkowych na liście, oszczędzając 5 bajtów.

Python 3.5 ma krótszą konwersję zestawu, dla 45 bajtów

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

To ta sama długość zrobić {*range(i,i+4)}jak {i,i+1,i+2,i+3}.

Labirynt, 41 bajtów

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

Odpowiedź collab z @ MartinBüttner. Myślę, że wycisnęliśmy ten daleko poza moje początkowe oczekiwania.

Wyjście jest 1zgodne z prawdą, puste dla fałszu. Wypróbuj online!

Szybkie wyjaśnienie

Konwertuj każdą liczbę nna binarną liczbę całkowitą 1, po której następuje n+1zero, tj 2^(n+1). Bitowo LUB wyniki i sprawdź 1111(w formacie binarnym). Potęgowanie należy zaimplementować ręcznie w Labiryncie.

Szczegółowe wyjaśnienie

Zwykły podkład:

• Labirynt to oparty na stosie język programowania 2D. Dla pamięci jest stos główny i stos pomocniczy, a wyskakiwanie z pustego stosu powoduje 0, a nie błąd.
• Na każdym skrzyżowaniu, gdzie wskaźnik instrukcji może przesuwać się w dół o dwie lub więcej możliwych ścieżek, sprawdzana jest góra stosu, aby zdecydować, gdzie iść dalej. Ujemne jest lewe, zero jest do przodu, pozytywne jest prawe.
• Cyfry w Labiryncie nie wypychają odpowiedniej cyfry na stos - raczej pop ni pop n*10 + <digit>. Aby rozpocząć nowy numer, _przesuwa zero.

Ustawiać

Wykonanie rozpoczyna się w lewym górnym rogu, ze wskaźnikiem instrukcji skierowanym w prawo. Wykonujemy:

=        Swap tops of main and auxiliary stacks
|        Bitwise OR

Oprócz skutecznego wypychania zer, instrukcje te nie zmieniają stosu.

Lewa pętla: wykładnicza i bitowa LUB

Labirynt nie ma potęgowania, więc musimy go wdrożyć ręcznie. Najpierw czytamy liczbę całkowitą ?, a ponieważ jest to z pewnością pozytywne, skręcamy w prawo. _1naciska 1 i wchodzimy w wewnętrzną pętlę.

Pętla wewnętrzna wykonuje następujące czynności:

(       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

Ponieważ jest to pętla „do-while”, dane wejściowe są nobliczane 2^(n+1). Kończymy 30zerowaniem danych wejściowych na stosie i zamieniamy to zero na 30. Następnie wykonujemy te same instrukcje z konfiguracji, ale tym razem są one faktycznie przydatne.

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

Ta pętla jest kontynuowana dla każdej liczby na wejściu, aż EOF, gdy ?zwróci 0. To powoduje, że poruszamy się do przodu zamiast skręcać, prowadząc do ...

Bridge: dodatkowa konfiguracja

30Po ?przekręca EOF od 0 do 30, które jest dociśnięte do stosu za pomocą pomocniczego }. Ważne jest to, że wepchnęliśmy 30 do stosu pomocniczego dla każdej liczby wejściowej, więc teraz stos pomocniczy zawiera 5 + 1 = 6kopie liczby 30 .

Tymczasem główny stos zawiera bitowe OR 2^(n+1)dla każdego wejścia n. Nazwijmy to bitową LUB b, ponieważ jest modyfikowane w odpowiedniej pętli.

Prawa pętla: sprawdź wynik i wynik

Oto, co dzieje się w pętli po prawej stronie:

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

W przypadku tego programu zakończenie pracy jest trochę trudne. Oto możliwe sposoby zakończenia programu:

• Po 3 iteracjach prawej pętli, i bwciąż jest pozytywna: Pamiętasz, jak umieściliśmy sześć 30 w stosie pomocniczym? Ponieważ używamy dwóch z nich w każdej iteracji, przy czwartej iteracji zaczynamy ciągnąć zera od spodu stosu pomocniczego. Powoduje to dzielenie przez zero, gdy to robimy {/, a program się kończy.

• Po wyprowadzeniu 1 dla małego strita : Więc wykonaliśmy, !a następnie skręciliśmy w prawo na "skrzyżowaniu no-op . Potem czeka nas kolejka górska, gdy znów zaczołgamy się po lewej stronie:

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.

Po kilku uruchomieniach w wykładniku stos wygląda mniej więcej tak [12 | 30 30], że błędy dzielą się przez dzielenie przez zero po kolejnych dwóch iteracjach w prawej pętli.

• Po tym, jak b staje się zero w pewnym momencie : Kluczem tutaj jest to, że :prawa pętla znajduje się na skrzyżowaniu. Jeśli wejście było, powiedzmy 1 1 1 1 1, to bbyłoby 4, potem 2, potem 1, potem 0po trzeciej iteracji. Zamiast zwracać się do :, IP porusza się teraz prosto i coś takiego jak poprzedni przypadek powoduje ostateczne zakończenie.

W sumie to bałagan, jak program się kończy, ale hej wszystko, aby zaoszczędzić te kilka bajtów!

Mathematica, 39 43 44 31 39 44 bajtów

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

Haskell, 39 34 bajtów

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

Przykład użycia: f [1,2,3,3,4]-> True.

Podobne do odpowiedzi @ xnor , tzn. Sprawdź, czy którakolwiek z małych prostych znajduje się na liście wprowadzania. Właściwie testuję wszystkie „małe proste” (tj. 4 kolejne cyfry), zaczynając od dowolnej liczby z listy danych wejściowych, niektóre z nich są nieprawidłowe i dlatego zawsze kończą się niepowodzeniem alli nie zniekształcają anytestu, np [5,6,7,8].

Edycja: @Zgarb zapisał 5 bajtów. Dzięki!

MATL, 11 bajtów

udY'w1=)2>a

Wypróbuj 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 bajtów

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

zwraca trueza prawdę i falseza fałsz.

Jak to działa

Zwraca, jeśli jakaś wartość w [0, 1, 2, 3] spełnia warunek, że dla każdej wartości w [0, 1, 2, 3] suma tych dwóch wartości znajduje się w tablicy wejściowej.

Zwróć więc, jeśli tablica ma wszystkie wartości w [0, 1, 2, 3] (niemożliwe), [1, 2, 3, 4], [2, 3, 4, 5] lub [3, 4, 5 , 6].

Ruby, 31 lat

Zamiast próbować być mądrym jak pierwsza odpowiedź Ruby , to po prostu przechodzi przez tablicę liczb całkowitych i dla każdej liczby całkowitej sprawdza, czy na wejściu jest mała prosta zaczynająca się od tej liczby całkowitej. Nie martwi się o możliwe wartości lub wyjątkowość.

Wydaje się, że używa tego samego algorytmu, co odpowiedź Sherlocka .

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

Rubinowy, 58 55 50 47 43 33 bajtów

Właśnie teraz zobaczyłem, że zostałem pobity przez odpowiedź Ruby Paula . Nie zniechęcam się jednak, ponieważ myślę, że nadal może to być przyzwoita odpowiedź przy odrobinie golfa. Częściowo w oparciu o odpowiedź Python na xnor .

Edycja: Trochę gry w golfa i korygowanie pomyłki w trójce warunkowej.

Edycja: Używam teraz Nie.any? tak, jak Charles robi w ich odpowiedzi Ruby, ale tylko dlatego, że potrzebowałem prostego sposobu na usunięcie ai zwrócenie tylko prawdy i falsey z, !([*i..i+3]-l)[0]ponieważ zwróciłoby .maptablicę truei false.

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

Zwraca albo truealbo false.

Nie golfowany:

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

Ważna uwaga: dla tych, którzy chcą użyć (a2 - a1).empty?kodu do ustalenia, czy wszystkie elementy a2są w a1środku, zauważ, że jeśli chcesz się upewnić, że, na przykład, [2,1,2]dotyczy [1,2,3,3]wielu elementów, potrzebujesz innego kodu. Odpowiednie omówienie tego problemu tutaj .

Japt, 13 12 bajtów

Uá4 d@7o ¬fX

Przetestuj online! lub Zweryfikuj wszystkie przypadki testowe .

Jak to działa

       // 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 bajtów

Obejmuje +1 dla -p

Uruchom sekwencję na STDIN, np

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

smallstraight.pl:

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

Wyjaśnienie

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 bajtów

7,4ewl~f&3f>

Daje niepusty ciąg dla prawdziwych przypadków testowych i pusty ciąg dla fałszywych przypadków.

Zestaw testowy.

Wyjaśnienie

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.

Pod koniec programu lista ta jest spłaszczana do jednego łańcucha i drukowana do STDOUT. Jeśli znaleziono którąkolwiek z małych prostych, pozostałe jej elementy będą w sznurku. W przeciwnym razie wszystkie listy byłyby puste, a zatem łańcuch również jest pusty.

05AB1E , 9 8 10 bajtów

Prawda zawiera tablicę w danych wyjściowych, fałsz ma miejsce, gdy dane wyjściowe nie są generowane. Kod:

œvy¦¥1QPiy

Wyjaśnienie nieaktualne :

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

Wypróbuj online!

Wykorzystuje kodowanie CP-1252 .

JavaScript ES6 47 bajtów

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

JavaScript ES6 52 bajty

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 bajty

dzięki ETHproductions za pomoc w oszczędzaniu kilku bajtów

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)

Testowanie

//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 bajtów

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

lub: (ta sama liczba bajtów)

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

Nie golfowany:

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
}

Duża edycja: Właśnie zdałem sobie sprawę, że muszę tylko opublikować funkcję, a nie cały program. To dużo oszczędza. Nie ma podstawki, nie trzeba konwertować ciągów znaków na liczby itp. Teraz zbliżamy się do znacznej liczby bajtów (w każdym razie dla języka nie golfowego).

Rubinowy - 80 -> 79 -> 76 -> 54 -> 48 -> 40 bajtów

Piąta próba (40 bajtów):

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

Używa składni lambda do zdefiniowania funkcji. (Dzięki konkurującemu Ruby golfistowi @ Sherlock9 za ten pomysł.)

Aby przetestować za pomocą połączenia lambda:

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

Czwarta próba:

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

Zastąpiony zero? i negacja z operatorem ===.

Trzecia próba:

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

Wykorzystuje wyrażenie regularne.

Druga próba:

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

Nowe podejście wykorzystuje dedup (uniq), sortuj i dołącz, a także włącz? aby wyszukać dopasowanie dowolnego rozwiązania w danych wejściowych renderowanych jako ciąg.

Pierwsza próba: 79 bajtów

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

Próbnik:

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

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

Używa deduplikacji (funkcja uniq) plus ustaw przecięcie (i operator), aby sprawdzić, czy którakolwiek z dobrych sekwencji pasuje do podanej sekwencji. Nie wymaga sortowania.

Pyth 13 11

@.PQ4.:S6 4

2 bajty dzięki Jakube!

Zwraca niepustą listę dla prawdy, pustą listę dla fałszu.

Wypróbuj online lub uruchom pakiet testowy (podzielony przez błąd składni Readability ™).

PHP, 95 bajtów

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

Poważnie, 21 bajtów

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

Wypróbuj online!

Zwraca wartość dodatnią dla wartości true, a 0 dla wartości false.

Wyjaśnienie:

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 bajtów

Można to prawdopodobnie pograć w golfa dalej, ale na początek:

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

Nie widzę sposobu na ograniczenie powielania bez użycia więcej miejsca; ta wersja ma 75 bajtów:

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

Siatkówka , 70 54 bajtów

Dane wejściowe to pojedynczy ciąg liczb całkowitych takich jak 13342. Dane wyjściowe to 1jeśli znaleziono lub 0jeśli nie.

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

Pamiętaj, że usunięcie duplikatów musi nastąpić tylko raz, ponieważ jest tylko pięć liczb. Konieczność usunięcia więcej niż jednej liczby oznaczałoby, że i tak nie ma małej prostej.

Wypróbuj online

Dzięki Martinowi za pomysł przeniesienia przecinków w grupach przechwytywania, oszczędzając aż 16 bajtów.

Pyth, 11 bajtów

f!-TQ.:S6 4

Zestaw testowy

Wygeneruj podciągi o długości 4 z [1..6], a następnie odfiltruj je pod kątem braku elementów, gdy zostaną usunięte elementy wejścia.

Galaretka, 9 bajtów

Musi istnieć 8-bajtowe rozwiązanie, będzie kontynuować wyszukiwanie ... Kod:

Œ!Ḋ€Iµ7Be

To jest to samo, co moje rozwiązanie 05AB1E .

Wyjaśnienie:

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

Wypróbuj online!

Galaretka, 8 bajtów

6Rṡ4ḟ€ċ“

Wypróbuj online! lub zweryfikuj prawdziwe przypadki testowe i przypadki fałszowania .

Jak to działa

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 bajtów

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

Próbnik:

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 bajty

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

Pobiera to liczbę 62 (111110 w systemie binarnym). Każda liczba w tablicy wejściowej usuwa ten bit

Wynikowa liczba powinna być albo

100000 or
000000 or
000010 or
000110 or
000100

więc sprawdzam, czy wynik jest mniejszy niż 7 (0000111) lub czy jest równy 32 (100000)

TI-BASIC, 25 bajtów

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

Równoważne (nie golfowe) wyrażenie w języku Python, które można przetestować :

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

Ideą tego jest podzielność. Aby sprawdzić, czy występuje a 1, 2, 3, 4, 2, 3, 4, 5lub 3, 4, 5, 6, możemy zmapować liczby 1-6 do 37-42, a następnie pomnożyć prawidłowe liczby razem.

Każda z liczb w [37, 42] ma główny czynnik, którego brakuje innym liczbom.

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

Dlatego jeśli iloczyn pięciu liczb jest podzielny przez 37, pierwotna lista zawierała 1. Jeśli przez 19, zawierała 2; itd. Jeśli jest podzielna przez 37*19*13*5= 65*703, zawiera 1, 2, 3, i 4podobnie dla pozostałych dwóch liczb.

To rozwiązanie jest lepsze od jednego , że @Weregoose pisał w 2009 r.

Świnka, 113 78 bajtów

Używana przeze mnie wersja Mumps to Cache InterSystems.

Nie mogę wymyślić krótszego sposobu gry w golfa; z inną techniką może to być możliwe, ale na razie to zrobi i przynajmniej będzie krótsze niż C ++ ... ale niewiele. Tak czy inaczej...

OK, tutaj jest krótsza droga. Zamiast mieć 3 oddzielne zmienne dla krótkich serii, użyj jednej zmiennej dla wszystkich 6 „kostek” i wyodrębnij porcje później:

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)

tyle dla mnie, że nie znalazłem lepszego sposobu z tą samą techniką ... powinienem spojrzeć, zanim skoczę, co? ;-)

Zostawię swoją oryginalną odpowiedź poniżej do celów historycznych ...

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

a oto wyjaśnienie, co dzieje się z kodem:

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.

Nie testowałem każdego wpisu zgodnego z prawdą i fałszem, ponieważ wymagało to ręcznego wpisania ich wszystkich; ale przetestowałem w przybliżeniu pierwszą połowę każdego z nich, sprawdziłem, czy długie proste nadal wykazują prawdziwość, a kilka z zaznaczonych przebiegów niekoniecznie działa poprawnie ([4,2,5,3,4], [1,2,3,3 , 4] itd.) I wydaje się działać poprawnie.

Dyalog APL , 15 bajtów

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

wykorzystuje ⎕IO=0

⍳4 jest 0 1 2 3

⍵∘.+⍳4 to 5 × 4 macierz każdej matrycy powiększona o każdą z nich ⍳4

⍵∊⍨ sprawdza, czy elementy macierzy są w ręku, wynikiem jest macierz boolowska (0-lub-1), musimy znaleźć wiersz wszystkich 1

∧/ jest redukcją według rzędów, wynikiem jest wektor boolowski

∨/ oznacza redukcję tego wektora

Galaretka, 11

QṢṡ4ðfø6Rṡ4

Wypróbuj online!

To właściwie kopia mojej odpowiedzi w Pyth, próbująca po prostu dowiedzieć się, jak połączyć łańcuchy. Wydaje się, że powinno być możliwe do gry w golfa.

Ekspansja:

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]

Jeśli chcesz zadać jakieś twarde pytanie, na przykład, dlaczego separatory są różne, to moja odpowiedź brzmi: „Odpowiem za 6-8 tygodni”: P (Poważniej, myślę, że to dopasowanie wzorca, monad-dyad kontra nilad-dyad, ale nie wiem i nie chcę rozpowszechniać dezinformacji.)