Catatan: Ini terkait dengan variasi permainan Rummikub

Latar Belakang & Aturan

Rummikub adalah game berbasis ubin. Ada empat warna: merah, oranye, biru dan hitam. Untuk setiap warna ada 13 ubin (diberi label dari 1 hingga 13), dan ada juga 2 Pelawak yang tidak tergantung warna, maka totalnya ada 54 buah. Dalam variasi Rummikub ini, setiap pemain menerima 14 ubin dan harus mendapatkan satu ubin lagi dan menjatuhkan satu lagi setiap putaran, sehingga jumlah ubin konstan. Para pemain tidak melihat ubin masing-masing. Tujuannya adalah untuk mengelompokkan ubin, sehingga semua bagian memiliki setidaknya satu grup (lihat di bawah). Ketika seorang pemain memiliki semua potongan yang dikelompokkan, mereka menjatuhkan papan ubin mereka dan mengungkapkan potongan mereka. Yang lain kemudian memeriksa apakah semua kombinasi itu valid, dan jika benar, pemain memenangkan ronde.

Bagaimana ubin bisa dikelompokkan?

Hanya ada dua jenis grup:

• Grup multi-warna :

  • Mereka terdiri dari 3 atau 4 ubin.
  • Mereka hanya berisi ubin dengan nomor yang sama.
  • Semua ubin memiliki warna yang berbeda.
  • Contoh: RED 9, BLUE 9, BLACK 9.

• Grup satu warna :

  • Mereka terdiri dari setidaknya 3 ubin.
  • Mereka tidak dapat berisi lebih dari 13 ubin.
  • Mereka hanya berisi ubin dengan nomor yang berbeda dan berurutan, dalam urutan menaik.
  • Semua ubin memiliki warna yang sama.
  • Ubin berlabel 1 mungkin bukan tempat setelah ubin berlabel 13.
  • Contoh: RED 5, RED 6, RED 7.

Tunggu, apa yang dilakukan Jokers?

Pelawak dapat mengganti bagian apa pun dalam permainan. Misalnya, contoh pertama kita bisa menjadi JOKER, BLUE 9, BLACK 9, RED 9, JOKER, BLACK 9atau RED 9, BLUE 9, JOKER. Hal yang sama berlaku untuk contoh kami yang lain. Namun, seseorang tidak boleh menempatkan dua Pelawak dalam kelompok yang sama, sehingga hal-hal seperti JOKER, ORANGE 8, JOKERitu dilarang.

Tugas

Diberikan grup ubin Rummikub, tentukan apakah itu valid. Anda dijamin bahwa tidak ada ubin duplikat akan muncul, kecuali untuk 2 pelawak dan bahwa ubin yang Anda terima sebagai input valid (mis. Hal-hal seperti 60tidak akan muncul).

Input output

Anda dapat mengambil input dan memberikan output dengan metode standar apa pun.

Beberapa format input yang valid: daftar string, daftar tupel, daftar bersarang, string, atau apa pun yang Anda temukan cocok. Warna dapat diambil sebagai Strings (misalnya:) "Blue","Red", etc., sebagai singkatan String (harap buat ubin Biru dan Hitam dapat dibedakan), atau sebagai bilangan bulat sesuai dengan warna. Ketika datang ke Jokers, Anda harus menyebutkan cara program Anda menerimanya sebagai input. Jika Anda memilih Strings, Anda mungkin memiliki sesuatu seperti RED 9, JOKER, ..., jika Anda memilih tuple yang dapat Anda miliki (9,"RED"), ("JOKER")atau sesuatu yang setara. Jika itu membantu, Anda mungkin menerima warna untuk Joker itu (yang seharusnya tidak mempengaruhi output program Anda). Sebagai contoh, Anda mungkin memiliki ("JOKER","RED")atau ("JOKER","BLUE"), tetapi itu seharusnya tidak mempengaruhi output dengan cara apa pun.

Mengenai output, aturan standar untuk masalah keputusan berlaku.

Contoh yang berhasil

Mari kita ambil contoh, yang diharapkan akan membuatnya lebih mudah untuk dipahami. Diberikan grup sebagai berikut, di mana setiap tupel mewakili ubin:

[(9, "RED"), (9, "ORANGE"), ("JOKER"), (9, "BLACK")]

Ini harus mengembalikan nilai kebenaran, karena inputnya valid. Dalam hal ini, pengganti Joker (9, "BLUE"), dan mereka membentuk kelompok multi-warna.

Jika Anda akan diberikan grup berikut:

[(9, "BLUE"), (9, "ORANGE"), (9, "RED"), (9, "BLACK"), ("JOKER")]

Itu akan tidak valid, dan dengan demikian program Anda harus mengembalikan nilai falsy, karena tidak ada yang tersisa untuk diganti oleh joker, karena jumlah maksimum kartu dalam kelompok multi-warna adalah 4.

Kasus Uji Tambahan

Ini adalah untuk rangkaian uji diperpanjang yang mencakup hampir semua situasi yang mungkin:

Input -> Output 

[(1, "BIRU"), (2, "BIRU"), (3, "BIRU"), (4, "BIRU"), (5, "BIRU"), (6, "BIRU")] - > jujur

[(6, "BLUE"), (6, "RED"), (6, "BLACK)] -> truthy

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

[("JOKER"), (3, "BLUE"), (3, "RED")] -> truthy

[(8, "BLACK"), (2, "RED"), (13, "BLUE")] -> falsy

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

[(5, "BLACK"), (6, "BLACK)] -> falsy

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

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

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

[(12, "BLACK"), (13, "BLACK), (1," BLACK ")] -> falsy

Ini adalah kode-golf , jadi kode terpendek dalam byte di setiap bahasa menang!

APL (Dyalog) , 58 byte

Mengambil daftar warna (1-4) sebagai argumen kanan dan daftar angka sebagai argumen kiri. Nomor Joker dilambangkan (⍳4)yang setara dengan (1 2 3 4)untuk menunjukkan bahwa itu bisa salah satu dari mereka. Demikian juga, warnanya dilambangkan (⍳13)untuk menunjukkan bahwa itu bisa berupa angka dari 1 hingga 13.

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

Cobalah online!

Algoritma

Ada tiga kondisi, dimana dua yang terakhir memiliki dua kondisi masing-masing:

1. Lari harus memiliki panjang lebih besar dari atau sama dengan 3

DAN LAINNYA

2. 1. satu nomor DAN

   2. warna yang unik

ATAU

3. 1. satu warna DAN
   2. nomor urut

agar proses berjalan valid.

Urutan membaca

 3≤3 kurang dari atau sama dengan ≢⍺jumlah ubin

∧ dan

   s⍵ semua angka sama

  ∧ dan

   ⍺≡∪⍺ warnanya unik

 ∨ atau

   1∊1 adalah di antara ≢∘∪¨jumlah  warna unik yang ⊃,¨/diperluas⍺

  ∧ dan

   ∨/terdapat setidaknya satu di ∊antara semua ⊃,¨/⍵bilangan yang diperluas ⍷¨⊂yang ditemukan dalam ⍳131 hingga 13

Penjelasan kode lengkap

{... } fungsi anonim di mana ⍺argumen kiri dan ⍵argumen benar

3.2.

 ⍳13 angka 1 hingga 13

 (… )⍷¨Temukan posisi awal dari masing-masing proses berikut:

  ,¨/⍵ bergabung dengan masing-masing elemen angka (membuat lari untuk setiap nilai Joker)

  ⊃ mengungkapkan (karena /mengurangi peringkat)

  ∊ ϵ daftar (ratakan)

 ∨/ ATAU pengurangan (yaitu, apakah benar?)

 (... )∧ DAN:

3.1

  (... )⍺ hasil penerapan fungsi berikut pada daftar warna:

   s←{... } s (untuk s ame) yang merupakan fungsi anonim berikut ( ⍵adalah yang argumen):

    ,¨/⍵ bergabung dengan setiap elemen di seberang (menciptakan lari untuk setiap nilai Joker)

    ⊃ mengungkapkan (karena /mengurangi peringkat)

    ≢∘∪¨ jumlah elemen unik di setiap daftar

    1∊ Apakah salah satu anggota? (yaitu apakah ada daftar semua yang sama?)

 (... )∨ ATAU:

2.2.

  ∪⍺ warna yang unik

  ⍺≡ identik dengan warna (yaitu mereka unik)

  (... )∧ DAN:

2.1.

   s⍵ jumlahnya semua sama

  (... )∧ DAN

1.

   ≢⍺ jumlah warna (yaitu jumlah ubin)

   3≤ tiga kurang dari atau sama dengan itu

Jelly , 41 40 38 36 byte

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

Cobalah online! (dilengkapi dengan footer test-suite)

Mengambil input sebagai array (color, value)untuk ubin biasa dan 0untuk pelawak. Warna direpresentasikan sebagai bilangan bulat (walaupun saya tidak yakin apakah itu penting untuk kode saat ini).

Output 1(benar) atau 0(falsy).

Penjelasan

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 byte

• @ Mr.Xcoder menyimpan 1 byte: str.split()bukanlist literal
• 8 byte disimpan: singkatan untuk len(x)-1
• 19 byte disimpan: J O BK B Runtuk Joker, Orange, Black, Blue, Redliteral
• @ Mr.Xcoder menyimpan 12 byte lagi, terima kasih !!
• Lain 4 byte berkat @ 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))

Cobalah online!

Javascript (ES6), 286 byte

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

(Perhatikan bahwa kasus uji di atas mengandung 2 kasus uji tambahan yang tidak ada dalam Pertanyaan: masing-masing benar dan salah: lihat versi yang tidak diklik untuk dibaca).

Proses kasar:

 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

Pelawak diindikasikan dengan memiliki 0sebagai nilai numeriknya (angka negatif juga berfungsi); ini menjaga agar input tetap konsisten (memiliki Warna dan Nilai) dan tidak bergantung pada keharusan memeriksa apakah c=="JOKER", menghemat 7 byte.

Mungkin beberapa tanda kurung dapat dihapus, mungkin dimungkinkan untuk tidak membuat kotak qsebagai array (saya mencobanya dan nilainya tinggal 0 atau menyebabkan setan hidung ).

Tidak Disatukan:

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

Versi yang saya kerjakan untuk mendapatkan logika yang benar. Lambda sekali pakai disatukan; inilah fungsi yang sesuai:

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 byte

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

Mengambil warna ubin dan angka sebagai daftar bilangan bulat yang terpisah. Spesifikasi pemetaan itu tidak masalah asalkan masing-masing warna memiliki bilangan bulat yang berbeda dan Jokers direpresentasikan sebagai 0.

Format untuk memasukkan angka cukup istimewa. Angka yang perlu diinput untuk angka nadalah 2 ^ n, sedangkan angka yang digunakan untuk mewakili joker adalah (2 ^ 14) -1. Ini memungkinkan bitwise dan u&xuntuk mengevaluasi Anda jika ubin x memiliki nilai yang sama dengan Anda atau adalah joker.

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

Solusi 2 byte lebih lama yang tidak eklektik tentang input. Ternyata hanya menggunakan kasing khusus untuk para pelawak di satu tempat yang sulit mereka tangani, tidak lebih lama dari operasi bitwise pintar yang sangat kubanggakan. Di sini Joker adalah (0,0), angka lain seperti yang diharapkan, dan warna diwakili 4 nilai yang berbeda satu sama lain dengan perbandingan default C # (khususnya, Distinct()operasi Linq harus mempertimbangkan nilai untuk warna yang sama sebagai 'tidak berbeda' dan nilai untuk warna berbeda sebagai 'berbeda').

Sesuatu yang mungkin berguna untuk bahasa lain, u*=!u++^x*xakan setara dengan u=u==x|x<1?u+1:0di beberapa bahasa; u ^ x adalah 0 iff u == x, dan 0 kali int adalah 0, jadi u ^ x * x akan menjadi 0 untuk u == x atau x == 0 jika C # tidak membuat operasi bitwise lebih diutamakan daripada yang matematika. C # juga tidak dapat menafsirkan int sebagai bools tanpa casting eksplisit. Sebuah bahasa yang berusaha lebih keras untuk membuat tipe berfungsi mungkin mengonversi nilai 0dan not 0ke falsedan truesebelum menerapkannya !, dan kemudian ketika kembali ke int menafsirkan !falsesebagai 1 dan !true0. Semua yang mengatakan, saya tidak dapat menjamin bahasa lain akan benar-benar manfaat dari sisa algoritma sehingga bahkan mungkin tidak muncul.

Scala, 491 477 karakter, 491 477 byte

Tantangan ini menyenangkan; Terima kasih.

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}

Jadi fpada saluran 4 adalah panggilan rekursif di mana saya mencoba mengganti "JOKER" oleh setiap ubin lainnya. Lihat tio untuk tampilan kode yang lebih jelas. Saya memilih menerima sebagai masukan urutan 2-tupel (Int, String) - dipanggil tdalam kode saya, lihat tio - jadi "JOKER" diwakili oleh 2-tupel (0, "JOKER").

EDIT: 14 byte disimpan berkat komentar, saya ambil OB b R untuk ORANGE BLACK BLUE RED.

Cobalah secara Online!

EDIT: -2 ​​byte, dihapus tidak berguna di (sekitar kondisi case _ ifs