Lưu ý: Điều này có liên quan đến một biến thể của trò chơi Rummikub

Bối cảnh & Quy tắc

Rummikub là một trò chơi dựa trên gạch. Có bốn màu: đỏ, cam, xanh và đen. Đối với mỗi màu có 13 gạch (được dán nhãn từ 1 đến 13), và cũng có 2 Joker độc lập với màu, do đó có tổng cộng 54 mảnh. Trong biến thể này của Rummikub, mỗi người chơi nhận được 14 ô và phải nhận thêm một ô và thả một ô khác mỗi vòng, sao cho số lượng ô không đổi. Các cầu thủ không nhìn thấy gạch của nhau. Mục tiêu là nhóm các gạch, sao cho tất cả các mảnh thuộc về ít nhất một nhóm (xem bên dưới). Khi một người chơi có tất cả các mảnh được nhóm lại, họ thả bảng gạch của họ và tiết lộ các mảnh của họ. Những người khác sau đó kiểm tra xem tất cả các kết hợp có hợp lệ không và nếu có, người chơi sẽ thắng vòng đấu.

Làm thế nào gạch có thể được nhóm?

Chỉ có hai loại nhóm:

• Nhóm nhiều màu :

  • Chúng bao gồm 3 hoặc 4 gạch.
  • Chúng chỉ chứa gạch có cùng số trên chúng.
  • Tất cả các gạch có màu sắc khác nhau.
  • Ví dụ : RED 9, BLUE 9, BLACK 9.

• Nhóm đơn sắc :

  • Chúng bao gồm ít nhất 3 gạch.
  • Chúng không thể chứa hơn 13 gạch.
  • Chúng chỉ chứa các ô có số khác nhau, liên tiếp trên chúng, theo thứ tự tăng dần.
  • Tất cả các gạch có cùng màu.
  • Gạch có nhãn có 1 thể không phải là nơi sau khi gạch có nhãn 13.
  • Ví dụ : RED 5, RED 6, RED 7.

Đợi đã, Joker làm gì?

Joker có thể thay thế bất kỳ phần nào trong trò chơi. Ví dụ, ví dụ đầu tiên của chúng tôi có thể trở thành JOKER, BLUE 9, BLACK 9, RED 9, JOKER, BLACK 9hoặc RED 9, BLUE 9, JOKER. Điều tương tự áp dụng cho ví dụ khác của chúng tôi. Tuy nhiên, người ta không thể đặt hai Joker trong cùng một nhóm, vì vậy những thứ như JOKER, ORANGE 8, JOKERbị cấm.

Bài tập

Đưa ra một nhóm gạch Rummikub, xác định xem nó có hợp lệ không. Bạn được đảm bảo rằng sẽ không có các ô trùng lặp nào xuất hiện, ngoại trừ 2 trò đùa và các ô bạn nhận làm đầu vào là hợp lệ (ví dụ: những thứ như 60sẽ không xuất hiện).

Đầu ra đầu vào

Bạn có thể lấy đầu vào và cung cấp đầu ra theo bất kỳ phương pháp tiêu chuẩn nào.

Một số định dạng đầu vào hợp lệ: danh sách các chuỗi, danh sách các bộ dữ liệu, danh sách lồng nhau, chuỗi hoặc bất kỳ thứ gì khác mà bạn thấy phù hợp. Các màu có thể được lấy dưới dạng Chuỗi (ví dụ "Blue","Red", etc.:), dưới dạng viết tắt Chuỗi (vui lòng phân biệt các ô màu Xanh lam và Đen) hoặc dưới dạng số nguyên cho phép tô màu cho một màu. Khi nói đến Jokers, bạn nên đề cập đến cách chương trình của bạn tiếp nhận chúng làm đầu vào. Nếu bạn chọn Chuỗi, bạn có thể có một cái gì đó như RED 9, JOKER, ..., nếu bạn chọn bộ dữ liệu bạn có thể có (9,"RED"), ("JOKER")hoặc một cái gì đó tương đương. Nếu nó giúp, bạn có thể nhận được màu cho Joker đó (không ảnh hưởng đến đầu ra của chương trình của bạn). Ví dụ, bạn có thể có ("JOKER","RED")hoặc ("JOKER","BLUE"), nhưng điều đó sẽ không ảnh hưởng đến đầu ra theo bất kỳ cách nào.

Về đầu ra, các quy tắc tiêu chuẩn cho một vấn đề quyết định được áp dụng.

Ví dụ làm việc

Hãy lấy một ví dụ, điều đó hy vọng sẽ làm cho nó dễ hiểu hơn. Đưa ra một nhóm như sau, trong đó mỗi bộ đại diện cho một ô:

[(9, "ĐỎ"), (9, "ORANGE"), ("CÔNG VIỆC"), (9, "ĐEN")]

Điều này sẽ trả về một giá trị trung thực, bởi vì đầu vào là hợp lệ. Trong trường hợp này, Joker thay thế (9, "BLUE"), và họ tạo thành một nhóm nhiều màu.

Nếu bạn sẽ được đưa ra nhóm sau:

[(9, "BLUE"), (9, "ORANGE"), (9, "ĐỎ"), (9, "ĐEN"), ("JOKER")]

Nó sẽ không hợp lệ và do đó, chương trình của bạn sẽ trả về giá trị giả, bởi vì không còn gì để joker thay thế, bởi vì số lượng thẻ tối đa trong một nhóm nhiều màu là 4.

Các trường hợp kiểm tra bổ sung

Đây là cho một bộ thử nghiệm mở rộng bao gồm gần như tất cả các tình huống có thể:

Đầu vào -> Đầu ra 

[(1, "BLUE"), (2, "BLUE"), (3, "BLUE"), (4, "BLUE"), (5, "BLUE"), (6, "BLUE")] - > sự thật

[(6, "XANH"), (6, "ĐỎ"), (6, "ĐEN)] -> sự thật

[(5, "ĐEN"), (6, "ĐEN"), (7, "ĐEN"), (8, "ĐEN"), (9, "ĐEN"), (10, "ĐEN"), ( "JOKER"), (12, "ĐEN")] -> sự thật 

[("JOKER"), (3, "BLUE"), (3, "ĐỎ")] -> sự thật

[(8, "ĐEN"), (2, "ĐỎ"), (13, "XANH")] -> giả

[(4, "ĐỎ"), (3, "ĐỎ"), (5, "ĐỎ")] -> giả

[(5, "ĐEN"), (6, "ĐEN)] -> giả

[("JOKER"), (5, "ĐỎ"), ("JOKER")] -> giả

[(4, "ĐỎ"), (5, "ĐỎ"), (6, XANH ")] -> giả

[(4, "ĐỎ"), ("CÔNG VIỆC"), (5, "ĐỎ")] -> giả

[(12, "ĐEN"), (13, "ĐEN), (1," ĐEN ")] -> giả

Đây là môn đánh gôn , vì vậy mã ngắn nhất tính theo byte trong mọi ngôn ngữ sẽ thắng!

APL (Dyalog) , 58 byte

Lấy danh sách các màu (1-4) làm đối số bên phải và danh sách các số làm đối số bên trái. Số của Joker được ký hiệu (⍳4)tương đương với số (1 2 3 4)đó có thể là bất kỳ số nào trong số đó. Tương tự như vậy, màu của nó được biểu thị (⍳13)để chỉ ra rằng nó có thể là bất kỳ số nào từ 1 đến 13.

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

Hãy thử trực tuyến!

Thuật toán

Có ba điều kiện, trong đó hai điều kiện cuối cùng có hai điều kiện:

1. Việc chạy phải có chiều dài lớn hơn hoặc bằng 3

VÀ TIN TỨC

2. 1. một số VÀ

   2. màu sắc độc đáo

HOẶC LÀ

3. 1. một màu VÀ
   2. số thứ tự

để chạy có hiệu lực.

Trình tự đọc

 3≤3 nhỏ hơn hoặc bằng ≢⍺số lượng gạch

∧ và

   s⍵ tất cả các số đều giống nhau

  ∧ và

   ⍺≡∪⍺ màu sắc là duy nhất

 ∨ hoặc là

   1∊1 là một trong ≢∘∪¨số các  màu ⊃,¨/mở rộng độc đáo⍺

  ∧ và

   ∨/tồn tại ít nhất một ∊trong số tất cả các ⊃,¨/⍵số mở rộng chạy ⍷¨⊂một được tìm thấy ⍳13từ 1 đến 13

Giải thích mã đầy đủ

{... } chức năng ẩn danh nơi ⍺còn lại tranh cãi và ⍵là lập luận đúng

3.2.

 ⍳13 các số từ 1 đến 13

 (... )⍷¨tìm ra vị trí bắt đầu của mỗi lần chạy sau:

  ,¨/⍵ nối từng phần tử của các số (tạo ra một lần chạy cho mỗi giá trị Joker)

  ⊃ tiết lộ (vì /giảm thứ hạng)

  ∊ ε nlist (flatten)

 ∨/ HOẶC giảm (tức là có đúng không?)

 (... )∧ VÀ:

3,1

  (... )⍺ là kết quả của việc áp dụng các chức năng sau trên danh sách các màu sắc:

   s←{Các } s (cho s ame) là hàm ẩn danh sau ( ⍵là đối số của nó ):

    ,¨/⍵ nối từng phần tử trên (tạo ra một lần chạy cho mỗi giá trị Joker)

    ⊃ tiết lộ (vì /giảm thứ hạng)

    ≢∘∪¨ số lượng phần tử duy nhất trong mỗi danh sách

    1∊ là một thành viên? (tức là có bất kỳ danh sách nào giống nhau không?)

 (... )∨ HOẶC:

2.2.

  ∪⍺ màu sắc độc đáo

  ⍺≡ giống hệt với màu sắc (tức là chúng là duy nhất)

  (... )∧ VÀ:

2.1.

   s⍵ các con số đều giống nhau

  (... )∧ VÀ

1.

   ≢⍺ số lượng màu sắc (tức là số lượng gạch)

   3≤ ba nhỏ hơn hoặc bằng

Thạch , 41 40 38 36 byte

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

Hãy thử trực tuyến! (đi kèm với phần chân thử nghiệm)

Lấy đầu vào như một mảng (color, value)cho gạch thông thường và 0cho người pha trò. Màu sắc được biểu diễn dưới dạng số nguyên (mặc dù tôi không chắc liệu điều đó có quan trọng đối với mã hiện tại hay không).

Đầu ra 1(trung thực) hoặc 0(giả).

Giải trình

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 đã lưu 1 byte: str.split()thay vìlist literal
• 8 byte được lưu: tốc ký cho len(x)-1
• Lưu 19 byte: J O BK B Rcho Joker, Orange, Black, Blue, Redchữ
• @ Mr.Xcoder đã lưu thêm 12 byte nữa, Cảm ơn !!
• Thêm 4 byte nhờ @ 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))

Hãy thử trực tuyến!

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

(Lưu ý rằng các trường hợp kiểm tra ở trên có chứa 2 trường hợp kiểm tra bổ sung không có trong Câu hỏi: chúng tương ứng đúng và sai: xem phiên bản không ghi chú để dễ đọc).

Quá trình thô sơ:

 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

Những người thích đùa được chỉ định bằng cách có 0giá trị bằng số của họ (một số âm cũng sẽ hoạt động); điều này giữ cho cấu trúc đầu vào nhất quán (có cả Màu và Giá trị) và không phụ thuộc vào việc phải kiểm tra xem c=="JOKER", có tiết kiệm 7 byte hay không.

Có thể một số dấu ngoặc đơn có thể được loại bỏ, có thể không đóng hộp qdưới dạng một mảng (tôi đã thử và giá trị chỉ ở mức 0 hoặc gây ra quỷ mũi ).

Ung dung:

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

Phiên bản tôi đã làm việc để có được logic chính xác. Lambdas sử dụng một lần có lót; đây là chức năng tương ứng của chúng:

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

Lấy màu sắc của gạch và số trên chúng dưới dạng danh sách các số nguyên riêng biệt. Các chi tiết cụ thể của ánh xạ đó không quan trọng miễn là mỗi màu có một số nguyên khác nhau và Jokers được biểu thị bằng 0.

Các định dạng để nhập số là khá đặc biệt mặc dù. Số cần được nhập cho một số nthay vì 2 ^ n, trong khi số được sử dụng để đại diện cho một người pha trò nên là (2 ^ 14) -1. Điều này cho phép bitwise và u&xđánh giá với u nếu ô x có giá trị bằng u hoặc là một 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));};

Một giải pháp dài hơn 2 byte mà không phải là chiết trung về đầu vào. Hóa ra chỉ sử dụng một trường hợp đặc biệt cho những người thích đùa ở một nơi mà họ khó đối phó không lâu hơn nhiều so với thao tác bitwise thông minh mà tôi rất tự hào. Ở đây, Jokers là (0,0), các số khác như mong đợi và màu sắc được biểu thị cho bất kỳ 4 giá trị nào khác biệt với nhau bằng so sánh mặc định của C # (cụ thể, Distinct()thao tác Linq phải xem xét các giá trị cho cùng màu là 'không khác biệt' và các giá trị cho các màu khác nhau là 'khác biệt').

Một cái gì đó có thể được sử dụng cho các ngôn ngữ khác, u*=!u++^x*xsẽ tương đương với u=u==x|x<1?u+1:0một số ngôn ngữ; u ^ x là 0 iff u == x và 0 lần bất kỳ int nào là 0, vì vậy u ^ x * x sẽ là 0 đối với u == x hoặc x == 0 nếu C # không thực hiện các thao tác bitwise có độ ưu tiên thấp hơn so với toán học. C # cũng không thể hiểu ints là bool mà không đúc rõ ràng. Một ngôn ngữ cố gắng hơn để làm cho các loại hoạt động có thể chuyển đổi các giá trị 0và not 0sang falsevà truetrước khi áp dụng !cho chúng, và sau đó khi quay lại phiên dịch int !falselà 1 và !true0. Tất cả những gì đã nói, tôi không thể đảm bảo ngôn ngữ khác sẽ thực sự lợi ích từ phần còn lại của thuật toán để nó có thể không xuất hiện.

Scala, 491 477 ký tự, 491 477 byte

Thử thách này rất vui; cảm ơn.

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}

Vì vậy, fở dòng 4 là một cuộc gọi đệ quy nơi tôi cố gắng thay thế "JOKER" bằng mọi ô khác. Xem tio để có cái nhìn rõ ràng hơn về mã. Tôi đã chọn lấy đầu vào là một chuỗi gồm 2 tuple (Int, String) - được gọi ttrong mã của tôi, xem tio - vì vậy "JOKER" được biểu thị bằng 2 tuple (0, "JOKER").

EDIT: 14 byte được lưu nhờ vào các bình luận, tôi lấy OB b R cho ORANGE BLACK BLUE RED.

Dùng thử trực tuyến!

EDIT: -2 ​​byte, đã xóa vô dụng (xung quanh các điều kiện của case _ ifs