1
00:00:00,000 --> 00:00:05,830

2
00:00:05,830 --> 00:00:07,910
>> ಸರಿ,, ಕಾಂಪ್ಯುಟೇಶನಲ್ ಸಂಕೀರ್ಣತೆ.

3
00:00:07,910 --> 00:00:10,430
ಎಚ್ಚರಿಕೆ ಕೇವಲ ಒಂದು ಬಿಟ್
ನಾವು ತುಂಬಾ far-- ಧುಮುಕುವುದಿಲ್ಲ ಮೊದಲು

4
00:00:10,430 --> 00:00:13,070
ಬಹುಶಃ ನಡುವೆ ಮಾಡುತ್ತೇವೆ
ಅತ್ಯಂತ ಗಣಿತ ಹೆವಿ ವಸ್ತುಗಳನ್ನು

5
00:00:13,070 --> 00:00:14,200
ನಾವು CS50 ಬಗ್ಗೆ ಮಾತನಾಡಲು.

6
00:00:14,200 --> 00:00:16,950
ಆಶಾದಾಯಕವಾಗಿ ಇದು ತುಂಬಾ ಅಗಾಧ ಸಾಧ್ಯವಿಲ್ಲ
ಮತ್ತು ನಾವು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಮಾರ್ಗದರ್ಶನ ನೀಡುತ್ತೇವೆ

7
00:00:16,950 --> 00:00:19,200
ಪ್ರಕ್ರಿಯೆಯ ಮೂಲಕ, ಆದರೆ
ನ್ಯಾಯಯುತ ಎಚ್ಚರಿಕೆ ಕೇವಲ ಒಂದು ಬಿಟ್.

8
00:00:19,200 --> 00:00:21,282
ಸ್ವಲ್ಪ ಇಲ್ಲ
ಗಣಿತದ ಇಲ್ಲಿ ಒಳಗೊಂಡಿರುವ.

9
00:00:21,282 --> 00:00:23,990
ಸರಿ, ಆದ್ದರಿಂದ ಸಲುವಾಗಿ ಮಾಡಲು
ನಮ್ಮ ಕಾಂಪ್ಯುಟೇಶನಲ್ ಸಂಪನ್ಮೂಲಗಳ ಬಳಕೆ

10
00:00:23,990 --> 00:00:28,170
ನಿಜವಾದ ವಿಶ್ವದಲ್ಲೇ ಇದು ನಿಜವಾಗಿಯೂ
ಕ್ರಮಾವಳಿಗಳು ತಿಳಿಯುವುದು ಮುಖ್ಯ

11
00:00:28,170 --> 00:00:30,750
ಮತ್ತು ಹೇಗೆ ದತ್ತಾಂಶವನ್ನು.

12
00:00:30,750 --> 00:00:32,810
ನಾವು ಹೊಂದಿದ್ದರೆ ನಿಜವಾಗಿಯೂ
ಸಮರ್ಥ ಅಲ್ಗಾರಿದಮ್, ನಾವು

13
00:00:32,810 --> 00:00:36,292
ಸಂಪನ್ಮೂಲಗಳ ಪ್ರಮಾಣದ ಕಡಿಮೆ ಮಾಡಬಹುದು
ನಾವು ವ್ಯವಹರಿಸುವ ಲಭ್ಯವಿರುವ ಹೊಂದಿವೆ.

14
00:00:36,292 --> 00:00:38,750
ನಾವು ಒಂದು ಕ್ರಮಾವಳಿ ಹೊಂದಿದ್ದರೆ ಆ
ಕೆಲಸ ಬಹಳಷ್ಟು ನಾಯಕನನ್ನು ಇದೆ

15
00:00:38,750 --> 00:00:41,210
ನಿಜವಾಗಿಯೂ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು
ಮಾಹಿತಿಗಳ ಬೃಹತ್ ಸೆಟ್, ಅದು

16
00:00:41,210 --> 00:00:44,030
ಹೆಚ್ಚು ಅಗತ್ಯವಿದೆ ಹೋಗಿ
ಹೆಚ್ಚು ಸಂಪನ್ಮೂಲಗಳು, ಮತ್ತು ಇದು

17
00:00:44,030 --> 00:00:47,980
ವಿಷಯವನ್ನು ಹಣ, RAM ಎಲ್ಲಾ ರೀತಿಯ.

18
00:00:47,980 --> 00:00:52,090
>> ಆದ್ದರಿಂದ, ಸಾಧ್ಯವಾಗದ ಒಂದು ವಿಶ್ಲೇಷಿಸಲು
ಕ್ರಮಾವಳಿ, ಈ ಉಪಕರಣವನ್ನು ಬಳಸಿ

19
00:00:52,090 --> 00:00:56,110
ಮೂಲತಃ, ಪ್ರಶ್ನೆ ಕೇಳುತ್ತದೆ
ಈ ಕ್ರಮಾವಳಿಯ ಪ್ರಮಾಣದ ಹೇಗೆ

20
00:00:56,110 --> 00:00:59,020
ನಾವು ಅದನ್ನು ಹೆಚ್ಚು ಡೇಟಾವನ್ನು ಎಸೆಯಲು ಎಂದು?

21
00:00:59,020 --> 00:01:02,220
CS50 ರಲ್ಲಿ, ನಾವು ಅಕ್ಷಾಂಶ ಪ್ರಮಾಣವನ್ನು ಆರ್
ಕೆಲಸ ಬಹಳ ಚಿಕ್ಕದಾಗಿದೆ.

22
00:01:02,220 --> 00:01:05,140
ಸಾಮಾನ್ಯವಾಗಿ, ನಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳು ಹೋಗುವ
ಎರಡನೇ ಅಥವಾ less-- ಚಲಾಯಿಸಲು

23
00:01:05,140 --> 00:01:07,830
ಬಹುಶಃ ಸಾಕಷ್ಟು ಕಡಿಮೆ
ವಿಶೇಷವಾಗಿ ಆರಂಭಿಕ.

24
00:01:07,830 --> 00:01:12,250
>> ಆದರೆ ವ್ಯವಹರಿಸುತ್ತದೆ ಒಂದು ಕಂಪನಿಯ ಬಗ್ಗೆ
ಗ್ರಾಹಕರು ಲಕ್ಷಾಂತರ ನೂರಾರು.

25
00:01:12,250 --> 00:01:14,970
ಅವರು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಅಗತ್ಯವಿದೆ
ಗ್ರಾಹಕ ಮಾಹಿತಿ.

26
00:01:14,970 --> 00:01:18,260
ಗ್ರಾಹಕರ ಸಂಖ್ಯೆ ಅವರು
ಹೊಂದಿರುತ್ತವೆ, ದೊಡ್ಡ ಮತ್ತು ದೊಡ್ಡ ಪಡೆಯುತ್ತದೆ

27
00:01:18,260 --> 00:01:21,230
ಇದು ಅಗತ್ಯ ವಿಶೇಷವೇನು
ಹೆಚ್ಚು ಸಂಪನ್ಮೂಲಗಳು.

28
00:01:21,230 --> 00:01:22,926
ಎಷ್ಟು ಹೆಚ್ಚು ಸಂಪನ್ಮೂಲಗಳನ್ನು?

29
00:01:22,926 --> 00:01:25,050
ಅಲ್ಲದೆ, ಹೇಗೆ ಅವಲಂಬಿಸಿರುತ್ತದೆ
ನಾವು ಅಲ್ಗಾರಿದಮ್ ವಿಶ್ಲೇಷಿಸುವುದು

30
00:01:25,050 --> 00:01:28,097
ಈ ಉಪಕರಣ ಸಾಧನಗಳನ್ನು ಬಳಸುವ.

31
00:01:28,097 --> 00:01:31,180
ನಾವು ಸಂಕೀರ್ಣತೆ ಬಗ್ಗೆ ಮಾತನಾಡಿ
ಒಂದು ಕ್ರಮಾವಳಿಯ ಕೆಲವೊಮ್ಮೆ ನೀವು ಮಾಡುತ್ತೇವೆ

32
00:01:31,180 --> 00:01:34,040
ಇದು ಸಮಯ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ ಕೇಳಲು
ಸಂಕೀರ್ಣತೆಯ ಅಥವಾ ಸ್ಪೇಸ್ ಸಂಕೀರ್ಣತೆ

33
00:01:34,040 --> 00:01:36,190
ಆದರೆ ನಾವು ನೀನು
complexity-- ಕರೆ

34
00:01:36,190 --> 00:01:38,770
ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಬಗ್ಗೆ ನೀವು
ಕೆಟ್ಟ ಸಂದರ್ಭಗಳಲ್ಲಿ.

35
00:01:38,770 --> 00:01:42,640
ಸಂಪೂರ್ಣ ಕೆಟ್ಟ ರಾಶಿಯನ್ನು ನೀಡಲಾಗಿದೆ
ನಾವು ಅದನ್ನು ಎಸೆಯುವ ಎಂದು ಮಾಹಿತಿ,

36
00:01:42,640 --> 00:01:46,440
ಹೇಗೆ ಈ ಅಲ್ಗಾರಿದಮ್ ಹೋಗುತ್ತದೆ
ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಅಥವಾ ದಶಮಾಂಶ ಎದುರಿಸಲು?

37
00:01:46,440 --> 00:01:51,450
ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ಕರೆ
ಒಂದು ಕ್ರಮಾವಳಿ ದೊಡ್ಡ ಓ ರನ್ಟೈಮ್.

38
00:01:51,450 --> 00:01:56,770
ಆದ್ದರಿಂದ ಒಂದು ಕ್ರಮಾವಳಿ ಹೇಳಬಹುದು
N ವರ್ಗ ಅಥವಾ n ಓ ಓ ರನ್.

39
00:01:56,770 --> 00:01:59,110
ಬಗ್ಗೆ ಮತ್ತು ಹೆಚ್ಚು
ಆ ಎರಡನೇ ಅರ್ಥ.

40
00:01:59,110 --> 00:02:01,620
>> ಕೆಲವೊಮ್ಮೆ, ಆದರೂ, ನಾವು ಕಾಳಜಿ
ಅತ್ಯುತ್ತಮ ಸಂದರ್ಭಗಳಲ್ಲಿ ಬಗ್ಗೆ.

41
00:02:01,620 --> 00:02:05,400
ಡೇಟಾ ಎಲ್ಲವೂ ಇದ್ದರೆ ನಾವು ಬೇಕಾಗಿದ್ದಾರೆ
ಇದು ಎಂದು ಮತ್ತು ಸಂಪೂರ್ಣವಾಗಿ ಪರಿಪೂರ್ಣ

42
00:02:05,400 --> 00:02:09,630
ಮತ್ತು ನಾವು ಈ ಪರಿಪೂರ್ಣ ಕಳುಹಿಸುವ
ನಮ್ಮ ಅಲ್ಗಾರಿದಮ್ ಮೂಲಕ ದತ್ತಾಂಶದ ಸೆಟ್.

43
00:02:09,630 --> 00:02:11,470
ಹೇಗೆ ಆ ಪರಿಸ್ಥಿತಿಯಲ್ಲಿ ನಿಭಾಯಿಸಲು ಎಂದು?

44
00:02:11,470 --> 00:02:15,050
ನಾವು ಕೆಲವೊಮ್ಮೆ ಎಂದು ನೋಡಿ
ದೊಡ್ಡ ಒಮೆಗಾ, ದೊಡ್ಡ ಓ ತದ್ವಿರುದ್ಧವಾಗಿರುತ್ತದೆ, ಆದ್ದರಿಂದ

45
00:02:15,050 --> 00:02:16,530
ನಾವು ದೊಡ್ಡ ಒಮೆಗಾ ಹೊಂದಿವೆ.

46
00:02:16,530 --> 00:02:18,880
ಅತ್ಯುತ್ತಮ ಸಂದರ್ಭಗಳಲ್ಲಿ ಬಿಗ್-ಒಮೆಗಾ.

47
00:02:18,880 --> 00:02:21,319
ಕೆಟ್ಟ ಸಂದರ್ಭಗಳಲ್ಲಿ ಬಿಗ್-ಓ.

48
00:02:21,319 --> 00:02:23,860
ಸಾಮಾನ್ಯವಾಗಿ, ನಾವು ಬಗ್ಗೆ ಮಾತಾಡುವುದನ್ನು
ಒಂದು ಕ್ರಮಾವಳಿ ಸಂಕೀರ್ಣತೆ,

49
00:02:23,860 --> 00:02:26,370
ನಾವು ಬಗ್ಗೆ ಮಾತನಾಡುವ ನೀವು
ಕೆಟ್ಟ ಸಂದರ್ಭಗಳಲ್ಲಿ.

50
00:02:26,370 --> 00:02:28,100
ಆದ್ದರಿಂದ ಮನಸ್ಸಿನಲ್ಲಿ ಆ ಇರಿಸಿಕೊಳ್ಳಲು.

51
00:02:28,100 --> 00:02:31,510
>> ಮತ್ತು ಈ ವರ್ಗ, ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ನೀನು
ಪಕ್ಕಕ್ಕೆ ಕಠಿಣ ವಿಶ್ಲೇಷಣೆಯಿಂದ ಬಿಡಲು.

52
00:02:31,510 --> 00:02:35,350
ವಿಜ್ಞಾನ ಮತ್ತು ಜಾಗ ಇವೆ
ಸ್ಟಫ್ ಈ ರೀತಿಯ ಮೀಸಲಾದ.

53
00:02:35,350 --> 00:02:37,610
ನಾವು ತಾರ್ಕಿಕ ಬಗ್ಗೆ ಮಾತನಾಡಿ
ಕ್ರಮಾವಳಿಗಳು ಮೂಲಕ,

54
00:02:37,610 --> 00:02:41,822
ನಾವು ಅನೇಕ ತುಂಡು ಮೂಲಕ ತುಂಡು ಮಾಡುತ್ತೇನೆ ಇದು
ಕ್ರಮಾವಳಿಗಳು ನಾವು ವರ್ಗ ಬಗ್ಗೆ ಮಾತನಾಡಲು.

55
00:02:41,822 --> 00:02:44,780
ನಾವು ನಿಜವಾಗಿಯೂ ಕೇವಲ ಬಗ್ಗೆ ನೀವು
ಸಾಮಾನ್ಯ ಪ್ರಜ್ಞೆಯ ಮೂಲಕ ತಾರ್ಕಿಕ

56
00:02:44,780 --> 00:02:47,070
ಸೂತ್ರಗಳನ್ನು, ಅಥವಾ ಸಾಕ್ಷ್ಯಗಳನ್ನು,
ಅಥವಾ ಹಾಗೆ ಏನು.

57
00:02:47,070 --> 00:02:51,600
ಆದ್ದರಿಂದ ಚಿಂತಿಸಬೇಡಿ, ನಾವು ಸಾಧ್ಯವಿಲ್ಲ
ದೊಡ್ಡ ಗಣಿತ ವರ್ಗದ ಬದಲಾಗುವ.

58
00:02:51,600 --> 00:02:55,920
>> ಹಾಗಾಗಿ ನಾವು ಸಂಕೀರ್ಣತೆ ಕಾಳಜಿವಹಿಸುವ ಹೇಳಿದರು
ಇದು ಪ್ರಶ್ನೆ ಹೇಗೆ ಕೇಳುತ್ತದೆ ಏಕೆಂದರೆ

59
00:02:55,920 --> 00:03:00,160
ನಮ್ಮ ಕ್ರಮಾವಳಿಗಳು ದೊಡ್ಡ ನಿರ್ವಹಿಸಲು ಇಲ್ಲ ಮತ್ತು
ದೊಡ್ಡ ಡೇಟಾ ಸೆಟ್ಗಳನ್ನು ಅವುಗಳನ್ನು ಎಸೆಯಲ್ಪಟ್ಟಾಗ.

60
00:03:00,160 --> 00:03:01,960
ಸರಿ, ಒಂದು ಮಾಹಿತಿ ಸೆಟ್ ಏನು?

61
00:03:01,960 --> 00:03:03,910
ನಾನು ಹೇಳಿದರು ನಾನು ಏನು ಹೇಳಿದಿರಿ?

62
00:03:03,910 --> 00:03:07,600
ಇದು ಅತ್ಯಂತ ಮಾಡುತ್ತದೆ ಯಾವುದೇ ಅರ್ಥ
ಸಾಂದರ್ಭಿಕ ಅರ್ಥ, ಪ್ರಾಮಾಣಿಕವಾಗಿ.

63
00:03:07,600 --> 00:03:11,160
ನಾವು ಒಂದು ಕ್ರಮಾವಳಿ, ಹೊಂದಿದ್ದರೆ
ಪ್ರಕ್ರಿಯೆಗಳು Strings-- ನಾವು ಬಹುಶಃ ಆರ್

64
00:03:11,160 --> 00:03:13,440
ಸ್ಟ್ರಿಂಗ್ ಗಾತ್ರವನ್ನು ಬಗ್ಗೆ.

65
00:03:13,440 --> 00:03:15,190
ಈ ಅಂಕಿಅಂಶಗಳ ಇಲ್ಲಿದೆ ಸೆಟ್
ಗಾತ್ರ, ಸಂಖ್ಯೆ

66
00:03:15,190 --> 00:03:17,050
ಸ್ಟ್ರಿಂಗ್ ರೂಪಿಸುವ ಪಾತ್ರಗಳ.

67
00:03:17,050 --> 00:03:20,090
ನಾವು ಬಗ್ಗೆ ಮಾತನಾಡುವ ನೀವು,
ಕಡತಗಳನ್ನು ಸಂಸ್ಕರಿಸುವ ಕ್ರಮಾವಳಿ

68
00:03:20,090 --> 00:03:23,930
ನಾವು ಹೇಗೆ ಬಗ್ಗೆ ಇರಬಹುದು
ಅನೇಕ ಕಿಲೋಬೈಟ್ಗಳಷ್ಟು ಫೈಲ್ ಒಳಗೊಂಡಿದೆ.

69
00:03:23,930 --> 00:03:25,710
ಮತ್ತು ಡೇಟಾವನ್ನು ಸೆಟ್ ಇಲ್ಲಿದೆ.

70
00:03:25,710 --> 00:03:28,870
ನಾವು ಒಂದು ಕ್ರಮಾವಳಿ ಬಗ್ಗೆ ಬಳಸುತ್ತಿದ್ದರೆ
ಎಂದು, ಹೆಚ್ಚು ಸಾಮಾನ್ಯವಾಗಿ ರಚನೆಗಳು ನಿಭಾಯಿಸುತ್ತದೆ

71
00:03:28,870 --> 00:03:31,510
ಉದಾಹರಣೆಗೆ ವಿಂಗಡಣೆ ಕ್ರಮಾವಳಿಗಳು
ಅಥವಾ ಕ್ರಮಾವಳಿಗಳು ಹುಡುಕುವ,

72
00:03:31,510 --> 00:03:36,690
ನಾವು ಬಹುಶಃ ಸಂಖ್ಯೆ ಬಗ್ಗೆ ನೀವು
ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಒಳಗೊಂಡಿರುವ ಅಂಶಗಳನ್ನು.

73
00:03:36,690 --> 00:03:39,272
>> ಈಗ, ನಾವು ಒಂದು ಅಳೆಯಬಹುದು
ಕ್ರಮಾವಳಿಯ ನಿರ್ದಿಷ್ಟವಾಗಿ,

74
00:03:39,272 --> 00:03:40,980
ನಾನು ಹೇಳಲು ನಾವು
ನಾನು, ಒಂದು ಕ್ರಮಾವಳಿ ಅಳೆಯಲು

75
00:03:40,980 --> 00:03:43,840
ನಾವು ಹೇಗೆ ಅಳೆಯಬಹುದು ಅರ್ಥ
ಅನೇಕ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಅದನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

76
00:03:43,840 --> 00:03:48,990
ಆ ಸಂಪನ್ಮೂಲಗಳ ಎಂಬುದು, ಎಷ್ಟು
RAM ನ ಬೈಟ್ಗಳು ಅಥವಾ RAM ಮೆಗಾಬೈಟ್

77
00:03:48,990 --> 00:03:49,790
ಇದು ಬಳಸುತ್ತದೆ.

78
00:03:49,790 --> 00:03:52,320
ಅಥವಾ ಎಷ್ಟು ಸಮಯ ಚಲಾಯಿಸಲು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

79
00:03:52,320 --> 00:03:56,200
ಮತ್ತು ನಾವು ಈ ಕರೆಯಬಹುದು
n ನ ಎಫ್, ನಿರಂಕುಶವಾಗಿ, ಅಳೆಯಲು.

80
00:03:56,200 --> 00:03:59,420
ಅಲ್ಲಿ n ನ ಸಂಖ್ಯೆ
ಡೇಟಾ ಸೆಟ್ ಅಂಶಗಳ.

81
00:03:59,420 --> 00:04:02,640
ಮತ್ತು n ನ ಎಫ್ ಎಷ್ಟು somethings ಆಗಿದೆ.

82
00:04:02,640 --> 00:04:07,530
ಎಷ್ಟು ಸಂಪನ್ಮೂಲಗಳ ಘಟಕಗಳು ಮಾಡುತ್ತದೆ
ಇದು ದತ್ತಾಂಶವನ್ನು ಅಗತ್ಯವಿರುತ್ತದೆ.

83
00:04:07,530 --> 00:04:10,030
>> ಈಗ, ನಾವು ವಾಸ್ತವವಾಗಿ ಹೆದರುವುದಿಲ್ಲ
ನಿಖರವಾಗಿ n ನ ಎಫ್ ಏನು ಬಗ್ಗೆ.

84
00:04:10,030 --> 00:04:13,700
ವಾಸ್ತವವಾಗಿ, ನಾವು ಬಹಳ ಅಪರೂಪವಾಗಿ ತಿನ್ನುವೆ
ಖಂಡಿತವಾಗಿಯೂ ಎಂದಿಗೂ ಈ class-- ನಾನು

85
00:04:13,700 --> 00:04:18,709
ಯಾವುದೇ ನಿಜವಾಗಿಯೂ ಆಳವಾದ ಧುಮುಕುವುದಿಲ್ಲ
ಆಫ್ ಎಫ್ ಎನ್ ಏನು ವಿಶ್ಲೇಷಣೆ.

86
00:04:18,709 --> 00:04:23,510
ನಾವು ಕೇವಲ ಯಾವ ಎಫ್ ಬಗ್ಗೆ ಮಾತನಾಡಲು ನೀನು
ಎನ್ ಸುಮಾರು ಅಥವಾ ಅದರ ಪ್ರವೃತ್ತಿಯನ್ನು ಹೊಂದಿದೆ.

87
00:04:23,510 --> 00:04:27,600
ಮತ್ತು ಒಂದು ಕ್ರಮಾವಳಿ ಪ್ರವೃತ್ತಿಯಾಗಿದೆ
ಅದರ ಉನ್ನತ ಆದೇಶ ಪದವನ್ನು ಅಪ್ಪಣೆಯಂತೆ.

88
00:04:27,600 --> 00:04:29,440
ಮತ್ತು ನಾವು ನೋಡಬಹುದು ನಾನು
ಪಡೆದುಕೊಂಡು ಎಂದರೆ

89
00:04:29,440 --> 00:04:31,910
ಒಂದು ಹೆಚ್ಚು ಕಾಂಕ್ರೀಟ್ ಉದಾಹರಣೆಯನ್ನು ನೋಡಿ.

90
00:04:31,910 --> 00:04:34,620
>> ಆದ್ದರಿಂದ ನಾವು ಎಂದು ಅವಕಾಶ
ಮೂರು ವಿವಿಧ ಕ್ರಮಾವಳಿಗಳು.

91
00:04:34,620 --> 00:04:39,350
ಇದು ಮೊದಲ N ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ
ಸಂಪನ್ಮೂಲಗಳ ಘನ, ಕೆಲವು ಘಟಕಗಳು

92
00:04:39,350 --> 00:04:42,880
ಗಾತ್ರ N ದತ್ತಾಂಶ ಸಂಗ್ರಹ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು.

93
00:04:42,880 --> 00:04:47,000
ನಾವು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಎರಡನೇ ಕ್ರಮಾವಳಿ
ಘನ ಜೊತೆಗೆ N ವರ್ಗ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಎನ್

94
00:04:47,000 --> 00:04:49,350
ಗಾತ್ರ N ದತ್ತಾಂಶ ಸಂಗ್ರಹ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು.

95
00:04:49,350 --> 00:04:52,030
ನಾವು ಮೂರನೇ ಹೊಂದಿವೆ
ಎಂದು ರಚಿಸಲಾಗಿತ್ತು ನಡೆಯುವ ಅಲ್ಗಾರಿದಮ್

96
00:04:52,030 --> 00:04:58,300
ಅಪ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ N ಘನ ಮೈನಸ್ 8N ವರ್ಗ
ಸಂಪನ್ಮೂಲಗಳ ಜೊತೆಗೆ 20 ಎನ್ ಘಟಕಗಳು

97
00:04:58,300 --> 00:05:02,370
ಒಂದು ಕ್ರಮಾವಳಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು
ಗಾತ್ರ N ಸೆಟ್ ದತ್ತಾಂಶ.

98
00:05:02,370 --> 00:05:05,594
>> ಈಗ ಮತ್ತೆ, ನಾವು ನಿಜವಾಗಿಯೂ ಇಲ್ಲ
ವಿವರ ಈ ಹಂತಕ್ಕೆ ಬರಲು.

99
00:05:05,594 --> 00:05:08,260
ನಾನು ಈ ಅಪ್ ನಿಜವಾಗಿಯೂ ನಾನು
ಇಲ್ಲಿ ಬಿಂದುವಿನ ಸಚಿತ್ರ

100
00:05:08,260 --> 00:05:10,176
ನಾನು ಪಡೆಯಲಿದ್ದೇನೆ
, ಎರಡನೇ ಮಾಡುವ ಇದು

101
00:05:10,176 --> 00:05:12,980
ನಾವು ಮಾತ್ರ ನಿಜವಾಗಿಯೂ ಕಾಳಜಿ ಎಂದು
ವಸ್ತುಗಳ ಪ್ರವೃತ್ತಿ ಬಗ್ಗೆ

102
00:05:12,980 --> 00:05:14,870
ಡೇಟಾ ಸೆಟ್ಗಳನ್ನು ದೊಡ್ಡ ಪಡೆಯಲು ಎಂದು.

103
00:05:14,870 --> 00:05:18,220
ದತ್ತಾಂಶ ಸಂಗ್ರಹ ಸಣ್ಣ ವೇಳೆ ಆದ್ದರಿಂದ, ಇಲ್ಲ
ವಾಸ್ತವವಾಗಿ ಒಂದು ಸಾಕಷ್ಟು ದೊಡ್ಡ ಬದಲಾವಣೆಯನ್ನು

104
00:05:18,220 --> 00:05:19,870
ಈ ಕ್ರಮಾವಳಿಗಳು ರಲ್ಲಿ.

105
00:05:19,870 --> 00:05:23,000
ಮೂರನೇ ಅಲ್ಗಾರಿದಮ್
13 ಬಾರಿ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ

106
00:05:23,000 --> 00:05:27,980
ಸಂಪನ್ಮೂಲಗಳ 13 ಬಾರಿ ಪ್ರಮಾಣದ
ಮೊದಲ ಒಂದು ಸಂಬಂಧಿತವಾದ ಚಲಾಯಿಸಲು.

107
00:05:27,980 --> 00:05:31,659
>> ನಮ್ಮ ಅಕ್ಷಾಂಶ ಸೆಟ್ ಗಾತ್ರ 10, ವೇಳೆ ಇದು
ದೊಡ್ಡ, ಆದರೆ ಅಗತ್ಯವಾಗಿ ದೊಡ್ಡ ಅಲ್ಲ

108
00:05:31,659 --> 00:05:33,950
ನಾವು ಇಲ್ಲ ಎಂದು ನೋಡಬಹುದು
ವಾಸ್ತವವಾಗಿ ಒಂದು ವ್ಯತ್ಯಾಸದ ಸ್ವಲ್ಪ.

109
00:05:33,950 --> 00:05:36,620
ಮೂರನೇ ಕ್ರಮಾವಳಿ
ಕಾರ್ಯಕ್ಷಮತೆ ಹೆಚ್ಚುತ್ತದೆ.

110
00:05:36,620 --> 00:05:40,120
ಇದು ವಾಸ್ತವವಾಗಿ 40% ಬಗ್ಗೆ -
ಅಥವಾ 60% ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ.

111
00:05:40,120 --> 00:05:41,580
ಇದು 40% ಸಮಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

112
00:05:41,580 --> 00:05:45,250
ಇದು ತೆಗೆದುಕೊಳ್ಳಬಹುದು run-- ಮಾಡಬಹುದು
ಸಂಪನ್ಮೂಲಗಳ 400 ಘಟಕಗಳು

113
00:05:45,250 --> 00:05:47,570
ಗಾತ್ರದ 10 ಒಂದು ಮಾಹಿತಿ ಸೆಟ್ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು.

114
00:05:47,570 --> 00:05:49,410
ಮೊದಲ ಆದರೆ
ಕ್ರಮಾವಳಿ ತದ್ವಿರುದ್ಧವಾಗಿ,

115
00:05:49,410 --> 00:05:54,520
ಸಂಪನ್ಮೂಲಗಳ 1,000 ಘಟಕಗಳು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ
ಗಾತ್ರದ 10 ಒಂದು ಮಾಹಿತಿ ಸೆಟ್ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು.

116
00:05:54,520 --> 00:05:57,240
ಆದರೆ ಏನಾಗುತ್ತದೆ ನೋಡಿ
ನಮ್ಮ ಸಂಖ್ಯೆಗಳನ್ನು ಇನ್ನೂ ದೊಡ್ಡ ಪಡೆಯಲು.

117
00:05:57,240 --> 00:05:59,500
>> ಈಗ, ವ್ಯತ್ಯಾಸ
ಈ ಕ್ರಮಾವಳಿಗಳು ನಡುವೆ

118
00:05:59,500 --> 00:06:01,420
ಸ್ವಲ್ಪ ಕಡಿಮೆ ಗೋಚರಿಸುವ ಪ್ರಾರಂಭಿಸಿ.

119
00:06:01,420 --> 00:06:04,560
ಅವುಗಳೆಂದರೆ ಮತ್ತು ವಾಸ್ತವವಾಗಿ
ಕೆಳ ಕ್ರಮಾಂಕದ ಪದಗಳನ್ನು ಅಥವಾ ಬದಲಿಗೆ,

120
00:06:04,560 --> 00:06:09,390
ಕಡಿಮೆ exponents-- ಪದಗಳು
ಅಪ್ರಸ್ತುತವಾಗಿದೆ ಪ್ರಾರಂಭಿಸಿ.

121
00:06:09,390 --> 00:06:12,290
ಒಂದು ಮಾಹಿತಿ ಸೆಟ್ ಗಾತ್ರದ ವೇಳೆ
1,000 ಮತ್ತು ಮೊದಲ ಕ್ರಮಾವಳಿಯ

122
00:06:12,290 --> 00:06:14,170
ಒಂದು ಬಿಲಿಯನ್ ಹಂತಗಳಲ್ಲಿ ಸಾಗುತ್ತದೆ.

123
00:06:14,170 --> 00:06:17,880
ಮತ್ತು ಎರಡನೇ ಕ್ರಮಾವಳಿಯ ಸಾಗುತ್ತದೆ
ಒಂದು ಬಿಲಿಯನ್ ಮತ್ತು ಒಂದು ಮಿಲಿಯನ್ ಕ್ರಮಗಳನ್ನು.

124
00:06:17,880 --> 00:06:20,870
ಮತ್ತು ಮೂರನೇ ಕ್ರಮಾವಳಿ ಸಾಗುತ್ತದೆ
ಒಂದು ಬಿಲಿಯನ್ ಕ್ರಮಗಳನ್ನು ಕೇವಲ ನಾಚಿಕೆ ರಲ್ಲಿ.

125
00:06:20,870 --> 00:06:22,620
ಅದು ಬಹುಮಟ್ಟಿಗೆ ಒಂದು ಬಿಲಿಯನ್ ಕ್ರಮಗಳನ್ನು.

126
00:06:22,620 --> 00:06:25,640
ಆ ಕೆಳ ಕ್ರಮಾಂಕದ ವಿಷಯದಲ್ಲಿ ಆರಂಭಿಸಲು
ನಿಜವಾಗಿಯೂ ಅಸಂಬದ್ಧ ಆಗಲು.

127
00:06:25,640 --> 00:06:27,390
ಮತ್ತು ಕೇವಲ ನಿಜವಾಗಿಯೂ
ಮನೆ ಸುತ್ತಿಗೆ ಅಂಶಗಳಿಲ್ಲ

128
00:06:27,390 --> 00:06:31,240
ಡೇಟಾ ಇನ್ಪುಟ್ ಗಾತ್ರ ಒಂದು ಆಫ್ ವೇಳೆ
million-- ಈ ಎಲ್ಲಾ ಮೂರು ಬಹುಮಟ್ಟಿಗೆ

129
00:06:31,240 --> 00:06:34,960
ಒಂದು quintillion-- ವೇಳೆ ತೆಗೆದುಕೊಳ್ಳಲು
ನನ್ನ ಗಣಿತದ correct-- ಹಂತಗಳನ್ನು ಹೊಂದಿದೆ

130
00:06:34,960 --> 00:06:37,260
ಡೇಟಾ ಇನ್ಪುಟ್ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು
ಗಾತ್ರ ಒಂದು ಮಿಲಿಯನ್.

131
00:06:37,260 --> 00:06:38,250
ಹಂತಗಳನ್ನು ಸಂಗತಿಯೇ.

132
00:06:38,250 --> 00:06:42,092
ಮತ್ತು ವಾಸ್ತವವಾಗಿ ಎಂದು ಅವುಗಳಲ್ಲಿ ಒಂದು ಮಾಡಬಹುದು
ಒಂದೆರಡು 100,000, ಅಥವಾ ಒಂದೆರಡು ತೆಗೆದುಕೊಂಡು 100

133
00:06:42,092 --> 00:06:44,650
ಮಿಲಿಯನ್ ಕಡಿಮೆ ಮಾಡಿದಾಗ
ನಾವು ಹಲವಾರು ಬಗ್ಗೆ ನೀವು

134
00:06:44,650 --> 00:06:46,990
ಆ ರೀತಿಯ ಅಸಂಬದ್ಧ big--.

135
00:06:46,990 --> 00:06:50,006
ಅವರು ಎಲ್ಲಾ ಪಡೆಯುತ್ತವೆ
ಸುಮಾರು N ಘನ,

136
00:06:50,006 --> 00:06:52,380
ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ವಾಸ್ತವವಾಗಿ ಉಲ್ಲೇಖಿಸಿದ್ದ
ಈ ಕ್ರಮಾವಳಿಗಳು ಎಲ್ಲಾ

137
00:06:52,380 --> 00:06:59,520
n ನ ಆದೇಶದ ಎಂದು
ಘನ ಅಥವಾ n ಘನ ದೊಡ್ಡ ಓ.

138
00:06:59,520 --> 00:07:03,220
>> ಇಲ್ಲಿ ಹೆಚ್ಚು ಕೆಲವು ಪಟ್ಟಿ ಇಲ್ಲಿದೆ
ಸಾಮಾನ್ಯ ಎಣಿಕೆಯ ಸಂಕೀರ್ಣತೆ ತರಗತಿಗಳು

139
00:07:03,220 --> 00:07:05,820
ನಾವು ಎದುರಿಸುವ ಮಾಡುತ್ತೇವೆ
ಕ್ರಮಾವಳಿಗಳು ಸಾಮಾನ್ಯವಾಗಿ.

140
00:07:05,820 --> 00:07:07,970
ಮತ್ತು ನಿರ್ದಿಷ್ಟವಾಗಿ CS50 ರಲ್ಲಿ.

141
00:07:07,970 --> 00:07:11,410
ಈ ಆದೇಶ ಮಾಡಲಾಗುತ್ತದೆ
ಸಾಮಾನ್ಯವಾಗಿ ಮೇಲ್ಭಾಗದಲ್ಲಿ ವೇಗವಾಗಿ,

142
00:07:11,410 --> 00:07:13,940
ಕೆಳಭಾಗದಲ್ಲಿ ಸಾಮಾನ್ಯವಾಗಿ ನಿಧಾನಕ್ಕೆ.

143
00:07:13,940 --> 00:07:16,920
ಆದ್ದರಿಂದ ನಿರಂತರ ಸಮಯದಲ್ಲಿ ಕ್ರಮಾವಳಿಗಳು ಒಲವು
ಇರಲಿ, ವೇಗವಾಗಿ ಎಂದು

144
00:07:16,920 --> 00:07:19,110
ಗಾತ್ರದ
ಡೇಟಾ ಇನ್ಪುಟ್ ನೀವು ಹಾದು.

145
00:07:19,110 --> 00:07:23,760
ಅವರು ಯಾವಾಗಲೂ ಒಂದು ಕಾರ್ಯಾಚರಣೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ಅಥವಾ
ಎದುರಿಸಲು ಸಂಪನ್ಮೂಲಗಳ ಒಂದು ಘಟಕ.

146
00:07:23,760 --> 00:07:25,730
ಇದು 2 ಇರಬಹುದು, ಇದು ಬಹುಶಃ
3, 4 ಇರಬಹುದು.

147
00:07:25,730 --> 00:07:26,910
ಆದರೆ ಅದು ಒಂದು ಸ್ಥಿರ ಸಂಖ್ಯೆ.

148
00:07:26,910 --> 00:07:28,400
ಇದು ಬದಲಾಗುವುದಿಲ್ಲ.

149
00:07:28,400 --> 00:07:31,390
>> ಅಲ್ಗಾರಿದಮ್ ಸಮಯ ಕ್ರಮಾವಳಿಗಳು
ಸ್ವಲ್ಪ ಉತ್ತಮ.

150
00:07:31,390 --> 00:07:33,950
ಮತ್ತು ಒಂದು ಒಳ್ಳೆಯ ಉದಾಹರಣೆ
ಒಂದು ಅಲ್ಗಾರಿದಮ್ ಸಮಯ ಅಲ್ಗಾರಿದಮ್

151
00:07:33,950 --> 00:07:37,420
ನೀವು ಖಂಡಿತವಾಗಿ ಈಗ ನೋಡಬಹುದಾಗಿದೆ ಬಂದಿದೆ
ಫೋನ್ ಪುಸ್ತಕದ ಹೊರತುಪಡಿಸಿ ಹರಿದು

152
00:07:37,420 --> 00:07:39,480
ಫೋನ್ ಪುಸ್ತಕದಲ್ಲಿ ಮೈಕ್ ಸ್ಮಿತ್.

153
00:07:39,480 --> 00:07:40,980
ನಾವು ಅರ್ಧ ಸಮಸ್ಯೆಯನ್ನು ಕತ್ತರಿಸಿ.

154
00:07:40,980 --> 00:07:43,580
ಮತ್ತು N ದೊಡ್ಡ ಗೆಟ್ಸ್ ಆದ್ದರಿಂದ
ಮತ್ತು ದೊಡ್ಡ ಮತ್ತು larger--

155
00:07:43,580 --> 00:07:47,290
ವಾಸ್ತವವಾಗಿ, ಪ್ರತಿ ಬಾರಿ ನೀವು ಡಬಲ್
ಎನ್, ಇದು ಕೇವಲ ಹೆಚ್ಚು ಹಂತದ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

156
00:07:47,290 --> 00:07:49,770
ಎಂದು ಬಹಳಷ್ಟು ಉತ್ತಮ ಆದ್ದರಿಂದ
ಹೆಚ್ಚು, ಹೇಳುತ್ತಾರೆ, ರೇಖೀಯ ಸಮಯದಲ್ಲಿ.

157
00:07:49,770 --> 00:07:53,030
ನೀವು ಎನ್ ಡಬಲ್ ಇದು, ಆಗಿದೆ
ಕ್ರಮಗಳನ್ನು ಎರಡರಷ್ಟು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

158
00:07:53,030 --> 00:07:55,980
ನೀವು ಎನ್ ಮೂರು ಪಟ್ಟು, ಅದನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ
ಕ್ರಮಗಳನ್ನು ಸಂಖ್ಯೆ ಮೂರು ಪಟ್ಟು.

159
00:07:55,980 --> 00:07:58,580
ಪ್ರತಿ ಯೂನಿಟ್ಗೆ ಒಂದು ಹೆಜ್ಜೆ.

160
00:07:58,580 --> 00:08:01,790
>> ನಂತರ ವಿಷಯಗಳನ್ನು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಹೆಚ್ಚು ಪಡೆಯುವುದು
ಸ್ವಲ್ಪ ಕಡಿಮೆ ಮಹಾನ್ ಅಲ್ಲಿಂದ.

161
00:08:01,790 --> 00:08:06,622
ನೀವು ಕೆಲವೊಮ್ಮೆ, ರೇಖೀಯ ಲಯಬದ್ಧ ಸಮಯ
ಲಾಗ್ ರೇಖೀಯ ಸಮಯದಲ್ಲಿ ಎಂಬ ಅಥವಾ N ಲಾಗ್ N.

162
00:08:06,622 --> 00:08:08,330
ಮತ್ತು ನಾವು ಉದಾಹರಣೆಯಾಗಿ ಮಾಡುತ್ತೇವೆ
ಒಂದು ಕ್ರಮಾವಳಿಯ ಎಂದು

163
00:08:08,330 --> 00:08:13,370
ಇನ್ನೂ ಉತ್ತಮ ಇದು N ಲಾಗ್ N, ರನ್
ಹೆಚ್ಚು ವರ್ಗ ಬಾರಿಗೆ N ವರ್ಗ.

164
00:08:13,370 --> 00:08:17,320
ಅಥವಾ ಬಹುಪದೀಯ ಸಮಯ, N ಎರಡು
ಎರಡು ಹೆಚ್ಚು ಯಾವುದೇ ಸಂಖ್ಯೆ.

165
00:08:17,320 --> 00:08:20,810
ಅಥವಾ ಘಾತೀಯ ಸಮಯ, ಇದು
ಸಹ worse-- ಸಿ ಎನ್ ಆಗಿದೆ.

166
00:08:20,810 --> 00:08:24,670
ಆದ್ದರಿಂದ ಕೆಲವು ಸ್ಥಿರ ಏರಿಸಲಾಯಿತು
ಇನ್ಪುಟ್ ಗಾತ್ರಕ್ಕೆ ಶಕ್ತಿ.

167
00:08:24,670 --> 00:08:28,990
ಆದ್ದರಿಂದ 1,000-- ಇಲ್ಲ ವೇಳೆ
ಡೇಟಾ ಇನ್ಪುಟ್, ಗಾತ್ರ 1,000 ಆಗಿದೆ

168
00:08:28,990 --> 00:08:31,310
ಇದು 1,000 ನೇ ಅಧಿಕಾರಕ್ಕೆ ಸಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

169
00:08:31,310 --> 00:08:33,559
ಇದು ಬಹುಪದೀಯ ಅವಧಿಗಿಂತ ಬಹಳಷ್ಟು ಕೆಟ್ಟದಾಗಿ ಇಲ್ಲಿದೆ.

170
00:08:33,559 --> 00:08:35,030
>> ಅಪವರ್ತನೀಯ ಸಮಯ ಇನ್ನೂ ಗಂಭೀರವಾಗಿದೆ.

171
00:08:35,030 --> 00:08:37,760
ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ನಿಜವಾಗಿಯೂ ಹಾಗೆ
ಅನಂತ ಸಮಯ ಗಣನ ವಿಧಾನಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ,

172
00:08:37,760 --> 00:08:43,740
ಅವರ ಇಂತಹ ಕರೆಯಲ್ಪಡುವ, ಸ್ಟುಪಿಡ್ sort--
ಕೆಲಸ ಯಾದೃಚ್ಛಿಕವಾಗಿ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಷಫಲ್

173
00:08:43,740 --> 00:08:45,490
ತದನಂತರ ಪರೀಕ್ಷಿಸಿ
ಎಂದು ಅದನ್ನು ವಿಂಗಡಿಸುತ್ತದೆ.

174
00:08:45,490 --> 00:08:47,589
ಮತ್ತು ಇದು ಯಾದೃಚ್ಛಿಕವಾಗಿ, ಅಲ್ಲ
ಮತ್ತೆ ಸರಣಿ ನಡೆ

175
00:08:47,589 --> 00:08:49,130
ಮತ್ತು ಅದನ್ನು ವಿಂಗಡಿಸುತ್ತದೆ ಎಂದು ಪರೀಕ್ಷಿಸಿ.

176
00:08:49,130 --> 00:08:51,671
ಮತ್ತು ನೀವು ಬಹುಶಃ imagine-- ಮಾಡಬಹುದು
ನೀವು ಪರಿಸ್ಥಿತಿ ಕಲ್ಪನೆಯ

177
00:08:51,671 --> 00:08:55,200
ಅಲ್ಲಿ ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ, ಆ ವಿಲ್
ವಾಸ್ತವವಾಗಿ ರಚನೆಯ ಆರಂಭವಾಗಬೇಕು ಎಂದಿಗೂ.

178
00:08:55,200 --> 00:08:57,150
ಆ ಕ್ರಮಾವಳಿಗಳು ಶಾಶ್ವತವಾಗಿ ಓಡುತ್ತವೆ.

179
00:08:57,150 --> 00:08:59,349
ಆದ್ದರಿಂದ ಒಂದು ಎಂದು
ಅನಂತ ಸಮಯ ಅಲ್ಗಾರಿದಮ್.

180
00:08:59,349 --> 00:09:01,890
ಆಶಾದಾಯಕವಾಗಿ ನೀವು ಬರೆಯಲು ಆಗುವುದಿಲ್ಲ
ಯಾವುದೇ ಅಪವರ್ತನೀಯ ಅಥವಾ ಅನಂತ ಸಮಯ

181
00:09:01,890 --> 00:09:04,510
CS50 ರಲ್ಲಿ ಕ್ರಮಾವಳಿಗಳು.

182
00:09:04,510 --> 00:09:09,150
>> ಆದ್ದರಿಂದ, ನೋಡೋಣ ಸ್ವಲ್ಪ ಹೆಚ್ಚು
ಕೆಲವು ಸರಳವಾದ ಕಾಂಕ್ರೀಟ್ ನೋಟ

183
00:09:09,150 --> 00:09:11,154
ಕಾಂಪ್ಯುಟೇಶನಲ್ ಕಾಂಪ್ಲೆಕ್ಸಿಟಿ ತರಗತಿಗಳು.

184
00:09:11,154 --> 00:09:13,070
ನಾವು ಒಂದು ಉದಾಹರಣೆಗೆ ಹೊಂದಿವೆ
ಅಥವಾ ಎರಡು ಉದಾಹರಣೆಗಳು ಇಲ್ಲಿ

185
00:09:13,070 --> 00:09:15,590
ನಿರಂತರ ಸಮಯದಲ್ಲಿ ಕ್ರಮಾವಳಿಗಳ,
ಇದು ಯಾವಾಗಲೂ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ

186
00:09:15,590 --> 00:09:17,980
ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ಒಂದು ಕಾರ್ಯಾಚರಣೆ.

187
00:09:17,980 --> 00:09:20,050
ಮೊದಲ ಉದಾಹರಣೆಗೆ ಆದ್ದರಿಂದ
ನಾವು ಒಂದು ಫಂಕ್ಷನ್

188
00:09:20,050 --> 00:09:23,952
ನೀವು 4 ಎಂದು
ಗಾತ್ರ 1,000 ಒಂದು ಶ್ರೇಣಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

189
00:09:23,952 --> 00:09:25,660
ಆದರೆ ಸ್ಪಷ್ಟವಾಗಿ
ವಾಸ್ತವವಾಗಿ ಕಾಣುವುದಿಲ್ಲ

190
00:09:25,660 --> 00:09:29,000
ಅದನ್ನು ನಿಜವಾಗಿಯೂ ಇಲ್ಲಿದೆ ಲೆಕ್ಕಕ್ಕೆ ನಲ್ಲಿ
, ಅದರ ಒಳಗೆ ರಚನೆಯ.

191
00:09:29,000 --> 00:09:30,820
ಯಾವಾಗಲೂ ಕೇವಲ ನಾಲ್ಕು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

192
00:09:30,820 --> 00:09:32,940
ಆದ್ದರಿಂದ ಆ ಅಲ್ಗಾರಿದಮ್,
ಇದು ಎಂದು ವಾಸ್ತವವಾಗಿ ಹೊರತಾಗಿಯೂ

193
00:09:32,940 --> 00:09:35,840
1,000 ಅಂಶಗಳನ್ನು ಮಾಡುವುದಿಲ್ಲ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ
ಅವರೊಂದಿಗೆ ಏನನ್ನೂ.

194
00:09:35,840 --> 00:09:36,590
ಕೇವಲ ನಾಲ್ಕು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

195
00:09:36,590 --> 00:09:38,240
ಯಾವಾಗಲೂ ಒಂದು ಹೆಜ್ಜೆ ಇಲ್ಲಿದೆ.

196
00:09:38,240 --> 00:09:41,600
>> ವಾಸ್ತವವಾಗಿ, 2 nums-- ಸೇರಿಸಿ
ನಾವು well-- ಮೊದಲು ನೋಡಿದ

197
00:09:41,600 --> 00:09:43,680
ಕೇವಲ ಎರಡು ಪೂರ್ಣಾಂಕಗಳ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು.

198
00:09:43,680 --> 00:09:44,692
ಇದು ಒಂದು ಹಂತದ ಅಲ್ಲ.

199
00:09:44,692 --> 00:09:45,900
ಇದು ವಾಸ್ತವವಾಗಿ ಒಂದೆರಡು ಕ್ರಮಗಳನ್ನು.

200
00:09:45,900 --> 00:09:50,780
ನೀವು ಪಡೆಯಲು, ನೀವು ಬಿ ಪಡೆಯಲು, ನೀವು ಸೇರಿಸಲು
ಒಟ್ಟಿಗೆ, ಮತ್ತು ನೀವು ಔಟ್ಪುಟ್ ಫಲಿತಾಂಶಗಳು.

201
00:09:50,780 --> 00:09:53,270
ಆದ್ದರಿಂದ 84 ಕ್ರಮಗಳನ್ನು.

202
00:09:53,270 --> 00:09:55,510
ಆದರೆ, ಯಾವಾಗಲೂ ನಿರಂತರ ಇಲ್ಲಿದೆ
ಇರಲಿ ಅಥವಾ ಬಿ.

203
00:09:55,510 --> 00:09:59,240
ನೀವು ಪಡೆಯಲು ಹೊಂದಿವೆ, ಬಿ ಪಡೆಯಲು ಸೇರಿಸಿ
ಒಟ್ಟಿಗೆ, ಔಟ್ಪುಟ್ ಪರಿಣಾಮವಾಗಿ.

204
00:09:59,240 --> 00:10:02,900
ಆದ್ದರಿಂದ ನಿರಂತರ ಸಮಯ ಕ್ರಮಾವಳಿ.

205
00:10:02,900 --> 00:10:05,170
>> ಇಲ್ಲಿ ಒಂದು ಉದಾಹರಣೆ
ರೇಖೀಯ ಸಮಯದಲ್ಲಿ ಕ್ರಮಾವಳಿಯ

206
00:10:05,170 --> 00:10:08,740
ಎಂದು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ gets-- ಒಂದು ಕ್ರಮಾವಳಿ
ಒಂದು ಹೆಚ್ಚುವರಿ ಹಂತವನ್ನು, ಬಹುಶಃ,

207
00:10:08,740 --> 00:10:10,740
ನಿಮ್ಮ ಇನ್ಪುಟ್ 1 ಮೂಲಕ ಬೆಳೆದಂತೆ.

208
00:10:10,740 --> 00:10:14,190
ಆದ್ದರಿಂದ, ನಾವು ಹುಡುಕುತ್ತಿರುವ ಹೇಳಲು ಅವಕಾಶ
ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಸಂಖ್ಯೆ 5 ಒಳಗೆ.

209
00:10:14,190 --> 00:10:16,774
ನೀವು ಪರಿಸ್ಥಿತಿ ಅಲ್ಲಿ ಹೊಂದಿರಬಹುದು
ನೀವು ಚೆನ್ನಾಗಿ ಆರಂಭದಲ್ಲಿ ಕಾಣಬಹುದು.

210
00:10:16,774 --> 00:10:18,606
ಆದರೆ ನೀವು ತೋರಿಸಬಹುದಿತ್ತು
ಪರಿಸ್ಥಿತಿ ಅಲ್ಲಿ ಇದು

211
00:10:18,606 --> 00:10:20,450
ರಚನೆಯ ಕೊನೆಯ ಅಂಶ ಇರಬಹುದು.

212
00:10:20,450 --> 00:10:23,780
ಗಾತ್ರ 5 ಒಂದು ಶ್ರೇಣಿಯನ್ನು, ವೇಳೆ ರಲ್ಲಿ
ನಾವು ಸಂಖ್ಯೆ 5 ಹುಡುಕುತ್ತಿರುವ.

213
00:10:23,780 --> 00:10:25,930
ಇದು 5 ಹೆಜ್ಜೆ ಎಂದು.

214
00:10:25,930 --> 00:10:29,180
ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ಇಲ್ಲ ಎಂದು ಊಹಿಸಿ
ಈ ಶ್ರೇಣಿಯಲ್ಲಿನ ಅಲ್ಲ 5 ಎಲ್ಲಿಯಾದರೂ.

215
00:10:29,180 --> 00:10:32,820
ನಾವು ಇನ್ನೂ ವಾಸ್ತವವಾಗಿ ನೋಡಲು ಹೊಂದಿವೆ
ರಚನೆಯ ಪ್ರತಿಯೊಂದು ಅಂಶ

216
00:10:32,820 --> 00:10:35,550
ನಿರ್ಧರಿಸಲು
ಅಥವಾ ಇಲ್ಲವೇ 5 ಇಲ್ಲ.

217
00:10:35,550 --> 00:10:39,840
>> ಆದ್ದರಿಂದ ಇದು ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ, ರಲ್ಲಿ
ಅಂಶ ರಚನೆಯ ಕೊನೆಯಾಗಿ

218
00:10:39,840 --> 00:10:41,700
ಅಥವಾ ಎಲ್ಲಾ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ.

219
00:10:41,700 --> 00:10:44,690
ನಾವು ಇನ್ನೂ ನೋಡಲು ಹೊಂದಿವೆ
N ಅಂಶಗಳನ್ನು ಎಲ್ಲಾ.

220
00:10:44,690 --> 00:10:47,120
ಮತ್ತು ಈ ಅಲ್ಗಾರಿದಮ್
ರೇಖೀಯ ಸಮಯದಲ್ಲಿ ಸಾಗುತ್ತದೆ.

221
00:10:47,120 --> 00:10:50,340
ನೀವು ಮೂಲಕ ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ
ಹೇಳುವ ಮೂಲಕ ಸ್ವಲ್ಪ ಸಮಾನಾಂತರವಾಗಿ

222
00:10:50,340 --> 00:10:53,080
ನಾವು 6 ಅಂಶ ರಚನೆಯ ವೇಳೆ ಮತ್ತು
ನಾವು, ಸಂಖ್ಯೆ 5 ಹುಡುಕುತ್ತಿರುವ

223
00:10:53,080 --> 00:10:54,890
ಇದು 6 ಕ್ರಮಗಳನ್ನು ಇರಬಹುದು.

224
00:10:54,890 --> 00:10:57,620
ನಾವು 7 ಅಂಶ ರಚನೆಯ ಹೊಂದಿದ್ದರೆ ಮತ್ತು
ನಾವು ಸಂಖ್ಯೆ 5 ಹುಡುಕುತ್ತಿರುವ.

225
00:10:57,620 --> 00:10:59,160
ಇದು 7 ಕ್ರಮಗಳನ್ನು ಇರಬಹುದು.

226
00:10:59,160 --> 00:11:02,920
ನಾವು ಒಂದು ಅಂಶ ಸೇರಿಸಲು ನಮ್ಮ
ಅರೇ, ಇದು ಹೆಚ್ಚು ಹಂತದ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

227
00:11:02,920 --> 00:11:06,750
ಒಂದು ರೇಖೀಯ ಅಲ್ಗಾರಿದಮ್ ಇಲ್ಲಿದೆ
ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ.

228
00:11:06,750 --> 00:11:08,270
>> ಒಂದೆರಡು ನೀವು ತ್ವರಿತ ಪ್ರಶ್ನೆಗಳನ್ನು.

229
00:11:08,270 --> 00:11:11,170
ಇಲ್ಲಿದೆ runtime-- ಇಲ್ಲಿದೆ
ಕೆಟ್ಟ ಪೆಟ್ಟಿಗೆ ರನ್ಟೈಮ್

230
00:11:11,170 --> 00:11:13,700
ಕೋಡ್ ಈ ನಿರ್ದಿಷ್ಟ ತುಣುಕನ್ನು?

231
00:11:13,700 --> 00:11:17,420
ಹಾಗಾಗಿ ನಡೆಯುವ ಇಲ್ಲಿ 4 ಲೂಪ್
ಜೆ 0, ಮೀ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಅಪ್ ಸಮನಾಗಿರುತ್ತದೆ.

232
00:11:17,420 --> 00:11:21,980
ಮತ್ತು ನಾನು ಇಲ್ಲಿ ನೋಡಿದ ಬಾಗುತ್ತೇನೆ, ಎಂದು
ಲೂಪ್ ದೇಹದ ನಿರಂತರ ಸಮಯದಲ್ಲಿ ಸಾಗುತ್ತದೆ.

233
00:11:21,980 --> 00:11:24,730
ಆದ್ದರಿಂದ ಪರಿಭಾಷೆ ಎಂದು ಬಳಸಿ
ನಾವು ಈಗಾಗಲೇ about-- ಮಾತಾಡಿದವರು

234
00:11:24,730 --> 00:11:29,390
ಕೆಟ್ಟ ಪೆಟ್ಟಿಗೆ ಎಂದು
ಈ ಕ್ರಮಾವಳಿಯ ರನ್ಟೈಮ್?

235
00:11:29,390 --> 00:11:31,050
ಎರಡನೇ.

236
00:11:31,050 --> 00:11:34,270
ಲೂಪ್ ಒಳ ಭಾಗದಲ್ಲಿ
ನಿರಂತರ ಸಮಯದಲ್ಲಿ ಸಾಗುತ್ತದೆ.

237
00:11:34,270 --> 00:11:37,510
ಮತ್ತು ಹೊರ ಭಾಗದಲ್ಲಿ
ಲೂಪ್ ಮೀ ಬಾರಿ ಔಟ್ ಹೋಗುತ್ತದೆ.

238
00:11:37,510 --> 00:11:40,260
ಆದ್ದರಿಂದ ಕೆಟ್ಟ ಪೆಟ್ಟಿಗೆ ರನ್ಟೈಮ್ ಇಲ್ಲಿ ಇಲ್ಲಿದೆ?

239
00:11:40,260 --> 00:11:43,210
ನೀವು ಮೀ ದೊಡ್ಡ ಓ ಊಹೆ ಮಾಡಿದ್ದೀರಾ?

240
00:11:43,210 --> 00:11:44,686
ನೀವು ಬಲ ಪಡುತ್ತೇವೆ.

241
00:11:44,686 --> 00:11:46,230
>> ಹೇಗೆ ಮತ್ತೊಂದು ಬಗ್ಗೆ?

242
00:11:46,230 --> 00:11:48,590
ನಾವು ಈ ಸಮಯದಲ್ಲಿ
ಲೂಪ್ ಒಳಗೆ ಲೂಪ್.

243
00:11:48,590 --> 00:11:50,905
ನಾವು ಹೊರ ಲೂಪ್
ಆ ಶೂನ್ಯ ಪು ಓಡುತ್ತವೆ.

244
00:11:50,905 --> 00:11:54,630
ನಾವು ಮಾಡುವ ಒಳ ಲೂಪ್
ಶೂನ್ಯ ಪು, ಮತ್ತು ಒಳಗೆ,

245
00:11:54,630 --> 00:11:57,890
ನಾನು ರಾಜ್ಯದ ದೇಹದ ಎಂದು
ಲೂಪ್ ನಿರಂತರ ಸಮಯದಲ್ಲಿ ಸಾಗುತ್ತದೆ.

246
00:11:57,890 --> 00:12:02,330
ಆದ್ದರಿಂದ ಕೆಟ್ಟ ಪೆಟ್ಟಿಗೆ ರನ್ಟೈಮ್ ಇಲ್ಲಿದೆ
ಕೋಡ್ ಈ ನಿರ್ದಿಷ್ಟ ತುಣುಕನ್ನು?

247
00:12:02,330 --> 00:12:06,140
ಅಲ್ಲದೆ, ಮತ್ತೆ, ನಾವು ಒಂದು ಹೊಂದಿವೆ
ಪು ಬಾರಿ ನಡೆಯುವ ಹೊರ ಲೂಪ್.

248
00:12:06,140 --> 00:12:09,660
ಮತ್ತು ಪ್ರತಿ ಬಾರಿಗೆ ಪುನರಾವರ್ತನೆ
ಆ ಲೂಪ್, ಬದಲಿಗೆ.

249
00:12:09,660 --> 00:12:13,170
ನಾವು ಒಳಗಿನ ಲೂಪ್
ಸಹ ಪು ಬಾರಿ ಸಾಗುತ್ತದೆ.

250
00:12:13,170 --> 00:12:16,900
ಎಂದು ಒಳಗೆ ತದನಂತರ, ಇಲ್ಲ
ಅಲ್ಲಿ ನಿರಂತರ ಬಾರಿಗೆ ಸ್ವಲ್ಪ ತುಣುಕನ್ನು.

251
00:12:16,900 --> 00:12:19,890
>> ನಾವು ಹೊರ ಲೂಪ್ ಹೊಂದಿದ್ದರೆ ಆದ್ದರಿಂದ
ಇದು ಒಳಗೆ ಪು ಬಾರಿ ಸಾಗುತ್ತದೆ

252
00:12:19,890 --> 00:12:22,880
ಒಳಗಿನ ಲೂಪ್ ಎಂದು
ಏನು ಬಾರಿ ಪು ಸಾಗುತ್ತದೆ

253
00:12:22,880 --> 00:12:26,480
ಕೆಟ್ಟ ಪೆಟ್ಟಿಗೆ ರನ್ಟೈಮ್
ಕೋಡ್ ತುಣುಕನ್ನು ಆಫ್?

254
00:12:26,480 --> 00:12:30,730
ನೀವು ಪು ದೊಡ್ಡ ಓ ಊಹೆ ಮಾಡಿದ್ದೀರಾ?

255
00:12:30,730 --> 00:12:31,690
>> ನಾನು ಡೌಗ್ ಲಾಯ್ಡ್ ಮನುಷ್ಯ.

256
00:12:31,690 --> 00:12:33,880
ಈ CS50 ಹೊಂದಿದೆ.

257
00:12:33,880 --> 00:12:35,622