🥇5 ವಿಶಿಷ್ಟ JavaScript ಸಂದರ್ಶನ ಕಾರ್ಯಗಳು: ವಿಶ್ಲೇಷಣೆ ಮತ್ತು ಪರಿಹಾರಗಳು

ಅನುವಾದಕರಿಂದ: ನಿಮಗಾಗಿ ಒಂದು ಲೇಖನವನ್ನು ಪ್ರಕಟಿಸಿದೆ ಮಾರಿಯಾ ಆಂಟೋನಿಯೆಟ್ಟಾ ಪೆರ್ನಾ, ಸಾಮಾನ್ಯ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕಾರ್ಯಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತಾರೆ, ಸಂದರ್ಶನಗಳ ಸಮಯದಲ್ಲಿ ಡೆವಲಪರ್ ಅರ್ಜಿದಾರರಿಗೆ ಹೆಚ್ಚಾಗಿ ನೀಡಲಾಗುತ್ತದೆ. ಲೇಖನವು ಅನನುಭವಿ ಪ್ರೋಗ್ರಾಮರ್ಗಳಿಗೆ ಮೊದಲನೆಯದಾಗಿ ಉಪಯುಕ್ತವಾಗಿರುತ್ತದೆ.

ಟೆಕ್ ಕಂಪನಿಗಳಲ್ಲಿ ಸಂದರ್ಶನಗಳು ಬಹಳ ಹಿಂದಿನಿಂದಲೂ ಪಟ್ಟಣದ ಚರ್ಚೆಯಾಗಿದೆ. ಇದು ಆಶ್ಚರ್ಯಪಡಬೇಕಾಗಿಲ್ಲ - ಸಂದರ್ಶನದಲ್ಲಿ ಯಶಸ್ವಿಯಾಗಿ ಉತ್ತೀರ್ಣರಾಗುವುದು ನಿಮಗೆ ಉತ್ತಮ ಕೆಲಸವನ್ನು ಪಡೆಯುವ ಅವಕಾಶವನ್ನು ನೀಡುತ್ತದೆ. ಆದರೆ ಇದು ಅಷ್ಟು ಸುಲಭವಲ್ಲ, ಏಕೆಂದರೆ ಸಂಕೀರ್ಣ ಸಮಸ್ಯೆಗಳನ್ನು ಹೆಚ್ಚಾಗಿ ಪರಿಹರಿಸಬೇಕಾಗುತ್ತದೆ.

ಇದಲ್ಲದೆ, ಹೆಚ್ಚಾಗಿ, ಈ ಹೆಚ್ಚಿನ ಕಾರ್ಯಗಳು ಅರ್ಜಿದಾರರು ನಿರ್ವಹಿಸುವ ಕೆಲಸಕ್ಕೆ ಸಂಬಂಧಿಸಿಲ್ಲ, ಆದರೆ ಅವುಗಳನ್ನು ಇನ್ನೂ ಪರಿಹರಿಸಬೇಕಾಗಿದೆ. ಕೆಲವೊಮ್ಮೆ ನೀವು ಅದನ್ನು Google ಅಥವಾ ಯಾವುದೇ ಇತರ ಮೂಲದೊಂದಿಗೆ ಪರಿಶೀಲಿಸದೆಯೇ ಬೋರ್ಡ್‌ನಲ್ಲಿ ಮಾಡಬೇಕು. ಹೌದು, ಪರಿಸ್ಥಿತಿಯು ಕ್ರಮೇಣ ಬದಲಾಗುತ್ತಿದೆ, ಮತ್ತು ಕೆಲವು ಕಂಪನಿಗಳು ಅಂತಹ ಸಂದರ್ಶನಗಳನ್ನು ತ್ಯಜಿಸುತ್ತಿವೆ, ಆದರೆ ಅನೇಕ ಉದ್ಯೋಗದಾತರು ಇನ್ನೂ ಈ ಸಂಪ್ರದಾಯಕ್ಕೆ ಬದ್ಧರಾಗಿದ್ದಾರೆ. ಈ ಲೇಖನವು ವಿಶಿಷ್ಟವಾದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕಾರ್ಯಗಳ ವಿಶ್ಲೇಷಣೆಗೆ ಮೀಸಲಾಗಿರುತ್ತದೆ, ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಉದ್ಯೋಗಾಕಾಂಕ್ಷಿಗಳಿಗೆ ಕಾರ್ಯಗಳಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.

ನಾವು ನೆನಪಿಸುತ್ತೇವೆ: ಎಲ್ಲಾ Habr ಓದುಗರಿಗೆ - Habr ಪ್ರೊಮೊ ಕೋಡ್ ಬಳಸಿಕೊಂಡು ಯಾವುದೇ ಸ್ಕಿಲ್‌ಬಾಕ್ಸ್ ಕೋರ್ಸ್‌ಗೆ ದಾಖಲಾಗುವಾಗ 10 ರೂಬಲ್ ರಿಯಾಯಿತಿ.

ಸ್ಕಿಲ್‌ಬಾಕ್ಸ್ ಶಿಫಾರಸು ಮಾಡುತ್ತದೆ: ಪ್ರಾಯೋಗಿಕ ಕೋರ್ಸ್ "ಮೊಬೈಲ್ ಡೆವಲಪರ್ ಪ್ರೊ".

ನಿಮ್ಮ ಸಂದರ್ಶನಕ್ಕೆ ಸಂಪೂರ್ಣವಾಗಿ ತಯಾರಿ ಮಾಡುವುದು ಮುಖ್ಯ ವಿಷಯ.

ಹೌದು, ನಾವು ಕಾರ್ಯಗಳನ್ನು ನೋಡಲು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು, ಕೆಲವು ಸಾಮಾನ್ಯ ಸಂದರ್ಶನ ತಯಾರಿ ಸಲಹೆಗಳನ್ನು ನೋಡೋಣ.

ಮುಂಚಿತವಾಗಿ ಸಿದ್ಧಪಡಿಸುವುದು ಮುಖ್ಯ ವಿಷಯ. ನೀವು ಅಲ್ಗಾರಿದಮ್‌ಗಳು ಮತ್ತು ಡೇಟಾ ರಚನೆಗಳನ್ನು ಎಷ್ಟು ಚೆನ್ನಾಗಿ ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತೀರಿ ಎಂಬುದನ್ನು ಪರೀಕ್ಷಿಸಿ ಮತ್ತು ನಿಮಗೆ ಹೆಚ್ಚು ಪರಿಚಯವಿಲ್ಲದ ಪ್ರದೇಶಗಳಲ್ಲಿ ನಿಮ್ಮ ಜ್ಞಾನವನ್ನು ಸುಧಾರಿಸಿ. ಸಂದರ್ಶನಗಳಿಗೆ ತಯಾರಾಗಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುವ ಅನೇಕ ಆನ್‌ಲೈನ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳಿವೆ. ನಾವು ಸಲಹೆ ನೀಡುತ್ತೇವೆ ಗೀಕ್ಸ್ಫೋರ್ಗೀಕ್ಸ್, ಪ್ರಾಂಪ್, Interviewing.io и ಕೋಡ್‌ಸಿಗ್ನಲ್.

ನಿರ್ಧಾರವನ್ನು ಜೋರಾಗಿ ಹೇಳಲು ಕಲಿಯುವುದು ಯೋಗ್ಯವಾಗಿದೆ. ನೀವು ಏನು ಮಾಡುತ್ತಿದ್ದೀರಿ ಎಂಬುದರ ಕುರಿತು ಅರ್ಜಿದಾರರಿಗೆ ಹೇಳಲು ಸಲಹೆ ನೀಡಲಾಗುತ್ತದೆ ಮತ್ತು ಬೋರ್ಡ್‌ನಲ್ಲಿ ಬರೆಯಬೇಡಿ (ಅಥವಾ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ಟೈಪ್ ಮಾಡಿ, ಮೌನವಾಗಿ). ಈ ರೀತಿಯಾಗಿ, ನೀವು ಕೋಡ್‌ನಲ್ಲಿ ತಪ್ಪು ಮಾಡಿದರೆ, ಆದರೆ ಪರಿಹಾರವು ಸಾಮಾನ್ಯವಾಗಿ ಸರಿಯಾಗಿದ್ದರೆ, ನಿಮ್ಮ ಯಶಸ್ಸಿನ ಸಾಧ್ಯತೆಗಳನ್ನು ನೀವು ಹೆಚ್ಚಿಸಬಹುದು.

ನೀವು ಅದನ್ನು ಪರಿಹರಿಸಲು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು ನೀವು ಸಮಸ್ಯೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು. ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ, ನೀವು ಕೆಲಸವನ್ನು ಮೇಲ್ನೋಟಕ್ಕೆ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಹುದು ಮತ್ತು ನಂತರ ತಪ್ಪು ದಾರಿಯಲ್ಲಿ ಹೋಗಬಹುದು. ಸಂದರ್ಶಕರಿಗೆ ಕೆಲವು ಸ್ಪಷ್ಟೀಕರಣದ ಪ್ರಶ್ನೆಗಳನ್ನು ಕೇಳುವುದು ಯೋಗ್ಯವಾಗಿದೆ.

ನೀವು PC ಯಲ್ಲಿ ಅಲ್ಲ, ಕೈಯಿಂದ ಕೋಡ್ ಬರೆಯುವುದನ್ನು ಅಭ್ಯಾಸ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಸಂದರ್ಶನಗಳ ಸಮಯದಲ್ಲಿ ಅರ್ಜಿದಾರರಿಗೆ ಮಾರ್ಕರ್ ಮತ್ತು ವೈಟ್‌ಬೋರ್ಡ್ ನೀಡಲಾಗುತ್ತದೆ, ಅಲ್ಲಿ ಯಾವುದೇ ಸುಳಿವು ಅಥವಾ ಸ್ವಯಂಚಾಲಿತ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಇಲ್ಲ. ಪರಿಹಾರವನ್ನು ಹುಡುಕುತ್ತಿರುವಾಗ, ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಕಾಗದದ ತುಂಡು ಅಥವಾ ನೇರವಾಗಿ ಬೋರ್ಡ್‌ನಲ್ಲಿ ಬರೆಯುವುದು ಯೋಗ್ಯವಾಗಿದೆ. ನೀವು ಎಲ್ಲವನ್ನೂ ನಿಮ್ಮ ತಲೆಯಲ್ಲಿ ಇಟ್ಟುಕೊಂಡರೆ, ನೀವು ಮುಖ್ಯವಾದದ್ದನ್ನು ಮರೆತುಬಿಡಬಹುದು.

JavaScript ನಲ್ಲಿ ಟೆಂಪ್ಲೇಟ್ ಕಾರ್ಯಗಳು

ಈ ಕೆಲವು ಕಾರ್ಯಗಳು ಬಹುಶಃ ನಿಮಗೆ ಈಗಾಗಲೇ ಪರಿಚಿತವಾಗಿವೆ. ನೀವು ಸಂದರ್ಶನಗಳನ್ನು ಹೊಂದಿದ್ದೀರಿ, ಅಲ್ಲಿ ನೀವು ಇದೇ ರೀತಿಯ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಬೇಕು ಅಥವಾ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕಲಿಯುವಾಗ ಅಭ್ಯಾಸ ಮಾಡಿದ್ದೀರಿ. ಸರಿ, ಈಗ ಅವುಗಳನ್ನು ಮತ್ತೆ ಪರಿಹರಿಸಲು ಸಮಯ, ಮತ್ತು ಪ್ರಕ್ರಿಯೆಯ ವಿವರವಾದ ವಿವರಣೆಯೊಂದಿಗೆ.

ಪಾಲಿಂಡ್ರೋಮ್

ಪಾಲಿಂಡ್ರೋಮ್ ಎನ್ನುವುದು ಪದ, ವಾಕ್ಯ ಅಥವಾ ಅಕ್ಷರಗಳ ಅನುಕ್ರಮವಾಗಿದ್ದು, ಇದನ್ನು ಸಾಮಾನ್ಯ ದಿಕ್ಕಿನಲ್ಲಿ ಮತ್ತು ವಿರುದ್ಧ ದಿಕ್ಕಿನಲ್ಲಿ ಒಂದೇ ರೀತಿ ಓದಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, "ಅನ್ನಾ" ಒಂದು ಪಾಲಿಂಡ್ರೋಮ್, ಆದರೆ "ಟೇಬಲ್" ಮತ್ತು "ಜಾನ್" ಅಲ್ಲ.

ವೇದಿಕೆ

ಸ್ಟ್ರಿಂಗ್ ನೀಡಲಾಗಿದೆ; ಸ್ಟ್ರಿಂಗ್ ಪಾಲಿಂಡ್ರೋಮ್ ಆಗಿದ್ದರೆ true ಅನ್ನು ಹಿಂತಿರುಗಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಕಾರ್ಯವನ್ನು ನೀವು ಬರೆಯಬೇಕಾಗಿದೆ ಮತ್ತು ಇಲ್ಲದಿದ್ದರೆ ತಪ್ಪು. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು ಜಾಗಗಳು ಮತ್ತು ವಿರಾಮ ಚಿಹ್ನೆಗಳನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಬೇಕಾಗುತ್ತದೆ.

ಪಾಲಿಂಡ್ರೋಮ್('ರೇಸ್‌ಕಾರ್') === ನಿಜ
ಪಾಲಿಂಡ್ರೋಮ್ ('ಟೇಬಲ್') === ತಪ್ಪು

ಕಾರ್ಯವನ್ನು ವಿಶ್ಲೇಷಿಸೋಣ

ಇಲ್ಲಿ ಮುಖ್ಯ ಉಪಾಯವೆಂದರೆ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ರಿವರ್ಸ್ ಮಾಡುವುದು. "ರಿವರ್ಸ್" ಸ್ಟ್ರಿಂಗ್ ಮೂಲ ಒಂದಕ್ಕೆ ಸಂಪೂರ್ಣವಾಗಿ ಒಂದೇ ಆಗಿದ್ದರೆ, ನಾವು ಪಾಲಿಂಡ್ರೋಮ್ ಅನ್ನು ಸ್ವೀಕರಿಸಿದ್ದೇವೆ ಮತ್ತು ಕಾರ್ಯವು ನಿಜವಾಗಬೇಕು. ಇಲ್ಲದಿದ್ದರೆ, ಸುಳ್ಳು.

ನಿರ್ಧಾರವನ್ನು

ಪಾಲಿಂಡ್ರೋಮ್ ಅನ್ನು ಪರಿಹರಿಸುವ ಕೋಡ್ ಇಲ್ಲಿದೆ.

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('')
}

ಇನ್‌ಪುಟ್ ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿರುವ ಅಕ್ಷರಗಳನ್ನು ಲೋವರ್ ಕೇಸ್‌ಗೆ ಪರಿವರ್ತಿಸುವುದು ಮೊದಲ ಹಂತವಾಗಿದೆ. ಪ್ರೋಗ್ರಾಂ ಪಾತ್ರಗಳನ್ನು ಸ್ವತಃ ಹೋಲಿಸುತ್ತದೆ ಎಂಬುದಕ್ಕೆ ಇದು ಖಾತರಿಯಾಗಿದೆ, ಮತ್ತು ಕೇಸ್ ಅಥವಾ ಬೇರೆ ಯಾವುದನ್ನಾದರೂ ಅಲ್ಲ.

ಎರಡನೇ ಹಂತವು ರೇಖೆಯನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸುವುದು. ಇದನ್ನು ಮಾಡುವುದು ಕಷ್ಟವೇನಲ್ಲ: .ಸ್ಪ್ಲಿಟ್() ವಿಧಾನವನ್ನು (ಸ್ಟ್ರಿಂಗ್ ಲೈಬ್ರರಿ) ಬಳಸಿಕೊಂಡು ನೀವು ಅದನ್ನು ಅರೇ ಆಗಿ ಪರಿವರ್ತಿಸಬೇಕಾಗಿದೆ. ನಂತರ ನಾವು .reverse() (Array library) ಅನ್ನು ಬಳಸಿಕೊಂಡು ಅರೇ ಅನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸುತ್ತೇವೆ. .join() (Array library) ಅನ್ನು ಬಳಸಿಕೊಂಡು ರಿವರ್ಸ್ ಅರೇ ಅನ್ನು ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಪರಿವರ್ತಿಸುವುದು ಕೊನೆಯ ಹಂತವಾಗಿದೆ.

ಈಗ ನೀವು ಮಾಡಬೇಕಾಗಿರುವುದು "ರಿವರ್ಸ್" ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಮೂಲ ಸ್ಟ್ರಿಂಗ್‌ನೊಂದಿಗೆ ಹೋಲಿಸಿ, ಫಲಿತಾಂಶವನ್ನು ಸರಿ ಅಥವಾ ತಪ್ಪು ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

FizzBuzz

ಸಂದರ್ಶನಗಳಲ್ಲಿ ಅತ್ಯಂತ ಜನಪ್ರಿಯ ಕಾರ್ಯಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ.

ವೇದಿಕೆ

1 ರಿಂದ n ವರೆಗಿನ ಸಂಖ್ಯೆಗಳನ್ನು ಕನ್ಸೋಲ್‌ಗೆ ಮುದ್ರಿಸುವ ಕಾರ್ಯವನ್ನು ನೀವು ಬರೆಯಬೇಕಾಗಿದೆ, ಅಲ್ಲಿ n ಒಂದು ಪೂರ್ಣಾಂಕವಾಗಿದ್ದು, ಈ ಕೆಳಗಿನ ಷರತ್ತುಗಳೊಂದಿಗೆ ಕಾರ್ಯವು ನಿಯತಾಂಕವಾಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ:

3 ರ ಗುಣಕಗಳ ಬದಲಿಗೆ ಔಟ್ಪುಟ್ ಫಿಜ್;
5 ರ ಗುಣಾಕಾರವಾಗಿರುವ ಸಂಖ್ಯೆಗಳ ಬದಲಿಗೆ ಔಟ್‌ಪುಟ್ buzz;
3 ಮತ್ತು 5 ಎರಡರ ಗುಣಾಕಾರವಾಗಿರುವ ಸಂಖ್ಯೆಗಳ ಬದಲಿಗೆ fizzbuzz ಔಟ್‌ಪುಟ್.

ಉದಾಹರಣೆಗೆ

Fizzbuzz(5)

ಪರಿಣಾಮವಾಗಿ

// 1
// 2
// ಫಿಜ್
// 4
//buzz

ಕಾರ್ಯವನ್ನು ವಿಶ್ಲೇಷಿಸೋಣ

ಇಲ್ಲಿ ಮುಖ್ಯ ವಿಷಯವೆಂದರೆ JavaScript ಅನ್ನು ಬಳಸಿಕೊಂಡು ಮಲ್ಟಿಪಲ್‌ಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವ ಮಾರ್ಗವಾಗಿದೆ. ಮಾಡ್ಯುಲಸ್ ಆಪರೇಟರ್ ಅಥವಾ ಉಳಿದ -% ಅನ್ನು ಬಳಸಿಕೊಂಡು ಇದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು, ಇದು ಎರಡು ಸಂಖ್ಯೆಗಳನ್ನು ವಿಭಜಿಸುವಾಗ ಉಳಿದವನ್ನು ತೋರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಶೇಷವು 0 ಆಗಿದ್ದರೆ, ಇದರರ್ಥ ಮೊದಲ ಸಂಖ್ಯೆಯು ಎರಡನೆಯದಕ್ಕೆ ಬಹುಸಂಖ್ಯೆಯಾಗಿದೆ.

12% 5 // 2 -> 12 5 ರ ಗುಣಕವಲ್ಲ
12% 3 // 0 -> 12 3 ರ ಗುಣಕವಾಗಿದೆ

ಆದ್ದರಿಂದ, ನೀವು 12 ಅನ್ನು 5 ರಿಂದ ಭಾಗಿಸಿದರೆ, ನೀವು 2 ಅನ್ನು 2 ರ ಶೇಷದೊಂದಿಗೆ ಪಡೆಯುತ್ತೀರಿ. ನೀವು 12 ಅನ್ನು 3 ರಿಂದ ಭಾಗಿಸಿದರೆ, ನೀವು 4 ರ ಶೇಷದೊಂದಿಗೆ 0 ಅನ್ನು ಪಡೆಯುತ್ತೀರಿ. ಮೊದಲನೆಯ ಸಂದರ್ಭದಲ್ಲಿ, 12 5 ರ ಗುಣಕವಲ್ಲ, ಎರಡನೆಯದು , 12 ಎಂಬುದು 3 ರ ಗುಣಕವಾಗಿದೆ.

ನಿರ್ಧಾರವನ್ನು

ಸೂಕ್ತವಾದ ಪರಿಹಾರವು ಈ ಕೆಳಗಿನ ಕೋಡ್ ಆಗಿರುತ್ತದೆ:

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
ನಿ: 1 ನಾನು: 1
ಡಿ: 1 ಇ: 1
ಇ: 1 ನಿ: 1
ಆರ್: 1 ಡಿ: 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
}

ಬಳಕೆಗೆ ಗಮನ ಕೊಡಿ Object.keys() ಮೇಲಿನ ತುಣುಕಿನಲ್ಲಿ. ಈ ವಿಧಾನವು ಆಬ್ಜೆಕ್ಟ್‌ನಲ್ಲಿ ಗೋಚರಿಸುವ ಅದೇ ಕ್ರಮದಲ್ಲಿ ಹೆಸರುಗಳು ಅಥವಾ ಕೀಗಳನ್ನು ಹೊಂದಿರುವ ಸರಣಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ ರಚನೆಯು ಈ ರೀತಿ ಇರುತ್ತದೆ:

['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 ಆಗಿರುವಾಗ ನಾವು ನಿಲ್ಲಿಸುತ್ತೇವೆ.

ತೀರ್ಮಾನಕ್ಕೆ

ಹೆಚ್ಚಾಗಿ, ನೀವು ಮುಂಭಾಗ ಅಥವಾ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೆವಲಪರ್ ಕೆಲಸಕ್ಕಾಗಿ ಸಂದರ್ಶನ ಮಾಡಿದ್ದರೆ (ವಿಶೇಷವಾಗಿ ಇದು ಜೂನಿಯರ್ ಹಂತದಲ್ಲಿದ್ದರೆ) ನೀವು ಈಗಾಗಲೇ ಈ ಕಾರ್ಯಗಳಲ್ಲಿ ಯಾವುದನ್ನಾದರೂ ಎದುರಿಸಿದ್ದೀರಿ. ಆದರೆ ನೀವು ಅವುಗಳನ್ನು ನೋಡದಿದ್ದರೆ, ಭವಿಷ್ಯದಲ್ಲಿ ಅವು ಉಪಯುಕ್ತವಾಗಬಹುದು - ಕನಿಷ್ಠ ಸಾಮಾನ್ಯ ಅಭಿವೃದ್ಧಿಗೆ.

ಸ್ಕಿಲ್‌ಬಾಕ್ಸ್ ಶಿಫಾರಸು ಮಾಡುತ್ತದೆ:

ಆನ್‌ಲೈನ್ ಕೋರ್ಸ್ ಅನ್ನು ಅನ್ವಯಿಸಲಾಗಿದೆ "ಪೈಥಾನ್ ಡೇಟಾ ವಿಶ್ಲೇಷಕ".

ಆನ್‌ಲೈನ್ ಕೋರ್ಸ್ "ವೃತ್ತಿ ಮುಂಭಾಗದ ಡೆವಲಪರ್".

ಪ್ರಾಯೋಗಿಕ ಒಂದು ವರ್ಷದ ಕೋರ್ಸ್ "0 ರಿಂದ PRO ವರೆಗೆ PHP ಡೆವಲಪರ್".

ಮೂಲ: www.habr.com

5 ವಿಶಿಷ್ಟ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸಂದರ್ಶನ ಕಾರ್ಯಗಳು: ವಿಶ್ಲೇಷಣೆ ಮತ್ತು ಪರಿಹಾರಗಳು

ನಿಮ್ಮ ಸಂದರ್ಶನಕ್ಕೆ ಸಂಪೂರ್ಣವಾಗಿ ತಯಾರಿ ಮಾಡುವುದು ಮುಖ್ಯ ವಿಷಯ.

JavaScript ನಲ್ಲಿ ಟೆಂಪ್ಲೇಟ್ ಕಾರ್ಯಗಳು

ತೀರ್ಮಾನಕ್ಕೆ

ಕಾಮೆಂಟ್ ಅನ್ನು ಸೇರಿಸಿ Отменить ответ