[Powered by Google Translate] [ნაწილი 3] [Less კომფორტული]
>> [Nate Hardison] [ჰარვარდის უნივერსიტეტის]
>> [ეს არის CS50.] [CS50.TV]
>> ყველა უფლება, მოდით დავიწყოთ.
კეთილი იყოს კვირა 4 of CS50.
თუ ბიჭები გახსენით ბრაუზერი და გახსენით pset 3,
Scramble ერთად CS50, ჩვენ ვაპირებთ დავიწყოთ აპირებს
მეშვეობით მონაკვეთზე კითხვები არსებობს.
ისევე, როგორც გასულ კვირას, ჩვენ უნდა მომუშავე CS50 სივრცეები,
თუ თქვენ ასევე გაიყვანოს, რომ ისევე,
და თუ წავიდეთ წინ და ეწვევა ამ ბმულს, რომ მაქვს აქ ზედა.
დროა დავიწყოთ.
გვაქვს ჩვენი პატარა hi პროგრამა აქ. არაფერი გიჟები.
ერთი პირველი რამ მინდა ვუყოთ შენ დღეს წავიდეთ მეტი რამდენიმე გადაწყვეტილებები
რათა პრობლემა Set 1, სახის მაგალითად გადაწყვეტილებები,
უბრალოდ, ასე რომ თქვენ შეგიძლიათ მიიღოთ შეგრძნებას, თუ რა სახის კოდი პერსონალის წერს,
რა სახის კოდი სხვა სტუდენტებს წერის,
და თქვენ შეხედეთ, რადგან ვიცი, რომ ეს უცნაური
როდესაც თქვენ წარმოადგინოს გადაწყვეტა პრობლემა კომპლექტი და კიდევ კომენტარი
საკუთარ ვერსია, მაგრამ ზოგჯერ ეს სასარგებლოა, თუ რამდენად სხვა ხალხი ეს,
განსაკუთრებით ვინც კი კარგია ეძებს.
უმეტესწილად, მე ნამდვილად შთაბეჭდილება მოახდინა გადაწყვეტილებები, რომ თქვენ ბიჭები წარმოებული.
მე ჯერ არ დაწყებულა ეძებს თქვენი პრობლემა Set 2S, მაგრამ თუ ისინი არაფერი პირველი,
ეს არაფერს ნიშნავს, მაგრამ კარგი რამ.
>> თუ გადავხედავთ ჩემი ვერსიებიდან, დავიწყოთ ყველა გზა ქვემოთ ცვლილებათა 1,
და ჩვენ ვაპირებთ მიიღოს სწრაფი შევხედოთ Mario გადაწყვეტა.
თუ თქვენ დახევის ეს ყველაფერი, ამ პროგრამების, რომ ჩვენ ვაპირებთ წარმოადგინოს სწორია.
არ იყო კორექტულობის საკითხებთან ერთად ეს პრობლემები, არამედ,
ჩვენ გვინდა გაიგო ცოტა შესახებ სხვადასხვა დიზაინის საკითხებზე
რომლებიც გამოიყენება აქ.
ერთი რამ, რომ იყო საინტერესო შესახებ გადაწყვეტა
არის ის, რომ ეს გამოიყენეს ახალი შენება მოუწოდა ფუნტი განსაზღვრა,
ზოგჯერ ასევე შეეხო როგორც hash განსაზღვრავს.
ნება მომეცით მიუახლოვდით აქ.
# განსაზღვრავს გაძლევთ საშუალებას მისცემს სახელები ამ ნომრებზე თქვენს პროგრამას.
ამ შემთხვევაში, მაქსიმალური სიმაღლე პირამიდის in Mario
იყო 23 და ვიდრე აყენებს 23 ჩემი კოდი-
ჩვენ ეხება, რომ როგორც მძიმე კოდირებას 23 -
ნაცვლად ამ აძლევს სახელი MAX_HEIGHT რომ ნომერი,
ასე რომ ქვევით აქ ჩემი do-ხოლო loop
შეგიძლიათ რეალურად ეხება MAX_HEIGHT
ნაცვლად გამოსული ხმების 23 შემოსული
[სტუდენტური] რა არის უპირატესობა კეთების რომ?
სწორედ დიდი კითხვაზე.
ერთი არის readability.
უპირატესობა გამოყენებისას # განსაზღვროს არის readability.
როდესაც მე კითხულობს ამ კოდექსის მე ვხედავ რა ხდება.
>> მე ვხედავ ამ მდგომარეობის აქ რომ ჩვენ ტესტირების
ამისთვის სიმაღლე მყოფი <0, რომელიც ჩვენ შეგვიძლია ასევე განისაზღვრა
უნდა იყოს მინიმალური სიმაღლე ან min სიმაღლე.
სხვა უპირატესობა არის ის, რომ მე შეიძლება მაშინ წაიკითხა დანარჩენი ხაზის ვიხილოთ
რომ ჩვენ ასევე შემოწმების დავრწმუნდეთ, რომ სიმაღლე არ არის მეტია მაქსიმალური სიმაღლე,
იმიტომ, რომ ჩვენ ვაპირებთ გავაგრძელოთ ხოლო სიმაღლე მეტია მაქსიმალური სიმაღლე.
სხვა უპირატესობა თუ მე დააშორებს ცოტა აქ-
თუ აწარმოებს ამ პროგრამის და მე გაუშვით, თქმით, 23 სწორედ ახლა,
იგი ამობეჭდოთ ყველა 23 რიგები ისევე რომ.
მაგრამ აცხადებენ მინდოდა შეცვლის მაქსიმალური სიმაღლე,
და ახლა მინდა ზღუდავს მაქსიმალური სიმაღლე პირამიდების
უნდა იყოს მხოლოდ ამბობენ-man, რომ იყო ხმაურიანი.
# Include , # define MAX_HEIGHT,
და ვთქვათ გვინდოდა დააყენეთ ტოლია 10.
ახლა ამ ეტაპზე, ყველა მე უნდა გაეკეთებინათ იყო შეცვლის ამ ერთ ადგილას.
შემიძლია recompile კოდი, და ახლა თუ მე ვცდილობ და აკრიფოთ 12,
მას შეეკითხება მომეცით კიდევ ერთხელ.
ამ შემთხვევაში, ჩვენ მხოლოდ გამოყენებით MAX_HEIGHT ერთხელ.
ეს არ არის, რომ დიდი hassle წავიდეთ
და შეცვალოს იგი ხოლო loop თუ საჭიროა.
მაგრამ სადაც თქვენ referencing იგივე ჯადოსნური ნომერი
უსასრულოდ, ეს # განსაზღვრავს მექანიზმი მართლაც მოსახერხებელი
იმიტომ, რომ თქვენ მხოლოდ შეცვლის ერთ დროს ზედა file-ის, როგორც წესი, სადაც თქვენ დააყენა მათ-
და ენის percolates მეშვეობით დანარჩენი ფაილი.
>> სხვა რამ მინდოდა აღვნიშნო ამ დავალების რომ მეგონა ჩანდა მართლაც კარგია,
ერთი იყო ნეიმინგი of ცვლადები.
ხედავთ აქ რომ გვაქვს მთელი ცვლადები ეწოდება გრაფაში და ე.წ. სიმაღლე.
სივრცეები, ჰეშები, ის ეხმარება მიიღოს კოდი ცოტა მეტი იკითხება,
ხდის უფრო გასაგები რა რეალურად მიმდინარეობს.
ეს არის განსხვავებით გამოყენებით, ვთქვათ, შემთხვევითი ასოები
ან უბრალოდ gobbledygook საერთოდ.
საბოლოო რამ მე აღვნიშნო, რომ ამისთვის მარყუჟების,
ხშირად ამ iterator ცვლადები, ეს მრიცხველები, რომ გამოიყენოთ თქვენი ამისთვის მარყუჟების,
ეს სტანდარტი და ჩვეულებრივი უნდა დაიწყოს მათ არც მე და შემდეგ კ და მერე K
და მიმდინარეობს იქიდან თუ გჭირდებათ მეტი ცვლადის,
და ეს მხოლოდ კონვენციას.
უამრავი კონვენციებს.
ეს დამოკიდებულია პროგრამირების ენა თქვენ იყენებთ.
მაგრამ C, ჩვენ, როგორც წესი, იწყება მე.
ეს არ აქვს აზრი გამოიყენოს, ვთქვათ, ან ბ
დამოკიდებულია სიტუაცია.
ეს არის ის ამ ერთ.
თუ თქვენ ახლა დახევის up ცვლილებათა 2, დაინახავთ სხვა Mario,
და ეს ერთი არის მსგავსი მეორე, რომ ჩვენ უბრალოდ დაინახა,
მაგრამ ჯერ რაღაც სახის cool.
თუ დავაკვირდებით ამ სექციაში უფლება აქ შიგნით შიდა ამისთვის მარყუჟის,
ისინი გამოყენებით ზოგიერთი გიჟები ეძებს სინტაქსი აქ უფლება ამ მხრივაც.
ამას უწოდებენ ternary ოპერატორს.
ეს თუ სხვაგან განაცხადი შემოკლება ერთ ხაზი.
მდგომარეობა არის ამ ნაწილის ფარგლებში ფრჩხილებში.
ეს ექვივალენტურია ამბობდა თუ j <სიმაღლე - I - 1.
და მაშინ რა შინაარსი, რომ თუ ბლოკი იქნება არიან სივრცეში
და შემდეგ შინაარსი რა სხვაგან იქნება არიან ამ #.
ეს არსებითად მინიჭების სივრცეში ამ ცვლადში.
ეს აყენებს სივრცეში შინაარსი ბლოკი ცვლადი,
თუ ეს მდგომარეობა დაკმაყოფილებულია და, თუ მდგომარეობა არ შეხვდა,
მაშინ ბლოკის ცვლადი იღებს ამ #.
და მაშინ, რა თქმა უნდა, ნაცვლად მშენებლობა მთელი სიმებიანი
და ბეჭდვა ყველაფერს დასასრულს ამ გადაწყვეტა ბეჭდავს მას ერთი ხასიათი დროს.
Pretty cool.
>> კიდევ ერთი წყვილი რამ შევხედოთ. ჩვენ გადაადგილება უნდა ხარბ.
ახლა თუ შევხედავთ ხარბ, ამ პირველი გადაწყვეტა
იყენებს ამ # განსაზღვრავს საკმაოდ მწირი.
გვაქვს ერთი მუდმივი განსაზღვრული თითოეული სხვადასხვა ციფრები ამ პროგრამაში.
გვაქვს ერთი ცენტი თითო დოლარი, ერთი მეოთხედი, dimes, nickels და pennies,
და ახლა თუ ჩვენ გადახვევა down და წაიკითხა კოდი,
ვხედავთ სტანდარტული do-ხოლო loop ბეჭდვის ყველაფერს.
სახის Crux ამ პრობლემის იყო იმაში, რომ
თქვენ საჭირო კონვერტირება float, რომ თქვენ წაიკითხოთ საწყისი მომხმარებელს მთელი რიცხვი
ზუსტად გავაკეთოთ მათემატიკის, და ეს იმიტომ
ერთად მცურავი პუნქტიანი ნომრები, როგორც ჩვენ ვისაუბრეთ ლექციების მოკლედ,
ეს შეუძლებელია ზუსტად წარმოადგენენ თითოეული ღირებულება ხმების ხაზი
რადგან არსებობს უსასრულოდ ბევრი ღირებულებების შორის 3 და, ვთქვათ, 3.1 კი.
თქვენ შეგიძლიათ 3,01 და 3,001 და 3,0001, და შეგიძლიათ შეინახოთ აპირებს.
თურმე როდესაც თქვენ მუშაობა ფული, თქვენ ხშირად აკონვერტირებთ ეს
შევიდა მთელი ფორმატში ასე რომ თქვენ არ კარგავს pennies და რომ მსგავსი საქმიანობები.
Doing რომ და დამრგვალება იყო გასაღები.
ეს გადაწყვეტილება გამოიყენა შესანიშნავად პირდაპირი, დიდი ალგორითმი,
რაც decremented ხმების ცენტი დარჩენილი, პირველი მიერ კვარტლები,
შემდეგ dimes, შემდეგ nickels, შემდეგ pennies,
და დასძინა, რომ რაოდენობის მონეტები ყოველ ჯერზე.
>> კიდევ ერთი გამოსავალი, რომ ჩვენ დავინახავთ, როგორც მე დააშორებს და წასვლა ცვლილებათა 4,
ჰქონდა ძალიან ჰგავს დასაწყისში არამედ გამოიყენება div და mod
უფლება მეტი აქ გამოთვლა ხმების ცენტი.
ეს, რაოდენობის მეოთხედი უდრის ხმების ცენტი იყოფა 25,
და მიზეზი ამ მუშაობს იმიტომ ვაკეთებთ მთელი განყოფილება,
ამიტომ discarding ნებისმიერი ნაშთი.
[სტუდენტური] გვაქვს კომენტარზე ძებნა?
ეს მართლაც დამოკიდებული.
[სტუდენტური] თქვენ კომენტირებისას ზე მეტი კოდი უფლება აქ.
ჰო, და ა.შ. არსებობს bunch სხვადასხვა ფილოსოფიებს ამ.
ჩემი პირადი ფილოსოფია არის ის, რომ თქვენი კოდი მართლაც სიმართლეს,
მოსწონს თქვენი კოდი არის ის, რაც სინამდვილეში შესრულებაში კომპიუტერზე,
და ასე რომ თქვენი კოდი უნდა იყოს, როგორც იკითხება როგორც შესაძლებელი არ საჭიროებს როგორც ბევრი კომენტარი.
რომ განაცხადა, როდესაც თქვენ აკეთებთ რამ, რომლებიც სახის სახიფათო მათემატიკურად
ან algorithmically, კარგია კომენტარის იმ ასე რომ თქვენ შეგიძლიათ
დაამატოთ დამატებითი განზომილება, ზედმეტი შრე ვინც კითხულობს თქვენს კოდი.
ამ გადაწყვეტილებების, ხშირად ისინი კომენტარი მეტი მძიმედ მხოლოდ იმიტომ
ჩვენ გვინდა, რომ სწრაფად გავრცელება მათ და აქვს ხალხს აირჩიოთ მათ up
და წაიკითხეთ მათ საკმაოდ ადვილად.
მაგრამ ნამდვილად, მე თანახმა რომ ეს არის მძიმე.
[სტუდენტური] მაგრამ როდესაც ეჭვი, წასვლა მძიმე?
როდესაც ეჭვი, წასვლა მძიმე.
ზოგიერთი ადამიანი იქნება ხანდახან ამბობენ დაბრუნების 0 ან რამე მაგდაგვარს.
მიმაჩნია, რომ ეს სასაცილოა კომენტარი.
ცხადია, რომ ის, რაც ხდება.
მე არ გვჭირდება ინგლისური მითხრა, რომ.
ზოგჯერ ადამიანი დაწერს პერსონალის როგორიცაა "kthxbai!"
სწორედ სახის cute არამედ არ-
ეს არ არის სწორი განსხვავება შორის კომენტირებისას რაოდენობა თუ არა.
იმ სახის კომენტარი უბრალოდ ჰა, ჰა.
ზემოთ.
>> ამ ეტაპზე, დავიწყოთ მუშაობა პრობლემა უცნობია 3 მონაკვეთზე კითხვები.
თუ ბიჭები დახევის ეს ყველაფერი ისევ და ისევ,
როგორც გასულ კვირას, ჩვენ არ ვაპირებთ, რომ უყუროთ შორტები ამ სექციაში.
ჩვენ მოგცემთ ბიჭებს რომ საკუთარ დროს და ვისაუბროთ კითხვები.
მაგრამ ახლა ამ სექციაში ჩვენ ვაპირებთ გაატაროთ ცოტა მეტი დრო
ვსაუბრობთ ნაკლები კოდირების საფუძვლები
ისე, როგორც გასულ კვირას, და ამის ნაცვლად, ჩვენ ვაპირებთ ფოკუსირება უფრო
ცოტა უფრო თეორიულად, ისე ვსაუბრობთ ორობითი ძებნა და შემდეგ დახარისხება.
იმ, ვინც უკვე შემდეგ ერთად ლექცია,
შეიძლება ვინმეს მომეცით recap, თუ რა განსხვავება არის
შორის ბინარული ძებნის და ხაზოვანი ძებნა?
რა ხდება? დარწმუნებული.
ხაზოვანი ძებნა ეძებს მეშვეობით ყოველ ელემენტს დახარისხებული სია
ერთი ერთი ერთი ერთი,
და ბინარული ძებნა ყოფს სიაში შევიდა 2 ჯგუფები,
ამოწმებს თუ გასაღებები ღირებულება, რომ თქვენ ეძებს მეტია ან ნაკლებია, ვიდრე შუაში ღირებულება
რომ თქვენ მხოლოდ ი, და თუ ნაკლები, ეს მიდის ერთად ქვედა სიაში
და მაშინ ყოფს, რომ ერთხელ, იგივეს ფუნქცია
ყველა გზა ქვემოთ, სანამ ის პოულობს შუაში უნდა იყოს ტოლი ღირებულების თავად.
მარჯვენა.
>> რატომ აღელვებს?
რატომ ვსაუბრობთ ორობითი ძებნა წინააღმდეგ ხაზოვანი ძებნა?
Yeah.
ორობითი არის ბევრი უფრო სწრაფად, ასე რომ, თუ თქვენ გაორმაგება ზომა პრობლემა
სჭირდება კიდევ ერთი ნაბიჯია, ვიდრე ორჯერ მეტი.
სწორედ.
სწორედ დიდი პასუხი.
ხაზოვანი ძებნა ძალიანაა შემოწმების ერთ ელემენტს დროს,
და როგორც ვნახეთ წლის პირველივე დღიდან ლექცია
როდესაც დავით გაიარა მისი სატელეფონო წიგნი მაგალითად
და ამოღებული ერთი გვერდი სატელეფონო წიგნაკი დროს
და ინახება აკეთებს, რომ მეტი და უსასრულოდ,
ის აპირებს მას მართლაც ხანგრძლივი დრო, რათა იპოვოს ვინმეს ტელეფონის წიგნი,
თუ არ, რა თქმა უნდა, ის ეძებდა ვინმეს ზუსტად იმ დასაწყისში ანბანი.
ერთად ორობითი ძებნა, შეგიძლიათ ბევრი უფრო სწრაფად,
და ეს არ არის მხოლოდ ორჯერ სწრაფად ან 3 ჯერ სწრაფად ან 4 ჯერ სწრაფად.
მაგრამ პრობლემა იღებს პატარა და პატარა და პატარა ბევრად უფრო სწრაფად.
საილუსტრაციოდ, ჩვენ დავიწყებთ საუბარს, რა ხდება
როდესაც ჩვენ წერენ ორობითი ძებნა.
პრობლემის მხრივ არის, რომ თუ მაქვს მასივი ნომრები,
ამბობენ, 1, 2, 3, 5, 7, 23, 45, 78, 12323,
და შემდეგ 9 ერთად ტონა 0S მას შემდეგ,
ჩვენ გვინდა, რომ სწრაფად გაერკვნენ მართლაც სწრაფად რა არის
ამ მასივი ნომრები.
მე ვიცი ეს, როგორც ჩანს, ცოტა სულელური და ცოტა contrived,
რადგან ახლა ეს.
ჩვენ გვყავს მასივი, რომ არ გააჩნია ძალიან ბევრი ელემენტები მასში,
და თუ ვთხოვ ერთი თქვენ უნდა გაერკვნენ თუ არა
23 არის მასივი, შეგიძლიათ გააკეთოთ, რომ საკმაოდ სწრაფად
მხოლოდ glancing ამ და მეუბნებოდა დიახ ან არა.
ანალოგური განიხილოს არის წარმოიდგინეთ, თუ ამ იყო, ვთქვათ,
Excel-თან 10,000 რიგები, 20,000 რიგები.
რა თქმა უნდა, შეგიძლიათ გააკეთოთ ბრძანება F ან კონტროლის F და მოუთმენლად up რაღაც.
თქვენ ასევე შეგიძლიათ გამოიყენოთ ფილტრები და ძებნა პერსონალის,
მაგრამ თუ ჰქონდა გაეცნონ რომ ფაილი ხაზის მიერ ხაზს,
დასჭირდება თქვენ დიდი ხნის საპოვნელად.
ეს სახის როგორიცაა სატელეფონო წიგნი მაგალითად, ძალიან, სადაც
არავინ გამოიყურება მეშვეობით სატელეფონო წიგნი ერთ გვერდზე დროს.
როგორც წესი, ისინი გახსნა მას ახლო,
ან იმ შემთხვევაში, თუ ბევრი ტელეფონი წიგნები და ლექსიკონები სადაც
თქვენ ნამდვილად არ ეს keyed პირველ წერილში,
თქვენ Flip რომ პირველი ასო და გახსნას და დაიწყოს გადის იქ.
>> მაგონებს შენი სახელის ერთხელ. >> სემ.
სემ.
Like სემ განაცხადა, რომ ხაზოვანი ძებნა პროცესი იქნება ნამდვილად ნელი,
და ნაცვლად ერთად ორობითი ძებნა, გზა ამ სამუშაოების არის, რომ
ყოველ ჯერზე ჩვენ გაიაროს iteration ჩვენი ძებნას ალგორითმი,
ჩვენ ვაპირებთ დაყოფის სია ნახევარ, არსებითად,
ორ პატარა სიები.
და მერე შემდეგი iteration of მარყუჟის, ჩვენ გაყოფა კიდევ ერთხელ
სხვა პატარა სიები.
როგორც ხედავთ, პრობლემა ნიშანდობლივია მიღების პატარა და პატარა
იმიტომ, რომ ჩვენ შევინარჩუნოთ discarding ნახევარში სიაში თითოეული დრო.
როგორ აკეთებს ამას გაუქმება მუშაობს?
ისევე, როგორც შეხსენება, რაც ჩვენ ვაპირებთ, თუ ჩვენ ვიყავით კომპიუტერი
და ჩვენ, ვთქვათ, ეძებს ნომერი 5 ამ სიაში
არის, რომ ჩვენ აირჩიოთ ხმების შუა.
შუა ამ სიაში, რადგან არსებობს 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ნომერი,
ჩვენ გვინდა აირჩიოთ ნომერი ან მე -4 პოზიცია ან მე -5 პოზიცია,
და ჩვენ გვინდა, რომ მოვუწოდებთ შუა ჩვენს სიაში.
Pick ნომერი შუა.
მაშინ, ისევე, როგორც სემ განაცხადა, ჩვენ შეამოწმოთ თუ ეს რიცხვი უდრის
ნომერზე, რომ ჩვენ გვინდა ან ჩვენი სასურველი ნომერი.
თუ ეს თანაბარი, მაშინ ჩვენ ვერ. ჩვენ გავიმარჯვებთ.
თუ ეს არ თანაბარი, მაშინ არსებობს რამდენიმე შემთხვევა.
ორი შემთხვევა ან ნომერი უნდა იყოს მეტი რაოდენობის ჩვენ შევხედავთ,
ან ეს ნაკლები.
თუ ეს უფრო დიდი, ჩვენ გადავა უფლება.
და თუ ის ნაკლებია, ჩვენ გადავა მარცხნივ.
და შემდეგ ჩვენ ვიმეორებ მთელი პროცესი კვლავ
ორივე მარჯვენა ნახევარში ან მარცხენა ნახევარი სიაში.
>> პირველი პრობლემა დღევანდელ მონაკვეთზე არის გაერკვნენ
როგორ შეგვიძლია რეალურად დაიწყოს გამოხატოს ეს C კოდი.
გვაქვს pseudocode აქ.
რა დავიწყებთ ჩანაფიქრია მე დახევის up ახალ სივრცეში,
შეინახეთ ამ გადასინჯვის ისე, რომ ჩვენ გვაქვს ეს შენიშვნები, მოგვიანებით,
ჩვენ წაშლა ამ ყველაფრისა, და შემდეგ დააკოპირეთ და ჩასვით საწყისი პრობლემა კომპლექტი
ამ ინფორმაციას ჩვენს ფართების, და იმედია ეს არ დაარღვიოს.
Perfect.
თუ ბიჭები ყველა ამისათვის, და ჩასვით ეს კოდი თქვენს ახალ სივრცეში,
შევიდა ცარიელი ერთი.
მოდით ვეცადოთ დანიელ. თუ კომპილაციის და აწარმოებს ამ პროგრამის მუშაობს იგი?
პოსტები >> რა არის ის ამბობდა?
განცხადებაში ნათქვამია კონტროლის აღწევს ბოლოს არასამთავრობო ბათილად ფუნქცია.
Yeah, ნება მომეცით, ვცდილობთ გაშვებული იგი.
თქვენ ბიჭები მინახავს ამ ადრე? იცით რას ნიშნავს?
Okay, მოდით dissect ამ ცოტა.
ის ამბობდა საათზე file.c on line 9, სვეტი 1 გვაქვს შეცდომა, ისევე, როგორც თქვენ განაცხადა,
და ნათქვამია, რომ ეს გამომდინარე შეცდომა გაფრთხილება და დაბრუნების ტიპის გაფრთხილება.
როგორც ჩანს რაღაც მიმდინარეობს დაბრუნების ტიპის, რომელიც აზრი.
გვაქვს არასამთავრობო ბათილად ფუნქცია, რაც იმას ნიშნავს, რომ ჩვენ მივიღეთ ფუნქცია
რომ არ დააბრუნებს ბათილად.
ბათილად ფუნქცია, რომელიც ასე გამოიყურება:
ბათილად foo (), და ეს იმიტომ, რომ ბათილად დაბრუნების ტიპის ბათილად,
რაც იმას ნიშნავს, რომ თუ ჩვენ გვქონდა რაღაც აქ
მოსწონს დაბრუნების 1 ჩვენ ავღნიშნო კიდევ შემდგენელი შეცდომა ამ.
თუმცა, ჩვენ გვაქვს არასამთავრობო ბათილად ფუნქცია.
ჩვენი არასამთავრობო ბათილად ფუნქცია ამ შემთხვევაში არის ჩვენი ძებნის ფუნქცია
რადგან მას დაბრუნების გაცნობის bool.
როცა ეს რომ კონტროლის ბოლოს მიაღწევს არასამთავრობო ბათილად ფუნქცია,
ეს იმიტომ, რომ ძებნა არ აქვს დაბრუნების განაცხადი.
ეს არ დაბრუნების არაფერი ტიპის bool.
>> ჩვენ შეგვიძლია დაფიქსირება, რომ, და რას ვფიქრობ ბიჭები
ძებნა უნდა დაუბრუნდეს იყოს?
რა უნდა იყოს ნაგულისხმევი დაბრუნების ღირებულება ძებნა?
იმიტომ რომ ის, რაც ჩვენ შეგვიძლია დააყენა დასასრულს.
Charlotte, გაქვთ რაიმე-?
True ან ყალბი? >> True ან ყალბი.
რომელი?
ყალბი. მე არ ვიცი.
ყალბი? მოდით ცდილობენ.
რატომ ამბობენ დაბრუნების ყალბი? სწორედ დიდი ინტუიცია.
[Charlotte] არ ვიცი.
ჩვენ ვაპირებთ დაბრუნებას ცრუ ამ შემთხვევაში, რადგან ეს იქნება ჩვენი რა
თუ რაიმე მიზეზით სია ცარიელია ან ნემსი
რომ ჩვენ ვეძებთ არ არსებობს.
შემდეგ კი ბოლომდე, თუ არ იქნება TRUE ადრე ამ ფუნქციას,
ჩვენ ყოველთვის ვიცით, რომ ამ ფუნქციის იტყვის nope, ეს არ მასივი.
ეს არ haystack.
ახლა თუ ჩვენ კომპილირდება და გაუშვით-ნება მომეცით გადარჩენა ამ ასე შეგვიძლია დახევის it up.
ახლა თუ ჩვენ კომპილირდება და აწარმოებს ჩვენი პროგრამა, იგი აშენებს.
მივიღებთ ჩვენი პატარა ზოლზე.
თუ მე მოხვდა 4-uh-oh.
ეს არ ბეჭდვა არაფერს. როგორც ჩანს ყველაფერი დასრულდა okay.
გვაქვს შევსება ამ სისტემაში
ჩვენ ვისაუბრეთ ალგორითმს pseudocode ცოტა წინ.
ნება მომეცით ვხედავ, გარდა ამისა,
და მე გაიყვანოს, რომ ალგორითმი უკან კვლავ.
მოდით მოხვდა ამ ბიჭს. Nope.
არსებობს ეს.
როგორ გავაკეთოთ ეს?
რა იქნება კარგი სტრატეგია დაწყებული off ეს კოდი?
თქვენ უნდა აირჩიოთ ხმების შუა.
როგორ უნდა შეარჩიო ხმების შუა მასივი?
რაიმე შემოთავაზება?
[სტუდენტური] Strlen იყოფა 2.
Strlen იყოფა 2. სწორედ დიდი ერთი.
Strlen სამუშაოები სპეციალური სახის მასივები.
რა სახის კოლექტორები?
სიმებიანი მასივები, ხასიათი მასივები.
ეს რომ იგივე სახის კონცეფცია რომ ჩვენ გვინდა მივმართოთ,
მაგრამ ჩვენ არ შეგვიძლია გამოვიყენოთ strlen რადგან ჩვენ არ გვაქვს მასივი სიმბოლო.
ჩვენ გვყავს მასივი ints.
მაგრამ რას strlen მიიღოს ჩვენთვის?
იცით, რა იგი იღებს ჩვენთვის?
[სტუდენტური] Strlen იღებს us სიგრძე.
სწორედ, იგი იღებს us სიგრძე.
Strlen იღებს სიგრძეზე მასივი ჩვენთვის.
>> როგორ მივიღებთ რომ ჩვენი ორობითი ძებნა პროგრამაში?
როგორ მიიღოთ სიგრძეზე მასივი?
[სტუდენტური] Strlen?
თქვენ შეგიძლიათ სიგრძეზე სწორად დაფორმატებული C სიმებიანი მასივში strlen.
პრობლემა, თუმცა, ის არის, რომ ჩვენ არ გვაქვს სიმებიანი მასივი.
თუ ჩვენ ვიხსენებთ ამ კოდექსით, ჩვენ გვაქვს ამ მთელ რიცხვს მასივი.
როგორ ვიცით რამდენი ხანი არის?
[სტუდენტური] არის ეკვივალენტი ერთი Endpoint, როგორიცაა int ლ ან რაღაც?
თურმე იქ ფაქტობრივად არ არის და ისე სხვათა შორის, ეს არის
ერთი იმ რამ, რომ უბრალოდ კარგი იცოდეთ C,
რომ არ არსებობს გზა სიგრძეზე მასივი
თუ ყველა მე გაძლევთ არის მასივი.
მიზეზი ის მუშაობს სიმები, მიზეზი strlen სამუშაოები,
არის, რადგან თუ სტრიქონს სწორად დაფორმატებული,
მას ეყოლება განსაკუთრებული \ 0 ხასიათი დროს ბოლომდე.
>> თქვენ ასევე შეგიძლიათ წარმოიდგინოთ თუ არასათანადოდ ფორმატირებული სიმებიანი
და არ არსებობს \ 0 ხასიათი არსებობს, მაშინ მთელი რამ არ მუშაობს.
[სტუდენტური] შეგიძლიათ დაამატოთ \ 0?
ჩვენ შეგვეძლო ამ შემთხვევაში.
ჩვენ შეგვეძლო დაამატოთ გარკვეული \ 0
ან გარკვეული signifying ხასიათი და შემდეგ გამოიყენოთ, რომ.
მაგრამ ეს არ არის საკმაოდ იმუშავებს
რადგან \ 0 არის char ტიპის,
და აქ გვაქვს ints.
სხვა რამ არის, თუ ჩვენ უნდა გამოვიყენოთ სპეციალური ღირებულება
მოსწონს -1 აღსანიშნავად ბოლოს მასივი
მაშინ ჩვენ ვერასოდეს შესანახად -1 ჩვენი რიცხვი მასივები.
მე მინდა დავრჩებოდით.
თურმე ერთადერთი გზა მიიღოს სიგრძე
საქართველოს მასივი დო არის რეალურად მახსოვს
როდესაც თქვენ დააყენეთ მდე და შემდეგ გაიაროს ეს გარშემო მასივი
ასე რომ როდესაც მე ფუნქცია რომ აპირებს დაკავდით მუშაობა
on მასივი რიცხვებით ან მოძრავი ან ორჯერ ან რა,
მე ასევე უნდა მივცეთ ფუნქცია მასივი ს სიგრძე,
და სწორედ ის, რაც ჩვენ გავაკეთეთ აქ ძებნა ფუნქცია.
თუ გადავხედავთ, რაც ჩვენ გავაკეთეთ, როდესაც ჩვენ გავლა ჩვენს მასივი აქ,
ჩვენ ასევე კორიდორი სიგრძე, ზომა.
უბრალოდ ხდება, რომ ჩვენ მოუწოდა ამ ცვლადის აქ,
ეს პარამეტრი ან არგუმენტი.
ეს ეწოდება ფუნქციის არგუმენტი სიაში ან პარამეტრის სია,
და ეს ასევე მოუწოდა არგუმენტები ან პარამეტრებს.
ხალხი გამოიყენოთ სხვადასხვა პირობებით სხვადასხვა დროს.
მე ზოგჯერ ცვლა მათ თავს.
ეს უბრალოდ ისე ხდება, რომ ეს ცვლადი აქ არის დასახელებული ანალოგიურად
ამ # განსაზღვროს აქ.
მაგრამ ისინი არ იმავეს.
კაპიტალიზაცია არ აქვს მნიშვნელობა.
>> თუ გადავხედავთ რა ხდება აქ, ვაცხადებთ
ჩვენი int array, რომელიც ჩვენ მოუწოდა ნომრები.
ჩვენ მოცემული ეს ჩვენი ზომა, რაც შეესაბამება ჩვენი # განსაზღვრავს up ზედა.
ეს იქნება 8.
და მაშინ, როდესაც ჩვენ მაშინ მოვუწოდებთ ჩვენს ძებნა ფუნქციის ქვემოთ ქვემოთ
ჩვენ კორიდორი ნომერი გვინდა მოძებნოთ, რომელიც ჩვენ აიძულა,
მიღებული საწყისი მომხმარებელს.
ჩვენ კორიდორი მასივი, ამ ნომრებზე,
და მაშინ ჩვენ ასევე უნდა გაიარონ in ზომა მასივი,
და მაშინ ღირებულების ზომა 8 იღებს შენახული
ან გავიდა ამ მთელ რიცხვს ცვლადში ზომა.
ჩვენ გვყავს ზომა მასივი.
ახლა თუ ჩვენ დავუბრუნდებით რა ჩვენ ვსაუბრობთ ადრე,
ვფიქრობ Missy აღიზარდოს წერტილი რომ ის, რაც ჩვენ გვჭირდებოდა გააკეთოთ მიიღოს სიგრძეზე მასივი
და ყოფს მას 2 და რომ მოგვცემს შუაში.
ვნახოთ.
შემიძლია აქვს ვინმეს დაწეროს ამ და შეინახოთ საკუთარ სივრცეში?
როგორ შესახებ ლეილა?
შემიძლია აქვს წერთ ამ წელს?
დაწერეთ პირველი ხაზი, სადაც თქვენ მიიღოს სიგრძეზე მასივი და კიდევ შუაში
და ჩაწეროთ იგი ახალი ცვლადი.
მე მივცემ თქვენ რამდენიმე წამში. მზად ხართ?
[სტუდენტური inaudible]
რა თქმა უნდა, შეიძლება მე თქვენ გამოთვალოთ შუაში
საქართველოს haystack მასივი შიგნით ძებნა ფუნქცია
გამოყენებით სიგრძეზე haystack მასივი, რომელიც ზომა ცვლადი?
არაფერი სახიფათო აქ.
[ლეილა] უბრალოდ ზომა / 2 და მხოლოდ-
და შეინახე, და მოხვდა Save ღილაკს აქ ზედა,
და ჩვენ გაიყვანოს it up.
Perfect.
იქ ჩვენ წავიდეთ. გასაოცარია.
>> როგორც არის, იქნება ეს კომპილირდება?
[ლეილა] არა, ეს უნდა იყოს უმაღლესი.
[Nate] ჰო, ისე რას უნდა გავაკეთოთ?
[ლეილა] მსგავსად int შუაში ან რამე.
გასაოცარია. ჰო, მოდით, რომ int შუაში = ზომა.
დაიცავს ეს კომპილირდება?
მოდით ამ კომენტარის წაშლა და მიიღეთ იგი გარეთ გზა.
რა იქნება არ კომპილირდება ამის შესახებ?
ჩვენ არ აკეთებს არაფერი მთელი რიცხვი,
ამიტომ ჩვენ უნდა ბეჭდვა ან რამე მაგდაგვარს.
ჰო, ზუსტად.
ჩვენ კიდევ გამოუყენებელი ცვლადი.
რა არ იმუშავებს ამის შესახებ?
მე ვფიქრობ, თქვენ განაცხადა რაღაც, სემ. Semicolons.
ჰო, მე დაკარგული იმ semicolons.
ეს იქნება მუდმივი რამ მთელი კურსი ვადით.
საბოლოო რამ გავაკეთებ არის მე დააყენა ზოგიერთი თეთრი სივრცე ორივე მხარეს
ამ ოპერატორს აქ, რადგან ეს არის ის, როგორც წესი, თუ როგორ ვაფასებთ
შესაბამისად ჩვენი სტილი სახელმძღვანელო.
გვაქვს შუაში ჩვენი მასივი.
ახლა თუ ჩვენ გვახსოვს უკან ჩვენი ალგორითმი,
რა იყო მეორე ნაბიჯი, რომელიც ჩვენ უნდა გაეკეთებინათ ერთხელ გვაქვს შუაში?
[სტუდენტური] თუ ეს უფრო დიდი [inaudible].
ჰო, ამიტომ ჩვენ უნდა გავაკეთოთ გარკვეული შედარებით, და რა არის ჩვენ შედარებით აქ?
თქვენ თქვით, თუ იგი აღემატება. რა არის ის, რომ სასჯელი გულისხმობდა?
ნომერი, რომელიც მოდის მდე, თუ ეს მეტია შუაში, მაშინ ახვიდეთ მასივი?
სწორედ, ასე რომ ხმების ჩნდება ჩვენ-
ნემსი, ასე რომ ჩვენ შედარებით ნემსი,
და რა ჩვენ შედარებით წინააღმდეგ ნემსი?
იმის გამო, რომ ნემსი არის ის, რაც ჩვენ ვეძებთ.
ჩვენ შედარებით ეს მისაღებად შუაში.
>> მაგრამ ეს აზრი შეამოწმეთ
თუ ნემსის = შუაში?
ამჯამად რომ აზრი?
ვინმეს აქვს არ ვეთანხმები?
მოდით გინება, თუ (ნემსი == შუაში).
[სტუდენტური] ნუ printf თქვენ ი იგი.
[Nate] Printf ("ჩვენ ვნახეთ ის \ n");
წინააღმდეგ შემთხვევაში-I'm აპირებს დაიწყოს აკეთებს რაღაც განსხვავებული აქ.
მე ვაპირებ დაიწყება აყენებს braces გარშემო თუ განცხადებებს ყველა დროის
მხოლოდ იმიტომ, რომ თუ დავუმატებთ მეტი პერსონალი, მაშინ
ჩვენ არ მიიღოს compilers.
Yeah, სემ. თქვენ მოხვდით წერტილი.
პრობლემა ისაა, რომ შუაში წარმოადგენს პოზიცია მასივი,
მაგრამ თქვენ უკვე შეგიძლიად წარმოადგინოს ღირებულების რომ პოზიცია მასივი.
სწორედ დიდი წერტილი.
ხომ ყველას გვესმის რა სემ განაცხადა?
მისი თქმით, შუაში როგორც არის
წარმოადგენს მხოლოდ პოზიცია მასივი, მაგრამ ეს არ იქნება ნამდვილი ელემენტი მასივი.
თუ ფიქრობთ კოდი როგორც წერილობითი ახლავე,
თუ დავაკვირდებით ამ მასივი ქვემოთ აქ, რომელსაც აქვს 8 ელემენტების ის,
რა არის ღირებულება შუაში იქნება ამ ფუნქციის?
[სტუდენტური] 4.
[Nate] 4.
თუ ჩვენ ვეძებთ ნომერი 4 -
და ჩვენ შეგვიძლია მხოლოდ აწარმოებს ამ კოდი და ამით ცოტა სევდიანი სახე აქ
რადგან ჩვენ ვერ მიაგნეს-თუ ჩვენ აწარმოებს ამ კოდი
როგორც არის ახლა, ეს ატვირთვა, მშენებლობა, ნება მომეცით გადახვევა down,
და თუ ჩვენ ვეძებთ ნომერი 4,
ჩვენ ვნახეთ, მაგრამ ჩვენ ვერ ამ printf დიახ.
ერთი მიზეზი ის არის, რომ ჩვენ არ იქნება TRUE,
მაგრამ არც ჩვენ ნამდვილად იპოვის ნომერი 4?
და სემ ამბობს არ.
რა მივიღეთ მოვძებნოთ?
ჩვენ ნამდვილად ნაპოვნია შუაში, რომელიც, თუ დავაკვირდებით მასივი ქვემოთ აქ,
ეს იქნება ელემენტს საათზე ინდექსი 4 რომ ჩვენ შევხედავთ,
რაც 23.
>> როგორ ჩვენ რეალურად კიდევ რომ ელემენტს დროს შუაში
და არა მხოლოდ შუაში თავად?
[სტუდენტური] ჩვენ შევიდოდა char ან რაღაც?
რა, რომ გავაკეთოთ, უბრალოდ გარეთ ცნობისმოყვარეობა?
შეგიძლიათ უფრო დეტალურად შევჩერდე?
თქვენ უნდა გარდაქმნას პოზიცია ნომერი,
ასე რომ თქვენ მოხვდით გარკვეული კავშირი-ვფიქრობ, char, მაგრამ ეს არ უნდა იყოს.
ჰო, კარგი წერტილი.
ჩვენ ბევრი აკეთებს ბევრი ამ კონვერტაცია პოზიციების შევიდა სიმბოლო, ეს გმირები,
პირველ ორ პრობლემას კომპლექტი.
თურმე აქ, ამ თითქმის მსგავსი
წვდომის შ ხასიათის ფარგლებში სიმებიანი, თუ ეს აზრი.
აქ გვინდა წვდომისათვის შუაში ელემენტს.
როგორ გავაკეთოთ ეს?
კევინ, გაქვთ რაიმე შემოთავაზება, თუ როგორ შეიძლება ამის გაკეთება?
თქვენ შეიძლება არ haystack, ღია bracket, შუა რიცხვებში, დახურული ფრჩხილი.
შეგიძლიათ წერთ, რომ ჩვენთვის?
შეინახეთ იგი აქ, და ჩვენ გაიყვანოს, რომ up.
ჩვენ ვეძებთ ამ ხაზის 9,
და ჩვენ ხვდებიან, რომ ჩვენ არ გვინდა, რომ შეადაროთ ნემსი უნდა შუაში,
მაგრამ ამის ნაცვლად, ჩვენ გვინდა შევადაროთ ნემსი
რათა ელემენტს პოზიციაში შუაში ფარგლებში ჩვენი haystack მასივი.
ზემოთ.
იქ ჩვენ წავიდეთ.
ჰო, გამოიყურება საკმაოდ კარგი, თუ (ნემსი == haystack [შუაში]).
ჩვენ ვნახეთ ის.
ახლა თუ ჩვენ აწარმოებს კოდი-we'll back up ოდნავ-
იგი ადგენს, ის მუშაობს, და ახლა თუ ვეძებთ 4,
ჩვენ ვერ, რადგან ახლა ჩვენ რეალურად მიღების ნომერი 23.
ჩვენ ვიღებთ ღირებულების 23, და რომ ის, რაც ჩვენ შედარებით ჩვენი ნემსი.
მაგრამ ეს კარგია. სწორედ ნაბიჯი სწორი მიმართულებით.
>> რაც ჩვენ ვცდილობთ გავაკეთოთ.
ჩვენ არ ვცდილობთ, რომ შეადაროთ ნემსი წინააღმდეგ პოზიციების მასივი
არამედ წინააღმდეგ ფაქტობრივი ელემენტების მასივი.
თუ ჩვენ ვიხსენებთ ერთხელ ახლა ჩვენი შემდეგი ნაბიჯი ალგორითმი,
რა არის შემდეგი ნაბიჯი?
ლეილა უკვე მოგახსენეთ ეს მოკლედ.
[სტუდენტური] შეამოწმეთ, რომ ეს მეტია ან ნაკლები და შემდეგ გადაწყვიტოს, რომელი გზა გადავა.
[Nate] ჰო, ისე როგორ იქნებოდა გავაკეთოთ, რომ?
შეგიძლიათ დააყენა ზოგიერთ-I'll გადარჩენა ამ ვერსიასთან,
და თუ თქვენც არ დაიშურებთ რამდენიმე ხაზები, რომ ყველაფერს გააკეთებს, რომ.
Yeah, Charlotte. >> მე მაქვს შეკითხვა.
არ უნდა იყოს შუაში - 1, რადგან პირველი რაც არის
ეს 0 ინდექსირებული ასე რომ, თუ ჩვენ 4, ეს არ არის რეალურად ხასიათი ჩვენ ვეძებთ?
დიახ, და სხვა პრობლემა რომ არის-
რომ დიდი დაჭერა, რადგან რა ხდება მოხვდნენ ხდება შესაძლოა
თუ ჩვენ შენარჩუნება მოძრავი და ჩვენ არ ოდესმე შეცვალოს თავდაპირველად?
ვფიქრობ, რაც ჩვენ შეიძლება დასრულდება მდე აკეთებს ცდილობს შედიხართ
ელემენტს დროს მე -8 პოზიცია მასივი,
რაც ამ შემთხვევაში არ არსებობს.
ჩვენ გვსურს რომ გარკვეული აღრიცხვის ფაქტი
რომ ჩვენ გვაქვს გარკვეული ნულოვანი ინდექსირებას.
[Charlotte] უკაცრავად, ამას ვგულისხმობდი შუაში - 1 წლის კვადრატულ ფრჩხილებში.
ჩვენ შეგვიძლია გავაკეთოთ, რომ.
ჩვენ დავბრუნდებით ამ საკითხს ოდნავ.
ერთხელ ჩვენ ვიწყებთ მისაღებად ფაქტობრივი looping,
სწორედ მაშინ ჩვენ ვხედავ ამ მოვიდეს პიესა.
ამ დროისათვის, ჩვენ შეგვიძლია ამის გაკეთება, მაგრამ თქვენ მთლიანად უფლება.
რომ ნულოვანი ინდექსირებას ექნება ეფექტი, რომ ჩვენ გვჭირდება გათვალისწინებით.
ვნახოთ.
>> როგორ არის მეტი და ნაკლები-?
[სტუდენტური] მივიღო როგორ მეტია და ნაკლები ნაწილი.
მე უბრალოდ არ იყო დარწმუნებული, თუ რა უნდა ბეჭდვა თუ შეამჩნევთ, რომ ნაკლები haystack შუაში ან მეტი.
აქ შეგიძლიათ შეინახოთ რა I've-
[Nate] ჰო, თუ თქვენ შეინახავთ რასაც თქვენ მოხვდით, და ჩვენ გაიყვანოს it up.
იქ ჩვენ წავიდეთ.
[სტუდენტური] და მე ზუსტად კითხვის ნიშნები, თუ რა არ ვიცოდი.
[Nate], რომ გამოიყურება დიდი.
აქ გვაქვს კითხვის ნიშნები, რადგან ჩვენ ჯერ კიდევ არ ვიცით
რაც ჩვენ ვაპირებთ საკმაოდ გავაკეთოთ ამჟამად.
რა გვინდა გავაკეთოთ-oops, გვაქვს გარკვეული braces ყველა ხმაურიანი ჩვენზე.
ჩვენ არ გაასწორებთ ამ braces.
იქ ჩვენ წავიდეთ.
და მერე რა გვინდა გავაკეთოთ, ჩვენი ალგორითმი,
თუ ჩვენ არ იპოვოს ნემსი?
ამბობენ, რომ საქმე ნემსი ნაკლებია ვიდრე ჩვენ შევხედავთ. კევინ.
მხოლოდ შევხედოთ მარცხენა ნახევარში.
მარჯვენა, ისე ჩვენ დააყენა კომენტარი აქ რომ ამბობს "შეხედეთ მარცხენა ნახევარი."
და თუ ნემსის მეტია haystack დროს შუაში, რა გვჭირდება ჩვენ უნდა გავაკეთოთ?
[სტუდენტური] მაშინ შევხედოთ მარჯვენა ნახევარში.
შეხედეთ მარჯვენა ნახევარში, "შეხედეთ მარჯვენა ნახევარში."
არც ისე shabby.
Okay, ამრიგად, ამ ეტაპზე, რამ ეძებენ საკმაოდ კარგი.
კოდის პრობლემა როგორც წერილობითი არის რა?
[სტუდენტური] თქვენ არ endpoints ამისთვის halves.
მარჯვენა, ჩვენ არ გვაქვს წერტილი ამისთვის halves.
ჩვენ ასევე მხოლოდ აპირებს გავლა ამ ერთხელ.
ჩვენ მხოლოდ აპირებს შევხედოთ ერთი შუაში.
ან ელემენტს არსებობს, ან მას არ.
იმისათვის, რომ შეავსოთ ეს, ჩვენ გვჭირდება გარკვეული განმეორება.
ჩვენ უნდა შევინარჩუნოთ იმეორებს მანამ, სანამ ჩვენ რომ
არც ელემენტი იქ, რადგან ჩვენ დავიწროებულ ქვემოთ და საბოლოოდ ი,
ან ის არ არსებობს, რადგან ჩვენ გადახედა ყველა რამ
შესაბამის halves of array და აღმოაჩინა, რომ არაფერი არ არის იქ.
>> როდესაც გვაქვს ეს განმეორება მიმდინარეობს, რასაც ჩვენ ვაპირებთ გამოვიყენოთ?
[სტუდენტური] loop.
გარკვეული loop. დიახ.
[სტუდენტური] გავაკეთოთ do-ხოლო მარყუჟის და აქვს ეს ასე და შემდეგ, ხოლო
ნემსი არ თანაბარი-I'm არ არის დარწმუნებული, სადაც მივდიოდი, რომ.
მაგრამ სახის მოსწონს გავაკეთოთ, რომ სანამ ის არ თანაბარი ღირებულება, რომელიც მომხმარებლის შეყვანის.
ჰო, ასე რომ ვნახოთ, თუ როგორ შეიძლება ამ წერენ თავად?
თქვენ თქვით მოდით გამოვიყენოთ do-ხოლო loop.
სად გავაკეთოთ დაწყება?
[სტუდენტური] მარჯვენა შემდეგ ზომა / 2.
[Nate] Okay, და რას აპირებს?
ჩვენ შეავსონ ხოლო მოგვიანებით.
რას აპირებს?
[სტუდენტური] არ გვინდა ყველაფერი პერსონალის გვაქვს თუ ნაწილი?
[Nate] Do ყველა ამ პერსონალის, დიდი.
ასლი და პასტა.
ოჰ, კაცი.
ვნახოთ, თუ ეს სამუშაოები, შევძლებთ თუ არა ამ tab დასრულდა.
ლამაზია.
Okay, და ჩვენ გადარჩენა ამ ფუნქციას იმისთვის, ბიჭებს გააჩნიათ.
ყველა უფლება და ჩვენ ვაპირებთ ამის გაკეთებას, ხოლო-
რა იყო, ხოლო მდგომარეობა იყავით შემდეგ?
[სტუდენტური] მიუხედავად იმისა, რომ ნემსი არ თანასწორი, ისე მოსწონს ძახილის წერტილი.
მაგრამ არ ვარ დარწმუნებული, ზუსტად რა, რომ ჯერ კიდევ არ არის.
[Nate] ჰო, ეს არის ერთი გზა ამის გაკეთება.
სემ, გაქვთ კომენტარის გაკეთება?
[სემ] მე გაიხსენა, როდესაც შევხედე videos,
მე მივიღე Screenshot ერთი მსგავსი, როდესაც ჩვენ გავაკეთეთ pseudocode მას,
გარკვეული შორის ურთიერთობა max და min.
ვფიქრობ, ეს იყო რაღაც მსგავსი თუ max ოდესმე ნაკლები min.
Got It.
[სემ] ან მინდა თუ მაქსიმალური არის არანაკლებ min ან რამე მაგდაგვარს,
იმიტომ, რომ ნიშნავს, რომ თქვენ ჩხრეკა ყველაფერი.
>> ჰო, ისე, რას ჟღერს, როგორც max და min იქნა გულისხმობდა?
[სემ] ფასეულობები რომ-რიცხვებით, რომლებიც შეიცვლება
შედარებით, სადაც ჩვენ დააყენა შუაში.
სწორედ.
[სემ] იმ მომენტისთვის, ის აპირებს [inaudible] გამოთვლა max და min.
შუაში არის ამ max და min იდეა.
ამჯამად რომ აზრი FOLKS?
თუ ჩვენ უნდა დაწყებულიყო ეძებს თუ როგორ ვაპირებთ ამის გაკეთებას iteration,
თქვენ მთლიანად უფლება, რომ ჩვენ გვინდა გამოვიყენოთ გარკვეული do-ხოლო loop.
მაგრამ ვფიქრობ, თუ ჩვენ გვახსოვს, რა ხდება ადგილზე ამ მასივი
და რაც რეალურად ხდება-I'm აპირებს დაწეროს აქ-
პირველივე iteration ორობითი ძებნა, ჩვენ გვაქვს-
მე ვაპირებ გამოვიყენო ბ და ე აღინიშნოს დასაწყისია.
და მერე ბოლომდე ჩვენი მასივი.
ჩვენ ვიცით, რომ დასაწყისში არის 4 უფლება მეტი აქ,
და ჩვენ ვიცით, რომ ბოლომდე არის 108.
Say ჩვენ ეძებს ნომერი 15.
პირველად ამის გაკეთება, როგორც ჩვენ ვნახეთ ადრე,
შუაში არის ან იქნება 16 ან 23
დამოკიდებულია თუ როგორ გამოვთვალოთ ნივთების.
მას შემდეგ, რაც თანაბრად გამყოფი შუა მისცემს ჩვენს ამ სივრცეში
შორის 16 და 23, რომ ჩვენ არ შეგვიძლია თანაბრად გაყოფა ეს
ან გაყოფა და კიდევ ერთი ჭეშმარიტი შუაში.
ჩვენ შევხედოთ 16.
ჩვენ ვაცნობიერებთ, "Hey, 16> 15 რომ ჩვენ ვეძებთ."
შემდეგ შევხედოთ მარცხენა ნახევარში მასივი
რა ჩვენ დასრულდება მდე აკეთებს არის discarding
მთელი ამ ზედა ნაწილი
და უთხრა: "Okay, ახლა ჩვენი Endpoint იქნება აქ."
შემდეგი iteration ჩვენი მარყუჟის, ჩვენ ახლა ეძებს ამ მასივი,
ეფექტურად რომელმაც განადგურდეს ამ ნაწილის რადგან ახლა
თუ ჩვენ აღების შუაში უნდა იყოს სხვაობა დასაწყისი და დასასრული,
ჩვენ ჩვენი შუაში უნდა იყოს 8,
რაც ჩვენ შეგვიძლია მაშინ შეამოწმოთ 8 ენახა სადაც დაკავშირებით ხმების ჩვენ ვეძებთ,
15, ნახავთ, რომ 15 მეტია,
ამიტომ ჩვენ უნდა გადავიდეთ მარჯვნივ ნაწილი სიაში,
რაც ჩვენ ვიცით, რადგან ჩვენ ადამიანები, და ვხედავთ მას.
ჩვენ ვიცით, რომ უფლება ნაწილი იქნება, სადაც ჩვენ ის,
მაგრამ კომპიუტერი არ იცის, რომ, ასე რომ ჩვენ ყველაფერს გავაკეთებთ არის ჩვენ გამოგიგზავნით რეალურად
ეს ახვიდეთ და ახლა დასაწყისი და დასასრული
არის იგივე ადგილზე, ასე რომ შუაში ხდება მხოლოდ ნომრის სია იმ წერტილს,
რაც 15 წლის და ჩვენ ვერ.
ამჯამად რომ დაიღვარა ზოგიერთი შუქი სადაც ეს მთელი max და min ნოტაცია აპირებს,
შენახვა ტრეკზე წერტილი of მასივი, რათა გაერკვნენ
როგორ ვიწრო რამ ქვემოთ?
>> რა მოხდება, თუ ეს არ იყო ტოლია 15 არის?
რა მოხდება, თუ ჩვენ ეძებდნენ 15 და, ნაცვლად, ეს რიცხვი ასევე 16?
მე მინდა ვთქვა, "ო, ეს უფრო დიდი.
ჩვენ გვინდა დავუბრუნდეთ მარცხენა. "
და ჩვენ გვინდა გადაადგილება ჩვენი ვებ მარჯვნივ,
სადაც წერტილი გვაქვს Endpoint იქნებოდა კონფლიქტის.
იგი ვერ შეძლებს, რათა მოძებნოთ ნებისმიერი მეტი ელემენტები
რადგან ახლა ჩვენ გვაქვს ჩვენი Endpoint და ჩვენი დასაწყისში წერტილი,
ჩვენი მაქსიმალური და ჩვენი წთ, ახლა flipped.
ჩვენ ძებნის მთელი მასივი. ჩვენ ვერ პოულობენ არაფრის.
სწორედ წერტილი, რომლის დროსაც ჩვენ ავღნიშნო მინდა ვთქვა, "Okay, ჩვენ შევწყვეტთ ამ ალგორითმი.
ჩვენ არ მოიძებნება რამე. ჩვენ ვიცით, რომ ეს არ აქ. "
როგორ ხდება ამ აპირებს?
[სტუდენტური] როგორ ზუსტად ამჯამად კომპიუტერი გადართოთ ბოლოს?
როგორ ამჯამად ბოლომდე დასრულდება მდე დაწყებამდე?
ბოლოს მთავრდება დაწყებამდე
გამო მათემატიკის, რომ ჩვენ ვაპირებთ ყოველ ჯერზე ჩვენ ამას ვაკეთებთ.
გზა ჩვენ სვოპ არის თუ გადავხედავთ ძალიან პირველად ვაკეთებთ ამ swap
სადაც ჩვენ გვყავს დასაწყისი 4 და ბოლოს
ყველა გზა ქვემოთ 108 და ჩვენი შუაში, ამბობენ, საღამოს 16 -
მე ვაპირებ აღადგინოთ ამ თავში 15-თუ ჩვენ ვეძებთ 15,
ვიცოდით, რომ ის, რაც ჩვენ გავაკეთეთ, როცა გადავამოწმეთ 16 და დაინახა, რომ ეს იყო უფრო მეტი
და უნდოდა გაუქმება მთელი უფლება ნაწილი სიაში,
ჩვენ ვნახეთ, რომ ის, რაც ჩვენ გვინდოდა ჯანმრთელობის სფეროში გაგვეკეთებინა არის გადაადგილება ამ ვებ უფლება აქ.
ეფექტურად, ვებ გაბმულ გადავიდა ერთი ადრე შუაში.
ანალოგიურად, როდესაც ეს გავაკეთეთ iteration of ალგორითმი
და შუაში იყო 8,
აღმოჩნდა, რომ 8 <15, ამიტომ გვინდოდა გადაადგილება ბ
ერთი წარსულში შუაში.
ახლა, დასაწყისი და დასასრული ორივე ერთად ამ 15.
>> თუ ჩვენ გვინდა ხდებოდა, რომ გადახედეთ სხვა ღირებულების, არა 15,
ან თუ ამ 15 ჰქონდა ნაცვლად ყოფილიყო 16,
ჩვენ არ გამოვლინდა, რომ ვებ გვინდა ვიაროთ ერთი ადრე შუაში.
ახლა ვებ იქნებოდა იქ flipped ნაკლები ბ.
მოდით გავლა როგორ ჩვენ ფაქტობრივად დასრულდება მდე კოდირების ეს ალგორითმი.
ჩვენ ვიცით, რომ ჩვენ გვინდა ამ შუაში გაანგარიშებით.
ჩვენ ვიცით ასევე, რომ ჩვენ გვინდა აკონტროლოთ დასაწყისში და დასასრულს მასივი
ჩვენი მიმდინარე მასივი ასე შეგვიძლია გაერკვნენ
სადაც ეს მარცხენა ნახევარში სია და სადაც მარჯვენა ნახევარში სია.
ჩვენ ამას ვაკეთებთ, რომ არც დაიწყება და დასრულდება,
ან შეგვიძლია მოვუწოდებთ მათ min და max.
მე გამოიყენოთ დაიწყება და დასრულდება ამ დროს.
როდესაც ჩვენ ვიწყებთ, თუ ჩვენ ვიხსენებთ ჩვენი მაგალითი ქვემოთ აქ,
ჩვენი დასაწყისში შეიქმნა დასაბამიდანვე მასივი, როგორც ბუნებრივი.
რა ინდექსი იყო ეს? რა უნდა დაიწყოს ჩვენი იყოს?
დანიელ.
[დანიელ] Haystack [0].
[Nate] ჰო, ამიტომ ვერ ვაყენებთ მას ტოლი haystack [0].
პრობლემა, თუმცა, ის არის, რომ ამ გვაძლევს არ პოზიცია პირველი ელემენტს.
ეს გვაძლევს მაჩვენებელი პირველ ელემენტს ან ფაქტობრივი ღირებულება რომ პირველი პოზიცია.
[სტუდენტური] ეს ხელს კონვერრტაციისთვის .20?
[Nate] რა ამ ყველაფერს გააკეთებს IS-კარგად, იგი ამას არ გააკეთებს ნებისმიერი კონვერტაცია.
როგორი იქნება გააკეთოთ ეს შეინახავს 4 წელს დაიწყება,
და მაშინ ეს იქნება რთული, რათა შედარებები წინააღმდეგ დაიწყოს
რადგან დასაწყისი იქნება ჩატარების ღირებულება 4,
რაც დასაწყისში ჩვენი მასივი,
მაგრამ ჩვენ გვინდა, რომ აკონტროლოთ ინდექსების მასივში
როგორც ეწინააღმდეგებოდა ღირებულებებს.
ჩვენ რეალურად გამოიყენოს 0, იგრძნობა.
ამისთვის ბოლოს მასივი-Charlotte მოიტანა ეს ყველაფერი ცოტა ადრე.
ეს არის სადაც ჩვენ გაითვალისწინოს ნულოვანი ინდექსირებას.
>> Charlotte, რა ბოლომდე მასივი?
რა არის მაჩვენებელი წლის ბოლომდე?
[Charlotte] ზომა - 1.
ჰო, და რომელიც ზომა უნდა გამოვიყენოთ?
უნდა გამოვიყენოთ კაპიტალის ზომა ან ამას ზომა?
Capital ზომა.
ამ შემთხვევაში, ჩვენ შეგვიძლია გამოვიყენოთ კაპიტალის ზომა.
თუ გვინდოდა ამ ფუნქციის იქნება პორტატულ
და გამოიყენოთ ეს ფუნქცია სხვა პროგრამები,
ჩვენ შეგვიძლია რეალურად გამოიყენოს ამას ზომა.
ეს ჯარიმა ძალიან.
მაგრამ შარლოტა სრულიად უფლება, რომ ჩვენ გვინდა ზომა - 1.
ამ ეტაპზე-
[სტუდენტური] როგორ არის, რომ თქვენ შეგიძლიათ გამოიყენოთ ზედა ზომა?
როგორ არის ის, რომ ჩვენ შეგვიძლია გამოვიყენოთ ზედა ზომა?
თურმე ამ # განსაზღვრავს მართლაც,
ქვეშ Hood, ტექსტი, როგორიცაა იპოვოთ და შეცვალოს, თუ ეს აზრი.
როდესაც თქვენ კომპილაციის თქვენი კოდი, preprocessing ფაზა
საქართველოს შემდგენელი გადის ფაილი,
და ეს ეძებს ყველგან, რომ თქვენ წერილობითი კაპიტალის ზომა,
და ეს ცვლის, რომ ტექსტი სიტყვასიტყვით ერთად 8, ისევე, როგორც, რომ.
ამ თვალსაზრისით, ეს ძალიან განსხვავდება ცვლადი.
იგი არ დასჭირდეს რაიმე სივრცეში მეხსიერებაში.
ეს მარტივი ტექსტი შეცვალოს შეასრულა.
ამ შემთხვევაში, ჩვენ ვაპირებთ გამოვიყენოთ ზომა.
აქედან ჩვენ გვსურს რომ გარკვეული განმეორება,
და ჩვენ სწორ გზაზე ჩვენს do-ხოლო loop.
ჩვენ გვინდა, რომ რამე სანამ მდგომარეობა არ ფლობს უქმნით,
და როგორც ჩვენ ვნახეთ ადრე, ჩვენ ვნახეთ, რომ მდგომარეობა
მართლაც, რომ ჩვენ არ გვინდა ბოლომდე
ნაკლები დაიწყოს.
>> ეს არის ჩვენი შეჩერების პირობით.
თუ ეს მოხდება, ჩვენ გვინდა შეჩერება და აცხადებენ, როგორიცაა, "Hey, ჩვენ ვერ არაფერი."
გამოხატოს ამ, ჩვენ გვინდა გამოვიყენოთ გარკვეული loop.
ამ შემთხვევაში, უნდა იყოს do-ხოლო მარყუჟის, ამისთვის მარყუჟის, ხოლო loop?
ჩვენ გვყავს do-loop ხოლო აქ.
თქვენ ბიჭები მოსწონს, რომ მიდგომა?
როგორ ფიქრობთ, ჩვენ უნდა შევეცადოთ სხვადასხვა მიდგომა?
კევინ, ნებისმიერი აზრები?
ჩვენ შეგვეძლო ხოლო loop რადგან ჩვენ ვიცით, მაქსიმალური
იქნება მეტი min სტარტზე მაინც.
ჰო, ასე რომ არ არსებობს ინიციალიზაციისას რომ სჭირდება მოხდეს.
იმ do-მარყუჟების ხოლო დიდი, როდესაც თქვენ უნდა ინიციალიზაცია რაღაც
სანამ შემდეგ ტესტირება, ხოლო აქ
ჩვენ ვიცით, რომ ჩვენ არ ვაპირებთ შენარჩუნება reinitializing ორივე დაიწყოს და დამთავრდეს
ყოველ რაუნდში loop.
ჩვენ ვიცით, რომ ჩვენ გვინდა ინიციალიზაცია მათ, მაშინ შეამოწმოთ ჩვენი მდგომარეობა.
ამ შემთხვევაში, მე რეალურად წავიდეთ ერთად მარტივი ხოლო loop.
თურმე do-ხოლო მარყუჟების გამოიყენება საკმაოდ იშვიათად.
ბევრი ადგილები კი არ ასწავლიან ამას ხოლო მარყუჟების.
ისინი კარგი გატარება მომხმარებლის input, ამიტომ ჩვენ ვნახეთ ბევრი მათგანი დღემდე.
მაგრამ ნორმალური და სანამ მარყუჟების არიან ბევრი საერთო.
თურმე ამ მდგომარეობაში როგორც წერილობითი
არ ნამდვილად us გაცილებით კარგი, და რატომ არის, რომ?
მე ბოდიში, არ ვიცი თქვენი სახელი.
მე ჯერი. >> უკაცრავად?
ეს B-O-R-U-I.
ოჰ, okay.
მე ვერ ვხედავ, რომ თქვენ ჩემი სიაში.
ოჰ, ეს იმიტომ-oh, რომ აზრი.
გაქვთ იდეა რატომ ხოლო loop შესაძლოა არ იმუშაოს როგორც განკუთვნილი,
როგორც დაწერილია მდგომარეობა?
[ჯერი] თქვენ ნიშნავს, როგორიც გსურთ ყველა პერსონალის შემდეგ იგი-?
ჰო, ისე, რომ ერთი.
ჩვენ შეიძლება უნდა დააყენოს ყველა ამ პერსონალის შევიდა ხოლო loop, რომელიც მთლიანად შეესაბამება სინამდვილეს.
სხვა საქმეა, რომ ცოტა მეტი პრობლემატური, თუმცა, ის არის, რომ ამ მდგომარეობაში არ მუშაობს.
[სტუდენტური] თქვენ უნდა Flip ეს.
მარჯვენა, ისე ამ მდგომარეობაში არ ოდესმე იყოს ჭეშმარიტი თავდაპირველად გზა ჩვენ ვისაუბრეთ ეს.
ჩვენ გვინდა, რომ რამე სანამ ბოლომდე <დაიწყოს,
მაგრამ ჩვენ გვინდა, რომ რამე ხოლო
დაიწყოს ≤ ბოლომდე.
>> იქ რომ შეცვლის შესახებ ლოგიკა არსებობს.
მე დამნაშავედ მიღების იმ შეცდომების ყველა დროის.
[სტუდენტური] რატომ უნდა იყოს ნაკლები ან ტოლია?
იმის გამო, რომ არ გახსოვთ, რომ საქმე გვაქვს, რათა
სადაც მხოლოდ ერთი ელემენტია, და ჩვენ ქვემოთ,
და ჩვენ შევხედავთ მხოლოდ 15 ჩვენს მასივი?
და ჩვენი დასაწყისი და ჩვენი ბოლომდე იყვნენ იმავე ელემენტს.
ჩვენ გვინდა დავრწმუნდეთ, რომ ჩვენ გაუმკლავდეს ასეთ შემთხვევაში.
თითქოს ჩვენ აქ სწორი ნაკლები,
ჩვენ მხოლოდ შევძლებთ მისაღებად ქვემოთ 2-ელემენტს მასივი.
ერთხელ მივიღეთ ქვემოთ რომ ბოლო ელემენტს, თუ ეს იყო ჩვენი ელემენტს ჩვენ ავღნიშნო არასოდეს საპოვნელად.
ახლა აქ, შეგვიძლია ზუსტად თქვენნაირი ამბობდნენ.
ჩვენ შეგვიძლია დავიწყოთ plopping პერსონალის მარჯვენა შუა ჩვენი ხოლო loop.
ჩვენ შეგვიძლია plop ჩვენს შუაში.
ჩვენ შეუძლია ყველა იმ შემთხვევაში, თუ პარლამენტის განცხადებები,
გაიყვანოს ისინი ამ do-ხოლო მარყუჟის,
plop მათ,
სუფთა რამ up ცოტა,
მე კი წავიდეთ წინ და შეინახოთ ამ ვერსიაზე.
და ამ ეტაპზე, ჩვენ ვიღებთ საკმაოდ ახლოს.
სემ.
მე ვფიქრობ, თქვენ ასევე უნდა ჰქონდეს int შუაში = ზომა - 1/2.
Got it, ზომა - 1/2.
არსებობს არაფერი ჩვენ უნდა შეცვალოთ შესახებ, რომ ხაზი?
ეს იყო კარგი დაჭერა.
>> რას ზომა გავაკეთო? ჩვენ ოდესმე შეცვლის ზომა?
რათა ხაზი მოსწონს, ჩვენ უნდა შეიცვალოს ზომა.
ჩვენ უნდა შეცვალოს ზომა ყოველ ჯერზე ჩვენ გარშემო ამისთვის loop.
მაგრამ გახსოვთ, როდესაც ჩვენ ვაპირებთ ჩვენი მაგალითი უბრალოდ ცოტა უფრო ადრე,
და ჩვენ გვქონდა დასაწყისი 4
და ბოლოს ყველა გზა ზე 108?
როგორ ჩვენ გამოვთვალოთ შუაში?
იყო ჩვენ გამოყენებით ზომა?
ან ჩვენ გამოყენებით დაიწყოს და დამთავრდეს ნაცვლად?
ეს განსხვავება ბოლომდე და დასაწყისია.
სწორედ და ზუსტად როგორ უნდა დავწერო, რომ Charlotte?
უბრალოდ დასასრული - დაიწყოს.
თქვენ არ უნდა გავაკეთოთ - 1
რადგან - 1 ჩაერთო ბოლომდე და დაიწყება უკვე.
[Nate] დიდი, თქვენ მთლიანად უფლება.
ჩვენ არ უნდა გავაკეთოთ - 1 იმიტომ, რომ 1 - უკვე შედის
და აღრიცხვა, როდესაც ჩვენ ინიციალიზაცია ბოლომდე ცვლადი.
>> არსებობს არაფერი მე უნდა გავაკეთოთ syntactically ჰქონდეს ამ ხაზის აზრი?
[სტუდენტური] Plus დაიწყოს. >> Plus დაიწყოს?
[სტუდენტური] დასასრულს.
იმიტომ რომ მხოლოდ გამოითვლება ნახევარი სიგრძე.
თქვენ უნდა დაამატოთ დაიწყოს.
[Nate] რა ამ გამოვთვალოთ ჩვენთვის?
თუ ჩვენ ვიფიქროთ ბოლომდე სწორედ ამ პირველი iteration of მარყუჟის,
ბოლომდე აპირებს იყოს თანამდებობა ინდექსი 7.
დასაწყისი არის თანამდებობა 0.
გახსოვდეთ, ჩვენ ვეძებთ ან
პოზიცია 3 ან თანამდებობა 4.
თუ დავაკვირდებით ამ math, უბრალოდ, რათა ის უფრო ხელშესახები,
დააყენა ზოგიერთი ნომრები აქ, ჩვენ გვაქვს 7, 0,
ასე 7 - 0, ხოლო შემდეგ / 2
არის 3 in რიცხვი გაყოფა, რომ არის.
მაშინ გვინდა მაშინ დაამატოთ უკან ჩვენი დაიწყოს?
ჩვენ არ ამ შემთხვევაში.
წლის პირველივე iteration, ეს იქნება ჯარიმა, რადგან დასაწყისი არის 0.
თუმცა, როგორც ჩვენ პროგრესის, ჩვენ მართლაც ყველა უბრალოდ უნდა
ბოლოს - დაიწყოს / 2.
თუმცა ერთი სხვა შეასრულა აქ, და რომ არის კერძოდ ერთ პრეცენდენტის.
[სტუდენტური] გვჭირდება ფრჩხილებში?
[Nate] ზუსტად, და ეს იმიტომ, რომ თუ ჩვენ არ დააყენა ამ ფრჩხილებში,
მაშინ ეს ხაზი იქნება გაგებული, ნაცვლად
როგორც (დასასრული) - (დაიწყოს / 2), რომელიც ჩვენ ნამდვილად არ გვინდა.
ფრთხილად იმ პრეცენდენტის წესები.
[სტუდენტური] რატომ არ დასრულდება + დაიწყოს?
რატომ არ დასრულდება + დაიწყოს?
[სტუდენტური] რატომ არის არა, რომ?
რატომ უნდა იყოს +?
ვფიქრობ თქვენ უფლება.
[სტუდენტური] იმიტომ რომ საშუალო?
[Nate] ბოლო + დაიწყოს, თქვენ მთლიანად უფლება.
Wow, სრულიად goofed. თქვენ უფლება.
თუ ვაკეთებდით მინუს, ჩვენ გვინდა, რომ დაამატოთ დაიწყოს უკან შემოსული
ამ შემთხვევაში, თქვენ ძალიან სწორი, რომ ჩვენ გვინდა მიიღოს საშუალოდ ორი,
ამიტომ ჩვენ გვინდა მათი დამატებაც, როგორც ეწინააღმდეგებოდა სხვაობა მათ.
[სტუდენტური] ეს ასევე იმუშავებს თუ რა გააკეთეთ ბოლომდე - დაიწყოს / 2 + დაიწყოს.
ეს იქნებოდა თუ ჩვენ-მჯერა ისე.
>> მაგალითად, თუ ჩვენ შევხედავთ დაიწყოს,
და ჩვენ გადავიდა ეს მეტი აქ
დან 15.
ახლა ვიწყებთ არის პოზიციაში 2.
ბოლო არის პოზიციაში 7.
თუ ჩვენ სხვაობა მათ, მივიღებთ 5.
დაიყოს, რომ 2, ჩვენ კიდევ 2.
და შემდეგ ჩვენ დაამატოთ 2 უკან,
და რომ იღებს გვაძლევს მე -4 პოზიცია,
რომელიც სწორედ აქ, რომელიც შუაში.
[სტუდენტური] გვჭირდება ზრუნვა შესაფუთი?
რა გრძნობა გვჭირდება ზრუნვა შესაფუთი?
თუ თანხა ან სხვაობა
დამოკიდებულია, თუ როგორ გავაკეთოთ ეს არ არის კიდევ ნომერი.
მაშინ კომპიუტერი იღებს დაბნეული თუ არა როცა ის 2.5;
მიგაჩნიათ გადავიდეს მარცხნივ ან მარჯვნივ, რათა დადგინდეს, რომელიც შუაში?
Got It.
თურმე ერთად მთელი განყოფილება,
ჩვენ არ ოდესმე კიდევ ამ მცურავი პუნქტიანი ნომრები.
ჩვენ არასოდეს მიიღოთ ათობითი.
ეს სრულიად უგულვებელყოფილია.
თუ თქვენ გაქვთ კომპიუტერი გაყოფა ორ int ცვლადები,
და ერთი არის 7, ხოლო მეორე 2,
ვერ მიიღებთ 3.5 შედეგად.
იგი მიიღებს 3.
ნაშთი იქნება განადგურდეს, ამიტომ ეფექტურად დამრგვალება-
არ მრგვალი არამედ სართული, თუ ბიჭები არიან იცნობს, რომ მათემატიკის,
სადაც თქვენ მთლიანად გაუქმება ათობითი,
და ა.შ. თქვენ არსებითად truncating იგი ქვემოთ უახლოეს
მთელი პოზიცია, რომ უახლოეს მთელი რიცხვი.
[სტუდენტური] მაგრამ შემდეგ რომ პრობლემატური, რადგან თუ თქვენ გაქვთ მასივი 7 ელემენტები
მაშინ ეს ავტომატურად იღებს მე -3 ელემენტს გარეთ შუაში ნაცვლად მე -4.
როგორ უნდა გავუმკლავდეთ, რომ?
ეს პრობლემატურია, რადგან თუ ჩვენ გვქონდა მასივი 7,
ეს იქნებოდა აირჩიოთ -3 ნაცვლად მე -4.
იქნებ ახსნას ცოტა მეტი?
[სტუდენტური] რადგან თუ თქვენ გაქვთ 7 ელემენტები მაშინ მე -4 ელემენტს
იქნება შუაში, არა?
გახსოვდეთ კომენტარი მყოფი ნულოვანი ინდექსირებული, თუმცა.
[სტუდენტური] ჰო, ისე თანამდებობა 3. ეს იქნება შუაში.
Yeah.
ოჰ, okay. მე ვხედავ, რაც თქვენ ნიშნავს.
ეს სახის უცნაური, როგორც ჩვენ შეეგუება ამ მთელი ცნება
მოშორების decimals.
სწორედ დიდი წერტილი.
მოდით დავამთავროთ ეს up.
ჩვენ გამოთვლილი ჩვენი შუაში.
>> ჩვენ ტესტირების თუ ჩვენი ნემსი უდრის შუა ღირებულება.
ჩვენ დაბეჭდვის, რომ ჩვენ აღმოვაჩინეთ, მაგრამ რეალურად, თუ რა გვინდა გავაკეთოთ ამ სიტუაციაში?
ჩვენ ი, ასე რომ ჩვენ გვინდა, ნება Caller იცოდეს, რომ ჩვენ ვერ.
გვაქვს ფუნქცია რომ ლოგიკური აკრეფილი ფუნქცია.
გზა ჩვენ სიგნალი Caller ჩვენი ფუნქცია რომ ჩვენ მზად ვართ წავიდეთ
არის ვამბობთ, "Hey, ეს მართლაც ასეა."
როგორ გავაკეთოთ რომ, კევინ?
თქვენ nodding თქვენი უფროსი. >> [Kevin] Add დაბრუნების ჭეშმარიტი.
[Nate] ზუსტად, იქნება TRUE.
ახლა, თუ ეს არ თანაბარი, როგორ შევხედავთ მარცხენა ნახევარში?
ნებისმიერი იდეები?
Stella, ნებისმიერი იდეები?
თქვენ უნდა დააყენოთ ახალი თანამდებობაზე ბოლომდე.
Yeah.
ამიტომ, ჩვენ უნდა გავაკეთოთ პოზიცია შუაში - დასასრული.
დიდი.
ჩვენ გვჭირდება შევქმნათ ახალი თანამდებობაზე ბოლომდე
შევხედოთ მარცხენა ნახევარში.
ეს იყო ის, რაც ჩვენ ვისაუბრეთ ადრე აქ
მე შენარჩუნება ბრუნდება ამ მაგალითს.
მე არ დაიწყოს აქ, და შემდეგ მაქვს ბოლომდე ყველა გზა აქ.
>> ისევ და ისევ, თუ ჩვენ ვეძებთ 15, და ჩვენი შუაში არის 16,
და ვაცნობიერებთ, "Oops, 16 არის უფრო დიდი.
ჩვენ გვინდა გადასვლის მარცხენა ნახევარი. "
ჩვენ გვინდა მაშინ გადატანა დასრულდეს 15,
და ჩვენ გავაკეთებთ, რომ ხდება ერთი დაშორებით შუაში
და განსაზღვრავს, რომ როგორც ჩვენი ახალი ბოლომდე.
ანალოგიურად, თუ გვინდა შევხედოთ მარჯვენა ნახევარში, როგორ გავაკეთოთ ეს?
გაქვთ იდეა?
[სტუდენტური] თქვენ უბრალოდ მითითებული დაიწყოს შუაში + 1.
[Nate] დიდი.
და ახლა იმ შემთხვევაში, რომ ჩვენ ვერ იპოვით რაიმეს,
ამჯამად რომ მიიღოთ მიღებული ზრუნვა ჩვენთვის?
დანიელ, ამჯამად რომ მისაღებად აღებული ზრუნვა ჩვენთვის?
[დანიელ] ჯგუფი
[Nate] თუ ჩვენ გვექნება ის მეშვეობით მთელი მასივი და ჩვენ ვერ იპოვით რაიმეს,
სად იქნებოდა, რომ იქნეს მიღებული ზრუნვა, ან უნდა იზრუნოს ეს?
[დანიელ] ხოლო მდგომარეობა.
[Nate] Yeah, ხოლო მდგომარეობა, ზუსტად.
იგი იზრუნებს გადის მთელი მასივი, თუ ჩვენ ვერ არაფერი.
ეს მაშინ, როცა მარყუჟის დასრულდება.
ჩვენ არასდროს არ შეექმნა ამ მდგომარეობაში,
და ჩვენ შეგვიძლია დაბრუნების ცრუ.
ჩვენ შეგვიძლია ასევე დატოვეთ თუ აქ ასე
რადგან თუ ეს იმ შემთხვევაში, თუ განაცხადი შეესაბამება სიმართლეს,
და ჩვენი ფუნქცია დააბრუნებს,
და ა.შ. ჩვენ გამოგიგზავნით არსებითად შეწყვეტთ ამ ფუნქციის ამ ეტაპზე
როდესაც ვბრუნდებით ჭეშმარიტი.
მაგრამ რა ხდება ამ სტრუქტურის აქ?
იქნება ეს ნამუშევარი მთლიანად, ან არსებობს გარკვეული ლოგიკური ხარვეზია იქ?
>> არსებობს ლოგიკური ხარვეზია იქ, სადაც გზა ის შეიქმნა.
რა შეიძლება იყოს?
[სტუდენტური] რატომ გჭირდებათ - და + 1s?
რომელიც ადგენს ჩვენი მასივი მდე იქნება ჩვენი ახალი მარცხენა ნახევარში და მარჯვენა ნახევარში.
[სტუდენტური] მაგრამ რატომ ვერ აკეთებ გარეშე - 1s და + 1s?
[Nate] ჩვენ ვერ ვაყენებთ მას ტოლი შუაში?
რა შეიძლება იყოს პრობლემატური შესახებ, რომ?
[სტუდენტური] ვფიქრობ ეს არაეფექტური რადგან თქვენ შემოწმების ღირებულება, რომელიც უკვე გადამოწმებულია.
[Nate] სწორედ ამიტომ სემ სრულიად უფლება.
თუ მითითებული ბოლომდე და დაიწყოს ტოლია შუაში
ნაცვლად - 1 და + 1 reflectively,
რაღაც მომენტში მომავალში ჩვენ დასრულდება მდე შემოწმების შუაში კვლავ.
[სტუდენტური] დავიწყე pset, ხოლო შემდეგ მე მქონდა რაღაც მსგავსი
აქ დამავიწყდა + 1 და მას ჩარჩენილი უსასრულო ციკლი.
მარჯვენა, რადგან რაღაც მომენტში თქვენ არასდროს მისაღებად დაიწყოს და დამთავრდეს
რეალურად გადახურვა.
ზემოთ.
თუმცა ერთი უფრო ლოგიკური ხარვეზია, და რომ ის არის, რომ ეს უნდა იყოს აუცილებლად
სხვაგან თუ.
რატომ შეიძლება, რომ იყოს?
>> მიზეზი კი ის არის, თუ ის არ სხვაგან თუ-არ ჩანს, კევინ?
[Kevin] ჰო, იმიტომ, რომ თქვენ შეცვლით ბოლომდე წერტილი.
[Nate] ზუსტად.
ჩვენ იცვლება Endpoint,
და თუ მას წერილობითი მოსწონს-we'll მიიღოს ფართების შორის-
ეს შეამოწმებს ამ შემთხვევაში.
ამ შემთხვევაში, თუ ის გაამართლებს, პროცესი შეწყვეტილია გარეთ ფუნქცია.
მერე შეამოწმებს ამ შემდეგი შემთხვევაში,
და თუ ეს გაამართლებს, ის შეცვალოს Endpoint,
და მერე გაგრძელდება და შეამოწმოთ ამ შემთხვევაში.
მაგრამ ამ ეტაპზე, ჩვენ არ გვსურს გავაგრძელოთ შემოწმების.
საბედნიეროდ, ჩვენ არ აღადგინოთ შუაში აქ,
და ვიცით, რომ ამ შემთხვევაში შედეგს ვერ მოიტანს.
მაგრამ ჩვენ ნამდვილად გვინდა დააყენა სხვაგან თუ არსებობს
მიუხედავად იმისა, რომ ეს შეიძლება, ამ შემთხვევაში
მას შემდეგ, რაც ჩვენ არ მორგება შუაში, რომ რომ განსხვავება?
არა, რადგან ამ შემთხვევაში ყველა ექსკლუზიური.
ისევ და ისევ, ჩემი ცუდი.
ჩვენ არ ვფიქრობ, გვჭირდება ეს სხვაგან თუ.
ჩვენ შეგვიძლია გინება და გაუშვით და ვნახოთ, რა მოხდება.
შენობა, შეცდომა.
ალბათ იმიტომ, რომ დავტოვე ეს ბ და ე ს აქ.
მაქვს იმის მეტი იმ up ზედა?
ეს არ ჰგავს მას.
ჩვენ დააშორებს, აშენება,
იქ მიდის, ასე რომ, ახლა თუ ჩვენ მოძებნოთ 15,
დიახ.
ნება მომეცით zoom სისტემაში
15, დიახ. ჩვენ შეგვიძლია გაუშვით ერთხელ.
ატვირთვა კოდის, შენობა, გაშვებული.
ჩვენ შეგვიძლია ვეძებოთ რაღაც 13,
და ჩვენ არ მიიღოთ არაფერი დაბეჭდვისას, ამიტომ არ მოძიებაში, რომ ჩვენთვის.
სწორედ დიდი, იმიტომ, რომ ეს არ არის ჩვენი სია.
>> ჩვენ ახლა გარეთ დრო.
რომ იქნება ეს ამ კვირაში.
მადლობა გაწევრიანების და ვნახავთ მოგაწვდით.
>> [CS50.TV]