किसी सूची में मान मौजूद है या नहीं, यह जांचने का सबसे तेज़ तरीका

Question

यह जानने का सबसे तेज़ तरीका क्या है कि किसी सूची में मान मौजूद है (इसमें लाखों मानों वाली सूची) और इसका सूचकांक क्या है?

मुझे पता है कि सूची में सभी मूल्य इस उदाहरण में अद्वितीय हैं।

मेरे द्वारा आजमाया गया पहला तरीका (मेरे वास्तविक कोड में 3.8 सेकंड):

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

if a.count(7) == 1:
    b=a.index(7)
    "Do something with variable b"

दूसरा तरीका जो मैं आजमाता हूं (2x तेज़: 1.9 सेकंड मेरे असली कोड के लिए):

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

try:
    b=a.index(7)
except ValueError:
    "Do nothing"
else:
    "Do something with variable b"

स्टैक ओवरफ्लो उपयोगकर्ता से प्रस्तावित तरीके (मेरे वास्तविक कोड के लिए 2.74 सेकंड):

a = [4,2,3,1,5,6]
if 7 in a:
    a.index(7)

मेरे वास्तविक कोड में, पहली विधि में 3.81 सेकंड लगते हैं और दूसरी विधि में 1.88 सेकंड लगते हैं। यह एक अच्छा सुधार है, लेकिन:

मैं पायथन / स्क्रिप्टिंग के साथ शुरुआत कर रहा हूं, और क्या एक ही तरीके से काम करने और अधिक प्रसंस्करण समय बचाने का एक तेज़ तरीका है?

मेरे आवेदन के लिए अधिक विशिष्ट अन्वेषण:

ब्लेंडर एपीआई में मैं कणों की एक सूची का उपयोग कर सकता हूं:

particles = [1, 2, 3, 4, etc.]

वहाँ से, मैं एक कण के स्थान तक पहुँच सकता हूँ:

particles[x].location = [x,y,z]

और प्रत्येक कण के लिए मैं परीक्षण करता हूं कि यदि कोई पड़ोसी प्रत्येक कण स्थान को खोजकर मौजूद है जैसे:

if [x+1,y,z] in particles.location
    "Find the identity of this neighbour particle in x:the particle's index
    in the array"
    particles.index([x+1,y,z])

Comments

अजगर में वर्ग कोष्ठक की बात को एक सूची कहा जाता है, न कि एक सरणी। एक सूची का उपयोग करने के बजाय एक सेट का उपयोग करें। या अपनी सूची को क्रमबद्ध रखें और bisectमॉड्यूल का उपयोग करें

— स्टीवन रूंबल्स्की

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

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

— रोमन बोडनार्चुक

मैं अपने प्रश्न को संपादित करता हूं और अधिक स्पष्ट रूप से समझाने की कोशिश करता हूं कि मैं क्या करना चाहता हूं ... मुझे आशा है कि ...

— जीन-फ्रेंकोइस गैलेंट

@StevenRumbalski: क्योंकि सेट में डुप्लीकेशन सामग्री नहीं हो सकती है, जबकि जीन कणों के स्थान को स्टोर करना चाहता है (x, y, z समान हो सकता है), हम इस मामले में सेट का उपयोग नहीं कर सकते

— Hieu Vo

Answer 1

7 in a

इसे करने का सबसे साफ़ और तेज़ तरीका।

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

Comments

लेकिन आपके पास अनुक्रमणिका नहीं है, और इसे प्राप्त करने से आपकी लागत बच जाएगी।

— कृपालु

जैसे: यदि 7 में a: b = a.index (7)?

— जीन-फ्रेंकोइस गैलेंट

@StevenRumbalski: सेट केवल एक विकल्प है यदि आपको इसे ऑर्डर करने की आवश्यकता नहीं है (और इसलिए, एक सूचकांक है)। और सेट कर रहे हैं स्पष्ट रूप से उल्लेख जवाब में, यह सिर्फ भी प्रश्न का सीधा जवाब के रूप में ओपी यह पूछा देता है। मुझे नहीं लगता कि यह मूल्य -1 है।

मैं अपने प्रश्न को संपादित करता हूं और अधिक स्पष्ट रूप से समझाने की कोशिश करता हूं कि मैं क्या करना चाहता हूं ... मुझे आशा है ...

— जीन-फ्रैंकोइस गैलेंट

ठीक है, मैं अपने वास्तविक कोड में आपकी विधि की कोशिश करता हूं और शायद थोड़ा अधिक समय लगता है क्योंकि मुझे मूल्य के सूचकांक को जानने की आवश्यकता है। अपनी दूसरी विधि के साथ, मैं जांचता हूं कि क्या यह मौजूद है और एक ही समय में सूचकांक प्राप्त करता है।

— जीन-फ्रेंकोइस गैलेंट

Answer 2

जैसा कि दूसरों द्वारा कहा गया है, inबड़ी सूचियों के लिए बहुत धीमा हो सकता है। यहाँ कुछ प्रदर्शनों की तुलना है in, setऔर bisect। समय पर ध्यान दें (दूसरे में) लॉग स्केल में है।

परीक्षण के लिए कोड:

import random
import bisect
import matplotlib.pyplot as plt
import math
import time

def method_in(a,b,c):
    start_time = time.time()
    for i,x in enumerate(a):
        if x in b:
            c[i] = 1
    return(time.time()-start_time)   

def method_set_in(a,b,c):
    start_time = time.time()
    s = set(b)
    for i,x in enumerate(a):
        if x in s:
            c[i] = 1
    return(time.time()-start_time)

def method_bisect(a,b,c):
    start_time = time.time()
    b.sort()
    for i,x in enumerate(a):
        index = bisect.bisect_left(b,x)
        if index < len(a):
            if x == b[index]:
                c[i] = 1
    return(time.time()-start_time)

def profile():
    time_method_in = []
    time_method_set_in = []
    time_method_bisect = []

    Nls = [x for x in range(1000,20000,1000)]
    for N in Nls:
        a = [x for x in range(0,N)]
        random.shuffle(a)
        b = [x for x in range(0,N)]
        random.shuffle(b)
        c = [0 for x in range(0,N)]

        time_method_in.append(math.log(method_in(a,b,c)))
        time_method_set_in.append(math.log(method_set_in(a,b,c)))
        time_method_bisect.append(math.log(method_bisect(a,b,c)))

    plt.plot(Nls,time_method_in,marker='o',color='r',linestyle='-',label='in')
    plt.plot(Nls,time_method_set_in,marker='o',color='b',linestyle='-',label='set')
    plt.plot(Nls,time_method_bisect,marker='o',color='g',linestyle='-',label='bisect')
    plt.xlabel('list size', fontsize=18)
    plt.ylabel('log(time)', fontsize=18)
    plt.legend(loc = 'upper left')
    plt.show()

Comments

लव कट-एंड-पेस्ट, निष्पादन योग्य कोड जैसे उत्तर में। दूसरों को कुछ सेकंड बचाने के लिए, आपको 3 आयातों की आवश्यकता होगी: import random / import bisect / import matplotlib.pyplot as pltऔर फिर कॉल करें:profile()

— kghastie

अजगर का कौन सा संस्करण है?

— काऊबर्ट

हमेशा कोड प्राप्त करने के लिए बहुत अच्छा है, लेकिन अभी मुझे सिर चलाने के लिए समय आयात करना है

— whla

और विनम्र range()वस्तु को मत भूलना । उपयोग करते समय var in [integer list], देखें कि क्या कोई range()वस्तु उसी क्रम को मॉडल कर सकती है। एक सेट के प्रदर्शन में बहुत करीब है, लेकिन अधिक संक्षिप्त।

— मार्टिन पीटर्स

Answer 3

आप अपने आइटम को एक में डाल सकते हैं set। सेट लुकअप बहुत कुशल हैं।

प्रयत्न:

s = set(a)
if 7 in s:
  # do stuff

संपादित करें एक टिप्पणी में आप कहते हैं कि आप तत्व का सूचकांक प्राप्त करना चाहते हैं। दुर्भाग्य से, सेट में तत्व स्थिति की कोई धारणा नहीं है। एक विकल्प अपनी सूची को पूर्व-सॉर्ट करना है और फिर हर बार आपको किसी तत्व को खोजने के लिए द्विआधारी खोज का उपयोग करना है।

Comments

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

— जीन-फ्रेंकोइस गैलेंट

@ जीन-फ्रेंकोइसग्लेंट: इस मामले में सेट का ज्यादा इस्तेमाल नहीं होगा। आप सूची को पूर्व-क्रमबद्ध कर सकते हैं और फिर बाइनरी खोज का उपयोग कर सकते हैं। कृपया मेरा अद्यतन उत्तर देखें।

— NPE

मैं अपने प्रश्न को संपादित करता हूं और अधिक स्पष्ट रूप से समझाने की कोशिश करता हूं कि मैं क्या करना चाहता हूं ... मुझे आशा है कि ...

— जीन-फ्रेंकोइस गैलेंट

Answer 4

def check_availability(element, collection: iter):
    return element in collection

प्रयोग

check_availability('a', [1,2,3,4,'a','b','c'])

मेरा मानना ​​है कि यह जानना सबसे तेज़ तरीका है कि किसी चुने हुए मूल्य को किसी सरणी में रखा गया है या नहीं।

Comments

return 'a' in a?

— Shikiryu

आपको कोड को एक परिभाषा में रखना होगा: def listValue (): a = [1,2,3,4, 'a', 'b', 'c'] 'a' को ax = listValue () प्रिंट करें ( x)

— तेनजिन

यह एक मान्य पायथन उत्तर है यह सिर्फ अच्छा नहीं है, पठनीय कोड है।

— रिक हेंडरसन

खबरदार! यह मेल खाता है, जबकि यह संभवतः वह है o='--skip'; o in ("--skip-ias"); # returns True !

— एलेक्स एफ

@Alex F inऑपरेटर सब्स्क्राइब सदस्यता का परीक्षण करने के लिए उसी तरह काम करता है। यहां भ्रमित करने वाला हिस्सा संभवतः ("hello")एक एकल-मूल्य टपल नहीं है, जबकि ("hello",)है - अल्पविराम से फर्क पड़ता है। o in ("--skip-ias",)है Falseके रूप में उम्मीद।

— मोक्सीबेल

Answer 5

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

index = dict((y,x) for x,y in enumerate(a))
try:
   a_index = index[7]
except KeyError:
   print "Not found"
else:
   print "found"

यह केवल एक अच्छा विचार होगा यदि कोई परिवर्तन नहीं करता है और इस प्रकार हम एक बार तानाशाही () भाग कर सकते हैं और फिर इसे बार-बार उपयोग कर सकते हैं। यदि कोई परिवर्तन करता है, तो कृपया जो आप कर रहे हैं उस पर अधिक विवरण प्रदान करें।

Comments

यह मेरे कोड में लागू होने पर नहीं बल्कि काम कर रहा है: "टाइपरोर: अस्वास्थ्यकर प्रकार: 'सूची'

— जीन-फ्रेंकोइस गैलेंट

@ जीन-फ्रेंकोइसग्लैंट, शायद ऐसा इसलिए है क्योंकि आप उन सूचियों का उपयोग कर रहे हैं जहां आपको वास्तव में ट्यूपल्स का उपयोग करना चाहिए। यदि आप अपने कोड को तेज करने के बारे में व्यापक सलाह चाहते हैं, तो आपको इसे codereview.stackexchange.com पर पोस्ट करना चाहिए। आपको स्टाइल और प्रदर्शन सलाह मिलेगी।

— विंस्टन एवर्ट

यह समस्या का एक बहुत ही चतुर समाधान है। निर्माण को छोड़कर प्रयास के बजाय, मैं करूंगा: a_index = index.get (7) जो कुंजी नहीं मिलने पर किसी को भी डिफ़ॉल्ट कर देगा।

— मूरफ्स 1

Answer 6

मूल प्रश्न था:

यह जानने का सबसे तेज़ तरीका क्या है कि किसी सूची में मान मौजूद है (इसमें लाखों मानों वाली सूची) और इसका सूचकांक क्या है?

इस प्रकार दो चीजें हैं:

1. सूची में एक आइटम है, और
2. सूचकांक क्या है (यदि सूची में है)।

इसकी ओर, मैंने सभी मामलों में अनुक्रमित की गणना करने के लिए @xslittlegrass कोड को संशोधित किया, और एक अतिरिक्त विधि जोड़ी।

परिणाम

तरीके हैं:

1. में - मूल रूप से अगर x में b: रिटर्न b.index (x)
2. प्रयास करें - b.index (x) पर प्रयास करें / पकड़ें (यदि x में ख की जाँच करने के लिए स्किप हो)
3. सेट - मूल रूप से अगर x सेट में (b): रिटर्न b.index (x)
4. bisect - इसके सूचकांक के साथ b छँटाई, छँटाई में x के लिए द्विआधारी खोज (b)। @Xslittlegrass से mod पर ध्यान दें, जो अनुक्रमित b के बजाय मूल b के बजाय इंडेक्स देता है)
5. रिवर्स - बी के लिए एक रिवर्स लुकअप शब्दकोश डी; तब d [x] x का सूचकांक प्रदान करता है।

परिणाम बताते हैं कि विधि 5 सबसे तेज है।

दिलचस्प है कि कोशिश और निर्धारित तरीके समय के बराबर हैं।

---

टेस्ट कोड

import random
import bisect
import matplotlib.pyplot as plt
import math
import timeit
import itertools

def wrapper(func, *args, **kwargs):
    " Use to produced 0 argument function for call it"
    # Reference https://www.pythoncentral.io/time-a-python-function/
    def wrapped():
        return func(*args, **kwargs)
    return wrapped

def method_in(a,b,c):
    for i,x in enumerate(a):
        if x in b:
            c[i] = b.index(x)
        else:
            c[i] = -1
    return c

def method_try(a,b,c):
    for i, x in enumerate(a):
        try:
            c[i] = b.index(x)
        except ValueError:
            c[i] = -1

def method_set_in(a,b,c):
    s = set(b)
    for i,x in enumerate(a):
        if x in s:
            c[i] = b.index(x)
        else:
            c[i] = -1
    return c

def method_bisect(a,b,c):
    " Finds indexes using bisection "

    # Create a sorted b with its index
    bsorted = sorted([(x, i) for i, x in enumerate(b)], key = lambda t: t[0])

    for i,x in enumerate(a):
        index = bisect.bisect_left(bsorted,(x, ))
        c[i] = -1
        if index < len(a):
            if x == bsorted[index][0]:
                c[i] = bsorted[index][1]  # index in the b array

    return c

def method_reverse_lookup(a, b, c):
    reverse_lookup = {x:i for i, x in enumerate(b)}
    for i, x in enumerate(a):
        c[i] = reverse_lookup.get(x, -1)
    return c

def profile():
    Nls = [x for x in range(1000,20000,1000)]
    number_iterations = 10
    methods = [method_in, method_try, method_set_in, method_bisect, method_reverse_lookup]
    time_methods = [[] for _ in range(len(methods))]

    for N in Nls:
        a = [x for x in range(0,N)]
        random.shuffle(a)
        b = [x for x in range(0,N)]
        random.shuffle(b)
        c = [0 for x in range(0,N)]

        for i, func in enumerate(methods):
            wrapped = wrapper(func, a, b, c)
            time_methods[i].append(math.log(timeit.timeit(wrapped, number=number_iterations)))

    markers = itertools.cycle(('o', '+', '.', '>', '2'))
    colors = itertools.cycle(('r', 'b', 'g', 'y', 'c'))
    labels = itertools.cycle(('in', 'try', 'set', 'bisect', 'reverse'))

    for i in range(len(time_methods)):
        plt.plot(Nls,time_methods[i],marker = next(markers),color=next(colors),linestyle='-',label=next(labels))

    plt.xlabel('list size', fontsize=18)
    plt.ylabel('log(time)', fontsize=18)
    plt.legend(loc = 'upper left')
    plt.show()

profile()

Comments

अपने विवरण में टाइपो ("रिवर्स लूप अप" "रिवर्स लुकअप," नहीं?) होना चाहिए

— कैम यू

@ कैमू - हां, इसे सही किया। ध्यान देने के लिए धन्यवाद।

— 19

Answer 7

ऐसा लगता है कि आपके एप्लिकेशन को ब्लूम फ़िल्टर डेटा संरचना के उपयोग से लाभ मिल सकता है।

संक्षेप में, एक ब्लूम फ़िल्टर लुक-अप आपको बहुत तेज़ी से बता सकता है यदि मूल्य एक सेट में मौजूद नहीं है। अन्यथा, आप सूची में POSSIBLY MIGHT BE के मान का सूचकांक प्राप्त करने के लिए एक धीमा लुक-अप कर सकते हैं। इसलिए यदि आपका आवेदन "नहीं मिला" परिणाम को अधिक बार प्राप्त करता है, तो "पाया गया" परिणाम, आप एक ब्लूम फ़िल्टर जोड़कर गति देख सकते हैं।

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

Answer 8

ध्यान दें कि inऑपरेटर परीक्षण न केवल समानता ( ==) लेकिन यह भी पहचान ( is), inके लिए तर्क listरों है मोटे तौर पर के बराबर निम्नलिखित (यह वास्तव में सी पायथन में और नहीं है, हालांकि लिखा है, कम से कम CPython में):

for element in s:
    if element is target:
        # fast check for identity implies equality
        return True
    if element == target:
        # slower check for actual equality
        return True
return False

ज्यादातर परिस्थितियों में यह विवरण अप्रासंगिक है, लेकिन कुछ परिस्थितियों में यह एक अजगर नौसिखिया को आश्चर्यचकित कर सकता है, उदाहरण के लिए, खुद के बराबर नहीं होनेnumpy.NAN की असामान्य संपत्ति है :

>>> import numpy
>>> numpy.NAN == numpy.NAN
False
>>> numpy.NAN is numpy.NAN
True
>>> numpy.NAN in [numpy.NAN]
True

इन असामान्य मामलों के बीच अंतर करने के लिए जिनका आप उपयोग कर सकते हैं any():

>>> lst = [numpy.NAN, 1 , 2]
>>> any(element == numpy.NAN for element in lst)
False
>>> any(element is numpy.NAN for element in lst)
True 

नोट inके लिए तर्क listके साथ any()होगा:

any(element is target or element == target for element in lst)

हालांकि, मुझे इस बात पर जोर देना चाहिए कि यह एक किनारे का मामला है, और अधिकांश मामलों के लिए inऑपरेटर अत्यधिक अनुकूलित है और वास्तव में आप क्या चाहते हैं (या तो एक के listसाथ set)।

Comments

नान == झूठे झूठे के बारे में कुछ भी असामान्य नहीं है। यह IEEE 754 मानक में परिभाषित व्यवहार है।

— टॉमी

Answer 9

या उपयोग करें __contains__:

sequence.__contains__(value)

डेमो:

>>> l=[1,2,3]
>>> l.__contains__(3)
True
>>> 

Answer 10

@ आइंस्टीन इवर्ट का समाधान बहुत बड़ी सूचियों के लिए एक बड़ी गति देता है, लेकिन यह स्टैकओवरफ्लो उत्तर बताता है कि कोशिश: / को छोड़कर: / अन्यथा: निर्माण को धीमा कर दिया जाएगा यदि अपवाद शाखा अक्सर पहुंच जाती है। एक विकल्प .get()तानाशाह के लिए विधि का लाभ उठाना है :

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

index = dict((y, x) for x, y in enumerate(a))

b = index.get(7, None)
if b is not None:
    "Do something with variable b"

.get(key, default)विधि सिर्फ मामला है जब आप गारंटी नहीं दे सकते एक महत्वपूर्ण dict में हो जाएगा के लिए है। यदि कुंजी है वर्तमान में, यह (के रूप में मान देता है dict[key]), लेकिन जब यह नहीं है, .get()अपने डिफ़ॉल्ट मान (यहाँ रिटर्न None)। आपको इस मामले में यह सुनिश्चित करने की आवश्यकता है कि चुना हुआ डिफ़ॉल्ट अंदर नहीं होगा a।

Answer 11

यह कोड नहीं है, लेकिन बहुत तेजी से खोज के लिए एल्गोरिथ्म है।

यदि आपकी सूची और आप जिस मूल्य की तलाश कर रहे हैं, वह सभी संख्याएँ हैं, तो यह बहुत सीधा है। यदि तार: नीचे देखें:

• -Let "n" अपनी सूची की लंबाई हो
• - वैकल्पिक चरण: यदि आपको तत्व के सूचकांक की आवश्यकता है: तत्वों के वर्तमान सूचकांक (0 से n-1) के साथ सूची में एक दूसरा कॉलम जोड़ें - बाद में देखें
• अपनी सूची या उसकी एक प्रति (.sort) का आदेश दें
• फन्दा बनाना:
  • सूची के n / 2th तत्व के लिए अपनी संख्या की तुलना करें
    • यदि बड़ा है, तो अनुक्रमित n / 2-n के बीच फिर से लूप करें
    • यदि छोटा है, तो इंडेक्स 0-एन / 2 के बीच फिर से लूप करें
    • अगर वही: आपको मिल गया
• सूची को तब तक संकुचित करते रहें, जब तक कि आप उसे न पा लें या केवल 2 संख्याएँ हों (आप जिसे खोज रहे हैं, उसके नीचे और ऊपर)
• यह 1.000.000 की सूची के लिए सबसे अधिक 19 चरणों में किसी भी तत्व को मिलेगा (लॉग (2) n सटीक होने के लिए)

यदि आपको अपने नंबर की मूल स्थिति की भी आवश्यकता है, तो इसे दूसरे, इंडेक्स कॉलम में देखें।

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

बेशक, इसके लिए छंटनी () विधि के निवेश की आवश्यकता है, लेकिन यदि आप जांच के लिए उसी सूची का पुन: उपयोग करते रहते हैं, तो यह इसके लायक हो सकता है।

Comments

आप यह उल्लेख करना भूल गए कि आपके द्वारा समझाया गया एल्गोरिथ्म एक सरल बाइनरी खोज है।

— diugalde

Answer 12

क्योंकि प्रश्न को हमेशा सबसे तेज़ तकनीकी तरीके के रूप में नहीं समझा जाता है - मैं हमेशा समझने / लिखने के लिए सबसे सरल सबसे तेज़ तरीका सुझाता हूँ: सूची बोध, वन-लाइनर

[i for i in list_from_which_to_search if i in list_to_search_in]

मेरे पास list_to_search_inसभी वस्तुओं के साथ था , और वस्तुओं के अनुक्रमित को वापस करना चाहता था list_from_which_to_search।

यह एक अच्छी सूची में अनुक्रमित देता है।

इस समस्या की जाँच करने के अन्य तरीके हैं - हालाँकि सूची की समझ काफी तेज़ है, किसी समस्या को हल करने के लिए इसे जल्दी से लिखने के तथ्य को जोड़ना।

Answer 13

मेरे लिए यह 0.030 सेकंड (वास्तविक), 0.026 सेकंड (उपयोगकर्ता), और 0.004 सेकंड (sys) था।

try:
print("Started")
x = ["a", "b", "c", "d", "e", "f"]

i = 0

while i < len(x):
    i += 1
    if x[i] == "e":
        print("Found")
except IndexError:
    pass

Answer 14

यह जाँचने के लिए कि क्या दो तत्व सरणी में मौजूद हैं जिनके उत्पाद के बराबर हैं:

n = len(arr1)
for i in arr1:
    if k%i==0:
        print(i)