फ्रायर सिम्युलेटर

31

आपका काम भोजन के टुकड़ों पर बल्लेबाज के प्रभावों को मॉडल करना है। क्रस्ट की तीन परतें जोड़ें।

[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], // in
 [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
 [0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0],
 [0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,1,0,0],
 [0,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]]
                   |
                   V
[[0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,2,1,2],
 [0,0,2,1,2,2,0,0,0,0,0,0,0,2,2,0,2,0],
 [0,0,2,1,1,1,2,0,0,0,0,0,2,1,1,2,0,0],
 [0,0,0,2,1,2,0,0,0,0,0,2,1,1,2,1,2,0],
 [0,0,0,0,2,0,0,0,0,0,0,0,2,1,1,1,2,0],
 [0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,0,0]]
                   |
                   V
[[0,0,3,2,3,3,0,0,0,0,0,0,0,3,3,2,1,2],
 [0,3,2,1,2,2,3,0,0,0,0,0,3,2,2,3,2,3],
 [0,3,2,1,1,1,2,3,0,0,0,3,2,1,1,2,3,0],
 [0,0,3,2,1,2,3,0,0,0,3,2,1,1,2,1,2,3],
 [0,0,0,3,2,3,0,0,0,0,0,3,2,1,1,1,2,3],
 [0,0,0,0,3,0,0,0,0,0,0,0,3,2,2,2,3,0]]
                   |
                   V
[[0,4,3,2,3,3,4,0,0,0,0,0,4,3,3,2,1,2], // out
 [4,3,2,1,2,2,3,4,0,0,0,4,3,2,2,3,2,3],
 [4,3,2,1,1,1,2,3,4,0,4,3,2,1,1,2,3,4],
 [0,4,3,2,1,2,3,4,0,4,3,2,1,1,2,1,2,3],
 [0,0,4,3,2,3,4,0,0,0,4,3,2,1,1,1,2,3],
 [0,0,0,4,3,4,0,0,0,0,0,4,3,2,2,2,3,4]]

थोड़ा दृश्य सहायता:

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

इनपुट एक बूलीयन मैट्रिक्स है जो फ्रायर का प्रतिनिधित्व करता है: तेल के लिए 0, भोजन के लिए 1। आपके फ़ंक्शन या प्रोग्राम को 1s के आसपास 3 लेयर्स को 2s, 3s और 4s के रूप में जोड़ना चाहिए, इस प्रकार कुछ 0s को ओवरराइट करना चाहिए। बल्लेबाज क्षैतिज और लंबवत (लेकिन तिरछे नहीं) किसी भी आकार या आकार के भोजन के लिए चिपक जाता है, जिसमें डोनट्स (छेद वाले भोजन) और टुकड़े टुकड़े (पृथक भोजन "पिक्सेल") शामिल हैं, और फ्रायर की सीमाओं तक सीमित है। पहले बल्लेबाज की परतें क्रस्ट में बदल जाती हैं और बाद में प्रभावित नहीं होती हैं।

दूसरे शब्दों में, पहले आपको उन सभी 0s को बदलना चाहिए जो 1s के von-Neumann पड़ोस में 2s के साथ हैं, फिर सभी 0s को 2s के von-Neumann के पड़ोस में 3s से बदल दें, और अंत में vs-Neumann के सभी पड़ोस को vs-Neumann के पड़ोस में बदल दें 3s के साथ 3s। इस प्रकार, संख्या 2,3,4 मैनहट्टन की दूरी से निकटतम 1-सेल तक की मात्रा का प्रतिनिधित्व करती है।

फ्रायर का आकार कम से कम 3-बाय -3 होगा और इसमें कम से कम एक टुकड़ा खाना होगा। I / O लचीला है - अपनी भाषा के लिए उपयुक्त मैट्रिक्स प्रारूप का उपयोग करें। अतिरिक्त व्हाट्सएप की अनुमति है, कम कोड वांछनीय, कमियां निषिद्ध हैं।

अधिक परीक्षण:

 [[0,0,1], // in
  [0,0,0],
  [0,1,0]]

 [[3,2,1], // out
  [3,2,2],
  [2,1,2]]

 -

 [[0,0,0,0,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], // in
  [0,0,0,0,0,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,0,1,1,0,1,1,1,0,0,0,0,0,0],
  [1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0],
  [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,1,0,0,1,0,0,0],
  [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,1,0,0,1,0,0,0,0,0,0],
  [0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0],
  [0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0],
  [0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1],
  [0,0,1,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0],
  [0,0,0,1,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],
  [0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,1,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,0,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]]

 [[3,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,3,3,4,3,3,3,4,4,4,3,2,1], // out
  [2,3,4,0,0,0,0,0,0,0,0,0,0,0,0,4,3,2,2,3,2,2,2,3,3,4,4,3,2],
  [1,2,3,4,0,0,0,0,0,0,0,0,0,0,4,3,2,1,1,2,1,1,1,2,2,3,4,4,3],
  [1,1,2,3,4,4,4,4,0,0,0,0,0,4,3,2,1,1,1,1,1,1,1,1,1,2,3,4,4],
  [2,2,3,4,4,3,3,3,4,0,0,0,4,3,2,1,1,2,1,1,1,1,1,2,2,1,2,3,4],
  [3,3,4,4,3,2,2,2,3,4,0,0,4,3,2,1,2,2,1,1,2,2,1,2,3,2,3,4,4],
  [4,4,4,3,2,1,1,1,2,3,4,0,4,3,2,1,1,2,1,2,3,3,2,2,2,3,4,3,3],
  [0,4,3,2,1,1,2,1,2,3,4,0,0,4,3,2,2,2,1,2,3,3,2,1,1,2,3,2,2],
  [4,3,2,1,1,2,2,1,2,3,4,0,0,0,4,3,3,3,2,3,4,4,3,2,2,3,2,1,1],
  [3,2,1,2,1,1,1,1,2,3,4,0,0,0,0,4,4,3,3,3,4,3,3,3,3,3,2,1,2],
  [4,3,2,1,2,2,1,2,3,4,0,0,0,0,0,4,3,2,2,2,3,2,2,3,4,4,3,2,3],
  [0,4,3,2,1,1,2,3,2,3,4,0,0,0,4,3,2,1,1,1,2,1,1,2,3,4,4,3,4],
  [0,0,4,3,2,2,3,2,1,2,3,4,0,0,0,4,3,2,2,2,3,2,2,3,4,4,3,2,3],
  [0,0,0,4,3,3,4,3,2,3,4,0,0,0,0,0,4,3,3,3,4,3,3,4,4,3,2,1,2],

थोड़ा दृश्य सहायता:

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

धन्यवाद @Tschallacka विज़ुअलाइज़ेशन के लिए।

code-golf  matrix 
— NGN
स्रोत
4
क्या आप एक वॉकथ्रू उदाहरण प्रदान कर सकते हैं, कृपया? यह मेरे लिए स्पष्ट नहीं है कि कब या क्यों 2, 3 या 4 का उपयोग करना है (मैं वीटीसी को अस्पष्ट मान रहा हूं लेकिन अब मेरे पास एक हथौड़ा है और ऐसा लगता है कि मैं अल्पमत में हूं)
— झबरा
1
@ मेरी समझ यह है कि संख्या "परत" की पहचान करती है। एक 1D उदाहरण: 000010000→ 000212000→ 003212300→043212340
— georgewatson
4
धन्यवाद, @georgewatson; ऐसा लगता है कि आप सही हैं। हालांकि, यह कल्पना से स्पष्ट नहीं है, जिसमें उल्लेख किया गया है कि "बल्लेबाज" को केवल भोजन से चिपके रहना चाहिए और बाद में बल्लेबाजों की पहले की परतें प्रभावित नहीं होती हैं। यह निर्धारित करने का एकमात्र तरीका परीक्षण मामलों से इसे समझना है।
— झबरा
6
आपकी अगली चुनौती फ्रायर सिम्युलेटर होनी चाहिए।
— मैजिक ऑक्टोपस Urn
5
@ सच में ? (Oct ° ͡) °)
— मैजिक ऑक्टोपस Urn

जवाबों:

10

स्टेंसिल : 1 + 14 = 15 बाइट्स

कमांड-लाइन तर्क: 3

कोड: s<×⌈/N:1+⌈/N⋄S

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

3 तीन बार निम्नलिखित परिवर्तन दोहराएं:

 s अगर एस योगिनी गैर-रिक्त है

 < से कम है

 × के हस्ताक्षर

 ⌈/N वॉन न्यूमन एन पड़ोस की अधिकतम

 : तब नया मान बन जाता है

  1+ एक प्लस

  ⌈/N वॉन न्यूमन एन पड़ोस की अधिकतम

 ⋄ अन्य

  S मान अपरिवर्तित रहता है ( S elf)

— एडम
स्रोत
क्या यह 15 बाइट्स (तर्क के लिए 14 + 1 3) नहीं होना चाहिए ? पहली बार स्टैंसिल को देखते हुए , लेकिन अगर मैं सही ढंग से समझूं तो यह मैट्रिसेस को फायदा पहुंचाने के लिए डायलाग एपीएल के लिए एक विस्तार है ? इसके अलावा, छोटी टिप्पणी: Neumannआपकी शुरुआत में अंत में छोटे के बजाय कैपिटल एन को बोल्ड होना चाहिए। :)
— केविन क्रूज़सेन
1
खैर, नवीनतम सर्वसम्मति से संकेत मिलता है कि एक ही भाषा के विभिन्न विन्यासों को अलग-अलग भाषाओं के रूप में गिना जाना चाहिए, लेकिन मैं इसे जोड़
— दूंगा
1
@ केविनक्रूजसेन स्टेंसिल का इस्तेमाल आसान सेल्युलर ऑटोमैट्स के लिए एक डायलाग एपीएल टूल के रूप में किया जा सकता है, लेकिन यह गोल्फ की भाषा के रूप में भी खड़ा है। वास्तव में, किसी के कोड को टूल उपयोग और गोल्फिंग भाषा के बीच में संशोधन की आवश्यकता हो सकती है।
— अड्म
1
@KevinCruijssen नहीं, बोल्ड अंतिम एन जानबूझकर है। दस्तावेज़ीकरण देखें कि स्टेंसिल स्वयं के लिए और बिना स्वयं के लिए मूरोमिक्स के रूप में मूर और वॉन न्यूमैन के पहले और आखिरी अक्षरों का उपयोग करता है, और गैर-खाली और तत्वों की वास्तविक सूची की गिनती के लिए लोअरकेस और अपरकेस का उपयोग करता है।
— आदम
@KevinCruijssen मुझे यह भी उल्लेख करना चाहिए कि स्टैंसिल केवल Dyalog APL के ⌺बिल्ट-इन ( स्टैंसिल कहा जाता है ) के लिए एक इंटरफ़ेस है । इसका प्रलेखन भी देखें । एक संपूर्ण गोल्फिंग भाषा, जो एक ही बिल्ड-इन पर बनी है! दरअसल, मैंने एकल Dyalog APL बिल्ट-इन: QuadR और QuadS पर आधारित दो अन्य गोल्फ भाषाओं को बनाया है ।
— प्रवेश
10

जावा 8, 271 269 247 210 202 198 193 बाइट्स

a->{for(int n=0,i,j,t,I,J;++n<4;)for(i=a.length;i-->0;)for(j=a[0].length;j-->0;)for(t=4;a[i][j]==n&t-->0;)try{a[I=t>2?i-1:t>1?i+1:i][J=t<1?j-1:t<2?j+1:j]+=a[I][J]<1?n+1:0;}catch(Exception e){}}

जावा और सूचकांक पर निर्भर matrices .. पहले से ही क्रिया भाषा के लिए एक अच्छा संयोजन के साथ शुरू करने के लिए नहीं ..

एक नया लौटने के बजाय इनपुट-मैट्रिक्स को संशोधित करता है।

स्पष्टीकरण:

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

a->{                            // Method with integer-matrix parameter and no return-type
  for(int n=0,i,j,t,I,J;++n<4;) //  Loop `n` in range [1, 4)
    for(i=a.length;i-->0;)      //   Inner loop over the rows
      for(j=a[0].length;j-->0;) //    Inner loop over the columns
        for(t=4;a[i][j]==n&     //     If the current cell contains the current `n`:
                t-->0;)         //      Loop `t` downwards in the range (4, 0]
          try{a[                //       Get the cell at a location relative to the current
                I=t>2?          //        If `t` is 3:
                 i-1            //         Take the cell above
                :t>1?           //        Else if `t` is 2:
                 i+1            //         Take the cell below
                :i][J=t<1?      //        Else if `t` is 0:
                 j-1            //         Take the cell left
                :t<2?           //        Else if `t` is 1:
                 j+1:j]         //         Take the cell right
              +=a[I][J]<1?      //       And if this cell contains a 0:
                 n+1:0;         //        Fill it with `n+1`
          }catch(Exception e){} //       catch and ignore ArrayIndexOutOfBoundsExceptions
                                //       (try-catch saves bytes in comparison to if-checks)
— केविन क्रूज़सेन
स्रोत
8

स्टेंसिल + सीएलए:,3 11 बाइट्स

s:S⋄+∘×⍨⌈/N

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

-1 Adám को धन्यवाद ।
-2 ngn द्वारा एक और उत्तर पर एक सुझाव के लिए धन्यवाद , जिसने मुझे इसे स्टेंसिल से स्टैंसिल + सीएलए में3 परिवर्तित करने का नेतृत्व किया :।

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

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

f=(m,k=1)=>k<4?f(m.map((r,y)=>r.map((v,x)=>v|[-1,0,1,2].every(d=>(m[y+d%2]||0)[x+~-d%2]^k)?v:k+1)),k+1):m

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

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

टिप्पणी की गई

f = (m, k = 1) =>                  // given the input matrix m[] and starting with k = 1
  k < 4 ?                          // if this is not the 4th iteration:
    f(                             //   do a recursive call:
      m.map((r, y) =>              //     for each row r[] at position y in m[]:
        r.map((v, x) =>            //       for each cell v at position x in r[]:
          v |                      //         if v is non-zero
          [-1, 0, 1, 2].every(d => //         or each neighbor cell at (x+dx, y+dy), with:
            (m[y + d % 2] || 0)    //           dy = d % 2 --> [-1, 0, 1, 0]
            [x + ~-d % 2]          //           dx = (d - 1) % 2 --> [0, -1, 0, 1]
            ^ k                    //           is different from k  
          ) ?                      //         then:
            v                      //           let the cell unchanged
          :                        //         else:
            k + 1                  //           set the cell to k + 1
        )                          //       end of inner map()
      ),                           //     end of outer map()
      k + 1                        //     increment k for the next iteration
    )                              //   end of recursive call
  :                                // else:
    m                              //   stop recursion and return m[]
— Arnauld
स्रोत
3

पायथन 3 , 176 बाइट्स

f=lambda a,i=-2,e=enumerate:a*i or f([[E or int((6*max(len(a)>i>-1<j<len(a[i])and a[i][j]for i,j in((r+1,c),(r-1,c),(r,c+1),(r,c-1))))**.5)for c,E in e(R)]for r,R in e(a)],i+1)

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

-18 बाइट्स धन्यवाद श्री Xcoder
-20 बाइट्स के लिए धन्यवाद

— HyperNeutrino
स्रोत
9
" जब मैं कल सुबह उठता हूं और इस कोड को फिर से देखता हूं तो शायद मैं बहुत गूंगा महसूस करने जा रहा हूं। " आप बेहतर होंगे, क्योंकि मैंने आपको जावा में बहिर्गमन किया था। ; पी
— केविन क्रूज़सेन
1
@ केविनक्रूजसेन क्या डी: स्वीकार्य नहीं है। जावा द्वारा पीटा नहीं जाना चाहिए: P
— HyperNeutrino
1
चलो जावा को हरा दें: सी - 196 बाइट्स ।
— श्री Xcoder
@ Mr.Xcoder yay धन्यवाद: c: D
— HyperNeutrino
@ नोव्स ओह अच्छा, टीए!
— हाइपरन्यूट्रिनो 20
3

फोरट्रान 95, 309 299 294 287 269 ​​बाइट्स

subroutine f(a)
integer::a(:,:),s(2)
integer,allocatable::b(:,:)
s=shape(a)
allocate(b(0:s(1)+1,0:s(2)+1))
do1 k=0,3
do1 i=1,s(1)
do1 j=1,s(2)
b(i,j)=a(i,j)
if(any((/b(i+1,j)==k,b(i-1,j)==k,b(i,j+1)==k,b(i,j-1)==k/)).and.b(i,j)<1.and.k>0)b(i,j)=k+1
1 a(i,j)=b(i,j)
end

फोरट्रान एक गोल्फ भाषा नहीं है।

  • संपादित करें: अजीब पुराने जमाने के लूप का उपयोग करके 10 बाइट्स सहेजे गए।
  • संपादित 2: 5 बाइट्स के साथ सहेजा गयाany()
  • संपादन 3: एक अनावश्यक को हटाकर 7 बाइट्स सहेजे गएif
  • संपादित करें 4: की घोषणा को सिकोड़कर 18 बाइट्स सहेजे गएs
— georgewatson
स्रोत
1

पर्ल, 63 बाइट्स

के लिए +3 शामिल है 0ap

perl -0ape 's/0(?=$a|.{@{-}}$a)/$a+1/seg,$_=reverse while($a+=$|-=/
/)<4'

अंतिम न्यूलाइन के बिना अंकों के एक ब्लॉक के रूप में इनपुट मैट्रिक्स दें ।, उदाहरण के लिए

001
000
010

3x3 उदाहरण के लिए। आउटपुट स्वरूप समान है, अंतिम न्यूलाइन के बिना अंकों का एक ब्लॉक।

आप जैसी छोटी स्क्रिप्ट का उपयोग कर सकते हैं 

perl -i -0pe 's/\n*$//' <file>

यदि आपके पसंदीदा संपादक में ऐसा करना कठिन है, तो फ़ाइल से अंतिम नई सूचियों को आसानी से हटा दें

— टन हास्पेल
स्रोत
1

रेटिना , 93 87 84 बाइट्स

1
4
3{m`(?<=^(.)*)0(?=4|.*¶(?>(?<-1>.)*)4|(?<=40|^(?(1)_)(?<-1>.)*4.*¶.*))
5
T`1-5`d

इसे ऑनलाइन आज़माएं! मेरे जवाब के आधार पर इसे मार डालो आग के साथ । संपादित करें: सहेजे गए 6 9 बाइट @MartinEnder के लिए धन्यवाद। स्पष्टीकरण:

1
4

सभी 1s को 4s में बदल दें।

3{

कार्यक्रम के बाकी हिस्सों को दोहराएं (अधिक से अधिक) 3 बार।

m`(?<=^(.)*)0(?=4|.*¶(?>(?<-1>.)*)4|(?<=40|^(?(1)_)(?<-1>.)*4.*¶.*))
5

4s से सटे सभी 0s को 5s में बदलें।

T`1-5`d

सभी अंकों में कमी।

रेटिना 0.8.2 , 100 94 बाइट्स

1
3
{m`(?<=^(.)*)0(?=3|.*¶(?>(?<-1>.)*)3|(?<=30|^(?(1)_)(?<-1>.)*3.*¶.*))
4
T`1-4`d`^[^1]+$

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

1
3

सभी 1s को 3s में बदल दें।

{

तब तक दोहराएं जब तक आउटपुट नहीं बदलता।

m`(?<=^(.)*)0(?=3|.*¶(?>(?<-1>.)*)3|(?<=30|^(?(1)_)(?<-1>.)*3.*¶.*))
4

4s में 3s से सटे सभी 0s बदलें।

T`1-4`d`^[^1]+$

यदि 1s नहीं हैं, तो सभी अंकों को घटाएं।

— नील
स्रोत
आप !इसके बजाय एक चरित्र का उपयोग करके कुछ बाइट्स बचा सकते हैं (जो इनपुट में प्रकट नहीं हो सकते हैं) (?!)।
— मार्टिन एंडर
@MartinEnder थैंक्स, जो इसे किल फॉर फायर के लिए भी काम करता है (और मुझे एक अलग-अलग 2-बाइट वाला गोल्फ मिला जो मैं वहां था!)
— नील
1

रूबी , 183 158 146 बाइट्स

->a{3.times{|n|a.size.times{|i|r=a[i];r.size.times{|j|(r[j]<1&&[i>0?a[i-1][j]:0,a[i+1]&.at(j),j>0?r[j-1]:0,r[j+1]].include?(n+1))?r[j]=n+2:0}}};a}

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

स्पष्ट तीन-लूप एल्गोरिथ्म का उपयोग करता है। तथ्य यह है कि रूबी सरणियों में नकारात्मक अनुक्रमण की अनुमति देता है इसका मतलब है कि सीमा की जांच करने के आसपास कोई रास्ता नहीं है (कि मैं देख सकता हूं)। एक सरणी रिटर्न की सीमा से परे पहुंचना nil, इसलिए केवल नकारात्मक बाध्य चेक आवश्यक हैं। a[i+1][j]बस के लिए चेक सुरक्षित पहुँच ऑपरेटर का उपयोग करने की आवश्यकता है।

मैं भी एक चर का उपयोग करके कुछ बाइट्स से मुंडा a[0]।

-12 और बाइट्स: (तीन स्थानों पर) के .timesबजाय का उपयोग करें (0...x).map।

->a{
  3.times{|n|                    # For n from 0 to 2
    a.size.times{|i|             # For each row
      r=a[i];
      r.size.times{|j|           # For each column
        (r[j]<1 && [             # If the current cell is 0, and any of
            i>0 ? a[i-1][j] : 0, #     the cell to the north,
            a[i+1]&.at(j),       #     the cell to the south,
            j>0 ? r[j-1] : 0,    #     the cell to the west,
            r[j+1]               #     or the cell to the east
          ].include?(n+1)        #   are set to the previous value,
        ) ? r[j]=n+2 : 0         # Set this cell to the next value (or 0)
      }
    }
  };
  a                              # Return the modified array
}
— benj2240
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.