Болгарський пасьянс - це одиночна гра, яку зробив популярний Мартин Гарднер у своїй математичній колонці в Scientific American .

У вас Nоднакові картки, розбиті на палі. Ви берете картку з кожної купи і формуєте нову купу зі знятими картками. Ви повторюєте цей процес, поки не досягнете стану, який ви вже бачили, і таким чином, продовжуючи, буде повторюватися цикл.

Наприклад, скажімо, у вас є 8картки, розділені на купу 5і купу 3. Пишемо розміри купи в порядку убування: 5 3. Ось стенограма гри:

5 3
4 2 2
3 3 1 1 
4 2 2

Ви спочатку виймаєте карту з кожної з двох паль, залишаючи палі 4і 2, і новостворену купу 2, віддаючи 4 2 2. На наступному кроці слід зменшити ці зміни 3 1 1з новою купою 3. Нарешті, останній крок опорожнює палі розміром 1і виробляє, 4 2 2які вже з’явилися, тому ми зупиняємось.

Зауважте, що сума розмірів ворсу залишається однаковою.

Ваша мета - роздрукувати таку стенограму гри із заданої стартової конфігурації. Це кодовий гольф, тому виграє найменше байтів.

Вхідні дані

Список позитивних чисел у порядку зменшення, що представляють початкові розміри палі. Візьміть вхід через STDIN або функціональний вхід. Ви можете використовувати будь-яку структуру, схожу на список, яку хочете.

Ви не отримуєте загальну кількість карток Nяк вхід.

Вихідні дані

Роздрукуйте послідовність розмірів ворсів, через які проходить гра в болгарський пасьянс. Зверніть увагу, що друк необхідний, а не повернення. Кожен крок повинен бути власною лінією.

Кожен рядок повинен мати послідовність додатних чисел у порядку зменшення без 0позначень. Можливо, у вас є роздільники, маркери початку та кінця (наприклад, [3, 3, 1, 1]). Числа можуть мати кілька цифр, тому їх слід якось розділити.

Роздрукуйте розрізи розміру ворсу, які ви бачите, до тих пір, поки не включите повторення. Отже, перший рядок повинен бути вхідним, а останній - повторенням попереднього рядка. Інших повторів не повинно бути.

Тестові справи

>> [1]
1
1

>> [2]
2
1 1
2

>> [1, 1, 1, 1, 1, 1, 1]
1 1 1 1 1 1 1
7
6 1
5 2
4 2 1
3 3 1
3 2 2
3 2 1 1
4 2 1

>> [5, 3]
5 3
4 2 2
3 3 1 1
4 2 2

>> [3, 2, 1]
3 2 1
3 2 1

>> [4, 4, 3, 2, 1]
4 4 3 2 1
5 3 3 2 1
5 4 2 2 1
5 4 3 1 1
5 4 3 2
4 4 3 2 1

Піта, 40 25

QW!}QY~Y]Q=Q_S+fTmtdQ]lQQ

Це досить близько до перекладу моєї відповіді python 2.

Проба зразка:

Вхід:

[4,4,3,2,1]

Вихід:

[4, 4, 3, 2, 1]
[5, 3, 3, 2, 1]
[5, 4, 2, 2, 1]
[5, 4, 3, 1, 1]
[5, 4, 3, 2]
[4, 4, 3, 2, 1]

Як це працює:

Q                          Q = eval(input()) # automatic
 W!}QY                     while not Q in Y:
      ~Y]Q                     Y += [Q]
               fTmtdQ                     filter(lambda T: T, map(lambda d: d - 1, Q))
            _S+      ]lQ           sorted(                                             + [len(Q)])[::-1]
          =Q_S+fTmtdQ]lQ       Q = sorted(filter(lambda T: T, map(lambda d: d - 1, Q)) + [len(Q)])[::-1]
                        Q      print(Q)
QW!}QY~Y]Q=Q_S+fTmtdQ]lQQ

CJam, 26 байт

q{~_:(_,+0-$W%]___&=}g{p}/

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

Приклад виконання

$ cjam <(echo 'q{~_:(_,+0-$W%]___&=}g{p}/') <<< '[5 3]'
[5 3]
[4 2 2]
[3 3 1 1]
[4 2 2]

Рубі, 98

f=->c{g={c=>1}
p *loop{c=(c.map(&:pred)<<c.size).sort.reverse-[0]
g[c]?(break g.keys<<c): g[c]=1}}

Пояснення

• Введення вважається аргументами лямбда. Він очікує Array.
• Попередні стани гри зберігаються у Hash g.
• Щоб створити новий стан гри, використовуйте Array#mapдля зменшення кожного елемента на 1, додайте довжину Arrayяк елемент, сортуйте його у порядку зменшення та видаліть елемент 0.
• Щоб перевірити, чи не спостерігалось стан гри раніше, gдостатньо перевірити, чи є ключ для нового стану гри.

CJam, 35 34 33 байт

(Чорт, цей перерив живлення, що я не був першим, хто опублікував у CJam)

l~{_p:(_,+{},$W%_`_S\#0<\S+:S;}g`

Вхід:

[1 1 1 1 1 1 1]

Вихід:

[1 1 1 1 1 1 1]
[7]
[6 1]
[5 2]
[4 2 1]
[3 3 1]
[3 2 2]
[3 2 1 1]
[4 2 1]

Спробуйте його онлайн тут

Пітон 2 - 103

p=input()
m=[]
print p
while p not in m:m+=[p];p=sorted([x-1 for x in p if x>1]+[len(p)])[::-1];print p

Схожий на відповідь Quincunx, але замінює додаток додаванням та видаляє останні два рядки.

Вибірка зразка:

[4, 4, 3, 2, 1]
[5, 3, 3, 2, 1]
[5, 4, 2, 2, 1]
[5, 4, 3, 1, 1]
[5, 4, 3, 2]
[4, 4, 3, 2, 1]

GolfScript, 50 46

~.p$[]{[1$]+\.{(.!";"*~}%\,+$.-1%p\.2$?)!}do];

Майже напевно можна пограти в гольф далі. Спробуйте це тут.

Хаскелл, 99

import Data.List
g l=until(nub>>=(/=))(\l->l++[reverse$sort$length(last l):[x-1|x<-last l,x>1]])[l]

CJam, 40 36 34 байт

]l~{a+_W=_p:(_,+$W%{},1$1$a#0<}gp;

Тестуйте це тут. Введіть введення як масив у стилі CJam, як-от [5 3], у поле STDIN. Формат виводу схожий, тому квадратні дужки та пробіли як роздільники.

Навіть якщо я буду гольфувати це далі (що, безумовно, можливо), немає ніякого способу перемогти Pyth цим. Можливо, саме час дізнатися Дж. Пояснення, що надходять пізніше.

JavaScript (E6) 113

Найгірший запис поки що :(

F=l=>{
  for(k=[];console.log(l),!k[l];)
    k[l]=l=[...l.map(n=>(p+=n>1,n-1),p=1),l.length].sort((a,b)=>b-a).slice(0,p)
}

Тест в консолі FireFox / FireBug

F([4,4,3,2,1])

Вихідні дані

[4, 4, 3, 2, 1]
[5, 3, 3, 2, 1]
[5, 4, 2, 2, 1]
[5, 4, 3, 1, 1]
[5, 4, 3, 2]
[4, 4, 3, 2, 1]

Пітон 2, 148 130 101

l=input()
s=[]
print l
while l not in s:s+=l,;l=sorted([i-1for i in l if 1<i]+[len(l)])[::-1];print l

Це просто запам'ятовує всі попередні ітерації та перевіряє, чи є нова в цьому списку. Потім він роздруковує його.

Проба зразка:

Вхід:

[4,4,3,2,1]

Вихід:

[4, 4, 3, 2, 1]
[5, 3, 3, 2, 1]
[5, 4, 2, 2, 1]
[5, 4, 3, 1, 1]
[5, 4, 3, 2]
[4, 4, 3, 2, 1]

Редагувати: я перечитав характеристики гольфу, а також застосував багато гольфу.

Пітон 3: 89 символів

g=lambda l,s=[]:print(l)!=l in s or g(sorted([x-1for x in l if~-x]+[len(l)])[::-1],s+[l])

Так само, як і вже розміщені рішення Python, але з рекурсивними викликами функцій, а не циклічними. У списку sзберігаються вже відомі розщеплення, а у разі повторення відбувається коротке замикання на рекурсію.

Функцію print()(це Python 3) просто потрібно якось викликати у кожному циклі. Найскладніша річ у тому, що a lambdaдопускає лише один вираз, тому ми не можемо це зробити print(l);.... Крім того, він виводить None, з чим важко працювати. Я закінчую ставити print(l)на один бік нерівності; ==чомусь не працює, я не розумію.

Альтернативний підхід до закріплення його у списку використовує однаково багато символів.

g=lambda l,s=[]:l in s+[print(l)]or g(sorted([x-1for x in l if~-x]+[len(l)])[::-1],s+[l])

Використання print(*l)буде форматувати результати, як, 4 2 2а не [4,2,2].