[Powered by Google Translate] [Week 3]
[David J. Malan - Harvard University]
[Dit is CS50. - CS50.TV]
Laat me ons te sturen in de richting van waar we gebleven waren vorige keer,
die begon te denken dat een beetje meer dan ongeveer syntaxis
en proberen om een ​​beetje minder na te denken over de minutiae
dat duurt een beetje tijd om te acclimatiseren tot nu toe op het gebied van puntkomma's
en haakjes en accolades,
om te beginnen met het nemen van dingen een beetje op een hoger conceptueel niveau
zodat de problemen die we nu beginnen met het oplossen in de komende paar weken
gaan veel meer te betrekken in het hoger niveau conceptuele problemen
en een beetje minder in de syntactische als je je voeten nat
en uw handen vuil met een aantal van de syntaxis van de afgelopen weken.
>> Dus herinneren dat vorige week hebben we dit idee van een array geïntroduceerd.
En een matrix in het Engels kan worden beschreven als wat? >> [Onverstaanbaar student reactie]
Sorry?
Een verzameling van? >> [Onverstaanbaar student reactie] >> Oke, goed.
Een verzameling van items. Zo zagen we arrays in Scratch.
Als je toevallig om te gebruiken voor PSET 0 een van Scratch zijn lijsten die je dingen kunt slepen
zoals sinaasappels en bananen in een inventaris van soorten,
dat is net zoiets als wat een array is.
En meer technisch, in het kader van een werkelijke computer,
een array is gewoon een aaneengesloten stuk geheugen.
Met andere woorden, je hebt een byte, dan een ander byte, toen nog een byte, toen nog een byte,
en als je naar die bytes te trekken in een foto,
ze zouden terugkomen om rug aan rug aan rug. Dat is wat we bedoelen met aaneengesloten.
>> Dus het is byte nummer 1, dan 2, dan 3.
Het is hier niet zeggen op, hier, hier, hier.
Een array is een aaneengesloten stuk van 0 of meer bytes.
Dus wat zijn ze nuttig voor?
Recall hadden we dit soort gekunstelde voorbeeld van het opslaan van mensen quiz cijfers in een programma
om uw quiz gemiddelde te berekenen voor een aantal cursus,
en herinneren dat we konden schrijven dat programma te starten door te verklaren een variabele quiz1.
Dan kunnen we nog een variabele genaamd quiz2.
Maar dan als er 3 quizzen in deze klasse, quiz4.
Of als er een wekelijkse quiz, zou het quiz5, quiz6, quiz7.
Dus zou je al deze variabelen gedeclareerd binnen van de belangrijkste
of ergens anders in uw programma,
en het probleem met die benadering, eenvoudige maar het is om gewoon kopiëren en plakken en,
is het gewoon heel snel onoverzichtelijk is.
God verhoede je eigenlijk hebt 30 quizzen of 50 quizzen.
Als het als een middelbare school stijl dagelijkse pop quiz,
dan hoef je alleen een belachelijk lange lijst van variabelen wordt verklaard,
en dit gewoon heel snel uit de hand.
Het lelijke is, is het moeilijk te onderhouden, het is zo veel makkelijker om een ​​typfout
als je 1 nummer een typefout gemaakt ergens in uw programma.
>> Dus introduceerden we de notie van een array in plaats daarvan.
En herinneren dat we dit programma uitgevoerd door het doen van een beetje iets als dit.
Laat me gaan naar de Bron van vandaag 3 maandag directory
en open array, die we zagen vorige keer.
En ook al waren er een paar nieuwe C trucs hier,
waaronder het begrip constant,
herinneren dat we meerdere praalwagens in wezen verklaard door het gebruik van de volgende syntaxis:
float, wordt de naam van de variabele, dan gebruikt vierkante haakjes echt voor het eerst
en wat we deden binnenkant van de rechte haken is effectief besteed en een aantal.
Maar in plaats van dat een nummer, zet ik deze geactiveerde woord, quizzen.
En wat was de motivatie voor het aanbrengen van een geactiveerde woord als Quizzen
en vervolgens met behulp van lijn 17 van de truc hier om daadwerkelijk te geven dat een aantal?
Wat was de motivatie er? Ja.
>> [Onverstaanbaar student reactie] >> Precies.
Als we willen dat de waarde 2 te veranderen, we hebben maar om het te veranderen in 1 plaats
want overwegen - Ik weet niet eens meer wat dit programma precies deed,
maar als je gewoon vluchtig door te nemen zie je Quizzes, quizzes.
Je ziet quizzen, hier beneden meer quizzen.
Dus als we niet hadden deze constante, dit gebruik van scherpe definiëren,
wij zouden hebben getypt 2, vervolgens 2, dan 2, dan 2, wat fijn is. Het zou net zo goed.
Maar stel dat volgend jaar hebben we 3 quizzen in CS50.
Dus ik moet gaan en het actualiseren van de code, moet ik het opnieuw compileren,
maar het probleem is als ik iets stoms, zoals ik over het hoofd een vermelding van 2
en vergeet aan te sluiten in 3, kon het hele programma heel goed breken.
Dus we gewoon vragen om problemen.
>> Dus het idee van een constante is alles over factoring enkele stuk van de gegevens,
of het nu een string of een char of een float of wat dan ook,
en verklaren dat een plaats, zodat u makkelijker kan veranderen in de toekomst.
En het is ook, eerlijk gezegd, een beetje makkelijker te lezen, want als je denk maar aan dit nu,
het is quizzen, of we kunnen zelfs een andere naam geven iets als NUMBER_OF_QUIZZES
of iets explicieter.
De code wordt alleen een beetje meer voor de hand in verband met wat hij aan het doen is,
en je vraagt ​​je af wat minder wat nummer 2 zou kunnen overkomen betekenen.
Dus de constante had niets te maken met fundamenteel arrays.
De array werd geïntroduceerd door middel van deze rechte haken.
>> Dus merken dat in lijn 23 hebben we de gebruiker vragen, "Wat waren uw quiz scores?"
Dan hoeven we alleen maar deze lus die blijkbaar vraagt ​​de gebruiker om hun cijfers. Hoe?
Het herhaalt 0-2. En ik zeg 2 omdat quizzen in hoofdletters is momenteel 2.
Dus het itereert van 0 tot 2 en dan drukt # Quiz iets van iets,
en dan gebruikt GetFloat om een ​​waarde van de gebruiker.
Dus merk dit is de enige andere nieuwe stuk van syntax van afgelopen woensdag.
Als je iets wilt opslaan in een bepaalde plaats in die array,
je weer gebruik maken van de vierkante haken.
>> Dus er is een beetje tweedeling hier.
De eerste keer dat u gebruik maken van de vierkante haakjes
je het gebruikt om aan te geven hoe groot je wilt dat de array zijn.
Maar deze volgende context hier, waar we weer in dienst van deze vierkante haakjes
betekent waar in die array wilt u een waarde zetten?
En het onderscheid hier kan worden afgeleid uit de context.
Let hier hebben we een data type, dan hebben we de naam van een variabele,
dan hebben we onze rechte haken met een aantal binnen, puntkomma. Dat is het.
Dus dat is een verklaring.
Het is net alsof we iets als float Voorraad1 gedaan; float Grade2;
maar nogmaals, dit zeer snel vervult, in veel te veel kopiëren, plakken,
dus in plaats daarvan hebben we net vereenvoudigd het als zodanig,
waardoor we voortaan een cijfer dat kan worden opgeslagen op schijf 0 hebben,
we hebben een gehalte dat kan worden opgeslagen op beugel 1
maar wat als ik Goof en, bijvoorbeeld, mijn lus gaat zo ver -
bijvoorbeeld ik deze minder dan of gelijk aan,
die herinneren was de bron van een eerdere bug -
Dit betekent effectief dat er op sommige derde toevallige iteratie van deze lus
Ik gebruik beugel 2. Effectief, kan wat hier gebeurt? Sorry?
[Student] Het zal worden vervangen. >> Gaat het te vervangen?
Wat zou vervangen worden?
Dit is letterlijk zegt te vervangen wat er op locatie 2 met de return waarde van GetFloat.
Maar het probleem is hoe groot is de array op dit punt in het verhaal?
[Onverstaanbaar student response] >> De array is nog steeds slechts van grootte 2
omdat de array, net als elke variabele, werd voor het eerst verklaard, voordat we gebruikten,
en we hier zijn opgegeven als gevolg van deze constante dat ik 2 cijfers die ik ga zetten hebben.
>> Maar vergeet niet, de computer wetenschappers beginnen te tellen vanaf 0.
Dus de eerste locatie in die array een beugel is 0.
De volgende locatie is 1. Dit ding is ooit zo iets te ver naar de zijkant.
Dus met andere woorden, als ik eigenlijk deze array had -
en laat me zien hoe goed dit werkt hier voor ons -
als ik een array die ik heb gewoon getekend als volgt
en ik heb toegewezen ruimte voor 2 elementen, zou ik dit getekend als dit in het geheugen
waar dit grote witte doek is.
Het is gewoon het RAM-geheugen heb ik in mijn computer, een optreden van RAM, 2 optredens van RAM-geheugen, wat dan ook,
maar deze 2 dozen nu individueel vertegenwoordigen een vlotter, 32 bits.
Dus als ik een nummer hier zo zeggen 1,0, dan heb ik hier zet een ander nummer als 3,2
maar dan doe ik beugel 2, dat is net alsof je hier iets.
En als de foto doet vermoeden, is er niets.
Het is een beetje als niemandsland, want ik heb niet gevraagd het besturingssysteem
om me deze derde quiz.
Als ik wilde die derde quiz, ik had had de voorbedachtheid
om het besturingssysteem voor het vragen door te verklaren QUIZZEN te zijn niet 2
maar in plaats daarvan gelijk 3.
>> Dus met andere woorden, het beeld dat we effectief bij de hand ziet er zo uit hier.
Dit is weer niemandsland. We kunnen beter niet proberen te schrijven waarden hier.
Maar nogmaals, omdat de computer wetenschappers tellen vanaf 0,
als we praten over deze locatie in de array, moet dat adres 0 te zijn,
dit wordt verondersteld om je locatiespelden 1 zijn, en dit bestaat niet eens
omdat we alleen gevraagd het besturingssysteem voor 2 dergelijke plaatsen.
Dus degenen onder u met voorafgaande programmeerervaring uit andere talen
zouden weten, dat dit niet altijd het geval is met arrays of dingen genoemd vectoren.
In plaats daarvan kunt u gewoon blijven toevoegen en het toevoegen en het toevoegen van dingen te arrays,
die eerlijk gezegd, hadden we dat vermogen in Scratch en toch hebben we lijken te hebben gegeven hier
want met C u veel explicieter programmeren.
Het is alleen jij en de computer op dit moment, en de computer zal alleen maar doen
wat u aangeeft dat te doen.
Dus als je alleen maar vertellen dat het om u 2 praalwagens door middel van lijn 22 hier,
dat is alles wat je gaat om terug te krijgen van het besturingssysteem: ruimte voor 2.
>> Dus in toenemende mate uw programma's zullen af ​​en toe buggy met betrekking tot arrays.
Dit is gewoon soort van de aard van het beestje waarbij alle van ons zijn feilbaar,
en op een gegeven moment zul je zeer waarschijnlijk index buiten de grenzen van de array.
En dat is gewoon een mooie manier om te zeggen dat je ging in de houder iets
en iets was gewoon te groot van een getal. Je ging verder dan de grenzen van de array.
Maar de kop is nu dit.
De rest van dit programma heeft echt niets fundamenteel te maken met arrays.
Het is allemaal gewoon over een aantal eenvoudige rekenkunde voor het berekenen van gemiddelden.
Dus we hebben hier in deze for loop hier eerst een variabele genaamd bedrag dat we initialiseren op 0.
Dan gaan we weer herhalen van 0 tot 2 en we voegen aan die sommatie variabele
de i-de klasse, dus beugel 0 dan beugel 1.
En dan als je dat zou doen op de lagere school van het gemiddelde berekenen,
we nemen gewoon dat bedrag, deel dit door het totale aantal quizzen,
en dan voor een goede maatregel noemen we een functie hier genoemd ronde.
>> Nu, als een terzijde, wat is de deal met deze haakjes int op lijn 34?
Het zou kunnen zijn al in paragraaf nog niet echt over gesproken formeel hier,
maar wat is dit int in parens waarschijnlijk aan het doen? >> [Onverstaanbaar student reactie]
Ja, dit verwijst naar gieten of typecasting,
wat betekent dat het nemen van een gegevenstype en om te zetten naar een ander.
Je kunt dit niet doen met alle soorten gegevens, want soms het zou een beetje vreemd.
Maar in dit geval, als de retourwaarde van ronde is een float
want tenslotte, ben ik het nemen van een float te delen door een getal zoals 2,
Ik ga terug te krijgen een vlotter.
Maar de lagere school mensen niet echt leuk om te weten dat hun gemiddelde was 93,4
omdat ze zich realiseren dat ze ooit zo dicht bij dat 95 afronding punt.
>> Dus we willen gebruiken in plaats int om iedereen af ​​te ronden op het dichtstbijzijnde int,
die in dit geval gaat 94 met geen punt na.
Dus dat is gewoon een beetje wiskundige truc.
En we zullen terugkomen op dit begrip van het gieten, omdat het zal gevolgen hebben,
als je nog niet hebt ontdekt, voor probleem set 2.
Dus een array, dan kunt u denken aan - het gaat om make me smile de hele dag.
Het lijkt erop dat dit als je een tekening maken van het,
maar de belangrijkste is dat de grootte ook door u gekozen
wanneer u deze bij het besturingssysteem.
Hebt u vragen dan op arrays? Ja.
[Onverstaanbaar student vraag]
Ah, goede vraag.
De vraag is wat er gebeurt met de null 0 in de array? Het bestaat niet in deze context.
Dat bestaat alleen in het kader van strings, die we op het punt om te komen in slechts een moment.
Maar voor een array, zoals in dit geval, alles wat je krijgt is wat je het besturingssysteem vragen.
>> En nog even terzijde, opdat dit niet duidelijk is,
Ik blijf zeggen dat je vraagt ​​het besturingssysteem, vraag het besturingssysteem.
Een besturingssysteem, zoals u waarschijnlijk weet, is Mac OS, Windows, Linux.
Als u belt functies zoals GetFloat
of je bent te verklaren variabelen zoals rangen,
aan het eind van de dag dat u in wezen te vernemen van iemand anders te geven dat u het geheugen
omdat wij als aspirant programmeurs
heb geen idee hoe je nu eigenlijk fysieke toegang tot het geheugen te krijgen.
Maar iemand doet: het besturingssysteem.
Dus naast de presentatie van ons met mooie iconen en menu's en mappen en dergelijke
dat u op uw bureaublad, of een Mac of pc,
besturingssystemen ook doen het lage niveau alledaagse dingen,
de zeer technische zaken van het beheer van de gigabyte
of 2 gigabyte aan geheugen die je hebt, het beheer van de CPU die je hebt, enzovoort.
Dus als u code schrijft,
je echt aansluiten op uw besturingssysteem in die zin.
Ik ga te hebben om dat te minimaliseren. Oke.
>> Andere vragen over arrays?
Nee? Oke.
Dus de overgang van nature uit arrays is eigenlijk een onderwerp dat is een beetje vertrouwd.
En we keken nog zo kort ingegaan op deze laatste keer ook.
Dit was een string voorbeeld van woensdag.
Deze string voorbeeld was een vrij eenvoudig programma,
en ik heb eigenlijk vereenvoudigd door een paar regels voor de doeleinden van vandaag.
Alles wat het doet in de lijn 19 is een snaar van de gebruiker, slaat deze op in een variabele genaamd s.
Toen in lijn 22 verder het is blijkbaar afdrukken die string 1 karakter per regel.
Maar hoe wordt het dit te doen?
We waarbij een variabele i, waarin het gelijk aan 0,
en dit wordt steeds oude gewoonte nu.
We hadden niet gezien tot woensdag, maar u kunt soort afleiden uit de naam
strlen keert precies wat wanneer het gegeven is? De lengte van de tekenreeks.
Dus als ik het doorgeven van een string, quote-unquote DAVID,
het is hopelijk gaat terug naar mij de nummer 5 als gevolg van DAVID.
Dus dat is zijn doel in het leven is om een ​​string, of hard gecodeerd door u
of in dit geval aangesloten als een variabele, als argument,
en het cijfers te komen wat de lengte van die string is.
>> Dus hier nu zijn we lenen een aantal notatie van de vorige quiz voorbeeld.
Dit heeft niets te maken met praalwagens, heeft niets te maken met quizzen,
maar het blijkt dat de leugentje om bestwil we al vertel je sinds week 1
is dat een reeks niet bestaat in C.
Een tekenreeks aan het eind van de dag is eigenlijk alleen een array.
Het is een array van bytes, dus byte, byte, byte, een byte, die recall is slechts 8 bits,
dus stuk van het geheugen, stuk van het geheugen, stuk van het geheugen, stuk van het geheugen.
En de wijze waarop een koord wordt uitgevoerd
is, terwijl de eerste teken hier
dan hier, dan hier, dan hier, rug aan rug aan rug in het geheugen van de computer.
Dus als je wilde spellen een woord als HELLO, zou je er 1 teken H,
dan E, dan L is dan L, dan is O - 5 karakters in totaal - ergens in uw computer RAM-geheugen.
Maar de sleutel detail hier is dat ze zullen terugkomen om rug aan rug aan rug,
naast elkaar.
Toen als ik zeg s [i], wat in het Engels is dit het geven van me?
Wat doet s [i] te vertegenwoordigen in dit geval? Ja.
>> [Student] de i-karakter in de string. >> Precies. De i teken in de string.
Nu, ik zal bij 0 beginnen als per mijn for-lus hier,
maar dat is goed, want alles begint te tellen vanaf 0.
Dus s [0] gaat naar de letter H te vertegenwoordigen in een woord als HELLO,
s [1] wordt een letter als E in een woord vormen zoals HELLO, enzovoort.
En wat we lijken te moeten doen op elke iteratie van deze lus
is het tijdelijk opslaan van de i-teken in een variabele met de naam c, dat is gewoon een char,
en dan gaan we afdrukken van c
zodat aan het eind van de dag wat dit programma doet is het volgende.
Als ik in de source directory en ik maak tekenreeks1 en ik ga je gang en lopen tekenreeks1,
en dan typ ik een woord als HELLO, Enter, alles wat het doet is het afdrukken 1 teken per keer.
>> Dus er is een kans voor verfijning hier.
Ik ben een beetje meer werk te verrichten, ook al is het duidelijker misschien op deze manier, dan nodig is.
Welke regel code hier kan ik waarschijnlijk helemaal weg te gooien? Ja.
Lijn 24. In lijn 24 Ik verklaar een variabele c.
Ik ben het opslaan van de i-karakter van s in, maar dan ga ik met c hier.
Dus ik ben met behulp van c, dus ik voel me alsof ik kan niet gewoon gooien lijn 24 te bereiken.
[Onverstaanbaar student commentaar] >> Precies.
Dus als het gaat om praten over het ontwerp van programma's,
merken deze lichte vereenvoudiging van de code, die is net zo leesbaar,
maar beseffen dat is gewoon een variabele, het data type is een array,
dus s [i] is gewoon om direct terug te keren naar je de i-teken in die string.
En als je wilt afdrukken, is dat prima.
Je hoeft alleen te% c te gebruiken omdat je niet het afdrukken van een string,
u het afdrukken van een teken in een string, en ook dit heeft het effect van het afdrukken van de i-karakter.
En echt herinneren aan de enige verschil met vorige week met het gebruik van printf
is dat terwijl in de weken voorbij zouden we iets doen super eenvoudig
zoals de% s tijdelijke aanduiding gevolgd door de naam van een string hier,
nu zijn we duiken in een beetje dieper onder de motorkap en zeggen:
worden niet afgedrukt de string; daarin afdrukken van de enkel teken.
>> Dus we kunnen iets doen een beetje anders hier, want er is een andere - niet bug
omdat dit programma is goed, maar ik doe iets stoms
die ik noemde kort op woensdag.
Maar terugdenkend, hoe kon dit programma ontwerp nog verder worden verbeterd? Ja.
[Onverstaanbaar student reactie] >> Oh, goed.
Dus herinneren dat we een zogenaamde tweede variabele n laatste keer geïntroduceerd,
dat lijkt te zijn tegenstrijdige onszelf omdat mijn doel een tweede geleden
was gewoon weg te gooien een variabele als onnodig,
maar herinneren dat woensdag eigenlijk we dit deden.
Ik veranderde de for-lus om daadwerkelijk hebben hier een komma, dan is n = strlen,
en dan hier deed ik i <n, dan ik mijn stappen deed.
Wat is het fundamentele winst die ik bereiken door het veranderen van mijn initialisatie van deze
en mijn voorwaarde om dit nu? >> [Onverstaanbaar student reactie] >> Precies.
Ik ben niet herinneren strlen opnieuw en opnieuw en opnieuw, omdat herinneren hoe de for-lus werken.
Zelfs als ze beginnen te krijgen ingewikkelder ogende,
herinneren dat het ding voor de eerste puntkomma is de initialisatie, die ooit gebeurt.
De toestand is echter in het midden
en dit wordt gecontroleerd elke keer dat je door de lus.
>> Dus het is een soort van dom om te vragen de computer dezelfde vraag opnieuw en opnieuw -
Wat is de lengte van HELLO? Wat is de lengte van HELLO? Wat is de lengte van HELLO? -
want zoals we zullen zien vandaag en op woensdag, is dit zeker gaan om tijd te nemen,
en het is niet een zeer goed gebruik van de tijd, omdat te achterhalen van de lengte van een string
eigenlijk duurt een beetje inspanning.
Het is niet onmiddellijk, want het is in sommige talen.
Dus door het veranderen van deze tot n, de prijs die ik betaal is wat?
We zien een trade-off hier.
Ik kan tijd besparen door niet te vragen hetzelfde verdomde vraag opnieuw en opnieuw,
maar het gaat kosten me iets, wat is wat?
>> [Student] Je verliest een bepaalde hoeveelheid geheugen. >> Precies. Het gaat kosten me wat geheugen.
Dus in dit geval kost het me wat?
Een andere 32 bits omdat n is slechts een int, zoals wordt gesuggereerd door het woord int hier.
Maar is dat goed?
Eerlijk gezegd, dat is waarschijnlijk goed, want als je erover nadenkt,
hoe langer de string is, hoe meer tijd ik ga verspillen
omdat strlen gaat opnieuw en opnieuw en opnieuw gecalled
voor elke iteratie van de lus.
En deze dagen, mijn Mac heeft 2 optredens van RAM-geheugen, deze dagen 4 optredens van RAM-geheugen soms.
Ik denk dat ik kan 4 van die bytes veroorloven om daadwerkelijk versnellen dingen.
Maar dit gaat om een ​​afweging en een thema echt bij de programmering en in de informatica
van nooit echt het krijgen van iets gratis.
Als u iets wilt hier te verbeteren, moet u voor het een of andere manier te betalen in de andere hand.
Ruimte tegen de tijd in dit geval.
>> Dus dit was allemaal in de aanloop naar iets cryptisch als dit,
die, zoals u waarschijnlijk bedacht door nu eigenlijk zegt?
[Onverstaanbaar student reactie] >> Ja, dus dit is, Zorg ervoor dat u uw Ovaltine drinken,
werkelijk gebruik maakt van een algoritme genaamd ROT13, ROT 1-3,
Dit betekent gewoon draaien alle letters 13 plaatsen,
wat betekent dat neemt A dan en voeg 13 tot en ga puntje, puntje, puntje
helemaal naar de 13e letter weg, hetzelfde doen voor B en voor C en D, enzovoort.
En dus als we hier eigenlijk om te zetten dit met behulp van een verschuiving van 13 plaatsen,
komen we terug op wat kleine Ralphie had, die was, Zorg ervoor dat u uw Ovaltine drinken.
Maar nu voor het probleem set 2, in de standaard editie in ieder geval,
je moet soort van doen deze encryptieapparatuur zelf,
en we moeten een of andere manier te nemen in ingang als deze en het of decoderen coderen.
>> Dus welke van deze grondbeginselen soort leidt ons om die kans?
Laten we eens een kijkje nemen op deze derde voorbeeld hier.
In de eerste plaats, het heet ASCII. Wat doet ASCII terug te verwijzen naar?
American Standard Code for Information Interchange,
dat is een heel lange manier om te zeggen wat? Wat is ASCII?
[Onverstaanbaar student reactie] >> Wat is dat? >> [Student] Een speciale tekens. >> Een karakter kaart.
Het is gewoon in kaart nummers om letters, want de wereld is gestandaardiseerd
welke nummers zal vertegenwoordigen wat letters zodat wij allemaal kunnen computers
en onze programma's zijn allemaal gewoon compatibel als het gaat om het afdrukken van dingen op het scherm.
Dus herinneren dat 65 gebeurt te vertegenwoordigen A, 97 gebeurt er vertegenwoordigen een kleine letter.
En dus dit eenvoudige programma is hier ASCII gebruik te maken van dat feit -
dat de wereld weet dat het kapitaal A 65 - en het is gewoon het afdrukken van de kaart brengen.
>> Dus voordat we een duik in deze code, laat me in plaats daarvan open een terminal venster.
Laat me ga je gang en maken ASCII, en dan laten we dit ding lopen alleen maar om de output te verwennen.
En het doet gewoon dit: een echt grote grafiek die gewoon vertelt me ​​al de verschillende codes
voor alle verschillende letters.
Dus een super eenvoudig programma, maar ik hoefde niet te harde code die 52 lijnen van de output:
26 hoofdletters, 26 kleine letters.
In plaats daarvan, ik deed dit programmatisch met een paar lussen.
Let op wat ik hier deed.
Ik herhaald van i is 65 op tot 65 + 26, want ik wilde om uit te printen 26 letters
in het Engels alfabet, i + + op elke iteratie, en nu weer merken.
Het is de herhaling van onze vriend typecasting
waarbij je converteert een gegevenstype naar een ander
want wat wil ik doen in dit programma?
Ik wil numeriek rekenen, want dat is hoe ik ben opgegroeid tellen - 65, 66, 67, enzovoort -
maar ik wil niet alleen de nummers af te drukken.
Ik wil de brief gevolgd door het nummer te drukken.
Ik wil een afdruk: aantal, B: nummer, maar ik kan dit doen met exact dezelfde variabele.
Dus print ik% c als een tijdelijke aanduiding voor een karakter,
% D als een tijdelijke aanduiding voor een cijfer of getal.
Dan wat moet ik aansluiten voor die 2 tijdelijke aanduidingen?
Ik voor het eerst de stekker in het karakter equivalent van i, en dan print ik i zelf.
>> Dus merken dit ook gewoon werkt.
Net zoals ik kan gegoten uit een float naar een int
om te gaan van een reëel getal een integer,
hier kan ik gaan van een int naar een char, dat is een beetje raar -
niet helemaal in kaart op de echte wereld - maar in computers
een char is maar een getal onder de motorkap,
dus we zijn ooit zo expliciet hier op de computer, zeggende:
printf, afdrukken niet i als 65, print het uit als zijn numerieke equivalent.
En het blijkt dat ik technisch niet eens nodig.
Wat ik een moment geleden doen is expliciet casting
door te geven welke data type Ik wil naar van en naar.
Maar merk dat ik al deze tijdelijke aanduiding% c hebben
en die andere% c tijdelijke aanduiding hier.
Ook al is dit niet int, de computer realiseert zich dat een char,
het is gewoon een int onder de kap.
>> Dus als ik echt hercompileren dit en voert u het ASCII-programma,
merken het nog steeds werkt gewoon omdat de computer zich realiseert dat er deze correspondentie.
Nu, het is belangrijker om de expliciete casting te doen in de wereld van praalwagens te ints
omdat er je eigenlijk het maken van een berekende beslissing:
weg te gooien alles na de komma.
Hier is echt niets weg te gooien omdat een karakter is maar een getal,
en een string is gewoon een array van karakters.
Dus toen het tijd werd om de uitvoering van bepaalde encryptie of decryptie komt,
hoe komt het dat we eigenlijk kunnen vertalen zoiets als dit onzin,
Zorg ervoor dat u uw Ovaltine drinken?
Wat als we nu weten - laten we als aanname - dat de sleutel,
het aantal dat we al deze brieven draaien door, is de nummer 13?
Dus gingen we uit de letter B helemaal naar O aan het begin van de zin,
Zorg ervoor dat u uw Ovaltine drinken, want als ik dat doe B
en dan ga ik C, D, E, F, G, H, I, J, K, L, M, N, O,
dat is de reden waarom de encryptie van de letter B wordt O
omdat ik gewoon toegevoegd 13 aan.
>> Dus als ik wil decoderen dit, ik wezen moet O te nemen en toen 13 af te trekken van het.
Of eerlijk gezegd, want er is 26 letters in het alfabet, dit is prachtig symmetrisch,
we kunnen ook gewoon toe te voegen 13 en we nemen contact met de letter B.
Maar hoe ga je over het implementeren iets als dit in Caesar
of echt manipuleren strings in het algemeen?
Als de letter B is welk nummer?
Wat is de letter B? Dus het is 66, toch?
Dus als de letter A is 65 en de letter B is 66,
zo 66, alles wat ik moet doen is het toevoegen 13 aan, en dat geeft me 79.
En als we naar onze kleine cheat sheet, 79 inderdaad kaarten op O.
>> Maar er is een beetje een hoek geval.
Wat is bijvoorbeeld de letter Z?
Als we 66 + 25 helemaal naar het einde van het alfabet, we op 91.
91 + 13 geeft me 104, en wat denk je?
104 niet gelijk een hoofdletter.
Laten we terug gaan naar een klein spiekbriefje.
Als ik dit programma opnieuw uit te voeren in het toestel, merk op dat 104, als ik terug naar de terminal venster,
104 is blijkbaar de kleine letters h.
Dus we moeten een aantal belangrijke truc hier in om ervoor te zorgen dat wanneer we beginnen bij Z
en we voegen 13 tot en met het we willen niet gewoon blijven smeden vooruit naar grotere en grotere aantallen.
Wat doen we echt willen doen?
Je omheen wilt laten lopen.
>> Zo blijkt, zoals je waarschijnlijk al gezien in paragraaf nu of in het probleem set spec zelf
gerealiseerd dat er dit andere operator in C die ook een procentteken,
maar dat we hebben gebruikt% hier om een ​​tijdelijke aanduiding te geven,
weten dat, met name voor probleem set 2, is er ook zoiets als dit:
int x = y% z.
Laat me dit te presenteren als een zeer algemene vorm van deze.
Procent betekent wat in een programmeertaal? >> [Student] Modulo.
Modulo, dat is een mooie manier om te zeggen de rest.
Ook al is er een lichte onderscheid met de definitie daar,
Dit betekent verdelen y door z, maar niet terug het resultaat van deze deling;
in plaats daarvan, de terugkeer van de rest.
>> Als y daadwerkelijk 3 en z is eigenlijk 2, 3 gedeeld door 2 1 met een rest van 1,
dus wat doet x eigenlijk gelijk in dit scenario? 1.
Dit is een dergelijke eenvoudige, laag idee.
Het duurt een beetje tijd om je geest eromheen
want het is waarschijnlijk al een tijdje geleden dat je zelfs moest geven om restanten
en daadwerkelijk gebruik van maken voor iets doelgericht,
maar in dit geval het simpele feit dat u kunt uit een groot aantal gaan als 3
een relatief klein aantal als 2 en wikkelen effectief
door gebruik te maken van de rest op een kleinere waarde als 1 gaat een waardevol truc
die we kunnen gebruiken voor zowel iets als Caesar en dat andere ding Vigenere
in probleem set 2, maar dit gaat om een ​​terugkerend truc loop van het semester zijn.
Dit eenvoudige, simpele idee van alleen het nemen van de rest in het algemeen
gaat ons in staat stellen om rond te wikkelen.
En als we beginnen te spelen meer met arrays, als we beginnen te spelen meer met het geheugen zelf,
dit gaat om meer en meer van een krachtige truc.
>> Dus vragen dan op ASCII of de vertegenwoordiging van strings als arrays?
En we nemen het op 1 inkeping verder. Ja.
[Onverstaanbaar student vraag] >> Goede vraag.
Wat betekent het als een variabele heeft een sterretje in de voorkant van het?
Laat me stellen de beantwoording van deze in detail,
maar verwijst naar een onderwerp bekend als een pointer.
Pointers te maken hebben met het geheugen, en we zijn eigenlijk vandaag
het nemen van de eerste stap in de richting van die discussie,
maar voor nu, laat me doen alsof de ster niet bestaat
en we blijven bellen snaren snaren in plaats van het gebruik van char *,
die heb je waarschijnlijk eerder gezien en ik zal op het scherm zetten in slechts een moment als een teaser.
Dus komen we terug aan die in de weg meer detail dan velen van jullie zullen waarschijnlijk graag.
Uiteindelijk, niet vandaag. Ja.
>> [Onverstaanbaar student vraag]
In welke context moet je het bord voorzien in een karakter? >> [Student] Ja.
Dus door gebrek, wanneer u geen + zet, net positieve getallen aangenomen.
Dus als gewoon schrijven het nummer 1, het is een positief 1.
Als je echt wilt de ontkenning van een waarde op te geven,
je letterlijk op -1 te doen op uw toetsenbord.
Maar dit is waarschijnlijk niet uw vraag. >> [Onverstaanbaar student reactie]
>> Goede vraag. Oke.
Dus dit moet, heb ik begrepen, te doen met een soort van bug je liep in
omdat je het omzetten van een geheel getal naar een personage,
maar een of andere manier negativiteit erbij betrokken,
en zo het karakter kwam net uit munged een of andere manier.
Dus voor nu, laat me een beetje te simpel tot we terugkomen naar dit soort onderwerp.
Voor nu, denk aan dingen op deze manier - en dit is een oversimplificatie.
Maar in de wereld van een geheel getal, heb je hoeveel bits tot uw beschikking?
Je hebt 32 bits.
En tot nu toe hebben we gesproken over het totaal aantal getallen kunt u vormen daarom
is ongeveer 4 miljard in totaal, want je hebt 32 bits,
dus dat is 2 bij de 32, zodat het ongeveer 4 miljard.
Maar we zagen een week of 2 geleden dat je niet echt een bereik van getallen
van 0 op maximaal 4 miljard.
De range loopt in plaats van ongeveer negatief 2 miljard naar positieve 2 miljard.
Maar dit roept dan de vraag, hoe kan je het begrip negatieve 2 miljard vertegenwoordigen
laat staan ​​negatief 1?
Voor nu kunnen we te simpel en gewoon zeggen dat we gaan naar het meest linkse bit te gebruiken
van deze 32 bits, en als het een 1 is een negatief getal
en als het een 0 is het een positief getal.
Het probleem met deze vereenvoudigde weergave van negatieve getallen
is dat als je bewust zijn slim en proberen om uit een teken om te zetten naar een aantal
of vice versa, is er niet zoiets als een negatief karakter.
In de wereld van ASCII, waarvan slechts 8 bits gebruikt, alle 8 van die bits stof,
en de meest linkse bit heeft niets te maken met negativiteit.
En alleen maar om duidelijk, als ik uiterst linkse stukjes zeggen,
herinneren dat wanneer we ons steentje bij-gerelateerde voorbeelden deed in de eerste week
herinneren dat we dingen trok als 1001101, zoiets als dit.
Toen ik de meest linkse bit zeggen, ik heb net letterlijk bedoel de 1 die je helemaal overschrijven naar links.
Dus in de wereld van tekens geen begrip negativiteit,
zodat meest linkse bit heeft eigenlijk iets te maken met ASCII, niets te maken met negativiteit.
>> Dus het klinkt als - en uit de context is het moeilijk om precies te beantwoorden -
maar een of andere manier, is de code verwarrend dat meest linkse bit als vertegenwoordiger van een negatieve waarde
toen was het echt een deel van het karakter in kwestie.
En nogmaals, ik ben te simpel omdat computers daadwerkelijk iets een beetje liefhebber
dan alleen het veranderen van die meest linkse bit een 1 voor een negatief teken ten opzichte van een 0.
Ze in plaats daarvan, als je nieuwsgierig bent naar Google, gebruiken iets typisch genoemd 2's complement,
dat is een beetje meer verfijnd van een aanpak
maar het idee is uiteindelijk hetzelfde.
>> Dus in het kort, het had te maken met het feit dat je een nummer masseren om een ​​teken te
of vice versa, maar de code was niet op de hoogte van het feit
dat een van deze bits had betekenis in de numerieke wereld.
Dat is niet het geval in het karakter wereld.
Maar het klinkt alsof je vast, in welk geval moot nu. Andere vragen.
Oke.
Tot nu toe zijn alle van de programma's die we hebben geschreven genomen inbreng misschien van de gebruiker
in de vorm van functies zoals GetInt, GetString,
of als je al vooruit lezen in verschillende boeken of online referenties,
jullie zelf misschien gebruikte functies, zoals scanf die, eerlijk gezegd, we gebruiken in de CS50 bibliotheek.
Maar in een week of 2, zullen we eigenlijk laten zien hoe de CS50 bibliotheek wordt uitgevoerd
zodat we kunnen nemen die zijwieltjes eraf helemaal.
>> Maar het blijkt dat er een andere manier om input te krijgen van een gebruiker.
In feite hebben we onszelf zijn met behulp van command line argumenten
voor een paar weken nu.
Elke keer als we geen Clang of we hebben gelopen te maken,
We hebben gewoon niet clang getypt, Enter, hebben we niet getypt te maken, op Enter.
Wat hebben we meestal geschreven na het woord clang op onze terminal vensters prompt?
[Student] De bestandsnaam. >> De bestandsnaam, toch?
Hello.c of mario.c of wat dan ook de relevante bestandsnaam is.
En in die zin wat je echt hebt gedaan is dat je beïnvloed het gedrag van Clang
omdat zeker de mensen die schreven Clang had geen idee dat er weinig oud je
ging om een ​​programma mario.c jaar later genoemd schrijven.
Dus je moest naar een of andere manier invloed op het gedrag van dat programma,
en dat programma Clang dat geschreven zodanig dat het invoer accepteren van u
door de toevoeging van woorden op de prompt voor de gebruiker op Enter.
>> Dus het blijkt dat al enige tijd hebben we bijna al onze programma's te verklaren
om te beginnen als deze - int main (void) - en dan hebben we doorgegaan
en begon te schrijven onze code.
En we misschien wat scherp omvat aan de bovenkant van het bestand,
maar bijna al onze programma's tot nu toe zijn begonnen met deze
ook al heb je misschien gezien in doorsnede, in boeken, online referenties
dat dit in feite niet te zijn nietig.
Een andere legitieme vorm om dit te laten nemen is int argc en vervolgens string argv [].
Dus nu wat is dit de vaststelling betekent?
Het blijkt dat argc, dat is een menselijke conventie - je zou kunnen noemen dit foo,
maar het zou gewoon een veel minder duidelijk aan de lezers -
argc is slechts een argument aan de functie genaamd belangrijkste dat staat voor wat?
Wat betekent argc staan ​​voor degenen die bekend zijn?
>> [Onverstaanbaar student reactie] >> Ja, het aantal argumenten of argumenten tellen.
Het is zo simpel als dat.
Hoeveel argumenten werden doorgegeven aan dit programma?
Wat betekent dat?
Als op de opdrachtregel Ik heb zoiets als dit - clang mario.c--
argc als ik op Enter geraakt zal nemen op een waarde van, ietwat verwarrend, 2.
Dus het blijkt dat argc is argument tellen,
maar historische redenen, wordt de naam van het programma zelf in die tellen.
Dus argc is 2 toen ik schreef clang mario.c.
Wat doet argv bevatten?
Allereerst argv lijkt een snaar maar niet helemaal
omdat vanaf afgelopen woensdag en des te meer vandaag de dag,
deze vierkante haken duiden wat? Dat is een array.
Er is geen nummer in de array, en dat moet intuïtief zinvol
omdat de mensen die schreven Clang jaar geleden had zeker geen idee
hoeveel woorden mensen zoals wij zou typen op de prompt voordat je op Enter.
>> Dus in dit geval hier zijn ze hebben verklaard de functie hoofd als het nemen van een reeks van argumenten,
0 of meer argumenten.
Ze weten niet van tevoren hoeveel het er zijn,
dus er is bewust geen nummer binnenkant van deze vierkante haken.
Maar het feit dat de vierkante haakjes zijn er vertellen de computer,
verwacht een array.
Argv is gewoon verkorte schrijfwijze voor argument vector.
Een vector is een mooie manier om te zeggen array,
en array is een mooie manier om te zeggen een lijst of verzameling.
Dus dit betekent gewoon dat als je schrijft main Vind je deze
in plaats van als hoe we doen het al de afgelopen paar weken,
uw programma heeft nu de macht om command line argumenten te aanvaarden
zodat die niet langer heb je te mario schrijven en dan druk op Enter,
typ in een aantal voor hoeveel blokken hoog je wilt dat de piramide te zijn,
dan druk nogmaals op Enter.
We weten niet eens nodig om GetString gebruiken meer of GetInt of GetFloat voor die kwestie.
We kunnen gewoon verwachten dat de gebruiker in staat om die woorden te typen op de prompt zelf
net als de auteurs van Clang besloten dat het een echt vervelend programma
als om de code te compileren u eerst getypte clang, druk op Enter,
dan zeiden we aan de gebruiker, typt u de naam van het bestand dat u wilt compileren,
dan typen we in mario.c en druk op Enter.
Maar dat is precies wat we hebben gedaan om onze gebruikers de afgelopen paar weken.
We maken gebruik van GetString en we wachten tot het programma draait om hen te vragen om input.
Dat moet niet meer het geval.
>> Dus in dit voorbeeld, hebben we nu string argv,
en ook dit is een oversimplificatie,
zijwieltjes dat zal zeer spoedig loskomen.
Dit is de meer juiste manier van het schrijven van dit alternatieve verklaring van de belangrijkste
want het blijkt dat wat we houden aanroeptekenreeks eigenlijk een ster heeft,
een asterisk in de werkelijke definitie, maar dit ziet er gewoon ingewikkeld,
het is verwarrend in het begin, dus we vereenvoudigen door gewoon het creëren van een synoniem van soorten
in de CS50 bibliotheek die kaarten char * aan deze meer gebruiksvriendelijke woord string.
>> Dus laten we eigenlijk proberen dan. Laat me gaan en open te stellen gedit hier.
Laat me ga je gang en open argv van 1.
Dit programma blijkbaar drukt de argumenten, maar in het Engels termen,
door te kijken naar deze code, dit is wat doen meer in het bijzonder?
Als ik typ in de command a.out foo bar, wordt gedrukt wat in mijn zwart-wit raam?
A.out foo bar, Enter.
Ga je gang. Ja. >> [Onverstaanbaar student reactie]
Goed. Dus a.out, nieuwe lijn, foo, nieuwe lijn, bar, nieuwe lijn.
Hoe komt dat? We kunnen zeker bevestigen in slechts een moment.
Dit is een soort van een pluizige regel code.
Hij drukt gewoon een nieuwe lijn alleen maar om de dingen mooier op het scherm.
Dit is een lus die is van 0 itereren van maximaal argc,
en dit wordt incrementeren op elke iteratie + +.
Dus dit zegt nu afdrukken van een tekenreeks, zoals geïmpliceerd door deze% s.
Argv [i] is vrij veel het zelfde idee van het vorige voorbeeld.
We gebruikten om de variabele s noemen, nu het heet, willekeurig, argv.
Dit betekent dat drukken de i-de argument dat werd getypt op de opdrachtregel,
en dan na dit alles gedaan is, gewoon af te drukken voor een goede maatregel een nieuwe regel.
>> Dus laten we dit zien. Laat me het openstellen van de terminal-venster.
Laat me stellen argv van 1, en nu laat ik argv lopen van 1, Enter. Hmm. Oke.
Laten we lopen foo bar. Interessant. Baz.
En als je ooit hebt afgevraagd waarom ik dit typ,
dit is gewoon ook een domme computer science conventie.
De wereld heeft vaak alleen maar verbale tijdelijke aanduidingen voor woorden.
Dus als je wilt praten over een aantal generieke string,
informatici gewoon de neiging om foo te zeggen wanneer ze behoefte aan een willekeurig woord,
dan zeggen ze bar als ze behoefte aan een tweede willekeurig woord,
dan zeggen ze baz als ze behoefte aan een derde woord, dan zijn ze QHx zeggen als ze behoefte aan een vierde woord,
en dan is er een grote religieuze debat online over wat er na QHx,
zodat u Google dat om erachter te komen wat de ander willekeurig woord zou moeten zijn.
Maar deze hebben geen enkele betekenis,
hoewel foo bar, als je op Google dat, dat betekent een betekenis hebben,
dat deel uitmaakt van de hier etymologie.
>> Dus dit alles wordt dan doet is met afdrukken 1 van deze strings per regel.
Dus als ik in plaats daarvan echter, wilde een beetje liefhebber,
neem aan dat ik niet wilde elke snaar per regel afdrukken;
Ik wilde elk teken af ​​te drukken vanaf elke snaar per regel.
Hoe kon ik in plaats daarvan doen?
Wat heb ik nodig om te veranderen over dit programma als ik wil niet elk woord af te drukken
maar ik wil elk woord letter afdrukken door letter voor letter,
dan is de volgende woord letter voor letter voor letter?
Hoe combineren we deze ideeën tot nu toe? Ja.
[Student]% c. >> Oke. Dus we ergens behoefte aan een% c.
Mooi, want ik wil niet om hele strings af te drukken, wil ik tekens af te drukken. En verder?
>> [Onverstaanbaar student reactie] >> Interessant.
Dus we moeten een soort van tweede dimensie hier nu
omdat denken aan argv als een array, maar het is een array van strings.
Maar vanaf, zoals, 15 minuten geleden, wat is een string? Het is een array van karakters.
Dus echt, argv is een array van een array van karakters,
een array van arrays van karakters.
Dus het blijkt dat we kunnen gebruiken gewoon meer vierkante haken notaties. Dus laten we dit doen.
In het begin van deze lus op lijn 19, ik ga herhalen van i tot en met argc,
maar dan ga ik om dit te doen:
voor - Ik kan nu niet gebruiken i.
Ik moet een andere variabele, want ik wil itereren over de woorden
maar dan ook over de letters in de woorden
dus ik soort van een verticale as en een horizontale as, een soort van conceptueel.
Dus int j 0 krijgt, dan wil ik j doen zolang j kleiner is dan - en ik zal dit opruimen in een beetje.
Hoe kan ik itereren over de letters in een string? We deden dit even geleden.
Strlen van argv [i]. Goed.
En nogmaals, ik maak een beetje inefficiëntie hier door niet het creëren van n of wat dan ook,
maar we zullen terugkeren naar dat.
>> Dus nu j + +. Nu moet ik verder streepje hier.
Wat moet ik nu wilt afdrukken op elke iteratie?
[Onverstaanbaar student reactie] >> Dus [i] geeft me het woord.
[I] [j], als een soort matrix.
Degenen onder jullie met wiskunde-y achtergronden,
we zijn soort van indexering nog dieper in deze matrix of deze array van arrays,
Dit 2-dimensionale structuur.
Dus nu laten we eens kijken wat er hier gebeurt. Laat me open mijn grotere terminal venster.
Laat me herhaling maken van argv van 1.
En ik heb het verpest hier, dat is een goede les, omdat ik te vergeten om dit te doen.
Impliciet verklaren C bibliotheek functie 'strlen' met unsigned type "-
Ik weet niet eens wat de rest van die middelen, maar ik heb dit eerder gezien,
impliciet verklaren.
Wanneer we deze fout te zien, dit is wat meestal betekent?
>> [Onverstaanbaar student antwoord] >> Ik ben een bibliotheek boven. Maar wacht eens even.
Meestal heb ik het verpest, omdat ik vergat de CS50 bibliotheek, maar dat is er.
Meestal heb ik het verpest, want ik ben vergeten standaard I / O.
En eerlijk gezegd, ik weet niet eens nodig. We zijn niet met behulp van GetString vandaag.
Dus wat mis ik?
Er is nog een bibliotheek die nu moeten we af en toe de naam string.h te gebruiken,
en dit is slechts nog een andere bibliotheek die meer functies die niet in de standaard I / O heeft
>> Dus laten we terug gaan naar mijn grote terminal-venster.
Oke. Nu, verdomme, ik denk dat ik verkeerd was. Ik was met behulp van de CS50 bibliotheek.
Dus we kunnen dit oplossen in een van de 2 manieren.
We kunnen de training wielen van dit moment en gewoon doen,
of laten we soort van houden dat vereenvoudiging alleen voor nu, plak deze terug in,
lossen dat probleem, en nu terug naar het terminal-venster.
Dus om duidelijk te zijn, in de CS50 bibliotheek is niet alleen functies,
het is ook het trefwoord string, dat is waarom die fout gebeurde gewoon.
>> Dus hier gaan we dan. I vastgesteld beide library problemen. Enter. Goed.
Argv van 1, foo bar, Enter. Uitstekend.
Dus nu hebben we elke letter van elk woord afgedrukt 1 per regel,
die niet zorgen voor een zeer interessant programma,
maar let nu hebben we de mogelijkheid om niet alleen itereren over woorden
maar ook over afzonderlijke letters in woorden, dat klinkt erg vertrouwd
de eenvoudigste toepassingen zoals scrambling letters in een string als deze zelfs.
Laten we verder gaan en hier nemen onze 5-minuten pauze.
En als we terug komen, zullen we beginnen te praten over de efficiëntie
waarmee we beter kunnen doen deze dingen.
>> Oke. We zijn weer terug.
Dankzij een van onze TFS die speelt veel Bananagrams,
We hebben eigenlijk een hele hoop van chars met ons hier vandaag
fysiek geïncarneerd met deze kleine stukjes plastic,
en laat me voorstellen dat dit lege witte lei hier het RAM-geheugen in mijn computer vertegenwoordigt -
laptop, desktop, wat dan ook - en daar ziet eruit als er veel van
want als we beginnen hakken dit RAM in kleine byte-grootte stukken,
laten we willekeurig zeggen dat iets dat de grootte en dat onscherpe vertegenwoordigt -
daar gaan we, en laten we hier uit te zoomen een beetje -
laten we zeggen iets dat de grootte van een enkele byte vertegenwoordigt.
Dus we kunnen inderdaad past een hele hoop van bytes of tekens binnenkant van dit geheugen,
zoals voorgesteld door de relatieve omvang hier.
>> Zodat nu dat het doel is om geheugen toewijzen voor een tekenreeks.
Hoe werkt dit eigenlijk?
In de programma's die we hebben geschreven, hebben we meestal gebruik gemaakt van GetString,
maar nu, duidelijk, er is een andere kanaal via welke we kunnen input van de gebruiker in argv krijgen
via command line argumenten.
Maar wat er werkelijk aan de hand onder de motorkap?
Het blijkt als we noemen - laten we terug te scrollen naar GetString - de functie GetString
in de CS50 bibliotheek wordt de gebruiker gevraagd een string,
de gebruiker typt in een woord - laten we noemen HELLO het.
En we hebben gezegd voor de afgelopen paar weken dat de return waarde van GetString
in feite een string, als het woord HELLO.
>> Maar wat is getString eigenlijk aan het doen?
Als de gebruiker in HELLO, Enter, wordt GetString uitzoeken,
oke, hoeveel tekens is dit? Dit H-E-L-L-O.
Dus het moet toewijzen aan, die het nodig heeft om het besturingssysteem te vragen - Linux in dit geval -
tenminste 5 bytes op te slaan HELLO.
En wat het gaat dan doen om een ​​keer hij terug die 5 bytes van het besturingssysteem
is de lay-out HELLO rug aan rug aan rug aan rug.
En dus wat er echt terug van GetString is een stuk van de gegevens die er als volgt uitziet.
Maar dit is een beetje onnauwkeurig, omdat het blijkt dat het niet zo eenvoudig
als gewoon opslaan van HELLO in het geheugen van de computer
want stel dat mijn programma dat ik aan het schrijven ben in C roept vervolgens getString weer,
en het volgende woord typt de gebruiker in is Bye, bye.
Nou, ik moet dat woord BYE ergens in het geheugen passen.
Ik kan niet clobber HELLO.
Bijvoorbeeld, ik wil niet dat de computer gewoon beginnen te overschrijven als deze
het oorspronkelijke woord, omdat ik nog steeds kan het woord worden met behulp van HELLO in een variabele
ergens anders in mijn programma.
>> Dus B-Y-E moet nu ergens anders in het geheugen.
Maar de conventie is typisch dat de volgende tekenreeks die u toewijzen
waarschijnlijk, maar niet altijd, zal eindigen bij de eerstvolgende geheugenplaats.
En als ik niet gevraagd het besturingssysteem voor het geheugen
sinds de laatste keer dat ik belde getString, is de kans het woord BYE
gaat naar rechts eindigen na het woord HELLO in het geheugen.
Maar op dit punt kun je misschien zien waar een potentieel probleem zich voordoet.
Omdat de volgende delen van het geheugen, de volgende bytes die waren gewoon vrij -
schone witte lei - in het geheugen van de computer waren direct naast HELLO,
het voelt als de eerste string vroeg ik om kan plotseling veranderen nu
want ik heb in wezen veranderd in HELLOBYE
plaats van andere manier demarcing begin BYE en eind HELLO.
>> Dus het blijkt dat wat er echt aan de hand is onder de motorkap,
die u misschien een glimp hebben opgevangen in online referenties of sectie of boeken
of helemaal niet gewoon nog niet, is dat er eigenlijk een bewuste afbakening
tussen woorden in het geheugen van een computer.
En in feite, in dit geval hier, in plaats van zomaar BYE naast HELLO,
in plaats daarvan, de computer zet een speciaal teken, het speciale nul-karakter, zo te zeggen,
die wordt voorgesteld met een marker met backslash 0.
Dus lang verhaal kort te herinneren dat tekens worden weergegeven in ASCII.
ASCII is gewoon een mapping tussen cijfers en letters,
en de meeste van die brieven beginnen ongeveer 65 voor kapitaal A,
maar het blijkt dat je kan zeker vertegenwoordigen het getal 0 als een geheel getal of in binaire,
en het blijkt dat de wereld lang besloten, lang geleden, "Weet je wat?"
"Let's reserve getal 0 niet overeen geen tekens op het toetsenbord -
"Geen brieven, geen nummers, geen leestekens. 0 is bijzonder."
"Het gaat om de speciale null karakter te zijn, en we gaan om het te schrijven als \ 0."
Het verschil is als we net schreef 0, 0 is een karakter.
Herinneren dat er ASCII codes voor 0, voor 1, 2, 3
omdat het karakter 0 afwijkt van het getal 0.
En je kunt zien dat als je terugkijkt vanaf week 1 bij de eerste hebben we gesproken over ASCII,
0 en 1 en 2 en 3 helemaal tot 9 hun eigen ASCII codes.
Ze zijn niet, toevallig, 0 tot en met 9. Ze zijn erg verschillend.
Dus 0 betekent gewoon "ik speciaal ben," en de \ 0 betekent, letterlijk, "Ik ben niet de 0 karakter."
"Ik ben dit bijzondere waarde, de nul-karakter."
Dus ik echt nodig een andere een van deze want ik kan niet twee keer dezelfde fout maken.
>> Dus na het woord BYE we gaan ook nog een van deze nultekens nodig hebben.
Laat me hier pak mijn pen en laat me snel een ander \ 0 te tekenen
zodat nadat ik heb gevraagd het besturingssysteem voor 2 strings
via GetString gevolgd door nog een oproep naar GetString,
dit is wat is eigenlijk in het geheugen.
Dus als ik terug een string, ik ben echt om weer dat,
en toen ik de volgende snaar te krijgen, ik ben echt om weer dat.
Dus dit is het de vraag, strlen, in de eerste plaats, wat moet daar terug?
Toen ik strlen een beroep doen op de string s en s was het woord HELLO die de gebruiker heeft ingevoerd in,
wat hebben we natuurlijk zeggen dat de lengte van HELLO was een paar minuten geleden?
Het was 5, toch? H-E-L-L-O. En dat is inderdaad hoe strlen werkt.
Retourneert wat een normaal mens zou verwachten de lengte van een string te zijn.
Maar in werkelijkheid, hoe groot is de matrix van karakters die hallo is het opslaan?
Het is eigenlijk 6.
Dus strlen betekent dat feit geen melding aan u.
Maar onder de motorkap van de computer is inderdaad met behulp van 6 bytes op een 5-letter woord op te slaan,
en dit is waar niet uit hoe lang het woord is.
Er is altijd gaat om een ​​speciale null eindigt karakter aan het einde van de string
om de totale lengte demarc.
>> Dus dan kun je nu de persoon uitvoering strlen 20, 30 jaar geleden,
hoe ga je over het implementeren strlen zelf?
Wij gaan ervan uit dat het bestaat, net zoals we voor lief nemen dat printf bestaat,
maar als HELLO is het woord in kwestie
en wat ik heb in het geheugen is iets dat er zo uitziet,
als je moest herimplementeren strlen omdat je werd gevraagd om
of omdat, eerlijk gezegd, wist je niet strlen bestond -
moest je deze rollen op uw eigen - hoe kon u de uitvoering van strlen
wanneer gegeven iets dat er zo uitziet?
Nu we weten dat een string een array is, kunnen we itereren over elk van de afzonderlijke tekens
met behulp van iets als - laten we proberen om dit te doen op de vlieg.
>> Laat me gaan in het apparaat. Laat me maak een nieuw bestand, strlen.c.
Laat me nu ga je gang en doen stdio.h, zodat we toegang hebben tot printf hebben te nemen.
Laat mij int main (void). Oh. Ik doe dit op mijn eigen voor nu dan. [Grinnikt]
Dank u.
Dit is wat ik doe. Oke.
Dus voordat ik me omdraaide op het scherm, typte ik dat allemaal.
En nu, wat ik ga doen is het volgende:
printf ("Geef me een string:")
Dat is gewoon pluizige instructies.
Nu laat me doen string s = GetString.
Ik heb al nodig om een ​​verandering nu te maken.
Ik gebruik de CS50 bibliotheek plotseling, dus laat me ga je gang en typ in cs50.h.
En nu laten we dit doen: printf ("De lengte is:% d, strlen [s] -
en ik ben nog niet klaar. Wat moet ik toevoegen aan dit programma?
>> [Student] string.h. >> String.h.
Dus voor nu, we gebruiken strlen, dus laten we ervoor zorgen dat de compiler weet waar dat is,
dus een beetje gezond verstand te controleren.
Ik krijg een string in lijn 8, en in lijn 9 ben ik het afdrukken van de lengte met% d.
Dus laten we verder gaan en open deze op.
We hebben te maken strlen - stelt okay -
strlen - laat me in te zoomen - Enter, H-E-L-L-O, Enter. De lengte is 5.
>> Oke, dus strlen lijkt te werken, maar de wereld wist dat.
Dus laten we nu strlen onszelf als volgt te implementeren.
Laat me weg te nemen deze bibliotheek.
We hoeven niet langer toegang hebben tot string.h omdat ik wist niet eens dat het bestond.
Maar dat geeft niet, want ik kan implementeren strlen mezelf
en hebben te nemen een string genaamd ingang,
en nu moet ik te achterhalen van de lengte van deze string.
Dus hoe kan ik dit doen?
Wat gebeurt er als ik - laten we eens kijken hoe dit te doen - Wat wil je doen?
>> [Onverstaanbaar student reactie] >> Oke.
Dus we kunnen dit doen in een bos van manieren. Laat me proberen om deze aanpak te nemen.
Ik geef mezelf een int variabele i, dus ik begint bij 0.
En laat ik dit zeggen: terwijl input [i] is niet gelijk aan wat? \ 0.
Zo blijkt, zoals met bij alle tekens bij het schrijven letterlijk ze in een programma,
je moet enkele aanhalingstekens, niet dubbele aanhalingstekens te gebruiken.
Dus als ik de letter a te schrijven, zou ik dat doen, de letter b, zou ik dat doen.
Dit daarentegen zou een string zijn geen eigen karakter.
>> Dus ik wil \ 0 letterlijk. Wat wil ik doen in deze lus?
Eigenlijk, ik heb een andere variabele, dus int length krijgt 0.
Zelfs als je niet zeker waarom we begonnen met de manier waarop we dat deden,
nu dat we gaan op deze weg, wat ik wil doen op lijn 9?
lengte + + en dan hier op lijn 10, het rendement lengte.
Dus hoe is geïmplementeerd strlen?
Het is eigenlijk wel geïmplementeerd als deze.
Misschien is de persoon die een for-lus, misschien een doe while loop - wie weet?
We zouden echt onder de motorkap kijken naar de werkelijke broncode
in sommige bestand met de naam string.c waarschijnlijk.
>> Maar hier laten we nadenken over wat ik doe.
Ik verklaar een variabele genaamd i, waarin het gelijk aan 0.
Ik ben dan te verklaren een andere variabele genaamd lengte, waarin het gelijk aan 0.
Dan zeg ik, terwijl de i-teken in ingang is niet gelijk aan de speciale null karakter, \ 0,
verhogen de lengte.
Maar zodra de i-karakter is dit speciale karakter, wat gebeurt er met de lus?
Het kortsluiting. Het stopt, wat betekent dat we dan onmiddellijk terugkeren lengte.
>> Dus als ik niet verknoeien, laten we verder gaan en ga terug naar mijn terminal venster.
Laat me opnieuw te compileren. En ik heb verpest.
Incompatibele declaratie van functie uit de bibliotheek strlen.
Dus ik probeerde om hier te komen te slim voor mijn eigen bestwil.
De compiler weet dat er eigenlijk een functie genaamd strlen
ook al hebben we niet opgenomen in de bibliotheek. Dat is prima. Het zal wel.
We gaan gewoon om dan samen te werken. Laten we de naam van deze lengte.
Laat mij het gebruik van het hier te veranderen op lengte, en dit zal Clang gelukkiger.
Even terzijde, omdat sommige van deze functies zijn zo darn gemeen -
strlen, prinf - ze daadwerkelijk hebben een soort speciale status.
En zo Clang weet alleen een beetje iets bijzonders over hen.
Dat is altijd niet het geval met de meeste functies, dus dat is waarom we werden uitgescholden.
>> Laat mij nog eens proberen. Gelukkig, het werkte die tijd.
Dus nu laat ik run mijn eigen strlen programma.
Geef me een string: H-E-L-L-O, Enter. En ik heb het verpest.
Waarom? >> [Onverstaanbaar student reactie] >> Precies.
Dus ik heb mezelf hier een heel mooi uitziende oneindige lus
want hoewel ik het verhogen lengte op elke iteratie,
wat ben ik duidelijk niet te doen? Ik ben niet verhogen i. Oke. Gemakkelijke oplossing. Ja?
Oke. Nee Nu zouden we afoul van een aantal andere veel voorkomende fout waar ik moet haken.
En eerlijk gezegd, wordt deze code begint te zien er lelijk uit,
dus nemen we een gooi naar het schoonmaken dit in een moment.
Maar nu ben ik het verhogen zowel de lengte en i.
Eerlijk gezegd, heb ik al hier een kans voor verbetering, maar we komen terug naar dat.
>> Dus nu laten we gewoon zorgen dat we in ieder geval het maken van vooruitgang.
Dit is gebeurd met een paar van jullie, en ik vergat dit te vermelden op voorhand.
Wanneer u het ongeluk van een scenario als dit hebben, hoe dit oplossen
kort van het herstarten van de machine of de computer of het sluiten van het raam?
Het is eigenlijk eenvoudig.
Control-C stuurt deze kleine wortel symbool C, en dat is gewoon beëindigt de meeste programma's.
Als je een echt slecht oneindige lus die is afgedrukt dingen oneindig vele malen,
soms moet je zou kunnen hebben om te slaan Control-C duizend keer om het echt te horen.
Dus juist nu te realiseren, omdat ik niet aan het afdrukken iets, dat was heel eenvoudig.
En technisch gezien, een keer is voldoende, maar ik ongeduldig en ik meestal raak het dat vele malen.
>> Dus strlen. Geef me een string: HELLO. Gaat het dit keer werken?
Oke. Een andere veel voorkomende fout. Moet opnieuw compileren.
Dat was bewust, dat een. Oke.
Dus strlen, H-E-L-L-O, Enter. Uitstekend.
Dus hebben we nu een strlen tot 5.
Dus we hebben letterlijk opnieuw geïmplementeerd dat wiel.
Dus nu laten we dit opruimen, omdat dit niet maakt me onder de indruk
met het ontwerp van mijn code.
Wat kunnen we duidelijk te schakelen in dit programma om dit op te ruimen?
[Onverstaanbaar student reactie] >> Ja. Letterlijk, we behandelen i en lengte identiek.
Dus waarom gaan we niet gewoon slim en zeg, terwijl lengte?
Integendeel, laten we noemen het gewoon lengte te beginnen, initialiseren op 0
omdat standaard de string heeft geen lengte tot we weten wat het is.
>> Nu we dit doen, en nu is dit een vrij elegante programma.
Een variabele. Ik ruimde het op, aangescherpt het op.
Dus nu laten we terug gaan naar mijn terminal-venster. Laten we verder gaan en het uitvoeren van deze.
Maak strlen. Ziet er goed uit. Opnieuw uit te voeren strlen, Enter.
Geef me een string: HELLO, Enter. En het lijkt te werken als 5.
Nu, om duidelijk te zijn, als ik niet had geschreven, bijvoorbeeld, HELLO in 1 string
en dan BYE in een ander, kunnen we zeker meerdere woorden.
Als de uitdrukking die ik eigenlijk wilde typen niet HELLO, maar, bijvoorbeeld,
HELLO WORLD, bericht dat wat we niet hebben is hier deze situatie, toch?
Dat zou suggereren dat dat is 2 snaren.
Je kan zeker hebben spatiebalk karakters, dus als we daadwerkelijk getypt in een langere zin
zoals HELLO WORLD we, wat zou echt in het geheugen
ziet er een beetje iets dergelijks daar.
>> Oke. Hebt u vragen dan over de vertegenwoordiging hier van strings?
Nee? Oke.
Dus ik zei eerder dat het opnieuw bellen strlen op keer opzettelijk zo
is waarschijnlijk niet het beste idee, want je gaat moeten doen een heleboel werk
opnieuw en opnieuw en opnieuw.
Inderdaad, wat voor soort werk is noodzakelijk voor het uitzoeken van de lengte van een string, blijkbaar?
Je moet beginnen bij het begin en dan kijk, kijk, kijk, kijk, kijk
totdat je uiteindelijk zien dat speciaal teken, op welk moment, ah, nu weet ik de lengte.
Dus eerder toen we strlen wordt opnieuw en opnieuw en opnieuw genoemd,
de reden dat ik voorgesteld dat was een soort van dom is omdat, opnieuw, dat string ziet er zo.
Het is niet van plan om elke keer dat u herhalen veranderen door enkele lus,
dus je doet onnodig werk.
Tegelijkertijd moet je weten, als een terzijde, dat compilers zoals Clang deze dagen
zijn ontwikkeld gedurende vele jaren,
en compiler schrijvers, programmeurs, zijn behoorlijk slim.
En zo blijkt dat Clang en andere compilers daadwerkelijk kan erachter te komen dat,
oke, ja, je schreef strlen in uw toestand,
wat betekent technisch dat we zouden noemen opnieuw en opnieuw en opnieuw.
Maar slimme compilers daadwerkelijk kan optimaliseren dat soort slechte beslissingen van gebruikers
uit uw code om dingen te herstellen.
>> Dus gewoon beseffen dat soms de compiler is slimmer dan wij
en zal soort van verborgen onze eigen fouten.
Maar zeker als het gaat om problemen sets en dergelijke,
niet na te denken over de fundamenteel verkeerde ontwerpbeslissingen
potentieel om de eenvoudige reden dat we zouden veel meer werk moeten doen
dan we eigenlijk moeten doen. Maar hoeveel meer werk?
In het geval van HELLO WORLD, laten we beginnen om de grootte van dit probleem te veralgemenen.
Wat is de lengte van het probleem of de omvang van het probleem
wanneer het woord de gebruiker heeft ingevoerd in is HELLO?
Het is blijkbaar 5, misschien 6. Plus of minus 1. Het zal wel.
Het is zo dichtbij we noemen het gewoon 5.
>> Dus wat is de omvang van het probleem hier wanneer het proberen te achterhalen van de lengte van HELLO?
Het is 1, 2, 3, 4, 5, 6 en misschien de laatste karakter, maar generaliseren laten dat als n.
Dus n, alleen de variabele n, is wat informatici zouden in het algemeen gebruik
om de grootte van een probleem, en het probleem te beschrijven bij de hand is hoe lang is HELLO?
Hoeveel tijd kost strlen nemen?
Duurt in de orde van n stappen, waarbij elke stap betekent kijken naar een karakter
kijken naar een karakter, kijken naar een karakter.
En we deze discussie had een tijdje terug, het aantal operaties iets duurt.
De eerste dag van de klas hadden we iedereen onhandig opstaan,
en dan begon iedereen paren uit elkaar
Om daadwerkelijk tellen ideaal hoeveel mensen in de kamer waren.
En we deden ook een ander ding, waarbij als ik in plaats daarvan deed het de oude school weg
van beginnende 1, 2, 3, 4, 5, 6 enzovoort,
dat ook de omvang van het probleem was van grootte n. Er waren n mensen in de kamer.
Maar ik kon versnellen dat, toch? Lagere school stijl die ik kon beginnen te tellen in 2s.
2, 4, 6, 8, 10, 12. En dat voelt zo veel sneller, en het is inderdaad.
Het is letterlijk twee keer zo snel, maar nogmaals, als nog eens 400 mensen liepen in deze kamer
alles in een keer, zouden die algoritmes nog een 400 of misschien 200 stappen.
>> Maar daarentegen, als we echt slim en we in plaats daarvan hebben jullie allemaal tel het dan zelf
herinneren hoe dat algoritme werkt.
Jullie stond op. Laat me snel uit naar deze.
U allen stond op, u gepaarde uit, en dan de helft van jullie ging zitten,
de helft van je ging zitten, de helft van jullie ging zitten,
en op elke iteratie van deze lus van de week 0, hebben we gehalveerd het probleem bij de hand
en ging n / 2, dan n / 4, dan n / 8.
En de implicatie daarvan is dat als er een andere 400 mensen lopen in de kamer, geen big deal,
Het zal ons nog 1 ronde, niet 400 meer rondes, niet 200 meer rondes.
En dus het verhaal vertelden we een tijdje terug moest een beetje iets met dit te doen.
Deze rode lijn hier lineair is, het is recht, en het is gelabeld als n
want de grootte van een probleem wordt,
als je algoritme of programma waarmee je het oplossen ervan duurt n stappen,
we kunnen uitzetten als een rechte lijn waar het meer tijd kost hoe groter de omvang van het probleem.
En de twosies aanpak, tellen 2, 4, 6, 8, nog steeds een rechte lijn, maar een beetje beter.
Het duurt een beetje minder tijd, zodat de gele lijn onder de rode lijn punt voor punt.
>> Maar nog beter was deze heilige graal van wat we genoemd logaritmische tijd
waar zelfs als we weer het aantal mensen verdubbelen in de kamer,
we het dubbele van de grootte van dat telefoonboek vanaf de eerste dag van klasse,
geen big deal, het duurt nog 1 pagina scheur, neemt 1 meer zitten
om een ​​probleem dat twee keer zo groot te lossen.
En dus het gesprek dat we nu om te beginnen met zijn
hoe kunnen we eigenlijk efficiënt problemen op te lossen
als we rekening houden met de eenvoudigste van de problemen zoals deze?
Stel we hebben 8 deuren waarachter een aantal nummers,
en elk van deze getallen niet gesorteerd op enigerlei wijze,
ze zijn gewoon willekeurige getallen achter deze deuren,
en stellen we de vraag hoe ga je over het vinden van het aantal - wie weet -
7 achter deze deuren?
Wat zou u, een mens, doen om mij vinden het getal 7
indien het nogmaals elk van deze zijn deuren en een waarde te zien moet je een deur te openen?
Wat zou je algoritme misschien?
>> [Onverstaanbaar student reactie] >> Dus beginnen met de linker-en een deur openen, opent een deur, een deur openen.
En in het ergste geval, is hoe lang het gaat ons om het nummer 7 vinden?
En nogmaals, ze zijn niet gesorteerd, dus het is niet zo eenvoudig als, nou ja, ik ga naar de 7e deur te openen.
Het kan nemen ons, maximaal, 8 stappen.
In het ergste geval, 7 is willekeurig aan het eind van de lijn van deuren,
dus we kunnen moeten alle n deuren te proberen.
Dus hier weer, lijken we een lineair algoritme hebben.
In feite hebben we dit een paar jaar geleden.
Een van uw voorgangers werd uitgedaagd met juist deze
waar we niet over een digitale versie te hebben, hebben we in plaats daarvan hadden een schoolbord
een paar stukken papier op.
En wat ik dacht dat ik zou doen is een snelle terugblik op hoe dit ging,
een van de beste en misschien wel het meest lastige kansen op het podium
om een ​​demonstratie te hebben hier op Sanders.
We hadden 2 rijen getallen.
We alleen maar te kijken naar wat er gebeurt hier met Sean voor de top van deze rijen.
Tenzij niemand ooit nog vrijwilligers in CS50,
we hadden Sean's zegen om dit te houden voor de camera,
dus hij weet dat honderden mensen zijn dit nu kijken al jaren.
Maar Sean heeft een geweldige job - of had hij -? Op het daadwerkelijk vinden van een bepaald nummer.
>> Dus laten we eens kijken hoe hij dit algoritme opgelost, zodat we dit gesprek te hervatten het duurde niet lang
van hoe we dingen vinden efficiënt.
[Malan op video] Ik heb verborgen achter deze deuren de nummer 7,
maar weggestopt in een aantal van deze deuren en de overige niet-negatieve getallen,
en je doel is om van deze bovenste rij van getallen zien als gewoon een array
of gewoon een reeks papiertjes met cijfers achter hen
en je doel is, alleen met behulp van de bovenste rij hier, vind ik het nummer 7.
En we worden dan gaan kritiek hoe je over te doen. >> Oke.
[Malan] Vind ons de nummer 7, alsjeblieft.
[Gelach]
[Malan] nr. [gelach]
5, 19, 13, [gelach]. Het is geen strikvraag.
1.
[Gelach]
Op dit punt je score is niet erg goed, dus je kan net zo goed blijven gaan. [Gelach]
3.
Ga door. Eerlijk gezegd, ik kan het niet helpen, maar vraag me af wat je nog denkt over. [Gelach]
Alleen de bovenste rij, dus je hebt 3 links. Dus vind ik 7.
[Studenten murmelende]
[Malan] 17.
[Studenten murmelende]
[Malan] 7! [Applaus]
>> Dus op woensdag zullen we duiken in dit en meer geavanceerde algoritmen voor het vinden van dingen.
Voor nu zullen we laten je met Sean en tot ziens op woensdag.
[CS50.TV]