İşte sizin için bir programlama bulmacası:

Örneğin, dize çiftlerinin ve karşılık gelen sayıların bir listesi verildiğinde [[A,37],[B,27],[C,21],[D,11],[E,10],[F,9],[G,3],[H,2]], yalnızca dizeleri aşağıdaki şekilde içerecek başka bir liste çıkarır:

1. Herhangi bir dizenin toplam sayısı, giriş verilerindeki karşılık gelen sayıya tam olarak eşit olmalıdır.

2. Hiçbir dize sırayla bitişik olarak tekrarlanmamalı ve her dize çıktı listesinde görünmelidir.

3. Sonraki dizenin seçimi, iki kuralın üzerine çıkmadığı sürece rastgele yapılmalıdır. Her çözelti, sıfır olmayan bir seçilme olasılığına sahip olmalıdır.

4. Herhangi bir kombinasyon mümkün değilse, çıktı sadece olmalıdır 0.

Giriş listesi herhangi bir sırayla (sıralı veya sıralanmamış) verilebilir ve listedeki dizeler herhangi bir uzunlukta olabilir.

Yukarıdaki örnek girişi için örnek çıktısı 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]

Giriş örneği 2:

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

İkinci giriş için çıkış:

0

çünkü kurallara dayalı bir liste mümkün değildir.

Örnek giriş 3:

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

geçerli çıktı: [AC,BD,AC,BD,AC]

geçersiz çıktı: [AC,BD,AC,AC,BD]

Daha fazla açıklama gerekiyorsa, lütfen yorumlarda bana söylemekten çekinmeyin ve derhal buna göre hareket edeceğim.

Bu kod golf , her dil için bayt olarak en kısa kod kazanır!

Jöle , 11 bayt

Œṙ'Œ!⁻ƝẠ$ƇX

Çevrimiçi deneyin!

Œṙ'Œ!⁻ƝẠ$Ƈ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.

Jöle , 17 bayt

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

Çevrimiçi deneyin!

Piton 2 , 114 189 185 174 bayt

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]

Çevrimiçi deneyin!

Ah! Kural 3 ile çok daha zor ... :). Yine de O(n!)yaklaşımdan kaçınmaya çalışıyor , böylece evrenin ısı ölümünden bir süre önce tüm test vakalarını işleyebilir ...

Algoritma: dize sayımlarının toplamının toplamı olduğunu varsayalım t. Herhangi bir dize sayımını varsa nile 2*n>t+1, o zaman kısıtlamaları karşılamak için mümkün değildir. (Daha önce seçilmiş kişi hariç) herhangi bir dize sayısı varsa nedenle, nile 2*n=t+1, o zaman sonraki o dizeyi seçmelidir. Aksi takdirde, önceden seçilen dize olmayan herhangi bir dizeyi rastgele seçebiliriz.

R , 148141 bayt

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)

Çevrimiçi deneyin! (Kopyaladım combinat::permnve combinatXXpermnorada aradım .)

Kaba kuvvet O (n!) Çözeltisi.

Tüm olası siparişleri oluşturmak permniçin combinatpaketten kullanır . Sonra kurallara uyup uymadığını kontrol eder ve bunlardan birini rastgele seçer.

JavaScript, 112 bayt

Bu ilk geçiş, (umarım) takip daha golf.

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

Çevrimiçi deneyin

J, 60 53 bayt

-7 sayesinde FrownyFrog

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

orijinal

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

ungolfed

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

İyileştirme önerileri hoş geldiniz.

Çevrimiçi deneyin!

JavaScript (ES6), 160 bayt

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

Çevrimiçi deneyin!

Kömür , 38 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama:

ＷΦθ§κ¹«

Sıfır olmayan en az bir sayı varken tekrarlayın.

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

Kalanın yarısından fazlasını oluşturan herhangi bir sayıyı bulun.

∨...ι

Bir tane yoksa, daha önce filtrelenen sıfır olmayan sayıları almanız yeterlidir.

Φ...¬⁼κυ

Son kez çıkan dizgeyi filtreleyin.

≔‽∨...υ

Yukarıdaki iki listenin ilk boş olmayanından son çıkış dizesine rastgele bir öğe atayın. İmkansız bir kombinasyon girilirse, programın bu noktada çökeceğini unutmayın.

§υ⁰

Dizeyi yazdırın.

⊞υ⊖⊟υ

Sayısını azalt.

Yakut , 85 bayt

Kaba kuvvet yaklaşımı (fikir için Jonah'a teşekkürler).

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

Çevrimiçi deneyin!

Yakut , 108100 96 bayt

Daha önce Bogosort yaklaşımı

->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)}

Çevrimiçi deneyin!

Pas 633 bayt

Bunu diğerlerinden biraz farklı kılan şey, fiziksel bir sistemi simüle ederek dizeleri yeniden düzenleme fikriyle başladı. Her dize önce uygun sayıda kopyalanır. Daha sonra her bir ip, bir alanda bir Parçacık olarak işlem görür. Aynı dize değerine sahip iki parçacık birbirini "iter", farklı değerlere sahip iki parçacık birbirini çeker. Örneğin, AAAAAAABBBBCC ile başlarsak, As birbirini uzaklaştıracak, birbirlerinden uzaklaşacak ve B'lerin aralarında hareket etmesine izin verecektir. Zamanla bu güzel parçacık karışımına ulaşır. Her 'parçacık hareketi' yinelemesinden sonra, program aynı parçacıkların bitişik olmadığını kontrol eder, daha sonra durur ve 1 boyutlu alanda göründükleri gibi dizelerin listesi olan sistemin durumunu yazdırır.

Şimdi, bu fiziksel sistemi gerçekte uygulama söz konusu olduğunda, her bir parçacık pozisyonunu ve hızını sayı olarak saklamak, daha sonra pozisyon ve hızı güncellemek için iterasyonlardan geçmek için eski moda PC demo / oyun tekniğini kullanmakla başladı. Her yinelemede, pozisyona (hareket) hız ekliyoruz ve hıza ivme ekliyoruz (hareket oranındaki değişiklik) ve ivmeyi hesaplıyoruz (parçacık üzerindeki kuvveti buluyoruz). Basitleştirmek için, sistem diğer tüm parçacıklara dayanarak her parçacık üzerindeki kuvveti hesaplamaz - sadece hemen yanındaki parçacıkları kontrol eder. Parçacıkların çok fazla hızlanmaması ve sonsuzluğa uçması için bir 'sönümleme' etkisi de vardı (örneğin, hız her adımda yüzde x oranında azalır).

Bununla birlikte, golf süreci boyunca, her şey kesildi ve büyük ölçüde basitleştirildi. Şimdi, birbirlerini iten iki parçacık yerine, sadece 'ışınlanıyorlar'. Farklı parçacıklar, sistemdeki durgunluğu önlemek için sadece bir çırpma biti 'toplarlar'. Örneğin A, A'nın yanındaysa ışınlanır. A, B'nin yanındaysa, sadece hafifçe kayacaktır. Daha sonra koşulların karşılanıp karşılanmadığını kontrol eder (bitişikteki parçacıklar gibi değil) ve 1-boyutlu boşluktaki konumlarına göre dizeleri sırayla yazdırır. Neredeyse bir simülasyondan daha çok bir sıralama algoritması gibidir - o zaman tekrar, sıralama algoritmaları 'kütle'ye dayalı bir benzetilmiş' sürüklenme 'biçimi olarak görülebilir. Konuya giriyorum.

Her neyse, bu benim ilk Rust programımdan biri, bu yüzden hala fırsatlar olsa da, birkaç saat golf yaptıktan sonra vazgeçtim. Ayrıştırma biti benim için zor. Giriş dizesini standart girişten okur. İstenirse bu "let mut s =" [[A, 3], [B, 2]] "ile değiştirilebilir. Ama şu anda 'echo [[A, 3], [B, 2]] | kargo 'komut satırında.

Durdurmanın hesaplanması bir problemdir. Sistemin geçerli bir durumuna asla ulaşılamayacağı nasıl belirlenir? İlk plan, 'şimdiki' durumun eski bir durumu tekrarlayıp tekrarlamadığını tespit etmekti, örneğin ACCC CACC'ye değiştiyse, ancak ACCC'ye döndüğünde, programın hiçbir zaman sonlandırılmayacağını biliyoruz, çünkü sadece sahte rastgele. Bu durumda vazgeçmeli ve 0 olursa yazdırmalıdır. Ancak bu çok büyük bir Rust kodu gibi görünüyordu, bu yüzden bunun yerine sadece çok sayıda yinelemeden geçerse, muhtemelen sıkışmış ve asla sabit bir duruma ulaşmayacağına karar verdim, bu yüzden 0 yazdırır ve durur. Kaç? Kareler halinde parçacık sayısı.

Kod:

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 bayt

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)

Çevrimiçi deneyin!

Java (JDK 10) , 191 bayt

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;}

Çevrimiçi deneyin!

Çözüm yoksa bu asla geri gelmez.