>> JASON HIRSCHHORN: Welcome კვირაში სამი ყველას.
ჩვენ დაკავებული, მაგრამ საინტერესო განყოფილების წინ გველოდება.
ასე რომ, პირველ რიგში, იმიტომ, რომ ჩვენ გარკვეული headway ერთად რა თქმა უნდა, მაგრამ ჩვენ მაინც
არ ბევრი სწავლის დაუტოვებიათ გავაკეთოთ, მე ვარ აპირებს აჩვენებს, თუ ბიჭები გარკვეული რესურსები
რომ უნდა დაამტკიცოს, რომ იყოს წარმოუდგენლად გამოსადეგი როგორც თქვენ არა მხოლოდ მიახლოება თქვენი
პრობლემა ადგენს, არამედ დაიჯესტს ყველა მასალა მოგაწვდით ბიჭები
ლექციები და შორტები და განყოფილება.
>> მაშინ ჩვენ ვაპირებთ გაატაროთ პირველი 20 25 წუთის განყოფილების აპირებს მეტი
GDB, რომელიც თქვენ შეიძლება იყოს ან არ აქვს გამოიყენება ამ ეტაპზე, მაგრამ ეს
ძალიან სასარგებლო ინსტრუმენტი, რომელიც დაგეხმარებათ გამართვის თქვენი პროგრამებს.
ბევრი თქვენ შეიძლება არ გამოიყენება printf წელს შუა თქვენი პროგრამა გაერკვნენ
თუ რა ცვლადი შეადგინა.
GDB არის უფრო უკეთესი, ვიდრე printf და არ ხრახნიანი up თქვენი კოდი, რომ თქვენ
აწარმოებს შესრულებადი ფაილი.
ასე რომ, ჩვენ წავიდეთ მეტი 10 ყველაზე სასარგებლო ბრძანებები თქვენ უნდა GDB, და ჩვენ
აპირებს განახორციელოს ერთად ისე, პრობლემა მითითებული სამი და მის ფარგლებს გარეთ, თქვენ
შეგიძლიათ გამოიყენოთ GDB რათა დაეხმაროს გამართვის თქვენი პროგრამებს.
და ბოლოს, ჩვენ ვაპირებთ წავიდეთ მეტი რამდენიმე დახარისხება და ძიების ალგორითმები
რომ ვნახე ლექცია, და ჩვენ აპირებს რეალურად კოდი, არა მხოლოდ
pseudocode, მაგრამ კოდი ორობითი ძებნა, bubble sort, და შერჩევის ჯიშია.
>> ასე რომ, პირველ რიგში, მინდა წასვლა მეტი რესურსი.
ეს არის ვრცელი სია, და ეს პატარა შრიფტის რადგან მქონდა ბევრი
ეტევა აქ.
მაგრამ ეს იქნება არა მხოლოდ დაგეხმაროთ, ისევ და ისევ, პრობლემა კომპლექტი და
digesting ინფორმაცია თქვენთვის ცნობილი, მაგრამ აუცილებლად, მოვა ვიქტორინა დროს, ეს იქნება
იყოს ძალიან სასარგებლო.
ასე რომ, პირველი, ლექცია აღნიშნავს.
თუ წასვლა cs50.net/lectures და გადაახვიეთ განსაზღვრული კვირაში და დღეს,
თქვენ ნახავთ, რომ არსებობს აღნიშნავს, თითოეული ლექცია, რომელიც არ არის უბრალოდ
ტექსტს, მაგრამ რედაქციის რა იყო დაფარული ლექცია დავუკავშირდეთ კოდი
snippets და სხვა სასარგებლო tidbits.
მე მაღალ რეკომენდაციას აპირებს იმ.
და შემდეგ ასევე, არსებობს კოდის შესაძლებელია თითოეული ლექცია.
ისევ და ისევ, ეს სლაიდები ასევე იქნება ხელმისაწვდომია cs50.net/sections
ამ საღამოს.
>> ასე რომ, მეორე არის შორტები ყოველ კვირას, რომ საფარი საკითხები, როგორც წესი, 5 დან 15
ე სიგრძის.
და იმ იმედია მოგცემთ დიდი მაჩვენებელი, სხვადასხვა თემებზე.
მესამე -
და ეს არის ახალი ამ წელი - ეს არის study.cs50.net.
თუ თქვენ არ გადაამოწმა ის, I უაღრესად გირჩევთ რომ ამისათვის.
თქვენ უნდა აირჩიოთ თემაზე.
ჩვენ ათობით თემა არსებობს.
ასე მაგალითად, თქვენ შეარჩიო ფუნქციები.
ეს გაძლევთ გარკვეული სლაიდები და შენიშვნები ფუნქციები.
ეს არის, ფაქტობრივად, სლაიდები, TFs უნდა გამოიყენონ დროს ჩვენი
პრეზენტაციები სექციაში.
არსებობს ასევე რჩევები და ხრიკები საქმე ფუნქციებს, და იქ
პრაქტიკის პრობლემები, რომელიც დაეხმარება თქვენ მუშაობა ფუნქციები.
ჩვენ ასევე მოგაწვდით ბმულები მოკლე ფუნქციები და ჯერ რომ ფუნქციები
არ ამუშავება ლექცია.
ასე study.cs50.net, ახალი ამ წელს, ფანტასტიკური რესურსი.
>> შემდეგი, მე ადამიანი, რომელიც არის სახელმძღვანელო ბრძანება, რომელიც შეგიძლიათ აწარმოებს
ბრძანებათა სტრიქონიდან.
ასე რომ, თუ თქვენ გაქვთ რაიმე შეკითხვები ბრძანება, მაგალითად, rand, რომელიც ჩვენ
შეექმნა გასულ კვირას განყოფილებაში და თქვენ ალბათ გვხვდება
თქვენი პრობლემა კომპლექტი, როდესაც გადის გენერირება კოდი, მაგრამ თუ ჩაწერეთ კაცი
rand, თქვენ მიიღებთ გვერდზე რომ გიჩვენებთ ყველაფერი rand.
ეს გაძლევთ რა სჭირდება, პარამეტრები სჭირდება, ისევე, როგორც დაბრუნება
ტიპის და მოკლე აღწერა რომ ფუნქცია.
>> ასე რომ, შეამოწმეთ rand.
ეს შეიძლება იყოს პატარა wordy და დამაბნეველი, ამიტომ ზოგჯერ მე რომ
უბრალოდ Googling რა მინდა ვიცოდე არის საუკეთესო გზა, რათა იპოვოს პასუხი.
ასე რომ პრაქტიკის Google.
კიდევ კარგი Google.
ის გახდება თქვენი საუკეთესო მეგობარი.
>> ისევე როგორც Google, თუ თქვენ ვერ პოულობთ მას Google, cs50.net/discuss, ეს
ფორუმი.
შანსი, თუ თქვენ გაქვთ კითხვა, ერთი თქვენი 700 + თანატოლებს აქვს, რომ
კითხვა და სთხოვა ეს უკვე განიხილავს
ფორუმის და იგი პასუხობს.
ასე რომ, თუ თქვენ გაქვთ გავრცელებული შეკითხვა ან თქვენ გაქვთ კითხვა, რომ თქვენ ვფიქრობ
იქნებ სხვა ადამიანი შეიძლება არ გადაეყარონ, შეამოწმეთ cs50.net/discuss.
>> საბოლოოდ, ბოლო ორი, თუ გსურთ გაიგო, რომ ნამდვილი ადამიანი, საოფისე
საათები ორშაბათიდან პარასკევის ჩათვლით.
არსებობს ასევე ონლაინ საათებში გაგრძელების სტუდენტებს.
და ბოლო, მაგრამ ნამდვილად არ მინიმუმ, ჩემთვის, ძახილის წერტილი.
თქვენ ყველა ჩემი საკონტაქტო ინფორმაცია.
თუ თქვენ გჭირდებათ არაფერს, გთხოვთ არასოდეს მოგერიდებათ დამიკავშირდეს.
ყოველთვის მოგერიდებათ ამის გაკეთება.
ძალიან ცოტა თქვენ დასძინა me on Gchat, ასე რომ უკვე გულდასაწყვეტია,
მაგრამ იმედია, რომ ყველაფერს შეცვლის შორის ამ და მომდევნო სექციაში.
ნებისმიერი კითხვები ჯერჯერობით რესურსი?
დიდი.
>> და ბოლოს, კიდევ ერთი დანამატი for კავშირი, sayat.me/cs50.
შეგიძლიათ მომეცი ანონიმური კავშირი თუ როგორ ვაკეთებ.
ეს იყო ნამდვილად გამოსადეგი გასულ კვირას.
მე მივიღე რამდენიმე კომენტარი თქვენ ბიჭები მას შემდეგ, რაც განყოფილებიანი, პლუს დან
სხვა სტუდენტები, რომლებიც უყურებდა მას კვირის განმავლობაში, და ეს
იყო ძალიან სასარგებლო.
მე ვაპირებ ცდილობენ და შეზღუდოს ჩემი გამოყენება სიტყვა "ტკბილი", მაგრამ მე გაჩვენებთ ჩემს
ენთუზიაზმი და შფოთვა სხვა გზები.
მაგრამ იყო სხვა დამატებითი არსებითი გამოხმაურებას,
როგორც pluses და დელტა.
ასე რომ, გთხოვთ, მე გაძლევთ ბიჭები კავშირი თქვენი პრობლემა კომპლექტი.
მოგერიდებათ მომეცი კავშირი ჩემი სწავლება.
მე აქ თქვენ ბიჭები.
>> დიდი.
ეს არის ყველა მაქვს პირველი განყოფილება.
ვინმეს აქვს რაიმე შეკითხვები აქამდე?
და მაქვს შენიშვნა მართვის ცენტრი.
Extension სტუდენტი messaged me განაცხადა, რომ ისინი ვერ ვიღებთ ნებისმიერი აუდიო,
მაგრამ ეს არ არის ჩემი ძალა დაფიქსირება.
ასე რომ, იმედია, რომ იღებს მოგვარდება მალე.
თუ თქვენ თვალს შემოსული, hi, მაგრამ თქვენ ვერ მოისმენს ჩემთვის.
>> ასე რომ, პირველი, ჩვენ ვაპირებთ გავლა GDB.
GDB, როგორც მე მიანიშნა ადრე, არის გამართვის საშუალება
ბევრად უკეთესია, ვიდრე printf.
ასე რომ დავიწყოთ GDB, თქვენ ბიჭები, თუ გსურთ გახსნათ თქვენი მოწყობილობების
და მიიღოს ფაილი, რომელიც მე ელექტრონული ფოსტით თქვენ ადრე - ამ ფაილს ასევე იქნება
ხელმისაწვდომი ცოტა -
და აწარმოებს GDB. / სახელით ფაილი.
პირველი, რა თქმა უნდა, თქვენ უნდა შეადგინონ ფაილი რადგან GDB მუშაობს მხოლოდ
შესრულებადი ფაილი.
>> მაგრამ თუ ოდესმე გვინდა, რომ დაიწყოს GDB, პირველი, რასაც თქვენ აკეთებთ,
თქვენ აწარმოებს GDB. / Caesar.
ასე რომ პროგრამის დასახელება ჩვენ აპირებს წავიდეთ ერთად ეს ახლა.
ამიტომ მე ვაპირებ წერენ მიიღოს Caesar, რომელიც მომცემს შესრულებადი ფაილი
აქ მონიშნულია მწვანე.
და შემდეგ მე ვაპირებ აწარმოებს GDB. / Cesar.
>> და იქ წასვლა.
ხედავთ ჩვენ რაიმე ტექსტი მეუბნებოდა შესახებ მობილური GDB, მაძლევს
ზოგიერთი გარანტიის ინფორმაცია, და მაშინ ჩვენ აქვს მშპ prompt, რომელიც გამოიყურება სახის
მოსწონს ჩვენი ბრძანების სწრაფი, მაგრამ ხედავთ ის ღია
paren, GDB, ახლო paren.
სანამ ჩვენ ვაგრძელებთ და გამართვის ამ ფაილის რომ მე იგზავნება თქვენს რიგში, მოდით შევხედოთ
სასარგებლო ბრძანებები ამიტომ ჩვენ გვაქვს აზრი რა ჩვენ ვაპირებთ დაფარავს.
>> ეს ბრძანებები ჩამოთვლილი აქ იმისათვის, რომელშიც მე ზოგადად მათი გამოყენება.
ასე რომ დავიწყო ჩემი პროგრამის მიერ გაშვებული GBD. / პროგრამის სახელი,
ამ შემთხვევაში, Caesar.
და მაშინ პირველი, რასაც მე ვაკეთებ 99.9% დრო არის type შესვენების ნიშნავს.
რომელიც ადგენს შესვენების წერტილი მთავარ.
არსებითად, თუ რას აკეთებს იქ არის პროგრამა აპირებს შეწყვიტოს
მთავარი, ასე რომ თქვენ შეგიძლიათ დაიწყოთ საგამოცდო ეს ხაზი ხაზის, ვიდრე გაშვებული ყველა
გზას.
შეგიძლიათ შესვენება სხვადასხვა ქულა თქვენი კოდი, მაგრამ მთავარი არის ზოგადად
კარგი ადგილია დაიწყება.
>> შემდეგი ბრძანების მე აწარმოებს აწარმოებს.
რომელიც იწყება პროგრამა გაშვებული და თუ თქვენ უნდა მიუთითოთ command line
არგუმენტები, თქვენ აწარმოებს, რომ ბრძანება.
აწარმოებს არგუმენტები.
ასე რომ, რადგან ჩვენ ვაპირებთ მეტი მობილური C, რომელიც პროგრამის თქვენ ბიჭები
წერდა pset ორი -
ეს ერთი, რა თქმა უნდა, აქვს გარკვეული შეცდომები ის, რომ იმედია, ჩვენ იპოვით -
ჩვენ ვაპირებთ, რომ აწარმოებს ტირაჟი რამდენიმე ბრძანება ხაზი არგუმენტები, რადგან კეისარი,
როგორც თქვენ ბიჭები ვიცი პოსტი პრობლემა მითითებული Spec, სჭირდება გარკვეული
ბრძანების არგუმენტები.
>> მომდევნო რამდენიმე ბრძანებები, მომავალ ერთი რეალურად მოუწოდა მომავალი.
რომ ერთი იღებს თქვენ ხაზს თქვენი პროგრამა.
ასე რომ hitting n შემდეგ შეიყვანეთ მოგაწვდით შემდეგი ხაზი, შესრულებაში
წინა ხაზი.
ნაბიჯი არა მხოლოდ მოგაწვდით შემდეგი ხაზი, მაგრამ ეს
მოგაწვდით შიგნით ფუნქციები.
ასე რომ, თუ არ წერია ფუნქცია თქვენი კოდი ან თუ გსურთ შეისწავლონ
მე, მაგალითად, თქვენ შეგიძლიათ მოხვდა s, და ვიდრე აპირებს მომდევნო ხაზი
ფაილი, რომელიც თქვენ გადის უფლება ახლა, თქვენ რეალურად დახევას შევიდა
ეს ფუნქცია და ვნახოთ მისი კოდი.
>> სია გიჩვენებთ, ძალიან მოსახერხებელი ფორმატი, 10 ან იმდენად ხაზები გარშემო
სადაც თქვენ ამჟამად არის თქვენი კოდი ასე რომ თქვენ შეგიძლიათ რეალურად ვხედავ ფაილი
ვიდრე მქონე სვოპ უკან და მეოთხე შორის განსხვავებული შეხედულებები.
Print ჰგავს printf, როგორც მისი სახელი გულისხმობს.
რომელიც აჩვენებს, თუ რა ცვლადი შეადგენს.
>> ინფორმაცია ადგილობრივები ნამდვილად გამოსადეგი.
ეს არის სპეციალური ვერსია ბეჭდვითი.
ინფორმაცია ადგილობრივების გიჩვენებთ ყველა ადგილობრივი ცვლადები, ბეჭდავს მათ ყველა თქვენ
რომ არის გაკეთებული შესაძლებელი.
ასე რომ, ზოგადად, ვიდრე მქონე ამობეჭდოთ ოთხი ცვლადები, რომ მე ვარ
დაინტერესდა, თუ მე ამისთვის მარყუჟის, ამისთვის მაგალითად, მე უბრალოდ წერენ კარგი ადგილობრივები,
და ეს კიდე ეჩვენებინა, თუ რა არის ჩემი counter i შეადგენს, ისევე, როგორც მასივი, რომ მე ვარ
მუშაობა შეადგენს.
>> საბოლოოდ, გაგრძელდება.
აკრეფით შესვენების შეწყვეტს თქვენ დროს შესვენების წერტილი.
შეგიძლიათ გავლა ხაზის მიერ შეესაბამება მომავალი და ნაბიჯი.
გაგრძელება ეშვება პროგრამა თქვენი მომავალი შესვენება წერტილი ან დასრულებამდე, თუ
არ არსებობს უფრო შესვენების რაოდენობა.
გამორთვა ხსნის შესვენების ქულა, თუ გადაწყდა, შესვენების დროს ძირითადი იყო
არაადეკვატური, გსურთ მითითებული ეს სხვაგან.
და ბოლოს q, დატოვა, გამოდის GDB.
>> ასე რომ ამ პროგრამის. / Caesar, ჩვენ ვაპირებთ გაეცნონ ახლავე და ჩვენ
აპირებთ გამოიყენოთ GDB იპოვოს შეცდომები ამ პროგრამაში.
მე გაიქცა ამ პროგრამის ადრე ჩეკი 50, და მე მივიღე ერთი frown.
ყველაფერი კი არსებობდა, იგი შედგენილი, ეს გავიდა მრავალი ტესტები, მაგრამ
გარკვეული მიზეზების გამო, ეს არ გაივლის მეხუთე ტესტი, გარდამტეხი BARFOO, ყველა caps, შევიდა
E-D-U-I-R-R, ყველა caps, გამოყენებით სამი, როგორც გასაღები.
მე მივიღე საკმაოდ ახლოს.
ჩამოვედი ერთი წერილი.
ასე რომ მცირე შეცდომა აქ.
მე გადავხედე ჩემი კოდი.
მე ვერ გაერკვნენ ის.
იმედია, თქვენ ბიჭები შეგიძლიათ დამეხმაროთ გაერკვნენ, რა ამ bug არის.
>> ასე რომ შეცდომა ჩვენ ეძებს.
მოდით გადავიდეთ GDB.
ისევ და ისევ, მე აწარმოებს GDB. / Caesar, ასე რომ, ახლა ჩვენ GDB.
და რა არის პირველი რამ უნდა გავაკეთოთ?
მე უბრალოდ შევიდა GDB.
ვიღაცამ მომეცი კარგი ბრძანება შევა.
>> სტუდენტური დაარღვიე მთავარი.
>> JASON HIRSCHHORN: Break მთავარი.
Fantastic.
მოდით აკრიფოთ რომ სისტემაში
თქვენ ბიჭები შეგიძლიათ ნახოთ აქ ან მოჰყვება ერთად თქვენი კომპიუტერი.
შესვენება მთავარ, და თქვენ ნახავთ შესვენების წერტილი განისაზღვრა -
ეს მაძლევს რაღაც უცნაური მეხსიერება მისამართი, და ასევე მაძლევს ხაზის ნომერი.
მე რომ ვიხსენებთ ამ ფაილის, მინდა გვესმოდეს, რომ მთავარი
მოხდა on line 21.
რა უნდა აწარმოებს შემდეგ?
არის ჩემი პროგრამა გაშვებული?
პოსტები
ასე რომ, რა უნდა აწარმოებს შემდეგ?
>> სტუდენტური აწარმოებს.
>> JASON HIRSCHHORN: გაუშვით.
უნდა მხოლოდ აწარმოებს ტირაჟი, ან უნდა I დაამატოთ ზოგიერთი სხვა რამ?
>> სტუდენტი: გაუშვით ერთად არგუმენტი.
>> JASON HIRSCHHORN: გაუშვით ერთად ბრძანების არგუმენტები.
და რადგან მე გამართვის ძალიან კონკრეტული შემთხვევაში, მე უნდა შევიდეს, რომ
ბრძანების არგუმენტი.
ასე რომ მე არ აწარმოებს სამი, რომელიც, კიდევ ერთხელ, გამომავალი მე მივიღე Check 50.
დაწყებული პროგრამა.
ჩვენ გაიაროს რამდენიმე ხაზები.
თქვენ ახლა ვხედავ, რომ ჩვენ on line 21.
როგორ მე ვიცი, რომ ჩვენ on line 21?
რადგან თუ გადავხედავთ მარცხენა ჩემი ტერმინალის ფანჯარა, იქ
იგი აცხადებს, რომ ხაზი 21.
და რომ მაძლევს, ფაქტობრივად, კოდი, რომელიც არის ხაზი 21.
ასე რომ, მე misspoke ადრე.
მთავარი არ არის რეალურად ერთი ხაზი 21.
მთავარი არის რამდენიმე ხაზი ზემოთ 21.
მაგრამ ხაზი 21, რომ სადაც ჩვენ არღვევს.
ამ ხაზი კოდი აქვს ჯერ კიდევ არ არის შესრულებული.
რომ მნიშვნელოვანია.
ხაზი ხედავთ არ შესრულებული არ არის.
სწორედ შემდეგი ხაზი კოდი თქვენ უნდა შეასრულოს.
>> ასე რომ, მომდევნო ხაზი, როგორც თქვენ ბიჭები არიან ალბათ იცნობს, ეს
მდგომარეობის შემოწმების თუ მაქვს შევიდა ბრძანების არგუმენტი.
და რომ მე, რა არის მეორე ნაწილი რომ აკეთებს?
რა არის, რომ მე?
>> სტუდენტური შეცვლის მას მთელი რიცხვი.
>> JASON HIRSCHHORN: უკაცრავად?
>> სტუდენტი: ეს იცვლება არგუმენტი რიცხვი.
>> JASON HIRSCHHORN: ასე რომ მე ცვლის Arg v1 საწყისი სიმებიანი რიცხვი.
და მერე რა, რომ ეს შემოწმება?
>> სტუდენტი: თუ არსებობს მეორე ბრძანების არგუმენტი, გარდა
გაშვებული პროგრამა.
>> JASON HIRSCHHORN: და რა მეორე ნახევარში ამ
ლოგიკური გამოხატვის შემოწმების დაყენებასთან დაკავშირებით?
ეს ნაწილი აქ, რომ მე?
>> სტუდენტი: თუ ეს ნეგატიური.
>> JASON HIRSCHHORN: მიღების დარწმუნებული ვარ, რა ხდება?
>> სტუდენტი: მიღების დარწმუნებული ვარ, რომ ეს არის, ფაქტობრივად, დადებითი.
>> JASON HIRSCHHORN: ზუსტად.
ეს ამოწმებს, რომ ნახოთ თუ ის უარყოფითი, და თუ ეს არის უარყოფითი, I
აქვს შეგრძნება შემდეგი ხაზი ძალა იქნება ჩემთვის ყვირილი at შესახებ.
მოდით მოხვდა ბოლომდე შეასრულოს ამ ხაზის.
ჩვენ ვერ ვხედავთ, რომ ხაზი, რომ თქვენ ბიჭები იქნებ სავარაუდოდ ვხედავ yelling ზე
შესახებ და შემდეგ დაბრუნების, რადგან ეს ხაზი არ შეასრულოს.
შევედი 3.
ასე რომ, მე, ფაქტობრივად, მიუთითოთ ორი ბრძანება ხაზი არგუმენტები, და 3
მეტი ნულოვანი.
ასე რომ, ჩვენ ვნახეთ, რომ ხაზი, ჩვენ შესრულებული, მაგრამ ჩვენ არ დაიხევს
შიგნით თუ მდგომარეობა.
>> ახლა, მომდევნო, მე ვხედავ, მე შექმნის int გასაღები შეადგენს to i ARG v1.
ასე რომ, ჩემთვის შექმნაში ცვლადი გასაღები.
ასე რომ, თუ მე ამობეჭდოთ გასაღები ახლა, რადგან რომელიც საშუალებას გაძლევთ ნახოთ
ღირებულება შიგნით ცვლადის გასაღები შეადგენს 47.
რომ უცნაური, მაგრამ, რა თქმა უნდა, ეს იმიტომ, რომ არ მაქვს
შესრულებული რომ ხაზი არავის გაუკეთებია.
ახლა თუ მე მოხვდა n, შეასრულოს, რომ ხაზი, და ამის ბეჭდვითი გასაღები, გასაღები გაუტოლდება 3,
რაც ჩვენ ველით, რომ გაუტოლდება.
>> ასე რომ კიდევ ერთხელ, ამ GDB, ხაზი თქვენ ვხედავ თქვენ არ აღსრულებულა.
თქვენ უნდა მოხვდა n ან s ან ნომერი სხვა ბრძანებები რეალურად
შეასრულოს, რომ ხაზი.
Print გასაღები.
გასაღები 3.
ჯერჯერობით, იმდენად კარგი.
სიმებიანი ძირითადი ტექსტი.
მოდით შეასრულოს, რომ ხაზი.
მე მიღების string საწყისი მომხმარებელს.
>> ვნახოთ, ჩემი Check 50, I შესვლის BARFOO ყველა caps, ისე
ის, რაც მე შევა.
თუ მე ახლა ბეჭდვა ძირითადი ტექსტი.
თქვენ ნახავთ, რომ ეს უდრის სიმებიანი.
ეს მაძლევს ზოგიერთი სხვა უცნაური თექვსმეტობითი ნომერი, მაგრამ ეს იმას in
ის ფაქტი, ვთქვა, რომ ჩემი სიმებიანი BARFOO.
იმ შემთხვევაში, თუ მინდოდა რა გასაღები შეადგინა at ამ ეტაპზე, როგორ შეიძლება მე გადაამოწმოთ გასაღები?
>> სტუდენტი: დაბეჭდილი გასაღები.
>> JASON HIRSCHHORN: Print გასაღები, ზუსტად.
და ფაქტობრივად, არსებობს კომბინაცია.
თუ თქვენ დაიღალა აკრეფით ბეჭდვა, შეგიძლიათ უბრალოდ აკრიფოთ გვ.
ასე რომ, p გასაღები აკეთებს იგივე ზუსტი რამ.
ისევ და ისევ, მე ვხედავ მას შეადგენს 3.
>> თუ მინდოდა გაირკვეს, თუ რა ორივე გასაღები და BARFOO შეადგინა, ამავე დროს,
მაგრამ მე ვიყავი დაიღალა აკრეფით თითოეული ერთი ინდივიდუალურად, I
შეიძლება აკრიფოთ კარგი ადგილობრივები.
რომელიც მაძლევს გასაღები შეადგენს 3.
ტექსტური შეადგენს BARFOO.
იგი ასევე მაძლევს ამ ორი უცნაური რამ ზედა, ამ ცვლადის i და
ეს ცვლადი n.
>> იმ რეალურად არსებული ჩემი მთავარი პროგრამა.
ჩვენ არ შეექმნა მათთვის არ არის, მაგრამ, როგორც ესკიზი, იმ
არსებობს ჩემი for loop.
ასე რომ, ახლა, ისინი ტოლი რაღაც უცნაური ციფრები, იმიტომ, რომ მათ არ
ინიციალიზაცია არ არის, მაგრამ ისინი მაინც არსებობს მეხსიერებაში, ასე რომ ისინი უბრალოდ მითითებული
ზოგიერთი ნაგვის ღირებულება.
მაგრამ ჩვენ ვხედავთ გასაღები ბარის ტექსტის უფლება არსებობს.
>> ამიტომ მე ვაპირებ, რათა შესრულდეს ამ ხაზის, ხაზი 34, ამისთვის loop.
ჩვენ ვაპირებთ, რომ ხტომა შევიდა მარყუჟის მიერ hitting n.
და ჩვენ შიგნით ამისთვის loop.
ჩვენ ჩვენი პირველი ქვითარი.
ისევ და ისევ, ეს უნდა სახის გამოიყურება ნაცნობი თქვენ იმიტომ, რომ ეს იყო
Caesar პროგრამა, რომელიც დაიწერა, მაგრამ ერთხელ, აქვს გარკვეული შეცდომა.
>> და ახლა, თუ კარგი ადგილობრივები, რადგან მე ვარ შიგნით რომ loop, თქვენ ნახავთ
რომ მე ნულის ტოლია, როგორც ჩვენ მოველით.
ის, რაც ჩვენ ვაყენებთ მას და ინიციალიზაცია მას ამ for loop.
n შეადგენს 6.
რომელიც ასევე აზრი, იმიტომ, რომ ჩვენ ვაყენებთ მას strlen ძირითადი ტექსტი.
ასე რომ, მე მინდა გავაკეთოთ კარგი ადგილობრივები ან ბეჭდვითი ცვლადი ხშირად დავრწმუნდეთ, რომ
ყველაფერი ყოველთვის რა ვიმედოვნებ, რომ ეს გაუტოლდება.
ამ შემთხვევაში, ყველაფერი არის რაც მე მოველი, რომ ეს გაუტოლდება.
>> ასე რომ დავიწყოთ მოძრავი მეშვეობით ამ loop.
ხაზი მე არის ხაზი 36, თუ ბარის ტექსტის i მეტია და ბარის
ტექსტის i ნაკლებია ან ტოლი z.
მე ვიცი, ჩემი პრობლემა არ არის ჩემი პირველი წერილი, ეს მეორე წერილი.
იმ შემთხვევაში, თუ ჩვენ ვიხსენებთ Check 50, B მიდის E ჯარიმა.
მე აღების და ტოვებს მას, როგორც A, არ იცვლება მას D. ასე რომ,
რაღაც ცუდი მეორე წერილში.
ამიტომ მე ვაპირებ გადაადგილება იქ მეორე.
>> მაგრამ თუ მე მინდა შეამოწმოთ, თუ რა უბრალო ტექსტის I შეადგინა ამ კონკრეტულ
შემთხვევაში, მე ვფიქრობ, ეს უნდა იყოს რა?
რა უნდა ჩვეულებრივი ტექსტური I გაუტოლდება ამ პირველი რაუნდი მეშვეობით for loop?
>> სტუდენტი: Zero?
>> JASON HIRSCHHORN: Plain ტექსტის მე?
ასე რომ, ეს უნდა იყოს კაპიტალის B. მე, რა თქმა უნდა, ნულის ტოლი, მაგრამ ჩვეულებრივი ტექსტური
bracket ნულოვანი დახურული ფრჩხილი შეადგენს B იმიტომ, strings, როგორც ვნახეთ გასულ კვირას,
არის array, ასე რომ, ჩვენ ვიღებთ პირველი ხასიათი რომ.
ასე რომ კიდევ ერთხელ, თუ მე ამობეჭდილი ბარის ტექსტი მე, მე, ფაქტობრივად, კიდევ ხასიათი
B. და ეს neat, არა?
მე არ რეალურად ჩვეულებრივი ტექსტური I. ეს არ არის ერთი ცვლადის მითითებული
ან ინიციალიზაცია, მაგრამ თქვენ შეგიძლიათ ამობეჭდოთ out მთელი რიგი რამ
თუ გსურთ.
>> მაგრამ მოდით გადაადგილება მეშვეობით.
იმ შემთხვევაში, თუ ჩვეულებრივი ტექსტური I მეტია და ჩვეულებრივი ტექსტური I ნაკლებია ან ტოლი
Z, რომელიც ნათლად არის ჭეშმარიტი, რადგან ჩვენ კაპიტალის B. მე ვაპირებ აწარმოებს
ზოგიერთი ბრძანება.
ჩვენ ვნახეთ, რომ მათემატიკის გასულ კვირას, ამიტომ ჩვენ ეს თავისთავად, რომ მუშაობს
მარჯვენა მიხედვით შემოწმება 50.
>> ეს curly აფრთხილებს, პირველი აჩვენა, რომ მე არსებული თუ
მდგომარეობაში, მეორე აჩვენა რომ მე არსებული for loop.
და ახლა, როდესაც მე მოხვდა შემდეგი, ჩვენ დავინახავთ ჩვენ უკან ამისთვის loop ერთხელ.
ჩვენ ვაპირებთ მეშვეობით for loop ერთხელ.
მოდით რეალურად დახევას შევიდა მეორე iteration of მარყუჟის და ტიპი
კარგი ადგილობრივები.
>> ასე რომ ჩვენ მეორე iteration ჩვენი for loop.
I შეადგენს 1, რომელიც ჩვენ მოველით.
N შეადგენს 6, რომელიც ჩვენ მოველით.
გასაღები შეადგენს 3, რომელიც ჩვენ მოველით.
და ჩვეულებრივი ტექსტური, თქვენ ნახავთ, ტოლობის EARFOO ახლა, არ BARFOO აღარაა, რადგან
ჩვენს წინა iteration, B იყო შეიცვალა დედაქალაქში E. ასე ჩვენ შესახებ
ექმნებათ პრობლემა, ამიტომ ეს არის, სადაც ჩვენ ვაპირებთ
ჩაყვინთვის შევიდა გამართვის.
მაგრამ ჯერ არავის გაქვთ რაიმე შეკითხვები შესახებ, რაც ჩვენ გავაკეთეთ აქამდე?
Fantastic.
>> ასე რომ, ჩვენ შესახებ, რათა შესრულდეს ამ შემთხვევაში მდგომარეობა, ჩვეულებრივი ტექსტური bracket I დახურულია
bracket მეტია და ჩვეულებრივი ტექსტური I ნაკლებია ან ტოლი ზ მაგრამ სანამ
მე წასვლას, რადგან ეს არის სადაც მე ვიცი, ჩემი შეცდომა ის არის, მინდა აღვნიშნო
out ჩვეულებრივი ტექსტური ი ასე რომ, მოდით დააყენა ბეჭდვითი out.
ეს არ გაუტოლდება ხასიათი, ისე, რომ როგორც ჩანს, ჯერჯერობით, ყველა კარგად და კარგი.
>> ასე რომ, ვიმედოვნებ, რომ ეს ხაზი თითო ჩემი ლოგიკა, ეს ხაზი უნდა იყოს ჭეშმარიტი.
ის დედაქალაქში წერილში.
მაგრამ თუ მე მოხვდა n, ჩვენ გვესმის, რომ ამ ხაზი, ფაქტობრივად, არ შეასრულოს.
მე გადახტა ქვემოთ სხვაგან თუ.
რატომ მოხდა ეს?
>> სტუდენტი: იმის გამო, რომ თქვენ გაქვთ თქვენი მდგომარეობის ძირითადი ტექსტი დიდია
გარდა, არ უდრის ან აღემატება.
>> JASON HIRSCHHORN: ასე მქონდა ჩვეულებრივი ტექსტური I მეტია, დიდი არ
მეტი ან ტოლია.
ასე ნათლად, დედაქალაქში არ გამოიწვევს თუ მდგომარეობაში, და გავაკეთეთ
არ დაიხევს შევიდა, და გავაკეთეთ არ გააკეთებს საჭირო ცვლა.
ასე რომ, ეს, რეალურად.
I figured out my bug.
მე ვერ დავუბრუნდეთ ჩემი წყარო ფაილი, შეცვლა, განახლება და
აწარმოებს ჩეკი 50 ერთხელ.
>> მაგრამ ჩვენ დავინახავთ, მხოლოდ პედაგოგიკა მიერ გულისთვის, თუ მე შენარჩუნებას აპირებს.
სხვაგან თუ არ შეასრულოს, თუმცა რა ნაცვლად შეადგენს არის ბრძანება
რომ არ იცვლება.
ასე რომ, ეს არ შეცვლილა, და თუ მე ბეჭდვა ჩვეულებრივი ტექსტური აქ, ჩვენ დავინახავთ აპირებს
მეშვეობით, რომ მარყუჟი არ, ფაქტობრივად, შეიცვალოს, რომ მეორე სიმბოლო იყო.
მაინც კაპიტალური ა
>> ასე რომ კიდევ ერთხელ, ჩვენ debugged ჩვენი შეცდომა.
ჩვენ მიხვდა, რომ არ იყო გარკვეული ლოგიკა დაკარგული.
და ჩვენ debugged მას ვადამდე ადრე რეალურად შესრულებაში, რომ ხაზი,
მაგრამ თქვენ არ შენიშნა ჰქონდა ჩვენ უბრალოდ მოხვდა შემდეგი და გადადით რომ სხვაგან, თუ
ეს ნიშნავს, რომ, თუ მდგომარეობა არ იყო მართალი.
ჩვენ არ, ფაქტობრივად, კიდევ შედეგი ველოდით.
ასე რომ მაშინ ჩვენ შეგვიძლია უკვე აიძულა, რომ ჩვენ არ ყოფილა ასე თავშეკავებულად, შევხედოთ
იმ შემთხვევაში, თუ მდგომარეობა და შეამოწმოთ, თუ, ფაქტობრივად, ჩვენი მდგომარეობა უნდა შეაფასოს, რათა
დიახ მიმდინარე კონტექსტში.
>> რომ ყველა გამართვის ეს პროგრამა.
ვინმეს გაქვთ რაიმე შეკითხვა?
რა ბრძანება ვერ მოხვდა დატოვა GDB?
Q. და მაშინ მე გკითხავთ, დატოვა მაინც?
არა.
მე მოხვდა დიახ, და მე არ დატოვა GDB.
>> ასე რომ, იყო სწრაფი პრემიერ GDB.
რეალურად, რეალური სცენარი, მე ამ ოფისში საათის განმავლობაში.
I GDBed ამ ზუსტი პროგრამა საოფისე საათი სტუდენტი.
და თუ ჩვენ დავუბრუნდებით ბრძანებები ვნახეთ ადრე, ჩვენ შესვენება მთავარ, პირველი
რაც ჩვენ გავაკეთეთ.
ჩვენ გამოიყენება აწარმოებს ერთად ბრძანების არგუმენტები, მეორე, რაც გავაკეთეთ.
ჩვენ გამოიყენება შემდეგ ბევრი გადაადგილება ჩვენს მეშვეობით ხაზები.
ისევ და ისევ, შემოკლებული ვერსია მომავალი არის n.
სწორედ ფრჩხილებში ნაცრისფერი on the slide.
>> ჩვენ არ ვიყენებთ ნაბიჯი, მაგრამ ჩვენ არ აუცილებლად უნდა ამ შემთხვევაში.
მაგრამ ჩვენ შეიძლება გამოვიყენოთ ეს ცოტა მოგვიანებით დღეს თუ ჩვენ გამართვის, for
მაგალითად, ორობითი ძებნა, როდესაც ორობითი ძებნის ეწოდება ცალკე
ფუნქცია მაგრამ იქ რაიმე შეცდომა იყო.
ჩვენ ვაპირებთ, რომ მინდა დახევას შევიდა ზარი ორობითი ძებნა და
რეალურად გამართვის იგი.
სიაში ჩვენ არ გამოიყენოთ, რადგან ჩვენ გვქონდა კარგი გრძნობა ჩვენი კოდი, მაგრამ თუ
არ გვინდა გრძნობა რა კოდი I იყო დაახლოებით, მე ვერ უბრალოდ გამოიყენოთ სიაში.
>> ბეჭდვა ჩვენ გამოიყენება, კარგი ადგილობრივები ჩვენ გამოიყენება.
გაგრძელება ჩვენ არ უნდა გამოვიყენოთ ამ შემთხვევაში, არც ჩვენ უნდა გამოვიყენოთ
გაუქმდება, მაგრამ ჩვენ გავაკეთეთ გამოყენების დატოვა.
ერთხელ, ამ 10 ბრძანებები, პრაქტიკაში მათ.
თუ თქვენ კარგად ესმის ეს 10 ბრძანებები, თქვენ უნდა იყოს მითითებული გამართვის ნებისმიერი
საკითხი GDB.
>> ასე რომ ჩვენ დაახლოებით წასვლა, კიდევ ერთხელ, crux განყოფილების დღეს დასრულდა
ეს დახარისხება და ძიების ალგორითმები.
სანამ ჩვენ ამისათვის ისევ, რაიმე შეკითხვები, კომენტარი, შეშფოთება GDB?
ასე რომ ყველას აპირებს გამოიყენოს GDB ვიდრე printf?
ასე რომ ყველას, for perpetuity გულისთვის, ყველას nodding მათი ხელმძღვანელი უფლება
ახლა, ასე რომ მე ვხედავ თქვენ საათებში და ყველა TFs ნახავთ თქვენ და
ისინი აცხადებენ, რომ ეჩვენებინა, თუ როგორ გამოიყენოთ GDB, და თქვენ გექნებათ
ვაჩვენოთ, არა?
კეთილი?
იქნებ იმედია.
ზემოთ.
>> ამიტომ, ჩვენ ვაპირებთ გადაინაცვლოს დახარისხება და ძებნას.
თქვენ ნახავთ მაქვს სიაში უკვე დახარისხებული ჩვენთვის, მაგრამ, რომ არ აპირებს
უნდა იყოს საქმე ყოველთვის.
ასე რომ, პრობლემა კომპლექტი სპეციფიკაცია პრობლემა კომპლექტი სამი, თქვენ უნდა შორტები
რომ თქვენ შეგიძლიათ უყუროთ და ეს ფაქტიურად გთხოვთ უყუროთ იმ შორტები.
ასევე ლექცია გასულ კვირას, წავედით მეტი ბევრი ამ ალგორითმები, ამიტომ მე
არ ვაპირებთ დროის გასატარებლად კლასში აპირებს მეტი ამ ალგორითმები კიდევ ერთხელ ან ნახაზი
სურათები როგორ შეიძლება ამ ალგორითმები მუშაობა.
კიდევ ერთხელ, რომ ინფორმაცია თქვენ შეგიძლიათ ხელახლა watch ლექცია, ან, რომ ინფორმაცია
მიტაცებული outstandingly წლის შორტები ამ ძიება ყველა
რომლებიც ხელმისაწვდომია cs50.net.
>> ასე რომ ნაცვლად, რასაც ჩვენ ვაპირებთ გავაკეთოთ არის წერენ ამ პროგრამების.
ჩვენ გრძნობა, გონებრივი მოდელი, თუ როგორ ისინი მუშაობენ და ასე შემდეგ, რასაც ჩვენ ვაპირებთ
ამის გაკეთება არის კოდი, მათთვის რეალური.
ჩვენ ვაპირებთ მივმართოთ, რომ ფსიქიკური მოდელი, რომ სურათი, თუ გნებავთ, შევიდა
ფაქტობრივი კოდი.
და თუ იყო ცოტა დაბნეული ან hazy გონებრივი მოდელი, სრულიად
მესმის.
>> ჩვენ რეალურად არ აპირებს გადადით კოდი straightaway.
ასე რომ სანამ ამ სწრაფი ამ slide სთხოვს თქვენ კოდექსში ორობითი ძებნა და
რეალურად, განმეორებითი მობილური ორობითი ძებნა, პირველი რაც მე
ნამდვილად გსურთ თქვენ უნდა გააკეთოთ წერენ ზოგიერთი pseudocode.
ასე, რომ თქვენ ამ ფსიქიკური მოდელი თუ როგორ ორობითი ძებნა ნამუშევრები.
აიღოს ფურცელი თუ გაქვთ ერთი ხელმისაწვდომი, ან ქმნის
ტექსტური რედაქტორი, და მინდა ყველას დაწერა.
მიიღეთ ოთხი წუთის დაწერა pseudocode ორობითი ძებნა.
>> ერთხელ, ვიფიქროთ, რომ ფსიქიკური მოდელი.
მე მოდის გარშემო თუ თქვენ გაქვთ შეკითხვები და ჩვენ შეგვიძლია დავხატოთ სურათი out.
მაგრამ პირველი, სანამ ჩვენ ვიწყებთ პროგრამირების, მინდა დაწერა
pseudocode ბინარული ძებნის ასე რომ, როდესაც ჩვენ ჩაყვინთვის, ჩვენ გვაქვს რამდენიმე მიმართულებით,
სადაც ჩვენ უნდა უხელმძღვანელებს.
>> სტუდენტი: შეიძლება ვივარაუდოთ მასივი ღირებულებები მივიღებთ უკვე დახარისხებული?
>> JASON HIRSCHHORN: ასე ორობითი ძებნა მუშაობა - შესანიშნავი კითხვა - თქვენ
უნდა მიიღოს დახარისხებული array ღირებულებებს.
ასე რომ ვივარაუდოთ, რომ ეს იმუშავებს.
ჩვენ დავუბრუნდეთ ამ slide.
თქვენ ნახავთ purple ფუნქცია დეკლარაცია bool binary_search int
ღირებულება, int ღირებულებებს, int n.
ეს უნდა გამოიყურებოდეს ნაცნობი თუ თქვენ უკვე მიუახლოვდა და მიღებული თქვენი
ხელში ბინძური პრობლემა კომპლექტი.
>> მაგრამ ეს თქვენი ფუნქცია დეკლარაცია.
ისევ და ისევ, არ უნდა ფიქრი რომ ბევრი რამ ამ ეტაპზე.
რაც მე მინდა თქვენ უნდა გააკეთოთ მიიღოს ოთხი წუთი pseudocode ორობითი
ძებნის და შემდეგ გავემგზავრებით მეტი რომ, როგორც ჯგუფი.
და მე მოვა გარშემო.
თუ თქვენ გაქვთ შეკითხვები, ვგრძნობ უფასო დააყენებს თქვენი მხრივ.
>> რატომ არ მიიღოს ორი წუთის განმავლობაში დასრულდება up pseudocode?
მე ვიცი, ეს შეიძლება, როგორც ჩანს, სასაცილოა, რომ ჩვენ ხარჯავს ამდენი დრო
რაღაც რომ არც კი რეალურად C, მაგრამ განსაკუთრებით ეს უფრო
რთული ალგორითმები და პრობლემა კომპლექტი, რომ ჩვენ უნდა გაერკვნენ,
დაწყებული pseudocode არ შემაშფოთებელია შესახებ სინტაქსი, უბრალოდ შემაშფოთებელია შესახებ
ლოგიკა, არის ძალიან სასარგებლო.
და ამ გზით, თქვენ არ გადაჭრის ორი წარმოუდგენლად რთული პრობლემები ერთდროულად.
თქვენ მხოლოდ აქცენტი ლოგიკა, და მაშინ თქვენ გადატანა შევიდა სინტაქსი.
>> OK.
დავიწყოთ გადის pseudocode.
მე არ წერია აქ, ორობითი ძებნა pseudocode.
ჩვენ წერენ ამ თემაზე მონიშნე ერთად.
ან დავწერ და თქვენ მივცემ me მოთხოვნა მჭირდება.
ასე რომ შეიძლება ვინმეს მომეცი პირველი ხაზი pseudocode თქვენ
წერდა ორობითი ძებნა?
დიახ, Annie?
>> სტუდენტი: მიუხედავად იმისა, რომ სიგრძეზე სიაში მეტი ნულოვანი.
>> JASON HIRSCHHORN: მიუხედავად იმისა, სიგრძით სიის მეტი ნულოვანი.
და ისევ, ჩვენ ვხედავთ რამოდენიმე C-ეძებს სინტაქსური რამ აქ.
მაგრამ ყველაზე მეტად ეს არის ინგლისურ ენაზე.
ხომ არავის გაქვთ რაიმე ონლაინ ისინი ადრე მათი ფსევდო კოდი?
>> სტუდენტური ოჯახის მასივი საქართველოს დახარისხებული ნომრები.
>> JASON HIRSCHHORN თქვენ დაწერა "მიიღოს მასივი დახარისხებული ნომრები. "პერ
ფუნქცია დეკლარაცია, ჩვენ უნდა გავლის მასივი დახარისხებული ნომრები.
>> სტუდენტი: [INAUDIBLE].
>> JASON HIRSCHHORN: So გვექნება, რომ.
მაგრამ დიახ, თუ ჩვენ არ გვაქვს, რომ ჩვენ უნდა დასალაგებლად ჩვენი მასივი
ციფრები, იმის გამო, რომ ორობითი ძებნა მუშაობს მხოლოდ დახარისხებული მასივი.
ასე რომ, ხოლო სიგრძით სია ნულის ტოლია, მე ვარ ვაპირებ დააყენა ზოგიერთ curly აფრთხილებს
რათა ის გამოიყურება ცოტა მეტი მოსწონს C. მაგრამ მაშინ, როცა, როგორც ჩანს რუკაზე გადატანა
ხოლო მარყუჟის, ასე რომ შიგნით ამ ხოლო loop რას უნდა
გავაკეთოთ ორობითი ძებნა?
>> ვინმე, ვინც არ მომცა პასუხის გაცემა, მაგრამ ვინ დაწერა ეს?
>> სტუდენტი: გადადით შუა სიაში.
>> JASON HIRSCHHORN: Tom.
წასვლა შუა სიაში.
და შემდგომი შეკითხვა, თუ რა ვაკეთებთ ერთხელ ჩვენ იმ
შუა სიაში?
>> სტუდენტი: ნუ გამშვები თუ არა რომ ნომერი თქვენ ვეძებთ.
>> JASON HIRSCHHORN: Excellent.
ტურიზმი შუა სია და შემოწმება თუ ჩვენი ღირებულება არის -
ფანტასტიური.
ხომ არავის აქვს არაფერი რომ იყო განსხვავებული, ვიდრე ეს?
ეს არის ზუსტად ის უფლება.
>> პირველი, რაც უნდა გავაკეთოთ ორობითი ძებნა არის წასვლა შუა სია და
შეამოწმეთ თუ ჩვენი ღირებულება არსებობს.
ასე რომ, მე ვივარაუდოთ, თუ ჩვენი ღირებულება არსებობს, რა ვქნათ?
>> სტუდენტი: ჩვენ დაბრუნდება ნულოვანი [INAUDIBLE].
>> JASON HIRSCHHORN: ჰო, თუ ჩვენი ღირებულება არსებობს, ჩვენ ვერ.
ასე რომ ჩვენ შეგვიძლია გითხრათ, გარკვეულწილად, თუმცა ეს ფუნქცია განისაზღვრება, ჩვენ გითხრათ შესახებ
ჩვენ ვერ.
იმ შემთხვევაში, თუ ეს არ არსებობს, თუმცა, რომ ის, სადაც ეს იღებს სახიფათო.
ასე რომ, თუ ის არ არის, ვინმეს, ვინც მუშაობს ორობითი ძებნა ან
აქვს იდეა, ახლა, რას ვაკეთებთ?
>> სტუდენტი: კითხვა.
>> JASON HIRSCHHORN: Yes?
>> სტუდენტი: არის მასივი უკვე დახარისხებული?
>> JASON HIRSCHHORN: დიახ, ჩვენ ვთქვათ, მასივი უკვე დახარისხებული.
>> სტუდენტი: ასე რომ, შემდეგ თქვენ უნდა შეამოწმოთ, თუ ღირებულება რომ ხედავთ მეტია
ღირებულება, რომელიც გსურთ, თქვენ შეგიძლიათ გადაადგილება შუა მეორე ნახევარში.
>> JASON HIRSCHHORN: ასე რომ, თუ შუა სიაში მეტია, რაც ჩვენ
ეძებს, მაშინ რა, რა?
ჩვენ გადაადგილება სად?
>> სტუდენტი: თქვენ გინდათ რომ გადავიდეს ნახევარი სია
ციფრები დაბალია, ვიდრე.
>> JASON HIRSCHHORN: ასე ჩვენ მოვუწოდებთ, რომ მარცხნივ.
ასე რომ, თუ შუა მეტია, ჩვენ შეგიძლიათ მოძებნოთ მარცხენა ნახევარში სიაში.
და შემდეგ ძიების, რა ვგულისხმობ საძიებო?
>> სტუდენტი: [INAUDIBLE].
>> JASON HIRSCHHORN: ჩვენ წასვლა ცენტრიდან.
ჩვენ, ფაქტობრივად, ვიმეორებ ამ რამ.
ჩვენ დავუბრუნდებით ჩვენი ხოლო loop.
მე მივცემ თქვენ ბოლო ერთი -
სხვაგან, თუ, შუა არის ნაკლები რა ჩვენ გავაკეთებთ, რას ვაკეთებთ აქ?
>> სტუდენტური პასუხი: გადადით მარჯვნივ.
>> JASON HIRSCHHORN: ძებნა უფლება.
ეს გამოიყურება კარგია, მაგრამ ჯერ არავის აქვს არაფერი რომ ჩვენ შეიძლება დაკარგული ან
არაფერი, რომ თქვენ დააყენა თქვენი ფსევდო კოდი?
ასე რომ, ეს არის ის, რაც ჩვენ ჯერჯერობით.
მიუხედავად იმისა, რომ სიგრძეზე სიაში მეტი ვიდრე ნულოვანი, ჩვენ ვაპირებთ წავიდეთ
შუა სიაში და შეამოწმეთ თუ ჩვენი ღირებულება არსებობს.
>> იმ შემთხვევაში, თუ შუა მეტია, ჩვენ ვაპირებთ ძებნა მარცხენა სხვაგან, თუ შუა არის
ნაკლებია, ჩვენ ვაპირებთ მოძებნოთ უფლება.
ასე რომ ჩვენ ყველა გვქონდა მნიშვნელოვანია თვალსაზრისით ჩვენ ვიყენებთ კომპიუტერულ მეცნიერებათა
და ინსტრუმენტები გვაქვს.
მაგრამ თქვენ უკვე შეამჩნევთ ვიყავით საუბარი ინგლისურ, მაგრამ ჩვენ ვნახეთ
ბევრი რამ, რომ თითქოს რუკა to ინსტრუმენტები გვაქვს ჩვენი კოდირების ინსტრუმენტი ნაკრები.
ასე რომ, უფლება off bat, ჩვენ არა ვართ აპირებს რეალურად კოდი არავის გაუკეთებია.
>> რა ჩვენ ვხედავთ აქ ინგლისურად, რომ რუკები რათა რამ შეგვიძლია წერა C?
>> სტუდენტი: მიუხედავად იმისა, რომ.
>> JASON HIRSCHHORN: მიუხედავად იმისა.
ასე რომ, ეს მაშინ, როდესაც სწორედ აქ რუკები რა?
>> სტუდენტი: ხოლო loop.
>> JASON HIRSCHHORN: A ხოლო loop?
ან, ალბათ, უფრო ზოგადად, loop.
ჩვენ გვინდა, რომ რაღაც მეტი და მეტი.
ამიტომ, ჩვენ ვაპირებთ კოდექსში loop.
და ჩვენ უკვე ვიცით, იმიტომ, რომ ჩვენ გავაკეთეთ ეს რამდენიმე ჯერ და ჩვენ
უამრავი მაგალითი არსებობს, რამდენად რეალურად დაწერა
ეს მაჩვენებელი ამისთვის loop.
ასე რომ, უნდა იყოს საკმაოდ მარტივია.
ჩვენ უნდა შეუძლია მიიღოს, რომ დაიწყო საკმაოდ სწრაფად.
>> რა ვხედავთ აქ?
რა სხვა სტრუქტურების syntaxes, რამ რომ ჩვენ იცნობს C, გვაქვს
უკვე გრძნობა Based off სიტყვები გამოვიყენეთ?
დიახ, ანა?
[INAUDIBLE]
მხოლოდ kidding.
ანა, წავიდეთ წინ.
>> სტუდენტი: თუ და სხვა.
>> JASON HIRSCHHORN: თუ და სხვა - უფლება აქ.
ასე რომ, რას იმ გამოიყურებოდეს?
>> სტუდენტი: თუ სხვაგან განცხადებაში.
>> JASON HIRSCHHORN: ჰო, პირობები, არა?
ამიტომ ჩვენ ალბათ უნდა წერენ გარკვეული პირობები.
და ისევ, მიუხედავად იმისა, რომ შესაძლოა, გაუგებარია at პირველ რიგში, ჩვენ ზოგადად გრძნობა ახლა
როგორ უნდა დაწეროთ პირობები და სინტაქსი პირობები.
და თუ ასე არ მოხდა, ჩვენ უბრალოდ ეძებოთ სინტაქსი პირობებში, cut და პასტა
იმიტომ, რომ ჩვენ ვიცით, გვჭირდება მდგომარეობაში აქ.
ნებისმიერი სხვა რამ, ჩვენ ვხედავთ, რომ რუკაზე გადატანა იმას, რასაც ჩვენ ალბათ უნდა გავაკეთოთ C?
ჰო, Aleha?
>> სტუდენტი: ეს შეიძლება იყოს აშკარა, მხოლოდ შემოწმების თუ
ღირებულება შეადგენს რაღაც.
>> JASON HIRSCHHORN: ასე როგორ უნდა შეამოწმოს და - ასე წასვლა შუა სიაში
და შემოწმება, თუ ჩვენი ღირებულება არის?
როგორ გავაკეთოთ, რომ C?
რა სინტაქსი, რომ?
>> სტუდენტი: უდრის, ტოლობის.
>> JASON HIRSCHHORN: უდრის, ტოლობის.
ასე რომ, ეს გამშვები ალბათ აპირებს უნდა იყოს შეადგენს, შეადგენს.
ასე რომ, ჩვენ ვიცით, რომ ჩვენ გვჭირდება, რომ სადღაც.
და რეალურად, მხოლოდ წერილობით ის, ჩვენ ვხედავთ იმ სხვა რამ.
ჩვენ ვაპირებთ, რომ უნდა გავაკეთოთ ზოგიერთი შედარების ოპერატორები იქ -
ფანტასტიური.
ასე რომ, რეალურად გამოიყურება, მიერ და დიდი, ჩვენ არ გაუკეთებია
სიტყვა C კოდი არავის გაუკეთებია.
მაგრამ მივიღეთ გონებრივი მოდელი ქვემოთ მეშვეობით ლექციები და იმ შორტები.
>> ჩვენ წერდა ფსევდო კოდი, როგორც ჯგუფი.
და უკვე, ჩვენ გვაქვს 80% თუ არა 90%, რაც ჩვენ უნდა გავაკეთოთ.
ახლა ჩვენ უბრალოდ უნდა კოდექსში ის, რაც ერთხელ,
არასამთავრობო ტრივიალური პრობლემის მოსაგვარებლად.
მაგრამ მაინც ჩვენ დავრჩებოდით on ლოგიკა.
მაინც ახლა, როდესაც ჩვენ წასვლა საათებში, შემიძლია ვთქვა, მე ვიცი, რა უნდა
ამის გაკეთება, მაგრამ შეგიძლიათ შეგახსენოთ მე სინტაქსი?
ან თუნდაც საათებში გადაჭედილი, თქვენ შეგიძლიათ Google-ის სინტაქსი, არამედ
გარდა მიმდინარეობს დავრჩებოდით on ლოგიკა.
>> და ისევ, ვიდრე ცდილობს გადაწყვიტოს ლოგიკა და სინტაქსის პრობლემები ყველა
ერთხელ, ხშირად ბევრად უკეთესი შესვენება იმ ორი მძიმე პრობლემები off შევიდა
კიდევ ორი ​​მართვადი პირობა და გავაკეთოთ ფსევდო კოდი და მერე კოდი in C.
მოდით ვნახოთ, რა გავაკეთე, რომ ფსევდო კოდი ვადამდე.
>> მიუხედავად იმისა, რომ სიგრძეზე სიაში მეტი ვიდრე ნულოვანი, შევხედოთ შუა
სიაში.
იმ შემთხვევაში, თუ ნომერი არ არის ნაპოვნი დაბრუნდა მართალია, სხვა იმ შემთხვევაში, თუ ნომერი უმაღლესი, ძებნის მარცხენა.
სხვაგან, თუ ნომერი დაბალია, ძიება მარჯვენა, დაბრუნების ცრუ.
ასე რომ გამოიყურება თითქმის იდენტურია თუ არა თითქმის იდენტურია, რაც ჩვენ დაწერა.
სინამდვილეში, ტომ, რაც თქვენ თქვით პირველი, არღვევს შუა სიაში და თუ
ნომერი გამოჩენას ორ განცხადებები რეალურად, რა გავაკეთე.
>> I შერწყმული მათ.
მე უნდა მოისმინა თქვენ პირველად.
ასე რომ ფსევდო კოდი გვაქვს.
თუ გსურთ ახლა, უკაცრავად, წასვლა უკან ჩვენი თავდაპირველი პრობლემა.
მოდით კოდი binary.c.
ასე რომ, განახორციელოს განმეორებითი მობილური ორობითი ძებნა გამოყენებით შემდეგ
ფუნქცია დეკლარაცია.
>> და თქვენ არ უნდა კოპირება მას უბრალოდ არავის გაუკეთებია.
მე რეალურად აპირებს გახსნას up აქ binary.c.
ასე რომ, არსებობს ფუნქცია დეკლარაცია შუა ეკრანზე.
და თქვენ ნახავთ მე ფსევდო კოდი ეხლა ჩემი მხრიდან, მაგრამ თითქმის იდენტურია
რაც ჩვენ წერდა და დააყენა, რომ თქვენ.
ახლა, მოდით, ხუთი წუთის კოდექსში ამ ფუნქციას.
>> ისევ და ისევ, თუ თქვენ გაქვთ რაიმე შეკითხვები, გაზარდოთ თქვენი მხრივ, ნება მომეცით ვიცი, მე
მოდის გარშემო.
>> სტუდენტი: [INAUDIBLE].
>> JASON HIRSCHHORN: ამიტომ მე მივიღე ორობითი ძებნა განსაზღვრება
დაბრუნება, on line 12.
ეს არის ის, რაც მე მივიღე ჩემი slide.
და მაშინ ყველა ამ ფსევდო კოდი უბრალოდ დააკოპირეთ და გაკრული საწყისი slide,
ფსევდო კოდი slide.
მე მაინც არ მოსმენის [INAUDIBLE].
>> ასე რომ, თუ თქვენ არ დასრულდა თქვენი განხორციელების, მინდა შეამოწმეთ იგი.
მე ელექტრონული ფოსტით თქვენ helpers.h ფაილი ადრე ამ კლასში.
და იგი ხელმისაწვდომი იქნება ონლაინ ასევე ჩამოტვირთვა ადამიანებს თვალს
ამ განყოფილებაში დრო გადაიდო.
და მე უბრალოდ გამოიყენა generic განაწილების კოდი, pset3.
ამიტომ მე მივიღე find.C, გამოიყენოთ ჩემი helpers.h ფაილი ვიდრე helpers.h ფაილი
რომ მოცემული განაწილების კოდი.
>> და მე უნდა გაეკეთებინათ ერთი ცვლილება find.C ვიდრე მოუწოდებდა უბრალოდ
ძიების, დარეკეთ binary_search.
ასე რომ, თუ გსურთ შეამოწმოთ თქვენი კოდი, ვიცით, რომ ეს არის, თუ როგორ უნდა გავაკეთოთ.
სინამდვილეში, როდესაც ჩვენ გაშვებული ეს კოდი ახლა, მე, უბრალოდ, ასლი
ჩემი pset3 დირექტორია, კიდევ ერთხელ, გაცვალეს out დამხმარე ფაილი და შემდეგ გააკეთა, რომ
შეიცვლება find.C მოვუწოდებთ binary_search ვიდრე უბრალოდ ძებნას.
>> JASON HIRSCHHORN: დიახ.
გაქვთ შეკითხვა?
>> სტუდენტი: Nevermind.
>> JASON HIRSCHHORN: არარის შეშფოთებულია.
კარგად, მოდით დავიწყოთ.
ჩვენ კოდექსს, როგორც ჯგუფი.
კიდევ ერთი შენიშვნა.
ისევ და ისევ, ეს, შეიძლება ადვილად გაცვალეს ამისთვის პრობლემა Set სამი.
მე მაქვს ჩემი helpers.h ფაილი, რომელიც, საკმაოდ ვიდრე helpers.h ჩვენ მოცემული,
აცხადებს ორობითი ძებნა, bubble დალაგების, და შერჩევის ჯიშია.
და find.c თქვენ შეამჩნევთ ხაზი, რა არის, რომ ხაზი 68, ჩვენ მოვუწოდებთ ორობითი
ძებნის ვიდრე ძებნა.
ასე რომ კიდევ ერთხელ, კოდი, რომელიც ხელმისაწვდომია ონლაინ ან კოდი, რომ თქვენ ხართ
შექმნაში ახლა შეიძლება ადვილად გაცვალეს ამისთვის p მითითებული 3 შეამოწმეთ იგი.
>> მაგრამ პირველი, ნება კოდექსის ორობითი ძებნა.
ჩვენი ფუნქცია დეკლარაცია, ჩვენ დაბრუნების bool.
ჩვენ მთელი მოუწოდა ღირებულება.
ჩვენ მასივი რიცხვებით მოუწოდა ღირებულებები, და ვიღებთ n იყოს
ზომა მასივი.
On line 10, სწორედ აქ, მე მაქვს მკვეთრი მოიცავს stdbool.h.
ვინმემ იცის რატომ, რომ არ არსებობს?
ასე რომ, რა, რომ ხაზი კოდი გავაკეთოთ?
>> სტუდენტი: ეს გაძლევთ საშუალებას გამოყენება bool დაბრუნების ტიპის.
>> JASON HIRSCHHORN: ზუსტად.
>> სტუდენტი: თუ ის ბიბლიოთეკა, რომელიც საშუალებას გამოვიყენოთ bool დაბრუნების ტიპის.
>> JASON HIRSCHHORN: ასე მკვეთრი არის stdbool.h ონლაინ მაძლევს ზოგიერთი
განმარტებები და განცხადებები რამ რომ მე დაშვებული გამოყენება
ამ ბიბლიოთეკაში.
ასე რომ, მათ შორის, ამბობს, რომ იქ ამ ტიპის ე.წ. bool, და ეს შეიძლება იყოს
ჭეშმარიტი ან ცრუ.
ასე რომ რა, რომ ხაზი აქვს.
და თუ არ აქვს, რომ ხაზი, მე მიიღონ trouble წერა ამ
სიტყვა აქ, bool, უფლება არსებობს.
სწორედ.
ასე რომ, მე უნდა, რომ ამ კოდი.
OK.
ასე რომ, ეს, კიდევ ერთხელ, არის iterative მობილური არა რეკურსიული ერთი.
ამდენად, მოდით, დავიწყოთ.
>> დავიწყოთ პირველი ონლაინ ფსევდო კოდი.
და იმედია, ჩვენ - თუ არა იმედია.
ჩვენ ვაპირებთ წავიდეთ გარშემო ოთახში.
ჩვენ წავიდეთ ხაზს, და მე დაეხმარება თქვენ გაერკვნენ ხაზი, რომ ჩვენ გვჭირდება
დაწერა პირველი.
ასე რომ, ხოლო სიგრძით სია მეტია ნულოვანი.
დავიწყოთ წინ.
რა ხაზი უნდა დავწერო აქ, კოდი?
>> სტუდენტი: მიუხედავად იმისა, რომ ფრჩხილებში n მეტია 0.
>> JASON HIRSCHHORN: მიუხედავად იმისა, n დიდია, ვიდრე 0.
ასე n ზომა სია, და ჩვენ შემოწმების თუ -
>> [INTERPOSING VOICES]
>> JASON HIRSCHHORN: - ბოდიში?
>> სტუდენტი: როგორ ვიცით, რომ n ზომა სიაში?
>> JASON HIRSCHHORN: უკაცრავად.
პოსტი pset დაზუსტება, ძიება და სორტირების ფუნქციები თქვენ უნდა დაწეროთ,
n ზომა სიაში.
დამავიწყდა განმარტავენ, რომ აქ.
მაგრამ დიახ. n ზომა სიაში, ამ შემთხვევაში.
ასე რომ, ხოლო n მეტია 0.
OK.
ეს შეიძლება დაამტკიცოს ცოტა პრობლემატური თუმცა, თუ რამ გაგრძელდება.
იმის გამო, რომ ჩვენ გავაგრძელებთ ვიცი ზომა სია მთელი ამ
ფუნქცია, მაგრამ ამბობენ, რომ ჩვენ დავიწყოთ off მასივი 5 რიცხვებით.
და ჩვენ გავლა და ჩვენ ახლა narrowed ის ქვემოთ
მასივი 2 რიცხვებით.
რომელიც 2 რიცხვებით არის, რომ?
ზომა არის 2 არის, რომ ჩვენ გვინდა შევხედოთ, მაგრამ 2 არის, რომ?
ამჯამად, რომ აზრი, რომ კითხვაზე?
>> OK.
მე ვთხოვ კიდევ ერთხელ.
ასე რომ, ჩვენ დაიწყება off ერთად ამ მასივი 5 რიცხვებით და n შეადგენს 5, არა?
ჩვენ აწარმოებს მეშვეობით აქ.
ჩვენ, ალბათ, შეცვალოს ზომა, უფლება, როგორც რამ გაგრძელდება.
რაც ჩვენ ვამბობთ, ჩვენ გვინდა, რომ გავაკეთოთ.
ჩვენ არ გვინდა, რომ მოძებნოთ სრული რამ ერთხელ.
ასე რომ ვთქვათ, ჩვენ მას ვცვლით 2.
ჩვენ ნახევარი სია, რომელიც უცნაური.
ასე რომ, სულაც 2.
ახლა n უდრის 2.
მე ბოდიშს ცუდი მარკერის მარკერები.
უფლება?
და ჩვენ ძებნას მეშვეობით სიაში ისევ სიაში ზომა 2.
ისე, ჩვენი მასივი კვლავ ზომა 5.
ჩვენ ვამბობთ, ჩვენ მხოლოდ გვინდა ძებნა 2 ლაქების იგი.
ასე რომ რაც 2 ლაქების არიან ისეთებიც?
>> ამჯამად რომ აზრი?
ისინი დაუტოვებიათ 2 ლაქები?
ისინი უფლება 2 ლაქები?
ისინი შუა 2 ლაქები?
ჩვენ არ გატყდა პრობლემა down, მაგრამ ჩვენ რეალურად არ ვიცი რომელი ნაწილი
პრობლემა ჩვენ ჯერ კიდევ ეძებს, უბრალოდ, რომელსაც ამ 2 ცვლადები.
ამიტომ ჩვენ გვჭირდება ცოტა მეტი, ხოლო n მეტია 0.
ჩვენ უნდა ვიცოდეთ, სად, რომ n ჩვენს ფაქტობრივი მასივი.
>> ასე რომ არავის აქვს შეცვლის ეს ხაზი?
ყველაზე ამ ხაზის იდეალურად სწორი.
არის კიდევ ერთი გარდა?
შეგვიძლია სვოპ რაღაც გარეთ n to რათა ამ ხაზის ოდნავ უკეთესი?
მმ hm?
>> სტუდენტური შეგიძლიათ ინიციალიზაცია ცვლადი მოსწონს სიგრძე n, რომ ამის შემდეგ იქნას გამოყენებული
მოგვიანებით ფუნქცია?
>> JASON HIRSCHHORN: So ინიციალიზაცია ცვლადი სიგრძის N,
და ვიყენებთ, რომ შემდეგ?
მაგრამ მაშინ ჩვენ მხოლოდ განაახლებს სიგრძის და ჩვენ კვლავ გადაეყარონ ამ პრობლემას, სადაც ჩვენ
მოჭრილი სიგრძის ჩვენი პრობლემა, მაგრამ ჩვენ არასდროს არ ვიცით, სადაც, ფაქტობრივად,
რომ სიგრძე რუკები გადატანა.
>> სტუდენტი: არ არის, რომ მოხდება მოგვიანებით, როცა ვამბობთ, ძებნის მარცხენა,
ძებნა უფლება?
თქვენ აპირებთ წასვლა სხვადასხვა ფართობი თქვენი -
>> JASON HIRSCHHORN: ჩვენ ვაპირებთ წავიდეთ ფართობი, მაგრამ ვიცით,
რომლებიც უნდა წავიდეს?
იმ შემთხვევაში, თუ ჩვენ მხოლოდ მასივი და ამ n, ვიცით, სად
წასვლა მასივი.
უკან, არა?
>> სტუდენტური გაქვთ, ისევე, ქვედა შეკრული და ზედა ზღვარი ცვლადი ან
რაღაც მსგავსი?
>> JASON HIRSCHHORN: OK.
ასე რომ, ეს არის კიდევ ერთი იდეა.
ვიდრე უბრალოდ შენახვა ტრეკზე ზომა, ჩვენ ტრეკზე ქვედა და
ზედა ზღვარი ცვლადი.
ასე როგორ უნდა გამოვთვალოთ ზომა ქვედა შეკრული და ზედა ზღვარი?
>> [INTERPOSING VOICES]
>> JASON HIRSCHHORN: გამოკლება.
და ასევე შენახვა ტრეკზე ქვედა შეკრული და ზედა ზღვარი შეგვატყობინოთ,
ჩვენ ძებნას ამ ორ?
ჩვენ ძებნას ამ ორ მეტი აქ?
ჩვენ ძებნას შუა ორი?
ალბათ არ ცენტრიდან იმიტომ, ეს, ფაქტობრივად, არის ორობითი ძებნა.
მაგრამ ახლა ჩვენ შევძლებთ მისაღებად ზომა, არამედ ლიმიტები მასივი.
არსებითად, თუ ჩვენ გვაქვს ჩვენი დიდი სატელეფონო წიგნი, ჩვენ დააკოპიროთ ის ნახევარი.
ახლა ჩვენ ვიცით, სადაც ეს პატარა სატელეფონო წიგნი არის.
მაგრამ ჩვენ რეალურად არ გაფატვრვის სატელეფონო წიგნი ნახევარი.
ჩვენ მაინც უნდა იცოდეს, სადაც ახალი საზღვრები, ჩვენი პრობლემა არის.
ვინმეს გაქვთ რაიმე შეკითხვები ამის შესახებ?
დიახ?
>> სტუდენტი: თუ ეს ქმნის ცვლადი, i, რომ თქვენ მაშინ უბრალოდ გადაიტანოს
პოზიცია i ნათესავი მისი მიმდინარე პოზიცია და სიგრძის, n?
>> JASON HIRSCHHORN: რა არის i?
>> სტუდენტი: Like i დაემსგავსო სახის -
თქვენნაირი იქნებოდა ინიციალიზაცია i იყოს შუა პოზიცია მასივი.
და მაშინ, თუ ღირებულება პოზიციაში i in შუა მასივი ნაპოვნი
შეიძლება იყოს ნაკლები ღირებულება გჭირდებათ, მე ახლა ხდება სიგრძეზე მასივი, პლუს
ღირებულება i იყოფა 2.
ისევე როგორც, ვხედავ, თქვენ გადაეტანა i -
>> JASON HIRSCHHORN: Right.
>> სტუდენტი: - მდე -
>> JASON HIRSCHHORN: ასე რომ მე თითქმის დადებითი, რომ იმუშავებს.
მაგრამ საქმე ისაა, რომ თქვენ უნდა ორ ცალი ინფორმაცია აქ.
თქვენ შეგიძლიათ ეს გააკეთოთ დასაწყისში და ბოლოს, ან თქვენ შეგიძლიათ ეს გააკეთოთ ზომა, და შემდეგ
ზოგიერთი მარკერის.
მაგრამ თქვენ უნდა ორი ცალი ინფორმაციის აქ.
თქვენ არ შეგიძლიათ მიიღოთ მიერ ერთად მხოლოდ ერთი.
ამჯამად რომ აზრი?
>> ამიტომ, ჩვენ ვაპირებთ გავლა და ჩვენ ვაპირებთ, რომ [INAUDIBLE]
და შექმნათ რამდენიმე მარკერები.
ასე what'd წერთ თქვენი კოდი?
>> სტუდენტი: მე უბრალოდ განაცხადა, int შეკრული ერთი უდრის 0.
>> JASON HIRSCHHORN: მოდით მოვუწოდებთ რომ int, დასაწყისია.
>> სტუდენტი: OK.
>> JASON HIRSCHHORN: ეს რაც უფრო გრძნობა ჩემთვის.
და?
>> სტუდენტი: მე ვუთხარი, ვფიქრობ, int დამთავრებული.
>> JASON HIRSCHHORN: GEO დამთავრებული.
>> სტუდენტი: ვფიქრობ, n მინუს 1, ან რამე მაგდაგვარს.
მსგავსად, ბოლო ელემენტს.
>> JASON HIRSCHHORN: ასე რომ თქვენ წერდა, int დაწყებული შეადგენს 0, მძიმით, და int
დამთავრებული შეადგენს n მინუს 1, მძიმით.
ასე რომ, არსებითად, თუ რას ვაკეთებთ აქ, 0 პირველი პოზიცია.
და როგორც ვიცით მასივები, ისინი არ მიდიან მდე n, მათ ახვიდეთ n მინუს 1.
ასე რომ, ჩვენ გვაქვს გარკვეული საზღვრები ჩვენი მასივი.
და ეს საწყის საზღვრები არ უნდა იყოს საწყის ფარგლებში ჩვენი პრობლემა.
OK.
ასე რომ ჟღერს კარგი.
შემდეგ, თუ ჩვენ დავუბრუნდებით ამ ხაზის, ხოლო ხანგრძლივობა სია მეტია 0,
რა ნაცვლად, n, უნდა ჩვენ აქ?
>> სტუდენტი: დაწერეთ დამთავრებული მინუს დასაწყისში.
>> JASON HIRSCHHORN: მიუხედავად იმისა, დამთავრებული minus დაწყებული მეტია 0?
OK.
და ჩვენ შეგვიძლია, თუ გვინდოდა გააკეთოს, რომ ცოტა გავალამაზოთ, რა
უნდა გვექნა?
თუ გვინდოდა, გაწმენდა ამ კოდექსის up ცოტა?
როგორ შეგვიძლია თავი დავაღწიოთ 0?
ეს არის მხოლოდ სტილის საკითხია.
ეს სწორი არ არის.
>> სტუდენტი: Ending არ თანაბარი დასაწყისში?
>> JASON HIRSCHHORN: ჩვენ შეგვიძლია გავაკეთოთ რა?
>> [INTERPOSING VOICES]
>> სტუდენტი: Ending დიდია?
>> JASON HIRSCHHORN: ჰო.
ჩვენ შეგვიძლია გავაკეთოთ ხოლო დამთავრებული მეტია დასაწყისში.
უფლება.
ჩვენ დამატებული დაწყებული მეორე მხარეს რომ, და ჩვენ მოიშორეს 0.
ასე რომ, ეს უბრალოდ გამოიყურება ცოტა სუფთა.
OK.
ასე რომ, ხოლო სიგრძეზე სიაში არის 0, ჩვენ წერდა რომ, ხოლო დამთავრებული მეტია
გარდა დასაწყისია.
ჩვენ ვაპირებთ დააყენა ჩვენი აუცილებელია curly აფრთხილებს, ხოლო შემდეგ პირველი, რაც
ჩვენ გვინდა, რომ შევხედოთ მათ პატარა სიაში.
თქვენ?
შეგიძლიათ მომეცი -
>> სტუდენტი: თუ ფრჩხილებში ღირებულება კვადრატული ფრჩხილი -
>> JASON HIRSCHHORN თუ ფრჩხილებში ღირებულება კვადრატული ფრჩხილი.
>> სტუდენტი: დამთავრებული იყოფა 2.
>> JASON HIRSCHHORN: დამთავრება?
>> სტუდენტი: მე ვხედავ პრობლემა -
>> JASON HIRSCHHORN: OK.
ასევე, შევხედოთ ცენტრიდან.
ვიცით, რა შუა არის?
ჰო.
ნება მომეცით წაშლა რომ კოდი.
ვიცით, რა შუა არის?
არაფერი, როდესაც თქვენ გაქვთ დასაწყისში და ბოლოს, როგორ მოვძებნოთ
შუა?
>> სტუდენტი: თქვენ საშუალოდ.
>> სტუდენტი: თქვენ დაამატეთ ერთად და შემდეგ -
>> JASON HIRSCHHORN სანიშნეს მათ ერთად და მერე?
>> სტუდენტი: თქვენ საშუალოდ.
ყოფს მას 2.
>> JASON HIRSCHHORN სანიშნეს მათ ერთად და გაყავით 2.
ასე int შუა უდრის?
Tom, თქვენ შეგიძლიათ მისცეს მას ჩემთვის?
>> სტუდენტი: გემო plus დამთავრებული -
>> JASON HIRSCHHORN: გემო პლუს დამთავრებული.
>> სტუდენტი: ყველა, bracket, იყოფა 2.
>> JASON HIRSCHHORN: ყველა, ფრჩხილებში, იყოფა 2.
ასე რომ მაძლევს შუა არაფერი, სწორი?
>> სტუდენტი: თქვენ უნდა გარშემო it up.
>> JASON HIRSCHHORN: რას ნიშნავს, მე უნდა გარშემო ეს?
>> [INTERPOSING VOICES]
>> სტუდენტი: იმიტომ, რომ თუ ეს უცნაური ნომერი, მაშინ ეს მოსწონს -
>> JASON HIRSCHHORN: Well, OK.
მე ვერ გარშემო it up.
მაგრამ თუ ეს უცნაური ნომერი, ან, 5, მე არ შემიძლია აღების 1 დაშორებით ცენტრიდან.
ან თუ კი ნომერი, ან, უფრო სწორად, ეს უკეთეს შემთხვევაში.
თუ ეს 4, ჩვენ მხოლოდ 4, მე შეუძლია მიიღოს პირველი "შუა", გაცემა, unquote ან
მეორე "შუა" ერთი.
არც იმუშავებს ორობითი ძებნა, ასე რომ მე არ რეალურად უნდა გარშემო მას.
მაგრამ არსებობს ერთი სხვა რამ უნდა შევხედოთ ამ ხაზის.
ჩვენ შეიძლება არ ესმოდეს, რომ ეს არ არის, მაგრამ ჩვენ დავბრუნდებით იგი.
იმის გამო, რომ ამ ხაზის ფაქტობრივად დღემდე სჭირდება ერთი სხვა რამ.
>> მაგრამ ჯერჯერობით, ჩვენ წერილობითი ოთხი ხაზი კოდი.
გვაქვს ჩვენი დასაწყისში და დამთავრებული მარკერები.
ჩვენ გვაქვს ჩვენი ხოლო loop, რომელიც რუკები პირდაპირ ჩვენი pseudocode.
ჩვენ ვეძებთ შუა, რომ რუკები პირდაპირ გადატანა ჩვენი pseudocode.
მე ვიტყოდი, ეს მიდის შუა სია, ეს ხაზი კოდი.
და მაშინ, როდესაც ჩვენ წასვლა შუა სია, შემდეგი რამ უნდა გავაკეთოთ
არის შემოწმება, თუ ჩვენი ღირებულება არსებობს pseudocode ჩვენ წერდა ადრე.
>> ასე როგორ უნდა შეამოწმოთ, თუ ჩვენი ღირებულება არის შუა სიაში?
თქვენ.
რატომ არ აკეთებთ ამას?
>> სტუდენტი: თუ ჩვენი ღირებულება ის არის შუა უდრის
რასაც ჩვენ მითითებული -
ვგულისხმობ ტოლია ტოლია -
>> JASON HIRSCHHORN: ეს -
OK.
>> სტუდენტი: მე არ ვარ დარწმუნებული, თუ რა ცვლადი ჩვენ ვეძებთ
განთავსების თუმცა, რადგან -
>> [INTERPOSING VOICES]
>> სტუდენტი: [INAUDIBLE].
>> JASON HIRSCHHORN: ზუსტად.
პოსტი ფუნქცია დეკლარაცია, ჩვენ ვეძებთ ღირებულება.
ასე რომ ჩვენ ეძებს ღირებულება მასივი ღირებულებებს.
ასე რომ თქვენ სწორედ.
თქვენ ამის გაკეთება, თუ ღია paren ღირებულება bracket შუა დახურული ფრჩხილი შეადგენს
უდრის ღირებულება და შიგნით არსებობს რა უნდა გავაკეთოთ?
თუ ჩვენი ღირებულება იქ, რა ჩვენ უნდა გავაკეთოთ?
>> [INTERPOSING VOICES]
>> სტუდენტი: დაბრუნება ნულოვანი.
>> JASON HIRSCHHORN: დაბრუნება ჭეშმარიტი.
>> სტუდენტი: დაბრუნება ჭეშმარიტი.
>> JASON HIRSCHHORN: მიხეილი, რა ამ ხაზის გაკეთება?
>> სტუდენტი: [INAUDIBLE] პროგრამის გასაშვებად მისი რა თქმა უნდა, და რომ დასრულდა და
თქვენ, რა უნდა გავაკეთოთ?
>> JASON HIRSCHHORN: პროგრამა თუ რა ხდება?
ამ შემთხვევაში?
>> სტუდენტი: ფუნქცია.
>> JASON HIRSCHHORN: ფუნქცია.
ასე რომ, დაბრუნებას, რასაც ეწოდება და მისცეს მას ღირებულება, მართალია.
სწორედ.
მთავარი.
რა არის დაბრუნების ტიპის მთავარი, მაიკლ?
>> სტუდენტი: int, რიცხვი?
>> JASON HIRSCHHORN: int, ზუსტად.
მთელი რიცხვი.
ეს იყო მხოლოდ კითხვა, რათა დავრწმუნდეთ, თქვენ ბიჭები არ ყოფილა თავზე მას.
რას ჩვეულებრივ დაბრუნდება, თუ ყველაფერი კარგად მუშაობს?
>> სტუდენტი: Zero.
>> JASON HIRSCHHORN: Zero.
სწორედ.
>> სტუდენტი: თუ ეს მხოლოდ ბრუნდება ნამდვილი, არ არსებობს ინფორმაცია აძლევენ
იმაზე, თუ რა -
ოჰ, ეს მხოლოდ ამბობდა, რომ ღირებულება შიგნით მასივი.
>> JASON HIRSCHHORN: ზუსტად.
ეს პროგრამა არ აძლევდა ინფორმაცია სადაც ზუსტად მნიშვნელობა.
ის მხოლოდ ამბობდა, რომ, დიახ, აღმოჩნდა, მას, ან არა, ჩვენ არ საპოვნელად.
ასე რომ, თუ ნომერი აღმოაჩინეს, TRUE.
ისე, რეალურად ჩვენ უბრალოდ გააკეთეს, რომ ნამდვილად სწრაფად, რომ ერთი ხაზი კოდი.
ასე რომ მე გადაადგილება რომ ხაზი pseudocode.
>> სტუდენტური არ გვჭირდება შეცვლის მასივი?
ეს უნდა იყოს ღირებულებები, არ ღირებულება, არა?
>> JASON HIRSCHHORN: უკაცრავად.
დიდი მადლობა.
>> სტუდენტი: Yeah.
>> JASON HIRSCHHORN: ეს ხაზი უნდა იყოს ღირებულებებს.
სწორედ.
OK.
ამიტომ ჩვენ შევხედე შუა სიაში.
იმ შემთხვევაში, თუ ნომერი არ არის ნაპოვნი დაბრუნების ჭეშმარიტი.
გრძელდება ჩვენი pseudocode, თუ შუა მეტია, ძებნის დატოვა.
ასე რომ, მე მქონდა აქ, თუ ნომერი უმაღლესი, ძებნის დატოვა.
კონსტანტინე, შეგიძლიათ მისცეს ჩემთვის ეს ხაზი კოდი?
>> სტუდენტი: თუ ღირებულება შუა -
>> JASON HIRSCHHORN: ასე რომ, თუ ღირებულება -
თუ ღია paren აფასებს bracket შუა ახლო bracket -
>> სტუდენტი: მცირეა ღირებულება?
>> JASON HIRSCHHORN: არის ნაკლები.
>> სტუდენტი: ნაკლები ღირებულება.
>> JASON HIRSCHHORN: ფასი.
ისე, რეალურად, გსურთ შეამოწმეთ თუ ნომერი -
უკაცრავად.
ეს არის პატარა დამაბნეველი.
მაგრამ სხვას თუ ნომერი შუა სია მეტია.
>> სტუდენტი: Oh, OK.
>> JASON HIRSCHHORN: მე შეცვლის.
სხვაგან, თუ შუა მაღალია, ჩვენ გსურთ მოძებნოთ მარცხენა, OK?
და რა ვქნათ შიგნით თუ მდგომარეობა?
>> სტუდენტი: შემიძლია პატარა ცვლილება მდგომარეობა, შეცვალოს იგი სხვაგან, თუ?
>> JASON HIRSCHHORN: Else თუ?
OK.
ასე რომ, ეს კოდი განახორციელებს დაახლოებით იგივე.
მაგრამ ლამაზი რამ გამოყენების შესახებ, თუ სხვაგან, თუ სხვაგან, თუ, თუ სხვაგან, თუ სხვაგან,
იმას ნიშნავს, რომ მხოლოდ ერთი, ვინც აპირებს მოწმდება, არ სამივე მათგანი,
პოტენციურად.
და, რაც უფრო ცოტა გავალამაზოთ კომპიუტერი, რომ
გაშვებული თქვენი პროგრამა.
>> ასე [? კონსტანტინე?]
ჩვენ შიგნით ამ ხაზის სხვაგან, თუ ღირებულებები, bracket შუა ახლო bracket
მეტია ღირებულება.
რა უნდა გავაკეთოთ?
ჩვენ უნდა მოძებნოთ მარცხენა.
როგორ გავაკეთოთ ეს?
მე ვაპირებ მოგცემთ დასაწყისია.
>> ჩვენ ეს ორი რამ მოუწოდა დაწყებული და დამთავრებული.
ასე რომ, რა უნდა მოხდეს დასაწყისში?
თუ გსურთ მოძებნოთ მარცხნივ სია, ჩვენ კიდევ ჩვენი დღევანდელი დასაწყისში.
რას უნდა გავაკეთოთ ეს?
>> სტუდენტი: ჩვენ დავსახეთ დასაწყისში შუა პლუს 1.
>> JASON HIRSCHHORN: ასე რომ, თუ ჩვენ ეძებს მარცხენა?
>> სტუდენტი: უკაცრავად, შუა მინუს -
ასე რომ ფინალი იქნება შუა მინუს 1 და დასაწყისში -
>> JASON HIRSCHHORN: რა ხდება დასაწყისში?
>> სტუდენტი: ეს რჩება იგივე.
>> JASON HIRSCHHORN: So მნიშვნელობა რჩება იგივე.
თუ ჩვენ ძებნას მარცხენა, ჩვენ იმავე დასაწყისში -
სწორედ.
და დამთავრებული?
უკაცრავად, რას დამთავრებული ტოლია ერთხელ?
>> სტუდენტი: ახლო მინუს 1.
>> JASON HIRSCHHORN: Middle მინუს 1.
ახლა, რატომ მინუს 1, არა მხოლოდ შუა?
>> სტუდენტი: შუა გარეთ ფოტოზე უკვე, იმიტომ რომ ჩვენ
შევამოწმე, რომ ეს out?
>> JASON HIRSCHHORN: ეს სწორედ.
ცენტრიდან არის სურათზე.
ჩვენ უკვე შეამოწმეს ცენტრიდან.
ასე რომ, ჩვენ არ გვინდა "შუა" გაცემა unquote, გააგრძელოს იყოს
მასივი, რომ ჩვენ ვეძებთ.
ასე რომ, ეს არის ფანტასტიური.
>> სხვაგან თუ ღირებულებები bracket შუა მეტია გარდა ღირებულება დამთავრებული შეადგენს
შუა მინუს 1.
Jeff, რაც შეეხება ამ ბოლო ხაზი?
>> სტუდენტი: Else.
ღირებულებები შუა ნაკლებია მნიშვნელობა?
>> JASON HIRSCHHORN: ჩვენ თქვენ მაძლევს სხვას.
ასე რომ, თუ არ მაძლევენ -
>> სტუდენტი: ასე შემდეგ დაწყებულ იქნება შუა პლუს 1.
>> JASON HIRSCHHORN: გემო შეადგენს შუა პლუს 1, კიდევ ერთხელ, იმავე
მიზეზი იმისა, რომ კონსტანტინე მოგვცა ადრე.
და ბოლოს, ვინც არ მიეცა მე ხაზი კოდი არის?
დაბრუნების ცრუ, Aleha, რა ჩვენ წერენ აქ?
>> სტუდენტი: დააბრუნებს: FALSE.
>> JASON HIRSCHHORN: დაბრუნება ყალბი.
და ჩვენ უნდა გავაკეთოთ, რადგან თუ ჩვენ არ პოულობთ მას, ჩვენ უნდა ვთქვათ, ჩვენ
არ საპოვნელად.
და ვთქვით, რომ ჩვენ ვაპირებთ დაბრუნებას bool, ასე რომ, ჩვენ აუცილებლად უნდა დაბრუნდეს
bool სადღაც.
>> მოდით აწარმოებს ამ კოდი.
მე რეალურად აპირებს -
ასე რომ, ჩვენ ტერმინალში.
ჩვენ გარკვევა ჩვენი ფანჯარა.
მოდით ყველა.
ჩვენ ვნახეთ, არსებობს ერთი შეცდომა.
იქ შეცდომა on line 15, მოსალოდნელია მძიმით დასასრულს
დეკლარაცია.
ასე რომ, რა დამავიწყდა?
>> სტუდენტი: მძიმით.
>> JASON HIRSCHHORN: მძიმით მარჯვენა აქ.
ვფიქრობ, რომ ტომ კოდი.
ასე რომ, ტომი, [INAUDIBLE].
Just kidding.
მოდით ყველა ერთხელ.
>> სტუდენტი: რა Dropbox დირექტორია უნდა იყოს ეს?
>> JASON HIRSCHHORN: ასე რომ თქვენ შეგიძლიათ უბრალოდ უყურეთ ამ bit.
თუმცა ისევ და ისევ, თუ თქვენ სურდა გადავიდეს ამ კოდი თქვენს pset3 დირექტორია ცდილობენ
ის, რომ ის, რაც გავაკეთე.
თუ თქვენ შეამჩნევთ აქ - ვწუხვარ, კარგი კითხვაა.
>> [? LS,?]
მაქვს აქ find.c კოდი ამ კვირის დისტრიბუტივისაა კოდი.
მაქვს helpers.h.
მაქვს მარკა ფაილი, რომელიც მე რეალურად რედაქტირებული ცოტა უნდა შეიცავდეს ეს ახალი
ფაილი: ჩვენ წერილობით.
ყველა რომ კოდი იქნება შესაძლებელი, არ განაწილების კოდი, მაგრამ ახალი
რათა ფაილი, ახალი helpers.h ფაილი ხელმისაწვდომი იქნება ონლაინ download.
ერთხელ, ასე რომ ეს ის დამატებითი კოდები გვაქვს.
>> ასე რომ ყველა, თითო ეს ხაზი, რაც იპოვოს, ორობითი, bubble შერჩევა - მარკისა
სამივე მათგანი და ადგენს შევიდა ამ შესრულებადი კოდი იპოვოს.
ასე რომ, ზოგადად, ჩვენ არ გვინდა, to პირდაპირ check50.
ჩვენ გვინდა აწარმოებს ზოგიერთი ტესტები ჩვენი საკუთარი.
მაგრამ მხოლოდ ასე შეგვიძლია დააჩქარებს ამ ცოტა, check50 2013 pset3.find გაივლიან
in helpers.c-- ჩემი ცუდი.
>> მე არ მაქვს, რომ ახლა.
ასე რომ ჩვენ რეალურად აპირებს აწარმოებს კოდი რეალური.
Usage.find /, თქვენ იცით, რას ნიშნავს ეს?
>> სტუდენტი: თქვენ უნდა მეორე ბრძანების იგი.
>> JASON HIRSCHHORN: მჭირდება მეორე command line.
და ერთ სპეციფიკაცია, მე უნდა შესვლის რასაც ჩვენ ვეძებთ.
მოდით შევხედოთ 42.
ჩვენ გავაგრძელებთ მას დახარისხებული, რადგან ჩვენ არ წერია ერთგვარი ფუნქცია ჯერ -
42, 43, 44.
>> და კონტროლის D არ აღმოჩნდა ნემსის haystack.
რომ ცუდია.
ეს ნამდვილად არსებობს.
მოდით ცდილობენ რაღაც.
იქნებ ეს იმიტომ, რომ მე დააყენა ის დასაწყისში.
>> მოდით 41, 42, 43.
იქ ჩვენ წავიდეთ.
ის ი.
მოდით ამას ბოლოს ახლა, უბრალოდ ასე რომ, ჩვენ შეიძლება იყოს სრულყოფილი -
40, 41, 42.
ვერ ნემსი.
ამიტომ ვთქვი, ეს ადრე.
სამწუხაროდ, ვიცოდი ეს მოხდება.
>> მაგრამ პედაგოგიური მიზნებისათვის, კარგია შესწავლას.
ეს არ იმუშავებს.
გარკვეული მიზეზების გამო, ეს ვერ პოულობთ მას.
ჩვენ ვიცით, რა არის, მაგრამ ჩვენ არ მოძიებაში.
ასე რომ, ერთი რამ, ჩვენ შეგვიძლია გავაკეთოთ, არის გაიაროს GDB საპოვნელად, მაგრამ ვინმეს,
გარეშე გადის GDB აქვს გრძნობა, სადაც ჩვენ ბრალია?
[? Madu? ?]
>> სტუდენტი: მე ვფიქრობ, რომ ეს შეიძლება იყოს, როდესაც დამთავრებული უდრის დასაწყისში, და ეს
მხოლოდ ერთი ელემენტი სიაში.
მაშინ უბრალოდ იგნორირებას უკეთებს ის ნაცვლად რეალურად შემოწმების.
>> JASON HIRSCHHORN: ეს სწორედ.
როდესაც ფინალი შეადგენს დასაწყისში, ჩვენ ჯერ კიდევ აქვს ელემენტს ჩვენს სიაში?
>> სტუდენტი: დიახ.
>> JASON HIRSCHHORN: დიახ, ფაქტობრივად, ჩვენ ერთი და მხოლოდ ერთი ელემენტია.
და რომ სავარაუდოდ მოხდეს, როდესაც, პოსტი კოდი ჩვენ გამოცდილი, ჩვენ ვიმყოფებით
თვალწინ haystack ან ბოლოს haystack.
სწორედ იქ, სადაც დასაწყისში და ფინალი აპირებს თანაბარი
ერთი, ორობითი ძებნა.
ასე რომ, ამ ორ შემთხვევაში ეს არ იმუშავებს, რადგან დამთავრებული ტოლფასი იყო დასაწყისში.
>> მაგრამ თუ დამთავრებული ტოლია დასაწყისში, ამჯამად ამ ხოლო loop შეასრულოს?
ეს არ.
და ჩვენ შეგვიძლია არ შემოწმდება რომ კიდევ ერთხელ მეშვეობით GDB.
მაშ, როგორ შეგვიძლია დაფიქსირება ამ კოდი, იმიტომ, როდესაც ხოლო დამთავრებული უდრის
დაწყებული, ჩვენ ასევე გვინდა, რომ ეს ხოლო loop გასაშვებად.
>> ასე რომ, რა fix შეგვიძლია ხაზი 18?
>> სტუდენტი: [INAUDIBLE] მეტია მეტი ან ტოლია.
>> JASON HIRSCHHORN: ზუსტად უფლება.
ხოლო ფინალი მეტია ან ტოლია დასაწყისში.
ახლა, ჩვენ დარწმუნებული ვართ, რომ მიიღოთ, რომ კუთხეში შემთხვევაში დასასრულს.
და ვნახოთ.
მოდით აწარმოებს ამ ერთი მეტი დრო.
>> მოდით ყველა.
ერთხელ, თქვენ უნდა მხოლოდ დაიცვას გასწვრივ აქ.
მონახე 41 ამ დროს.
უბრალოდ შეინახოს იგი თანმიმდევრული.
>> მონახე 42.
მოდით ამას დასაწყისში -
42, 43, 44.
ჩვენ ვერ.
ასე რომ, მართლაც ცვლილება ჩვენ გვჭირდებოდა მიიღოს.
>> ეს იყო ბევრი კოდირების ჩვენ უბრალოდ გააკეთეს, ორობითი ძებნა.
ვინმეს გაქვთ რაიმე შეკითხვები, სანამ მე გადაადგილება შევიდა ხაზები ჩვენ წერდა
ორობითი ძებნა ან როგორ ჩვენ figured თუ რა ჩვენ არ გაერკვნენ?
სანამ ჩვენ გადასვლა, ასევე მინდა აღვნიშნო , რომ საერთო ჯამში, ჩვენ mapped
ჩვენი ფსევდო კოდი ერთი ერთი გადატანა ჩვენი კოდი.
>> ჩვენ არ გვაქვს, რომ სახიფათო რამ გაერკვნენ ერთად
დაწყებული და დამთავრებული.
მაგრამ თქვენ არ figured რომ, თქვენ იქნებოდა დაწერილი საკმაოდ ბევრი
იდენტური კოდი, გარდა იმ ზედა ორი ხაზი.
და მაშინ მიხვდა, როდესაც თქვენ გააკეთა ის კონტროლისა და შემთხვევები,
თქვენ უნდა რაღაც.
ისე კი, თუ მოჰყვა ჩვენი ფსევდო კოდი ხაზი ხაზი, თქვენ უკვე
მიღებული ყველა მაგრამ ორი ხაზი კოდი თქვენ საჭირო დაწერა.
>> და მე მინდა იყოს, რომლებსაც სურთ დადებს, რომ თქვენ ბიჭები იქნებოდა ყველა figured რომ
საკმაოდ სწრაფად, რომ თქვენ საჭირო იმისათვის, რომ გარკვეული მარკერის იქ გაერკვნენ
თუ სად იყო.
რომ კიდევ ერთხელ, არის ძალა აკეთებს ფსევდო კოდი ვადამდე.
ასე რომ ჩვენ შეგვიძლია გავაკეთოთ ლოგიკა პირველი, ხოლო შემდეგ ჩვენ შეგვიძლია ფიქრი სინტაქსი.
>> რომ ჩვენ დაბნეული შესახებ ლოგიკა ხოლო ცდილობს დაწეროს ეს კოდი C,
ჩვენ არ მიღებული ყველა არევა.
და მაშინ ჩვენ მინდა იყოს სვამს კითხვებს ლოგიკა და სინტაქსი და meshing
მათ ყველა ერთად.
და ჩვენ არ მიღებული დაკარგული რა შეიძლება სწრაფად გახდეს
ძალიან რთული პრობლემაა.
მოდით გადავიდეთ ახლა შერჩევა ჯიშია.
>> ჩვენ 20 წუთი დარჩა.
ასე რომ, ისეთი შეგრძნება მაქვს, ჩვენ ვერ შეძლებს მიიღოთ მეშვეობით ყველა შერჩევის დალაგების
და ბუშტი ჯიშია.
მაგრამ მოდით მინიმუმ მცდელობა დასრულდება შერჩევა ჯიშია.
ასე რომ განახორციელოს შერჩევა სახის გამოყენებით შემდეგი ფუნქცია დეკლარაცია.
>> ერთხელ, ეს აღებულია პრობლემა კომპლექტი სპეციფიკაცია.
Int ღირებულებების ფრჩხილებში არის მასივი რიცხვებით.
და int.n არის ზომა, რომ მასივი.
შერჩევა სახის აპირებს დასალაგებლად ამ მასივი.
>> ასე რომ თითო ჩვენი ფსიქიკური მოდელის შერჩევა სახის, ჩვენ გაიყვანოს -
პირველი, ჩვენ გაიაროს სიაში პირველი დრო, პატარა ნომერი, ან,
დააყენოს ის დასაწყისში, იპოვოს მეორე პატარა ნომერი, დააყენოს ის
მეორე პოზიციაზე, თუ ჩვენ გვინდა დალაგების აღმავალი შეკვეთა.
მე არ აიძულა თქვენ დაწერა ფსევდო კოდი ახლა.
>> მაგრამ სანამ ჩვენ გავაკეთებთ კოდი, როგორც კლასი ხუთი წუთის განმავლობაში, ჩვენ ვაპირებთ დავწეროთ
ფსევდო კოდი ასე რომ ჩვენ გვაქვს გარკვეული სადაც ჩვენ ვაპირებთ.
ასე რომ ცდილობენ წერენ ფსევდო კოდი საკუთარი.
და შემდეგ ცდილობენ იქცეს, რომ ფსევდო კოდი შევიდა კოდი.
ჩვენ ყველაფერს გავაკეთებთ, რომ, როგორც ჯგუფი ხუთ წუთში.
>> და რა თქმა უნდა, ნება მომეცით ვიცი, თუ თქვენ გაქვთ რაიმე შეკითხვებს.
>> სტუდენტური სწორედ ეს?
>> JASON HIRSCHHORN: იხილეთ რამდენად შორს თქვენ შეუძლიათ მიიღონ კიდევ ორი ​​წუთის განმავლობაში.
მე მესმის, თქვენ არ შეძლებს დასრულდება.
მაგრამ ჩვენ წავიდეთ ამ, როგორც ჯგუფი.
>> თქვენ ყველა კოდირების ასე რომ [INAUDIBLE], ამიტომ მე უკაცრავად პაუზის რას ვაკეთებთ.
მაგრამ მოდით გავლა ამ, როგორც ჯგუფი.
და ისევ, ორობითი ძებნა, თქვენ ყველა მისცეს ჩემთვის ერთი თუ არა ხაზი კოდი.
გმადლობთ, რომ.
ჩვენ ვაპირებთ, რომ გავაკეთოთ იგივე აქ, კოდი ერთად, როგორც ჯგუფი.
>> ასე რომ შერჩევა ერთგვარი - მოდით დავწეროთ რამდენიმე სწრაფი ფსევდო კოდი.
პოსტი გონებრივი მოდელი, შეგიძლიათ ვინმეს მომეცი პირველი ხაზი ფსევდო კოდი, გთხოვთ?
რა გსურთ?
>> სტუდენტი: მიუხედავად იმისა, რომ სიაში მწყობრიდან.
>> JASON HIRSCHHORN: OK, ხოლო სიაში არის მწყობრიდან.
და რას ნიშნავს "მწყობრიდან?"
>> სტუდენტი: მიუხედავად იმისა, რომ [INAUDIBLE]
ჯერ არ არის დახარისხებული.
>> JASON HIRSCHHORN: მიუხედავად იმისა, რომ სიაში მწყობრიდან, რა ვქნათ?
მომეცი მეორე ხაზი, გთხოვთ, Marcus.
>> სტუდენტი: ასე რომ მომდევნო პატარა ნომერი.
ეს იქნება indented.
>> JASON HIRSCHHORN: ასე რომ იპოვოს მომდევნო პატარა ნომერი.
და მერე სხვისი?
მას შემდეგ, რაც ჩვენ მომავალი პატარა ნომერი, რა ვქნათ?
მე ვაპირებ ვთქვა იპოვოს ყველაზე პატარა ნომერი.
ეს არის ის, რაც ჩვენ გვინდა, რომ გავაკეთოთ.
>> ასე რომ ყველაზე პატარა ნომერი.
მაშინ რა ვქნათ?
>> სტუდენტი: [INAUDIBLE] დასაწყისში.
>> JASON HIRSCHHORN: უკაცრავად?
>> სტუდენტი: ადგილი იგი დასაწყისში სიაში.
>> JASON HIRSCHHORN: So განათავსეთ იგი დასაწყისში სიაში.
და რა უნდა გავაკეთოთ, რომ ის რომ იყო დასაწყისში
სიაში, უფლება?
ჩვენ overwriting რაღაც.
ასე რომ სად ჩვენ, რომ?
ჰო, ანა?
>> სტუდენტი: სად პატარა ნომერი?
>> JASON HIRSHHORN: ასე რომ დააყენა დასაწყისში სიაში, სადაც
პატარა ნომერი იყო.
ასე რომ სანამ სიაში არის მწყობრიდან, იპოვოს ყველაზე პატარა ნომერი, ან, მოათავსეთ იგი
დასაწყისში სიაში, დააყენა დასაწყისში სიაში, სადაც
პატარა ნომერი იყო.
Marcus, შეგიძლიათ rephrase ამ ხაზის ხოლო სია მწყობრიდან?
>> სტუდენტი: მიუხედავად იმისა, რომ ნომერი არ არის დახარისხებული?
>> JASON HIRSHHORN: OK, ასე, რათა ვიცით, რომ ნომერი არ იყო
დახარისხებული, რა უნდა გავაკეთოთ?
რამდენად გვჭირდება გავლა ამ სიაში?
>> სტუდენტი: ამიტომ ვფიქრობ, ამისთვის მარყუჟის, ან ხოლო, ხოლო ციფრები შემოწმდება ნაკლებია,
გარდა სიგრძეზე სიაში?
>> JASON HIRSHHORN: OK, რომ კარგია.
ვფიქრობ misphrased ჩემი შეკითხვა ცუდად.
მე უბრალოდ ცდილობს at ჩვენ ვაპირებთ, რომ უნდა წავიდეს
მთელი სია.
ასე რომ სანამ სიაში არის მწყობრიდან, ჩემთვის ძნელია რუკა.
მაგრამ ძირითადად, ასე მე ვფიქრობ, რომ ამის შესახებ.
გავლა მთელი სია, იპოვოს პატარა ნომერი, განათავსეთ იგი
დაწყებული - ფაქტობრივად, თქვენ უფლება.
მოდით დააყენა ორივე.
>> ასე რომ სანამ სიაში არის მწყობრიდან, ჩვენ უნდა გაიაროს მთელი სია
ერთხელ, იპოვოს ყველაზე პატარა ნომერი, ადგილი ის დასაწყისში სიაში, დასვა
დასაწყისში სიაში, სადაც პატარა ნომერი იყო, ხოლო შემდეგ, თუ
სიაში კვლავ მწყობრიდან გამოვიდა, ჩვენ მივიღე გავლა ამ
პროცესი ისევ, არა?
სწორედ ამიტომ შერჩევის დალაგების, Big-O runtime შერჩევის დალაგების, ვინმე?
>> სტუდენტი: n კვადრატში.
>> JASON HIRSHHORN: n კვადრატში.
იმის გამო, როგორიცაა Marcus და მე უბრალოდ მიხვდა, აქ, ჩვენ ვაპირებთ, რომ უნდა
გავლა სია სია რაოდენობის ჯერ.
ასე რომ გადის რაღაც ხანგრძლივობა n n რაოდენობის ჯერ
ფაქტიურად n კვადრატში.
>> ასე რომ, ეს არის ჩვენი pseudocode.
ეს ძალიან კარგია.
ვინმეს გაქვთ რაიმე შეკითხვები შესახებ pseudocode?
რადგან რეალურად შერჩევა სახის უნდა ალბათ მოვა ერთ ერთი, კოდი,
pseudocode.
ასე რომ, რაიმე შეკითხვები ლოგიკა pseudocode?
გთხოვთ ახლა.
>> შერჩევის დალაგება - ხოლო სიაში არ არის მიზნით, ჩვენ ვაპირებთ გავლა
და იპოვოს პატარა ყოველ ჯერზე და დააყენოს ის წინ.
ასე რომ სანამ სიაში არის მწყობრიდან, სისტემაში ვინმეს მომეცი, რომ ხაზი კოდი, რომელიც
არ მომცა ხაზი კოდი არ არის, გთხოვთ?
ეს ჟღერს რა?
>> სტუდენტი: სწორედ ამისთვის loop.
>> JASON HIRSHHORN: ჟღერს მინდა ამისთვის loop.
OK, შეგიძლიათ მომეცი for loop?
იყიდება -
>> სტუდენტი: i უდრის 0.
>> JASON HIRSHHORN: i ან -
რას დაკარგული?
რა მიდის აქ?
>> სტუდენტი: Int.
>> JASON HIRSHHORN: ზუსტად.
(Int i = 0; -
>> სტუდენტი: i <n; i + +).
>> JASON HIRSHHORN: nailed იგი, Jeff.
ჩვენ ვაპირებთ მეშვეობით სიაში, უფლება?
ჩვენ ვნახეთ, რომ კოდი ადრე.
სრულყოფილი.
მოდით დააყენა ჩვენი curly აფრთხილებს აქ.
მე ვაპირებ დააყენა რამდენიმე curly აფრთხილებს აქ.
>> ასე რომ სანამ ეს 0, ჩვენ უნდა წავიდეთ მთელი სია.
ასე რომ, ყოველ ჯერზე ჩვენ გაიაროს სიაში, რა გვინდა ტრეკზე?
>> სტუდენტი: თუ რომელიმე სვოპების მზადდება.
>> JASON HIRSHHORN: მონახე ყველაზე პატარა ნომერი.
ამიტომ, ჩვენ, ალბათ ტრეკზე ყველაზე პატარა ნომერი, ყოველ ჯერზე.
ასე რომ ხაზი გავაკეთო ტრეკზე ყველაზე პატარა ნომერი?
Aleha, როგორ ვარჩინო სიმღერა რამე?
>> სტუდენტი: დაწყება ახალი ცვლადი.
>> JASON HIRSHHORN: დაწყება ახალი ცვლადი.
მოდით შევქმნათ ცვლადი.
რა სახის?
>> სტუდენტი: Int.
>> JASON HIRSHHORN: Int.
მოდით ეძახით პატარა.
და რას უდრის, როდესაც ჩვენ მხოლოდ დაწყებული გარეთ?
ჩვენ არ გაიარა სიაში არავის გაუკეთებია.
ჩვენ პირველი ნაწილი სიაში ჩვენი პირველი მეშვეობით.
რას თანასწორი, პატარა ნომერი?
>> სტუდენტი: ფასეულობები i.
>> JASON HIRSHHORN: ფასეულობები i.
რომ ჟღერს სწორედ, არა?
ყველაზე პატარა ნომერი დასაწყისში სადაც ჩვენ ვართ.
ასე რომ, ახლა ჩვენ გვაქვს ჩვენი პატარა, და ჩვენ გვჭირდება გავლა მთელი სია და
შევადარებთ ამ პატარა to ყველაფერი.
ასე რომ ჩვენ გაიაროს სიაში ისევ?
Michael?
>> სტუდენტი: თქვენ მოგიწევთ მეორე loop.
>> JASON HIRSHHORN: სხვა for loop.
მოდით გავაკეთოთ.
მომეცით კოდი.
>> სტუდენტი: For loop -
პატარა -
უბრალოდ int j, შეიძლება ვთქვა?
= 0; ისეთი, რომ -
>> JASON HIRSHHORN: ისე, თუ ჩვენ გვინდა, გავლა მთელი სია -
>> სტუდენტი: j <n, j + +).
>> JASON HIRSHHORN: Fantastic.
ჩვენ ვაპირებთ გავლა ამისთვის loop კიდევ ერთხელ.
და როგორ უნდა იპოვოს პატარა ნომერი?
ტომ?
ჩვენ მიმდინარე პატარა ნომერი, ან, ასე როგორ უნდა იპოვოს ახალი პატარა?
>> სტუდენტი: ჩვენ შეგვიძლია შევამოწმოთ, თუ პატარა ნომერი ჩვენ მეტია
აფასებს bracket კ.
>> JASON HIRSHHORN: ასე რომ, თუ პატარა არის უფრო მეტი, ვიდრე ღირებულებების bracket კ.
ასე რომ, თუ ჩვენი პატარა მეტია -
მე ვაპირებ გადაადგილება ამ ორ ხაზს კოდი არსებობს მეორე.
იმიტომ, რომ სანამ ჩვენ რაიმე შევცვალე, ჩვენ უნდა გაიაროს მთელი სია.
ასე რომ, ეს pseudocode რეალურად უნდა გარეთ რომ შიდა for loop.
ასე რომ წავიდეთ მთელი სია.
იმ შემთხვევაში, თუ პატარა მეტია ღირებულებები j მერე რა?
>> სტუდენტური მაშინ პატარა შეადგენს ღირებულებების კ.
>> JASON HIRSHHORN: Fantastic.
ერთი სწრაფი კითხვა -
პირველად ჩვენ გაიაროს ამ მარყუჟის, i აპირებს გაუტოლდება 0, j აპირებს
გაუტოლდება 0 ერთხელ მივიღებთ აქ.
ამიტომ, ჩვენ ვაპირებთ, რომ იყოს შედარებით ნომერი თავად.
ის არის, რომ ეფექტური?
არა, ეს ნამდვილად არ არის ეფექტური.
ასე რომ ჩვენი j უნდა წავიდეს 0 დან N თითოეული დროს?
ჩვენ ყოველთვის უნდა შეამოწმოს მთელი სია?
[INAUDIBLE]?
>> სტუდენტი: დაწყება i ნაცვლად.
>> JASON HIRSHHORN: j can დაიწყოს რა?
>> სტუდენტი: i.
>> JASON HIRSHHORN: j შეგიძლიათ i.
ახლა შევადარებთ დაწყებული ერთად ერთი ჩვენ შესახებ.
მაგრამ მაშინაც, არის ის, რომ, როგორც ეფექტური როგორც შესაძლებელი?
>> სტუდენტი: i + 1.
>> JASON HIRSHHORN: i + 1 როგორც ჩანს, ყველაზე ეფექტური, რადგან ჩვენ
უკვე i.
ჩვენ იმის შესახებ, რომ, როგორც პატარა ხაზი 15.
ჩვენ ვაპირებთ იწყება მომდევნო ერთი ავტომატურად.
ასე რომ, ჩვენ გაიაროს for loop.
ჩვენ გავლა ყოველ ჯერზე.
ჩვენ გავლა რაოდენობის ჯერ.
ახლა ჩვენ მიღებული მეშვეობით ამ შიდა for loop.
ჩვენ პატარა ღირებულება ზოგავს.
ჩვენ უნდა მოათავსოთ დასაწყისში სიაში.
ასე რომ, როგორ შემიძლია მოათავსოთ დასაწყისში სიაში?
რა არის ცვლადი, რომელიც ეხება დასაწყისში სიაში?
ჩვენ ამ გარეთ loop, ასე რომ ეხება
დასაწყისში სიაში?
>> სტუდენტი: ფასეულობები i.
>> JASON HIRSHHORN: ზუსტად უფლება.
ღირებულებები მე დასაწყისში -
ან sorry, არ დასაწყისში.
ეს იყო დამაბნეველი.
ეს არის სადაც ჩვენ ვართ დასაწყისში დაუხარისხებელი ნაწილი სიაში.
ასე აფასებს i.
და რა, რომ თანაბარი?
>> სტუდენტი: პატარა.
>> JASON HIRSHHORN: ფასეულობები i შეადგენს რა?
>> სტუდენტი: პატარა.
>> JASON HIRSHHORN: პატარა.
სწორედ.
ასე რომ ჩვენ დებს მას დასაწყისში სია, და ახლა ჩვენ უნდა დააყენოს
დასაწყისში სიაში, სადაც ყველაზე პატარა ნომერი იყო.
ასე რომ, როგორ ვწერ, სადაც პატარა ნომერი იყო?
ღირებულებები რა?
>> სტუდენტი: 0.
>> JASON HIRSHHORN: მცირე ნომერი არის 0?
>> სტუდენტი: Yeah.
>> JASON HIRSHHORN: რა მოხდება, თუ პატარა ნომერი დასასრულს
ამ დაუხარისხებელი სიაში?
>> სტუდენტი: უკაცრავად, რა იყო კითხვა?
>> JASON HIRSHHORN: სად არის ყველაზე პატარა ნომერი?
ჩვენ მივიღეთ პატარა და ამით იგი დასაწყისში, ამ ონლაინ უფლება აქ.
>> სტუდენტი: მას უნდა ჰქონდეს ინახება ზოგიერთი -
>> სტუდენტი: მნიშვნელობებია j.
>> JASON HIRSHHORN: ისე, ეს არ არის აუცილებელი, ფასეულობები კ.
ის კი არ არსებობს ამ ეტაპზე.
>> სტუდენტი: თქვენ უნდა განაცხადოს ცვლადი ადრე და
მაშინ მივანიჭოთ მას -
როდესაც თქვენ პატარა ნომერი, ან, დაავალოს მაჩვენებელი, რომ ნომერი
ზოგიერთი ცვლადის ან რამე მაგდაგვარს.
>> JASON HIRSHHORN: ასე რომ შეგიძლიათ თქვენ ამბობთ, რომ კიდევ ერთხელ?
>> სტუდენტი: ასე რომ, სადაც თქვენ განაცხადა int პატარა, თქვენ ასევე უნდა განაცხადოს int
პატარა index = i, ან რამე მაგდაგვარს.
>> JASON HIRSHHORN: ასე რომ, სადაც მე int პატარა, მე უნდა არა მხოლოდ ტრეკზე
ღირებულების, არამედ ადგილმდებარეობა.
int smallest_location = ამ შემთხვევაში, ჩვენ უბრალოდ i.
ჩვენ უნდა ვიცოდეთ, სადაც ის არის.
მივიღეთ ბოლოს კოდი, და ჩვენ მიხვდა, რომ ჩვენ კი არ ჰქონდათ, სადაც ეს იყო.
და ა.შ. კიდევ ერთხელ, ჩვენ რუკების ეს ერთ ერთი.
თქვენ ბიჭები კოდირების ეს თქვენი ნებით ალბათ იგივე პრობლემა.
როგორ heck მოვძებნო ეს?
და მაშინ ხვდები, დაველოდოთ, მე უნდა ტრეკზე რომ.
>> ასე რომ, თუ პატარა დიდია გარდა ღირებულებების კ.
ჩვენ დავსახეთ პატარა შეადგენს ღირებულებების კ.
რა გვჭირდება შეცვალოს?
Constantin, რა გავაკეთოთ ჩვენ უნდა შეცვალოს?
>> სტუდენტი: ადგილმდებარეობა.
>> JASON HIRSHHORN: ზუსტად.
ასე რომ მომეცი, რომ ხაზი კოდი.
>> სტუდენტი: smallest_location = კ.
>> JASON HIRSHHORN: ზუსტად.
და შემდეგ ქვევით ბოლოს, თუ გვინდა, რომ დააყენა დასაწყისში სიაში, სადაც
ყველაზე პატარა ნომერი, როგორ ჩვენ ეხება, სადაც
პატარა ნომერი იყო?
Marcus?
>> სტუდენტი: ყველაზე პატარა ნომერი მდებარეობს პატარა ადგილმდებარეობა.
>> JASON HIRSHHORN: ასე რომ, ფასეულობები smallest_location.
და რა ჩვენ იქ?
დასაწყისში სიაში, რა არის ეს?
>> სტუდენტი: ისე, ჩვენ ნამდვილად არ ვიცი აღარ რადგან ჩვენ overwrote.
ამიტომ swapped ადგილებში იმ ორ ხაზს?
თუ თქვენ გადახვიდეთ იმ ორი ხაზი გარშემო.
>> JASON HIRSHHORN: OK, ასე რომ, ჩვენ არ აღარ, იმიტომ, რომ ჩვენ გადატვირთვის ხაზი
ადრე ღირებულებების მე პატარა.
ასე რომ, ჩვენ დავკარგეთ, რომ თავდაპირველი ღირებულება.
ასე, რომ თქვენ განაცხადა swap ეს ორი ხაზი.
ახლა დააყენა დასაწყისში სიაში სადაც პატარა ნომერი იყო.
ასე smallest_location შეადგენს ღირებულებების i.
რომ მოძრავი დასაწყისში დაუხარისხებელი ნაწილი სია
პატარა ადგილმდებარეობა.
და შემდეგ შევიდა ღირებულებები i ჩვენ მოძრავი რომ პატარა ნომერი.
>> ამჯამად, რომ აზრი, ამიტომ ჩვენ უნდა გაეკეთებინათ, რომ swap?
ჩვენ არ გადაეწერება, რომ ღირებულება - კიდევ ერთი რამ, ალბათ, იქნებოდა
figured out და ნაპოვნი მშპ.
ამიტომ ჩვენ ზრუნვა ყველა pseudocode.
არსებობს არაფერი ჩვენ უნდა დაწეროთ აქ?
შეიძლება ვინმეს ვფიქრობ არაფერი?
>> სტუდენტი: როგორ იცით, როდესაც თქვენ გაკეთდეს?
>> JASON HIRSHHORN: როგორ გავაკეთოთ იცით, როდესაც ჩვენ გავაკეთეთ?
დიდი კითხვა.
ასე რომ, ვიცით, როდესაც ჩვენ გავაკეთეთ.
>> სტუდენტური შექმნა ცვლადი შენარჩუნება რაოდენობა , თუ არსებობს swap გააკეთა თუ არა
და გაიაროს უღელტეხილზე.
>> JASON HIRSHHORN: OK.
რომ მუშაობა bubble sort.
მაგრამ შერჩევის დალაგების, თუ ჩვენ არ მიიღოს swap, რომელიც შეიძლება იყოს
რადგან პატარა ღირებულება ეს უფლება ადგილმდებარეობა.
ჩვენ შეიძლება ჰქონდეს სიაში 1, 2, 4, 3.
მეორედ მეშვეობით ჩვენ არ გავაკეთებ გაცვლებს.
ჩვენ იქნება 2, მაგრამ ჩვენ მაინც უნდა შენარჩუნებას აპირებს.
ასე რომ ჩვენ უნდა ტრეკზე როცა ჩვენ გავაკეთეთ, ან ჩვენ უბრალოდ უნდათ
სანამ ეს დასრულდა?
>> სტუდენტი: ჩვენ შეგვიძლია უბრალოდ წასვლა სანამ ის დასრულდა.
>> JASON HIRSHHORN: ჩვენ შეგვიძლია მხოლოდ წავიდეთ, სანამ ეს დასრულდა.
In bubble sort, თქვენ სწორედ, Jeff და Aleha, თქვენი გადაწყვეტა -
ეს არის დიდი ტრეკზე რამდენი სვოპების თქვენ გააკეთა, რადგან bubble
სახის, თუ რეალურად არ გაცვლებს, თქვენ კეთდება და შეგიძლიათ იქნებ გაჭრა თქვენი
პრობლემა ქვემოთ bit.
მაგრამ შერჩევის დალაგების, თქვენ ნამდვილად მივიღე გაიაროს ბოლომდე
სიაში ყოველ ჯერზე გარშემო.
>> ასე რომ, ეს არის ის, რომ.
ჩვენ გვაქვს ორი წუთი დარჩა.
მოდით ყველა.
ნება მომეცით, უბრალოდ ღია მოძებნა აქ და დარწმუნებული ვარ, მე რეალურად მოუწოდებდა up -
მე არ მოუწოდებდა bubble sort.
მოდით შევცვალოთ ეს შერჩევა ჯიშია.
ყველა. / იპოვოს.
მოდით მოვძებნოთ 42.
ამ დროს ჩვენ ვაპირებთ გაივლის დაუხარისხებელი სიაში, რადგან ეს უნდა დასალაგებლად
პირველი, პოსტი იპოვოს კოდი - უნდა დასალაგებლად პირველი ჩვენი დალაგების ფუნქცია და შემდეგ
ვეძებთ რაიმე.
თითების გადმოკვეთა ყველას.
>> Oh ჩემი სიკეთე.
Whoa, ჩემი გული სცემდა.
ასე რომ, არის სწორი.
ფაქტობრივად, თუ ჩვენ გაიქცა ეს უფრო ინტენსიურად, კოდი, რამდენადაც შემიძლია
გითხრათ, სრულიად სწორი.
არსებობს წინადადებები მე თქვენთვის.
მაგალითად, 15 და 16 როგორც ჩანს, ცოტა გადაჭარბებული.
როგორც ჩანს, თქვენ არ ემთხვეოდეს უნდა გადავარჩინოთ, როგორც იმ.
თუ თქვენ გაქვთ პატარა ადგილმდებარეობა, თქვენ შეგიძლიათ ადვილად მოიძიებთ პატარა ღირებულება
უბრალოდ აკრეფით ღირებულებების i.
>> ასე რომ, თუ მე უნდა შეფასების თქვენი კოდი, რომელიც მე რეალურად იყოს, მინდა
სავარაუდოდ off წერტილი, თუ შედის ორივე, რადგან თქვენ
არ გვჭირდება ორივე.
თუ თქვენ გაქვთ განთავსების შეგიძლიათ ძალიან მარტივად მიიღოთ ღირებულება.
და როგორც ჩანს ცოტა უცნაურია შესანახად ორივე მათგანი.
იქნებ არც კი მიიღოს წერტილი, მაგრამ რა თქმა უნდა კომენტარს, რომ შესაძლოა
არ სტილისტური არჩევანი თქვენ უნდა მიიღოს.
რა თქმა უნდა, კოდი მაინც გადის კარგად.
>> ასე რომ, სამწუხაროდ, ჩვენ არ მიიღეთ ბუშტი ჯიშია.
მე ვწუხვარ, რომ.
ჩვენ გავაკეთეთ დასრულდება შერჩევა ჯიშია.
ვინმეს აქვს რაიმე საბოლოო შეკითხვები დაახლოებით შერჩევა ერთგვარი?
>> OK, სანამ ჩვენ უხელმძღვანელებს გარეთ, მინდა გახსნა თქვენი Chrome ბრაუზერში.
სამწუხაროდ, ეს იყო მხოლოდ უხეში plug ერთი ტიპის ინტერნეტ ბრაუზერი.
თქვენ შეგიძლიათ გახსნათ ნებისმიერი ბრაუზერი, მაგრამ ეს ალბათ Chrome.
და გადადით ამ შემდეგ ვებ -
sayat.me/cs50.
თუ თქვენ არ აკრეფით თქვენს კომპიუტერში ახლა, თქვენ ნათლად
არ ვაკეთებთ, ტომ.
>> და გთხოვთ, არც უფლება ახლა ან მომდევნო საათი -
მომეცი გარკვეული კავშირი.
ეს არის მხოლოდ მონაკვეთზე ორი.
ჩვენ კიდევ ბევრი რამ ერთად, ასე რომ, აქვს უამრავი ოთახი გაუმჯობესება.
მე იმედია ასევე გააკეთა ზოგიერთი რამ კარგად.
ასე რომ თქვენ შეუძლია მე ვგრძნობ ყველა ცუდი, მაგრამ თუ თქვენ ასევე მინდა მომეცი smiley
სახე, მე ვაფასებ რომ ისევე.
შეავსეთ რომ სისტემაში
>> და ერთი წუთი დარჩა, რომ იყო კვირაში სამი.
მე გარეთ დგანან ცოტა თუ თქვენ გაქვთ რაიმე შეკითხვებს.
მე ვხედავ, რომ თქვენ ბიჭები ლექცია ხვალ.