1
00:00:00,000 --> 00:00:02,700
[Powered by Google Translate] [ದರ್ಶನ - ಸಮಸ್ಯೆ ಸೆಟ್ 4]

2
00:00:02,700 --> 00:00:05,000
[Zamyla ಚಾನ್ - ಹಾರ್ವರ್ಡ್ ವಿಶ್ವವಿದ್ಯಾಲಯ]

3
00:00:05,000 --> 00:00:07,340
[ಈ CS50 ಹೊಂದಿದೆ. - CS50.TV]

4
00:00:08,210 --> 00:00:11,670
ಎಲ್ಲಾ ಸರಿ. ಹಲೋ, ಎಲ್ಲರೂ, ಮತ್ತು ದರ್ಶನ 4 ಸ್ವಾಗತ.

5
00:00:11,670 --> 00:00:14,270
>> ಇಂದು ನಮ್ಮ pset ಫೊರೆನ್ಸಿಕ್ಸ್ ಹೊಂದಿದೆ.

6
00:00:14,270 --> 00:00:18,080
ಫೊರೆನ್ಸಿಕ್ಸ್ ಬಿಟ್ಮ್ಯಾಪ್ ಕಡತಗಳನ್ನು ವ್ಯವಹರಿಸುವಾಗ ಒಳಗೊಂಡಿರುತ್ತದೆ ನಿಜವಾಗಿಯೂ ಮೋಜಿನ pset ಆಗಿದೆ

7
00:00:18,080 --> 00:00:21,550
ಒಂದು ಅಪರಾಧ ಎಂದು ಕಂಡುಹಿಡಿಯುವ.

8
00:00:21,550 --> 00:00:24,200
ಆಗ, ಕೆಲವು ಬಿಟ್ಮ್ಯಾಪ್ ಕಡತಗಳನ್ನು ಮರುಗಾತ್ರಗೊಳಿಸಲು ನೀನು

9
00:00:24,200 --> 00:00:27,780
ನಂತರ ನಾವು, ಕೊಡು ಎಂಬ ನಿಜವಾಗಿಯೂ ಮೋಜಿನ ಭಾಗವಾಗಿ ವ್ಯವಹರಿಸಲು ನೀನು

10
00:00:27,780 --> 00:00:31,160
ಇದರಲ್ಲಿ ನಾವು ಮೂಲಭೂತವಾಗಿ ಒಂದು ಮೆಮೊರಿ ಕಾರ್ಡ್ ಹ್ಯಾಂಡೆಡ್ ನೀವು

11
00:00:31,160 --> 00:00:34,350
ಇದರಲ್ಲಿ ಯಾರಾದರೂ ಆಕಸ್ಮಿಕವಾಗಿ ತಮ್ಮ ಕಡತಗಳನ್ನು ಎಲ್ಲಾ ಅಳಿಸಿದ್ದಾರೆ,

12
00:00:34,350 --> 00:00:38,860
ಮತ್ತು ನಾವು ಆ ಕಡತಗಳನ್ನು ಚೇತರಿಸಿಕೊಳ್ಳಲು ಕೇಳಿದಾಗ ನೀವು.

13
00:00:38,860 --> 00:00:42,910
>> ನಾವು pset ಬರಲು ಮೊದಲು ಆದರೆ ಮೊದಲು, ನಾನು ಕೇವಲ ಎಲ್ಲರೂ ಅಭಿನಂದಿಸುತ್ತೇನೆ ಬಯಸುವ.

14
00:00:42,910 --> 00:00:45,230
ಈ ಕೋರ್ಸ್ ಕೇಂದ್ರ ಬಿಂದುವಾಗಿ ಬಗ್ಗೆ ಆರ್.

15
00:00:45,230 --> 00:00:50,070
ರಸಪ್ರಶ್ನೆ 0 ನಮಗೆ ಹಿಂದೆ, ಮತ್ತು ನಾವು ಅರ್ಧದಾರಿಯಲ್ಲೇ ಆರ್, ಆದ್ದರಿಂದ ಮೂಲಭೂತವಾಗಿ, pset4 ನಲ್ಲಿ ಆರ್.

16
00:00:50,070 --> 00:00:55,490
ನಿಮ್ಮ psets, pset0 ಮತ್ತು pset1 ಮತ್ತೆ ನೋಡಲು ನಾವು, ಒಂದು ದೀರ್ಘ ಎಲ್ಲರೂ ನಾವು

17
00:00:55,490 --> 00:00:57,300
ಆದ್ದರಿಂದ, ಆ ಬಗ್ಗೆ ನಿಮ್ಮನ್ನು ಅಭಿನಂದಿಸುತ್ತೇನೆ

18
00:00:57,300 --> 00:01:00,760
ಮತ್ತು ನಾವು ಕೆಲವು ನಿಜವಾಗಿಯೂ ತಮಾಷೆಯ ಸಂಗತಿಗಳನ್ನು ಬರಲು ನೀನು.

19
00:01:00,760 --> 00:01:07,070
>> ಆದ್ದರಿಂದ ಈ pset ನಮ್ಮ ಉಪಕರಣ, ಮತ್ತೆ, ಬದಲಿಗೆ sudo yum-ವೈ ಅಪ್ಡೇಟ್ ಚಲಾಯಿಸುವ,

20
00:01:07,070 --> 00:01:13,890
ನೀವು ಮೇಲೆ APPLIANCE ಆವೃತ್ತಿ 17.3 ಮತ್ತು ಇಂತಹ ನಾವು update50 ಚಲಿಸಬಹುದು ಆರ್.

21
00:01:13,890 --> 00:01:17,380
ಆದ್ದರಿಂದ update50 ರನ್ ಮರೆಯಬೇಡಿ - ಇದು ಕೆಲವು ಕಡಿಮೆ ಅಕ್ಷರಗಳು, ಸಾಕಷ್ಟು ಸುಲಭ -

22
00:01:17,380 --> 00:01:20,640
ನೀವು APPLIANCE ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಯನ್ನು ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

23
00:01:20,640 --> 00:01:25,410
ನಾವು CS50 ಚೆಕ್ ಬಳಸಿಕೊಂಡು ಪ್ರಾರಂಭಿಸಿದಾಗ ವಿಶೇಷವಾಗಿ update50 ಮುಖ್ಯವಾಗಿರುತ್ತದೆ.

24
00:01:25,410 --> 00:01:28,700
ನೀವು ಹಾಗೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

25
00:01:28,700 --> 00:01:30,760
>> ಈ pset ವಿಭಾಗದಲ್ಲಿ ಎಲ್ಲಾ,

26
00:01:30,760 --> 00:01:34,350
ನಾವು ಫೈಲ್ ಆದಾನಗಳು ಮತ್ತು ವ್ಯವಹರಿಸುತ್ತದೆ ಎಂದು ನೀನು, ಫೈಲ್ ಐ / ಒ

27
00:01:34,350 --> 00:01:38,140
ನಾವು ಸರಣಿಗಳ ವ್ಯವಹರಿಸಲು ಕಾರ್ಯಸೂಚಿಗಳನ್ನು ಸಾಕಷ್ಟು ಹೋಗುವಾಗ ಎಂದು ನೀನು

28
00:01:38,140 --> 00:01:40,350
ಕಡತಗಳನ್ನು ಮತ್ತು ವಿಷಯಗಳನ್ನು ಸೂಚಿಸುವ,

29
00:01:40,350 --> 00:01:43,050
ಆದ್ದರಿಂದ ನಾವು ನಿಜವಾಗಿಯೂ ಪರಿಚಿತ ಮತ್ತು ಆರಾಮದಾಯಕ ಎಂಬುದನ್ನು ಖಾತ್ರಿಪಡಿಸಲು ಬಯಸುವ

30
00:01:43,050 --> 00:01:47,990
ಹೇಗೆ ಕಡತಗಳು ಇನ್ಪುಟ್ ಮತ್ತು ಔಟ್ಪುಟ್ ಮಾಡಲು ವ್ಯವಹರಿಸುತ್ತದೆ.

31
00:01:47,990 --> 00:01:52,080
>> ಈ pset ಹಂಚಿಕೆಗಾಗಿ ಕೋಡ್ copy.c ಎಂಬ ಫೈಲ್ ಆಗಿದೆ

32
00:01:52,080 --> 00:01:55,280
ಮತ್ತು ನಮಗೆ ನಿಜವಾಗಿಯೂ ಉಪಯುಕ್ತ ಎಂದು ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂದು ನಾವು ಹೇಗೆ ನೀನು ನ

33
00:01:55,280 --> 00:02:00,340
ನಾವು ಅಂತ್ಯಗೊಳ್ಳುತ್ತಿತ್ತು ನೀನು ಏಕೆಂದರೆ ವಾಸ್ತವವಾಗಿ copy.c ಫೈಲ್ ನಕಲು

34
00:02:00,340 --> 00:02:05,350
ಮತ್ತು ಕೇವಲ ಸ್ವಲ್ಪ ಸಮಸ್ಯೆ ಸೆಟ್ ಮೊದಲ 2 ಭಾಗಗಳು ಸಾಧಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ಅದನ್ನು ಬದಲಿಸಿಬಿಡುತ್ತದೆ.

35
00:02:05,350 --> 00:02:09,030
>> ನಾನು ಮೊದಲೇ ಹೇಳಿದಂತೆ ಮತ್ತು ಆದ್ದರಿಂದ, ನಾವು ಬಿಟ್ಮ್ಯಾಪ್ಗಳನ್ನು ಹಾಗೆಯೇ JPEGs ವ್ಯವಹರಿಸುತ್ತದೆ.

36
00:02:09,030 --> 00:02:13,170
ಆದ್ದರಿಂದ ನಿಜವಾಗಿಯೂ, ಆ ಕಡತಗಳನ್ನು ಆಯೋಜಿಸಲಾಗಿದೆ ಹೇಗೆ ವಿನ್ಯಾಸವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ

37
00:02:13,170 --> 00:02:16,170
ನಾವು ನಿಜವಾಗಿಯೂ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಆಗಿ 0 ಸೆ ಮತ್ತು 1 ಭಾಷಾಂತರಿಸಿ ಹೇಗೆ

38
00:02:16,170 --> 00:02:19,040
ಮತ್ತು ನಾವು ನಿಜವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮತ್ತು ಸಂಪಾದಿಸಬಹುದು ವಸ್ತುಗಳನ್ನು,

39
00:02:19,040 --> 00:02:21,000
ಎಂದು, ನಿಜವಾಗಿಯೂ ಪ್ರಮುಖವಾದದ್ದು

40
00:02:21,000 --> 00:02:25,970
ಆದ್ದರಿಂದ JPEG ಮತ್ತು ಬಿಟ್ಮ್ಯಾಪ್ ಕಡತಗಳನ್ನು ಹೋಗುವುದನ್ನು ಮತ್ತು ಆ ರಚನೆಯ ಅರ್ಥ.

41
00:02:25,970 --> 00:02:30,780
>> Pset4, ಎಂದಿನಂತೆ, ಪ್ರಶ್ನೆಗಳನ್ನು ಒಂದು ವಿಭಾಗ ಆರಂಭವಾಗುತ್ತದೆ.

42
00:02:30,780 --> 00:02:36,600
ಆ ಫೈಲ್ I / O ವ್ಯವಹರಿಸುವ ಮತ್ತು ಆ ಒಗ್ಗಿಕೊಂಡಿರಲಿಲ್ಲವಾದ್ದರಿಂದ ಪಡೆಯುತ್ತಾನೆ.

43
00:02:36,600 --> 00:02:42,520
ನಂತರ ಭಾಗ 1 ನೀವು ಬಿಟ್ಮ್ಯಾಪ್ ಕಡತ ನೀಡಿದ ನೀವು ಇದರಲ್ಲಿ, ವೊಡುನಿಟ್ ಆಗಿದೆ

44
00:02:42,520 --> 00:02:45,630
ಎಲ್ಲಾ ಮೇಲೆ ಕೆಂಪು ಚುಕ್ಕೆಗಳು ರೀತಿಯ ರೀತಿಯ ಕಾಣುತ್ತದೆ.

45
00:02:45,630 --> 00:02:52,180
ತದನಂತರ ಮೂಲತಃ ನಾವು ಹೋಗುವ ಏನನ್ನು ಈ ಫೈಲ್ ತೆಗೆದುಕೊಂಡು ಸ್ವಲ್ಪ ಅದನ್ನು ಸಂಪಾದಿಸಲು

46
00:02:52,180 --> 00:02:54,010
ನಾವು ಓದಬಹುದು ರೂಪಾಂತರವಾಗಿ.

47
00:02:54,010 --> 00:02:56,000
ಮೂಲಭೂತವಾಗಿ, ಒಮ್ಮೆ ನಾವು ಒಂದೇ ಕಡತದಲ್ಲಿ ಸಾಧ್ಯವಿದೆ, ಪೂರ್ಣಗೊಳಿಸಲು

48
00:02:56,000 --> 00:03:02,630
ಹೊರತುಪಡಿಸಿ ನಾವು ಎಲ್ಲಾ ಕೆಂಪು ಚುಕ್ಕೆಗಳು ಅಡಗಿಸಿಟ್ಟಿತ್ತು ಗುಪ್ತ ಸಂದೇಶ ನೋಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.

49
00:03:02,630 --> 00:03:07,310
ನಂತರ ಗಣಕತೆರೆ ಫೈಲ್ ನೀಡಿದ, ಒಂದು ಕಾರ್ಯಕ್ರಮ

50
00:03:07,310 --> 00:03:11,490
ಮತ್ತು ಅದು ಹೊರತರುವ ಆ ಕಡತದ ಹೆಸರನ್ನು ನಂತರ, ಜೊತೆಗೆ ಕೊಟ್ಟಿದೆ

51
00:03:11,490 --> 00:03:16,850
ವಾಸ್ತವವಾಗಿ ಆ ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯ ಆ ಬಿಟ್ಮ್ಯಾಪ್ ಗಾತ್ರ ಬದಲಾವಣೆ ಕಾಣಿಸುತ್ತದೆ.

52
00:03:16,850 --> 00:03:19,240
ನಂತರ ಕೊನೆಯದಾಗಿ, ನಾವು ಚೇತರಿಸಿಕೊಳ್ಳಲು pset ಹೊಂದಿರುತ್ತವೆ.

53
00:03:19,240 --> 00:03:24,160
ನಾವು ಒಂದು ಮೆಮೊರಿ ಕಾರ್ಡ್ ನೀಡಿದ ನಂತರ ಫೋಟೋಗಳನ್ನು ಎಲ್ಲಾ ಚೇತರಿಸಿಕೊಳ್ಳಲು ಹೊಂದಿವೆ

54
00:03:24,160 --> 00:03:25,920
ಆಕಸ್ಮಿಕವಾಗಿ ಅಳಿಸಲಾಗಿದೆ ಎಂದು,

55
00:03:25,920 --> 00:03:31,420
ನಾವು ಕಲಿಯೋಣ ಆದರೆ, ವಾಸ್ತವವಾಗಿ ಅಳಿಸಲಾಗಿದೆ ಮತ್ತು ಕಡತವನ್ನು ತೆಗೆದು ಅಲ್ಲ;

56
00:03:31,420 --> 00:03:38,470
ಅವರು ಫೈಲ್ ಸಂದರ್ಭದಲ್ಲಿ ಆಫ್ ನಾವು ರೀತಿಯ ಸೋತರು, ಆದರೆ ನಾವು ಚೇತರಿಸಿಕೊಳ್ಳಲು ನೀನು.

57
00:03:38,470 --> 00:03:44,950
>> ಗ್ರೇಟ್. ಆದ್ದರಿಂದ ನೀವು ಬಳಸುತ್ತಿರುವ ನಾವು ಕಾರ್ಯಗಳ ಒಂದು ಸಂಪೂರ್ಣ ಪಟ್ಟಿಯನ್ನು I / O ನಿರ್ದಿಷ್ಟವಾಗಿ, ಈ ಮಾಡುತ್ತಿರುವ ಫೈಲ್ ಸಾಗುವ.

58
00:03:44,950 --> 00:03:49,840
ನೀವು ಈಗಾಗಲೇ ಸ್ವಲ್ಪ fopen ಮೂಲಭೂತ, fread, ಮತ್ತು fwrite, ನೋಡಬಹುದು

59
00:03:49,840 --> 00:03:54,350
ಆದರೆ ಕೆಲವು ಫೈಲ್ ಮತ್ತಷ್ಟು ನೋಡಲು ನೀನು ನಾನು / ಉದಾಹರಣೆಗೆ fputc ಮಾಹಿತಿ ಒ ಕಾರ್ಯಗಳನ್ನು

60
00:03:54,350 --> 00:03:56,930
ಇದರಲ್ಲಿ ನೀವು, ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಅಕ್ಷರವನ್ನು ಬರೆಯಲು

61
00:03:56,930 --> 00:04:02,000
ಅಲ್ಲಿ ನೀವು ರೀತಿಯ ಫಾರ್ವರ್ಡ್ಗಳು ಮತ್ತು ಹಿಂದಕ್ಕೆ ಕಡತ ಸ್ಥಾನವನ್ನು ಸೂಚಕ ಸಾಗುತ್ತಿರುವಂತೆ, fseek, ಗೆ

62
00:04:02,000 --> 00:04:05,770
ನಂತರ ಕೆಲವರು. ಆದರೆ ನಾವು pset ಸಮಯದಲ್ಲಿ ಸ್ವಲ್ಪ ನಂತರ ಆಗಿ ಹೋಗುತ್ತೇನೆ.

63
00:04:08,050 --> 00:04:13,100
>> ಮೊದಲು, ಕೇವಲ ಕಡತ ಬರಲು I / O ನಾವು pset ಹೋಗಿ ಮೊದಲು,

64
00:04:13,100 --> 00:04:19,860
ಒಂದು ಕಡತವನ್ನು ತೆರೆಯಲು, ಉದಾಹರಣೆಗೆ, ಏನು ಮಾಡಬೇಕು ವಾಸ್ತವವಾಗಿ ಆ ಕಡತಕ್ಕೆ ಒಂದು ಪಾಯಿಂಟರ್ ಹೊಂದಿಸಲಾಗಿದೆ.

65
00:04:19,860 --> 00:04:22,710
ನಾವು ಫೈಲ್ * ಪಾಯಿಂಟರ್ ಹೊಂದಿರುತ್ತವೆ.

66
00:04:22,710 --> 00:04:27,140
ನನ್ನ infile ಎಂದು ವಿಶೇಷವೇನು ಏಕೆಂದರೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾನು ಪಾಯಿಂಟರ್ ಒಂದು ಕರೆ ನುಡಿದರು.

67
00:04:27,140 --> 00:04:33,340
ಮತ್ತು ಆದ್ದರಿಂದ ನಾನು ಕಾರ್ಯ fopen ತದನಂತರ ಫೈಲ್ ಹೆಸರನ್ನು ಬಳಸಲು ಪಡೆಯಲಿದ್ದೇನೆ

68
00:04:33,340 --> 00:04:36,360
ತದನಂತರ ನಾನು ಹೋಗುತ್ತಿರುವೆ ಇದರಲ್ಲಿ ಮೋಡ್ ಕಡತ ವ್ಯವಹರಿಸುವಾಗ ಎಂದು.

69
00:04:36,360 --> 00:04:42,080
ಆದ್ದರಿಂದ ಓದಲು ಈ ಸಂದರ್ಭದಲ್ಲಿ "R", ಬರವಣಿಗೆಗೆ "W", ಮತ್ತು ನಂತರ ಸೇರಿಸುವುದರಿಂದ ಫಾರ್ "ಒಂದು" ಇಲ್ಲ.

70
00:04:42,080 --> 00:04:44,270
ಉದಾಹರಣೆಗೆ, ನೀವು ಒಂದು infile ಮಾತಾಡುತ್ತಿದ್ದೀರಿ

71
00:04:44,270 --> 00:04:47,310
ಮತ್ತು ನೀವು ಬಯಸುವ ಎಲ್ಲಾ, ಅಲ್ಲಿ ಸಂಗ್ರಹಿಸಿರುವ ಬಿಟ್ಗಳು ಮತ್ತು ಬೈಟ್ಗಳು ಓದಲು

72
00:04:47,310 --> 00:04:50,420
ನಂತರ ನೀವು ಬಹುಶಃ ನಿಮ್ಮ ಮೋಡ್ ಎಂದು "R" ಬಳಸಬೇಕಿರುವ ಎಂದು ನೀನು.

73
00:04:50,420 --> 00:04:54,520
ನೀವು ನಿಜವಾಗಿ ಬರೆಯಲು ಬಯಸಿದಾಗ, ರೀತಿಯ ಒಂದು ಹೊಸ ಫೈಲ್ ಮಾಡಲು,

74
00:04:54,520 --> 00:04:57,220
ನಂತರ ನಾವು ಮಾಡಲು ನೀನು ನಾವು ಹೊಸ ಕಡತವನ್ನು ತೆರೆಯಲು ನೀನು ಆಗಿದೆ

75
00:04:57,220 --> 00:05:02,410
ಮತ್ತು ಬರೆಯಲು "W" ಮೋಡ್ ಬಳಸಿ.

76
00:05:02,410 --> 00:05:07,540
>> ಆದ್ದರಿಂದ ನೀವು ನಿಜವಾಗಿಯೂ ಕಡತಗಳು ಓದುವ ಮಾಡಿದಾಗ, ರಚನೆ ಹೀಗಿದೆ.

77
00:05:07,540 --> 00:05:14,930
ಮೊದಲ ನೀವು ಓದುವ ನೀವು ಬೈಟ್ಗಳು ಹೊಂದಿರುವ struct ಸೂಚಕವನ್ನು ಸೇರಿವೆ.

78
00:05:14,930 --> 00:05:19,830
ಆದ್ದರಿಂದ ನೀವು ಓದುವ ನೀವು ಬೈಟ್ಗಳು ಕೊನೆಯಲ್ಲಿ ಸ್ಥಳ ಎಂದು ವಿಶೇಷವೇನು.

79
00:05:19,830 --> 00:05:23,360
ನೀವು ನಂತರ ಗಾತ್ರವನ್ನು ಸೂಚಿಸಲು ನೀನು, ಇಷ್ಟ ಮೂಲತಃ ಎಷ್ಟು ಬೈಟ್ಗಳು

80
00:05:23,360 --> 00:05:30,100
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಫೈಲ್ ಗೆ ಓದಲು ಹೊಂದಿದೆ, ಗಾತ್ರ ಮೂಲತಃ ಒಂದು ಅಂಶ, ಇದು

81
00:05:30,100 --> 00:05:32,620
ತದನಂತರ ನೀವು ಓದಲು ಬಯಸುವ ಎಷ್ಟು ಅಂಶಗಳನ್ನು ಸೂಚಿಸಲು ನೀನು.

82
00:05:32,620 --> 00:05:34,980
ತದನಂತರ ಅಂತಿಮವಾಗಿ, ನೀವು, ನೀವು ಓದುವ ನೀವು ಅಲ್ಲಿ ಗೊತ್ತಿರಬೇಕಾಗುತ್ತದೆ

83
00:05:34,980 --> 00:05:37,580
ಆದ್ದರಿಂದ ನಿಮ್ಮ ಪಾಯಿಂಟರ್ ಎಂದು ವಿಶೇಷವೇನು.

84
00:05:37,580 --> 00:05:41,780
Fread ಸಹ fwrite ಹೋಲುತ್ತದೆ, ಏಕೆಂದರೆ ನಾನು ಈ ಬಣ್ಣ ಕೋಡೆಡ್

85
00:05:41,780 --> 00:05:47,050
ನೀವು ಸರಿಯಾದ ಬಳಸುವ ಖಾತ್ರಿಪಡಿಸಿಕೊಳ್ಳಬೇಕಾಗಿದೆ ಹೊರತುಪಡಿಸಿ,

86
00:05:47,050 --> 00:05:51,960
ನೀವು ನಿಜವಾಗಿ ಬರೆಯಲು ಅಥವಾ ಬಲ ಕಡತದಿಂದ ಓದುವಲ್ಲಿ ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

87
00:05:54,910 --> 00:05:58,610
>> ಆದ್ದರಿಂದ ಎಂದು ಮೊದಲು, ನಾವು ಅಂಶ ಗಾತ್ರವನ್ನು ಹಾಗೆಯೇ ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹೊಂದಿದ್ದರೆ,

88
00:05:58,610 --> 00:06:00,600
ನಾವು ಇಲ್ಲಿ ಸ್ವಲ್ಪ ಸುಮಾರು ವಹಿಸುತ್ತದೆ.

89
00:06:00,600 --> 00:06:06,810
ನಾನು ನಾಯಿ struct ಮತ್ತು ಆದ್ದರಿಂದ ನಾನು ಆ ಸಮಯದಲ್ಲಿ ಎರಡು ನಾಯಿಗಳು ಓದಲು ಬಯಸುವ ಸೇ.

90
00:06:06,810 --> 00:06:12,450
ನಾನು ಹಾಗೆ ಮಾಡಲು ಒಂದು ಅಂಶ ಗಾತ್ರವನ್ನು ಹೇಳಲು ಒಂದು ನಾಯಿಯ ಗಾತ್ರ ಏರಲಿದೆ

91
00:06:12,450 --> 00:06:14,770
ನಾನು ನಿಜವಾಗಿಯೂ ಎರಡು ಓದಲು ಪಡೆಯಲಿದ್ದೇನೆ.

92
00:06:14,770 --> 00:06:18,290
ಪರ್ಯಾಯವಾಗಿ, ಏನು ನಾನು ಎಂದು ನಾನು ಒಂದು ಅಂಶ ಓದಲು ಪಡೆಯಲಿದ್ದೇನೆ ಹೇಳಲು ಇದೆ

93
00:06:18,290 --> 00:06:21,340
ಮತ್ತು ಒಂದು ಅಂಶ ಎರಡು ನಾಯಿಗಳು ಗಾತ್ರವನ್ನು ಎಂದು ಹೋಗುತ್ತದೆ ಎಂದು.

94
00:06:21,340 --> 00:06:24,320
ಆದ್ದರಿಂದ ಹೋಲುತ್ತದೆ ಹವ್ ಯು ಗಾತ್ರ ಮತ್ತು ಸಂಖ್ಯೆಯ ಸುಮಾರು ಆಟದ ರೀತಿಯ ಮಾಡಬಹುದು

95
00:06:24,320 --> 00:06:28,250
ನಿಮಗೆ ಮತ್ತಷ್ಟು ಗ್ರಹಿಸುವಂತೆ ಎಂಬುದನ್ನು ಅವಲಂಬಿಸಿ.

96
00:06:28,250 --> 00:06:30,810
>> ಎಲ್ಲಾ ಸರಿ. ಈಗ ನಾವು ಬರೆಯುವ ಕಡತಗಳನ್ನು ಪಡೆಯುವುದು.

97
00:06:30,810 --> 00:06:36,880
ನೀವು ಓದುವ ನೀವು ಅಲ್ಲಿ ನೀವು ಕಡತವನ್ನು ಬರೆಯಲು ಬಯಸಿದಾಗ, ಮೊದಲ ವಾದವು ವಾಸ್ತವವಾಗಿ.

98
00:06:36,880 --> 00:06:42,050
ಆದ್ದರಿಂದ, ನೀವು ಫೈಲ್ ಆಗಿ ಬರೆಯಲು ಹೋಗುವ ಮೂಲಭೂತ ಮಾಹಿತಿ ಇಲ್ಲಿದೆ

99
00:06:42,050 --> 00:06:44,490
ಕೊನೆಯಲ್ಲಿ ಔಟ್ ಪಾಯಿಂಟರ್ ಇದು.

100
00:06:44,490 --> 00:06:47,670
ಆದ್ದರಿಂದ ನೀವು pset ವ್ಯವಹರಿಸುವಾಗ ಮಾಡಿದಾಗ, ನೀವು ತಪ್ಪಾಗಿ ಖಾತ್ರಿಪಡಿಸಿಕೊಳ್ಳಿ.

101
00:06:47,670 --> 00:06:50,480
ಬಹುಶಃ ಪಕ್ಕದ ವ್ಯಾಖ್ಯಾನಗಳು ಅಡ್ಡ ಹೊಂದಿರುತ್ತವೆ.

102
00:06:50,480 --> 00:06:58,090
ನೀವು, ಉದಾಹರಣೆಗೆ, ಮನುಷ್ಯನನ್ನು ನಮೂದಿಸುವ ಮೂಲಕ ಕೈಪಿಡಿಯಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಗಳು ಮೇಲೆಳೆದುಕೊಳ್ಳಲು ತದನಂತರ fwrite ಮಾಡಬಹುದು

103
00:06:58,090 --> 00:06:59,950
ಟರ್ಮಿನಲ್ ನಲ್ಲಿ, ಅಥವಾ ಈ ಸ್ಲೈಡ್ ಮರಳಿ ಉಲ್ಲೇಖಿಸಬಹುದು

104
00:06:59,950 --> 00:07:03,570
ಮತ್ತು ನೀವು ಸರಿಯಾದ ಒಂದು ಬಳಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

105
00:07:03,570 --> 00:07:08,700
ಆದ್ದರಿಂದ ಮತ್ತೆ, fwrite, ನೀವು ಒಂದು ಕಡತವನ್ನು ಹೊಂದಿರುವ ನೀವು, ಆಗಿ ಬರೆಯಲು ಬಯಸುವ

106
00:07:08,700 --> 00:07:14,290
ಕಳೆದ ವಾದವು ಎಂದು ವಿಶೇಷವೇನು ಮತ್ತು ಆ ಕಡತ ಒಂದು ಪಾಯಿಂಟರ್ ಎಂದು ವಿಶೇಷವೇನು.

107
00:07:14,290 --> 00:07:18,670
ಆದ್ದರಿಂದ, ನಾವು ಒಂದು ಸಮಯದಲ್ಲಿ ಬಹುಶಃ ಅನೇಕ ಬೈಟ್ಗಳು ಬರೆಯುವ ವ್ಯವಹರಿಸಲು ಹೇಗೆ

108
00:07:18,670 --> 00:07:21,820
ಆದರೆ ನೀವು ಕೇವಲ ಒಂದೇ ಅಕ್ಷರದಲ್ಲಿ ಬರೆಯಲು ಬಯಸುವ ಹೇಳುತ್ತಾರೆ.

109
00:07:21,820 --> 00:07:25,940
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ ನಂತರ ನೋಡುತ್ತಾರೆ ಎಂದು, ಬಿಟ್ಮ್ಯಾಪ್ಗಳನ್ನು ರಲ್ಲಿ ನಾವು ಬಳಸಲು ಸಾಧ್ಯವಿದೆ.

110
00:07:25,940 --> 00:07:32,180
ನಾವು fputc ಬಳಸಬಹುದು ಆ ಸ್, ಮೂಲಭೂತವಾಗಿ ಕೇವಲ chr, ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಅಕ್ಷರವನ್ನಾದರೂ ಪುಟ್ಟಿಂಗ್

111
00:07:32,180 --> 00:07:37,050
ಅಲ್ಲಿ ಫೈಲ್ ಪಾಯಿಂಟರ್ ಆಗಿ, ಮತ್ತು ನಮ್ಮ ಔಟ್ ಪಾಯಿಂಟರ್.

112
00:07:38,700 --> 00:07:41,560
ಆದ್ದರಿಂದ ನಾವು, ಹುಡುಕುವುದು ಅಥವಾ ಒಂದು ಕಡತದಲ್ಲಿ ಬರೆಯಲು ಬಂದಾಗಲೆಲ್ಲಾ

113
00:07:41,560 --> 00:07:44,690
ಫೈಲ್ ನಾವು ಅಲ್ಲಿ ಗಮನವಿಡುತ್ತಾ ಇದೆ.

114
00:07:44,690 --> 00:07:47,810
ಆದ್ದರಿಂದ ಕರ್ಸರ್, ಕಡತ ಸ್ಥಾನವನ್ನು ಸೂಚಕ ಒಂದು ರೀತಿಯ ಇಲ್ಲಿದೆ.

115
00:07:47,810 --> 00:07:54,330
ಮತ್ತು, ಆದ್ದರಿಂದ ನಾವು ಬರೆಯಲು ಮಾಡುವಾಗ ಅಥವಾ ಫೈಲ್ ಆಗಿ ಮತ್ತೆ ಓದಲು

116
00:07:54,330 --> 00:07:56,760
ಅದು ಅಲ್ಲಿ ಫೈಲ್ ವಾಸ್ತವವಾಗಿ, ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತಾರೆ

117
00:07:56,760 --> 00:07:59,270
ಮತ್ತು ಆದ್ದರಿಂದ ಕರ್ಸರ್ ಸ್ಥಳದಿಂದ ಮುಂದುವರೆಯುತ್ತದೆ.

118
00:07:59,270 --> 00:08:03,970
ನೀವು ಬಯಸುವ ಈ ಏನಾದರೂ ಒಂದು ನಿರ್ದಿಷ್ಟ ಪ್ರಮಾಣದ ಓದಲು, ಹೇಳುತ್ತಾರೆ, ಲಾಭಕರವಾಗಿರುತ್ತದೆ

119
00:08:03,970 --> 00:08:06,160
ನಂತರ, ಈ ಪ್ರಮಾಣವನ್ನು ಓದಲು

120
00:08:06,160 --> 00:08:10,700
ಆದರೆ ಕೆಲವೊಮ್ಮೆ ನಾವು ಒಂದು ನಿರ್ದಿಷ್ಟ ಉಲ್ಲೇಖ ಮೌಲ್ಯವನ್ನು ಆರಂಭವಾಗುತ್ತವೆ ಹಿಂದಕ್ಕೆ ಅಥವಾ ವಾಸ್ತವವಾಗಿ ಹೋಗಿ ಬಯಸಬಹುದು.

121
00:08:10,700 --> 00:08:16,870
ಆದ್ದರಿಂದ fseek ಕಾರ್ಯ, ಅದು ಏನು ಮಾಡುತ್ತದೆ ನಮಗೆ ಕೆಲವು ಕಡತದಲ್ಲಿ ಕರ್ಸರ್ ಸರಿಸು ಅನುಮತಿಸುತ್ತದೆ

122
00:08:16,870 --> 00:08:19,680
ಬೈಟ್ಗಳು ಒಂದು ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆ.

123
00:08:19,680 --> 00:08:24,260
ನಂತರ ನಾವು ಮಾಡಬೇಕು ಉಲ್ಲೇಖ ಮೌಲ್ಯವಾಗಿರುತ್ತದೆ ಅಲ್ಲಿ ಸೂಚಿಸಿ ಆಗಿದೆ.

124
00:08:24,260 --> 00:08:31,520
ಆದ್ದರಿಂದ ಅದನ್ನು, ತೆರೆಸೂಚಕವು ಪ್ರಸ್ತುತ ಅಲ್ಲಿ ರಿಂದ ಮುಂದಕ್ಕೆ ಅಥವಾ ಹಿಂದಕ್ಕೆ ಚಲಿಸುತ್ತದೆ

125
00:08:31,520 --> 00:08:35,750
ಅಥವಾ ನಾವು ಕೇವಲ ಕಡತ ಆರಂಭದಿಂದಲೂ ಚಲಿಸುತ್ತವೆ ಎಂದು ಸೂಚಿಸಬಹುದು

126
00:08:35,750 --> 00:08:37,090
ಅಥವಾ ಕಡತದ ತುದಿಯಿಂದ.

127
00:08:37,090 --> 00:08:41,230
ಆದ್ದರಿಂದ ನೀವು ಪ್ರಮಾಣದ ಋಣಾತ್ಮಕ ಅಥವಾ ಧನಾತ್ಮಕ ಮೌಲ್ಯಗಳನ್ನು ಹಸ್ತಾಂತರಿಸುತ್ತಾನೆ

128
00:08:41,230 --> 00:08:44,960
ಮತ್ತು ಆ ರೀತಿಯ ಎರಡೂ ಮುಂದಕ್ಕೆ ಅಥವಾ ಹಿಂದಕ್ಕೆ ಕರ್ಸರ್ ಸರಿಸು ಕಾಣಿಸುತ್ತದೆ.

129
00:08:46,170 --> 00:08:51,920
>> ನಾವು ಇತರ psets ಬರಲು ಮೊದಲು ಫೈಲ್ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳನ್ನು ನಾನು / ಓ?

130
00:08:53,860 --> 00:08:59,990
ಸರಿ. ನಾವು ಹೆಚ್ಚು ಉದಾಹರಣೆಗಳು ಬರಲು ಮಾಹಿತಿ, ಪ್ರಶ್ನೆಗಳನ್ನು ನನಗೆ ನಿಲ್ಲಿಸಲು ಹಿಂಜರಿಯಬೇಡಿ.

131
00:08:59,990 --> 00:09:06,930
>> ಆದ್ದರಿಂದ ವೊಡುನಿಟ್ ರಲ್ಲಿ, ನೀವು ಸ್ಲೈಡ್ ಈ ಕೆಂಪು ರೀತಿಯದೇ ಒಂದು ಬಿಟ್ಮ್ಯಾಪ್ ಕಡತ ಹಸ್ತಾಂತರಿಸಿದ ನೀವು,

132
00:09:06,930 --> 00:09:14,510
ಮತ್ತು ಇದು ಕಾಣುತ್ತದೆ - ಕೆಂಪು ಚುಕ್ಕೆಗಳ ಒಂದು ಗುಂಪೇ - ಮತ್ತು ನೀವು ನಿಜವಾಗಿಯೂ ಬರೆಯದ ಏನು ಗೊತ್ತಿಲ್ಲ.

133
00:09:14,510 --> 00:09:23,310
ನೀವು ಅರೆಮುಚ್ಚು ವೇಳೆ, ನೀವು ಮಧ್ಯಮ ಒಳಗೆ ಸ್ವಲ್ಪ ನೀಲಿ ಬಣ್ಣವನ್ನು ನೋಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.

134
00:09:23,310 --> 00:09:26,270
ಪಠ್ಯ ಸಂಗ್ರಹವಾಗಿರುವ ಅಲ್ಲಿ ಅಗತ್ಯವಾಗಿ, ಇದು.

135
00:09:26,270 --> 00:09:30,270
ಅಲ್ಲಿ ಸಂಭವಿಸಿದ ಒಂದು ಕೊಲೆ, ಮತ್ತು ನಾವು ಮಾಡಿದ ಓರ್ವ ಕಂಡು ಹಿಡಿಯಬೇಕು.

136
00:09:30,270 --> 00:09:36,760
ಹಾಗೆ ಮಾಡಲು, ನಾವು ಓದಬಹುದಾದ ರೂಪದಲ್ಲಿ ಈ ಚಿತ್ರವನ್ನು ಪರಿವರ್ತಿಸಲು ರೀತಿಯ ಅಗತ್ಯವಿದೆ.

137
00:09:36,760 --> 00:09:42,740
ನೀವು ಹುಡುಗರಿಗೆ ಹಿಂದೆಂದೂ ಈ ವೇಳೆ ಎದುರಿಸಿದೆ, ಕೆಲವೊಮ್ಮೆ ಕಡಿಮೆ ಕಿಟ್ಗಳು ಇರುವುದಿಲ್ಲ

138
00:09:42,740 --> 00:09:48,510
ಅಲ್ಲಿ ನೀವು ಒಂದು ಕೆಂಪು ಚಲನಚಿತ್ರ ಭೂತಗನ್ನಡಿಯಿಂದ ಹೊಂದಿರುತ್ತದೆ. ಯಾರಾದರೂ? ಹೌದು.

139
00:09:48,510 --> 00:09:52,770
ಆದ್ದರಿಂದ ಈ ರೀತಿಯ ತಿರುಗಿದ ಏನೋ ಎಂದು, ನೀವು ಒಂದು ಭೂತಗನ್ನಡಿಯಿಂದ ಹೊಂದಿರುತ್ತದೆ

140
00:09:52,770 --> 00:09:58,130
ಅದರ ಮೇಲೆ ಕೆಂಪು ಚಲನಚಿತ್ರ, ನೀವು, ಇಮೇಜ್ ಮೇಲೆ ಇದು ಪ್ರದರ್ಶಿಸುತ್ತದೆ

141
00:09:58,130 --> 00:10:03,410
ಮತ್ತು ನೀವು ಸಂದೇಶವನ್ನು ಅದರೊಡನೆ ಮರೆಮಾಡಲಾಗಿದೆ ವೀಕ್ಷಿಸಬಹುದಾಗಿದೆ ಎಂದು.

142
00:10:03,410 --> 00:10:07,080
ನಾವು ಕೆಂಪು ಚಲನಚಿತ್ರ ಭೂತಗನ್ನಡಿಯಿಂದ ಹೊಂದಿಲ್ಲ, ಆದ್ದರಿಂದ ಬದಲಿಗೆ ನಾವು ರೀತಿಯ ನಮ್ಮ ರಚಿಸಲು ಆಫ್ ಎಂದು ನೀನು

143
00:10:07,080 --> 00:10:09,060
ಈ pset ರಲ್ಲಿ.

144
00:10:09,060 --> 00:10:15,760
ಮತ್ತು ಆದ್ದರಿಂದ ಬಳಕೆದಾರರು, ನಂತರ ಇನ್ಪುಟ್ ವೊಡುನಿಟ್, ಸುಳಿವಿಗೆ ಹೋಗುತ್ತದೆ. BMP,

145
00:10:15,760 --> 00:10:18,800
ಕೆಂಪು ಬಿಂದುವನ್ನು ಸಂದೇಶವಾಗಿದೆ infile, ಆದುದರಿಂದ ಆ

146
00:10:18,800 --> 00:10:23,550
ತದನಂತರ ಅವರು verdict.bmp ನಮ್ಮ outfile ಏರಲಿದೆ ಹೇಳುತ್ತಿದ್ದಾರೆಂಬುದನ್ನು.

147
00:10:23,550 --> 00:10:27,900
ಆದ್ದರಿಂದ ಸುಳಿವನ್ನು ರೀತಿಯ ಹೊಸ ಬಿಟ್ಮ್ಯಾಪ್ ಚಿತ್ರಿಕೆಯನ್ನು ರಚಿಸಲು ವಿಶೇಷವೇನು

148
00:10:27,900 --> 00:10:32,600
ಒಂದು ಓದಬಲ್ಲ ಶೈಲಿಯಲ್ಲಿ ಹೊರತುಪಡಿಸಿ ಅಲ್ಲಿ ನಾವು ಗುಪ್ತ ಸಂದೇಶವನ್ನು ನೋಡಬಹುದು.

149
00:10:32,600 --> 00:10:37,550
>> ನಾವು ಕೆಲವು ರೀತಿಯ ಬಿಟ್ಮ್ಯಾಪ್ಗಳನ್ನು ಸಂಪಾದಿಸುವ ಮತ್ತು ಮ್ಯಾನಿಪುಲೇಟ್ ವ್ಯವಹರಿಸುವಾಗ ಎಂದು ನೀನು ರಿಂದ

150
00:10:37,550 --> 00:10:42,400
ನಾವು ಈ ಬಿಟ್ಮ್ಯಾಪ್ ಕಡತಗಳ ರಚನೆಯಲ್ಲಿ ರಲ್ಲಿ ಡೈವ್ ರೀತಿಯ ನೀನು.

151
00:10:42,400 --> 00:10:48,130
ನಾವು ಉಪನ್ಯಾಸ ಈ ಸ್ವಲ್ಪ ಮೇಲೆ ಹೋದ, ಆದರೆ ಕೆಲವು ಅವುಗಳನ್ನು ನೋಡೋಣ ನ.

152
00:10:48,130 --> 00:10:51,740
ಬಿಟ್ಮ್ಯಾಪ್ಗಳನ್ನು ಮೂಲಭೂತವಾಗಿ ಬೈಟ್ಗಳು ಕೇವಲ ಒಂದು ವ್ಯವಸ್ಥೆ ಇರುತ್ತದೆ

153
00:10:51,740 --> 00:10:55,790
ನಾವು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ನೀವು ಅಲ್ಲಿ ಇದು ಬೈಟ್ಗಳು ಏನು ಅರ್ಥ.

154
00:10:55,790 --> 00:11:00,540
ಇಲ್ಲಿ ಬಿಟ್ಮ್ಯಾಪ್ ಚಿತ್ರದ ಒಂದು ನಕ್ಷೆ ಮುಂತಾದ ರೀತಿಯ ಹೊಂದಿದೆ

155
00:11:00,540 --> 00:11:08,550
ಇದು ಕೆಲವು ಹೆಡರ್ ಕಡತಗಳನ್ನು ಆರಂಭವಾಗುತ್ತದೆ ಎಂದು, ಅಲ್ಲಿ ಕೆಲವು ಮಾಹಿತಿಯನ್ನು ಆರಂಭವಾಗುತ್ತದೆ.

156
00:11:08,550 --> 00:11:16,540
ನೀವು ಬಗ್ಗೆ ಬೈಟ್ ಸಂಖ್ಯೆ 14 ನಲ್ಲಿ ಗಾತ್ರ ಬಿಟ್ಮ್ಯಾಪ್ ಚಿತ್ರದ ಸೂಚಿಸಲಾಗುತ್ತದೆ ನೋಡಿ

157
00:11:16,540 --> 00:11:18,520
ಮತ್ತು ಇದು ಮುಂದುವರಿಯುತ್ತದೆ.

158
00:11:18,520 --> 00:11:23,810
ಆದರೆ ಆಗ ನಾವು ನಿಜವಾಗಿಯೂ ಇಲ್ಲಿ ನೀವು ಆಸಕ್ತಿ ಬೈಟ್ ಸಂಖ್ಯೆ 54 ಸುಮಾರು ಶುರುವಾಗುತ್ತಿದೆ.

159
00:11:23,810 --> 00:11:26,060
ನಾವು ಈ RGB ಮೂರು ಹೊಂದಿರುತ್ತವೆ.

160
00:11:26,060 --> 00:11:30,760
ಮಾಡಲು ವಿಶೇಷವೇನು ಎಂದು ಯಾವ ನಿಜವಾದ ಪಿಕ್ಸೆಲ್ಗಳ ಬಣ್ಣದ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ ಹೊಂದಿದೆ.

161
00:11:30,760 --> 00:11:35,950
ಶಿರೋಲೇಖ ಆ ಮೇಲೆ ಎಲ್ಲವೂ ಕೆಲವು ಮಾಹಿತಿ

162
00:11:35,950 --> 00:11:41,240
ಚಿತ್ರ, ಚಿತ್ರದ ಅಗಲ ಮತ್ತು ಎತ್ತರ ಗಾತ್ರಕ್ಕೆ ಅನುಗುಣವಾಗಿ.

163
00:11:41,240 --> 00:11:44,930
ನಾವು ನಂತರ ಪ್ಯಾಡಿಂಗ್ ಒಳಗೆ ಹೋದಾಗ, ನಾವು ನೋಡುತ್ತಾರೆ ಏಕೆ ಚಿತ್ರದ ಗಾತ್ರ

164
00:11:44,930 --> 00:11:48,670
ಅಗಲ ಅಥವಾ ಎತ್ತರ ವಿಭಿನ್ನವಾದ ಇರಬಹುದು.

165
00:11:48,670 --> 00:11:54,240
ಆದ್ದರಿಂದ ಈ ಪ್ರತಿನಿಧಿಸಲು - ಈ ಬಿಟ್ಮ್ಯಾಪ್ ಇಮೇಜ್ಗಳನ್ನು ಬೈಟ್ಗಳು ಸರಣಿಗಳನ್ನು ಅವು -

166
00:11:54,240 --> 00:11:59,370
ಸರಿ ಹೇಳಲು ಇದೆ ನಾವು ಯಾವ, ನಾನು ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಪಡೆಯಲಿದ್ದೇನೆ ಎಂದು ಸೂಚ್ಯಂಕ 14 ನಲ್ಲಿ,

167
00:11:59,370 --> 00:12:03,380
ನಾವು ಈ ಸುಲಭ ಮಾಡಲು ಮಾಡಲು ನೀನು ಯಾವ ಬದಲಿಗೆ ಗಾತ್ರದ ಉದಾಹರಣೆಗೆ, ಅಲ್ಲಿ, ಆದರೆ

168
00:12:03,380 --> 00:12:06,020
ಒಂದು struct ಇದು ಕೋಶೀಕರಿಸುತ್ತದೆ ಇದೆ.

169
00:12:06,020 --> 00:12:08,880
ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಮಾಡಿದ ಎರಡು ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ, ಒಂದು BITMAPFILEHEADER ಹೊಂದಿವೆ

170
00:12:08,880 --> 00:12:10,440
ಮತ್ತು ಒಂದು BITMAPINFOHEADER,

171
00:12:10,440 --> 00:12:14,840
ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಕಡತವನ್ನು ಓದಲು ಬಂದಾಗಲೆಲ್ಲಾ, ಡೀಫಾಲ್ಟ್ ಮೂಲಕ, ಸಲುವಾಗಿ ಹೋಗಿ ಎಂದು ವಿಶೇಷವೇನು

172
00:12:14,840 --> 00:12:22,360
ಮತ್ತು ಆದ್ದರಿಂದ ದೃಷ್ಟಿಯಿಂದ ಇದು biWidth ಮತ್ತು biSize ಎಂದು ಚರಾಂಕಗಳ ಮೇಲೆ ತುಂಬಲು ವಿಶೇಷವೇನು.

173
00:12:25,270 --> 00:12:31,230
ತದನಂತರ ಅಂತಿಮವಾಗಿ, ಪ್ರತಿ ಪಿಕ್ಸೆಲ್ ಮೂರು ಬೈಟ್ಗಳು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

174
00:12:31,230 --> 00:12:35,500
ಮೊದಲ ಒಂದು ಪಿಕ್ಸೆಲ್ ನೀಲಿ ಪ್ರಮಾಣವನ್ನು, ಎರಡನೇ, ಹಸಿರು ಪ್ರಮಾಣವನ್ನು

175
00:12:35,500 --> 00:12:41,120
ಮತ್ತು ಅಂತಿಮವಾಗಿ, 0 ಅಗತ್ಯವಾಗಿ ನೀಲಿ ಅಥವಾ ಹಸಿರು ಅಲ್ಲಿ ಕೆಂಪು, ಪ್ರಮಾಣವನ್ನು ಅಥವಾ ಕೆಂಪು

176
00:12:41,120 --> 00:12:43,720
ತದನಂತರ ಎಫ್ಎಫ್ ಗರಿಷ್ಠ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ.

177
00:12:43,720 --> 00:12:46,800
ಈ ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಮೌಲ್ಯಗಳು.

178
00:12:46,800 --> 00:12:53,870
ನಾವು ff0000 ಹೊಂದಿದ್ದರೆ ಆದ್ದರಿಂದ, ಆ ನೀಲಿ ಗರಿಷ್ಠ ಪ್ರಮಾಣವನ್ನು ಸೂಚಿಸುತ್ತದೆ

179
00:12:53,870 --> 00:12:58,890
ತದನಂತರ ಹಸಿರು ಮತ್ತು ಕೆಂಪು, ಆದ್ದರಿಂದ ನಂತರ ನಮಗೆ ಒಂದು ನೀಲಿ ಪಿಕ್ಸೆಲ್ ನೀಡುವ ಯಾವುದೇ.

180
00:12:58,890 --> 00:13:04,190
ನಾವು ಬೋರ್ಡ್ ಅಡ್ಡಲಾಗಿ ಎಫ್ಎಫ್ ಎಲ್ಲಾ ಹೊಂದಿದ್ದರೆ ನಂತರ, ನಂತರ ನಾವು ಒಂದು ಬಿಳಿ ಪಿಕ್ಸೆಲ್ ಎಂದು ಅರ್ಥ.

181
00:13:04,190 --> 00:13:11,370
ನಾವು RGB ಹೇಳಲು ಈ ವಿಶಿಷ್ಟವಾಗಿ ವಿರುದ್ಧ ರೀತಿಯ. ಇದು ವಾಸ್ತವವಾಗಿ BGR ವಿಶೇಷವೇನು.

182
00:13:12,750 --> 00:13:18,990
>> ನಾವು ನಿಜವಾಗಿ ಒಂದು ಬಿಟ್ಮ್ಯಾಪ್ ಚಿತ್ರದ ಉದಾಹರಣೆ ನೋಡೋಣ ಆದ್ದರಿಂದ - ನನಗೆ ಇಲ್ಲಿ ಒಂದು ಅಪ್ ಪುಲ್ ಅವಕಾಶ.

183
00:13:31,560 --> 00:13:33,830
ಇದು ಸ್ವಲ್ಪ ಸಣ್ಣ ಇಲ್ಲಿದೆ.

184
00:13:39,890 --> 00:13:47,840
ನಾನು ಝೂಮ್ ಭಾವಿಸುತ್ತೇನೆ, ಮತ್ತು ನಾವು pixelated ನೋಡಬಹುದು. ಇದು ಬಣ್ಣದ ಬ್ಲಾಕ್ಗಳನ್ನು ತೋರುತ್ತಿದೆ.

185
00:13:47,840 --> 00:13:50,110
ನೀವು ನಂತರ ಬಿಳಿ ಬ್ಲಾಕ್ಗಳನ್ನು ಮತ್ತು ಕೆಂಪು ಬ್ಲಾಕ್ಗಳನ್ನು ಹೊಂದಿವೆ.

186
00:13:50,110 --> 00:13:53,700
ನೀವು Microsoft ಪೈಂಟ್ ಆಡುವ ವೇಳೆ, ಉದಾಹರಣೆಗೆ, ಆ ರೀತಿ ಏನನ್ನಾದರೂ ಮಾಡಬಹುದು

187
00:13:53,700 --> 00:13:58,960
ಅದಕ್ಕೆ ಮೂಲತಃ ಕೇವಲ ಒಂದು ನಿಶ್ಚಿತ ಕ್ರಮದಲ್ಲಿ ಕೆಲವು ಚೌಕಗಳು ವರ್ಣಚಿತ್ರ.

188
00:13:58,960 --> 00:14:08,060
ಆದ್ದರಿಂದ ಬಿಟ್ಮ್ಯಾಪ್ ರಲ್ಲಿ ಯಾವ ಈ ಅನುವಾದಿಸಲಾಗುತ್ತದೆ ಈ ರೀತಿ ಇರುತ್ತದೆ.

189
00:14:08,060 --> 00:14:15,710
ಇಲ್ಲಿ ನಾವು ಎಲ್ಲಾ 6 ಎಫ್ ನ ಎಂದು, ಮೊದಲ ಬಿಳಿ ಪಿಕ್ಸೆಲ್ಗಳು ಹೊಂದಿವೆ, ಮತ್ತು ನಂತರ ನಾವು ಕೆಂಪು ಪಿಕ್ಸೆಲ್ಗಳು ಹೊಂದಿವೆ

190
00:14:15,710 --> 00:14:19,910
0000ff ಸೂಚಿಸಲಾಗುತ್ತದೆ.

191
00:14:19,910 --> 00:14:27,940
ಮತ್ತು ಆದ್ದರಿಂದ ಆ ಬೈಟ್ಗಳು ಅನುಕ್ರಮ ಬಿಟ್ಮ್ಯಾಪ್ ಚಿತ್ರವನ್ನು ನೋಡಲು ಹೋಗುವುದು ಹೇಗೆ ಸೂಚಿಸುತ್ತದೆ.

192
00:14:27,940 --> 00:14:32,230
ಹಾಗಾಗಿ ನಾನು ಇಲ್ಲಿ ಮಾಡಿದ ಕೇವಲ ಎಲ್ಲಾ ಬೈಟ್ಗಳು ಔಟ್ ಬರೆಯಲಾಗಿದೆ ಮತ್ತು ಕೆಂಪು ಬಣ್ಣದ ನಂತರ

193
00:14:32,230 --> 00:14:37,550
ನೀವು ರೀತಿಯ ನೋಡಬಹುದು ಆದ್ದರಿಂದ, ಆ ರೀತಿಯ ಒಂದು ನಗುತ್ತಿರುವ ಮುಖವನ್ನು ಸೂಚಿಸುತ್ತದೆ ಹೇಗೆ ನೀವು ಅರೆಮುಚ್ಚು ಸ್ವಲ್ಪ, ವೇಳೆ.

194
00:14:40,180 --> 00:14:46,390
>> ಬಿಟ್ಮ್ಯಾಪ್ ಇಮೇಜ್ಗಳನ್ನು ಕೆಲಸ ನಾನು ಆ ರೀತಿಯಲ್ಲಿ ಒಂದು ಗ್ರಿಡ್ ಮೂಲತಃ ಕಲ್ಪಿಸಿಕೊಳ್ಳಬಲ್ಲರಾಗಿದ್ದರು.

195
00:14:46,390 --> 00:14:54,940
ಮತ್ತು ಆದ್ದರಿಂದ ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಗ್ರಿಡ್ ಪ್ರತಿಯೊಂದು ಸಾಲು 4 ಬೈಟ್ಗಳು ಒಂದು ಬಹು ಎಂದು ಹೊಂದಿದೆ.

196
00:15:00,520 --> 00:15:07,060
ನಾವು ಒಂದು ಬಿಟ್ಮ್ಯಾಪ್ ಚಿತ್ರ ನೋಡಿದರೆ, ನೀವು ಪ್ರತಿ ಮೌಲ್ಯ ತುಂಬುವ ಮಾಡುತ್ತಿದ್ದೇವೆ.

197
00:15:07,060 --> 00:15:17,370
ಉದಾಹರಣೆಗೆ, ನೀವು, ಇಲ್ಲಿ, ಇಲ್ಲಿ, ಇಲ್ಲಿ ಒಂದು ನೀಲಿ ಹಸಿರು ಕೆಂಪು ಹೊಂದಿರಬಹುದು

198
00:15:17,370 --> 00:15:24,950
ಆದರೆ ನೀವು ಚಿತ್ರ ನಾಲ್ಕು ಬೈಟ್ಗಳು ಒಂದು ಬಹು ಮುಚ್ಚಬೇಕಾಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕು.

199
00:15:24,950 --> 00:15:32,200
ನಾನು ಮೂರು ಬ್ಲಾಕ್ಗಳನ್ನು ವ್ಯಾಪಕ ನನ್ನ ಚಿತ್ರವನ್ನು ನೀವು ಆದ್ದರಿಂದ, ನಂತರ ನಾನು ಖಾಲಿ ಮೌಲ್ಯ ಹಾಕಬೇಕು ಎಂದು

200
00:15:32,200 --> 00:15:35,640
ಕಳೆದ ಒಂದು ಅದನ್ನು ನಾಲ್ಕು ಒಂದು ಬಹು ಮಾಡಲು.

201
00:15:35,640 --> 00:15:39,530
ಆದ್ದರಿಂದ ನಾವು ಪ್ಯಾಡಿಂಗ್ ಕರೆ ಮಾಡುತ್ತಿದ್ದರೆ ಅದು ರಲ್ಲಿ ಸೇರಿಸುತ್ತದೆ.

202
00:15:39,530 --> 00:15:43,750
ನಾನು ಅಲ್ಲಿ ಒಂದು X ನೊಂದಿಗೆ ಸೂಚಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ.

203
00:15:44,920 --> 00:15:54,160
ಈಗ ನಾವು ಉದಾಹರಣೆಗೆ, 7 ಪಿಕ್ಸೆಲ್ಗಳು ಉದ್ದವಾಗಿದೆ ಚಿತ್ರವೊಂದನ್ನು ನೀವು ಹೇಳಬಹುದು.

204
00:15:54,160 --> 00:15:59,550
ನಾವು 1, 2, 3, 4, 5, 6, 7, ಹೊಂದಿವೆ

205
00:16:04,750 --> 00:16:07,000
ಮತ್ತು ಎಲ್ಲಾ ಬಣ್ಣದೊಂದಿಗೆ ತುಂಬಲಾಗುವುದು.

206
00:16:07,000 --> 00:16:10,620
ಬಿಟ್ಮ್ಯಾಪ್ ಇಮೇಜ್ಗಳನ್ನು ಕೆಲಸ ರೀತಿಯಲ್ಲಿ ನಾವು ಒಂದು 8 ಅಗತ್ಯವಿದೆ ಎಂದು.

207
00:16:10,620 --> 00:16:12,460
ಇದೀಗ ನಾವು 1, 2, 3, 4, 5, 6, 7 ಹೊಂದಿರುತ್ತವೆ.

208
00:16:12,460 --> 00:16:19,360
ನಾವು ಸರಿಯಾಗಿ ಓದಲು ಬಿಟ್ಮ್ಯಾಪ್ ಚಿತ್ರಕ್ಕಾಗಿ 8 ಸ್ಥಳಗಳಲ್ಲಿ ಅಗತ್ಯವಿದೆ.

209
00:16:19,360 --> 00:16:25,600
ಆದ್ದರಿಂದ ನಾವು ಏನು ಪ್ಯಾಡಿಂಗ್ ಕೇವಲ ಸ್ವಲ್ಪ ರಲ್ಲಿ ಸೇರಿಸಲು ಇದೆ

210
00:16:25,600 --> 00:16:29,430
ಅಗಲಗಳನ್ನು ಎಲ್ಲಾ ಏಕರೂಪದ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ

211
00:16:29,430 --> 00:16:34,260
ಮತ್ತು ಅಗಲ ಎಲ್ಲಾ 4 ಒಂದು ಬಹು.

212
00:16:42,110 --> 00:16:47,310
ಮತ್ತು ಆದ್ದರಿಂದ ನಾನು ಮೊದಲು, ಒಂದು X ಅಥವಾ ಅಂಕು ಡೊಂಕು ಅಕ್ಷರಗಳುಳ್ಳ ಸಾಲಿನಂತೆ padding, ಸೂಚಿಸಲಾಗುತ್ತದೆ

213
00:16:47,310 --> 00:16:53,880
ಆದರೆ ನಿಜವಾದ ಬಿಟ್ಮ್ಯಾಪ್ ಇಮೇಜ್ಗಳನ್ನು ಪ್ಯಾಡಿಂಗ್ ಒಂದು ಹೆಕ್ಸಾಡೆಸಿಮಲ್ 0 ಸೂಚಿಸುತ್ತದೆ.

214
00:16:53,880 --> 00:16:57,340
ಆದ್ದರಿಂದ ಒಂದು ಪಾತ್ರ 0 ಆಗಿರುತ್ತದೆ.

215
00:16:58,980 --> 00:17:06,329
ಏನು HANDY ರಲ್ಲಿ ಬರಬಹುದೆಂದು xxd ಆಜ್ಞೆಯ.

216
00:17:06,329 --> 00:17:11,220
ಏನು ಅದು ನಾನು ನಗು ಜೊತೆ ಮೊದಲು ಏನು ಹೋಲುತ್ತದೆ, ನಿಜವಾಗಿ ನೀವು ತೋರಿಸುತ್ತದೆ ನಂತೆ

217
00:17:11,220 --> 00:17:15,630
ನಾನು ವಾಸ್ತವವಾಗಿ ಪ್ರತಿ ಬಣ್ಣ ಪಿಕ್ಸೆಲ್ಗೂ ಎಂಬುದನ್ನು ಔಟ್ ಮುದ್ರಿಸಿತು

218
00:17:15,630 --> 00:17:21,800
ನೀವು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಜೊತೆ xxd ರನ್ ಮಾಡಿದಾಗ ಮತ್ತು ನಂತರ, ಅದು ಬಣ್ಣ ಕೋಡೆಡ್

219
00:17:21,800 --> 00:17:28,670
ಅದು ನಿಜವಾಗಿ ಬಣ್ಣಗಳು ಆ ಚಿತ್ರಬಂಧಗಳ ಏನೆಂದು ಮುದ್ರಿಸಲು ಕಾಣಿಸುತ್ತದೆ.

220
00:17:28,670 --> 00:17:33,810
ಏನು ಮಾಡಬೇಕು-ರು 54 ನಾನು ಸೂಚಿಸಲು ಇಲ್ಲಿ ಸುಮಾರು

221
00:17:33,810 --> 00:17:36,530
ನಾನು 54TH ಬೈಟ್ ನಲ್ಲಿ ಪ್ರಾರಂಭಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ ಹೇಳುತ್ತಾರೆ

222
00:17:36,530 --> 00:17:40,820
ನಾವು ಬಿಟ್ಮ್ಯಾಪ್ಗಳನ್ನು ನಕ್ಷೆಯನ್ನು ಮರಳಿ ನೋಡಿದರೆ ಮೊದಲು ಏಕೆಂದರೆ, ನೆನಪು

223
00:17:40,820 --> 00:17:42,690
ಹಾಗೆ ಹೆಡರ್ ಮಾಹಿತಿಯನ್ನು ಮತ್ತು ವಸ್ತುಗಳ ಎಲ್ಲ ಇಲ್ಲಿದೆ.

224
00:17:42,690 --> 00:17:46,280
ಆದರೆ ನಾವು ನಿಜವಾಗಿಯೂ ಕಾಳಜಿ ಬಣ್ಣ ಸೂಚಿಸುವ ನಿಜವಾದ ಪಿಕ್ಸೆಲ್ಗಳು.

225
00:17:46,280 --> 00:17:52,700
ಆದ್ದರಿಂದ, ರು 54 ಆ ಧ್ವಜ ನಲ್ಲಿ ಸೇರಿಸುವ ಮೂಲಕ, ಆಗ ಬಣ್ಣದ ಮೌಲ್ಯಗಳನ್ನು ವೀಕ್ಷಿಸಬಹುದಾಗಿದೆ ಆರ್.

226
00:17:52,700 --> 00:17:56,020
ಮತ್ತು ಆ ತರಹದ ಸಂಕೀರ್ಣ ಧ್ವಜಗಳು ಮತ್ತು ವಿಷಯಗಳ ಬಗ್ಗೆ ಚಿಂತಿಸಬೇಡಿ.

227
00:17:56,020 --> 00:18:05,020
ಸಮಸ್ಯೆ ಸೆಟ್ ನಿರ್ದಿಷ್ಟಪಡಿಸುವಿಕೆಯನ್ನು, ನೀವು ಪಿಕ್ಸೆಲ್ಗಳು ಪ್ರದರ್ಶಿಸಲು xxd ಬಳಸಲು ಹೇಗೆ ದಿಕ್ಕುಗಳಲ್ಲಿ ಹೊಂದಿರುತ್ತದೆ.

228
00:18:07,070 --> 00:18:15,590
ನೀವು ಇಲ್ಲಿ ನೋಡಿ, ಅದು ಒಂದು ಬಗೆಯ ಒಂದು ಹಸಿರು ಬಾಕ್ಸ್, ಈ ಸಣ್ಣ ವಿಷಯ ತೋರುತ್ತಿದೆ.

229
00:18:15,590 --> 00:18:23,610
ನಾನು ಮೂಲತಃ ಯಾವುದೇ ನೀಲಿ, ಹಸಿರು ಬಹಳಷ್ಟು, ಮತ್ತು ಕೆಂಪು ಹೇಳಿದಂತೆ 00ff00 ಬಣ್ಣ ಕೋಡೆಡ್ ಮಾಡಿದ್ದೀರಿ.

230
00:18:23,610 --> 00:18:26,370
ಆದ್ದರಿಂದ ಹಸಿರು ಅನುರೂಪವಾಗಿದೆ.

231
00:18:26,370 --> 00:18:31,920
ನೀವು ಇಲ್ಲಿ ನೋಡಿ, ನಾವು ಒಂದು ಹಸಿರು ಆಯಾತ ನೋಡಿ.

232
00:18:31,920 --> 00:18:36,660
ಈ ಹಸಿರು ಆಯಾತ ನಾವು ಏನನ್ನು ಆದ್ದರಿಂದ, ಕೇವಲ 3 ಪಿಕ್ಸೆಲ್ಗಳು ಅಗಲವಿದೆ

233
00:18:36,660 --> 00:18:44,350
ಚಿತ್ರ 4 ವ್ಯಾಪಕ ಒಂದು ಬಹು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಹೆಚ್ಚುವರಿ ಪ್ಯಾಡಿಂಗ್ ರಲ್ಲಿ ಸೇರಿಸಲು ಹೊಂದಿದೆ.

234
00:18:44,350 --> 00:18:49,460
ಮತ್ತು ಆದ್ದರಿಂದ ನೀವು ಇಲ್ಲಿ ಈ 0 ಸೆ ನೋಡಿ ಹೇಗೆ.

235
00:18:49,460 --> 00:18:54,510
ಈ ವಾಸ್ತವವಾಗಿ, ನಿಮ್ಮ ಗಣಕತೆರೆ pset ನ ಫಲಿತಾಂಶ

236
00:18:54,510 --> 00:19:01,350
ಮೂಲಭೂತವಾಗಿ ಸಣ್ಣ ಬಿಟ್ಮ್ಯಾಪ್ ತೆಗೆದುಕೊಂಡು ನಂತರ 4 ಮೂಲಕ ಎನ್ಲಾರ್ಜಿಂಗ್.

237
00:19:01,350 --> 00:19:09,380
ಆದ್ದರಿಂದ ನಾವು ನೋಡಿ, ವಾಸ್ತವವಾಗಿ ಈ ಚಿತ್ರವನ್ನು 12 ಪಿಕ್ಸೆಲ್ ಅಗಲ ಎಂದು, ಆದರೆ 12 4 ರ ಅಪವರ್ತ್ಯ

238
00:19:09,380 --> 00:19:12,940
ನಾವು ಯಾವುದೇ ಸೇರಿಸಲು ಅಗತ್ಯವಿಲ್ಲ ಏಕೆಂದರೆ ಆದ್ದರಿಂದ ನಾವು ವಾಸ್ತವವಾಗಿ ಕೊನೆಯಲ್ಲಿ ಯಾವುದೇ 0 ಸೆ ಕಾಣುವುದಿಲ್ಲ

239
00:19:12,940 --> 00:19:19,070
ಸಂಪೂರ್ಣವಾಗಿ ಪೂರ್ವಪ್ರತ್ಯಯ ವಿಶೇಷವೇನು ಏಕೆಂದರೆ. ಯಾವುದೇ ಹೆಚ್ಚಿನ ಸ್ಥಳಾವಕಾಶ ಇರುವುದಿಲ್ಲ.

240
00:19:20,720 --> 00:19:23,470
>> ಸರಿ. ಪ್ಯಾಡಿಂಗ್ ಬಗ್ಗೆ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳನ್ನು?

241
00:19:25,150 --> 00:19:27,460
ಸರಿ. ಕೂಲ್.

242
00:19:27,460 --> 00:19:32,520
>> ನಾನು ಮೊದಲೇ ಹೇಳಿದಂತೆ, ಬಿಟ್ಮ್ಯಾಪ್ಗಳನ್ನು ಕೇವಲ ಬೈಟ್ಗಳು ಅನುಕ್ರಮ ಇವೆ.

243
00:19:32,520 --> 00:19:39,170
ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಹೊಂದಿಲ್ಲ ಬದಲಿಗೆ ಬೈಟ್ ನಿರ್ದಿಷ್ಟವಾದ ಸಂಖ್ಯೆಯನ್ನು ಟ್ರ್ಯಾಕ್ ಬಯಸುವ ಹೊಂದಿದೆ

244
00:19:39,170 --> 00:19:47,050
ಒಂದು ನಿರ್ದಿಷ್ಟ ಅಂಶ ಸೂಚಿಸುತ್ತದೆ, ನಾವು ವಾಸ್ತವವಾಗಿ ಆ ಪ್ರತಿನಿಧಿಸಲು struct ರಚಿಸಿದ.

245
00:19:47,050 --> 00:19:50,930
ಆದ್ದರಿಂದ ನಾವು ಹೊಂದಿರುವ RGBTRIPLE struct ಹೊಂದಿದೆ.

246
00:19:50,930 --> 00:19:54,590
ನೀವು RGB ಟ್ರಿಪಲ್ ಒಂದು ಉದಾಹರಣೆಗೆ ಇದ್ದಾಗಲೆಲ್ಲಾ,

247
00:19:54,590 --> 00:20:00,970
ಈ ಒಂದು ರೀತಿಯ struct ವ್ಯಾಖ್ಯಾನಿಸಲು ಏಕೆಂದರೆ, ನಂತರ ನೀವು, rgbtBlue ವೇರಿಯಬಲ್ ಪ್ರವೇಶಿಸಬಹುದು

248
00:20:00,970 --> 00:20:09,520
ಸೂಚಿಸುತ್ತದೆ ಇದು ಹಾಗೆಯೇ ಹಸಿರು ಮತ್ತು ಕೆಂಪು ಚರಾಂಕಗಳ ಎಷ್ಟು ನೀಲಿ, ಹಸಿರು, ಮತ್ತು ಕೆಂಪು,

249
00:20:09,520 --> 00:20:11,580
ಅನುಕ್ರಮವಾಗಿ, ನೀವು.

250
00:20:11,580 --> 00:20:16,800
>> ನಾವು 0 ಗೆ, ಎಫ್ಎಫ್ ಹಸಿರು ಸೆಟ್, ನೀಲಿ ವೇರಿಯಬಲ್ ಸೆಟ್ ಆದ್ದರಿಂದ

251
00:20:16,800 --> 00:20:22,060
, ಇದು ನೀವು ಗರಿಷ್ಠ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ, ನಂತರ ಕೆಂಪು ವೇರಿಯಬಲ್ 0 ಗೆ ಸೆಟ್

252
00:20:22,060 --> 00:20:27,870
ನಂತರ ಯಾವ ಬಣ್ಣದ ಈ ನಿರ್ದಿಷ್ಟ RGB ಟ್ರಿಪಲ್ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ? >> [ವಿದ್ಯಾರ್ಥಿ] ಹಸಿರು.

253
00:20:27,870 --> 00:20:29,150
ಹಸಿರು. ನಿಖರವಾಗಿ.

254
00:20:29,150 --> 00:20:34,480
ಅದನ್ನು ತಿಳಿಯಲು ಉಪಯುಕ್ತ ಎಂದು ವಿಶೇಷವೇನು ಎಂದು ನೀವು RGB ಟ್ರಿಪಲ್ ಒಂದು ಉದಾಹರಣೆಗೆ ಇದ್ದಾಗಲೆಲ್ಲಾ,

255
00:20:34,480 --> 00:20:41,340
, ನೀಲಿ ಹಸಿರು, ಮತ್ತು ಕೆಂಪು - - ಪ್ರತ್ಯೇಕವಾಗಿ ನೀವು ವಾಸ್ತವವಾಗಿ ಬಣ್ಣದ ಪ್ರಮಾಣವನ್ನು ಪ್ರವೇಶಿಸಬಹುದು.

256
00:20:43,350 --> 00:20:54,900
>> ಈಗ ನಾವು ರಚನೆ ಬಗ್ಗೆ ಮಾತನಾಡಿದ್ದರು ಎಂಬುದನ್ನು, ನ BMP ಫೈಲ್ ನಲ್ಲಿ ಅವಲೋಕಿಸೋಣ.

257
00:20:54,900 --> 00:20:57,870
ಈ ನೀವು ಮಾಡಿದ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಇವೆ.

258
00:20:57,870 --> 00:21:01,820
ಇಲ್ಲಿ ನಾವು ಒಂದು BITMAPFILEHEADER struct ಹೊಂದಿರುತ್ತವೆ.

259
00:21:01,820 --> 00:21:07,610
ಆಸಕ್ತಿ ಗಾತ್ರವನ್ನು ಹೊಂದಿದೆ.

260
00:21:07,610 --> 00:21:12,660
ನಂತರ, ನಾವು ನಮಗೆ ಆಸಕ್ತಿಕರ ಎಂದು ಕೆಲವು ವಿಷಯಗಳನ್ನು ಹೊಂದಿರುವ ಮಾಹಿತಿಯನ್ನು ಹೆಡರ್, ಹೊಂದಿವೆ

261
00:21:12,660 --> 00:21:15,480
ಅವುಗಳೆಂದರೆ ಗಾತ್ರ, ಅಗಲ ಮತ್ತು ಎತ್ತರ.

262
00:21:15,480 --> 00:21:19,170
ನಾವು ನಂತರ ಹೋಗಲು ನಾವು, ನೀವು ಫೈಲ್ ಗೆ ಓದಿದಾಗ,

263
00:21:19,170 --> 00:21:25,500
ಇದು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಾವು ಅದೇ ಸಲುವಾಗಿ ಸೆಟ್ ಮಾಡಿದ ಏಕೆಂದರೆ ಓದುತ್ತದೆ.

264
00:21:25,500 --> 00:21:31,990
ಆದ್ದರಿಂದ biSize ಚಿತ್ರದ ನಿಜವಾದ ಗಾತ್ರವನ್ನು ಹೋಲುವ ಬಲ ಬೈಟ್ಗಳು ಹೊಂದಿರುತ್ತವೆ.

265
00:21:34,700 --> 00:21:40,500
ನಾವು ಕುರಿತು ನೀವು ಮಾಹಿತಿ ಮತ್ತು ನಂತರ ಇಲ್ಲಿ, ಕೊನೆಯದಾಗಿ,, ನಾವು RGBTRIPLE typedef struct ಹೊಂದಿರುತ್ತವೆ.

266
00:21:40,500 --> 00:21:46,840
ನಾವು ಸಂಬಂಧಿಸಿದ rgbtBlue, ಹಸಿರು, ಮತ್ತು ಕೆಂಪು ಹೊಂದಿರುತ್ತವೆ.

267
00:21:48,210 --> 00:21:49,340
>> ಗ್ರೇಟ್. ಸರಿ.

268
00:21:49,340 --> 00:21:56,360
ಈಗ ನಾವು ಬಿಟ್ಮ್ಯಾಪ್ಗಳನ್ನು ಸ್ವಲ್ಪ ಅರ್ಥ, ನಾವು ಒಂದು ಕಡತ ಹೆಡರ್ ಎಂದು ಅರ್ಥ

269
00:21:56,360 --> 00:22:00,790
ಮತ್ತು ಅದನ್ನು ಮತ್ತು ಆ ನಂತರ ಸಂಬಂಧಿಸಿದ ಮಾಹಿತಿಯನ್ನು ಹೆಡರ್, ನಾವು ಆಸಕ್ತಿದಾಯಕ ವಿಷಯವನ್ನು ಹೊಂದಿಲ್ಲ

270
00:22:00,790 --> 00:22:05,110
ಬಣ್ಣಗಳು, ಮತ್ತು ಆ ಬಣ್ಣಗಳು RGBTRIPLE ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ

271
00:22:05,110 --> 00:22:12,710
ಮತ್ತು ಆ, ಪ್ರತಿಯಾಗಿ, ಹಸಿರು, ನೀಲಿ, ಮತ್ತು ಕೆಂಪು ಸಂಬಂಧಿಸಿದ ಮೂರು ಮೌಲ್ಯಗಳು.

272
00:22:12,710 --> 00:22:17,270
>> ಈಗ, ನಾವು ಬಗ್ಗೆ ಸ್ವಲ್ಪ ಕೊಡು ಯೋಚಿಸಿರುವಿರಿ ರೀತಿಯ ಮಾಡಬಹುದು.

273
00:22:17,270 --> 00:22:20,130
ಕ್ಷಮಿಸಿ. ವೊಡುನಿಟ್ ಬಗ್ಗೆ ಯೋಚಿಸಿ.

274
00:22:20,130 --> 00:22:25,750
ನಮ್ಮ ಸುಳಿವನ್ನು ಕಡತ ಮಾಡಿಕೊಂಡು, ನಂತರ ನಾವು ಮಾಡಲು ಬಯಸುವ ಇದು ಪಿಕ್ಸೆಲ್ ಮೂಲಕ ಪಿಕ್ಸೆಲ್ ನಲ್ಲಿ ಓದಲು

275
00:22:25,750 --> 00:22:33,860
ನಾವು ಓದಬಹುದಾದ ರೂಪದಲ್ಲಿ ಅದನ್ನು ಔಟ್ಪುಟ್ ಇದರಿಂದ ನಂತರ ಹೇಗಾದರೂ ಆ ಪಿಕ್ಸೆಲ್ಗಳು ಬದಲಾಯಿಸಬಹುದು.

276
00:22:33,860 --> 00:22:41,020
ಮತ್ತು ಆದ್ದರಿಂದ ಔಟ್ಪುಟ್ ಮಾಡಲು, ನಾವು verdict.bmp ಫೈಲ್ ಆಗಿ ಪಿಕ್ಸೆಲ್ ಮೂಲಕ ಪಿಕ್ಸೆಲ್ ಬರೆಯಲು ನೀನು.

277
00:22:41,020 --> 00:22:45,120
ಹಾಗೆ ಮಾಡಲು ಸಾಕಷ್ಟು ಭಾಸವಾಗುತ್ತದೆ. ನಾವು ಅರ್ಥ.

278
00:22:45,120 --> 00:22:49,860
ಆದ್ದರಿಂದ ನಾವು ಮಾಡಿದ ನಾವು ನಿಜವಾಗಿ ನಿಮಗೆ ಒದಗಿಸಲಾದ ಹೊಂದಿದೆ copy.c.

279
00:22:49,860 --> 00:22:57,610
ಏನು copy.c ಮಾಡುತ್ತದೆ ಕೇವಲ ನಿರ್ದಿಷ್ಟ ಬಿಟ್ಮ್ಯಾಪ್ ಕಡತದ ನಿಖರ ಪ್ರತಿಯನ್ನು ಮಾಡುತ್ತದೆ ಮತ್ತು ಅದು ಹೊರತರುವ ಹೊಂದಿದೆ.

280
00:22:57,610 --> 00:23:01,900
ಆದ್ದರಿಂದ ಈ ಈಗಾಗಲೇ, ನೀವು ಕಡತವನ್ನು ತೆರೆಯುತ್ತದೆ ಪಿಕ್ಸೆಲ್ ಮೂಲಕ ಪಿಕ್ಸೆಲ್ ರಲ್ಲಿ ಓದುತ್ತದೆ

281
00:23:01,900 --> 00:23:04,510
ಮತ್ತು ನಂತರ ಒಂದು ಔಟ್ಪುಟ್ ಫೈಲ್ ಆಗಿ ಅದನ್ನು ಬರೆಯುತ್ತಾರೆ.

282
00:23:04,510 --> 00:23:07,080
>> ಅವರ ಆ ಒಂದು ಗಮನಿಸೋಣ.

283
00:23:13,390 --> 00:23:18,290
ಈ, ಸರಿಯಾದ ಬಳಕೆಯ ಖಾತರಿ ಇದೆ

284
00:23:18,290 --> 00:23:22,640
ಇಲ್ಲಿ ಕಡತದ ಗೆಟ್ಟಿಂಗ್.

285
00:23:22,640 --> 00:23:29,940
ಏನು ಮಾಡುತ್ತದೆ, ಇದನ್ನು ನಾವು ಇಲ್ಲಿ infile ರಲ್ಲಿ ಜಾರಿಗೆ ನಾವು ಏನು ಎಂದು ಇನ್ಪುಟ್ ಫೈಲ್ ಹೊಂದಿಸುತ್ತದೆ ಆಗಿದೆ

286
00:23:29,940 --> 00:23:34,750
ಇದು ನಮ್ಮ ಎರಡನೇ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟನ್ನು ಹೊಂದಿದೆ.

287
00:23:34,750 --> 00:23:37,640
ನಾವು ಕಡತವನ್ನು ತೆರೆಯಲು ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಪರಿಶೀಲಿಸುತ್ತದೆ.

288
00:23:38,960 --> 00:23:44,860
ನಾವು ಇಲ್ಲಿ ಹೊಸ outfile ಮಾಡಬಹುದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಪರಿಶೀಲಿಸುತ್ತದೆ.

289
00:23:45,630 --> 00:23:53,270
ನಂತರ ಈ ಇಲ್ಲಿ ಏನು, ಇದು ಮೂಲತಃ ಆರಂಭದಿಂದಲೂ ಬಿಟ್ಮ್ಯಾಪ್ ಕಡತವನ್ನು ಓದುವ ಆರಂಭವಾಗುತ್ತದೆ.

290
00:23:53,270 --> 00:23:56,700
ಪ್ರಾರಂಭದಲ್ಲಿ, ನಾವು ತಿಳಿದಿರುವಂತೆ, BITMAPFILEHEADER ಒಳಗೊಂಡಿದೆ

291
00:23:56,700 --> 00:24:03,200
ಮತ್ತು ಆದ್ದರಿಂದ ಬಿಟ್ಗಳು ಆ ಅನುಕ್ರಮಗಳನ್ನು ನೇರವಾಗಿ BITMAPFILEHEADER ತುಂಬಲು ಕಾಣಿಸುತ್ತದೆ.

292
00:24:03,200 --> 00:24:07,940
ಆದ್ದರಿಂದ ಇಲ್ಲಿರುವುದು ಎಂದು BITMAPFILEHEADER BF ಹೇಳುತ್ತಾರೆ -

293
00:24:07,940 --> 00:24:13,150
ಆ ರೀತಿಯ BITMAPFILEHEADER ನಮ್ಮ ಹೊಸ ವೇರಿಯಬಲ್ ಇಲ್ಲಿದೆ -

294
00:24:13,150 --> 00:24:22,560
ನಾವು ದಿಕ್ಸೂಚಕ ಓದುವುದಕ್ಕೆ ಯಾವ BF ಒಳಗೆ ಇರಿಸಬೇಕಿರುವ ನೀನು, ಇದು ನಮ್ಮ infile ಹೊಂದಿದೆ.

295
00:24:22,560 --> 00:24:23,970
ನಾವು ಎಷ್ಟು ಓದಲು ಇಲ್ಲ?

296
00:24:23,970 --> 00:24:32,160
ನಾವು ಇಡೀ BITMAPFILEHEADER ಹೊಂದಿರುತ್ತವೆ ಅಗತ್ಯವಿದೆ ಎಷ್ಟು ಬೈಟ್ಗಳಲ್ಲಿ ಓದಲು.

297
00:24:32,160 --> 00:24:34,660
ಹಾಗೆಯೇ, ಆ ಮಾಹಿತಿಯನ್ನು ಹೆಡರ್ ನಾವು ಏನು ಇಲ್ಲಿದೆ.

298
00:24:34,660 --> 00:24:39,010
ಆದ್ದರಿಂದ ನಾವು, infile ನಮ್ಮ ಕಡತದ ಉದ್ದಕ್ಕೂ ಮುಂದುವರೆದಿದೆ ನೀವು

299
00:24:39,010 --> 00:24:44,360
ಮತ್ತು ನಾವು ಆ ಬಿಟ್ಗಳು ಮತ್ತು ಬೈಟ್ಗಳು ಓದುವ ನೀವು ಮತ್ತು ನಾವು ನೇರವಾಗಿ ಅವುಗಳನ್ನು ಪ್ಲಗಿಂಗ್ ನೀವು

300
00:24:44,360 --> 00:24:47,880
ನಾವು ಮಾಡುವ ನೀವು ಅಸ್ಥಿರ ಈ ಸಂದರ್ಭಗಳಲ್ಲಿ ಒಳಗೆ.

301
00:24:49,370 --> 00:24:53,800
ಇಲ್ಲಿ ನಾವು ಬಿಟ್ಮ್ಯಾಪ್ ಒಂದು ಬಿಟ್ಮ್ಯಾಪ್ ಎಂದು ಖಚಿತವಾಗಿ ನೀವು ಮಾಡುತ್ತಿರುವಿರಿ.

302
00:24:57,670 --> 00:25:01,030
>> ಈಗ ನಾವು, ಒಂದು outfile ಹೊಂದಿವೆ?

303
00:25:01,030 --> 00:25:04,420
ನಾವು ರಚಿಸುವಾಗ ಇದು ನಿಂತಿದೆ ಆದ್ದರಿಂದ, ಇದು ಖಾಲಿ ಇಲ್ಲಿದೆ.

304
00:25:04,420 --> 00:25:07,710
ನಾವು ಮೂಲತಃ ಆರಂಭದಿಂದ ಹೊಸ ಬಿಟ್ಮ್ಯಾಪ್ ರಚಿಸಲು ಹೊಂದಿರುತ್ತವೆ.

305
00:25:07,710 --> 00:25:12,280
ನಾವು ಹಾಗೆ ನಾವು ಫೈಲ್ ಹೆಡರ್ ನಲ್ಲಿ ನಕಲಿಸಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಹೊಂದಿದೆ

306
00:25:12,280 --> 00:25:16,850
ಮತ್ತು ಕೇವಲ infile ರೀತಿಯ ಮಾಹಿತಿಯನ್ನು ಹೆಡರ್ ಹೊಂದಿದೆ.

307
00:25:16,850 --> 00:25:22,850
ಮತ್ತು BF ವೇರಿಯಬಲ್ ಎಂದು ನೆನಪಿಡಿ - ನಾವು ಏನು ನಾವು ಬರೆಯಲು ಆಗಿದೆ

308
00:25:22,850 --> 00:25:29,300
ರೀತಿಯ BITMAPFILEHEADER ನ, ನಾವು ಏನು ನಾವು ವಿಷಯವನ್ನು ಬಳಸಲು ಆದ್ದರಿಂದ

309
00:25:29,300 --> 00:25:34,980
outfile ಆಗಿ ಬರೆಯಲು.

310
00:25:36,550 --> 00:25:38,510
ಇಲ್ಲಿ, ನಾವು ಪ್ಯಾಡಿಂಗ್ ಬಗ್ಗೆ ಮಾತನಾಡಿದರು ನೆನಪಿಡಿ

311
00:25:38,510 --> 00:25:47,820
ನಾವು ಹೊಂದಿರುವ ಪಿಕ್ಸೆಲ್ಗಳು ಪ್ರಮಾಣವನ್ನು 4 ಒಂದು ಬಹು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಪ್ರಮುಖ ಹೇಗೆ.

312
00:25:47,820 --> 00:25:52,790
ಈ ನೀವು ಎಷ್ಟು ಪ್ಯಾಡಿಂಗ್ ಲೆಕ್ಕಹಾಕಲು ಒಂದು ಬಹಳ ಉಪಯುಕ್ತ ಸೂತ್ರವು

313
00:25:52,790 --> 00:25:57,670
ನಿಮ್ಮ ಕಡತ ಅಗಲ ನೀಡಲಾಗಿದೆ.

314
00:25:57,670 --> 00:26:04,120
ನಾನು ನೀವು ಹುಡುಗರಿಗೆ copy.c ನಾವು ಪ್ಯಾಡಿಂಗ್ ಗಣಿಸಲು ಸೂತ್ರವನ್ನು ಹೊಂದಿರುವ ನೆನಪಿಡುವ ಬಯಸುವ.

315
00:26:04,120 --> 00:26:07,970
ಸರಿ? ಆದ್ದರಿಂದ ಎಲ್ಲರೂ ನೆನಪು. ಗ್ರೇಟ್.

316
00:26:07,970 --> 00:26:14,050
ಆದ್ದರಿಂದ copy.c ಏನು ಮುಂದಿನ ಇದು ಪರಿಶೀಲನರೇಖೆಗಳು ಎಲ್ಲಾ ಮೇಲೆ iterates ಹೊಂದಿದೆ.

317
00:26:14,050 --> 00:26:23,730
ಇದು ಮೊದಲ ಸಾಲುಗಳಲ್ಲಿ ಸಾಗುವ ಮತ್ತು ನಂತರ ಅದನ್ನು ಓದುವ ಪ್ರತಿ ಟ್ರಿಪಲ್ ಸಂಗ್ರಹಿಸುತ್ತದೆ

318
00:26:23,730 --> 00:26:26,920
ತದನಂತರ outfile ಅದನ್ನು ಬರೆಯುತ್ತಾರೆ.

319
00:26:26,920 --> 00:26:33,120
ಆದ್ದರಿಂದ ಇಲ್ಲಿ ನಾವು ಒಂದು ಸಮಯದಲ್ಲಿ ಕೇವಲ ಒಂದೇ RGB ಟ್ರಿಪಲ್ ಓದುವ ನೀವು

320
00:26:33,120 --> 00:26:39,860
ತದನಂತರ outfile ಆಗಿ ಅದೇ ಟ್ರಿಪಲ್ ಇರಿಸಿದೆ.

321
00:26:41,120 --> 00:26:48,340
ಟ್ರಿಕಿ ಭಾಗವಾಗಿ, ಪ್ಯಾಡಿಂಗ್ ಒಂದು RGB ತ್ರಿವಳಿ ಎಂದು ಹೊಂದಿದೆ

322
00:26:48,340 --> 00:26:55,200
ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು RGB ಮೂರು ಆ ಪ್ಯಾಡಿಂಗ್ ಪ್ರಮಾಣವನ್ನು ಓದಲು ಸಾಧ್ಯವಿಲ್ಲ.

323
00:26:55,200 --> 00:27:01,460
ನಾವು ಮಾಡಬೇಕು ವಾಸ್ತವವಾಗಿ ಕೇವಲ, ನಮ್ಮ ಫೈಲ್ ಸ್ಥಾನವನ್ನು ಸೂಚಕ ಸರಿಸಲು ನಮ್ಮ ಕರ್ಸರ್ ಸರಿಸು ಇದೆ

324
00:27:01,460 --> 00:27:06,840
ಮುಂದಿನ ಸಾಲು ಎಂಬುದನ್ನು ಎಲ್ಲಾ ಪ್ಯಾಡಿಂಗ್ ಮೇಲೆ ತೆರಳಿ ರೀತಿಯ ಗೆ.

325
00:27:06,840 --> 00:27:12,990
ತದನಂತರ ಈ ಏನು ನಕಲನ್ನು ನೀವು ಪ್ಯಾಡಿಂಗ್ ಸೇರಿಸಲು ಬಯಸಬಹುದು ಹೇಗೆ ನೀವು ತೋರಿಸುತ್ತದೆ.

326
00:27:12,990 --> 00:27:14,990
ಆದ್ದರಿಂದ, ನಾವು ಎಷ್ಟು ಪ್ಯಾಡಿಂಗ್ ಲೆಕ್ಕ ಮಾಡಿದ

327
00:27:14,990 --> 00:27:18,220
ಆದ್ದರಿಂದ ನಾವು 0 ಸೆ ನ ಪ್ಯಾಡಿಂಗ್ ಸಂಖ್ಯೆ ಅಗತ್ಯವಿದೆ ಎಂದರ್ಥ.

328
00:27:18,220 --> 00:27:24,510
ಏನು ಮಾಡುತ್ತದೆ ನಮ್ಮ outfile ಆಗಿ 0 ಸೆ ನ ಪ್ಯಾಡಿಂಗ್ ಸಂಖ್ಯೆ ಈಡಾಗಿಸುವ ಲೂಪ್ ಒಂದು ಆಗಿದೆ.

329
00:27:24,510 --> 00:27:31,170
ತದನಂತರ ಅಂತಿಮವಾಗಿ, ನೀವು ಎರಡೂ ಕಡತಗಳನ್ನು ಮುಚ್ಚಿ. ನೀವು infile ಹಾಗೆಯೇ outfile ಮುಚ್ಚಿ.

330
00:27:31,170 --> 00:27:34,870
>> ಆದ್ದರಿಂದ ಹವ್ copy.c ಕೃತಿಗಳು

331
00:27:34,870 --> 00:27:37,430
ಮತ್ತು ಬಹಳ ಉಪಯುಕ್ತ ಎಂದು ವಿಶೇಷವೇನು.

332
00:27:39,720 --> 00:27:43,750
ಬದಲಿಗೆ ಕೇವಲ ವಾಸ್ತವವಾಗಿ ನೇರವಾಗಿ ನಕಲು ಮತ್ತು ಅಂಟಿಸಲು ಆಫ್

333
00:27:43,750 --> 00:27:46,800
ಅಥವಾ ಅದನ್ನು ನೋಡಿ ಮತ್ತು ನೀವು ಬಯಸುವ ಯಾವುದೇ ನಮೂದಿಸುವುದನ್ನು

334
00:27:46,800 --> 00:27:49,440
ನೀವು, ಟರ್ಮಿನಲ್ ಈ ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ ಬಯಸಬಹುದು

335
00:27:49,440 --> 00:27:54,520
ಒಂದು ಹೊಸ ಕಡತವನ್ನು ರಚಿಸುತ್ತದೆ CP copy.c whodunit.c, whodunit.c,

336
00:27:54,520 --> 00:27:58,330
ಆ ನಕಲು ಮಾಡುವಂತೆ ನಿಖರ ಅದೇ ವಿಷಯವನ್ನು ಒಳಗೊಂಡಿದೆ.

337
00:27:58,330 --> 00:28:03,880
ಆದ್ದರಿಂದ ನಾವು ಏನು ಮಾಡಬಹುದು ಚೌಕಟ್ಟನ್ನು ಮಾಹಿತಿ ಮೇಲೆ ನಿರ್ಮಿಸಲು ಮತ್ತು ಸಂಪಾದಿಸಲು ಆ ಬಳಸುತ್ತವೆ

338
00:28:03,880 --> 00:28:06,900
ನಮ್ಮ ವೊಡುನಿಟ್ ಕಡತ.

339
00:28:08,500 --> 00:28:14,670
>> ಈ ನಮ್ಮ ಗೆ-DOS ವೊಡುನಿಟ್ ಫಾರ್ ಮಾಡಲು, ಆದರೆ ಏನು copy.c ಮಾಡುತ್ತದೆ

340
00:28:14,670 --> 00:28:16,730
ವಾಸ್ತವವಾಗಿ ನಮಗೆ ಅವುಗಳನ್ನು ಅತ್ಯಂತ ನೋಡಿಕೊಳ್ಳುತ್ತಾರೆ ಇದೆ.

341
00:28:16,730 --> 00:28:21,900
ನಾವು ಮುಂದಿನ ಮಾಡಬೇಕಾದ್ದು ಎಲ್ಲಾ ಅಗತ್ಯವಿರುವ ಪಿಕ್ಸೆಲ್ಗಳು ಬದಲಾವಣೆ

342
00:28:21,900 --> 00:28:25,920
ವಾಸ್ತವವಾಗಿ ಕಡತ ಓದಬಲ್ಲ ಮಾಡಲು.

343
00:28:25,920 --> 00:28:32,960
ರೀತಿಯ RGBTRIPLE ಒಂದು ನಿರ್ದಿಷ್ಟ ವೇರಿಯಬಲ್ ಹಾಗೆ, ಟ್ರಿಪಲ್ ನೀಡಿರುವ ಪಿಕ್ಸೆಲ್ಗೂ ನೆನಪಿಡಿ,

344
00:28:32,960 --> 00:28:35,990
ನೀವು ನೀಲಿ, ಹಸಿರು, ಮತ್ತು ಕೆಂಪು ಮೌಲ್ಯಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು.

345
00:28:35,990 --> 00:28:38,670
ಆ HANDY ಬರುತ್ತವೆ ಇನ್ನು ನೀವು ಅವುಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು ವೇಳೆ ಏಕೆಂದರೆ,

346
00:28:38,670 --> 00:28:41,770
ನೀವು ಸಹ, ಅವುಗಳನ್ನು ಪರಿಶೀಲಿಸಿ ಎಂದರ್ಥ

347
00:28:41,770 --> 00:28:45,430
ಮತ್ತು ನೀವು ಅವುಗಳನ್ನು ಬದಲಾಯಿಸಬಹುದು ಎಂದು.

348
00:28:45,430 --> 00:28:49,430
>> ಆದ್ದರಿಂದ ನಾವು ನಮ್ಮ ಕೆಂಪು ಭೂತಗನ್ನಡಿಯಿಂದ ಉದಾಹರಣೆಗೆ ಮತ್ತೆ ಹೋದಾಗ

349
00:28:49,430 --> 00:28:53,390
ಮೂಲತಃ, ಎಂದು ನಮಗೆ ಶೋಧಕದ ಒಂದು ರೀತಿಯ ನಟನೆಯನ್ನು ಮಾಡಿದರು.

350
00:28:53,390 --> 00:28:58,160
ಹಾಗಾಗಿ ನಾವು ಬಯಸುವ ನಾವು ಒಳಬರುತ್ತಿದೆ ಎಂದು ಮೂರು ಎಲ್ಲಾ ಫಿಲ್ಟರ್ ಬಯಸುವ ಆಗಿದೆ

351
00:28:58,160 --> 00:29:01,240
ಇದನ್ನು ಮಾಡಲು ಅನೇಕ ಮಾರ್ಗಗಳಿವೆ.

352
00:29:01,240 --> 00:29:07,100
ಮೂಲಭೂತವಾಗಿ, ನೀವು ಬಯಸುವ ಶೋಧಕದ ಯಾವುದೇ ರೀತಿಯ ಮಾಡಬಹುದು.

353
00:29:07,100 --> 00:29:09,890
ಬಹುಶಃ ನೀವು ಎಲ್ಲಾ ಕೆಂಪು ಪಿಕ್ಸೆಲ್ಗಳು ಬದಲಾಯಿಸಲು ಬಯಸುವ

354
00:29:09,890 --> 00:29:13,570
ಅಥವಾ ಬಹುಶಃ ನೀವು ಬೇರೆ ಬಣ್ಣಕ್ಕೆ ಬೇರೆ ಬಣ್ಣ ಪಿಕ್ಸೆಲ್ ಬದಲಾಯಿಸಲು ಬಯಸುವ.

355
00:29:13,570 --> 00:29:15,400
ಅದು ನಿಮಗೆ ಬಿಟ್ಟಿದ್ದು.

356
00:29:15,400 --> 00:29:19,580
ನೀವು ಪಿಕ್ಸೆಲ್ ಏನು ಬಣ್ಣವಾಗಿದೆ ಪರಿಶೀಲಿಸಬಹುದು ನೆನಪಿಡಿ

357
00:29:19,580 --> 00:29:23,000
ನೀವು ಮೂಲಕ ನೀನು ಮತ್ತು ನಂತರ ನೀವು ಇದನ್ನು ಬದಲಾಯಿಸಬಹುದು.

358
00:29:24,410 --> 00:29:26,420
>> ಸರಿ. ಆದ್ದರಿಂದ ವೊಡುನಿಟ್ ಇಲ್ಲಿದೆ.

359
00:29:26,420 --> 00:29:32,760
ಒಮ್ಮೆ ನೀವು ವೊಡುನಿಟ್ ರನ್, ನೀವು ಅಪರಾಧದ ಅಪರಾಧಿ ಯಾರು ಗೊತ್ತು ಮಾಡುತ್ತೇವೆ.

360
00:29:32,760 --> 00:29:35,540
>> ಈಗ ನಾವು ಮರುಗಾತ್ರಗೊಳಿಸಿ ಹೋಗಲು ನೀನು.

361
00:29:35,540 --> 00:29:37,990
ನಾವು ಇನ್ನೂ ಬಿಟ್ಮ್ಯಾಪ್ಗಳನ್ನು ವ್ಯವಹರಿಸುವಾಗ ಎಂದು ನೀನು.

362
00:29:37,990 --> 00:29:40,750
ನಾವು ಹೊಂದಿದೆ ಮಾಡಲು ನೀನು ನಾವು ಇನ್ಪುಟ್ ಬಿಟ್ಮ್ಯಾಪ್ ಹೊಂದಿರುವ ನೀನು

363
00:29:40,750 --> 00:29:45,890
ಮತ್ತು ನಾವು ಹಲವು ಪಾಸ್ ಮತ್ತು ನಂತರ outfile ಬಿಟ್ಮ್ಯಾಪ್ ಪಡೆಯಲು ನೀನು

364
00:29:45,890 --> 00:29:51,380
ಮೂಲಭೂತ N ಮಾಪನ ನಮ್ಮ infile ಎಲ್ಲಿ.

365
00:29:54,670 --> 00:30:01,450
ನನ್ನ ಫೈಲ್ ಕೇವಲ ಒಂದು ಪಿಕ್ಸೆಲ್ ದೊಡ್ಡದಾಗಿದೆ ಸೇ.

366
00:30:01,450 --> 00:30:09,100
ನನ್ನ N 3 3, ಸ್ಕೇಲಿಂಗ್ ಎಂದು ನಂತರ, ನಂತರ ನಾನು, ಪಟ್ಟು ಪಿಕ್ಸೆಲ್ N ಸಂಖ್ಯೆ ಪುನರಾವರ್ತಿಸಲು ಎಂದು

367
00:30:09,100 --> 00:30:14,410
ಆದ್ದರಿಂದ 3 ಬಾರಿ, ಮತ್ತು ನಂತರ ಕೂಡ 3 ಬಾರಿ ಅದನ್ನು ಅಳೆಯಲು.

368
00:30:14,410 --> 00:30:17,840
ನೀವು ನಾನು ಎಂದು ಅಡ್ಡಲಾಗಿ ಲಂಬವಾಗಿ ಅಲ್ಲದೇ ಅದನ್ನು ಅಳೆಯುವುದು ನಾನು ನೋಡಿ.

369
00:30:17,840 --> 00:30:19,680
>> ತದನಂತರ ಇಲ್ಲಿ ಒಂದು ಉದಾಹರಣೆ.

370
00:30:19,680 --> 00:30:27,590
ನೀವು N = 2, ನೀವು ಮೊದಲು ನೀಲಿ ಪಿಕ್ಸೆಲ್ ಎರಡು ಬಾರಿ ಅಲ್ಲಿ ಪುನರಾವರ್ತಿತ ಎಂದು ನೋಡಿ

371
00:30:27,590 --> 00:30:30,930
ಅಡ್ಡಲಾಗಿ ಎರಡು ಬಾರಿ ಲಂಬವಾಗಿ ಮತ್ತು.

372
00:30:30,930 --> 00:30:38,040
ಮತ್ತು ನಂತರ ಮುಂದುವರಿಯುತ್ತದೆ, ಮತ್ತು ಆದ್ದರಿಂದ ನೀವು ಎರಡು ನಿಮ್ಮ ಮೂಲ ಚಿತ್ರದ ನೇರ ಸ್ಕೇಲಿಂಗ್ ಹೊಂದಿರುತ್ತವೆ.

373
00:30:40,920 --> 00:30:47,600
>> ನಾವು ಈ ವಿವರ ಸೂಡೊಕೋಡ್ಗಳನ್ನು ಗೆ ವೇಳೆ ಆದ್ದರಿಂದ, ನಾವು ಕಡತವನ್ನು ತೆರೆಯಲು ಬಯಸುವ.

374
00:30:47,600 --> 00:30:49,880
ನಂತರ, ನಾವು ಇಲ್ಲಿ ಹಿಂತಿರುಗಿ ವೇಳೆ ತಿಳಿಸುವ

375
00:30:49,880 --> 00:30:54,540
ನಾವು outfile ಸಂಬಂಧಿಸಿದ ಅಗಲ infile ಸಂಬಂಧಿಸಿದ ಅಗಲ ಭಿನ್ನವಾಗಿರಬೇಕು ಹೋಗುವ ಎಂದು ನೋಡಿ.

376
00:30:54,540 --> 00:30:56,130
ಎಂದು ಅರ್ಥ ಏನು?

377
00:30:56,130 --> 00:31:01,230
ನಮ್ಮ ಹೆಡರ್ ಮಾಹಿತಿಯನ್ನು ಬದಲಾಯಿಸಲು ಹೋಗುವ ಅಂದರೆ.

378
00:31:01,230 --> 00:31:03,790
ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಮಾಡಲು ಬಯಸುವಿರಿ, ಹೆಡರ್ ಮಾಹಿತಿಯನ್ನು ಅಪ್ಡೇಟ್ ಆಗಿದೆ

379
00:31:03,790 --> 00:31:11,820
ನೀವು copy.c ಚೌಕಟ್ಟಿನೊಳಗೆ ಕಾರ್ಯ ಮಾಡಿದಲ್ಲಿ ನಾವು ಕಡತಗಳಲ್ಲಿ ಓದಿದಾಗ ಎಂದು ತಿಳಿದಿದ್ದ,

380
00:31:11,820 --> 00:31:17,570
ನಾವು ಈಗಾಗಲೇ ಗಾತ್ರ ಏನು ಸೂಚಿಸುತ್ತದೆ ಮತ್ತು ವಿಷಯಗಳನ್ನು ಒಂದು ವೇರಿಯೇಬಲ್ ಹೊಂದಿರುತ್ತವೆ.

381
00:31:17,570 --> 00:31:24,060
ಹಾಗೆ ಒಮ್ಮೆ ನೀವು ಏನು ಬಯಸಬಹುದು ಆ ನಿರ್ದಿಷ್ಟ ಅಸ್ಥಿರ ಬದಲಾವಣೆ, ಹೊಂದಿಲ್ಲ.

382
00:31:24,060 --> 00:31:29,380
ನೀವು struct ಹೊಂದಿದ್ದರೆ ನೀವು ಒಳಗೆ ಅಸ್ಥಿರ ಪ್ರವೇಶಿಸಲು ಹೇಗೆ, ನೆನಪಿಡಿ.

383
00:31:29,380 --> 00:31:32,080
ನೀವು ಬಲ, ಡಾಟ್ ಆಯೋಜಕರು ಬಳಸಲು?

384
00:31:32,080 --> 00:31:36,420
ಆ ಬಳಸಿಕೊಂಡು ಆದ್ದರಿಂದ, ನೀವು ಹೆಡರ್ ಮಾಹಿತಿಯನ್ನು ಬದಲಾಯಿಸಲು ಅಗತ್ಯವಿದೆ ಎಂದು ತಿಳಿದಿದೆ.

385
00:31:36,480 --> 00:31:41,030
ಇಲ್ಲಿ ಕೇವಲ ನಿಮ್ಮ ಫೈಲ್ ಬದಲಾಗುತ್ತಿರುವ ಹೋಗುವುದಾಗಿ ವಾಸ್ತವ ಅಂಶಗಳ ಪಟ್ಟಿ ಇಲ್ಲಿದೆ.

386
00:31:41,030 --> 00:31:45,180
ಕಡತ ಗಾತ್ರ, ಚಿತ್ರ, ಮತ್ತು ಅಗಲ ಮತ್ತು ಎತ್ತರ ಬದಲಾಗುತ್ತಿರುವ ಏರಲಿದೆ.

387
00:31:45,180 --> 00:31:50,080
ಆದ್ದರಿಂದ, ಬಿಟ್ಮ್ಯಾಪ್ಗಳನ್ನು ನಕ್ಷೆ ಹಿಂದಕ್ಕೆ ಹೋಗಿ

388
00:31:50,080 --> 00:31:57,730
ಇದು ಕಡತ ಹೆಡರ್ ಅಥವಾ ಮಾಹಿತಿಯನ್ನು ಹೊಂದಿರುವ ಮಾಹಿತಿಯನ್ನು ಹೆಡರ್ ನ ಎಂಬುದನ್ನು ನೋಡಲು

389
00:31:57,730 --> 00:32:00,920
ಮತ್ತು ನಂತರ ಬೇಕಾದ ಬದಲಾಯಿಸಬಹುದು.

390
00:32:05,010 --> 00:32:12,470
ಮತ್ತೆ, CP copy.c resize.c ಹೇಳುತ್ತಾರೆ.

391
00:32:12,470 --> 00:32:19,270
ಆ resize.c ಈಗ ನಕಲನ್ನು ಒಳಗೆ ಹೊಂದಿತ್ತು ಎಂದು ಎಲ್ಲವನ್ನೂ ಹೊಂದಿರುವ ಅರ್ಥ

392
00:32:19,270 --> 00:32:24,490
ನಕಲನ್ನು ನಮಗೆ ಪಿಕ್ಸೆಲ್ ಪ್ರತಿ scanline ಪಿಕ್ಸೆಲ್ ಗೆ ಓದುವ ರೀತಿಯಲ್ಲಿ ಒದಗಿಸುತ್ತದೆ ಏಕೆಂದರೆ.

393
00:32:24,490 --> 00:32:29,860
ಈಗ ಹೊರತುಪಡಿಸಿ, ಬದಲಿಗೆ ನಾವು ವೊಡುನಿಟ್ ಮಾಡಿದಂತೆಯೇ ನಂತಹ ಕೇವಲ ಮೌಲ್ಯಗಳು ಬದಲಾಗುವ,

394
00:32:29,860 --> 00:32:37,980
ನಾವು ಮಾಡಲು ಬಯಸುವ ನಾವು ಅನೇಕ ಪಿಕ್ಸೆಲ್ಗಳಲ್ಲಿ ಬರೆಯಲು ಬಯಸುವ ಆಗಿದೆ

395
00:32:37,980 --> 00:32:43,580
ಎಲ್ಲಿಯವರೆಗೆ ನಮ್ಮ N 1 ಹೆಚ್ಚಾಗಿರುವುದರಿಂದ.

396
00:32:43,580 --> 00:32:47,110
>> ನಂತರ ನಾವು ಮಾಡಲು ಬಯಸುವ, ನಾವು N ಅದಕ್ಕೆ ಅಡ್ಡಲಾಗಿ ಇದು ವಿಸ್ತಾರಗೊಳಿಸಬಹುದು ಬಯಸುವ ಆಗಿದೆ

397
00:32:47,110 --> 00:32:50,490
ಹಾಗೆಯೇ N ಮೂಲಕ ಲಂಬವಾಗಿ ಇದು ವಿಸ್ತಾರಗೊಳಿಸಬಹುದು.

398
00:32:50,490 --> 00:32:52,710
ಹೇಗೆ ನಾವು ಏನು ಮಾಡಬಹುದು?

399
00:32:52,710 --> 00:32:56,890
ನಿಮ್ಮ N 2 ಸೇ ಮತ್ತು ಈ ನಿರ್ದಿಷ್ಟ infile ಹೊಂದಿರುತ್ತವೆ.

400
00:32:56,890 --> 00:32:58,730
ನಿಮ್ಮ ಕರ್ಸರ್, ಮೊದಲ ಒಂದು ಆರಂಭವಾಗುವುದು ಹಾಕುತ್ತದೆ

401
00:32:58,730 --> 00:33:03,530
N 2 ವೇಳೆ ಮತ್ತು ನೀವು ಏನು ಮಾಡಲು ಬಯಸುವ, ಆ 2 ರಲ್ಲಿ ಮುದ್ರಿಸಲು ಬಯಸುವ.

402
00:33:03,530 --> 00:33:05,490
ಆದ್ದರಿಂದ ನೀವು ಆ 2 ರಲ್ಲಿ ಮುದ್ರಿಸಿ.

403
00:33:05,490 --> 00:33:10,830
ನಂತರ ನಿಮ್ಮ ಕರ್ಸರ್, ಕೆಂಪು ಒಂದು ಇದು ಮುಂದಿನ ಪಿಕ್ಸೆಲ್, ಸರಿಸಲು ಹೋಗುತ್ತದೆ

404
00:33:10,830 --> 00:33:18,400
ಮತ್ತು ಇದು ಮೊದಲು ಆಟದ ಮೇಲೆ ಸೇರಿಸುವುದರಿಂದ, ಆ ಕೆಂಪು ಬಣ್ಣದವು 2 ಮುದ್ರಿಸುತ್ತದೆ ಹೋಗುವುದಿಲ್ಲ.

405
00:33:18,400 --> 00:33:26,280
ನಂತರ ಕರ್ಸರ್ ಮುಂದಿನ ಪಿಕ್ಸೆಲ್ ಸರಿಸಲು ಮತ್ತು ಆ 2 ರಲ್ಲಿ ರಚಿಸುತ್ತೇನೆ.

406
00:33:26,280 --> 00:33:37,180
ನೀವು ಇಲ್ಲಿಯೇ ಈ ಏನು copy.c ಚೌಕಟ್ಟನ್ನು, ಮತ್ತೆ ನೋಡಿದರೆ

407
00:33:37,180 --> 00:33:42,830
ಅದು RGB ತ್ರಿವಳಿ ತ್ರಿವಳಿ ಎಂಬ ಹೊಸ ವೇರಿಯಬಲ್ ಹೊಸ ಉದಾಹರಣೆಗೆ ಸೃಷ್ಟಿಸುತ್ತದೆ ಇದೆ.

408
00:33:42,830 --> 00:33:50,500
ಮತ್ತು ಇದನ್ನು ಓದುತ್ತದೆ ಇಲ್ಲಿ ಅದು infile 1 RGBTRIPLE ರಿಂದ ಓದುತ್ತದೆ

409
00:33:50,500 --> 00:33:53,470
ಮತ್ತು ಟ್ರಿಪಲ್ ವೇರಿಯಬಲ್ ಒಳಗೆ ಅದನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ.

410
00:33:53,470 --> 00:33:57,590
ಆದ್ದರಿಂದ ನೀವು ವಾಸ್ತವವಾಗಿ ನಿರ್ದಿಷ್ಟ ಪಿಕ್ಸೆಲ್ ಪ್ರತಿನಿಧಿಸುವ ಒಂದು ವೇರಿಯೇಬಲ್ ಹೊಂದಿರುತ್ತವೆ.

411
00:33:57,590 --> 00:34:05,290
ನಂತರ ನೀವು ಮಾಡಲು ಬಯಸಬಹುದು ಏನು, ಬರೆಯಲು ಯಾವಾಗ ಲೂಪ್ ಒಂದು ಆಗಿ fwrite ಹೇಳಿಕೆಯನ್ನು ಆವರಿಸು ಆಗಿದೆ

412
00:34:05,290 --> 00:34:11,080
ಎಂದು ಅಗತ್ಯವಿದೆ ಬಾರಿ ನಿಮ್ಮ outfile ಅದನ್ನು ಬರೆಯುತ್ತಾರೆ.

413
00:34:17,449 --> 00:34:20,100
ಸಾಕಷ್ಟು ಸರಳವಾಗಿದೆ.

414
00:34:20,200 --> 00:34:27,590
ಕೇವಲ ಮೂಲತಃ ಬರಹದ N ಅಡ್ಡಲಾಗಿ ಇದು ಅಳೆಯುವ ಬಾರಿ ಪುನರಾವರ್ತಿಸಿ.

415
00:34:27,590 --> 00:34:32,969
>> ಆದರೆ ನಾವು ನಮ್ಮ ಪ್ಯಾಡಿಂಗ್ ಬದಲಾಯಿಸಲು ಹೋಗುತ್ತದೆ ಎಂದು ನೆನಪಿಡುವ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ.

416
00:34:47,350 --> 00:34:53,020
ಮೊದಲು, ನಾವು ಉದ್ದ 3 ಏನೋ ತಿಳಿಸಿದ.

417
00:34:53,020 --> 00:35:00,130
ನಂತರ ನಾವು ಎಷ್ಟು ಪ್ಯಾಡಿಂಗ್ ರಲ್ಲಿ ಸೇರಿಸುವುದು? ಕೇವಲ ಒಂದು ಹೆಚ್ಚು 4 ಒಂದು ಬಹು ಮಾಡಲು.

418
00:35:00,130 --> 00:35:10,480
ಆದರೆ ನಾವು N = 2 ಈ ನಿರ್ದಿಷ್ಟ ಚಿತ್ರದ ಅಳೆಯುವುದು ನೀವು ಹೇಳಬಹುದು.

419
00:35:10,480 --> 00:35:16,300
ಆದ್ದರಿಂದ ಎಷ್ಟು ನೀಲಿ ಪಿಕ್ಸೆಲ್ಗಳು ನಾವು ಕೊನೆಯಲ್ಲಿ ಎಂದು? ನಾವು 6 ಹೊಂದಿರುತ್ತದೆ.

420
00:35:16,300 --> 00:35:21,470
1, 2, 3, 4, 5, 6. ಎಲ್ಲಾ ಸರಿ.

421
00:35:21,470 --> 00:35:26,580
6 4 ಒಂದು ಬಹು ಅಲ್ಲ. 4 ಹತ್ತಿರದ ಬಹು ಯಾವುದು? ಆ 8 ಎಂದು ವಿಶೇಷವೇನು.

422
00:35:26,580 --> 00:35:33,200
ನಾವು ನಿಜವಾಗಿಯೂ ಅಲ್ಲಿ ಪ್ಯಾಡಿಂಗ್ 2 ಅಕ್ಷರಗಳು ಉಳಿದಿವೆ ಎಂದು ನೀನು.

423
00:35:33,200 --> 00:35:38,720
>> ನಾವು ಪ್ಯಾಡಿಂಗ್ ಲೆಕ್ಕಹಾಕಲು ಒಂದು ಸೂತ್ರವನ್ನು ಹೊಂದಿದ್ದರೆ ಯಾರಾದರೂ ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಡಸ್

424
00:35:38,720 --> 00:35:41,350
ಮತ್ತು ಅಲ್ಲಿ ಎಂದು ಇರಬಹುದು?

425
00:35:41,350 --> 00:35:45,160
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ ಪ್ರತಿಕ್ರಿಯೆ] >> ಹೌದು, copy.c. ರೈಟ್.

426
00:35:45,160 --> 00:35:49,800
ನೀವು ಎಷ್ಟು ಪ್ಯಾಡಿಂಗ್ ಲೆಕ್ಕಹಾಕಲು copy.c ಒಂದು ಸೂತ್ರವಿಲ್ಲ

427
00:35:49,800 --> 00:35:53,810
ಬಿಟ್ಮ್ಯಾಪ್ ಚಿತ್ರದ ಒಂದು ನಿರ್ದಿಷ್ಟ ಅಗಲವನ್ನು ನೀಡಲಾಗಿದೆ.

428
00:35:53,810 --> 00:36:02,950
ನೀವು ಪ್ಯಾಡಿಂಗ್ ಒಂದು ನಿರ್ದಿಷ್ಟ ಪ್ರಮಾಣದಲ್ಲಿ ಸೇರಿಸುವ ಅಗತ್ಯವಿದೆ ಯಾವಾಗ ಆದ್ದರಿಂದ ವಿಶೇಷವೇನು ಎಂದು ಉಪಯೋಗಿಸಲು

429
00:36:02,950 --> 00:36:06,160
ವಾಸ್ತವವಾಗಿ ನೀವು ಸೇರಿಸಲು ಎಷ್ಟು ಪ್ಯಾಡಿಂಗ್ ಔಟ್ ಲೆಕ್ಕಾಚಾರ.

430
00:36:10,820 --> 00:36:15,850
ಆದರೆ ಒಂದು ಟಿಪ್ಪಣಿ, ಆದಾಗ್ಯೂ, ನೀವು ಸರಿಯಾಗಿ ಬಳಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬಯಸುತ್ತೇವೆ.

431
00:36:15,850 --> 00:36:21,410
ನೀವು ಮೂಲತಃ ಎರಡು ಬಿಟ್ಮ್ಯಾಪ್ ಇಮೇಜ್ಗಳನ್ನು ವ್ಯವಹರಿಸುವಾಗ ಎಂದು ನೀನು ಏಕೆಂದರೆ ಕೇವಲ ಜಾಗರೂಕರಾಗಿರಿ.

432
00:36:21,410 --> 00:36:23,410
ನೀವು ಸರಿಯಾದ ಒಂದು ಬಳಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬಯಸುತ್ತೇನೆ.

433
00:36:23,410 --> 00:36:26,820
ನೀವು outfile ಫಾರ್ ಪ್ಯಾಡಿಂಗ್ ಲೆಕ್ಕಾಚಾರ ಮಾಡಿದಾಗ, ನೀವು outfile ಅಗಲ ಬಳಸಲು ಬಯಸುವ

434
00:36:26,820 --> 00:36:29,860
ಮತ್ತು ಹಿಂದಿನ ಒಂದು ಅಗಲ.

435
00:36:29,860 --> 00:36:37,240
>> ಗ್ರೇಟ್. ಆ ರೀತಿಯ ಅಡ್ಡಲಾಗಿ ಇಡೀ ಬಿಟ್ಮ್ಯಾಪ್ ಚಿತ್ರ ಎಳೆಯುವ ನೋಡಿಕೊಳ್ಳುತ್ತಾರೆ.

436
00:36:37,240 --> 00:36:41,290
ಆದರೆ ನಾವು ಯಾವ ವಾಸ್ತವವಾಗಿ ಲಂಬವಾಗಿ ಅಲ್ಲದೇ ವ್ಯಾಪಿಸಿಲ್ಲ.

437
00:36:41,290 --> 00:36:48,760
ನಾವು ಸತತವಾಗಿ ನಕಲು ಮುಕ್ತಾಯಗೊಂಡ ಏಕೆಂದರೆ ಸ್ವಲ್ಪ ಚಾತುರ್ಯದ ಏರಲಿದೆ

438
00:36:48,760 --> 00:36:51,580
ಮತ್ತು ಸಾಲು ಬರೆಯುವುದು, ನಮ್ಮ ಕರ್ಸರ್ ಕೊನೆಯಲ್ಲಿ ಎಂದು ಹೋಗುತ್ತದೆ.

439
00:36:51,580 --> 00:36:56,210
ನಾವು ಮತ್ತೆ ಓದಲು ಹಾಗೆ, ಅದು ಮುಂದಿನ ಲೈನ್ ಗೆ ಓದಲು ವಿಶೇಷವೇನು.

440
00:36:56,210 --> 00:37:03,660
ಹಾಗಾಗಿ ನಾವು ನೀವು ಮತ್ತೆ ಆ ಸಾಲುಗಳನ್ನು ನಕಲು ಕೆಲವು ರೀತಿಯಲ್ಲಿ ಹೇಗೆ ರೀತಿಯ ಹೊಂದಿದೆ

441
00:37:03,660 --> 00:37:12,500
ಅಥವಾ ಆ ಸಾಲನ್ನು ತೆಗೆದುಕೊಂಡು ನಂತರ ಮತ್ತೆ ಪುನಃ ಕೇವಲ ರೀತಿಯ.

442
00:37:14,380 --> 00:37:17,940
ನಾನು ರೀತಿಯ ಪ್ರಸ್ತಾಪಿಸುತ್ತಾನೆ ಎಂದು, ಈ ಮಾಡಲು ಅನೇಕ ಮಾರ್ಗಗಳಿವೆ.

443
00:37:17,940 --> 00:37:23,040
ನೀವು ಮೂಲಕ ಹೋಗಿ ನಿರ್ದಿಷ್ಟ scanline ಮೂಲಕ ಓದುವ ಮಾಡಿದಾಗ ನೀವು ಏನು ಎಂದು ಹೇಳಲಾಗಿದೆ

444
00:37:23,040 --> 00:37:28,560
ಮತ್ತು ಅಗತ್ಯ ಬದಲಾವಣೆ, ನಂತರ ಅಂಗಡಿಯ ರೀತಿಯ ಒಂದು ವ್ಯೂಹದಲ್ಲಿ ಆ ಪಿಕ್ಸೆಲ್ಗಳ ಎಲ್ಲಾ.

445
00:37:28,560 --> 00:37:36,350
ನಂತರ ನೀವು ಮತ್ತೆ ಆ ಶ್ರೇಣಿಯನ್ನು ಮುದ್ರಿಸುತ್ತದೆ ಮಾಡಬೇಕಾಗುತ್ತದೆ ಎಂದು ತಿಳಿದಿರುವ,

446
00:37:36,350 --> 00:37:39,830
ಆದ್ದರಿಂದ ನೀವು ಹಾಗೆ ಮಾಡಲು ಬಳಸಿಕೊಳ್ಳಬಹುದು.

447
00:37:39,830 --> 00:37:44,500
ಇದನ್ನು ಮತ್ತೊಂದು ರೀತಿಯಲ್ಲಿ, ನೀವು ಒಂದು ಸಾಲಿನ ಕೆಳಗೆ ನಕಲಿಸಿ ಎಂದು ಹೇಳಲಾಗಿದೆ

448
00:37:44,500 --> 00:37:47,950
ನೀವು ಮತ್ತೆ ನಕಲಿಸಿ ಅಗತ್ಯವಿದೆ ಎಂದು ಅರ್ಥ, ಆದ್ದರಿಂದ ವಾಸ್ತವವಾಗಿ, ನಿಮ್ಮ ಕರ್ಸರ್ ಸರಿಸು

449
00:37:47,950 --> 00:37:50,950
ಮತ್ತು ಮಾದರಿಯನ್ನು fseek ಬಳಸುತ್ತಿರುವ ಹೋಗುವುದಿಲ್ಲ.

450
00:37:50,950 --> 00:37:56,410
ನೀವು ನಿಮ್ಮ ಕರ್ಸರ್ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಸರಿಸಲು ಮತ್ತು ನಂತರ ಮತ್ತೆ ನಕಲು ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪುನರಾವರ್ತಿಸುವಂತೆ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ.

451
00:37:56,410 --> 00:38:03,960
>> ನಮ್ಮ ಸ್ಕೇಲಿಂಗ್ ಸಂಖ್ಯೆ n ವೇಳೆ ಆದ್ದರಿಂದ, ನಂತರ ಎಷ್ಟು ಬಾರಿ ನಾವು ಹಿಂದಕ್ಕೆ ಹೋಗಲು ಹೊಂದಿರುತ್ತದೆ

452
00:38:03,960 --> 00:38:10,500
ಮತ್ತು ಒಂದು ಸಾಲು ಮತ್ತೆ? >> [ವಿದ್ಯಾರ್ಥಿ] N - 1. >> ಹೌದು, ಪರಿಪೂರ್ಣ. n - 1.

453
00:38:10,500 --> 00:38:14,390
ನಾವು ಒಮ್ಮೆ ಈಗಾಗಲೇ ಮಾಡಿದ, ಆದ್ದರಿಂದ ನಾವು ಹೋಗಿ ಮರಳಿ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪುನರಾವರ್ತಿಸುವಂತೆ ಬಯಸುವಿರಿ

454
00:38:14,390 --> 00:38:17,460
N - ಬಾರಿ 1 ಪ್ರಮಾಣವನ್ನು.

455
00:38:22,730 --> 00:38:25,860
ಸರಿ. ಆದ್ದರಿಂದ ನಿಮ್ಮ ಗಣಕತೆರೆ ಫಂಕ್ಷನ್.

456
00:38:25,860 --> 00:38:34,360
>> ಈಗ ನಾವು ನಿಜವಾಗಿಯೂ ಮೋಜಿನ ಭಾಗ ಕೊಡು ಇದು ನನ್ನ ನೆಚ್ಚಿನ pset, ಗೆ ಪಡೆಯಬಹುದು.

457
00:38:34,360 --> 00:38:39,580
ಬದಲಿಗೆ ಬಿಟ್ಮ್ಯಾಪ್ಗಳನ್ನು ಈ ಸಮಯದಲ್ಲಿ ನಾವು JPEGs ಮಾತಾಡುತ್ತಿದ್ದೀರಿ.

458
00:38:39,580 --> 00:38:43,370
ನಾವು ವಾಸ್ತವವಾಗಿ ಕೇವಲ JPEGs ಒಂದು ಕಡತ ನೀಡಿದ ಇಲ್ಲ,

459
00:38:43,370 --> 00:38:46,600
ನಾವು ಮೂಲತಃ ಕಚ್ಚಾ ಮೆಮೊರಿ ಕಾರ್ಡ್ ರೂಪದಲ್ಲಿ ನೀಡಲಾಗುತ್ತದೆ ಮಾಡುತ್ತಿದ್ದೇವೆ.

460
00:38:46,600 --> 00:38:51,790
ಮತ್ತು ಆದ್ದರಿಂದ ಇದು ಆರಂಭದಲ್ಲಿ ಮಾಹಿತಿ ಮತ್ತು ಕಸ ಮೌಲ್ಯಗಳ ಬಿಟ್ ಒಳಗೊಂಡಿದೆ

461
00:38:51,790 --> 00:38:57,240
ಮತ್ತು ಅದು ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಮತ್ತು JPEG ಕಡತಗಳಿಗೆ ಒಂದು ಗುಂಪೇ ಹೊಂದಿದೆ.

462
00:38:57,240 --> 00:39:03,430
ನಾವು ಫೋಟೋಗಳನ್ನು ಅಳಿಸಿದ್ದೀರಿ ಅಲ್ಲಿ ಆದರೆ, ನಾವು ಒಂದು ಕಾರ್ಡ್ ಹ್ಯಾಂಡೆಡ್ ನೀವು;

463
00:39:03,430 --> 00:39:08,300
ಫೋಟೋಗಳನ್ನು ಕಾರ್ಡ್ ಸ್ಥಿತವಾಗಿದೆ ಅಲ್ಲಿ ಮುಖ್ಯವಾಗಿ, ನಾವು ಮರೆತು ನಾವು.

464
00:39:08,300 --> 00:39:12,770
ಆದ್ದರಿಂದ ಮರುಪಡೆಯಿರಿ ನಮ್ಮ ಕೆಲಸವನ್ನು ಈ ಕಾರ್ಡ್ ರೂಪದಲ್ಲಿ ಮೂಲಕ ಹೋಗಲು ಹೊಂದಿದೆ

465
00:39:12,770 --> 00:39:16,500
ಮತ್ತು ಮತ್ತೆ ಆ ಚಿತ್ರಗಳನ್ನು ಹೇಗೆ.

466
00:39:16,500 --> 00:39:23,990
>> ಅದೃಷ್ಟವಶಾತ್, JPEG ಕಡತಗಳಿಗೆ ಮತ್ತು ಕಾರ್ಡ್ ಕಡತ ರಚನೆ ಸ್ವಲ್ಪ ಸಹಾಯಕವಾಗುತ್ತದೆ.

467
00:39:23,990 --> 00:39:28,850
ಈ ನಿರ್ದಿಷ್ಟ ರೂಪದಲ್ಲಿ ಇಲ್ಲದಿದ್ದರೆ ಇದು ಖಂಡಿತವಾಗಿಯೂ ಸ್ವಲ್ಪ ಚಾತುರ್ಯದ ಸಾಧ್ಯವಿತ್ತು.

468
00:39:28,850 --> 00:39:40,160
ಪ್ರತಿ JPEG ಕಡತವನ್ನು ವಾಸ್ತವವಾಗಿ ಮೇಲೆ ತಿಳಿಸಿದ ಎರಡು ಸಂಭವನೀಯ ಸೀಕ್ವೆನ್ಸ್ಗಳನ್ನು ಆರಂಭವಾಗುತ್ತದೆ.

469
00:39:40,160 --> 00:39:42,970
ಮೂಲಭೂತವಾಗಿ, ನೀವು ಒಂದು ಹೊಸ JPEG ಫೈಲ್, ಇದ್ದಾಗಲೆಲ್ಲಾ

470
00:39:42,970 --> 00:39:52,720
ಇದು ಅನುಕ್ರಮ ffd8 ffe0 ಅಥವಾ ಇತರ ಒಂದು, ffd8 ffe1 ಎರಡೂ ಆರಂಭವಾಗುತ್ತದೆ.

471
00:39:52,720 --> 00:39:59,530
ತಿಳಿಯಲು ಮತ್ತೊಂದು ಉಪಯುಕ್ತ ವಸ್ತು JPEGs ಸಮೀಪವಿರುವ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಎಂದು.

472
00:39:59,530 --> 00:40:03,380
ಆದ್ದರಿಂದ ಒಂದು JPEG ಫೈಲ್ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಮಾಡುವಾಗ ಇತರೆ ಪ್ರಾರಂಭಿಸುತ್ತದೆ.

473
00:40:03,380 --> 00:40:07,070
ಆದ್ದರಿಂದ ಮೌಲ್ಯಗಳನ್ನು ನಡುವೆ ಯಾವುದೇ ರೀತಿಯ ಇಲ್ಲ.

474
00:40:07,070 --> 00:40:15,510
ನೀವು ಈಗಾಗಲೇ JPEG ಓದುತ್ತಿದ್ದಾರೆ ನೀವು ಒಮ್ಮೆ, ಒಂದು JPEG ಆರಂಭದಲ್ಲಿ ಹಿಟ್

475
00:40:15,510 --> 00:40:21,800
ನೀವು ಹಿಂದಿನ ಹಾಗೂ ಮುಂದಿನ ಒಂದು ಆರಂಭದಲ್ಲಿ ಅಂತ್ಯ ಹಿಟ್ ಎಂಬುದನ್ನು.

476
00:40:21,800 --> 00:40:25,890
>> ಈ ದೃಶ್ಯೀಕರಿಸುವುದು ರೀತಿಯ ನಾನು ಒಂದು ರೂಪರೇಖೆಯ ಮಾಡಿದ.

477
00:40:25,890 --> 00:40:36,910
JPEGs ಬಗ್ಗೆ ಇನ್ನೊಂದು ವಿಷಯ, ನಾವು ಒಂದು ಸಮಯದಲ್ಲಿ 512 ಬೈಟ್ಗಳು ಸರಣಿಗಳನ್ನು ಅವುಗಳನ್ನು ಓದಲು ಮಾಡುತ್ತದೆ

478
00:40:36,910 --> 00:40:39,380
ಹಾಗೆಯೇ ಕಾರ್ಡ್ ಆರಂಭದಲ್ಲಿ.

479
00:40:39,380 --> 00:40:43,370
ನಾವು ಹೀರುವಂತೆ ಏಕೆಂದರೆ ಪ್ರತಿಯೊಂದು ಬೈಟ್ ಪರಿಶೀಲಿಸುವ ಅಗತ್ಯ ಇಲ್ಲ.

480
00:40:43,370 --> 00:40:48,200
ಆದ್ದರಿಂದ ಬದಲಿಗೆ, ನಾವು ಮಾಡಬಹುದು ವಾಸ್ತವವಾಗಿ ಕೇವಲ ಸಮಯದಲ್ಲಿ 512 ಬೈಟ್ಗಳಲ್ಲಿ ಓದಲು

481
00:40:48,200 --> 00:40:54,700
ತದನಂತರ, ಬದಲಿಗೆ ಆ ಸಣ್ಣ ಸಣ್ಣ ಹೋಳುಗಳಾಗಿ ಆ ನಡುವೆ ಪರಿಶೀಲಿಸುವ,

482
00:40:54,700 --> 00:40:58,640
ನಾವು 512 ಬೈಟ್ಗಳು ಆರಂಭದಲ್ಲಿ ಪರಿಶೀಲಿಸಬಹುದು.

483
00:40:58,640 --> 00:41:02,570
ಮೂಲಭೂತವಾಗಿ, ಈ ಚಿತ್ರದಲ್ಲಿ, ನೀವು ನೋಡಿ, ಕಾರ್ಡ್ ಆರಂಭದಲ್ಲಿ ಆಗಿದೆ

484
00:41:02,570 --> 00:41:08,700
ನೀವು ನಿಜವಾದ JPEGs ತಮ್ಮನ್ನು ನಿಜವಾಗಿಯೂ ಸೂಕ್ತ ಎಂದು ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿವೆ.

485
00:41:08,700 --> 00:41:15,830
ಆದರೆ ನಂತರ ಯಾವ ನಾನು ಹೊಂದಿವೆ ಒಂದು JPEG ಎರಡು ಆರಂಭಿಕ ಸರಣಿಗಳ ಒಂದು ಸೂಚಿಸಲು ನಟ.

486
00:41:15,830 --> 00:41:19,910
ಆದ್ದರಿಂದ ನೀವು ಒಂದು ನಕ್ಷತ್ರ ನೋಡಿ ಬಂದಾಗಲೆಲ್ಲಾ, ನೀವು JPEG ಫೈಲ್ ಎಂಬುದನ್ನು.

487
00:41:19,910 --> 00:41:25,030
ತದನಂತರ ಪ್ರತಿ JPEG ಫೈಲ್ 512 ಬೈಟ್ಗಳು ಕೆಲವು ಬಹು ಏರಲಿದೆ

488
00:41:25,030 --> 00:41:27,880
ಆದರೆ ಅದೇ ಅನೇಕ ಇಲ್ಲ.

489
00:41:27,880 --> 00:41:32,050
ನೀವು ಮತ್ತೊಂದು ನಕ್ಷತ್ರ ಹಿಟ್ ವೇಳೆ ನೀವು ಇನ್ನೊಂದು JPEG ಹಿಟ್ ಎಂಬುದನ್ನು ಆ ರೀತಿಯಲ್ಲಿ, ಇದು

490
00:41:32,050 --> 00:41:39,090
ಬೈಟ್ಗಳು ಇನ್ನೊಂದು ಆರಂಭಿಕ ಅನುಕ್ರಮ.

491
00:41:39,090 --> 00:41:43,330
ನಂತರ ನಿಮಗೆ ಇಲ್ಲಿ ಹೊಂದಿವೆ ನೀವು ಸ್ಟಾರ್ ಹಿಟ್ ತನಕ ನೀವು ಮುಂದುವರೆಯುವ ಕೆಂಪು JPEG ಕಡತವನ್ನು ಹೊಂದಿದೆ

492
00:41:43,330 --> 00:41:45,150
ಇದು ಒಂದು ಹೊಸ ಬಣ್ಣವನ್ನು ಸೂಚಿಸುತ್ತದೆ.

493
00:41:45,150 --> 00:41:48,510
ನೀವು ಮುಂದುವರಿಸಲು ಮತ್ತು ನಂತರ ನೀವು ಮತ್ತೊಂದು ನಕ್ಷತ್ರ ಹಿಟ್, ನೀವು ಮತ್ತೊಂದು JPEG ಹಿಟ್

494
00:41:48,510 --> 00:41:50,590
ನೀವು ಕೊನೆಯವರೆಗೆ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಮುಂದುವರಿಸಲು.

495
00:41:50,590 --> 00:41:53,180
ನೀವು, ಇಲ್ಲಿ ಕೊನೆಯ ಚಿತ್ರವನ್ನು ಗುಲಾಬಿ ಒಂದು ಆರ್.

496
00:41:53,180 --> 00:41:58,220
ನೀವು ಫೈಲ್ ಪಾತ್ರದ ಕೊನೆಯ ಹಿಟ್ ತನಕ ನೀವು ಕೊನೆಯಲ್ಲಿ ಹೋಗಿ.

497
00:41:58,220 --> 00:42:00,820
ಈ ನಿಜವಾಗಿಯೂ ಉಪಯುಕ್ತ ಎಂದು ಹೋಗುತ್ತದೆ.

498
00:42:00,820 --> 00:42:03,170
>> ಇಲ್ಲಿ ಕೆಲವು ಪ್ರಮುಖ takeaways:

499
00:42:03,170 --> 00:42:06,670
ಕಾರ್ಡ್ ಫೈಲ್, ಒಂದು JPEG ಆರಂಭವಾಗಬೇಕು ಇಲ್ಲ

500
00:42:06,670 --> 00:42:13,350
ಒಂದು JPEG ಆರಂಭವಾಗುತ್ತದೆ ಒಮ್ಮೆ ಆದರೆ, JPEGs ಎಲ್ಲಾ ಪಕ್ಕ ಪರಸ್ಪರ ಅಡ್ಡ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ.

501
00:42:17,520 --> 00:42:20,420
>> ಕೊಡು ಕೆಲವು ಸೂಡೊಕೋಡ್ಗಳನ್ನು.

502
00:42:20,420 --> 00:42:22,570
ಮೊದಲ, ನಾವು, ನಮ್ಮ ಕಾರ್ಡ್ ಫೈಲ್ ತೆರೆಯಲು ನೀನು

503
00:42:22,570 --> 00:42:27,500
ಮತ್ತು ನಮ್ಮ ಫೈಲ್ I / O ಕಾರ್ಯಗಳನ್ನು ಬಳಸುತ್ತಿರುವ ಹೋಗುವುದಿಲ್ಲ.

504
00:42:27,500 --> 00:42:32,430
ನಾವು ಫೈಲ್ ಕೊನೆಯಲ್ಲಿ ತಲುಪಿದ್ದೀರಿ ರವರೆಗೆ ಕೆಳಗಿನ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪುನರಾವರ್ತಿಸುವಂತೆ ನೀನು.

505
00:42:32,430 --> 00:42:36,450
ನಾವು ಒಂದು ಸಮಯದಲ್ಲಿ 512 ಬೈಟ್ಗಳು ಓದಲು ನೀನು.

506
00:42:36,450 --> 00:42:39,180
ಮತ್ತು ನಾನು ಇಲ್ಲಿ ಹೇಳಿದರು, ನಾವು ಒಂದು ಬಫರ್ ಅದನ್ನು ಶೇಖರಿಸಲು ನೀನು ಆಗಿದೆ

507
00:42:39,180 --> 00:42:46,230
ನಾವು ಅವರೊಂದಿಗೆ ಮಾಡಲು ನಿಖರವಾಗಿ ತಿಳಿಯಲು ರವರೆಗೂ ಮೂಲತಃ ಆ 512 ಬೈಟ್ಗಳು ಉಳಿಸಿಕೊಳ್ಳುವುದು.

508
00:42:46,230 --> 00:42:50,300
ನಂತರ ನಾವು ಮಾಡಲು ಬಯಸುವ ನಾವು ನಕ್ಷತ್ರ ಅಥವಾ ಹಿಟ್ ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸಲು ಬಯಸುವ ಹೊಂದಿದೆ.

509
00:42:50,300 --> 00:42:57,960
ನಾವು ಆರಂಭಿಕ ಸರಣಿಗಳ ಒಂದು ಹಿಟ್ ಮಾಡಿದ ನಾವು, ಒಂದು ನಕ್ಷತ್ರದ ಹೊಡೆಯಲು ನೀವು,

510
00:42:57,960 --> 00:42:59,980
ನಂತರ ನಾವು ಒಂದು ಹೊಸ JPEG ಫೈಲ್ ಹಿಟ್ ಎಂಬುದನ್ನು.

511
00:42:59,980 --> 00:43:08,860
ನಮಗೆ ಮಾಡಲು ಬಯಸುವಿರಿ ನಾವು ನಮ್ಮ pset4 ಕೋಶದಲ್ಲಿ ಒಂದು ಹೊಸ ಕಡತವನ್ನು ರಚಿಸಲು ಬಯಸುವ ಎಂದು ನೀನು

512
00:43:08,860 --> 00:43:14,480
ಫೈಲ್ ಮಾಡುವ ಮುಂದುವರೆಯಲು.

513
00:43:14,480 --> 00:43:18,220
ಆದರೆ, ನಾವು ಈಗಾಗಲೇ, ಮೊದಲು ಒಂದು JPEG ಮಾಡಿದ ವೇಳೆ

514
00:43:18,220 --> 00:43:25,620
ಆಗ, ಆ ಫೈಲ್ ಕೊನೆಗೊಳಿಸಿ pset4 ಫೋಲ್ಡರ್ಗೆ ತಳ್ಳಿ ಬಯಸುವ

515
00:43:25,620 --> 00:43:29,780
ಆ ಫೈಲ್ ಸಂಗ್ರಹವಾಗಿರುವ ನಿಮಗಿದೆ ಅಲ್ಲಿ ನಾವು ಆ JPEG ಫೈಲ್ ಕೊನೆಗೊಂಡಿತು ಎಂಬುದನ್ನು ಸೂಚಿಸಲು ಇದ್ದರೆ ಏಕೆಂದರೆ,

516
00:43:29,780 --> 00:43:37,290
ನಾವು ಮೂಲತಃ ಅನಿರ್ದಿಷ್ಟ ಪ್ರಮಾಣವನ್ನು ಹೊಂದಿರುತ್ತದೆ. JPEGs ಮುಗಿಯುವುದೇ ಇಲ್ಲವೇನೋ.

517
00:43:37,290 --> 00:43:40,840
ಆದ್ದರಿಂದ, ನಾವು ಒಂದು JPEG ಕಡತವನ್ನು ಓದುವ ಮತ್ತು ನೀವು ಬರೆಯಲು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬಯಸುವ

518
00:43:40,840 --> 00:43:46,590
ನಾವು ವಿಶೇಷವಾಗಿ ಮುಂದಿನ ತೆರೆಯಿರಿ ಸಲುವಾಗಿ ಎಂದು ಅಳಿಸಲು.

519
00:43:46,590 --> 00:43:48,430
ನಾವು ಅನೇಕ ವಿಷಯಗಳನ್ನು ಪರಿಶೀಲಿಸಿ ಬಯಸುವಿರಿ.

520
00:43:48,430 --> 00:43:52,880
ನಾವು ನಮ್ಮ ಬಫರ್ ಹೊಸ JPEG ಆರಂಭದಲ್ಲಿ ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸಲು ಬಯಸುವ

521
00:43:52,880 --> 00:43:56,780
ಮತ್ತು ನಾವು ಈಗಾಗಲೇ ಒಂದು JPEG ಕಂಡು ಬಂದಲ್ಲಿ

522
00:43:56,780 --> 00:44:03,930
ಏಕೆಂದರೆ ಸ್ವಲ್ಪ ನಿಮ್ಮ ಪ್ರಕ್ರಿಯೆ ಬದಲಾಗುತ್ತದೆ.

523
00:44:03,930 --> 00:44:07,880
ನೀವು ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಮೂಲಕ ಹೋಗಿ ಮತ್ತು ನಂತರ ಆದ್ದರಿಂದ ನೀವು ಕಡತದ ಕೊನೆಯಲ್ಲಿ ಹಿಟ್

524
00:44:07,880 --> 00:44:11,570
ನಂತರ ನೀವು ಏನು ಮಾಡಲು ಬಯಸುವಿರಿ ನೀವು ಪ್ರಸ್ತುತ ತೆರೆಯಲು ಎಲ್ಲಾ ಫೈಲ್ಗಳನ್ನು ಕ್ಲೋಸ್ ಬಯಸುವಿರಿ ಹೊಂದಿದೆ.

525
00:44:11,570 --> 00:44:14,100
ಎಂದು ಬಹುಶಃ, ನೀವು ಕಳೆದ JPEG ಫೈಲ್ ಕಾಣಿಸುತ್ತದೆ

526
00:44:14,100 --> 00:44:18,930
ಹಾಗೆಯೇ ಕಾರ್ಡ್ ಫೈಲ್ ನೀವು ವ್ಯವಹರಿಸುವಾಗ ಮಾಡಲಾಗಿದೆ ಎಂಬುದನ್ನು.

527
00:44:21,940 --> 00:44:28,670
>> ನಾವು ನಿಭಾಯಿಸಲು ಅಗತ್ಯವಿರುವ ಕೊನೆಯಾಗಿ ಅಡಚಣೆಯಾಗಿದೆ ವಾಸ್ತವವಾಗಿ ಒಂದು JPEG ಫೈಲ್ ಮಾಡಲು ಹೇಗೆ

528
00:44:28,670 --> 00:44:31,950
ಮತ್ತು ವಾಸ್ತವವಾಗಿ ಫೋಲ್ಡರ್ಗೆ ತಳ್ಳಿ ಹೇಗೆ.

529
00:44:33,650 --> 00:44:39,850
pset, ನಗರದಲ್ಲಿ ಪ್ರತಿ JPEG ಕೆಳಗಿನ ರೂಪದಲ್ಲಿ ಎಂದು ಅಗತ್ಯವಿದೆ

530
00:44:39,850 --> 00:44:43,990
ಅಲ್ಲಿ ನೀವು ಸಂಖ್ಯೆಯ. JPG.

531
00:44:43,990 --> 00:44:50,750
ಸಂಖ್ಯೆ, ಇದು 0 ಕೂಡ ಆಗಿರಬಹುದು, ನಾವು 000.jpg ಕರೆ.

532
00:44:50,750 --> 00:44:55,730
ನೀವು, ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಒಂದು JPEG ಹೇಗೆ ಯಾವಾಗ

533
00:44:55,730 --> 00:44:58,040
ನೀವು ಕಂಡುಬಂದಿಲ್ಲ ಎಂದು ಸಲುವಾಗಿ ಅದನ್ನು ಹೆಸರಿಸಲು ಬಯಸುವ ಎಂದು ನೀನು.

534
00:44:58,040 --> 00:44:59,700
ಇದರ ಅರ್ಥ ಏನು?

535
00:44:59,700 --> 00:45:03,530
ನಾವು ಕಂಡುಬಂದರೆ ಎಷ್ಟು ಗಮನದಲ್ಲಿರಿಸಲು ರೀತಿಯ ಅಗತ್ಯವಿದೆ

536
00:45:03,530 --> 00:45:08,680
ಮತ್ತು ಪ್ರತಿ JPEG ಸಂಖ್ಯೆಯನ್ನು ಏನಾಗಿರಬೇಕೆಂದು.

537
00:45:08,680 --> 00:45:13,800
ಇಲ್ಲಿ ನಾವು sprintf ಕಾರ್ಯ ಲಾಭ ಪಡೆಯಲು ನೀನು.

538
00:45:13,800 --> 00:45:17,480
, Printf ಹೋಲುವ ಇದು ಟರ್ಮಿನಲ್ಗೆ ಅಚ್ಚುಗಳ ಕೇವಲ ರೀತಿಯ ಮೌಲ್ಯವನ್ನು ಔಟ್,

539
00:45:17,480 --> 00:45:23,910
sprintf ಫೋಲ್ಡರ್ ಆಗಿ ಫೈಲ್ ಔಟ್ ಮುದ್ರಿಸುತ್ತದೆ.

540
00:45:23,910 --> 00:45:30,870
ಆದ್ದರಿಂದ ಈ, ಅಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ನಂತರ ಯಾವ ನಾನು sprintf, ಶೀರ್ಷಿಕೆ ವೇಳೆ ಹಾಗೆ, ಹಾಗೂ

541
00:45:30,870 --> 00:45:36,660
ಇದು 2.jpg ಮುದ್ರಿಸುತ್ತದೆ ಎಂದು.

542
00:45:36,660 --> 00:45:41,020
ನಾನು ಸರಿಯಾಗಿ ನನ್ನ ಕಡತಗಳನ್ನು ಮುಚ್ಚಿದರೂ ಭಾವಿಸಿ

543
00:45:41,020 --> 00:45:47,210
ನಾನು ಔಟ್ ಬರೆದಿದ್ದಾನೆ ಫೈಲ್ ಹೊಂದಿರಬೇಕು.

544
00:45:47,210 --> 00:45:50,320
ಆದರೆ ಒಂದು ವಿಷಯ ಎಂದು ನಾನು ಇಲ್ಲಿ ಹೊಂದಿರುವ ಕೋಡ್

545
00:45:50,320 --> 00:45:53,360
ಸಾಕಷ್ಟು pset ಅವಶ್ಯಕವಾದ ಪದಗಳನ್ನು ಇಲ್ಲ.

546
00:45:53,360 --> 00:46:02,410
pset ಎರಡನೇ JPEG ಕಡತವನ್ನು ಕೇವಲ 2 002 ಹೆಸರಿನ ಎಂದು ಅಗತ್ಯವಿದೆ.

547
00:46:02,410 --> 00:46:09,160
ಆದ್ದರಿಂದ ನೀವು ಹೆಸರು ಮುದ್ರಿಸುತ್ತದೆ, ನಂತರ ಬಹುಶಃ ನೀವು ಸ್ವಲ್ಪ ಪ್ಲೇಸ್ಹೋಲ್ಡರ್ ಮಾರ್ಪಡಿಸುತ್ತದೆ ಬಯಸಬಹುದು.

548
00:46:09,160 --> 00:46:18,140
>> ಯಾರಾದರೂ ನಾವು ಏನನ್ನಾದರೂ ಮುದ್ರಿಸಲು ನಾವು ಹೆಚ್ಚುವರಿ ಖಾಲಿ ಅವಕಾಶ ಹೇಗೆ ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಡಸ್?

549
00:46:18,140 --> 00:46:22,530
ಹೌದು. >> [ವಿದ್ಯಾರ್ಥಿ] ನೀವು ಶೇಕಡಾ ಚಿಹ್ನೆ ಮತ್ತು 2 ನಡುವೆ 3 ಪುಟ್. >> ಹೌದು, ಪರಿಪೂರ್ಣ.

550
00:46:22,530 --> 00:46:25,610
ನಾವು 3 ಜಾಗ ಬಯಸುವ ಏಕೆಂದರೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ 3 ಹಾಕುತ್ತೇವೆ.

551
00:46:25,610 --> 00:46:32,590
% 3D ಬಹುಶಃ ನೀವು 002.jpg ಬದಲಾಗಿ 2 ನೀಡುತ್ತದೆ.

552
00:46:32,590 --> 00:46:40,120
sprintf ಕಾರ್ಯ ಆಗಿ ಮೊದಲ ವಾದವನ್ನು, ವಾಸ್ತವವಾಗಿ ಒಂದು ಚಾರ್ ರಚನೆ

553
00:46:40,120 --> 00:46:42,520
ಇದು ನಾವು ಹಿಂದೆ ತಂತಿಗಳನ್ನು ಎಂದು ತಿಳಿದಿದ್ದರು.

554
00:46:42,520 --> 00:46:50,700
ಆ ವಿಲ್, ಒಂದು ತಾತ್ಕಾಲಿಕ ಶೇಖರಣಾ ಹೆಚ್ಚು ರೀತಿಯ ಕೇವಲ ಪರಿಣಾಮಕ ಸ್ಟ್ರಿಂಗ್ ಶೇಖರಿಸಿಡಲು.

555
00:46:50,700 --> 00:46:54,950
ನೀವು ನಿಜವಾಗಿಯೂ ಈ ವ್ಯವಹರಿಸುವಾಗ ಮಾಡಲಾಗುವುದಿಲ್ಲ, ಆದರೆ ನೀವು ಅದನ್ನು ಸೇರಿವೆ ಅಗತ್ಯವಿದೆ.

556
00:46:54,950 --> 00:47:00,710
>> ಪ್ರತಿ ಕಡತ ಹೆಸರು ಮೂರು ಪಾತ್ರಗಳು ತೆಗೆದುಕೊಂಡರೆ ಇದು ಹೊಂದಿದೆ, ತಿಳಿದುಕೊಂಡು,

557
00:47:00,710 --> 00:47:06,770
ತದನಂತರ. JPG, ಈ ರಚನೆಯ ಹೇಗೆ ಉದ್ದವಾಗಿರಬೇಕು?

558
00:47:09,070 --> 00:47:14,310
ಒಂದು ಸಂಖ್ಯೆಯನ್ನು ಚೆಲ್ಲಿದೆ. ಹೆಸರಿನಲ್ಲಿ ಶೀರ್ಷಿಕೆ ಎಷ್ಟು ಪಾತ್ರಗಳು,?

559
00:47:18,090 --> 00:47:26,320
ಆದ್ದರಿಂದ 3 hashtags, ಅವಧಿ, JPG ಇಲ್ಲ. >> [ವಿದ್ಯಾರ್ಥಿ] 7. >> 7. ಹೆಚ್ಚು.

560
00:47:26,320 --> 00:47:32,000
ನಾವು ಹಾಗೂ ಶೂನ್ಯ ಟರ್ಮಿನೇಟರ್ ಅವಕಾಶ ಬಯಸುವ ನಾವು 8 ಬಯಸುವ ಎಂದು ನೀನು.

561
00:47:45,340 --> 00:47:49,730
>> ಅಂತಿಮವಾಗಿ, ಕೇವಲ, ನೀವು ಕೊಡು ಮಾಡುತ್ತಿದ್ದ ವಾಪಸಾಗುತ್ತೇವೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸೆಳೆಯಲು

562
00:47:49,730 --> 00:47:55,420
ನೀವು ಕೆಲವು ಆರಂಭದಲ್ಲಿ ಮಾಹಿತಿ.

563
00:47:55,420 --> 00:48:02,460
ನೀವು JPEG ಫೈಲ್ ಆರಂಭದಲ್ಲಿ ಹೇಗೆ ತನಕ ನೀವು ಮುಂದುವರಿಸಲು

564
00:48:02,460 --> 00:48:07,900
ಮತ್ತು ಎರಡು ಆರಂಭಿಕ ಅನುಕ್ರಮಗಳನ್ನು ಎರಡೂ ಒಂದು ಮಾಡಬಹುದು.

565
00:48:07,900 --> 00:48:12,510
ನೀವು ಓದಿದ ಮೇಲೆ ಇರಿಸಿಕೊಳ್ಳಲು. ಇಲ್ಲಿ ಪ್ರತಿ ಸ್ಲ್ಯಾಷ್ 512 ಬೈಟ್ಗಳು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

566
00:48:12,510 --> 00:48:22,630
ನೀವು ಇನ್ನೊಂದು ಆರಂಭಿಕ ಅನುಕ್ರಮ ಎದುರಿಸಬಹುದು ರವರೆಗೆ ಓದಿದ ಮೇಲೆ ಇಡಲು, ಓದುವಿಕೆ ನ್ನು ಇರಿಸಿಕೊಳ್ಳಲು.

567
00:48:22,630 --> 00:48:29,790
ಒಮ್ಮೆ ನೀವು ಪ್ರಸ್ತುತ JPEG ಕೊನೆಗೊಳ್ಳಬೇಕು ಎಂದು ಹೊಂದಿವೆ - ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಇದು ಕೆಂಪು ಒಂದಾಗಿದೆ,

568
00:48:29,790 --> 00:48:31,030
ಆದ್ದರಿಂದ ನೀವು ಅಂತಿಮವಾಗಿ ನೀವು.

569
00:48:31,030 --> 00:48:35,540
ನೀವು, ನಿಮ್ಮ pset4 ಫೋಲ್ಡರ್ ಆಗಿ ಆ sprintf ಹೆಸರು ಬಯಸುವ

570
00:48:35,540 --> 00:48:41,580
ನಂತರ ನೀವು ಒಂದು ಹೊಸ JPEG ತೆರೆದು ನಂತರ ಓದುವ ನ್ನು ಇರಿಸಿಕೊಳ್ಳಲು ಬಯಸುತ್ತೀರಿ

571
00:48:41,580 --> 00:48:46,370
ನೀವು ಮುಂದಿನ ಎದುರಿಸಬಹುದು ರವರೆಗೆ.

572
00:48:46,370 --> 00:48:49,040
, ಓದುವಿಕೆ ನ್ನು ಇರಿಸಿಕೊಳ್ಳಲು, ಓದುವಿಕೆ ಮೇಲೆ ಇರಿಸಿ

573
00:48:49,040 --> 00:48:56,290
ತದನಂತರ ಅಂತಿಮವಾಗಿ, ಅಂತಿಮವಾಗಿ, ನೀವು ಕಡತದ ಕೊನೆಯಲ್ಲಿ ತಲುಪಲು ನೀನು

574
00:48:56,290 --> 00:49:00,360
ಆದ್ದರಿಂದ ನೀವು ಕೆಲಸ ಎಂದು ಕೊನೆಯಾಗಿ JPEG ಮುಚ್ಚಿ ಬಯಸುವಿರಿ

575
00:49:00,360 --> 00:49:08,380
sprintf ನಿಮ್ಮ pset4 ಫೋಲ್ಡರ್ ಆಗಿ, ತದನಂತರ ನೀವು ಪಡೆದ ನೀವು ಚಿತ್ರಗಳನ್ನು ಎಲ್ಲಾ ನೋಡಲು ಆ.

576
00:49:08,380 --> 00:49:12,050
ಆ ಚಿತ್ರಗಳನ್ನು ನಿಜವಾಗಿ CS50 ಸಿಬ್ಬಂದಿಯ ಚಿತ್ರಗಳು ಇಲ್ಲಿವೆ

577
00:49:12,050 --> 00:49:16,430
pset ನ ಬೋನಸ್ ಮೋಜಿನ ಭಾಗದಲ್ಲಿ ಬರುತ್ತದೆ ಮತ್ತು ಆದ್ದರಿಂದ ಇದು

578
00:49:16,430 --> 00:49:26,310
ನೀವು ಚಿತ್ರಗಳಲ್ಲಿ TFS ಹುಡುಕಲು ನಿಮ್ಮ ವಿಭಾಗಗಳಲ್ಲಿ ಸ್ಪರ್ಧಾತ್ಮಕ ಮಾಡುತ್ತದೆ

579
00:49:26,310 --> 00:49:34,610
ಮತ್ತು ಅವರೊಂದಿಗೆ ಚಿತ್ರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ನೀವು pset ಮಾಡಿದ ಸಾಬೀತುಪಡಿಸಲು

580
00:49:34,610 --> 00:49:37,030
ಆದ್ದರಿಂದ ನೀವು ಸಿಬ್ಬಂದಿ ಚಿತ್ರಗಳಲ್ಲಿ ಅವು ನೋಡಬಹುದು.

581
00:49:37,030 --> 00:49:41,510
ಆದ್ದರಿಂದ ನೀವು ಸಿಬ್ಬಂದಿ ಚಿತ್ರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು. ಕೆಲವೊಮ್ಮೆ ನೀವು ಅವರನ್ನು ಮುಟ್ಟಲು ಸಾಧ್ಯವಿದೆ.

582
00:49:41,510 --> 00:49:44,680
ಪ್ರಾಯಶಃ ಅವುಗಳಲ್ಲಿ ಕೆಲವು ನೀವು ದೂರ ರನ್ ಪ್ರಯತ್ನಿಸುತ್ತದೆ.

583
00:49:44,680 --> 00:49:47,320
ನೀವು ಅವರೊಂದಿಗೆ ಚಿತ್ರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು.

584
00:49:47,320 --> 00:49:51,190
ಈ ನಡೆಯುತ್ತಿದೆ. Pset ಕಾರಣ ಅದು ಕಾರಣ ಅಲ್ಲ.

585
00:49:51,190 --> 00:49:53,340
ಗಡುವು ನಿರ್ದಿಷ್ಟಪಡಿಸುವಿಕೆಯನ್ನು ಘೋಷಿಸಿತು ಮಾಡಲಾಗುತ್ತದೆ.

586
00:49:53,340 --> 00:49:58,060
ನಂತರ ಒಟ್ಟಿಗೆ ನಿಮ್ಮ ವಿಭಾಗವು, ಯಾವುದೇ ವಿಭಾಗದಲ್ಲಿ ಹೆಚ್ಚಿನ ಚಿತ್ರಗಳನ್ನು ತೆಗೆಯುತ್ತದೆ

587
00:49:58,060 --> 00:50:04,430
ಹೆಚ್ಚಿನ ಸಿಬ್ಬಂದಿ ಒಂದು ಬಹಳ ಉತ್ತಮವಾಗಿದೆ ಬಹುಮಾನ ಗಳಿಸಿತು.

588
00:50:04,430 --> 00:50:08,890
ಪಡೆಯಲು ಉತ್ತೇಜಕ ಭಾಸವಾಗುತ್ತದೆ ನಿಮ್ಮ pset4 ಸಾಧ್ಯವಿದ್ದಷ್ಟು ಮುಗಿಸಿದರು

589
00:50:08,890 --> 00:50:10,820
ನಂತರ ನೀವು ವ್ಯಾಪಾರ ಕೆಳಗೆ ಪಡೆಯುವುದು ಏಕೆಂದರೆ

590
00:50:10,820 --> 00:50:14,570
ಎಲ್ಲಾ ವಿವಿಧ CS50 ಸಿಬ್ಬಂದಿ ಬೇಟೆಯಾಡುವುದು.

591
00:50:14,570 --> 00:50:17,500
ಕಡ್ಡಾಯ ಅಲ್ಲ ಎಂದು, ಆದರೂ, ಹಾಗೆ ಒಮ್ಮೆ, ಚಿತ್ರಗಳನ್ನು ಪಡೆಯಿರಿ

592
00:50:17,500 --> 00:50:20,310
ನಂತರ ನೀವು pset4 ಜೊತೆ ಪೂರ್ಣಗೊಳಿಸಲಾಗಿದೆ.

593
00:50:20,310 --> 00:50:23,970
>> ಮತ್ತು ನಾನು ಬರುವ ಎಲ್ಲಾ ಧನ್ಯವಾದಗಳು, ದರ್ಶನ 4 ಗಳಿಸಿದರು ನುಡಿದರು.

594
00:50:23,970 --> 00:50:29,330
ಫೊರೆನ್ಸಿಕ್ಸ್ ಉತ್ತಮ ಅದೃಷ್ಟ. [ಚಪ್ಪಾಳೆಯನ್ನು]

595
00:50:29,330 --> 00:50:31,000
[CS50.TV]