O jogo de Sevens é jogado da seguinte forma: os njogadores sentam em círculo e começam a contar a partir de 1, passando para a esquerda (ou de jogador Apara jogador B).

Quando um número pque tem um 7OU é divisível por, 7é atingido, o jogador que falou o número p-1, depois que o próximo jogador diz p, deve dizer p+1e a ordem das pessoas que fala está invertida. Por exemplo, se o jogador Bfala 6, o jogador Cdiz 7, Bdiz 8e o jogador Adiz 9.

Nota: Para aqueles que querem jogar na vida real, se uma pessoa esquecer um número (ou na versão em que sevensnão se diz, acidentalmente diz a seven), eles serão eliminados do círculo, mas omitiremos esse detalhe desse desafio.

O desafio em si é imprimir quais números cada jogador deve dizer em um jogo perfeito de Sevens até uma entrada mpara njogadores de entrada .

Como um exemplo, onde cinco pessoas, A, B, C, D, e E, se jogar até chegarem 30. Eles jogam dessa maneira

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

onde sevensestão marcados com *. Observe que em 27e 28, estamos invertendo duas vezes, e o jogo continua "normalmente" de Dpara E.

Observe que a saída não precisa estar no formato acima. Simplesmente imprimi dessa maneira para ter mais clareza.

Regras

• A entrada é dois números inteiros em qualquer ordem, mrepresentando o último número a dizer, nrepresentando o número de jogadores.

• A saída pode ser de várias matrizes ou várias strings, uma para cada jogador. Se você usa strings, não precisa usar separadores (no entanto, se você puder adicionar alguns em seus testes de código, agradecemos a legibilidade). Se você realmente puder imprimi-los em um círculo de alguma forma, isso também é aceitável e seria muito legal também.

• A saída não precisa designar quais jogadores são (é óbvio que o primeiro jogador é quem diz 1), embora se a saída não for classificada por qualquer motivo, você deve deixar claro qual jogador está falando qual conjunto de números . Omitir jogadores que não dizem nada também é permitido se você deixar claro quais jogadores estão falando. Vou adicionar mais alguns exemplos de possíveis resultados abaixo.

• Esse é o código golf, portanto o menor número de bytes vence.

Como sempre, se o problema não estiver claro, entre em contato. Boa sorte e bom golfe!

Exemplos

>>> 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]

Pitão, 38 bytes

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

Experimente online. Suíte de teste.

Basicamente, uma porta da minha resposta Python; provavelmente há uma maneira melhor. Toma como entrada o número a contar ne o número de jogadores pem linhas separadas, produz o resultado como uma matriz bidimensional.

Haskell, 151 bytes

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 bytes

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)

Utiliza gráficos de tartaruga para imprimir em círculo, de modo que os números falados pelo mesmo reprodutor estejam no mesmo raio. O raio do círculo aumenta quando a direção é invertida ou quando a sequência envolve o círculo, para que os números anteriores não sejam substituídos.

Saída de amostra para f(22,6)

Python 2, 103 102 101 bytes

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

Define uma função S(n,p)que leva o número para contar ne o número de jogadores pe imprime o resultado como uma matriz de seqüências de caracteres.

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

Python 2, 91 90 87 bytes

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

Imprime uma lista de tuplas. Teste em Ideone .

Gelatina , 27 25 bytes (não concorrente)

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

Experimente online! ou verifique todos os casos de teste .

Dyalog APL, 50 47 35 bytes

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

Isso exibe os números que cada jogador disse como uma tabela, onde a primeira coluna enumera os jogadores. As linhas são preenchidas com 0 s no mesmo comprimento e as linhas sem números são omitidas.

Verificação

      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

Observe que, no último exemplo, 7 e 8 são omitidos, pois esses jogadores ainda não disseram nada.

Ruby, 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}

Implementação bastante direta. Retorna uma seqüência feia de glommed (você pode adicionar um espaço para torná-la "#{k+=1} "... bem, uma sequência espaçada). Gostaria de saber se existe algum algoritmo matemático por aí.

Fator 172

Consegui fazer isso por mais tempo que Haskell e tão legível quanto a APL! Eu recebo um biscoito?

[| 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 ]

É uma cotação (função anônima) que gera uma sequência circular de vetores. Cada vetor começa com o número de jogador e, em seguida, os números que correspondem a esse jogador.

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

Comecei com isso:

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

que não é um bom código de fator, mas muito mais claro (sim, estou usando números como nomes de variáveis ​​lá, não me olhe assim!).

JavaScript (ES6) 100

Retornando resultado como uma matriz de strings, sem separadores

(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

Ou mais legível, por mais 3 bytes, retornando resultado como uma matriz de matrizes

(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

Teste usando o novo recurso maravilhoso de console dos Snippets de pilha

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 bytes

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

Verificação

   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