1
00:00:00,000 --> 00:00:00,493

2
00:00:00,493 --> 00:00:09,860
>> [ಸಂಗೀತ]

3
00:00:09,860 --> 00:00:13,520
>> ZAMYLA ಚಾನ್: ನೀವು ಬದಲಿಗೆ ಪಡೆಯುತ್ತಾರೆ
$ 10 ಮಿಲಿಯನ್ ಈಗ ಸರಿ ಅಥವಾ ಸ್ವೀಕರಿಸಲು

4
00:00:13,520 --> 00:00:17,460
ನಾಣ್ಯಗಳು ತಿಂಗಳ ಪ್ರತಿದಿನ, ಅಲ್ಲಿ
ಪ್ರತಿ ನಂತರದ ದಿನ, ನೀವು ಸ್ವೀಕರಿಸುವ

5
00:00:17,460 --> 00:00:21,280
ನೀವು ನಾಣ್ಯಗಳು ಪ್ರಮಾಣವನ್ನು ಡಬಲ್
ಮೊದಲು ದಿನ ಪಡೆಯಿತು?

6
00:00:21,280 --> 00:00:24,010
ನಾಣ್ಯಗಳು, ನಾವು ಹೊರಟಿರುವೆ
ಸಾಬೀತು ಏಕೆ ನೀವು ಮಾಡಬೇಕು

7
00:00:24,010 --> 00:00:27,000
ಖಂಡಿತವಾಗಿ ನಾಣ್ಯಗಳು ತೆಗೆದುಕೊಳ್ಳಬಹುದು.

8
00:00:27,000 --> 00:00:29,130
- Pennies.c-ನಿಮ್ಮ ಕೆಲಸ ಬರೆಯಲು ಆಗಿದೆ

9
00:00:29,130 --> 00:00:33,330
ಮೊದಲ ಹೇಗೆ ಬಳಕೆದಾರ ಕೇಳುವ ಒಂದು ಪ್ರೋಗ್ರಾಂ
ಹಲವಾರು ದಿನಗಳ ತಿಂಗಳಲ್ಲಿ ಮತ್ತು

10
00:00:33,330 --> 00:00:38,780
ನಂತರ ಬಳಕೆದಾರರು ಎಷ್ಟು ನಾಣ್ಯಗಳು ಕೇಳುತ್ತದೆ
ಮೊದಲ ದಿನ ಸ್ವೀಕರಿಸುತ್ತೀರಿ.

11
00:00:38,780 --> 00:00:41,780
ಪ್ರೋಗ್ರಾಂ ನಂತರ ಲೆಕ್ಕ ಮಾಡಬೇಕು
ಬಳಕೆದಾರ ಬರುವುದು ಪ್ರಮಾಣವನ್ನು

12
00:00:41,780 --> 00:00:46,530
ಕೊನೆಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಿದೆ
ತಿಂಗಳ ಮತ್ತು ಅದನ್ನು ಪ್ರದರ್ಶಿಸಲು.

13
00:00:46,530 --> 00:00:49,670
>> ಈ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಉರುಳಿಸುತ್ತದೆ
ಕೆಲಸಗಳನ್ನು ಒಂದೆರಡು ಒಳಗೆ.

14
00:00:49,670 --> 00:00:52,830
ನಾವು ಕೇಳುತ್ತದೆ ಅಗತ್ಯವಿದೆ
ಬಹು ಬಳಕೆದಾರ ಒಳಹರಿವು -

15
00:00:52,830 --> 00:00:55,510
ದಿನಗಳ ಮತ್ತು ತಿಂಗಳ, ಮತ್ತು ನಾಣ್ಯಗಳು
ಮೊದಲ ದಿನ.

16
00:00:55,510 --> 00:00:59,390
ನಾವು ಕಾಪಾಡುವುದು ಎಷ್ಟು ಹಣ
ಬಳಕೆದಾರ ಪ್ರತಿ ಹೊಂದಿದೆ ಮತ್ತು ಇದು ನವೀಕರಿಸಿ

17
00:00:59,390 --> 00:01:03,060
ದಿನ, ಪ್ರಮಾಣದ ಡಬಲ್
ಅವರು ಸ್ವೀಕರಿಸುವ ನಾಣ್ಯಗಳು.

18
00:01:03,060 --> 00:01:06,710
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಾವು ಮುದ್ರಿಸಲು ತಮ್ಮ
ಡಾಲರ್ ಅಂತಿಮ ಒಟ್ಟು.

19
00:01:06,710 --> 00:01:08,570
>> ಮೊದಲ ಟ್ಯಾಕ್ಲ್ ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ನೋಡೋಣ.

20
00:01:08,570 --> 00:01:11,560
ನಾನು, apples.c ತೆರೆಯುತ್ತದೆ ಹೋಗುವ ಬಾಗುತ್ತೇನೆ
ವ್ಯವಹರಿಸುತ್ತದೆ ಎಂದು ಕಿರು ಪ್ರೋಗ್ರಾಂ

21
00:01:11,560 --> 00:01:13,840
ಆದಾನಗಳು ಮತ್ತು.

22
00:01:13,840 --> 00:01:17,310
ಇಲ್ಲಿ ಮೇಲ್ಭಾಗದಲ್ಲಿ, ನಾನು ಕೆಲವು ಒಳಗೊಂಡಿತ್ತು ಬಂದಿದೆ
- ನಾನು ಅಗತ್ಯವಿರುವ ಗ್ರಂಥಾಲಯಗಳನ್ನು

23
00:01:17,310 --> 00:01:20,450
CS50 ತಂದೆಯ ಗ್ರಂಥಾಲಯದ ಪ್ರಮಾಣಿತ
I / O lib.

24
00:01:20,450 --> 00:01:24,310
ನಾನು ಬಳಸಿಕೊಂಡು ಒಂದು ಪ್ರಾಂಪ್ಟ್ ಮುದ್ರಿಸಿ
ರಿಂದ printf ಕ್ರಿಯೆ

25
00:01:24,310 --> 00:01:25,660
ಸ್ಟ್ಯಾಂಡರ್ಡ್ I / O lib.

26
00:01:25,660 --> 00:01:29,740
ಆದರೆ ಬಳಕೆದಾರನ ಪ್ರೇರೇಪಿಸಿತು ನಿಜವಾದ
ಈ ಮುಂದಿನ ಸಾಲಿನಲ್ಲಿ ನಡೆಯುವ

27
00:01:29,740 --> 00:01:33,650
CS50 ಗ್ರಂಥಾಲಯದಲ್ಲಿ GetInt ಕಾರ್ಯ.

28
00:01:33,650 --> 00:01:38,300
>> GetInt ಬಳಕೆದಾರರಿಂದ ಇನ್ಪುಟ್ ಮತ್ತು ಪಡೆದುಕೊಳ್ಳುವ
ಇನ್ಪುಟ್ ಒಂದು ಪೂರ್ಣಾಂಕ ಖಾತ್ರಿಗೊಳಿಸುತ್ತದೆ.

29
00:01:38,300 --> 00:01:45,160
ಆದ್ದರಿಂದ ನಾನು ಪೂರ್ಣಾಂಕ ಒಳಗೆ ಬಳಕೆದಾರರ ಇನ್ಪುಟ್ ಶೇಖರಿಸಿಡಲು
ನಾನು ರಿಂದ 1 ಕಳೆಯಿರಿ, ತದನಂತರ

30
00:01:45,160 --> 00:01:47,610
ನಾನು ಒಂದು ವೇಳೆ ಹೊಸ ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.

31
00:01:47,610 --> 00:01:53,050
ಬಳಸಿ apples.c ಸಂಗ್ರಹಿಸಿದ ನಂತರ
ಆಜ್ಞೆಯು "ಸೇಬುಗಳು ಮಾಡಲು," ನಾನು ಒಂದು ಹೊಂದಿವೆ

32
00:01:53,050 --> 00:01:55,770
ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಫೈಲ್ ಸೇಬುಗಳು.

33
00:01:55,770 --> 00:01:58,760
ನಾನು ಇನ್ಪುಟ್ 1, ಎಂದು ಮಾಡುತ್ತೇವೆ ರನ್ನಿಂಗ್.

34
00:01:58,760 --> 00:02:02,600
ಪ್ರೋಗ್ರಾಂ ನನಗೆ ಹೇಳುತ್ತದೆ ಎಂದು
ನಾನು ಬಿಟ್ಟು 0 ಸೇಬುಗಳು ಹೊಂದಿರುತ್ತವೆ.

35
00:02:02,600 --> 00:02:05,480
ಮತ್ತು ಆದ್ದರಿಂದ ನಿರೀಕ್ಷಿಸಿದಂತೆ ಕೆಲಸ ಎಂದು.

36
00:02:05,480 --> 00:02:09,740
>> ಆದ್ದರಿಂದ ತಂದೆಯ ಮತ್ತೆ ಈ ಔಟ್ ಅವಕಾಶ
ಋಣಾತ್ಮಕ ಮತ್ತು ಇನ್ಪುಟ್ 1.

37
00:02:09,740 --> 00:02:13,950
ಈಗ, ಸೇಬುಗಳು ಒಂದು ಋಣಾತ್ಮಕ ಪ್ರಮಾಣವನ್ನು ಹೊಂದಿರುವ
ನಿಜವಾಗಿಯೂ ಅರ್ಥದಲ್ಲಿ ಮಾಡಲು, ಆದರೆ

38
00:02:13,950 --> 00:02:18,370
ಋಣಾತ್ಮಕ ಏಕೆಂದರೆ ಪ್ರೋಗ್ರಾಂ, ಇದು ಸ್ವೀಕರಿಸುತ್ತದೆ
1, ಹಾಗೆಯೇ, ಇದು ಒಂದು ಪೂರ್ಣಾಂಕ.

39
00:02:18,370 --> 00:02:22,740
ಮತ್ತು ಈಗ ಪ್ರೊಗ್ರಾಮ್ ಅಥವಾ ದೈತ್ಯ
ಪ್ರೋಗ್ರಾಂ ಒಂದು ಋಣಾತ್ಮಕ ತಿಂದು ಒಳಗೆ

40
00:02:22,740 --> 00:02:26,250
ಸೇಬು, ಮತ್ತು ಈಗ ನಾನು
ಋಣಾತ್ಮಕ 2 ಸೇಬುಗಳು.

41
00:02:26,250 --> 00:02:28,610
ಎಚ್ಎಂ, ಆದ್ದರಿಂದ ಒಂದು ಪಾಠ ಇಲ್ಲಿದೆ -

42
00:02:28,610 --> 00:02:32,965
ಸಹ GetInt ಕಾರ್ಯ ಮತ್ತು
ಸಂಬಂಧಿತ GetFlow ರೀತಿಯ ಕಾರ್ಯಗಳನ್ನು, ಅಥವಾ

43
00:02:32,965 --> 00:02:38,100
ಪಡೆಯಲು ಬಲ ದಶಮಾಂಶ ಕೌಟುಂಬಿಕತೆ GetString, ನೀವು
ಇನ್ಪುಟ್ ಮಾಡುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಮಾಡಬೇಕು

44
00:02:38,100 --> 00:02:41,430
ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮಕ್ಕಾಗಿ ಅರ್ಥದಲ್ಲಿ.

45
00:02:41,430 --> 00:02:45,500
>> ನಾಣ್ಯಗಳು, ಇದನ್ನು ಕೇವಲ ಒಂದು ಪ್ರಾಂಪ್ಟ್ ಮಾಡಲು ಆಗುವುದಿಲ್ಲ
ಒಂದು ಪೂರ್ಣಾಂಕ, ನೀವು ಮಾಡುವ ಅಗತ್ಯವಿದೆ

46
00:02:45,500 --> 00:02:49,550
ಖಚಿತವಾಗಿ ಬಳಕೆದಾರ ಒಳಹರಿವು ಒಂದು ಪೂರ್ಣಾಂಕ ಎಂದು
ಆ ಸಂದರ್ಭದಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಅರ್ಥದಲ್ಲಿ ಮಾಡಲು.

47
00:02:49,550 --> 00:02:55,690
ತಿಂಗಳು ಮಾತ್ರ, 28 ಹೊಂದಬಹುದು
29, 30, ಅಥವಾ 31 ದಿನಗಳ.

48
00:02:55,690 --> 00:02:59,160
ನಾವು ನಿರಂತರವಾಗಿ ಬೇಡಿಕೆ ಬಯಸುವ
ಮಾನ್ಯ ಪೂರ್ಣಾಂಕ.

49
00:02:59,160 --> 00:03:03,240
ಅವರು ಇನ್ಪುಟ್ ನಮ್ಮ ಒಂದು ಪೂರ್ಣಾಂಕ ಹೊರಗೆ ವೇಳೆ
ಒಪ್ಪಿತ ಎಲ್ಲೆಯಿಲ್ಲ, ನಾವು ಅವುಗಳನ್ನು ಪ್ರಾಂಪ್ಟ್ ಮಾಡುತ್ತೇವೆ

50
00:03:03,240 --> 00:03:07,190
ಮತ್ತೆ ಮತ್ತೆ ರವರೆಗೆ ನೀವು
ನಮಗೆ ಮಾನ್ಯ ಪೂರ್ಣಾಂಕ ನೀಡಲು.

51
00:03:07,190 --> 00:03:10,070
>> "ರವರೆಗೆ ಮತ್ತೆ" ನೆನಪಿರಲಿ
ಸ್ಕ್ರ್ಯಾಚ್ ರಲ್ಲಿ ನಿರ್ಬಂಧಿಸಲು?

52
00:03:10,070 --> 00:03:13,070
ನೀವು ಇದೇ ರಚನೆ ಮಾಡಬಹುದು
ಸಿ ಒಂದು "ಅದೇ" ಲೂಪ್ ಬಳಸಿ

53
00:03:13,070 --> 00:03:14,830
ಅಥವಾ "ಆದರ್ಶವಾದಿ ಮಾಡುವಾಗ" ಲೂಪ್.

54
00:03:14,830 --> 00:03:18,280
ಅದೇ ಲೂಪ್ ರಚನೆ ಸ್ಥಿತಿಯನ್ನು ಹೊಂದಿದೆ
ಪೂರೈಸಬೇಕು ಎಂದು

55
00:03:18,280 --> 00:03:20,160
ಕಾರ್ಯಗತಗೊಳಿಸಲು ಲೂಪ್ ದೇಹದ.

56
00:03:20,160 --> 00:03:23,080
>> ಇದು ಸ್ವಲ್ಪ ಇದೇ ತೋರಬೇಕು
ಪರಿಸ್ಥಿತಿ ಕೇವಲ ರೀತಿಯ ಏಕೆಂದರೆ

57
00:03:23,080 --> 00:03:25,970
ಕೋನಗಳನ್ನು ಹೊಂದಿರುವ ಸ್ಕ್ರ್ಯಾಚ್ ಬ್ಲಾಕ್ಗಳನ್ನು
ಮತ್ತು ಆವರಣ ಹೋಗುತ್ತಿದೆ

58
00:03:25,970 --> 00:03:27,950
"ಅದೇ" ಕುಣಿಕೆಯಿಂದ.

59
00:03:27,950 --> 00:03:30,600
ಆದ್ದರಿಂದ ಷರತ್ತಿನ ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ
ಪೂರ್ಣಾಂಕ ವ್ಯಾಪ್ತಿಯಲ್ಲಿದ್ದು

60
00:03:30,600 --> 00:03:32,680
ಸೂಕ್ತ ಎಲ್ಲೆಯಿಲ್ಲ.

61
00:03:32,680 --> 00:03:36,620
ನೀವು ಪೂರ್ಣಾಂಕ ಬಳಸಿಕೊಂಡು GetInt ಸೂಚಿಸಬಹುದು
ತದನಂತರ ನಿಮ್ಮ "ಅದೇ" ಕಾರ್ಯರೂಪಕ್ಕೆ

62
00:03:36,620 --> 00:03:41,030
ಲೂಪ್, ಪುನರಾವರ್ತಿತ ಪ್ರಾಂಪ್ಟ್ ಮತ್ತು ಮುದ್ರಣ
ಸೂಚನೆಗಳನ್ನು, ಆದರೆ ಇನ್ಪುಟ್

63
00:03:41,030 --> 00:03:43,470
ಮಾನ್ಯವಾಗಿಲ್ಲ.

64
00:03:43,470 --> 00:03:47,610
>> ಸರಿಯಾದ ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಇನ್ನೊಂದು ರೀತಿಯಲ್ಲಿ
, ಒಂದು "ಆದರ್ಶವಾದಿ ಮಾಡುವಾಗ" ಲೂಪ್ ಬಳಸುವುದು

65
00:03:47,610 --> 00:03:50,400
ಇದು ಸ್ವಲ್ಪ ಲೂಪ್ ಹೋಲುತ್ತದೆ.

66
00:03:50,400 --> 00:03:54,950
"ಆದರ್ಶವಾದಿ ಮಾಡುವಾಗ" ಲೂಪ್ ಕೋಡ್ ಕಾರ್ಯಗತಗೊಳಿಸಿ
ದೇಹದ ಪದಗಳಿಗಿಂತ ಮತ್ತು ನಂತರ ತಪಾಸಣೆ ಒಳಗೆ

67
00:03:54,950 --> 00:03:57,150
ಸ್ಥಿತಿಯನ್ನು ಭೇಟಿ ಬಿಡಲಿ.

68
00:03:57,150 --> 00:04:00,590
ಇದು ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ಪಡೆಯಲು ಉಪಯುಕ್ತವಾಗಿದೆ
ನೀವು ನೀವು ತಿಳಿದಿರುವ ಕಾರಣ

69
00:04:00,590 --> 00:04:02,980
ಒಮ್ಮೆಯಾದರೂ ಅವರನ್ನು ಪ್ರಾಂಪ್ಟ್ ಮಾಡಲು.

70
00:04:02,980 --> 00:04:07,200
ಸ್ಥಿತಿಯನ್ನು ಭೇಟಿ ಹೋದರೆ, ಪ್ರೋಗ್ರಾಂ
ನಂತರ ಸಾಲು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಮಾಡುತ್ತದೆ

71
00:04:07,200 --> 00:04:08,530
ನಿಮ್ಮ "ಆದರ್ಶವಾದಿ ಮಾಡುವಾಗ" ಲೂಪ್.

72
00:04:08,530 --> 00:04:13,230
ಪರಿಸ್ಥಿತಿ ಕೂಡ ಭೇಟಿ ಮಾಡಿದಲ್ಲಿ,
ಲೂಪ್ ಪುನರಾವರ್ತಿಸುತ್ತೀರಿ

73
00:04:13,230 --> 00:04:17,490
>> ಬಳಕೆದಾರ ಊರ್ಜಿತಗೊಳಿಸಿ ಒಂದು "ಆದರ್ಶವಾದಿ ಮಾಡುವಾಗ" ಲೂಪ್
ಇನ್ಪುಟ್ ಈ ರೀತಿಯ ಕಾಣುತ್ತವೆ.

74
00:04:17,490 --> 00:04:24,530
ನಾನು ವೇರಿಯಬಲ್ N, GetInt ಘೋಷಿಸಲು ಮತ್ತು
N ಮಾನ್ಯ ತನಕ ನಂತರ ಪುನರಾವರ್ತಿಸಿ.

75
00:04:24,530 --> 00:04:28,040
ಮತ್ತು ಈ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ, ನಾನು ವಿವರಿಸಿದರು, ಬಳಸಿದ್ದು
ಪೂರ್ಣಾಂಕ-ದಶಮಾಂಶ ಮಾದರಿ, ಇದು

76
00:04:28,040 --> 00:04:29,820
ನೀವು ತಿಂಗಳ ದಿನಗಳ ಬಳಸಿ.

77
00:04:29,820 --> 00:04:33,560
ಆದರೆ ನಾವು ತಿಳಿದಿರುವ ನಾಣ್ಯಗಳು ಸಂಖ್ಯೆ
ಸಲುವಾಗಿ ಆದ್ದರಿಂದ, ಚುರುಕಾಗಿ ಪೈಲ್ ಕಾಣಿಸುತ್ತದೆ

78
00:04:33,560 --> 00:04:39,160
ದೊಡ್ಡ ಸಂಖ್ಯೆಯ ಸಂಗ್ರಹಿಸಲು, ದಶಮಾಂಶ ಮಾದರಿ ಬಳಸಿ
LongLong, ಆದರೆ ಅದೇ ಮರೆಯದಿರಿ

79
00:04:39,160 --> 00:04:42,590
ಕ್ರಮಬದ್ಧಗೊಳಿಸುವಿಕೆ ತತ್ವ ಅನ್ವಯಿಸುತ್ತದೆ.

80
00:04:42,590 --> 00:04:47,070
>> ನಾಡಿದು, ಆದ್ದರಿಂದ ಒಮ್ಮೆ ನಾವು ಎರಡು ಮಾನ್ಯವಾದ ಹೊಂದಿವೆ
ಬಳಕೆದಾರರಿಂದ ಒಳಹರಿವು -

81
00:04:47,070 --> 00:04:49,530
ತಿಂಗಳಲ್ಲಿ ದಿನಗಳ ಮತ್ತು ನಾಣ್ಯಗಳು
ಮೊದಲ ದಿನ -

82
00:04:49,530 --> 00:04:52,870
ನಾವು ಮುಂದಿನ ಮೇಲೆ ಚಲಿಸಬಹುದು
ಕಾರ್ಯಕ್ರಮದ ಭಾಗವಾಗಿ.

83
00:04:52,870 --> 00:04:56,680
ಮೊದಲ ದಿನ, ಬಳಕೆದಾರ ಆರಂಭವಾಗುತ್ತದೆ
ಅವರು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಆದಾಗ್ಯೂ ಅನೇಕ ನಾಣ್ಯಗಳು

84
00:04:56,680 --> 00:05:00,370
ಮತ್ತು ನಾಣ್ಯಗಳು ಪ್ರಮಾಣವನ್ನು ಎಂದು ಅವರು
ಮರುದಿನ ಸ್ವೀಕರಿಸಲು ಎರಡರಷ್ಟಿರುತ್ತದೆ.

85
00:05:00,370 --> 00:05:03,130
ಆದ್ದರಿಂದ ಇದು ಕಾಪಾಡುವುದು ಸಮಂಜಸವೇ
ಈ ಎರಡು ಪ್ರಮಾಣದ -

86
00:05:03,130 --> 00:05:08,890
ಬಳಕೆದಾರ ಮತ್ತು ಹೇಗೆ ಎಷ್ಟು ಹಣ
ಅನೇಕ ನಾಣ್ಯಗಳು ಅವರು ನೀಡಲಾಗುವುದು ಮಾಡುತ್ತೇವೆ.

87
00:05:08,890 --> 00:05:13,760
>> ಈಗ, 28 31 ದಿನಗಳ ಏನನ್ನಾದರೂ ಮಾಡುವ
ಪುನರಾವರ್ತಿತ, ಆದ್ದರಿಂದ ತಂದೆಯ ಒಂದು "ಫಾರ್" ಬಳಸಲು ಅವಕಾಶ

88
00:05:13,760 --> 00:05:18,220
ದಿನಗಳಲ್ಲಿ ಪ್ರತಿ ತಿರುಗಿ ಗೆ ಲೂಪ್
ತಿಂಗಳು, ಒಟ್ಟು ಮತ್ತು ಪೆನ್ನಿ ಅಪ್ಡೇಟ್

89
00:05:18,220 --> 00:05:21,010
ಪ್ರತಿ ಬಾರಿ ಮೊತ್ತ.

90
00:05:21,010 --> 00:05:23,550
ಲೂಪ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಹೊಂದಿದೆ "ಫಾರ್"
ಕೆಳಗಿನ -

91
00:05:23,550 --> 00:05:27,510
ಪ್ರಾಥಮಿಕ, ಸ್ಥಿತಿಯಾಗಿದೆ
ಮತ್ತು ಒಂದು ಅಪ್ಡೇಟ್.

92
00:05:27,510 --> 00:05:29,590
ನಿಮ್ಮ "ಫಾರ್" ಲೂಪ್ ಆರಂಭಿಸಲು ಕಾಣಿಸುತ್ತದೆ
ಒಂದು ವೇರಿಯೇಬಲ್, ಅದು

93
00:05:29,590 --> 00:05:31,380
ಮೊದಲ ಲೂಪ್ ಪ್ರವೇಶಿಸಿತು.

94
00:05:31,380 --> 00:05:34,860
ಸ್ಥಿತಿಯನ್ನು ಭೇಟಿ ಮಾಡಿದಲ್ಲಿ, ದೇಹದ
ಕುಣಿಕೆ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಮಾಡುತ್ತದೆ.

95
00:05:34,860 --> 00:05:36,860
ನಂತರ, ಅಪ್ಡೇಟ್ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಮಾಡುತ್ತದೆ.

96
00:05:36,860 --> 00:05:40,900
ಪರಿಸ್ಥಿತಿ ಇನ್ನೂ ಭೇಟಿ ಮಾಡಿದಲ್ಲಿ,
ಲೂಪ್ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಮತ್ತು ನವೀಕರಿಸಿ, ಮತ್ತು

97
00:05:40,900 --> 00:05:45,820
ಅಲ್ಲಿಯವರೆಗೆ ನಿಮ್ಮ ಸ್ಥಿತಿಯಂತೆ, ಪುನರಾವರ್ತಿಸಲು
ನಿಜವೆಂದು ಮಾಪನ.

98
00:05:45,820 --> 00:05:51,080
>> ಇಲ್ಲಿ ಒಂದು ವಿಭಜಿಸುವ "ಫಾರ್" ಲೂಪ್ ಇಲ್ಲಿದೆ
2 10 ಬಾರಿ ಮೂಲಕ ಪೂರ್ಣಸಂಖ್ಯೆ p.

99
00:05:51,080 --> 00:05:55,380
ನಾನು ಪೂರ್ಣಸಂಖ್ಯೆ p ಡಿಕ್ಲೇರ್ಡ್ ಹೇಗೆ ಗಮನಿಸಿ
ನನ್ನ "ಫಾರ್" ಲೂಪ್ ಹೊರಗೆ, ಆದ್ದರಿಂದ

100
00:05:55,380 --> 00:05:59,850
ಪೂರ್ಣಾಂಕ ಸುಲಭವಾಗಿ ಮಾಡಬಹುದು
"ಫಾರ್" ಲೂಪ್ ಹೊರಗೆ.

101
00:05:59,850 --> 00:06:03,620
ತಿಂಗಳ ಜಾರಿಗೆ ನಂತರ, ಇದು ಸಮಯ
ಬಳಕೆದಾರ ಹೇಳಲು ಎಷ್ಟು ಹಣ

102
00:06:03,620 --> 00:06:04,790
ಅವರು ಪಡೆದ ಬಂದಿದೆ.

103
00:06:04,790 --> 00:06:08,740
ವಿಶೇಷ ಪ್ರತಿ, ನೀವು ಬಳಕೆದಾರ ಹೇಳಲು ಅಗತ್ಯವಿದೆ
ಎಷ್ಟು ಡಾಲರ್, ಆದರೆ ಎಷ್ಟು

104
00:06:08,740 --> 00:06:10,780
ನಾಣ್ಯಗಳು, ಅವರು.

105
00:06:10,780 --> 00:06:14,620
ಆದರೆ ಇಲ್ಲಿಯವರೆಗೆ, ನೀವು ಜಾಡು ಇಟ್ಟುಕೊಂಡು ಬಂದಿದೆ
ಒಟ್ಟು ಮತ್ತು LongLongs ಬಳಸಿಕೊಂಡು ನಾಣ್ಯಗಳು,

106
00:06:14,620 --> 00:06:16,640
ಪೂರ್ಣಾಂಕಗಳ ಇವು.

107
00:06:16,640 --> 00:06:20,560
>> $ 1 ಗೆ 100 ನಾಣ್ಯಗಳು ಆದ್ದರಿಂದ, ಇವೆ ಹೊರತು
ನಾಣ್ಯಗಳು ಸಂಖ್ಯೆ ಒಂದು

108
00:06:20,560 --> 00:06:24,860
100 ಅನೇಕ, ನೀವು ಮಾಡಬೇಕಾಗುತ್ತದೆ
ಫೆಸಿಲಿಟಿ ಸ್ಥಳಗಳಲ್ಲಿ ಪ್ರತಿನಿಧಿಸುತ್ತವೆ.

109
00:06:24,860 --> 00:06:28,060
ದುಪ್ಪಟ್ಟು ಪಡಿಯಚ್ಚು ಅನುಮತಿಸುತ್ತದೆ
ನೀವು ಇದನ್ನು ಮಾಡಲು.

110
00:06:28,060 --> 00:06:32,790
ಆದ್ದರಿಂದ ಹೇಗೆ ನಾವು ಪ್ರತಿನಿಧಿಸುವ ಮತಾಂತರ ಇಲ್ಲ
ಡಾಲರ್ ನಾಣ್ಯಗಳು?

111
00:06:32,790 --> 00:06:35,330
>> ತಂದೆಯ ಅವಲೋಕಿಸೋಣ pi.c.

112
00:06:35,330 --> 00:06:41,690
ಈ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಒಂದು LongLong big_pi ಮತ್ತು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ
100,000 ಮೂಲಕ ವಿಭಜಿಸಲ್ಪಡುತ್ತದೆ ಮತ್ತು ಮುದ್ರಿಸುತ್ತದೆ

113
00:06:41,690 --> 00:06:44,270
ಐದು ದಶಮಾಂಶ ಸ್ಥಳಗಳಿಗೆ ಪರಿಣಾಮವಾಗಿ.

114
00:06:44,270 --> 00:06:48,560
ನಾವು ನಾಲ್ಕು ಫೆಸಿಲಿಟಿ ಪ್ರದರ್ಶಿಸಲು ಬಯಸಿದರೆ
ಸ್ಥಳಗಳು, ನಂತರ ನಾವು ಈ ಬದಲಾಯಿಸಲ್ಪಡುತ್ತದೆ

115
00:06:48,560 --> 00:06:49,760
ಇಲ್ಲಿ ಸಂಖ್ಯೆ.

116
00:06:49,760 --> 00:06:58,370
ಆದ್ದರಿಂದ ತಂದೆಯ ಉಳಿಸಲು ಪೈ ಕಂಪೈಲ್, ಮತ್ತು ಅವಕಾಶ
ನಂತರ, ಪರಿಣಾಮವಾಗಿ ನೋಡಿ ನಾವು

117
00:06:58,370 --> 00:07:02,240
3,1415 ನಿರೀಕ್ಷೆ -

118
00:07:02,240 --> 00:07:04,540
ಪೈ ಮೊದಲ ಐದು ಅಂಕೆಗಳು.

119
00:07:04,540 --> 00:07:06,300
>> ಇದು ಕೂಡ ಅಲ್ಲ.

120
00:07:06,300 --> 00:07:07,390
ಮತ್ತು ಏಕೆ?

121
00:07:07,390 --> 00:07:11,920
ವೆಲ್, big_pi, ಒಂದು LongLong ಏಕೆಂದರೆ
ಒಂದು ಪೂರ್ಣಾಂಕವನ್ನು, ಇದು ಇದು ಅಲ್ಲ ತಿನ್ನುವೆ

122
00:07:11,920 --> 00:07:13,740
ದಶಮಾಂಶಗಳು ಜಾಡನ್ನು.

123
00:07:13,740 --> 00:07:16,850
ನಾನು ಅಗತ್ಯ ಬದಲಾವಣೆ
ಮಾಡಲು ವಿಭಾಗದಲ್ಲಿ ಆಗಿದೆ.

124
00:07:16,850 --> 00:07:23,300
ನಾನು ಮೊದಲು ಇಲ್ಲಿ ಎರಡು ಆಯ್ಕೆ ಮಾಡಬೇಕಾಗುತ್ತದೆ
ಡಬಲ್ಸ್ ಇರಿಸಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಿಲ್ಲ ಏಕೆಂದರೆ, ವಿಭಜಿತ

125
00:07:23,300 --> 00:07:25,260
ದಶಮಾಂಶದ ಸ್ಥಳಗಳ ಟ್ರ್ಯಾಕ್.

126
00:07:25,260 --> 00:07:28,080
ಮತ್ತು ನಾನು ಒಂದು ಹೊಸ ಸಾಲನ್ನು ಸೇರಿಸಿ ಹೋಗುವ ಬಾಗುತ್ತೇನೆ
ಇಲ್ಲಿ ಉತ್ತಮ ಸ್ವರೂಪಗೊಳಿಸುವುದಕ್ಕಾಗಿ.

127
00:07:28,080 --> 00:07:33,090

128
00:07:33,090 --> 00:07:34,230
>> ಮತ್ತು ಇಲ್ಲಿ ನಾವು ಹೊಂದಿವೆ -

129
00:07:34,230 --> 00:07:37,660
3,1416.

130
00:07:37,660 --> 00:07:43,520
ನೀವು ಇದು 3.1416 ಮುದ್ರಿಸುತ್ತದೆ ಗಮನಿಸಬಹುದು
ಬದಲಿಗೆ 3,1415 ರಂತೆ ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ.

131
00:07:43,520 --> 00:07:47,550
ಸಮಯದಲ್ಲಿ ಏಕೆಂದರೆ ಇದು ಸುತ್ತುಗಳ ಇಲ್ಲಿದೆ
ವಿಭಾಗ ಪ್ರಕ್ರಿಯೆ, ಎಂದು ಕೇವಲ ವಿರುದ್ಧವಾಗಿ

132
00:07:47,550 --> 00:07:50,490
ಮೌಲ್ಯ ಕತ್ತರಿಸಲಾಗುತ್ತಿದೆ.

133
00:07:50,490 --> 00:07:53,710
ಈಗ ನೀವು ಮುದ್ರಿಸಬೇಕೆಂದು ಮಾಡುವಂತಿರಬೇಕು
ಮುಗಿಸಿದ ಇದು ಸರಿಯಾಗಿ ಅಂತಿಮ ಒಟ್ಟು,

134
00:07:53,710 --> 00:07:54,870
ಪ್ರೋಗ್ರಾಂ.

135
00:07:54,870 --> 00:07:55,930
>> ಅಭಿನಂದನೆಗಳು.

136
00:07:55,930 --> 00:07:57,340
ನನ್ನ ಹೆಸರು Zamyla ಆಗಿದೆ.

137
00:07:57,340 --> 00:07:58,720
ಮತ್ತು ಈ ನಾಣ್ಯಗಳು ಆಗಿತ್ತು.

138
00:07:58,720 --> 00:08:05,589
>> [ಸಂಗೀತ]