에서 카탄의의 정착민 벽돌, 로그인, 광석, 밀, 그리고 양 : 보드 게임, 다섯 개 자원 유형이 있습니다. 정착지 건설에는 벽돌, 통나무, 밀 및 양이 필요합니다. 그러나 동일한 유형의 리소스를 얻기 위해 4 개의 동일한 리소스를 거래 할 수도 있습니다. 예를 들어, 손에 네 개의 광석이 있다면, 그들 모두를 거래하고 한 마리의 양을 얻을 수 있습니다.

당신의 임무는 내 손이 주어지면 내가 정착을 할 수 있는지 여부를 결정하는 것입니다.

당신의 작업

입력이 문자의 순서가 될 것이다 B, L, O, W, 및 S, 합리적인 형식으로 촬영. 이 문자는 위에 주어진 5 가지 자원 유형에 해당합니다. 네 종류의 거래 가능성을 고려하여 정산에 필요한 자원이 있는지 여부를 출력해야합니다.

이것은 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)

파이썬 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 개의 광석은 ⌊n / 4⌋의 자유를줍니다.

정리 : 우리는 4 이상의‘자유’가있는 경우에만 정착 할 수 있습니다.

그래서 우리는 자유를 세고 그 중 4 이상이 있는지 확인합니다. 계수 광석을 ⌊n / 4⌋로 취급하고 다른 자원 ⌊ (n + 3) / 4⌋로 처리하기 위해, 우리는 인위적으로 다른 자원의 계수를 3 씩 부풀린 다음 모든 자원에 대해 ⌊n / 4⌋를 계수합니다. (s+"BLSW"*3).count대신 에 매핑하여이 작업을 수행합니다 s.count.

증명 :

• 우리가 정착 할 수 있다고 가정 해 봅시다. 그런 다음 [B, L, S, W] 각각에 대해 (a) 이미 보유한 자원 중 하나를 사용했거나 (b) 자원을 만들기 위해 다른 자원 (광석 포함) 중 4 개를 희생했습니다. 두 경우 모두 위 규칙에 따라 최소 1 개의 자유를 계산합니다. 따라서 우리는 ≥ 4 자유가 있습니다.

• 우리가 4 개의 자유를 가지고 있다고 가정하자. 그 중 k는“과잉”(광석으로부터의 자유는 모두 초과 하고 첫 번째 자원을 지나는 다른 자원으로부터의 모든 자유 도)이며 4k는 적어도 하나를 소유하고 있음을 목격 한다고 가정하자 벽돌 / 통나무 / 밀 / 양 (“첫 번째 자유”를 준 것). 그런 다음 우리는 첫 번째 자유를 준 벽돌 / 통나무 / 밀 / 양으로 4k 슬롯을 채우고 나머지를 변환하여 나머지 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 중 하나를 사용한 후에 나머지 를 보충해야 합니다. 따라서 우리는 손에 여분의 O 를 더한 다음 모든 카운트를 1 씩 줄인 다음 정수를 모든 카운트를 4로 나눈 다음 합할 수 있습니다-결과가 0 이상이면 (필수 자원이 없어서 해결할 수 있습니다) 또는 우리는 누락 된 것들을 얻기 위해 거래 할 수 있기 때문입니다.

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 - 우리가 취득해야 우리의 나머지 자원에서 그들 (이 실제로 별도의 추가 달성 O를 ( 5) 및 감소 다섯 에 의해 카운트 1 ). 다음으로이 값을 모두 4로 정수 나누면 -1 과 0 카운트에 영향을 미치지 않으면 서 자원 유형별로 남은 각 개수와 교환 할 수있는 단위 수를 볼 수 있습니다 ( -1 로 나누어 진 정수는0이 아닌 -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

자바 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 배의 수입니다. 각 자원 유형 (Ore 제외)을 반복하여 h보유한 추가 자원의 4 배씩 증가 하고 자원이없는 위치를 감소시킵니다. 우리의 결과는 h음 이 아닌지 여부 입니다.

라인

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

h자원이 없거나 (부족한) 자원이 하나 이상 있는지 (잉여)에 관계없이 적절하게 조정합니다 . f[i]잉여의 경우 필요한 자원을 고려하여 부족한 경우 -1을 생성하도록 감소됩니다. 부호있는 오른쪽 시프트는 표현식을 0 (여분의 경우) 또는 -1 (부족의 경우)로 줄이므로 f[i++] / 4잉여 사중 의 수 (여백의 경우)가있는 비트 단위 OR 은 부족한 경우에는 영향을 미치지 않지만 숫자는 발생합니다. 잉여의 경우 그 자체.

감사의 말

• 비트 마스터 인 Nevay 덕분에 -9 바이트

망막 , 34 바이트

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

온라인으로 사용해보십시오! 설명 : 합의를 빌드하려면 첫 번째 B, L, W 또는 S 인 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}

온라인으로 사용해보십시오!

파이썬 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. 처음 네 개의 자원 (letters BLWS) 에 대한 나머지 가 0이 아닌 수를 계산하십시오. 이것은 숫자 c를 제공합니다 .
4. 몫을 합치십시오. 이 숫자 제공 의 .
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, 그리고 0O.이 조합을 찾는 것은 사실의 사용을 만듭니다에 사용되는 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›

온라인으로 사용해보십시오!

자바 스크립트 (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

온라인으로 사용해보십시오!

슈퍼 클러 키 나쁜 대답. 더 청소할 수 있다고 확신합니다. 이 스레드에서 Lynn의 답변에서 영감을 얻은 방법.

코 틀린 , 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