బిగ్- O సంజ్ఞామానం అంటే ఏమిటి?

మీరు వ్రాసిన ప్రోగ్రామ్ అమలు చేయడానికి ఎందుకు ఎక్కువ సమయం పట్టిందని మీరు ఎప్పుడైనా ఆలోచిస్తున్నారా? మీరు మీ కోడ్‌ని మరింత సమర్థవంతంగా చేయగలరో లేదో తెలుసుకోవాలనుకోవచ్చు. కోడ్ ఎలా నడుస్తుందో అర్థం చేసుకోవడం మీ కోడ్‌ను తదుపరి స్థాయికి తీసుకురాగలదు. బిగ్- O సంజ్ఞామానం అనేది మీ కోడ్ నిజంగా ఎంత సమర్థవంతంగా పనిచేస్తుందో లెక్కించడానికి సులభమైన సాధనం.

బిగ్- O సంజ్ఞామానం అంటే ఏమిటి?

మీ కోడ్‌ను అమలు చేయడానికి ఎంత సమయం పడుతుందో లెక్కించడానికి బిగ్-ఓ సంజ్ఞామానం మీకు ఒక మార్గాన్ని అందిస్తుంది. మీ కోడ్ అమలు చేయడానికి ఎంత సమయం పడుతుందో మీరు భౌతికంగా టైమ్ చేయవచ్చు, కానీ ఆ పద్ధతిలో, చిన్న సమయ వ్యత్యాసాలను గుర్తించడం కష్టం. ఉదాహరణకు, కోడ్ యొక్క 20 మరియు 50 లైన్ల మధ్య నడుస్తున్న సమయం చాలా తక్కువ. అయితే, ఒక పెద్ద ప్రోగ్రామ్‌లో, ఆ అసమర్థతలు జోడించబడతాయి.

కోరిందకాయ పై 3 బి వర్సెస్ బి+

బిగ్- O సంజ్ఞామానం అల్గోరిథం దాని సామర్థ్యాన్ని అంచనా వేయడానికి ఎన్ని దశలను అమలు చేయాలో లెక్కిస్తుంది. సామర్థ్యాన్ని పెంచడానికి మీరు మీ కోడ్‌ని ట్యూన్ చేయాల్సి వస్తే మీ కోడ్‌ని ఈ విధంగా చేరుకోవడం చాలా ప్రభావవంతంగా ఉంటుంది. బిగ్- O సంజ్ఞామానం అమలు చేయడానికి అవసరమైన దశల సంఖ్యతో విభిన్న అల్గారిథమ్‌లను కొలవడానికి మరియు అల్గోరిథంల సామర్థ్యాన్ని నిష్పాక్షికంగా సరిపోల్చడానికి మిమ్మల్ని అనుమతిస్తుంది.

మీరు బిగ్-ఓ నొటేషన్‌ను ఎలా లెక్కిస్తారు

డ్రాయర్‌లో ఎన్ని వ్యక్తిగత సాక్స్‌లు ఉన్నాయో లెక్కించే రెండు ఫంక్షన్లను పరిశీలిద్దాం. ప్రతి ఫంక్షన్ జత సాక్స్‌ల సంఖ్యను తీసుకుంటుంది మరియు వ్యక్తిగత సాక్స్‌ల సంఖ్యను అందిస్తుంది. కోడ్ పైథాన్‌లో వ్రాయబడింది, కానీ మేము దశల సంఖ్యను ఎలా లెక్కించాలో అది ప్రభావితం చేయదు.

అల్గోరిథం 1:

def sockCounter(numberOfPairs):  
 individualSocks = 0  
 for x in range(numberOfPairs):  
 individualSocks = individualSocks + 2  
 return individualSocks

అల్గోరిథం 2:

def sockCounter(numberOfPairs):  
 return numberOfPairs * 2

ఇది ఒక వెర్రి ఉదాహరణ, మరియు ఏ అల్గోరిథం మరింత సమర్థవంతంగా ఉందో మీరు సులభంగా చెప్పగలరు. కానీ అభ్యాసం కోసం, ప్రతి ద్వారా అమలు చేద్దాం.

సంబంధిత: ప్రోగ్రామింగ్‌లో ఫంక్షన్ అంటే ఏమిటి?

అల్గోరిథం 1 లో అనేక దశలు ఉన్నాయి:

ఇది వేరియబుల్ వ్యక్తిగత సాక్స్‌లకు సున్నా విలువను కేటాయిస్తుంది.
ఇది వేరియబుల్ i కి ఒక విలువను కేటాయిస్తుంది.
ఇది i యొక్క విలువను నంబర్‌ఫేర్‌లతో పోల్చింది.
ఇది వ్యక్తిగత సాక్స్‌లకు రెండింటిని జోడిస్తుంది.
ఇది వ్యక్తిగత సాక్స్ యొక్క పెరిగిన విలువను దానికే కేటాయిస్తుంది.
ఇది నేను ఒకటి పెంచుతుంది.
ఇది 3 నుండి 6 దశల ద్వారా తిరిగి అదే సంఖ్యలో (ఇండివిజువల్ సాక్స్ - 1) తిరుగుతుంది.

అల్గోరిథం కోసం మనం పూర్తి చేయాల్సిన దశల సంఖ్య ఇలా వ్యక్తీకరించబడుతుంది:

4n + 2

మేము n సార్లు పూర్తి చేయాల్సిన నాలుగు దశలు ఉన్నాయి. ఈ సందర్భంలో, n నంబర్‌ఓఫ్‌పెయిర్‌ల విలువకు సమానం. ఒకసారి పూర్తి చేసిన 2 దశలు కూడా ఉన్నాయి.

పోల్చి చూస్తే, అల్గోరిథం 2 కేవలం ఒక దశను కలిగి ఉంది. నంబర్‌ఆఫ్‌పెయిర్‌ల విలువ రెండుతో గుణించబడుతుంది. మేము దీనిని ఇలా వ్యక్తపరుస్తాము:

1

ఇది ఇప్పటికే స్పష్టంగా లేనట్లయితే, అల్గోరిథం 2 మరింత సమర్థవంతంగా పనిచేస్తుందని మనం ఇప్పుడు సులభంగా చూడవచ్చు.

బిగ్-ఓ విశ్లేషణ

సాధారణంగా, మీరు అల్గోరిథం యొక్క బిగ్-ఓ సంజ్ఞామానంపై ఆసక్తి కలిగి ఉన్నప్పుడు, మీరు మొత్తం సామర్థ్యంపై ఎక్కువ ఆసక్తి కలిగి ఉంటారు మరియు దశల సంఖ్య యొక్క చక్కటి ధాన్యం విశ్లేషణలో తక్కువగా ఉంటారు. సంజ్ఞామానం సరళీకృతం చేయడానికి, మనం సామర్థ్యం యొక్క పరిమాణాన్ని పేర్కొనవచ్చు.

పై ఉదాహరణలలో, అల్గోరిథం 2 ఒకటిగా వ్యక్తీకరించబడుతుంది:

O(1)

కానీ అల్గోరిథం 1 సరళీకరించబడుతుంది:

O(n)

ఈ శీఘ్ర స్నాప్‌షాట్ అల్గోరిథం యొక్క సామర్థ్యం n విలువతో ఎలా ముడిపడి ఉందో తెలియజేస్తుంది. పెద్ద సంఖ్య ఎక్కువ దశలను అల్గోరిథం పూర్తి చేయాలి.

లీనియర్ కోడ్

చిత్ర క్రెడిట్: నిక్ ఫ్లెడెరస్/ నామవాచకం ప్రాజెక్ట్

మనకు n విలువ తెలియదు కాబట్టి, n విలువ అమలు చేయడానికి అవసరమైన కోడ్ మొత్తాన్ని ఎలా ప్రభావితం చేస్తుందో ఆలోచించడం మరింత ఉపయోగకరంగా ఉంటుంది. అల్గోరిథం 1 లో సంబంధం సరళంగా ఉందని మనం చెప్పగలం. మీరు దశల సంఖ్య వర్సెస్ వర్సెస్ n విలువను ప్లాన్ చేస్తే, మీరు పైకి వెళ్లే సరళ రేఖను పొందుతారు.

క్వాడ్రాటిక్ కోడ్

అన్ని సంబంధాలు సరళ ఉదాహరణ వలె సులభం కాదు. మీరు 2D శ్రేణిని కలిగి ఉన్నారని ఊహించండి మరియు మీరు శ్రేణిలో విలువ కోసం శోధించాలనుకుంటున్నారు. మీరు ఇలాంటి అల్గోరిథం సృష్టించవచ్చు:

def searchForValue(targetValue, arraySearched):  
 foundTarget = False  
 for x in arraySearched:  
 for y in x:  
 if(y == targetValue):  
 foundTarget = True  
 return foundTarget

ఈ ఉదాహరణలో, దశల సంఖ్య శ్రేణి శోధనలోని శ్రేణుల సంఖ్య మరియు ప్రతి శ్రేణిలోని విలువల సంఖ్యపై ఆధారపడి ఉంటుంది. కాబట్టి, సరళీకృత దశల సంఖ్య n * n లేదా n² అవుతుంది.

నా బాహ్య హార్డ్ డ్రైవ్ ఎందుకు కనిపించడం లేదు

చిత్ర క్రెడిట్: నిక్ ఫ్లెడెరస్/ నామవాచకం ప్రాజెక్ట్

ఈ సంబంధం ఒక చతుర్ముఖ సంబంధం, అంటే మా అల్గోరిథంలో దశల సంఖ్య n తో విపరీతంగా పెరుగుతుంది. Big-O సంజ్ఞామానం లో, మీరు దీనిని ఇలా వ్రాస్తారు:

O(n²)

సంబంధిత: CSS ఫైల్‌లను తనిఖీ చేయడానికి, శుభ్రపరచడానికి మరియు ఆప్టిమైజ్ చేయడానికి ఉపయోగకరమైన సాధనాలు

లోగరిథమిక్ కోడ్

అనేక ఇతర సంబంధాలు ఉన్నప్పటికీ, మనం చూసే చివరి సంబంధం లాగరిథమిక్ సంబంధాలు. మీ మెమరీని రిఫ్రెష్ చేయడానికి, సంఖ్య యొక్క లాగ్ అనేది బేస్ ఇచ్చిన సంఖ్యను చేరుకోవడానికి అవసరమైన ఘాతాంక విలువ. ఉదాహరణకి:

log 2 (8) = 3

లాగ్ మూడుకి సమానం ఎందుకంటే మా బేస్ 2 అయితే, 8 వ సంఖ్యకు చేరుకోవడానికి మనకు 3 యొక్క ఘాతాంక విలువ అవసరం.

చిత్ర క్రెడిట్: నిక్ ఫ్లెడెరస్/ నామవాచకం ప్రాజెక్ట్

కాబట్టి, లాగరిథమిక్ ఫంక్షన్ యొక్క సంబంధం ఘాతాంక సంబంధానికి వ్యతిరేకం. N పెరుగుతున్న కొద్దీ, అల్గోరిథం అమలు చేయడానికి తక్కువ కొత్త దశలు అవసరం.

మొదటి చూపులో, ఇది ప్రతికూలంగా అనిపిస్తుంది. అల్గోరిథం దశలు n కంటే నెమ్మదిగా ఎలా పెరుగుతాయి? దీనికి మంచి ఉదాహరణ బైనరీ శోధనలు. ఏకైక విలువల శ్రేణిలో ఒక సంఖ్య కోసం శోధించడానికి ఒక అల్గోరిథంను పరిశీలిద్దాం.

మేము శోధించడానికి ఒక శ్రేణిని ప్రారంభిస్తాము, అది చిన్నది నుండి పెద్దది వరకు ఉంటుంది.
తరువాత, మేము శ్రేణి మధ్యలో విలువను తనిఖీ చేస్తాము.
మీ సంఖ్య ఎక్కువగా ఉంటే, మా శోధనలో మేము తక్కువ సంఖ్యలను మినహాయించాము మరియు సంఖ్య తక్కువగా ఉంటే, మేము అధిక సంఖ్యలను మినహాయించాము.
ఇప్పుడు, మిగిలిన సంఖ్యల మధ్య సంఖ్యను చూద్దాం.
మళ్లీ, మా లక్ష్యం విలువ మధ్య విలువ కంటే ఎక్కువ లేదా తక్కువగా ఉందా అనే దాని ఆధారంగా మేము సగం సంఖ్యలను మినహాయించాము.
మేము మా లక్ష్యాన్ని కనుగొనే వరకు లేదా అది జాబితాలో లేదని నిర్ధారించే వరకు మేము ఈ ప్రక్రియను కొనసాగిస్తాము.

మీరు చూడగలిగినట్లుగా, బైనరీ సెర్చ్‌లు ప్రతి పాస్‌లో సగం విలువలను తొలగిస్తాయి కాబట్టి, n పెద్దది కావడంతో, మేము శ్రేణిని ఎన్నిసార్లు తనిఖీ చేస్తామో దాని ప్రభావం ప్రభావితం కాదు. దీనిని పెద్ద- O సంజ్ఞామానం లో వ్యక్తీకరించడానికి, మేము వ్రాస్తాము:

O(log(n))

బిగ్-ఓ నొటేషన్ యొక్క ప్రాముఖ్యత

బిగ్-ఓ దేశం అల్గోరిథం ఎంత సమర్థవంతంగా ఉందో తెలియజేయడానికి మీకు శీఘ్ర మరియు సులభమైన మార్గాన్ని అందిస్తుంది. ఇది వివిధ అల్గోరిథంల మధ్య నిర్ణయించడం సులభం చేస్తుంది. మీరు లైబ్రరీ నుండి అల్గోరిథం ఉపయోగిస్తుంటే మరియు కోడ్ ఎలా ఉంటుందో తెలియకపోతే ఇది ప్రత్యేకంగా సహాయపడుతుంది.

ఆవిరి ప్రొఫైల్‌ను ఎలా చల్లగా చేయాలి

మీరు మొదట కోడ్ నేర్చుకున్నప్పుడు, మీరు సరళ విధులు ప్రారంభిస్తారు. పై గ్రాఫ్ నుండి మీరు చూడగలిగినట్లుగా, అది మిమ్మల్ని చాలా దూరం చేస్తుంది. కానీ మీరు మరింత అనుభవజ్ఞులై మరియు మరింత క్లిష్టమైన కోడ్‌ని రూపొందించడం ప్రారంభించినప్పుడు, సమర్థత సమస్యగా మారడం ప్రారంభమవుతుంది. మీ కోడ్ యొక్క సామర్థ్యాన్ని ఎలా లెక్కించాలో అర్థం చేసుకోవడం వలన మీరు సమర్థత కోసం ట్యూన్ చేయడం మరియు అల్గోరిథంల యొక్క లాభాలు మరియు నష్టాలను అంచనా వేయడం ప్రారంభించడానికి అవసరమైన సాధనాలను మీకు అందిస్తుంది.

షేర్ చేయండి షేర్ చేయండి ట్వీట్ ఇమెయిల్ 10 అత్యంత సాధారణ ప్రోగ్రామింగ్ మరియు కోడింగ్ తప్పులు

కోడింగ్ తప్పులు చాలా సమస్యలకు దారితీస్తాయి. ఈ చిట్కాలు ప్రోగ్రామింగ్ తప్పులను నివారించడానికి మరియు మీ కోడ్‌ను అర్థవంతంగా ఉంచడంలో మీకు సహాయపడతాయి.

తదుపరి చదవండి సంబంధిత అంశాలు

ప్రోగ్రామింగ్
ప్రోగ్రామింగ్

రచయిత గురుంచి జెన్నిఫర్ సీటన్(21 కథనాలు ప్రచురించబడ్డాయి)

J. సీటన్ ఒక సైన్స్ రైటర్, ఇది సంక్లిష్ట అంశాలను విచ్ఛిన్నం చేయడంలో ప్రత్యేకత కలిగి ఉంది. ఆమె సస్కట్చేవాన్ విశ్వవిద్యాలయం నుండి PhD కలిగి ఉంది; ఆమె పరిశోధన ఆన్‌లైన్‌లో విద్యార్థుల నిశ్చితార్థాన్ని పెంచడానికి ఆట ఆధారిత అభ్యాసాన్ని ఉపయోగించడంపై దృష్టి పెట్టింది. ఆమె పని చేయనప్పుడు, ఆమె చదవడం, వీడియో గేమ్‌లు ఆడటం లేదా తోటపనితో మీరు ఆమెను కనుగొంటారు.

జెన్నిఫర్ సీటన్ నుండి మరిన్ని

మా వార్తాలేఖకు సభ్యత్వాన్ని పొందండి

టెక్ చిట్కాలు, సమీక్షలు, ఉచిత ఈబుక్‌లు మరియు ప్రత్యేకమైన డీల్స్ కోసం మా వార్తాలేఖలో చేరండి!

సభ్యత్వం పొందడానికి ఇక్కడ క్లిక్ చేయండి