जीवन का स्थिर खेल


19

चुनौती:

0 और 1s के एक मैट्रिक्स (या 2 डी सरणी) को देखते हुए, कॉनवे के जीवन के खेल के लिए स्थिर अवस्था तक पहुंचने के लिए, या -1 तक पहुंचने के लिए उठाए जाने वाले चरणों की संख्या को आउटपुट करता है। एक स्थिर अवस्था एक ऐसी अवस्था है जिसमें प्रत्येक चरण पर कोई कोशिका चालू या बंद नहीं होती है। गेम को दिए गए मैट्रिक्स में चलना चाहिए, ऊपर और नीचे जुड़े हुए, और जुड़े हुए पक्षों के साथ। (यानी 4x3 मैट्रिक्स दिया गया है, इसे 4x3 टोरस पर चलना चाहिए) इनपुट मैट्रिक्स 15x15 से बड़ा नहीं होगा।

नोट: यदि मैट्रिक्स स्थिर स्थिति में शुरू होता है, तो आउटपुट 0 होना चाहिए।

नमूने:

इनपुट:

[[0,0,0],  
 [0,1,1],  
 [0,1,0]]

आउटपुट:

2

प्रक्रिया: (इसे प्रदर्शित करने की आवश्यकता नहीं है)

[[0,0,0],
 [0,1,1],
 [0,1,0]]

[[1,1,1],
 [1,1,1],
 [1,1,1]]

[[0,0,0],
 [0,0,0],
 [0,0,0]]

इनपुट:

[[0,0,1,1],
 [0,1,1,1],
 [0,1,0,0],
 [0,1,1,1]]

आउटपुट:

2

प्रक्रिया:

[[0,0,1,1],
 [0,1,1,1],
 [0,1,0,0],
 [0,1,1,1]]

[[0,0,0,0],
 [0,1,0,1],
 [0,0,0,0],
 [0,1,0,1]]

[[0,0,0,0],
 [0,0,0,0],
 [0,0,0,0],
 [0,0,0,0]]

इनपुट:

[[0,1,0,0],
 [0,1,0,0],
 [0,1,0,0],
 [0,0,0,0]]

आउटपुट:

-1

प्रक्रिया:

[[0,1,0,0],
 [0,1,0,0],
 [0,1,0,0],
 [0,0,0,0]]

[[0,0,0,0],
 [1,1,1,0],
 [0,0,0,0],
 [0,0,0,0]]

[[0,1,0,0],
 [0,1,0,0],
 [0,1,0,0],
 [0,0,0,0]]

हमेशा के लिए दोहरा रहे हैं

इनपुट:

[[0,0,0,0],
 [0,0,0,1],
 [0,1,1,1],
 [0,0,1,0]]

आउटपुट:

4

प्रक्रिया:

[[0,0,0,0],
 [0,0,0,1],
 [0,1,1,1],
 [0,0,1,0]]

[[0,0,0,0],
 [1,0,0,1],
 [1,1,0,1],
 [0,1,1,1]]

[[0,1,0,0],
 [0,1,1,1],
 [0,0,0,0],
 [0,1,0,1]]

[[0,1,0,1],
 [1,1,1,0],
 [0,1,0,1],
 [1,0,1,0]]

[[0,0,0,0],
 [0,0,0,0],
 [0,0,0,0],
 [0,0,0,0]]

इनपुट:

[[0,0,0,0],
 [0,1,1,0],
 [0,1,1,0],
 [0,0,0,0]]

आउटपुट:

0

प्रक्रिया:

शुरुआत की अवस्था स्थिर है।

जीवन के खेल के नियम

यदि एक कोशिका जो बंद है (0), ठीक तीन (1) कोशिकाओं के ठीक बगल में है, तो उसे चालू कर दिया जाता है। अन्यथा, इसे छोड़ दिया जाता है। यदि कोई सेल चालू है, जो चौकों पर 2 या 3 के बगल में है, तो यह कहता है। अन्यथा, इसे बंद कर दिया जाता है।


यदि पैटर्न हमेशा के लिए दोहराता है तो आउटपुट क्या होना चाहिए?
निधि मोनिका का मुकदमा

2
संभव इनपुट प्रारूप? मैट्रिक्स आकार पर कोई सीमा? यदि नहीं, तो क्या होगा यदि हमारे पास 100x100 मैट्रिक्स है? इसके अलावा, आपको इस सवाल में गेम ऑफ लाइफ के नियमों का सारांश रखना चाहिए ताकि यह स्व-निहित हो।
एल'एंडिया स्ट्रोमैन

3
ओह मैं समझा। मैंने एक उदाहरण को गलत बताया। एक और सवाल, हालांकि - हमें किस बिंदु पर यह मान लेना चाहिए कि यह स्थिर नहीं है? क्योंकि मुझे यकीन है कि बहुत सारे पैटर्न हैं जो सैकड़ों या हजारों पुनरावृत्तियों के बाद स्थिर हो जाते हैं। वहाँ भी इसके लिए एक श्रेणी है: मेथ्यूलस
फंड मोनिका का मुकदमा

18
मुझे पूरा यकीन है कि यह चुनौती अनिवार्य रूप से "हल करने की समस्या का समाधान" पूछ रही है।
Mego

6
250 पीढ़ियों को दिखाने के लिए एक जवाबी कार्रवाई के रूप में हमेशा पर्याप्त नहीं होता है: 15 से 14 मैट्रिक्स के लिए, अन्यथा खाली क्षेत्र में एक एकल ग्लाइडर 15 * 14 * 4 = 840 पीढ़ियों को अपनी मूल स्थिति में वापस ले जाएगा। यदि उस लंबे पथ का अंत 2 से 2 ब्लॉक करके अवरुद्ध हो जाता है, तो ग्लाइडर एक स्थिर कॉन्फ़िगरेशन को नष्ट कर देगा। यह शुरुआत में ग्लाइडर को सही तरीके से नष्ट करने से बचने के लिए पथ के अंत से कुछ पंक्तियां होंगी, लेकिन स्थिरता के साथ 600 से अधिक पीढ़ियों के बाद भी।
ट्राइकोप्लाक्स

जवाबों:


10

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

#&@@FirstPosition[Partition[CellularAutomaton[{224,{2,{{2,2,2},{2,1,2},{2,2,2}}},{1,1}},#,2^Length[Join@@#]],2,1],{x_,x_},0,1]-1&

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

व्याख्या

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

कोड के माध्यम से चलते हैं:

2^Length[Join@@#]

यह 2 N की गणना करता है , क्योंकि Join@@इसका उपयोग 2D सूची को समतल करने के लिए किया जाता है।

CellularAutomaton[{224,{2,{{2,2,2},{2,1,2},{2,2,2}}},{1,1}},#,...]

यह 2 एन पीढ़ियों के लिए जीवन के खेल का अनुकरण करता है । 3x3 मैट्रिक्स एक कुलीन 2D ऑटोमेटन के पड़ोस को निर्दिष्ट करता है और 224जीवन के मानक गेम की नियम संख्या है। मैंने इस बारे में लिखा है कि इस नंबर की गणना यहाँ पर कैसे करें ।

Partition[...,2,1]

यह पीढ़ियों के सभी लगातार (अतिव्यापी) जोड़े प्राप्त करता है।

FirstPosition[...,{x_,x_},0,1]

यह समान पीढ़ियों की पहली जोड़ी को ढूंढता है, 0अगर कोई भी नहीं मिला है तो डिफ़ॉल्ट है और खोज को गहराई तक सीमित करता है 1। यदि ऐसी जोड़ी पाई जाती है, तो परिणाम एक सूची में वापस आ जाता है। इसलिए हम उपयोग करते हैं:

#&@@...

उस सूची से पहला तत्व निकालने के लिए ( 0परमाणु होने का डिफ़ॉल्ट मान , इससे अप्रभावित है)।

...-1

अंत में हम एक घटाते हैं क्योंकि चुनौती उम्मीद 0सूचकांकों और -1विफलता के लिए उम्मीद करती है ।


8

लुआ, 531 509 488 487 464 424 405 404 बाइट्स

कौन एक बड़े पैमाने पर प्रस्तुत करना चाहता है? \ O /

संपादित करें: इसमें सुधार हुआ है, लेकिन पता नहीं है कि इसे और अधिक कैसे बढ़ाया जाए, इसलिए ... स्पष्टीकरण आ रहे हैं टिप्पणियाँ जोड़ी गईं :)

@ केनीलाऊ की मदद से ~ 60 बाइट्स बचाए

छोटे गोल्फ काटने से एक का नाम बदलकर अधिक बाइट aमें Yinlined हेक्साडेसिमल रूपांतरण को रोकने के लिए

function f(m)c={}t=table.concat::z::c[#c+1]={}p=c[#c]Y={}for i=1,#m do k=m[i]p[#p+1]=t(k)Y[i]={}for j=1,#k
do v=m[i%#m+1]l=j%#k+1w=m[(i-2)%#m+1]h=(j-2)%#k+1Y[i][j]=v[l]+k[l]+w[l]+v[h]+v[j]+w[h]+w[j]+k[h]end
end s=''for i=1,#m do k=m[i]for j=1,k do
x=Y[i][j]k[j]=k[j]>0 and((x<2or x>3)and 0or 1)or (x==3 and 1or 0)end
s=s..t(k)end for i=1,#c do
if(s==t(c[i]))then return#c>i and-1or i-1
end end goto z end

Ungolfed

function f(m)                -- takes a 2D array of 0 and 1s as input
  c={}                       -- intialise c -> contains a copy of each generation
  t=table.concat             -- shorthand for the concatenating function 
  ::z::                      -- label z, used to do an infinite loop
    c[#c+1]={}               -- initialise the first copy 
    p=c[#c]                  -- initialise a pointer to this copy
    a={}                     -- initialise the 2D array of adjacency
    for i=1,#m               -- iterate over the lines of m
    do
      k=m[i]                 -- shorthand for the current line
      p[#p+1]=t(k])          -- saves the current line of m as a string
      a[i]={}                -- initialise the array of adjacency for the current line
      for j=1,#k             -- iterate over each row of m
      do
                             -- the following statements are used to wraps at borders
        v=m[i%#m+1]          -- wrap bottom to top
        l=j%#k+1             -- wrap right to left
        w=m[(i-2)%#m+1]      -- wrap top to bottom
        h=(j-2)%#k+1         -- wrap left to right

        a[i][j]= v[l]        -- living cells are 1 and deads are 0
                +k[l]        -- just add the values of adjacent cells
                +w[l]        -- to know the number of alive adjacent cells
                +v[h]
                +v[j]
                +w[h]
                +w[j]
                +k[h]
      end
    end

    s=''                     -- s will be the representation of the current generation
    for i=1,#m               -- iterate over each line
    do
      k=m[i]                 -- shorthand for the current line
      for j=1,#k             -- iterate over each row
      do
        x=a[i][j]            -- shorthand for the number of adjacent to the current cell
                             -- the next line change the state of the current cell
        k[j]=k[j]>0          -- if it is alive
                and((x<2     --   and it has less than 2 adjacent
                    or x>3)  --   or more than 3 adjacent
                  and 0      --     kill it
                  or 1)      --     else let it alive
                or           -- if it is dead
                  (x==3      --   and it has 3 adjacent
                  and 1      --     give life to it
                  or 0)      --     else let it dead
      end
      s=s..t(k)              -- save the representation of the current line
    end
    for i=1,#c               -- iterate over all the generation done until now
    do                       
      if(s==t(c[i]))         -- if the representation of the current generation
      then                   -- is equal to one we saved
        return#c>i           -- check if it is the latest generation
              and-1          -- if it isn't, it means we are in a loop -> return -1
              or i-1         -- if it is, we did 2 generations without changing
                             --  -> return the number of generation
      end
    end
  goto z                     -- if we reach that point, loop back to the label z
end

परीक्षण के मामलों

यहाँ कुछ परीक्षण मामले हैं

function f(m)c={}t=table.concat::z::c[#c+1]={}p=c[#c]a={}for i=1,#m do k=m[i]p[#p+1]=t(k)a[i]={}for j=1,#k
do v=m[i%#m+1]l=j%#k+1w=m[(i-2)%#m+1]h=(j-2)%#k+1
a[i][j]=v[l]+k[l]+w[l]+v[h]+v[j]+w[h]+w[j]+k[h]end
end s=''for i=1,#m do k=m[i]for j=1,k do
x=a[i][j]k[j]=k[j]>0 and((x<2or x>3)and 0or 1)or (x==3 and 1or 0)end
s=s..t(k)end for i=1,#c do
if(s==t(c[i]))then return#c>i and-1or i-1
end end goto z end




print(f({{0,0,0},{0,1,1},{0,1,0}}))
print(f({{0,1,0,0},{0,1,0,0},{0,1,0,0},{0,0,0,0}}))
-- 53 generation, 15x15, takes 50-100 ms on a bad laptop
print(f({{0,0,0,0,1,1,0,1,0,0,0,0,1,0,0},
       {0,1,1,0,1,1,1,1,1,1,1,0,0,0,0},
       {0,1,1,1,0,1,0,1,0,0,0,0,1,0,0},
       {0,0,1,0,1,1,1,0,0,1,1,1,0,1,1},
       {1,1,0,0,1,1,1,0,1,1,0,0,0,1,0},
       {0,0,0,0,1,1,0,1,0,0,0,0,1,0,0},
       {0,1,1,0,1,1,1,1,1,1,1,0,0,0,0},
       {0,1,1,1,0,1,0,1,0,0,0,0,1,0,0},
       {0,0,1,0,1,1,1,0,0,1,1,1,0,1,1},
       {1,1,0,0,1,1,1,0,1,1,0,0,0,1,0},
       {0,0,1,0,1,1,1,0,0,1,1,1,0,1,1},
       {1,1,0,0,1,1,1,0,1,1,0,0,0,1,0},
       {0,0,0,0,1,1,0,1,0,0,0,0,1,0,0},
       {0,0,0,0,1,1,0,1,0,0,0,0,1,0,0},
       {0,1,1,0,1,1,1,1,1,1,1,0,0,0,0}}))
-- Glider on a 15x14 board
-- 840 distinct generation
-- loop afterward -> return -1
-- takes ~4-5 seconds on the same bad laptop
print(f({{0,0,0,0,0,0,0,0,0,0,0,0,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,0,1,0,0,0,0,0,0,0,0,0},
       {0,0,0,1,1,1,0,0,0,0,0,0,0,0,0},
       {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
       {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
       {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
       {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
       {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
       {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
       {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
       {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
       {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}}))

5

जेली, 26 25 बाइट्स

ṙ-r1¤SZµ⁺_|=3
ÇÐĿ-LiṪÇ$$?

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें

बड़े परीक्षण के मामले ( @ काटेनको के उत्तर से ): 15 × 15 स्थिर | 15 × 14 ग्लाइडर

यह काम किस प्रकार करता है

ṙ-r1¤SZµ⁺_|=3  Helper link. Argument: G (grid)
               This link computes the next state of G.

    ¤          Evaluate the three links to the left as a niladic chain.
 -               Yield -1.
   1             Yield 1.
  r              Range; yield [-1, 0, 1].
ṛ              Rotate the rows of G -1, 0 and 1 units up.
     S         Compute the sum of the three resulting grids.
               Essentially, this adds the rows directly above and below each given
               row to that row.
      Z        Zip; transpose rows and columns.
       µ       Convert the preceding chain into a link and begin a new chain.
        ⁺      Apply the preceding chain once more.
               This zips back and adds the surrounding columns to each column.
         _     Subtract G from the result.
               Each cell now contains the number of lit cells that surround it.
          |    That the bitwise OR of the result and G.
               Notably, 3|0 = 3|1 = 2|1 = 3.
           =3  Compare each resulting number with 3.


ÇÐĿ-LiṪÇ$$?    Main link. Argument: G (grid)

ÇÐL            Repeatedly apply the helper link until the results are no longer
               unique. Collect all unique results in a list.
         $     Evaluate the two links to the left as a monadic chain:
        $        Evaluate the two links to the left as a monadic chain:
      Ṫ            Pop the last element of the list of grids.
       Ç           Apply the helper link to get the next iteration.
     i           Get the index of the grid to the right (the first non-unique one)
                 in the popped list of grids. This yields 0 iff the popped list
                 doesn't contain that grid, i.e., the grid reached a stable state.
          ?    If the index is non-zero:
   -             Return -1.
    L            Else, return the length of the popped list of grids.

5

पर्ल, 154 151 144 140 137 133 133 बाइट्स

के लिए +3 शामिल है -ap0

अंतरिक्ष द्वारा अलग किए गए अंकों के समूहों की एक पंक्ति के रूप में इनपुट के साथ चलाएं

life.pl <<< "0000 0001 0111 0010"

इनपुट के तुरंत स्थिर होने की स्थिति में यह वास्तव में आवश्यक है। अन्य सभी मामलों में आप अंकों की अलग लाइनों के रूप में इसे और अधिक आसानी से दे सकते हैं:

life.pl
0000
0001
0111
0010
^D

इस तरह से इनपुट देने पर 0 के बजाय 1 तुरंत स्थिर कॉन्फ़िगरेशन के लिए 1 दिया जाएगा।

life.pl:

#!/usr/bin/perl -ap0
map{@f=map$F[$_%@F]x3,$i-1..++$i;s%.%"0+($&+33)=~grep\$_,map{(//g)[@--1..@+]}\@f"%eeg}@Q=@F;$_=/@Q/?keys%n:$n{$_="@Q"}--||redo

लगभग इस पर गणितज्ञ की पिटाई ...

केवल पुराने पर्ल संस्करणों पर (जहां आप एक चर के रूप में एक स्थिरांक का उपयोग कर सकते हैं) यह 126 बाइट समाधान कार्य करता है:

#!/usr/bin/perl -p0a
map{@f=map$F[$_++%@F]x2,-1..1;s%.%"0+($&+33)=~grep\$_,map{(//g)[@--1..@+]}\@f"%eeg}@Q=@F;$_=/@Q/?keys%n:$n{$_="@Q"}--||redo

मामले में कम से कम 2 पंक्तियाँ होना निश्चित हैं, यह 123 बाइट समाधान सभी पर्ल संस्करणों पर काम करता है:

#!/usr/bin/perl -p0a
@F=@F[-$#F..!s%.%"0+($&+33)=~grep\$_,map{(//g,//g)[@--1..@+]}\@F[-1..1]"%eeg]for@Q=@F;$_=/@Q/?keys%n:$n{$_="@Q"}--||redo

1

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

->a{r=[];(r<<a;a=(0...a.size).map{|i|(0...a[i].size).map{|j|n=0;(-1..1).map{|u|(-1..1).map{|v|n+=a[(i+u)%a.size][(j+v)%a[i].size]}};[n==3,n>2&&n<5][a[i][j]]?1:0}})while(!r.index(a));(a==r[-1])?r.index(a):-1}

मैं प्रत्येक बोर्ड का एक इतिहास रखता हूं, इसलिए यदि मुझे एक बोर्ड मिलता है, जिसे मैंने पहले देखा है तो मुझे पता है कि दो में से एक बात हुई थी। पहले यह हो सकता है कि हमने एक स्थिर स्थिति पाई है, जिस स्थिति में यह हमारे इतिहास में सबसे अधिक नाराजगी होगी। दूसरी संभावना यह है कि हमारे पास एक लूप है।


15x15 मैट्रिक्स का मतलब है कि हमारे पास 2 ^ 225 संभावित बोर्ड हैं, मुझे अत्यधिक संदेह है कि आप दुनिया में सभी कंप्यूटर की मेमोरी का उपयोग करके उन मेट्रिसेस को भी याद कर सकते हैं (भले ही अधिकांश गेम संभवतः 1000 से कम बोर्डों के साथ समाप्त हो जाएंगे) .. सौभाग्य कि संबोधित करते हुए 64 बिट मशीनें।
GameDeveloper

1
@DarioOO यहां तक ​​कि एक 15x14 बोर्ड पर एक ग्लाइडर को अपने पहले राज्य में वापस जाने से पहले "केवल" 840 पीढ़ी की आवश्यकता होगी, इसलिए हम लगभग हर चीज की उम्मीद कर सकते हैं कि यह 1000 ग्राम से कम हो। इसके अलावा, 32 बिट्स पूर्णांक का उपयोग करके 15x15 पर 1000 गेंस 15*15*4*1000-> 900 केबी की मेमोरी उपयोग के परिणामस्वरूप , उन मामलों के लिए पर्याप्त है जहां हमें 10k + gens :) की आवश्यकता होगी।
काटेन्को

1

जूलिया, 92 88 बाइट्स

f(x,r...)=x∈r?(r[k=end]==x)k-1:f(sum(i->circshift(x,[i÷3,i%3]-1),0:8)-x|x.==3,r...,x)

सत्यापन

julia> f(x,r...)=x∈r?(r[k=end]==x)k-1:f(sum(i->circshift(x,[i÷3,i%3]-1),0:8)-x|x.==3,r...,x)
f (generic function with 1 method)

julia> f([0 0 0;0 1 1;0 1 0])
2

julia> f([0 0 1 1;0 1 1 1;0 1 0 0;0 1 1 1])
2

julia> f([0 1 0 0;0 1 0 0;0 1 0 0;0 0 0 0])
-1

julia> f([0 0 0 0;0 0 0 1;0 1 1 1;0 0 1 0])
4

julia> f([0 0 0 0;0 1 1 0;0 1 1 0;0 0 0 0])
0

julia> f([0 0 0 0 1 1 0 1 0 0 0 0 1 0 0;0 1 1 0 1 1 1 1 1 1 1 0 0 0 0;0 1 1 1 0 1 0 1 0 0 0 0 1 0 0;0 0 1 0 1 1 1 0 0 1 1 1 0 1 1;1 1 0 0 1 1 1 0 1 1 0 0 0 1 0;0 0 0 0 1 1 0 1 0 0 0 0 1 0 0;0 1 1 0 1 1 1 1 1 1 1 0 0 0 0;0 1 1 1 0 1 0 1 0 0 0 0 1 0 0;0 0 1 0 1 1 1 0 0 1 1 1 0 1 1;1 1 0 0 1 1 1 0 1 1 0 0 0 1 0;0 0 1 0 1 1 1 0 0 1 1 1 0 1 1;1 1 0 0 1 1 1 0 1 1 0 0 0 1 0;0 0 0 0 1 1 0 1 0 0 0 0 1 0 0;0 0 0 0 1 1 0 1 0 0 0 0 1 0 0;0 1 1 0 1 1 1 1 1 1 1 0 0 0 0])
53

julia> f([0 0 0 0 0 0 0 0 0 0 0 0 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 0 1 0 0 0 0 0 0 0 0 0;0 0 0 1 1 1 0 0 0 0 0 0 0 0 0;0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;0 0 0 0 0 0 0 0 0 0 0 0 0 0 0])
-1
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.