ในเกมกระดานSettlers of Catanมีห้าประเภทของทรัพยากร: Brick, Log, Ore, Wheat, และ Sheep การสร้างการตั้งถิ่นฐานมีค่าใช้จ่ายแบบอิฐท่อนซุงข้าวสาลีและแกะ อย่างไรก็ตามคุณยังสามารถแลกเปลี่ยนทรัพยากรที่เหมือนกันสี่อย่างเพื่อรับทรัพยากรประเภทอื่น ตัวอย่างเช่นหากคุณมีแร่สี่มือคุณสามารถแลกเปลี่ยนทั้งหมดและรับแกะหนึ่งตัว

งานของคุณคือการพิจารณาว่าฉันสามารถสร้างข้อตกลงได้หรือไม่

งานของคุณ

การป้อนข้อมูลจะเป็นลำดับของตัวอักษรB, L, O, WและSนำมาในรูปแบบที่เหมาะสมใด ๆ ตัวอักษรเหล่านี้สอดคล้องกับทรัพยากรห้าประเภทที่ระบุไว้ด้านบน คุณควรส่งออกหรือไม่ฉันมีทรัพยากรที่จำเป็นในการสร้างการตั้งถิ่นฐานโดยคำนึงถึงความเป็นไปได้ของการซื้อขายสี่ชนิด

นี่คือcode-golfดังนั้นรหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

หมายเหตุ

• คุณไม่จำเป็นต้องแสดงผลลัพธ์การซื้อขายที่ฉันต้องทำหรือจำนวนการตั้งถิ่นฐานที่ฉันสามารถสร้างได้ "ใช่" หรือ "ไม่" ง่าย ๆ จะทำ
• คุณอาจไม่คิดว่าอินพุตอยู่ในลำดับเฉพาะใด ๆ โดยเฉพาะอย่างยิ่งคุณอาจไม่คิดว่าทรัพยากรประเภทเดียวกันจะถูกจัดกลุ่มเข้าด้วยกันดังนั้นจึงOBLSOเป็นอินพุตที่ถูกต้อง
• นี่คือปัญหาในการตัดสินใจดังนั้นคุณสามารถใช้ค่าใด ๆ ที่คุณต้องการหมายถึง "ใช่" และ "ไม่" ตราบใดที่ค่าที่เลือกสองค่านั้นแตกต่างกันและสอดคล้องกัน
• กฎเดียวที่เราเกี่ยวข้องนี่คือกฎที่ระบุไว้ด้านบน ผู้ตั้งกฎ Catan ที่ซับซ้อนมากขึ้นเช่นการซื้อขายกับผู้เล่นอื่นหรือที่ท่าเรือไม่เกี่ยวข้องที่นี่
• ตัวละครอินพุท ( B, L, O, W, S) สามารถทดแทนกับค่าอื่น ๆ ถ้ามันเป็นเรื่องง่ายสำหรับภาษาใดภาษาหนึ่งของทางเลือกตราบใดที่มีห้าปัจจัยการผลิตที่แตกต่างกัน หากคุณใช้ค่าอินพุตอื่น ๆ โปรดระบุไว้ในคำตอบของคุณ

ตัวอย่าง

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)

Python 2 , 54 ไบต์

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

ลองออนไลน์!

สำหรับแต่ละทรัพยากรของเราเรานับจำนวนของ“เสรีภาพ”ที่กำหนดโดยมีnของทรัพยากรที่ อิสรภาพแสดงให้เห็นถึงโอกาสในการเติมช่องแกะสลักอิฐ - ข้าวสาลี - หนึ่งที่เราต้องกรอกเพื่อชำระบัญชีซึ่งเป็นข้อเท็จจริงที่ว่าเราสามารถแปลงทรัพยากรของเราได้

สำหรับทุก BLSW มีหนึ่งของทรัพยากรที่จะช่วยให้เราเป็นหนึ่งในเสรีภาพดังกล่าวและทุกส่วนเกินที่เพิ่มขึ้นของ 4 จะช่วยให้เราอีก กฎการนับอิสระเป็นเช่นนี้:

* 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.
* …

ดังนั้นnอิฐ / logs / ข้าวสาลี / แกะให้⌊ (n + 3) / 4⌋เสรีภาพ

สำหรับสินแร่เท่านั้นจำนวนที่เหลืออยู่เท่านั้นที่นับได้ กฎการนับอิสระเป็นเช่นนี้:

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

ดังนั้นnแร่ให้⌊n / 4⌋เสรีภาพ

ทฤษฎีบท:เราสามารถตัดสินได้ถ้าหากเรามี "เสรีภาพ" เช่นนั้น≥ 4

ดังนั้นเราจะนับจำนวนเสรีภาพของเราและตรวจสอบว่ามี≥ 4 ของพวกเขาหรือไม่ ในการจัดการกับการนับแร่เป็น⌊n / 4⌋ แต่แหล่งข้อมูลอื่น⌊ (n + 3) / 4⌋เราจะขยายจำนวนนับสำหรับทรัพยากรอื่น ๆ โดย 3 และจากนั้นนับ⌊n / 4⌋สำหรับพวกเขาทั้งหมด เราทำเช่นนี้โดยการทำแผนที่แทน(s+"BLSW"*3).counts.count

หลักฐาน :

• สมมติว่าเราสามารถชำระ จากนั้นสำหรับ [B, L, S, W] เราแต่ละคน (a) ใช้ 1 ของทรัพยากรที่เรามีอยู่แล้วหรือ (b) เสียสละ 4 ของทรัพยากรอื่น ๆ (รวมถึงแร่) เพื่อสร้าง ไม่ว่าในกรณีใดเราจะนับอย่างน้อย 1 อิสรภาพโดยกฎข้างต้น ดังนั้นเรามี≥ 4 เสรีภาพ

• สมมติว่าเรามี 4 เสรีภาพ, k ซึ่งเกิดจาก "ความเกิน" (ทุกอิสรภาพจากแร่นั้นมากเกินไป, และอิสรภาพจากทรัพยากรอื่น ๆ ที่ผ่านมาเป็นคนแรกเช่นกัน) และ 4 − k ซึ่งเป็นพยานในการเป็นเจ้าของอย่างน้อยหนึ่งคน อิฐ / บันทึก / ข้าวสาลี / แกะ (หนึ่งที่ให้ "เสรีภาพแรก") จากนั้นเราเติมช่อง 4 − k ด้วยอิฐ / ท่อนซุง / ข้าวสาลี / แกะที่ให้อิสระแก่เราครั้งแรกและเติมช่อง k ที่เหลือโดยการแปลงส่วนเกินของเรา ช่องทั้ง 4 นั้นเต็มไปและเราสามารถตัดสินได้ เราสามารถเห็นได้ชัดว่ายังคงทำเช่นนี้หากเรามีมากขึ้นกว่า 4 เสรีภาพ

หลักฐานนี้แย่มาก แต่ฉันง่วงนอน ฉันแน่ใจว่ามีคำอธิบายที่ดีกว่า

Python 2 ,  52  51 ไบต์

-1 ไบต์ขอบคุณLuke (แทนที่>=0ด้วย<0inverting the False/ Trueresults)

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

ฟังก์ชั่นที่ไม่มีชื่อใช้สตริงของตัวละครB , O , W , LและS (เช่นเดียวกับใน OP) และกลับมาFalseถ้าคุณสามารถชำระหรือTrueไม่

ลองออนไลน์! (รวมการส่งออกไปยังค่าyes/noของ OP)

อย่างไร?

นี่คือพอร์ตของคำตอบ Jelly ของฉัน เราต้องชดเชยค่าB , W , LหรือS ที่ขาดหายไปหลังจากใช้หนึ่งในนั้น เช่นนี้เราสามารถเพิ่มOพิเศษไว้ในมือของเราจากนั้นลดจำนวนที่นับได้ทั้งหมดจากนั้นหนึ่งจำนวนเต็มหารจำนวนที่นับทั้งหมดด้วยสี่แล้วรวม - ถ้าผลลัพธ์เป็นศูนย์หรือมากกว่านั้นเราสามารถชำระได้ (เพราะไม่มีทรัพยากรที่จำเป็นขาดหายไป หรือเพราะเราสามารถแลกเปลี่ยนเพื่อรับสิ่งที่ขาดหายไป

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)

Pyth , 14 ไบต์

gsm/t/+Q4d4U5Z

ลองที่นี่! หรือตรวจสอบกรณีทดสอบทั้งหมด

Pyth ,  31 27 17  16 ไบต์

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

ตรวจสอบกรณีทดสอบ

ทำงานเหล่านี้ได้อย่างไร

คำอธิบาย # 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.

คำอธิบาย # 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.

นี่คือรหัสที่โปรแกรมของฉันใช้:

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

เยลลี่ ,  13  12 ไบต์

;5ċЀ5’:4S>-

ลิงก์ monadic ยอมรับรายการตัวเลขที่แสดงถึงทรัพยากรที่คุณเป็นเจ้าของและส่งคืน1หากคุณสามารถชำระได้หรือ0ไม่

ทรัพยากรที่มี1, 2, 3, 4, 5ที่5หมายถึงแร่

ลองออนไลน์! หรือดูชุดทดสอบ (โดยใช้ OP IO)

อย่างไร?

แนวคิดคือการนับทรัพยากรตามประเภทก่อนจากนั้นลดจำนวนB , L , WและS ทั้งหมดโดยหนึ่ง - ถ้าเรานับไม่มีเลยสำหรับทั้งสี่นี้แล้วตอนนี้พวกเขาจะมีรายการ-1 - เราต้องได้รับ พวกเขาจากแหล่งข้อมูลที่เหลือของเรา (ซึ่งสามารถทำได้จริงโดยการเพิ่มOพิเศษ( 5) และลดจำนวนทั้งห้าด้วย1 ) ต่อไปเราจะหารค่าทั้งหมดเหล่านี้ด้วยสี่เพื่อดูจำนวนหน่วยที่เราอาจแลกเปลี่ยนกับจำนวนที่เหลือของเราแต่ละประเภทตามประเภททรัพยากรในขณะที่ไม่มีผลต่อการนับ-1และ0 (โปรดทราบว่า-1จำนวนเต็มหารด้วยสี่คือ-1ไม่ใช่0 ) สุดท้ายเราเพิ่มค่าและตรวจสอบว่าผลลัพธ์มากกว่าหรือเท่ากับศูนย์ (ที่นี่มากกว่า-1สามารถใช้เนื่องจากเรามักจะมีจำนวนเต็ม)

;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 ไบต์

แลมบ์ดาจากไปint[] มอบหมายให้booleanFunction<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;}

ลองใช้ออนไลน์

อินพุตและเอาต์พุต

อินพุตคืออาร์เรย์ของจำนวนเต็มตั้งแต่ 0 ถึง 4 โดยรวม 4 หมายถึงแร่และการแมปอื่น ๆ นั้นไม่สำคัญ กรณีทดสอบของฉันคือการแปลโดยตรงของคำถามเหล่านั้นโดยมี 0 เป็นอิฐ 1 เป็นบันทึก 2 เป็นข้าวสาลีและ 3 เป็นแกะ

ผลลัพธ์คือการสร้างข้อตกลง

Ungolfed

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

คำอธิบาย

hคือจำนวนสี่เท่าของทรัพยากรที่มีอยู่เพื่อการค้า เราวนซ้ำทรัพยากรแต่ละประเภท (ยกเว้นแร่) การเพิ่มhสำหรับแต่ละสี่เท่าของทรัพยากรพิเศษที่เรามีและการลดลงเมื่อไม่มีทรัพยากรอยู่ ถ้าอย่างนั้นผลลัพธ์ของเราคือไม่hติดลบ

เส้น

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

ปรับhอย่างเหมาะสมโดยไม่คำนึงว่าไม่มีทรัพยากร (ขาดแคลน) หรือมีอย่างน้อยหนึ่งทรัพยากร (ส่วนเกิน) f[i]ถูกลดขนาดให้กับบัญชีสำหรับทรัพยากรที่ต้องการในกรณีส่วนเกินโดยสร้าง -1 ในกรณีขาดแคลน การเปลี่ยนแปลงด้านขวาที่ลงนามจะลดการแสดงออกเป็น 0 (กรณีส่วนเกิน) หรือ -1 (กรณีการขาดแคลน) ดังนั้นบิตหรือ OR ที่มีจำนวนf[i++] / 4ของส่วนเกินสี่เท่า (ในกรณีส่วนเกิน) ไม่มีผลในกรณีการขาดแคลน แต่ส่งผลให้จำนวน ตัวเองในกรณีส่วนเกิน

กิตติกรรมประกาศ

• -9 ไบต์ขอบคุณ Nevay, Master of bits

เรติน่า 34 ไบต์

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

ลองออนไลน์! คำอธิบาย: การสร้างข้อตกลงต้องใช้ทรัพยากร 4 ประเภทซึ่งอาจเป็น B, L, W หรือ S แรกของคุณหรือแหล่งข้อมูลอื่น ๆ 4 ประเภทที่เหมือนกัน สิ่งนี้เทียบเท่ากับการเพิ่มสามในสี่ประเภทของทรัพยากรเหล่านั้นแล้วนับเพื่อดูว่าคุณมีสี่ชุดสี่ชุด

เยลลี่ 23 ไบต์

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

ลองออนไลน์!

อ้างถึงตารางต่อไปนี้สำหรับค่า:

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

เรติน่า 43 ไบต์

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

D`[^a]
.{4}

ลองออนไลน์!

Python 3 , 79 78 ไบต์

แก้ไข: -1 ไบต์ขอบคุณ@ Mr.Xcoder

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

ลองออนไลน์!

MATL , 19 ไบต์

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

อินพุตเป็นเวกเตอร์แถวที่เป็นตัวเลขซึ่งตัวอักษรถูกแทนด้วยตัวเลขดังนี้:

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

เอาท์พุท1สำหรับความจริง0สำหรับเท็จ

ลองมันออนไลน์ !: ตรวจสอบกรณีทดสอบทั้งหมด

มันทำงานอย่างไร

1. นับจำนวนรอบของแต่ละทรัพยากร
2. Div-mod พวกเขา 4
3. นับจำนวนเศษที่เหลือสำหรับสี่ทรัพยากรแรก (ตัวอักษรBLWS) ที่ไม่ใช่ศูนย์ นี้จะช่วยให้ตัวเลขค
4. รวมผลหาร นี้จะช่วยให้จำนวนs
5. เอาต์พุตไม่ว่าจะเป็นc + s ≥ 4

รหัสแสดงความคิดเห็น

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 ไบต์

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

ลองออนไลน์!

ใช้การแมปทรัพยากรต่อไปนี้:

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

ไม่สำคัญว่าจะใช้การจับคู่แบบใดตราบใดที่อยู่ในช่วง0-4และ0ใช้สำหรับ O. ใช้ข้อเท็จจริงที่ว่าการค้นหาชุดค่าผสมBLWSนั้นเหมือนกับการค้นหาชุดค่าผสมOBLWSในขณะที่มีอยู่แล้วOใน มือ.

05AB1E , 19 ไบต์

0 -> Ore
1 -> Brick
2 -> Log
3 -> Wheat
4 -> Sheep

ส่งคืน 0 เมื่อเท็จและ 1 เป็นอย่างอื่น

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

ลองออนไลน์!

คำอธิบาย:

{γ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

โซลูชันที่ไม่สามารถแข่งขันได้: 17 ไบต์

มีข้อผิดพลาดใน 05AB1E เมื่อฉันส่งโซลูชันนั้นเป็นครั้งแรกซึ่งผู้ให้บริการบางรายจัดการอินพุตว่างไม่ดี สิ่งนี้ส่งผลให้โซลูชันนี้ตอบกลับ1อินพุตว่าง ตอนนี้ได้รับการแก้ไขแล้วดังนั้นวิธีนี้จึงใช้ได้ดี

ความแตกต่างที่นี่คือเราเพิ่มแร่ก่อนที่จะลบหนึ่งในแต่ละทรัพยากรตามอำเภอใจนับจำนวนทรัพยากรที่เอาออกด้วยวิธีการนั้น จากนั้นเราจะลดจำนวนตัวนับ 1 เพื่อให้ได้จำนวน B, L, W และ S ที่ถูกต้อง

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

ลองออนไลน์!

JavaScript (SpiderMonkey) , 116 ไบต์

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

ลองออนไลน์!

คำตอบที่ไม่ดี Super Clunky ฉันแน่ใจว่ามันสามารถทำความสะอาดได้มากขึ้น วิธีที่ได้แรงบันดาลใจจากคำตอบของ Lynn ในหัวข้อนี้

Kotlin , 131 129 ไบต์

ส่ง

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

ทดสอบ

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

ไม่สามารถใช้งาน TryItOnline ได้ แต่ใช้งานได้กับ try.kotlinlang.org