У настільній грі The Settlers of Catan є п’ять типів ресурсів: Цегла, Колода, Руда, Пшениця та Вівці. Побудова поселення коштує цегли, колоди, пшениці та овець. Однак ви також можете торгувати чотирма однаковими ресурсами, щоб отримати ресурс іншого типу. Наприклад, якщо у вас було чотири руди в руці, ви могли торгувати всіма ними і отримувати одну овечку.

Ваше завдання полягає в тому, щоб визначити, чи можу я побудувати поселення, подаючи руку.

Ваше завдання

Введення буде послідовністю букв B, L, O, W, і S, взяті в будь-якому прийнятному форматі. Ці листи відповідають п’яти типам ресурсів, наведеним вище. Ви повинні вивести, чи є у мене ресурси, необхідні для створення поселення, враховуючи можливість торгувати чотирма подібними.

Це код-гольф , тому найкоротший код у байтах виграє.

Примітки

• Вам не потрібно виводити, які угоди мені потрібно виконувати чи скільки розрахунків я можу створити. Просте "так" чи "ні" не обійдеться.
• Ви можете не припускати, що введення в певному порядку. Зокрема, ви можете не припускати, що ресурси одного типу згруповані разом, тому OBLSOце правильне введення.
• Це проблема вирішення , тому ви можете використовувати будь-яке значення, яке ви хочете означати "так" і "ні", якщо два обраних значення відрізняються і відповідають.
• Єдині правила, які нас тут стосуються, - це перелічені вище. Тут не доречні більш складні правила посередників Катану, такі як торгівля з іншими гравцями або на пристанях.
• Вхідні символи ( 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 цегли / колоди / пшениця / вівці дають ⌊ (n + 3) / 4⌋ свободи.

Для руд розраховується лише надлишок четвертинки. Правило підрахунку свободи таке:

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

Тож п руди дають ⌊n / 4⌋ свободи.

Теорема: ми можемо врегулюватись лише тоді, якщо у нас є ≥ 4 таких "свободи".

Тому ми підраховуємо свої свободи і перевіряємо, чи є їх ≥ 4. Для обробки підрахунку руд як ⌊n / 4⌋, але інших ресурсів ⌊ (n + 3) / 4⌋, ми штучно завищуємо рахунки для інших ресурсів на 3, а потім підраховуємо ⌊n / 4⌋ для всіх. Ми робимо це за допомогою картографування (s+"BLSW"*3).countзамість s.count.

Доказ :

• Припустимо, ми можемо влаштуватися. Тоді для кожного з [B, L, S, W] ми або (а) використовували 1 ресурс, який у нас уже був, або (b) жертвували 4 іншим ресурсом (включаючи руди) для його створення. В будь-якому випадку ми враховуємо принаймні 1 свободу за вищезазначеними правилами. Отже ми маємо ≥ 4 ​​свободи.

• Припустимо, у нас є 4 свободи, k з яких обумовлені «надмірностями» (кожна свобода руд є надлишком, і кожна свобода від інших ресурсів, попередніх - перша) і 4-k з яких є свідком володіння хоча б однією цегла / зруб / пшениця / вівця (той, що дав «першу свободу»). Тоді ми заповнюємо 4-k прорізи цеглою / зрубом / пшеницею / овечками, які дали нам першу свободу, і заливаємо решту k-слотів, перетворюючи наші надлишки. Всі 4 слоти заповнені, і ми можемо влаштуватися. Ми, очевидно, все ще можемо це зробити, якщо у нас більше 4 свобод.

Цей доказ гасить, але я сонний. Я впевнений, що є краще пояснення.

Python 2 ,  52  51 байт

-1 байт завдяки Луці (замініть >=0на <0, перевернувши False/ Trueрезультати)

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

Безіменна функція, яка бере рядки з символів B , O , W , L і S (як в ОП) і повертається, Falseякщо ви можете вирішити чи Trueні.

Спробуйте в Інтернеті! (примушує вихід доyes/noОП).

Як?

Це портрет моєї відповіді на желе. Нам потрібно компенсувати будь-які відсутні B , W , L або S із залишку після використання одного з них. Як такий, ми можемо додати додатковий О в нашій руці, а потім зменшити всі підрахунки на одиницю, потім на ціле число поділити всі підрахунки на чотири, а потім підсумовувати - якщо результат дорівнює нулю або більше, ми можемо врегулювати (або тому, що не було відсутніх необхідних ресурсів або тому, що ми можемо торгувати, щоб придбати відсутніх (-ів)).

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)

Піт , 14 байт

gsm/t/+Q4d4U5Z

Спробуйте тут! або Перевірте всі тестові випадки.

Піт ,  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>-

Монадійне посилання, що приймає список номерів, що представляють ресурси, якими ви володієте, і повертаються, 1якщо ви можете влаштуватися чи 0ні.

Ресурси 1, 2, 3, 4, 5там , де 5представляє Руду .

Спробуйте в Інтернеті! або ознайомтеся з набором тестів (використовуючи OP IO).

Як?

Ідея полягає в тому, щоб спочатку підрахувати ресурси за типом, а потім зменшити всі підрахунки B , L , W і S на один - якщо ми не порахували жодного з цих чотирьох, то вони тепер матимуть записи -1 - нам потрібно придбати їх з наших решти ресурсів (Це фактично досягається додаванням додаткового O ( 5) і зменшення всіх п'яти підрахунків на 1 ). Далі ми ціле число ділимо всі ці значення на чотири, щоб побачити, на скільки одиниць ми можемо торгувати з кожним з наших решти рахунків за типом ресурсу, не впливаючи на число -1 та 0 (зауважте, що -1 , а не 0 -1 ціле число ділиться на чотири). Нарешті ми додаємо значення і перевіряємо, чи результат більший або дорівнює нулю (тут можна використовувати більше -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[]до boolean. Призначити 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;}

Спробуйте це в Інтернеті

Вхід і вихід

Вхід - це масив цілих чисел від 0 до 4, включно. 4 являє собою Руду, а інші відображення несуттєві. Мої тестові випадки - це прямі переклади запитань, 0 - як цегла, 1 - як колод, 2 - як пшениця, - 3 - вівці.

Результат - чи можна побудувати поселення.

Безумовно

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 (випадок відсутності), так що побіжно АБО з числомf[i++] / 4 відсутності надлишків у чотири (у випадку надлишку) не має ефекту у випадку дефіциту, а призводить до числа себе у випадку надлишків.

Подяка

• -9 байт завдяки Неваю, майстру бітів

Сітківка , 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}

Спробуйте в Інтернеті!

Пітон 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) є нульовим. Це дає число c .
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використовуються для О. Дозволяє використовувати то , що шукаєш комбінацію BLWSє таким же , як пошук комбінації , OBLWSа вже маючи Oв системі рукою.

05AB1E , 19 байт

0 -> Руда
1 -> Цегла
2 -> Колода
3 -> Пшениця
4 -> Вівця

Повертає 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

Спробуйте в Інтернеті!

Супер Клункі погана відповідь. Я впевнений, що його можна було б прибрати більше. Метод, натхненний відповіддю Лінни в цій темі.

Котлін , 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