[Powered by Google Translate] [రివ్యూ] [Quiz 0]
>> [Lexi రాస్, టామీ MacWilliam, లుకాస్ ఫ్రీటస్, జోసెఫ్ వోంగ్] [హార్వర్డ్ విశ్వవిద్యాలయం]
>> [ఈ CS50 ఉంది.] [CS50.TV]
>> హేయ్, ప్రతి ఒక్కరూ.
ఈ బుధవారం జరిగే ఇది క్విజ్ 0 కొరకు సమీక్ష సెషన్ కు స్వాగతం.
ఈ రాత్రి చేయబోతున్నామని ఏమిటి, నేను, 3 ఇతర TFS తో ఉన్నాను
మరియు కలిసి మేము ఇప్పటివరకు కోర్సులో చేసిన ఏమి ఒక సమీక్ష ద్వారా వెళ్ళడానికి వెళుతున్న.
ఇది 100% సమగ్ర మాత్రం కాదు, అయితే మీరు ఒక మంచి ఆలోచన ఇస్తుంది
మీరు ఇప్పటికే డౌన్ కలిగి ఏమి మరియు మీరు ఇప్పటికీ బుధవారం ముందు అధ్యయనం అవసరం.
మేము వెంట వెళుతున్న మరియు, ప్రశ్నలు మీ చేయి పైకెత్తడం సంకోచించకండి
కానీ మేము కూడా సమయం కొద్దిగా ఉంటుంది గుర్తుంచుకోండి చివరి
మేము సాధారణ ప్రశ్నలు చేయడానికి విడి-కొన్ని నిమిషాలు తో ద్వారా వస్తే,
కాబట్టి గుర్తుంచుకోండి, అందువలన మేము వీక్ 0 తో ప్రారంభంలో ఆరంభమవుతుంది చేస్తున్నారు.
>> మేము ముందు [0 రివ్యూ క్విజ్!] [పార్ట్ 0] [Lexi రాస్] కానీ లెట్స్ గురించి మాట్లాడే
క్విజ్ లాజిస్టిక్స్.
>> [లాజిస్టిక్స్] [Quiz ఉపన్యాసం బదులుగా బుధవారం 10/10 న జరుగుతుంది]
>> [(వివరాల కోసం http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf చూడండి)] ఇది బుధవారం, అక్టోబర్ 10 న ఉంది.
>> ఈ బుధవారం, మరియు మీరు ఇక్కడ ఈ URL కు వెళ్ళండి ఉంటే,
ఇది కూడా ఒక లింక్ను CS50.net-అక్కడ 's నుండి ప్రాప్తి అది-
మీరు ఆధారంగా వెళ్ళడానికి పేరు గురించి సమాచారాన్ని చూడగలరు
మీ చివరి పేరు లేదా పాఠశాల అనుబద్ధత అలాగే
దాని గురించి ఖచ్చితంగా క్విజ్ మీరు పొందగలిగిన చేస్తున్న కవర్ మరియు రకాల ప్రశ్నలు ఏ చెబుతుంది.
మీరు కూడా విభాగంలో క్విజ్ కోసం సమీక్షించడానికి అవకాశం వస్తుంది గుర్తుంచుకోండి,
మీ TFS, కొన్ని ఆచరణ సమస్యలు మీద వెళ్ళడం చేయాలి
మరియు మీరు ఇప్పటికీ క్విజ్ అప్ అధ్యయనం అవసరం పేరు తెలుసుకోవటానికి మరొక మంచి అవకాశం.
బిట్స్ 'n' బైట్లతో ప్రారంభంలో ప్రారంభిద్దాం.
ఒక బిట్ ఒక 0 లేదా 1, ఇది గుర్తుంచుకో
మరియు బైట్ ఆ బైట్ల 8 యొక్క సమాహారం.
ఇక్కడే బిట్స్ ఈ సేకరణ చూడండి యొక్క లెట్.
మేము ఎన్ని బిట్స్ గుర్తించడానికి ఉండాలి.
మేము కౌంట్ ఎక్కడ వాటిలో 8, ఎనిమిది 0 లేదా 1 యూనిట్లు కేవలం ఉంది.
మరియు నుండి 8 బిట్స్ 1 బైట్ అని ఉన్నది
మరియు హెక్సాడెసిమల్ యొక్క మార్పిడి తెలియజేయండి.
హెక్సాడెసిమల్ బేస్ 16, మరియు ఇది మార్చేందుకు అందంగా సులభం
బైనరీ ఒక సంఖ్య, ఇది హెక్సాడెసిమల్ లో అనేక, ఆ ఇంతే.
మేము అన్ని మేము, 4 సమూహాలను చూడండి ఉంది
మరియు మేము తగిన హెక్సాడెసిమల్ అంకెల వాటిని మార్చేందుకు.
మేము 0011, 4 కుడి అత్యంత సమూహం ప్రారంభం.
తద్వారా కలిసి 3 చేస్తుంది, ఒక 1 మరియు ఒక 2 చేస్తాడు.
ఆపై యొక్క 4 ఇతర బ్లాక్ చూద్దాం.
1101. ఒక 1, 4 ఒక, మరియు ఒక 8 చేస్తాడు.
కలిసి ఆ D. చేస్తుంది, 13 చేస్తాడు
మరియు మేము హెక్సాడెసిమల్ లో మేము 9 ద్వారా 0 జరగనప్పుడు గుర్తుంచుకోవాలి చేస్తాము.
మేము 9 తర్వాత, F ద్వారా కి 10 సమంగా 0 వెళ్ళి,
F 15 ఉన్న 11 బి, et సెటేరా.
ఇక్కడ 13, ఒక D ఉంది
కాబట్టి ఇది మేము అన్ని మేము వాస్తవానికి దశాంశ మార్చుకునేందుకు
2 యొక్క ఒక శక్తిగా ప్రతి స్థానం చికిత్స.
ఒక 1, 2 ఒకటి సున్నా 4s, సున్నా 8, ఒక 16, et సెటేరా, యొక్క
మరియు మీ తల గణించడం చాలా కొద్దిగా కష్టం, కానీ మేము తదుపరి స్లయిడ్ వెళ్ళండి ఉంటే
మేము దానికి సమాధానం చూడగలరు.
>> ముఖ్యంగా మేము, ఎడమ తిరిగి కుడి నుండి వెళుతున్న చేస్తున్నారు
మరియు మేము 2 సంబంధిత శక్తి ద్వారా ప్రతి అంకెల గుణించడం చేస్తున్నారు.
మరియు, గుర్తు హెక్సాడెసిమల్ కోసం మేము ప్రారంభంలో 0x తో ఈ సంఖ్యలు సూచించడానికి
కాబట్టి మేము ఒక దశాంశ సంఖ్య తో తికమక లేదు.
కొనసాగిస్తూ, ఈ, ఒక ASCII టేబుల్ ఉంది
మరియు మేము కోసం ASCII ఉపయోగం అక్షరాలు నుండి సంఖ్యా విలువలకు ను ఉంటుంది.
గూఢ లిపి శాస్త్రం pset లో గుర్తుంచుకో మేము ASCII టేబుల్ విస్తృతంగా వాడారు
గూఢ లిపి శాస్త్రం యొక్క వివిధ పద్ధతులు ఉపయోగించడానికి,
వివిధ రకాల అక్షరాలతో మార్చేందుకు సీజర్ మరియు విజెనెరే సాంకేతికలిపి,
యూజర్ ఇచ్చిన కీ ప్రకారం ఒక స్ట్రింగ్ లో.
యొక్క ASCII మఠం కొద్దిగా చూద్దాం.
Q అని పాత్ర రూపంలో, 'P' వద్ద + 1 గురించి,
మరియు '5 '≠ 5 గుర్తుంచుకోవాలి.
మరియు ఎలా మేము ఆ 2 రూపాలు మధ్య మారుస్తానని?
ఇది నిజంగా చాలా కష్టంగా కాదు.
5 పొందడానికి మేము '0 వ్యవకలనం '
ఎందుకంటే '0 మధ్య 5 ప్రదేశాలు ఉన్నాయి 'మరియు '5.'
మేము కేవలం 0 జోడించండి ఇతర మార్గం చేయడానికీ,
కాబట్టి ఇది సాధారణ గణిత వంటి విధమైన ఉంది.
జస్ట్ ఏదో అది చుట్టూ కోట్ ఉన్నప్పుడు అది ఒక పాత్ర యొక్క గుర్తుంచుకోవాలి
మరియు ఆ విధంగా ASCII పట్టికలో ఒక విలువ సూచించదు.
సాధారణ కంప్యూటర్ సైన్స్ విషయాలు మారడం.
మేము ప్రోగ్రామింగ్ ఉపయోగం ఒక అల్గోరిథం మరియు నేర్చుకున్నారు
అల్గోరిథంలు అమలు చెయ్యటానికి.
అల్గోరిథంలు యొక్క కొన్ని ఉదాహరణలు వంటి రియల్లీ సింపుల్ ఏదో ఉంటాయి
అనేక సరి లేదా బేసి అనే తనిఖీ.
ఆ కోసం మేము 2 సంఖ్య MoD మరియు ఫలితంగా 0 ఉంటే తనిఖీ గుర్తుంచుకోవాలి.
అలా అయితే, అది కూడా ఉంది. లేకపోతే, అది బేసి ఉంటుంది.
మరియు ఒక యదార్థ ప్రాథమిక అల్గోరిథం యొక్క ఉదాహరణకు.
>> మరింత పాల్గొన్న ఒక అ లిటిల్ బిట్ బైనరీ శోధన,
ఇది మేము సమీక్ష సెషన్ తరువాత వెళ్ళి చేస్తాము.
మరియు ప్రోగ్రామింగ్ మేము ఒక అల్గోరిథం తీసుకొని ఉపయోగించే పదం
మరియు అది కంప్యూటర్ కోడ్ని మారిన చదువుకోవచ్చు.
ప్రోగ్రామింగ్ యొక్క 2 ఉదాహరణలు, స్క్రాచ్ ఉంది
ఇది మేము వీక్ 0 లో చేసిన ఏమిటి.
మేము నిజంగా కోడ్ అవుట్ టైప్ లేకపోయినప్పటికీ అది అమలు ఒక మార్గం
సంఖ్యలు 1-10 ప్రింటింగ్ ఇది ఈ అల్గోరిథం,
మరియు ఇక్కడ మేము C ప్రోగ్రామింగ్ లాంగ్వేజ్ లో ఇదే విధంగా.
ఇవి వివిధ భాషలలో లేదా వాక్యనిర్మాణం వ్రాసిన, క్రియాశీలంగా సమానంగా ఉంటాయి.
మేము అప్పుడు, బూలియన్ వ్యక్తీకరణలు నేర్చుకున్న
మరియు బూలియన్, ఒప్పు లేదా తప్పు గాని ఉన్న ఒక విలువ
మరియు ఇక్కడ oftentimes బూలియన్ భావాలు
అయితే (x ≤ 5), పరిస్థితులు లోపలి వెళ్లి,
అలాగే, మేము ఇప్పటికే ఆ పరిస్థితి నిజమైన విశ్లేషించదు అన్నారు x = 5, కాబట్టి సెట్.
ఇది నిజం ఉంటే, ఏ కోడ్ పరిస్థితి క్రింద ఉంది
కంప్యూటర్ ద్వారా విశ్లేషించబడుతుంది అన్నారు, తద్వారా స్ట్రింగ్ ముద్రించబడిన అన్నారు
ప్రామాణిక అవుట్పుట్, మరియు పదం పరిస్థితికి
అయితే ప్రకటన కుండలీకరణాలు లోపల ఉండే వస్తువు సూచిస్తుంది.
అన్ని ఆపరేటర్లు గుర్తుంచుకో.
| మేము ప్రయత్నిస్తున్న సమయంలో కలపడానికి 2 లేదా అంతకంటే ఎక్కువ షరతులను, | అది యొక్క && మరియు గుర్తుంచుకో
== లేదు = 2 సమానంగా ఉన్నాయి లేదో తనిఖీ చేయడానికి.
== బూలియన్ ఆపరేటర్ అయితే = విధినిర్వహణ కోసం అని గుర్తుంచుకోండి.
≤, ≥ మరియు అప్పుడు ఫైనల్ 2 స్వయం వివరణ ఉన్నాయి.
ఇక్కడ బోలియన్ లాజిక్ యొక్క ఒక సాధారణ సమీక్ష.
మరియు బూలియన్ భావాలు, పాశ్యాలలో కూడా ముఖ్యమైనవి
ఇది మేము ఇప్పుడు వెళ్ళి చేస్తాము.
మేము అయితే, కోసం, CS50 ఇప్పటివరకు లూప్ల సుమారు 3 రకాల నేర్చుకున్నాడు, మరియు ఉన్నప్పుడు.
మరియు అది తెలిసిన ముఖ్యమైన చాలా ప్రయోజనాల కోసం అయితే
మేము నిజంగా సాధారణంగా లూప్ ఏ రకమైన ఉపయోగించవచ్చు
అవసరాలు లేదా సాధారణ నమూనాలు కొన్ని రకాల ఉన్నాయి
ప్రత్యేకంగా ఈ లూప్ల ఒక పిలుపునిస్తూ ప్రోగ్రామింగ్ లో
అది చేసే సమర్థవంతమైన లేదా విధంగా అది కోడ్ సొగసైన.
యొక్క ఈ వలయాలు ప్రతి తరచుగా ఉపయోగించబడుతుంది ఉంటుంది వాటిని వదలి వేస్తారు.
>> ఒక In లూప్ మేము సాధారణంగా ఇప్పటికే మేము iterate మీరు ఎలా అనేక సార్లు తెలుసు.
అంటే పరిస్థితిలో ఉంచారు ఏమిటి.
నేను = 0, i <10, ఉదాహరణకు.
మేము ఇప్పటికే ఏదో 10 సార్లు చేయాలనుకుంటున్నారా తెలుసు.
ఇప్పుడు, ఒక సమయంలో లూప్, సాధారణంగా మనం అవసరం లేదు
మేము లూప్ అమలు చేయండి ఎన్ని సార్లు తెలుసు.
కానీ మనం దానికి కావలసిన పరిస్థితి విధమైన తెలుసా
ఎప్పుడూ నిజమే లేదా ఎల్లప్పుడూ తప్పుగా.
ఉదాహరణకు, అయితే సెట్.
లెట్ యొక్క బూలియన్ వేరియబుల్ చెబుతారు.
ఆ నిజం మేము కోడ్ విశ్లేషించడానికి మీరు,
కాబట్టి కొద్దిగా ఎక్కువ విస్తృతి, లూప్ ఒక కంటే ఎక్కువ సాధారణ కొద్దిగా,
కానీ లూప్ ఏ కూడా కొంత లూప్ వలె మారుతుంది.
చివరగా, విధంగా వెంటనే గ్రహించడానికి trickiest ఉండవచ్చు ఉచ్చులు,,
మేము మొదటి కోడ్ విశ్లేషించడానికి ఉంటుంది తరచుగా ఉపయోగిస్తారు
మొదటిసారి ముందు మేము పరిస్థితి తనిఖీ.
ఒక సాధారణ ఉపయోగ సందర్భం విధంగా లూప్
మీరు యూజర్ ఇన్ పుట్ పొందడానికి ఉంటుంది, మరియు మీరు యూజర్ కోరవలసి తెలుసు
ఇన్పుట్ కోసం కనీసం ఒకసారి, కాని మీరు మంచి ఇన్పుట్ ఇవ్వాలని లేదు ఉంటే వెంటనే
మీరు అవి మీరు మంచి ఇన్పుట్ ఇస్తుంది వరకు కోరుతూ ఉంచాలని.
అయితే లూప్ ఒక అతి సాధారణ వినియోగం, అలా ఉంది
మరియు యొక్క ఈ వలయాలు వాస్తవ నిర్మాణం చూద్దాం.
వారు సాధారణంగా ఎప్పుడూ ఈ నమూనాలను అనుసరించండి ఉంటాయి.
>> లోపల కోసం లూప్ మీరు 3 భాగాలు ఉన్నాయి:
ప్రారంభ, సాధారణంగా ఏదో వంటి Int నేను కౌంటర్ ఉన్న = 0,
మేము ఈ పరిస్థితి ఇప్పటికీ కలిగి కాలం లూప్ ఈ అమలు చెప్పడానికి ఎక్కడ పరిస్థితి,
మేము పెంచడం ఎలా ఉంది చివరికి నేను అప్పుడు <10, మరియు, నవీకరణ, వంటి
లూప్ లో ప్రతి పాయింట్ వద్ద కౌంటర్ వేరియబుల్.
అక్కడ చూడటానికి ఒక సాధారణ విషయం, కేవలం నేను + + ఉంది
ఇది 1 ప్రతిసారీ నేను పెంచడం అంటే.
మీరు, నేను + = 2 వంటి ఏదో ఒకటి కాలేదు
ఇది నేను మీరు లూప్ ద్వారా వెళ్ళి ప్రతిసారీ 2 జోడించండి అర్థం.
మరియు తర్వాత ఇది కేవలం వాస్తవానికి లూప్ భాగంగా నడుస్తుంది ఏ కోడ్ సూచిస్తుంది.
మరియు ఒక సమయంలో లూప్, ఈ సమయంలో మేము నిజానికి, లూప్ వెలుపల ప్రారంభ కలిగి
కాబట్టి, ఉదాహరణకు యొక్క మేము నేను పేర్కొన్న లూప్ యొక్క ఒకే రకమైన చేయడానికి ప్రయత్నిస్తున్న అని పిలవబడు.
మేము Int i = 0 లూప్ ముందే చెబుతారు.
I <10 ఈ విధంగా అప్పుడు, చెప్పగల్గినవి
ముందు వలె కోడ్ కాబట్టి అదే బ్లాక్,
మరియు ఈ సమయంలో ఉదాహరణకు కోడ్ నవీకరణ భాగంగా, నేను + +,
నిజానికి లూప్ యొక్క లోపల వెళుతుంది.
చివరకు, ఒక, అది అయితే లూప్ వలె యొక్క ఉన్నప్పుడు,
కానీ మేము కోడ్ ఒకసారి అంచనా వేసింది అని గుర్తుంచుకోండి
పరిస్థితి తనిఖీ ముందు, కాబట్టి ఇది చాలా అర్ధమే
మీరు పైనుంచి క్రమంలో అది చూడండి. ఉంటే
ఒక మీరు కూడా పరిస్థితి చూడండి ముందు లూప్ కోడ్ మదింపు ఉన్నప్పుడు,
ఒక సమయంలో లూప్ అయితే, అది మొదటి వెతుకుతుంది.
ప్రకటనలు మరియు వేరియబుల్స్.
మేము ఒక కొత్త కారకం సృష్టించాలనుకునే మేము మొదటి అది ప్రారంభించడం మీరు.
>> ఉదాహరణకు, Int బార్, వేరియబుల్ బార్ initializes
కానీ ఇప్పుడు బార్ యొక్క విలువ ఏమిటి, కనుక ఒక విలువ ఉండదు?
మనం చెప్పలేము.
ఇది మునుపటి మెమరీలో నిల్వ ఉన్నట్లు కొన్ని చెత్త విలువ ఉంటుంది
మరియు మేము ఆ వేరియబుల్ ఉపయోగించాలనుకుంటున్నాను లేదు
మేము దీన్ని ఒక విలువ ఇవ్వడం, వరకు
కాబట్టి మేము ఇక్కడ అది డిక్లేర్.
అప్పుడు మేము ఈ కింది 42 కు ప్రారంభించడం.
ఇప్పుడు, కోర్సు యొక్క, మేము ఈ ఒక పంక్తిలో, Int బార్ = 42 చేయవచ్చు తెలుసు.
కానీ, జరుగుతున్నాయి ఆ అనేక దశలను క్లియర్ చేయడానికి
ప్రకటన మరియు ప్రారంభ ఇక్కడ విడిగా సంభవిస్తున్నాయి.
ఇది తదుపరి, Int బాజ్ = బార్ + 1, ఒక దశలో జరుగుతుంది, మరియు
ఈ కోడ్ బ్లాక్ చివరిలో క్రింద ఈ ప్రకటన, ఆ ఇంక్రిమెంట్ బాజ్,
మేము బాజ్ యొక్క విలువ ముద్రించడానికి అయినప్పుడు 44 ఉంటుంది
మేము, ప్రకటించి 1> బార్ గా ఉండటం ప్రారంభించడం ఎందుకంటే
మరియు తర్వాత మేము తో మరోసారి అది పెంచడం + +.
మేము ఇది చాలా క్లుప్తంగా మీద వెళ్ళాడు, కానీ ఒక సాధారణ కలిగి మంచి
థ్రెడ్ మరియు సంఘటనలు ఏమిటో అర్ధం.
మేము ప్రధానంగా, స్క్రాచ్ ఈ చేశాడు
కాబట్టి మీరు కోడ్ పలు సన్నివేశాలు వంటి థ్రెడ్లు ఆలోచించవచ్చు
అదే సమయంలో అమలు.
వాస్తవానికి, ఇది బహుశా, అదే సమయంలో అమలులో లేదు
కానీ విధమైన బొత్తిగా మేము ఆ విధంగా అది కూడా ఆలోచించవచ్చు.
>> స్క్రాచ్ లో, ఉదాహరణకు, బహుళ స్ప్రిట్స్ వచ్చింది.
ఇది ఒకే సమయంలో వేర్వేరు కోడ్ అమలు చేయవచ్చు.
ఇతర ఏదైనా అని ఉన్నప్పుడు ఒకరోజు వాకింగ్ చేయవచ్చు
స్క్రీన్ వేరే భాగంలో.
ఈవెంట్స్ తర్కం వేరుచేసి యొక్క మరొక మార్గం
మీ కోడ్ వివిధ అంశాల మధ్య,
మరియు స్క్రాచ్ లో మేము, బ్రాడ్కాస్ట్ ఉపయోగించి ఘటనలను ప్రేరేపించడానికి సాధించారు
నేను అందుకున్నప్పుడు మరియు, నేను వినిపించడం లేదు చేసినప్పుడు, వాస్తవానికి ఉంది
కానీ ముఖ్యంగా ఇది సమాచారాన్ని ప్రసారం ఒక మార్గం
ఒక దేవదూత నుండి మరొక.
ఉదాహరణకు, మీరు, ఆట ప్రసారం చేయవచ్చు
మరియు మరొక దేవదూత మీద ఆట అందుకున్నప్పుడు,
ఒక నిర్దిష్ట మార్గంలో స్పందిస్తుంది.
ఇది కార్యక్రమాలను అర్థం ఒక ముఖ్యమైన మోడల్.
జస్ట్ ప్రాథమిక వీక్ 0 వెళ్ళి కు, మనం ఇప్పటివరకు పైగా మారారు,
యొక్క ఈ సులభమైన సి కార్యక్రమం చూద్దాం.
టెక్స్ట్ ఇక్కడ నుండి చిన్న కొద్దిగా ఉంటుంది, కాని దాన్ని పైగా నిజంగా శీఘ్ర వెళ్తారో.
మేము టాప్, cs50.h మరియు stdio.h వద్ద 2 శీర్షిక ఫైల్స్ చేస్తున్నారు.
మేము అప్పుడు 100 కు స్థిరమైన అని పరిమితి నిర్వచించు చేస్తున్నారు.
మేము అప్పుడు మా ప్రధాన విధి అమలు చేస్తున్నారు.
మేము ఇక్కడ ఆదేశ పంక్తి వాదనలు ఉపయోగించని నుండి మేము తప్ప ఉంచాలి
ప్రధాన కోసం వాదనలు.
మేము ప్రధాన పై Int చూడండి. తిరిగి టైప్ అదే, అందువలన క్రింద 0 తిరిగి.
మరియు మేము Int పొందండి CS50 లైబ్రరీ ఫంక్షన్ ఉపయోగించే
ఇన్పుట్ కోసం వినియోగదారు అడగండి మరియు మేము ఈ చరరాశి X లో నిల్వ చేయడంలో,
కాబట్టి మేము పైన x, మరియు మేము x = GetInt తో ప్రారంభించడం.
>> మేము అప్పుడు యూజర్ మాకు మంచి ఇన్పుట్ ఇచ్చింది అని తనిఖీ చేయండి.
అది ≥ LIMIT అయితే మేము 1 యొక్క ఒక లోపం కోడ్ తిరిగి మరియు ఒక దోష సందేశం ప్రింట్ మీరు.
చివరకు, యూజర్ మాకు ఇచ్చారు ఉంటే మంచి ఇన్పుట్
మేము సంఖ్య స్క్వేర్ మరియు ఫలితంగా ముద్రించాలా వెళుతున్న.
జస్ట్ నిర్ధారించడానికి ఆ హిట్ హోం అన్ని
మీరు ఇక్కడ కోడ్ వివిధ ప్రాంతాల యొక్క లేబుల్స్ చూడగలరు.
నేను స్థిరమైన, శీర్షిక ఫైళ్లు పేర్కొన్నారు.
ఓహ్, Int x. స్థానిక వేరియబుల్ గుర్తుంచుకోవాలి చేయండి.
అంటే గురించి మాట్లాడదాము ఇది ఒక ప్రపంచ వేరియబుల్ నుండి భిన్నంగా
కొద్దిగా తరువాత సమీక్ష సమావేశంలో,
మరియు మేము, printf లైబ్రరీ చర్యను కాల్ చేస్తారు
మేము stdio.h శీర్షికా ఫైలును చేర్చబడలేదు చేసింది అయితే
మేము printf కాల్ చెయ్యలేరు చేస్తుంది.
నేను ఇక్కడ నరికి దట్ గాట్ బాణం% d కు సూచిస్తుంది నమ్మకం
printf ఒక ఫార్మాటింగ్ స్ట్రింగ్ ఇది.
ఇది ఒక సంఖ్య,% d ఈ వేరియబుల్ ముద్రించాలా చెప్పారు.
ఆ వారం 0 ఇది ఉంది.
ఇప్పుడు లుకాస్ కొనసాగుతుంది అన్నారు.
హేయ్, guys. నా పేరు లుకాస్ ఉంది.
నేను, క్యాంపస్, మాథుర్ ఉత్తమంగా ఇంట్లో ఒక రెండవ ఉన్నాను
మరియు నేను వీక్ 1 మరియు 2.1 కొద్దిగా చర్చ వెళుతున్న.
[వీక్ 1 మరియు 2.1!] [లుకాస్ ఫ్రీటస్]
మేము మొదటి నుండి సి మీ కోడ్ అనువాదం మొదలు Lexi విధంగా ఉంది
మేము గమనించాము పనులు ఒకటి మీరు కేవలం నిజం కాదు
మీ కోడ్ వ్రాసి ఇకపై ఒక ఆకుపచ్చ ఫ్లాగ్ను ఉపయోగిస్తున్నారు అమలు.
అసలైన, మీరు మీ సి కార్యక్రమం చేయడానికి కొన్ని విధానాలను ఉపయోగించండి కలిగి
ఒక ఎక్జిక్యూటబుల్ ఫైల్ మారింది.
నిజానికి మీరు ఒక కార్యక్రమం వ్రాస్తున్నప్పుడు మీరు అని
మీరు, ఒక కంపైలర్ అర్థం ఒక భాష లోకి మీ ఆలోచన అనువదించు
మీరు C లో ఒక ప్రోగ్రామ్ రాస్తున్నాం కాబట్టి ఉన్నప్పుడు
మీరు చేయుచున్నారు నిజానికి మీ కంపైలర్ అర్థం అన్నారు ఏదో రాత,
ఆపై కంపైలర్ ఆ కోడ్ అనువదించు అన్నారు
మీ కంప్యూటర్ అర్ధం ఏదైనా లోకి.
>> మరియు విషయం, మీ కంప్యూటర్ వాస్తవానికి చాలా మూగ ఉంది.
మీ కంప్యూటర్ మాత్రమే, 0 సె మరియు 1s అర్ధం చేసుకోగలరు
కాబట్టి నిజంగా మొదటి కంప్యూటర్లలో ప్రజలు సాధారణంగా ప్రోగ్రామ్
ఇకపై 0 సె మరియు 1s, కానీ ఉపయోగించి, దేవుని ధన్యవాదాలు.
మేము 0 సె మరియు 1s కోసం సన్నివేశాలు గుర్తు లేదు
లూప్ లేదా కొంత లూప్ మరియు మొదలైనవి కోసం ఒక కోసం.
మేము ఒక కంపైలర్ ఎందుకు పేర్కొంది.
నా కంపైలర్ చేస్తుంది, ఇది ప్రాథమికంగా సి కోడ్ అనువదిస్తుంది ఉంది
మా సందర్భంలో, మీ కంప్యూటర్ అర్ధం అయ్యే భాష,
ఇది వస్తువు కోడ్, మరియు ఇక్కడ ఆ కంపైలర్ ఉంది
గణగణమని ద్వని చేయు అని పిలుస్తారు, ఈ వాస్తవానికి గణగణమని ద్వని చేయు కోసం గుర్తు.
మీరు మీ కార్యక్రమాన్ని కలిగి, మీరు 2 పనులు ఉన్నాయి.
మొదట, మీరు మీ కార్యక్రమాన్ని కంపైల్ చేయాలి, మరియు అప్పుడు మీరు మీ అమలు చూడాలని.
మీరు అలా ఎంపికలు చాలా మీ ప్రోగ్రామ్ తయారు చేసుకుని.
మొదటి ఒక గణగణమని ద్వని చేయు program.c ఏమి చేయాలో
దీనిలో ప్రోగ్రామ్ మీ ప్రోగ్రామ్ యొక్క పేరు.
ఈ సందర్భంలో మీరు అవి చెబుతున్న దాన్ని చూడవచ్చు "హే, నా ప్రోగ్రామ్ కంపైల్."
మీరు లేదా ఏదైనా "నా ప్రోగ్రామ్ కోసం ఈ పేరు మీరు" చెప్పడం లేదు.
>> రెండవ మీ ప్రోగ్రామ్ ఒక పేరు ఇచ్చి ఉంది.
అప్పుడు మీరు గణగణమని ద్వని చేయు-o మరియు మీకు కావలసిన పేరు చెప్పగలదు
ఎక్జిక్యూటబుల్ ఫైల్ మరియు తరువాత program.c పేరుతో.
మరియు మీరు కూడా కార్యక్రమం ఉందని, మరియు ఎలా మొదటి 2 సందర్భాలలో చూడగలరు
నేను. సి ఉంచారు, మరియు మూడవ నేను మాత్రమే కార్యక్రమాలు?
అవును, మీరు నిజంగా పెట్టలేదు ఉండాలి. సి మీరు తయారు ఉపయోగించేటప్పుడు.
లేకపోతే కంపైలర్ నిజానికి మీరు అరుస్తుంటారు అన్నారు.
మీరు అబ్బాయిలు గుర్తు ఉంటే కూడా, నేను, నాకు తెలియదు
కానీ మేము కూడా ఉపయోగించిన lcs50 లేదా LM సార్లు చాలా.
ఆ లింక్ అంటారు.
ఇది కేవలం, మీరు అక్కడే ఆ గ్రంథాలయాలు ఉపయోగించే కంపైలర్ చెబుతుంది
మీరు cs50.h ఉపయోగించడానికి మీరు అనుకుంటే మీరు నిజంగా టైప్ కలిగి
గణగణమని ద్వని చేయు program.c-lcs50.
మీరు అలా లేకపోతే, కంపైలర్ తెలుసుకోవటానికి వెళ్ళడం లేదు
మీరు cs50.h. ఆ ఫంక్షన్లను ఉపయోగించి చేస్తున్న
మరియు మీరు 2 ఎంపికలను మీ ప్రోగ్రామ్ను అమలు చేయడానికి ఉంటుంది.
మీరు గణగణమని ద్వని చేయు program.c పొతే మీ ప్రోగ్రామ్ ఒక పేరు ఇచ్చి లేదు.
మీరు. / A.out ఉపయోగించి అమలు చేయాలి.
A.out మీరు ఒక పేరు ఇచ్చి లేకపోతే గణగణమని ద్వని చేయు మీ ప్రోగ్రామ్ ఇచ్చే ప్రామాణిక పేరు.
మీరు మీ కార్యక్రమాన్ని ఒక పేరు ఇచ్చి పెడితే మీరు. / కార్యక్రమం చేయబోతున్నామని,
మీరు ప్రోగ్రామ్ పేరు తయారు చేస్తే మరియు ఒక ప్రోగ్రామ్ పొందగలిగిన అని
ఇప్పటికే సి ఫైల్ అదే పేరు ప్రోగ్రామ్ అన్నారు.
అప్పుడు మేము డేటా రకాలను మరియు డేటా మాట్లాడారు.
>> నిజానికి డేటా రకాల వారు ఉపయోగించే చిన్న బాక్సులను అదే విషయం ఉంటాయి
విలువలు నిల్వ, కాబట్టి డేటా రకాల కేవలం Pokémons వంటి ఉన్నాయి.
వారు అన్ని రకాల మరియు వస్తాయి.
ఆ సారూప్యత అర్ధమే ఉంటే నాకు తెలీదు.
డేటా పరిమాణం వాస్తవానికి యంత్రం నిర్మాణం మీద ఆధారపడి ఉంటుంది.
నేను ఇక్కడ చూపించబోతున్నాను అన్ని డేటా పరిమాణాలు
మా ఉపకరణం విషయంలో ఇది ఒక 32-bit మిషన్, కోసం ఉన్నాయి
కానీ మీరు నిజంగా మీ Mac లేదా Windows లో కూడా కోడింగ్ ఉంటే
బహుశా మీరు ఒక 64-bit మిషన్ చూడాలని
నేను వెళుతున్నాను అని డేటా పరిమాణాలు ఇక్కడ చూపడానికి గుర్తుంచుకోవాలి
32-bit మిషన్ కోసం ఉన్నాయి.
మేము చూసిన మొట్టమొదటి ఒక, ఒక పూర్ణాంకానికి ఉంది
ఇది చాలా సూటిగా ఉంటుంది.
మీరు ఒక పూర్ణాంకం నిల్వ Int ఉపయోగించండి.
మేము కూడా పాత్ర చార్ చూసింది.
మీరు ఒక అక్షరం లేదా కొద్దిగా గుర్తు ను ఉపయోగించడానికి మీరు బహుశా ఒక చార్ ఉపయోగించడానికి వెళుతున్న.
ఒక చార్ Lexi చెప్పినట్టూ 8 బిట్స్ అంటే 1 బైట్ కలిగి ఉంది.
నిజానికి మేము 256 కలిగి ఒక ASCII పట్టికను కలిగి
0 సె మరియు 1s యొక్క సాధ్యమైన కలయికల,
మరియు తర్వాత మీరు ఒక చార్ టైప్ చేసినప్పుడు అది అనువదించడానికి జరగబోతోంది
పాత్ర ఇన్పుట్లను మీరు Lexi వంటి ASCII పట్టిక కలిగి అనేక చెప్పారు.
మేము దశాంశ సంఖ్యలను నిల్వ చేయడానికి ఉపయోగించే ఫ్లోట్ కలిగి.
మీరు 3,14 ఎంచుకోవాలనుకుంటే, ఉదాహరణకు, మీరు ఒక ఫ్లోట్ ఉపయోగించడానికి వెళుతున్న
లేదా మరింత PRECISION కలిగి డబుల్.
ఫ్లోట్ 4 బైట్లు ఉంది.
ఒక డబుల్ 8 బైట్లు ఉన్నాయి, కాబట్టి మాత్రమే తేడా PRECISION ఉంది.
మేము కూడా, పూర్ణ సంఖ్యలు ఉపయోగించే కలిగి
మరియు మీరు, ఒక Int మరియు దీర్ఘ అదే పరిమాణం కలిగి 32-bit మిషన్ కోసం చూడగలరు
కనుక దీనిని ఒక వాస్తవిక 32-bit మిషన్ లో సుదీర్ఘ ఉపయోగించడానికి సమంజసం అనిపించుకోదు.
>> మీరు ఒక Mac మరియు 64-bit మిషన్ ఉపయోగించే అయితే, వాస్తవానికి సుదీర్ఘ, పరిమాణం 8 ఉంది
కాబట్టి ఇది నిజంగా నిర్మాణం మీద ఆధారపడి ఉంటుంది.
32-bit మిషన్ ఇది నిజంగా ఒక పెద్ద ఉపయోగించడానికి సమంజసం అనిపించుకోదు.
మరియు తర్వాత ఒక లాంగ్ లాంగ్, మరోవైపు, 8 బైట్లు ఉంది
మీరు సుదీర్ఘ పూర్ణాంక కావాలి కాబట్టి అది చాలా మంచిది.
చివరకు, మేము, అసలైన చార్ * ఇది స్ట్రింగ్ కలిగి
ఒక చార్ ఒక పాయింటర్ ఉంది.
ఇది స్ట్రింగ్ యొక్క పరిమాణం వలె అన్నారు అనుకొనే చాలా సులభం
మీరు అక్కడ ఆ పాత్రల సంఖ్య,
కానీ వాస్తవానికి చార్ * కూడా
4 బైట్లు ఒక చార్, ఒక పాయింటర్ యొక్క పరిమాణాన్ని కలిగి ఉంది.
ఒక చార్ * యొక్క పరిమాణం 4 బైట్లు.
మీరు ఒక చిన్న పదం లేదా ఒక అక్షరం లేదా ఏదైనా కలిగి ఉంటే అది పెద్ద విషయం కాదు.
ఇది 4 బైట్లు చేస్తాడు.
మేము కూడా, CASTING గురించి కొద్దిగా నేర్చుకున్నాను
మీరు కలిగి ఉంటే మీరు చూడగలరు గా, ఉదాహరణకు, ఒక ప్రోగ్రామ్ అని
Int x = 3 మరియు తరువాత printf ("% d", x / 2)
మీరు అబ్బాయిలు ఇది తెరపై ముద్రించడానికి ఏమి తెలుసు?
>> ఎవరో? >> [స్టూడెంట్స్] 2.
1. >> 1, అవును.
మీరు 3/2 చేసినప్పుడు అది, 1.5 పరుచుట కొరకు
మేము ఒక పూర్ణాంకం ఉపయోగించే నుండి కానీ, దశాంశ భాగంగా విస్మరించడానికి జరగబోతోంది
మరియు మీరు 1 చూడాలని.
మీరు, ఉదాహరణకు, మీరు చెయ్యగలరు జరిగే అనుకుంటే
ఫ్లోట్ డిక్లేర్ ఉంది y = x.
అప్పుడు 3 కలిగిన x ఇప్పుడు y లో 3,000 అవతరిస్తుంది.
ఆపై మీరు y / 2 ముద్రించవచ్చు.
అసలైన, నేను ఒక 2 ఉండాలి. అక్కడ.
ఇది 3.00/2.00 చేయడానికి జరగబోతోంది
మరియు మీరు 1.5 పొందడానికి వెళుతున్న.
మరియు మేము దశాంశ భాగంగా 2 దశాంశ యూనిట్లు ఎంటర్టైన్ ఈ 2 f ఉన్నాయి.
మీరు .3 F కలిగి ఉంటే ఇది నిజానికి 1.500 కలిగి జరగబోతోంది.
అది అయితే 2 అది 1.50 చేస్తాడు.
మేము కూడా ఇక్కడ ఈ కారణం ఉంది.
మీరు ఫ్లోట్ చేస్తే x = 3,14 ఆపై మీరు printf x
మీరు 3,14 పొందడానికి వెళుతున్న.
మరియు మీరు లేకపోతే x x యొక్క = Int,
ఒక పూర్ణాంకానికి వంటి x చికిత్స అంటే మరియు మీరు ఇప్పుడు ముద్రించవచ్చు x ఇది
మీరు 3.00 చూడాలని.
ఆ సమంజసం లేదు?
మీరు మొదటి పూర్ణాంకం వంటి x చికిత్స చేస్తున్నారు, కనుక మీరు, దశాంశ భాగంగా విస్మరించలేరు
మరియు తర్వాత మీరు x ప్రింటింగ్ చేస్తున్నారు.
మరియు చివరిగా, మీరు కూడా చేయవచ్చు
Int x = 65, ఆపై మీరు ఒక చార్ సి = x ప్రకటించి,
మీరు సి ప్రింట్ ఉంటే మరియు మీరు నిజంగా పొందడానికి వెళుతున్న
A, మీరు ఇక్కడ అలా ప్రధానంగా ఏమి
, పాత్ర లోకి పూర్ణాంక అనువాదం ఉంది
కేవలం వంటి ASCII టేబుల్ చేస్తుంది.
మేము కూడా గణిత ఆపరేటర్లు మాట్లాడారు.
వారిలో ఎక్కువ మంది అందంగా సూటిగా, అందుచే +, -, *, /,
మరియు మేము 2 సంఖ్యలను విభజన మిగిలిన ఇది mod, మాట్లాడారు.
మీరు ఉదాహరణకు 10% 3, కలిగి ఉంటే
ఇది 3 10 విభజించి అర్థం, మరియు మిగిలిన ఏమిటి?
ఇది 1 చేస్తాడు, కనుక ఇది కార్యక్రమాలు చాలా కోసం నిజంగా చాలా ఉపయోగకరంగా ఉంది.
విజెనెరే మరియు సీజర్ నేను మీరు అబ్బాయిలు అన్ని mod ఉపయోగించిన చాలా ఖచ్చితంగా అనుకుంటున్నాను.
* మరియు / కలపడం ఉన్నప్పుడు గణిత ఆపరేటర్లు గురించి చాలా జాగ్రత్తగా ఉండండి.
>> మీరు ఉదాహరణకు, (3/2) 2 మీరు పొందడానికి వెళ్తున్నారు?
[స్టూడెంట్స్] 2.
అవును, 2, 3/2 ఎందుకంటే 1.5 ఉండబోతుంది,
కానీ మీరు 2 పూర్ణాంకాల మధ్య కార్యకలాపాలు చేస్తున్నా నుండి
మీరు నిజానికి, 1 పరిగణలోకి చూడాలని
మరియు తర్వాత 1 * 2 2 మాత్రం ఉంది, కాబట్టి చాలా జాగ్రత్తగా
పూర్ణాంకాల తో అంకగణితం చేస్తున్నప్పుడు ఎందుకంటే
మీరు ఆ సందర్భంలో, ఆ 2 = 3 పొందండి ఉండవచ్చు.
మరియు కూడా ప్రాధాన్యత గురించి చాలా జాగ్రత్తగా ఉండండి.
సాధారణంగా మీరు మీరు చేస్తున్న ఏమి తెలుసు నిర్ధారించుకోండి కు కుండలీకరణాలు ఉపయోగించాలి.
కొన్ని ఉపయోగకరమైన సత్వరమార్గాలు, కోర్సు యొక్క, ఒక నేను + + లేదా నేను + = 1
ఉపయోగించడం + =.
నేను = నేను + 1 చేయడం అదే విషయం.
మీరు కూడా ఐ కెన్ డు - లేదా నేను - = 1,
ఇది, i = i -1 అదే విషయం
ఏదో మీరు అబ్బాయిలు కనీసం, ఉచ్చులు కోసం చాలా ఉపయోగిస్తాయి.
అలాగే, *, మీరు * = మరియు మీరు ఒకవేళ, ఉదాహరణకు ఉపయోగిస్తే,
నేను * = 2 i = i * 2 మాట్లాడుతూ అదే విషయం,
మరియు విభజన ఒకే విషయం.
మీరు i / = 2 చేస్తే అది i = i / 2 అదే విషయం.
>> ఇప్పుడు విధులు గురించి.
మీరు అబ్బాయిలు విధులు కోడ్ సేవ్ ఒక మంచి వ్యూహం అని నేర్చుకున్నాడు
మీరు ప్రోగ్రామింగ్ చేస్తున్న సమయంలో, మీరు అదే పని అనుకుంటే
కోడ్ మళ్ళీ మళ్ళీ బహుశా మీరు ఒక ఫంక్షన్ ఉపయోగించాలనుకుంటున్నాను
కేవలం మీరు మళ్ళీ మరియు పైగా కోడ్ కాపీ మరియు పేస్ట్ లేదు.
అసలైన, ప్రధాన క్రియ, నేను ఒక ఫంక్షన్ యొక్క ఫార్మాట్ ప్రదర్శన
మీరు ఆ అందంగా స్పష్టమైన ఉందని చూడాలని.
మేము కూడా, కొన్ని లైబ్రరీలు విధులు ఉపయోగించడానికి
ఉదాహరణకు, printf, CS50 లైబ్రరీ నుండి ఇది GetIn,
మరియు toupper వంటి ఇతర పనిచేస్తుంది.
ఆ విధులను అన్ని వాస్తవానికి, ఇతర గ్రంథాలయాల్లో అమలు
మరియు మీరు మీ కార్యక్రమం ప్రారంభంలో ఆ పగ్గము ఫైళ్లను ఉంచారు ఉన్నప్పుడు
మీరు నాకు ఆ ప్రక్రియలకు కోడ్ తెలపండి చెప్పడం చేస్తున్నారు
కాబట్టి నేను వాటిని అమలు లేదు?
మరియు మీరు కూడా మీరు ప్రోగ్రామింగ్ ప్రారంభించిన కాబట్టి, మీ స్వంత విధులు రాయడం
మీరు గ్రంథాలయాలు మీరు అవసరం అన్ని విధులు లేని తెలుసుకుంటారు.
గత pset కోసం, ఉదాహరణకు,,, పెనుగులాట గీసి, వెతికే రాశాడు
మరియు ఇది ఫంక్షన్లు వ్రాయండి చెయ్యడానికి చాలా ముఖ్యం
వారు ఉపయోగపడతాయి, మరియు మేము వాటిని ప్రోగ్రామింగ్ అన్ని సమయం ఉపయోగిస్తాయి,
మరియు అది కోడ్ చాలా సేవ్ చేస్తుంది.
ఒక చర్య యొక్క ఫార్మాట్ ఈ ఒకటి.
మేము ప్రారంభంలో తిరిగి టైపు. తిరిగి ఏ రకం?
మీ విధి తిరిగి వెళ్ళడం ఉన్నప్పుడు కేవలం ఉంది.
మీరు కారకమైన ఉదాహరణకు ఒక ఫంక్షన్, కలిగి ఉంటే
ఆ, పూర్ణాంకం యొక్క ఒక కారకమైన లెక్కించేందుకు అన్నారు
బహుశా దీన్ని కూడా పూర్ణాంకం తిరిగి వెళుతున్న.
అప్పుడు తిరిగి టైప్ Int అని అన్నారు.
Printf వాస్తవానికి తిరిగి టైప్ తప్ప ఉంది
మీరు ఏదైనా తిరిగి లేదు ఎందుకంటే.
మీరు స్క్రీన్ విషయాలను ప్రింటింగ్ చేసిన
మరియు తర్వాత ఫంక్షన్ త్యజించడం.
అప్పుడు మీరు ఎంచుకోవచ్చు ఆ చర్య యొక్క పేరును కలిగి ఉంటాయి.
XYZ వంటి ఒక పేరును ఎంచుకోండి లేదు మీకు, కొద్దిగా సహేతుకమైన ఉండాలి
లేదా x2f ఇష్టపడుతున్నారు.
అర్ధమే ఒక పేరు తయారు చేయడానికి ప్రయత్నించండి.
>> ఉదాహరణకు, కారకమైన అయితే, కారకమైన చెప్పారు.
అది ఏదో డ్రా వెళ్ళి ఒక ఫంక్షన్ ఉంది, అది డ్రా పేరు.
మరియు తర్వాత మేము కూడా వాదనలు పిలవబడే పారామితులు, కలిగి
మీ పనితీరు అవసరమైన వనరులను మాదిరిగా ఉంటాయి
మీ కోడ్ నుంచి పని.
మీరు అనేక కారకమైన లెక్కించేందుకు చేయాలనుకుంటే
probably మీరు ఒక కారకమైన గణించడానికి ఒక సంఖ్య అవసరం.
మీరు చూడాలని ఆ వాదనలు ఒకటి సంఖ్య ఉంటుంది.
అది ఏదో ఒకటి మరియు చివరికి వద్ద విలువ తిరిగి వెళుతున్న
అది ఒక గర్జన ఫంక్షన్ ఉంది తప్ప.
యొక్క ఒక ఉదాహరణ చూడండి లెట్.
నేను, పూర్ణాంకాల వ్యూహం అన్ని సంఖ్యలు సూచించే ఒక ఫంక్షన్ రాయడానికి మీరు అనుకుంటే
అన్ని మొదటి, తిరిగి టైప్ Int అవతరిస్తుంది
నేను పూర్ణాంకాల వ్యూహం ఎందుకంటే.
మరియు నేను, sumArray వంటి పని పేరు కలిగి వెళుతున్న
మరియు అప్పుడు, Int nums కు, అర్రే కూడా తీసుకోవాలని జరగబోతోంది
తరువాత నేను సంకలనం ఎన్ని సంఖ్యలు తెలుసు కాబట్టి శ్రేణి యొక్క పొడవు.
అప్పుడు నేను 0 to ఉదాహరణకు ఒక వేరియబుల్ అని మొత్తం, ప్రారంభించడం కలిగి
మరియు నేను శ్రేణి ఒక మూలకం చూడండి ప్రతి సమయం నేను మొత్తం జోడించడానికి ఉండాలి, నేను లూప్ ఒక చేశాడు.
Lexi చెప్పారు వలె, మీరు Int i = 0, i <పొడవు మరియు నేను + +.
మరియు యెరే నందలి ప్రతి మూలకం కోసం నేను మొత్తం + = nums [i] చేసాడు,
మరియు నేను మొత్తం తిరిగి, కాబట్టి ఇది చాలా సులభం, మరియు అది కోడ్ చాలా ఆదా
మీరు ఈ ఫంక్షన్ సార్లు చాలా ను ఉపయోగిస్తున్నట్లయితే.
అప్పుడు మేము పరిస్థితులు వద్ద చూడటం జరిగింది.
మేము వేరే ఉంటే కలిగి, మరియు మిగిలిన ఉంటే.
ఆ మధ్య తేడా ఏమిటి చూద్దాం.
ఈ 2 సంకేతాలు వద్ద టేక్ ఎ లుక్. వాటి మధ్య తేడా ఏమిటి?
మొదటి ఒక ప్రాథమికంగా సంకేతాలు మీకు తెలియజేయాలని అనుకుంటున్నారా
, లేదా 0 - అనేక +, ఉంటే.
మొదటి దానిని> 0 అయితే అప్పుడు అనుకూల యొక్క చెప్పారు.
ఇది 0 to = అయితే అప్పుడు 0, అది <0 అయితే అప్పుడు ప్రతికూల ఉంది.
>> ఇంకా, ఒకవేళ వేరే ఉంటే ఇతర ఒక చేస్తోంది.
ఈ రెండింటి మధ్య వ్యత్యాసం ఈ ఒక నిజానికి అన్నారు ఉంది
తనిఖీ ఉంటే> 0, <0 లేదా = 0 మూడు సార్లు,
మీరు సంఖ్య 2 కలిగి అయితే, ఉదాహరణకు, ఇది ఇక్కడ వచ్చి చెప్పడానికి జరగబోతోంది
అది అవును చెప్పడానికి జరగబోతోంది (x> 0) ఉంటే, నేను మంచి ప్రింట్.
కాని దాన్ని> 0 అని తెలిసిన మరియు అది 0 లేదా <0 గా మాత్రం కాదు అయినప్పటికీ
నేను ఇంకా 0 చేయ బోతున్నాను, అది, <0
నేను నిజానికి నేను లేదు అని IFS లోపలి వెళుతున్న
నేను ఇప్పటికే ఈ పరిస్థితులు ఏవైనా సంతృప్తి మాత్రం కాదు తెలుసు ఎందుకంటే.
నేను ప్రకటన else, ఉంటే వేరే ఉంటే ఉపయోగించవచ్చు.
X = 0 నేను పాజిటివ్ ప్రింట్ ఉంటే ఇది ప్రాథమికంగా చెప్పారు.
అలా కాకపోతే, నేను కూడా ఈ పరీక్ష వెళుతున్న.
ఇది 2 అయితే నేను దీన్ని వెళుతున్న కాదు.
నేను x = 2 కలిగి ఉంటే ప్రాథమికంగా మీరు చెప్పిన విధంగా
(x> 0) ఉంటే, అవును, ఈ ప్రింట్.
ఇప్పుడు నేను> 0 అని తెలిసిన మరియు అది మొదటి ఉంటే సంతృప్తి
నేను కూడా ఈ కోడ్ అమలు చేయడానికి వెళ్ళడం లేదు.
మీరు ఈ ఉపయోగిస్తే కోడ్ 3 రెట్లు వేగవంతమైన, వాస్తవానికి, వేగంగా నడుస్తుంది.
మేము కూడా గురించి మరియు మరియు లేదా నేర్చుకున్నాడు.
నేను Lexi ఇప్పటికే వారిని గురించి మాట్లాడారు ఎందుకంటే ఈ ద్వారా వెళ్ళడానికి వెళ్ళడం లేదు.
| ఆపరేటర్లు | అది && మరియు ఉంటుంది.
>> నేను మీరు మాత్రమే విషయం మీరు 3 పరిస్థితులు ఉన్నప్పుడు జాగ్రత్తగా ఉంది.
ఇది చాలా గందరగోళంగా ఎందుకంటే మీరు ఒక పరిస్థితి ఉన్నప్పుడు రేఖల వినియోగం
మరియు మరొక ఒకటి లేదా మరొక ఒకటి.
మీ పరిస్థితులు సమంజసం అని మీరు అని రేఖల వినియోగం
ఆ సందర్భంలో, ఉదాహరణకు, మీరు ఊహించే ఎందుకంటే ఆ
అది మొదటి పరిస్థితి మరియు ఒకటి లేదా ఇతర ఉంటుంది
లేదా 2 ఒక మిళితం పరిస్థితులు మరియు
లేదా మూడవ ఒక, కాబట్టి జాగ్రత్త వహించాలి.
చివరకు, మేము స్విచ్లు మాట్లాడారు.
మీరు ఒక వేరియబుల్ తర్వాత ఒక స్విచ్ చాలా ఉపయోగకరంగా ఉంటుంది.
మీరు n వంటి వేరియబుల్ అని చెప్పారు
ఆ 0, 1, లేదా 2 ఉంటుంది, మరియు ఆ కేసులు ప్రతి
మీరు ఒక పని వెళుతున్న.
మీరు వేరియబుల్ మారడానికి చెప్పగలదు, మరియు అది సూచిస్తుంది
విలువ అప్పుడు, విలువ 1 అని నేను దీన్ని వెళుతున్న ఉంది
మరియు నేను బ్రేక్, ఇది నేను ఇతర కేసుల్లో ఏ కు వెళ్ళడం లేదు అంటే
మేము ఇప్పటికే ఆ సందర్భంలో సంతృప్తి ఎందుకంటే
ఆపై VALUE2 మొదలగునవి మరియు నేను కూడా ఒక డిఫాల్ట్ స్విచ్ ఉండవచ్చు.
నేను కలిగి కేసులు ఏ సంతృప్తి ఒకవేళ అర్థం
నేను ఇంకా ఏదో ఒకటి వెళుతున్న, కానీ ఆ ఇచ్చాపూరితం ఆ.
నాకు అన్ని పేర్కొంది. ఇప్పుడు యొక్క టామీ వివరించారు.
అన్ని కుడి, ఈ వారం 3-ish అవతరిస్తుంది.
ఈ మేము, et సెటేరా crypto, స్కోప్, శ్రేణులు, కవరింగ్ వస్తుంది విషయాలు ఉన్నాయి.
Crypto కేవలం శీఘ్ర పదం. మేము ఈ Home హామర్ వెళ్ళి లేదు.
>> మేము pset 2 లో ఈ, కానీ క్విజ్ కోసం మీరు తేడా తెలుసు నిర్ధారించుకోండి
సీజర్ సాంకేతికలిపి మరియు విజెనెరే సాంకేతికలిపి మధ్య,
ఆ సాంకేతికలిపులు పని రెండు మరియు దానిని గుప్తీకరించడానికి వంటి ఎలా
ఆ 2 సాంకేతికలిపులు ఉపయోగించి మరియు వ్యక్తీకరించడానికి టెక్స్ట్.
గుర్తుంచుకోండి, సీజర్ సాంకేతికలిపి కేవలం ఒకే పరిమాణం ప్రతి పాత్ర తిరుగుతూ
వర్ణమాల అక్షరాలను సంఖ్య ద్వారా మీరు mod చూసుకోవాలి.
మరియు విజెనెరే సాంకేతికలిపి, మరోవైపు, ప్రతి పాత్ర తిరుగుతూ
వేరే మొత్తం ద్వారా, కాబట్టి బదులుగా చెప్పడం కంటే
3 విజెనెరే ద్వారా ప్రతి పాత్ర తిప్పి ప్రతి పాత్ర తిరుగుతాయి
కొన్ని కీవర్డ్ ఆధారంగా ఒక విభిన్న మొత్తం ద్వారా
కీవర్డ్ లో ప్రతి అక్షరం కొన్ని వివిధ మొత్తం సూచిస్తుంది పేరు
ద్వారా స్పష్టమైన టెక్స్ట్ తిప్పడానికి.
వేరియబుల్ స్కోప్ గురించి మొదటి చర్చ యొక్క లెట్.
చరరాశుల 2 వివిధ రకాలు.
మేము స్థానిక వేరియబుల్స్ ఉన్నాయి, మరియు ఈ నిర్వచించవచ్చు వెళ్ళే
బయట ప్రధాన లేదా ఏదైనా ఫంక్షన్ లేదా బ్లాక్ వెలుపల,
మరియు ఈ ప్రోగ్రామ్ మీ ఎక్కడైనా యాక్సెస్ చేయబడుతుంది.
మీరు ఒక చర్య మరియు ఆ ఫంక్షన్ లో ఒక సమయంలో లూప్ ఉంటే
పెద్ద ప్రపంచ వేరియబుల్ ప్రతిచోటా అందుబాటులో ఉంది.
ఒక స్థానిక వేరియబుల్, మరోవైపు, ఇది నిర్వచించబడింది ప్రదేశాన్ని దర్శిని గల ఉంది.
>> మీరు ఇక్కడ ఒక ఫంక్షన్ కలిగి ఉంటే, ఉదాహరణకు, ఈ ఫంక్షన్ g కలిగి
మరియు G లోపలి Y అని ఇక్కడ ఒక వేరియబుల్ ఉంది
మరియు ఈ ఒక స్థానిక వేరియబుల్ అని అర్థం.
ఈ వేరియబుల్ y అనే అయినప్పటికీ
మరియు ఈ వేరియబుల్ ఈ 2 విధులు Y అని పిలుస్తారు
ఒకరి స్థానిక వేరియబుల్స్ ఏమిటో సంఖ్య ఆలోచన ఉంది.
మరోవైపు, ఇక్కడ మేము, Int x = 5 సే
మరియు ఈ ఏదైనా ఫంక్షన్ యొక్క పరిధిని వెలుపల ఉంది.
ఇది ప్రధాన పరిధి బయట, కనుక ఈ ప్రపంచ చరరాశి.
లేదా x + + - నేను x చెప్పినప్పుడు మీరు ఈ 2 విధులను ఆ లోపల అర్థం
నేను ఈ Y మరియు ఈ y వివిధ వేరియబుల్స్ చేస్తుంది, తద్వారా అదే x యాక్సెస్ చేస్తున్నాను.
ప్రపంచ వేరియబుల్ మరియు ఒక స్థానిక వేరియబుల్ మధ్య వ్యత్యాసం పేర్కొంది.
చాలా డిజైన్ సంబంధించినంతవరకు, కొన్నిసార్లు అది ఒక మంచి ఆలోచన
మీరు బహుశా చెయ్యవచ్చు చేసినప్పుడు వేరియబుల్స్ స్థానిక ఉంచడానికి
కలిగి నుండి ప్రపంచ వేరియబుల్స్ యొక్క కొంత నిజంగా గందరగోళంగా పొందవచ్చు.
మీరు విధులను కొంత ఉంటే ఒకే విషయం సవరించుట
ఈ ఫంక్షన్ అనుకోకుండా ఈ ప్రపంచ మార్పు ఏం మీరు, మర్చిపోతే ఉండవచ్చు
మరియు ఈ ఇతర ఫంక్షన్, దాని గురించి తెలియదు
మీరు మరింత కోడ్ పొందండి మరియు ఇది అందంగా గందరగోళంగా పొందండి లేదు.
మీరు బహుశా చెయ్యవచ్చు చేసినప్పుడు వేరియబుల్స్ స్థానిక కీపింగ్
కేవలం మంచి నమూనా.
వ్యూహాలను, గుర్తుంచుకోండి, కేవలం ఒకే రకమైన అంశాల జాబితా ఉంటాయి.
CI యొక్క ఇన్సైడ్ హలో, 1, 2.0 వంటి జాబితా ఉండకూడదు.
మేము అలా కాదు.
>> మేము సి లో వ్యూహం డిక్లేర్ చేసినప్పుడు అన్ని మూలకాల ఒకే రకమైన ఉండాలి.
ఇక్కడ నేను 3 పూర్ణాంకాల యొక్క వ్యూహం ఉంది.
ఇక్కడ నేను శ్రేణి పొడవు ఉన్నాయి, కాని నేను ఈ వాక్యనిర్మాణంలో అది ప్రకటించారు నేను ఉంటే
నేను అన్ని మూలకాల నేను సాంకేతికంగా ఈ 3 అవసరం లేదు ఏమిటో పేర్కొనండి పేరు.
కంపైలర్ అర్రే అయి ఉండాలి ఎంత పెద్ద గుర్తించడానికి తగినంత స్మార్ట్ ఉంది.
ఇప్పుడు నేను ఒక అర్రే విలువ పొందడానికి లేదా సెట్ ఉంటుంది
ఈ అలా సింటెక్స్ ఉంది.
, గుర్తు ఎందుకంటే ఇది వాస్తవానికి శ్రేణి యొక్క రెండో మూలకం సవరించడానికి కనిపిస్తుంది,
సంఖ్యా 1 కాదు, 0 మొదలవుతుంది.
నేను ఆ విలువ చదవాలనుకుంటున్న ఉంటే నేను లాగ చెప్పగలదు Int x = శ్రేణి [1].
నేను ఆ విలువ సెట్ అనుకుంటే లేదా, అని నేను, ఇక్కడ చేస్తున్నదాన్ని
నేను శ్రేణి [1] చెప్పగలదు = 4.
వారి ఇండెక్స్ ద్వారా అంశాలను యాక్సెస్ ఆ సమయంలో
లేదా వారి స్థానం లేదా వారు శ్రేణి ఉన్నాయి,
మరియు ఆ జాబితా 0 మొదలవుతుంది.
మేము కూడా, శ్రేణుల యొక్క శ్రేణుల కలిగి
మరియు ఈ బహుళ పరిమాణాల శ్రేణి అంటారు.
మేము ఒక బహుళ పరిమాణాల శ్రేణి ఉన్నప్పుడు
మేము, వరుసలు మరియు కాలమ్లను లాగ కలిగి అనగా
మరియు ఈ ఈ భావన లేదా దాని గురించి ఆలోచిస్తున్నామని ఇది ఒక మార్గం ఉంది.
నేను ఒక బహుళ పరిమాణాల శ్రేణి ఉన్నప్పుడు నేను అవసరం ప్రారంభం వెళుతున్న అర్థం
పైగా 1 ఇండెక్స్ ఎందుకంటే నేను గ్రిడ్ ఉంటే
కేవలం మీరు ఏమి చేస్తున్నామో వరుస మాట్లాడుతూ మాకు అనేక ఇవ్వదు.
ఇది నిజంగా కేవలం మాకు సంఖ్యల జాబితా ఇవ్వాలని జరగబోతోంది.
లెట్ యొక్క నేను ఇక్కడ ఈ శ్రేణి కలిగి చెప్పారు.
నేను గ్రిడ్ అని వ్యూహం లేదు, నాకు, అది యొక్క 2 వరుసలు మరియు నిలువు 3 మాట్లాడుతూ నేను
మరియు ఈ దానిని ఊహించుకోవడానికి ఒక మార్గం.
నేను [1] వద్ద మూలకం పొందడానికి అనుకుందాం చేసినప్పుడు [2]
ఈ వరుసలు మొదటి మరియు తర్వాత నిలువు ఎందుకంటే అర్థం
నేను 1 చెప్పారు నుండి 1 వరుస వెళ్లగలదు వెళుతున్న.
>> అప్పుడు నేను కాలమ్ 2 ఇక్కడ పైగా వచ్చి వెళుతున్న మరియు నేను విలువ 6 పొందడానికి వెళుతున్న.
సమంజసం?
మల్టీ డైమెన్షనల్ శ్రేణులను గుర్తుంచుకోండి, సాంకేతికంగా శ్రేణుల యొక్క కేవలం వ్యూహం ఉంటాయి.
మేము శ్రేణుల యొక్క శ్రేణుల యొక్క శ్రేణుల ఉండవచ్చు.
మేము కొనసాగించడాన్ని, కానీ గురించి భావిస్తున్నాను ఒక మార్గం
ఈ ఏర్పాటు ఉంది మరియు ఏం జరగబోతోంది ఎలా చూసేందుకు ఉంది
ఈ వంటి ఒక గ్రిడ్లో.
మేము విధులకు శ్రేణుల పాస్, వారు ప్రవర్తించే చూడాలని
మేము విధులకు సాధారణ వేరియబుల్స్ పాస్ కంటే భిన్నంగా కొద్దిగా
ఒక పూర్ణాంకానికి లేదా ఫ్లోట్ ప్రయాణిస్తున్న ఇష్టపడుతున్నారు.
మేము ఒక పూర్ణాంకానికి లేదా చార్ లేదా ఈ ఇతర డేటా ఏ రకాల పాస్ చేసినప్పుడు
మేము కేవలం ఫంక్షన్ మార్పు ఉంటే పరిశీలించి పట్టింది
మార్పు అప్ ప్రచారం చెయ్యడానికి వెళ్ళడం లేదు అని ఆ వేరియబుల్ విలువ
కాలింగ్ కు.
వ్యూహం తో, మరోవైపు, ఆ జరగవచ్చు.
నేను కొన్ని కు వ్యూహంలో పాస్ మరియు ఆ ఫంక్షన్, మూలకాల యొక్క కొన్ని మార్పులు ఉంటే
నేను దీనిని ఆ ఫంక్షన్ వరకు తిరిగి వచ్చినప్పుడు
నా శ్రేణి ఇప్పుడు భిన్నంగా కు వెళ్ళి ఆ కోసం పదజాలం
మేము తరువాత చూస్తారు వంటి ఉంది శ్రేణులను సూచనగా పంపుతారు.
ఈ ఎలా గమనికలు పని, పేరు ఈ ప్రాథమిక డేటా రకాల సంబంధించినది
మరోవైపు, విలువ ద్వారా పంపుతారు.
>> మేము కొన్ని వేరియబుల్ ఒక నకలు తరువాత నకలుతీయి అక్కడ ఆ యొక్క ఆలోచించవచ్చు.
ఇది ఆ వేరియబుల్ ఏం పట్టింపు లేదు.
కాల్ ఫంక్షన్ మార్చబడింది తెలుసుకోండి కాదు.
వ్యూహాలను ఆ విషయంలో వివిధ కేవలం కొద్దిగా ఉంటాయి.
మేము ఇప్పుడు చూసిన వంటి ఉదాహరణకు, ప్రధాన కేవలం ఒక విధి
ఆ 2 వాదనలు లో పడుతుంది.
ప్రధాన విధి మొదటి వాదన, argc, లేదా వాదనలు సంఖ్య
మరియు రెండవ వాదన, argv అంటారు
మరియు ఆ ఆ వాదనలు వాస్తవ విలువలు.
లెట్ యొక్క, నేను this.c అనే ప్రోగ్రామ్ను సే
మరియు నేను ఈ చేయడానికి, మరియు నేను కమాండ్ లైన్ వద్ద ఈ అమలు వెళుతున్న.
ఇప్పుడు నా ప్రోగ్రామ్ కొన్ని వాదనలు లో పాస్, అని
నేను ఏదో వంటి చెప్పొచ్చు. / ఈ CS 50.
ఈ మేము టెర్మినల్ వద్ద ప్రతి రోజు డేవిడ్ చేయడానికి ఊహించుకోండి ఏమిటి.
ఆ ప్రోగ్రాం యొక్క కానీ ఇప్పుడు ప్రధాన విధి లోపల
ఈ విలువలు ఉన్నాయి, కాబట్టి argc 4 ఉంటుంది.
మేము మాత్రమే CS 50 అక్కడ ఉన్నందున ఇది కొద్దిగా గందరగోళంగా ఉండవచ్చు.
మాత్రమే 3 యొక్క.
కానీ గుర్తు ఆ argv మొదటి మూలకం లేదా మొదటి వాదన
ఫంక్షన్ యొక్క పేరు.
కాబట్టి, మనం ఇక్కడ 4 విషయాలు ఉండవు
మరియు మొదటి మూలకం. / ఇది అన్నారు.
మరియు ఈ స్ట్రింగ్ వంటి ప్రాతినిధ్యం చేయబడుతుంది.
తరువాత మిగిలిన అంశాలను మేము ప్రోగ్రామ్ యొక్క పేరు తర్వాత టైప్ చేసిన ఉపయోగించలేరు.
కాబట్టి పక్కన కేవలం ఒక, మేము బహుశా pset 2 చూసిన వంటి,
స్ట్రింగ్ 50 పూర్ణాంక 50 ≠ గుర్తుంచుకోండి.
కాబట్టి మేము వంటి ఏదో చెప్పలేను 'Int x = argv 3.'
>> ఈ స్ట్రింగ్ ఎందుకంటే అది, సమంజసం మాత్రం కాదు, మరియు ఈ ఒక పూర్ణ సంఖ్య.
మీరు 2 మధ్య మార్చేందుకు అనుకుంటే, గుర్తుంచుకోండి, మేము వెళుతున్నాం
atoi అని ఈ మాయా చర్య.
ఒక స్ట్రింగ్ తీసుకుని ఆ స్ట్రింగ్ లోపల ప్రాతినిధ్యం పూర్ణాంక తిరిగి.
అందువలన క్విజ్ న చేయడానికి సులభమైన తప్పు ఉంది
ఈ స్వయంచాలకంగా సరైన పద్ధతి అని ఆలోచిస్తూ.
కానీ ఈ ఎల్లప్పుడూ తీగలను అని తెలుసు
స్ట్రింగ్ మాత్రమే పూర్ణాంకం లేదా ఒక అక్షరం లేదా ఫ్లోట్ కలిగి ఉన్నప్పటికీ.
కాబట్టి ఇప్పుడు యొక్క అమలు సమయం గురించి మాట్లాడేందుకు అనుమతిస్తాయి.
మేము ఈ క్రేజీ పనులను అన్ని ఈ క్రమసూత్ర ఉన్నప్పుడు,
అది, అడుగుతున్న ప్రశ్న నిజంగా ఉపయోగకరంగా మారుతుంది "వారు ఎంత సమయం పడుతుంది చెయ్యాలి?"
మేము asymptotic సంజ్ఞామానం అనే ఆ సూచిస్తాయి.
అలాగే, యొక్క మేము మా అల్గోరిథం ఇవ్వాలని అని పిలవబడు - కాబట్టి ఈ అర్థం
కొన్ని నిజంగా, నిజంగా పెద్ద ఇన్పుట్.
మేము ప్రశ్న కోరవలసి, "ఎంత తీసుకోబడుతుంది ఉండబోతుంది?
ఎన్ని చర్యలు అమలు మా అల్గోరిథం పడుతుంది
ఇన్పుట్ పరిమాణం యొక్క విధిగా? "
కాబట్టి మేము అమలు సమయం వివరిస్తుంది మొదటి మార్గం పెద్ద O. తో
మరియు ఈ మా చెత్త-సందర్భంలో రన్నింగ్ సమయం ఉంది.
మేము ఒక అర్రే క్రమం మీరు అనుకుంటే, మరియు మేము మా అల్గోరిథం వ్యూహం ఇవ్వాలని
అది ఆరోహణ క్రమంలో ఉండాలి ఆ, క్రమం యొక్క
ఆ విషయంలో చేస్తాడు.
ఈ మా అల్గోరిథం పడుతుంది సమయం గరిష్ట పొడవు కట్టుబడి మా ఉన్నత ఉంది.
మరోవైపు, ఈ Ω ఉత్తమ కేసు నడుస్తున్న సమయంలో వివరించడానికి అన్నారు.
మేము వేరు అల్గోరిథం ఒక ఇప్పటికే క్రమబద్ధీకరించబడతాయి శ్రేణి ఇస్తుంది అయితే,
ఇది క్రమం ఎంత కాలం అది పడుతుంది?
మరియు ఈ, అప్పుడు, అమలు సమయం లో తక్కువ బౌండ్ వివరిస్తుంది.
ఇక్కడ కొన్ని సాధారణ నడుస్తున్న కాలంలో వివరించే కొన్ని పదాలు.
ఈ క్రమంలో ఉంటాయి.
మేము కలిగి వేగంగా అమలు సమయం స్థిరంగా అంటారు.
>> మేము మా అల్గోరిథం ఇవ్వాలని ఎన్ని అంశాలు ఉన్నా, అనగా
మా శ్రేణి క్రమీకరించడం, ఎలా పెద్దది ఉన్నా
లేదా మేము శ్రేణి చేస్తున్నా ఏమి ఎప్పుడూ సమయం యొక్క అదే మొత్తం పడుతుంది.
కాబట్టి మేము కేవలం ఒక స్థిరాంకం ఒక 1, ఆ సూచిస్తుంది.
మేము కూడా సంవర్గమాన పరుగుల సమయంలో కనిపించింది.
కాబట్టి బైనరీ శోధన లాగ, సంవర్గమాన ఉంది
మేము సగం ప్రతిసారీ సమస్య కట్ పేరు
మరియు తర్వాత విషయాలు అక్కడే నుండి అధిక పొందండి.
మరియు మీరు ఏ కారకమైన అల్గోరిథం యొక్క ఒక O రాస్తున్నాం ఉంటే,
మీరు బహుశా మీ రోజు పని ఈ పరిగణలోకి లేదు.
మేము అమలు సార్లు పోల్చి అది దృష్టిలో ఈ విషయాలను ముఖ్యం.
నేను ఒక O (n) అని అల్గోరిథం, మరియు ఇతరులు కలిగి అయితే
O యొక్క ఒక అల్గోరిథం (2N) ఈ వాస్తవానికి asymptotically సమానమైన ఉన్నాయి.
మేము eleventy బిలియన్ వంటి పెద్ద సంఖ్య అని n ఊహించిన అయితే:
కాబట్టి మేము eleventy బిలియన్ లాగ + 3 eleventy బిలియన్ పోల్చడం చేసినప్పుడు,
అకస్మాత్తుగా ఆ +3 నిజంగా ఇకపై ఒక పెద్ద మార్పు లేదు.
మేము ఈ విషయాలు సమానంగా భావించి ఆరంభమవుతుంది చేసిన ఎందుకు పేర్కొంది.
ఇక్కడ ఈ స్థిరాంకాలు వంటి వాటిని అందువలన, అక్కడ 2 x ఈ, లేదా ఒక 3 జోడించడం
ఈ కేవలం స్థిరాంకాలు ఉంటాయి, మరియు ఈ అప్ డ్రాప్ ఇస్తున్నాయి.
ఈ పరుగుల సార్లు అన్ని 3 వారు O (n) ఉన్నారు ఇలా ఒకటే వై సో ఆ.
మేము 2 ఇతర పరుగుల సార్లు ఉంటే అదేవిధంగా, O (n ³ + 2N ²), మేము జోడించవచ్చు సే తెలియజేయండి
అప్పుడు + n, + 7, మరియు మేము కేవలం O మరొక రన్ టైం (n ³) ఉన్నాయి.
ఈ అదే కాదు - ఈ ఎందుకంటే మళ్ళీ, ఈ ఇదే ఉంటాయి.
ఈ అదే విషయాలు, సారీ. కాబట్టి ఈ అదే ఎందుకంటే
ఈ n ³ ఈ 2N ² ఆధిపత్యం అన్నారు.
>> మేము O (n ³) మరియు O వంటి సార్లు అమలు కలిగి ఉంటే అదే విషయం కాదు (n ²)
ఈ n ³ ఈ n ² కంటే ఎక్కువగా ఉంటుంది.
మేము ప్రతినిధులు ఉంటే కాబట్టి, అకస్మాత్తుగా ఈ, పట్టింపు మొదలవుతుంది
మేము ఇక్కడ ఉన్నాయి కాని, మనం కేవలం కారకాలు వ్యవహరించే చేసినప్పుడు
అప్పుడు అవి మధ్యలోనే మానేస్తున్నారు వెళ్లే ఎందుకంటే పట్టింపు మాత్రం కాదు.
యొక్క మేము ఇప్పటివరకు చూసిన అల్గోరిథంలు యొక్క కొన్ని పరిశీలించి లెట్
మరియు వారి రన్ టైం గురించి మాట్లాడండి.
ఒక జాబితాలో అనేక వెతుకుతున్న మొదటి మార్గం, మేము చూసిన, సరళ శోధన ఉంది.
మరియు సరళ శోధన అమలు సూపర్ సూటిగా ఉంటుంది.
మేము ఒక జాబితా, మరియు మేము జాబితాలో ప్రతి మూలకం కు వెళుతున్న
మేము సంఖ్య కనుగొనేందుకు వరకు మేము చూస్తున్న.
కాబట్టి అని చెత్త సందర్భంలో, ఈ O (n).
మూలకం ఉంటే మరియు ఇక్కడ విషయంలో ఉంటుంది
గత మూలకం, అప్పుడు సరళ శోధన ఉపయోగించి మేము ప్రతి మూలకం కు కలిగి
మేము అది జాబితాలో వాస్తవానికి అని తెలుసు చేయడానికి చివరి ను వరకు.
మేము సగం వదిలివేసి చెప్పలేను, "అక్కడ బహుశా కాదు."
సరళ శోధన తో మేము మొత్తం విషయం కు ఉంది.
ఉత్తమ కేసు నడుస్తున్న సమయంలో, మరోవైపు, స్థిరంగా ఉంటుంది
ఉత్తమ సందర్భంలో మేము చూస్తున్న మూలకం కేవలం జాబితాలో మొదటి ఒకటి ఎందుకంటే.
కాబట్టి మాకు ఖచ్చితంగా 1 అడుగు, జాబితా ఎలా పెద్దది ఉన్నా తీసుకోవాలని జరగబోతోంది
మేము మొదటి మూలకం కోసం ప్రతిసారీ మీకెప్పుడూ.
>> కాబట్టి మీరు శోధించినప్పుడు, గుర్తుంచుకోండి, మా జాబితా వేరు అవసరం లేదు.
మేము కేవలం ప్రతి మూలకం చూసి చూడాలని, మరియు దీనికి నిజంగా ప్రాధాన్యత లేదు ఎందుకంటే
ఏ క్రమంలో ఆ అంశాలను సైన్ ఉంటాయి
మరింత తెలివైన శోధన అల్గోరిథం బైనరీ శోధన వంటిది.
మీరు చూడాలని గుర్తుంచుకోండి, బైనరీ శోధన అమలు ఉంది
జాబితా మధ్య చూడటం ఉంచండి.
మేము మధ్య వద్ద చూస్తున్న ఎందుకంటే, మేము జాబితా క్రమబద్ధీకరించబడింది అవసరం
లేదంటే మధ్య ఉన్న మనం చెప్పలేము, మరియు మేము చూసి ఉంటుంది
దానిని కనుగొనేందుకు మొత్తం జాబితా, మరియు ఆ సమయంలో మేము సమయాన్ని వృధా చేస్తున్నారు.
మేము ఒక క్రమబద్ధీకరించబడతాయి జాబితా మరియు మేము మధ్య కనుగొనేందుకు చేస్తే, మేము మధ్య పోల్చి చూడాలని
అంశానికి మేము చూస్తున్న.
ఇది చాలా హై, అప్పుడు మేము సగం మరిచిపోవచ్చు
మేము తెలిసినందున మా మూలకం ఇప్పటికే చాలా అధికంగా ఉంది
మరియు ఈ మూలకం యొక్క కుడి ప్రతిదీ కూడా ఎక్కువగా ఉంటుంది,
అప్పుడు మేము ఇకపై అక్కడ చూడవలసిన అవసరం లేదు.
ఎక్కడ మరోవైపు, మా మూలకం చాలా తక్కువగా ఉన్నట్లయితే,
మేము ఆ మూలకం యొక్క ఎడమ ప్రతిదీ కూడా చాలా తక్కువ తెలుసు
కాబట్టి ఇది నిజంగా గాని, అక్కడ చూడటానికి సమంజసం అనిపించుకోదు.
ఈ విధంగా, జాబితా యొక్క midpoint ప్రతి అడుగు మరియు మేము చూడండి ప్రతి సమయం,
అకస్మాత్తుగా మనకు తెలుసు ఎందుకంటే మేము సగం లో మా సమస్య కట్ చూడాలని
మేము చూస్తున్న ఒక సాధ్యం కాని సంఖ్యల యొక్క మొత్తం బంచ్.
>> Pseudocode లో ఈ, ఈ వంటి ఏదో చూస్తారు
మరియు ఎందుకంటే మేము, సగం ప్రతి సమయంలో జాబితా కటింగ్ చేస్తున్నారు
సంవర్గమాన కు సరళ నుండి మా చెత్త-రన్ కేసులో సమయం హెచ్చుతగ్గుల.
కాబట్టి హఠాత్తుగా మనం లాగ్ ఇన్ జాబితా ఒక మూలకం కనుగొనడానికి వాటిని దశలు.
ఉత్తమ కేసు నడుస్తున్న సమయంలో, అయితే, ఇప్పటికీ స్థిరంగా ఉంటుంది
ఇప్పుడు ఎందుకంటే, కేవలం మేము చూస్తున్న మూలకం అని సే తెలియజేయండి
అసలు జాబితాను ఎల్లప్పుడూ కచ్చితమైన మధ్య.
కాబట్టి, మనం కావలసిన పెద్ద మా జాబితా పెరుగుతాయి, కానీ మేము చూస్తున్న మూలకం మధ్య వద్ద ఉంది
అప్పుడు మాత్రమే మాకు 1 దశకు చెప్పారు.
మేము O (n లాగ్) మరియు Ω (1) లేదా స్థిరమైన ఉండటానికి కాబట్టి ఆ.
యొక్క నిజానికి ఈ జాబితాలో బైనరీ శోధన అమలు అయ్యేలా అనుమతించండి.
కాబట్టి యొక్క మేము మూలకం 164 వెతికే అని పిలవబడు.
మేము వెళ్ళే మొదటి విషయం ఈ జాబితాలో midpoint కనుగొనేందుకు ఉంది.
ఇది కేవలం కాబట్టి, midpoint ఈ 2 సంఖ్యలను మధ్య పడిన అన్నారు జరిగితే
కాబట్టి, midpoint 2 సంఖ్యలను మధ్య వస్తుంది ప్రతిసారీ, కేవలం ఏకపక్ష సే తెలియజేయండి
యొక్క కేవలం చుట్టుముట్టటమే తెలియజేయండి.
మేము ఈ విధంగా ప్రతి అడుగు వాటిని చెయ్యండి అవసరం.
కాబట్టి మేము చుట్టుముట్టటమే చూడాలని, మరియు మేము మా 161 జాబితాలో మధ్య పేర్కొన్నారు చూడాలని.
కాబట్టి 161 <164, మరియు 161 యొక్క ఎడమ ప్రతి మూలకం
కూడా <164, కాబట్టి మేము అన్ని వద్ద మాకు సహాయం చెయ్యడానికి వెళ్ళడం లేదు మనకు తెలుసు
మేము ఉండదు చూస్తున్న మూలకం ఎందుకంటే ఇక్కడ పైగా చూస్తున్న ప్రారంభించడానికి.
సో వాట్ మేము, మేము జాబితాలో ఆ మొత్తం ఎడమ అర్ధ మీరు మరిచిపోవచ్చు ఉంది
మరియు ఇప్పుడు మాత్రమే 161 నుండీ కుడి నుండి భావిస్తారు.
>> మరలా, ఈ midpoint ఉంది; యొక్క కేవలం చుట్టుముట్టటమే తెలియజేయండి.
ఇప్పుడు 175 చాలా పెద్దది.
కాబట్టి మేము ఇది మాకు ఇక్కడ లేదా ఇక్కడ చూస్తున్న సహాయం మాత్రం కాదు తెలుసు
కాబట్టి మేము ఆ తీసివేసినట్లు మరియు చివరికి మేము 164 హిట్ చేస్తాము.
బైనరీ శోధన ఏ ప్రశ్నలు?
లెట్ యొక్క ఇప్పటికే క్రమబద్ధీకరించబడతాయి జాబితా ద్వారా శోధించడం నుండి బయటపడేందుకు
వాస్తవానికి ఏ క్రమంలో సంఖ్యల జాబితా తీసుకోవడానికి
మరియు క్రమంలో ఆ జాబితా తయారు.
మేము చూసాము మొదటి అల్గోరిథం బబుల్ సార్ట్ అని పిలిచేవారు.
మరియు ఈ మేము చూసిన అల్గోరిథంలు యొక్క సులభమైన ఉంటుంది.
బబుల్ సార్ట్, జాబితా లోపల ఏ 2 అంశాలు స్థానం నుంచి బయటకు ఉన్నప్పుడు చెప్పారు
అధిక సంఖ్యలో తక్కువ సంఖ్య ఎడమ వైపున ఉంది, అనగా
ఆ జాబితా ఉంటుందని అర్థం ఎందుకంటే అప్పుడు మేము వాటిని మార్పిడి చూడాలని
అది ముందు కంటే "మరిన్ని క్రమబద్ధీకరించబడతాయి".
మరియు మేము మళ్లీ మళ్లీ మళ్లీ ఈ ప్రక్రియ కొనసాగుతుంది వెళ్లి మీరు
చివరికి అంశాలు వారి సరైన స్థానానికి బబుల్ యొక్క రకం మరియు మేము ఒక క్రమబద్ధీకరించబడతాయి జాబితా వరకు.
>> ఈ యొక్క రన్ టైం O ఉండబోతుంది (n ²). ఎందుకు?
Well, చెత్త విషయంలో ఎందుకంటే, మేము ప్రతి మూలకం తీసుకుంటున్నానని, మరియు మీరు
మేము జాబితాలో ప్రతి ఇతర మూలకం పోల్చారు వదులుకోవడానికి వెళుతున్న.
కాని ఇది ఉత్తమ సందర్భంలో, మేము ఇప్పటికే క్రమబద్ధీకరించబడతాయి జాబితా, బబుల్ సార్ట్ యొక్క
కేవలం ఒకసారి ద్వారా వెళ్ళడానికి సే, వెళ్ళటం "వద్దు. నేను ఏ మార్పిడులు లేదు, నేను పూర్తయింది."
కాబట్టి మేము Ω (n) యొక్క ఉత్తమ కేసు నడుస్తున్న సమయం.
యొక్క జాబితాలో బబుల్ సార్ట్ అమలు అయ్యేలా అనుమతించండి.
లేదా మొదటి, యొక్క కేవలం నిజంగా త్వరగా కొన్ని pseudocode చూద్దాం.
మేము, మేము లూప్ యొక్క ప్రతి మళ్ళా లో, యొక్క ట్రాక్ చెయ్యాలనుకుంటున్నారా చెప్పాలనుకోవడం
మేము ఏ అంశాలు మార్చబడ్డాయి లేదో గమనించండి.
ఆ కారణం కాబట్టి, మనం ఏదైనా మూలకాల మార్చుకున్నారు లేదు ఎప్పుడు నిలిపివేయాలి చూడాలని.
మా లూప్ ప్రారంభంలో మేము ఏదైనా మార్చుకున్నారు, కాబట్టి మేము తప్పుడు అని చెప్పడానికి చేస్తాము.
ఇప్పుడు మేము జాబితా ద్వారా వెళ్ళి నేను మూలకం నేను + 1 మూలకం పోల్చి చూడాలని
మరియు అది ఒక పెద్ద సంఖ్య చిన్న సంఖ్యలో ఎడమ వైపున ఉంది సందర్భంలో,
అప్పుడు మేము వాటిని మార్పిడి చూడాలని.
>> మరియు తర్వాత మేము ఒక మూలకం మార్చుకున్నారు ఆ గుర్తు చేస్తున్నారు.
అంటే జాబితా ద్వారా కనీసం 1 ఎక్కువ సమయం వెళ్లవలసిన అవసరం అంటే
మొత్తం జాబితా ఇప్పటికే క్రమబద్ధీకరించబడింది మేము ఆగింది పరిస్థితి ఎందుకంటే,
మేము ఏ మార్పిడులు చేసిన చేయలేదు అర్థం.
మా పరిస్థితి డౌన్ ఇక్కడ ఎందుకు కాబట్టి ఆ 'కొన్ని ఎలిమెంట్లను మార్చుకున్నారు కలిగి ఉంటాయి.'
కాబట్టి ఇప్పుడు యొక్క ఈ జాబితాను నడుస్తున్న చూద్దాం.
నేను జాబితా 5,0,1,6,4 ఉన్నాయి.
బబుల్ సార్ట్ ఎడమ వద్ద అన్ని మార్గం ఆరంభమవుతుంది, మరియు అది పోల్చడానికి జరగబోతోంది
నేను అంశాలను, కాబట్టి మూలకం 1 ఇది 0 నేను + 1.
, ఇది కూడా 5> 0 చెప్పడానికి జరగబోతోంది, అయితే ప్రస్తుతం 5 ఎడమవైపు
నేను 5 మరియు 0 మార్పిడి అవసరం.
నేను వాటిని మార్పిడి చేసినప్పుడు, అనుకోకుండా ఈ వివిధ జాబితా పొందండి.
ఇప్పుడు 5> 1, కాబట్టి మేము వాటిని మార్పిడి చూడాలని.
5> 6 లేదు, కాబట్టి మేము ఇక్కడ ఏమీ చేయాల్సిన అవసరం లేదు.
కానీ 6> 4, కాబట్టి మేము మార్పిడి అవసరం.
మళ్లీ, మేము చివరికి కనుగొనడానికి మొత్తం జాబితా ద్వారా అమలు చేయాలి
ఈ క్రమంలో ఉన్నాయి ఆ; మేము వాటిని స్వాప్
మరియు ఈ సమయంలో మేము జాబితా ద్వారా 1 ఎక్కువ సమయం అమలు చేయాలి
ప్రతిదీ దాని క్రమంలో ఉంది, మరియు ఈ పాయింట్ బబుల్ సార్ట్ వద్ద ముగిసింది నిర్ధారించుకోండి కు.
కొన్ని అంశాలను మరియు వాటిని క్రమబద్ధీకరించేందుకు కోసం వేరొక అల్గోరిథం ఎంపిక విధమైన ఉంది.
ఎంపిక విధమైన ఆలోచనకు మేము జాబితా యొక్క ఒక క్రమబద్ధీకరించబడతాయి భాగాన్ని నిర్మించేందుకు వెళుతున్న ఉంది
ఒక సమయంలో 1 మూలకం.
>> మరియు మేము ఆ చేయబోతున్నామని విధంగా జాబితాలో ఎడమ భాగాన్ని పెంపొందించడం ఉంది.
మరియు ప్రధానంగా, ప్రతి - ప్రతి దశలో, మేము వదలి చిన్న మూలకం తీసుకుని వెళుతున్నాం
ఆ ఇంకా క్రమబద్ధీకరించబడతాయి లేదు, మరియు మేము ఆ పేర్చిన విభాగంలో దానిని తరలించడానికి వెళుతున్న.
అనగా మేము నిరంతరం కనీస క్రమబద్ధీకరించనిది మూలకం కనుగొనేందుకు అవసరం
మరియు ఆ కనీస మూలకం తీసుకొని ఏ తో మార్పిడి
ఎడమ అత్యంత మూలకం వర్గీకరించరు అని.
ఈ యొక్క రన్ టైం O ఉండబోతుంది (n ²) ఎందుకంటే విషయంలో లో
మేము ప్రతి ఇతర అంశానికి ప్రతి మూలకం పోల్చి చూడాలి.
మేము జాబితా ఎడమ అర్ధ వద్ద మొదలు, మేము అవసరమైన చెబుతున్న దాన్ని ఎందుకంటే
చిన్న మూలకం కనుగొనేందుకు మొత్తం కుడి భాగాన్ని ద్వారా వెళ్ళడానికి.
ఆపై, మళ్ళీ, మేము మొత్తం కుడి భాగాన్ని వెళ్ళి అవసరం
మళ్ళీ మరియు పైగా మరియు పైగా పైగా ఆ పై కొనసాగించడాన్ని.
ఆ n ² చేస్తాడు. మేము లూప్ మరొక యొక్క లూప్ లోపల అవసరం చూడాలని
ఇది n ² సూచిస్తుంది.
ఉత్తమ కేసు ఆలోచనలో, యొక్క మేము అది ఇప్పటికే క్రమబద్ధీకరించబడతాయి జాబితా ఇవ్వండి అని పిలవబడు;
మేము నిజంగా n ² కంటే ఏ బాగా లేదు.
ఎంపిక విధమైన తెలుసుకోవడం కాదు కలిగి ఉంటుంది
కనీస మూలకం కేవలం నేను చూడటం కావడం ఒకటి.
ఇప్పటికీ ఈ వాస్తవానికి కనీస నిర్ధారించుకోండి అవసరం.
>> మరియు ఈ అల్గారిథమ్ ఉపయోగించి, అది కనీసం ఆ నిర్ధారించుకోండి ఏకైక మార్గం,
మళ్ళీ ప్రతి మూలకం కు ఉంది.
కాబట్టి నిజంగా, మీరు ఇచ్చి ఉంటే - మీరు ఎంపిక విధమైన ఇప్పటికే క్రమబద్ధీకరించబడతాయి జాబితా ఇవ్వాలని ఉంటే,
అది ఇంకా వర్గీకరించరు ఒక జాబితా ఇచ్చి కంటే ఏ బాగా మాత్రం కాదు.
అది సందర్భంలో జరిగితే మార్గం ద్వారా, ఏదో ఓ (ఏదో) అని
మరియు ఏదో యొక్క ఒమేగా, మేము మరింత క్లుప్తమైన అది ఏదో యొక్క θ యొక్క చెబుతాను.
మీరు ఆ యొక్క మాత్రమే అర్థం ఆ, ఎక్కడైనా వచ్చి చూడండి చేస్తున్నాను.
>> ఏదో n యొక్క తీట ఉంటే ², రెండు పెద్ద O (n ²) మరియు Ω (n ²) ఉంది.
ఉత్తమ కేసు మరియు విషయంలో కాబట్టి, అది, ఒక వైవిధ్యం లేదు
అల్గోరిథం ఇదే ప్రతి మీకు అన్నారు.
కాబట్టి ఈ ఎంపిక విధమైన కోసం pseudocode ఎలా అనే దాని ఉంది.
మేము ప్రధానంగా నేను జాబితా పై iterate చేయదలిచిన చెప్పడానికి వెళుతున్న
కుడికి, మరియు లూప్ యొక్క ప్రతి పునరావృతం వద్ద ఎడమ నుండి, నేను తరలించడానికి వెళుతున్న
జాబితా ఈ విభజించిన భాగంలోకి కనీస మూలకం.
మరియు ఒకసారి నేను అక్కడ ఏదో తరలించడానికి, నేను మళ్లీ ఆ మూలకం కు అవసరం లేదు.
వెంటనే నేను జాబితా యొక్క ఎడమ భాగాన్ని కు ఒక మూలకం మార్పిడి, అది క్రమబద్ధీకరించబడతాయి కాబట్టి
మేము తక్కువ పరిమాణాల ఉపయోగించి క్రమంలో ప్రతిదీ చేస్తున్నా ఎందుకంటే.
కాబట్టి మేము సరే, మేము స్థానం i ఉన్నాము, మరియు మేము వద్ద అన్ని మూలకాల చూడవలసిన అవసరం, అన్నాడు
కనీస కనుగొనడానికి వాటిని నేను కుడివైపున.
కాబట్టి మేము జాబితా చివర నేను + 1 నుండి చూడవచ్చు అర్థం.
ఇప్పుడు, మేము ప్రస్తుతం శోధిస్తున్న మూలకం, ఇప్పటివరకు మా కనీస కంటే తక్కువ ఉంటే
గుర్తుంచుకోండి, మేము అని కనీస ఆఫ్ మొదలు పెడుతున్నారు ఇది,
ఏ మూలకం మేము ప్రస్తుతం ఉన్నారు; నేను కనీసం ఆ ఊహించుకోవటం చేస్తాము.
నేను కంటే చిన్న విధంగా ఒక మూలకం కనుగొనడానికి, అప్పుడు నేను, సరే, చెప్పడానికి వెళుతున్న
అలాగే, నేను ఒక కొత్త కనీస గుర్తించారు.
నేను ఆ కనీస ఉన్న గుర్తు చేస్తున్నాను.
>> కాబట్టి ఇప్పుడు, ఒకసారి నేను, ఆ కుడి క్రమబద్ధీకరించనిది విభాగంలో ద్వారా మారారు
నేను స్థానం నేను అని మూలకం తో కనీస మూలకం స్వాప్ వెళుతున్న చెప్పగలను.
నా జాబితా నిర్మించే అవకాశముంది, ఎడమ నుండి కుడికి జాబితాలో నా క్రమబద్ధీకరించబడతాయి భాగం,
మరియు మనం ఆ భాగంలో తర్వాత మళ్లీ ఒక మూలకం కు లేదు.
ఒకసారి మేము అది మార్చుకున్నారు చేసిన.
కాబట్టి యొక్క ఈ జాబితాలో ఎంపిక విధమైన అమలు అనుమతిస్తాయి.
ఇక్కడ నీలం మూలకం నేను మాత్రం, మరియు ఎరుపు మూలకం కనీస మూలకం ఉండాలని అనుకున్నాము.
నేను 5 వద్ద కాబట్టి, జాబితా యొక్క ఎడమ వద్ద అన్ని మార్గం మొదలవుతుంది.
ఇప్పుడు మేము కనీసం క్రమబద్ధీకరించనిది మూలకం కనుగొనేందుకు అవసరం.
కాబట్టి మేము 0 <5, కాబట్టి 0 నా కొత్త కనీస అంటారు.
>> మేము, 0 చిన్నది గుర్తించాయి చేస్తారు ఎందుకంటే కానీ, అక్కడ కాంట్ స్టాప్
మేము నిర్ధారించడానికి జాబితా ప్రతి ఇతర మూలకం ద్వారా అమలు చేయాలి.
, 6 పెద్దది పెద్దది 1 కాబట్టి, 4 పెద్దగా ఉంది.
ఈ అన్ని మూలకాల చూడటం తర్వాత, నేను 0 చిన్నది కనుగొన్నాము అర్థం.
నేను 5 మరియు 0 స్వాప్ వెళుతున్న.
ఒకసారి నేను మార్పిడి, నేను ఒక క్రొత్త జాబితా పొందడానికి వెళుతున్న మరియు నేను మళ్ళీ ఆ 0 కు అవసరం లేదు తెలుసు
ఒకసారి నేను మార్చుకున్నారు చేసిన ఎందుకంటే, నేను విభజించిన చేసిన మరియు మేము పూర్తి చేసిన.
ఇప్పుడు అది కేవలం, నీలం మూలకం మళ్లీ 5 ఆ జరుగుతుంది
మరియు మేము ఆ 1 నిర్ణయించడానికి, 1 కు 6 మరియు 4 అవసరం
చిన్న కనీస మూలకం, కాబట్టి మేము 1 మరియు 5 మార్పిడి చేస్తాము.
మళ్లీ, మేము కు అవసరం - 6 మరియు 4 నుండి 5 పోల్చి,
మరియు మేము 4 మరియు 5 స్వాప్ కు వెళ్ళి, చివరగా పోల్చి చేస్తున్నారు
ఆ 2 సంఖ్యలను మరియు మేము మా క్రమబద్ధీకరించబడతాయి జాబితా వచ్చేవరకు వాటిని మార్పిడి.
ఎంపిక విధమైన ఏ ప్రశ్నలు?
సరే. యొక్క ఇక్కడ చివరి అంశం తరలించడానికి లెట్, మరియు ఆ సూత్రం ఉంది.
>> సూత్రం, గుర్తుంచుకోండి, ఈ నిజంగా మెటా విషయం ఉన్న ఒక ఫంక్షన్
పదేపదే కూడా పిలుస్తుంది.
కాబట్టి ఏదో ఒక సమయంలో, మా fuction పదేపదే కూడా కాల్ ఉన్నప్పుడు,
మనం అని పిలవడం ఆపివేయండి ఇది కొన్ని పాయింట్ అవసరం.
మేము అలా లేకపోతే, అప్పుడు మేము ఎప్పటికీ ఈ కొనసాగుతుందని వెళుతున్న కారణంగా,
మరియు మా కార్యక్రమం కేవలం రద్దు ఉండదని.
మేము ఈ పరిస్థితి బేస్ కేసు కాల్.
మరియు బేస్ కేసు కాకుండా మళ్ళీ ఒక చర్యను కాల్ కంటే అన్నారు
నేను కొన్ని విలువ తిరిగి వెళుతున్న.
మేము ఒక విలువ తిరిగి చేసిన తర్వాత కాబట్టి, మనం కాల్ ఆపివేశారు
మరియు మేము ఇప్పటివరకు చేసిన కాల్స్ మిగిలిన కూడా తిరిగి రావచ్చు.
బేస్ కేసులో సరసన పునరావృత విషయం.
మరియు ఈ మనం సైన్ ప్రస్తుతం ఉన్నట్లు కు మరొక కాల్ చేయడానికి ఉంటుంది ఉంది
మరియు మేము బహుశా, ఎల్లప్పుడు అయితే, వివిధ వాదనలు ఉపయోగించాలనుకుంటున్నాను.
>> మేము F అనే చర్య మరియు F కేవలం, 1 వాదన పడుతుంది అని అయితే
మరియు మేము కేవలం F (1), F (1), F (1) కాల్ ఉంచేందుకు, మరియు ఇది కేవలం కాబట్టి ఆ జరుగుతుంది
వాదన 1 పునరావృత కేసు పడతాడు, మేము ఇప్పటికీ ఆపడానికి వెళ్ళడం ఎప్పుడూ చేస్తున్నారు.
మేము ఒక బేస్ కేసు సరే, మేము చివరికి ఆ బేస్ కేసు హిట్ చూడాలని ఉద్దేశ్యంతో నిర్ధారించుకోవాలనుకుంటున్నాము.
మేము ఈ పునరావృత కేసులో ఉంటున్న ఉంచేందుకు లేదు.
సాధారణంగా, మనం కాల్ చేసినప్పుడు, మేము బహుశా వేరే వాదన ప్రతి సమయం చూడాలని.
ఇక్కడ ఒక రియల్లీ సింపుల్ పునరావృత విధి.
కాబట్టి ఈ అనేక కారకమైన గణించడం కనిపిస్తుంది.
అప్ మేము మా బేస్ సందర్భాన్ని ఇక్కడ అగ్ర.
N ≤ 1, మేము మళ్ళీ కారకమైన కాల్ ఉండదు చేస్తున్న సందర్భంలో.
మేము ఆపడానికి వెళుతున్న; మేము కొన్ని విలువ తిరిగి చూడాలని.
ఇది నిజం కాదు, అప్పుడు మేము మా పునరావృత కేసు హిట్ చూడాలని.
చాలా సహాయకారిగా ఎందుకంటే, మనం కేవలం కారకమైన (n) కాల్ చేస్తున్నట్లు ఇక్కడ గమనించవచ్చు.
మేము ఏదో యొక్క కారకమైన కాల్ చూడాలని.
>> మరియు మీరు, మేము ఒక కారకమైన (5) లేదా ఏదో పాస్ చివరికి ఉంటే, చూడగలరు
మేము కారకమైన (4), అందువలన న కాల్ చూడాలని, మరియు చివరికి మేము ఈ బేస్ కేసు హిట్ చూడాలని.
కాబట్టి ఈ బాగుంది. మేము నిజంగా ఈ అమలు ఏమి జరుగుతుంది చూద్దాం.
ఈ స్టాక్, మరియు లెట్స్ ప్రధాన వాదన (4) తో ఈ ఫంక్షన్ కాల్ అన్నారు చెబుతారు.
కాబట్టి ఒకసారి కారకమైన చూస్తాడు మరియు = 4, కారకమైన కూడా కాల్ చేస్తుంది.
ఇప్పుడు, అకస్మాత్తుగా, మేము (3) కారకమైన ఉన్నాయి.
కాబట్టి ఈ విధులు చివరికి మా బేస్ కేసు హిట్ వరకు పెరుగుతున్న ఉంచడానికి వెళ్తున్నారు.
ఈ సమయంలో, ఈ తిరిగి విలువ తిరిగి (NX ఈ తిరిగి విలువ) ఉంది
ఈ తిరిగి విలువ ఈ యొక్క NX తిరిగి విలువ.
చివరికి మేము కొన్ని సంఖ్య హిట్ అవసరం.
ఇక్కడ పైభాగంలో, మేము తిరిగి 1 చెప్పారు.
ఒకసారి మేము ఆ సంఖ్య తిరిగి అని, మేము స్టాక్ ఆఫ్ ఈ పాప్ చేయవచ్చు.
కాబట్టి ఈ కారకమైన (1) చేయబడుతుంది.
ఎప్పుడు 1 రాబడి, ఈ కారకమైన (1) రాబడి, 1 ఈ తిరిగి.
ఈ తిరిగి విలువ గుర్తుంచుకోండి, ఈ తిరిగి విలువ NX ఉంది.
కాబట్టి అకస్మాత్తుగా, ఈ గై నేను 2 తిరిగి కావలసిన తెలుసు.
>> కాబట్టి, గుర్తు ఈ విలువ ఇక్కడ తిరిగి విలువ కేవలం NX అప్ తిరిగి.
కాబట్టి ఇప్పుడు మేము 3 x 2 చెప్పగలదు, మరియు చివరకు, ఇక్కడ మేము చెప్పగలను
ఈ కేవలం 4 x 3 x 2 అన్నారు.
మరియు ఈ రాబడి ఒకసారి, మేము ప్రధాన యొక్క ఒక పూర్ణాంకం లోపలి క్రిందికి.
సూత్రం లో ఏదైనా ప్రశ్నలు?
అన్ని కుడి. కాబట్టి ప్రశ్నలకు ఎక్కువ సమయం, చివరిలో ఉంది
కానీ ఇప్పుడు జోసెఫ్ మిగిలిన విషయాలు కవర్ చేస్తుంది.
>> [జోసెఫ్ వోంగ్] అన్ని కుడి. కాబట్టి ఇప్పుడు మేము recursions గురించి మాట్లాడారు చేసారు,
యొక్క విధమైన ఉంది విలీనం గురించి కొద్దిగా చర్చ తెలియజేయండి.
విలీనం విధమైన ప్రధానంగా సంఖ్యల జాబితా విభజన మరొక మార్గం.
మరియు అది విలీనంతో విధమైన తో, వర్క్స్ ఎలా మీరు ఒక జాబితా, మరియు మేము ఉంది
మేము యొక్క 2 భాగాలుగా విభజించబడింది ఈ తెలియజేయండి చెప్పారు.
మేము మొదటి, ఎడమ అర్ధ మళ్లీ విధమైన విలీనం అమలు చేస్తాము
అప్పుడు మేము, కుడి అర్ధభాగంలో విధమైన విలీనం అమలు చేస్తాము
మరియు ఆ ఇప్పుడు మాకు క్రమబద్ధీకరించబడతాయి ఆ 2 విభజించటం ఇస్తుంది, మరియు ఇప్పుడు మేము కలిసి ఆ చొక్కాలను కలిపి చూడాలని.
ఇది ఒక ఉదాహరణ లేకుండా చూడడానికి కొంచెం కష్టం, కాబట్టి మేము కదలికలు ద్వారా వెళ్ళి ఏమి చూస్తారు.
కాబట్టి మీరు ఈ జాబితాను, మేము 2 భాగాలుగా విభజించబడింది అది మొదలు.
మేము మొదటి ఎడమ అర్ధభాగంలో విధమైన విలీనం అమలు.
కాబట్టి ఆ ఎడమ అర్ధ, మరియు ఇప్పుడు మేము మళ్ళీ ఈ జాబితా ద్వారా వాటిని అమలు
ఇది మేము, మళ్ళీ, చూడండి అప్పుడు విలీనంతో విధమైన జారీ, మరియు తీర్చుకుంటాడు
ఈ జాబితా యొక్క ఎడమ వైపు వద్ద మరియు మేము అది న విధమైన విలీనం అమలు.
ఇప్పుడు, మేము, 2 సంఖ్యల జాబితాను క్రిందికి
మరియు ఇప్పుడు ఎడమ అర్ధ మాత్రమే 1 మూలకం పొడవుగా ఉంది, మరియు మేము కాదు
సగం మాత్రమే 1 ఎలిమెంట్ ఒక జాబితా విభజించబడింది, కాబట్టి మేము కేవలం ఒకసారి మేము 50 కలిగి సే,,
ఇది కేవలం 1 మూలకం, ఇది అప్పటికే పేర్చిన యొక్క.
>> మేము పూర్తి చేసిన తర్వాత, మేము ఆ మేము చూడగలరు
ఈ జాబితా యొక్క కుడి సగం కొనసాగండి,
మరియు 3 కూడా అలా ఇప్పుడు ఈ జాబితాలో రెండు భాగాలుగా విభజించిన చేసిన క్రమబద్ధీకరించబడతాయి మరియు
మేము తిరిగి కలిసి ఈ సంఖ్యలు చేరవచ్చు.
కాబట్టి మేము 50 మరియు 3 వద్ద చూడండి 3 50 కంటే తక్కువగా ఉంది, కాబట్టి ఇది మొదటి వెళుతుంది మరియు తరువాత 50 సైన్ వస్తుంది
ఇప్పుడు, ఆ పని యొక్క; మేము సరైన సగం అని జాబితా మరియు విధమైన వరకు తిరిగి వెళ్ళండి.
42 అది యొక్క సొంత సంఖ్య, కాబట్టి ఇది ఇప్పటికే క్రమబద్ధీకరించబడతాయి యొక్క.
కాబట్టి ఇప్పుడు మేము, మొదటి ఉంచే కాబట్టి 2 మరియు 3 42 కంటే తక్కువగా ఉంది ఈ పోల్చి
ఇప్పుడు 42 ఉంచే, మరియు 50 సైన్ ఉంచే
ఇప్పుడు, క్రమబద్ధీకరించబడింది అలా మేము, టాప్ తిరిగి 1337 మరియు 15 అన్ని మార్గం వెళ్ళి.
Well, మేము ఇప్పుడు ఈ జాబితాలో ఎడమ అర్ధ చూడండి; 1337 ద్వారా కనుక అది 15 తో విభజించిన మరియు సేమ్.
కాబట్టి ఇప్పుడు మేము ఆ Original జాబితా, 15 <1337, క్రమం ఈ 2 సంఖ్యలు కలిపి
కాబట్టి ఇది మొదటి వెళుతుంది, అప్పుడు 1337 సైన్ వెళుతుంది
ఇప్పుడు మేము టాప్ అసలు జాబితాను రెండు భాగాలుగా విభజించిన.
మరియు మేము అన్ని ఈ మిళితం ఉంది.
మేము ఈ జాబితాలో మొదటి 2 అంకెలు, 3 <15 చూడండి, కాబట్టి ఇది మొదటి విధమైన శ్రేణి వెళతాడు.
15 <42, అది ఇప్పుడు సైన్ వెళుతుంది 42 <1337, ఆ సైన్ వెళుతుంది
50 <1337, కాబట్టి ఇది సైన్ వెళ్లి మేము ఈ జాబితాలో 2 సంఖ్యలను ఆఫ్ పట్టింది గమనిస్తారు.
కాబట్టి మేము కేవలం 2 జాబితాలు మధ్య ప్రత్యామ్నాయ లేదు.
మేము ప్రారంభంలో చూస్తున్న, మరియు మేము మూలకం వేస్తున్నాము
చిన్న చిన్న మరియు అప్పుడు మా శ్రేణి లో కానీ పెట్టడానికి ఉంది.
ఇప్పుడు మేము అన్ని విభజించటం విలీనం చేసిన మరియు మేము పూర్తి చేసిన.
>> గురించి ప్రశ్నలు విధమైన విలీనం? అవును?
[స్టూడెంట్] వివిధ విభాగాలుగా విభజించడం అయితే, ఎందుకు వారు దీనిని ఒకసారి విడిపోయిన లేదు
మరియు మీరు ఒక సమూహంలో 3 మరియు 2 ఉందా? [ప్రశ్న అపారదర్శక యొక్క రెస్ట్]
కారణం - కాబట్టి ప్రశ్న, మేము వాటిని తరువాత ఎందుకు ఆ మొదటి దశ వాటిని విలీనం చేయలేరు?
మేము చేయవచ్చు కారణం, రెండు వైపుల ఎడమ అధిక మూలకాల వద్ద ప్రారంభం
తరువాత, చిన్న ఒక తీసుకుని దానికి ఉంచారు మేము ఈ తెలిసిన ఉంది
వ్యక్తిగత జాబితాలు క్రమబద్ధీకరించబడతాయి ఆర్డర్లు ఉన్నాయి.
నేను రెండు భాగాలుగా ఎడమ అధిక మూలకాల వద్ద చూస్తున్నాను అయితే,
నేను ఆ జాబితాల చిన్న అంశాలు మాత్రం కాదని మాకు తెలుసు.
నేను ఈ పెద్ద జాబితా యొక్క అతి చిన్న మూలకం మచ్చలు వాటిని ఉపయోగించవచ్చు.
మరోవైపు, నేను అక్కడ రెండవ స్థాయి ఆ 2 జాబితాలు విషయంలో చూస్తే,
50, 3, 42, 1337 మరియు 15, ఆ వర్గీకరించరు.
నేను 50 మరియు 1337 చూడండి అలా అయితే, నేను మొదటి నా జాబితాలో 50 ఉంచారు వెళుతున్న.
కానీ నిజంగా 3 ఆ అన్ని బయటకు చిన్న మూలకం ఎందుకంటే, సమంజసం అనిపించుకోదు.
కాబట్టి మేము ఈ కలపడం దశల చేయవచ్చు మాత్రమే కారణం మా జాబితాలు ఇప్పటికే క్రమబద్ధీకరించబడతాయి ఎందుకంటే ఉంది.
మేము దిగువ వరకు డౌన్ పొందడానికి ఎందుకు ఇది
మేము కేవలం ఒక సంఖ్య, మీరు ఒక ఏకైక సంఖ్య తెలిసినందున
మరియు యొక్క ఇప్పటికే క్రమబద్ధీకరించబడతాయి జాబితా ఉంది.
>> ఏదైనా ప్రశ్నలు? కాదు?
సంక్లిష్టత? సరే, మీరు, ప్రతి దశ ముగింపు సంఖ్యలు అక్కడ చూడగలరు
మరియు మేము, సగం లాగ్ n కాలంలో జాబితా తిరగడానికి చేయవచ్చు
మేము ఈ n x లాగ్ n సంక్లిష్టత చోటే ఇది.
మరియు మీరు విలీనంతో విధమైన ఉత్తమ కేసు N log N ఉంది చూస్తారు, మరియు ఇది కేవలం కాబట్టి జరుగుతుంది
విషయంలో, లేదా అక్కడ Ω, కూడా n n లాగిన్ ఆ.
గుర్తుపెట్టుకోవలసిన ఏదో.
వెళ్లడానికి, కొన్ని సూపర్ ప్రాథమిక ఫైల్ I / O వారికి న వీడలేదు
మీరు పెనుగులాట చూసాము, మేము సిస్టమ్ విధమైన కలిగి ఉండటం మీరు గమనించవచ్చు
మీరు కోడ్ ద్వారా రీడ్ మీరు ఒక లాగ్ ఫైల్ వ్రాయడం అందజేయవచ్చు.
యొక్క మీరు అలా ఎలా చెప్పండి.
Well, మేము fprintf, మీరు, కేవలం printf భావిస్తారు ఇది
కానీ ప్రారంభంలో F అందుకే బదులుగా ఫైల్ కి ముద్రించడం, మరియు.
ఇక్కడ కోడ్ ఈ విధమైన మీరు పెనుగులాట చూడవచ్చు ఉండవచ్చు వంటి ఏ అది ఉంది
అది సంఖ్యలు ఏమి వరుసగా అవుట్ మీ 2 డైమెన్షనల్ శ్రేణి ముద్రణ ద్వారా వెళుతుంది.
ఈ సందర్భంలో, మీ printf టెర్మినల్ కు ముద్రిస్తుంది లేదా మేము విభాగం యొక్క ప్రామాణిక అవుట్పుట్ కాల్ ఏమి.
>> ఇప్పుడు, ఈ సందర్భంలో, మనం చేయాల్సిందల్లా, fprintf తో printf స్థానంలో ఉంది
మీరు ముద్రించవచ్చు చేయడానికి ఏమి ఫైలు చెప్పాలి, మరియు ఈ సందర్భంలో అది ఆ ఫైలును దీనిని ముద్రిస్తుంది
బదులుగా మీ టెర్మినల్ కు ముద్రించిన.
వెల్, అప్పుడు ఆ ప్రశ్న ప్రార్థిస్తాడు: అక్కడ మనం నుండి ఫైలు ఈ విధమైన వస్తుందా?
మేము ఈ fprintf fuction లాగ్ ఇన్ జారీ కాని మేము దాని నుండి వచ్చిన తెలియదు.
Well, ప్రారంభ కోడ్, మనం కలిగి, ఇక్కడ పైగా కోడ్ ఈ భాగం ఉంది
ప్రధానంగా ఫైల్ను తెరువు log.txt కాల్స్ చెప్పారు ఇది.
ఆ తర్వాత మేము ఏమి మేము ఫైలు వాస్తవానికి విజయవంతంగా ప్రారంభించబడింది నిర్ధారించుకుని ఉంటుంది.
కనుక ఇది బహుళ కారణాల వైఫల్యం చెందవచ్చు; మీరు ఉదాహరణకు, మీ కంప్యూటర్లో తగినంత ఖాళీ లేదు.
మీరు ఫైల్ ఏ కార్యకలాపాలను చేసే ముందు కనుక ఇది ఎల్లప్పుడూ ముఖ్యం
మేము ఆ ఫైల్ విజయవంతంగా ప్రారంభించబడింది లేదో తనిఖీ ఆ.
సో వాట్ ఒక, ఆ fopen ఒక వాదన అని, అలాగే, మేము అనేక విధాలుగా ఫైలు విప్పగలరు.
మేము ఉంటుంది చేయగలరు, మేము, దొరుతుంది ఇప్పటికే ఫైల్ భర్తీ అంటే, అది W ​​తరలిస్తారు
మేము, వారు దీనిని భర్తీ ఫైల్ చివర కలపవచ్చు, ఇది ఒక ఒక తరలిస్తారు
లేదా మేము అంటే, r పేర్కొనవచ్చు, యొక్క ఫైలు చదవడానికి మాత్రమే ఓపెన్ అనుమతిస్తుంది.
కార్యక్రమం, ఫైలు ఏ మార్పులు చెయ్యడానికి ప్రయత్నిస్తుంది అయితే
వాటిని అరుస్తుంటారు మరియు వాటిని అది తెలియజేసేలా లేదు.
చివరగా, ఒకసారి మేము, దానిపై కార్యకలాపాలను చేయడం పూర్తి, ఫైలు పూర్తి చేసిన
మేము ఫైల్ దగ్గరగా నిర్ధారించుకోవాలనుకుంటున్నాము.
కాబట్టి మీ ప్రోగ్రామ్ యొక్క ముగింపులో, మీరు వాటిని మళ్లీ పాస్ వెళ్తున్నారు
మీరు తెరిచిన మరియు దానికి దగ్గరగా ఈ ఫైలు ఆ.
కాబట్టి ఈ మీరు మీరు నిర్ధారించడానికి కలిగి ముఖ్యమైన విషయం.
కాబట్టి మీరు ఒక ఫైల్ తెరవగలరు గుర్తు, అప్పుడు మీరు, ఫైలు వ్రాయగలరు
ఫైలు కార్యకలాపాలు, కాని మీరు చివరిలో ఫైలు దగ్గరగా ఉంటుంది.
>> ప్రాథమిక ఫైల్ ఏ ప్రశ్నలు I / O? అవును?
[స్టూడెంట్ ప్రశ్న, అపారదర్శక]
ఇక్కడే. ప్రశ్న, ఈ log.txt ఫైలు ఎక్కడ కనిపిస్తుంది ఉంది?
మీరు దాని log.txt ఇవ్వాలని ఉంటే సరే, అది executable అదే డైరెక్టరీనందు ఇది సృష్టిస్తుంది.
కాబట్టి you're ఉంటే - >> [స్టూడెంట్ ప్రశ్న, అపారదర్శక]
అవును. అదే ఫోల్డర్ లో, లేదా అదే డైరెక్టరీనందు, మీరు కాల్ వంటి.
ఇప్పుడు మెమరీ, స్టాక్, మరియు కుప్ప.
కాబట్టి కంప్యూటర్ స్థాపితం మెమరీ ఎలా ఉంది?
సరే, మీరు ఇక్కడ ఈ బ్లాక్ యొక్క విధమైన వంటి మెమరీ ఊహించవచ్చు.
మరియు మెమరీలో మేము అక్కడ కష్టం కుప్ప, మరియు అక్కడ డౌన్ అని స్టాక్ అని ఏమి ఉన్నాయి.
మరియు కుప్ప క్రిందికి పెరుగుతుంది మరియు స్టాక్ పైకి పెరుగుతుంది.
టామీ పేర్కొన్నారు కనుక - OH, బాగా, మరియు మేము నేను రెండో చూస్తారు ఈ ఇతర 4 విభాగాలు కలిగి -
టామీ ముందు చెప్పిన విధంగా, మీరు తన విధులు తమను తాము మరియు ప్రతి ఇతర కాల్ ఎలా?
వారు స్టాక్ ఫ్రేమ్ యొక్క ఈ విధమైన నిర్మించే.
Well, ప్రధాన కాల్స్ foo, foo స్టాక్ మీద ఉంచే ఉంటే.
Foo కాల్స్ బార్, బార్ యొక్క స్టాక్ ఉంచబడింది పొందండి, మరియు తర్వాత స్టాక్ మీద ఉంచే ఆ.
వారు తిరిగి మరియు, వారు ప్రతి స్టాక్ తొలగించబడింది కలుగుతుంది.
ఈ స్థానాల ప్రతి మరియు మెమరీ ఏమి కలిగి లేదు?
Well, టెక్స్ట్ భాగమైన టాప్, ప్రోగ్రామ్ కూడా ఉంది.
యంత్రం కోడ్ కాబట్టి, అక్కడ, మీరు మీ కార్యక్రమాన్ని కంపైల్.
తరువాత, ఏ ప్రపంచ వేరియబుల్స్ initialized.
>> కాబట్టి, మీరు మీ కార్యక్రమంలో ప్రపంచ వేరియబుల్స్ ఉన్నాయి, మరియు మీరు ఒక = 5, వంటి సే
ఆ విభాగంలో ఉంచారు, మరియు కుడి ఆ కింద పొందే,
మీరు కేవలం ఒక Int ఉన్న ఏదైనా అవినియోగిత ప్రపంచ డేటా కలిగి
కానీ మీరు ఏదైనా సమానం చెప్పాలి లేదు.
ఈ ప్రపంచ వేరియబుల్స్, అందుచే వారు ప్రధాన బయట ఉన్నారు రియలైజ్.
కాబట్టి ఈ డిక్లేర్డ్ కాని initialized లేదు ఏ ప్రపంచ వేరియబుల్స్ అర్థం.
కాబట్టి కుప్ప లో ఏమిటి? మెమరీ మేము కొద్ది సేపట్లో చూస్తారు ఇది malloc, ఉపయోగించి కేటాయించింది.
చివరకు, స్టాక్ మీకు ఏ స్థానిక వేరియబుల్స్ ఉన్నాయి
మరియు ఏ విధులు మీరు వారి పారామితులు ఏ కాల్ ఉండవచ్చు.
లాస్ట్ థింగ్, మీరు నిజంగా, ఎన్విరాన్మెంట్ వేరియబుల్సు ఏమి తెలుసుకోవాలి లేదు
కానీ మీరు ప్రోగ్రామ్ రన్ చేసినప్పుడు, సంబంధం ఏదో వంటి ఉంది
ఈ కార్యక్రమాన్ని నడిపిన వ్యక్తి యొక్క యూజర్ పేరు.
మరియు ఆ క్రింద విధమైన చేస్తాడు.
హెక్సాడెసిమల్ విలువలు ఇది మెమరీ చిరునామాలు, పరంగా,
0 వద్ద టాప్ ప్రారంభంలో విలువలు, మరియు అవి దిగువన వరకు డౌన్ వెళ్ళండి.
ఈ సందర్భంలో, మీరు 32-bit వ్యవస్థ మీద అయితే,
దిగువన చిరునామా ఆ 32 బిట్స్ ఎందుకంటే, AF తరువాత, 0x అవతరిస్తుంది
ఇది 8 బైట్లు, మరియు ఈ సందర్భంలో 8 బైట్లు 8 హెక్సాడెసిమల్ సంఖ్యలను సూచించదు.
కాబట్టి డౌన్ ఇక్కడ మీరు, ఇష్టం, 0xffffff చూడాలని, మరియు అక్కడ మీరు 0 చూడాలని.
సో వాట్ గమనికలు ఉన్నాయి? మీరు కొన్ని ముందు విభాగంలో ఈ కవర్ ఉండకపోవచ్చు.
కానీ మేము ఉపన్యాసంలో ఇది వెళ్ళి చేసింది, పాయింటర్ ఒక డేటా రకాన్ని కనుక
బదులుగా 50 వంటి విలువ విధమైన, అది మెమొరీ లో కొన్ని నగర చిరునామా స్టోర్స్ దుకాణాలు,.
ఆ స్మృతి వంటి [అపారదర్శక].
కాబట్టి ఈ సందర్భంలో, మనం ఉంది ఏమి, మేము, ఒక పూర్ణాంకం లేదా ఒక పూర్ణాంకానికి * ఒక పాయింటర్ కలిగి
మరియు అది 0xDEADBEEF ఈ హెక్సాడెసిమల్ చిరునామా ఉంది.
>> సో వాట్ మనం మెమొరీ కొన్ని స్థానంలో ఈ పాయింటర్ పాయింట్లు, ఇప్పుడు, ఉంది,
మరియు అది కేవలం ఒక వ్యక్తి, విలువ 50 ఈ మెమరీ స్థానం ఉంది.
కొన్ని 32-bit వ్యవస్థలు, అన్ని 32-bit వ్యవస్థ మీద గమనికలు 32 బిట్స్ లేదా 4 బైట్లు పడుతుంది.
కానీ, ఉదాహరణకు, ఒక 64-bit వ్యవస్థ మీద, గమనికలు 64 బిట్స్ ఉంటాయి.
తద్వారా మీరు గుర్తుంచుకోండి చెయ్యవచ్చును ఏదో ఉంది.
కాబట్టి ముగింపు-bit వ్యవస్థ మీద, ఒక పాయింటర్ ముగింపు బిట్స్ పొడవుగా ఉంది.
గమనికలు, అదనపు విషయాలు లేకుండా విధమైన జీర్ణమై కష్టం
కాబట్టి యొక్క డైనమిక్ మెమరీ కేటాయింపు ఒక ఉదాహరణ ద్వారా వదలి వేస్తారు.
, వాట్ డైనమిక్ మెమరీ కేటాయింపు మీకు చేస్తుంది, లేదా మేము malloc కాల్ ఏమి
మీరు సెట్ వెలుపల డేటా విధమైన కేటాయించాలని అనుమతిస్తుంది.
కాబట్టి ఈ డేటాను విధమైన కార్యక్రమం వ్యవధి కోసం శాశ్వతంగా ఉంటుంది.
మీకు తెలిసిన ఎందుకంటే, మీరు ఒక చర్య యొక్క లోపల x, మరియు ఆ ఫంక్షన్ తిరిగి డిక్లేర్ ఉంటే,
మీరు ఇకపై x నిల్వ ఆ డేటాను ప్రాప్తి.
వాట్ గమనికలు మాకు తెలియజేసేలా వారు మాకు మెమరీ లేదా స్టోర్ విలువలు నిల్వ వీలు ఉంది
అవి మెమరీ వేరే విభాగంలో, కుప్ప లో.
ఇప్పుడు ఒకసారి మేము కాలం మేము ఒక పాయింటర్ కలిగి, ఫంక్షన్ నుండి తిరిగి
మెమరీ ఆ స్థానానికి, అప్పుడు మేము ఏమి మేము అక్కడే విలువలు చూడవచ్చు ఉంది.
యొక్క ఒక ఉదాహరణ చూద్దాం: ఈ మళ్లీ మా మెమరీ లేఅవుట్ ఉంది.
మరియు మేము ప్రధాన, ఈ చర్య.
వాట్ అది ఉంది - సరే, సాధారణ, కుడి - Int x = 5, కేవలం ప్రధాన లో స్టాక్ మీద ఒక వేరియబుల్.
>> మరోవైపు, ఇప్పుడు మేము ఫంక్షన్ giveMeThreeInts పిలిచే ఒక పాయింటర్ ప్రకటిస్తాయి.
కాబట్టి ఇప్పుడు మేము ఈ ఫంక్షన్ వెళ్ళాలని మరియు మేము దీనికి కొత్త స్టాక్ ఫ్రేమ్ సృష్టించడానికి.
అయితే, ఈ స్టాక్ ఫ్రేమ్ లో, మేము, Int * టెంప్ డిక్లేర్
ఇది మాకు mallocs 3 పూర్ణ సంఖ్యలలో.
కాబట్టి Int యొక్క పరిమాణం, ఈ Int ఎన్ని బైట్లు మాకు ఇస్తుంది
మరియు malloc మాకు ఇచ్చే కుప్ప మీద స్థలం అనేక బైట్లు.
కాబట్టి ఈ సందర్భంలో, మనం, 3 పూర్ణాంకాల తగినంత స్థలం సృష్టించిన
మరియు కుప్ప నేను అధిక అప్ డ్రా చేసిన ఎందుకు ఇది అక్కడికి మార్గం.
మేము పూర్తి చేసిన తర్వాత, మేము అప్ తిరిగి ఇక్కడికి వచ్చి, మీరు మాత్రమే 3 ints తిరిగి అవసరం,
మరియు ఆ మెమొరీ ఉన్న ఈ సందర్భంలో, చిరునామా తిరిగి.
మరియు మేము పాయింటర్ = స్విచ్ సెట్, మరియు అక్కడ మేము మరొక పాయింటర్ ఉంది.
కాని తిరిగి వచ్చే చర్యలు ఇక్కడ పేర్చబడి, అదృశ్యమవుతుంది అని.
కాబట్టి టెంప్ అదృశ్యమవుతుంది, కాని మేము ఇంకా పేరు యొక్క చిరునామా నిర్వహించడానికి
ఆ 3 పూర్ణాంకాల మెయిన్స్ లోపలి ఉంటాయి.
కాబట్టి ఈ సెట్ లో, గమనికలు, ఒకదాని ఫ్రేమ్ కోసం స్థానికంగా దర్శిని గల ఉంటాయి
కానీ అవి ప్రస్తావించబడుతున్న మెమరీ నిండుగా ఉంది.
>> ఆ సమంజసం లేదు?
[స్టూడెంట్] మీరు ఆ పునరావృతం కాలేదు? >> [జోసెఫ్] అవును.
నేను తిరిగి కేవలం కొద్దిగా వెళ్ళి చేస్తే, మీరు తాత్కాలిక కేటాయింపుకు చూడండి
అక్కడ అప్ కుప్ప మీద కొన్ని మెమరీ.
కాబట్టి ఈ ఫంక్షన్, giveMeThreeInts తిరిగి, ఇక్కడ ఈ స్టాక్ అదృశ్యం అన్నారు ఉన్నప్పుడు.
మరియు ఈ సందర్భంలో వేరియబుల్స్ యొక్క ఏ, ఒకదాని చట్రంలో కేటాయించారు ఈ పాయింటర్ తో.
మేము టెంప్ తిరిగి నుంచి అదృశ్యం కు వెళ్ళి కానీ
మరియు మేము = టెంప్, పాయింటర్ ఇప్పుడు టెంప్ గా నగర అదే మెమరీ మార్చాలి జరగబోతోంది పాయింటర్ సెట్.
కాబట్టి ఇప్పుడు, మేము టెంప్, స్థానిక పాయింటర్, కోల్పోతారు కూడా
మేము ఇప్పటికీ ఆ వేరియబుల్ పాయింటర్ లోపలి సూచించే దాని యొక్క మెమరీ చిరునామా కలిగి ఉంటారు.
ప్రశ్నలు? మీరు విభాగంలో ఇది దాటి ఉండకపోతే ఒక గందరగోళంగా విషయం రకం ఉంటుంది.
మేము, మీ TF ఖచ్చితంగా అది వెళ్ళి ఉంటుంది మరియు కోర్సు యొక్క మేము ప్రశ్నలు జవాబివ్వడానికి
ఈ కోసం సమీక్ష సెషన్ ముగింపులో.
కానీ ఈ ఒక క్లిష్టమైన అంశం విధమైన ఉంది, మరియు నేను చూపించే వెళ్ళే మరిన్ని ఉదాహరణలు ఉన్నాయి
ఆ గమనికలు ఉన్నాయి ఏమి స్పష్టం సహాయం చేస్తుంది.
>> ఈ సందర్భంలో, గమనికలు, శ్రేణుల సమానంగా ఉంటాయి
కాబట్టి నేను ఒక పూర్ణాంకానికి వ్యూహం ఇదే ఈ పాయింటర్ ఉపయోగించవచ్చు.
నేను, 0 లోకి సూచి, మరియు 1 మొదటి పూర్ణాంక మారుతున్న నేను
2 రెండవ పూర్ణాంక మారుతున్న, మరియు 3 వ పూర్ణాంక 3.
గమనికలు కాబట్టి మరింత. Well, Binky గుర్తు.
ఈ సందర్భంలో, మనం ఒక పాయింటర్ కేటాయించింది చేసిన, లేదా మేము ఒక పాయింటర్ డిక్లేర్డ్
కానీ ముందుగా, నేను పాయింటర్ ప్రకటించింది, అది ఎక్కడైనా మెమరీలో సూచించే కాదు.
ఇది లోపలి కేవలం చెత్త విలువలు ఉంది.
నేను ఈ పాయింటర్ సూచించే కౌంటీ సంఖ్య ఆలోచన ఉంది.
ఇది కేవలం 0 మరియు 1 యొక్క మొదట ప్రకటించారు పేరు నింపుతారు ఒక చిరునామాను కలిగి ఉంటుంది.
నేను malloc కాల్ వరకు నేను ఈ తో ఏదీ చేయలేము
మరియు అప్పుడు నాకు లోపల విలువలు ఉంచవచ్చు పేరు కుప్ప మీద కొద్దిగా ఖాళీ ఇస్తుంది.
మళ్లీ ఈ మెమరీ లోపల ఏమి తెలియదు.
నేను లేదు మొదటి విషయం వ్యవస్థ తగినంత శక్తి ఉండేది అని తనిఖీ ఉంది
నాకు ఈ తనిఖీ చేయడం నేను ఎందుకు ఇది మొదటి స్థానంలో 1 పూర్ణాంక తిరిగి ఇవ్వాలని.
పాయింటర్ శూన్య ఉంటే, ఆ, అది తగినంత స్థలం లేదా కొన్ని ఇతర లోపం ఏర్పడింది లేదు అంటే
నేను నా ప్రోగ్రామ్ నుండి బయటకు ఉండాలి.
అది విజయవంతం చేశారు అయితే, ఇప్పుడు నేను ఆ పాయింటర్ ఉపయోగించవచ్చు
ఏ * పాయింటర్ చేస్తుంది చిరునామా ఎక్కడ కింది విధంగా ఉంది
పేరు ఆ విలువ, మరియు అది 1 కి సమానమైన సెట్లు.
ఆ స్మృతి ఉనికిలో ఉంటే ఇక్కడ పైగా మేము తనిఖీ చేస్తున్నాము.
>> మీరు ఇది ఉనికిలో తెలిసిన, మీరు దీనిని ఉంచవచ్చు
ఏ విలువ మీరు ఉంచి మీరు; ఈ సందర్భంలో 1 లో.
మేము అది పూర్తి చేసిన తర్వాత, మీరు ఆ పాయింటర్ విడిపించేందుకు అవసరం
మేము సిస్టమ్ మీరు మొదటి స్థానంలో అడిగారు ఆ మెమరీ తిరిగి పొందాలి ఎందుకంటే.
ఎందుకంటే కంప్యూటర్ మేము అది పూర్తి చేసినప్పుడు తెలియదు.
ఈ సందర్భంలో మనం స్పష్టంగా ఇది చెప్పుకుంటున్నారు, సరే, ఆ మెమరీ పూర్తి చేశారు.
కొన్ని ఇతర ప్రక్రియ ఇది ​​అవసరమైతే, కొన్ని ఇతర ప్రోగ్రామ్ కావాలి, ముందుకు వెళ్ళి, అది పడుతుంది సంకోచించకండి.
మనం కూడా చేయవచ్చు మేము సెట్ స్థానిక వేరియబుల్స్ యొక్క చిరునామా పొందుతారు.
కాబట్టి Int x ప్రధాన యొక్క అమర్చినట్లు చట్రంలో ఉంది.
మరియు మేము ఈ ఆంపర్సండ్ చిహ్నం ఉపయోగిస్తున్నప్పుడు, ఈ మరియు ఆపరేటర్లు, ఏ అది ఉంది
ఇది x పడుతుంది, మరియు x మెమరీలో కొన్ని డేటా, కాని ఇది ఒక చిరునామాను కలిగి ఉంటుంది.
ఇది ఎక్కడో ఉన్న ఉంది. ఈ ఏమి కాలింగ్ & x, ఉంటుంది కనుక ఇది మాకు x యొక్క చిరునామా ఇస్తుంది.
ఈ విధంగా చేయడం వలన, మేము x మెమరీలో ఉన్న కు పాయింటర్ పాయింట్ మీరు చేస్తున్నారు.
ఇప్పుడు మేము * లాగ x, మేము 5 తిరిగి చూడాలని లేదు.
స్టార్ ఇది dereferencing అంటారు.
మీరు చిరునామా అనుసరించండి మరియు మీరు అక్కడ నిల్వ దాని విలువను పొందగలరు.
>> ఏదైనా ప్రశ్నలు? అవును?
మీరు 3-సూటిగా పనిని లేకపోతే [స్టూడెంట్], ఇది కంపైల్ లేదు?
అవును. మీరు 3-పాయింటర్ పనిని లేకపోతే, అది ఇప్పటికీ, కంపైల్ వెళుతున్న
కానీ నేను, రెండవ లో ఏమి మీరు, మరియు ఆ చేయకుండా చేస్తాము
మేము మెమొరీ లీక్ కాల్ ఏమిటి. మీరు సిస్టమ్ ఇచ్చి లేదు
దాని మెమరీ వెనుకకు, కాబట్టి ఒక తర్వాత కార్యక్రమం పేరుకుపోవడంతో జరిగే సమయంలో
అది ఉపయోగించి కాదు, మరియు గత్యంతరం దాన్ని ఉపయోగించవచ్చు మెమరీ ఆ.
మీరు మీ కంప్యూటర్ లో 1.5 మిలియన్ ల తో Firefox చూసిన ఉంటే,
టాస్క్ మేనేజర్, ఆ ఏమి ఉంది.
వారు నిర్వహించడం లేదు ప్రోగ్రామ్ లో మెమొరీ లీక్ ఉన్నాయి.
కాబట్టి ఎలా అంక గణితానికి పని చేస్తుంది?
Well, అంక గణితానికి వ్యూహం లోకి వంటి ఇండెక్సింగ్ యొక్క విధమైన ఉంది.
ఈ సందర్భంలో, నేను ఒక పాయింటర్ కలిగి, మరియు నేను నేను మొదటి అంశానికి పాయింటర్ ఉద్దేశ్యాన్ని ఉంది
నేను కేటాయించింది చేసిన 3 పూర్ణాంకాల ఈ శ్రేణి యొక్క.
కాబట్టి ఇప్పుడు నేను ఏమి, స్టార్ పాయింటర్ కేవలం జాబితాలో మొదటి మూలకం మారుస్తుంది.
ఇక్కడ పైగా స్టార్ పాయింటర్ +1 పాయింట్లు.
కాబట్టి పాయింటర్ ఇక్కడ ఓవర్, పాయింటర్ +1 ఇక్కడ ఓవర్, పాయింటర్ +2 ఇక్కడ పైగా ఉంది.
>> కాబట్టి కేవలం 1 జోడించడం ఈ శ్రేణి పాటు కదిలే అదే విషయం.
మనం చెయ్యవలసింది ఉంది, మేము పాయింటర్ +1 చేసినప్పుడు మీరు ఇక్కడ పైగా చిరునామా పొందండి
మరియు ఇక్కడ విలువ పొందడానికి, మీరు మొత్తం వ్యక్తీకరణ నుండి ఒక నక్షత్రం ఉంచండి
అది dereference కు.
కాబట్టి, ఈ సందర్భంలో, నేను, 1 ఈ శ్రేణి లో మొదటి స్థానం సెట్ చేస్తున్నాను
2 రెండవ స్థానాన్ని, మరియు 3 మూడవ స్థానం.
అప్పుడు నేను ఇక్కడ పైగా చేయడం, నన్ను మా పాయింటర్ +1 ప్రింటింగ్ చేస్తున్నాను ఉంది
ఇది నాకు 2 ఇస్తుంది.
ఇప్పుడు నేను పాయింటర్ పెంచడం నేను, కాబట్టి పాయింటర్ పాయింటర్ +1 సమానం
ఇది ముందుకు అది కదులుతుంది.
కాబట్టి ఇప్పుడు నేను పాయింటర్ +1 ముద్రించాలా ఉంటే, పాయింటర్ +1, ఇప్పుడు 3
ఈ సందర్భంలో ఇది 3 ముద్రిస్తుంది.
మరియు ఉచిత ఏదో, అది ఇచ్చే పాయింటర్ చేయడానికి
నేను malloc నుండి తిరిగి వచ్చాయి శ్రేణి ప్రారంభంలో పై ఉండాలి.
నేను ఇక్కడ 3 కాల్ చేస్తే, ఈ సందర్భంలో, ఈ, కుడి కాదు
అది యెరే మధ్యలో ఎందుకంటే.
నేను అసలు స్థానం పొందేందుకు వ్యవకలనం కలిగి
నేను ఇది ఉచితం ముందు ప్రధమ స్థానాన్ని.
కాబట్టి, ఇక్కడ ఒక ఎక్కువ పాల్గొంటుంది ఉదాహరణకు.
ఈ సందర్భంలో, మనం ఒక పాత్ర పరిధిలో 7 అక్షరాలు పెడుతోంది చేస్తున్నారు.
>> మరియు ఈ విషయంలో మేము ఏమి చేస్తున్నామన్న, మేము వాటిని మొదటి 6 పైగా మళ్ళీ వెతికినా చేస్తున్న ఉంది
మరియు మేము Z. వాటిని సెట్ చేస్తున్నాము
కాబట్టి, Int కోసం i = 0, i> 6, నేను + +,
కాబట్టి, పాయింటర్ + నేను, ఈ సందర్భంలో, మాకు ఇస్తుంది
పాయింటర్, పాయింటర్ +1, +2 పాయింటర్, పాయింటర్ +3, అందువలన న మొదలైనవి లూప్ లో.
ఏమి చేయాలో అవకాశముంది, అది విలువ పొందడానికి, dereferences ఆ చిరునామా గెట్స్ ఉంది
ఒక Z. మరియు ఆ మార్పులు విలువ
కానీ చివరకు కుడివైపు, ఈ ఒక స్ట్రింగ్ గుర్తు?
అన్ని స్ట్రింగ్స్ శూన్య రద్దు పాత్ర ముగించాడు ఉన్నాయి.
కాబట్టి, నేను పాయింటర్ 6 లో నేను సైన్ శూన్య టెర్మినేటర్ పాత్ర పెట్టబడింది
ఇప్పుడు నేను ప్రధానంగా ఇక్కడ పైగా చేస్తున్నదాన్ని, ఒక స్ట్రింగ్ కోసం printf కుడి అమలు చేస్తున్నది?
>> కాబట్టి, ఎప్పుడు printf ఇప్పుడు ఒక స్ట్రింగ్ ముగింపు స్థానాన్ని పొందింది చేస్తుంది?
అది శూన్య రద్దు పాత్ర తగిలినప్పుడు.
కాబట్టి, ఈ సందర్భంలో, ఈ శ్రేణి యొక్క ప్రారంభానికి నా అసలు పాయింటర్ పాయింట్లు.
నేను మొదటి పాత్రను ప్రింట్. నేను ఒక మీద అది తరలించు.
నేను ఆ పాత్రను ప్రింట్. నేను దాని పై తరలించు.
మరియు నేను ముగింపు చేరుకోవడానికి వరకు ఈ పనిని.
ఇప్పుడు ముగింపు * పాయింటర్ రెడీ dereference ఈ మరియు శూన్య రద్దు పాత్ర తిరిగి.
మరియు నా అయితే లూప్ ఆ విలువ శూన్య రద్దు అక్షరం మాత్రమే నడుస్తుంది.
కాబట్టి, ఇప్పుడు నేను ఈ లూప్ నుండి నిష్క్రమించండి.
కాబట్టి నేను, ఈ పాయింటర్ నుండి 6 వ్యవకలనం ఉంటే
నేను తిరిగి ప్రారంభం వరకు వెళ్ళండి.
నేను ఇది ఉచితం చేయడానికి ప్రారంభానికి వెళ్ళు ఉంటాయి, ఎందుకంటే గుర్తుంచుకోండి, నేను ఇలా చేస్తున్నాను.
>> కనుక, నేను ఒక చాలా ఉంది తెలుసు. ఏ ప్రశ్నలు ఉన్నాయా?
దయచేసి, అవును?
[స్టూడెంట్ ప్రశ్న అపారదర్శక]
మీరు బిగ్గరగా చెప్పగలరు? క్షమించాలి.
[స్టూడెంట్] మీరు పాయింటర్ విముక్తి కుడి ముందు చివరి స్లయిడ్ న
మీరు నిజంగా పాయింటర్ యొక్క విలువను మార్చడం జరిగింది?
[జోసెఫ్] కాబట్టి ఇక్కడే. >> [స్టూడెంట్] ఓహ్, ఓకే.
[జోసెఫ్] కాబట్టి, నేను, ఒక పాయింటర్ మైనస్ మైనస్ కలిగి,
ఇది నేను ఇది ఉచితం అప్పుడు ఒక విషయం వెళుతుంది,
ఈ పాయింటర్ శ్రేణి ప్రారంభంలో మళ్లించాల్సిన కలిగి.
మీరు ఆ పంక్తిలో తర్వాత ఆగిపోయింది [స్టూడెంట్] కానీ అవసరం లేదు అని.
నేను ఈ తరువాత ఆగిపోయింది ఉంటే [జోసెఫ్] అందువలన, ఈ, మెమొరీ లీక్ అవుతుంది
నేను ఉచిత అమలు ఎందుకంటే.
[స్టూడెంట్] నేను [అపారదర్శక] మీరు పాయింటర్ +1 [అపారదర్శక] కలిగి ఉన్న మొదటి మూడు పంక్తులు తరువాత.
[జోసెఫ్] మారుపేర్లు హుహ్. కాబట్టి, అక్కడ ప్రశ్న ఏమిటి?
క్షమించాలి. లేదు, లేదు. దయచేసి వెళ్లి, వెళ్ళండి.
[స్టూడెంట్] కాబట్టి, మీరు గమనికలు యొక్క విలువను మార్చడం లేదు.
మీరు పాయింటర్ మైనస్ మైనస్ అనుకుంటున్న కాదు.
[జోసెఫ్] అవును, సరిగ్గా.
కనుక, నేను పాయింటర్ +1 మరియు పాయింటర్ +2 చేసినప్పుడు,
నేను పాయింటర్ చేయడం లేదు పాయింటర్ +1 సమానం.
కాబట్టి, పాయింటర్ కేవలం శ్రేణి ప్రారంభంలో పై ఉంటుంది.
నేను ప్లస్ చేసినప్పుడు అది ప్లస్ అది పాయింటర్ లోపల తిరిగి విలువ సెట్ చేసే
నిజానికి పాటు ఈ కదిలే.
అన్ని కుడి.
మరిన్ని ప్రశ్నలు?
>> ఈ అధిక యొక్క విధమైన ఉంటే మళ్ళీ, ఈ సెషన్ లో కవర్ చేస్తుంది.
దాని గురించి మీ బోధన తోటి అడగండి, మరియు మేము చివరిలో ప్రశ్నలకు.
మరియు సాధారణంగా మేము ఈ మైనస్ పనిని చేయడానికి ఇష్టం లేదు.
ఈ నాకు యెరే నందలి ఆఫ్సెట్ చేసిన ఎంత పర్యవేక్షించడం అవసరం ఉంది.
కాబట్టి, సాధారణంగా, ఈ అంక గణితానికి ఎలా పనిచేస్తుంది వివరించడానికి కేవలం ఉంది.
కాని మేము సాధారణంగా చేయాలని, మేము పాయింటర్ కాపీని సృష్టించడానికి లాగా ఉంటుంది
మేము స్ట్రింగ్ లో చుట్టూ తరలించడానికి చేసినప్పుడు మరియు అప్పుడు ఆ కాపీని ఉపయోగిస్తాము.
కాబట్టి, ఈ విషయంలో మీరు కాపీ, మొత్తం స్ట్రింగ్ ప్రింట్ ఉపయోగించే
కానీ మేము, పాయింటర్ మైనస్ 6 వంటి లేదు లేదా మేము ఈ వచ్చారు ఎంత ట్రాక్ లేదు
మేము మా అసలు పాయింట్ ఇప్పటికీ జాబితా ప్రారంభం చూపారు మనకు తెలుసు కనుక
మరియు మేము మార్చివేసింది ఈ కాపీని ఉంది.
కాబట్టి, సాధారణంగా, మీ అసలు పాయింటర్ యొక్క కాపీలు మారుస్తాయి.
వంటి యొక్క క్రమం చేయడానికి ప్రయత్నించండి లేదు - అసలు కాపీలు మార్పు don't.
మీ అసలు మాత్రమే కాపీలు మార్చడానికి ప్రయత్నిస్తున్న.
మేము printf లోకి స్ట్రింగ్ పాస్ కనుక, మీరు గమనిస్తారు
మీరు, మేము అన్ని ఇతర dereferences ద్వారా కూడా లాగా ముందు స్టార్ ఉంచారు హక్కు లేదు?
మీరు మొత్తం స్ట్రింగ్% s ఆశిస్తున్నట్లు ముద్రించాలా చేస్తే, ఒక చిరునామా
మరియు ఈ సందర్భంలో ఒక పాయింటర్ లేదా అక్షరాల యొక్క శ్రేణి వంటి ఈ సందర్భంలో.
>> అక్షరాలు, చార్ * s, మరియు శ్రేణుల ఇదే ఉంటాయి.
పాయింటర్ అక్షరాలు ఉంది, మరియు పాత్ర శ్రేణుల ఇదే ఉంటాయి.
కాబట్టి, మేము అన్ని పాయింటర్ లో తరలింపు.
మేము * పాయింటర్ లేదా అలాంటిదే ఏదైనా వంటి లో పాస్ లేదు.
కాబట్టి, శ్రేణుల మరియు గమనికలు ఇదే ఉంటాయి.
మీరు X వంటి చెయ్యడానికి చేసిన తర్వాత ఇక్కడ పైగా వ్యూహం కోసం [y],
ఏది హుడ్ కింద ఏమి అది చెప్పడం అని, సరే, అది, ఒక పాత్ర శ్రేణి యొక్క
కాబట్టి ఇది ఒక పాయింటర్ ఉంది.
కాబట్టి x, ఇదే ఉంటాయి
మరియు కనుక ఇది ఏమి చేస్తుంది, ఇది x కు y జతచేస్తుంది ఉంది
ఆ మెమరీని ముందుకు వెళ్ళటం ఇదే ఇది.
ఇప్పుడు x + y, మాకు చిరునామా విధమైన ఇస్తుంది
మరియు మేము చిరునామా dereference లేదా బాణం అనుసరించండి
పేరు మెమరీ ఆ స్థానం మరియు మేము మెమరీ ఆ నగర విలువ పొందడానికి.
కాబట్టి, అందువలన ఈ రెండు సరిగ్గా ఇదే ఉంటాయి.
ఇది కేవలం ఒక వాక్యనిర్మాణ చక్కెర ఉంటుంది.
వారు ఇదే. వారు ప్రతి ఇతర కోసం వివిధ వాక్యనిర్మాణ ఉన్నారు.
>> కాబట్టి, గమనికలు తప్పు ఏమి చేయగలరు? చాలా, ఇష్టపడుతున్నారు. సరే. కాబట్టి, చెడు విషయాల.
మీ malloc కాల్ శూన్య, కుడి తిరిగి మీరు చెయ్యగలిగిన కొన్ని చెడు విషయాల తనిఖీ లేదు?
ఈ సందర్భంలో, నేను నాకు ఇవ్వండి సిస్టమ్ అడగడం నేను - ఆ నంబర్ ఏమిటి?
ఒక పూర్ణ సంఖ్య యొక్క పరిమాణం 4 బైట్లు ఎందుకంటే, 2 బిలియన్ సార్లు 4 ఇష్టపడుతున్నారు.
నేను 8 బిలియన్ బైట్లు వంటి కోసం అందులో నేను.
అయితే నా కంప్యూటర్ నాకు ఆ మెమరీని తిరిగి ఇవ్వాలని చెయ్యడానికి వెళ్ళడం లేదు.
ఈ శూన్య ఉంటే మరియు మేము అక్కడ dereference అది ప్రయత్నించినప్పుడు కాబట్టి, తనిఖీ లేదు -
అది వెళుతున్న పేరు బాణం అనుసరించండి - మేము ఆ స్మృతి లేదు.
ఈ మేము ఒక నల్ పాయింటర్ dereferencing పిలుస్తాము.
మరియు ఇది తప్పనిసరిగా మీరు segfault చేస్తుంది.
ఈ మీరు segfault చేయవచ్చు మార్గం.
మీరు ఇతర చెడ్డ విషయాలు - బాగా ఓహ్.
ఒక నల్ పాయింటర్ dereferencing జరిగినది. సరే.
ఇతర తప్పుడు విషయాలు - బాగా, మీరు అక్కడ ఒక చెక్ పెట్టే పరిష్కరించడానికి
ఆ పాయింటర్ శూన్య అనే వెతుకుతుంది
ఆ malloc ఒక నల్ పాయింటర్ తిరిగి జరిగితే మరియు ప్రోగ్రామ్ నుండి నిష్క్రమించండి.
Xkcd హాస్య పేర్కొంది. ప్రజలు ఇప్పుడు అర్థం. అబ్బాయి.
>> కాబట్టి, మెమరీ. నేను ఈ పైగా జరిగింది.
మేము ఒక లూప్ లో malloc పిలుపు కానీ మేము malloc కాల్ ప్రతిసారీ మీరు
మేము, ఈ పాయింటర్ సూచించే కౌంటీ యొక్క ట్రాక్ కోల్పోతున్నాము
మేము అది clobbering అయినందున.
కాబట్టి, malloc ప్రారంభంలో కాల్ నన్ను ఇక్కడ మెమరీ మీద ఇస్తుంది.
ఈ నా పాయింటర్ పాయింటర్లు.
ఇప్పుడు నేను ఇది ఉచితం లేదు, కాబట్టి ఇప్పుడు నేను మళ్ళీ కాల్ malloc.
ఇప్పుడు అది ఇక్కడ పాయింట్ల. ఇప్పుడు నా మెమరీ ఇక్కడ పైగా సూచించబడిన.
ఇక్కడ పైగా గురిపెట్టి. ఇక్కడ పైగా గురిపెట్టి.
కానీ నేను ఇక్కడ నేను కేటాయింపుకు అన్ని మెమరీ అడ్రసులను వివరాలు కోల్పోయి.
కాబట్టి ఇప్పుడు నేను వాటిని ఇకపై ఏ సూచన లేదు.
కనుక, నేను ఈ లూప్ వెలుపల వారిని కాదు.
కాబట్టి, ఈ వంటి ఏదో పరిష్కరించే క్రమంలో
మీరు ఉచిత మెమరీ మర్చిపోతే మరియు మీరు ఈ మెమొరీ లీక్ వస్తే,
మీరు పూర్తి చేసిన తర్వాత ఈ లూప్ యొక్క లోపల మెమరీ విడిపించేందుకు ఉంటుంది.
Well, ఈ ఏమి ఉంది. నేను మీరు మా ఈ ద్వేషం తెలుసు.
కానీ ఇప్పుడు - అవును! మీరు 44,000 లు వంటి పొందండి.
కాబట్టి, మీరు, లూప్ చివరిలో ఇది ఉచితం
మరియు కేవలం మెమరీ ప్రతిసారీ విముక్తికై జరగబోతోంది.
ముఖ్యంగా, మీ ప్రోగ్రామ్ ఇకపై మెమొరీ లీక్ లేదు.
>> ఇప్పుడు మీరు చేయవచ్చు ఏదో మీరు రెండుసార్లు అడిగారు చేసిన కొన్ని మెమరీ ఉచితం.
ఈ సందర్భంలో, మీరు malloc ఏదో, మీరు దాని విలువ మార్చండి.
మీరు పూర్తి తెలిపారు ఒకసారి ఎందుకంటే మీరు ఇది ఉచితం.
కానీ మేము దాన్ని మళ్ళీ విముక్తి.
ఇది చాలా దురదృష్టకరం విషయం.
ఇది మొదట segfault మాత్రం కాదు
కానీ తర్వాత ఈ జంట ఈ అవినీతిపరులు మీ కుప్ప నిర్మాణం ఉండండి ఏమి ఉన్నప్పుడు,
మీరు CS61 వంటి తరగతి తీసుకోవాలని ఎంచుకుంటే మరియు మీరు దీని గురించి కొద్దిగా ఎక్కువ నేర్చుకోవచ్చు.
కానీ ముఖ్యంగా తర్వాత మీ కంప్యూటర్ అయోమయం పెట్టడానికి జరిగే సమయంలో
- పేరు మరియు అది నిల్వ ఏమి స్మృతిని గురించి
పేరు డేటా మెమరీలో నిల్వ చేయబడుతుంది.
కాబట్టి ఒక పాయింటర్ ఉండండి రెండుసార్లు మీరు అనుకుంటున్న ఒక చెడ్డ విషయం.
>> తప్పు వెళ్ళే ఇతర విషయాల sizeof ఉపయోగించడం లేదు.
కాబట్టి, ఈ విషయంలో మీరు, 8 బైట్లు malloc
మరియు ఆ కుడి, రెండు పూర్ణాంకాల అదే విషయం?
కాబట్టి, అది ఖచ్చితంగా సురక్షితంగా, అయితే?
Well, లుకాస్, వివిధ ఆకృతులనందు గురించి మాట్లాడింది
పూర్ణాంకాల వివిధ కాల యొక్క ఉన్నాయి.
కాబట్టి, మీరు ఉపయోగించే ఆ ఉపకరణంపై, పూర్ణ గురించి 4 బైట్లు ఉన్నాయి
కానీ కొన్ని ఇతర వ్యవస్థ మీద వారు 8 బైట్లు కావచ్చు లేదా అవి 16 బైట్లు కావచ్చు.
కాబట్టి, నేను ఇక్కడ ఈ సంఖ్య ఉపయోగిస్తే,
ఈ కార్యక్రమం, ఉపకరణంపై పనిచేయవచ్చు
కానీ కొన్ని ఇతర వ్యవస్థ తగినంత మెమరీ కేటాయించే మాత్రం కాదు.
ఈ సందర్భంలో, ఈ sizeof ఆపరేటర్లు ఉపయోగిస్తారు ఏమిటి.
ఈ ఉండదు మేము కాల్ చేసినప్పుడు sizeof (Int),
అది మాకు కార్యక్రమం అమలు చేస్తున్నట్లు వ్యవస్థ మీద ఒక పూర్ణ సంఖ్య యొక్క పరిమాణం ఇస్తుంది.
కాబట్టి, ఈ సందర్భంలో, sizeof (Int), ఉపకరణం వలె ఏదైనా 4 తిరిగి
మరియు ఇప్పుడు 8 ఇది ఈ విల్ 4 * 2,
ఇది కేవలం రెండు పూర్ణాంకాల అవసరం స్పేస్ మొత్తం.
ఒక విభిన్నమైన విధానం, ఒక Int 16 బైట్లు లేదా 8 బైట్లు వంటి ఉంటే,
అది కేవలం ఆ మొత్తం నిల్వచేయటానికి కావలసినంత బైట్లు తిరిగి వెళుతున్న.
>> చివరకు, structs.
కాబట్టి, మీరు మెమరీ లో ఒక సుడోకు బోర్డు నిల్వ కోరుకుంటే, ఎలా మేము దీన్ని ఉండవచ్చు?
మీరు మొదటి విషయం కోసం ఒక వేరియబుల్ వంటి భావిస్తారు ఉండవచ్చు
రెండవ విషయం కోసం ఒక వేరియబుల్, మూడవ విషయం కోసం ఒక వేరియబుల్,
చెడు, కుడి - నాలుగో విషయం కోసం ఒక వేరియబుల్?
కాబట్టి, మీరు ఈ పైన చేయవచ్చు ఒక అభివృద్ధి ఒక 9 x 9 శ్రేణి చేయడమే.
ఆ మంచిది, కానీ మీరు సుడోకు బోర్డు ఇతర అంశాలను అనుబంధించాలి అనుకున్నవే ఉంటే
, బోర్డు యొక్క కష్టం గురించే
లేదా, ఉదాహరణకు, మీ స్కోర్, లేదా ఎంత సమయం మీరు ఈ బోర్డు పరిష్కారానికి తీసుకువెళ్లారు?
Well, మీరు ఏమి మీరు ఒక struct సృష్టించవచ్చు ఉంది.
నేను ప్రధానంగా చెప్పడం, నన్ను ఇక్కడ ఈ నిర్మాణం నిర్వచించు చేస్తున్నాను ఉంది
మరియు నేను x 9 9 ఒక బోర్డు ను కలిగి ఉండే సుడోకు బోర్డు నిర్వచించు చేస్తున్నాను.
>> మరియు అది స్థాయి పేరు గమనికలు కలిగి ఉన్నాయి ఏమి.
ఇది కూడా నేను ఇప్పుడు ఎక్కడ యొక్క అక్షాంశాలు ఇవి x మరియు y, ఉన్నాయి.
ఇది సమయం [అపారదర్శక] గడిపాడు, మరియు నేను ఇప్పటివరకు ఇన్పుట్ చేసిన ఎత్తుగడలు మొత్తం ఉన్నాయి.
కాబట్టి ఈ సందర్భంలో, నేను కేవలం ఒక నిర్మాణాన్ని డేటా యొక్క ఒక సంపూర్ణ బంచ్ సమూహాన్ని చేయవచ్చు
బదులుగా వివిధ వేరియబుల్స్ వంటి లో చుట్టూ ఎగిరే లాగా కలిగి
నేను నిజంగా ట్రాక్ ఉంచకూడదు ఆ.
మరియు ఈ మాకు ఈ struct లోపలి వివిధ విషయాలను సూచిస్తూ యొక్క విధమైన కేవలం nice సింటాక్స్ పేర్కొనడానికి అనుమతిస్తుంది.
నేను board.board లాగే మరియు నేను తిరిగి సుడోకు బోర్డు పొందండి.
Board.level, నేను ఎంత కఠినమైన పొందండి.
Board.x మరియు board.y నాకు బోర్డు లో ఉండవచ్చు యొక్క అక్షాంశాలు ఇస్తాయి.
కాబట్టి నేను మేము struct ఫీల్డ్ కాల్ ఏమి యాక్సెస్ చేస్తున్నాను.
ఈ నేను కలిగి, ఇది ఒక రకమైన sudokuBoard, నిర్వచిస్తుంది.
ఇప్పుడు మేము ఇక్కడ ఉన్నాము. నేను రకం sudokuBoard యొక్క "బోర్డు" అని ఒక వేరియబుల్ ఉన్నాయి.
కాబట్టి ఇప్పుడు నేను ఇక్కడ ఈ నిర్మాణం చేసిన అన్ని రంగాల్లో యాక్సెస్ చేయవచ్చు.
>> Structs గురించి ప్రశ్నలు? అవును?
Int x, y కోసం [స్టూడెంట్], మీరు ఒక లైన్ రెండు ప్రకటించింది? >> [జోసెఫ్] మారుపేర్లు హుహ్.
[స్టూడెంట్] కాబట్టి, వాటిని అన్ని ఆ పని చేయడు?
X వలే, Y కామా సార్లు మొత్తం?
[జోసెఫ్] అవును, మీరు ఖచ్చితంగా నేను అదే మార్గం లో x మరియు y ఉంచారు కారణం, కాని కాలేదు -
మేము అదే లైన్ చేయవచ్చు ఎందుకు మరియు ప్రశ్న?
ఎందుకు మేము అదే లైన్ లో ఈ అన్ని ఉంచవద్దు
x మరియు y ప్రతి ఇతర సంబంధించిన,
మరియు ఈ ఒక కోణంలో, కేవలం ఆకృతిని మరింత సరైనది
ఒకే పంక్తి రెండు విషయాలు గ్రూపింగ్ను ఎందుకంటే
ఆ విధమైన వంటి ఇదే సంబంధించినవి.
మరియు నేను దూరంగా ఈ విడిపోయారు. ఇది కేవలం శైలి విషయం.
ఇది క్రియాశీలంగా ఎలాంటి తేడా చేస్తుంది.
Structs ఏ ఇతర ప్రశ్నలు?
మీరు struct ఒక Pokédex నిర్వచించలేదు.
ఒక పోకీమాన్ ఉన్నాయి మరియు ఇది ఒక లేఖ, ఒక యజమాని, ఒక రకం లేదు.
మీరు పోకీమాన్ యొక్క వ్యూహం ఉంటే అప్పుడు, మీరు కుడి, ఒక Pokédex అప్ చేయవచ్చు?
సరే, చల్లని. కాబట్టి, structs ప్రశ్నలకు. ఆ structs కలిగి ఉన్నాయి.
>> చివరగా, GDB. GDB మీరు ఏమి వీలు లేదు? మీరు మీ కార్యక్రమాన్ని డీబగ్ అనుమతిస్తుంది.
మీరు GDB ఉపయోగించరు ఉంటే, నేను చిన్న చూడటం సిఫార్సు చేస్తుంది
మరియు కేవలం GDB ఉంది వాటిని వెళ్ళి ఎలా మీరు, మీరు ఏ విధంగా ఉపయోగించుకోవాలో, అది పని
మరియు ఒక కార్యక్రమంలో దీనిని పరీక్షించడానికి.
కాబట్టి GDB మీరు చెయ్యడానికి వీలు ఏది విరామం [అపారదర్శక] మీ ప్రోగ్రామ్ అనుమతిస్తుంది ఉంది
మరియు ఒక ఆచరణాత్మక లైన్.
ఉదాహరణకు, నేను, నా ప్రోగ్రామ్ యొక్క లైన్ 3 వంటి వద్ద విరామం అమలు చేయదలిచిన
మరియు నేను లైన్ 3 వద్ద వెళుతున్నాను నేను ఉన్నాయి అన్ని విలువలు అవుట్ ముద్రించవచ్చు.
ఒక లైన్ లో pausing వంటి మరియు కాబట్టి మేము ఏమి కాల్
మేము ఈ లైనును ఒక బ్రేక్ పాయింట్ ఉంచడం పిలుస్తారు
మరియు తర్వాత మేము ఆ సమయంలో ప్రోగ్రామ్ యొక్క స్థితి వద్ద వేరియబుల్స్ అవుట్ ముద్రించవచ్చు.
>> మేము అప్పుడు నుండి ప్రోగ్రామ్ లైన్ ద్వారా లైన్ ద్వారా అక్కడ అడుగు చేయవచ్చు.
మరియు తర్వాత మేము సమయంలో స్టాక్ రాష్ట్రంలో చూడవచ్చు.
కాబట్టి GDB, మనం చెయ్యవలసింది మేము సి ఫైల్లో గణగణమని ద్వని చేయు పిలుపు, ఉపయోగించడానికి
కానీ మేము దానిని ggdb జెండా పాస్ ఉంటుంది.
మరియు ఒకసారి మేము కేవలం ఫలిత అవుట్పుట్ ఫైల్ లో GDB అమలు ఆ పూర్తి చేశారు.
కాబట్టి మీరు ఈ వంటి టెక్స్ట్ యొక్క కొన్ని వంటి సామూహిక పొందండి
కానీ మీరు చేయాల్సిందల్లా నిజంగా అన్ని ప్రారంభంలో ఆదేశాలను టైప్ ఉంది.
బ్రేక్ ప్రధాన ప్రధాన వద్ద ఒక బ్రేక్ పాయింట్ ఉంచుతుంది.
జాబితా 400 లైన్ 400 చుట్టూ లైన్స్ ఆఫ్ కోడ్ జాబితా.
కాబట్టి ఈ విషయంలో మీరు, OH, చుట్టూ చూసి చెప్పగలను
నేను ఈ వాక్యం ఇది లైన్ 397 వద్ద ఒక బ్రేక్ పాయింట్, సెట్ చేయాలనుకుంటున్నారా
ఆపై మీ ప్రోగ్రామ్ ఆ దశ లో నడుస్తుంది మరియు ఇది బ్రేక్ చెప్పారు.
అక్కడ విరామం అవకాశముంది, మరియు మీరు, ఉదాహరణకు, తక్కువ లేదా ఎక్కువ విలువ అవుట్ ముద్రించవచ్చు.
కాబట్టి మీరు తెలుసుకోవలసిన ఆదేశాల బంచ్ ఉన్నాయి
మరియు ఈ స్లైడ్, వెబ్సైట్ లో వెళ్తుంది
మీరు ఈ ప్రస్తావించడానికి కావలసిన లేదా మీ మోసగాడు షీట్ మీద వారికి ఇష్టం అయితే, సంకోచించకండి.
>> కూల్. ఆ క్విజ్ రివ్యూ 0, మరియు మీరు ఏవైనా ప్రశ్నలు ఉంటే మేము చుట్టూ కర్ర చేస్తాము.
అన్ని కుడి.
>> [చప్పట్లు]
>> [CS50.TV]