बैक्टीरियल विस्तार

25

जीवाणुओं की कॉलोनियों को समान रूप से रिक्त कोशिकाओं के एक सेगमेंट पर लाइव के 1माध्यम से लेबल किया जाता है 9, जिनके द्वारा संकेतित खाली कोशिकाएं होती हैं0

0 0 2 0 0 0 1 2 0 0 3 3 0 0

प्रत्येक सेकंड, प्रत्येक कॉलोनी आसन्न खाली कोशिकाओं में फैलती है। यदि एक ही समय में दो कॉलोनी एक खाली सेल तक पहुंचती हैं, तो बड़ी लेबल वाली कॉलोनी इसे ले जाती है।

t=0:  0 0 2 0 0 0 1 2 0 0 3 3 0 0
t=1:  0 2 2 2 0 1 1 2 2 3 3 3 3 0
t=2:  2 2 2 2 2 1 1 2 2 3 3 3 3 3

कालोनियां सीमाओं से बाहर नहीं फैल सकती हैं। एक कॉलोनी दूसरे कॉलोनी द्वारा कभी विस्थापित नहीं की जाती है, इसलिए एक बार सभी खाली कोशिकाओं को भर देने के बाद, कुछ भी नहीं बदलता है।

प्रारंभिक अवस्था को देखते हुए, आउटपुट या अंतिम स्थिति प्रिंट करें। किसी भी उचित सूची या स्ट्रिंग प्रारूप का उपयोग करें। आपको किसी भी मध्यवर्ती राज्यों का उत्पादन नहीं करना चाहिए। इनपुट में कम से कम एक जीवाणु कॉलोनी होगी।

संबंधित: एक सूची में शून्य को कवर करें । (उपनिवेश केवल दाईं ओर फैलते हैं।)

परीक्षण के मामले: इनपुट के नीचे आउटपुट।

0 0 2 0 0 0 1 2 0 0 3 3 0 0
2 2 2 2 2 1 1 2 2 3 3 3 3 3

7 0 3 0 0 0 0 0 8 0 9 1
7 7 3 3 3 8 8 8 8 9 9 1

5 0 3 0 0 0
5 5 3 3 3 3

7 7 1
7 7 1

1 0 1
1 1 1

कोड स्निपेट दिखाएं

code-golf  cellular-automata 
— XNOR
स्रोत

जवाबों:

14

जावास्क्रिप्ट (ईएस 6), 66 62 बाइट्स

a=>a.map(_=>a=a.map((c,i)=>c||Math.max(a[i-1]|0,a[i+1]|0)))&&a

व्याख्या

a=>                 // a = input as array of numbers
  a.map(_=>         // loop for the length of a, this ensures the end is always reached
    a=a.map((c,i)=> // update a after to the result of t, for each cell c of index i
      c||           // keep the cell if it is not 0
        Math.max(   // else set the cell to the max value of:
          a[i-1]|0, //     the previous cell (or 0 if i - 1 less than 0),
          a[i+1]|0  //     or the next cell (or 0 if i + 1 greater than the length of a)
        )
    )
  )
  &&a               // return a

परीक्षा

कोड स्निपेट दिखाएं

— user81655
स्रोत
10

पायथ, 18 बाइट्स

um|@d1eSd.:++0G03Q

परीक्षण सूट

पूर्णांकों की सूची के रूप में इनपुट लेता है।

मूलतः, यह का उपयोग करता है एक, अभिसरण पाश जब तक लागू u। यह प्रत्येक सेल की सभी सूचियों और दोनों ओर दो सेल बनाकर अपडेट को लागू करता है, फिर प्रत्येक शून्य सेल को अपने पड़ोसियों की अधिकतम तक अपडेट करता है।

um|@d1eSd.:++0G03Q
                      Implicit: Q = eval(input())
u                Q    Apply the following until convergence, starting with G = Q.
           ++0G0      Pad G with zeros on either side.
         .:     3     Form all 3 element substrings.
                      Now, for each element of G, we have a list of the form
                      [previous, current, next]
 m                    Map over this list
  |@d1                The current element, if it's nonzero
      eSd             Else the max of the list.
— isaacg
स्रोत
8

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

Alephalpha के //.समाधान के साथ तुलना में बहुत प्रतिस्पर्धी नहीं है , लेकिन मुझे लगा कि एक सेलुलर-ऑटोमेटा चुनौती का CellularAutomatonजवाब होना चाहिए :

CellularAutomaton[{If[#2<1,Max@##,#2]&@@#&,{},1},{#,0},{{{l=Length@#}},l-1}]&

समारोह में मापदंडों का एक टन लगता है ... चलो उन्हें कुछ नाम देते हैं:

CellularAutomaton[{f,n,r},{i,b},{{{t}},d}]

यहाँ वे क्या करते हैं:

  • rनियम की सीमा है, अर्थात यह निर्धारित करता है कि अद्यतन के लिए कितने पड़ोसियों पर विचार किया जाता है। हम प्रत्येक पक्ष में एक पड़ोसी चाहते हैं, इसलिए हम उपयोग करते हैं 1।
  • nआम तौर पर रंगों की संख्या या सूची (विभिन्न प्रकार के सेल) हैं, लेकिन अगर हम नियम को नियम संख्या के बजाय कस्टम फ़ंक्शन के रूप में निर्दिष्ट करते हैं, तो यह होना चाहिए {}।
  • fअद्यतन नियम का निर्धारण करने वाला एक कार्य है। यह 3 सेल (यदि r = 1) की सूची लेता है और मध्य सेल के लिए नया रंग देता है।
  • iप्रारंभिक स्थिति है। वह इनपुट है।
  • bपृष्ठभूमि है। यदि यह नहीं दिया गया है, तो CellularAutomatonआवधिक सीमाओं का उपयोग करता है, जो हम नहीं चाहते हैं। इसके बजाय 0एक मृत सीमा शर्त लगाता है।
  • tअनुकरण करने के लिए समय की संख्या है। हमें इनपुट की तुलना में अधिक चरणों की आवश्यकता नहीं है, क्योंकि उसके बाद बैक्टीरिया परिवर्तित हो जाएगा, इसलिए t = Length@#। आम तौर पर, CellularAutomatonसभी मध्यवर्ती चरणों को लौटाता है। हम tदो सूचियों में लपेटकर इससे बच सकते हैं ।
  • dनिर्धारित करता है कि आउटपुट में कौन से सेल प्रस्तुत किए जाते हैं। डिफ़ॉल्ट रूप से, हम सभी कोशिकाओं को प्राप्त करेंगे जो संभावित रूप से नियम से प्रभावित हो सकते हैं (जो t*rइनपुट के दोनों छोर पर अतिरिक्त सेल हैं)। हम इसे देते हैं l-1, क्योंकि यह गणितज्ञ की कुछ स्थितियों में से एक है जहां शून्य-आधारित सूचकांक का उपयोग किया जाता है।
— मार्टिन एंडर
स्रोत
6

हास्केल, 86 83 81 79 73 71 बाइट्स

(0#r)l=max r l
(o#_)_=o
p!_=zipWith3(#)p(0:p)$tail p++[0] 
id>>=foldl(!)

प्रयोग उदाहरण: id>>=foldl(!) $ [7,0,3,0,0,0,0,0,8,0,9,1]-> [7,7,3,3,3,8,8,8,8,9,9,1]।

समझाने के लिए ज्यादा कुछ नहीं: अगर एक सेल 0 है, तो पड़ोसी तत्वों का अधिकतम लाभ उठाएं। इनपुट समय की लंबाई दोहराएँ। इसके लिए मैं इसके xमाध्यम से पुनरावृति करता हूं foldlलेकिन दूसरे तर्क को अनदेखा करता हूं p।

संपादित करें: @Mauris को बचाने के लिए 6 बाइट्स मिले और @xnor एक और दो। धन्यवाद!

— nimi
स्रोत
आप बदल सकते हैं h pके साथ p!_तो की जगह (const.h)के साथ (!)करने के लिए 6 बचाने बाइट्स।
— लिन
@ मौरिस: चतुर। आपका बहुत बहुत धन्यवाद!
— nimi
@ मुझे लगता है कि अंतिम पंक्ति के लिए अनाम है id>>=foldl(!)।
— xnor
@ xnor: हाँ यह करता है! अच्छी तरह से देखा गया!
— निमि
4

सीजेएम, 27 24 बाइट्स

{_,{0\0++3ew{~@e>e|}%}*}

इसका परीक्षण यहां करें।

यह एक अनाम ब्लॉक को धक्का देता है जो स्टैक पर एक सूची को एक नई सूची में बदल देता है।

व्याख्या

_,       e# Duplicate the input and get its length N.
{        e# Run this block N times (convergence won't take that long)...
  0\0++  e#   Wrap the list in two zeroes.
  3ew    e#   Get all sublists of length 3.
  {      e#   Map this block onto each sublist...
    ~    e#     Dump all three elements on the stack.
    @    e#     Pull up the left neighbour.
    e>   e#     Maximum of both neighbours.
    e|   e#     Logical OR between centre cell and maximum of neighbours.
  }%
}*
— मार्टिन एंडर
स्रोत
सिडस्टैपिंग अभिसरण एक अच्छी चाल है
— लुइस मेंडू
1
... जो मैंने बेशर्मी से उधार लिया है :-)
— लुइस मेंडो
4

जे, 24 23 बाइट्स

(+=&0*(0,~}.)>.0,}:)^:_

उपयोग:

   ((+=&0*(0,~}.)>.0,}:)^:_) 0 1 5 0 0 0 6
1 1 5 5 6 6 6

विधि मॉरिस के समाधान के समान है ।

(                  )^:_ repeat until change
               0,}:     concat 0 and tailless input
      (0,~}.)           concat headless input and 0
             >.         elementwise maximum of the former two lists
  =&0*                  multiply by input_is_0 (zeroing out the list at nonzero input positions)
 +                       add to input

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

1 बाइट ने जरगब को धन्यवाद दिया।

— randomra
स्रोत
3

गणितज्ञ, 77 74 66 62 बाइट्स

मार्टिन ब्यूटनर को 12 बाइट्स धन्यवाद दिया।

#//.i_:>BlockMap[If[#2<1,Max@##,#2]&@@#&,Join[{0},i,{0}],3,1]&
— alephalpha
स्रोत
3

जे, 33 बाइट्स

3 :'y+(y=0)*>./(_1,:1)|.!.0 y'^:_

मुझे पसंद है की तुलना में थोड़ा लंबा।

3 :'                         '^:_   Repeat a "lambda" until a fixed point:
                            y         The input to this lambda.
               (_1,:1)|.!.0           Shift left and right, fill with 0.
            >./                       Maximum of both shifts.
      (y=0)*                          Don't grow into filled cells.
    y+                                Add growth to input.
— लिन
स्रोत
जो मेरे पास है, उससे बहुत अलग है, मुझे लगता है कि आपको इसे एक उत्तर के रूप में पोस्ट करना चाहिए :)
— लिन
3

पायथन 3.5, 83 बाइट्स

यह फ़ंक्शन पूर्णांक की पायथन सूची लेता है। यकीन नहीं है कि गोल्फ के लिए बहुत कुछ बचा है, लेकिन मैं इसे कम से कम दूसरी भाषा के साथ प्रतिस्पर्धा करना पसंद करूंगा!

def b(s):
 for _ in s:s=[s[n]or max((0,*s)[n:n+3])for n in range(len(s))]
 return s

अजगर 3.5 से, पीईपी 448 हमें खोल देता है sमें 0,*s। पहले रिलीज के लिए एक बाइट अतिरिक्त की आवश्यकता होती है, जैसे:

def b(s):
 for _ in s:s=[s[n]or max(([0]+s)[n:n+3])for n in range(len(s))]
 return s

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

— टिम पेडरिक
स्रोत
@ChrisH: यह अजगर 3.5 पर काम नहीं करता है, और मुझे नहीं लगता कि यह पहले के संस्करणों पर काम करेगा या तो: कि नहीं ले returnकरने के लिए अंदरfor _ in s पाश?
— टिम पैडरिक
टिप्पणी हटा दी गई - मैं केवल उन परीक्षण मामलों को आज़माने के लिए हुआ जो पहली बार हल करते हैं।
— क्रिस एच
3

मतलाब, 90 बाइट्स

कुछ संकल्पों के बारे में कैसे?

x=input('');for n=x;x=x+max(conv(x,[0 0 1],'same'),conv(x,[1 0 0],'same')).*~x;end;disp(x)

उदाहरण

>> x=input('');for n=x;x=x+max(conv(x,[0 0 1],'same'),conv(x,[1 0 0],'same')).*~x;end;disp(x)
[7 0 3 0 0 0 0 0 8 0 9 1]
     7     7     3     3     3     8     8     8     8     9     9     1
— लुइस मेंडो
स्रोत
3

हास्केल, 66 65 बाइट्स

f x=[maximum[[-j*j,a]|(j,a)<-zip[-i..]x,a>0]!!1|(i,_)<-zip[0..]x]

यह एक फ़ंक्शन को परिभाषित करता है जिसे कहा जाता है f।

व्याख्या

सेलुलर ऑटोमेटन को पुनरावृत्त करने के बजाय, मैं सीधे अंतिम मूल्यों की गणना करता हूं। परिभाषा एकल सूची समझ है। मान तब iसे 0लेकर length x - 1, जब तक हम xप्राकृतिक संख्याओं के साथ ज़िप करते हैं। प्रत्येक सूचकांक के लिए i, हम 2-तत्व सूचियों की सूची तैयार करते हैं

[-(-i)^2, x0], [-(-i+1)^2, x1], [-(-i+2)^2, x2], ..., [-(-i+n)^2, xn]

इस सूची से, हम अधिकतम तत्व की गणना करते हैं जिसका दूसरा समन्वय नॉनज़ेरो है और उस दूसरे तत्व को साथ ले जाते हैं !!1। यह इंडेक्स के सबसे नज़दीकी नॉनज़ेरो वैल्यू को देता है i, जिससे बड़ी वैल्यू लेने से संबंध टूट जाते हैं।

— Zgarb
स्रोत
इनाम जीतने पर बधाई!
— xnor
2

लुआ, 133 बाइट्स

दो छोरों, नेस्टेड टर्नरीज़ ... अगर मैं इसे आगे बढ़ाना चाहता हूं, तो मुझे इसे करने का एक और तरीका खोजना होगा, लेकिन मैं एक नहीं देखता।

function f(a)for i=1,#a do b={}for j=1,#a do c,d=a[j+1]or 0,a[j-1]b[j]=0<a[j]and a[j]or(d or 0)>c and d or c end a=b end return a end

स्पष्टीकरण

function f(a)
  for i=1,#a                       -- this loop allow us to be sure the cycle is complete
  do
    b={}                           -- set a new pointer for b
    for j=1,#a                     -- loop used to iterate over all elements in a
    do
      c,d=a[j+1]or 0,a[j-1]        -- gains some bytes by attributing these expressions 
                                   -- to a variable
      b[j]=0<a[j]and a[j]or        -- explained below
            (d or 0)>c and d or c
    end
    a=b                            -- we are one cycle further, new value for a
  end                              -- which is our reference array
  return a
end

भाग

b[j]=0<a[j]and a[j]or(d or 0)>c and d or c

तक विस्तारित किया जाएगा 

b[j]=0<a[j]and a[j]or(a[j-1] or 0)>(a[j+1] or 0) and a[j-1] or(a[j+1]or 0)

जिसे नेस्टेड ifमें अनुवादित किया जा सकता है

if 0<a[j]
then
    value=a[j]          -- if the cell isn't at 0, it keeps its value
elseif (a[j-1] or 0)<(a[j+1] or 0)
--[[ x or y as the following truth table :
x | y ||x or y
------||-------
0 | 0 || false
0 | 1 ||   y
1 | 0 ||   x
1 | 1 ||   x
    -- It means that when j=1 (1-based) and we try to index a[j-1]
    -- instead of failing, we will fall in the case false or true
    -- and use the value 0
    -- the same trick is used for when we try to use an index > a:len
]]--
then
    value=a[j-1]        -- the left cell propagate to the cell j
else
    value=a[j+1] or 0   -- if j=a:len, we put 0 instead of a[j+1]
                        -- this case can only be reached when we are on the right most cell
                        -- and a[j-1]==0
end
— Katenkyo
स्रोत
1

पायथ, 17 बाइट्स

meeSe#.e,_akdbQUQ

स्टड से पायथन शैली की सूची लेता है, स्टडआउट के लिए आउटपुट।

व्याख्या

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

                   Implicit: Q is input list
m              UQ  Map over input index d:
      .e      Q     Map over input index k and element b:
        ,_akdb       The pair [-abs(k-d), b]
    e#              Remove those where b==0
 eeS                Take the second element of the maximal pair
— Zgarb
स्रोत
1

एपीएल (डायलॉग) , 18 बाइट्स

बेनामी tacit उपसर्ग समारोह।

(⊢+~∘××3⌈/0,,∘0)⍣≡

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

(… )⍣≡ जब तक परिणाम तर्क के समान न हो, तब तक निम्नलिखित टैटिट फ़ंक्शन लागू करें:

 ⊢ बहस

 + प्लस

  ~ नहीं  Signum
  ∘
  ×

 × बार

 3⌈/ अधिकतम तीन में से प्रत्येक समूह पर

 0, इसके बाद शून्य

  ,
  ∘ एक
  0 शून्य के  बाद तर्क

— एडम
स्रोत
1

जावा 8, 155 142 बाइट्स

a->{for(int b[],i,l=a.length,p,n,f=l;f>0;)for(b=a.clone(),i=0,f=l;i<l;f-=a[i-1]>0?1:0)if(a[i++]<1)a[i-1]=(p=i>1?b[i-2]:0)>(n=i<l?b[i]:0)?p:n;}

int[]बाइट्स को बचाने के लिए एक नया वापस करने के बजाय इनपुट को संशोधित करता है ।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

a->{                   // Method with integer-array parameter and no return-type
  for(int b[],         //  Copy array
          i,           //  Index integer
          l=a.length,  //  Length of the array
          p,n,         //  Temp integers (for previous and next)
          f=1;         //  Flag integer, starting at 1
      f>0;)            //  Loop (1) as long as the flag is not 0 (array contains zeroes)
    for(b=a.clone(),   //   Create a copy of the current state of the array
        i=0,           //   Reset the index to 0
        f=l;           //   Reset the flag to the length of the array `l`
        i<l;           //   Inner loop (2) over the array
        f-=a[i-1]>0?   //     After every iteration, if the current item is not a zero:
            1          //      Decrease flag `f` by 1
           :           //     Else:
            0)         //      Leave flag `f` the same
      if(a[i++]<1)     //    If the current item is a 0:
        a[i-1]=        //     Change the current item to:
         (p            //      If `p` (which is:
           =i>1?       //        If the current index is not 0:
             b[i-2]    //         `p` is the previous item
            :          //        Else:
             0)        //         `p` is 0)
         >(n           //      Is larger than `n` (which is:
            =i<l?      //        If the current index is not `l-1`:
              b[i]     //         `n` is the next item
             :         //        Else:
              0)?      //         `n` is 0):
          p            //       Set the current item to `p`
         :             //      Else:
          n;           //       Set the current item to `n`
                       //   End of inner loop (2) (implicit / single-line body)
                       //  End of loop (1) (implicit / single-line body)
}                      // End of method
— केविन क्रूज़सेन
स्रोत
0

रूबी, 81 बाइट्स

->(a){a.map{|o|a=a.map.with_index{|x,i|x!=0 ? x : a[[0,i-1].max..i+1].max}}[-1]}

मुझे लगता है कि आंतरिक mapको और आगे बढ़ाया जा सकता है।

— हर्ष गुप्ता
स्रोत
बस एहसास हुआ, मेरा जवाब थोड़े @ user81655 के जवाब के समान है ।
— हर्ष गुप्ता
मुझे लगता है कि आप टर्नरी में रिक्त स्थान को हटा सकते हैं, अर्थात चारों ओर ?और :।
— एलेक्स ए।
0

PHP - 301 291 289 288 264 वर्ण

ऐसा करने से पहले अन्य उत्तरों पर ध्यान न दें। भाषा को दोष मत दो, मुझे दोष दो। बहुत सुखद और चुनौतीपूर्ण गैर कम। सभी कोड गोल्फ सलाह भारी सराहना की।

$a=explode(' ',$s);$f=1;while($s){$o=1;foreach($a as&$b){
if($b==0){$u=current($a);prev($a);$d=prev($a);if(!$o&&current($a)==0){end($a);$d=prev($a);}if(!$f){$f=1;continue;}if($u>$d)$b=$u;if($u<$d){$b=$d;$f=0;}}
$o=0;}if(!in_array(0,$a))break;}$r=join(' ',$a);echo$r;

व्याख्या की

// Input
$s = '0 0 2 0 0 0 1 2 0 0 3 3 0 0';

// Create array
$a = explode(' ', $s);
// Set skip flag
$f = 1;
while ($s)
{
    // Set first flag
    $o = 1;
    // Foreach
    foreach ($a as &$b)
    {
        // Logic only for non zero numbers
        if ($b == 0)
        {
            // Get above and below value
            $u = current($a);
            prev($a);
            $d = prev($a);

            // Fix for last element
            if (! $o && current($a) == 0)
            {
                end($a);
                $d = prev($a);
            }

            // Skip flag to prevent upwards overrun
            if (! $f)
            {
                $f = 1;
                continue;
            }

            // Change zero value logic
            if ($u > $d)
                $b = $u;
            if ($u < $d)
            {
                $b = $d;
                $f = 0;
            }
        }

        // Turn off zero flag
        $o = 0;
    }

    // if array contains 0, start over, else end loop
    if (! in_array(0, $a))
        break;
}
// Return result
$r = join(' ', $a);
echo $r;(' ', $a);
echo $r;
— बत्तख
स्रोत
1
गंभीरता से? गोल्फिंग आपके कोड में सिर्फ व्हाट्सएप नहीं हटा रहा है। एल्गोरिथ्म इसके अलावा, यहाँ कुछ सुझाव हैं: उपयोग 1करने के बजाय true, splitबजाय explode, forके बजाय while, joinबजाय implode, बेकार कर्ली कोष्ठक निकालने के लिए, ...
— ब्लैकहोल
मैं विस्फोट करता रहा क्योंकि विभाजन को ह्रास किया जा रहा है। इसके अलावा, मैं नहीं जानता कि कैसे एक लूप का उपयोग करना लिखना है, इसलिए मैंने इसे अभी के लिए रखा है, जब तक कि यहां कोई अपना ज्ञान साझा नहीं कर सकता है या लिंक साझा नहीं कर सकता है। आप सभी को धन्यवाद।
— हंस
0

पायथन, 71 बाइट्स

g=lambda l:l*all(l)or g([l[1]or max(l)for l in zip([0]+l,l,l[1:]+[0])])

zipसभी लंबाई -3 एक तत्व और अपने पड़ोसियों के उप-सूचियों बनाता है, के रूप में अंतिम बिंदु से परे इलाज 0। केंद्रीय तत्व, l[1]एक lशून्य सूची, यदि शून्य, के maxसाथ उसके पड़ोसियों द्वारा प्रतिस्थापित किया जाता है l[1]or max(l)। l*all(l)रिटर्न सूची lजब यह नहीं है 0की।

— XNOR
स्रोत
0

रूबी, 74 बाइट्स

->a{(r=0...a.size).map{|n|a[r.min_by{|i|[(a[i]<1)?1:0,(i-n).abs,-a[i]]}]}}

निकटतम गैर-शून्य संख्या प्राप्त करके काम करता है।

— MegaTom
स्रोत
0

MATL , 38 बाइट्स

मेरे मतलबी उत्तर का सीधा अनुवाद। भाषा / संकलक के वर्तमान संस्करण का उपयोग करता है ।

it:"tttFFTo2X5I$X+wTFFo2X5I$X+vX>w~*+]

उदाहरण

>> matl it:"tttFFTo2X5I$X+wTFFo2X5I$X+vX>w~*+]
> [7 0 3 0 0 0 0 0 8 0 9 1]
7 7 3 3 3 8 8 8 8 9 9 1

संपादित करें: इसे ऑनलाइन आज़माएं! साथ X+द्वारा बदल दिया Y+और vसे &v, भाषा में किया परिवर्तन के कारण।

— लुइस मेंडो
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.