Im Brettspiel The Settlers of Catan gibt es fünf Ressourcentypen: Brick, Log, Ore, Wheat und Sheep. Der Bau einer Siedlung kostet einen Ziegelstein, einen Baumstamm, einen Weizen und ein Schaf. Sie können jedoch auch mit vier identischen Ressourcen handeln, um eine Ressource eines anderen Typs zu erhalten. Wenn Sie zum Beispiel vier Erze in der Hand hätten, könnten Sie alle eintauschen und ein Schaf bekommen.

Ihre Aufgabe ist es festzustellen, ob ich mit meiner Hand eine Siedlung bauen kann oder nicht.

Deine Aufgabe

Eingang wird eine Abfolge der Buchstaben B, L, O, W, und Sin jedem vernünftigen Format gemacht. Diese Buchstaben entsprechen den fünf oben angegebenen Ressourcentypen. Sie sollten ausgeben, ob ich die Ressourcen habe, die zum Aufbau einer Siedlung erforderlich sind, und dabei die Möglichkeit berücksichtigen, mit vier Gleichartigen zu handeln.

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes.

Anmerkungen

• Sie müssen nicht ausgeben, welche Trades ich ausführen muss oder wie viele Siedlungen ich aufbauen könnte. Ein einfaches "Ja" oder "Nein" reicht aus.
• Sie können nicht davon ausgehen, dass sich die Eingabe in einer bestimmten Reihenfolge befindet. Insbesondere können Sie nicht davon ausgehen, dass Ressourcen desselben Typs zusammen gruppiert sind. Dies OBLSOist also eine gültige Eingabe.
• Da dies ein Entscheidungsproblem ist , können Sie jeden Wert verwenden, den Sie als "Ja" und "Nein" bezeichnen möchten, sofern die beiden ausgewählten Werte unterschiedlich und konsistent sind.
• Die einzigen Regeln, um die es hier geht, sind die oben aufgeführten. Kompliziertere Regeln für Siedler von Catan wie der Handel mit anderen Spielern oder an Häfen sind hier nicht relevant.
• Die Eingabe von Zeichen ( B, L, O, W, S) können mit anderen Werten ersetzt werden , wenn es einfacher für Ihre bestimmte Sprache der Wahl ist, so lange es fünf verschiedene Eingänge. Wenn Sie andere Eingabewerte verwenden, geben Sie diese bitte in Ihrer Antwort an.

Beispiele

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 Bytes

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

Probieren Sie es online!

Für jede unserer Ressourcen zählen wir die Anzahl der „Freiheiten“, die sich aus n dieser Ressourcen ergeben. Eine Freiheit ist eine Gelegenheit , einen der Brick-Log-Wheat-Sheep-Slots zu füllen, die wir für die Besiedlung benötigen, und dabei die Tatsache zu berücksichtigen, dass wir unsere Ressourcen umwandeln können.

Für alle BLSW, mit einer der Ressource gibt uns eine solche Freiheit, und jede weitere mehr als 4 gibt uns ein anderes. Die Freiheitszählregel lautet wie folgt:

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

Also geben n Steine ​​/ Stämme / Weizen / Schafe ⌊ (n + 3) / 4⌋ Freiheiten.

Für Erze zählen nur die überschüssigen Vierer. Die Freiheitszählregel lautet wie folgt:

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

Also geben n Erze ⌊n / 4⌋ Freiheiten.

Theorem: Wir können uns nur zufrieden geben, wenn wir ≥ 4 solcher „Freiheiten“ haben.

Also zählen wir unsere Freiheiten und prüfen, ob es ≥ 4 davon gibt. Um das Zählen von Erzen als ⌊n / 4⌋, aber anderer Ressourcen ⌊ (n + 3) / 4⌋ zu behandeln, erhöhen wir die Anzahl der anderen Ressourcen künstlich um 3 und zählen dann ⌊n / 4⌋ für alle. Wir tun dies durch Mapping (s+"BLSW"*3).countstatt s.count.

Beweis :

• Angenommen, wir können uns zufrieden geben. Dann haben wir für jedes von [B, L, S, W] entweder (a) 1 dieser Ressource verwendet, die wir bereits hatten, oder (b) 4 einer anderen Ressource (einschließlich Erze) geopfert, um sie zu erstellen. In jedem Fall zählen wir mindestens 1 Freiheit nach den oben genannten Regeln. Wir haben also ≥ 4 Freiheiten.

• Nehmen wir an, wir haben 4 Freiheiten, von denen k auf „Exzesse“ zurückzuführen sind (jede Freiheit von Erzen ist ein Überschuss, und jede Freiheit von anderen Ressourcen, die über die erste hinausgehen, ist ebenfalls eine) und 4-k davon zeugen davon, mindestens eine zu besitzen Ziegel / Holz / Weizen / Schaf (derjenige, der die "erste Freiheit" gab). Dann füllen wir 4 − k Felder mit dem Ziegel / Holz / Weizen / Schaf, das uns unsere erste Freiheit gab, und füllen die verbleibenden k Felder durch Umrechnen unserer Exzesse. Alle 4 Slots sind belegt und wir können uns einrichten. Wir können das natürlich immer noch tun, wenn wir mehr als 4 Freiheiten haben.

Dieser Beweis ist scheiße, aber ich bin müde. Ich bin sicher, es gibt eine bessere Erklärung.

Python 2 ,  52  51 Bytes

-1 Byte dank Luke (Ersetzen >=0durch <0, Invertieren der False/ TrueErgebnisse)

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

Eine unbenannte Funktion, die eine Zeichenfolge aus den Zeichen B , O , W , L und S (wie im OP) verwendet und zurückgibt, Falseob Sie eine Einigung erzielen können oder Truenicht.

Probieren Sie es online! (zwingt den Ausgang zumyes/noOP).

Wie?

Dies ist eine Portierung meiner Gelee-Antwort. Wir müssen jedes fehlende B , W , L oder S aus dem Rest nachholen , nachdem wir jeweils eines davon verwendet haben. Als solches können wir unserer Hand ein zusätzliches O hinzufügen , dann alle Zählungen um eins reduzieren, dann alle Zählungen durch vier dividieren und dann summieren - wenn das Ergebnis null oder mehr ist, können wir abrechnen (entweder weil es keine fehlenden erforderlichen Ressourcen gab) oder weil wir handeln können, um die fehlenden zu erwerben.

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 Bytes

gsm/t/+Q4d4U5Z

Probieren Sie es hier aus! oder Überprüfen Sie alle Testfälle.

Pyth ,  31 27 17  16 Bytes

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

Überprüfen Sie die Testfälle.

Wie funktionieren diese?

Erklärung # 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.

Erklärung # 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.

Dies sind die von meinem Programm verwendeten Codes:

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

Jelly ,  13  12 Bytes

;5ċЀ5’:4S>-

Ein monadischer Link, der eine Liste von Zahlen akzeptiert, die Ihre eigenen Ressourcen darstellen, und 1zurückgibt, ob Sie sich beruhigen können oder 0nicht.

Die Ressourcen sind , 1, 2, 3, 4, 5wo 5repräsentiert Ore .

Probieren Sie es online! oder sehen Sie sich die Testsuite an (über OP IO).

Wie?

Die Idee ist, zuerst die Ressourcen nach Typ zu zählen und dann alle Zählungen von B , L , W und S um eins zu reduzieren. Wenn wir keine dieser vier gezählt haben, müssen wir jetzt Einträge von -1 erfassen sie aus unseren restlichen Ressourcen (Dies wird tatsächlich erreicht, indem ein zusätzliches O ( 5) hinzugefügt und alle fünf Zählungen um 1 verringert werden ). Als nächstes dividieren wir alle diese Werte durch vier, um zu sehen, wie viele Einheiten wir mit jeder unserer verbleibenden Zählungen nach Ressourcentyp handeln dürfen, ohne die Zählungen -1 und 0 zu beeinflussen (beachten Sie, dass -1 durch vier geteilt ist-1 , nicht 0 ). Zuletzt addieren wir die Werte und prüfen, ob das Ergebnis größer oder gleich Null ist (hier kann größer als -1 verwendet werden, da wir immer ganze Zahlen haben).

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

Lambda von int[]bis boolean. Zuweisen zu 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;}

Probieren Sie es online

Ein- und Ausgabe

Die Eingabe ist ein Array von ganzen Zahlen von 0 bis einschließlich 4. 4 stellt Erz dar, und die anderen Abbildungen sind unerheblich. Meine Testfälle sind direkte Übersetzungen der in Frage kommenden Personen, mit 0 als Brick, 1 als Log, 2 als Wheat und 3 als Sheep.

Ausgabe ist, ob eine Siedlung aufgebaut werden kann.

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

Erläuterung

hist die Anzahl der Ressourcenvierfachen, die für den Handel verfügbar sind. Wir iterieren über jeden Ressourcentyp (außer Erz), inkrementieren hfür jedes Vierfache der zusätzlichen Ressourcen, die wir haben, und dekrementieren, wo keine Ressourcen vorhanden sind. Dann ist unser Ergebnis, ob hnichtnegativ ist.

Die Linie

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

Passt sich hangemessen an, unabhängig davon, ob keine Ressourcen vorhanden sind (Mangel) oder mindestens eine Ressource vorhanden ist (Überschuss). f[i]wird dekrementiert, um die erforderliche Ressource im Überschussfall zu berücksichtigen, was im Engpassfall -1 ergibt. Die vorzeichenbehaftete Rechtsverschiebung reduziert den Ausdruck auf 0 (Überdeckung) oder -1 (Unterdeckung), so dass ein bitweises ODER mit der Anzahl f[i++] / 4der Überdeckungsvierfachen (im Überdeckungsfall) im Unterdeckungsfall keine Wirkung hat, sondern die Anzahl ergibt sich im Überschussfall.

Danksagung

• -9 Bytes dank Nevay, Meister der Bits

Retina , 34 Bytes

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

Probieren Sie es online! Erläuterung: Für den Bau einer Siedlung sind 4 Ressourcen erforderlich, entweder Ihr erstes B, L, W oder S, oder 4 beliebige andere Ressourcen desselben Typs. Dies entspricht dem Hinzufügen von drei dieser vier Ressourcentypen und dem anschließenden Zählen, um festzustellen, ob Sie über vier Vierergruppen verfügen.

Jelly , 23 Bytes

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

Probieren Sie es online!

Die Werte finden Sie in der folgenden Tabelle:

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

Retina , 43 Bytes

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

D`[^a]
.{4}

Probieren Sie es online!

Python 3 , 79 78 Bytes

Edit: -1 Byte dank @ Mr.Xcoder

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

Probieren Sie es online!

MATL , 19 Bytes

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

Die Eingabe ist ein numerischer Zeilenvektor, bei dem die Buchstaben wie folgt als Zahlen dargestellt werden:

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

Output ist 1für die Wahrheit, 0für die Falschheit.

Probieren Sie es online aus !: Überprüfen Sie alle Testfälle .

Wie es funktioniert

1. Anzahl der Vorkommen jeder Ressource.
2. Div-mod sie durch 4.
3. Zählen Sie, wie viele der Reste der ersten vier Ressourcen (Buchstaben BLWS) ungleich Null sind. Dies gibt eine Zahl c .
4. Summiere die Quotienten. Dies gibt eine Zahl s .
5. Ausgabe, ob c + s ≥ 4 ist.

Kommentierter Code

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 Bytes

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

Probieren Sie es online!

Verwendet die folgende Ressourcenzuordnung:

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

Es spielt keine Rolle, welche Zuordnung verwendet wird, solange sie sich im Bereich befindet 0-4, und sie 0wird für O verwendet. Nutzt die Tatsache, dass das Suchen nach der Kombination BLWSdasselbe ist wie das Suchen nach der Kombination, OBLWSwährend sie bereits einen OEingang hat Hand.

05AB1E , 19 Bytes

0 -> Erz
1 -> Ziegel
2 -> Holz
3 -> Weizen
4 -> Schafe

Gibt 0 zurück, wenn falsch, und 1, wenn nicht.

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

Probieren Sie es online!

Erläuterung:

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

Nicht konkurrierende Lösung: 17 Bytes

In 05AB1E gab es einen Fehler, als ich diese Lösung zum ersten Mal einreichte, bei der einige Operatoren leere Eingaben schlecht handhabten. Dies führte dazu, dass diese Lösung 1auf eine leere Eingabe antwortete . Dies wurde nun behoben, sodass diese Lösung problemlos funktioniert.

Der Unterschied besteht darin, dass wir vor dem Entfernen einer Ressource wahllos ein Erz hinzufügen und dabei die Anzahl der auf diese Weise entfernten Ressourcen zählen. Wir dekrementieren dann den Zähler um 1, um die korrekte Anzahl von B, L, W und S zu erhalten.

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

Probieren Sie es 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

Probieren Sie es online!

Super klobige schlechte Antwort. Ich bin sicher, es könnte mehr aufgeräumt werden. Methode inspiriert von Lynns Antwort in diesem Thread.

Kotlin , 131 129 Bytes

Einreichung

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

Prüfung

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

Kann nicht mit TryItOnline arbeiten, funktioniert aber mit try.kotlinlang.org