1
00:00:00,000 --> 00:00:05,960
>> [సంగీతాన్ని]

2
00:00:05,960 --> 00:00:08,540
>> డౌ LLOYD: హాయ్, కాబట్టి లెట్స్
C. లో ఆపరేటర్ల గురించి మాట్లాడటానికి

3
00:00:08,540 --> 00:00:12,590
కాబట్టి, మేము ఇప్పటికే ఒక చూసిన, నిజానికి,
కార్య ఆపరేటర్లు సమానం.

4
00:00:12,590 --> 00:00:15,510
ఇది మాకు కేవలం చాలు అనుమతిస్తుంది
ఒక వేరియబుల్ ఒక విలువ.

5
00:00:15,510 --> 00:00:18,046
ఆ కార్య కాదు
ఆపరేటర్లు, ఒకే సమాన సైన్.

6
00:00:18,046 --> 00:00:20,670
మార్చటానికి క్రమంలో మరియు పని లో
సి విలువలు మరియు వేరియబుల్స్ తో,

7
00:00:20,670 --> 00:00:23,710
మేము ఆపరేటర్ల సంఖ్యను కలిగి
మా పారవేయడం వద్ద మేము ఉపయోగించే.

8
00:00:23,710 --> 00:00:25,543
యొక్క పరిశీలించి లెట్
సాధారణంగా కనిపించే వాటిలో కొన్ని

9
00:00:25,543 --> 00:00:27,430
అంకగణిత ఆపరేటర్లు ప్రారంభమయ్యాయి.

10
00:00:27,430 --> 00:00:31,080
మీరు ఊహించిన విధంగా, మేము చేయవచ్చు
C. లో అందంగా ప్రాథమిక గణిత కార్యకలాపాలు

11
00:00:31,080 --> 00:00:36,520
మేము, జోడించడానికి వ్యవకలనం, గుణకారం, మరియు చేయవచ్చు
ప్లస్ ఉపయోగించి విభజన సంఖ్యలు, మైనస్, స్టార్,

12
00:00:36,520 --> 00:00:38,422
వరుసగా స్లాష్.

13
00:00:38,422 --> 00:00:40,630
ఇక్కడ రేఖల జంట
కోడ్ దీనిలో మేము అలా.

14
00:00:40,630 --> 00:00:44,150
కాబట్టి, మేము Int x, y ప్లస్ 1 సమానం.

15
00:00:44,150 --> 00:00:46,460
యొక్క ఎక్కడో ఊహించుకోవటం తెలియజేయండి
కోడ్ యొక్క ఈ లైన్ పైన

16
00:00:46,460 --> 00:00:49,230
మేము Int y 10 సమానం చెప్పారు.

17
00:00:49,230 --> 00:00:55,790
X యొక్క విలువ నేను తరువాత ఏమిటి
కోడ్ యొక్క ఈ మొదటి లైన్ అమలు?

18
00:00:55,790 --> 00:00:56,700
మీరు 11 చెబుతాడు?

19
00:00:56,700 --> 00:00:57,910
మీరు కుడి భావిస్తున్న.

20
00:00:57,910 --> 00:00:58,420
ఎందుకు అని?

21
00:00:58,420 --> 00:00:59,790
Well, y 10 ఉంది.

22
00:00:59,790 --> 00:01:03,215
కొన్ని నేను చెప్పడం నేను, Int x 10 ప్లస్ 1 సమానం.

23
00:01:03,215 --> 00:01:04,269
10 ప్లస్ 1 నుండి 11 ఉంది.

24
00:01:04,269 --> 00:01:08,540
కాబట్టి, విలువ 11 గెట్స్
వేరియబుల్ x లో నిల్వ.

25
00:01:08,540 --> 00:01:09,740
చాలా చెడ్డ కాదు, కుడి?

26
00:01:09,740 --> 00:01:14,040
>> ఎలా యొక్క ఈ తదుపరి లైన్ గురించి
కోడ్? x x సార్లు 5 సమానం.

27
00:01:14,040 --> 00:01:17,700
Well, ముందు మేము ఉరితీయబడ్డారు
కోడ్ యొక్క ఈ లైన్ x 11 ఉంది.

28
00:01:17,700 --> 00:01:21,237
కాబట్టి, విలువ ఏమిటి
x కోడ్ యొక్క ఈ లైన్ తర్వాత?

29
00:01:21,237 --> 00:01:21,820
రెండవ తీసుకోండి.

30
00:01:21,820 --> 00:01:24,710

31
00:01:24,710 --> 00:01:27,620
సో, x x సార్లు 5 సమానం.

32
00:01:27,620 --> 00:01:29,850
x 11 ఉంది.

33
00:01:29,850 --> 00:01:32,970
కాబట్టి, x 11 సార్లు 5 సమానం.

34
00:01:32,970 --> 00:01:34,360
లేదా 55.

35
00:01:34,360 --> 00:01:36,490
మీరు 55 చెప్పారు కనుక, మీరు కుడి భావించాలి.

36
00:01:36,490 --> 00:01:41,770
>> ఇప్పుడు, అది కొద్దిగా గందరగోళంగా ఉండవచ్చు, కానీ
ఆ అప్పగించిన సి పనిచేస్తుంది మార్గం

37
00:01:41,770 --> 00:01:46,030
కుడివైపు విలువ గెట్స్
ఎడమవైపు విలువ కేటాయించిన.

38
00:01:46,030 --> 00:01:49,090
సో, మొదటి మేము x సార్లు 5 అంచనా.

39
00:01:49,090 --> 00:01:50,800
సో, 11 సార్లు 5 55 ఉంది.

40
00:01:50,800 --> 00:01:53,340
మరియు తర్వాత మేము x లో ఆ విలువ నిల్వ.

41
00:01:53,340 --> 00:01:56,100
ఉందని 11
ముందు ఇప్పుడు భర్తీ ఉంది.

42
00:01:56,100 --> 00:01:58,280
కాబట్టి x యొక్క విలువ ఇప్పుడు 55 ఉంది.

43
00:01:58,280 --> 00:02:00,820
ఆశాజనక బొత్తిగా సూటిగా ఉంది.

44
00:02:00,820 --> 00:02:04,246
>> మీరు చేసిన మరొక ఆపరేటర్లు ఉంది
బహుశా తప్పనిసరిగా వినకుంటే

45
00:02:04,246 --> 00:02:06,620
ఈ అంటారు, కానీ మీరు చేసిన
ఖచ్చితంగా గతంలో కలిసి పనిచేసిన

46
00:02:06,620 --> 00:02:09,470
మీరు పొడవాటి మీ రోజుల గుర్తు ఉంటే
గ్రేడ్ పాఠశాల తిరిగి డివిజన్ మార్గం.

47
00:02:09,470 --> 00:02:11,270
ఇది బహుళ సాహచర్యం ఆపరేటర్లు అని.

48
00:02:11,270 --> 00:02:13,620
ఏం మాడ్యులస్ అది ఉంది
మీరు మిగిలిన ఇస్తుంది

49
00:02:13,620 --> 00:02:15,400
మీరు కలిసి రెండు సంఖ్యలు విభజించబడినప్పుడు.

50
00:02:15,400 --> 00:02:21,750
నేను చెప్పే చేస్తే, 13 ద్వారా విభజించబడింది
4, మిగిలిన ఏమిటి?

51
00:02:21,750 --> 00:02:24,860
మరియు ఆ విలువను లెక్కిస్తారు అవుతుంది
మాడ్యులస్ ఆపరేటర్లు ద్వారా.

52
00:02:24,860 --> 00:02:28,320
>> కనుక, నేను కోడ్ ఒక లైన్ కలిగి
ఇక్కడ, Int m 13 mod 4 సమానం.

53
00:02:28,320 --> 00:02:31,960
నేను ఒక వ్యాఖ్యలో ఇక్కడ చెప్పటానికి
ఆ m యొక్క విలువ ఇప్పుడు 1.

54
00:02:31,960 --> 00:02:32,750
నేను ఎందుకు అని చెబుతారు?

55
00:02:32,750 --> 00:02:36,270
బాగా, పొడవైన విభాజక అవుట్ చేయండి మీ
తల మీరు రెండవ కోసం నాతో భరించలేదని ఉంటే.

56
00:02:36,270 --> 00:02:40,070
సో, నేను 4 13 విభజించింది.

57
00:02:40,070 --> 00:02:44,087
4 13 మూడు సార్లు వెళతాడు
1 యొక్క మిగిలిన తో.

58
00:02:44,087 --> 00:02:45,920
కాబట్టి, ప్రాథమికంగా, అన్ని
మాడ్యులస్ ఆపరేటర్లు చేస్తుంది

59
00:02:45,920 --> 00:02:48,600
మీరు ఉన్నప్పుడు మీరు చెబుతుంది
విభజన, మీరు మిగిలిన పొందండి.

60
00:02:48,600 --> 00:02:51,420
మీరు ఆ నిజానికి అనుకుంటున్నాను ఉండవచ్చు
ఒక భయంకరమైన ఉపయోగకరమైన విషయం,

61
00:02:51,420 --> 00:02:54,350
కానీ మీరు నిజంగా ఆశ్చర్యం లోనవుతాను
ఎంత తరచుగా ఆ మాడ్యులస్ ద్వారా

62
00:02:54,350 --> 00:02:55,820
ఆపరేటర్లు ఉపయోగపడుట చేయవచ్చు.

63
00:02:55,820 --> 00:02:58,420
>> సమస్యలను జంట ఉంది
మేము అది వ్యవహరించే CS50 చేస్తాను.

64
00:02:58,420 --> 00:03:00,545
ఇది కూడా చేయడం కోసం బావుంటుంది
యాదృచ్ఛిక సంఖ్య వంటి విషయాలు.

65
00:03:00,545 --> 00:03:03,850
కాబట్టి, ఉదాహరణకు మీరు ఎప్పుడైనా చేసిన ఉంటే
ఒక యాదృచ్ఛిక సంఖ్య జనరేటర్ యొక్క విన్న,

66
00:03:03,850 --> 00:03:06,620
మీరు ఒక సంఖ్య ఇవ్వాలని జరగబోతోంది
0 నుండి కొన్ని భారీ సంఖ్యలో.

67
00:03:06,620 --> 00:03:10,390
కాని మీరు మాత్రమే నిజంగా
0 నుండి 20 వరకు అనేక అవసరం.

68
00:03:10,390 --> 00:03:13,425
మీరు బహుళ సాహచర్యం ఆపరేటర్లు ఉపయోగిస్తే
ఆ జెయింట్ సంఖ్య ఆ

69
00:03:13,425 --> 00:03:17,080
ద్వారా ఉత్పత్తి అవుతుంది
యాదృచ్ఛిక సంఖ్య జనరేటర్,

70
00:03:17,080 --> 00:03:20,230
మీరు తీసుకుని వెళుతున్న చేస్తున్నాం సంసార
అది భారీ విలువ, 20 ద్వారా తిరగడానికి

71
00:03:20,230 --> 00:03:21,210
మరియు మిగిలిన పొందండి.

72
00:03:21,210 --> 00:03:24,050
మిగిలిన మాత్రమే
0 నుండి 19 వరకు ఒక విలువ.

73
00:03:24,050 --> 00:03:27,140
కాబట్టి, మీరు బహుళ సాహచర్యం ఆపరేటర్లు ఉపయోగించడానికి
ఈ భారీ సంఖ్యలో తీసుకోవాలని

74
00:03:27,140 --> 00:03:29,640
మరియు డౌన్ ఏదో లోకి చెక్కకొయ్య ఇది
కొంచెం అర్ధవంతమైన.

75
00:03:29,640 --> 00:03:31,764
నేను మీరు ఉంటాం అందంగా ఖచ్చితంగా ఉన్నాను
ఆ రెండు వాడుకునేలా

76
00:03:31,764 --> 00:03:34,710
CS50 లో భవిష్యత్తులో ఏదో ఒక సమయంలో.

77
00:03:34,710 --> 00:03:37,030
>> కావున C కూడా మాకు ఒక మార్గాన్ని అందిస్తుంది
ఒక అంక దరఖాస్తు

78
00:03:37,030 --> 00:03:39,910
ఒకే వేరియబుల్ ఆపరేటర్లు
కొంచెం సంక్షిప్తలిపి మార్గంలో.

79
00:03:39,910 --> 00:03:44,520
కాబట్టి, మునుపటి స్లయిడ్ లో,
మేము x x సార్లు 5 సమానం చూసింది.

80
00:03:44,520 --> 00:03:45,260
అని పని.

81
00:03:45,260 --> 00:03:47,660
x సార్లు 5 అప్పుడు x తిరిగి నిల్వఉంటోంది.

82
00:03:47,660 --> 00:03:52,490
దీన్ని తక్కువ మార్గం ఆలోచన లేదు,
మరియు అది వాక్యనిర్మాణం x సార్లు 5 సమానం వార్తలు.

83
00:03:52,490 --> 00:03:55,020
ఇది అదే ఖచ్చితమైన విషయం
మాట్లాడుతూ x x సార్లు 5 సమానం.

84
00:03:55,020 --> 00:03:56,824
ఇది కేవలం కొద్దిగా వార్తలు
దీన్ని తక్కువ మార్గం.

85
00:03:56,824 --> 00:03:58,740
మరియు మీరు కొన్ని చూసినప్పుడు
పంపిణీ కోడ్ లేదా మీరు

86
00:03:58,740 --> 00:04:01,287
కొన్ని నమూనా కోడ్ కనిపించిందని
ఈ వంటి పనులు,

87
00:04:01,287 --> 00:04:03,120
కేవలం తెలిసిన ఉండాలి
వాక్యనిర్మాణం అర్థం.

88
00:04:03,120 --> 00:04:05,980
మీరు ఖచ్చితంగా లేదు
మీరు లేకపోతే దాన్ని ఉపయోగించండి, కానీ,

89
00:04:05,980 --> 00:04:08,235
మీ కోడ్ సంపాదించగలరు
కొద్దిగా slicker చూడండి.

90
00:04:08,235 --> 00:04:11,360
మరియు మీరు కూడా మీరు ఉపయోగించవచ్చు తెలుసు
వివిధ ఆపరేటర్లు మేము ఇప్పటికే చేసిన

91
00:04:11,360 --> 00:04:12,660
ముందు బదులుగా సార్లు చూసిన.

92
00:04:12,660 --> 00:04:16,720
మీరు x ప్లస్ 5, మైనస్ సమానం చెప్పగల్గినవి
5, సార్లు, విభజన, మరియు mod సమానం.

93
00:04:16,720 --> 00:04:18,959
ఆ పని అంతా.

94
00:04:18,959 --> 00:04:21,089
>> ఏదో కూడా ఉంది
సి లో కాబట్టి సాధారణ వార్తలు

95
00:04:21,089 --> 00:04:24,080
మేము నిర్ణయించుకుంది చేసిన
మరింత ఆ శుద్ధి.

96
00:04:24,080 --> 00:04:26,916
1 ఒక వేరియబుల్ పెంచడం
లేదా, 1 వేరియబుల్ దానికి వీలు

97
00:04:26,916 --> 00:04:30,040
ఇటువంటి ఒక సాధారణ విషయం ముఖ్యంగా
మేము మాట్లాడినప్పుడు గురించి కొద్దిగా తరువాత ఉచ్చులు

98
00:04:30,040 --> 00:04:35,240
మొదలైనవి మేము బదులుగా నిర్ణయించుకుంది చేసిన
, x ప్లస్ లాగ 1 సమానం మాట్లాడుతూ

99
00:04:35,240 --> 00:04:40,190
లేదా x x ప్లస్ 1 సమానం, మేము కూడా చేసిన
చిన్న ఆ x ప్లస్ ప్లస్ అప్పగించారు.

100
00:04:40,190 --> 00:04:46,940
సో, xx ప్లస్ 1, x ప్లస్ 1 సమానం సమానం,
మరియు x ప్లస్ ప్లస్ అన్ని ఇదే.

101
00:04:46,940 --> 00:04:48,470
వారు 1 అన్ని పెంపు x.

102
00:04:48,470 --> 00:04:50,630
కానీ ఆ పెంచడం
మరియు 1 తగ్గించ దానికి వీలు

103
00:04:50,630 --> 00:04:54,110
మేము కలిగి కాబట్టి సాధారణం
ప్లస్ ప్లస్ మరియు మైనస్ మైనస్

104
00:04:54,110 --> 00:04:59,140
మాకు సంక్షిప్తలిపి అనుమతిస్తుంది
మరింత ఆ.

105
00:04:59,140 --> 00:05:02,110
>> కాబట్టి, యొక్క రెండవ గేర్లు మారవచ్చు వీలు
మరియు బూలియన్ వ్యక్తీకరణలు గురించి మాట్లాడటానికి.

106
00:05:02,110 --> 00:05:06,340
కూడా రకమైన ఇవి అన్ని వస్తాయి
ఆపరేటర్ల ఓవరాల్ కేటగిరీ.

107
00:05:06,340 --> 00:05:09,030
కానీ బూలియన్ వ్యక్తీకరణలు,
అంకగణిత ఆపరేటర్లు కాకుండా,

108
00:05:09,030 --> 00:05:11,860
విలువలు పోల్చడానికి ఉపయోగిస్తారు.

109
00:05:11,860 --> 00:05:15,550
సి సో, మళ్ళీ, అన్ని బూలియన్ వ్యక్తీకరణలు
రెండు విలువలను ఒకటి విశ్లేషించదు

110
00:05:15,550 --> 00:05:16,050
గుర్తు.

111
00:05:16,050 --> 00:05:17,740
నిజమా లేక అబధ్ధమా.

112
00:05:17,740 --> 00:05:21,880
ఆ కేవలం రెండు విలువలు వార్తలు
బూలియన్ వేరియబుల్ పొందగలవు.

113
00:05:21,880 --> 00:05:25,780
మేము ఫలితాలు ఉపయోగించవచ్చు
బూలియన్ వ్యక్తీకరణ

114
00:05:25,780 --> 00:05:27,650
ప్రోగ్రామింగ్ ఎన్నోవిధాలుగా లో.

115
00:05:27,650 --> 00:05:29,400
నిజానికి, మీరు ఉంటాం
ఈ చాలా చాలా చేయడం.

116
00:05:29,400 --> 00:05:32,870
>> ఉదాహరణకు, మేము నిర్ణయించుకుంటారు ఉండవచ్చు,
బాగా, కొన్ని పరిస్థితి నిజమైతే,

117
00:05:32,870 --> 00:05:34,665
బహుశా నేను ఈ తీసుకొని వెళ్తాము
నా కోడ్ డౌన్ శాఖ.

118
00:05:34,665 --> 00:05:35,980
ఒక నియత, మాట్లాడటానికి.

119
00:05:35,980 --> 00:05:37,970
మేము వెంటనే చాలా ఆ గురించి నేర్చుకుంటారు.

120
00:05:37,970 --> 00:05:40,560
లేదా ఉండవచ్చు, ఉన్నంత
ఈ నేను కావలసిన నిజం

121
00:05:40,560 --> 00:05:42,790
ఈ పనిని
పైగా మరియు పైగా మరియు పైగా.

122
00:05:42,790 --> 00:05:43,480
ఒక లూప్.

123
00:05:43,480 --> 00:05:48,350
రెండు సందర్భాలలో, మేము ఉపయోగించే తెలుసు
నిజమైన లేదా తప్పుడు బూలియన్ వ్యక్తీకరణ,

124
00:05:48,350 --> 00:05:52,411
లేదో నిర్ణయించే
ఒక నిర్దిష్ట మార్గం పడుతుంది.

125
00:05:52,411 --> 00:05:54,660
కొన్నిసార్లు మేము పని చేస్తున్నాము
బూలియన్ వ్యక్తీకరణలు,

126
00:05:54,660 --> 00:05:56,410
మేము bool రకం వేరియబుల్స్ ఉపయోగించడానికి చేస్తుంది.

127
00:05:56,410 --> 00:05:58,461
మీరు డిక్లేర్డ్ ఉండవచ్చు
ఒక bool, వేరియబుల్ టైప్

128
00:05:58,461 --> 00:06:00,210
మరియు మీరు ఉపయోగించడానికి చేస్తాము మీ
బూలియన్ వ్యక్తీకరణ.

129
00:06:00,210 --> 00:06:02,130
కానీ మీరు ఎప్పుడూ అలా లేదు.

130
00:06:02,130 --> 00:06:06,690
అది, సి, ప్రతి కాని 0 టర్న్స్
విలువ నిజమైన మాట్లాడుతూ ఒకటే.

131
00:06:06,690 --> 00:06:10,680
మీరు డిక్లేర్డ్ చేసిన ఉంటే
రకం బూలియన్ వేరియబుల్,

132
00:06:10,680 --> 00:06:14,240
మరియు ఆ, నిజమైన విలువ కేటాయించిన
పూర్ణాంకం ప్రకటించారు అదే

133
00:06:14,240 --> 00:06:17,410
మరియు అది విలువ కేటాయించి
1, 2, 3, లేదా నిజంగా ఏ విలువ

134
00:06:17,410 --> 00:06:19,580
0 కంటే ఇతర లేనే.

135
00:06:19,580 --> 00:06:22,690
సి ఎందుకంటే, ప్రతి కాని 0 విలువ నిజం.

136
00:06:22,690 --> 00:06:24,820
0, మరోవైపు, FALSE.

137
00:06:24,820 --> 00:06:27,162
ఈ రావచ్చు
తెలుసు తర్వాత సులభ,

138
00:06:27,162 --> 00:06:28,620
కానీ ఏదో మనస్సులో ఉంచాలని.

139
00:06:28,620 --> 00:06:31,890
మేము ఎల్లప్పుడూ ఉపయోగించడానికి లేదు
బూలియన్ రకాన్ని వేరియబుల్స్ మేము

140
00:06:31,890 --> 00:06:34,980
బూలియన్ వ్యక్తీకరణలు పనిచేస్తున్నారు.

141
00:06:34,980 --> 00:06:37,890
>> బూలియన్ రెండు ప్రధాన రకాలు ఉన్నాయి
మేము పని చేస్తాము అని వ్యక్తీకరణలు.

142
00:06:37,890 --> 00:06:40,640
లాజికల్ ఆపరేటర్లు మరియు
రిలేషనల్ ఆపరేటర్లు.

143
00:06:40,640 --> 00:06:42,640
ఉంది భాష
భయంకరమైన ముఖ్యమైనది కాదు.

144
00:06:42,640 --> 00:06:44,970
ఇది నేను వాటిని ఒక చోట చేస్తున్నాను ఎంత నిజంగా ఉంది.

145
00:06:44,970 --> 00:06:49,222
మరియు మీరు ఖచ్చితంగా చేస్తాము, నేను త్వరగా అనుకుంటున్నాను
ఒక రిలేషనల్ ఆపరేటర్ అనేదానికి

146
00:06:49,222 --> 00:06:51,680
ఆధారంగా వారు ఏమి ఉన్నాయి మేము
రెండవ వాటిని గురించి మాట్లాడటానికి.

147
00:06:51,680 --> 00:06:54,250
కానీ తప్పనిసరిగా గురించి ఆందోళన లేదు
పదం తార్కిక ఆపరేటర్లు గుర్తుంచుకోవడం

148
00:06:54,250 --> 00:06:55,460
లేదా రిలేషనల్ ఆపరేటర్లు.

149
00:06:55,460 --> 00:07:00,070
నేను సమూహం దానిని ఉపయోగించి వెబ్
వాటిని ఒక తార్కిక విధంగా.

150
00:07:00,070 --> 00:07:02,620
>> కాబట్టి, యొక్క పరిశీలించి తెలియజేయండి
మూడు తార్కిక ఆపరేటర్లు

151
00:07:02,620 --> 00:07:04,970
మేము చాలా చూస్తారు
CS50 లో ప్రోగ్రామింగ్ లో బిట్

152
00:07:04,970 --> 00:07:06,710
మరియు ప్రోగ్రామింగ్ సాధారణంగా.

153
00:07:06,710 --> 00:07:10,470
తార్కిక మరియు నిజమైన ఉంటే
మాత్రమే రెండు ఆపరాండ్లను నిజమైన ఉంటే.

154
00:07:10,470 --> 00:07:11,775
లేకపోతే తప్పు.

155
00:07:11,775 --> 00:07:12,650
ఆ ఎక్కడ అర్థం ఏమిటి?

156
00:07:12,650 --> 00:07:15,840
కాబట్టి, యొక్క నేను వద్ద am అని పిలవబడు
నేను కలిగి నా కోడ్ లో అభిప్రాయపడుతున్నారు

157
00:07:15,840 --> 00:07:18,310
రెండు వేరియబుల్స్ x మరియు y.

158
00:07:18,310 --> 00:07:21,620
నేను లేదో మార
నా కోడ్ లో ఏదో చేయాలని

159
00:07:21,620 --> 00:07:25,780
x నిజం మరియు y నిజమైన ఉంటే ఆధారంగా.

160
00:07:25,780 --> 00:07:27,730
నేను మాత్రమే ఉంటే చేయాలనుకుంటున్నాను
అవి రెండూ, నిజమేనని

161
00:07:27,730 --> 00:07:30,980
లేకపోతే నేను ఆ డౌన్ వెళ్లాలని మీరు లేదు
మార్గం ఇది నాకు సహాయం వెళ్ళడం లేదు ఎందుకంటే.

162
00:07:30,980 --> 00:07:37,420
నేను చెప్పగలను x & ఉంటే y ఉంది.

163
00:07:37,420 --> 00:07:42,380
ఒక తార్కిక బూలియన్ ఉంటుంది
వ్యక్తీకరణ పోల్చడం x మరియు y

164
00:07:42,380 --> 00:07:45,240
మరియు ఒక నిర్దిష్ట మార్గంలో తీసుకొని
వారి విలువలు ఏమిటో ఆధారంగా.

165
00:07:45,240 --> 00:07:48,400
X నిజం మరియు కనుక, Y నిజం
ఇక్కడ ఈ నిజం పట్టిక ఆధారంగా,

166
00:07:48,400 --> 00:07:50,430
అప్పుడు మాత్రమే మనం ఆ మార్గం డౌన్ వెళ్తుంది.

167
00:07:50,430 --> 00:07:52,940
X, & & పీ ఉంటే.

168
00:07:52,940 --> 00:07:58,320
ఇది మాత్రమే true-- మరియు మాత్రమే ఉంది లో
x నిజం మరియు y నిజం నిజమైతే.

169
00:07:58,320 --> 00:08:00,850
గాని ఒక తప్పుడు ఉంటే,
మేము సత్యం పట్టిక చూడండి,

170
00:08:00,850 --> 00:08:02,370
అప్పుడు x మరియు y రెండు నిజమైన కాదు.

171
00:08:02,370 --> 00:08:07,660
అందువలన, x & y తప్పుగా.

172
00:08:07,660 --> 00:08:12,044
>> తార్కిక లేదా ఉంటే మరియు మాత్రమే నిజమైన ఉంది
కనీసం ఒక operand నిజమైన ఉంటే.

173
00:08:12,044 --> 00:08:12,710
లేకపోతే తప్పు.

174
00:08:12,710 --> 00:08:15,760
కాబట్టి తార్కిక మరియు అవసరమైన
x మరియు y రెండు నిజమైన ఉండాలి.

175
00:08:15,760 --> 00:08:21,185
తార్కిక లేదా నిజమైన లేదా y ఉండాలి x అవసరం
నిజమని లేదా x మరియు y రెండు నిజమని.

176
00:08:21,185 --> 00:08:23,310
సో, మళ్ళీ, మేము రకమైన కనుగొనేందుకు
పరిస్థితి మేమే

177
00:08:23,310 --> 00:08:26,460
మేము మా కోడ్ వెళుతున్న,
మరియు మేము రహదారి ఒక ఫోర్క్ చేరుకుంది.

178
00:08:26,460 --> 00:08:29,850
మరియు మేము ఒక డౌన్ వెళ్లాలని మీరు
విశేష x నిజమైతే

179
00:08:29,850 --> 00:08:33,299
లేదా y నిజం, కానీ
తప్పనిసరిగా ఉంటే రెండు నిజమైన.

180
00:08:33,299 --> 00:08:35,830
కానీ బహుశా ఉంటే రెండు నిజమైన.

181
00:08:35,830 --> 00:08:38,460
X నిజం మరియు కనుక y ఉంది
నిజమైన, మేము ఆ మార్గం డౌన్ వెళ్తారో.

182
00:08:38,460 --> 00:08:39,066
x నిజం.

183
00:08:39,066 --> 00:08:40,190
వారిలో ఒకరు కుడి, నిజం?

184
00:08:40,190 --> 00:08:42,080
X నిజం మరియు y నిజమైన ఉంటే.

185
00:08:42,080 --> 00:08:44,910
X నిజం, మరియు y తప్పుడు ఉంటే,
వాటిలో ఒకటి ఇప్పటికీ వర్తిస్తుంది.

186
00:08:44,910 --> 00:08:48,020
సో, X లేదా Y ఇప్పటికీ నిజం.

187
00:08:48,020 --> 00:08:52,290
X తప్పుడు ఉంది, మరియు y నిజమైన ఉంటే,
వాటిలో ఒకటి కుడి, ఇప్పటికీ నిజం?

188
00:08:52,290 --> 00:08:53,290
y ఈ సందర్భంలో, నిజం.

189
00:08:53,290 --> 00:08:57,950
కాబట్టి, అది x లేదా y నిజం ఆ నిజం.

190
00:08:57,950 --> 00:09:02,620
X తప్పుడు, y తప్పుడు మాత్రమే ఉంటే
మేము ఆ మార్గం డౌన్ వెళ్లరు

191
00:09:02,620 --> 00:09:04,454
x లేదా y ఎవరికీ నిజం.

192
00:09:04,454 --> 00:09:06,370
ఇప్పుడు, మీరు చూస్తున్నారా ఉంటే
స్క్రీన్ వద్ద ప్రస్తుతం

193
00:09:06,370 --> 00:09:09,062
మరియు ఆ wondering
చిహ్నం తార్కిక లేదా కోసం,

194
00:09:09,062 --> 00:09:10,270
ఇది నిలువు బార్ అని.

195
00:09:10,270 --> 00:09:13,730
మరియు మీరు ఉంటే మీ కీబోర్డు చూడటం
ఒక నిమిషం, నేను ఇప్పుడు ఏమి చేస్తున్నానో వంటి,

196
00:09:13,730 --> 00:09:16,940
అది కేవలం పైన సాధారణంగా వార్తలు
Enter కీ, అత్యంత కీబోర్డులపై

197
00:09:16,940 --> 00:09:19,630
బాక్ స్లాష్ అదే కీ న.

198
00:09:19,630 --> 00:09:22,790
ఇది కూడా సాధారణంగా కుడి వార్తలు
చదరపు బ్రాకెట్లలో పక్కన.

199
00:09:22,790 --> 00:09:27,240
కాబట్టి, అది ఒక కీ కావచ్చు మీరు
గతంలో చాలా టైప్ లేదు.

200
00:09:27,240 --> 00:09:29,700
కానీ, మీరు ఎప్పుడూ చేస్తున్నా
తార్కిక పోలికలు,

201
00:09:29,700 --> 00:09:31,882
మేము ఒక చేస్తూ ఉంటాను గా
కోర్సు లో చాలా, అంతే

202
00:09:31,882 --> 00:09:33,840
కు ఉపయోగకరంగా అన్నారు
ఆ కీ కనుగొని దాన్ని ఉపయోగించండి.

203
00:09:33,840 --> 00:09:38,340
కాబట్టి, అది అదే కీ సాధారణంగా వార్తలు
బాక్ స్లాష్ అంతే పైన నమోదు చేయండి.

204
00:09:38,340 --> 00:09:39,757
>> చివరి తార్కిక ఆపరేటర్లు లేదు.

205
00:09:39,757 --> 00:09:41,131
మరియు చాలా సూటిగా ఉంది.

206
00:09:41,131 --> 00:09:42,830
ఇది దాని operand విలువ inverts.

207
00:09:42,830 --> 00:09:46,080
X నిజమైతే, అప్పుడు x FALSE.

208
00:09:46,080 --> 00:09:49,960
X తప్పుడు ఉంటే, అప్పుడు కాదు x నిజం.

209
00:09:49,960 --> 00:09:53,850
కొన్నిసార్లు మీరు ఈ గుర్తు వింటారని
బ్యాంగ్ లేదా ఆశ్చర్యార్థకం అని పలుకబడిన

210
00:09:53,850 --> 00:09:55,231
లేదా.

211
00:09:55,231 --> 00:09:56,730
ఇది చాలా చక్కని అన్ని అదే విషయం.

212
00:09:56,730 --> 00:10:00,185
ఒకవేళ మీరు ఆ మాట్లాడే వినడానికి మరియు
మీరు అర్థం ఏమి ఖచ్చితంగా కాదు ఉన్నాము

213
00:10:00,185 --> 00:10:02,310
అది కేవలం ఆశ్చర్యార్థకం వార్తలు
పాయింట్, కానీ కొన్నిసార్లు అది

214
00:10:02,310 --> 00:10:04,215
ఒక జంట వివిధ విషయాలు అని.

215
00:10:04,215 --> 00:10:06,340
All right, కాబట్టి పడుతుంది
తార్కిక ఆపరేటర్ల శ్రద్ధ.

216
00:10:06,340 --> 00:10:08,640
కాబట్టి, యొక్క మాట్లాడటానికి వీలు
రిలేషనల్ ఆపరేటర్లు.

217
00:10:08,640 --> 00:10:11,610
మళ్ళీ, మీరు ఈ తెలిసి ఉంటే
గ్రేడ్ పాఠశాల తిరిగి సంఖ్యాశాస్త్రం

218
00:10:11,610 --> 00:10:13,870
మీరు బహుశా తెలిసి
తో ఎలా ఈ పని ఇప్పటికే.

219
00:10:13,870 --> 00:10:15,411
మీరు ఆశించిన పెంచండి ఈ ఖచ్చితంగా ప్రవర్తించే.

220
00:10:15,411 --> 00:10:19,800
కాబట్టి తక్కువ అది ఈ లో, నిజం కంటే
ఉదాహరణకు, X y కంటే తక్కువ ఉంటే.

221
00:10:19,800 --> 00:10:24,380
X 4 మరియు కనుక, y ఉంది
6, x, y కంటే తక్కువ.

222
00:10:24,380 --> 00:10:26,035
అది నిజం.

223
00:10:26,035 --> 00:10:27,910
కంటే తక్కువ లేదా సమానం
అందంగా అదేవిధంగా పనిచేస్తుంది.

224
00:10:27,910 --> 00:10:33,020
X 4, మరియు y అప్పుడు, 4 ఉంటే
x, y కంటే తక్కువ లేదా సమానం.

225
00:10:33,020 --> 00:10:35,310
అంతకన్నా ఎక్కువ. x, y కంటే ఎక్కువ.

226
00:10:35,310 --> 00:10:39,310
మరియు కంటే ఎక్కువ లేదా, x సమానం
y కంటే ఎక్కువ లేదా సమానం.

227
00:10:39,310 --> 00:10:41,745
ఇది నిజం ఉంటే, అప్పుడు మీరు చేస్తాము
ఆ వ్యక్తీకరణ పాస్,

228
00:10:41,745 --> 00:10:44,490
మరియు మీరు డౌన్ వెళ్తారో
రోడ్డు మీద ఆ మార్గం.

229
00:10:44,490 --> 00:10:48,590
X, y కంటే ఎక్కువ ఉంటే మీరు ఒక కలిగి ఉంటే,
మరియు x, నిజానికి, y కంటే ఎక్కువగా ఉంటుందని,

230
00:10:48,590 --> 00:10:51,670
మీరు ఏమైనా చేస్తాను
ఆ పరిస్థితి లోబడి.

231
00:10:51,670 --> 00:10:54,396
>> మేము ఒక కలిగి లేదు అని గుర్తించలేకపోతే
కంటే తక్కువ కోసం ఒకే పాత్ర

232
00:10:54,396 --> 00:10:57,020
లేదా సమానం గా మీరు కావచ్చు
గణిత పాఠ్యపుస్తకాలు నుండి తెలిసిన.

233
00:10:57,020 --> 00:10:59,874
కాబట్టి, మేము సింబల్ కంటే తక్కువ కలిగి
సమాన సైన్ తరువాత.

234
00:10:59,874 --> 00:11:01,790
మేము ప్రాతినిధ్యం ఎలా
కంటే లేదా సమానం తక్కువ.

235
00:11:01,790 --> 00:11:04,490
మరియు అలాగే, మేము అలా అలా
కంటే ఎక్కువ లేదా సమానం కోసం.

236
00:11:04,490 --> 00:11:06,698
>> చివరి రెండు రిలేషనల్
ముఖ్యమైన ఆపరేటర్లు

237
00:11:06,698 --> 00:11:09,320
సమానత్వం మరియు అసమానత కోసం పరీక్షిస్తున్నాయి.

238
00:11:09,320 --> 00:11:13,380
సో, x సమానం, y సమానం నిజం
x మరియు y యొక్క విలువ సమానంగా ఉంటుంది.

239
00:11:13,380 --> 00:11:19,610
X 10, మరియు y అప్పుడు, 10 ఉంటే
x సమానం Y నిజం సమానం.

240
00:11:19,610 --> 00:11:26,010
X 10 మరియు y, x 11, ఉంటే
y నిజం కాదు సమానం సమానం.

241
00:11:26,010 --> 00:11:29,680
మేము కూడా ఉపయోగించి అసమానత కోసం పరీక్షించవచ్చు
ఆశ్చర్యార్థకం పాయింట్ లేదా బ్యాంగ్ లేదా,

242
00:11:29,680 --> 00:11:30,330
మళ్ళీ.

243
00:11:30,330 --> 00:11:35,049
ఉంటే x ఉంటే, y కు సమానం కాదు
మేము ఇక్కడ ఉపయోగిస్తున్నట్లయితే పరీక్ష

244
00:11:35,049 --> 00:11:35,840
మేము అన్నిటికి అంటాను.

245
00:11:35,840 --> 00:11:40,340
సో, x సమానం కాదు ఉంటే
y, మేము ఆ మార్గం డౌన్ వెళ్తారో.

246
00:11:40,340 --> 00:11:41,441
>> ఇక్కడ నిజంగా జాగ్రత్తగా ఉండండి.

247
00:11:41,441 --> 00:11:44,440
ఇది నిజంగా సాధారణ mistake-- మరియు
ఒక నేను ఖచ్చితంగా తయారు చాలా ఉన్నప్పుడు

248
00:11:44,440 --> 00:11:47,340
నేను started-- అయిపోతున్నట్లు
అనుకోకుండా తప్పు

249
00:11:47,340 --> 00:11:51,690
కార్య ఆపరేటర్లు, ఒకే సమానం
సమానత్వం పోలిక ఆపరేటర్లు,

250
00:11:51,690 --> 00:11:52,582
డబుల్ సమానం.

251
00:11:52,582 --> 00:11:54,540
ఇది కొన్ని విచిత్రమైన దారి చేస్తాము
మీ కోడ్ లో ప్రవర్తన,

252
00:11:54,540 --> 00:11:56,730
మరియు సాధారణంగా కంపైలర్ రెడీ
మీరు ప్రయత్నించినప్పుడు దాని గురించి మిమ్మల్ని హెచ్చరిస్తుంది

253
00:11:56,730 --> 00:11:59,910
మరియు మీ కోడ్ కంపైల్, కానీ కొన్నిసార్లు
మీరు ద్వారా అది చొప్పించాడు చేయగలరు.

254
00:11:59,910 --> 00:12:02,770
ఇది తప్పనిసరిగా ఒక మంచి విషయం కాదు
మీరు ద్వారా అది చొప్పించాడు, అయితే.

255
00:12:02,770 --> 00:12:04,710
జస్ట్ మీరు చేస్తున్న కనుక
అసమానత పరీక్ష,

256
00:12:04,710 --> 00:12:07,970
మీరు రెండు లేదో తనిఖీ చేస్తున్నాము ఉంటే
వేర్వేరు చరరాశుల ఒకే విలువను కలిగి

257
00:12:07,970 --> 00:12:11,980
వాటిలో లోపల, ఉపయోగించడానికి నిర్ధారించుకోండి
సమానం, మరియు ఒకే సమానం సమానం.

258
00:12:11,980 --> 00:12:15,450
ఆ విధంగా మీ కార్యక్రమాన్ని రెడీ
మీరు ఉద్దేశం ప్రవర్తన కలిగి ఉంటాయి.

259
00:12:15,450 --> 00:12:18,400
నేను డౌ లాయిడ్ ఉన్నాను మరియు ఈ CS50 ఉంది.

260
00:12:18,400 --> 00:12:20,437