[Powered by Google Translate] [Walkthrough - సమస్య సెట్ 2]
[Zamyla చాన్ - హార్వర్డ్ యూనివర్శిటీ]
[ఈ CS50 ఉంది. CS50.TV]
అన్ని కుడి. హలో, ప్రతి ఒక్కరూ, మరియు Walkthrough 2 కు స్వాగతం.
మొదటి, నేను pset 1 నిలిచినందుకు మీరు అభినందించటానికి కావలసిన.
నేను, మీరు కొన్ని ఒక బిట్ కఠినమైన ఉండేవి తెలుసు
మీరు రాసిన మీ మొదటి కంప్యూటర్ ప్రోగ్రామ్ ఉండేవి,
కానీ, మీరు సెమిస్టర్ చివరిలో తిరిగి చూడాలని, ఈ చివర గుర్తుంచుకోవాలి
మీరు pset 1 వద్ద పరిశీలిస్తాము మరియు మీరు "అని 5 నిమిషాల్లో. హే, నేను చేసి" సే చేస్తాము
కాబట్టి తెలిసిన మరియు ఈ చివరలో మీరు ఖచ్చితంగా చాలా సరళంగా pset 1 పొందుతారు విశ్వసిస్తున్నాను.
కానీ ఇప్పుడు ఇది ఒక పూర్తియింది, మరియు సద్వినియోగపరచవచ్చు కోసం అభినందనలు.
ఇప్పుడు కూడా త్వరిత గమనిక మేము walkthrough యొక్క మాంసం పొందడానికి ముందు.
నేను కొన్నిసార్లు తగిన సమయం ఉండదు ఒక త్వరిత గమనిక అనుకున్న
పూర్తి వివరణలు సమయంలో సమస్య సెట్ చేయడం ప్రతి ఒక్క మార్గం ద్వారా వెళ్ళడానికి
మరియు కేవలం ఉండవచ్చు ఆచరణలు యొక్క 1 లేదా 2 రకం మీద దృష్టి
మీరు ఈ చేయగల మార్గాలను.
కానీ అది మరొక విధంగా చేయడం నిషేధము కాదు ఉంది.
పనులను అనేక మార్గాలు, కంప్యూటర్ సైన్స్ వలె, తరచుగా ఉన్నాయి
అందువలన కచ్చితంగా నేను అందించిన ఉండవచ్చు కంటే పరిష్కారం యొక్క ఒక భిన్నమైన రకానికి ఉపయోగించడానికి సంకోచించకండి.
[Pset 2: క్రిప్టో - Zamyla చాన్ - zamyla@cs50.net]
[Pset2 - 0. ప్రశ్నల యొక్క విభాగం - 1. సీజర్ - 2. విజెనెరే]
అన్ని కుడి. కాబట్టి సమస్య 2 సెట్: క్రిప్టో ఒక ఆహ్లాదకరమైన ఒకటి.
మళ్లీ, ప్రతి pset మీకు ప్రశ్నలు ఒక విభాగం ప్రారంభం చేస్తాము
మీ కేటాయించిన టీచింగ్ తోటి మీ విభాగాలు నిర్వహించిన చేస్తాడు.
మేము, walkthrough పైగా ఈ ద్వారా వెళ్ళడానికి వెళ్ళడం లేదు
కానీ అవి మీరు pset పూర్తి సహాయం చేస్తుంది.
కాబట్టి సమస్య సెట్ మొదటి భాగం సీజర్ ఉంది.
కాబట్టి సీజర్ లో ఎవరైనా, మీరు ఒక పూర్ణాంకం ఒక కీ పాస్ కనిపిస్తుంది
మరియు వారు మీరు అందించే టెక్స్ట్ యొక్క స్ట్రింగ్ గుప్తీకరించును
మరియు ఎన్క్రిప్టెడ్ విషయం వాటిని తిరిగి ఇవ్వండి.
ఎవరైనా క్రిస్మస్ స్టోరీ వీక్షించారు ఉంటే, అక్కడ ఆ యొక్క ఒక ఉదాహరణ ఉంది.
అప్పుడు సమస్య సెట్ రెండవ భాగం, విజెనెరే ఉంది
ఇది మరింత ఆధునిక ఎన్క్రిప్షన్ టెక్నిక్.
కాబట్టి మేము, వచనం యొక్క ఒక భాగాన్ని encipher చూడాలని
బదులుగా కేవలం ఒక పూర్ణాంకం తో తప్ప, మేము దీన్ని ఎన్కోడ్ చూడాలని
యూజర్ మాకు అందించే కీవర్డ్ తో.
సరే, పేజీలు నేడు మొదటి సాధనం వాస్తవానికి ఉపకరణం నవీకరించడాన్ని అవతరిస్తుంది.
చర్చా వేదిక పైన మేము, వంటి వాటిని చూస్తాము "ఎందుకు ఈ పనిచేయటం లేదు?"
"ఎందుకు పని 50 సమర్పించండి లేదు?"
మరియు తరచుగా SOLUTION మీ ఉపకరణం నవీకరించడానికి కేవలం వాస్తవానికి ఉంది.
కాబట్టి మీరు మీ ఉపకరణం సుడో yum-y ఒక టెర్మినల్ విండో లో అమలు చేస్తే -
ఆ అవును వార్తను జెండా యొక్క, ప్రతిదీ update - నవీకరణను,
అవసరం ఉంటే అప్పుడు మీ ఉపకరణం నవీకరిస్తారు.
మీరు ఇప్పటికే ఉపకరణం యొక్క అత్యంత తాజా వెర్షన్ వద్ద ఉంటే మరియు అది బాధిస్తుందని లేదు.
అప్పుడు అది ఏ కొత్త నవీకరణలు అందుబాటులో చెబుతాను మరియు మీరు వెంట పని కొనసాగించవచ్చు.
కానీ ఈ కూడా మీరు ఉపకరణం తెరిచిన ప్రతిసారీ అమలు మంచి ఉంది
మేము ఇంకా చాలా ఉన్నాము ఎందుకంటే -
పరికరంలోని దీన్ని పరిష్కరించడానికి - కొన్నిసార్లు మేము ఒక బగ్ వస్తాయి ఉంటే.
కాబట్టి మీరు ఉపకరణం యొక్క అత్యంత తాజా వెర్షన్ ఉందని నిర్ధారించుకోండి
మరియు అక్కడ నవీకరించుట అమలు.
అన్ని కుడి. మేము అక్షరాలు వ్యవహరించే మరియు మారుతున్న, విషయాలు enciphering, మీరు కనుక నుండి
మేము నిజంగా మా ASCII పట్టిక మంచి స్నేహితులు కోరిక చూడాలని.
మీరు భావిస్తే అనేక వాటిని, ఆన్లైన్ ఉన్నాయి. బహుశా మీ స్వంత తయారు కూడా.
సాధారణంగా, ప్రతి అక్షరం ప్రతి సంఖ్య ప్రతి పాత్ర
వాటికి సంబంధించిన అనేక ఉంది
మరియు కనుక ఇది వాస్తవ లేఖ పాటు వారి ASCII విలువలు చూడటానికి బావుంటుంది.
ఆ ఖచ్చితంగా సమస్య సెట్ లో మీరు సహాయం చేస్తుంది.
నిజంగా ఈ సమస్య సెట్ లో నన్ను సాయపడింది ఒక విషయం, వాస్తవానికి అది ముద్రించాలా ఉంది
నేను ద్వారా వెళుతున్నానని మరియు, నిజానికి, ఇది అందుకున్నాయి
, రాయడానికి "ఈ అక్కడ వెళ్ళడానికి కలిగి ఉంటే, అప్పుడు ..."
యొక్క విధమైన తీసుకుంటారు మరియు మార్కప్, మీ ASCII పట్టిక తో మంచి స్నేహితులవుతారు.
అప్పుడు మేము మా పారవేయడం వద్ద కొన్ని ఇతర పరికరాలను కలిగి.
ఈ సమయంలో బదులుగా వాస్తవానికి వారి ఇన్పుట్ అన్ని యూజర్ ప్రాంప్ట్
మేము కలయిక చేయబోతున్నామని.
మేము కొన్ని ఇన్పుట్ కోసం ప్రాంప్ట్ చూడాలని
కానీ మేము కూడా కేవలం కమాండ్ లైన్ వాదనలు ఉపయోగించడానికి వెళుతున్న.
కాబట్టి వారు తమ అమలు చేసేటప్పుడు, సాధారణంగా మీరు చెప్పారు. / హలో, ఉదాహరణకు,
మీ ప్రోగ్రామ్ hello.c ఉంటే.
కానీ ఈ సమయంలో బదులుగా కేవలం చెప్పి, తర్వాత వారు పదాలు, వాదనలు ఉంచవచ్చు.
వారు కూడా వారి ఇన్పుట్ వంటి మాకు లో పాస్ ఏ కాబట్టి మేము ఉపయోగించడానికి వెళుతున్న
కాబట్టి కేవలం పూర్ణాంక కోసం ప్రాంప్ట్ మించి కదిలే కానీ కమాండ్ లైన్ వాదనలను ఉపయోగించి.
మరియు తర్వాత మేము అలాగే చాలా ఉపయోగించి వస్తుంది ఇది శ్రేణుల మరియు తీగలు లోకి తీసుకెళ్తుంది.
ఇక్కడ 1 మినీ ASCII చార్ట్ కేవలం ఉదాహరణకు.
నేను అన్నాడు, ప్రతి అక్షరం అనేక అనుగుణంగా
అందువలన, అంతటమీరే సుపరిచితులు. ఇది ఉపయోగకరంగా ఉండగలదో.
మరియు తరువాత మేము సంఖ్యలు వ్యవహరించే కొన్ని ASCIIMath చేయడం ప్రారంభించినప్పుడు -
వాటిని తీసివేయడం, జోడించడం - ఈ పట్టికను సూచిస్తున్నారు అప్పుడు ఖచ్చితంగా మంచి.
మీరు ఆడి అని ఏదో - ఇక్కడ ఒక సీజర్ సాంకేతికలిపి యొక్క ఉదాహరణకు.
ఇది కేవలం ఒక వీల్ ఉంది. ముఖ్యముగా, ఒక బాహ్య వర్ణమాల ఉంది మరియు తర్వాత ఒక అంతర్గత వర్ణమాల ఉంది.
కాబట్టి ఇక్కడే సీజర్ సాంకేతికలిపి యొక్క కాని 0 కీలక ఒక ఉదాహరణ.
Z. వరకు సాధారణంగా, ఒక భావానికి, B B భావానికి, అన్ని మార్గం
కానీ మేము ఉదాహరణకు, 3 యొక్క ఒక కీ కోరుకున్నారు చెప్పారు.
ఒక ఇప్పుడు D, తదితర సర్దుబాటు తద్వారా అప్పుడు లోపలి చక్రం తిప్పడానికి చేస్తుంది
కాబట్టి ఈ మేము చేయబోతున్నామని ఏమి తప్పనిసరిగా ఉంది.
మేము ఒక వీల్ లేదు, కానీ మేము చేయబోతున్నామని మా కార్యక్రమం తయారు ఉంది
రకం సంఖ్యల కొంత మాకు పాటు వర్ణమాల ఉంచారు.
నేను ముందు చెప్పారు కనుక, మేము ఆదేశ పంక్తి వాదనలు వ్యవహరించే కావడం చేస్తున్నారు
అలాగే పూర్ణాంకం పొందడం వంటివి.
కాబట్టి ఒక వినియోగదారు మీ సీజర్ అమలు చేసే విధంగా విధంగా ఉంది. / సీజర్
మరియు ఆ తర్వాత అనేక ఎంటర్.
మరియు ఆ సంఖ్య కీ, షిఫ్ట్, సూచిస్తుంది
ఎన్ని మీ సీజర్ సాంకేతికలిపి యొక్క అంతర్గత వీల్ తిరిగే కావడం చేసిన టైమ్స్.
మరియు మీరు ఇక్కడ ఒక ఉదాహరణ చూడండి.
మేము, మా సీజర్ సాంకేతికలిపి లో కి L నుండి అక్షరాలు ఎంటర్ ఉంటే
అప్పుడు, O ద్వారా ఇన్పుట్ D ఆ 3 సార్లు మారింది ప్రతి అక్షరం ఎందుకంటే ఆ
కేవలం నేను మీరు చూపించారు చక్రం యొక్క ఉదాహరణ ఇష్టపడుతున్నారు.
కాబట్టి మీరు ఎంటర్ చేస్తే, ఉదాహరణకు, ఈ CS50 ఉంది!
అప్పుడు కూడా అక్షరాలు అన్ని కదులుతారు.
మరియు ఆ సీజర్ మరియు విజెనెరే రెండు ముఖ్యమైన విషయం
మేము ఏ కాని అక్షరాలు మీద skip చూడాలని ఉంది.
కాబట్టి ఏ ప్రదేశాలు, అక్షరాలు, etc, సంఖ్యలు, మేము వాటిని అదే ఉంచడానికి వెళుతున్న.
మేము ఈ సందర్భంలో అక్షరాలు మార్చేందుకు వెళుతున్న.
మీరు చక్రం లో చూడండి కనుక, మేము మాత్రమే, మాకు అందుబాటులో అక్షరాలు కలిగి
కాబట్టి మేము కేవలం అక్షరాలు బదిలీ మరియు అక్షరాలు గుప్తీకరించడానికి మీరు.
ఇది మొదటి విషయం, మీరు సమస్య లో సీజర్ కోసం వినియోగ 2 సెట్ గమనించాను
మీరు టెర్మినల్ లో అమలు చేసినప్పుడు సీజర్ అమలు మరియు తరువాత అనేక ఎంటర్ ఉంది.
కాబట్టి మనం ఏమి చేయాలి ఏదో ఆ గెట్ కీ మరియు యాక్సెస్ ఉంటుంది.
కాబట్టి మేము ఏదో అది రెండవ కమాండ్ లైన్ వాదన చేస్తాడు చూడాలనుకుంటే.
మొదటి ఒకటి. / సీజర్ ఉండబోతుంది, మరియు తరువాత ఒక కీ సంఖ్య అన్నారు.
మేము మా సి కార్యక్రమాలు ప్రారంభించడానికి Int ప్రధాన (తప్ప) వచ్చింది. కాబట్టి ముందు
మేము తిరిగి చర్మము ఒక పొర కొద్దిగా చూడాలని
మరియు వాస్తవానికి చూసే బదులు మా ప్రధాన కు శూన్యంలో తరలింపు
మేము నిజంగా 2 పారామితులు వ్యవహరించే చేస్తున్నారు.
మేము argc అనే ఒక Int కలిగి ఆపై తీగలను యొక్క వ్యూహం argv అని.
కాబట్టి argc, ఒక పూర్ణ సంఖ్య
మరియు మీ ప్రోగ్రామ్ లో ఆమోదం వాదనలు సంఖ్య సూచిస్తుంది.
ఆపై argv వాస్తవానికి జారీ వాదనలు జాబితా ఉంది.
వాదనలు అన్ని స్ట్రింగ్స్, మరియు అందువల్ల argv తీగలను ఒక వరుస జాబితా, సూచిస్తుంది.
యొక్క శ్రేణుల కొద్దిగా గురించి మాట్లాడేందుకు లెట్.
వ్యూహాలను కూడా కావాలంటే ఒక కొత్త డేటా నిర్మాణం ఉన్నాయి.
మేము, మేము డబుల్స్ చేశారు, ints మేము తీగలను కలిగి, మరియు ఇప్పుడు మేము శ్రేణుల ఉన్నాయి.
వ్యూహాలను, ఒకే రకమైన అనేక విలువలు కలిగి ఆ డేటా కట్టడాలు
కాబట్టి ముఖ్యంగా, మీరు కావలసిన రకం జాబితా.
ముఖ్యంగా, మీరు అన్ని 1 వేరియబుల్ పూర్ణాంకాల యొక్క జాబితా కోరుకుంటే,
అప్పుడు మీరు టైప్ Int శ్రేణి యొక్క అని ఒక కొత్త కారకం సృష్టిస్తుంది.
కాబట్టి శ్రేణుల శ్రేణి యొక్క మొదటి మూలకం సూచిక 0 వద్ద అని అర్థం, సున్నా-వర్గీకరించబడతాయి.
అర్రే ఈ ఉదాహరణలో వంటి పొడవు 4, యొక్క ఉంటే, అప్పుడు మీ చివరి మూలకం, ఇండెక్స్ 3 వద్ద ఉంటుంది
1 - 4 ఉంటుంది.
కాబట్టి శ్రేణి సృష్టించడానికి, మీరు ఈ వంటి ఏదో ఒకటి ఉంటుంది.
మీరు ఒక డబుల్ శ్రేణి కోరుకున్నారు సే.
ఈ అయితే, డేటా రకం ఏ రకం కోసం వెళుతుంది.
మీరు ఒక డబుల్ శ్రేణి కావలసిన చెప్పడానికి. మీరు మెయిల్ బాక్స్ కాల్ అనుకుందాం.
మీరు ఏ ఇతర డబుల్ ప్రారంభించడం ఉంటుంది వలె,
, మీరు డబుల్ ఆపై పేరు చెబుతారు, కానీ ఈ సమయంలో చదరపు బ్రాకెట్లలో మేము ఉంచండి
ఆపై సంఖ్య శ్రేణి పొడవు ఉంటుంది.
శ్రేణుల లో మనం పొడవు మార్చలేరు గమనించండి,
మీరు ఎల్లప్పుడూ, ఎన్ని పెట్టెలు నిర్వచించే మరియు ఎంచుకోవడానికి కలిగి
ఎన్ని విలువలు మీ శ్రేణి కలిగి అన్నారు.
మీ శ్రేణి వివిధ విలువల సెట్, మీరు, ఈ క్రింది సింటెక్స్ ఉపయోగించడానికి వెళుతున్న
మీరు స్లయిడ్ న చూడుము.
మీకు మెయిల్ బాక్స్ సూచిక 0, 1.2 అమర్చబడుతుంది
2.4 మెయిల్బాక్స్ సూచిక 1 సెట్ మొదలైనవి
కాబట్టి ఇప్పుడు మేము శ్రేణుల ఒక బిట్ సమీక్షించారు చేసారు, యొక్క argc మరియు argv తిరిగి వదలి వేస్తారు.
మేము ఇప్పుడు argv తీగలను యొక్క వ్యూహం అని తెలుసు.
కాబట్టి ఒక వినియోగదారు లో పోయినప్పుడు - వారు ఒక ప్రోగ్రామ్ను అమలు చేస్తున్నారు అనుకోండి -
వారు చెప్పేది. / హలో డేవిడ్ మలన్,
మీరు ఇప్పటికే వాస్తవానికి argc మరియు argv ఏమిటో ఆలోచన ఉంది కోసం ప్రోగ్రామ్ ఏమి కనిపిస్తుంది.
కాబట్టి దాని గురించి ఆందోళన అవసరం లేదు.
అది ఖాళీలతో వేరు 3 విభిన్న పదాలను చూస్తారు ఎందుకంటే ఈ సందర్భంలో Argc 3 ఉంటుంది.
కాబట్టి ఈ సందర్భంలో అర్రే, మొదటి సూచిక ఉంటుంది. / హలో,
తదుపరి డేవిడ్, తర్వాత ఒక మలన్.
ఎవరైనా, argv మధ్య ఏ సంబంధం వెంటనే చూడండి లేదు
అర్రే, మరియు argc ఉంది?
అవును. మేము args.c. ఒక ఉదాహరణ ఆ లోకి పొందుతారు
మేము 2 మధ్య సంబంధం యొక్క ప్రయోజనాన్ని లేదో యొక్క చూసేలా.
ఇక్కడ మీరు పరికరంలోని ఆ కలిగించే డిఫాల్ట్ అప్లికేషన్
. సి ఫైళ్ళను తెరవడానికి కొన్నిసార్లు Emacs ఉంది.
కానీ మేము gedit వ్యవహరించే మీరు, మీరు ఏమి మీరు మీ సి ఫైలు క్లిక్ చెయ్యండి కనుక
దీనితో తెరువు, ప్రాపర్టీస్ వెళ్లి, డిఫాల్ట్ లా సెట్ చెయ్యండి gedit, ఎంచుకోండి
మరియు ఇప్పుడు మీ ప్రోగ్రామ్ gedit బదులుగా Emacs ప్రారంభం అవ్వాలి.
పర్ఫెక్ట్.
ఇక్కడ నేను ప్రతి కమాండ్ లైన్ ఆర్గ్యుమెంట్ ముద్రించడానికి కావలసిన ఒక ప్రోగ్రామ్ను.
ఏ యూజర్ ఇన్పుట్లను కాబట్టి, నేను తప్పనిసరిగా కొత్త లైన్ వాటిని తిరిగి తిరిగి అనుకుంటున్నారా.
కాబట్టి మేము ఏదో పైగా iterate ఉపయోగించే ఒక నిర్మాణం ఏది -
మీరు బహుశా మీ pset 1 లో ఉపయోగించిన ఏదో?
మీరు విషయాలను సెట్ సంఖ్య ద్వారా వెళ్లాలనుకుంటున్నారా? ఉంటే >> లూప్ [విద్యార్థి].
లూప్. సరిగ్గా. కాబట్టి లూప్ తో ప్రారంభిద్దాం.
మేము Int i = 0 ఉన్నది. లెట్ యొక్క కేవలం ప్రామాణిక ప్రారంభ వేరియబుల్ ప్రారంభం.
నేను ఒక సెట్ కోసం పరిస్థితి వదిలి నేను + +, అక్కడ పనులు వెళ్లి చెప్పే వెళుతున్న.
అన్ని కుడి.
కాబట్టి argv కార్యక్రమానికి జారీ వాదనలు జాబితా ఉంది, argv తిరిగి ఆలోచించడం
మరియు argc, కార్యక్రమంలో వాదనలు సంఖ్య
ఆ argc argv ముఖ్యమైన పొడవు, కుడి, అర్థం
argc యొక్క విలువ చాలా వాదనలు ఉన్నట్లు వెళ్తున్నారు ఎందుకంటే.
మేము, argv ప్రతి మూలకం పైగా iterate మీరు అనుకుంటే
మేము ప్రతి సమయం సూచిక వద్ద argv లో వేరియబుల్ యాక్సెస్ కావలసిన చూడాలని.
కుడివైపు, ఈ తో ప్రాతినిధ్యం చేయవచ్చు?
ఇక్కడ ఈ వేరియబుల్ ఈ సందర్భంలో ప్రత్యేకంగా తంతి సూచిస్తుంది
ఎందుకంటే అది ఒక స్ట్రింగ్ శ్రేణి ఉంది - ఆ సూచిక వద్ద ప్రత్యేక స్ట్రింగ్.
మేము మీరు ఏమి, ఈ విషయంలో మేము దాన్ని ముద్రించడానికి కావాలి, కాబట్టి printf సే తెలియజేయండి.
ఇప్పుడు argv స్ట్రింగ్, కాబట్టి మేము అక్కడ ఆ ప్లేస్హోల్డర్ ఉంచాలి కావలసిన.
మేము దానిని అందంగా కనిపించేలా ఒక కొత్త లైన్ కావలసిన.
ఇక్కడ మేము ఒక కోసం లూప్ ఉన్నాయి. మేము ఇంకా పరిస్థితి లేదు.
నేను ఇచ్చిన స్ట్రింగ్ ముద్రించడానికి జరగబోతోంది ప్రతిసారీ అప్పుడు 0 మొదలవుతుంది మరియు
అర్రే లో నిర్దిష్ట సూచిక వద్ద.
కాబట్టి మేము యెరే నందలి అంశాలు ముద్రించిన ఆపివేయాలనుకుంటున్నారా లేనప్పుడు?
మేము పూర్తి చేసిన తర్వాత, కుడి? మేము శ్రేణి ముగింపు చేరుకున్నారు ఉన్నప్పుడు.
కాబట్టి మేము, అర్రే యొక్క పొడవు గత దాటి చేయకూడదని
మరియు మేము ఇప్పటికే మేము నిజంగా చురుకుగా argv యొక్క పొడవు ఎంత కనుగొనేందుకు అవసరం లేదు తెలుసు
ఎందుకంటే అది మాకు ఇచ్చిన, మరియు ఆ ఏది యొక్క? Argc. సరిగ్గా.
కాబట్టి మేము సార్లు ఈ ప్రక్రియ argc సంఖ్య చేయాలనుకుంటున్నారా.
నేను డైరెక్టరీ కాదు.
అన్ని కుడి.
ఇప్పుడు ARGS తయారు చేద్దాము. గొప్ప ఇది లోపాలు.
కాబట్టి యొక్క కేవలం ARGS అమలు అనుమతిస్తాయి.
ఈ మాకు తిరిగి ఏమి జరుగుతుందో? ఇది కేవలం అది తిరిగి ముద్రించడం జరగబోతోంది.
"మీరు కార్యక్రమంలోకి ARGS ఇన్పుట్; నేను మీకు తిరిగి ఇవ్వాలని వెళుతున్న."
కాబట్టి లెట్స్ మేము అప్పుడు foo బార్ ARGS చెప్పడానికి అనుకుందాం.
కాబట్టి అప్పుడు మాకు తిరిగి దాన్ని ముద్రిస్తుంది. అన్ని కుడి?
కాబట్టి మీరు argc మరియు argv ఉపయోగించవచ్చు ఎలా ఒక ఉదాహరణ ఉంది
ఆ argc తెలుసుకోవడం argv యొక్క పొడవు సూచిస్తుంది.
మీరు శ్రేణి పొడవు మించి శ్రేణుల యాక్సెస్ ఒక తో ఎప్పుడూ లేదు నిర్ధారించుకోండి
సి ఖచ్చితంగా మీరు వద్ద అరవండి ఎందుకంటే.
మీరు, విభజన లోపంగా అనే పొందుతారు
ఇది ప్రాథమికంగా మీరు ఏదో ప్రాప్తి చేయడానికి ప్రయత్నిస్తున్న చెప్పడం, సరదాగా ఎన్నటికీ
లేదు, మీరు చెందినది కాదు.
కాబట్టి నిర్ధారించుకోండి, మరియు ముఖ్యంగా సున్నా-ఇండెక్సింగ్ తో, మేము అనుకుంటున్న -
మేము పొడవు 4 యొక్క వ్యూహం ఉంటే, ఉదాహరణకు ఇష్టం
మేము సున్నా సూచిక వద్ద, 0 వద్ద మొదలు ఎందుకంటే ఆ అర్రే సూచిక 4 లేదు.
మేము 0 వద్ద ప్రారంభించిన ఇది ఉచ్చులు కోసం వంటి రెండవ ప్రకృతి అవుతుంది.
కాబట్టి కేవలం గుర్తుంచుకోండి.
మీరు ఎప్పుడూ మీ అంచనాలను మించి ఆ వ్యూహం యొక్క ఇండెక్స్ ప్రాప్తి చేయడానికి ఇష్టం లేదు.
కాబట్టి మేము ఎలా మేము ఆక్సెస్ రకం ఇప్పుడు చూడగలరు
సైన్ జారీ ఆ ఆదేశ పంక్తి వాదనలు
మీరు స్ట్రింగ్ చూసిన కానీ, argv అసలైన స్ట్రింగ్ శ్రేణి.
కాబట్టి అది ఇంకా నిజానికి ఒక పూర్ణాంకం కాదు, అయితే సీజర్ లో మనం పూర్ణాంకం వ్యవహరించే మీరు.
అదృష్టవశాత్తు, వాస్తవానికి పూర్ణాంకం ఒక స్ట్రింగ్ మార్చవచ్చు మాకు రూపొందించినవారు ఒక ఫంక్షన్ ఉంది.
మేము వాటిని ప్రోత్సహించే ఎక్కడ కూడా ఇక్కడ మేము వినియోగదారు ఇన్పుట్ వ్యవహరించే లేదు
కీ కోసం ఇక్కడ ఇన్పుట్ కోసం, కాబట్టి మేము నిజానికి, reprompt మరియు చెప్పలేను
"అది చెల్లదు అయితే ఓహ్, సే,, నాకు మరొక పూర్ణాంకం ఇస్తాయి."
కానీ మేము ఇంకా సరైన వాడుక తనిఖీ చేయాలి.
సీజర్ వారు మాత్రమే, 1 సంఖ్య పాస్ అనుమతించబడతాయి
అందువలన వారు. / సీజర్ అమలు చేసి తర్వాత వారు మీరు అనేక ఇవ్వాల్సి ఉంటుంది.
కాబట్టి argc ఒక నిర్దిష్ట సంఖ్యలో ఉండాలి.
వారు మీరు. / సీజర్ మరియు తరువాత కీ పాస్ కలిగి ఉంటే సంఖ్య ఉంటుంది?
Argc ఏమిటి? >> [విద్యార్థి] 2. >> రెండు. సరిగ్గా.
కాబట్టి మీరు argc 2 నిర్ధారించుకోవాలి.
లేకపోతే మీరు ప్రధానంగా ప్రోగ్రామ్ను అమలు చేయడానికి నిరాకరిస్తుంది.
ప్రధాన ఇది, Int ప్రధాన అని ఒక ఫంక్షన్ ఉంది
కాబట్టి అప్పుడు విజయవంతమైన ప్రోగ్రామ్ చివరిలో మంచి పద్ధతి తిరిగి 0 లో ఎప్పుడూ మేము.
సే, చేస్తే, వారు మీరు 3 ఆదేశ పంక్తి వాదనలు బదులుగా 2 ఇవ్వాలని
లేదా మీరు ఆ కోసం తనిఖీ చెయ్యవచ్చును మీరు ఏమి చేస్తాము ఉంది అప్పుడు, ఉదాహరణకు, మీరు 1 ఇవ్వాలని
మరియు తర్వాత ఏ విధంగా 1 తిరిగి, నేను ఈ కార్యక్రమం కొనసాగలేము.
[విద్యార్థి] ఉన్నాయి మీ టెక్స్ట్ లో ఒక స్పేస్ ఉండకూడదు. >> నాకు క్షమించండి?
[విద్యార్థి] మీరు గుప్తీకరించడానికి ప్రయత్నిస్తున్న టెక్స్ట్ లో ఒక స్పేస్ ఉండదు.
ఆహ్!
మేము గుప్తీకరించడానికి ప్రయత్నిస్తున్న టెక్స్ట్ పరంగా, వాస్తవానికి తరువాత వస్తుంది
మేము టెక్స్ట్ అందచేసినప్పుడు.
కాబట్టి ఇప్పుడు మేము వాస్తవ సంఖ్య, ఆదేశం వాదనలు అంగీకరించడం చేస్తున్నారు
సీజర్ ఎన్క్రిప్షన్ కోసం నిజమైన మార్పు.
[విద్యార్థి] కేవలం 1 argc వ్యతిరేకంగా ఎందుకు మీరు 2 చేయాలి? 1 సంఖ్య ఖచ్చితంగా ఉంది.
కుడి. మేము argc 2 అవసరం కారణం బదులుగా 1
మీరు ఒక ప్రోగ్రామ్ రన్ మరియు చెప్పినప్పుడు మీరు ఎందుకంటే ఉంది. / సీజర్ లేదా. / హలో,
వాస్తవానికి ఒక కమాండ్ లైన్ వాదన గా లెక్కింపబడుతుంది.
కాబట్టి ఆ ఇప్పటికే 1 తీసుకుంటుంది మరియు అందువలన మేము 1 అదనపు ఇవ్వడం చేస్తున్నారు.
కాబట్టి మీరు నిజంగా కమాండ్ లైన్ వాదన లో స్ట్రింగ్ ఇవ్వడం చేస్తున్నారు.
మీరు మీరు ఏమి, సీజర్ కోసం మేము, ఒక పూర్ణాంకం వ్యవహరించే మీరు
కాబట్టి మీరు ఈ atoi క్రియాశీలతను ఉపయోగించగలదు.
మరియు ప్రధానంగా, మీరు ఒక స్ట్రింగ్ లో పాస్ మరియు అప్పుడు పూర్ణాంకం మీరు తిరిగి తిరిగి
అది ఒక పూర్ణాంకం ఆ స్ట్రింగ్ చేయడానికి అవకాశం ఉంటే.
మేము వలె printf లేదా GetString విషయాలు వ్యవహరించే చేసినప్పుడు ఇప్పుడు గుర్తు
మేము మాకు నిర్దిష్టమైన గ్రంధాలయాలు ఉన్నాయి.
కాబట్టి ప్రారంభంలో ఆ వంటి హాష్ ట్యాగ్ ప్రామాణిక I / O,. H, ఏదో ప్రారంభం.
Well, atoi, ఆ గ్రంథాలయాల్లో ఒకటిగా లో లేదు
కాబట్టి మనం చేయవలసింది ఆ సరైన గ్రంధాలయం ఉన్నాయి కలిగి ఉంది.
నేను మాన్యువల్ ఫంక్షన్ చర్చించే Walkthrough 1 తిరిగి గుర్తు.
మీరు మీ టెర్మినల్ వ్యక్తి టైప్ చేసి, ఆపై ఒక చర్య యొక్క పేరును అనుసరిస్తూ.
కాబట్టి, దాని ఉపయోగం యొక్క పూర్తి జాబితాను అప్ కలిగించే
కానీ అదే ఆ చెందిన ఇది లైబ్రరీ కి తీసుకొస్తుంది.
నేను atoi తో మాన్యువల్ ఫంక్షన్ను ఉపయోగించడానికి మీరు ఆ చెప్పను
మరియు మీరు atoi క్రియాశీలతను ఉపయోగించదు చెయ్యడానికి ఉన్నాయి అవసరం ఇది లైబ్రరీని చూడవచ్చు.
, కాబట్టి మేము కీ పొందారు మరియు ఇప్పుడు అది సాదా టెక్స్ట్ పొందడానికి వస్తుంది
అందువలన వాస్తవంగా మిమ్ములను పేరు వినియోగదారు ఇన్పుట్ మాత్రం ఆ.
మేము అదే పంథాలో కాబట్టి GetInt మరియు GetFloat నిర్వహించాయి, మరియు
మేము GetString వ్యవహరించే కావడం చేస్తున్నారు.
అయితే లేదా ఉచ్చులు తనిఖీ కానీ ఈ విషయంలో మేము ఏ చేస్తారా లేదు.
GetString ఖచ్చితంగా, మాకు ఒక స్ట్రింగ్ ఇస్తుంది
మరియు మేము వినియోగదారు మాకు ఇస్తుంది ఏ గుప్తీకరించడానికి వెళుతున్న.
మీరు ఈ యూజర్ ఇన్పుట్ చేసిన తీగలను అన్ని సరైనవని పొందవచ్చు.
గ్రేట్.
, కాబట్టి అప్పుడు మీరు కీ పొందారు మరియు ఒకసారి మీరు టెక్స్ట్ పొందారు
ఇప్పుడు ఎడమ ఏమి మీరు సాదా encipher ఉంటుంది ఉంది.
జస్ట్ త్వరగా లింగో పైగా కవర్ చేయడానికి, సాదా, యూజర్ మీరు లభిస్తుంది
మరియు సాంకేతికలిపి మీరు వాటిని తిరిగి ఏమిటి.
తీగలను కాబట్టి, లేఖ ద్వారా వాస్తవానికి లేఖ ద్వారా వెళ్ళి చెయ్యడానికి
మేము ప్రతి అక్షరం మార్చేందుకు ఎందుకంటే,
మేము ఆ తీగలను అర్థం, అయితే తిరిగి పొర పీల్ మేము రకం
మేము అవి నిజంగా అక్షరాలు జాబితా మేము చూసాము.
ఒక ఇతర తర్వాత వస్తుంది.
వారు అక్షరాలు వ్యూహాలను ఎందుకంటే కాబట్టి మేము శ్రేణుల వంటి తీగలను చికిత్స చేయవచ్చు.
, మీరు టెక్స్ట్ అనే స్ట్రింగ్ కలిగి చెప్పడానికి
మరియు ఆ వేరియబుల్ పాఠ్యమును లోపల ఈ CS50 ఉంది నిల్వ చేయబడుతుంది.
అప్పుడు ఇండెక్స్ 0 వద్ద టెక్స్ట్ రాజధాని T ఉంటుంది, ఇండెక్స్ 1 h, మొదలైనవి ఉంటుంది
ఆపై శ్రేణితో, args.c లో argc ఉదాహరణలో,
మేము వ్యూహం మీద iterate వచ్చింది చూసిన
అందువలన మేము నేను పొడవు కంటే తక్కువగా ఉంటుంది వరకు నేను = 0 అప్ iterate వచ్చింది.
కాబట్టి మేము మా స్ట్రింగ్ యొక్క పొడవు ఎంత ఇందుకు కొన్ని మార్గం అవసరం
మేము దాని పై iterate చూడాలని ఉంటే.
అదృష్టవశాత్తు మళ్లీ మాకు అక్కడ ఒక ఫంక్షన్ అయితే తర్వాత CS50 లో ఉంది
మీరు ఖచ్చితంగా మీ స్వంత ఫంక్షన్ అమలు తయారు చేయగలరు
ఒక స్ట్రింగ్ యొక్క పొడవు లెక్కించవచ్చు.
కానీ ఇప్పుడు కోసం మేము స్ట్రింగ్ పొడవు, కాబట్టి strlen ఉపయోగించడానికి వెళుతున్న.
మీరు ఒక స్ట్రింగ్ లో పాస్, మరియు అప్పుడు మీరు మీ స్ట్రింగ్ యొక్క పొడవు సూచించే ఒక Int చూపిస్తుంది.
యొక్క మేము ఒక స్ట్రింగ్ లో ప్రతి పాత్ర మీద iterate చేయగలరు ఎలా ఒక ఉదాహరణ చూద్దాం
మరియు ఆ ఏదో ఒకటి.
మనం చేయాలనుకుంటున్నారా, స్ట్రింగ్ యొక్క ప్రతి పాత్ర మీద iterate ఉంది
మరియు మేము చేయాలనుకుంటున్నారా ఉంది మేము 1 ప్రతి పాత్ర 1 తిరిగి ప్రింట్
మేము అది ప్రక్కన ఏదో జోడించడానికి తప్ప.
కాబట్టి లూప్ తో ప్రారంభిద్దాం. Int i = 0.
మేము పరిస్థితి స్థలాన్ని విడిచి వెళుతున్న.
మేము స్ట్రింగ్ ముగింపు చేరుకోవడానికి వరకు, iterate మీరు కుడి?
కాబట్టి అప్పుడు ఏమి ఫంక్షన్ మాకు స్ట్రింగ్ యొక్క పొడవు ఇస్తుంది?
[వినబడని విద్యార్థి ప్రతిస్పందన]
ఆ ఆదేశ పంక్తి వాదనలు యొక్క పొడవు ఉంది.
కానీ ఒక స్ట్రింగ్ కోసం మేము మాకు స్ట్రింగ్ యొక్క పొడవు ఇచ్చే ఫంక్షన్ ఉపయోగించాలనుకుంటున్నాను.
కాబట్టి ఆ స్ట్రింగ్ పొడవు ఉంది.
కాబట్టి మీకు ఒక స్ట్రింగ్ లో ఉత్తీర్ణత సాధించవలసి ఉంటుంది.
ఇది పొడుగు గణించటం అవసరం ఏమి స్ట్రింగ్ తెలుసుకోవాలి.
కాబట్టి ఈ విషయంలో మేము స్ట్రింగ్ s వ్యవహరించే చేస్తున్నారు.
గ్రేట్.
కాబట్టి అప్పుడు మేము మీరు ఏమి, యొక్క printf తెలియజేయండి.
ఇప్పుడు మేము అక్షరాలు వ్యవహరించే మీరు. మేము ప్రతి వ్యక్తి పాత్రను ప్రింట్ మీరు.
మీరు ఒక ఫ్లోట్ ముద్రించాలా ఉంటుంది, మీరు% F వంటి ప్లేస్హోల్డర్ ఉపయోగించారు.
ఒక పూర్ణాంకానికి మీరు% d ను ఉపయోగించాలి.
కాబట్టి అదే విధంగా, ఒక పాత్ర మీకు నేను ఒక పాత్ర ప్రింటింగ్ కూడా వెళుతున్న చెప్పడానికి% C ఉపయోగించండి
ఒక వేరియబుల్ లోపల నిల్వ చెయ్యబడింది.
కాబట్టి మేము ఈ కలిగి, మరియు ఇది ఒక కాలం మరియు ఖాళీ జోడించడానికి అనుమతిస్తుంది.
మేము ఏ పాత్ర ఉపయోగిస్తున్నారు?
మేము స్ట్రింగ్ యొక్క ఉన్నాము ఏ పాత్ర ఉపయోగించి చూడాలని.
కాబట్టి అప్పుడు మేము, స్ట్రింగ్ ఏదో ఉపయోగించి చూడాలని
కానీ మేము అక్కడ కొన్ని పాత్ర యాక్సెస్ మీరు కోరుకుంటున్నారు.
ఒక స్ట్రింగ్ కేవలం ఒక శ్రేణి చేస్తే, అప్పుడు మేము ఎలా శ్రేణుల యొక్క అంశాలను యాక్సెస్ చేయాలి?
మేము ఆ చదరపు బ్రాకెట్లలో కలిగి, మరియు అప్పుడు మేము అక్కడ సూచిక ఉంచండి.
కాబట్టి మేము చదరపు బ్రాకెట్లలో ఉంది. ఈ సందర్భంలో మా ఇండెక్స్ మేము ఉపయోగించడానికి. సరిగ్గా.
ఇక్కడ మేము, మేము ఒక డాట్ మరియు ఒక స్పేస్ ఒక పాత్ర ప్రింటింగ్ కావడం చేస్తున్న చెబుతున్న దాన్ని
మరియు ఆ పాత్ర మా స్ట్రింగ్ s లో ith లేఖలో అన్నారు.
నేను ఆ సేవ్ వెళుతున్న. సరే.
ఇప్పుడు నేను స్ట్రింగ్ పొడవు అమలు వెళుతున్న.
కాబట్టి మేము OMG అనే స్ట్రింగ్ కలిగి, మరియు ఇప్పుడు అది మరింత నొక్కి యొక్క.
అదేవిధంగా, లెట్స్ మేము నిజంగా వినియోగదారు నుండి ఒక స్ట్రింగ్ పొందడానికి అనుకుందాం.
దీన్ని మేము ఎలా ఏమి ఉండవచ్చు?
ముందు, ఎలా మేము ఒక పూర్ణాంకానికి వచ్చింది?
మేము GetInt, కుడి చెప్పారు? కానీ ఈ Int, అందువలన GetString చూద్దాం.
యొక్క స్ట్రింగ్ పొడవు తయారు చేద్దాము. ఇక్కడ మేము ఒక నిర్దిష్ట ప్రాంప్ట్ నమోదు చేయలేదు.
కాబట్టి నాకు తెలీదు.
నేను ఇక్కడ నా పేరు పెట్టి వెళుతున్న మరియు అందువల్ల నేను ఆ విషయాలు ఒకటి చేయవచ్చు
నాకు అది ఇష్టం ప్రతి అక్షరం లేదా ఏదో ఒక పదం కేటాయించి పేరు. కూల్.
కాబట్టి ఆ స్ట్రింగ్ పొడవు ఉంది.
కాబట్టి మేము సీజర్ తిరిగి ఉన్నారు.
మేము, మేము స్ట్రింగ్ పైగా iterate ఎలా కొన్ని పరికరాలను కలిగి
మేము ప్రతి వ్యక్తి మూలకం యాక్సెస్ ఎలా.
కాబట్టి ఇప్పుడు మేము ప్రోగ్రామ్ ను తిరిగి చేయవచ్చు.
నేను ముందు, ASCII పట్టికలో, మీ ఉత్తమ స్నేహితుని, చెప్పినట్లుగా
మీరు ప్రతి అక్షరం సంబంధం సంఖ్యలను చూడండి చూడాలని.
ఇక్కడ మా సాదా నేను డిజ్జి ఉన్నాను అంటారు!
ఈ అక్షరాలు ప్రతి ఒక సంఖ్య మరియు దానికి సంబంధించిన ASCII విలువను కలిగి అన్నారు
కూడా అపాస్టిఫియర్, కూడా స్థలం కూడా ఆశ్చర్యార్థకం గుర్తును,
కాబట్టి మీరు గుర్తుంచుకోండి చెయ్యవచ్చును.
కాబట్టి కమాండ్ లైన్ వాదన చేర్చారు యూజర్ 6 అని మా కీ చెప్పారు.
73 ద్వారా ప్రాతినిధ్యం ఇది నేను ఇది మొదటి అక్షరం, అంటే అర్థం ఆ
మీరు 73 + 6 ASCII విలువను ద్వారా ప్రాతినిధ్యం ఏమైనా లేఖ వాటిని తిరిగి అనుకుంటున్నారా.
ఈ సందర్భంలో ఆ 79 ఉంటుంది.
ఇప్పుడు రాబోయే పాత్ర కు వెళ్లాలని మీరు అనుకుంటున్నారా.
కాబట్టి సాదా యొక్క సూచిక 1 తదుపరి అపాస్టిఫియర్ ఉంటుంది.
కానీ మేము కేవలం అక్షరాలు encipher మీరు గుర్తుంచుకోవాలి.
కాబట్టి మేము, అపాస్టిఫియర్ ఒకే ఉంటాయి ఆ నిర్ధారించుకోవాలి
మేము 39 నుండి ఏ 45 మార్చలేని ఉంది.
మేము అపాస్ట్రఫీని గా ఉంచాలని.
కాబట్టి మేము కేవలం అక్షరాలు encipher కు గుర్తుంచుకోవాలనుకుంటున్న
మేము ఇతర చిహ్నాలు అన్ని మా కార్యక్రమంలో మారదు మీరు ఎందుకంటే.
మేము కావలసిన మరొక విషయం క్యాపిటలైజేషన్ ఉంచాలనే.
కాబట్టి మీరు ఒక పెద్ద అక్షరం ఉన్నప్పుడు, అది ఒక పెద్ద వంటి ఉండడానికి ఉండాలి.
Lowercases చిన్న వంటి ఉండడానికి ఉండాలి.
కాబట్టి కొన్ని ఉపయోగకరమైన విధులు మాత్రమే enciphering అక్షరాలు వ్యవహరించే చెయ్యడానికి
మరియు విషయాలు క్యాపిటలైజేషన్ సంరక్షించడానికి ఉంచడానికి
isalpha, isupper, islower విధులు ఉంది.
కాబట్టి ఈ మీరు బూలియన్ విలువ తిరిగి క్రియలు.
సాధారణంగా, ఒప్పు లేదా తప్పు. ఈ ఒక పెద్ద ఉంది? ఈ ఆల్ఫాన్యూమరిక్ ఉంది?
ఇది తప్పనిసరిగా ఒక అక్షరం.
ఇక్కడ మీరు ఆ ఫంక్షన్ ఉపయోగించే ఎలా 3 ఉదాహరణలు.
సాధారణంగా, మీరు విలువ ఆ చర్య ద్వారా మీరు తిరిగి లేదో పరీక్షించుకోవచ్చు నిజమైన లేదా తప్పుగా
ఆ ఇన్పుట్ ఆధారంగా.
గాని encipher కాదు లేదా అది సాంకేతికలిపి లేదా పెద్ద, మొదలైనవి అని ఖచ్చితంగా ఉందని
[విద్యార్థి] మీరు కొంచెం ఎక్కువ మరియు ఎలా మీరు వాటిని ఉపయోగించే ఆ వివరిస్తుంది? >> అవును, ఖచ్చితంగా.
మేము తిరిగి చూడాలని అలా అయితే, ఇక్కడ మేము, ఒక రాజధాని నేను ఉందా?
కాబట్టి మేము నేను + 6 ఓ ఎందుకంటే నేను ఓ వెళ్లే తెలుసు
కానీ మేము O ఒక రాజధాని O. మాత్రం ఆ నిర్ధారించుకోవాలి
కాబట్టి ప్రాథమికంగా, మా ఇన్పుట్ మార్చుకోబోతున్నారు యొక్క రకం.
అది పెద్ద లేదా మేము అది వ్యవహరించే మార్గాన్ని మార్చడానికి రకం రెడీ లేదు కాబట్టి అని.
కాబట్టి అప్పుడు మేము నిర్దిష్ట ఇండెక్స్ లో isupper ఫంక్షన్ ఉపయోగిస్తే,
నిజమైన మాకు తిరిగి తద్వారా isupper ("నేను"),, కాబట్టి మేము ఇది ఉన్నత మనకు తెలుసు.
కాబట్టి ఆ ఆధారంగా, తరువాత మేము ఒక సూత్రం వలె వెళ్తారో
మీరు, సీజర్ లో విషయాలను మార్చేందుకు ఉపయోగించి మేము
అది పెద్ద అయితే కనుక అప్పుడు ప్రధానంగా, కొంచెం ఫార్ములా ఉన్నట్లు జరగబోతోంది
వంటి చిన్న వ్యతిరేకంగా. సమంజసం?
అవును. కంగారుపడవద్దు.
నేను చాలా సమంజసం అనిపించుకోదు ఒక లేఖ, 6 జోడించడం గురించి ఒక బిట్ మాట్లాడుకున్నారు
మేము రకమైన అర్థం తప్ప ఈ అక్షరాలు
పూర్ణాంకాల పరస్పర మార్పిడి యొక్క రకమైన ఉన్నాయి.
మనం చెయ్యవలసింది మేము ఉపయోగం అవ్యక్త CASTING రకం.
మీరు ఒక విలువను పడుతుంది పేరు ఒక బిట్ తర్వాత కాస్టింగ్ లోకి వెళ్తారో మరియు మీరు వేరే రకం మార్చడానికి
ఇది మొదట కంటే.
కానీ ఈ pset తో మేము పరస్పరం అక్షరాలను ఉపయోగించవచ్చు రకమైన చేయగలరు
మరియు వాటి సంబంధిత ఇంటీజర్ విలువలకు.
మీరు కేవలం కేవలం సింగిల్ కోట్స్ ఒక పాత్ర పొదుగు అయితే,
అప్పుడు మీరు పూర్ణాంకం గా వ్యవహరించే, పూర్ణ తో పని చేయగలరు.
కాబట్టి రాజధాని సి 67 సంబంధించింది. చిన్న F 102 సంబంధించినది.
మీరు ఈ విలువలను తెలుసుకోవాలనుకుంటే మళ్లీ,, మీ ASCII పట్టిక చూడండి.
కాబట్టి యొక్క మీరు తీసివేయడం మరియు జోడించుకోగలరు ఎలా కొన్ని ఉదాహరణలు లోకి వీడలేదు,
మీరు నిజంగా నిజంగా ఈ అక్షరాలు పని ఎలా, పరస్పరం వాటిని ఉపయోగించండి.
నేను ఆ ASCIIMath పూర్ణాంకం ఒక పాత్ర యొక్క అదనంగా లెక్కించేందుకు అన్నారు సే
ఆపై ఫలితంగా పాత్ర అలాగే ఫలితంగా ASCII విలువను ప్రదర్శిస్తుంది.
మరియు ఇక్కడ నేను చెప్పడం నేను - ఈ భాగం we'll ఒప్పందం తరువాత -
కానీ సాధారణంగా, నేను, వినియోగదారు ఒక కీ పాటు అమలు ASCIIMath చెప్పాలి చెప్పి నేను
మరియు నేను ఆ కీ సంఖ్య మాత్రం చెబుతూ నేను
తో మేము ఈ పాత్ర జోడించండి చూడాలని.
ఇక్కడ గమనించవచ్చు ఆ నేను కీ డిమాండ్ చేస్తున్నాను నుండి,
నేను వారు నాకు 1 విషయం ఇచ్చి చేస్తున్న డిమాండ్ చేస్తున్నాను నుండి
నేను మాత్రమే. / Asciimath మరియు ఒక కీ అంగీకరించడానికి.
నేను argc 2 కు సమానంగా ఉంటుంది డిమాండ్ వెళుతున్న.
అలా కాకపోతే, అప్పుడు నేను తిరిగి 1 మరియు కార్యక్రమంలో నిష్క్రమిస్తుంది వెళుతున్న.
నేను, కీ మొదటి కమాండ్ లైన్ వాదన మాత్రం లేదు మాట్లాడుతూ నేను
ఇది రెండవ చేస్తాడు, మరియు మీరు ఇక్కడ చూడండి వంటి
నేను ఒక పూర్ణాంకం ఆ మలుపు వెళుతున్న.
అప్పుడు నేను r అని ఒక పాత్ర సెట్ వెళుతున్న.
వేరియబుల్ chr రకం నిజానికి ఒక పూర్ణ సంఖ్య అని గమనించండి.
నేను ఒక పూర్ణాంకం వంటి r ఉపయోగించగలరు ఉన్నాను విధంగా ఈ సింగిల్ కోట్స్ తో encasing ద్వారా ఉంది.
మేము ఒక పాత్ర కోసం ఒక ప్లేస్హోల్డర్ కలిగి ఉన్న మా printf ప్రకటన తిరిగి
ఆపై పూర్ణాంకం ఒక ప్లేస్హోల్డర్,
పాత్ర chr ద్వారా ప్రాతినిధ్యం, మరియు పూర్ణాంక కీ ఉంది.
కాబట్టి అప్పుడు మేము ఫలితంగా కలిసి 2 జోడించండి చూడాలని.
కాబట్టి మేము r జోడించండి చూడాలని + కీ ఏమైనా
మరియు తర్వాత ఆ ఫలితంగా ముద్రించడానికి వెళుతున్న.
కాబట్టి యొక్క asciimath తయారు చేద్దాము. ఇది తాజాగా, కనుక యొక్క కేవలం asciimath అమలు అనుమతిస్తాయి.
మేము దీన్ని ఒక కీ ఇవ్వని కారణంగా, OH కానీ, అది ఏదీ చెయ్యవద్దు.
కనుక ఇది కేవలం 1, మా ప్రధాన విధి తిరిగి అది మాకు తిరిగి.
కాబట్టి అప్పుడు యొక్క కీలక లో పాస్ అయ్యేందుకు. ఒకరు ఒక సంఖ్య ఇవ్వండి. >> [విద్యార్థి] 4.
4. సరే.
కాబట్టి r 4 మాకు 118 యొక్క ASCII విలువను అనుగుణంగా ఉండే v, ఇవ్వాలని అన్నారు పెరిగింది.
కాబట్టి అప్పుడు రకమైన భావన ఆ చేస్తుంది -
అసలైన, నేను, మీరు అడగవచ్చు మీరు r + 4 118 ఉంటే r యొక్క ASCII విలువ ఏమి ఆలోచిస్తాడు?
అప్పుడు అవును, r 114 ఉంది.
మీరు ASCII పట్టిక చూడండి అయితే, ఖచ్చితంగా తగినంత, మీరు ఆ r 114 ద్వారా ప్రాతినిధ్యం చూస్తారు.
కాబట్టి ఇప్పుడు మనం అక్షరాలు వరకు పూర్ణాంకాల జోడించే తెలిసిన, ఈ చాలా సాధారణమైన అంశంగా.
మేము ముందు ఒక ఉదాహరణ చూసిన వంటి స్ట్రింగ్ పైగా iterate చూడాలని.
అది ఒక లేఖ ఉంటే మేము తనిఖీ చేస్తాము.
అది ఉంటే, అప్పుడు మేము కీ ఉండే వస్తువు ద్వారా బదిలీ చేస్తాము.
ప్రెట్టీ సాధారణ, మీరు ఈ ను తప్ప,
మీరు z, 122 ద్వారా ప్రాతినిధ్యం, అప్పుడు మీరు వేరొక పాత్ర కల్పించే చూడండి.
మేము నిజంగా, మా వర్ణమాల లోపల ఉండండి కుడి?
కాబట్టి మేము చుట్టూ చుట్టడం రకం విధంగా గుర్తించడానికి అవసరం.
మీరు జెడ్ చేరుకోవడానికి మరియు మీరు ఒక నిర్దిష్ట సంఖ్యలో పెరుగుతుందని ఉంటుంది,
మీరు ASCII అక్షరం విభాగం మించి వెళ్ళాలని అనుకుంటున్న;
మీరు A. వరకు తిరిగి మూసివేయాలని మీరు
అయితే మీరు ఇప్పటికీ కేసు సంరక్షించడానికి చేసిన గుర్తుంచుకోండి.
కాబట్టి అక్షరాలు తెలుసుకోవడం చిహ్నాలు కాలేరు
కేవలం చిహ్నాలు వంటి అలాగే మారుతున్న కావడం లేదు.
గత pset లో మీరు ఖచ్చితంగా, అవసరం లేదు
కానీ ఒక ఎంపికను మాడ్యులస్ ఫంక్షన్ ఉపయోగించి మీ అత్యాశ pset అమలు ఉంది.
అయితే ఇప్పుడు మేము నిజానికి, మాడ్యులస్ ఉపయోగించాలి చూడాలని
కాబట్టి యొక్క ఈ కొద్దిగా వెళ్ళి తెలపండి.
ముఖ్యంగా, మీరు Y ద్వారా విభజించబడింది x మిగిలిన ఇచ్చే x మాడ్యులో y, ఉన్నప్పుడు.
ఇక్కడ కొన్ని ఉదాహరణలు. మేము 27% 15 ఉన్నాయి.
సాధారణంగా, మీరు ప్రతికూల లేకుండా సాధ్యం సార్లు 27 నుండి 15 వ్యవకలనం ఉన్నప్పుడు
అప్పుడు మీరు 12 ఎడమ పొందుతాయి.
కాబట్టి ఆ గణిత సందర్భంలో వంటి రకమైన, కానీ మేము ఎలా వాస్తవానికి ఈ ఉపయోగించవచ్చు?
ఇది మా wrapover ఉపయోగకరంగా చేస్తాడు.
ఈ కోసం, కేవలం నేను 3 సమూహాలుగా విభజించింది మీరు అన్ని అడిగాడు సే తెలియజేయండి.
కొన్నిసార్లు మీరు సమూహాలు మరియు అలాంటిదే చేస్తాము.
నేను "సరే, నేను 3 విభజించారు మీరు అన్ని కోరుకుంటున్నాను.", అన్నాడు సే
మీరు ఎలా అలా ఉండవచ్చు?
[వినబడని విద్యార్థి ప్రతిస్పందన] అవును, సరిగ్గా. ఆఫ్ కౌంట్. సరే.
వాస్తవానికి అలా చేసుకుందాం. మీరు ప్రారంభించడానికి మీరు అనుకుంటున్నారా?
1, 2, 3, 4 [విద్యార్థులు ఆఫ్ లెక్కింపు].
కానీ గుర్తు ... >> [విద్యార్థి] ఓహ్, సారీ.
ఒక మంచి పాయింట్.
మీరు 4 చెప్పారు, కానీ మేము కేవలం 3 సమూహాలు కావలసిన ఎందుకంటే మేము నిజంగా మీరు 1 చెప్పాలనుకోవడం.
కాబట్టి అప్పుడు, ఎలా - అప్పుడు ఎలా మీరు 1 అనవచ్చు ఎందుకంటే లేదు, ఒక మంచి ఉదాహరణకు?
4 మరియు 1 మధ్య సంబంధం ఏమిటి?
Well, 4 mod 3 1.
మీరు కొనసాగితే కాబట్టి, మీరు 2 ఉంటుంది.
కాబట్టి మేము 1, 2, 3, 1, 2 ఉన్నాయి.
మరలా, మీరు నిజంగా 5 వ వ్యక్తి. ఎలా మీరు 2 బదులుగా 5 చెప్పడానికి తెలుసు?
మీరు 5 mod 3 2 అంటారు.
నేను ను ఎలా అనేక 3 సమూహాలను చూడాలనుకుంటే, తర్వాత క్రమంలో I. am
కాబట్టి అప్పుడు మేము, గది మొత్తాన్ని పాటు కొనసాగింది ఉంటే
అప్పుడు మేము ఎల్లప్పుడూ నిజానికి మేమే కు mod ఫంక్షన్ దరఖాస్తు చేస్తున్న చూడగలం
రకమైన ఆఫ్ లెక్కించడానికి.
మీరు మాడ్యులో ఉపయోగించడానికి ఎలా ప్రత్యక్ష ఉదాహరణ యొక్క రకంగా
నేను ఖచ్చితంగా ఉన్నాను ఎందుకంటే మాకు చాలా బహుశా ఆ ప్రక్రియ దాటి
మేము ఆఫ్ లెక్కించడానికి కలిగింది పేరు.
మోడ్యులో ఏ ప్రశ్నలు?
ఇది ఈ భావనల అర్థం చాలా ముఖ్యమైనది ఉంటుంది
నేను మీరు అబ్బాయిలు అర్థం నిర్ధారించుకోవాలి.
[విద్యార్థి] ఏ మిగిలిన ఉంటే, మీరు అసలు సంఖ్య ఇవ్వలేదు?
వాటిలో మొదటి 3 యొక్క ఒక దానిని చేసిన ఉంటే, అది, వారు నిజంగా ఏం చేస్తున్నారో వారిని ను ఇచ్చింది
లేదా వాటిని ను ఇచ్చింది [వినబడని] >> ఒక మంచి ప్రశ్న.
మోడ్యులో ఏ మిగిలిన ఉన్నప్పుడు - మీరు 6 mod 3 కలిగి చెప్పడానికి -
వాస్తవానికి 0 మీరు తిరిగి ఇస్తుంది.
మేము ఒక బిట్ తర్వాత గురించి మాట్లాడదాము.
అవును, ఉదాహరణకు, 3 వ వ్యక్తి - 3 mod 3 వాస్తవానికి 0 అయితే ఆమె 3 చెప్పారు.
కాబట్టి ఆ ఉదాహరణకు, ఒక అంతర్గత క్యాచ్ వంటి రకమైన యొక్క,
mod అప్పుడు 0 అయితే ఓకే ఇష్టం, 3 వ వ్యక్తి వెళుతున్న.
కానీ మేము 0 తరువాత ఏమి వ్యవహరించే మీరు ఎలా రకమైన లోకి వస్తాయి.
కాబట్టి ఇప్పుడు మేము ఏదో కుడి లేఖ జెడ్ మ్యాపింగ్ ఒక మార్గం ఉంది.
కాబట్టి ఇప్పుడు మేము ఈ ఉదాహరణలు ద్వారా మారారు
మేము రకమైన సీజర్ పని ఎలా చూడండి.
మీరు 2 వర్ణమాలలు చూడండి మరియు మీరు వాటిని తరలించడం చూడండి.
కాబట్టి యొక్క ప్రయత్నించండి మరియు ఫార్ములా పరంగా ఆ వ్యక్తం తెలియజేయండి.
ఈ ఫార్ములా వాస్తవానికి, స్పెక్ లో మీరు ఇవ్వబడుతుంది
కానీ ప్రతి వేరియబుల్ అర్థం ద్వారా లుక్ యొక్క లెట్స్ రకమైన.
మా తుది ఫలితంగా సాంకేతికపాఠం అని అన్నారు.
కాబట్టి ఈ అని సాంకేతికపాఠం యొక్క ith పాత్ర
సాదా యొక్క ith పాత్ర అనుగుణంగా అన్నారు.
మేము ఎల్లప్పుడూ పైకి ఈ విషయాలు లైనింగ్ అనుకుంటే ఎందుకంటే భావన కల్పిస్తుంది.
కాబట్టి అది మా కీ ఇది సాంకేతికపాఠం ప్లస్ k యొక్క ith పాత్ర చేస్తాడు -
భావన కల్పిస్తుంది - మరియు తర్వాత మేము ఈ mod 26 ఉన్నాయి.
మేము జెడ్ ఉన్నప్పుడు తిరిగి గుర్తుంచుకో
మేము పాత్ర పొందడానికి లేదు, కాబట్టి మేము అది MoD అనుకున్నారు
వర్ణమాల సర్దుబాటు మరియు రకం.
జెడ్ తర్వాత మీరు ఒక వెళ్లాల్సి ఉంది, బి, మీరు కుడి సంఖ్య c, d, కాకముందు వరకు.
కాబట్టి మేము తెలిసిన జెడ్, జెడ్ a, b, c, d, E, F వచ్చిన తర్వాత ఎందుకంటే + 6, మాకు F చూపినట్లయితే.
కాబట్టి యొక్క మేము జెడ్ + 6 మాకు F ఇవ్వాలని అన్నారు ఖచ్చితంగా తెలుసు గుర్తు తెలియజేయండి.
ASCII విలువలు లో, z 122 మరియు 102 F ఉంది.
కాబట్టి మేము మా సీజర్ ఫార్ములా తయారు చేసే కొన్ని వెళ్లేందుకు కలిగి మాకు 102 ఇవ్వటానికి
122 లో తీసుకున్న తరువాత.
మేము ఈ ఫార్ములా, వాస్తవానికి మీరు 24 ఇచ్చే ('z' + 6)% 26, దరఖాస్తు అయితే
122 + 6 128 ఎందుకంటే; 128% 26 మీరు 24 మిగిలిన ఇస్తుంది.
కానీ నిజంగా F కాదు. ఆ ఖచ్చితంగా 102 కాదు.
కూడా వర్ణమాలలో 6 లేఖ కాదు.
కాబట్టి సహజంగా, మేము ట్వీకింగ్ ఈ కొద్దిగా విధంగా ఉండాలి.
సాధారణ వర్ణమాల ప్రకారం, మేము z 26TH అక్షరం మరియు F 6 అని తెలుసు.
కానీ మేము కంప్యూటర్ సైన్స్ లో ఉన్నాము, కాబట్టి మాకు 0 వద్ద ఇండెక్స్ చూడాలని.
బదులుగా z సంఖ్య 26 గా కాబట్టి అప్పుడు, మేము అది యొక్క సంఖ్య 25 చెప్పడానికి వెళుతున్న
ఒక 0 ఎందుకంటే.
కాబట్టి ఇప్పుడు యొక్క ఈ ఫార్ములా దరఖాస్తు తెలియజేయండి.
మేము z మీరు 31 ఇస్తుంది, 25 + 6 ప్రాతినిధ్యం ఉంటాయి.
మరియు 31 mod 26 ఒక మిగిలిన వంటి మీరు 5 ఇస్తుంది.
మేము F వర్ణమాల 5 వ అక్షరం తెలుసు ఎందుకంటే, ఆ పరిపూర్ణ ఉంది.
కానీ ఇప్పటికీ సరైన, F కాదు? ఇప్పటికీ 102 కాదు.
కాబట్టి ఈ pset కోసం, ఒక సవాలు సంబంధం కనుగొనేందుకు ప్రయత్నిస్తున్న ఉంటుంది
ఈ ASCII విలువలు మరియు అక్షర సూచిక మధ్య మార్పిడి మధ్య.
ముఖ్యంగా, మీరు చెయ్యవచ్చును ఏమిటి, మీరు, ASCII విలువలు తో ప్రారంభం కావాలి
కానీ అప్పుడు మీరు ఏదో ఒక అక్షర సూచిక ఆ అనువదించాలనుకుంటున్న
అప్పుడు అది ఏ అక్షరం లెక్కించేందుకు - సాధారణంగా, దాని అక్షర సూచిక ఏమిటి
సాంకేతికలిపి పాత్ర - ఆ తిరిగి ASCII విలువలు అనువదించు.
మీరు మీ ASCII పట్టిక అవుట్ రెచ్చిపోయినప్పుడు చేస్తే, అప్పుడు 102 మరియు 5, ప్రయత్నించండి మరియు మధ్య సంబంధాలు కనుగొనడానికి, సే
లేదా 122 మరియు 25.
మేము ఆదేశ పంక్తి వాదనలు నుండి మా కీ సంపాదించిన తర్వాత, మేము, సాదా సంపాదించిన చేసిన
మేము అది enciphered చేసిన.
ఇప్పుడు మేము వదలి అన్ని ప్రింట్ ఉంది.
మేము ఈ వివిధ రెండు మార్గాలు పని చేయడు.
మేము సహకరించు వంటి మనం చేయగల వాస్తవానికి ప్రింట్ చేయబడుతుంది.
మేము స్ట్రింగ్ లో అక్షరాల కంటే iterate వంటి,
మేము అది లెక్కించేందుకు మేము కేవలం సరైన చేసి, ప్రింట్ చేయవచ్చు.
ప్రత్యామ్నాయంగా, మీరు కూడా వ్యూహంలో ఇది నిల్వ మరియు అక్షరాలు ఒక వరుస కలిగి
మరియు చివరిలో ఆ వ్యూహరచనలు పైగా iterate మరియు దీనిని ప్రింట్.
కాబట్టి మీరు ఆ ఎంపికలను ఒక జంట కలిగి ఉంటాయి.
మరియు% సి ఒక పాత్ర ప్రింటింగ్ కోసం ప్లేస్హోల్డర్ మాత్రం గుర్తుంచుకోండి.
, అందువల్ల మేము సీజర్ కలిగి, మరియు ఇప్పుడు మేము విజెనెరే కొనసాగండి
ఇది సీజర్ సమానమైన కానీ కొద్దిగా సంక్లిష్టంగా ఉంటుంది.
కాబట్టి ముఖ్యంగా విజెనెరే మీకు ఒక కీవర్డ్ అక్కడ కూడా చూడాలని ఉంది.
బదులుగా ఒక సంఖ్య యొక్క కాబట్టి, మీరు, ఒక స్ట్రింగ్ చూడాలని
అందువలన, మీ కీవర్డ్ వ్యవహరించే జరగబోతోంది.
అప్పుడు, మామూలుగానే, మీరు యూజర్ నుండి ఒక స్ట్రింగ్ కొరకు ప్రేరణ పొందండి చూడాలని
మరియు తర్వాత ఇది encipher మరియు తరువాత వారిని సాంకేతికపాఠం తిరిగి ఇవ్వండి.
నేను అన్నాడు కనుక, అది, ఒక నిర్దిష్ట సంఖ్యలో తరలించడం యొక్క తప్ప, సీజర్ సమానమైన యొక్క
సంఖ్య వాస్తవానికి పాత్ర నుండి పాత్ర ప్రతి సమయాన్ని మార్చడానికి అన్నారు.
మార్చేందుకు నిజమైన సంఖ్య సూచించుటకు, అది కీబోర్డ్ అక్షరాల ప్రాతినిధ్యం ఉంది.
ఉదాహరణకు మీరు ఒక ఒక మార్పు నమోదు చేసుకుంటూ ఉంటే, అప్పుడు ఆ 0 ఒక షిఫ్ట్ అనుగుణంగా ఉంటుంది.
కాబట్టి మళ్ళీ అక్షర సూచిక తిరిగి ఉంది.
మీరు మేము నిజంగా ASCII విలువలు వ్యవహరించే చేస్తున్న చూస్తూ ఉన్నట్లయితే ఉపయోగకరంగా ఉండవచ్చు ఏమి
అలాగే అక్షరాలు అలాగే అక్షర సూచిక వంటి
బహుశా, 25 ద్వారా 0 యొక్క అక్షర సూచిక చూపే మీ స్వంత ASCII పట్టిక కనుగొనడానికి లేదా తయారు
తద్వారా మీరు రకమైన సంబంధం z ద్వారా, మరియు ASCII విలువలు చూడగలరు
మరియు గీసేందుకు మరియు కొన్ని నమూనాలు ప్రయత్నించండి మరియు కనుగొనండి.
అదేవిధంగా, మీరు F ద్వారా కొన్ని ఉదాహరణకు వద్ద తరలించడం జరిగింది ఉంటే -
మరియు ఈ గాని చిన్న లేదా పెద్ద F ఉంది - ఆ 5 అనుగుణంగా ఉంటుంది.
మేము ఇప్పటివరకు మంచి భావిస్తున్నారా?
విజెనెరే సూత్రం ఒక భిన్నమైనది.
సాధారణంగా, మీరు అది సీజర్ వంటిది ఆ చూడండి
తప్ప బదులుగా కేవలం k మేము k సూచిక j ఉన్నాయి.
మేము, ఎందుకంటే తప్పనిసరిగా కీవర్డ్ యొక్క పొడవు నేను ఉపయోగించి చేస్తున్నట్లు గమనించండి
మా సాంకేతికపాఠం యొక్క పొడవు అవసరం లేదు.
మేము నేను తర్వాత ఒక బిట్ కలిగి ఒక ఉదాహరణ చూడండి ఈ ఒక బిట్ స్పష్టమైన ఉంటుంది.
సాధారణంగా, మీరు ohai ఒక ముఖ్య పదాన్ని మీ ప్రోగ్రామ్ అమలు చేస్తే,
ఆ ప్రతిసారీ, ohai మీ మార్పు మాత్రం దీని అర్థం.
కాబట్టి మీరు మీ కీవర్డ్ లో ఏమిటో స్థానం బట్టి,
మీరు ఆ మొత్తం మీ కొన్ని సాంకేతికపాఠం పాత్ర మార్చేందుకు వెళుతున్న.
మళ్లీ, కేవలం సీజర్ వంటి మేము విషయాలను క్యాపిటలైజేషన్ సంరక్షించబడింది నిర్ధారించుకోవాలి
మరియు మేము మాత్రమే encipher అక్షరాలు, కాని అక్షరాలు లేదా ఖాళీలను.
కాబట్టి, మీరు ఉపయోగించి ఉండవచ్చు క్రియలు న సీజర్ తిరిగి చూడండి
మీరు విషయాలను మార్చడానికి మరియు ఇక్కడ మీ ప్రోగ్రామ్ ఆ దరఖాస్తు ఎలా నిర్ణయించుకుంది విధంగా.
కాబట్టి ఇది మ్యాప్ చూద్దాం.
మేము GetString వినియోగదారు నుండి సంపాదించిన చేసిన సాదా కలిగి
ఈ చెప్పడం ... CS50 ఉంది!
అప్పుడు మేము ohai ఒక ముఖ్య పదాన్ని కలిగి ఉన్నాయి.
మొదటి 4 అక్షరాలు అందంగా సులువు.
మేము T, o ద్వారా మార్చబడుతుంది అన్నారు తెలుసు
h h ద్వారా మార్చబడుతుంది అన్నారు అప్పుడు, నేను ద్వారా మార్చబడుతుంది అన్నారు.
ఇక్కడ మీరు ఒక 0 ప్రాతినిధ్యం చూడండి
కాబట్టి అప్పుడు ముగింపు విలువ వాస్తవానికి ముందు కేవలం ఒకే అక్షరం.
అప్పుడు s నేను ద్వారా బదిలీ అవుతుంది.
కానీ మీరు ఇక్కడ ఈ బిందువులను.
మేము అప్పుడు మేము ఏదైనా దాన్ని మార్చడానికి లేదు, ఆ encipher చేయకూడదని
మరియు కేవలం మారకుండా కాలం ముద్రించాలా.
[విద్యార్థి] నేను మీరు ఈ ద్వారా బదిలీ అవుతుంది తెలుసు ఎలా అర్థం లేదు - ఎక్కడ చేశాడు - >> ఓహ్, సారీ.
ఇక్కడ ఎగువన మీరు ఇక్కడ ఆ ఆదేశ పంక్తి వాదన ohai, చూడండి
ఆ కీవర్డ్ చేస్తాడు.
కాబట్టి ప్రాథమికంగా, మీరు కీవర్డ్ లో అక్షరాల కంటే సైకిల్ చేస్తున్నారు.
[విద్యార్థి] కాబట్టి o అదే బదిలీ కావడం ఉంది -
కాబట్టి o వర్ణమాలలో ఒక నిర్దిష్ట సంఖ్యలో సూచించదు.
[విద్యార్థి] రైట్. కానీ మీరు CS50 భాగంగా ఎక్కడ నుండి వచ్చింది?
ఓహ్. మీరు వంటి ఎక్కడ GetString యొక్క "నాకు ఎన్కోడ్ ఒక స్ట్రింగ్ ఇవ్వండి."
[విద్యార్థి] వారు మీరు మారిపోయే ఆ వాదన ఇవ్వాలని వెళుతున్న
మరియు మీరు మీ మొదటి స్ట్రింగ్ కోసం అడుగుతాము. >> అవును.
కాబట్టి వారు అమలు చేసేటప్పుడు, వారు కీవర్డ్ ఉన్నాయి చూడాలని
కమాండ్ లైన్ వాదనలు వారు అమలు చేసినప్పుడు.
,, తక్కువ కాదు అప్పుడు మీరు వారు నిజానికి మీరు 1 ఇచ్చిన చేసిన తనిఖీ చేసిన మరియు మరింత
అప్పుడు మీరు ఒక స్ట్రింగ్ కోసం ప్రాంప్ట్ చూడాలని, చెప్పడానికి, "నాకు ఒక స్ట్రింగ్ ఇవ్వండి."
ఈ సందర్భంలో వారు మీరు ఈ ఇచ్చాను పేరు కాబట్టి ఆ ... CS50 ఉంది!
కాబట్టి మీరు ఆ ఉపయోగించడానికి మరియు ohai ఉపయోగించడానికి మరియు పైగా iterate చూడాలని.
ఇక్కడ మేము కాలాలు ఎన్క్రిప్ట్ పైగా హాజరు గమనించండి,
కానీ ohai, తదుపరి కోసం మా స్థానం నుండి మేము o ఉపయోగిస్తారు.
ఈ సందర్భంలో ఇది 4 అని ఎందుకంటే చూడటానికి కాస్త కష్టం
కాబట్టి యొక్క ఒక బిట్ చెయ్యనివ్వండి. కేవలం నా కొనసాగించు.
అప్పుడు మేము వరుసగా o మరియు h అనువదించారు ఇవి నేను మరియు s, ఉన్నాయి.
అప్పుడు మేము ఒక స్పేస్, కాబట్టి, అప్పుడు మేము ఖాళీలను encipher కు వెళ్ళడం లేదు తెలుసు.
కానీ నోటీసు ఆ బదులుగా ఇక్కడ ఈ స్పాట్ లో వెళుతున్న,
మేము ఒక ద్వారా ఎన్క్రిప్ట్ చేసిన - ఇక్కడే - మీరు ఆ చూడవచ్చు నాకు తెలీదు.
అది మీరు నిజంగా ముందుగా నిర్ణయించిన ఇష్టం సే, o ఇక్కడ వస్తుంది కాదు, h ఇక్కడ వస్తుంది,
ఒక ఇక్కడకు వెళ్తుంది, నేను ఓ, h, ఒక, i, o, h, ఒక, i., ఇక్కడ వస్తుంది మీరు ఆ పని చేయడం లేదు.
మీరు ముఖ్యపదాన్ని మీ స్థానం బదిలీ
మీరు నిజంగా ఒక నిజమైన లేఖ ఎన్క్రిప్ట్ కావడం చేస్తున్న తెలిసిన ఉన్నప్పుడు.
ఆ రకమైన సమంజసం లేదు?
సరే.
కాబట్టి కొన్ని రిమైండర్లు.
మీరు మాత్రమే మీ కీవర్డ్ తరువాతి అక్షరం చేరుకునేందుకు ఆ నిర్ధారించుకోవాలి
మీ పాఠంలోని అక్షరం ఒక అక్షరం ఉంది.
మేము o వద్ద ఉన్నారు చెప్పడానికి.
మేము తదుపరి పాత్ర సాదా యొక్క నేను సూచిక, ఉదాహరణకు, ఒక సంఖ్య అని గమనించండి.
మేము మరొక అక్షరం చేరుకునే వరకు అప్పుడు, j, మా కీవర్డ్ కోసం సూచిక ముందుకు లేదు.
మరలా, మీరు కూడా కీవర్డ్ ప్రారంభంలో మిమ్మల్ని చుట్టబెట్టిన ఆ నిర్ధారించుకోవాలి
మీరు చివరిలో ఉన్నప్పుడు.
మీరు ఇక్కడ మేము నేను ఉన్నాము చూసినట్లయితే, తర్వాత ఒక o ఉండాలి.
కాబట్టి మీరు మీ కీవర్డ్ ప్రారంభానికి చుట్టబెట్టిన చేసే విధంగా కావలసిన
మీరు ముగింపు చేరుకోవడానికి ప్రతి సమయం.
మరియు మరలా, ఏ ఆపరేటర్లు రకమైన చుట్టూ అంటించే ఆ సందర్భంలో ఉపయోగపడుతుంది?
ఉదాహరణకు ఆఫ్ లెక్కింపు లో ఇష్టపడుతున్నారు.
[విద్యార్థి] శాతం సంకేతం. >> అవును, మాడ్యులో ఇది శాతం సైన్.
కాబట్టి మాడ్యులో మీ ohai లో ఇండెక్స్ మీద మూసివేయాలని ఉంటుంది ఇక్కడ ఉపయోగకరంగా ఉండగలదో.
మరియు కేవలం ఒక శీఘ్ర సూచన: ఒక బిట్ లెక్కింపు ఆఫ్ వంటి కీవర్డ్ పైగా చుట్టే ఆలోచించడానికి ప్రయత్నించండి
3 సమూహాలు, 4 వ వ్యక్తి, ఇక్కడ ఉంటే
వారు మాట్లాడుతూ వారి సంఖ్య 1 ఇది 4 mod 3, ఉంది.
కాబట్టి ఆ విధంగా ప్రయత్నించండి మరియు ఆలోచించండి.
మీరు అప్పుడు KJ ci మరియు తరువాత pi కానీ అక్కడ, ఫార్ములా చూసిన, వంటి
ఆ ట్రాక్ ఆ నిర్ధారించుకోవాలి.
మీరు నేను కాల్ లేదు, మీరు, ఇది j కాల్ లేదు
కానీ మీరు మీ పాఠంలోని వద్ద మీరు ఈ స్థానంలో ట్రాక్ ఆ నిర్ధారించుకోవాలి
అలాగే స్థానం వంటి మీరు మీ కీవర్డ్ లో వద్ద ఉన్నట్లు
ఆ అవసరం అదే మాత్రం కాదు ఎందుకంటే.
కీవర్డ్ లేదు మాత్రమే - మీ సాదా కంటే పూర్తిగా భిన్నంగా పొడవు ఉంటుంది.
అలాగే, మీ సాదా, సంఖ్యలు మరియు అక్షరాలు ఉన్నాయి
కాబట్టి ఇది ఖచ్చితంగా కలిసి మ్యాచ్ మాత్రం కాదు. అవును.
[విద్యార్థి] అక్కడ కేసు మార్చేందుకు క్రియ?
మీరు రాజధాని కి ఒక మార్చవచ్చు? >> అవును, ఖచ్చితంగా ఉంది.
మీరు తనిఖీ చేయవచ్చు - నేను toupper, అన్ని 1 పదం భావిస్తున్నారు.
కానీ మీరు విషయాలు సాంకేతికలిపి మరియు టెక్స్ట్ నిల్వ చేయడానికి ప్రయత్నిస్తున్న సమయంలో,
అది ప్రత్యేక సందర్భాలలో కలిగి ఉత్తమ ప్రధానంగా ఉంది.
అది ఒక పెద్ద అయితే, మీరు ఈ ద్వారా మారిపోయే కావలసిన
మీ సూత్రంలో, మీరు తిరిగి చూడాలని మేము గో యొక్క రకాన్ని కలిగి ఎలా ఎందుకంటే
పరస్పరం సంఖ్యలు ప్రాతినిధ్యం యొక్క ASCII మార్గం మధ్య
అసలు అక్షర సూచిక, మేము నిర్ధారించుకోవాలి
మీరు వెళుతున్న ఆ నమూనా యొక్క కొన్ని రకమైన ఉన్నట్లు జరగబోతోంది.
వాస్తవానికి నమూనా మరొక గమనిక.
మీరు ఖచ్చితంగా సంఖ్యలు వ్యవహరించే కావడం చేస్తున్నారు.
శైలి యొక్క ఒక ఉదాహరణ, ఇది మ్యాజిక్ సంఖ్యలు ఉపయోగించడానికి లేదు ప్రయత్నించండి.
మీరు ద్వారా ప్రతి సమయ మార్పిడి ఏదో మీరు చెప్పడానికి -
మీరు ఏదో బదిలీ కావడం చేసినప్పుడు సరే, సూచన కాబట్టి, మరొక స్పాయిలర్ ఉంది
కొంత ద్వారా, ఒక వాస్తవ సంఖ్య ద్వారా ప్రాతినిథ్యం లేదు ప్రయత్నించండి
కానీ ప్రయత్నించండి మరియు మీరు రకమైన మరింత అర్ధవంతం ఇది ASCII విలువను ఉపయోగించవచ్చు చూడండి.
మరో గమనిక: మేము సూత్రాలు రంజింప చేయడానికి ప్రయత్నిస్తున్నాము,
మీ TF రకమైన మీరు ఉపయోగిస్తూ ఉండవచ్చు ఏమి నమూనా తెలుస్తుంది అయినప్పటికీ,
మీ వ్యాఖ్యలు రకమైన లో ఉత్తమ తర్కం, ఇష్టం, వివరించేందుకు
"నేను ఈ నమూనా ఉపయోగించి నేను ..." మరియు రకమైన మీ వ్యాఖ్యలలో క్లుప్తమైన నమూనా వివరిస్తాయి.
[ఈ walkthrough 2] ఇతర ప్రశ్నలు లేకపోతే, అప్పుడు నేను కొద్దిగా కోసం ఇక్కడ ఉండడానికి చేస్తాము.
క్రిప్టో మరియు ధన్యవాదాలు: మీ pset 2 అదృష్టం.
[విద్యార్థి] ధన్యవాదాలు. >> ధన్యవాదాలు.
[మీడియా ఆఫ్లైన్ పరిచయ]