1
00:00:00,000 --> 00:00:10,210
>> [ಸಂಗೀತ]

2
00:00:10,210 --> 00:00:13,320
>> ZAMYLA ಚಾನ್: ಲೆಟ್ಸ್ ಬ್ಲೋ
ಗಣಕತೆರೆ ಕೆಲಸಗಳನ್ನು ಅಪ್.

3
00:00:13,320 --> 00:00:17,710
ಗಣಕತೆರೆ ರಲ್ಲಿ ಬಳಕೆದಾರ ಮೂಲಕ, ಹಾದು ಹೋಗಲಿದೆ
ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ, ಒಂದು ಬಿಟ್ಮ್ಯಾಪ್ ಚಿತ್ರ ಎಂದು

4
00:00:17,710 --> 00:00:21,860
ಅವರು ನೀವು ಅನೇಕ ಅಳೆಯುವ ಬಯಸುವ
ಅವರು, ಹಾದು

5
00:00:21,860 --> 00:00:23,770
ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ.

6
00:00:23,770 --> 00:00:24,690
ಹೇಗೆ ನಾವು ಏನು ಇಲ್ಲ?

7
00:00:24,690 --> 00:00:28,270
>> ಅಲ್ಲದೆ, ಮೊದಲ ಮೊದಲ ವಿಷಯಗಳನ್ನು ಅವಕಾಶ ತಂದೆಯ
ಹಂತಗಳನ್ನು ಈ ಮುರಿಯಲು.

8
00:00:28,270 --> 00:00:31,510
ನೀವು, infile ತೆರೆಯಲು ಬಯಸುವ ನೀನು
ಅವರು ನೀವು ನೀಡಲು, ಹಾಗೆಯೇ ಆ

9
00:00:31,510 --> 00:00:35,560
ರಚಿಸಲು ಮತ್ತು outfile ತೆರೆಯುವ
ನೀವು ಹಾಕಲು ನೀನು

10
00:00:35,560 --> 00:00:38,020
ಸೈನ್ ಗಾತ್ರ ಚಿತ್ರ

11
00:00:38,020 --> 00:00:42,050
ನಂತರ, ನೀವು ಮರುಗಾತ್ರಗೊಳಿಸಲು, ಮತ್ತು ಏಕೆಂದರೆ
ಇದು ಒಂದು ಬಿಟ್ಮ್ಯಾಪ್ ಏಕೆಂದರೆ, ಇದು ಒಂದು ಹೆಡರ್, ಆದ್ದರಿಂದ

12
00:00:42,050 --> 00:00:46,080
ನೀವು ಹೆಡರ್ ನವೀಕರಿಸಲು ನೀನು
outfile ಫಾರ್ ಮಾಹಿತಿ,

13
00:00:46,080 --> 00:00:47,950
ಮತ್ತು ಸೈನ್ ಎಂದು ಬರೆಯಲು

14
00:00:47,950 --> 00:00:51,850
ನಂತರ, ನೀವು ಒಳಗೆ ಓದಲು ನೀನು
, infile ಆಫ್ scanline,

15
00:00:51,850 --> 00:00:56,890
ಪಿಕ್ಸೆಲ್ ಮೂಲಕ ಪಿಕ್ಸೆಲ್, ಅಡ್ಡಡ್ಡಲಾಗಿ ಮರುಗಾತ್ರಗೊಳಿಸಲು
ಮತ್ತು ಆ ಪಿಕ್ಸೆಲ್ಗಳು ಬರೆಯಲು

16
00:00:56,890 --> 00:01:00,910
outfile, ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ
ಬಳಕೆದಾರರ ಪ್ರಮಾಣದ ಮೂಲಕ.

17
00:01:00,910 --> 00:01:03,940
>> ನೀವು ನೆನಪಿಡುವ ನೀನು
ಅಗತ್ಯ ಪ್ಯಾಡಿಂಗ್ ಸೇರಿಸಲು.

18
00:01:03,940 --> 00:01:05,400
ನಂತರ ಮೇಲೆ ಹೆಚ್ಚು.

19
00:01:05,400 --> 00:01:07,790
ತದನಂತರ ಲಂಬವಾಗಿ ಗಾತ್ರವನ್ನು.

20
00:01:07,790 --> 00:01:08,890
ಸರಿ.

21
00:01:08,890 --> 00:01:13,280
ಆದ್ದರಿಂದ ಈ ಸ್ವಲ್ಪ ಏರಲಿದೆ
ಇದು ಡನ್ ಯಾರು ಹೆಚ್ಚು ಸಂಕೀರ್ಣ, ಆದರೆ

22
00:01:13,280 --> 00:01:18,310
ಏನು ಹೋಲುತ್ತದೆ ಎಂದು copy.c ಹೊಂದಿದೆ,
ಮತ್ತೆ, ತುಂಬಾ ಉಪಯುಕ್ತ ಸಾಬೀತು.

23
00:01:18,310 --> 00:01:23,160
, Copy.c ಒಂದು ಕಡತವನ್ನು ತೆರೆಯುತ್ತದೆ ನೆನಪಿಡಿ
ಹೆಡರ್ ಮಾಹಿತಿಯನ್ನು ನವೀಕರಣಗಳನ್ನು

24
00:01:23,160 --> 00:01:28,250
outfile, ನಂತರ scanline ಓದುತ್ತದೆ,
ಪಿಕ್ಸೆಲ್ ಮೂಲಕ ಪಿಕ್ಸೆಲ್, ಪ್ರತಿ ಪಿಕ್ಸೆಲ್ ಬರೆಯಲು

25
00:01:28,250 --> 00:01:30,510
ಔಟ್ಪುಟ್ ಕಡತವನ್ನು ನ scanline ಒಳಗೆ.

26
00:01:30,510 --> 00:01:37,040
>> ಆದ್ದರಿಂದ ಮತ್ತೆ, ನಿಮ್ಮ ಮೊದಲ ಹಂತದ ಬಹುಶಃ ಮಾಡಬಹುದು
CP, copy.c, resize.c ಎಂದು

27
00:01:37,040 --> 00:01:40,560
ನಿಮ್ಮ Pset5 ಕೋಶಕ್ಕೆ.

28
00:01:40,560 --> 00:01:43,920
ನೀವು ಅದನ್ನು ನಕಲಿಸಿ ಮೊದಲು, ಆದರೂ ನೆನಪಿಡಿ,
ನೀವು ಅರ್ಥ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ

29
00:01:43,920 --> 00:01:46,600
ಆಳವಾಗಿ copy.c.

30
00:01:46,600 --> 00:01:47,620
ಸರಿ.

31
00:01:47,620 --> 00:01:49,880
>> ಆದ್ದರಿಂದ ಒಂದು ಕಡತವನ್ನು ತೆರೆಯಲು ಅವಕಾಶ.

32
00:01:49,880 --> 00:01:50,870
ನೀವು ಹಾಗೆ ಹೇಗೆ ಗೊತ್ತು.

33
00:01:50,870 --> 00:01:52,600
ನಾನು ನಿಮಗೆ ಆ ಬಿಡಲು ಪಡೆಯಲಿದ್ದೇನೆ.

34
00:01:52,600 --> 00:01:56,050
ಮುಂದೆ, ಹೆಡರ್ ಮಾಹಿತಿಯನ್ನು ಅಪ್ಡೇಟ್
outfile ಫಾರ್.

35
00:01:56,050 --> 00:01:59,240
ನಾವು ಹೊಸ ಬಿಟ್ಮ್ಯಾಪ್ ಏಕೆಂದರೆ,
ನಾವು ಹೊಸ ಹೆಡರ್ ಮಾಹಿತಿಯನ್ನು ಹೊಂದಿವೆ.

36
00:01:59,240 --> 00:02:00,970
ಇಲ್ಲಿಗೆ ಯಾವ ಬದಲಾವಣೆ?

37
00:02:00,970 --> 00:02:06,000
ಅಲ್ಲದೆ, ಫೈಲಿನ ಗಾತ್ರ ಬದಲಾಯಿಸಲು ಹೋಗುತ್ತದೆ
ನಾವು ಹೆಚ್ಚು ಮಾಡಲಿಕ್ಕೆ ಏಕೆಂದರೆ

38
00:02:06,000 --> 00:02:07,900
ಹಿಂದಿಗಿಂತ ಪಿಕ್ಸೆಲ್ಗಳು.

39
00:02:07,900 --> 00:02:11,060
ಚಿತ್ರದ ಗಾತ್ರ ಸಹ, ಹೀಗೆ, ಆಗಿದೆ
ಎಂದು, ಬದಲಿಸಲು ಹೋಗಿ

40
00:02:11,060 --> 00:02:13,050
ಅಗಲ ಮತ್ತು ಎತ್ತರ.

41
00:02:13,050 --> 00:02:17,180
>> ಆದ್ದರಿಂದ ಇದು ಅಸ್ಥಿರ ಆ ನಿಖರವಾಗಿ, ಅವು?

42
00:02:17,180 --> 00:02:20,960
ಅಲ್ಲದೆ, ನೀವು ಹೆಡರ್ ತನಿಖೆ ವೇಳೆ
ಮಾಹಿತಿ, ನೀವು ಅಲ್ಲಿ ನೋಡಿ

43
00:02:20,960 --> 00:02:25,640
ಒಟ್ಟು ಪ್ರತಿನಿಧಿಸುವ biSizeImage,
ಬೈಟ್ಗಳು ಚಿತ್ರದ ಗಾತ್ರ,

44
00:02:25,640 --> 00:02:28,340
ಪಿಕ್ಸೆಲ್ಗಳು ಮತ್ತು ಪ್ಯಾಡಿಂಗ್ ಸೇರಿದಂತೆ.

45
00:02:28,340 --> 00:02:32,520
biWidth ಚಿತ್ರದ ಅಗಲ
ಪಿಕ್ಸೆಲ್ಗಳಲ್ಲಿ, ಪ್ಯಾಡಿಂಗ್ ಮೈನಸ್.

46
00:02:32,520 --> 00:02:35,580
biHeight ಎತ್ತರವು
ಪಿಕ್ಸೆಲ್ಗಳಲ್ಲಿ ಚಿತ್ರ.

47
00:02:35,580 --> 00:02:39,200
ಮತ್ತು ಆದ್ದರಿಂದ ಆ ಒಳಗೊಂಡಿರುವ
ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ BITMAPFILEHEADER ಮತ್ತು

48
00:02:39,200 --> 00:02:40,390
BITMAPINFOHEADER.

49
00:02:40,390 --> 00:02:45,300
ನೀವು ಮೂಲಕ ಇದು ಒಂದು ಹೇಳಬಹುದು
bmp.h ಹೋಗುವ ಮತ್ತು ನೋಡುವ

50
00:02:45,300 --> 00:02:49,670
BITMAPINFOHEADER struct ಮತ್ತು ವೀಕ್ಷಣೆ
ಅಸ್ಥಿರ ಪಟ್ಟಿ.

51
00:02:49,670 --> 00:02:54,700
>> ಆದ್ದರಿಂದ outfiles ಹೆಡರ್ ನವೀಕರಿಸಲು
ಮಾಹಿತಿ, ನೀವು ಬಯಸುವ ನೀನು

52
00:02:54,700 --> 00:02:57,025
ಆ ಮೌಲ್ಯಗಳನ್ನು ಬದಲಾಯಿಸಲು
ಎತ್ತರ ಮತ್ತು ಅಗಲ.

53
00:02:57,025 --> 00:03:00,570
ಆದರೆ ಅವಕಾಶಗಳನ್ನು ನೀವು ಕೆಲವು ಬೇಕು
, infile ಹೆಡರ್ ಮಾಹಿತಿಯನ್ನು

54
00:03:00,570 --> 00:03:03,670
ನಂತರ, ಆದ್ದರಿಂದ ಉತ್ತಮ ಎರಡೂ ಕಾಪಾಡುವುದು.

55
00:03:03,670 --> 00:03:07,770
ಆದರೆ ನಿಮ್ಮ ವೇರಿಯಬಲ್ ಅತ್ಯಂತ ಸ್ಪಷ್ಟವಾದ
ಹೆಸರುಗಳು ಆದ್ದರಿಂದ ನೀವು ಅಲ್ಲ ಆಕಸ್ಮಿಕವಾಗಿ

56
00:03:07,770 --> 00:03:12,490
ತಪ್ಪಾಗಿದೆ ಮೌಲ್ಯಗಳನ್ನು ಬರೆಯಲು
outfile ಫಾರ್ ಹೆಡರ್.

57
00:03:12,490 --> 00:03:16,160
>> ಈಗ ಒಳಗೆ ಓದುವ ಪಡೆಯಲು ಅವಕಾಶ
scanline ಪಿಕ್ಸೆಲ್ ಮೂಲಕ ಪಿಕ್ಸೆಲ್.

58
00:03:16,160 --> 00:03:20,210
ಮತ್ತೆ, ನಾವು ನಮ್ಮ ನಂಬಲರ್ಹ ಮಾಡಲು ನೀನು
I / O lib ಫೈಲ್, ಮತ್ತು ನೋಡಲು

59
00:03:20,210 --> 00:03:22,100
fread ಕಾರ್ಯ.

60
00:03:22,100 --> 00:03:26,150
fread ಒಂದು struct ಒಂದು ಪಾಯಿಂಟರ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ
ಬೈಟ್ಗಳು ಹೊಂದಿರುವ ಆ

61
00:03:26,150 --> 00:03:30,130
ನೀವು ಓದುವ ಬಳಸುತ್ತಿದ್ದರೆ, ಪ್ರತಿ ಗಾತ್ರ
ನೀವು ಓದುವ ನೀವು ಅಂಶ -

62
00:03:30,130 --> 00:03:34,410
ಮತ್ತೆ, sizeof ಉಪಯುಕ್ತ ಏರಲಿದೆ
ಇಲ್ಲಿ ಕಾರ್ಯ, ಸಂಖ್ಯೆ

63
00:03:34,410 --> 00:03:38,820
ನೀವು ಎಂಬುದನ್ನು ಗಾತ್ರ, ಗಾತ್ರ ಅಂಶಗಳನ್ನು,
ನಂತರ ಅಂತಿಮವಾಗಿ ಓದುವ, ಮತ್ತು,

64
00:03:38,820 --> 00:03:41,310
inpointer, ಕಡತ ಎಂದು
ನೀವು ಓದುವ ನೀವು.

65
00:03:41,310 --> 00:03:46,770
ಆದ್ದರಿಂದ ನೀವು ಸಂಖ್ಯೆ ಅಂಶಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ನೀವು
inpointer ಗಾತ್ರ, ಮತ್ತು

66
00:03:46,770 --> 00:03:49,040
ಡೇಟಾ ಅವುಗಳನ್ನು ಹಾಕುವ.

67
00:03:49,040 --> 00:03:51,695
>> ಈಗ ಅಡ್ಡಲಾಗಿ ಮರುಗಾತ್ರಗೊಳಿಸಲು ಸಮಯ.

68
00:03:51,695 --> 00:03:56,880
ಎನ್ ಪ್ರತಿಯೊಂದು ಪಿಕ್ಸೆಲ್ಗೆ ನಂತರ, 2 ಸಮನಾಗಿರುತ್ತದೆ
, infile, ನಾವು ಬರೆಯಲು ನೀನು

69
00:03:56,880 --> 00:04:00,870
ಎರಡು ಬಾರಿ outfile ರಲ್ಲಿ.

70
00:04:00,870 --> 00:04:02,210
ಹೇಗೆ ನಾವು ಕಡತಗಳನ್ನು ಬರೆಯುವಿರಾ?

71
00:04:02,210 --> 00:04:06,400
ಹಾಗೆಯೇ, ನಾವು ರಚಿಸುವಲ್ಲಿ ಫಂಕ್ಷನ್, ಆದ್ದರಿಂದ
ನಾವು struct ಸೂಚಕವನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು

72
00:04:06,400 --> 00:04:10,170
ನೀವು ನೀವು ಬೈಟ್ಗಳು ಹೊಂದಿದೆ
ಬರೆಯುವ, ಮತ್ತು ನಂತರ ನಾವು ಹಾದು

73
00:04:10,170 --> 00:04:14,430
ಗಾತ್ರ, ಸಂಖ್ಯೆ, ಹಾಗು ಔಟ್ಪುಟ್, ಅಲ್ಲಿ
ನೀವು ಎಂದು ಬರೆಯಲು ನೀನು.

74
00:04:14,430 --> 00:04:19,200
ತದನಂತರ ಒಂದು ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪುನರಾವರ್ತಿಸುವಂತೆ, ಎಂದು
ಲೂಪ್ ಸಾಧ್ಯವಾಗುತ್ತದೆ ಸರಳ ರೋಗ.

75
00:04:19,200 --> 00:04:21,740
>> ಆದರೆ ನಾವು ನೆನಪಿಡುವ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ
ಸೈನ್ ಪ್ಯಾಡಿಂಗ್ ಸೇರಿಸಲು

76
00:04:21,740 --> 00:04:26,040
ಪ್ಯಾಡಿಂಗ್ ಪರಿಕಲ್ಪನೆಯನ್ನು ಎಂದು, ಮತ್ತು,
ಪ್ರತಿ ಪಿಕ್ಸೆಲ್ ಮೂರು ಕಡಿತದ, ಆದರೆ

77
00:04:26,040 --> 00:04:28,940
ಪ್ರತಿ scanline ಮಸ್ಟ್ ಗಾತ್ರ
4 ಬೈಟ್ಗಳು ಒಂದು ಬಹು ಎಂದು.

78
00:04:28,940 --> 00:04:33,660
ಆದ್ದರಿಂದ ಪಿಕ್ಸೆಲ್ಗಳ ಸಂಖ್ಯೆ ವೇಳೆ ಒಂದು
4 ಅನೇಕ, ನಾವು ಕೆಲವು ಸೇರಿಸುವ ಅಗತ್ಯವಿದೆ

79
00:04:33,660 --> 00:04:36,630
ಕೇವಲ ಸೊನ್ನೆಗಳ ಇದು ಪ್ಯಾಡಿಂಗ್,.

80
00:04:36,630 --> 00:04:42,130
ಈಗ, ಇದನ್ನು ಯಾರು ಭಿನ್ನವಾಗಿ, ಮತ್ತು ಭಿನ್ನವಾಗಿ
ಪ್ರತಿಯನ್ನು ನಂತರ, infile ಚಿತ್ರ ಮತ್ತು

81
00:04:42,130 --> 00:04:44,370
outfile ಫೈಲ್ ವಿವಿಧ ಹೊಂದಿರುವುದಿಲ್ಲ
ವಿವಿಧ ಪ್ಯಾಡಿಂಗ್ ಅವರು ಆರ್ ಏಕೆಂದರೆ

82
00:04:44,370 --> 00:04:46,360
ವಿವಿಧ ಅಗಲ.

83
00:04:46,360 --> 00:04:46,690
>> ಸರಿ.

84
00:04:46,690 --> 00:04:51,050
ಆದ್ದರಿಂದ ಬಹುಶಃ ಸೂತ್ರವನ್ನು ಎಂದು
ಇಲ್ಲಿ HANDY ಬರುತ್ತವೆ.

85
00:04:51,050 --> 00:04:55,120
ನಾನು ಕಂಡುಹಿಡಿಯಲು ನಿಮಗೆ ಅದನ್ನು ಬಿಟ್ಟು ಮಾಡುತ್ತೇವೆ, ಆದರೆ
ಪ್ಯಾಡಿಂಗ್ ಬರೆಯಲು, ಎಂದು ಹೇಳಲು,

86
00:04:55,120 --> 00:04:59,360
ಅಲ್ಲದೆ, ಇದನ್ನು ಕೇವಲ ಒಂದು ಸರಳ fputc ಕಾರ್ಯ ನ,
ಮೀ ಸಾಗುವ

87
00:04:59,360 --> 00:05:02,200
ನೀವು ನಂತರ ಬರೆಯಲು ಬಯಸುವ, ಮತ್ತು ಆ
ಕಡತ ಪಾಯಿಂಟರ್ ನೀವು

88
00:05:02,200 --> 00:05:04,280
ಬರೆಯಲು ಮಾಡಿ.

89
00:05:04,280 --> 00:05:08,670
ಈಗ ನಾವು, ಅಡ್ಡಡ್ಡಲಾಗಿ ಗಾತ್ರ ಎಂಬುದನ್ನು
ತದನಂತರ, ಪ್ಯಾಡಿಂಗ್ ಬಳಸಲಾಗುತ್ತದೆ

90
00:05:08,670 --> 00:05:12,030
ನಿಮ್ಮ ಕಡತ ಚಲಿಸಬೇಕಾಗುತ್ತದೆ ನೆನಪು
ಸ್ಥಾನವನ್ನು ಸೂಚಕ, ನೀವು ಏಕೆಂದರೆ

91
00:05:12,030 --> 00:05:14,480
ಪ್ಯಾಡಿಂಗ್ ಒಳಗೆ fread ಸಾಧ್ಯವಿಲ್ಲ.

92
00:05:14,480 --> 00:05:18,230
ಆದ್ದರಿಂದ ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬಯಸುವ ನಿಮ್ಮ ಕಡತ
, infile ಸ್ಥಾನವನ್ನು ಸೂಚಕ

93
00:05:18,230 --> 00:05:19,980
ಸರಿಯಾದ ಹಂತದಲ್ಲಿ ಇದು.

94
00:05:19,980 --> 00:05:23,970
ನಾವು ಬಯಸುವ ಕಾರಣ
ಲಂಬವಾಗಿ ಗಾತ್ರವನ್ನು.

95
00:05:23,970 --> 00:05:27,090
ನಾವು, ಅಡ್ಡಲಾಗಿ ಇದು ವಿಸ್ತಾರಗೊಳಿಸಬಹುದು ಸಾಧ್ಯವಿಲ್ಲ
ಪ್ರತಿ ಸಾಲಿನ ಅಗತ್ಯವಿದೆ ಏಕೆಂದರೆ

96
00:05:27,090 --> 00:05:30,370
N ಬಾರಿ ನಕಲು ಮಾಡಲು.

97
00:05:30,370 --> 00:05:33,050
>> ಈಗ, ವಿವಿಧ ಹಲವಾರು ಇವೆ
ಈ ಮಾಡಲು ರೀತಿಯಲ್ಲಿ.

98
00:05:33,050 --> 00:05:39,010
ಆದ್ದರಿಂದ, ನಾವು ರಲ್ಲಿ, ಪುನಃ ಬರೆಯುವಂತೆ ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು
ನಾವು ಪಿಕ್ಸೆಲ್ಗಳು ಎಲ್ಲಾ ನೆನಪು

99
00:05:39,010 --> 00:05:42,840
ಒಂದು ನಿರ್ದಿಷ್ಟ ವಿನ್ಯಾಸಗಳನ್ನು ಸಾಲು, ಮತ್ತು
ನಂತರ ನಾವು ಆ ಸರಣಿ ಬರೆಯಲು

100
00:05:42,840 --> 00:05:44,730
ಅನೇಕ ಬಾರಿ ಅಗತ್ಯವಿರುವ.

101
00:05:44,730 --> 00:05:49,530
ಅಥವಾ ಅಲ್ಲಿ recopy ವಿಧಾನವು ಇಲ್ಲ,
, infile ಸಾಲು ಓದಿದ ನಂತರ

102
00:05:49,530 --> 00:05:53,530
ಮತ್ತು ತದನಂತರ outfile ಎಂದು ಬರೆಯುವ
ಪ್ಯಾಡಿಂಗ್ ಸೇರಿಸುವ, ನಾವು fseek

103
00:05:53,530 --> 00:05:57,250
ಮೂಲ ಸಾಲು ಶುರುವಾಗುವ ಹಿಂದಕ್ಕೆ,
ಮತ್ತು ನಂತರ ಸಮತಲ ಪುನರಾವರ್ತಿಸಲು

104
00:05:57,250 --> 00:05:58,710
ಅಲ್ಲಿಂದ ಮರುಗಾತ್ರಗೊಳಿಸಲು.

105
00:05:58,710 --> 00:06:02,280
ಹೊರತಾಗಿ ವಿಧಾನದ, ಆದರೂ, ನೀವು ಮಾಡುತ್ತೇವೆ
ಪ್ರತಿ ಪಿಕ್ಸೆಲ್ ಪುನರಾವರ್ತಿಸಬಹುದು ಬಯಸುವ

106
00:06:02,280 --> 00:06:06,370
N ಬಾರಿ, ಮತ್ತು ಪ್ರತಿ ಸಾಲು ಎಂದು
ಹಾಗೆಯೇ N ಬಾರಿ ಪುನರಾವರ್ತನೆಯಾಯಿತು.

107
00:06:06,370 --> 00:06:09,160
>> ಎಂದು, ನೀವು ಬಿಟ್ಮ್ಯಾಪ್ ಹೊಂದಿರುತ್ತದೆ
ಜೀವನದ ದೊಡ್ಡ.

108
00:06:09,160 --> 00:06:11,760
ನನ್ನ ಹೆಸರು Zamyla ಹೊಂದಿದೆ, ಮತ್ತು ಈ CS50 ಹೊಂದಿದೆ.

109
00:06:11,760 --> 00:06:19,542