Dalam permainan papan The Settlers of Catan , ada lima jenis sumber daya: Brick, Log, Ore, Wheat, dan Sheep. Membangun pemukiman membutuhkan biaya untuk mendapatkan Brick, Log, Gandum, dan Domba. Namun, Anda juga dapat berdagang di empat sumber daya yang identik untuk mendapatkan sumber daya dari jenis yang berbeda. Misalnya, jika Anda memiliki empat bijih di tangan, Anda bisa menukar semuanya dan mendapatkan satu domba.

Tugas Anda adalah menentukan apakah saya dapat membangun pemukiman atau tidak, dengan tangan saya.

Tugas Anda

Masukan akan menjadi urutan huruf B, L, O, W, dan S, diambil dalam format yang wajar. Surat-surat ini sesuai dengan lima jenis sumber daya yang diberikan di atas. Anda harus memberi tahu apakah saya memiliki sumber daya yang diperlukan untuk membangun penyelesaian, dengan mempertimbangkan kemungkinan perdagangan empat jenis.

Ini adalah kode-golf , jadi kode terpendek dalam byte menang.

Catatan

• Anda tidak harus menampilkan perdagangan apa yang perlu saya lakukan atau berapa banyak pemukiman yang bisa saya bangun. "Ya" atau "tidak" yang sederhana akan berhasil.
• Anda tidak boleh berasumsi bahwa input dalam urutan tertentu. Secara khusus, Anda mungkin tidak berasumsi bahwa sumber daya dari jenis yang sama dikelompokkan bersama, jadi OBLSOmerupakan input yang valid.
• Ini adalah masalah keputusan , jadi Anda dapat menggunakan nilai apa pun yang Anda inginkan dengan "ya" dan "tidak", selama dua nilai yang dipilih berbeda dan konsisten.
• Satu-satunya aturan yang kami perhatikan di sini adalah yang tercantum di atas. Aturan Settler of Catan yang lebih rumit seperti perdagangan dengan pemain lain atau di pelabuhan tidak relevan di sini.
• Karakter input ( B, L, O, W, S) dapat diganti dengan nilai-nilai lain jika lebih mudah untuk bahasa tertentu pilihan Anda, asalkan ada lima input yang berbeda. Jika Anda menggunakan nilai input lain, harap sebutkan dalam jawaban Anda.

Contohnya

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 byte

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

Cobalah online!

Untuk setiap sumber daya kami, kami menghitung jumlah "kebebasan" yang diberikan dengan memiliki n dari sumber daya itu. Suatu kebebasan merupakan kesempatan untuk mengisi salah satu slot bata-kayu-gandum-domba yang perlu kita isi untuk menyelesaikan, dengan memperhitungkan fakta bahwa kita dapat mengkonversi sumber daya kita.

Untuk semua BLSW, memiliki salah satu sumber daya memberi kita satu kebebasan seperti itu, dan setiap kelebihan tambahan 4 memberi kita yang lain. Aturan penghitungan kebebasan adalah seperti ini:

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

Jadi n batu bata / log / gandum / domba memberikan ⌊ (n + 3) / 4⌋ kebebasan.

Untuk bijih, hanya kelebihan foursome yang dihitung. Aturan penghitungan kebebasan adalah seperti ini:

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

Jadi n ores memberikan ⌊n / 4⌋ kebebasan.

Teorema: kita dapat menyelesaikan jika dan hanya jika kita memiliki ≥ 4 "kebebasan".

Jadi kami menghitung kebebasan kami dan memeriksa apakah ada ≥ 4 di antaranya. Untuk menangani penghitungan bijih sebagai ⌊n / 4⌋ tetapi sumber daya lain ⌊ (n + 3) / 4⌋, kami secara artifisial meningkatkan jumlah sumber daya lainnya sebesar 3 dan kemudian menghitung ⌊n / 4⌋ untuk semuanya. Kami melakukan ini dengan memetakan (s+"BLSW"*3).countalih-alih s.count.

Bukti :

• Misalkan kita bisa menyelesaikan. Kemudian untuk masing-masing [B, L, S, W], kami (a) menggunakan 1 dari sumber daya yang telah kami miliki, atau (b) mengorbankan 4 dari beberapa sumber daya lain (termasuk bijih) untuk membuatnya. Dalam kedua kasus, kami menghitung setidaknya 1 kebebasan dengan aturan di atas. Jadi kita memiliki ≥ 4 kebebasan.

• Misalkan kita memiliki 4 kebebasan, k yang disebabkan oleh "ekses" (setiap kebebasan dari bijih adalah ekses, dan setiap kebebasan dari sumber daya lain melewati yang pertama juga ada) dan 4 − k di antaranya adalah saksi memiliki setidaknya satu bata / log / gandum / domba (yang memberi "kebebasan pertama"). Kemudian kita mengisi 4 − k slot dengan batu bata / log / gandum / domba yang memberi kita kebebasan pertama kita, dan mengisi slot k yang tersisa dengan mengubah kelebihan kita. Semua 4 slot diisi dan kita bisa menyelesaikan. Kami jelas masih bisa melakukan ini jika kami memiliki lebih dari 4 kebebasan.

Bukti ini menyebalkan, tapi saya mengantuk. Saya yakin ada penjelasan yang lebih baik.

Python 2 ,  52  51 byte

-1 byte terima kasih kepada Luke (ganti >=0dengan <0, membalik False/ Truehasil)

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

Fungsi tanpa nama mengambil string karakter B , O , W , L , dan S (seperti pada OP) dan kembali Falsejika Anda dapat menyelesaikan atau Truejika tidak.

Cobalah online! (memaksa output keyes/noOP).

Bagaimana?

Ini adalah port jawaban Jelly saya. Kita perlu menebus B , W , L , atau S yang hilang dari sisa setelah menggunakan salah satu dari mereka masing-masing. Dengan demikian kita dapat menambahkan O ekstra ke tangan kita, kemudian mengurangi semua hitungan dengan satu, lalu integer membagi semua jumlah dengan empat dan kemudian menjumlahkan - jika hasilnya nol atau lebih kita dapat menyelesaikan (baik karena tidak ada sumber daya yang diperlukan hilang) atau karena kita dapat berdagang untuk mendapatkan yang hilang.

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 byte

gsm/t/+Q4d4U5Z

Coba di sini! atau Verifikasi semua kasus uji.

Pyth ,  31 27 17  16 byte

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

Verifikasi kasus uji.

Bagaimana cara kerjanya?

Penjelasan # 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.

Penjelasan # 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.

Ini adalah kode yang digunakan oleh program saya:

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

Jelly ,  13  12 byte

;5ċЀ5’:4S>-

Tautan monadik yang menerima daftar angka yang mewakili sumber daya yang Anda miliki dan kembali 1jika Anda dapat menyelesaikannya atau 0jika tidak.

Sumber daya adalah 1, 2, 3, 4, 5tempat 5mewakili Bijih .

Cobalah online! atau lihat test-suite (menggunakan OP IO).

Bagaimana?

Idenya adalah untuk pertama menghitung sumber daya berdasarkan jenis, kemudian mengurangi semua jumlah B , L , W , dan S oleh satu - jika kita tidak menghitung satu pun dari keempat ini maka mereka sekarang akan memiliki entri -1 - kita perlu memperoleh mereka dari sumber daya kami yang tersisa (Ini sebenarnya dicapai dengan menambahkan O tambahan ( 5) dan mengurangi semua lima hitungan dengan 1 ). Selanjutnya kita integer-bagi semua nilai-nilai ini dengan empat untuk melihat berapa banyak unit kita dapat berdagang dengan masing-masing jumlah kita yang tersisa berdasarkan jenis sumber daya sementara tidak mempengaruhi jumlah -1 dan 0 (perhatikan bahwa -1 integer-dibagi dengan empat adalah-1 , bukan 0 ). Terakhir kami menjumlahkan nilai-nilai dan memeriksa apakah hasilnya lebih besar dari atau sama dengan nol (di sini lebih besar dari -1 dapat digunakan karena kami selalu memiliki bilangan bulat).

;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 dari int[]ke boolean. Tetapkan untuk 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;}

Cobalah secara Online

Masukan dan keluaran

Input adalah array bilangan bulat dari 0 hingga 4, inklusif. 4 mewakili Bijih, dan pemetaan lainnya tidak material. Kasing uji saya adalah terjemahan langsung dari pertanyaan-pertanyaan tersebut, dengan 0 sebagai Brick, 1 sebagai Log, 2 sebagai Gandum, dan 3 sebagai Domba.

Keluaran adalah apakah penyelesaian dapat dibangun.

Tidak disatukan

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

Penjelasan

hadalah jumlah sumber daya empat kali lipat tersedia untuk diperdagangkan. Kami beralih ke setiap jenis sumber daya (kecuali Bijih), menambah hsetiap empat kali lipat sumber daya tambahan yang kami miliki, dan mengurangi di mana tidak ada sumber daya yang ada. Maka hasil kami adalah apakah htidak negatif.

Garis

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

menyesuaikan dengan htepat terlepas dari apakah tidak ada sumber daya (kekurangan) atau setidaknya ada satu sumber daya (surplus). f[i]didekrementasi untuk memperhitungkan sumber daya yang dibutuhkan dalam kasus surplus, menghasilkan -1 dalam kasus kekurangan. Pergeseran kanan yang ditandatangani mengurangi ekspresi menjadi 0 (kasus surplus) atau -1 (kasus kekurangan), sehingga bitwise OR dengan jumlah f[i++] / 4surplus empat kali lipat (dalam kasus surplus) tidak memiliki efek dalam kasus kekurangan tetapi menghasilkan angka sendiri dalam kasus surplus.

Ucapan Terima Kasih

• -9 byte terima kasih kepada Nevay, master bit

Retina , 34 byte

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

Cobalah online! Penjelasan: Membangun penyelesaian membutuhkan 4 sumber daya yang merupakan B, L, W, atau S pertama Anda, atau 4 sumber daya lainnya dengan jenis yang sama. Ini sama dengan menambahkan tiga dari masing-masing empat jenis sumber daya, dan kemudian menghitung untuk melihat apakah Anda memiliki empat set empat.

Jelly , 23 byte

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

Cobalah online!

Lihat tabel berikut untuk nilai:

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

Retina , 43 byte

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

D`[^a]
.{4}

Cobalah online!

Python 3 , 79 78 byte

Sunting: -1 byte berkat @ Mr.Xcoder

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

Cobalah online!

MATL , 19 byte

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

Input adalah vektor baris numerik di mana huruf direpresentasikan sebagai angka sebagai berikut:

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

Output adalah 1 untuk kebenaran, 0untuk kepalsuan.

Cobalah online !: verifikasi semua kasus uji .

Bagaimana itu bekerja

1. Hitung tingkat setiap sumber daya.
2. Div-mod mereka dengan 4.
3. Hitung berapa banyak dari sisa untuk empat sumber pertama (huruf BLWS) tidak nol. Ini memberi angka c .
4. Jumlahkan quotients. Ini memberi angka s .
5. Keluarkan apakah c + s ≥ 4.

Kode yang dikomentari

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:-}-${:)

Cobalah online!

Gunakan pemetaan sumber daya berikut:

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

Tidak masalah pemetaan apa yang digunakan, selama mereka berada dalam jangkauan 0-4, dan 0digunakan untuk O. Menggunakan fakta bahwa mencari kombinasi BLWSsama dengan mencari kombinasi OBLWSsementara sudah memiliki Oin tangan.

05AB1E , 19 byte

0 -> Bijih
1 -> Brick
2 -> Log
3 -> Gandum
4 -> Domba

Mengembalikan 0 saat false, dan 1 sebaliknya.

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

Cobalah online!

Penjelasan:

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

Solusi non-kompetitif: 17 byte

Ada bug di 05AB1E ketika saya pertama kali mengirimkan solusi itu, di mana beberapa operator menangani input kosong dengan buruk. Ini menghasilkan solusi ini menjawab 1pada input kosong. Ini sekarang telah diperbaiki, jadi solusi ini berfungsi dengan baik.

Perbedaannya di sini adalah bahwa kami menambahkan bijih sebelum menghapus salah satu dari setiap sumber daya, tanpa pandang bulu, menghitung jumlah sumber daya yang dihilangkan dengan cara itu. Kami kemudian mengurangi penghitung dengan 1 untuk mendapatkan jumlah B, L, W, dan S. yang benar.

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

Cobalah online!

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

Cobalah online!

Super Clunky jawaban buruk. Saya yakin itu bisa dibersihkan lebih banyak. Metode yang terinspirasi oleh jawaban Lynn di utas ini.

Kotlin , 131 129 byte

pengajuan

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

Uji

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

Tidak dapat bekerja di TryItOnline, tetapi berfungsi di try.kotlinlang.org