У грі 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]]

Фальсі:

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

Truthy - це масив ненульових значень. 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

Пітон, 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

Оскільки це цикл до-час, для введення 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 тепер рухається прямо вперед, і щось подібне до попереднього випадку відбувається, щоб викликати можливе припинення.

Загалом, це безлад, як програма закінчується, але прислухайтеся до всього, щоб зберегти ці кілька байтів!

Математика, 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

Замість того, щоб намагатися бути розумним, як перша відповідь Рубі , це просто проходить через масив цілих чисел, і для кожного цілого числа бачить, чи є невеликий прямий на вході, починаючи з цього цілого числа. Не хвилює можливих значень чи унікальності.

Це, здається, використовує той же алгоритм, що і відповідь Шерлока .

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

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

Щойно я побачив, що мене побили ударом у відповідь Пауля Рубі . Я, однак, не відлякуюсь, оскільки я думаю, що це все-таки може бути гідною відповіддю з додатковим гольфом. Частково ґрунтуючись на відповіді Pynor на xnor .

Редагувати: Дещо гольф і виправлення змішування в потрійному умовному.

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

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

Повертається або true або false.

Безголівки:

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

Truthy містить масив у висновку, помилковим є те, коли вихід не виробляється. Код:

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

Безголівки:

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}

Для визначення функції використовується синтаксис лямбда. (Завдяки конкуренції Рубі гольфіст @ 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

Тестер:

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

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

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

Pyth, 13 11

@.PQ4.:S6 4

2 байти завдяки Jakube!

Повертає не порожній список для правдивого, порожній список для помилки.

Спробуйте в Інтернеті або запустіть тестовий набір (розділений на синтаксичну помилку для читабельності ™).

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Σ

Спробуйте в Інтернеті!

Виводить позитивне значення для істинного та 0 для хибного.

Пояснення:

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ḟ€ċ“

Спробуйте в Інтернеті! або перевірки тестових випадків truthy і falsy тестових випадків .

Як це працює

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)

Тестер:

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

Еквівалентний вираз (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, початковий список містив a 1. Якщо до 19, він містив 2; і т.д. Якщо він ділиться на 37*19*13*5= 65*703, вона містить 1, 2, 3, і4 аналогічно для двох інших чисел.

Це рішення є удосконаленням одного , що @Weregoose писав в 2009 році.

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

Версія Mumps, яку я використовую, - це кеш InterSystems.

Я не можу придумати спосіб гольфу в цій техніці коротше; з іншою технікою це може бути можливим, але поки це буде зроблено, і принаймні це коротше, ніж 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] тощо) і, здається, працює правильно.

Діалог APL , 15 байт

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

використовує ⎕IO=0

⍳4 є 0 1 2 3

⍵∘.+⍳4 дорівнює 5 × 4 матриці кожної матриці, що збільшується кожним з ⍳4

⍵∊⍨ перевіряє, чи є елементи матриці в руці, результат - булева (0-або-1) матриця, нам потрібно знайти рядок усіх 1s

∧/ - і -редукція по рядках, результат - булевий вектор

∨/ - або зменшення цього вектора

Желе, 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 (Більш серйозно, я думаю, що це відповідність шаблону, монада-діада проти nilad-dyad, але я не знаю і не хочу поширювати дезінформацію.)