అల్గోరిథం అనేది ఇన్పుట్ను కావలసిన అవుట్పుట్గా మార్చే పరిమిత, బాగా నిర్వచించిన దశల క్రమం. మేము దీనిని రెండు అక్షాలపై నిర్ణయిస్తాము: సరితనం (ఇది ఎల్లప్పుడు సరైన సమాధానాన్ని ఇస్తుందా?) మరియు సామర్థ్యం (ఇది ఎంత సమయం మరియు మెమరీని ఉపయోగిస్తుంది?).
వైధ్య అల్గోరిథం తప్పనిసరిగా అస్పష్టమైనది కాకుండా ఉండాలి (ప్రతి దశ స్పష్టంగా ఉంది), పరిమితమైనది (ఇది ముగుస్తుంది), మరియు ప్రతి సరైన ఇన్పుట్కు సరైన ఫలితాన్ని ఉత్పత్తి చేయాలి.
# Find the maximum value in a list
def find_max(nums):
if not nums:
return None # handle empty input
largest = nums[0] # assume first is the max
for n in nums[1:]: # scan the rest
if n > largest:
largest = n # update when we see something bigger
return largest
find_max([3, 9, 2, 7]) # -> 9
ఇది ప్రతి మూలకాన్ని ఒక్క సారి సందర్శిస్తుంది.
ఇదే సమస్య, వివిధ ఖర్చులు ఉన్న అనేక అల్గోరిథమ్లు. ఎల్లప్పుడు ఎడ్జ్ కేసులను తనిఖీ చేయండి (ఖాళీ ఇన్పుట్, ఒక్క మూలకం, నకులు) — అక్కడే సరితనం సాధారణంగా విచ్ఛిన్నమవుతుంది.
అల్గోరిథమ్లు సాఫ్टువేర్లో సమస్య పరిష్కారం యొక్క కేంద్రం.
రెండు ప్రోగ్రామ్లు ఒకే సమాధానం ఇవ్వగలవు, అయితే ఒకటి వేలు రెట్లు వేగవంతమైనది.
సరితనం మరియు సామర్థ్యం పరంగా ఆలోచించడం అనేది పరీక్ష కేసులో పనిచేసే కోడ్ను స్కేల్లో పనిచేసే కోడ్ నుండి వేరు చేసేది.
ఇది సాంకేతిక ఇంటర్వ్యూ మరియు సిస్టమ్ డిజైన్ చర్చల యొక్క సమర్థ ఐక్యభాష కూడా.