[Powered by Google Translate] [Walkthrough - პრობლემა Set 2]
[Zamyla Chan - ჰარვარდის უნივერსიტეტი]
[ეს არის CS50. CS50.TV]
ყველა უფლება. Hello, ყველას, და მივესალმები რომ Walkthrough 2.
პირველი, მე მინდა მივულოცო თქვენ დასრულების pset 1.
მე ვიცი, რომ ეს შეიძლებოდა ყოფილიყო ცოტა მკაცრი ზოგიერთ თქვენგანს,
შეიძლებოდა ყოფილიყო თქვენი პირველი კომპიუტერი პროგრამა, რომელიც თქვენ წერდა,
მაგრამ გვახსოვდეს, რომ დასასრულს ამ, როდესაც თქვენ ვიხსენებთ ბოლოს სემესტრის
თქვენ შეხედეთ pset 1 და თქვენ ამბობენ, "Hey, I შეეძლო, რომ 5 წუთი."
ასე რომ იცნობთ და ენდობით, რომ ბოლომდე თქვენ აუცილებლად იპოვოს pset 1 საკმაოდ მარტივია.
მაგრამ ახლა ეს უზარმაზარი კეთილმოწყობის და გილოცავთ მიღების გაკეთდეს.
ახლა, ასევე სწრაფი შენიშვნა, სანამ შეღწევას ხორცი walkthrough.
მინდა, რათა სწრაფი გაითვალისწინოთ, რომ მე ხანდახან არ ექნება საკმარისი დრო
დროს walkthroughs გავლა თითოეულ გზას აკეთებს პრობლემის კომპლექტი
და საკმაოდ უბრალოდ იქნებ ფოკუსირება 1 ან 2 სახის შესრულება,
გზები, რომ თქვენ შეიძლება ამის გაკეთება.
მაგრამ ეს არ არის იმის თქმა, რომ თქვენ ეკრძალება აკეთებს ამას სხვა გზა.
ხშირია, როგორც კომპიუტერული მეცნიერების, მრავალი გზა კეთების რამ,
და ასე ნამდვილად მოგერიდებათ გამოიყენოს სხვადასხვა ტიპის გადაწყვეტა, ვიდრე შეიძლება წარმოდგენილი.
[Pset 2: Crypto - Zamyla Chan - zamyla@cs50.net]
[Pset2 - 0. სექცია კითხვები - 1. Caesar - 2. Vigenere]
ყველა უფლება. ასე რომ პრობლემა მითითებული 2: Crypto არის fun ერთი.
ისევ და ისევ, ყველა pset თქვენ იწყება მონაკვეთზე კითხვები
რომ აპირებს ჩატარდება თქვენი სექციები თქვენი ენიჭება სწავლების თანამემამულე.
ჩვენ არ ვაპირებთ გავლა ამ მეტი walkthrough,
მაგრამ ისინი აუცილებლად დაგეხმარებათ დაასრულებს pset.
ამიტომ პირველ ნაწილს პრობლემა კომპლექტი არის Caesar.
და ასე Caesar ვინმე გაივლის თქვენ გასაღების მთელ რიცხვს,
და თქვენ გაშიფრავს სიმებიანი ტექსტის, რომ მოგაწოდოთ
და მისცეს მათ უკან დაშიფრული რამ.
თუ ვინმე უყურებს საშობაო ამბავი, არსებობს მაგალითი, რომ არსებობს.
მაშინ მეორე ნაწილი პრობლემა კომპლექტი არის Vigenere,
რაც უფრო მოწინავე დაშიფვრის ტექნიკით.
ასე რომ, ჩვენ ვაპირებთ encipher ნაჭერი ტექსტი,
გარდა ნაცვლად მხოლოდ ერთი რიცხვი, ჩვენ რეალურად აპირებს encode ეს
ერთად სიტყვით რომ მომხმარებელი მიიღებს მოგვაწოდოთ.
Okay, ასე პირველი იარაღია ყუთისთვის დღეს რეალურად უნდა განახლებაზე ელექტრო მოწყობილობების.
On ფორუმი ჩვენ ვხედავთ რამ, როგორიცაა, "რატომ არ ეს ნამუშევარი?"
"რატომ არ წარმოადგენს 50 სამუშაო?"
და ხშირად გამოსავალი არის რეალურად მხოლოდ განაახლოთ თქვენი მოწყობილობის.
და ასე თუ მხოლოდ აწარმოებს ტერმინალში ფანჯარა თქვენს ელექტრო sudo yum-y -
რომ დროშა ამბობდა დიახ, განაახლოს ყველაფერი - განახლება,
მაშინ თქვენი მოწყობილობის განაახლებს თუ საჭირო იქნება.
და იგი არ ავნებს თუ უკვე არიან უახლესი ვერსია ელექტრო მოწყობილობების.
მაშინ ეს უბრალოდ ამბობენ არ არის ახალი განახლებები შესაძლებელი გავაგრძელოთ მუშაობა გასწვრივ.
მაგრამ ეს არის კარგი შეასრულოს კი ყოველ ჯერზე, რომ თქვენ გახსნა ელექტრო მოწყობილობების
რადგან ჩვენ ჯერ კიდევ ძალიან ბევრი რამ -
ხანდახან თუ ჩვენ მოვიდეს bug - აფიქსირებს მას ელექტრო მოწყობილობების.
ასე რომ დარწმუნდით რომ თქვენ გაქვთ უახლესი ვერსია ელექტრო მოწყობილობების
და აწარმოებს, რომ განაახლოს არსებობს.
ყველა უფლება. ასე რომ, რადგან ჩვენ საქმე გვაქვს წერილებს და შეცვლის, enciphering რამ,
ჩვენ ვაპირებთ ნამდვილად სურს გახდეს საუკეთესო მეგობარი ჩვენს ASCII ჩარტში.
უამრავი პირობა შემოსული, თუ თქვენთვის. შესაძლოა, საკუთარი.
ძირითადად, ყველა წერილში და ყველა ნომერი და ყველა პერსონაჟი
არსებობს მთელი რიგი მათთან ასოცირებული,
ამიტომ კარგია, რომ ნახოთ მათი ASCII ღირებულებებს ერთად ფაქტობრივი წერილში.
რომ აუცილებლად დაგეხმაროთ პრობლემა კომპლექტი.
ერთი რამ, რომ ნამდვილად დამეხმარა ამ პრობლემის კომპლექტი იყო რეალურად ბეჭდვა ის,
და როგორც მე გადის, მინდა რეალურად მიაპყროს მასზე,
წერენ, "თუ ეს წასვლა იქ, მაშინ ..."
სახის მიაპყროს მასზე და მარკ it up, გახდეს საუკეთესო მეგობრებს თქვენი ASCII მაგიდასთან.
მაშინ ჩვენ გვაქვს რამდენიმე სხვა იარაღები ჩვენს ხელთ არსებული.
ამჯერად ნაცვლად რეალურად რამაც მომხმარებლის ყველა მათი შეყვანის
ჩვენ ვაპირებთ მოედანზე.
ჩვენ ვაპირებთ შეეკითხება მათ გარკვეული შეყვანის,
მაგრამ ჩვენ ასევე ვაპირებთ უბრალოდ გამოიყენოთ ბრძანება ხაზი არგუმენტები.
ასე რომ, როდესაც მათ პროგრამა, ჩვეულებრივ ამბობთ. / Hello, მაგალითად,
თუ თქვენი პროგრამა იყო hello.c.
მაგრამ ამ დროს ნაცვლად მხოლოდ ვამბობთ, რომ, მათ შეუძლიათ დააყენა სიტყვა, არგუმენტების შემდეგ.
ასე რომ, ჩვენ ვაპირებთ გამოვიყენოთ ჩვენს ხელთ მათ კორიდორი ჩვენთვის, როგორც მათი შეყვანის ისევე,
ასე მოძრავი მიღმა მხოლოდ რითაც ამისთვის მთელი რიცხვი არამედ გამოყენებით command line არგუმენტები.
და მაშინ საბოლოოდ დავრწმუნდებით წასვლას კოლექტორები და სიმები, რომელიც ჩვენ უნდა გამოყენებით ბევრი ისევე.
აქ უბრალოდ მაგალითი 1 მინი ASCII ჩარტში.
როგორც ვთქვი, ყველა წერილში შეესაბამება ნომერი,
და ა.შ. გაეცანით რომ. იგი მოვა მოსახერხებელი.
და მოგვიანებით, როცა ჩვენ ვიწყებთ აკეთებს ზოგიერთი ASCIIMath საქმე ნომრები -
დასძინა, subtracting მათ - მაშინ აუცილებლად კარგი მიმართოს ამ ჩარტში.
ასე რომ აქ მაგალითია კეისრის კოდი - რაღაც, რომ თქვენ შეიძლება არ ითამაშა, რომელზეც.
უბრალოდ საჭე. არსებითად, არსებობს გარე ანბანი და შემდეგ არსებობს შიდა ანბანი.
ასე რომ სწორედ აქ არის მაგალითი კეისრის კოდი, მაგრამ გასაღები 0.
არსებითად, არის შეესაბამება, B არის შეესაბამება B, ყველა გზა მდე ზ
მაგრამ შემდეგ ამბობენ გვინდოდა გასაღები 3, მაგალითად.
მაშინ ჩვენ როტაცია შიდა წამყვანი ისე, რომ ახლა aligns ერთად D და ა.შ.
და ა.შ. ეს არის არსებითად, რასაც ჩვენ ვაპირებთ გავაკეთოთ.
ჩვენ არ გვაქვს საჭე, მაგრამ რაც ჩვენ ვაპირებთ გავაკეთოთ არის ჩვენი პროგრამა
სახის გადაეტანა ანბანი ერთად us გარკვეული რაოდენობის ნომრები.
ასე რომ, როგორც ვთქვი, ჩვენ ვაპირებთ იყოს საქმე command line არგუმენტები
ასევე მიღების რიცხვი.
ამიტომ გზა, რომელიც მომხმარებლის იმოძრავებს თქვენი Caesar პროგრამის მიერ დაყრდნობით. / Caesar
და შემდეგ შევდივართ ხმების ამის შემდეგ.
და ეს რიცხვი წარმოადგენს გასაღები, ცვლა,
რამდენჯერ თქვენ უნდა მოძრავი შიდა წამყვანი თქვენი კეისრის კოდი.
და ა.შ. ხედავთ აქ მაგალითად.
თუ შევედით წერილები to L ჩვენს კეისრის კოდი,
მაშინ შეყვანის D მეშვეობით O იმიტომ რომ ყოველ წერილში გადავიდა მეტი 3 ჯერ,
ისევე, როგორც მაგალითი იმისა, საჭე რომ მე აჩვენა თქვენ.
ასე რომ თუ თქვენ შევიდა, მაგალითად, ეს არის CS50!
მაშინ ასევე გადავიდეს ყველა ის ასოები.
და ეს მთავარია ორივე კეისარი და Vigenere
ის არის, რომ ჩვენ ვაპირებთ გამოტოვოთ ვიდრე რომელიმე არასამთავრობო წერილებს.
ასე რომ ნებისმიერი ფართები, გმირები და ა.შ., ციფრებს, ჩვენ ვაპირებთ შეინახოთ იგივე.
ჩვენ მხოლოდ აპირებს გადაეტანა წერილებს ამ შემთხვევაში.
ასე რომ, როგორც ხედავთ საჭე, ჩვენ მხოლოდ წერილებს ჩვენს ხელთ არსებული,
ამიტომ ჩვენ მხოლოდ გვინდა გადაეტანა წერილები და გაშიფრავს წერილებს.
ასე რომ პირველი რაც უნდა გააკეთოს, თქვენ ხედავთ, რომ გამოყენება Caesar პრობლემების მითითებული 2
არის გასაშვებად კეისრის და მხოლოდ შემდეგ შეიყვანოთ ხმების როდესაც თქვენ აწარმოებს ის ტერმინალში.
ამიტომ, რაც ჩვენ უნდა გავაკეთოთ არის ის, რომ როგორმე კიდევ რომ გასაღები და ვებგვერდზე.
და ასე გვინდა რატომღაც დანახვა იქნება მეორე ბრძანება ხაზი არგუმენტი.
პირველი იქნება. / კეისარი და შემდეგი ერთი იქნება გასაღები ნომერი.
ასე რომ ადრე გვქონდა int ძირითადი (void) დაიწყოს ჩვენი C პროგრამებს.
ჩვენ ვაპირებთ კანი უკან ფენა ცოტა
და რეალურად ვხედავთ, რომ ნაცვლად გადადის ბათილად ჩვენი მთავარი ფუნქცია
ჩვენ რეალურად საქმე 2 პარამეტრებს.
ჩვენ გვყავს int დაასახელა argc და შემდეგ მასივი სიმები მოუწოდა argv.
ამიტომ argc არის მთელი რიცხვი,
და იგი წარმოადგენს რიგი არგუმენტები გაიარა თქვენს პროგრამას.
და შემდეგ argv ფაქტიურად სიაში არგუმენტები გავიდა.
ყველა არგუმენტებია სიმები, და ასე argv წარმოადგენს მასივი, სია, რა სიმები.
ვისაუბროთ იმაზე კოლექტორები ცოტა.
კოლექტორები ძირითადად ახალი მონაცემები სტრუქტურა.
ჩვენ გვყავს ints, ჩვენ ორჯერ, ჩვენ გვაქვს სიმები, და ახლა გვაქვს მასივები.
კოლექტორები არის მონაცემები სტრუქტურები, რომ შეიძლება გამართავს მრავალჯერადი ღირებულებების იგივე ტიპის,
ამიტომ არსებითად, ჩამონათვალი რასაც ტიპის გსურთ.
არსებითად, თუ უნდოდა სიაში რიცხვებით ყველა 1 ცვლადი,
მაშინ იქნებოდა შექმნა ახალი ცვლადი რომ იყო ტიპის int მასივი.
ასე რომ კოლექტორები არის ნულოვანი ინდექსირებულ, რაც იმას ნიშნავს, რომ პირველი ელემენტი array არის ინდექსი 0.
თუ წყობა სიგრძის 4, როგორც ამ მაგალითში, მაშინ თქვენი ბოლო ელემენტს იქნებოდა საათზე ინდექსი 3,
რომელიც 4 - 1.
ასე, რომ შევქმნათ მასივი, თქვენ რაღაც მოსწონს ეს.
Say თქვენ სურდა ორმაგი მასივი.
ეს მიდის ნებისმიერი ტიპის მონაცემები ტიპის, თუმცა.
ასე ვთქვათ, გნებავთ ორმაგი მასივი. Say გსურთ ეძახით საფოსტო ყუთი.
ისევე, როგორც თქვენ, რომ ვრთავ ნებისმიერ სხვა ორმაგი,
თქვენ ვიტყოდი ორმაგი და შემდეგ სახელი, მაგრამ ამ დროს ჩვენ დააყენა კვადრატულ ფრჩხილებში,
და მაშინ ნომერი იქნება სიგრძით მასივი.
შენიშვნა, რომ მასივით ჩვენ შეგვიძლია არ ოდესმე შეცვლის სიგრძე,
ასე რომ თქვენ ყოველთვის უნდა განსაზღვროს და აირჩიოს რამდენი ყუთები,
რამდენი ფასეულობების თქვენი მასივი აპირებს გამართავს.
ასე შექმნას სხვადასხვა ღირებულებების თქვენს მასივი, თქვენ აპირებს გამოიყენოს ეს შემდეგი სინტაქსის,
როგორც ხედავთ on the slide.
თქვენ გაქვთ საფოსტო ყუთი ინდექსი 0 დაწესდება 1,2,
საფოსტო ყუთი ინდექსი 1 კომპლექტი 2.4 და ა.შ.
ახლა რომ ჩვენ მიმოიხილა კოლექტორები bit, მოდით დავუბრუნდეთ argc და argv.
ჩვენ ვიცით, რომ argv არის მასივი სტრიქონები.
ასე რომ, როდესაც მომხმარებლის შეჭრა - ამბობენ ისინი გაშვებული პროგრამა -
ამბობენ. / მიესალმები დავით Malan,
რა პროგრამა თქვენთვის უკვე რეალურად ამუშავება რა argc და argv არიან.
ასე რომ თქვენ არ გჭირდებათ ფიქრი, რომ.
Argc ამ ​​შემთხვევაში იქნება 3, რადგან ის ხედავს 3 განსხვავებული სიტყვა მაქს.
და ასე შემდეგ array ამ შემთხვევაში, პირველი ინდექსის იქნებოდა. / Hello,
შემდეგი ერთი დავით, შემდეგი ერთი Malan.
ვინმეს ვხედავთ დაუყოვნებლივ რა შორის ურთიერთობა argv,
array და argc არის?
Yeah. ჩვენ შეღწევას, რომ მაგალითად args.c.
მოდით ვნახოთ, თუ შევძლებთ ისარგებლოს შორის ურთიერთობა 2.
აქ თქვენ შეიძლება, რომ ელექტრო მოწყობილობების ფაილთა
გახსნას. გ ფაილები ხანდახან Emacs.
მაგრამ ჩვენ გვინდა, რომ გაუმკლავდეთ gedit, ასე რომ თქვენ შეგიძლიათ გააკეთოთ შეგიძლიათ დააწკაპუნეთ თქვენი C ფაილი,
გადადით Properties, გახსენი და შემდეგ აირჩიოს gedit, უცნობია, როგორც default,
და ახლა თქვენი პროგრამა უნდა გახსნას gedit ნაცვლად Emacs.
Perfect.
ასე რომ აქ მაქვს პროგრამა, რომელიც მინდა ამობეჭდოთ თითოეული ბრძანება ხაზი არგუმენტი.
ასე რომ რაც არ უნდა მომხმარებლის საშუალებებით, მინდა არსებითად დაბრუნება თავში მათ ახალი ხაზი.
რა არის სტრუქტურა, რომელიც ჩვენ შეგვიძლია გამოვიყენოთ, რათა iterate მეტი რაღაც -
რაღაც, რომ თქვენ ალბათ გამოიყენება თქვენი pset 1?
თუ გსურთ გავლა მითითებული რაოდენობის რამ? >> [სტუდენტი] For loop.
იყიდება loop. სწორედ. ასე რომ დავიწყოთ ამისთვის loop.
ჩვენ გვყავს ამისთვის int i = 0. მოდით უბრალოდ იწყება სტანდარტული ინიციალიზაციისას ცვლადი.
მე ვაპირებ დატოვების პირობა კომპლექტი და შემდეგ ვთქვა + +, აპირებს რამ არსებობს.
ყველა უფლება.
ასე ფიქრობდა თავში argv, თუ argv არის სიაში არგუმენტები წელს მიღებული პროგრამის
და argc არის ხმების არგუმენტებს პროგრამა,
მაშინ ეს იმას ნიშნავს, რომ argc არსებითად სიგრძეზე argv, უფლება,
რადგან არსებობს იქნება როგორც ბევრი არგუმენტები როგორც ღირებულება argc.
ასე რომ, თუ ჩვენ გვინდა iterate მეტი თითოეულ ელემენტს argv,
ჩვენ ვაპირებთ, რომ გსურთ ყოველ ჯერზე შედიხართ ცვლადი წელს argv მოცემულ ინდექსი.
რომელიც შეიძლება წარმოდგენილი ამ, არა?
ეს ცვლადი აქ წარმოადგენს კონკრეტულ სიმებიანი ამ ინსტანციის
იმიტომ რომ string მასივი - კერძოდ სიმებიანი რომ მოცემული ინდექსი.
რაც ჩვენ გვსურს რომ, ამ შემთხვევაში ჩვენ გვინდა ბეჭდვა ის, ასე ვთქვათ printf.
და ახლა argv არის ტექსტი, ასე რომ ჩვენ გვინდა, რომ დააყენა placeholder არსებობს.
ჩვენ გვინდა ახალი ხაზი უბრალოდ, რათა ის გამოიყურება კარგი.
ასე რომ აქ გვაქვს ამისთვის loop. ჩვენ არ გვაქვს მდგომარეობა ამჟამად.
ასე რომ იწყება 0, ხოლო შემდეგ ყოველ ჯერზე ის აპირებს ბეჭდვა მოცემული სიმებიანი
იმ კონკრეტულ ინდექსი მასივი.
ასე რომ, როდესაც გვინდა, შეწყვიტოს დაბეჭდვისას ელემენტების მასივი?
როდესაც ჩვენ დავამთავრე, არა? როდესაც ჩვენ მიაღწია ბოლოს მასივი.
ამიტომ, ჩვენ არ გვსურს აღემატებოდეს წარსულში სიგრძეზე მასივი,
და ჩვენ უკვე ვიცით, ჩვენ არ გვჭირდება რეალურად აქტიურად გაირკვეს, თუ რა სიგრძის argv არის
რადგანაც ეს მოცემული ჩვენთვის, და რაც რომ? Argc. სწორედ.
ასე რომ ჩვენ გვინდა, რომ ეს პროცესი argc რაოდენობის ჯერ.
მე არ ვარ სწორი დირექტორია.
ყველა უფლება.
ახლა გადავდგათ args. არარის შეცდომები, რაც საკმაოდ დიდი.
მოდით უბრალოდ აწარმოებს args.
რა არის ეს დაბრუნებას აპირებს us? უბრალოდ აპირებს ბეჭდვა უკან.
"თქვენ inputted args იქნება პროგრამაში, მე ვაპირებ მისთვის უკან თქვენ."
ასე ვთქვათ ჩვენ გვინდა ვთქვათ args შემდეგ foo ბარი.
ასე რომ მაშინ ბეჭდავს ის უკან ჩვენ. ყველა უფლება?
ასე რომ არსებობს მაგალითი იმისა, თუ როგორ შეგიძლიათ გამოიყენოთ argc და argv
იცის, რომ argc წარმოადგენს სიგრძეზე argv.
დარწმუნდით, რომ თქვენ არ ოდესმე ერთად კოლექტორები ხელმისაწვდომობის ერთი მიღმა სიგრძეზე მასივი
რადგან C აუცილებლად shout at თქვენ.
თქვენ მიიღებთ რაღაც მოუწოდა სეგმენტაცია ბრალია,
რომელიც არასოდეს არ არის გართობა, ძირითადად ამბობდა თქვენ ცდილობთ წვდომისათვის რაღაც
რომ არ არსებობს, არ ეკუთვნის თქვენ.
ასე რომ დარწმუნდით, და განსაკუთრებით ნულოვანი ინდექსირებას, ჩვენ არ გვინდა -
ისევე როგორც მაგალითად, თუ გვაქვს მასივი სიგრძე 4,
რომ მასივი ინდექსი 4 არ არსებობს, რადგან ჩვენ იწყება 0, საღამოს ნულოვანი ინდექსი.
იგი გახდება მეორე ბუნება, ისევე, როგორც ამისთვის მარყუჟების როდესაც ჩვენ იწყება 0.
ასე რომ მხოლოდ შეინარჩუნოს, რომ გონება.
თქვენ არ მინდა ოდესმე შედიხართ მაჩვენებელი მასივი რომ მიღმა თქვენი მიუწვდომელ.
ასე რომ, ჩვენ ვხედავთ, ახლა როგორ შეგვიძლია სახის ხელმისაწვდომობის
ბრძანება ხაზი არგუმენტები, რომლებიც გაიარა სისტემაში
მაგრამ როგორც ვნახეთ სიმებიანი, argv ფაქტიურად სიმებიანი მასივი.
ასე რომ, რეალურად არ არის მთელი არ არის, მაგრამ კეისრის გვინდა გაუმკლავდეთ რიცხვებით.
საბედნიეროდ, არსებობს ფუნქცია შექმნილი ჩვენთვის, რომ შეიძლება რეალურად კონვერტირება სიმებიანი რომ მთელი რიცხვი.
ასევე აქ ჩვენ არ საქმე მომხმარებლის input, სადაც ჩვენ რითაც მათ
ამისთვის შეყვანის აქ გასაღები, ამიტომ ჩვენ არ შეგვიძლია რეალურად reprompt და აცხადებენ,
"ოჰ, მომეცი კიდევ ერთი რიცხვი, ვთქვათ, თუ ის მცდარია."
მაგრამ ჩვენ მაინც უნდა შეამოწმოს კორექტული გამოყენება.
In Caesar ისინი მხოლოდ კორიდორი 1 ნომერი,
და ასე რომ მათ უხდებათ აწარმოებს. / Caesar და შემდეგ მათ აქვთ გადმოგცეთ ნომერი.
ამიტომ argc უნდა იყოს გარკვეული რაოდენობა.
რა რაოდენობის იქნებოდა, რომ იყოს, თუ ისინი უნდა გაიარონ თქვენ. / Caesar და შემდეგ გასაღები?
რა არის argc? >> [სტუდენტი] 2. >> ორი. სწორედ.
ასე, რომ თქვენ გვინდა დავრწმუნდეთ, რომ argc არის 2.
წინააღმდეგ შემთხვევაში თქვენ ძირითადად უარს აცხადებენ პროგრამის გაშვება.
მთავარ ეს ფუნქცია, რომელიც ამბობს, int, მთავარ
ასეა, მაშინ ჩვენ ყოველთვის კარგი პრაქტიკის დაბრუნების 0 დასასრულს წარმატებული პროგრამა.
ასე რომ, თუ, ვთქვათ, მათ მოგცემთ 3 ბრძანების ხაზი არგუმენტები ნაცვლად 2
ან მოგაწვდით 1, მაგალითად, მაშინ, რა თქვენ გააკეთოთ თქვენ გვინდა შევამოწმოთ რომ
და შემდეგ დაბრუნდნენ 1 ამბობდა, არა, მე ვერ გააგრძელებს ამ პროგრამის.
[სტუდენტი] არსებობს არ შეიძლება იყოს სივრცის თქვენი ტექსტი. >> შეწყალებას me?
[სტუდენტი] არსებობს არ შეიძლება იყოს სივრცის ტექსტი თქვენ ცდილობთ დაშიფვრა.
Ah!
თვალსაზრისით ტექსტი, რომ ჩვენ ვცდილობთ დაშიფვრა, რომ რეალურად მოდის მოგვიანებით
როდესაც ვაძლევთ, რომ ტექსტში.
ასე რომ ახლა ჩვენ უბრალოდ მიღების ბრძანება არგუმენტები რეალურ რაოდენობასთან,
ფაქტობრივი Shift for Caesar კოდირებით.
[სტუდენტი] რატომ გჭირდებათ 2 ნაცვლად მხოლოდ 1 argc? იქ აუცილებლად 1 ნომერი.
მარჯვენა. მიზეზი, რის გამოც ჩვენ გვჭირდება 2 ამისთვის argc ნაცვლად 1
არის, რადგან, როდესაც თქვენ აწარმოებს პროგრამის და ამბობენ. / Caesar ან. / Hello,
რომ რეალურად ითვლის როგორც ბრძანების არგუმენტი.
ასე რომ მაშინ ეს უკვე იღებს up 1 და ა.შ. მაშინ ჩვენ შესაყვანი 1 დამატებითი.
ასე რომ თქვენ შესაყვანი რეალურად string in command line არგუმენტი.
რა გსურთ, ამისთვის Caesar გვინდა გაუმკლავდეთ მთელ რიცხვს,
ასე რომ თქვენ შეგიძლიათ გამოიყენოთ ეს atoi ფუნქცია.
და ძირითადად, თქვენ გაივლით მას სიმებიანი და მერე დაბრუნდება თქვენი დაბრუნება მთელი რიცხვი
თუ ეს შესაძლებელია, რათა რომ სიმებიანი შევიდა რიცხვი.
ახლა გახსოვთ, როდესაც ჩვენ საქმე printf ან GetString, რამ, როგორიცაა, რომ
ჩვენ მოიცავს ბიბლიოთეკების, რომლებიც კონკრეტული ჩვენთვის.
ამიტომ დასაწყისში ჩვენ დავიწყებთ hash tag სტანდარტული I / O,. თ, რაღაც რომ.
ისე, atoi არ შედის ერთი იმ ბიბლიოთეკების,
ამიტომ, რაც ჩვენ უნდა გავაკეთოთ არის ჩვენ უნდა შეიცავდეს უფლება ბიბლიოთეკა, რომ.
ასე რომ გავიხსენოთ თავში Walkthrough 1 სადაც მე განიხილეს სახელმძღვანელოს ფუნქციას.
თქვენ ტიპი კაცი თქვენს ტერმინალი და მოყვება სახელით ფუნქციონირებს.
და ისე, რომ გამოიტანს მთელ სიას მისი გამოყენება,
არამედ იგი გამოიტანს, რომელიც ბიბლიოთეკაში რომ ეკუთვნის.
ასე რომ დავტოვებთ, რომ თქვენ გამოიყენოთ სახელმძღვანელო ფუნქციის atoi
და გაერკვნენ, რომელიც ბიბლიოთეკაში თქვენ უნდა შეიცავდეს რომ შეძლოთ atoi ფუნქცია.
ამიტომ, ჩვენ მივიღეთ გასაღები და ახლა საქმე მიღების ძირითადი ტექსტი,
და ისე, რომ რეალურად იქნება მომხმარებლის შეყვანის სადაც თქვენ ზოლზე.
ჩვენ შეეხო GetInt და GetFloat და ა.შ. ამავე ვენების
ჩვენ ვაპირებთ იყოს საქმე GetString.
მაგრამ ამ შემთხვევაში ჩვენ არ გვჭირდება რაიმე do ხოლო ან ხოლო მარყუჟების, რათა შეამოწმოს.
GetString აუცილებლად მოგვცემს სიმებიანი,
და ჩვენ ვაპირებთ დაშიფვრა რასაც მომხმარებლის გვაძლევს.
ასე, რომ თქვენ შეიძლება ვივარაუდოთ, რომ ყველა ეს მომხმარებლის inputted სიმები სწორია.
დიდი.
ასე რომ მაშინ კიდევ თქვენ მოხვდით გასაღები და ერთხელ თქვენ მოხვდით ტექსტი,
ახლა რა არის დაუტოვებიათ თქვენ უნდა encipher plaintext.
უბრალოდ სწრაფად დაფარავს მეტი lingo, plaintext არის ის, რაც მომხმარებლის გაძლევთ,
და ciphertext არის ის, რაც თქვენ დაბრუნდება მათ.
ასე რომ სიმები, რათა მათ შეძლონ გავლა ფაქტობრივად წერილი წერილი
იმიტომ რომ ჩვენ გვაქვს გადაეტანა ყველა წერილი,
ჩვენ გვესმის, რომ სიმები, თუ ჩვენ სახის კანი უკან ფენა,
ჩვენ ვხედავთ, რომ ისინი უბრალოდ ნამდვილად სიაში სიმბოლო.
ერთი უძღოდა სხვა.
ასე რომ, ჩვენ შეიძლება მკურნალობა სიმები როგორც კოლექტორები რადგან ისინი კოლექტორები პერსონაჟების.
ასე რომ ვთქვათ, თქვენ გაქვთ სიმებიანი დასახელებული ტექსტი,
და შიგნით რომ ცვლადი ტექსტი ინახება ეს არის CS50.
შემდეგ ტექსტის ინდექსი 0 იქნებოდა კაპიტალის T, ინდექსი 1 იქნებოდა თ და ა.შ.
შემდეგ კი მასივები, წელს argc მაგალითად args.c,
ჩვენ ვნახეთ, რომ მოგვიწია iterate მეტი მასივი
და ასე მოგვიწია iterate საწყისი i = 0 წლამდე მე ნაკლებია, ვიდრე სიგრძე.
ამიტომ ჩვენ გვჭირდება გარკვეული გზა მჭიდროდაა რა სიგრძე ჩვენი სტრიქონს
თუ ჩვენ ვაპირებთ iterate მას.
საბედნიეროდ კვლავ არსებობს ფუნქცია არსებობს ჩვენთვის, თუმცა მოგვიანებით in CS50
თქვენ აუცილებლად უნდა შეეძლოს განახორციელოს და საკუთარი ფუნქცია
რომელსაც შეუძლია გამოთვალოს სიგრძეზე სიმებიანი.
მაგრამ ახლა ჩვენ ვაპირებთ გამოვიყენოთ სიმებიანი სიგრძე, ასე strlen.
თქვენ კორიდორი სიმებიანი და შემდეგ იგი დაბრუნდება თქვენ int, რომელიც წარმოადგენს სიგრძე თქვენი სიმებიანი.
მოდით შევხედოთ მაგალითს, თუ როგორ ჩვენ შესაძლოა iterate აღემატება თითოეული პერსონაჟი სიმებიანი
და რაღაც რომ.
რაც ჩვენ გვსურს რომ არის iterate აღემატება თითოეული ხასიათი სიმებიანი,
და რაც ჩვენ გვსურს რომ არის ჩვენ ბეჭდვა უკან თითოეული ხასიათი 1 by 1
გარდა დავუმატებთ რაღაცას შემდეგი მას.
ასე რომ დავიწყოთ ამისთვის loop. Int i = 0.
ჩვენ ვაპირებთ დატოვონ ფართი მდგომარეობა.
ჩვენ გვინდა iterate სანამ მივაღწევთ ბოლოს სიმებიანი, არა?
ასეა, მაშინ რა ფუნქცია გვაძლევს სიგრძეზე სიმებიანი?
[Inaudible სტუდენტი საპასუხოდ]
სწორედ სიგრძეზე command line არგუმენტები.
მაგრამ string გვინდა გამოვიყენოთ ფუნქცია გვაძლევს სიგრძეზე სიმებიანი.
ასე რომ სიმებიანი სიგრძე.
და ასე შემდეგ თქვენ უნდა გაიაროს in string მას.
მან უნდა იცოდეს, თუ რა სიმებიანი სჭირდება გამოთვლა სიგრძეზე.
ასეა, მაშინ ამ შემთხვევაში ჩვენ საქმე გვაქვს string s.
დიდი.
ასე შემდეგ, რაც ჩვენ გვსურს რომ, მოდით printf.
ახლა ჩვენ გვინდა გაუმკლავდეთ სიმბოლო. ჩვენ გვინდა, რომ ამობეჭდოთ თითოეული ხასიათი.
როდესაც გნებავთ ამობეჭდოთ float, თქვენ გამოიყენოთ placeholder მოსწონს% ვ.
ერთად int გსურთ გამოიყენოთ% d.
და ა.შ. ანალოგიურად, ერთად ხასიათი თქვენ იყენებთ% C ვთქვა მე ვაპირებ იყოს დაბეჭდვის ხასიათი
რომ ინახება შიგნით ცვლადი.
ამიტომ ამ და მოდით დაამატოთ პერიოდში და სივრცეში მას.
რომელ ხასიათის ჩვენ გამოყენებით?
ჩვენ ვაპირებთ იყოს გამოყენებით რასაც ხასიათი ჩვენ დროს საქართველოს სიმებიანი.
ასე რომ მაშინ ჩვენ ვაპირებთ იყოს გამოყენებით რაღაც ერთად სიმებიანი,
მაგრამ ჩვენ გვინდა ვიყოთ წვდომის გარკვეული ხასიათი არსებობს.
ასე რომ, თუ სიმებიანი მხოლოდ მასივი, მაშინ როგორ უნდა თქვათ ელემენტების მასივი?
ჩვენ გვყავს იმ კვადრატულ ფრჩხილებში, ხოლო შემდეგ ჩვენ ინდექსი არსებობს.
ამიტომ კვადრატულ ფრჩხილებში. ჩვენი ინდექსი ამ შემთხვევაში შეგვიძლია მხოლოდ გამოიყენოს მე. სწორედ.
ასე რომ აქ ჩვენ ვამბობთ, რომ ჩვენ უნდა დაბეჭდვის ხასიათი მოსდევს dot და სივრცე,
და რომ ხასიათის იქნება შ წერილში ჩვენს string s.
მე უბრალოდ აპირებს გადარჩენა რომ. Okay.
ახლა მე ვაპირებ აწარმოებს სიმებიანი სიგრძე.
ამიტომ ჩვენ გვქონდა სიმებიანი მოუწოდა OMG, და ახლა კი ხაზგასმით აღნიშნა, კიდევ უფრო.
ანალოგიურად, ვთქვათ ჩვენ რეალურად გვინდა string საწყისი მომხმარებელს.
როგორ შეიძლება გავაკეთოთ ეს?
მანამდე, თუ როგორ მივიღეთ სამაგიეროდ int?
ჩვენ ვთქვით GetInt, არა? მაგრამ ეს არ არის int, მოდით GetString.
ჩვენ გადავდგათ სიმებიანი სიგრძე. აქ ჩვენ არ შევიდა კონკრეტულ ზოლზე.
ასე რომ არ ვიცი.
მე ვაპირებ რომ ჩემი სახელი აქ და ასე შემდეგ შემიძლია ერთი იმ რამ
სადაც მე დაავალოს სიტყვა ყველა წერილი ან რამე მაგდაგვარს. ზემოთ.
ასე რომ სიმებიანი სიგრძე.
ასე რომ ჩვენ თავში Caesar.
ჩვენ გვყავს რამდენიმე ინსტრუმენტის როგორ iterate მეტი ტექსტი,
როგორ შედიხართ თითოეული ელემენტს.
ახლა შეგვიძლია დავუბრუნდეთ პროგრამა.
როგორც აღვნიშნე ადრე, წელს ASCII მაგიდასთან, თქვენი საუკეთესო მეგობარი,
თქვენ ვაპირებთ ვხედავ ციფრები, რომლებიც ასოცირდება ყოველ წერილში.
ასე ამბობენ ჩვენი plaintext არის მე თავბრუსხვევას?
მაშინ თითოეული ეს გმირები აპირებს აქვს ნომერი და ASCII ასოცირებული მნიშვნელობა მას,
კი აპოსტროფი, თუნდაც სივრცეში, თუნდაც ძახილის ნიშნის,
ასე რომ თქვენ სურს, რომ გონება.
ასე ვთქვათ, ჩვენი გასაღები, რომ მომხმარებლის შედის მათი ბრძანება ხაზი არგუმენტი 6.
ეს იმას ნიშნავს, რომ პირველი წერილი, რომელიც მე, რომელიც წარმოდგენილია 73,
გსურთ დაბრუნებას მათ რასაც წერილში წარმოდგენილია ASCII ღირებულების 73 + 6.
ამ შემთხვევაში იქნებოდა 79.
ახლა ჩვენ გვინდა წასვლა შემდეგი ხასიათი.
ასე რომ მომდევნო ინდექსი 1 plaintext იქნებოდა აპოსტროფი.
მაგრამ გვახსოვდეს, ჩვენ მხოლოდ გვინდა encipher წერილებს.
ამიტომ, ჩვენ გვინდა დავრწმუნდეთ, რომ აპოსტროფი რეალურად რჩება იგივე,
რომ ჩვენ არ შეიცვლება 39 დან რასაც 45 არის.
ჩვენ გვინდა, რომ შევინარჩუნოთ ის, როგორც აპოსტროფი.
ასე რომ ჩვენ გვინდა მახსოვს მხოლოდ encipher წერილების
იმიტომ, რომ ჩვენ გვინდა ყველა სხვა სიმბოლიკის დარჩეს უცვლელი ჩვენი პროგრამა.
სხვა საქმეა, რომ ჩვენ გვინდა არის შეინარჩუნოს კაპიტალიზაცია.
ასე რომ, როდესაც თქვენ გაქვთ ზედა წერილი, უნდა დარჩნენ როგორც ზედა.
Lowercases უნდა დარჩნენ როგორც ამას.
ასე რომ ზოგიერთი სასარგებლო ფუნქციები შეძლებს გაუმკლავდეს მხოლოდ enciphering წერილების
შენარჩუნებას და შენარჩუნების კაპიტალიზაცია რამ
არის isalpha, isupper, islower ფუნქციები.
და ა.შ. ეს ფუნქციები, რომ დაბრუნებას თქვენ ლოგიკური მნიშვნელობა.
ძირითადად, ჭეშმარიტი ან მცდარი. ეს ზედა? ეს ალფანუმერული?
არის თუ არა ეს წერილი, არსებითად.
ასე რომ აქ არის 3 მაგალითები, როგორ გამოიყენოს რომ ფუნქცია.
ძირითადად, თქვენ შეიძლება შეამოწმოთ თუ არა ღირებულების დაბრუნდა თქვენ მიერ რომ ფუნქცია მართალია ან ყალბი
დაყრდნობით, რომ შეყვანის.
ან არ encipher რაღაც ან cipher თუ დარწმუნდით, რომ ზედა და ა.შ.
[სტუდენტი] შეგიძლიათ უბრალოდ ავუხსნათ იმ ცოტა მეტი და როგორ გამოვიყენოთ ისინი? >> ჰო, ნამდვილად.
ასე რომ, თუ ჩვენ ვიხსენებთ, აქ გვაქვს დედაქალაქში მე, არა?
ასე რომ, ჩვენ ვიცით, რომ მე ღებულობენ O რადგან მე + 6 არის ო
მაგრამ ჩვენ გვინდა დავრწმუნდეთ, რომ O იქნება კაპიტალის ო
ასე რომ, ძირითადად, რაც სახის შეიცვლება ჩვენი დასტური.
ასე რომ თუ არა ეს ზედა თუ არა სახის შეცვლის გზა, რომ ჩვენ გაუმკლავდეთ მას.
ასე რომ თუ ჩვენ ვიყენებთ isupper ფუნქციის კონკრეტულ ინდექსი,
ასე isupper ("მე"), რომ ბრუნდება ჩვენთვის ჭეშმარიტი, ამიტომ ჩვენ ვიცით, რომ ეს ზედა.
ასე რომ მაშინ დაყრდნობით, მოგვიანებით ჩვენ წასვლას ფორმულა
რომ თქვენ გამოიყენებთ გადაეტანა რამ კეისარი
ასეა, მაშინ ძირითადად, იქ იქნება ოდნავ განსხვავებული ფორმულა, თუ ის ზედა
როგორც ეწინააღმდეგებოდა ამას. აზრი?
Yeah. არარის შეშფოთება.
ვესაუბრე bit შესახებ დასძინა 6 დან წერილში, რომელიც არ საკმაოდ აზრი
გარდა, როდესაც ჩვენ სახის გვესმოდეს, რომ ამ სიმბოლოებს
არიან სახის ურთიერთშემცვლელნი ერთად რიცხვებით.
რას ვაკეთებთ ჩვენ სახის გამოყენების დაფარული გააპროტესტეს.
ჩვენ წასვლას კასტინგის ცოტა მოგვიანებით, სადაც თქვენ მიიღოს ღირებულება და აქციოს იგი სხვადასხვა ტიპის
ვიდრე ეს თავდაპირველად იყო.
მაგრამ ამ pset ჩვენ შევძლებთ სახის interchangeably გამოიყენოთ სიმბოლოების
და მათი შესაბამისი რიცხვი ღირებულებებს.
ასე რომ, თუ თქვენ უბრალოდ encase ხასიათი მხოლოდ ერთჯერადი შეთავაზებები,
მაშინ შევძლებთ ვიმუშაოთ ერთად მთელი რიცხვები, რომლებიც ეხება მას, როგორც მთელი რიცხვი.
ამიტომ კაპიტალის C ეხება 67. მხედრულ F ეხება 102.
ისევ და ისევ, თუ გვინდა ვიცოდეთ, ამ ღირებულებების, შევხედოთ თქვენი ASCII მაგიდასთან.
მოდით წასვლას მაგალითები თქვენ შესაძლოა სხვაობა და დაამატოთ,
როგორ შეიძლება რეალურად მართლაც მუშაობა ამ პერსონაჟების, გამოიყენონ მათ interchangeably.
მე ვიტყვი, რომ ASCIIMath აპირებს გამოთვლა დამატებით ხასიათის მთელი რიცხვი
და შემდეგ აჩვენებს resultant ხასიათი ასევე resultant ASCII ღირებულების.
და ა.შ. აქ მე ვამბობ, - we'll გაუმკლავდეთ ამ ნაწილს მოგვიანებით -
მაგრამ ძირითადად, მე ვამბობ, რომ მომხმარებელმა უნდა ვთქვა აწარმოებს ASCIIMath ერთად გასაღები,
და მე ვამბობ, რომ გასაღები იქნება ნომერი
რომელთანაც ჩვენ ვაპირებთ დაამატოთ ეს ხასიათი.
ასე რომ აქ რომ რადგან მე მოთხოვნით გასაღები,
რადგან მე მოითხოვს ისინი მაძლევს 1 რამ,
მე მხოლოდ მინდა, რომ მიიღოს. / Asciimath და გასაღები.
ამიტომ მე ვაპირებ მოითხოვოს, რომ argc უდრის 2.
თუ ეს არა, მაშინ მე ვაპირებ დაბრუნებას 1 და პროგრამა გაითიშება.
ამიტომ მე ვამბობ, გასაღები არ აპირებს იყოს პირველი ბრძანება ხაზი არგუმენტი,
ეს იქნება მეორე, და როგორც ხედავთ აქ,
მე ვაპირებ, რომ ჩართოთ შევიდა რიცხვი.
მაშინ მე ვაპირებ მითითებული ხასიათის იყოს r.
გაითვალისწინეთ, რომ ტიპის ცვლადი Chr ფაქტიურად მთელი რიცხვი.
ისე, რომ მე ვარ ისარგებლებენ r როგორც მთელი რიცხვი არის encasing იგი ამ ერთჯერადი შეთავაზებები.
ასე რომ თავში ჩვენი printf განცხადება, სადაც ჩვენ გვაქვს placeholder for ხასიათი
და შემდეგ placeholder for რიცხვი,
ხასიათი წარმოდგენილია Chr, და მთელი რიცხვი არის გასაღები.
და ასე შემდეგ ჩვენ ვაპირებთ შედეგად დაამატოთ 2 ერთად.
ამიტომ, ჩვენ ვაპირებთ დაამატოთ R + რასაც გასაღები არის,
და მაშინ ჩვენ ვაპირებთ ბეჭდვა შედეგად რომ.
მოდით მიიღოს asciimath. ეს დღემდე, მოდით უბრალოდ აწარმოებს asciimath.
ოჰ, მაგრამ ვხედავ, ის არაფერს აკეთებს, რადგან ჩვენ არ რეალურად მისცეს მას გასაღები.
ასე რომ, როდესაც ის უბრალოდ დაბრუნდა 1, ჩვენი მთავარი ფუნქცია, უბრალოდ დაბრუნდა us.
ასე რომ მაშინ მოდით კორიდორი გასაღები. ვიღაცამ მომეცი ნომერი. >> [სტუდენტი] 4.
4. Okay.
ამიტომ R გაიზარდა 4 აპირებს მოგვცეს V, რაც შეესაბამება ASCII ღირებულება 118.
ასე რომ მაშინ სახის აზრი, რომ -
სინამდვილეში, შემიძლია გთხოვოთ, როგორ ფიქრობთ ASCII ღირებულების r არის თუ R + 4 არის 118?
მაშინ ჰო, r არის 114.
ასე რომ, თუ გადავხედავთ წლის ASCII მაგიდასთან შემდეგ, დარწმუნებული საკმარისი, თქვენ ნახავთ, რომ r წარმოდგენილია 114.
ახლა, რომ ჩვენ ვიცით, რომ ჩვენ შეგვიძლია დაამატოთ რიცხვებით უნდა გმირები, ეს როგორც ჩანს საკმაოდ მარტივია.
ჩვენ უბრალოდ აპირებს iterate მეტი სიმებიანი მოსწონს ვნახეთ მაგალითად ადრე.
ჩვენ შეამოწმოთ, თუ ის წერილი.
თუ ეს, მაშინ ჩვენ გადაეტანა იგი ნებისმიერი გასაღები არის.
Pretty მარტივი, როდესაც თქვენ მიიღებთ like this,
ხედავთ, რომ Z, წარმოდგენილი 122, მაშინ მისცემს თქვენ სხვადასხვა ხასიათის.
ჩვენ ნამდვილად გინდათ დარჩენა ფარგლებში ჩვენი ანბანი, არა?
ამიტომ, ჩვენ უნდა გაერკვნენ რამდენიმე გზა სახის შესაფუთი გარშემო.
როდესაც თქვენ მივაღწიოთ Zed და გსურთ იზრდება გარკვეული რაოდენობა,
თქვენ არ გსურთ შეხვიდეთ მიღმა ASCII ანბანი მონაკვეთზე;
გსურთ გადაიტანოთ უკან ყველა გზა ა
მაგრამ გახსოვდეთ, თქვენ კვლავ შენარჩუნების შემთხვევაში.
ასე იცის, რომ წერილებს ვერ გახდება სიმბოლიკა
ისევე, როგორც სიმბოლიკა არ ვაპირებთ შეცვლაა ისევე.
უკანასკნელ pset თქვენ აუცილებლად არ უნდა,
მაგრამ ალტერნატივა არ განახორციელოს თქვენი ხარბ pset გამოყენებით modulus ფუნქცია.
მაგრამ ახლა ჩვენ რეალურად აპირებს უნდა გამოვიყენოთ modulus,
მოდით უბრალოდ ამ ცოტა.
არსებითად, როდესაც თქვენ x modulo Y, რომ გაძლევთ დარჩენილი x დაყოფილი წ.
აქ არის რამოდენიმე მაგალითები აქ. ჩვენ გვყავს 27% 15.
ძირითადად, როცა სხვაობა 15 დან 27 როგორც მრავალჯერ შესაძლებელია მიღების გარეშე უარყოფითი
მაშინ თქვენ მიიღებთ 12 დარჩენილი.
ასე რომ სახის მსგავსად მათემატიკის კონტექსტში, მაგრამ როგორ შეგვიძლია რეალურად გამოიყენოს ეს?
ეს იქნება სასარგებლო ჩვენი wrapover.
ამისათვის მოდით უბრალოდ, ვამბობთ მე გთხოვეთ ყველა გაყავით შევიდა 3 ჯგუფად.
ზოგჯერ ხაზვის ჯგუფებში და რამე მაგდაგვარს.
ამბობენ მე ვუთხარი, "Okay, მინდა ყველას დაიყოს 3."
როგორ შეიძლება თქვენ ეს?
[Inaudible სტუდენტი საპასუხოდ] ჰო, ზუსტად. გრაფი off. Okay.
მოდით რეალურად გაგვაჩნია. გსურთ დაიწყოს?
[სტუდენტი დათვლის off] 1, 2, 3, 4.
მაგრამ გვახსოვდეს, ... >> [სტუდენტი] ოჰ, უკაცრავად.
სწორედ კარგი წერტილი.
თქვენ თქვით, 4, მაგრამ ჩვენ რეალურად მინდა ვთქვა 1 რადგან ჩვენ მხოლოდ გვინდა 3 ჯგუფად.
ასე შემდეგ, როგორ - არა, რომ მართლაც კარგი მაგალითი, რადგან მაშინ როგორ შეიძლება თქვათ 1?
რა არის შორის ურთიერთობა 4 და 1?
ისე, 4 mod 3 არის 1.
ასე თუ გააგრძელებთ, თქვენ იქნებოდა 2.
ასე რომ, ჩვენ გვაქვს 1, 2, 3, 1, 2.
ერთხელ, თქვენ რეალურად მე -5 პირი. იცით ვთქვა 2 ნაცვლად 5?
თქვენ ამბობთ 5 mod 3 არის 2.
მინდა დაინახოს რამდენი ჯგუფების 3 დარჩა მეტი, მაშინ რომელიც იმისათვის am ი
და ასე შემდეგ, თუ ჩვენ განაგრძო გასწვრივ მთელი ოთახი,
მაშინ ჩვენ ვხედავთ, რომ ჩვენ ყოველთვის რეალურად გამოყენებით mod ფუნქციის საკუთარ თავს
to სახის ითვლიან off.
სწორედ მეტი სახის მატერიალური მაგალითია, თუ როგორ შეიძლება გამოვიყენოთ modulo
რადგან დარწმუნებული ვარ, ყველაზე მეტად ჩვენს ალბათ გაიარა, რომ პროცესი
სადაც ჩვენ გვქონდა დათვლა off.
ნებისმიერი შეკითხვა modulo?
ეს იქნება საკმაოდ მნიშვნელოვანია იმის გაგება, კონცეფციები ამ,
ამიტომ მინდა დარწმუნდით ბიჭებს ესმით.
[სტუდენტი] თუ არ არის დარჩენილი, იგი მოგცემთ რეალურ რაოდენობასთან?
თუ ერთერთი პირველი 3 მათგანი გაკეთებული რომ, რომ მას არ მიეცეს მათ, რაც მათ რეალურად იყო,
ან უნდა მისცეს მათ [inaudible] >> სწორედ კარგი კითხვაა.
როდესაც არ არსებობს დარჩენილი ამისთვის modulo - ასე ამბობენ გაქვთ 6 mod 3 -
რომ რეალურად იძლევა თქვენი დაბრუნება 0.
ჩვენ ვსაუბრობთ, რომ მოგვიანებით.
Oh yeah, მაგალითად, მე -3 პირი - 3 mod 3 ფაქტიურად 0, მაგრამ მან განაცხადა, 3.
ასე რომ სახის მოსწონს შიდა დაჭერა, მაგალითად,
მოსწონს okay, თუ mod არის 0 მერე მე ვაპირებ იყოს მე -3 პირი.
მაგრამ ჩვენ შეღწევას სახის როგორ ჩვენ დაგვჭირდება გაუმკლავდეთ რა არის 0 მოგვიანებით.
ახლა ჩვენ როგორღაც აქვს გზა ობიექტების Zed მარჯვნივ წერილში.
ახლა ჩვენ გავიარეთ ეს მაგალითები,
ჩვენ სახის ვხედავ როგორ Caesar შესაძლოა მუშაობა.
ხედავთ 2 დამწერლობას და შემდეგ ხედავთ მათ დაიკავეს.
მოდით ვეცადოთ და გამოხატოს, რომ თვალსაზრისით ფორმულა.
ეს ფორმულა ფაქტობრივად გასულ თქვენს Spec,
მაგრამ მოდით სახის გადავხედავთ რა თითოეული ცვლადი ნიშნავს.
ჩვენი საბოლოო ჯამში იქნება ciphertext.
ასე რომ, ეს ნათქვამია, რომ შ ხასიათი ciphertext
აპირებს შეესაბამება შ ხასიათი plaintext.
რომ აზრი იმიტომ, რომ ჩვენ გვინდა ყოველთვის დოლომიტ ეს ყველაფერი მდე.
ასე რომ, ეს იქნება შ ხასიათი ciphertext Plus K, რომელიც ჩვენი გასაღები -
რომ აზრი - და შემდეგ ჩვენ გვაქვს ამ mod 26.
დამახსოვრება უკან, როდესაც ჩვენ გვქონდა Zed
ჩვენ არ გვინდოდა შეღწევას ხასიათი, ამიტომ გვინდოდა mod ეს
და სახის შემაჯამებელი გარშემო ანბანი.
შემდეგ Zed თქვენ წავიდოდა, B, C, D, სანამ შენ მარჯვნივ ნომერი.
ასე რომ, ჩვენ ვიცით, რომ Zed, თუ + 6, რომ მოგვცეს ვ რადგან შემდეგ Zed მოდის, B, C, D, E, F.
ასე რომ გავიხსენოთ, ჩვენ ვიცით, რომ Zed + 6 აპირებს მოგვცეს ვ.
In ASCII ღირებულებები, z არის 122 და F არის 102.
ამიტომ, ჩვენ უნდა მოვძებნოთ რაღაც გზა, რომ ჩვენი Caesar ფორმულა მოგვცეს 102
მიღების შემდეგ წელს 122.
ასე რომ, თუ ჩვენ მხოლოდ გამოიყენოს ეს ფორმულა, ('z' + 6)% 26, რომ რეალურად გაძლევთ 24
რადგან 122 + 6 არის 128, 128% 26 გაძლევთ 24 დარჩენილი.
მაგრამ ეს არ ნიშნავს, ნამდვილად ვ. სწორედ ნამდვილად არ 102.
სწორედ ასევე არ -6 ასო ანბანი.
ამიტომ ბუნებრივია, ჩვენ გვჭირდება გარკვეული გზა tweaking ეს ცოტა.
თვალსაზრისით რეგულარული ანბანი, ჩვენ ვიცით, რომ Z არის 26 წერილი და F არის მე -6.
მაგრამ ჩვენ კომპიუტერულ მეცნიერებაში, ამიტომ ჩვენ ვაპირებთ ინდექსი at 0.
ასეა, მაშინ ნაცვლად z მყოფი ნომერი 26, ჩვენ ვაპირებთ რომ ვთქვათ ნომერი 25
რადგან არის 0.
ახლა მოდით გამოიყენოს ეს ფორმულა.
ჩვენ გვყავს z წარმოდგენილია 25 + 6, რომელიც გაძლევთ 31.
და 31 mod 26 გაძლევთ 5 როგორც ნაშთი.
სწორედ სრულყოფილი, რადგან ჩვენ ვიცით, რომ F არის მე -5 ასო ანბანი.
მაგრამ ეს ჯერ კიდევ არ არის F, არა? ეს ჯერ კიდევ არ არის 102.
ასეა, მაშინ ამ pset, გამოწვევა იქნება ცდილობს გასარკვევად ურთიერთობისათვის
შორის კონვერტირებას შორის ASCII ღირებულებები და ანბანური ინდექსი.
არსებითად, რა თქვენ გსურთ, თქვენ გინდათ რომ დაიწყოს ერთად ASCII ღირებულებების,
მაგრამ შემდეგ გსურთ როგორღაც თარგმნოს რომ შევიდა ანბანური ინდექსი
მაშინ გამოთვლა რა წერილი უნდა იყოს - ძირითადად, რა მისი ანბანური ინდექსი არის
საქართველოს cipher ხასიათი - მაშინ თარგმნოს, რომ თავში ASCII ღირებულებებს.
ასე რომ, თუ თქვენ Whip out თქვენი ASCII მაგიდასთან, მაშინ ცადეთ და იპოვოთ ურთიერთობებს, ვთქვათ, 102 და 5
ან 122 და 25.
ჩვენ მიღებული ჩვენი გასაღები საწყისი ბრძანებათა სტრიქონიდან არგუმენტები, ჩვენ მიღებული plaintext,
ჩვენ enciphered იგი.
ახლა ყველა ჩვენ არ დაუტოვებიათ გააკეთოთ დაბეჭდეთ.
ჩვენ შეგვეძლო ამის გაკეთება რამდენიმე განსხვავებული გზები.
რაც ჩვენ შეეძლო რეალურად ბეჭდვა, როგორც ჩვენ წავიდეთ ერთად.
როგორც ჩვენ iterate მეტი სიმბოლოების ტექსტი,
ჩვენ უბრალოდ უბრალოდ ბეჭდვა უფლება მაშინ, როდესაც ჩვენ გამოვთვალოთ იგი.
გარდა ამისა, თქვენ შეიძლება ასევე ჩაწეროთ იგი array და აქვს მასივი გმირები
და ბოლოს iterate მეტი რომ მთელი მასივი და ამობეჭდოთ.
ასე რომ თქვენ არ რამდენიმე ვარიანტს, რომ.
და მახსოვს, რომ% C იქნება placeholder დასაბეჭდად ხასიათი.
ასე რომ ჩვენ გვაქვს Caesar, და ახლა ჩვენ გადაადგილება, რათა Vigenere,
რომელიც ძალიან გავს Caesar მაგრამ ოდნავ უფრო რთული.
ამიტომ არსებითად ერთად Vigenere არის თქვენ უნდა გადადის სიტყვით.
ასე რომ ნაცვლად ნომერი, თქვენ აპირებს აქვს ტექსტი,
და ისე, რომ აპირებს იმოქმედოს, როგორც თქვენი სიტყვით.
მაშინ, როგორც ყოველთვის, თქვენ აპირებს მიიღოს სწრაფი ამისთვის string საწყისი მომხმარებლის
და შემდეგ encipher და მერე მივცეთ ciphertext უკან.
ასე რომ, როგორც ვთქვი, ეს ძალიან ჰგავს Caesar, გარდა ნაცვლად გადავიდა მიერ გარკვეული რაოდენობა,
პუნქტების რეალურად შეიცვლება ყველა დროის ხასიათის ხასიათი.
წარმოდგენა, რომ რეალურ რაოდენობასთან გადაეტანა, ის წარმოდგენილია კლავიატურის ასოები.
ასე რომ, თუ თქვენ შევა ცვლის, მაგალითად, მაშინ, რომ შეესაბამება ცვლის 0.
ასე რომ კიდევ ერთხელ თავში ანბანური ინდექსი.
რა შეიძლება იყოს სასარგებლო თუ თქვენ ხედავს, რომ ჩვენ რეალურად საქმე ASCII ღირებულებები
ისევე როგორც წერილებს, ასევე ანბანური ინდექსი,
იქნებ მოძებნის ან საკუთარი ASCII მაგიდასთან, რომელიც აჩვენებს ანბანური ინდექსი 0 მეშვეობით 25,
მეშვეობით z, და ASCII ღირებულებებს ისე, რომ თქვენ შეიძლება სახის ვხედავ ურთიერთობისათვის
და ესკიზის გარეთ და ცდილობენ და გამოძებნოს შაბლონებს.
ანალოგიურად, თუ თქვენ გადასვლის დროს გარკვეული ინსტანციის მიერ ვ -
და ეს არის ან ამას ან ზედა F - მაშინ რომ შეესაბამება 5.
ჩვენ კარგი აქამდე?
ფორმულა Vigenere ოდნავ განსხვავებული.
ძირითადად, ხედავთ, რომ ისევე, როგორც კეისარი
გარდა ნაცვლად მხოლოდ K გვაქვს K ინდექსი კ.
გაითვალისწინეთ, რომ ჩვენ არ იყენებს მე რადგან არსებითად, სიგრძით სიტყვით
არ არის აუცილებლად სიგრძე ჩვენი ciphertext.
ეს იქნება ცოტა ნათელი, როდესაც ჩვენ დავინახავთ, რომ მაგალითად მე ცოტა მოგვიანებით.
ძირითადად, თუ თქვენ აწარმოებს თქვენი პროგრამის სიტყვით of ohai,
მაშინ ეს იმას ნიშნავს, რომ ყოველ ჯერზე, ohai იქნება თქვენი ცვლა.
ასე რომ დამოკიდებულია რა პოზიცია, თქვენი სიტყვით,
თქვენ აპირებს გადაეტანა თქვენი გარკვეული ciphertext ხასიათი რომ თანხა.
ისევ, ისევე, როგორც კეისრის, ჩვენ გვინდა დავრწმუნდეთ, რომ ჩვენ შევინარჩუნოთ კაპიტალიზაცია რამ
და ჩვენ მხოლოდ encipher წერილებს, არ გმირები ან სივრცეებს.
ასე გამოიყურება თავში Caesar on ფუნქციებს, რომ თქვენ შეიძლება არ გამოიყენება,
ისე, რომ თქვენ გადაწყვიტეთ როგორ გადაეტანა ნივთები, და ვრცელდება, რომ თქვენი პროგრამა აქ.
მოდით სამოქმედო გეგმა გარეთ.
ჩვენ გვყავს plaintext რომ ჩვენ მიღებული საწყისი მომხმარებლისთვის GetString
ამბობდა, ეს ... არის CS50!
მაშინ ჩვენ გვაქვს სიტყვით of ohai.
პირველი 4 სიმბოლოები საკმაოდ მარტივია.
ჩვენ ვიცით, რომ T აპირებს გადაინაცვლებს მიერ o,
მაშინ თ აპირებს გადაინაცვლებს მიერ H, I აპირებს გადაინაცვლებს მიერ.
აქ თქვენ ხედავთ, რომ წარმოადგენს 0,
ასეა, მაშინ ბოლომდე ღირებულება რეალურად მხოლოდ იმავე წერილში, როგორც ადრე.
მაშინ ჯერ არის გადაინაცვლებს ი.
მაგრამ მაშინ თქვენ ამ პერიოდებში აქ.
ჩვენ არ გვინდა, რომ encipher, ასეა, მაშინ ჩვენ არ შეცვლის მას არაფერი
და უბრალოდ ამობეჭდოთ პერიოდში უცვლელი.
[სტუდენტი] მე არ მესმის, როგორ თქვენ იცით, რომ ეს არის გადაინაცვლებს მიერ - სად - >> ოჰ, უკაცრავად.
ზედა აქ ხედავთ, რომ ბრძანება ხაზი არგუმენტი ohai აქ,
რომ იქნება სიტყვით.
და ა.შ. ძირითადად, თქვენ Cycling მეტი სიმბოლოების სიტყვით.
[სტუდენტი] ასე o იქნება გადასვლის იგივე -
ამიტომ o შეესაბამება გარკვეული რაოდენობის ანბანი.
[სტუდენტი] მარჯვენა. მაგრამ სად უნდა გაიტანოთ CS50 ნაწილი?
Oh. სწორედ იმ GetString აქ თქვენ მოსწონს, "მომეცი string to encode".
[სტუდენტი] ისინი აპირებენ, რომ არგუმენტი გადაეტანა მიერ
და მაშინ თქვენ გთხოვოთ პირველი სიმებიანი. >> Yeah.
ასე რომ, როდესაც ისინი პროგრამის გაშვება, ისინი აპირებენ მოიცავს სიტყვით
მათი ბრძანება ხაზი არგუმენტები, როდესაც ისინი გაუშვით.
მაშინ ერთხელ თქვენ შემოწმდება, რომ ისინი რეალურად მოცემული 1 და არა, არანაკლებ,
მაშინ თქვენ აპირებს უბიძგონ მათ სიმებიანი, ვთქვათ, "მომეცი string."
ასე რომ, სადაც ამ შემთხვევაში ისინი მოცემული, ეს ... არის CS50!
ასეა, მაშინ თქვენ აპირებს გამოიყენოს რომ და გამოიყენოთ ohai და iterate დასრულდა.
გაითვალისწინეთ, რომ აქ ჩვენ გამოტოვებენ მეტი encrypting პერიოდები,
მაგრამ თვალსაზრისით ჩვენი პოზიციის ohai, შემდეგი ერთი გამოვიყენეთ o.
ამ შემთხვევაში ეს ცოტა რთული ვხედავ რადგან ისინი 4,
მოდით გავაგრძელოთ bit. Just გამყარებაში ჩემთან ერთად აქ.
მაშინ მე და s, რომლებიც შემდეგ თარგმნა o და თ შესაბამისად.
მაშინ ჩვენ გვაქვს სივრცეში და ასე შემდეგ ჩვენ ვიცით, რომ ჩვენ არ ვაპირებთ encipher სივრცეებს.
მაგრამ ცნობა ნაცვლად აპირებს ამ ადგილზე სწორედ აქ,
ჩვენ encrypting მიერ - არ ვიცი, თუ თქვენ ხედავთ, რომ - სწორედ აქ.
ამიტომ არ მომწონს თქვენ ნამდვილად წინასწარ, ვთქვათ, o მიდის აქ, თ მიდის აქ,
აქ, მე აქ, o, H,, I, O, თ,, მე. თქვენ არ გაგვაჩნია.
თქვენ მხოლოდ გადაიტანოს თქვენი პოზიცია სიტყვით
როდესაც თქვენ იცით, რომ თქვენ რეალურად იქნება encrypting ფაქტობრივი წერილში.
ამჯამად ასეთი სახის აზრი?
Okay.
ასე რომ რამოდენიმე გადმონაშთებისადმი.
თქვენ გვინდა დავრწმუნდეთ, რომ თქვენ მხოლოდ წინასწარ შემდეგი წერილით თქვენს სიტყვით
თუ ხასიათი თქვენს plaintext არის წერილში.
ასე რომ ვთქვათ, ჩვენ at o.
ჩვენ შეამჩნევთ, რომ შემდეგი სიმბოლო, მე მაჩვენებელი plaintext, არის ნომერი, მაგალითად.
მაშინ ჩვენ არ უწყობს j, ინდექსი ჩვენი სიტყვით, სანამ მივაღწევთ სხვა წერილში.
ერთხელ, თქვენ ასევე გვინდა დავრწმუნდეთ, რომ თქვენ wraparound დასაწყისში სიტყვით
როდესაც თქვენ დასასრულს იგი.
თუ ხედავთ აქ ვართ საათზე მე, შემდეგი ერთი უნდა იყოს პ.
ასე რომ გსურთ გამოძებნოს გზა, რომელსაც აქვს უნარი wraparound დასაწყისში თქვენი სიტყვით
ყოველ ჯერზე, რომ თქვენ მიღწევა ბოლომდე.
და ა.შ. კიდევ ერთხელ, თუ რა სახის ოპერატორი სასარგებლოა, რომ საქმე შესაფუთი გარშემო?
მსგავსად დათვლა off მაგალითად.
[სტუდენტი] პროცენტს ნიშანი. >> Yeah, პროცენტი ნიშანი, რომელიც modulo.
ამიტომ modulo მოვა მოსახერხებელი აქ როდესაც გსურთ გადაიტანოთ მეტი ინდექსი თქვენს ohai.
და მხოლოდ სწრაფი მინიშნება: შეეცადეთ ვფიქრობ შესაფუთი მეტი სიტყვით ცოტა მოსწონს დათვლის off,
აქ თუ იქ 3 ჯგუფები, მე -4 პირი,
მათი რიცხვი, რომ მათი თქმით, 4 mod 3, რომელიც 1.
ასე რომ ცადეთ და ვფიქრობ, რომ გზა.
როგორც თქვენ ნახეთ ფორმულაში, სადაც თქვენ გაქვთ ci და შემდეგ pi მაგრამ შემდეგ kj,
თქვენ გვინდა დავრწმუნდეთ, რომ თქვენ ტრეკზე იმ.
თქვენ არ გჭირდებათ ეძახით მე, თქვენ არ გჭირდებათ ეძახით j,
მაგრამ თქვენ გვინდა დავრწმუნდეთ, რომ თქვენ ტრეკზე პოზიცია, რომ თქვენ დროს თქვენს plaintext
ისევე როგორც პოზიცია, რომ თქვენ დროს თქვენს სიტყვით
რადგან ეს ის აუცილებლად არ იქნება იგივე.
არა მარტო სიტყვით - ეს შეიძლება იყოს სრულიად განსხვავებული სიგრძე, ვიდრე თქვენი plaintext.
ასევე, თქვენი plaintext, არის ციფრები და სიმბოლოები,
ამიტომ არ აპირებს შესანიშნავად ემთხვევა up ერთად. დიახ.
[სტუდენტი] არსებობს ფუნქცია შეცვალოს შემთხვევაში?
შეგიძლიათ შეცვალოთ კაპიტალის? >> ჰო, იქ ნამდვილად არის.
თქვენ შეგიძლიათ შეამოწმოთ out - მჯერა, toupper, ყველა 1 სიტყვა.
მაგრამ როდესაც თქვენ ცდილობთ cipher რამ და შეინარჩუნოს ტექსტი,
ეს საუკეთესო ძირითადად ჰქონდეს ცალკეული შემთხვევები.
თუ ეს ზედა, მაშინ გსურთ გადაიტანოს ამ
რადგან თქვენს ფორმულა, როდესაც თქვენ ვიხსენებთ თუ როგორ უნდა სახის გადასვლა
interchangeably შორის ASCII გზას წარმოადგენს ნომრები
და ფაქტობრივი ანბანური ინდექსი, ჩვენ გვინდა დავრწმუნდეთ
იქ იქნება გარკვეული სახის ნიმუში, რომ თქვენ აპირებს გამოიყენოს.
კიდევ ერთი შენიშვნა ნიმუში, რეალურად.
თქვენ ვაპირებთ აუცილებლად იქნება საქმე ნომრები.
სცადეთ არ გამოიყენოს მაგიური ციფრები, რომელიც მაგალითად სტილის.
ასე ვთქვათ, გსურთ ყოველ ჯერზე ცვლა რაღაც მიერ like -
Okay, ასე მინიშნება, კიდევ ერთი სპოილერი არის, როდესაც თქვენ უნდა გადასვლის რაღაც
მიერ გარკვეული თანხა, ცდილობენ არ წარმოადგენს, რომ რეალურ რაოდენობასთან
არამედ შეეცდება და ვხედავ თუ შეგიძლიათ გამოიყენოთ ASCII ღირებულების, რომელიც სახის უფრო გრძნობა.
კიდევ ერთი შენიშვნა: იმის გამო, რომ ჩვენ საქმე გვაქვს ფორმულები,
მიუხედავად იმისა, რომ თქვენი TF იქნება სახის ვიცით რა ნიმუში თქვენ შეიძლება გამოყენებით,
იმისათვის, რომ თქვენს კომენტარები სახის ახსნას ლოგიკას, ისევე,
"მე გამოყენებისას ნიმუში, რადგან ..." და სახის ახსნას ნიმუში succinctly თქვენს კომენტარები.
[ეს იყო walkthrough 2] თუ არ არსებობს სხვა სახის კითხვებით, მაშინ მე უბრალოდ დარჩენა აქ ცოტა.
წარმატებებს გისურვებთ თქვენი pset 2: Crypto და მადლობა მობრძანებისათვის.
[სტუდენტი] დიდი მადლობა. >> მადლობა.
[მედია შემოსული INTRO]