27

नियम 110 कुछ दिलचस्प गुणों के साथ एक सेलुलर ऑटोमोबोन है। आपका लक्ष्य नियम 110 को यथासंभव कुछ वर्णों में अनुकरण करना है।

जो लोग नहीं जानते हैं, नियम 110 एक ग्रिड में लाइन द्वारा सिम्युलेटेड लाइन है। ग्रिड की एक पंक्ति में प्रत्येक वर्ग ऊपर, बाएं और ऊपर-नीचे के वर्गों को देखता है कि यह क्या सेल होना चाहिए।

current pattern  111 110 101 100 011 010 001 000
new cell          0   1   1   0   1   1   1   0

इनपुट: किसी भी उचित प्रारूप (अल्पविराम से अलग स्ट्रिंग, सूची, फ़ंक्शन तर्क) में शीर्ष पंक्ति nth इनपुट वर्ग का प्रतिनिधित्व करते हुए 0 से 39 तक की संख्या। 1-अनुक्रमित भाषाओं को समायोजित करने के लिए, संख्याएं 1-अनुक्रमित भी हो सकती हैं और इसलिए 1 से 40 तक होती हैं।

उदाहरण इनपुट:

38,39

आउटपुट: पहली पंक्ति सहित चल रहे ऑटोमेटा का प्रतिनिधित्व करते हुए 40 x 40 ग्रिड। आपको 0 को रिक्त और 1 किसी भी दृश्यमान मुद्रण चरित्र के रूप में छोड़ देना चाहिए। अनुगामी रिक्त स्थान की अनुमति दी जाती है, जब तक कि वास्तविक ग्रिड को यथोचित रूप से प्रतिष्ठित किया जा सकता है। ग्रिड के नीचे एक नई रेखा हो सकती है लेकिन ग्रिड लाइनों के बीच रिक्त लाइनें नहीं होनी चाहिए।

उदाहरण आउटपुट:

                                  XX
                                 XXX
                                XX X
                               XXXXX
                              XX   X
                             XXX  XX
                            XX X XXX
                           XXXXXXX X
                          XX     XXX
                         XXX    XX X
                        XX X   XXXXX
                       XXXXX  XX   X
                      XX   X XXX  XX
                     XXX  XXXX X XXX

आदि।

नोट: 1 डी सेलुलर ऑटोमेटा के बारे में एक समान प्रश्न पहले ही पूछा जा चुका है, लेकिन मुझे उम्मीद है कि, केवल एक नियम का उपयोग करके, छोटे उत्तरों को लिखा जा सकता है।

code-golf cellular-automata

— qwr
स्रोत

4

क्या पैटर्न चारों ओर से लपेटता है (यानी बाईं-सबसे सेल, इसके ऊपर की रेखा में दाईं-सबसे सेल की जांच करती है)?

— वेंटरो

4

यदि यह एकवचन है, तो यह एक कोशिकीय ऑटोमोबैटन है ।

— ClickRick

1

उत्तर भिन्नात्मक रूप से किसी भी 1D सेलुलर ऑटोमेटन के अनुकरण से कम हो सकते हैं क्योंकि नियम इनपुट से पार्स किए जाने के बजाय हार्ड-कोडेड है, लेकिन इसके अलावा अन्य उत्तर भी समान होने जा रहे हैं। यदि यह एक अलग नियम होता तो बचत की संभावना होती, लेकिन पृथ्वी पर ट्यूरिंग-शक्तिशाली नियम विशेष-आवरण को सामान्य कार्यान्वयन पर कुछ भी कैसे बचा सकता है?

— पीटर टेलर

1

@ वेंटरो वे इस संस्करण में नहीं हैं।

— क्यूर

1

@ बीएमओ यह एक पुराना सवाल है, लेकिन चूंकि आजकल आम सहमति लचीले इनपुट प्रारूपों की अनुमति देने की है, इसलिए मैं प्रश्न को संशोधित करने की अनुमति

— दूंगा

8

CJam - 47

S40*l',/{i'!t}/{N40,S3$S++f{>3<2b137Yb='!^}}39*

यह !"1" कोशिकाओं के लिए उपयोग करता है।

इसे http://cjam.aditsu.net/ पर आज़माएं

स्पष्टीकरण:

S40*40 स्थानों का एक स्ट्रिंग (सरणी) बनाता है
l',/और एक पंक्ति को पढ़ता है और अल्पविराम द्वारा विभाजन
{…}/प्रत्येक आइटम (स्ट्रिंग रूप में संख्या) के लिए ब्लॉक निष्पादित करता है
- i'!tसंख्या को पूर्णांक में परिवर्तित करता है और पिछली स्ट्रिंग में उस स्थिति में आइटम सेट करता है (शुरू में 40 रिक्त स्थान) ) सेवा मेरे '!'
इस बिंदु पर हमने पहली पंक्ति प्राप्त की है।
{…}39*39 बार ब्लॉक निष्पादित करता है
- Nएक नई रेखा जोड़ता है
- 40,सरणी बनाता है [0 1 ... 39]
- S3$S++पिछली पंक्ति (स्टैक पर स्थिति 3) की प्रतिलिपि बनाता है और इसे प्रत्येक पक्ष पर एक स्थान के साथ पैड करता है
- f{…}ब्लॉक को {0 से प्रत्येक संख्या के लिए निष्पादित करता है। 39} और {गद्देदार रेखा}
- >3<वर्तमान संख्या से शुरू होने वाली गद्देदार रेखा से 3 वस्तुओं का एक टुकड़ा लेती है
- 2bआधार 2 से धर्मान्तरित; हमारे द्वारा कटाए गए आइटम बेस -2 अंक नहीं हैं, लेकिन अक्षर अपने ASCII मूल्यों और '' मॉड 8 8 0 और 0 '' में परिवर्तित हो जाते हैं! mod 8 1 है
- 137Yb137 को आधार 2 ( Y= 2) में परिवर्तित करता है , [1 0 0 0 1 0 0 1 1] प्राप्त करता है, जो कि 110 उल्टा और उपेक्षित (8 बिट्स पर)
- ='!^संगत बेस -2 अंक प्राप्त करता है (ए सरणी को चारों ओर लपेटता है, इसलिए सूचकांक को मॉड 8 लिया जाता है) और 'के साथ' xor है! चरित्र, 'में परिणाम!' 1 के लिए और '' 1 के लिए

— aditsu
स्रोत

17

रूबी, 113 वर्ण

c=[0]*41
eval"[#{gets}].map{|i|c[i]=1}"+'
c=(0..39).map{|x|putc" X"[u=c[x]]
110[4*c[x-1]+2*u+c[x+1]]}<<0;puts'*40

स्टड पर इनपुट लेता है। किसी भिन्न नियम का उपयोग करने के लिए, बस 110अंतिम पंक्ति को उस नियम से बदलें जिसे आप प्रयास करना चाहते हैं।

उदाहरण:

$ ruby 110.rb <<< 38,39
                                      XX
                                     XXX
                                    XX X
                                   XXXXX
                                  XX   X
                                 XXX  XX
                                XX X XXX
                               XXXXXXX X
                              XX     XXX
                             XXX    XX X
                            XX X   XXXXX
                           XXXXX  XX   X
                          XX   X XXX  XX
                         XXX  XXXX X XXX
                        XX X XX  XXXXX X
                       XXXXXXXX XX   XXX
                      XX      XXXX  XX X
                     XXX     XX  X XXXXX
                    XX X    XXX XXXX   X
                   XXXXX   XX XXX  X  XX
                  XX   X  XXXXX X XX XXX
                 XXX  XX XX   XXXXXXXX X
                XX X XXXXXX  XX      XXX
               XXXXXXX    X XXX     XX X
              XX     X   XXXX X    XXXXX
             XXX    XX  XX  XXX   XX   X
            XX X   XXX XXX XX X  XXX  XX
           XXXXX  XX XXX XXXXXX XX X XXX
          XX   X XXXXX XXX    XXXXXXXX X
         XXX  XXXX   XXX X   XX      XXX
        XX X XX  X  XX XXX  XXX     XX X
       XXXXXXXX XX XXXXX X XX X    XXXXX
      XX      XXXXXX   XXXXXXXX   XX   X
     XXX     XX    X  XX      X  XXX  XX
    XX X    XXX   XX XXX     XX XX X XXX
   XXXXX   XX X  XXXXX X    XXXXXXXXXX X
  XX   X  XXXXX XX   XXX   XX        XXX
 XXX  XX XX   XXXX  XX X  XXX       XX X
XX X XXXXXX  XX  X XXXXX XX X      XXXXX
XXXXXX    X XXX XXXX   XXXXXX     XX   X

— Ventero
स्रोत

8

गणितज्ञ, 122 बाइट्स

f[a_]:=Riffle[CellularAutomaton[110,Array[If[MemberQ[ToExpression["{"<>a<>"}"],#-1],1,0]&,40],39]/.0->" "/.1->"X","
"]<>""

हाँ, आप इसे इस खामियों को गाली देते हुए देख सकते हैं , लेकिन क) जो खामियाजा है, वह विवादित है, ख) एक सेल्युलर आटोमैटन प्रश्न को गणित के उत्तर की आवश्यकता है (विशेष रूप से नियम 110 के बारे में) और ग) वेंटरो के रूबी का उत्तर वैसे भी कम है, इसलिए मैं डॉन कोई नुकसान नहीं हुआ है।

अधिकांश वर्ण इनपुट पार्सिंग और आउटपुट स्वरूपण के लिए उपयोग किए जाते हैं। वास्तविक ऑटोमेटन का उपयोग करके नकली किया जाता है

CellularAutomaton[110,initialGrid,39]

यह आवधिक सीमा की स्थितियों का उपयोग करता है (ताकि ग्रिड चारों ओर घूमता है)।

— मार्टिन एंडर
स्रोत

8

अजगर - 141

i=input()
o=range(40)
l=''.join(' X'[c in i]for c in o)
for r in o:print l;l=''.join('X '[l[c-1:c+2]in('XXX','   ','X  ','','  ')]for c in o)

जैसे भागो python 110.py <<< 38,39

— एलेक्स एल
स्रोत

3

['X',' ']'X '5 वर्णों को बचाने के लिए बदला जा सकता है ।

— केल्विन के

16

मेरा पसंदीदा फल अब एकo=range()

— kitcar2000

7

क्यू, 67 62 58 बाइट्स

कोई रैप-अराउंड नहीं मानता:

{40{not(2 sv'flip 1 0 -1 xprev\:x)in 0 4 7}\@[40#0b;x;~:]}

पुराना संस्करण

{40{not(flip(prev;::;next)@\:x)in 3 cut 111100000b}\@[40#0b;x;not]}
{40{not(flip 1 0 -1 xprev\:x)in 3 3#111100000b}\@[40#0b;x;~:]}

— skeevey
स्रोत

5

पायथन, 186

def r(s,m=range(40)):
 s=[int(i in s)for i in m]
 for g in m:print''.join([' X'[i]for i in s]);s=[int(not''.join(map(str,s[i-1:i+2]if i else s[:2]))in'111 100 000 00'.split())for i in m]

निर्णय लेकिन शायद इष्टतम नहीं है।

आपने यह निर्दिष्ट नहीं किया कि इनपुट कैसे प्राप्त होता है इसलिए मैंने अभी एक कार्य किया है।

उदाहरण का उपयोग करें:

आर ([38,39])

आउटपुट:

                                      XX
                                     XXX
                                    XX X
                                   XXXXX
                                  XX   X
                                 XXX  XX
                                XX X XXX
                               XXXXXXX X
                              XX     XXX
                             XXX    XX X
                            XX X   XXXXX
                           XXXXX  XX   X
                          XX   X XXX  XX
                         XXX  XXXX X XXX
                        XX X XX  XXXXX X
                       XXXXXXXX XX   XXX
                      XX      XXXX  XX X
                     XXX     XX  X XXXXX
                    XX X    XXX XXXX   X
                   XXXXX   XX XXX  X  XX
                  XX   X  XXXXX X XX XXX
                 XXX  XX XX   XXXXXXXX X
                XX X XXXXXX  XX      XXX
               XXXXXXX    X XXX     XX X
              XX     X   XXXX X    XXXXX
             XXX    XX  XX  XXX   XX   X
            XX X   XXX XXX XX X  XXX  XX
           XXXXX  XX XXX XXXXXX XX X XXX
          XX   X XXXXX XXX    XXXXXXXX X
         XXX  XXXX   XXX X   XX      XXX
        XX X XX  X  XX XXX  XXX     XX X
       XXXXXXXX XX XXXXX X XX X    XXXXX
      XX      XXXXXX   XXXXXXXX   XX   X
     XXX     XX    X  XX      X  XXX  XX
    XX X    XXX   XX XXX     XX XX X XXX
   XXXXX   XX X  XXXXX X    XXXXXXXXXX X
  XX   X  XXXXX XX   XXX   XX        XXX
 XXX  XX XX   XXXX  XX X  XXX       XX X
XX X XXXXXX  XX  X XXXXX XX X      XXXXX
XXXXXX    X XXX XXXX   XXXXXX     XX   X

— केल्विन के शौक
स्रोत

मैंने इनपुट निर्दिष्ट किया है: आपके मामले में आपको इनपुट का उपयोग करना होगा () और मूल पोस्ट में निर्दिष्ट इनपुट को प्रारूपित करना होगा।

— क्यूर

5

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

एक और गणितज्ञ जवाब का उपयोग कर CellularAutomaton।

Print@@" "["X"][[#]]&/@CellularAutomaton[110,SparseArray[#+1->1&/@ImportString[InputString[],"CSV"][[1]],40],39];

— alephalpha
स्रोत

दिलचस्प है, कैसे " "["X"][[#]]&काम करता है ?

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

@ m.buettner " "["X"][[1]]है "X"। अर्थात् " "["X"][[0]]के सिर लौटाता है । " "["X"]" "

— एलेफल्फा

ओह मैं समझा। इसलिए यह आम तौर पर सूचियों के लिए एक चरित्र को बचा रहा है। यह वास्तव में चतुर है। मुझे लगता है कि आप इसे codegolf.stackexchange.com/questions/12900/… पर

— मार्टिन

4

सी - 178

यह कोड इस तथ्य पर निर्भर करता है कि मैट्रिक्स में प्रत्येक पंक्ति सन्निहित मेमोरी में संग्रहीत है। इसके अलावा, यह पहली पंक्ति को प्रिंट नहीं करता है, लेकिन यह अगले 40 लोगों को प्रिंट करता है, क्योंकि नियमों ने केवल एक 40x40 ग्रिड निर्दिष्ट किया है।

केवल पठनीयता के लिए प्रस्तुत, बाइट गिनती में केवल आवश्यक कोड शामिल हैं।

a[41][42],i,j,*t;
main(){
    while(scanf("%d,",&j)>0)
        a[i][j]=1;
    for(;i<40;i++,puts(""))
        for(j=0;++j<40;)
            t=&a[i][j],
            putchar((*(t+42)=1&(110>>(*(t+1)?1:0)+(*t?2:0)+(*(t-1)?4:0)))?88:32);
}

— Allbeert
स्रोत

3

लुआ - 351

गोल्फ के लिए आदर्श भाषा नहीं।

s,n,t,u=arg[1],{},table.remove,table.insert
for i=1,40 do u(n,i,'.') end
for i in s:gmatch("%d+")do u(n,i,'x');t(n)end
function a(b) c="";for i=1,40 do c=c..b[i] end;print(c);return c end
for i=1,40 do z= n[40]..a(n)..n[1];for k=2,41 do y=string.sub(z,k-1,k+1);if y=="xxx"or y=="x.." or y=="..." then u(n,k-1,'.')else u(n,k-1,'x')end;t(n)end end

— AndoDaan
स्रोत

1

do u(n,i,'x')यह जानबूझकर नहीं है?

— स्टेन स्ट्रम

3

हास्केल , 175 170 169 136 127 124 बाइट्स

−9 बाइट्स @bmo को धन्यवाद

t(a:b:r:_)=mod(b+r+b*r+a*b*r)2
w%a=take 40.map w.iterate a
d l=t%tail$0:l++[0]
f l=map(" #"!!)%d$(fromEnum.(`elem`l))%succ$0

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

— FrownyFrog
स्रोत

3

हास्केल , 135 131 130 बाइट्स

^{-1 बाइट थैंक्स टू अर्जन जोहान्सन (रीग्रांजिंग take 40)}

FrownyFrog के जवाब के लिए पूरी तरह से अलग दृष्टिकोण लेकिन एक ही लंबाई के बारे में:

(a?b)r=mod(b+r+b*r+a*b*r)2
r x=0:(zipWith3(?)x=<<tail$tail x++[0])
f y=take 40$map(" o"!!)<$>iterate r[sum[1|elem i y]|i<-[0..40]]

$1$

व्याख्या

$41$ $\texttt{0}$ $\texttt{1}$

f y=                               [sum[1|elem i y]|i<-[0..40]]

$40$

    take 40$              iterate r

$\texttt{0}$ $\texttt{1}$

            map(" o"!!)<$>

r $\texttt{110}$ zipWith3(?)

r x=0:(zipWith3(?)x=<<tail$tail x++[0])

(?)ऑपरेटर समाधान के सबसे दिलचस्प हिस्सा है: इससे पहले मैं एक बूलियन एक Karnaugh नक्शे के साथ उत्पन्न नियम है, लेकिन इस्तेमाल किया जाता है बाहर नहीं है और भी अधिक संक्षिप्त तरीके:

(a?b)r=mod(b+r+b*r+a*b*r)2

— ბიმო
स्रोत

1

take 40$पहले लगाकर बाइट बचाएं map(" o"!!)<$>।

— अर्जन जोहान्सन

3

भूसी , 31 28 बाइट्स

हह, हस्क जेली को पीट रहा है!

†!¨↑¨↑40¡ȯẊȯ!ḋ118ḋėΘ`:0M#ŀ40

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

स्पष्टीकरण और असंगति

स्पष्टीकरण जोड़ने से पहले, मुझे इसे थोड़ा अनफ़ॉल्ग कर दें .. आइए सबसे पहले विभिन्न रचनाओं को हटाते हैं, स्पष्ट कोष्ठक जोड़ते हैं और ¨↑¨स्ट्रिंग को अनलॉकर करते हैं । इसके अलावा अधिक पठनीय स्पष्टीकरण के 40साथ बदलें 4:

†!"t "↑4¡(Ẋ(!ḋ118ḋė)Θ`:0)M#ŀ4  -- example input: [3]
                           ŀ4  -- lower range of 4: [0,1,2,3]
                         M     -- map over left argument
                          #    -- | count in list
                               -- : [0,0,0,1]
        ¡(              )      -- iterate the following indefinitely (example with [0,1,1,1])
                     `:0       -- | append 0: [0,1,1,1,0]
                    Θ          -- | prepend 0: [0,0,1,1,1,0]
          Ẋ(       )           -- | map over adjacent triples (example with  1 1 0
                  ė            -- | | create list: [1,1,0]
                 ḋ             -- | | convert from base-2: 6
                               -- | | convert 118 to base-2: [1,1,1,0,1,1,0]
                               -- | | 1-based index: 1
                               -- | : [1,1,0,1]
                               -- : [[0,0,0,1],[0,0,1,1],[0,1,1,1],[1,1,0,1],[1,1,1,1],[1,0,0,1],...]
      ↑4                       -- take 4: [[0,0,0,1],[0,0,1,1],[0,1,1,1],[1,1,0,1]]
†                              -- deep map the following (example with [1,1,0,1])
 !"t "                         -- | use each element to index into "t ": "tt t"
                               -- : ["   t","  tt"," ttt","tt t"]

— ბიმო
स्रोत

2

जावा, 321 वर्ण

उदाहरण के लिए इनपुट कमांड लाइन से तर्क के रूप में पारित हुआ java R 38,39

मैंने कभी अधिक ओफ़्सेटेड जावा कोड नहीं लिखा है :-)

class R{public static void main(String[]a) {
Integer s=40;boolean[]n,o=new boolean[s];
for(String x:a[0].split(","))o[s.valueOf(x)]=s>0;
for(Object b:o){n=o.clone();
for(int j=0;j<s;j++){
boolean l=j>1&&o[j-1],r=o[j],c=j+1<s&&o[j+1];
n[j]=!(l&c&r|l&!c&!r|!(l|c|r));
System.out.print((r?"X":" ")+(j>s-2?"\n":""));
}o=n;}}}

— तोमाव डवोक
स्रोत

2

अद्यतन: सही उत्पादन उदाहरण यहाँ (के साथ 40 लाइनें नहीं 50): (संक्षिप्तता के लिए हटाया पिछले एक) के नीचे नया उत्पादन:

                                      xx
                                     xxx
                                    xx x
                                   xxxxx
                                  xx   x
                                 xxx  xx
                                xx x xxx
                               xxxxxxx x
                              xx     xxx
                             xxx    xx x
                            xx x   xxxxx
                           xxxxx  xx   x
                          xx   x xxx  xx
                         xxx  xxxx x xxx
                        xx x xx  xxxxx x
                       xxxxxxxx xx   xxx
                      xx      xxxx  xx x
                     xxx     xx  x xxxxx
                    xx x    xxx xxxx   x
                   xxxxx   xx xxx  x  xx
                  xx   x  xxxxx x xx xxx
                 xxx  xx xx   xxxxxxxx x
                xx x xxxxxx  xx      xxx
               xxxxxxx    x xxx     xx x
              xx     x   xxxx x    xxxxx
             xxx    xx  xx  xxx   xx   x
            xx x   xxx xxx xx x  xxx  xx
           xxxxx  xx xxx xxxxxx xx x xxx
          xx   x xxxxx xxx    xxxxxxxx x
         xxx  xxxx   xxx x   xx      xxx
        xx x xx  x  xx xxx  xxx     xx x
       xxxxxxxx xx xxxxx x xx x    xxxxx
      xx      xxxxxx   xxxxxxxx   xx   x
     xxx     xx    x  xx      x  xxx  xx
    xx x    xxx   xx xxx     xx xx x xxx
   xxxxx   xx x  xxxxx x    xxxxxxxxxx x
  xx   x  xxxxx xx   xxx   xx        xxx
 xxx  xx xx   xxxx  xx x  xxx       xx x
xx x xxxxxx  xx  x xxxxx xx x      xxxxx
xxxxxx    x xxx xxxx   xxxxxx     xx   x

एक और पहेली करते हुए मैंने php में छोरों के लिए नेस्टिंग स्टेटमेंट के बारे में कुछ दिलचस्प सीखा, और अचानक वे मूल रूप से जितना मैंने सोचा था उससे कहीं अधिक जटिल हैं। जब मुझे समय मिलता है तो मैं इस स्कोर को काफी हरा सकता हूं। अभी के लिए हालांकि यह गैर-प्रतिस्पर्धी 408 पर अपरिवर्तित है।

मेरा PHP संस्करण 408 वर्ण:

यह एक बड़ी पहेली थी। मैंने भी इनपुट के साथ खेलने में उम्र बिताई क्योंकि ये आकर्षक चीजें हैं जिन्हें यह कहा जाना चाहिए। वैसे भी, यहाँ मेरा PHP संस्करण है (जो पोस्ट किए गए उत्तरों में से कुछ के समान अच्छा है, लेकिन पूर्ण है। केवल 0 स्थिति में ऊपर और दाएं ऊपर ले जाते हैं, 39 वें स्थान पर केवल ऊपर और ऊपर बाईं ओर ले जाते हैं, अर्थात कोई लपेटन नहीं। मेरा संस्करण है:

<?php $a='38,39';$b='';$d=explode(',',$a);for($i=0;$i<40;++$i){$c=' ';
foreach($d as $k=>$v){if($v == $i){$c='x';}}$b.=$c;}echo $b."\n";
for($x=1;$x<41;++$x){$o='';for($i=1;$i<41;++$i){if(($i>1)AND(substr($b,$i-2,1)=='x')){
$l=1;}else{$l=0;}if((substr($b,$i-1,1))=='x'){$v=1;}else{$v=0;}if((substr($b,$i,1))=='x'){
$r=1;}else{$r=0;}if((($l+$v+$r)==2)OR(($v+$r)==1)){$o.='x';}else{$o.=' ';}}
echo $o."\n";$b=$o;}?>

आप इसे देख सकते हैं और इसे यहां चला सकते हैं: http://codepad.org/3905T8i8

इनपुट शुरू में एक इनपुट स्ट्रिंग है जैसा कि $ a = '38, 39 ';

आउटपुट निम्नानुसार है:

xx removed as was too long originally - had 50 lines, not 40 xx

उम्मीद है आप इसे पसंद करते हैं!!!

PS मुझे कोड में कुछ पंक्ति विराम जोड़ना था ताकि आप यह सब देख सकें और स्क्रॉल पट्टी के साथ पृष्ठ के चारों ओर खिंचाव न हो।

— पॉल ड्रियेट
स्रोत

आपके आउटपुट में 50 लाइनें हैं

— aditsu

आह, ऐसा इसलिए था क्योंकि मैं खत्म होने के बाद उसके साथ खेल रहा था और फिर क्या हुआ। नियमों को थोड़ा बदलने से इस तरह के दिलचस्प प्रभाव पड़ते हैं। वैसे भी अब इसे बदलकर 40 कर दिया गया है और इसे गायब करने के लिए खेद है।

— पॉल ड्रूयट

आप आउटपुट को बदलना चाहते हैं: p

— aditsu

आउटपुट को ठीक किया और सही मान के साथ नया कोडपैड लिंक जोड़ा। फिर से धन्यवाद।

— पॉल ड्रूयट जूल

2

स्टेक्स , 24 बाइट्स ^CP437

╦♥µ╤u{£┬íQ<;▀ΦΣ╢╕╚äZ↕áû↑

भागो और डिबग ऑनलाइन!

"1" कोशिकाओं के लिए CP437 में कोडपॉइंट 1 का उपयोग करता है।

इस भाषा की शक्ति दिखाने के लिए उत्कृष्ट मामला।

व्याख्या

समझाने के लिए अनपैक्ड संस्करण (29 बाइट्स) का उपयोग करता है।

0]40X*,1&xDQ0]|S3B{:b^374:B@m
0]40X*                           Prepare a tape with 40 cells
      ,1&                        Assign 1 to the cells specified by the input
         xD                      Repeat the rest of the program 40 times
           Q                     Output current tape
            0]|S                 Prepend and append a 0 cell to it
                3B               All runs of length 3
                  {         m    Map each run with block
                   :b            Convert from binary
                     ^           Increment (call this value `n`)
                      374:B      The binary representation of 374
                                 [1,0,1,1,1,0,1,1,0]
                                 which is `01101110` reversed and prepended a 1
                           @     Element at 0-based index `n`

— वीजुन झोउ
स्रोत

1

के (ngn / k) , 44 35 बाइट्स

{"X "39{(2\145)@2/'3'1,x,1}\^x?!40}

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

{ } तर्क के साथ कार्य करें x

!40 0 से 39 तक की सूची की सूची

x?नहीं मिला के लिए x, 0N("पूर्णांक अशक्त") में अपने सूचकांक का पता लगाएं

^उनमें से कौन से नल हैं? यह हमें इनपुट, नकारा हुआ देता है

39{ }\ 39 बार लागू करें, एक सूची में मध्यवर्ती परिणाम एकत्र करना

1,x,1 सूची को 1s (नकारात्मक 0s) से घेरें

3' लगातार वस्तुओं के triples

2/' बाइनरी डिकोड प्रत्येक

@ में सूचकांक के रूप में उपयोग करें ...

2\145 बाइनरी एनकोड 145 (110 के नकारात्मक बिट्स)

"X "अंत में, स्ट्रिंग में सूचकांक के रूप में 40x40 मैट्रिक्स का उपयोग करें "X "( @यहाँ निहित है)

— NGN
स्रोत

0

जेली , 29 बाइट्स

‘;41ṬṖŻ;0Ḅe“¢£¤¦©‘Ɗ3ƤƊ39Ð¡Yo⁶

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

— आउटग्रॉफर को एरिक करें
स्रोत

नियम 110 का अनुकरण करें

CJam - 47

रूबी, 113 वर्ण

गणितज्ञ, 122 बाइट्स

अजगर - 141

क्यू, 67 62 58 बाइट्स

पायथन, 186

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

सी - 178

लुआ - 351

हास्केल , 175 170 169 136 127 124 बाइट्स

हास्केल , 135 131 130 बाइट्स

व्याख्या

भूसी , 31 28 बाइट्स

स्पष्टीकरण और असंगति

जावा, 321 वर्ण

स्टेक्स , 24 बाइट्स CP437

व्याख्या

के (ngn / k) , 44 35 बाइट्स

जेली , 29 बाइट्स

स्टेक्स , 24 बाइट्स ^CP437