这是给您的编程难题：

例如，给定一对字符串和对应数字的[[A,37],[B,27],[C,21],[D,11],[E,10],[F,9],[G,3],[H,2]]列表，请输出另一个列表，该列表将仅以以下方式包含字符串：

1. 任何字符串的总计数应完全等于输入数据中其对应的数字。

2. 不应在序列中相邻重复任何字符串，并且每个字符串都应出现在输出列表中。

3. 只要不超过两个规则，就应该随机选择下一个字符串。每个解决方案的选择概率均应为非零。

4. 如果无法组合，则输出应为just 0。

输入列表可以以任何顺序（排序或未排序）给出，列表中的字符串可以具有任何长度。

上述样本输入1的样本输出

[A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,C,A,C,A,C,A,C,A,C,A,C,A,C,A,C,A,C,A,C,D,C,D,C,D,C,D,C,D,C,D,C,D,C,D,C,D,C,D,C,D,C,E,F,E,F,E,F,E,F,E,F,E,F,E,F,E,F,E,F,E,G,H,G,H,G]

输入样本2：

[[A,6],[B,1],[C,1]]

第二个输入的输出：

0

因为根据规则无法列出。

样本输入3：

[[AC,3],[BD,2]]

有效输出： [AC,BD,AC,BD,AC]

无效的输出： [AC,BD,AC,AC,BD]

如果需要进一步澄清，请随时在评论中告诉我，我将立即采取行动。

这是代码高尔夫球，因此每种语言的最短代码以字节为单位！

果冻，11字节

Œṙ'Œ!⁻ƝẠ$ƇX

在线尝试！

Œṙ'Œ!⁻ƝẠ$ƇX Arguments: z
  '         Flat: Apply link directly to x, ignoring its left and right depth properties
Œṙ            Run-length decode
   Œ!       Permutations of x
         Ƈ  Filter; keep elements of x for which the link returns a truthy result
        $     ≥2-link monadic chain
      Ɲ         Apply link on overlapping pairs (non-wrapping)
     ⁻            x != y
       Ạ        Check if all elements of x have a truthy value (+vacuous truth)
          X Pick a random element of x; return 0 if the list is empty.

果冻，17个字节

Wẋ¥Ɲ€ẎẎŒ!Œɠ’SƊÐḟX

在线尝试！

Python 2中，114个 189 185 174字节

from random import*
a=input()
s=u=[]
while a:x,y=a.pop(a.index(next((w for w in a if w[1]>sum(v[1]for v in a+u)/2),choice(a))));s=s+[x];a+=u;u=[[x,y-1]]*(y>1)
print[s,0][y>1]

在线尝试！

哎哟! 规则3变得更加困难... :)。仍在尝试避免这种O(n!)方法，因此它可以在宇宙热死之前的某个时间处理所有测试用例。

算法：假设字符串计数的总和为t。如果任何字符串的计数n为2*n>t+1，则不可能满足约束。因此，如果任何字符串（不包括先前选择的字符串）的计数n为2*n=t+1，那么我们必须接下来选择该字符串。否则，我们可以随机选择不是先前选择的字符串的任何字符串。

R，148141字节

function(x,y,p=combinatXXpermn(rep(seq(y),y)),q=which(sapply(lapply(p,diff),all)))"if"(n<-sum(q|1),"if"(n-1,x[p[[sample(q,1)]]],x[p[[q]]]),0)

在线尝试！（我已combinat::permn在combinatXXpermn此处复制并调用它。）

蛮力O（n！）解决方案。

用途permn从combinat包生成所有可能的排序。然后检查是否有任何规则，并随机选择其中之一。

JavaScript，112字节

第一次通过，希望打更多的高尔夫球。

f=([i,...a],o=[])=>a.sort((x,y)=>(y[1]-x[1])*Math.random()-n*.5,n=--i[1],o.push(i[0]))+a?f(n?[...a,i]:a,o):n?0:o

在线尝试

J，60 53字节

-7感谢FrownyFrog

(?@#{])@(#~*/@(2~:/\])"1)@(]i.@!@#@;A.;) ::0(#~>)/&.>

原版的

(?@#{])@(#~2&([:*/~:/\)"1)@(A.~i.@!@#)@;@:(([#~>@])/&.>) ::0

不打高尔夫球

(?@# { ])@(#~ 2&([: */ ~:/\)"1)@(A.~ i.@!@#)@;@:(([ #~ >@])/&.>) ::0

欢迎提出改进建议。

在线尝试！

JavaScript（ES6），160字节

a=>(g=(a,m=[])=>a.map((v,n)=>v==m[0]||g(a.filter(_=>n--),[v,...m]))>[]?0:r=m)(a.reduce((p,[v,n])=>[...p,...Array(n).fill(v)],r=[]).sort(_=>Math.random()-.5))||r

在线尝试！

木炭，38字节

ＷΦθ§κ¹«≔‽Φ∨Φι›⊗§κ¹ΣＥι§μ¹ι¬⁼κυυ§υ⁰⊞υ⊖⊟υ

在线尝试！链接是详细版本的代码。说明：

ＷΦθ§κ¹«

在至少有一个非零计数时重复。

Φι›⊗§κ¹ΣＥι§μ¹

找出构成余数一半以上的任何计数。

∨...ι

如果没有，则只需取较早过滤的非零计数即可。

Φ...¬⁼κυ

过滤掉上次输出的字符串。

≔‽∨...υ

从上述两个列表的第一个非空到最后一个输出字符串分配一个随机元素。请注意，如果输入了不可能的组合，则程序将在此时崩溃。

§υ⁰

打印字符串。

⊞υ⊖⊟υ

减少其计数。

红宝石，85字节

蛮力方法（感谢乔纳的主意）。

->l{l.flat_map{|a,b|[a]*b}.permutation.select{|p|r=0;p.all?{|a|a!=r&&r=a}}.sample||0}

在线尝试！

红宝石，10810096字节

以前，Bogosort方法

->l{w=[];l.map{|a,b|w+=[a]*b;b}.max*2>w.size+1?0:(w.shuffle!until(r='';w.all?{|a|a!=r&&r=a});w)}

在线尝试！

锈633字节

之所以与其他方法有所不同，是因为它的想法是通过模拟物理系统来重新排列字符串。每个字符串首先被复制适当的次数。然后，每个单独的字符串都被视为空间中的粒子。具有相同字符串值的两个粒子彼此“排斥”，而具有不同值的两个粒子彼此吸引。例如，如果我们以AAAAAAABBBBCC开头，则A将会相互废除，彼此远离，从而允许B在它们之间移动。随着时间的流逝，颗粒会形成很好的混合物。在“粒子运动”的每次迭代之后，程序检查是否没有相同的粒子相邻，然后停止并打印系统状态，该状态只是按顺序列出的字符串列表，因为它们出现在1维空间中。

现在，在实际实现该物理系统时，它开始使用老式的PC演示/游戏技术，将每个粒子的位置和速度存储为数字，然后进行迭代以更新位置和速度。在每次迭代中，我们将速度添加到位置（运动），并将加速度添加到速度（运动速率的变化），并计算加速度（确定作用在粒子上的力）。为简化起见，系统不会基于所有其他粒子来计算每个粒子上的力-它仅检查紧邻的粒子。还有一个“阻尼”效应，以使粒子不会加速太多而飞到无穷大（例如，速度每步降低x百分比）。

但是，通过打高尔夫球的过程，这整个过程被削减并大大简化了。现在，它们不再是两个相同的粒子互相排斥，而只是“传送”。不同的粒子只是简单地“挖角”一点以防止系统停滞。例如，如果A在A旁边，它将进行传送。如果A在B旁边，则只会稍微移动。然后，它检查条件是否得到满足（附近没有类似的粒子），并根据字符串在1维空间中的位置顺序打印字符串。它几乎更像是一种排序算法，而不是一种模拟-然后，人们又可以将排序算法视为一种基于“质量”的模拟“漂移”形式。我离题了。

无论如何，这是我的第一个Rust程序之一，所以打了几个小时的高尔夫球后我还是放弃了，尽管那里仍然有机会。解析位对我来说很难。它从标准输入中读取输入字符串。如果需要，可以将其替换为“ let mut s =“ [[A，3]，[B，2]]”。但是现在我回显[[A，3]，[B，2]] |在命令行上运行。

停止的计算有点问题。如何检测系统永远不会达到有效状态？第一个计划是检测“当前”状态是否重复了旧状态，例如，如果ACCC更改为CACC，但随后又返回ACCC，我们知道程序将永远不会终止，因为它只是伪随机的。然后，如果出现这种情况，它应该放弃并打印0。但是，这似乎是大量的Rust代码，所以我只是决定，如果它经过大量的迭代，它可能会卡住并且永远不会达到稳定状态，因此它显示0并停止。多少？粒子数的平方。

码：

extern crate regex;
struct P {s:String,x:i32,v:i32}
fn main() {
    let (mut i,mut j,mut p,mut s)=(0,0,Vec::new(),String::new());
    std::io::stdin().read_line(&mut s);
    for c in regex::Regex::new(r"([A-Z]+),(\d+)").unwrap().captures_iter(&s) {
        for _j in 0..c[2].parse().unwrap() {p.push(P{s:c[1].to_string(),x:i,v:0});i+=1;}
    }
    let l=p.len(); while i>1 {
        j+=1;i=1;p.sort_by_key(|k| k.x);
        for m in 0..l {
            let n=(m+1)%l;
            if p[m].s==p[n].s {p[m].v=p[m].x;if n!=0 {i=2}} else {p[m].v=1}
            p[m].x=(p[m].x+p[m].v)%l as i32;
        }
        if j>l*l{p.truncate(1);p[0].s="0".to_string();i=1}
    }
    for k in &p{print!("{}",k.s)};println!();
}

JavaScript（Node.js），249字节

l=>(a=[],g=(r,s)=>s.length?s.forEach((x,i)=>g([...r,x],s.filter((y,j)=>j-i))):a.push(r),g([],l.reduce(((a,x)=>[...a, ...(x[0]+' ').repeat(x[1]).split(' ')]),[]).filter(x=>x)),p=a.filter(a=>a.every((x,i)=>x!=a[i+1])),p[~~(Math.random()*p.length)]||0)

在线尝试！

Java（JDK 10），191字节

S->N->{var l=new java.util.Stack();int i=0,j;for(var s:S)for(j=N[i++];j-->0;)l.add(s);for(;i>0;){i=0;java.util.Collections.shuffle(l);for(var s:S)if(s.join("",l).contains(s+s))i++;}return l;}

在线尝试！

如果没有解决方案，则永远不会返回。