चलो एक-खिलाड़ी गेम खेलते हैं जिसे जंप द एरे कहा जाता है । खेलने के लिए, आपको केवल एक पूर्णांक की आवश्यकता है, कहते हैं a। आप किसी स्थिति में शुरू करते हैं i, और प्रत्येक मोड़ पर, आप एक नए स्थान पर जाते हैं। चालू होने पर n,

यदि nहै भी, तो आप पूर्ण स्थिति में कूद जाते हैं a[i] mod length(a),
यदि nविषम है, तो आप सापेक्ष स्थिति में कूद जाते हैं (i + a[i]) mod length(a)।

सरणी अनुक्रमण शून्य पर शुरू होता है। आप पहली छलांग को टर्न 0या टर्न के रूप में गिन सकते हैं 1, जो एक अलग खेल देता है। चूंकि खेल का राज्य स्थान परिमित है (आपकी चाल आपकी स्थिति और टर्न नंबर की समता से निर्धारित होती है), आप निश्चित रूप से अंत में समान लंबाई का लूप दर्ज करेंगे। loop(a, i, b)इस लूप की लंबाई से निरूपित करें, जब पहली छलांग को बारी के रूप में गिना जाता है b।

इनपुट

aसाथ खेलने के लिए पूर्णांक की एक गैर-रिक्त सरणी ।

उत्पादन

अधिक से अधिक संख्या p, जब किसी स्थिति पर शुरू होती है iऔर 0या तो पहले मोड़ की गिनती करती है या 1, आप अंततः लंबाई का एक लूप दर्ज करते हैं 2 * p। दूसरे शब्दों में, आपका आउटपुट नंबर है

max { loop(a, i, b)/2 : i in [0 .. length(a)-1], b in [0,1] }

नियम

आप एक समारोह या एक पूर्ण कार्यक्रम दे सकते हैं। सबसे छोटी बाइट गिनती जीतती है, और मानक खामियों को रोक दिया जाता है।

परीक्षण के मामलों

[0] -> 1
[-213] -> 1
[1,3,12,-1,7] -> 1
[2,3,5,7,9,11,13,17,19] -> 2
[-2,3,-5,7,-9,11,-13,17,-19,23,-27] -> 3
[0,2,5,4,-9,0,-1,1,-1,1,-6] -> 4

code-golf array-manipulation

— Zgarb
स्रोत

@ kukac67 हाँ, यह बाद का विकल्प है, जैसा कि मार्टिन ने कहा।

— जर्गब

मुझे लगता है कि सी। के विपरीत modहमेशा सकारात्मक ( -1 mod 5 == 4) के रूप में परिभाषित किया जाता है क्या यह मामला है?

— नटकी

@ कुटकी हां, मैं हास्केल-शैली का उपयोग करता हूं mod, जो हमेशा नॉनगेटिव परिणाम देता है।

— जर्बर्ब

यदि शून्य-इंडेक्सिंग मोड़ एक-इंडेक्सिंग से एक अलग परिणाम देता है, तो क्या हमें या तो परिणाम करना चाहिए, या जो भी कम हो?

— केएसएफटी

@ मार्टिनबटनर नहीं, मैं बारी-बारी से अनुक्रमण के बारे में पूछ रहा था , न कि सरणियों से।

— केएसएफटी

6

पायथ : 28 चरित्र (पायथन 2: 116 चरित्र)

eSmhxtu+G%@Q+eG@QeGlQUQ]ddUQ

उपयोग:

इसे यहाँ आज़माएँ: पायथ कंपाइलर / एक्ज़ीक्यूटर

यह इनपुट के रूप में पूर्णांक की एक सूची की उम्मीद करता है [0,2,5,4,-9,0,-1,1,-1,1,-6]

स्पष्टीकरण:

मैंने फ़ंक्शन की एक महत्वपूर्ण संपत्ति पर ध्यान दिया loop: प्रत्येक के iलिए एक है j, ताकि loop(a,i,0) == loop(a,j,1)और इसके विपरीत। इसलिए हम केवल मूल्यों की गणना करने की जरूरत loop(a,i,b)के लिए b=0।

प्रमाण: यदि एक चक्र i -> j -> k -> ... -> z -> iहै b = 0, तो चक्र के j -> k -> ... -> z -> i -> jसाथ मौजूद है b = 1।

इसलिए एक साधारण स्क्रिप्ट निम्नलिखित तरीके से काम कर सकती है। सभी को अलग i-अलग करें और iपुनरावृत्त कंप्यूटिंग द्वारा पहुंचने का प्रयास करें i = a[(i + a[i]) mod len(a)] mod len(a)। चूँकि यह गणना बिना चक्र के चल सकती है i, हम len(a)चरणों के बाद गणना को रद्द कर देते हैं । तब हम अधिकतम चक्र प्रिंट करते हैं।

एक पायथन 2 कार्यान्वयन इस तरह दिखता है ( 125 वर्ण ):

a=input();A=len(a);m=[]
for i in range(A):
 j=i
 for c in range(A):
  j=a[(j+a[j])%A]%A
  if i==j:m+=[c+1];break
print max(m)

अजगर के कार्यान्वयन के लिए मैंने थोड़ा अलग दृष्टिकोण का उपयोग किया। प्रत्येक के लिए iमैं पदों की सूची की गणना करता हूं, और iइस सूची में देखता हूं ।

eSmhxtu+G%@Q+eG@QeGlQUQ]ddUQ  
  m                       UQ    for each d in [0, ..., len(input)-1] compute a
      u                ]d         list G (using reduce), 
                                  which is first initialized with G = [d]
                     UQ           for each H in [0, ..., len(input)-1]:
       +G                            append to G the value
         %@Q+eG@QeGlQ                   input[G[-1] +input[G[-1]] % len(input)
                                        (notice that list lookups in pyth work with modular wrapping)
     t                            remove the first value (which is d)
    x                    d        and find the index of d in this shortend list
                                  (it's -1, if d is not in the list)
   h                              add 1
eS                              print the maximum (end of sorted list)

संपादित करें: पायथन 2: 116 वर्ण

@proud हैस्केलर का समाधान मेरे पायथन समाधान से कुछ कम छोटा था, इसलिए मैंने इसे थोड़ा छोटा करने के लिए 'किया' था।

a=input();A=len(a);l=lambda j,i,c:c<=A and(c*(i==j)or l(a[(j+a[j])%A]%A,i,c+1));print max(l(i,i,0)for i in range(A))

अंतर यह है, कि मैं पुनरावृत्ति के बजाय पुनरावर्ती संख्या की गणना करता हूं।

— Jakube
स्रोत

8

अजगर - 157

a=input()
z=len(a)
b=[]
for i in range(z):
    s,c,t=[],"",0
    while(c in s[:-1])-1:j=(i*t+a[i])%z;c=`t`+`i`;s+=[c];t^=1
    b+=[len(s)-s.index(c)-1]
print max(b)/2

— KSFT
स्रोत

1

यदि आप len(a)एक चर में डालते हैं और सभी len(a)को उस चर के नाम से बदल देते हैं, तो आप कुछ वर्णों को बचा सकते हैं।

— प्रोग्रामफॉक्स

1

कुछ विचार: t+=1;t%=2-> t^=1और if t: j=(j+a[j])%z else: j=a[j]%z->j=(t*j+a[j])%z

— वेक्टर

1

इंडेंट करने के लिए केवल एक स्थान का उपयोग करें। यहां 9 चरस बचती है।

— पुरकाकूदरी

1

एक और विचार: while c not in s[:-1]:हो सकता है while(c in s[:-1])-1:।

— पुरकाकूदरी

1

एक और। आप उपयोग की जरूरत नहीं है j, के रूप में यह पाश की सामग्री प्रदान करती है range(z)के iबजाय इसे बढ़ाने की। बस की जगह jके साथ iकरने के लिए 4 बचाने वर्ण।

— पुरकाकूदरी

5

हास्केल, 120 105

f s|t<-l s=maximum[g$drop t$iterate(\i->s!!mod(i+s!!mod i t)t)i|i<-s]
g(x:s)=l$0:fst(span(/=x)o)
l=length

यह प्रत्येक प्रारंभिक बिंदु के लिए एक अनंत सूची बनाता है (गोल्फिंग कारणों से हम सभी अनुक्रमों के बजाय सभी मूल्यों पर पुनरावृति करते हैं, जो समान हैं)। तो यह प्रत्येक सूची (के चक्र लंबाई के चक्र की गणना करता xsहै xs % [])।

यह चक्रों के बारे में @ जाकुब्स की टिप्पणियों का उपयोग करता है। क्योंकि यह एक समय में 2 कदम रखता है, हमें अंत में 2 से विभाजित करने की आवश्यकता नहीं है।

संपादित करें : अब nपहले तत्व के साथ एक चक्र होने की गारंटी देने के लिए पहले तत्वों को छोड़ने के @ MthViewMark की चाल का उपयोग करना । वैसे, मैं उनके अल्गोरिद्म को 112पात्रों तक पहुँचाने में कामयाब रहा :

l=length
o(x:y)=1+l(takeWhile(/=x)y)
j a|n<-l a=maximum$map(o.drop n.iterate(\i->mod(a!!mod(i+a!!i)n)n))[0..n-1]

— गर्वित हेकलर
स्रोत

2

हास्केल - 139 वर्ण

l=length
o(x:y)=1+l(takeWhile(/=x)y)
j a=maximum$map(o.drop n.iterate(b!!))[0..n-1]
 where b=zipWith(\x y->mod(a!!mod(x+y)n)n)a[0..];n=l a

उदाहरण:

λ: j [0]
1

λ: j [-213]
1

λ: j [1,3,12,-1,7]
1

λ: j [2,3,5,7,9,11,13,17,19]
2

λ: j [-2,3,-5,7,-9,11,-13,17,-19,23,-27]
3

λ: j [0,2,5,4,-9,0,-1,1,-1,1,-6]
4

यह @ जकुब के अवलोकन का उपयोग करता है जिसे आपको प्रति चलना 2 चरणों का प्रदर्शन करते समय केवल शुरुआती मूल्यों की जांच करने की आवश्यकता है।

— MtnViewMark
स्रोत

आप whereपिछले करने के लिए स्क्विश कर सकते हैं ]। इसके अलावा, आप के cycle l!!iबजाय का उपयोग करने की कोशिश की l!!mod n(length l)?

— गर्वित हैकेलर

इसके अलावा, आप इनलाइन को खत्म करने के bलिए एक पैटर्न गार्ड |n<-l aका उपयोग कर सकते हैं where।

— गर्वित हैकेलर

2

अजगर, 160

l=lambda a,b,c,d:(b,c)in d and len(d)-d.index((b,c))or l(a,(a[b]+[0,b][c])%len(a),~c,d+[(b,c)])
j=lambda a:max(l(a,b,c,[])for b in range(len(a))for c in(0,1))/2

उत्तर के लिए कार्य है j।
पुनरावर्ती फ़ंक्शन lकिसी दिए गए सरणी, प्रारंभ, और पहली बारी के लिए लूप की लंबाई लौटाता है, और फ़ंक्शन jअधिकतम पाता है।

— faubi
स्रोत

मुझे लगता है कि आप जे को परिभाषित करके कुछ पात्रों को बचा सकते हैं lambda।

— केएसएफटी

1

गणितज्ञ, 189 162 161 बाइट्स

यदि अनाम फ़ंक्शंस की अनुमति है - 161 बाइट्स:

Max[l=Length;Table[b={};n=p;i=s-1;e:={i,n~Mod~2};While[b~Count~e<2,b~AppendTo~e;h=#[[i+1]];i=If[EvenQ@n++,h,i+h]~Mod~l@#];l@b-b~Position~e+1,{s,l@#},{p,0,1}]/4]&

अन्यथा - 163 बाइट्स:

f=Max[l=Length;Table[b={};n=p;i=s-1;e:={i,n~Mod~2};While[b~Count~e<2,b~AppendTo~e;h=#[[i+1]];i=If[EvenQ@n++,h,i+h]~Mod~l@#];l@b-b~Position~e+1,{s,l@#},{p,0,1}]/4]&

सभी परीक्षण-मामलों पर यह चल रहा है:

f /@ {
  {0},
  {-213},
  {1, 3, 12, -1, 7},
  {2, 3, 5, 7, 9, 11, 13, 17, 19},
  {-2, 3, -5, 7, -9, 11, -13, 17, -19, 23, -27},
  {0, 2, 5, 4, -9, 0, -1, 1, -1, 1, -6}
}

का परिणाम:

{1, 1, 1, 2, 3, 4}

पायथन 2, 202 बाइट्स

def l(a,n,i):
 b=[]
 while not[i,n]in b:b.append([i,n]);i=(a[i]if n<1 else i+a[i])%len(a);n+=1;n%=2
 return len(b)-b.index([i,n])
def f(a):print max([l(a,n,i) for n in[0,1]for i in range(len(a))])/2

डेमो

यह मेरे गणितज्ञ उत्तर का लगभग एक हिस्सा है।

— kukac67
स्रोत

यह दिखने में मेरे जैसा ही है। पहली बार में एक (दो से विभाजित होने से पहले) मेरा था। मुझे अभी भी यकीन नहीं है कि क्यों, लेकिन मैंने विभाजित होने से पहले एक घटाया।

— केएसएफटी

मैं गणितज्ञ को नहीं जानता, इसलिए मैं वास्तव में अधिक मदद नहीं कर सकता।

— केएसएफटी

@Zgarb ओह! अच्छा है कि सब कुछ बताते हैं। मैंने ऐसा सोचा भी नहीं था। धन्यवाद!

— kukac67

For 3 तर्कों के साथ आमतौर पर कम है While (क्योंकि आप सामने अर्धविराम पर सहेज सकते हैं For)।

— मार्टिन एंडर

1

गणितज्ञ, 113 112 वर्ण

l=Length;m=MapIndexed;f=Max[l/@ConnectedComponents@Graph@m[Tr@#2->#&,Part@@Thread@Mod[#+{Tr@#2,1}&~m~#,l@#,1]]]&

उदाहरण:

f /@ {
  {0},
  {-213},
  {1, 3, 12, -1, 7},
  {2, 3, 5, 7, 9, 11, 13, 17, 19},
  {-2, 3, -5, 7, -9, 11, -13, 17, -19, 23, -27},
  {0, 2, 5, 4, -9, 0, -1, 1, -1, 1, -6}
}

{, 1, 1, 1, 2, 3, 4}

— alephalpha
स्रोत

1

ईड 82

ised '@1{0,2,5,4,-9,0,-1,1,-1,1,-6};@2{1};' '@{4 5}{(@3{:$1_x++x*@2{1-$2}:}2*#$1)::[#$1]};{1+?{:@5{$3::$5}=$4:}@::[2*#$1]_0}/2'

पहला तर्क लंबाई (सरणी आरंभीकरण में $1और में गिनती नहीं है)b आरंभ में$2 - "गेम" चुनें)।

— ओरियन
स्रोत

कूदो ऐरे!

इनपुट

उत्पादन

नियम

परीक्षण के मामलों

पायथ : 28 चरित्र (पायथन 2: 116 चरित्र)

उपयोग:

स्पष्टीकरण:

संपादित करें: पायथन 2: 116 वर्ण

अजगर - 157

हास्केल, 120 105

हास्केल - 139 वर्ण

अजगर, 160

गणितज्ञ, 189 162 161 बाइट्स

पायथन 2, 202 बाइट्स

गणितज्ञ, 113 112 वर्ण

ईड 82