1
00:00:00,000 --> 00:00:00,340

2
00:00:00,340 --> 00:00:01,960
>> ಸ್ಪೀಕರ್ 1: ಈಗ ಸರಿಪಡಿಸಲು ಅವಕಾಶ
ಕೊನೆಯ ಪ್ರೋಗ್ರಾಂ.

3
00:00:01,960 --> 00:00:04,920
ಈ ಸಮಯದಲ್ಲಿ, ನ ಸ್ಪಷ್ಟವಾಗಿ ನಿಯೋಜಿಸಿ ಅವಕಾಶ
ಕೆಲವು ಮೆಮೊರಿ ಇದರಲ್ಲಿ

4
00:00:04,920 --> 00:00:06,550
ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ಸಂಗ್ರಹಿಸಲಾಗುವುದು.

5
00:00:06,550 --> 00:00:09,600
ಹಾಗೆ ಮಾಡಲು, ನ ಮೊದಲ ಮೇಲೆ ಅಭಿವೃದ್ಧಿಗೊಳಿಸಲು ಅವಕಾಶ
ನಾವು ರು ಡಿಕ್ಲೇರ್ಡ್ ಅಲ್ಲಿ ಕೋಡ್ ಸಾಲು

6
00:00:09,600 --> 00:00:11,590
ಹಿಂದೆ ಒಂದು ಚಾರ್ ಸ್ಟಾರ್.

7
00:00:11,590 --> 00:00:14,210
ಈ ಸಮಯದಲ್ಲಿ, ನಾವು ಮತ್ತೆ ಘೋಷಿಸಿದ
ಇದು ಕೆಳಗಿನಂತೆ -

8
00:00:14,210 --> 00:00:19,380
ಚಾರ್ ರು ಬ್ರಾಕೆಟ್ 16, ಉದಾಹರಣೆಗೆ,
Close ಬ್ರಾಕೆಟ್.

9
00:00:19,380 --> 00:00:23,690
>> ಅರ್ಥಾತ್, ರ ನೋ ರು ಘೋಷಿಸಲು ಅವಕಾಶ
ಮುಂದೆ ಪಾತ್ರ ಒಂದು ವಿಳಾಸಕ್ಕೆ ಎಂದು,

10
00:00:23,690 --> 00:00:26,610
ಆದರೆ 16 ಪಾತ್ರಗಳ ಬದಲಿಗೆ ಒಂದು ಶ್ರೇಣಿಯನ್ನು.

11
00:00:26,610 --> 00:00:30,295
ಈ ರೀತಿಯಲ್ಲಿ, ಬಳಕೆದಾರರ 15 ಟೈಪ್ ಮಾಡಬಹುದು
ಪಾತ್ರಗಳು ಮತ್ತು ಇನ್ನೂ ಕೊಠಡಿ ಬಿಟ್ಟು

12
00:00:30,295 --> 00:00:31,570
ಒಂದು ಶೂನ್ಯ ಟರ್ಮಿನೇಟರ್.

13
00:00:31,570 --> 00:00:35,870
ಉಳಿಸಿ ನ ಹೋಗೋಣ, ಕಂಪೈಲ್,
ಮತ್ತು ಈ ಪ್ರೋಗ್ರಾಂ.

14
00:00:35,870 --> 00:00:40,770
Scanf2 ಡಾಟ್ ಕತ್ತರಿಸಿ scanf2 ಮಾಡಿ.

15
00:00:40,770 --> 00:00:45,100
ಈಗ ನಿನ್ನ ಸ್ಟ್ರಿಂಗ್ ಟೈಪ್ ಲೆಟ್,
ಮತ್ತು ನಾವು ನಿನ್ನ ಧನ್ಯವಾದ ಮಾಡುತ್ತಿದ್ದೇವೆ.

16
00:00:45,100 --> 00:00:46,440
>> ಈಗ, ಸಮಸ್ಯೆ ಇನ್ನೂ ಇಲ್ಲ.

17
00:00:46,440 --> 00:00:50,140
ನಾನು ಮಾತ್ರ ಮಾತ್ರ ಇದು, ಹಲೋ ಬೆರಳಚ್ಚಿಸಿದ
ಶೂನ್ಯ ಐದು ಪಾತ್ರಗಳು, ಜೊತೆಗೆ 1

18
00:00:50,140 --> 00:00:50,445
ಟರ್ಮಿನೇಟರ್.

19
00:00:50,445 --> 00:00:53,610
ಇದು ಕೇವಲ ನಮಗೆ ಬಿಟ್ಟು
ಆರು ಬೈಟ್ಗಳು ಅಗತ್ಯವಿದೆ.

20
00:00:53,610 --> 00:00:56,740
>> ಆದರೆ ದುರದೃಷ್ಟವಶಾತ್, ನಾವು ಮಾತ್ರ
ಒಟ್ಟು 16 ಹಂಚಿಕೆ.

21
00:00:56,740 --> 00:01:01,305
ಆದ್ದರಿಂದ 16 ರಲ್ಲಿ ಬಳಕೆದಾರ ವಾಸ್ತವವಾಗಿ ರೀತಿಯ
ಪಾತ್ರಗಳು, ಅಥವಾ 17, ಅಥವಾ ನೂರಾರು

22
00:01:01,305 --> 00:01:04,410
ಪಾತ್ರಗಳು, ನಾವು ಇನ್ನೂ ಹೋಗುತ್ತಿಲ್ಲ
ಮೆಮೊರಿ ಸಾಕಷ್ಟು ಸ್ಥಳಾವಕಾಶ

23
00:01:04,410 --> 00:01:05,400
ಬಳಕೆದಾರ ಇನ್ಪುಟ್.

24
00:01:05,400 --> 00:01:07,750
ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ಈ ವಿಸ್ಮಯಕ್ಕೆ
ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ಪಡೆಯುವಲ್ಲಿ ಆದ್ದರಿಂದ

25
00:01:07,750 --> 00:01:08,940
ಸಾಮಾನ್ಯವಾಗಿ ಕಷ್ಟ.

26
00:01:08,940 --> 00:01:12,270
ನಾವು ಜಾರಿಗೆ ಏಕೆ ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ಈ
ಮೊದಲ ಪಡೆಯಲು ಸ್ಟ್ರಿಂಗ್ ಕಾರ್ಯ

27
00:01:12,270 --> 00:01:13,900
CS50 ಗ್ರಂಥಾಲಯದ ಸ್ಥಳದಲ್ಲಿ -

28
00:01:13,900 --> 00:01:16,900
ಆ ನಿರ್ವಹಿಸಲು ಹೇಗೆ ಲೆಕ್ಕಾಚಾರ
ಸಂದರ್ಭಗಳಲ್ಲಿ ಅಲ್ಲಿ ಬಳಕೆದಾರ ರೀತಿಯ

29
00:01:16,900 --> 00:01:19,710
ನಾವು ಹೆಚ್ಚು ಪಾತ್ರಗಳು
ಆರಂಭದಲ್ಲಿ ನಿರೀಕ್ಷಿಸಿದ್ದಕ್ಕಿಂತ.

30
00:01:19,710 --> 00:01:21,750
>> ನಾನೂ, ಇಲ್ಲದೆ ಸಂಪೂರ್ಣವಾಗಿ
ಈ ಪ್ರೋಗ್ರಾಂ ಪುನಃ,

31
00:01:21,750 --> 00:01:23,290
ಯಾವುದೇ ಕ್ಲೀನ್ ಪರಿಹಾರ ಇಲ್ಲ.

32
00:01:23,290 --> 00:01:26,970
ಬದಲಿಗೆ, ನಾವು ಮಾಡಬೇಕು ಎಂದು ಪಡೆಯುವುದು
ಒಂದು ಬಳಕೆದಾರ ಒಂದು ಪಾತ್ರ

33
00:01:26,970 --> 00:01:28,860
ಸಮಯ, ಮತ್ತೆ ಮತ್ತೆ.

34
00:01:28,860 --> 00:01:32,510
ಮತ್ತು ಪ್ರತಿ ಹಂತದಲ್ಲಿ ನಾವು ಆರ್ ಅರ್ಥ
ಮೆಮೊರಿ ಹೊರಗೆ, ನಾವು ಎಂದು

35
00:01:32,510 --> 00:01:36,450
ಆ ಹಿಂದಕ್ಕೆ ಹೋಗಿ ಪುನರ್ವಿಂಗಡಿಸು
ಕೆಲವು ಹೆಚ್ಚು ಮೆಮೊರಿ, ಬಳಕೆದಾರರ ನಕಲಿಸಿ

36
00:01:36,450 --> 00:01:39,400
ನಮ್ಮ ಮೊದಲ ಪಡೆ ನಿಂದ ಹಿಂದಿನ ಇನ್ಪುಟ್
ಹೊಸ ಒಳಗೆ ಮೆಮೊರಿ,

37
00:01:39,400 --> 00:01:40,810
ಮೆಮೊರಿ ದೊಡ್ಡ ಪಡೆ.

38
00:01:40,810 --> 00:01:44,610
ತದನಂತರ ಮತ್ತೆ ಆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪುನರಾವರ್ತಿಸುವಂತೆ ಮತ್ತು
ಬಳಕೆದಾರ ಒದಗಿಸುವ ಮಾಡಲಾಗುತ್ತದೆ ಮತ್ತೆ ರವರೆಗೆ

39
00:01:44,610 --> 00:01:45,860
ತನ್ನ ಇನ್ಪುಟ್.

40
00:01:45,860 --> 00:01:48,246