यह क्या है? - ROT-n को डिक्रिप्ट करें

25

यहाँ अंग्रेजी वर्णमाला के अक्षर क्रम से हैं:

e t a o i n s h r d l c u m w f g y p b v k j x q z

यही है, eसबसे अधिक इस्तेमाल किया जाने वाला पत्र है, और zकम से कम सामान्य है। ( विकिपीडिया से डेटा ।)

आपकी चुनौती कुछ ROT-n'd पाठ लेने की है, जैसे:

ocdndnvqzmtnzxmzohznnvbzocvodnqzmtnzxpmzviynvaz

यह ROT-21 (42 का आधा) के माध्यम से "एनक्रिप्टेड" है कि "thisisaverysecretmessagetisverysecureandsafe" पाठ है। आपका प्रोग्राम, ऊपर की आवृत्ति तालिका का उपयोग करके, यह निर्धारित करने में सक्षम होना चाहिए कि प्रत्येक वर्ण को कितना घुमाया गया था और मूल पाठ।

(यदि आप ROT-n से परिचित नहीं हैं, तो यह अनिवार्य रूप से प्रत्येक वर्ण को शिफ्ट कर रहा है n। उदाहरण के लिए, ROT-2 में a -> c, b -> d, ..., x -> z, y -> a, z -> b।)

कैसे, आप पूछें? (बहुत भोली) एल्गोरिथ्म जो आपको उपयोग करना चाहिए वह है:

  • प्रत्येक के लिए nसे 0करने के लिए 25समावेशी, ROT- लागू -nइनपुट स्ट्रिंग के लिए। (नकारात्मक nक्योंकि हम एन्क्रिप्शन को उलटना चाहते हैं । ROT- ROT- -nके बराबर है 26-n, अगर यह कोई आसान है।)
  • वर्णों के सापेक्ष आवृत्तियों को जोड़कर प्रत्येक इनपुट स्ट्रिंग को संख्या में परिवर्तित करें। eहै 0, tहै 1, aहै 2आदि उदाहरण के लिए, स्ट्रिंग के लिए इसी नंबर "hello"7 + 0 + 10 + 10 + 3 = 30 है।
  • वह स्ट्रिंग ढूंढें जिसमें सबसे कम संख्या हो।
  • उत्पादन कि स्ट्रिंग और इसके अनुरूप n।

नियम:

  • इनपुट कहीं भी वाजिब हो सकता है (STDIN, फंक्शन आर्ग्युमेंट्स, किसी फाइल आदि से), और इसलिए आउटपुट (STDOUT, फंक्शन रिटर्न वैल्यू, फाइल के लिए इत्यादि) कर सकता है।
  • आप एक अलग एल्गोरिथ्म का उपयोग कर सकते हैं, जब तक कि यह हमेशा समान परिणाम उत्पन्न करता है। उदाहरण के लिए, z0 होना और e25 होना और उच्चतम संख्या चुनना भी ठीक है।
  • यदि दो तारों में समान स्कोर हैं, तो आप उनमें से किसी एक (या दोनों) को आउटपुट करना चुन सकते हैं। यह एक एज केस है और आपको इसका हिसाब नहीं रखना है।
  • यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाएगा!

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

इनपुट: ocdndnvqzmtnzxmzohznnvbzocvodnqzmtnzxpmzviynvaz
आउटपुट:21 thisisaverysecretmessagethatisverysecureandsafe

इनपुट: pmttwxmwxtmwnxzwoziuuqvoxchhtmakwlmowtnabiksmfkpivom
आउटपुट:8 hellopeopleofprogrammingpuzzlescodegolfstackexchange

इनपुट: ftueimeqzodkbfqpiuftdaffiqxhqeaufygefnqbqdrqofxkemrq
आउटपुट:12 thiswasencryptedwithrottwelvesoitmustbeperfectlysafe

इनपुट: jgtgkuvjghkpcnvguvecugvjcvaqwowuvfgetarv
आउटपुट:2 hereisthefinaltestcasethatyoumustdecrypt

यदि आप सोच रहे थे, तो यहां जावास्क्रिप्ट परीक्षण कोड का एक JSFiddle मैंने लिखा है, जो मैंने उस पर फेंकने वाले सभी परीक्षण मामलों को सफलतापूर्वक डिक्रिप्ट किया है।

code-golf  string  cryptography 
— Doorknob
स्रोत
किनारे के मामलों पर ध्यान देना उपयोगी हो सकता है। उदाहरण के लिए, wtaadदेना चाहिए 0 wtaadपरिणाम के रूप में, और vszzcदेना चाहिए 25 wtaadपरिणाम के रूप में।
— मेलमोकब
आपको TrippleROT-N के कार्यान्वयन का पता लगाने के लिए अतिरिक्त अंक देने चाहिए।
— user19713
@ user19713 ट्रिपलरोट क्या है? मेरा मतलब है, ROT-6 और तीन बार ROT-2 में क्या अंतर है?
— मिस्टर लिस्टर
2
@mrlister यह एक पुराना क्रिप्टोकरंसी है जो पेशाब को ट्रिपलडीएस से बाहर ले जाता है।
— user19713
क्या हम डिक्रिप्टेड स्ट्रिंग के बाद n- रूट आउटपुट कर सकते हैं?
— मेयरमोनी

जवाबों:

6

गोल्फस्क्रिप्ट - 87

यहां धोखा हर रोटेशन को एक साथ बनाने का है। चूँकि हमें हर ROT पर हर लूप के बाद लूप की जरूरत होती है, तो बस हर कैरेक्टर पर लूप करें, पूरी वर्णमाला को स्लाइस करें, फिर इसे ज़िप करें। वहाँ से अपेक्षित रूप से आगे बढ़ें: प्रत्येक आरओटी के लिए अंक गिनें और न्यूनतम चुनें।

अतिरिक्त गोल्फ:

{97- 26,{97+}%.+''+>}/]{27<}%zip:d{{"etaoinshrdlcumwfgypbvkjxqz"?}%{+}*}%.$0=?.26\-\d=

केवल थोड़ा गोल्फ:

# the alphabet, and by frequency
26,{97+}%.+''+:a;
"etaoinshrdlcumwfgypbvkjxqz":f;

# build evey ROT decryption
{97-a>}/]{27<}%zip:d

# calculate likelihood
{{f?}%{+}*}%.

# find min
$0=

# output rotation factor and decryption
?.26\-\d=
— couchand
स्रोत
8

हास्केल - 192 175

f y=sum.map(\x->length.fst$break(==x)y)
main=interact(\s->snd$minimum$[(f"etaoinshrdlcumwfgypbvkjxqz"r,show(26-n)++" "++r)|n<-[0..25],let r=map(\x->([x..'z']++['a'..])!!n)s])

चल रहा है

% ./rot-n <<< "pmttwxmwxtmwnxzwoziuuqvoxchhtmakwlmowtnabiksmfkpivom"
8 hellopeopleofprogrammingpuzzlescodegolfstackexchange
— बेंत की मार
स्रोत
संक्षेप लंबाई के बजाय, आप संख्याओं को एकात्मक, उदा। में संख्याओं का प्रतिनिधित्व करते हुए बना सकते हैं [1,1,1,1], और यह समान क्रम देगा। मैपिंग और संक्षेपण तब हो जाता है, concatMapजिसे एक सूची समझ का उपयोग करके आसानी से लिखा जा सकता है। कुछ अन्य ट्रिक्स के साथ, मैंने इसे 152 वर्णों तक छोटा कर दिया main=interact(\s->snd$minimum[([1|x<-r,_<-fst$span(/=x)"etaoinshrdlcumwfgypbvkjxqz"],show(26-n)++' ':r)|n<-[0..25],r<-[[([x..'z']++['a'..])!!n|x<-s]]]):।
— हमर
7

GolfScript, 112 108 102 100 वर्ण

{{}/]{97-}%}:b~:|;"etaoinshrdlcumwfgypbvkjxqz"b:f,:&,{:x[|{&x-+&%f?}%{+}*\]}%$0=1=:x|{&x-+&%97+}%''+

मैं अंत में फिर से डिक्रिप्टिंग के साथ दोहराव के बारे में खुश नहीं हूं, लेकिन meh।

Ungolfed (यदि इसका कोई अर्थ है: P) और थोड़ा पुराना संस्करण:

# store input IDs (a = 0, b = 1, etc.) in s
[{}/]{97-}%:s;
# store frequency data IDs in f (blah, repetition)
"etaoinshrdlcumwfgypbvkjxqz"[{}/]{97-}%:f

# for each number from 0 to 26 (length of previous string left unpopped)...
,,{
  # the number is x
  :x;
  # return an array of...
  [
    # the score
    s{x 26\-+26%f?}%{+}*
    # and the n
    x
  ]
}%

# use $ort to find the n to output
$0=1=:x

# get the string that the n corresponded to (blah, more repetition)
s{x 26\-+26%97+}%''+
— Doorknob
स्रोत
"इनपुट कहीं भी उचित हो सकता है" गोल्फस्क्रिप्ट की मदद करता है। पहले तो मैं यह पता नहीं लगा सका कि हमारी स्क्रिप्ट्स अंत में एक अतिरिक्त चरित्र को प्रिंट करने के लिए क्यों महसूस करती हैं, जब तक मुझे एहसास नहीं हुआ echoकि डिफ़ॉल्ट रूप से एक नई पंक्ति है, जो दुभाषिया चुनता है।
— Couchand
6

जावास्क्रिप्ट (205)

f='zqxjkvbpygfwmucldrhsnioate';a='abcdefghijklmnopqrstuvwxyz';for(s=prompt(o=m=n=0)
,i=27;i--;w>m&&(m=w,n=i,o=u))for(u='',w=c=0;c<s.length;w+=f.indexOf(x))u+=x=(a+a)[a
.indexOf(s[c++])+i];alert((26-n)+' '+o)

मुझे लगता है कि यह अभी भी थोड़ा और अधिक गोल्फ हो सकता है, इसलिए सुझावों का स्वागत है!

समाधान को समझने में मदद करने के लिए कुछ नोट्स

  • m, nऔर oउच्चतम स्कोर को ट्रैक करें।
  • uऔर wवर्तमान के लिए क्रमशः चरित्र और मूल्य परिणाम को ट्रैक करते हैंi
  • (a+a)अतीत के दौरान लपेटते समय अतिप्रवाह को रोकने में मदद करता है z, और ऐसा करने से कम होता है%26
  • मेरे पास रिवर्स ऑर्डर में आवृत्ति है, इसलिए मैं मिनट के बजाय अधिकतम खोज कर सकता हूं।

प्रमाण: http://jsfiddle.net/J9ZyV/5/

— mellamokb
स्रोत
— user2428118 14:24
4

सी # + लिनक - 273 264

एक फ़ंक्शन के रूप में जो इनपुट स्ट्रिंग लेता है और डिकोड किए गए स्ट्रिंग और ऑफसेट (आवश्यकताओं के अनुसार) को वापस करता है:

static Tuple<string,int> d(string s){var r=Enumerable.Range(0,25).Select(i=>string.Concat(from c in s select (char)((c-97+i)%26+97))).OrderBy(x=>(from c in x select "etaoinshrdlcumwfgypbvkjxqz".IndexOf(c)).Sum()).First();return Tuple.Create(r,(s[0]-r[0]+26)%26);}

टिप्पणियों के साथ अपुष्ट:

static Tuple<string,int> d(string s)
{
    var r=Enumerable.Range(0,25)                                               // for every possible offset i
          .Select(i=>string.Concat(from c in s select (char)((c-97+i)%26+97))) // calculate rot_i(input string)
          .OrderBy(                                                            // order these by their score
              x=>(
              from c in x select "etaoinshrdlcumwfgypbvkjxqz".IndexOf(c)       // lookup frequency of each character
              ).Sum()                                                          // and sum each frequency to get the score
           ).First();                                                          // get the first one (lowest score)

    return Tuple.Create(r,(s[0]-r[0]+26)%26);                                  // compute offset and return results
}

लिटिल टेस्ट ड्राइवर (लाइनक के लिए संदर्भ संकलित करना याद रखें System.Core):

using System;
using System.Linq;

namespace codegolf
{
    class Program
    {
        static Tuple<string,int> d(string s){var r=Enumerable.Range(0,25).Select(i=>string.Concat(from c in s select (char)((c-97+i)%26+97))).OrderBy(x=>(from c in x select "etaoinshrdlcumwfgypbvkjxqz".IndexOf(c)).Sum()).First();return Tuple.Create(r,(s[0]-r[0]+26)%26);}

        static void Main(string[] args)
        {
            while (true)
            {
                var input = Console.ReadLine();
                if (input == null) break;
                var retval = d(input);
                Console.WriteLine(String.Format("{0} {1}", retval.Item2, retval.Item1));
            }
        }
    }
}

देते हुए:

$ mcs /reference:System.Core.dll main.cs && mono ./main.exe
ocdndnvqzmtnzxmzohznnvbzocvodnqzmtnzxpmzviynvaz
21 thisisaverysecretmessagethatisverysecureandsafe
pmttwxmwxtmwnxzwoziuuqvoxchhtmakwlmowtnabiksmfkpivom
8 hellopeopleofprogrammingpuzzlescodegolfstackexchange
ftueimeqzodkbfqpiuftdaffiqxhqeaufygefnqbqdrqofxkemrq
12 thiswasencryptedwithrottwelvesoitmustbeperfectlysafe
jgtgkuvjghkpcnvguvecugvjcvaqwowuvfgetarv
2 hereisthefinaltestcasethatyoumustdecrypt
thisisaverysecretmessagethatisverysecureandsafe
0 thisisaverysecretmessagethatisverysecureandsafe
— थॉमस
स्रोत
मुझे लगता है कि आप गलत थे - आपका वर्तमान समाधान वास्तव में 263 अक्षर है। इसके अलावा, आप एक और चार के बीच अंतरिक्ष को हटाकर बचा सकते हैंTuple<string,int> d
— mellamokb
यहां मेरा संस्करण है जो कार्यान्वयन में बहुत करीब है, लेकिन थोड़ा छोटा है:Tuple<int,string>f(string x){return Enumerable.Range(0,25).Select(n=>Tuple.Create(26-n,string.Concat(x.Select(c=>(char)((c-97+n)%26+97))))).OrderBy(t=>(t.Item2.Select(c=>"etaoinshrdlcumwfgypbvkjxqz".IndexOf(c))).Sum()).First();}
— पोर्स
मुझे लगता है कि आपको उपयोग करना चाहिए Range(0, 26), नहीं 25।
— रॉलिंग
4

डीजी - 137 130 129 128 बाइट्स

f=t->min key:(t->sum$map 'etaoinshrdlcumwfgypbvkjxqz'.index$snd t)$map(n->n,''.join$map(c->chr$((ord c + 7-n)%26+ 97))t)(0..26)

उदाहरण:

>>> f 'ocdndnvqzmtnzxmzohznnvbzocvodnqzmtnzxpmzviynvaz'
(21, 'thisisaverysecretmessagethatisverysecureandsafe')
>>> f 'pmttwxmwxtmwnxzwoziuuqvoxchhtmakwlmowtnabiksmfkpivom'
(8, 'hellopeopleofprogrammingpuzzlescodegolfstackexchange')
>>> f 'ftueimeqzodkbfqpiuftdaffiqxhqeaufygefnqbqdrqofxkemrq'
(12, 'thiswasencryptedwithrottwelvesoitmustbeperfectlysafe')
>>> f 'jgtgkuvjghkpcnvguvecugvjcvaqwowuvfgetarv'
(2, 'hereisthefinaltestcasethatyoumustdecrypt')

अघोषित कोड:

func = t ->
  #: Compute the score of the text `t` with respect to the frequency table.
  #: score :: (int, str) -> int
  score = t ->
    sum $ map 'etaoinshrdlcumwfgypbvkjxqz'.index $ snd t

  #: Compute rot-n of the string `t`. Return the offset and the shifted text.
  #: rot :: int -> (int, str)
  rot = n ->
    n, ''.join $ map (c->chr $ ((ord c + 7 - n) % 26 + 97)) t

  # return the minimum (computed by `score`) amongst all shifted messages
  min key: score $ map rot (0..26)
— रूबिक
स्रोत
क्या आप उन जगहों को नहीं हटा सकते हैं c - 97और (0..26)?
— मनिएप
मैं केवल दूसरे को हटा सकता हूं। अभी कर रहा हूँ। मैं कुछ उदाहरण जोड़ूंगा।
— रुबिक
1
dgपहले कभी नहीं सुना । क्या आप एक लिंक प्रदान कर सकते हैं?
— TheDoctor
@ डॉक्टर: ज़रूर! pyos.github.io/dg मुखपृष्ठ और pyos.github.com/dg/tutorial ट्यूटोरियल है।
— रुबिक
आप 97 को घटाने के बजाय 7 जोड़कर एक वर्ण को बचा सकते हैं। मोदुलो 26 वे एक ही चीज हैं।
— हमार
4

जे - 92 चार

थोड़ा बदसूरत बत्तख का बच्चा, लेकिन यह काम करता है। दो लाइनों पर संख्या और फिर स्ट्रिंग को आउटपुट करता है।

(26|](-1!:2&2&.":)(/:'ctljapqhewvknfdsyigbmuoxrz')+/@i."1(i.<./@:)26|(i.-27)+/])&.(_97+3&u:)

यदि आप उन्हें एक ही लाइन पर रखना चाहते हैं, तो अंतरिक्ष अलग हो जाता है, यह केवल 93 चार्ट तक जाता है , लेकिन एक बदसूरत मार्ग लेता है।

((":@],[:u:32,97+26|-)(/:'ctljapqhewvknfdsyigbmuoxrz')+/@i."1(i.<./@:)26|(i.-27)+/])@(7+3&u:)

(/:'ctljapqhewvknfdsyigbmuoxrz')इसके लिए एक स्पष्टीकरण : इस क्रिया में, हम अक्षर मानों को A = 0, B = 1, C = 2, आदि के रूप में संचालित करते हैं। स्ट्रिंग के अक्षर मानों को एनकोड करने के लिए etaoinshrdlcumwfgypbvkjxqz, सबसे छोटा तरीका वास्तव में इसके लिए क्रमबद्ध क्रमपरिवर्तन लेना है। अजीब तार। ऐसा इसलिए है क्योंकि A इंडेक्स 4 पर है, B इंडेक्स 19 में, C 0 पर, D 14 में, और इसी तरह; इसलिए 4 19 0 14 8 13 ...जब आप /:इसे ग्रेड ( ) करते हैं तो क्रमबद्ध क्रमपरिवर्तन होता है, और आपको इसके लिए बिल्कुल मान मिलते हैं etaoin...।

उपयोग:

   (26|](-1!:2&2&.":)(/:'ctljapqhewvknfdsyigbmuoxrz')+/@i."1(i.<./@:)26|(i.-27)+/])&.(_97+3&u:) 'ocdndnvqzmtnzxmzohznnvbzocvodnqzmtnzxpmzviynvaz'
21
thisisaverysecretmessagethatisverysecureandsafe

   NB. naming for convenience
   f =: (26|](-1!:2&2&.":)(/:'ctljapqhewvknfdsyigbmuoxrz')+/@i."1(i.<./@:)26|(i.-27)+/])&.(_97+3&u:)
   f 'pmttwxmwxtmwnxzwoziuuqvoxchhtmakwlmowtnabiksmfkpivom'
8
hellopeopleofprogrammingpuzzlescodegolfstackexchange
   f 'wtaad'
0
wtaad
— algorithmshark
स्रोत
3

क्यू, 97

{(w;m w:g?min g:(+/')("etaoinshrdlcumwfgypbvkjxqz"!t)m:(t!u!/:rotate[;u:.Q.a]'[(-)t:(!)26])@\:x)}

।

q) tests:(
    "ocdndnvqzmtnzxmzohznnvbzocvodnqzmtnzxpmzviynvazocdndnvqzmtnzxmzohznnvbzocvodnqzmtnzxpmzviynvaz";
    "pmttwxmwxtmwnxzwoziuuqvoxchhtmakwlmowtnabiksmfkpivom";
    "ftueimeqzodkbfqpiuftdaffiqxhqeaufygefnqbqdrqofxkemrq";
    "jgtgkuvjghkpcnvguvecugvjcvaqwowuvfgetarv")

q) f:{(w;m w:g?min g:(+/')("etaoinshrdlcumwfgypbvkjxqz"!t)m:(t!u!/:rotate[;u:.Q.a]'[(-)t:(!)26])@\:x)}

q) f each tests
21 "thisisaverysecretmessagethatisverysecureandsafethisisaverysecretmessagethatisverysecureandsafe"
8  "hellopeopleofprogrammingpuzzlescodegolfstackexchange"
12 "thiswasencryptedwithrottwelvesoitmustbeperfectlysafe"
2  "hereisthefinaltestcasethatyoumustdecrypt"
— tmartin
स्रोत
2

एपीएल - 70 अक्षर

F←{↑⍋+/'etaoinshrdlcumwfgypbvkjxqz'⍳⊃(⍳26){l[(⍺⌽l←⎕UCS 97+⍳26)⍳⍵]}¨⊂⍵}

उदाहरण:

      F 'ocdndnvqzmtnzxmzohznnvbzocvodnqzmtnzxpmzviynvaz'
21
      F 'pmttwxmwxtmwnxzwoziuuqvoxchhtmakwlmowtnabiksmfkpivom'
8
      F 'ftueimeqzodkbfqpiuftdaffiqxhqeaufygefnqbqdrqofxkemrq'
12
      F 'jgtgkuvjghkpcnvguvecugvjcvaqwowuvfgetarv'
2

मुझे यकीन है कि आगे इसे संपीड़ित करने के तरीके हैं, और मैं किसी अन्य एपीएल उपयोगकर्ताओं को इसके लिए समाधान के साथ आने के लिए आमंत्रित करता हूं।

— इलायस मायर्टेंसन
स्रोत
6
आप का फैसला किया स्ट्रिंग बहुत उत्पादन के लिए है ...
— दरवाज़े
2

अजगर 188

x="abcdefghijklmnopqrstuvwxyz"
y=input()
r=lambda n:"".join(x[x.find(i)-n]for i in y)
s={sum("etaoinshrdlcumwfgypbvkjxqz".find(b)for b in r(a)):(a,r(a))for a in range(26)}
print(s[min(s)])
— gcq
स्रोत
1

Perl: आवृत्ति तालिका सहित 256 char (पठनीयता के लिए नए सिरे)

@f=unpack("W*","etaoinshrdlcumwfgypbvkjxqz");
@c=unpack("W*",<>);$m=ord("a");$b=1E10;
for$n(0..25){$s=0;$t="";
for$x(0..scalar@c){$r=($c[$x]-$n-$m)%26+$m;$t.=chr($r);
for(0..scalar@f){if($r==$f[$_]){$s+=$_}}}
if($s<$b){$b=$s;$w=$t;$a=$n}}
printf"%d %s\n",$a,$w;

पाठ इस प्रकार प्रदान किया गया है:

echo "ocdndnvqzmtnzxmzohznnvbzocvodnqzmtnzxpmzviynvaz" | perl ./freq.pl 
21 thisisaverysecretmessagethatisverysecureandsafewm

यदि आप आर्ड (a) और @f की लंबाई के मान में सेंकना चाहते हैं, तो 12 char को उतारें

— OJW
स्रोत
1

एल्म - 465

किसी भी गोल्फिंग अवार्ड को जीतने के लिए नहीं, बल्कि यह एक स्थिर वेबपेज बनाता है जो [(rotation number, rotated string)]आपके द्वारा टाइप किए गए फॉर्म की सूची प्रदर्शित करता है ।

नोट: यहाँ अभी तक काम नहीं कर रहा है, लेकिन आप इसे आधिकारिक संपादक में कॉपी-पेस्ट कर सकते हैं और इसे चला सकते हैं।

import String as S
import Char (..)
import Graphics.Input (..)
import Graphics.Input.Field (..)
f="ETAOINSHRDLCUMWFGYPBVKJXQZ"
r s n=let t c=mod(toCode c-65+n)26+65 in map(fromCode . t)(S.toList s)
w s=case s of 
 ""->0
 s->sum(S.indexes(S.left 1 s)f)+w(S.dropLeft 1 s)
b s=sort<|map(\x->((w . S.fromList . r s)x,(26-x,S.fromList<|r s x)))[0..25]
c=input noContent
main=above<~(field defaultStyle c.handle id""<~c.signal)~(asText . b . .string<~c.signal)
— hoosierEE
स्रोत
1

पायथन 2, 171

f,R,i='zqxjkvbpygfwmucldrhsnioate',{},raw_input();a=sorted(f)*2
for n in range(26):_=''.join(a[ord(x)-71-n]for x in i);R[sum(2**f.index(x)for x in _)]=n,_
print R[max(R)]
— dieter
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.