Trong trò chơi hội đồng quản trị The Settlers of Catan , có năm loại tài nguyên: Brick, Log, Ore, Wheat và Sheep. Xây dựng một khu định cư tốn một viên gạch, khúc gỗ, lúa mì và cừu. Tuy nhiên, bạn cũng có thể giao dịch trong bốn tài nguyên giống hệt nhau để có được tài nguyên thuộc loại khác. Ví dụ, nếu bạn có bốn quặng trong tay, bạn có thể trao đổi tất cả chúng và lấy một con cừu.

Công việc của bạn là xác định liệu tôi có thể xây dựng một khu định cư hay không, trao tay tôi.

Nhiệm vụ của bạn

Đầu vào sẽ là một chuỗi của các chữ cái B, L, O, W, và S, thực hiện trong bất kỳ định dạng hợp lý. Những chữ cái này tương ứng với năm loại tài nguyên được đưa ra ở trên. Bạn nên xuất liệu tôi có tài nguyên cần thiết để xây dựng một khu định cư hay không, có tính đến khả năng giao dịch bốn loại.

Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte thắng.

Ghi chú

• Bạn không phải xuất các giao dịch tôi cần thực hiện hoặc có bao nhiêu khu định cư tôi có thể xây dựng. Một từ "có" hoặc "không" đơn giản sẽ làm được.
• Bạn không thể cho rằng đầu vào theo thứ tự cụ thể. Cụ thể, bạn không thể cho rằng các tài nguyên cùng loại được nhóm lại với nhau, do đó, OBLSOlà một đầu vào hợp lệ.
• Đây là vấn đề quyết định , vì vậy bạn có thể sử dụng bất kỳ giá trị nào bạn muốn có nghĩa là "có" và "không", miễn là hai giá trị được chọn là khác biệt và nhất quán.
• Các quy tắc duy nhất chúng tôi quan tâm ở đây là những quy tắc được liệt kê ở trên. Các quy tắc định cư phức tạp hơn của Catan như giao dịch với người chơi khác hoặc tại các bến cảng không liên quan ở đây.
• Các nhân vật đầu vào ( B, L, O, W, S) có thể được thay thế bằng các giá trị khác nếu nó là dễ dàng hơn cho ngôn ngữ cụ thể của bạn lựa chọn, miễn là có năm đầu vào riêng biệt. Nếu bạn sử dụng các giá trị đầu vào khác, vui lòng chỉ định chúng trong câu trả lời của bạn.

Ví dụ

BLWS -> Yes
OOOOWLB -> Yes (trade four O for a S)
OOW -> No
BBBO -> No
(empty input) -> No
BBBBLW -> No
BBBBBLW -> Yes (trade four B for a S)
OOOOOOOOOOOOOOOO -> Yes (sixteen O; trade for B, L, W, S)
BLBLBLBLBL -> Yes (trade L for W and B for S)
BLSWBLSWBLSW -> Yes (extra, unused resources are ignored)

Con trăn 2 , 54 byte

lambda s:sum((s+"BLSW"*3).count(n)/4for n in"BLSWO")>3

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

Đối với mỗi tài nguyên của chúng tôi, chúng tôi đếm số lượng các quyền tự do được đưa ra bằng cách có n tài nguyên đó. Một sự tự do đại diện cho một cơ hội để lấp đầy một trong những khe gạch-log-lúa mì-cừu mà chúng ta cần phải điền vào để giải quyết, vì thực tế là chúng ta có thể chuyển đổi tài nguyên của mình.

Đối với tất cả BLSW, việc có một trong số các tài nguyên mang lại cho chúng tôi một sự tự do như vậy, và mỗi lần vượt quá 4 sẽ mang lại cho chúng tôi một tài nguyên khác. Quy tắc đếm tự do là như thế này:

* Having 1 brick/log/wheat/sheep gives 1 freedom.
* Having 5 bricks/logs/wheat/sheep gives 2 freedoms.
* Having 9 bricks/logs/wheat/sheep gives 3 freedoms.
* …

Vì thế n viên gạch / khúc gỗ / lúa mì / cừu cho ⌋ (n + 3) / 4⌋ quyền tự do.

Đối với quặng, chỉ có bốn lượng dư thừa. Quy tắc đếm tự do là như thế này:

* Having 4 ores gives 1 freedom.
* Having 8 ores gives 2 freedoms.
* Having 12 ores gives 3 freedoms.
* …

Vì thế n quặng cho tự do ⌊n / 4⌋.

Định lý: chúng ta có thể giải quyết khi và chỉ khi chúng ta có ≥ 4 quyền tự do như vậy.

Vì vậy, chúng tôi đếm các quyền tự do của mình và kiểm tra xem có 4 trong số đó không. Để xử lý quặng đếm là ⌊n / 4⌋ nhưng các tài nguyên khác (n + 3) / 4⌋, chúng tôi tăng số lượng nhân tạo cho các tài nguyên khác bằng 3 và sau đó đếm n / 4⌋ cho tất cả các tài nguyên đó. Chúng tôi làm điều này bằng cách ánh xạ (s+"BLSW"*3).countthay vìs.count .

Bằng chứng :

• Giả sử chúng ta có thể giải quyết. Sau đó, với mỗi [B, L, S, W], chúng tôi (a) đã sử dụng 1 trong số tài nguyên mà chúng tôi đã có hoặc (b) đã hy sinh 4 trong số một số tài nguyên khác (bao gồm cả quặng) để tạo ra nó. Trong cả hai trường hợp, chúng tôi tính ít nhất 1 tự do theo các quy tắc trên. Vậy ta có ≥ 4 quyền tự do.

• Giả sử chúng ta có 4 quyền tự do, k trong số đó là do “thái quá” (mỗi giải thoát khỏi quặng là dư thừa, và mọi tự do từ các nguồn lực khác trong quá khứ là người đầu tiên cũng là) và 4-k trong số đó là nhân chứng của việc sở hữu ít nhất một gạch / khúc gỗ / lúa mì / cừu (thứ đã mang lại sự tự do đầu tiên cho người Hồi giáo). Sau đó, chúng tôi lấp đầy các khe 4 k bằng gạch / log / lúa mì / cừu đã cho chúng tôi sự tự do đầu tiên của chúng tôi và lấp đầy các khe k còn lại bằng cách chuyển đổi các phần thừa của chúng tôi. Tất cả 4 khe được lấp đầy và chúng tôi có thể giải quyết. Rõ ràng chúng ta vẫn có thể làm điều này nếu chúng ta có nhiều hơn 4 quyền tự do.

Bằng chứng này hút, nhưng tôi buồn ngủ. Tôi chắc chắn có một lời giải thích tốt hơn.

Python 2 ,  52  51 byte

-1 byte nhờ Luke (thay thế >=0bằng <0, đảo ngược kết quả False/ True)

lambda h:sum(~-(h+"O").count(c)/4for c in"BOWLS")<0

Một hàm không tên lấy một chuỗi các ký tự B , O , W , L và S (như trong OP) và trả về Falsenếu bạn có thể giải quyết hoặc Truenếu không.

Hãy thử trực tuyến! (ép đầu ra choyes/noOP).

Làm sao?

Đây là một cổng của câu trả lời Jelly của tôi. Chúng ta cần bù cho bất kỳ B , W , L hoặc S bị thiếu nào từ phần còn lại sau khi sử dụng một trong số chúng. Như vậy, chúng ta có thể thêm một chữ O vào tay, sau đó giảm tất cả các số đếm một, sau đó số nguyên chia tất cả các số cho bốn và sau đó tổng - nếu kết quả bằng 0 hoặc nhiều hơn, chúng ta có thể giải quyết (vì không thiếu tài nguyên cần thiết hoặc bởi vì chúng ta có thể giao dịch để có được (các) cái còn thiếu.

lambda h:sum(~-(h+"O").count(c)/4for c in"BOWLS")<0
lambda h:                                           - a function that takes h (a string)
                                 for c in"BOWLS"    - for each letter, c, in "BOWLS":
                h+"O"                               -   append "O" to h
               (     ).count(c)                     -   count c instances
              -                                     -   negate
             ~                                      -   bitwise not (this is -x-1)
                               /4                   -   integer divide by 4
                                                    -    (NB: -1 and 0 are not affected)
         sum(                                   )   - sum the five values
                                                 <0 - less than zero? (inverted result)

Bình thường , 14 byte

gsm/t/+Q4d4U5Z

Hãy thử nó ở đây! hoặc Xác minh tất cả các trường hợp thử nghiệm.

Pyth ,  31 27 17  16 byte

<3s/R4/L+Q*3U4U5

Xác nhận các trường hợp thử nghiệm.

Làm thế nào để làm việc này?

Giải thích số 1

gsm/t/+Q4d4U5Z   - Full program.

  m        U5    - Map over the range [0, 5) with a variable d.
      +Q4        - The input, with a 4 appended (this corresponds to O)
     /   d       - Count the occurrences of the current value in ^.
    t            - Decrement.
   /      4      - Integer division by 4.
 s               - Sum
g            Z   - Is non-negative (is the sum ≥ 0)?  
                 - Output implicitly.

Giải thích số 2

<3s/R4/L+Q*3U4U5   - Full program.

          *3U4     - The range [0, 4) repeated 3 times.
        +Q         - The input with ^ appended.
      /L      U5   - Count the occurrences of each element in [0, 5) in ^.
   /R4             - Integer division of each by 4.
  s                - Sum.
<3                 - Is higher than 3?
                   - Output implicitly.

Đây là những mã được sử dụng bởi chương trình của tôi:

B -> 0
L -> 1
S -> 2
W -> 3
O -> 4

Thạch ,  13  12 byte

;5ċЀ5’:4S>-

Một liên kết đơn âm chấp nhận danh sách các số đại diện cho tài nguyên bạn sở hữu và trả lại 1nếu bạn có thể ổn định hoặc0 nếu không.

Các tài nguyên là 1, 2, 3, 4, 5nơi 5đại diện Ore .

Hãy thử trực tuyến!hoặc xem bộ thử nghiệm (sử dụng OP IO).

Làm sao?

Ý tưởng trước tiên là đếm các tài nguyên theo loại, sau đó giảm tất cả số lượng B , L , W và S xuống một - nếu chúng ta không đếm được bất kỳ tài nguyên nào trong bốn tài nguyên này thì bây giờ chúng sẽ có các mục -1 - chúng ta cần có được chúng từ các tài nguyên còn lại của chúng tôi (Điều này thực sự đạt được bằng cách thêm O ( 5) và giảm tất cả năm số đếm xuống 1 ). Tiếp theo, chúng tôi chia số nguyên cho tất cả các giá trị này cho bốn để xem có bao nhiêu đơn vị chúng tôi có thể giao dịch với mỗi số đếm còn lại của chúng tôi theo loại tài nguyên trong khi không ảnh hưởng đến -1 và 0 (lưu ý rằng -1 số nguyên chia cho bốn là-1 , không phải 0 ). Cuối cùng, chúng tôi cộng các giá trị và kiểm tra xem kết quả lớn hơn hoặc bằng 0 (ở đây lớn hơn -1 có thể được sử dụng vì chúng tôi luôn có số nguyên).

;5ċЀ5’:4S>- - Link: list of numbers (BLWSO:12345) e.g. [3,2,2,2,2,2,5,5,5,5] (WLLLLLOOOO)
;5           - concatenate a five                       [3,2,2,2,2,2,5,5,5,5,5]
     5       - literal 5
   Ѐ        - map across implicit range(5) = [1,2,3,4,5]:
  ċ          -   count                                  [ 0, 5, 1, 0, 5]
      ’      - decrement (vectorises)                   [-1, 4, 0,-1, 4]
       :4    - integer divide by four                   [-1, 1, 0,-1, 1]
         S   - sum                                      0
           - - literal -1                              -1
          >  - greater than?                            1

Java 8, 101 byte

Lambda từ int[]đến boolean. Chỉ định cho Function<int[], Boolean>.

a->{int h,f[]=new int[5],i=0;for(int x:a)f[x]++;for(h=f[4]/4;i<4;)h+=--f[i]>>-1|f[i++]/4;return~h<0;}

Dùng thử trực tuyến

Đầu vào và đầu ra

Đầu vào là một dãy các số nguyên từ 0 đến 4, bao gồm. 4 đại diện cho Ore, và các ánh xạ khác là không quan trọng. Các trường hợp thử nghiệm của tôi là bản dịch trực tiếp của những người trong câu hỏi, với 0 là Brick, 1 là Log, 2 là Wheat và 3 là Sheep.

Đầu ra là liệu một khu định cư có thể được xây dựng.

Bị đánh cắp

a -> {
    int
        h,
        f[] = new int[5],
        i = 0
    ;
    for (int x : a)
        f[x]++;
    for (h = f[4] / 4; i < 4; )
        h += --f[i] >> 31 | f[i++] / 4;
    return ~h < 0;
}

Giải trình

hlà số lượng gấp bốn lần tài nguyên có sẵn để giao dịch. Chúng tôi lặp lại qua từng loại tài nguyên (trừ Ore), tăng dần hcho mỗi bốn phần tài nguyên bổ sung mà chúng tôi có và giảm dần khi không có tài nguyên. Sau đó, kết quả của chúng tôi là liệu hkhông âm.

Dòng

h += --f[i] >> 31 | f[i++] / 4;

điều chỉnh hmột cách thích hợp bất kể không có tài nguyên (thiếu) hay có ít nhất một tài nguyên (thặng dư). f[i]được giảm xuống để chiếm tài nguyên cần thiết trong trường hợp dư thừa, tạo ra -1 trong trường hợp thiếu. Sự thay đổi bên phải đã ký làm giảm biểu thức thành 0 (trường hợp dư) hoặc -1 (trường hợp thiếu), do đó, theo chiều bit HOẶC với sốf[i++] / 4 gấp bốn lần (trong trường hợp thặng dư) không có hiệu lực trong trường hợp thiếu hụt nhưng dẫn đến số chính nó trong trường hợp dư thừa.

Lời cảm ơn

• -9 byte nhờ Nevay, bậc thầy về bit

Võng mạc , 34 byte

^
BBBLLLWWWSSS
O`.
((.)\2{3}.*){4}

Hãy thử trực tuyến! Giải thích: Xây dựng một khu định cư đòi hỏi 4 tài nguyên là B, L, W hoặc S đầu tiên của bạn hoặc bất kỳ 4 tài nguyên nào khác cùng loại. Điều này tương đương với việc thêm ba trong số bốn loại tài nguyên đó và sau đó đếm xem bạn có bốn bộ bốn hay không.

Thạch , 23 byte

œ-4R¤©Ġs€4ẎL€>3+®e€$S>3

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

Tham khảo bảng sau để biết các giá trị:

B: 1
L: 2
O: 5
W: 3
S: 4

Võng mạc , 43 byte

O`.
O{4}
a
}`([^a])\1{4}
$1a
O

D`[^a]
.{4}

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

Trăn 3 , 79 78 byte

Chỉnh sửa: -1 byte nhờ @ Mr.Xcoder

lambda x:3<sum((a>0)+~-a*(a>1)//4for a in map(x.count,"BLSW"))+x.count("O")//4

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

MATL , 19 byte

Oh!5:=s4&\w4:)ghs3>

Đầu vào là một vectơ hàng số trong đó các chữ cái được biểu diễn dưới dạng số như sau:

B: 1
L: 2
W: 3
S: 4
O: 5

Đầu ra là 1cho sự thật, 0cho sự giả dối .

Dùng thử trực tuyến!: Xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

1. Đếm số lượng của mỗi tài nguyên.
2. Div-mod chúng bằng 4.
3. Đếm xem có bao nhiêu phần còn lại cho bốn tài nguyên (chữ cái BLWS) đầu tiên là khác không. Điều này cho một số c .
4. Tính tổng các chỉ tiêu. Điều này cho một số s .
5. Đầu ra cho dù c + s 4.

Mã nhận xét

Oh     % Append 0 to implicit input. This is just in case inpout is empty
!      % Convert into column vector
5:     % Push row vector [1 2 3 4 5]
=      % Compare for equality, element-wise with broadcast
s      % Sum of each column. Gives number of times that each entry of
       % [1 2 3 4 5] appears in the input
4&\    % Mod-div 4, element-wise. Pushes vector of remainders and then vector
       % of quotients of division by 4
w      % Swap. Brings remainders to top
4:)    % Get the first four entries
g      % Convert to logical. This transforms non-zero values into 1
h      % Concatenate with vector of quotients
s      % Sum
3>     % Does the result exceed 3? Implicitly display

> <> , 61 byte

510ap\~1(n;
1+$ap> i:0(?v8%:ag
0:ga:v?=5:+1<$-}$,4-%4:-}-${:)

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

Sử dụng ánh xạ tài nguyên sau:

O -> 0
B -> 1
L -> 2
W -> 3
S -> 4

Nó không thực sự có vấn đề gì lập bản đồ được sử dụng, miễn là họ đang ở trong phạm vi 0-4, và 0được sử dụng cho O. Làm cho việc sử dụng thực tế là tìm kiếm sự kết hợp BLWScũng giống như tìm kiếm sự kết hợp OBLWStrong khi đã có một Otrong tay.

05AB1E , 19 byte

0 -> Quặng
1 -> Gạch
2 -> Nhật ký
3 -> Lúa mì
4 -> Cừu

Trả về 0 khi sai và 1 khác.

{γvyDĀi¼¨}g4÷}¾)O3›

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

Giải trình:

{γvyDĀi¼¨}g4÷}¾)O3› Implicit input, e.g. 0030201
{                   Sort -> 0000123
 γ                  Split into chunks of consecutive elements: [0000, 1, 2, 3]
  vy                For each chunk...
    DĀ                 ...is different than 0?
      i¼¨}                ...if true: increment the counter by 1, and 
                              remove 1 element from the chunk
          g4÷         ...divide the number of elements by 4
             }      End For
              ¾     Push the counter
               )    Wrap the entire stack in a list
                O   Sum of that list
                 3> True if > 3
                    Implicit output

Giải pháp không cạnh tranh: 17 byte

Có một lỗi trong 05AB1E khi tôi lần đầu tiên gửi giải pháp đó, trong đó một số nhà khai thác xử lý không tốt các đầu vào trống. Điều này dẫn đến giải pháp này trả lời 1trên một đầu vào trống. Điều này hiện đã được sửa chữa, vì vậy giải pháp này hoạt động tốt.

Sự khác biệt ở đây là chúng tôi thêm một quặng trước khi loại bỏ một trong mỗi tài nguyên, một cách bừa bãi, đếm số lượng tài nguyên bị loại bỏ theo cách đó. Sau đó, chúng tôi giảm số lượt truy cập bằng 1 để lấy đúng số B, L, W và S.

0«{γε¨g4÷¼}O¾<+3›

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

JavaScript (SpiderMonkey) , 116 byte

s=>Array.from("BLOWS").reduce((m,c)=>Math.floor(((s+"BLSW".repeat(3)).match(new RegExp(c,'g'))||"").length/4)+m,0)>3

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

Siêu Clunky trả lời xấu. Tôi chắc chắn rằng nó có thể được làm sạch nhiều hơn. Phương pháp lấy cảm hứng từ câu trả lời của Lynn trong chủ đề này.

Kotlin , 131 129 byte

Nộp hồ sơ

fun r(i:String):Any=i.split("").groupingBy{it}.eachCount().map{when(it.key){
""->0
"O"->it.value/4
else->(it.value+3)/4}}.sum()>3

Kiểm tra

fun r(i:String):Any=i.split("").groupingBy{it}.eachCount().map{when(it.key){
""->0
"O"->it.value/4
else->(it.value+3)/4}}.sum()>3

data class TestData(val input:String, val output:Boolean) {
    fun run() {
        val out = r(input)
        if (out != output) {
            throw AssertionError("Failed test: ${this} -> $out")
        }
    }
}
fun main(args: Array<String>) {
    listOf(

            TestData("BLWS", true),
            TestData("OOOOWLB", true),
            TestData("OOW", false),
            TestData("BBBO", false),
            TestData("", false),
            TestData("BBBBLW", false),
            TestData("BBBBBLW", true),
            TestData("OOOOOOOOOOOOOOOO", true),
            TestData("BLBLBLBLBL", true),
            TestData("BLSWBLSWBLSW", true)
    ).forEach(TestData::run)
    println("Test passed")
}

Không thể hoạt động trên TryItOnline, nhưng hoạt động trên try.kotlinlang.org