可以说您的工作是给杆子上漆，客户要求您给杆子涂上4个红色部分和3个黄色部分。您可以很容易地做到这一点，如下所示：

r y r y r y r

仅有黄色和红色条纹。现在，假设您的客户要您用2个红色部分，2个黄色部分和1个绿色部分绘制一个杆。有两种方法可以画杆子

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

更确切地说，多数民众赞成在十二种方法来画杆。这会炸掉涉及的更多颜色和部分

现在，如果您的客户说他们想要3个红色的部分和1个黄色的部分，则无法绘制这样的杆。因为无论您如何尝试安排这些部分，两个红色部分都会接触，而当两个红色部分接触时，它们将变成一个红色部分。

这几乎是我们画杆的一条规则

相邻部分的颜色可能不同

任务

给定所需颜色和截面的列表，根据要求输出可能的方法来绘制杆。您可以用任何合理的方式来表示颜色（整数，字符，字符串），但是一次不会给您提供255种以上的不同颜色。如果您愿意，甚至可以选择不为颜色分配名称，如果方便的话，只需列出部分计数即可。

测试用例

手工很难计算出这些，尤其是当它们变得更大时。如果有人有建议的测试用例，我将其添加。

[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 个字节

将输入作为整数列表{1, 1, 1, 2, 2}。在Wolfram Sandbox上尝试一下。

模式匹配方法，谢谢@不是一棵树！

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

Split分割一个单一列表划分为连续的元件，例如的子列表{1, 1, 2, 3, 4, 4}进{{1, 1}, {2}, {3}, {4, 4}}

{{_}..}是{{_}, {_}, {_}, ...}。该模式匹配一​​元子列表的列表。

Differences 方法，48个字节：

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

该代码用于Differences确定相邻元素是否相同。

一步步：

1. Permutations@# 生成输入列表到N！* N列表的所有排列。
2. Differences/@ 计算N个元素之间的差，并生成N！*（N-1）列表。
3. 1##&@@@计算所有列表的乘法。如果列表包含0（两个相邻元素相同），则结果将为0N，否则为非零！清单。
4. Clip[]类似于Sign[]，将列表从（-inf，inf）转换为[-1，1]
5. Tr@Abs关闭所有-1到1现在的N！-length列表只包含0（无效）和1（有效）。因此，我们只对列表进行汇总。

果冻，7个字节

Œ!QIẠ€S

在线尝试！

以输入为例 [1,1,1,1,2,2,2]对[4,3]。该[8,3,2]测试用例的时间太长对TIO运行。

怎么运行的

Œ!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个字节

œÙ€¥PĀO

在线尝试！

-1感谢nmjcman101的另一个答案。

Mathematica，50个字节

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

在Mathics或Wolfram沙箱中尝试！

像测试用例一样接受输入-例如，{4,3}表示“ 4条红色条纹，3条黄色条纹”。

这是我在这里找到的公式的简单实现。“天真”的意思是“我不知道数学是如何工作的，所以请不要要求我解释……”

Python 3.5，65个字节

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

在线尝试！

Ruby 2.4，47个字节

输入是字符的列表：对于测试用例[4,3]，输入可以是%w[a a a a b b b]，"1111222".chars，或，在Ruby的有效一些其它阵列格式的方法。

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

需要2.4 for Enumerator#uniq（仅早期版本在Array类中可用）。这样，TIO链接会添加5个字节，以首先通过以下方式将置换枚举器转换为数组to_a，因为它不具有上述功能。

在线尝试！

R，72个字节

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

创建功能

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

[1,1,1,1,2,2,2]按照Outgolfer的评论Erik 的形式输入信息。使用combinat的permn函数创建所有排列的列表，然后unique获取所有不同的条目。sapply然后对所有条目应用以下功能：

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

哪个评估为

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

请注意，这与big函数的输入中的x不相同x。在此功能中使用另一个字符会很傻pryr::f地认为大函数需要另一个参数。

无论如何，给定排列后，此函数将采用向量之间的差：2 1 3 4 2 1 -> -1 2 1 -2 -1。!将非零FALSE值转换为，零值转换为TRUE，所以向量变为FALSE FALSE FALSE FALSE FALSE。总结一下以检查是否有TRUEs（TRUE这意味着diff=0->两个相同的连续数字）。我们可以再次用反转此值，!以获取排列中是否有连续值的布尔值。

将这些布尔值相加得出的结果是排列的总数（不是这种情况）。

对于[8,3,2]测试用例不起作用，因为它需要46GB的向量来存储这些排列。

果冻，11字节

Œ!Q⁻2\Ạ$ÐfL

在线尝试！

Python 2中，140个 89字节

输入格式'aaaabbb'用于测试用例[4,3]。

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

在线尝试！

外壳，8字节

#ȯ¬ṁtguP

在线尝试！ 接受格式"aaabb"为的输入[3,2]。在最长的测试用例上超时。

说明

这里没什么好想的，只计算所有相邻元素组的长度为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个字节

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}

递归lambda函数。查看每种可能的颜色，并进行递归树搜索，计算其使用所有条纹的次数。

说明（对于旧版本）：

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字节

Y@Xu!dAs

输入格式[1 1 1 1 2 2 2]用于[4 3]，等等。

最后一个测试用例的内存不足。

在线尝试！

说明

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