ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಸೈಕ್ಲಿಕ್ ಪ್ಲೇಪಟ್ಟಿಗಳನ್ನು ಪತ್ತೆ ಮಾಡಲಾಗುತ್ತಿದೆ
ಕೋಡಿಂಗ್ ಸಂದರ್ಶನ ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಿಸುವಾಗ ಚಕ್ರಗಳು ಅಥವಾ ಪುನರಾವರ್ತನೆಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆಯಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ಲಿಂಕ್ ಮಾಡಿದ ಪಟ್ಟಿಗಳಂತಹ ಡೇಟಾ ರಚನೆಗಳ ಅಗತ್ಯವಿರುತ್ತದೆ. ಈ ಸಮಸ್ಯೆಯು ಸಾಮಾನ್ಯವಾಗಿ ಪ್ಲೇಪಟ್ಟಿಗಳಲ್ಲಿ ಉದ್ಭವಿಸುತ್ತದೆ, ಅಲ್ಲಿ ಹಾಡುಗಳು ಉಲ್ಲೇಖಗಳ ಸರಣಿಯಲ್ಲಿ ಒಂದಕ್ಕೊಂದು ಲಿಂಕ್ ಮಾಡಬಹುದು. ಒಂದು ಹಾಡು ಹಿಂದಿನ ಹಾಡನ್ನು ಉಲ್ಲೇಖಿಸಿದರೆ ಪ್ಲೇಪಟ್ಟಿ ಪುನರಾವರ್ತನೆಯಾಗುತ್ತದೆ ಎಂದು ಹೇಳಲಾಗುತ್ತದೆ.
ಈ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡಿಂಗ್ ವ್ಯಾಯಾಮದ ಉದ್ದೇಶವು ಪ್ಲೇಪಟ್ಟಿಯಲ್ಲಿ ಯಾವುದೇ ಹಾಡುಗಳು ಪುನರಾವರ್ತನೆಯಾಗುತ್ತದೆಯೇ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುವ ಕಾರ್ಯವನ್ನು ಬರೆಯುವುದು. ಇದು ಪ್ರತಿ ಹಾಡಿನ ಮೇಲೆ ಒಂದೊಂದಾಗಿ ಹೋಗುತ್ತಿದೆ ಮತ್ತು ಹಿಂದಿನ ಹಾಡಿಗೆ ಹಿಂತಿರುಗುವ ಉಲ್ಲೇಖವಿದೆಯೇ ಎಂದು ನೋಡುತ್ತಿದೆ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಈ ತೋರಿಕೆಯಲ್ಲಿ ನೇರವಾದ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಪ್ರಯತ್ನಿಸುವಾಗ ಅನುಭವಿ ಪ್ರೋಗ್ರಾಮರ್‌ಗಳು ಆಬ್ಜೆಕ್ಟ್ ಉಲ್ಲೇಖಗಳು ಮತ್ತು ಲೂಪ್ ನಿಯಂತ್ರಣದ ಸೂಕ್ಷ್ಮತೆಗಳ ಮೇಲೆ ಎಡವಿ ಬೀಳಬಹುದು.
ಆಗಾಗ್ಗೆ, ಸಮಸ್ಯೆಯು ಪುನರಾವರ್ತನೆಯ ತರ್ಕವನ್ನು ವ್ಯಕ್ತಪಡಿಸುವ ವಿಧಾನದಿಂದ ಉಂಟಾಗುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ವಸ್ತುಗಳ ನಡುವಿನ ಉಲ್ಲೇಖಗಳನ್ನು ನಿರ್ವಹಿಸುವ ವಿಧಾನದಿಂದ. ಈ ನಿದರ್ಶನದಲ್ಲಿ, ಲೂಪ್‌ಗಳ ಒಳಗೆ ಆಬ್ಜೆಕ್ಟ್ ಉಲ್ಲೇಖಗಳನ್ನು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ನಿಮ್ಮ ಸಾಮರ್ಥ್ಯದ ಮೇಲೆ ಪರಿಹಾರವು ಅವಲಂಬಿತವಾಗಿರುತ್ತದೆ. ನಾವು ಪರಿಹಾರವನ್ನು ಪರಿಶೀಲಿಸುವಾಗ ಪ್ಲೇಪಟ್ಟಿಯಲ್ಲಿ ಈ ಉಲ್ಲೇಖಗಳನ್ನು ಹೇಗೆ ಸೂಕ್ತವಾಗಿ ಮರುಹೊಂದಿಸುವುದು ಮತ್ತು ಟ್ರ್ಯಾಕ್ ಮಾಡುವುದು ಎಂಬುದರ ಕುರಿತು ನಾವು ಗಮನಹರಿಸುತ್ತೇವೆ.
ನಾವು ಸಮಸ್ಯೆಯನ್ನು ವಿವರವಾಗಿ ವಿಂಗಡಿಸುತ್ತೇವೆ, ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪರಿಹಾರದ ನ್ಯೂನತೆಗಳನ್ನು ನೋಡುತ್ತೇವೆ ಮತ್ತು ಮುಂದಿನ ಚರ್ಚೆಯಲ್ಲಿ ಈ ಮರುಕಳಿಸುವ ಪ್ಲೇಪಟ್ಟಿ ಅಡಚಣೆಗೆ ಕಾರ್ಯಸಾಧ್ಯವಾದ ಪರಿಹಾರವನ್ನು ನೀಡುತ್ತೇವೆ. ಈ ಸರಿಪಡಿಸುವಿಕೆಯೊಂದಿಗೆ, ಕಾರ್ಯವು ಪ್ಲೇಪಟ್ಟಿಯಲ್ಲಿ ಆವರ್ತಕ ಉಲ್ಲೇಖಗಳನ್ನು ನಿಖರವಾಗಿ ಗುರುತಿಸಲು ಮತ್ತು ಉದ್ದೇಶಿತ ಫಲಿತಾಂಶವನ್ನು ಉತ್ಪಾದಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.
| ಆಜ್ಞೆ | ಬಳಕೆಯ ಉದಾಹರಣೆ |
|---|---|
| Set() | ಅನನ್ಯ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು JavaScript ಸೆಟ್() ವಸ್ತುವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಪ್ಲೇಪಟ್ಟಿ ಚಕ್ರಗಳನ್ನು ಗುರುತಿಸಲು ಸಹಾಯ ಮಾಡಲು, ವೀಕ್ಷಿಸಿದ ಹಾಡುಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಉದಾಹರಣೆಯಲ್ಲಿ ಬಳಸಿಕೊಳ್ಳಲಾಗುತ್ತದೆ, ಯಾವುದೇ ಹಾಡನ್ನು ಮತ್ತೆ ಪ್ಲೇ ಮಾಡಲಾಗುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. |
| has() | ಸೆಟ್ () ವಸ್ತುವು ಹ್ಯಾಸ್ () ಕಾರ್ಯವನ್ನು ಹೊಂದಿದೆ. ಸೆಟ್‌ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಅಂಶವಿದೆಯೇ ಎಂದು ಇದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಇಲ್ಲಿ, ಪ್ಲೇಪಟ್ಟಿ ಪುನರಾವರ್ತನೆಯಾಗುತ್ತಿದೆ ಎಂದು ಸೂಚಿಸುವ ಹಾಡನ್ನು ಈಗಾಗಲೇ ಕೇಳಲಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. |
| add() | ಸೆಟ್ () ವಸ್ತುವು ಹ್ಯಾಸ್ () ಕಾರ್ಯವನ್ನು ಹೊಂದಿದೆ. ನಿರ್ದಿಷ್ಟ ಅಂಶವು ಸೆಟ್‌ನಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಎಂದು ಇದು ಪರೀಕ್ಷಿಸುತ್ತದೆ. ಇಲ್ಲಿ, ಪ್ಲೇಪಟ್ಟಿ ಪುನರಾವರ್ತನೆಯಾಗುತ್ತಿದೆ ಎಂದು ಸೂಚಿಸುವ ಹಾಡನ್ನು ಈಗಾಗಲೇ ಕೇಳಲಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. |
| two-pointer technique | ಈ ವಿಧಾನವನ್ನು ಕೆಲವೊಮ್ಮೆ ಫ್ಲಾಯ್ಡ್-ವಾರ್ಷಲ್ ಸೈಕಲ್ ಪತ್ತೆ ಅಲ್ಗಾರಿದಮ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ, ಎರಡು ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ಲೇಪಟ್ಟಿಯನ್ನು ನ್ಯಾವಿಗೇಟ್ ಮಾಡುತ್ತದೆ: ನಿಧಾನ ಮತ್ತು ವೇಗ. ಲೂಪ್‌ಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಪತ್ತೆಹಚ್ಚಲು, ನಿಧಾನ ಪಾಯಿಂಟರ್ ಒಂದು ಹೆಜ್ಜೆ ಚಲಿಸುತ್ತದೆ ಆದರೆ ವೇಗದ ಪಾಯಿಂಟರ್ ಎರಡು ಹಂತಗಳನ್ನು ಹೋಗುತ್ತದೆ. |
| nextSong | ಸಾಂಗ್ ಕ್ಲಾಸ್ ನೆಕ್ಸ್ಟ್ ಸಾಂಗ್ ಎಂಬ ವಿಶಿಷ್ಟ ಆಸ್ತಿಯನ್ನು ಹೊಂದಿದ್ದು ಅದು ಪ್ಲೇಪಟ್ಟಿಯಲ್ಲಿ ಅದರ ನಂತರ ಬರುವ ಹಾಡನ್ನು ಉಲ್ಲೇಖಿಸುತ್ತದೆ. ಇದು ಪ್ರತಿ ಹಾಡು ಅನುಕ್ರಮವಾಗಿ ಪ್ರತಿ ಇತರ ಹಾಡನ್ನು ಉಲ್ಲೇಖಿಸುವ ಲಿಂಕ್ ಪಟ್ಟಿ ರಚನೆಯ ಅನುಕರಣೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. |
| describe() | ಸಂಬಂಧಿತ ಘಟಕ ಪರೀಕ್ಷೆಗಳನ್ನು ಸಂಘಟಿಸಲು ಮೋಚಾ ಪರೀಕ್ಷಾ ಚೌಕಟ್ಟಿನ ವಿವರಣೆ() ಕಾರ್ಯವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಇದು ಪರೀಕ್ಷೆಗಳನ್ನು ತಾರ್ಕಿಕ ವರ್ಗಗಳಾಗಿ ವಿಭಜಿಸುತ್ತದೆ, ಅಂತಹ ಪ್ಲೇಪಟ್ಟಿಗಳು ಪುನರಾವರ್ತಿಸುವ ಮತ್ತು ಮಾಡದಿರುವವುಗಳು. |
| it() | ಮೋಚಾದಲ್ಲಿ, ಪರೀಕ್ಷಾ ಪ್ರಕರಣದ ವ್ಯಾಖ್ಯಾನವನ್ನು ಇದನ್ನು () ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಇದು ಪರೀಕ್ಷಿಸಬೇಕಾದ ನಿರ್ದಿಷ್ಟ ಪ್ರಕರಣವನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಅಂತಹ ಕಾರ್ಯವು ಮರುಕಳಿಸುವ ಪ್ಲೇಪಟ್ಟಿಯನ್ನು ಸೂಕ್ತವಾಗಿ ಗುರುತಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. |
| assert.strictEqual() | ಈ ವಿಧಾನವು Node.js ನಲ್ಲಿನ ದೃಢೀಕರಣ ಮಾಡ್ಯೂಲ್‌ನಿಂದ ಬಂದಿದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಎರಡು ಮೌಲ್ಯಗಳು ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಸಮಾನವಾಗಿದೆಯೇ ಎಂದು ನಿರ್ಧರಿಸುವ ಮೂಲಕ ಪ್ಲೇಪಟ್ಟಿ ಪುನರಾವರ್ತನೆಯ ಕಾರ್ಯದ ಭವಿಷ್ಯ ಫಲಿತಾಂಶವನ್ನು ಇದು ಪರಿಶೀಲಿಸುತ್ತದೆ. |
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಪ್ಲೇಪಟ್ಟಿ ಸೈಕಲ್ ಪತ್ತೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು
ನೀಡಲಾದ ಮೊದಲ ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರತಿ ಹಾಡನ್ನು ನೋಡ್‌ನಂತೆ ಪರಿಗಣಿಸುವ ಮೂಲಕ ಪ್ಲೇಪಟ್ಟಿಯಲ್ಲಿ ಪುನರಾವರ್ತನೆಯಾಗುವ ಹಾಡುಗಳನ್ನು ಗುರುತಿಸಲು ಲಿಂಕ್ಡ್ ಲಿಸ್ಟ್ ವಿಧಾನವನ್ನು ಬಳಸುತ್ತದೆ. JavaScript ನ ವರ್ಗ ರಚನೆಯನ್ನು ನಿರ್ಮಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ a ಹಾಡು ಹಾಡಿನ ಹೆಸರು ಮತ್ತು ಮುಂದಿನ ಹಾಡಿನ ಉಲ್ಲೇಖವನ್ನು ಸಂಗ್ರಹಿಸುವ ಮೂಲಕ ಟ್ರ್ಯಾಕ್‌ನಿಂದ ಟ್ರ್ಯಾಕ್‌ಗೆ ಪ್ಲೇಪಟ್ಟಿಯ ಹರಿವನ್ನು ಅನುಕರಿಸುವ ವಸ್ತು. ಪರಿಹಾರ ಟ್ರ್ಯಾಕ್‌ಗಳ ಮುಖ್ಯ ಅಂಶವು ಹಿಂದೆ ಸಂಗೀತವನ್ನು ಬಳಸಿ ಎದುರಿಸಿತು ಹೊಂದಿಸಿ. ಹಾಡುಗಳ ಮೂಲಕ ಪುನರಾವರ್ತಿಸಲು ನಾವು ಸ್ವಲ್ಪ ಸಮಯದ ಲೂಪ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಪ್ರಸ್ತುತ ಹಾಡನ್ನು ಮೊದಲು ಕೇಳಲಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತೇವೆ. ಹಾಗಿದ್ದಲ್ಲಿ, ನಿಜವನ್ನು ಹಿಂತಿರುಗಿಸುವ ಮೂಲಕ ಪ್ಲೇಪಟ್ಟಿ ಪುನರಾವರ್ತನೆಯಾಗುತ್ತಿದೆ ಎಂದು ನಾವು ಸೂಚಿಸುತ್ತೇವೆ.
ಫ್ಲಾಯ್ಡ್‌ನ ಸೈಕಲ್ ಪತ್ತೆ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಎರಡು-ಪಾಯಿಂಟರ್ ತಂತ್ರ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ, ಇದನ್ನು ಎರಡನೇ ರೀತಿಯಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ. ಈ ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು, ಎರಡು ಪಾಯಿಂಟರ್‌ಗಳು ಪ್ಲೇಪಟ್ಟಿಯ ಮೂಲಕ ಪ್ರತ್ಯೇಕ ವೇಗದಲ್ಲಿ ಚಲಿಸುತ್ತವೆ: ಒಂದು ಎರಡು ಹಾಡುಗಳನ್ನು ಬಿಟ್ಟು ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಹಾಡನ್ನು ಮುಂದಕ್ಕೆ ಚಲಿಸುತ್ತದೆ. ಪ್ಲೇಪಟ್ಟಿ ಪುನರಾವರ್ತನೆಯಾಗುತ್ತದೆ ಎಂದು ಸೂಚಿಸುವ ಚಕ್ರವಿದ್ದರೆ ಈ ಪಾಯಿಂಟರ್‌ಗಳು ಅಂತಿಮವಾಗಿ ಭೇಟಿಯಾಗುತ್ತವೆ. ಇದು ಕಂಡುಬರುವ ಹಾಡುಗಳನ್ನು ಉಳಿಸುವ ಅಗತ್ಯವಿಲ್ಲದ ಕಾರಣ, ಈ ವಿಧಾನವು ಹೆಚ್ಚು ಸ್ಥಳ-ಸಮರ್ಥವಾಗಿದೆ ಮತ್ತು ಆದ್ದರಿಂದ ದೊಡ್ಡ ಪ್ಲೇಪಟ್ಟಿಗಳಿಗೆ ಉತ್ತಮ ಆಯ್ಕೆಯಾಗಿದೆ.
ಈ ಪರಿಹಾರಗಳು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಲಿಂಕ್ ಮಾಡಿದ ಪಟ್ಟಿಗಳನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂಬುದನ್ನು ಸಹ ತೋರಿಸುತ್ತವೆ ಮುಂದಿನ ಹಾಡು ಪ್ರತಿಯೊಂದು ಆಸ್ತಿ ಲಿಂಕ್‌ಗಳು ಹಾಡು ಇನ್ನೊಂದನ್ನು ಆಕ್ಷೇಪಿಸಿ. ಮೊದಲ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಸೈಕಲ್ ಪತ್ತೆಯು ಸೆಟ್ ರಚನೆಯ ಪ್ರಯೋಜನವನ್ನು ನೀಡುತ್ತದೆ. ಸೆಟ್‌ಗಳು ಅನನ್ಯತೆಯನ್ನು ಖಾತ್ರಿಪಡಿಸುವ ಕಾರಣ, ಅದನ್ನು ಸೆಟ್‌ಗೆ ಸೇರಿಸಿದ ನಂತರ ಹಾಡನ್ನು ಈಗಾಗಲೇ ಪ್ಲೇ ಮಾಡಲಾಗಿದೆಯೇ ಎಂದು ನಾವು ತಕ್ಷಣ ನಿರ್ಧರಿಸಬಹುದು. ಇದು ಸೆಟ್‌ಗಳನ್ನು ವಿಶೇಷವಾಗಿ ಸಹಾಯಕವಾಗಿಸುತ್ತದೆ. ಚಕ್ರವು ಯಾವಾಗ ಪ್ರಾರಂಭವಾಗುತ್ತಿದೆ ಎಂಬುದನ್ನು ಗುರುತಿಸಲು ಇದು ನಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ ಮತ್ತು ಅಂತ್ಯವಿಲ್ಲದ ಲೂಪ್‌ನಲ್ಲಿ ಸಿಲುಕಿಕೊಳ್ಳದಂತೆ ತಡೆಯುತ್ತದೆ.
ಕೊನೆಯದಾಗಿ, ಎರಡೂ ತಂತ್ರಗಳಿಗೆ ಸೇರಿಸಲಾದ ಘಟಕ ಪರೀಕ್ಷೆಗಳು ವಿವಿಧ ಸೆಟ್ಟಿಂಗ್‌ಗಳಲ್ಲಿ ಪರಿಹಾರವು ನಿಖರವಾಗಿದೆ ಎಂದು ಖಾತರಿಪಡಿಸುತ್ತದೆ. ನಮ್ಮ ಕೋಡ್ ಅನ್ನು ಪರಿಶೀಲಿಸಲು, ನಾವು ಮೋಚಾ ಪರೀಕ್ಷಾ ಚೌಕಟ್ಟನ್ನು ಬಳಸಿದ್ದೇವೆ. Node.js ಪ್ರತಿಪಾದಿಸುತ್ತಾರೆ ಔಟ್‌ಪುಟ್‌ಗಳು ನಿರೀಕ್ಷೆಯಂತೆ ಮತ್ತು ಮೋಚಾ ಎಂದು ಖಚಿತಪಡಿಸಲು ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ ವಿವರಿಸಿ ಮತ್ತು ಇದು ಪರೀಕ್ಷೆಗಳನ್ನು ತಾರ್ಕಿಕವಾಗಿ ರೂಪಿಸಲು ಕಾರ್ಯಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಘಟಕ ಪರೀಕ್ಷೆಗಳು ಅಭಿವೃದ್ಧಿ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ನಿರ್ಣಾಯಕ ಪಾತ್ರವನ್ನು ವಹಿಸುತ್ತವೆ ಏಕೆಂದರೆ ಕಾರ್ಯವು ಪುನರಾವರ್ತಿತ ಮತ್ತು ಪುನರಾವರ್ತಿತವಲ್ಲದ ಪ್ಲೇಪಟ್ಟಿಗಳಿಗೆ ನಿರೀಕ್ಷೆಯಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಪರಿಹಾರದ ಸ್ಥಿತಿಸ್ಥಾಪಕತ್ವದ ಮೇಲೆ ಭರವಸೆ ನೀಡುತ್ತದೆ.
JavaScript ನೊಂದಿಗೆ ಪ್ಲೇಪಟ್ಟಿಯಲ್ಲಿ ಪುನರಾವರ್ತಿತ ಹಾಡುಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು
ಲೂಪ್‌ಗಳೊಂದಿಗೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್
class Song {constructor(name) {this.name = name;this.nextSong = null;}/* @return {boolean} true if the playlist is repeating, false if not.*/isRepeatingPlaylist() {let seenSongs = new Set();let current = this;while (current) {if (seenSongs.has(current)) {return true; // Playlist is repeating}seenSongs.add(current);current = current.nextSong;}return false; // Playlist is not repeating}}// Testing the solutionlet first = new Song("Hello");let second = new Song("Eye of the Tiger");let third = new Song("Third");first.nextSong = second;second.nextSong = third;third.nextSong = first; // Creates a loopconsole.log(first.isRepeatingPlaylist()); // true
ಪರ್ಯಾಯ ವಿಧಾನ: ಸೈಕಲ್ ಪತ್ತೆಗಾಗಿ ಎರಡು ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಬಳಸುವುದು
ಫ್ಲಾಯ್ಡ್-ವಾರ್ಷಲ್ ಅಲ್ಗಾರಿದಮ್‌ನೊಂದಿಗೆ ಲಿಂಕ್ಡ್ ಲಿಸ್ಟ್ ಸೈಕಲ್ ಪತ್ತೆ
class Song {constructor(name) {this.name = name;this.nextSong = null;}/* @return {boolean} true if the playlist is repeating, false if not.*/isRepeatingPlaylist() {let slow = this;let fast = this;while (fast !== null && fast.nextSong !== null) {slow = slow.nextSong; // move slow pointer by 1 stepfast = fast.nextSong.nextSong; // move fast pointer by 2 stepsif (slow === fast) {return true; // Loop detected}}return false; // No loop}}// Testing the solutionlet first = new Song("Hello");let second = new Song("Eye of the Tiger");let third = new Song("Third");first.nextSong = second;second.nextSong = third;third.nextSong = first; // Creates a loopconsole.log(first.isRepeatingPlaylist()); // true
ಪ್ಲೇಪಟ್ಟಿ ಲೂಪ್ ಪತ್ತೆಗಾಗಿ ಘಟಕ ಪರೀಕ್ಷೆ
Node.js ಮತ್ತು Mocha ನೊಂದಿಗೆ isRepeatingPlaylist ಕಾರ್ಯವನ್ನು ಪರೀಕ್ಷಿಸಲಾಗುತ್ತಿದೆ
const assert = require('assert');describe('isRepeatingPlaylist', function () {it('should return true for a repeating playlist', function () {let first = new Song('Song A');let second = new Song('Song B');let third = new Song('Song C');first.nextSong = second;second.nextSong = third;third.nextSong = first; // Creates a loopassert.strictEqual(first.isRepeatingPlaylist(), true);});it('should return false for a non-repeating playlist', function () {let first = new Song('Song A');let second = new Song('Song B');let third = new Song('Song C');first.nextSong = second;second.nextSong = third;assert.strictEqual(first.isRepeatingPlaylist(), false);});});
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಸುಧಾರಿತ ಪ್ಲೇಪಟ್ಟಿ ಲೂಪ್ ಪತ್ತೆ ತಂತ್ರಗಳು
ಪರಿಭಾಷೆಯಲ್ಲಿ ಪ್ಲೇಪಟ್ಟಿಯ ಮೂಲಭೂತ ರಚನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಲಿಂಕ್ ಮಾಡಿದ ಪಟ್ಟಿಗಳು ಪ್ಲೇಪಟ್ಟಿ ಲೂಪ್ ಪತ್ತೆಗೆ ಆಸಕ್ತಿದಾಯಕ ಭಾಗವಾಗಿದೆ. ಪುನರಾವರ್ತನೆಯಾಗದ ಪ್ಲೇಪಟ್ಟಿಯಲ್ಲಿರುವ ಪ್ರತಿಯೊಂದು ಹಾಡು ಅದರ ಹಿಂದಿನದಕ್ಕೆ ಲಿಂಕ್ ಮಾಡುತ್ತದೆ, ಆ ಹಾಡಿಗೆ ಯಾವುದೇ ಹೆಚ್ಚಿನ ಉಲ್ಲೇಖಗಳಿಲ್ಲ ಮತ್ತು ಪಟ್ಟಿಯು ಕೊನೆಗೊಳ್ಳುವವರೆಗೆ. ಒಂದು ಹಾಡು ಹಿಂದಿನದನ್ನು ಉಲ್ಲೇಖಿಸಿದಾಗ ನಾವು ಚಕ್ರವನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ, ಆದ್ದರಿಂದ ಒಂದು ಅರ್ಥದಲ್ಲಿ ಪಟ್ಟಿ "ಅನಂತ". ಈ ರೀತಿಯ ಚಕ್ರಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಪ್ಲೇಪಟ್ಟಿಗಳಿಗೆ ಮಾತ್ರವಲ್ಲದೆ ಮೆಮೊರಿ ಹಂಚಿಕೆ ಮತ್ತು ರೂಟಿಂಗ್ ಅಲ್ಗಾರಿದಮ್‌ಗಳಿಗೂ ಮುಖ್ಯವಾಗಿದೆ.
ಪಾಯಿಂಟರ್ ತಂತ್ರಗಳು ಮತ್ತು ರಚನೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಈ ಚಕ್ರಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಕಂಡುಹಿಡಿಯಬಹುದು ಹೊಂದಿಸಿ. ಏಕೆಂದರೆ ಇದು ಅನನ್ಯತೆಯನ್ನು ಖಾತ್ರಿಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಚಕ್ರವನ್ನು ಪ್ರಾರಂಭಿಸದೆ ಹಾಡುಗಳನ್ನು ಮರುಭೇಟಿ ಮಾಡುವುದನ್ನು ತಡೆಯುತ್ತದೆ, ದಿ ಹೊಂದಿಸಿ ವಿಶೇಷವಾಗಿ ಸಹಾಯಕವಾಗಿದೆ. ಇದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ, ಫ್ಲಾಯ್ಡ್-ವಾರ್ಷಲ್ ಎರಡು-ಪಾಯಿಂಟರ್ ವಿಧಾನವು ಬಾಹ್ಯಾಕಾಶ-ಆಪ್ಟಿಮೈಸ್ಡ್ ಪರಿಹಾರವಾಗಿದೆ, ಇದರಲ್ಲಿ ಎರಡು ಚಲಿಸುವ ಉಲ್ಲೇಖಗಳು ಅಥವಾ ಪಾಯಿಂಟರ್‌ಗಳು ವಿಭಿನ್ನ ವೇಗವನ್ನು ಹೊಂದಿರುತ್ತವೆ. ಅವರು ಒಟ್ಟಿಗೆ ಬಂದರೆ, ಒಂದು ಮಾದರಿಯು ಕಂಡುಬರುತ್ತದೆ.
ಈ ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮಾಡುವ ಮೂಲಕ, ಸಾವಿರಾರು ಹಾಡುಗಳನ್ನು ಹೊಂದಿರುವ ಪ್ಲೇಪಟ್ಟಿಗಳನ್ನು ತ್ವರಿತವಾಗಿ ಪರಿಶೀಲಿಸಲು ಸಾಧ್ಯವಿದೆ. ಎರಡು-ಪಾಯಿಂಟರ್ ತಂತ್ರವು ಮೆಮೊರಿ ಬಳಕೆ ಸಮಸ್ಯೆಯಾಗಿರುವಾಗ ಸನ್ನಿವೇಶಗಳಿಗೆ ಪರಿಪೂರ್ಣವಾಗಿದೆ ಏಕೆಂದರೆ ಇದು O(n) ಸಮಯದ ಸಂಕೀರ್ಣತೆ ಮತ್ತು O(1) ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆಯನ್ನು ಹೊಂದಿದೆ. ಇದಲ್ಲದೆ, ವಿವಿಧ ಸೆಟ್ಟಿಂಗ್‌ಗಳಲ್ಲಿ ಲೂಪಿಂಗ್ ಮತ್ತು ಲೂಪಿಂಗ್ ಅಲ್ಲದ ಪ್ಲೇಪಟ್ಟಿಗಳನ್ನು ಪತ್ತೆಹಚ್ಚುವ ಮೋಚಾದೊಂದಿಗೆ ಮಾಡಲಾದಂತಹ ಯುನಿಟ್ ಪರೀಕ್ಷೆಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಮೂಲಕ ನಮ್ಮ ಪರಿಹಾರಗಳು ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ.
ಪ್ಲೇಪಟ್ಟಿ ಸೈಕಲ್ ಪತ್ತೆ ಬಗ್ಗೆ ಸಾಮಾನ್ಯವಾಗಿ ಕೇಳಲಾಗುವ ಪ್ರಶ್ನೆಗಳು
- ಪ್ಲೇಪಟ್ಟಿಯಲ್ಲಿ ಸೈಕಲ್ ಎಂದರೇನು?
- ಪ್ಲೇಪಟ್ಟಿಯಲ್ಲಿನ ಹಾಡು ಹಿಂದಿನ ಹಾಡನ್ನು ಉಲ್ಲೇಖಿಸಿದಾಗ, ಸೈಕಲ್ ಎಂದು ಕರೆಯಲ್ಪಡುವ ಲೂಪಿಂಗ್ ಅನುಕ್ರಮವನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ.
- ಎರಡು-ಪಾಯಿಂಟರ್ ತಂತ್ರವು ಚಕ್ರವನ್ನು ಹೇಗೆ ಪತ್ತೆ ಮಾಡುತ್ತದೆ?
- ವೇಗದ ಪಾಯಿಂಟರ್ ಎರಡು ಹಂತಗಳನ್ನು ಚಲಿಸುತ್ತದೆ, ಮತ್ತು ನಿಧಾನ ಪಾಯಿಂಟರ್ ಎರಡು-ಪಾಯಿಂಟರ್ ತಂತ್ರವನ್ನು ಬಳಸಿಕೊಂಡು ಒಂದು ಹಂತಕ್ಕೆ ಚಲಿಸುತ್ತದೆ. ಅವರು ಒಟ್ಟಿಗೆ ಬಂದರೆ, ಒಂದು ಲೂಪ್ ಇರುತ್ತದೆ.
- ಏಕೆ ಎ Set ಸೈಕಲ್ ಪತ್ತೆಗೆ ಬಳಸಲಾಗಿದೆಯೇ?
- ಎ Set, ವಿಭಿನ್ನ ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ. ಆಲಿಸಿದ ಸಂಗೀತದ ಟಿಪ್ಪಣಿಯನ್ನು ಇಟ್ಟುಕೊಳ್ಳುವುದು ಸಹಾಯಕವಾಗಿದೆ. ಸಂಗೀತವನ್ನು ಮತ್ತೆ ನುಡಿಸಿದರೆ ಲೂಪ್ ಅನ್ನು ಗುರುತಿಸಲಾಗುತ್ತದೆ.
- ಇತರ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ ನಾನು ಈ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಬಳಸಬಹುದೇ?
- ವಾಸ್ತವವಾಗಿ, ಚಕ್ರ ಪತ್ತೆ ತಂತ್ರವನ್ನು ಬಳಸಿಕೊಂಡು ಲಿಂಕ್ ಮಾಡಿದ ಪಟ್ಟಿಗಳು, ಮೆಮೊರಿ ನಿರ್ವಹಣೆ ಮತ್ತು ನೆಟ್‌ವರ್ಕ್ ರೂಟಿಂಗ್‌ನಲ್ಲಿ ಲೂಪ್‌ಗಳನ್ನು ಗುರುತಿಸಲು ಬಹಳಷ್ಟು ಕೆಲಸಗಳು ಹೋಗುತ್ತದೆ.
- ನಾವು ಏಕೆ ಬಳಸುತ್ತೇವೆ while ಪ್ಲೇಪಟ್ಟಿ ಟ್ರಾವರ್ಸಲ್‌ನಲ್ಲಿ ಲೂಪ್‌ಗಳು?
- ಅನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ಪ್ಲೇಪಟ್ಟಿಯ ಮೂಲಕ ಪುನರಾವರ್ತಿತವಾಗಿ ಹೋಗಬಹುದು while ನಾವು ಚಕ್ರವನ್ನು ಕಂಡುಕೊಳ್ಳುವವರೆಗೆ ಅಥವಾ ಪಟ್ಟಿಯ ಅಂತ್ಯಕ್ಕೆ ಹೋಗುವವರೆಗೆ ಲೂಪ್ ಮಾಡಿ.
ಪುನರಾವರ್ತಿತ ಪ್ಲೇಪಟ್ಟಿಗಳನ್ನು ಪತ್ತೆಹಚ್ಚುವಲ್ಲಿ ಅಂತಿಮ ಆಲೋಚನೆಗಳು
ವಿಶೇಷವಾಗಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಆಬ್ಜೆಕ್ಟ್ ರೆಫರೆನ್ಸ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್ ಅನ್ನು ನ್ಯಾವಿಗೇಟ್ ಮಾಡುವಾಗ ಪ್ಲೇಪಟ್ಟಿಯಲ್ಲಿ ಸೈಕಲ್‌ಗಳನ್ನು ಗುರುತಿಸಲು ಕಷ್ಟವಾಗಬಹುದು. ಆದಾಗ್ಯೂ, ನಾವು ಈ ಸಮಸ್ಯೆಯನ್ನು ಸಮರ್ಥವಾಗಿ ನಿಭಾಯಿಸಬಹುದು ಮತ್ತು ಎರಡು-ಪಾಯಿಂಟರ್ ತಂತ್ರವನ್ನು ಅನ್ವಯಿಸುವ ಅಥವಾ ಸೆಟ್‌ನೊಂದಿಗೆ ಹಾಡಿನ ಉಲ್ಲೇಖಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವಂತಹ ತಂತ್ರಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಮೂಲಕ ನಮ್ಮ ಕೋಡ್ ಅನ್ನು ಸುವ್ಯವಸ್ಥಿತಗೊಳಿಸಬಹುದು.
ಈ ತಂತ್ರಗಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ತಿಳಿದುಕೊಳ್ಳುವುದು ಸಮಸ್ಯೆಗಳನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಪರಿಹರಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ, ನೀವು ಇದನ್ನು ಕೋಡಿಂಗ್ ಸಂದರ್ಶನಕ್ಕಾಗಿ ಅಥವಾ ಪ್ರಾಯೋಗಿಕ ಬಳಕೆಗಳಿಗಾಗಿ ನಿಭಾಯಿಸುತ್ತಿರಲಿ. ನಂತಹ ಪರಿಣಾಮಕಾರಿ ರಚನೆಗಳನ್ನು ಬಳಸುವುದು ಹೊಂದಿಸಿ ಮತ್ತು ಚಕ್ರ ಪತ್ತೆಯಲ್ಲಿ ಪಾಯಿಂಟರ್‌ಗಳು ಹೇಗೆ ಸಹಾಯ ಮಾಡುತ್ತವೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಕಲಿಯಬೇಕಾದ ಮುಖ್ಯ ಪಾಠಗಳಾಗಿವೆ.
ಪ್ಲೇಪಟ್ಟಿ ಸೈಕಲ್ ಪತ್ತೆಗಾಗಿ ಸಂಪನ್ಮೂಲಗಳು ಮತ್ತು ಉಲ್ಲೇಖಗಳು
- ಪ್ಲೇಪಟ್ಟಿ ಸೈಕಲ್ ಪತ್ತೆ ಅಲ್ಗಾರಿದಮ್‌ಗಳಿಗೆ ಸ್ಪೂರ್ತಿಯನ್ನು ಫ್ಲಾಯ್ಡ್-ವಾರ್ಷಲ್ ಅಲ್ಗಾರಿದಮ್‌ನಂತಹ ಸಾಮಾನ್ಯ ಲಿಂಕ್ ಪಟ್ಟಿ ಸಮಸ್ಯೆಗಳು ಮತ್ತು ತಂತ್ರಗಳಿಂದ ಪಡೆಯಲಾಗಿದೆ. ಈ ಸಮಗ್ರ ಸಂಪನ್ಮೂಲದಲ್ಲಿ ಲಿಂಕ್ ಮಾಡಿದ ಪಟ್ಟಿಗಳು ಮತ್ತು ಸೈಕಲ್ ಪತ್ತೆಹಚ್ಚುವಿಕೆಯ ಕುರಿತು ಇನ್ನಷ್ಟು ತಿಳಿಯಿರಿ: ವಿಕಿಪೀಡಿಯಾದಲ್ಲಿ ಸೈಕಲ್ ಪತ್ತೆ .
- ಬಳಸಿದ ಮತ್ತೊಂದು ಉತ್ತಮ ಸಂಪನ್ಮೂಲವೆಂದರೆ ಸೆಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗಾಗಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ದಸ್ತಾವೇಜನ್ನು, ಇದು ಮೊದಲ ಪರಿಹಾರ ವಿಧಾನದಲ್ಲಿ ಪ್ರಮುಖ ಪಾತ್ರವನ್ನು ವಹಿಸುತ್ತದೆ: MDN ನಲ್ಲಿ JavaScript ಹೊಂದಿಸಲಾಗಿದೆ .
- ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಹೆಚ್ಚು ವಿವರವಾದ ಪರೀಕ್ಷಾ ತಂತ್ರಗಳಿಗಾಗಿ, ಪರೀಕ್ಷಾ ರಚನೆ ಮತ್ತು ಸಮರ್ಥನೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮೋಚಾದ ಅಧಿಕೃತ ದಾಖಲಾತಿಯು ಪ್ರಮುಖ ಮೂಲವಾಗಿದೆ: ಮೋಚಾ ಪರೀಕ್ಷಾ ಚೌಕಟ್ಟು .
- ಎರಡು-ಪಾಯಿಂಟರ್ ತಂತ್ರದ ಕುರಿತು ಈ ಮಾರ್ಗದರ್ಶಿಯನ್ನು ಎಕ್ಸ್‌ಪ್ಲೋರ್ ಮಾಡಿ, ಇದನ್ನು ಸೈಕಲ್ ಪತ್ತೆ ಸಮಸ್ಯೆಗಳಿಗೆ ಆಗಾಗ್ಗೆ ಬಳಸಲಾಗುತ್ತದೆ ಮತ್ತು ಇಲ್ಲಿ ಬಳಸಲಾದ ಪರಿಣಾಮಕಾರಿ ವಿಧಾನಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ: ಲಿಂಕ್ ಮಾಡಿದ ಪಟ್ಟಿಯಲ್ಲಿ ಲೂಪ್ ಅನ್ನು ಪತ್ತೆ ಮಾಡಿ .