El juego de Sevens se juega de la siguiente manera: los njugadores se sientan en círculo y comienzan a contar desde 1, pasando a la izquierda (o de jugador Aa jugador B).

Cuando se alcanza un número pque tiene un 7OR dentro del cual es divisible 7, entonces el jugador que pronunció el número p-1, después del siguiente jugador dice p, debe decir p+1y el orden de las personas que hablan se invierte. Por ejemplo, si el jugador Bhabla 6, el jugador Cdice 7, Bdice 8y el jugador Adice 9.

Nota: Para aquellos que quieren jugar en la vida real, si una persona olvida un número (o en la versión donde sevensno se dice, accidentalmente dice a seven), se elimina del círculo, pero omitiremos este detalle de este desafío.

El desafío en sí mismo es imprimir qué números debe decir cada jugador en un juego perfecto de Sevens hasta una entrada mpara un njugador de entrada .

A modo de ejemplo, donde cinco personas, A, B, C, D, y E, son para jugar hasta que lleguen 30. Ellos juegan de esta manera

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

donde sevensestán marcados con *. Tenga en cuenta que en 27y 28, estamos retrocediendo dos veces, y el juego continúa "normalmente" de Da E.

Tenga en cuenta que la salida no tiene que estar en el formato anterior. Simplemente lo imprimí de esa manera para mayor claridad.

Reglas

• La entrada es de dos enteros en cualquier orden, mrepresentando el último número para decir, nrepresentando el número de jugadores.

• La salida puede ser varias matrices o varias cadenas, una para cada jugador. Si usa cadenas, no tiene que usar separadores (sin embargo, si pudiera agregar algunos en sus pruebas de código, agradeceríamos la legibilidad). Si realmente puede imprimirlos en un círculo de alguna manera, eso también es aceptable, y también sería genial.

• La salida no tiene que designar qué jugadores son cuáles (es bastante obvio que el primer jugador es el que dice 1), aunque si la salida no está ordenada por alguna razón, debe dejar en claro qué jugador está hablando qué conjunto de números . Omitir jugadores que no dicen nada también está permitido si dejas en claro qué jugadores están hablando. Agregaré algunos ejemplos más de posibles resultados a continuación.

• Este es el código de golf, por lo que gana el menor número de bytes.

Como siempre, si el problema no está claro, hágamelo saber. ¡Buena suerte y buen golf!

Ejemplos

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

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

Pruébalo en línea. Banco de pruebas.

Básicamente un puerto de mi respuesta Python; Probablemente hay una mejor manera. Toma como entrada el número para contar ny el número de jugadores pen líneas separadas, emite el resultado como una 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 tortuga para imprimir en un círculo, de modo que los números pronunciados por el mismo jugador estén en el mismo radio. El radio del círculo aumenta cuando se invierte la dirección, o cuando la secuencia se envuelve alrededor del círculo, por lo que los números anteriores no se sobrescriben.

Salida de muestra 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 una función S(n,p)que toma el número para contar ny el número de jugadores pe imprime el resultado como un conjunto de cadenas.

>>> 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 una lista de tuplas. Pruébelo en Ideone .

Jalea , 27 25 bytes (no competitiva)

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

Pruébalo en línea! o verificar todos los casos de prueba .

Dyalog APL, 50 47 35 bytes

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

Esto muestra los números que cada jugador dijo como una tabla, donde la primera columna enumera a los jugadores. Las filas se rellenan con 0 s de la misma longitud y se omiten las filas sin números.

Verificación

      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

Tenga en cuenta que, en el último ejemplo, se omiten 7 y 8 ya que esos jugadores aún no han dicho nada.

Rubí, 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}

Implementación bastante sencilla. Devuelve una cadena engominada fea (puede agregar un espacio para que sea "#{k+=1} "... bueno, una cadena espaciada). Me pregunto si hay un algoritmo más matemático por ahí.

Factor 172

¡Logré hacerlo más tiempo que Haskell, y tan legible como APL! ¿Me dan una galleta?

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

Es una cita (función anónima) que genera una secuencia circular de vectores. Cada vector comienza con el número de jugador y luego los números que corresponden a ese jugador.

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

Empecé con esto:

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

lo cual no es un buen código factorial, pero mucho más claro (sí, estoy usando números como nombres de variables allí, ¡no me mires así!).

JavaScript (ES6) 100

Devuelve el resultado como una matriz de cadenas, sin 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

O más legible, por 3 bytes más, devolviendo el resultado como una matriz de matrices

(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

Prueba con la nueva y maravillosa función de consola de los fragmentos de pila

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'

Verificación

   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