1
00:00:07,370 --> 00:00:09,760
[Powered by Google Translate] ಟಾಮಿ MACWILLIAM: ಲೂಪ್ ಬಗ್ಗೆ ಲೆಟ್ಸ್ ಟಾಕ್, ಸಾಮಾನ್ಯ ಒಂದು

2
00:00:09,760 --> 00:00:13,380
ಪ್ರೋಗ್ರಾಮಿಂಗ್ ನಾವು CS50 ಉದ್ದಕ್ಕೂ ನೋಡುತ್ತಾರೆ ರಚನೆಗಳು.

3
00:00:13,380 --> 00:00:15,570
ನಾವು ನಿರ್ವಹಿಸಲು ಬಯಸುವ ನಾವು ಕುಣಿಕೆಗಳು ಬಳಸಿ

4
00:00:15,570 --> 00:00:17,200
ಒಂದಕ್ಕಿಂತಲೂ ಕೆಲಸವನ್ನು ಹೆಚ್ಚು.

5
00:00:17,200 --> 00:00:20,700
ಉದಾಹರಣೆಗೆ, ನಾವು "ಹೈ" 100 ಬಾರಿ ಅಥವಾ ಮುದ್ರಣ ಮುದ್ರಿಸಲು ಬಯಸಬಹುದು

6
00:00:20,700 --> 00:00:22,700
ವರ್ಣಮಾಲೆಯ ಎಲ್ಲ ಅಕ್ಷರಗಳು ಔಟ್.

7
00:00:22,700 --> 00:00:26,030
ಈ ಸಂದರ್ಭಗಳಲ್ಲಿ ಎರಡೂ, ನಾವು ಮಾಡಲು ಬಯಸುವ ಒಂದು ವಿಷಯ ಹೊಂದಿವೆ

8
00:00:26,030 --> 00:00:28,700
ಅನೇಕ ಬಾರಿ, ಏನಾದರೂ ಮುದ್ರಿಸುತ್ತದೆ.

9
00:00:28,700 --> 00:00:31,970
ಆದರೆ, ನಾವು ಮುದ್ರಿಸುತ್ತದೆ ಏನು ಪ್ರತಿ ಬಾರಿ ಬದಲಾಗಬಹುದು.

10
00:00:31,970 --> 00:00:34,530
ನಾವು ಪ್ರತಿ ಮೇಲೆ ಸ್ವಲ್ಪಮಟ್ಟಿಗೆ ಬೇರೆ ಮಾಡಬಹುದು

11
00:00:34,530 --> 00:00:37,820
ಪುನರಾವೃತ್ತಿ ಅಥವಾ ಸಂಪರ್ಕದ ಮೂಲಕ ರನ್.

12
00:00:37,820 --> 00:00:41,280
ನಾವು ಆದರೆ, ಸಿ ಕುಣಿಕೆಗಳು ಮೂರು ವಿವಿಧ ನೋಡುತ್ತಾರೆ

13
00:00:41,280 --> 00:00:44,700
ಕುಣಿಕೆಗಳು, ಲೂಪ್, ಮತ್ತು ಲೂಪ್ ಹಾಗೆಯೇ ಮಾಡಬೇಕು.

14
00:00:44,700 --> 00:00:47,850
ಲೂಪ್ ಈ ಮೂರು ರೀತಿಯ ವಿಭಿನ್ನ ವಾಕ್ಯ ಹೊಂದಿದ್ದರೂ,

15
00:00:47,850 --> 00:00:50,630
ಅವುಗಳನ್ನು ಹಿಂದೆ ಕಲ್ಪನೆಗಳು ಒಂದೇ.

16
00:00:50,630 --> 00:00:53,930
ನಾವು, ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ಒಳಗೆ ಕೋಡ್ ಕೆಲವು ಬ್ಲಾಕ್ ವ್ಯಾಖ್ಯಾನಿಸಲು ವಿಲ್

17
00:00:53,930 --> 00:00:57,810
ನಾವು ಕಾರ್ಯಗತ ಬಯಸುವ, ಲೂಪ್ ದೇಹದ ಎಂಬ

18
00:00:57,810 --> 00:00:59,790
ಬಾರಿ ಕೆಲವು ಸಂಖ್ಯೆ.

19
00:00:59,790 --> 00:01:03,370
ದೇಹದ ಬಳಸಲಾಗುತ್ತದೆ ವ್ಯತ್ಯಾಸಗಳ ಮೌಲ್ಯವನ್ನು ಬದಲಿಸುವ ಮೂಲಕ, ನಾವು

20
00:01:03,370 --> 00:01:07,570
ನಮ್ಮ ಲೂಪ್ ಬೇರೆ ಚಾಲನೆ ಪ್ರತಿ ಬಾರಿ ಮಾಡಬಹುದು.

21
00:01:07,570 --> 00:01:10,750
ನಾವು ಬರೆಯಲು ಯಾವುದೇ ಲೂಪ್ ಜೊತೆಗೆ, ನಾವು ನಿರ್ಧರಿಸುವ ಅಗತ್ಯವಿದೆ ಮಾಡಿದಾಗ

22
00:01:10,750 --> 00:01:12,400
ಲೂಪ್ ಚಾಲನೆಯಲ್ಲಿರುವ ನಿಷ್ಕ್ರಿಯಗೊಳ್ಳುತ್ತವೆ.

23
00:01:12,400 --> 00:01:15,650
ನಾವು ಹಾಗೆ ಮಾಡದಿದ್ದರೆ, ನಂತರ ನಮ್ಮ ನಂಬಲರ್ಹ ಕಂಪ್ಯೂಟರ್ ಮುಂದುವರಿಯುತ್ತದೆ

24
00:01:15,650 --> 00:01:19,040
ನಾವು ಪ್ರೋಗ್ರಾಂ ಕೊಲ್ಲಲು ರವರೆಗೆ ಎಂದು ಲೂಪ್ ಚಲಾಯಿಸಲು.

25
00:01:19,040 --> 00:01:22,490
ಸ್ಕ್ರಾಚ್, ನಾವು ಮತ್ತೆ ಮತ್ತೆ N ಬಾರಿ ಬಳಸಬಹುದು

26
00:01:22,490 --> 00:01:24,600
ಲೂಪ್ ರಚಿಸಲು ನಿರ್ಬಂಧಿಸಲು.

27
00:01:24,600 --> 00:01:28,200
ಪುನರಾವರ್ತಿತ 10 ಹೇಳಿದರು ಒಂದು ಬ್ಲಾಕ್ ಒಳಗೆ ಎಲ್ಲಾ ಕಾಯಿಗಳನ್ನು

28
00:01:28,200 --> 00:01:30,130
10 ಬಾರಿ ಔಟ್ ಎಂದು.

29
00:01:30,130 --> 00:01:34,160
ನಂತರ, ನಾವು ಲೂಪ್ ನಂತರ ಕಾಯಿಗಳ ಮೇಲೆ ಸರಿಸಲು ಬಯಸುವ.

30
00:01:34,160 --> 00:01:38,140
ನಮ್ಮ ನಿಲುಗಡೆಯ ಸ್ಥಿತಿಗೆ ಸುಮ್ಮನೆ ಹಾಗೆ, ಈ ಬ್ಲಾಕ್ ಮಾಡಲಾಗಿದೆ

31
00:01:38,140 --> 00:01:39,830
10 ಬಾರಿ ಔಟ್.

32
00:01:39,830 --> 00:01:43,900
ಸ್ಕ್ರಾಚ್ ಪಡಿಸಿಕೊಳ್ಳುವುದು ಸಲುವಾಗಿ ಸಿ ಈ ಪುನಃ ಆದ್ದರಿಂದ ಈಗ

33
00:01:43,900 --> 00:01:46,920
ಪುನರಾವರ್ತಿತ ಬ್ಲಾಕ್ ಒಳಗೆ ತುಣುಕುಗಳನ್ನು ಮರಣದಂಡನೆ ಎಂದು

34
00:01:46,920 --> 00:01:51,180
ಸರಿಯಾಗಿ 10 ಬಾರಿ, ಸ್ಕ್ರ್ಯಾಚ್ ಪ್ರತಿ ಟ್ರ್ಯಾಕ್ ಅಗತ್ಯವಿದೆ

35
00:01:51,180 --> 00:01:53,750
ಪುನರಾವರ್ತಿತ ಬ್ಲಾಕ್ನ ನಿರ್ವಹಣೆ.

36
00:01:53,750 --> 00:01:56,790
ನಮ್ಮ ದೇಹದ ಲೂಪ್ ಎಂದು ಎಷ್ಟು ಬಾರಿ ಕಾಪಾಡುವುದು

37
00:01:56,790 --> 00:02:00,360
ಮರಣದಂಡನೆ, ಐ ಎಂಬ ಮಾರ್ಪಡಿಸಬಹುದಾದ ರಚಿಸಲು ಅವಕಾಶ.

38
00:02:00,360 --> 00:02:03,400
ನಮ್ಮ ಲೂಪ್ ಏಕೆಂದರೆ ಶೂನ್ಯ ನಾನು ಆರಂಭಿಸುತ್ತಾರೆ ವಿಲ್

39
00:02:03,400 --> 00:02:04,650
ಇನ್ನೂ ರನ್ ಇಲ್ಲ.

40
00:02:10,009 --> 00:02:10,949
ಸರಿ

41
00:02:10,949 --> 00:02:15,560
ಈಗ ನಾವು ನಮ್ಮ ಲೂಪ್ ಆಫ್ ಆರಂಭಿಸುವ ಸಂದರ್ಭದಲ್ಲಿ ಕೀವರ್ಡ್ ಬಳಸಿ.

42
00:02:20,100 --> 00:02:24,180
ಈಗ ನಾವು ನಮ್ಮ ಲೂಪ್ ನಿಲ್ಲಿಸಲು ಯಾವಾಗ ವ್ಯಕ್ತಿಯು ಅಗತ್ಯವಿದೆ, ಆದರೆ ನಾವು

43
00:02:24,180 --> 00:02:26,730
ಈಗ ಈ ಬಿಟ್ಟು ನಂತರ ಅದನ್ನು ಮರಳಿ ಬರಲಿ.

44
00:02:30,970 --> 00:02:32,150
ಎಲ್ಲಾ ಸರಿ.

45
00:02:32,150 --> 00:02:35,260
ನಮ್ಮ ಲೂಪ್ ಒಳಗೆ, ಹಾಗೆ ಸುಮ್ಮನೆ ಒಂದು ಸಂದೇಶವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ ಅವಕಾಶ

46
00:02:35,260 --> 00:02:38,535
"ಹೈ." ನಾವು ಈ printf ಕಾರ್ಯವನ್ನು ಉಪಯೋಗಿಸಬಹುದು.

47
00:02:48,400 --> 00:02:49,230
ಎಲ್ಲಾ ಸರಿ.

48
00:02:49,230 --> 00:02:54,210
ಈಗ ನಾವು ಲೂಪ್ ದೇಹದ ಒಂದು ಪುನರಾವರ್ತನೆಯನ್ನು ಹೊಂದಿರುವ ರೆಕಾರ್ಡ್ ಮಾಡುತ್ತೇವೆ

49
00:02:54,210 --> 00:02:55,750
ಗಲ್ಲಿಗೇರಿಸಿದ್ದುದು.

50
00:02:55,750 --> 00:03:00,320
ನಮ್ಮ ಪ್ರತಿ, ಗೆ 1 ಸೇರಿಸುವ, ಅಥವಾ ಏರಿಕೆಯ ಮೂಲಕ ಮಾಡಬಹುದು

51
00:03:00,320 --> 00:03:01,740
ವೇರಿಯಬಲ್, ನಾನು.

52
00:03:01,740 --> 00:03:09,180
ಹಾಗೆ ಮಾಡಲು, ನಾವು ನಾನು + 1, ಅಥವಾ ಹೆಚ್ಚು ಸಮಾನವಾಗಿದೆ ಹೇಳಬಹುದು

53
00:03:09,180 --> 00:03:16,520
ಸರಳವಾಗಿ, ನಾನು ಪ್ಲಸ್ ಪ್ಲಸ್.

54
00:03:16,520 --> 00:03:17,320
ಗ್ರೇಟ್.

55
00:03:17,320 --> 00:03:21,810
ಈಗ ನಾವು, ಪ್ರತಿ ಬಾರಿ ನಮ್ಮ ಲೂಪ್ ರನ್ ಎಂದು ನೋಡಬಹುದು ನಮ್ಮ

56
00:03:21,810 --> 00:03:24,500
ಪ್ರತಿ ವೇರಿಯಬಲ್ ಒಂದು ನಷ್ಟು ಹೋಗುತ್ತದೆ.

57
00:03:24,500 --> 00:03:29,410
ಆದ್ದರಿಂದ ನಾವು ಇಲ್ಲಿಯವರೆಗೆ ಹೊಸದೊಂದು ನಿಖರವಾಗಿ ಎಷ್ಟು ಪುನರಾವರ್ತನೆಗಳು ತಿಳಿದಿದೆ.

58
00:03:29,410 --> 00:03:31,630
ನಂತರ ಲೂಪ್ ಒಂದು ಪುನರಾವೃತ್ತಿ ನಮ್ಮ ಮೌಲ್ಯ

59
00:03:31,630 --> 00:03:34,270
ನ ನಾನು 1 ಆಗಿರುತ್ತದೆ.

60
00:03:34,270 --> 00:03:37,460
ಎರಡು ಪುನರಾವೃತ್ತಿಗಳ ನಂತರ, ನಾನು 2 ಆಗಿರುತ್ತದೆ.

61
00:03:37,460 --> 00:03:42,640
ಮತ್ತು 10 ಪುನರಾವರ್ತನೆಗಳು ನಂತರ, ನಾನು 10 ಆಗಿರುತ್ತದೆ.

62
00:03:42,640 --> 00:03:46,780
ಆದ್ದರಿಂದ, ನಾವು ಈ ಲೂಪ್ ಚಲಾಯಿಸಲು ಬಯಸಿದಲ್ಲಿ ನಿಖರವಾಗಿ 10 ಬಾರಿ, ನಂತರ

63
00:03:46,780 --> 00:03:49,240
ಈ ನಾವು ನಿಲ್ಲಿಸಲು ಬಯಸುವ ಆಗ.

64
00:03:49,240 --> 00:03:53,860
ಆದ್ದರಿಂದ ನಾನು ಕಡಿಮೆ 10 ಹಾಗೆಯೇ ಈ ಲೂಪ್ ಚಲಾಯಿಸಲು ಬಯಸುವ, ಮತ್ತು

65
00:03:53,860 --> 00:03:57,630
ಎಂದು, ನಿಖರವಾಗಿ ನಾವು ಬರೆಯಲು ನೀವು ಯಾವ ವಿಷಯವೆಂದರೆ ನಾನು

66
00:03:57,630 --> 00:04:02,450
ಕಡಿಮೆ 10 ಆಗಿದೆ.

67
00:04:02,450 --> 00:04:06,380
ಈ ಪರಿಸ್ಥಿತಿ ಕೇವಲ ವೇಳೆ ನಾವು ಬಳಸುವ ನಿಯಮಗಳು ತೋರುತ್ತಿದೆ

68
00:04:06,380 --> 00:04:07,830
ಬೇರೆ ಬ್ಲಾಕ್ಗಳನ್ನು.

69
00:04:07,830 --> 00:04:11,690
ನಮ್ಮ ಲೂಪ್ ದೇಹದ ಮರಣದಂಡನೆ ನಂತರ, ನಮ್ಮ ಕಾರ್ಯಕ್ರಮ

70
00:04:11,690 --> 00:04:14,690
ಕುಣಿಕೆಗಳು ಸ್ಥಿತಿಗೆ ಹಿಂದಿರುಗಿ ಜಿಗಿತವನ್ನು ಕಾಣಿಸುತ್ತದೆ.

71
00:04:14,690 --> 00:04:17,290
ಪರಿಸ್ಥಿತಿಯ ನಂತರ, ದೇಹದ ನಿಜವಾದ ವೇಳೆ

72
00:04:17,290 --> 00:04:18,990
ಲೂಪ್ ಮತ್ತೆ ಚಾಲನೆ ನೀಡಲಾಗುವುದು.

73
00:04:18,990 --> 00:04:22,190
ಪರಿಸ್ಥಿತಿ ನಿಜವಾದ ಎಂದಿಗೂ ವೇಳೆ, ನಂತರ ನಮ್ಮ ಲೂಪ್ ಸಾಧ್ಯವಿಲ್ಲ

74
00:04:22,190 --> 00:04:25,700
ಎಂದಿಗೂ ರನ್ ಮತ್ತು ಕೋಡ್ ಮುಂದಿನ ಸಾಲಿನ ಮೇಲೆ ಚಲಿಸುವ

75
00:04:25,700 --> 00:04:27,876
ನಮ್ಮ ಲೂಪ್ ಕೆಳಗೆ.

76
00:04:27,876 --> 00:04:28,550
ಎಲ್ಲಾ ಸರಿ.

77
00:04:28,550 --> 00:04:30,740
ಆದ್ದರಿಂದ ಅವರ ಎರಡನೇ ಪ್ರಕಾರದ ಒಂದು ಅವಲೋಕಿಸೋಣ

78
00:04:30,740 --> 00:04:33,000
ಲೂಪ್ ಫಾರ್ ಲೂಪ್,.

79
00:04:33,000 --> 00:04:37,310
ಆದರೆ ಕೀವರ್ಡ್ ಮುಂದೆ, ಆವರಣ, ನಾವು, ಒಂದು ವಿಷಯ ಹೊಂದಿತ್ತು

80
00:04:37,310 --> 00:04:39,840
ನಿಜವಾದ ಎಂದು ಅಗತ್ಯವಿದೆ ಷರತ್ತಿನ

81
00:04:39,840 --> 00:04:42,010
ಲೂಪ್ ದೇಹದ ನಡೆಸಲ್ಪಟ್ಟವು.

82
00:04:42,010 --> 00:04:45,440
ನಾವು ಹೊರಗೆ ನಮ್ಮ ಕೌಂಟರ್ ವೇರಿಯಬಲ್ ತಯಾರಿಸಿದರು ಅಂದರೆ

83
00:04:45,440 --> 00:04:48,760
ಕೆಲವು ಸಮಯದಲ್ಲಿ ಲೂಪ್ ಮತ್ತು ಹೆಚ್ಚಿಸಲು ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಆಫ್

84
00:04:48,760 --> 00:04:51,050
ಲೂಪ್ ಒಳಗೆ.

85
00:04:51,050 --> 00:04:54,320
ಲೂಪ್ ನಮ್ಮ ಫಾರ್ ಹೆಡರ್ ಮತ್ತೊಂದೆಡೆ, ಮೂರು

86
00:04:54,320 --> 00:04:58,510
ಭಾಗಗಳು, ಇದರಲ್ಲಿ ಪ್ರತಿಯೊಂದು ಒಂದು ಅರ್ಧವಿರಾಮ ಚಿಹ್ನೆಯಿಂದ ಬೇರ್ಪಡಿಸಲಾಗುವುದು.

87
00:04:58,510 --> 00:05:01,950
ನಮ್ಮ ಮೊದಲ ಮೂರನೇ, ನಾವು ಯಾವುದೇ ಕೌಂಟರ್ ಅಥವಾ ಸಹಾಯಕ ಘೋಷಿಸಬಹುದು

88
00:05:01,950 --> 00:05:05,000
ಅಸ್ಥಿರ ನಮ್ಮ ಚಕ್ರಕ್ಕೆ ನಿಮ್ಮಿಷ್ಟದ.

89
00:05:05,000 --> 00:05:07,350
ಪ್ರಾಯೋಗಿಕವಾಗಿ, ಈ ನಿಜವಾಗಿಯೂ ಸಹಾಯವಾಗುತ್ತದೆ.

90
00:05:07,350 --> 00:05:10,590
ನಾವು ನಿಜವಾಗಿಯೂ ನಮ್ಮ ಆದರೆ ನಂತರ ವೇರಿಯಬಲ್, ನಾನು, ಅಗತ್ಯವಿಲ್ಲ

91
00:05:10,590 --> 00:05:13,650
ಲೂಪ್ ನಡೆಸುತ್ತಿದೆ, ಆದ್ದರಿಂದ ನಾವು ಅದನ್ನು ಘೋಷಿಸಲು ಹಾಗಿಲ್ಲ

92
00:05:13,650 --> 00:05:15,810
ಲೂಪ್ ಹೊರಗೆ.

93
00:05:15,810 --> 00:05:19,080
ಎರಡನೇ ಮೂರನೇ ನಿಜವಾದ ಮಾಡಬೇಕಾದ ಸ್ಥಿತಿಗೆ ಕಾಣಿಸುತ್ತದೆ

94
00:05:19,080 --> 00:05:21,850
ದೇಹದ ಕೇವಲ ಹಾಗೆ ಮತ್ತೊಮ್ಮೆ ಕಾರ್ಯಗತಗೊಳಿಸಲ್ಪಡುತ್ತದೆ ಮಾಡಲು

95
00:05:21,850 --> 00:05:23,330
ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ ಚಕ್ರಕ್ಕೆ.

96
00:05:23,330 --> 00:05:26,350
ನಮ್ಮ ಕೊನೆಯ ಮೂರನೇ, ನಾವು ಎಂದು ಹೇಳಿಕೆ ಚಲಾಯಿಸಬಹುದು

97
00:05:26,350 --> 00:05:30,270
ಲೂಪ್ ಪ್ರತಿಯೊಂದು ಪುನರಾವರ್ತನೆ ನಂತರ ಕಾರ್ಯರೂಪಕ್ಕೆ, ಆದ್ದರಿಂದ ನಾವು ಹೊಂದಿಲ್ಲ

98
00:05:30,270 --> 00:05:32,710
ಲೂಪ್ ದೇಹದ ಅದನ್ನು ನಿರ್ಮಿಸಲು.

99
00:05:32,710 --> 00:05:38,390
ಇದರಿಂದ 5 ರಿಂದ 1 ಕೆಳಗೆ ಸದಸ್ಯ ಎಂದು ಲೂಪ್ ಒಂದು ಬರೆಯಬಹುದು.

100
00:05:38,390 --> 00:05:41,790
ನಾವು ಕೀವರ್ಡ್ ಆರಂಭವಾಗಬೇಕು ಮಾಡುತ್ತೇವೆ.

101
00:05:41,790 --> 00:05:44,680
ನಾವು ಇದನ್ನು ನಾವು ಮಾಡುತ್ತೇವೆ, ಮೊದಲ ಪ್ರತಿ ವೇರಿಯಬಲ್ ರಚಿಸಬಹುದು

102
00:05:44,680 --> 00:05:47,840
ನಾವು ಕೆಳಗೆ ಎಣಿಸುವ ನೀವು ರಿಂದ 5 ಈ ಸಮಯ ಸೆಟ್,

103
00:05:47,840 --> 00:05:50,110
ಒಂದು ಅಲ್ಪ ವಿರಾಮ ಚಿಹ್ನೆಯನ್ನು ನಂತರ.

104
00:05:50,110 --> 00:05:53,660
ಮುಂದೆ ನಾವು ಹಿಂತಿರುಗಿ ನಾವು ನಮ್ಮ ಸ್ಥಿತಿಯನ್ನು ಹೊಂದಿದೆ.

105
00:05:53,660 --> 00:05:57,540
ಮೂರನೇ, ನಾವು ನಂತರ ನಮ್ಮ ಕೌಂಟರ್ ವೇರಿಯಬಲ್ ಇಳಿಕೆ ಬಯಸುವ

106
00:05:57,540 --> 00:05:59,620
ಲೂಪ್ ಪ್ರತಿಯೊಂದು ಪುನರಾವರ್ತನೆ.

107
00:05:59,620 --> 00:06:04,740
ಆದ್ದರಿಂದ ಬದಲಿಗೆ ನಾನು ಪ್ಲಸ್ ಪ್ಲಸ್ ಹೇಳುವ ಬದಲು, ನಾವು ನಾನು ಮೈನಸ್ ಮೈನಸ್ ಹೇಳುತ್ತೇನೆ.

108
00:06:04,740 --> 00:06:05,300
ಎಲ್ಲಾ ಸರಿ.

109
00:06:05,300 --> 00:06:09,490
ಆದ್ದರಿಂದ ನಾನು ಇನ್ನೂ ಲೂಪ್ ದೇಹದ ಚಲಾಯಿಸಲು ಬಯಸುವ

110
00:06:09,490 --> 00:06:11,960
0 ಹೆಚ್ಚು.

111
00:06:11,960 --> 00:06:16,160
ಲೂಪ್ ದೇಹದಲ್ಲಿ, ಐ ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ ಅವಕಾಶ.

112
00:06:16,160 --> 00:06:20,480
ಹಾಗೆ ಮಾಡಲು, ನಾವು% s ಬಳಸಿಕೊಂಡು printf ಕಾರ್ಯ ಬಳಸಿ

113
00:06:20,480 --> 00:06:21,650
ಪ್ಲೇಸ್ಹೋಲ್ಡರ್.

114
00:06:21,650 --> 00:06:24,820
ನೆನಪಿಡಿ, ಆ ಪ್ಲೇಸ್ಹೋಲ್ಡರ್ ಬದಲಾಯಿಸಲ್ಪಡುತ್ತದೆ

115
00:06:24,820 --> 00:06:27,040
ನಾನು ಮೌಲ್ಯವನ್ನು.

116
00:06:27,040 --> 00:06:32,060
ಅಂತಿಮವಾಗಿ, ನ ಲೂಪ್ ನಮ್ಮ ನಂತರ ಹೇಳಿಕೆ ಸೇರಿಸಲು ಅವಕಾಶ.

117
00:06:32,060 --> 00:06:35,850
ನಾವು ಈ ಲೂಪ್ ರನ್, ನಾನು, 5 ಆಫ್ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ

118
00:06:35,850 --> 00:06:38,070
ಆದ್ದರಿಂದ 5 ಮುದ್ರಿಸಲಾಗುತ್ತದೆ.

119
00:06:38,070 --> 00:06:42,000
ಒಮ್ಮೆ ನಾನು 0 ಮಾರಿದರೆ, ಮುಂದುವರಿಕೆ ಸ್ಥಿತಿಯನ್ನು, ನಾನು

120
00:06:42,000 --> 00:06:44,450
0 ಹೆಚ್ಚು, ಇನ್ನು ಮುಂದೆ ಅನ್ವಯಿಸುತ್ತದೆ.

121
00:06:44,450 --> 00:06:47,330
ಆದ್ದರಿಂದ ನಮ್ಮ ಲೂಪ್ ಪಾಲಿಸಲು ನಿಲ್ಲುತ್ತದೆ, ಮತ್ತು ನಾವು ನೋಡುತ್ತಾರೆ

122
00:06:47,330 --> 00:06:49,850
ಲೂಪ್ ನಂತರ ಹೇಳಿಕೆ.

123
00:06:49,850 --> 00:06:51,340
ಆದ್ದರಿಂದ ಅವರ ಈ ಕೋಡ್ ರನ್ ಅವಕಾಶ.

124
00:06:51,340 --> 00:06:52,700
ಮೊದಲ, ನಾವು ಕಂಪೈಲ್ ವಿಲ್

125
00:06:52,700 --> 00:06:56,460
ಎಣಿಕೆ ಮಾಡುವ ಜೊತೆಗೆ countdown.c.

126
00:06:56,460 --> 00:06:59,320
ಈಗ, ನಾವು. / ಕ್ಷಣಗಣನೆ ಈ ಕೋಡ್ ಚಲಾಯಿಸಬಹುದು.

127
00:07:02,340 --> 00:07:06,040
ಎರಡೂ ಸಂದರ್ಭದಲ್ಲಿ ಕುಣಿಕೆಗಳು ಮತ್ತು ಲೂಪ್, ನಮ್ಮ ಮುಂದುವರಿಕೆ

128
00:07:06,040 --> 00:07:09,010
ಸ್ಥಿತಿಯು ದೇಹದ ಮೊದಲು ಪರಿಶೀಲಿಸಲಾಗಲಿಲ್ಲ ಕಾಣಿಸುತ್ತದೆ

129
00:07:09,010 --> 00:07:10,960
ಕುಣಿಕೆಯ ಮರಣದಂಡನೆ ಇದೆ.

130
00:07:10,960 --> 00:07:13,840
ಅರ್ಥ ಎಂದು, ನಮ್ಮ ಸ್ಥಿತಿಯನ್ನು ಆರಂಭದಲ್ಲಿ ವೇಳೆ

131
00:07:13,840 --> 00:07:18,100
ನಿಜವಾದ, ನಂತರ ನಮ್ಮ ಲೂಪ್ ದೇಹದ ಚಾಲನೆ ಎಂದಿಗೂ.

132
00:07:18,100 --> 00:07:22,060
ಆದ್ದರಿಂದ ನಂತರ ಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸಿ ಕೆಲವೊಮ್ಮೆ ಉಪಯುಕ್ತವಾಗಿರುವ

133
00:07:22,060 --> 00:07:25,150
ಲೂಪ್ ದೇಹದ ಬದಲಿಗೆ ಮೊದಲು ಹೆಚ್ಚು.

134
00:07:25,150 --> 00:07:28,270
ಆದ್ದರಿಂದ ಒಂದು ಸಂಖ್ಯೆಯ ಬಳಕೆದಾರರು ಪ್ರಾಂಪ್ಟ್ ಮಾಡಲು ನ ಲೂಪ್ ಬರೆಯೋಣ

135
00:07:28,270 --> 00:07:30,990
ಧನಾತ್ಮಕ ಸಂಖ್ಯೆ ಪೂರೈಕೆ ಮಾಡುವವರೆಗೂ.

136
00:07:30,990 --> 00:07:34,740
ಯೂಸರ್ ಇನ್ಪುಟ್ಸ್ ಋಣಾತ್ಮಕ ಸಂಖ್ಯೆ, ನಾವು ಅವರನ್ನು ಕೇಳಲು ಬಯಸುವಿರಿ

137
00:07:34,740 --> 00:07:36,260
ಇನ್ನೊಂದು ಸಂಖ್ಯೆ.

138
00:07:36,260 --> 00:07:38,940
ನಾವು ಒಳಗೆ ಈ ಪ್ರಾಂಪ್ಟ್ ಬಯಸುವಿರಿ

139
00:07:38,940 --> 00:07:41,050
ಲೂಪ್ ಆಫ್ ದೇಹದ.

140
00:07:41,050 --> 00:07:44,730
ಆದಾಗ್ಯೂ, ಲೂಪ್ ಮೊದಲ ಬಾರಿಗೆ ಔಟ್ ಮಾಡಿದಾಗ, ಬಳಕೆದಾರ

141
00:07:44,730 --> 00:07:46,750
ಇನ್ನೂ ನಮಗೆ ಸಂಖ್ಯೆ ನೀಡಿಲ್ಲ.

142
00:07:46,750 --> 00:07:49,640
ಅದು ಧನಾತ್ಮಕ ಇದ್ದರೆ ಪರಿಶೀಲಿಸಲು ಅರ್ಥದಲ್ಲಿ ಮಾಡುವುದಿಲ್ಲ.

143
00:07:49,640 --> 00:07:54,020
ಬದಲಾಗಿ, ನಾವು ದೇಹದ ನಂತರ ಸಂಖ್ಯೆಯನ್ನು ಪರಿಶೀಲಿಸಿ ಬಯಸುವಿರಿ

144
00:07:54,020 --> 00:07:55,720
ಲೂಪ್ ರನ್ ಇದೆ.

145
00:07:55,720 --> 00:08:00,310
ನಾವು ಲೂಪ್ ಒಂದು ದೊ ಈ ಮಾಡಬಹುದು.

146
00:08:00,310 --> 00:08:03,560
ಮೊದಲ, ನಾವು, ಹಿಡಿದುಕೊಳ್ಳಿ ಎಂದು N, ಒಂದು ವೇರಿಯೇಬಲ್ ರಚಿಸುತ್ತೇವೆ

147
00:08:03,560 --> 00:08:05,230
ಬಳಕೆದಾರ ಇನ್ಪುಟ್.

148
00:08:05,230 --> 00:08:09,960
ಈಗ ನಾವು ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ನಂತರ ದೊ ಕೀವರ್ಡ್, ಬಳಸಿ ಎಂದು

149
00:08:09,960 --> 00:08:12,930
ನಮ್ಮ ಲೂಪ್ ದೇಹದ ಆಫ್ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.

150
00:08:12,930 --> 00:08:16,230
ದೇಹದಲ್ಲಿ, ನಾವು ಹಲವಾರು ಬಳಕೆದಾರ ಸೂಚಿಸಬಹುದು

151
00:08:16,230 --> 00:08:18,480
ಕಾರ್ಯ GetInt.

152
00:08:18,480 --> 00:08:23,230
ಈಗ, ನಾವು ಈ ಲೂಪ್ ದೇಹದಲ್ಲಿ ಮತ್ತೆ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಯಸುವಿರಿ ವೇಳೆ

153
00:08:23,230 --> 00:08:28,370
ಬಳಕೆದಾರ ಒಂದು ಋಣಾತ್ಮಕ ಸಂಖ್ಯೆ ಟೈಪ್, ಆದ್ದರಿಂದ ನಾವು ವಿಲ್ N

154
00:08:28,370 --> 00:08:30,420
ಕಡಿಮೆ 0 ಆಗಿದೆ.

155
00:08:30,420 --> 00:08:33,140
ಆದರೆ ಹೇಳಿಕೆ ನಂತರ ಇಲ್ಲಿ ಅಲ್ಪವಿರಾಮ ಚಿಹ್ನೆಯಿಂದ ಗಮನಿಸಿ.

156
00:08:38,909 --> 00:08:40,679
ಆದ್ದರಿಂದ ಅವರ ಈ ಕೋಡ್ ರನ್ ಅವಕಾಶ.

157
00:08:40,679 --> 00:08:44,780
ಮೊದಲ, ನಾವು ಸಕಾರಾತ್ಮಕ ಮಾಡಲು ಈ ಕಂಪೈಲ್ ಮಾಡುತ್ತೇವೆ.

158
00:08:44,780 --> 00:08:49,340
ಈಗ ನಾವು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಚಲಾಯಿಸಬಹುದು. / ಧನಾತ್ಮಕ.

159
00:08:49,340 --> 00:08:52,660
ನಾವು ಈ ಕಾರ್ಯಕ್ರಮವನ್ನು ಋಣಾತ್ಮಕ ಒಂದು ಋಣಾತ್ಮಕ ಸಂಖ್ಯೆ, ಕೊಟ್ಟರೆ

160
00:08:52,660 --> 00:08:56,560
4, ನಂತರ ನಾವು ಏಕೆಂದರೆ ಹಲವಾರು ಮತ್ತೆ ಅಪೇಕ್ಷಿಸುತ್ತದೆ ವಿಲ್

161
00:08:56,560 --> 00:09:00,490
ನಮ್ಮ ದೊ ಸ್ಥಿತಿ ಲೂಪ್ ನಿಜವಾದ ಸಂದರ್ಭದಲ್ಲಿ.

162
00:09:00,490 --> 00:09:04,690
ಒಮ್ಮೆ ನಾವು ನಂತರ, 8 ರೀತಿಯಲ್ಲಿ, ಒಂದು ಧನಾತ್ಮಕ ಸಂಖ್ಯೆಯನ್ನು ನೀಡಿ

163
00:09:04,690 --> 00:09:08,560
ನಮ್ಮ ದೊ ಸ್ಥಿತಿ ಲೂಪ್ ಎಂದಿಗೂ ಸತ್ಯ ಮಾಡುತ್ತದೆ.

164
00:09:08,560 --> 00:09:12,080
ಆದ್ದರಿಂದ ಲೂಪ್ ಮತ್ತೊಮ್ಮೆ ಕಾರ್ಯಗತಗೊಳಿಸಲ್ಪಡುತ್ತದೆ ಮಾಡಲಾಗುವುದಿಲ್ಲ.

165
00:09:12,080 --> 00:09:15,290
ಮತ್ತು ನಾವು ಸಿ ರಲ್ಲಿ ಬಳಸಿ ಕುಣಿಕೆಗಳು ಮೂರು ವಿಧದ ಅದು

166
00:09:15,290 --> 00:09:18,840
ನನ್ನ ಹೆಸರು ಟಾಮಿ ಆಗಿದೆ, ಮತ್ತು ಈ CS50 ಹೊಂದಿದೆ.