>> రాబ్: హాయ్, నేను రాబ్ ఉన్నాను, మరియు యొక్క అర్థమును తెలియజేయండి విజెనెరే కార్యక్రమం.
మేము చెయ్యాల్సిన మొదటి విషయం ఖచ్చితంగా వినియోగదారు మేము ఊహించిన దాని ఎంటర్
వాటిని కమాండ్ లైన్ వద్ద.
Argc 2 కాదు చేస్తే అర్ధం యూజర్ స్ట్రింగ్ మేము నమోదు చేయలేదు
మా Encrypting వంటి ఉపయోగించి కావలసిన స్ట్రింగ్, లేదా వారు
చాలా విషయాలు ప్రవేశించింది.
మరియు మేము ఏమి లేదు ఆ ఇతర విషయాలు.
>> కాబట్టి మేము వాటిని చెప్పండి వారు ఎంటర్ వుండాలి.
మరియు మేము తిరిగి.
ఇప్పుడు, మేము, argc 2 అని ఊహించుకొని కార్యక్రమం మిగిలిన కొనసాగుతుంది.
>> మేము [1] argv పేరు అలియాస్
వేరియబుల్ కీవర్డ్ లోకి.
మేము లేదు కాబట్టి [1] పేరు argv ఉపయోగించడానికి
కార్యక్రమం మిగిలిన.
మరియు బహుశా మేము మర్చిపోతే చేస్తాము ఏ కాబట్టి అర్థం మరియు.
కీవర్డ్ చాలా NICER పేరు.
మరియు మేము వెంటనే పొడవు పట్టుకోడానికి ఉంటుంది ఇక్కడే మా కీవర్డ్.
>> OK, కాబట్టి ఇప్పుడు మేము ఆ తనిఖీ మీరు మా కీవర్డ్ నిజానికి చెల్లుతుంది.
మేము తీగలను గుప్తీకరించడానికి ఉపయోగించడానికి కీవర్డ్ కేవలం అక్షర ఉండాలి
అక్షరాలు.
యూజర్ కాని అక్షర ఎంటర్ చేస్తే అక్షరాలు, మేము చెప్పాలి, కీవర్డ్
మాత్రమే ఒక ద్వారా కలిగి ఉండాలి అప్పుడు Z మరియు తిరిగి.
కాబట్టి ఈ ఐటరేట్ పైగా అన్ని మా కీవర్డ్ అక్షరాలు, తనిఖీ
ఒక అక్షర అప్పుడు లేకపోతే మేము ఆ హెచ్చరిక ప్రింట్ అవసరం.
>> మేము ఈ పాయింట్ ను ఒకసారి, మేము తెలుసు స్ట్రింగ్ సరైన ఉండాలి.
కీవర్డ్ సరైన ఉండాలి.
ఇప్పుడు మేము నుండి సందేశం పొందాలి వారు మాకు కావలసిన యూజర్
ఆ కీ పదబంధం గుప్తీకరించడానికి.
కాబట్టి ఆ సందేశం, మేము ఒక కలిగి అయితే వెళుతున్న ఆ లూప్
నిరంతరం వినియోగదారు నుండి ఒక స్ట్రింగ్ పొందండి అవి చెల్లుబాటు అయ్యే స్ట్రింగ్ ఎంటర్ వరకు.
>> కొనసాగిస్తూ, మేము ఇక్కడ ఈ వేరియబుల్ చూడండి, పూర్ణాంకానికి nun_letters_seen.
మేము అవసరం ఎందుకు మేము చూస్తారు రెండవ ఆ.
కాని లూప్ ఈ iterate అన్నారు నేను అప్ 0 అన్ని మార్గం సమానం నుండి
మేము iterating అంటే, n సమానం అన్ని సాధ్యం పైగా
మా సందేశంలో అక్షరాలు.
మేము అన్ని గుప్తీకరించడానికి తెచ్చుకున్నాయి మా సందేశంలో అక్షరాలు.
కాబట్టి, మేము (isalphamessage [నేను] ఉంటే ఏమి గమనించవచ్చు మేము గుప్తీకరించడానికి అనుకుంటున్న ఎందుకంటే
అక్షర లేని అక్షరాలు.
అడ్డుకోలేవు ఉంటే, స్పేస్, లేదా సంఖ్యలు, మేము లేదు
ఆ గుప్తీకరించడానికి మీరు.
>> ఇప్పుడు, అది అక్షర అని అనుకుంటే మేము మొదటి గుర్తించడానికి కావలసిన మేము
వాస్తవానికి గుప్తీకరించడానికి మీరు ఉపయోగించి సందేశం.
కాబట్టి నేను ఆ ద్వారా ఏమిటి?
>> యొక్క ఊహించుకోవటం కీ పదబంధం ఎంటర్ యూజర్ abc ఉంది.
మేము గుప్తీకరించడానికి ఉపయోగిస్తున్నదానికి ఉంది.
ఇప్పుడు, naively, మేము అర్థం భావిస్తున్న మేము మొదటి పాత్ర గుప్తీకరించడానికి మీరు
0 ద్వారా మా భాషా, నుండి సాధనంగా 0 పాత్ర తిరిగే.
>> మేము రెండవ పాత్ర గుప్తీకరించడానికి మీరు 1 ద్వారా, 2 ద్వారా మూడవ పాత్ర,
0 ద్వారా నాలుగో పాత్ర ఐదవ 1 ద్వారా, అందువలన న 2 ఆరవ మరియు.
కానీ మేము వెళ్ళకండి ఆ, గుర్తుంచుకోవాలి ప్రదేశములలో చిహ్నాలు మరియు సంఖ్యలు.
అంటే యూజర్ ఎంటర్ ఉంటే సందేశంగా హలో వరల్డ్
వారు అప్పుడు, గుప్తీకరించడానికి కావలసిన మేము 0 ద్వారా h గుప్తీకరించడానికి మీరు
, 1 ద్వారా ఒక, ఇ సంబంధిత l 2 ద్వారా, 0 ద్వారా l, 1 ద్వారా o.
మేము ఎన్క్రిప్టెడ్, స్పేస్ వెళ్ళకండి 2 ద్వారా w, 0, 1, 2, 0 ద్వారా o.
మేము దిగింది చేసింది అయితే, గమనించవచ్చు స్పేస్, అప్పుడు మేము ఎన్క్రిప్టెడ్ ఉండేది
0 ద్వారా w మరియు తో ముగించారు తప్పు స్ట్రింగ్.
>> సరే, ఈ మేము వేరియబుల్ అవసరం ఏమిటి కోసం num_letters_seen.
మేము ఉపయోగించి గుప్తీకరించడానికి ఉండేవి వదలదు ఈ పద్దతి,
చిహ్నాలు, స్పేస్ మరియు సంఖ్యలను అప్పుడు మేము కేవలం నేను ఏమి వంటి వేరియబుల్ ఉపయోగించవచ్చు
మా కీ పదబంధం లోకి సూచిక.
మేము ఉంచడానికి num_letters_seen ఉపయోగించాలి వాస్తవ స్థలం ట్రాక్
మేము ఇండెక్స్ కావలసిన కీ పదబంధం.
ఇక్కడ, కీవర్డ్ మేము ఉంటే, ఉంటే num_letter_seen mod keyword_length, కాబట్టి
ఎందుకు మేము mod చేయాలి కీవర్డ్ పొడవు ద్వారా?
>> Well, హలో ప్రపంచ ఒక మంచి ఉదాహరణ.
కీవర్డ్ abc ఉంది, అప్పుడు మేము అవసరం నిరంతరం బి ఒక అప్పటి గుప్తీకరించడానికి
అప్పుడు సి, అప్పుడు, చుట్టూ తిరిగి వ్రాప్ ఒక, బి, సి, ఒక, బి, సి.
కాబట్టి మేము కీవర్డ్ పొడవు ద్వారా mod అవసరం చుట్టూ తిరిగి మూసివేయాలని క్రమంలో.
>> కాబట్టి, ఈ ఒక పెద్ద అక్షరం ఉంటే తర్వాత మేము ద్వారా Int ప్రధాన
వర్ణమాలలో లేఖ యొక్క స్థానం, మేము చాలా పొందుటకు ఇది
రాజధాని A. తీసివేయడం మరియు అదేవిధంగా, చిన్న అక్షరాలను కోసం, మేము
మేము ద్వారా కావలసిన కీ పొందవచ్చు చిన్న ఒక తీసివేయడం.
కాబట్టి సంబంధం లేకుండా లేఖ కీ పదబంధం లో ఒక రాజధాని లేదా
చిన్న అక్షరం, మేము చూడాలని అదే ద్వారా గుప్తీకరించడానికి.
>> ఇప్పుడు మేము మా కీ కలిగి, మేము ఇక్కడ చూడండి, ఆ సందేశం ఉంటే నేను ఒక పెద్ద ఉంది
పాత్ర, అప్పుడు మేము లెక్కించేందుకు ఆ వర్ణమాలలో స్థానం
పాత్ర, ఇది మా కీ జోడించడానికి, తిరిగి వ్రాప్ చుట్టూ కాబట్టి మేము గతంలో జరిగింది ఒక
z మేము తిరిగి ఒక, బి, సి వెళ్లి,.
, చివరకు, రాజధాని A. తిరిగి జోడించండి కాబట్టి మేము [తిరిగి మారవచ్చు? Ascii?]
ఈ అక్షరాలు పరిధి బదులుగా వర్ణమాలలో సంఖ్యా స్థానం
ఈ అక్షరాలు.
>> మరియు మేము కోసం ఇదే చిన్నబడి అక్షరాలు.
మేము చిన్న అవుట్ వ్యవకలనం కావలసిన తప్ప ఒక మరియు లో తిరిగి జోడించండి
ముగింపు, ఒక చిన్న.
ఆ num_letter_seen మాత్రమే ఉంది గమనించండి పెరుగుదల ఉంటే నేను సందేశాన్ని
అక్షర.
ఈ ఫైళ్ళను, చిహ్నాలు skip ఎలా ఉంది, మరియు మా కీ పదబంధం, నుండి సంఖ్యలు
num_letter_seen మేము ఉపయోగిస్తున్నదానికి ఉంది మా కీవర్డ్ లోకి సూచిక.
>> చివరగా, చివరికి, ఇప్పుడు ఆ సందేశం నేను, గుప్తీకరించబడింది మేము
నేను సందేశాన్ని ముద్రించడానికి.
అంతే.
నా పేరు రాబ్ ఉంది.
మరియు ఈ విజెనెరే ఉంది.
>> [MUSIC ప్లే]