क्या जिमी अपनी रस्सी पर लटक सकता है?

18

फिर भी अपने मूल पिता द्वारा एक और जिमी चुनौती। देखिए ये दूसरी प्यारी चुनौतियां ।

जैसा कि आप सभी जानते हैं, हाल ही में हम प्लेटफार्मों पर जिमी से संबंधित चुनौतियों को देख रहे हैं। अब, जिमी एक कलाबाज है जैसा कि मैंने पहले उल्लेख किया है, और उसने अपनी आस्तीन ऊपर अन्य चालें प्राप्त की हैं।

इनमें से एक चाल रस्सियों से लटकी हुई है। यहाँ एक रस्सी जिमी से लटकने का एक उदाहरण दिया जा सकता है:

            ||
            ||
            ||
            ||
            ||
            ||

जब जिमी रस्सी पर लटकता है, तो वह ऐसा दिखता है:

            ||
            ||
           /o\
            ||
            ||
            ||

वह रस्सी के बाईं या दाईं ओर लटक सकता है, इसलिए:

            ||
            ||
            ||
            /o\
            ||
            ||

भी मान्य है। लेकिन वह सिर्फ एक शरीर के हिस्से से नहीं लटक सकता, इसलिए ऐसा कुछ भी:

            ||
            ||
            ||
          /o\|
            ||
            ||

अमान्य है। ध्यान दें कि जब वह शरीर के एक हिस्से से लटक रहा होता है तो रस्सी का दूसरा भाग दिखाई देता है क्योंकि जिमी उसे कवर नहीं करता है।

इसके अलावा, जिमी को रस्सी के नीचे लटकना पसंद नहीं है - यह उसे डराता है - इसलिए:

            ||
            ||
            ||
            ||
            ||
            /o\

अमान्य है।

चुनौती

जिमी स्थिति का इनपुट ऊपर के लोगों की तरह लें, और आउटपुट दें कि जिमी रस्सी पर लटकेगा या नहीं, सच्चाई या झूठे मूल्य के माध्यम से।

बारीकियाँ

  • एक प्रोग्राम लिखें जो इनपुट लेता है। यह एक फ़ंक्शन या किसी अन्य उपयुक्त इनपुट विधि के माध्यम से हो सकता है।

    1. इनपुट में एक जिमी का एक दृश्य होना चाहिए और एक रस्सी जैसा कि ऊपर उदाहरण दिया गया है।

  • कार्यक्रम को सांत्वना के लिए एक सत्य या मिथ्या मूल्य का उत्पादन करना चाहिए कि क्या जिमी रस्सी पर लटका सकता है या अगर वह रस्सी से गिर जाएगा, तो क्रमशः।

  • जिमी रस्सी पर लटकने में सक्षम होने के मापदंड:

    1. उसके शरीर के दो हिस्से रस्सी पर हैं।

    2. वह रस्सी के नीचे नहीं है।

    3. वह मध्य हवा में नहीं तैर रहा है।

  • आप मान सकते हैं कि रस्सी सीधी होगी, ||खंडों से बनी होगी, और ऊंचाई में एक वर्ण से अधिक लंबी होगी।

  • आप एक पूरी रस्सी मान सकते हैं और एक विलक्षण जिमी आपके दृश्य में मौजूद होगा, कोई कम और कोई कम नहीं।

  • आप मान सकते हैं कि रस्सी के निचले भाग में कोई नई रूपरेखा नहीं होगी।

  • आप रस्सी से पहले और बाद में किसी भी अग्रणी या अनुगामी रिक्त स्थान को कवर करना चाहिए।

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

           ||
           ||
           ||                 TRUTHY
           /o\
           ||
           ||


            ||
            ||
          /o\|                FALSY
            ||
            ||


        ||
       /o\                    TRUTHY
        ||


            ||
           /o\                FALSY


         /o\
          ||                  TRUTHY


            ||
            ||
       /o\  ||                FALSY
            ||
            ||

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम स्कोर लगभग एक हफ्ते के बाद जीतता है।

लीडरबोर्ड

आप नीचे दिए गए विजेट / स्निपेट का विस्तार करके इस पोस्ट के लिए लीडरबोर्ड देख सकते हैं। आपकी पोस्ट को रैंकिंग में शामिल करने के लिए, आपको # header textनिम्नलिखित जानकारी के साथ एक हेडर ( ) चाहिए:

  • भाषा का नाम (इसे कॉमा ,या डैश के साथ समाप्त करें -), उसके बाद ...

  • बाइट गिनती, आपके शीर्ष लेख में दिखाई देने वाली अंतिम संख्या के रूप में।

उदाहरण के लिए, JavaScript (ES6), 72 bytesमान्य है, लेकिन Fortran, 143 bytes (8-bit)अमान्य है क्योंकि बाइट गिनती हैडर में अंतिम संख्या नहीं है (आपका उत्तर 8 बाइट्स के रूप में पहचाना जाएगा - इसका लाभ न लें)।

<!-- Run the snippet to see the leaderboard. Report any bugs to @ozewski on Github. -->    <iframe src="https://ozewski.github.io/ppcg-leaderboard/?id=187759" width="100%" height="100%" style="border:none;">Oops, your browser is too old to view this content! Please upgrade to a newer version of your browser that supports HTML5.</iframe><style>html,body{margin:0;padding:0;height:100%;overflow:hidden}</style>
स्निपेट का विस्तार करें

code-golf  string  ascii-art  parsing 
— अपना चार्जर कनेक्ट करें
स्रोत
1
क्या रस्सी में हमेशा एक ही नंबर का स्पेस होने वाला है, या क्या वह अलग-अलग हो सकता है?
— 15 मार्च को mprogrammer
@ मैक्सवेल जो भिन्न हो सकते हैं।
— 15y:58 पर connectyourcharger
क्या हम इनपुट को एक सूची की तरह कुछ ले सकते हैं, जहां प्रत्येक पंक्ति एक अलग स्ट्रिंग है, या क्या यह एक एकल स्ट्रिंग होना चाहिए?
— 16 मार्च को mprogrammer
19
जिमी को वास्तव में छुट्टी लेनी चाहिए
— लुइस मेन्डो
7
@LuisMendo जिमी वह क्या करता है के लिए समर्पित है!
— संयोजक जूल

जवाबों:

13

जाप , 5 बाइट्स

मुझे लगता है कि यह सही है; मैं 16 घंटे के लिए काम कर रहा हूँ सीधे और मुश्किल से मेरा अपना नाम पता है तो मुझे आश्चर्य नहीं होगा अगर यह नहीं है!

Õø|io

कोशिश करो

Õø|io     :Implicit input
Õ         :Transpose
 ø        :Contains?
  |io     :  "|" prepended with "o"
— झबरा
स्रोत
2
16 घंटे? अब यही समर्पण है!
— संयोजक जूल
2
प्रतीक्षा करें तो आपको 5 बाइट्स लिखने में 16 घंटे लग गए? ;-)
— कुलुबुल
लगता है कि आपको एक ब्रेक की जरूरत है (थोड़ी सलाह जिमी के लिए जाती है!)।
— Ivenvenoidea
@connectyourcharger, नहीं, यह मेरा जीवन है! समर्पण यह एक ब्रेक के बिना कर रहा होगा। जो मैंने किया!
— झबरा
1
@ihavenoidea, Pfft! मैं तभी सोऊंगा जब मैं मर जाऊंगा!
— झबरा
22

अजगर 2 या 3 ,  33  30 बाइट्स

-3 मैक्सवेल को धन्यवाद

lambda l:'o'in map(max,l[:-1])

एक अनाम फ़ंक्शन जो लाइनों की एक सूची को स्वीकार करता है

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

कैसे?

जिमी द्वारा अस्पष्ट रस्सी का एक खंड होने की आवश्यकता है जो नीचे नहीं है।

lambda l:'o'in map(max,l[:-1])
lambda l:                      # a function taking l (the lines as strings)
                       l[:-1]  # strip off the last line
               map(max,      ) # maximum of each line (where '|'>'o'>'\'>'/'>' ')
         'o'in                 # was 'o' one of them? (hence Jimmy obscured all the rope)
— जोनाथन एलन
स्रोत
तीन बाइट्स बचाएं:lambda l:'o'in map(max,l[:-1])
— mprogrammer
ओह, बहुत सूक्ष्म - धन्यवाद!
— जोनाथन एलन
यह ASCII मूल्यों का एक बहुत ही चतुर उपयोग है। अच्छा लगा।
— निधि मोनिका का मुकदमा
16

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

lambda x:"o', '|"in`zip(*x)`

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

यह कैसे काम करता है? यह स्ट्रिंग्स की सूची के रूप में इनपुट लेता है, और ज़िप स्ट्रिंग में शामिल होता है। जिमी रस्सी पर रहता है अगर वहाँ एक "है।" एक "ओ" के नीचे, इसलिए यह कोड सभी लाइनों और जाँच में शामिल होता है अगर कोई "ओ" है जिसके बाद एक "" है।

एनोटेट कोड:

lambda x: # Creates an anonymous function that takes one argument
  "o', '|" # If this substring is in the zip object, then Jimmy's "o" is above a "|"
    in
    `    # Back quotes change the object into its string representation
    zip(*x)` # Joins the lines together

(पुराना उत्तर) अजगर 2 या 3, 39 बाइट्स

lambda x:1-all("|"in i for i in x[:-1])

एक फ़ंक्शन जो इनपुट को स्ट्रिंग्स की एक सूची के रूप में लेता है, प्रत्येक स्ट्रिंग एक अलग लाइन है।

-11 बाइट्स के लिए धन्यवाद xnor! जोनाथन एलन को -2 बाइट्स धन्यवाद!

इसे ऑनलाइन आज़माएं! (यदि आप अधिक परीक्षण मामलों को आज़माना चाहते हैं, तो इनपुट बॉक्स में लाइनों के प्रत्येक सेट के बाद "a।" डालें।)

यह कैसे काम करता है? ठीक है, अगर जिमी पूरी तरह से रस्सी पर है, तो उस लाइन में कोई भी नहीं होगा "|" पात्र। इसलिए, हम प्रत्येक पंक्ति की जांच कर सकते हैं, और अगर हमें कोई नहीं मिल रहा है "|" अक्षर, तो हम जानते हैं कि जिमी रस्सी पर रह सकता है। हालांकि, जिमी रस्सी के नीचे की तरफ नहीं लटक सकता है; इसलिए, हम अपने चेक में अंतिम पंक्ति को शामिल नहीं करते हैं। अगर अंतिम पंक्ति रस्सी का सिर्फ एक और हिस्सा है, तो इससे कोई फर्क नहीं पड़ेगा, क्योंकि हम अभी भी एक वैध पंक्ति को ऊपर पाएंगे, लेकिन अगर अंतिम पंक्ति जिमी के साथ एक है, तो यह एक पंक्ति नहीं पाएगी बिना "|" कहीं भी, और झूठा लौट आएगा।

— mprogrammer
स्रोत
क्या आप इसे चेक के बिना कर सकते हैं कि लाइन में "/" है?
— xnor
@ एक्सनोर यूप! -11 बाइट्स
— mprogrammer
1
एक जोड़े को ऐसे बचाएं:lambda x:1-all("|"in i for i in x[:-1])
— जोनाथन एलन
1
आउच, आप और तेज़ थे :)
— डेनियल टूटूबलिन
1
@KlaymenDK फ़ंक्शन x [: - 1] के माध्यम से प्रसारित होता है, x नहीं। x [: - 1] अंतिम तत्व को छोड़कर सूची के सभी तत्व हैं, क्योंकि पायथन में आप नकारात्मक सूचकांकों का उपयोग कर सकते हैं। इसलिए, यह (सही ढंग से) झूठा परिणाम देता है यदि जिमी रस्सी के नीचे होता है।
— mprogrammer
8

जेली ,  ९ elly  ६ बाइट्स

Ṗ<”|ṀẠ

लाइनों की एक सूची को स्वीकार करने वाला एक अद्वैत लिंक

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

कैसे?

जिमी द्वारा अस्पष्ट रस्सी का एक खंड होने की आवश्यकता है जो नीचे नहीं है।

Ṗ<”|ṀẠ - Main Link: list of lines of characters
Ṗ      - remove last line
  ”|   - pipe character
 <     - less than? (vectorises) - Note that all other characters are
    Ṁ  - maximum
     Ạ - all?
— जोनाथन एलन
स्रोत
1
मुझे लगता है कि जिमीज़ के बारे में इन चुनौतियों को लिखना कितना अजीब है। एक बार जब आप एक ही रस्सी से लटकते हुए कई जिमीज़ की कल्पना करते हैं तो यह आपको अजीब लगने लगता है।
— 16y:04 पर कनेक्टयूरचैगर
1
@connectyourcharger पूर्वाभास?
— नकारात्मक सात
@negativeseven संभवतः। मैंने पहले ही जिमी के सभी पोस्टों को अनुक्रमित करने के लिए मेटा समुदाय विकी पर विचार किया है।
— कनेक्टयूरचार्जर
1
नौ बाइट्स, और एक बार फिर, हमें अभी भी पता चलता है कि कोई कैसे मर सकता है।
— IMustBeSomeone
1
" Note that all other characters are [less than '|']"?
— निकोलर जूल
5

ब्रेनफक, 79 64 बाइट्स

>>+<<,[----------[<]>>[.-]+<[>-]+[---------<-->]<[<]>>[-]<[>]<,]

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

सत्य के लिए 0x01 बाइट को आउटपुट करता है और मिथ्या के लिए कुछ भी नहीं।

Z: 0
A: input
B: 0
C: has no | been found on this line?

>>+<<                       initialize C to 1
,[                          loop over each char

  ----------                set A to 0 if input was \n
  [<]>>                     move to C if input was \n; B otherwise
  [                         if input was \n and C is true
    .-                      output 1
  ]

  +                         this will reinitialize C to 1 if input was \n
                            but also clobber B with 1 if it wasn't
                            now we have { 0   0   0  (1)} if input was \n;
                                        { 0   _  (1)  _ } otherwise
  <[>-]                     clear own cell if the one to the left is positive
                            this yields { 0   0  (0)  1 } and
                                        { 0   _  (0)  _ } as desired

  +[---------<-->]          set A to 0 if input was |
  <[<]>>                    move to C if input was |; B otherwise
  [-]                       zero out current cell: clears C if input was |
  <[>]<                     realign pointer onto A

,]                          break on end of input
— Doorknob
स्रोत
4

05AB1E , 5 बाइट्स

Çü%àθ

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

Ç         # convert the input to a 2D array of codepoints
 ü%       # pairwise modulo (vectorized)
   à      # maximum (*not* vectorized, returns a single number)
    θ     # tail (last digit)

इनपुट में दिखाई देने वाले एकमात्र पात्र \o/ |संबंधित कोडपॉइंट्स 92, 111, 47, 32, 124 के साथ हैं (कोई नई बात नहीं है, क्योंकि हमने इनपुट को एक पंक्ति के रूप में चुना है)। इनमें से दो संख्याओं को संशोधित करके संभावित परिणाम 0, 13, 15, 17, 19, 28, 30, 32, 45, 47, 92, 111 हैं। 111 उनमें से सबसे बड़ा है, और केवल 1 के साथ समाप्त होता है , तो कोड सत्य का उत्पादन करेगा यदि और केवल 111 सूची में मौजूद है (केवल 1 05AB1E में सत्य है)। 111 111 ( o)% 124 ( |) है, और ऐसा केवल तभी होता है जब इनपुट में oऊपर है |।

— ग्रिमी
स्रोत
1
जोड़ीदार मोडुलो के साथ बहुत अच्छा।
— केविन क्रूज़सेन
3

एपीएल (Dyalog यूनिकोड) , 8 बाइट्स SBCS

अनाम मौन उपसर्ग फ़ंक्शन, तर्क के रूप में एक वर्ण मैट्रिक्स ले रहा है।

1∊'o|'⍷⍉

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

⍉ पक्षांतरित

'o|'⍷ हर जगह के लिए मुखौटा oतत्काल पीछा किया जाता है|

1∊ क्या उसका कोई सदस्य है?

— एडम
स्रोत
2

जावास्क्रिप्ट, ३ ९ 33 बाइट्स

2 बाइट्स से गोल्फिंग के लिए @Daniil Tutubalin धन्यवाद

x=>!!x.match(/^( *)\/[^|]*\n/m)

यह किसी भी रेखा से मेल खाता है जो वह रेखा नहीं है जहाँ उसका बायाँ हाथ दिखाई देता है और कोई भी रस्सी नहीं दिखाती है।

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

— fənɛtɪk
स्रोत
यह असफल प्रतीत होता है अगर वह रस्सी के नीचे है
— fɛnɪt Julk
यह विफल होना चाहिए अगर वह सबसे नीचे है, है ना? क्योंकि जिमी गिर जाता है अगर वह रस्सी के नीचे है
— mprogrammer
मेरा मतलब है कि जब मैं उसे रस्सी के नीचे किसी कारण से अपने कार्य के लिए वापस लाया तो 1
— f atnɛtɪk
हम्म, फिर कभी नहीं।
— mprogrammer
1
किस बारे में /^ *.o. *\n/?
— tsh
2

/// , 53 50 बाइट्स

/~/\/\~/\/o\\/1~1 /1~ 1/1~|1~/1|~/|~/1.~/ ~/.~/
~.

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

क्योंकि /// में इनपुट लेने का कोई अन्य तरीका नहीं है, यह हार्ड-कोडेड है:

/~/\/\~/\/o\\/1~1 /1~ 1/1~|1~/1|~/|~/1.~/ ~/.~/
~<INPUT HERE>.

स्पष्टीकरण:

सामान्य दृष्टिकोण जिमी को 1 के साथ बदलना है, फिर उसे उन सभी स्थितियों से हटा दें जहां वह खतरे में है। यदि वह जीवित रहता है, तो उसे आउटपुट किया जाता है। अगर वह नहीं है, तो कुछ भी नहीं है। ~कोड में के लिए एक स्थानापन्न कर रहे हैं //, जो कोड 3 बाइट्स यहाँ से छोटा किया जा करने के लिए अनुमति देते हैं। उन्हें स्पष्टीकरण से हटा दिया गया है।

/{/\//
/}/\/\//

          {The top two lines allow me to leave comments without disturbing the code.}

/\/o\\/1/ {Replace Jimmy with a 1.}
/1 /1/    {Get rid of any spaces in front of Jimmy. This moves Jimmy towards the rope from the left.}
/ 1/1/    {Get rid of any spaces after Jimmy. This moves Jimmy towards the rope from the right.}

/|1//     {If Jimmy is touching the rope, remove him and the rope.}
/1|//     {This is based on the observation that in all cases where Jimmy is safe, there is no visible rope on his line.}


/|//      {Remove any remaining rope. If Jimmy was touching a rope, it's already too late for him.}
/1.//     {This handles the case where Jimmy is at the bottom of the rope (hence the period at the end).}


/ //      {The remaining lines clean up the output.}
/.//
/
//

           ||
           ||
           ||
           /o\
           ||.

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

— कॉमरेड स्पार्कलपनी
स्रोत
2

रूबी 2.5.5, 22 बाइट्स

->x{x.pop;!x.all? /\|/}

लाइनों की एक सरणी की अपेक्षा करता है। 2.5.5 के न्यूनतम संस्करण की आवश्यकता है क्योंकि यह Array#all?(pattern)जोड़ा गया है।

बाधाओं के कारण कि इनपुट हमेशा जिमी और रस्सी का एक वैध दृश्य होगा, यह उबलता है कि क्या अंतिम पंक्ति से पहले की लाइनों में से कोई भी रस्सी अस्पष्ट है।

— DaveMongoose
स्रोत
1

रेटिना , 9 बाइट्स

m`^[^|]+^

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

अब, मैंने पहले कभी रेटिना में प्रोग्राम नहीं किया है, लेकिन जहां तक ​​मैं यह काम बता सकता हूं। यह एक नियमित अभिव्यक्ति है जो एक स्ट्रिंग युक्त इनपुट का पता लगाता है (1) इनपुट की शुरुआत, (2) नहीं "| अक्षर, और (3) एक नई रेखा।

नियमित अभिव्यक्ति या रेटिना से अधिक परिचित लोग सुझाव देने के लिए प्रोत्साहित होते हैं। -2 बाइट्स नील को धन्यवाद!

— mprogrammer
स्रोत
दो विकल्प: 1) \nक्योंकि नई लाइन नहीं है , इसलिए निकालें |और वैसे भी मेल खाएंगे, और अंतिम ^यह सुनिश्चित करने के लिए कि आप वास्तव में एक नई रेखा से मेल खाते हैं। 2) के बजाय एक पायलट का उपयोग करें \nऔर अनुगामी को हटा दें ^(क्योंकि यह बहुस्तरीय मोड में एक नई रेखा के बाद हमेशा सच होता है)।
— नील
1

बेफ़ुंज -98 (PyFunge) , 26 24 बाइट्स

]~:a-!#v_' `+
^_-3q#$<
@

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

रिटर्न कोड 3 के साथ बाहर निकलता है यदि \nसामना किया गया है और अंतिम पंक्ति में 3 गैर-अंतरिक्ष वर्ण हैं, अन्यथा ईओएफ पर रिटर्न कोड 0 के साथ बाहर निकलता है। इस प्रकार, यह अंतिम पंक्ति पर निर्भर करता है जिसमें अनुगामी नई रेखा नहीं होती है।

विच्छेदित

]~                     :a-!#v_                ' `+
 Read character,      Branch downwards if   Increment counter on 
 branch up (and        equal to 10 ('\n')   the stack if greater
 loop around) if                            than 32 (' ') and
 end of stream                              implicitly loop

^_-3q#$<                    <
 Return with code 3
 if counter is equal to 3,
 otherwise reset counter
 and return to beginning

@
 Return with exit
 code 0
— नकारात्मक सात
स्रोत
1

05AB1E (विरासत) , 6 बाइट्स

ζJ„o|å

पोर्ट ऑफ @ शागी का जाप उत्तर ।

लाइनों की एक सूची के रूप में इनपुट।

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

स्पष्टीकरण:

ζ       # Zip/transpose the (implicit) strings in the input-list, with space as filler
        # (NOTE: zip/transpose doesn't work on string-list in the new version of 05AB1E,
        #  which is why we use the legacy version)
 J      # Join these zipped/transposed lines together to a single string
  „o|å  # And check if it contains the string "o|"
        # (after which the result is output implicitly)
— केविन क्रूज़सेन
स्रोत
1
— ग्रिमी
1

एल्म 0.19, 68 बाइट्स

f r=List.any(not<<String.contains"|")(List.take((List.length r)-1)r)

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

सभी परीक्षण मामलों को यहां सत्यापित करें ।

— OOBalance
स्रोत
1

शक्ति कोशिका , 26 बाइट्स

रेटिना के लिए मैक्सवेल के जवाब का पोर्ट ।

"$args"-match'(?m)^[^|]+^'

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

स्पष्टीकरण:

true अगर:

  1. एक दृश्य में एक पंक्ति होती है जिसमें चरित्र नहीं होता है |
  2. और इस लाइन के बाद एक नई लाइन की शुरुआत होती है।

false अन्यथा।

— Mazzy
स्रोत
0

पाइरेट, 79 बाइट्स

{(l):all2({(r,n):string-char-at(n,string-index-of(r,"o") == "|")},l,link(0,l))}

तार के रूप में लाइनों की एक सरणी की उम्मीद है। एक प्रति बनाता है link(0,l)जहां सभी पंक्तियों को एक-एक करके स्थानांतरित कर दिया जाता है। प्रत्येक पंक्ति के माध्यम से जाता है rऔर nजहां n नीचे पंक्ति है। जाँच करता है कि अगर जिमी का शरीर "o"किसी स्थिति में है, तो उसके नीचे की पंक्ति में एक पाइप है (यानी जिमी रस्सी पर लटका हुआ है और नीचे नहीं है)।

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