Nel gioco da tavolo The Settlers of Catan , ci sono cinque tipi di risorse: Brick, Log, Ore, Wheat e Sheep. La costruzione di un insediamento costa un mattone, un ceppo, un grano e una pecora. Tuttavia, puoi anche scambiare quattro risorse identiche per ottenere una risorsa di tipo diverso. Ad esempio, se avessi quattro minerali in mano, potresti scambiarli tutti e ottenere una pecora.

Il tuo compito è determinare se posso costruire un accordo o meno, data la mia mano.

Il tuo compito

Ingresso sarà una sequenza di lettere B, L, O, W, e S, presa in qualsiasi formato ragionevole. Queste lettere corrispondono ai cinque tipi di risorse indicati sopra. Dovresti ottenere se ho le risorse necessarie per costruire un accordo, tenendo conto della possibilità di negoziare quattro nel loro genere.

Questo è code-golf , quindi vince il codice più breve in byte.

Gli appunti

• Non devi produrre quali operazioni devo eseguire o quanti insediamenti potrei costruire. Un semplice "sì" o "no" farà.
• Si può non dare per scontato che l'ingresso è in un ordine specifico. In particolare, non si può presumere che le risorse dello stesso tipo siano raggruppate insieme, quindi OBLSOè un input valido.
• Questo è un problema decisionale , quindi puoi usare qualsiasi valore tu voglia dire "sì" e "no", purché i due valori scelti siano distinti e coerenti.
• Le uniche regole di cui ci occupiamo qui sono quelle sopra elencate. Le regole più complicate dei coloni di Catan come il trading con altri giocatori o nei porti non sono rilevanti qui.
• I caratteri di input ( B, L, O, W, S) possono essere sostituiti con altri valori se è più facile per il particolare linguaggio di scelta, finché ci sono cinque ingressi distinti. Se si utilizzano altri valori di input, specificarli nella risposta.

Esempi

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 byte

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

Provalo online!

Per ciascuna delle nostre risorse, contiamo il numero di "libertà" fornite avendo n di quella risorsa. Una libertà rappresenta un'opportunità per riempire uno degli slot mattone-ceppo-grano-pecora che dobbiamo riempire per stabilirci, tenendo conto del fatto che possiamo convertire le nostre risorse.

Per tutti i BLSW, avere una delle risorse ci dà una tale libertà, e ogni ulteriore eccesso di 4 ce ne dà un'altra. La regola del conteggio della libertà è così:

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

Quindi n mattoni / tronchi / grano / pecora danno ⌊ (n + 3) / 4⌋ libertà.

Per i minerali, contano solo i quartetti in eccesso. La regola del conteggio della libertà è così:

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

Così n minerali dare ⌊n / 4⌋ libertà.

Teorema: possiamo accontentarci se e solo se abbiamo ≥ 4 tali "libertà".

Quindi contiamo le nostre libertà e controlliamo se ce ne sono ≥ 4. Per gestire il conteggio dei minerali come ⌊n / 4⌋ ma altre risorse ⌊ (n + 3) / 4⌋, gonfiamo artificialmente i conteggi per le altre risorse di 3 e quindi contiamo ⌊n / 4⌋ per tutti. Lo facciamo mappando (s+"BLSW"*3).countinvece di s.count.

Prova :

• Supponiamo che possiamo accontentarci. Quindi per ciascuno di [B, L, S, W], o (a) abbiamo usato 1 di quella risorsa che avevamo già, o (b) abbiamo sacrificato 4 di qualche altra risorsa (compresi i minerali) per crearlo. In entrambi i casi, contiamo almeno 1 libertà secondo le regole di cui sopra. Quindi abbiamo ≥ 4 libertà.

• Supponiamo di avere 4 libertà, delle quali k sono dovute a "eccessi" (ogni libertà dai minerali è un eccesso, e ogni libertà dalle altre risorse oltre la prima è anche) e 4-k delle quali sono testimoni di possedere almeno una mattone / ceppo / grano / pecora (quello che ha dato la "prima libertà"). Quindi riempiamo gli slot da 4 k con il mattone / log / grano / pecora che ci ha dato la nostra prima libertà, e riempiamo gli k spazi rimanenti convertendo i nostri eccessi. Tutti e 4 gli slot sono occupati e possiamo accontentarci. Ovviamente possiamo ancora farlo se abbiamo più di 4 libertà.

Questa prova fa schifo, ma ho sonno. Sono sicuro che ci sia una spiegazione migliore.

Python 2 ,  52  51 byte

-1 byte grazie a Luke (sostituisci >=0con <0, invertendo i False/ Truerisultati)

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

Una funzione senza nome che prende una stringa di caratteri B , O , W , L e S (come nell'OP) e ritorna Falsese puoi accontentarti o Trueno.

Provalo online! (costringe l'output ayes/nodell'OP).

Come?

Questa è una porta della mia risposta Jelly. Dobbiamo recuperare eventuali B , W , L o S mancanti dal resto dopo averne usato uno. Come tale possiamo aggiungere una O in più alla nostra mano, quindi ridurre tutti i conteggi di uno, quindi dividere tutti i conteggi per quattro e quindi sommare - se il risultato è zero o più possiamo accontentarci (o perché non c'erano risorse richieste mancanti o perché possiamo negoziare per acquisire quelli mancanti.

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 byte

gsm/t/+Q4d4U5Z

Provalo qui! oppure Verifica tutti i casi di test.

Pyth ,  31 27 17  16 byte

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

Verifica i casi di test.

Come funzionano questi?

Spiegazione n. 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.

Spiegazione n. 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.

Questi sono i codici utilizzati dal mio programma:

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

Gelatina ,  13  12 byte

;5ċЀ5’:4S>-

Un collegamento monadico che accetta un elenco di numeri che rappresentano le risorse che possiedi e che restituiscono 1se puoi sistemarti o 0no.

Le risorse sono 1, 2, 3, 4, 5dove 5rappresenta Ore .

Provalo online! oppure vedere la suite di test (usando OP IO).

Come?

L'idea è di prima contare le risorse per tipo, quindi ridurre tutti i conteggi di B , L , W e S di uno - se non ne abbiamo contato nessuno per nessuno di questi quattro, ora avranno voci di -1 - dobbiamo acquisire dalle nostre risorse rimanenti (questo è effettivamente ottenuto aggiungendo una O in più ( 5) e riducendo tutti e cinque i conteggi di 1 ). Successivamente dividiamo tutti questi valori per quattro per vedere quante unità possiamo scambiare con ciascuno dei nostri conteggi rimanenti per tipo di risorsa senza influire sui conteggi -1 e 0 (nota che -1 intero diviso per quattro è-1 , non 0 ). Infine sommiamo i valori e controlliamo se il risultato è maggiore o uguale a zero (qui è possibile utilizzare maggiore di -1 poiché abbiamo sempre numeri interi).

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

Lambda da int[]a boolean. Assegna a 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;}

Provalo online

Ingresso e uscita

L'input è un array di numeri interi compresi tra 0 e 4, inclusi. 4 rappresenta il minerale metallifero e le altre mappature sono irrilevanti. I miei casi di test sono traduzioni dirette di coloro che sono nella domanda, con 0 come Brick, 1 come Log, 2 come Wheat e 3 come Sheep.

L'output indica se è possibile creare un insediamento.

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

Spiegazione

hè il numero di quadruple di risorse disponibili per lo scambio. Esaminiamo ogni tipo di risorsa (tranne Ore), aumentando hper ogni quadruplo di risorse extra che abbiamo e diminuendo dove non sono presenti risorse. Quindi il nostro risultato è se hnon è negativo.

La linea

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

si adatta in modo happropriato indipendentemente dal fatto che non vi siano risorse (carenza) o che vi sia almeno una risorsa (eccedenza). f[i]viene diminuito per tenere conto della risorsa richiesta nel caso di eccedenza, producendo -1 nel caso di carenza. Lo spostamento a destra con segno riduce l'espressione a 0 (caso di surplus) o -1 (caso di carenza), in modo che un OR bit a bit con il numero f[i++] / 4di quadrupli di surplus (nel caso di surplus) non abbia alcun effetto nel caso di carenza ma comporti il ​​numero stesso nel caso del surplus.

Ringraziamenti

• -9 byte grazie a Nevay, maestro dei bit

Retina , 34 byte

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

Provalo online! Spiegazione: La creazione di un insediamento richiede 4 risorse che sono le prime B, L, W o S o qualsiasi altra 4 risorse dello stesso tipo. Ciò equivale ad aggiungere tre di ciascuno di questi quattro tipi di risorse e quindi a contare per vedere se hai quattro serie di quattro.

Gelatina , 23 byte

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

Provalo online!

Fare riferimento alla seguente tabella per i valori:

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

Retina , 43 byte

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

D`[^a]
.{4}

Provalo online!

Python 3 , 79 78 byte

Modifica: -1 byte grazie a @ Mr.Xcoder

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

Provalo online!

MATL , 19 byte

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

L'input è un vettore di riga numerico in cui le lettere sono rappresentate come numeri come segue:

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

L'output è 1per verità, 0per falsità.

Provalo online !: verifica tutti i casi di test .

Come funziona

1. Conta le occorrenze di ogni risorsa.
2. Div-mod li di 4.
3. Conta quanti resti per le prime quattro risorse (lettere BLWS) sono diversi da zero. Questo dà un numero c .
4. Somma i quozienti. Questo dà un numero s .
5. Uscita se c + s ≥ 4.

Codice commentato

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 byte

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

Provalo online!

Utilizza la seguente mappatura delle risorse:

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

E 'davvero non importa quale sia la mappatura viene utilizzato, purché siano nel campo 0-4, e 0viene utilizzato per O. si avvale del fatto che cerca la combinazione BLWSè la stessa che cerca la combinazione OBLWS, mentre già avendo un Oa mano.

05AB1E , 19 byte

0 -> Minerale
1 -> Mattone
2 -> Ceppo
3 -> Grano
4 -> Pecora

Restituisce 0 se falso e 1 altrimenti.

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

Provalo online!

Spiegazione:

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

Soluzione non competitiva: 17 byte

C'è stato un bug in 05AB1E quando ho presentato per la prima volta quella soluzione, in cui alcuni operatori gestivano male input vuoti. Ciò ha comportato la risposta di questa soluzione1 a un input vuoto. Questo è stato risolto, quindi questa soluzione funziona perfettamente.

La differenza qui è che aggiungiamo un minerale prima di rimuovere una di ogni risorsa, indiscriminatamente, contando il numero di risorse rimosse in quel modo. Quindi diminuiamo il contatore di 1 per ottenere il numero corretto di B, L, W e S.

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

Provalo 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

Provalo online!

Brutta risposta di Super Clunky. Sono sicuro che potrebbe essere pulito di più. Metodo ispirato alla risposta di Lynn in questo thread.

Kotlin , 131 129 byte

Presentazione

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

Test

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

Non funziona su TryItOnline, ma funziona su try.kotlinlang.org