क्या यह जाँचने का एक पैथोनिक तरीका है कि कोई सूची पहले से ही क्रमबद्ध है ASCया नहींDESC
listtimestamps = [1, 2, 3, 5, 6, 7]isttimestamps.isSorted()रिटर्न Trueया ऐसा कुछ False।
मैं कुछ संदेशों के लिए टाइमस्टैम्प की एक सूची इनपुट करना चाहता हूं और जांचता हूं कि लेनदेन सही क्रम में दिखाई दिया या नहीं।
जवाबों:
वास्तव में हम जवाब नहीं दे रहे हैं कि अइजहाव की तलाश है। यहाँ एक लाइनर है:
all(l[i] <= l[i+1] for i in xrange(len(l)-1))पायथन 3 के लिए:
all(l[i] <= l[i+1] for i in range(len(l)-1))def isSorted(x, key = lambda x: x): return all([key(x[i]) <= key(x[i + 1]) for i in xrange(len(x) - 1)])
operator.leतेजी से लैम्ब्डा से होना चाहिए
l = [1, 2, 3, 4, 1, 6, 7, 8, 7] all(l[i] <= l[i+1] for i in xrange(len(l)-1)) परिणामTrue
xrangeअब और नहीं है, बस उपयोग करें range। मुझे लगता है NameError: name 'xrange' is not definedजब मैं उस कोड को चलाता हूं। मैंने इसे केवल उपयोग rangeकरने के लिए स्विच किया xrangeऔर यह ठीक काम करता है। देखें: stackoverflow.com/questions/15014310/…
मैं बस उपयोग करूंगा
if sorted(lst) == lst:
# code hereजब तक यह एक बहुत बड़ी सूची नहीं है कि किस मामले में आप एक कस्टम फ़ंक्शन बनाना चाहते हैं।
यदि आप इसे क्रमबद्ध करने जा रहे हैं, अगर यह क्रमबद्ध नहीं है, तो चेक को भूल जाएँ और इसे क्रमबद्ध करें।
lst.sort()और इसके बारे में बहुत ज्यादा मत सोचो।
यदि आप एक कस्टम फ़ंक्शन चाहते हैं, तो आप कुछ ऐसा कर सकते हैं
def is_sorted(lst, key=lambda x: x):
for i, el in enumerate(lst[1:]):
if key(el) < key(lst[i]): # i is the index of the previous element
return False
return Trueयह O (n) होगा यदि सूची पहले से ही (और O (n) forउस पर एक लूप में छंटनी की गई है!) तो, जब तक आप अपेक्षा नहीं करते हैं कि यह छंटनी नहीं होगी (और काफी यादृच्छिक) ज्यादातर समय, मैं करूंगा, फिर से, सूची को क्रमबद्ध करें।
पूर्णांक अनुक्रमणिका का उपयोग करने से यह इटोमर फॉर्म 10-15% तेज है:
# python2 only
if str is bytes:
from itertools import izip as zip
def is_sorted(l):
return all(a <= b for a, b in zip(l, l[1:]))izipऔर isliceitertools से यह तेजी से बनाने के लिए।
इसे लागू करने का एक सुंदर तरीका यह है कि imapफ़ंक्शन का उपयोग करें itertools:
from itertools import imap, tee
import operator
def is_sorted(iterable, compare=operator.le):
a, b = tee(iterable)
next(b, None)
return all(imap(compare, a, b))यह कार्यान्वयन तेज है और किसी भी पुनरावृत्तियों पर काम करता है।
is_sorted(iter([1,2,3,2,5,8]))या समकक्ष जनरेटर की कोशिश करो । आप के लिए एक स्वतंत्र iterator उपयोग करने की आवश्यकता tail, कोशिश itertools.tee।
iter(x) is xपुनरावृत्तियों के लिए
itertools.imapमें इसका नाम बदल दिया गया है [__builtins__.]map।
मैंने एक बेंचमार्क चलाया और । ये बेंचमार्क मैकबुक प्रो 2010 13 "(कोर 2 डुओ 2.66GHz, 4GB 1067MHz DDR3 रैम, मैक OS X 10.6.5) पर चलाए गए थे।sorted(lst, reverse=True) == lstलंबी सूचियों के all(l[i] >= l[i+1] for i in xrange(len(l)-1))लिए सबसे तेज़ था , और छोटी सूचियों के लिए सबसे तेज़ था
अद्यतन: मैंने स्क्रिप्ट को संशोधित किया ताकि आप इसे सीधे अपने सिस्टम पर चला सकें। पिछले संस्करण में बग थे। इसके अलावा, मैंने सॉर्ट किए गए और अनसर्टेड इनपुट्स दोनों को जोड़ा है।
all(l[i] >= l[i+1] for i in xrange(len(l)-1))sorted(l, reverse=True) == lall(l[i] >= l[i+1] for i in xrange(len(l)-1))all(l[i] >= l[i+1] for i in xrange(len(l)-1))तो ज्यादातर मामलों में एक स्पष्ट विजेता है।
अद्यतन: aaronsterling के उत्तर (# 6 और # 7) वास्तव में सभी मामलों में सबसे तेज हैं। # 7 सबसे तेज़ है क्योंकि इसमें कुंजी को देखने के लिए अप्रत्यक्ष की एक परत नहीं है।
#!/usr/bin/env python
import itertools
import time
def benchmark(f, *args):
t1 = time.time()
for i in xrange(1000000):
f(*args)
t2 = time.time()
return t2-t1
L1 = range(4, 0, -1)
L2 = range(100, 0, -1)
L3 = range(0, 4)
L4 = range(0, 100)
# 1.
def isNonIncreasing(l, key=lambda x,y: x >= y):
return all(key(l[i],l[i+1]) for i in xrange(len(l)-1))
print benchmark(isNonIncreasing, L1) # 2.47253704071
print benchmark(isNonIncreasing, L2) # 34.5398209095
print benchmark(isNonIncreasing, L3) # 2.1916718483
print benchmark(isNonIncreasing, L4) # 2.19576501846
# 2.
def isNonIncreasing(l):
return all(l[i] >= l[i+1] for i in xrange(len(l)-1))
print benchmark(isNonIncreasing, L1) # 1.86919999123
print benchmark(isNonIncreasing, L2) # 21.8603689671
print benchmark(isNonIncreasing, L3) # 1.95684289932
print benchmark(isNonIncreasing, L4) # 1.95272517204
# 3.
def isNonIncreasing(l, key=lambda x,y: x >= y):
return all(key(a,b) for (a,b) in itertools.izip(l[:-1],l[1:]))
print benchmark(isNonIncreasing, L1) # 2.65468883514
print benchmark(isNonIncreasing, L2) # 29.7504849434
print benchmark(isNonIncreasing, L3) # 2.78062295914
print benchmark(isNonIncreasing, L4) # 3.73436689377
# 4.
def isNonIncreasing(l):
return all(a >= b for (a,b) in itertools.izip(l[:-1],l[1:]))
print benchmark(isNonIncreasing, L1) # 2.06947803497
print benchmark(isNonIncreasing, L2) # 15.6351969242
print benchmark(isNonIncreasing, L3) # 2.45671010017
print benchmark(isNonIncreasing, L4) # 3.48461818695
# 5.
def isNonIncreasing(l):
return sorted(l, reverse=True) == l
print benchmark(isNonIncreasing, L1) # 2.01579380035
print benchmark(isNonIncreasing, L2) # 5.44593787193
print benchmark(isNonIncreasing, L3) # 2.01813793182
print benchmark(isNonIncreasing, L4) # 4.97615599632
# 6.
def isNonIncreasing(l, key=lambda x, y: x >= y):
for i, el in enumerate(l[1:]):
if key(el, l[i-1]):
return False
return True
print benchmark(isNonIncreasing, L1) # 1.06842684746
print benchmark(isNonIncreasing, L2) # 1.67291283607
print benchmark(isNonIncreasing, L3) # 1.39491200447
print benchmark(isNonIncreasing, L4) # 1.80557894707
# 7.
def isNonIncreasing(l):
for i, el in enumerate(l[1:]):
if el >= l[i-1]:
return False
return True
print benchmark(isNonIncreasing, L1) # 0.883186101913
print benchmark(isNonIncreasing, L2) # 1.42852401733
print benchmark(isNonIncreasing, L3) # 1.09229516983
print benchmark(isNonIncreasing, L4) # 1.59502696991enumerateगलत हैं। enumerate(l[1:])प्रतिस्थापित किया जाना चाहिएenumerate(l[1:], 1)
enumerate(l[1:])पर enumerate(l[1:], 1)आप l[i-1]द्वारा प्रतिस्थापित किया जा सकता है l[i]।
L5=range(100); random.shuffle(L5)तो # 5 तुलनात्मक रूप से धीमा है। इस मामले में संशोधित # 7 तेजी से समग्र codepad.org/xmWPxHQY है
मैं यह करूँगा (यहाँ बहुत सारे जवाबों से चोरी करना [ऐरॉन स्टर्लिंग, वाई यिप तुंग, पॉल मैकगायर से सॉर्टा] और ज्यादातर आर्मिन रोनचेर ):
from itertools import tee, izip
def pairwise(iterable):
a, b = tee(iterable)
next(b, None)
return izip(a, b)
def is_sorted(iterable, key=lambda a, b: a <= b):
return all(key(a, b) for a, b in pairwise(iterable))एक अच्छी बात: आपको श्रृंखला के लिए दूसरी पुनरावृत्ति का एहसास नहीं है (एक सूची स्लाइस के साथ)।
key। keyवस्तुओं को तुलनीय मूल्यों में बदलने के लिए उपयोग किया जाना चाहिए।
मैं इस एक-लाइनर का उपयोग numpy.diff () पर आधारित करता हूं:
def issorted(x):
"""Check if x is sorted"""
return (numpy.diff(x) >= 0).all() # is diff between all consecutive entries >= 0?मैंने वास्तव में इसे किसी अन्य विधि के खिलाफ नहीं बनाया है, लेकिन मुझे लगता है कि यह किसी भी शुद्ध पायथन विधि की तुलना में तेज़ है, विशेष रूप से बड़े एन के लिए, क्योंकि लूप क्रॉपी में है। -1 तुलना)।
हालांकि, आपको सावधान रहने की जरूरत है अगर x एक अहस्ताक्षरित इंट है, जो कि खामोश पूर्णांक को numpy.diff () में कारण हो सकता है, जिसके परिणामस्वरूप एक गलत सकारात्मक परिणाम होगा। यहाँ एक संशोधित संस्करण है:
def issorted(x):
"""Check if x is sorted"""
try:
if x.dtype.kind == 'u':
# x is unsigned int array, risk of int underflow in np.diff
x = numpy.int64(x)
except AttributeError:
pass # no dtype, not an array
return (numpy.diff(x) >= 0).all()यह शीर्ष उत्तर के समान है, लेकिन मुझे यह बेहतर लगता है क्योंकि यह स्पष्ट अनुक्रमण से बचता है। मान लें कि आपकी सूची में नाम है lst, तो आप
(item, next_item)अपनी सूची से tuples उत्पन्न कर सकते हैं zip:
all(x <= y for x,y in zip(lst, lst[1:]))पायथन 3 में, zipपहले से ही एक जनरेटर लौटाता है, पायथन 2 में आप itertools.izipबेहतर मेमोरी दक्षता के लिए उपयोग कर सकते हैं ।
छोटा डेमो:
>>> lst = [1, 2, 3, 4]
>>> zip(lst, lst[1:])
[(1, 2), (2, 3), (3, 4)]
>>> all(x <= y for x,y in zip(lst, lst[1:]))
True
>>>
>>> lst = [1, 2, 3, 2]
>>> zip(lst, lst[1:])
[(1, 2), (2, 3), (3, 2)]
>>> all(x <= y for x,y in zip(lst, lst[1:]))
Falseजब टपल (3, 2)का मूल्यांकन किया जाता है तो अंतिम वाला विफल हो जाता है।
बोनस: परिमित जाँच (!) जेनरेटर जिन्हें अनुक्रमित नहीं किया जा सकता है:
>>> def gen1():
... yield 1
... yield 2
... yield 3
... yield 4
...
>>> def gen2():
... yield 1
... yield 2
... yield 4
... yield 3
...
>>> g1_1 = gen1()
>>> g1_2 = gen1()
>>> next(g1_2)
1
>>> all(x <= y for x,y in zip(g1_1, g1_2))
True
>>>
>>> g2_1 = gen2()
>>> g2_2 = gen2()
>>> next(g2_2)
1
>>> all(x <= y for x,y in zip(g2_1, g2_2))
Falseitertools.izipयदि आप पायथन 2 का उपयोग कर रहे हैं, तो यहां उपयोग करना सुनिश्चित करें , अन्यथा आप जनरेटर से सूचियां नहीं बनाने के उद्देश्य को हरा देंगे।
isliceटुकड़ा करने की क्रिया के लिए अनुकूलित करने के लिए उपयोग कर सकते हैं । इटर्स्टूल मॉड्यूल में भी। all(x <= y for x, y in izip(lst, islice(lst, 1)))।
नीलमणि काफी सही है। आप बस उपयोग कर सकते हैं lst.sort()। यदि सूची पहले से ही सॉर्ट की गई है, तो पायथन का क्रमबद्ध कार्यान्वयन (टिमसर्ट) जांचता है। यदि ऐसा है (तो) रैखिक समय में पूरा हो जाएगा। एक सूची को हल करने के लिए पायथोनिक तरीके की तरह लगता है;)
हालांकि मुझे नहीं लगता कि इसके लिए कोई sortedकॉल-इन cmp फ़ंक्शन है i+1, i, लेकिन यह CPython के लिए ऐसा लगता है।
तो आप कुछ ऐसा कर सकते हैं:
def my_cmp(x, y):
cmpval = cmp(x, y)
if cmpval < 0:
raise ValueError
return cmpval
def is_sorted(lst):
try:
sorted(lst, cmp=my_cmp)
return True
except ValueError:
return False
print is_sorted([1,2,3,5,6,7])
print is_sorted([1,2,5,3,6,7])या इस तरह (अगर बयानों के बिना -> ईएएफपी गलत हो गया? ;-)):
def my_cmp(x, y):
assert(x >= y)
return -1
def is_sorted(lst):
try:
sorted(lst, cmp=my_cmp)
return True
except AssertionError:
return Falseबहुत पाइथोनिक नहीं है, लेकिन हमें कम से कम एक reduce()उत्तर की आवश्यकता है, है ना?
def is_sorted(iterable):
prev_or_inf = lambda prev, i: i if prev <= i else float('inf')
return reduce(prev_or_inf, iterable, float('-inf')) < float('inf')संचायक चर केवल पिछले-चेक किए गए मान को संग्रहीत करता है, और यदि कोई मान पिछले मान से छोटा है, तो संचायक अनंत पर सेट होता है (और इस तरह अब भी अंत में अनंत होगा, क्योंकि 'पिछला मान' हमेशा से बड़ा होगा वर्तमान एक)।
जैसा कि @aaronsterling द्वारा उल्लेख किया गया है, निम्न समाधान सबसे छोटा है और सबसे तेज़ लगता है जब सरणी को सॉर्ट किया जाता है और बहुत छोटा नहीं होता है: def is_sorted (lst): return (सॉर्टेड (lst) == lst)
यदि अधिकांश समय सरणी को सॉर्ट नहीं किया जाता है, तो ऐसे समाधान का उपयोग करना वांछनीय होगा जो संपूर्ण सरणी को स्कैन नहीं करता है और जैसे ही एक अनसुलझी उपसर्ग का पता चलता है, वैसे ही वह गलत हो जाता है। निम्नलिखित सबसे तेज़ समाधान है जो मुझे मिल सकता है, यह विशेष रूप से सुरुचिपूर्ण नहीं है:
def is_sorted(lst):
it = iter(lst)
try:
prev = it.next()
except StopIteration:
return True
for x in it:
if prev > x:
return False
prev = x
return Trueनाथन फ़ारिंगटन के बेंचमार्क का उपयोग करते हुए, यह बड़े सॉर्ट किए गए सूची पर चलने के अलावा सभी मामलों में सॉर्ट किए गए (lst) का उपयोग करने से बेहतर रनटाइम प्राप्त करता है।
यहाँ मेरे कंप्यूटर पर बेंचमार्क परिणाम हैं।
हल (lst) == lst घोल
दूसरा उपाय:
यदि आप सुन्न सरणियों के लिए सबसे तेज़ तरीका चाहते हैं , तो सुंबा का उपयोग करें , जो कि यदि आप कांड का उपयोग करते हैं तो पहले से ही स्थापित होना चाहिए
कोड तेजी से होगा क्योंकि यह सुंबा द्वारा संकलित किया जाएगा
import numba
@numba.jit
def issorted(vec, ascending=True):
if len(vec) < 2:
return True
if ascending:
for i in range(1, len(vec)):
if vec[i-1] > vec[i]:
return False
return True
else:
for i in range(1, len(vec)):
if vec[i-1] < vec[i]:
return False
return Trueऔर फिर:
>>> issorted(array([4,9,100]))
>>> Trueबस एक और तरीका जोड़ने के लिए (भले ही इसके लिए अतिरिक्त मॉड्यूल की आवश्यकता हो) iteration_utilities.all_monotone:
>>> from iteration_utilities import all_monotone
>>> listtimestamps = [1, 2, 3, 5, 6, 7]
>>> all_monotone(listtimestamps)
True
>>> all_monotone([1,2,1])
FalseDESC आदेश की जांच करने के लिए:
>>> all_monotone(listtimestamps, decreasing=True)
False
>>> all_monotone([3,2,1], decreasing=True)
Trueएक strictपैरामीटर भी है यदि आपको कड़ाई से जांच करने की आवश्यकता है (यदि क्रमिक तत्व समान नहीं होना चाहिए) मोनोटोनिक अनुक्रम।
यह आपके मामले में कोई समस्या नहीं है, लेकिन यदि आपके अनुक्रम में nanमूल्य हैं, तो कुछ विधियाँ विफल होंगी, उदाहरण के लिए छाँटे गए:
def is_sorted_using_sorted(iterable):
return sorted(iterable) == iterable
>>> is_sorted_using_sorted([3, float('nan'), 1]) # definetly False, right?
True
>>> all_monotone([3, float('nan'), 1])
Falseध्यान दें कि iteration_utilities.all_monotoneविशेष रूप से अनइंस्टॉल्ड इनपुट ( बेंचमार्क देखें ) के लिए यहां वर्णित अन्य समाधानों की तुलना में तेजी से प्रदर्शन करता है ।
from itertools import tee
def is_sorted(l):
l1, l2 = tee(l)
next(l2, None)
return all(a <= b for a, b in zip(l1, l2))all(a <= b for a, b in zip(l, l[1:]))
lएक जनरेटर है और स्लाइसिंग का समर्थन नहीं करता है।
पायथन 3.6.8
from more_itertools import pairwise
class AssertionHelper:
@classmethod
def is_ascending(cls, data: iter) -> bool:
for a, b in pairwise(data):
if a > b:
return False
return True
@classmethod
def is_descending(cls, data: iter) -> bool:
for a, b in pairwise(data):
if a < b:
return False
return True
@classmethod
def is_sorted(cls, data: iter) -> bool:
return cls.is_ascending(data) or cls.is_descending(data)>>> AssertionHelper.is_descending((1, 2, 3, 4))
False
>>> AssertionHelper.is_ascending((1, 2, 3, 4))
True
>>> AssertionHelper.is_sorted((1, 2, 3, 4))
True
from functools import reduce
# myiterable can be of any iterable type (including list)
isSorted = reduce(lambda r, e: (r[0] and (r[1] or r[2] <= e), False, e), myiterable, (True, True, None))[0]व्युत्पन्न कमी मूल्य एक 3-भाग टपल है ( सॉर्टेडसोफर्लग , फ़र्स्टटाइम फ़्लैग , लास्टफेलवैल्यू )। यह शुरू में साथ (शुरू होता है True, True, None) है, जो भी एक खाली सूची के लिए परिणाम के रूप में प्रयोग किया जाता है (माना के रूप में हल कर क्योंकि कोई बाहर के आदेश तत्व हैं)। चूंकि यह प्रत्येक तत्व को संसाधित करता है, यह टूपल के लिए नए मानों की गणना करता है (अगले तत्ववैल्यू के साथ पिछले टपल मूल्यों का उपयोग करके):
[0] (sortedSoFarFlag) evaluates true if: prev_0 is true and (prev_1 is true or prev_2 <= elementValue)
[1] (firstTimeFlag): False
[2] (lastElementValue): elementValueकटौती का अंतिम परिणाम निम्न है:
[0]: True/False depending on whether the entire list was in sorted order
[1]: True/False depending on whether the list was empty
[2]: the last element valueपहला मूल्य वह है जिसमें हम रुचि रखते हैं, इसलिए हम [0]इसे कम परिणाम से हड़पने के लिए उपयोग करते हैं।
जैसा कि मैंने ऊपर यह विकल्प नहीं देखा है, मैं इसे सभी उत्तरों में जोड़ दूंगा। इसके बाद सूची को निरूपित करें l:
import numpy as np
# Trasform the list to a numpy array
x = np.array(l)
# check if ascendent sorted:
all(x[:-1] <= x[1:])
# check if descendent sorted:
all(x[:-1] >= x[1:])असाइनमेंट एक्सप्रेशंस का उपयोग कर एक समाधान (पायथन 3.8 में जोड़ा गया):
def is_sorted(seq):
seq_iter = iter(seq)
cur = next(seq_iter, None)
return all((prev := cur) <= (cur := nxt) for nxt in seq_iter)
z = list(range(10))
print(z)
print(is_sorted(z))
import random
random.shuffle(z)
print(z)
print(is_sorted(z))
z = []
print(z)
print(is_sorted(z))देता है:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
True
[1, 7, 5, 9, 4, 0, 8, 3, 2, 6]
False
[]
Trueअगर यह सॉर्ट किया गया है तो सही प्रिंट करेगा या अन्य गलत होगा
def is_Sorted(lst):
if len(lst) == 1:
return True
return lst[0] <= lst[1] and is_Sorted(lst[1:])
any_list = [1,2,3,4]
print is_Sorted(any_list)RuntimeError: maximum recursion depth exceededलंबी सूची के लिए जुटाएगा । कोशिश करो any_list = range(1000)।
इसके बारे में क्या खयाल है ? सरल और सीधा।
def is_list_sorted(al):
llength =len(al)
for i in range (llength):
if (al[i-1] > al[i]):
print(al[i])
print(al[i+1])
print('Not sorted')
return -1
else :
print('sorted')
return trueनिश्चित रूप से पायथन 3 और उससे ऊपर के पूर्णांक या तारों के लिए काम करता है:
def tail(t):
return t[:]
letters = ['a', 'b', 'c', 'd', 'e']
rest = tail(letters)
rest.sort()
if letters == rest:
print ('Given list is SORTED.')
else:
print ('List NOT Sorted.')================================================== ===================
दी गई सूची को क्रमबद्ध किया गया है या नहीं, यह जानने का एक और तरीका है
trees1 = list ([1, 4, 5, 3, 2])
trees2 = list (trees1)
trees2.sort()
if trees1 == trees2:
print ('trees1 is SORTED')
else:
print ('Not sorted')
keyउपयोग करने के लिए एक फ़ंक्शन पास हो सके।key=lambda x, y: x < yएक अच्छा डिफ़ॉल्ट बनाता है।