“ Sevens”游戏的玩法如下：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)

Python 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€

在线尝试！或验证所有测试用例。

Dyalog APL，50 47 35字节

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

这将每个玩家说的号码显示为表格，第一列列出了玩家。行用0 s 填充到相同的长度，没有数字的行被省略。

验证

      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