सबसे कुशल शावक

19

मूल रूप से किसी भी कोड को मैन्युअल रूप से लिखने के लिए बहुत थकाऊ है। आपकी चुनौती एएससीआईआई पाठ को क्यूबली स्रोत कोड में अनुवाद करना है।

Cubically

यह क्यूबिकली बस एक त्वरित रन-डाउन है; भंडार एक और अधिक पूरा गाइड और विवरण है।

मूल रूप से एक एसोलैंग है जिसे मैंने कुछ समय पहले लिखा था, जिसे उपयोग करने के लिए दर्दनाक बनाया गया था। इसमें मेमोरी के दो टुकड़े होते हैं, एक 3x3x3 रूबिक क्यूब और एक रजिस्टर जिसे "नोटपैड" कहा जाता है।

स्मृति

आंतरिक रुबिक का घन इस तरह से आरंभ किया गया है:

   000
   000          top face
   000
111222333444    left, front, right, and back faces, respectively
111222333444
111222333444
   555
   555          down face
   555

दाहिने चेहरे पर 90 ° घूमने के बाद, मेमोरी क्यूब इस तरह दिखेगा:

   002
   002
   002
111225333044
111225333044
111225333044
   554
   554
   554

आदेश

एक गैर-पूर्णांक वर्ण डिफ़ॉल्ट कमांड सेट करता है। डिफ़ॉल्ट पूर्ण कमांड को एक बार फिर सेट करने से पहले प्रत्येक पूर्णांक के लिए, कमांड उस पूर्णांक के साथ किया जाता है। उदाहरण के लिए, 5 के साथ x524y312कमांड करेगा x, फिर 2 के साथ, फिर 4 के साथ, फिर y3 के साथ कमांड करेगा , फिर 1 के साथ, फिर 2 के साथ कमांड करेगा ।

पूर्णांक जो कमांड का उपयोग करते हैं वे फेस इंडेक्स का प्रतिनिधित्व करते हैं। तो यूपी (0-अनुक्रमित) चेहरे पर x0प्रदर्शन करेंगे x। LEFT (1-अनुक्रमित) चेहरे पर x1प्रदर्शन करेगा x, और इसी तरह।

किसी भी कमांड 6को प्रदर्शन करने से नोटपैड मान पर उस कमांड का प्रदर्शन होगा। 6 से अधिक किसी भी पूर्णांक के साथ किसी भी कमांड को निष्पादित करने में त्रुटि होगी।

यहाँ कुछ उदाहरण आदेश दिए गए हैं:

  • R1 - राइट फेस क्लॉकवाइज 90 ° मोड़ें ताकि आंतरिक क्यूब ऊपर के दूसरे उदाहरण की तरह दिखाई देगा
  • R11 - समान रूप से दो बार राइट फेस क्लॉकवाइज 90 ° मोड़ें R2
  • +0 - नोटपैड में यूपी चेहरे के सभी मूल्यों को जोड़ें
  • +000 - यूपी फेस के सभी मूल्यों को तीन बार नोटपैड में जोड़ें
  • @6 - एक चरित्र के रूप में noxistent 6-अनुक्रमित चेहरे (मेमोरी) को प्रिंट करें
  • %4 - BACK चेहरे पर सभी मानों के योग को पूर्णांक के रूप में प्रिंट करें

कमांड और सिंटैक्स की एक पूरी सूची रिपॉजिटरी में उपलब्ध है ।

चुनौती

आप ASCII टेक्स्ट को इनपुट के रूप में लेंगे और आउटपुट के रूप में एक क्यूबिक प्रोग्राम को प्रिंट करेंगे।

उदाहरण ( यहां और यहां से चुराए गए ):

Input -> Output
Hello, World! -> +53@6+1F2L2+0@6L2F2U3R3F1L1+2@66L3F3R1U1B3+0@6:4U1R1+00@6-000@6*0-4+000@6-00@6+2-000000@6-5+4000@6-00@6/0+00@6:0+0/0+00@6
1$2$3$4$5$6$7$8$9$10$ -> B1+2/2%6@4+00/0%6@4+00/1%6@4+21/1%6@4+30/0%6@4+22/1%6@4+22/1%6@4+40/1%6@4+52/1%6@4+42/1%6@4

नियम

  • आपके कार्यक्रम में १०० टेस्टकेस के अनुवाद वाले शब्दकोश नहीं हो सकते हैं।
  • आपका कार्यक्रम 180 सेकंड से कम समय में समाप्त होना चाहिए (कोई ब्रूट-फोर्स प्रोग्राम जो सप्ताह लगते हैं)।
  • आपके कार्यक्रम को मान्य रूप से घन कोड का उत्पादन करना चाहिए जो 180 सेकंड से कम समय में समाप्त हो जाता है।
  • जब तक आप परीक्षण ड्राइवर के साथ गड़बड़ नहीं करना चाहते, आपका कार्यक्रम मानक इनपुट के माध्यम से इनपुट लेगा।
  • आपके प्रोग्राम को क्यूबिक कोड को आउटपुट करना चाहिए जो रन करते समय आपके प्रोग्राम के इनपुट के अलावा कुछ भी नहीं पैदा करता है। ಠ_ಠ

स्कोरिंग

आप अपने प्रोग्राम को 100 छद्म आयामी pseudorandom लंबाई के तार के साथ परीक्षण करेंगे। (एक बैश स्क्रिप्ट प्रदान की जाती है जो आपके लिए यह करेगी।) यहां बताया गया है कि आप कैसे स्कोर करेंगे:

  • आउटपुट प्रोग्राम की लंबाई ओ हो ।
  • इनपुट स्ट्रिंग की लंबाई l होने दें ।
  • एक चर आर ओ / एल का परिणाम है ।
  • सभी आर का औसत ज्ञात करें : (आर 1 + आर 2 + आर ... + आर 100 ) / 100 ।

इस स्क्रिप्ट के साथ परीक्षण करें। आपको निर्देशानुसार इसे संशोधित करना होगा। ध्यान दें कि प्रोग्राम यह जांच नहीं करता है कि आउटपुट वैध रूप से क्यूबिक कोड है या नहीं। यदि आपको स्क्रिप्ट काम नहीं कर रही है, तो मैं मदद कर सकता हूं। मुझे क्यूबिक चैट रूम में पिंग करें ।

code-challenge  cubically 
— एमडी एक्सएफ
स्रोत
1
— एमडी एक्सएफ
क्या " @6- एक चरित्र के रूप में नॉन-सेंस 6-इंडेक्सड फेस (नोटपैड) का योग" अधिक सटीक होगा? है %4यह भी एक योग? कर रहे हैं +आदेशों राशि चेहरा फिर ... सभी मूल्यों या करने के लिए है कि जोड़ सकता हूँ?
— जोनाथन एलन
@JonathanAllan @6/ %6सीधे नोटपैड मान को वर्ण / पूर्णांक के रूप में प्रिंट करता है। @x/ %x(जहां x कोई मौजूदा चेहरा है) x-indexed चेहरे पर सभी मान जोड़ता है और योग को वर्ण / पूर्णांक के रूप में प्रिंट करता है। +निर्दिष्ट चेहरे पर सभी मानों को रजिस्टर में जोड़ता है।
— एमडी XF
आह, किसी कारण से मैं 9 मान होने के कारण नोटपैड के बारे में सोच रहा था।
— जोनाथन एलन

जवाबों:

4

सी ++ 11, स्कोर : 6.37

#include <iostream>
#include <vector>
#include <array>
#include <limits>
#include <algorithm>

const int inf = std::numeric_limits<int>::max(),
maxDiff = 128, nFace = 6;
std::array<int, maxDiff+1> plusvalue, totalvalue, plustrace, totaltrace;
std::array<int, nFace> input;

void prtrace(int value) {
    while (value) {
        std::cout << plustrace[value];
        value -= input[plustrace[value]];
    }
}

void prexpr(int i) {
    char xorwt = 0;
    if (i < 0) {
        xorwt = '+' ^ '-';
        i = -i;
    }
    if (totalvalue[i] != 0 && totalvalue[i] != inf) {
        std::cout << (char)('+' xor xorwt);
        prtrace(totaltrace[i]);
        if (totaltrace[i] != i) {
            std::cout << (char)('-' xor xorwt);
            prtrace(totaltrace[i] - i);
        }
    }
}

int main() {
    std::cout << "RU";
    input = {6, 15, 27, 26, 19, 42};
    std::cin >> std::noskipws;

    std::fill(plusvalue.begin(), plusvalue.end(), inf);
    plusvalue[0] = 1; // '+'
    for (int i = 0; i < nFace; ++i) { // knapsack, each value repeated inf times
        int val = input[i];
        if (val == 0) continue;
        for (int p = 0; p <= maxDiff - val; ++p) {
            if (plusvalue[p] != inf && plusvalue[p + val] > plusvalue[p] + 1) {
                plusvalue[p + val] = plusvalue[p] + 1;
                plustrace[p + val] = i;
            }
        }
    }
    for (int p = 0; p <= maxDiff; ++p) totalvalue[p] = plusvalue[p], totaltrace[p] = p;
    totalvalue[0] = 0;
    for (int sub = 1; sub <= maxDiff; ++sub) {
        if (plusvalue[sub] == inf) continue;
        for (int p = 0; p <= maxDiff - sub; ++p) {
            if (plusvalue[p+sub] != inf && totalvalue[p] > plusvalue[p+sub] + plusvalue[sub]) { // include '+'s
                totalvalue[p] = plusvalue[p+sub] + plusvalue[sub];
                totaltrace[p] = p+sub;
            }
        }
    }

//    // Note: plustrace[x] = i<=nFace : plustrace[x-input[i]] + 1 = plustrace[x]
//    long long sum = 0;
//    for (int i = 0; i <= maxDiff; ++i) {
//        sum += totalvalue[i];
//        std::cout << i << '\t' << totalvalue[i] << '\t';
//        prexpr(i);
//        std::cout << '\n';
//    }
//
//    std::cout << "_______________________________\n\nAverage = " << sum / (maxDiff + 1.) << '\n';

// RU 3.98131

    char ch;
    int cur = 0;
    while (std::cin >> ch) {
        int diff = ch - cur;
        prexpr(diff);
        std::cout << "@6";
        cur += diff; // cur = ch
    }
}

/*
RU 3.98131
*/

इसे ऑनलाइन आज़माएं! (ASCII से क्यूबिक कोड उत्पन्न करें) और (क्यूबिक कोड चलाएं)

स्पष्टीकरण:

  • पहले कार्यक्रम "आरयू" को प्रिंट करता है, जो चेहरे को योग से {0,9,18,27,36,45}बनाते हैं {6, 15, 27, 26, 19, 42}। जो चेहरा अंकित करता है, वह उपयोगी है कि gcd 1 है, इसलिए Bézout की पहचान dसे उन संख्याओं के योग (या अंतर) से किसी संख्या का निर्माण करने का एक तरीका मौजूद है ।
  • इसलिए, यदि अगला चार्ट है chऔर वर्तमान नोटपैड मान है n, तो d = ch - n, हम क्यूबिक कमांड को इस +{digits from 0 to 5}-{digits from 0 to 5}तरह से निष्पादित कर सकते हैं कि नोटपैड मान बन जाता है ch। फिर %6नोटपैड मान को प्रिंट करने के लिए निष्पादित करें।
  • dफेस योग सेट में संख्याओं के योग / अंतर के रूप में व्यक्त करने के लिए सबसे कुशल तरीका खोजने के लिए , मैं 0 से 128 तक सभी संख्याओं के लिए नॅप्सैक एल्गोरिथ्म का उपयोग करता हूं। जैसे, d=1कार्यक्रम मिलता है 27 - 26 = 1, इसलिए यह प्रिंट करता है +2-3, जो है 27 - 26 = 1। जिसे इनपुट abc, प्रोग्राम आउटपुट के साथ प्रोग्राम चलाते समय देखा जा सकता है

    आरयू + 4333 @ 6 + 2-3 @ 6 + 2-3 @ 6

— user202729
स्रोत
वाह, बहुत अच्छा काम! द नॅप्सैक अल्गोरिथम वह है जिसे हम अनुमान लगा रहे थे।
— तेहरप्स
ध्यान दें कि भाषा अपडेट के कारण, आप @अंतर्निहित रूप से कॉल करके बेहतर स्कोर प्राप्त कर सकते हैं - सभी मामलों में @6छोटा किया जा सकता है @।
— एमडी एक्सएफ
17

लुआ, स्कोर : 85.91 13.50 13.20 12.70 9.41 9.32 9.83 9.66 9.12 9.06 8.03 (औसत)

-- Get input
local inp = io.read("*a")

local out = ""
local faces = { [5] = 45, [4] = 36, [3] = 27, [2] = 18, [1] = 9 }
local lastChar = nil

-- Mode the program is in
-- 2 = not set (needs :), 1 = just set (needs +), 0 = normal
local mode = 1;
for i = 1, inp:len() do
  -- Character value at current position
  local c = string.byte(inp, i)

  if c == lastChar then
    -- Repeat character
    out = out .. "6"
  elseif c % 9 == 0 and c <= 45 then
    if #out == 0 then
      out = out .. "@"
    end
    out = out .. (c / 9)
  else
    local c2 = c

    -- Handle if difference from lastChar is divisible by 9
    if lastChar and (c - lastChar) % 9 == 0 then
      local difference = c - lastChar
      if difference > 0 then
        out = out .. "+"
      else
        out = out .. "-"
        difference = difference * -1
      end

      for index = 5, 1, -1 do
        local face = faces[index]
        while difference >= face do
          difference = difference - face
          out = out .. index
        end
      end
      c = 0
    end

    -- Handle anything not divisible by 9
    local extra = c % 9
    if extra > 0 then
      -- Try to optimize by dividing by 9, if possible
      if lastChar and math.floor(lastChar / 9) == extra then
        out = out .. "/1"
        mode = 1
        extra = 0
      else
        while extra > 0 do
          local n = extra > 5 and 5 or extra

          if mode == 2 then
            out = out .. ":"
            mode = 1
          elseif mode == 1 then
            out = out .. "+"
            mode = 0
          end
          out = out .. n
          extra = extra - n
        end
        out = out .. "/1"
        mode = 1
      end

      c = c - (c % 9)
    end

    -- Handle anything divisible by 9
    for index = 5, 1, -1 do
      local face = faces[index]
      while c >= face do
        if mode == 2 then
          out = out .. ":"
          mode = 1
        elseif mode == 1 then
          out = out .. "+"
          mode = 0
        end
        c = c - face
        out = out .. index
      end
    end

    out = out .. "@6"
    lastChar = c2
  end

  mode = 2
end
print(out)

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

ठीक है, मुझे नहीं लगता कि मैं इसे अब और अनुकूलित कर सकता हूं।

यह संस्करण प्रत्येक वर्ण के माध्यम से पुनरावृत्ति करता है, c% 9 (जहां c वर्ण का दशमलव मान है) :5+2/1को जोड़कर, फिर उस चेहरे के मान को जोड़कर भागों को 9 से विभाज्य कर देता है। उदाहरण के लिए: :2/1+551@"ई" प्रिंट करने के लिए , जहां :2/12 जोड़ता है, +55199 (9 * (5 + 5 + 1), या 9 * 11) जोड़ता है, और @आउटपुट प्रिंट करता है। इनपुट के साथ पढ़ा जाता है io.read()।

ऑप्टिमाइज़ेशन में प्रिंटिंग के बाद सीधे जोड़ना / घटाना शामिल है यदि वर्णों के बीच का अंतर 9 का गुणक है, तो वर्तमान मान को विभाजित करना यदि संभव हो तो खरोंच से c% 9 स्थापित करने के बजाय, और वर्णों को पुन: गणना करने के बजाय वर्तमान मान को फिर से प्रिंट करके दोहराएं। इसके अतिरिक्त, मैंने कामिल के तरीके को तुरंत किसी भी चेहरे को प्रिंट करने के लिए लागू किया है जिसमें पहले से ही लक्ष्य मूल्य शामिल है, और एमडी एक्सएफ का सुझाव :शुरुआत में उपयोग नहीं करने के लिए, लेकिन इसके बजाय बस एक के साथ शुरू करें +।

— TehPers
स्रोत
1
आप हमेशा अपने स्वयं के प्रश्नों और उत्तरों पर टिप्पणी कर सकते हैं, लेकिन आप अभी तक सामान्य टिप्पणी विशेषाधिकारों के लिए नहीं हैं। इस तरह के उत्तर के साथ लंबे समय तक नहीं रहना चाहिए (या, अधिक संभावना है, बस एक बार कुछ और लोगों द्वारा इसे देखे जाने पर यह उत्तर)
— कामिल दकरी
2
@MDXF मैं बहुत अच्छा नहीं हूं: P
— कामिल दकरी
1
आप बदल सकते हैं local inp = io.read()करने के लिए local inp = io.read("*all")। जो समस्या को ठीक करता है।
— एमडी एक्सएफ
1
एक और संभावित अनुकूलन - चूंकि नोटपैड 0 से शुरू होता है, इसलिए आपको वास्तव में आउटपुट की आवश्यकता नहीं है, उदाहरण के लिए :5+124, इसके बजाय आप बस लिख सकते हैं +5124, जो कि अगर आप इसे सही करते हैं तो स्कोर थोड़ा कम हो जाएगा।
— एमडी एक्सएफ
1
यदि आप हाल ही में किए गए कुछ अपडेट का समर्थन करने के लिए अपना उत्तर बदलते हैं, तो आपको एक बेहतर स्कोर प्राप्त होगा, जैसे कि अंतर्निहित चेहरे के मोड़।
— एमडी एक्सएफ
16

मूल रूप से , स्कोर : 86.98

U3D1R3L1F3B1U1D3~:7+1(-1@3(-1%1)6:1+3111@6%1-31111+004@6:1+11111%6:1+45@6:1-1%6~:7+1)6

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

पता चलता है, आप सभी की जरूरत है सशर्त छोरों, 1 के बराबर एक चेहरा, और लगातार एंड-टू-इनपुट व्यवहार।

U3D1R3L1F3B1U1D3     set LEFT face sum to 1
~:7                  read input, set notepad to input
+1                   add 1 to notepad

(                    open loop that can always be jumped to
 -1                   subtract 1 from notepad
 @3                   print RIGHT face (ASCII 43 '+')

            ##   the following mechanism gets the output program's   ##
            ##   notepad to the current inputted ASCII value:        ##

 (                    open loop that can always be jumped to
  -1                   subtract 1 from notepad
  %1                   print '1'
 )6                   jump back to loop while notepad is nonzero

            ##   the following mechanism prints "/1@6:1"             ##

 :1+3111@6            set notepad to 47,    print (ASCII 47 '/')
 %1                   print LEFT face       print (integer '1')
 -31111+004@6         set notepad to 64,    print (ASCII 64 '@')
 :1+11111%6           set notepad to 6,     print (integer 6)
 :1+45@6              set notepad to 58,    print (ASCII 58 ':')
 :1-1%6               set notepad to 0,     print (integer 1)

 ~                    read input
 :7+1                 set notepad to input plus 1, so EOF changes to zero
)6                    loop if notepad is truthy

ईओएफ पढ़ने के बाद लूप के चेहरे को जोड़ने / घटाना लूप को समाप्त करना है।

— कामिल दकरी
स्रोत
2
आपके पास मिला मजाक किया जाना है। यह अविश्वसनीय है।
— एमडी एक्सएफ
ओह हे, यह भी मेरे मूल सी # जवाब से बेहतर स्कोर है!
— कामिल दकरी
ध्यान दें कि भाषा अपडेट के कारण, आप @अंतर्निहित रूप से कॉल करके बेहतर स्कोर प्राप्त कर सकते हैं - सभी मामलों में @6छोटा किया जा सकता है @।
— एमडी एक्सएफ
9

सी # (.NET कोर) , स्कोर: 129.98 11.73 10.82 9.62 10.33 10.32 10.20

चरित्र को दोहराने @6666...के @6@6@6@6...लिए उपयोग करने के लिए एमडी एक्सएफ के सुझाव से -1.2 अंक , और बेहतर आरंभीकरण अनुक्रम

static void Main()
{
	List<byte> input = new List<byte>();
            int inChar = Console.Read();
            while (inChar != -1)
            {
                input.Add((byte)inChar);
                inChar = Console.Read();
            }


            Console.Write("U3D1R3L1F3B1U1D3");
            byte[] sides = new byte[] { 20, 1, 14, 43, 24, 33 };

            byte currentChar = 0;

   	    if(currentChar == input[0] || sides.Contains(input[0])) Console.Write("@");

            foreach (byte character in input)
            {
		if (currentChar == character)
		{
			Console.Write("6");
			continue;
		}
		
		if (sides.Contains(character))
		{
			Console.Write(Array.IndexOf(sides, character));
			continue;
		}
                if (currentChar < character)
                {
                    Console.Write("+");
                    while (currentChar < character)
                    {
                        byte nextAdd = sides.Where(s => s + currentChar <= character).Max();
                        currentChar = (byte)(currentChar + nextAdd);
                        Console.Write(Array.IndexOf(sides, nextAdd));
                    }
                }

                if (currentChar > character)
                {
                    Console.Write("-");
                    while (currentChar > character)
                    {
                        byte nextSub = sides.Where(v => currentChar - v >= character).Max();
                        currentChar = (byte)(currentChar - nextSub);
                        Console.Write(Array.IndexOf(sides, nextSub));
                    }
                }

                Console.Write("@6");
            }
}

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

मेरा नवीनतम संस्करण वास्तव में घन के कुछ हेरफेर करता है! वाह!

पहले Console.Writeवहाँ एक निश्चित हेरफेर है एमडी एक्सएफ ने काम किया जो इस घन को बनाता है:

   242
   202
   242
000131555313
010121535343
000131555313
   424
   454
   424

इस क्यूब का महत्व यह है कि इसके एक पक्ष में 1 की राशि है, जो नौ के गुणकों की तुलना में छोटे पैमाने पर नोटपैड के हेरफेर की अनुमति देता है, और विशेष रूप से यह प्रत्येक चरित्र को शून्य से शुरू करने की आवश्यकता के बजाय सापेक्ष आंदोलन को सरल करता है; इस एल्गोरिथ्म में वर्णों के बीच सबसे छोटा रास्ता निकालने के लिए जोड़ और घटाव दोनों का इस्तेमाल किया जाता है।

प्रारंभिक के MD XF के संस्करण में पक्ष 2 का 14 का योग है, जो 14 और 20 के बीच ASCII दूरियों के लिए आउटपुट के कई बाइट्स बचाता है।

अब आंतरिक newlines के साथ आदानों को संभाल सकते हैं, Console.Read () को फ़ाइल के अंत तक अलग-अलग वर्ण मिलते हैं; TIO लिंक देखें जिसमें इनपुट होना चाहिए

Hello, 
World!

एक बिंदु के कुछ अंशों को तुरंत एक चरित्र के रूप में उकेरा जाता है यदि उसका ASCII मूल्य सिर्फ एक पक्ष में पहले से मौजूद है।

एमडीएक्सएफ के सौजन्य से टेस्ट स्क्रिप्ट शिष्टाचार

पिछले यहाँ प्रस्तुत और स्पष्टीकरण:

यह थोड़े उबाऊ है, लेकिन जहां तक ​​मैं यह बता सकता है काम करता है। निश्चित रूप से मैंने केवल कोशिश की, Hello, World!लेकिन मैंने आउटपुट को TIO क्यूबिकली इंटरप्रेटर में चलाया और यह आउटपुट "हैलो, वर्ल्ड!" इसलिए मैंने यह काम किया।

वास्तव में क्यूब को बिल्कुल हेरफेर करने के बजाय, नोटपैड को केवल 1 चेहरे (9) के योग द्वारा बार-बार बढ़ाया जाता है जब तक कि यह प्रत्येक वर्ण के लिए सही मूल्य न हो, फिर इसे प्रिंट करता है।

— कामिल दकरी
स्रोत
टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।
— मार्टिन एंडर
@MartinEnder क्या आप उन्हें मौजूदा चैट रूम में स्थानांतरित कर सकते हैं ?
— एमडी एक्सएफ
@MDXF मैं कर सकता था, लेकिन मैं यह नहीं बता सकता कि क्या वे पूरी तरह से उस स्थान पर और संदर्भ से बाहर हैं।
— मार्टिन एंडर
@MartinEnder चैटरूम की तुलना में पुरानी हैं, इसलिए वे ट्रांसक्रिप्ट में वापस आ जाएंगे, सही है?
— एमडी एक्सएफ
वे करेंगे। धन्यवाद, मैं संदेशों को स्थानांतरित करूँगा।
— मार्टिन एंडर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.