Ось головоломка програмування для вас:

Наприклад [[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

неозорий

(?@# { ])@(#~ 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}

Спробуйте в Інтернеті!

Рубі , 108 100 96 байт

Раніше підхід Богоссорта

->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, As будуть скасовувати один одного, віддаляючись один від одного, дозволяючи Bs рухатися між ними. З часом це досягає приємної суміші частинок. Після кожної ітерації «руху частинок» програма перевіряє, чи не є однакові частинки, а потім зупиняється та друкує стан системи, що є просто списком рядків у порядку, як вони з’являються в 1-мірному просторі.

Тепер, коли мова заходить про те, щоб реально реалізувати цю фізичну систему, вона почалася, використовуючи стару модну демонстраційну / ігрову техніку ПК, щоб зберігати кожну позицію та швидкість частинок як числа, а потім проходити ітерації для оновлення положення та швидкості. При кожній ітерації ми додаємо швидкість до положення (руху), а також додаємо прискорення до швидкості (зміна швидкості руху) та обчислюємо прискорення (знаходження сили на частинку). Для спрощення система не розраховує силу на кожну частинку на основі всіх інших частинок - вона лише перевіряє частинки, що знаходяться безпосередньо поруч. Був також ефект «демпфування», щоб частинки не надто прискорювались і відлітали до нескінченності (наприклад, швидкість зменшується на х відсотків на кожен крок).

Однак у процесі гольфу все це було скорочено та спрощено. Тепер замість двох однакових частинок, що відштовхуються одна від одної, вони просто "телепортуються". Різні частинки просто "забивають" шматочки, щоб запобігти застою в системі. Наприклад, якщо A поруч з A, він телепортується. Якщо A поруч із B, він лише трохи зміститься. Потім він перевіряє, чи виконуються умови (не так, як сусідні частинки) і друкує рядки в порядку, виходячи з їх положення в 1-денному просторі. Це майже більше схоже на алгоритм сортування, ніж на моделювання - тоді знову можна побачити алгоритми сортування як форму імітованого «дрейфування» на основі «маси». Я відволікаюсь.

У всякому разі, це одна з моїх перших програм «Іржа», тому я відмовився після кількох годин гри в гольф, хоча можливо ще є можливості. Біт розбору для мене важкий. Він зчитує вхідний рядок зі стандартного вводу. За бажанням це можна замінити на "нехай 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;}

Спробуйте в Інтернеті!

Це ніколи не повертається, якщо немає рішень.