Nel gioco Yahtzee , i giocatori lanciano cinque dadi a sei facce e tentano di creare determinate mani per ottenere punti. Una di queste mani è una piccola scala : quattro numeri consecutivi, non necessariamente in ordine. I tre possibili piccoli rettilinei sono 1, 2, 3, 4, 2, 3, 4, 5e 3, 4, 5, 6.

Ad esempio, [3, 5, 6, 1, 4]contiene la piccola scala [3, 4, 5, 6].

Ingresso

Un elenco non ordinato di cinque numeri interi, ciascuno compreso tra 1 e 6 inclusi, che rappresenta una mano Yahtzee.

Produzione

Un valore vero se la mano contiene una piccola scala e un valore falso in caso contrario.

Casi test

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

_{Ispirato da questo}

Catalogare

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

Grazie mille a @lirtosiast per la rimozione di 2 byte

ud7BXf

La verità è una matrice di valori diversi da zero. Falsy è un array vuoto (nessun output visualizzato).

A partire dalla versione 16.2.0, uè stabile per impostazione predefinita. Quindi il codice ha bisogno di un extra Sper ordinare l'output: uSd7BXf( 7 byte ). Il collegamento include questa modifica.

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

Torna dopo 9 mesi con un miglioramento. Non è necessario verificare se iè presente nel set con l'idea di Zgarb di verificare solo i valori iniziali nel set. Ora possiamo usare anche <per sottoinsiemi rigorosi perché idevono essere inclusi anche.

47 byte:

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

Verifica se qualche tiro di dado è l'inizio di un piccolo set di scala. Grazie a Zgarb per l'idea di controllare solo i valori iniziali nell'elenco, salvando 5 byte.

Python 3.5 ha una conversione di set più corta, per 45 byte

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

E 'la stessa lunghezza di fare {*range(i,i+4)}come {i,i+1,i+2,i+3}.

Labirinto, 41 byte

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

Una risposta globale con @ MartinBüttner. Penso che l'abbiamo spremuto ben oltre le mie aspettative iniziali.

L'output è 1vero, vuoto per falso. Provalo online!

Spiegazione veloce

Converti ogni numero nin un numero intero binario 1 seguito da n+1zero, cioè 2^(n+1). Bit a bit O i risultati e verificare 1111(in binario). L'esponenziazione deve essere implementata manualmente in Labyrinth.

Spiegazione dettagliata

Il solito primer:

• Labyrinth è un linguaggio di programmazione 2D basato su stack. Per la memoria c'è uno stack principale e uno stack ausiliario e il pop-up da uno stack vuoto produce 0 anziché un errore.
• Ad ogni incrocio, in cui il puntatore dell'istruzione potrebbe spostarsi verso il basso di due o più possibili percorsi, viene controllata la parte superiore dello stack per decidere dove andare dopo. Il negativo è a sinistra, lo zero è in avanti, il positivo è a destra.
• Le cifre in Labyrinth non spingono la cifra corrispondente nello stack - piuttosto, pop ne push n*10 + <digit>. Per iniziare un nuovo numero, _spinge zero.

Impostare

L'esecuzione inizia in alto a sinistra, con il puntatore dell'istruzione rivolto verso destra. Eseguiamo:

=        Swap tops of main and auxiliary stacks
|        Bitwise OR

Oltre a spingere efficacemente gli zero, queste istruzioni non cambiano lo stack.

Anello sinistro: esponenziale e bit a bit OR

Labyrinth non ha esponenziazione, quindi dobbiamo implementarlo manualmente. Per prima cosa leggiamo un numero intero con ?, e poiché questo è garantito per essere positivo, giriamo a destra. _1spinge 1 ed entriamo nel circuito interno.

Il ciclo interno procede come segue:

(       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

Poiché si tratta di un ciclo do-while, per l'input viene ncalcolato 2^(n+1). Finiamo con l'ingresso azzerato nello stack e 30trasformiamo questo zero in 30. Quindi eseguiamo le stesse istruzioni dall'impostazione, ma questa volta sono effettivamente utili.

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

Questo ciclo continua per ogni numero nell'input fino a EOF, quando ?restituisce 0. Questo ci fa avanzare invece di girare, portando in ...

Bridge: qualche configurazione aggiuntiva

Il 30dopo ?trasforma lo 0 da EOF a 30, che viene spinto nello stack ausiliario tramite }. È importante il fatto che abbiamo inserito un 30 nello stack ausiliario per ogni numero di input, quindi ora lo stack ausiliario contiene 5 + 1 = 6copie del numero 30 .

Nel frattempo, lo stack principale contiene l'OR bit 2^(n+1)per bit di ciascun input n. Chiamiamolo bit a bit O b, poiché viene modificato nel loop destro.

Anello destro: controlla il risultato e l'output

Ecco cosa succede nel loop di destra:

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

Ora, la risoluzione è un po 'complicata con questo programma. Ecco i possibili modi in cui il programma può terminare:

• Dopo 3 iterazioni del loop destro, ed bè ancora positivo: ricordi come abbiamo messo sei 30s nello stack ausiliario? Dato che ne usiamo due per ciascuna iterazione, alla quarta iterazione iniziamo a estrarre zero dal fondo dello stack ausiliario. Ciò provoca una divisione per zero quando lo facciamo {/e il programma termina.

• Dopo aver emesso un 1 per un piccolo rettilineo : quindi abbiamo eseguito !quindi girato a destra al "bivio no-op . Quindi entriamo per le montagne russe mentre ricominciamo a strisciare su tutta la metà sinistra:

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.

Dopo alcuni viaggi nell'esponente, lo stack sembra qualcosa del genere [12 | 30 30], che si risolve per divisione per zero dopo altre due iterazioni nel loop destro.

• Dopo che b diventa zero a un certo punto : la chiave qui è che il :loop a destra si trova in una giunzione. Se l'input fosse, diciamo, 1 1 1 1 1allora bsarebbe 4, quindi 2, quindi 1, 0dopo la terza iterazione. Invece di girare su :, l'IP ora procede dritto e qualcosa come il caso precedente sembra causare un'eventuale chiusura.

Tutto sommato è un casino come termina il programma, ma ehi qualsiasi cosa per salvare quei pochi byte!

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

Esempio di utilizzo: f [1,2,3,3,4]-> True.

Simile alla risposta di @ xnor , vale a dire verificare se qualcuno dei piccoli rettilinei è presente nell'elenco di input. In realtà sto testando tutti i "piccoli rettilinei" (ovvero 4 numeri consecutivi) a partire da uno qualsiasi dei numeri dall'elenco di input, alcuni dei quali non sono validi e quindi falliscono sempre il alltest e non distorcono il anytest, ad es [5,6,7,8].

Modifica: @Zgarb ha salvato 5 byte. Grazie!

MATL, 11 byte

udY'w1=)2>a

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

ritorna trueper verità e falsefalsità.

Come funziona

Restituisce se un valore in [0, 1, 2, 3] soddisfa la condizione che per ogni valore in [0, 1, 2, 3] la somma di questi due valori sia nell'array di input.

Quindi, restituisci se l'array ha tutti i valori in [0, 1, 2, 3] (impossibile), [1, 2, 3, 4], [2, 3, 4, 5] o [3, 4, 5 , 6].

Ruby, 31 anni

Invece di cercare di essere intelligente come la prima risposta di Ruby , questo passa attraverso l'array di numeri interi e, per ogni numero intero, vede se c'è un piccolo rettangolo nell'input che inizia con quel numero intero. Non si preoccupa dei possibili valori o unicità.

Questo sembra usare lo stesso algoritmo della risposta di Sherlock .

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

Rubino, 58 55 50 47 43 33 byte

Ho appena visto che sono stato picchiato a pugni dalla risposta di Ruby di Paul . Non mi scoraggia comunque, poiché penso che questa potrebbe essere una risposta decente con un po 'più di golf. Basato, in parte, sulla risposta di Python di xnor .

Modifica: Alcuni golf e correggendo un disordine nel condizionale ternario.

Modifica: ora uso .any?come Non quello che Charles fa nella loro risposta su Ruby, ma solo perché avevo bisogno di un modo semplice per rimuovere ae restituire solo una verità e una falsità, !([*i..i+3]-l)[0]dato .mapche restituiva una serie di truee false.

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

Restituisce trueo 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

Nota importante: per coloro che desiderano utilizzare il (a2 - a1).empty?codice per determinare se tutti gli elementi a2sono presenti a1, tenere presente che se si desidera assicurarsi che, ad esempio, [2,1,2]si trovi nella [1,2,3,3]molteplicità degli elementi, è necessario altro codice. Discussione pertinente di questo problema qui .

Japt, 13 12 byte

Uá4 d@7o ¬fX

Provalo online! oppure Verifica tutti i casi di test .

Come funziona

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

Include +1 per -p

Esegui con la sequenza su STDIN, ad es

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

smallstraight.pl:

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

Spiegazione

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>

Produce una stringa non vuota per casi di prova veritieri e una stringa vuota per casi falsi.

Suite di test.

Spiegazione

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.

Alla fine del programma, questo elenco viene appiattito in un'unica stringa e stampato su STDOUT. Se viene trovato uno qualsiasi dei rettilinei piccoli, i loro elementi rimanenti saranno nella stringa. Altrimenti tutte le liste erano vuote e quindi anche la stringa è vuota.

05AB1E , 9 8 10 byte

La verità contiene un array nell'output, il falso è quando non viene prodotto alcun output. Codice:

œvy¦¥1QPiy

Spiegazione obsoleta :

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

Provalo online!

Utilizza la codifica 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

grazie a ETHproductions per aver contribuito a salvare diversi 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)

analisi

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

oppure: (stesso numero di byte)

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
}

Big Edit: ho appena realizzato che ho solo bisogno di pubblicare una funzione, non un intero programma. Ciò consente di risparmiare molto. Nessuna targhetta, nessuna necessità di convertire l'input della stringa in numeri, ecc. Ora ci stiamo avvicinando a un numero rispettabile di byte (comunque per un linguaggio non golf).

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

Quinto tentativo (40 byte):

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

Utilizza la sintassi lambda per definire la funzione. (Grazie a Ruby Golfer @ Sherlock9 per questa idea.)

Per testare usando la chiamata lambda:

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

Quarto tentativo:

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

Sostituito con zero? e negazione con l'operatore ===.

Terzo tentativo:

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

Usa un'espressione regolare.

Secondo tentativo:

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

Il nuovo approccio utilizza dedup (uniq), ordina e unisce, oltre a includere? per cercare una corrispondenza di qualsiasi soluzione nell'input reso come stringa.

Primo tentativo: 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

Tester:

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

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

Utilizza il deduping (funzione uniq) più set intersezione (e operatore) per verificare se una delle sequenze valide corrisponde a quella data. Nessun ordinamento necessario.

Pyth, 13 11

@.PQ4.:S6 4

2 byte grazie a Jakube!

Restituisce un elenco non vuoto per verità, elenco vuoto per falsità.

Provalo online o esegui Test Suite (diviso per un errore di sintassi per 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

Scherzi a parte, 21 byte

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

Provalo online!

Emette un valore positivo per true e uno 0 per false.

Spiegazione:

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

Questo può probabilmente essere ulteriormente approfondito, ma come inizio:

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

Non vedo un modo per ridurre la duplicazione senza usare più spazio; questa versione è di 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

L'input è una singola stringa di numeri interi come 13342. L'output è un 1se trovato o un 0se no.

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

Si noti che la rimozione dei duplicati deve avvenire una sola volta, poiché ci sono solo cinque numeri. La necessità di rimuovere più di un numero significherebbe che non esiste comunque una piccola scala.

Provalo online

Grazie a Martin per l'idea di spostare le virgole all'interno dei gruppi di acquisizione, salvando ben 16 byte.

Pyth, 11 byte

f!-TQ.:S6 4

Suite di test

Generare la lunghezza 4 sottostringhe di [1..6], quindi filtrarle su nessun elemento rimanente quando vengono rimossi gli elementi dell'input.

Gelatina, 9 byte

Ci deve essere una soluzione a 8 byte, continuerà la ricerca ... Codice:

Œ!Ḋ€Iµ7Be

Questo è lo stesso della mia soluzione 05AB1E .

Spiegazione:

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

Provalo online!

Gelatina, 8 byte

6Rṡ4ḟ€ċ“

Provalo online! oppure verifica i casi di test veritieri e i casi di test falsi .

Come funziona

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)

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

Questo prende il numero 62 (111110 in binario) Per ogni numero nell'array di input rimuove quel bit

Il numero risultante dovrebbe essere

100000 or
000000 or
000010 or
000110 or
000100

quindi controllo se il risultato è inferiore a 7 (0000111) o se è uguale a 32 (100000)

TI-BASIC, 25 byte

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

Un'espressione Python equivalente (non golfizzata) che puoi testare :

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

L'idea alla base è la divisibilità. Per verificare se a 1, 2, 3, 4, 2, 3, 4, 5o si 3, 4, 5, 6verifica, possiamo mappare i numeri da 1-6 a 37-42 e quindi moltiplicare i numeri corretti insieme.

Ciascuno dei numeri in [37,42] ha un fattore primo che manca agli altri numeri.

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

Pertanto, se il prodotto dei cinque numeri è divisibile per 37, l'elenco originale conteneva un 1. Se per 19, conteneva un 2; ecc Se è divisibile per 37*19*13*5= 65*703, contiene 1, 2, 3, e 4analogamente per gli altri due numeri.

Questa soluzione è un miglioramento su quello che @Weregoose pubblicato nel 2009.

Parotite, 113 78 byte

La versione di Mumps che sto usando è InterSystems Cache.

Non riesco a pensare a un modo di giocare a golf questa tecnica più breve; con una tecnica diversa potrebbe essere possibile, ma per ora questo lo farà e almeno è più breve di C ++ ... ma non di molto. Comunque...

OK, ecco un modo più breve. Invece di avere 3 variabili separate per le brevi tirature, usa una singola variabile per tutti e 6 i 'dadi' ed estrai le porzioni in seguito:

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)

così tanto per me non trovare un modo migliore con la stessa tecnica ... Dovrei guardare prima di saltare, eh? ;-)

Lascerò la mia risposta originale qui sotto per scopi storici ...

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

ed ecco la spiegazione di cosa sta succedendo con il codice:

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.

Non ho testato ogni singolo input di verità e falsità poiché ciò comportava la digitazione manuale di tutti; ma ho provato circa la prima metà di ciascuno, verificato che i rettilinei lunghi mostrino ancora la verità e molte delle piste notate per non funzionare necessariamente correttamente ([4,2,5,3,4], [1,2,3,3 , 4] ecc.) E sembra funzionare correttamente.

Dyalog APL , 15 byte

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

usi ⎕IO=0

⍳4 è 0 1 2 3

⍵∘.+⍳4 è 5 × 4 una matrice di ciascun dado incrementata di ciascuno di ⍳4

⍵∊⍨ controlla se gli elementi della matrice sono nella mano, il risultato è una matrice booleana (0-o-1), dobbiamo trovare una riga di tutti gli 1

∧/ è la riduzione e per righe, il risultato è un vettore booleano

∨/ è la riduzione or di quel vettore

Jelly, 11

QṢṡ4ðfø6Rṡ4

Provalo online!

Questa è praticamente una copia della mia risposta Pyth, sto solo cercando di capire come concatenare le cose. Sembra che dovrebbe essere giocabile a golf.

Espansione:

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]

Se vuoi fare domande difficili, come il motivo per cui i separatori sono diversi, la mia risposta è: "Risponderò tra 6-8 settimane": P (Più seriamente, penso che sia il pattern matching, monade-diade vs nilad-dyad, ma non lo so e non voglio diffondere disinformazione.)