1
00:00:00,000 --> 00:00:03,250
>> SPEAKER 1: ఇప్పుడు ఒక ప్రోగ్రామ్ను రాయడం లెట్
వారు నిజంగా రెండు రెమ్మలు పోల్చి

2
00:00:03,250 --> 00:00:04,245
పాత్ర కోసం పాత్ర.

3
00:00:04,245 --> 00:00:06,830
యొక్క వంటి 0 సరిపోల్చండి ఉపయోగిస్తాను
మా ప్రారంభ స్థానం.

4
00:00:06,830 --> 00:00:11,550
కానీ పొర యొక్క మొదటి చర్మము తెలియజేయండి
స్ట్రింగ్ రకం మరియు ఇది తిరిగి

5
00:00:11,550 --> 00:00:14,120
అది నిజంగా ఉంది ఏమి కోసం, ఇది
ఒక చార్ నక్షత్రం.

6
00:00:14,120 --> 00:00:17,740
అని ఒక పాత్ర యొక్క చిరునామా ఉంది,
ఒక ప్రత్యేకంగా మొదటి పాత్ర

7
00:00:17,740 --> 00:00:21,010
మేము మరింత ఇష్టం అక్షరాలు క్రమం
సాధారణంగా ఒక స్ట్రింగ్ వంటి తెలుసు.

8
00:00:21,010 --> 00:00:21,880
>> T కోసం అదే.

9
00:00:21,880 --> 00:00:25,660
యొక్క స్ట్రింగ్ ప్రకటన తిరిగి వ్రాద్దాము
చార్ స్టార్.

10
00:00:25,660 --> 00:00:28,690
ఇప్పుడు మేము అవసరం ఇకపై
లేదంటే, t వ్యతిరేకంగా లు సరిపోల్చండి

11
00:00:28,690 --> 00:00:30,150
మేము రెండు చిరునామాలు సరిపోల్చండి.

12
00:00:30,150 --> 00:00:33,180
మేము నిజంగా పోల్చడానికి కావలసిన
రెండు రెమ్మలు తాము.

13
00:00:33,180 --> 00:00:37,520
ఇది చేయుటకు, మేము ఒక ఫంక్షన్ ఉపయోగించవచ్చు
string.h లో ప్రకటించింది.

14
00:00:37,520 --> 00:00:40,920
నేను కూడా జోడించాలి
నా ఫైలు పైన.

15
00:00:40,920 --> 00:00:43,130
>> ఆపై నేను మార్పు వెళుతున్న
ఇక్కడ ఈ లైన్.

16
00:00:43,130 --> 00:00:47,920
T వ్యతిరేకంగా లు సరిపోల్చండి కాకుండా, నేను ఉన్నాను
ఒక ఫంక్షన్ ప్రకంపనలు comp కాల్ అన్నారు,

17
00:00:47,920 --> 00:00:52,290
స్ట్రింగ్ కోసం సరిపోల్చండి మరియు పాస్
వాదనలు s మరియు t వంటి లో.

18
00:00:52,290 --> 00:00:56,480
మేము పోల్చడానికి స్ట్రింగ్ తరువాత వాయిదా చేస్తాము
s మరియు t నిజానికి సమాన ఉంటే గుర్తించడానికి

19
00:00:56,480 --> 00:00:59,870
మరియు పోల్చి ఎలా గుర్తించడానికి అనుమతిస్తాయి
పాత్ర కోసం వాటిని పాత్ర.

20
00:00:59,870 --> 00:01:02,410
>> ఇప్పుడు, డాక్యుమెంటేషన్ ప్రకారం
స్ట్రింగ్ సరిపోల్చండి కోసం, వాస్తవానికి

21
00:01:02,410 --> 00:01:06,920
0 తిరిగి వెళుతున్న ఉంటే రెండు రెమ్మలు
s మరియు t ఒకటే ద్వారా దిశగానే.

22
00:01:06,920 --> 00:01:09,490
ఇది ఒక ప్రతికూల సంఖ్య తిరిగి వెళుతున్న
లు t ముందు వచ్చి ఉండాలి

23
00:01:09,490 --> 00:01:13,740
అక్షర లేదా సానుకూల నంబర్ ఉంటే
లు అక్షర t తర్వాత వచ్చి ఉండాలి.

24
00:01:13,740 --> 00:01:16,090
>> కానీ ఇప్పుడు కోసం, మేము మాత్రమే శ్రద్ధ
సమానత్వం గురించి.

25
00:01:16,090 --> 00:01:19,270
నేను కేవలం పరీక్ష వెళుతున్న ఉంటే
స్ట్రింగ్ తిరిగి విలువ, సరిపోల్చండి

26
00:01:19,270 --> 00:01:21,450
s మరియు t లో మీదుగా 0 సమానం.

27
00:01:21,450 --> 00:01:24,940
మరియు అలా అయితే, నేను దావా వెళుతున్న ఆ
రెండు రెమ్మలు అదే.

28
00:01:24,940 --> 00:01:26,820
>> కానీ నేను ఒక చేయడానికి వెళుతున్న
ఇతర మార్పు.

29
00:01:26,820 --> 00:01:30,410
ఇది దాని ప్రకారం, ఆ స్ట్రింగ్ అవుతుంది
డాక్యుమెంటేషన్, కొన్నిసార్లు తిరిగి

30
00:01:30,410 --> 00:01:34,320
ప్రకారం, శూన్య, ఒక సెంటినెల్ విలువ
తీగలను డాక్యుమెంటేషన్, మార్గాల పొందడానికి

31
00:01:34,320 --> 00:01:35,450
చెడు ఏదో జరిగింది.

32
00:01:35,450 --> 00:01:38,830
ఉదాహరణకు, మేము మెమరీ అయిపోయింది లేదా
యూజర్ ఏదో సహకరించలేదు.

33
00:01:38,830 --> 00:01:41,080
>> స్ట్రింగ్, మరోవైపు, సరిపోల్చండి
కొద్దిగా దుర్బలంగా.

34
00:01:41,080 --> 00:01:44,730
మీరు శూన్య గాని దాని కోసం పాస్ ఉంటే
మొదటి లేదా రెండవ వాదన, చెడు

35
00:01:44,730 --> 00:01:45,650
విషయాలు జరుగుతుంది.

36
00:01:45,650 --> 00:01:47,970
సాధారణంగా పాల్గొన్న చెడు విషయాలు
సెగ్మెంటేషన్ లోపాలుగా.

37
00:01:47,970 --> 00:01:52,210
కాబట్టి పూర్తిగా సంభావ్య నివారించేందుకు,
నేను మొదటి ఈ ఉపయోగం మూసివేయాలని వెళుతున్న

38
00:01:52,210 --> 00:01:56,350
ఈ మొత్తం ఇండెంటింగ్ చెయ్యడం ద్వారా సరిపోల్చండి స్ట్రింగ్
కోడ్ మరియు మొదటి మాత్రమే చేయడం బ్లాక్

39
00:01:56,350 --> 00:02:03,140
ఆ లు శూన్య సమానం కాదు ఉంటే
మరియు t శూన్య సమానం కాదు.

40
00:02:03,140 --> 00:02:08,280
>> వేరే ఉంటే నేను నిర్మించడానికి చుట్టడం
వంకర జంట కలుపులు వంటి గతంలో టైప్

41
00:02:08,280 --> 00:02:12,270
బాగా, కాబట్టి నేను మాత్రమే టచ్ ఈ సమయంలో
s మరియు t నేను కొన్ని రెడీ ఉంటే

42
00:02:12,270 --> 00:02:13,450
వారు శూన్య కాదు.

43
00:02:13,450 --> 00:02:17,220
ఇప్పుడు, సేవ్ సంకలనం లెట్, మరియు
ఈ కార్యక్రమం తిరిగి అమలు.

44
00:02:17,220 --> 00:02:22,240
>> 1 సరిపోల్చండి 1 డాట్ స్లాష్ పోల్చి తయారు.

45
00:02:22,240 --> 00:02:23,950
నేను మళ్ళీ హలో చెప్పండి చేస్తాము.

46
00:02:23,950 --> 00:02:25,890
హలో మళ్ళీ తరువాత.

47
00:02:25,890 --> 00:02:28,110
మరియు ఈ సమయంలో, నేను నిజానికి
ఒకే విషయం టైప్.

48
00:02:28,110 --> 00:02:30,255