पायथन में संख्याओं की एक सूची का योग

Question

मेरे पास संख्याओं की एक सूची है जैसे कि [1,2,3,4,5...], और मैं (1+2)/2दूसरे (2+3)/2और तीसरे (3+4)/2और इसी तरह की गणना करना चाहता हूं । मैं उसे कैसे कर सकता हूँ?

मैं पहले नंबर को दूसरे के साथ जोड़ना चाहूंगा और इसे 2 से भाग दूंगा, फिर तीसरे के साथ दूसरे को जोड़ूंगा और 2 से विभाजित करूंगा, और इसी तरह।

इसके अलावा, मैं संख्याओं की सूची कैसे लिख सकता हूं?

a = [1, 2, 3, 4, 5, ...]

क्या यह:

b = sum(a)
print b

एक नंबर पाने के लिए?

यह मेरे लिए काम नहीं करता है।

Comments

यह सूची कब तक है? 0 और 1 के बीच मूल्य कितने यादृच्छिक हैं?

— केवपी

यदि आप अजगर को गड़बड़ाने से पहले योग को परिभाषित करते हैं, तो डेल राशि का प्रयास करें। शायद यह कहीं न कहीं कोड में परिभाषित किया गया है और डिफ़ॉल्ट फ़ंक्शन को ओवरराइट करता है। इसलिए मैंने इसे हटा दिया और समस्या हल हो गई। (user4183543 द्वारा उत्तर)

— NicoKowe

"यह काम नहीं करता है" एक समस्या वर्णन नहीं है।

— लोर्न

Answer 1

प्रश्न 1: तो आप चाहते हैं (तत्व 0 + तत्व 1) / 2, (तत्व 1 + तत्व 2) / 2, ... आदि।

हम दो सूची बनाते हैं: पहले को छोड़कर प्रत्येक तत्व में से एक, और अंतिम को छोड़कर प्रत्येक तत्व में से एक। फिर हम जो औसत चाहते हैं वह दो सूचियों से ली गई प्रत्येक जोड़ी का औसत है। हम zipदो सूचियों से जोड़े लेने के लिए उपयोग करते हैं।

मुझे लगता है कि आप परिणाम में दशमलव देखना चाहते हैं, भले ही आपके इनपुट मान पूर्णांक हों। डिफ़ॉल्ट रूप से, पायथन पूर्णांक विभाजन करता है: यह शेष को छोड़ देता है। सभी तरह से चीजों को विभाजित करने के लिए, हमें फ्लोटिंग-पॉइंट नंबरों का उपयोग करने की आवश्यकता है। सौभाग्य से, एक फ्लोट द्वारा एक इंट को विभाजित करने से एक फ्लोट का उत्पादन होगा, इसलिए हम सिर्फ 2.0अपने विभाजक के लिए उपयोग करते हैं 2।

इस प्रकार:

averages = [(x + y) / 2.0 for (x, y) in zip(my_list[:-1], my_list[1:])]

प्रश्न 2:

इसका उपयोग sumठीक काम करना चाहिए। निम्नलिखित कार्य:

a = range(10)
# [0,1,2,3,4,5,6,7,8,9]
b = sum(a)
print b
# Prints 45

इसके अलावा, आपको हर कदम पर एक चर के साथ सब कुछ असाइन करने की आवश्यकता नहीं है। print sum(a)ठीक काम करता है।

आपने जो लिखा और जो काम नहीं कर रहा है, उसके बारे में आपको अधिक विशिष्ट होना पड़ेगा।

Comments

मुझे नहीं मिला, पहले सवाल के लिए मुझे my_list अपरिभाषित मिला। मेरे कार्यक्रम में इसकी एक यादृच्छिक संख्या 1, 2, 3, 4 .. दूसरे प्रश्न के लिए मेरे साथ काम नहीं करेगी, मुझे पता नहीं क्यों

— Layo

my_listकेवल परिभाषित है यदि आप इसे परिभाषित करते हैं। यह माना जाता था कि आप जिस भी सूची में काम करने की कोशिश कर रहे हैं, आपको वह जगह मिल जाएगी। मैं अनुमान नहीं लगा सकता कि आपने इसे क्या कहा है।

— कार्ल Knechtel

6 साल बाद, यह पोस्ट अभी भी लोगों की मदद कर रही है। मेरे पास मेरे कोड में गड़बड़ थी और यह पुष्टि करने के लिए आपके पोस्ट का उपयोग करने में सक्षम था कि मेरे कोड में आपके लिए संबंधित अवधारणाएं भी सही थीं, इसलिए समस्या कहीं और होनी चाहिए। तब मैंने इसे पाया। बस आपने और प्रश्न वाले व्यक्ति को त्वरित धन्यवाद के रूप में एक अप-वोट दिया। शुभकामनाएँ।

— TMWP

@KarlKnechtel उनके पास अपने प्रश्न में एक सूची थी और इसे " a" कहा जाता था ।

— 18गूगल में HelloGoodbye

चूंकि zipयह एक बार छोटे तर्क के अंत तक पहुँच जाता है, zip(my_list, my_list[1:])पर्याप्त है।

— 19

Answer 2

संख्याओं की सूची:

sum(list_of_nums)

सूची बोध का उपयोग करके n और n - 1 का आधा भाग (यदि मेरा पैटर्न सही है) :

[(x + (x - 1)) / 2 for x in list_of_nums]

समीपवर्ती तत्व, जैसे ((1 + 2) / 2) + ((2 + 3) / 2) + ... कम और लंबोदा का उपयोग

reduce(lambda x, y: (x + y) / 2, list_of_nums)

Comments

मुझे लगता है कि वह आसन्न तत्वों को योग करना चाहता है। का औसत निकालकर कोई मतलब नहीं होगा xऔर x - 1; हम इसके बजाय केवल 0.5 घटा सकते हैं।

— कार्ल केनचेल

कम फ़ंक्शन वह नहीं करता है जो पोस्ट कहता है। यह गणना करता है (((a1 + a2) / 2 + a3) / 2 + a4) / 2 ...

— Moberg

from functools import reduce

— टाइरेक्स

Answer 3

प्रश्न 2: पूर्णांक की सूची का योग करने के लिए:

a = [2, 3, 5, 8]
sum(a)
# 18
# or you can do:
sum(i for i in a)
# 18

यदि सूची में तार के रूप में पूर्णांक हैं:

a = ['5', '6']
# import Decimal: from decimal import Decimal
sum(Decimal(i) for i in a)

Comments

sum(i for i in a)बस बेमानी है।

— जीन फ़्राँस्वा Fabre

sum(Decimal(i) for i in a)=> sum(int(i) for i in a)याsum(map(int,a))

— जीन फ़्राँस्वा Fabre

Answer 4

आप इस तरह से कोशिश कर सकते हैं:

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
sm = sum(a[0:len(a)]) # Sum of 'a' from 0 index to 9 index. sum(a) == sum(a[0:len(a)]
print(sm) # Python 3
print sm  # Python 2

Comments

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

— जीन फ़्राँस्वा Fabre

@ जीन-फ्रांस्वा फ़्रेबर क्या आप कृपया अपनी टिप्पणी का विवरण दे सकते हैं? यह "भयानक रूप से अप्राकृतिक" क्यों है?

— पियरेफ

शुरुआत के लिए a[0:len(a)]एक प्रतिलिपि बनाता है a, सीपीयू और मेमोरी को बर्बाद करने के अलावा क्या बात है? फिर print(sm)अजगर 2 में भी काम करता है। मुझे समझ में नहीं आता कि 2017 के मध्य में यह बहुत अधिक क्यों है ... लेकिन यह यहां अधिकांश उत्तरों पर लागू होता है।

— जीन-फ्रांस्वा फाबरे

Answer 5

>>> a = range(10)
>>> sum(a)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable
>>> del sum
>>> sum(a)
45

ऐसा लगता है कि sumकोड में कहीं परिभाषित किया गया है और डिफ़ॉल्ट फ़ंक्शन को ओवरराइट करता है। इसलिए मैंने इसे हटा दिया और समस्या हल हो गई।

Answer 6

एक सरल list-comprehensionऔर का उपयोग करना sum:

>> sum(i for i in range(x))/2. #if x = 10 the result will be 22.5

Comments

आपको उपयोग करने की आवश्यकता नहीं है [और ], आप जनरेटर अभिव्यक्ति को पास कर सकते हैंsum(i/2. for i in range(x))

— इवान

sum(range(x)) / 2.सभी विभाजनों से बचा जाता है, बस अंत में विभाजित होते हैं।

— जीन फ़्राँस्वा Fabre

Answer 7

सभी उत्तरों ने एक प्रोग्रामेटिक और सामान्य दृष्टिकोण दिखाया। मैं आपके मामले के लिए विशिष्ट गणितीय दृष्टिकोण का सुझाव देता हूं। यह विशेष रूप से लंबी सूचियों के लिए तेज हो सकता है। यह काम करता है क्योंकि आपकी सूची प्राकृतिक संख्याओं की एक सूची है n:

मान लें कि हमारे पास प्राकृतिक संख्याएँ हैं 1, 2, 3, ..., 10:

>>> nat_seq = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

आप sumकिसी सूची में फ़ंक्शन का उपयोग कर सकते हैं :

>>> print sum(nat_seq)
55

आप उस सूत्र का उपयोग भी कर सकते हैं n*(n+1)/2जहां nसूची में अंतिम तत्व का मूल्य है (यहां nat_seq[-1]:), इसलिए आप तत्वों पर पुनरावृत्ति से बचते हैं:

>>> print (nat_seq[-1]*(nat_seq[-1]+1))/2
55

अनुक्रम उत्पन्न करने के लिए (1+2)/2, (2+3)/2, ..., (9+10)/2आप एक जनरेटर और सूत्र का उपयोग कर सकते हैं (2*k-1)/2.(मान को फ़्लोटिंग पॉइंट बनाने के लिए ध्यान दें)। नई सूची बनाते समय आपको पहला तत्व छोड़ना होगा:

>>> new_seq = [(2*k-1)/2. for k in nat_seq[1:]]
>>> print new_seq
[1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5]

यहाँ भी, आप sumउस सूची में फ़ंक्शन का उपयोग कर सकते हैं :

>>> print sum(new_seq)
49.5

लेकिन आप सूत्र का उपयोग भी कर सकते हैं (((n*2+1)/2)**2-1)/2, ताकि आप तत्वों पर ध्यान देने से बच सकें:

>>> print (((new_seq[-1]*2+1)/2)**2-1)/2
49.5

Answer 8

इस समस्या को हल करने का सबसे सरल तरीका:

l =[1,2,3,4,5]
sum=0
for element in l:
    sum+=element
print sum

Answer 9

इस सवाल का जवाब यहां दिया गया है

a = [१,२,३,४] योग (क) १०

Answer 10

import numpy as np    
x = [1,2,3,4,5]
[(np.mean((x[i],x[i+1]))) for i in range(len(x)-1)]
# [1.5, 2.5, 3.5, 4.5]

Answer 11

जेनरेटर इसे लिखने का एक आसान तरीका है:

from __future__ import division
# ^- so that 3/2 is 1.5 not 1

def averages( lst ):
    it = iter(lst) # Get a iterator over the list
    first = next(it)
    for item in it:
        yield (first+item)/2
        first = item

print list(averages(range(1,11)))
# [1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5]

Comments

पूर्णांक विभाजन से बचने के लिए आप 2.0 से भाग कर सकते हैं।

— क्रिस एंडरसन

अजगर में सच नहीं @ChrisAnderson 3. फ्लोटिंग पॉइंट डिवीजन डिफ़ॉल्ट है।

— जस्टिन मीनर्स

Answer 12

आइए हम शुरुआत के लिए आसान बनाते हैं: -

1. globalकीवर्ड एक नया स्थानीय चर उत्पादन के बिना वैश्विक चर संदेश मुख्य कार्य के भीतर सौंपा जा करने की अनुमति देगा

    message = "This is a global!"


def main():
    global message
    message = "This is a local"
    print(message)


main()
# outputs "This is a local" - From the Function call
print(message)
# outputs "This is a local" - From the Outer scope

इस अवधारणा को शैडोइंग कहा जाता है

2. पायथन में संख्याओं की एक सूची का योग

nums = [1, 2, 3, 4, 5]

var = 0


def sums():
    for num in nums:
        global var
        var = var + num
    print(var)


if __name__ == '__main__':
    sums()

आउटपुट = 15

Answer 13

pairwise Itertools नुस्खा का उपयोग :

import itertools
def pairwise(iterable):
    "s -> (s0,s1), (s1,s2), (s2, s3), ..."
    a, b = itertools.tee(iterable)
    next(b, None)
    return itertools.izip(a, b)

def pair_averages(seq):
    return ( (a+b)/2 for a, b in pairwise(seq) )

Answer 14

लघु और सरल:

def ave(x,y):
  return (x + y) / 2.0

map(ave, a[:-1], a[1:])

और यहाँ है कि यह कैसा दिखता है:

>>> a = range(10)
>>> map(ave, a[:-1], a[1:])
[0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5]

में कैसे अजगर एक हैंडल कुछ मूर्खता के कारण mapदो से अधिक सूचियों, आप, सूची में काट-छांट की क्या ज़रूरत है a[:-1]। यदि आप उपयोग करते हैं तो यह आपकी अपेक्षा के अनुसार काम करता है itertools.imap:

>>> import itertools
>>> itertools.imap(ave, a, a[1:])
<itertools.imap object at 0x1005c3990>
>>> list(_)
[0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5]

Comments

लघु, हाँ। सरल? इसे समझने के लिए लंबे समाधानों की तुलना में लंबे समय तक स्पष्टीकरण की आवश्यकता है कि यह क्या कर रहा है।

— टेकहेड

यह फ्लोटिंग पॉइंट संचय त्रुटि का परिचय देता है। इसके बजाय अंत में विभाजित करें।

— जीन फ़्राँस्वा Fabre

@ जीन-फ्रांस्वा फ़्रेब्रे दोनों विधियाँ अपूर्ण हैं - अंत में विभाजित होने से बड़ी संख्या के लिए अतिप्रवाह होगा, समाधान डेटा (और उपयोग के मामले) पर निर्भर करता है।

— cz

Answer 15

इतने सारे समाधान, लेकिन मेरा पसंदीदा अभी भी गायब है:

>>> import numpy as np
>>> arr = np.array([1,2,3,4,5])

एक सुन्न सरणी एक सूची (इस उपयोग के मामले में) से बहुत अलग नहीं है, सिवाय इसके कि आप संख्याओं की तरह सरणियों का इलाज कर सकते हैं:

>>> ( arr[:-1] + arr[1:] ) / 2.0
[ 1.5  2.5  3.5  4.5]

किया हुआ!

व्याख्या

फैंसी सूचकांकों का यह अर्थ है: [1:]1 से अंत तक सभी तत्व शामिल हैं (इस प्रकार तत्व 0 छोड़ना), और [:-1]अंतिम तत्व को छोड़कर सभी तत्व हैं:

>>> arr[:-1]
array([1, 2, 3, 4])
>>> arr[1:]
array([2, 3, 4, 5])

इसलिए उन दोनों को जोड़ने से आपको एलीमेन्स (1 + 2), (2 + 3) और इसी तरह की एक सरणी मिलती है। ऐसा नहीं है कि मैं विभाजित कर रहा हूं 2.0, 2इसलिए नहीं कि अन्यथा पायथन का मानना ​​है कि आप केवल पूर्णांकों का उपयोग कर रहे हैं और पूर्णांक पूर्णांक परिणाम उत्पन्न करते हैं।

सुन्न का उपयोग करने का लाभ

Numpy संख्याओं की सूची के आसपास छोरों की तुलना में बहुत तेज हो सकता है । आपकी सूची कितनी बड़ी है, इस पर निर्भर करते हुए कि परिमाण के कई क्रम तेज़ हैं। इसके अलावा, यह बहुत कम कोड है, और कम से कम मेरे लिए, इसे पढ़ना आसान है। मैं संख्याओं के सभी समूहों के लिए उपयोग करने से बाहर एक आदत बनाने की कोशिश कर रहा हूं, और यह सभी छोरों और लूप्स-भीतर-छोरों के लिए एक बहुत बड़ा सुधार है जो मुझे अन्यथा बनाना होगा।

Answer 16

मैं सिर्फ नक्शे के साथ एक लंबो () का उपयोग करूँगा

a = [1,2,3,4,5,6,7,8,9,10]
b = map(lambda x, y: (x+y)/2.0, fib[:-1], fib[1:])
print b

Answer 17

मैं whileपरिणाम प्राप्त करने के लिए एक लूप का उपयोग करता हूं :

i = 0
while i < len(a)-1:
   result = (a[i]+a[i+1])/2
   print result
   i +=1

Answer 18

सूची में तत्वों के माध्यम से लूप और इस तरह कुल अपडेट करें:

def sum(a):
    total = 0
    index = 0
    while index < len(a):
        total = total + a[index]
        index = index + 1
    return total

Answer 19

कार्ल Knechtel के लिए धन्यवाद मैं आपके प्रश्न को समझने में सक्षम था। मेरी व्याख्या:

1. आप तत्व i और i + 1 के औसत के साथ एक नई सूची चाहते हैं।
2. आप सूची में प्रत्येक तत्व को जोड़ना चाहते हैं।

अनाम फ़ंक्शन (उर्फ लंबोदा फ़ंक्शन) का उपयोग करके पहला प्रश्न:

s = lambda l: [(l[0]+l[1])/2.] + s(l[1:]) if len(l)>1 else []  #assuming you want result as float
s = lambda l: [(l[0]+l[1])//2] + s(l[1:]) if len(l)>1 else []  #assuming you want floor result

अनाम फ़ंक्शन (उर्फ लंबोदा फ़ंक्शन) का उपयोग करके दूसरा प्रश्न:

p = lambda l: l[0] + p(l[1:]) if l!=[] else 0

कोड की एक पंक्ति में दोनों प्रश्न संयुक्त हैं:

s = lambda l: (l[0]+l[1])/2. + s(l[1:]) if len(l)>1 else 0  #assuming you want result as float
s = lambda l: (l[0]+l[1])/2. + s(l[1:]) if len(l)>1 else 0  #assuming you want floor result

अपनी जरूरतों के हिसाब से जो सबसे उपयुक्त हो, उसका उपयोग करें

Answer 20

आप पुनरावृत्ति का उपयोग करके भी ऐसा कर सकते हैं:

पायथन स्निपेट:

def sumOfArray(arr, startIndex):
    size = len(arr)
    if size == startIndex:  # To Check empty list
        return 0
    elif startIndex == (size - 1): # To Check Last Value
        return arr[startIndex]
    else:
        return arr[startIndex] + sumOfArray(arr, startIndex + 1)


print(sumOfArray([1,2,3,4,5], 0))

Answer 21

एक सूची समझ का उपयोग करने का प्रयास करें। कुछ इस तरह:

new_list = [(old_list[i] + old_list[i+1])/2 for i in range(len(old_list-1))]

Comments

@ यह एक काम कर रहा है (यदि हम अंत में कोष्ठक को ठीक करते हैं - होना चाहिए range(len(old_list) - 1)), लेकिन पाइथोनिस्टस आमतौर पर 'रेंज' और 'लेन' के संयोजन पर आधारित होते हैं। "यह करने के लिए केवल एक ही तरीका होना चाहिए" का एक कोरोलरी है "मानक पुस्तकालय आपको बदसूरत चीजों से बचने का एक तरीका प्रदान करता है"। अप्रत्यक्ष पुनरावृत्ति - संख्याओं के अनुक्रम पर पुनरावृत्ति, ताकि आप उन संख्याओं का उपयोग करके अनुक्रमण कर सकें कि आप वास्तव में क्या करना चाहते हैं - यह एक बदसूरत चीज़ है।

— कार्ल Knechtel

Answer 22

Itertools की भावना में। जोड़ीदार नुस्खा से प्रेरणा।

from itertools import tee, izip

def average(iterable):
    "s -> (s0,s1)/2.0, (s1,s2)/2.0, ..."
    a, b = tee(iterable)
    next(b, None)
    return ((x+y)/2.0 for x, y in izip(a, b))

उदाहरण:

>>>list(average([1,2,3,4,5]))
[1.5, 2.5, 3.5, 4.5]
>>>list(average([1,20,31,45,56,0,0]))
[10.5, 25.5, 38.0, 50.5, 28.0, 0.0]
>>>list(average(average([1,2,3,4,5])))
[2.0, 3.0, 4.0]

Answer 23

n = int(input("Enter the length of array: "))
list1 = []
for i in range(n):
    list1.append(int(input("Enter numbers: ")))
print("User inputs are", list1)

list2 = []
for j in range(0, n-1):
    list2.append((list1[j]+list1[j+1])/2)
print("result = ", list2)

Answer 24

एक सरल तरीका iter_tools क्रमचय का उपयोग करना है

# If you are given a list

numList = [1,2,3,4,5,6,7]

# and you are asked to find the number of three sums that add to a particular number

target = 10
# How you could come up with the answer?

from itertools import permutations

good_permutations = []

for p in permutations(numList, 3):
    if sum(p) == target:
        good_permutations.append(p)

print(good_permutations)

परिणाम है:

[(1, 2, 7), (1, 3, 6), (1, 4, 5), (1, 5, 4), (1, 6, 3), (1, 7, 2), (2, 1, 7), (2, 3, 
5), (2, 5, 3), (2, 7, 1), (3, 1, 6), (3, 2, 5), (3, 5, 2), (3, 6, 1), (4, 1, 5), (4, 
5, 1), (5, 1, 4), (5, 2, 3), (5, 3, 2), (5, 4, 1), (6, 1, 3), (6, 3, 1), (7, 1, 2), 
(7, 2, 1)]

ध्यान दें कि आदेश मायने रखता है - 1, 2, 7 को भी 2, 1, 7 और 7, 1, 2 के रूप में दिखाया गया है। आप एक सेट का उपयोग करके इसे कम कर सकते हैं।

Answer 25

पायथन 3.8 में, नए असाइनमेंट ऑपरेटर का उपयोग किया जा सकता है

>>> my_list = [1, 2, 3, 4, 5]
>>> itr = iter(my_list)
>>> a = next(itr)
>>> [(a + (a:=x))/2 for x in itr]
[1.5, 2.5, 3.5, 4.5]

aसूची में पिछले मान का एक रनिंग संदर्भ है , इसलिए इसे सूची के पहले तत्व से आरंभीकृत किया जाता है और पुनरावृति सूची के बाकी हिस्सों में होती है , aप्रत्येक पुनरावृत्ति में उपयोग किए जाने के बाद यह अद्यतन करता है।

एक स्पष्ट पुनरावृत्ति का उपयोग करके सूची की एक प्रति बनाने की आवश्यकता से बचने के लिए उपयोग किया जाता है my_list[1:]।

Answer 26

निम्नलिखित का प्रयास करें -

mylist = [1, 2, 3, 4]   

def add(mylist):
    total = 0
    for i in mylist:
        total += i
    return total

result = add(mylist)
print("sum = ", result)

Comments

एक नया उत्तर वास्तव में मौजूदा उत्तरों से अलग होना चाहिए। साथ ही, आपका sumफ़ंक्शन बिल्ट- sumइन व्यवहार या नाम से अलग नहीं है । आप वास्तव में अपने उत्तर से फ़ंक्शन की परिभाषा को हटा सकते हैं और यह अभी भी काम करेगा।

— नूमेनन

क्या आप अब जांच कर सकते हैं

— साईं जी

मैं सराहना करता हूं कि आप अपना उत्तर सुधार रहे हैं! चर नाम अधिक वर्णनात्मक हैं और बिल्ट-इन को छाया नहीं देते हैं। लेकिन मूलभूत समस्याएं अभी भी हैं: फॉर-लूप दृष्टिकोण पहले से ही stackoverflow.com/a/35359188/733092 द्वारा प्रदान किया गया था , और फ़ंक्शन अंतर्निहित के साथ बेमानी है sum। आपको प्रश्न का सही उत्तर देने के लिए एक परीक्षण पर ए मिलेगा, लेकिन स्टैकऑवरफ्लो उत्तर भी इस पृष्ठ पर पहुंचने वाले लोगों के लिए उपयोगी होना चाहिए , और डुप्लिकेट उत्तर नहीं हैं।

— नोमेनन जू