Uwaga: jest to związane z odmianą gry Rummikub

Tło i zasady

Rummikub to gra oparta na kafelkach. Istnieją cztery kolory: czerwony, pomarańczowy, niebieski i czarny. Na każdy kolor przypada 13 kafelków (oznaczonych od 1 do 13), a także 2 Jokery, które są niezależne od koloru, dlatego w sumie jest ich 54. W tej odmianie Rummikub każdy gracz otrzymuje 14 płytek i musi zdobyć jeszcze jeden kafelek i upuszczać kolejne w każdej rundzie, aby liczba płytek była stała. Gracze nie widzą siebie nawzajem. Celem jest zgrupowanie płytek, tak aby wszystkie elementy należały do ​​co najmniej jednej grupy (patrz poniżej). Kiedy gracz zgrupuje wszystkie pionki, upuszcza swoją płytkę i odsłania swoje pionki. Inni następnie sprawdzają, czy wszystkie kombinacje są prawidłowe, a jeśli tak, to gracz wygrywa rundę.

Jak można grupować kafelki?

Istnieją tylko dwa typy grup:

• Grupy wielokolorowe :

  • Składają się z 3 lub 4 płytek.
  • Zawierają tylko płytki z tym samym numerem na nich.
  • Wszystkie płytki są w różnych kolorach.
  • Przykład: RED 9, BLUE 9, BLACK 9.

• Grupy jednobarwne :

  • Składają się z co najmniej 3 płytek.
  • Nie mogą zawierać więcej niż 13 płytek.
  • Zawierają tylko kafelki z różnymi kolejnymi liczbami w porządku rosnącym.
  • Wszystkie płytki mają ten sam kolor.
  • Płytki oznaczone etykietą 1 nie mogą być miejscami po płytkach oznaczonych etykietą 13.
  • Przykład: RED 5, RED 6, RED 7.

Zaraz, co robią Jokery?

Jokery mogą zastąpić dowolny element w grze. Na przykład naszym pierwszym przykładem może być JOKER, BLUE 9, BLACK 9, RED 9, JOKER, BLACK 9lub RED 9, BLUE 9, JOKER. To samo dotyczy naszego drugiego przykładu. Jednak nie można umieszczać dwóch Jokerów w tej samej grupie, więc takie rzeczy JOKER, ORANGE 8, JOKERsą zabronione.

Zadanie

Biorąc pod uwagę grupę kafelków Rummikub, sprawdź, czy jest poprawna. Masz gwarancję, że nie pojawią się duplikaty kafelków, z wyjątkiem 2 jokerów i że kafelki otrzymane jako dane wejściowe są prawidłowe (np. Rzeczy takie jak 60nie pojawią się).

Wejście wyjście

Możesz wziąć dane wejściowe i dostarczyć dane wyjściowe dowolną standardową metodą.

Niektóre prawidłowe formaty wejściowe: lista ciągów, lista krotek, zagnieżdżone listy, ciągi lub cokolwiek innego, co uważasz za odpowiednie. Kolory mogą być traktowane jako ciągi znaków (np . "Blue","Red", etc.:), skróty ciągów znaków (należy wyróżnić niebieskie i czarne kafelki) lub jako liczby całkowite odpowiadające kolorowi. Jeśli chodzi o Jokery, powinieneś wspomnieć o tym, jak twój program odbiera je jako dane wejściowe. Jeśli wybierzesz Strings, możesz mieć coś takiego RED 9, JOKER, ..., jeśli wybierzesz krotki, które możesz mieć (9,"RED"), ("JOKER")lub coś równoważnego. Jeśli to pomoże, możesz otrzymać kolor dla tego Jokera (co nie powinno wpływać na wynik twojego programu). Na przykład możesz mieć ("JOKER","RED")lub ("JOKER","BLUE"), ale nie powinno to w żaden sposób wpływać na wynik.

Jeśli chodzi o wynik, zastosowanie mają standardowe zasady dotyczące problemu decyzyjnego .

Sprawdzone przykłady

Weźmy przykład, który, miejmy nadzieję, ułatwiłby zrozumienie. Biorąc pod uwagę grupę w następujący sposób, gdzie każda krotka reprezentuje kafelek:

[(9, „RED”), (9, „ORANGE”), („JOKER”), (9, „BLACK”)]

Powinno to zwrócić prawdziwą wartość, ponieważ dane wejściowe są prawidłowe. W tym przypadku Joker zastępuje (9, "BLUE")i tworzą grupę wielokolorową.

Jeśli otrzymasz następującą grupę:

[(9, „NIEBIESKI”), (9, „POMARAŃCZOWY”), (9, „CZERWONY”), (9, „CZARNY”), („JOKER”)]

Byłoby to nieprawidłowe, dlatego program powinien zwrócić wartość falsy, ponieważ joker nie ma już nic do zastąpienia, ponieważ maksymalna liczba kart w grupie wielokolorowej wynosi 4.

Dodatkowe przypadki testowe

Są to dla rozszerzonego zestawu testów, który obejmuje prawie wszystkie możliwe sytuacje:

Wejście -> Wyjście 

[(1, „NIEBIESKI”), (2, „NIEBIESKI”), (3, „NIEBIESKI”), (4, „NIEBIESKI”), (5, „NIEBIESKI”), (6, „NIEBIESKI”)] - > prawda

[(6, „NIEBIESKI”), (6, „CZERWONY”), (6, „CZARNY)] -> truey

[(5, „CZARNY”), (6, „CZARNY”), (7, „CZARNY”), (8, „CZARNY”), (9, „CZARNY”), (10, „CZARNY”), ( „JOKER”), (12, „BLACK”)] -> truey 

[(„JOKER”), (3, „NIEBIESKI”), (3, „CZERWONY”)] -> truey

[(8, „CZARNY”), (2, „CZERWONY”), (13, „NIEBIESKI”)] -> falsy

[(4, „RED”), (3, „RED”), (5, „RED”)] -> falsy

[(5, „CZARNY”), (6, „CZARNY)] -> falsy

[(„JOKER”), (5, „RED”), („JOKER”)] -> falsy

[(4, „RED”), (5, „RED”), (6, BLUE ”)] -> falsy

[(4, „RED”), („JOKER”), (5, „RED”)] -> falsy

[(12, „CZARNY”), (13, „CZARNY), (1,„ CZARNY ”)] -> falsy

To jest golf golfowy , więc wygrywa najkrótszy kod w bajtach w każdym języku!

APL (Dyalog) , 58 bajtów

Pobiera listę kolorów (1-4) jako prawy argument i listę liczb jako lewy argument. Oznaczono liczbę Jokera, (⍳4)która jest równoważna (1 2 3 4)z informacją, że może to być dowolny z nich. Podobnie, jego kolor jest oznaczony, (⍳13)aby wskazać, że może to być dowolna z liczb od 1 do 13.

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

Wypróbuj online!

Algorytm

Istnieją trzy warunki, z których dwa ostatnie mają dwa warunki:

1. Przebieg musi mieć długość większą lub równą 3

I JESZCZE

2. 1. pojedynczy numer ORAZ

   2. unikalne kolory

LUB

3. 1. jeden kolor ORAZ
   2. kolejne numery

aby przebieg był ważny.

Kolejność czytania

 3≤3 jest mniejsza lub równa ≢⍺liczbie płytek

∧ i

   s⍵ wszystkie liczby są takie same

  ∧ i

   ⍺≡∪⍺ kolory są wyjątkowe

 ∨ lub

   1∊1 należy ≢∘∪¨do liczby unikatowych ⊃,¨/rozszerzonych ⍺ kolorów

  ∧ i

   ∨/istnieje co najmniej jeden ∊spośród wszystkich ⊃,¨/⍵rozszerzeń numerów ⍷¨⊂jeden, który znajduje się w punktach od ⍳131 do 13

Pełne wyjaśnienie kodu

{… } Anonimowa funkcja, w której ⍺argument jest lewy, a ⍵argument prawy

3.2

 ⍳13 liczby od 1 do 13

 (… )⍷¨Znajdź pozycje początkowe każdego z następujących przebiegów:

  ,¨/⍵ dołącz każdy element liczb (tworzy przebieg dla każdej wartości Jokera)

  ⊃ ujawnić (ponieważ /zmniejsza rangę)

  ∊ ε nlist (spłaszczyć)

 ∨/ LUB redukcja (tj. Czy są jakieś prawdziwe?)

 (… )∧ I:

3.1

  (… )⍺ Wynik zastosowania następującej funkcji na liście kolorów:

   s←{... } s (dla s ame), która jest następująca funkcja anonimowa ( ⍵jest jego argument):

    ,¨/⍵ połącz każdy element w poprzek (tworzy przebieg dla każdej wartości Jokera)

    ⊃ ujawnić (ponieważ /zmniejsza rangę)

    ≢∘∪¨ liczba unikalnych elementów na każdej liście

    1∊ jest członkiem? (tj. czy są jakieś takie same listy?)

 (… )∨ LUB:

2.2

  ∪⍺ unikalne kolory

  ⍺≡ są identyczne z kolorami (tzn. są niepowtarzalne)

  (… )∧ I:

2.1

   s⍵ liczby są takie same

  (… )∧ I

1.

   ≢⍺ liczba kolorów (tj. liczba płytek)

   3≤ trzy jest mniejsze lub równe temu

Galaretka , 41 40 38 36 bajtów

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

Wypróbuj online! (zawiera stopkę zestawu testów)

Pobiera dane wejściowe jako tablicę (color, value)dla zwykłych kafelków i 0dla jokerów. Kolory są reprezentowane jako liczby całkowite (chociaż nie jestem pewien, czy to w ogóle ma znaczenie dla bieżącego kodu).

Wyjścia 1(prawda) lub 0(fałsz).

Wyjaśnienie

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 bajtów

• @ Mr.Xcoder zapisał 1 bajt: str.split()zamiastlist literal
• Zapisano 8 bajtów: skrót dla len(x)-1
• Zapisano 19 bajtów: J O BK B Rna Joker, Orange, Black, Blue, Redliterały
• @ Mr.Xcoder zapisał kolejne 12 bajtów, dziękuję !!
• Kolejne 4 bajty dzięki @ 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))

Wypróbuj online!

JavaScript (ES6), 286 bajtów

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

(Zauważ, że powyższe przypadki testowe zawierają 2 dodatkowe przypadki testowe, których nie ma w pytaniu: są one odpowiednio prawdziwe i fałszywe: zobacz czytelność wersji bez golfisty).

Szorstki proces:

 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

Jokery są oznaczone jako mające 0wartość liczbową (działałaby również liczba ujemna); dzięki temu struktura danych wejściowych jest spójna (ma zarówno Kolor, jak i Wartość) i nie polega na sprawdzaniu, czy c=="JOKER"oszczędzając 7 bajtów.

Możliwe, że niektóre nawiasy zostaną usunięte, może nie być pola qjako tablicy (próbowałem, a wartość pozostała 0 lub spowodowała demony nosowe ).

Nie golfowany:

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

Wersja, nad którą pracowałem, aby uzyskać prawidłową logikę. Lambdas jednorazowego użytku są wbudowane; oto ich odpowiednia funkcja:

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 bajtów

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

Pobiera na nich kolory kafelków i liczb jako osobne listy liczb całkowitych. Specyfika tego odwzorowania nie ma znaczenia, dopóki każdy kolor ma inną liczbę całkowitą, a Jokery są reprezentowane jako 0.

Format wprowadzania liczb jest jednak wyjątkowy. Liczba, którą należy wprowadzić dla liczby, nto 2 ^ n, podczas gdy liczba używana do reprezentowania jokera powinna wynosić (2 ^ 14) -1. Umożliwia to bitowe i u&xocenę u, jeśli kafelek x ma wartość równą u lub jest jokerem.

C # (.NET Core) , 200 bajtów

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

2 bajtowe rozwiązanie dłuższe, które nie jest eklektyczne w kwestii wprowadzania. Okazuje się, że używam specjalnego etui dla żartownic w jednym miejscu, z którym trudno było sobie poradzić, nie było dużo dłuższe niż sprytna bitowa operacja, z której byłem tak dumny. Tutaj Jokery są (0,0), inne liczby są zgodne z oczekiwaniami, a kolory są reprezentowane 4 dowolnymi wartościami, które różnią się od siebie w domyślnym porównaniu C # (konkretnie, Distinct()operacja Linq musi brać pod uwagę wartości dla tego samego koloru jako „nierozróżnialne” oraz wartości dla różnych kolorów jako „wyraźne”).

Coś, co mogłoby być przydatne w innych językach, u*=!u++^x*xbyłoby równoważne u=u==x|x<1?u+1:0w niektórych językach; u ^ x wynosi 0 iff u == x, a 0 razy dowolny int jest równy 0, więc u ^ x * x będzie 0 dla u == x lub x == 0, jeśli C # nie sprawi, że operacje bitowe będą miały niższy priorytet niż matematyczne. C # nie może również interpretować ints jako bools bez jawnego rzutowania. Język, który próbuje trudniej zrobić typy praca może konwertować wartości 0i not 0celu false, a trueprzed nałożeniem !na nich, choć i wtedy, gdy wracając do int interpretować !falsejako 1 i !truejako 0. Wszystkie powiedział, że nie mogę zagwarantować, inny język faktycznie skorzystaj z reszty algorytmu, więc może nawet nie powstać.

Scala 491 477 chars, 491 477 bajtów

To wyzwanie było zabawne; dzięki.

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}

Więc fna linii 4 jest rekurencyjne wywołanie, w którym próbuję zastąpić „JOKER” każdą inną płytką. Zobacz tio, aby uzyskać wyraźniejszy widok kodu. Jako wejście wybrałem sekwencję 2-krotek (Int, String) - wywoływanych tw moim kodzie, patrz tio - więc „JOKER” jest reprezentowany przez 2-krotkę (0, „JOKER”).

EDYCJA: 14 bajtów zapisanych dzięki komentarzom, biorę OB b R za POMARAŃCZOWY CZARNY NIEBIESKI CZERWONY.

Wypróbuj online!

EDYCJA: -2 bajty, usunięty bezużyteczny (wokół warunków case _ ifs