[Powered by Google Translate] სექცია პრობლემა უცნობია 2: Hacker Edition
რობ Bowden, ჰარვარდის უნივერსიტეტი
ეს არის CS50. CS50.TV
ასე რომ, მე რობ. მე უფროსი in KIRKLAND. ეს ჩემი მესამე წელი TFing CS50.
ეს პირველი შემთხვევაა, როდესაც ჩვენ იცვლება ტრადიციული-ლექცია სტილის განყოფილებაში
სადაც ჩვენ უბრალოდ სახის მიმოხილვას თუ რა მოხდა ლექცია და მერე ბიჭებს კითხვის დასმის,
ახლა მიმდინარეობს გაცილებით მეტი პრობლემა დაფუძნებული, სადაც ჩვენ გამოტოვოთ, და -
ოჰ, ისე იდეა წასვლა ბმული მე გაგზავნილი თქვენ და შემდეგ თქვენ გექნებათ ჩემი ფართი.
ვინმეს არ აქვს ლეპტოპი? Okay.
ამიტომ, ჩვენ ვაპირებთ იყოს გამოყენებისას, და ჩვენ ვაპირებთ იყოს აკეთებს პრობლემების ცხოვრობენ ნაწილში
განხილვა მათ და მჭიდროდაა რა არის არასწორი
და ალბათ დახევის up ზოგიერთი თქვენი კოდი და ალბათ განიხილოს თქვენი იდეები.
ასე რომ უკვე ვინმე უჭირდათ?
შეგიძლიათ სტატისტიკა მხარეს, მე არ ვიცი, თუ ჩვენ გვექნება მიზეზი.
ახლა, ისევე როგორც წინა supersection, თუ იყო, რომ კლასი, იცით რა, რომ დაახლოებით.
ყველა P კომპლექტი იქ იქნება ამ მონაკვეთების.
ასე რომ P-set 2, სპეციფიკაციები, ვფიქრობ თქვენ ნახეთ ეს P-set 1 უკვე.
მაგრამ ჩვენ შეგვიძლია შევხედოთ P-set 2 რისთვისაც ჩვენ ვაპირებთ იყოს ვაპირებთ დღეს სრულდება.
და დაინახავთ მონაკვეთზე კითხვები.
ასე რომ, ეს იქნება ყველა P-კომპლექტი; იქ ვიქნები მონაკვეთზე კითხვები.
აქამდე ჩვენ განაცხადა, "ჩათვალეთ ეს საშუალებას."
თქვენ არ იქნება სთხოვა წარუდგინოს ამ პროგრამის.
იდეა არის, რომ ეს უნდა სახის დაგეხმარებათ დაიწყო პრობლემა კომპლექტი.
ვფიქრობ on Hacker გამოცემა, ბევრი მათგანი უნდა იყოს მხოლოდ ახალი, საინტერესო რამ უნდა ვისწავლოთ.
ისინი არ შეიძლება იყოს პირდაპირ გამოიყენება პრობლემა კომპლექტი.
და სწორედ ახლა ჩვენ არ მქონე თქვენ წარუდგინოს ისინი, მაგრამ თეორიულად,
მოგვიანებით პრობლემა კომპლექტი, თქვენ შეიძლება წარუდგინოს ისინი, და ამით თქვენ შეგიძლიათ მოსვლა სექციაში
ან საყურადღებო მონაკვეთზე მიიღოს პასუხი, ან შეგიძლიათ უბრალოდ მათ საკუთარ
თუ არ იგრძნონ მოსარგებლე ჩემი თანდასწრებით.
ამიტომ - ვფიქრობ, ეს არის პირველი.
Oh. ასევე, ამ მონაკვეთზე კითხვები ჩვენ ასევე თქვენ კითხვის დასმის შესახებ შორტები.
ამიტომ ვფიქრობ, თეორიულად, თქვენ უნდა უყუროთ ამ მისვლამდე მონაკვეთზე,
მაგრამ ჯარიმა თუ არ; ჩვენ წავიდეთ მათზე მაინც.
ასე რომ ჩვენ შეგვიძლია დავიწყოთ ამ: "როგორ ამჯამად ხოლო loop განსხვავდება do-ხოლო loop?
როდესაც არის ეს უკანასკნელი განსაკუთრებით სასარგებლოა? "
ასე რომ ვინმეს აქვს რაიმე -?
[სტუდენტური] do-ხოლო loop ყოველთვის შეასრულოს ერთხელ მაინც.
დიახ. ასე რომ არის განსხვავება. ხოლო loop - I'll მხოლოდ ამის შესახებ აქ - ხოლო მარყუჟის, ჩვენ გვაქვს მდგომარეობა
სწორედ აქ, ხოლო do-ხოლო, თქვენ არ მდგომარეობა სანამ არ მივიღებთ ქვემოთ აქ.
ასე რომ, როდესაც თქვენი პროგრამის შესრულებაში, და იგი იღებს, რათა ხოლო მარყუჟის,
იგი მაშინვე ამოწმებს თუ ეს მდგომარეობა არის ჭეშმარიტი.
თუ ეს მდგომარეობა არ არის სიმართლე, ეს იქნება უბრალოდ გამოტოვოთ მეტი loop მთლიანად.
Do-loop ხოლო, როგორც პროგრამის შესრულებაში, იგი იღებს, რათა "გავაკეთოთ."
არაფერი ხდება ამ ეტაპზე, უბრალოდ აგრძელებს შესრულებაში.
მაშინ, როდესაც ის იგებს "ხოლო," თუ მდგომარეობა არის ნამდვილი, ის ყველაფერს loop უკან და ამის გაკეთება კიდევ ერთხელ
და ისევ და ისევ სანამ მდგომარეობა არ არის სიმართლე და შემდეგ უბრალოდ მოდის მეშვეობით.
ასე რომ, განსხვავებით,,, რომ ეს შეიძლება გამოტოვოთ უფლება თავიდანვე.
ეს აუცილებლად ახორციელებს ერთხელ და მერე შეიძლება შესრულდეს უფრო თუ მდგომარეობა კვლავ ჭეშმარიტი.
ასე რომ სანამ loop იქნება მხოლოდ ამის გაკეთება კიდევ ერთხელ, ან - ხოლო loop - ჩვენ შეიძლება არ გვჭირდება საერთოდ,
რადგან როგორც კი მივიღებთ, თუ ეს პირობა არის ყალბი, ჩვენ უბრალოდ გამოტოვოთ უფლება მას.
ვინაიდან do-ხოლო მარყუჟის, ჩვენ შეასრულოს ის ერთხელ, აუცილებლად.
მაშინ, როცა ჩვენ ვიღებთ, რათა მდგომარეობა, ჩვენ შეამოწმოთ, თუ ეს სიმართლეა ან ცრუ.
თუ ეს სიმართლეა, ჩვენ გავაკეთებთ ერთხელ, თუ ეს ცრუ, ჩვენ უბრალოდ გავაგრძელებთ აპირებს.
ასე რომ, როდესაც არის ეს უკანასკნელი განსაკუთრებით სასარგებლოა?
ასე, რომ შეიძლება ითქვას, რომ მთლიანად საქართველოს 4 წლის, 3 წლის განმავლობაში, რაც,
რომ მე უკვე პროგრამირების, მე არ გამოიყენება ამ, ისევე, ქვეშ 10 ჯერ.
და ალბათ 5 მათგანი CS50 როდესაც ჩვენ შემოღების do-ხოლო მარყუჟების.
ასე რომ, როდესაც თქვენ როგორ გამოიყენა do-ხოლო მარყუჟების?
როდესაც არის - Yeah?
[სტუდენტური] როცა თქვენ ცდილობს მომხმარებლის input, ან რაღაც გსურთ შეამოწმოთ -
Yeah. ასე რომ, ხოლო მარყუჟების, მომხმარებლის შეყვანის არის დიდი ერთი.
ამიტომ პირველ რამდენიმე პრობლემა კომპლექტი, როდესაც თქვენ მინდა ვკითხო მომხმარებლის, ისევე,
"მომეცი სიმებიანი," ვერ გაგრძელდება სანამ არ მიიღებთ, რომ სიმებიანი.
და ასე რომ თქვენ, აუცილებლად, უნდა მოითხოვოთ სიმებიანი ერთხელ მაინც.
მაგრამ შემდეგ, თუ ისინი უპასუხოს რაღაც ცუდი, მაშინ უნდა loop თავში და ვთხოვ კიდევ ერთხელ.
მაგრამ, გარდა მომხმარებლის input, ძალიან იშვიათი რომ მე ექმნებათ შემთხვევაში
აქ მინდა მარყუჟის "ერთხელ მაინც" მაგრამ შესაძლოა უფრო.
კითხვები ან -? აქვს ვინმეს გამოყენებული do-loop ხოლო სხვაგან?
Okay. ასე რომ შემდეგი ერთი, "რას გამოუცხადებელ იდენტიფიკატორი
ჩვეულებრივ მიუთითებს თუ outputted მიერ clang? "
ასე რომ, თუ რა სახის კოდი შეიძლება ვწერ მისაღებად 'გამოუცხადებელ იდენტიფიკატორი?'
[სტუდენტური], რომ x = 2?
ასე რომ ჩვენ შეგვიძლია სცადეთ იგი აქ, X = 2.
ჩვენ აწარმოებს ამ - Oh, მე არ დაწკაპეთ იგი. ასე რომ აქ კიდევ - ყველა უფლება.
"გამოიყენე გამოუცხადებელი იდენტიფიკატორი x".
ასე რომ გამოუცხადებელ იდენტიფიკატორი, ცვლადი.
ეს იქნება ხშირად მოვუწოდებთ ცვლადი იდენტიფიკატორი.
ასე რომ, შესაძლოა, არ იციან, რეალურად ცვლადი, არ ვიცი რა არის.
ასე რომ იდენტიფიკატორი.
ასე რატომ არის გამოუცხადებელი? Yeah.
ასე უნდა იყოს მკაფიო on ტერმინოლოგიას, დეკლარაცია ცვლადი
როდესაც ამბობთ "int x," ან "string Y", რასაც.
ინიციალიზაციისას of ცვლადი, ან დავალებით ცვლადი,
არის როცა ამბობენ, რომ "X = 2."
ასე რომ ჩვენ შეგვიძლია გავაკეთოთ ეს ცალკე ნაბიჯები, int x, x = 2 და სანამ - ჩვენ შეგვიძლია აქვს bunch პერსონალის აქ -
მაგრამ სანამ ამ ხაზის მოხდება, x კვლავ uninitialized, მაგრამ ეს გამოცხადდა.
და ასე შეგვიძლია აშკარად ამას 1 ხაზი, და ახლა ჩვენ ვაცხადებთ და ინიციალიზაციისას.
კითხვები?
და ბოლოს, "რატომ არის კეისრის კოდი არ არის ძალიან უსაფრთხო?"
ასე რომ, პირველი, ჯერ არავის მინდა ვთქვა, რა კეისრის კოდი არის?
[სტუდენტური] კეისრის კოდი მხოლოდ ის არის, რომ თქვენ რუკა, თქვენ გადაეტანა ყველა წერილი,
გარკვეული რაოდენობის ასოები წასვლა დასრულდა და გადაადგილდება მეტი, და ეს არ არის ძალიან უსაფრთხო, რადგან
იქ მხოლოდ 26 შესაძლო ვარიანტები და უბრალოდ უნდა ვეცადოთ ყოველ 1 იმ სანამ ამას არ გაიგებთ.
Oh. ასე რომ, მე უნდა გავიმეორო?
კეისრის კოდი, it's - ვგულისხმობ, თქვენ უნდა საქმე ის პრობლემები, რომელიც თქვენ -
ან ვფიქრობ სტანდარტული გამოცემა პრობლემა კომპლექტი რომ არა ჰაკერი გამოცემა.
ასე სტანდარტული გამოცემა პრობლემა კომპლექტი, თქვენ გაგზავნა მოსწონს, "Hello, World,"
და თქვენ ასევე აქვს ხმების მოსწონს 6, და შენ რომ გაგზავნა, და თითოეული ინდივიდუალური ხასიათი,
თქვენ როტაცია იგი 6 თანამდებობებზე ანბანი.
ასე რომ "თ" წელს მიესალმები გახდება H-I-j-K-L-მ n.
ასე რომ პირველი ასო იქნება n. ჩვენ ამას ვაკეთებთ იგივე ერთად ე.
თუ ჩვენ გვაქვს, ისევე, z ან რამე, მაშინ ჩვენ საერთო უკან გარშემო to '.'
მაგრამ ყოველ ხასიათი იღებს cycled 6 სიმბოლო მოგვიანებით ანბანი, და ეს არ არის ძალიან უსაფრთხო
რადგან არსებობს მხოლოდ 26 შესაძლებლობები რამდენი გზები შეგიძლიათ გადაიტანოთ ერთი წერილი.
ასე რომ თქვენ შეგიძლიათ სცადეთ ყველა 26 მათგანი და, სავარაუდოდ, ამისთვის ხანგრძლივი საკმარისი გაგზავნა,
მხოლოდ 1 იმ შესაძლო 26 რამ იქნება legible,
და legible ერთი იქნება ორიგინალური გაგზავნა.
ასე რომ არ არის ძალიან კარგი გზა encrypting არაფერი ყოფილა.
უკავშირდება იმ შორტები, "რა არის ფუნქცია?"
რა არის ფუნქცია? დიახ.
[სტუდენტური] ეს მოსწონს ცალკე ნაჭერი კოდი, რომელიც შეგიძლიათ დარეკოთ გავლა და შემდეგ მიიღოს დაბრუნების ღირებულება რასაც.
Yeah. ასე რომ მე ვუპასუხო მას ასევე პასუხობდა შემდეგი - ან განმეორებითი მიერ ასევე უბრალოდ პასუხობდა შემდეგი ერთი.
თქვენ შეგიძლიათ გამოიყენოთ ფუნქციები ნაცვლად მხოლოდ გადაწერა და pasting კოდი უსასრულოდ.
უბრალოდ, რომ კოდი, დაუსვან მას ფუნქციის გამოსართავად, და მაშინ შეიძლება მხოლოდ მოვუწოდებთ ფუნქცია
სადაც არ უნდა იყოთ უკვე გადაწერა და pasting.
ამიტომ ფუნქციებია სასარგებლო.
ახლა ჩვენ გავაკეთებთ აქტუალურ პრობლემებზე.
პირველი. ასე რომ იდეა პირველი ის არის, თქვენ უნდა გაიაროს ეს ტექსტი, და მიუხედავად -
ან გვეუბნება ყველა ამას? ეს არ ვთქვა, ყველა ამას.
ამიტომ გაგზავნა შეიძლება იყოს არაფერი, და - Oh no. ის ჯერ.
"რამეთუ სიმარტივის, თქვენ შეიძლება ვივარაუდოთ, რომ მომხმარებელი მიიღებს მხოლოდ შეყვანის ამას წერილსა და სივრცეებს."
ამიტომ, ჩვენ უნდა გაიაროს ეს გაგზავნა მხოლოდ ამას წერილებს და შემდეგ ჩვენ ალტერნატიულ
შორის კაპიტალი და ამას - შევცვლით სიმებიანი უნდა იყოს დედაქალაქში და ამას, მონაცვლეობით.
ასე რომ სანამ ჩვენ მოგცემთ მეორე კი ჩაყვინთვის შევიდა პრობლემა,
რა არის პირველი რაც უნდა გავაკეთოთ?
ოჰ, რა მე უბრალოდ დააწკაპუნეთ? ოჰ, მე უბრალოდ დაწკაპავთ ელ აქ.
ასე რომ პირველი რაც უნდა გავაკეთოთ - მე ეძებს არასწორი ერთი?
ეს ნაწილი ამ ერთი?
არა, იმ დღემდე, არადა.
Okay, ჯერ კიდევ აქ.
ახლა ჩვენ არ შეგვიძლია ვივარაუდოთ, -? დიახ. აქ ჩვენ არ შეგვიძლია ვივარაუდოთ, რომ ეს მხოლოდ ამას და სივრცეებს.
ახლა გვაქვს საქმე იმით, რომ ასოები შეიძლება იყოს რასაც ჩვენ გვინდა, რომ იყოს.
და ა.შ. პირველი რაც ჩვენ გვსურს რომ არის უბრალოდ გაგზავნა.
ჩვენ უბრალოდ უნდა მიიღოს სიმებიანი, სიმებიანი s = GetString, okay.
ახლა ეს პრობლემა, არის რამდენიმე გზა არსებობს ამის გაკეთება.
მაგრამ ჩვენ ვაპირებთ გინდათ გამოიყენოთ bitwise ოპერატორები აქ.
არსებობს ხალხი, რომელიც არც არ იმყოფებოდნენ supersection,
ან რაღაც, და არ ვიცი რა bitwise ოპერატორები არიან?
ან როგორ ისინი ეხება ASCII არანაირად?
[სტუდენტური] მე არ იყო supersection, მაგრამ მე ვიცი რა bitwise ოპერატორები არიან.
Okay. ასეა, მაშინ მე არ მაქვს წასვლა მეტი საფუძვლებს, მაგრამ მე ახსნას
რაც ჩვენ ვაპირებთ გინდათ გამოიყენოთ აქ.
ასე რომ '': ორობითი წარმომადგენლობა დედაქალაქში, ნომერი 65.
მე უბრალოდ აპირებს შევხედოთ - 41 იქნება 01000001.
ასე რომ უნდა იყოს 65 წელს ათობითი, ამიტომ ეს არის ორობითი წარმომადგენლობა ხასიათი კაპიტალური ა
ახლა, ორობითი წარმომადგენლობა ხასიათი მხედრულ ''
იქნება იგივე, თითქმის. არის, რომ - 6, yeah. ეს არის სწორი.
ასე რომ ორობითი დედაქალაქში, ორობითი ამას ". '
ასე რომ განსხვავება და '' ეს ერთჯერადი bit.
ეს მაშინ იქნება 32 ბიტიანი, ცოტა წარმოადგენს ნომერი 32.
და რომ აზრი წლიდან არის 65; '' არის 97.
განსხვავება მათ შორის არის 32.
ახლა ჩვენ ვიცით, ჩვენ შეგვიძლია კონვერტირება საწყისი to '"მიერ აღების
და bitwise ORing იგი, - რომ ჰგავს 1.
ეს არის bitwise ან, ერთად 00100000, და რომ მივცემ us '.'
ჩვენ შეუძლიათ მიიღონ '' to მიერ bitwise ANDing
11, 0 რომ ადგილი, 11111.
ასე რომ, ეს იქნება მაშინ მოგვცეს ზუსტად რა '' იყო, მაგრამ გააუქმოს ეს ინდივიდუალური bit,
ამიტომ ჩვენ გვექნება 01000001, მე არ ვიცი, თუ მე დათვლილი უფლება.
მაგრამ ამ ტექნიკას bitwise ORing მიიღოს საწყისი კაპიტალის მხედრულ,
და bitwise ANDing მისაღებად საწყისი ამას კაპიტალის არ არის ექსკლუზიური ა
ყველა წერილებს, K vs K, Z vs z,
ყველა მათგანი მხოლოდ აპირებს განსხვავდება ამ ერთჯერადი bit.
და ასე რომ თქვენ შეგიძლიათ გამოიყენოთ ეს შეცვალოს ნებისმიერი ამას წერილში ნებისმიერ დედაქალაქში წერილში და პირიქით.
Okay. ასე მარტივად მიღების ამ - ასე ნაცვლად, რომელმაც უნდა
წერენ გარეთ რასაც 1011111 არის - მარტივი გზა წარმოადგენს ეს რიცხვი, და ეს არ არის ერთი
რომ მივედი დასრულდა supersection, მაგრამ tilde (~) არის კიდევ ერთი bitwise ოპერატორს.
რა ~ არ არის ის უყურებს ცოტა წარმომადგენლობა.
ავიღოთ ნებისმიერი რაოდენობის.
ეს არის რამოდენიმე ორობითი ნომერი, და რა ~ ამჯამად არის უბრალოდ შეიჭრება ყველა ბიტი.
ასე რომ, ეს იყო 1, არის 0, ეს 0, ახლა 1, 010100.
ასე რომ ყველა ~ აკეთებს. ასე 32 იქნება ნომერი - მოვაშოროთ, რომ -
ასე 32 იქნება ნომერი 00100000, და ასე ~ ამ იქნება
ეს რიცხვი აქ, რომ მე ANDed '' ერთად.
ამჯამად ყველას ვხედავ, რომ? ეს არის საკმაოდ გავრცელებული, ასე, როდესაც გსურთ გაერკვნენ
მოგვიანებით რამ, რომ ჩვენ შეიძლება ვხედავთ, როდესაც ჩვენ გვინდა, რომ თუ -
ან ჩვენ გვინდა ყველაფერი, თითოეული bit კომპლექტი გარდა 1
თქვენ ტენდენცია არ ~ საქართველოს bit, რომ ჩვენ არ გვინდა მითითებული.
ასე რომ არ გვინდა 32 bit კომპლექტი, ასე რომ ჩვენ ~ 32.
Okay. ასე რომ ჩვენ შეგვიძლია გამოვიყენოთ ყველა იმ აქ.
ყველა უფლება, ამიტომ ჯარიმის თუ თქვენ არ კეთდება, უნდა ნელა სიარული მეტი ერთად,
ფეხით ან მეტი ამ, ასე - მისი მეშვეობით. გავლა ამ.
ამიტომ, ჩვენ გვაქვს ჩვენი სიმებიანი, და გვინდა, რომ მარყუჟი აღემატება თითოეული პერსონაჟი, რომ სიმებიანი და რაღაც მას.
ასე როგორ უნდა loop მეტი სიმებიანი? რა უნდა გამოიყენოს?
მე არ ვაპირებ ამის შესახებ აქ. Yeah.
ასე რომ მე მაქვს ჩემი iterator და თქვა, მაგრამ რა ვიცი, რამდენი გმირები არიან სიმებიანი?
Strlen (s), მერე + +.
მერე რა მე ვაკეთებ აქ არ არის საუკეთესო გზა კეთების რამ.
ვინმეს თუ რატომ?
იმიტომ, რომ თქვენ შემოწმების ენა სიმებიანი თითოეული დრო.
ამიტომ, ჩვენ ვაპირებთ, რომ გვინდა ვიაროთ strlen, მე შეიძლება ითქვას, აქ, int სიგრძე = strlen (s),
და მერე მე <სიგრძე, და იმ შემთხვევაში თუ თქვენ არ მინახავს ეს ადრე,
მე შეიძლება გავაკეთოთ int i = 0, სიგრძე = strlen (s).
და ა.შ. ეს გარკვეულწილად სასურველია, რადგან ახლა მე შეზღუდული არეალი
საქართველოს ცვლადი სიგრძის მხოლოდ ამ 'for' loop, ნაცვლად გამოცხადების ეს ადრე
და რომ ყოველთვის არსებობს და იმ შემთხვევაში თუ თქვენ არ დაიჭიროთ რატომ რომ ცუდი,
ან რატომ ორიგინალური იყო ცუდი, it's - იწყება ამისთვის loop.
მე შევამოწმე მდგომარეობა. მე ვარ <სიგრძით s?
ამიტომ სიგრძით s, მოდით ვიმუშაოთ "Hello" მთელი ამ დროის.
ამიტომ სიგრძით s, H-E-L-მ-o. სიგრძე არის 5.
ასე რომ = 0, სიგრძე არის 5, ამიტომ არ არის <5, ასე loop გრძელდება.
მაშინ ჩვენ წავიდეთ ერთხელ. ჩვენ შეამოწმოს მდგომარეობა. მე ვარ <სიგრძეზე მიესალმები?
მოდით შევამოწმოთ სიგრძეზე hello. H-e-L-მ-o. სწორედ 5, მე არ არის <5, ამიტომ ჩვენ ვაგრძელებთ ერთხელ.
ჩვენ გაანგარიშების, ჩვენ მათი იმედი გვაქვს hello, თითოეული iteration of მარყუჟის,
კი ეგონა, არასდროს შეიცვლება, ის ყოველთვის იქნება 5.
ამიტომ, ჩვენ უბრალოდ გვახსოვდეს 5 up წინა და ახლა ყველაფერი სჯობს.
ამიტომ iterating მთელ string.
რას გსურთ თითოეული ხასიათი სიმებიანი?
[სტუდენტური მოლაპარაკე, გაუგებარია]
Yeah. ასე რომ, თუ ხასიათი არის არასამთავრობო ანბანურ, მაშინ ჩვენ გვსურს მხოლოდ გამოტოვოთ მას.
იმიტომ, რომ ჩვენ მხოლოდ აინტერესებს ანბანურ წერილებს, ჩვენ ვერ capitalize ნომერი.
ასე რომ როგორ შეგვიძლია ამის გაკეთება? ასე რომ ჩვენი მდგომარეობა, ასე რომ, თუ ჩვენ გვინდა რაღაც - შეამოწმეთ თუ ანბანურ.
ასე როგორ უნდა შეამოწმოთ ამ?
[სტუდენტური] შეგიძლიათ უბრალოდ გამოიყენოთ ფუნქცია alpha.
ის არის, რომ შედის არც ერთ ამ, ან ნებისმიერ მოიცავს, როგორიცაა, char.h ან რაღაც?
მოდით არ გამოიყენოთ არის ალფა ფუნქცია და გამოიყენონ გამოკვეთილ - ასე გვაქვს s [i],
რომ არის მერვე ხასიათი s, გვახსოვდეს, რომ სტრიქონს მასივი გმირები,
ასე მერვე ხასიათი s.
ახლა, თუ ეს კაპიტალი წერილში, ჩვენ ვიცით უნდა იყოს კონკრეტული დიაპაზონი.
და რა არის ის, რომ სპექტრი?
Yeah. ასე რომ, თუ s [i] არის ≥ 65, და s [i] არის ≤ 90, რა უნდა გავაკეთო ნაცვლად?
Yeah. ასე, რომ თქვენ უნდა აბსოლუტურად არასოდეს კი უნდა იცოდეთ ASCII ღირებულებებს არაფერი ოდესმე.
არასოდეს ვფიქრობ ნომრები 65, 90, 97 და 102, ან რასაც იგი.
თქვენ არ გჭირდებათ - 112? - თქვენ არ უნდა იცოდეთ ის ყველა. სწორედ არასწორი ძალიან.
მხოლოდ ერთ ციტირებით გმირები, მარტოხელა ციტირებით მუდმივები. ასე რომ "ა" და ნაკლები 90 არის 'ზ'
და ეს არის მნიშვნელოვნად უკეთესი - მე არ ვიცი Off ზევით ჩემი უფროსი, რომ Z არის 90.
მე ვიცი Off ზევით ჩემი უფროსი, რომ "Z" არის კაპიტალური ზ
ასე რომ, სანამ ეს სპექტრი კაპიტალი კაპიტალის Z, ან ჩვენ შეგვიძლია შევამოწმოთ ამას,
ან თუ იმ დიაპაზონში ≥ "ა" და ≤ z.
ასე რომ ჩვენი მდგომარეობა.
სტილი სად დააყენა ეს ყველაფერი მერყეობს.
მე გავაკეთებთ მოსწონს ეს.
ახლა, რა გვჭირდება ჩვენ უნდა გავაკეთოთ?
ჩვენ ვიცით, ეს წერილი არის ხასიათი, ანბანური ხასიათი.
ამიტომ, ჩვენ უნდა ჰყავდეს შორის თუ არა ეს უნდა იყოს კაპიტალის წერილით ან ამას წერილში.
როგორ უნდა ტრეკზე რომელიც ერთი ჩვენ გვინდა, რომ იყოს?
[სტუდენტური ხმები, გაუგებარია]
ასე რომ დიახ, მაგრამ ნება მიბოძეთ შეამოწმოს.
მოდული 0-2 ითქვა, იყო წინადადება გადმოაგდეს, და ვეთანხმები, რომ.
გარდა ცნობა, როგორიცაა - არის ამ შემთხვევაში? Yeah.
ეს ყოველ მეორე, მაგრამ ჩვენ არ შეგვიძლია მოდული 2 I, ან მე mod 2, ვინაიდან
შეამჩნევთ, რომ E არის კაპიტალური და '' არის ამას? მაგრამ სივრცე ჰყოფს მათ?
ამიტომ ისინი უნდა იყოს იგივე mod 2, მაგრამ ისინი სხვადასხვა შემთხვევებში.
[სტუდენტური კითხვაზე, გაუგებარია]
Yeah. ასე რომ ჩვენ უბრალოდ აპირებს შეინარჩუნოს რაოდენობა.
ჩვენ შეგვიძლია აგრეთვე გავაკეთოთ, რომ აქ, თუ გვინდოდა, რომ შესაძლოა პატარა unwieldy
in for loop დეკლარაციების; მე ამას აქ.
ასე int რაოდენობა = იწყება 0.
და ახლა, მე ვაპირებ ითვლიან რამდენი ანბანის სიმბოლოების ჩვენ გვქონდა.
ამიტომ ჩვენ აუცილებლად ვაპირებთ ითვლიან + + წლიდან აღმოვაჩინეთ კიდევ ერთი ანბანური ხასიათი.
მაგრამ, ასე ახლა თქვენ ამბობდა, თუ რაოდენობა mod 2.
მერე რა, რომ რაოდენობა mod 2? Oh. მე გავაკეთებ == 0 ახლა.
ჩვენ ასევე წასვლა მეტი რომ. ასე რომ, თუ რაოდენობა mod 2 == 0, მერე რა?
[სტუდენტები პასუხი, გაუგებარია]
ამიტომ ჩვენ გვსურს დასრულდება მდე ზედა.
არის 2 შემთხვევა; ზედა და ამას are 2 შემთხვევა.
ასე რომ, თუ ჩვენ ამას ჩვენ გვჭირდება, რათა ის ზედა.
თუ ეს ზედა ჩვენ არ გვჭირდება არაფრის.
მაგრამ, არსებობს გზა - shouldn't არ flipped -
რომ ჩვენ არც კი უნდა შეამოწმოთ, რამდენად მიზანშეწონილია ზედა ან ამას?
რა გავაკეთოთ, რომ ყოველთვის დარწმუნდით, რომ ჩვენ ყოველთვის დასრულდება მდე საათზე ზედა?
ასე რომ შეამჩნია, რასაც ჩვენ გააკეთა ამას ''; რა, თუ ეს გავაკეთეთ იგივე ზუსტი რამ ზედა?
Does ზედა ცვლილება, ან ჯერ ფასი ცვლილება?
Yeah. ასე რომ ნებისმიერი კაპიტალის წერილში bitwise ANDed ერთად ~ 32 იქნება, რომ იგივე ზედა ხასიათი
რადგან ნებისმიერი ზედა ხასიათი 32ND ცოტა არ არის მითითებული.
ასე რომ, თუ ჩვენ გვინდა, რათა ხასიათი s [i], ჩვენ გვსურს, რომ გახდეს ამას ან ზედა.
ასე რომ, თუ ეს იყო ამას, ეს არის ზედა, თუ ეს იყო ზედა, მაინც ზედა, და ამით ყველაფერი მთავრდება.
მე ვთქვი ეს supersection: თქვენ შეგიძლიათ გამოიყენოთ 32 თუ გინდათ, მაგრამ მე როგორც წესი, ამჯობინებენ აკეთებს '' -,
ნაცვლად მხოლოდ ბარის 32, იმიტომ რომ ეს შეიძლება იყოს ნებისმიერი სხვა bit.
შემდეგ 32 bit, ეს შეიძლება იყოს რომელიმე ამ, ან ჩვენ არ გვაქვს საკმარისი
ნომრები წარმოადგინოს ყველა სიმბოლო.
ასე რომ თუ თქვენ გაქვთ 32 ბიტიანი, შეიძლება იყოს 64 bit, ეს შეიძლება იყოს 128 ბიტიანი.
ნებისმიერი იმ ბიტი შეიძლება ცოტა რომ განასხვავებს ზედა და ამას.
მე არ უნდა უნდა იცოდეთ, რომ ეს 32 ბიტიანი.
შემიძლია ამ ნაწილის "ა" - მიიღოს ცოტა რომ განსხვავდება შორის ორი
გარეშე სჭირდება უნდა დაეყრდნოს Magic ნომერი, რომელიც 32.
და ა.შ. ახლა, სხვას დათვლა უცნაური, და ასე რა გსურთ?
[სტუდენტური პასუხები, გაუგებარია]
[სტუდენტური] რა არის რომ?
მე ამას 1 წამში.
ახლა თუ მინდა - მინდა დარწმუნდით ხასიათი არის ამას,
და ასე, რომ შეიძლება ან 32 და 32 მნიშვნელობა '' - ა
მაგრამ ცნობა, იმავე მიზეზის როგორც ადრე, რომ თუ
წერილში უკვე ამას, მაშინ ORing მიერ 32 მხოლოდ ინახავს მხედრულ.
ეს არ შეცვლილა ორიგინალური ხასიათი.
მაგრამ ახლა არ მაქვს, რათა თავიდან ავიცილოთ განაცხადა, "თუ ეს ამას, უბრალოდ დაივიწყოს ის,
თუ ზედა, მაშინ შეცვლის. "
ეს ბევრად უფრო მოსახერხებელია ამის გაკეთება.
[სტუდენტური] Would რომ სტრატეგია subtracting ზედა მხრიდან ამას მუშაობა თუ იგი არ იყო 32?
თუ ეს იყო, ისევე, 34 ან რამე?
ასე რომ, თქვენ უნდა იცოდეთ, რომ განსხვავება არის 2 -? >> 1 bit.
ეს შეიძლება იყოს მეტი, ვიდრე 1 bit, რადგან ყველა ბიტი ქვემოთ ამ თანამდებობაზე ერთი და იგივე.
ამიტომ ჩვენ გვჭირდება მინიმუმ 26 ჩარი - ან, არის 26 სიმბოლო.
ამიტომ ჩვენ გვჭირდება მინიმუმ 26 ნომრის წარმოადგენს სხვაობა -
განსხვავება და '' უნდა იყოს მინიმუმ 26,
ანდა ჩვენ არ წარმოდგენილია ყველა დედაქალაქში ნომრები.
ეს იმას ნიშნავს, რომ, თუ ჩვენ იწყება 1, ის აპირებს გამოიყენოს ყველა ამ ბიტი,
ყველა ამ პირველი 5 ბიტი, წარმოადგინოს ყველაფერი მეშვეობით ზ
ამიტომ შემდეგი bit, ან ამ bit, შემდეგი bit არის ერთი, რომ მიერ არჩეული გამოირჩეოდნენ შორის და '.'
სწორედ ასევე, თუ რატომ, ამ ASCII მაგიდა, არის 5 სიმბოლიკა ჰყოფს ასოებით საწყისი ამას წერილებს.
მას შემდეგ, რაც ეს ის სიმბოლიკა, დამატებით 5, რომ გამოიტანს 32 მყოფი განსხვავება მათ შორის.
[სტუდენტური], ამიტომ ვერ გავაკეთებთ, რადგან ASCII ის შექმნილია, რომ გზა.
დიახ. მაგრამ ASCII - განსხვავება შეიძლება ორივე ბიტი.
მსგავსად, თუ იყო 10000001, და '' იყო 11100001 - მე დაგვავიწყდეს, რასაც.
მაგრამ თუ ეს იყო, მაშინ ჩვენ შეგვიძლია კვლავ გამოიყენოს "ა" - ა
უბრალოდ ახლა სხვაობა და '' ჯერ კიდევ ამ 2 ბიტი.
ვფიქრობ, ეს დაწერილი 48. არის თუ არა 32 + 64? მე ვფიქრობ, ეს არის?
ეს მაინც იყოს 2 ბიტი, თითოეული ხასიათი, ისევე, Z და z, K და K,
ისინი ჯერ კიდევ აქვს იგივე ზუსტი ბიტი მითითებული გარდა იმ 2 ბიტი.
ასე რომ სანამ რომ ყოველთვის ასეა, მიუხედავად თუ ჩვენ გამოყენებით ASCII ან სხვა სისტემა,
რადგან არსებობს მხოლოდ კომპლექტი რაოდენობის ბიტი, რომლებიც სხვადასხვა თითოეული ხასიათი,
მაშინ რომ მუშაობს ჯარიმა.
უბრალოდ, 32 შეიქმნა იმიტომ რომ პირველი ჩვენ შეიძლება გამოვიყენოთ. >> Cool.
მე როგორც წესი, ერჩივნა, იმ შემთხვევაში თუ თქვენ არ მინახავს, ​​თუ ბლოკი მხოლოდ ერთი ხაზი,
შეგიძლიათ დავაღწიოთ Curly braces, ამიტომ მე ტენდენცია ურჩევნია აკეთებენ.
ასევე, თქვენ იცით, თუ როგორ შეგვიძლია გავაკეთოთ რამ, როგორიცაა s [i] + = 1?
თქვენ ასევე შეგიძლიათ გავაკეთოთ s [i] bitwise და = 32.
და bitwise OR = 32.
ასევე, ითვლიან mod 2 == 0.
ასე რომ გვახსოვდეს, რომ - მე არ დავწერ აქ - ნებისმიერი არასამთავრობო ნულოვანი ღირებულება არის ჭეშმარიტი და 0 სიცრუეა.
ასე რომ "თუ რაოდენობა mod 2 == 0" იგივეა, რაც რომ "თუ არ ითვლიან mod 2."
მე ალბათ ახლახანს შეცვალა ხაზები და განაცხადა, რომ "თუ რაოდენობა mod 2,
ნუ ან 1, სხვას რას და 1 ", ასე, რომ არ გვჭირდება" არა ".
მაგრამ ეს მუშაობს მხოლოდ ასევე.
და რა გავაკეთო აქ?
თქვენ შეიძლება დააკავშიროთ მათ ternary თუ უნდოდა, მაგრამ მაშინ ეს უბრალოდ მიიღოს რამ messier
და ალბათ უფრო რთული წასაკითხი, ამიტომ ჩვენ არ გაგვაჩნია.
ვინმეს აქვს რაიმე სხვა წინადადებები?
არის, რომ ყველა პრობლემა სთხოვა? Oh Yeah.
ასე რომ დავაღწიოთ ამ ცარიელი ხაზები, ახლა ჩვენ ბეჭდვა ვ% s მყოფი ერთ სიმებისათვის,
ჩვენ ბეჭდვა F, s.
ახლა მოდით გაუშვით. არ ვამბობ არაფერს არასწორი?
სწორედ \ "; მინდა n.
Okay. ახლა ჩვენ გაუშვით. ეს ალბათ დაწეროთ at me.
Strlen არის string.h.
ასე რომ, ეს არის კარგი რამ შესახებ Clang არის ის გიჩვენებთ რასაც ის წელს,
ნაცვლად gcc რომელიც მხოლოდ ამბობს: "Hey, თქვენ დაგავიწყდათ რაღაც, არ ვიცი, რაც იყო."
მაგრამ ეს იქნება მითხრათ, "თქვენ ნიშნავდა მოიცავს string.h."
ასე რომ მე არ შეეკითხება რაიმეს, ამიტომ არ ვამბობ არაფერს.
მაგრამ ჩვენ ყველაფერს გავაკეთებთ მათ მაგალითზე, "გმადლობთ 4 დამატება".
რომელიც გამოიყურება უფლება. Hooray.
ამიტომ დაბრუნების თქვენი მთავარი, მე თითქმის არასდროს გავაკეთებთ.
ეს პირობითი. და მთავარი არის ერთადერთი ფუნქცია, რომლის მიმართაც ის სურვილისამებრ.
თუ არ დაბრუნდნენ არაფერს მთავარ, ეს ვარაუდი, რომ თქვენ ნიშნავდა დაბრუნებას 0.
კითხვები?
Okay. ახლა მეორე პრობლემა.
"შეგახსენებთ, საწყისი კვირაში 2 მეორე ლექცია, რომ შევცვალე 2 ცვლადები 'ღირებულებების გავლით
იმ 2 ცვლადები ფუნქციის (თუნდაც მოუწოდა swap) არ ზუსტად იმუშავებს, მაინც არ გარეშე "პოინტერები".
და იგნორირება პოინტერები სანამ არ მივიღებთ მათ.
ჩვენ გვინდა, რომ სვოპ 2 ცვლადები; ჩვენ არ იყენებს ფუნქციას ამის გაკეთება.
ჩვენ კვლავ აპირებს ის ძირითადი მოსწონს ნათქვამია მოხსენებაში.
მაგრამ გამოიყენოს იმ 2 ცვლადები, არ გვინდა გამოვიყენოთ დროებითი ცვლადი.
2 გზა არსებოსბს ამის გაკეთება.
თქვენ შეგიძლიათ ეს გააკეთოთ გამოყენებით თქვენი ტრადიციული ბინარული ოპერატორები.
ასე რომ ვინმეს ვიცი სწრაფი და ბინძური გზა აკეთებს, რომ?
ეს შეიძლება პრაქტიკულად წუთი აზროვნების. თუ მე -
მე მითითებული პრობლემა მოსწონს ისინი კითხულობენ. ასე რომ, თუ მაქვს 2 ცვლადები,, რაც არის მთელი რიცხვი
რომ მომცეს, და თანხა ცვლადი B, რაც კიდევ ერთი რიცხვი, რომ მე მოცემული.
ასე რომ, თუ მაქვს ამ 2 ცვლადები, ახლა მინდა სვოპ მათ.
ტრადიციული, თქვენი რეგულარული ბინარული ოპერატორები, ვგულისხმობ, როგორიც +, -, ÷.
არ bitwise ოპერატორების რომელიც მოქმედებს ორობითი.
ასე გამოყენებით -, +, î, და ყველა იმ.
ჩვენ შეგვეძლო სვოპ ამით რაღაც = + B და B = - ბ, = - ბ.
ასე რომ, საღი აზრის შეამოწმეთ და შემდეგ ვნახავთ, თუ რატომ, რომ სამუშაოები.
ვთქვათ = 7, ბ = 3, მაშინ a + b იქნება 10.
ამიტომ ჩვენ ახლა შექმნის = 10, და შემდეგ ვაკეთებთ B = - ბ.
ასე ვაკეთებთ B = - ბ, რომელიც იქნება 7, ბ = - ბ ერთხელ,
ან = - ბ. რომელიც იქნება 10 - 7 რომელიც არის 3.
ახლა, სწორად, '' იყო 7, ბ იყო 3 და ახლა B არის 7 და '' არის 3.
ასე რომ ასეთი სახის აზრი; '' არის კომბინაცია 2 ნომრები.
ამ ეტაპზე, "ა" არის კომბინაცია, და შემდეგ ჩვენ subtracting გარეთ ორიგინალური ბ,
და მაშინ ჩვენ subtracting რა იყო ორიგინალური '.'
მაგრამ ეს არ მუშაობს ყველა ნომრები.
, რომ ეს, განვიხილოთ სისტემა, ამიტომ როგორც წესი, ჩვენ ვიფიქროთ, მთელი რიცხვები, როგორც 32 ბიტი.
მოდით მუშაობა რაღაც რომ მხოლოდ მოსწონს 4 ბიტი.
იმედია მე ამუშავება კარგი მაგალითი ახლავე.
ასე რომ, მე ვიცი, ეს იქნება ადვილი.
ვთქვათ ჩვენი 2 ნომრები არიან 1111 და 1111, ამიტომ ჩვენ წელს ორობითი ახლავე.
რეალურ decimals, თუ თქვენ გინდათ რომ ვფიქრობ ის, რომ გზა, = 15 და B = 15.
ამიტომ ჩვენ ველით, რომ მას შემდეგ, რაც ჩვენ სვოპ მათ - მათ არც კი უნდა იყოს იგივე ნომრები,
მაგრამ ეს ამ გზით.
მოდით მათ არ იგივე ნომრები. მოდით 1111 და 0001.
ასე = 15 და B = 1.
მას შემდეგ რაც სვოპ მათ, ჩვენ ველით, რომ "ა" უნდა იყოს 1 და B უნდა იყოს 15.
ამიტომ ჩვენი პირველი ნაბიჯი არის = + ბ.
ჩვენი ნომრები მხოლოდ 4 ბიტი ფართო, ასე ',' რომელიც 1111, + B, რომელიც 0001,
აპირებს დასრულდება მდე მიმდინარეობს 10000, მაგრამ ჩვენ მხოლოდ 4 ბიტი.
ახლა = 0.
და ახლა ჩვენ გვინდა მითითებული B = - ბ - ფაქტობრივად, ეს მაინც შეიმუშავებს შესანიშნავად.
= - ბ - ვნახოთ, თუ ამ შეიმუშავებს შესანიშნავად.
ასეა, მაშინ B = 0 - 1, რომელიც კვლავ იყოს 15, ხოლო შემდეგ = - ბ, რომელიც იქნება 1.
იქნებ ეს სულაც მუშაობა.
ვგრძნობ, როგორიცაა არსებობს მიზეზი ის არ მუშაობს გამოყენებით რეგულარული.
Okay, ასე მუშაობს ვარაუდი, რომ იგი არ მუშაობს რეგულარული ბინარული ოპერაციები,
და მე ვეძებთ - მე Google თუ რომ მართლაც ასეა.
ასე რომ ჩვენ გვინდა ამის გაკეთება გამოყენებით bitwise ოპერატორები, და ნახავ აქ XOR.
ასე რომ, შემოღების XOR (^) თუ არ მინახავს ეს არავის გაუკეთებია.
ეს, კიდევ ერთხელ, bitwise ოპერატორი ასე მოქმედებს ნელ bit, და it's -
თუ თქვენ გაქვთ ბიტი 0 და 1, მაშინ ეს იქნება 1.
თუ თქვენ გაქვთ ბიტი 1 და 0, ეს იქნება 1, თქვენ გაქვთ ბიტი 0 და 0 ეს იქნება 0,
და თუ თქვენ გაქვთ ბიტი 1 და 1 ეს იქნება 0.
ასე რომ მოსწონს ან. თუ არც ბიტი არის ჭეშმარიტი, ეს 1, მაგრამ განსხვავებით, ან მას არ შეუძლია იყოს როგორც ბიტი, რომ არის ჭეშმარიტი.
OR იქნებოდა ეს იყოს 1, XOR იქნებოდა ეს იყოს 0.
ამიტომ, ჩვენ ვაპირებთ, რომ გსურთ გამოიყენოთ XOR აქ.
დაფიქრდით ერთი წუთით, მე ვაპირებ Google.
ისე, თქვენ ვერ ხედავთ, რომ მე ვარ ამჟამად XOR swap ალგორითმი გვერდზე.
იმედია ამ აგიხსნით რატომ can't -
სწორედ ეს არის ის ალგორითმი, რომ ჩვენ უბრალოდ გააკეთეს.
მე მაინც ვერ ვხედავ, რატომ - მე უნდა უბრალოდ აღებული ცუდი მაგალითია,
მაგრამ ამ შემთხვევაში '' მოხდა, რომ გახდეს 0, მას შემდეგ, რაც დან 5 ბიტი, ამიტომ ახლა '' არის 0,
რომ არის რა ჰქვია "Integer overflow".
მიხედვით ვიკიპედია, "განსხვავებით XOR swap, ამ ვარიაციის მოითხოვს, რომ იგი იყენებს ზოგიერთი მეთოდები
უნდა უზრუნველყოს, რომ x + y არ იწვევს მთელი overflow ".
ასე რომ, ეს არ აქვს პრობლემები, რაც მთელი რიცხვი overflow, მაგრამ რაღაც არასწორია.
მე არ ვარ დარწმუნებული. ვეცდები რომ ამუშავება კიდევ ერთი.
[სტუდენტური] ისე, არ არის მთელი რიცხვი overflow როდესაც თქვენ ცდილობთ დააყენა ნომერი არსებობს
დიდია, ვიდრე თანხის ბიტი თქვენ არ გამოყო?
Yeah. ჩვენ გვყავს 4 ბიტი. That's - გვქონდა 4 ბიტი, ჩვენ მაშინ ცდილობენ დაამატოთ 1 მას, ასე რომ ჩვენ დასრულდება მდე, 5 ბიტი.
მაგრამ მეხუთე bit უბრალოდ იღებს შეწყვიტა, yeah.
ეს შესაძლოა რეალურად -
[სტუდენტური] არა, რომ ჩააგდოს თქვენ შეცდომა, ან არ, რომ - რომ რომ ჩააგდოს შეცდომა?
პოსტები ასე არ შეცდომა. როდესაც თქვენ მიიღებთ ასამბლეის დონეზე, სპეციალური bit
სადღაც არის მითითებული, რომ განაცხადა, რომ overflow, მაგრამ C თქვენ სახის უბრალოდ არ გაუმკლავდეთ რომ.
თქვენ ნამდვილად ვერ გაუმკლავდეთ მას თუ არ გამოიყენოს სპეციალური ასამბლეის ინსტრუქცია C.
მოდით ვიფიქროთ XOR swap.
და ვფიქრობ ვიკიპედიის სტატიიდან შეიძლება ასევე ამბობდა, რომ -
ასე რომ, ეს ასევე აღიზარდნენ მოდულარული არითმეტიკა, ასე ვფიქრობ მე ვიყავი, თეორიულად, აკეთებს მოდულარული არითმეტიკა
როდესაც ვთქვი, რომ 1 - 0 არის 15 ერთხელ.
ასე, რომ ეს შეიძლება რეალურად - რეგულარულ პროცესორი რომ არ 0 - 1 = 15.
ვინაიდან ჩვენ დასრულდება მდე at 0, ჩვენ სხვაობა 1, ასე რომ მაშინ მხოლოდ დასრულდება უკან გარშემო ნომერზე 1111.
ასე რომ, ეს ალგორითმი შეიძლება რეალურად მუშაობა, + B, - ბ, ბ -, რომ შესაძლოა, ჯარიმა.
მაგრამ ზოგიერთი პროცესორები რომლებიც არ გავაკეთოთ, და ა.შ. ეს არ იქნება ჯარიმა იმ კონკრეტულ მიიჩნიეს.
XOR swap იმუშავებს ნებისმიერი პროცესორი. Okay.
იდეა არის ის, რომ ეს უნდა იყოს იგივე, თუმცა.
სადაც ჩვენ ვართ გამოყენებით XOR რათა როგორმე მიიღოს ინფორმაცია ორივე შევიდა 1 of ცვლადები,
და შემდეგ გაიყვანოს ინფორმაციით ინდივიდუალური ცვლადები ერთხელ.
ასე რომ ვინმეს აქვს იდეები / პასუხი?
[სტუდენტური პასუხი, გაუგებარია]
ასე რომ, ეს უნდა იმუშაოს, და ასევე, XOR არის commutative.
მიუხედავად რომელიც წესრიგის ამ 2 ნომრები მოხდეს იყოს აქ,
ეს შედეგი იქნება იგივე.
ასე ^ B არის ბ ^.
თქვენ შესაძლოა, ასევე ხედავენ ამ წერილობითი როგორც ^ = B, B ^ =, ^ = B ერთხელ.
ასე რომ, ეს უფლება, და თუ რატომ ეს სამუშაოები, ვფიქრობ ბიტი.
გამოყენება smallish ნომერი, ვთქვათ 11001, 01100 და.
ასე რომ, ეს ''; ეს ბ.
ასე ^ = B.
ჩვენ ვაპირებთ უნდა დააყენოთ '' = to XOR ამ 2 რამ.
ამგვარად 1 ^ 0 არის 1; 1 ^ 1 არის 0; 0 ^ 1 არის 1 და 0 ^ 0 არის 0; 1 ^ 0 არის 1.
ასე რომ ',' თუ შევხედოთ ათობითი რიცხვი, ეს იქნება -
თქვენ არ აპირებენ ვხედავ დიდი შორის ურთიერთობის ორიგინალური "ა" და ახალი ", '
მაგრამ თუ ჩვენ შევხედავთ ბიტი, '' არის მოსწონს mesh ინფორმაციის
ორივე ორიგინალური "ა" და ორიგინალური ბ.
ასე რომ, თუ ჩვენ ვიღებთ ბ ^, ჩვენ ვხედავთ, რომ ჩვენ დასრულდება მდე საათზე ორიგინალური '.'
და თუ ავიღებთ ორიგინალური '' ^ ახალი ',' ჩვენ ვხედავთ ჩვენ დასრულდება მდე საათზე ორიგინალური ბ.
ასე რომ (^ ბ) ^ B = ორიგინალური '.'
და (^ ბ) ^ = ორიგინალური ბ.
არსებობს - სხვა გზა ხედავს ეს არაფერი XOR თავისთავად ყოველთვის 0.
ასე რომ 1101 ^ 1101, ყველა ბიტი ვაპირებთ იყოს იგივე.
ასე რომ ის არასდროს იქნება შემთხვევაში სადაც 1 არის 0, ხოლო მეორე 1.
ასე რომ, ეს არის 0000.
იგივე ამ. (^ ბ) ^ ბ ჰგავს ^ (B ^ ბ).
(ბ ^ ბ) იქნება 0; ^ 0 მხოლოდ იქნება ", 'რადგან ყველა ბიტი არის 0.
ასე რომ ერთადერთი პირობა, რომ ვაპირებთ იყოს სადაც "'თავდაპირველად 1 - ჰქონდა მიიჩნიეს.
და იგივე იდეა აქ ვარ საკმაოდ დარწმუნებული ასევე commutative.
Yeah. მე ვთქვა ადრე, რომ ეს იყო commutative.
^ ',' და ეს ასოციაციური, ამიტომ ახლა (B ^) ^.
და ჩვენ შეგვიძლია გავაკეთოთ ბ ^ (^).
და ა.შ. ერთხელ, მივიღებთ ორიგინალური ბ.
ასე რომ '' არის კომბინაცია "ა" და ბ ერთად.
ჩვენი ახალი Combo '' ვამბობთ B = Combo '' ^ ორიგინალური ბ, მივიღებთ ორიგინალური '.'
და ახლა = Combo '' ^ ახალი ბ, რომელიც იყო ორიგინალურ - ან რომელიც არის, რა იყო '"ან ბ.
სწორედ ამ შემთხვევაში ქვემოთ აქ. ეს არის = B, ძველი ბ.
ასე რომ ახლა ყველაფერი უკან swapped მიზნით.
თუ ჩვენ რეალურად შევხედე ბიტი, ბ = ^ B, აპირებს XOR ამ 2,
და პასუხი იქნება ამ და შემდეგ = ^ B არის XORing ამ 2 და პასუხი არის ამ.
კითხვები? Okay. ასე რომ ბოლო ერთი გარკვეულწილად მნიშვნელოვნად უფრო რთულია.
[სტუდენტური] ვფიქრობ მას კითხვას ამის შესახებ. >> ოჰ, უკაცრავად.
[სტუდენტური] რა არის რეალურად უფრო სწრაფად? თუ იყენებთ ამ XOR, ან არის, თუ გამოაცხადოს ახალი ცვლადი?
რა არის რეალურად უფრო სწრაფად, გამოცხადების ახალი ცვლადი ან გამოყენებით XOR რომ სვოპ?
პასუხი არის, ყველა ალბათობა, დროებითი ცვლადი.
და ეს იმიტომ, რომ ერთხელ ის შედგენილი Down - ისე ასამბლეის დონეზე,
არსებობს ასეთი რამ, როგორც ადგილობრივი ცვლადები ან ნებისმიერ დროებითი ცვლადები ან ამ პერსონალის.
ისინი ისევე როგორც - იქ მეხსიერება, და არსებობს რეგისტრების.
რეგისტის, რა აქტიურად ხდება.
თქვენ არ დაამატოთ 2 რამ მეხსიერება; თქვენ დაამატოთ 2 რამ რეგისტრების.
და თქვენ მოუტანს ნივთები მეხსიერების რეგისტრების შევიდა, რათა შემდეგ add მათ,
და მაშინ შეიძლება განათავსოთ მათ უკან მეხსიერებაში, მაგრამ ყველა მოქმედება ხდება რეგისტრების.
ასე რომ, როდესაც თქვენ იყენებთ დროებითი ცვლადი მიდგომა, ჩვეულებრივ, რა ხდება
ამ 2 ნომრები უკვე რეგისტრების.
და შემდეგ რომ წერტილი, შემდეგ თქვენ swapped მათ,
ეს კიდე დავიწყო გამოყენებით სხვა რეესტრში.
ერთგან თქვენ უკვე გამოყენებით B, იგი ყველაფერს უბრალოდ გამოიყენოთ რეგისტრაცია რომ უკვე შენახვა ". '
ასე რომ, ეს არ უნდა გავაკეთოთ არაფერი მართლაც swap. ჰო?
[სტუდენტური] არამედ იღებს მეტი მეხსიერების, არა?
იგი მხოლოდ მიიღოს მეტი მეხსიერების თუ მას სჭირდება შესანახად, რომ დროებითი ცვლადი.
Like თუ მოგვიანებით გამოყენება, რომ დროებითი ცვლადი ერთხელ სადღაც,
მაშინ - ან თქვენ დაავალოს რაღაც რომ დროებითი ცვლადი.
ასე რომ, თუ ნებისმიერ მომენტში "," ბ temp აქვს მკაფიო ღირებულებები ან რაღაც,
მაშინ აპირებს აქვს მკაფიო ადგილებში მეხსიერება, მაგრამ ეს სიმართლეა, რომ
არსებობს მრავალი ადგილობრივი ცვლადები რომელიც მხოლოდ არსებობს რეგისტრების.
რა შემთხვევაში, არასდროს ექსპლუატაციაში შევიდა მეხსიერება და ა.შ. თქვენ არასოდეს გაყვანაა მეხსიერება.
Okay. ბოლო კითხვაზე ოდნავ მეტი.
ასე რომ აქ, ამ CS50 ელექტრო მოწყობილობების, არსებობს ლექსიკონი.
და მიზეზი არის ის, რადგან [? B66] არის მართლწერის შემოწმება, სადაც თქვენ უნდა წერა
გამოყენებით hash მაგიდები ან ლელო ან მონაცემები სტრუქტურა.
თქვენ უნდა წერა მართლწერის შემოწმება, და თქვენ უნდა გამოყენებისას ლექსიკონი გავაკეთოთ, რომ.
მაგრამ ამ პრობლემას, ჩვენ უბრალოდ აპირებს ეძებოთ თუ ერთი სიტყვა არის ლექსიკონში.
ასე რომ ნაცვლად შენახვა მთელი ლექსიკონი ზოგიერთ მონაცემები სტრუქტურა
და შემდეგ ეძებს მეტი დოკუმენტის სრულად თუ არაფერი ის misspelled,
ჩვენ გვსურს მხოლოდ მოძიების 1 სიტყვა. ასე რომ ჩვენ შეგვიძლია მხოლოდ სკანირების მთელ ლექსიკონი
და თუ ჩვენ არასოდეს მოვძებნოთ სიტყვა მთელი ლექსიკონი, მაშინ მას არ არსებობს.
თუ ჩვენ სკანირების მთელ ლექსიკონი და ნუ ვხედავ სიტყვას, მაშინ ჩვენ კარგი, ჩვენ ვერ.
იგი ამბობს, რომ ჩვენ გვინდა, რომ დაიწყოს ეძებს C-ს ფაილის დამუშავება ფუნქცია,
მას შემდეგ, რაც ჩვენ გვინდა წაიკითხოთ ლექსიკონი,
მაგრამ მისცემს მინიშნება აქ როგორც რომლის ფუნქციები უნდა იფიქრონ.
მე წერენ მათ სივრცეებს.
ასე რომ მთავარი პირობა თქვენ გსურთ შევხედოთ მათ F ღია და შემდეგ, აუცილებლად, ვ დახურულია,
რომელიც წავა დასასრულს თქვენი პროგრამა, და ვ სკანირების ვ.
თქვენ შეიძლება ასევე გამოიყენოს ვ წავიკითხე, მაგრამ როგორც ჩანს არ მინდა
იმიტომ, რომ - თქვენ არ დასრულდება მდე სჭირდება, რომ.
F სკანირების ვ არის თუ რას აპირებენ გამოყენებით სკანირებას მეტი ლექსიკონი.
და ასე რომ თქვენ არ გჭირდებათ კოდი up გადაწყვეტა, სცადეთ და როგორც ფსევდო კოდი თქვენი გზა
უნდა გადაწყვეტა, და შემდეგ ჩვენ განვიხილავთ მას.
და ფაქტობრივად, რადგან მე უკვე მისცა თქვენ ამ, თუ ნებისმიერ ტერმინალში ან თქვენი ელექტრო ს შელი,
მინდა - მე როგორც წესი - თუ არ მინახავს ჯერ, არ ვიცი, თუ რა გააკეთეთ კლასში,
მაგრამ კაცი, ასე რომ მამაკაცს გვერდებზე, საკმაოდ სასარგებლოა ეძებს საკმაოდ ბევრი ნებისმიერი ფუნქცია.
ასე რომ შემიძლია, ისევე, ადამიანი F, სკანირების ვ.
ეს არის ინფორმაცია იმის შესახებ, სკანირების ვ ოჯახის ფუნქციები.
მე შეიძლება გააკეთოს მამაკაცმა F, ღია, და რომ მივცემ ჩემს დეტალებს რომ.
ასე რომ, თუ თქვენ იცით რა ფუნქცია თქვენ იყენებთ, ან თქვენ კითხულობს კოდი
და ხედავთ ზოგიერთი ფუნქცია და თქვენ, როგორიცაა, "რას აკეთებთ?"
უბრალოდ კაცი, რომ ფუნქციის სახელი.
არსებობს რამდენიმე უცნაური მაგალითიც მოიყვანა, სადაც თქვენ შეიძლება უნდა ვთქვა
მინდა. კაცი 2, რომ ფუნქციის სახელი, ან ადამიანის 3 რომ ფუნქციის სახელი,
მაგრამ თქვენ მხოლოდ უნდა გავაკეთოთ, რომ თუ კაცი ფუნქციის სახელი არ ხდება მუშაობა პირველად.
[სტუდენტური] ასე მე კითხულობს კაცი გვერდზე ღია, მაგრამ მე ჯერ კიდევ დაბნეული, თუ როგორ გამოიყენოთ იგი და პროგრამა.
Okay. ბევრი ადამიანი, გვერდებზე ნაკლები გამოსადეგი.
ისინი უფრო გამოსადეგი თუ იცით რას აკეთებს
და მაშინ თქვენ უბრალოდ უნდა გვახსოვდეს ბრძანებით არგუმენტები ან რამე.
ან მათ მოგცემთ ზოგად მიმოხილვას, მაგრამ ზოგი მათგანი ძალიან დიდი.
მომწონს F სკანირების ვ, ასევე. ეს გაძლევთ ინფორმაციას ყველა ამ ფუნქციების
და 1 ხაზი ქვემოთ აქ ხდება ვთქვა, "F სკანირების ვ კითხულობს სიმებიანი წერტილი ან სტრიმის ჩართვა."
მაგრამ ვ გახსნა. ასე რომ, როგორ ვიყენებთ ვ ღია?
იდეა პროგრამა, რომელიც სჭირდება გავაკეთოთ ფაილის I / O ის არის, რომ
თქვენ ჯერ უნდა გახსნა ფაილი გსურთ რამ, და აუცილებლად,
წაკითხვის ნივთები რომ ფაილი და გააკეთოს პერსონალის მათთან.
F ღია არის ის, რაც ჩვენ ვიყენებთ გახსნას ფაილი.
რამ მივიღებთ უკან, ასე რომ ფაილი გვინდა გახსნას, ეს გვაძლევს -
აქ ნათქვამია "/ user / share / dict / სიტყვა."
ეს არის ფაილი, რომ ჩვენ გვინდა გავხსნათ, და გვინდა, რომ იგი უნდა გახსნას -
ჩვენ უნდა მიუთითოთ თუ არა ჩვენ გვინდა გავხსნათ ეს წაიკითხოს ან თუ გვინდა გასახსნელად დაწერა.
არსებობს რამდენიმე კომბინაციები და პერსონალი, მაგრამ ჩვენ გვინდა, რომ გახსნას ამ წასაკითხად.
ჩვენ გვინდა, რომ წაკითხვის ფაილი.
რას გვეუბნება ამ დაბრუნების? ის დააბრუნებს ფაილი ვარსკვლავი (*),
და მე უბრალოდ ნახოთ ყველაფერი ცვლადი F, ასე *,
ერთხელ, ეს მაჩვენებელი, მაგრამ ჩვენ არ გვინდა, რომ გაუმკლავდეთ პოინტერები.
შეგიძლიათ წარმოიდგინოთ, რომ F როგორც, F არის ცვლადი თქვენ აპირებს გამოიყენოს წარმოადგინოს ფაილი.
ასე რომ, თუ გსურთ წაკითხვა ფაილი, თქვენ წაკითხვის ვ.
თუ გსურთ დახურეთ ფაილი, თქვენ დახურვა ვ.
ამიტომ დასასრულს პროგრამის როდესაც ჩვენ აუცილებლად გვინდა დახურვა ფაილი, რა უნდა გავაკეთოთ?
ჩვენ გვინდა, რომ დახუროს ვ.
ახლა ბოლო ფაილი ფუნქცია, რომ ჩვენ ვაპირებთ გინდათ გამოიყენოთ არის სკანირების ვ, ვ სკანირების ვ.
და რა რომ არ არის ეს დაასკანირებს მეტი ფაილი ეძებს ნიმუში ემთხვევა.
ეძებს კაცს გვერდზე აქ, ჩვენ ვხედავთ int F სკანირების ვ, იგნორირება დაბრუნების მნიშვნელობა არის.
პირველი არგუმენტი ფაილი * ნაკადი, ასე პირველი არგუმენტი ჩვენ ვაპირებთ გვინდა უღელტეხილი ვ.
ჩვენ სკანირების მეტი ვ.
მეორე არგუმენტი არის სტრიქონში.
მე მოგცემთ სტრიქონში ახლავე.
ვფიქრობ, არ უნდა ვთქვათ, 127s \ n, ბევრი რომ ზედმეტი.
იდეა რა, რომ სტრიქონში არის, არის შეგიძლიათ წარმოიდგინოთ, რომ სკანირების ვ როგორც საპირისპირო ბეჭდვითი ვ.
ამიტომ ბეჭდვითი F, ბეჭდვითი F ჩვენ ასევე ვიყენებთ ამ ტიპის ფორმატი პარამეტრი,
მაგრამ ბეჭდვით F იმას თუ რას ვაკეთებთ არის - მოდით შევხედოთ ექვივალენტს.
ამიტომ ბეჭდვა F, და იქ ფაქტიურად ასევე F ბეჭდვითი F, სადაც პირველი არგუმენტი იქნება ვ.
როდესაც თქვენ ბეჭდვა F, შეიძლება ითქვას, მსგავსი რამ, "ბეჭდვის 127s \ n" და შემდეგ, თუ ჩვენ გაიაროს ეს რამდენიმე სტრიქონი,
ის აპირებს ბეჭდვა ეს კონტექსტი და შემდეგ ახალი ხაზი.
რა 127 საშუალებებით, მე საკმაოდ დარწმუნებული, მაგრამ მე არასდროს შეზღუდული თავს მას,
თქვენ არც უნდა ითქვას, '127 'in ბეჭდვითი F,
მაგრამ რას ნიშნავს არის ბეჭდვის პირველი 127 სიმბოლო.
ამიტომ მე საკმაოდ დარწმუნებული ვარ, რომ არის საქმე. შეგიძლიათ Google-ის რომ.
მაგრამ მომდევნო ერთი მე თითქმის პოზიტიური ეს ნიშნავს, რომ.
ასე რომ, ეს არის ბეჭდვის პირველი 127 სიმბოლოს, რასაც მოჰყვა ახალი ხაზი.
F სკანირების ვ ახლა, ნაცვლად ეძებს ცვლადი და ბეჭდვა ეს,
ის აპირებს შევხედოთ ზოგიერთი სიმებიანი, და შესანახად ნიმუში შევიდა ცვლადი.
მოდით რეალურად გამოიყენოთ სკანირების ვ in სხვადასხვა მაგალითი.
ასე ვთქვათ ჩვენ გვქონდა int, x = 4,
და გვინდოდა სტრინგის შექმნის დამზადებული - სურდა შექმნა string
რომ იყო, ეს იქნება ამუშავება გაცილებით გვიან,
რაღაც რომ ისევე 4.jpg.
ასე რომ, ეს შეიძლება იყოს პროგრამის სადაც თქვენ გექნებათ თანხა counter,
მთლიანობაში დავუპირისპირდეთ მე, და გსურთ შეინახოთ bunch of images.
ასე რომ გსურთ შეინახოთ i.jpg, სადაც მე რაღაც iteration თქვენი loop.
ასე როგორ უნდა გააკეთოს ეს კონტექსტი რომ JPEG?
თუ უნდოდა ბეჭდვა 4.jpg, შეიძლება უბრალოდ, ვამბობთ ბეჭდური F,% d.jpg,
და მაშინ ბეჭდვა რომ JPEG.
მაგრამ თუ გვინდა, რომ გადავარჩინოთ სიმებიანი 4.jpg, ჩვენ ვიყენებთ სკანირების ვ.
ამიტომ string s - რეალურად ჩვენ can't - ხასიათი, char s, მოდით წავიდეთ 100.
ასე რომ მე უბრალოდ გამოაცხადა გარკვეული მასივი 100 სიმბოლო,
და რომ სწორედ ეს ჩვენ აუცილებლად უნდა შენახვის, რომ JPEG სისტემაში
ამიტომ, ჩვენ ვაპირებთ, გამოვიყენოთ სკანირების ვ, და ფორმატი, თუ როგორ ვიტყოდი% d.jpg
რათა ბეჭდვა 4.jpg, ფორმატი ამ იქნება% d.jpg.
ასე ფორმატი% d.jpg, რაც გვინდა, შევცვალოთ% d არის x,
და ახლა გვჭირდება შესანახად რომ სიმებიანი სადღაც.
და სადაც ჩვენ ვაპირებთ შესანახად ეს კონტექსტი არის მასივი s.
ასე რომ ამის შემდეგ ხაზი კოდი, s, თუ ჩვენ ბეჭდვა F,% s ცვლადი s,
ის აპირებს ბეჭდვა 4.jpg.
ასე ვ F სკანირების არის იგივე როგორც სკანირების ვ, გარდა ახლა კი ეძებს ამ ფაილის
ამისთვის, რა მაღაზიის s.
სწორედ ბოლო არგუმენტი იქნება.
ჩვენ გვინდა შესანახად - "Scan ვ ოჯახის ფუნქციების Scans ორივე მიხედვით ფორმატი, როგორც შევეცადეთ ქვემოთ.
თუ რომელიმე ინახება წერტილები შეიძლება დაბრუნდეს - "
არა, ჩვენ შეიძლება იყოს კარგი. ნება მომეცით ვფიქრობ, მეორე.
ამიტომ სკანირების ვ არ - რა heck არის ფუნქცია, რომელიც აკეთებს, რომ?
ამიტომ სკანირების ვ არ აპირებს მიიღოს მთელი რიცხვი და ნუ dot jpg.
იგი აპირებს [mumbles].
შენახვა int ცვლადი in string int C.
რა არის ეს ცვლადი, ან რა არის ეს ფუნქცია, რომელსაც ჰქვია?
დიახ. That's - დიახ. მერე რა მე განსაზღვრის თქვენ ადრე იყო და ბეჭდვითი F,
რაც - ხდის ბევრად უფრო გრძნობა, რატომ განაცხადა, რომ ეს იყო ბევრად უფრო მოსწონს ბეჭდვითი ვ.
სკანირების ვ კვლავ სახის მოსწონს ბეჭდვითი F, მაგრამ s ბეჭდვითი ვ აპირებს სკანირების მას მეტი
და შეცვლის ცვლადები და ახლა ჩაწერს მას სიმებიანი.
იმის ნაცვლად, რომ დაბეჭდვის, ეს ინახავს მას სიმებიანი.
ასე იგნორირება, რომ მთლიანად. თქვენ შეგიძლიათ კვლავ ვფიქრობ ფორმატში specifier როგორც მოსწონს, რომ ბეჭდური ვ.
ახლა, თუ ჩვენ გვინდოდა ჯანმრთელობის სფეროში გაგვეკეთებინა 4.jpg რამ, ჩვენ ყველაფერს გააკეთებს s ბეჭდვითი F, X ამ.
მერე რა სკანირების ვ აკეთებს - როგორი იყო თქვენი კითხვა იქნება?
[სტუდენტური] მე უბრალოდ დაბნეული რა ჩვენ ვცდილობთ გავაკეთოთ უფლება აქ
რომ JPEG. შეგიძლიათ განმარტავენ, რომ 1 უფრო მეტი დრო?
ასე რომ, ეს იყო - ეს ნაკლებად relevent to F სკანირების ვ ახლა, იმედია, ეს იქნება უსიამოვნოა უკან რაღაც გზა.
მაგრამ, რაც მე თავდაპირველად აპირებს შოუ - ეს არის რეალურად პირდაპირ შესაბამის ამ [? F5]
თქვენ უნდა გამოყენებით s ბეჭდვითი F, სადაც, ვთქვათ გვაქვს 100, სურათებით,
და თქვენ გინდათ წაიკითხოთ გამოსახულება 1.jpg, 2.jpg, 3.jpg.
რათა მოხდეს ასე, თქვენ უნდა ვ ღია და შემდეგ თქვენ უნდა გაიაროს in string რომ გსურთ გახსნა.
ასე რომ ჩვენ გვინდა გავხსნათ 1.jpg; შესაქმნელად string რომ არის 1.jpg,
ვაკეთებთ s ბეჭდვითი F of% d.jpg--ჩვენ არ გააკეთოს int i = 0.
I <40 მე + +.
რათა ბეჭდვითი ვ% d.jpg, I.
ასე რომ ამის შემდეგ ხაზი, ახლა ცვალებად და array s აპირებს 1.jpg.
ან, 0.jpg, 1.jpg, 2.jpg. ასე რომ, ჩვენ შეიძლება გახსნა, თავის მხრივ, თითოეული image წასაკითხად.
ასე რომ არის რა ბეჭდვა F აკეთებს. ხედავთ რა ბეჭდვა F არის აკეთებთ?
[სტუდენტური] Okay, ამიტომ აღების - იგი ქმნის სტრინგს, something.jpg და შემდეგ ინახავს მას.
დიახ. იგი ქმნის - ეს არის კიდევ ერთი სტრიქონში, ისევე, როგორც სკანირების ვ და ბეჭდვითი F,
სადაც ეს ჩანართები ყველა ცვლადები შევიდა მეორე არგუმენტი, შესაძლოა, ჯერ როგორც ეწინააღმდეგებოდა მე.
ალბათ - ვგულისხმობ, რომ საქმე. მაგრამ რაც ბრძანებით არგუმენტები არის.
იგი აპირებს ჩადეთ ყველა ცვლადები შევიდა სტრიქონში
და შემდეგ ვინახავთ ჩვენს ბუფერული, ჩვენ მოვუწოდებთ, რომ ბუფერული, ეს სადაც ჩვენ შენახვის სიმებიანი.
ჩვენ შენახვის შიგნით s სწორად ფორმატირებული ტექსტი,% d გამო შეცვალა 4.
[სტუდენტური] ასე რომ, თუ ეს გავაკეთეთ, არის ცვლადი ვ უბრალოდ უნდა გადაიყვანა?
დიახ. ამიტომ, ჩვენ უნდა დახუროს ორიგინალური ვ ადრე აკეთებენ.
მაგრამ - და შემდეგ ასევე, თუ არ იყო ვ გახსენით აქ, მაშინ ჩვენ უნდა ვთქვა -
Yeah. მაგრამ ეს არ გახსნა ასი სხვადასხვა ფაილები.
[სტუდენტური] მაგრამ ჩვენ ვერ წვდომისათვის ან - okay.
Okay. ამიტომ სკანირების ვ, ვ სკანირების F, არის ერთგვარი იგივე იდეა,
მაგრამ ნაცვლად, ნაცვლად შენახვის ის ტექსტი, ეს უფრო მოსწონს თქვენ ახლა
აპირებს მეტი Sting და ნიმუში შესატყვისი წინააღმდეგ რომ სიმებიანი და შენახვის იწვევს ცვლადები.
თქვენ შეგიძლიათ გამოიყენოთ სკანირების ვ გარჩევის გამო რაღაც 4.jpg, და შესანახად რიცხვი 4 შევიდა თანხა int x.
რაც ჩვენ შეგვიძლია გამოვიყენოთ სკანირების ვ ამისთვის.
F სკანირების ვ გაკეთებას აპირებს, რომ ბრძანებათა ზოლს.
მე რეალურად საკმაოდ დარწმუნებული ეს რა CS50 ბიბლიოთეკა აკეთებს.
ასე რომ, როდესაც თქვენ ამბობთ, "Get int," ეს სკანირების F-ing მეტი - სკანირების ვ არის გზა თქვენ მომხმარებლის შეყვანის.
F სკანირების ვ აპირებს იგივე მაგრამ გამოყენებით ფაილის სკანირებას დასრულდა.
ასე რომ აქ, ჩვენ სკანირების ამ ფაილის.
ნიმუში ვცდილობთ ემთხვევა არის ზოგიერთი სიმებიანი რომ არის 127 სიმბოლომდე
მოჰყვა ახალი ხაზი
ამიტომ მე საკმაოდ დარწმუნებული შეგვეძლო კი უბრალოდ, ვამბობთ "ემთხვევა s," რადგან ლექსიკონი
ჩვენ არ უნდა ჰქონდეს, რომ ჩვენ გარანტირებული სიტყვას არ არის, რომ ხანგრძლივი,
და ასევე F სკანირების ვ, ვფიქრობ, იქნება შეჩერება ახალი ხაზი არა აქვს მნიშვნელობა რა.
მაგრამ ამას მოიცავს ახალი ხაზი მატჩი, და -
[სტუდენტური] თუ ჩვენ არ შედის ახალი ხაზი, რომ არა იგი იპოვის ნაწილების სიტყვა?
იგი - ყოველ - ეძებს ლექსიკონი -
ასე რომ ლექსიკონი, ეს არის ყველა ჩვენი სიტყვა.
თითოეული არის ახალი ხაზი.
სკანირების ვ აპირებს შეარჩიო ამ სიტყვის.
თუ ჩვენ არ შეიცავს ახალი ხაზი, მაშინ შესაძლებელია, რომ მომდევნო სკანირების ვ მხოლოდ წაიკითხა ახალი ხაზი.
მაგრამ მათ შორის ახალი ხაზი მაშინ იქნება უბრალოდ იგნორირება ახალი ხაზი.
მაგრამ ჩვენ არასდროს მიიღოთ ნაწილი სიტყვას, რადგან ჩვენ ყოველთვის კითხულობს მდე ახალი ხაზი, არ აქვს მნიშვნელობა რა.
[სტუდენტური] მაგრამ რა, თუ თქვენ მოძებნოთ სიტყვა "cissa," მოსწონს cissa.
იქნება ეს იპოვოს, რომ, და აცხადებენ, რომ ეს მატჩი?
ასე რომ აქ ჩვენ - ის იკითხება - ეს არის რეალურად კარგი წერტილი.
ჩვენ არასოდეს გამოყენებით მიმდინარე - სიტყვა ჩვენ ვეძებთ არის პირველი ბრძანება ხაზი არგუმენტი.
ამიტომ სტრიქონს, სიტყვა = argv 1.
ამიტომ სიმებიანი ჩვენ ვეძებთ არის argv 1.
ჩვენ არ ვეძებთ სიტყვა ყველა ჩვენს სკანირების ვ.
რას ვაკეთებდით ერთად სკანირების ვ დღითიდღე ყოველ სიტყვას ლექსიკონი,
და შემდეგ კიდევ გვაქვს, რომ სიტყვა ჩვენ ვაპირებთ გამოვიყენოთ strcmp შედარების მათ.
ჩვენ ვაპირებთ შეადაროთ ჩვენი სიტყვა და რასაც ჩვენ უბრალოდ წაიკითხა შემოსული
ასე რომ აუცილებლად, ჩვენ ვაპირებთ დასრულდება მდე აკეთებს bunch of სკანირების FS
სანამ ასე მოხდება, რომ სკანირების ვ დაბრუნდება -
იგი დაბრუნდება ერთი, რადგან მას შესაბამისი ახალი სიტყვა,
და ეს დაბრუნდება რაღაც, როგორც კი ვერ ემთხვევა სიტყვა.
ჩვენ მათ შორის მთელ ლექსიკონი, შენახვა ხაზს თითოეულ სიტყვას შევიდა ცვლადი s.
მაშინ ჩვენ შედარებით სიტყვაზე s, და თუ შედარებით == 0,
strcmp ხდება, რათა 0 თუ მატჩი გაკეთდა.
ასე რომ, თუ ეს იყო 0, მაშინ ჩვენ შეგვიძლია ბეჭდვა F, შესაბამისი,
ან სიტყვა არის ლექსიკონის, ან რასაც თქვენ გსურთ ბეჭდვა ვ.
და მაშინ - ჩვენ არ გვინდა, რომ ვ დახურვა უსასრულოდ.
ეს არის სახის რამ გვინდა გავაკეთოთ, და ჩვენ არა მხოლოდ ეძებს სიტყვას ლექსიკონი.
ამიტომ ვერ გავაკეთებთ, თუ გვინდოდა ვეძებოთ მათი ნიმუში, cissa, თქვენნაირი დაწყებამდე განაცხადა,
თუ გვინდოდა ვეძებოთ, რომ ნიმუში, მაშინ ვერ შემთხვევაში
რადგან ეს არ არის რეალურად სიტყვა, მაგრამ ერთი სიტყვა ლექსიკონი მოსდის აქვს, რომ მასში.
ასე, რომ ეს დაემთხვა ამ სიტყვის, მაგრამ ეს subset of სიტყვა არ არის სიტყვა თავად.
მაგრამ ეს არ არის, თუ როგორ იყენებთ მას; ჩვენ კითხულობს თითოეულ სიტყვას
და მაშინ შედარებით სიტყვა გვაქვს, რომ სიტყვა.
ამიტომ ჩვენ ყოველთვის შედარებით სრული სიტყვა.
მე შეგიძლიათ გააგზავნოთ out დასრულდა გადაწყვეტილებები მოგვიანებით.
ეს არის სახის თითქმის სწორად უნდა უპასუხოს, ვფიქრობ.
[სტუდენტური კომენტარი, გაუგებარია]
ოჰ, არც მე მოშორება, რომ ადრე? ჩარ s, ვფიქრობ ჩვენ განაცხადა 127 - I დაგვავიწყდეს, თუ რა არის ყველაზე დიდი.
ჩვენ უბრალოდ 128, ამიტომ ახლა s არის ხანგრძლივი საკმარისი.
ჩვენ არ გვჭირდება ბეჭდვა არაფერი.
ჩვენ ასევე ვაპირებთ სურს დახუროს ჩვენი ფაილი, და რომ უნდა იყოს დაახლოებით უფლება პასუხი.
CS50.TV