В игре Yahtzee игроки бросают пять шестигранных кубиков и пытаются создать определенные руки, чтобы набрать очки. Одной из таких рук является небольшая стрит : четыре последовательных числа, не обязательно по порядку. Три возможные небольшие стрит 1, 2, 3, 4, 2, 3, 4, 5и 3, 4, 5, 6.

Например, [3, 5, 6, 1, 4]содержит небольшой прямой [3, 4, 5, 6].

вход

Несортированный список из пяти целых чисел, каждое от 1 до 6 включительно, представляющих руку Яхтзе.

Выход

Истинное значение, если рука содержит маленькую стрит, а в противном случае - ложное значение.

Контрольные примеры

Truthy:

[[1, 2, 3, 3, 4], [1, 2, 3, 4, 5], [3, 5, 6, 1, 4], [1, 5, 3, 4, 6], [4, 5, 2, 3, 5], [1, 4, 3, 2, 2], [5, 4, 3, 6, 3], [5, 3, 5, 4, 6], [2, 4, 5, 1, 3], [3, 6, 4, 5, 3], [5, 6, 4, 3, 5], [4, 5, 3, 6, 3], [4, 5, 5, 3, 2], [4, 5, 2, 3, 5], [4, 6, 5, 3, 6], [4, 2, 3, 1, 5], [3, 6, 4, 6, 5], [5, 2, 1, 3, 4], [4, 4, 1, 2, 3], [4, 1, 4, 2, 3], [5, 1, 4, 3, 6], [5, 2, 2, 3, 4], [4, 4, 6, 5, 3], [2, 4, 3, 5, 1], [5, 4, 2, 5, 3], [2, 3, 5, 5, 4], [1, 6, 3, 4, 5], [4, 5, 3, 3, 6], [6, 4, 3, 6, 5], [4, 6, 6, 5, 3], [4, 3, 5, 2, 2], [2, 3, 2, 1, 4], [4, 2, 6, 1, 3], [4, 4, 5, 3, 6], [4, 5, 6, 3, 6]]

Falsy:

[[1, 2, 3, 5, 6], [5, 1, 1, 6, 6], [4, 6, 4, 1, 1], [6, 4, 1, 6, 4], [4, 6, 3, 6, 6], [2, 1, 4, 6, 4], [2, 6, 1, 5, 6], [2, 6, 1, 5, 6], [3, 6, 5, 3, 2], [3, 2, 3, 5, 3], [5, 5, 6, 2, 3], [3, 4, 6, 4, 3], [1, 4, 5, 5, 1], [1, 4, 4, 4, 1], [1, 6, 5, 1, 4], [6, 6, 4, 5, 4], [5, 3, 3, 3, 2], [5, 2, 1, 5, 3], [3, 5, 1, 6, 2], [6, 4, 2, 1, 2], [1, 3, 1, 3, 2], [3, 1, 3, 4, 3], [4, 3, 1, 6, 3], [4, 6, 3, 3, 6], [3, 6, 3, 6, 4], [1, 1, 3, 1, 3], [5, 5, 1, 3, 2], [3, 4, 2, 6, 6], [5, 4, 2, 6, 1], [2, 4, 4, 5, 4], [3, 6, 2, 5, 5], [2, 5, 3, 5, 1], [3, 2, 2, 3, 4], [5, 2, 2, 6, 2], [5, 6, 2, 5, 6]]

_{Вдохновленный этим}

Каталог

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 байт

Большое спасибо @lirtosiast за удаление 2 байтов

ud7BXf

Истина - это массив ненулевых значений. Falsy - пустой массив (без вывода данных).

Начиная с версии 16.2.0, uстабильно по умолчанию. Таким образом, Sдля сортировки вывода требуется дополнительный код : uSd7BXf( 7 байт ). Ссылка включает в себя эту модификацию.

Попробуйте онлайн!

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 байта

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

Вернуться через 9 месяцев с улучшением. Нам не нужно проверять, есть ли iв наборе идея Згарба о проверке только начальных значений в наборе. Теперь мы можем также использовать <для строгих подмножеств, потому что iтакже должны быть включены.

47 байт:

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

Проверяет, есть ли броски кубика, это начало небольшого стрита. Спасибо Zgarb за идею проверки только начальных значений в списке, экономя 5 байтов.

Python 3.5 имеет более короткий набор преобразований, на 45 байт

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

Это та же длина сделать {*range(i,i+4)}так {i,i+1,i+2,i+3}.

Лабиринт, 41 байт

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

Совместный ответ с @ MartinBüttner. Я думаю, что мы сжали это далеко за пределы моих первоначальных ожиданий.

Выход 1для правдивых, пустой для ложных. Попробуйте онлайн!

Быстрое объяснение

Преобразование каждого числа nв двоичное целое число 1 с последующими n+1нулями, то есть 2^(n+1). Побитовое ИЛИ результаты и проверьте 1111(в двоичном виде). Возведение в степень должно быть осуществлено вручную в Лабиринте.

Детальное объяснение

Обычный праймер:

• Лабиринт - это основанный на стеке двумерный язык программирования. Для памяти есть основной стек и вспомогательный стек, а выталкивание из пустого стека дает 0, а не ошибку.
• На каждом соединении, где указатель инструкции может двигаться вниз по двум или более возможным путям, верхняя часть стека проверяется, чтобы решить, куда идти дальше. Отрицательный слева, ноль вперед, положительный справа.
• Цифры в Лабиринте не помещают соответствующую цифру в стек, скорее они nвыталкивают и толкают n*10 + <digit>. Чтобы начать новый номер, _толкает ноль.

Настроить

Выполнение начинается в верхнем левом углу, указатель инструкции направлен вправо. Мы выполняем:

=        Swap tops of main and auxiliary stacks
|        Bitwise OR

Помимо эффективного нажатия на нули, эти инструкции не меняют стек.

Левый цикл: возведение в степень и побитовое ИЛИ

Лабиринт не имеет возведения в степень, поэтому нам нужно реализовать его вручную. Сначала мы читаем целое число с ?, и, поскольку это гарантированно будет положительным, мы поворачиваем направо. _1нажимаем 1 и мы входим во внутренний цикл.

Внутренний цикл делает следующее:

(       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

Поскольку это цикл do-while, для ввода nрассчитывается 2^(n+1). Мы заканчиваем 30нулевым вводом в стеке и превращаем этот ноль в 30. Затем мы выполняем те же инструкции из установки, но на этот раз они действительно полезны.

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

Этот цикл продолжается для каждого числа на входе до EOF, когда ?возвращается 0. Это заставляет нас двигаться вперед, а не поворачиваться, приводя к ...

Мост: некоторые дополнительные настройки

После 30того, как ?превращает 0 из EOF в 30, который вставляется во вспомогательный стек через }. Важным является тот факт, что мы помещали 30 во вспомогательный стек для каждого входного числа, поэтому теперь вспомогательный стек содержит 5 + 1 = 6копии числа 30 .

Между тем, основной стек содержит побитовое ИЛИ 2^(n+1)для каждого входа n. Давайте назовем это побитовым ИЛИ b, так как оно модифицируется в правильном цикле.

Правый цикл: проверить результат и вывод

Вот что происходит в правой части цикла:

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

Теперь завершение немного сложнее с этой программой. Вот возможные пути завершения программы:

• После 3 итераций правого цикла, и bвсе еще положительно: Помните, как мы поместили шесть 30-х во вспомогательный стек? Поскольку мы используем два из них в каждой итерации, на четвертой итерации мы начинаем вытягивать нули из нижней части вспомогательного стека. Это вызывает деление на ноль, когда мы делаем {/, и программа завершается.

• После вывода 1 для небольшого стрита : Итак, мы выполнили, !затем повернули направо на "перекрестке без операции . Затем нас ждут американские горки, и мы снова начинаем ползать по всей левой половине:

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.

После нескольких поездок в экспоненте, стек выглядит примерно так [12 | 30 30], который выдает ошибку делением на ноль после двух других итераций в правом цикле.

• После того, как b становится равным нулю в какой-то момент : ключ здесь в том, что :в правом цикле находится на стыке. Если бы вход был, скажем, то 1 1 1 1 1, то bбыл бы 4, тогда 2, тогда 1, 0после третьей итерации. Вместо того, чтобы поворачиваться в :, IP теперь движется прямо вперед, и что-то похожее на предыдущий случай может привести к возможному завершению.

В общем, это беспорядок, как программа завершается, но что угодно, чтобы сохранить эти несколько байтов!

Mathematica, 39 43 44 31 39 44 байта

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

Haskell, 39 34 байта

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

Пример использования: f [1,2,3,3,4]-> True.

Аналогичен ответу @ xnor , т. Е. Проверьте, есть ли какие-либо небольшие прямые в списке ввода. На самом деле я тестирую все «маленькие прямые» (то есть 4 последовательных числа), начиная с любого из чисел из списка ввода, некоторые из них являются недействительными и поэтому всегда не проходят allтест и не искажают anyтест, например [5,6,7,8].

Редактировать: @Zgarb сохранил 5 байтов. Благодарность!

MATL, 11 байт

udY'w1=)2>a

Попробуйте онлайн

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 байта

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

возвращается trueза правдой и falseложью.

Как это работает

Возврат, если какое-либо значение в [0, 1, 2, 3] удовлетворяет условию, что для каждого значения в [0, 1, 2, 3] сумма этих двух значений находится во входном массиве.

Итак, верните, если массив имеет все значения в [0, 1, 2, 3] (невозможно), [1, 2, 3, 4], [2, 3, 4, 5] или [3, 4, 5 , 6].

Руби, 31

Вместо того, чтобы пытаться быть умным, как первый ответ Ruby , он просто просматривает массив целых чисел и для каждого целого числа видит, есть ли небольшая прямая на входе, начинающаяся с этого целого числа. Не беспокоиться о возможных значениях или уникальности.

Похоже, что он использует тот же алгоритм, что и ответ Шерлока .

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

Рубин, 58 55 50 47 43 33 байта

Я только сейчас увидел, что меня избил ответ Пола Руби . Однако я не сдерживаюсь, так как думаю, что это все еще может быть достойным ответом с еще большим количеством игры в гольф. Частично основано на ответе xnor на Python .

Редактировать: немного игры в гольф и исправление путаницы в троичной условно.

Редактировать: я теперь использую, .any?как не то, что Чарльз делает в своем ответе на Ruby, но только потому, что мне нужен был простой способ удалить aи вернуть только правду и ложь с, !([*i..i+3]-l)[0]так .mapкак возвращал бы массив trueи false.

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

Возвращает либо trueили 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

Важное замечание: Для тех , кто хочет использовать (a2 - a1).empty?код , чтобы определить, все ли элементы a2в a1, заметим , что если вы хотите , чтобы убедиться , что сделать, например, [2,1,2]в [1,2,3,3]кратности элементов, вам нужен другой код. Актуальное обсуждение этой проблемы здесь .

Japt, 13 12 байт

Uá4 d@7o ¬fX

Проверьте это онлайн! или Проверьте все контрольные примеры .

Как это работает

       // 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 байт

Включает +1 для -p

Запустите с последовательностью на STDIN, например,

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

smallstraight.pl:

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

объяснение

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 байт

7,4ewl~f&3f>

Возвращает непустую строку для истинных тестовых случаев и пустую строку для ложных.

Тестирование.

объяснение

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.

В конце программы этот список сведен в одну строку и напечатан в STDOUT. Если были обнаружены какие-либо из небольших прямых, их оставшиеся элементы будут в строке. В противном случае все списки были пусты, и поэтому строка также пуста.

05AB1E , 9 8 10 байт

Истина содержит массив в выводе, ложь - когда вывод не производится. Код:

œvy¦¥1QPiy

Объяснение устарело :

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

Попробуйте онлайн!

Использует кодировку CP-1252 .

Javascript ES6 47 байт

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

Javascript ES6 52 байта

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 байта

спасибо ETHproductions за помощь в сохранении нескольких байтов

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)

тестирование

//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 байтов

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

или: (такое же количество байтов)

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: только что понял, что мне нужно опубликовать функцию, а не целую программу. Это экономит много. Нет шаблонов, нет необходимости преобразовывать строковый ввод в числа и т. Д. Теперь мы приближаемся к порядочному числу байтов (во всяком случае, для языка без игры в гольф).

Рубин - 80 -> 79 -> 76 -> 54 -> 48 -> 40 байтов

Пятая попытка (40 байт):

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

Использует лямбда-синтаксис для определения функции. (Спасибо конкурирующему Ruby golfer @ Sherlock9 за эту идею.)

Чтобы проверить использование лямбда-вызова:

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

Четвертая попытка:

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

Заменил ноль? и отрицание с оператором ===.

Третья попытка:

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

Использует регулярное выражение.

Вторая попытка:

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

Новый подход использует dedup (uniq), сортировку и объединение, плюс включают? искать совпадения любых решений во входных данных, представленных в виде строки.

Первая попытка: 79 байт

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

Tester:

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

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

Используется дедупликация (функция uniq) плюс установка пересечения (& оператор), чтобы проверить, соответствует ли какая-либо из хороших последовательностей данной последовательности. Сортировка не требуется.

Pyth, 13 11

@.PQ4.:S6 4

2 байта благодаря Якубе!

Возвращает непустой список для правдивого, пустой список для ложных.

Попробуйте онлайн или запустите Test Suite (разделенный синтаксической ошибкой для Readability ™).

PHP, 95 байт

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

Серьезно, 21 байт

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

Попробуйте онлайн!

Выводит положительное значение для true и 0 для false.

Объяснение:

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 байт

Это, вероятно, может быть дальше, но для начала:

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

Я не вижу способа уменьшить дублирование, не используя больше места; эта версия составляет 75 байт:

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

Сетчатка , 70 54 байта

Ввод - это одна строка из целых чисел 13342. Выход - 1если найден, или 0если нет.

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

Обратите внимание, что удаление дубликатов должно происходить только один раз, поскольку существует только пять чисел. Необходимость удалить более одного числа означала бы, что в любом случае нет маленькой прямой.

Попробуйте онлайн

Спасибо Мартину за идею перенести запятые в группы захвата, сэкономив колоссальные 16 байтов.

Pyth, 11 байт

f!-TQ.:S6 4

Тестирование

Сгенерируйте подстроки длиной 4 из [1..6], затем отфильтруйте их по отсутствующим элементам, когда элементы ввода удалены.

Желе, 9 байт

Должно быть 8-байтовое решение, продолжим поиск ... Код:

Œ!Ḋ€Iµ7Be

Это то же самое, что и мое решение 05AB1E .

Объяснение:

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

Попробуйте онлайн!

Желе, 8 байт

6Rṡ4ḟ€ċ“

Попробуйте онлайн! или проверьте достоверные контрольные примеры и ложные контрольные примеры .

Как это работает

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 байт

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

Tester:

val f = <code here>
val truthy = Seq(Seq(1, 2, 3, 3, 4), Seq(1, 2, 3, 4, 5), Seq(3, 5, 6, 1, 4), Seq(1, 5, 3, 4, 6), Seq(4, 5, 2, 3, 5), Seq(1, 4, 3, 2, 2), Seq(5, 4, 3, 6, 3), Seq(5, 3, 5, 4, 6), Seq(2, 4, 5, 1, 3), Seq(3, 6, 4, 5, 3), Seq(5, 6, 4, 3, 5), Seq(4, 5, 3, 6, 3), Seq(4, 5, 5, 3, 2), Seq(4, 5, 2, 3, 5), Seq(4, 6, 5, 3, 6), Seq(4, 2, 3, 1, 5), Seq(3, 6, 4, 6, 5), Seq(5, 2, 1, 3, 4), Seq(4, 4, 1, 2, 3), Seq(4, 1, 4, 2, 3), Seq(5, 1, 4, 3, 6), Seq(5, 2, 2, 3, 4), Seq(4, 4, 6, 5, 3), Seq(2, 4, 3, 5, 1), Seq(5, 4, 2, 5, 3), Seq(2, 3, 5, 5, 4), Seq(1, 6, 3, 4, 5), Seq(4, 5, 3, 3, 6), Seq(6, 4, 3, 6, 5), Seq(4, 6, 6, 5, 3), Seq(4, 3, 5, 2, 2), Seq(2, 3, 2, 1, 4), Seq(4, 2, 6, 1, 3), Seq(4, 4, 5, 3, 6), Seq(4, 5, 6, 3, 6))
val falsy = Seq(Seq(1, 2, 3, 5, 6), Seq(5, 1, 1, 6, 6), Seq(4, 6, 4, 1, 1), Seq(6, 4, 1, 6, 4), Seq(4, 6, 3, 6, 6), Seq(2, 1, 4, 6, 4), Seq(2, 6, 1, 5, 6), Seq(2, 6, 1, 5, 6), Seq(3, 6, 5, 3, 2), Seq(3, 2, 3, 5, 3), Seq(5, 5, 6, 2, 3), Seq(3, 4, 6, 4, 3), Seq(1, 4, 5, 5, 1), Seq(1, 4, 4, 4, 1), Seq(1, 6, 5, 1, 4), Seq(6, 6, 4, 5, 4), Seq(5, 3, 3, 3, 2), Seq(5, 2, 1, 5, 3), Seq(3, 5, 1, 6, 2), Seq(6, 4, 2, 1, 2), Seq(1, 3, 1, 3, 2), Seq(3, 1, 3, 4, 3), Seq(4, 3, 1, 6, 3), Seq(4, 6, 3, 3, 6), Seq(3, 6, 3, 6, 4), Seq(1, 1, 3, 1, 3), Seq(5, 5, 1, 3, 2), Seq(3, 4, 2, 6, 6), Seq(5, 4, 2, 6, 1), Seq(2, 4, 4, 5, 4), Seq(3, 6, 2, 5, 5), Seq(2, 5, 3, 5, 1), Seq(3, 2, 2, 3, 4), Seq(5, 2, 2, 6, 2), Seq(5, 6, 2, 5, 6))
println("Failed truthy: " + truthy.filterNot(f))
println("Failed falsy: " + falsy.filter(f))

Javascript ES6 43 байта

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

Это берет число 62 (111110 в двоичном формате) Для каждого числа во входном массиве это удаляет тот бит

Полученное число должно быть

100000 or
000000 or
000010 or
000110 or
000100

поэтому я проверяю, является ли результат меньше 7 (0000111) или равен 32 (100000)

TI-BASIC, 25 байтов

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

Эквивалентное (ungolfed) выражение Python, которое вы можете проверить :

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

За этим стоит идея делимости. Чтобы проверить , является ли 1, 2, 3, 4, 2, 3, 4, 5или 3, 4, 5, 6происходит, мы можем сопоставить число 1-6 до 37-42, а затем умножить правильные цифры вместе.

Каждое из чисел в [37,42] имеет главный фактор, которого нет у других чисел.

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

Следовательно, если произведение пяти чисел делится на 37, исходный список содержал 1. Если на 19 он содержал 2; и т.д. Если он делится на 37*19*13*5= 65*703, она содержит 1, 2, 3, и 4аналогично для двух других чисел.

Это решение является улучшением того, которое @Weregoose опубликовал в 2009 году.

Свинка 113 78 байт

Версия Mumps, которую я использую, - InterSystems Cache.

Я не могу придумать способ игры в гольф покороче; с другой техникой это может быть возможно, но сейчас это подойдет и, по крайней мере, короче, чем C ++ ... но ненамного. Так или иначе...

Хорошо, вот более короткий путь. Вместо трех отдельных переменных для коротких серий используйте одну переменную для всех 6 кубиков и извлеките порции позже:

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)

так много для меня, что я не могу найти лучший способ с той же техникой ... Я должен посмотреть, прежде чем прыгнуть, а? ;-)

Я оставлю свой оригинальный ответ ниже для исторических целей ...

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

и вот объяснение того, что происходит с кодом:

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.

Я не проверял каждый ввод правдивых и ложных данных, так как он вводил их вручную; но я проверил примерно первую половину каждого, проверил, что длинные стриты все еще показывают правдивость, и некоторые из прогонов, отмеченных как не обязательно работающие правильно ([4,2,5,3,4], [1,2,3,3 , 4] и т. Д.) И, кажется, работает правильно.

Дьялог АПЛ , 15 байт

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

использования ⎕IO=0

⍳4 является 0 1 2 3

⍵∘.+⍳4 5 × 4 матрица каждого кристалла, увеличенная на каждый из ⍳4

⍵∊⍨ проверяет, находятся ли элементы матрицы в руке, результат - логическая (0-или-1) матрица, нам нужно найти строку всех 1

∧/ - и-сокращение по строкам, результат - логический вектор

∨/ или сокращение этого вектора

Желе, 11

QṢṡ4ðfø6Rṡ4

Попробуйте онлайн!

Это в значительной степени копия моего ответа Pyth, просто пытаюсь понять, как связать вещи. Чувствуется, что это должно быть пригодным для игры в гольф.

Расширение:

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]

Если вы хотите задать какие-либо сложные вопросы, например, почему разделители отличаются, то я отвечу вам: «Я отвечу через 6-8 недель»: P (Более серьезно, я думаю, что это сопоставление с образцом, monad-dyad против нилад-диад, но я не знаю и не хочу распространять дезинформацию.)