Đây là một câu đố lập trình cho bạn:

Ví dụ [[A,37],[B,27],[C,21],[D,11],[E,10],[F,9],[G,3],[H,2]], đưa ra một danh sách các cặp chuỗi và số tương ứng, hãy đưa ra một danh sách khác sẽ chỉ có các chuỗi theo cách sau:

1. Tổng số của bất kỳ chuỗi nào phải chính xác bằng số tương ứng của nó trong dữ liệu đầu vào.

2. Không có chuỗi nào được lặp lại liên tục trong chuỗi và mỗi chuỗi sẽ xuất hiện trong danh sách đầu ra.

3. Việc lựa chọn chuỗi tiếp theo nên được thực hiện ngẫu nhiên miễn là chúng không vi phạm trên hai quy tắc. Mỗi giải pháp nên có xác suất khác không được chọn.

4. Nếu không có sự kết hợp nào là có thể, thì đầu ra chỉ là 0.

Danh sách đầu vào có thể được đưa ra theo bất kỳ thứ tự nào (được sắp xếp hoặc chưa được sắp xếp) và các chuỗi trong danh sách có thể có độ dài bất kỳ.

Đầu ra mẫu cho đầu vào mẫu trên 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]

Mẫu đầu vào 2:

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

Đầu ra cho đầu vào thứ hai:

0

vì không có danh sách có thể dựa trên các quy tắc.

Mẫu đầu vào 3:

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

đầu ra hợp lệ: [AC,BD,AC,BD,AC]

đầu ra không hợp lệ: [AC,BD,AC,AC,BD]

Nếu cần làm rõ thêm, xin vui lòng, đừng ngần ngại cho tôi biết trong các ý kiến ​​và tôi sẽ nhanh chóng hành động phù hợp.

Đây là mã golf , vì vậy mã ngắn nhất tính theo byte cho mỗi ngôn ngữ sẽ thắng!

Thạch , 11 byte

Œṙ'Œ!⁻ƝẠ$ƇX

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

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

Thạch , 17 byte

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

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

Python 2 , 114 189 185 174 byte

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]

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

Ôi! Khó hơn nhiều với quy tắc 3 ... :). Vẫn đang cố gắng tránh O(n!)cách tiếp cận, vì vậy đôi khi nó có thể xử lý tất cả các trường hợp thử nghiệm trước cái chết nóng của vũ trụ ...

Thuật toán: giả sử tổng tổng số chuỗi là t. Nếu bất kỳ chuỗi nào có số đếm nvới 2*n>t+1thì không thể thỏa mãn các ràng buộc. Do đó, nếu bất kỳ chuỗi nào (không bao gồm chuỗi đã chọn trước đó) được tính nvới 2*n=t+1, thì chúng ta phải chọn chuỗi đó tiếp theo. Mặt khác, chúng ta có thể chọn ngẫu nhiên bất kỳ chuỗi nào không phải là chuỗi đã chọn trước đó.

R , 148 141 byte

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)

Hãy thử trực tuyến! (Tôi đã sao chép combinat::permnvà gọi nó combinatXXpermnở đó.)

Dung dịch O (n!).

Sử dụng permntừ combinatgói để tạo ra tất cả các thứ tự có thể. Sau đó kiểm tra xem liệu có tuân theo quy tắc nào không và chọn một trong số đó một cách ngẫu nhiên.

JavaScript, 112 byte

Đầu tiên vượt qua điều này, nhiều golf để (hy vọng) làm theo.

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

Dùng thử trực tuyến

J, 60 53 byte

-7 cảm ơn FrownyFrog

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

nguyên

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

vô dụng

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

Đề nghị cải tiến chào mừng.

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

JavaScript (ES6), 160 byte

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

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

Than , 38 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

ＷΦθ§κ¹«

Lặp lại trong khi có ít nhất một số khác không.

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

Tìm bất kỳ số lượng nào chiếm hơn một nửa số còn lại.

∨...ι

Nếu không có, thì chỉ cần lấy số khác không được lọc trước đó.

Φ...¬⁼κυ

Lọc ra chuỗi đã xuất ra lần trước.

≔‽∨...υ

Gán một phần tử ngẫu nhiên từ danh sách không trống đầu tiên của hai danh sách trên cho chuỗi đầu ra cuối cùng. Lưu ý rằng nếu một sự kết hợp không thể được nhập vào, chương trình sẽ bị sập vào thời điểm này.

§υ⁰

In chuỗi.

⊞υ⊖⊟υ

Giảm số lượng của nó.

Ruby , 85 byte

Cách tiếp cận vũ phu (cảm ơn Jonah vì ý tưởng).

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

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

Ruby , 108 100 96 byte

Trước đây, cách tiếp cận 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)}

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

Rust 633 byte

Điều làm cho điều này khác một chút so với những người khác là nó bắt đầu với ý tưởng sắp xếp lại các chuỗi bằng cách mô phỏng một hệ thống vật lý. Mỗi chuỗi đầu tiên được nhân đôi số lần thích hợp. Sau đó, mỗi chuỗi riêng lẻ được coi là một Hạt trong một không gian. Hai hạt có cùng giá trị chuỗi "đẩy lùi" nhau, trong khi hai hạt có giá trị khác nhau thu hút lẫn nhau. Ví dụ: nếu chúng ta bắt đầu với AAAAAAABBBBCC, As sẽ hủy bỏ nhau, di chuyển ra xa nhau, cho phép các Bs di chuyển giữa chúng. Theo thời gian điều này đạt đến một hỗn hợp tốt đẹp của các hạt. Sau mỗi lần lặp của 'chuyển động hạt', chương trình sẽ kiểm tra xem không có các hạt giống nhau nào kề nhau, sau đó dừng lại và in trạng thái của hệ thống, đơn giản là danh sách các chuỗi theo thứ tự, khi chúng xuất hiện trong không gian 1 chiều.

Bây giờ, khi thực sự triển khai hệ thống vật lý đó, nó bắt đầu bằng cách sử dụng kỹ thuật demo / trò chơi PC cũ của fashiond, để lưu trữ từng vị trí và vận tốc của các hạt dưới dạng số, sau đó đi qua các lần lặp để cập nhật vị trí và vận tốc. Ở mỗi lần lặp, chúng ta sẽ thêm vận tốc vào vị trí (chuyển động) và thêm gia tốc cho vận tốc (thay đổi tốc độ chuyển động) và tính gia tốc (tìm lực tác dụng lên hạt). Để đơn giản hóa, hệ thống không tính toán lực trên mỗi hạt dựa trên tất cả các hạt khác - nó chỉ kiểm tra các hạt liền kề ngay lập tức. Ngoài ra còn có hiệu ứng 'giảm xóc' để các hạt không tăng tốc quá nhiều và bay đến vô cực (ví dụ vận tốc giảm x phần trăm mỗi bước).

Tuy nhiên, thông qua quá trình chơi golf, toàn bộ điều này đã được cắt giảm và đơn giản hóa mạnh mẽ. Bây giờ, thay vì hai hạt giống nhau đẩy lùi nhau, chúng chỉ đơn giản là "dịch chuyển tức thời". Các hạt khác nhau chỉ đơn giản là 'tăng tốc' một chút để ngăn chặn sự trì trệ trong hệ thống. Ví dụ, nếu A bên cạnh A, nó sẽ dịch chuyển tức thời. Nếu A bên cạnh B, nó sẽ chỉ thay đổi một chút. Sau đó, nó kiểm tra xem các điều kiện có được đáp ứng (không giống như các hạt liền kề) và in các chuỗi theo thứ tự, dựa trên vị trí của chúng trong không gian 1-d. Nó gần giống như một thuật toán sắp xếp hơn là một mô phỏng - sau đó, một lần nữa, người ta có thể thấy các thuật toán sắp xếp là một dạng mô phỏng 'trôi' dựa trên 'khối lượng'. Tôi lạc đề.

Dù sao, đây là một trong những chương trình Rust đầu tiên của tôi nên tôi đã bỏ cuộc sau vài giờ chơi golf, mặc dù vẫn có cơ hội ở đó. Các bit phân tích là khó khăn đối với tôi. Nó đọc chuỗi đầu vào từ đầu vào tiêu chuẩn. Nếu muốn, điều đó có thể được thay thế bằng "let mut s =" [[A, 3], [B, 2]] ". Nhưng ngay bây giờ tôi làm 'echo [[A, 3], [B, 2]] | hàng chạy 'trên dòng lệnh.

Việc tính toán dừng lại là một vấn đề. Làm thế nào để phát hiện nếu một trạng thái hợp lệ của hệ thống sẽ không bao giờ đạt được? Kế hoạch đầu tiên là phát hiện xem trạng thái 'hiện tại' có lặp lại trạng thái cũ hay không, ví dụ nếu ACCC thay đổi thành CACC nhưng sau đó quay lại ACCC, chúng tôi biết chương trình sẽ không bao giờ chấm dứt, vì nó chỉ là giả ngẫu nhiên. Sau đó nó sẽ từ bỏ và in 0 nếu điều đó xảy ra. Tuy nhiên, đây có vẻ như là một số lượng lớn mã Rust, vì vậy thay vào đó tôi chỉ quyết định rằng nếu nó trải qua số lần lặp cao, nó có thể bị kẹt và sẽ không bao giờ đạt đến trạng thái ổn định, vì vậy nó in 0 và dừng lại. Bao nhiêu? Số lượng hạt bình phương.

Mã số:

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 byte

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)

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

Java (JDK 10) , 191 byte

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

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

Điều này không bao giờ trở lại nếu không có giải pháp.