Not: Bu oyun Rummikub bir varyasyon ile ilgilidir

Arka Plan ve Kurallar

Rummikub çini tabanlı bir oyundur. Dört renk vardır: kırmızı, turuncu, mavi ve siyah. Her renk için 13 karo vardır (1 ila 13 arasında etiketlenmiştir) ve ayrıca renkten bağımsız 2 Joker vardır, bu nedenle toplam 54 adet vardır. Rummikub'ın bu varyasyonunda, her oyuncu 14 karo alır ve karo sayısı sabit olacak şekilde her turda bir karo daha almalı ve başka bir karo bırakmalıdır. Oyuncular birbirlerinin taşlarını görmezler. Amaç karoları gruplandırmaktır, böylece tüm parçalar en az bir gruba aittir (aşağıya bakınız). Bir oyuncu tüm parçaları gruplandırdığında, döşeme tahtasını düşürür ve parçalarını ortaya çıkarır. Diğerleri daha sonra tüm kombinasyonların geçerli olup olmadığını kontrol ederler ve eğer varsa, oyuncu raundu kazanır.

Fayanslar nasıl gruplanabilir?

Sadece iki tür grup vardır:

• Çok renkli gruplar:

  • 3 veya 4 karodan oluşurlar.
  • Sadece üzerinde aynı numaraya sahip karolar içerirler.
  • Tüm karolar farklı renktedir.
  • Örnek: RED 9, BLUE 9, BLACK 9.

• Tek renk grupları:

  • En az 3 karodan oluşurlar.
  • 13'ten fazla karo içeremezler.
  • Sadece artan sırayla farklı, ardışık sayılara sahip karolar içerirler.
  • Tüm karolar aynı renge sahiptir.
  • İle etiketlenmiş Fayans 1 olmayabilir fayans etiketli sonra yerler olabilir 13.
  • Örnek: RED 5, RED 6, RED 7.

Bekle, Jokerler ne yapar?

Jokerler oyundaki herhangi bir parçayı değiştirebilir. Örneğin, bizim ilk örnek olabilir JOKER, BLUE 9, BLACK 9, RED 9, JOKER, BLACK 9ya da RED 9, BLUE 9, JOKER. Aynısı diğer örneğimiz için de geçerlidir. Ancak, bir olabilir değil şeyler sever bu yüzden, aynı gruptaki iki Jokerleri yerleştirmek JOKER, ORANGE 8, JOKERyasaktır.

Görev

Bir Rummikub döşeme grubu verildiğinde, geçerli olup olmadığını belirleyin. 2 joker dışında yinelenen döşemelerin görünmeyeceği ve girdi olarak aldığınız döşemelerin geçerli olduğu garanti edilir (örn. Gibi şeyler 60görünmez).

Giriş çıkış

Herhangi bir standart yöntemle girdi alabilir ve çıktı sağlayabilirsiniz.

Bazı geçerli giriş biçimleri: dize listesi, tuples listesi, iç içe listeler, dize veya uygun bulduğunuz başka bir şey. Renkler, Dizeler (örneğin:) "Blue","Red", etc., String kısaltmaları (lütfen Mavi ve Siyah döşemeleri ayırt edilebilir hale getirin) veya bir renge karşılık gelen tamsayılar olarak alınabilir . Jokerler söz konusu olduğunda, programınızın bunları girdi olarak alma biçiminden bahsetmelisiniz. Dizeleri seçerseniz, sahip olabileceğiniz RED 9, JOKER, ...tuplleri (9,"RED"), ("JOKER")veya eşdeğer bir şeyi seçerseniz, benzer bir şeye sahip olabilirsiniz . Yardımcı olursa, o Joker için bir renk alabilirsiniz (bu, programınızın çıktısını etkilememelidir). Örneğin, olabilir ("JOKER","RED")veya olabilir ("JOKER","BLUE"), ancak bu çıktıyı hiçbir şekilde etkilemez.

Çıktı ile ilgili olarak, bir karar problemi için standart kurallar geçerlidir.

Çalışılan örnekler

Umarım anlamayı kolaylaştıracak bir örnek alalım. Her grubun bir kutucuğu temsil ettiği aşağıdaki gibi bir grup verilir:

[(9, "KIRMIZI"), (9, "TURUNCU"), ("JOKER"), (9, "SİYAH")]

Girdi geçerli olduğundan, bu doğruluk değeri döndürmelidir. Bu durumda, Joker ikame eder (9, "BLUE")ve çok renkli bir grup oluştururlar.

Aşağıdaki grup size verilecekse:

[(9, "MAVİ"), (9, "TURUNCU"), (9, "KIRMIZI"), (9, "SİYAH"), ("JOKER")]

Geçersiz olur ve bu nedenle programın bir falsy değeri döndürmesi gerekir, çünkü jokerin yerini alacak hiçbir şey kalmaz, çünkü çok renkli bir gruptaki maksimum kart sayısı 4'tür.

Ek Test Durumları

Bunlar, neredeyse tüm olası durumları kapsayan genişletilmiş bir test takımı içindir:

Giriş -> Çıkış 

[(1, "MAVİ"), (2, "MAVİ"), (3, "MAVİ"), (4, "MAVİ"), (5, "MAVİ"), (6, "MAVİ")] - > doğruluk

[(6, "MAVİ"), (6, "KIRMIZI"), (6, "SİYAH)] -> doğruluk

[(5, "beyaz"), (6, "beyaz"), (7, "beyaz"), (8, "beyaz"), (9, "beyaz"), (10, "beyaz"), ( "JOKER"), (12, "BLACK")] -> doğruluk 

[("JOKER"), (3, "MAVİ"), (3, "KIRMIZI")] -> doğruluk

[(8, "SİYAH"), (2, "KIRMIZI"), (13, "MAVİ")] -> falsili

[(4, "KIRMIZI"), (3, "KIRMIZI"), (5, "KIRMIZI")] -> falsili

[(5, "SİYAH"), (6, "SİYAH)] -> falsili

[("JOKER"), (5, "KIRMIZI"), ("JOKER")] -> falsili

[(4, "KIRMIZI"), (5, "KIRMIZI"), (6, MAVİ ")] -> falsili

[(4, "KIRMIZI"), ("JOKER"), (5, "KIRMIZI")] -> falsili

[(12, "SİYAH"), (13, "SİYAH), (1," SİYAH ")] -> falsili

Bu kod golf , bu yüzden her dilde bayt en kısa kod kazanır!

APL (Dyalog) , 58 bayt

Renk listesini (1-4) sağ argüman olarak ve sayı listesini sol argüman olarak alır. Bunlardan herhangi biri olabileceğini göstermek (⍳4)için eşdeğer bir Joker numarası belirtilir (1 2 3 4). Benzer şekilde, rengi, (⍳13)1'den 13'e kadar olan sayılardan herhangi biri olabileceğini göstermek için gösterilir.

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

Çevrimiçi deneyin!

Algoritma

Son ikisinin her biri iki koşula sahip olan üç koşul vardır:

1. Koşu uzunluğu 3 veya daha büyük olmalıdır

VE EITHER

2. 1. tek bir sayı VE

   2. benzersiz renkler

VEYA

3. 1. tek bir renk VE
   2. sıralı sayılar

çalışmanın geçerli olması için.

Okuma sırası

 3≤3 ≢⍺karo sayısından daha az veya ona eşit

∧ ve

   s⍵ tüm sayılar aynı

  ∧ ve

   ⍺≡∪⍺ renkler benzersiz

 ∨ veya

   1∊1 ≢∘∪¨benzersiz ⊃,¨/genişletilmiş ⍺ renk sayısı arasında

  ∧ ve

   ∨/1'den 13'e kadar olan ∊tüm ⊃,¨/⍵genişletilmiş sayı çalıştırmaları arasında en az bir tane var⍷¨⊂⍳13

Tam kod açıklaması

{… } Anonim işlev ⍺sol argüman ve ⍵sağ argüman

3.2.

 ⍳13 1'den 13'e kadar sayılar

 (… )⍷¨Aşağıdaki koşuların her birinin başlangıç ​​pozisyonlarını bulun:

  ,¨/⍵ sayıların her bir elemanını birleştir (her bir Joker değeri için bir koşu oluşturur)

  ⊃ ifşa et (çünkü /sıralamayı azaltır)

  ∊ ϵ nlist (düzleştir)

 ∨/ VEYA azaltma (yani herhangi bir doğru mu?)

 (… )∧ VE:

3.1

  (… )⍺ Renkler listesine aşağıdaki fonksiyonların uygulanmasının sonucu:

   s←{... } s (için s aşağıdaki anonim fonksiyondur ame) ( ⍵olan kendi argümanı):

    ,¨/⍵ her öğeyi birleştir (her Joker değeri için bir çalışma oluşturur)

    ⊃ ifşa et (çünkü /sıralamayı azaltır)

    ≢∘∪¨ her listedeki benzersiz öğelerin sayısı

    1∊ bir üye mi? (örneğin, aynı listeler var mı?)

 (… )∨ VEYA:

2.2.

  ∪⍺ eşsiz renkler

  ⍺≡ renklerle özdeş (yani benzersizdir)

  (… )∧ VE:

2.1.

   s⍵ sayıların hepsi aynı

  (… )∧ VE

1.

   ≢⍺ renklerin sayısı (yani karo sayısı)

   3≤ üç, bundan küçük veya ona eşit

Jöle , 41 40 38 36 bayt

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

Çevrimiçi deneyin! (test takımı altbilgisi ile birlikte gelir)

(color, value)Normal fayans ve 0joker için bir dizi olarak girdi alır . Renkler tamsayı olarak temsil edilir (ancak geçerli kod için bile önemli olup olmadığından emin değilim).

Çıktılar 1(doğru) veya 0(yanlış).

açıklama

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 3703623341329325 bayt

• @ Mr.Xcoder 1 bayt kaydetti: str.split()yerinelist literal
• 8 bayt kaydedildi: için kestirme len(x)-1
• 19 byte kaydedildi: J O BK B Riçin Joker, Orange, Black, Blue, Reddeğişmezleri
• @ Mr.Xcoder 12 bayt daha kaydetti, Teşekkürler !!
• @ Mr.Xcoder sayesinde 4 bayt daha

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

Çevrimiçi deneyin!

Javascript (ES6), 286 bayt

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

(Yukarıdaki test senaryolarının Soruda olmayan 2 ek test vakası içerdiğini unutmayın: sırasıyla doğru ve yanlış: okunabilirlik için ungolfed versiyonuna bakın).

Kaba işlem:

 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

Jokerler 0sayısal değerlerine sahip olarak belirtilir (negatif bir sayı da işe yarar); bu, giriş yapısını tutarlı tutar (hem Renk hem de Değer içerir) ve c=="JOKER"7 bayt tasarruf edip etmediğini kontrol etmek zorunda değildir .

Bazı parantezlerin kaldırılması mümkün olabilir q, bir dizi olarak kutulamak mümkün olmayabilir (denedim ve değer sadece 0 kaldı veya burun şeytanlarına neden oldu ).

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

Versiyon Mantığı düzeltmek için çalıştım. Tek kullanımlık lambdalar astarlıdır; İşte onların karşılık gelen işlevi:

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 bayt

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

Fayans ve sayıların renklerini ayrı bir tamsayı listesi olarak alır. Her bir rengin farklı bir tamsayısı olduğu ve Jokerler 0 olarak gösterildiği sürece, bu eşlemenin özellikleri önemli değildir.

Sayı girme formatı oldukça özeldir. Bir sayı için girilmesi gereken sayı n2 ^ n iken, bir joker'i temsil etmek için kullanılan sayı (2 ^ 14) -1 olmalıdır. Bu, bitsel olarak sağlar ve u&xx döşemesinin u değerine eşit veya joker olup olmadığını u olarak değerlendirir.

C # (.NET Core) , 200 bayt

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

Girdi hakkında eklektik olmayan 2 bayt daha uzun bir çözüm. Anlaşılması zor olan tek yerde jokerler için özel bir dava kullanarak ortaya çıktı. Burada Jokerler (0,0), diğer sayılar beklendiği gibi ve renkler C # 'ın varsayılan karşılaştırmasıyla birbirinden farklı 4 değeri temsil ediyor (özellikle Linq Distinct()işlemi,' farklı değil 'ile aynı renk için değerleri dikkate almalıdır ve farklı renkler için değerleri 'farklı' olarak ayarlayın).

Diğer diller için yararlı olabilecek bir şey , bazı dillerde u*=!u++^x*xeşdeğerdir u=u==x|x<1?u+1:0; u ^ x 0 iff u == x, ve herhangi bir int 0 kez 0'dır, bu nedenle C # bitsel işlemlerden daha düşük önceliğe sahip değilse u ^ x * x u == x veya x == 0 için 0 olur matematiksel olanlar. C # da açık döküm olmadan ints bools olarak yorumlayamaz. Sert çalışır tipleri çalışma değerlerini dönüştürebilir olmak için bu bir dil 0ve not 0karşı falseve trueuygulamadan önce !bir int geri giderken ardından olsa onlara ve yorumlamak !false1 olarak ve !trueben başka bir dil garanti edemez söyledi 0. All olarak aslında olur algoritmanın geri kalanından yararlanın, böylece gelmeyebilir.

Scala, 491 477 karakter, 491 477 bayt

Bu zorluk eğlenceliydi; Teşekkürler.

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}

Yani f4. satırda "JOKER" yerine diğer her döşemeyi değiştirmeye çalıştığım özyinelemeli bir çağrı var. Kodun daha net bir görünümü için tio'ya bakın . Ben giriş olarak 2 tuples (Int, String) bir dizi alarak seçti - tbenim kod çağrıldı , bkz tio - böylece "JOKER" 2-demet (0, "JOKER") ile temsil edilir.

EDIT: 14 bayt yorumları sayesinde kaydedildi, ben TURANG BLACK BLUE RED için OB b R alır.

Çevrimiçi Deneyin!

EDIT: -2 ​​bayt, s (koşulları etrafında yararsız silindicase _ if