एल्गोरिथ्म ब्रेडिंग - मातृ दिवस के लिए

Question

कार्य:

आपका कार्य एक ऐसा प्रोग्राम बनाना है, जब एक स्ट्रिड के कई किस्में और कई पुनरावृत्तियों को देखते हुए, यह बताएगा कि प्रत्येक स्ट्रैंड कहां जाता है। नियम इस प्रकार हैं:

• किस्में की संख्या हमेशा विषम होगी, और 3 से 6000 के बीच (समावेशी)
• जब आप शुरू करते हैं, तो किस्में को 2 (लगभग) समान गुच्छों में विभाजित किया जाएगा, leftऔर ए right। leftएक और किनारा जब आप शुरू होगा।

7 के इनपुट के लिए:

/ / / / \ \ \
1 2 3 4 5 6 7

• प्रत्येक पुनरावृत्ति, अधिक स्ट्रैंड के साथ पक्ष के सबसे बाहरी किनारा को विपरीत दिशा का सामना करना पड़ केंद्र में रखा जाएगा। विपरीत किस्में के बीच केंद्र को परिभाषित किया गया है ////middle\\\:।

इनपुट 7 का 1 पुनरावृत्ति (किनारा 1 केंद्र में ले जाया गया था):

/ / / \ \ \ \
2 3 4 1 5 6 7

उदाहरण:

इनपुट:

3 4

संगणना:

1 2 3
 \
2 1 3
   /
2 3 1
 \
3 2 1
   /
3 1 2

आउटपुट:

3 1 2

नियम:

• आपको स्ट्रैंड दिशा के लिए स्लैश प्रदर्शित करने की आवश्यकता नहीं है, केवल संख्या।
• आपको केवल अंतिम पुनरावृत्ति के बाद संख्याओं को प्रदर्शित करने की आवश्यकता है।
• आपका आउटपुट स्ट्रैंड्स का स्पेस-डिलेमिनेटेड आईडी होगा
• इनपुट फॉर्म में होगा: strands [space] iterations
• किस्में की संख्या हमेशा विषम होगी, और 3 <= x <= 6000
• यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है!

Comments

क्या यह 3 से 5999 नहीं होगा क्योंकि 6000 विषम नहीं है इसलिए आपके पास '6000 तक' नहीं होगा?

— किटकार्ने २२

तो उत्पादन के लिए 11 2होगा 2345611178910?

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

@ आपकी जमा राशि ने मेरा परिवर्तन तोड़ दिया

— TheDoctor

@ TheDctor आपके परिवर्तन से पहले मेरा जवाब था।

— हावर्ड

मुझे लगता है कि आपका उदाहरण पढ़ना चाहिए 123 -> 213 -> 231 -> 321 -> 312।

— हावर्ड

Answer 1

GolfScript, 33 अक्षर

~\),(@{:^1$[=]:y-.,2//y*^~}*;' '*

स्टड पर इनपुट प्रदान किया जाना चाहिए।

उदाहरण (आप ऑनलाइन परीक्षण कर सकते हैं ):

> 7 1
2 3 4 1 5 6 7

> 3 4
3 1 2

> 11 2
2 3 4 5 6 11 1 7 8 9 10

Answer 2

पायथन: 179 240 , 152 अक्षर

सबसे पहले, 179

के लिए Nकिस्में और iपुनरावृत्तियों, इस उत्तर का उपयोग करता है O(1)अंतरिक्ष और O(N)समय। मैं बस प्रत्येक कतरा के अंत की स्थिति की गणना करता हूं, कभी मध्यवर्ती पदों पर पुनरावृत्ति नहीं करता!

बिग एडिट: बूलियन बीजगणित में सशर्त परिवर्तन करके इस उत्तर को तैयार किया। मैंने यह भी लिखा कि यह कैसे काम करता है, इसकी एक लंबी व्याख्या । टीएल; डीआर: सूत्र पैटर्न, मोडुलो डिवीजन।

from sys import *
N,i=map(int,stdin.readline().split())
h,t=N/2,3*N
f=lambda p:(p>N)*(t/2-(p&-2))+p/2+1
for s in xrange(N):print f((2*s+1+(s>h)*(t-4*s-2)+i*(N+1-N*(s!=h)))%(2*N)),

अब 152

यह अधिक उचित रूप से गोल्फ वाला अजगर है। (संपादित करें: 165 से 152 तक संपादन के लिए एलेक्स थॉर्नटन का धन्यवाद)

from sys import*;l=map;r=range;n,m=l(int,stdin.readline().split());b=r(1,n+1)
for k in r(m):v=b.pop((0,n-1)[k%2]);b.insert(n/2,v)
print' '.join(l(str,b)

Comments

यदि आप रुचि रखते हैं, तो इसे और भी घटाकर 151 कर दिया है: pastebin.com/1pbwax6s

— एलेक्स थॉर्नटन

साधारण परिवर्तन, लेकिन बहुत प्रभावी। धन्यवाद!

— गलतू

मुझे लगता है कि आप इसे lऔर vवैरिएबल्स को हटाकर और insertस्लाइस असाइनमेंट में बदलकर और भी कम कर सकते हैं ।

— user2357112

मुझे यकीन है कि गोल्फ छोटा हो सकता है। ईमानदारी से मैं सिर्फ पहले एक पर टिप्पणी की उम्मीद है अगर कुछ भी!

— गलतू

मैंने वैसे भी एक स्पष्टीकरण लिखा और पोस्ट को अपडेट किया :)

— गलत

Answer 3

पायथन 2 (109) / पायथन 3 (121)

अजगर २

s,n=map(int,raw_input().split())
b=range(s)
for i in range(n):b[s/2:s/2]=[b.pop(0-i%2)]
for x in b:print x+1,

अजगर ३

s,n=map(int,input().split())
b=list(range(s))
for i in range(n):b[s//2:s//2]=[b.pop(0-i%2)]
for x in b:print(x+1,end=' ')

पायथन 3 से अधिक अपने गोल्फ फायदे दिखाने के लिए कोड को पायथन 2 द्वारा रिश्वत दिया जाना चाहिए: श्रेणियों की सूची, विभाजन को एक अंत तक ले जाना, एक नई शुरुआत न करना। अजीब 0-i%2है क्योंकि -i%2मूल्यांकन के रूप में है (-i)%2।

संभवतः पुनरावृत्ति की तुलना में अधिक कुशल दृष्टिकोण है, अर्थात् प्रत्येक अंतिम परिणाम को सीधे गणना करना। ब्रेडिंग ऑपरेशन की अवधि 2 * s है, इसलिए यह उतना जटिल नहीं हो सकता।

Answer 4

रूबी, 105

बस सेट हेरफेर का एक बहुत। पुश, पॉप, रिवर्स और शिफ्ट! मैंने इनपुटर्स को पूर्णांक में परिवर्तित नहीं करने की कोशिश की, लेकिन इसमें लगभग 20 अक्षर जोड़े गए।

n,i=$*.map(&:to_i)
f=l=(1..n).to_a
t=r=l.pop(n/2).reverse
i.times{f,t=t<<f.shift,f}
$><<(l+r.reverse)*' '

lऔर r( leftऔर right) "थ्रेड" कतार हैं। rightउलटा होता है इसलिए हम बाहर से खींचना शुरू करते हैं।

tऔर f( toऔर from) क्रमशः के रूप में rightऔर शुरू करते leftहैं, लेकिन जब हम जाते हैं तो हम उन्हें स्वैप करते रहते हैं ताकि हम हमेशा पिछले "थ्रेड" को इसमें से शिफ्ट कर सकें fromऔर इसे to( f,t=t<<f.shift,f) में धकेल सकें । यह बहुत सारे स्थान बचाता है।

फिर हम rightअंत में बस फिर से उल्टा करते हैं।

बदलाव का:

2.2 105 ओह, हाँ, नक्शा एक खरीद ले सकते हैं

२.१ १० और वास्तव में, बस हेरफेर के हिस्से के रूप में चीजें फ्लिप करें।

2.0 116 उस अस्थायी सरणी का उपयोग नहीं करते हैं। इसके बजाय दो पॉइंटर वैरिएबल का उपयोग करें जिन्हें हम हेरफेर कर सकते हैं और पुनः इंगित कर सकते हैं। तब केवल अंत प्रदर्शित करें

1.0 123 प्रारंभिक विचार

Answer 5

जावा, 270 वर्ण

golfed:

import java.util.*;class B{public static void main(String[] a){int n=Integer.valueOf(a[0]),t=Integer.valueOf(a[1]),i=0;List<Integer> r=new ArrayList<Integer>();for(;i<n;i++){r.add(i+1);}for(i=0;i<t;i++){int k=i%2==0?0:n-1;r.add(n/2,r.remove(k));}System.out.println(r);}}

अन-golfed:

import java.util.*;
public class Braid {
    public static void main(String[] args) {
        int num = Integer.valueOf(args[0]);
        int iterations = Integer.valueOf(args[1]);

        //populate array
        List<Integer> arr = new ArrayList<Integer>();
        for (int i=0; i < num; i++) {
            arr.add(i+1);
        }
        for (int i=0; i < iterations; i++) {
            int index = i%2==0?0:num-1; 
            arr.add(num/2, arr.remove(index));
        }
        System.out.println(arr);
    }
}

ऑनलाइन चलाएं