でカタンの開拓者のレンガ、ログ、鉱石、小麦、および羊：ボードゲーム、5つのリソースタイプがあります。集落の建設には、レンガ、丸太、小麦、羊が必要です。ただし、4つの同一のリソースを交換して、異なるタイプのリソースを取得することもできます。たとえば、4つの鉱石を手に持っている場合、それらすべてを交換して1頭の羊を入手できます。

あなたの仕事は、私の手を与えられて、私が和解を構築できるかどうかを判断することです。

あなたのタスク

入力は文字の配列になりますB、L、O、W、およびS、任意の合理的なフォーマットで撮影しました。これらの文字は、上記の5つのリソースタイプに対応しています。私は、4種類の取引の可能性を考慮して、和解を構築するために必要なリソースがあるかどうかを出力する必要があります。

これはcode-golfであるため、バイト単位の最短コードが優先されます。

ノート

• あなたは、私が実行する必要がある取引または私が構築できるいくつの和解を出力する必要はありません。単純な「はい」または「いいえ」で十分です。
• 入力が特定の順序であると想定することはできません。特に、同じタイプのリソースがグループ化されているとは想定できないためOBLSO、有効な入力です。
• これは意思決定問題であるため、選択した2つの値が明確で一貫している限り、「はい」と「いいえ」を意味する任意の値を使用できます。
• ここで関係しているルールは、上記のルールのみです。他のプレイヤーや港での取引のような、より複雑なカタンの開拓者のルールはここでは関係ありません。
• 入力された文字（B、L、O、W、Sそれは選択のあなたの特定の言語のために簡単である場合）ので、長い5つの別個の入力があるので、他の値で置換することができます。他の入力値を使用する場合は、回答でそれらを指定してください。

例

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個持つことによって与えられる「自由」の数を数えます。自由とは、リソースを変換できるという事実を考慮して、解決するために埋める必要のあるレンガ、ログ、小麦、羊のスロットの1つを埋める機会を表します。

BLSWのすべてにとって、リソースの1つがあれば、そのような自由が与えられ、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個の鉱石は⌊n/4⌋の自由を与えます。

定理：そのような「自由」が4つ以上ある場合にのみ、解決できます。

そこで、私たちは自由を数え、それらが4つ以上あるかどうかをチェックします。鉱石のカウントを⌊n/4⌋であるが他のリソース⌊（n + 3）/4⌋として処理するには、他のリソースのカウントを人為的に3倍に増やしてから、すべてのリソースについて⌋n/4⌋をカウントします。これは、の(s+"BLSW"*3).count代わりにマッピングすることで行いs.countます。

証明：

• 解決できるとしましょう。次に、[B、L、S、W]のそれぞれについて、（a）すでに持っているリソースを1つ使用するか、（b）他のリソース（鉱石を含む）を4つ犠牲にして作成しました。いずれの場合も、上記の規則により少なくとも1つの自由をカウントします。したがって、4つ以上の自由度があります。

• 4つの自由があり、そのうちkは「過剰」によるものであり（鉱石からの自由はすべて過剰であり、最初の資源を超えた他の資源からの自由もすべて）、4-kが少なくとも1つを所有している証人であるとしますbrick / log / wheat / sheep（「最初の自由」を与えたもの）。次に、最初の自由を与えたブリック/ログ/小麦/羊で4 kスロットを埋め、余剰を変換して残りのkスロットを埋めます。4つのスロットがすべて満たされ、解決できます。4つ以上の自由がある場合、明らかにこれを行うことができます。

この証拠はひどいですが、私は眠いです。もっと良い説明があるはずです。

パイソン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の文字列（OPのように）を取り、False解決できるかTrueどうかを返す、名前のない関数。

オンラインでお試しください！（出力をyes/noOPに強制します）。

どうやって？

これは私のゼリーの答えの移植版です。不足しているB、W、L、またはSを、それぞれの1つを使用した後に補う必要があります。そのため、余分なOを手に追加し、すべてのカウントを1つ減らし、すべてのカウントを4で整数で除算してから合計します-結果がゼロ以上の場合、（必要なリソースが不足していないため）または不足しているものを取得するために取引できるからです）。

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

所有するリソースを表す数字のリストを受け入れ、1落ち着くことができるかどうかを返すモナドリンク0。

リソースはOreを表す1, 2, 3, 4, 5場所です。5

オンラインでお試しください！または、テストスイートを参照してください（OP IOを使用）。

どうやって？

アイデアは、最初にタイプ別にリソースをカウントし、次にBのすべてのカウントを減らすことです。、L、W、およびSの 1つこれら4つのいずれにもカウントしなかった場合、-1のエントリが得られます-取得する必要があります残りのリソースからそれらを取得します（これは、実際に余分なO（5）を追加し、5つすべてのカウントを1減らすことで実現されます）。次に、これらすべての値を4で整数で除算し、残りの各カウントで、-1および0のカウントに影響を与えずに取引できる単位数を確認します（-1で 4で除算すると、-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[]へ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取引に利用可能なリソースの4倍の数です。各リソースタイプ（鉱石を除く）を反復処理し、増分しますh 4倍の余分なリソースごとし、リソースが存在しない場合は減分します。次に、結果はh負でないかどうかです。

この線

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

hリソースがない（不足）か、少なくとも1つのリソースがある（余剰）かに関係なく、適切に調整します。f[i]余剰ケースでは必要なリソースを考慮して減分され、不足ケースでは-1が生成されます。符号付き右シフトは式を0（余剰の場合）または-1（不足の場合）に減らすためf[i++] / 4、余剰の4 倍数のビットごとのOR （余剰の場合）は不足の場合には効果がありませんが、結果は数になります余剰の場合はそれ自体。

謝辞

• ビットのマスター、Nevayのおかげで-9バイト

網膜、34バイト

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

オンラインでお試しください！説明：集落を構築するには、最初のB、L、W、またはSの4つのリソース、または同じタイプの他の4つのリソースが必要です。これは、これらの4種類のリソースをそれぞれ3つずつ追加し、4セットが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バイト

編集：@ Mr.Xcoderのおかげで-1バイト

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. それらを4で除算します。
3. 最初の4つのリソース（文字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、Oに使用されている限り、どのマッピングが使用されるかは実際には関係ありません。BLWS組み合わせOBLWSを検索することはO、既にinハンド。

05AB1E、19バイト

0->鉱石
1->レンガ
2->ログ
3->小麦
4->羊

falseの場合は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つを無差別に削除する前に、その方法で削除されたリソースの数をカウントする鉱石を追加することです。次に、カウンターを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

オンラインでお試しください！

超不格好な悪い答え。もっときれいにできると確信しています。このスレッドでのリンの答えに触発された方法。

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では動作し ます