Diyelim ki işiniz direkleri boyamaktır ve bir müşteri sizden 4 kırmızı bölüm ve 3 sarı bölümden oluşan bir direk boyamanızı ister. Bunu aşağıdaki gibi kolayca yapabilirsiniz:

r y r y r y r

Sadece sarı ve kırmızı çizgili. Şimdi müşterinizden sizden 2 kırmızı bölüm, 2 sarı bölüm ve 1 yeşil bölümden bir direğe boyamanızı istediğini söyleyelim . Direğini boyamanın birkaç yolu var.

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

Daha doğrusu bu direği boyamak için 12 yol. Bu, daha fazla renk ve ilgili bölümleri havaya uçurur

Şimdi müvekkiliniz 3 kırmızı bölüm ve 1 sarı bölüm istediklerini söylerse, böyle bir direği boyamanın yolu yoktur. Çünkü bölümleri nasıl düzenlemeye çalışırsanız çalışın iki kırmızı bölüm dokunur ve iki kırmızı bölüm dokunduğunda tek kırmızı bölüm olur.

Ve bu direkleri boyamak için tek kuralımızdır.

Bitişik bölümler aynı renkte olmayabilir

Görev

Gereken renk ve bölümlerin bir listesi göz önüne alındığında, istendiği gibi bir direği boyamak için olası yolların sayısını çıktı. Renkleri makul herhangi bir şekilde (tam sayılar, karakterler, dizeler) temsil edebilirsiniz, ancak bir seferde asla 255'ten fazla farklı renk verilmez. İsterseniz renk atanmış adlara sahip olmamayı bile seçebilirsiniz ve eğer kolaysa bölüm sayımlarının bir listesini alabilirsiniz.

Test Kılıfları

Bunları, özellikle büyüdükçe, elle hesaplamak oldukça zordur. Herhangi birinin önerilen bir test vakası varsa, ekleyeceğim.

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

Bir tamsayı listesi olarak giriş yapın {1, 1, 1, 2, 2}. Wolfram Sandbox'ta dene .

Desen eşleştirme yöntemi, teşekkürler @Bir ağaç yok!

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

Splittek bir listeyi ardışık elemanların alt listelerine böler {1, 1, 2, 3, 4, 4};{{1, 1}, {2}, {3}, {4, 4}}

{{_}..}yani {{_}, {_}, {_}, ...},. Model, birleşik alt listelerin bir listesiyle eşleşir.

Differences yöntem, 48 bayt:

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

Kod, Differencesbitişik öğelerin aynı olup olmadığını belirlemek için kullanır .

Adım adım:

1. Permutations@# Giriş listesinin tüm permütasyonlarını bir N! * N listesine oluşturur.
2. Differences/@ N elementleri arasındaki farkı hesaplar ve bir N! * (N-1) listesi verir.
3. 1##&@@@Tüm listelerin çarpımını hesaplar. Bir liste içeriyorsa 0(iki bitişik eleman aynıdır), sonuç 0N-sıfır olacaktır , aksi halde N! liste.
4. Clip[]gibi davranır Sign[], listeyi (-inf, inf) 'den [-1, 1]' e dönüştür
5. Tr@AbsTüm döner -1içine 1ve şimdi N! uzunlukta liste sadece içerir 0() geçersiz ve 1(geçerli). Yani sadece listeyi özetliyoruz.

Jöle , 7 bayt

Œ!QIẠ€S

Çevrimiçi deneyin!

Örneğin [1,1,1,1,2,2,2]için girişi alır [4,3]. Test [8,3,2]çantasının TIO'da çalışması çok uzun sürüyor.

Nasıl çalışır

Œ!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 bayt

œÙ€¥PĀO

Çevrimiçi deneyin!

-1 , başka bir cevapta nmjcman101'e teşekkürler .

Mathematica, 50 bayt

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

Matematikte veya Wolfram sanal alanında deneyin !

Test durumlarında olduğu gibi girdi alır - örneğin {4,3}"4 kırmızı çizgili, 3 sarı çizgili" anlamına gelir.

Bu, burada bulduğum bir formülün saf bir uygulamasıdır . "Naif", "Matematiğin nasıl çalıştığı hakkında hiçbir fikrim yok, bu yüzden lütfen benden bir açıklama istemeyin" anlamına gelir.

Python 3.5 , 65 bayt

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

Çevrimiçi deneyin!

Yakut 2.4, 47 bayt

Girdi karakterlerinin listesi aşağıdadır: test için [4,3], girdi olabilir %w[a a a a b b b], "1111222".charsya da Ruby geçerli olduğunu diğer bazı dizi biçimlendirme yöntemi.

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

2.4 için gerektirir Enumerator#uniq(önceki sürümlerde yalnızca Arraysınıfta mevcuttu ). Bu nedenle, TIO bağlantısı, permütasyon numaralandırıcısını ilk önce bir diziye dönüştürmek için 5 bayt ekler to_a, çünkü yukarıdaki işlevi yoktur.

Çevrimiçi deneyin!

R, 72 bayt

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

Fonksiyonu yaratır

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

[1,1,1,1,2,2,2]Outgolfer'in yorumuna göre Erik formda girdi . Kullanımları combinat'in permnfonksiyonu sonra tüm permütasyon bir listesini oluşturmak ve uniquetüm farklı girdileri alır. sapplydaha sonra tüm girişlere aşağıdaki işlevi uygular:

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

Hangi için değerlendirir

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

Bunun x, xbüyük fonksiyonun girişindeki ile aynı olmadığını unutmayın . Bu işlevde başka bir karakter kullanılması pryr::f, büyük işlevin başka bir argümana ihtiyaç duyduğuna inanmayı aptallaştırır.

Neyse, bir permütasyon verildiğinde, bu fonksiyon vektör: arasındaki farkı alır 2 1 3 4 2 1 -> -1 2 1 -2 -1. !sıfır olmayan FALSEve sıfır olanları dönüştürür TRUE, böylece vektör olur FALSE FALSE FALSE FALSE FALSE. Eğer varsa kontrol etmek için bu toplarsak TRUEler ( TRUEima diff=0-> ikisi aynı ardışık sayılar). !Permütasyonda ardışık değerler olup olmadığına dair bir boolean almak için bunu tekrar tersine çevirebiliriz .

Bu booleanların toplanması bize, bunun olmadığı durumlarda toplam izin sayısını verir.

[8,3,2]Test çantası için çalışmaz çünkü bu izinleri saklamak için 46GB'lık bir vektör gerektirir.

Jöle , 11 bayt

Œ!Q⁻2\Ạ$ÐfL

Çevrimiçi deneyin!

Python 2 , 140 89 bayt

Giriş formatı 'aaaabbb'test durumu içindir [4,3].

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

Çevrimiçi deneyin!

Kabuğu , 8 bayt

#ȯ¬ṁtguP

Çevrimiçi deneyin! Biçimine giriş Alır "aaabb"için [3,2]. En uzun testte zaman aşımına uğradı.

açıklama

Burada hiçbir fantezi yok, sadece bitişik öğelerin tüm gruplarının uzunluğu 1 olan benzersiz permütasyonları sayarak.

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

Ruby, 84 76 bayt

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}

Bir özyinelemeli lambda işlevi. Mümkün olan her renge bakar ve özyinelemeli bir ağaç araması yapar, tüm çizgileri kullanma sayısını sayarak.

Açıklama (eski versiyon için):

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 bayt

Y@Xu!dAs

Girdi biçimi [1 1 1 1 2 2 2]için [4 3]vs.

Son sınama durumu için bellek yetersiz kalıyor.

Çevrimiçi deneyin!

açıklama

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