एक विलम्ब का विलोम विलोम

17

एक विलम्ब का विलोम विलोम

आपका काम है, हस्ताक्षरित 32 बिट पूर्णांक की एक सरणी दी गई है, इसे अपने विलोम डेल्टा के साथ फिर से जोड़ें। उदाहरण के लिए, सूची

1  3  4  2  8

डेल्टास रखती है:

  2  1 -2  6

जो तब उपेक्षित हैं, उपज:

 -2 -1  2 -6

और recompiled, उपज:

1 -1 -2  0 -6

अंतिम परिणाम के रूप में।

इनपुट आउटपुट

आपको एक सूची / सारणी / टेबल / ट्यूपल / स्टैक / आदि दी जाएगी। किसी भी मानक इनपुट पद्धति के माध्यम से इनपुट के रूप में हस्ताक्षरित पूर्णांक।

उपरोक्त डेल्टा उलटा विधि के बाद, आपको किसी भी स्वीकार्य रूप में एक बार फिर संशोधित डेटा का उत्पादन करना होगा।

आपको एन इनपुट प्राप्त होगा 0 < N < 10जहां प्रत्येक संख्या सीमा के भीतर आती है-1000 < X < 1000

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

5 6 7 8          -> 5 4 3 2
1 3 4 2 8        -> 1 -1 -2 0 -6
32 18 25 192 199 -> 32 46 39 -128 -135

टिप्पणियाँ

  • आप डेल्टा आधारित विधि तक ही सीमित नहीं हैं: यदि आप आसान विधि (जो बहुत कठिन नहीं होनी चाहिए) का उपयोग कर सकते हैं, तो आप इसका उपयोग करने के लिए स्वतंत्र हैं।
  • जैसा कि ऊपर कहा गया है, आप हमेशा कम से कम 1 इनपुट प्राप्त करेंगे, और 9 से अधिक नहीं।
  • आउटपुट की पहली संख्या हमेशा इनपुट की पहली संख्या होनी चाहिए , अगर यह मामला नहीं है, तो आपका तरीका गलत है।
  • केवल मानक इनपुट आउटपुट स्वीकार किया जाता है
  • मानक खामियां लागू होती हैं
  • यह कोड-गोल्फ है , इसलिए सबसे कम बाइट-काउंट जीतता है!
  • मज़े करो!

हमें विजेता मिल गया।

टिनी 3 बाइट्स में डेनिस के जेली उत्तर ने घर को सोना ले लिया है, इस तथ्य के कारण कि मैं इस धारणा के तहत हूं कि इसे पीटा नहीं जा सकता।

मैं हल्के से निराश था कि मुझे मूल कल्पना के आधार पर एक उत्तर देखने को नहीं मिला, हालांकि, मैं बाद में ठीक उसी पर एक इनाम रख सकता हूं।

code-golf  integer 
— Ataco
स्रोत
1
मैं recompile कदम समझ में नहीं आता? आप -2, -1, 2, -6 से 1, -1, -2, 0, -6 कैसे प्राप्त करते हैं?
— फोगमिस्टर
@ फोगमिस्टर आप उसी प्रारंभिक मूल्य से शुरू करते हैं और फिर मूल के बजाय इन अंतरों को लागू करते हैं।
— मार्टिन एंडर
स्टैंडर्ड इनपुट आउटपुट - मैंने ऐसा नहीं सुना है जो पहले किसी चुनौती में इस्तेमाल किया गया हो, लेकिन मुझे पता है कि इसका मतलब यह नहीं है कि स्टड / स्टडआउट, क्योंकि अन्यथा यहाँ सभी उत्तर गलत प्रतीत होते हैं। मुझे लगता है कि इसका मतलब है कि आप चर्च के अंकों या कुछ के रूप में इनपुट नहीं ले सकते हैं? वैसे भी, अगर इसका यही मतलब है, तो इसे शायद कुछ और कहा जाना चाहिए क्योंकि मानक आउटपुट / इनपुट का एक और अर्थ भी है।
— हेराल्ड कोर्नेलियुसन
@MartinEnder 1 + 0 = 1, 3-2 = -1 ?, 4-1 = -2 ?? यही मैंने सोचा था लेकिन उन नंबरों को जोड़ नहीं है। ओह! कोई बात नहीं। मैंने अभी देखा। आप मूल मान पर शुरू होने वाले नए सरणी बनाते हैं लेकिन नए अंतर के साथ। तो -2 के अंतर के साथ 1 -1 हो जाता है, फिर -1 के अंतर के साथ यह -2 हो जाता है।
— फोगमिस्टर
1
@ हेराल्डकोर्नेलियुसेन यह शायद इस बात का जिक्र कर रहा है (और शायद यही सब लोग मान रहे हैं)
— मार्टिन एंडर

जवाबों:

26

जेली , 7 3 बाइट्स

ḤḢ_

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

पृष्ठभूमि

के डेल्टा (क, ख, ग, घ) कर रहे हैं ख - एक , ग - ख , और घ - सी । घटाव द्वारा कम (ए, बी - ए, सी - बी, डी - सी) घटाव पैदावार से एक (बी - ए) = 2 ए - बी , 2 ए - बी - (सी - बी) = 2 ए - सी , और 2 ए - सी - (डी - सी) = 2 ए - डी , इसलिए सही परिणाम है (2 ए - ए, 2 ए - बी, 2 ए - सी, 2 ए - डी) ।

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

ḤḢ_  Main link. Argument: A (array)

Ḥ    Unhalve; multiply all integers in A by 2.
 Ḣ   Head; extract first element of 2A.
  _  Subtract the elements of A from the result.
— डेनिस
स्रोत
1
खैर, इसे पैक अप करें। हार में क्रॉल को छोड़कर यहां कुछ भी नहीं किया जाना है।
— स्टीवन एच।
3
डेनिस बस एक सवाल पोस्ट करने के लिए मेरा इंतजार करता है और मुझे इन छोटे जेली उत्तरों के साथ रोकता है। मुझे कोई शिकायत नहीं है।
— एटीको
10

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

lambda x:[x[0]*2-n for n in x]

Ideone पर इसका परीक्षण करें ।

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

के डेल्टा (क, ख, ग, घ) कर रहे हैं ख - एक , ग - ख , और घ - सी । घटाव द्वारा कम (ए, बी - ए, सी - बी, डी - सी) घटाव पैदावार से एक (बी - ए) = 2 ए - बी , 2 ए - बी - (सी - बी) = 2 ए - सी , और 2 ए - सी - (डी - सी) = 2 ए - डी , इसलिए सही परिणाम है (2 ए - ए, 2 ए - बी, 2 ए - सी, 2 ए - डी) ।

— डेनिस
स्रोत
7

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

2#-{##}&

एक अनिश्चित संख्या के तर्कों को लेते हुए कार्य करें। यह "आसान" तरीके का उपयोग करता है: पूरी सूची को नकारता है और दो बार (मूल) पहला तत्व जोड़ता है।

उदाहरण के लिए बुलाया 2#-{##}&[1,3,4,2,8]; जैसी सूची देता है {1,-1,-2,0,-6}।

— ग्रेग मार्टिन
स्रोत
वास्तव में, धन्यवाद - केवल एक टाइपो।
— ग्रेग मार्टिन
2

पायथन, 44 बाइट्स

lambda l:[l[0]]+[x-(x-l[0])*2for x in l[1:]]

यह "आसान विधि" का उपयोग करता है।

— DJMcMayhem
स्रोत
2

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

->l{l.map{|x|l[0]*2-x}}

विशेष रूप से मूल नहीं।

— जीबी
स्रोत
2

पर्ल 6 ,  40  16 बाइट्स

{[\+] .[0],|.rotor(2=>-1).map({[-] @_})}
{.map(.[0]*2-*)}

विस्तारित:

{ # bare block lambda with single implicit parameter ｢$_｣ ( input is a List )

  [\[+]]  # triangle reduce the following using ｢&infix:<+>｣

    .[0], # the first value

    |(    # Slip this list into outer one ( Perl 6 doesn't auto flatten )

      .rotor( 2 => -1 ) # take the input 2 at a time, backing up 1
      .map({ [-] @_ })  # reduce the pairs using ｢&infix:<->｣

    )
}
{ # bare block lambda with single implicit parameter ｢$_｣ ( input is a List )

  .map(          # map over the inputs
    .[0] * 2 - * # take the first value multiply by 2 and subtract the current value
    #          ^- this makes the statement a WhateverCode, and is the input
  )
}
— ब्रैड गिल्बर्ट b2gills
स्रोत
2

ब्रेन-फ्लैक , 76 बाइट्स

([][()]){{}(({})<(({}){}[{}]<>)<>>)([][()])}{}({}<<>([]){{}({}<>)<>([])}<>>)

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

स्पष्टीकरण:

Part 1:
(      )                                        # Push:
 []                                             # the height of the stack
   [()]                                         # minus 1
        {                                  }    # While the height - 1 != 0:
         {}                                     # Pop the height
           (({})<                               # Hold onto the top value, but put it back.
                                                # This ensures that the top value is always
                                                # what was the first element of input
                 (            )                 # Push:
                  ({}){}                        # Top * 2
                        [{}]                    # minus the next element
                            <> <>               # onto the other stack

                                 >)             # Put back the element we held onto.
                                   (      )     # Push:
                                    []          # The height of the stack
                                      [()]      # Minus 1  
                                            {}  # Pop the counter used for the height
Part 2:
({}<                                            # Hold onto the top element.
                                                # This was the first number for input
                                                # so it needs to end up on top
    <>                                          # Switch stacks
      ([])                                      # Push the height of the stack
          {              }                      # While the height != 0:
           {}                                   # Pop the height
             (    )                             # Push:
              {}                                # The top element of this stack
                <>                              # onto the other stack
                   <>                           # and switch back
                     ([])                       # Push the new height of the stack
                          <>                    # After every element has switched stacks
                                                # (which reverses their order),
                                                # switch stacks
                            >)                  # Push the first element back on
— रिले
स्रोत
2

हास्केल, 20 19 बाइट्स

f(x:r)=x:map(2*x-)r

डेनिस के रूप में एक ही समाधान, आपके विचार के लिए धन्यवाद 2a - x।

क्रिश्चियन सेवर्स को एक बाइट धन्यवाद दिया।

— Renzeee
स्रोत
एक बाइट बचाएं:f(x:r)=x:map(2*x-)r
— क्रिश्चियन सिवर्स
धन्यवाद, मैंने @ के साथ और बिना कई अलग-अलग तरीकों की कोशिश की थी, लेकिन सिर्फ xसामने रखने के बारे में नहीं सोचा था ।
— Renzeee
1

PHP, 48 बाइट्स

for(;''<$c=$argv[++$i];)echo-$c+2*$a=$a??$c,' ';

डेनिस से तकनीक का उपयोग करना। उपयोग की तरह:

php -r "for(;''<$c=$argv[++$i];)echo-$c+2*$a=$a??$c,' ';" 1 3 4 2 8

गैर-डेनिस 55 बाइट संस्करण:

for(;''<$c=$argv[++$i];$l=$c)echo$a+=($l??$c*2)-$c,' ';
— user59178
स्रोत
a&इसके बजाय एक बाइट के साथ सहेजें ''<और दो बाइट के _बजाय के साथ ' '।
— टाइटस
1

एपीएल, 8 बाइट्स

+\⊃,2-/+

स्पष्टीकरण:

+\           ⍝ running sum of
  ⊃          ⍝ first item of list
   ,         ⍝ followed by
    2-/      ⍝ differences between every pair in
       +     ⍝ input list

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

      ( +\⊃,2-/+ ) ¨ (5 6 7 8) (1 3 4 2 8) (32 18 25 192 199)
┌───────┬────────────┬──────────────────┐
│5 4 3 2│1 ¯1 ¯2 0 ¯6│32 46 39 ¯128 ¯135│
└───────┴────────────┴──────────────────┘
— मारीनस
स्रोत
1

भूलभुलैया , 34 बाइट्स

?:_2*}
@    _
)\?_1"
,    ;
!`-}:{

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

@ डेनिस के (2a - a, 2a - b, 2a - c, 2a - d)दृष्टिकोण का उपयोग करता है ।

यहाँ छवि विवरण दर्ज करें

पीली टाइलें नियंत्रण प्रवाह के लिए हैं। इस 2 डी प्रोग्रामिंग भाषा में, कार्यक्रम शुरू करने के लिए पूर्व-बाईं-सबसे टाइल पर पूर्व की ओर बढ़ते हुए शुरू होता है। जंक्शनों पर, दिशा मुख्य ढेर के शीर्ष के संकेत से निर्धारित होती है। खाली टाइलें दीवारें हैं।

हरा

यह खंड 2a को सहायक ढेर में बचाता है।

  • ? पहला नंबर प्राप्त करें और इसे मुख्य स्टैक के शीर्ष पर धकेलें
  • : ढेर के ऊपर डुप्लिकेट करें
  • _2 स्टैक के शीर्ष पर दो पुश करें
  • *पॉप y, पॉप x, पुशx*y
  • } ऑक्ज़िलरी स्टैक के शीर्ष पर मुख्य स्टैक के ऊपर ले जाएँ।
  • _ स्टैक के शीर्ष पर शून्य पुश करें

संतरा

यह खंड वर्तमान संख्या से 2a को घटाता है, परिणाम को नकारता है, परिणाम को आउटपुट करता है, अगला वर्ण (परिधि) प्राप्त करता है, बाहर निकलता है यदि ईओएफ, एक नई पंक्ति को आउटपुट करता है, तो अगला नंबर मिलता है।

  • "NOOP। यदि उत्तर से आ रहा है, तो ढेर का शीर्ष शून्य होगा और कार्यक्रम दक्षिण में जारी रहेगा। यदि पश्चिम से आ रहा है, तो ढेर का शीर्ष एक होगा और कार्यक्रम दाएं मुड़ जाएगा (दक्षिण की ओर जारी रहेगा)
  • ;ढेर के शीर्ष को त्यागें। जैसा कि शून्य या एक का उपयोग केवल नियंत्रण प्रवाह के लिए किया जाता है, हमें इन्हें त्यागने की आवश्यकता है
  • { ऑक्ज़िलरी स्टैक (2a) के शीर्ष को मुख्य स्टैक के शीर्ष पर ले जाएँ
  • : मुख्य स्टैक के शीर्ष पर डुप्लिकेट करें
  • } ऑक्ज़िलरी स्टैक के शीर्ष पर मुख्य स्टैक के ऊपर ले जाएँ
  • -पॉप y, पॉप x, पुशx-y
  • \`` Negate the top of the stack. This and the previous three operations have the effect of- (x-2a) = 2a-x`
  • ! स्टैक के शीर्ष पर पॉप करें और इसे एक संख्या के रूप में आउटपुट करें
  • , अगले वर्ण को पुश करें (जो कि सीमांकक होगा) या नकारात्मक अगर ईओएफ
  • )ढेर के ऊपर वृद्धि। यदि अंतिम वर्ण ईओएफ है, तो स्टैक का शीर्ष अब शून्य होगा और कार्यक्रम सीधे @और बाहर निकलने के लिए जारी रहेगा । यदि अंतिम वर्ण एक परिधि था, तो स्टैक के शीर्ष पर सकारात्मक होगा, जिससे प्रोग्राम दाएं मुड़ जाएगा और पूर्व की ओर जारी रहेगा\
  • \ आउटपुट एक नई रेखा
  • ? अगला नंबर प्राप्त करें
  • _1 जंक्शन पर दाएं मुड़ने के लिए स्टैक के शीर्ष पर एक पुश करें
— रॉबर्ट हिकमैन
स्रोत
हुह, यह याद दिलाता है कि मैंने इस चुनौती को भी हल किया है लेकिन समाधान पोस्ट करने के लिए पूरी तरह से भूल गया। मुझे 24 बाइट्स में तीन अलग-अलग समाधान मिले हैं (और मुझे पूरा यकीन है कि वे इष्टतम नहीं हैं), इसलिए मुझे लगता है कि मैं अपना पोस्ट देने से पहले आपको कुछ दिन या तो मैच या हरा दूंगा। अच्छा काम है, अभी भी! :)
— मार्टिन एंडर
@MartinEnder, मुझ पर इंतजार करने की कोई जरूरत नहीं है। मुझे संदेह है कि मैं जल्द ही किसी भी समय बेहतर समाधान के बारे में सोचूंगा। मुझे अभी भी स्टैक-आधारित समस्या को हल करने की आदत है। मुझे प्रोग्रामिंग के बारे में सोचने का एक नया तरीका सीखने में मजा आ रहा है।
— रॉबर्ट हिकमैन
1

भूलभुलैया , 24 बाइट्स

+:}:?
}
<}}?;%):,\!-{:{>

इनपुट और आउटपुट प्रारूप अलग-अलग सूचियाँ हैं (हालाँकि इनपुट प्रारूप वास्तव में बहुत अधिक लचीला है)। कार्यक्रम एक त्रुटि के साथ समाप्त होता है।

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

मुझे इस बाइट गिनती में दो अन्य समाधान मिले हैं, जो मूल रूप से एक ही काम करते हैं लेकिन कुछ अलग नियंत्रण प्रवाह का उपयोग करते हैं।

:+:}:?
{
,}-!
?  {
:";\@

{:+:}:?
_
<>__-?:;%):,\!

व्याख्या

अनुदेश सूचक (आईपी) पहली पंक्ति के साथ पूर्व की ओर बढ़ना शुरू कर देता है, लेकिन ?वैश्विक राज्य पर मूल रूप से नो-ऑप्स होने से पहले सभी कमांड हैं, क्योंकि हम कहीं भी स्टैक डेप्थ कमांड का उपयोग नहीं कर रहे हैं। तो कोड वास्तव में ?पश्चिम में शुरू होता है , क्योंकि जब यह मृत अंत होता है , तो आईपी चारों ओर मुड़ जाता है।

इसलिए कोड निम्नलिखित रैखिक बिट कोड के साथ शुरू होता है:

?:}:+}

यह बस हमें सूत्र 2aका उपयोग करने की एक प्रति के साथ सेट करता [2a - a, 2a - b, 2a - c, ...]है।

?   Read first integer a.
:}  Move a copy off to the auxiliary stack.
:+  Multiply a by 2 (by adding it to itself).
}   Move that off to the auxiliary stack as well.

अब हम प्रोग्राम के मुख्य लूप में प्रवेश करते हैं, कोड की एक लाइन के माध्यम से लूप के लिए एक मानक मानक चाल का उपयोग करते हुए:

<...>

ध्यान दें कि जब भी हम हिट करेंगे तो स्टैक खाली होगा <इसलिए हमें पता है कि हम वहां शून्य प्राप्त करेंगे। इसके <बाद आईपी ले रही पूरी लाइन को घुमाता है, इसलिए हमें यह मिलता है:

...><

इसके बाद आईपी को बाईं ओर ले जाना पड़ता है, जहां >लाइन अपने मूल स्थान पर वापस जाती है (अगले पुनरावृत्ति के लिए इसे तैयार करने के लिए)। फिर लाइन को बस दाएं से बाएं निष्पादित किया जाता है, इसलिए एक एकल लूप पुनरावृत्ति यह है:

{:{-!\,:)%;?}}

इस प्रकार के लूप के साथ काम करते समय पकड़ यह है कि आप सशर्त निष्पादन के किसी भी रूप के साथ काम नहीं कर सकते हैं, क्योंकि लेबिरिंथ में कोड को छोड़ने का कोई तरीका नहीं है। इसलिए, हम ईओएफ को हिट करते हुए प्रोग्राम को शून्य से एक विभाजन के साथ समाप्त कर देंगे। यहां प्रत्येक लूप पुनरावृत्ति का टूटना है।

{:   Pull 2a back to the main stack and make a copy.
{    Pull the latest value i of the input list back to main as well.
-    Compute 2a-i/
!\   Print it with a trailing linefeed.
,    Read a character. If there are input elements left, this will be some
     form of separator character, and therefore a positive value x. However,
     at the end of the program, this will give -1.
:)   Make an incremented copy.
%    Try to to compute x%(x+1). This will error out at EOF.
;    Discard the result of the division.
?    Read the next input value.
}}   Move that and the remaining copy of 2a back to the auxiliary stack.
— मार्टिन एंडर
स्रोत
ये उपाय महान हैं। इनकी जांच करना और भूलभुलैया में सोचने के बारे में जानना बहुत अच्छा है।
— राबर्ट हिकमैन
0

सी ++ 14, 36 बाइट्स

अनाम लैंबडा अपने इनपुट को संशोधित करने के रूप में:

[](auto&c){for(auto&x:c)x=2*c[0]-x;}

डेनिस से तकनीक का उपयोग करना। जैसे किसी भी कंटेनर के लिए काम करता है int[]या vector<int>।

उपयोग:

#include<iostream>

auto f=
[](auto&c){for(auto&x:c)x=2*c[0]-x;}
;

int main(){
  int a[] = {1,  3,  4,  2,  8};
  f(a);
  for(auto&x:a)
    std::cout << x << ", ";
  std::cout<<"\n";
}
— कार्ल नेफ
स्रोत
0

सीजेएम, 16 बाइट्स

इनपुट प्रारूप: [1 2 3 4]। आसान सूत्र का उपयोग करता है।

l~_(2*/;a/,@@*.-

स्पष्टीकरण:

l~_(2*/;a/,@@*.-
l~_                     e#Read input twice into an array. Stack: [1 2 3 4] [1 2 3 4]
   (                    e#Get first element of the array. Stack: [1 2 3 4] [2 3 4] 1
    2*                  e#Multiply by two. Stack: [1 2 3 4] [2 3 4] 2
      /;                e#Discard second element. Stack: [1 2 3 4] 2
        a               e#Wrap into an array. Stack: [1 2 3 4] [2]
         /,             e#Rotate and get length. Stack: [2] [1 2 3 4] 4
           @@           e#Rotate twice. Stack: [1 2 3 4] 4 [2]
            *           e#Repeat len times. Stack: [1 2 3 4] [2 2 2 2]
             .-         e#Vectorized substraction. Stack: [-1 0 1 2]
                        e#Implictly print

बिना किसी परीक्षा लिंक के क्षमा करें। मुझे लगता है कि एसई को यह पसंद नहीं है कि यह अंदर कोष्ठक के साथ लिंक है।

— रोमन ग्रैफ़
स्रोत
Cjam.tryitonline.net भी है , जो बेस 64 सभी क्षेत्रों को एन्कोड करता है। हालांकि दोनों दुभाषिए मुझे एक त्रुटि देते हैं।
— डेनिस
0

पुष्य , 9 बाइट्स

{&}2*K~-_

Cmd लाइन पर अल्पविराम से मानों के रूप में तर्क दें $ pushy invdeltas.pshy 1,3,4,2,8:। यहाँ ब्रेकडाउन है, उदाहरण स्टैक के साथ:

           % Implicit: Input on stack              [1, 3, 4, 2, 8]
{&}        % Copy first item, put at end of stack  [1, 3, 4, 2, 8, 1]
   2*      % Multiply by 2                         [1, 3, 4, 2, 8, 2]
     K~    % Negate everything on stack            [-1, -3, -4, -2, -8, -2]
       -   % Subtract last item from all           [1, -1, -2, 0, -6]
        _  % Print whole stack

नोट: यह 8 बाइट्स हो सकता है यदि बैकवर्ड आउटपुट की अनुमति है: @&2*K~-_

— FlipTack
स्रोत
0

पर्ल, 26 + 3 ( -plaध्वज) = 29 बाइट्स

$_="@{[map$F[0]*2-$_,@F]}"

या

$_=join$",map$F[0]*2-$_,@F

का उपयोग करते हुए:

perl -plae '$_="@{[map$F[0]*2-$_,@F]}"' <<< "32 18 25 192 199"
— डेनिस इबाव
स्रोत
0

आइड, 11 बाइट्स

2*$1_0-$1

मंगलाचरण: ised --l 'file with input.txt' '2*$1_0-$1

(संपादित करें: डेनिस से बीजगणित चोरी करके सही किया गया)

— ओरियन
स्रोत
0

आश्चर्य है , 17 बाइट्स

@->#@- *2:0#1#0#0

मुझे यकीन नहीं है कि मैंने यह पहले क्यों नहीं पोस्ट किया। उपयोग:

(@->#@- *2:0#1#0#0)[5 6 7 8]

अधिक पठनीय:

@(map @
  - (
    * 2 get 0 #1
  ) #0
) #0
— मामा फन रोल
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.