세븐 즈 게임은 다음과 같이 진행됩니다. n플레이어는 원 안에 앉아 1부터 카운트 업을 시작하여 왼쪽으로 (또는 플레이어 A에서 플레이어로) 시작합니다.B ) 시작합니다.

안에있는 숫자 가 나눌 수 있는 숫자 p에 도달하면, 다음 플레이어가 말한 후에 숫자를 말한 플레이어는 말 을해야 하고 사람들의 말 순서가 반대로됩니다. 예를 들어, 플레이어가 있다면 말 , 플레이어는 말한다 , 라고 , 그리고 플레이어는 말한다 .77p-1pp+1B6C7B8A9

참고 : 실생활에서 게임을하고 싶은 사람은 숫자를 잊어 버린 경우 (또는 sevens언급되지 않은 버전에서 실수로seven ) 서클에서 제거되지만이 도전에서이 세부 사항을 생략합니다.

도전 자체는 입력 m에 대한 입력 까지 각 플레이어가 7의 완벽한 게임에서 말해야 할 숫자를 인쇄하는 것입니다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표시되어 *있습니다. at 27및 28에서 Google은 두 번 후진하며 게임은 "정상"에서에서 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

온라인으로 사용해보십시오. 테스트 스위트.

기본적으로 내 파이썬 답변의 포트; 아마도 더 좋은 방법이있을 것입니다. 계산할 수 n와 p별도의 줄 에있는 플레이어 수를 입력으로 받아 결과를 2 차원 배열로 출력합니다.

하스켈, 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]

파이썬 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']

파이썬 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}

매우 간단한 구현입니다. 못생긴 문자열을 반환합니다 (공간을 추가 "#{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 ;

이것은 좋은 요소 코드는 아니지만 훨씬 더 명확합니다 (예, 변수 이름으로 숫자를 사용하고 있습니다. 그렇게 보지 마십시오!).

자바 스크립트 (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