セブンズのゲームは次のようにプレイされます：nプレイヤーは円に座って、1からカウントアップを開始し、左へ（またはプレイヤーからプレイヤーAへB）通過します。

数ときにp持っている7ことにORで割り切れる7達したが、その後、番号を話したプレイヤーはp-1、次のプレーヤーが言う後p、言わなければならないp+1とは逆転を話す人々のため。例えば、プレイヤーがあればB話す6、プレイヤーはC言う7、Bと言う8と、プレイヤーがA言います9。

注：実生活でプレイしたい人のために、人が数字を忘れた場合（またはsevens言われなかったバージョンで誤ってを言う場合seven）、サークルから除外されますが、この課題からこの詳細を省略します。

チャレンジ自体は、セブンの完璧なゲームで、各プレイヤーがm入力nプレイヤーへの入力までに言うべき数字を印刷することです。

5人は、一例として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で2回反転し、からDまで「通常どおり」プレイが継続することに注意してくださいE。

出力は上記の形式である必要はないことに注意してください。わかりやすくするために、そのように印刷しました。

ルール

• 入力は任意の順序の2つの整数でありm、最後に言う数をn表し、プレーヤーの数を表します。

• 出力は、プレーヤーごとに1つずつ、複数の配列または複数のストリングにすることができます。文字列を使用する場合は、区切り文字を使用する必要はありません（ただし、コードテストに文字列を追加できる場合は、読みやすくしてください）。どういうわけか実際にそれらを円で印刷できるなら、それも受け入れられます、そしてそれはかなりクールです。

• 出力は、どのプレイヤーがどのプレイヤーであるかを指定する必要はありません（最初のプレイヤーが言う人であることはかなり明らかです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別々の行のプレーヤーの数を取り、結果を2次元配列として出力します。

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が埋め込まれ、数字のない行は省略されます。

検証

      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}

非常に簡単な実装。gloいグロムされた文字列を返します（スペースを追加して、スペースを追加でき"#{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

Stack Snippetsの新しいすばらしいコンソール機能を使用してテストする

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