La partita di Sevens si gioca come segue: i ngiocatori si siedono in cerchio e iniziano a contare da 1, passando a sinistra (o da giocatore Aa giocatore B).

Quando viene raggiunto un numero pche ha un 7OR o divisibile per, 7viene raggiunto il giocatore che ha pronunciato il numero p-1, dopo il giocatore successivo p, p+1e l'ordine delle persone che parlano si inverte. Ad esempio, se il giocatore Bparla 6, il giocatore Cdice 7, Bdice 8e il giocatore Adice 9.

Nota: per coloro che vogliono giocare nella vita reale, se una persona dimentica un numero (o nella versione in cui sevensnon viene detto, dice accidentalmente a seven), vengono eliminati dal cerchio, ma ometteremo questo dettaglio da questa sfida.

La sfida stessa è quella di stampare i numeri che ogni giocatore dovrebbe dire in un gioco perfetto di Sevens fino a un input mper un ngiocatore di input .

A titolo di esempio, in cui cinque persone, A, B, C, D, e E, sono a giocare fino a raggiungere 30. Suonano in questo modo

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

dove sevenssono contrassegnati con *. Nota che su 27e 28, stiamo invertendo due volte, e il gioco continua "normalmente" da Da E.

Si noti che l'output non deve essere nel formato sopra. L'ho semplicemente stampato in questo modo per un po 'di chiarezza.

Regole

• L'input è di due numeri interi in qualsiasi ordine, che mrappresenta l'ultimo numero da dire, che nrappresenta il numero di giocatori.

• L'output può essere costituito da più array o più stringhe, una per ciascun giocatore. Se si utilizzano stringhe, non è necessario utilizzare separatori (tuttavia, se è possibile aggiungerne alcuni nei test del codice, apprezzeremmo la leggibilità). Se riesci effettivamente a stamparli in un cerchio in qualche modo, anche questo è accettabile, e sarebbe anche abbastanza bello.

• L'output non deve indicare quali giocatori sono quali (è abbastanza ovvio che il primo giocatore è quello che dice 1), anche se se l'output non è ordinato per qualsiasi motivo, dovresti chiarire quale giocatore sta parlando quale set di numeri . Omettere giocatori che non dicono nulla è consentito anche se si chiarisce quali giocatori stanno parlando. Aggiungerò altri esempi di possibili uscite di seguito.

• Questo è il codice golf, quindi vince il minor numero di byte.

Come sempre, se il problema non è chiaro, per favore fatemi sapere. Buona fortuna e buon golf!

Esempi

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

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

Provalo online. Suite di test.

Fondamentalmente una porta della mia risposta Python; c'è probabilmente un modo migliore. Prende come input il numero da contare ne il numero di giocatori psu linee separate, genera il risultato come un array bidimensionale.

Haskell, 151 byte

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 byte

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)

Usa la grafica della tartaruga per stampare in un cerchio in modo tale che i numeri pronunciati dallo stesso lettore siano sullo stesso raggio. Il raggio del cerchio aumenta quando la direzione viene invertita o quando la sequenza si avvolge attorno al cerchio, quindi i numeri precedenti non vengono sovrascritti.

Uscita di esempio per f(22,6)

Python 2, 103 102 101 byte

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

Definisce una funzione S(n,p)che accetta il numero da contare ne il numero di giocatori pe stampa il risultato come una matrice di stringhe.

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

Python 2, 91 90 87 byte

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

Stampa un elenco di tuple. Provalo su Ideone .

Gelatina , 27 25 byte (non competitiva)

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

Provalo online! o verifica tutti i casi di test .

Dyalog APL, 50 47 35 byte

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

Questo mostra i numeri che ogni giocatore ha detto come un tavolo, dove la prima colonna elenca i giocatori. Le righe sono riempite con 0 s della stessa lunghezza e le righe senza numeri sono omesse.

Verifica

      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

Nota che, nell'ultimo esempio, 7 e 8 sono stati omessi poiché quei giocatori non hanno ancora detto nulla.

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

Implementazione piuttosto semplice. Restituisce una brutta stringa glommed (puoi aggiungere uno spazio per farlo "#{k+=1} "per ... beh, una stringa spaziata). Mi chiedo se ci sia un algoritmo più matematico là fuori.

Fattore 172

Sono riuscito a farlo più a lungo di Haskell e leggibile come APL! Ricevo un biscotto?

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

È una citazione (funzione anonima) che genera una sequenza circolare di vettori. Ogni vettore inizia con il numero di giocatore, quindi i numeri che corrispondono a quel giocatore.

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

Ho iniziato con questo:

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

che non è un buon codice fattore, ma molto più chiaro (sì, sto usando numeri come nomi di variabili lì, non guardarmi così!).

JavaScript (ES6) 100

Restituisce il risultato come una matrice di stringhe, senza separatori

(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 più leggibile, per 3 byte in più, restituendo il risultato come una matrice di array

(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

Prova usando la nuova meravigliosa funzionalità console degli Stack Snippet

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 byte

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

Verifica

   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