En el juego Yahtzee , los jugadores lanzan cinco dados de seis lados e intentan crear ciertas manos para ganar puntos. Una de esas manos es una pequeña escalera : cuatro números consecutivos, no necesariamente en orden. Las tres posibles pequeñas rectas son 1, 2, 3, 4, 2, 3, 4, 5y 3, 4, 5, 6.

Por ejemplo, [3, 5, 6, 1, 4]contiene la pequeña recta [3, 4, 5, 6].

Entrada

Una lista sin clasificar de cinco enteros, cada uno entre 1 y 6 inclusive, que representa una mano Yahtzee.

Salida

Un valor verdadero si la mano contiene una recta pequeña y un valor falso de lo contrario.

Casos de prueba

Verdad:

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

_{Inspirado por esto}

Catalogar

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 bytes

Muchas gracias a @lirtosiast por eliminar 2 bytes

ud7BXf

La verdad es una matriz de valores distintos de cero. Falsy es una matriz vacía (no se muestra ningún resultado).

A partir de la versión 16.2.0, ues estable de manera predeterminada. Entonces, el código necesita un extra Spara ordenar la salida: uSd7BXf( 7 bytes ). El enlace incluye esta modificación.

Pruébalo en línea!

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 bytes

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

De vuelta después de 9 meses con una mejora. No necesitamos verificar si iestá en el conjunto con la idea de Zgarb de verificar solo los valores iniciales en el conjunto. Ahora también podemos usar <para subconjuntos estrictos porque itambién deben incluirse.

47 bytes:

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

Comprueba si alguna tirada de dados es el comienzo de una pequeña serie recta. Gracias a Zgarb por la idea de verificar solo los valores iniciales en la lista, ahorrando 5 bytes.

Python 3.5 tiene una conversión de conjunto más corta, para 45 bytes

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

Es la misma longitud que hacer {*range(i,i+4)}tan {i,i+1,i+2,i+3}.

Laberinto, 41 bytes

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

Una respuesta colaborativa con @ MartinBüttner. Creo que hemos exprimido esto mucho más allá de mis expectativas iniciales.

La salida es 1para la verdad, vacía para la falsedad. Pruébalo en línea!

Explicacion rapida

Convierta cada número na un entero binario 1 seguido de n+1ceros, es decir 2^(n+1). Bitwise O los resultados y verifique 1111(en binario). La exponenciación debe implementarse manualmente en Labyrinth.

Explicación detallada

La cartilla habitual:

• Labyrinth es un lenguaje de programación 2D basado en pila. Para la memoria hay una pila principal y una pila auxiliar, y al saltar de una pila vacía se produce 0 en lugar de un error.
• En cada cruce, donde el puntero de instrucciones podría moverse por dos o más rutas posibles, se comprueba la parte superior de la pila para decidir a dónde ir después. Negativo es izquierda, cero es hacia adelante, positivo es correcto.
• Los dígitos en Labyrinth no empujan el dígito correspondiente a la pila, sino que aparecen ny empujan n*10 + <digit>. Para comenzar un nuevo número, _presiona cero.

Preparar

La ejecución comienza en la esquina superior izquierda, con el puntero de instrucciones hacia la derecha. Ejecutamos:

=        Swap tops of main and auxiliary stacks
|        Bitwise OR

Además de empujar efectivamente los ceros, estas instrucciones no cambian la pila.

Bucle izquierdo: exponencial y bit a bit O

El laberinto no tiene exponenciación, por lo que debemos implementarlo manualmente. Primero leemos un número entero con ?, y como se garantiza que es positivo, giramos a la derecha. _1empuja 1 y entramos en el bucle interno.

El bucle interno hace lo siguiente:

(       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

Dado que este es un bucle do-while, para la entrada nesto calcula 2^(n+1). Terminamos con la entrada puesta a cero en la pila y 30convertimos este cero en 30. Luego realizamos las mismas instrucciones de la configuración, pero esta vez son realmente útiles.

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

Este ciclo continúa para cada número en la entrada hasta EOF, cuando ?devuelve 0. Esto nos hace avanzar en lugar de girar, lo que lleva a ...

Puente: alguna configuración extra

El 30después de las ?vueltas del 0 de EOF en 30, que se empuja a la pila auxiliar a través }. Es importante el hecho de que empujamos un 30 a la pila auxiliar para cada número de entrada, por lo que ahora la pila auxiliar contiene 5 + 1 = 6copias del número 30 .

Mientras tanto, la pila principal contiene el OR bit a bit de 2^(n+1)cada entrada n. Llamemos a esto OR bit a bit b, ya que se modifica en el bucle derecho.

Bucle derecho: verificar el resultado y la salida

Esto es lo que sucede en el bucle del lado derecho:

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

Ahora, la terminación es un poco complicada con este programa. Estas son las posibles formas en que el programa puede terminar:

• Después de 3 iteraciones del bucle derecho, y bsigue siendo positivo: ¿Recuerdas cómo colocamos seis 30 en la pila auxiliar? Como usamos dos de ellos en cada iteración, en la cuarta iteración comenzamos a extraer ceros desde la parte inferior de la pila auxiliar. Esto provoca una división por cero cuando lo hacemos {/, y el programa termina.

• Después de generar un 1 para una recta pequeña : hemos ejecutado y !luego giramos a la derecha en el "cruce sin operaciones . Luego nos espera una montaña rusa cuando comenzamos a gatear por la mitad izquierda nuevamente:

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.

Después de algunos viajes en el exponente, la pila se ve algo así [12 | 30 30], que se equivoca por división por cero después de otras dos iteraciones en el bucle derecho.

• Después de que b se convierte en cero en algún momento : la clave aquí es que el :bucle derecho está en una unión. Si la entrada fue, digamos, 1 1 1 1 1entonces bsería 4, luego 2, luego 1, luego de 0la tercera iteración. En lugar de girar en el :, la IP ahora se mueve hacia adelante, y algo como el caso anterior causa una eventual terminación.

En general, es un desastre cómo termina el programa, ¡pero oye cualquier cosa para guardar esos pocos bytes!

Mathematica, 39 43 44 31 39 44 bytes

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

Haskell, 39 34 bytes

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

Ejemplo de uso: f [1,2,3,3,4]-> True.

Similar a la respuesta de @ xnor , es decir, verifique si alguna de las rectas pequeñas está en la lista de entrada. En realidad, estoy probando todas las "rectas pequeñas" (es decir, 4 números consecutivos) comenzando con cualquiera de los números de la lista de entrada, algunos de ellos no son válidos y, por lo tanto, siempre fallan la allprueba y no distorsionan la anyprueba, por ejemplo [5,6,7,8].

Editar: @Zgarb ahorró 5 bytes. ¡Gracias!

MATL, 11 bytes

udY'w1=)2>a

Pruébalo en línea

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 bytes

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

vuelve truepor la verdad y falsepor la falsedad.

Cómo funciona

Devuelva si algún valor en [0, 1, 2, 3] cumple la condición de que para cada valor en [0, 1, 2, 3] la suma de estos dos valores está en la matriz de entrada.

Entonces, regrese si la matriz tiene todos los valores en [0, 1, 2, 3] (imposible), [1, 2, 3, 4], [2, 3, 4, 5], o [3, 4, 5 6].

Ruby, 31

En lugar de tratar de ser inteligente como la primera respuesta de Ruby , esto solo pasa por la matriz de enteros, y para cada entero, ve si hay una pequeña recta en la entrada que comienza con ese entero. No se preocupa por los posibles valores o la unicidad.

Esto parece estar usando el mismo algoritmo que la respuesta de Sherlock .

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

Ruby, 58 55 50 47 43 33 bytes

Acabo de ver que la respuesta de Paul Ruby me ha golpeado hasta el golpe . Sin embargo, no estoy disuadido ya que creo que esto podría ser una respuesta decente con un poco más de golf. Basado, en parte, en la respuesta de Python de xnor .

Editar: Algunos jugando al golf y corrigiendo una confusión en el condicional ternario.

Editar: ahora uso .any?como No lo que Charles hace en su respuesta de Ruby, sino solo porque necesitaba una forma simple de eliminar ay devolver solo una verdad y una falsey con !([*i..i+3]-l)[0]ya .mapque devolvería una matriz de truey false.

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

Devuelve ya sea trueo false.

Sin golf:

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: para aquellos que quieran usar el (a2 - a1).empty?código para determinar si todos los elementos a2están en a1, tenga en cuenta que si desea asegurarse de que, por ejemplo, [2,1,2]esté en la [1,2,3,3]multiplicidad de elementos, necesita otro código. Discusión relevante de este problema aquí .

Japt, 13 12 bytes

Uá4 d@7o ¬fX

¡Pruébelo en línea! o Verificar todos los casos de prueba .

Cómo funciona

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

Incluye +1 para -p

Ejecutar con la secuencia en STDIN, p. Ej.

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

smallstraight.pl:

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

Explicación

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 bytes

7,4ewl~f&3f>

Produce una cadena no vacía para casos de prueba verdaderos y una cadena vacía para casos falsos.

Banco de pruebas.

Explicación

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.

Al final del programa, esta lista se aplana en una sola cadena y se imprime en STDOUT. Si se encuentra alguna de las rectas pequeñas, sus elementos restantes estarán en la cadena. De lo contrario, todas las listas estaban vacías, por lo que la cadena también está vacía.

05AB1E , 9 8 10 bytes

La verdad contiene una matriz en la salida, la falsa es cuando no se produce ninguna salida. Código:

œvy¦¥1QPiy

Explicación desactualizada :

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

Pruébalo en línea!

Utiliza la codificación CP-1252 .

Javascript ES6 47 bytes

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

Javascript ES6 52 bytes

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 bytes

gracias a ETHproductions por ayudar a ahorrar varios bytes

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)

Pruebas

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

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

o: (mismo número de bytes)

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

Sin golf:

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: Acabo de darme cuenta de que solo necesito publicar una función, no un programa completo. Eso ahorra mucho. No hay repeticiones, no es necesario convertir la entrada de cadena en números, etc. Ahora nos estamos acercando a un número respetable de bytes (de todos modos, para un lenguaje que no sea de golf).

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

Quinto intento (40 bytes):

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

Utiliza la sintaxis lambda para definir la función. (Gracias a la competidora de golf Ruby @ Sherlock9 por esta idea).

Para probar usando la llamada lambda:

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

Cuarto intento:

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

Reemplazado nulo? y negación con === operador.

Tercer intento:

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

Utiliza expresiones regulares.

Segundo intento:

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

El nuevo enfoque utiliza dedup (uniq), ordenar y unir, además de incluir? para buscar una coincidencia de cualquier solución en la entrada representada como una cadena.

Primer intento: 79 bytes

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

Ensayador:

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

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

Utiliza la deducción (función uniq) más la intersección establecida (y operador) para probar si alguna de las secuencias correctas coincide con la secuencia dada. No se necesita clasificación.

Pyth 13 11

@.PQ4.:S6 4

2 bytes gracias a Jakube!

Devuelve una lista no vacía para verdadero, lista vacía para falso.

Pruébelo en línea o ejecute Test Suite (dividido por un error de sintaxis para Readability ™).

PHP, 95 bytes

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

En serio, 21 bytes

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

Pruébalo en línea!

Emite un valor positivo para verdadero y un 0 para falso.

Explicación:

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 bytes

Esto probablemente se pueda jugar más, pero como comienzo:

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

No veo una forma de reducir la duplicación sin usar más espacio; esta versión es de 75 bytes:

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 bytes

La entrada es una sola cadena de enteros como 13342. La salida es un 1si se encuentra, o un 0si 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

Tenga en cuenta que la eliminación de duplicados solo debe ocurrir una vez, ya que solo hay cinco números. La necesidad de eliminar más de un número significaría que no hay una recta pequeña de todos modos.

Pruébalo en línea

Gracias a Martin por la idea de mover las comas dentro de los grupos de captura, ahorrando la friolera de 16 bytes.

Pyth, 11 bytes

f!-TQ.:S6 4

Banco de pruebas

Genere las 4 subcadenas de longitud de [1..6], luego fíltrelas en ningún elemento restante cuando se eliminen los elementos de la entrada.

Jalea, 9 bytes

Tiene que haber una solución de 8 bytes, continuará buscando ... Código:

Œ!Ḋ€Iµ7Be

Esto es lo mismo que mi solución 05AB1E .

Explicación:

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

Pruébalo en línea!

Jalea, 8 bytes

6Rṡ4ḟ€ċ“

Pruébalo en línea! o verificar los casos de prueba de la verdad y los casos de prueba de la falsedad .

Cómo funciona

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 bytes

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

Ensayador:

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 bytes

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

Esto toma el número 62 (111110 en binario) Para cada número en la matriz de entrada, elimina ese bit

El número resultante debería ser

100000 or
000000 or
000010 or
000110 or
000100

entonces verifico si el resultado es menor que 7 (0000111) o si es igual a 32 (100000)

TI-BASIC, 25 bytes

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

Una expresión de Python equivalente (sin golf) que puede probar :

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

La idea detrás de esto es la divisibilidad. Para verificar si a 1, 2, 3, 4, 2, 3, 4, 5u 3, 4, 5, 6ocurre, podemos mapear los números 1-6 a 37-42, y luego multiplicar los números correctos.

Cada uno de los números en [37,42] tiene un factor primo que los otros números carecen.

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

Por lo tanto, si el producto de los cinco números es divisible por 37, la lista original contenía un 1. Si por 19, contenía un 2; etc. Si es divisible por 37*19*13*5= 65*703, que contiene 1, 2, 3, y 4y lo mismo para los otros dos números.

Esta solución es una mejora en uno que @Weregoose publicada en 2009.

Paperas, 113 78 Bytes

La versión de Paperas que estoy usando es InterSystems Cache.

No puedo pensar en una forma de jugar golf esta técnica más corta; con una técnica diferente podría ser posible, pero por ahora esto funcionará y al menos es más corto que C ++ ... pero no por mucho. De todas formas...

OK, aquí hay un camino más corto. En lugar de tener 3 variables separadas para las tiradas cortas, use una sola variable para los 6 'dados' y extraiga las porciones más tarde:

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)

tanto para mí no encontrar una mejor manera con la misma técnica ... Debería buscar antes de saltar, ¿eh? ;-)

Dejaré mi respuesta original a continuación para fines históricos ...

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

y aquí está la explicación de lo que está pasando con el código:

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.

No he probado todos y cada uno Truthy y entrada Falsy como la implicada escribir manualmente todos ellos en; pero probé aproximadamente la primera mitad de cada una, verifiqué que las rectas largas todavía muestran la verdad y varias de las carreras notaron que no necesariamente funcionan correctamente ([4,2,5,3,4], [1,2,3,3 , 4] etc.) y parece estar funcionando correctamente.

Dyalog APL , 15 bytes

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

usos ⎕IO=0

⍳4 es 0 1 2 3

⍵∘.+⍳4 es 5 × 4 una matriz de cada dado incrementada por cada uno de ⍳4

⍵∊⍨ comprueba si los elementos de la matriz están en la mano, el resultado es una matriz booleana (0-o-1), necesitamos encontrar una fila de todos los 1s

∧/ es la reducción y por filas, el resultado es un vector booleano

∨/ es la o-reducción de ese vector

Gelatina, 11

QṢṡ4ðfø6Rṡ4

Pruébalo en línea!

Esto es más o menos una copia de mi respuesta de Pyth, solo tratando de descubrir cómo encadenar cosas. Parece que debería ser golfable.

Expansión:

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 desea hacer preguntas difíciles, como por qué los separadores son diferentes, mi respuesta es: "Contestaré en 6-8 semanas": P (Más en serio, creo que es la coincidencia de patrones, mónada-díada vs nilad-dyad, pero no sé y no quiero difundir información errónea).