Dans le jeu Yahtzee , les joueurs lancent cinq dés à six faces et tentent de créer certaines mains pour marquer des points. Une telle main est une petite ligne droite : quatre numéros consécutifs, pas nécessairement dans l’ordre. Les trois petites lignes droites possibles 1, 2, 3, 4, 2, 3, 4, 5et 3, 4, 5, 6.

Par exemple, [3, 5, 6, 1, 4]contient la petite ligne droite [3, 4, 5, 6].

Contribution

Une liste non triée de cinq nombres entiers, chacun compris entre 1 et 6 inclus, représentant une main de Yahtzee.

Sortie

Une valeur de vérité si la main contient une petite ligne droite et une valeur de fausseté sinon.

Cas de test

Vérité

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

Fausseté:

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

_{Inspiré par cela}

Catalogue

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 octets

Merci beaucoup à @lirtosiast pour la suppression de 2 octets

ud7BXf

La vérité est un tableau de valeurs non nulles. Falsy est un tableau vide (aucune sortie affichée).

A partir de la version 16.2.0, uest stable par défaut. Le code nécessite donc un extra Spour trier la sortie: uSd7BXf( 7 octets ). Le lien inclut cette modification.

Essayez-le en ligne!

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 octets

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

De retour après 9 mois avec une amélioration. Nous n'avons pas besoin de vérifier si iest dans le jeu avec l'idée de Zgarb de vérifier uniquement les valeurs de départ dans le jeu. Nous pouvons maintenant également utiliser <pour des sous-ensembles stricts, car ils idoivent également être inclus.

47 octets:

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

Vérifie si un résultat au dé est le début d'une petite série de quilles. Merci à Zgarb pour l’idée de ne vérifier que les valeurs de départ dans la liste, en économisant 5 octets.

Python 3.5 a une conversion d'ensemble plus courte, pour 45 octets

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

C'est la même longueur à faire {*range(i,i+4)}comme {i,i+1,i+2,i+3}.

Labyrinthe, 41 octets

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

Une réponse en collaboration avec @ MartinBüttner. Je pense que nous avons réduit celui-ci bien au-delà de mes attentes initiales.

La sortie est 1pour la vérité, vide pour la fausseté. Essayez-le en ligne!

Explication rapide

Convertit chaque nombre nen un entier binaire 1 suivi de n+1zéros, c.-à-d 2^(n+1). Ou binaire OU les résultats et vérifier 1111(en binaire). L'exponentiation doit être implémentée manuellement dans Labyrinth.

Explication détaillée

L'amorce habituelle:

• Labyrinth est un langage de programmation 2D basé sur des piles. Pour la mémoire, il y a une pile principale et une pile auxiliaire, et le saut d'une pile vide génère 0 plutôt qu'une erreur.
• À chaque jonction, où le pointeur d'instruction peut descendre par au moins deux chemins possibles, le haut de la pile est vérifié pour décider de la prochaine étape. Le négatif est à gauche, le zéro est en avant, le positif est à droite.
• Les chiffres dans Labyrinth n'inscrivent pas le chiffre correspondant dans la pile, ils apparaissent net poussent n*10 + <digit>. Pour commencer un nouveau numéro, _appuie sur zéro.

Installer

L'exécution commence en haut à gauche, le pointeur d'instruction étant orienté vers la droite. Nous exécutons:

=        Swap tops of main and auxiliary stacks
|        Bitwise OR

Mis à part le fait de pousser efficacement les zéros, ces instructions ne changent pas la pile.

Boucle gauche: exponenti et bitwise OU

Labyrinth n'a pas d'exponentiation, nous devons donc l'implémenter manuellement. Nous lisons d’abord un entier avec ?, et comme cela est garanti, nous tournons à droite. _1pousse 1 et nous entrons dans la boucle intérieure.

La boucle interne a les effets suivants:

(       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

Étant donné que c'est un do-while, pour l' entrée nce calcule 2^(n+1). Nous finissons avec l'entrée mise à zéro sur la pile et 30transformons ce zéro en 30. Nous effectuons ensuite les mêmes instructions à partir de l'installation, mais cette fois-ci, elles sont réellement utiles.

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

Cette boucle continue pour chaque numéro de l'entrée jusqu'à EOF, quand ?renvoie 0. Cela nous oblige à avancer au lieu de tourner, conduisant à ...

Bridge: une configuration supplémentaire

La 30suite ?tourne le 0 de EOF en 30, qui est poussé vers la pile auxiliaire via }. Le fait que nous ayons poussé un 30 dans la pile auxiliaire pour chaque nombre saisi est donc important. La pile auxiliaire contient donc des 5 + 1 = 6copies du nombre 30 .

Pendant ce temps, la pile principale contient le OU bit à bit de 2^(n+1)pour chaque entrée n. Appelons cela OU au niveau du bit b, car il est modifié dans la bonne boucle.

Boucle de droite: résultat de contrôle et sortie

Voici ce qui se passe dans la boucle de droite:

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

Maintenant, la résiliation est un peu délicate avec ce programme. Voici les différentes manières de terminer le programme:

• Après 3 itérations de la boucle de droite, et best toujours positif: rappelez - vous comment nous avons mis six 30 dans la pile auxiliaire? Comme nous en utilisons deux à chaque itération, à la quatrième itération, nous commençons à tirer des zéros au bas de la pile auxiliaire. Cela provoque une division par zéro lorsque nous le faisons {/et le programme se termine.

• Après avoir généré un 1 pour une petite suite : Nous avons donc exécuté !puis tourné à droite à la "jonction sans issue. Ensuite, nous allons faire des montagnes russes et commencer à ramper à nouveau dans la moitié gauche:

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.

Après quelques allers-retours dans l'exposant, la pile ressemble à une pile ressemblant à une [12 | 30 30]division par zéro après deux autres itérations dans la boucle de droite.

• Après que b devienne nul à un moment donné : La clé ici est que la :boucle dans la droite est à une jonction. Si l'entrée était, disons, 1 1 1 1 1alors, bserait 4, alors 2, puis 1, 0après la troisième itération. Au lieu de tourner à la :, l'adresse IP avance maintenant tout droit, et quelque chose comme le cas précédent provoque éventuellement une résiliation.

Dans l’ensemble, le programme s’arrête, mais il n’ya rien pour sauver ces quelques octets!

Mathematica, 39 43 44 31 39 44 octets

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

Haskell, 39 à 34 octets

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

Exemple d'utilisation: f [1,2,3,3,4]-> True.

Similaire à la réponse de @ xnor , c’est-à-dire vérifier si l’une des petites lignes droites se trouve dans la liste de saisie. En fait, je teste toutes les "petites lignes droites" (c'est-à-dire 4 numéros consécutifs) en commençant par l'un des nombres de la liste de saisie, certaines d'entre elles étant invalides et par conséquent échouant toujours le alltest et ne faussant pas le anytest, par exemple [5,6,7,8].

Edit: @Zgarb a enregistré 5 octets. Merci!

MATL, 11 octets

udY'w1=)2>a

Essayez-le en ligne

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 octets

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

retourne truepour la vérité et falsepour la fausseté.

Comment ça marche

Retourne si une valeur dans [0, 1, 2, 3] remplit la condition selon laquelle pour chaque valeur dans [0, 1, 2, 3], la somme de ces deux valeurs est dans le tableau en entrée.

Donc, retourne si le tableau a toutes les valeurs dans [0, 1, 2, 3] (impossible), [1, 2, 3, 4], [2, 3, 4, 5] ou [3, 4, 5 , 6].

Ruby, 31 ans

Au lieu d'essayer d'être intelligent comme la première réponse Ruby , ceci passe simplement par le tableau des nombres entiers et, pour chaque nombre entier, vérifie s'il existe une petite suite dans l'entrée commençant par ce nombre entier. Ne vous inquiétez pas des valeurs possibles ou de l'unicité.

Cela semble utiliser le même algorithme que la réponse de Sherlock .

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

Ruby, 58 55 50 47 43 33 octets

Je viens de voir que j'ai été battu à coups de poing par la réponse Ruby de Paul . Je ne suis toutefois pas découragé, car je pense que cela pourrait encore être une bonne réponse avec un peu plus de golf. Basé, en partie, sur la réponse Python de xnor .

Edit: Quelques parties de golf et correction d’une confusion dans les conditions ternaires.

Edit: J'utilise maintenant .any?comme Pas que Charles fait dans leur réponse Ruby mais uniquement parce que j'avais besoin d'un moyen simple de supprimer aet de renvoyer uniquement une vérité et une falsey avec !([*i..i+3]-l)[0]depuis .maprenverrait un tableau de trueet false.

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

Retourne soit trueou 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

Remarque importante: pour ceux qui souhaitent utiliser le (a2 - a1).empty?code afin de déterminer si tous les éléments a2sont a1présents, notez que si vous souhaitez vous assurer que, par exemple, il [2,1,2]existe [1,2,3,3]une multiplicité d'éléments, vous avez besoin d'un autre code. Discussion pertinente sur ce problème ici .

Japt, 13 12 octets

Uá4 d@7o ¬fX

Testez-le en ligne! ou Vérifiez tous les cas de test .

Comment ça marche

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

Inclut +1 pour -p

Exécuter avec la séquence sur STDIN, par exemple

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

smallstraight.pl:

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

Explication

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 octets

7,4ewl~f&3f>

Donne une chaîne non vide pour les cas de test de véracité et une chaîne vide pour les cas de fausseté.

Suite de tests.

Explication

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.

À la fin du programme, cette liste est aplatie en une seule chaîne et imprimée sur STDOUT. Si l'une des petites lignes droites était trouvée, leurs éléments restants seraient dans la chaîne. Sinon, toutes les listes étaient vides et la chaîne est également vide.

05AB1E , 9 8 10 octets

La vérité contient un tableau dans la sortie, la fausseté consiste à ne produire aucune sortie. Code:

œvy¦¥1QPiy

Explication obsolète :

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

Essayez-le en ligne!

Utilise le codage CP-1252 .

Javascript ES6 47 octets

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

Javascript ES6 52 octets

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 octets

merci à ETHproductions pour avoir aidé à économiser plusieurs octets

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)

Essai

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

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

ou: (même nombre d'octets)

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: Je viens juste de réaliser que je n'ai besoin que de poster une fonction, pas tout un programme. Cela économise beaucoup. Pas de passe-partout, pas besoin de convertir les entrées de chaîne en nombres, etc. Nous approchons maintenant d'un nombre respectable d'octets (pour un langage ne faisant pas le golf de toute façon).

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

Cinquième essai (40 octets):

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

Utilise la syntaxe lambda pour définir la fonction. (Merci à Ruby golfer @ Sherlock9 pour cette idée.)

Pour tester en utilisant l'appel lambda:

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

Quatrième essai:

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

Remplacé nul? et la négation avec l'opérateur ===.

Troisième essai:

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

Utilise l'expression régulière.

Deuxième essai:

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

La nouvelle approche utilise dedup (uniq), trier et rejoindre, plus include? pour rechercher une correspondance de toutes les solutions dans l'entrée rendue sous forme de chaîne.

Premier essai: 79 octets

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

Testeur:

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

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

Utilise déduplication (fonction uniq) et intersection définie (& opérateur) pour vérifier si l’une des bonnes séquences correspond à la séquence donnée. Pas de tri nécessaire.

Pyth, 13 11

@.PQ4.:S6 4

2 octets grâce à Jakube!

Retourne une liste non vide pour la vérité, une liste vide pour la fausseté.

Essayez-le en ligne ou exécutez la suite de tests (divisée par une erreur de syntaxe pour Readability ™).

PHP, 95 octets

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

Sérieusement, 21 octets

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

Essayez-le en ligne!

Renvoie une valeur positive pour true et un 0 pour false.

Explication:

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 octets

Cela peut probablement être joué plus loin, mais pour commencer:

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

Je ne vois pas un moyen de réduire la duplication sans utiliser plus d'espace; cette version est de 75 octets:

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 octets

L'entrée est une chaîne unique d'entiers comme 13342. La sortie est un 1si trouvé, ou un 0si non.

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

Notez que la suppression des doublons ne doit avoir lieu qu'une seule fois, car il n'y a que cinq nombres. Avoir besoin de supprimer plus d'un chiffre signifierait qu'il n'y a pas une petite suite de toute façon.

Essayez-le en ligne

Merci à Martin pour l’idée de déplacer les virgules à l’intérieur des groupes de capture, en économisant 16 octets.

Pyth, 11 octets

f!-TQ.:S6 4

Suite de tests

Générez la longueur de 4 sous-chaînes de [1..6], puis filtrez-les sans qu'il ne reste d'éléments lorsque les éléments de l'entrée sont supprimés.

Gelée, 9 octets

Il doit y avoir une solution de 8 octets, poursuivra la recherche ... Code:

Œ!Ḋ€Iµ7Be

C'est la même chose que ma solution 05AB1E .

Explication:

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

Essayez-le en ligne!

Gelée, 8 octets

6Rṡ4ḟ€ċ“

Essayez-le en ligne! ou vérifier les cas de test de vérité et les cas de test de fausseté .

Comment ça marche

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 octets

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

Testeur:

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 octets

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

Ceci prend le nombre 62 (111110 en binaire). Pour chaque nombre dans le tableau d’entrée, il supprime ce bit.

Le nombre obtenu doit être soit

100000 or
000000 or
000010 or
000110 or
000100

donc je vérifie si le résultat est inférieur à 7 (0000111) ou égal à 32 (100000)

TI-BASIC, 25 octets

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

Une expression Python équivalente (non-golfée) que vous pouvez tester :

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'idée derrière ceci est la divisibilité. Pour vérifier si un 1, 2, 3, 4, 2, 3, 4, 5ou 3, 4, 5, 6se produit, nous pouvons mapper les nombres 1-6 à 37-42, puis multiplier les bons numéros ensemble.

Chacun des nombres de [37,42] a un facteur primordial qui manque aux autres nombres.

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

Par conséquent, si le produit des cinq nombres est divisible par 37, la liste initiale contenait un 1. Si, par 19, elle contenait un 2; etc. Si elle est divisible par 37*19*13*5= 65*703, il contient 1, 2, 3et4 de même pour les deux autres numéros.

Cette solution est une amélioration par rapport à celle que @Weregoose a publiée en 2009.

Oreillons, 113 78 octets

La version de Mumps que j'utilise est le cache InterSystems.

Je ne peux pas penser à une façon de jouer au golf cette technique plus courte; avec une technique différente, cela pourrait être possible, mais pour l’instant, ça ira et au moins, c’est plus court que C ++ ... mais pas beaucoup. En tous cas...

OK, voici un moyen plus court. Au lieu d'avoir 3 variables distinctes pour les séries courtes, utilisez une seule variable pour tous les 6 'dés' et extrayez les portions plus tard:

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)

tant pis pour moi de ne pas trouver un meilleur moyen avec la même technique ... Je devrais regarder avant de sauter, hein? ;-)

Je laisserai ma réponse originale ci-dessous à des fins historiques ...

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

et voici l'explication de ce qui se passe avec le code:

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.

Je n'ai pas testé chaque entrée vérité et fausseté, car cela impliquait de les taper manuellement toutes; mais j’ai testé environ la première moitié de chacune d’entre elles, vérifié que les longues lignes droites montraient toujours la vérité et que plusieurs des manches notées ne fonctionnaient pas nécessairement correctement ([4,2,5,3,4], [1,2,3,3 , 4] etc.) et semble fonctionner correctement.

Dyalog APL , 15 octets

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

les usages ⎕IO=0

⍳4 est 0 1 2 3

⍵∘.+⍳4 est 5 × 4 une matrice de chaque matrice incrémentée de chacun des ⍳4

⍵∊⍨ vérifie si les éléments de la matrice sont dans la main, le résultat est une matrice booléenne (0 ou 1), nous devons trouver une ligne de tous les 1

∧/ est l'and-reduction by rows, le résultat est un vecteur booléen

∨/ est l'ou-réduction de ce vecteur

Gelée, 11

QṢṡ4ðfø6Rṡ4

Essayez-le en ligne!

Ceci est à peu près une copie de ma réponse Pyth, essayant juste de comprendre comment enchaîner des choses. On se sent comme il devrait être golfable.

Expansion:

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]

Si vous souhaitez poser des questions difficiles, comme par exemple en quoi les séparateurs sont différents, ma réponse est: "je répondrai dans 6 à 8 semaines": P (Plus sérieusement, je pense que c'est le filtrage par motif, monad-dyad vs nilad-dyad, mais je ne sais pas et je ne veux pas répandre la désinformation.)