Le jeu de Sevens se joue comme suit: les njoueurs s'assoient en cercle, et commencent à compter à partir de 1, en passant à gauche (ou de joueur Aà joueur B).

Lorsqu'un nombre pqui contient un 7OU est divisible par 7est atteint, alors le joueur qui a prononcé le nombre p-1, après que le joueur suivant a dit p, doit dire p+1et l'ordre des personnes qui parlent s'inverse. Par exemple, si le joueur Bparle 6, le joueur Cdit 7, Bdit 8et le joueur Adit 9.

Remarque: Pour ceux qui veulent jouer dans la vraie vie, si une personne oublie un numéro (ou dans la version où sevensne sont pas dit, dit accidentellement seven), ils sont éliminés du cercle, mais nous allons omettre ce détail de ce défi.

Le défi lui-même est d'imprimer les nombres que chaque joueur devrait dire dans un jeu parfait de Sevens jusqu'à une entrée m pour une entrée des njoueurs.

À titre d'exemple, où cinq personnes, A, B, C, Det E, sont appelés à jouer jusqu'à ce qu'ils atteignent30 . Ils jouent de cette manière

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

où sevenssont marqués *. Notez que à 27et 28, nous inversons deux fois, et le jeu continue "comme d'habitude" de Dà E.

Veuillez noter que la sortie ne doit pas nécessairement être au format ci-dessus. Je l'ai simplement imprimé de cette façon pour plus de clarté.

Règles

• L'entrée est deux entiers dans n'importe quel ordre, mreprésentant le dernier nombre à dire, nreprésentant le nombre de joueurs.

• La sortie peut être plusieurs tableaux ou plusieurs chaînes, une pour chaque joueur. Si vous utilisez des chaînes, vous n'avez pas besoin d'utiliser de séparateurs (cependant, si vous pouviez en ajouter dans vos tests de code, nous apprécierions la lisibilité). Si vous pouvez les imprimer dans un cercle d'une manière ou d'une autre, cela est également acceptable, et ce serait plutôt cool aussi.

• La sortie n'a pas à désigner quels joueurs sont lesquels (il est assez évident que le premier joueur est celui qui dit 1 ), bien que si la sortie n'est pas triée pour une raison quelconque, vous devez préciser quel joueur parle quel ensemble de nombres . L'omission de joueurs qui ne disent rien est également autorisée si vous précisez quels joueurs parlent. J'ajouterai plus d'exemples de sorties possibles ci-dessous.

• C'est le golf de code, donc le plus petit nombre d'octets gagne.

Comme toujours, si le problème n'est pas clair, faites-le moi savoir. Bonne chance et bon golf!

Exemples

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

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

Essayez-le en ligne. Suite de tests.

Fondamentalement, un port de ma réponse Python; il y a probablement une meilleure façon. Prend en entrée le nombre à compter net le nombre de joueurs psur des lignes distinctes, produit le résultat sous forme de tableau à deux dimensions.

Haskell, 151 octets

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 octets

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)

Utilise des graphiques de tortues pour imprimer dans un cercle de telle sorte que les nombres prononcés par le même joueur soient dans le même rayon. Le rayon du cercle est augmenté lorsque la direction est inversée ou lorsque la séquence s'enroule autour du cercle, de sorte que les numéros précédents ne sont pas remplacés.

Exemple de sortie pour f(22,6)

Python 2, 103 102 101 101 octets

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

Définit une fonction S(n,p)qui prend le nombre à compter net le nombre de joueurs pet imprime le résultat sous la forme d'un tableau de chaînes.

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

Python 2, 91 90 87 octets

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 une liste de tuples. Testez-le sur Ideone .

Gelée , 27 25 octets (non concurrent)

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

Essayez-le en ligne! ou vérifiez tous les cas de test .

Dyalog APL, 50 47 35 octets

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

Cela affiche les nombres que chaque joueur a dit sous forme de tableau, où la première colonne énumère les joueurs. Les lignes sont remplies de 0 s à la même longueur et les lignes sans chiffres sont omises.

Vérification

      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

Notez que, dans le dernier exemple, 7 et 8 sont omis car ces joueurs n'ont encore rien dit.

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

Implémentation assez simple. Renvoie une chaîne glommed laide (vous pouvez ajouter un espace pour le faire "#{k+=1} "pour ... eh bien, une chaîne espacée). Je me demande s'il y a un algorithme plus mathématique.

Facteur 172

J'ai réussi à le faire plus longtemps que Haskell, et aussi lisible qu'APL! Est-ce que je reçois un cookie?

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

C'est une citation (fonction anonyme) qui produit une séquence circulaire de vecteurs. Chaque vecteur commence par le nombre de joueurs, puis les nombres qui correspondent à ce joueur.

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

J'ai commencé avec ceci:

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

ce qui n'est pas un bon code factoriel, mais beaucoup plus clair (oui, j'utilise des nombres comme noms de variables là-bas, ne me regardez pas comme ça!).

JavaScript (ES6) 100

Retour du résultat sous forme de tableau de chaînes, pas de séparateurs

(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 plus lisible, pour 3 octets de plus, renvoyant le résultat sous forme de tableau de tableaux

(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

Test à l' aide de la nouvelle fonctionnalité de console merveilleuse des extraits de pile

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 octets

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

Vérification

   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