यह सर्वविदित है कि शराब के प्रभाव में एक ग्रिड पर एक व्यक्ति के पास किसी भी उपलब्ध दिशा में जाने की समान संभावना है। हालांकि, यह सामान्य ज्ञान का बयान बहुत छोटे शराबी के दायरे में नहीं होता है , जिनका व्यवहार बहुत अधिक है जैसे कि वे हर उपलब्ध पथ को एक साथ लेते हैं, और वे जो संभव रास्ते लेते हैं वे एक-दूसरे के साथ हस्तक्षेप कर सकते हैं। आपका काम nकदमों के बाद इस तरह के क्वांटम शराबी के संभावित पदों को प्रदर्शित करना है ।

विशिष्टता

प्रश्न में शराबी एक वर्ग ग्रिड पर कब्जा कर लेता है, और वॉन न्यूमैन (प्लस-आकार) पड़ोस का उपयोग करके 3-राज्य सेलुलर ऑटोमेटन माना जा सकता है जो इन सरल नियमों का पालन करता है:

Emptyको जाता है Awake, तो इसमें केवल एक ही के निकट है Awake, और अन्यथा को जाता हैEmpty
Awake जाता है Sleeping
Sleeping जाता है Sleeping

बोर्ड की प्रारंभिक स्थिति एस के Awakeअनंत क्षेत्र से घिरा एक एकल है Empty।

चुनौती

एक गैर-पूर्णांक को देखते हुए n, nचरणों के बाद शराबी का ASCII प्रतिनिधित्व बनाएं । प्रत्येक राज्य को एक अलग चरित्र द्वारा दर्शाया जाना चाहिए, और समाधान यह बताना चाहिए कि कौन सा चरित्र किस राज्य का अर्थ है। यदि आप रिक्त स्थान का उपयोग करते हैं Empty, तो आपको एक पंक्ति के अंत में उनमें से एक रन को शामिल करने की आवश्यकता नहीं है।

यह कोड-गोल्फ है , इसलिए सबसे कम उत्तर जीतता है। मानक कमियां लागू होती हैं, अग्रणी और अनुगामी व्हाट्सएप की अनुमति दी जाती है, स्ट्रिंग सरणी / 2 डी चार सरणी आउटपुट की अनुमति है, आदि।

उदाहरण

इन उदाहरणों का उपयोग के लिए Empty, @के लिए Awake, और #के लिए Sleeping।

n=0
@

n = 1
 @
@#@
 @

n = 2
  @
  #
@###@
  #
  @

n = 3
   @
  @#@
 @ # @
@#####@
 @ # @
  @#@
   @

n=6

      @
      # 
    @###@
     @#@  
  @  ###  @
  #@# # #@#
@###########@
  #@# # #@#
  @  ###  @
     @#@
    @###@
      #
      @

n=10
          @
          #
        @###@
         @#@
         ###
        # # #
       #######
      #  ###  #
  @  ##  ###  ##  @
  #@# ### # ### #@#
@###################@
  #@# ### # ### #@#
  @  ##  ###  ##  @
      #  ###  #
       #######
        # # #
         ###
         @#@
        @###@
          #
          @

दिलचस्प नोट

OEIS में व्याप्त कोशिकाओं की संख्या के अनुक्रम को देखने से, मैंने पाया कि क्वांटम शराबी बहुत बेहतर अध्ययन किए गए टूथपिक अनुक्रम में आइसोमोर्फिक है । यदि आप उस ज्ञान को एक बेहतर गोल्फ में शामिल कर सकते हैं, तो मैं उपयुक्त रूप से प्रभावित होगा।

code-golf ascii-art cellular-automata

— stellatedHexahedron
स्रोत

1

क्या आप यह सत्यापित करने के लिए जांच कर सकते हैं कि आपका मामला n=10सही है? मैंने कुछ तरीकों की कोशिश की है और वे सभी एक ही (गलत) उत्तर प्राप्त करते हैं, इसलिए मैं सिर्फ यह सुनिश्चित करना चाहता हूं। यह थोड़ा दूर लगता है लेकिन मुझे नहीं पता।

— हाइपरन्यूट्रिनो

4

@HyperNeutrino मैं आप कर सकते हैं एक बेहतर

— stellatedHexahedron

1

क्या एक आयामी चार सरणी की अनुमति है?

— जोनाथन फ्रेच

4

पहली बड़ी चुनौती, BTW!

— लुइस मेन्डो

1

@ PM2Ring मान्य है। मेरी पुस्तक में एक देशी सरणी के रूप में एक सुन्न सरणी गिना जाता है

— stellatedHexahedron

34

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 92 91 बाइट्स

Print@@@CellularAutomaton[{7049487784884,{3,{a={0,3,0},3-2a/3,a}},{1,1}},{j={{1}},0},{j#}]&

गणितज्ञ के बिलिन का उपयोग करने के लिए एक सही चुनौती CellularAutomaton!

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

खाली = ०, जाग = १, सो = २

पहले 256 पुनरावृत्तियों (सफेद = खाली, ग्रे = जाग, काला = शयन) का एनीमेशन:

व्याख्या

CellularAutomaton[ ... ]

CellularAutomatonविनिर्देशों के साथ चलाएं ...

{7049487784884,{3,{a={0,3,0},3-2a/3,a}},{1,1}}

3-रंग समग्र नियम 7049487784884, वॉन न्यूमैन पड़ोस के साथ लागू करें ...

{j={{1}},0}

बीच में एक 1 के साथ एक बोर्ड पर, 0 की पृष्ठभूमि के साथ ...

{j#}

दोहराएँ <input>बार ( {j#}करने के लिए मूल्यांकन करता है {{{#}}})। सरणी स्वचालित रूप से फैलती है अगर सीमा के बाहर एक सेल पृष्ठभूमि के समान नहीं है

7049487784884

यह नियम आधार -3 संख्या से आता है 220221220221220221220221220, जिसका अर्थ है "सभी को बदलना 1या बदलना, और यदि केवल इसके आस-पास विषम संख्या में है तो बदल जाना ।"22011

Print@@@

सरणी मुद्रित करें।

"'विषम `1`s' का अर्ध-प्रमाण 'ठीक एक `1`' के बराबर है :"

पिक्सल के इस 5x5 ग्रिड पर विचार करें। व्हाइट एक 0या एक 2सेल (गैर-जागृत पिक्सेल) है, और ग्रे एक 1सेल है।

यदि एक 1सेल तीन 0कोशिकाओं के आसपास उत्पन्न हुई थी , तो ग्रिड को इस तरह दिखना चाहिए: यह 1एक यू-आकार (या एक घुमाए गए संस्करण) में तीन एस की व्यवस्था इस प्रकार है:

इस सेलुलर ऑटोमेटन की आत्म-समानता के कारण, सेलुलर ऑटोमेटन में दिखाई देने वाला कोई भी पैटर्न विकर्ण (प्रेरण द्वारा) पर दिखाई देना चाहिए। हालांकि, यह पैटर्न तिरछे सममित नहीं है। यानी यह विकर्ण पर नहीं हो सकता है और सेलुलर ऑटोमेटन पर कहीं भी दिखाई नहीं दे सकता है।

जागना / सोना बराबर है

ध्यान दें कि एक 0सेल ठीक एक या तीन 2कोशिकाओं और बाकी 0कोशिकाओं से घिरा नहीं हो सकता है , क्योंकि इसका मतलब यह होगा कि कुछ कदम पहले, सेल में एक या तीन 1कोशिकाओं का पड़ोसी था - और 1पहले से ही (विरोधाभास) में बदल गया होगा । इसलिए, यह के बीच भेद की अनदेखी के लिए ठीक है 1और 2और राज्य 'सभी को बदलने 1के लिए 1, और एक 0एक को 1तभी यह अशून्य पड़ोसियों के एक विषम संख्या है या नहीं।'

परिणामस्वरूप सेलुलर ऑटोमेटन वास्तव में मूल के समान है, केवल अंतर यह है कि "जाग" और "सो" शराबी के बीच कोई अंतर नहीं है। यह पैटर्न OEIS A169707 में वर्णित है ।

Print@@@CellularAutomaton[{750,{2,{a={0,2,0},2-a/2,a}},{1,1}},{j={{1}},0},{j#}]&

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

पहले 16 पुनरावृत्तियों की साइड-बाय-साइड तुलना:

लगातार दो पुनरावृत्तियों को जोड़ने से एक परिणाम प्राप्त होता है जो चुनौती चश्मा (94 बाइट्स) का अनुसरण करता है:

Print@@@Plus@@CellularAutomaton[{750,{2,{a={0,2,0},2-a/2,a}},{1,1}},{{{1}},0},{Ramp@{#-1,#}}]&

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

— जंगहवान मिन
स्रोत

11

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

x=input()
o=c={x+x*1j}
R=range(x-~x)
exec"n=[C+k for k in-1j,1j,-1,1for C in c];n={k for k in n if(k in o)<2-n.count(k)};o|=c;c=n;"*x
print[[`(X+Y*1jin c)+(X+Y*1jin o|c)`for Y in R]for X in R]

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

-17 बाइट्स धन्यवाद
जोनाथन के आउटपुट फॉर्मेट
-11 बाइट्स का उपयोग करते हुए मिस्टर एक्सकोडर -9 बाइट्स के लिए धन्यवाद।
-3 बाइट्स के लिए धन्यवाद लिन -3 बाइट्स ओव्स के लिए धन्यवाद

— HyperNeutrino
स्रोत

एक पूर्ण प्रोग्राम पर स्विच करना जहां आप exec9 बाइट्स बचा सकते हैं , और …for k in 0,1,2,3for…एक और बचाते हैं: लिंक

— लिन

1

दरअसल, n=[C+k for k in-1j,1j,-1,1for C in c]एक और बाइट बचाता है!

— लिन

1

... ठीक है, मुझे मानना होगा X+Y*1jinकि मैं वास्तव में संभव नहीं था कुछ ऐसा है: P

— ETHproductions

1

@ETHproductions मुझे उम्मीद नहीं थी कि यह या तो काम करेगा, लेकिन मैं ऐसा था "अरे आप पहचानकर्ता / कीवर्ड से पहले एक नंबर के बाद रिक्त स्थान निकाल सकते हैं, अगर यह लालच से मेल खाता है जैसे कि यह जटिल संख्याओं के साथ काम करेगा ?: डी पायथन आश्चर्यजनक है:"

— हाइपरएनुट्रीनो

10

C, 360 354 343 319

#define A(i,b,e)for(int i=b;i<e;++i)
#define B(b,e)A(r,b,e){A(c,b,e)
#define W(n)(n<0?-(n):n)
#define C(r,c)b[W(r)*s+W(c)]
#define D C(r,c)

q(n){char N,s=n+2,(*b)[2]=calloc(s,2*s);C(0,0)
[1]=1;A(g,0,n+1){B(0,s)*D=D[1];}B(0,g+2){N=(*C
(r-1,c)+*C(r+1,c)+*C(r,c-1)+*C(r,c+1))&1;D[1]=
*D?2:N;}}}B(2-s,s-1)putchar(*D+32);puts("");}}

गैर- #defineलाइनों के बाद की नई लाइनें केवल यहां प्रस्तुति के लिए हैं, इसलिए उनकी गिनती नहीं की जाती है। मैंने एक रैपर फ़ंक्शन शामिल किया है, इसलिए यह −6 (313) है यदि फ़ंक्शन की गणना नहीं की गई है और आप मान लेते हैं कि nकहीं और से आता है। q(10)आउटपुट:

          !          
          "          
        !"""!        
         !"!         
         """         
        " " "        
       """""""       
      "  """  "      
  !  ""  """  ""  !  
  "!" """ " """ "!"  
!"""""""""""""""""""!
  "!" """ " """ "!"  
  !  ""  """  ""  !  
      "  """  "      
       """""""       
        " " "        
         """         
         !"!         
        !"""!        
          "          
          !

का उपयोग करते हुए खाली के लिए, "सो, और के लिए !जाग लिए।

यह इस तरह काम करता है:

A(i,b,e)"”i“ [b, e)। ", B(b,e)" ∈r b [b, e) .∀c e [b, e) "है।
ध्यान दें कि n पीढ़ियों के बाद , बोर्ड 2 n + 1 वर्ग है।
बोर्ड की समरूपता के कारण, यह केवल निचले दाएं चतुर्भुज का अनुकरण करने की आवश्यकता है, इसलिए हम बाद के पड़ोसी लुकअप (इसलिए n + 2) के लिए 1 पंक्ति और स्तंभ के साथ एक n + 1 वर्ग मैट्रिक्स आवंटित करते हैं ।
साथ आवंटन callocहमें एक साथ ऊंचाई से चौड़ाई गुणा और करने के लिए बोर्ड साफ़ करने देता है 0(खाली)।
जब अपने निर्देशांक ( Cऔर D) द्वारा एक सेल को देखते हैं , तो यह Wस्वचालित रूप से निर्देशांक को दर्पण करने के लिए पंक्ति और स्तंभ ( ) के निरपेक्ष मान का उपयोग करता है ।
बोर्ड को वर्तमान और पिछली पीढ़ी का प्रतिनिधित्व करने वाले पूर्णांकों के जोड़े के एक सरणी के रूप में संग्रहीत किया जाता है। प्रश्न में पूर्णांक हैं charइसलिए हम बच सकते हैं sizeof।
पीढ़ी को सबसे अधिक बार देखा गया (पड़ोसी परीक्षण द्वारा) पिछली पीढ़ी है, इसलिए इसे जोड़ी में सूचकांक 0 पर रखा गया है ताकि इसके साथ पहुँचा जा सके *।
प्रत्येक पीढ़ी ( g) में, वर्तमान पीढ़ी को पिछली पीढ़ी में एक Bलूप का उपयोग करके कॉपी किया जाता है , फिर नई पीढ़ी पुरानी से उत्पन्न होती है।
प्रत्येक कोशिका को 0खाली, 1जागने के 2लिए और सोने के लिए उपयोग किया जाता है । पड़ोसियों की गणना मूल रूप से सेल के कम 4 बिट्स में सेट बिट्स की संख्या की गणना थी जब 4 पड़ोसियों को स्थानांतरित किया जाता है और उन्हें एक साथ झंडे ( N) के रूप में, 16सोने के लिए उपयोग किया जाता है। लेकिन इस अवलोकन के साथ कि पड़ोसियों की एक विषम संख्या ठीक 1 पड़ोसी के बराबर है, हम सिर्फ 1 के साथ मुखौटा का उपयोग करके कई पात्रों को बचा सकते हैं।
अंत में, बोर्ड एक ही निरपेक्ष मान समन्वय चाल का उपयोग करके निचले दाएं चतुर्थांश पर पुनरावृत्ति करके पूर्ण रूप से मुद्रित किया जाता है, ताकि हम बोर्ड पर बाहरी पैडिंग को प्रिंट न करें। यही कारण है कि Bलूप में एक उद्घाटन घुंघराले ब्रैकेट शामिल है, क्योंकि हमारे पास बाहरी लूप में अतिरिक्त न्यूलाइन स्टेटमेंट है।
ASCII कोड आसानी से एक स्थान पर 0 + 32 (खाली), 2 + 32 (नींद) ", और 1 + 32 (जागने) के लिए मैप करते हैं !।

सब सब मुझे लगता है कि यह समस्या की अच्छी संरचना के कारण आश्चर्यजनक रूप से पठनीय गोल्फ है।

— जॉन पंडी
स्रोत

वाह। टिनी बात है, लेकिन मुझे लगता है कि आप गुणा के साथ और बदलाव की जगह कुछ और बाइट्स बचा सकता है putchar(10)के साथputs("")

— undercat

1

@undercat: धन्यवाद! जवाब में जोड़ा गया। कभी-कभी मैं कुछ चीजों को कम करने पर ध्यान केंद्रित करता हूं ताकि मैं अन्य जीत को याद करूं जो स्पष्ट है जैसे ही कोई उन्हें इंगित करता है।

— जॉन पूर्डी

343 बाइट्स ।

— जोनाथन फ्रेच

@JonathanFrech: धन्यवाद, जोड़ा गया। मैं भूल गया कि पड़ोसियों की गिनती एक नंद का उपयोग कर सकती है।

— जॉन पूर्डी

@JonathanFrech: क्षमा करें, मुझे लगता है कि स्पष्ट नहीं था। &~एक नंद नहीं है, मेरा मतलब है कि मैं कभी-कभी के !(a &~ b)संदर्भ में सोचता हूं a NAND (NOT b), हालांकि इस मामले में तार्किक !बिटवाइज़ के समान नहीं है ~क्योंकि हम 0या उसके 1परिणाम पर भरोसा कर रहे हैं !।

— जॉन पुरडी

6

MATL , 39 बाइट्स

QtE:=&*G:"tt0=w1Y6Z+Xj1=*w|gJ*+]Q|U31+c

यह प्रदर्शित करता है

Emptyके रूप में (अंतरिक्ष)
Awake जैसा #
Sleepingके रूप में !।

इसे ऑनलाइन आज़माएं! आप यह भी देख सकते हैं पैटर्न बढ़ने ASCII आर्ट में, या रेखांकन (संशोधित कोड)।

व्याख्या

कोड जटिल संख्याओं का उपयोग करता है 0, 1, jतीन राज्यों का प्रतिनिधित्व करने के लिए:, खाली, वेक क्रमशः सो।

Q         % Implicitly input n. Add 1
tE        % Duplicate and multiply by 2
:         % Range [1 2 ... 2*n]
=         % Test for equalty. Gives [0 ... 0 1 0... 0], with 1 at position n
&*        % Matrix of all pairwise products. Gives square matrix of size 2*n
          % filled with 0, except a 1 at position (n,n). This is the grid
          % where the walk will take place, initiallized with an awake cell
          % (value 1). The grid is 1 column and row too large (which saves a
          % byte)
G:"       % Do n times
  tt      %   Duplicate current grid state twice
  0=      %   Compare each entry with 0. Gives true for empty cells, false
          %   for the rest
  w       %   Swap: moves copy of current grid state to top
  1Y6     %   Push 3×3 matrix with Von Neumann's neighbourhood
  Z+      %   2D convolution, maintaining size
  Xj      %   Real part
  1=      %   Compare each entry with 1. This gives true for cells that
          %   have exactly 1 awake neighbour
  *       %   Multiply, element-wise. This corresponds to logical "and": 
          %   cells that are currently empty and have exactly one awake
          %   neighbour. These become 1, that is, awake
  w       %   Swap: moves copy of current grid state to top
  |g      %   Absolute value, convert to logical: gives true for awake or
          %   sleeping cells, false for empty cells
  J*+     %   Mulltiply by j and add, element-wise. This sets awake and 
          %   sleeping cells to sleeping. The grid is now in its new state
]         % End
Q         % Add 1, element-wise. Transforms empty, awake, sleeping 
          % respectively from 0, 1, j into 1, 2, 1+j
|U        % Abolute value and square, element-wose. Empty, awake, sleeping 
          % respectively give 1, 4, 2
31+c      % Add 31 element-wise and convert to char. Empty, awake, sleeping 
          % respectively give characters ' ' (codepoint 32), '#' (codepoint 
          % 35) and '!' (codepoint 33). Implicitly display

— लुइस मेंडो
स्रोत

5

Befunge, 384 304 बाइट्स

&:00p->55+,000g->>00g30p:40p\:50p\5>>40g!50g!*vv0g05g04p03-<
@,+55_^#`g00:+1$_^>p:4+4g5%2-50g+5#^0#+p#1<v03_>30g:!#v_:1>^
#v_>$99g,1+:00g`^ ^04+g04-2%5g4:\g05\g04\p<>g!45*9+*3+v>p:5-
 >\50p\40p\30p:#v_>>0\99g48*`!>v >30g:1-30^>>**\!>#v_>v^9 9<
$0\\\\0$        >\99g88*-!+\:4->#^_\>1-!48>^       >$3>48*+^

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

Befunge में इस तरह की चीज़ को लागू करने की कोशिश के साथ समस्या सीमित मेमोरी साइज़ (डेटा और कोड दोनों के लिए 2000 बाइट्स) है। इसलिए मुझे एक एल्गोरिथ्म का उपयोग करना होगा जो पिछले गणना के संदर्भ के बिना किसी भी समन्वय के लिए सही चरित्र की गणना करता है। यह उस समय तक पुन: प्राप्त करता है जब सभी संभावित रास्तों पर समय के साथ पीछे मुड़कर देखा जा सकता है।

दुर्भाग्य से यह एक विशेष कुशल समाधान नहीं है। यह काम करता है, लेकिन यह अविश्वसनीय रूप से धीमा है, और यह तेजी से n के मूल्य को धीमा कर देता है । जब तक यह संभावित रूप से लगभग 127 (Befunge की 7-बिट मेमोरी सेल सीमा) के लिए किसी भी एन के लिए काम कर सकता है , व्यवहार में आप अनिवार्य रूप से परिणाम के लिए इंतजार कर ब्याज खो देंगे। TIO पर, यह लगभग 6 (सबसे अच्छा) की तुलना में कुछ भी अधिक पर 60 सेकंड का समय देगा। एक कंपाइलर बहुत बेहतर करेगा, लेकिन फिर भी आप शायद 10 से ज्यादा नहीं जाना चाहेंगे।

फिर भी, मुझे लगा कि यह प्रस्तुत करने के लायक था क्योंकि यह वास्तव में Befunge में एक पुनरावर्ती "फ़ंक्शन" का काफी अच्छा प्रदर्शन है।

— जेम्स होल्डरनेस
स्रोत

4

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

def f(n):k=n-~n;N=k*k;A=[0]*N;A[N/2]=2;exec"A=[[2*([j%k>0and A[j-1],j%k<k-1and A[j+1],j/k>0and A[j-k],j/k<k-1and A[j+k]].count(2)==1),1,1][v]for j,v in enumerate(A)];"*n;print[map(str,A)[k*x:][:k]for x in range(k)]

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

व्याख्या

के 0लिए empty, के 1लिए sleepingऔर के 2लिए उपयोग करता है awake। दो-आयामी चरित्र (एक-लंबाई के तार) की सूची प्रिंट करता है।
एक फ़ंक्शन को परिभाषित करता है जो एक गैर-नकारात्मक पूर्णांक में लेता है n। जब तक वांछित स्थिति तक नहीं पहुंच जाता है तब तक सेलुलर ऑटोमोबोन को सफलतापूर्वक आगे बढ़ाता है। अंत में, आंतरिक पूर्णांक मान और वास्तविक वर्णों के बीच रूपांतरण लागू होता है।

— जोनाथन फ्रेच
स्रोत

4

लुआ , 251 242 239 238 बाइट्स

-8 बाइट्स कुछ अतिरिक्त अग्रणी व्हाट्सएप की कीमत पर सरणी इनिशियलाइज़र को सरल बनाकर। में
बदलकर -1 बाइट । -3 बाइट्स को पहले एक पूरी स्ट्रिंग बनाकर और अंत में एक बार प्रिंट करके। के रूप में फिर से लिखना द्वारा जोनाथन फ्रेच को -1 बाइट धन्यवाद ।c=i==2+...and print(s)c=i~=2+...or print(s)

or(g(...)==1 andor(1==g(...)and

function g(x,y)return(a[x]or{})[y]or 0 end a={{1}}for i=2,2+...do n={}s=""for x=-i,i do n[x]=n[x]or{}q=a[x]or{}for y=-i,i do n[x][y]=q[y]and 0or(1==g(x+1,y)+g(x,y+1)+g(x-1,y)+g(x,y-1)and 1)s=s..(q[y]or" ")end s=s.."\n"end a=n end print(s)

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

खाली = अंतरिक्ष
जागना = 1
नींद आना0

कमांड लाइन से इनपुट लेता है और स्टडआउट पर प्रिंट करता है।

के रूप में राज्यों का प्रतिनिधित्व करने से false/ nil, 1और 0आंतरिक रूप से, का पता लगाने "खाली" किसी भी कोड की जरूरत नहीं है और "ठीक एक जाग" चेक सिर्फ एक अतिरिक्त के साथ किया जा सकता है।

— जोनाथन एस।
स्रोत

मुझे लगता है कि or(g(...)==1 andहो सकता है or(1==g(...)and।

— जोनाथन फ्रेच

4

APL (Dyalog) , 38 बाइट्स

((2∘∧⌈1={2⊃+/1=⍵,⍉⍵}⌺3 3)(⌽0,⍉)⍣4)⍣⎕⍪1

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

-4 Adám को धन्यवाद ।
-8 ngn के लिए धन्यवाद ।

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

आइए हम इस चर्चा को चैट में जारी रखते हैं ।

— 11

4

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

-,1ṙ@€Sµ+Z
‘ṬŒḄ×þ`µÇ×¬Ḃ+Ḃ+µ³¡

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

का उपयोग करता है 0, 1और 2खाली जाग और सोने के लिए। लिंक में पाद लेख को यह धर्मान्तरित , @और #।

के ṬŒḄबजाय का उपयोग करके -1 बाइट ḤḶ=¹।
के -बजाय का उपयोग करके -2 बाइट्स 1N। ¤अनावश्यक भी बनाता है ।
के Sबजाय का उपयोग करके -1 बाइट +/।
के Ḃ+Ḃ+बजाय का उपयोग करके -6 बाइट्स %3=1+=1Ḥ$+। अब 2इसके बजाय सोने के लिए उपयोग करता है 3।

स्पष्टीकरण आ रहा है ...

— dylnan
स्रोत

4

APL (Dyalog Classic) , 38 बाइट्स

((2∘∧⌈2|⍉∘g∘⍉+g←3+/0,,∘0)(⌽0,⍉)⍣4)⍣⎕⍪1

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

एरिक आउटगोलर के समाधान पर आधारित है

⍪1 1x1 मैट्रिक्स वाला 1 है

⎕ eval'ed इनपुट

( )⍣⎕ कई बार लागू करें

(⌽0,⍉)⍣40s के साथ घेरें, जो कि 4 गुना है: ट्रांज़ोज़ ( ⍉), बाईं ओर 0s जोड़ें ( 0,), क्षैतिज रूप से रिवर्स करें ( ⌽)
g←3+/0,,∘0 एक फ़ंक्शन जो क्षैतिज त्रिगुणों को बोता है, उसे कॉल करें g
⍉∘g∘⍉एक फ़ंक्शन जो ऊर्ध्वाधर त्रिकोणीय को बोता है - जो gट्रांसपोज़िशन के तहत है
2 | ⍉∘g∘⍉ + g←3+/0,,∘0 दो राशियों का योग modulo 2
⌈ उस के बीच और अधिक से अधिक ...
2∘∧ 2 और मूल मैट्रिक्स का LCM - यह 1s 2s में बदल जाता है, जबकि 0s और 2s का संरक्षण होता है

— NGN
स्रोत

3

पर्ल 5 , 192 + 1 ( `-n`) = 193 बाइट्स

for$i(1..2*$_+1){push@a,[()x$_]}$a[$_][$_]=1;map{@b=();for$i(0..$#a){map$b[$i][$_]=$a[$i][$_]?2:$a[$i-1][$_]+($_&&$a[$i][$_-1])+$a[$i+1][$_]+$a[$i][$_+1]==1?1:0,0..$#a}@a=@b}1..$_;say@$_ for@a

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

खाली के लिए 0 का उपयोग करता है, जागने के लिए 1 और सो के लिए 2 का उपयोग करता है।

— Xcali
स्रोत

3

रूबी , ₁₆₄ 153 बाइट्स

->n{(r=([e=' ']*(l=2*n+1)<<"
")*l)[n+n*l+=1]=a=?@
n.times{r=r.map.with_index{|c,i|c==a ??#:c==e ?r.values_at(i-1,i+1,i-l,i+l).one?{|v|v==a}?a:e:c}}
r*""}

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

जागने के लिए "" खाली के लिए, "@" का उपयोग करता है, और नींद के लिए "#" (उदाहरण के रूप में)। मैं संख्याओं का उपयोग करके 6 बाइट्स बचा सकता था, मुझे लगता है, लेकिन यह इस तरह बेहतर दिखता है।

— iamnotmaynard
स्रोत

2

पिप , 69 61 बाइट्स

-lध्वज के लिए कोड के 60 बाइट्स, +1 ।

YZG2*a+1y@a@a:1LaY{y@a@b?2oN(y@(a+_)@(b+B)MP[0o0v0])=1}MC#yy

nकमांड-लाइन तर्क के रूप में लेता है। 0खाली करने के लिए, 1जागने के लिए, और 2सोने के लिए उपयोग करता है । (चुनौती के उदाहरणों के रूप में अच्छे ASCII- कला प्राप्त करने के लिए, अंतिम के yसाथ बदलें " @#"@y।)

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

व्याख्या

सेट अप:

YZG2*a+1y@a@a:1

                 Implicit: a is 1st cmdline arg; o is 1; v is -1
 ZG2*a+1         Square grid (i.e. nested list) of 0's, with side length 2*a+1
Y                Yank into y variable
        y@a@a:1  Set the element at coordinates (a,a) to 1

मुख्य घेरा:

LaY{...}MC#y

La            Loop (a) times:
          #y  Len(y) (i.e. 2*a+1)
   {   }MC    Map this function to the coordinate pairs in a 2*a+1 by 2*a+1 grid
  Y           and yank the resulting nested list back into y

जहां फ़ंक्शन बॉडी है:

y@a@b?2oN(y@(a+_)@(b+B)MP[0o0v0])=1

                                     The function args, representing the coords of the
                                     current cell, are a and b
y@a@b?                               Is the cell at these coords 0 or nonzero?
      2                              If nonzero (1 or 2), make it 2
                                     Else, if zero, we need to check the neighbors
                         [0o0v0]     List of [0; 1; 0; -1; 0]
                       MP            Map this function to each adjacent pair of values--
                                     i.e. call it four times with args (0; 1), (1; 0),
                                     (0; -1), and (-1; 0)
          y                           Index into the grid using
           @(a+_)                     a + the 1st item in the pair as the row and
                 @(b+B)               b + the 2nd item in the pair as the column
                                     The result of MP is a list of the values of the cells
                                     in the Von Neumann neighborhood
       oN(                      )    Get the number of 1's in that list
                                 =1  and test if it equals 1
                                     If so, the new value of this cell is 1; if not, it's 0

पाश के बाद, हम बस autoprint y। -lझंडा मतलब यह है कि नेस्टेड सूची प्रत्येक पंक्ति की सामग्री श्रृंखलाबद्ध और नई-पंक्तियों के साथ पंक्तियों को अलग करके छपा है।

— DLosc
स्रोत

2

जावा (ओपनजेडके 8) , 220 बाइट्स

n->{int s=n*2+3,i=0,x,y;char[][]a=new char[s][s],b;for(a[s/2][s--/2]=61;i++<n;a=b)for(b=new char[s+1][s+1],x=0;++x<s;)for(y=0;++y<s;)b[x][y]=a[x][y]>32?'0':(a[x][y-1]+a[x][y+1]+a[x-1][y]+a[x+1][y])%8==5?61:' ';return a;}

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

नोट: सरणी में एक सीमा या '\0'वर्ण हैं। चूंकि विमान अनंत माना जाता है, केवल गैर-सीमा का उपयोग किया जाता है।

चरित्र मानचित्रण:

खाली: (स्थान)
जाग: =
सोया हुआ: 0

बचाता है

29 बाइट्स ने जोनाथन एस को धन्यवाद दिया।
9 और बाइट्स ने जोनाथन एस को धन्यवाद दिया कि वे दूसरों के साथ चरित्रों की अदला-बदली करते हैं और "प्राइम्स और मॉड्यूलर अंकगणित के साथ जादू करते हैं"

— ओलिवियर ग्रेजायर
स्रोत

1

229 बाइट्स।

— जोनाथन एस।

धन्यवाद @JonathanS। मैं अपने @-चेक को सुधारने में वास्तव में बहुत कठिन लग रहा था , और आपको कुंजी मिल गई! अच्छा लगा। char-Cast मुझ से एक कुल निरीक्षण किया गया था।

— ओलिवियर ग्रेजायर

1

Primes और मॉड्यूलर अंकगणित के साथ जादू करके 220 बाइट्स ।

— जोनाथन एस।

यह बहुत अच्छी सोच है!

— ओलिवियर ग्रेजायर

1

धन्यवाद! मुझे सिर्फ एक प्रीटियर संस्करण मिला है जो कि 220 बाइट्स, अलग-अलग मापांक है।

— जोनाथन एस।

2

पायथन, 199 192 बाइट्स

यह कोड Python 2 और Python 3 दोनों पर चलता है, लेकिन यह सरणी को संभालने के लिए लोकप्रिय 3rd-पार्टी Numpy लाइब्रेरी का उपयोग करता है।

from numpy import*
def f(n):
 m=2*n+1;g=zeros((m+2,)*2,'i');g[n+1,n+1]=1
 while n:a=g[1:-1,1:-1];a[:]=(a<1)*(sum(g[r:r+m,c:c+m]&1for r,c in((0,1),(1,0),(1,2),(2,1)))==1)+(a>0)*2;n-=1
 return g

खाली = ०
जागना = १
सोना = २

print(f(6)) आउटपुट

[[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 1 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 2 0 0 0 0 0 0 0]
 [0 0 0 0 0 1 2 2 2 1 0 0 0 0 0]
 [0 0 0 0 0 0 1 2 1 0 0 0 0 0 0]
 [0 0 0 1 0 0 2 2 2 0 0 1 0 0 0]
 [0 0 0 2 1 2 0 2 0 2 1 2 0 0 0]
 [0 1 2 2 2 2 2 2 2 2 2 2 2 1 0]
 [0 0 0 2 1 2 0 2 0 2 1 2 0 0 0]
 [0 0 0 1 0 0 2 2 2 0 0 1 0 0 0]
 [0 0 0 0 0 0 1 2 1 0 0 0 0 0 0]
 [0 0 0 0 0 1 2 2 2 1 0 0 0 0 0]
 [0 0 0 0 0 0 0 2 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 1 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]]

यदि आप प्रिटियर प्रिंटिंग चाहते हैं, तो आप इसे इस तरह से कॉल कर सकते हैं:

n=6;print('\n'.join(''.join(' @#'[v]for v in u)for u in f(n)))

जो प्रश्न में दिए गए समान वर्णों का उपयोग करता है।

— दोपहर 2 बजे
स्रोत

मुझे नहीं पता कि एक पूर्णांक मैट्रिक्स को ouputting की अनुमति है, के रूप में [e]ach state should be represented by a different character(मैं characterएक पूर्णांक के बजाय एक वास्तविक ASCII चरित्र के रूप में व्याख्या करता हूं )।

— जोनाथन फ्रेच

@JonathanFrech फेयर कॉल। मैं ओपी से पूछूंगा।

— PM 2Ring

क्वांटम ड्रंकर्ड वॉक

विशिष्टता

चुनौती

उदाहरण

दिलचस्प नोट

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 92 91 बाइट्स

व्याख्या

"'विषम 1s' का अर्ध-प्रमाण 'ठीक एक 1' के बराबर है :"

जागना / सोना बराबर है

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

C, 360 354 343 319

MATL , 39 बाइट्स

व्याख्या

Befunge, 384 304 बाइट्स

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

व्याख्या

लुआ , 251 242 239 238 बाइट्स

APL (Dyalog) , 38 बाइट्स

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

APL (Dyalog Classic) , 38 बाइट्स

पर्ल 5 , 192 + 1 ( -n) = 193 बाइट्स

रूबी , 164 153 बाइट्स

पिप , 69 61 बाइट्स

व्याख्या

जावा (ओपनजेडके 8) , 220 बाइट्स

बचाता है

पायथन, 199 192 बाइट्स

"'विषम `1`s' का अर्ध-प्रमाण 'ठीक एक `1`' के बराबर है :"

पर्ल 5 , 192 + 1 ( `-n`) = 193 बाइट्स

रूबी , ₁₆₄ 153 बाइट्स