1
00:00:00,000 --> 00:00:00,982

2
00:00:00,982 --> 00:00:11,293
>> [ಸಂಗೀತ]

3
00:00:11,293 --> 00:00:13,580
>> ರಾಬ್ ಬೌಡೆನ್: ಇದು, ರಾಬ್ ನನಗೆ ಇಲ್ಲಿದೆ.

4
00:00:13,580 --> 00:00:16,540
ನ ಹೇಗೆ ಸಂಚರಿಸಲು ಅವಕಾಶ
ಮಾರಿಯೋ ಕಾರ್ಯಗತಗೊಳಿಸಲು.

5
00:00:16,540 --> 00:00:21,040
ನಾವು ಮಾಡಬೇಕಾದ್ದು ಮೊದಲ ವಿಷಯ
ಇನ್ಪುಟ್ ಬಳಕೆದಾರ ಸೂಚಿಸುತ್ತದೆ.

6
00:00:21,040 --> 00:00:24,440
>> ನಾವು ನಿಖರವಾಗಿ ಹೇಗೆ ಹೇಳಿ ಅಗತ್ಯವಿದೆ
ಎತ್ತರದ ಪಿರಮಿಡ್ ಇರಬೇಕು.

7
00:00:24,440 --> 00:00:27,110
ಇಲ್ಲಿ, ನಾವು ಮಾಡುತ್ತಿರುವುದು ನೋಡಿ
ಎತ್ತರ = GetInt.

8
00:00:27,110 --> 00:00:32,479
ಒಂದು ಮತ್ತು ನೆನಪು GetInt ಕಾರ್ಯ
CS50 ರಲ್ಲಿ ಜಾರಿಗೆ

9
00:00:32,479 --> 00:00:38,060
ಗ್ರಂಥಾಲಯದ, ಹೀಗಾಗಿ, ನಾವು ಅಗತ್ಯವಿದೆ
# ಮರೆಯದಿರಿ cs50.h. ಸೇರಿವೆ

10
00:00:38,060 --> 00:00:41,360
>> ಆದ್ದರಿಂದ ನಾವು ಈ ಸುತ್ತಿ ಇಲ್ಲ
ಒಂದು ಮಾಡಬೇಡಿ ಸಮಯದಲ್ಲಿ ಲೂಪ್ ರಲ್ಲಿ?

11
00:00:41,360 --> 00:00:45,080
ಅಲ್ಲದೆ, ನಾವು ನೆನಪಿಡುವ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ
ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ಮಾನ್ಯ ಹೊಂದಿದೆ.

12
00:00:45,080 --> 00:00:46,910
ಅಮಾನ್ಯ ಇನ್ಪುಟ್ ಏನು?

13
00:00:46,910 --> 00:00:51,460
ಅಲ್ಲದೆ pset ವಿಶೇಷ ನಿರ್ದಿಷ್ಟವಾಗಿ ಹೇಳುತ್ತಾರೆ
ಒಂದು ಎತ್ತರ ಕಡಿಮೆ 0 ಅಥವಾ ಹೆಚ್ಚಿನ

14
00:00:51,460 --> 00:00:54,530
23 ಅಮಾನ್ಯವಾಗಿದೆ ಹೆಚ್ಚು.

15
00:00:54,530 --> 00:00:59,030
>> ಆದ್ದರಿಂದ ಇಲ್ಲಿ, ನಾವು ವ್ಯಾಖ್ಯಾನಿಸಲು ಮಾಡುತ್ತಿದ್ದೇವೆ ಎಂದು ನೋಡಿ
ಜೊತೆ MAX_HEIGHT ನಿರಂತರ ಎಂಬ

16
00:00:59,030 --> 00:01:00,750
23 ಮೌಲ್ಯವನ್ನು.

17
00:01:00,750 --> 00:01:06,380
ಈ ಮಾಡಬೇಡಿ ಸಮಯದಲ್ಲಿ ಲೂಪ್ ಮುಂದುವರಿಯುತ್ತದೆ
ಎತ್ತರ ಕಡಿಮೆ 0 ಅಥವಾ MAX_HEIGHT ಆಗಿದೆ

18
00:01:06,380 --> 00:01:11,870
ಅಂದರೆ ಎತ್ತರ, ಕಡಿಮೆ
23 ಎತ್ತರ ಕಡಿಮೆ.

19
00:01:11,870 --> 00:01:15,390
ಎತ್ತರ 24 ಅಥವಾ ಹೆಚ್ಚಿನ ವೇಳೆ ಆದ್ದರಿಂದ, ನಾವು
ಲೂಪಿಂಗ್ ಮುಂದುವರಿಸಲು ಹೋಗುವ.

20
00:01:15,390 --> 00:01:18,300
ನೆನಪಿಡಿ ಹಾಗೆ ಆದರೆ ಕುಣಿಕೆಗಳು ಸುಂದರಿ
ಉಪಯುಕ್ತ ನಾವು ಪಡೆಯಲು ಬಯಸುವ ಬಂದ

21
00:01:18,300 --> 00:01:22,070
ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ಮತ್ತು ನಂತರ, ಮೌಲ್ಯೀಕರಿಸಲು
ನಾವು ಅನಿವಾರ್ಯವಾಗಿ ಬಳಕೆದಾರ ಕೇಳಲು ಅಗತ್ಯವಿದೆ

22
00:01:22,070 --> 00:01:25,010
ಒಮ್ಮೆಯಾದರೂ ಅವರು ಬಯಸುವ ಮೌಲ್ಯಕ್ಕೆ.

23
00:01:25,010 --> 00:01:28,500
>> ಹಾಗೆ ಒಮ್ಮೆ ನಾವು ಅವರ ಇನ್ಪುಟ್, ನಾವು
ಈಗ ಪಿರಮಿಡ್ ರಚಿಸಬಹುದು.

24
00:01:28,500 --> 00:01:31,940
ಈ ಸಮಸ್ಯೆಯನ್ನು ಸೆಟ್ ತಂತ್ರಗಳನ್ನು ಒಂದಾಗಿದೆ
ನಾವು ಮೇಲಿರುವ ಪ್ರಾರಂಭಿಸಬೇಕು ಎಂದು

25
00:01:31,940 --> 00:01:32,750
ಪಿರಮಿಡ್.

26
00:01:32,750 --> 00:01:36,800
ನೀವು ಕೆಳಗೆ printf ಸಾಧ್ಯವಿಲ್ಲ
ಪಿರಮಿಡ್ ಮತ್ತು ನಂತರ ಅಪ್ ನಿಮ್ಮ ರೀತಿಯಲ್ಲಿ ನಿರ್ಮಿಸಲು.

27
00:01:36,800 --> 00:01:38,830
ಆದ್ದರಿಂದ ಅವರ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ
pset ವಿಶೇಷ ನಿಂದ.

28
00:01:38,830 --> 00:01:41,530

29
00:01:41,530 --> 00:01:45,430
>> ನಾವು ಇಲ್ಲಿ ನೋಡಿ ನಾವು ಎತ್ತರ ನಮೂದಿಸಿ
8, ಅತ್ಯಂತ ಕೆಳಭಾಗದಲ್ಲಿ

30
00:01:45,430 --> 00:01:48,660
ಪಿರಮಿಡ್ ಒಂಬತ್ತು ಹ್ಯಾಷೆಸ್ ಮುದ್ರಿಸುತ್ತದೆ.

31
00:01:48,660 --> 00:01:52,990
ಎಂದು ಒಂದು ಮಟ್ಟದ ಅಪ್ ಮುದ್ರಿತ
ಒಂದು ಬಾಹ್ಯಾಕಾಶ ಮತ್ತು ಎಂಟು ಹ್ಯಾಷೆಸ್.

32
00:01:52,990 --> 00:01:58,250
ಎಂದು ಒಂದು ಮಟ್ಟದ ಎರಡು ಜಾಗಗಳು ಮತ್ತು
ಏಳು ಹ್ಯಾಷೆಸ್, ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ತನಕ ನಾವು

33
00:01:58,250 --> 00:02:03,050
ಇದು ಪಿರಮಿಡ್, ಮೇಲೆ ಪಡೆಯಲು
ಏಳು ಮುದ್ರಿಸುತ್ತದೆ ಅಪ್ ಎಂಟು ಹಂತಗಳಲ್ಲಿ,

34
00:02:03,050 --> 00:02:06,000
ಖಾಲಿ ಮತ್ತು ಎರಡು ಹ್ಯಾಷೆಸ್.

35
00:02:06,000 --> 00:02:08,810
ನಾವು ಎಂದು ನೆನಪಿಡಿ
ಮೊದಲ ಉನ್ನತ ಮಟ್ಟದಲ್ಲಿ ಮಾಡಲು.

36
00:02:08,810 --> 00:02:11,620

37
00:02:11,620 --> 00:02:18,500
>> ಇಲ್ಲಿ ನಾವು iterating ನೀವು
ಉನ್ನತ ಮಟ್ಟದ, ಸತತವಾಗಿ 8, ಮುಂದುವರೆಯುವ

38
00:02:18,500 --> 00:02:22,150
ಸಾಲು 0 ತಲುಪುವವರೆಗೆ.

39
00:02:22,150 --> 00:02:25,820
ಆದ್ದರಿಂದ ಹೇಗೆ ನಾವು ಅನೇಕ ಜಾಗಗಳು ಅಗತ್ಯವಿದೆ ಮಾಡಲಿಲ್ಲ
ಎಂದು ಉನ್ನತ ಸಾಲಾಗಿ ಮುದ್ರಿಸಲು?

40
00:02:25,820 --> 00:02:29,310
ನಾವು ಏಳು ಸ್ಥಳಗಳಲ್ಲಿ ಮುದ್ರಿತ
ಮತ್ತು ಎರಡು ಹ್ಯಾಷೆಸ್.

41
00:02:29,310 --> 00:02:34,450
ನಾವು ಬಯಸುವ ಸ್ಥಳಗಳಲ್ಲಿ ಸಂಖ್ಯೆ
ಮೈನಸ್ 1 ಎಂದು ಸಾಲು.

42
00:02:34,450 --> 00:02:39,310
>> ಮೇಲಿನ ಸಾಲು 8, 8 ಮೈನಸ್ ವೇಳೆ
1 ನಮಗೆ ಏಳು ಸ್ಥಳಗಳಲ್ಲಿ ನೀಡುತ್ತದೆ.

43
00:02:39,310 --> 00:02:43,770
ನಂತರ ನಾವು ಮುದ್ರಿಸಿ ಲೂಪ್ ಹೊಂದಿವೆ
ಒಂದು ಸಮಯದಲ್ಲಿ ಪ್ರತಿ ಜಾಗವನ್ನು ಒಂದು ಔಟ್.

44
00:02:43,770 --> 00:02:47,450
ಆದ್ದರಿಂದ ಖಾಲಿ ಈ ಲೂಪ್, 7
ಏಳು ಬಾರಿ, ಮುದ್ರಣ

45
00:02:47,450 --> 00:02:50,300
ಏಳು ಪ್ರತ್ಯೇಕ ಸ್ಥಳಗಳಲ್ಲಿ.

46
00:02:50,300 --> 00:02:54,672
>> ಈಗ ನಾವು ಈ ಹ್ಯಾಷೆಸ್ ಮುದ್ರಿಸಲು ಅಗತ್ಯವಿದೆ
ಪಿರಮಿಡ್ ಕೊನೆಯಲ್ಲಿ.

47
00:02:54,672 --> 00:02:57,930
ಇಲ್ಲಿ, ನಾವು ಲೆಕ್ಕ ಅಗತ್ಯವಿದೆ
ಸಂಖ್ಯೆ ಹ್ಯಾಶ್ಗಳನ್ನು.

48
00:02:57,930 --> 00:03:01,930
ನಾವು ಎತ್ತರ ಮಾಡುತ್ತಿರುವುದು ನೋಡಬಹುದು
ಮೈನಸ್ ಸಾಲು ಜೊತೆಗೆ 2.

49
00:03:01,930 --> 00:03:04,170
ಆದ್ದರಿಂದ ಹೇಗೆ ನಾವು ಬಂದೆವು?

50
00:03:04,170 --> 00:03:08,630
>> ನೆನಪಿಡಿ ಪಿರಮಿಡ್ ಮೇಲೆ
ಸಾಲು 8, ಮತ್ತು ಎತ್ತರ 8.

51
00:03:08,630 --> 00:03:10,890
ಮತ್ತು ನಾವು ಇನ್ನೂ ಎರಡು ಹ್ಯಾಷೆಸ್ ಮುದ್ರಿತ.

52
00:03:10,890 --> 00:03:15,420
ಆದ್ದರಿಂದ ಅತ್ಯಂತ ಕನಿಷ್ಠ 8 ಮೈನಸ್ 8 ಪ್ಲಸ್
2 ನಮಗೆ ಸರಿಯಾದ ಉತ್ತರ ನೀಡುತ್ತದೆ.

53
00:03:15,420 --> 00:03:19,170
ತದನಂತರ ಕೆಳಗೆ ಪರಿಗಣಿಸಲು
ಪಿರಮಿಡ್, 1 ಸಾಲನ್ನು.

54
00:03:19,170 --> 00:03:24,020
ಎತ್ತರ ಮೈನಸ್ ಸಾಲು ನಮಗೆ 7 ನೀಡುತ್ತದೆ,
ನಂತರ ಜೊತೆಗೆ 2 ನಮಗೆ ಒಂಬತ್ತು ಹ್ಯಾಷೆಸ್ ನೀಡುತ್ತದೆ,

55
00:03:24,020 --> 00:03:26,620
ಇದು ನಿಖರವಾಗಿ ಸಂಖ್ಯೆ
ನಾವು ಮುದ್ರಿತ ಹ್ಯಾಷ್ ಸ್.

56
00:03:26,620 --> 00:03:29,880
ಈ ನಾವು ಬಯಸುವ ಸೂತ್ರ
ಸಂಖ್ಯೆ ಲೆಕ್ಕಹಾಕಲು ಬಳಸುವ

57
00:03:29,880 --> 00:03:32,220
ಪ್ರತಿ ಸತತವಾಗಿ ಹ್ಯಾಷ್ ಸ್.

58
00:03:32,220 --> 00:03:36,020
>> ಎಂದು ಬಳಸಿ, ನಾವು ನಂತರ ಮತ್ತೊಂದು ಹೊಂದಿವೆ
ಹೋಲುತ್ತದೆ ಲೂಪ್, ಫಾರ್

59
00:03:36,020 --> 00:03:41,270
ನಾವು ಸ್ಥಳಗಳಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ ಲೂಪ್,
ಎಂದು ಹ್ಯಾಷೆಸ್ ಬಾರಿ iterates ಸಂಖ್ಯೆ

60
00:03:41,270 --> 00:03:43,720
ಒಂದು ಹ್ಯಾಶ್ ಪ್ರತಿ ಬಾರಿ ಮುದ್ರಣ.

61
00:03:43,720 --> 00:03:46,010
ಮೇಲಿನ ಸಾಲಿನಲ್ಲಿ, ಎಂದು ಮಾಡುತ್ತೇವೆ
ಎರಡು ಹ್ಯಾಷೆಸ್ ಮುದ್ರಿಸಲು.

62
00:03:46,010 --> 00:03:48,390
ಕೆಳಗಿನ ಸಾಲು ರಂದು, ಎಂದು ಮಾಡುತ್ತೇವೆ
ಒಂಬತ್ತು ಹ್ಯಾಷೆಸ್ ಮುದ್ರಿಸಲು.

63
00:03:48,390 --> 00:03:52,610
ಪರಸ್ಪರ ಸಾಲು ಪ್ರತಿ ಮುದ್ರಿಸಿ
ನಡುವೆ ಸಂಖ್ಯೆ ಹ್ಯಾಶ್ಗಳನ್ನು.

64
00:03:52,610 --> 00:03:57,340
>> ತದನಂತರ ಅತ್ಯಂತ ಕೊನೆಯಲ್ಲಿ, ನಾವು ಅಗತ್ಯವಿದೆ
ಮುಂದಿನ ಹೋಗಲು ನಮ್ಮ ಹೊಸ ಲೈನ್ ಮುದ್ರಿಸು

65
00:03:57,340 --> 00:03:59,400
ಪಿರಮಿಡ್ ಸಾಲು.

66
00:03:59,400 --> 00:04:03,070
ಅಂತಿಮವಾಗಿ, ನಾವು ಹೊಸ ಲೈನ್ ಮುದ್ರಿಸಲು ಅಗತ್ಯವಿದೆ
ಸಾಲಿನ ಕೊನೆಗೆ ಸಲುವಾಗಿ ನಲ್ಲಿ

67
00:04:03,070 --> 00:04:06,260
ಮುಂದಿನ ಮುಂದುವರಿಯುತ್ತದೆ
ಪಿರಮಿಡ್ ಸಾಲು.

68
00:04:06,260 --> 00:04:08,980
ಮತ್ತು ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಕೊನೆಯಲ್ಲಿ,
ನಾವು ಮರಳಿ 0 ಹೊಂದಿರುತ್ತವೆ.

69
00:04:08,980 --> 00:04:12,770
>> Pset ವಿಶೇಷ, ರಿಟರ್ನ್ ಪ್ರಕಾರ
0 ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಅನಿವಾರ್ಯವಲ್ಲ.

70
00:04:12,770 --> 00:04:15,710
ಆದರೆ ಇದು ಮುಖ್ಯ ಮಾಡಲಾಗುತ್ತದೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ.

71
00:04:15,710 --> 00:04:17,610
ನನ್ನ ಹೆಸರನ್ನು ರಾಬ್, ಮತ್ತು ಈ ಮಾರಿಯೋ ಆಗಿತ್ತು.

72
00:04:17,610 --> 00:04:22,470
>> [ಸಂಗೀತ]

73
00:04:22,470 --> 00:04:25,558