>> [მუსიკის დაკვრა]
>> Andi Peng: ეს ​​არის CS50, და მივესალმებით კვირაში ორი მონაკვეთზე.
ეს არის რეალურად, ხოლო კვირაში ჩვენი ორი კლასის ფაქტობრივად,
პირველ კვირას, რომ ჩვენ გვქონდა განყოფილებაში.
შოუ ხელში, რამდენი თქვენგანი ყველა მოვიდა სუპერ მონაკვეთზე გასულ კვირას?
OK, რომ კარგადაა.
ეს არის ის, OK.
რამდენი თქვენგანი უყურებს სუპერ მონაკვეთზე გასულ კვირას?
OK.
და შენ გააკეთა ჯარიმის on პრობლემა მითითებული ერთი?
ასე რომ, მე ვაპირებ, რომ ჩვენ გვაქვს რამოდენიმე მართლაც ჭკვიანი ბავშვები
ამ კლასში და რამ კარგად იქნება.
OK.
ასე რომ, პირველი
>> პირველ რიგში, ჩვენ უბრალოდ აპირებს მოკლედ გადასვლა ზე მეტი დღის წესრიგში დღეს.
ჩვენ ვსაუბრობთ, რა თქმა უნდა ლოგისტიკის.
ბევრი თქვენგანი ალბათ აქვს შეკითხვები
როგორ რამ აწარმოებს ამ კურსს.
ჩვენ უპასუხოს მათ.
ჩვენ ვაპირებთ, რომ მოკლედ გადასვლა ზე მეტი მარყუჟების შემთხვევაში
რომელიმე თქვენ ბიჭები გაუშვა სუპერ მონაკვეთზე.
ჩვენ ვსაუბრობთ ASCII რუკების.
ჩვენ ვსაუბრობთ კოლექტორები, ფუნქციები, ბრძანების არგუმენტები.
და ბოლოს, რა თქვენ ბიჭები ალბათ ყველა ნამდვილად გსურთ იყოს აქ, რათა გაეცნონ,
თქვენი pset2.
ჩვენ გვექნება ზოგიერთი ლამაზი ტრიუკები და რჩევა, თუ როგორ უნდა გავაკეთოთ, რომ.
>> OK.
გარდა ამისა, მეორე რიგში, ჩვენ უამრავი candy აქ.
ვისაც უყვარს candy, მხოლოდ ამუშავება აქ.
Grab ზოგიერთი.
მე მაქვს რამოდენიმე.
ჩვენ გვყავს ტონა ოფისში.
მე ნამდვილად არ მინდა ჭამა Candy მთელი დღე.
თქვენ ბიჭები უნდა ჭამა ყველა კამფეტი, იმიტომ, რომ მე მოუტანა მას აქ თქვენ ბიჭები.
უბრალოდ ჭამეთ კანფეტი.
იქ იქნება candy ყოველ სექციაში.
>> ასე რომ, პირველი, ვინ ვარ მე?
ჩემი სახელი არის Andi Peng.
უფროსი მე ვარ TA of CS50 აქ იელის.
და გარდა ამისა, რომ, მე ასევე be--
თუ ვინმე მოსწონს თქვენი გაშვებული buddy, თქვენი მხრის ტირილი.
იმ შემთხვევაში, თუ ღამეს თქვენი pset ის გამო, თქვენ არ ვიცი, რა ხდება,
მოხვდა me up.
ჩვენ commiserate ერთად, და სხვა.
უბრალოდ ვიცი, რომ მე აქ ვარ, როგორც რესურსი თქვენ, როგორც ფრონტის ხაზი
ეხმარება ბიჭებს გაერკვნენ, თუ როგორ პრობლემების CS50 და მის ფარგლებს გარეთ.
>> ჩემი ელ არის andi.peng@yale.edu.
მე ასევე out ინდივიდუალური ელ ჩემი ტელეფონის ნომერი ის
ისე, რომ არ ყველას ინტერნეტ ხედავთ, ჩემი ტელეფონის ნომერი.
მოგერიდებათ მირეკავენ ნებისმიერ დროს.
სერიოზულად, ჩემი ტელეფონი არის როგორც წესი, ერთვის ჩემი მხრივ.
მე შეიძლება არ უპასუხა ფარგლებში რამდენიმე წუთის განმავლობაში.
მე არ რეაგირება რამდენიმე საათის განმავლობაში.
მაგრამ მე გარანტიას გაძლევთ, თუ თქვენ e-mail me, თუ მირეკავენ,
ტექსტის, მე კი გიპასუხებთ 24 საათის განმავლობაში.
ხშირ შემთხვევაში, მე რეაგირება ადრე რომ, რადგან მე მესმის
რომ ყველას გვაქვს გარკვეული პრობლემები, და გსურთ თქვენი პასუხი
უნდა გაეცეს პასუხი ძალიან სწრაფად.
>> თუმცა, თუ თქვენ მოვუწოდებთ მე 30 წუთით ადრე
რომ ნაჭერი რომ იმის გამო, ხუთშაბათი ღამე იყოს, Andi, დამეხმაროთ,
მე არ started-- მე შეიძლება მისცეს რომ მხრის ტირილი შესახებ.
მაგრამ ეს შეიძლება იყოს დრო, რომ ვიფიქროთ როგორ არ უნდა გავაკეთოთ, რომ მომავალი დრო.
OK.
Oops.
როგორ შემიძლია დაბრუნდეს?
იქ ჩვენ წავიდეთ.
>> ასე რომ, რა თქმა უნდა, ჩვენ გვაქვს ტონა მხარდაჭერა ყველას.
გარდა ამისა, უბრალოდ განყოფილებები აქ, რომელიც
ყოველ კვირას დახარჯოს 90 მშვენიერი ე წუთზე ჩემთან ერთად,
ჩვენ ასევე გვაქვს საათებში.
რამდენი თქვენგანი უკვე ყოფილა საათებში დახმარება?
შესანიშნავი.
ეს არის ძალიან კარგი, რომ ნახოთ, იმიტომ, რომ ჩვენ აქვს შტაბის 45-ზე მეტ TAs და CAS
მომზადებული ამ, რა თქმა უნდა, რომ აქ ხართ ეხმარება თქვენ ბიჭები თქვენი psets.
>> ორშაბათს ისინი გაიმართა TEAL კლასის 17 Hill House აქ
იელის.
სამშაბათს და ხუთშაბათს, ისინი გაიმართა commons.
8:00 11:00 საკმაოდ ბევრი ყოველ სამუშაო დღეს.
მოდით, გამოვა.
არანაირი პრობლემა, არ პრობლემის უბრალოდ მოვიდა წელს,
და მაშინ ჩვენ დაგეხმარებით ერთად, რომ.
>> მეორე, გარდა იმისა, რომ სამუშაო საათებში და სექციები, ჩვენ ასევე გვაქვს შორტები.
აქვს ვინმეს ოდესმე მინახავს რამდენიმე შორტები ან walkthroughs ვიდეოკადრები
ვებ გვერდი?
OK.
ასე რომ, ისინი ნამდვილად, ნამდვილად გამოსადეგი.
ჩვენი საყვარელი ჰარვარდის წარმოება გუნდის იქ, რომ სკოლა
ჩრდილოეთით, მათ გადაიღეს და წარმოებული ეს წარმოუდგენელი walkthrough videos.
>> ისინი თქვენ ეტაპობრივად მეშვეობით როგორ წავიდეთ შესახებ გადაჭრის პრობლემას.
ხშირ შემთხვევაში, თუ თქვენ დაბნეული შესახებ მარტივი კონცეფცია, სინგულარული კონცეფცია,
შევხედოთ, იმიტომ, რომ ჩვენ, ალბათ, მოკლე მასზე სადღაც ჩვენს ვებგვერდზე.
და ეს, როგორც წესი, დიდი რესურსი უნდა ვეძებოთ, როდესაც თქვენ პირველი
დაკარგა თუ როგორ უნდა გაუმკლავდეს პრობლემა.
>> მესამე, ჩვენ ასევე უნდა study50 და reference50.
ასე რომ შეისწავლოს 50 საიტზე მხოლოდ ბმული.
ეს, ჩემი აზრით, study.cs50.net ან რამე მაგდაგვარს.
მხოლოდ Google.
ჩვენ გვყავს უამრავი სლაიდები მომზადებული.
ჩვენ გვყავს უამრავი შორტები და walkthroughs-- რამ ყველა შედგენილი
ძალიან ლამაზი და სუფთა თქვენ ბიჭები ყველა დაათვალიეროთ, ვხედავ რაიმე ცნებები
რომ თქვენ დაბნეული შესახებ.
ეს ალბათ იქნება დაფარული იქ study50.
>> Reference50-- მსგავსი.
ჩვენ გვყავს ბევრი სხვადასხვა შენიშვნები ხელმისაწვდომი თქვენს განკარგულებაში.
და ბოლოს, ჩვენ, რა არის მოუწოდა CS50 საუბარი,
ფორუმს, რომელიც, თუ ღამეს თქვენ აკეთებთ თქვენი პრობლემა, ვთქვათ,
გაქვთ შეკითხვა.
შესვლა CS50 იმსჯელებს.
განათავსეთ თქვენი კითხვა.
და მაშინ ერთი hundreds-- ალბათ, thousands-- თანატოლებს
აღების ამ კლასში შემოსული შესვლა.
და, შესაძლოა, ვინმეს შეუძლია მიიღოს თქვენი პასუხი ადრე TA შეუძლია.
ეს არსებითად მხოლოდ ფორუმი რომ ჩვენ შეგვიძლია ყველა
გამოყენება, რათა განიხილონ ჩვენი პრობლემები.
ეს არის მაგარი.
>> OK.
ასე რომ, პრობლემა ადგენს.
ჩვენ შესახებ უფლება სქელი პრობლემა მითითებული ორი.
ბევრი ჩვენგანი უკვე იბრძოლა პრობლემა მითითებული ერთი.
ჩვენ უკვე ვიცით, რომ ალბათ ელოდება ბოლო ღამე უნდა გავაკეთოთ თქვენი pset
არ არის smartest რამ უნდა გავაკეთოთ CS50.
>> რჩევები და მინიშნებები არსებითად წარმატება წავიკითხე მთელი სპეც.
რამდენი თქვენგანი უკვე წაკითხვის სპეც pset 2?
OK.
ეს არის მყარი თანხა.
მე ვიცი, შენ ალბათ აღიარებული , ახლა specs მართლაც ხანგრძლივი.
ისინი მართლაც, მართლაც ხანგრძლივი.
>> ეს მართლაც მძიმე წასაკითხი ყველა ხაზი რომ ყურადღებით სიტყვა-სიტყვით.
გსურთ უბრალოდ skim, სადაც ის გიჩვენებთ უნდა გავაკეთოთ რაღაც.
მე გარანტიას გაძლევთ, რომ არ გაგვაჩნია.
თუ თქვენ, რომ, თქვენ ალბათ აპირებს მენატრება სადღაც
სადაც ეს გიჩვენებთ როგორ უნდა დაიწყოს პრობლემა
ან გიჩვენებთ თუ რა სახელი თქვენი პრობლემა და ეს გიჩვენებთ,
ეს არის ალბათ საუკეთესო გზა დაიწყოს აკეთებს თქვენი პრობლემა.
და მაშინ თქვენ უნდა დაიკარგოს.
>> როდესაც თქვენ ცდილობენ წაიკითხონ თქვენი სპეც შუა ნაწილამდე იყვნენ მეშვეობით,
ბევრი მნიშვნელოვანი information--, რომ თქვენ არ
აპირებს შეძლებს მართლაც ხელმისაწვდომობა.
ასე წავიკითხე მთელი სპეც.
ცდილობენ წაიკითხონ მთელი სპეც სანამ მოვა განყოფილებიანი,
იმიტომ, რომ მაშინ, როდესაც ჩვენ ვისაუბროთ pset,
ჩვენ შეგვიძლია ყველა გაქვთ იდეა რა ხდება.
>> მეორე, ეს არის კონცეფცია რომ მე მინდა მინიშნება
ბევრი მთელი კურსი სემესტრში.
მაგრამ არსებითად, ჩვენთან შესახვედრად შუა ნაწილამდე იყვნენ, არა?
მე, როგორც თქვენი TA და ჯეისონ როგორც, რა თქმა უნდა მენეჯერი და Scaz როგორც თქვენი პროფესორი
და დავით, როგორც თქვენი პროფესორი და ყველა სხვა lovely TAs ამ რა თქმა უნდა,
თანაშემწეები ამ course-- ჩვენ ყველაფერს გავაკეთებთ იმისათვის,
უზრუნველყოს, რომ თქვენ მითითებული მდე წარმატების რა თქმა უნდა.
ჩვენ ჩავატარებთ განყოფილებაში.
ჩვენ ჩავატარებთ საათებში.
ჩვენ გიპასუხებთ თქვენი ტელეფონი ზარები, უპასუხოს თქვენი ელექტრონული ფოსტის,
ყველაფერი გავაკეთოთ, რათა დარწმუნებული ვარ, თქვენს კითხვებს უპასუხა.
>> თუმცა, დაგვეხმარება ძალიან.
ჩვენთან შესახვედრად შუა ნაწილამდე იყვნენ.
თუ მოვა საათებში არ რომელმაც წავიდა განყოფილებიანი, არ
იხილა ლექციები, რომელსაც არ ვიცი, რა ხდება, იყოს, დამეხმაროთ.
მე ვაპირებ, რომ იყოს, ასევე, მე ბოდიში.
ეს შეიძლება იყოს დრო, რომ სარგებლის რომ მხრის ტირილი,
იმიტომ, რომ მე არ ვარ დარწმუნებული რა შეგვიძლია გავაკეთოთ, რათა დაგეხმაროთ
თუ არ ცდილობენ მინიმუმ დახმარება თავს ცოტა დასაწყისში.
ჩვენთან შესახვედრად შუა ნაწილამდე იყვნენ.
თქვენ იცით, გთხოვთ მოდის მზად არის პასუხი გასცეს და მიიღოს
მზად არის ჩაერთოს მასალა.
რაც რამ იმდენად ადვილია ყველასთვის ჩართული.
ჰო, საკმაოდ ბევრი იყო.
>> შეფასების.
ასე რომ, სილაბუსი, ეს არის საკმაოდ სიღრმისეული დაკავშირებით, თუ როგორ ჩვენ კლასის.
მაგრამ არსებითად, ავარია ამ 50% თქვენი grade
იქნება psets, რომელიც არის ლამაზი, იმიტომ, რომ ის
სადაც თქვენ ხარჯავს უზარმაზარ უმრავლესობა რა თქმა უნდა დრო.
ტესტებში 40%, და თქვენი საბოლოო პროექტი იქნება 10%.
იქნება ორი ვიქტორინებში მთელი რა თქმა უნდა, სემესტრში.
მე ვფიქრობ, რომ ჯერ და ვადები ასევე ჩამოთვლილია სილაბუსში.
>> ისე, რომ ჩვენ უნდა შეფასების თქვენს psets
არის, რომ ჩვენ არსებითად ოთხ ფასეულობები, რომელიც უნდა მივუთითოთ თითოეული კლასის.
ჩვენ გვყავს მნიშვნელობა ფარგლებს, სისწორეში, დიზაინი და სტილი.
ასე რომ, როგორც ხედავთ, ეს ერთგვარი ჩვენი ფორმულა psets.
სამი ვაძლევთ ყველაზე წონა სისწორე,
რადგან აშკარად თქვენი მწვრთნელი უნდა ტესტირება შემთხვევებში
ჩვენ გვინდა, რომ ეს ტესტი.
>> თქვენ ბიჭები ყველას გვაქვს check50 თქვენს განკარგულებაში.
ეს არის ძალიან სასარგებლო ფუნქცია რომ თქვენ ბიჭები შეუძლია ყველა
ატვირთეთ თქვენი კოდი ჩვენი სერვერები სადაც ჩვენ აუცილებლად შეამოწმეთ იგი თქვენთვის.
და ვნახე ის, frowny სახეები, ღიმილიანი სახეები.
ისინი მართლაც, ნამდვილად გამოსადეგი.
გთხოვთ არ იყოს სტუდენტი, რომელიც მინდა ლელო
რომ hardcode ყველა პასუხი.
მე ნამდვილად მინახავს pset, სადაც ვიღაც დაინახა ყველა ღირებულებებს check50
და ისინი უბრალოდ მყარი კოდირებული შიგნით, თუ ეს ნომერი, ამობეჭდოთ ეს ნომერი.
თუ რომ ნომერი, ბეჭდვა, რომ ნომერი.
არ გაგვაჩნია.
>> მიუხედავად იმისა, რომ ტექნიკურად check50 არის სწორი,
თქვენი გზა გადაჭრის პრობლემა არ არის სწორი.
ასე რომ, უბრალოდ გამოიყენოთ check50 sparingly.
მაგრამ ასევე დარწმუნდით, რომ თქვენ გაგება, თუ როგორ ფუნქციონირებს,
პროგრამა ფუნქციონირებს გარდა check50,
იმიტომ, რომ ჩვენ არ შეგვიძლია შევამოწმოთ ყველა შესაძლებელია შემთხვევაში check50.
ჩვენ უნდა ტესტირების ზოგიერთი მათგანი.
>> დიზაინი არსებითად, თუ როგორ მოფიქრებული თქვენი კოდი?
თუ თქვენ ხართ ასლი pasting სხვადასხვა ხაზი კოდი ბევრჯერ.
იქნებ არ საკმაოდ საუკეთესო დიზაინის თქვენი კოდი.
იქნებ დროა, რომ დაამატოთ loop.
არსებითად, აქ უბრალოდ ყველა ცდილობს თქვენი კოდი
ცდილობს თქვენი კოდი ეფექტურად შესაძლებელია ისე, რომ თქვენი პროგრამა ეშვება
რაც შეიძლება სწრაფად.
>> და ბოლოს, ჩვენ გვაქვს სტილი.
ასე რომ, სტილი არის ერთგვარი თვითნებური, სუბიექტური ვადით.
მე ვიცი, ჩვენ ოფიციალურად აქვს სტილი 50 მეგზური CS50,
სადაც ეს გიჩვენებთ, oh, უნდა ჰქონდეს სივრცე აქ.
თქვენ უნდა სახის ფორმატი თქვენი კოდი ამ გზით.
თქვენ უნდა დაასახელოს რამ ამ გზით.
>> მე ნამდვილად არ მაინტერესებს, თავისთავად, თუ როგორ თქვენ თქვენი სტილი კოდი,
უბრალოდ, როგორც თქვენ დარჩება თანმიმდევრული.
მაგალითად, თუ გსურთ დატოვეთ ფართი შემდეგ თქვენი ოთხ
სანამ თქვენი ოთხი ციკლი, უბრალოდ, რომ ყოველ ჯერზე.
ნუ სახის ამის გაკეთება.
არ გააკეთოთ ეს სხვა დროს.
თუ გსურთ, რომ შევინარჩუნოთ curly braces სივრცეში გარკვეული გზა,
უბრალოდ ყოველთვის გავაკეთებთ, რომ გზა.
ნუ სახის გავაკეთოთ, რომ სადღაც აქ და სადღაც იქ არ არის.
როდესაც ჩვენ შეფასების, ეს მართლაც რთულია
თუ მე არ ვიცი, როგორ თქვენ გაფორმებით თქვენი კოდი,
რამ wacky და გარეთ ადგილი.
თუ თქვენ უბრალოდ შეინახოს იგი თანმიმდევრული, ეს ბევრად უფრო ადვილია ჩემთვის, როგორც დიდი
შეძლებს იკითხება თქვენი კოდი.
ეს ბევრად უფრო ადვილია თქვენთვის, როგორც სტუდენტი შეძლებს გაეცნონ კოდი
და ვნახოთ, რა არის არასწორი ეს ხაზი, თუ რატომ არის საკითხები.
სტილი არის ერთ ერთი ყველაზე იოლი რამ თქვენ ბიჭები შეუძლია მიიღოს სრული ქულა.
არსებითად, თუ უბრალოდ მაინტერესებს, თუ იხდით ხუთი წუთის ყურადღება
თქვენი კოდი, ყოველ კვირას, თქვენ უნდა იქნება მიღების სრული სტილი რაოდენობა.
>> და ბოლოს, ჩვენ გვაქვს რასაც მულტიპლიკატორის ფარგლებს.
ფარგლებს მე ვიცი, რომ ეს არის დიდი სიტყვა, განსაკუთრებით ამ კლასში.
მაგრამ ფარგლებს, რომ ყველა საშუალებით არის, რომ თქვენ ცდილობს
psets რომ საუკეთესო თქვენი უნარი.
თუ თქვენ ჩართოთ სამში თქვენი ოთხი პრობლემა
და კი არ ცდილობენ ბოლო ერთი, თქვენ ალბათ
აპირებს დაკარგავს გარკვეული რაოდენობა on ფარგლებს.
>> მაშინაც კი, თუ თქვენ დავიწყო პრობლემა, ნუ თქვენი საუკეთესო გავლა იგი.
მაშინაც კი, თუ ეს არ იმუშავებს, აქციოს იგი, იმიტომ, რომ აჩვენებს და მეტყველებს იმაზე,
ჩვენთვის, რომ თქვენ ცდილობთ, რომ თქვენ სცადა პრობლემის მითითებული
მაქსიმალურად თქვენი უნარი.
და მაშინ ჩვენ შეგვიძლია მოგცეთ სრული ქულა ფარგლებს.
>> სფერო არის ასევე ძალიან მნიშვნელოვანია, როდესაც ჩვენ ვისაუბროთ ყველაზე დაბალი pset ანგარიში წვეთი.
ასე რომ, რა თქმა უნდა, სემესტრში, თქვენ ბიჭებს აქვთ ცხრა psets.
და ჩვენ, ფაქტობრივად, ჩაშვების ყველაზე დაბალი ქულა აქედან ცხრა,
მაგრამ მხოლოდ იმ შემთხვევაში თუ თქვენ გაქვთ სრული ფარგლებს რაოდენობა.
>> ასე რომ, თუ თქვენ ჩართოთ არასრული pset, სამწუხაროდ, ჩვენ ვერ ჩამოაგდეს, რომ ერთი,
იმიტომ, რომ თქვენი ფარგლებს რაოდენობა დასრულებული არ იყო.
ასე რომ, თუ თქვენ გაქვთ საშინელი კვირაში სადაც თქვენ კვდება და თქვენ ავადმყოფი
ან თქვენი ძაღლი მოკვდება, თქვენი კატა კვდება, და თქვენ გადატვირთულია საშინაო დავალება,
უბრალოდ ცდილობენ pset.
ამის გაკეთება, რათა საუკეთესო თქვენი უნარი.
თუ ეს არ მოხდა, ეს არ აქვს.
უბრალოდ ჩართოთ იგი.
ყოველ შემთხვევაში, ჩვენ შეუძლია თქვენ მიუთითებს ძალისხმევა.
>> ამისთვის ძალისხმევა ამ კლასში.
მინიმუმ დაბალი ქულა წვეთი ძალისხმევა.
ასე რომ, yeah.
ეს არის საკმაოდ ბევრი იყო.
ვინმეს აქვს კითხვები ასე რამდენადაც, თუ როგორ ჩვენ grade კლასში?
ან ეს?
ნებისმიერი ამ, ასე far-- განყოფილებები, სამუშაო საათებში?
ზემოთ.
OK.
>> ასე რომ, ეს არის საგანი, რომელიც არ ერთი ნამდვილად უყვარს ლაპარაკი.
მე ნამდვილად არ მინდა ამაზე.
თქვენ ბიჭები ნამდვილად არ მინდა მომისმინოთ ამაზე.
მაგრამ, სამწუხაროდ, ჩვენ ყველა უნდა გაიგო ამის შესახებ.
დავით გატარებული 20 წუთი ლექცია საუბრობდა.
და ეს არის თემა აკადემიური პატიოსნება.
>> ასე რომ, ჩვენ ყველა აქ ალბათ დაწერილი ესსე შუალედში ჩვენს Yale კარიერა.
ჩვენ, ალბათ, მიღებული განხილვა, სადაც ჩვენ უკვე განუცხადა არ plagiarize ჩვენი ესსე,
იმიტომ, რომ მუშაობა არ არის ჩვენი.
კომპიუტერულ მეცნიერებაში, ჩვენ გვაქვს იგივე სახის კონცეფცია.
ყველა სამუშაო, რომ თქვენ წარმოადგინოს, ყველა კოდი რომ წერთ
უნდა იყოს კოდი, რომ თქვენ არ წერია.
არ უნდა იყოს კოდი, რომ თქვენ გადაწერა სხვაგან.
არ უნდა იყოს კოდი, რომელიც თქვენ googled და plopped in
და თქვენ ნამდვილად არ ვიცი, თუ ის მუშაობს.
თქვენ სახის გრძნობა რასაც ის აკეთებს, მაგრამ ნამდვილად არ.
როდესაც ეჭვი, არსებითად, ის უბრალოდ იყოს გონივრული.
ჩვენს სილაბუსი, ჩვენ გვაქვს მთელი სია რამ
როგორც ვხედავთ, გონივრული წინააღმდეგ არ არის მიზანშეწონილი.
>> მაგალითად, გონივრული თქვენ და თქვენი მეგობარი
მსჯელობენ, თუ რა არის საუკეთესო გზა წავიდეთ ამის შესახებ ლოგიკურად გადაჭრის პრობლემას.
ეს არის საკმაოდ გონივრული.
რა არ იქნებოდა მიზანშეწონილი არის თუ ბიჭები ერთად, აკრეფილი იგივე კოდი,
და აღმოჩნდა იმავე კოდი.
ეს არ არის მიზანშეწონილი.
იგივე, სახის ესსე.
თუ გსურთ განიხილავს თქვენი მეგობარი, hey,
ეს არის ის, რაც მე მინდა, რომ წერენ.
ეს არის ნაბიჯები მინდა მიიღოს წერენ, დიდი.
ეს არის მშვენიერი.
გთხოვთ, ითანამშრომლონ ერთმანეთთან.
თუ ბიჭები დაიწყოს წერა იგივე,
გახდეს იმავე წერილში, რომელიც ნაკლები OK.
ასე რომ, როდესაც ეჭვი, უბრალოდ არ აკეთებენ.
>> აქ, ჩვენ CS50, ჩვენ სკრიპტები რომ აწარმოებს ავტომატიზაცია შესამოწმებლად
არა მხოლოდ სისწორეში თქვენი კოდი, არამედ უნიკალურობა თქვენი კოდი.
ასე რომ გთხოვთ არ დაგვაყენა პოზიცია რომელსაც ეხება თქვენი საქმე EXCOMM.
გთხოვთ, უბრალოდ ყველას, მოდით უბრალოდ რომ ეს შესანიშნავი გამოცდილება.
ყველას გაიგებს უკეთესი, ჩვენ ყველანი ვართ ბედნიერი,
და ჩვენ ყველა შეიქმნა წარმატების რა თქმა უნდა.
ის, რაც ძალიან უნიკალური ამ კლასში
რომ მე ვფიქრობ, რომ ყველას უნდა ნამდვილად ყურადღება მიაქციონ არის, რომ ჩვენ გვაქვს
რასაც სინანული პუნქტი ჩვენს სილაბუსში.
ასე რომ, არსებითად, 72 საათის განმავლობაში, თუ თქვენ გვჯერა, რომ თქვენ გავაკეთეთ რაღაც
თქვენ ნამდვილად არ ვიცი იყო საჭიროების შემთხვევაში, გთხოვთ მოგვმართოთ.
ჩვენ გპირდებით, რომ 72 საათის განმავლობაში ჩვენ გაუმკლავდეს შემთხვევაში საკუთარ თავს
მითითების გარეშე უმაღლესი ორგანოს ადმინისტრაციას.
>> ასე რომ, თუ თქვენ მოვიდა ჩემთან და ამბობენ, Andi, hey, მე ნამდვილად ვწუხვარ,
მაგრამ მე ვფიქრობ, რომ არსებობს რამდენიმე ხაზები ჩემი კოდი ღამით, რომ მე სახის googled,
გადმოვიდა of Stack Overflow, ასლი და გაკრული,
და მე ნამდვილად, ნამდვილად ვწუხვარ იმის შესახებ, რომ, ნება მომეცით ვიცი.
გთხოვთ, ნუ უბრალოდ ასეც გართულდეს და იმედი მაქვს, რომ მე დაჭერა მას.
ჩვენ დაჭერა მას.
მოდი.
მიადევნე თვალი 72 საათის განმავლობაში.
ჩვენ გაერკვნენ გამოსავალი.
და გპირდებით, რომ ჩვენ არ ეხება უნივერსიტეტის ხელისუფლება არსებითად.
ასე რომ, ეს თქვენი საუკეთესო ინტერესი უბრალოდ იყოს პატიოსანი ყველას
ჩართული, რა თქმა უნდა.
>> OK.
OK.
ახლა, სწრაფად, სანამ მე გადაადგილება, ვინმემ
აქვს შეკითხვები ლოგისტიკის იმაზე, თუ როგორ კურსები ჩვენ ვაპირებთ აწარმოებს,
როგორ სექციები ვაპირებთ აწარმოებს, რომ არც ერთი?
OK.
ჰო.
>> აუდიტორია: [INAUDIBLE]?
Andi Peng: ჰო.
ასე რომ ტესტებში რამდენი ხართ ამ სამშაბათი / ოთხშაბათი განყოფილებაში?
რამდენი ხართ სამშაბათი / ხუთშაბათი?
OK, ასე, რომ ეს არის მყარი გაყოფილი აქ.
ასე რომ, ისე, რომ ჩვენ აწარმოებს ის იელის არის, რომ ჩვენ
ვაპირებთ აქვს ორი დამოუკიდებელი ტესტებში ერთი თითოეული სექცია, რომელიც
იქნება მიღებული დროს კლასი.
მე ვფიქრობ, რომ ოქტომბერში, ოქტომბრის ბოლოს, ასე რომ, ერთი კვირის ერთი
ვიქტორინა.
ჰო, ისე, უბრალოდ მოვიდა კლასის.
იმ ორშაბათს და ოთხშაბათს, თქვენ მიიღოს ვიქტორინა.
იმ სამშაბათს ან ხუთშაბათს, თქვენ მიიღოს სხვადასხვა ვიქტორინა.
მაგრამ იმავე მასალის დაიფარება.
ჰო.
კარგი კითხვაა.
ჰო.
>> აუდიტორია: სად წასვლა შეამოწმოთ ჩვენი შეფასება?
>> Andi Peng: ჰო.
ასე რომ, მე იქნება გაგზავნის out ელ-ფოსტა რასაც ყოველ კვირას
როდესაც ტესტები graded-- ან, ვწუხვარ, როდესაც psets ფასდება.
Psets, როგორც წესი, აღმოჩნდა ამ შუადღისას ან პარასკევს.
ასე რომ, მე გპირდებით, რომ ცდილობენ მიიღონ მათ უკან თქვენ
შუადღისთვის შემდეგი პარასკევი.
>> როდესაც მე grade pset, მე გამოგიგზავნით გარეთ შეტყობინებას grade წიგნაკი
, რომელიც გიჩვენებთ თქვენი ანგარიში შეიძლება ჩაითვალოს ონლაინ რეჟიმში.
ასე რომ, ამ კვირაში, მას შემდეგ, რაც მე დასრულდება შეფასების გასულ კვირას psets,
თქვენ ბიჭები მიიღებს ელ-ფოსტა შეტყობინებას გეუბნებოდით,
hey ეს არის სადაც თქვენ წასვლა ნახოთ თქვენი შეფასება.
და თქვენ შეგიძლიათ ნახოთ ყველა ავარია თქვენი შეფასება.
თქვენ შეგიძლიათ ნახოთ კომენტარი.
ოჰ, სწრაფი რამ ასევე.
კომენტარი სექციაში დიდი წიგნი, სადაც მე, ალბათ,
ატარებენ უმრავლესობა ჩემი დრო შეფასების.
ასე რომ, ერთი რამ, რომ მართლაც მნიშვნელოვანია, როდესაც
თქვენ ბიჭები არიან ათვალიერებენ თქვენი შეფასება თქვენს psets
ეს არ არის მხოლოდ ეძებს ფიზიკური ანგარიში
არამედ აღების დრო ნამდვილად წაიკითხა ჩემი კომენტარი.
>> ხშირად, რომელიც გაძლევთ კავშირი იმაზე, თუ როგორ თქვენ გადაჭრის პრობლემას.
თუ თქვენ უნდა გავაკეთოთ რაღაც ცოტა უკეთესი,
კონსტრუქციული კრიტიკა, როგორც წესი, საუკეთესო მიეცეს იმ კომენტარი სექციაში.
ასე რომ, გთხოვთ, გთხოვთ, მე ვაპირებ დროის გასატარებლად წერილობითი კომენტარები.
გთხოვთ, მე ნამდვილად იმსახურებს თუ ბიჭები რომ წაიკითხა იმ კომენტარი.
OK.
ზემოთ.
>> ყველა უფლება.
ასე რომ, ჩვენ ვაპირებთ, რომ დაიწყოს საუბარი და მხოლოდ განხილვის სწრაფად
ზოგიერთი მასალა კვირაში ნულოვანი მხოლოდ ასე ჩვენ
მარჯვენა გვერდზე დაწყებული ამ კვირაში პრობლემები.
ასე რომ სანამ loop ერთ-ერთი სამი ტიპის მარყუჟების
ჩვენ განვიხილეთ ადრე ამ კლასში.
>> ხოლო loop არსებითად წერია სინტაქსი
სადაც, ხოლო გარკვეული მდგომარეობა, ამისათვის არაერთხელ, არა?
ვფიქრობ, რომ ეს ამ გრაფიკული აქ.
თქვენ აპირებს დაიწყოს ზე გარკვეულ მომენტში თქვენი კოდი.
თქვენ აპირებს შესვლის loop მდგომარეობაში if-- მე არ ვიცი x ნაკლებია.
>> თუ ეს ასეა, თქვენ აპირებს შეასრულოს loop ორგანო.
და თქვენ ვაპირებთ აკეთეთ რომ კიდევ ერთხელ, კიდევ ერთხელ, კიდევ ერთხელ,
მეტი და over-- რის გამოც ის მარყუჟის სანამ თქვენი მდგომარეობა ხდება
ყალბი.
ასე რომ, ამ გზით, ხოლო loop ერთ-ერთი მარტივი გზა
დაწერა რაიმე პირობით, რომ საჭიროებს ვიმეორებ მეტი და მეტი და მეტი.
უბრალოდ ფრთხილად, როცა თქვენ წერილობით რაიმე სახის loop
რომ თქვენ გაქვთ გასასვლელი მდგომარეობა, როგორც ისევე როგორც განახლება, რასაც ის
ასე, რომ თქვენი loop არ მხოლოდ აწარმოებს და მეტი უსასრულოდ.
ნებისმიერ შემთხვევაში, თქვენ აპირებს უნდა გვინდა დავრწმუნდეთ,
რომ თქვენ შეცვლით ზოგიერთი ასპექტი თქვენი კოდი და ბოლოს ციკლი
უბრალოდ დარწმუნდით, რომ თქვენ გაქვთ გზა პროგრესირებს მიმართ მდგომარეობაში
რომ გსურთ აკმაყოფილებდეს ბოლომდე.
არა, რომ აზრი ყველას?
ჩვენ უბრალოდ არ მინდა, რომ იყოს წამოეწია ამ სპირალი, სადაც
ჩვენ გარშემო და ირგვლივ და არ არსებობს გზა შესვენება loop.
და ყოველ loop არსებითად აქვს გზა აკეთებს, რომ.
OK.
>> მეორეც, ბევრი თქვენგანი თქვენს Mario psets
ალბათ დასაქმება ამ ტიპის loop.
ეს ეწოდება do ხოლო loop.
პირველ რიგში, შეიძლება ვინმეს მითხრათ რა განსხვავებაა do
ხოლო მარყუჟის და ხოლო loop არის?
ჰო.
>> აუდიტორია: do ხოლო loop გადის პირველი [INAUDIBLE].
>> Andi Peng: ჰო, ზუსტად.
ასე რომ, ნუ ხოლო მარყუჟის ყოველთვის აკეთებს რასაც შიგნით do, შიგნით ფრჩხილებში
იქ და იმას, რომ მდგომარეობა ადრე შემოწმების the-- ბოდიში,
იმას, რომ კოდი წინაშე შემოწმების პირობით.
ეს განსაკუთრებით მნიშვნელოვანია ჩვენთვის აქ ამ კლასში, იმიტომ, რომ ყველაზე ჯერ
ჩვენ ვაპირებთ, რომ გსურთ უბიძგონ მომხმარებლის გარკვეული შეყვანა.
და მაშინ, დამოკიდებულია შეყვანის ისინი გვაძლევენ,
მაშინ ჩვენ შეგვიძლია შევაფასოთ, რა, ამის ჩვენ უნდა უბიძგონ კიდევ ერთხელ?
>> ასე რომ, Mario, თუ მომხმარებელს მისცა თქვენ უარყოფითი სიმაღლე, მაგალითად,
თქვენ აპირებს პირველი სწრაფი და ნუ რაც არის შიგნით.
მაშინ ვაპირებთ, რათა შეამოწმოს, ხოლო.
თქვენ იცით, არის უარყოფითი 1, ის არის, რომ დადებითი რიცხვი?
თუ ეს არ არის, მე ვაპირებ წასვლა უკან და ვიმეორებ do და ვიმეორებ
და ვიმეორებ და ვიმეორებ, სანამ ისინი საბოლოოდ გაძლევთ ნომერი, რომელიც გსურთ,
რომ ჩვენ შეგვიძლია ყველა დასაქმება ჩვენი კოდი.
ეს არის საკმაოდ მნიშვნელოვანი არსებითად პროფაილი შეყვანა.
შემიძლია გარანტია მოგცეთ, ნებისმიერ დრო pset, სადაც
ჩვენ ვთხოვთ თქვენ შეყვანის რაიმე კოდი, ჩვენ
ალბათ აპირებს მოგცემთ ტესტი საქმე, რომელიც ჩვენ
აპირებს მოგცემთ რაღაც ცუდი, რომ აპირებს ცდილობენ დაარღვიოს თქვენი კოდი.
>> თუ ჩვენ ვცდილობთ გთხოვოთ შეყვანის რიცხვი, ჩვენ შეიძლება მხოლოდ მოგცემთ სიმებიანი
და ვხედავ, თუ როგორ გაუმკლავდეს, რომ.
თუ ჩვენ ვთხოვთ თქვენ დასაქმება ასაკის, ჩვენ მოგცემთ უარყოფითი ნომერი
იმისათვის, რომ ნახოთ, თუ როგორ გაუმკლავდეს, რომ.
უბრალოდ დარწმუნდით, რომ თქვენ ბიჭები ტესტირება საქმე, რომელშიც თქვენ არ მიიღოს საუკეთესო
input, მოდით უბრალოდ, ვამბობთ.
და ნუ ხოლო მარყუჟის არის ხშირად საუკეთესო
გზა, რათა შეიმუშავონ თქვენი კოდი ისე რომ იგი აკმაყოფილებს, რომ ფარგლებს.
OK.
>> OK.
ასე რომ, ეს არის ალბათ ყველაზე კომპლექსი loop გარეთ სამი
რომ ჩვენ შევხედე ჯერჯერობით.
და როგორც ჩანს, ძალიან საშინელი პირველი.
მაგრამ მე გაძლევთ გარანტიას, ერთხელ თქვენ ბიჭები შეეგუონ, თუ როგორ გამოიყენოთ ამისთვის მარყუჟის,
ეს არის ერთ ერთი ყველაზე სასარგებლო რამ, ყველაზე სასარგებლო ინსტრუმენტები თქვენს არსენალში
წინსვლის ამ კლასში.
>> ასე მაგალითად, Scratch, ჩვენ გვქონდა ამ ძალიან მარტივი ბლოკი
რომელიც მხოლოდ განაცხადა ვიმეორებ ამ კონკრეტულ ფრაზები გარკვეული რაოდენობის ჯერ.
სხვათა შორის, SAJ-- რომ არის Scaz Andi ჯეისონ.
ჩვენ ხშირად მოაწეროს ჩვენი ელ SAJ.
თუ ვიტყვით, SAJ, არ უნდა იყოს დაბნეული.
ეს მხოლოდ ჩვენთვის.
>> ასე რომ, Scratch, ჩვენ შევძელით ბლოკი რომ განაცხადა, ვიმეორებ, მე მიყვარს SAJ!
10-ჯერ.
ძალიან მარტივია.
ლოგიკა, რომელიც არის ძალიან, ძალიან მარტივია, არა?
მე მინდა პირველი გავლა პირველი დრო და ვხედავთ, რომ, მეორედ
და ვხედავ, რომ, მესამედ, ა.შ. და ასე შემდეგ, სანამ არ მოხვდა 10.
>> და გზა ჩვენ წარმოადგენს, რომ კოდი არის უბრალო for loop.
ასე რომ, თქვენ აპირებს გამოაცხადოს თქვენი ცვლადი აქ, ამ შემთხვევაში,
ერთად int.
ჩვენ ვაპირებთ, რომ დაარქვით i.
ჩვენ ვაპირებთ, რომ ინიციალიზაცია მას 0.
და გაჩერების გამოცემა იქნება მე ნაკლებია 10.
და განახლება იქნება i ++.
>> და შიგნით მარყუჟის, ის აპირებს შეასრულოს, სანამ საბოლოოდ
ჰიტები ბოლოს condition--, რომელიც შემთხვევაში, ის აპირებს დაარღვიოს loop.
არ უნდა იყოს პერსონალის, რომ თქვენ ბიჭები ყველა სახის მინახავს ადრე
და ეს უნდა გააკეთოს, რომ თქვენი პრობლემა მითითებული ერთი.
ვინმეს გაქვთ რაიმე შეკითხვები დაკავშირებით მარყუჟების ახლა?
OK.
შესანიშნავი.
>> OK.
ასე რომ, იმ თქვენ, ვინც წაკითხვის pset სპეც ამ კვირაში
ვიცით, რომ ჩვენ ვაპირებთ, რომ დასაქმება რაღაც მოუწოდა ASCII და ASCII მაგიდასთან.
დავითმა ლექცია წავიდა მოკლედ როგორ კომპიუტერები არსებითად ყველაფერი
არის კოდირებული კომპიუტერი ორობითი, zeros და პირობა.
და ისე, რომ კომპიუტერი შეუძლიათ შესანახად სხვადასხვა ღირებულებების გარდა
zeros და პირობა მეშვეობით რუკების იმ ნომრები წარმოადგენს სხვა ციფრები
ან არსებითად სხვა სიმბოლოები.
>> ასე რომ, ამ შემთხვევაში, ASCII მაგიდასთან ყველა ეს ასეა,
არის რუკა გმირები, ან სიმბოლო, ნომრები.
ასე რომ, კოდის, ფაილი თქვენს კომპიუტერში ის ხედავს,
hey, bunch of zeros და პირობა, zeros და პირობა, zeros და პირობა.
აი, რა ინახება ფაქტობრივი მეხსიერების თქვენს კომპიუტერში.
>> მაგრამ, როდესაც ჩვენ ადამიანებს გვინდა ურთიერთობა კომპიუტერი,
ჩვენ want-- ვთქვათ, მაგალითად, თუ მინდა ზედა,
მე ვაპირებ უნდა გარკვეული გზა ვეუბნებოდი კომპიუტერი, oh,
როდესაც მე აკრიფოთ ზედა, ვგულისხმობ ეს წარმომადგენლობა ორობითი.
>> ასე რომ გზა გავაკეთოთ, რომ ესროლა თვითნებური რამ მოუწოდა ASCII მაგიდასთან,
სადაც ჩვენ, როგორც ადამიანები, როგორც პროგრამისტები, რამდენიმე ხნის წინ,
ჩვენ თვითნებურად გადაწყვიტა, რომ ჩვენ მიდიოდნენ დაავალოს ამ რაოდენობის
ღირებულებები, ეს გმირები.
>> ასე რომ, შენ შეიძლება google ამ ონლაინ რეჟიმში.
მე ვფიქრობ, რომ ბმული ეს თქვენი pset-- მხოლოდ ASCII რუკა მაგიდა, ASCII
მაგიდა.
ეს მხოლოდ ითარგმნება ორობითი ნომრები სიმბოლო.
და ეს იქნება ძალიან სასარგებლო თქვენი პრობლემა კომპლექტი
როდესაც გსურთ გამოვთვალოთ არაფერი და თუ
გვინდა, რომ არიან გარკვეული გმირები და რიცხვებით
ან მანიპულირება გარკვეული სიმბოლო.
ეს იქნება ძალიან მნიშვნელოვანია, რომ თქვენ ყველა
იცით, თუ როგორ ნავიგაცია ASCII მაგიდასთან.
>> ასე მაგალითად, ზედა წარმოდგენილია ნომერი 65.
და ამას წარმოდგენილია 97.
ამიტომ მნიშვნელოვანია, რომ იცით, რომ განსხვავება ორ ღირებულებები
32.
ხშირ შემთხვევაში, თუ უნდა გადაიყვანოთ ერთი სხვა, განსხვავება არის 32.
და არ ინერვიულოთ თუ თქვენ სახის ბუნდოვანი ამ პირველი.
ჩვენ წავიდეთ მეტი, თუ როგორ ჩვენ გვინდა დასაქმება ეს ფაქტობრივი კოდი.
>> OK.
ასე რომ, იმ თქვენ, ლაპტოპები out, მოგერიდებათ დახევის up ASCII მაგიდასთან,
იმიტომ, რომ ეს ალბათ მოითხოვს თუ არა ბიჭები მითითებას
რა სიმბოლოები.
OK.
>> ასე იცის, რომ გარკვეული გმირები რუკაზე გარკვეული ნომრები,
თუ მე აწარმოებს მხოლოდ პირველი ხაზი, რომ code--, printf a,
ამას, მინუს ზედა A. ვინმეს
გაქვთ ამოიცნობთ, თუ რა იქნება დაბეჭდვის ეკრანზე ახლა?
>> ასე რომ, პირველ რიგში, რა ამას წარმოადგენს?
რა ნომერი არის, რომ კოდირებული ASCII მაგიდასთან.
ბოდიში?
>> აუდიტორია: 97?
>> Andi Peng: 97, დიდი.
და რა არის ზედა?
>> აუდიტორია: 65.
>> Andi Peng: რა არის 97 მინუს 65?
>> აუდიტორია: 32.
Andi Peng: OK.
ასე რომ, რას ბიჭები ვფიქრობ აპირებს მოხდეს, როდესაც მე input, რომ ხაზი კოდი
ჩემს კომპიუტერში?
>> აუდიტორია: [INAUDIBLE].
Andi Peng: სამწუხაროდ, საუბარი up.
არ აწუხებს.
ეს არის ძალიან უსაფრთხო გარემო, მინუს კამერა.
ჩვენ ყველა აპირებს, რომელთა მიზანია არ აწუხებს.
უბრალოდ ჩვენ ყველა აპირებს პრეტენზია მოსწონს ეს მხოლოდ ჩვენს გამყინვარება ამ ოთახში.
არ აწუხებს.
კითხვის ნიშნები არ არის ძალიან სულელური.
პასუხი არ არის სულელური პასუხი.
მე ალბათ აპირებს, რათა შეცდომები რა თქმა უნდა, ჩემი სწავლების.
სერიოზულად, ბიჭები, უბრალოდ ირჩევენ ის.
იყავით დარწმუნებული საკუთარ თავს, თქვენ იცით?
ასე რომ, რა იყო ეს?
ვინ თქვა, რომ ბოლო პასუხი?
OK.
Shout, რომ ლამაზი და ნათელი.
>> აუდიტორია: 32?
>> Andi Peng: 32.
OK, მოდით აწარმოებს ამ კოდი და თუ, რომ ის, რაც ხდება.
OK.
ასე რომ, როგორც თქვენ ბიჭები შეგიძლიათ სახის ვხედავ, ტიპიური notation მე
შეიქმნა აქ, როგორ უნდა დაასაქმოს რაიმე პროგრამა ჩვენს კომპიუტერში.
ჩვენ გვაქვს ჩვენი მთავარი ფუნქცია ჩვენს ძირითად ფუნქციას.
მე უბრალოდ აპირებს კოპირება და ჩასვით ეს ხაზი კოდი.
ასევე, ფრთხილად, როდესაც თქვენ ბიჭები გადაწერა და pasting კოდი.
ზოგჯერ გარკვეული ოპერატორები არ ჩასვით მეტი სწორად.
იმ შემთხვევაში, მინუს ნიშანი იყო, ფაქტობრივად, dash.
ასე რომ, კომპიუტერში არ აირჩიოთ it up.
ასე რომ, მე უნდა დაბრუნდეს და ფიზიკური გაიმეორეთ, რომ.
უბრალოდ ფრთხილად, როდესაც თქვენ ბიჭები აკეთებენ, რომ.
>> OK.
ჩვენ ვაპირებთ, რომ აწარმოებს ამ აქ.
ასე რომ, ჩვენ ვაპირებთ, რომ cd ჩვენი section2.
მე მოუწოდა ამ პროგრამის asciimath.
ასე მახსოვს, როდესაც ჩვენ აწარმოებს ნებისმიერი პროგრამა, ჩვენ გვინდა, რომ პირველი კომპილირება
გაშვებული ეს ჩვენი მიიღოს.
და მაშინ ჩვენ გვინდა, რომ რეალურად აწარმოებს პროგრამა აკეთებს dot-slash.
ასე რომ, ჩვენ ვაპირებთ ./asciimath.
>> მარჯვენა, იქ ჩვენ წავიდეთ.
და ჩვენ ვხედავთ, 32.
კარგად გაკეთდეს.
თქვენ იმსახურებთ ცალი კანფეტი.
Candy თქვენთვის.
ბოდიში.
ყველა უფლება.
OK.
ასე რომ, ჩვენ შეგვიძლია დავუბრუნდეთ ჩვენს მაგალითს აქ.
Aah, არ.
Aah.
OK.
მე უბრალოდ აპირებს, რომ შევინარჩუნოთ ის, რომ.
OK.
ასე რომ, როგორც თქვენ ბიჭები ხედავთ, ჩვენ შეგვიძლია გავაკეთოთ უამრავი ძალიან საინტერესო რამ,
ბევრი ძალიან მაგარი რამ, ბევრი ძალიან რთული რამ, მათ შორის
ASCII სიმბოლოები და ციფრები.
მას შემდეგ, რაც თქვენ მიიღებთ ქვემოთ ხაზი ხუთ, რომ ბევრი დაიცვას გასწვრივ.
ჩვენ არ ვაპირებთ წასვლა განყოფილების მეშვეობით.
მოგერიდებათ, თუ შეგიძლია, მიზეზი, ქაღალდზე
პირველი, რაც უნდა იყოს მაშინ, როდესაც შეყვანის ასეთი სიმებიანი ღირებულებებს.
მაგალითად, რომ ბოლო ხაზი, ჩვენ გვაქვს z--, რომელიც წარმოადგენს გარკვეული რიცხვი
a--, რომელიც ასევე წარმოადგენს გარკვეული რიცხვი პლუს 1 modulos 26
პლუს ამას.
>> თუ ბიჭები შეინახოს მოსმენით ამ გზით, თქვენ
შეიძლება იხილეთ ნიმუში ამუშავება როგორ ჩვენ მანიპულირების კოდი.
მე მაღალ, უაღრესად გთავაზობთ შემდეგ სექციაში ყველა თქვენგანს
ბიჭები წავიდეთ წინ და შეტანის იმ ყველა თქვენს კომპიუტერში
და რა სახის ციფრები გამოდის
და მსჯელობა, რატომ ვართ ხდება, რადგან თქვენს psets
ეს იქნება მართლაც მნიშვნელოვანია თქვენ უნდა გვესმოდეს,
რატომ გარკვეული ხდება.
ყველა ეს სლაიდები იქნება ონლაინ რეჟიმში.
ასე რომ, არ აწუხებს ცდილობს ფიზიკური ასლი ქვემოთ აღნიშნავს.
ყველაფერი ონლაინ რეჟიმში.
ეს სექცია თავად იქნება ონლაინ რეჟიმში.
ყველა ჩემი კოდის რომ მე გაშვებული იქნება ონლაინ რეჟიმში.
ჰო.
გსმენიათ მაინც გაქვთ შეკითხვა?
აუდიტორია: რა არის modulos?
Andi Peng: OK.
ასე რომ, modulo არის ოპერატორი, რომ აპირებს იყოს საკმაოდ მნიშვნელოვანია, რომ თქვენი ბიჭები ის pset
აქ.
ასე რომ, ისე, რომ ოპერატორები C და პროგრამირების მუშაობა
არის, რომ თქვენ რასაც გაყოფის სიმბოლოდ და modulus სიმბოლო,
რომელიც ისევე, როგორც პროცენტი ნიშანი.
>> ასე რომ, C, როდესაც თქვენ რიცხვი იყოფა რიცხვი ერთად ხაზი,
C აქვს ტენდენცია მინდა მოჭრილი off ყველა ათობითი ქულა,
იმის გამო, რომ მთელი სურს კონვერტირება რიცხვი.
ეს არ აპირებს მინდა იყოს ორმაგი ერთად bunch of ათწილადები ყველა მას შემდეგ.
>> ასე რომ, თუ 3 იყოფა 2, ის აპირებს შეწყვიტა 0.5 და მხოლოდ მოგცემთ 1.
ასე რომ, რაღაც უნდა იყოს ძალიან ფრთხილად, როდესაც თქვენ
ვაკეთებთ ნებისმიერი სახის მათემატიკის პროგრამირებაში, ის არის, რომ ნომრები თქვენ
არ შეიძლება ნომრები რომ თქვენ ფიქრი,
რის გამოც დამრგვალება თქვენს ბოლო pset იმდენად მნიშვნელოვანია.
>> Modulo გაძლევთ დარჩენილი.
ასე მაგალითად, თუ მე 3 modulo 2- ასე 3 პროცენტს ნიშანი 2-
ეს საშუალებას მისცემს თქვენ დარჩენილი, რომ.
ასე რომ, 3 იყოფა 2 1.5.
ეს არის 1 დარჩენილი 1.
ეს მოგცემთ 1, რომელიც არის დარჩენილი, რომ.
>> ასე რომ, როდესაც თქვენ ბიჭები მივდივართ მეშვეობით ASCII მაგიდა,
modulo დასრულდება მდე მიმდინარეობს ის, რომ ძალიან მნიშვნელოვანია,
და ჩვენ განვიხილავთ, რომ მოგვიანებით.
>> OK.
ასე რომ, ის, რაც არის საკმაოდ, საკმაოდ ახალი და საკმაოდ უნიკალური
რომ ჩვენ განიხილეს ამ კვირაში კონცეფცია, თუ რა არის მასივი.
ამიტომ მასივი პირველი ტიპის მონაცემთა სტრუქტურის
რომ ჩვენ ვაპირებთ ექმნებათ ამ კლასში.
ყველა მონაცემები სტრუქტურა არის გარკვეული თვითნებური,
ფაქტიურად რამ, როგორიცაა სტრუქტურა რომ ჩვენ, როგორც პროგრამისტების შევქმენით,
რომ ჩვენ ჩავდეთ კოდი, რომელიც შეიძლება შეიცავდეს სხვა ცალი კოდი.
>> ასე რომ, ამ თვალსაზრისით, მასივი ვფიქრობ, რომ ეს ფაილი კაბინეტი,
სადაც თუ გახსნა სხვადასხვა თაროები თქვენი ფაილი კაბინეტი,
თქვენ შეგიძლიათ თქვათ სხვადასხვა რამ.
მეხსიერება, მასივი უბრალოდ აკეთებს იგივე, რაც თქვენს კომპიუტერში.
თქვენ შეგიძლიათ სხვადასხვა blocks-- ჩვენ მოვუწოდებთ მათ indices-- მასივი.
ეს, ისევე, ბლოკი, თაროზე მეხსიერება
რომელიც ჩვენ შევქმენით თქვენი კომპიუტერი, რომელიც შეგიძლიათ შეყვანის
გარკვეული რამ სხვადასხვა ფართები.
>> ამრიგად მასივი, თქვენ ყოველთვის უნდა specify--
თქვენ უნდა მიუთითოთ გამოცხადების მასივი შემდეგ ფორმატში.
თქვენ აპირებს პირველი მითითებული მონაცემები ტიპის
რომ გსურთ შექმნათ მასივი.
თუ მინდა მასივი რიცხვებით, მე ვაპირებ დააყენა int უფლება არსებობს.
თუ მინდა მასივი სტრიქონები, მე ვაპირებ დააყენოს strings იქ,
სახელი თქვენი მასივი, და მაშინ თქვენ აპირებთ უნდა კვადრატულ ფრჩხილებში.
და შიგნით კვადრატულ ფრჩხილებში, თქვენ აპირებთ უნდა ზომა თქვენი მასივი.
>> ის, რაც ნამდვილად მნიშვნელოვანია გვახსოვდეს, როდესაც შექმნა კოლექტორები არის
ის, რომ ერთხელ თქვენ შექმნით მასივი, რომ ზომა არ შეიცვლება.
ასე რომ, თუ თქვენ იცით, რომ ახლა თქვენ გაქვთ მასივი ზომა 10,
თქვენ იცით, რომ მე ვაპირებ აქვს 10 საკნებში ფარგლებში ან 10 მაჩვენებლების ფარგლებში მასივი,
და ის არ აპირებს გაფართოებას ან შეამცირებს
არ აქვს მნიშვნელობა რა, და რომ იქ ამჟამად მხოლოდ 10 ბლოკები სივრცეში
გამოყოფილი თქვენს მეხსიერებაში, რომ შეგიძლიათ შეინახოთ 10 რამ, რაც არ უნდა თქვენ დააყენა.
>> ასე რომ, ამ გზით, მასივი მონაცემები ტიპის, მონაცემები სტრუქტურა, რომელიც არის მასივი
ძალიან განსხვავდება ზოგიერთი სხვა ჩვენ გამოგიგზავნით გააშუქებს მოგვიანებით ამ კურსს.
ჰო.
მაგალითად, თუ თქვენ სურდა შექმნა მასივი ზომა 3,
შეიცავს ცვლადები რიცხვი ოჰ, უკაცრავად, ერთი temperature--
და ტემპერატურა, საქართველოს რა თქმა უნდა, არის მთელი რიცხვი.
>> ასე რომ, ჩვენ შევქმნათ int, რომელიც არის მონაცემები ტიპის, რაც ჩვენ გვინდა შესანახად.
ჩვენ ვაპირებთ, რომ მოვუწოდო ამ ტემპერატურა გულისთვის ნომენკლატურა დასახელებისგან
ის, რომ ჩვენ ყველას გვესმის.
ჩვენ ვაპირებთ, რომ კვადრატულ ფრჩხილებში.
და ჩვენ გვინდა, სამი ნომრები.
ასე რომ, ჩვენ ვაპირებთ, რომ სამი შიგნით მას.
>> რაღაც რომ მართლაც მნიშვნელოვანია გვახსოვდეს,
ის არის, რომ კოლექტორები ნულოვანი ინდექსირებული.
ყველა იმას ნიშნავს, რომ თქვენ იწყება ინდექსი 0,
და თქვენ აწარმოებს მეშვეობით ზომა მასივი მინუს 1.
ასე მაგალითად, აქ ჩვენ აქვს მასივი ზომა 3.
ის აპირებს შეძლებს გამართავს სამი ღირებულებებს.
მაგრამ ციფრები themselves--, რომ ნომერი, მასივი, რომ ინდექსი,
მასივი, არის 0-დან 2.
ასე რომ, ბიჭები, იქნება ნამდვილად, ნამდვილად ფრთხილად, როდესაც თქვენ გადის თქვენი პრობლემები შეიქმნა
და ქმნის რაიმე სახის მასივი, იმიტომ, რომ ბევრი ჯერ ეს
ნამდვილად, ნამდვილად იცის, რომ.
მე რეალურად არ აქვს ინდექსი 3, რომ მე გაკეთებული მხოლოდ
გვაქვს მაჩვენებელი 2.
და თუ თქვენ ცდილობენ წვდომის მესამე ინდექსი,
ის იქნება, თუ რა არის მოუწოდა null terminator.
ის არ აპირებს რეალურად არსებობს მასივი.
და კომპიუტერი არ ვაპირებთ, რომ.
ასე რომ, ფრთხილად, როდესაც თქვენ წვდომის რამ მხოლოდ
იმისთვის, რომ თქვენ უნდა გვახსოვდეს რომ კოლექტორები არის ნულოვანი ინდექსირებული.
>> OK.
ასე რომ, პირველი მაგალითი არის მხოლოდ ერთი გზა შექმნის მასივი.
მეორე მაგალითი მაქვს ქვემოთ არის უბრალოდ ცალკე გზა
შექმნის რა არის იგივე მონაცემები სტრუქტურა, რომელიც ჩვენ მხოლოდ inputted.
ასე რომ, ნაცვლად ფიზიკური გაშვებული მეშვეობით და აყენებს ტემპერატურა 0
უდრის რასაც, ტემპერატურა 1 უდრის რასაც, ტემპერატურა 2 ტოლობის
რაც არ უნდა, შემეძლო რეალურად მხოლოდ პირდაპირ შექმნა ეს ყველაფერი ერთი ხაზი
შევიდა ტემპერატურა კვადრატულ ფრჩხილებში შეადგენს.
>> და შეამჩნია ამ შემთხვევაში, თქვენ არ უნდა დააკონკრეტა, თუ როგორ დიდი თქვენი მასივი,
რადგან კომპიუტერის აპირებს გავლა და ვხედავთ, რომ იქ
სამი ელემენტები იმ Curly braces.
და ის აპირებს, რომ ვიცი, OK, მე უნდა მასივი ზომა 3.
თქვენ არ აპირებთ უნდა შეყვანის შემდეგ გზა.
>> ასევე, yeah, რომ გზა.
ვინმეს აქვს კითხვები დაკავშირებით, თუ როგორ ჩვენ კოლექტორები
ან როგორ სტრუქტურა მასივი მუშაობს?
ჰო.
>> აუდიტორია: [INAUDIBLE]?
Andi Peng: ჰო, ზუსტად.
ასე რომ, თუ თქვენ ვაცხადებთ და ვრთავ მასივი შემდეგი მეთოდი,
რომელიც მეორე გზა, თქვენ შეგიძლიათ უბრალოდ დატოვონ იმ.
და კომპიუტერული ავტომატურად იცის, რომ ეს
საჭიროებს ითვლიან რამდენი ელემენტები არიან იმ Curly braces, გამოეყო
წერტილებით.
>> ასე რომ, აქ ისინი ხედავენ 65, 87, 30.
ასე რომ, კომპიუტერი იცის, oh, ეს არის სამი რიცხვებით.
მე ვიცი, რომ შევქმნათ მასივი სახელი ტემპერატურის სამი ელემენტები მას.
კარგი კითხვაა.
ჰო.
>> აუდიტორია: არის თუ არა შესაძლებელი, რომ შევქმნათ მასივი სხვადასხვა სახის მონაცემები
რომელიც შეიძლება შევიდნენ?
მაგალითად, რიცხვებით [INAUDIBLE]?
Andi Peng: მიზნებისათვის ამ კლასის, არ, ახლავე.
როდესაც თქვენ შექმნათ მონაცემთა სტრუქტურირებაზე როგორიცაა მასივი,
თქვენ ვეუბნებოდი კომპიუტერი, hey, მე უნდა
გამოყოს ეს ბევრად მეხსიერების ჩემს მყარ დისკზე,
თითოეულ საკანში მყოფი გარკვეული რაოდენობის ბიტი.
>> დამახსოვრება გავიგეთ კვირაში ნულოვანი რომ განსხვავებული მონაცემები
სახის გვაქვს სხვადასხვა ზომის?
ასე მაგალითად, სიმებიანი არის სხვადასხვა ოდენობის
სივრცეში, ვიდრე char, რომელიც არის სხვადასხვა ოდენობით სივრცეში
საწყისი რიცხვი.
ასე რომ, თუ თქვენ არ დააკონკრეტა და თქვენ ავურიოთ და ემთხვევა თუ რა სახის ცვლადები
თქვენ გაქვთ, კომპიუტერის იქნება ძალიან დაბნეული.
და ის არ აპირებს ვიცი რამდენი მეხსიერება გადმოგცეთ.
ასე რომ, იმ მიზნით, რომ უფლება ახლა, კომპიუტერები მხოლოდ
აღიარებს ერთი ტიპის მასივი.
კარგი კითხვაა.
OK.
>> ასე რომ, ბუნებრივია, მეორე კითხვა გვაქვს
არის, ასევე, რომ ჩვენ შევქმენით array და ჩვენ დააყენა ყველა ამ საკითხზე
მასივი, როგორ ვართ ჩვენ იქნება საშუალება, რათა შეამოწმონ ეს?
ასე რომ, ტიპური სტრუქტურა, რომ ჩვენ ყოველთვის წვდომის მასივი ჩვენი საყვარელი for loop.
მე გპირდებით, რომ ბიჭები რომ ჩვენ ვიქნებით ხედავს ბევრი ამ თანამემამულე აქ.
>> არსებითად, ნებისმიერ დროს გსურთ შეყვანის აფასებს მასივი
ან თქვენ გინდათ, მათ შორის, საუკეთესო გზა ამის გაკეთება არის ამისთვის მარყუჟის,
იმის გამო, რომ ამისთვის მარყუჟის, თქვენ ვიცი, რამდენჯერ თქვენ
აპირებს გსურთ აწარმოებს მეშვეობით მასივი, იმიტომ, რომ თქვენ გაქვთ გაჩერება გამოცემა, არა?
და ყოველ ჯერზე თქვენ აწარმოებს მეშვეობით, თქვენ შეგიძლიათ თქვათ
სხვადასხვა ელემენტს მასივი.
>> ასევე, ეს არის მიზეზი, რის გამოც, როგორც წესი, ჩვენ დავიწყებთ ჩვენი ამისთვის მარყუჟების at 0 ღირებულება,
იმიტომ, რომ, როდესაც თქვენ შედიხართ მასივები, თქვენ შეგიძლიათ თქვათ ნულოვანი ინდექსი.
ასე რომ, ეს პარალელები ძალიან ლამაზად.
თქვენ ბიჭები შეიძლება არ სურდა წერენ int i უდრის 1.
რომ ნაკლებია ან ტოლი 3.
>> მაგრამ ეს არ იმუშავებს საკმაოდ აქ კარგად, იმიტომ, რომ თქვენ მხოლოდ
ელემენტებს, 0, 1 და 2.
ასე რომ, თუ თქვენ უნდა დაიწყოს თქვენი i at ელემენტი 1, 2, 3
თქვენ აპირებს დასრულდება მდე მიმდინარეობს გარეთ ფარგლებში თქვენი მასივი,
და ცუდი რამ მოხდება.
>> ასე რომ, ვიმედოვნებ, რომ ბიჭები ნახოთ segue რატომ ადრე კატეგორიები
ჩვენ ასწავლის, თუ ბიჭები როგორ აწარმოებს და ფორმატის for loop გზა, რომ ჩვენ ვიყავით.
ეს იმიტომ, რომ, ახლა ჩვენ transitioned შევიდა მასივები,
თქვენ ხედავთ, რატომ 0 lends თავად ძალიან ლამაზად წვდომის.
>> ასე რომ გზა გავაკეთოთ, რომ ისაა, რომ მე ვარ უბრალოდ ბეჭდვის ის აქ გულისთვის
ბეჭდვა ეს.
მაგრამ მე მაქვს ჩემი placeholder, მძიმით.
და ფაქტობრივი წვდომის ნაწილი ხდება.
სახელი მასივი ეწოდა ტემპერატურა.
ასე რომ, ეს ტემპერატურა და i-ე ელემენტს მასივი.
>> ასე რომ, როგორც for loop გადის, ის აპირებს იწყება 0.
ის აპირებს ამობეჭდოთ 0th ინდექსი მასივი.
შემდეგ ის აპირებს ბეჭდვა პირველი ელემენტია.
შემდეგ ის აპირებს ბეჭდვა out მეორე.
და მაშინ ჩვენ ვაპირებთ, რომ დაარღვიოს.
ყველას ნათელი on როგორ რომ ხდება?
შესანიშნავი.
>> ყველა უფლება.
ასე რომ აქ გვაქვს გზა განაცხადა, რომ, თუ ჩვენ არ გვინდა,
მყარი კოდი შიგნით ჩემთვის, როგორც პროგრამისტი.
მე არ მინდა, რომ რეალურად ფიზიკურად ბოლო ყოველ ცალკეულ ელემენტს
ამ მასივი.
თუ მინდოდა ნაცვლად აქვს მომხმარებლის შეყვანის ღირებულებები,
რა არის საუკეთესო გზა ამის გაკეთება?
>> ისე, აქ მე შევქმენი ამ ლამაზი ფუნქცია,
რომელიც მე შეიძლება განაცხადოს მასივი.
ასე int scores-- მოდით უბრალოდ ვიტყვი, რომ ჩვენ გვსურს
მასივი, რომელიც გაიმართა შეფასება ყველა 18 სტუდენტების აქ ამ სექციაში.
მე ვფიქრობ, რომ ჩვენ მივიღეთ ცოტა 18-ზე მეტი ბავშვებს დღეს.
მაგრამ მაგალითად გულისთვის, მოდით უბრალოდ ვივარაუდოთ, რომ ჩვენ გვქონდა 18.
მე შექმნათ მასივი სახელი ქულები ტიპი int, რადგან ქულა, რა თქმა უნდა,
ნომრები.
და მე ვაპირებ აქვს 18 კვადრატულ ფრჩხილებში,
იმიტომ, რომ რამდენი სტუდენტები გსურთ შეძლებს შესანახად ქულით.
>> და გზა მინდა მოეყვანა მასივი, რომ მე
გაუშვით მეშვეობით ამისთვის მარყუჟის, საქართველოს რა თქმა უნდა, 0, ჩემი 0th ინდექსი.
და მერე 18 რომ ჩემი შეჩერების გამოცემა, იმიტომ, რომ იქ
18 ელემენტების მასივი.
და მაშინ მე ვაპირებ ამის printf, შეიტანეთ ანგარიში student-- იადა იადა იადა.
>> შეუძლია ვინმეს მითხრათ, რატომ აქ ვარ ბეჭდვის i პლუს 1 და არა მე?
ეს არის ერთგვარი შეასრულა კითხვაზე, ნამდვილად არ.
ეს არ არის რეალურად ფიზიკურად იმოქმედებს გაძღოლას კოდი.
ჰო.
>> აუდიტორია: [INAUDIBLE] 0?
Andi Peng: ჰო, ზუსტად.
ეს ცოტა უხერხულია ამბობენ, hey, თქვენ 0th სტუდენტი ამ კლასში.
ეს ცოტა უცნაურია.
ამიტომ ჩვენთვის, როგორც ადამიანები, ნამდვილად არ მოსწონს ვფიქრობ, თუ როგორ კომპიუტერები ვფიქრობ.
ასე რომ, მიუხედავად იმისა, რომ კომპიუტერული, ის შენახვის ღირებულებების
ამ 0-ე ინდექსი, როდესაც ჩვენ ადამიანები, ჩვენ ნამდვილად არ
მინდა ეხება საკუთარ თავს, როგორც ნულოვანი.
ასე რომ, როდესაც მე უბრალოდ ბეჭდვა, რომ, მე ვაპირებ ბეჭდვა და დაამატოთ
1 გულისთვის სიცხადე.
ასე რომ, როდესაც მე ბეჭდვა, მე ვაპირებ, რომ შეუძლია ბეჭდვა სტუდენტები 1 მეშვეობით 18.
ეს ფაქტობრივად არ აისახება გაძღოლას კოდი
არანაირად, სხვათა შორის, მე ბეჭდვა.
>> მაგრამ ფრთხილად, როდესაც თქვენ რეალურად წვდომის მასივი.
როდესაც ხედავთ ქულა i, შეამჩნია აქ მე ვარ
წვდომის 0th ინდექსი და არა 1 + 0- ან 1 + 1
ამ შემთხვევაში, ინდექსი ასე რომ რეალურად ნათელია.
ყველას სახის OK on როგორ ეს გადის
და ყოველი ინდექსი ვარ აყენებს მნიშვნელობა შევიდა მასივი
და ქმნის მასივი 18 ნომრები რომ მომხმარებლის აპირებს შეყვანის?
OK.
ზემოთ.
>> OK.
ჩვენ ახლა გადავიდეს ის, რაც საკმაოდ შესაბამისი ამ ცალი მითითებული, ისევე.
მე ვიცი, ლექცია, დავით ბოდიში, თქვენ კითხვა ჰქონდა?
>> აუდიტორია: შეგიძლიათ enlarge ეს?
>> Andi Peng: ჰო, მე სცადა.
მაგრამ მე არ ვიცი.
გარკვეული მიზეზების გამო, ამ მობილური PowerPoint
მართლაც არ მუშაობს კარგად არიან.
ასე რომ, ჩვენ უბრალოდ აპირებს რომ შევინარჩუნოთ ის მოსწონს ეს.
ყველა ეს იქნება ინტერნეტში.
უკაცრავად, ბიჭები.
ჰო.
OK.
>> ასე რომ, ჩვენ შეიძლება ასევე აქვს სიმები.
ასე რომ, თუ თქვენ ბიჭები რეალურად შეამჩნია მე ვიცი, Rob წავიდა ამ ლექცია
რომ მას did-- სიმებიანი არის რეალურად მხოლოდ მასივი გმირები,
თუ ფიქრობთ, რომ ეს, არა?
სიმებიანი სახელი ან წინადადება ან სიტყვა, არა?
>> მე რომ შევქმნათ string დაასახელა Andi-- მხოლოდ ჩემი სახელით, A-N-D-I.
თქვენ ფიქრობთ, რომ, როგორც მხოლოდ ერთი ცვლადი.
მაგრამ რეალურად, ეს ჩაიშალა შევიდა მხოლოდ მასივი სიმბოლო.
ასე რომ, ის მივიღე ხასიათი შენახული მასივი ღირებულება.
მას აქვს ხასიათი n ინახება მეორე ინდექსი და ასე შემდეგ და ასე შემდეგ.
>> ასე რომ, ამ გზით, ჩვენ რეალურად ამ სახის
სტრუქტურა მითითებული განათავსეთ ჩვენი სიმები.
ასე რომ, თუ მე უნდა შეყვანის სიტყვა "ჭამა", - ასე სიმებიანი სიტყვა ტოლია
მიიღოს სიმებიანი.
მე რომ შეყვანის სიტყვა "ჭამა", რომელიც ფიზიკურად, ისე, რომ ჩემი კომპიუტერი
შენახვის რომ სიმებიანი ჩემი მეხსიერება.
>> და თუ მინდოდა აწარმოებს მეშვეობით, რომ და ბეჭდვა, რომ out-- ისე შევიდა i
ნულის ტოლია, გახსოვდეთ, ლექცია, ჩვენ დაფარული რაღაც რომ ე.წ. strlen,
ან სიგრძეზე სიმებიანი.
იმის გამო, რომ მე არ იცით, თუ როგორ დიდი მასივი
ნებისმიერი მომხმარებლის inputting--
>> მაგალითად, მე inputted სიტყვა "ჭამა", და მე ვიცი,
რომ სამი სიმბოლო, არა?
ასე რომ, მე ვერ დააყენა სამი იქ და ყველაფერი კარგად იქნება.
მაგრამ თუ თქვენი მომხმარებლის შეყვანის რაღაც რომ სხვადასხვა რაოდენობით ღირებულებების,
თქვენ აპირებს ვერ შეძლებს ნამდვილად ვიცით, რომ როდესაც თქვენ პროგრამა თქვენი კოდი.
>> ასე რომ გზა, რომ ჩვენ გაუმკლავდეს ტესტის მინდა, რომ ის არის, რომ ჩვენ გვაქვს რაღაც
მოუწოდა strlen, რომელიც მხოლოდ ფუნქცია რომელიც გიჩვენებთ თუ რამდენი ხანი სტრიქონს.
ამიტომ strlen სიტყვა.
ჩემი სიტყვა ჭამა.
n უდრის strlen სიტყვა.
შეუძლია ვინმეს მითხრათ რა, რომ ღირებულება რეალურად არის აქ?
რას n წარმოადგენს სწორი ახლა, ამ მაგალითად, თუ მე მქონდა ჭამა?
>> აუდიტორია: 3.
>> Andi Peng: 3, ზუსტად.
ასე რომ, ჩვენ გვაქვს int i შეადგენს ნულოვანი, n შეადგენს 3, არსებითად.
და მე მიღებას აპირებს სანამ ეს ნაკლები 3i ++.
და ის აპირებს, რომ არსებითად წასვლა მეშვეობით და იგივე რამ.
ის აპირებს ამობეჭდოთ ყველა ღირებულება და მოგცემთ
E-A-T. უბრალოდ აღმნიშვნელი სხვადასხვა გზა წერის იგი.
ეს იქნება ძალიან სასარგებლო.
ჰო.
აუდიტორია: რა სარგებელი აყენებს ო ტოლია strlen სიტყვის შიგნით რომ
ამისთვის loop [INAUDIBLE]?
Andi Peng: ჰო.
ასე რომ, თუ მე, რომელთა მიზანია, მაგალითად, თუ მე უნდა გავაკეთოთ, რომ და შემდეგ
გავაკეთოთ oop--, რომ ჩემი კოდი, ის რომ რეალურად უნდა აკეთებს, როგორიცაა იგივე.
თუმცა, ისე, რომ მან ეს შემდეგნაირად ახსნა ის დროს ლექცია, თუ რომელიმე თქვენ ბიჭები
გვახსოვდეს, რომ, როგორც ადამიანები, როგორც პროგრამისტები,
ჩვენ ნამდვილად ვცდილობთ პროგრამა ჩვენი კოდი ისე, რომ ჩვენი კომპიუტერი
მუშაობა, როგორც მინიმალური, რაც შეიძლება, ისე, რომ ჩვენი კოდი არის ძალიან ეფექტური.
>> ასე რომ, თუ მქონდა, რომ იქ, რა მოხდება ჩემი for loop
ის არის, რომ მე პირველი განაცხადოს ცვლადი სახელად i იქნება 0.
მე ვაპირებ, რომ ნახოთ, oh, რა არის strlen სიტყვა?
ოჰ, strlen არის 3.
ასე რომ, მე ნაკლები სამი?
დიახ, ეს არის.
მე ვაპირებ აწარმოებს.
>> და მაშინ მეორედ უკან გარშემო მარყუჟის, მე ვაპირებ, რომ ნამატი i.
i იქნება ერთი.
და მე აპირებს შეამოწმოს, oh, მაგრამ რა არის strlen სიტყვა?
ოჰ, ეს სამი.
და იმას, რომ როგორც ჩანს, სახის არარაციონალური, ყოველ დროს, თქვენ აწარმოებს მეშვეობით მარყუჟის,
უნდა შემოწმების ფუნქცია, მიუხედავად იმისა, რომ strlen სიტყვა
არასოდეს რეალურად ცვლის?
>> ასე რომ, ეს დამატებითი ძალა კომპიუტერი.
როდესაც თქვენ დავიწყოთ საუბარი რამ რომ მილიარდობით
და მილიარდობით ადგილებში ხანგრძლივი, წარმოიდგინეთ, თქვენს კომპიუტერში
რომელსაც ფიზიკურად გავლა და შეამოწმეთ ყველა რომ თითოეული დრო.
სწორედ ამიტომ, რათა მხოლოდ გულისთვის ეფექტურობის,
ჩვენ, როგორც წესი, მხოლოდ ამის გაკეთება, იმის გამო, რომ ამ გზით ჩვენ მხოლოდ
მოუწოდებენ ფუნქცია კიდევ დასაწყისში,
და რომ ყოველ ჯერზე ეს გადის ის აპირებს
შენახვის ღირებულება 3 იქ, რომ თქვენ არ
უნდა მუდმივად შეამოწმეთ ყოველ ჯერზე.
ჰო.
>> აუდიტორია: უკაცრავად.
უბრალოდ [INAUDIBLE].
იქნებ არ int n შეადგენს strlen და რომ ზემოთ გარეთ ამისთვის loop
ისევე?
Andi Peng: ჰო.
თქვენ შეიძლება ამის გაკეთება, აბსოლუტურად.
მიზეზი ჩვენ ის აქ არის რადგან გზა ამისთვის loop სამუშაოები
ის არის, რომ ეს ე.წ. ადგილობრივი ცვლადი გრძნობა
რომ ყველაფერი თქვენ შექმნის შიგნით ამისთვის loop
მხოლოდ არსებობს შიგნით ამისთვის loop.
>> ასე რომ, ცვლადი მე მხოლოდ არსებობს იმ ფრჩხილებში.
აქ ცვლადები n ასევე არსებობს მხოლოდ იმ ფრჩხილებში.
ასე რომ, თუ თქვენ უნდა გამოვიყენოთ strlen of სიტყვა რამდენჯერმე ქვემოთ,
აბსოლუტურად საუკეთესო გზა უნდა გააკეთოს, იქნება გამოაცხადოს ის up დაბრუნება
ასე რომ თქვენ არ უნდა გავაკეთოთ, რომ ერთხელ.
ჰო.
აუდიტორია: რატომ გაქვთ ახალი ხაზი შემდეგ პროცენტს
ხედავს, თუ გსურთ, რომ ყველა წერილები შემდეგ იგი გამოყოფა?
>> Andi Peng: Oh, მინდოდა ბეჭდვა მათ თითოეული ხაზი.
არ აქვს მნიშვნელობა,.
ჰო, გაფორმებით.
ეს არის კარგი კითხვა, თუმცა.
ჰო, თუ მინდოდა ბეჭდვა ეს ყველაფერი მხოლოდ ერთი ხაზი,
მე არ აქვს ტირე.
OK.
ყველას კარგი?
OK.
ზემოთ.
>> ასე რომ, მე ვფიქრობ, რომ მე ვესაუბრე საკმარისი.
თქვენ ბიჭები თავის მხრივ აწარმოებს მეშვეობით კოდი და მეუბნებოდა, თუ რა არის არასწორი აქ.
სად არის bug?
ასე რომ, როგორც ხედავთ, მე გამოაცხადა ახალი მასივი ტიპის სიმებიანი დაასახელა კლასის.
და მე inputted Sam, Jess და კიმ შევიდა.
და მე მცდელობაში დაბეჭდვა ყველა ელემენტების მასივი.
შეუძლია ვინმეს მითხრათ, რატომ არის ეს აპირებს მომეცი პრობლემები?
მე მივცემ თქვენ ბიჭები 10 წამი ვიფიქროთ ამ.
>> OK.
ჰო?
>> აუდიტორია: მარცხენა ცენტრი უდრის 3 ან [INAUDIBLE]?
Andi Peng: მარჯვენა.
რამდენჯერ არის ეს, ფაქტობრივად, აპირებს მეშვეობით ამ loop?
>> აუდიტორია: ოთხი.
>> Andi Peng: ზუსტად.
ის აპირებს მეშვეობით ოთხჯერ.
ის აპირებს მეშვეობით 0, 1, 2, 3,
იმიტომ, რომ მათი ელემენტს i ნაკლებია ან ტოლი 3.
ეს არ შევწყვეტთ, როდესაც ის 2.
ის აპირებს შენარჩუნება აპირებს, სანამ ის ჰიტები 3.
და როგორც ვიცით, იქ მხოლოდ სამი ელემენტები ჩვენს ფაქტობრივი მასივი.
>> თუ ჩვენ ვცდილობთ მეოთხე ელემენტს ან ინდექსი 3,
თქვენ ვაპირებთ მოხვდა სადმე მეხსიერებაში, რომ არ არსებობს.
ეს მოუწოდა null terminator.
არაფერი არ იქნება იქ.
თქვენი კომპიუტერი არ აპირებს ძალიან ბედნიერი თქვენთან ერთად.
ჰო.
ვინმეს აქვს კითხვები თუ რატომ, რომ ხდებოდა?
ეს არის ის, საერთო ფართობი რათა თავიდან ავიცილოთ.
ჰო.
>> აუდიტორია: არა, არ არის პირველი ლღობას ასევე აქვს სიმებიანი 2?
Andi Peng: No.
ასე რომ, არსებითად, როდესაც თქვენ მიღების მასივი,
რომ bracket უფლება იქ, რომ რიცხვი ყველა
გეუბნება ის არის, თუ როგორ ბევრი ელემენტები მაქვს.
ეს რეალურად არ ვეუბნებოდი მე ინდექსების არაფერი.
ასე რომ, ამ შემთხვევაში, მე ვიცი, მე მინდა წერა სამ ადგილას,
სამი ფიზიკური ადგილებში გამართავს რასაც მინდა გამართავს.
ასე რომ, რატომ ნომერი სამი არის.
თუმცა, თუ მინდოდა რეალურად წვდომის,
თუ მინდოდა მეთქვა, printf კლასი bracket ნომერი, მაშინ
თქვენ აპირებს რეალურად დააყენა ფიზიკური ინდექსი არსებობს.
ჰო, კარგი კითხვა.
>> აუდიტორია: ასე რომ ფიზიკური ინდექსი უნდა იყოს [INAUDIBLE]?
Andi Peng: მე ბოდიში.
შეგიძლიათ საუბარი ცოტა?
>> აუდიტორია: ასე რომ ფიზიკური ინდექსი [INAUDIBLE] თითოეული ყუთები?
[INAUDIBLE]?
>> Andi Peng: ჰო.
ამიტომ, მე ვაპირებ დაბრუნდეს უფლება აქ.
წარმოიდგინეთ უფლება აქ.
ჩვენ გვყავს მასივი ზომა 3.
არსებობს სამი ადგილებში, როგორიცაა, ფიზიკური placeholders აქ.
მაგრამ ისინი დაასახელა 0, 1 და 2.
ასე რომ, თუ მინდოდა შეღწევის, ისე, რომ მე თქვათ მათ
არის printf, რაც მინდოდა აქ.
თქვენ უნდა ბეჭდვა გარეთ სახელწოდება,
იმიტომ, რომ მაშინ კომპიუტერი იცის, რა, მე უნდა გამოიყურებოდეს
ამ მასივი, რომ 0th ინდექსი.
ჰო.
მაგრამ ზომა არ იცვლება.
ზომა 3, მიუხედავად იმისა, თუ როგორ წარწერა მათ.
OK.
ყველას კარგი?
აუდიტორია: ასე რომ, ყოველ ჯერზე მე [INAUDIBLE]?
Andi Peng: OK.
ასე რომ, ამ შემთხვევაში, ჩვენ ნამდვილად არ მოხვდება იგი ახლა, რა თქმა უნდა.
მაგრამ ვიცი, რომ სიმებიანი, როგორიც მე განაცხადა, სიმებიანი არსებითად
მასივი სიმბოლო.
ასე რომ, თუ შევქმნათ მასივი სიმები, I ტიპის
მასივი მასივი გმირები, არა?
>> ასე რომ, ამ შემთხვევაში, იმიტომ, რომ მე მასივი სიმები,
თუ იყო შეტანის მართლაც დიდი სიტყვა, რომ ჯერ კიდევ იკავებს მხოლოდ ერთ სივრცეში,
იმიტომ, რომ ერთი სტრიქონი.
მაგრამ თუ თქვენ ფიქრი გმირები, რომ მასივი,
მაშინ რომ აღების ბევრი სხვა პერსონაჟი, ვიდრე ნებისმიერ სხვა სიტყვა
არიან.
ნამდვილად არ მნიშვნელოვანია ახლა.
მაგრამ ეს მხოლოდ ზოგადად როგორ მუშაობს.
>> OK.
ასე რომ, ეს არის ის, რაც მე გაძლევთ ამის გაკეთება ბევრი მეტი კურსი სემესტრი.
მე უნდა დაისვენოს ჩემი ხმა.
თქვენ ბიჭები უნდა სტიმულირება თავი.
ბევრი თქვენგანი ალბათ აქვს ძილის ახლავე.
მე შესაყვანი შემთხვევითი პრობლემები სადაც ჩვენ, როგორც კლასის ან თქვენ
პარტნიორი შემდეგ თქვენ ვაპირებთ გაატარონ რამდენიმე წუთის მსჯელობენ
შესახებ, თუ როგორ წავიდოდა შესახებ გადაჭრის ან შექმნის პროგრამა, როგორიცაა ამ.
>> ასე რომ, ახლა, ჩვენ გვინდა უნდა შეიქმნას პროგრამაში
ჩვენ ვაპირებთ, რომ ეძახით upper.c-- რომ გარდაქმნის
ამას სიტყვა ზედა კლასის სიმებიანი ზედა, ბოდიში.
სიტყვა სიმები, ბოდიში, არის სინონიმი.
მე ვაპირებ შეცვლას იმას ნიშნავს, რომ იგივე.
>> ჰო.
მიიღეთ რამდენიმე წუთში.
ეს არ უნდა იყოს ნებისმიერ ენაზე.
უბრალოდ pseudocode კოდი და ლოგიკურად როგორ ჩვენ გვინდა კიდევ
წავიდეთ შესახებ აკეთებს ასეთი პრობლემა.
ჰო.
>> [SIDE საუბრის]
>> მე ასევე შენიშნა, რომ თქვენ ბიჭები can-- მე სახის ვხედავ უკვე პროგრამა.
ვფიქრობ, ჩემი ნაკლებობა წამყვანის რეჟიმი არის პრობლემა.
მაგრამ ეს OK.
>> [SIDE საუბრის]
ჰო, გთხოვთ, ბიჭები.
მოდი მიიღოთ კამფეტი.
>> აუდიტორია: დიახ!
>> [SIDE საუბრის]
Andi Peng: გარდა ამისა, ვიცი, დავიწყებ სროლა candy
ადამიანები, რომლებიც არ უპასუხოს კითხვებს.
ასე რომ თქვენ უნდა ყველა კითხვას.
ან მე ვფიქრობ, ადამიანები, რომლებიც უპასუხეთ კითხვებს.
ჰო, პირიქით.
>> [SIDE საუბრის]
აუდიტორია: [INAUDIBLE]
>> Andi Peng: ჰო.
ჰო.
>> [SIDE საუბრის]
>> ყველა უფლება, ბიჭები.
მიიღეთ, როგორც, კიდევ 10 წამი.
>> [SIDE საუბრის]
>> OK, ბიჭები.
ასე რომ, სანამ ჩვენ ვიწყებთ ცდილობს რეალურად ფიზიკურად წერენ კოდი,
კარგი ჩვევა განვითარება არის ის, რომ ჩვენ გვინდა, რომ პირველი სახის მიზეზი
out ლოგიკურად როგორ უნდა გავაკეთოთ ეს.
თქვენ გვინდა დავრწმუნდეთ, სანამ ფიზიკურად
დაიწყოს ცდილობს კოდექსში Mario, რომ თქვენ მიიღოს
დარწმუნებული ვარ, რომ თქვენ გაქვთ თქვენი pseudocode.
რომ აღების თქვენ მეშვეობით ის, რაც თქვენ უნდა შექმნათ ასე
რომ, როდესაც თქვენ ფიზიკურად დაწერეთ თქვენი პროგრამის შემდეგ,
თქვენ უკეთ შეუძლია შეცდომების დაჭერა თქვენი კოდი და რამ, როგორიცაა, რომ.
>> ამიტომ, ჩვენ ვაპირებთ, რომ დავიწყო by-- ინგლისურ pseudocode,
ვინმეს გსურთ მისცეს ჩემთვის ზოგადი ახსნა
თუ როგორ წავიდოდა შესახებ ამით?
ჰო.
>> აუდიტორია: [INAUDIBLE].
Andi Peng: რა თქმა უნდა, არ აწუხებს.
აუდიტორია: შეგიძლიათ ვთხოვო მას ან ითხოვენ ვინმე მისაღებად სიმებიანი 1-- yeah, სიმებიანი,
და შემდეგ
>> Andi Peng: დიახ, ასე რომ ეს არის კარგი დასაწყისია.
დავიწყებ აკრეფით, ვწუხვარ, რადგან თქვენ საუბარი.
ასე რომ--
>> აუდიტორია: --The ამას ციფრები უფრო მაღალია, არა?
ან ამას წერილები აქვს მაღალი ნომრები?
Andi Peng: ზუსტად.
აუდიტორია: ასე შემდეგ ვაკლებთ 32 რასაც [INAUDIBLE].
>> Andi Peng: დიდი.
ასე რომ, ჩვენ სახის გაქვთ ზოგადად გრძნობა როგორ უნდა იმუშაოს ამ პრობლემის შესახებ.
იცის, რომ ჩვენ სახის ვისწავლეთ ფიზიკური, რომ სტრიქონები
ინახება მეხსიერებაში, რას უკვე
იცით, რომ თქვენ აპირებთ, ალბათ, უნდა დაწეროთ თქვენი კოდი
იმისათვის, რომ გადაადგილება მეშვეობით სიმებიანი?
>> აუდიტორია: loop.
Andi Peng: A for loop, ზუსტად.
შესანიშნავი.
ასე რომ, ჩვენ ასეთი აქვს generic pseudocode წერილობითი ქვემოთ
რომ სახის იძლევა თქვენ აღნიშნავს, თუ როგორ
გადაინაცვლებს შესახებ პრობლემის გადაჭრის.
ახლა, რომ თქვენ გაქვთ ეს, თქვენ შეგიძლიათ მითითებას მას მოგვიანებით
მაშინ, როდესაც თქვენ ცდილობთ რეალურად დაწეროთ თქვენი კოდი.
ასე რომ, ჩვენ შეგვიძლია რეალურად აქ.
და მაქვს ფუნქცია მოუწოდა upper.c-- იქ მას is-- მხოლოდ ერთი ცარიელი თარგი
ახლა, რომ თქვენ ბიჭები ვაპირებთ დამეხმარება გაერკვნენ, თუ როგორ დაწერა
ეს ხაზი კოდი არ ხაზი კოდი.
ეს იქნება სხვადასხვა ხაზების კოდი.
>> როდესაც დაწყებული ნებისმიერი სახის ცარიელი pset, რა არის
პირველი, რაც მე უნდა უნდა გვახსოვდეს, რომ გავაკეთოთ?
>> აუდიტორია: [INAUDIBLE].
>> Andi Peng: დიდი Yep.
ჩართეთ.
stdio.h.
ხშირად ეს არის ერთ ერთი ყველაზე მარტივი შეცდომები
გახდის, როდესაც ისინი წერა, არის ის, რომ ისინი ყველაფერს
უნდა დაგვავიწყდეს, რომ მოიცავს მნიშვნელოვანი ბიბლიოთეკა მათ სჭირდებათ.
ასე რომ, თუ ის ოფისში საათი და თქვენ, როგორიცაა, მე არ ვიცი, რატომ ჩემი კოდი არ მუშაობს.
შეგიძლიათ მითხრათ, რატომ არ მუშაობს?
ჩვენ ვაპირებთ, რომ ვთქვათ გქონდათ შეიცავდეს?
თქვენ უნდა შეიცავდეს იგი.
OK.
>> ამიტომ, ჩვენ მივიღეთ სტანდარტული I / O აქ.
ის არის, რომ ბიბლიოთეკა ჩვენ ვაპირებთ, რომ უნდა აქ?
რა ვართ აპირებს?
ბოდიში.
ვიღაცამ უბრალოდ ყვირილი ის?
>> აუდიტორია: [INAUDIBLE].
Andi Peng: იქ წასვლა.
OK.
და როგორ წავიდეთ შესახებ დაწყებული ნებისმიერი სახის ფუნქცია, ნებისმიერი სახის მთავარი ფუნქცია
ჩვენს პროგრამაში?
Int მთავარი.
OK.
რა შემიძლია დააყენა შიგნით აქ?
რა არის პირველი რაც თქვენ უნდა გავაკეთოთ?
თუ ჩვენ გვინდა სიმებიანი ეხლა შესახებ,
რასაც ჩვენ ვაპირებთ, რომ აქვს უნდა გავაკეთოთ ეს პირველი ხაზი?
ბოდიში, თქვენ ბიჭები უბრალოდ ვგრძნობ უფასო ლაპარაკი და ხმამაღალი.
უბრალოდ ყვირილი რასაც.
>> აუდიტორია: გააქვთ მომხმარებელი?
Andi Peng: როგორ უნდა გავაკეთოთ, რომ?
Ask-- ვარ მე ტიპის "ვთხოვ შესახებ"?
>> აუდიტორია: Printf.
>> Andi Peng: OK.
Printf.
რა გვინდა printf?
>> აუდიტორია: ტიპი რაღაც.
>> Andi Peng: მომწონს, რომ?
ბიჭები, თითქოს, როგორიც მე ვარ კომპიუტერი.
ფიზიკური მეუბნებოდა, ყოველი ნაბიჯი რომ მე უნდა აკრიფოთ აქ?
ვაკეთებ რაღაც?
თუ მე აკრეფილი რაღაც?
>> აუდიტორია: თქვენ უნდა შეთავაზებები.
>> Andi Peng: მე უნდა შეთავაზებები?
OK.
>> აუდიტორია: და მერე ახალი ხაზი.
მძიმით.
Andi Peng: მძიმით?
OK.
კარგი.
>> აუდიტორია: იქნებ მიუთითოთ რომ გსურთ იგი ამას?
>> Andi Peng: დიდი.
თქვენ ბიჭები დამცინიან დავიწყება დააყენოს მძიმით.
მე გაძლევთ გარანტიას, სადღაც რა თქმა უნდა, ამ კლასის,
თქვენ დაგავიწყდეთ დააყენოს მძიმით, და ეს
გადაგიყვანთ სამი საათის განმავლობაში უნდა გაერკვნენ გაირკვეს, თუ რატომ თქვენი კოდი არ მუშაობს.
ეს მოხდა ყველა ჩვენგანისთვის.
ეს ალბათ მოხდება.
მიიღეთ კარგი ჩვევა გამოყენებით semicolons.
OK.
>> აუდიტორია: გსურთ გავაკეთოთ წარმატებული წელს?
>> Andi Peng: რა თქმა უნდა.
გსურთ გააკეთოთ წარმატებული წელს?
>> აუდიტორია: დიახ.
>> Andi Peng: დიდი.
OK.
რა გავაკეთო შემდეგი?
>> აუდიტორია: მიიღეთ სიმებიანი.
Andi Peng: მიიღეთ სიმებიანი.
ასე რომ, რა ტიპის?
ვინმეს?
>> აუდიტორია: სიმებიანი s.
>> Andi Peng: სიმებიანი s.
აუდიტორია: GetString.
Andi Peng: Somebody, შეგიძლიათ მითხრათ, სადაც
ამ ფუნქციის GetString მოდის?
>> აუდიტორია: string.h.
>> Andi Peng: string.h?
თქვენ ფიქრობთ, რომ ეს from string.h?
>> აუდიტორია: [INAUDIBLE].
>> Andi Peng: იქ წასვლა.
ეს ეხლა cs50.h.
თუ თქვენ ყოველთვის დაბნეული, სადაც ბიბლიოთეკა ფაილი ან header ფაილი,
google ფაქტიურად string.h, და მე გეტყვით,
რა არის ყველა ის ფუნქცია რომლებიც string.h.
OK.
>> ასე რომ, ახლა, რომ მე შევქმენი სიმებიანი და მე უბიძგონ შესახებ მას,
მე ინახება ეს ცვლადი სახელად s, რა უნდა ქნას?
>> აუდიტორია: შეამოწმეთ თუ ამას.
Andi Peng: ბოდიში?
აუდიტორია: შეამოწმეთ თუ ამას.
Andi Peng ყველა უფლება, მოდით გავაკეთოთ.
როგორ შემიძლია ამის გაკეთება?
სინამდვილეში, იმ მიზნით, კლასის ახლავე,
ჩვენ უბრალოდ აპირებს ვივარაუდოთ, რომ ყველაფერი
რომ ჩვენ შეტანის უკვე ამას.
თუ უნდოდა, რათა შეამოწმოს, თქვენ აკეთებთ უბრალოდ დაამატოთ პირობითი განაცხადი
რომ შეამოწმეს, რომ გაიქცა მეშვეობით თითოეული მასივი ელემენტს
და შეამოწმა, თუ ის შორის გარკვეული ღირებულებები.
მე დაგვავიწყდეს, რა რაოდენობის ღირებულებები ამას არიან.
თქვენ შეგიძლიათ შეხედეთ ის ASCII მაგიდასთან.
მაგრამ ჰო, რომ არის ძალიან კარგი წერტილი.
მაგრამ ახლა, ჩვენ უბრალოდ აპირებს ვივარაუდოთ, რომ ყველა სიმები ჩვენ input
ვართ ამას.
OK.
>> ასე რომ, როგორ მივდივარ შესახებ ეს პრობლემა არის შემდეგი?
აუდიტორია: loop.
Andi Peng: For loop?
OK.
მითხარით, რა უნდა აკრიფოთ.
>> აუდიტორია: int i = 0.
>> Andi Peng: OK.
>> აუდიტორია: Oh, რეალურად, მაშინ თქვენ ამის მძიმით და ნუ ო შეადგენს strlen.
>> Andi Peng: ასე რომ, მთავარია, რომ მე ვფიქრობ, რომ ის შენიშნა აქ
ის არის, რომ ჩვენ არ უნდა ვთქვა, int n მეორედ ეს გავაკეთეთ.
უბრალოდ ვიცი, რომ ამისთვის loop როცა თქვენ გამოცხადების,
თქვენ ნამდვილად არ გვჭირდება int of მეორე, როცა ამის გაკეთება ცვლადი.
შეიძლება ითქვას, n strlen.
>> აუდიტორია: s.
>> Andi Peng: s.
OK.
>> აუდიტორია: მაშინ მძიმით.
>> Andi Peng: რა თქმა უნდა.
>> აუდიტორია: და მერე [INAUDIBLE] n.
მერე ++.
>> Andi Peng: დიდი.
ყველა უფლება.
რა გვინდა შიგნით ამ loop ახლა?
გახსოვდეთ, თუ ჩვენ ვაპირებთ აწარმოებს მეშვეობით სიმებიანი და აწარმოებს მეშვეობით მასივი,
ჩვენ გვინდა, რომ ნახოთ რამ იგი.
რას აპირებს უნდა?
ეს არის ერთგვარი სახიფათო ნაწილი ახლა.
ვინმეს აქვს ვხვდები?
>> OK.
ასე რომ, პირველი, თუ როგორ ჩვენ კი წვდომის?
როგორ ჩვენ კი პირველი გამშვები ან წვდომის ელემენტი მასივი?
როგორ უნდა გავაკეთოთ, რომ?
რა არის notation ვიყენებთ ამის გაკეთება?
რა სახელით ამ მასივი მოუწოდა?
ეს მოუწოდა, არა?
>> გახსოვდეთ, ნებისმიერი string ყოველთვის მასივი.
ასე რომ, s bracket i, არა?
იმიტომ, რომ მიმდინარე ღირებულება ან ინდექსის მნიშვნელობა ჩვენ შემოწმების.
და ჩვენ ვაპირებთ მითითებული, რომ თანაბარი რომელთა მიზანია ჩვენ გვინდა, ამას მნიშვნელობა, არა?
ჩვენ გვინდა, რომ იქცეს, რომ lower-- უკაცრავად, ჩვენ გვინდა, რომ ზედა.
ჩვენ გვინდა, რომ გახდეს ამას მნიშვნელობა შევიდა ზედა.
და ასე მოსწონს მე ვწუხვარ, რა გქვია?
>> აუდიტორია: Heidi.
>> Andi Peng: ბოდიში?
>> აუდიტორია: Heidi.
>> Andi Peng: Heidi.
ისევე როგორც ჰაიდი განაცხადა თავდაპირველად, ჩვენ, ალბათ,
აპირებთ უნდა the-- ჩვენ ალბათ აპირებს უნდა გამოვაკლოთ
32 რასაც charc რომ არის, უფლება?
იმის გამო, რომ წლის ASCII მაგიდა, განსხვავება
შორის ამას წერილი და ზედა წერილი 32.
ასე რომ, როდესაც ჩვენ ამით, ჩვენ, ალბათ, აპირებს გვინდა გამოვაკლოთ 32, არა?
>> ასე რომ, ჩვენ ვაპირებთ, რომ s i.
არა ყველას მესმის, რატომ გააკეთა ეს?
იმის გამო, რომ ახლა, ჩვენს მასივი, ჩვენ შემოწმების 0th ინდექსი, არა?
და 0th ინდექსი სიმებიანი, რომ პირველი ხასიათი.
და რომ ხასიათი, ჩვენ ვაპირებთ უნდა ვივარაუდოთ, რომ ეს ამას.
თუ ჩვენ გვინდა, რომ ის ზედა, ჩვენ უნდა გამოვაკლოთ 32 მისი ღირებულება,
იმიტომ, რომ ჩვენი ASCII მაგიდა, რომ, თუ ჩვენ მას
მომდევნო შესაბამისი მნიშვნელობა, რაც მას ზედა.
ამჯამად ყველას გვესმის, რომ?
ჰო.
>> აუდიტორია: იქნებ ასევე გთხოვთ ამას მინუს
>> Andi Peng: ჰო, ისე, რომ რეალურად ძალიან კარგი.
მე ვაპირებ დაბრუნებას, რომ კითხვა მას შემდეგ, რაც ჩვენ ამის გაკეთება.
ჰო.
და მაშინ, თუ მე მინდა ვნახოთ, რა ხდება,
მე ალბათ აპირებს გსურთ ბეჭდვა, უფლება?
ვინმეს მითხრათ რა მინდა ამობეჭდოთ აქ.
>> აუდიტორია: printf პროცენტი c წარმატებული [INAUDIBLE].
ეს არის ის, ღირებულება [INAUDIBLE] s i.
>> Andi Peng: s i, ბოდიში?
აუდიტორია: [INAUDIBLE].
Andi Peng: მე არ ვიცი.
რას ფიქრობთ?
>> აუდიტორია: ისე, მე wouldn't-- ვფიქრობ, მე არ bring--
მე მიიღოს იგი გარეთ შიგნით, რადგან [INAUDIBLE].
Andi Peng: Oh, თქვენ არ კეთდება, რომ?
აუდიტორია: Yeah.
Andi Peng: მოდით დატოვოს ის გზა ეს არის, და მე რატომ მოგვიანებით.
გახსოვდეთ, მაშინაც კი, როცა აქვს ადგილი მფლობელი,
გსურთ დააყენა ფრჩხილებში გარშემო.
ყველა უფლება.
ასე რომ, ეს უნდა იყოს მყარი ფუნქცია აქ.
მოდით გაუშვით და თუ იგი ადგენს.
ჩადება ზედა.
Uh-oh.
ეს არ გამოიყურება ძალიან კარგი.
რატომ ხდება ეს?
როგორც ნებისმიერი შეცდომა, გსურთ წავიდეთ უკან და იწყება პირველი,
იმიტომ, რომ, როგორც წესი, ერთი შეცდომა მიზეზები უამრავი სხვა შეცდომები მას შემდეგ.
აქ ჩვენ ვხედავთ, upper.c: 18: 25, რომელიც მოგვითხრობს მე ამ პროგრამაში სახელად upper.c,
on line 18, შეცდომა მინიშნებით გამოცხადების ბიბლიოთეკის ფუნქციები strlen ტიპი
unassigned-- blah, მე არ ვიცი, რა ხდება ამის შემდეგ.
>> ყველა ის მეუბნებოდა, რომ ახლა არის რომ რაღაც ხდება strlen.
კომპიუტერი და დაბნეული, რადგან ეს იგივეა, მე არ ვიცი, რა strlen არის?
რას რომელიც, სავარაუდოდ, გითხრათ თქვენ დაკარგული?
>> აუდიტორია: თქვენ აკლია [INAUDIBLE].
>> Andi Peng: თქვენ უფლება.
ზუსტად.
ასე რომ, ეს არის, სადაც ეს მნიშვნელოვანია, რომ დავრწმუნდეთ
რომ ყველა ფუნქცია თქვენ იყენებთ თქვენს კოდი აქვს სწორი header
ფაილი ბიბლიოთეკა, ანდა თქვენ აპირებთ მისაღებად უამრავი შეცდომები
და თქვენი კოდი არ აპირებს ვიცი, რა ხდება.
ასე რომ, ჩვენ ვაპირებთ, რომ მოიცავს string.h აქ.
>> ახლა, როდესაც ჩვენ ვცდილობთ შეადგინონ ზედა.
კომპილირდება სწორად.
მოდით აწარმოებს ამ პროგრამის.
ასე რომ, აკრიფოთ რაღაც ამას.
რას ბიჭები გსურთ შეიტანოთ?
ყვირილი რაღაც.
ყველა უფლება, Charly უბრალოდ დადიოდა.
ჩვენ აკრიფოთ Charly სახელი.
>> Charly ამას.
და იმედია, იმედია, ეს არის აპირებს ყვირილი და შამფურზე
Charly ზედა.
საზაფხულო!
ჯერ ყველას კარგად ესმის, თუ როგორ მივედი გადაჭრის, რომ?
ისე, რომ მე არ შემიძლია მანიპულირება გამოყენებით რიცხვებით
გადაწყვიტოს, რომ რაღაც მე მინდა, რომ სტრიქონები,
იმიტომ, რომ გმირები და რიცხვებით შეუძლია მითითებული იმ გზით, რადგან
of ASCII რუკების.
>> ასე რომ, უნდა დაბრუნდეს თქვენი აზრი, თუ მე მინდოდა, რომ აქ ნაცვლად 32
ზედა მინუს მხედრულ, ისევე, როგორც რომ, რომელიც იმუშავებს ერთნაირად ისევე,
იმიტომ, რომ ის, უბრალოდ, მხოლოდ განსხვავება ამ ორ ღირებულებას შორის.
თუ მე მინდა, რომ ეს ერთხელ charly.
Oh no.
მე ვფიქრობ, რომ ჩვენ წავიდა არასწორი გზა, არა?
>> აუდიტორია: [INAUDIBLE] ამას.
>> Andi Peng: იქ წასვლა.
Yep.
და გარეთ ფეხზე charly.
ასე რომ, ფრთხილად, როდესაც თქვენ ვაკლებთ ღირებულებები
უნდა გვახსოვდეს, რომელიც ერთი არის უფრო მეტი, ვიდრე სხვა.
მაგალითად, აქ დამავიწყდა რომ ამას რეალურად
უფრო მეტი, ვიდრე ზედა A. ასე რომ, როდესაც მე ცდილობდა სხვაობა მათ სხვა გზა
გარშემო, მე მივიღე უარყოფითი 32.
და ჩემი კომპიუტერი იყო, მე არ ვიცი, რა არის.
ეს ალბათობა რამოდენიმე შემთხვევითი ღირებულება, რომელიც არ არის ძალიან კარგი.
ასე რომ დარწმუნდით, რომ თქვენ გამოკლებით, სწორი სიგრძე
იპოვოს ხასიათი გსურთ.
OK.
არის ვინმე დაბნეული შესახებ, თუ როგორ წავიდა წერა ეს ფუნქცია?
OK.
ასე რომ, რეალურად, ფუნქცია უკვე არსებობს ბიბლიოთეკა მოუწოდა ctype.h.
ბიბლიოთეკის მოუწოდა ctype.h.
ეს ფუნქცია რეალურად არის უკვე დაწერილი თქვენთვის.
ეს ე.წ. ზედა.
>> ასე რომ, იმ მიზნით, ამ pset, თქვენ აპირებს
მოძიების, რომ თქვენ ნამდვილად გსურთ გამოიყენოთ ბევრი ფუნქციები შეიცავს
ფარგლებში ctype ბიბლიოთეკა.
ზედა, ქვედა, არის ზედა, არის lower-- იმ ყველა ფუნქციები
რომ თქვენ შეძლებთ გამოიყენოთ ძალიან, ძალიან სწრაფად საკუთარი კოდი, რომელიც
ზუსტად რა ეს იმას.
ჩვენ ვწერდით, თუ როგორ უნდა გარდაქმნას სიმებიანი ზედა.
მაგრამ ეს არის რეალურად კოდი რომ სხვისი დაწერილი
და რომ თქვენ შეგიძლიათ თქვათ მეშვეობით სხვადასხვა ფუნქცია.
ჰო?
>> აუდიტორია: ასე რომ თქვენ უბრალოდ დააკოპირეთ-ის იქ და ამას თითოეული წერილი?
>> Andi Peng: ჰო, იმიტომ, რომ მე არ აინტერესებს ღირებულებებს.
მე უბრალოდ მაინტერესებს, რომ განსხვავება მათ შორის არის 32, არა?
შორის განსხვავება ამას ბ და ზედა B ასევე 32.
და განსხვავება გ და ზედა C ყოველთვის 32.
>> მე უბრალოდ აინტერესებს განსხვავება ორ,
იმიტომ, რომ ყველა ასო მოჰყვება იგივე ნიმუში, არა?
თუ მე მაქვს განსხვავება შორის ერთ-ერთი მათგანი,
მე ვიცი, რა განსხვავებაა შორის ყველა მათგანი.
კარგი კითხვაა.
ჰო.
ყველას კარგი?
OK.
OOP.
>> OK.
ასე რომ კიდევ ერთი კონცეფცია, რომელიც არის იქნება ძალიან სასარგებლო, რადგან თქვენ
გააგრძელოს განვითარება თქვენი კოდი არის ეს იდეა
შექმნის ფუნქცია ან აბსტრაქცია.
ასე რომ, ახლა, ჩვენ ყველა მიღებული ალგებრა.
ალგებრაში, თქვენ ასწავლიან, რომ არ ეს მშვენიერი რამ მოუწოდა ფუნქცია
მანქანა, სადაც, თუ თქვენ შეყვანის ერთი სახის ნომერი,
ის გადის ამ შესანიშნავი ფუნქცია და გარეთ pops სხვადასხვა გამომავალი, არა?
კოდი, იგივე ხდება ნებისმიერი სახის ფუნქცია.
>> ასე რომ, შემეძლო ფიზიკურად წერენ ჩემი სხეული ჩემი კოდი
მთავარი განცხადებას, რომ რეალურად აკეთებს რასაც სხეულის კოდი აკეთებს.
მაგრამ გარეთ რომ, შემიძლია ასევე წერენ სხვადასხვა ფუნქციები
რომ ბევრი სხვადასხვა რამ.
მაგალითად, ჩვენ უკვე დაიწყო ზოგიერთი მათგანი.
Printf-- რომ არის ფუნქცია, რომელიც სხვისი
უკვე წერდა, რომ ჩვენ შეგვიძლია მოვუწოდებთ ჩვენს კოდი.
იმისათვის, რომ upper-- ამ შემთხვევაში, upper-- კიდევ ერთი ფუნქცია
დავწერეთ, რომ ჩვენ შეგიძლიათ დარეკოთ ჩვენს კოდი.
ასე რომ, ვფიქრობ, რატომ ჩვენ კი ფუნქციები?
რატომ არ გვაქვს უბრალოდ plop ეს ყველაფერი იგივე ხაზი კოდი?
რაც მას ადვილად ყველასთვის.
>> ისე, ლოგიკა, რომ ეს არის, პირველ რიგში, ორგანიზაცია.
ეს მართლაც შემაშფოთებელი აპირებს მეშვეობით ვიღაცის კოდი
და ერთი ფუნქცია printf.
თუ ბიჭები რეალურად იცოდა, რა ფუნქცია printf მოჰყვა დაწერა,
ეს, ისევე, როგორც 1000 ხაზების კოდი.
>> თუ ყოველ ჯერზე მე მინდოდა printf, რაღაც,
მე მქონდა დაწერა 1,000 ხაზი კოდი, რომ იყოს მართლაც შემაშფოთებელი, რომ წავიკითხე,
არა?
სწორედ ამიტომ ჩვენ მხოლოდ ის ამ აბსტრაქტული ფუნქცია
რომ ჩვენ გვაქვს უკვე ვინმე სხვა დაწერილი სხვაგან.
და ყოველ ჯერზე ჩვენ უნდა გამოვიყენოთ ეს ჩვენი კოდი, ჩვენ უბრალოდ უნდა ვთქვა printf.
და რომ შეუძლია გამოიყენოთ ფუნქცია ვინმეს არ გაუკეთებია ჩვენს კოდი.
ეს ხდის ადვილი ორგანიზაციულად წაკითხვის კოდი.
>> მეორე, ეს არის გამარტივებას.
ეს ამარტივებს ნაბიჯები ჩვენ მიიღოს გადაჭრას ჩვენი პრობლემა.
Printf, ფუნქციების მსგავსად printf, ფუნქციები, როგორიცაა ზემო
ყველაფერი, რაც საშუალებას გვაძლევს გავიმარტივოთ კოდი ქვემოთ ასე უფრო ადვილია.
და ბოლოს, რაც reusability.
>> ასე რომ ის ფაქტი, რომ ჩვენ გვაქვს ფუნქცია მოუწოდა printf
შეგვიძლია ვუწოდოთ სხვადასხვა ჯერ და საშუალებას, რომ იყოს მრავალჯერადი.
თუ მე უნდა დამეწერა printf, მე მხოლოდ დაწერა ერთხელ.
იგი არსებობს მხოლოდ, რომ ერთი ადგილი.
თუ მინდოდა ამის გაკეთება კიდევ ერთხელ, მე უნდა დააკოპირეთ და ჩასვით ყველა რომ
ჩემს მეორე ხაზი კოდი.
სწორედ ამიტომ, თუ ჩვენ შევქმნით ფუნქცია რომ არსებობს გარეთ ჩვენი მთავარი,
ჩვენ შეგვიძლია მხოლოდ მოუწოდებენ და reuse ეს მაშინ, როდესაც
ჩვენ გვჭირდება ისე, რომ ბევრი ადვილია ჩვენთვის, როგორც პროგრამების დაწერა.
>> ასე რომ გზა, რომ ჩვენ რეალურად დაწეროს ფუნქცია არის ძალიან ჰგავს, არა?
ეს არის ერთგვარი პირველი მაგალითად, რომელშიც ჩვენ
იხილეთ ფუნქცია იღებს სტილი განსხვავებული, ვიდრე ჩვენი int ძირითადი ბათილად.
ამ შემთხვევაში, თუ მინდოდა, დაწეროს ფუნქცია უწოდა q, არა?
>> და int მნიშვნელობა აქ არის ყველა მეუბნებოდა,
რა მინდა ამ ფუნქციონირებს დაბრუნებას მე?
თუ მინდა კუბი რიცხვი, მე ვაპირებ გვინდა შეყვანის.
ეს არის პარამეტრებს.
მე ვაპირებ საშუალებებით მნიშვნელობა ტიპის int.
და მე ვაპირებ დაბრუნებას სხვა ტიპის ღირებულება int.
და აქ, როგორც თქვენ ხედავთ, ყველა მე ვაკეთებ
არის cubing რასაც ჩემი შეყვანის როგორც ჩემი გამომავალი და დაბრუნების იგი.
>> ასე რომ, ყველა ამ ფუნქციის არ არის იღებს გარკვეული რიცხვი.
ეს multiplies ეს თავისთავად ორჯერ ისე, რომ იგი კუბურები ეფექტი.
და მაშინ ის დააბრუნებს რასაც გამომავალი.
ასე რომ, ამ შემთხვევაში, ეს ორი ხაზი კოდი, რომელიც ჩვენ უნდა დაწეროს დამატებით.
მაგრამ თუ ჩვენ მინდოდა დარეკვა საფუძველზე ამ რამდენჯერმე,
ეს არის ბევრი ადვილია შეიტანოთ, რომ ერთი ხაზი აქ, რომ ის cube, ვიდრე
უნდა გაიაროს რამდენჯერმე.
>> ასე რომ გზა, რომელიც არსებითად ნებისმიერი გაფორმებით ნებისმიერ ფუნქცია
აპირებს არსებობს ჰგავს აქ.
ასე რომ, ჩვენ აქვს ფუნქცია სახელი.
ამ შემთხვევაში, ეს ე.წ. კუბი.
ჩვენ დაარქვით cube, რადგან ეს ადვილად დასამახსოვრებელი.
შეგიძლიათ დაასახელოთ ის მოედანზე და ეს შეიძლება რეალურად იყოს კუბში.
მნიშვნელობა არ აქვს.
მხოლოდ სახელი, რომ თქვენ მინიჭების თქვენი ფუნქცია.
>> ეს უფლება აქ, int, არის ტიპის პარამეტრი გჭირდებათ.
ასე რომ, რას ნიშნავს ეს ფუნქცია გინდათ მუშაობას?
ისე, მას სჭირდება შეყვანა.
დაასახელა ის შეყვანა.
შეგიძლიათ დაასახელოთ ის რაც გსურთ.
მაგრამ მე უნდა რაიმე ტიპის int.
ის აპირებს რეალურად შეასრულოს რაც შიგნით აქ,
ორგანოს ფუნქცია.
და მაშინ დაბრუნების ტიპის სწორედ აქ, ამ გაკეთება int
ყველა ის მეუბნებოდა, რომ არის რომ ეს ფუნქცია
დაბრუნებას აპირებს ჩემთვის int.
ასე რომ, ის აპირებს მიიღოს int, და ის აპირებს მოგცემთ უკან int.
ამჯამად ყველას გვესმის, თუ როგორ გაფორმებით ამ სახის სამუშაოები?
ზემოთ.
>> OK.
ასე რომ არ იყოს შეშფოთებული, თუ ეს, როგორც ჩანს, ცოტა აბსტრაქტული ახლავე.
ეს არის ის, რომ ჩვენ ვსაუბრობთ.
ჩვენ ჩაყვინთვის უფრო ღრმა მოგვიანებით, რა თქმა უნდა.
ისე, რომ ნებისმიერ მაღალ დონეზე აბსტრაქცია ამ საკითხზე მუშაობა
ის არის, რომ, მეხსიერება, და თქვენს კომპიუტერში, ყველაფერი
ინახება ამ ტიპის დასტის, უნდა ვთქვა.
>> ასე რომ, იქ ზედა.
მე არ ვიცი, თუ ბიჭები ვხედავთ, რომ კარგად.
ვეცდები, რომ მიუახლოვდით.
აქ ზედა, ჩვენ აქვს ფიზიკური ტექსტი
რა კომპიუტერი interpreting-- ყველა zeros და პირობა, რომ
არსებობს ჩვენს კომპიუტერში.
და მაშინ ჩვენ ინიციალიზაცია მონაცემები და uninitialized მონაცემები,
რაც ჩვენ მოვუწოდებთ გლობალური ცვლადები.
ასე რომ ცვლადების, რომ არსებობს მთელი პროგრამები
და მთელს თქვენს მთელი, არსებითად, კოდი.
არ აწუხებს თუ ბიჭები არიან სახის გაურკვეველია ამ.
ეს ნამდვილად არ აქვს მნიშვნელობა ახლა.
>> და მაშინ ჩვენ გვაქვს რა არის მოუწოდა ბევრი Stack.
წარმოიდგინეთ დასტის სიტყვასიტყვით ისევე, როგორც დასტის რამ,
დასტის სხვადასხვა რამ აიძულა თავზე
ერთმანეთს რომ შესანახად სხვადასხვა ცვლადები და სინტაქსი თქვენი კოდი.
და მერე აქ ძალიან ბოლოში, ჩვენ გვაქვს გარემოს ცვლადები
რას შესრულებაში ფარგლებში მხოლოდ თქვენი პატარა ხაზი კოდი.
>> და ჩვენ უბრალოდ აპირებს მასშტაბის ამ ფაქტობრივი დასტის ნაწილი.
ასე რომ სწორედ აქ, თუ ჩვენ, რომ გაადიდოთ წელს მხოლოდ ამ სფეროში დასტის,
ეს არის ის, რაც ჰგავს.
და ეს არის რეალურად საკმაოდ მნიშვნელოვანი როდესაც თქვენ ბიჭები საუბრობენ ფუნქციები,
იმიტომ, რომ ცნობა, რომ მეხსიერების თქვენი კომპიუტერის
შენახვის ცვლადები და ფუნქციები
და პარამეტრების როგორც თქვენი ფუნქცია და თქვენი ძირითადი ცვლადები
სხვადასხვა ადგილებში.
>> ასე რომ, ახლა, მთავარი არის ფაქტობრივი ფუნქცია
რომ თქვენ აღასრულებს კოდი.
თქვენ არ მისი პარამეტრების ინახება აქ და მისი ადგილობრივი ცვლადები ინახება აქ.
ადგილობრივი ცვლადი მხოლოდ იმას ნიშნავს, ნებისმიერი ცვლადი რომ არსებობს მხოლოდ, რომ ფუნქცია.
და თავზე ის, რომ თქვენ გაქვთ ეს ცალკე ფუნქცია მოუწოდა კუბი.
თქვენ უნდა, რომ პარამეტრების ისევე, როგორც იმ ადგილობრივები.
>> და მიზეზი შეგიძლიათ ვხედავ აქ არის ის, რომ ის, რაც
ხდება, როდესაც კუბი იღებს მნიშვნელობა მთავარი ფუნქცია
ის არის, რომ რეალურად ის გადაწერა, რომ დასრულდა.
ასე რომ, თუ მინდოდა კუბი 2 და დაბრუნდეს 8, რომელიც 2
რეალურად inputted როგორც პარამეტრი და ეს
გადაწერა დასრულდა ისე, რომ თქვენ გაქვთ ეს არსებული ორ სხვადასხვა ადგილას მეხსიერებაში.
და თქვენ უნდა იყოს ძალიან ფრთხილად on დამახსოვრების რომელიც ერთ-ერთი იმ
თქვენ რეალურად მანიპულირება.
და მაგალითად, თუ რა მოხდა ეს იქნება ძალიან, ძალიან ცუდი
არსებობს აქ.
>> ასე რომ, აქ, მე მაქვს, თეორიულად, პროგრამა სწორედ აქ, მთავარი ფუნქცია
რომ მე გამოცხადების int x უდრის 1.
მე გამოცხადების მეორე int y უდრის 2.
და მაშინ მე გაშვებული ეს მეშვეობით, ამ ფუნქციის
მოუწოდა swap, სადაც მე ვივარაუდოთ, რომ ეს შევცვალე ორი ღირებულებებს.
და მაშინ მე ვაპირებ ბეჭდვა მათ, არა?
ეს არის ის, რაც მე მინდა ეს პროგრამა უნდა გააკეთოს.
>> მოდით, ქვემოთ და შევხედოთ.
ასე რომ, თუ რეალურად დაწეროს სხვადასხვა ფუნქცია, როგორც ხედავთ,
ჩვენ გვაქვს ჩვენი მთავარი ფუნქცია აქ.
და მაშინ ჩვენ გვაქვს ჩვენი მეორე ფუნქცია აქ.
ძალადაკარგულად გაცვლა.
ბათილად მხოლოდ იმას ნიშნავს, რომ ეს დაბრუნებას არ აპირებს არაფერი.
ფუნქცია სახელი მოუწოდა swap, და ეს
აპირებს მიღება ორი ცვლადის, int a და int ბ, თქვენი [INAUDIBLE] ფუნქცია.
>> ასე რომ, არსებითად, აქ, ჩვენ გავლის x და y ამ ფუნქციას.
და თუ ჩვენ შექმნა ამას ასე რომ ჩვენ გვინდა
შექმნას დროებითი ღირებულება, არა?
ჩვენ ვაპირებთ, რომ დაავალოს, რომ ა.
და შემდეგ აპირებს ახლა თანაბარი ბ.
და ბ იქნება უკან სადაც temp ღირებულება,
რომელიც არის, რადგან, როდესაც გსურთ სვოპ რამ,
თქვენ არ შეგიძლიათ უბრალოდ მინდა სვოპ მათ.
>> თქვენ უნდა შევინარჩუნოთ ერთი აქ, ასე რომ მას ახსოვს
რა არის, იმიტომ, რომ ერთხელ თქვენ სვოპ ერთი, თქვენ დაგავიწყდებათ
რა, რომ ორიგინალური ღირებულება იყო, არა?
ამ თეორიის მიხედვით, ამ პროგრამის უნდა ვიმუშაოთ, არა?
თუ მინდოდა, რომ სვოპ ორი, მათ უნდა სვოპ.
მოდით აწარმოებს და თუ მუშაობს.
>> ასე რომ, როგორც თქვენ ბიჭები ხედავთ, x ოდესღაც 1 და Y კიდევ 2.
და თუ მე ამობეჭდოთ, x კვლავ 1 და Y არის 2.
Hmm, ეს პროგრამა არ ჩანს, სამუშაო ისე, რომ მე მინდა, რომ ეს მუშაობა.
ვინმეს სურს მიიღოს ესროლეს გამოცნობა, რატომ ხდება?
ეს უნდა გააკეთოს გზა რომ სხვადასხვა რამ არის
ინახება სხვადასხვა ადგილებში მეხსიერებაში.
>> OK.
ასე, რომ თქვენ ბიჭები არ უნდა ფიქრი ძალიან ბევრი ამ ახლავე.
მაგრამ ვიცი, რომ კუბი ადგილობრივი ცვლადები იყო და ბ,
იმიტომ, რომ აქ ჩვენი ფუნქცია, ჩვენ განაცხადა და ბ
როგორც ცვლადი, რომ არსებობს ფარგლებში cube, რომ ფუნქცია.
მაგრამ, როგორც ხედავთ, პარამეტრების, რომელიც ის აღების მიმდინარეობს ინახება აქ.
მაგრამ ჩვენ არ ვიყავით რეალურად დაბრუნების არაფერი.
ჩვენ არ რეალურად შეცვლის x და y.
ჩვენ უბრალოდ იცვლება და ბ.
>> გადმოვიწერეთ x და y შევიდა რაღაც მოუწოდა და ბ.
მაგრამ ჩვენ არასოდეს რეალურად მანიპულირება x და y თავს.
ხართ თუ არა ბიჭები ხედავს როგორ რომ ხდება?
არის, რომ ჩვენ უბრალოდ გადმოწერილია მეტი, მაგრამ ჩვენ არ რეალურად ინახება
სიმღერა, სადაც მათ მეხსიერებაში.
>> ასე რომ, ახლა კომპიუტერი ეძებს, oh, მე
აწარმოებს ამ რამ მეშვეობით ამ ლამაზი ფუნქცია.
მაგრამ x და y კვლავ x და y.
არაფერი მოხდა მათ იმ ფაქტის გამო,
რომ იმ პარამეტრების და ადგილობრივი ცვლადები
ინახება სხვადასხვა განათავსეთ მეხსიერებაში.
და ეს არის უმაღლესი დონის კონცეფცია, რომელიც ჩვენ გამოგიგზავნით
დაიწყოს ხედავს მოგვიანებით, რა თქმა უნდა.
მაგრამ ვიცი, რომ ეს არის პრობლემა, რომელიც შეიძლება მოხდეს
და რომ ჩვენ გაერკვნენ გზა, თუ როგორ უნდა გაუმკლავდეთ ამ მოგვიანებით, რა თქმა უნდა.
OK.
ყველა უფლება.
ასე რომ, ბოლო კონცეფცია ჩვენ ნამდვილად დაფარავს
რომ იქნება სასარგებლო ამისთვის pset ამ კვირაში
არიან რა ეწოდება ბრძანების ხაზი არგუმენტები.
ასე რომ, რობ მისი ლექცია გაიარა სახის მოკლედ, თუ როგორ ეს მუშაობა.
არსებითად ვიცი, რომ როდესაც თქვენ წერა
ისევე როგორც მთავარი ფუნქცია, როდესაც ჩვენ წერდა ფუნქციები ადრე წარსულში,
ჩვენ გვქონდა int ძირითადი ბათილად.
და მიზეზი გვქონდა ბათილად არ იყო, რადგან ჩვენი პროგრამები არ
უნდა შეყვანის ღირებულებები აწარმოებს, უფლება?
როდესაც მე გაიქცა Mario, მე არ უნდა რეალურად მხოლოდ ჩაწერეთ რაღაც
როდესაც მე გაიქცა Mario.
მე ვერ უბიძგონ შესახებ მოგვიანებით.
მაგრამ ეს ყოველთვის არ იყოს საქმე.
>> მაგალითად, ამ კვირის პრობლემა კომპლექტი,
თქვენ იქნება სთხოვა, რომ გარდა გაშვებული თქვენი პროგრამა,
თქვენ აპირებს მინდა შეყვანის გარკვეული რამ სწორი, როგორც თქვენ
აწარმოებს თქვენი პროგრამის.
ასე რომ გზა გავაკეთოთ, რომ ე.წ. ბრძანების არგუმენტი, რომელიც
არის როგორც არგუმენტი შეგიძლიათ შეყვანის პირდაპირ
როგორც თქვენ ცდილობენ აწარმოებს თქვენი პროგრამის.
>> ასე რომ, notation ამ, ეს არის საკმაოდ რთული, ლამაზი,
მაგრამ ეს ნამდვილად არ არის, რომ რთულია. ასე int main--
ეს მხოლოდ თქვენი მთავარი ფუნქცია.
Into argc მძიმე სიმებიანი argv ფრჩხილებში.
ასე რომ, ყველა, რომ ვამბობ, არის ის, რომ ამ int argc-- ყველა რომ გეუბნება
ის არის, რომ ეს არის ნომერი არგუმენტები კომპიუტერი უნდა ველოდოთ.
>> ასე რომ, ერთი რამ, რომ ნამდვილად მნიშვნელოვანია, რომ შევინარჩუნოთ სიმღერა
ფიზიკური სახელი თქვენი პროგრამა იმედი აქვს, როგორც ერთ-ერთი იმ არგუმენტებს.
ასე რომ, თუ მინდოდა ჩემი პროგრამა აწარმოებს დამატებული command line
არგუმენტი, მე რეალურად აპირებს აქვს ორი.
Argc რეალურად იქნება ორი.
და შემდეგ სიმებიანი argv bracket-- ყველა რომ აკეთებს,
ეს მაძლევს მასივი სტრიქონები, რომ
ვაპირებ უბრალოდ არიან და ჩაწეროთ რა ყველა იმ ბრძანების ხაზი არგუმენტები.
>> ასე მაგალითად, თუ მინდოდა ეს პროგრამა, ./copy infile outfile, არა?
ეს უბრალოდ ტიპიური Linux ბრძანება.
რა არის argc?
რამდენი ბრძანების არგუმენტები არსებობს ფაქტიურად ამ?
ყველა ეს არ არის, რათა ასლი infile სახელით ერთი ფაილი
და ეს აკოპირებს კიდევ ერთი ფაილი, არა?
ეს არის ის, რომ ყველა ამ აკეთებს.
როგორც ხედავთ, მე ვაკეთებ ერთ ხაზს გარეშე რეალურად სჭირდება პროგრამა.
>> რა არის ჩვენი argc ამ ​​შემთხვევაში?
რამდენი არგუმენტები გვაქვს?
აუდიტორია: სამი?
Andi Peng: ჩვენ სამი, ზუსტად.
ასე რომ, ეს ძალიან ინტუიციური უბრალოდ ვფიქრობ, რომ ეს მხოლოდ
infile და outfile.
მაგრამ ვიცი, რომ ფიზიკური სახელი პროგრამა თქვენ გაშვებული ითვლის როგორც ერთი.
ასე რომ, ამ შემთხვევაში, argc ფაქტიურად სამი.
როგორ შესახებ, თუ რა არის argv 0?
გახსოვდეთ, რომ ყველა ბრძანების ხაზი არგუმენტები
ინახება მასივი სტრიქონები.
ასე რომ, თუ ცდილობენ, რათა შეამოწმონ ის, რაც რომ argv bracket 0 მომეცი?
>> აუდიტორია: [INAUDIBLE].
Andi Peng: ზუსტად.
ეს მაძლევს dot სლეში ასლი, იმიტომ, რომ ის
0th ელემენტის, პირველ ელემენტს ჩემი მასივი.
რაც შეეხება argv 1?
>> აუდიტორია: infile.
Andi Peng: infile, ზუსტად.
რაც შეეხება argv 2?
აუდიტორია: outfile.
Andi Peng: outfile.
ეს არის ცოტა სახიფათო ახლა.
რას ბიჭები ვფიქრობ argv 3 იქნება მაძლევს
თუ მე შევეცადე ბეჭდვა, რომ გარეთ?
>> აუდიტორია: [INAUDIBLE]?
>> Andi Peng: ხომ არ აქვს ხელი?
ჰო.
>> აუდიტორია: ალტერნატიული.
>> Andi Peng: ზუსტად.
ასე მახსოვს, ლექცია, რომ ჩვენ აქვს ბოლოს რასის რაღაც
მოუწოდა null terminator?
ჩვენ შეღწევას ეს ასევე შემდგომი კლასში.
მაგრამ ვიცი, რომ notation, გზა თქვენს კომპიუტერში
იცის, რომ ბოლოს მასივი არის ის, რომ
აყენებს რაღაც მოუწოდა null terminator ან dash ნულოვანი.
>> ასე რომ, თუ თქვენ ცდილობენ, რათა შეამოწმონ argv 3, თქვენ ვაპირებთ მოხვდა ამ dash 0.
ეს არის კიდევ უფრო შეასრულა კითხვაზე.
რაც შეეხება argv 4?
ასე რომ, ეს არის წარსული null terminator, წარსულში ფარგლებში ჩვენი მასივი.
რას ფიქრობთ აპირებს მოხდეს, როდესაც ჩვენ ვცდილობთ, რომ?
>> აუდიტორია: [INAUDIBLE]?
Andi Peng: ბოდიში?
ამბობენ, რომ ცოტა ხმამაღალი?
>> აუდიტორია: [INAUDIBLE].
Andi Peng: დიახ.
ეს არის სახელი ფართობი თქვენ სავარაუდოდ.
მაგრამ ვიცი, რომ argv 4-- რომელიც საშუალებას გაძლევთ ხელმისაწვდომობის
ადგილები თქვენი კომპიუტერის მეხსიერება, რომ თქვენ ნამდვილად
არ უნდა ეხება, რადგან ახლა თქვენ იცით, რა argv არის.
თქვენ იცით, რომ ეს მასივი ზომა 3 რომ აქვს dot ასლი, infile და outfile.
>> თუ თქვენ ცდილობენ წავიდეთ აქამდე, რომ რომ თქვენ წარსულში null terminator,
თქვენს კომპიუტერში აქვს, ალბათ, შენახული რაღაც argv 4.
თქვენ ნამდვილად არ უნდა იყოს უშვებენ შევიდა argv 4,
იმიტომ, რომ თქვენ გაქვთ ფაილი კაბინეტი და თქვენ მხოლოდ
უშვებენ იმ სამი თაროები.
მაგრამ თუ თქვენ ცდილობენ მიაღწიონ გზა მიღმა შელფზე სადაც ნებადართულია,
თქვენ აპირებს დაიწყოს ძვირფასი სხვა რამ თქვენი კომპიუტერის მეხსიერებაში.
ეს იქნება ნამდვილად, ნამდვილად ცუდი.
ასე რომ, მხოლოდ ის ვიცი, რომ.
იყავით ძალიან ფრთხილად, რომ თქვენ არა მხოლოდ შემთხვევით დაიწყება
წვდომის ელემენტების მასივი, რომ არ იყო რა უნდოდა, რათა შეიქმნას.
Yep.
>> OK.
ასე რომ, ჩვენ ვაპირებთ, რომ კიდევ ერთი ტერმინალის მაგალითად აქ.
OK.
ასე რომ, Rob სწრაფად ლექცია მეორე დღეს წავიდა
ამ გზით, მაგალითად, სადაც ის ჰქონდა int ძირითადი int argc სიმებიანი argv
ფრჩხილებში, რომელიც მეუბნებოდა, რომ მე ვარ აპირებს აქვს ბრძანების არგუმენტები.
>> მას აქვს, თუ argc უდრის უდრის 2- მახსოვს,
შეადგენს შეადგენს ნიშნავს შედარებით.
თუ ეს უდრის 2, მაშინ მე ვარ აპირებს ბეჭდვა hello,
რასაც პირველი ელემენტის მასივი.
Else ბეჭდვა, hello მსოფლიოში.
რა არის ეს აპირებს მოხდება არსებითად?
შეგიძლიათ ვინმეს უბრალოდ განმარტავენ, ინგლისური რა ეს პროგრამა აკეთებს?
ჰო.
>> აუდიტორია: თუ ვინმე აკრეფილი ბრძანება და განაცხადა, რომ მათი სახელი და გვარი,
ეს არ არის მხოლოდ ბეჭდვა პირველი და ვთქვა, hello,
რასაც თქვენი სახელი არის.
>> Andi Peng: OK, მოდით გაუშვით.
ასე მაგალითად, თუ მე უნდა გააკეთოს ეს ფაილი მიიღოს hello, რომელთა მიზანია მიესალმები
რომელთა მიზანია, რაც გინდა, შეყვანის?
>> აუდიტორია: სახელი და გვარი.
>> Andi Peng: სახელი და გვარი?
სივრცეები?
>> აუდიტორია: Yeah.
>> Andi Peng: შეიძლება ვინმეს ვუთხრა ჩემთვის ახლა, რა არის argc?
უბრალოდ უფლება არსებობს?
Oops, უკაცრავად.
ნება მომეცით დაბრუნდეს.
რამდენი ბრძანების არგუმენტები are-- თქვენ ბიჭები ნამდვილად ვერ ვხედავ.
მაგრამ ვეცდები, რომ მიუახლოვდით.
ვცდილობ.
დიახ, აქ არის სამი, არა?
ეს dot slash hello, ეს Andi, და ეს Peng.
>> ასე რომ, რა ბიჭები ვფიქრობ, რომ ეს პროგრამა იქნება დაბეჭდვისას?
Oh.
ბოდიში.
არასწორი სახელი.
ეს დაბეჭდვისას, hello მსოფლიოში.
ვინმეს გვინდა ავუხსნათ რატომ, რომ ხდება?
ჰო?
>> აუდიტორია: [INAUDIBLE].
Andi Peng: ზუსტად.
ასე რომ, აქ, პირობითი არის, თუ argc უდრის უდრის 2.
ასე რომ, მხოლოდ იმ შემთხვევაში, რომ იქ ორი ბრძანება ხაზი არგუმენტები.
ამის შემდეგ მე ვაპირებ ბეჭდვა, hello, რაც არ არის.
მაგრამ სხვაგან, მე ვაპირებ ბეჭდვა მხოლოდ, hello მსოფლიოში.
ასე რომ, ჯერ ვინმეს სურს მომეცი მაგალითად
როგორ მე შეძლებთ რეალურად მისაღებად მას ბეჭდვა ღირებულება argv 1?
>> რა მე უნდა შეყვანის აქ?
მხოლოდ ერთი რამ, არა?
იმის გამო, რომ dot მიესალმები უკვე იმედი აქვს, როგორც პირველი არგუმენტი.
მე მხოლოდ ერთი.
ასე dot მიესალმები თუ უბრალოდ Andi.
Hello, Andi.
ამჯამად ყველას გვესმის რატომ, რომ ხდება?
ჰო.
>> აუდიტორია: ასე რომ სივრცე ბრძანება ხაზი არის ის, [INAUDIBLE]?
Andi Peng: No.
ასე რომ, სივრცეში ბრძანების არგუმენტი, x, ვუთხრა თქვენს კომპიუტერში
რომ ეს არის დაწყების ახალი სიმებიანი.
ასე რომ, სიმებიანი argv აქ იგი მაღაზიებში ყველა თქვენი ბრძანებები ხაზი არგუმენტები
სტრიქონები.
ასე რომ, სივრცეში ბრძანების არგუმენტი ყველა რომ არ არის გითხრათ,
ეს არის ბოლოს ერთი სტრიქონი და დროა გადაადგილება სხვა.
>> ჰო.
ეს არის საკმაოდ მნიშვნელოვანი თქვენი pset, იმიტომ, რომ თქვენ
იქნება ტესტირება ეს.
ასე რომ ვინმეს აქვს ნებისმიერი კითხვები ამ?
OK, მაგარი.
ჰო?
>> აუდიტორია: ასე რომ მიზეზი, რომ ბოლო რიცხვი არგუმენტი calc ნაცვლად
[INAUDIBLE] იქნებოდა, როდესაც გსურთ აკრიფოთ დამატებითი ინფორმაციის
[INAUDIBLE]?
>> Andi Peng: ჰო, ზუსტად.
ზოგიერთი პროგრამები დასჭირდება თქვენ შეყვანის ბრძანების არგუმენტი
ის, რომ გადის და რომელიც იყენებს, რომ.
ჰო.
აუდიტორია: მერე რა, რომ [INAUDIBLE]?
>> Andi Peng: ისე, რა მაქვს უნდა შეიცვალოს შემდეგ ჩემი პროგრამა?
>> აუდიტორია: Just 3.
>> Andi Peng: რატომ არის, რომ ხდება, როგორ ფიქრობთ?
>> აუდიტორია: იმის გამო, რომ [INAUDIBLE].
>> აუდიტორია: ნეტავ უნდა შეეცვალათ ის 2 [INAUDIBLE].
>> აუდიტორია: 1 და 2.
Andi Peng: 1 და 2, ზუსტად.
ასე რომ, ამ შემთხვევაში, თქვენ, ალბათ, მინდა, რომ ორი printf statements--
ერთი, რომ დაბეჭდილი argv 1 და ერთი, რომ დაბეჭდილი argv 2.
აქ.
მე შემიძლია რეალურად გავაკეთოთ, რომ რეალური სწრაფი.
ესეც ასე.
Oh.
არ არის, რა უნდოდა.
მაგრამ თუ ბიჭები სასადილო გარშემო გაფორმებით, ის გამოვა.
ჰო.
ზემოთ.
მე ვიცი, ჩვენ ცოტა მოკლე დროში.
მაგრამ მე უბრალოდ აპირებს სწრაფად დახარჯოს რამდენიმე წუთის გადის helpful--
აუდიტორია: თქვენ გაქვთ ორი წუთი.
Andi Peng: მე მაქვს ორი წუთი?
დიდი მადლობა.
რამდენიმე სწრაფი pset რჩევები.
ასე რომ, ამ pset, მე მაღალ რეკომენდაციას, როგორც ვთქვი, ყველას წაკითხვის სპეც.
თქვენ უნდა წერა სამი პროგრამების ერთ-ერთი მოუწოდა initials.c, ერთი მოუწოდა caesar.c,
ერთი მოუწოდა vigenere.c.
რამდენიმე მნიშვნელოვანი რჩევა, რომ თქვენ ბიჭები ნამდვილად გსურთ
უნდა შევინარჩუნოთ გონება, ასე რომ ეს არის ფუნქცია
მოუწოდა atoi-- როგორც მე მინდა ვთქვა, trois.
გაურკვეველია, თუ ეს ფაქტობრივად, თუ როგორ ვთქვათ.
მაგრამ ყველა ის აკეთებს, ის შესაყვანი.
ეს აკონვერტებს სიმებიანი int.
ასე რომ, წარმოადგენს ASCII რომ i რიცხვი.
ეს მხოლოდ კონვერტაცია ASCII ფასეულობები რიცხვი ღირებულებებს.
ასე მახსოვს argv, მასივი, რომ მაღაზიები ყველა თქვენი ბრძანებები გამოდიან არგუმენტი
ის ინახავს მათ ყველა, როგორც სიმები.
ასე რომ, თუ გსურთ შეძლებს ერთ-ერთი მათგანი გახდეს რიცხვი,
თქვენ ვაპირებთ აქვს უნდა გამოიყენოს ეს მნიშვნელობა აქ.
>> Modulo, როგორც ჩვენ დაფარული ადრე კლასში დღეს,
გაძლევთ საშუალებას აქვს დანარჩენი რასაც თქვენ გაქვთ.
ასე რომ, თუ ჩვენ, რეალურად, მართლაც დიდი რაოდენობით Caesar,
რა მოხდება, თუ ჩვენ ბოლომდე სიმებიანი Vigenere?
როგორ აპირებთ შეძლებს უნდა, რომ გადაიტანოთ გარშემო?
თუ მე მოხვდა z და მინდა მას დაბრუნდეს,
როგორ ვაპირებ მისაღებად რომ გადაიტანოთ გარშემო?
ალბათ გსურთ გამოიყენოთ modulo იქ სადღაც.
>> მეორე, დაათვალიეროთ გარშემო თქვენი ბიბლიოთეკა. ctype.h.
სწორედ ახალი ბიბლიოთეკა გვაქვს.
თქვენ ნახავთ, ბევრი ნამდვილად, ნამდვილად სასარგებლო ფუნქცია isupper, islower,
toupper, tolower, isalpha, et cetera.
ყველა ის ფუნქცია, რომელიც იქნება ძალიან სასარგებლო როდესაც თქვენ ცდილობენ გაერკვნენ,
ეს ხასიათი ამას წერილი?
როგორ შემიძლია გადაიყვანოთ ამ სიმებიანი ზედა?
ეს ყველაფერი იქნება ძალიან, ძალიან სასარგებლოა თქვენი pset.
OK.
>> სამუშაო საათები დღეს არის 8:00 11:00 TEAL კლასის ხვალ
ისევე, როგორც ოთხშაბათს და ხუთშაბათს ღამით.
სამუშაო საათები არიან commons.
მაღალი გთავაზობთ ბიჭები ყველა დავიწყოთ დაუყოვნებლივ,
იმიტომ, რომ თქვენ არ გსურთ, რომ ბავშვი, რომელიც ხუთშაბათს ღამით პრობლემები აქვს
წარდგენის თქვენი pset და ასე, მე არ ვიცი, რა უნდა გააკეთოს.
დავიწყე, მე დასრულდა, მე წარმოდგენილი.
სცადეთ მისცეს საკუთარ თავს გარკვეული ოთახი, რადგან კოდი პრობლემა ყოველთვის მოხდეს.
თქვენ გვინდა დავრწმუნდეთ, რომ თქვენ თავს
ბევრი დრო უნდა შეეძლოს დასრულებას psets.
ზემოთ.
მე გათიშეთ გარშემო აქ.
>> აუდიტორია: ეს არის ონლაინ უკვე?
Andi Peng: მე არ ვიცი, თუ ის ამჟამად უკვე, მაგრამ ეს იქნება.
მე გათიშეთ გარშემო აქ თუ ვინმეს აქვს რაიმე შეკითხვები უკვე.
მადლობა მობრძანებისათვის.