కాబట్టి మీరు అక్కడ ఉన్నారు. ఉపశమనం. అయిపోయిన. మీ ఇంటర్వ్యూయర్ మిమ్మల్ని అడిగే గమ్మత్తైన కోడింగ్ ప్రశ్నను పరిష్కరించడానికి మీరు చివరకు ఒక విధానంతో ముందుకు వచ్చారు. బహుశా మీరు దీన్ని వైట్బోర్డ్లో, లైన్ వారీగా వ్రాశారు. మరియు మీరు మంచి సమయం చేసారు! మీరు సమావేశానికి 20 నిమిషాలు మాత్రమే ఉన్నారు. మీ ఇంటర్వ్యూయర్ ఆకట్టుకోవాలి.
రైట్?
"ఇది పని చేస్తుంది, కానీ దీన్ని మరింత సమర్థవంతంగా ఎలా చేయాలో ఏమైనా ఆలోచనలు ఉన్నాయా?"
మీ గుండె మునిగిపోతుంది. మీరు గమ్మత్తైన అల్గోరిథం డిజైన్ భాగంతో పూర్తి చేశారని మీరు అనుకున్నారు! మీరు సమస్యను పరిష్కరించడానికి మరిన్ని మార్గాల గురించి ఆలోచించడానికి ప్రయత్నిస్తారు, కానీ మీరు ఆలోచించగలిగేది మీరు ఇప్పటికే ముందుకు వచ్చిన ఒక విధానం.
ఇది దాదాపు అందరికీ జరుగుతుంది. మరియు వారు తెలివితక్కువవారు కాబట్టి కాదు. ఎందుకంటే చాలా మందికి వారి అల్గోరిథంల సామర్థ్యాన్ని మెరుగుపరచడానికి ఒక పద్ధతి లేదు.
కానీ నిజం, పుష్కలంగా ఉన్నాయి. మీరు స్టంప్ చేసిన తదుపరిసారి, ఈ మూడు సాధారణ విధానాలను వర్తింపజేయడానికి ప్రయత్నించండి.
1. హాష్ మ్యాప్ ఉపయోగించండి
అది నిజం. హాష్ పటాలు / అనుబంధ శ్రేణులు / నిఘంటువులు (అవి మీరు ఉపయోగిస్తున్న ప్రోగ్రామింగ్ భాషను బట్టి చాలా పేర్లతో వెళ్తాయి) అల్గోరిథంల రన్టైమ్ను తగ్గించే మాయా సామర్థ్యాన్ని కలిగి ఉంటాయి.
ఉదాహరణకు, సంఖ్యల శ్రేణిలో ఎక్కువసార్లు పునరావృతమయ్యే సంఖ్యను కనుగొనడం ప్రశ్న అని అనుకుందాం.
మీ మొదటి ఆలోచన కొన్ని ఉచ్చులు దూకడం కావచ్చు. మా ప్రతి సంఖ్య కోసం, దాని గణనను గుర్తించండి మరియు ఇది పెద్దది కాదా అని చూడండి. ప్రతి సంఖ్యకు గణనను ఎలా పొందగలం? శ్రేణి ద్వారా లూప్ చేయండి, ఇది ఎన్నిసార్లు సంభవిస్తుందో లెక్కిస్తుంది! కాబట్టి మేము రెండు సమూహ ఉచ్చుల గురించి మాట్లాడుతున్నాము. సూడోకోడ్లో:
def get_mode (nums): max_count = 0 మోడ్ = సంఖ్యలలో సంభావ్య_మోడ్ కోసం శూన్య: మా_అరేలో సంఖ్యకు కౌంట్ = 0: కౌంట్ + = 1 ఉంటే కౌంట్> = max_count: మోడ్ = సంభావ్య_మోడ్ max_count = కౌంట్ రిటర్న్ మోడ్
ప్రస్తుతం, మేము శ్రేణిలోని ప్రతి అంశం కోసం ఒకసారి మా మొత్తం శ్రేణి ద్వారా లూప్ చేస్తున్నాము - కాని మేము బాగా చేయగలం. పెద్ద O సంజ్ఞామానం లో, ఇది మొత్తం O (n 2 ) సమయం.
మేము మా గణనలను హాష్ మ్యాప్లో నిల్వ చేస్తే (వాటి గణనలకు సంఖ్యలను మ్యాపింగ్ చేయండి), మేము శ్రేణి (O (n) సమయం ద్వారా ఒకే నడకలో సమస్యను పరిష్కరించగలము!):
def get_mode (nums): max_count = 0 మోడ్ = శూన్య గణనలు = క్రొత్త హాష్ మ్యాప్, సంభావ్య_మోడ్ కోసం ప్రతి విలువను 0 వద్ద ప్రారంభించి సంఖ్యలు: గణనలు + = 1 ఉంటే గణనలు> max_count: మోడ్ = సంభావ్య_మోడ్ max_count = గణనలు తిరిగి మోడ్
చాలా వేగంగా!
2. బిట్ మానిప్యులేషన్ ఉపయోగించండి
ఇది నిజంగా మిమ్మల్ని ప్యాక్ నుండి వేరు చేస్తుంది. ఇది ప్రతి సమస్యకు వర్తించదు, కానీ మీరు దీన్ని మీ వెనుక జేబులో ఉంచి సరైన సమయంలో దాన్ని బస్ట్ చేస్తే, మీరు రాక్స్టార్ లాగా కనిపిస్తారు.
ఇక్కడ ఒక ఉదాహరణ ఉంది: మనకు సంఖ్యల శ్రేణి ఉందని అనుకుందాం, ఇక్కడ ప్రతి సంఖ్య రెండుసార్లు కనిపిస్తుంది, ఒక్క సంఖ్య తప్ప ఒక్కసారి మాత్రమే జరుగుతుంది. ఒంటరి, పునరావృతం కాని సంఖ్యను కనుగొనడానికి మేము ఒక ఫంక్షన్ వ్రాస్తున్నాము.
మీ మొదటి ప్రవృత్తి హాష్ మ్యాప్ను ఉపయోగించడం కావచ్చు, ఎందుకంటే మేము దాని గురించి మాట్లాడాము. అది మంచి స్వభావం! మరియు ఇది ఈ కోసం పని చేస్తుంది. మేము చాలా సారూప్యమైన “గణనలు” మ్యాప్ను తయారు చేయవచ్చు మరియు 1 సంఖ్యతో ఏ సంఖ్య ముగుస్తుందో చూడటానికి దాన్ని ఉపయోగించండి.
కానీ ఇంకా మంచి మార్గం ఉంది. మీకు బిట్ మానిప్యులేషన్ గురించి తెలిస్తే, మీకు XOR తో పరిచయం ఉండవచ్చు. XOR గురించి ప్రత్యేకమైన ఒక విషయం ఏమిటంటే, మీరు దానితోనే ఒక సంఖ్యను XOR చేస్తే, బిట్స్ 0 కి “రద్దు” చేస్తాయి. ఈ సమస్య కోసం, మేము శ్రేణిలోని ప్రతి సంఖ్యను XOR చేస్తే, మేము చేయని ఒక సంఖ్యతో మిగిలిపోతాము రద్దు చేయవద్దు:
def find_unrepeated (nums): సంఖ్యలలో సంఖ్యకు పునరావృతం చేయని = 0: పునరావృతం చేయని = పునరావృతం చేయని XOR సంఖ్యా రిటర్న్
3. బాటమ్-అప్ వెళ్ళండి
సంఖ్య n ఇచ్చిన “nth” ఫైబొనాక్సీ సంఖ్యను అవుట్పుట్ చేసే ఫంక్షన్ను వ్రాయండి. ఇది ఒక క్లాసిక్, మరియు ఇది పునరావృతానికి చాలా చక్కగా ఇస్తుంది:
def fib (n): n 0 లేదా 1 అయితే: 1 రిటర్న్ ఫైబ్ (n-1) + ఫైబ్ (n-2)
కానీ సాధారణ పునరావృత సమాధానం ఒక్కటే కాదు! ఈ ఫంక్షన్ ఏమి చేస్తుందో జాగ్రత్తగా ఆలోచించండి. N 5 అని అనుకుందాం. సమాధానం పొందడానికి, ఇది పునరావృతంగా ఫైబ్ (4) మరియు ఫైబ్ (3) అని పిలుస్తుంది. ఇప్పుడు, ఫైబ్ (4) కు ఆ కాల్ ఏమి చేస్తుంది? ఇది ఫైబ్ (3) మరియు ఫైబ్ (2) అని పిలుస్తుంది. కానీ మేము ఇప్పటికే ఫైబ్ (3) కు కాల్ చేశామని చెప్పాము! ఈ అందమైన పునరావృత ఫంక్షన్ చాలా పునరావృత పని చేస్తుంది. మొత్తం సమయ ఖర్చు O (2 n ) గా మారుతుంది. ఇది O (n 2 ) కన్నా చెడ్డది.
N నుండి 1 వరకు పునరావృతమయ్యే బదులు, 1 నుండి n వరకు “బాటమ్-అప్” కి వెళ్దాం. ఇది పునరావృతాన్ని దాటవేయడానికి మాకు అనుమతిస్తుంది:
డెబ్ ఫైబ్ (ఎన్): 1 నుండి n పరిధిలో i కోసం మునుపటి = 0 మునుపటి_ప్రెవియస్ = 1: ప్రస్తుత = మునుపటి + మునుపటి_ మునుపటి_ప్రెవియస్ = మునుపటి = ప్రస్తుత మునుపటి ప్రస్తుత
కోడ్ ఎక్కువ, కానీ ఇది చాలా సమర్థవంతంగా ఉంటుంది! O (n) సమయానికి డౌన్. పునరావృత అల్గోరిథంలను అన్రోలింగ్ చేయడంతో అదనపు బోనస్గా, మేము స్థలాన్ని ఆదా చేస్తాము. ఆ పునరావృత కాల్స్ అన్నీ కాల్ స్టాక్లో నిర్మించబడతాయి, ఇది మెమరీలో కూర్చుని మా స్థల వ్యయాన్ని లెక్కించింది. మా పునరావృత ఫంక్షన్కు O (n) స్థల వ్యయం ఉంది, కానీ ఈ పునరుక్తికి O (1) స్థలం పడుతుంది.
మీ ఇంటర్వ్యూయర్ మీ పరిష్కారం యొక్క సామర్థ్యాన్ని మెరుగుపరచమని మిమ్మల్ని అడిగినప్పుడు, ఈ వ్యూహాల ద్వారా నడవడానికి ప్రయత్నించండి మరియు వారు సహాయం చేస్తారో లేదో చూడండి. తగినంత అభ్యాసంతో, మీరు ఆప్టిమైజ్ చేసిన పరిష్కారానికి నేరుగా దూకుతారు, మరింత అమాయక పరిష్కారాన్ని దాటవేస్తారు. మరియు అది గొప్ప విషయం. మీరు మంచి ఇంటర్వ్యూయర్ అవుతున్నారని దీని అర్థం కాదు-అంటే మీరు మంచి ఇంజనీర్ అవుతున్నారని అర్థం.
