>> [მუსიკის დაკვრა]
>> Andi Peng: კეთილი კვირაში 3 მონაკვეთზე.
მადლობა, შენ, ყველა მოდის ამ ადრე დაიწყება დღეს.
ჩვენ მივიღეთ ლამაზი, პატარა ინტიმური ჯგუფი დღეს.
ასე რომ, იმედია მივიღებთ ფერი, ალბათ, ადრე,
ცოტა ადრეული დღეს.
ასე სწრაფად, რამდენიმე განცხადებები დღის წესრიგში დღეს.
დაწყებამდე, ჩვენ აპირებს უბრალოდ მეტი
რამდენიმე მოკლე ლოგისტიკური საკითხების, pset კითხვები, გამოკითხვა, რამ, როგორიცაა, რომ.
და მაშინ ჩვენ ჩაყვინთვის უფლება.
ჩვენ ვიყენებთ debugger ეწოდება GDB, რომ დაიწყოს ედავებიან ჩვენი კოდი, რომელიც დავით
განმარტა ლექცია მეორე დღეს.
ჩვენ წავიდეთ მეტი ოთხი ტიპის სახის.
ჩვენ წავიდეთ მათ საკმაოდ სწრაფად მას შემდეგ, რაც ისინი საკმაოდ ინტენსიური.
მაგრამ ვიცი, რომ ყველა სლაიდები და კოდის ყოველთვის ონლაინ რეჟიმში.
ასე რომ, შეგიძლიათ, თქვენს perusal, რომ დაბრუნდეს და შევხედოთ, რომ.
>> ჩვენ გავლა asymptotic ნოტაცია, რომელიც
არის მხოლოდ ლამაზი გზა რომ "runtimes,"
სადაც ჩვენ გვაქვს დიდი O, რომელიც დავით განმარტა ლექცია.
ჩვენ ასევე გვაქვს Omega, რომელიც არის ქვედა ზღვარი დგინდება გაშვების დროს.
და ჩვენ ვსაუბრობთ ცოტა მეტი სიღრმისეული დაკავშირებით, თუ როგორ იმ სამუშაოს.
და ბოლოს, ჩვენ წავიდეთ მეტი ორობითი ძებნა, იმიტომ, რომ ბევრი თქვენგანი, ვინც უკვე
მოხვდა თქვენს psets ალბათ იცით, რომ რომ არის საკითხი, რომელიც არის თქვენი pset.
ასე, რომ თქვენ ყველა იყოს ბედნიერი რომ ჩვენ დაფარავს ამ დღეს.
>> და ბოლოს, თქვენი პოსტი განყოფილებაში კავშირი, მე რეალურად
მარცხენა დაახლოებით 15 წუთის განმავლობაში ბოლომდე უბრალოდ მეტი
ლოგისტიკის pset3, რაიმე შეკითხვები, იქნებ ცოტა ხელმძღვანელობით, თუ გნებავთ,
სანამ ჩვენ ვიწყებთ პროგრამირების.
მოდით ცდილობენ მეშვეობით მასალა საკმაოდ სწრაფად.
და მაშინ ჩვენ შეგვიძლია გარკვეული დრო გაატაროს აღების მეტი შეკითხვა pset.
OK.
>> სწრაფად, ასე რომ მხოლოდ რამდენიმე განცხადებები დაწყებამდე გააკეთა.
პირველ რიგში, მივესალმები მიღების ეს ორი თქვენი psets.
მე მივიღე შევხედოთ your-- ჰო, მოდით კიდევ ტაში, რომ ერთი.
სინამდვილეში, მე ნამდვილად, ნამდვილად დიდი შთაბეჭდილება მოახდინა.
მე ფასდება პირველი pset თქვენ ბიჭები გასულ კვირას და ბიჭები გააკეთა წარმოუდგენელი.
>> სტილი იყო წერტილი გარდა ამისა, რამდენიმე კომენტარი.
დარწმუნდით, რომ თქვენ ყოველთვის კომენტირებისას თქვენი კოდი.
მაგრამ თქვენი psets იყო წერტილი.
და შეინახოს იგი.
და ეს კარგია კლასის მოსწავლე ვხედავთ, რომ თქვენ ბიჭები არიან აყენებს
როგორც ბევრი ძალისხმევა თქვენი სტილი და თქვენი დიზაინი თქვენი კოდი
რომ ჩვენ გვინდა, რომ თქვენ ხედავთ.
ასე რომ, მე მიდიოდა გადავუხადო დანარჩენი ერთი TAs.
>> თუმცა არსებობს რამდენიმე გამოკითხვა კითხვები
მე უბრალოდ მინდა წასვლა, რომ გახდის როგორც ჩემი ცხოვრება
და ბევრი სხვა ტასის "ცხოვრობს ცოტა ადვილია.
პირველ რიგში, მე შენიშნა ეს ბოლო კვირის განმავლობაში, თუ რამდენი
უკვე გაშვებული check50 on თქვენი კოდი, სანამ წარუდგინოს?
OK.
ასე რომ ყველას უნდა აკეთებს check50, იმიტომ საიდუმლო ჩვენ რეალურად
აწარმოებს check50 როგორც ნაწილი ჩვენი სისწორის სკრიპტები ტესტირება თქვენი კოდი.
ასე რომ, თუ თქვენი კოდი ვერ check50, ყველა ალბათობა,
ეს, ალბათ, აპირებს ვერ ჩვენი შემოწმება, ასევე.
ზოგჯერ თქვენ ბიჭები აქვს უფლება პასუხი.
მსგავსად, ხარბ, ზოგიერთი თქვენ გაქვთ უფლება, ნომრები,
თქვენ უბრალოდ ამობეჭდოთ გარკვეული დამატებითი პერსონალი.
და რომ დამატებითი პერსონალი რეალურად ვერ შემოწმება,
რადგან კომპიუტერი არ ნამდვილად ვიცი, რასაც ის ეძებს.
ასე რომ, ეს უბრალოდ აწარმოებს მეშვეობით, ხედავთ, რომ თქვენი გამომავალი არ
ემთხვევა, რაც ჩვენ ველით, რომ პასუხი უნდა იყოს, და აღსანიშნავად, რომ არასწორია.
>> და მე ვიცი, რომ მოხდა ზოგიერთი თქვენი შემთხვევებში ამ კვირაში.
ასე რომ, მე დავბრუნდი და ხელით regraded ყველას კოდი.
მომავალში, თუმცა, გთხოვთ, დარწმუნდით
რომ თქვენ გაშვებული შეამოწმეთ 50 თქვენი კოდი.
იმიტომ, რომ ეს არის ერთგვარი ტკივილი TA უნდა დაბრუნდეს და ხელით regrade
თითოეული pset ყველა ერთ, პატარა გაშვებული მაგალითად.
ასე რომ, მე არ მიიღოს off ნებისმიერი რაოდენობა.
მე ვფიქრობ, რომ აფრინდა, შესაძლოა, ერთი ან ორი დიზაინი.
მომავალში, თუმცა, თუ თქვენ ვერ check50,
რაოდენობა იქნება მიღებული დააგვირგვინა სისწორე.
>> გარდა ამისა, psets არიან იმის გამო, პარასკევს შუადღისას.
მე ვფიქრობ, რომ შვიდ-წუთიანი გვიან საშეღავათო პერიოდი, რომ ჩვენ გაძლევთ.
პერ ჰარვარდის დროს, ისინი დაშვებული შვიდი წუთის დაგვიანებით ყველაფერი.
ასე რომ, აქ იელის, ჩვენ ვიცავთ, რომ ისევე.
მაგრამ საკმაოდ ბევრი, at 12:07, თუ თქვენი pset არ არის,
ის აპირებს აღინიშნება, როგორც გვიან.
ასე რომ, მიუხედავად იმისა, რომ აღინიშნება როგორც გვიან, TA-- ვარ
ჯერ კიდევ უნდა შეფასების თქვენი psets.
ასე, რომ თქვენ ჯერ კიდევ ვხედავთ grade გამოჩნდება.
თუმცა, ვიცი, რომ ბოლოს სემესტრში,
ყველა გვიან psets იქნება მხოლოდ ავტომატურად zeroed კომპიუტერი.
>> ჩვენ ამას ვაკეთებთ, ორი მიზეზის გამო.
ერთ-ერთი, ზოგჯერ მივიღებთ ბოდიში, როგორიცაა დეკანის excuses,
მოგვიანებით, რომ მე არ ვიცი, არავის გაუკეთებია.
ასე რომ, ჩვენ გვსურს დავრწმუნდეთ, რომ ჩვენ შეფასების ყველაფერი მხოლოდ იმ შემთხვევაში, მოსწონს, მე
დაკარგული დეკანის საბაბი.
და მეორე, შენარჩუნება გონება, თქვენ მაინც
ჩამოაგდეს ერთი pset, რომ აქვს სრული ფარგლებს რაოდენობა.
ასე რომ, ჩვენ გვსურს grade ყველა თქვენი psets მხოლოდ
დარწმუნდით, რომ თქვენი ფარგლებს ს იქ და თქვენ ცდილობს მათ.
ასე რომ, მაშინაც კი, თუ გვიან, თქვენ ჯერ კრედიტი ფარგლებს რაოდენობა, ვფიქრობ.
>> ასე რომ, მორალური ამბავი, რომ დარწმუნებული ვარ, თქვენი psets არიან დროში.
და თუ ისინი არ არიან დროში, ვიცი, რომ ეს არ არის დიდი.
ჰო, სანამ გადავა, ვინმეს აქვს რაიმე შეკითხვები pset კავშირი?
ჰო.
>> აუდიტორია: ხომ არ ამბობენ, ჩვენ შეიძლება ვარდნა ერთ psets?
>> Andi Peng: ჰო.
ასე რომ, ცხრა psets საერთო მეტი კურსი სემესტრი.
და თუ თქვენ გაქვთ ფარგლებში points-- ასე ფარგლებს უბრალოდ,
საკმაოდ ბევრი, თქვენ ცდილობს პრობლემა, თქვენ აყენებს დროს,
თქვენ აჩვენებს, რომ თქვენ აჩვენა თქვენ წაიკითხოთ სპეც.
ეს არის საკმაოდ ბევრი ფარგლებს.
და თუ თქვენ ასრულებს ფარგლებს რაოდენობა,
შეიძლება ვარდნა ყველაზე დაბალი ყოველი სრულ სპექტრს.
ასე რომ, თქვენი უპირატესობა დასრულებას და ცდილობენ ყოველ pset.
>> მაშინაც კი, upload-- თუ არცერთი მათ მუშაობა, ატვირთეთ მათ ყველა.
და მაშინ ჩვენ იმედია შეძლებს გადმოგცეთ ზოგიერთი იმ რაოდენობა უკან.
ზემოთ.
ნებისმიერი სხვა კითხვები?
შესანიშნავი.
>> მეორე, ოფისი საათთან რამდენიმე სწრაფი შენიშვნები შესახებ საათებში.
ასე რომ, პირველი, მოდის, ადრე კვირაში.
არავინ არ არის ოდესმე სამუშაო საათებში ორშაბათობით.
Christabel მოვიდა სამუშაო საათებში ღამით.
ჰო, Christabel.
და რა გვაქვს ოფისი საათი ღამით, Christabel?
>> აუდიტორია: ჩვენ გვქონდა ნაყინი.
>> Andi Peng: ასე რომ უფლება, ჩვენ გვქონდა ნაყინის ოფისში საათი ღამით.
მიუხედავად იმისა, რომ მე ვერ დაგპირდებით, რომ ჩვენ გვექნება ნაყინის ოფისში საათი
ყოველ კვირას, რაც მე გპირდებით ის არის, რომ არ იქნება მნიშვნელოვნად
უკეთესად რომ TA რაციონი.
ისევე, როგორც ნათქვამია, ეს როგორც სამი ერთი.
ამასთან, განსხვავებით, რომ ერთად ხუთშაბათი, თქვენ მოხვდით შესახებ 150
ნამდვილად ხაზი გაუსვა, ბავშვები და ნაყინი.
და ეს უბრალოდ არ არის პროდუქტიული ვინმეს.
ასე რომ, მორალური ამბავი, მოდის დასაწყისში საათებში და კარგი რამ
მოხდება.
>> გარდა ამისა, მოვიდა მომზადებული შეკითხვები.
თქვენ იცით?
მიუხედავად იმისა, რა TAs, მე ვფიქრობ, უკვე განაცხადა, რომ,
ჩვენ უკვე მიღების რამდენიმე სტუდენტები ვინც მოდის ხუთშაბათს, ისევე, 10:50
არ წამიკითხავს სპეც დაემსგავსო დამეხმაროთ, დამეხმარება.
სამწუხაროდ, იმ ეტაპზე, არ არსებობს დიდად არ შეგვიძლია გავაკეთოთ, რათა დაგეხმაროთ.
ასე რომ გთხოვთ მოდის ადრე კვირაში.
მოდი ადრეულ საათებში.
მოვიდა მომზადებული შეკითხვები.
დარწმუნდით, რომ თქვენ, როგორც სტუდენტი, სად
თქვენ უნდა იყოს ისე, რომ TAs შეიძლება უხელმძღვანელებს თქვენ გასწვრივ,
რაც ოფისში საათი უნდა იყოს გამოყოფილი.
>> მეორე, მე ვიცი, პროფესორები მინდა გაოცება ტესტები.
მე მქონდა პროფესორი იმ როგორიცაა, yo, სხვათა შორის,
გვახსოვდეს, რომ შუალედური თქვენ გაქვთ მომავალი ორშაბათიდან.
ჰო, მე არ ვიცი, რომ შუალედური.
ამიტომ, მე ვაპირებ უნდა იყოს, რომ TA რომ შეგახსენებთ, რომ ყველა ინტელექტუალური
0- იმიტომ, რომ თქვენ იცით, რომ ჩვენ CS.
ახლა, რომ ჩვენ გავაკეთეთ კოლექტორები, თქვენ ამიტომ ეს ინტელექტუალური 0, არა ვიქტორინა 1, eh?
OK.
ოჰ, მე მივიღე რამდენიმე chuckles, რომ ერთი.
OK.
>> ასე რომ, ინტელექტუალური 0 იქნება 14 ოქტომბერს, თუ თქვენ ამ ორშაბათი-ოთხშაბათი განყოფილებაში
და 15 ოქტომბერს, თუ თქვენ სამშაბათი-ხუთშაბათი განყოფილებაში.
ეს არ ეხება იმ თქვენ, ჰარვარდის
who-- მე ვფიქრობ, თქვენ ყველა იყოს აღების თქვენი ტესტებში მე -14.
>> ასე რომ, yeah, მომავალ კვირას, თუ დავით, ლექცია, მიდის,
ჰო, ისე, რომ ვიქტორინა მომავალ კვირას, თქვენ ყველა
არ იქნება შოკირებულია, რადგან თქვენ მოვიდა განყოფილებაში
და თქვენ იცით, რომ თქვენი ვიქტორინა 0 ორ კვირაში.
და გვექნება მიმოხილვა სხდომებს და ყველაფერი.
ასე რომ, არ აწუხებს მას ეშინია, რომ.
ნებისმიერი კითხვები ადრე რაიმე შეკითხვები ყველა დაკავშირებით საორგანიზაციო საკითხები,
შეფასების, საათებში, სექციები?
ჰო.
>> აუდიტორია: ასე ვიქტორინა არის იქნება დროს ლექციას?
>> Andi Peng: ჰო.
ასე რომ, ინტელექტუალური, მე ვფიქრობ, 60 წუთის გამოყოფილი, რომ დრო სლოტი
ის, რომ თქვენ უბრალოდ მიიღოს აუდიტორია.
ასე რომ თქვენ არ უნდა მოვიდეს შესახებ, როგორიცაა, შემთხვევითი 7:00 PM.
ეს ყველაფერი კარგი.
ჰო.
ზემოთ.
>> ყველა უფლება.
ასე რომ, ჩვენ ვაპირებთ დანერგვა კონცეფცია თქვენ
ამ კვირაში, რომ დავით უკვე სახის საქართველოს შეეხო ლექცია გასულ კვირას.
ეს ე.წ. GDB.
და რამდენი, ხოლო რა თქმა უნდა, წერილობით თქვენი psets,
არ შენიშნა დიდი ღილაკს, რომელიც ამბობს "გამართვის" ზედა თქვენი IDE?
OK.
ასე რომ, ახლა ჩვენ რეალურად მიიღონ, ჩასწვდეს საიდუმლო რა ღილაკს რომ რეალურად
აკეთებს.
და მე გაძლევთ გარანტიას, რომ ეს არის ლამაზი, ლამაზი რამ.
>> ასე რომ, დღემდე, მე ვფიქრობ, იქ იყო ორი რამ
სტუდენტები არ ყოფილა, როგორც წესი, აკეთებს, როდესაც გამართვის psets.
ერთ-ერთი, ისინი ან დაამატოთ printf () - ასე რომ, ყოველ რამდენიმე ხაზები,
ისინი დაამატოთ printf () - აი, რა არის ეს ცვლადი?
აი, რა არის ეს ცვლადი, ახლა და თქვენ სახის ვხედავ პროგრესიით
თქვენი კოდი როგორც მართავს.
ან მეორე მეთოდი ბავშვებს არის რომ ისინი უბრალოდ წერენ მთელი რამ
და მერე, როგორც ეს ბოლოს.
იმედია მუშაობს.
მე გაძლევთ გარანტიას, GDB უკეთესია ვიდრე ორივე იმ მეთოდებს.
ჰო.
ასე რომ, ეს იქნება თქვენი ახალი საუკეთესო მეგობარი.
იმიტომ, რომ ეს ლამაზი რამ, რომ ვიზუალურად აჩვენებს ორივე
რა თქვენი კოდი აკეთებს აქვს კონკრეტული წერტილი
ისევე, როგორც ის, რაც ყველა თქვენი ცვლადების ტარების,
მსგავსი იმისა, რაც მათი ღირებულებები, იმ კონკრეტული წერტილი.
და ამ გზით, თქვენ ნამდვილად მითითებული breakpoints თქვენს კოდი.
თქვენ შეგიძლიათ აწარმოებს მეშვეობით ხაზს.
და GDB უბრალოდ უნდა for თქვენ, ნაჩვენები თქვენ,
რა ყველა თქვენი ცვლადები არიან, რას აკეთებენ,
რა ხდება კოდი.
და ასეთ შემთხვევაში, ეს იმდენად უფრო ადვილია,
რა ხდება ნაცვლად printf-ing ან წერილობით ქვემოთ თქვენი განცხადებები.
>> ასე რომ, ჩვენ ყველაფერს გავაკეთებთ მაგალითია შემდეგ.
ასე რომ, ეს, როგორც ჩანს, ცოტა აბსტრაქტული.
არ აწუხებს, ჩვენ ყველაფერს გავაკეთებთ მაგალითები.
ასე რომ, არსებითად, სამი უდიდესი, ყველაზე გამოიყენება ფუნქცია დაგჭირდებათ GDB
არის შემდეგი, ჩამოდი, და ნაბიჯი შევიდა ღილაკებით.
მე ვაპირებ უხელმძღვანელებს გადასცა არსებობს, ფაქტობრივად, ახლა.
>> ასე რომ, შეგიძლიათ ბიჭები ყველა ვხედავთ, რომ ან უნდა ზომით ცოტა?
უკან, ხედავთ, რომ?
თუ ზომით?
უბრალოდ ცოტა?
OK, მაგარი.
იქ ჩვენ წავიდეთ.
OK.
>> ასე რომ, მე, აქ, ჩემი განხორციელების ხარბ.
მიუხედავად იმისა, რომ ბევრი თქვენგანი ბიჭები დაწერა ხარბ ხოლო loop form--, რომ
არის იდეალურად მისაღები გზა უნდა გააკეთოს, it-- სხვა გზა ამის გაკეთება, უბრალოდ,
გათიშე modulo.
იმის გამო, რომ მაშინ შეგიძლიათ თქვენი ღირებულება და შემდეგ თქვენი დარჩენილი.
და მაშინ თქვენ შეგიძლიათ უბრალოდ რჩეულებში ყველა ერთად.
არა ლოგიკა, რასაც მე ვაკეთებ აქ აზრი, რომ ყველასთვის,
სანამ ჩვენ ვიწყებთ?
სახის?
ზემოთ.
შესანიშნავი.
ეს არის საკმაოდ sexy ცალი კოდი, მე ვიტყოდი.
როგორც ვთქვი, დავით, ლექცია, შემდეგ კი,
თქვენ ყველა დაიწყება ვხედავთ კოდი როგორც, რომ რაღაც ლამაზი.
და ზოგჯერ, როდესაც ხედავთ ლამაზი კოდი, რომ ასეთი მშვენიერი განცდა.
>> ასე რომ, თუმცა, მიუხედავად იმისა, რომ ეს კოდი არის ძალიან ლამაზი, ეს არ იმუშავებს.
მოდით აწარმოებს check50 ამ.
შეამოწმეთ 50 20-- oop.
2?
ის არის, რომ pset2?
ჰო.
ოჰ, pset1.
OK.
ასე რომ, ჩვენ აწარმოებს check50.
>> და როგორც თქვენ ბიჭებს აქ, ეს ვერ შესძლო რამდენიმე შემთხვევა.
ხოლო ზოგიერთი თქვენ, რა თქმა უნდა, ამით თქვენი პრობლემა კომპლექტი,
თქვენ, როგორიცაა, ah, რატომ არ არის ეს სამუშაო.
რატომ არის სამუშაო ზოგიერთი ღირებულებები, მაგრამ არა სხვები?
ისე, GDB აპირებს დაგეხმარებათ ფიგურა გაირკვეს, რატომ იმ საშუალებებით არ მუშაობს.
>> OK.
ასე რომ, ვნახოთ, ერთ-ერთი ამოწმებს მე ვერ check50
იყო შეყვანილი ღირებულება 0.41.
ასე რომ, სწორი პასუხი, რომ თქვენ უნდა მისაღებად არის 4.
არამედ ის, რასაც მე დაბეჭდვისას არის 3-n, რაც არასწორია.
მოდით უბრალოდ გაუშვით ეს ხელით, ისევე დარწმუნდით, რომ check50 მუშაობს.
მოდით გავაკეთოთ ./greedy.
Oops, I უნდა მიიღოს ხარბ.
იქ ჩვენ წავიდეთ.
ახლა ./greedy.
>> რამდენად კუთვნილს?
მოდით გავაკეთოთ 0.41.
და yep, ჩვენ ვხედავთ აქ რომ ის outputting 3
როდესაც სწორი პასუხი, ფაქტობრივად, უნდა იყოს 4.
ასე რომ, მოდით შეიყვანოთ GDB და ვნახოთ, როგორ შეიძლება წავიდეთ შესახებ აფიქსირებს ამ პრობლემას.
>> ასე რომ, პირველი ნაბიჯი ყოველთვის debugging თქვენი კოდი
არის მითითებული breakpoint, ან პუნქტი, რომელიც თქვენ
მინდა კომპიუტერი ან debugger დაიწყოს ეძებს.
ასე რომ, თუ თქვენ ნამდვილად არ იცით, რა თქვენი პრობლემა ის არის,
როგორც წესი, ტიპიური, რაც ჩვენ გვინდა გავაკეთოთ არის მითითებული ჩვენი breakpoint დროს ძირითადი.
ასე რომ, თუ ბიჭები ვხედავთ ამ წითელ ღილაკს უფლება არსებობს,
yep, რომელიც ჩემთვის შექმნის breakpoint ძირითადი ფუნქცია.
მე დააჭირეთ რომ.
>> და მერე შეიძლება ახვიდეთ ჩემი Debug ღილაკს.
მე მოხვდა, რომ ღილაკს.
ნება მომეცით zoom უკან, თუ არ შემიძლია.
იქ ჩვენ წავიდეთ.
ასე რომ, ჩვენ, აქ, პანელის მარჯვენა.
მე ბოდიში, ბიჭები უკან, თქვენ ვერ ვხედავ ნამდვილად კარგად.
მაგრამ არსებითად, ყველა ეს უფლება პანელი აკეთებს
შენახვა ტრეკზე როგორც მონიშნულია ხაზი, რომელიც არის ხაზი კოდი
რომ კომპიუტერი მოქმედი, ისევე როგორც ყველა თქვენი ცვლადები
ქვემოთ აქ.
>> ასე, რომ თქვენ მოხვდით ცენტი, მონეტები, n, ყველა განაცხადა, რომ სხვადასხვა რამ
ამ ეტაპზე.
არ აწუხებს, იმიტომ, რომ ჩვენ არ რეალურად ინიციალიზაცია მათ ნებისმიერ ცვლადები ამჟამად.
ასე რომ, თქვენს კომპიუტერში, თქვენი კომპიუტერული უბრალოდ ხედავს,
oh, 32767 იყო გამოყენებული ბოლოს ფუნქცია რომ მეხსიერების სივრცე ჩემს კომპიუტერში.
და ასე რომ, სადაც ცენტი ამჟამად.
მაგრამ არ არის, რომ ერთხელ თქვენ აწარმოებს კოდი, ეს უნდა გახდეს initialized.
>> მოდით გავლა, ხაზი ხაზი, თუ რა ხდება აქ.
OK.
ასე რომ, აქ არის სამი ღილაკები, რომ მე უბრალოდ განმარტა.
თქვენ გაქვთ თამაში, ან Run ფუნქცია, ღილაკს, თქვენ გაქვთ ნაბიჯი მეტი ღილაკს,
და თქვენ ასევე აქვს ნაბიჯი შევიდა ღილაკს.
და არსებითად, სამივე მათ უბრალოდ გავლა თქვენი კოდი
და სხვადასხვა რამ.
>> ასე რომ, როგორც წესი, როცა თქვენ გამართვის, ჩვენ არ გვინდა, რომ უბრალოდ მოხვდა თამაში,
იმიტომ, რომ თამაში იქნება მხოლოდ აწარმოებს თქვენი კოდი ბოლომდე იგი.
და მაშინ, ფაქტობრივად, არ იცით, რა თქვენი პრობლემა
თუ არ შეიქმნა მრავალი breakpoints.
თუ თქვენ მითითებული მრავალჯერადი breakpoints, ეს იქნება მხოლოდ ავტომატურად
აწარმოებს ერთი breakpoint, შემდეგი, მომდევნო.
მაგრამ ამ შემთხვევაში ჩვენ მხოლოდ ის, რომ ერთი, იმიტომ, რომ ჩვენ
მინდა მუშაობა ჩვენი გზა ზემოდან ქვემოთ ბოლოში.
ამიტომ, ჩვენ ვაპირებთ იგნორირება, რომ ღილაკს ახლავე მიზნით ამ პროგრამის.
>> ასე რომ, ნაბიჯი მეტი ფუნქცია მხოლოდ ნაბიჯები მეტი თითოეული ხაზი
და ეუბნება, თუ რა კომპიუტერი აკეთებს.
ნაბიჯი შევიდა ფუნქცია მიდის შევიდა ფაქტობრივი ფუნქცია
რომ არის თქვენი ხაზი კოდი.
ასე მაგალითად, როგორიცაა printf (), რომ არის ფუნქცია, არა?
თუ მინდოდა ფიზიკურად ნაბიჯი შევიდა printf () ფუნქცია,
მე რეალურად წასვლას ნაჭერი კოდი, სადაც printf () დაიწერა და ვნახოთ
რა ხდება იქ.
>> მაგრამ, როგორც წესი, ვივარაუდოთ, რომ კოდი, რომელიც ჩვენ გაძლევთ მუშაობს.
ჩვენ ვივარაუდოთ printf () მუშაობს.
უნდა ვივარაუდოთ, რომ GetInt () მუშაობს.
ასე რომ, არ არის საჭირო ნაბიჯ შევიდა იმ ფუნქციებს.
მაგრამ თუ ფუნქცია რომ წერთ თავს
რომ გსურთ შემოწმება გაირკვეს, თუ რა ხდება,
თქვენ სურს გადადგას რომ ფუნქცია.
>> ასე რომ, ახლა ჩვენ უბრალოდ აპირებს გადადგას მეტი ეს კოდი.
ასე რომ, ვნახოთ.
ოჰ, ბეჭდვითი, "Oh hai, როგორ ბევრი ცვლილება კუთვნილს? "
ჩვენ არ მაინტერესებს.
ჩვენ ვიცით, რომ ის მუშაობს, ასე რომ, ჩვენ ნაბიჯ მას.
>> ასე რომ, ო, რომელიც ჩვენი float, რომ ჩვენ initialized-- ან declared--
ზედა, ჩვენ ახლა რითაც, რომ GetFloat ().
მოდით ნაბიჯი მეტი რომ.
და ვხედავთ, ქვედა აქ, პროგრამა
რითაც ჩემთვის შეყვანის მნიშვნელობა.
მოდით შეყვანის ღირებულება გვინდა, შესამოწმებლად აქ, რომელიც არის 0.41.
შესანიშნავი.
>> ასე რომ, ახლა N-- თქვენ ბიჭები ვხედავ აქ, bottom-- ეს
stored-- იმიტომ, რომ ჩვენ არ მრგვალდება არ არის, ეს
ინახება ამ, როგორიცაა გიგანტური float, რომელიც 0,4099999996,
რომელიც ახლოს არის საკმარისი იმისათვის, რომ ჩვენი მიზნებისათვის, ახლა, რომ 0.41.
და მაშინ ვნახავთ, მოგვიანებით, როგორც ჩვენ გაგრძელდება სტეპინგზე მეტი პროგრამა,
მას შემდეგ, რაც აქ, n გახდა მომრგვალებული და ცენტი გახდა 41.
შესანიშნავი.
ასე რომ, ჩვენ ვიცით, რომ ჩვენი დამრგვალება სამუშაო.
ჩვენ ვიცით, რომ ჩვენ გვაქვს სწორი რაოდენობის ცენტი,
ასე რომ, ჩვენ ვიცით, რომ ეს ნამდვილად არ არის პრობლემა.
>> ჩვენ გავაგრძელებთ სტეპინგზე მე ამ პროგრამაში.
ჩვენ აქ.
და ასე შემდეგ, ეს ხაზი კოდი, ჩვენ უნდა იცოდეს, რამდენი მეოთხედი გვაქვს.
ჩვენ გადადგას მეტი.
თქვენ ხედავთ, რომ ჩვენ, ფაქტობრივად, აქვს ერთი კვარტალში, რადგან ჩვენ ვაკლებდით 25
ჩვენი თავდაპირველი ღირებულება 41.
და ჩვენ გვაქვს 16 მარცხენა ჩვენი ცენტი.
>> ამჯამად ყველას გვესმის, თუ როგორ პროგრამა სტეპინგზე მეშვეობით
და რატომ ცენტი გახდა 16 და ამიტომ, ახლა, მონეტები გახდა 1?
ყველას შემდეგ, რომ ლოგიკა?
ზემოთ.
ასე რომ, როგორც ამ ეტაპზე, პროგრამის სამუშაო, არა?
ჩვენ ვიცით, ის აკეთებს ზუსტად ის, რაც ჩვენ გვინდა, რომ ეს.
ჩვენ პრაქტიკულად არ უნდა ამობეჭდოთ, oh, რა
არის ცენტი, ამ ეტაპზე, რა არის მონეტები ამ ეტაპზე.
>> ჩვენ ვაგრძელებთ მეშვეობით პროგრამა.
ჩამოდი.
ზემოთ.
ჩვენ წავიდეთ მეტი dimes.
შესანიშნავი.
ჩვენ ვხედავთ, რომ ის მიღებული off $ 0.10 dime.
და ახლა ჩვენ გვაქვს ორი მონეტა.
ეს არის სწორი.
>> ჩვენ წავიდეთ მეტი pennies და ჩვენ ვხედავთ, რომ ჩვენ მივიღეთ დარჩა ცენტი.
Hmm, რომ უცნაურია.
Up აქ პროგრამა, მე უნდა არ აკლდება ჩემი pennies.
ალბათ მე უბრალოდ არ იყო აკეთებს, რომ ხაზი.
და ვაი, თქვენ ხედავთ, აქ, რადგან ჩვენ ვიცით,
რომ ჩვენ სტეპინგზე მეშვეობით ხაზები 32 და 33,
ეს არის ის, სადაც ჩვენი პროგრამა არასწორად ჰქონდა ცვლადები აწარმოებს.
ასე რომ, ჩვენ შეგვიძლია შევხედოთ და ვნახოთ, რა, მე გამოკლება ცენტი აქ,
მაგრამ მე არ ვარ რეალურად და დასძინა, რომ ჩემი მონეტა ღირებულება.
მე დასძინა ცენტი.
და მე არ მინდა, რომ რჩეულებში ცენტი, მინდა ვთქვა, რომ მონეტები.
ასე რომ, თუ შევცვლით, რომ მონეტები, ჩვენ მივიღეთ სამუშაო პროგრამა.
შემიძლია აწარმოებს check50.
შეგიძლიათ უბრალოდ გაითიშება GDB უფლება აქ და შემდეგ აწარმოებს check50 ერთხელ.
მე შეიძლება მხოლოდ ამის გაკეთება.
მე უნდა მიიღოს ხარბ.
0.41.
და აქ, ეს არის ბეჭდვის out სწორი პასუხი.
>> ასე რომ, როგორც თქვენ ბიჭები ხედავთ, GDB არის ძალიან ძლიერი ინსტრუმენტი
როდესაც ჩვენ გვაქვს იმდენად კოდი მიმდინარეობს და ამდენი ცვლადები
რომ რთულია ჩვენთვის, ადამიანის, შენარჩუნება სიმღერა.
კომპიუტერული, ამ GDB debugger, აქვს უნარი
შენარჩუნება სიმღერა ყველაფერი.
ვიცი, Visionaire, თქვენ ბიჭები ალბათ შეიძლება არ მოხვდა რამდენიმე სეგმენტაცია ხარვეზებით
იმიტომ, რომ თქვენ გაშვებული ფარგლებს გარეთ თქვენი მასივი.
მაგალითში კეისრის, რომ ზუსტად ის, რაც მე ხორციელდება აქ.
>> ასე რომ დამავიწყდა შემოწმება რა მოხდება, თუ მე
არ აქვს ორი ბრძანება ხაზი არგუმენტები.
მე უბრალოდ არ დააყენა, რომ ქვითარი.
ასე რომ, თუ მე აწარმოებს Debug-- I მითითებული ჩემი breakpoint უფლება არსებობს.
მე აწარმოებს Debug.
>> OK.
ჰო.
ასე რომ, რეალურად, GDB მოსალოდნელი იყო არ მითხრა,
იყო სეგმენტაცია ბრალია არსებობს.
მე არ ვიცი, რა ხდებოდა უფლება არსებობს, მაგრამ როცა გაიქცა,
იგი მუშაობდა.
როდესაც თქვენ აწარმოებს ხაზების კოდი მეშვეობით და GDB შეიძლება მხოლოდ მოულოდნელად დატოვა თქვენ,
უფროსი და შევხედოთ რა წითელი შეცდომა.
ეს გეტყვით, Hey, თქვენ ჰქონდა სეგმენტაცია ბრალია,
რაც იმას ნიშნავს, რომ თქვენ ცდილობდა ხელმისაწვდომობა ფართი მასივი, რომ არ არსებობდა.
ჰო.
>> ასე რომ, მომდევნო პრობლემა მითითებული ამ კვირაში, თქვენ ბიჭები
ალბათ ბევრი ცვლადები მცურავი გარშემო.
თქვენ არ იქნება დარწმუნებული, თუ რა ისინი ნიშნავს გარკვეულ ეტაპზე.
ასე რომ, GDB ნამდვილად დაგეხმარებათ მჭიდროდაა გაირკვეს, თუ რა ისინი ყველა გაუთანაბრდა
და რომ ნახოს, რომ ვიზუალურად.
არის ვინმე დაბნეული, თუ როგორ რომელიმე რომ მუშაობდა?
ზემოთ.
ყველა უფლება.
ასე რომ, მას შემდეგ, რაც, ჩვენ ვართ ვაპირებთ ჩაყვინთვის მარჯვენა
შევიდა ოთხი სხვადასხვა სახის ჯიშები ამ კვირაში.
რამდენი თქვენგანი, პირველი ყოვლისა, სანამ ჩვენ ვიწყებთ,
წავიკითხე მთელი სპეც pset3?
OK.
მე ამაყი ვარ, თქვენ ბიჭები.
სწორედ ისევე, როგორც ნახევარი კლასი, რომელიც გაცილებით მეტია, ვიდრე ბოლო დროს.
>> ასე რომ, დიდი, რადგან, როდესაც ჩვენ ვსაუბრობთ შინაარსი
in ლექცია და ვწუხვარ, ამ სექციაში მომწონს
ეხება ბევრი რომ უკან რა pset არის
და როგორ გსურთ განახორციელოს, რომ თქვენი pset.
ასე რომ, თუ მოდის, რომელსაც წაკითხვის Spec, ის ყველაფერს
იქნება ბევრი ადვილია თქვენ უნდა გვესმოდეს, რა მე ვსაუბრობ, როცა ამბობენ,
oh hey, ეს შეიძლება იყოს მართლაც კარგი განახორციელოს ამ სახის.
ასე რომ, იმ თქვენ, რომლებიც არ წაიკითხა სპეც ვიცით, რომ, როგორც ნაწილი თქვენი pset,
თქვენ აპირებთ უნდა წერენ ტიპის სახის.
ასე რომ, ეს შეიძლება იყოს ძალიან სასარგებლო ბევრი თქვენგანი დღეს.
>> ასე რომ, ჩვენ დავიწყებთ, არსებითად, ყველაზე მარტივი ტიპის
სახის, შერჩევა ჯიშია.
ტიპიური ალგორითმი როგორ ჩვენ მინდა წასვლა ამ
is-- დავით გაიარა ამ ყველა ლექცია, ასე რომ მე სწრაფად გადაადგილება
აქ არსებითად, თქვენ მასივი ღირებულებებს.
და მაშინ თქვენთვის პატარა არასორტირებული მნიშვნელობა
და სვოპ, რომ ღირებულება პირველი დაუხარისხებელი ღირებულება.
და მაშინ უბრალოდ შეინახოს იმეორებს დანარჩენ თქვენს სიაში.
>> აქ არის ვიზუალური განმარტება როგორ, რომ იმუშავებს.
ასე მაგალითად, თუ ჩვენ უნდა დაიწყოს მასივი ხუთ ელემენტები, ინდექსი
0-დან 4, 3, 5, 2, 6 და 4 ღირებულებები განთავსებული მასივი ახლავე
ჩვენ უბრალოდ აპირებს ვივარაუდოთ, რომ ისინი ყველა დაუხარისხებელი
იმიტომ, რომ ჩვენ არ ტესტირება სხვაგვარად.
>> ასე რომ, როგორ შერჩევა ერთგვარი სამუშაო არის ის, რომ პირველი
აწარმოებს მეშვეობით მთლიანად არასორტირებული მასივი.
ეს იქნებოდა გამოარჩიეთ პატარა მნიშვნელობა.
ამ შემთხვევაში, 3, მარჯვენა ახლა, არის პატარა.
იგი იღებს 5.
Nope, 5 არ არის უფრო მეტი ვიდრე ან ბოდიში, არ არის ნაკლები ვიდრე 3.
ასე რომ, მინიმალური ღირებულება კვლავ 3.
და შემდეგ თქვენ მიიღებთ 2.
კომპიუტერული ხედავს, OH, 2 ნაკლებია, ვიდრე 3.
2 უნდა იყოს მინიმალური ღირებულება.
ასე რომ, 2 გაცვლებს, რომ პირველი მნიშვნელობა.
>> ასე რომ, მას შემდეგ, რაც ერთ უღელტეხილზე, ჩვენ მართლაც ვხედავთ რომ 2 და 3 გაცვალეს.
და ჩვენ უბრალოდ აპირებს გააგრძელოს აკეთებს ეს კიდევ ერთხელ დანარჩენი მასივი.
ასე რომ, ჩვენ ვაპირებთ, რომ უბრალოდ აწარმოებს მეშვეობით ბოლო ოთხი ინდექსები მასივი.
ჩვენ დავინახავთ, რომ 3 შემდეგი მინიმალური ღირებულება.
ასე რომ, ჩვენ ვაპირებთ, რომ სვოპ რომ 4.
და მაშინ ჩვენ უბრალოდ აპირებს შეინარჩუნოს გადის, სანამ, საბოლოოდ,
მისაღებად დახარისხებული მასივი, რომელიც 2, 3, 4, 5, 6 და ყველა დახარისხებული.
ამჯამად ყველას გვესმის ლოგიკა თუ როგორ შერჩევის დალაგების მუშაობს?
>> თქვენ უბრალოდ უნდა გარკვეული მინიმალური ღირებულება.
თქვენ შენახვა სიმღერა, თუ რა არის.
და როდესაც თქვენ მას, თქვენ სვოპ ის პირველი ღირებულების მასივი
ან, არ არის პირველი value-- შემდეგი მნიშვნელობა მასივი.
ზემოთ.
>> ასე რომ, როგორც თქვენ ბიჭები სახის დაინახა მოკლე glimpse,
ჩვენ ვაპირებთ, რომ Pseudocode გარეთ.
ასე რომ, თუ თქვენ ბიჭები უკან გვინდა შექმნან ჯგუფი, ყველას მაგიდასთან
შეუძლია შექმნას პატარა პარტნიორი, მე ვაპირებ რათა თქვენ ბიჭები მოსწონს სამი წუთის
უბრალოდ გაიგო მეშვეობით ლოგიკა, ინგლისურ,
როგორ შეიძლება შეძლებს განახორციელოს pseudocode დაწერა შერჩევა ერთგვარი.
და იქ Candy.
გთხოვთ ამუშავება და მიიღოთ კამფეტი.
თუ თქვენ უკან და გსურთ candy, შემიძლია სახიფათოა candy თქვენ.
სინამდვილეში, ამის you-- მაგარი.
ბოდიში.
OK.
>> ასე რომ, თუ ჩვენ გვინდა, რომ, როგორც კლასი, ჩაწერის pseudocode
ამისთვის, თუ როგორ შეიძლება მივუდგეთ ეს პრობლემა, უბრალოდ ვგრძნობ უფასოდ.
მე უბრალოდ გარშემო და, იმისათვის, სთხოვეთ ჯგუფებს
მომდევნო ხაზი ის, რაც ჩვენ უნდა აკეთებს.
ასე რომ, თუ თქვენ ბიჭები მინდა, რომ დაიწყოს off, რა არის პირველი რამ,
უნდა გავაკეთოთ, როდესაც თქვენ ცდილობთ განახორციელოს გზით გადაჭრის ამ პროგრამის
შერჩევით დასალაგებლად სიაში?
მოდით, უბრალოდ, ჩვენ ვივარაუდოთ, მასივი, ყველა უფლება?
>> აუდიტორია: თქვენ მინდა, რომ შევქმნათ ერთგვარი [INAUDIBLE], რომ თქვენ
გადის თქვენი მთელი მასივი.
>> Andi Peng: მარჯვენა.
ასე რომ, თქვენ აპირებს გვინდა iterate ყოველი სივრცე, არა?
ასე რომ, დიდი.
თუ თქვენ ბიჭები მინდა მომეცი შემდეგი ხაზი ჰო, წელს დაბრუნდა.
>> აუდიტორია: შეამოწმეთ მათ ყველა პატარა.
>> Andi Peng: იქ ჩვენ წავიდეთ.
ასე რომ, ჩვენ გვინდა გავლა და შემოწმება ვნახოთ, რა მინიმალური ღირებულება არის, უფლება?
მე ვაპირებ abbreviate, რომ "მინ."
რას ბიჭები მინდა ამის გაკეთება მას შემდეგ, რაც თქვენ ი მინიმალური ღირებულება?
>> აუდიტორია: [INAUDIBLE]
Andi Peng: ასე რომ, თქვენ აპირებს მინდა ჩართოთ იგი პირველი რომ მასივი,
არა?
ეს არის ის, დასაწყისში, მე ვაპირებ ვთქვა.
ყველა უფლება.
ასე რომ, ახლა, რომ თქვენ გაცვალეს პირველი ერთი, რა გინდა, რომ ამის შემდეგ?
ასე რომ, ახლა ჩვენ ვიცით, რომ ეს ერთი აქ უნდა იყოს პატარა ღირებულება, არა?
მაშინ თქვენ გაქვთ დამატებითი დანარჩენი მასივი, რომ დაუხარისხებელი.
ასე რომ, რა გსურთ ამის გაკეთება აქ, თუ ბიჭები მინდა მომეცი შემდეგი ხაზი?
აუდიტორია: ასე შემდეგ გსურთ iterate მეშვეობით მთელი მასივი.
Andi Peng: ჰო.
ასე რომ, რას iterating მეშვეობით სახის გულისხმობს ჩვენ ალბათ უნდა?
რა ტიპის of--
>> აუდიტორია: Oh, დამატებითი ცვლადი?
Andi Peng ალბათ მეორე მარყუჟის, არა?
ასე რომ, ჩვენ ალბათ აპირებს მინდა iterate მეშვეობით დიდი.
და მაშინ თქვენ აპირებს დაბრუნდეს და ალბათ შემოწმება მინიმალური ერთხელ,
არა?
და თქვენ ვაპირებთ შევინარჩუნოთ იმეორებს ეს იმიტომ, რომ მარყუჟების უბრალოდ აპირებს
შენარჩუნება გაშვებული, არა?
>> ასე რომ, როგორც თქვენ ბიჭები ხედავთ, ჩვენ მხოლოდ ზოგადი pseudocode
როგორ გვინდა, რომ ეს პროგრამა უნდა გამოიყურებოდეს.
ეს iterate აქ, რა ჩვენ როგორც წესი, უნდა დაწეროთ ჩვენს კოდი
თუ ჩვენ გვინდა iterate მეშვეობით მასივი, რა ტიპის სტრუქტურა?
მე ვფიქრობ, რომ Christabel უკვე განაცხადა, რომ ეს ადრე.
>> აუდიტორია: A for loop.
>> Andi Peng: A for loop?
ზუსტად.
ასე რომ, ეს, ალბათ, იქნება ამისთვის loop.
რა არის გამშვები აქ აპირებს გულისხმობს?
როგორც წესი, თუ გსურთ შემოწმება თუ რამე არის რაღაც else--
>> აუდიტორია: თუ.
>> Andi Peng: An თუ, არა?
და მაშინ swap აქ, ჩვენ წავიდეთ მეტი მოგვიანებით, იმიტომ, რომ დავით
გაიარა, რომ ლექცია ისევე.
და მაშინ მეორე iterate implies--
>> აუდიტორია: სხვა for loop.
>> Andi Peng: --another ამისთვის მარყუჟის, ზუსტად.
ასე რომ, თუ ჩვენ ვეძებთ ამ სწორად, ჩვენ
ხედავთ, რომ ჩვენ, ალბათ, აპირებთ უნდა წყობილი for loop
ერთად პირობითი განცხადებაში იქ და შემდეგ ფაქტობრივი ნაჭერი კოდი, რომელიც არის
ვაპირებ სვოპ ღირებულებებს.
ასე რომ, მე უბრალოდ ზოგადად წერია pseudocode კოდი აქ.
და მაშინ ჩვენ რეალურად აპირებს ფიზიკურად, როგორც კლასის,
ცდილობენ განახორციელონ ამ დღეს.
მოდით დავუბრუნდეთ ამ IDE.
>> Uh-oh.
რატომ არის, რომ not-- ეს არის.
OK.
უკაცრავად, ნება მომეცით ცდილობენ მიუახლოვდით ცოტა მეტი.
იქ ჩვენ წავიდეთ.
ყველა მე ვაკეთებ აქ არის მე შეიქმნა პროგრამა "შერჩევა / sort.c".
მე შეიქმნა მასივი ცხრა ღირებულებები, 4, 8, 2, 1, 6, 9, 7, 5, 3.
ამჟამად, როგორც თქვენ შეგიძლიათ ვხედავ, ისინი უწესრიგო.
n იქნება ნომერი, რომელიც გიჩვენებთ თანხა ღირებულებები
თქვენ გაქვთ თქვენი მასივი.
ამ შემთხვევაში, ჩვენ გვაქვს ცხრა ღირებულებებს.
და მე უბრალოდ მიიღო ამისთვის loop აქ , ბეჭდავს out დაუხარისხებელი მასივი.
>> და ბოლოს, მე ასევე მივიღეთ ამისთვის loop, უბრალოდ ბეჭდავს მას კიდევ ერთხელ.
თეორიულად, თუ ეს პროგრამა მუშაობს სწორად, ბოლოს,
თქვენ უნდა დაინახოს დაბეჭდილი loop რომელიც 1, 2, 3, 4, 5, 6, 7, 8,
9 სწორად მიზნით.
>> ამიტომ, ჩვენ მივიღეთ ჩვენი pseudocode აქ.
ვინმეს სურს, რომელთა მიზანია, მე მხოლოდ აპირებს მისვლას ითხოვენ volunteers--
მითხრათ ზუსტად რა უნდა აკრიფოთ თუ ჩვენ გვინდა, რომ, პირველ რიგში, უბრალოდ iterate
მეშვეობით დასაწყისში მასივი?
რა არის ხაზი კოდი, მე ვარ ალბათ აპირებს უნდა აქ?
>> აუდიტორია: [INAUDIBLE]
>> Andi Peng: ჰო, გრძნობს უფასო რომელთა მიზანია ბოდიში, თქვენ
არ უნდა დავდგეთ up-- შეგრძნებას უფასო ხმა ცოტა.
>> აუდიტორია: int i შეადგენს 0-
>> Andi Peng: ჰო, კარგი.
>> აუდიტორია: მე ნაკლებია, ვიდრე მასივი სიგრძე.
>> Andi Peng: ასე რომ შევინარჩუნოთ იბადება აქ, იმიტომ, რომ ჩვენ
არ აქვს ფუნქცია, რომ გვეუბნება, სიგრძით მასივი,
ჩვენ უკვე გვაქვს მნიშვნელობა, რომელიც ინახავს, ​​რომ.
მარჯვენა?
კიდევ ერთი რამ, რომ შევინარჩუნოთ ამ mind-- მასივი
ცხრა ღირებულებები, რა არის ინდექსები?
მოდით უბრალოდ, ვამბობთ ამ მასივი 0 3.
თქვენ ხედავთ, რომ ბოლო ინდექსი ფაქტიურად 3.
ეს არ არის 4, მიუხედავად იმისა, რომ იქ ოთხი ღირებულებების მასივი.
>> ასე რომ, აქ, ჩვენ უნდა ვიყოთ ძალიან ფრთხილად რა არის ჩვენი მდგომარეობა ხანგრძლივობა
იქნება.
>> აუდიტორია: თუ არ იქნება, ო მინუს 1?
Andi Peng: იგი აპირებს ო მინუს 1, ზუსტად.
აკეთებს, რომ აზრი, რატომ ეს ო მინუს 1, ყველას?
ეს იმიტომ, რომ კოლექტორები არის ნულოვანი ინდექსირებული.
ისინი დაიწყოს 0-ზე და აწარმოებს ო მინუს 1.
ჰო, ცოტა სახიფათო.
OK.
ხოლო შემდეგ
აუდიტორია: Isnt'1, რომ უკვე მიღებული ზრუნვა, თუმცა,
უბრალოდ არ ვამბობ "ნაკლებია ან თანაბარი "და უბრალოდ, ვამბობთ," ნაკლები? "
>> Andi Peng: ეს ​​არის კარგი კითხვა.
ასე რომ, დიახ.
მაგრამ, ასევე, ისე, რომ ჩვენ განხორციელების შემოწმების უფლება,
თქვენ უნდა შეადაროთ ორი ღირებულებებს.
ასე, რომ თქვენ რეალურად გვინდა დატოვონ ", რათა" ცარიელი.
იმის გამო, რომ თუ შევადარებთ ეს ერთი, თქვენ არ აპირებს
აქვს არაფერი მას შემდეგ, რაც შედარება, არა?
ჰო.
ასე რომ, მე ++.
მოდით დაამატოთ ჩვენი ფრჩხილები.
Whoops.
შესანიშნავი.
ასე რომ, ჩვენ დასაწყისში ჩვენი გარე loop.
ასე რომ, ახლა ჩვენ, ალბათ, სურს შექმნა ცვლადი შენახვა
სიმღერა პატარა ღირებულება, არა?
ვინმეს სურს, რომ მომეცი ხაზი კოდი, რომ ყველაფერს გააკეთებს, რომ?
რა უნდა გავაკეთოთ, თუ ჩვენ ვაპირებთ რომ გსურთ შესანახად რაღაც?
>> უფლება.
იქნებ უკეთესი სახელი, რომ რომ be-- "დროებითი" სრულიად works--
იქნებ უფრო aptly დაასახელა იქნება, თუ გვინდა, რომ პატარა value--
>> აუდიტორია: მინ.
Andi Peng: წუთი, იქ ჩვენ წავიდეთ.
min კარგი იქნება.
ასე რომ, აქ, რა ჩვენ მინდა ინიციალიზაცია მას?
ეს არის ცოტა სახიფათო.
იმის გამო, რომ ახლა დაწყებული ამ მასივი,
თქვენ არ ჩანდა არაფერი, არა?
მერე რა, ავტომატურად, თუ ჩვენ მხოლოდ i უდრის 0,
რა გვინდა ინიციალიზაცია ჩვენი პირველი მინიმალური ღირებულება?
აუდიტორია: i.
Andi Peng: i, ზუსტად.
Christabel, რატომ გვინდა ინიციალიზაცია მას i?
>> აუდიტორია: იმიტომ, ასევე, ჩვენ ვიწყებთ 0.
ასე რომ, იმიტომ, რომ ჩვენ არაფერი გვაქვს შედარება მას, მინიმალური დასრულდება მდე მიმდინარეობს 0.
>> Andi Peng: ზუსტად.
ასე რომ, ის სწორედ.
იმიტომ, რომ ჩვენ არ რეალურად შევხედე არაფერი არ არის,
ჩვენ არ ვიცით, რა არის ჩვენი მინიმალური მნიშვნელობა.
ჩვენ გვინდა რომ ვრთავ, რომ i, რომელიც, ამჟამად, სწორედ აქ.
და, როგორც ჩვენ ვაგრძელებთ ქვევით ამ მასივი,
ჩვენ დავინახავთ, რომ, თითოეული დამატებითი უღელტეხილზე, i მდე.
ასე რომ, ამ დროს, i ალბათ აპირებს
გვინდა, რომ იყოს მინიმალური, იმიტომ, რომ ეს იქნება, რასაც
დასაწყისში არასორტირებული მასივი.
ზემოთ.
>> ასე რომ, ახლა ჩვენ გვსურს, რომ ამისთვის loop აქ, რომ
აპირებს iterate მეშვეობით დაუხარისხებელი, ან დანარჩენი მასივი.
ვინმეს სურს მომეცი ხაზი კოდი, რომ ყველაფერს გააკეთებს, რომ?
Hint-- რა გვჭირდება ქვემოთ აქ?
რა ხდება წასვლა ამ for loop?
ჰო.
აუდიტორია: ასე რომ, ჩვენ მინდა აქვს სხვადასხვა რიცხვი,
იმიტომ, რომ ჩვენ გადის დანარჩენი მასივი ნაცვლად i, იქნებ
კ.
>> Andi Peng: ჰო, j ჟღერს ჩემთვის.
უდრის?
>> აუდიტორია: ასე იქნება i + 1, იმიტომ, რომ თქვენ იწყება შემდეგი მნიშვნელობა.
და შემდეგ end-- კიდევ ერთხელ, კ ნაკლებია, ვიდრე n მინუს 1, და შემდეგ კ ++.
Andi Peng: დიდი.
>> და მაშინ აქ, ჩვენ ვაპირებთ, რომ გსურთ შეამოწმეთ თუ ჩვენი მდგომარეობა შეხვდა,
არა?
იმის გამო, რომ გსურთ შეცვლა მინიმალური ღირებულება
თუ ეს რეალურად ნაკლები, რაც თქვენ შედარებით ეს, არა?
ასე რომ, რასაც ჩვენ ვაპირებთ, რომ მინდა აქ?
შეამოწმეთ.
რა ტიპის განაცხადი ვართ ჩვენ ალბათ აპირებს
ti გსურთ გამოიყენოთ თუ ჩვენ გვინდა, რომ შემოწმება რაღაც?
>> აუდიტორია: თუ განაცხადი.
>> Andi Peng: თუ განაცხადი.
ასე რომ, თუ და რა იქნება იმ პირობით, რომ ჩვენ გვინდა შიგნით
ჩვენი თუ განაცხადი?
>> აუდიტორია: თუ ღირებულება j ნაკლებია, ვიდრე ღირებულება შევიდე
>> Andi Peng: ზუსტად.
ასე რომ, თუ ასე რომ, ეს მასივი ეწოდება "მასივი".
შესანიშნავი.
ასე რომ, თუ მასივი რა იყო ეს?
გაიმეორე.
>> აუდიტორია: თუ მასივი კ ნაკლებია, ვიდრე array-i, მაშინ ჩვენ შეიცვლება წთ.
ასე რომ წთ იქნება კ.
>> Andi Peng: არა, რომ აზრი?
OK.
და ახლა ქვემოთ აქ, ჩვენ, ფაქტობრივად, გვინდა, რომ განახორციელოს swap, არა?
ასე რომ გავიხსენოთ, ლექცია, რომ დავით, როდესაც იგი ცდილობდა, რომ სვოპ the-- რა იყო
it-- ფორთოხლის წვენი და milk--
>> აუდიტორია: ეს იყო უხეში.
>> Andi Peng: ჰო, რომ სახის უხეში.
მაგრამ ეს იყო საკმაოდ კარგი კონცეფცია დემონსტრირებას დროს.
ასე რომ, ვფიქრობ, რომ თქვენი ღირებულებების აქ.
თქვენ მოხვდით მასივი მინიმუმ, მასივი i,
ან რასაც ჩვენ ვცდილობთ, რომ სვოპ აქ.
და თქვენ, ალბათ, ვერ დაასხით მათ ერთმანეთს, ამავე დროს, არა?
ასე რომ, რასაც ჩვენ ვაპირებთ უნდა შეიქმნას აქ
იმისათვის, რომ სვოპ ფასეულობები სწორად?
>> აუდიტორია: დროებითი ცვლადი.
>> Andi Peng: დროებითი ცვლადი.
ასე რომ მოდით int temp.
აგრეთვე, ეს იქნება უკეთესი დრო, რომელთა მიზანია: Whoa, რა იყო ეს?
OK.
ასე რომ, ეს იქნებოდა უკეთესი დრო ასახელებს ცვლადი "დროებითი".
ასე რომ მოდით int temp.
ჩვენ რას აპირებს მითითებული temp ტოლია აქ?
აუდიტორია: Min?
Andi Peng: ეს ​​ცოტა სახიფათო.
ეს რეალურად არ აქვს მნიშვნელობა ბოლომდე.
არ აქვს მნიშვნელობა, რა რათა თქვენ სვოპ
რადგან თქვენ მიღების დარწმუნებული ვარ, რომ თქვენ შენახვა სიმღერა, თუ რას შევცვალე.
>> აუდიტორია: ეს შეიძლება იყოს მასივი-i.
>> Andi Peng: ჰო, მოდით გავაკეთოთ array-i.
და მერე რა არის შემდეგი ხაზი კოდი გვინდა, რომ გვქონდეს აქ?
აუდიტორია: array-i ტოლია მასივი კ.
Andi Peng: და ბოლოს?
აუდიტორია: array-j ტოლია მასივი-i.
აუდიტორია: ან მასივი j ტოლობის მასივი temp-- ან, temp.
>> Andi Peng: OK.
მოდით აწარმოებს და ვნახოთ თუ ის იმუშავებს.
სად არის ის, რომ ხდება?
ოჰ, რომ პრობლემა.
იხილეთ, on line 40, ჩვენ ცდილობს გამოიყენოს მასივი j?
მაგრამ სად j მხოლოდ არსებობს?
>> აუდიტორია: In for loop.
Andi Peng: მარჯვენა.
ასე რომ, რასაც ჩვენ ვაპირებთ, რომ უნდა გავაკეთოთ?
>> აუდიტორია: განსაზღვრეთ გარეთ the--
აუდიტორია: ჰო, მე ვფიქრობ, თქვენ უნდა გამოიყენოს სხვა, თუ განაცხადი, არა?
ასე რომ, თუ minimum-- ყველა უფლება, მოდით მე ვფიქრობ.
>> Andi Peng: ბიჭები, ცდილობენ შევხედოთ მოდით
ვნახოთ, რა არის ის, რომ ჩვენ შეგვიძლია გავაკეთოთ აქ?
>> აუდიტორია: OK.
ასე რომ, თუ მინიმალური არ უდრის j-- ასე რომ, თუ მინიმალური მაინც შევიდე
მაშინ ჩვენ არ უნდა სვოპ.
>> Andi Peng: არა, რომ თანაბარი i?
რა გინდათ ვთქვა აქ?
>> აუდიტორია: ან ჰო, იმ შემთხვევაში, თუ მინიმალური არ თანაბარი i, yeah.
Andi Peng: OK.
ისე, რომ წყვეტს, სახის, ჩვენს პრობლემებს.
მაგრამ ეს ჯერ კიდევ არ გადაჭრა პრობლემა რა მოხდება, თუ j-- წლიდან j
არ არსებობს გარეთ, რა თქვენ გვინდა გავაკეთოთ ეს?
გამოაცხადოს ის გარეთ?
მოდით ვეცადოთ გაშვებული ეს.
Uh-oh.
ჩვენი ერთგვარი არ მუშაობს.
>> როგორც ხედავთ, ჩვენი თავდაპირველი მასივი ჰქონდა იმ ღირებულებებს.
და შემდეგ მას უნდა ჰქონდეს უკვე 1, 2, 3, 4, 5, 6, 7, 8, 9.
არ მუშაობს.
ოხ.
რას ვაკეთებთ?
აუდიტორია: Debug.
Andi Peng ყველა უფლება, ჩვენ შეგვიძლია ვცდილობთ, რომ.
ჩვენ შეგვიძლია გამართვის.
დააშორებს ცოტა.
მოდით მითითებული ჩვენი breakpoint.
მოდით წავიდეთ მოსწონს OK.
>> ასე რომ, რადგან ჩვენ ვიცით, რომ ამ მიმართულებით, 15, 22,
არიან working-- რადგან ყველა ვაკეთებ უბრალოდ iterating მეშვეობით და დაბეჭდვის
შემიძლია წავიდეთ წინ და გაფართოებული, რომ.
დავიწყოთ line 25.
OOP, ნება მომეცით თავი დაეღწია, რომ.
>> აუდიტორია: ასე breakpoint ს სადაც გამართვის იწყება?
Andi Peng: ან გაჩერება.
აუდიტორია: ან გაჩერება.
Andi Peng: ჰო.
თქვენ შეგიძლიათ დააყენოთ სხვადასხვა breakpoints და მას შეუძლია მხოლოდ ხტომა ერთი სხვა.
მაგრამ ამ შემთხვევაში ჩვენ არ ვიცით, სადაც შეცდომა ხდება.
ასე რომ, ჩვენ უბრალოდ გვინდა დაიწყოს ზემოდან ქვემოთ.
Yep.
OK.
>> ასე რომ, ეს ხაზი აქ, ჩვენ შეიძლება გადადგას.
თქვენ ხედავთ, ქვემოთ აქ, ჩვენ მივიღეთ მასივი.
იმ ღირებულებების რომ მასივი.
მიგაჩნიათ თუ არა, რომ, თუ როგორ ინდექსი 0, შეესაბამება value-- oh,
მე ვაპირებ ცდილობენ მიუახლოვდით.
სამწუხაროდ, ეს მართლაც რთულია, რომ see-- at მასივი ინდექსი 0,
ჩვენ გვაქვს ღირებულება 4 და მაშინ ასე მეოთხე და ასე შემდეგ.
ჩვენ გვაქვს ჩვენი ადგილობრივი ცვლადები.
ახლა მე უდრის 0, რაც ჩვენ გვინდა, რომ იყოს.
>> ასე რომ, მოდით შენარჩუნება სტეპინგზე მეშვეობით.
ჩვენი მინიმალური უდრის 0, რომელიც ჩვენ ასევე გვინდა, რომ იყოს.
და მაშინ ჩვენ შევა ჩვენი მეორე loop, თუ მასივი კ ნაკლებია, ვიდრე მასივი-i,
რომელიც არ იყო.
ასე რომ, ხედავთ, როგორ რომ გამოტოვებენ, რომ?
>> აუდიტორია: ასე უნდა იყოს თუ მინიმალური, ყველა that-- არ უნდა, რომ
იყოს შიგნით პირველი მარყუჟის?
Andi Peng: არა, იმიტომ, თქვენ კვლავ სურს გამოსცადოს.
გსურთ თუ შედარებით ყოველ დროს, მას შემდეგ, რაც თქვენ აწარმოებს მეშვეობით.
თქვენ არ მინდა ამის გაკეთება პირველ გამჭოლი.
გსურთ ამის გაკეთება ყოველი დამატებითი უღელტეხილზე კიდევ ერთხელ.
ასე, რომ თქვენ გსურთ შემოწმება თქვენი მდგომარეობა შიგნით.
ასე რომ, ჩვენ უბრალოდ აპირებს შენარჩუნება გადის აქ.
მე მივცემ თქვენ ბიჭები მინიშნება.
ეს უნდა გააკეთოს, რომ როდესაც თქვენ შემოწმების თქვენი პირობით,
თქვენ არ შემოწმების სწორი ინდექსი.
ასე რომ, ახლა თქვენ შემოწმება მასივი მაჩვენებელი კ ნაკლებია, ვიდრე მასივი
ინდექსი i.
მაგრამ რას აკეთებს up at დასაწყისში for loop?
ხომ არ შექმნის j ტოლი i?
>> ჰო, ასე რომ ჩვენ შეგვიძლია რეალურად გასვლა debugger აქ.
მოდით შევხედოთ ჩვენი pseudocode.
For-- ჩვენ ვაპირებთ იწყება i = 0.
ჩვენ ვაპირებთ, რომ ახვიდეთ ო მინუს 1.
მოდით შეამოწმეთ, არ გვაქვს, რომ უფლება?
Yep, რომ სწორი იყო.
>> ასე რომ, შიგნით აქ, ჩვენ აპირებთ შექმნათ მინიმალური ღირებულება
და მითითებული, რომ თანაბარი i.
ხომ არ გავაკეთოთ, რომ?
Yep, რომ.
ახლა ჩვენს შიდა ამისთვის მარყუჟის, ჩვენ ვაპირებთ, რომ გავაკეთოთ j შეადგენს i ო მინუს 1.
ხომ არ გავაკეთოთ, რომ?
მართლაც, ჩვენ გავაკეთეთ, რომ.
>> ასე რომ, თუმცა, რა ჩვენ შედარებით აქ?
>> აუდიტორია: j + 1.
Andi Peng: ზუსტად.
და მაშინ ვაპირებთ გვინდა მითითებული თქვენი მინიმალური ტოლია j + 1, ისევე.
ასე რომ, მე გაიარა, რომ ძალიან სწრაფად.
მიგაჩნიათ თუ არა ბიჭები გაგება, ამიტომ ეს j + 1?
OK.
>> ასე რომ, თქვენს მასივი, თქვენი პირველი გადის,
თქვენი for მარყუჟის, int i უდრის 0, მოდით უბრალოდ
ვივარაუდოთ, რომ ეს არ შეცვლილა.
ჩვენ გვყავს მასივი, სრულიად, მხოლოდ ოთხი დაუხარისხებელი ელემენტების, არა?
ასე რომ, ჩვენ გვინდა ინიციალიზაცია i = 0.
და მე ვაპირებ აწარმოებს ამ loop.
ასე რომ, პირველ უღელტეხილზე, ჩვენ ვაპირებთ ინიციალიზაცია ცვლადში "min"
რომელიც ასევე შეადგენს i, რადგან ჩვენ არ გვაქვს მინიმალური ღირებულება.
ასე რომ, გაკეთებული უდრის 0, ისევე.
და მაშინ ჩვენ ვაპირებთ გავლა.
ჩვენ გვინდა iterate ერთხელ.
ახლა, ჩვენ აღმოვაჩინეთ, რაც ჩვენი მინიმალური არის, ჩვენ გვინდა რომ iterate
ერთხელ თუ ეს შედარება, არა?
ასე რომ, j, აქ, აპირებს თანაბარი i, რომელიც არის 0.
და მაშინ, თუ მასივი j პლუს i, რომელიც არის ერთი, რომ მომდევნო მეტი, ნაკლები
ვიდრე თქვენი მიმდინარე მინიმალური მნიშვნელობა, გსურთ სვოპ.
>> ასე რომ, მოდით უბრალოდ, ვამბობთ, რომ ჩვენ მიიღო, ისევე, 2, 5, 1, 8.
ახლა, მე უდრის 0 კ უდრის 0.
ეს არის ჩვენი მინიმალური ღირებულება.
თუ მასივი j პლუს შევიდე ასე რომ, თუ ერთ-ერთი რომ მას შემდეგ, რაც ერთი ჩვენ შევხედავთ
უფრო მეტი, ვიდრე ერთი, სანამ ის, ის აპირებს გახდეს მინიმალური.
>> ასე რომ აქ ჩვენ ვხედავთ, რომ 5 ნაკლები არ არის, რომ.
ასე რომ, ის აპირებს არ უნდა იყოს 5.
ჩვენ ვხედავთ, რომ 1 ნაკლებია 2, არა?
ასე რომ, ახლა ჩვენ ვიცით, რომ ჩვენი მინიმალური არის იქნება ინდექსის მნიშვნელობა 0, 1, 2.
ჰო?
და მაშინ, როდესაც თქვენ ქვემოთ აქ, შეგიძლიათ სვოპ სწორი ღირებულებები.
>> ასე რომ, როდესაც თქვენ ბიჭები უბრალოდ მქონე j ადრე, თქვენ არ ეძებს ერთი
მას შემდეგ.
თქვენ ეძებს იგივე ღირებულება, რომელიც
ამიტომ, ის უბრალოდ არ აკეთებს არაფერს.
არა, რომ აზრი ყველას, ამიტომ ჩვენ საჭირო, რომ პლუს 1 იქ?
OK.
ახლა მოდით უბრალოდ აწარმოებს მეშვეობით, რათა დარწმუნებული ვარ, რომ დანარჩენი კოდი არის სწორი.
რატომ არის, რომ ხდება?
Ah, ეს წთ უფლება აქ.
ჩვენ ვიყავით შედარებით არასწორი მნიშვნელობა.
Oh no.
>> ჰო, აქ ქვემოთ ვიყავით შევცვალე არასწორი ღირებულებები ისევე.
იმის გამო, რომ ჩვენ შევხედავთ i და j.
ეს არის პირობა, ჩვენ შემოწმებას.
ჩვენ რეალურად გვინდა, რომ სვოპ მინიმალური, მიმდინარე მინიმუმი,
რასაც ერთი გარეთ.
და როგორც თქვენ ბიჭები ხედავთ ქვემოთ აქ, ჩვენ გვაქვს დახარისხებული მასივი.
ეს უბრალოდ უნდა გაეკეთებინათ ის ფაქტი, რომ
ჩვენ შემოწმების ღირებულებები ჩვენ შედარება
ჩვენ არ ეძებს მარჯვენა ღირებულებებს.
ჩვენ შევხედავთ იგივე ერთი აქ, ფაქტობრივად, არ შევცვალე ის.
თქვენ უნდა შევხედოთ ერთი შემდეგი მას და შემდეგ შეგიძლიათ სვოპ.
ასე რომ, რა იყო ერთგვარი bugging ჩვენი კოდი ადრე.
და რაც მე აქ არის ყველაფერი debugger შეიძლება გაკეთდეს თქვენთვის
მე უბრალოდ ეს ფორუმში, იმიტომ, რომ ეს ადვილი
იმისათვის, რომ ნახოთ ვიდრე ცდილობს რომ მიუახლოვდით debugger.
არა, რომ აზრი ყველას?
ზემოთ.
>> ყველა უფლება.
ჩვენ შეგიძლიათ გადაადგილება, რათა ლაპარაკი asymptotic ნოტაცია, რომელიც
უბრალოდ ლამაზი გზა ამბობდა runtimes ყველა ამ სახის.
ასე რომ, მე ვიცი, დავით, ლექცია, შეეხო runtimes.
დადიოდა მთელი ფორმულა როგორ გამოვთვალოთ runtimes.
არ აწუხებს, რომ.
თუ თქვენ ნამდვილად აინტერესებს იმაზე, თუ როგორ მუშაობს,
მოგერიდებათ გაიგო, რომ მე მას შემდეგ, რაც განყოფილებაში.
ჩვენ შეგვიძლია გავლა ფორმულები ერთად.
მაგრამ ყველა ბიჭები უნდა ნამდვილად ვიცი, რომ n კვადრატში მეტი 2
არის იგივე, როგორც n კვადრატში.
იმის გამო, რომ დიდი რაოდენობის, მაჩვენებლებით, იზრდება საუკეთესო.
ასე რომ, ჩვენი მიზნებისთვის, ყველა ჩვენ აღელვებს
ის არის, რომ გიგანტური რომ იზრდება.
>> ასე რომ, რა არის საუკეთესო შემთხვევაში runtime შერჩევის დალაგების?
თუ თქვენ აპირებთ უნდა iterate მეშვეობით სია
და შემდეგ iterate მეშვეობით დანარჩენი სიაში,
რამდენი ჯერ აპირებთ თუ არა, ალბათ,
ყველაზე ცუდი case-- წელს საუკეთესო შემთხვევაში, ბოდიში აწარმოებს მეშვეობით?
იქნებ უკეთესი კითხვაზე ვთხოვო, რა არის ყველაზე უარესი შემთხვევაში
runtime შერჩევის დალაგების.
აუდიტორია: n კვადრატში.
Andi Peng: ეს ​​n კვადრატში, მარჯვნივ.
ასე რომ, ადვილი გზა, რომ ვფიქრობ, ეს არის, როგორც, ნებისმიერ დროს თქვენ გაქვთ ორი წყობილი ამისთვის მარყუჟების,
ის აპირებს იყოს N კვადრატში.
იმის გამო, რომ არა მხოლოდ თქვენ, გადის კიდევ ერთხელ,
თქვენ უნდა დაბრუნდეს გარშემო და აწარმოებს მეშვეობით
კიდევ ერთხელ შიგნით ყველა ღირებულება.
ასე რომ ამ შემთხვევაში, თქვენ გაშვებული n ჯერ N კვადრატში, რომელსაც is-- ბოდიში,
N ჯერ N, რომელიც უდრის n კვადრატში.
>> და ერთგვარი ასევე ცოტა უნიკალური იმ გაგებით,
ის, რომ არ აქვს მნიშვნელობა, თუ ამ ღირებულებები უკვე მიზნით.
ეს ჯერ კიდევ აპირებს მეშვეობით მაინც.
მოდით უბრალოდ, ვამბობთ, რომ ეს იყო 1, 2, 3, 4.
მიუხედავად იმისა, არის თუ არა ეს იყო იმისათვის, რომ ეს ჯერ კიდევ არ გაიქცა მეშვეობით
და მაინც გადაამოწმა მინიმალური ღირებულება.
ეს არ გააკეთა იგივე რაოდენობის ამოწმებს
თითოეული დროს, თუნდაც ეს პრაქტიკულად არ შეეხოთ არაფერს.
>> ასე რომ, ამ შემთხვევაში, საუკეთესო და ყველაზე ცუდი runtimes არის რეალურად ექვივალენტს.
ასე რომ ელოდებიან runtime შერჩევის დალაგების,
რომელიც ჩვენ დანიშნოს სიმბოლო თეტა, თეტა, ამ შემთხვევაში,
ასევე იქნება n კვადრატში.
სამივე ეს იქნება n კვადრატში.
ყველას ნათელი, თუ რატომ runtime n კვადრატში?
>> ყველა უფლება.
ასე რომ, მე უბრალოდ აპირებს სწრაფად აწარმოებს მეშვეობით დანარჩენი სახის.
ალგორითმი ბუშტი დალაგება მახსოვს,
ეს იყო პირველი დავით წავიდა ლექცია.
არსებითად, თქვენ დაიხევს მთელი სია
და თქვენ swap-- უბრალოდ შედარება ორი დროს.
და თუ ერთი უფრო დიდი, ვიდრე უბრალოდ სვოპ მათ.
ასე რომ, თუ ეს უფრო მეტია, თქვენ სვოპ.
მაქვს ოფიციალური უფლება აქ.
>> ასე რომ, მოდით უბრალოდ, ვამბობთ თუ არა 8, 6, 4, 2.
ნეტავ შედარება 8 და 6.
ნეტავ უნდა სვოპ მათ.
თქვენ შედარების 8 და 4.
ნეტავ უნდა სვოპ მათ.
თუ თქვენ უნდა სვოპ 8 და 2, შეცვლის მათ ასევე.
ასე რომ, ასეთი გრძნობა, ხედავთ, ითამაშა მეტი ხანგრძლივი დროის განმავლობაში,
როგორ ღირებულებების სახის ბუშტი ბოლოები, რის გამოც ჩვენ მას
bubble sort.
>> ჩვენ მხოლოდ აწარმოებს მეშვეობით ისევ ჩვენი მეორე უღელტეხილზე, და მესამე უღელტეხილზე,
და მეოთხე აკეთებს.
არსებითად, bubble sort უბრალოდ გადის სანამ თქვენ არ რაიმე უფრო გაცვლებს.
ასე რომ, ამ თვალსაზრისით, ეს მხოლოდ ზოგადი pseudocode მას.
არ აწუხებს, ეს იქნება ყველა ონლაინ რეჟიმში.
ჩვენ არ უნდა რეალურად წასვლა ამ.
>> ჩვენ უბრალოდ ვრთავ counter ცვლადი რომ იწყება 0.
ჩვენ iterate მთელი მასივი.
და თუ ერთი მნიშვნელობა is-- თუ ეს მნიშვნელობა მეტია, რომ ღირებულება,
თქვენ აპირებს სვოპ მათ.
და მაშინ თქვენ უბრალოდ შენარჩუნება აპირებს.
და თქვენ ვაპირებთ ითვლიან.
და თქვენ უბრალოდ აპირებს შეინარჩუნოს აკეთებს ეს მაშინ, როცა კონტრ არის დიდი
ვიდრე 0, რაც ნიშნავს, რომ ყოველ დროს, თქვენ უნდა სვოპ,
თქვენ იცით, თუ უნდათ უკან და შემოწმება ერთხელ.
გსურთ, რომ შევინარჩუნოთ შემოწმების სანამ თქვენ იცით, რომ თქვენ არ უნდა სვოპ მთელი მსოფლიოს მასშტაბით.
>> რა არის საუკეთესო და ყველაზე ცუდი შემთხვევაში runtimes for ბუშტი დალაგება?
და hint-- ეს არის რეალურად სხვადასხვა შერჩევა ერთგვარი იმ გაგებით,
რომ ეს ორი პასუხი არ არის იგივე.
დაფიქრდით, რა მოხდებოდა იმ შემთხვევაში, თუ იგი უკვე გადანაწილებული.
და ვიფიქროთ, რა მოხდება, თუ ეს იყო
იმ შემთხვევაში, რომელშიც იგი არ არის დახარისხებული.
და თქვენ შეგიძლიათ სახის აწარმოებს მეშვეობით, რის გამოც, რომ ხდება.
მე მივცემ თქვენ ბიჭები, ისევე, როგორც 30 წამი ვიფიქროთ, რომ.
>> OK.
ვინმეს აქვს გამოიცანით რა უარეს შემთხვევაში runtime of bubble sort არის?
ჰო.
>> აუდიტორია: უნდა იყოს, როგორიცაა, N ჯერ ო მინუს 1 ან რამე მაგდაგვარს?
მსგავსად, ყოველ ჯერზე ის მუშაობს, ეს უბრალოდ, როგორც ერთ-ერთი swap ნაკლები
რომ რაც არ იყო.
>> Andi Peng: ჰო, ისე, თქვენ მთლიანად უფლება.
და ეს არის საქმე, რომელიც თქვენს პასუხი იყო რეალურად უფრო რთული
ვიდრე ჩვენ უნდა მივცეთ.
ასე რომ, ის აპირებს პერსპექტივაში ვარ აპირებს წაშალოს ეს ყველაფერი აქ.
ყველას კარგი?
შემიძლია წაშლას ეს?
OK.
თქვენ აპირებს მეშვეობით n ჯერ პირველად, არა?
და ისინი აპირებს მეშვეობით ო მინუს 1 მეორედ, არა?
და მაშინ ვაპირებთ, რომ შევინარჩუნოთ აპირებს, n ნაღმების 2, et cetera.
დავით გააკეთა ეს ლექცია, სადაც, თუ ემატება ყველა ის ღირებულებები,
თქვენ, რომ რაღაც მოსწონს yeah-- მეტი 2, რომელიც არსებითად მხოლოდ ამცირებს
ქვემოთ n კვადრატში.
თქვენ აპირებთ მისაღებად უცნაური ფრაქცია არსებობს.
ასე რომ, უბრალოდ ვიცი, რომ n კვადრატში ყოველთვის
იღებს უპირატესი ფრაქციას.
ასე რომ, ამ შემთხვევაში, ყველაზე ცუდი runtime იქნება n კვადრატში.
თუ ეს იყო კლებადი იმისათვის, ვფიქრობ, თქვენ
უნდა მიიღოს swap თითოეული დრო.
>> რა იქნება, პოტენციურად, საუკეთესო შემთხვევაში runtime?
მოდით უბრალოდ, ვამბობთ, თუ სიაში იყო უკვე იმისათვის, რა runtime იყოს?
>> აუდიტორია: n.
Andi Peng: ეს ​​არის n, ზუსტად.
და რატომ არის ის ო?
აუდიტორია: იმიტომ, რომ თქვენ მხოლოდ უნდა შეამოწმოს თითოეული ერთხელ.
Andi Peng: ზუსტად.
ასე რომ, მაქსიმალურად runtime, იმ შემთხვევაში, თუ ამ სიაში იყო უკვე
sorted-- მოდით ვთქვათ, 1, 2, 3, 4-- თქვენ რომ უბრალოდ გავლა, თქვენ უნდა ნახოთ,
თქვენ ხედავთ, oh, ისინი ყველა პან გარეთ.
მე არ შემიცვლია.
მე გაკეთდეს.
ასე რომ ამ შემთხვევაში, უბრალოდ n ან რიგი ნაბიჯები, თქვენ უბრალოდ
უნდა შეამოწმოს პირველ სიაში.
>> ხოლო მას შემდეგ, ახლა ჩვენ მოხვდა Insertion დალაგების, სადაც
ალგორითმი არსებითად გათიშე მას დახარისხებული და არასორტირებული ნაწილი.
და მაშინ ერთი, არასორტირებული ღირებულებები
შეიყვანეს მათ შესაბამისი თანამდებობებზე დასაწყისში სიაში.
>> ასე მაგალითად, ჩვენ გვაქვს სია 3, 5, 2, 6, 4 ერთხელ.
ჩვენ ვიცით, რომ ეს გაკეთებული დაუხარისხებელი იმიტომ, რომ ჩვენ მხოლოდ
დაიწყო ეძებს მას.
ჩვენ შევხედოთ და ჩვენ ვიცით, რომ პირველი მნიშვნელობა დალაგებულია, არა?
თუ თქვენ მხოლოდ ეძებს მასივი ზომა, თქვენ იცით, რომ ეს დახარისხებული.
>> ასე რომ, ჩვენ ვიცით, რომ სხვა ოთხი დაუხარისხებელი.
ჩვენ გაიაროს და ჩვენ ვხედავთ, რომ მნიშვნელობა.
მოდით დავუბრუნდეთ.
ვხედავთ, რომ ღირებულების 5?
ჩვენ შევხედოთ მას.
ჩვენ შევადარებთ მას 3.
ჩვენ ვიცით, რომ ეს უფრო მეტია, ვიდრე 3, ასე რომ ჩვენ ვიცით, რომ დახარისხებული.
ასე რომ, ახლა ჩვენ ვიცით, რომ პირველი ორი დალაგებულია და ბოლო სამი არ არის.
>> ჩვენ შევხედოთ 2.
ჩვენ პირველი შეამოწმეთ იგი 5.
ეს არის 5-ზე ნაკლები?
ეს არ არის.
ასე რომ, ჩვენ უნდა შევინარჩუნოთ ეძებს ქვემოთ.
მაშინ თქვენ შეამოწმოთ 2 off 3.
ეს არის ნაკლები?
No.
ასე, რომ თქვენ იცით, 2 უნდა იყოს ჩასმული შევიდა წინა და 3 და 5
ორივე უნდა აიძულა.
ეს კიდევ ერთხელ გავაკეთოთ 6 და 4.
და ჩვენ უბრალოდ შეინახოს შემოწმების არსებითად, სადაც ჩვენ უბრალოდ შემოწმება, შემოწმება, შემოწმება.
და სანამ ეს სწორი პოზიცია, სახის მხოლოდ
ჩადეთ იგი სწორი პოზიცია, რაც არის, სადაც სახელი მოვიდა.
>> ასე რომ მხოლოდ ალგორითმი, pseudocode per se, სახის,
შესახებ, თუ როგორ განახორციელებენ რომ Insertion დალაგების.
Pseudocode აქ.
ეს ყველაფერი ონლაინ რეჟიმში.
არ აწუხებს თუ ბიჭები არიან ცდილობს კოპირება ამ ქვემოთ.
ასე რომ, კიდევ ერთხელ, იმავე კითხვას, თუ რა იქნება საუკეთესო და ყველაზე ცუდი runtimes
ჩანართი დალაგების?
ის ძალიან გავს ბოლო კითხვა.
მე მივცემ თქვენ ბიჭები, ისევე, როგორც 30 წამი ვფიქრობ, რომ ამ ისევე.
>> OK ვინმეს სურს მომეცი ყველაზე ცუდი runtime?
ჰო.
>> აუდიტორია: n კვადრატში.
>> Andi Peng: ეს ​​n კვადრატში.
და რატომ არის ის n კვადრატში?
>> აუდიტორია: იმის გამო, რომ საპირისპირო მიზნით, თქვენ უნდა
გავლა N ჯერ N, რომელიც is--
Andi Peng: ჰო, ზუსტად.
ასე რომ, იგივე როგორც bubble sort.
თუ ამ სიაში არის კლებადობით, თქვენ
აპირებთ უნდა შეამოწმოთ პირველი ერთხელ.
და მაშინ ყველა დამატებითი ღირებულება, თქვენ
აპირებთ უნდა ნახოთ ის წინააღმდეგ თითოეული ღირებულება, არა?
ასე რომ, საერთოდ, თქვენ ვაპირებთ ო უღელტეხილზე ჯერ კიდევ ო გაივლის, რომელიც
არის n კვადრატში.
რაც შეეხება საუკეთესო შემთხვევაში?
ჰო.
>> აუდიტორია: N მინუს 1, იმიტომ, რომ პირველი უკვე კვადრატი.
>> Andi Peng: ასე რომ, ახლოს.
პასუხი არის, ფაქტობრივად, ნ.
იმის გამო, რომ მიუხედავად იმისა, რომ პირველი არის დახარისხებული, ეს არ შეიძლება რეალურად ეს
ჩვენ უბრალოდ lucked გარეთ, რომ, მაგალითად, რომ 2
მოხდა, რომ ყველაზე მცირე რაოდენობა.
მაგრამ ეს ყოველთვის არ იყოს საქმე.
თუ 2 უკვე დახარისხებული დასაწყისში მაგრამ გადავხედავთ და იქ 1 აქ,
1 აპირებს bump იგი.
და ის აპირებს დასრულდება მიმდინარეობს შეხვდნენ მაინც.
>> ასე რომ, საუკეთესო შემთხვევაში, ეს რეალურად იქნება n.
თუ თქვენ გაქვთ 1, 2, 3, 4, 5, 6, 7, 8, თქვენ
აპირებს მეშვეობით რომ მთელი სია ერთხელ
შეამოწმეთ თუ ყველაფერი კარგად არის.
ყველას მკაფიო გაშვებული ჯერ შერჩევა ისევე?
მე ვიცი, მე ვაპირებ მეშვეობით ამ მართლაც სწრაფი.
მაგრამ ვიცი, რომ თუ თქვენ იცით, ზოგადი ცნებები, თქვენ უნდა იყოს კარგი.
OK.
ასე რომ, მე მხოლოდ მოგცემთ ბიჭები შესაძლოა, ისევე, წუთში გაიგო, რომ თქვენი მეზობლები
თუ რა არის რამოდენიმე მთავარი სხვაობა
შორის ამ ტიპის სახის.
ჩვენ წავიდეთ, რომ მალე.
აუდიტორია: Oh, OK.
Andi Peng: ჰო.
OK.
Cool, მოდით შეკრებას, როგორც კლასი.
OK.
ასე რომ, ეს იყო ერთგვარი ღია შეკითხვის იმ გაგებით,
რომ არსებობს უამრავი პასუხი.
და ჩვენ წავიდეთ მეტი ზოგიერთი მათგანი მოკლედ.
მე უბრალოდ მინდოდა თქვენ ბიჭები ფიქრი რა დიფერენცირებული
სამივე სახის.
და გავიგე, ასევე, დიდი კითხვა რას შერწყმა დალაგების გავაკეთოთ?
დიდი კითხვა, იმიტომ, რომ ის, რაც ჩვენ მოიცავს შემდეგ.
>> ასე რომ შერწყმა დალაგების არის ერთი სახის, რომ ფუნქციები
ძალიან განსხვავებულად სხვა სახის.
როგორც შენ შეიძლება see-- დავით გაკეთება, რომ დემო
სადაც მას ჰქონდა ყველა მაგარი noises ვხედავთ, როგორ შერწყმა
სახის გაიქცა, როგორც, უსასრულოდ სწრაფად, ვიდრე სხვა ორი სახის?
OK.
ასე რომ, ეს იმიტომ, რომ შერწყმა დალაგების ახორციელებს, რომ გათიშე
და დაიპყროთ კონცეფცია, რომელიც ჩვენ ვისაუბრეთ ბევრი ლექცია.
იმ გაგებით, რომ ჩვენ მინდა მუშაობა მსოფლიოს სასურველი სტუმარი გახდებით, არ დამძიმდა, როდესაც თქვენ დაყოფის
და დაიპყროთ პრობლემები, და შესვენება მათ ქვემოთ, შემდეგ კი ისინი ერთად,
კარგი რამ ყოველთვის ხდება.
>> ასე რომ გზა, რომ შერწყმა დალაგების არსებითად მუშაობს
არის ის, რომ ჰყოფს დაუხარისხებელი მასივი ნახევარი.
და მაშინ ის რაღაც ორ ნაწილად მასივები.
და ეს მხოლოდ სახის ამ ორ ნაწილად.
უბრალოდ ნიშანდობლივია გამყოფი ნახევარი, ნახევარი, ნახევარი, სანამ ყველაფერი დალაგებულია
და შემდეგ რეკურსიული აყენებს ეს ყველაფერი ერთად.
>> ასე რომ, რეალურად აბსტრაქტული.
ასე რომ, ეს უბრალოდ ცოტა pseudocode.
თუ არა, რომ აზრი გზა ის გაშვებული?
ასე რომ, მოდით უბრალოდ, ვამბობთ თქვენ გაქვთ მასივი N ელემენტები, არა?
თუ n ნაკლებია, ვიდრე 2, შეგიძლიათ დაბრუნდეს.
იმის გამო, რომ თქვენ იცით, რომ, თუ არსებობს მხოლოდ ერთი რამ, ეს უნდა იყოს გადანაწილებული.
სხვაგან, დასალაგებლად მარცხენა ნახევარში, და მაშინ დასალაგებლად მარჯვენა ნახევარში,
და მაშინ შერწყმა.
>> ასე რომ, მიუხედავად იმისა, რომ როგორც ჩანს, მართლაც ადვილია, სინამდვილეში, ფიქრობს, რომ ეს არის
სახის რთული. იმის გამო, რომ თქვენ, როგორიცაა, ისე, რომ სახის გაშვებული თავად.
მარჯვენა?
ის გაშვებული თავად.
ასე რომ, ამ თვალსაზრისით, დავით შეეხო საფუძველზე უკან კლასში.
და ეს კონცეფცია ჩვენ ვსაუბრობთ მეტი.
ის, რომ, ამ ორი ხაზი აქ, რეალურად არის პროგრამა
ვეუბნებოდი, რომ აწარმოებს თავად სხვადასხვა შეყვანა.
ასე რომ, ვიდრე აწარმოებს თავად მთლიანად N ელემენტები,
შეგიძლიათ შესვენება მას შევიდა მარცხენა ნახევარში და მარჯვენა ნახევარში
და შემდეგ გაუშვით ერთხელ.
>> და მაშინ ჩვენ შევხედოთ მას ვიზუალურად, იმიტომ, რომ მე ვიზუალური მოსწავლეზე.
იგი მუშაობს უკეთესი ჩემთვის.
ასე რომ, ჩვენ შევხედოთ ვიზუალური მაგალითი აქ.
>> მოდით ვთქვათ, რომ ჩვენ გვაქვს მასივი, ექვსი ელემენტები, 3, 5, 2, 6, 4, 1, არ არის დახარისხებული.
ყველა უფლება, იქ არის ბევრი ამ გვერდზე.
ასე რომ, თუ თქვენ ბიჭები შეიძლება შევხედოთ პირველი ნაბიჯი აქ, 3, 5, 2, 6, 4, 1,
თქვენ შეგიძლიათ გაყოფილი ის ნახევარზე.
თქვენ გაქვთ 3, 5, 2, 6, 4, 1.
თქვენ იცით, რომ ეს aren't-- თქვენ არ ვიცი, თუ ისინი დახარისხებული თუ არა,
ასე რომ თქვენ გაქვთ არღვევს მათ ქვემოთ, ნახევარი, ნახევარი, ნახევარი, სანამ საბოლოოდ,
თქვენ გაქვთ მხოლოდ ერთი ელემენტი.
და ერთ ელემენტს ყოველთვის დალაგებულია, არა?
>> ჩვენ ვიცით, რომ 3, 5, 2, 4, 6, 1, თავად, დახარისხებული.
და ახლა ჩვენ შეგვიძლია ისინი უკან ერთად.
ასე რომ, ჩვენ ვიცით, 3, 5.
ჩვენ იმ ერთად.
ჩვენ ვიცით, რომ არის დახარისხებული.
2 ის ჯერ კიდევ არსებობს.
ჩვენ შეგვიძლია დააყენა 4 და 6 ერთად.
ჩვენ ვიცით, რომ დახარისხებული, ამიტომ ჩვენ რომ ერთად.
და 1 არ არის.
>> და მაშინ უბრალოდ შევხედოთ ამ ორი halves უფლება აქ.
თქვენ გაქვთ 3, 5, 2, 2, 3, 5.
შეგიძლიათ უბრალოდ შედარება ყველაფრის დასაწყისია.
იმის გამო, რომ თქვენ იცით, რომ ეს არის დახარისხებული და თქვენ იცით, რომ დახარისხებული.
ასე რომ, თქვენ კი არ უნდა შედარების 5, უბრალოდ შედარების 3.
და 2 ნაკლებია, ვიდრე 3, ასე თქვენ იცით, 2 უნდა წავიდეს ბოლომდე.
>> იგივე იქ.
1 უნდა წავიდეს აქ.
და მაშინ, როდესაც მიდიხარ დააყენა ის ორი ღირებულებებს ერთად,
თქვენ იცით, რომ ეს არის გადანაწილებული და თქვენ იცით, რომ დალაგებულია.
ასე რომ, 1 და 2, 1 2 დღეზე ნაკლები.
ეს ეუბნება, რომ 1 უნდა წავიდეს ბოლოს ეს
გარეშე კი შევხედავთ 3 ან 5.
და მაშინ 4, შეგიძლიათ მხოლოდ შეამოწმეთ, მიდის უფლება აქ.
თქვენ არ გაქვთ შევხედოთ 5.
იგივე 6.
თქვენ იცით, რომ 6-- ეს მხოლოდ არ უნდა იყოს ჩანდა.
>> ასე რომ, ამ გზით, თქვენ მხოლოდ გადარჩენის საკუთარ თავს
ბევრი ნაბიჯები, როდესაც თქვენ შედარებით.
თქვენ არ უნდა შეადაროთ ყველა ელემენტს წინააღმდეგ სხვა ელემენტებს.
თქვენ უბრალოდ შედარება წინააღმდეგ პირობა რომ თქვენ უნდა შეადაროთ ის წინააღმდეგ.
ასე რომ, ერთგვარი აბსტრაქტული ცნება.
არ აწუხებს, თუ ეს არ არის საკმაოდ დარტყმის უფლება არავის გაუკეთებია.
მაგრამ ზოგადად, ეს არის როგორ შერწყმა დალაგების მუშაობს.
კითხვები, სწრაფი კითხვები, სანამ გადავა?
ჰო.
>> აუდიტორია: ასე რომ თქვენ თქვით, რომ მიიღოს 1 და შემდეგ 4 და 6
და ამით მათ.
ასე რომ, არ არის those-- არ თქვენ ეძებს მათ
როგორც ცალკეული ელემენტები, არა როგორც მთელი?
Andi Peng: ჰო.
ასე რომ, რა ხდება არის, რომ თქვენ, ძირითადად,
ვქმნით ახალ მასივი.
ასე, რომ თქვენ იცით, რომ აქ, მე მაქვს ორი კოლექტორები ზომა 3, არა?
ასე, რომ თქვენ იცით, რომ ჩემი დახარისხებული მასივი უნდა ჰქონდეს ექვსი ელემენტები.
ასე, რომ თქვენ უბრალოდ შექმნათ ახალი თანხის მეხსიერება.
ასე რომ, თქვენ სახის მოსწონს უკვე არარაციონალური მეხსიერება,
მაგრამ, რომ არ აქვს მნიშვნელობა იმიტომ, რომ ეს იმდენად მცირე.
ასე, რომ თქვენ შევხედოთ 1 და გადავხედავთ 2.
და თქვენ იცით, რომ 1 ნაკლებია 2.
ასე, რომ თქვენ იცით, რომ 1 უნდა წავიდეს დასაწყისში ყველა იმ.
>> თქვენ კი არ უნდა შევხედოთ 3 და 5.
ასე რომ თქვენ იცით 1 მიდის იქ.
მაშინ ძირითადად chop off 1.
ეს, ისევე, როგორც მკვდარი ჩვენთვის.
მაშინ ჩვენ უბრალოდ 2, 3, 5, და მერე 4 და 6.
და მაშინ თქვენ იცით, რომ თქვენ შედარების 4 და 2,
oh, 2 უნდა წავიდეს იქ.
ასე, რომ თქვენ ვეცემით 2 ქვემოთ, თქვენ chop ეს off.
ასე რომ, თქვენ უბრალოდ უნდა 3 და 5 4 და 6.
თქვენ უბრალოდ შეინახოს ტყეში ეს off სანამ დააყენა მათ მასივი.
>> აუდიტორია: ასე რომ თქვენ მხოლოდ ყოველთვის შედარებით [INAUDIBLE]?
>> Andi Peng: ზუსტად.
ასე რომ, ამ მხრივ, თქვენ უბრალოდ შედარებით, არსებითად,
ერთი ნომერი, წინააღმდეგ მეორე ნომერი.
და იმიტომ, რომ თქვენ იცით, რომ ეს დახარისხებული, თქვენ
არ უნდა გაეცნონ ყველა ნომრები.
თქვენ უბრალოდ უნდა შევხედოთ პირველი.
და მაშინ თქვენ შეგიძლიათ უბრალოდ plop მათ ქვემოთ, იმიტომ, რომ თქვენ იცით,
მათ ეკუთვნის, სადაც ისინი უნდა ეკუთვნოდეს.
ჰო.
კარგი კითხვაა.
>> და მაშინ, თუ თქვენ არის ცოტა ამბიციური,
მოგერიდებათ გადავხედავთ ამ კოდი.
ეს არის რეალურად ფიზიკური განხორციელება
როგორ ჩვენ წერენ შერწყმა დალაგების.
და თქვენ შეგიძლიათ ნახოთ, ძალიან მოკლე.
მაგრამ იდეები უკან ეს არის საკმაოდ რთული.
ასე რომ, თუ თქვენ გრძნობს, როგორც ხატვის ამ out თქვენს დავალებას დღეს, მოგერიდებათ.
>> OK.
ასე რომ, დავითი წავიდა ეს ლექცია.
რა არის საუკეთესო შემთხვევაში runtimes, უარეს შემთხვევაში runtimes,
და მოსალოდნელი runtimes შერწყმა დალაგების?
რამდენიმე წამი ვფიქრობ.
ეს არის საკმაოდ რთული, მაგრამ სახის ინტუიციური თუ ფიქრობთ, რომ ეს.
ყველა უფლება.
>> აუდიტორია: უარეს შემთხვევაში ო ჟურნალი ო?
Andi Peng: ზუსტად.
და რატომ არის იგი N შეხვიდეთ n.
>> აუდიტორია: არის თუ არა ეს იმიტომ, რომ ეს ხდება exponentially უფრო სწრაფად,
ასე რომ, როგორც ფუნქცია, რომელიც ნაცვლად უბრალოდ მყოფი n
კვადრატში ან რამე?
Andi Peng: ზუსტად.
ასე რომ, თუ რატომ runtime ამ არის N შესვლა
n არის იმიტომ, რომ ის, რაც ხარ აკეთებს ყველა ეს ნაბიჯი?
თქვენ მხოლოდ ტყეში ის ნახევარზე, არა?
ასე რომ, როდესაც ჩვენ ვაკეთებთ შესვლა, რომ ყველა ის აკეთებს
არის გამყოფი პრობლემა ნახევარი, ნახევარი, ნახევარი, უფრო halves.
ამ მხრივ, შეგიძლიათ სახის საქართველოს აღმოფხვრას ხაზოვანი მოდელი
რომ ჩვენ უკვე გამოყენებით.
იმის გამო, რომ, როდესაც თქვენ chop რამ ნახევარი, ეს ჟურნალი.
ეს მხოლოდ მათემატიკური გზა წარმოადგენს იგი.
>> და ბოლოს, ბოლოს, თქვენ მხოლოდ მიღების ერთი ბოლო გადის
იმისათვის, რომ ყველა მათგანი, რათა, არა?
ასე რომ, თუ თქვენ უბრალოდ უნდა შეამოწმეთ ერთი რამ, რომ ო.
ასე რომ, თქვენ სახის გამრავლებით ორი ერთად.
ასე რომ, როგორც თქვენ მოხვდით, რომ საბოლოო შევამოწმოთ n ქვემოთ აქ ჟურნალი n
აქ.
და თუ გავამრავლებთ მათ, რომ N შეხვიდეთ n.
>> ასე რომ, საუკეთესო შემთხვევაში და უარეს საქმე და ელოდებიან და ყველა N შეხვიდეთ n.
ეს არის ასევე როგორც სხვა სახის.
ეს იგივეა, შერჩევის დალაგების იმ გაგებით, რომ ის
არ აქვს მნიშვნელობა რა თქვენი სიაში არის, ის უბრალოდ აპირებს
უნდა გავაკეთოთ იგივე ყოველ ერთ დროს.
OK.
ასე რომ, როგორც ბიჭებს ვხედავ, მიუხედავად იმისა, სახის, ჩვენ წავიდა through-- n
კვადრატი, ეს არ არის ძალიან ეფექტური.
და მაშინაც კი, ამ N ჟურნალი ო არ არის ყველაზე ეფექტური.
თუ ბიჭები არიან ცნობისმოყვარენი, არსებობს ერთგვარი მექანიზმები
რომ იმდენად ეფექტური, რომ ისინი თითქმის არსებითად ბინა runtime.
>> თქვენ მოხვდით გარკვეული log n ს.
თქვენ მოხვდით გარკვეული ჟურნალი ჟურნალი ო ს.
ჩვენ არ შევეხო მათ ამ კლასში ახლავე.
მაგრამ, თუ ბიჭები არიან ცნობისმოყვარენი, მოგერიდებათ google, რა არის
ყველაზე ეფექტური დახარისხება მექანიზმები.
მე არ ვიცი, არსებობს მართლაც სასაცილოა პირობა,
მოსწონს არსებობს გარკვეული ნამდვილად სასაცილო პირობა, რომ ხალხი.
და თქვენ მაინტერესებს, როგორ ოდესმე ეგონა, რომ.
ასე რომ, google, თუ თქვენ გაქვთ რაიმე სათადარიგო დროს,, რა სასაცილო გზა
რომ ადამიანები, ისევე როგორც ეფექტური ways-- ადამიანი
უკვე შეუძლია განახორციელოს ჯიშები.
OK.
და აქ მხოლოდ პატარა მოსახერხებელი გრაფიკი.
მე ვიცი, რომ ყველა თქვენ, მანამდე ინტელექტუალური 0, იქნება თქვენს ოთახში ალბათ ცდილობს
გვემახსოვრება, რომ.
ასე რომ, ლამაზი იქ თქვენ ბიჭები.
უბრალოდ არ უნდა დაგვავიწყდეს, რომ ლოგიკა, რომელიც made-- ამიტომ, ის ნომრები ხდება.
თუ თქვენ ყოველთვის დაკარგა, უბრალოდ დარწმუნდით, რომ თქვენ იცით, თუ რა სახის არის.
და თქვენ შეგიძლიათ აწარმოებს მეშვეობით მათ თქვენი გონება
გაერკვნენ, თუ რატომ იმ პასუხი იმ პასუხებს.
>> ყველა უფლება.
ასე რომ, ჩვენ ვაპირებთ გადაადგილება წლის ბოლოს, ძებნას.
იმის გამო, რომ, როგორც იმ თქვენ, ვინც წაიკითხა pset,
სამძებრო ასევე ნაწილი ამ კვირის პრობლემა კომპლექტი.
თქვენ მოგეთხოვებათ განახორციელოს ორი სახის ეძებს.
ერთი არის წრფივი ძიება და ერთი არის ორობითი ძებნა.
>> ასე რომ, ხაზოვანი ძებნა საკმაოდ მარტივია.
თქვენ უბრალოდ უნდა ვეძებოთ ელემენტი სიაში თუ თქვენ მიიღოს იგი.
თქვენ უბრალოდ უნდა iterate მეშვეობით.
და თუ ეს უდრის რაღაც, თქვენ შეგიძლიათ დააბრუნებს მას, არა?
მაგრამ ერთი, რომ ჩვენ ყველაზე დაინტერესებული ვსაუბრობთ
არის ორობითი ძებნა, უფლება, რომელიც არის გათიშე და დაიპყროთ მექანიზმი, რომელიც
დავით დემონსტრირება იყო ლექცია.
>> დამახსოვრება სატელეფონო წიგნი მაგალითად რომ ინახავს აღზრდა,
ერთი, რომ სახის იბრძოდა ცოტა გასულ წელს,
სადაც თქვენ დაყოს პრობლემა ნახევარი, ნახევარი, ნახევარი, ისევ და ისევ,
სანამ თქვენთვის, თუ რას ეძებს?
და თქვენ მოხვდით runtime, რომელიც ასევე.
და თქვენ შეგიძლიათ ნახოთ, ეს მნიშვნელოვნად უფრო ეფექტური
ვიდრე ნებისმიერი სხვა ტიპის ძიება.
>> ასე რომ, ისე, რომ ჩვენ წავიდოდა შესახებ განხორციელების ორობითი ძებნა
არის, თუ ჩვენ გვქონდა მასივი, ინდექსი 0 6, შვიდი ელემენტები,
ჩვენ შეგვიძლია შუა, right-- ვწუხვარ, თუ ჩვენს კითხვაზე, პირველი
თუ ჩვენ გვინდა ვთხოვოთ შეკითხვას, აკეთებს მასივი შეიცავს ელემენტს 7,
ცხადია, უკვე ადამიანებს, და რომელსაც ასეთი პატარა მასივი, ადვილი ჩვენთვის
ვთქვა, დიახ.
მაგრამ გზა განახორციელოს ორობითი ძიება იქნებოდა მოსაძებნად შუა.
>> ჩვენ ვიცით, რომ ინდექსი 3 შუა, იმიტომ, რომ ჩვენ
ვიცი, არსებობს შვიდი ელემენტები.
რა 7 გაყოფილი 2?
შეგიძლიათ chop off, რომ დამატებით 1.
თქვენ მოხვდით 3 შუა.
ასე რომ, მასივი 3 = 7?
ეს არ არის, უფლება?
მაგრამ ჩვენ შეგვიძლია ამის გაკეთება რამდენიმე ამოწმებს.
არის მასივი 3 7-ზე ნაკლები ან არის მასივი 3 მეტია 7?
>> და ჩვენ ვიცით, რომ ეს 7-ზე ნაკლები.
ჩვენ ვიცით, რომ, ოჰ, ეს უნდა არ უნდა იყოს მარცხენა ნახევარში.
ჩვენ ვიცით, რომ ეს უნდა იყოს მარჯვენა ნახევარში, არა?
ასე რომ ჩვენ შეგვიძლია უბრალოდ Chop off ნახევარი მასივი.
ჩვენ კი არ უნდა შევხედოთ მას აღარ.
იმიტომ, რომ ჩვენ ვიცით, რომ ნახევარი ჩვენი პრობლემა
ჩვენ ვიცით, რომ პასუხი არის მარჯვენა ნახევარში ჩვენი პრობლემა.
ასე რომ, ჩვენ უბრალოდ შევხედოთ, რომ ახლა.
>> ასე რომ, ახლა ჩვენ შევხედოთ შუა რა დარჩა.
ეს მაჩვენებელი 5.
ჩვენ იგივე გამშვები ერთხელ და ჩვენ ვხედავთ, რომ ეს არის პატარა.
ასე შევხედავთ, რომ მარცხნივ რომ.
და მაშინ ჩვენ ვხედავთ, რომ ქვითარი.
არის მასივი ღირებულება ინდექსი 4 = 7?
ეს არის.
ასე რომ, ჩვენ შეიძლება დაბრუნდეს ჭეშმარიტი, რადგან აღმოჩნდა, მნიშვნელობა ჩვენს სიაში.
არა ისე, მე გაიარა რომ აზრი, რომ ყველას?
OK.
მე მივცემ თქვენ ბიჭები შესაძლოა, ისევე, სამი, ოთხი წუთის გაერკვნენ
როგორ Pseudocode ეს.
>> ასე რომ, წარმოიდგინეთ მე გთხოვეთ დაწერა ფუნქცია მოუწოდა ძებნა (), რომელიც დაბრუნდა
მნიშვნელობა, ლოგიკური მნიშვნელობა, რომ იყო true ან false, როგორიცაა,
ასეა თუ ი მნიშვნელობა, ცრუ თუ თქვენ არ.
და მაშინ იყო გავიდა ღირებულება თქვენ
ეძებს შევიდა ღირებულებები, რომელიც არის მასივი რა, მე აუცილებლად დააყენა
რომ არასწორი ადგილი.
OK.
Anyways, რომ უნდა ჰქონდეს უკვე მარჯვნივ ღირებულებებს.
და მაშინ int n რაოდენობის ელემენტები, რომ მასივი.
როგორ წავიდეთ შესახებ ცდილობს რომ Pseudocode, რომ პრობლემა?
მე მივცემ თქვენ ბიჭები მოსწონს სამ წუთში უნდა გააკეთოს, რომ.
არა, მე ვფიქრობ, რომ only-- ჰო, არსებობს ერთი სწორი აქ.
აუდიტორია: შემიძლია?
Andi Peng: ჰო, მე თქვენ.
ის არის, რომ სამუშაო?
OK, მაგარი.
>> OK.
ყველა უფლება ბიჭები, ჩვენ აპირებს გაკონტროლების იგი.
OK.
ასე რომ, ვივარაუდოთ, რომ ჩვენ მივიღეთ ამ ლამაზი პატარა მასივი n ღირებულებების იგი.
მე არ შევაჩერო ხაზები.
მაგრამ როგორ ჩვენ შესახებ ცდილობს დაწეროს ეს?
ვინმეს სურს მომეცი პირველი ხაზი?
თუ გსურთ, რომ მომეცი პირველი ხაზი ამ pseudocode.
>> აუდიტორია: [INAUDIBLE]
აუდიტორია: თქვენ მინდა iterate მეშვეობით
აუდიტორია: კიდევ ერთი for loop?
აუდიტორია: --for.
>> Andi Peng: ასე რომ, ეს ერთი ცოტა სახიფათო.
ვფიქრობ დაახლოებით გსურთ შენარჩუნება გაშვებული ამ მარყუჟის
უსასრულოდ სანამ, როდესაც?
>> აუდიტორია: სანამ [INAUDIBLE] მნიშვნელობა უდრის, რომ მნიშვნელობა.
Andi Peng: ზუსტად.
ასე რომ, შეგიძლიათ რეალურად უბრალოდ წერა ჩვენ შეგვიძლია კიდევ გამარტივება უფრო.
ჩვენ შეგვიძლია უბრალოდ, ხოლო მარყუჟის, არა?
ასე რომ, შეგიძლიათ უბრალოდ მარყუჟის ჩვენ ვიცით, რომ ეს ცოტა ხნით.
მაგრამ ახლა, მე ვაპირებ ამბობენ, რომ "მარყუჟი" - მეშვეობით, თუ რა?
Loop until-- რა არის ჩვენი დამთავრებული მდგომარეობა?
მე ვფიქრობ, რომ მე მოვისმინე.
გავიგე ვინმე ვთქვათ.
>> აუდიტორია: Values ​​ტოლია შუა.
Andi Peng: ამბობენ, რომ ეს კიდევ ერთხელ.
აუდიტორია: ან, სანამ მნიშვნელობა თქვენ ეძებს
არის ტოლი შუა ღირებულება.
>> Andi Peng: მერე რა, რომ არ არსებობს?
რა მოხდება, თუ მნიშვნელობა თქვენ ეძებს ამისთვის არ არის რეალურად ამ მასივი?
აუდიტორია: თქვენ დაბრუნდება 1.
>> Andi Peng: მაგრამ რა გვინდა მარყუჟი სანამ, თუ ჩვენ გვაქვს მდგომარეობა?
ჰო.
>> აუდიტორია: სანამ არსებობს მხოლოდ ერთი მნიშვნელობა?
Andi Peng: თქვენ შეგიძლიათ loop until-- ასე რომ თქვენ იცით, რომ თქვენ
აპირებს აქვს მაქსიმალური ღირებულება, არა?
და თქვენ იცით, რომ თქვენ აპირებთ აქვს წთ ღირებულება, არა?
იმის გამო, ასევე, რომ რაღაც დამავიწყდა იმის თქმა ადრე,
რომ ის, რაც არის კრიტიკული ორობითი ძებნა
ის არის, რომ თქვენს მასივი უკვე დახარისხებული.
იმის გამო, რომ სხვა გზა არ აკეთებს ამ შემთხვევაში ისინი უბრალოდ შემთხვევითი ღირებულებებს.
თუ თქვენ არ იცით, თუ ერთი არის უფრო დიდი, ვიდრე სხვა, არა?
>> ასე, რომ თქვენ იცით, რომ თქვენი max და თქვენი წთ აქ ვართ, არა?
თუ თქვენ აპირებთ უნდა მორგება თქვენი max თქვენს წთ და mid--
მოდით უბრალოდ ვივარაუდოთ, თქვენი შუა მნიშვნელობა სწორედ აქ
თქვენ აპირებს ძირითადად loop სანამ თქვენი მინიმუმი
დაახლოებით იგივე, რაც თქვენს max, მარჯვნივ, ან თუ თქვენი მაქსიმალური არის იგივე, რაც თქვენი წთ.
მარჯვენა?
იმის გამო, რომ როცა ეს მოხდება, თქვენ იცით, რომ თქვენ საბოლოოდ მოხვდა იგივე ღირებულება.
ასე რომ გსურთ loop სანამ თქვენი წთ ნაკლებია ან ტოლი oops,
არა ნაკლები ან ტოლია სხვა გზა around-- max არის.
>> იცოდით, რომ აზრი?
მე მივიღე რამდენიმე ცდილობს, რომ უფლება.
მაგრამ loop სანამ თქვენი max მნიშვნელობა არსებითად თითქმის ნაკლები
მეტი ან ტოლია თქვენი მინიმალური, არა?
ეს მაშინ, როდესაც თქვენ იცით, რომ თქვენ თანხვედრა.
აუდიტორია: როცა გვინდა თქვენი მაქსიმალური ღირებულება იქნება ნაკლები მინიმალური?
Andi Peng: თუ თქვენ გაქვთ მორგება, რომელიც
არის ის, რაც ჩვენ ვაპირებთ უნდა აკეთებს ამ.
ამას რამე აზრი აქვს?
მინიმალური და მაქსიმალური არის მხოლოდ რიცხვებით, რომ ჩვენ, ალბათ,
აპირებს შევქმნა შენარჩუნება ტრეკზე სადაც ჩვენ ვეძებთ.
იმის გამო, რომ მასივი არსებობს მიუხედავად იმისა, თუ რას ვაკეთებთ ჩვენ.
ისევე, როგორც ჩვენ, ფაქტობრივად, არ ფიზიკურად chopping off მასივი, არა?
ჩვენ უბრალოდ მორგება სადაც ჩვენ ვეძებთ.
ამას რამე აზრი აქვს?
>> აუდიტორია: Yeah.
>> Andi Peng: OK.
ასე რომ თუ ეს პირობა ჩვენი მარყუჟის, რა გვინდა შიგნით ამ loop?
რას აპირებს იყოს სურვილს?
ასე რომ, ახლა, ჩვენ მივიღეთ მაქსიმალური და წუთი, მარჯვენა,
ალბათ ის აქ სადღაც.
ჩვენ ვაპირებთ, რომ, ალბათ, სურს მოძიების შუა, არა?
როგორ მივდივართ უნდა იყოს შევძლოთ შუა?
რა არის mathematical--
აუდიტორია: Max პლუს წთ გაყოფილი 2.
Andi Peng: ზუსტად.
ამას რამე აზრი აქვს?
და ბიჭები, თუ რატომ ეს არ არის მხოლოდ გამოიყენოს ამიტომ, ჩვენ გავაკეთეთ ეს
ნაცვლად აკეთებს უბრალოდ ო იყოფა 2?
ეს იმიტომ, რომ n არის ღირებულება რომ აპირებს იგივე რჩება.
მარჯვენა?
მაგრამ, როგორც ჩვენ შეცვალოს ჩვენი მინიმალური და მაქსიმალური ღირებულებები, ისინი აპირებენ, რომ შეიცვალოს.
ამის შედეგად, ჩვენი საშუალო შეიცვლება ძალიან.
ასე რომ, რატომ გვინდა, უნდა გავაკეთოთ ეს უფლება აქ.
OK.
>> და შემდეგ, ახლა, რომ ჩვენ აღმოვაჩინეთ our-- yeah.
>> აუდიტორია: უბრალოდ სწრაფი კითხვა როცა ამბობენ, მინ და მაქს,
ჩვენ ვთქვათ, რომ ეს უკვე გადანაწილებული?
>> Andi Peng: ჰო, ფაქტიურად წინაპირობა ორობითი ძებნა,
რომ თქვენ უნდა იცოდეს, ეს დახარისხებული.
სწორედ ამიტომ ერთგვარი, თქვენ დაწეროთ თქვენი პრობლემა კომპლექტი სანამ თქვენი ორობითი ძებნა.
OK.
ასე, რომ ახლა ჩვენ ვიცით, სადაც ჩვენი შუაში არის, რა გინდა აქ?
>> აუდიტორია: ჩვენ გვინდა, რომ შეადაროთ რომ მეორე.
Andi Peng: ზუსტად.
ასე, რომ თქვენ ვაპირებთ შედარების შუა ღირებულება, არა?
და რა, რომ გითხრათ, ჩვენს როდესაც ჩვენ შედარება?
რა გვინდა ჩვენ უნდა გავაკეთოთ შემდეგ?
>> აუდიტორია: თუ ღირებულება არის დიდი ვიდრე შუა, ჩვენ გვინდა, მოიკვეთე იგი.
Andi Peng: ზუსტად.
ასე რომ, თუ ღირებულება არის დიდი ვიდრე შუა, ჩვენ
აპირებს მინდა, რომ შეიცვალოს ეს მინიმალური და maxes, არა?
რა გვინდა ჩვენ, რომ შეიცვალოს?
ასე რომ, თუ ჩვენ ვიცით, მნიშვნელობა სადღაც აქ, რას ჩვენ შეცვალოს?
ჩვენ გვინდა, რომ ჩვენი მინიმალური უნდა იყოს შუა, არა?
და მერე სხვას, თუ ის ამ ნახევარი, რა გვინდა, რომ შეიცვალოს?
>> აუდიტორია: თქვენი მაქსიმალური.
Andi Peng: ჰო.
და მაშინ თქვენ უბრალოდ აპირებს შენარჩუნება looping, არა?
იმის გამო, რომ მას შემდეგ, რაც ერთ-ერთი მცდელობაა მეშვეობით, თქვენ მოხვდით max აქ.
და მაშინ ხელახლა გადათვლა შუა რიცხვებში.
და შემდეგ შეგიძლიათ შეადაროთ.
და თქვენ შენარჩუნება აპირებს სანამ წთ და maxes
არსებითად თანხვედრა.
და ეს მაშინ, როდესაც თქვენ იცით, რომ თქვენ მოხვდა ბოლოს იგი.
და არც თქვენ ი ან თქვენ არ გაქვთ იმ ეტაპზე.
>> ნიშნავს თუ არა ეს აზრი ყველას?
OK.
ეს არის საკმაოდ მნიშვნელოვანი, იმიტომ, რომ თქვენ
დაწერა ამ თქვენი კოდი ამაღამ.
მაგრამ თქვენ ბიჭები აქვს საკმაოდ კარგი გრძნობა, რაც თქვენ უნდა აკეთებს,
რომელიც არის კარგი.
OK.
ამიტომ, ჩვენ მივიღეთ დაახლოებით შვიდი წუთი დარჩა განყოფილებაში.
ამიტომ, ჩვენ ვაპირებთ ვისაუბროთ ამ pset, რომ ჩვენ უნდა აკეთებს.
ასე რომ, pset იყოფა ორ ნაწილად.
პირველი ნახევარი მოიცავს ახორციელებს იპოვოს
რომელშიც წერთ ხაზოვანი ძიება, ორობითი ძებნის და დახარისხება ალგორითმი.
>> ასე რომ, ეს არის პირველი დრო pset, სადაც
ჩვენ ვიქნებით გაწვდით ბიჭები რასაც განაწილების კოდი, რაც კოდი
ჩვენ წინასწარ დაწერილი, მაგრამ მხოლოდ დაუტოვებიათ რამდენიმე ცალი off
თქვენ დასრულდება წერილობით.
ასე, რომ თქვენ ბიჭები, როდესაც თქვენ შეხედეთ ამ კოდი, შესაძლოა ნამდვილად ეშინია.
თუ თქვენ, ისევე, როგორც, ahh, მე არ ვიცი, რა რომ აკეთებს,
მე არ ვიცი, როგორც, რომ, როგორც ჩანს, ისე რთულია, ahh, დაისვენოთ.
ეს OK.
დაწვრილებით სპეც.
სპეც ავუხსნათ, თუ ზუსტად რა ყველა ამ პროგრამების ვაკეთებთ.
>> მაგალითად, generate.c არის პროგრამა რომ მოვა თქვენი pset.
თქვენ არ რეალურად უნდა შეეხოთ, მაგრამ თქვენ უნდა გვესმოდეს, რასაც ის აკეთებს.
და generate.c, ყველა ის აკეთებს ან გამოიმუშავებს შემთხვევითი რიცხვების
ან შეგიძლიათ მისცეს მას თესლი, ისევე როგორც დამონტაჟებული ნომერი, რომელიც სჭირდება,
და უფრო მეტი რაოდენობით.
ასე რომ, არსებობს კონკრეტული გზა განახორციელოს generate.c, რომელიც
თქვენ შეგიძლიათ მხოლოდ მიიღოს bunch of ნომრები თქვენ შეამოწმოთ თქვენი სხვა მეთოდები.
>> ასე რომ, თუ თქვენ სურდა, ამისთვის მაგალითად, შეამოწმოთ თქვენი ძებნა,
თქვენ სურს, რომ აწარმოებს generate.c, გენერირება bunch of ნომრები,
და შემდეგ აწარმოებს თქვენი დამხმარე ფუნქცია.
თქვენი დამხმარე ფუნქცია, სადაც თქვენ რეალურად ფიზიკურად წერა კოდი.
და ვფიქრობ, დამხმარე ბიბლიოთეკა ფაილი თქვენ წერილობით, რომ იპოვოს მოუწოდებს.
ასე რომ, ფარგლებში helpers.c, თქვენ ამის მოძიება და დახარისხება.
>> და მაშინ ვაპირებთ არსებითად მხოლოდ ისინი ყველა ერთად.
სპეც გეტყვით, თუ როგორ უნდა დააყენა, რომ ბრძანების ხაზი.
და თქვენ შეძლებთ შეამოწმოთ თუ არ არის თქვენი დალაგება და ძებნის მუშაობენ.
ზემოთ.
აქვს ვინმეს უკვე დაიწყო და შეექმნა პრობლემა ან კითხვა
მათ აქვთ უფლება, ახლა ეს?
OK.
>> აუდიტორია: მოითმინეთ.
მე მაქვს შეკითხვა.
>> Andi Peng: ჰო.
>> აუდიტორია: ასე დავიწყე აკეთებს ხაზოვანი ძიება helpers.c
და ეს არ იყო ნამდვილად მუშაობს.
მაგრამ შემდეგ, მივხვდი, ჩვენ მხოლოდ უნდა წაშალოთ და ამის ორობითი ძებნა.
ასე რომ, ეს არ აქვს მნიშვნელობა, თუ ის არ მუშაობს?
>> Andi Peng: მოკლე პასუხი არ არის.
მაგრამ მას შემდეგ, რაც ჩვენ not--
აუდიტორია: მაგრამ არავის რეალურად შემოწმების.
Andi Peng: ჩვენ არასდროს ვაპირებთ, რომ.
მაგრამ თქვენ ალბათ გინდათ დარწმუნდით, რომ თქვენი ძებნა მუშაობს.
იმიტომ, რომ თუ თქვენი წრფივი ძებნა არ მუშაობს,
მაშინ შანსი თქვენი ორობითი ძებნა არ იმუშავებს ისევე.
იმის გამო, რომ თქვენ გაქვთ მსგავსი ლოგიკა ორივე მათგანი.
და არა, ეს ნამდვილად არ აქვს.
ასე რომ, მხოლოდ თქვენ გახდეს ამ დალაგების და ორობითი ძებნა.
ჰო.
>> ასევე, ბევრი ბავშვები იყვნენ ცდილობს შეადგინოს helpers.c.
თქვენ არ რეალურად დაშვებული უნდა გავაკეთოთ, რომ, რადგან helpers.c
ამჯამად არ აქვს მთავარი ფუნქცია.
ასე რომ, თქვენ უნდა მხოლოდ რეალურად შედგენა
გენერირება და იპოვოს, იმიტომ, რომ ნახავთ მოუწოდებს helpers.c და ფუნქციების ფარგლებში.
ასე რომ, რაც გამართვის ტკივილი კონდახით.
მაგრამ ის, რაც ჩვენ უნდა გავაკეთოთ.
აუდიტორია: თქვენ უბრალოდ ყველა, არა?
Andi Peng თქვენ შეგიძლიათ მხოლოდ რათა ყველა, ისევე, yeah.
OK.
ასე რომ, ის თვალსაზრისით, თუ რა საქართველოს pset გეკითხებით ყველა უნდა გააკეთოს.
თუ თქვენ გაქვთ რაიმე შეკითხვები, შეგიძლიათ უფასო მკითხავთ შემდეგ სექციაში.
მე ვიქნები აქ, ისევე, 20-ე წუთზე.
>> და ჰო, pset ს ნამდვილად არ არის, რომ ცუდი.
თქვენ ბიჭები უნდა იყოს OK.
ეს, უბრალოდ მიჰყევით პრინციპებს.
სახის ჰქონდეს განცდა, ლოგიკურად, რა უნდა ხდება და თქვენ იქნება ჯარიმა.
არ უნდა იყოს ძალიან ეშინია.
არსებობს ბევრი კოდი უკვე წერია.
არ უნდა იყოს ძალიან ეშინია თუ არ მესმის რა ყველა რომ ნიშნავს.
თუ ეს არის ბევრი, ეს სრულიად ჯარიმა.
და მოვიდა საათებში.
ჩვენ დაგეხმარებით შევხედოთ.
>> აუდიტორია: ერთად დამატებით ფუნქციები, არ გადავხედავთ იმ up?
>> Andi Peng: ჰო, ეს არის კოდი.
თამაშში 15, ნახევარი ეს უკვე დაწერილი თქვენთვის.
ასე რომ, ეს ფუნქციები უკვე კოდი.
Yep.
ყველა უფლება.
ისე, წარმატებებს გისურვებთ.
ეს არის ამაზრზენი დღეს.
ასე რომ, იმედია, თქვენ ბიჭები არ გრძნობს, ძალიან ცუდი რჩებიან შიგნით და კოდირებას.