1
00:00:07,720 --> 00:00:10,950
[Powered by Google Translate] ನೀವು ಬಹುಶಃ ಜನರು ವೇಗದ ಅಥವಾ ದಕ್ಷ ಅಲ್ಗಾರಿದಮ್ ಬಗ್ಗೆ ಕೇಳಿರುವ

2
00:00:10,950 --> 00:00:13,090
ನಿಮ್ಮ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯವನ್ನು ನಿರ್ವಹಿಸುವುದಕ್ಕಾಗಿ,

3
00:00:13,090 --> 00:00:16,110
ಆದರೆ ವೇಗದ ಅಥವಾ ದಕ್ಷ ಎಂದು ಒಂದು ಅಲ್ಗಾರಿದಮ್ ಫಾರ್ ನಿಖರವಾಗಿ ಏನು?

4
00:00:16,110 --> 00:00:18,580
ಅಲ್ಲದೆ, ಇದು ನೈಜ ಸಮಯದಲ್ಲಿ ಒಂದು ಮಾಪನದ ಬಗ್ಗೆ ದೊರೆಯದಿದ್ದಲ್ಲಿ

5
00:00:18,580 --> 00:00:20,500
ಸೆಕೆಂಡ್ಗಳು ಅಥವಾ ನಿಮಿಷಗಳು ನಂತಹ.

6
00:00:20,500 --> 00:00:22,220
ಈ ಕಾರಣ ಕಂಪ್ಯೂಟರ್ ಯಂತ್ರಾಂಶ

7
00:00:22,220 --> 00:00:24,260
ಮತ್ತು ಸಾಫ್ಟ್ವೇರ್ ತೀವ್ರವಾಗಿ ಬದಲಾಗುತ್ತದೆ.

8
00:00:24,260 --> 00:00:26,020
ನನ್ನ ಪ್ರೋಗ್ರಾಂ, ನಿಮ್ಮ ನಿಧಾನವಾಗಿ ರನ್ ಆಗಬಹುದು

9
00:00:26,020 --> 00:00:28,000
ನಾನು ಹಳೆಯ ಕಂಪ್ಯೂಟರ್ನಲ್ಲಿ ಇದು ಚಾಲನೆಯಲ್ಲಿರುವ ನಾನು ಏಕೆಂದರೆ

10
00:00:28,000 --> 00:00:30,110
ಅಥವಾ ನಾನು ಆನ್ಲೈನ್ ವೀಡಿಯೊ ಆಟದಲ್ಲಿ ಎಂದು ಸಂಭವಿಸಿ ಏಕೆಂದರೆ

11
00:00:30,110 --> 00:00:32,670
ಅದೇ ಸಮಯದಲ್ಲಿ, ಇದು ನನ್ನ ಮೆಮೊರಿ hogging ಇದೆ

12
00:00:32,670 --> 00:00:35,400
ಅಥವಾ ನಾನು ವಿವಿಧ ತಂತ್ರಾಂಶ ಮೂಲಕ ನನ್ನ ಕಾರ್ಯಕ್ರಮವನ್ನು ನಡೆಸುವ ಇರಬಹುದು

13
00:00:35,400 --> 00:00:37,550
ಇದು ಕಡಿಮೆ ಮಟ್ಟದ ವಿಭಿನ್ನವಾಗಿ ಯಂತ್ರ ಸಂವಹನ.

14
00:00:37,550 --> 00:00:39,650
ಇದು ಸೇಬು ಮತ್ತು ಕಿತ್ತಳೆ ಹೋಲಿಸುವ ಅನಿಸುತ್ತದೆ.

15
00:00:39,650 --> 00:00:41,940
ನನ್ನ ನಿಧಾನವಾಗಿ ಕಂಪ್ಯೂಟರ್ ಮುಂದೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಕೇವಲ

16
00:00:41,940 --> 00:00:43,410
ನಿಮ್ಮ ಉತ್ತರವನ್ನು ಹಿಂದಕ್ಕೆ ನೀಡಲು ಹೆಚ್ಚು

17
00:00:43,410 --> 00:00:45,510
ನೀವು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ಅಲ್ಗಾರಿದಮ್ ಹೊಂದಿದೆ ಎಂದಲ್ಲ.

18
00:00:45,510 --> 00:00:48,830
>> ಆದ್ದರಿಂದ, ನಾವು ನೇರವಾಗಿ ಕಾರ್ಯಕ್ರಮಗಳ ರನ್ಟೈಮ್ಗಳನ್ನು ಹೋಲಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ, ಏಕೆಂದರೆ

19
00:00:48,830 --> 00:00:50,140
ಸೆಕೆಂಡುಗಳು ಅಥವಾ ನಿಮಿಷಗಳಲ್ಲಿ,

20
00:00:50,140 --> 00:00:52,310
ಹೇಗೆ ನಾವು 2 ವಿವಿಧ ಕ್ರಮಾವಳಿಗಳು ಹೋಲಿಸಿ ನೋಡಬಹುದು

21
00:00:52,310 --> 00:00:55,030
ಯಾವುದೇ ಹಾರ್ಡ್ವೇರ್ ಅಥವಾ ಸಾಫ್ಟ್ವೇರ್ ಪರಿಸರದ?

22
00:00:55,030 --> 00:00:58,000
ಕ್ರಮಾವಳಿಯ ದಕ್ಷತೆ ಅಳೆಯಲು ಒಂದು ಏಕರೂಪದ ರೀತಿಯಲ್ಲಿ ರಚಿಸಲು,

23
00:00:58,000 --> 00:01:00,360
ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನಿಗಳು ಹಾಗೂ ಗಣಿತಜ್ಞರು ರೂಪಿಸಿದರು ಎಂದು

24
00:01:00,360 --> 00:01:03,830
ಒಂದು ಕಾರ್ಯಕ್ರಮದ ಅಸಂಪಾತ ಸಂಕೀರ್ಣತೆ ಅಳೆಯುವ ಪರಿಕಲ್ಪನೆಗಳು

25
00:01:03,830 --> 00:01:06,110
ಮತ್ತು ಒಂದು ಸಂಕೇತ 'ಬಿಗ್ Ohnotation' ಎಂಬ

26
00:01:06,110 --> 00:01:08,320
ಈ ಸೂಚಿಸಲು.

27
00:01:08,320 --> 00:01:10,820
ಔಪಚಾರಿಕ ವ್ಯಾಖ್ಯಾನವನ್ನು ಒಂದು ಫಂಕ್ಷನ್ f (x)

28
00:01:10,820 --> 00:01:13,390
ಗ್ರಾಂ ಕ್ರಮವನ್ನು (X) ಚಲಿಸುತ್ತದೆ

29
00:01:13,390 --> 00:01:15,140
ಕೆಲವು (X) ಮೌಲ್ಯವನ್ನು ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ವೇಳೆ, X ₀ ಮತ್ತು

30
00:01:15,140 --> 00:01:17,630
ಕೆಲವು ಸ್ಥಿರ, ಸಿ, ಯಾವ

31
00:01:17,630 --> 00:01:19,340
f (x) ಕಡಿಮೆ ಅಥವಾ ಸಮ

32
00:01:19,340 --> 00:01:21,230
ಆ ನಿರಂತರ ಬಾರಿ g (x)

33
00:01:21,230 --> 00:01:23,190
X ₀ ಹೆಚ್ಚಿನ ಎಲ್ಲಾ x ಗಾಗಿ.

34
00:01:23,190 --> 00:01:25,290
>> ಆದರೆ ಔಪಚಾರಿಕ ವ್ಯಾಖ್ಯಾನವನ್ನು ಕೂಡಿದೆ ನಿಮಗಿರುವುದು ಇಲ್ಲ.

35
00:01:25,290 --> 00:01:28,020
ಈ ವಾಸ್ತವವಾಗಿ ಸೈದ್ಧಾಂತಿಕ ಪದಗಳನ್ನು ಕಡಿಮೆ ಅರ್ಥ ಏನು?

36
00:01:28,020 --> 00:01:30,580
ಅಲ್ಲದೆ, ಇದು ಮೂಲತಃ ವಿಶ್ಲೇಷಿಸುವ ಒಂದು ಮಾರ್ಗವಾಗಿದೆ

37
00:01:30,580 --> 00:01:33,580
ಒಂದು ಪ್ರೋಗ್ರಾಂ ನ ರನ್ಟೈಮ್ asymptotically ಬೆಳೆಯುತ್ತದೆ ಎಷ್ಟು ವೇಗವಾಗಿ.

38
00:01:33,580 --> 00:01:37,170
ನಿಮ್ಮ ಒಳಹರಿವಿನ ಗಾತ್ರ ಅನಂತ ಕಡೆಗೆ ಹೆಚ್ಚಿಸುತ್ತದೆ ಎಂದು, ಇದು

39
00:01:37,170 --> 00:01:41,390
ಸೇ, ನೀವು ಗಾತ್ರ 10 ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೋಲಿಸಿದರೆ ಗಾತ್ರದಲ್ಲಿ 1000 ಒಂದು ಶ್ರೇಣಿಯನ್ನು ವಿಂಗಡಿಸುವ ಮಾಡುತ್ತಿದ್ದೇವೆ.

40
00:01:41,390 --> 00:01:44,950
ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ರನ್ಟೈಮ್ ಹೇಗೆ ಬೆಳೆಯುತ್ತವೆ ಮಾಡುವುದಿಲ್ಲ?

41
00:01:44,950 --> 00:01:47,390
ಉದಾಹರಣೆಗೆ, ಪಾತ್ರಗಳ ಸಂಖ್ಯೆಯನ್ನು ಎಣಿಸುವ ಕಲ್ಪನೆ

42
00:01:47,390 --> 00:01:49,350
ಒಂದು ಸಾಲಿನಲ್ಲಿ ಸರಳ ರೀತಿಯಲ್ಲಿ

43
00:01:49,350 --> 00:01:51,620
 ಇಡೀ ಅಕ್ಷರ ಮೂಲಕ ಕಾಲ್ನಡಿಗೆಯಲ್ಲೇ

44
00:01:51,620 --> 00:01:54,790
ಪತ್ರ ಅದಕ್ಕೆ ಅಕ್ಷರದ ಮತ್ತು ಪ್ರತಿ ಪಾತ್ರಕ್ಕೆ ಪ್ರತಿ 1 ಸೇರಿಸುವ.

45
00:01:55,700 --> 00:01:58,420
ಈ ಕ್ರಮಾವಳಿಯ ರೇಖೀಯ ಸಮಯದಲ್ಲಿ ರನ್ ಹೇಳಲಾಗುತ್ತದೆ

46
00:01:58,420 --> 00:02:00,460
ಪಾತ್ರಗಳು ಸಂಖ್ಯೆಗೆ ಸಂಬಂಧಿಸಿದಂತೆ,

47
00:02:00,460 --> 00:02:02,670
ಸಾಲಿನಲ್ಲಿ 'ಎನ್'.

48
00:02:02,670 --> 00:02:04,910
ಸಂಕ್ಷಿಪ್ತವಾಗಿ, ಇದು ಒ (N) ರಲ್ಲಿ ಚಲಾಯಿಸುತ್ತದೆ.

49
00:02:05,570 --> 00:02:07,290
ಏಕೆ ಈ?

50
00:02:07,290 --> 00:02:09,539
ಅಲ್ಲದೆ, ಈ ವಿಧಾನ ಬಳಸಿ, ಸಮಯ ಅಗತ್ಯವಿದೆ

51
00:02:09,539 --> 00:02:11,300
ಇಡೀ ಸ್ಟ್ರಿಂಗ್ ಹಾದುಹೋಗಬೇಕಾದರೆ

52
00:02:11,300 --> 00:02:13,920
ಅಕ್ಷರಗಳ ಸಂಖ್ಯೆಯು ಅನುಪಾತದಲ್ಲಿರುತ್ತದೆ.

53
00:02:13,920 --> 00:02:16,480
20 ಅಕ್ಷರ ಸ್ಟ್ರಿಂಗ್ ಪಾತ್ರಗಳ ಸಂಖ್ಯೆಯನ್ನು ಎಣಿಸುವ

54
00:02:16,480 --> 00:02:18,580
ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಎರಡರಷ್ಟು ಉದ್ದದ ನಾಯಕನನ್ನು ಇದೆ

55
00:02:18,580 --> 00:02:20,330
10 ಅಕ್ಷರ ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರಗಳನ್ನು ಎಣಿಸಲು,

56
00:02:20,330 --> 00:02:23,000
ನೀವು ಎಲ್ಲಾ ಪಾತ್ರಗಳು ನೋಡಲು ಏಕೆಂದರೆ

57
00:02:23,000 --> 00:02:25,740
ಮತ್ತು ಪ್ರತಿ ಪಾತ್ರದ ನೋಡಲು ಅಷ್ಟೇ ಸಮಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

58
00:02:25,740 --> 00:02:28,050
ನೀವು ಪಾತ್ರಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹೆಚ್ಚಿಸುವ, ಮಾಹಿತಿ

59
00:02:28,050 --> 00:02:30,950
ರನ್ಟೈಮ್ ಇನ್ಪುಟ್ ಉದ್ದ ರೇಖೀಯವಾಗಿ ಹೆಚ್ಚಾಗುತ್ತದೆ.

60
00:02:30,950 --> 00:02:33,500
>> ಆ ರೇಖೀಯ ಕಾಲದ ನಿರ್ಧರಿಸಿದರೆ ಈಗ, ಕಲ್ಪನೆ

61
00:02:33,500 --> 00:02:36,390
ಒ (N), ಕೇವಲ ಸಾಕಷ್ಟು ವೇಗವಾಗಿ ನೀವು ಅಲ್ಲ?

62
00:02:36,390 --> 00:02:38,750
ಬಹುಶಃ ನೀವು ಭಾರೀ ತಂತಿಗಳ ಸಂಗ್ರಹಿಸಲು ನೀವು

63
00:02:38,750 --> 00:02:40,450
ಮತ್ತು ನೀವು ತೆಗೆದುಕೊಳ್ಳುವ ಹೆಚ್ಚುವರಿ ಸಮಯ ಹೊಂದಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ

64
00:02:40,450 --> 00:02:44,000
ಒಂದು ಮೂಲಕ ಒಂದು ಎಣಿಸುವ ಅವರ ಪಾತ್ರಗಳು ಎಲ್ಲಾ ಹಾದುಹೋಗಬೇಕಾದರೆ.

65
00:02:44,000 --> 00:02:46,650
ಆದ್ದರಿಂದ, ನೀವು ಬೇರೆ ಪ್ರಯತ್ನಿಸಲು ನಿರ್ಧರಿಸಿ.

66
00:02:46,650 --> 00:02:49,270
ನೀವು ಈಗಾಗಲೇ ಪಾತ್ರಗಳ ಸಂಖ್ಯೆ ಸಂಗ್ರಹಿಸಲು ಏನಾಗಬಹುದು ವೇಳೆ

67
00:02:49,270 --> 00:02:52,690
ಸಾಲಿನಲ್ಲಿ, ', ಲೆನ್' ಎಂಬ ವೇರಿಯಬಲ್, ಸೇ

68
00:02:52,690 --> 00:02:54,210
ಆರಂಭದಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ ನಲ್ಲಿ,

69
00:02:54,210 --> 00:02:57,800
ನೀವು ಸಹ ನಿಮ್ಮ ಸ್ಟ್ರಿಂಗ್ ಬಹಳ ಮೊದಲ ಅಕ್ಷರ ಸಂಗ್ರಹವಾಗಿರುವ ಮೊದಲು?

70
00:02:57,800 --> 00:02:59,980
ನಂತರ, ಎಲ್ಲಾ ನೀವು, ಸ್ಟ್ರಿಂಗ್ ಉದ್ದ ಕಂಡುಹಿಡಿಯಲು ಈಗ ಮಾಡಬೇಕು ಬಯಸುವ

71
00:02:59,980 --> 00:03:02,570
ವೇರಿಯಬಲ್ ಮೌಲ್ಯವನ್ನು ಏನು ಪರಿಶೀಲಿಸಿ ಇದೆ.

72
00:03:02,570 --> 00:03:05,530
ನೀವು ಎಲ್ಲಾ ಸಮಯದಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ಸ್ವತಃ ನೋಡಲು ಅಗತ್ಯವಿಲ್ಲ

73
00:03:05,530 --> 00:03:08,160
ಮತ್ತು ಲೆನ್ ಒಂದು ವೇರಿಯೇಬಲ್ ಮೌಲ್ಯವನ್ನು ಪ್ರವೇಶಿಸುವ ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ

74
00:03:08,160 --> 00:03:11,100
ಒಂದು asymptotically ನಿರಂತರ ಸಮಯದಲ್ಲಿ ಕಾರ್ಯಾಚರಣೆಯ

75
00:03:11,100 --> 00:03:13,070
ಅಥವಾ ಓ (1).

76
00:03:13,070 --> 00:03:17,110
ಏಕೆ ಈ? ಅಲ್ಲದೆ, ಅಸಂಪಾತ ಸಂಕೀರ್ಣತೆಯನ್ನು ಅರ್ಥ ಎಂಬುದನ್ನು ನೆನಪಿಡಿ.

77
00:03:17,110 --> 00:03:19,100
ಹೇಗೆ ಗಾತ್ರವು ರನ್ಟೈಮ್ ಬದಲಾಗಬಹುದು

78
00:03:19,100 --> 00:03:21,400
ನಿಮ್ಮ ಒಳಹರಿವು ಬೆಳೆಯುತ್ತದೆ?

79
00:03:21,400 --> 00:03:24,630
>> ನೀವು ದೊಡ್ಡ ಸ್ಟ್ರಿಂಗ್ ಪಾತ್ರಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪಡೆಯಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಹೇಳುತ್ತಾರೆ.

80
00:03:24,630 --> 00:03:26,960
ಅಲ್ಲದೆ, ಇದು, ನೀವು ಸ್ಟ್ರಿಂಗ್ ಮಾಡಲು ಹೇಗೆ ದೊಡ್ಡ ಪರವಾಗಿಲ್ಲ ಎಂದು

81
00:03:26,960 --> 00:03:28,690
ಇನ್ನೂ ಒಂದು ಮಿಲಿಯನ್ ಅಕ್ಷರಗಳು ಉದ್ದ,

82
00:03:28,690 --> 00:03:31,150
ಎಲ್ಲಾ ನೀವು, ಈ ವಿಧಾನ ಸ್ಟ್ರಿಂಗ್ ಉದ್ದದ ಹುಡುಕಲು ಮಾಡಬೇಕು ಬಯಸುವ

83
00:03:31,150 --> 00:03:33,790
, ವೇರಿಯಬಲ್ ಲೆನ್ ಮೌಲ್ಯವನ್ನು ಓದಿ ಆಗಿದೆ

84
00:03:33,790 --> 00:03:35,440
ಇದು ನೀವು ಈಗಾಗಲೇ ಮಾಡಿದ.

85
00:03:35,440 --> 00:03:38,200
ಎಂದು ಇನ್ಪುಟ್ ಉದ್ದ, ನೀವು ಹೇಗೆ ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಸ್ಟ್ರಿಂಗ್ ಉದ್ದ,

86
00:03:38,200 --> 00:03:41,510
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ರನ್ ಎಷ್ಟು ವೇಗವಾಗಿ ಎಲ್ಲ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ.

87
00:03:41,510 --> 00:03:44,550
ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಈ ಭಾಗವನ್ನು ಒಂದು ಪಾತ್ರ ತಂತುವಿನ ಮೇಲೆ ಅಷ್ಟೇ ವೇಗವಾಗಿ ಓಡುತ್ತವೆ

88
00:03:44,550 --> 00:03:46,170
ಮತ್ತು ಒಂದು ಸಾವಿರ ಅಕ್ಷರ ಸ್ಟ್ರಿಂಗ್,

89
00:03:46,170 --> 00:03:49,140
ಈ ಕಾರ್ಯಕ್ರಮ ನಿರಂತರ ಸಮಯದಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಎಂದು ಏಕೆ ಎಂದು ಮತ್ತು ಆ ಸ್

90
00:03:49,140 --> 00:03:51,520
ಇನ್ಪುಟ್ ಗಾತ್ರಕ್ಕೆ ಸಂಬಂಧಿಸಿದಂತೆ.

91
00:03:51,520 --> 00:03:53,920
>> ಸಹಜವಾಗಿ, ಒಂದು ನ್ಯೂನತೆ ಇತ್ತು.

92
00:03:53,920 --> 00:03:55,710
ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ನಲ್ಲಿ ಹೆಚ್ಚುವರಿ ಮೆಮೊರಿ ಸ್ಪೇಸ್ ಖರ್ಚು

93
00:03:55,710 --> 00:03:57,380
ವೇರಿಯಬಲ್ ಸಂಗ್ರಹಿಸುವ

94
00:03:57,380 --> 00:03:59,270
ಮತ್ತು ನೀವು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಹೆಚ್ಚುವರಿ ಸಮಯ

95
00:03:59,270 --> 00:04:01,490
ವೇರಿಯಬಲ್ ನಿಜವಾದ ಸಂಗ್ರಹ ಮಾಡಲು,

96
00:04:01,490 --> 00:04:03,390
ಆದರೆ ಪಾಯಿಂಟ್ ಇನ್ನೂ ನಿಂತಿದೆ,

97
00:04:03,390 --> 00:04:05,060
ನಿಮ್ಮ ವಾಕ್ಯವನ್ನು ಹೇಗೆ ದೀರ್ಘ ಪತ್ತೆ

98
00:04:05,060 --> 00:04:07,600
ಎಲ್ಲ ಸ್ಟ್ರಿಂಗ್ ಉದ್ದ ಅವಲಂಬಿಸಿಲ್ಲ.

99
00:04:07,600 --> 00:04:10,720
ಆದ್ದರಿಂದ, ಇದು ಒ (1) ಅಥವಾ ನಿರಂತರ ಸಮಯದಲ್ಲಿ ಸಾಗುತ್ತದೆ.

100
00:04:10,720 --> 00:04:13,070
ಈ ಖಂಡಿತವಾಗಿಯೂ ಅರ್ಥ ಹೊಂದಿಲ್ಲ

101
00:04:13,070 --> 00:04:15,610
ನಿಮ್ಮ ಕೋಡ್, 1 ಹಂತದಲ್ಲಿ ಚಾಲನೆ

102
00:04:15,610 --> 00:04:17,470
ಆದರೆ ಯಾವುದೇ ಎಷ್ಟು ಹಂತಗಳನ್ನು ಅದು,

103
00:04:17,470 --> 00:04:20,019
ಇದು ಒಳಹರಿವಿನ ಗಾತ್ರದೊಂದಿಗೆ ಬದಲಾಗದ,

104
00:04:20,019 --> 00:04:23,420
ಈಗಲೂ ನಾವು ಒ (1) ಮಾಹಿತಿ ಪ್ರತಿನಿಧಿಸುವ asymptotically ಸ್ಥಿರ ಇಲ್ಲಿದೆ.

105
00:04:23,420 --> 00:04:25,120
>> ನೀವು ಬಹುಶಃ ಊಹೆ ಮಾಡಬಹುದು ಎಂದು,

106
00:04:25,120 --> 00:04:27,940
ಜೊತೆಗೆ ಕ್ರಮಾವಳಿಗಳು ಅಳೆಯಲು ವಿವಿಧ ದೊಡ್ಡ ಒ ರನ್ಟೈಮ್ಗಳನ್ನು ಇವೆ.

107
00:04:27,940 --> 00:04:32,980
ಒ (N) ² ಕ್ರಮಾವಳಿಗಳು O (N) ಕ್ರಮಾವಳಿಗಳಿಗಿಂತ asymptotically ನಿಧಾನವಾಗಿರುತ್ತವೆ.

108
00:04:32,980 --> 00:04:35,910
ಘಟಕಗಳ ಸಂಖ್ಯೆ (n) ಬೆಳೆಯುತ್ತದೆ ಎಂದು, ಇದು

109
00:04:35,910 --> 00:04:39,280
ಅಂತಿಮವಾಗಿ O (N) ² ಕ್ರಮಾವಳಿಗಳು ಹೆಚ್ಚು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ

110
00:04:39,280 --> 00:04:41,000
ಒ (N) ಕ್ರಮಾವಳಿಗಳು ಚಲಾಯಿಸಲು ಹೆಚ್ಚು.

111
00:04:41,000 --> 00:04:43,960
ಈ ಒ (N) ಕ್ರಮಾವಳಿಗಳು ಯಾವಾಗಲೂ ವೇಗವಾಗಿ ರನ್ ಅರ್ಥವಲ್ಲ

112
00:04:43,960 --> 00:04:46,410
ಒ (N) ² ಕ್ರಮಾವಳಿಗಳಿಗಿಂತ, ಒಂದೇ ಪರಿಸರದಲ್ಲಿ,

113
00:04:46,410 --> 00:04:48,080
ಅದೇ ಯಂತ್ರಾಂಶಕ್ಕೆ.

114
00:04:48,080 --> 00:04:50,180
ಬಹುಶಃ ಸಣ್ಣ ಇನ್ಪುಟ್ ಗಾತ್ರಕ್ಕಾಗಿ

115
00:04:50,180 --> 00:04:52,900
 ಒ (N) ² ಅಲ್ಗಾರಿದಮ್ ವಾಸ್ತವವಾಗಿ, ವೇಗವಾಗಿ ಕೆಲಸ

116
00:04:52,900 --> 00:04:55,450
ಆದರೆ, ಅಂತಿಮವಾಗಿ, ಇನ್ಪುಟ್ ಗಾತ್ರ ಹೆಚ್ಚಿಸುತ್ತದೆ

117
00:04:55,450 --> 00:04:58,760
ಅನಂತ ಕಡೆಗೆ, O (N) ² ಅಲ್ಗಾರಿದಮ್ ನ ರನ್ಟೈಮ್

118
00:04:58,760 --> 00:05:02,000
ಅಂತಿಮವಾಗಿ O (N) ಕ್ರಮಾವಳಿಯ ರನ್ಟೈಮ್ ಮೀರಿಸಬಹುದು ಕಾಣಿಸುತ್ತದೆ.

119
00:05:02,000 --> 00:05:04,230
ಯಾವುದಾದರೂ ವರ್ಗ ಗಣಿತ ಕಾರ್ಯದ ರೀತಿಯಲ್ಲಿ

120
00:05:04,230 --> 00:05:06,510
 ಅಂತಿಮವಾಗಿ ಯಾವುದೇ ರೇಖೀಯ ಕಾರ್ಯ ಹಿಂದಿಕ್ಕಿ ಕಾಣಿಸುತ್ತದೆ,

121
00:05:06,510 --> 00:05:09,200
ಎಷ್ಟು ತಲೆ ರೇಖೀಯ ಕಾರ್ಯವನ್ನು ಆರಂಭಿಸಲು ಯಾವುದೇ ಜೊತೆಗೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.

122
00:05:10,010 --> 00:05:12,000
ನೀವು ದತ್ತಾಂಶದ ದೊಡ್ಡ ಪ್ರಮಾಣಗಳ ಜೊತೆ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದಾರೆ

123
00:05:12,000 --> 00:05:15,510
ಓ ಚಲಾಯಿಸಲು ಕ್ರಮಾವಳಿಗಳನ್ನು (N) ² ಸಮಯ ನಿಜವಾಗಿಯೂ, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ನಿಧಾನವಾಗುತ್ತಿದೆ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಮಾಡಬಹುದು

124
00:05:15,510 --> 00:05:17,770
ಆದರೆ ಸಣ್ಣ ಇನ್ಪುಟ್ ಗಾತ್ರಕ್ಕಾಗಿ

125
00:05:17,770 --> 00:05:19,420
ನೀವು ಬಹುಶಃ ಗಮನಕ್ಕೆ ಸಹ ಆಗುವುದಿಲ್ಲ.

126
00:05:19,420 --> 00:05:21,280
>> ಮತ್ತೊಂದು ಅಸಂಪಾತ ಸಂಕೀರ್ಣತೆ, ಆಗಿದೆ

127
00:05:21,280 --> 00:05:24,420
ಲಾಗರಿದಮ್ ಸಮಯ, ಒ (ಲಾಗ್ N).

128
00:05:24,420 --> 00:05:26,340
ಶೀಘ್ರವಾಗಿ ಈ ಹಾದು ಒಂದು ಕ್ರಮಾವಳಿಯ ಒಂದು ಉದಾಹರಣೆ

129
00:05:26,340 --> 00:05:29,060
, ಶಾಸ್ತ್ರೀಯ ಬೈನರಿ ಸರ್ಚ್ ಕ್ರಮಾವಳಿ

130
00:05:29,060 --> 00:05:31,850
ಅಂಶಗಳ ಈಗಾಗಲೇ ವಿಂಗಡಿಸಲಾದ ಪಟ್ಟಿಯಲ್ಲಿ ಒಂದು ಅಂಶ ಹುಡುಕುವ.

131
00:05:31,850 --> 00:05:33,400
>> ನೀವು ಬೈನರಿ ಸರ್ಚ್ ಏನು ಗೊತ್ತಿಲ್ಲ ವೇಳೆ,

132
00:05:33,400 --> 00:05:35,170
ನಾನು ತಕ್ಷಣ ನೀವು ಅದನ್ನು ವಿವರಿಸಲು ಮಾಡುತ್ತೇವೆ.

133
00:05:35,170 --> 00:05:37,020
ಲೆಟ್ಸ್ ನೀವು ಸಂಖ್ಯೆ 3 ಹುಡುಕುತ್ತಿರುವ ಹೇಳುತ್ತಾರೆ

134
00:05:37,020 --> 00:05:40,200
ಪೂರ್ಣಾಂಕಗಳ ಈ ಶ್ರೇಣಿಯಲ್ಲಿನ.

135
00:05:40,200 --> 00:05:42,140
ಇದು ರಚನೆಯ ಮಧ್ಯಮ ಅಂಶ ನೋಡುತ್ತದೆ

136
00:05:42,140 --> 00:05:46,830
ಮತ್ತು "ನಾನು ಹೆಚ್ಚು ಬಯಸುವ ಅಂಶ, ಸಮಾನ ಅಥವಾ ಈ ಕಡಿಮೆ?", ಕೇಳುತ್ತದೆ

137
00:05:46,830 --> 00:05:49,150
ಇದು ನಂತರ ಉತ್ತಮ, ಸಮಾನ ಸರಿ. ನೀವು ಅಂಶ ಕಂಡು, ಮತ್ತು ನೀವು ಮುಗಿಸಿದ್ದೀರಿ.

138
00:05:49,150 --> 00:05:51,300
ಇದು ಹೆಚ್ಚು ಇದ್ದರೆ, ಆಗ ನೀವು ಅಂಶ ತಿಳಿದಿದೆ

139
00:05:51,300 --> 00:05:53,440
, ರಚನೆಯ ಬಲಭಾಗದ ಎಂದು ಹೊಂದಿದೆ

140
00:05:53,440 --> 00:05:55,200
ಮತ್ತು ನೀವು ಮಾತ್ರ, ಭವಿಷ್ಯದಲ್ಲಿ ಆ ನೋಡಬಹುದು

141
00:05:55,200 --> 00:05:57,690
ಇದು ಸಣ್ಣ ಇದ್ದರೆ ಮತ್ತು, ನಂತರ ನೀವು ಎಡಗಡೆಯಲ್ಲಿ ಎಂದು ಹೊಂದಿದೆ ತಿಳಿದಿದೆ.

142
00:05:57,690 --> 00:06:00,980
ಈ ಪ್ರಕ್ರಿಯೆಯ ನಂತರ ಸಣ್ಣ ಗಾತ್ರದ ಸಹಿತ ಪುನರಾವರ್ತಿಸಲಾಗುತ್ತದೆ

143
00:06:00,980 --> 00:06:02,870
ಸರಿಯಾದ ಅಂಶ ಕಂಡುಬರುತ್ತದೆ ರವರೆಗೆ.

144
00:06:08,080 --> 00:06:11,670
>> ಈ ಶಕ್ತಿಶಾಲಿ ಅಲ್ಗಾರಿದಮ್ ಪ್ರತಿ ಕಾರ್ಯಾಚರಣೆಯಲ್ಲಿ ಅರ್ಧ ರಚನೆಯ ಗಾತ್ರ ಕತ್ತರಿಸಿ.

145
00:06:11,670 --> 00:06:14,080
ಆದ್ದರಿಂದ, ಗಾತ್ರ 8 ಒಂದು ವಿಂಗಡಿಸಲಾದ ಶ್ರೇಣಿಯಲ್ಲಿನ ಒಂದು ಅಂಶ ಹುಡುಕಲು,

146
00:06:14,080 --> 00:06:16,170
ಹೆಚ್ಚೆಂದರೆ (₂ 8 ಲಾಗಿನ್)

147
00:06:16,170 --> 00:06:18,450
ಈ ಕಾರ್ಯಾಚರಣೆಗಳ ಅಥವಾ 3,

148
00:06:18,450 --> 00:06:22,260
ಮಧ್ಯಮ ಅಂಶ ಪರೀಕ್ಷಿಸುವುದು, ನಂತರ ಅರ್ಧ ರಚನೆಯ ಕತ್ತರಿಸುವುದು, ಅಗತ್ಯವಿದೆ

149
00:06:22,260 --> 00:06:25,670
ಗಾತ್ರ 16 ಒಂದು ಶ್ರೇಣಿಯನ್ನು, (₂ 16 ಲಾಗ್) ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಆದರೆ

150
00:06:25,670 --> 00:06:27,480
ಅಥವಾ 4 ಕಾರ್ಯಾಚರಣೆಗಳು.

151
00:06:27,480 --> 00:06:30,570
ಕೇವಲ ಒಂದು ದುಪ್ಪಟ್ಟು ಗಾತ್ರದ ಶ್ರೇಣಿಗೆ 1 ಹೆಚ್ಚು ಕಾರ್ಯಾಚರಣೆಯ.

152
00:06:30,570 --> 00:06:32,220
ರಚನೆಯ ಗಾತ್ರ ದ್ವಿಗುಣಗೊಳಿಸುವ

153
00:06:32,220 --> 00:06:35,160
ಈ ಕೋಡ್ ಕೇವಲ 1 ಚಂಕ್ ಅದಕ್ಕೆ ರನ್ಟೈಮ್ ಹೆಚ್ಚಿಸುತ್ತದೆ.

154
00:06:35,160 --> 00:06:37,770
ಮತ್ತೆ, ನಂತರ ವಿಭಜಿಸುವ ಪಟ್ಟಿಯ ಮಧ್ಯಮ ಅಂಶ ಪರೀಕ್ಷಿಸುವುದು.

155
00:06:37,770 --> 00:06:40,440
ಆದ್ದರಿಂದ, ಇದು, ಲಾಗರಿದಮ್ ಸಮಯದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಹೇಳಲಾಗುತ್ತದೆ

156
00:06:40,440 --> 00:06:42,440
ಒ (ಲಾಗ್ N).

157
00:06:42,440 --> 00:06:44,270
ಆದರೆ, ನೀವು ಹೇಳುವ, ನಿರೀಕ್ಷಿಸಿ

158
00:06:44,270 --> 00:06:47,510
ಪಟ್ಟಿಯಲ್ಲಿ ನೀವು ಹುಡುಕುತ್ತಿರುವ ಅಂಶ ಅಲ್ಲಿ ಈ ಅವಲಂಬಿಸಿಲ್ಲ?

159
00:06:47,510 --> 00:06:50,090
ಹೀಗಾದರೆ ನೀವು ನೋಡಲು ಮೊದಲ ಅಂಶ ಬಲ ಎಂದು ಏನಾಗುತ್ತದೆ?

160
00:06:50,090 --> 00:06:52,040
ನಂತರ, ಕೇವಲ, 1 ಕಾರ್ಯಾಚರಣೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ

161
00:06:52,040 --> 00:06:54,310
ಪಟ್ಟಿ ಎಷ್ಟು ದೊಡ್ಡ ಯಾವುದೇ.

162
00:06:54,310 --> 00:06:56,310
>> ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನಿಗಳು ಹೆಚ್ಚು ಪದಗಳನ್ನು ಏಕೆ ಹಾಗೆಯೇ, ಆ ಸ್

163
00:06:56,310 --> 00:06:58,770
ಉತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ ಪ್ರತಿಬಿಂಬಿಸುವ ಅಸಂಪಾತ ಸಂಕೀರ್ಣತೆಯಿಂದಾಗಿ

164
00:06:58,770 --> 00:07:01,050
ಮತ್ತು ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ಒಂದು ಕ್ರಮಾವಳಿಯ ಪ್ರದರ್ಶನಗಳು.

165
00:07:01,050 --> 00:07:03,320
ಹೆಚ್ಚು ಸರಿಯಾಗಿ, ಮೇಲಿನ ಮತ್ತು ಕೆಳಗಿನ ಪರಿಮಿತಿ

166
00:07:03,320 --> 00:07:05,090
ರನ್ಟೈಮ್ ಮೇಲೆ.

167
00:07:05,090 --> 00:07:07,660
ಬೈನರಿ ಸರ್ಚ್ ಅತ್ಯುತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ, ನಮ್ಮ ಅಂಶ

168
00:07:07,660 --> 00:07:09,330
ಬಲ ಅಲ್ಲಿ ಮಧ್ಯದಲ್ಲಿ,

169
00:07:09,330 --> 00:07:11,770
ಮತ್ತು ನೀವು, ನಿರಂತರ ಸಮಯದಲ್ಲಿ ಅದು ಸಿಗುತ್ತದೆ

170
00:07:11,770 --> 00:07:14,240
ಸರಣಿ ಉಳಿದ ಹೇಗೆ ದೊಡ್ಡದಾಗಿದೆ ಯಾವುದೇ.

171
00:07:15,360 --> 00:07:17,650
ಈ ಬಳಸುವ ಚಿಹ್ನೆ Ω ಹೊಂದಿದೆ.

172
00:07:17,650 --> 00:07:19,930
ಆದ್ದರಿಂದ, ಈ ಅಲ್ಗಾರಿದಮ್ Ω (1) ಚಲಾಯಿಸಲು ಹೇಳಲಾಗುತ್ತದೆ.

173
00:07:19,930 --> 00:07:21,990
ಅತ್ಯುತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ, ಇದು ತ್ವರಿತವಾಗಿ ಅಂಶ ಕಂಡುಕೊಳ್ಳುತ್ತದೆ

174
00:07:21,990 --> 00:07:24,200
ಅರೇ ಎಷ್ಟು ದೊಡ್ಡ ಯಾವುದೇ,

175
00:07:24,200 --> 00:07:26,050
ಆದರೆ ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ,

176
00:07:26,050 --> 00:07:28,690
ಇದು (ಲಾಗ್ N) ಸ್ಪ್ಲಿಟ್ ಚೆಕ್ ಮಾಡಲು ಹೊಂದಿದೆ

177
00:07:28,690 --> 00:07:31,030
ರಚನೆಯ ಬಲ ಅಂಶ ಪಡೆಯುವುದು.

178
00:07:31,030 --> 00:07:34,270
ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ಮೇಲಿನ ಗಡಿ ನೀವು ಈಗಾಗಲೇ ತಿಳಿದಿರುವ ದೊಡ್ಡ "ಓ" ಸೂಚಿಸಲಾಗುತ್ತದೆ.

179
00:07:34,270 --> 00:07:38,080
ಆದ್ದರಿಂದ, ಇದು ಒ (ಲಾಗ್ N), ಆದರೆ Ω (1) ದ.

180
00:07:38,080 --> 00:07:40,680
>> ರೇಖೀಯ ಹುಡುಕಾಟ ತದ್ವಿರುದ್ಧವಾಗಿ,

181
00:07:40,680 --> 00:07:43,220
ನೀವು ರಚನೆಯ ಪ್ರತಿ ಅಂಶ ಸಂಚರಿಸಲು ಇದರಲ್ಲಿ

182
00:07:43,220 --> 00:07:45,170
ನೀವು ಒಂದು ಹುಡುಕಲು,

183
00:07:45,170 --> 00:07:47,420
ಅತ್ಯುತ್ತಮ Ω (1) ನಲ್ಲಿ ಹೊಂದಿದೆ.

184
00:07:47,420 --> 00:07:49,430
ಮತ್ತೆ, ಮೊದಲ ಅಂಶ ನೀವು ಬಯಸುವ.

185
00:07:49,430 --> 00:07:51,930
ಆದ್ದರಿಂದ, ಅದು ರಚನೆಯ ಎಷ್ಟು ದೊಡ್ಡ ಅಪ್ರಸ್ತುತವಾಗುತ್ತದೆ.

186
00:07:51,930 --> 00:07:54,840
ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ, ರಚನೆಯ ಕೊನೆಯ ಅಂಶವಾಗಿದೆ.

187
00:07:54,840 --> 00:07:58,560
ಆದ್ದರಿಂದ, ನೀವು ಖರೀದಿ ಶ್ರೇಣಿಯಲ್ಲಿನ ಎಲ್ಲಾ N ಅಂಶಗಳ ಮೂಲಕ ನಡೆಯಬೇಕು

188
00:07:58,560 --> 00:08:02,170
ನೀವು 3 ಹುಡುಕುತ್ತಿರುವ ವೇಳೆ ಇಷ್ಟ.

189
00:08:04,320 --> 00:08:06,030
ಆದ್ದರಿಂದ, ಇದು ಒ (N) ಸಮಯದಲ್ಲಿ ರನ್

190
00:08:06,030 --> 00:08:09,330
ಇದು ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ಅನುಪಾತದಲ್ಲಿರುತ್ತದೆ ಏಕೆಂದರೆ.

191
00:08:10,800 --> 00:08:12,830
>> ಬಳಸುವ ಒಂದು ಸಂಕೇತ Θ ಹೊಂದಿದೆ.

192
00:08:12,830 --> 00:08:15,820
ಈ ಅಲ್ಲಿ ಉತ್ತಮ ಮತ್ತು ಕೆಟ್ಟ ಸಂದರ್ಭಗಳಲ್ಲಿ ಕ್ರಮಾವಳಿಗಳು ವಿವರಿಸಲು ಬಳಸಬಹುದು

193
00:08:15,820 --> 00:08:17,440
ಒಂದೇ.

194
00:08:17,440 --> 00:08:20,390
ನಾವು ಹಿಂದಿನ ಬಗ್ಗೆ ಮಾತನಾಡಿದರು ಸ್ಟ್ರಿಂಗ್ ಉದ್ದದ ಕ್ರಮಾವಳಿಗಳಲ್ಲಿ ಸಂದರ್ಭದಲ್ಲಿ.

195
00:08:20,390 --> 00:08:22,780
ನಾವು ಮೊದಲು ವೇರಿಯಬಲ್ ಅದನ್ನು ಸಂಗ್ರಹಿಸಲು ವೇಳೆ ಅಂದರೆ,

196
00:08:22,780 --> 00:08:25,160
ನಾವು ಸ್ಟ್ರಿಂಗ್ ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ನಂತರ ನಿರಂತರ ಸಮಯದಲ್ಲಿ ಪ್ರವೇಶಿಸಲು.

197
00:08:25,160 --> 00:08:27,920
ಯಾವ ಸಂಖ್ಯೆಯು ಯಾವುದೇ

198
00:08:27,920 --> 00:08:30,130
ನಾವು ವೇರಿಯಬಲ್ ಸಂಗ್ರಹಿಸಲು ನೀವು, ನಾವು ನೋಡಲು ಸಾಧ್ಯವಿದೆ.

199
00:08:33,110 --> 00:08:35,110
ಅತ್ಯುತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ನೋಡೋಣ

200
00:08:35,110 --> 00:08:37,120
ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ ಉದ್ದವನ್ನು ಹೇಗೆ.

201
00:08:37,120 --> 00:08:39,799
Ω (1) ಅಥವಾ ಉತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ ನಿರಂತರ ಸಮಯ ಆದ್ದರಿಂದ.

202
00:08:39,799 --> 00:08:41,059
ಕೆಟ್ಟ ನಿದರ್ಶನವನ್ನು

203
00:08:41,059 --> 00:08:43,400
ನಾವು ನೋಡಲು ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ ಉದ್ದವನ್ನು ಹೇಗೆ.

204
00:08:43,400 --> 00:08:47,300
ಆದ್ದರಿಂದ, ಓ (1) ಅಥವಾ ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ನಿರಂತರ ಸಮಯ.

205
00:08:47,300 --> 00:08:49,180
ಆದ್ದರಿಂದ, ಉತ್ತಮ ಕೇಸ್ ಮತ್ತು ವರ್ಸ್ಟ್ ಸಂದರ್ಭಗಳಲ್ಲಿ ಕಾರಣ, ಒಂದೇ

206
00:08:49,180 --> 00:08:52,520
ಈ Θ (1) ಸಮಯ ಚಲಾಯಿಸಲು ಹೇಳಬಹುದು.

207
00:08:54,550 --> 00:08:57,010
>> ಸಂಕ್ಷಿಪ್ತವಾಗಿ, ನಾವು ಸಂಕೇತಗಳು ದಕ್ಷತೆ ಬಗ್ಗೆ ಕಾರಣ ಉತ್ತಮ ಮಾರ್ಗಗಳಿವೆ

208
00:08:57,010 --> 00:09:00,110
ಅವರು ರನ್ ತೆಗೆದುಕೊಳ್ಳಬಹುದು ನೈಜ ಜಗತ್ತಿನ ಆ ಬಗ್ಗೆ ಏನು ತಿಳಿಯದೆ,

209
00:09:00,110 --> 00:09:02,270
ಇದು ಹೊರಗಿನ ಅಂಶಗಳು ಸಾಕಷ್ಟು ಪ್ರಭಾವಿತವಾಗಿರುತ್ತದೆ

210
00:09:02,270 --> 00:09:04,190
ವಿವಿಧ ಯಂತ್ರಾಂಶ, ತಂತ್ರಾಂಶ, ಸೇರಿದಂತೆ

211
00:09:04,190 --> 00:09:06,040
ಅಥವಾ ನಿಮ್ಮ ಕೋಡ್ ವಿಶಿಷ್ಟತೆಗಳು.

212
00:09:06,040 --> 00:09:08,380
ಸಹ, ಇದು ನಮಗೆ ಏನಾಗುವುದೆಂದು ಬಗ್ಗೆ ಉತ್ತಮ ಕಾರಣವನ್ನು ಅನುಮತಿಸುತ್ತದೆ

213
00:09:08,380 --> 00:09:10,180
ಆಗ ಒಳಹರಿವು ಹೆಚ್ಚಾಗುತ್ತದೆ ಗಾತ್ರ.

214
00:09:10,180 --> 00:09:12,490
>> ನೀವು ಒ (N) ² ಕ್ರಮಾವಳಿ, ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿರುವ ನೀವು

215
00:09:12,490 --> 00:09:15,240
ಅಥವಾ ಕಳಪೆ, ಒಂದು ಒ (2 ⁿ) ಕ್ರಮಾವಳಿ,

216
00:09:15,240 --> 00:09:17,170
ವೇಗವಾಗಿ ಬೆಳೆಯುತ್ತಿರುವ ರೀತಿಯ ಒಂದು,

217
00:09:17,170 --> 00:09:19,140
ನೀವು ನಿಜವಾಗಿಯೂ ಕುಸಿತ ಗಮನಕ್ಕೆ ಆರಂಭಿಸಲು ಮಾಡುತ್ತೇವೆ

218
00:09:19,140 --> 00:09:21,220
ನೀವು ಡೇಟಾವನ್ನು ದೊಡ್ಡ ಪ್ರಮಾಣದಲ್ಲಿ ಕೆಲಸ ಪ್ರಾರಂಭಿಸಿದಾಗ.

219
00:09:21,220 --> 00:09:23,590
>> ಆ ಅಸಂಪಾತ ಸಂಕೀರ್ಣತೆ ಇಲ್ಲಿದೆ. ಧನ್ಯವಾದಗಳು.