सेवन्स का खेल! किसने क्या कहा?

Question

सेवेन्स का खेल निम्नानुसार खेला जाता है: nखिलाड़ी एक सर्कल में बैठते हैं, और 1 से गिनती शुरू करते हैं, बाईं ओर (या खिलाड़ी Aसे खिलाड़ी तक B) पास करते हैं।

जब एक संख्या pजिसमें 7यह है या द्वारा विभाज्य है 7, पहुंच गया है, तो उस खिलाड़ी ने जो नंबर बोला p-1, अगले खिलाड़ी के pकहने के बाद , कहना होगा p+1और बोलने वाले लोगों के आदेश को उलट देता है। उदाहरण के लिए, यदि खिलाड़ी Bबोलता है 6, तो खिलाड़ी Cकहता है 7, Bकहता है 8और खिलाड़ी Aकहता है 9।

नोट: जो लोग वास्तविक जीवन में खेलना चाहते हैं, अगर कोई व्यक्ति एक संख्या भूल जाता है (या उस संस्करण में जहां sevensगलती से नहीं कहा जाता है seven), तो वे सर्कल से समाप्त हो जाते हैं, लेकिन हम इस चुनौती से इस विस्तार को छोड़ देंगे।

यह चुनौती खुद को प्रिंट करना है कि प्रत्येक खिलाड़ी को mएक इनपुट 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के साथ चिह्नित हैं *। ध्यान दें कि 27और 28, हम दो बार पलट रहे हैं, और "से सामान्य" के रूप में खेलना जारी 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]

Comments

मुझे लगता है कि खेल खेलने की कल्पना के प्रयोजनों के लिए एक अधिक उपयोगी आउटपुट खेल के क्रम में खिलाड़ियों की एक सूची होगी। (जैसे 4 खिलाड़ियों और अधिकतम 15 के साथ, यह होगा 1 2 3 4 1 2 3 2 1 4 3 2 1 4 1।) मैं यह नहीं कह रहा हूं कि वह चुनौती के मामले में बेहतर या बदतर है: बस यह वास्तविक दुनिया में अधिक उपयोगी होगा।

— msh210

क्या हम शून्य के साथ मैट्रिक्स और पैड के रूप में परिणाम प्रदर्शित कर सकते हैं?

— डेनिस

@ डेनिस खाली एरे को रखा जाना चाहिए। परिणाम शून्य-गद्देदार मैट्रिक्स हो सकता है।

— शर्लक

Answer 1

पायथ, 38 बाइट्स

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

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

मूल रूप से मेरे पायथन उत्तर का एक बंदरगाह; शायद एक बेहतर तरीका है। अलग-अलग लाइनों पर nसंख्या और खिलाड़ियों की संख्या के इनपुट के रूप में लेता है p, परिणाम को दो-आयामी सरणी के रूप में आउटपुट करता है।

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

Comments

कैसे के mod n 7<1बजाय mod n 7==0और के s<$>[1..]बजाय map s[1..]? इसके अलावा, इसके print[]बजाय क्यों नहीं mapM_ print[]?

— माइकल क्लेन

Answer 3

पायथन 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)

Comments

ओह, यह चतुर और सुंदर है। +1: डी

— शर्लक

Answer 4

पायथन 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']

Answer 5

पायथन 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 पर इसका परीक्षण करें ।

Answer 6

जेली , 27 25 बाइट्स (गैर-प्रतिस्पर्धात्मक)

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

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

Comments

यह प्रतिस्पर्धा क्यों नहीं है

— बैलिंट

क्योंकि चुनौती दिसंबर 2015 से है और जेली के निर्माण से पहले है।

— डेनिस

ओह, स्पष्टीकरण के लिए धन्यवाद!

— बैलिंट

क्या यह एक आधिकारिक नियम है? मैं कभी भी प्रोग्रामिंग लैंग्वेज आविष्कार की तारीख के खिलाफ प्रश्न दिनांक की जाँच नहीं करता।

— थॉमस वेलर

@ThomasWell क्या चुनौती के पोस्ट होने के बाद आविष्कार की गई भाषा के साथ मैं कभी जवाब दे सकता हूं?

— डेनिस

Answer 7

दिल्लोग एपीएल, 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 को छोड़ दिया गया है क्योंकि उन खिलाड़ियों ने अभी तक कुछ भी नहीं कहा है।

Answer 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} "... ठीक है, एक कड़ा हुआ स्ट्रिंग)। मुझे आश्चर्य है कि अगर वहाँ एक और गणितीय एल्गोरिथ्म है।

Answer 9

कारक 172

मैं इसे हास्केल की तुलना में लंबा करने में कामयाब रहा, और एपीएल के रूप में पठनीय! क्या मुझे एक कुकी मिलती है?

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

जो अच्छा कारक कोड नहीं है, लेकिन बहुत अधिक स्पष्ट है (हाँ, मैं वहां चर नामों के रूप में संख्याओं का उपयोग कर रहा हूं, मुझे इस तरह मत देखो!)।

Comments

"क्या मुझे एक कुकी मिलती है?" हाँ आप कीजिए।

— लीकेय नन

वाह, यह अप्रत्याशित था! Ty, @LeakyNun: D

— fede s।

वाह, मुझे यह पसंद है! पहचानकर्ताओं के रूप में संख्याओं का उपयोग करने के लिए आपको शाप!

— बिल्ली

मैं @cat वास्तव में यह की तरह एक विकृत तरीके से: पी लेकिन स्थानीय लोगों का समाधान की लंबाई मुद्दा SYMBOL:एक बहुत बेहतर: एक अक्षर के नाम, और से छुटकारा हो रही है setऔर get!

— फेड एस।

Answer 10

जावास्क्रिप्ट (ईएस 6) 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))

Answer 11

जे, 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