అనువాదకుని నుండి: మీ కోసం ఒక కథనాన్ని ప్రచురించింది , ఇంటర్వ్యూల సమయంలో డెవలపర్ దరఖాస్తుదారులకు చాలా తరచుగా అందించబడుతుంది. వ్యాసం మొదటగా, అనుభవం లేని ప్రోగ్రామర్లకు ఉపయోగకరంగా ఉంటుంది.
టెక్ కంపెనీలలో ఇంటర్వ్యూలు చాలా కాలంగా పట్టణంలో చర్చనీయాంశంగా ఉన్నాయి. ఇది ఆశ్చర్యపోనవసరం లేదు - ఇంటర్వ్యూలో విజయవంతంగా ఉత్తీర్ణత సాధించడం వలన మీకు మంచి ఉద్యోగం వచ్చే అవకాశం లభిస్తుంది. కానీ ఇది చాలా సులభం కాదు, ఎందుకంటే సంక్లిష్ట సమస్యలను తరచుగా పరిష్కరించాల్సిన అవసరం ఉంది.
అంతేకాకుండా, చాలా తరచుగా, ఈ పనులు చాలా వరకు దరఖాస్తుదారు చేసే పనికి సంబంధించినవి కావు, కానీ అవి ఇంకా పరిష్కరించబడాలి. కొన్నిసార్లు మీరు దీన్ని Google లేదా మరే ఇతర మూలాధారంతో తనిఖీ చేయకుండా బోర్డులో చేయాల్సి ఉంటుంది. అవును, పరిస్థితి క్రమంగా మారుతోంది, మరియు కొన్ని కంపెనీలు అలాంటి ఇంటర్వ్యూలను వదిలివేస్తున్నాయి, అయితే చాలా మంది యజమానులు ఇప్పటికీ ఈ సంప్రదాయానికి కట్టుబడి ఉన్నారు. ఈ కథనం జావాస్క్రిప్ట్ టాస్క్‌ల విశ్లేషణకు అంకితం చేయబడింది, వీటిని తరచుగా ఉద్యోగార్ధులకు టాస్క్‌లుగా ఉపయోగిస్తారు.
మేము గుర్తు చేస్తున్నాము: Habr పాఠకులందరికీ - Habr ప్రోమో కోడ్‌ని ఉపయోగించి ఏదైనా Skillbox కోర్సులో నమోదు చేసుకున్నప్పుడు 10 రూబుల్ తగ్గింపు.
Skillbox సిఫార్సు చేస్తోంది: ప్రాక్టికల్ కోర్సు .
ప్రధాన విషయం ఏమిటంటే మీ ఇంటర్వ్యూ కోసం పూర్తిగా సిద్ధం చేయడం.
అవును, మేము టాస్క్‌లను చూడటం ప్రారంభించే ముందు, కొన్ని సాధారణ ఇంటర్వ్యూ ప్రిపరేషన్ చిట్కాలను చూద్దాం.
ప్రధాన విషయం ముందుగానే సిద్ధం చేయడం. మీరు అల్గారిథమ్‌లు మరియు డేటా స్ట్రక్చర్‌లను ఎంత బాగా గుర్తుంచుకున్నారో పరీక్షించుకోండి మరియు మీకు అంతగా పరిచయం లేని ప్రాంతాల్లో మీ పరిజ్ఞానాన్ని మెరుగుపరచుకోండి. ఇంటర్వ్యూలకు సిద్ధం కావడానికి మీకు సహాయపడే అనేక ఆన్‌లైన్ ప్లాట్‌ఫారమ్‌లు ఉన్నాయి. మేము సలహా ఇస్తున్నాము , , и .
నిర్ణయాన్ని బిగ్గరగా చెప్పడం నేర్చుకోవడం విలువ. మీరు ఏమి చేస్తున్నారో దరఖాస్తుదారులకు చెప్పడం మంచిది, మరియు కేవలం బోర్డులో వ్రాయడం మాత్రమే కాదు (లేదా కంప్యూటర్‌లో కోడ్‌ని టైప్ చేయండి, నిశ్శబ్దంగా కూడా). ఈ విధంగా, మీరు కోడ్‌లో పొరపాటు చేస్తే, కానీ పరిష్కారం సాధారణంగా సరైనది అయితే, మీరు మీ విజయావకాశాలను పెంచుకోవచ్చు.
సమస్యను పరిష్కరించడానికి ముందు మీరు సమస్యను అర్థం చేసుకోవాలి. కొన్ని సందర్భాల్లో, మీరు ఒక పనిని ఉపరితలంగా అర్థం చేసుకుని, తప్పుడు మార్గంలో వెళ్లవచ్చు. ఇంటర్వ్యూయర్‌కి కొన్ని స్పష్టమైన ప్రశ్నలను అడగడం విలువైనదే కావచ్చు.
మీరు PCలో కాకుండా చేతితో కోడ్ రాయడం ప్రాక్టీస్ చేయాలి. ఇంటర్వ్యూల సమయంలో దరఖాస్తుదారుకు మార్కర్ మరియు వైట్‌బోర్డ్ ఇవ్వబడుతుంది, ఇక్కడ సూచనలు లేదా ఆటోమేటిక్ ఫార్మాటింగ్ లేవు. పరిష్కారం కోసం చూస్తున్నప్పుడు, మీ కోడ్‌ను కాగితంపై లేదా నేరుగా బోర్డుపై రాయడం విలువైనది. మీరు ప్రతిదీ మీ తలలో ఉంచుకుంటే, మీరు ముఖ్యమైనదాన్ని మరచిపోవచ్చు.
జావాస్క్రిప్ట్‌లో టెంప్లేట్ టాస్క్‌లు
ఈ టాస్క్‌లలో కొన్ని మీకు ఇప్పటికే తెలిసి ఉండవచ్చు. మీరు జావాస్క్రిప్ట్ నేర్చుకునేటప్పుడు మీరు అలాంటిదే పరిష్కరించాల్సిన ఇంటర్వ్యూలను కలిగి ఉండవచ్చు లేదా వాటిపై సాధన చేసారు. సరే, ఇప్పుడు వాటిని మళ్లీ పరిష్కరించడానికి సమయం ఆసన్నమైంది మరియు ప్రక్రియ యొక్క వివరణాత్మక వివరణతో.
పాలిండ్రోమ్
పాలిండ్రోమ్ అనేది సాధారణ దిశలో మరియు వ్యతిరేక దిశలో సరిగ్గా ఒకే విధంగా చదవబడే పదం, వాక్యం లేదా అక్షరాల క్రమం. ఉదాహరణకు, "అన్నా" అనేది పాలిండ్రోమ్, కానీ "టేబుల్" మరియు "జాన్" కాదు.
స్టేజింగ్
ఒక స్ట్రింగ్ ఇవ్వబడింది; స్ట్రింగ్ పాలిండ్రోమ్ అయితే ఒప్పు అని మరియు కాకపోతే తప్పుని అందించడానికి మిమ్మల్ని అనుమతించే ఫంక్షన్‌ను మీరు వ్రాయాలి. ఈ సందర్భంలో, మీరు ఖాళీలు మరియు విరామ చిహ్నాలను పరిగణనలోకి తీసుకోవాలి.
పాలిండ్రోమ్('రేస్‌కార్') === నిజం
పాలిండ్రోమ్('టేబుల్') === తప్పు
పనిని విశ్లేషిద్దాం
స్ట్రింగ్‌ను రివర్స్ చేయడం ఇక్కడ ప్రధాన ఆలోచన. "రివర్స్" స్ట్రింగ్ అసలైన దానికి పూర్తిగా ఒకేలా ఉంటే, అప్పుడు మేము పాలిండ్రోమ్‌ని అందుకున్నాము మరియు ఫంక్షన్ నిజమైనదిగా తిరిగి రావాలి. కాకపోతే, అబద్ధం.
నిర్ణయం
పాలిండ్రోమ్‌ను పరిష్కరించే కోడ్ ఇక్కడ ఉంది.
const palindrome = str => {
// turn the string to lowercase
str = str.toLowerCase()
// reverse input string and return the result of the
// comparisong
return str === str.split('').reverse().join('')
}ఇన్‌పుట్ స్ట్రింగ్‌లోని అక్షరాలను లోయర్ కేస్‌కి మార్చడం మొదటి దశ. ప్రోగ్రామ్ పాత్రలను స్వయంగా సరిపోల్చుతుందని ఇది హామీ, మరియు కేసు లేదా మరేదైనా కాదు.
రెండవ దశ రేఖను రివర్స్ చేయడం. దీన్ని చేయడం కష్టం కాదు: మీరు దీన్ని .split() పద్ధతి (స్ట్రింగ్ లైబ్రరీ) ఉపయోగించి శ్రేణిగా మార్చాలి. అప్పుడు మేము .reverse() (అరే లైబ్రరీ) ఉపయోగించి శ్రేణిని రివర్స్ చేస్తాము. .join() (అరే లైబ్రరీ)ని ఉపయోగించి రివర్స్ అర్రేని స్ట్రింగ్‌గా మార్చడం చివరి దశ.
ఇప్పుడు మీరు చేయాల్సిందల్లా "రివర్స్" స్ట్రింగ్‌ను అసలు స్ట్రింగ్‌తో సరిపోల్చడం, ఫలితాన్ని ఒప్పు లేదా తప్పు అని అందించడం.
FizzBuzz
ఇంటర్వ్యూలలో అత్యంత ప్రజాదరణ పొందిన టాస్క్‌లలో ఒకటి.
స్టేజింగ్
మీరు 1 నుండి n వరకు సంఖ్యలను కన్సోల్‌కు ప్రింట్ చేసే ఫంక్షన్‌ను వ్రాయాలి, ఇక్కడ n అనేది పూర్ణాంకం, ఈ క్రింది షరతులతో ఫంక్షన్ పరామితిగా తీసుకుంటుంది:
- 3 యొక్క గుణిజాలకు బదులుగా అవుట్‌పుట్ ఫిజ్;
- 5 యొక్క గుణిజాలుగా ఉండే సంఖ్యలకు బదులుగా అవుట్‌పుట్ బజ్;
- 3 మరియు 5 రెండింటికి గుణిజాలుగా ఉండే సంఖ్యలకు బదులుగా fizzbuzz అవుట్‌పుట్.
ఉదాహరణకు
Fizzbuzz(5)
ఫలితంగా
// 1
// 2
// ఫిజ్
// 4
//బజ్
పనిని విశ్లేషిద్దాం
ఇక్కడ ప్రధాన విషయం JavaScriptని ఉపయోగించి గుణిజాలను కనుగొనే మార్గం. ఇది మాడ్యులస్ ఆపరేటర్ లేదా మిగిలిన - % ఉపయోగించి అమలు చేయబడుతుంది, ఇది రెండు సంఖ్యలను విభజించేటప్పుడు మిగిలిన వాటిని చూపడానికి మిమ్మల్ని అనుమతిస్తుంది. శేషం 0 అయితే, మొదటి సంఖ్య రెండవ సంఖ్య యొక్క గుణకం అని అర్థం.
12% 5 // 2 -> 12 అనేది 5 యొక్క గుణకం కాదు
12% 3 // 0 -> 12 అనేది 3కి గుణకారం
కాబట్టి, మీరు 12ని 5తో భాగిస్తే, మీరు 2ని మిగిలిన 2తో భాగిస్తే, మీరు 12ని 3తో భాగిస్తే, మీకు 4 వస్తుంది. , 0 అనేది 12 యొక్క గుణకం.
నిర్ణయం
సరైన పరిష్కారం క్రింది కోడ్ అవుతుంది:
const fizzBuzz = num => {
for(let i = 1; i <= num; i++) {
// check if the number is a multiple of 3 and 5
if(i % 3 === 0 && i % 5 === 0) {
console.log('fizzbuzz')
} // check if the number is a multiple of 3
else if(i % 3 === 0) {
console.log('fizz')
} // check if the number is a multiple of 5
else if(i % 5 === 0) {
console.log('buzz')
} else {
console.log(i)
}
}
}ఫంక్షన్ షరతులతో కూడిన స్టేట్‌మెంట్‌లను ఉపయోగించి అవసరమైన తనిఖీలను నిర్వహిస్తుంది మరియు వినియోగదారుకు అవసరమైన ఫలితాన్ని ఉత్పత్తి చేస్తుంది. సమస్యలో, if...else స్టేట్‌మెంట్‌ల క్రమానికి శ్రద్ధ చూపడం విలువ: డబుల్ షరతుతో ప్రారంభించండి (&&) మరియు బహుళ సంఖ్యలు కనుగొనబడని సందర్భంలో ముగించండి. ఫలితంగా, మేము అన్ని ఎంపికలను కవర్ చేస్తాము.
అనగ్రామ్
మరొక పదంలోని అన్ని అక్షరాలను ఒకే సంఖ్యలో కానీ వేరే క్రమంలో ఉండే పదానికి ఇది పేరు.
స్టేజింగ్
మేము రెండు స్ట్రింగ్‌లు అనగ్రామ్‌లు కాదా అని తనిఖీ చేసే ఫంక్షన్‌ను వ్రాయాలి మరియు కేసు పట్టింపు లేదు. అక్షరాలు మాత్రమే లెక్కించబడతాయి; ఖాళీలు లేదా విరామ చిహ్నాలు పరిగణనలోకి తీసుకోబడవు.
అనగ్రామ్('ఫైండర్', 'ఫ్రెండ్') —> నిజం
అనగ్రామ్('హలో', 'బై') —> తప్పు
పనిని విశ్లేషిద్దాం
ఇక్కడ పరిగణించవలసిన ముఖ్యమైన విషయం ఏమిటంటే, మీరు రెండు ఇన్‌పుట్ లైన్‌లలోని ప్రతి అక్షరాన్ని మరియు ప్రతి లైన్‌లోని వాటి సంఖ్యను తనిఖీ చేయాలి.
ఫైండర్ —> f: 1 స్నేహితుడు —> f: 1
i: 1 r: 1
n: 1 i: 1
డి: 1 ఇ: 1
ఇ: 1 ని: 1
r: 1 d: 1
అనగ్రామ్ డేటాను నిల్వ చేయడానికి, మీరు JavaScript ఆబ్జెక్ట్ లిటరల్ వంటి నిర్మాణాన్ని ఎంచుకోవాలి. ఈ సందర్భంలో కీలకం అక్షరం యొక్క పాత్ర, విలువ ప్రస్తుత పంక్తిలో దాని పునరావృతాల సంఖ్య.
ఇతర షరతులు ఉన్నాయి:
- పోల్చినప్పుడు అక్షరాల కేసును పరిగణనలోకి తీసుకోలేదని మీరు నిర్ధారించుకోవాలి. మేము రెండు స్ట్రింగ్‌లను లోయర్ లేదా అప్పర్ కేస్‌కి మారుస్తాము.
- మేము పోలిక నుండి అన్ని అక్షరాలు కాని వాటిని మినహాయిస్తాము. పని చేయడం ఉత్తమం .
నిర్ణయం
// helper function that builds the
// object to store the data
const buildCharObject = str => {
const charObj = {}
for(let char of str.replace(/[^w]/g).toLowerCase()) {
// if the object has already a key value pair
// equal to the value being looped over,
// increase the value by 1, otherwise add
// the letter being looped over as key and 1 as its value
charObj[char] = charObj[char] + 1 || 1
}
return charObj
}
// main function
const anagram = (strA, strB) => {
// build the object that holds strA data
const aCharObject = buildCharObject(strA)
// build the object that holds strB data
const bCharObject = buildCharObject(strB)
// compare number of keys in the two objects
// (anagrams must have the same number of letters)
if(Object.keys(aCharObject).length !== Object.keys(bCharObject).length) {
return false
}
// if both objects have the same number of keys
// we can be sure that at least both strings
// have the same number of characters
// now we can compare the two objects to see if both
// have the same letters in the same amount
for(let char in aCharObject) {
if(aCharObject[char] !== bCharObject[char]) {
return false
}
}
// if both the above checks succeed,
// you have an anagram: return true
return true
}ఉపయోగంపై శ్రద్ధ వహించండి పై స్నిప్పెట్‌లో. ఈ పద్ధతి ఆబ్జెక్ట్‌లో కనిపించే అదే క్రమంలో పేర్లు లేదా కీలను కలిగి ఉన్న శ్రేణిని అందిస్తుంది. ఈ సందర్భంలో శ్రేణి ఇలా ఉంటుంది:
['f', 'i', 'n', 'd', 'e', 'r']
ఈ విధంగా మనం బల్క్ లూప్ చేయకుండానే వస్తువు యొక్క లక్షణాలను పొందుతాము. సమస్యలో, రెండు స్ట్రింగ్‌లు ఒకే సంఖ్యలో అక్షరాలను కలిగి ఉన్నాయో లేదో తనిఖీ చేయడానికి మీరు ఈ పద్ధతిని .length ప్రాపర్టీతో ఉపయోగించవచ్చు - ఇది అనగ్రామ్‌ల యొక్క ముఖ్యమైన లక్షణం.
అచ్చుల కోసం శోధించండి
ఇంటర్వ్యూలలో తరచుగా వచ్చే చాలా సులభమైన పని.
స్టేజింగ్
మీరు స్ట్రింగ్‌ను ఆర్గ్యుమెంట్‌గా తీసుకుని, స్ట్రింగ్‌లో ఉన్న అచ్చుల సంఖ్యను అందించే ఫంక్షన్‌ను వ్రాయాలి.
అచ్చులు "a", "e", "i", "o", "u".
ఉదాహరణకు:
ఫైండ్ అచ్చులు('హలో') // —> 2
అచ్చులను కనుగొనండి ('ఎందుకు') // —> 0
నిర్ణయం
ఇక్కడ సరళమైన ఎంపిక ఉంది:
const findVowels = str => {
let count = 0
const vowels = ['a', 'e', 'i', 'o', 'u']
for(let char of str.toLowerCase()) {
if(vowels.includes(char)) {
count++
}
}
return count
}.includes() పద్ధతిని ఉపయోగించడంపై శ్రద్ధ చూపడం ముఖ్యం. ఇది స్ట్రింగ్‌లు మరియు శ్రేణులు రెండింటికీ అందుబాటులో ఉంది. శ్రేణి నిర్దిష్ట విలువను కలిగి ఉందో లేదో తెలుసుకోవడానికి దీనిని ఉపయోగించాలి. శ్రేణి పేర్కొన్న విలువను కలిగి ఉంటే ఈ పద్ధతి ఒప్పు అని మరియు అది లేకపోతే తప్పు అని అందిస్తుంది.
సమస్యకు చిన్న పరిష్కారం ఉంది:
const findVowels = str => {
const matched = str.match(/[aeiou]/gi)
return matched ? matches.length : 0
}ఇది .match() పద్ధతిని ఉపయోగిస్తుంది, ఇది సమర్థవంతమైన శోధనను అమలు చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. పేర్కొన్న స్ట్రింగ్‌లో మెథడ్ ఆర్గ్యుమెంట్‌గా రెగ్యులర్ ఎక్స్‌ప్రెషన్ కనుగొనబడితే, రిటర్న్ విలువ అనేది సరిపోలే అక్షరాల శ్రేణి. సరే, సరిపోలికలు లేకుంటే, .match() శూన్యతను అందిస్తుంది.
ఫైబొనాక్సీ
వివిధ స్థాయిలలో ఇంటర్వ్యూలలో కనుగొనబడే ఒక క్లాసిక్ టాస్క్. ఫిబొనాక్సీ సీక్వెన్స్ అనేది సంఖ్యల శ్రేణి అని గుర్తుంచుకోవాలి, ఇక్కడ ప్రతి తదుపరిది మునుపటి రెండింటి మొత్తం. కాబట్టి, మొదటి పది సంఖ్యలు ఇలా కనిపిస్తాయి: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34.
స్టేజింగ్
మీరు ఒక నిర్దిష్ట క్రమంలో nవ రికార్డ్‌ను తిరిగి ఇచ్చే ఫంక్షన్‌ను వ్రాయాలి, n అనేది ఫంక్షన్‌కు ఆర్గ్యుమెంట్‌గా పంపబడిన సంఖ్య.
ఫైబొనాక్సీ(3) // —> 2
ఈ టాస్క్‌లో ఆర్గ్యుమెంట్‌లో పేర్కొన్న అనేక సార్లు లూప్ ద్వారా నడవడం, తగిన స్థానం వద్ద విలువను తిరిగి ఇవ్వడం. సమస్యను ఎదుర్కొనే ఈ విధంగా లూప్‌లను ఉపయోగించడం అవసరం. బదులుగా మీరు రికర్షన్‌ని ఉపయోగిస్తే, అది ఇంటర్వ్యూయర్‌ని సంతోషపెట్టవచ్చు మరియు మీకు కొన్ని అదనపు పాయింట్‌లను అందించవచ్చు.
నిర్ణయం
const fibonacci = num => {
// store the Fibonacci sequence you're going
// to generate inside an array and
// initialize the array with the first two
// numbers of the sequence
const result = [0, 1]
for(let i = 2; i <= num; i++) {
// push the sum of the two numbers
// preceding the position of i in the result array
// at the end of the result array
const prevNum1 = result[i - 1]
const prevNum2 = result[i - 2]
result.push(prevNum1 + prevNum2)
}
// return the last value in the result array
return result[num]
}ఫలితాల శ్రేణిలో, మొదటి రెండు సంఖ్యలు సిరీస్‌లో ఉంటాయి, ఎందుకంటే క్రమంలో ప్రతి ఎంట్రీ మునుపటి రెండు సంఖ్యల మొత్తం. చాలా ప్రారంభంలో తదుపరి సంఖ్యను పొందడానికి తీసుకోవలసిన రెండు సంఖ్యలు లేవు, కాబట్టి లూప్ వాటిని స్వయంచాలకంగా రూపొందించదు. కానీ, మనకు తెలిసినట్లుగా, మొదటి రెండు సంఖ్యలు ఎల్లప్పుడూ 0 మరియు 1. కాబట్టి, మీరు ఫలితాల శ్రేణిని మానవీయంగా ప్రారంభించవచ్చు.
పునరావృతం విషయానికొస్తే, ప్రతిదీ సరళమైనది మరియు అదే సమయంలో మరింత క్లిష్టంగా ఉంటుంది:
const fibonacci = num => {
// if num is either 0 or 1 return num
if(num < 2) {
return num
}
// recursion here
return fibonacci(num - 1) + fibonacci(num - 2)
}మేము ఫైబొనాక్సీ()ని పిలుస్తూ ఉంటాము, చిన్న మరియు చిన్న సంఖ్యలను ఆర్గ్యుమెంట్‌లుగా పంపుతాము. ఆమోదించబడిన వాదన 0 లేదా 1 అయినప్పుడు మేము ఆపివేస్తాము.
తీర్మానం
చాలా మటుకు, మీరు ఫ్రంటెండ్ లేదా జావాస్క్రిప్ట్ డెవలపర్ ఉద్యోగం కోసం ఇంటర్వ్యూ చేసినట్లయితే (ముఖ్యంగా ఇది జూనియర్ స్థాయిలో ఉంటే) మీరు ఇప్పటికే ఈ టాస్క్‌లలో దేనినైనా ఎదుర్కొన్నారు. కానీ మీరు వాటిని చూడకపోతే, అవి భవిష్యత్తులో ఉపయోగకరంగా ఉండవచ్చు - కనీసం సాధారణ అభివృద్ధికి.
Skillbox సిఫార్సు చేస్తోంది:
- ఆన్‌లైన్‌లో దరఖాస్తు చేసుకున్నారు .
- ఆన్‌లైన్ కోర్సు .
- ప్రాక్టికల్ ఒక సంవత్సరం కోర్సు .
మూలం: www.habr.com