[Powered by Google Translate] [ರಿವ್ಯೂ] [ರಸಪ್ರಶ್ನೆ 0] 

[Lexi ರಾಸ್, ಟಾಮಿ MacWilliam, ಲ್ಯೂಕಾಸ್ ಫ್ರೀಟಾಸ್, ಜೋಸೆಫ್ ಓಂಗ್] [ಹಾರ್ವರ್ಡ್ ವಿಶ್ವವಿದ್ಯಾಲಯ] 

[ಈ CS50 ಹೊಂದಿದೆ.] [CS50.TV] 

ಹೇ, ಎಲ್ಲರೂ. ಈ ಬುಧವಾರ ನಡೆಯುತ್ತಿದೆ ಇದು ರಸಪ್ರಶ್ನೆ 0, ರಿವ್ಯೂ ಅಧಿವೇಶನದ ಸ್ವಾಗತ. ನಾವು ಟುನೈಟ್ ಮಾಡಲು ನೀನು ಏನು, ನಾನು, 3 ಇತರ TFS ಜೊತೆ ಆಮ್ ಮತ್ತು ಒಟ್ಟಿಗೆ ನಾವು ಇಲ್ಲಿಯವರೆಗೆ ಸಂದರ್ಭದಲ್ಲಿ ಮಾಡಿದ ಯಾವ ಒಂದು ವಿಮರ್ಶೆ ಮೂಲಕ ಹೋಗಲು ನೀನು. ಇದು 100% ವ್ಯಾಪಕವಾದ ಹಿಂದಿರುಗಬಹುದೆಂದು, ಆದರೆ ನೀವು ಒಂದು ಉತ್ತಮ ಕಲ್ಪನೆಯನ್ನು ನೀಡುತ್ತದೆ ನೀವು ಈಗಾಗಲೇ ಕೆಳಗೆ ಏನು ಮತ್ತು ಯಾವ ನೀವು ಇನ್ನೂ ಬುಧವಾರ ಮೊದಲು ಅಧ್ಯಯನ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ನಾವು ಜೊತೆಗೆ ನೀನು ಮತ್ತು ಪ್ರಶ್ನೆಗಳನ್ನು ನಿಮ್ಮ ಕೈ ಹೆಚ್ಚಿಸಲು ಹಿಂಜರಿಯಬೇಡಿ ಆದರೆ ನಾವು ಸಮಯದಲ್ಲಿ ಒಂದು ಸ್ವಲ್ಪ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ ಕೊನೆಯ ನಾವು ಸಾಮಾನ್ಯ ಪ್ರಶ್ನೆಗಳನ್ನು ಮಾಡಲು ಬಡಕಲ ಕೆಲವು ನಿಮಿಷಗಳ ಮೂಲಕ ಪಡೆಯಲು ವೇಳೆ, ಆದ್ದರಿಂದ ಮನಸ್ಸು ಆ ಇರಿಸಿಕೊಳ್ಳಲು, ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ವೀಕ್ 0 ಆರಂಭದಲ್ಲಿ ಆರಂಭಿಸಲು ನೀನು. 

ನಾವು ಮೊದಲು [0 ರಿವ್ಯೂ ಕ್ವಿಜ್!] [ಭಾಗ 0] [Lexi ರಾಸ್] ಆದರೆ ನಾವು ಬಗ್ಗೆ ಮಾತನಾಡುವುದು ರಸಪ್ರಶ್ನೆಯ ಜಾರಿ. 

[ಲಾಜಿಸ್ಟಿಕ್ಸ್] [ರಸಪ್ರಶ್ನೆ ಉಪನ್ಯಾಸ ಬದಲಾಗಿ ಬುಧವಾರ 10/10 ರಂದು ನಡೆಯುತ್ತದೆ] 

[(ವಿವರಗಳಿಗಾಗಿ http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf ನೋಡಿ)] ಇದು ಬುಧವಾರ, ಅಕ್ಟೋಬರ್ 10 ರಂದು ಹೊಂದಿದೆ. 

ಈ ಬುಧವಾರ, ಮತ್ತು ನೀವು ಇಲ್ಲಿ ಈ URL ಗೆ ಹೋದರೆ, ಇದು ಲಿಂಕ್ CS50.net-ಇಲ್ಲ 'ಗಳ ಮೂಲಕ ಪ್ರವೇಶಿಸಬಹುದು ಇದು ನೀವು ಆಧರಿಸಿ ಹೋಗಲು ಅಲ್ಲಿ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ನೋಡಬಹುದು ನಿಮ್ಮ ಕೊನೆಯ ಹೆಸರು ಅಥವಾ ಶಾಲೆಯ ಅನುಸರಣೆ ಹಾಗೂ ಅದರ ಬಗ್ಗೆ ನಿಖರವಾಗಿ ರಸಪ್ರಶ್ನೆ ನೀವು ಪಡೆಯಲು ನೀನು ಆ ಕವರ್ ಮತ್ತು ಪ್ರಶ್ನೆಗಳ ವಿಧಗಳು ಎಂಬುದನ್ನು ಹೇಳುತ್ತದೆ. ನೀವು ವಿಭಾಗದಲ್ಲಿ ರಸಪ್ರಶ್ನೆ ರಿವ್ಯೂ ಅವಕಾಶ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ, ನಿಮ್ಮ TFS, ಕೆಲವು ಅಭ್ಯಾಸ ಸಮಸ್ಯೆಗಳನ್ನು ಹೋಗುವಾಗ ಮಾಡಬೇಕು ಮತ್ತು ನೀವು ಇನ್ನೂ ರಸಪ್ರಶ್ನೆ ಅಪ್ ಅಧ್ಯಯನ ಅಗತ್ಯವಿದೆ ಅಲ್ಲಿ ನೋಡಲು ಇನ್ನೊಂದು ಒಳ್ಳೆಯ ಅವಕಾಶ ಇಲ್ಲಿದೆ. ಬಿಟ್ಸ್ 'ಎನ್' ಒಂದುಪುಟದಗಾತ್ರ ಜೊತೆ ಆರಂಭದಲ್ಲಿ ಆರಂಭಿಸೋಣ. ಒಂದು ಬಿಟ್ ಕೇವಲ 0 ಅಥವಾ 1, ರಿಮೆಂಬರ್ ಮತ್ತು ಒಂದು ಬೈಟ್ ಆ ಬಿಟ್ಗಳ 8 ಸಂಗ್ರಹವಾಗಿದೆ. ಇಲ್ಲಿಯೇ ಬಿಟ್ಗಳ ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ನೋಡೋಣ. ನಾವು ಅಲ್ಲಿ ಎಷ್ಟು ಬಿಟ್ಗಳ ಔಟ್ ಲೆಕ್ಕಾಚಾರ ಸಾಧ್ಯವಾಗುತ್ತದೆ. ನಾವು ಲೆಕ್ಕ ಅಲ್ಲಿ ಅವುಗಳಲ್ಲಿ 8, ಎಂಟು 0 ಅಥವಾ 1 ಘಟಕಗಳು ಕೇವಲ ಇಲ್ಲ. ಮತ್ತು ರಿಂದ 8 ಬಿಟ್ಗಳು, 1 ಬೈಟ್ ಎಂದು, ಇಲ್ಲ ಮತ್ತು ಅವರ ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಪರಿವರ್ತಿಸಲು ಅವಕಾಶ. ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಬೇಸ್ 16, ಮತ್ತು ಪರಿವರ್ತಿಸುವುದು ಬಹಳ ಸುಲಭ ಅವಳಿ ಒಂದು ಸಂಖ್ಯೆ, ಇದು ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಒಂದು ಸಂಖ್ಯೆಗೆ, ಅಂದರೆ ಏನು. ನಾವು ಎಲ್ಲಾ ನಾವು, 4 ಗುಂಪುಗಳನ್ನು ನೋಡಿ ಆಗಿದೆ ಮತ್ತು ನಾವು ಸರಿಯಾದ ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಅಂಕಿಯ ಅವುಗಳನ್ನು ಪರಿವರ್ತಿಸುತ್ತದೆ. ನಾವು 0011, 4 ಬಲ ಅತ್ಯಂತ ಗುಂಪು ಪ್ರಾರಂಭಿಸಿ. ಆದ್ದರಿಂದ ಒಟ್ಟಿಗೆ 3 ಮಾಡುತ್ತದೆ, ಒಂದು 1 ಮತ್ತು 2 ಎಂದು ವಿಶೇಷವೇನು. ಮತ್ತು ನಂತರ 4 ಇತರೆ ಬ್ಲಾಕ್ ನೋಡೋಣ. 1101. ಒಂದು 1, 4, ಹಾಗೂ ಒಂದು 8 ಎಂದು ವಿಶೇಷವೇನು. ಒಟ್ಟಿಗೆ ಎಂದು ಡಿ ಮಾಡುತ್ತದೆ, 13 ಎಂದು ವಿಶೇಷವೇನು ಮತ್ತು ನಾವು ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ನಾವು ಕೇವಲ 9 ಮೂಲಕ 0 ಕಾಣುವುದಿಲ್ಲ ನೆನಪು ಮಾಡುತ್ತೇವೆ. ನಾವು, ಆದ್ದರಿಂದ 9 ನಂತರ, ಎಫ್ ಮೂಲಕ ಒಂದು 10 ಅನುರೂಪವಾಗಿಯೂ 0 ಹೋಗಿ, ಎಫ್ 15 ಅಲ್ಲಿ 11 ಬಿ, ಎಟ್ ಇತ್ಯಾದಿ. ಇಲ್ಲಿ 13, ಡಿ ಆಗಿದೆ ಆದ್ದರಿಂದ ನಾವು ಎಲ್ಲಾ ನಾವು ವಾಸ್ತವವಾಗಿ ದಶಮಾಂಶ ಮತಾಂತರಗೊಳ್ಳಲು 2 ಒಂದು ಶಕ್ತಿಯಾಗಿ ಪ್ರತಿ ಸ್ಥಾನವನ್ನು ಚಿಕಿತ್ಸೆ. ಒಂದು 1, 2 ಒಂದು, ಶೂನ್ಯ 4s, ಶೂನ್ಯ 8s, ಒಂದು 16, ಎಟ್ ಇತ್ಯಾದಿ, ಅವರ ಮತ್ತು ನಿಮ್ಮ ತಲೆ ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಸ್ವಲ್ಪ ಕಷ್ಟ, ಆದರೆ ಮುಂದಿನ ಸ್ಲೈಡ್ ಹೋಗಿ ವೇಳೆ ನಾವು ಉತ್ತರವನ್ನು ನೋಡಬಹುದು. 

ಮೂಲಭೂತವಾಗಿ ನಾವು ಎಡ ಮತ್ತೆ ಬಲಕ್ಕೆ ಅಡ್ಡಲಾಗಿರುವ ನೀನು ಮತ್ತು ನಾವು 2 ಸರಿಹೊಂದುವ ಶಕ್ತಿಯಿಂದ ಪ್ರತಿ ಅಂಕಿಯ ಗುಣಿಸಿದಾಗ ಮಾಡುತ್ತಿದ್ದೇವೆ. ಮತ್ತು, ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ನಾವು ಆರಂಭದಲ್ಲಿ 0x ಈ ಸಂಖ್ಯೆಗಳನ್ನು ಸೂಚಿಸಲು ಆದ್ದರಿಂದ ನಾವು ದಶಮಾಂಶ ಸಂಖ್ಯೆಯ ಗೊಂದಲ ಇಲ್ಲ. ಮುಂದುವರೆಯುತ್ತಿದೆ, ಈ, ಒಂದು ASCII ಟೇಬಲ್ ಆಗಿದೆ ಮತ್ತು ನಾವು ASCII ಬಳಸುವುದಕ್ಕೆ ಪಾತ್ರಗಳಾದ ಸಂಖ್ಯಾತ್ಮಕ ಮೌಲ್ಯಗಳನ್ನು ಗೆ ಮ್ಯಾಪ್ ಆಗಿದೆ. ಗೂಢಲಿಪಿಶಾಸ್ತ್ರ pset ರಲ್ಲಿ ನೆನಪಿಡಿ ನಾವು ASCII ಟೇಬಲ್ ವ್ಯಾಪಕವಾದ ಬಳಕೆಯನ್ನು ಮಾಡಿದ ಗೂಢಲಿಪಿಶಾಸ್ತ್ರ ವಿವಿಧ ವಿಧಾನಗಳನ್ನು ಬಳಸಲು, ವಿವಿಧ ಅಕ್ಷರಗಳನ್ನು ಪರಿವರ್ತಿಸಲು ಸೀಸರ್ ಮತ್ತು Vigenère ಸೈಫರ್, ಬಳಕೆದಾರ ನೀಡಿದ ಕೀಲಿಯನ್ನು ಪ್ರಕಾರ ಒಂದು ಸಾಲಿನಲ್ಲಿ. ನ ASCII ಗಣಿತ ಒಂದು ಸ್ವಲ್ಪ ನೋಡೋಣ. ಪ್ರಶ್ನೆ ಎಂದು ಅಕ್ಷರ ರೂಪದಲ್ಲಿ, 'ಪಿ' ನಲ್ಲಿ + 1 ನೋಡುತ್ತಿರುವುದು, ಮತ್ತು '5 '≠ 5 ನೆನಪಿನಲ್ಲಿಡಿ. ಮತ್ತು ಹೇಗೆ ನಿಖರವಾಗಿ ನಾವು ಆ 2 ನಡುವಿನ ಪರಿವರ್ತಿಸಲು ಎಂದು? ಇದು ನಿಜವಾಗಿಯೂ ತುಂಬಾ ಹಾರ್ಡ್ ಅಲ್ಲ. 5 ಪಡೆಯುವ ಸಲುವಾಗಿ ನಾವು '0 ಕಳೆಯಿರಿ ' ಏಕೆಂದರೆ '0 ನಡುವೆ 5 ಸ್ಥಳಗಳಲ್ಲಿ 'ಮತ್ತು '5.' ನಾವು 0 ಸೇರಿಸಿ ಇತರ ರೀತಿಯಲ್ಲಿ ಹೋಗಿ ಸಲುವಾಗಿ, ಆದ್ದರಿಂದ ಸಾಮಾನ್ಯ ಗಣಿತ ಮುಂತಾದ ರೀತಿಯ ಇಲ್ಲಿದೆ. ಕೇವಲ ಏನೋ ಇದು ಸುಮಾರು ಉಲ್ಲೇಖಗಳು ಯಾವಾಗ ಒಂದು ಪಾತ್ರದ ನೆನಪು ಆದ್ದರಿಂದ ASCII ಕೋಷ್ಟಕದಲ್ಲಿ ಮೌಲ್ಯವನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಸಾಮಾನ್ಯ ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನ ವಿಷಯಗಳನ್ನು ಚಲಿಸಿದ. ನಾವು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಬಳಸುವುದಕ್ಕೆ ಒಂದು ಕ್ರಮಾವಳಿ ಮತ್ತು ಕಲಿತರು ಕ್ರಮಾವಳಿಗಳನ್ನು ಅಳವಡಿಸಲು. ಕ್ರಮಾವಳಿಗಳು ಕೆಲವು ಉದಾಹರಣೆಗಳು ನಂತಹ ನಿಜವಾಗಿಯೂ ಸರಳ ಏನೋ ಒಂದು ಸಂಖ್ಯೆ ಸಮ ಅಥವಾ ಬೆಸ ಎಂದು ಪರೀಕ್ಷಿಸುವುದು. ಇದಕ್ಕಾಗಿ ನಾವು 2 ಸಂಖ್ಯೆಯ Mod ಮತ್ತು ಪರಿಣಾಮವಾಗಿ 0 ವೇಳೆ ಪರೀಕ್ಷಿಸಲು ಮರೆಯದಿರಿ. ಹಾಗಿದ್ದಲ್ಲಿ, ಇದು ಕೂಡ ಇಲ್ಲಿದೆ. ಇಲ್ಲದಿದ್ದರೆ, ಇದು ಬೆಸ ಇಲ್ಲಿದೆ. ಮತ್ತು ಒಂದು ನಿಜವಾಗಿಯೂ ಮೂಲ ಕ್ರಮಾವಳಿ ಒಂದು ಉದಾಹರಣೆ. 

ಹೆಚ್ಚು ಒಳಗೊಂಡಿರುವ ಒಂದು ಸ್ವಲ್ಪ ಬೈನರಿ ಸರ್ಚ್ ಹೊಂದಿದೆ, ಇದು ನಾವು ವಿಮರ್ಶೆ ಅಧಿವೇಶನದ ನಂತರ ಮೇಲೆ ಹೋಗಿ ನೋಡುತ್ತಾರೆ. ಮತ್ತು ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ನಾವು ಒಂದು ಕ್ರಮಾವಳಿ ತೆಗೆದುಕೊಳ್ಳುವ ಬಳಸಲು ಪದ ಮತ್ತು ಕಂಪ್ಯೂಟರ್ ಕೋಡ್ ಬದಲಾಯಿಸಲಾಗಿಲ್ಲ ಓದಬಹುದು. ಕಾರ್ಯಕ್ರಮಗಳ 2 ಉದಾಹರಣೆಗಳು, ಸ್ಕ್ರಾಚ್ ಆಗಿದೆ ಇದು ನಾವು ವೀಕ್ 0 ರಲ್ಲಿ ಏನು ಆಗಿದೆ. ನಾವು ವಾಸ್ತವವಾಗಿ ಕೋಡ್ ಔಟ್ ಟೈಪ್ ಸಹ ಆದರೂ ಇದು ಅನುಷ್ಠಾನಕ್ಕೆ ಒಂದು ಮಾರ್ಗವಾಗಿದೆ ಸಂಖ್ಯೆಗಳನ್ನು 1-10 ಮುದ್ರಿಸುವ ಇದು ಈ ಕ್ರಮಾವಳಿ, ಮತ್ತು ಇಲ್ಲಿ ನಾವು C ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಲ್ಲಿ ಹೀಗೆ. ಈ ಕೇವಲ ವಿವಿಧ ಭಾಷೆಗಳಲ್ಲಿ ಅಥವಾ ವಾಕ್ಯ ಬರೆದ ಕಾರ್ಯಕಾರಿಯಾಗಿ ಸಮನಾಗಿದೆ. ನಾವು ಆಗ, ಬೂಲಿಯನ್ ನಿರೂಪಣೆಗಳೂ ಕಲಿತ ಮತ್ತು ಒಂದು ಬೂಲಿಯನ್, ಸರಿ ಅಥವಾ ತಪ್ಪು ಎರಡೂ ಎಂದು ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ ಇಲ್ಲಿ ಅನೇಕ ವೇಳೆ ಬೂಲಿಯನ್ ಅಭಿವ್ಯಕ್ತಿಗಳು ಆದ್ದರಿಂದ (x ≤ 5), ಪರಿಸ್ಥಿತಿಗಳ ಒಳಗೆ ಹೋಗಿ, ಹಾಗೆಯೇ, ನಾವು ಈಗಾಗಲೇ ಷರತ್ತಿನ ನಿಜವಾದ ಗೆ ಮೌಲ್ಯಮಾಪನ ಹೋಗುವ ಇದೆ X = 5, ಆದ್ದರಿಂದ ಸೆಟ್. ಇದು ನಿಜ ವೇಳೆ ಮತ್ತು, ಯಾವುದೇ ಕೋಡ್ ಸ್ಥಿತಿಯನ್ನು ಕೆಳಗಡೆ ಕಂಪ್ಯೂಟರ್ ಮೌಲ್ಯಮಾಪನ ಹೋಗುವ ಇದೆ, ಆದ್ದರಿಂದ ಸ್ಟ್ರಿಂಗ್ ಮುದ್ರಿತ ಏರಲಿದೆ ಗುಣಮಟ್ಟದ ಉತ್ಪಾದನೆ, ಮತ್ತು ಪದ ಸ್ಥಿತಿಗೆ ವೇಳೆ ಹೇಳಿಕೆಯ ಆವರಣ ಒಳಗೆ ಯಾವುದೇ ಸೂಚಿಸುತ್ತದೆ. ಎಲ್ಲಾ ನಿರ್ವಾಹಕರು ನೆನಪಿಡಿ. | ನಾವು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಸಂದರ್ಭದಲ್ಲಿ ಸಂಯೋಜಿಸಲು 2 ಅಥವಾ ಹೆಚ್ಚಿನ ಪರಿಸ್ಥಿತಿಗಳು, | ಅದನ್ನು && ಮತ್ತು ನೆನಪಿಡಿ == ಅಲ್ಲ = 2 ಸಂಗತಿಗಳು ಸಮಾನವಾಗಿವೆ ಎಂದು ಪರಿಶೀಲಿಸಲು. == ಒಂದು ಬೂಲಿಯನ್ ಆಯೋಜಕರು ಆದರೆ = ನಿಯೋಜನೆ ಫಾರ್ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ. ≤, ≥ ಮತ್ತು ನಂತರ ಅಂತಿಮ 2 ಸ್ವಯಂ ವಿವರಣಾತ್ಮಕ ಇವೆ. ಇಲ್ಲಿ ಬೂಲಿಯನ್ ತರ್ಕವನ್ನು ಒಂದು ಸಾಮಾನ್ಯ ವಿಮರ್ಶೆ. ಮತ್ತು ಬೂಲಿಯನ್ ಅಭಿವ್ಯಕ್ತಿಗಳು, ಲೂಪ್ ಕೂಡ ಮುಖ್ಯ ಇದು ನಾವು ಈಗ ಮೇಲೆ ಹೋಗುತ್ತೇನೆ. ನಾವು ಆದರೆ, ಫಾರ್, CS50 ಇಲ್ಲಿಯವರೆಗೆ ಕುಣಿಕೆಗಳು ಸುಮಾರು 3 ರೀತಿಯ ಕಲಿತರು, ಮತ್ತು ಹಾಗೆಯೇ ಮಾಡಬೇಕು. ಮತ್ತು ಅದನ್ನು ತಿಳಿಯಲು ಪ್ರಮುಖ ಹೆಚ್ಚಿನ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ವಾಸ್ತವವಾಗಿ ಸಾಮಾನ್ಯವಾಗಿ ಲೂಪ್ ಯಾವುದೇ ರೀತಿಯ ಬಳಸಬಹುದು ಉದ್ದೇಶಗಳಿಗಾಗಿ ಅಥವಾ ಸಾಮಾನ್ಯ ಮಾದರಿಗಳ ಕೆಲವು ರೀತಿಯ ನಿರ್ದಿಷ್ಟವಾಗಿ ಈ ಕುಣಿಕೆಗಳನ್ನು ಒಂದು ಕರೆ ಎಂದು ಪ್ರೊಗ್ರಾಮಿಂಗ್ನಲ್ಲಿ ಇದನ್ನು ಮಾಡಲು ಅತ್ಯಂತ ಪರಿಣಾಮಕಾರಿಯಾದ ಅಥವಾ ಆ ರೀತಿಯಲ್ಲಿ ಇದು ಕೋಡ್ ಗೆ ಸೊಗಸಾದ. ನ ಈ ಕುಣಿಕೆಗಳು ಪ್ರತಿಯೊಂದು ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ ಒಲವು ಯಾವ ಮೇಲೆ ಹೋಗಿ ನೋಡೋಣ. 

ಒಂದು ಲೂಪ್ ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಈಗಾಗಲೇ ನಾವು ಮರಳಿ ಬಯಸುವ ಎಷ್ಟು ಬಾರಿ ತಿಳಿದಿದೆ. ನಾವು ಸ್ಥಿತಿಯಲ್ಲಿ ಪುಟ್ ಇಲ್ಲಿದೆ. ನಾನು = 0, ನಾನು <10, ಉದಾಹರಣೆಗೆ. ನಾವು ಈಗಾಗಲೇ ಏನೋ 10 ಬಾರಿ ಮಾಡಲು ಬಯಸುವ ತಿಳಿದಿದೆ. ಈಗ, ಒಂದು ಸಮಯದಲ್ಲಿ ಲೂಪ್ ಫಾರ್, ಸಾಮಾನ್ಯವಾಗಿ ನಾವು ಎಂದೇನೂ ಇಲ್ಲ ನಾವು ಲೂಪ್ ಚಲಾಯಿಸಲು ಬಯಸುವ ಎಷ್ಟು ಬಾರಿ ತಿಳಿದಿದೆ. ಆದರೆ ನಾವು ಬಯಸುವ ಪರಿಸ್ಥಿತಿ ಕೆಲವು ರೀತಿಯ ಗೊತ್ತು ಯಾವಾಗಲೂ ನೈಜ ಅಥವಾ ಯಾವಾಗಲೂ ಸುಳ್ಳು. ಉದಾಹರಣೆಗೆ, ಆದರೆ ಹೊಂದಿಸಲಾಗಿದೆ. ಲೆಟ್ಸ್ ಒಂದು ಬೂಲಿಯನ್ ವೇರಿಯಬಲ್ ಎಂದು ಹೇಳುತ್ತಾರೆ. ನಿಜವಾದ ವಿಷಯವೆಂದರೆ ನಾವು ಕೋಡ್ ಮೌಲ್ಯಮಾಪನ ಬಯಸುವ, ಆದ್ದರಿಂದ ಸ್ವಲ್ಪ ವಿಸ್ತರಣೆಯು, ಲೂಪ್ ಒಂದು ಹೆಚ್ಚು ಸಾಮಾನ್ಯ ಸ್ವಲ್ಪ, ಆದರೆ ಲೂಪ್ ಯಾವುದೇ ಒಂದು ಸಮಯದಲ್ಲಿ ಲೂಪ್ ಪರಿವರ್ತಿಸಬಹುದು. ಅಂತಿಮವಾಗಿ, ಹಾಗೆ ಮಾಡುವಾಗ ಈಗಿನಿಂದಲೇ ಗ್ರಹಿಸಲು trickiest ಆಗಿರಬಹುದು ಕುಣಿಕೆಗಳು, ನಾವು ಮೊದಲ ಕೋಡ್ ಮೌಲ್ಯಮಾಪನ ಬಯಸುವ ಕೆಲವೊಮ್ಮೆ ಬಳಸಲಾಗುತ್ತದೆ ಮೊದಲ ಬಾರಿಗೆ ಮೊದಲು ನಾವು ಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸಿ. ಒಂದು ಒಂದು ಸಾಮಾನ್ಯ ಬಳಕೆಯ ಸಂದರ್ಭದಲ್ಲಿ ಮಾಡುವುದಿಲ್ಲ ಲೂಪ್ ನೀವು ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ಪಡೆಯಲು ಬಯಸಿದಾಗ, ಮತ್ತು ನೀವು ಬಳಕೆದಾರ ಕೇಳಲು ಬಯಸುವ ತಿಳಿದಿದೆ ಸೇರಿಸುವ ಒಮ್ಮೆಲೇ, ಆದರೆ ನೀವು ಒಳ್ಳೆಯ ಇನ್ಪುಟ್ ನೀಡದಿದ್ದಲ್ಲಿ ಈಗಿನಿಂದಲೇ ಅವರು ನೀವು ಒಳ್ಳೆಯ ಇನ್ಪುಟ್ ನೀಡುವ ತನಕ ಕೇಳಿ ಇರಿಸಿಕೊಳ್ಳಲು ಬಯಸುತ್ತೀರಿ. ಆದರೆ ಲೂಪ್ ಒಂದು ಸಾಮಾನ್ಯ ಬಳಕೆಯ ಆ ಬೇಕು ಮತ್ತು ಅವರ ಈ ಕುಣಿಕೆಗಳು ನಿಜವಾದ ರಚನೆಯನ್ನು ನೋಡೋಣ. ಅವರು ಸಾಮಾನ್ಯವಾಗಿ ಯಾವಾಗಲೂ ಈ ಮಾದರಿಗಳನ್ನು ಒಲವು. 

ಒಳಗಿನ ಲೂಪ್ ನಲ್ಲಿ 3 ಘಟಕಗಳನ್ನು ಹೊಂದಿವೆ: ಪ್ರಾಥಮಿಕ, ವಿಶಿಷ್ಟವಾಗಿ ಏನಾದರೂ ನಂತಹ ಇಂಟ್ ನಾನು ಕೌಂಟರ್ ಅಲ್ಲಿ = 0, ಈ ಪರಿಸ್ಥಿತಿ ಇನ್ನೂ ಹೊಂದಿದೆ ತನಕ ಲೂಪ್ ಈ ರನ್ ಹೇಳಲಿಚ್ಚಿಸುತ್ತೇನೆ ಅಲ್ಲಿ ಪರಿಸ್ಥಿತಿ,, ನಾವು ಹೆಚ್ಚಿಸಲು ಹೇಗೆ ಇದು ನಾನು ಅಂತಿಮವಾಗಿ ನಂತರ <10, ಮತ್ತು, ಅಪ್ಡೇಟ್, ಹಾಗೆ ಚಕ್ರಕ್ಕೆ ಪ್ರತಿ ಹಂತದಲ್ಲಿ ಪ್ರತಿ ವೇರಿಯಬಲ್. ಅಲ್ಲಿ ನೋಡಲು ಒಂದು ಸಾಮಾನ್ಯ ವಿಷಯವಾಗಿ, ನಾನು + + ಆಗಿದೆ ಇದು 1 ರಿಂದ ಪ್ರತಿ ಬಾರಿ ನಾನು ಹೆಚ್ಚಿಸಲು ಅರ್ಥ. ನೀವು, ನಾನು + = 2 ರೀತಿಯ ಇಲ್ಲ ಇದು ನಾನು ನೀವು ಲೂಪ್ ಮೂಲಕ ಹೋಗಿ ಪ್ರತಿ ಬಾರಿ 2 ಸೇರಿಸಲು ಅರ್ಥ. ನಂತರ ಇದನ್ನು ಕೇವಲ ವಾಸ್ತವವಾಗಿ ಲೂಪ್ ಭಾಗವಾಗಿ ಹರಿಯುತ್ತದೆ ಯಾವುದೇ ಕೋಡ್ ಸೂಚಿಸುತ್ತದೆ. ಮತ್ತು ಸ್ವಲ್ಪ ಲೂಪ್, ಈ ಬಾರಿ ನಾವು ವಾಸ್ತವವಾಗಿ, ಲೂಪ್ ಹೊರಗೆ ಆರಂಭಕ್ಕೆ ಹೊಂದಿವೆ ಆದ್ದರಿಂದ ಉದಾಹರಣೆಗೆ, ನಾವು ನಾನು ವಿವರಿಸಿದಂತೆ ಲೂಪ್ ಅದೇ ರೀತಿಯ ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಹೇಳಲು ಅವಕಾಶ. ನಾವು ಇಂಟ್ ನಾನು = 0 ಲೂಪ್ ಪ್ರಾರಂಭವಾಗುವುದಕ್ಕೆ ಮೊದಲು ಹೇಳುತ್ತಿದ್ದರು. ನಾನು <10 ಹಾಗೆ ಆದರೆ ನಂತರ ನಾವು ಹೇಳಬಹುದು ಮೊದಲು ಕೋಡ್ ಆದ್ದರಿಂದ ಅದೇ ಬ್ಲಾಕ್, ಈ ಸಮಯದಲ್ಲಿ ಉದಾಹರಣೆಗೆ ಕೋಡ್ ಅಪ್ಡೇಟ್ ಭಾಗವಾಗಿ, ನಾನು + + ವಾಸ್ತವವಾಗಿ ಲೂಪ್ ಒಳಗೆ ಹೋಗುತ್ತದೆ. ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಒಂದು, ಅದು ಹಾಗೆಯೇ ಲೂಪ್ನಂತೆಯೇ ವಿಷಯವೆಂದರೆ ಹಾಗೆ, ಆದರೆ ಕೋಡ್ ಒಮ್ಮೆ ಮೌಲ್ಯಮಾಪನ ಎಂದು ನೆನಪಿಡುವ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ ಪರಿಸ್ಥಿತಿ ಪರಿಶೀಲಿಸಿದ ಮೊದಲು, ಆದ್ದರಿಂದ ಬಹಳ ಸಮಂಜಸವಾಗಿರುತ್ತದೆ ನೀವು ಮೇಲಿನಿಂದ ಕೆಳಕ್ಕೆ ಮೇರೆಗೆ ಅದನ್ನು ನೋಡಲು. ವೇಳೆ ಒಂದು ನೀವು ಕೂಡ ಅದೇ ಸ್ಥಿತಿಯನ್ನು ನೋಡಲು ಮೊದಲು ಲೂಪ್ ಕೋಡ್ ಮೌಲ್ಯಮಾಪನ ಮಾಡುವಾಗ ಹಾಗೆ, ಸ್ವಲ್ಪ ಲೂಪ್ ಆದರೆ, ಇದು ಮೊದಲ ಪರಿಶೀಲಿಸುತ್ತದೆ. ಹೇಳಿಕೆಗಳು ಮತ್ತು ಅಸ್ಥಿರ. ನಾವು ಹೊಸ ವೇರಿಯಬಲ್ ರಚಿಸಲು ಬಯಸುವ ನಾವು ಮೊದಲು ಆರಂಭಿಸಲು ಬಯಸುವ. 

ಉದಾಹರಣೆಗೆ, ಇಂಟ್ ಬಾರ್, ವೇರಿಯಬಲ್ ಬಾರ್ ಆರಂಭಿಸುತ್ತದೆ ಆದರೆ ಈಗ ಬಾರ್ ಮೌಲ್ಯದ ಏನು ಅದು ಮೌಲ್ಯವನ್ನು ನೀಡುವುದಿಲ್ಲ? ನಾವು ಗೊತ್ತಿಲ್ಲ. ಇದು ಹಿಂದೆ ಅಲ್ಲಿ ಮೆಮೊರಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಎಂದು ಕೆಲವು ತ್ಯಾಜ್ಯವನ್ನು ಮೌಲ್ಯವನ್ನು ಆಗಿರಬಹುದು ಮತ್ತು ನಾವು ವೇರಿಯಬಲ್ ಬಳಸಲು ಇಷ್ಟವಿಲ್ಲ ನಾವು ವಾಸ್ತವವಾಗಿ ಇದು ಒಂದು ಮೌಲ್ಯವನ್ನು ನೀಡಿ ರವರೆಗೆ ಆದ್ದರಿಂದ ನಾವು ಇಲ್ಲಿ ಘೋಷಿಸಬೇಕಾಗಿದೆ. ನಂತರ ನಾವು ಕೆಳಗೆ 42 ಎಂದು ಆರಂಭಿಸಲು. ಈಗ, ನಾವು ಈ ಒಂದು ಸಾಲಿನಲ್ಲಿ, ಇಂಟ್ ಬಾರ್ = 42 ಮಾಡಬಹುದು ತಿಳಿದಿದೆ. ಆದರೆ, ಹೋಗುಗಳನ್ನು ಅನೇಕ ಹಂತಗಳನ್ನು ತೆರವುಗೊಳಿಸಿ ಎಂದು ಘೋಷಣೆ ಮತ್ತು ಆರಂಭಕ್ಕೆ ಇಲ್ಲಿ ಪ್ರತ್ಯೇಕವಾಗಿ ಸಂಭವಿಸುತ್ತಿವೆ. ಮುಂದಿನ ಒಂದು, ಇಂಟ್ ಬಾಜ್ = ಬಾರ್ + 1, ಒಂದು ಹಂತದಲ್ಲಿ ಸಂಭವಿಸುತ್ತದೆ, ಮತ್ತು ಈ ಕೋಡ್ ಬ್ಲಾಕ್ ಕೊನೆಯಲ್ಲಿ ಕೆಳಗೆ ಈ ಹೇಳಿಕೆ, ಆ ಬೆಳವಣಿಗೆಗಳ ಬಾಜ್, ನಾವು ಬಾಜ್ ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸಲು ಬಳಸಿದರೆ 44 ಎಂದು ನಾವು, ಘೋಷಿಸಲು ಮತ್ತು 1> ಬಾರ್ ಎಂದು ಇದು ಆರಂಭಿಸಲು ಕಾರಣ ನಂತರ ನಾವು ಮತ್ತೆ ಅದನ್ನು ಹೆಚ್ಚಿಸಲು + +. ಈ ಬಹಳ ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಮೇಲೆ ಹೋದರು, ಆದರೆ ಇದು ಒಂದು ಸಾಮಾನ್ಯ ಹೊಂದುವುದು ಒಳ್ಳೆಯದು ಎಳೆಗಳನ್ನು ಮತ್ತು ಘಟನೆಗಳು ಎಂಬುದನ್ನು ಅರ್ಥ ಮಾಡಿಕೊಳ್ಳಲು. ನಾವು ಮುಖ್ಯವಾಗಿ, ಸ್ಕ್ರ್ಯಾಚ್ ಈ ಮಾಡಿದರು ಆದ್ದರಿಂದ ನೀವು ಕೋಡ್ ಬಹು ಸೀಕ್ವೆನ್ಸ್ ಎಳೆಗಳನ್ನು ನಗರದ ಅದೇ ಸಮಯದಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ. ವಾಸ್ತವದಲ್ಲಿ, ಇದು ಬಹುಶಃ ಅದೇ ಸಮಯದಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿಲ್ಲ ಆದರೆ ರೀತಿಯ ಅಮೂರ್ತವಾದ ಆ ರೀತಿಯಲ್ಲಿ ಇದು ನಗರದ. 

ಸ್ಕ್ರಾಚ್ ಉದಾಹರಣೆಗೆ, ನಾವು ಅನೇಕ sprites ಹೊಂದಿತ್ತು. ಅದೇ ಸಮಯದಲ್ಲಿ ವಿಭಿನ್ನ ಕೋಡ್ ಪಾಲಿಸಲು ಸಾಧ್ಯ. ಇತರ ಹೇಳುತ್ತಿದ್ದೇನೆ ಆದರೆ ಒಂದು ವಾಕಿಂಗ್ ಮಾಡಬಹುದು ಪರದೆಯ ಬೇರೆ ಭಾಗದಲ್ಲಿ. ಕ್ರಿಯೆಗಳು ತರ್ಕ ಬೇರ್ಪಡಿಸುವ ಇನ್ನೊಂದು ದಾರಿ ನಿಮ್ಮ ಕೋಡ್ ವಿವಿಧ ಅಂಶಗಳ ನಡುವೆ, ಮತ್ತು ಸ್ಕ್ರ್ಯಾಚ್ ನಾವು, ಬ್ರಾಡ್ಕಾಸ್ಟ್ ಅನ್ನು ಘಟನೆಗಳು ಅನುಕರಿಸಲು ಸಮರ್ಥರಾದರು ನಾನು ಸ್ವೀಕರಿಸಿದಾಗ ಮತ್ತು, ನಾನು ಹಿಯರ್ ಇದ್ದಾಗ, ವಾಸ್ತವವಾಗಿ ಆದರೆ ಮೂಲಭೂತವಾಗಿ ಈ ಮಾಹಿತಿಯನ್ನು ರವಾನಿಸಲು ಒಂದು ಮಾರ್ಗವಾಗಿದೆ ಒಂದು ಸ್ಪ್ರೈಟ್ ಇನ್ನೊಂದು. ಉದಾಹರಣೆಗೆ, ನೀವು, ಆಟದ ಮೇಲೆ ಪ್ರಸಾರ ಬಯಸಬಹುದು ಮತ್ತೊಂದು ಪಿಶಾಚಿ ಆಟ ಸ್ವೀಕರಿಸಿದಾಗ, ಇದು ಕೆಲವು ರೀತಿಯಲ್ಲಿ ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆ. ಇದು ಕಾರ್ಯಕ್ರಮಗಳ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಒಂದು ಪ್ರಮುಖ ಮಾದರಿ. ಕೇವಲ ಮೂಲ ವೀಕ್ 0 ಮೇಲೆ ಹೋಗಿ, ನಾವು ಇದುವರೆಗೆ ಸುಮಾರು ಹೋಗಿದ್ದೀರಿ, ಅವರ ಈ ಸರಳ ಸಿ ಪ್ರೋಗ್ರಾಂ ನೋಡೋಣ. ಪಠ್ಯ ಇಲ್ಲಿಂದ ಸಣ್ಣ ಸ್ವಲ್ಪ, ಆದರೆ ನಾನು ಅದನ್ನು ನಿಜವಾಗಿಯೂ ತ್ವರಿತ ಹೋಗುತ್ತೇನೆ. ನಾವು ಉನ್ನತ, cs50.h ಮತ್ತು stdio.h 2 ಹೆಡರ್ ಕಡತಗಳನ್ನು ಸೇರಿದಂತೆ ನೀವು. ನಾವು 100 ಎಂದು ನಿರಂತರ ಎಂಬ ಮಿತಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಮಾಡುತ್ತಿದ್ದೇವೆ. ನಾವು ನಮ್ಮ ಮುಖ್ಯ ಕಾರ್ಯವನ್ನು ಅನುಷ್ಠಾನಕ್ಕೆ ಮಾಡುತ್ತಿದ್ದೇವೆ. ನಾವು ಇಲ್ಲಿ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಬಳಸುವುದಿಲ್ಲ ಏಕೆಂದರೆ ನಾವು ಶೂನ್ಯವನ್ನು ಇರಿಸಬೇಕಾಗುತ್ತದೆ ಮುಖ್ಯ ಫಾರ್ ವಾದಗಳನ್ನು. ನಾವು ಪ್ರಮುಖ ಮೇಲೆ ಇಂಟ್ ನೋಡಿ. ರಿಟರ್ನ್ ಪ್ರಕಾರದ ಎಂದು, ಆದ್ದರಿಂದ ಕೆಳಭಾಗದಲ್ಲಿ 0 ಹಿಂತಿರುಗಿ. ಮತ್ತು ನಾವು ಇಂಟ್ ಪಡೆಯಲು CS50 ಲೈಬ್ರರಿ ಫಂಕ್ಷನ್ ಬಳಸುತ್ತಿದ್ದೀರಿ ಇನ್ಪುಟ್ ಬಳಕೆದಾರ ಕೇಳಬಹುದು, ಮತ್ತು ನಾವು ಈ ವ್ಯತ್ಯಯ X ಅದನ್ನು ಸಂಗ್ರಹಿಸಲು, ಆದ್ದರಿಂದ ನಾವು ಮೇಲೆ X ಘೋಷಿಸಿದ, ಮತ್ತು x = GetInt ಇದನ್ನು ಆರಂಭಿಸಲು. 

ನಾವು ನಂತರ ಬಳಕೆದಾರ ನಮಗೆ ಒಳ್ಳೆಯ ಇನ್ಪುಟ್ ನೀಡಿದರು ನೀವು ಪರೀಕ್ಷಿಸಿ. ಇದು ≥ LIMIT ಆಗಿದ್ದರೆ ನಾವು 1 ಒಂದು ದೋಷ ಕೋಡ್ ಹಿಂದಿರುಗಿ ಒಂದು ದೋಷ ಸಂದೇಶವನ್ನು ಮುದ್ರಿಸಲು ಬಯಸುವ. ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಬಳಕೆದಾರ ನಮಗೆ ನೀಡಿದ ವೇಳೆ ಒಳ್ಳೆಯ ಇನ್ಪುಟ್ ನಾವು ಸಂಖ್ಯೆ ಸ್ಕ್ವೇರ್ ಮತ್ತು ಪರಿಣಾಮವಾಗಿ ಮುದ್ರಿಸುತ್ತದೆ ಎಂದು ನೀನು. ಕೇವಲ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಆ ಹಿಟ್ ಮನೆಯ ಎಲ್ಲಾ ನೀವು ಇಲ್ಲಿ ಕೋಡ್ ವಿವಿಧ ಭಾಗಗಳ ಲೇಬಲ್ಗಳನ್ನು ನೋಡಬಹುದು. ನಾನು ಸ್ಥಿರ, ಹೆಡರ್ ಕಡತಗಳನ್ನು ಪ್ರಸ್ತಾಪಿಸಿದ್ದಾರೆ. ಓಹ್, ಇಂಟ್ X. ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್ ಎಂದು ನೆನಪಿಡುವ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ನಾವು ಬಗ್ಗೆ ಮಾತನಾಡಲು ವಿಲ್ ಇದು ಒಂದು ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಇದನ್ನು ವೈರುಧ್ಯ ಸ್ವಲ್ಪ ನಂತರ ವಿಮರ್ಶೆ ಅಧಿವೇಶನದಲ್ಲಿ, ಮತ್ತು ನಾವು, printf ಲೈಬ್ರರಿ ಫಂಕ್ಷನ್ ಕರೆಯುತ್ತಿರುವ ನಾವು stdio.h ಹೆಡರ್ ಕಡತವನ್ನು ಒಳಗೊಂಡಿಲ್ಲ ಎಂದು ಹಾಗಿದ್ದಲ್ಲಿ ನಾವು printf ಕರೆಯಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ. ಮತ್ತು ನಾನು ಇಲ್ಲಿ ಕತ್ತರಿಸಿ ಕೊಂಡಿರುವ ಬಾಣದ% D ತೋರುತ್ತಿರುವಂತೆ ನಂಬಿದ್ದಾರೆ printf ಒಂದು ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಸ್ಟ್ರಿಂಗ್ ಇದು. ಒಂದು ಸಂಖ್ಯೆ,% d ಈ ವೇರಿಯಬಲ್ ಮುದ್ರಿಸುತ್ತದೆ ಹೇಳುತ್ತಾರೆ. ಮತ್ತು ವೀಕ್ 0 ಇದು ಹೊಂದಿದೆ. ಈಗ ಲ್ಯೂಕಾಸ್ ಮುಂದುವರಿಸಲು ಹೋಗುತ್ತದೆ. ಹೇ, ವ್ಯಕ್ತಿಗಳು. ನನ್ನ ಹೆಸರು ಲ್ಯೂಕಾಸ್ ಹೊಂದಿದೆ. ನಾನು, ಕ್ಯಾಂಪಸ್, ಮ್ಯಾಥರ್ ಉತ್ತಮ ಮನೆಯಲ್ಲಿ ಎರಡನೆಯ ಆಮ್ ಮತ್ತು ನಾನು ವೀಕ್ 1 ಮತ್ತು 2.1 ಕುರಿತಾಗಿ ಸ್ವಲ್ಪ ಮಾತನಾಡಲು ಪಡೆಯಲಿದ್ದೇನೆ. [ವೀಕ್ 1 ಮತ್ತು 2.1!] [ಲ್ಯೂಕಾಸ್ ಫ್ರೀಟಾಸ್] ನಾವು ಮೊದಲಿನಿಂದ ಸಿ ನಿಮ್ಮ ಕೋಡ್ ಅನುವಾದ ಆರಂಭಿಸಿದಾಗ Lexi, ಹೇಳಿಕೆಯ ಮಾಹಿತಿ ನಾವು ಗಮನಿಸಿದ್ದೇವೆ ವಸ್ತುಗಳ ಒಂದು ನೀವು ಕೇವಲ ಮಾಡುತ್ತದೆ ನಿಮ್ಮ ಕೋಡ್ ಬರೆಯಲು ಮತ್ತು ಎಂದಿಗೂ ಹಸಿರು ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಚಾಲನೆ. ವಾಸ್ತವವಾಗಿ, ನಿಮ್ಮ ಸಿ ಪ್ರೋಗ್ರಾಂ ಮಾಡಲು ಕೆಲವು ಕ್ರಮಗಳನ್ನು ಬಳಸಬೇಕು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಫೈಲ್ ಆಗಿ. ಮೂಲತಃ ನಿಮಗೆ ಒಂದು ಪ್ರೋಗ್ರಾಂ ಬರೆಯಲು ನೀವು ನೀವು ಏನು ಎಂದು ನೀವು ಒಂದು ಕಂಪೈಲರ್ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಒಂದು ಭಾಷೆಗೆ ನಿಮ್ಮ ಕಲ್ಪನೆ ಭಾಷಾಂತರಿಸಿ ನೀವು ಸಿ ಯೋಜನೆಯನ್ನು ನಾವು ಬರೆಯುತ್ತಿದ್ದೇವೆ ಯಾವಾಗ ಏನು ನೀವು ಮಾಡುತ್ತಿರುವ ನೀವು ನಿಜವಾಗಿಯೂ ನಿಮ್ಮ ಕಂಪೈಲರ್ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಹೋಗುತ್ತದೆ ಎಂದು ಏನೋ ಬರೆಯಲು ಇದೆ, ತದನಂತರ ಕಂಪೈಲರ್ ಕೋಡ್ ಭಾಷಾಂತರಿಸಲು ಹೋಗುತ್ತದೆ ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ ಅರ್ಥ ಆ ಆಗಿ. 

ಮತ್ತು ವಿಷಯ, ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ ವಾಸ್ತವವಾಗಿ ತುಂಬಾ ಮೂಕ ಆಗಿದೆ. ನಿಮ್ಮ ಗಣಕವು ಕೇವಲ, 0 ಸೆ ಮತ್ತು 1 ಅರ್ಥವಾಗುವಂತಹ ಆದ್ದರಿಂದ ವಾಸ್ತವವಾಗಿ ಮೊದಲ ಕಂಪ್ಯೂಟರ್ಗಳಲ್ಲಿ ಜನರು ಸಾಮಾನ್ಯವಾಗಿ ಪ್ರೋಗ್ರಾಮ್ ಎಂದಿಗೂ 0 ಸೆ ಮತ್ತು 1, ಆದರೆ ಬಳಸಿಕೊಂಡು ದೇವರ ಧನ್ಯವಾದ. ನಾವು 0 ಸೆ ಮತ್ತು 1 ಗಾಗಿ ಅನುಕ್ರಮಗಳನ್ನು ನೆನಪಿಟ್ಟುಕೊಳ್ಳುವ ಹೊಂದಿಲ್ಲ ಲೂಪ್ ಅಥವಾ ಸ್ವಲ್ಪ ಲೂಪ್ ಹೀಗೆ ಒಂದು ಕಾಲ. ನಾವು ಕಂಪೈಲರ್ ಏಕೆ ಆ. ಯಾವ ಒಂದು ಕಂಪೈಲರ್ ಮಾಡುತ್ತದೆ, ಇದು ಮೂಲತಃ C ಕೋಡ್ ಭಾಷಾಂತರಿಸುತ್ತದೆ ಆಗಿದೆ ನಮ್ಮ ವಿಷಯದಲ್ಲಿ, ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ ಅರ್ಥ ಒಂದು ಭಾಷೆಗೆ, ಇದು ವಸ್ತು ಕೋಡ್, ಮತ್ತು ನಾವು ಬಳಸುತ್ತಿದ್ದೀರಿ ಎಂಬುದನ್ನು ಕಂಪೈಲರ್ ಹೊಂದಿದೆ ಖಣಿಲು ಕರೆಯಲಾಗುತ್ತದೆ, ಈ ವಾಸ್ತವವಾಗಿ ಖಣಿಲು ಸಂಕೇತಿಸಿದರೆ. ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ, ನೀವು 2 ವಿಷಯಗಳನ್ನು ಮಾಡಬೇಕು. ಮೊದಲ, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಕಂಪೈಲ್, ಮತ್ತು ನಂತರ ನೀವು ನಿಮ್ಮ ಪ್ರೊಗ್ರಾಮನ್ನು ನೀನು. ನೀವು ಹಾಗೆ ಆಯ್ಕೆಗಳನ್ನು ಸಾಕಷ್ಟು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಸಂಕಲಿಸಲು. ಮೊದಲ ಒಂದು ಖಣಿಲು program.c ಮಾಡಲು ಹೊಂದಿದೆ ಇದರಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಹೆಸರು. ಈ ಸಂದರ್ಭದಲ್ಲಿ ಅವರು ಕೇವಲ ಹೇಳುತ್ತಿದ್ದಾರೆಂಬುದನ್ನು ನೋಡಬಹುದು "ಹೇ, ನನ್ನ ಪ್ರೋಗ್ರಾಂ ಕಂಪೈಲ್." ನೀವು ಅಥವಾ ಏನು "ನನ್ನ ಪ್ರೋಗ್ರಾಂ ಈ ಹೆಸರನ್ನು ನೀವು" ಹೇಳುತ್ತಿಲ್ಲ. 

ಎರಡನೇ ಆಯ್ಕೆಯನ್ನು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಒಂದು ಹೆಸರನ್ನು ನೀಡುವ ಇದೆ. ನೀವು ನಂತರ ಖಣಿಲು-O ಮತ್ತು ನೀವು ಬಯಸುವ ಹೆಸರನ್ನು ಹೇಳಬಹುದು ಫೈಲ್ ಮತ್ತು ನಂತರ program.c ಹೆಸರಿಸಿದ. ಮತ್ತು ನೀವು ಪ್ರೋಗ್ರಾಂ ಚಲಾಯಿಸುತ್ತಾರೆ ಮತ್ತು ಹೇಗೆ ಮೊದಲ 2 ಸಂದರ್ಭಗಳಲ್ಲಿ ನೋಡಬಹುದು ನಾನು. ಸಿ ಪುಟ್, ಮತ್ತು ಮೂರನೇ ಒಂದು ನಾನು ಮಾತ್ರ ಹೊಂದಿವೆ? ಹೌದು, ನೀವು ವಾಸ್ತವವಾಗಿ ಪುಟ್ ಮಾಡಬಾರದು. ಸಿ ನೀವು ಬಳಸಿದಾಗ. ಇಲ್ಲದಿದ್ದರೆ ಕಂಪೈಲರ್ ವಾಸ್ತವವಾಗಿ ನೀವು ಭಯ ಹೋಗಿ ಇದೆ. ನೀವು ಹುಡುಗರಿಗೆ ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ವೇಳೆ ಮತ್ತು, ನಾನು, ಗೊತ್ತಿಲ್ಲ ಆದರೆ ನಾವು ಕೂಡ ಬಳಸಲಾಗುತ್ತದೆ-lcs50 ಅಥವಾ ಐಎಂ ಬಾರಿ ಸಾಕಷ್ಟು. ಆ ಲಿಂಕ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಇದು ಕೇವಲ, ನೀವು ಬಲ ಅಲ್ಲಿ ಆ ಗ್ರಂಥಾಲಯಗಳು ಬಳಸುವ ಕಂಪೈಲರ್ ಹೇಳುತ್ತದೆ ನೀವು cs50.h ಬಳಸಲು ಬಯಸುವ ಆದ್ದರಿಂದ ನೀವು ನಿಜವಾಗಿಯೂ ಟೈಪ್ ಮಾಡಬೇಕು ಖಣಿಲು program.c-lcs50. ನೀವು ಮಾಡದಿದ್ದರೆ, ಕಂಪೈಲರ್ ತಿಳಿಯಲು ಹೋಗುತ್ತಿಲ್ಲ ಇದೆ ನೀವು cs50.h. ಆ ಕಾರ್ಯಗಳನ್ನು ಬಳಸುತ್ತಿದ್ದೀರಿ ಎಂಬುದನ್ನು ಮತ್ತು ನೀವು 2 ಆಯ್ಕೆಗಳು ನಿಮ್ಮ ಪ್ರೊಗ್ರಾಮನ್ನು ಬಯಸಿದಾಗ. ನೀವು ಖಣಿಲು program.c ಮಾಡಿದರೆ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಒಂದು ಹೆಸರನ್ನು ಬಳಸಲಿಲ್ಲ. ನೀವು. / A.out ಬಳಸಿ ಚಾಲನೆ ಮಾಡಬೇಕು. A.out ನೀವು ಒಂದು ಹೆಸರನ್ನು ನೀಡದಿದ್ದಲ್ಲಿ ಖಣಿಲು ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮವನ್ನು ನೀಡುವ ಒಂದು ಸಾಮಾನ್ಯ ಹೆಸರಾಗಿದೆ. ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಒಂದು ಹೆಸರನ್ನು ನೀಡಿದರು, ಇಲ್ಲದಿದ್ದರೆ ನೀವು. / ಪ್ರೋಗ್ರಾಂ ಮಾಡಲು ನೀನು, ನೀವು ಪ್ರೋಗ್ರಾಂ ಹೆಸರು ಮಾಡಿದರು ವೇಳೆ ಮತ್ತು ಒಂದು ಪ್ರೋಗ್ರಾಂ ಕಾಣುವುದು ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ಈಗಾಗಲೇ ಸಿ ಕಡತ ಹೆಸರಿನ ಪ್ರೋಗ್ರಾಮ್ ಏರಲಿದೆ. ನಂತರ ನಾವು ಡೇಟಾ ವಿಧಾನಗಳು ಮತ್ತು ಮಾಹಿತಿ ಬಗ್ಗೆ ಮಾತನಾಡಿದರು. 

ಮೂಲತಃ ಡೇಟಾ ಪ್ರಕಾರಗಳು ಅವರು ಬಳಸುವ ಸಣ್ಣ ಪೆಟ್ಟಿಗೆಗಳು ಅದೇ ಆಗಿವೆ ಮೌಲ್ಯಗಳು ಶೇಖರಿಸಿಡಲು, ಆದ್ದರಿಂದ ಡೇಟಾ ಪ್ರಕಾರಗಳು ಕೇವಲ Pokémons ನಂತಹ ವಾಸ್ತವವಾಗಿ. ಅವರು ಎಲ್ಲಾ ಗಾತ್ರಗಳು ಮತ್ತು ರೀತಿಗಳಲ್ಲಿ ಬರುತ್ತವೆ. ಸಾದೃಶ್ಯವು ಅರ್ಥವಿಲ್ಲ ವೇಳೆ ನನಗೆ ಗೊತ್ತಿಲ್ಲ. ಡೇಟಾವನ್ನು ಗಾತ್ರವು ನಿಜವಾಗಿ ಯಂತ್ರದ ವಿನ್ಯಾಸದ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ. ನಾನು ಇಲ್ಲಿ ತೋರಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ ಎಲ್ಲಾ ಡೇಟಾವನ್ನು ಗಾತ್ರಗಳು ನಮ್ಮ APPLIANCE ಸಂದರ್ಭದಲ್ಲಿ ಇದು ಒಂದು 32 ಬಿಟ್ ಯಂತ್ರ, ಫಾರ್ ವಾಸ್ತವವಾಗಿ ಆದರೆ ನೀವು ನಿಜವಾಗಿಯೂ ನಿಮ್ಮ ಮ್ಯಾಕ್ ಅಥವಾ ವಿಂಡೋಸ್ ಕೂಡ ಕೋಡಿಂಗ್ ಮಾತ್ರ ಬಹುಶಃ ನೀವು, ಒಂದು 64 ಬಿಟ್ ಯಂತ್ರ ಹೊಂದಿರುವ ನೀನು ಆದ್ದರಿಂದ ನಾನು ಹೋಗುತ್ತಿರುವೆ ಡೇಟಾವನ್ನು ಗಾತ್ರಗಳು ಇಲ್ಲಿ ತೋರಿಸಲು ನೆನಪು 32-ಬಿಟ್ ಯಂತ್ರ ಹೊಂದಿದೆ. ನಾವು ನೋಡಿದ ಪ್ರಥಮ ಒಂದು, ಒಂದು int ಆಗಿತ್ತು ಇದು ಬಹಳ ನೇರವಾಗಿದೆ. ನೀವು ಒಂದು ಪೂರ್ಣಾಂಕ ಶೇಖರಿಸಿಡಲು ಇಂಟ್ ಬಳಸಿ. ನಾವು ಪಾತ್ರ ಚಾರ್ ಕಂಡಿತು. ನೀವು ಒಂದು ಅಕ್ಷರ ಅಥವಾ ಸ್ವಲ್ಪ ಚಿಹ್ನೆಯನ್ನು ಬಳಸಲು ಬಯಸಿದರೆ ನೀವು ಬಹುಶಃ ಚಾರ್ ಬಳಸಲು ನೀನು. ಎ ಚಾರ್ Lexi ಹೇಳಿದರು ನಂತಹ 8 ಬಿಟ್ಗಳು, ಅಂದರೆ 1 ಬೈಟ್ ಹೊಂದಿದೆ. ಮೂಲಭೂತವಾಗಿ ನಾವು 256 ಹೊಂದಿರುವ ASCII ಟೇಬಲ್ ಹೊಂದಿರುತ್ತದೆ 0 ಸೆ ಮತ್ತು 1 ಗಳ ಸಂಭಾವ್ಯ ಸಂಯೋಜನೆಗಳಿಂದ, ತದನಂತರ ನೀವು ಚಾರ್ ಟೈಪ್ ಮಾಡಿದಾಗ ಅದನ್ನು ಭಾಷಾಂತರಿಸಲು ವಿಶೇಷವೇನು ಪಾತ್ರದ ಒಳಹರಿವು ನೀವು Lexi ನಂತಹ, ASCII ಕೋಷ್ಟಕದಲ್ಲಿ ಹೊಂದಿರುವ ಹಲವಾರು ಹೇಳಿದ್ದಾರೆ. ನಾವು ದಶಮಾಂಶ ಸಂಖ್ಯೆಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಬಳಸುವ ಫ್ಲೋಟ್ ಹೊಂದಿರುತ್ತವೆ. ನೀವು 3,14 ಆಯ್ಕೆ ಬಯಸಿದರೆ, ಉದಾಹರಣೆಗೆ, ನೀವು ಒಂದು ಫ್ಲೋಟ್ ಬಳಸಲು ನೀನು ಅಥವಾ ಹೆಚ್ಚಿನ ನಿಖರತೆಯನ್ನು ಹೊಂದಿರುವ ಎರಡು. ಒಂದು ಫ್ಲೋಟ್ 4 ಬೈಟ್ಗಳು ಹೊಂದಿದೆ. ಒಂದು ಜೋಡಿ 8 ಬೈಟ್ಗಳು ಹೊಂದಿದೆ, ಆದ್ದರಿಂದ ಕೇವಲ ವ್ಯತ್ಯಾಸ PRECISION ಹೊಂದಿದೆ. ನಾವು, ಪೂರ್ಣಾಂಕಗಳು ಬಳಸುವ ಬಹಳ ಹೊಂದಿವೆ ಮತ್ತು, ಒಂದು int ಮತ್ತು ದೀರ್ಘ ಒಂದೇ ಗಾತ್ರ ಹೊಂದಿವೆ ಒಂದು 32 ಬಿಟ್ ಯಂತ್ರದ ನೋಡಬಹುದು ಆದ್ದರಿಂದ ಇದು ನಿಜವಾಗಿಯೂ ಒಂದು 32 ಬಿಟ್ ಯಂತ್ರದಲ್ಲಿ ಬಹಳ ಬಳಸಲು ಅರ್ಥದಲ್ಲಿ ಮಾಡುವುದಿಲ್ಲ. 

ನೀವು ಮ್ಯಾಕ್ ಮತ್ತು 64 ಬಿಟ್ ಯಂತ್ರ ಬಳಸುತ್ತಿರುವ ಆದರೆ, ವಾಸ್ತವವಾಗಿ ಒಂದು ಉದ್ದ, ಗಾತ್ರ 8 ಹೊಂದಿದೆ ಆದ್ದರಿಂದ ನಿಜವಾಗಿಯೂ ವಿನ್ಯಾಸದ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ. 32-ಬಿಟ್ ಯಂತ್ರ ಇದು ನಿಜವಾಗಿಯೂ ಬಹಳ ಬಳಸಲು ಅರ್ಥದಲ್ಲಿ ಮಾಡುವುದಿಲ್ಲ. ಮತ್ತು ನಂತರ ಒಂದು ದೀರ್ಘ ದೀರ್ಘ, ಮತ್ತೊಂದೆಡೆ, 8 ಬೈಟ್ಗಳು ಹೊಂದಿದೆ ನೀವು ಮುಂದೆ ಪೂರ್ಣಾಂಕ ಬೇಕು ಆದ್ದರಿಂದ ಇದು ಬಹಳ ಒಳ್ಳೆಯದು. ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಾವು, ವಾಸ್ತವವಾಗಿ ಒಂದು ಚಾರ್ * ಇದು, ದಾರಗಳನ್ನು ಒಂದು ಹಾಳೆಯನ್ನು ಒಂದು ಸೂಚಿಯಾಗಿದೆ. ಇದು ತಂತುವಿನ ಗಾತ್ರ ಹಾಗೆ ಹೋಗುತ್ತದೆ ಭಾವಿಸುತ್ತೇನೆ ಬಹಳ ಸುಲಭ ನೀವು ಹೊಂದಿರುವ ಪಾತ್ರಗಳ ಸಂಖ್ಯೆ, ಆದರೆ ವಾಸ್ತವವಾಗಿ ಚಾರ್ * ಸ್ವತಃ 4 ಬೈಟ್ಗಳು ಇದು ಚಾರ್, ಒಂದು ಪಾಯಿಂಟರ್ ಗಾತ್ರವನ್ನು ಹೊಂದಿದೆ. ಒಂದು ಚಾರ್ * ಗಾತ್ರವನ್ನು 4 ಬೈಟ್ಸ್. ನೀವು ಒಂದು ಸಣ್ಣ ಪದ ಅಥವಾ ಅಕ್ಷರ ಅಥವಾ ಏನು ಹೊಂದಿದ್ದರೆ ಅದು ಲೆಕ್ಕಕ್ಕೆ ಬರುವುದಿಲ್ಲ. ಇದು 4 ಬೈಟ್ಗಳು ಎಂದು ವಿಶೇಷವೇನು. ನಾವು, CASTING ಬಗ್ಗೆ ಸ್ವಲ್ಪ ಕಲಿತ ನೀವು ಹೊಂದಿದ್ದರೆ ನೀವು ನೋಡಬಹುದು ಎಂದು, ಉದಾಹರಣೆಗೆ, ಒಂದು ಪ್ರೋಗ್ರಾಂ ಹೇಳುತ್ತದೆ ಇಂಟ್ x = 3 ತದನಂತರ printf ("% s", X / 2) ನೀವು ಹುಡುಗರಿಗೆ ಇದು ಪರದೆಯ ಮೇಲೆ ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು ಏನು ಗೊತ್ತೇ? 

ಯಾರೋ? >> [ವಿದ್ಯಾರ್ಥಿಗಳು] 2. 1. >> 1, ಹೌದು. 3/2 ಮಾಡಿದಾಗ ಅದು 1.5 ಪಡೆಯಲು ವಿಶೇಷವೇನು ನಾವು ಒಂದು ಪೂರ್ಣಾಂಕ ಬಳಸುತ್ತಿರುವ ಕಾರಣ ಆದರೆ, ದಶಮಾಂಶ ಭಾಗವಾಗಿ ನಿರ್ಲಕ್ಷಿಸಲು ವಿಶೇಷವೇನು ಮತ್ತು ನೀವು 1 ಹೊಂದಿವೆ ಎಂದು ನೀನು. ನೀವು, ಉದಾಹರಣೆಗೆ, ನೀವು ಏನು ಮಾಡಬಹುದು ತೀರುತ್ತದೆ ಬಯಸದಿದ್ದರೆ ಒಂದು ಫ್ಲೋಟ್ ಘೋಷಿಸಲು ಇದೆ Y = X. ನಂತರ 3 ಎಂದು ಬಳಸಿದ X ಈಗ ವೈ ರಲ್ಲಿ 3,000 ಏರಲಿದೆ. ತದನಂತರ ನೀವು ವೈ / 2 ಮುದ್ರಿಸಬಹುದು. ವಾಸ್ತವವಾಗಿ, ನಾನು 2 ಇರಬೇಕು. ಆ. ಇದು 3.00/2.00 ಮಾಡಲು ವಿಶೇಷವೇನು ಮತ್ತು ನೀವು 1.5 ಪಡೆಯಲು ನೀನು. ಮತ್ತು ನಾವು ದಶಮಾಂಶ ಭಾಗದಲ್ಲಿ 2 ದಶಮಾಂಶ ಘಟಕಗಳಿಗೆ ಕೇಳಲು ಈ .2 f ನ. ನೀವು .3 F ಹೊಂದಿದ್ದರೆ ನಿಜವಾಗಿ 1.500 ಇರುತ್ತವೆ ಹೊಂದಲು ವಿಶೇಷವೇನು. ಅದು ವೇಳೆ 2 ಇದು 1.50 ಎಂದು ವಿಶೇಷವೇನು. ನಾವು ಇಲ್ಲಿ ಈ ಸಂದರ್ಭದಲ್ಲಿ ಹೊಂದಿರುತ್ತದೆ. ನೀವು ಫ್ಲೋಟ್ ಮಾಡಿದರೆ X = 3,14 ಮತ್ತು ನಂತರ ನೀವು printf X ನೀವು 3,14 ಪಡೆಯಲು ನೀನು. ಮತ್ತು ನೀವು ವೇಳೆ X x ನ = ಇಂಟ್, ಒಂದು ಇಂಟ್ ಮಾಹಿತಿ X ಚಿಕಿತ್ಸೆ ಅರ್ಥ ಮತ್ತು ನೀವು ಈಗ X ಮುದ್ರಿಸಲು ಇದು ನೀವು 3.00 ಹೊಂದಿರುವ ನೀನು. ಎಂದು ಅರ್ಥ ಡಸ್? ನೀವು ಮೊದಲು ಒಂದು ಪೂರ್ಣಾಂಕವಾಗಿ X ಚಿಕಿತ್ಸೆ ಆಗಿರುವ ಕಾರಣ, ಆದ್ದರಿಂದ ನೀವು ದಶಮಾಂಶ ಭಾಗವನ್ನು ಉಪೇಕ್ಷಿಸಿ ನೀವು ತದನಂತರ ನೀವು X ಮುದ್ರಣ ಮಾಡುತ್ತಿದ್ದೇವೆ. ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನೀವು, ಈ ಮಾಡಬಹುದು ಇಂಟ್ x = 65, ಮತ್ತು ನಂತರ ನೀವು ಚಾರ್ ಸಿ = X ಘೋಷಿಸಿದ, ನೀವು ಸಿ ಮುದ್ರಿಸಲು ವೇಳೆ ಮತ್ತು ನಂತರ ನೀವು ನಿಜವಾಗಿಯೂ ಪಡೆಯಲು ನೀನು ಒಂದು, ನೀವು ಇಲ್ಲಿ ಆದ್ದರಿಂದ ಮೂಲಭೂತವಾಗಿ ಏನು ಮಾಡುತ್ತಿದ್ದೇವೆ , ಪಾತ್ರದ ಗೆ ಪೂರ್ಣಾಂಕ ಅನುವಾದ ಇದೆ ಕೇವಲ ರೀತಿಯ ASCII ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ. ನಾವು ಗಣಿತ ನಿರ್ವಾಹಕರು ಬಗ್ಗೆ ಮಾತನಾಡಿದರು. ಅವುಗಳಲ್ಲಿ ಅತ್ಯಂತ ಬಹಳ ಸರಳವಾಗಿದ್ದು, ಆದ್ದರಿಂದ +, -, *, /, ಮತ್ತು ನಾವು 2 ಸಂಖ್ಯೆಗಳ ವಿಭಾಗ ಉಳಿದ ಇದು ಮೋಡ್ ಬಗ್ಗೆ ಮಾತನಾಡಿದರು. ನೀವು ಉದಾಹರಣೆಗೆ 10% 3, ಇದ್ದರೆ ಇದು 3 ರಿಂದ 10 ಭಾಗಿಸಿ ಎಂದರ್ಥ, ಮತ್ತು ಉಳಿದ ಏನು? ಇದು 1 ಎಂದು, ಆದ್ದರಿಂದ ಇದು ಕಾರ್ಯಕ್ರಮಗಳು ಸಾಕಷ್ಟು ನಿಜವಾಗಿ ತುಂಬಾ ಉಪಯುಕ್ತವಾಗಿರುವ. Vigenère ಮತ್ತು ಸೀಸರ್ ನಾನು ನೀವು ಹುಡುಗರಿಗೆ ಎಲ್ಲಾ ಮಾಡ್ ಬಳಸಿದ ಬಹಳ ನನಗೆ ಖಾತ್ರಿಯಿದೆ. * ಮತ್ತು / ಸಂಯೋಜಿಸಿದಾಗ ಗಣಿತ ನಿರ್ವಾಹಕರು ಬಗ್ಗೆ, ಜಾಗ್ರತೆಯಿಂದಿರಬೇಕು. 

ನೀವು ಉದಾಹರಣೆಗೆ, (3/2) * 2 ಏನು ಪಡೆಯಲು ಹೋಗುವ? [ವಿದ್ಯಾರ್ಥಿಗಳು] 2. ಹೌದು, 2, 3/2 ಕಾರಣ 1.5 ಎಂದು ಹೋಗುತ್ತದೆ, ಆದರೆ ನೀವು 2 ಪೂರ್ಣಾಂಕಗಳ ನಡುವೆ ಕಾರ್ಯಾಚರಣೆಗಳ ಮಾಡುತ್ತಿರುವುದು ರಿಂದ ನಿಜವಾಗಿಯೂ, ಕೇವಲ 1 ಪರಿಗಣಿಸಲು ನೀನು ನಂತರ 1 * 2 2 ಎಂದು ಹೋಗುತ್ತದೆ, ಆದ್ದರಿಂದ ತುಂಬಾ ಜಾಗರೂಕರಾಗಿರಿ ಪೂರ್ಣಾಂಕಗಳ ಜೊತೆ ಅಂಕಗಣಿತದ ಮಾಡುವಾಗ ಏಕೆಂದರೆ ಆ ಸಂದರ್ಭದಲ್ಲಿ, 2 = 3 ಸಿಗುತ್ತವೆ. ಮತ್ತು ಅಗ್ರಸ್ಥಾನವನ್ನು ಬಗ್ಗೆ ಜಾಗರೂಕರಾಗಿರಿ. ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ನೀವು ಮಾಡುವ ಏನನ್ನು ತಿಳಿಯಲು ಖಚಿತವಾಗಿ ಎಂದು ಆವರಣ ಬಳಸಬೇಕು. ಕೆಲವು ಉಪಯುಕ್ತ ಶಾರ್ಟ್ಕಟ್ಗಳನ್ನು, ಸಹಜವಾಗಿ, ಒಂದು ನಾನು + + ಅಥವಾ i + 1 = ಅಥವಾ ಬಳಸಿಕೊಂಡು + =. ನಾನು = ನಾನು + 1 ಮಾಡುವ ಅದೇ ವಿಷಯ. ನೀವು ನಾನು ಮಾಡಬಹುದು - ಅಥವಾ ನಾನು - = 1, ಇದು, ನಾನು = ನಾನು -1 ಅದೇ ವಿಷಯ ಏನೋ ನೀವು ಹುಡುಗರಿಗೆ ಕನಿಷ್ಠ ಕುಣಿಕೆಗಳು ಗಾಗಿ ಬಹಳಷ್ಟು ಬಳಸಿ. ಸಹ, *, ನೀವು * = ಮತ್ತು ನೀವು ಹೋದರೆ, ಉದಾಹರಣೆಗೆ ಬಳಸುತ್ತಿದ್ದರೆ, ನಾನು * = 2 ನಾನು = ನಾನು * 2 ಹೇಳುವ ಅದೇ ವಿಷಯ, ಮತ್ತು ವಿಭಾಗಕ್ಕೆ ಒಂದೇ. ನೀವು ನಾನು / = 2 ಮಾಡಿದರೆ ನಾನು = I / 2 ಅದೇ ವಿಷಯ. 

ಈಗ ಕಾರ್ಯಗಳನ್ನು ಬಗ್ಗೆ. ನೀವು ಹುಡುಗರಿಗೆ ಕಾರ್ಯಗಳನ್ನು ಕೋಡ್ ಉಳಿಸಲು ಉತ್ತಮ ತಂತ್ರ ಕಲಿತಿದ್ದು ನೀವು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮಾಡುತ್ತಲೇ, ನೀವು ಕೆಲಸವನ್ನು ನಿರ್ವಹಿಸಲು ಬಯಸಿದಲ್ಲಿ ಕೋಡ್ ಮತ್ತೆ ಮತ್ತೆ, ಪ್ರಾಯಶಃ ನೀವು ಕಾರ್ಯವನ್ನು ಬಳಸಲು ಬಯಸುವ ಕೇವಲ ಆದ್ದರಿಂದ ನೀವು ಮತ್ತೊಮ್ಮೆ ಮತ್ತು ಮೇಲೆ ಕೋಡ್ ನಕಲಿಸಿ ಮತ್ತು ಅಂಟಿಸಿ ಇಲ್ಲ. ವಾಸ್ತವವಾಗಿ, ಮುಖ್ಯ ಕಾರ್ಯ, ಮತ್ತು ನಾನು ಒಂದು ಕ್ರಿಯೆಯ ಸ್ವರೂಪ ಪ್ರದರ್ಶಿಸಿದಾಗ ನೀವು ಸಾಕಷ್ಟು ಸ್ಪಷ್ಟವಾಗಿರುವ ನೋಡಲು ನೀನು. ನಾವು ಕೆಲವು ಲೈಬ್ರರಿಗಳಿಂದ ಕಾರ್ಯಗಳನ್ನು ಬಳಸಿ ಉದಾಹರಣೆಗೆ, printf, CS50 ಲೈಬ್ರರಿಯಿಂದ ಇದು GetIn, ಮತ್ತು toupper ಇತರ ಕಾರ್ಯಗಳು. ಆ ಕಾರ್ಯಗಳನ್ನು ಎಲ್ಲಾ ವಾಸ್ತವವಾಗಿ, ಇತರ ಗ್ರಂಥಾಲಯಗಳು ಅಳವಡಿಸಲಾಗಿದೆ ಮತ್ತು ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಪ್ರಾರಂಭದಲ್ಲಿ ಆ tether ಕಡತಗಳನ್ನು ಹುಟ್ಟುಹಾಕಿದಾಗ ನೀವು ನನ್ನನ್ನು ಆ ಕಾರ್ಯಗಳನ್ನು ಕೋಡ್ ನೀಡಿ ಮಾಡಬಹುದು ಹೇಳುತ್ತಿದ್ದಾರೆಂಬುದನ್ನು ಆದ್ದರಿಂದ ನಾನು ಅವುಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಇಲ್ಲ? ಮತ್ತು ನೀವು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಪ್ರಾರಂಭಿಸಿದಾಗ ಆದ್ದರಿಂದ, ನಿಮ್ಮ ಸ್ವಂತ ಕಾರ್ಯಗಳನ್ನು ಬರೆಯಬಹುದು ನೀವು ಗ್ರಂಥಾಲಯಗಳು ನೀವು ಎಲ್ಲಾ ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿರುವುದಿಲ್ಲ ಎಂಬುದನ್ನು. ಕೊನೆಯ pset ಉದಾಹರಣೆಗೆ,, ನಾವು, ಸ್ಕ್ರಾಂಬಲ್ ಸೆಳೆಯುತ್ತವೆ, ಮತ್ತು ನೋಡುವಿಕೆಯನ್ನು ಬರೆದರು ಮತ್ತು ಕಾರ್ಯಗಳನ್ನು ಬರೆಯಲು ಮಾಡಲು ತುಂಬಾ ಮುಖ್ಯ ಅವರು ಉಪಯುಕ್ತ, ಹಾಗೂ ನಾವು ಅವುಗಳನ್ನು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಎಲ್ಲಾ ಸಮಯದಲ್ಲಿ ಬಳಸಲು ಕಾರಣ, ಮತ್ತು ಇದು ಕೋಡ್ ಸಾಕಷ್ಟು ಉಳಿಸುತ್ತದೆ. ಒಂದು ಕ್ರಿಯೆಯ ಸ್ವರೂಪವನ್ನು ಈ ಒಂದಾಗಿದೆ. ನಾವು ಆರಂಭದಲ್ಲಿ ಲಾಭ ರೀತಿಯ. ರಿಟರ್ನ್ ಪ್ರಕಾರ ಯಾವುದು? ನಿಮ್ಮ ಕಾರ್ಯ ಮರಳಲು ಹತ್ತಿದರೆ ಜಸ್ಟ್. ನೀವು ಅಪವರ್ತನೀಯ ಉದಾಹರಣೆಗೆ ಒಂದು ಕ್ರಿಯೆ, ಇದ್ದರೆ ಎಂದು, ಒಂದು ಪೂರ್ಣಾಂಕ ಒಂದು ಅಪವರ್ತನೀಯ ಲೆಕ್ಕ ಹಾಕುತ್ತದೆ ಬಹುಶಃ ಇದು ಒಂದು ಪೂರ್ಣಾಂಕ ಮರಳಲು ವಿಶೇಷವೇನು. ನಂತರ ಮರಳಿ ರೀತಿಯ ಇಂಟ್ ಏರಲಿದೆ. Printf ವಾಸ್ತವವಾಗಿ ಒಂದು ರಿಟರ್ನ್ ರೀತಿಯ ಶೂನ್ಯವನ್ನು ಹೊಂದಿದೆ ನೀವು ಏನು ಹಿಂದಿರುಗಿದ ಆಗದೇ ಇರುವ ಕಾರಣ. ನೀವು ತೆರೆಯ ವಿಷಯಗಳನ್ನು ಮುದ್ರಿಸುವ ನೀವು ನಂತರ ಕಾರ್ಯ ತೊರೆದು. ನಂತರ ನೀವು ಆಯ್ಕೆ ಮಾಡುವ ಕ್ರಿಯೆಯ ಹೆಸರನ್ನು ಹೊಂದಿವೆ. XYZ ಒಂದು ಹೆಸರನ್ನು ಆಯ್ಕೆ ಇಲ್ಲ ನಿಮಗೆ, ಸ್ವಲ್ಪ ಸಮಂಜಸವಾದ ಆಗಿರಬೇಕು ಅಥವಾ x2f ನಂತಹ. ಅರ್ಥವನ್ನು ನೀಡುವ ಒಂದು ಹೆಸರನ್ನು ಅಪ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿ. 

ಉದಾಹರಣೆಗೆ, ಇದು ಅಪವರ್ತನೀಯ ಇದ್ದರೆ, ಅಪವರ್ತನೀಯ ಹೇಳುತ್ತಾರೆ. ಯಾವುದನ್ನಾದರೂ ಸೆಳೆಯಲು ಹೋಗುತ್ತದೆ ಒಂದು ಫಂಕ್ಷನ್ ಅದನ್ನು ಡ್ರಾ ಹೆಸರು. ನಂತರ ನಾವು ವಾದಗಳನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ ಮಾನದಂಡಗಳು, ಹೊಂದಿವೆ ನಿಮ್ಮ ಕಾರ್ಯ ಅಗತ್ಯವಿರುವ ಸಂಪನ್ಮೂಲಗಳನ್ನು ರೀತಿಯಲ್ಲಿ ಇವು ನಿಮ್ಮ ಕೋಡ್ ಅದರ ಕಾರ್ಯ ನಿರ್ವಹಿಸಲು. ನೀವು ಒಂದು ಸಂಖ್ಯೆಯ ಅಪವರ್ತನೀಯ ಲೆಕ್ಕ ಬಯಸಿದರೆ ಬಹುಶಃ ನೀವು ಅಪವರ್ತನೀಯ ಲೆಕ್ಕಹಾಕಲು ಒಂದು ಸಂಖ್ಯೆಯ ಅಗತ್ಯವಿದೆ. ನೀವು ಎಂದು ನೀನು ಆ ವಾದಗಳಲ್ಲಿ ಒಂದು ಸಂಖ್ಯೆ ಆಗಿದೆ. ನಂತರ ಅದನ್ನು ಏನಾದರೂ ಮತ್ತು ಕೊನೆಯಲ್ಲಿ ಮೌಲ್ಯವನ್ನು ಮರಳಲು ವಿಶೇಷವೇನು ಇದು ಶೂನ್ಯವನ್ನು ಕಾರ್ಯ ದ ಹೊರತು. ನ ಒಂದು ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ. ನಾನು, ಪೂರ್ಣಾಂಕಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಎಲ್ಲಾ ಸಂಖ್ಯೆಗಳು ಸಂಯೋಜಿಸುತ್ತಾನೆ ಒಂದು ಫಂಕ್ಷನ್ ಬರೆಯಲು ಬಯಸಿದರೆ ಎಲ್ಲಾ ಮೊದಲ, ರಿಟರ್ನ್ ಪ್ರಕಾರ ಇಂಟ್ ಏರಲಿದೆ ನಾನು ಪೂರ್ಣಾಂಕಗಳ ವ್ಯೂಹದ ಕಾರಣ. ಆಗ ನಾನು, sumArray ನಂತಹ ಕಾರ್ಯವನ್ನು ಹೆಸರನ್ನು ಹೊಂದಲು ಪಡೆಯಲಿದ್ದೇನೆ ನಂತರ ಅದನ್ನು, ಇಂಟ್ nums ಗೆ, ಸರಣಿ ಸ್ವತಃ ತೆಗೆದುಕೊಳ್ಳುವುದು ತದನಂತರ ನಾನು ಮೊತ್ತಕ್ಕೆ ಎಷ್ಟು ಸಂಖ್ಯೆಗಳನ್ನು ತಿಳಿದಿರುವುದರಿಂದ ರಚನೆಯ ಉದ್ದ. ನಂತರ ನಾನು 0 ಉದಾಹರಣೆಗೆ ಒಂದು ವೇರಿಯೇಬಲ್ ಎಂಬ ಮೊತ್ತವು, ಆರಂಭಿಸಲು ಹೊಂದಿವೆ ಮತ್ತು ನಾನು ಶ್ರೇಣಿಯಲ್ಲಿನ ಒಂದು ಅಂಶ ನೋಡಿ ಪ್ರತಿ ಬಾರಿ ನಾನು ಮೊತ್ತವು ಇದನ್ನು ಸೇರಿಸಬೇಕು, ಆದ್ದರಿಂದ ನಾನು ಲೂಪ್ ಒಂದು ಮಾಡಿದರು. Lexi ಹೇಳಿದರು ಹಾಗೆ, ನೀವು ಇಂಟ್ ನಾನು = 0, ನಾನು <ಉದ್ದ ಮತ್ತು i + +. ಮತ್ತು ರಚನೆಯ ಪ್ರತಿ ಅಂಶ ನಾನು ಮೊತ್ತವು + = nums [I] ಮಾಡಿದರು, ತದನಂತರ ನಾನು ಮೊತ್ತವು ಮರಳಿದರು, ಆದ್ದರಿಂದ ತುಂಬಾ ಸುಲಭ, ಮತ್ತು ಅದನ್ನು ಕೋಡ್ ಸಾಕಷ್ಟು ಉಳಿಸುತ್ತದೆ ನೀವು ಈ ಕಾರ್ಯವನ್ನು ಬಾರಿ ಸಾಕಷ್ಟು ಬಳಸುತ್ತಿದ್ದರೆ. ನಾವು ಸ್ಥಿತಿಗತಿಗಳ ಅವಲೋಕನ ಮಾಡಿಕೊಂಡೆವು. ನಾವು ಬೇರೆ, ವೇಳೆ ಹೊಂದಿವೆ, ಮತ್ತು ಬೇರೆ ವೇಳೆ. ಆ ನಡುವೆ ವ್ಯತ್ಯಾಸ ಏನು ನೋಡೋಣ. ಈ 2 ಸಂಕೇತಗಳು ನೋಡೋಣ. ಅವುಗಳ ನಡುವೆ ವ್ಯತ್ಯಾಸ ಏನು? ಮೊದಲ ಒಂದು ಮೂಲಭೂತವಾಗಿ ಮಾಡಿದೆ ಸಂಕೇತಗಳು ಹೇಳಲು ಬಯಸುವ , ಅಥವಾ 0 - ಹಲವಾರು + ವೇಳೆ. ಮೊದಲ ಒಂದು ಇದು> 0 ಇದ್ದರೆ ಅದು ಧನಾತ್ಮಕ ಹೇಳುವಂತೆ. ಇದು 0 ಗೆ = ಆಗಿದ್ದರೆ ಅದು 0, ಮತ್ತು <0 ಇದ್ದರೆ ಅದು ನಕಾರಾತ್ಮಕವಾಗಿದೆ. 

ಬೇರೆ, ಬೇರೆ ವೇಳೆ, ವೇಳೆ ಮತ್ತು ಇತರ ಒಂದು ಮಾಡುತ್ತೇವೆ. ಎರಡು ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಈ ಒಂದು ವಾಸ್ತವವಾಗಿ ಹೋಗುವ ಇದೆ ಎಂದು ಪರಿಶೀಲಿಸಿ ವೇಳೆ> 0, <= 0 0 ಅಥವಾ ಮೂರು ಬಾರಿ, ನೀವು ಸಂಖ್ಯೆ 2 ಹಾಗಾಗಿ, ಉದಾಹರಣೆಗೆ, ಇದು ಇಲ್ಲಿ ಬಂದು ಹೇಳಲು ವಿಶೇಷವೇನು ಅದು ಹೌದು ಹೇಳಲು ವಿಶೇಷವೇನು (X> 0) ವೇಳೆ, ಮತ್ತು, ಆದ್ದರಿಂದ ನಾನು ಧನಾತ್ಮಕ ಮುದ್ರಿಸಿ. ಆದರೆ ನಾನು> 0 ಗೊತ್ತಾಯಿತು ಮತ್ತು 0 ಅಥವಾ <0 ಹಿಂದಿರುಗಬಹುದೆಂದು ಸಹ ನಾನು ಇನ್ನೂ 0 ಮಾಡಲು ಪಡೆಯಲಿದ್ದೇನೆ, ಇದು, <0 ಆದ್ದರಿಂದ ನಾನು ಇಲ್ಲ ಎಂದು IFS ಒಳಗೆ ಪಡೆಯಲಿದ್ದೇನೆ ನಾನು ಈಗಾಗಲೇ ಈ ಪರಿಸ್ಥಿತಿಗಳ ಯಾವುದೇ ಪೂರೈಸಲು ಹೋಗುತ್ತಿಲ್ಲ ಎಂದು ತಿಳಿದಿರುವ ಕಾರಣ. ನಾನು ಹೇಳಿಕೆಯನ್ನು ಬೇರೆ, ಬೇರೆ ವೇಳೆ, ನೀವು ಬಳಸಬಹುದು. X = 0 ನಾನು ಧನಾತ್ಮಕ ಮುದ್ರಿಸಲು ಅದು ಮೂಲಭೂತವಾಗಿ ಹೇಳುತ್ತದೆ. ಇದು ಅಲ್ಲ ವೇಳೆ, ನಾನು ಈ ಪರೀಕ್ಷಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ. ಇದನ್ನು 2 ರ ವೇಳೆ ನಾನು ಇದನ್ನು ಮಾಡಲು ನನಗೆ ಸಾಧ್ಯವಿಲ್ಲ. ನಾನು X = 2 ಹೊಂದಿದ್ದರೆ ಮೂಲತಃ ನೀವು ಹೇಳಬಹುದು (X> 0) ವೇಳೆ, ಹೌದು, ಈ ಮುದ್ರಿಸಿ. ಈಗ ನಾನು> 0 ಗೊತ್ತಾಯಿತು ಎಂದು ಮತ್ತು ಅದು ಮೊದಲ ವೇಳೆ ತೃಪ್ತಿ ನಾನು ಈ ಕೋಡ್ ರನ್ ಹೋಗಿ ಇಲ್ಲ. ಈ ಬಳಸುತ್ತಿದ್ದರೆ ಕೋಡ್ 3 ಪಟ್ಟು ವೇಗವಾಗಿ, ವಾಸ್ತವವಾಗಿ, ವೇಗವಾಗಿ ಚಲಿಸುತ್ತದೆ. ನಾವು ಸುಮಾರು ಮತ್ತು ಮತ್ತು ಅಥವಾ ಕಲಿತರು. ನಾನು Lexi ಈಗಾಗಲೇ ಬಗ್ಗೆ ಮಾತನಾಡಿದರು ಏಕೆಂದರೆ ಈ ಮೂಲಕ ಹೋಗುತ್ತಿದ್ದೇವೆ ಇಲ್ಲ. | ಆಯೋಜಕರು | ಅದು && ಮತ್ತು ಇಲ್ಲಿದೆ. 

ನಾನು ಹೇಳುತ್ತೇನೆ ಮಾತ್ರ ವಿಷಯ ನೀವು 3 ಪರಿಸ್ಥಿತಿಯ ಎಚ್ಚರಿಕೆಯಿಂದಿರಿ ಹೊಂದಿದೆ. ಇದು ತುಂಬಾ ಗೊಂದಲಮಯ ಏಕೆಂದರೆ ನೀವು ಸ್ಥಿತಿಯನ್ನು ಹೊಂದಿರುವಾಗ ಆವರಣ ಬಳಸಿ ಮತ್ತು ಇನ್ನೊಂದು ಒಂದು ಅಥವಾ ಮತ್ತೊಂದು. ನಿಮ್ಮ ಪರಿಸ್ಥಿತಿಗಳು ಅರ್ಥ ಖಚಿತವಾಗಿ ಎಂದು ಆವರಣ ಬಳಸಿ ಆ ಸಂದರ್ಭದಲ್ಲಿ, ಉದಾಹರಣೆಗೆ, ನಿಮ್ಮ ಕಲ್ಪನೆಯ ಏಕೆಂದರೆ ಇದು ಮೊದಲ ಸ್ಥಿತಿಗೆ ಮತ್ತು ಒಂದು ಅಥವಾ ಇತರ ಆಗಿರಬಹುದು ಅಥವಾ 2 ಒಂದು ಸಂಯೋಜಿಸಲ್ಪಟ್ಟಿವೆ ಪರಿಸ್ಥಿತಿಗಳು ಮತ್ತು ಅಥವಾ ಮೂರನೇ ಒಂದು, ಆದ್ದರಿಂದ ಕೇವಲ ಜಾಗರೂಕರಾಗಿರಿ. ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಾವು ಸ್ವಿಚ್ಗಳು ಬಗ್ಗೆ ಮಾತನಾಡಿದರು. ನೀವು ವೇರಿಯಬಲ್ ಹೊಂದಿವೆ ಒಂದು ಸ್ವಿಚ್ ಬಹಳ ಉಪಯುಕ್ತವಾಗಿದೆ. ಲೆಟ್ಸ್ ನೀವು N ಒಂದು ವೇರಿಯೇಬಲ್ ಹೇಳುವುದು ಆ 0, 1, ಅಥವಾ 2 ಮಾಡಬಹುದು, ಮತ್ತು ಆ ಪ್ರಕರಣಗಳು ಪ್ರತಿ ನೀವು ಕೆಲಸ ಮಾಡಲು ನೀನು. ನೀವು ವೇರಿಯಬಲ್ ಬದಲಾಯಿಸಲು ಹೇಳಬಹುದು, ಮತ್ತು ಇದು ಸೂಚಿಸುತ್ತದೆ ಮೌಲ್ಯದ ನಂತರ, ಮೌಲ್ಯ 1 ನಂತಹ ನಾನು ಹಾಗೆ ಹೋಗುವ ನನಗೆ ಮತ್ತು ನಂತರ ನಾನು ಬ್ರೇಕ್, ಇದು ನಾನು ಇತರ ಸಂದರ್ಭಗಳಲ್ಲಿ ಯಾವುದೇ ನೋಡಲು ಹೋಗುವ ಇಲ್ಲ ಅರ್ಥ ನಾವು ಈಗಾಗಲೇ ಕೇಸ್ ತೃಪ್ತಿ ಏಕೆಂದರೆ ತದನಂತರ VALUE2 ಹೀಗೆ, ಮತ್ತು ನಾನು ಒಂದು ಡೀಫಾಲ್ಟ್ ಸ್ವಿಚ್ ಹೊಂದಬಹುದು. ನಾನು ಹೊಂದಿದ್ದ ಸಂದರ್ಭಗಳಲ್ಲಿ ಯಾವುದೇ ಪದಗಳನ್ನು ಇದ್ದಲ್ಲಿ ಅರ್ಥ ನಾನು ಬೇರೇನಾದರೂ ಮಾಡುವಂತೆ ಪಡೆಯಲಿದ್ದೇನೆ, ಆದರೆ ಐಚ್ಛಿಕ ಎಂದು. ನನಗೆ ಎಲ್ಲಾ ಆ. ಈಗ ಟಾಮಿ ಹೊಂದಿವೆ ಅವಕಾಶ. ಸರಿ, ಈ ವಾರ 3 ರೀತಿಯಲ್ಲಿ ಎಂದು ಹೋಗುತ್ತದೆ. ಈ ನಾವು, ಎಟ್ ಇತ್ಯಾದಿ ಕ್ರಿಪ್ಟೋ, ವ್ಯಾಪ್ತಿ, ಸಾಲುಗಳು, ಕವರಿಂಗ್ ಪಡೆದುಕೊಳ್ಳುತ್ತೀರಿ ವಿಷಯಗಳ ಕೆಲವು. ಕ್ರಿಪ್ಟೋ ಮೇಲೆ ಕೇವಲ ಒಂದು ತ್ವರಿತ ಪದ. ನಾವು ಈ ಮನೆ ಬಡಿಯಲು ಹೋಗುತ್ತಿಲ್ಲ. 

ನಾವು pset 2 ಈ ಆದರೆ ರಸಪ್ರಶ್ನೆ ನೀವು ವ್ಯತ್ಯಾಸವನ್ನು ತಿಳಿಯಲು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಸೀಸರ್ ಸೈಫರ್ ಮತ್ತು Vigenère ಸೈಫರ್ ನಡುವೆ, ಆ ಸೈಫರ್ಗಳು ಕೆಲಸ ಎರಡೂ ಮತ್ತು ಅದರ ಗೂಢಲಿಪೀಕರಿಸಲು ರೀತಿಯಲ್ಲಿ ಹೇಗೆ ಆ 2 ಸೈಫರ್ಗಳು ಬಳಸಿಕೊಂಡು ಡೀಕ್ರಿಪ್ಟ್ ಪಠ್ಯ. ನೆನಪಿಡಿ, ಸೀಸರ್ ಸೈಫರ್ ಸರಳವಾಗಿ, ಅದೇ ಪ್ರಮಾಣದ ಪ್ರತಿ ಪಾತ್ರದ ತಿರುಗುತ್ತಿದೆ ವರ್ಣಮಾಲೆಯ ಅಕ್ಷರಗಳನ್ನು ಸಂಖ್ಯೆಯಿಂದ ನೀವು ಮಾಡ್ ದೃಢಪಡಿಸಿಕೊಳ್ಳಬೇಕು. ಮತ್ತು Vigenère ಸೈಫರ್, ಇನ್ನೊಂದೆಡೆ, ಪ್ರತಿ ಪಾತ್ರದ ತಿರುಗುತ್ತಿದೆ ಬೇರೆ ಪ್ರಮಾಣದ ಮೂಲಕ, ಆದ್ದರಿಂದ ಬದಲಿಗೆ ಹೇಳುವ ಹೆಚ್ಚು 3 Vigenère ಪ್ರತಿ ಪಾತ್ರದ ಸುತ್ತುವ ಪ್ರತಿ ಪಾತ್ರದ ತಿರುಗಿಸಲು ಕಾಣಿಸುತ್ತದೆ ಕೆಲವು ಕೀವರ್ಡ್ ಆಧಾರದ ಮೇಲೆ ವಿವಿಧ ಪ್ರಮಾಣದ ಮೂಲಕ ಕೀವರ್ಡ್ ಪ್ರತಿಯೊಂದು ಅಕ್ಷರದ ಕೆಲವು ವಿಭಿನ್ನ ಪ್ರಮಾಣವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಅದಕ್ಕೆ ಸ್ಪಷ್ಟ ಪಠ್ಯ ತಿರುಗಿಸಲು. ವೇರಿಯಬಲ್ ವ್ಯಾಪ್ತಿ ಬಗ್ಗೆ ಮೊದಲ ಚರ್ಚೆ ಮಾಡೋಣ. ಅಸ್ಥಿರ 2 ವಿವಿಧ ವಿಧಗಳಿವೆ. ನಾವು ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು ಹೊಂದಿವೆ, ಮತ್ತು ಈ ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು ಹೋಗುವ ಹೊರಗೆ ಪ್ರಮುಖ ಅಥವಾ ಯಾವುದೇ ಕ್ರಿಯೆ ಅಥವಾ ಬ್ಲಾಕ್ ಹೊರಗೆ, ಮತ್ತು ಈ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ನಗರದಲ್ಲಿ ಪ್ರವೇಶಿಸಬಹುದು. ನೀವು ಒಂದು ಫಂಕ್ಷನ್ ಮತ್ತು ಕಾರ್ಯದಲ್ಲಿ ಸ್ವಲ್ಪ ಲೂಪ್ ವೇಳೆ ದೊಡ್ಡ ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಎಲ್ಲೆಡೆ ಪ್ರವೇಶಿಸಬಹುದು. ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್ ಮತ್ತೊಂದೆಡೆ, ಅದನ್ನು ಅಲ್ಲಿ ಸ್ಥಳಕ್ಕೆ ಕ್ಷೇತ್ರ ಆಗಿದೆ. 

ನೀವು ಇಲ್ಲಿ ಒಂದು ಫಂಕ್ಷನ್ ವೇಳೆ, ಉದಾಹರಣೆಗೆ, ನಾವು, ಈ ಫಂಕ್ಷನ್ g ಹೊಂದಿವೆ ಮತ್ತು ಜಿ ಒಳಗೆ ವೈ ಎಂದು ಇಲ್ಲಿ ವೇರಿಯಬಲ್, ಇಲ್ಲ ಮತ್ತು ಈ ಒಂದು ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್ ಎಂದರ್ಥ. ಈ ವೇರಿಯಬಲ್ ವೈ ಕರೆಯಲಾಗುತ್ತದೆ ಸಹ ಮತ್ತು ಈ ವೇರಿಯಬಲ್ ಈ 2 ಕಾರ್ಯಗಳನ್ನು Y ಕರೆಯಲಾಗುತ್ತದೆ ಪರಸ್ಪರರ ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು ಯಾವ ಕಲ್ಪನೆಯೂ ಇಲ್ಲ. ಮತ್ತೊಂದೆಡೆ, ಅಪ್ ಇಲ್ಲಿ ನಾವು, ಇಂಟ್ X = 5 ಸೇ ಈ ಯಾವುದೇ ಕಾರ್ಯ ವ್ಯಾಪ್ತಿಯ ಹೊರಗಿದೆ. ಇದು ಮುಖ್ಯ ವ್ಯಾಪ್ತಿಯ ಹೊರಗೆ, ಆದ್ದರಿಂದ ಈ ಒಂದು ಜಾಗತಿಕ ಅಸ್ಥಿರವಾಗಿದೆ. ಅಥವಾ X + + - ನಾನು X ಹೇಳಬೇಕಾದಾಗ ಈ 2 ಕಾರ್ಯಗಳನ್ನು ಎಂದು ಒಳಗೆ ಅರ್ಥ ನಾನು ಈ Y ಮತ್ತು ಈ ವೈ ವಿವಿಧ ಚರಗಳಾಗಿವೆ ಬಗೆಗಿನ ಒಂದೇ X ಪ್ರವೇಶಿಸುವ ನುಡಿದರು. ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಮತ್ತು ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್ ನಡುವೆ ವ್ಯತ್ಯಾಸವನ್ನು ಆ. ದೂರದ ವಿನ್ಯಾಸ ಸಂಬಂಧಿಸಿದಂತೆ ಕೆಲವೊಮ್ಮೆ ಇದು ಬಹುಶಃ ಒಂದು ಉತ್ತಮ ಉಪಾಯ ನೀವು ಬಹುಶಃ ಮಾಡಬಹುದು ಬಂದಾಗಲೆಲ್ಲಾ ಅಸ್ಥಿರ ಸ್ಥಳೀಯ ಇರಿಸಿಕೊಳ್ಳಲು ಹೊಂದಿರುವ ರಿಂದ ಜಾಗತಿಕ ಅಸ್ಥಿರತೆಗಳ ಒಂದು ಗುಂಪೇ ನಿಜವಾಗಿಯೂ ಗೊಂದಲಮಯ ಪಡೆಯುವುದು. ನೀವು ಕಾರ್ಯಗಳನ್ನು ಒಂದು ಗುಂಪೇ ಇದ್ದರೆ ಎಲ್ಲವೂ ಒಂದೇ ಮಾರ್ಪಡಿಸುವ ಈ ಕಾರ್ಯವನ್ನು ಆಕಸ್ಮಿಕವಾಗಿ ಈ ಜಾಗತಿಕ ಮಾರ್ಪಡಿಸುವ ಹೀಗಾದರೆ ನೀವು ಮರೆತರೆ ಇರಬಹುದು ಮತ್ತು ಈ ಇತರ ಕಾರ್ಯ, ಅದರ ಬಗ್ಗೆ ಗೊತ್ತಿಲ್ಲ ನೀವು ಹೆಚ್ಚು ಕೋಡ್ ಪಡೆಯಲು ಮತ್ತು ಇದು ಬಹಳ ಗೊಂದಲಮಯವಾಗಿ ಪಡೆಯಲು ಇಲ್ಲ. ನೀವು ಬಹುಶಃ ಮಾಡಬಹುದು ಬಂದಾಗಲೆಲ್ಲಾ ಅಸ್ಥಿರ ಸ್ಥಳೀಯ ಕೀಪಿಂಗ್ ಕೇವಲ ಉತ್ತಮ ವಿನ್ಯಾಸ ಹೊಂದಿದೆ. ರಚನೆಗಳು, ನೆನಪಿಡಿ, ಕೇವಲ ಒಂದೇ ರೀತಿಯ ಅಂಶಗಳನ್ನು ಪಟ್ಟಿಗಳು. CI ಒಳಗೆ ಹಲೋ, 1, 2.0 ಒಂದು ಪಟ್ಟಿಯನ್ನು ಹೊಂದಿರುತ್ತವೆ. ನಾವು ಹಾಗೆ ಮಾಡಬಹುದು. 

ನಾವು ಸಿ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಿದ ಸಂದರ್ಭದಲ್ಲಿ ಅಂಶಗಳನ್ನು ಒಂದೇ ರೀತಿಯ ಇರಬೇಕು. ಇಲ್ಲಿ ನಾನು 3 ಪೂರ್ಣಾಂಕಗಳ ಒಂದು ಸರಣಿ. ಇಲ್ಲಿ ನಾನು ರಚನೆಯ ಉದ್ದವನ್ನು ಹೊಂದಿದ್ದರೆ, ಆದರೆ ನಾನು ಈ ವಾಕ್ಯ ಅದನ್ನು ಘೋಷಿಸುವ ಭಾವಿಸುತ್ತೇನೆ ವೇಳೆ ನಾನು ಅಂಶಗಳನ್ನು ಎಲ್ಲಾ ನಾನು ತಾಂತ್ರಿಕವಾಗಿ ಈ 3 ಅಗತ್ಯವಿಲ್ಲ ಎಂಬುದನ್ನು ಸೂಚಿಸಲು ಅಲ್ಲಿ. ಕಂಪೈಲರ್ ರಚನೆಯ ಎಷ್ಟು ದೊಡ್ಡ ವ್ಯಕ್ತಿಯು ಸಾಕಷ್ಟು ಸ್ಮಾರ್ಟ್ ಆಗಿದೆ. ಈಗ ನಾನು ರಚನೆಯ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲು ಅಥವಾ ಹೊಂದಿಸಲು ಬಯಸಿದಾಗ ಈ ಮಾಡಲು ಸಿಂಟ್ಯಾಕ್ಸ್ ಹೊಂದಿದೆ. , ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಏಕೆಂದರೆ ವಾಸ್ತವವಾಗಿ ರಚನೆಯ ಎರಡನೆಯ ಅಂಶ ಮಾರ್ಪಡಿಸಿ ಕಾಣಿಸುತ್ತದೆ, ಸಂಖ್ಯಾ 1 ಅಲ್ಲ, 0 ಆರಂಭಗೊಂಡು. ನಾನು ಮೌಲ್ಯ ಓದಲು ಬಯಸಿದರೆ ನಾನು ಸ್ವಲ್ಪ ಹೇಳಬಹುದು ಇಂಟ್ X = ರಚನೆಯ [1]. ನಾನು ಮೌಲ್ಯವನ್ನು ನೀವು ಅಥವಾ ನಾನು ಇಲ್ಲಿ ಮಾಡುತ್ತಿರುವೆ ನಾನು ರಚನೆಯ [1] ಹೇಳಬಹುದು = 4. ತಮ್ಮ ಸೂಚ್ಯಂಕ ಧಾತುಗಳ ಪ್ರವೇಶಿಸುವಾಗ ಆ ಅಥವಾ ತಮ್ಮ ಸ್ಥಾನಕ್ಕೆ ಅಥವಾ ಅಲ್ಲಿ ಅವರು ಶ್ರೇಣಿಯನ್ನು ನಲ್ಲಿ, ಮತ್ತು ಪಟ್ಟಿಗಳನ್ನು 0 ಆರಂಭಗೊಂಡು. ನಾವು, ಆಯ್ರೆಗಳ ಸರಣಿಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ ಮತ್ತು ಈ ಒಂದು ಬಹು ಆಯಾಮದ ರಚನೆಯ ಕರೆಯಲಾಗುತ್ತದೆ. ನಾವು ಬಹು ಆಯಾಮದ ರಚನೆಯ ಹೊಂದಿರುವಾಗ ನಾವು, ಸಾಲುಗಳನ್ನು ಮತ್ತು ಕಾಲಮ್ಗಳನ್ನು ರೀತಿಯ ಹೊಂದಬಹುದು ಅರ್ಥ ಮತ್ತು ಈ ಆಚರಣಕಾರರು ಅಥವಾ ವಿಚಾರ ಕೇವಲ ಒಂದು ಮಾರ್ಗವಾಗಿದೆ. ನಾನು ಬಹು ಆಯಾಮದ ಸರಣಿ ಆ ನಾನು ಅಗತ್ಯವಿಲ್ಲದೇ ಆರಂಭಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ ಅರ್ಥ ಹೆಚ್ಚು 1 ಸೂಚ್ಯಂಕ ಏಕೆಂದರೆ ನಾನು ಗ್ರಿಡ್ ಹೊಂದಿದ್ದರೆ ಕೇವಲ ನೀವು ಏನನ್ನು ಸಾಲು ಹೇಳುವ ನಮಗೆ ಸಂಖ್ಯೆಯನ್ನು ನೀಡುವುದಿಲ್ಲ. ನಿಜಕ್ಕೂ ಕೇವಲ ನಮಗೆ ಸಂಖ್ಯೆಗಳ ಪಟ್ಟಿಯನ್ನು ನೀಡಲು ವಿಶೇಷವೇನು. ಲೆಟ್ಸ್ ನಾನು ಇಲ್ಲಿ ಈ ಸರಣಿ ಹೇಳುತ್ತಾರೆ. ನಾನು ಗ್ರಿಡ್ ಎಂಬ ಸರಣಿ, ಮತ್ತು ನಾನು, ಅದು 2 ಸಾಲುಗಳನ್ನು ಮತ್ತು ಕಾಲಮ್ಗಳನ್ನು 3 ಹೇಳುವ ನಾನು ಮತ್ತು ಆದ್ದರಿಂದ ಇದು ದೃಶ್ಯೀಕರಿಸುವ ಒಂದು ಮಾರ್ಗವಾಗಿದೆ. ನಾನು [1] ನಲ್ಲಿ ಅಂಶ ಸಿಗತ್ತೆ ಹೇಳುವುದಾದರೆ [2] ಈ ಸಾಲುಗಳನ್ನು ಮೊದಲ ತದನಂತರ ಕಾಲಮ್ಗಳನ್ನು ಏಕೆಂದರೆ ಅರ್ಥ ನಾನು 1 ಹೇಳಿದರು ರಿಂದ 1 ಸಾಲನ್ನು ನೆಗೆಯುವುದನ್ನು ಪಡೆಯಲಿದ್ದೇನೆ. 

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

ನಾವು ಕೆಲವು ಚರಾಂಶದ ನಕಲು ಮತ್ತು ನಂತರ ನಕಲು ಹಾದುಹೋಗುವ ಎಂದು ನಗರದ. ಇದು ನಾವು ವೇರಿಯಬಲ್ ಜೊತೆಗೆ ಏನು ಅಪ್ರಸ್ತುತವಾಗುತ್ತದೆ. ಕರೆ ಕಾರ್ಯವನ್ನು ಇದು ಬದಲಾಯಿತು ತಿಳಿದಿರಲಿ ಮಾಡುವುದಿಲ್ಲ. ಅರೆಸ್ ಆ ನಿಟ್ಟಿನಲ್ಲಿ ವಿವಿಧ ಸ್ವಲ್ಪ ಇರುತ್ತದೆ. ನಾವು ನೋಡಿದ ಉದಾಹರಣೆಗೆ, ಮುಖ್ಯ ಕೇವಲ ಒಂದು ಕಾರ್ಯ ಆ 2 ವಾದಗಳಲ್ಲಿನ ತೆಗೆದುಕೊಳ್ಳಬಹುದು. ಮುಖ್ಯ ಕಾರ್ಯ ಮೊದಲ ವಾದವನ್ನು, argc, ಅಥವಾ ವಾದಗಳನ್ನು ಸಂಖ್ಯೆ ಮತ್ತು ಎರಡನೇ ಆರ್ಗ್ಯುಮೆಂಟ್, argv ಕರೆಯಲಾಗುತ್ತದೆ ಮತ್ತು ಆ ಆ ವಾದಗಳಲ್ಲಿ ನಿಜವಾದ ಮೌಲ್ಯಗಳು. ಲೆಟ್ಸ್, ನಾನು this.c ಎಂಬ ಪ್ರೋಗ್ರಾಂ ಹೇಳುತ್ತಾರೆ ಮತ್ತು ನಾನು ಈ ಮಾಡಲು ಹೇಳುತ್ತಾರೆ, ಮತ್ತು ನಾನು ಆಜ್ಞಾ ಸಾಲಿನ ಈ ರನ್ ಪಡೆಯಲಿದ್ದೇನೆ. ಈಗ ನನ್ನ ಕಾರ್ಯಕ್ರಮಕ್ಕೆ ಕೆಲವು ವಾದಗಳನ್ನು ರಲ್ಲಿ ರವಾನಿಸಲು, ಈ ಎಂಬ ನಾನು ಏನೋ ಹಾಗೆ ಹೇಳಬಹುದು. / ಈ CS 50. ಈ ನಾವು ಟರ್ಮಿನಲ್ ಪ್ರತಿ ದಿನ ಡೇವಿಡ್ ಮಾಡಲು ಕಲ್ಪನೆ ಏನು. ಆ ಕಾರ್ಯಕ್ರಮದ ಆದರೆ ಈಗ ಮುಖ್ಯ ಕಾರ್ಯ ಒಳಗೆ ಈ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿದೆ, ಆದ್ದರಿಂದ argc 4. ನಾವು ಮಾತ್ರ CS 50 ರಲ್ಲಿ ಹಾದು ಇರುವ ಕಾರಣ ಇದು ಸ್ವಲ್ಪ ಗೊಂದಲ ಇರಬಹುದು. ಕೇವಲ 3. ಆದರೆ ನೆನಪಿಡಿ ಎಂದು argv ಮೊದಲ ಅಂಶ ಅಥವಾ ಮೊದಲ ವಾದವನ್ನು ಕಾರ್ಯ ಸ್ವತಃ ಹೆಸರು. ಆದ್ದರಿಂದ, ನಾವು 4 ವಿಷಯಗಳನ್ನು ಅರ್ಥ ಮತ್ತು ಮೊದಲ ಅಂಶ. / ಈ ಏರಲಿದೆ. ಮತ್ತು ಈ ಸ್ಟ್ರಿಂಗ್ ನಿರೂಪಿಸಲಾಗಿದೆ ಮಾಡಲಾಗುತ್ತದೆ. ನಂತರ ಉಳಿದ ಅಂಶಗಳನ್ನು ನಾವು ಕಾರ್ಯಕ್ರಮದ ಹೆಸರು ನಂತರ ಬೆರಳಚ್ಚಿಸಿದ ಯಾವುವು. ಆದ್ದರಿಂದ ಪಕ್ಕಕ್ಕೆ ಕೇವಲ ಒಂದು, ನಾವು ಬಹುಶಃ pset 2 ರಲ್ಲಿ ಕಂಡಿತು ಎಂದು, ಸ್ಟ್ರಿಂಗ್ 50 ಪೂರ್ಣಾಂಕ 50 ≠ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ. ಆದ್ದರಿಂದ ನಾವು, ಸ್ವಲ್ಪ ಹೇಳಲು ಸಾಧ್ಯವಿಲ್ಲ 'ಇಂಟ್ X = argv 3.' 

ಈ ಸ್ಟ್ರಿಂಗ್ ಏಕೆಂದರೆ ಕೇವಲ, ಅರ್ಥ ಹಿಂದಿರುಗಬಹುದೆಂದು, ಮತ್ತು ಈ ಒಂದು ಪೂರ್ಣಾಂಕ. ನೀವು 2 ನಡುವೆ ಬದಲಾಯಿಸಲು ಬಯಸುವ ಹಾಗಿದ್ದಲ್ಲಿ, ನೆನಪಿಡಿ, ನಾವು ನೀನು atoi ಎಂಬ ಈ ಮ್ಯಾಜಿಕ್ ಫಂಕ್ಷನ್. ಒಂದು ಸಾಲನ್ನು ತೆಗೆದುಕೊಂಡು ಒಂದು ತಂತುವಿನ ಒಳಗೆ ನಿರೂಪಿಸಲಾಗಿದೆ ಪೂರ್ಣಾಂಕ ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ, ರಸಪ್ರಶ್ನೆ ಮೇಲೆ ಮಾಡಲು ಸುಲಭ ತಪ್ಪು ಇಲ್ಲಿದೆ ಈ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸರಿಯಾದ ರೀತಿಯ ಯೋಚಿಸಿದರು. ಆದರೆ ಕೇವಲ ಈ ಯಾವಾಗಲೂ ತಂತಿಗಳನ್ನು ಎಂದು ತಿಳಿದಿದೆ ತಂತಿ ಮಾತ್ರ ಒಂದು ಪೂರ್ಣಾಂಕ ಅಥವಾ ಅಕ್ಷರ ಅಥವಾ ಒಂದು ಫ್ಲೋಟ್ ಹೊಂದಿದೆ ಸಹ. ಈಗ ಸಮಯ ಚಾಲನೆಯಲ್ಲಿರುವ ಬಗ್ಗೆ ಮಾತನಾಡೋಣ. ನಾವು ಎಲ್ಲಾ ಈ ಅಸಾಮಾನ್ಯ ಕೆಲಸಗಳನ್ನು ಎಲ್ಲಾ ಈ ಕ್ರಮಾವಳಿಗಳು ಹೊಂದಿರುವಾಗ, ಇದು ಪ್ರಶ್ನೆ ಕೇಳಲು ನಿಜವಾಗಿಯೂ ಉಪಯುಕ್ತ ಆಗುತ್ತದೆ "ಅವರು ಎಷ್ಟು ತೆಗೆದುಕೊಳ್ಳುವಿರಿ?" ನಾವು ಅಸಂಪಾತ ಸಂಕೇತನ ಕರೆಯುವುದನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಹಾಗೆಯೇ, ನಾವು ನಮ್ಮ ಅಲ್ಗಾರಿದಮ್ ನೀಡಲು ಹೇಳಲು ಅವಕಾಶ - ಈ ಅರ್ಥ ಕೆಲವು ನಿಜವಾಗಿಯೂ, ನಿಜವಾಗಿಯೂ ದೊಡ್ಡ ಇನ್ಪುಟ್. ನಾವು ಪ್ರಶ್ನೆ ಕೇಳಲು ಬಯಸುವ, "ಎಷ್ಟು ತೆಗೆದುಕೊಳ್ಳಲು ಹೋಗುತ್ತದೆ? ಎಷ್ಟು ಹಂತಗಳನ್ನು ಚಲಾಯಿಸಲು ನಮ್ಮ ಅಲ್ಗಾರಿದಮ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಇನ್ಪುಟ್ ಗಾತ್ರವು ಕ್ರಿಯೆಯಾಗಿದೆ ಎಂದು? " ನಾವು ರನ್ ಸಮಯ ವಿವರಿಸಬಹುದು ಮೊದಲ ರೀತಿಯಲ್ಲಿ ದೊಡ್ಡ ಒ ಮೂಲಕ ಮತ್ತು ಈ ನಮ್ಮ ಕೆಟ್ಟ ಪೆಟ್ಟಿಗೆ ರನ್ನಿಂಗ್ ಸಮಯ. ನಾವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ವಿಂಗಡಿಸಲು ಬಯಸುವ ಹಾಗಿದ್ದಲ್ಲಿ, ಮತ್ತು ನಾವು ನಮ್ಮ ಅಲ್ಗಾರಿದಮ್ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನೀಡಿ ಇದು ಆರೋಹಣ ಕ್ರಮದಲ್ಲಿ ಆಗಿರಬೇಕು ಆ, ಅವರೋಹಣ ಕ್ರಮದಲ್ಲಿ ದ ಆ ಕೆಟ್ಟ ಕೇಸ್ ಎಂದು ವಿಶೇಷವೇನು. ಈ ನಮ್ಮ ಅಲ್ಗಾರಿದಮ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಸಮಯದಲ್ಲಿ ಗರಿಷ್ಠ ಉದ್ದ ಬೌಂಡ್ ನಮ್ಮ ಮೇಲಿನ ಹೊಂದಿದೆ. ಮತ್ತೊಂದೆಡೆ, ಈ Ω ಉತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ ಚಾಲನೆಯ ಸಮಯ ವಿವರಿಸಲು ಹೋಗುತ್ತದೆ. ನಾವು ವಿಂಗಡಿಸುವ ಅಲ್ಗಾರಿದಮ್ ಒಂದು ಈಗಾಗಲೇ ವಿಂಗಡಿಸಲಾದ ಶ್ರೇಣಿಯನ್ನು ನೀಡುತ್ತದೆ ಹಾಗಾಗಿ, ಅದನ್ನು ವಿಂಗಡಿಸಲು ಹೇಗೆ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ? ಮತ್ತು ಈ, ನಂತರ ಸಮಯ ಚಾಲನೆಯಲ್ಲಿರುವ ಒಂದು ಕಡಿಮೆ ಪರಿಮಿತಿಯು ವಿವರಿಸುತ್ತದೆ. ಇಲ್ಲಿ ಕೆಲವು ಸಾಮಾನ್ಯ ಚಾಲನೆಯಲ್ಲಿರುವ ಬಾರಿ ವಿವರಿಸುವ ಕೆಲವು ಪದಗಳು. ಈ ಏರಿಕೆಯ ಕ್ರಮದಲ್ಲಿ ಇರುತ್ತದೆ. ನಾವು ವೇಗದ ಚಾಲನೆಯ ಸಮಯ ಸ್ಥಿರ ಕರೆಯಲಾಗುತ್ತದೆ. 

ನಮ್ಮ ಅಲ್ಗಾರಿದಮ್ ನೀಡಿ ಎಷ್ಟು ಅಂಶಗಳು ಯಾವುದೇ, ಅರ್ಥ ನಮ್ಮ ಶ್ರೇಣಿಯನ್ನು ಇದು ವಿಂಗಡಿಸುವ, ಎಷ್ಟು ದೊಡ್ಡದಾಗಿದೆ ಯಾವುದೇ ಅಥವಾ ನಾವು ಶ್ರೇಣಿಯನ್ನು ಮಾಡುತ್ತಿರುವುದು ಕೆಲಸದಲ್ಲಿರುವಾಗ ಯಾವಾಗಲೂ ಅಷ್ಟೇ ಸಮಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ನಾವು ಕೇವಲ ಒಂದು ಸ್ಥಿರ ಇದು 1, ಆ ಪ್ರತಿನಿಧಿಸಬಹುದು. ನಾವು ಲಾಗರಿದಮ್ ರನ್ ಸಮಯದಲ್ಲಿ ನೋಡುತ್ತಿದ್ದರು. ಆದ್ದರಿಂದ ಬೈನರಿ ಸರ್ಚ್ ಸ್ವಲ್ಪ ಲಾಗರಿದಮ್ ಆಗಿದೆ ನಾವು ಅರ್ಧ ಪ್ರತಿ ಬಾರಿ ಸಮಸ್ಯೆಯನ್ನು ಕತ್ತರಿಸಿ ಅಲ್ಲಿ ತದನಂತರ ವಿಷಯಗಳನ್ನು ಕೇವಲ ಅಲ್ಲಿಂದ ಹೆಚ್ಚಿನ ಪಡೆಯಿರಿ. ಮತ್ತು ನೀವು ಯಾವುದೇ ಅಪವರ್ತನೀಯ ಕ್ರಮಾವಳಿಯ ಒಂದು ಓ ಬರೆಯುವ ಬಳಸುತ್ತಿದ್ದರೆ, ನೀವು ಬಹುಶಃ ನಿಮ್ಮ ದಿನ ಕೆಲಸ ಈ ಪರಿಗಣಿಸುವುದಿಲ್ಲ ಮಾಡಬೇಕು. ನಾವು ಚಾಲನೆಯಲ್ಲಿರುವ ಬಾರಿ ಹೋಲಿಸಿ ಅದು ಮನಸ್ಸಿನಲ್ಲಿ ಈ ವಿಷಯಗಳನ್ನು ಉಳಿಸಿಕೊಳ್ಳಲು ಮುಖ್ಯವಾಗಿರುತ್ತದೆ. ನಾನು ಒ (N) ಎಂದು ಕ್ರಮಾವಳಿ, ಮತ್ತು ಬೇರೆಯವರು ಹಾಗಾಗಿ ಓ ಒಂದು ಕ್ರಮಾವಳಿ (2n) ಈ ವಾಸ್ತವವಾಗಿ asymptotically ಸಮಾನ ಹೊಂದಿದೆ. ನಾವು eleventy ಶತಕೋಟಿ ಒಂದು ದೊಡ್ಡ ಸಂಖ್ಯೆ ಎಂದು n ಇಮ್ಯಾಜಿನ್ ಆದ್ದರಿಂದ: ಆದ್ದರಿಂದ ನಾವು eleventy ಶತಕೋಟಿ ರೀತಿಯ + 3 eleventy ಶತಕೋಟಿ ಹೋಲಿಕೆ ಮಾಡಿದಾಗ, ಇದ್ದಕ್ಕಿದ್ದಂತೆ ಆ +3 ನಿಜವಾಗಿಯೂ ಎಂದಿಗೂ ಒಂದು ದೊಡ್ಡ ವ್ಯತ್ಯಾಸವನ್ನು ಮಾಡುವುದಿಲ್ಲ. ನಾವು ಈ ವಿಷಯಗಳನ್ನು ಸಮಾನ ಪರಿಗಣಿಸಿ ಆರಂಭಿಸಲು ನೀನು ಏಕೆ ಆ. ಇಲ್ಲಿ ಈ ಸ್ಥಿರ ವಿಷಯಗಳನ್ನು ಆದ್ದರಿಂದ,, 2 X ಈ ಸ್, ಅಥವಾ 3 ಸೇರಿಸುವ ಈ ಕೇವಲ ಸ್ಥಿರಾಂಕಗಳಾಗಿವೆ, ಮತ್ತು ಈ ಅಪ್ ಬಿಡಿ ಹೋಗುವ. ಈ ರನ್ ಬಾರಿ ಎಲ್ಲಾ 3 ಅವರು ಒ (N) ನೀವು ಹೇಳುವ ಅದೇ ಏಕೆ ಆ ನ. ನಾವು 2 ಇತರ ರನ್ಟೈಮ್ ಹೊಂದಿದ್ದರೆ ಹಾಗೆಯೇ, ಒ (N ³ + 2n ²) ನಾವು ಸೇರಿಸಬಹುದು ಹೇಳಿ ನೋಡೋಣ ನಂತರ + N, + 7, ಮತ್ತು ನಾವು ಒ ಎಂದು ಇನ್ನೊಂದು ರನ್ ಸಮಯ (N ³) ಹೊಂದಿರುತ್ತವೆ. ಈ ಒಂದೇ ಅಲ್ಲ - ಈ ಕಾರಣ ಮತ್ತೆ, ಈ ಒಂದೇ ಆಗಿವೆ. ಈ ಅದೇ ವಸ್ತುಗಳು, ಕ್ಷಮಿಸಿ. ಆದ್ದರಿಂದ ಈ ಅದೇ ಕಾರಣ ಈ N ³ ಈ 2n ² ಪ್ರಭಾವ ಹೋಗುತ್ತದೆ. 

ನಾವು ಒ (N ³) ಮತ್ತು ಓ ನಂತಹ ಬಾರಿ ರನ್ ನೀವು ಏನು ಒಂದೇ ಅಲ್ಲ (N ²) ಈ N ³ ಈ N ² ಹೆಚ್ಚು ದೊಡ್ಡ ಕಾರಣ. ನಾವು ಘಾತಾಂಕಗಳ ಹೊಂದಿದ್ದರೆ ಆದ್ದರಿಂದ, ಇದ್ದಕ್ಕಿದ್ದಂತೆ ಈ, ಪರವಾಗಿಲ್ಲ ಆರಂಭಿಸುತ್ತದೆ ನಾವು ಇಲ್ಲಿ ಅಪ್ ಆದರೆ ನಾವು, ಅಂಶಗಳು ವ್ಯವಹರಿಸುವಾಗ ಮಾಡಿದಾಗ ನಂತರ ಅವರು ಕೇವಲ ರೊಳಗಿನ ಹೋಗುವ ಕಾರಣ ಪರವಾಗಿಲ್ಲ ಹಿಂದಿರುಗಬಹುದೆಂದು. ನಾವು ಇದುವರೆಗೆ ನೋಡಿದ ಕ್ರಮಾವಳಿಗಳ ಕೆಲವು ಅವಲೋಕಿಸೋಣ ಮತ್ತು ತಮ್ಮ ರನ್ ಆ ಬಗ್ಗೆ ಮಾತನಾಡಲು. ಒಂದು ಪಟ್ಟಿಯಲ್ಲಿ ಹಲವಾರು ಹುಡುಕುತ್ತಿರುವ ಮೊದಲ ರೀತಿಯಲ್ಲಿ, ನಾವು ನೋಡಿದ, ರೇಖೀಯ ಹುಡುಕಾಟ ಆಗಿತ್ತು. ಮತ್ತು ರೇಖೀಯ ಹುಡುಕಾಟ ಅನುಷ್ಠಾನಕ್ಕೆ ಸೂಪರ್ ನೇರವಾಗಿರುತ್ತದೆ. ನಾವು ಕೇವಲ ಒಂದು ಪಟ್ಟಿಯನ್ನು ಹೊಂದಿದ್ದು, ಮತ್ತು ನಾವು ಪಟ್ಟಿಯಲ್ಲಿ ಪ್ರತಿಯೊಂದು ಅಂಶ ನೋಡಲು ನೀನು ನಾವು ಸಂಖ್ಯೆಯನ್ನು ಕಂಡು ರವರೆಗೆ ನಾವು ಹುಡುಕುತ್ತಿರುವ. ಆದ್ದರಿಂದ ಅರ್ಥ ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ, ಈ ಒ (N). ಅಂಶ ವೇಳೆ ಇಲ್ಲಿ ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ಆಗಿರಬಹುದು ಕೊನೆಯ ಅಂಶ, ನಂತರ ರೇಖೀಯ ಹುಡುಕಾಟ ಬಳಸಿ ನಾವು ಪ್ರತಿಯೊಂದು ಅಂಶ ನೋಡಲು ಹೊಂದಿವೆ ನಾವು ಅದನ್ನು ಪಟ್ಟಿಯಲ್ಲಿ ವಾಸ್ತವವಾಗಿ ಎಂದು ತಿಳಿಯಲು ಕಳೆದ ಒಂದು ಪಡೆಯಲು ತನಕ. ನಾವು ಅರ್ಧದಾರಿಯಲ್ಲೇ ಕೈಬಿಟ್ಟು ಹೇಳಲು ಸಾಧ್ಯವಿಲ್ಲ, "ಇದು ಪ್ರಾಯಶಃ ಇಲ್ಲಿ ಅಲ್ಲ." ರೇಖೀಯ ಹುಡುಕಾಟ ನಾವು ಎಲ್ಲಾ ವಿಷಯವನ್ನು ನೋಡಲು ಹೊಂದಿವೆ. ಉತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ ಚಾಲನೆಯ ಸಮಯ, ಮತ್ತೊಂದೆಡೆ, ಸ್ಥಿರವಾಗಿರುತ್ತದೆ ಅತ್ಯುತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಹುಡುಕುತ್ತಿರುವ ಅಂಶ ಕೇವಲ ಪಟ್ಟಿಯಲ್ಲಿ ಮೊದಲ ಒಂದು ಕಾರಣ. ಆದ್ದರಿಂದ ನಮಗೆ ನಿಖರವಾಗಿ 1 ಹಂತ, ಪಟ್ಟಿಯನ್ನು ಹೇಗೆ ದೊಡ್ಡದಾಗಿದೆ ಯಾವುದೇ ತೆಗೆದುಕೊಳ್ಳುವುದು ನಾವು ಮೊದಲ ಅಂಶ ಪ್ರತಿ ಬಾರಿ ಹುಡುಕುತ್ತಿರುವ ವೇಳೆ. 

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

ಸೂಡೊಕೋಡ್ಗಳನ್ನು ಈ, ಈ ರೀತಿಯ ಕಾತುರದಲ್ಲಿರುತ್ತಿದ್ದರು ಮತ್ತು ನಾವು, ಅರ್ಧ ಪ್ರತಿಯೊಂದು ಸಮಯದಲ್ಲಿ ಪಟ್ಟಿಯನ್ನು ಕತ್ತರಿಸಿ ನೀವು ಲಾಗರಿದಮ್ ಗೆ ರೇಖೀಯ ನಮ್ಮ ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ರನ್ ಸಮಯ ನೆಗೆತ. ಆದ್ದರಿಂದ ಇದ್ದಕ್ಕಿದ್ದಂತೆ ನಾವು ಲಾಗಿನ್ ಪಟ್ಟಿಯನ್ನು ಒಂದು ಅಂಶ ಪಡೆಯುವ ಕ್ರಮವನ್ನು. ಉತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ ಚಾಲನೆಯ ಸಮಯ, ಆದರೂ, ಇನ್ನೂ ಸ್ಥಿರವಾಗಿರುತ್ತದೆ ಈಗ ಏಕೆಂದರೆ, ನಾವು ಹುಡುಕುತ್ತಿರುವ ಅಂಶ ಹೇಳುತ್ತಾರೆ ನೋಡೋಣ ಮೂಲ ಪಟ್ಟಿಯ ಯಾವಾಗಲೂ ನಿಖರ ಮಧ್ಯಮ. ಆದ್ದರಿಂದ, ನಾವು ಬಯಸುವ ದೊಡ್ಡ ನಮ್ಮ ಪಟ್ಟಿ ಬೆಳೆಯುತ್ತದೆ, ಆದರೆ ನಾವು ಹುಡುಕುತ್ತಿರುವ ಅಂಶ ಮಧ್ಯಭಾಗದಲ್ಲಿ ವೇಳೆ ಅದು ಮಾತ್ರ ನಮ್ಮನ್ನು 1 ಹಂತದ ತೆಗೆದುಕೊಳ್ಳುವುದು. ನಾವು ಒ (ಲಾಗ್ N) ಮತ್ತು Ω (1) ಅಥವಾ ನಿರಂತರ ನೀವು ಏಕೆ ಆ ನ. ನ ವಾಸ್ತವವಾಗಿ ಈ ಪಟ್ಟಿಯಲ್ಲಿ ಬೈನರಿ ಸರ್ಚ್ ಔಟ್ ಲೆಟ್. ಆದ್ದರಿಂದ ನಾವು ಅಂಶ 164 ಹುಡುಕುತ್ತಿರುವ ಹೇಳುವ ಅವಕಾಶ. ನಾವು ಹೋಗುವ ಮೊದಲನೆಯದಾಗಿ ಈ ಪಟ್ಟಿಯ ಸ್ಥಳವಾಗಿರುವುದರಿಂದ ಕಾಣುವುದು. ಅದು ಹಾಗೆ, ಕೇಂದ್ರ ಈ 2 ಸಂಖ್ಯೆಗಳ ನಡುವೆ ಬಿದ್ದು ಹೋಗುವ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ಸಂಭವಿಸುತ್ತದೆ ಆದ್ದರಿಂದ, ಕೇಂದ್ರ 2 ಸಂಖ್ಯೆಗಳ ನಡುವೆ ಬೀಳುವ ಪ್ರತಿ ಸಮಯ, ಕೇವಲ ನಿರಂಕುಶವಾಗಿ ಹೇಳಿ ನೋಡೋಣ ನ ಕೇವಲ ಪೂರ್ತಿಗೊಳಿಸಲು ಅವಕಾಶ. ನಮಗೆ ಈ ರೀತಿಯಲ್ಲಿ ಪ್ರತಿಯೊಂದು ಹಂತದ ಖಾತ್ರಿಪಡಿಸಿಕೊಳ್ಳಿ ಅಗತ್ಯವಿದೆ. ಆದ್ದರಿಂದ ನಾವು ಹಿಡಿಯಲು ನೀನು ಮತ್ತು ನಾವು 161 ನಮ್ಮ ಪಟ್ಟಿಯ ಮಧ್ಯಮ ಎಂದು ಹೇಳಲು ನೀನು. ಆದ್ದರಿಂದ 161 <164, ಮತ್ತು 161 ಎಡ ಪ್ರತಿ ಅಂಶ ಸಹ <164, ಆದ್ದರಿಂದ ನಾವು ಇದನ್ನು ನಮಗೆ ಸಹಾಯ ಹಿಂದಿರುಗಬಹುದೆಂದು ತಿಳಿದಿದೆ ನಾವು ಅಲ್ಲಿ ಸಾಧ್ಯವಿಲ್ಲ ಹುಡುಕುತ್ತಿರುವ ಅಂಶ ಏಕೆಂದರೆ ಇಲ್ಲಿ ಮೇಲೆ ಕಾಣುವ ಆರಂಭಿಸಲು. ಆದ್ದರಿಂದ ನಾವು ಮಾಡಬಹುದು, ನಾವು ಪಟ್ಟಿಯ ಇಡೀ ಎಡ ಅರ್ಧ ಮರೆತುಬಿಡಿ ಆಗಿದೆ ಈಗ ಕೇವಲ 161 ರಿಂದ ಆಫ್ ಬಲದಿಂದ ಪರಿಗಣಿಸುತ್ತಾರೆ. 

ಆದ್ದರಿಂದ ಮತ್ತೆ, ಈ ತಲುಪಿ; ನ ಕೇವಲ ಪೂರ್ತಿಗೊಳಿಸಲು ಅವಕಾಶ. ಈಗ 175 ತುಂಬಾ ದೊಡ್ಡದಾಗಿದೆ. ಆದ್ದರಿಂದ ನಾವು, ನಮಗೆ ಇಲ್ಲಿ ಅಥವಾ ಇಲ್ಲಿ ನೋಡುತ್ತಿರುವ ಸಹಾಯ ಹಿಂದಿರುಗಬಹುದೆಂದು ತಿಳಿದಿದೆ ಆದ್ದರಿಂದ ನಾವು ಆ ಎಸೆದು, ಮತ್ತು ಅಂತಿಮವಾಗಿ ನಾವು 164 ಹಿಟ್ ಮಾಡುತ್ತೇವೆ. ಬೈನರಿ ಸರ್ಚ್ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು? ಲೆಟ್ಸ್ ಈಗಾಗಲೇ ಪ್ರತಿಗಳ ಪಟ್ಟಿಯನ್ನು ಮೂಲಕ ಶೋಧಿಸುವುದಕ್ಕೆ ತೆರಳಿ ವಾಸ್ತವವಾಗಿ ಯಾವುದೇ ಕ್ರಮದಲ್ಲಿ ಸಂಖ್ಯೆಗಳ ಪಟ್ಟಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಮತ್ತು ಏರುವ ಆ ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ. ನಾವು ನೋಡಿವೆ ಮೊದಲ ಅಲ್ಗಾರಿದಮ್ ಬಬಲ್ ರೀತಿಯ ಕರೆಯಲಾಯಿತು. ಈ ನಾವು ನೋಡಿದ ಕ್ರಮಾವಳಿಗಳ ಸರಳ ಎಂದು. ಬಬಲ್ ರೀತಿಯ, ಪಟ್ಟಿಯಲ್ಲಿ ಒಳಗೆ ಯಾವುದೇ 2 ಅಂಶಗಳನ್ನು ಸ್ಥಳದ ಔಟ್ ಆಗ ಹೇಳುತ್ತಾನೆ ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆ ಕಡಿಮೆ ಸಂಖ್ಯೆಯ ಎಡಕ್ಕೆ ಇಲ್ಲ ಅರ್ಥ ಆ ಪಟ್ಟಿಯಲ್ಲಿ ಎಂಬುದನ್ನು ಅರ್ಥ ಏಕೆಂದರೆ ನಾವು, ಅವುಗಳನ್ನು ವಿನಿಮಯ ನೀನು ಇದು ಮೊದಲು ಹೆಚ್ಚು "ಹೆಚ್ಚು ಪ್ರತಿಗಳ". ಮತ್ತು ನಾವು ಮತ್ತೆ ಮತ್ತೆ ಮತ್ತೆ ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಮುಂದುವರೆಸಲು ಹೋಗಿ ಮತ್ತು ನೀವು ಅಂತಿಮವಾಗಿ ಅಂಶಗಳನ್ನು ತಮ್ಮ ಸರಿಯಾದ ಸ್ಥಳಕ್ಕೆ ಬಬಲ್ ರೀತಿಯ ನಾವು ಪ್ರತಿಗಳ ಪಟ್ಟಿಯನ್ನು ತನಕ. 

ಈ ರನ್ ಸಮಯ ಒ ಏರಲಿದೆ (N ²). ಏಕೆ? ಅಲ್ಲದೆ, ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ಏಕೆಂದರೆ, ನಾವು ಪ್ರತಿ ಅಂಶ ತೆಗೆದುಕೊಳ್ಳುವುದು, ಮತ್ತು ನೀವು ನಾವು ಪಟ್ಟಿಯಲ್ಲಿ ಪ್ರತಿ ಇತರ ಅಂಶ ಅದನ್ನು ಹೋಲಿಸಿ ಅಂತ್ಯಗೊಳ್ಳುತ್ತಿತ್ತು ನೀನು. ಆದರೆ ಉತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಈಗಾಗಲೇ ಪ್ರತಿಗಳ ಪಟ್ಟಿಯನ್ನು ಹೊಂದಿದ್ದು, ಬಬಲ್ ರೀತಿಯ ನ ಕೇವಲ ಒಮ್ಮೆ ಮೂಲಕ ಹೋಗಲು, ಹೇಳಿ ಹೋಗಿ "ಇಲ್ಲ. ನಾನು ಯಾವುದೇ ವಿನಿಮಯ ಮಾಡಲಿಲ್ಲ, ಆದ್ದರಿಂದ ನಾನು ಮುಗಿಸಿದ್ದೇನೆ." ನಾವು Ω (N) ಒಂದು ಉತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಸಮಯ. ನ ಪಟ್ಟಿಯಲ್ಲಿ ಬಬಲ್ ರೀತಿಯ ಔಟ್ ಲೆಟ್. ಅಥವಾ ಮೊದಲು, ನ ಕೇವಲ ನಿಜವಾಗಿಯೂ ವೇಗವಾಗಿ ಕೆಲವು ಸೂಡೊಕೋಡ್ಗಳನ್ನು ನೋಡೋಣ. ನಾವು ಲೂಪ್ ಪ್ರತಿಯೊಂದು ಪುನರಾವರ್ತನೆ ರಲ್ಲಿ, ಟ್ರ್ಯಾಕ್ ಬಯಸುವ ಹೇಳಲಿಚ್ಚಿಸುತ್ತೇನೆ ನಾವು ಯಾವುದೇ ಅಂಶಗಳನ್ನು ಬದಲಾಯಿಸಲಾಗಿದೆ ಎಂದು ಅಥವಾ ಟ್ರ್ಯಾಕ್. ಎಂದು ಕಾರಣ ಆದ್ದರಿಂದ, ನಾವು ಯಾವುದೇ ಅಂಶಗಳನ್ನು ವಿನಿಮಯವಾಗಿದೆ ಮಾಡಿಲ್ಲ ಮಾಡಿದಾಗ ನಿಲ್ಲಿಸಲು ನೀನು. ಆದ್ದರಿಂದ ನಮ್ಮ ಲೂಪ್ ಆರಂಭದಲ್ಲಿ ನಾವು ಏನು ವಿನಿಮಯವಾಗಿದೆ, ಆದ್ದರಿಂದ ನಾವು ತಪ್ಪು ಎಂದು ಹೇಳುತ್ತೇನೆ. ಈಗ, ನಾವು ಪಟ್ಟಿ ಮೂಲಕ ಹೋಗಿ ನಾನು ಅಂಶ ನಾನು + 1 ಅಂಶ ಹೋಲಿಸಲು ನೀನು ಮತ್ತು ಇದು ಒಂದು ದೊಡ್ಡ ಸಂಖ್ಯೆಯ ಒಂದು ಸಣ್ಣ ಸಂಖ್ಯೆಯ ಎಡಕ್ಕೆ ಎಂದು ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಅವುಗಳನ್ನು ವಿನಿಮಯ ನೀನು. 

ನಂತರ ನಾವು ಒಂದು ಅಂಶ ಬದಲಾಯಿಸಿಕೊಳ್ಳಬಹುದು ಎಂದು ನೆನಪಿಡುವ ನೀನು. ನಾವು ಪಟ್ಟಿ ಮೂಲಕ ಕನಿಷ್ಠ 1 ಬಾರಿ ಕ್ರಮಿಸಬೇಕಾಗುತ್ತದೆ ಅರ್ಥ ಸಂಪೂರ್ಣ ಪಟ್ಟಿಯನ್ನು ಈಗಾಗಲೇ ಪ್ರತ್ಯೇಕಿಸಲ್ಪಡುತ್ತವೆ ನಾವು ನಿಲ್ಲಿಸಿದ ಸ್ಥಿತಿಯಲ್ಲಿ ಏಕೆಂದರೆ, ನಾವು ಯಾವುದೇ ಸ್ವಾಪ್ಸ್ ಮಾಡಿಲ್ಲ ಎಂದರ್ಥ. ನಮ್ಮ ಪರಿಸ್ಥಿತಿ ಕೆಳಗೆ ಇಲ್ಲಿ ಏಕೆ ಆ ನ 'ಕೆಲವು ಅಂಶಗಳನ್ನು ವಿನಿಮಯವಾಗಿದೆ ಮಾಡಲಾಗಿತ್ತು.' ಈಗ ಅವರ ಈ ಪಟ್ಟಿಯಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ನೋಡೋಣ. ನಾನು ಪಟ್ಟಿಯನ್ನು 5,0,1,6,4 ಹೊಂದಿರುತ್ತವೆ. ಬಬಲ್ ರೀತಿಯ ಎಡ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಪ್ರಾರಂಭಿಸಲು ಹೋಗುತ್ತದೆ, ಮತ್ತು ಹೋಲಿಸಲು ವಿಶೇಷವೇನು ನಾನು ಅಂಶಗಳು, ಆದ್ದರಿಂದ ಅಂಶ 1 ಇದು 0 ಗೆ ನಾನು + 1,. ಇದು, ಹಾಗೂ 5> 0 ಹೇಳಲು ವಿಶೇಷವೇನು, ಆದರೆ ಇದೀಗ 5 ಎಡಕ್ಕೆ ಆಗಿದೆ ಆದ್ದರಿಂದ ನಾನು 5 ಮತ್ತು 0 ಸ್ವ್ಯಾಪ್ ಅಗತ್ಯವಿದೆ. ನಾನು ಅವುಗಳನ್ನು ಸ್ವ್ಯಾಪ್ ಮಾಡಿದಾಗ, ಇದ್ದಕ್ಕಿದ್ದಂತೆ ಈ ವಿಭಿನ್ನ ಪಟ್ಟಿಯನ್ನು ಪಡೆಯುವುದು. ಈಗ 5> 1, ಆದ್ದರಿಂದ ನಾವು ಅದನ್ನು ಸ್ವ್ಯಾಪ್ ಎಂದು ನೀನು. 5> 6 ಅಲ್ಲ, ಆದ್ದರಿಂದ ನಾವು ಇಲ್ಲಿ ಏನೂ ಮಾಡಬೇಕಿಲ್ಲ. ಆದರೆ 6> 4, ಆದ್ದರಿಂದ ನಾವು ಸ್ವ್ಯಾಪ್ ಅಗತ್ಯವಿದೆ. ಮತ್ತೆ, ನಾವು ಅಂತಿಮವಾಗಿ ತಿಳಿಯಲು ಸಂಪೂರ್ಣ ಪಟ್ಟಿ ಮೂಲಕ ಚಲಿಸಬೇಕಾಗುತ್ತದೆ ಈ ಕ್ರಮದಲ್ಲಿ ಔಟ್ ಎಂದು; ನಾವು ಅವುಗಳನ್ನು ಸ್ವ್ಯಾಪ್, ಈ ಹಂತದಲ್ಲಿ ನಾವು ಪಟ್ಟಿ ಮೂಲಕ 1 ಹೆಚ್ಚು ಬಾರಿ ಔಟ್ ಅಗತ್ಯವಿದೆ ಎಲ್ಲವನ್ನೂ ಅದರ ಸಲುವಾಗಿ, ಮತ್ತು ಈ ಬಬಲ್ ರೀತಿಯ ಗಳಿಸಿದರು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಕೆಲವು ಅಂಶಗಳನ್ನು ತೆಗೆದುಕೊಂಡು ವಿಂಗಡಿಸುವ ಒಂದು ವಿಭಿನ್ನ ಕ್ರಮಾವಳಿ ಆಯ್ಕೆ ತೆರನಾದ. ಆಯ್ಕೆ ರೀತಿಯ ಹಿಂದಿನ ಉದ್ದೇಶ ನಾವು ಪಟ್ಟಿಯ ಸಾರ್ಟೆಡ್ ಭಾಗವನ್ನು ನಿರ್ಮಿಸಲು ನೀನು ಎಂದು ಒಂದು ಸಮಯದಲ್ಲಿ 1 ಅಂಶ. 

ಮತ್ತು ನಾವು ಮಾಡಲು ನೀನು ರೀತಿಯಲ್ಲಿ ಪಟ್ಟಿಯನ್ನು ಎಡ ಭಾಗವನ್ನು ನಿರ್ಮಿಸುವ ಮೂಲಕ. ಮತ್ತು ಮೂಲಭೂತವಾಗಿ, ಪ್ರತಿ - ಪ್ರತಿ ಹಂತದ ಮೇಲೆ, ನಾವು ಬಿಟ್ಟು ಚಿಕ್ಕ ಅಂಶ ತೆಗೆದುಕೊಳ್ಳಲು ನೀನು ಎಂದು ಇನ್ನೂ ವಿಂಗಡಿಸಲಾದ ಇಲ್ಲ, ಮತ್ತು ನಾವು ವಿಂಗಡಿಸಲಾದ ವಿಭಾಗದಲ್ಲಿ ಅದನ್ನು ಸರಿಸಲು ನೀನು. ಅಂದರೆ ನಾವು ನಿರಂತರವಾಗಿ ಕನಿಷ್ಠ ಆಯ್ದ ಅಂಶ ಕಂಡುಹಿಡಿಯಬೇಕು ಮತ್ತು ನಂತರ ಕನಿಷ್ಠ ಅಂಶ ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಮತ್ತು ಯಾವುದೇ ಅದನ್ನು ಸ್ವ್ಯಾಪ್ ಅತ್ಯಂತ ಎಡಬದಿಯ ಅಂಶ ವಿಂಗಡಿಸುತ್ತದೆ ಎಂದು. ಈ ರನ್ ಸಮಯ ಒ ಏರಲಿದೆ (N ²) ಏಕೆಂದರೆ ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಪ್ರತಿ ಇತರ ಅಂಶ ಪ್ರತಿ ಏಕ ಅಂಶ ಹೋಲಿಸಿ ಅಗತ್ಯವಿದೆ. ನಾವು ಪಟ್ಟಿ ಎಡ ಅರ್ಧ ಆರಂಭವಾಗುವುದು ವೇಳೆ, ನಾವು ಅಗತ್ಯವಿದೆ ಎಂದು ಹೇಳುವ ಕಾರಣ ಚಿಕ್ಕ ಅಂಶ ಪಡೆಯುವ ಸಂಪೂರ್ಣ ಹಕ್ಕು ವಿಭಾಗದ ಮೂಲಕ ಹೋಗಲು. ನಂತರ, ಮತ್ತೆ, ನಾವು ಸಂಪೂರ್ಣ ಬಲ ಭಾಗದ ಮೇಲೆ ಹೋಗಿ ಅಗತ್ಯವಿದೆ ಮತ್ತೆ ಮೇಲೆ ಮತ್ತು ಸುಮಾರು ಕ್ಕಿಂತ ಮುಂದುವರಿಸುವುದಕ್ಕೆ. ಎಂದು N ² ಎಂದು ವಿಶೇಷವೇನು. ನಾವು ಲೂಪ್ ಮತ್ತೊಂದು ಕುಣಿಕೆಯ ಒಳಗೆ ಅಗತ್ಯವಿದೆ ಎಂದು ನೀನು ಇದು n ² ಸೂಚಿಸುತ್ತದೆ. ಅತ್ಯುತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ ಚಿಂತನೆಯಲ್ಲಿ, ನ ನಾವು ಈಗಾಗಲೇ ಪ್ರತಿಗಳ ಪಟ್ಟಿಯನ್ನು ನೀಡುವುದು ಹೇಳಲು ಅವಕಾಶ; ನಾವು ವಾಸ್ತವವಾಗಿ N ² ಉತ್ತಮವಾಗಿ ಮಾಡಬೇಡಿ. ಆಯ್ಕೆ ರೀತಿಯ ಎಂದು ತಿಳಿಯಲು ಯಾವುದೇ ಮಾರ್ಗಗಳಿಲ್ಲ ಏಕೆಂದರೆ ಕನಿಷ್ಠ ಅಂಶ ನಾನು ನೋಡಿ ಎಂದು ಸಂಭವಿಸಿ ಒಂದಾಗಿದೆ. ಇದು ಈ ವಾಸ್ತವವಾಗಿ ಕನಿಷ್ಠ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಅಗತ್ಯವಿದೆ. 

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

ಏನೋ N ಆಫ್ ಥೀಟಾ ವೇಳೆ ², ಇದು ದೊಡ್ಡ O (N ²) ಮತ್ತು Ω (N ²) ಆಗಿದೆ. ಬೆಸ್ಟ್ ಕೇಸ್ ಮತ್ತು ವರ್ಸ್ಟ್ ಕೇಸ್ ಆದ್ದರಿಂದ, ಒಂದು ವ್ಯತ್ಯಾಸವನ್ನು ಮಾಡುವುದಿಲ್ಲ ಕ್ರಮಾವಳಿ ಒಂದೇ ಪ್ರತಿ ಬಾರಿ ಏನು ಪ್ರಯೋಜನ ಇದೆ. ಆದ್ದರಿಂದ ಈ ಆಯ್ಕೆಯನ್ನು ರೀತಿಯ ಫಾರ್ ಸೂಡೊಕೋಡ್ಗಳನ್ನು ಕಾಣುತ್ತದೆ ಏನು. ನಾವು ಮೂಲತಃ ನಾನು ಪಟ್ಟಿಯ ಮೇಲೆ ಮರಳಿ ಬಯಸುವ ಹೇಳಲು ನೀನು ಬಲಕ್ಕೆ, ಮತ್ತು ಲೂಪ್ ಪ್ರತಿಯೊಂದು ಪುನರಾವರ್ತನೆ ನಲ್ಲಿ ಎಡದಿಂದ, ನಾನು ಸರಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ ಪಟ್ಟಿಯಲ್ಲಿ ಈ ವಿಂಗಡಿಸಲಾದ ಭಾಗದ ಮೇಲೆ ಕನಿಷ್ಠ ಅಂಶ. ಮತ್ತು ಒಮ್ಮೆ ನಾನು ಏನಾದರೂ ಸರಿಸಲು, ನಾನು ಮತ್ತೆ ಆ ಅಂಶ ನೋಡಬೇಕು ಎಂದಿಗೂ. ತಕ್ಷಣ ನಾನು ಪಟ್ಟಿಯನ್ನು ಎಡ ಭಾಗಕ್ಕೆ ಒಂದು ಅಂಶ ಸ್ವ್ಯಾಪ್ ಇದು ವಿಂಗಡಿಸಲಾದ ಏಕೆಂದರೆ ನಾವು ಕನಿಷ್ಟ ಬಳಸಿಕೊಂಡು ಏರಿಕೆಯ ಕ್ರಮದಲ್ಲಿ ಎಲ್ಲವನ್ನೂ ಮಾಡುತ್ತಿರುವುದು ಕಾರಣ. ನಾವು ಸರಿ, ನಾವು ಸ್ಥಾನವನ್ನು ಐ ಆರ್, ಮತ್ತು ನಾವು ಅಂಶಗಳನ್ನು ಎಲ್ಲಾ ನೋಡಬೇಕು, ಹೇಳಿದರು ಕನಿಷ್ಠ ಪಡೆಯುವ ಸಲುವಾಗಿ i ನ ಬಲಕ್ಕೆ. ಆದ್ದರಿಂದ ನಾವು ಪಟ್ಟಿಯ ಕೊನೆಯಲ್ಲಿ ನಾನು + 1 ನೋಡಲು ಬಯಸುವ ಅರ್ಥ. ಈಗ, ನಾವು ಪ್ರಸ್ತುತ ನಲ್ಲಿ ಹುಡುಕುತ್ತಿರುವ ಎಂದು ಅಂಶ, ಇಲ್ಲಿಯವರೆಗೆ ನಮ್ಮ ಕನಿಷ್ಠ ಕಡಿಮೆ ವೇಳೆ ನೆನಪಿಡಿ, ನಾವು ಎಂದು ಕನಿಷ್ಠ ಪ್ರಾರಂಭ ನೀವು ಇದು, ಯಾವುದೇ ಅಂಶ ನಾವು ಪ್ರಸ್ತುತ ಆರ್; ನಾನು ಕನಿಷ್ಠ ಎಂದು ಊಹಿಸುತ್ತವೆ ಮಾಡುತ್ತೇವೆ. ನಾನು ಚಿಕ್ಕದಾಗಿದೆ ಎಂದು ಒಂದು ಅಂಶ ಹುಡುಕಲು ವೇಳೆ, ನಂತರ ನಾನು, ಸರಿ, ಹೇಳಲು ಪಡೆಯಲಿದ್ದೇನೆ ಜೊತೆಗೆ, ನಾನು ಒಂದು ಹೊಸ ಕನಿಷ್ಠ ಕಂಡುಕೊಂಡಿವೆ. ನಾನು ಕನಿಷ್ಠ ಆಗಿತ್ತು ಅಲ್ಲಿ ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಪಡೆಯಲಿದ್ದೇನೆ. 

ಈಗ, ಒಮ್ಮೆ ನಾನು, ಆ ಹಕ್ಕನ್ನು ಆಯ್ದ ಭಾಗ ಮೂಲಕ ಹೋಗಿದ್ದೀರಿ ನಾನು ಸ್ಥಾನವನ್ನು ನಾನು ಎಂದು ಅಂಶ ಹೊಂದಿರುವ ಕನಿಷ್ಠ ಅಂಶ ಸ್ವ್ಯಾಪ್ ಪಡೆಯಲಿದ್ದೇನೆ ಹೇಳಬಹುದು. ನನ್ನ ಪಟ್ಟಿ ನಿರ್ಮಿಸಲು ವಿಶೇಷವೇನು, ಎಡದಿಂದ ಬಲಕ್ಕೆ ಪಟ್ಟಿಯಲ್ಲಿ ನನ್ನ ವಿಂಗಡಿಸಲಾದ ಭಾಗ, ಮತ್ತು ನಾವು ಆ ಭಾಗದಲ್ಲಿ ಒಮ್ಮೆ ಮತ್ತೆ ಅಂಶ ನೋಡಲು ಅಗತ್ಯವಿರುವುದಿಲ್ಲ. ಒಮ್ಮೆ ನಾವು ಬದಲಾಗಿ ನೀವು. ಆದ್ದರಿಂದ ಅವರ ಈ ಪಟ್ಟಿಯಲ್ಲಿ ಆಯ್ಕೆ ರೀತಿಯ ರನ್ ಅವಕಾಶ. ಇಲ್ಲಿ ನೀಲಿ ಅಂಶ ನಾನು ಎಂದು ಹೋಗುತ್ತದೆ, ಮತ್ತು ಕೆಂಪು ಅಂಶ ಕನಿಷ್ಠ ಅಂಶ ಎಂದು ಹೋಗುತ್ತದೆ. ನಾನು 5 ನೇ ಆದ್ದರಿಂದ ಪಟ್ಟಿಯ ಎಡ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಆರಂಭವಾಗುತ್ತದೆ. ಈಗ ನಾವು ಕನಿಷ್ಠ ಆಯ್ದ ಅಂಶ ಕಂಡುಹಿಡಿಯಬೇಕು. ನಾವು 0 <5, ಆದ್ದರಿಂದ 0 ನನ್ನ ಹೊಸ ಕನಿಷ್ಠ ಹೇಳುತ್ತಾರೆ. 

ನಾವು, 0 ಚಿಕ್ಕ ಗುರುತಿಸಲು ಕೂಡ ಏಕೆಂದರೆ ಆದರೆ ನಾನು, ಅಲ್ಲಿ ನಿಲ್ಲಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ನಾವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಪಟ್ಟಿಯ ಪ್ರತಿಯೊಂದು ಅಂಶ ಮೂಲಕ ಚಲಿಸಬೇಕಾಗುತ್ತದೆ. , 6 ದೊಡ್ಡದು ದೊಡ್ಡದು 1 ಆದ್ದರಿಂದ, 4 ದೊಡ್ಡದಾಗಿದೆ. ಈ ಅಂಶಗಳನ್ನು ಎಲ್ಲಾ ನೋಡುವ ನಂತರ, ನಾನು 0 ಚಿಕ್ಕ ದೃಢಪಟ್ಟಿದೆ ಎಂದರ್ಥ. ಹಾಗಾಗಿ 5 ಮತ್ತು 0 ಸ್ವ್ಯಾಪ್ ಪಡೆಯಲಿದ್ದೇನೆ. ಒಮ್ಮೆ ನಾನು ಸ್ವ್ಯಾಪ್, ನಾನು ಒಂದು ಹೊಸ ಪಟ್ಟಿಯನ್ನು ಪಡೆಯಲು ಪಡೆಯಲಿದ್ದೇನೆ, ಮತ್ತು ನಾನು ಮತ್ತೆ ಆ 0 ನೋಡಬೇಕು ಎಂದೂ ತಿಳಿದಿದೆ ಒಮ್ಮೆ ನಾನು ಬದಲಾಗಿ ನೀವು ಏಕೆಂದರೆ, ನಾನು ಅದನ್ನು ವಿಂಗಡಿಸುತ್ತದೆ ನೀವು ಮತ್ತು ನಾವು ಮುಗಿಸಿದ್ದೀರಿ. ಈಗ ಅದು ಕೇವಲ ಆದ್ದರಿಂದ, ನೀಲಿ ಅಂಶ ಮತ್ತೆ 5 ಎಂದು ಸಂಭವಿಸುತ್ತದೆ ಮತ್ತು ನಾವು 1 ನಿರ್ಧರಿಸಲು, 1 ನೋಡಲು 6 ಮತ್ತು 4 ಅಗತ್ಯವಿದೆ ಚಿಕ್ಕ ಕನಿಷ್ಠ ಅಂಶ, ಆದ್ದರಿಂದ ನಾವು 1 ಮತ್ತು 5 ಸ್ವ್ಯಾಪ್ ಮಾಡುತ್ತೇವೆ. ಮತ್ತೆ, ನಾವು ನೋಡಬೇಕು - 6 ಮತ್ತು 4 ರಿಂದ 5 ಹೋಲಿಸಿ, ಮತ್ತು ನಾವು 4 ಮತ್ತು 5 ಸ್ವ್ಯಾಪ್ ಹೋಗುವ, ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಹೋಲಿಸಿ ನೀವು ಆ 2 ಸಂಖ್ಯೆಗಳು ಮತ್ತು ನಮ್ಮ ಪ್ರತಿಗಳ ಪಟ್ಟಿಯನ್ನು ಪಡೆಯಲು ತನಕ ಅದನ್ನು ಸ್ವ್ಯಾಪ್. ಆಯ್ಕೆ ರೀತಿಯ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು? ಸರಿ. ನ ಇಲ್ಲಿ ಕೊನೆಯ ವಿಷಯಕ್ಕೆ ಚಲಿಸೋಣ, ಮತ್ತು ರಿಕರ್ಶನ್ ಹೊಂದಿದೆ. 

ಪುನರಾವರ್ತನ, ನೆನಪಿಡಿ, ಈ ನಿಜವಾಗಿಯೂ ಮೆಟಾ ವಿಷಯ ಅಲ್ಲಿ ಒಂದು ಫಂಕ್ಷನ್ ಪದೇಪದೇ ಸ್ವತಃ ಕರೆಗಳನ್ನು. ಕೆಲವು ಸಮಯದಲ್ಲಿ, ನಮ್ಮ fuction ಪದೇಪದೇ ಸ್ವತಃ ಕರೆ ಆದರೆ, ನಾವು ಕರೆ ತಡೆಯಲು ಇದು ಕೆಲವು ಪಾಯಿಂಟ್ ಇರಬೇಕು. ನಾವು ಹಾಗೆ ಮಾಡದಿದ್ದರೆ, ಆಗ ನಾವು ಶಾಶ್ವತವಾಗಿ ಇದನ್ನು ಮುಂದುವರಿಸಲು ನೀನು ಏಕೆಂದರೆ, ಮತ್ತು ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಕೇವಲ ಅಂತ್ಯಗೊಳಿಸಲು ಹೋಗುತ್ತಿಲ್ಲ ಇದೆ. ಈ ಸ್ಥಿತಿಯನ್ನು ಬೇಸ್ ಸಂದರ್ಭದಲ್ಲಿ ಕರೆ. ಮತ್ತು ಬೇಸ್ ಸಂದರ್ಭದಲ್ಲಿ, ಬದಲಿಗೆ ಮತ್ತೊಮ್ಮೆ ಕಾರ್ಯ ಕರೆ ಹೆಚ್ಚು ಹೇಳುತ್ತಾರೆ ನಾನು ಕೆಲವು ಮೌಲ್ಯವನ್ನು ಮರಳಿ ಪಡೆಯಲಿದ್ದೇನೆ. ನಾವು ಮೌಲ್ಯವನ್ನು ಮರಳಿದರು ಒಮ್ಮೆ ಆದ್ದರಿಂದ, ನಾವು ನಾವೇ ಕರೆ ನಿಲ್ಲಿಸಿದ ನಾವು ಮತ್ತು ನಾವು ಇದುವರೆಗೆ ಮಾಡಿದ ಕರೆಗಳನ್ನು ಉಳಿದ ಸಹ ಮರಳಬಹುದು. ಮೂಲ ಪ್ರಕರಣದ ವಿರುದ್ಧ ಪುನರಾವರ್ತಿತ ಸಂದರ್ಭದಲ್ಲಿ. ಈ ನಾವು ಸೈನ್ ಪ್ರಸ್ತುತ ಎಂಬುದನ್ನು ಕ್ರಿಯೆಯ ಮತ್ತೊಂದು ಕರೆ ಮಾಡಲು ಬಯಸುವ ಆಗ ಮತ್ತು ನಾವು ಬಹುಶಃ ಯಾವಾಗಲೂ ಆದರೂ, ವಿವಿಧ ವಾದಗಳು ಬಳಸಲು ಬಯಸುವ. 

ನಾವು ಎಫ್ ಎಂಬ ಫಂಕ್ಷನ್, ಮತ್ತು ಎಫ್ ಕೇವಲ, 1 ಆರ್ಗ್ಯುಮೆಂಟ್ ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಎಂದು ಹಾಗಿದ್ದಲ್ಲಿ ಮತ್ತು ನಾವು ಕೇವಲ F (1), F (1), F (1) ಕರೆ ಇರಿಸಿಕೊಳ್ಳಲು, ಮತ್ತು ಇದು ಆದ್ದರಿಂದ ಅದು ಸಂಭವಿಸಿದಲ್ಲಿ ಆರ್ಗ್ಯುಮೆಂಟ್ 1 ಪುನರಾವರ್ತಿತ ಸಂದರ್ಭದಲ್ಲಿ ಬರುತ್ತಾರೆ, ನಾವು ಇನ್ನೂ ನಿಲ್ಲಿಸಲು ಹೋಗುವ ಎಂದಿಗೂ ನೀವು. ನಾವು ಒಂದು ಬೇಸ್ ಸಂದರ್ಭದಲ್ಲಿ ಹೊಂದಿದ್ದರೂ ಸಹ, ನಾವು ಅಂತಿಮವಾಗಿ ನಾವು ಬೇಸ್ ಸಂದರ್ಭದಲ್ಲಿ ಹೊಡೆಯಲು ನೀನು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಅಗತ್ಯವಿದೆ. ನಾವು ಈ ಪುನರಾವರ್ತಿತ ಸಂದರ್ಭದಲ್ಲಿ ಉಳಿದರು ಇರಿಸಿಕೊಳ್ಳಲು ಇಲ್ಲ. ಸಾಮಾನ್ಯವಾಗಿ, ನಾವು ಕರೆ ಮಾಡಿದಾಗ, ನಾವು ಬಹುಶಃ ಬೇರೊಂದು ವಾದವು ಪ್ರತಿ ಸಮಯ ಎಂದು ನೀನು. ಇಲ್ಲಿ ನಿಜವಾಗಿಯೂ ಸರಳ ಪುನರಾವರ್ತಿತ ಕ್ರಿಯೆಯಾಗಿದೆ. ಆದ್ದರಿಂದ ಈ ಒಂದು ಸಂಖ್ಯೆಯ ಅಪವರ್ತನೀಯ ಲೆಕ್ಕಾಚಾರ ಕಾಣಿಸುತ್ತದೆ. ಅಪ್ ನಮ್ಮ ಬೇಸ್ ಸಂದರ್ಭದಲ್ಲಿ ಹೊಂದಿರುತ್ತದೆ ಇಲ್ಲಿ ಮೇಲಕ್ಕೆ. N ≤ 1, ನಾವು ಮತ್ತೆ ಅಪವರ್ತನೀಯ ಕರೆಯಲು ಹೋಗುತ್ತಿಲ್ಲ ಆ ಸಂದರ್ಭದಲ್ಲಿ. ನಾವು ನಿಲ್ಲಿಸಲು ನೀನು; ನಾವು ಕೆಲವು ಮೌಲ್ಯವನ್ನು ಮರಳಲು ನೀನು. ಈ ನಿಜವಾದ ಇದ್ದರೆ, ಆಗ ನಮ್ಮ ಪುನರಾವರ್ತಿತ ಸಂದರ್ಭದಲ್ಲಿ ಹೊಡೆಯಲು ನೀನು. ಬಹಳ ಉಪಯುಕ್ತ ಎಂದು ಏಕೆಂದರೆ ನಾವು, ಅಪವರ್ತನೀಯ (N) ಕರೆ ಎಂಬುದಾಗಿ ನೀವು ಇಲ್ಲಿ ಗಮನಿಸಿ. ನಾವು ಮತ್ತೇನನ್ನೋ ಅಪವರ್ತನೀಯ ಕರೆಯಲು ನೀನು. 

ಮತ್ತು ನೀವು, ನಾವು ಅಪವರ್ತನೀಯ (5) ಅಥವಾ ಏನಾದರೂ ಹಾದು ಅಂತಿಮವಾಗಿ ವೇಳೆ, ನೋಡಬಹುದು ನಾವು ಅಪವರ್ತನೀಯ (4) ಮತ್ತು ಹೀಗೆ ಕರೆಯಲು ನೀನು, ಮತ್ತು ಅಂತಿಮವಾಗಿ ಈ ಬೇಸ್ ಸಂದರ್ಭದಲ್ಲಿ ಹೊಡೆಯಲು ನೀನು. ಆದ್ದರಿಂದ ಈ ಚೆನ್ನಾಗಿ ಕಾಣುತ್ತದೆ. ನಾವು ವಾಸ್ತವವಾಗಿ ಈ ರನ್, ಏನಾಗುತ್ತದೆ ನೋಡೋಣ. ಈ ಸಂಗ್ರಹವನ್ನು ಹೊಂದಿದೆ, ಮತ್ತು ಈಗ ಮುಖ್ಯ ವಾದವನ್ನು (4) ಈ ಕಾರ್ಯ ಕರೆ ಹೋಗಿ ಎಂದು ಹೇಳುತ್ತಾರೆ. ಹಾಗೆ ಒಮ್ಮೆ ಅಪವರ್ತನೀಯ ನೋಡುತ್ತಾನೆ ಮತ್ತು = 4, ಅಪವರ್ತನೀಯ ಸ್ವತಃ ಕರೆಯುತ್ತೇವೆ. ಈಗ, ಇದ್ದಕ್ಕಿದ್ದಂತೆ, ನಾವು (3) ಅಪವರ್ತನೀಯ ಹೊಂದಿರುತ್ತವೆ. ಆದ್ದರಿಂದ ಈ ಕಾರ್ಯಗಳು ಅಂತಿಮವಾಗಿ ನಾವು ನಮ್ಮ ಮೂಲ ಸಂದರ್ಭದಲ್ಲಿ ಹಿಟ್ ರವರೆಗೆ ಬೆಳೆಯುತ್ತಿರುವ ಇರಿಸಿಕೊಳ್ಳಲು ಹೋಗುವ. ಈ ಹಂತದಲ್ಲಿ, ಈ ಮರಳುವ ಮೌಲ್ಯವನ್ನು ರಿಟರ್ನ್ (NX ಈ ಮರಳುವ ಮೌಲ್ಯವನ್ನು), ಆಗಿದೆ ಈ ಮರಳುವ ಮೌಲ್ಯವನ್ನು ಈ NX ಮರಳುವ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ. ಅಂತಿಮವಾಗಿ ನಾವು ಕೆಲವು ಸಂಖ್ಯೆಯ ಹೊಡೆಯಲು ಬೇಕಾಗುತ್ತದೆ. ಇಲ್ಲಿ ಮೇಲ್ಭಾಗದಲ್ಲಿ ನಾವು ರಿಟರ್ನ್ 1 ಹೇಳುತ್ತಾರೆ. ಒಮ್ಮೆ ನಾವು ಸಂಖ್ಯೆ ಮರಳಿ ಎಂದು ಅರ್ಥ, ನಾವು ಸ್ಟಾಕ್ ಆಫ್ ಈ ಪಾಪ್ ಮಾಡಬಹುದು. ಆದ್ದರಿಂದ ಈ ಅಪವರ್ತನೀಯ (1) ಮಾಡಲಾಗುತ್ತದೆ. ಆಗ 1 ಮರಳುತ್ತದೆ, ಈ ಅಪವರ್ತನೀಯ (1) ಹಿಂತಿರುಗುತ್ತದೆ 1 ಮರಳಿ. ಈ ಮರಳುವ ಮೌಲ್ಯವನ್ನು, ನೆನಪಿಡಿ, ಈ ಮರಳುವ ಮೌಲ್ಯವನ್ನು NX ಆಗಿತ್ತು. ಆದ್ದರಿಂದ ಇದ್ದಕ್ಕಿದ್ದಂತೆ, ಈ ವ್ಯಕ್ತಿ ನಾನು 2 ಮರಳಲು ಬಯಸುವ ತಿಳಿದಿದೆ. 

ಆದ್ದರಿಂದ, ಮರೆಯದಿರಿ ಈ ಮೌಲ್ಯವನ್ನು ಇಲ್ಲಿ ಮರಳುವ ಮೌಲ್ಯವನ್ನು ಕೇವಲ NX ಅಪ್ ಹಿಂತಿರುಗಿ. ಈಗ ನಾವು 3 x 2 ಹೇಳಬಹುದು, ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಇಲ್ಲಿ ನಾವು ಹೇಳಬಹುದು ಈ ಕೇವಲ 4 x 3 x 2 ಎಂದು ಹೋಗುತ್ತದೆ. ಮತ್ತು ಈ ಮರಳುತ್ತದೆ ಒಮ್ಮೆ ನಾವು ಮುಖ್ಯ ಒಂದು ಪೂರ್ಣಾಂಕ ಒಳಗೆ ಕೆಳಗೆ ಪಡೆಯುವುದು. ರಿಕರ್ಶನ್ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು? ಎಲ್ಲಾ ಸರಿ. ಆದ್ದರಿಂದ ಪ್ರಶ್ನೆಗಳಿಗೆ ಹೆಚ್ಚಿನ ಸಮಯ, ಕೊನೆಯಲ್ಲಿ ಇಲ್ಲ ಆದರೆ ಈಗ ಜೋಸೆಫ್ ಉಳಿದ ವಿಷಯಗಳು ಕ್ರಮಿಸುತ್ತದೆ. 

[ಜೋಸೆಫ್ ಓಂಗ್] ಸರಿ. ಈಗ ನಾವು recursions ಬಗ್ಗೆ ಮಾತನಾಡಿದರು ಮಾಡಿರುವುದರಿಂದ, ನ ತೆರನಾದ ವಿಲೀನಗೊಳ್ಳಲು ಬಗ್ಗೆ ಸ್ವಲ್ಪ ಮಾತನಾಡೋಣ. ವಿಲೀನಗೊಳ್ಳಲು ರೀತಿಯ ಮೂಲತಃ ಸಂಖ್ಯೆಗಳ ಪಟ್ಟಿಯನ್ನು ವಿಂಗಡಿಸುವ ಮತ್ತೊಂದು ದಾರಿ. ಮತ್ತು ವಿಲೀನ ರೀತಿಯ ಜೊತೆ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ನೀವು ಒಂದು ಪಟ್ಟಿಯನ್ನು ಹೊಂದಿದ್ದು, ಮತ್ತು ನಾವು ಆಗಿದೆ ನಾವು ನ 2 ಹಂತವಾಗಿ ಈ ಬೇರ್ಪಟ್ಟು ಅವಕಾಶ ಹೇಳುತ್ತಾರೆ. ನಾವು ಮೊದಲು ಎಡ ಅರ್ಧದಲ್ಲಿ ಮತ್ತೆ ರೀತಿಯ ವಿಲೀನಗೊಳ್ಳಲು ರನ್ ಮಾಡುತ್ತೇವೆ ನಂತರ ನಾವು ಬಲ ಅರ್ಧದಲ್ಲಿ ರೀತಿಯ ವಿಲೀನಗೊಳ್ಳಲು ರನ್ ಮಾಡುತ್ತೇವೆ ಮತ್ತು ಈಗ ನಮಗೆ ವಿಂಗಡಿಸಲಾಗುತ್ತದೆ ಎಂದು 2 ಅರ್ಥ ನೀಡುತ್ತದೆ ಮತ್ತು ಈಗ ನಾವು ಒಟ್ಟಾಗಿ ಆ ಅರ್ಥ ಸಂಯೋಜಿಸಲು ನೀನು. ಇದು ಉದಾಹರಣೆಗೆ ಯಾವುದೇ ನೋಡಲು ಸ್ವಲ್ಪ ಕಷ್ಟ, ಆದ್ದರಿಂದ ನಾವು ಚಲನೆಗಳ ಮೂಲಕ ಹೋಗಿ ಏನಾಗುತ್ತದೆ ನೋಡುತ್ತಾರೆ. ಆದ್ದರಿಂದ ಈ ಪಟ್ಟಿಯನ್ನು, ನಾವು 2 ಅರ್ಥ ವಿಭಾಗಿಸಿರಿ ಪ್ರಾರಂಭಿಸಿ. ನಾವು ಮೊದಲ ಎಡ ಅರ್ಧದಲ್ಲಿ ರೀತಿಯ ವಿಲೀನಗೊಳ್ಳಲು ರನ್. ಆದ್ದರಿಂದ ಎಡ ಅರ್ಧ, ಮತ್ತು ಈಗ ನಾವು ಮತ್ತೆ ಈ ಪಟ್ಟಿಯಲ್ಲಿ ಮೂಲಕ ರನ್ ಇದು ನಾವು, ಮತ್ತೆ, ನೋಡಲು ನಂತರ ವಿಲೀನ ರೀತಿಯ ರವಾನೆಯಾದವು, ಮತ್ತು ಮುಟ್ಟುತ್ತದೆ ಈ ಪಟ್ಟಿಯ ಎಡಭಾಗದಲ್ಲಿ ಮತ್ತು ನಾವು ಮೇಲೆ ವಿಂಗಡಿಸಿ ವಿಲೀನಗೊಳ್ಳಲು ರನ್. ಈಗ, ನಾವು, 2 ಸಂಖ್ಯೆಗಳ ಪಟ್ಟಿಯನ್ನು ಕೆಳಗೆ ಪಡೆಯಿರಿ ಮತ್ತು ಈಗ ಎಡ ಅರ್ಧ ಮಾತ್ರ 1 ಅಂಶ ಉದ್ದವಾಗಿದೆ ಮತ್ತು ನಾವು ಅರ್ಧದಷ್ಟನ್ನು ಮಾತ್ರ 1 ಅಂಶ ಎಂದು ಪಟ್ಟಿಯನ್ನು ಬೇರ್ಪಟ್ಟು, ಆದ್ದರಿಂದ ನಾವು ಒಮ್ಮೆ ನಾವು 50 ಹೊಂದಿವೆ, ಹೇಳುತ್ತಾರೆ, ಇದು ಕೇವಲ 1 ಅಂಶ, ಇದು ಈಗಾಗಲೇ ವಿಂಗಡಿಸಲಾದ ನ. 

ನಾವು ಪೂರೈಸಿದ ನಂತರ, ನಾವು ನಾವು ನೋಡಬಹುದು ಈ ಪಟ್ಟಿಯ ಬಲ ಅರ್ಧ ಕಡೆಗೆ, ಮತ್ತು 3, ಆದ್ದರಿಂದ ಈಗ ಈ ಪಟ್ಟಿಯ ಎರಡೂ ಅರ್ಥ ವಿಂಗಡಿಸಲಾಗುತ್ತದೆ ಎಂದು ವಿಂಗಡಿಸಿ, ಮತ್ತು ನಾವು ಮತ್ತೆ ಒಟ್ಟಿಗೆ ಈ ಸಂಖ್ಯೆಗಳನ್ನು ಸೇರಬಹುದು. ನಾವು 50 ಮತ್ತು 3 ನೋಡಲು; 3 50 ಚಿಕ್ಕದಾಗಿದೆ, ಆದ್ದರಿಂದ ಮೊದಲ ಹೋಗುತ್ತಾನೆ ಮತ್ತು ನಂತರ 50 ಸೈನ್ ಬರುತ್ತದೆ ಈಗ ಆ ನಿಲ್ಲಿಸುವುದಾಗಿ; ನಾವು ಬಲ ಅರ್ಧ ಎಂದು ಪಟ್ಟಿ ಮತ್ತು ರೀತಿಯ ಹಿಂದಿರುಗಿ ಹೋಗಿ. 42 ಇದು ಆದ ಸಂಖ್ಯೆ, ಆದ್ದರಿಂದ ಈಗಾಗಲೇ ವಿಂಗಡಿಸಲಾದ ನ. ಈಗ ನಾವು, ಮೊದಲ ಪುಟ್ ಗಳಿಸುವ ಆದ್ದರಿಂದ, 2 ಮತ್ತು 3 42 ಚಿಕ್ಕದಾಗಿದೆ ಈ ಹೋಲಿಕೆ ಈಗ 42 ರಲ್ಲಿ ಪುಟ್ ಮಾಡಲ್ಪಡುತ್ತವೆ, ಮತ್ತು 50 ಸೈನ್ ಪುಟ್ ಮುಟ್ಟುತ್ತದೆ ಈಗ ಪ್ರತಿಗಳ ಎಂದು, ನಾವು, ಮೇಲಕ್ಕೆ ಹಿಂದೆ 1337 ಮತ್ತು 15 ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಹೋಗಿ. ಹಾಗೆಯೇ, ನಾವು ಈಗ ಈ ಪಟ್ಟಿಯ ಎಡ ಅರ್ಧ ನೋಡಲು; 1337 ಸ್ವತಃ ಆದ್ದರಿಂದ ಇದು 15 ಮೂಲಕ ಪ್ರತ್ಯೇಕಿಸಬಹುದು ಮತ್ತು ಅದೇ ಸ್. ಈಗ ನಾವು ಮೂಲ ಪಟ್ಟಿ, 15 <1337, ವಿಂಗಡಿಸಲು ಈ 2 ಸಂಖ್ಯೆಗಳು ಒಗ್ಗೂಡಿ ಆದ್ದರಿಂದ ಮೊದಲ ಹೋಗುತ್ತದೆ, ನಂತರ 1337 ಸೈನ್ ಹೋಗುತ್ತದೆ ಮತ್ತು ಈಗ ನಾವು ಟಾಪ್ ಅಪ್ ಮೂಲ ಪಟ್ಟಿಯನ್ನು ಎರಡೂ ಅರ್ಥ ವಿಂಗಡಿಸುತ್ತದೆ. ಮತ್ತು ನಾವು ಎಲ್ಲಾ ಈ ಒಟ್ಟುಗೂಡುತ್ತವೆ. ಈ ಪಟ್ಟಿಯಲ್ಲಿ ಮೊದಲ 2 ಸಂಖ್ಯೆಗಳು 3 <15 ನೋಡಲು, ಆದ್ದರಿಂದ ಮೊದಲ ರೀತಿಯ ಸರಣಿ ಹೋಗುತ್ತದೆ. 15 <42, ಆದ್ದರಿಂದ, ಈಗ ಸೈನ್ ಹೋಗುತ್ತದೆ 42 <1337, ಆ ಸೈನ್ ಹೋಗುತ್ತದೆ 50 <1337, ಆದ್ದರಿಂದ ಸೈನ್ ಹೋಗುತ್ತದೆ ಮತ್ತು ನಾವು ಈ ಪಟ್ಟಿಯ 2 ಸಂಖ್ಯೆಗಳು ಹಾರಿದ ಗಮನಿಸಿ. ಆದ್ದರಿಂದ ನಾವು 2 ಪಟ್ಟಿಗಳನ್ನು ನಡುವಿನ ಪರ್ಯಾಯ ಇಲ್ಲ. ನಾವು ಆರಂಭದಲ್ಲಿ ಹುಡುಕುತ್ತಿರುವ, ಮತ್ತು ನಾವು ಅಂಶ ತೆಗೆದುಕೊಳ್ಳುವ ನೀವು ಸಣ್ಣ ಮತ್ತು ನಂತರ ನಮ್ಮ ವ್ಯೂಹವನ್ನು ಅದನ್ನು ಪುಟ್ಟಿಂಗ್ ದ. ಈಗ ನಾವು ಎಲ್ಲಾ ಅರ್ಥ ವಿಲೀನಗೊಂಡಿತು ನೀವು ಮತ್ತು ನಾವು ಮುಗಿಸಿದ್ದೀರಿ. 

ಬಗ್ಗೆ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳನ್ನು ರೀತಿಯ ವಿಲೀನಗೊಳ್ಳಲು? ಹೌದು? [ವಿದ್ಯಾರ್ಥಿ] ಇದು ವಿಭಿನ್ನ ಗುಂಪುಗಳಾಗಿ ವಿಭಾಗಿಸಿ ಸರಿ, ಏಕೆ ಅವರು ಕೇವಲ ಒಮ್ಮೆ ಬೇರ್ಪಟ್ಟು ಇಲ್ಲ ಮತ್ತು ನೀವು ಒಂದು ಗುಂಪಿನಲ್ಲಿ 3 ಮತ್ತು 2 ಹೊಂದಿವೆ? [ಪ್ರಶ್ನೆಯನ್ನು ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ ಉಳಿದ] ಕಾರಣ - ಹೀಗೆ ಪ್ರಶ್ನೆ, ನಾವು ಅವುಗಳನ್ನು ನಂತರ ಏಕೆ ನಾವು ಮೊದಲ ಹಂತದಲ್ಲಿ ಅವರನ್ನು ವಿಲೀನಗೊಳಿಸಲಾಗುವುದಿಲ್ಲ? ನಾವು ಈ ಮಾಡಬಹುದು ಕಾರಣ, ಎರಡೂ ಎಡ ಅತ್ಯಂತ ಅಂಶಗಳನ್ನು ಆರಂಭವಾಗುವುದು ತದನಂತರ, ಸಣ್ಣ ಒಂದು ತೆಗೆದುಕೊಂಡು ಅದನ್ನು ಇರಿಸಲಾಯಿತು ನಾವು ಈ ತಿಳಿದಿದೆ ಎಂದು ಮಾಲಿಕ ಪಟ್ಟಿಗಳನ್ನು ವಿಂಗಡಿಸಲಾದ ಆದೇಶಗಳನ್ನು ಇವೆ. ನಾನು ಎರಡೂ ಅರ್ಥ ಎಡ ಅತ್ಯಂತ ಅಂಶಗಳನ್ನು ಬಯಸುತ್ತೇನೆ ಹಾಗಾಗಿ, ನಾನು ಆ ಪಟ್ಟಿಗಳನ್ನು ಚಿಕ್ಕ ಅಂಶಗಳು ಎಂದು ನೀನು ತಿಳಿದಿದೆ. ಆದ್ದರಿಂದ ನಾನು ಈ ದೊಡ್ಡ ಪಟ್ಟಿಯ ಚಿಕ್ಕ ಅಂಶ ತಾಣಗಳು ಅವುಗಳನ್ನು ಹಾಕಬಹುದು. ಮತ್ತೊಂದೆಡೆ, ನಾನು ಮೇಲೆ ಎರಡನೆಯ ಮಟ್ಟದಲ್ಲಿ ಆ 2 ಪಟ್ಟಿಗಳನ್ನು ನೋಡಿದರೆ, 50, 3, 42, 1337 ಮತ್ತು 15, ಆ ವಿಂಗಡಿಸಲಾದ ಇಲ್ಲ. ನಾನು 50 ಮತ್ತು 1337 ನೋಡಲು ಆದ್ದರಿಂದ, ನಾನು ನನ್ನ ಮೊದಲ ಪಟ್ಟಿ 50 ಪುಟ್ ಪಡೆಯಲಿದ್ದೇನೆ. ಆದರೆ ನಿಜವಾಗಿಯೂ 3 ಆ ಎಲ್ಲಾ ಔಟ್ ಚಿಕ್ಕ ಅಂಶ ಏಕೆಂದರೆ, ಅರ್ಥದಲ್ಲಿ ಮಾಡುವುದಿಲ್ಲ. ಆದ್ದರಿಂದ ನಾವು ಈ ತುಲನೆ ಹಂತದ ಮಾಡಬಹುದು ಏಕೈಕ ಕಾರಣವೆಂದರೆ ನಮ್ಮ ಪಟ್ಟಿಗಳನ್ನು ಈಗಾಗಲೇ ವಿಂಗಡಿಸಲಾಗುತ್ತದೆ ಏಕೆಂದರೆ. ನಾವು ಕೆಳಗೆ ಎಲ್ಲಾ ವೇ ಡೌನ್ ಪಡೆಯಲು ಏಕೆ ಇದು ನಾವು ಒಂದು ಸಂಖ್ಯೆಯ ಮಾಡಿದಾಗ, ನೀವು ಒಂದು ಏಕೈಕ ಸಂಖ್ಯೆ ತಿಳಿದಿರುವ ಕಾರಣ ಮತ್ತು ಸ್ವತಃ ಈಗಾಗಲೇ ಪ್ರತಿಗಳ ಪಟ್ಟಿಯನ್ನು ಹೊಂದಿದೆ. 

ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು? ಇಲ್ಲ? ಸಂಕೀರ್ಣತೆ? ಅಲ್ಲದೆ, ನೀವು, ಪ್ರತಿ ಹಂತದಲ್ಲೂ ಕೊನೆಯಲ್ಲಿ ಸಂಖ್ಯೆಗಳು ಇಲ್ಲ ಎಂದು ನೋಡಬಹುದು ಮತ್ತು ನಾವು, ಅರ್ಧ ಲಾಗ್ N ಕಾಲದಲ್ಲಿ ಪಟ್ಟಿಯನ್ನು ಭಾಗಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಈ X N ಲಾಗ್ N ಸಂಕೀರ್ಣತೆ ಪಡೆಯಲು ಅಲ್ಲಿ ಇದು. ಮತ್ತು ನೀವು ವಿಲೀನ ರೀತಿಯ ಅತ್ಯುತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ N ಲಾಗ್ N ಹೊಂದಿದೆ ನೋಡುತ್ತಾರೆ, ಮತ್ತು ಇದು ಆದ್ದರಿಂದ ಸಂಭವಿಸುತ್ತದೆ ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ, ಅಥವಾ ಅಲ್ಲಿರುವ Ω, ಸಹ N N ಲಾಗ್ ಎಂದು. ನೆನಪಿನಲ್ಲಿಡಿ ಏನಾದರೂ. ಮೇಲೆ ಚಲಿಸುವ, ಅವರ ಕೆಲವು ಸೂಪರ್ ಮೂಲ ಕಡತ I / O ಗೆ ಹೋಗಿ ಅವಕಾಶ ನೀವು ಸ್ಕ್ರ್ಯಾಂಬಲ್ ನೋಡಿವೆ ವೇಳೆ, ನಾವು ವ್ಯವಸ್ಥೆಯ ಕೆಲವು ರೀತಿಯ ಹೊಂದಿತ್ತು ಗಮನಕ್ಕೆ ಮಾಡುತ್ತೇವೆ ನೀವು ಕೋಡ್ ಓದಲು ನೀವು ಲಾಗ್ ಕಡತಕ್ಕೆ ಬರೆಯಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ. ನ ನೀವು ಹಾಗೆ ಹೇಗೆ ನೋಡೋಣ. ಹಾಗೆಯೇ, ನಾವು fprintf ಹೊಂದಿದ್ದರೆ, ನೀವು, ಎಂದು ಕೇವಲ printf ನಗರದ ಇದು ಆದರೆ ಆರಂಭದಲ್ಲಿ F ಆದ್ದರಿಂದ ಬದಲಿಗೆ ಕಡತ ಮುದ್ರಿಸುವ, ಮತ್ತು. ಅಪ್ ಇಲ್ಲಿ ಕೋಡ್ ಈ ರೀತಿಯ, ನೀವು ಸ್ಕ್ರ್ಯಾಂಬಲ್ ಕಂಡ ಇರಬಹುದು ಎಂದು ಅದು ಏನು ಮಾಡುತ್ತದೆ, ಆಗಿದೆ, ಇದು ಸಂಖ್ಯೆಗಳನ್ನು ಯಾವ ಸಾಲಿನ ಮೂಲಕ ಸಾಲು ನಿಮ್ಮ 2 ಆಯಾಮದ ರಚನೆಯ ಮುದ್ರಣ ಮೂಲಕ ಹೋಗುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಿಮ್ಮ printf ಟರ್ಮಿನಲ್ಗೆ ಔಟ್ ತೋರಿಸುತ್ತದೆ ಅಥವಾ ನಾವು ವಿಭಾಗ ಪ್ರಮಾಣಿತ ಔಟ್ಪುಟ್ ಕರೆಯುವ. 

ಈಗ, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಎಲ್ಲಾ fprintf ಜೊತೆ printf ಸ್ಥಾನವನ್ನು ಹೊಂದಿದೆ ನೀವು ಮುದ್ರಿಸಲು ಯಾವ ಫೈಲ್ ಅದನ್ನು ತಿಳಿಸಿ, ಮತ್ತು ಈ ವಿಚಾರದಲ್ಲಿ, ಅದು ಕೇವಲ ಫೈಲ್ ಇದನ್ನು ತೋರಿಸುತ್ತದೆ ಬದಲಿಗೆ ನಿಮ್ಮ ಟರ್ಮಿನಲ್ ಅದನ್ನು ಔಟ್ ಮುದ್ರಣ. ಅಲ್ಲದೆ, ಆ ಪ್ರಶ್ನೆಯನ್ನು ಬೇಡಿಕೊಂಡಳು: ಎಲ್ಲಿ ನಾವು, ಫೈಲ್ ಅನ್ನು ಈ ರೀತಿಯ ಸಿಗುತ್ತವೆ? ಈ fprintf fuction ಪ್ರವೇಶಿಸಲು ಜಾರಿಗೆ ಆದರೆ ನಾವು ಬಂದ ಅಲ್ಲಿ ಕಲ್ಪನೆ ಇರಲಿಲ್ಲ. ಅಲ್ಲದೆ, ಆರಂಭದಲ್ಲಿ ಕೋಡ್ ನಲ್ಲಿ, ನಾವು ಹೊಂದಿದ್ದು, ಇಲ್ಲಿ ಸುಮಾರು ಕೋಡ್ ಈ ಚಂಕ್ ಆಗಿತ್ತು ಮೂಲತಃ ತೆರೆದ ಕಡತ log.txt ಅಪೇಕ್ಷಿಸುವ ಹೇಳುತ್ತದೆ. ಆ ನಂತರ ನಾವು ನಾವು ಫೈಲ್ ವಾಸ್ತವವಾಗಿ ಯಶಸ್ವಿಯಾಗಿ ಆರಂಭವಾಯಿತು ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕು. ಆದ್ದರಿಂದ ಅನೇಕ ಕಾರಣಗಳಿಗೆ ಕೆಲಸ ಮಾಡದೆ ಇರಬಹುದು; ನೀವು ಉದಾಹರಣೆಗೆ, ನಿಮ್ಮ ಗಣಕದಲ್ಲಿ ಸಾಕಷ್ಟು ಸ್ಥಳವನ್ನು ಹೊಂದಿಲ್ಲ. ನೀವು ಫೈಲ್ ಯಾವುದೇ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಮೊದಲು ಆದ್ದರಿಂದ ಯಾವಾಗಲೂ ಪ್ರಮುಖ ಆ ಫೈಲ್ ಯಶಸ್ವಿಯಾಗಿ ತೆರೆಯಲಾಯಿತು ಎಂದು ಪರಿಶೀಲಿಸಿ ಎಂದು. ಹಾಗಾಗಿ ಒಂದು, ಆ fopen ಒಂದು ವಾದದ ಪ್ರಕಾರ, ಹಾಗೆಯೇ, ನಾವು ಅನೇಕ ವಿಧಗಳಲ್ಲಿ ಒಂದು ಕಡತವನ್ನು ತೆರೆಯುತ್ತದೆ. ನಾವು ಹೊಂದಿದೆ ಏನು ಮಾಡಬಹುದು, ನಾವು, ಇದು ಹೊರಹೋಗುವ ವೇಳೆ ಈಗಾಗಲೇ ಫೈಲ್ ಅತಿಕ್ರಮಿಸಲಾಗುವುದಿಲ್ಲ ಅಂದರೆ, ಇದು W ಹಸ್ತಾಂತರಿಸುತ್ತಾನೆ ನಾವು, ಅವರು ಬದಲಿಗೆ ಇದು ಅತಿ ಮುಖ್ಯ ಫೈಲ್ ಕೊನೆಗೆ ಸೇರಿಸಲು ಇದು, ಒಂದು ಪಾಸ್ ಮಾಡಬಹುದು ಅಥವಾ ನಾವು ಅಂದರೆ, R ಸೂಚಿಸಬಹುದು, ಫೈಲ್ ಓದಲು ಮಾತ್ರ ತೆರೆಯಲು ಅವಕಾಶ. ಪ್ರೋಗ್ರಾಂ, ಫೈಲ್ ಯಾವುದೇ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ ಹಾಗಿದ್ದಲ್ಲಿ ಅವುಗಳನ್ನು ಕೂಗಿ ಮತ್ತು ಅವುಗಳನ್ನು ಮಾಡಲಿ ಇಲ್ಲ. ಅಂತಿಮವಾಗಿ, ಒಮ್ಮೆ ನಾವು, ಅದರ ಮೇಲೆ ಕಾರ್ಯಾಚರಣೆ ಮಾಡುವ ಆಯಿತು, ಕಡತ ಪೂರೈಸಿದ ನಾವು ಫೈಲ್ ಮುಚ್ಚಿ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಅಗತ್ಯವಿದೆ. ಮತ್ತು ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಕೊನೆಯಲ್ಲಿ, ನೀವು ಮತ್ತೆ ಅವುಗಳನ್ನು ಹಾದು ಹೋಗುವ ನೀವು ತೆರೆಯಿತು, ಮತ್ತು ಅದನ್ನು ಮುಚ್ಚಿ ಈ ಫೈಲ್ ಆ. ಆದ್ದರಿಂದ ಈ ನೀವು ಖಾತ್ರಿಪಡಿಸಿಕೊಳ್ಳಿ ಅವುಗಳ ಪ್ರಮುಖ ಸಂಗತಿಯಾಗಿದೆ. ಆದ್ದರಿಂದ ನೀವು ಒಂದು ಕಡತವನ್ನು ತೆರೆಯಲು ನೆನಪಿನಲ್ಲಿಟ್ಟುಕೊಳ್ಳಿ, ನಂತರ ನೀವು, ಕಡತ ಬರೆಯಬಹುದು ಕಡತದಲ್ಲಿ ಕಾರ್ಯಾಚರಣೆಯನ್ನು, ಆದರೆ ನೀವು ಕೊನೆಯಲ್ಲಿ ಕಡತವನ್ನು ಮುಚ್ಚಲು ಹೊಂದಿರುತ್ತವೆ. 

ಮೂಲ ಫೈಲ್ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳನ್ನು ನಾನು / ಓ? ಹೌದು? [ವಿದ್ಯಾರ್ಥಿ ಪ್ರಶ್ನೆ, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ] ಇಲ್ಲಿಯೇ. ಪ್ರಶ್ನೆ, ಈ log.txt ಫೈಲ್ ಅಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ ಇದೆ? ನೀವು ಅದನ್ನು log.txt ಕೊಟ್ಟರೆ ಅಲ್ಲದೆ, ಇದು ಕಾರ್ಯಗತಗೊಳ್ಳುವ ಅದೇ ಕೋಶದಲ್ಲಿನ ಇದು ಸೃಷ್ಟಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ you're ವೇಳೆ - >> [ವಿದ್ಯಾರ್ಥಿ ಪ್ರಶ್ನೆ, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ] ಹೌದು. ಒಂದೇ ಕಡತದಲ್ಲಿ, ಅಥವಾ ಅದೇ ಕೋಶದಲ್ಲಿನ, ನೀವು ಕರೆ. ಈಗ ಮೆಮೊರಿ, ಸ್ಟಾಕ್, ಮತ್ತು ರಾಶಿ. ಆದ್ದರಿಂದ ಕಂಪ್ಯೂಟರ್ ಇರಿಸಲ್ಪಟ್ಟಿವೆ ಸ್ಮರಣೆ ಹೇಗೆ? ಅಲ್ಲದೆ, ನೀವು ಇಲ್ಲಿ ಈ ಬ್ಲಾಕ್ನ ತೆರನಾದ ಮೆಮೊರಿ ಕಲ್ಪಿಸಬಹುದಾದ. ಮತ್ತು ನೆನಪಿಗಾಗಿ ನಾವು ಅಲ್ಲಿರುವ ಅಂಟಿಕೊಂಡಿತು ರಾಶಿ, ಹಾಗೂ ಕೆಳಗೆ ಎಂದು ಸ್ಟಾಕ್ ಎಂಬ ಏನನ್ನು ಹೊಂದಿರುತ್ತವೆ. ಮತ್ತು ರಾಶಿ ಕೆಳಮುಖವಾಗಿ ಬೆಳೆಯುವ ಮತ್ತು ಸ್ಟಾಕ್ ಮೇಲಕ್ಕೆ ಬೆಳೆಯುತ್ತದೆ. ಟಾಮಿ ಪ್ರಸ್ತಾಪಿಸಿದ್ದಾರೆ ಆದ್ದರಿಂದ - ಓಹ್, ಚೆನ್ನಾಗಿ, ಮತ್ತು ನಾವು ನಾನು ಎರಡನೇ ಗೆ ಪಡೆಯುತ್ತೀರಿ ಈ ಇತರ 4 ಭಾಗಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ - ಟಾಮಿ ಮೊದಲೇ ಹೇಳಿದಂತೆ, ನೀವು ಅವರ ಕಾರ್ಯಗಳನ್ನು ತಮ್ಮನ್ನು ಕರೆ ಮತ್ತು ಪರಸ್ಪರ ಕರೆ ಹೇಗೆ ಗೊತ್ತು? ಅವರು ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ಈ ರೀತಿಯ ನಿರ್ಮಿಸಲು. ಜೊತೆಗೆ, ಪ್ರಮುಖ ಕರೆಗಳು foo, foo ಸ್ಟಾಕ್ ಮೇಲೆ ಗೆಟ್ಸ್ ವೇಳೆ. ಫೂ ಕರೆಗಳನ್ನು ಬಾರ್, ಬಾರ್ ನ ಸ್ಟಾಕ್ ಮೇಲೆ ಪಡೆಯಲು, ಮತ್ತು ನಂತರ ಸ್ಟಾಕ್ ಮೇಲೆ ಬಂದಿದೆ. ಅವರು ಹಿಂದಿರುಗಿ ಎಂದು ಮತ್ತು, ಅವರು ಪ್ರತಿ ಸ್ಟಾಕ್ ಹೊರತೆಗೆಯಲಾಗಿತ್ತು ಪಡೆಯುತ್ತೀರಿ. ಈ ಸ್ಥಾನಗಳ ಪ್ರತಿ ಮತ್ತು ಮೆಮೊರಿ ಏನು ಹಿಡಿದುಕೊಳ್ಳಿ ಇಲ್ಲ? ಅಲ್ಲದೆ, ಪಠ್ಯ ವಿಭಾಗದಲ್ಲಿ ಇದು ಅಗ್ರ, ಪ್ರೋಗ್ರಾಮ್ ಒಳಗೊಂಡಿದೆ. ಯಂತ್ರ ಕೋಡ್ ಆದ್ದರಿಂದ, ಇಲ್ಲ ಎಂದು, ಒಮ್ಮೆ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಕಂಪೈಲ್. ಮುಂದಿನ ಯಾವುದೇ ಜಾಗತಿಕ ಅಸ್ಥಿರ ಆರಂಭಿಸಲಾಗಿಲ್ಲ. 

ಆದ್ದರಿಂದ, ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಜಾಗತಿಕ ಅಸ್ಥಿರ ಹೊಂದಿವೆ, ಮತ್ತು ನೀವು ಒಂದು = 5, ಹೇಳುವ ಆ ವಿಭಾಗದಲ್ಲಿ ಪುಟ್, ಮತ್ತು ಬಲ ಎಂದು ಅಡಿಯಲ್ಲಿ ಗಳಿಸುವ, ನೀವು ಕೇವಲ ಒಂದು ಇಂಟ್ ಯಾವುದೇ ಆರಂಭಗೊಳ್ಳದ ಜಾಗತಿಕ ಅಕ್ಷಾಂಶ ಹೊಂದಿರುತ್ತವೆ ಆದರೆ ನೀವು ಏನು ಸಮಾನವಾಗಿರುತ್ತದೆ ಹೇಳುತ್ತಾರೆ ಇಲ್ಲ. ಈ ಜಾಗತಿಕ ಚರಗಳಾಗಿವೆ, ಆದ್ದರಿಂದ ಅವರು ಮುಖ್ಯ ಹೊರಗೆ ನೀವು ಅರ್ಥ. ಆದ್ದರಿಂದ ಈ ಡಿಕ್ಲೇರ್ಡ್ ಆದರೆ ಆರಂಭಿಸಲಾಗಿಲ್ಲ ಯಾವುದೇ ಜಾಗತಿಕ ಅಸ್ಥಿರ ಅರ್ಥ. ಆದ್ದರಿಂದ ಹೇರಳ ಎಂಬುದರ? ಮೆಮೊರಿ ನಾವು ಸ್ವಲ್ಪ ರಲ್ಲಿ ಪಡೆಯುತ್ತೀರಿ ಇದು malloc ಬಳಸಿ ಹಂಚಿಕೆ. ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಸ್ಟಾಕ್ ನಿಮಗೆ ಯಾವುದೇ ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು ಹೊಂದಿವೆ ಮತ್ತು ಯಾವುದೇ ಕಾರ್ಯಗಳನ್ನು ನೀವು ಅವರ ನಿಯತಾಂಕಗಳನ್ನು ಯಾವುದೇ ಕರೆ ಇರಬಹುದು. ಕೊನೆಯಲ್ಲಿ, ನೀವು ನಿಜವಾಗಿಯೂ, ಪರಿಸರ ವೇರಿಯಬಲ್ಗಳ ಏನು ತಿಳಿಯಲು ಇಲ್ಲ ಆದರೆ ನೀವು ಪ್ರೊಗ್ರಾಮನ್ನು ಬಂದಾಗಲೆಲ್ಲಾ, ಸಂಬಂಧ ಏನಾದರೂ ಹಾಗೆ ಇಲ್ಲ ಈ ಕಾರ್ಯಕ್ರಮವನ್ನು ನಿರ್ವಹಿಸಿದ ವ್ಯಕ್ತಿಯ ಬಳಕೆದಾರಹೆಸರು ಆಗಿದೆ. ಮತ್ತು ಕೆಳಭಾಗದಲ್ಲಿ ರೀತಿಯ ಎಂದು ವಿಶೇಷವೇನು. ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಮೌಲ್ಯಗಳು ಇದು ಮೆಮೊರಿ ವಿಳಾಸಗಳನ್ನು, ವಿಷಯದಲ್ಲಿ, 0 ಅತ್ಯುತ್ತಮ ಆರಂಭದಲ್ಲಿ ಮೌಲ್ಯಗಳು, ಮತ್ತು ಅವರು ಕೆಳಗೆ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಕೆಳಗೆ ಹೋಗಿ. ಈ ಪ್ರಕರಣದಲ್ಲಿ, ನೀವು 32-ಬಿಟ್ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಇಂತಹ, ಕೆಳಭಾಗದಲ್ಲಿ ವಿಳಾಸಕ್ಕೆ ಎಂದು 32 ಬಿಟ್ಗಳು ಏಕೆಂದರೆ, AF ನಂತರ, 0x ಏರಲಿದೆ ಇದು 8 ಬೈಟ್ಸ್, ಮತ್ತು ಈ ಸಂದರ್ಭದಲ್ಲಿ 8 ಬೈಟ್ಗಳು 8 ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಅಂಕೆಗಳು ಅನುರೂಪವಾಗಿದೆ. ಆದ್ದರಿಂದ ಕೆಳಗೆ ಇಲ್ಲಿ ನೀವು, ಇಷ್ಟ, 0xffffff ಹೊಂದಿವೆ ಎಂದು ನೀನು, ಮತ್ತು ಅಲ್ಲಿ ನೀವು 0 ಹೊಂದಿವೆ ಎಂದು ನೀನು. ಆದ್ದರಿಂದ ಯಾವ ಪಾಯಿಂಟರ್ಸ್ ಇವೆ? ನೀವು ಕೆಲವು ಮೊದಲು ವಿಭಾಗದಲ್ಲಿ ಈ ಒಳಗೊಂಡಿದೆ ಇರಬಹುದು. ಆದರೆ ನಾವು ಉಪನ್ಯಾಸ ಅದನ್ನು ಮೇಲೆ ಎಲ್ಲಿಯವರೆಗೆ, ಒಂದು ಪಾಯಿಂಟರ್ ಕೇವಲ ಅಕ್ಷಾಂಶ ರೀತಿಯ ಆದ್ದರಿಂದ ಬದಲಿಗೆ 50 ನಂತಹ ಮೌಲ್ಯದ ವಿಧದ, ಇದು ಮೆಮೊರಿ ಕೆಲವು ಸ್ಥಳ ವಿಳಾಸವನ್ನು ಶೇಖರಿಸುತ್ತದೆ ಇದು ಅಂಗಡಿಗಳು. ಆ ಮೆಮೊರಿ ಲೈಕ್ [ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ]. ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಸಿಗುತ್ತಾರೆ ಏನು, ನಾವು, ಒಂದು ಪೂರ್ಣಾಂಕ ಅಥವಾ ಒಂದು ಇಂಟ್ * ಒಂದು ಪಾಯಿಂಟರ್ ಹೊಂದಿವೆ ಮತ್ತು 0xDEADBEEF ಈ ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ವಿಳಾಸಕ್ಕೆ ಒಳಗೊಂಡಿದೆ. 

ಹಾಗಾಗಿ ನಾವು ಮೆಮೊರಿ ಕೆಲವು ಸ್ಥಳ ಈ ಪಾಯಿಂಟರ್ ಅಂಕಗಳನ್ನು, ಈಗ ಆಗಿದೆ, ಮತ್ತು ಕೇವಲ ಅವರ, ಮೌಲ್ಯ 50 ಈ ಮೆಮೊರಿ ಸ್ಥಳ ಆಗಿದೆ. ಕೆಲವು 32-ಬಿಟ್ ಗಣಕಗಳಲ್ಲಿ, ಎಲ್ಲಾ 32-ಬಿಟ್ ಗಣಕಗಳಲ್ಲಿ, ಪಾಯಿಂಟರ್ಸ್ 32 ಬಿಟ್ಗಳು ಅಥವಾ 4 ಬೈಟ್ಗಳು ತೆಗೆದುಕೊಳ್ಳಬಹುದು. ಆದರೆ, ಉದಾಹರಣೆಗೆ, ಒಂದು 64 ಬಿಟ್ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ, ಪಾಯಿಂಟರ್ಸ್ 64 ಬಿಟ್ಗಳು ಇವೆ. ಆದ್ದರಿಂದ ನೀವು ನೆನಪಿಡಬೇಕು ಬಯಸುವಿರಿ ವಿಷಯ. ಹೀಗಾಗಿ ಅಂತಿಮ ಬಿಟ್ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ, ಒಂದು ಪಾಯಿಂಟರ್ ಕೊನೆಯಲ್ಲಿ ಬಿಟ್ಗಳು ಉದ್ದವಾಗಿದೆ. ಪಾಯಿಂಟರ್ಸ್, ಹೆಚ್ಚುವರಿ ವಿಷಯಗಳು ಯಾವುದೇ ರೀತಿಯ ಜೀರ್ಣಿಸಿಕೊಳ್ಳಲು ಕಷ್ಟವಾಗುತ್ತದೆ ಆದ್ದರಿಂದ ನ ಕ್ರಿಯಾಶೀಲ ಸ್ಮರಣೆ ಹಂಚಿಕೆ ಉದಾಹರಣೆ ಮೂಲಕ ಹೋಗಲು ಅವಕಾಶ. , ಏನು ಕ್ರಿಯಾಶೀಲ ಸ್ಮರಣೆ ಹಂಚಿಕೆ ನೀವು ಮಾಡುತ್ತದೆ, ಅಥವಾ ನಾವು malloc ಕರೆಯುವ ನೀವು ಸೆಟ್ ಹೊರಗಿನ ದತ್ತಾಂಶದ ಬಗೆಯ ನಿಯೋಜಿಸಿ ಅನುಮತಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ ಈ ಡೇಟಾವನ್ನು ರೀತಿಯ ಕಾರ್ಯಕ್ರಮದ ಕಾಲಾವಧಿಯ ಹೆಚ್ಚು ಶಾಶ್ವತ. ನೀವು ತಿಳಿದಿರುವ ಕಾರಣ, ನೀವು ಒಂದು ಕಾರ್ಯದ ಒಳಗೆ X, ಮತ್ತು ಕಾರ್ಯ ಮರಳುತ್ತದೆ ಘೋಷಿಸಿದ ವೇಳೆ, ನೀವು ಇನ್ನು ಮುಂದೆ X ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಎಂದು ಮಾಹಿತಿ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಏನು ಪಾಯಿಂಟರ್ಸ್ ನಮಗೆ ಮಾಡಿ ಅವರು ನಮಗೆ ಮೆಮೊರಿ ಅಥವಾ ಅಂಗಡಿ ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಅವಕಾಶ ಹೊಂದಿದೆ ಅವುಗಳೆಂದರೆ ಮೆಮೊರಿಯ ಬೇರೆ ವಿಭಾಗದಲ್ಲಿ, ಹೇರಳ. ಈಗ ಒಮ್ಮೆ ನಾವು ಎಲ್ಲಿಯವರೆಗೆ ನಾವು ಪಾಯಿಂಟರ್ ಹೊಂದಿವೆ, ಕ್ರಿಯೆಯ ಔಟ್ ಹಿಂತಿರುಗಿ ಮೆಮೊರಿ ಆ ಸ್ಥಳಕ್ಕೆ, ನಾವು ಏನು ಮಾಡಬಹುದು ನಾವು ಅಲ್ಲಿ ಮೌಲ್ಯಗಳನ್ನು ನೋಡಬಹುದು ಆಗಿದೆ. ನ ಒಂದು ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ: ಈ ಮತ್ತೆ ನಮ್ಮ ಮೆಮೊರಿ ವಿನ್ಯಾಸ ಹೊಂದಿದೆ. ಮತ್ತು ನಾವು ಮುಖ್ಯ, ಈ ಫಂಕ್ಷನ್. ಏನು ಅದು ಹೊಂದಿದೆ - ಸರಿ, ಆದ್ದರಿಂದ ಸರಳ, ಬಲ - ಇಂಟ್ X = 5, ಎಂದು ಕೇವಲ ಮುಖ್ಯ ರಲ್ಲಿ ಸ್ಟಾಕ್ ಒಂದು ವೇರಿಯೇಬಲ್ ನ. 

ಮತ್ತೊಂದೆಡೆ, ಈಗ ನಾವು ಕಾರ್ಯ giveMeThreeInts ಕರೆಗಳನ್ನು ಒಂದು ಪಾಯಿಂಟರ್ ಘೋಷಿಸಿದ. ಆದ್ದರಿಂದ ಈಗ ನಾವು ಈ ಕಾರ್ಯವನ್ನು ಹೋಗಿ ನಾವು ಹೊಸ ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ರಚಿಸಲು. ಆದಾಗ್ಯೂ, ಈ ಸ್ಟಾಕ್ ಚೌಕಟ್ಟಿನಲ್ಲಿ, ನಾವು, ಇಂಟ್ * ಟೆಂಪ್ ಘೋಷಿಸಲು ಇದು ನಮಗೆ mallocs 3 ಪೂರ್ಣಾಂಕಗಳ ರಲ್ಲಿ. ಆದ್ದರಿಂದ ಇಂಟ್ ಗಾತ್ರವನ್ನು, ಈ ಇಂಟ್ ಎಷ್ಟು ಬೈಟ್ಗಳು ನಮಗೆ ನೀಡುತ್ತದೆ ಮತ್ತು malloc ನಮಗೆ ನೀಡುವ ರಾಶಿ ಮೇಲೆ ಜಾಗ ಅನೇಕ ಬೈಟ್ಗಳು. ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು, 3 ಪೂರ್ಣಾಂಕಗಳ ಸಾಕಷ್ಟು ಸ್ಥಳವಿಲ್ಲ ರಚಿಸಿದ ಮತ್ತು ರಾಶಿ ನಾನು ಹೆಚ್ಚಿನ ಅಪ್ ಅದನ್ನು ಡ್ರಾ ಮಾಡಿದ ಇದಕ್ಕಾಗಿಯೇ, ಅಪ್ ಅಲ್ಲಿ ಮಾರ್ಗವಾಗಿದೆ. ನಾವು ಮುಗಿಸಿದ ನಂತರ, ನಾವು ಇಲ್ಲಿ ಹಿಂತಿರುಗಿ, ನೀವು ಕೇವಲ 3 ints ಮರಳಿದರು ಅಗತ್ಯವಿದೆ, ಮತ್ತು ಆ ಮೆಮೊರಿ ಅಲ್ಲಿ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ವಿಳಾಸಕ್ಕೆ ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಮತ್ತು ನಾವು ಪಾಯಿಂಟರ್ = ಸ್ವಿಚ್ ಸೆಟ್, ಮತ್ತು ಅಲ್ಲಿ ನಾವು ಮತ್ತೊಂದು ಪಾಯಿಂಟರ್ ಹೊಂದಿರುತ್ತವೆ. ಆದರೆ ಯಾವ ಕ್ರಿಯೆ ಮರಳುತ್ತದೆ ಇಲ್ಲಿ ಜೋಡಿಸಲಾದ ಮತ್ತು ಕಣ್ಮರೆಯಾಗುತ್ತದೆ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ. ಆದ್ದರಿಂದ ಟೆಂಪ್ ಮಾಯವಾಗಿ, ಆದರೆ ನಾವು ಈಗಲೂ ಅಲ್ಲಿ ವಿಳಾಸವನ್ನು ನಿರ್ವಹಿಸಲು ಆ 3 ಪೂರ್ಣಾಂಕಗಳ ಕೊಳವೆಗಳು ಒಳಭಾಗದಲ್ಲಿ. ಈ ಸೆಟ್, ಪಾಯಿಂಟರ್ಸ್, ಜೋಡಿಸಲಾದ ಚೌಕಟ್ಟಿಗೆ ಸ್ಥಳೀಯವಾಗಿ ಕ್ಷೇತ್ರ ಗಳು ಆದರೆ ಅವು ಉಲ್ಲೇಖಿಸಲು ಮೆಮೊರಿ ಹೇರಳ ಹೊಂದಿದೆ. 

ಎಂದು ಅರ್ಥ ಡಸ್? [ವಿದ್ಯಾರ್ಥಿ] ಆ ಪುನರಾವರ್ತಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ? >> [ಜೋಸೆಫ್] ಹೌದು. ನಾನು ಮತ್ತೆ ಸ್ವಲ್ಪ ಹೋಗಿ ಆದ್ದರಿಂದ, ನೀವು ಟೆಂಪ್ ವಿಂಗಡಿಸುವ ನೋಡಿ ಇಲ್ಲಿ ಅಪ್ ರಾಶಿ ಮೇಲೆ ಸ್ವಲ್ಪ ಮೆಮೊರಿ. ಈ ಕ್ರಿಯೆ, giveMeThreeInts ಮರಳುತ್ತದೆ, ಇಲ್ಲಿ ಈ ಸ್ಟಾಕ್ ಕಣ್ಮರೆಯಾಗುತ್ತಿವೆ ಹತ್ತಿದರೆ. ಮತ್ತು ಈ ಸಂದರ್ಭದಲ್ಲಿ ಅಸ್ಥಿರಗಳ ಯಾವುದೇ, ಜೋಡಿಸಲಾದ ಚೌಕಟ್ಟಿನಲ್ಲಿ ಹಂಚಲಾಯಿತು ಈ ಪಾಯಿಂಟರ್. ನಾವು ಟೆಂಪ್ ಮರಳಿದರು ಎಂದು ಕಣ್ಮರೆಯಾಗಿ ಹೋಗುವ, ಆದರೆ ಮತ್ತು ನಾವು = ಟೆಂಪ್, ಪಾಯಿಂಟರ್ ಈಗ ತಾಪಮಾನ ಎಂದು ಸ್ಥಳ ಅದೇ ಮೆಮೊರಿ ತೋರಿಸಲು ವಿಶೇಷವೇನು ಪಾಯಿಂಟರ್ ಸೆಟ್. ಈಗ, ನಾವು ಟೆಂಪ್, ಸ್ಥಳೀಯ ಪಾಯಿಂಟರ್, ಕಳೆದುಕೊಳ್ಳಲು ಕೂಡ ನಾವು ಈಗಲೂ ಆ ವೇರಿಯಬಲ್ ಪಾಯಿಂಟರ್ ಒಳಗೆ ತೋರುತ್ತಿರುವಂತೆ ಏನು ನೆನಪಿಗಾಗಿ ವಿಳಾಸಕ್ಕೆ ಉಳಿಸಿಕೊಳ್ಳುತ್ತವೆ. ಪ್ರಶ್ನೆಗಳು? ನೀವು ವಿಭಾಗದಲ್ಲಿ ಅದನ್ನು ಹೋದ ಇದ್ದರೆ ಒಂದು ಗೊಂದಲಮಯ ವಿಷಯ ರೀತಿಯ ಮಾಡಬಹುದು. ನಾವು, ನಿಮ್ಮ TF ಖಂಡಿತವಾಗಿಯೂ ಅದನ್ನು ಹೋಗುತ್ತದೆ ಮತ್ತು ಸಹಜವಾಗಿ ನಾವು ಪ್ರಶ್ನೆಗಳನ್ನು ಉತ್ತರಿಸುವಿರೆ ಈ ರಿವ್ಯೂ ಅಧಿವೇಶನದ ಕೊನೆಯಲ್ಲಿ. ಆದರೆ ಈ ಸಂಕೀರ್ಣ ವಿಷಯದ ತೆರನಾದ, ಮತ್ತು ನಾನು ತೋರಿಸುತ್ತವೆ ಹೋಗುವವರು ಹೆಚ್ಚು ಉದಾಹರಣೆಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ ಆ ಪಾಯಿಂಟರ್ಸ್ ವಾಸ್ತವವಾಗಿ ಯಾವ ಸ್ಪಷ್ಟನೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ. 

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಪಾಯಿಂಟರ್ಸ್, ಸರಣಿಗಳ ಸಮನಾಗಿದೆ ಆದ್ದರಿಂದ ನಾನು ಒಂದು ಇಂಟ್ ಸರಣಿ ಅದೇ ವಿಷಯ ಈ ಪಾಯಿಂಟರ್ ಬಳಸಬಹುದು. ಹಾಗಾಗಿ, 0 ಗೆ ಸೂಚಿ, ಮತ್ತು 1 ಮೊದಲ ಪೂರ್ಣಾಂಕ ಬದಲಾಗುತ್ತಿರುವ ನಾನು 2 ಎರಡನೇ ಪೂರ್ಣಾಂಕ ಬದಲಾಯಿಸುವ, ಮತ್ತು 3 ನೇ ಪೂರ್ಣಾಂಕ 3. ಪಾಯಿಂಟರ್ಸ್ ಹಾಗೆ ಹೆಚ್ಚು. ಅಲ್ಲದೆ, Binky ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತಾರೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಒಂದು ಪಾಯಿಂಟರ್ ಮಂಜೂರು ಮಾಡಿದ, ಅಥವಾ ನಾವು ಒಂದು ಪಾಯಿಂಟರ್ ಡಿಕ್ಲೇರ್ಡ್ ಆದರೆ ಆರಂಭದಲ್ಲಿ, ನಾನು ಒಂದು ಪಾಯಿಂಟರ್ ಘೋಷಿಸಿತು, ಇದು ನಗರದಲ್ಲಿ ನೆನಪಿಗಾಗಿ ತೋರುತ್ತಿರುವಂತೆ ಅಲ್ಲ. ಇದು ಒಳಗೆ ಕೇವಲ ತ್ಯಾಜ್ಯವೇ ಮೌಲ್ಯಗಳನ್ನು ಇಲ್ಲಿದೆ. ಆದ್ದರಿಂದ ನಾನು ಈ ಪಾಯಿಂಟರ್ ತೋರುತ್ತಿರುವಂತೆ ಅಲ್ಲಿ ಕಲ್ಪನೆಯೂ ಇಲ್ಲ. ಇದು ಕೇವಲ 0 ಮತ್ತು 1 ರ ಆರಂಭದಲ್ಲಿ ಘೋಷಿಸಲಾಯಿತು ಅಲ್ಲಿ ತುಂಬಿ ಒಂದು ವಿಳಾಸವನ್ನು ಹೊಂದಿಲ್ಲ. ನಾನು malloc ಕರೆ ತನಕ ನಾನು ಏನನ್ನೂ ಮಾಡಬಹುದು ಮತ್ತು ನಂತರ ನಾನು ಒಳಗೆ ಮೌಲ್ಯಗಳನ್ನು ಹಾಕಬಹುದು ಅಲ್ಲಿ ರಾಶಿ ಮೇಲೆ ಸ್ವಲ್ಪ ಜಾಗವನ್ನು ನೀಡುತ್ತದೆ. ನಂತರ, ಈ ಮೆಮೊರಿಯ ಒಳಗೆ ಎಂಬುದನ್ನು ತಿಳಿದಿಲ್ಲ. ಆದ್ದರಿಂದ ನಾನು ಮಾಡಬೇಕು ಮೊದಲ ವಿಷಯ ವ್ಯವಸ್ಥೆಯನ್ನು ಸಾಕಷ್ಟು ಮೆಮೊರಿಯನ್ನು ಹೊಂದಿತ್ತು ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸಿ ಆಗಿದೆ ನಾನು ಈ ಪರಿಶೀಲಿಸಿ ಮಾಡುತ್ತಿರುವೆ ಏಕೆ ಇದು ಮೊದಲ ಸ್ಥಳದಲ್ಲಿ 1 ಪೂರ್ಣಾಂಕ ಮರಳಿ ನೀಡಲು. ಪಾಯಿಂಟರ್ ಶೂನ್ಯ ವೇಳೆ, ಅದು ಸಾಕಷ್ಟು ಜಾಗವನ್ನು ಅಥವಾ ಕೆಲವು ಇತರ ದೋಷ ಸಂಭವಿಸಿದೆ ಹೊಂದಿಲ್ಲ ಎಂದರ್ಥ ಆದ್ದರಿಂದ ನನ್ನ ಕಾರ್ಯಕ್ರಮದ ಔಟ್ ನಿರ್ಗಮಿಸಲು ಮಾಡಬೇಕು.  ಯಶಸ್ವಿಗೊಳ್ಳಲು ಮಾಡಿದರೆ ಆದರೆ, ಈಗ ನಾನು ಪಾಯಿಂಟರ್ ಬಳಸಬಹುದು ಮತ್ತು * ಪಾಯಿಂಟರ್ ಮಾಡುತ್ತದೆ ವಿಳಾಸಕ್ಕೆ ಅಲ್ಲಿ ಅದು ಈ ರೀತಿ ಇರುತ್ತದೆ ಅಲ್ಲಿ ಆ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ, ಮತ್ತು ಇದು 1 ಗೆ ಸಮಾನ ಸೆಟ್ಸ್. ಆ ಮೆಮೊರಿ ಅಸ್ತಿತ್ವದಲ್ಲಿತ್ತು ವೇಳೆ ಇಲ್ಲಿ ಮೇಲೆ ನಾವು ಪರಿಶೀಲಿಸುತ್ತಿದ್ದೇವೆ ಮಾಡುತ್ತಿದ್ದೇವೆ. 

ನೀವು ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ತಿಳಿಯಲು ಒಮ್ಮೆ ಇದನ್ನು ಇರಿಸಬಹುದು ಯಾವ ಮೌಲ್ಯವನ್ನು ನೀವು ಜಾರಿಗೆ ಬಯಸುವ; ಈ ಸಂದರ್ಭದಲ್ಲಿ 1 ರಲ್ಲಿ. ನಾವು ಇದನ್ನು ಮುಗಿಸಿದ ನಂತರ, ನೀವು ಎಂದು ಪಾಯಿಂಟರ್ ಮುಕ್ತಗೊಳಿಸಲು ಅಗತ್ಯವಿದೆ ನಾವು ವ್ಯವಸ್ಥೆಯನ್ನು ನೀವು ಮೊದಲ ಸ್ಥಾನದಲ್ಲಿ ಕೇಳಿದ ಆ ಮೆಮೊರಿ ಸಂಪರ್ಕಿಸಲಾಗುತ್ತದೆ ಬೇಕಾಗುತ್ತದೆ. ಏಕೆಂದರೆ ಕಂಪ್ಯೂಟರ್ ನಾವು ಪೂರೈಸಿದ ಮೇಲೆ ಗೊತ್ತಿಲ್ಲ. ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಸ್ಪಷ್ಟವಾಗಿ ಹೇಳುತ್ತವೆ, ಸರಿ, ನಾವು ಮೆಮೊರಿ ಪೂರೈಸಿದ. ಕೆಲವು ಇತರ ಪ್ರಕ್ರಿಯೆಯ ಇದು ಅಗತ್ಯವಿದ್ದರೆ, ಕೆಲವು ಇತರ ಪ್ರೋಗ್ರಾಂ ಅದು ಅಗತ್ಯವಿದೆ, ಮುಂದೆ ಹೋಗಿ ಅದನ್ನು ಪಡೆಯಲು ಹಿಂಜರಿಯಬೇಡಿ. ನಾವು ಕೂಡ ಮಾಡಬಹುದು ನಾವು ಸೆಟ್ನಲ್ಲಿ ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳ ವಿಳಾಸಕ್ಕೆ ಗಳಿಸುತ್ತಿದ್ದರು. ಆದ್ದರಿಂದ ಇಂಟ್ X ಮುಖ್ಯ ಜೋಡಿಸಲಾದ ಫ್ರೇಮ್ ಒಳಗಿದೆ. ಮತ್ತು ನಾವು ಈ ವನ್ನಾಗಲಿ ಬಳಸಿದಾಗ, ಈ ಮತ್ತು ಆಯೋಜಕರು, ಏನು ಅದು ಹೊಂದಿದೆ ಇದು X ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಮತ್ತು X ಮೆಮೊರಿ ಕೇವಲ ಕೆಲವು ಡೇಟಾವನ್ನು ಹೊಂದಿದೆ, ಆದರೆ ಇದು ಒಂದು ವಿಳಾಸವನ್ನು ಹೊಂದಿಲ್ಲ. ಇದು ಎಲ್ಲೋ ಇದೆ ಮಾಡಿದ. ಈ ಏನು ಕರೆ & X, ನಿಂದ ಆದ್ದರಿಂದ ನಮಗೆ X ವಿಳಾಸವನ್ನು ನೀಡುತ್ತದೆ. ಹೀಗೆ ಮಾಡುವುದರ ಮೂಲಕ, ನಾವು X ನೆನಪಿಗಾಗಿ ಅಲ್ಲಿ ಸೂಚಕವನ್ನು ಪಾಯಿಂಟ್ ನೀವು ಮಾಡುತ್ತಿರುವಿರಿ. ಈಗ ನಾವು * ನಂತೆ X, ನಾವು 5 ಮರಳಿ ಪಡೆಯಲು ನೀನು ಇಲ್ಲ. ನಕ್ಷತ್ರ ಇದು dereferencing ಕರೆಯಲಾಗುತ್ತದೆ. ನೀವು ವಿಳಾಸಕ್ಕೆ ಅನುಸರಿಸಲು ಮತ್ತು ನೀವು ಸಂಗ್ರಹಿಸಿದ ಅದು ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲು. 

ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು? ಹೌದು? ನೀವು 3 ಚೂಪಾದ ವಸ್ತು ಮಾಡದಿದ್ದರೆ [ವಿದ್ಯಾರ್ಥಿ], ಇದು ಇನ್ನೂ ಕಂಪೈಲ್ ಮಾಡುವುದಿಲ್ಲ? ಹೌದು. ನೀವು 3 ಪಾಯಿಂಟರ್ ವಿಷಯ ಮಾಡದಿದ್ದರೆ, ಇದು ಈಗಲೂ ಸಂಕಲಿಸಲು ವಿಶೇಷವೇನು ಆದರೆ, ಎರಡನೇ ನಡೆಯುವ ನೀವು ತೋರಿಸಲು, ಮತ್ತು ಕೈಗೊಳ್ಳದೆ ವಿಲ್ ನಾವು ಒಂದು ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ಕರೆಯುವ ಇಲ್ಲಿದೆ. ನೀವು ವ್ಯವಸ್ಥೆಯನ್ನು ನೀಡುವ ಇಲ್ಲ ಅದರ ಮೆಮೊರಿ ಬ್ಯಾಕ್, ಆದ್ದರಿಂದ ಒಂದು ನಂತರ ಪ್ರೋಗ್ರಾಂ ಕೂಡಿಕೊಂಡು ಹೋಗಿ ಹಾಗೆಯೇ ಇದು ಬಳಸುವ, ಮತ್ತು ಮತ್ತೇನಲ್ಲ ಬಳಸಬಹುದು ಮೆಮೊರಿ ಆ. ನೀವು ಎಂದಾದರೂ ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ನಲ್ಲಿ 1.5 ಮಿಲಿಯನ್ ಕಿಲೋಬೈಟ್ಗಳಷ್ಟು ಜೊತೆ ಫೈರ್ಫಾಕ್ಸ್ ನೋಡಿದ ವೇಳೆ, ಕಾರ್ಯ ನಿರ್ವಾಹಕ ರಲ್ಲಿ, ಎಂದು ಇಂದಿನ ವಿಶೇಷವೇನು ಇಲ್ಲಿದೆ. ಅವರು ನಿಭಾಯಿಸಲು ಎಂಬುದಾಗಿ ನೀವು ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಒಂದು ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ಹೊಂದಿರುತ್ತವೆ. ಆದ್ದರಿಂದ ಹೇಗೆ ಪಾಯಿಂಟರ್ ಅಂಕಗಣಿತದ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ? ಅಲ್ಲದೆ, ಪಾಯಿಂಟರ್ ಅಂಕಗಣಿತದ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಆಗಿ ಮುಂತಾದ ಅನುಕ್ರಮಣಿಕೆ ರೀತಿಯ ಹೊಂದಿದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾನು ಪಾಯಿಂಟರ್ ಹೊಂದಿವೆ, ಮತ್ತು ನಾನು ನನ್ನ ಮೊದಲ ಅಂಶ ಸೂಚಕವನ್ನು ಪಾಯಿಂಟ್ ಮಾಡಿ ಆಗಿದೆ ನಾನು ನಿಯೋಜಿತವಾದ ಎಂಬುದನ್ನು 3 ಪೂರ್ಣಾಂಕಗಳ ಈ ರಚನೆಯ. ಈಗ ನಾನು ಏನು, ಸ್ಟಾರ್ ಪಾಯಿಂಟರ್ ಕೇವಲ ಪಟ್ಟಿಯಲ್ಲಿ ಮೊದಲ ಅಂಶ ಬದಲಾಯಿಸುತ್ತದೆ. ಇಲ್ಲಿ ಮೇಲೆ ಸ್ಟಾರ್ ಪಾಯಿಂಟರ್ +1 ಅಂಕಗಳನ್ನು. ಆದ್ದರಿಂದ ಪಾಯಿಂಟರ್ ಇಲ್ಲಿ ಸುಮಾರು, ಪಾಯಿಂಟರ್ +1 ಇಲ್ಲಿ ಸುಮಾರು, ಪಾಯಿಂಟರ್ +2 ಇಲ್ಲಿ ಮುಗಿದ. 

ಆದ್ದರಿಂದ ಕೇವಲ 1 ಸೇರಿಸುವ ಈ ರಚನೆಯ ಉದ್ದಕ್ಕೂ ಚಲಿಸುತ್ತಿರುವ ಅದೇ ವಿಷಯ. ನಾವು ಏನು ಆಗಿದೆ, ನಾವು ಪಾಯಿಂಟರ್ +1 ಮಾಡಿದಾಗ ನೀವು ಇಲ್ಲಿ ಮೇಲೆ ವಿಳಾಸವನ್ನು ಪಡೆಯಲು ಮತ್ತು ಇಲ್ಲಿ ಮೌಲ್ಯ ಪಡೆಯುವ ಸಲುವಾಗಿ, ನೀವು ಸಂಪೂರ್ಣ ನಿರೂಪಣೆಯಿಂದ ಒಂದು ಸ್ಟಾರ್ ಪುಟ್ ಇದು dereference ಗೆ. ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾನು, 1 ಈ ರಚನೆಯ ಮೊದಲ ಸ್ಥಳ ಹೊಂದಿಸುವ ನಾನು 2 ಎರಡನೇ ಸ್ಥಳ, ಮತ್ತು 3 ಮೂರನೇ ಸ್ಥಳ. ನಂತರ ಏನು ನಾನು ಇಲ್ಲಿ ಮೇಲೆ ಮಾಡುತ್ತಿರುವೆ, ನಾನು ನಮ್ಮ ಪಾಯಿಂಟರ್ +1 ಮುದ್ರಿಸುವ ನನಗೆ ಇದು ನನಗೆ 2 ನೀಡುತ್ತದೆ. ಈಗ, ನಾನು ಪಾಯಿಂಟರ್ ಏರಿಕೆಯ ಭಾವಿಸುತ್ತೇನೆ, ಆದ್ದರಿಂದ ಪಾಯಿಂಟರ್ ಪಾಯಿಂಟರ್ +1 ಸಮನಾಗಿರುತ್ತದೆ ಇದು ಮುಂದೆ ಇದು ಚಲಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ ಈಗ ನಾನು ಪಾಯಿಂಟರ್ +1 ಮುದ್ರಿಸುತ್ತದೆ ವೇಳೆ, ಪಾಯಿಂಟರ್ +1, ಈಗ 3 ಈ ಸಂದರ್ಭದಲ್ಲಿ 3 ಔಟ್ ಮುದ್ರಿಸುತ್ತದೆ. ಮತ್ತು ಉಚಿತ ಏನೋ, ನಾನು ನೀಡುವ ಪಾಯಿಂಟರ್ ಸಲುವಾಗಿ ನಾನು malloc ಮರಳಿ ಪಡೆದುಕೊಂಡರು ರಚನೆಯ ಆರಂಭದಲ್ಲಿ ತೋರುಗಡ್ಡಿ ಮಾಡಬೇಕು. ನಾನು ಇಲ್ಲಿ 3 ಕರೆಯಲು ವೇಳೆ ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಈ, ಬಲ ನೆರವೇರಿಸಲಾಯಿತು ಇದು ರಚನೆಯ ಮಧ್ಯದಲ್ಲಿ ಏಕೆಂದರೆ. ನಾನು ಮೂಲ ಸ್ಥಳ ಪಡೆಯಲು ಕಳೆಯುವುದು ಹೊಂದಿವೆ ನಾನು ಮುಕ್ತಗೊಳಿಸಲು ಮೊದಲು ಆರಂಭಿಕ ಮೊದಲ ಸ್ಥಾನ. ಆದ್ದರಿಂದ, ಇಲ್ಲಿ ಹೆಚ್ಚು ಒಳಗೊಂಡಿತ್ತು ಉದಾಹರಣೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಒಂದು ಪಾತ್ರ ಶ್ರೇಣಿಯಲ್ಲಿನ 7 ಪಾತ್ರಗಳು ಹಂಚುತ್ತಾರೆ ಮಾಡುತ್ತಿದ್ದೇವೆ. 

ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಆಲ್ಬಮ್ನಲ್ಲಿ ಏನು, ನಾವು ಅವರನ್ನು ಮೊದಲ 6 ಮೇಲೆ ಲೂಪ್ ನೀವು ಆಗಿದೆ ಮತ್ತು ನಾವು ಝಡ್ ಅವರನ್ನು ಹೊಂದಿಸುವಾಗ ನೀವು ಆದ್ದರಿಂದ, ಇಂಟ್ ನಾನು = 0, ನಾನು> 6, ನಾನು + + ಆದ್ದರಿಂದ, ಪಾಯಿಂಟರ್ + ನಾನು, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಮಗೆ ನೀಡುತ್ತದೆ ಪಾಯಿಂಟರ್, ಪಾಯಿಂಟರ್ +1, ಪಾಯಿಂಟರ್ +2, ಪಾಯಿಂಟರ್ +3, ಹೀಗೆ ಇತ್ಯಾದಿ ಚಕ್ರಕ್ಕೆ. ಏನು ಮಾಡಲು ವಿಶೇಷವೇನು, ಅದು ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲು, dereferences ಎಂದು ವಿಳಾಸಕ್ಕೆ ಗೆಟ್ಸ್ ಆಗಿದೆ ಒಂದು ಝಡ್ ಮತ್ತು ಬದಲಾವಣೆಗಳನ್ನು ಮೌಲ್ಯ ನಂತರ ಕೊನೆಯಲ್ಲಿ ಹಕ್ಕನ್ನು, ಈ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ ನೆನಪಿಡಿ? ಎಲ್ಲಾ ತಂತಿಗಳನ್ನು ಶೂನ್ಯ ಕೊನೆಗೊಳಿಸುವ ಅಕ್ಷರದೊಂದಿಗೆ ಅಂತ್ಯಗೊಳಿಸಲು ಹೊಂದಿರುತ್ತವೆ. ಆದ್ದರಿಂದ, ನಾನು ಏನನ್ನು ಪಾಯಿಂಟರ್ 6 ನಾನು ಸೈನ್ ಶೂನ್ಯ ಟರ್ಮಿನೇಟರ್ ಪಾತ್ರ ಹಾಕಲಾಗುತ್ತದೆ ಮತ್ತು ಈಗ ನಾನು ಮೂಲತಃ ಇಲ್ಲಿ ಮೇಲೆ ಏನು ಮಾಡುತ್ತಿರುವೆ, ಒಂದು ತಂತಿಗೆ printf ಬಲ ಅನುಷ್ಠಾನಕ್ಕೆ ಇದೆ? 

ಆದ್ದರಿಂದ, ಯಾವಾಗ printf ಈಗ ಸ್ಟ್ರಿಂಗ್ ಕೊನೆಯಲ್ಲಿ ತಲುಪಿದ್ದೇನೆ ಅದು? ಇದು ಶೂನ್ಯ ಕೊನೆಗೊಳಿಸುವ ಪಾತ್ರ ಬಡಿದಾಗ. ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಈ ರಚನೆಯ ಆರಂಭದಲ್ಲಿ ನನ್ನ ಮೂಲ ಪಾಯಿಂಟರ್ ಅಂಕಗಳನ್ನು. ನಾನು ಮೊದಲ ಅಕ್ಷರ ಮುದ್ರಿಸುತ್ತದೆ. ನಾನು ಮೇಲೆ ಅದನ್ನು ಸರಿಸಲು. ನಾನು ಆ ಪಾತ್ರವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ. ನಾನು ಮೇಲೆ ಸರಿಸಲು. ಮತ್ತು ನಾನು ಕೊನೆಯಲ್ಲಿ ತಲುಪುವವರೆಗೆ ಈ ನಡೆಸುವ. ಈಗ ಕೊನೆಯಲ್ಲಿ * ಪಾಯಿಂಟರ್ ತಿನ್ನುವೆ dereference ಈ ಮತ್ತು ಶೂನ್ಯ ಕೊನೆಗೊಳಿಸುವ ಪಾತ್ರವನ್ನು ಹಿಂದೆ. ಆದ್ದರಿಂದ ನನ್ನ ಸಮಯದಲ್ಲಿ ಲೂಪ್ ಎಂದು ಮೌಲ್ಯವನ್ನು ಶೂನ್ಯ ಕೊನೆಗೊಳಿಸುವ ಅಕ್ಷರವಾಗಿದೆ ಮಾತ್ರ ಚಲಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ, ಈಗ ನಾನು ಈ ಕುಣಿಕೆಯಿಂದ ಹೊರಗೆ ನಿರ್ಗಮಿಸಲು. ಮತ್ತು ನಾನು ಈ ಪಾಯಿಂಟರ್ 6 ಕಳೆಯಿರಿ ವೇಳೆ ನಾನು ಮರಳಿ ಆರಂಭಿಸಿ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಹೋಗಿ. ನಾನು ಮುಕ್ತವಾಗಿಸುವುದೇ ಆರಂಭಕ್ಕೆ ಹೋಗಲು ಏಕೆಂದರೆ ನೆನಪಿಡಿ, ನಾನು ಈ ಮಾಡುತ್ತಿರುವೆ. 

ಆದ್ದರಿಂದ, ನಾನು ಒಂದು ಸಾಕಷ್ಟು ಗೊತ್ತಿರಲಿಲ್ಲ. ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳನ್ನು ಇವೆ? ದಯವಿಟ್ಟು, ಹೌದು? [ವಿದ್ಯಾರ್ಥಿ ಪ್ರಶ್ನೆಗೆ ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ] ನೀವು ಜೋರಾಗಿ ಎಂದು ಹೇಳಬಹುದು? ಕ್ಷಮಿಸಿ. [ವಿದ್ಯಾರ್ಥಿ] ನೀವು ಪಾಯಿಂಟರ್ ಬಿಡುಗಡೆ ಬಲ ಮೊದಲು ಕೊನೆಯ ಸ್ಲೈಡ್ ರಂದು, ಅಲ್ಲಿ ನೀವು ವಾಸ್ತವವಾಗಿ ಪಾಯಿಂಟರ್ ಮೌಲ್ಯವನ್ನು ಬದಲಾಗುತ್ತಿರುವ? [ಜೋಸೆಫ್] ಆದ್ದರಿಂದ, ಇಲ್ಲಿಯೇ. >> [ವಿದ್ಯಾರ್ಥಿ] ಓಹ್, ಸರಿ. [ಜೋಸೆಫ್] ಆದ್ದರಿಂದ, ನಾನು, ಒಂದು ಪಾಯಿಂಟರ್ ಮೈನಸ್ ಮೈನಸ್ ಹೊಂದಿವೆ, ಇದು, ನಾನು ಕ್ಲಿಕ್ ನಂತರ ಒಂದು ವಿಷಯ ಚಲಿಸುತ್ತದೆ, ಮತ್ತು ಈ ಪಾಯಿಂಟರ್ ರಚನೆಯ ಆರಂಭದಲ್ಲಿ ತೋರಿಸಿದರು ಮಾಡಬೇಕು ಏಕೆಂದರೆ. ನೀವು ಆ ಸಾಲಿನಲ್ಲಿ ನಂತರ ನಿಲ್ಲಿಸಿದ [ವಿದ್ಯಾರ್ಥಿ] ಆದರೆ ಅಗತ್ಯವಿದೆ ಎಂದು. ಈ ನಂತರ ನಿಲ್ಲಿಸಿದ ವೇಳೆ [ಜೋಸೆಫ್] ಆದ್ದರಿಂದ,, ಈ, ಒಂದು ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ ನಾನು ಮುಕ್ತ ರನ್ ಕಾರಣ. [ವಿದ್ಯಾರ್ಥಿ] ನಾನು [ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ] ನೀವು ಪಾಯಿಂಟರ್ +1 [ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ] ಹೊಂದಿತ್ತು ಅಲ್ಲಿ ಮೊದಲ ಮೂರು ಸಾಲುಗಳು ನಂತರ. [ಜೋಸೆಫ್] ಹುಂ. ಆದ್ದರಿಂದ ಪ್ರಶ್ನೆ ಇಲ್ಲಿದೆ? ಕ್ಷಮಿಸಿ. ಇಲ್ಲ, ಇಲ್ಲ. ದಯವಿಟ್ಟು, ಹೋಗಿ ಹೋಗಿ. [ವಿದ್ಯಾರ್ಥಿ] ಆದ್ದರಿಂದ, ನೀವು ಪಾಯಿಂಟರ್ಸ್ ಮೌಲ್ಯವನ್ನು ಬದಲಾವಣೆ ಇಲ್ಲ. ನೀವು ಪಾಯಿಂಟರ್ ಮೈನಸ್ ಮೈನಸ್ ಮಾಡಲೇಬೇಕಿತ್ತು ಮಾಡಿರಲಿಲ್ಲ. [ಜೋಸೆಫ್] ಹೌದು, ನಿಖರವಾಗಿ. ಆದ್ದರಿಂದ, ನಾನು ಪಾಯಿಂಟರ್ +1 ಮತ್ತು ಪಾಯಿಂಟರ್ +2 ಮಾಡಿದಾಗ, ನಾನು ಪಾಯಿಂಟರ್ ಮಾಡುವುದರಿಂದ ಇಲ್ಲ ಪಾಯಿಂಟರ್ +1 ಸಮನಾಗಿರುತ್ತದೆ. ಆದ್ದರಿಂದ, ಪಾಯಿಂಟರ್ ಕೇವಲ ರಚನೆಯ ಆರಂಭದಲ್ಲಿ ತೋರುಗಡ್ಡಿ ಆಗಿರುತ್ತದೆ. ನಾನು ಜೊತೆಗೆ ಮಾಡಿದಾಗ ಇದು ಮಾತ್ರ ಜೊತೆಗೆ ಇದು ಪಾಯಿಂಟರ್ ಒಳಗೆ ಮತ್ತೆ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿಸುತ್ತದೆ ಇದು ವಾಸ್ತವವಾಗಿ ಉದ್ದಕ್ಕೂ ಈ ಚಲಿಸುವ. ಎಲ್ಲಾ ಸರಿ. ಹೆಚ್ಚು ಪ್ರಶ್ನೆಗಳು? 

ಈ ಅಗಾಧ ರೀತಿಯ ವೇಳೆ ಮತ್ತೆ, ಈ ಅಧಿವೇಶನದಲ್ಲಿ ರಕ್ಷಣೆಯನ್ನು ಕಾಣಿಸುತ್ತದೆ. ಅದರ ಬಗ್ಗೆ ನಿಮ್ಮ ಇತರ ಸಹ ಕೇಳಿ, ಮತ್ತು ನಾವು ಕೊನೆಯಲ್ಲಿ ಪ್ರಶ್ನೆಗಳನ್ನು ಉತ್ತರಿಸಬಹುದು. ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ಈ ಮೈನಸ್ ವಿಷಯವನ್ನು ಬಯಸುವುದಿಲ್ಲ. ಈ ನಾನು ಶ್ರೇಣಿಯಲ್ಲಿನ ಆಫ್ಸೆಟ್ ನೀವು ಎಷ್ಟು ಗಮನವಿಡುತ್ತಾ ಅಗತ್ಯ ಹೊಂದಿದೆ. ಆದ್ದರಿಂದ, ಸಾಮಾನ್ಯವಾಗಿ, ಈ ಪಾಯಿಂಟರ್ ಅಂಕಗಣಿತದ ಕೃತಿಗಳು ಹೇಗೆ ವಿವರಿಸಲು ಕೇವಲ ಹೊಂದಿದೆ. ಆದರೆ ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಮಾಡಲು ನಮಗೂ ಪಾಯಿಂಟರ್ ಪ್ರತಿಯನ್ನು ರಚಿಸಲು ಇರುತ್ತದೆ ನಾವು ಸಾಲಿನಲ್ಲಿ ಸಂಚರಿಸುವ ಮಾಡಿದಾಗ ಮತ್ತು ನಂತರ ನಾವು ನಕಲನ್ನು ಬಳಸಿ. ಆದ್ದರಿಂದ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ನೀವು ನಕಲು, ಇಡೀ ಸ್ಟ್ರಿಂಗ್ ಮುದ್ರಿಸಲು ಬಳಸುವ ಆದರೆ, ಪಾಯಿಂಟರ್ ಮೈನಸ್ 6 ಹಾಗೆ ಮಾಡಬೇಕು ಅಥವಾ ನಾವು ಈ ಬಂದು ಎಷ್ಟು ಟ್ರ್ಯಾಕ್ ಇಲ್ಲ ನಾವು ನಮ್ಮ ಮೂಲ ಪಾಯಿಂಟ್ ಇನ್ನೂ ಪಟ್ಟಿಯಲ್ಲಿ ಆರಂಭದಲ್ಲಿ ತೋರಿಸಿದರು ಎಂದು ತಿಳಿದಿರುವ ಕಾರಣ ಮತ್ತು ನಾವು ಮಾರ್ಪಡಿಸಿದವು ಈ ಪ್ರತಿಯನ್ನು ಆಗಿತ್ತು. ಆದ್ದರಿಂದ, ಸಾಮಾನ್ಯವಾಗಿ, ನಿಮ್ಮ ಮೂಲ ಪಾಯಿಂಟರ್ ಪ್ರತಿಗಳನ್ನು ಮಾರ್ಪಡಿಸುತ್ತದೆ. ತರಹದ ವಿಂಗಡಿಸಲು ಪ್ರಯತ್ನಿಸಿ ಮಾಡಬೇಡಿ - ಮೂಲ ಪ್ರತಿಗಳು ಮಾರ್ಪಡಿಸುತ್ತದೆ don't. ನಿಮ್ಮ ಮೂಲ ಮಾತ್ರ ಪ್ರತಿಗಳನ್ನು ಬದಲಾಯಿಸಲು ಪ್ರಯತ್ನಿಸಲಾಗುತ್ತಿದೆ. ನಾವು printf ಆಗಿ ಸ್ಟ್ರಿಂಗ್ ಹಾದುಹೋದಾಗ ಆದ್ದರಿಂದ, ನೀವು ಗಮನಿಸಿ ನೀವು, ನಾವು ಎಲ್ಲಾ dereferences ಜೊತೆ ಮಾಡಿದರು ಹಾಗೆಯೇ ಮುಂದೆ ನಕ್ಷತ್ರ ಪುಟ್ ಹಕ್ಕನ್ನು ಹೊಂದಿಲ್ಲ? ನೀವು ಸಂಪೂರ್ಣ ಸ್ಟ್ರಿಂಗ್% ರು ನಿರೀಕ್ಷಿಸುತ್ತದೆ ಮುದ್ರಿಸುತ್ತದೆ ಆದ್ದರಿಂದ, ಒಂದು ವಿಳಾಸ ಮತ್ತು ಈ ಸಂದರ್ಭದಲ್ಲಿ ಒಂದು ಪಾಯಿಂಟರ್ ಅಥವಾ ಪಾತ್ರಗಳು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರೀತಿ ಸಂದರ್ಭದಲ್ಲಿ. 

ಪಾತ್ರಗಳು, ಚಾರ್ * ಗಳು, ಮತ್ತು ಸರಣಿಗಳ ಒಂದೇ ಆಗಿವೆ. ಪಾಯಿಂಟರ್ ಅಕ್ಷರಗಳನ್ನು ಹೊಂದಿದೆ, ಮತ್ತು ಪಾತ್ರದ ಸರಣಿಗಳನ್ನು ಒಂದೇ ಆಗಿವೆ. ಆದ್ದರಿಂದ, ನಾವು ಎಲ್ಲಾ ಪಾಯಿಂಟರ್ ರಲ್ಲಿ ಅನುಮೋದನೆ ಇದೆ. ನಾವು * ಪಾಯಿಂಟರ್ ಅಥವಾ ಹಾಗೆ ಏನು ನಂತಹ ರಲ್ಲಿ ಅನುಮೋದನೆ ಇಲ್ಲ. ಆದ್ದರಿಂದ, ರಚನೆಗಳು ಮತ್ತು ಪಾಯಿಂಟರ್ಸ್ ಒಂದೇ ಆಗಿವೆ. ನೀವು X ರೀತಿಯ ಮಾಡುವುದರಿಂದ ನೀವು ಇಲ್ಲಿ ಮೇಲೆ ಒಂದು ಶ್ರೇಣಿಗಾಗಿ [ವೈ] ಅದರ HOOD ಅಡಿಯಲ್ಲಿ ಮಾಡುತ್ತಿದ್ದಾರೆ ಹೇಳುವ ಎಂದರೆ, ಸರಿ, ಇದು, ಒಂದು ಪಾತ್ರವನ್ನು ವ್ಯೂಹವನ್ನು ಇಲ್ಲಿದೆ ಆದ್ದರಿಂದ ಒಂದು ಪಾಯಿಂಟರ್ ಇಲ್ಲಿದೆ. ಹೀಗಾಗಿ X, ಒಂದೇ ಆಗಿವೆ ಮತ್ತು ಆದ್ದರಿಂದ ಏನು, ಇದು X ಗೆ ವೈ ಸೇರ್ಪಡೆಯಾಗುತ್ತದೆ ಸಾಕಷ್ಟು ಮೆಮೊರಿ ಮುಂದೆ ಚಲಿಸುತ್ತಿರುವ ಅದೇ ವಿಷಯ ಇದು. ಈಗ x + y, ನಮಗೆ ವಿಳಾಸಕ್ಕೆ ಕೆಲವು ರೀತಿಯ ನೀಡುತ್ತದೆ ಮತ್ತು ನಾವು ವಿಳಾಸಕ್ಕೆ dereference ಅಥವಾ ಬಾಣದ ಅನುಸರಿಸಲು ಅಲ್ಲಿ ಮೆಮೊರಿ ಆ ಸ್ಥಳ ಮತ್ತು ನಾವು ಮೆಮೊರಿ ಆ ಸ್ಥಳ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲು. ಆದ್ದರಿಂದ, ಆದ್ದರಿಂದ ಈ ಎರಡು ಒಂದೇ ಆಗಿವೆ. ಇದು ಕೇವಲ ಒಂದು ವಾಕ್ಯರಚನೆಯ ಸಕ್ಕರೆಗಳನ್ನು. ಅವರು ಒಂದೇ ವಿಷಯವನ್ನು. ಅವರು ಪರಸ್ಪರ ಕೇವಲ ವಿವಿಧ syntactics ಆರ್. 

ಆದ್ದರಿಂದ, ಪಾಯಿಂಟರ್ಸ್ ಜೊತೆ ತಪ್ಪು ಏನು ಮಾಡಬಹುದು? ಬಹಳಷ್ಟು, ಹಾಗೆ. ಸರಿ. ಆದ್ದರಿಂದ, ಕೆಟ್ಟ ಸಂಗತಿಗಳು. ನಿಮ್ಮ malloc ಕರೆ ಶೂನ್ಯ, ಬಲ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ನೀವು ಮಾಡಬಹುದು ಕೆಲವು ಕೆಟ್ಟ ವಿಷಯಗಳನ್ನು ಪರಿಶೀಲಿಸುವ ಇಲ್ಲ? ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾನು ನೀಡಲು ವ್ಯವಸ್ಥೆ ಕೇಳುವ ನಾನು - ಆ ಸಂಖ್ಯೆ ಏನು? ಒಂದು ಪೂರ್ಣಾಂಕ ಗಾತ್ರವನ್ನು 4 ಬೈಟ್ಗಳು ಏಕೆಂದರೆ, 2 ಬಿಲಿಯನ್ ಬಾರಿ 4 ಲೈಕ್. ನಾನು 8 ಬಿಲಿಯನ್ ಬೈಟ್ಗಳು ರೀತಿಯಲ್ಲಿ ಅದನ್ನು ಕೇಳುವ ನುಡಿದರು. ಖಂಡಿತವಾಗಿಯೂ ನನ್ನ ಕಂಪ್ಯೂಟರ್ ನನಗೆ ಸಾಕಷ್ಟು ಮೆಮೊರಿಯನ್ನು ಮರಳಿ ನೀಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ಹೋಗುವ ಇಲ್ಲ. ಈ ಶೂನ್ಯ ವೇಳೆ ಮತ್ತು ನಾವು ಅಲ್ಲಿರುವ dereference ಅದನ್ನು ಪ್ರಯತ್ನಿಸಿ ಆದ್ದರಿಂದ, ಪರಿಶೀಲಿಸಿ ಇಲ್ಲ - ಇದು ಇನ್ನು ಅಲ್ಲಿ ಬಾಣದ ಅನುಸರಿಸಲು - ನಾವು ಮೆಮೊರಿ ಇಲ್ಲ. ಈ ನಾವು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ dereferencing ಕರೆಯುತ್ತಾರೆ. ಮತ್ತು ಈ ಮೂಲಭೂತವಾಗಿ ನೀವು segfault ಕಾರಣವಾಗುತ್ತದೆ. ನೀವು segfault ರೀತಿಗಳ ಒಂದಾಗಿದೆ. ನೀವು ಇತರ ಕೆಟ್ಟ ವಸ್ತುಗಳು - ಚೆನ್ನಾಗಿ OH. ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ dereferencing ಮಾಡಲಾಯಿತು. ಸರಿ. ಇತರ ಕೆಟ್ಟ ವಸ್ತುಗಳು - ಅಲ್ಲದೆ, ನೀವು ಇಲ್ಲಿ ಒಂದು ಚೆಕ್ ಪುಟ್ ಹೊಂದಿಸುವುದು ಆ ಪಾಯಿಂಟರ್ ಶೂನ್ಯ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ ಆ malloc ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಉಂಟಾದರೆ ಮತ್ತು ಕಾರ್ಯಕ್ರಮದ ಔಟ್ ನಿರ್ಗಮಿಸಲು. Xkcd ಕಾಮಿಕ್ ಆ. ಜನರು ಈಗ ಅರ್ಥ. ರೀತಿಯ. 

ಆದ್ದರಿಂದ, ಮೆಮೊರಿ. ಮತ್ತು ನಾನು ಈ ಮೇಲೆ ಹೋದರು. ನಾವು ಒಂದು ಆವರ್ತನದಲ್ಲಿ malloc ಕರೆ, ಆದರೆ ನಾವು malloc ಕರೆ ಪ್ರತಿ ಬಾರಿ ನೀವು ನಾವು, ಈ ಪಾಯಿಂಟರ್ ತೋರುತ್ತಿರುವಂತೆ ಅಲ್ಲಿ ಜಾಡು ಕಳೆದುಕೊಳ್ಳುತ್ತಿದ್ದೇವೆ ನಾವು clobbering ಇರುವ ಕಾರಣ. ಆದ್ದರಿಂದ, malloc ಆರಂಭಿಕ ಕರೆ ನನಗೆ ಇಲ್ಲಿ ಮೆಮೊರಿ ಮೇಲೆ ನೀಡುತ್ತದೆ. ಈ ನನ್ನ ಪಾಯಿಂಟರ್ ಪಾಯಿಂಟರ್ಸ್. ಈಗ, ನಾನು ಇದು ಉಚಿತ ಇಲ್ಲ, ಆದ್ದರಿಂದ ಈಗ ನಾನು ಮತ್ತೆ malloc ಕರೆ. ಈಗ ಇಲ್ಲಿ ಸುಮಾರು ಸೂಚಿಸುತ್ತಿದೆ. ಈಗ ನನ್ನ ಮೆಮೊರಿ ಇಲ್ಲಿ ಮೇಲೆ ತೋರಿಸುವ ಇದೆ. ಇಲ್ಲಿ ಮೇಲೆ ಸೂಚಿಸುವ. ಇಲ್ಲಿ ಮೇಲೆ ಸೂಚಿಸುವ. ಆದರೆ ಇಲ್ಲಿ ನಾನು ವಿಂಗಡಿಸುವ ಎಲ್ಲಾ ಮೆಮೊರಿ ವಿಳಾಸಗಳ ಲಾಸ್ಟ್ ಟ್ರ್ಯಾಕ್ ಮಾಡಿದ. ಆದ್ದರಿಂದ ಈಗ ನಾನು ಅವುಗಳನ್ನು ಇನ್ನು ಮುಂದೆ ಯಾವುದೇ ಉಲ್ಲೇಖ ಇಲ್ಲ. ಆದ್ದರಿಂದ, ನಾನು ಈ ಕುಣಿಕೆಯಿಂದ ಹೊರಗೆ ಅವರನ್ನು ಮುಕ್ತಗೊಳಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಆದ್ದರಿಂದ, ಈ ರೀತಿಯ ಪರಿಹಾರ ಹುಡುಕುವ ಸಲುವಾಗಿ ನೀವು ಉಚಿತ ಮೆಮೊರಿ ಮರೆಯ ಮತ್ತು ಈ ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ಪಡೆಯಲು ವೇಳೆ, ನೀವು ಅದನ್ನು ಪೂರೈಸಿದ ಒಮ್ಮೆ ಈ ಲೂಪ್ ಒಳಗೆ ಮೆಮೊರಿ ಮುಕ್ತಗೊಳಿಸಲು ಹೊಂದಿರುತ್ತವೆ. ಅಲ್ಲದೆ, ಈ ಏನಾಗುತ್ತದೆ ಹೊಂದಿದೆ. ನಾನು ಸಾಕಷ್ಟು ಈ ದ್ವೇಷದ ತಿಳಿದಿದೆ. ಆದರೆ ಈಗ - ವಾಹ್! ನೀವು 44,000 ಕಿಲೋಬೈಟ್ಗಳಷ್ಟು ನಂತಹ ಪಡೆಯಿರಿ. ಆದ್ದರಿಂದ, ನೀವು, ಲೂಪ್ ಕೊನೆಯಲ್ಲಿ ಕ್ಲಿಕ್ ಮತ್ತು ಕೇವಲ ಮೆಮೊರಿ ಪ್ರತಿ ಬಾರಿ ಮುಕ್ತಗೊಳಿಸಲು ವಿಶೇಷವೇನು. ಮೂಲಭೂತವಾಗಿ, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಎಂದಿಗೂ ಒಂದು ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ಹೊಂದಿಲ್ಲ. 

ಈಗ ನೀವು ಮಾಡಬಹುದು ಯಾವುದೋ ನೀವು ಎರಡು ಬಾರಿ ಕೇಳಿದರು ನೀವು ಕೆಲವು ಮೆಮೊರಿ ಉಚಿತ. ಈ ಪ್ರಕರಣದಲ್ಲಿ, ನೀವು malloc ಏನಾದರೂ, ನೀವು ಅದರ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಬಹುದು. ನೀವು ಅದನ್ನು ಮಾಡಿದ ಹೇಳಿದರು ಒಮ್ಮೆ ನೀವು ಕ್ಲಿಕ್. ಆದರೆ ನಂತರ ನಾವು ಮತ್ತೆ ಬಿಡುಗಡೆ. ಇದು ತುಂಬಾ ಹಾನಿಕಾರಕ ವಿಷಯ. ಇದು ಆರಂಭದಲ್ಲಿ segfault ಹಿಂದಿರುಗಬಹುದೆಂದು ಆದರೆ ನಂತರ ಈ ಜೋಡಿ ಈ corrupts ನಿಮ್ಮ ರಾಶಿ ರಚನೆ ಮುಕ್ತಗೊಳಿಸಿದ ಇದೆ ಏನು ಆದರೆ, ನೀವು CS61 ರೀತಿಯ ಒಂದು ವರ್ಗ ತೆಗೆದುಕೊಳ್ಳಲು ಆಯ್ಕೆ ವೇಳೆ ಮತ್ತು ಈ ಬಗ್ಗೆ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ತಿಳಿಯುವಿರಿ. ಆದರೆ ಮೂಲಭೂತವಾಗಿ ನಂತರ ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ ತಪ್ಪಾಗಿ ಹೋಗುವ ಸಮಯ - ಅಲ್ಲಿ ಮತ್ತು ಅಲ್ಲಿ ಅದು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಸ್ಮರಣೆಯ ಯಾವ ಸ್ಥಳಗಳು ಬಗ್ಗೆ ಅಲ್ಲಿ ಅಕ್ಷಾಂಶ ಮೆಮೊರಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ. ಮತ್ತು ಆದ್ದರಿಂದ ಒಂದು ಪಾಯಿಂಟರ್ ಮುಕ್ತಗೊಳಿಸಿದ ಬಾರಿ ನೀವು ಬಯಸದಿದ್ದರೆ ಒಂದು ಕೆಟ್ಟ ವಿಷಯ. 

ತಪ್ಪು ಹೋಗಿ ಇತರ ವಿಷಯಗಳನ್ನು sizeof ಬಳಸದೇ. ಆದ್ದರಿಂದ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ನೀವು, 8 ಬೈಟ್ಗಳು malloc ಮತ್ತು ಬಲ, ಎರಡು ಪೂರ್ಣಾಂಕಗಳ ಅದೇ ವಿಷಯ? ಆದ್ದರಿಂದ, ಇದು ಸಂಪೂರ್ಣವಾಗಿ ಸುರಕ್ಷಿತವಾಗಿರುತ್ತವೆ, ಆದರೆ ಹೊಂದಿದೆ? ಅಲ್ಲದೆ, ಲ್ಯೂಕಾಸ್, ವಿವಿಧ ಆರ್ಕಿಟೆಕ್ಚರುಗಳ ಮೇಲೆ ಬಗ್ಗೆ ಮಾತನಾಡಿಸಿ ಪೂರ್ಣಾಂಕಗಳ ವಿವಿಧ ಉದ್ದದ ಇವೆ. ಆದ್ದರಿಂದ, ನೀವು ಬಳಸುವ ಆ ಉಪಕರಣದಲ್ಲಿ, ಪೂರ್ಣಾಂಕಗಳು ಸುಮಾರು 4 ಬೈಟ್ಗಳು, ಅವು ಆದರೆ ಕೆಲವು ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಅವರು 8 ಬೈಟ್ಗಳು ಇರಬಹುದು ಅಥವಾ ಅವು 16 ಬೈಟ್ಗಳು ಇರಬಹುದು. ಆದ್ದರಿಂದ, ನಾನು ಇಲ್ಲಿ ಈ ಸಂಖ್ಯೆ ಬಳಸುತ್ತಿದ್ದರೆ, ಈ ಕಾರ್ಯಕ್ರಮವು, ಉಪಕರಣದಲ್ಲಿ ಕೆಲಸ ಆದರೆ ಕೆಲವು ಇತರ ಗಣಕದಲ್ಲಿ ಸಾಕಷ್ಟು ಮೆಮೊರಿ ನಿಯೋಜಿಸಿ ಹಿಂದಿರುಗಬಹುದೆಂದು. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಈ sizeof ಆಯೋಜಕರು ಬಳಸಲಾಗುತ್ತದೆ ಏನು. ಏನು ಮಾಡುತ್ತದೆ ನಮಗೆ ಕರೆ ಮಾಡಿದಾಗ sizeof (ಇಂಟ್),  ನಮಗೆ ಪ್ರೋಗ್ರಾಂ ಚಾಲನೆಯಲ್ಲಿರುವ ಗಣಕದಲ್ಲಿ ಪೂರ್ಣಾಂಕ ಗಾತ್ರವನ್ನು ನೀಡುತ್ತದೆ. ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ, sizeof (ಇಂಟ್), APPLIANCE ರೀತಿಯ ಮೇಲೆ 4 ಹಿಂತಿರುಗುವುದು ಈಗ 8 ಇದು ಈ ವಿಲ್ 4 * 2,, ಇದು ಕೇವಲ ಎರಡು ಪೂರ್ಣಾಂಕಗಳ ಅಗತ್ಯವಿರುವ ಜಾಗದ ಪ್ರಮಾಣವನ್ನು. ಬೇರೆ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ, ಒಂದು int 16 ಬೈಟ್ಗಳು ಅಥವಾ 8 ಬೈಟ್ಗಳು ನಂತಹ ವೇಳೆ, ಇದು ಕೇವಲ ಪ್ರಮಾಣವನ್ನು ಶೇಖರಿಸಿಡಲು ಸಾಕಷ್ಟು ಬೈಟ್ಗಳು ಮರಳಲು ವಿಶೇಷವೇನು. 

ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ. ಆದ್ದರಿಂದ, ನೀವು ನೆನಪಿನಲ್ಲಿ ಒಂದು ಸುಡೊಕು ಬೋರ್ಡ್ ಶೇಖರಿಸಿಡಲು ಬಯಸಿದರೆ, ಹೇಗೆ ನಾವು ಏನು ಮಾಡಬಹುದು? ನೀವು, ಮೊದಲನೆಯದಾಗಿ ಒಂದು ವೇರಿಯೇಬಲ್ ರೀತಿಯ ನಗರದ ಇರಬಹುದು ಎರಡನೆಯ ವಿಷಯ ಒಂದು ವೇರಿಯೇಬಲ್, ಮೂರನೇ ವಿಷಯ ಒಂದು ವೇರಿಯೇಬಲ್, ಕೆಟ್ಟ, ಬಲ - ನಾಲ್ಕನೇ ವಿಷಯ ಒಂದು ವೇರಿಯೇಬಲ್? ಆದ್ದರಿಂದ, ನೀವು ಈ ಮೇಲೆ ಮಾಡಬಹುದು ಒಂದು ಸುಧಾರಣೆ ಒಂದು 9 X 9 ರಚನೆಯ ಮಾಡುವುದು. ಆ ಉತ್ತಮ, ಆದರೆ ನೀವು ಸುಡೊಕು ಮಂಡಳಿಯ ಇತರ ವಿಷಯಗಳನ್ನು ಸಂಯೋಜಿಸಲು ಬಯಸಿದ್ದರು ಹೀಗಾದರೆ , ಮಂಡಳಿಯ ಸಮಸ್ಯೆ ಏನು ಇಷ್ಟ ಅಥವಾ, ಉದಾಹರಣೆಗೆ, ನಿಮ್ಮ ಸ್ಕೋರ್, ಅಥವಾ ಎಷ್ಟು ಬಾರಿ ನೀವು ಈ ಬೋರ್ಡ್ ಪರಿಹರಿಸಲು ತೆಗೆದುಕೊಂಡದ್ದಾಗಿದೆ? ಅಲ್ಲದೆ, ನೀವು ಏನು ಮಾಡಬಹುದು ನೀವು struct ರಚಿಸಬಹುದು ಹೊಂದಿದೆ. ಏನು ನಾನು ಮೂಲತಃ ಹೇಳುವ, ನಾನು ಇಲ್ಲಿ ಈ ರಚನೆಯನ್ನು ವಿವರಿಸುವುದು ನನಗೆ ಮತ್ತು ನಾನು X 9 9 ಒಂದು ಬೋರ್ಡ್ ಒಳಗೊಂಡ ಸುಡೊಕು ಬೋರ್ಡ್ ವ್ಯಾಖ್ಯಾನಿಸುವುದು ನುಡಿದರು. 

ಮತ್ತು ಇದು ಮಟ್ಟದ ಹೆಸರು ರೀತಿಯು ಹೊಂದಿರುತ್ತದೆ ಎಂಬುದನ್ನು. ಇದು ನಾನು ಈಗ ನಾನು ಅಲ್ಲಿ ನಿರ್ದೇಶಾಂಕ ಇವು X ​​ಮತ್ತು Y ಹೊಂದಿದೆ. ಇದು ಸಮಯ [ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ] ಕಳೆದರು, ಮತ್ತು ನಾನು ಇಲ್ಲಿಯವರೆಗೆ ಇನ್ಪುಟ್ ನೀವು ಚಲಿಸುತ್ತದೆ ಒಟ್ಟು ಹೊಂದಿದೆ. ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾನು ಒಂದು ಕಟ್ಟಡಕ್ಕೆ ಅಕ್ಷಾಂಶ ಒಂದು ಇಡೀ ಗುಂಪೇ ಗುಂಪಿನಲ್ಲೇ ಮಾಡಬಹುದು ಬದಲಾಗಿ ವಿವಿಧ ಚರಾಂಕಗಳ ನಂತಹ ಸುಮಾರು ಹಾರುವ ರೀತಿಯಲ್ಲಿ ಅದನ್ನು ಹೊಂದುವ ನಾನು ಟ್ರ್ಯಾಕ್ ಇರಿಸಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಿಲ್ಲ. ಮತ್ತು ಈ ಈ struct ಒಳಗೆ ವಿವಿಧ ವಿಷಯಗಳನ್ನು ಗುರುತಿಸಲಾಗುತ್ತಿದೆ ರೀತಿಯ ಕೇವಲ ಸಂತೋಷವನ್ನು ವಾಕ್ಯ ಹೊಂದಿರುವ ಅನುಮತಿಸುತ್ತದೆ. ನಾನು board.board ರೀತಿಯಲ್ಲಿಯೇ, ಮತ್ತು ನಾನು ಮತ್ತೆ ಸುಡೊಕು ಬೋರ್ಡ್ ಪಡೆಯಿರಿ. Board.level, ನಾನು ಎಷ್ಟು ಕಠಿಣ ಪಡೆಯಿರಿ. Board.x ಮತ್ತು board.y ನಾನು ಮಂಡಲಿಯಲ್ಲಿ ಇರಬಹುದು ಅಲ್ಲಿ ನಿರ್ದೇಶಾಂಕ ನೀಡಿ. ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು struct ಕ್ಷೇತ್ರಗಳು ಕರೆಯುವ ಪ್ರವೇಶಿಸುವ ನುಡಿದರು. ನಾನು ಹೊಂದಿರುವ ಒಂದು ರೀತಿಯ ಇದು sudokuBoard, ವರ್ಣಿಸಬಹುದು. ಈಗ ನಾವು ನೀವು. ನಾನು ರೀತಿಯ sudokuBoard ಆಫ್ "ಮಂಡಳಿ" ಎಂಬ ಮಾರ್ಪಡಿಸಬಹುದಾದ ಹೊಂದಿರುತ್ತವೆ. ಆದ್ದರಿಂದ ಈಗ ನಾನು ಇಲ್ಲಿ ಈ ರಚನೆ ರೂಪಿಸುವ ಎಲ್ಲಾ ಜಾಗ ಪ್ರವೇಶಿಸಬಹುದು. 

ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಬಗ್ಗೆ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳನ್ನು? ಹೌದು? ಇಂಟ್ X, Y ಫಾರ್ [ವಿದ್ಯಾರ್ಥಿ], ನೀವು ಒಂದೇ ಸಾಲಿನಲ್ಲಿ ಎರಡೂ ಡಿಕ್ಲೇರ್ಡ್? >> [ಜೋಸೆಫ್] ಹುಂ. [ವಿದ್ಯಾರ್ಥಿ] ಆದ್ದರಿಂದ, ನೀವು ಅವುಗಳನ್ನು ಎಲ್ಲಾ ಹಾಗೆ ಸಾಧ್ಯವಾಯಿತು? X ನಲ್ಲಿನ ಲೈಕ್, ವೈ ಅಲ್ಪವಿರಾಮ ಪಟ್ಟು ಒಟ್ಟು? [ಜೋಸೆಫ್] ಹೌದು, ನೀವು ಖಂಡಿತವಾಗಿ ನಾನು ಅದೇ ಸಾಲಿನಲ್ಲಿ x ಮತ್ತು y ಪುಟ್ ಕಾರಣ ಹಾಗೆ, ಆದರೆ - ನಾವು ಒಂದೇ ಸಾಲಿನಲ್ಲಿ ಇದನ್ನು ಏಕೆ ಮತ್ತು ಪ್ರಶ್ನೆ? ಯಾಕೆ ನಾವು ಅದೇ ಸಾಲಿನಲ್ಲಿ ಈ ಎಲ್ಲಾ ಇರಿಸಬೇಡಿ x ಮತ್ತು y ಒಂದಕ್ಕೊಂದು ಸಂಬಂಧಪಟ್ಟಿವೆ, ಮತ್ತು ಇದು ಒಂದು ಅರ್ಥದಲ್ಲಿ, ಕೇವಲ ಶೈಲಿಯಲ್ಲಿ ಹೆಚ್ಚು ಸರಿಯಾಗಿದೆ ಇದು ಒಂದೇ ಸಾಲಿನಲ್ಲಿ ಎರಡು ವಸ್ತುಗಳ ಗುಂಪಿನ ವಿಶೇಷವೇನು ಏಕೆಂದರೆ ಆ ರೀತಿಯ ರೀತಿಯ ಒಂದೇ ಸಂಬಂಧಿಸಿದೆ. ಮತ್ತು ನಾನು ಹೊರತುಪಡಿಸಿ ಈ ವಿಭಜನೆಯಾಯಿತು. ಇದು ಕೇವಲ ಒಂದು ಶೈಲಿ ವಿಷಯ. ಇದು ಕಾರ್ಯತಃ ಯಾವುದೇ ವ್ಯತ್ಯಾಸವಿಲ್ಲ. ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು? ನೀವು struct ಒಂದು Pokédex ರೂಪಿಸಬಹುದು. ಒಂದು ಪೊಕ್ಮೊನ್ ಹೊಂದಿದೆ ಮತ್ತು ಒಂದು ಅಕ್ಷರದ, ಮಾಲೀಕರು, ಒಂದು ರೀತಿಯ ಹೊಂದಿದೆ. ನೀವು ಪೊಕ್ಮೊನ್ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿದ್ದರೆ ಮತ್ತು ನಂತರ, ನೀವು ಬಲ, ಒಂದು Pokédex ಅಪ್ ಮಾಡಬಹುದು? ಸರಿ, ತಂಪು. ಆದ್ದರಿಂದ, ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಮೇಲೆ ಪ್ರಶ್ನೆಗಳು. ಆ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಸಂಬಂಧಿಸಿವೆ. 

ಅಂತಿಮವಾಗಿ, GDB. GDB ನೀವು ಏನು ಅವಕಾಶ ಇಲ್ಲ? ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ದೋಷ ಅನುಮತಿಸುತ್ತದೆ. ನೀವು GDB ಬಳಸದೆ ಇದ್ದಲ್ಲಿ ಮತ್ತು, ನಾನು ಸಣ್ಣ ವೀಕ್ಷಿಸಲು ಶಿಫಾರಸು ಎಂದು ಮತ್ತು ಕೇವಲ GDB ಯಾವುದು ಹೋಗುವಾಗ, ಹೇಗೆ ನೀವು, ನೀವು ಬಳಸಬಹುದು ಎಂಬುದನ್ನು ಇದು ಕೆಲಸ ಮತ್ತು ಒಂದು ಪ್ರೋಗ್ರಾಂ ಅದನ್ನು ಪರೀಕ್ಷಿಸಲು. ಮತ್ತು ಆದ್ದರಿಂದ GDB ನೀವು ಅನುಮತಿಸುತ್ತದೆ ಅದರ ವಿರಾಮ [ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ] ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಅವಕಾಶ ಹೊಂದಿದೆ ಮತ್ತು ಪ್ರಾಯೋಗಿಕ ಲೈನ್. ಉದಾಹರಣೆಗೆ, ನಾನು, ನನ್ನ ಕಾರ್ಯಕ್ರಮದ ಲೈನ್ 3 ರೀತಿಯ ನಲ್ಲಿ ವಿರಾಮ ನಿರ್ವಹಣೆ ಬಯಸುವ ಮತ್ತು ನಾನು ಲೈನ್ 3 ನಲ್ಲಿ ಆಮ್ ಐ ಇವೆ ಎಲ್ಲಾ ಮೌಲ್ಯಗಳನ್ನು ಮುದ್ರಿಸುತ್ತದೆ. ಒಂದು ಸಾಲಿನಲ್ಲಿ pausing ಇಷ್ಟಪಟ್ಟಾಗ ನಾವು ಕರೆಯುವ ಈ ಸಾಲನ್ನು ಒಂದು ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಪುಟ್ಟಿಂಗ್ ಕರೆ ಇದೆ ನಂತರ ನಾವು ಆ ಸಮಯದಲ್ಲಿ ಕಾರ್ಯಕ್ರಮದ ರಾಜ್ಯ ಅಸ್ಥಿರ ಮುದ್ರಿಸುತ್ತದೆ. 

ನಾವು ನಂತರ ಕಾರ್ಯಕ್ರಮದ ಲೈನ್ ಮೂಲಕ ಲೈನ್ ಮೂಲಕ ಅಲ್ಲಿ ಹೆಜ್ಜೆ ಮಾಡಬಹುದು. ನಂತರ ನಾವು ಸಮಯದಲ್ಲಿ ಸ್ಟಾಕ್ ರಾಜ್ಯದ ನೋಡಬಹುದು. ಮತ್ತು ಆದ್ದರಿಂದ GDB, ಎಂಬುದನ್ನು ನಾವು ನಾವು ಸಿ ಫೈಲ್ನಲ್ಲಿ ಖಣಿಲು ಕಾಲ್ ಆಗಿದೆ, ಬಳಸಲು ಆದರೆ ನಾವು ಅದನ್ನು ggdb ಧ್ವಜ ರವಾನಿಸಲು ಹೊಂದಿರುತ್ತವೆ. ಮತ್ತು ಒಮ್ಮೆ ನಾವು ಫಲಿತಾ ಔಟ್ಪುಟ್ ಕಡತವನ್ನು ಮೇಲೆ GDB ಓಡುವ ಪೂರೈಸಿದ. ಆದ್ದರಿಂದ ನೀವು ಈ ರೀತಿ ಪಠ್ಯದ ಕೆಲವು ರೀತಿಯ ಸಾಮೂಹಿಕ ಪಡೆಯಿರಿ ಆದರೆ ನೀವು ಮಾಡಬೇಕು ನಿಜವಾಗಿಯೂ ಎಲ್ಲಾ ಆರಂಭದಲ್ಲಿ ಆಜ್ಞೆಗಳನ್ನು ಟೈಪ್ ಇದೆ. ಬ್ರೇಕ್ ಮುಖ್ಯ ಮುಖ್ಯ ಒಂದು ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಇರಿಸುತ್ತದೆ. ಪಟ್ಟಿ 400 ಲೈನ್ 400 ಸುತ್ತ ಕೋಡ್ ಸಾಲುಗಳನ್ನು ಪಟ್ಟಿಮಾಡುತ್ತದೆ. ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ ನೀವು, ಓಹ್, ಹುಡುಕುತ್ತೇನೆ ಮತ್ತು ಹೇಳಬಹುದು ಈ ಸಾಲಿನಲ್ಲಿ ಇದು 397 ಲೈನ್ ಒಂದು ಬ್ರೇಕ್ಪಾಯಿಂಟ್, ಸೆಟ್ ಬಯಸುವ ತದನಂತರ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಆ ಹಂತದ ಹೋಗುತ್ತಾನೆ ಮತ್ತು ಅದನ್ನು ಮುರಿಯಲು ವಿಶೇಷವೇನು. ಇದು ಅಲ್ಲಿ ತಾತ್ಕಾಲಿಕ ವಿಶೇಷವೇನು, ಮತ್ತು ನೀವು, ಉದಾಹರಣೆಗೆ, ಕಡಿಮೆ ಅಥವಾ ಹೆಚ್ಚಿನ ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ ನೀವು ತಿಳಿದುಕೊಳ್ಳಬೇಕಾದ ಆಜ್ಞೆಗಳ ಒಂದು ಗುಂಪೇ ಇವೆ ಮತ್ತು ಈ ಸ್ಲೈಡ್ಶೋ, ವೆಬ್ಸೈಟ್ ಮೇಲೆ ಹೋಗುತ್ತದೆ ನೀವು ಈ ಉಲ್ಲೇಖಿಸಿ ನೀವು ಅಥವಾ ನಿಮ್ಮ ಮೋಸಮಾಡುವುದನ್ನು ಹಾಳೆಗಳ ಮೇಲೆ ಇರಿಸಿ ಇಷ್ಟ ಹಾಗಾಗಿ, ಹಿಂಜರಿಯಬೇಡಿ. 

ಕೂಲ್. ಆ ರಸಪ್ರಶ್ನೆ ರಿವ್ಯೂ 0 ಆಗಿತ್ತು, ಮತ್ತು ನೀವು ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳನ್ನು ಹೊಂದಿದ್ದರೆ ನಾವು ಸುಮಾರು ಅಂಟಿಕೊಳ್ಳುವುದಿಲ್ಲ ಮಾಡುತ್ತೇವೆ. ಎಲ್ಲಾ ಸರಿ. 

 [ಚಪ್ಪಾಳೆಯನ್ನು] 

[CS50.TV]