Im Spiel Yahtzee würfeln die Spieler mit fünf sechsseitigen Würfeln und versuchen, bestimmte Hände zu bilden, um Punkte zu erzielen. Eine solche Hand ist eine kleine Straße : vier aufeinanderfolgende Zahlen, nicht unbedingt in der richtigen Reihenfolge. Die drei möglichen kleinen Geraden sind 1, 2, 3, 4, 2, 3, 4, 5und 3, 4, 5, 6.

Zum Beispiel [3, 5, 6, 1, 4]enthält die kleine Gerade [3, 4, 5, 6].

Eingang

Eine unsortierte Liste mit fünf ganzen Zahlen zwischen 1 und 6 (einschließlich), die eine Yahtzee-Hand darstellen.

Ausgabe

Ein wahrer Wert, wenn die Hand eine kleine Straße und ansonsten einen falschen Wert enthält.

Testfälle

Wahrheit:

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

Falsch:

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

_{Davon inspiriert}

Katalog

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

Vielen Dank an @lirtosiast für das Entfernen von 2 Bytes

ud7BXf

Wahrheit ist ein Array von Werten ungleich Null. Falsy ist ein leeres Array (es wird keine Ausgabe angezeigt).

Ab Release 16.2.0 uist standardmäßig stabil. Der Code benötigt also ein Extra S, um die Ausgabe zu sortieren: uSd7BXf( 7 Bytes ). Der Link enthält diese Änderung.

Probieren Sie es 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)

Zurück nach 9 Monaten mit einer Besserung. Wir brauchen nicht zu prüfen, ob ies in der Menge ist, mit der Idee von Zgarb, nur Startwerte in der Menge zu prüfen. Wir können jetzt auch <für strenge Teilmengen verwenden, da diese iebenfalls einbezogen werden müssen.

47 Bytes:

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

Prüft, ob ein Würfelwurf der Anfang eines kleinen geraden Satzes ist. Vielen Dank an Zgarb für die Idee, nur die Startwerte in der Liste zu überprüfen und 5 Bytes zu sparen.

Python 3.5 hat eine kürzere Satzkonvertierung für 45 Bytes

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

Es ist genauso lang {*range(i,i+4)}wie {i,i+1,i+2,i+3}.

Labyrinth, 41 Bytes

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

Eine Antwort in Zusammenarbeit mit @ MartinBüttner. Ich denke, wir haben dies weit über meine ursprünglichen Erwartungen hinaus gequetscht.

Die Ausgabe ist 1für Wahres, leer für Falsches. Probieren Sie es online!

Schnelle Erklärung

Konvertieren Sie jede Zahl nin eine binäre Ganzzahl 1, gefolgt von n+1Nullen, dh 2^(n+1). Bitweise ODER die Ergebnisse und überprüfen Sie 1111(in Binär). Die Exponentiation muss manuell in Labyrinth implementiert werden.

Ausführliche Erklärung

Die übliche Grundierung:

• Labyrinth ist eine stapelbasierte 2D-Programmiersprache. Für den Speicher gibt es einen Hauptstapel und einen Hilfsstapel, und das Abspringen von einem leeren Stapel erzeugt eher eine 0 als einen Fehler.
• An jeder Kreuzung, an der sich der Befehlszeiger über zwei oder mehr mögliche Pfade bewegen könnte, wird die Oberseite des Stapels überprüft, um zu entscheiden, wohin er als Nächstes gehen soll. Negativ ist links, Null ist vorwärts, positiv ist rechts.
• Die Ziffern im Labyrinth drücken nicht die entsprechende Ziffer auf den Stapel, sondern platzen nund drücken n*10 + <digit>. _Drücken Sie die Null, um eine neue Nummer zu beginnen .

Installieren

Die Ausführung beginnt oben links mit dem Anweisungszeiger nach rechts. Wir führen aus:

=        Swap tops of main and auxiliary stacks
|        Bitwise OR

Abgesehen davon, dass effektiv Nullen gedrückt werden, ändern diese Anweisungen den Stapel nicht.

Linke Schleife: Potenzieren und bitweises ODER

Labyrinth hat keine Potenzierung, daher müssen wir es manuell implementieren. Zuerst lesen wir eine ganze Zahl mit ?, und da dies garantiert positiv ist, biegen wir rechts ab. _1drückt 1 und wir betreten die innere Schleife.

Die innere Schleife führt Folgendes aus:

(       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

Da dies eine do-while-Schleife ist, wird diese für die Eingabe nberechnet 2^(n+1). Wir beenden die Eingabe mit Null auf dem Stapel und 30wandeln diese Null in 30 um. Wir führen dann die gleichen Anweisungen aus dem Setup aus, aber diesmal sind sie tatsächlich nützlich.

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

Diese Schleife wird für jede Zahl in der Eingabe bis zu EOF fortgesetzt, wenn ?0 zurückgegeben wird. Dadurch bewegen wir uns vorwärts, anstatt uns zu drehen, und führen zu ...

Bridge: einige zusätzliche Einstellungen

Das 30nach dem ?dreht die 0 von EOF in 30, die über zum Zusatzstapel geschoben wird }. Von Bedeutung ist die Tatsache, dass wir für jede eingegebene Nummer eine 30 in den Zusatzstapel verschoben haben, sodass der Zusatzstapel5 + 1 = 6 jetzt Kopien der Nummer 30 enthält .

In der Zwischenzeit enthält der Hauptstapel das bitweise ODER von 2^(n+1)für jede Eingabe n. Nennen wir dies bitweises ODER b, da es in der rechten Schleife geändert wird.

Rechte Schleife: Ergebnis und Ausgabe prüfen

Folgendes passiert in der rechten Schleife:

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

Jetzt ist die Beendigung mit diesem Programm ein wenig schwierig. Hier sind die möglichen Möglichkeiten, wie das Programm beendet werden kann:

• Nach 3 Iterationen der rechten Schleife und bimmer noch positiv: Erinnern Sie sich, wie wir sechs 30s in den Hilfsstapel gelegt haben? Da wir bei jeder Iteration zwei davon verwenden, ziehen wir bei der vierten Iteration Nullen vom unteren Rand des Hilfsstapels. Dies führt zu einer Division durch Null {/, und das Programm wird beendet.

• Nach der Ausgabe einer 1 für eine kleine Straße : Also haben wir ausgeführt und sind !dann an der No-Op- "Kreuzung nach rechts abgebogen. Dann warten wir auf eine Achterbahnfahrt, während wir wieder über die linke Hälfte kriechen:

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.

Nach ein paar Schritten im Exponentiator sieht der Stack so aus, als ob er [12 | 30 30]nach zwei weiteren Iterationen in der rechten Schleife durch Division durch Null ausfällt.

• Nachdem b irgendwann zu Null wird : Der Schlüssel hier ist, dass sich :die rechte Schleife an einer Kreuzung befindet. Wenn die Eingabe beispielsweise wäre 1 1 1 1 1, dann bwäre es 4, dann 2, dann 1, 0nach der dritten Iteration. Anstatt sich umzudrehen :, bewegt sich die IP jetzt geradeaus, und so etwas wie der vorherige Fall führt zu einer eventuellen Beendigung.

Alles in allem ist es ein Chaos, wie das Programm endet, aber hey alles, um diese wenigen Bytes zu retten!

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

Anwendungsbeispiel: f [1,2,3,3,4]-> True.

Ähnlich wie bei der Antwort von @ xnor , dh überprüfen Sie, ob eine der kleinen Geraden in der Eingabeliste enthalten ist. Tatsächlich teste ich alle "kleinen Geraden" (dh 4 aufeinanderfolgende Nummern), beginnend mit einer der Nummern aus der Eingabeliste, von denen einige ungültig sind und daher den allTest immer nicht bestehen und den Test nicht verzerren any, z [5,6,7,8].

Edit: @Zgarb sparte 5 Bytes. Vielen Dank!

MATL, 11 Bytes

udY'w1=)2>a

Probieren Sie es online aus

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 Byte

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

kehrt truefür wahr und falsefür falsch.

Wie es funktioniert

Rückgabe, wenn ein Wert in [0, 1, 2, 3] die Bedingung erfüllt, dass sich für jeden Wert in [0, 1, 2, 3] die Summe dieser beiden Werte im Eingabearray befindet.

Geben Sie also zurück, wenn das Array alle Werte in [0, 1, 2, 3] (unmöglich), [1, 2, 3, 4], [2, 3, 4, 5] oder [3, 4, 5] enthält 6].

Rubin, 31

Anstatt zu versuchen, klug wie die erste Ruby-Antwort zu sein , wird nur das Array von Ganzzahlen durchlaufen und für jede Ganzzahl geprüft, ob die Eingabe eine kleine Gerade enthält, die mit dieser Ganzzahl beginnt. Kümmert sich nicht um die möglichen Werte oder die Eindeutigkeit.

Dies scheint den gleichen Algorithmus wie Sherlocks Antwort zu verwenden .

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

Ruby, 58 55 50 47 43 33 Bytes

Ich habe gerade gesehen, dass ich von Pauls Ruby-Antwort hart getroffen worden bin . Ich bin jedoch nicht davon abgeschreckt, da ich denke, dass dies mit etwas mehr Golf noch eine anständige Antwort sein könnte. Zum Teil basierend auf der Python-Antwort von xnor .

Edit: Etwas Golf spielen und eine Verwechslung in der ternären Bedingung korrigieren.

Edit: Ich benutze jetzt .any?wie Nicht, dass Charles in ihrer Ruby-Antwort tut, sondern nur, weil ich einen einfachen Weg brauchte, um eine Reihe von und zu entfernen aund nur eine Wahrheit und eine Falschheit mit !([*i..i+3]-l)[0]da .mapzurückzugeben .truefalse

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

Gibt entweder trueoder zurück 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

Wichtiger Hinweis: Für diejenigen, die verwendet werden soll (a2 - a1).empty?Code , um zu bestimmen , ob alle Elemente a2in sind a1, beachten Sie, dass , wenn Sie sicherstellen möchten , dass zum Beispiel [2,1,2]in ist [1,2,3,3]auf Vielzahl von Elementen, Sie anderen Code benötigen. Relevante Diskussion dieses Problems hier .

Japt, 13 12 Bytes

Uá4 d@7o ¬fX

Testen Sie es online! oder Überprüfen Sie alle Testfälle .

Wie es funktioniert

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

Beinhaltet +1 für -p

Führen Sie mit der Sequenz STDIN aus, z

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

smallstraight.pl:

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

Erläuterung

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>

Ergibt eine nicht leere Zeichenfolge für echte Testfälle und eine leere Zeichenfolge für falsche.

Testsuite.

Erläuterung

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.

Am Ende des Programms wird diese Liste zu einer einzigen Zeichenfolge zusammengefasst und an STDOUT ausgegeben. Wenn eine der kleinen Geraden gefunden wurde, befinden sich die verbleibenden Elemente in der Zeichenfolge. Ansonsten waren alle Listen leer und der String ist auch leer.

05AB1E , 9 8 10 Bytes

Wahrheit enthält ein Array in der Ausgabe, falsch ist, wenn keine Ausgabe erzeugt wird. Code:

œvy¦¥1QPiy

Erklärung veraltet :

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

Probieren Sie es online!

Verwendet die CP-1252- Codierung.

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

danke an ETHproductions für die hilfe mehrere bytes zu sparen

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)

Testen

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

oder: (gleiche Anzahl von 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
}

Big Edit: Hab gerade gemerkt, dass ich nur eine Funktion posten muss, nicht ein ganzes Programm. Das spart eine Menge. Kein Boilerplate, keine Notwendigkeit, Strings in Zahlen umzuwandeln usw. Jetzt nähern wir uns einer respektablen Anzahl von Bytes (für eine nicht-golfende Sprache jedenfalls).

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

Fünfter Versuch (40 Bytes):

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

Verwendet Lambda-Syntax, um die Funktion zu definieren. (Vielen Dank an Ruby Golfer @ Sherlock9 für diese Idee.)

So testen Sie mit Lambda-Aufruf:

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

Vierter Versuch:

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

Ersetzt nil? und Negation mit === Operator.

Dritter Versuch:

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

Verwendet regulären Ausdruck.

Zweiter Versuch:

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

Neuer Ansatz verwendet dedup (uniq), sortieren und verbinden sowie include? um nach einer Übereinstimmung aller Lösungen in der als Zeichenfolge gerenderten Eingabe zu suchen.

Erster Versuch: 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

Prüfer:

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

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

Verwendet Deduplizierung (Uniq-Funktion) plus Schnittmenge (& -Operator), um zu testen, ob eine der guten Sequenzen mit der angegebenen Sequenz übereinstimmt. Keine Sortierung nötig.

Pyth, 13 11

@.PQ4.:S6 4

2 Bytes dank Jakube!

Gibt eine nicht leere Liste für wahrheitsgemäß und eine leere Liste für falsch zurück.

Probieren Sie es online aus oder führen Sie die Test Suite aus (aufgeteilt durch einen Syntaxfehler für 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

Im Ernst, 21 Bytes

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

Probieren Sie es online!

Gibt einen positiven Wert für true und eine 0 für false aus.

Erläuterung:

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

Dies kann wahrscheinlich weiter golfen werden, aber zu Beginn:

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

Ich sehe keine Möglichkeit, die Duplizierung zu reduzieren, ohne mehr Speicherplatz zu belegen. Diese Version ist 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

Die Eingabe ist eine einzelne Zeichenfolge der Ganzzahlen wie 13342. Die Ausgabe ist ein 1wenn gefunden oder ein 0wenn nicht.

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

Beachten Sie, dass das Entfernen von Duplikaten nur einmal erfolgen muss, da es nur fünf Zahlen gibt. Mehr als eine Zahl entfernen zu müssen, würde bedeuten, dass es sowieso keine kleine Straße gibt.

Probieren Sie es online aus

Vielen Dank an Martin für die Idee, die Kommas innerhalb der Erfassungsgruppen zu verschieben und dabei satte 16 Bytes zu sparen.

Pyth, 11 Bytes

f!-TQ.:S6 4

Testsuite

Generieren Sie die Teilzeichenfolgen mit der Länge 4 von [1..6] und filtern Sie sie dann nach keinen verbleibenden Elementen, wenn die Elemente der Eingabe entfernt werden.

Gelee, 9 Bytes

Es muss eine 8-Byte-Lösung geben, die weiter sucht ... Code:

Œ!Ḋ€Iµ7Be

Dies ist das gleiche wie meine 05AB1E- Lösung .

Erläuterung:

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

Probieren Sie es online!

Gelee, 8 Bytes

6Rṡ4ḟ€ċ“

Probieren Sie es online! oder überprüfen Sie die wahrheitsgemäßen Testfälle und die falschen Testfälle .

Wie es funktioniert

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)

Prüfer:

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

Dies nimmt die Zahl 62 (111110 in binär). Für jede Zahl im Eingabearray wird dieses Bit entfernt

Die resultierende Zahl sollte entweder sein

100000 or
000000 or
000010 or
000110 or
000100

Also überprüfe ich, ob das Ergebnis kleiner als 7 (0000111) oder gleich 32 (100000) ist

TI-BASIC, 25 Byte

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

Ein äquivalenter (ungolfed) Python-Ausdruck, den Sie testen können :

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

Die Idee dahinter ist die Teilbarkeit. Um zu überprüfen, ob a1, 2, 3, 4 , 2, 3, 4, 5oder 3, 4, 5, 6vorkommt, können wir die Zahlen 1-6 bis 37-42 zuordnen und dann die richtigen Zahlen miteinander multiplizieren.

Jede der Zahlen in [37,42] hat einen Primfaktor, den die anderen Zahlen nicht haben.

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

Wenn also das Produkt der fünf Zahlen durch 37 teilbar ist, enthielt die ursprüngliche Liste eine 1. Wenn es durch 19 enthielt, enthielt es eine 2; etc. Wenn es teilbar durch 37*19*13*5= 65*703, es enthält 1, 2,3 , und 4und in ähnlicher Weise für die andere beiden Zahlen.

Diese Lösung ist eine Verbesserung gegenüber einer , die @Weregoose im Jahr 2009 veröffentlicht hat.

Mumps, 113 78 Bytes

Die Version von Mumps, die ich benutze, ist InterSystems Cache.

Ich kann mir keine Möglichkeit vorstellen, diese Technik kürzer zu spielen. Mit einer anderen Technik könnte es möglich sein, aber im Moment reicht das und es ist zumindest kürzer als C ++ ... aber nicht viel. Sowieso...

OK, hier ist ein kürzerer Weg. Anstatt 3 separate Variablen für die kurzen Läufe zu haben, verwenden Sie eine einzige Variable für alle 6 "Würfel" und extrahieren Sie die Teile später:

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)

So viel für mich, dass ich mit der gleichen Technik keinen besseren Weg finde ... Ich sollte nachsehen, bevor ich springe, oder? ;-)

Ich werde meine ursprüngliche Antwort unten für historische Zwecke hinterlassen ...

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

Und hier ist die Erklärung, was mit dem Code los ist:

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.

Ich habe nicht jede einzelne wahrheitsgemäße und falsche Eingabe getestet, da sie manuell eingegeben werden musste. aber ich habe ungefähr die erste Hälfte von jedem getestet, verifiziert, dass die langen Geraden immer noch wahr sind und dass einige der Läufe nicht unbedingt korrekt funktionieren ([4,2,5,3,4], [1,2,3,3 , 4] etc.) und scheint korrekt zu funktionieren.

Dyalog APL , 15 Bytes

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

Verwendet ⎕IO=0

⍳4 ist 0 1 2 3

⍵∘.+⍳4 ist 5 × 4 eine Matrix von jedem Chip, inkrementiert um jeden von ⍳4

⍵∊⍨ prüft, ob die Elemente der Matrix in der Hand sind, Ergebnis ist eine boolesche (0-or-1) Matrix, wir müssen eine Reihe aller Einsen finden

∧/ ist die And-Reduktion um Zeilen, Ergebnis ist ein Boolescher Vektor

∨/ ist die oder-Reduktion dieses Vektors

Jelly, 11

QṢṡ4ðfø6Rṡ4

Probieren Sie es online!

Dies ist so ziemlich eine Kopie meiner Pyth-Antwort und versucht nur herauszufinden, wie man Sachen verkettet. Fühlt sich an, als sollte es golffähig sein.

Erweiterung:

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]

Wenn Sie schwierige Fragen stellen möchten, zum Beispiel, warum die Trennzeichen unterschiedlich sind, dann lautet meine Antwort an Sie: "Ich antworte in 6-8 Wochen": P (Im Ernst, ich denke, es ist die Musterübereinstimmung, monad-dyad gegen nilad-dyad, aber ich weiß es nicht und möchte keine Fehlinformationen verbreiten.)