In Catan Settlers Tuğla, Günlüğü, Cevher, Buğday ve Koyun: masa oyunu, beş kaynak türleri vardır. Bir yerleşim yeri inşa etmek bir Tuğla, Kütük, Bir Buğday ve Bir Koyun'a mal olur. Ancak, farklı türde bir kaynak elde etmek için dört özdeş kaynakla da işlem yapabilirsiniz. Örneğin, elinizde dört cevher varsa, hepsini alıp bir tane koyun alabilirsiniz.

İşiniz, elimle verilen bir yerleşim yapıp yapamayacağımı belirlemek.

Senin görevin

Girdi harflerin bir dizi olacak B, L, O, W, ve S, herhangi bir makul biçimde kaldırıldı. Bu harfler yukarıda verilen beş kaynak türüne karşılık gelir. Bir tür dörde işlem yapma olasılığını göz önünde bulundurarak, bir çözüm oluşturmak için gerekli kaynaklara sahip olup olmadığımı yazmalısınız.

Bu kod golf , bayt cinsinden en kısa kod kazanır.

notlar

• Yapmam gereken işlemleri veya kaç yerleşim yapabileceğimi ortaya koymanız gerekmiyor. Basit bir "evet" veya "hayır" yapacaktır.
• Sen olabilir değil girişi herhangi belirli bir düzen içinde olduğunu varsayalım. Özellikle, aynı türde kaynakların birlikte gruplandırıldığını varsaymayabilirsiniz, bu nedenle OBLSOgeçerli bir girdidir.
• Bu karar sorunudur , bu nedenle, seçilen iki değer farklı ve tutarlı olduğu sürece, "evet" ve "hayır" demek istediğiniz herhangi bir değeri kullanabilirsiniz.
• Burada ilgilendiğimiz tek kural, yukarıda listelenen kurallardır. Diğer oyuncularla veya limanlarda ticaret yapmak gibi daha karmaşık Katan yerleşimcileri kuralları burada önemli değil.
• Giriş karakterleri ( B, L, O, W, So seçtiğiniz belirli bir dil için daha kolay ise) bu kadar uzun beş ayrı girişler olduğu gibi, diğer değerlerle ikame edilebilir. Başka giriş değerleri kullanıyorsanız, lütfen cevabınızı belirtin.

Örnekler

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 bayt

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

Çevrimiçi deneyin!

Kaynaklarımızın her biri için, sayısını “özgürlükler” sahip olarak verilen n bu kaynağın. Bir özgürlük , yerleşmek için doldurmamız gereken tuğla log log-buğday-koyun yuvalarından birini doldurma fırsatını temsil eder , kaynaklarımızı dönüştürebileceğimizi hesaplar.

Tüm BLSW için, kaynaklardan birine sahip olmak bize böyle bir özgürlük verir ve her 4 fazlalık bize başka bir tane verir. Özgürlük sayma kuralı şöyle:

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

Böylece n tuğla / kütük / buğday / koyun ⌊ (n + 3) / 4⌋ özgürlük verir.

Cevherler için, sadece aşırı dörtlü sayılır. Özgürlük sayma kuralı şöyle:

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

Böylece n cevherleri / n / 4⌋ özgürlükleri verir.

Teorem: eğer böyle bir “özgürlüğe” sahip olduğumuzda ≥ 4 varsa ve çözebiliriz.

Bu yüzden özgürlüklerimizi sayıyoruz ve ≥ 4'ü olup olmadığını kontrol ediyoruz. Sayma cevherlerini ⌊n / 4⌋, ancak diğer kaynaklar ⌊ (n + 3) / 4⌋ olarak ele almak için, diğer kaynaklar için sayımları yapay olarak 3'e kadar şişiririz ve sonra hepsi için ⌊n / 4⌋ olarak sayırız. Bunu (s+"BLSW"*3).countyerine eşleştirerek yapıyoruz s.count.

Kanıt :

• Yerleşelim diyelim. Sonra, [B, L, S, W] 'nin her biri için, (a) sahip olduğumuz kaynağın 1'ini kullandık ya da (b) başka bir kaynağın 4'ünü (cevherler dahil) oluşturmak için feda ettik. Her iki durumda da, yukarıdaki kurallara göre en az 1 serbestlik sayıyoruz. Bu yüzden ≥ 4 özgürlüğümüz var.

• Farz edelim ki, k “aşırı” dır (cevherlerden gelen her özgürlük bir aşırıdır ve ilkini de geçen diğer kaynaklardan gelen her özgürlük ) ve 4 −k en az bir tanesine sahip olan 4 özgürlüğümüz olduğunu varsayalım . tuğla / kütük / buğday / koyun (“ilk özgürlüğü” veren kişi). Daha sonra 4 −k yarıkları bize ilk özgürlüğümüzü veren tuğla / log / buğday / koyunla dolduruyoruz ve kalan k yarıkları aşırılıklarımızı dönüştürerek dolduruyoruz. 4 yuvanın tamamı doludur ve yerleşebiliriz. Elimizdeki eğer biz Açıkçası hala yapabiliriz fazla 4'ten özgürlükleri.

Bu kanıt berbat ama uykum var. Eminim daha iyi bir açıklaması vardır.

Python 2 ,  52  51 bayt

-1 byte sayesinde Luke (yerine >=0ile <0tersine çevrilmesi, False/ Truesonuçlar)

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

B , O , W , L ve S karakterlerinden oluşan bir dizi alan (OP'deki gibi) bir dizgeyi alan ve ayarlayıp Falseayarlayamadığınızı belirten bir adsız işlev True.

Çevrimiçi deneyin! (yes/noOPçıkışını zorlar).

Nasıl?

Bu Jelly cevabımın bir limanı. Bunlardan birini kullandıktan sonra geri kalan kısımdaki eksik B , W , L veya S'yi telafi etmemiz gerekir . Böylece, elimize fazladan bir O ekleyebiliriz , sonra tüm sayıları bir azaltabiliriz, daha sonra tamsayı tüm sayıları dörde böler ve sonra toplamı - sonuç sıfır veya daha fazla ise, çözebiliriz (ya da eksik gerekli kaynaklar olmadığı için) veya eksik olanları elde etmek için işlem yapabileceğimizden dolayı.

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 bayt

gsm/t/+Q4d4U5Z

Burada dene! veya Tüm test durumlarını doğrulayın.

Pyth ,  31 27 17  16 bayt

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

Test durumlarını doğrulayın.

Bunlar nasıl çalışır?

Açıklama # 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.

Açıklama 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.

Programım tarafından kullanılan kodlar:

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

Jöle ,  13  12 bayt

;5ċЀ5’:4S>-

Monadik bir bağlantı, sahip olduğunuz kaynakları temsil eden bir sayılar listesini kabul eder ve 1yerleşebilirseniz veya 0vermeyecekseniz geri döndürür .

Kaynaklardır 1, 2, 3, 4, 5nerede 5temsil Cevheri .

Çevrimiçi deneyin! veya test takımına bakın (OP IO kullanarak).

Nasıl?

Buradaki fikir ilk önce kaynakları türe göre saymak, ardından tüm B , L , W ve S sayılarını bir azaltmaktır - eğer bu dördün herhangi biri için hiçbirini saymazsak, o zaman şimdi -1'e sahip olacaklardır - edinmeliyiz Onları kalan kaynaklarımızdan (Bu aslında fazladan bir O ekleyerek ( 5) ve beş sayının hepsini 1'e düşürerek elde edilir ). Daha sonra -1 ve 0 sayılarını etkilemeyken, kalan sayımızın her biri için kaynak türüne göre ne kadar işlem yapabileceğimizi görmek için tüm bu değerleri dörte böleriz ( -1 tam sayıya dörde bölünür;-1 , 0 değil ). Son olarak, değerleri toplar ve sonucun sıfıra eşit veya daha büyük olup olmadığını kontrol ederiz (burada her zaman tamsayılara sahip olduğumuz için -1'den büyük olabilir).

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

Lambda int[]için boolean. Atama 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;}

Çevrimiçi Deneyin

Giriş ve çıkış

Giriş, 0 ile 4 arasında bir tamsayı dizisidir, dahil. Şekil 4 Ore'yi temsil eder ve diğer eşlemeler önemsizdir. Test vakalarım, söz konusu soruların doğrudan tercümesi, 0 Brick, 1 Log, 2 Wheat ve 3 Sheep.

Çıktı, bir yerleşim yapılıp yapılamayacağıdır.

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

açıklama

hticarete hazır kaynak dörtlüsü sayısıdır. Sahip olduğumuz her hekstra kaynak miktarını artıran ve kaynak bulunmayan yerlerde azalan her kaynak türü (Cevher hariç) üzerinde yineliyoruz. Öyleyse bizim sonucumuz holumsuz değil.

Çizgi

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

hKaynak bulunmamasına (yetersiz) veya en az bir kaynak bulunup bulunmadığına bakılmaksızın uygun şekilde ayarlama yapar . f[i]fazlalık davada gerekli kaynağı hesaba katarak, eksiklik durumunda -1 üreterek azaltılır. İmzalı sağa kayma, ifadeyi 0 (artı durum) veya -1 (yetersiz durum) olarak azaltır, böylece bitli bir OR f[i++] / 4, artı dörtlü sayısıyla (artı durumdaki) kıtlıkta hiçbir etkisi olmaz, ancak sayı ile sonuçlanır. Artı durumunda kendisi.

Teşekkür

• -9 bayt, bitlerin efendisi Nevay sayesinde

Retina , 34 bayt

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

Çevrimiçi deneyin! Açıklama: Bir yerleşim yeri oluşturmak, ilk B, L, W veya S'niz olan 4 kaynak veya aynı türden diğer 4 kaynak gerektirir. Bu, bu dört tür kaynağın üçünden birine eklemeye ve dört kümenin olup olmadığını görmek için saymaya eşdeğerdir.

Jöle , 23 bayt

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

Çevrimiçi deneyin!

Değerler için aşağıdaki tabloya bakın:

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

Retina , 43 bayt

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

D`[^a]
.{4}

Çevrimiçi deneyin!

Python 3 , 79 78 bayt

Düzenleme: @ Mr.Xcoder sayesinde -1 bayt

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

Çevrimiçi deneyin!

MATL , 19 bayt

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

Giriş, harflerin aşağıdaki gibi sayılarla temsil edildiği sayısal bir satır vektörüdür:

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

Çıktı 1gerçeğe uygun, 0sahtedir.

Çevrimiçi deneyin !: tüm test durumlarını doğrulayın .

Nasıl çalışır

1. Her kaynağın aslını sayın.
2. Onları 4'e bölün.
3. İlk dört kaynağın (harflerin BLWS) kalanlarının kaçının sıfır olmadığını hesaplayın. Bu bir sayı c verir .
4. Bölümleri topla. Bu bir sayı s verir .
5. Çıktı olup olmadığını c + s ≥ 4.

Yorumlanan kod

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 bayt

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

Çevrimiçi deneyin!

Aşağıdaki kaynak eşlemesini kullanır:

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

Bu gerçekten önemli kullanılır ne haritalama değil, yeter ki aralığında konum olarak 0-4ve 0O. kombinasyonu arayan gerçeği kullanımını yapar için kullanılan BLWSkombinasyon arayan aynıdır OBLWSzaten yerken Oin el.

05AB1E , 19 bayt

0 -> Cevher
1 -> Tuğla
2 -> Kütük
3 -> Buğday
4 -> Koyun

Yanlış olduğunda 0, aksi takdirde 1 döndürür.

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

Çevrimiçi deneyin!

Açıklama:

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

Rekabetçi olmayan çözüm: 17 bayt

05AB1E'de, bazı operatörlerin boş girdileri kötü kullandığı bir çözümü ilk gönderdiğimde bir hata oluştu. Bu 1, boş bir girişi yanıtlayan bu çözümle sonuçlandı . Bu şimdi düzeltildi, bu yüzden bu çözüm gayet iyi çalışıyor.

Buradaki fark, her bir kaynaktan birini ayırmadan önce, ayırt etmeden, bu şekilde çıkarılan kaynakların sayısını sayarak bir cevher eklememizdir. Ardından doğru B, L, W ve S sayılarını almak için sayacı 1 oranında azaltırız.

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

Çevrimiçi deneyin!

JavaScript (SpiderMonkey) , 116 bayt

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

Çevrimiçi deneyin!

Süper Clunky kötü cevap. Daha fazla temizlenebileceğine eminim. Bu konudaki Lynn'in cevabından ilham alan bir yöntem.

Kotlin , 131 129 bayt

boyun eğme

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

Ölçek

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 üzerinde çalışamıyor, ancak try.kotlinlang.org sitesinde çalışıyor