प्रत्येक आयाम में योग


20

आपको पूर्णांक का एक बहु-आयामी सरणी दिया जाता है। प्रत्येक आयाम का एक निश्चित आकार होता है (ताकि यह 2 डी होने पर हमेशा आयताकार हो)। आपके कार्यक्रम को प्रत्येक आयाम में रकम की गणना करनी चाहिए और उस आयाम में नए अंतिम आइटम के रूप में रकम को जोड़ना चाहिए।

मान लें कि इनपुट और आउटपुट सरणियां ए और बी हैं, और ए के आयाम I का आकार n i है । B का आयाम A के समान होगा और आयाम I का आकार n i +1 होगा। बी जे 1 , जे 2 , ..., जे एमके 1 , के 2 , ..., के एम योग है जहां:

  • k i = j i अगर j i <= n i
  • 0 <k i <= n i अगर j i = n i +1

इनपुट के लिए:

[[1 2 3]
 [4 5 6]]

आपका प्रोग्राम (या फ़ंक्शन) आउटपुट होना चाहिए:

[[1 2 3 6]
 [4 5 6 15]
 [5 7 9 21]]

इनपुट में केवल सरणी है। प्रत्येक आयाम की कुल संख्या और प्रत्येक आयाम का आकार इनपुट में नहीं दिया गया है। (लेकिन आप उन्हें अपने कोड से सरणी से प्राप्त कर सकते हैं।) आप अपनी भाषा में किसी भी सुविधाजनक सूची प्रारूपों का उपयोग कर सकते हैं, जब तक कि यह सीधे आयामों या आयाम आकारों की संख्या निर्दिष्ट नहीं करता है।

इनपुट में कम से कम 1 आयाम है, और सरणी में कम से कम 1 आइटम है।

यह कोड-गोल्फ है। सबसे छोटा कोड जीतता है।

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

Input:
[5 2 3]
Output:
[5 2 3 10]

Input:
[[1 2 3] [4 5 6]]
Outputs:
[[1 2 3 6] [4 5 6 15] [5 7 9 21]]

Input:
[[[1] [1] [1] [0]]]
Output:
[[[1 1] [1 1] [1 1] [0 0] [3 3]] [[1 1] [1 1] [1 1] [0 0] [3 3]]]

Input:
[[[[-1]]]]
Output:
[[[[-1 -1] [-1 -1]] [[-1 -1] [-1 -1]]] [[[-1 -1] [-1 -1]] [[-1 -1] [-1 -1]]]]

क्या आप उस 16 बाइट एपीएल समाधान को पोस्ट करेंगे? अगर तुम नहीं, मैं कर सकता हूँ?
डेनिस

@ डेनिस आपको इसे पोस्ट करना चाहिए।
jimmy23013

जवाबों:


9

जे, 14 बाइट्स

#@$(0|:],+/^:)

उपयोग:

   ]a=.i.2 3
0 1 2
3 4 5

   (#@$(0|:],+/^:)) a    NB. parens are optional
0 1 2  3
3 4 5 12
3 5 7 15

फ़ंक्शन निम्न के बराबर है, (0|:],+/)^:(#@$)लेकिन पार्न्स को सहेजने के लिए उपयोगकर्ता-परिभाषित क्रियाविशेषण का उपयोग करता है।

दाईं ओर से बाईं ओर बाद वाले कोड के लिए स्पष्टीकरण:

  • ^:(#@$)आयामों ^:की संख्या #के लिए दोहराएं $:

    • ],+/अंतिम आयाम पर इसके योग के साथ ,तर्क को संक्षिप्त करें]+/
    • 0|:आयाम-सूची के अंत में |:पहले एक 0को डालकर आयामों को घुमाएं
  • उपरोक्त प्रक्रिया करने के बाद हमें सभी आयामों पर रकम के साथ मूल इनपुट वापस मिलता है।

मेरे पुराने समाधान के लिए संशोधन इतिहास की जाँच करें।

इसे यहाँ ऑनलाइन आज़माएँ।


15

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

#/.List->({##,+##}&)&

उदाहरण:

In[1]:= #/.List->({##,+##}&)&[{{1, 2, 3}, {4, 5, 6}}]

Out[1]= {{1, 2, 3, 6}, {4, 5, 6, 15}, {5, 7, 9, 21}}

स्पष्टीकरण:

का फुल फॉर्म {{1, 2, 3}, {4, 5, 6}}है List[List[1, 2, 3], List[4, 5, 6]]। फिर Listफ़ंक्शन के साथ सभी एस को अभिव्यक्ति में बदलें ({##,+##}&)


10

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

from numpy import*
a=copy(input())
for d in r_[:a.ndim]:a=r_[`d`,a,sum(a,d,keepdims=1)]
print a

यह प्रत्येक आयाम पर पुनरावृत्ति करता है, NumPy का उपयोग करके इसकी रकम को समाप्‍त करता है।

मैं NumPy के पार गया r_, जो कि गोल्फ के लिए बहुत बढ़िया है।r_[:n]से कम range(n)और बहुत अधिक शक्तिशाली (जैसे r_[:4, 7, 8, 10:100:10]) है। यह अन्य चीजों को भी कर सकता है जैसे कि एक मनमाना अक्ष के साथ संघनन।

उदाहरण का उपयोग:

$ python sum.py
[[1, 2, 3], [4, 5, 6]]
[[ 1  2  3  6]
 [ 4  5  6 15]
 [ 5  7  9 21]]

7

एपीएल, 16 15 बाइट्स

{×≡⍵:∇¨⍵,+/⍵⋄⍵}

3 बाइट को बंद करने और उचित इनपुट प्रारूप का पता लगाने के लिए @ user23013 के लिए धन्यवाद।

TryAPL के साथ परीक्षण मामलों को ऑनलाइन सत्यापित करें ।

विचार

सामान्य विचार मेरे सीजेएम सबमिशन के समान है, जिसके लिए एपीएल बहुत कम कार्यान्वयन की अनुमति देता है। इसमें केवल दो चरण होते हैं:

  1. सरणी को इसके सबसे बाहरी आयाम पर योग करें।

  2. प्रत्येक सबर्रे के लिए चरण 1 को दोहराएं।

कोड

{             } ⍝ Define a monadic function with argument ⍵ and reference ∇.
 ×≡⍵:           ⍝ If the depth of ⍵ is positive:
     ∇          ⍝   Apply this function...
      ¨         ⍝   to each element of...
       ⍵,       ⍝   the concatenation of ⍵...
         +/⍵    ⍝   and the sum across ⍵.
            ⋄⍵  ⍝  Else, return ⍵.

बस अपने मूल कोड के लिए इनपुट प्रारूप का पता लगाया: ,⊂(,1)(,1)(,1)(,0)और ,⊂,⊂,⊂,¯1क्रमशः। तो आप एक और चरित्र को हटा सकते हैं।
jimmy23013

2
@ user23013: तो मेरे कोड ने काम किया! आपको एक प्रोग्रामिंग भाषा से प्यार करना होगा, जहां वास्तविक कोड की तुलना में इनपुट फॉर्मेट को प्राप्त करना अधिक कठिन होता है ...
डेनिस

6

पिप , 18 15 बाइट्स

{a-a?fMaAE$+aa}

यह एक अनाम फ़ंक्शन है, जो सरणी को तर्क के रूप में लेता है और परिणाम देता है। नमूना मंगलाचरण, -pपठनीय उत्पादन प्राप्त करने के लिए ध्वज का उपयोग करना :

C:\> pip.py -pe "( {a-a?fMaAE$+aa} [[1 2 3] [4 5 6]] )"
[[1;2;3;6];[4;5;6;15];[5;7;9;21]]

विचार मूल रूप से डेनिस के एपीएल के समान है , हालांकि स्वतंत्र रूप से व्युत्पन्न है। अधिक विशेष रूप से:

{             }  Define a lambda function with parameter a
 a-a?            Shortest way I could find to test whether the argument is a list
                 or scalar: subtracting a number from itself gives 0 (falsy);
                 subtracting a list from itself gives a list of zeros (truthy!)
     fM          If truthy, it's a list, so map the same function (f) recursively to:
       aAE         Argument, with appended element...
          $+a      ...sum of argument (fold on +)
             a   If falsy, it's a scalar, so just return it

यह विधि काम करती है क्योंकि +(कई अन्य ऑपरेटरों के साथ) पिप में सूचियों पर आइटम-वार कार्य करता है - एपीएल जैसी सरणी-प्रोग्रामिंग भाषाओं से प्रेरित एक विशेषता। इसलिए जब आप $+एक सूची पसंद करते हैं [[1 2 3] [4 5 6]], तो परिणाम [5 7 9]वांछित होता है। सूची-या-स्केलर परीक्षण में भी उपयोग किया जाता है: [1 2 3] - [1 2 3]देता है [0 0 0], जो सत्य है (जैसा कि खाली सूची को छोड़कर सभी सूचियां हैं)।

पिछला 18-बाइट संस्करण:

{Ja=a?a(fMaAE$+a)}

परिवर्तन:

  1. स्केलर-या-सूची परीक्षण पर एक बाइट को बचाया - पिछली विधि तर्क में शामिल होने के लिए थी (खाली स्ट्रिंग पर) और परीक्षण करें कि क्या इसके संयुक्त-स्व के बराबर है (क्योंकि काम करता है [1 2 3] != 123);
  2. कोष्ठकों को समाप्त कर दिया। वे मूल में आवश्यक हैं क्योंकि Mकम पूर्ववर्तीता की तुलना में ?(हालांकि मैं शायद इसे बदलने जा रहा हूं, विशेष रूप से अब): उनके बिना, कोड के रूप में पार्स होगा (Ja=a?af)M(aAE$+a), जो त्रुटि संदेशों के लिए अग्रणी होगा । हालांकि, एक टर्नरी ऑपरेटर के मध्य तर्क में किसी भी पूर्वता की कोई भी अभिव्यक्ति हो सकती है, किसी कोष्ठक की आवश्यकता नहीं है। इसलिए सूची को सच्चाई का मामला बनाकर, मैं उन दो बाइट्स को बचा सकता हूं।

2
यह एक दिलचस्प भाषा है जो आपको वहां मिली है। आइटमवाइज ऑपरेटर्स CJam और Pyth में गायब हैं।
डेनिस

@ डेनिस धन्यवाद! यह अभी भी बहुत काम प्रगति पर है, लेकिन कुछ कार्य ऐसे हैं जो इसके साथ काफी अच्छी तरह से करते हैं।
DLosc

5

एपीएल (25)

{N⊣{N,[⍵]←+/[⍵]N}¨⍳⍴⍴N←⍵}

एपीएल के सरणियों में अंतर्निहित आयाम हैं, इसलिए यह एक ऐसा फ़ंक्शन है जो एक n -dimensional सरणी लेता है और फिर प्रत्येक आयाम के साथ बैठता है।

      {N⊣{N,[⍵]←+/[⍵]N}¨⍳⍴⍴N←⍵} ↑(1 2 3)(4 5 6)
1 2 3  6
4 5 6 15
5 7 9 21

स्पष्टीकरण:

  • N←⍵: में सरणी स्टोर N
  • ⍴⍴N: आयामों की मात्रा प्राप्त करें N। ( आयाम देता है, यानी ⍴↑(1 2 3)(4 5 6)देता है 2 3, इसलिए ⍴⍴आयामों के आयाम देता है।)
  • {... }¨⍳: 1 से प्रत्येक संख्या के लिए ⍴⍴N:
    • +/[⍵]N: Nआयाम के साथ योग
    • N,[⍵]←: परिणाम को Nउस आयाम में शामिल करें
  • N: अंत में, वापस N

अगर सरणी में एकल शामिल हैं तो मैं यह काम नहीं कर सकता। आप इस फंक्शन को तीसरे या चौथे टेस्ट केस के लिए कैसे कहेंगे?
डेनिस

3
@ डेनिस: आपको फ़ंक्शन को बहुआयामी सरणी पास करना होगा। क्या ↑(1 2 3)(4 5 6)कर रहा है बस का उपयोग कर 2 1-आयामी लोगों से एक 2-आयामी सरणी का निर्माण कर रहा है । यह बिल्ट-इन नोटेशन नहीं है और यह आपके सोचने के तरीके को सामान्य नहीं करता है। विहित रास्ता 3 के निर्माण के लिए और 4 सरणियों होगा 1 4 1⍴1 1 1 0और 1 1 1 1⍴¯1, लेकिन यह भी आकार, जैसे, तीसरे सरणी भी साथ निर्माण किया जा सकता का जिक्र किए बिना उन्हें निर्माण संभव है ↑⍉⍪(,1)(,1)(,1)(,0), चौथे एक के साथ निर्माण किया जा सकता ↑⍪⊂⍪¯1
मारीनस

ठीक है, जो सब कुछ समझाता है। एक पुनरावर्ती दृष्टिकोण के मेरे भोले कार्यान्वयन के लिए अच्छी तरह से काम करता है जो मैंने सोचा था कि एरेज़ (जैसे f←{0=≡⍵:⍵⋄f¨⍵,+/⍵}⋄f((1 2)(3 4))((5 6)(7 8))) थे, लेकिन ऐसा लगता है कि नेस्टेड वैक्टर और सरणियां अलग हैं और पूर्व एकल से स्केलर को अलग नहीं करता है ...
डेनिस

2
@Dennis golfed: {×≡⍵:∇¨⍵,+/⍵⋄⍵}((1 2)(3 4))((5 6)(7 8))। फिक्स्ड: {×⍴⍴⍵:∇↓⍵,+/⍵⋄⍵}1 4 1⍴1 1 1 0। यह अब गणितज्ञ की तुलना में छोटा है ...
jimmy23013

3

CJam, 36 बाइट्स

{_`{'[<}#:D{_":"D'.e]'++~a+{S}%}&}:S

यह एक पुनरावर्ती फ़ंक्शन है जो स्टैक से एक सरणी पॉप करता है और बदले में एक छोड़ देता है।

CJam दुभाषिया में परीक्षण मामलों की कोशिश करें ।

विचार

अफसोस की बात है, सीजेएम के पास कुछ ऑटोमैटिक ऑपरेटर नहीं हैं जो मनमाने ढंग से नेस्टेड एरेज़ को जोड़ने की अनुमति देता है, इसलिए हमें खुद को लागू करना होगा। सौभाग्य से, यह दो infix ऑपरेटरों, :(कम) और .(वेक्टराइज़) करता है, जो इस कार्य के लिए मददगार साबित होंगे।

चरण एक आयामों की संख्या की गणना कर रहा है। यह आसान है: अपने स्ट्रिंग प्रतिनिधित्व में सरणी में कनवर्ट करें और अग्रणी की संख्या की गणना [ के।

अब, एक आयाम की एक सरणी को कम करने के लिए, आप आमतौर पर सिर्फ निष्पादित करते हैं :+:

[1 2] :+ e# Pushes 3.

दो आयामों की एक सरणी के +लिए, जोड़-घटाव के बजाय संगति करेंगे, इसलिए हमें इसे सदिश करना होगा:

[[1 2][3 4]] :.+ Pushes [4 6].

अब, तीन आयामों की एक सरणी के .+लिए, दो आयामों के सरणियों पर काम करेंगे और प्रदर्शन करेंगे, एक बार फिर से, संघनन। इस बार, हमें वेक्टर करना होगा .+:

[[[1 2][3 4]][[5 6][7 8]]] :..+ e# Pushes [[[6 8] [10 12]]].

सामान्य मामले के लिए, आयाम डी की एक सरणी , हमें श्रृंखला एक :, डी - 1 . और एक की श्रृंखला है +

बेशक, यह केवल सरणी को केवल अपने सबसे अधिक आयाम पर रखता है। हम इसे एक फ़ंक्शन S को परिभाषित करके हल कर सकते हैं जो आयाम की गणना करता है (और शून्य होने पर कुछ भी नहीं करता है), ऊपर बताए अनुसार योग करता है और अंत में, सरणी के तत्वों पर खुद को लागू करता है।

कोड

{                                }:S e# Define S:
 _`                                  e#   Push a string representation of a the array.
   {'[<}#                            e#   Find the index of the first non-bracket.
         :D                          e#   Save it in D.
           {                   }&    e#   If D is positive:
            _                        e#     Push a copy of the array.
             ":"D'.e]                e#     Pad ":" with "."s to a string of length D.
                     '++~            e#     Add a "+" to the string and evaluate.
                         a+          e#     Wrap the result in a array and concatenate.
                           {S}%      e#     Apply S to the elements of the array.

2

रूबी ( 181 139 119 108 बाइट्स)

def d a;a.push a[0].to_s['[']?a.map{|x|d x}.transpose.map{|x|x.reduce:+}:a.reduce(:+)end
p d eval ARGF.read

माना जाता है कि इनपुट JSON के रूप में पारित किया गया है।


और वास्तव में आप केवल एक फ़ंक्शन लिख सकते हैं जो एक पार्स सरणी को स्वीकार करता है और एक सरणी देता है, और dइस उत्तर के लिए केवल 95 बाइट्स गिनता है ।
jimmy23013

2

जावा, 669 बाइट्स

झूठ मत बोलो, मुझे इस पर गर्व है: पी

import java.lang.reflect.Array;enum S{D;<A>A s(A a){int l=Array.getLength(a),x=0;Class t=a.getClass();Class c=t.getComponentType();A r=(A)Array.newInstance(c,l+1);System.arraycopy(a,0,r,0,l);if(t==int[].class)for(;x<l;)((int[])r)[l]=((int[])r)[l]+((int[])r)[x++];else{for(;x<l;)Array.set(r,x,S.this.s(Array.get(r,x++)));Object o=Array.get(r,0);for(;--x>0;)o=s(o,Array.get(r,x));Array.set(r,l,o);}return r;}<A>A s(A a,A b){int l=Array.getLength(a),x=0;Class t=a.getClass();A r=(A)Array.newInstance(t.getComponentType(),l);if(int[].class==t)for(;x<l;)((int[])r)[x]=((int[])a)[x]+((int[])b)[x++];else for(;x<l;)Array.set(r,x,s(Array.get(a,x),Array.get(b,x++)));return r;}}

परीक्षण के साथ विस्तारित:

import java.lang.reflect.Array;
import java.util.Arrays;

public enum SumOf{
    Dimensions;

    <A>A sum(A array){ //call this method to solve the challenge
        int length=Array.getLength(array),x=0;
        Class arrayType=array.getClass();
        Class componentType=arrayType.getComponentType();
        //grow the array to include the sum element
        A result=(A)Array.newInstance(componentType,length+1);
        System.arraycopy(array,0,result,0,length);
        if(arrayType==int[].class) //one-dimensional array needs to be handled separately
            for(;x<length;) //find the sum
                ((int[])result)[length]=((int[])result)[length]+((int[])result)[x++];        
        else{ //multi-dimensional array
            for(;x<length;) //find the sum for each element in this dimension's array
                Array.set(result,x,sum(Array.get(result,x++)));
            //find the total sum for this dimension's array
            Object s=Array.get(result,0);
            for(;--x>0;)
                s=_sum(s,Array.get(result,x)); //add the 2 elements together
            Array.set(result,length,s);
        }
        return result;
    }

    <A>A _sum(A arrayA,A arrayB){ //this method is used by the previous method
        int length=Array.getLength(arrayA),x=0;
        Class arrayType=arrayA.getClass();
        A result=(A)Array.newInstance(arrayType.getComponentType(),length);
        if(int[].class==arrayType) //one-dimensional array needs to be handled separately
            for(;x<length;) //find the sum of both arrays
                ((int[])result)[x]=((int[])arrayA)[x]+((int[])arrayB)[x++];
        else
            for(;x<length;) //find the sum of both arrays
                Array.set(result,x,sum(Array.get(arrayA,x),Array.get(arrayB,x++)));
            return result;
        }

    static int[] intArray( int firstElement, int...array ) {
        if( array == null ) array = new int[0];
        array = Arrays.copyOf( array, array.length + 1 );
        System.arraycopy( array, 0, array, 1, array.length - 1 );
        array[0] = firstElement;
        return array;
    }

    static <E> E[] arrayArray( E firstElement, E...array ) {
        if( array == null ) array = (E[]) Array.newInstance( firstElement.getClass(), 0 );
        array = Arrays.copyOf( array, array.length + 1 );
        System.arraycopy( array, 0, array, 1, array.length - 1 );
        array[0] = firstElement;
        return array;
    }

    static void printIntArray( int[]array ){
        System.out.print("[ ");
        for( int x = 0; x < array.length; x++ )
            System.out.print( array[x] + " " );
        System.out.print("] ");
    }

    static < A > void printArray( A array ) {
        if( array.getClass() == int[].class ){
            printIntArray( (int[]) array );
        }
        else {
            System.out.print("[ ");
            int length = Array.getLength( array );
            for( int x = 0; x < length; x++ )
                printArray( Array.get( array, x ) );
            System.out.print("] ");
        }
    }

    public static void main(String[]s){
        int[] test01 = intArray( 5, 2, 3 );
        System.out.print("Input: ");
        printArray( test01 );
        System.out.print("\nOutput: ");
        printArray( SumOf.Dimensions.sum( test01 ) );
        System.out.println();

        int[][] test02 = arrayArray( intArray( 1, 2, 3 ), intArray( 4, 5, 6 ) );
        System.out.print("\nInput: ");
        printArray( test02 );
        System.out.print("\nOutput: ");
        printArray( SumOf.Dimensions.sum( test02 ) );
        System.out.println();

        int[][][] test03 = arrayArray( arrayArray( intArray( 1 ), intArray( 1 ), intArray( 1 ), intArray( 0 ) ) );
        System.out.print("\nInput: ");
        printArray( test03 );
        System.out.print("\nOutput: ");
        printArray( SumOf.Dimensions.sum( test03 ) );
        System.out.println();

        int[][][][] test04 = arrayArray( arrayArray( arrayArray( intArray( -1 ) ) ) );
        System.out.print("\nInput: ");
        printArray( test04 );
        System.out.print("\nOutput: ");
        printArray( SumOf.Dimensions.sum( test04 ) );
        System.out.println();

        int[][][] test05 = arrayArray( arrayArray( intArray( 1, 2, 3 ), intArray( 4, 5, 6 ), intArray( 7, 8, 9 ) ), arrayArray( intArray( 11, 12, 13 ), intArray( 14, 15, 16 ), intArray( 17, 18, 19 ) ), arrayArray( intArray( 21, 22, 23 ), intArray( 24, 25, 26 ), intArray( 27, 28, 29 ) ) );
        System.out.print("\nInput: ");
        printArray( test05 );
        System.out.print("\nOutput: ");
        printArray( SumOf.Dimensions.sum( test05 ) );
        System.out.println();
    }

}

विस्तारित परीक्षण संस्करण चलाने से यह प्रिंट होता है:

Input: [ 5 2 3 ] 
Output: [ 5 2 3 10 ] 

Input: [ [ 1 2 3 ] [ 4 5 6 ] ] 
Output: [ [ 1 2 3 6 ] [ 4 5 6 15 ] [ 5 7 9 21 ] ] 

Input: [ [ [ 1 ] [ 1 ] [ 1 ] [ 0 ] ] ] 
Output: [ [ [ 1 1 ] [ 1 1 ] [ 1 1 ] [ 0 0 ] [ 3 3 ] ] [ [ 1 1 ] [ 1 1 ] [ 1 1 ] [ 0 0 ] [ 3 3 ] ] ] 

Input: [ [ [ [ -1 ] ] ] ] 
Output: [ [ [ [ -1 -1 ] [ -1 -1 ] ] [ [ -1 -1 ] [ -1 -1 ] ] ] [ [ [ -1 -1 ] [ -1 -1 ] ] [ [ -1 -1 ] [ -1 -1 ] ] ] ] 

Input: [ [ [ 1 2 3 ] [ 4 5 6 ] [ 7 8 9 ] ] [ [ 11 12 13 ] [ 14 15 16 ] [ 17 18 19 ] ] [ [ 21 22 23 ] [ 24 25 26 ] [ 27 28 29 ] ] ] 
Output: [ [ [ 1 2 3 6 ] [ 4 5 6 15 ] [ 7 8 9 24 ] [ 12 15 18 45 ] ] [ [ 11 12 13 36 ] [ 14 15 16 45 ] [ 17 18 19 54 ] [ 42 45 48 135 ] ] [ [ 21 22 23 66 ] [ 24 25 26 75 ] [ 27 28 29 84 ] [ 72 75 78 225 ] ] [ [ 33 36 39 108 ] [ 42 45 48 135 ] [ 51 54 57 162 ] [ 126 135 144 405 ] ] ] 

विस्तारित संस्करण के लिए erm, पंक्ति: Array.set (परिणाम, x, योग (Array.get (arrayA, x), Array.get (arrayB, x ++))); _sum (...) विधि में _sum (...) को बुलाया जाना चाहिए, योग (...) को नहीं। मेरा बुरा
जैक अम्मो
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.