Diciamo che il tuo compito è quello di dipingere i pali e un cliente ti chiede di dipingere un palo con 4 sezioni rosse e 3 sezioni gialle. Puoi farlo abbastanza facilmente come segue:

r y r y r y r

Con solo strisce gialle e rosse. Ora supponiamo che il tuo cliente ti chieda di dipingere un palo con 2 sezioni rosse, 2 sezioni gialle e 1 sezione verde . Ci sono un paio di modi in cui potresti dipingere il tuo palo

g y r y r
y g r y r
y r g y r
y r y g r
y r y r g
g r y r y
r g y r y
r y g r y
r y r g y
r y r y g
y r g r y
r y g y r

Più precisamente sono 12 i modi per dipingere il palo. Questo fa esplodere più colori e sezioni sono coinvolti

Ora se il tuo cliente dice che vogliono 3 sezioni rosse e 1 sezione gialla non c'è modo di dipingere un palo del genere. Perché, indipendentemente dal modo in cui si tenta di disporre le sezioni, verranno toccate due sezioni rosse e, quando due sezioni rosse si toccano, diventano un'unica sezione rossa.

E questa è praticamente la nostra unica regola per dipingere i pali

Le sezioni adiacenti potrebbero non essere dello stesso colore

Compito

Dato un elenco di colori e sezioni richiesti, visualizza il numero di modi possibili per dipingere un palo come richiesto. Puoi rappresentare i colori in qualsiasi modo ragionevole (numeri interi, caratteri, stringhe), ma non ti verranno mai dati più di 255 colori diversi alla volta. Se lo desideri, puoi anche scegliere di non assegnare i colori ai nomi e prendere semplicemente un elenco di conteggi di sezione se è più facile.

Casi test

Questi sono piuttosto difficili da calcolare a mano, soprattutto quando diventano più grandi. Se qualcuno ha un caso di prova suggerito lo aggiungerò.

[4,3]    -> 1
[2,2,1]  -> 12
[3,1]    -> 0
[8,3,2]  -> 0
[2,2,1,1]-> 84

Mathematica, 37 44 48 60 62 byte

Prendi input come un elenco di numeri interi {1, 1, 1, 2, 2}. Provalo su Wolfram Sandbox .

Metodo di abbinamento dei modelli, grazie @Non un albero!

Count[Split/@Permutations@#,{{_}..}]&

Splitsuddivide un singolo elenco in elenchi secondari di elementi consecutivi, ad esempio {1, 1, 2, 3, 4, 4}in{{1, 1}, {2}, {3}, {4, 4}}

{{_}..}è, vale a dire {{_}, {_}, {_}, ...}. Il modello corrisponde a un elenco di elenchi secondari unari.

Differences metodo, 48 byte:

Tr@Abs@Clip[1##&@@@Differences/@Permutations@#]&

Il codice utilizza Differencesper determinare se gli elementi adiacenti sono uguali.

Passo dopo passo:

1. Permutations@# genera tutte le permutazioni dell'elenco di input in un elenco N! * N.
2. Differences/@ calcola la differenza tra N elementi e produce un elenco N! * (N-1).
3. 1##&@@@calcola la moltiplicazione di tutte le liste. Se un elenco contiene 0(due elementi adiacenti sono uguali), il risultato sarà 0, altrimenti diverso da zero, a una N! elenco.
4. Clip[]si comporta come Sign[], trasforma l'elenco da (-inf, inf) a [-1, 1]
5. Tr@Abstrasforma tutto -1in 1e ora l'elenco N! -length contiene solo 0(non valido) e 1(valido). Quindi sommiamo semplicemente l'elenco.

Gelatina , 7 byte

Œ!QIẠ€S

Provalo online!

Accetta input come ad es . [1,1,1,1,2,2,2]Per [4,3]. Il [8,3,2]testcase impiega troppo tempo a funzionare su TIO.

Come funziona

Œ!QIẠ€S - main link, input as a list
Œ!      - all permutations
  Q     - remove duplicates
   I    - take increments (returns a 0 for two adjacent identical numbers)
    Ạ€  - apply “all” atom to each: 0 for containing 0 and 1 otherwise
      S - sum

05AB1E , 7 byte

œÙ€¥PĀO

Provalo online!

-1 grazie a nmjcman101 su un'altra risposta.

Mathematica, 50 byte

Expand[1##&@@(LaguerreL[#,-1,x](-1)^#)]/._^i_:>i!&

Provalo in matematica o nella sandbox Wolfram !

Accetta input come nei casi di test, ad esempio {4,3}significa "4 strisce rosse, 3 strisce gialle".

Questa è un'implementazione ingenua di una formula che ho trovato qui . "Naïve" significa "Non ho idea di come funzioni la matematica, quindi per favore non chiedermi una spiegazione ..."

Python 3.5 , 65 byte

f=lambda s,p=0:sum(f(s.replace(c,'',1),c)for c in{*s}-{p})or''==s

Provalo online!

Ruby 2.4, 47 byte

Input è un elenco di caratteri: Per il caso di test [4,3], ingresso può essere %w[a a a a b b b], "1111222".charso qualche altro metodo array di formattazione che è valida in Ruby.

->x{x.permutation.uniq.count{|a|a*''!~/(.)\1/}}

Richiede 2.4 per Enumerator#uniq(le versioni precedenti erano disponibili solo sulla Arrayclasse). Come tale, il collegamento TIO aggiunge 5 byte per convertire prima l'enumeratore di permutazione in un array to_a, poiché non ha la funzione sopra.

Provalo online!

R, 72 byte

pryr::f(sum(sapply(unique(combinat::permn(x)),pryr::f(!sum(!diff(x))))))

Crea la funzione

function (x) 
{
    sum(sapply(unique(combinat::permn(x)), pryr::f(!sum(!diff(x)))))
}

Prende l'input nel modulo [1,1,1,1,2,2,2]secondo Erik il commento dell'Outgolfer. Utilizza combinatla permnfunzione per creare un elenco di tutte le permutazioni e quindi uniqueottenere tutte le voci distinte. sapplyquindi applica la seguente funzione su tutte le voci:

pryr::f(!sum(!diff(x)))

Che valuta

function (x) 
!sum(!diff(x))

Si noti che questo xnon è lo stesso xdell'input della funzione grande. L'uso di un altro personaggio in questa funzione sarebbe insensato pryr::fnel credere che la grande funzione abbia bisogno di un altro argomento.

Comunque, quando somministrato una permutazione, questa funzione prende la differenza tra il vettore: 2 1 3 4 2 1 -> -1 2 1 -2 -1. !converte gli zero FALSEe gli zeri in TRUE, quindi il vettore diventa FALSE FALSE FALSE FALSE FALSE. Riassumendo che per verificare se ci sono TRUEs ( TRUEimplicherebbe diff=0-> due gli stessi numeri consecutivi). Possiamo di nuovo invertire questo con !per ottenere un valore booleano sull'esistenza o meno di valori consecutivi nella permutazione.

Sommare questi booleani ci fornisce il numero totale di permutazioni laddove non è così.

Non funziona per la [8,3,2]testcase perché richiede un vettore di 46 GB per memorizzare quelle permutazioni.

Gelatina , 11 byte

Œ!Q⁻2\Ạ$ÐfL

Provalo online!

Python 2 , 140 89 byte

Il formato di input è 'aaaabbb'per test case [4,3].

lambda s:len({p for p in permutations(s)if all(map(cmp,p,p[1:]))})
from itertools import*

Provalo online!

Buccia , 8 byte

#ȯ¬ṁtguP

Provalo online! Accetta input nel formato "aaabb"per [3,2]. Timeout sul test case più lungo.

Spiegazione

Niente di speciale qui, contando solo le permutazioni uniche in cui tutti i gruppi di elementi adiacenti hanno lunghezza 1.

#ȯ¬ṁtguP
       P  Permutations.
      u   Remove duplicates.
#ȯ        Count how many satisfy the following condition:
     g    group adjacent elements,
   ṁt     concatenate tails of groups
  ¬       and negate.

Rubino, 84 76 byte

f=->a,x=p{i=s=0;a.map{a[i-=1]-=1;a[i]<0||i!=x&&s+=f[a,i];a[i]+=1}.max>0?s:1}

Una funzione lambda ricorsiva. Guarda ogni possibile colore e dosare una ricerca di alberi ricorsiva, contando il numero di volte in cui utilizza tutte le strisce.

Spiegazione (per la vecchia versione):

f=->
  a, # a is the input array in [3,3,4] form
  x = -1 # x is the last color placed (-1 when run normaly, used in recursive calls)
{
  j = i = s = 0;
  # i is the index
  # s is the sum of valid final patterns (the answer)
  # j is used to count the total stripes

  a.map{|e| # Iterate over array of colors

    a[i] -= 1; # remove a stripe of current color (the array will be used in recursive call)

    s += f[a,i] if i!=x && e>0;
      # add to sum recursively if:
        # we are not using the same color as the last color AND
        # we have stripes of the current color left to paint

    a[i] += 1; # replace the stripe we removed above 

    j += a[i]; # add stripes to j

    i+=1 # increment the index

  }; # End loop

  j == 0 ? 1 : s
  # if we had stripes, give the recursive sum, otherwise return 1 
}

MATL , 11 8 byte

Y@Xu!dAs

Il formato di input è [1 1 1 1 2 2 2]per [4 3], ecc.

Esaurisce la memoria per l'ultimo caso di test.

Provalo online!

Spiegazione

Y@    % Implicit input. Matrix of all permutations. Each row is a permutation
Xu    % Unique rows
!     % Transpose
d     % Consecutive differences along each column
A     % All: true for columns such that all its entries are nonzero
s     % Sum. Implicitly display