Hinweis: Dies hängt mit einer Variation des Spiels Rummikub zusammen

Hintergrund & Regeln

Rummikub ist ein auf Kacheln basierendes Spiel. Es gibt vier Farben: Rot, Orange, Blau und Schwarz. Für jede Farbe gibt es 13 Kacheln (von 1 bis 13 beschriftet) und es gibt auch 2 Joker, die farbunabhängig sind, daher gibt es insgesamt 54 Teile. In dieser Variante von Rummikub erhält jeder Spieler 14 Plättchen und muss in jeder Runde ein weiteres Plättchen erhalten und ein weiteres fallen lassen, so dass die Anzahl der Plättchen konstant ist. Die Spieler sehen sich nicht gegenseitig. Ziel ist es, die Kacheln so zu gruppieren, dass alle Teile zu mindestens einer Gruppe gehören (siehe unten). Wenn ein Spieler alle Teile gruppiert hat, lässt er sein Kachelbrett fallen und legt seine Teile frei. Die anderen prüfen dann, ob alle Kombinationen gültig sind, und wenn dies der Fall ist, gewinnt der Spieler die Runde.

Wie können die Kacheln gruppiert werden?

Es gibt nur zwei Arten von Gruppen:

• Mehrfarbige Gruppen:

  • Sie bestehen aus 3 oder 4 Kacheln.
  • Sie enthalten nur Kacheln mit derselben Nummer.
  • Alle Fliesen sind in verschiedenen Farben.
  • Beispiel : RED 9, BLUE 9, BLACK 9.

• Einfarbige Gruppen:

  • Sie bestehen aus mindestens 3 Kacheln.
  • Sie dürfen nicht mehr als 13 Kacheln enthalten.
  • Sie enthalten nur Kacheln mit unterschiedlichen fortlaufenden Nummern in aufsteigender Reihenfolge.
  • Alle Fliesen haben die gleiche Farbe.
  • Mit gekennzeichnete Kacheln 1 dürfen keine Stellen nach gekennzeichneten Kacheln sein 13.
  • Beispiel : RED 5, RED 6, RED 7.

Warten Sie, was machen die Joker?

Joker können jedes Stück im Spiel ersetzen. Zum Beispiel kann unser erstes Beispiel werden JOKER, BLUE 9, BLACK 9, RED 9, JOKER, BLACK 9oder RED 9, BLUE 9, JOKER. Gleiches gilt für unser anderes Beispiel. Man darf jedoch nicht zwei Joker in dieselbe Gruppe einordnen, so dass Dinge wie JOKER, ORANGE 8, JOKERverboten sind.

Aufgabe

Bestimmen Sie anhand einer Rummikub-Kachelgruppe, ob diese gültig ist. Sie werden garantiert, dass keine doppelten Kacheln angezeigt werden, mit Ausnahme der 2 Joker, und dass die Kacheln, die Sie als Eingabe erhalten, gültig sind (z. B. Dinge wie 60werden nicht angezeigt).

Input-Output

Sie können Eingaben vornehmen und die Ausgabe mit einer beliebigen Standardmethode bereitstellen.

Einige gültige Eingabeformate: Liste der Zeichenfolgen, Liste der Tupel, verschachtelte Listen, Zeichenfolgen oder alles andere, was Sie für geeignet halten. Die Farben können als Zeichenfolgen (z. B. "Blue","Red", etc.:), als Zeichenfolgenabkürzungen (bitte machen Sie blaue und schwarze Kacheln unterscheidbar) oder als Ganzzahlen entsprechend einer Farbe verwendet werden. Wenn es um Joker geht, sollten Sie als Eingabe angeben, wie Ihr Programm sie empfängt. Wenn Sie Strings wählen, haben Sie möglicherweise etwas wie RED 9, JOKER, ..., wenn Sie Tupel wählen, die Sie haben können, (9,"RED"), ("JOKER")oder etwas Äquivalentes. Wenn es hilft, erhalten Sie möglicherweise eine Farbe für diesen Joker (die die Ausgabe Ihres Programms nicht beeinflussen sollte). Zum Beispiel haben Sie vielleicht ("JOKER","RED")oder ("JOKER","BLUE"), aber das sollte die Ausgabe in keiner Weise beeinflussen.

In Bezug auf die Ausgabe gelten Standardregeln für ein Entscheidungsproblem .

Arbeitsbeispiele

Nehmen wir ein Beispiel, das hoffentlich das Verständnis erleichtert. Geben Sie eine Gruppe wie folgt an, wobei jedes Tupel eine Kachel darstellt:

[(9, "ROT"), (9, "ORANGE"), ("JOKER"), (9, "SCHWARZ")]

Dies sollte einen wahrheitsgemäßen Wert zurückgeben, da die Eingabe gültig ist. In diesem Fall ersetzt der Joker (9, "BLUE")und sie bilden eine mehrfarbige Gruppe.

Wenn Sie die folgende Gruppe erhalten würden:

[(9, "BLAU"), (9, "ORANGE"), (9, "ROT"), (9, "SCHWARZ"), ("JOKER")]

Es wäre ungültig, und daher sollte Ihr Programm einen falschen Wert zurückgeben, da der Joker nichts mehr ersetzen kann, da die maximale Anzahl von Karten in einer mehrfarbigen Gruppe 4 beträgt.

Zusätzliche Testfälle

Diese sind für eine erweiterte Testsuite vorgesehen, die nahezu alle möglichen Situationen abdeckt:

Eingabe -> Ausgabe 

[(1, "BLAU"), (2, "BLAU"), (3, "BLAU"), (4, "BLAU"), (5, "BLAU"), (6, "BLAU")] - > wahr

[(6, "BLAU"), (6, "ROT"), (6, "SCHWARZ)] -> wahr

[(5, "SCHWARZ"), (6, "SCHWARZ"), (7, "SCHWARZ"), (8, "SCHWARZ"), (9, "SCHWARZ"), (10, "SCHWARZ"), ( "JOKER"), (12, "BLACK")] -> wahr 

[("JOKER"), (3, "BLAU"), (3, "ROT")] -> wahr

[(8, "SCHWARZ"), (2, "ROT"), (13, "BLAU")] -> falsch

[(4, "ROT"), (3, "ROT"), (5, "ROT")] -> Falschheit

[(5, "SCHWARZ"), (6, "SCHWARZ)] -> falsch

[("JOKER"), (5, "RED"), ("JOKER")] -> falsch

[(4, "ROT"), (5, "ROT"), (6, BLAU ")] -> falsch

[(4, "ROT"), ("JOKER"), (5, "ROT")] -> Falschheit

[(12, "SCHWARZ"), (13, "SCHWARZ), (1," SCHWARZ ")] -> falsch

Dies ist Code-Golf , also gewinnt der kürzeste Code in Bytes in jeder Sprache!

APL (Dyalog) , 58 Bytes

Nimmt die Liste der Farben (1-4) als rechtes Argument und die Liste der Zahlen als linkes Argument. Die Nummer eines Jokers wird angegeben, (⍳4)was (1 2 3 4)bedeutet, dass es sich um eine dieser Nummern handeln kann . Ebenso wird seine Farbe (⍳13)angegeben, um anzuzeigen, dass es sich um eine der Zahlen von 1 bis 13 handeln kann.

{(3≤≢⍺)∧((s⍵)∧⍺≡∪⍺)∨((s←{1∊≢∘∪¨⊃,¨/⍵})⍺)∧∨/∊(⊃,¨/⍵)⍷¨⊂⍳13}

Probieren Sie es online aus!

Algorithmus

Es gibt drei Bedingungen, von denen die letzten beiden jeweils zwei Bedingungen haben:

1. Der Lauf muss eine Länge größer oder gleich 3 haben

UND ENTWEDER

2. 1. eine einzelne Zahl UND

   2. einzigartige Farben

ODER

3. 1. eine einzelne Farbe UND
   2. fortlaufende Nummern

damit der Lauf gültig ist.

Lesereihenfolge

 3≤3 ist kleiner oder gleich der ≢⍺Anzahl der Kacheln

∧ und

   s⍵ Alle Zahlen sind gleich

  ∧ und

   ⍺≡∪⍺ Die Farben sind einzigartig

 ∨ oder

   1∊1 gehört ≢∘∪¨zur Anzahl der einzigartigen ⊃,¨/erweiterten ⍺ Farben

  ∧ und

   ∨/∊Unter allen ⊃,¨/⍵erweiterten Nummernläufen gibt es mindestens einen ⍷¨⊂, der in ⍳131 bis 13 zu finden ist

Vollständige Code-Erklärung

{… } Anonyme Funktion, bei der ⍺es sich um ein linkes und ⍵ein rechtes Argument handelt

3.2.

 ⍳13 die Zahlen 1 bis 13

 (… )⍷¨Finden Sie die Startpositionen für jeden der folgenden Läufe:

  ,¨/⍵ Verbinden Sie jedes Element der Zahlen (erstellt einen Lauf für jeden Joker-Wert)

  ⊃ offenlegen (weil /Rang reduziert)

  ∊ ϵ nlist (abflachen)

 ∨/ ODER Reduktion (dh sind irgendwelche wahr?)

 (… )∧ UND:

3.1

  (… )⍺ Das Ergebnis der Anwendung der folgenden Funktion auf die Liste der Farben:

   s←{… } S (für s ame) ist die folgende anonyme Funktion ( ⍵ist ihr Argument):

    ,¨/⍵ Verbinden Sie jedes Element über (erstellt einen Lauf für jeden Joker-Wert)

    ⊃ offenlegen (weil /Rang reduziert)

    ≢∘∪¨ die Anzahl der eindeutigen Elemente in jeder Liste

    1∊ ist man ein Mitglied? (dh gibt es alle gleichen Listen?)

 (… )∨ ODER:

2.2.

  ∪⍺ die einzigartigen Farben

  ⍺≡ sind identisch mit den Farben (dh sie sind einzigartig)

  (… )∧ UND:

2.1.

   s⍵ Die Zahlen sind alle gleich

  (… )∧ UND

1.

   ≢⍺ die Anzahl der Farben (dh die Anzahl der Kacheln)

   3≤ drei ist kleiner oder gleich dem

Gelee , 41 40 38 36 Bytes

EȧI=1ȦȯE
0,W€yµZç/ɓQ⁼⁸ȧ
L>2ȧ4p13ðç€Ṁ

Probieren Sie es online aus! (kommt mit einer Test-Suite Fußzeile)

Nimmt die Eingabe als Array (color, value)für normale Kacheln und 0für Joker auf. Farben werden als Ganzzahlen dargestellt (obwohl ich nicht sicher bin, ob dies für den aktuellen Code überhaupt von Bedeutung ist).

Ausgaben 1(wahr) oder 0(falsch).

Erläuterung

L>2ȧ4p13ðç€Ṁ    Main link, checks if a sequence is valid. Args: sequence
L                 Get the length of the sequence.
 >2               Check if it's at least 3 tiles.
   ȧ4             And: yield 4 if it is, 0 otherwise.
     p13          Cartesian product: yield all possible tiles if
                  result was 4, empty array otherwise.
        ð         Begin a new dyadic chain with args (tiles, sequence).
         ç€       Call the first helper link for each tile with args (tile, sequence).

0,W€yµZç/ɓQ⁼⁸ȧ    First helper link, checks if a sequence is valid if jokers
                  are substituted for the given tile. Args: tile, sequence
0,                  Make a pair [0, tile].
  W€                Turn that into [[0], [tile]].
    y               Map all 0's (jokers) into tile in the sequence.
     µ              Begin a new monadic chain with args (sequence).
      Z             Transpose to get list [colors, values].
       ç/           Call the second helper link with args (colors, values).
         ɓ          Begin a new dyadic chain with args (sequence, valid).
          Q         Remove duplicate tiles from the sequence.
           ⁼⁸       Check if the sequence is unchanged (i.e. there were no duplicates).
             ȧ      And with the output of the second helper.

EȧI=1ȦȯE    Second helper link, checks if a sequence is valid assuming no duplicates.
            Args: colors, values
E             Check if all the colors are the same.
 ȧ            Logical and with the values array.
              Yields the values if they were, 0 if not.
  I           Find the differences between each value.
              Yields [] if the colors differed.
   =1         See if each difference is equal to 1.
              Yields [] if the colors differed.
     Ȧ        Check if the list was nonempty and all values were truthy.
              Yields 1 for valid mono-colors, 0 otherwise.
      ȯ       Logical or with the values array.
              Yields 1 for valid mono-colors, the values otherwise.
       E      Check if all the values are the same. For valid mono-colors
              this tests if all items of [1] are equal (obviously true).
              Yields 1 for valid sequences, 0 otherwise.

Python 2 , 371 370 362 341 329 325 Bytes

• @ Mr.Xcoder hat 1 Byte gespeichert: str.split()stattlist literal
• 8 Bytes gespeichert: Kurzform für len(x)-1
• 19 Bytes gespeichert: J O BK B Rfür Joker, Orange, Black, Blue, RedLiterale
• @ Mr.Xcoder hat noch 12 Bytes gespeichert, Danke !!
• Weitere 4 Bytes dank @ Mr.Xcoder

def f(x):
 j=sum("J"in i for i in x);z=len(x)-1
 if j>1or z<2:return False
 if j<1:return(all(i[0]==x[0][0]for i in x)and sum(i[1]==x[0][1]for i in x)<2)or(all(i[1]==x[0][1]for i in x)and sum(int(x[m+1][0])==int(x[m][0])+1for m in range(z))==z)
 return any(f([[k,(i+1,j)]["J"in k]for k in x])for j in'RBbO'for i in range(13))

Probieren Sie es online aus!

Javascript (ES6), 286 Bytes

var testcases = [[{n:1,c:"BLUE"},{n:2,c:"BLUE"},{n:3,c:"BLUE"},{n:4,c:"BLUE"},{n:5,c:"BLUE"}, {n:6,c:"BLUE"}],[{n:6,c:"BLUE"},{n:6,c:"RED"},{n:6,c:"BLACK"}],[{n:5,c:"BLACK"},{n:6,c:"BLACK"},{n:7,c:"BLACK"},{n:8,c:"BLACK"},{n:9,c:"BLACK"},{n:10,c:"BLACK"},{n:0,c:"JOKER"},{n:12,c:"BLACK"}],[{n:0,c:"JOKER"},{n:3,c:"BLUE"},{n:3,c:"RED"}],[{n:8,c:"BLACK"},{n:2,c:"RED"},{n:13,c:"BLUE"}],[{n:4,c:"RED"}, {n:3,c:"RED"}, {n:5,c:"RED"}],[{n:5,c:"BLACK"}, {n:6,c:"BLACK"}],[{n:0,c:"JOKER"},{n:5,c:"RED"},{n:0,c:"JOKER"}],[{n:4,c:"RED"},{n:5,c:"RED"},{n:6,c:"BLUE"}],[{n:4,c:"RED"},{n:0,c:"JOKER"},{n:5,c:"RED"}],[{n:12,c:"BLACK"},{n:13,c:"BLACK"},{n:1,c:"BLACK"}],[{n:11,c:"BLACK"},{n:12,c:"BLACK"},{n:0,c:"JOKER"}],[{n:1,c:"BLACK"},{n:2,c:"BLACK"},{n:3,c:"BLACK"},{n:1,c:"BLUE"},{n:2,c:"BLUE"},{n:3,c:"BLUE"}]];

g=a=>a.length
j=a=>a.n==0
l=(x,y)=>x.c==y.c||j(x)||j(y)
a=s=>g(s)>2&&([q=[0],x=s[0],s.map(y=>q[0]+=x==y||((l(x,y)||x.n==y.n)&&!(j(x)&&j(y)))&&(([n=s.indexOf(y),n<1||([x=s[n-1],!l(x,y)||y.n>0&&x.n<y.n])[1]||(n<g(s)-1&&x.n+1<s[n+1].n)||(n==g(s)-1&&y.n==0&&x.n<13)])[1])?1:0)])[0][0]==g(s)

testcases.forEach(H=>console.log(a(H)));

(Beachten Sie, dass die obigen Testfälle zwei zusätzliche Testfälle enthalten, die nicht in der Frage enthalten sind: Sie sind wahr bzw. falsch: Informationen zur Lesbarkeit finden Sie in der ungolfed-Version.)

Grober Prozess:

 Using first tile x:
   For each tile y:
     count for x: can group with y
 return: x matches n tiles, where n is the number of tiles

Joker werden durch a 0als numerischen Wert angezeigt (eine negative Zahl würde auch funktionieren); Dies hält die Eingabestruktur konsistent (hat sowohl eine Farbe als auch einen Wert) und muss nicht überprüft werden c=="JOKER", ob 7 Bytes eingespart werden.

Es ist möglich, dass einige Klammern entfernt werden könnten, es könnte möglich sein, nicht qals Array zu boxen (ich habe es versucht und der Wert blieb entweder entweder 0 oder verursachte Nasendämonen ).

Ungolfed:

var testcases = [
[{n:1,c:"BLUE"},{n:2,c:"BLUE"},{n:3,c:"BLUE"},{n:4,c:"BLUE"},{n:5,c:"BLUE"}, {n:6,c:"BLUE"}],//true
[{n:6,c:"BLUE"},{n:6,c:"RED"},{n:6,c:"BLACK"}],//true
[{n:5,c:"BLACK"},{n:6,c:"BLACK"},{n:7,c:"BLACK"},{n:8,c:"BLACK"},{n:9,c:"BLACK"},{n:10,c:"BLACK"},{n:0,c:"JOKER"},{n:12,c:"BLACK"}],//true
[{n:0,c:"JOKER"},{n:3,c:"BLUE"},{n:3,c:"RED"}],//true
[{n:8,c:"BLACK"},{n:2,c:"RED"},{n:13,c:"BLUE"}],//false
[{n:4,c:"RED"}, {n:3,c:"RED"}, {n:5,c:"RED"}],//false
[{n:5,c:"BLACK"}, {n:6,c:"BLACK"}],//false
[{n:0,c:"JOKER"},{n:5,c:"RED"},{n:0,c:"JOKER"}],//false
[{n:4,c:"RED"},{n:5,c:"RED"},{n:6,c:"BLUE"}],//false
[{n:4,c:"RED"},{n:0,c:"JOKER"},{n:5,c:"RED"}],//false
[{n:12,c:"BLACK"},{n:13,c:"BLACK"},{n:1,c:"BLACK"}],//false
[{n:11,c:"BLACK"},{n:12,c:"BLACK"},{n:0,c:"JOKER"}],//true
[{n:1,c:"BLACK"},{n:2,c:"BLACK"},{n:3,c:"BLACK"},{n:1,c:"BLUE"},{n:2,c:"BLUE"},{n:3,c:"BLUE"}]
];

g=a=>a.length
i=(a,v)=>a.indexOf(v)
j=x=>x.n==0
m=(x,y)=>
       (l(x,y)||x.n==y.n)
    &&!(j(x)&&j(y))
l=(x,y)=>x.c==y.c||j(x)||j(y)
c=(a,v)=>([n=i(a,v),
      n<1
    ||([x=a[n-1],!l(x,v)||v.n>0&&x.n<v.n])[1]
    ||(n<g(a)-1&&x.n+1<a[n+1].n)
    ||(n==g(a)-1&&v.n==0&&x.n<13)])[1]
a=s=>g(s)>2&&([q=[0],x=s[0],s.map(y=>q[0]+=x==y||m(x,y)&&c(s,y)?1:0)])[0][0]==g(s)

testcases.forEach(H=>console.log(a(H)));

Version, an der ich gearbeitet habe, um die Logik korrekt zu machen. Einweg-Lambdas wurden in die Reihe gestellt; Hier ist ihre entsprechende Funktion:

g() -> string.length
i() -> indexof
j() -> isJoker
m() -> do tiles match
l() -> do colors match
c() -> same-color isConsecutiveOrder
a() -> main lambda

C # (.NET Core) , 198 Bytes

using System.Linq;(C,N)=>{int l=C.Length,j=C.Count(x=>x<1),c=C.Distinct().Count(),n=N.Distinct().Count(),u=N.Min();foreach(var x in N)u*=0<(u&x)?2:0;return l>2&((u>0&n==l&c<2+j)|(n<2+j&c==l&l<5));};

Nimmt die Farben von Kacheln und Zahlen als separate Listen von ganzen Zahlen auf. Die Besonderheiten dieser Zuordnung spielen keine Rolle, solange jede Farbe eine andere Ganzzahl hat und Joker als 0 dargestellt werden.

Das Format für die Eingabe von Zahlen ist jedoch ziemlich speziell. Die Zahl, die für eine Zahl eingegeben werden muss, nist stattdessen 2 ^ n, während die Zahl, die zur Darstellung eines Jokers verwendet wird, (2 ^ 14) -1 sein sollte. Dies ermöglicht das bitweise und u&xAuswerten von u, ob die Kachel x einen Wert gleich u hat oder ein Joker ist.

C # (.NET Core) , 200 Byte

using System.Linq;(C,N)=>{int l=C.Length,j=N.Count(x=>x<1),c=C.Distinct().Count(),n=N.Distinct().Count(),u=N.Min();foreach(var x in N)u=u==x|x<1?u+1:0;return l>2&((u>0&n==l&c<2+j)|(n<2+j&c==l&l<5));};

Eine 2 Byte längere Lösung, die bei der Eingabe nicht vielseitig ist. Es stellte sich heraus, dass die Verwendung eines Sonderfalls für Joker an dem Ort, an dem sie schwer zu handhaben waren, nicht viel länger dauerte als die clevere bitweise Operation, auf die ich so stolz war. Hier sind Joker (0,0), andere Zahlen sind wie erwartet und Farben werden durch 4 Werte dargestellt, die sich durch den Standardvergleich von C # voneinander unterscheiden (insbesondere muss die Linq- Distinct()Operation Werte für dieselbe Farbe als "nicht verschieden" berücksichtigen. und Werte für verschiedene Farben als "verschieden").

Etwas, das für andere Sprachen von Nutzen sein könnte, u*=!u++^x*xwäre u=u==x|x<1?u+1:0in einigen Sprachen gleichwertig ; u ^ x ist 0, wenn u == x, und 0 mal jedes int ist 0, also wäre u ^ x * x entweder für u == x oder x == 0 0, wenn C # keine bitweisen Operationen mit niedrigerer Priorität als mathematische. C # kann Ints auch nicht ohne explizites Casting als Bools interpretieren. Eine Sprache , die versucht härter Arten Arbeit machen könnten die Werte konvertieren 0und not 0zu falseund truevor der Anwendung , !obwohl ihnen, und dann , wenn sie einem int interpretieren zurück !falseals 1 und !trueals 0 Alles , was gesagt, ich kann nicht eine andere Sprache würde garantieren , tatsächlich Profitieren Sie vom Rest des Algorithmus, sodass er möglicherweise nicht einmal angezeigt wird.

Scala, 491 477 Zeichen, 491 477 Bytes

Diese Herausforderung hat Spaß gemacht; Vielen Dank.

var c=Seq("O","B","b","R")
t match{case _ if t.length<3=>false
case _ if t.exists(x=>x._1==0)=>{var b=false
if(t.filter(q=>q._1!=0).exists(q=>q._1==0))b else{for(y<-1 to 13)for(u<-c)b=b|f(t.takeWhile(q=>q._1!=0)++:(y,u)+:t.reverse.takeWhile(q=>q._1!=0).reverse)
b}}
case _::(x,_)::_ if t.forall(_._1==x)=>true
case _ if t.forall(_._2==c(0))|t.forall(_._2==c(1))|t.forall(_._2==c(2))|t.forall(_._2==c(3))=>(t(0)._1 to t(0)._1+t.length-1).toList equals t.map(_._1)
case _=>false}

In fZeile 4 steht also ein rekursiver Aufruf, bei dem ich versuche, "JOKER" durch jede andere Kachel zu ersetzen. Siehe tio für eine klarere Ansicht des Codes. Ich habe als Eingabe eine Folge von 2-Tupeln (Int, String) gewählt - tin meinem Code aufgerufen , siehe tio -, sodass "JOKER" durch ein 2-Tupel (0, "JOKER") dargestellt wird.

EDIT: 14 Bytes dank Kommentaren gespeichert, ich nehme OB b R für ORANGE BLACK BLUE RED.

Probieren Sie es online aus!

EDIT: -2 ​​Bytes, gelöscht nutzlos (um Bedingungen der case _ ifs