Sevens oyunu şu şekilde oynanır: noyuncular bir daire içinde oturur ve soldan (veya oyuncudan Aoyuncuya B) geçen 1'den saymaya başlar .

Bir numara ne zaman pbir sahip 7o VEYA ile bölünebilir 7ulaşıldığında, ardından numarayı konuştu oyuncu p-1, sonraki oyuncu diyor sonra psöylemeliyim p+1ve bota konuşan insanların sırası. Örneğin, oyuncu Bkonuşursa 6, oyuncu Cdiyor 7, Bdiyor 8ve oyuncu Adiyor 9.

Not: Gerçek hayatta oynamak isteyenler için, eğer bir kişi bir sayıyı unutursa (veya sevenssöylenmeyen versiyonda , yanlışlıkla a der seven), çemberden çıkarılır, ancak bu detayı bu zorluktan çıkarırız.

Zorluk, her bir oyuncunun, Sevens'in mükemmel bir oyununda mbir girdi noyuncuları için bir girdiye kadar hangi sayıları söylemesi gerektiğidir .

Beş kişi, bir örnek olarak A, B, C, D, ve Eonlar ulaşana kadar oynamak için vardır 30. Bu şekilde oynarlar

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

nerede sevensile işaretlenmiştir *. Not o 27ve 28biz iki kez geri vites konum ve oyun dan "normal olarak" devam Detmek E.

Çıktının yukarıdaki biçimde olması gerekmediğini lütfen unutmayın. Sadece netlik için bu şekilde yazdırdım.

kurallar

• Girdi, herhangi bir sırada iki tamsayıdır ve msöylenecek son sayıyı ntemsil eder, oyuncu sayısını temsil eder.

• Çıktı, her oyuncu için bir tane olmak üzere birkaç dizi veya dizge olabilir. Dizeler kullanırsanız, ayırıcılar kullanmanız gerekmez (yine de, kod testlerinize bazılarını ekleyebiliyorsanız, okunabilirliği takdir ederiz). Onları bir şekilde bir daireye yazdırabiliyorsanız, bu da kabul edilebilir ve çok güzel olurdu.

• Çıktının hangi oyuncuların hangisi olduğunu belirtmesi gerekmez (ilk oyuncunun söylediği kişi oldukça açıktır 1), ancak çıktı herhangi bir nedenle sıralanmamışsa, hangi oyuncunun hangi sayı kümesini konuştuğunu netleştirmelisiniz. . Hangi oyuncuların konuştuğunu netleştirirseniz, hiçbir şey söylemeyen oyuncuların çıkarılmasına da izin verilir. Aşağıda olası çıktılara birkaç örnek daha ekleyeceğim.

• Bu kod golf, bu yüzden en az bayt sayısı kazanır.

Her zaman olduğu gibi, sorun net değilse, lütfen bana bildirin. İyi şanslar ve iyi golf!

Örnekler

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

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

Çevrimiçi deneyin. Test odası.

Temelde Python cevabımın bir portu; muhtemelen daha iyi bir yol var. Sayılacak sayıyı nve payrı satırlardaki oyuncu sayısını girdi olarak alır , sonucu iki boyutlu bir dizi olarak çıktılar.

Haskell, 151 bayt

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 bayt

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)

Aynı oyuncu tarafından söylenen sayılar aynı yarıçapta olacak şekilde bir daire içinde yazdırmak için kaplumbağa grafiklerini kullanır. Yön ters çevrildiğinde veya sıra dairenin etrafına sarıldığında dairenin yarıçapı artar, böylece önceki sayıların üzerine yazılmaz.

İçin örnek çıktı f(22,6)

Piton 2, 103 102 101 bayt

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

Sayılacak sayıyı ve oyuncu S(n,p)sayısını alan bir işlevi tanımlar ve sonucu dizeler dizisi olarak yazdırır.np

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

Python 2, 91 90 87 bayt

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

Tüplerin bir listesini yazdırır. Ideone üzerinde test edin .

Jöle , 27 25 bayt (rakip olmayan)

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

Çevrimiçi deneyin! veya tüm test senaryolarını doğrulayın .

Dyalog APL, 50 47 35 bayt

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

Bu, her bir oyuncunun masa olarak söylediği sayıları görüntüler; burada ilk sütun oyuncuları numaralandırır. Satırlar aynı uzunlukta 0 s ile doldurulur ve numarasız satırlar çıkarılır.

Doğrulama

      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

Son örnekte, bu oyuncular henüz bir şey söylemediğinden 7 ve 8'in atlandığını unutmayın.

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}

Oldukça basit bir uygulama. Çirkin bir glommed dize döndürür (bunu yapmak için bir boşluk ekleyebilirsiniz "#{k+=1} "... iyi, aralıklı bir dize). Orada daha matematiksel bir algoritma olup olmadığını merak ediyorum.

Faktör 172

Haskell'den daha uzun ve APL kadar okunabilir yaptım! Bir çerez alır mıyım?

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

Bu, dairesel bir vektör dizisi çıktısı veren bir tırnak (isimsiz işlev). Her vektör oyuncu sayısı ve ardından o oyuncuya karşılık gelen sayılarla başlar.

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

Bununla başladım:

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

Bu iyi bir faktör kodu değil, ama çok daha açık (evet, orada değişken isimleri olarak sayıları kullanıyorum, bana öyle bakma!).

JavaScript (ES6) 100

Sonucu dize dizisi olarak döndürme, ayırıcı yok

(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

Veya daha okunabilir, 3 bayt daha fazla, sonucu diziler dizisi olarak döndürür

(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

Yığın Parçacıklarının yeni harika konsol özelliğini kullanarak test etme

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 bayt

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

Doğrulama

   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