Гра «Сімка» грає так: nгравці сідають у коло і починають рахувати з 1, переходячи вліво (або від гравця Aдо гравця B).

Коли число, pщо має 7в ньому АБО, не ділиться на 7, тоді гравець, який говорив число p-1, після того, як сказав наступний гравець p, повинен сказати, p+1і порядок людей, що говорять, змінюється. Наприклад, якщо гравець Bговорить 6, гравець Cкаже 7, Bкаже 8, а гравець Aкаже 9.

Примітка. Для тих, хто хоче грати в реальному житті, якщо людина забуде число (або у версії, де sevensне сказано, випадково каже а seven), вони виключаються з кола, але ми опустимо цю деталь із цього виклику.

Сама задача полягає в тому, щоб надрукувати, які номери повинен сказати кожен гравець у ідеальній грі «Сімки», аж до mвведення nгравців, що вводять інформацію .

В якості прикладу, де п'ять чоловік, A, B, C, D, і E, покликані відігравати , поки вони НЕ досягають 30. Вони грають таким чином

A: 1 6 8 13    15 19       23    30
B: 2 7*  12    16 18       24
C: 3     11    17*         25
D: 4     10          21*   26 28*
E: 5      9 14*      20 22 27*29

де sevensпозначені *. Зауважте, що в 27і 28ми перевертаємось двічі, і гра продовжується "як звичайно" від Dдо E.

Зверніть увагу, що висновок не повинен бути у наведеному вище форматі. Я просто надрукував це таким чином для ясності.

Правила

• Вхід є двома цілими числами в будь-якому порядку, mпредставляючи останнє число, яке потрібно сказати, що nпредставляє кількість гравців.

• Вихід може бути декількома масивами або декількома рядками, по одному для кожного гравця. Якщо ви використовуєте рядки, вам не доведеться використовувати роздільники (хоча, якщо ви можете додати їх у свої тести коду, ми будемо вдячні для читабельності) Якщо ви можете якось надрукувати їх по колу, це теж прийнятно, і це було б дуже круто.

• Вихідні дані не повинні вказувати, хто саме гравців (це цілком очевидно, що перший гравець - це той, хто говорить 1), хоча якщо результат не відсортований з будь-якої причини, слід уточнити, який гравець говорить, який набір чисел . Випускати гравців, які нічого не говорять, також дозволяється, якщо ви даєте зрозуміти, які гравці виступають. Я додаю ще кілька прикладів можливих результатів нижче.

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

Як завжди, якщо проблема неясна, будь ласка, повідомте мене про це. Успіхів і хорошого гольфу!

Приклади

>>> sevens_string(30, 5, " ")
'1 6 8 13 15 19 23 30'
'2 7 12 16 18 24'
'3 11 17 25'
'4 10 21 26 28'
'5 9 14 20 22 27 29'
>>> sevens_string(42, 5)
'16813151923303539'
'27121618243140'
'31117253241'
'410212628333742'
'591420222729343638'
>>> sevens_array(20, 3)
[1, 4, 7, 10, 13, 15, 19]
[2, 5, 9, 12, 16, 18]
[3, 6, 8, 11, 14, 17, 20]
>>> sevens_array(18, 10)
[1, 13, 15]
[2, 12, 16, 18]
[3, 11, 17]
[4, 10]
[5, 9]
[6, 8]
[7]
[]
[]
[14]

Pyth, 38 байт

Jm[)EA,01VQa@JZ=hG=+Z=W|}\7`G!%G7H_H;J

Спробуйте в Інтернеті. Тестовий набір.

В основному порт моєї відповіді Python; є, мабуть, кращий спосіб. В якості введення приймає число, до якого слід відлічити, nта кількість гравців pна окремих рядках, виводить результат у вигляді двовимірного масиву.

Haskell, 151 байт

s n|elem '7'(show n)||mod n 7==0=(0-)|0<1=id
a=scanl1(+)$map($1)$scanl(.)id$map s[1..]
f m n=mapM_ print[[x+1|x<-[0..m-1],mod(a!!x-1)n==i]|i<-[0..n-1]]

*Main> f 30 5
[1,6,8,13,15,19,23,30]
[2,7,12,16,18,24]
[3,11,17,25]
[4,10,21,26,28]
[5,9,14,20,22,27,29]

Python 3, 155 байт

from turtle import*
def f(m,n,i=0,r=20,d=360):
 k=n
 while i<m:i+=1;fd(r);write(i);bk(r);e='7'[:i%7]in str(i);d*=1-2*e;k=~-e*(1-k)%n;r+=(k<1)*15;rt(d/n)

Для друку по колу використовується графіка черепах, щоб цифри, промовлені тим самим гравцем, знаходилися на одному радіусі. Радіус кола збільшується, коли напрямок обернено, або коли послідовність обертається навколо кола, тому попередні числа не перезаписуються.

Вибірка зразка для f(22,6)

Пітон 2, 103 102 101 байт

def S(n,p):
 P=0;D=N=1;O=['']*p
 while n:O[P%p]+=`N`;D*=1-2*(N%7<1or'7'in`N`);N+=1;P+=D;n-=1
 print O

Визначає функцію, S(n,p)яка приймає число для підрахунку nта кількість гравців pі друкує результат у вигляді масиву рядків.

>>> S(42,5)
['16813151923303539', '27121618243140', '31117253241', '410212628333742','591420222729343638']

Python 2, 91 90 87 байт

def f(m,n):a=d=i=0;r=[()]*n;exec"i+=1;r[a%n]+=i,;d^='7'[:i%7]in`i`;a+=1-2*d;"*m;print r

Друкує список кортежів. Перевірте це на Ideone .

Желе , 27 25 байт (неконкуренто)

D;Æf7e
R’Ç€^\ḤC+\_'R}⁹ḍT€

Спробуйте в Інтернеті! або перевірити всі тестові випадки .

Діалог APL, 50 47 35 байт

{,⌸⍵|+\0,¯1*+\{0=7|⍵×~7∊⍎¨⍕⍵}¨⍳⍺-1}

Це відображає числа, які кожен гравець сказав як таблицю, де в першому стовпці перераховуються гравці. Рядки прокладені по 0 с однакової довжини, а рядки без цифр опущені.

Перевірка

      f ← {,⌸⍵|+\0,¯1*+\{0=7|⍵×~7∊⍎¨⍕⍵}¨⍳⍺-1}
      30 f 5
0 1  6  8 13 15 19 23 30
1 2  7 12 16 18 24  0  0
2 3 11 17 25  0  0  0  0
3 4 10 21 26 28  0  0  0
4 5  9 14 20 22 27 29  0
      42 f 5
0 1  6  8 13 15 19 23 30 35 39
1 2  7 12 16 18 24 31 40  0  0
2 3 11 17 25 32 41  0  0  0  0
3 4 10 21 26 28 33 37 42  0  0
4 5  9 14 20 22 27 29 34 36 38
      20 f 3
0 1 4 7 10 13 15 19
1 2 5 9 12 16 18  0
2 3 6 8 11 14 17 20
      14 f 10
0  1 13
1  2 12
2  3 11
3  4 10
4  5  9
5  6  8
6  7  0
9 14  0

Зауважте, що в останньому прикладі 7 та 8 опущені, оскільки ці гравці ще нічого не сказали.

Рубі, 81

->n,m{g=[""]*n
k=j=0
i=1
m.times{g[j%n]+=w="#{k+=1}"
j+=i=k%7<1||w[/7/]?-i :i}
g}

Досить просто реалізація. Повертає некрасиву глянцеву рядок (ви можете додати пробіл, щоб зробити його "#{k+=1} "для ... ну, пробілом ). Цікаво, чи є там більше математичний алгоритм.

Фактор 172

Мені вдалося зробити це довше, ніж Haskell, і настільки читабельним, як APL! Я можу отримати печиво?

[| l! n! | 1 0 0 :> ( p! x! z! ) n iota [ 1vector ] map <circular> n! l iota [ 1 + z! z 7 mod 0 = 55 z 10 >base in? or -1 and 1 or p * p! z x n nth push x p + x! ] each n ]

Це цитата (анонімна функція), яка виводить кругову послідовність векторів. Кожен вектор починається з кількості гравців, а потім з цифр, які відповідають цьому гравцю.

30 5 [| l! n! | 1 0 0 :> ( p! x! z! ) n iota [ 1vector ] map <circular> n! l iota [ 1 + z! z 7 mod 0 = 55 z 10 >base in? or -1 and 1 or p * p! z x n nth push x p + x! ] each n ] call

Outputs:
T{ circular
    { seq
        {
            V{ 0 1 6 8 13 15 19 23 30 }
            V{ 1 2 7 12 16 18 24 }
            V{ 2 3 11 17 25 }
            V{ 3 4 10 21 26 28 }
            V{ 4 5 9 14 20 22 27 29 }
        }      ^ Note: first val is player number starting at 0
    }
}

Я почав з цього:

: game-of-7 ( last-num num-players -- {players:={numbers}} )
  1 1 set ! increment
  0 2 set ! current-index
  iota [ drop V{ } clone ] map <circular>
  swap iota
  [ 1 + ! iotas go 0 to n-1
    dup [ 7 mod 0 = ] [ 10 >base 55 swap in? ] bi or
    [ 1 get -1 * 1 set ] when
    over 2 get swap nth push
    2 get 1 get + 2 set
  ] each ;

що не є хорошим факторним кодом, але набагато зрозуміліше (так, я використовую номери як імена змінних там, не дивіться на мене так!).

JavaScript (ES6) 100

Результат, що повертається у вигляді рядкового масиву, без роздільників

(m,n)=>(d=>{for(r=[],p=i=0;i++<m;d=i%7&&!~(i+'').search(7)?d:n-d,p=(p+d)%n)r[p]=(r[p]||'')+i})(1)||r

Або більш читабельний, на 3 байти більше, повертаючий результат у вигляді масиву масивів

(m,n)=>(d=>{for(r=[],p=i=0;i++<m;d=i%7&&!~(i+'').search(7)?d:n-d,p=(p+d)%n)r[p]=[...r[p]||[],i]})(1)||r

Тест Використання нової чудової консольної функції фрагментів стека

S=(m,n)=>(d=>{for(r=[],p=i=0;i++<m;d=i%7&&!~(i+'').search(7)?d:n-d,p=(p+d)%n)r[p]=(r[p]||'')+i})(1)||r

A=(m,n)=>(d=>{for(r=[],p=i=0;i++<m;d=i%7&&!~(i+'').search(7)?d:n-d,p=(p+d)%n)r[p]=[...r[p]||[],i]})(1)||r

console.log(S(42,5))
console.log(A(20,3))

J, 63 60 59 58 56 байт

4 :'>:@I.(i.y)=/y|+/\0,_1^+/\(7 e."1 q:,.10#.inv])}.i.x'

Перевірка

   f =: 4 :'>:@I.(i.y)=/y|+/\0,_1^+/\(7 e."1 q:,.10#.inv])}.i.x'
   30 f 5
1  6  8 13 15 19 23 30
2  7 12 16 18 24  0  0
3 11 17 25  0  0  0  0
4 10 21 26 28  0  0  0
5  9 14 20 22 27 29  0
   42 f 5
1  6  8 13 15 19 23 30 35 39
2  7 12 16 18 24 31 40  0  0
3 11 17 25 32 41  0  0  0  0
4 10 21 26 28 33 37 42  0  0
5  9 14 20 22 27 29 34 36 38
   20 f 3
1 4 7 10 13 15 19
2 5 9 12 16 18  0
3 6 8 11 14 17 20
   14 f 10
 1 13
 2 12
 3 11
 4 10
 5  9
 6  8
 7  0
 0  0
 0  0
14  0