นี่คือปริศนาการเขียนโปรแกรมสำหรับคุณ:

รับรายการคู่ของสายอักขระและหมายเลขที่เกี่ยวข้องตัวอย่างเช่น[[A,37],[B,27],[C,21],[D,11],[E,10],[F,9],[G,3],[H,2]]เอาท์พุทรายการอื่นซึ่งจะมีเพียงสตริงในลักษณะดังต่อไปนี้:

1. จำนวนรวมของสตริงใด ๆ ควรเท่ากับจำนวนที่สอดคล้องกันในข้อมูลอินพุต

2. ไม่ควรมีสตริงซ้ำติดกันในลำดับและทุกสตริงควรปรากฏในรายการผลลัพธ์

3. การเลือกสตริงถัดไปควรทำแบบสุ่มตราบเท่าที่พวกเขาไม่ได้อยู่เหนือกฎสองข้อ แต่ละโซลูชันควรมีความน่าจะเป็นที่ไม่เป็นศูนย์ของการเลือก

4. 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 , 148 141 ไบต์

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

ungolfed

(?@# { ])@(#~ 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 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

ＷΦθ§κ¹«

ทำซ้ำในขณะที่มีการนับที่ไม่เป็นศูนย์อย่างน้อยหนึ่งรายการ

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

ค้นหาจำนวนใด ๆ ที่ทำขึ้นมากกว่าครึ่งหนึ่งที่เหลือ

∨...ι

หากไม่มีให้เลือกตัวกรองที่ไม่ใช่ค่าศูนย์ก่อนหน้านี้

Φ...¬⁼κυ

กรองสตริงที่ถูกเอาต์พุตครั้งล่าสุด

≔‽∨...υ

กำหนดองค์ประกอบแบบสุ่มจากรายการแรกที่ไม่ว่างเปล่าของสองรายการข้างต้นไปยังสตริงเอาต์พุตสุดท้าย โปรดทราบว่าหากมีการป้อนค่าที่เป็นไปไม่ได้โปรแกรมจะหยุดทำงาน ณ จุดนี้

§υ⁰

พิมพ์สตริง

⊞υ⊖⊟υ

ลดจำนวนลง

Ruby , 85 ไบต์

วิธีการที่ดุร้าย (ขอบคุณโจนาห์สำหรับความคิด

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

ลองออนไลน์!

Ruby , 108 100 96 ไบต์

ก่อนหน้านี้แนวทางของ 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, ในฐานะที่จะยกเลิกซึ่งกันและกัน, ย้ายออกจากกัน, อนุญาตให้ Bs ย้ายในระหว่างพวกเขา เมื่อเวลาผ่านไปถึงการผสมผสานที่ดีของอนุภาค หลังจากการวนซ้ำของ 'การเคลื่อนที่ของอนุภาค' แต่ละครั้งโปรแกรมจะตรวจสอบว่าไม่มีอนุภาคใด ๆ ติดกันจากนั้นหยุดและพิมพ์สถานะของระบบ

ตอนนี้เมื่อพูดถึงการนำระบบกายภาพมาใช้จริงมันเริ่มต้นจากการใช้เทคนิคการสาธิต / เกมเก่า fashiond PC เพื่อเก็บตำแหน่งและความเร็วของอนุภาคแต่ละตัวเป็นตัวเลขจากนั้นจึงทำการวนซ้ำเพื่ออัปเดตตำแหน่งและความเร็ว ในการวนซ้ำแต่ละครั้งเรากำลังเพิ่มความเร็วไปยังตำแหน่ง (การเคลื่อนไหว) และเพิ่มการเร่งความเร็วให้กับความเร็ว (การเปลี่ยนแปลงอัตราการเคลื่อนไหว) และการคำนวณการเร่งความเร็ว (การค้นหาแรงบนอนุภาค) เพื่อให้ง่ายขึ้นระบบจะไม่คำนวณแรงของแต่ละอนุภาคตามอนุภาคอื่น ๆ ทั้งหมด แต่จะตรวจสอบอนุภาคที่อยู่ติดกันทันที นอกจากนี้ยังมีผล 'การทำให้หมาด ๆ ' เพื่อให้อนุภาคจะไม่เร่งความเร็วมากเกินไปและบินไปที่อินฟินิตี้ (เช่นความเร็วลดลงร้อยละ x ในแต่ละขั้นตอนเป็นต้น)

อย่างไรก็ตามตลอดกระบวนการเล่นกอล์ฟสิ่งทั้งหมดนี้ถูกลดทอนลงและทำให้ง่ายขึ้นอย่างมาก ทีนี้แทนที่จะเป็นสองอนุภาคที่เหมือนกันที่จะต้านทานพวกมันก็แค่ 'เทเลพอร์ต' อนุภาคที่แตกต่างกันเพียงแค่ 'วิ่งหนี' เล็กน้อยเพื่อป้องกันความเมื่อยล้าในระบบ ตัวอย่างเช่นถ้า A อยู่ถัดจาก A มันจะทำการส่งผ่านทางไกล ถ้า A อยู่ถัดจาก B มันจะเปลี่ยนไปเพียงเล็กน้อยเท่านั้น จากนั้นจะตรวจสอบว่าตรงตามเงื่อนไขหรือไม่ (ไม่เหมือนอนุภาคที่อยู่ติดกัน) และพิมพ์สตริงตามลำดับโดยขึ้นอยู่กับตำแหน่งในพื้นที่ 1-d มันเกือบจะเหมือนอัลกอริธึมการเรียงลำดับมากกว่าการจำลอง - จากนั้นอีกครั้งเราสามารถเห็นการเรียงลำดับอัลกอริธึมเป็นรูปแบบของการจำลอง 'การดริฟท์' ตาม 'มวล' ฉันเชือนแช

อย่างไรก็ตามนี่เป็นหนึ่งในโปรแกรม Rust แรกของฉันดังนั้นฉันจึงยอมแพ้หลังจากเล่นกอล์ฟหลายชั่วโมงแม้ว่าอาจมีโอกาสยังคงอยู่ บิตการแยกวิเคราะห์ยากสำหรับฉัน มันอ่านสตริงอินพุตจากอินพุตมาตรฐาน หากต้องการก็สามารถแทนที่ด้วย "let mut s =" [[A, 3], [B, 2]] "แต่ตอนนี้ฉันทำ 'echo [[A, 3], [B, 2]] | Cargo Run 'บนบรรทัดคำสั่ง

การคำนวณการหยุดเป็นปัญหาเล็กน้อย จะตรวจสอบได้อย่างไรว่าสถานะที่ถูกต้องของระบบจะไม่ถึง แผนแรกคือการตรวจสอบว่าสถานะ 'ปัจจุบัน' เคยทำซ้ำสถานะเก่าเช่นถ้า ACCC เปลี่ยนเป็น CACC แต่กลับไปที่ ACCC เรารู้ว่าโปรแกรมจะไม่ยุติเนื่องจากเป็นเพียงการสุ่มหลอก มันควรจะยอมแพ้และพิมพ์ 0 ถ้ามันเกิดขึ้น อย่างไรก็ตามนี่ดูเหมือนว่าจะเป็นรหัสสนิมจำนวนมากดังนั้นฉันแค่ตัดสินใจว่าถ้ามันผ่านการทำซ้ำจำนวนมากมันอาจติดอยู่และจะไม่ถึงสถานะคงที่ดังนั้นมันจึงพิมพ์ 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;}

ลองออนไลน์!

สิ่งนี้จะไม่ส่งคืนหากไม่มีวิธีแก้ไข