Hãy nói rằng công việc của bạn là sơn cột, và một khách hàng yêu cầu bạn vẽ một cây cột với 4 phần màu đỏ và 3 phần màu vàng. Bạn có thể làm điều đó khá dễ dàng như sau:

r y r y r y r

Chỉ với sọc vàng và đỏ. Bây giờ, giả sử khách hàng của bạn yêu cầu bạn vẽ một cây cột với 2 phần màu đỏ, 2 phần màu vàng và 1 phần màu xanh lá cây . Có một số cách bạn có thể vẽ cực của bạn

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

Chính xác hơn đó là 12 cách để vẽ cột. Điều này thổi lên nhiều màu sắc và các phần có liên quan

Bây giờ nếu khách hàng của bạn nói rằng họ muốn 3 phần màu đỏ và 1 phần màu vàng thì không có cách nào để vẽ một cây sào như thế. Bởi vì bất kể bạn cố gắng sắp xếp các phần như thế nào, hai phần màu đỏ sẽ chạm vào nhau và khi hai phần màu đỏ chạm vào chúng sẽ trở thành một phần màu đỏ duy nhất.

Và đó là khá nhiều quy tắc của chúng tôi để vẽ cực

Các phần liền kề có thể không cùng màu

Bài tập

Đưa ra một danh sách các màu sắc và các phần cần thiết, xuất ra số cách có thể để vẽ một cột theo yêu cầu. Bạn có thể biểu diễn màu sắc theo bất kỳ cách hợp lý nào (số nguyên, ký tự, chuỗi), nhưng bạn sẽ không bao giờ được cung cấp nhiều hơn 255 màu khác nhau cùng một lúc. Nếu bạn muốn, bạn thậm chí có thể chọn không có màu được gán tên và chỉ cần lấy một danh sách đếm phần nếu điều đó dễ dàng hơn.

Các trường hợp thử nghiệm

Đây là khá khó để tính toán bằng tay, đặc biệt là khi chúng lớn hơn. Nếu bất cứ ai có một trường hợp thử nghiệm đề nghị tôi sẽ thêm nó.

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

Toán học, 37 44 48 60 62 byte

Lấy đầu vào là một danh sách các số nguyên {1, 1, 1, 2, 2}. Hãy thử nó trên Wolfram Sandbox .

Phương thức khớp mẫu, cảm ơn @ Không phải là một cây!

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

Splitchia một danh sách thành các danh sách con của các phần tử liên tiếp, ví dụ {1, 1, 2, 3, 4, 4}thành{{1, 1}, {2}, {3}, {4, 4}}

{{_}..}là, cụ thể là {{_}, {_}, {_}, ...}. Các mẫu phù hợp với một danh sách các danh sách con unary.

Differences phương thức, 48 byte:

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

Mã sử ​​dụng Differencesđể xác định xem các phần tử liền kề có giống nhau không.

Từng bước một:

1. Permutations@# tạo ra tất cả các hoán vị của danh sách đầu vào vào danh sách N! * N.
2. Differences/@ tính toán sự khác biệt giữa các phần tử N và đưa ra danh sách N! * (N-1).
3. 1##&@@@tính toán nhân của tất cả các danh sách. Nếu một danh sách chứa 0(hai phần tử liền kề là như nhau), kết quả sẽ là 0, khác không, thành N! danh sách.
4. Clip[]hành động như Sign[], chuyển đổi danh sách từ (-inf, inf) thành [-1, 1]
5. Tr@Absbiến tất cả -1thành 1và bây giờ danh sách N! -ngngth chỉ chứa 0(không hợp lệ) và 1(hợp lệ). Vì vậy, chúng tôi chỉ cần tổng hợp danh sách.

Thạch , 7 byte

Œ!QIẠ€S

Hãy thử trực tuyến!

Lấy đầu vào như ví dụ [1,1,1,1,2,2,2]cho [4,3]. Các [8,3,2]testcase mất quá nhiều thời gian để chạy trên TIO.

Làm thế nào nó hoạt động

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

Hãy thử trực tuyến!

-1 cảm ơn nmjcman101 về một câu trả lời khác.

Toán học, 50 byte

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

Hãy thử nó trong Mathics , hoặc tại hộp cát Wolfram !

Có đầu vào như trong các trường hợp thử nghiệm - ví dụ: {4,3}"4 sọc đỏ, 3 sọc vàng".

Đây là một triển khai ngây thơ của một công thức tôi tìm thấy ở đây . "Naïve" có nghĩa là "Tôi không biết toán học hoạt động như thế nào nên xin đừng hỏi tôi một lời giải thích".

Python 3.5 , 65 byte

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

Hãy thử trực tuyến!

Ruby 2.4, 47 byte

Đầu vào là một danh sách các nhân vật: Đối với các trường hợp thử nghiệm [4,3], đầu vào có thể được %w[a a a a b b b], "1111222".charshoặc một số mảng định dạng phương pháp khác đó là hợp lệ trong Ruby.

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

Yêu cầu 2.4 cho Enumerator#uniq(các phiên bản trước chỉ có sẵn trên Arraylớp). Như vậy, liên kết TIO thêm 5 byte để chuyển đổi bộ liệt kê hoán vị thành một mảng trước thông qua to_a, vì nó không có chức năng trên.

Hãy thử trực tuyến!

R, 72 byte

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

Tạo chức năng

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

Đưa đầu vào theo mẫu [1,1,1,1,2,2,2]theo nhận xét của Erik Outgolfer. Sử dụng chức năng combinatcủa permnnó để tạo một danh sách tất cả các hoán vị, và sau đó uniqueđể có được tất cả các mục riêng biệt. sapplysau đó áp dụng chức năng sau cho tất cả các mục:

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

Mà đánh giá

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

Lưu ý rằng điều này xkhông giống với xđầu vào của hàm lớn. Sử dụng một ký tự khác trong hàm này sẽ đánh lừa việc pryr::ftin rằng hàm lớn cần một đối số khác.

Dù sao, khi được hoán vị, hàm này có sự khác biệt giữa vectơ : 2 1 3 4 2 1 -> -1 2 1 -2 -1. !chuyển đổi FALSEsố không thành số và thành số không TRUE, vì vậy vectơ trở thành FALSE FALSE FALSE FALSE FALSE. Tổng kết để kiểm tra xem có bất kỳ TRUEs nào không ( TRUEsẽ ngụ ý diff=0-> hai số liên tiếp giống nhau). Chúng ta có thể một lần nữa đảo ngược điều này với !để có được một boolean về việc có hay không các giá trị liên tiếp trong hoán vị.

Tổng kết các booleans này cho chúng ta tổng số hoán vị trong trường hợp này không phải là trường hợp.

Không hoạt động cho [8,3,2]testcase vì nó yêu cầu một vectơ 46GB để lưu trữ các hoán vị đó.

Thạch , 11 byte

Œ!Q⁻2\Ạ$ÐfL

Hãy thử trực tuyến!

Python 2 , 140 89 byte

Định dạng đầu vào là 'aaaabbb'cho trường hợp thử nghiệm [4,3].

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

Hãy thử trực tuyến!

Husk , 8 byte

#ȯ¬ṁtguP

Hãy thử trực tuyến! Đưa đầu vào ở định dạng "aaabb"cho [3,2]. Lần ra về trường hợp thử nghiệm dài nhất.

Giải trình

Không có gì lạ mắt ở đây, chỉ tính các hoán vị duy nhất trong đó tất cả các nhóm yếu tố liền kề có độ dài 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.

Ruby, 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}

Một hàm lambda đệ quy. Nhìn vào từng màu có thể và liều lượng tìm kiếm cây đệ quy, đếm số lần nó sử dụng tất cả các sọc.

Giải thích (cho phiên bản cũ):

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

Định dạng đầu vào là [1 1 1 1 2 2 2]cho [4 3], v.v.

Chạy ra khỏi bộ nhớ cho trường hợp thử nghiệm cuối cùng.

Hãy thử trực tuyến!

Giải trình

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