1
00:00:00,000 --> 00:00:08,532
>> [ಸಂಗೀತ]

2
00:00:08,532 --> 00:00:12,060
>> ZAMYLA ಚಾನ್: ನೀವು ಬಹುಶಃ ಮೊದಲ ವಿಷಯ
ಹೇಗೆ ಬಗ್ಗೆ ಸೂಚನೆ ಎಂದು ನಾವು ಈಗಾಗಲೇ

3
00:00:12,060 --> 00:00:13,450
ಕೋಡ್ ನಮಗೆ ಬರೆದಿದ್ದಾರೆ.

4
00:00:13,450 --> 00:00:15,160
ಈ ವಿತರಣಾ ಕೋಡ್ ಎಂದು ಕರೆಯುತ್ತಾರೆ.

5
00:00:15,160 --> 00:00:18,000
ಆದ್ದರಿಂದ ನಾವು ನಮ್ಮ ಸ್ವಂತ ಬರೆಯಲು ಇಲ್ಲ
ಎಲ್ಲಿಯೂ ಆರಂಭದಿಂದ ಕೋಡ್.

6
00:00:18,000 --> 00:00:22,800
ಬದಲಿಗೆ, ನಾವು ಖಾಲಿಜಾಗಗಳು ತುಂಬುವ ಮಾಡುತ್ತಿದ್ದೇವೆ
ಕೆಲವು ಪೂರ್ವ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕೋಡ್.

7
00:00:22,800 --> 00:00:27,790
>> find.c ಪ್ರೋಗ್ರಾಂ ಸಂಖ್ಯೆಗಳನ್ನು ಕೇಳುತ್ತದೆ
ಬಣಬೆ ತುಂಬಲು, ಹುಡುಕುತ್ತದೆ

8
00:00:27,790 --> 00:00:32,189
ಒಂದು ಬಳಕೆದಾರ ಸಲ್ಲಿಸಿದ ಸೂಜಿ ಬಣಬೆ,
ಮತ್ತು ಇದು ರೀತಿಯ ಕರೆದು ಮೂಲಕ ಹೀಗೆ ಮಾಡುತ್ತದೆ

9
00:00:32,189 --> 00:00:35,590
ಹುಡುಕಾಟ, ಕಾರ್ಯಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ
helpers.c ರಲ್ಲಿ.

10
00:00:35,590 --> 00:00:37,670
ಆದ್ದರಿಂದ find.c ಈಗಾಗಲೇ ಬರೆಯಲಾಗಿದೆ.

11
00:00:37,670 --> 00:00:40,770
ನಿಮ್ಮ ಕೆಲಸ ಸಹಾಯಕರು ಬರೆಯಲು.

12
00:00:40,770 --> 00:00:41,870
>> ನಾವು ಏನು ಮಾಡುತ್ತಿದ್ದಿಯಾ?

13
00:00:41,870 --> 00:00:44,210
ನಾವು ಎರಡು ಕಾರ್ಯಗಳನ್ನು ಅನುಷ್ಠಾನಕ್ಕೆ ಮಾಡುತ್ತಿದ್ದೇವೆ.

14
00:00:44,210 --> 00:00:49,030
ನಿಜವಾದ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಇದು ಹುಡುಕು, ಒಂದು ಮೌಲ್ಯವನ್ನು
ಹಿಂದಿರುಗಿದ, ಬಣಬೆ ಕಂಡುಬರುತ್ತದೆ

15
00:00:49,030 --> 00:00:51,370
ಸುಳ್ಳು ಮೌಲ್ಯವನ್ನು ವೇಳೆ
ಅಲ್ಲ ಬಣಬೆ.

16
00:00:51,370 --> 00:00:57,990
ನಂತರ ನಾವು ರೀತಿಯ ಅನುಷ್ಠಾನಕ್ಕೆ ಮಾಡುತ್ತಿದ್ದೇವೆ
ಇದು ಮೌಲ್ಯಗಳನ್ನು ಎಂಬ ರೀತಿಯ ರಚನೆಯ.

17
00:00:57,990 --> 00:00:59,960
>> ಆದ್ದರಿಂದ ಹುಡುಕಾಟ ನಿಭಾಯಿಸಲು ಅವಕಾಶ.

18
00:00:59,960 --> 00:01:04,560
ಹುಡುಕು ಪ್ರಸ್ತುತ ಅನುಷ್ಠಾನಗೊಳಿಸಲಾಗುತ್ತದೆ
ರೇಖೀಯ ಹುಡುಕಾಟ, ಆದರೆ ನೀವು ತುಂಬಾ ಮಾಡಬಹುದು

19
00:01:04,560 --> 00:01:05,550
ಉತ್ತಮ.

20
00:01:05,550 --> 00:01:09,910
ರೇಖೀಯ ಹುಡುಕಾಟ ಓ ಅಳವಡಿಸಲಾಗಿದೆ
ಎನ್ ಸಮಯ, ಇದು ಸ್ವಲ್ಪ ನಿಧಾನ.

21
00:01:09,910 --> 00:01:13,850
ಆದರೂ, ಇದು ಹುಡುಕಬಹುದು
ಇದು ನೀಡಿದ ಯಾವುದೇ ಪಟ್ಟಿ.

22
00:01:13,850 --> 00:01:20,130
ನಿಮ್ಮ ಕೆಲಸ ಬೈನರಿ ಸರ್ಚ್ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಆಗಿದೆ,
ಲಾಗ್ N ಸಮಯ ಒ ರನ್ ಇದು.

23
00:01:20,130 --> 00:01:21,130
ಆ ಬಹಳ ವೇಗವಾಗಿ ಇಲ್ಲಿದೆ.

24
00:01:21,130 --> 00:01:23,170
>> ಆದರೆ ಒಂದು ಷರತ್ತು ಇಲ್ಲ.

25
00:01:23,170 --> 00:01:27,600
ಬೈನರಿ ಸರ್ಚ್ ಮಾತ್ರ ಹುಡುಕಬಹುದು
ಮೊದಲೇ ವಿಂಗಡಿಸಲಾದ ಪಟ್ಟಿಗಳನ್ನು ಮೂಲಕ.

26
00:01:27,600 --> 00:01:30,370
ಏಕೆ ಎಂದು?

27
00:01:30,370 --> 00:01:32,620
>> ಅಲ್ಲದೆ ನ ಒಂದು ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ.

28
00:01:32,620 --> 00:01:36,280
ಮೌಲ್ಯಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನೀಡಿದ, ಬಣಬೆ,
ನಾವು ನೋಡುತ್ತಿರುವ ನೀನು

29
00:01:36,280 --> 00:01:37,130
ಒಂದು ಸೂಜಿ.

30
00:01:37,130 --> 00:01:40,460
ಮತ್ತು ಈ ಉದಾಹರಣೆಗೆ,
ಪೂರ್ಣಾಂಕ ಮೂರು.

31
00:01:40,460 --> 00:01:44,130
ಬೈನರಿ ಸರ್ಚ್ ಕೆಲಸ ರೀತಿಯಲ್ಲಿ ಎಂದು
ನಾವು ಮಧ್ಯದಲ್ಲಿ ಮೌಲ್ಯವನ್ನು ಹೋಲಿಸಿ

32
00:01:44,130 --> 00:01:48,370
ಹೆಚ್ಚು ಸೂಜಿ ರಚನೆಯ, ಹೇಗೆ
ನಾವು ಮಧ್ಯಮ ಒಂದು ದೂರವಾಣಿ ಪುಸ್ತಕ ತೆರೆಯಿತು

33
00:01:48,370 --> 00:01:50,660
ವಾರದ ಶೂನ್ಯ ರಲ್ಲಿ ಪುಟ.

34
00:01:50,660 --> 00:01:54,650
>> ಆದ್ದರಿಂದ ಮಧ್ಯಮ ಮೌಲ್ಯವನ್ನು ಹೋಲಿಕೆ ನಂತರ
ಸೂಜಿ, ನೀವು ಎರಡೂ ತಿರಸ್ಕರಿಸಬಹುದು

35
00:01:54,650 --> 00:01:58,530
ಎಡ ಅಥವಾ ರಚನೆಯ ಬಲ ಅರ್ಧ
ನಿಮ್ಮ ರಭಸದಿಂದ ಬಿಗಿ ಮೂಲಕ.

36
00:01:58,530 --> 00:02:03,390
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಮೂರು ರಿಂದ ನಮ್ಮ ಸೂಜಿ,
ಕಡಿಮೆ 10, ಮಧ್ಯದ ಮೌಲ್ಯವು ಆಗಿದೆ

37
00:02:03,390 --> 00:02:05,990
ಬಲ ಬೌಂಡ್ ಕಡಿಮೆ ಮಾಡಬಹುದು.

38
00:02:05,990 --> 00:02:08,400
ಆದರೆ ನಿಮ್ಮ ರಭಸದಿಂದ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿ
ಸಾಧ್ಯವಾದಷ್ಟು ಬಿಗಿಯಾಗಿ.

39
00:02:08,400 --> 00:02:11,630
ಮಧ್ಯಮ ಮೌಲ್ಯ ಸೂಜಿ ಇದ್ದರೆ,
ನಂತರ ನೀವು ಅಗತ್ಯವಿಲ್ಲ ತಿಳಿದಿದೆ

40
00:02:11,630 --> 00:02:13,010
ನಿಮ್ಮ ಹುಡುಕಾಟ ಸೇರಿವೆ.

41
00:02:13,010 --> 00:02:17,310
ನೀವು ಬಲ ಹೊರಟ ನೀವು ಬಿಗಿಗೊಳಿಸುತ್ತದಾದರಿಂದ
ಕೇವಲ ಸಣ್ಣ ಬಿಟ್ ಹೆಚ್ಚು ಹುಡುಕಾಟ ಗಡಿ,

42
00:02:17,310 --> 00:02:21,770
ಹೀಗೆ ಇತ್ಯಾದಿ ರವರೆಗೆ
ನಿಮ್ಮ ಸೂಜಿ ಕಾಣಬಹುದು.

43
00:02:21,770 --> 00:02:23,480
>> ಹಾಗಾಗಿ ಸೂಡೊಕೋಡ್ಗಳನ್ನು ರೀತಿ ಮಾಡುವುದಿಲ್ಲ?

44
00:02:23,480 --> 00:02:28,420
ನಾವು ಇನ್ನೂ ಮೂಲಕ ಹುಡುಕುತ್ತಿರುವ ಚೆನ್ನಾಗಿ
ಪಟ್ಟಿ ಮತ್ತು ಇನ್ನೂ ಅಂಶಗಳನ್ನು ಹೊಂದಿವೆ

45
00:02:28,420 --> 00:02:33,690
ನೋಡಲು, ನಾವು, ಪಟ್ಟಿ ಮಧ್ಯದಲ್ಲಿ ತೆಗೆದುಕೊಳ್ಳಬಹುದು
ಮತ್ತು ಮಧ್ಯದ ಮೌಲ್ಯವು ಹೋಲಿಸಿ

46
00:02:33,690 --> 00:02:34,950
ನಮ್ಮ ಸೂಜಿ.

47
00:02:34,950 --> 00:02:37,310
ಅವರು ಸಮಾನ ಆಗಿದ್ದರೆ, ಆಗ ನಾವು ನೀವು ಅರ್ಥ
ಸೂಜಿ ಕಂಡು ಮತ್ತು ನಾವು

48
00:02:37,310 --> 00:02:38,990
ನಿಜವಾದ ಹಿಂತಿರುಗಿ.

49
00:02:38,990 --> 00:02:42,870
>> ಇಲ್ಲವಾದರೆ, ಸೂಜಿ ಕಡಿಮೆ ವೇಳೆ
ಮಧ್ಯದ ಮೌಲ್ಯವು ನಂತರ ನಾವು ಅರ್ಥ

50
00:02:42,870 --> 00:02:47,280
ಬಲ ಅರ್ಧ ತಿರಸ್ಕರಿಸಲು ಕೇವಲ ಮಾಡಬಹುದು
ರಚನೆಯ ಎಡಭಾಗದಲ್ಲಿ ಹುಡುಕಲು.

51
00:02:47,280 --> 00:02:51,090
ಇಲ್ಲವಾದರೆ, ನಾವು ಹುಡುಕಲು ಮಾಡುತ್ತೇವೆ
ರಚನೆಯ ಬಲಭಾಗದ.

52
00:02:51,090 --> 00:02:54,410
ಮತ್ತು ಕೊನೆಯಲ್ಲಿ, ನೀವು ಯಾವುದೇ ಇಲ್ಲ
ಹೆಚ್ಚು ಹುಡುಕಲು ಎಡ ಅಂಶಗಳನ್ನು ಆದರೆ ನೀವು

53
00:02:54,410 --> 00:02:58,050
ನೀವು ನಂತರ, ಇನ್ನೂ ನಿಮ್ಮ ಸೂಜಿ ಕಂಡುಬಂದಿಲ್ಲ
ಸುಳ್ಳು ಹಿಂತಿರುಗಿ ಏಕೆಂದರೆ ಸೂಜಿ

54
00:02:58,050 --> 00:03:01,890
ಖಂಡಿತವಾಗಿಯೂ ಬಣಬೆ ಅಲ್ಲ.

55
00:03:01,890 --> 00:03:05,270
>> ಈ ಸೂಡೊಕೋಡ್ಗಳನ್ನು ಬಗ್ಗೆ ಈಗ ಅಚ್ಚುಕಟ್ಟಾಗಿ ವಿಷಯ
ಬೈನರಿ ಸರ್ಚ್ ಅದನ್ನು ಮಾಡುತ್ತದೆ

56
00:03:05,270 --> 00:03:09,940
ರೋಗ ಎರಡೂ ತಿಳಿಯುತ್ತದೆ
ಅಥವಾ ಪುನರಾವರ್ತಿತ ಅನುಷ್ಠಾನ.

57
00:03:09,940 --> 00:03:13,810
ನೀವು ಎಂದು ಆದ್ದರಿಂದ ಇದು ಪುನರಾವರ್ತಿತ ಎಂದು
ಹುಡುಕಾಟ ಒಳಗೆ ಹುಡುಕಾಟ ಕಾರ್ಯ

58
00:03:13,810 --> 00:03:17,350
ರಚನೆಯ ಎರಡೂ ಅರ್ಧ ಮೇಲೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ.

59
00:03:17,350 --> 00:03:21,030
ನಾವು ಸ್ವಲ್ಪ ನಂತರ ರಿಕರ್ಶನ್ ರಕ್ಷಣೆ ಮಾಡುತ್ತೇವೆ
ಸಹಜವಾಗಿ, ಆದರೆ ಇದು ಒಂದು ಎಂದು ಗೊತ್ತು

60
00:03:21,030 --> 00:03:24,190
ಆಯ್ಕೆಯನ್ನು ನೀವು ಪ್ರಯತ್ನಿಸಿ ಬಯಸಿದಲ್ಲಿ.

61
00:03:24,190 --> 00:03:26,030
>> ಈಗ ವಿಂಗಡಿಸಿ ನೋಡೋಣ.

62
00:03:26,030 --> 00:03:30,750
ವಿಂಗಡಿಸಿ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಮತ್ತು ಪೂರ್ಣಾಂಕ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ
ರಚನೆಯ ಗಾತ್ರ N,.

63
00:03:30,750 --> 00:03:34,030
ಈಗ ವಿವಿಧ ವಿವಿಧ ರೀತಿಯ
ರೀತಿಯ, ಮತ್ತು ನೀವು ಕೆಲವು ನೋಡಬಹುದು

64
00:03:34,030 --> 00:03:36,370
ಡೆಮೊಗಳು ಮತ್ತು ವಿವರಣೆಗಳಿಗೆ ಕಿರು.

65
00:03:36,370 --> 00:03:39,580
ಪ್ರತಿಯಾಗಿ ರೀತಿಯ ನಮ್ಮ
ರೀತಿಯ ಕಾರ್ಯದಲ್ಲಿ ಅನೂರ್ಜಿತ.

66
00:03:39,580 --> 00:03:43,580
ಆದ್ದರಿಂದ ನಾವು ಹೋಗುತ್ತಿಲ್ಲ ಅರ್ಥ
ರೀತಿಯ ಯಾವುದೇ ವ್ಯೂಹ ಮರಳಲು.

67
00:03:43,580 --> 00:03:48,140
ನಾವು ವಾಸ್ತವವಾಗಿ ಬಹಳ ಬದಲಾಯಿಸಲು ನೀನು
ನಮಗೆ ಒಳಗೆ ರವಾನಿಸಲಾಗಿದೆ ಎಂದು ರಚನೆಯ.

68
00:03:48,140 --> 00:03:52,290
>> ಸರಣಿಗಳ ಏಕೆಂದರೆ ಸಾಧ್ಯತೆಯೂ
ನಾವು ಈಗ ಸಿ ಉಲ್ಲೇಖ ಮಾಡುತ್ತೇವೆ ಜಾರಿಗೆ

69
00:03:52,290 --> 00:03:55,290
ನಂತರ ಈ ಬಗ್ಗೆ ಹೆಚ್ಚು ನೋಡಿ, ಆದರೆ
ರವಾನಿಸುವುದನ್ನು ನಡುವಿನ ಅವಶ್ಯಕ ವ್ಯತ್ಯಾಸ

70
00:03:55,290 --> 00:03:59,340
ಒಂದು ಪೂರ್ಣಾಂಕ ಮತ್ತು ಹಾದುಹೋಗುವ ರೀತಿಯ
ಒಂದು ಶ್ರೇಣಿಯನ್ನು, ಎಂದು ನೀವು

71
00:03:59,340 --> 00:04:03,490
ಒಂದು ಪೂರ್ಣಾಂಕ ಹಾದು, ಸಿ ಕೇವಲ ಹೋಗುತ್ತದೆ
ಪೂರ್ಣಾಂಕ ಪ್ರತಿಯನ್ನು ಮಾಡಲು ಮತ್ತು ರವಾನಿಸಲು

72
00:04:03,490 --> 00:04:04,450
ಫಂಕ್ಷನ್ ಇದು.

73
00:04:04,450 --> 00:04:08,530
ಮೂಲ ವೇರಿಯಬಲ್ ಬದಲಾಗುವುದಿಲ್ಲ
ಕಾರ್ಯ ಮುಗಿದ ನಂತರ.

74
00:04:08,530 --> 00:04:12,480
ಸಹಿತ, ಮತ್ತೊಂದೆಡೆ, ಅದು
ಪ್ರತಿಯನ್ನು ಮಾಡಲು ಹೋಗಿ, ಮತ್ತು ನೀವು ಅಲ್ಲ

75
00:04:12,480 --> 00:04:17,910
ವಾಸ್ತವವಾಗಿ ಸಂಪಾದನೆ
ಬಹಳ ರಚನೆಯ ಸ್ವತಃ.

76
00:04:17,910 --> 00:04:21,269
>> ಆದ್ದರಿಂದ ರೀತಿಯ ಒಂದು ವಿಧ
ಆಯ್ಕೆ ರೀತಿಯ.

77
00:04:21,269 --> 00:04:24,750
ಆಯ್ಕೆ ರೀತಿಯ ಪ್ರಾರಂಭವಾಗುವ ಕೆಲಸ
ನೀವು ತಿರುಗಿ ನಂತರ ಆರಂಭದಲ್ಲಿ, ಮತ್ತು

78
00:04:24,750 --> 00:04:26,820
ಮೇಲೆ ಮತ್ತು ಚಿಕ್ಕ ಅಂಶ ಪಡೆಯುವ.

79
00:04:26,820 --> 00:04:30,710
ತದನಂತರ ನೀವು ಸ್ವ್ಯಾಪ್ ಚಿಕ್ಕ
ಮೊದಲ ಒಂದು ಅಂಶ.

80
00:04:30,710 --> 00:04:34,360
ನಂತರ ನೀವು ಎರಡನೇ ಅಂಶ ಸರಿಸಲು
, ಮುಂದಿನ ಚಿಕ್ಕ ಹೇಗೆ

81
00:04:34,360 --> 00:04:38,320
ನಂತರ ಅಂಶ, ಮತ್ತು ಸ್ವ್ಯಾಪ್ ಜೊತೆ
ರಚನೆಯ ಎರಡನೆಯ ಅಂಶ ಏಕೆಂದರೆ

82
00:04:38,320 --> 00:04:41,100
ಮೊದಲ ಅಂಶ ಈಗಾಗಲೇ ಪ್ರತ್ಯೇಕಿಸಲ್ಪಡುತ್ತವೆ.

83
00:04:41,100 --> 00:04:45,370
ಮತ್ತು ಆದ್ದರಿಂದ ನೀವು ಪ್ರತಿ ಮುಂದುವರೆಯಲು
ಚಿಕ್ಕ ಗುರುತಿಸುವ ಅಂಶ

84
00:04:45,370 --> 00:04:47,690
ಮೌಲ್ಯ ಮತ್ತು ಔಟ್ ವಿನಿಮಯ.

85
00:04:47,690 --> 00:04:53,460
>> ನಾನು 0, ಮೊಟ್ಟಮೊದಲ ಅಂಶ ಸಮನಾಗಿರುತ್ತದೆ ಫಾರ್
ಎನ್ ಮೈನಸ್ 1, ನೀವು ಹೋಲಿಸಲು ನೀನು

86
00:04:53,460 --> 00:04:57,820
ಪ್ರತಿ ಮುಂದಿನ ನಂತರ ಮೌಲ್ಯ ಮತ್ತು ಹೇಗೆ
ಕನಿಷ್ಠ ಮೌಲ್ಯದ ಸೂಚ್ಯಂಕ.

87
00:04:57,820 --> 00:05:02,520
ನೀವು ಕನಿಷ್ಠ ಮೌಲ್ಯವನ್ನು ಸೂಚ್ಯಂಕ ಹೇಗೆ ಒಮ್ಮೆ,
ನೀವು ರಚನೆಯ ಮೌಲ್ಯವನ್ನು ವಿನಿಮಯ ಮಾಡಬಹುದು

88
00:05:02,520 --> 00:05:05,930
ಕನಿಷ್ಠ ಮತ್ತು ರಚನೆಯ ಐ

89
00:05:05,930 --> 00:05:09,760
>> ರೀತಿಯ ಮತ್ತೊಂದು ವಿಧದ ಎಂದು ನೀವು
ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಬಲ್ ರೀತಿಯ ಆಗಿದೆ.

90
00:05:09,760 --> 00:05:14,380
ಪಟ್ಟಿಯ ಮೇಲೆ ಆದ್ದರಿಂದ ಬಬಲ್ ರೀತಿಯ iterates
ಪಕ್ಕದ ಅಂಶಗಳನ್ನು ಮತ್ತು ಹೋಲಿಸುವ

91
00:05:14,380 --> 00:05:17,720
ಅಂಶಗಳನ್ನು ಬದಲಾಯಿಸಿಕೊಳ್ಳಬೇಕು ಎಂದು
ತಪ್ಪು ಕ್ರಮದಲ್ಲಿ ಇರುತ್ತದೆ.

92
00:05:17,720 --> 00:05:22,380
ಮತ್ತು ಈ ರೀತಿಯಲ್ಲಿ, ದೊಡ್ಡ ಅಂಶ
ಬಬಲ್ ಕೊನೆಯಲ್ಲಿ ತಿನ್ನುವೆ.

93
00:05:22,380 --> 00:05:28,070
ಮತ್ತು ಪಟ್ಟಿ ಒಮ್ಮೆ ಯಾವುದೇ ಪ್ರತ್ಯೇಕಿಸಲ್ಪಡುತ್ತವೆ
ಅಂಶಗಳನ್ನು ವಿನಿಮಯವಾಗಿದೆ ಮಾಡಲಾಗಿತ್ತು.

94
00:05:28,070 --> 00:05:31,920
>> ಆದ್ದರಿಂದ ಆ ರೀತಿಯ ಎರಡು ಉದಾಹರಣೆಗಳು
ನೀವು ಕಾರ್ಯಗತಗೊಳಿಸುವುದಿಲ್ಲ ಎಂಬುದನ್ನು ಕ್ರಮಾವಳಿಗಳು

95
00:05:31,920 --> 00:05:33,230
ಹೇಗೆ ಕಾರ್ಯಕ್ರಮ.

96
00:05:33,230 --> 00:05:37,350
ನೀವು ರೀತಿಯ ಪೂರ್ಣಗೊಳಿಸಲು, ಮತ್ತು ನೀವು ಒಮ್ಮೆ
ಹುಡುಕಾಟ ಮಾಡಲಾಗುತ್ತದೆ, ನೀವು ಗಳಿಸಿದರು ಮಾಡುತ್ತಿದ್ದೇವೆ.

97
00:05:37,350 --> 00:05:39,720
ನನ್ನ ಹೆಸರು Zamyla ಹೊಂದಿದೆ, ಮತ್ತು ಈ CS50 ಹೊಂದಿದೆ.

98
00:05:39,720 --> 00:05:46,987
>> [ಸಂಗೀತ]