12

कभी-कभी, जब मैं वास्तव में ऊब ( वास्तव में ऊब) होता हूं, तो मुझे एक लाइन खंड खींचना और उस पर अंक खींचना पसंद है।

सबसे पहले, मैं एक निश्चित आकार के एक लाइन सेगमेंट को आकर्षित करता हूं, जो कि एन के कुछ मूल्य के लिए 2 ^ एन है। लाइन को .वर्णों की एक श्रृंखला द्वारा दर्शाया जाएगा ।

................

फिर, मैं बाएं छोर पर एक बिंदु की साजिश करता हूं। अंक Xपात्रों द्वारा दर्शाए जाएंगे ।

X...............

फिर, मैं एक पैटर्न का पालन करता हूं। सबसे हाल ही में प्लॉट किए गए बिंदु (जिसे मैं ए कहूंगा) पर शुरू करते हुए, मैं लाइन पर अगले प्लॉट किए गए बिंदु (बी) पर अग्रिम करता हूं (आवश्यक रूप से चारों ओर लपेटता हूं)। फिर, मैं लाइन (सी) पर अगले प्लॉट किए गए बिंदु पर अग्रिम करता हूं । फिर, मैं इस तीसरे बिंदु (C) और अगले पहले से प्लॉट किए गए बिंदु (D) के बीच में एक नए बिंदु पर आधे रास्ते की साजिश रचता हूं।

जब भी आप रेखा के चारों ओर लपेटते हैं, तो "मध्य" को रैपिंग तरीके से निर्धारित किया जाता है। नव प्लॉट किया गया बिंदु हमेशा C के दाईं ओर होता है।

मान लीजिए कि निम्नलिखित पंक्ति मेरी वर्तमान रेखा थी। यहां बताया गया है कि मैं अगले दो बिंदुओं को कैसे लिखूंगा। इस उदाहरण के लिए, मैं प्रत्येक महत्वपूर्ण बिंदु को एक पत्र के साथ लेबल करूँगा।

X...A...X.X...X.
    ^

X...A...B.X...X.
        ^

X...A...B.C...X.
          ^

X...A...B.C...D.
            ^

X...X...X.X.A.X.
            ^

X...X...X.X.A.B.
              ^

C...X...X.X.A.B.
^

C...D...X.X.A.B.
  ^

X.A.X...X.X.X.X.
  ^

पिछले उदाहरण पर लौटते हुए, अगले बिंदु को लाइन के बीच में प्लॉट किया जाएगा।

X.......X.......

यह शायद एक विशेष मामले का एक छोटा सा हिस्सा है: अगले बिंदु पर आगे बढ़ने से बस आपको छोड़ देता है जहां आपने शुरू किया था। एकमात्र उपयोगी आधा बिंदु "चक्रीय" आधा बिंदु (लाइन पर आधा बिंदु) है, जैसा कि खुद के शीर्ष पर एक बिंदु को साजिश रचने का विरोध किया गया था।

नीचे बिंदुओं की श्रृंखला है जिसे मैं यहां से अंत तक लाइन पर लिखूंगा।

X.......X.......
X.......X...X...
X.......X.X.X...
X...X...X.X.X...
X...X...X.XXX...
X.X.X...X.XXX...
X.X.X...XXXXX...

अगले बिंदु पर प्लॉट करने के लिए अब कोई जगह नहीं है, क्योंकि यह दो आसन्न बिंदुओं के बीच होना चाहिए, इसलिए मैं एन = 4 के दिए गए मूल्य के लिए अधिकतम गहराई तक पहुंच गया हूं। उपरोक्त सूची में अंतिम पंक्ति "पूर्ण" है। । "

चुनौती

लक्ष्य सबसे छोटा प्रोग्राम / नामित फ़ंक्शन लिखना है जो एन के दिए गए मान के लिए पूरी की गई रेखा को प्रिंट / वापस करेगा। उपरोक्त = 4 दिखाता है।

इनपुट

इनपुट एक एकल गैर-नकारात्मक पूर्णांक N होगा। उत्पन्न लाइन की लंबाई तब 2 ^ N होगी।

उत्पादन

आउटपुट लंबाई 2 ^ N की पूरी लाइन होगी, जो कि अक्षरों .और Xवर्णों द्वारा बनाई गई है । एक अनुगामी newline कोई फर्क नहीं पड़ता।

उदाहरण I / O

0
X

1
XX

2
X.XX

3
X.X.XXX.

4
X.X.X...XXXXX...

5
X.X.X...X...X...X.XXX.XXX.......

code-golf

— PhiNotPi
स्रोत

4

अजगर 2, 137

n=input()
l=[0]*2**n;i=0
while~i%2:i=i/2%2**n;l[i]=1;i=sum([k for k,v in enumerate(l*4)if(k>i)*v][1:3])
print''.join(['.X'[x]for x in l])

काफी निष्कपट।

पायथ, ४ ९

कमोबेश अनुवाद। मुख्य अंतर यह है कि मैं लाइन का प्रतिनिधित्व करने वाली सूची का उपयोग नहीं करता, मैं एक स्ट्रिंग का उपयोग करता हूं।

J*\.^2QW!%Z2K%/Z2lJ=JXJK\X=Zs<tf&q\X@JT>TKU*4J2)J

इसे ऑनलाइन आज़माएं ।

                         Q=input(); Z=0 #implicit
J*\.^2Q                  J = "."*(2^Q)
W!%Z2                    while !(Z%2):
  K%/Z2lJ                  K=(Z/2)%(len(J))
  =JXJK\X                  change J, the point at index K is changed to a "X"
       f          U*4J     filter all elements T in [0, 1, 2, ..., 4*len(J)-1]:
        &q\X@JT>TK           where J[T]=='X' and T>K
     <t               2    only us the second and third element
  =Zs                      and store the sum to Z
)J                       end while and print J

— Jakube
स्रोत

4

क्लिप , 95

[z?zF#2(z*2*:(#2(z'.'X]'X]]n[Fa[b[q[j[r?=rirFrsrb'X]b]][t[u+*<ut*Blb/+tu2]]g+2jqg+3jq]#qa]%b'X}

— Ypnypn
स्रोत

3

गोल्फस्क्रिप्ट (61 बाइट्स)

~2\?,[]0{.@|$4*.@?2+1$>2<.+~<!4$,*++.2/\1&!}do;`{&!'X.'1/=}+%

लूप पुनरावृत्तियों की संख्या की आवश्यकता A061419 से प्रतीत होती है , लेकिन डू-लूप इसकी गणना करने से कम है। एक divmod डो लूप के अंदर एक चार को बचाएगा। जो हिस्सा सबसे ज्यादा बेकार लगता है वह आउटपुट रूपांतरण है, लेकिन मैं यह नहीं देखता कि इसे कैसे सुधारूं।

— पीटर टेलर
स्रोत

3

CJam, 55 53 51 50 बाइट्स

2ri#:N'.*0aN{):U+__Nf++$_U#))>2<1bNe|2/N%|}*{'Xt}/

कुछ के साथ शुरू करने के लिए।

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

2

जावा, 209 207 195 191 बाइट्स

मुझे आश्चर्य है कि मैं इसे इस छोटे से प्राप्त करने में सक्षम था। अभी भी सुधार की गुंजाइश है। हमेशा की तरह, सुझावों की सराहना की जाएगी :)

यह एक रिटर्न char[]। का उपयोग कर कॉल करें a(n)।

char[]a;int b,c,d,e=2;char[]a(int f){java.util.Arrays.fill(a=new char[b=1<<f],'.');for(a[0]=88;d+1<e;c=(d+e)/2,a[c%b]=88)e=b(d=b(b(c)));return a;}int b(int f){for(;;)if(a[++f%b]>87)return f;}

इंडेंट:

char[] a;
int b, c, d, e = 2;

char[] a(int f){
    java.util.Arrays.fill(
            a = new char[
                    b = 1 << f
                    ]
            , '.'
    );
    for(
            a[0] = 88;
            d + 1 < e;
                c = (d + e) / 2,
                a[c % b] = 88
        )
        e = b(
                d = b(
                        b(c)
                )
        );
    return a;
}

int b(int f){
    for (;;)
        if (a[++f % b] > 87)
            return f;
}

12 बाइट्स पीटर के लिए धन्यवाद :)
4 बाइट्स टीएनटी के लिए धन्यवाद;)

— नंबर एक
स्रोत

(c%b+b)%b? क्या आप cनकारात्मक होने की उम्मीद कर रहे हैं ?

— पीटर टेलर

c=0और d=0बस cऔर के लिए छोटा किया जा सकता है d। intवर्ग स्तर पर परिभाषित प्रकार स्वचालित रूप से 0.

— टीएनटी

1

हास्केल, 182 बाइट्स

(a:b)%(c:d)|a<c=a:b%(c:d)|1<2=c:(a:b)%d
f i=putStr$map(!(0:g[0,n..]))[0..n-1]where n=2^i;e!l|e`elem`l='X'|1<2='.';g(_:_:c:d:r)|m==c=[]|1<2=mod m n:g((d:r)%[m,m+n..])where m=div(c+d)2

उपयोग: f 5। आउटपुट: X.X.X...X...X...X.XXX.XXX.......।

दुर्भाग्य से हास्केल का मानक पुस्तकालयों में विलय का कार्य नहीं है, इसलिए मुझे अपना (-> %) प्रदान करना होगा। सौभाग्य से मुझे केवल अनंत सूचियों का विलय करना है, इसलिए मुझे आधार मामलों, यानी खाली सूचियों को कवर करने की आवश्यकता नहीं है। अभी भी इसकी कीमत 40 बाइट्स है।

यह कैसे काम करता है: Xएस को सीधे एक सरणी में सेट करने के बजाय , मैं उन पदों की सूची रखता हूं जहां वे हैं। इसके अलावा मैं चारों ओर नहीं लपेटता, 2^Nलेकिन अनंत की ओर स्थितियां बढ़ाता रहता हूं (उदाहरण के लिए N = 2 के Xलिए सामने की ओर, स्थिति सूची जैसी दिखती है [0,4,8,12,16,20,…])। मैं तीसरी और चौथी तत्व ( cऔर d) लेता हूं , नई स्थिति की गणना करता हूं (c+d)/2, इसे आउटपुट सूची के लिए रखता हूं , पुरानी स्थिति की सूची को स्थिति 4 ( d) से एक नए सिरे से शुरू करता (c+d)/2हूं और पुनरावृत्ति करता हूं। (c+d)/2बराबरी करने पर मैं रुक जाता हूं c। अंत में मैं 0आउटपुट सूची में एक जोड़ देता हूं और Xदिए गए पदों और .अन्य जगहों पर प्रिंट करता हूं ।

step by step example, N=2

step  position list       (c+d)/2  output     lists to merge (pos. list for next round)
                                   list       old list from d on / new list from (c+d)/2

  #1  [0,4,8,12,16,…]       10     [10]          [12,16,20,24,…] / [10,14,18,22,…]
  #2  [10,12,14,16,18,…]    15     [10,15]       [16,18,20,22,…] / [15,19,23,27,…]
  #3  [15,16,18,19,20,…]    18

stop here, because c equals (c+d)/2

add 0 to the output list: [0,10,15]
take all elements modulo 2^N: [0,2,3]
print X at position 0, 2 and 3

— nimi
स्रोत

1

गणितज्ञ, ११० १०२ ११२ १०atic १० 110

a=Array["."&,n=2^Input[]];a[[Mod[Round@{n/2,n}//.{x_,y_,z___}/;y-x>1:>{z,x+n,(x+y)/2+n,y+n},n]+1]]="X";""<>a

— alephalpha
स्रोत

एक रेखा पर भग्न बिंदु