Gra w Siódemki przebiega w następujący sposób: ngracze siedzą w kręgu i zaczynają liczyć od 1, przechodząc w lewo (lub od gracza Ado gracza B).

Gdy liczba, pktóra zawiera 7OR, jest podzielna, 7zostanie osiągnięty, wówczas gracz, który wypowiedział numer p-1, po tym, jak następny gracz powie p, musi powiedzieć, p+1a kolejność mówienia zmienia się. Na przykład, jeśli gracz Bmówi 6, gracz Cmówi 7, Bmówi 8, a gracz Amówi 9.

Uwaga: dla tych, którzy chcą grać w prawdziwym życiu, jeśli dana osoba zapomni liczbę (lub w wersji, w której sevensnie podano, przypadkowo mówi a seven), zostaną wyeliminowani z kręgu, ale pomijamy ten szczegół w tym wyzwaniu.

Samo wyzwanie polega na wydrukowaniu liczb, które każdy gracz powinien wypowiadać w idealnej grze Sevens, aż do wkładu mdla ngraczy wejściowych .

Jako przykład, w którym pięć osób, A, B, C, D, i Esą do gry aż dotrą 30. Grają w ten sposób

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

gdzie sevenssą oznaczone *. Pamiętaj, że w 27i 28cofamy się dwukrotnie, a gra jest kontynuowana „normalnie” od Ddo E.

Należy pamiętać, że dane wyjściowe nie muszą być w powyższym formacie. Po prostu wydrukowałem to w ten sposób dla większej przejrzystości.

Zasady

• Dane wejściowe to dwie liczby całkowite w dowolnej kolejności, mreprezentujące ostatnią liczbę do powiedzenia, nreprezentującą liczbę graczy.

• Wyjściem może być kilka tablic lub kilka ciągów, po jednym dla każdego odtwarzacza. Jeśli używasz ciągów znaków, nie musisz używać separatorów (jeśli jednak możesz dodać trochę w testach kodu, będziemy wdzięczni za czytelność). Jeśli rzeczywiście możesz wydrukować je w kółko, jest to również do przyjęcia i byłoby też całkiem fajne.

• Dane wyjściowe nie muszą określać, którzy gracze są tymi, którzy mówią (to całkiem oczywiste, że pierwszy gracz jest tym, który mówi 1), chociaż jeśli wynik nie zostanie posortowany z jakiegokolwiek powodu, należy wyjaśnić, który gracz mówi, który zestaw liczb . Pominięcie graczy, którzy nic nie mówią, jest również dozwolone, jeśli jasno określisz, którzy gracze mówią. Poniżej dodam kilka przykładów możliwych wyników.

• To jest kod golfowy, więc wygrywa najmniejsza liczba bajtów.

Jak zawsze, jeśli problem jest niejasny, daj mi znać. Powodzenia i dobrej gry w golfa!

Przykłady

>>> 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 bajtów

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

Wypróbuj online. Zestaw testowy.

Zasadniczo port mojej odpowiedzi w Pythonie; jest prawdopodobnie lepszy sposób. Pobiera na wejściu liczbę do zliczenia ni liczbę graczy pna osobnych liniach, zwraca wynik jako dwuwymiarową tablicę.

Haskell, 151 bajtów

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 bajtów

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)

Używa grafiki żółwia do drukowania w kółku, tak że liczby wypowiadane przez tego samego gracza znajdują się w tym samym promieniu. Promień koła zwiększa się, gdy kierunek jest odwrócony lub gdy sekwencja owija się wokół koła, więc poprzednie liczby nie są nadpisywane.

Przykładowe dane wyjściowe dla f(22,6)

Python 2, 103 102 101 bajtów

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

Definiuje funkcję, S(n,p)która bierze liczbę do zliczenia ni liczbę graczy pi wypisuje wynik jako tablicę ciągów.

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

Python 2, 91 90 87 bajtów

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

Drukuje listę krotek. Przetestuj na Ideone .

Galaretka , 27 25 bajtów (niekonkurujących)

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

Wypróbuj online! lub zweryfikuj wszystkie przypadki testowe .

Dyalog APL, 50 47 35 bajtów

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

Wyświetla liczby podane przez każdego gracza jako tabelę, w której w pierwszej kolumnie wymieniono graczy. Rzędy są wypełnione 0 s dla tej samej długości, a rzędy bez numerów są pomijane.

Weryfikacja

      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

Zauważ, że w ostatnim przykładzie 7 i 8 zostały pominięte, ponieważ ci gracze jeszcze nic nie powiedzieli.

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}

Dość prosta implementacja. Zwraca brzydki łańcuch glommed (możesz dodać spację, aby zrobić "#{k+=1} "... no cóż, łańcuch z odstępami). Zastanawiam się, czy istnieje jakiś algorytm matematyczny.

Współczynnik 172

Udało mi się to zrobić dłużej niż Haskell i tak czytelny jak APL! Czy dostaję ciasteczko?

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

Jest to cytat (funkcja anonimowa), który generuje cykliczną sekwencję wektorów. Każdy wektor zaczyna się od numeru gracza, a następnie liczb odpowiadających temu graczowi.

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

Zacząłem od tego:

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

co nie jest dobrym kodem czynnikowym, ale o wiele bardziej jasne (tak, używam liczb jako nazw zmiennych, nie patrz tak na mnie!).

JavaScript (ES6) 100

Zwracany wynik jako tablica ciągów, bez separatorów

(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

Lub bardziej czytelny, dla 3 bajtów więcej, zwracający wynik jako tablicę tablic

(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

Przetestuj za pomocą nowej wspaniałej funkcji konsoli Snippets stosu

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 bajtów

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

Weryfikacja

   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