No jogo Yahtzee , os jogadores jogam cinco dados de seis lados e tentam criar certas mãos para marcar pontos. Uma dessas mãos é uma pequena sequência : quatro números consecutivos, não necessariamente em ordem. Os três possíveis pequenas retas são 1, 2, 3, 4, 2, 3, 4, 5e 3, 4, 5, 6.

Por exemplo, [3, 5, 6, 1, 4]contém a pequena reta [3, 4, 5, 6].

Entrada

Uma lista não classificada de cinco números inteiros, cada um entre 1 e 6, inclusive, representando uma mão Yahtzee.

Saída

Um valor verdadeiro se a mão contiver um pequeno straight e um valor falso caso contrário.

Casos de teste

Verdade:

[[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 isso}

Catálogo

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

Muito obrigado a @lirtosiast por remover 2 bytes

ud7BXf

Truthy é uma matriz de valores diferentes de zero. Falsy é uma matriz vazia (nenhuma saída é exibida).

A partir do release 16.2.0, ué estável por padrão. Portanto, o código precisa de um extra Spara classificar a saída: uSd7BXf( 7 bytes ). O link inclui esta modificação.

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

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

Voltar após 9 meses com uma melhoria. Não precisamos verificar se iestá no conjunto com a idéia do Zgarb de verificar apenas os valores iniciais no conjunto. Agora também podemos usar <subconjuntos estritos porque itambém devem ser incluídos.

47 bytes:

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

Verifica se alguma rolagem do dado é o início de um pequeno conjunto reto. Agradecemos ao Zgarb pela idéia de apenas verificar os valores iniciais na lista, economizando 5 bytes.

O Python 3.5 possui uma conversão de conjunto mais curta, para 45 bytes

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

É o mesmo comprimento para fazer {*range(i,i+4)}como {i,i+1,i+2,i+3}.

Labirinto, 41 bytes

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

Uma resposta colaborativa com @ MartinBüttner. Acho que esprememos este muito além das minhas expectativas iniciais.

A saída é 1para verdade, vazia para falsidade. Experimente online!

Explicação rápida

Converta cada número nem um número inteiro binário 1 seguido de n+1zeros, ou seja 2^(n+1). Bit a bit OU os resultados e verifique 1111(em binário). A exponenciação precisa ser implementada manualmente no Labirinto.

Explicação detalhada

A cartilha usual:

• Labyrinth é uma linguagem de programação 2D baseada em pilha. Para memória, há uma pilha principal e uma pilha auxiliar, e saltar de uma pilha vazia produz 0 em vez de um erro.
• Em cada junção, onde o ponteiro da instrução pode se mover por dois ou mais caminhos possíveis, a parte superior da pilha é verificada para decidir para onde ir. O negativo é deixado, o zero é encaminhado, o positivo é correto.
• Os dígitos no Labyrinth não empurram o dígito correspondente para a pilha; em vez disso, eles aparecem ne empurram n*10 + <digit>. Para iniciar um novo número, _empurra zero.

Configuração

A execução começa no canto superior esquerdo, com o ponteiro de instruções voltado para a direita. Executamos:

=        Swap tops of main and auxiliary stacks
|        Bitwise OR

Além de efetivamente empurrar zeros, essas instruções não alteram a pilha.

Loop esquerdo: exponencial e OR bit a bit

O labirinto não possui exponenciação, por isso precisamos implementá-lo manualmente. Primeiro, lemos um número inteiro com ?e, como isso é garantido, vira à direita. _1empurra 1 e entramos no loop interno.

O loop interno faz o seguinte:

(       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

Como esse é um loop do-while, para entrada, nesse cálculo é calculado 2^(n+1). Terminamos com a entrada zerada na pilha e 30transforma esse zero em 30. Em seguida, executamos as mesmas instruções da instalação, mas desta vez elas são realmente úteis.

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

Esse loop continua para cada número na entrada até EOF, quando ?retorna 0. Isso nos faz avançar, em vez de virar, levando a ...

Bridge: alguma configuração extra

O 30após as ?voltas a 0 de EOF em 30, que é accionado para a pilha auxiliar via }. De importância é o fato de termos empurrado um 30 para a pilha auxiliar para cada número de entrada; portanto, agora a pilha auxiliar contém 5 + 1 = 6cópias do número 30 .

Enquanto isso, a pilha principal contém o OR bit a bit de 2^(n+1)cada entrada n. Vamos chamar isso de OR bit a bit b, uma vez que é modificado no loop certo.

Laço direito: verifique o resultado e a saída

Aqui está o que acontece no loop do lado direito:

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

Agora, a rescisão é um pouco complicada com este programa. Aqui estão as maneiras possíveis de o programa terminar:

• Após 3 iterações do loop direito, e bainda é positivo: Lembre - se de como colocamos seis 30s na pilha auxiliar? Como usamos dois deles em cada iteração, na quarta iteração, começamos a extrair zeros da parte inferior da pilha auxiliar. Isso causa uma divisão por zero quando o fazemos {/, e o programa termina.

• Depois de dar 1 para uma sequência pequena : executamos !e vimos à direita no "entroncamento no-op . Em seguida, entramos em uma montanha-russa quando começamos a engatinhar pela metade esquerda novamente:

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.

Depois de algumas viagens no exponenciador, a pilha se parece com algo que equivale [12 | 30 30]a zero por divisão após outras duas iterações no loop direito.

• Depois que b se torna zero em algum momento : A chave aqui é que o :loop direito está em uma junção. Se a entrada fosse, digamos,, 1 1 1 1 1então bseria 4, então 2, então 1, 0depois da terceira iteração. Em vez de virar no :, o IP agora segue em frente, e algo como o caso anterior causa um encerramento final.

Em suma, é uma bagunça como o programa termina, mas ei qualquer coisa para salvar esses poucos 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

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

Semelhante à resposta do @ xnor , ou seja, verifique se alguma das retas pequenas está na lista de entradas. Na verdade, estou testando todas as "pequenas retas" (ou seja, 4 números consecutivos) começando com qualquer um dos números da lista de entrada, alguns deles são inválidos e, portanto, sempre falham no allteste e não distorcem o anyteste, por exemplo [5,6,7,8].

Edit: @Zgarb salvou 5 bytes. Obrigado!

MATL, 11 bytes

udY'w1=)2>a

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

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

retorna truepor verdade e falsepor falsidade.

Como funciona

Retorne se algum valor em [0, 1, 2, 3] cumprir a condição de que para cada valor em [0, 1, 2, 3] a soma desses dois valores esteja na matriz de entrada.

Portanto, retorne se a matriz tiver todo valor em [0, 1, 2, 3] (impossível), [1, 2, 3, 4], [2, 3, 4, 5] ou [3, 4, 5 6].

Ruby, 31

Em vez de tentar ser inteligente como a primeira resposta do Ruby , isso passa pela matriz de números inteiros e, para cada número inteiro, verifica se há uma pequena reta na entrada começando com esse número inteiro. Não se preocupa com os possíveis valores ou singularidade.

Parece estar usando o mesmo algoritmo da resposta de Sherlock .

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

Ruby, 58 55 50 47 43 33 bytes

Acabei de ver que fui derrotado pela resposta de Paul em Ruby . Não estou intimidado no entanto, pois acho que isso ainda pode ser uma resposta decente com um pouco mais de golfe. Baseado, em parte, na resposta Python do xnor .

Edit: Alguns jogando golfe e corrigindo uma confusão no condicional ternário.

Edit: Agora eu uso .any?como Não, que Charles faz em sua resposta Ruby, mas apenas porque eu precisava de uma maneira simples de remover ae retornar apenas uma verdade e uma falsey com !([*i..i+3]-l)[0]uma vez .mapque retornaria uma matriz de truee false.

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

Retorna 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

Nota importante: Para aqueles que desejam usar o (a2 - a1).empty?código para determinar se todos os elementos de a2estão a1, observe que, se você quiser garantir que, por exemplo, [2,1,2]esteja na [1,2,3,3]multiplicidade de elementos, precisará de outro código. Discussão relevante sobre esse problema aqui .

Japonês, 13 12 bytes

Uá4 d@7o ¬fX

Teste online! ou Verifique todos os casos de teste .

Como 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

Inclui +1 para -p

Execute com a sequência em STDIN, por exemplo

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

smallstraight.pl:

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

Explicação

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>

Gera uma sequência não vazia para casos de teste de verdade e uma sequência vazia para casos falsos.

Suíte de teste.

Explicação

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.

No final do programa, essa lista é achatada em uma única sequência e impressa em STDOUT. Se alguma das retas pequenas for encontrada, seus elementos restantes estarão na sequência. Caso contrário, todas as listas estavam vazias e, portanto, a sequência também estará vazia.

05AB1E , 9 8 10 bytes

Verdade é que contém uma matriz na saída, falso é quando nenhuma saída é produzida. Código:

œvy¦¥1QPiy

Explicação desatualizada :

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

Experimente online!

Usa a codificação 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

graças à ETHproductions por ajudar a economizar vários 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)

Teste

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

ou: (mesmo 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;}

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
}

Edição grande: Acabei de perceber que eu só preciso postar uma função, não um programa inteiro. Isso economiza muito. Sem clichês, sem necessidade de converter a entrada de strings em números, etc. Agora, na verdade, estamos nos aproximando de um número respeitável de bytes (de qualquer maneira para um idioma que não seja de golfe).

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

Quinta tentativa (40 bytes):

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

Usa a sintaxe lambda para definir a função. (Agradecemos a Ruby golfista @ Sherlock9 por essa ideia.)

Para testar usando a chamada lambda:

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

Quarta tentativa:

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

Substituído zero? e negação com o operador ===.

Terceira tentativa:

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

Usa expressão regular.

Segunda tentativa:

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

A nova abordagem usa desduplicação (uniq), classificação e associação, além de incluir? para procurar uma correspondência de qualquer solução na entrada renderizada como uma sequência.

Primeira tentativa: 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

Testador:

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

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

Usa deduplicação (função uniq) mais interseção definida (& operador) para testar se alguma das boas seqüências corresponde à sequência especificada. Nenhuma classificação necessária.

Pyth, 13 11

@.PQ4.:S6 4

2 bytes graças a Jakube!

Retorna uma lista não vazia para verdade, lista vazia para falsidade.

Experimente online ou execute o Test Suite (dividido por um erro de sintaxe no 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

Sério, 21 bytes

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

Experimente online!

Emite um valor positivo para true e um 0 para false.

Explicação:

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

Provavelmente isso pode ser ainda mais complicado, mas como começo:

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

Não vejo uma maneira de reduzir a duplicação sem usar mais espaço; esta versão tem 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

Input é uma única sequência de números inteiros, como 13342. A saída é a 1se encontrada, ou a 0se não for.

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

Observe que a remoção de duplicatas precisa ocorrer apenas uma vez, pois existem apenas cinco números. A necessidade de remover mais de um número significaria que não há uma pequena reta de qualquer maneira.

Experimente online

Agradecemos a Martin pela idéia de mover as vírgulas dentro dos grupos de captura, economizando 16 bytes.

Pitão, 11 bytes

f!-TQ.:S6 4

Suíte de teste

Gere o comprimento 4 substrings de [1..6] e depois filtre-os em nenhum elemento restante quando os elementos da entrada forem removidos.

Geléia, 9 bytes

Tem que haver uma solução de 8 bytes, continuará pesquisando ... Código:

Œ!Ḋ€Iµ7Be

É o mesmo que minha solução 05AB1E .

Explicação:

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

Experimente online!

Geléia, 8 bytes

6Rṡ4ḟ€ċ“

Experimente online! ou verifique os casos de teste de verdade e os casos de teste de falsidade .

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

Testador:

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

Isso leva o número 62 (111110 em binário). Para cada número na matriz de entrada ele remove esse bit

O número resultante deve ser

100000 or
000000 or
000010 or
000110 or
000100

então eu verifico se o resultado é menor que 7 (0000111) ou se é igual a 32 (100000)

TI-BASIC, 25 bytes

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

Uma expressão Python equivalente (não destruída) que você pode testar :

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

A idéia por trás disso é divisibilidade. Para verificar se a 1, 2, 3, 4, 2, 3, 4, 5ou 3, 4, 5, 6ocorre, podemos mapear os números de 1 a 6 a 37 a 42 e depois multiplicar os números corretos.

Cada um dos números em [37,42] possui um fator primo que os outros números não possuem.

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

Portanto, se o produto dos cinco números é divisível por 37, a lista original continha um 1. Se por 19, continha um 2; etc Se é divisível por 37*19*13*5= 65*703, ele contém 1, 2, 3, e 4e similarmente para os outros dois números.

Esta solução é uma melhoria de uma que a @Weregoose postou em 2009.

Caxumba, 113 78 bytes

A versão do Mumps que estou usando é o InterSystems Cache.

Não consigo pensar em uma maneira de jogar essa técnica mais curta; com uma técnica diferente, pode ser possível, mas por enquanto isso funciona e, pelo menos, é mais curto que o C ++ ... mas não muito. De qualquer forma...

OK, aqui está uma maneira mais curta. Em vez de ter 3 variáveis ​​separadas para execuções curtas, use uma única variável para todos os 6 'dados' e extraia as partes posteriormente:

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 mim não encontrar uma maneira melhor com a mesma técnica ... eu deveria olhar antes de pular, hein? ;-)

Deixarei minha resposta original abaixo para fins 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

e aqui está a explicação do que está acontecendo com o 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.

Não testei todas as entradas verdadeiras e falsas, pois envolviam digitar manualmente todas; mas testei aproximadamente a primeira metade de cada uma, verifiquei que as retas longas ainda mostram verdade e várias corridas observadas não necessariamente funcionam corretamente ([4,2,5,3,4], [1,2,3,3 , 4] etc.) e parece estar funcionando corretamente.

Dyalog APL , 15 bytes

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

usa ⎕IO=0

⍳4 é 0 1 2 3

⍵∘.+⍳4 é 5 × 4 uma matriz de cada dado incrementada por cada um dos ⍳4

⍵∊⍨ verifica se os elementos da matriz estão na mão, o resultado é uma matriz booleana (0 ou 1), precisamos encontrar uma linha de todos os 1s

∧/ é a redução por linhas, result é um vetor booleano

∨/ é a redução ou redução desse vetor

Jelly, 11

QṢṡ4ðfø6Rṡ4

Experimente online!

Esta é praticamente uma cópia da minha resposta Pyth, apenas tentando descobrir como encadear coisas. Parece que deveria ser jogável.

Expansão:

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 você quiser fazer perguntas difíceis, como por que os separadores são diferentes, minha resposta é: "Responderei em 6 a 8 semanas": P (Mais sério, acho que é o padrão de correspondência, mônada-díade vs nilad-díade, mas eu não sei e não quero espalhar desinformação.)