1
00:00:00,000 --> 00:00:00,500

2
00:00:00,500 --> 00:00:02,500
ZAMYLA ಚಾನ್: ಇದು ನನಗೆ,, Zamyla ಇಲ್ಲಿದೆ.

3
00:00:02,500 --> 00:00:06,910
ಮಾರಿಯೋ ಇಂದು, ನಾವು ಎಂದು ನೀನು
ಮಾರಿಯೋ ಅರ್ಧ ಪಿರಮಿಡ್ ರೇಖಾಚಿತ್ರ

4
00:00:06,910 --> 00:00:08,290
ಮೇಲೇರಲು.

5
00:00:08,290 --> 00:00:11,570
>> ಆದ್ದರಿಂದ ಬಗ್ಗೆ ಮಾತನಾಡೋಣ ನಮ್ಮ
ಈ ಸಮಸ್ಯೆಗೆ ಟು-ಡು.

6
00:00:11,570 --> 00:00:13,610
ನಾವು ಬಯಸುವ ಎಂದು ನೀನು
ಕೇಳುತ್ತದೆ ಮತ್ತು ಮೌಲ್ಯೀಕರಿಸಲು

7
00:00:13,610 --> 00:00:18,290
ಹೇಗೆ ಒಂದು ಮಾನ್ಯ ಇನ್ಪುಟ್ ಬಳಕೆದಾರ
ಹೆಚ್ಚಿನ ಅವರು ಎಂದು ಮಾರಿಯೋ ಪಿರಮಿಡ್ ಬಯಸುವ.

8
00:00:18,290 --> 00:00:20,090
ನಂತರ, ನಾವು ಇದು ಸೆಳೆಯಲು ನೀನು.

9
00:00:20,090 --> 00:00:24,870
ಆದ್ದರಿಂದ ಪ್ರೇರಣೆಯಂತೆ ಪ್ರಾರಂಭಿಸಲು ಅವಕಾಶ ಮತ್ತು
ತಮ್ಮ ಇನ್ಪುಟ್ ಬಳಕೆದಾರ ಊರ್ಜಿತಗೊಳಿಸಿ.

10
00:00:24,870 --> 00:00:27,640
>> ನಾವು ಬಳಸಿಕೊಳ್ಳಬಹುದಾಗಿದೆ
CS50 ಗ್ರಂಥಾಲಯದ ಕಾರ್ಯವನ್ನು

11
00:00:27,640 --> 00:00:31,160
ಖಾತ್ರಿ ಎಂದು ಇಂಟ್ ಪಡೆಯಿರಿ
ಬಳಕೆದಾರ ಒಂದು ಪೂರ್ಣಾಂಕ ಒಳಹರಿವು.

12
00:00:31,160 --> 00:00:35,730
ಯಾವುದೇ ಧನಾತ್ಮಕ ಪೂರ್ಣಾಂಕಗಳು ಋಣಾತ್ಮಕ
ಪೂರ್ಣಾಂಕಗಳು ಸಂಖ್ಯೆ 0 ಎಲ್ಲಾ ನ್ಯಾಯಯುತ ಆಟದ.

13
00:00:35,730 --> 00:00:41,670
ಇಲ್ಲವಾದರೆ, ಬಳಕೆದಾರ ಸೂಚಿಸಲಾಗುವುದು
ಅವರು ಇನ್ಪುಟ್ ಮಾನ್ಯ ಪೂರ್ಣಾಂಕ ತನಕ ಮರುಪ್ರಯತ್ನಿಸಿ.

14
00:00:41,670 --> 00:00:44,210
ಈಗ ಇಂಟ್ ಪಡೆಯಲು ಆದಾಗ್ಯೂ
ಬಹಳಷ್ಟು ನಮಗೆ ಕೆಲಸ

15
00:00:44,210 --> 00:00:46,730
ಮುಟ್ಟುವಲ್ಲಿ ಎಂದು
ಬಳಕೆದಾರ ನಮಗೆ ಒಂದು ಪೂರ್ಣಾಂಕ ನೀಡುತ್ತದೆ,

16
00:00:46,730 --> 00:00:50,760
ನಾವು ಇನ್ನೂ ಕೆಲವು ಅನ್ವಯಿಸಲು ಅಗತ್ಯವಿದೆ
ಮೇಲೆ ಹೆಚ್ಚುವರಿ ನಿರ್ಬಂಧಗಳನ್ನು.

17
00:00:50,760 --> 00:00:56,420
ಎಲ್ಲಾ ನಂತರ, ನಾವು ಮಾರಿಯೋ ಕ್ಲೈಂಬಿಂಗ್ ಹೊಂದುವಂತಿಲ್ಲ
ಋಣಾತ್ಮಕ 12 ಎತ್ತರದ ಒಂದು ಅರ್ಧ ಪಿರಮಿಡ್.

18
00:00:56,420 --> 00:00:59,040
>> ಅದಕ್ಕೆ ಜೊತೆಯಾಗಿ,
ಸಮಸ್ಯೆ ವಿವರಣೆಯನ್ನು

19
00:00:59,040 --> 00:01:02,490
ನಾವು ಮಾತ್ರ ಹೇಳುತ್ತಾರೆ
ಮಾರಿಯೋ ಏರಲು ಅವಕಾಶ

20
00:01:02,490 --> 00:01:06,940
ಒಂದು ಪಿರಮಿಡ್ ಹೈಟ್ಸ್ 0 ಮತ್ತು 23 ರ ನಡುವೆ.

21
00:01:06,940 --> 00:01:11,120
ಸರಿ, ಆದ್ದರಿಂದ ನಾವು ಅಗತ್ಯವಿರುವ ಅರ್ಥ
ನಿರಂತರವಾಗಿ ಬಳಕೆದಾರರು ಪ್ರಾಂಪ್ಟ್ ಮಾಡಲು

22
00:01:11,120 --> 00:01:14,320
ನಮಗೆ ಮಾನ್ಯ ನೀಡಲು
ಸಂಖ್ಯೆ ಮತ್ತು ಮಾತ್ರ ಮುಂದುವರಿಸಿ

23
00:01:14,320 --> 00:01:17,120
ಒಮ್ಮೆ ಅವರು ಮಾನ್ಯ ಎತ್ತರ ನೀಡಿದ್ದೇನೆ.

24
00:01:17,120 --> 00:01:18,720
ಹೇಗೆ ನಾವು ಏನು ಇಲ್ಲ?

25
00:01:18,720 --> 00:01:23,760
>> ಅಲ್ಲದೆ, ನಿರಂತರ ಪ್ರಕ್ರಿಯೆಗಳಾದ ನೀಡುವಂತಹ
ಸೇರಿರುವ ಏನಾದರೂ ಮಾಡುವ ಕಲ್ಪನೆ

26
00:01:23,760 --> 00:01:24,720
ಪುನರಾವರ್ತಿತ.

27
00:01:24,720 --> 00:01:28,220
ಸದ್ಯಕ್ಕೆ ಸಿ ಒಂದು ಲೂಪ್
ಲೂಪ್ ನಿರಂತರವಾಗಿ ತಿನ್ನುವೆ

28
00:01:28,220 --> 00:01:33,480
ಅಲ್ಲಿಯವರೆಗೆ ಲೂಪ್ ದೇಹದ ಕಾರ್ಯಗತಗೊಳಿಸಲು
ಕೊಟ್ಟಿರುವ ಶರತ್ತು ನಿಜವೆಂದು ಮಾಪನ.

29
00:01:33,480 --> 00:01:36,200
ತಕ್ಷಣ ಆ ಸ್ಥಿತಿಯಂತೆ
ತಪ್ಪಾಗಿ ರೋಗ,

30
00:01:36,200 --> 00:01:39,770
ಪ್ರೋಗ್ರಾಂ ಮುಂದುವರೆಯಲು ಮಾಡುತ್ತದೆ
ಯಾವುದೇ ನಂತರ ಬರುತ್ತದೆ.

31
00:01:39,770 --> 00:01:43,180
ಹಾಗೆಯೇ ಕುಣಿಕೆಗಳು ಒಂದು ಮಾರ್ಗವಾಗಿದೆ
ನಿರಂತರವಾಗಿ ನಾವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವ

32
00:01:43,180 --> 00:01:45,320
ಮಾನ್ಯ ಇನ್ಪುಟ್ ಬಳಕೆದಾರರು ಪ್ರಾಂಪ್ಟ್.

33
00:01:45,320 --> 00:01:50,070
ಮತ್ತು ಒಮ್ಮೆ ಅವರು ನಮಗೆ ಒಂದು ಮಾನ್ಯವಾದ ಇನ್ಪುಟ್ ನೀಡಲು,
ನಾವು ಮುಂದಿನ ಬರುತ್ತದೆ ಯಾವುದೇ ಮುಂದುವರೆಯಲು ಮಾಡುತ್ತೇವೆ.

34
00:01:50,070 --> 00:01:54,380
ನಾವು ಕೇಳಲು ನೀನು ತಿಳಿದಿದೆ
ಇನ್ಪುಟ್ ಬಳಕೆದಾರ ಒಮ್ಮೆಯಾದರೂ.

35
00:01:54,380 --> 00:01:59,200
ಈಗ ನಾವು ಒಂದು ಸಹೋದರಿ ಬಂದು
ಸಮಯದಲ್ಲಿ ಲೂಪ್, ಮಾಡಬೇಡಿ ಸಮಯದಲ್ಲಿ ಲೂಪ್.

36
00:01:59,200 --> 00:02:02,650
>> ಕುಣಿಕೆಗಳು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಮಾಡುತ್ತದೆ ಡು
ಲೂಪ್ ದೇಹದ ಒಮ್ಮೆಯಾದರೂ.

37
00:02:02,650 --> 00:02:06,150
ಆದ್ದರಿಂದ ಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸುವ ಇಲ್ಲದೆ,
ಇದು ಲೂಪ್ ದೇಹದ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಮಾಡುತ್ತದೆ.

38
00:02:06,150 --> 00:02:09,750
ತದನಂತರ ನೋಡಲು ಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸಿ
ಎಂಬುದು ಸ್ವತಃ ಪುನರಾವರ್ತಿಸುವಂತೆ ಅಗತ್ಯವಿದೆ.

39
00:02:09,750 --> 00:02:13,080
ಈ HANDY ಬರುತ್ತದೆ
ನಾವು ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ಊರ್ಜಿತಗೊಳಿಸಿ ನೀವು.

40
00:02:13,080 --> 00:02:15,830
ನಾವು ನೀನು ತಿಳಿದಿದೆ
ಒಮ್ಮೆಯಾದರೂ ಅವರನ್ನು ಕೇಳಲು.

41
00:02:15,830 --> 00:02:18,780
ಆದ್ದರಿಂದ ಹಾಗೆ ಲೂಪ್ ಮಾಡಬಹುದು
ಈ ರೀತಿಯ ನೋಡಲು.

42
00:02:18,780 --> 00:02:20,090
ನಾವು ಒಂದು ಪೂರ್ಣಾಂಕ ಎನ್.

43
00:02:20,090 --> 00:02:22,760
ಮತ್ತು ಸಂದರ್ಭದಲ್ಲಿ ಒಳಗೆ
ಲೂಪ್, ನಾವು ತಕ್ಷಣ

44
00:02:22,760 --> 00:02:24,750
ಒಂದು ಪೂರ್ಣಾಂಕ ಬಳಕೆದಾರ ಕೇಳುತ್ತದೆ.

45
00:02:24,750 --> 00:02:29,740
ಎನ್ ಅಮಾನ್ಯವಾಗಿದೆ ವೇಳೆ, ನಾವು ಅವುಗಳನ್ನು ಪ್ರಾಂಪ್ಟ್ ಮಾಡುತ್ತೇವೆ
ಮತ್ತೆ ಮತ್ತೆ ಮತ್ತೆ ಅವರು ರವರೆಗೆ

46
00:02:29,740 --> 00:02:31,820
ನಮಗೆ ಮಾನ್ಯ ಪೂರ್ಣಾಂಕ ನೀಡಲು.

47
00:02:31,820 --> 00:02:37,440
ಅಂತಿಮವಾಗಿ, ಒಮ್ಮೆ N ಮಾನ್ಯ ಇನ್ಪುಟ್, ನಾವು ಮಾಡುತ್ತೇವೆ
ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಉಳಿದ ಮುಂದುವರೆಯಲು.

48
00:02:37,440 --> 00:02:41,830
>> ಆದ್ದರಿಂದ ನ ವಿಶೇಷ ಮತ್ತು ಚೆಕ್ ಹಿಂತಿರುಗಿ ಅವಕಾಶ
ಏನು ಮಾನ್ಯ ಇನ್ಪುಟ್ ಸ್ಥಿತಿಗತಿಗಳನ್ನು

49
00:02:41,830 --> 00:02:43,670
ಎಂದು ನಾನು.

50
00:02:43,670 --> 00:02:48,090
ಮಾನ್ಯ ಎತ್ತರಕ್ಕೆ ಹೋಗುವ
0 ಮತ್ತು 23 ಅನ್ನು ಒಳಗೊಂಡಂತೆ ನಡುವೆ.

51
00:02:48,090 --> 00:02:53,350
ಆದ್ದರಿಂದ ಅಮಾನ್ಯವಾಗಿದೆ ಎತ್ತರಕ್ಕೆ ಹೋಗುವ
ಎಂದು ಕಡಿಮೆ 0 ಅಥವಾ ಹೆಚ್ಚು 23.

52
00:02:53,350 --> 00:02:56,420
ವಿನ್ಯಾಸ ಆದ್ದರಿಂದ ನೆನಪಿಡಿ
ನಿಮ್ಮ ಸ್ಥಿತಿಯನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ

53
00:02:56,420 --> 00:02:58,660
ಪರಿಸ್ಥಿತಿ ತಿಳಿಸುವ
ಮಾಡಬೇಡಿ ಸಮಯದಲ್ಲಿ ಲೂಪ್

54
00:02:58,660 --> 00:03:01,470
ಎನ್ ಅಮಾನ್ಯವಾಗಿದೆ ಸಂದರ್ಭದಲ್ಲಿ ಇರಬೇಕು.

55
00:03:01,470 --> 00:03:05,080
ಈಗ ಈ ಒಂದು ಹಿಂದಿರುಗಬಹುದೆಂದು ಇದೆ
ಸರಳ ಏಕೈಕ ಬೂಲಿಯನ್ ಅಭಿವ್ಯಕ್ತಿ.

56
00:03:05,080 --> 00:03:07,630
ನಾವು ಒಗ್ಗೂಡಿ ಮಾಡಬೇಕು ನೀನು
ಎರಡು ವಿಭಿನ್ನ ಅಭಿವ್ಯಕ್ತಿಗಳು

57
00:03:07,630 --> 00:03:09,900
ನಮ್ಮ ಇಡೀ ಸ್ಥಿತಿಯನ್ನು ಮಾಡಲು.

58
00:03:09,900 --> 00:03:13,290
>> ಇದರಿಂದ ಕೇವಲ ಒಂದು ಸತ್ಯ ನನ್ನ ಟೇಬಲ್ ಬಂದಿದೆ ನೋಡೋಣ
ಈಗಾಗಲೇ ನಾವು ಎಂಬುದನ್ನು ಸುಳಿವು ನೀಡಿದ

59
00:03:13,290 --> 00:03:15,200
ಎರಡು Booleans ವ್ಯವಹರಿಸುವಾಗ ಎಂದು ನೀನು.

60
00:03:15,200 --> 00:03:19,620
ಇಲ್ಲಿ ಒಂದು ಸತ್ಯ ಟೇಬಲ್ ಅಲ್ಲಿ ನಾನು
ಎರಡು Booleans-- ಬೂಲಿಯನ್ 1 ಮತ್ತು 2 ಹೊಂದಿವೆ.

61
00:03:19,620 --> 00:03:27,050
ನಾವು ಮೌಲ್ಯಮಾಪನ ಆಯ್ಕೆಯು
bool1 ಮತ್ತು bool2 ಅಥವಾ bool1 ಅಥವಾ bool2.

62
00:03:27,050 --> 00:03:31,980
ಮತ್ತು ಕೇವಲ ಎರಡೂ ವೇಳೆ ನಿಜವಾದ ಇರುತ್ತದೆ
Booleans ಎಲ್ಲಾ ಆದರೆ ನಿಜವಾದ ಗೆ ಮೌಲ್ಯಮಾಪನ

63
00:03:31,980 --> 00:03:37,280
ಅಥವಾ ಒಂದು ಎಲ್ಲಿಯವರೆಗೆ ನಿಜವಾದ ಇರುತ್ತದೆ
ಎರಡು Booleans ನಿಜವೆಂದು ಮಾಪನ.

64
00:03:37,280 --> 00:03:41,450
ಸರಿ, ಆದ್ದರಿಂದ ಕೊಂಚ ಬಿಡುವು, ಈ ವಿರಾಮ
ವೀಡಿಯೊ ಮತ್ತು ಈ ಸತ್ಯ ಟೇಬಲ್ ಜೀರ್ಣಿಸಿಕೊಳ್ಳಲು.

65
00:03:41,450 --> 00:03:42,930
ನಾನು ಇಲ್ಲಿ ಕಾಯುವ ಮಾಡುತ್ತೇವೆ.

66
00:03:42,930 --> 00:03:45,760
ನೀವು ಮತ್ತೆ ಬಂದಾಗ, ನೋಡಿ
ನೀವು ಒಟ್ಟಿಗೆ ಪೀಸ್ ವೇಳೆ

67
00:03:45,760 --> 00:03:51,910
ಒಂದು ಬೂಲಿಯನ್ ಅಭಿವ್ಯಕ್ತಿ ನಿಮ್ಮ
ಎನ್ ಪರಿಸ್ಥಿತಿ ಅಮಾನ್ಯ ಇನ್ಪುಟ್.

68
00:03:51,910 --> 00:03:54,420
>> ಈಗ ನಾವು ಹೊಂದಿರುವ
ಮಾನ್ಯವಾದ ಬಳಕೆದಾರ ಇನ್ಪುಟ್, ಅವಕಾಶ

69
00:03:54,420 --> 00:03:58,710
ಮುಂದೆ ಹೋಗಿ ನಾವು ಹೇಗೆ ಬಗ್ಗೆ ಮಾತನಾಡಲು
ಅರ್ಧ ಪಿರಮಿಡ್ ಸೆಳೆಯಲು ಇರಬಹುದು.

70
00:03:58,710 --> 00:04:03,410
ಇಲ್ಲಿ ಈ ಸರಳ ಪಠ್ಯ ಸಂಪಾದಕದಲ್ಲಿ,
ನಾನು ಎಡ ಜೋಡಿಸಿದ ಪಿರಮಿಡ್ ಡ್ರಾ ಮಾಡಿದ.

71
00:04:03,410 --> 00:04:07,050
ಆದರೆ ನಾವು ನಮ್ಮ ಅಗತ್ಯವಿರುವ ತಿಳಿದಿದೆ
ಪಿರಮಿಡ್ ಬಲ ಜೋಡಿಸಿದ ಎಂದು.

72
00:04:07,050 --> 00:04:08,650
ಆದ್ದರಿಂದ ಹೇಗೆ ನಾನು ಏನು ಮಾಡಬಹುದು?

73
00:04:08,650 --> 00:04:11,440
ನಾನು ತಳ್ಳಲು ಪ್ರಯತ್ನಿಸಿ
ಬದಿಗೆ ಎಲ್ಲವೂ

74
00:04:11,440 --> 00:04:14,880
ಕೇವಲ ಸ್ವಲ್ಪ ಹಾಕುವ ಮೂಲಕ
ನಡುವೆ ಪಾತ್ರ.

75
00:04:14,880 --> 00:04:16,779
ತದನಂತರ, ಮುಂದಿನ
ಲೈನ್, ನಾನು ಹಾಕಲು ಪಡೆಯಲಿದ್ದೇನೆ

76
00:04:16,779 --> 00:04:20,970
ಕೆಲವು ಪಾತ್ರಗಳು ಇದು ಉದ್ದಕ್ಕೂ ತಳ್ಳಲು,
ಮತ್ತು further-- ಹೀಗೆ forth--

77
00:04:20,970 --> 00:04:23,360
ನಾನು ಬಲ ಜೋಡಿಸಿದ ಪಿರಮಿಡ್ ತನಕ.

78
00:04:23,360 --> 00:04:27,780
ನಾವು ಒಂದು ಬಲ ಪಿರಮಿಡ್ ಧೃವೀಕರಣ ಹೊಂದಿರುತ್ತವೆ, ಆದರೆ
ಇದು ಚುಕ್ಕೆಗಳು ಬಹಳವೇ ತೋರುತ್ತಿಲ್ಲ.

79
00:04:27,780 --> 00:04:30,680
ಆದರೆ ನಾವು ಇನ್ನೂ ಬಯಸುವ
ಸಂತೋಷವನ್ನು ಅಂತರ ನಿರ್ವಹಿಸಲು.

80
00:04:30,680 --> 00:04:35,260
ಹಾಗಾಗಿ ಅಕ್ಷರಶಃ ಪಡೆಯಲಿದ್ದೇನೆ
ಕೆಲವು ಸ್ಥಳಗಳಲ್ಲಿ ಸೇರಿಸಿ.

81
00:04:35,260 --> 00:04:39,420
>> ಬದಲಿಗೆ ಮೂರು ಚುಕ್ಕೆಗಳ, ನಾನು ಮಾಡುತ್ತೇವೆ
ಒಂದು, ಎರಡು, ಮೂರು ಸ್ಥಳಗಳಲ್ಲಿ ಪುಟ್.

82
00:04:39,420 --> 00:04:40,370
ಎರಡನೇ ಸಾಲಿನಲ್ಲಿ.

83
00:04:40,370 --> 00:04:42,640
ನಾನು ಒಂದು, ಎರಡು ಸ್ಥಳಗಳಲ್ಲಿ ಹಾಕುತ್ತೇವೆ.

84
00:04:42,640 --> 00:04:45,370
ಮತ್ತು ಉಪಾಂತ ಮೇಲೆ
ಲೈನ್, ಒಂದು ಜಾಗವನ್ನು.

85
00:04:45,370 --> 00:04:48,290
ಇಲ್ಲಿ ನಾನು ಬಲ ಜೋಡಿಸಿದ ಪಿರಮಿಡ್ ಹೊಂದಿರುತ್ತವೆ.

86
00:04:48,290 --> 00:04:52,170
ಪಠ್ಯ ಉದಾಹರಣೆಗೆ ಮಾಡುವುದರಿಂದ
ಸಂಪಾದಕ, ನಾವು ಮಾದರಿ ಒಂದು ಕಲ್ಪನೆ

87
00:04:52,170 --> 00:04:54,590
ನಾವು ಅರ್ಧ ಪಿರಮಿಡ್ ಸೆಳೆಯಲು ಬಳಸಿ.

88
00:04:54,590 --> 00:04:58,080
ಪ್ರತಿ ಸಾಲಿನ, ನಾವು ಏನು ಮಾಡಿದರು
ನಾವು ಕೆಲವು ಸ್ಥಳಗಳಲ್ಲಿ ವಿಧ,

89
00:04:58,080 --> 00:05:00,170
ಕೆಲವು ತದನಂತರ ಟೈಪ್
ಹ್ಯಾಷ್ ಸ್, ಮತ್ತು ನಂತರ ಟೈಪ್

90
00:05:00,170 --> 00:05:03,020
Enter ಕೀಲಿಯನ್ನು, ಇದು
ಹೊಸ ಲೈನ್ ರಚಿಸುತ್ತಿದೆ.

91
00:05:03,020 --> 00:05:07,770
ಈಗ ನಾವು ಹೊಂದಿರುವ, ಮುಂದುವರೆಯೋಣ
ಇನ್ನೂ ಒಂದು ಹೆಜ್ಜೆ ಮತ್ತು ಒಂದು ಮಾದರಿ ಹೇಗೆ.

92
00:05:07,770 --> 00:05:10,170
>> ಹಾಗಾಗಿ, ಹೇಳಲು ಪಡೆಯಲಿದ್ದೇನೆ
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ ಬಗ್ಗೆ,

93
00:05:10,170 --> 00:05:12,480
ನಾವು 8 ಎತ್ತರದಲ್ಲಿ ಮಾತಾಡುತ್ತಿದ್ದೀರಿ.

94
00:05:12,480 --> 00:05:17,100
ಮೊದಲ ಸಾಲಿನಲ್ಲಿ ಎರಡು ಮಾಡಲಿಕ್ಕೆ ಇದೆ
ಏಳು ಸ್ಥಳಗಳನ್ನು ಕೆಳಗಿನ ಹ್ಯಾಷೆಸ್.

95
00:05:17,100 --> 00:05:20,020
ಎರಡನೇ ಮೂರು ಹ್ಯಾಷೆಸ್, ಆರು ಸ್ಥಳಗಳನ್ನು.

96
00:05:20,020 --> 00:05:24,260
ಮೂರನೇ row-- ನಾಲ್ಕು ಹ್ಯಾಷೆಸ್, ಐದು
ಜಾಗಗಳು ಹೀಗೆ ಮುಂದಕ್ಕೆ

97
00:05:24,260 --> 00:05:26,350
ನಾವು ಎನ್ತ್ ಸಾಲಿನ ಪಡೆಯಲು ತನಕ.

98
00:05:26,350 --> 00:05:31,540
ಆದ್ದರಿಂದ, ನಾನು ಎನ್ತ್ ಸಾಲಿನ ಕೇಳುತ್ತೇವೆ,
ಎಷ್ಟು ಹ್ಯಾಷೆಸ್ ನಾವು ಹೋಗುವ

99
00:05:31,540 --> 00:05:33,120
ಮತ್ತು ಎಷ್ಟು ಸ್ಥಳಗಳಲ್ಲಿ?

100
00:05:33,120 --> 00:05:37,000
ಆದ್ದರಿಂದ ಒಂದು ಲೆಕ್ಕಾಚಾರ ನಿಮಗೆ ಬಿಟ್ಟಿದ್ದು
ಸೂತ್ರ ಎಷ್ಟು ಹ್ಯಾಷೆಸ್ ಪ್ರತಿನಿಧಿಸಲು

101
00:05:37,000 --> 00:05:42,020
ಮತ್ತು ಹೇಗೆ ಅನೇಕ ಸ್ಥಳಗಳನ್ನು ಅಗತ್ಯವಿದೆ
ಎನ್ತ್ ಸಾಲು ನೀವು ಕೆಲವು ಎತ್ತರ ಹೊಂದಿರುವಾಗ.

102
00:05:42,020 --> 00:05:46,060
>> ಈಗ ನೀವು ಈ ಕುರಿತಾಗಿ ಮಾಡಿದಾಗ,
ನೀವು ಸೂಚಿ ನೀವು ಜಾಗರೂಕರಾಗಿರಿ.

103
00:05:46,060 --> 00:05:49,170
ನಾನು ಈ ಮೂಲಕ ಅರ್ಥ ಎಂದು
ದೈನಂದಿನ ಜೀವನದಲ್ಲಿ ನಮಗೆ ಎಲ್ಲಾ

104
00:05:49,170 --> 00:05:51,540
1 ಸಾಮಾನ್ಯವಾಗಿ, ಎಣಿಸುವ ಆರಂಭಿಸಲು.

105
00:05:51,540 --> 00:05:55,950
ಆದರೆ CS50 ರಲ್ಲಿ ಮತ್ತು ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನದಲ್ಲಿ
ಸಾಮಾನ್ಯವಾಗಿ, ನಾವು 0 ಸೂಚಿತವಾಗಿರುವ ಮಾಡಲಾಗುತ್ತದೆ.

106
00:05:55,950 --> 00:06:00,620
ಆದ್ದರಿಂದ ಮೊದಲ ಸಾಲಿನಲ್ಲಿ ಎಂದು
0 ಎನ್ 1 ವಿರೋಧಿಸಿದರು.

107
00:06:00,620 --> 00:06:04,550
ನೀವು ಇರುವಾಗ ಈ ಜಾಗರೂಕರಾಗಿರಿ
ನಿಮ್ಮ ಮಾದರಿ ಔಟ್ ಲೆಕ್ಕಾಚಾರ ಹಾಕಿದ್ದೆ.

108
00:06:04,550 --> 00:06:07,570
ಈಗ ಹೇಗೆ ಹಿಂತಿರುಗಿ ಅವಕಾಶ
ನಾವು ನಮ್ಮ ಪಿರಮಿಡ್ ಸೆಳೆಯಲು ನೀನು.

109
00:06:07,570 --> 00:06:12,300
ಪ್ರತಿ ಸಾಲಿನ, ನಾವು ಬಯಸುವ ಹೋಗುವ
, ಸ್ಥಳಗಳಲ್ಲಿ ಮುದ್ರಿಸಿ ಹ್ಯಾಷೆಸ್ ಮುದ್ರಿಸಲು,

110
00:06:12,300 --> 00:06:14,050
ಮತ್ತು ನಂತರ ಒಂದು ಹೊಸ ಸಾಲು ಮುದ್ರಿಸಲು.

111
00:06:14,050 --> 00:06:19,160
ಇಲ್ಲಿ ಸುಳಿವು
ಪ್ರತಿ ಸಾಲಿನ "ಫಾರ್" ಪದ.

112
00:06:19,160 --> 00:06:21,470
ಸಿ, ನಾವು ಒಂದು ರಚನೆ ಹೊಂದಿವೆ
ಲೂಪ್ ಒಂದು ಎಂದು,

113
00:06:21,470 --> 00:06:25,250
ಒಂದು ಒಳಗೊಂಡಿರುವುದರಿಂದ
ಪ್ರಾಥಮಿಕ, ಸ್ಥಿತಿ, ಒಂದು ಅಪ್ಡೇಟ್,

114
00:06:25,250 --> 00:06:26,790
ಮತ್ತು ಲೂಪ್ ದೇಹದ.

115
00:06:26,790 --> 00:06:31,360
>> ನಾನು ಹೇಳಲು ಬಯಸಿದರು ಹಲೋ ಹೇಳಿ
ವಿಶ್ವದ ಲೂಪ್ 50 ಬಾರಿ ನನ್ನ,

116
00:06:31,360 --> 00:06:32,880
ಈ ರೀತಿಯ ಕಾತುರದಲ್ಲಿರುತ್ತಿದ್ದರು.

117
00:06:32,880 --> 00:06:35,480
ನಾನು 0 ನನ್ನ ಪೂರ್ಣಾಂಕ ಆರಂಭಿಸಲು.

118
00:06:35,480 --> 00:06:38,230
ಪರಿಸ್ಥಿತಿ ನಾನು 50 ಕಡಿಮೆ ಎಂದು.

119
00:06:38,230 --> 00:06:42,350
ತದನಂತರ ನನ್ನ ಅಪ್ಡೇಟ್ ಕೇವಲ
ಒಂದು ಪ್ರತಿ ಬಾರಿ ನಾನು ಏರಿಕೆಯ.

120
00:06:42,350 --> 00:06:45,140
ನಾವು ಕುಣಿಕೆಗಳು ಬಳಸಬಹುದು
ವಿಷಯಗಳನ್ನು ಮೇಲೆ ತಿರುಗಿ.

121
00:06:45,140 --> 00:06:47,820
ಇಲ್ಲಿ ಗಮನಿಸಿ ನಾವು ಹೇಗೆ
ಹಾರ್ಡ್ ಹಲವಾರು ಮಾಡಲಾದ,

122
00:06:47,820 --> 00:06:51,820
ಆದರೆ ವೇರಿಯಬಲ್ ಇರಿಸಲಾಗುತ್ತದೆ
ಬದಲಿಗೆ ಸ್ಥಿತಿಯೊಳಗಿನ ಎತ್ತರ.

123
00:06:51,820 --> 00:06:56,420
ಹಾಗಾಗಿ ನಾನು ಇಲ್ಲಿ ಮಾಡುತ್ತಿರುವೆ ನಾನು iterating ನುಡಿದರು
ಪಿರಮಿಡ್ ಪ್ರತಿ ಸಾಲಿನ ಮೇಲೆ.

124
00:06:56,420 --> 00:07:00,160
ನಾನು ಪ್ರತಿ ಏನನ್ನಾದರೂ ಮಾಡಬಹುದು
ನನ್ನ ಲೂಪ್ ದೇಹದ ಒಳಗೆ ಸಾಲು.

125
00:07:00,160 --> 00:07:02,350
>> ನಾವು ಒಳಗೆ ಏನು ಮಾಡುತ್ತಿರುವೆ
ಲೂಪ್ ದೇಹದ?

126
00:07:02,350 --> 00:07:07,120
ವೆಲ್, ನಾವು ಈಗಾಗಲೇ ಹೇಳಿದಂತೆ, ನಾವು ಮುದ್ರಿಸುವ ನೀವು
ಜಾಗಗಳು ಮತ್ತು ನಾವು ಹ್ಯಾಷೆಸ್ ಮುದ್ರಿಸುವ

127
00:07:07,120 --> 00:07:09,480
ಮತ್ತು ಒಂದು ಹೊಸ ಸಾಲನ್ನು ಮುದ್ರಿಸುವ ಮಾಡುತ್ತಿದ್ದೇವೆ.

128
00:07:09,480 --> 00:07:11,950
ಲೂಪ್ ನನ್ನ ಹೊರ
ಈ ರೀತಿ ಕಾಣಿಸುತ್ತದೆ.

129
00:07:11,950 --> 00:07:15,070
ನಾನು ಪ್ರತಿ ಸಾಲಿನ ಮೇಲೆ ತಿರುಗಿ
ಪಿರಮಿಡ್, ಬಳಸಿ,

130
00:07:15,070 --> 00:07:18,890
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ವ್ಯತ್ಯಾಸಗೊಳ್ಳುವ ಎತ್ತರ
ಪಿರಮಿಡ್ ಎತ್ತರ ಸಂಗ್ರಹಿಸುತ್ತದೆ.

131
00:07:18,890 --> 00:07:22,870
ಎಂದು ಲೂಪ್ ದೇಹದ ಒಳಗೆ, ನಾನು ಮನುಷ್ಯ
ಪದೇ ಪದೇ ಸ್ಥಳಗಳಲ್ಲಿ ಮುದ್ರಿಸಿ ಹೋಗಿ, ಮುದ್ರಣ

132
00:07:22,870 --> 00:07:26,730
ಪದೇ ಪದೇ ಹ್ಯಾಷೆಸ್,
ಮತ್ತು ನಂತರ ಒಂದು ಹೊಸ ಸಾಲು ಮುದ್ರಿಸಲು.

133
00:07:26,730 --> 00:07:31,010
>> ಈಗ, ಎಲ್ಲಾ ಪರಿಕಲ್ಪನೆಗಳ ಬಳಸಿ
ನಾನು ಈ ವಾಕ್ ಮೂಲಕ ಕುರಿತು ಮಾಡಿದ,

134
00:07:31,010 --> 00:07:35,210
ಕೇಳುತ್ತದೆ ಸಾಧ್ಯವಾಗುತ್ತದೆ
ಬಳಕೆದಾರ ಇನ್ಪುಟ್, ಇನ್ಪುಟ್ ಮೌಲ್ಯೀಕರಿಸಲು,

135
00:07:35,210 --> 00:07:37,370
ನಂತರ ಅರ್ಧ ಪಿರಮಿಡ್ ಸೆಳೆಯುತ್ತವೆ.

136
00:07:37,370 --> 00:07:41,510
>> ನನ್ನ ಹೆಸರು Zamyla ಆಗಿದೆ, ಮತ್ತು ಈ CS50 ಹೊಂದಿದೆ.

137
00:07:41,510 --> 00:07:43,167