1 00:00:00,000 --> 00:00:02,000 [Powered by Google Translate] [6 અઠવાડિયું] 2 00:00:02,000 --> 00:00:04,000 [ડેવિડ જે Malan] [હાર્વર્ડ યુનિવર્સિટી] 3 00:00:04,000 --> 00:00:08,000 [આ CS50 છે.] [CS50.TV] 4 00:00:08,000 --> 00:00:12,000 >> આ CS50 છે, અને આ 6 અઠવાડિયું શરૂઆત છે, 5 00:00:12,000 --> 00:00:16,000 જેથી નવા સાધનો દંપતી હવે ઉપલબ્ધ છે માટે તમે લાભ ના લેવા માટે, 6 00:00:16,000 --> 00:00:19,000 જેમાં સૌ પ્રથમ CS50 પ્રકાર કહેવામાં આવે છે. 7 00:00:19,000 --> 00:00:22,000 ઓડ્સ છે જો તમે મને અથવા શિક્ષણ ફેલો કોઈપણ જેવા છીએ, 8 00:00:22,000 --> 00:00:26,000 તમે કદાચ કાર્યક્રમ, જેમની શૈલી આ જેવી થોડી કંઈક જુએ છે જોઇ છે. 9 00:00:26,000 --> 00:00:30,000 કદાચ તમે કેટલાક મોડી રાત્રે જ ખૂણામાંથી કાપવાની શરૂ કરવા, અથવા તમે તેની સાથે પાછળથી વ્યવહાર પડશે, 10 00:00:30,000 --> 00:00:32,000 અને પછી ટીએફ અથવા CA ઓફિસ કલાકો દરમિયાન ઉપર આવે છે. 11 00:00:32,000 --> 00:00:34,000 પછી તેને હાર્ડ અમારા માટે વાંચવા માટે. 12 00:00:34,000 --> 00:00:38,000 વેલ, આ કોડ વાક્યરચના અનુસાર યોગ્ય છે, અને તે કમ્પાઇલ કરવામાં આવશે, અને તે વાસ્તવમાં ચાલી જશે. 13 00:00:38,000 --> 00:00:40,000 પરંતુ તે ચોક્કસપણે શૈલી માટે 5 નથી. 14 00:00:40,000 --> 00:00:45,000 >> પરંતુ હવે અહીં, જો આપણે આ ડિરેક્ટરીમાં જાઓ 15 00:00:45,000 --> 00:00:48,000 નોટિસ અને એ કે હું conditions2.c-હોય 16 00:00:48,000 --> 00:00:55,000 અને હું આ ફાઈલ conditions2.c પર આ નવા આદેશ, style50, સ્કોર લિમિટેડ, 17 00:00:55,000 --> 00:00:57,000 નોંધ્યું છે કે તે મને જાણ છે કે તે ઢબના રહી છે. 18 00:00:57,000 --> 00:01:00,000 Gedit નોંધ્યું કે ફાઈલ ડિસ્ક પર બદલાઈ ગયેલ છે, 19 00:01:00,000 --> 00:01:08,000 અને જો હું ફરીથી લોડ કરો ક્લિક કરો, તમારા બધા સમસ્યાઓ હવે ઓટોમેટેડ છે. 20 00:01:08,000 --> 00:01:15,000 [વધાવી] 21 00:01:15,000 --> 00:01:17,000 કે જે વસ્તુઓ અમે આ સપ્તાહમાં કર્યું છે. 22 00:01:17,000 --> 00:01:20,000 સમજો કે તે અપૂર્ણ છે, કારણ કે ત્યાં અમુક કોડ છે 23 00:01:20,000 --> 00:01:23,000 કે તે ફક્ત સંપૂર્ણપણે stylize કરવાનો નથી, થશે 24 00:01:23,000 --> 00:01:26,000 સમજો પરંતુ હવે એ સાધન તમે લાભ ના લઈ શકે છે 25 00:01:26,000 --> 00:01:33,000 માત્ર જો ઉપર વ્યવસ્થિત વધુ મૂકવામાં errantly સર્પાકાર કૌંસ કેટલાક અને ગમે છે. 26 00:01:33,000 --> 00:01:36,000 >> પરંતુ વધુ આકર્ષક હવે CS50 તપાસ છે. 27 00:01:36,000 --> 00:01:39,000 CS50 તપાસ સાથે, તમે ખરેખર આ જ ચોકસાઈ પરીક્ષણો કરી શકો છો 28 00:01:39,000 --> 00:01:42,000 તમારા પોતાના કોડ કે જે શિક્ષણ ફેલો કરવા સક્ષમ હોય છે છે. 29 00:01:42,000 --> 00:01:44,000 આ આદેશ વાક્ય ઉપયોગીતા છે કે જે ઉપકરણ હવે આવે છે 30 00:01:44,000 --> 00:01:46,000 જલદી તમે દીઠ તરીકે update50 કરવું 31 00:01:46,000 --> 00:01:49,000 pset 4 સ્પષ્ટીકરણો, તમે અને તે અનિવાર્યપણે ઉપયોગ આના જેવું જ. 32 00:01:49,000 --> 00:01:51,000 તમે આદેશ check50 ચલાવો. 33 00:01:51,000 --> 00:01:56,000 પછી તમે આદેશ વાક્ય દલીલ પાસ, અથવા વધુ સામાન્ય રીતે સ્વીચ અથવા ધ્વજ તરીકે પણ ઓળખાય છે. 34 00:01:56,000 --> 00:01:58,000 સામાન્ય રીતે, વસ્તુઓ છે કે જે hyphens પાસે સ્વીચ તરીકે ઓળખવામાં આવે છે 35 00:01:58,000 --> 00:02:02,000 આદેશ વાક્ય કાર્યક્રમ છે, તેથી-c સ્પષ્ટ 36 00:02:02,000 --> 00:02:04,000 ચકાસણીઓમાંની કે જે તમે ચલાવવા માંગો છો. 37 00:02:04,000 --> 00:02:07,000 >> આ પરીક્ષણો છે કે જે તમે ચલાવવા માંગો છો આ શબ્દમાળાને દ્વારા વિશિષ્ટ રીતે ઓળખાય છે, 38 00:02:07,000 --> 00:02:10,000 2012/pset4/resize. 39 00:02:10,000 --> 00:02:13,000 અન્ય શબ્દોમાં, કે જે હમણાં જ એક મનસ્વી પરંતુ અનન્ય શબ્દમાળા છે 40 00:02:13,000 --> 00:02:18,000 કે અમે અનન્ય pset હિસ્સો 4 ચોકસાઈ પરીક્ષણો ઓળખવા વાપરો. 41 00:02:18,000 --> 00:02:21,000 અને પછી તો તમે ફાઈલો એક જગ્યા અલગ પડેલ યાદી સ્પષ્ટ કરે છે કે તમે અપલોડ કરવા માંગો છો 42 00:02:21,000 --> 00:02:24,000 વિશ્લેષણ માટે CS50 તપાસ માટે. 43 00:02:24,000 --> 00:02:29,000 હમણાં પૂરતું, જો હું મારા દ્રાવણમાં માટે અહીં જાઓ resize.c- 44 00:02:29,000 --> 00:02:31,000 દો મને એક મોટી બારી ટર્મિનલ ખોલો 45 00:02:31,000 --> 00:02:42,000 અને હું આગળ વધો અને ચાલો સ્કોર check50-c 2012/pset4/resize કહે, 46 00:02:42,000 --> 00:02:46,000 અને પછી હું આગળ જાઓ અને ફાઈલો નામો સ્પષ્ટ કરવા માટે, 47 00:02:46,000 --> 00:02:49,000 resize.c, અને પછી Enter ફટકો તે સંકોચન કરતું, 48 00:02:49,000 --> 00:02:53,000 તે અપલોડ્સ, તે ચકાસે છે, અને હું માત્ર પરીક્ષણ સમગ્ર જથ્થો નિષ્ફળ ગયું. 49 00:02:53,000 --> 00:02:59,000 શીર્ષ પર ડાબે લાલ માં એક કહે છે કે resize.c અને bmp અસ્તિત્વ ધરાવે છે. 50 00:02:59,000 --> 00:03:01,000 કે કસોટી હતી. કે પ્રશ્ન અમે કહેવામાં આવી હતી. 51 00:03:01,000 --> 00:03:04,000 અને તે નાખુશ છે કારણ કે જવાબ ખોટા હતા. 52 00:03:04,000 --> 00:03:08,000 તેને નીચે સફેદ લખાણ કહે છે તે અસ્તિત્વમાં bmp.h અપેક્ષિત છે, અને તે માત્ર મારા દોષ છે. 53 00:03:08,000 --> 00:03:11,000 હું તેને અપલોડ કરવા માટે ભૂલી ગયા છો, તેથી હું બન્ને ફાઇલો અપલોડ કરવાની જરૂર છે, 54 00:03:11,000 --> 00:03:14,000 resize.c અને bmp.h. 55 00:03:14,000 --> 00:03:17,000 પરંતુ હવે અન્ય પરીક્ષણો તમામ પીળો છે નોટિસ કારણ કે તેઓ નથી ચાલે છે, 56 00:03:17,000 --> 00:03:21,000 અને તેથી હસતો ચહેરો ઊભી છે કારણ કે તેઓ ન તો ખુશ ન ઉદાસી છે, 57 00:03:21,000 --> 00:03:25,000 પરંતુ અમે લાલ કે મુદ્દો નિવારણ પહેલાં તે અન્ય ચેકો રન કરશે. 58 00:03:25,000 --> 00:03:27,000 >> મને આ નક્કી કરે છે. 59 00:03:27,000 --> 00:03:30,000 મને બહાર ઝૂમ અને આ પુનઃ ચલાવો, bmp.h સાથે પણ આ સમય 60 00:03:30,000 --> 00:03:34,000 આદેશ વાક્ય પર, દાખલ કરો, અને હવે જો તમામ સારી રીતે જાય, 61 00:03:34,000 --> 00:03:38,000 તે પછી અને પરિણામે તપાસ પરત તમારા પકડ ચાલી રહ્યું છે શ્વાસ- 62 00:03:38,000 --> 00:03:42,000 બધા લીલા, જેનો અર્થ થાય છે કે હું ખરેખર સારી 4 pset પર કરી રહ્યો છું અત્યાર સુધી. 63 00:03:42,000 --> 00:03:44,000 તમે જુઓ છો અને વર્ણનાત્મક ટેક્સ્ટ માંથી અટકળ બાંધવી અહીં કરી શકો છો 64 00:03:44,000 --> 00:03:47,000 બરાબર શું છે અમે પરીક્ષણ કર્યું છે. 65 00:03:47,000 --> 00:03:49,000 અમે પરીક્ષણ પ્રથમ ફાઇલો અસ્તિત્વમાં હોય? 66 00:03:49,000 --> 00:03:51,000 પછી અમે પરીક્ષણ resize.c કમ્પાઇલ કરે છે? 67 00:03:51,000 --> 00:03:58,000 તો પછી અમે એ નથી કે તે ફરીથી કદમાં જ્યારે n એ, એ પુન: માપ પરિબળ, 1 છે નથી 1x1-પિક્સેલ બીએમપી પરીક્ષણ કર્યું છે. 68 00:03:58,000 --> 00:04:01,000 હવે, જો તમે કોઈ વિચાર n એ શું છે, તો તમે એક વાર તમે 4 pset માં ડાઇવ કરશે, 69 00:04:01,000 --> 00:04:04,000 પરંતુ તે માત્ર એક સેનીટી ચકાસવા માટે ખાતરી કરો કે તમે માપ બદલવાની નથી કરો 70 00:04:04,000 --> 00:04:08,000 બધા એક છબી જો પુન: માપ પરિબળ 1 છે. 71 00:04:08,000 --> 00:04:14,000 જો તેનાથી વિપરિત, તે 2x2 યોગ્ય રીતે એક 1x1 પિક્સેલ બીએમપી માટે 1x1 પિક્સેલ resizes 72 00:04:14,000 --> 00:04:19,000 જ્યારે n 2 છે, પછી એ જ રીતે, ખાણ મુજબ રચાય છે. 73 00:04:19,000 --> 00:04:22,000 >> ટૂંકમાં, આ કરવા માટે, એક જ છે, જે પાર આંગળીઓને લેવા 74 00:04:22,000 --> 00:04:25,000 તમે પહેલાં અધિકાર સમીકરણની તમારા pset સબમિટ કરો. 75 00:04:25,000 --> 00:04:28,000 તમે જાણતા હશે ચોકકસ શું તમારા ટીએફ ટૂંક જાણતા હશે 76 00:04:28,000 --> 00:04:30,000 , જ્યારે તમે આ સમસ્યા સેટ કેટલાક સબમિટ વિશે જાઓ 77 00:04:30,000 --> 00:04:34,000 અને શિક્ષણશાસ્ત્ર વિષયક પ્રેરણા ખરેખર છે મૂકવા 78 00:04:34,000 --> 00:04:37,000 તમે સામે કે જેથી તક જ્યારે તમે તર્કગમ્ય ખબર 79 00:04:37,000 --> 00:04:39,000 કે ત્યાં તમારો કોડ માં ભૂલો અને પરીક્ષણો છે કે જે પસાર થઈ રહી નથી છે, 80 00:04:39,000 --> 00:04:43,000 તમે વધુ અસરકારક સમય આગળ ઉપર મૂકવા માટે તે સમસ્યા હલ કરી શકો છો 81 00:04:43,000 --> 00:04:45,000 બદલે પોઈન્ટ ગુમાવી, તમારા ટીએફ માંથી પ્રતિસાદ મેળવવા, 82 00:04:45,000 --> 00:04:48,000 અને પછી જાઓ, "Ahh," જેમ હું જે figured છે કરીશું. 83 00:04:48,000 --> 00:04:50,000 હવે ઓછામાં ઓછા ત્યાં મદદ માટે છે કે જે તમને શોધવા સાધન છે. 84 00:04:50,000 --> 00:04:52,000 તે બહાર નિર્દેશ જ્યાં ભૂલ નથી જવાનું, પણ તે તમને જણાવશે 85 00:04:52,000 --> 00:04:54,000 તે દર્શાવે છે. 86 00:04:54,000 --> 00:04:57,000 >> હવે ખ્યાલ એ પરીક્ષણો જરૂરી સંપૂર્ણ નથી. 87 00:04:57,000 --> 00:04:59,000 જસ્ટ કારણ કે તમે એક લીલો હસતો ચહેરાઓ પૂર્ણ સ્ક્રીન વિચાર 88 00:04:59,000 --> 00:05:02,000 નથી તેનો અર્થ નથી, તમારો કોડ પરિપૂર્ણ છે પરંતુ તે અર્થ એ નથી 89 00:05:02,000 --> 00:05:06,000 કે તે ચોક્કસ ઉલ્લેખ દ્વારા સૂચવવામાં પરીક્ષણ પાસ છે. 90 00:05:06,000 --> 00:05:08,000 ક્યારેક અમે તપાસમાં નથી પ્રકાશિત થશે. 91 00:05:08,000 --> 00:05:10,000 હમણાં પૂરતું, ગૂઢ રહસ્યની અથવા ડિટેક્ટિવ વાર્તા કે નાટક, એક 4 pset પાસાંઓ છે, 92 00:05:10,000 --> 00:05:15,000 છે નિરાશાજનક પ્રકારની જો અમે તમને આપી 93 00:05:15,000 --> 00:05:18,000 તે શું છે, અને ત્યાં છતી ઘણી છે તે જવાબ 94 00:05:18,000 --> 00:05:21,000 જે વ્યક્તિ કે લાલ અવાજ છે. 95 00:05:21,000 --> 00:05:24,000 આ સ્પેક હંમેશા pset 5 આગળ માટે ભવિષ્યમાં સ્પષ્ટ થશે 96 00:05:24,000 --> 00:05:26,000 શું તમે અસ્તિત્વમાં ચકાસે છે. 97 00:05:26,000 --> 00:05:28,000 તમે નોટિસ પડશે ત્યાં નીચે આ સફેદ URL છે. 98 00:05:28,000 --> 00:05:30,000 હવે માટે, આ માત્ર તપાસ આઉટપુટ છે. 99 00:05:30,000 --> 00:05:33,000 જો તમે તે URL ની મુલાકાત લો, તમે ઉન્મત્ત, છુપાયેલું સંદેશાઓ સંપૂર્ણ જથ્થો મળશે 100 00:05:33,000 --> 00:05:36,000 કે જે તમે મારફતે જોવા સ્વાગત કરશો, પરંતુ તે સ્ટાફ માટે મોટે ભાગે છે 101 00:05:36,000 --> 00:05:41,000 તેથી અમે નિદાન અને check50 પોતે ભૂલો ડિબગ કરી શકો છો. 102 00:05:41,000 --> 00:05:46,000 >> મુસીબત વગર, ચાલો જ્યાં અમે બોલ છોડી પર ખસેડો. 103 00:05:46,000 --> 00:05:48,000 CS50 પુસ્તકાલય અમે લીધો માટે અમુક અઠવાડિયા માટે મંજૂર 104 00:05:48,000 --> 00:05:52,000 પછી પરંતુ છેલ્લા અઠવાડિયે, અમે પાછા એક તેનો સ્તરોની peeling શરૂ કર્યું. 105 00:05:52,000 --> 00:05:55,000 અમે એકાંતે બદલે શું તરફેણમાં શબ્દમાળા મૂકવા શરૂ? 106 00:05:55,000 --> 00:05:57,000 [વિદ્યાર્થીઓ] ચાર. 107 00:05:57,000 --> 00:05:59,000 ચાર *, જે ઘરનાં પરચૂરણ કામો * કરવામાં આવ્યો છે અને આ તમામ સમય, 108 00:05:59,000 --> 00:06:03,000 પરંતુ હવે અમે ડોળ કરે છે કે તે એક વાસ્તવિક માહિતી પ્રકાર શબ્દમાળા છે નથી. 109 00:06:03,000 --> 00:06:06,000 તેના બદલે, તે પ્રકારની સમાનાર્થી ઘરનાં પરચૂરણ કામો * માટે લાગે, 110 00:06:06,000 --> 00:06:09,000 અને શબ્દમાળા અક્ષરો ક્રમ છે, 111 00:06:09,000 --> 00:06:14,000 તેથી તે શા માટે અર્થમાં બનાવવા નથી ઘરનાં પરચૂરણ કામો * ઓ તરીકે શબ્દમાળાઓ પ્રતિનિધિત્વ? 112 00:06:14,000 --> 00:06:20,000 ચાર રચે છે * શું શબ્દમાળા આ વિચાર સંદર્ભમાં પ્રતિનિધિત્વ કરે છે? 113 00:06:20,000 --> 00:06:23,000 યાહ >> [વિદ્યાર્થી]. પ્રથમ અક્ષર. 114 00:06:23,000 --> 00:06:25,000 ગુડ, પ્રથમ અક્ષર છે, પરંતુ તદ્દન પ્રથમ અક્ષર. 115 00:06:25,000 --> 00:06:27,000 તે [વિદ્યાર્થીઓ] સરનામું છે. 116 00:06:27,000 --> 00:06:29,000 ગુડ, પ્રથમ અક્ષર ની સરનામું. 117 00:06:29,000 --> 00:06:33,000 બધા જરૂરી છે માટે કોમ્પ્યુટરની મેમરીમાં શબ્દમાળા પ્રતિનિધિત્વ 118 00:06:33,000 --> 00:06:36,000 ફક્ત તેની પ્રથમ બાઇટ તે અનન્ય સરનામું છે. 119 00:06:36,000 --> 00:06:38,000 તમે પણ જાણતા લાંબા તે કેવી રીતે નથી હોય 120 00:06:38,000 --> 00:06:42,000 કારણ કે તમે કેવી રીતે આકૃતિ બહાર ગતિશીલ કરી શકે છે? 121 00:06:42,000 --> 00:06:44,000 [વિદ્યાર્થી] શબ્દમાળા રન નોંધાયો નહીં. 122 00:06:44,000 --> 00:06:48,000 તમે શબ્દમાળા લંબાઈ, ઉત્તમ છે, પરંતુ શબ્દમાળા લંબાઈ કામ કરે છે કેવી રીતે કહી શકે છે? 123 00:06:48,000 --> 00:06:50,000 તે શું કરે છે? યાહ. 124 00:06:50,000 --> 00:06:52,000 [વિદ્યાર્થી] જઈને ત્યાં સુધી તમે નલ અક્ષર વિચાર રાખો. 125 00:06:52,000 --> 00:06:54,000 અરે વાહ, બરાબર, તે માત્ર લૂપ માટે એક સાથે iterates, લૂપ જ્યારે, 126 00:06:54,000 --> 00:06:57,000 * ના અંત ગમે છે, અને ઓવરને રજૂ થાય છે 127 00:06:57,000 --> 00:07:01,000 0 \ દ્વારા કહેવાતા nul પાત્ર, nul, 128 00:07:01,000 --> 00:07:05,000 માટે નલ, કે જે નિર્દેશક સાથે ભેળસેળ ન શકાય, 129 00:07:05,000 --> 00:07:07,000 જે વાતચીત આજે ફરીથી આવશે. 130 00:07:07,000 --> 00:07:11,000 >> અમે પાછા GetInt એક સ્તર peeled, અને પછી અમે GetString જોતા હતા, 131 00:07:11,000 --> 00:07:14,000 અને તે વિધેયો બંને ખરેખર, અથવા યાદ, 132 00:07:14,000 --> 00:07:18,000 GetString, ચોક્કસ કાર્ય મદદથી હતી 133 00:07:18,000 --> 00:07:21,000 ખરેખર પાર્સ છે, કે જે, અથવા વંચાય છે વિશ્લેષણ, વપરાશકર્તાની ઇનપુટ. 134 00:07:21,000 --> 00:07:25,000 અને જે નવા કાર્ય શું છે? 135 00:07:25,000 --> 00:07:27,000 Scanf અથવા sscanf. વાસ્તવમાં તે થોડા અલગ લોટમાંથી બનાવવામાં આવે છે. 136 00:07:27,000 --> 00:07:31,000 ત્યાં scanf છે, ત્યાં sscanf છે, ત્યાં fscanf છે. 137 00:07:31,000 --> 00:07:35,000 હવે માટે, જોકે, ચાલો એક વધુ સરળતાથી સમજાવી પર કેન્દ્રિત છે, 138 00:07:35,000 --> 00:07:38,000 દો અને મને આગળ વધો અને સાધન માં ખોલવા 139 00:07:38,000 --> 00:07:41,000 આ જેવા ફાઇલ, scanf1.c. 140 00:07:41,000 --> 00:07:43,000 આ એક સુપર સરળ કાર્યક્રમ છે, 141 00:07:43,000 --> 00:07:46,000 પરંતુ તે કંઈક કે અમે ક્યારેય કર્યું છે કરે છે 142 00:07:46,000 --> 00:07:48,000 આ CS50 પુસ્તકાલય ની મદદ વગર. 143 00:07:48,000 --> 00:07:51,000 આ વપરાશકર્તા માંથી પૂર્ણાંક નોંધાયો નહીં. તે કેવી રીતે કામ કરે છે? 144 00:07:51,000 --> 00:07:53,000 વેલ, 16 ત્યાં લીટી માં, 145 00:07:53,000 --> 00:07:56,000 નોંધ્યું છે કે અમે પૂર્ણાંક કહેવાય એક્સ જાહેર અને વાર્તામાં આ બિંદુએ, 146 00:07:56,000 --> 00:07:58,000 x ની કિંમત શું છે? 147 00:07:58,000 --> 00:08:00,000 [અશ્રાવ્ય વિદ્યાર્થી જવાબ] 148 00:08:00,000 --> 00:08:02,000 [ડેવિડ એમ] અધિકાર કોણ જાણે, કેટલાક કચરો કિંમત સંભવિત છે, તેથી 17 માં, અમે માત્ર વપરાશકર્તા કહેવું 149 00:08:02,000 --> 00:08:06,000 મને નંબર આપવા માટે, કૃપા કરીને, અને 18 પગલું છે જ્યાં તે રસપ્રદ નોંધાયો નહીં. 150 00:08:06,000 --> 00:08:11,000 Scanf માટે printf એક વિચાર છે કે જેમાં તે અવતરણ આ બંધારણમાં કોડ વાપરે ઉધાર લાગે છે. 151 00:08:11,000 --> 00:08:13,000 % D કોર્સ એક અક્ષાંશ નંબર છે. 152 00:08:13,000 --> 00:08:21,000 પરંતુ શા માટે હું અને તેના બદલે એક્સ માત્ર એક્સ માં પસાર છું? 153 00:08:21,000 --> 00:08:24,000 ભૂતપૂર્વ યોગ્ય છે. યાહ. 154 00:08:24,000 --> 00:08:26,000 [અશ્રાવ્ય વિદ્યાર્થી જવાબ] 155 00:08:26,000 --> 00:08:31,000 બરાબર, જો આ કાર્યક્રમના ઉદ્દેશ, કાર્ય GetInt પોતે જેમ, 156 00:08:31,000 --> 00:08:34,000 છે વપરાશકર્તાના પૂર્ણાંક વિચાર હું વિધેયો પસાર કરી શકો છો 157 00:08:34,000 --> 00:08:38,000 તમામ ચલો હું માંગો છો, પરંતુ જો હું તેમને સંદર્ભ દ્વારા પાસ કરતું નથી 158 00:08:38,000 --> 00:08:41,000 અથવા સરનામા દ્વારા અથવા નિર્દેશક, આજની હેતુઓ માટે તમામ પર્યાય, 159 00:08:41,000 --> 00:08:46,000 પછી કાર્ય કરવા માટે કોઈ કે ચલ સમાવિષ્ટો બદલી કરવાની ક્ષમતા ધરાવે છે. 160 00:08:46,000 --> 00:08:49,000 આ એક નકલ માં સ્વેપ એ બગડેલ આવૃત્તિ જેવી જ પસાર કરશે 161 00:08:49,000 --> 00:08:51,000 કે અમે થોડા સમયમાં લગભગ હવે વાત કરી છે. 162 00:08:51,000 --> 00:08:54,000 >> પરંતુ તેના બદલે, આમ અને એક્સ દ્વારા, હું શું શાબ્દિક માં પસાર છું? 163 00:08:54,000 --> 00:08:57,000 [વિદ્યાર્થી] આ સરનામું. એક્સ ઓફ સરનામા. >> 164 00:08:57,000 --> 00:09:01,000 તે scanf કહેવાય કાર્ય માટે એક નકશો દોરવા અને અહીં જણાવ્યું હતું કે જેવું છે, 165 00:09:01,000 --> 00:09:04,000 આ કમ્પ્યુટર મેમરી એક ભાગ માટે દિશાઓ છે 166 00:09:04,000 --> 00:09:07,000 જે માટે તમારે સાઇન કેટલાક પૂર્ણાંક સંગ્રહવા જઈ શકે છે 167 00:09:07,000 --> 00:09:10,000 ક્રમમાં sscanf માટે હવે શું કરવું 168 00:09:10,000 --> 00:09:13,000 શું ઓપરેટર, વાક્યરચના કયા ભાગ તે માટે ઉપયોગ કરે છે રહ્યું છે 169 00:09:13,000 --> 00:09:19,000 છતાં પણ અમે તેને જોઈ કારણ કે કોઈએ આ કાર્ય લખ્યું કરી શકે છે? 170 00:09:19,000 --> 00:09:21,000 અન્ય શબ્દોમાં કહીએ - કે શું છે? 171 00:09:21,000 --> 00:09:23,000 [વિદ્યાર્થી] વાંચી એક્સ. 172 00:09:23,000 --> 00:09:27,000 ત્યાં કેટલાક વાંચન જ હશે, પરંતુ માત્ર એક્સ અહીં બાબતે. 173 00:09:27,000 --> 00:09:30,000 જો scanf x ની સરનામું કરવામાં આવી પસાર થાય છે, 174 00:09:30,000 --> 00:09:35,000 વાક્યરચના અનુસાર, ઓપરેટર શું ક્યાંક અસ્તિત્વમાં બંધાયેલ છે 175 00:09:35,000 --> 00:09:38,000 અંદર ની scanf અમલીકરણ કરે છે, જેથી scanf 176 00:09:38,000 --> 00:09:42,000 વાસ્તવમાં તે સરનામા માટે 2 નંબર લખી શકે? 177 00:09:42,000 --> 00:09:44,000 અરે વાહ, જેથી *. 178 00:09:44,000 --> 00:09:47,000 યાદ કે * અમારા ડિરેફરન્સ ઓપરેટર, જે અર્થ એવો થાય ત્યાં જવું. 179 00:09:47,000 --> 00:09:50,000 >> એકવાર તમે એક સરનામું કરવામાં આપ્યો કર્યું છે, કારણ કે કેસ અહીં છે, 180 00:09:50,000 --> 00:09:53,000 scanf કદાચ-જો આપણે છે તે ખરેખર તેના સ્ત્રોત આસપાસ જોવામાં કોડ 181 00:09:53,000 --> 00:09:59,000 છે * એક્સ અથવા વાસ્તવમાં તે સરનામા પર જાઓ અને કેટલાક કિંમત ત્યાં મૂકી સમકક્ષ કરી. 182 00:09:59,000 --> 00:10:02,000 હવે, તરીકે કેવી રીતે scanf કીબોર્ડ તરફથી ઇનપુટ નહીં, 183 00:10:02,000 --> 00:10:04,000 અમારા હાથ આજે બહાર વેવ પડશે. 184 00:10:04,000 --> 00:10:07,000 જસ્ટ ધારે છે કે ઓપરેટિંગ સિસ્ટમ સાથે વાત sscanf પરવાનગી આપે છે 185 00:10:07,000 --> 00:10:11,000 વપરાશકર્તાની કીબોર્ડ છે, પરંતુ આ 19 વાક્ય હવે બિંદુએ, 186 00:10:11,000 --> 00:10:14,000 જ્યારે અમે ફક્ત બહાર એક્સ છાપો, તે કેસ હોય તેમ લાગે છે 187 00:10:14,000 --> 00:10:17,000 scanf કે એક્સ માં પૂર્ણાંક મૂકવામાં આવ્યું છે. 188 00:10:17,000 --> 00:10:19,000 કે ખરેખર કેવી રીતે કામ કરે છે scanf છે, અને છેલ્લા અઠવાડિયે યાદ 189 00:10:19,000 --> 00:10:25,000 કે બરાબર કેવી રીતે GetString અને GetInt અને તેના કાર્યો અન્ય કુટુંબ 190 00:10:25,000 --> 00:10:28,000 આખરે કામ કરે છે, sscanf જેમ થોડો અણબનાવ હોવા છતાં, 191 00:10:28,000 --> 00:10:31,000 જેનો અર્થ થાય છે કે જેને બદલે શબ્દમાળા સ્કેન કરે છે. 192 00:10:31,000 --> 00:10:33,000 દો પરંતુ આ થોડો અણબનાવ પર એક નજર. 193 00:10:33,000 --> 00:10:37,000 Scanf2, હું ખરેખર અપ ખરાબ કર્યું. 194 00:10:37,000 --> 00:10:42,000 શું ખોટું અને છે હું ટિપ્પણી કે ખૂબ જ સમજાવે છે છુપાવવા પડશે 195 00:10:42,000 --> 00:10:47,000 શું આ કાર્યક્રમ સાથે ખોટું છે, સંસ્કરણ 2? 196 00:10:47,000 --> 00:10:55,000 કારણ કે આ સમય શક્ય તકનીકી રહો. 197 00:10:55,000 --> 00:10:57,000 તે ખૂબ સારી દેખાય છે. 198 00:10:57,000 --> 00:11:03,000 તે સરસ રીતે, ઇન્ડેન્ટેડ છે પરંતુ- 199 00:11:03,000 --> 00:11:07,000 ઠીક, કેવી રીતે આપણે તેના ટૂંકા પ્રશ્નો માટે નીચે વૃક્ષ, રોપા, વેલીનાં નકામાં ડાળ, ડાંખળાં, પાન, વગેરે કાપી નાખીને તેને ઘાટમાં લેવાં? 200 00:11:07,000 --> 00:11:17,000 16 લાઇન. 16 વાક્ય ચોક્કસ પરંતુ તકનિકી ઇંગલિશ માં કરી શું છે? 201 00:11:17,000 --> 00:11:20,000 થોડું ત્રાસદાયક મેળવી. હા, માઇકલ. 202 00:11:20,000 --> 00:11:25,000 [વિદ્યાર્થી] તે એક શબ્દમાળા પ્રથમ અક્ષર તરફ ઇશારો કરે છે. 203 00:11:25,000 --> 00:11:27,000 >> ઠીક છે, બંધ. મને કે થોડો ઝટકો. 204 00:11:27,000 --> 00:11:33,000 શબ્દમાળા પ્રથમ અક્ષર માટે પોઇન્ટિંગ, તો તમે ચલ કહેવાય બફર જાહેર કરવામાં આવે છે 205 00:11:33,000 --> 00:11:36,000 કે જે શબ્દમાળા પ્રથમ સરનામા માટે નિર્દેશ કરી, 206 00:11:36,000 --> 00:11:39,000 અથવા બદલે છે, કે જે વધારે કામની પાળી માટે ખાસ નિર્દેશ કરશે. 207 00:11:39,000 --> 00:11:42,000 વાસ્તવમાં તે ગમે ત્યાં નથી પોઇન્ટ છે કારણ કે ત્યાં કોઈ સોંપણી ઓપરેટર છે નોટિસ. 208 00:11:42,000 --> 00:11:46,000 ત્યાં કોઈ સમાન નિશાની છે, જેથી તમામ અમે કરી રહ્યા છીએ તે ચલ કહેવાતા બફર allocating છે. 209 00:11:46,000 --> 00:11:49,000 તે 32 બિટ્સ બને છે કારણ કે તે એક નિર્દેશક છે, 210 00:11:49,000 --> 00:11:52,000 બફર સમાવિષ્ટો કદાચ છેવટે અને 211 00:11:52,000 --> 00:11:57,000 ચાર રચે એક સરનામું સમાવે છે, પણ હવે, બફર શું છે? 212 00:11:57,000 --> 00:11:59,000 જસ્ટ કેટલાક બનાવટી કોણ જાણે, કેટલાક કચરો કિંમત, 213 00:11:59,000 --> 00:12:03,000 કારણ કે અમે તેને બાહ્ય રીતે નથી આરંભ છે, તેથી અમે કંઈપણ નથી લાગતું કરીશું. 214 00:12:03,000 --> 00:12:06,000 ઠીક છે, તેથી હવે 17 વાક્ય શું છે 17 લીટી કરતું હોય તો શું? 215 00:12:06,000 --> 00:12:08,000 કદાચ કે આ ઉપર ગરમ કરશે. 216 00:12:08,000 --> 00:12:10,000 તે શબ્દમાળા અધિકાર છાપે છે? 217 00:12:10,000 --> 00:12:12,000 તે છાપે શબ્દમાળા કરો. 218 00:12:12,000 --> 00:12:15,000 >> 18 લીટી પરિચિત પ્રકારની હવે એ છે કે અમે ફક્ત આ એક અણબનાવ જોયું 219 00:12:15,000 --> 00:12:18,000 પરંતુ અલગ ફોર્મેટ કોડ સાથે છે, તેથી 18 લીટી માં, 220 00:12:18,000 --> 00:12:23,000 અમે scanf કહેવાની કરી રહ્યાં છો અહીં મેમરી એક ભાગ સરનામું છે. 221 00:12:23,000 --> 00:12:27,000 હું તમને એક શબ્દમાળા માં ઉપર ફોન કરો,% s દ્વારા સૂચિત કરવા માંગો છો, 222 00:12:27,000 --> 00:12:32,000 પરંતુ સમસ્યા એ છે કે આપણે વસ્તુઓને એક દંપતિ અહીં કર્યું નથી. 223 00:12:32,000 --> 00:12:35,000 એક સમસ્યાઓ શું છે? 224 00:12:35,000 --> 00:12:38,000 [વિદ્યાર્થી] તે એક NULL નિર્દેશક ખોટો સંદર્ભ માટે પ્રયાસ કરી રહી છે. 225 00:12:38,000 --> 00:12:41,000 ગુડ, નલ અથવા ફક્ત અન્યથા અજ્ઞાત પોઇન્ટર. 226 00:12:41,000 --> 00:12:45,000 તમે scanf એક સરનામું સોંપવામાં કરી રહ્યાં છો, પરંતુ તમે માત્ર એક ક્ષણ પહેલા કહ્યું હતું કે, 227 00:12:45,000 --> 00:12:49,000 કે જે અમુક સરનામા કચરો કિંમત છે કારણ કે અમે ખરેખર કંઈપણ તેને ન સોંપો નહોતી, 228 00:12:49,000 --> 00:12:53,000 અને તેથી તમે કહેતાં રહ્યાં છો scanf અસરકારક રીતે જવું શબ્દમાળા અહીં મૂકો, 229 00:12:53,000 --> 00:12:56,000 પરંતુ અમે જ્યાં હજી સુધી અહીં છે ખબર નહિં હોય, 230 00:12:56,000 --> 00:12:59,000 તેથી અમે ખરેખર બફર માટે મેમરી નથી ફાળવવામાં આવ્યા છે. 231 00:12:59,000 --> 00:13:03,000 વધુમાં, તમે શું પણ છે scanf પણ કહેવાની? 232 00:13:03,000 --> 00:13:06,000 ધારો કે આ મેમરી એક ભાગ હતો, અને તે કચરો કિંમત ન હતી, 233 00:13:06,000 --> 00:13:09,000 પરંતુ તમે હજુ પણ મહત્વપૂર્ણ કંઈક કહેવાની થતો નથી scanf. 234 00:13:09,000 --> 00:13:12,000 [વિદ્યાર્થી] તે ક્યાં ખરેખર છે, & "અને" નું ચિહ્ન. 235 00:13:12,000 --> 00:13:15,000 & "અને" નું ચિહ્ન છે, તેથી આ કિસ્સામાં, તે ઠીક છે. 236 00:13:15,000 --> 00:13:18,000 કારણ કે બફર પહેલાથી જ એક નિર્દેશક તરીકે જાહેર કરવામાં આવે છે 237 00:13:18,000 --> 00:13:22,000 સિન્ટેક્ષ ના * ભાગ સાથે, અમે & "અને" નું ચિહ્ન ઉપયોગ કરવાની જરૂર નથી 238 00:13:22,000 --> 00:13:25,000 કારણ કે તે પહેલાથી જ એક સરનામું છે, પરંતુ મને લાગે છે કે હું અહીં સાંભળ્યું. 239 00:13:25,000 --> 00:13:27,000 [વિદ્યાર્થી] મોટું તે કેવી રીતે છે? 240 00:13:27,000 --> 00:13:29,000 ગુડ, અમે scanf નથી કહેતાં મોટું કેવી રીતે આ બફર છે રહ્યાં છો, 241 00:13:29,000 --> 00:13:32,000 જેનો અર્થ થાય છે તો પણ બફર એક નિર્દેશક હતા, 242 00:13:32,000 --> 00:13:35,000 અમે scanf કહી રહ્યાં છે, એક શબ્દમાળા અહીં મૂકો, 243 00:13:35,000 --> 00:13:38,000 પરંતુ અહીં 2 બાઇટ્સ હોઇ શકે છે, તેને 10 બાઇટ્સ હોઇ શકે છે, તે મેગાબાઇટ હોઈ શકે છે. 244 00:13:38,000 --> 00:13:41,000 Scanf કોઈ વિચાર ધરાવે છે, અને કારણ કે આ મેમરી એક ભાગ છે 245 00:13:41,000 --> 00:13:43,000 કદાચ, તે હજુ સુધી શબ્દમાળા નથી. 246 00:13:43,000 --> 00:13:48,000 તે માત્ર ત્યારે જ શબ્દમાળા છે એક વાર તમે અક્ષરો અને \ મેમરી કે ભાગ માટે 0 લખો. 247 00:13:48,000 --> 00:13:51,000 હવે તે માત્ર મેમરી કેટલાક ભાગ છે. 248 00:13:51,000 --> 00:13:55,000 Scanf ખબર પડશે ત્યારે તે સરનામું લખીને રોકવા માટે. 249 00:13:55,000 --> 00:13:59,000 >> જો તમે ભૂતકાળમાં કેટલાક ઉદાહરણો છે જ્યાં હું રેન્ડમ કીબોર્ડ પર ટાઈપ યાદ 250 00:13:59,000 --> 00:14:03,000 બફર ઓવરફ્લો પ્રયત્ન કરી રહ્યા છે, અને અમે બરાબર છે કે જે વિશે શુક્રવારે વાત કરી. 251 00:14:03,000 --> 00:14:07,000 જો શત્રુ કોઈક તમારા કાર્યક્રમ એક બહુ મોટા શબ્દ injects 252 00:14:07,000 --> 00:14:10,000 અથવા વાક્ય અથવા શબ્દસમૂહ પછી તમે અપેક્ષા રાખતા હતા તમે રોળાઈ શકે છે 253 00:14:10,000 --> 00:14:13,000 મેમરી એક ભાગ છે, જે ખરાબ પરિણામ હોઈ શકે છે, 254 00:14:13,000 --> 00:14:15,000 સમગ્ર કાર્યક્રમ પોતે ઉપર લઈ જેવા હોય છે. 255 00:14:15,000 --> 00:14:17,000 અમે આ કોઈક ઠીક કરવાની જરૂર છે. 256 00:14:17,000 --> 00:14:20,000 મને બહાર ઝૂમ અને આ કાર્યક્રમ 3 આવૃત્તિ માં જાઓ. 257 00:14:20,000 --> 00:14:22,000 કે થોડો વધુ સારી છે. 258 00:14:22,000 --> 00:14:24,000 આ વૃતાન્તમાં, તફાવત નોટિસ. 259 00:14:24,000 --> 00:14:27,000 16 લીટી માં, હું ફરીથી એક ચલ કહેવાય બફર જાહેર છું, 260 00:14:27,000 --> 00:14:29,000 પરંતુ તે શું હવે? 261 00:14:29,000 --> 00:14:33,000 તે 16 અક્ષરો ઝાકઝમાળ છે. 262 00:14:33,000 --> 00:14:36,000 આ સારી છે અને આ અર્થ કારણ કે હવે હું scanf કહી શકે છે 263 00:14:36,000 --> 00:14:39,000 અહીં મેમરી એક વાસ્તવિક ભાગ છે. 264 00:14:39,000 --> 00:14:42,000 તમે લગભગ પોઇંટરો હવે હોવાથી એરે વિચાર કરી શકો છો, 265 00:14:42,000 --> 00:14:44,000 છતાં પણ તેઓ ખરેખર સમકક્ષ નથી. 266 00:14:44,000 --> 00:14:47,000 તેઓ અલગ અલગ સંદર્ભમાં વર્તે પડશે. 267 00:14:47,000 --> 00:14:50,000 પરંતુ તે ચોક્કસપણે કેસ કે બફર સંદર્ભ આપે છે છે 268 00:14:50,000 --> 00:14:53,000 16 સંલગ્ન અક્ષરો કારણ કે કે એક એરે શું છે 269 00:14:53,000 --> 00:14:55,000 અને કેટલાક અઠવાડિયા માટે હવે બની રહી છે. 270 00:14:55,000 --> 00:14:59,000 >> અહીં, હું scanf કહેવાની છું અહીં મેમરી એક ભાગ છે. 271 00:14:59,000 --> 00:15:01,000 આ સમય છે, તે ખરેખર મેમરી એક ભાગ છે, 272 00:15:01,000 --> 00:15:07,000 પરંતુ આ કાર્યક્રમ શા માટે છે હજી પણ વાપરી? 273 00:15:07,000 --> 00:15:11,000 શું ખોટું હજુ પણ છે? 274 00:15:11,000 --> 00:15:14,000 મેં કહ્યું કર્યા છે મને, પરંતુ-16 બાઇટ્સ આપી 275 00:15:14,000 --> 00:15:16,000 [વિદ્યાર્થી] તો શું તેઓ 16 કરતાં વધુ માં લખ્યું છે? 276 00:15:16,000 --> 00:15:20,000 બરાબર, જો 17 અક્ષરો અથવા 1700 અક્ષરો વપરાશકર્તા પ્રકારો? 277 00:15:20,000 --> 00:15:23,000 હકીકતમાં, ચાલો જોવા અમે આ ભૂલ પર સફર નથી કરી શકો છો હવે તો. 278 00:15:23,000 --> 00:15:25,000 તે વધુ સારી રીતે નથી, પરંતુ સંપૂર્ણ છે. 279 00:15:25,000 --> 00:15:28,000 મને આગળ વધો અને scanf3 બનાવવા માટે આ કાર્યક્રમ કમ્પાઇલ ચલાવો. 280 00:15:28,000 --> 00:15:34,000 મને scanf3 ચલાવવા માટે, કૃપા કરીને શબ્દમાળા: હેલો, અને અમે ઠીક લાગે છે. 281 00:15:34,000 --> 00:15:37,000 મને થોડી લાંબા સમય સુધી એક પ્રયાસ કરો, હેલો ત્યાં. 282 00:15:37,000 --> 00:15:42,000 ઠીક છે, હેલ્લો ત્યાં દો કેવી રીતે આજે તમે છે, દાખલ કરો. 283 00:15:42,000 --> 00:15:54,000 નસીબદાર પ્રકારની અહીં મેળવી રહ્યા છે, ચાલો હેલ્લો ત્યાં કહેવું તમે કેવી રીતે છે. 284 00:15:54,000 --> 00:15:56,000 તે ખરેખર ખૂબ જ. 285 00:15:56,000 --> 00:16:03,000 ઠીક છે, તેથી અમે નસીબદાર મળી. ચાલો જોવા જો આપણે આ ન ઠીક કરી શકે છે. 286 00:16:03,000 --> 00:16:06,000 ના, તે દો મને પણ નકલ કરશો નહિં બનશે. 287 00:16:06,000 --> 00:16:09,000 ચાલો આ ફરીથી પ્રયાસ કરો. 288 00:16:09,000 --> 00:16:12,000 અધિકાર બધા દ્વારા ઊભી છે. 289 00:16:12,000 --> 00:16:20,000 અમે જોશો લાંબા હું કેવી રીતે ધ્યાન કેન્દ્રિત જ્યારે હજુ પણ આ કરી ડોળ કરી શકો છો. 290 00:16:20,000 --> 00:16:23,000 તે ખરેખર ખૂબ જ. કે બદલે યોગ્ય ખરેખર છે. 291 00:16:23,000 --> 00:16:26,000 ત્યાં અમે જાઓ. 292 00:16:26,000 --> 00:16:30,000 બિંદુ કરી હતી. 293 00:16:30,000 --> 00:16:34,000 >> આ મૂંઝવતી છતાં પણ તે છે, કે તે એક મહાન મૂંઝવણ સૂત્રોની 294 00:16:34,000 --> 00:16:38,000 જ્યારે કાર્યક્રમો કે જે ભૂલો હોય લખવાનું કારણ કે તેઓ પોતાની જાતને પ્રગટ 295 00:16:38,000 --> 00:16:40,000 માત્ર એક વખત ક્યારેક જ્યારે છે. 296 00:16:40,000 --> 00:16:43,000 આ વાસ્તવિકતા એ છે કે જો તમારી કોડ સંપૂર્ણપણે તૂટી જાય છે, 297 00:16:43,000 --> 00:16:46,000 તે માત્ર સંપૂર્ણપણે ટૂંક સમયમાં આવી શકે એકવાર ભાંગી 298 00:16:46,000 --> 00:16:49,000 કારણ કે, કેટલીકવાર અનિવાર્યપણે થાય છે શું ઓપરેટિંગ સિસ્ટમ ફાળવે છે 299 00:16:49,000 --> 00:16:52,000 તમે કરતાં થોડી વધુ મેમરી ખરેખર કારણ ગમે તે માટે જરૂર છે, 300 00:16:52,000 --> 00:16:57,000 અને તેથી કોઈ એક 16 અક્ષરો તમારા ભાગ પછી તરત મેમરી ઉપયોગ કરે છે, 301 00:16:57,000 --> 00:17:01,000 તેથી જો તમે 17, 18, 19, ગમે છે, તે જેમ કે મોટો સોદો નથી જાઓ. 302 00:17:01,000 --> 00:17:04,000 હવે, કોમ્પ્યુટર, પણ જો તે બિંદુ પર તૂટી નથી, 303 00:17:04,000 --> 00:17:09,000 છેવટે કંઈક બીજું બાઇટ નંબર 17 અથવા 18 અથવા 19 નો ઉપયોગ કરી શકે છે, 304 00:17:09,000 --> 00:17:14,000 જે અંતે તમારો ડેટા નિર્દેશ કરે છે કે તમે ત્યાં મૂકી લાંબા અતિશય છે, તેમ છતાં, 305 00:17:14,000 --> 00:17:18,000 છે ફરીથી લખાઈ કેટલાક અન્ય કાર્ય દ્વારા સંભવિત બનશે. 306 00:17:18,000 --> 00:17:21,000 તે આવશ્યકપણે માટે અકબંધ રહી નથી ચાલી રહ્યું છે, 307 00:17:21,000 --> 00:17:23,000 પરંતુ તે જરૂરી seg દોષ નથી કારણ બનશે. 308 00:17:23,000 --> 00:17:26,000 પરંતુ આ કિસ્સામાં, હું આખરે પર્યાપ્ત અક્ષરો પૂરી પાડવામાં 309 00:17:26,000 --> 00:17:29,000 કે હું અનિવાર્યપણે મેમરી મારા સેગમેન્ટમાં વટાવી ગયું, અને છેતરપિંડી, 310 00:17:29,000 --> 00:17:33,000 ઓપરેટિંગ સિસ્ટમ જણાવ્યું હતું કે, "માફ કરશો, તે કોઈ સારું, સેગ્મેન્ટેશન ક્ષતિમાં છે." 311 00:17:33,000 --> 00:17:38,000 >> દો અને હવે શું શું મારું અહીં રહે ડિરેક્ટરી- 312 00:17:38,000 --> 00:17:40,000 નોંધ્યું છે કે હું આ ફાઇલને અહીં છે, કોર. 313 00:17:40,000 --> 00:17:42,000 નોંધ કરો કે આ ફરી કોર ડમ્પ કહે છે. 314 00:17:42,000 --> 00:17:46,000 તે આવશ્યકપણે એક ફાઇલ છે કે જે તમારા કાર્યક્રમ મેમરી સામગ્રી સમાવે છે 315 00:17:46,000 --> 00:17:48,000 એક મુદ્દો છે જેમાં તે ક્રેશ થયું છે, 316 00:17:48,000 --> 00:17:51,000 અને થોડા ઉદાહરણ અહીં પ્રયાસ માત્ર દો મને અહીં જાઓ 317 00:17:51,000 --> 00:17:57,000 અને scanf3 પર gdb ચલાવો અને પછી ત્રીજા કોર કહેવાય દલીલ સ્પષ્ટ કરવા માટે, 318 00:17:57,000 --> 00:18:01,000 અને અહીં નોંધ્યું છે કે જો હું કોડ યાદી, 319 00:18:01,000 --> 00:18:06,000 અમે હંમેશની જેમ કરવાનો gdb સાથે આ કાર્યક્રમ દ્વારા વૉકિંગ શરૂ કરી શકશો, 320 00:18:06,000 --> 00:18:10,000 અને હું તેને ચલાવવા અને માં પગલું આદેશ સાથે હું ફટકો-તરીકે કરી શકો છો કે તરત gdb- 321 00:18:10,000 --> 00:18:13,000 જલદી હું વિશાળ શબ્દમાળા માં લખીને પછી સંભવિત બગડેલ રેખા દબાવો, 322 00:18:13,000 --> 00:18:16,000 હું ખરેખર તેને અહીં ઓળખવા માટે સમર્થ હશો. 323 00:18:16,000 --> 00:18:19,000 વધુ આ પર, છતાં, કોર ડમ્પ દ્રષ્ટિએ વિભાગમાં 324 00:18:19,000 --> 00:18:22,000 અને ગમે કે જેથી તમે ખરેખર આસપાસ કોર ડમ્પ કરી શકે થેલી, કોથળી અંદર 325 00:18:22,000 --> 00:18:27,000 અને જુઓ વાક્ય શું કાર્યક્રમ તમે નિષ્ફળ ગયું. 326 00:18:27,000 --> 00:18:32,000 પછી પોઇંટરો અને સરનામાં પર કોઈપણ પ્રશ્ન છે? 327 00:18:32,000 --> 00:18:36,000 પર આજે કારણ કે, અમે લેવા માટે મંજૂર છે કે આ વસ્તુઓ અસ્તિત્વ ધરાવે છે શરૂ જઈ રહ્યાં છો 328 00:18:36,000 --> 00:18:40,000 અને અમે જાણીએ છીએ કે ચોકકસ શું તેઓ છે. 329 00:18:40,000 --> 00:18:42,000 હા. 330 00:18:42,000 --> 00:18:46,000 >> [વિદ્યાર્થી] આવો તમે એક & "અને" નું ચિહ્ન આગામી મૂકી નહોતી કેવી રીતે ભાગ- 331 00:18:46,000 --> 00:18:48,000 પ્રશ્ન સારું. 332 00:18:48,000 --> 00:18:51,000 હું કેવી રીતે આવ્યા હતા હોય છે એક & "અને" નું ચિહ્ન અક્ષર એરે માટે આગામી મૂકી તરીકે હું અગાઉ ન 333 00:18:51,000 --> 00:18:53,000 અમારા ઉદાહરણો સાથે સૌથી? 334 00:18:53,000 --> 00:18:55,000 ટૂંકા જવાબ છે એરે થોડો ખાસ હોય છે. 335 00:18:55,000 --> 00:18:59,000 તમે લગભગ ખરેખર એક સરનામું તરીકેની બફર વિચાર કરી શકો છો, 336 00:18:59,000 --> 00:19:03,000 અને તે માત્ર જેથી આ કેસ બને છે કે ચોરસ કૌંસ સંકેતલિપિ 337 00:19:03,000 --> 00:19:06,000 સગવડ છે કે જેથી અમે 0 કૌંસ, 1 કૌંસ માં જઈ શકે છે, 338 00:19:06,000 --> 00:19:10,000 2 માટે * નોટેશનમાં ઉપયોગ કર્યા વગર, કૌંસ. 339 00:19:10,000 --> 00:19:13,000 કે જે સફેદ જૂઠ એક બીટ છે કારણ કે એરે અને પોઇન્ટર 340 00:19:13,000 --> 00:19:17,000 હકીકત છે, થોડુંક અલગ છે, પરંતુ તેઓ ઘણીવાર પરંતુ હંમેશા એકબીજાના ઉપયોગ કરી શકો છો. 341 00:19:17,000 --> 00:19:21,000 ટૂંકમાં, જ્યારે કાર્ય મેમરી એક ભાગ એક નિર્દેશક એવી અપેક્ષા છે, 342 00:19:21,000 --> 00:19:24,000 તમે ક્યાં તો તેને એક સરનામું કે malloc દ્વારા પરત ફર્યા હતા પસાર કરી શકો છો, 343 00:19:24,000 --> 00:19:29,000 અને અમે malloc ફરીથી લાંબા પહેલાં પડશે જુઓ, અથવા તમે તેને એરે નું નામ પસાર કરી શકે છે. 344 00:19:29,000 --> 00:19:32,000 તમે સંગ્રહ સાથે & "અને" નું ચિહ્ન કરતા નથી કારણ કે તેઓ પહેલાથી જ નથી 345 00:19:32,000 --> 00:19:34,000 અનિવાર્યપણે સરનામાં ગમે છે. 346 00:19:34,000 --> 00:19:36,000 કે એક અપવાદ છે. 347 00:19:36,000 --> 00:19:39,000 કુલ સ્કોર કૌંસ તેમને ખાસ બનાવે છે. 348 00:19:39,000 --> 00:19:41,000 >> તમે એક & "અને" નું ચિહ્ન મૂકી શકે બફર માટે આગામી? 349 00:19:41,000 --> 00:19:43,000 આ કિસ્સામાં નથી. 350 00:19:43,000 --> 00:19:46,000 કારણ કે ફરીથી, આ ખૂણામાં કેસ કામ કરશે 351 00:19:46,000 --> 00:19:49,000 એરે તદ્દન ખરેખર સરનામાં નથી જ્યાં. 352 00:19:49,000 --> 00:19:54,000 પરંતુ અમે કદાચ તે પહેલાં લાંબા પાછા અન્ય ઉદાહરણો સાથે આવી પડશે. 353 00:19:54,000 --> 00:19:56,000 ચાલો એક સમસ્યા અહીં ઉકેલ લાવવા પ્રયાસ કરો. 354 00:19:56,000 --> 00:20:00,000 અમે એ માહિતી બંધારણ છે કે અમે કેટલીક એક એરે તરીકે પણ ઓળખાય છે સમય માટે ઉપયોગ કરી રહ્યો છું હોય છે. 355 00:20:00,000 --> 00:20:02,000 બિંદુ માં કેસ, કે અમે શું માત્ર હતી. 356 00:20:02,000 --> 00:20:04,000 પરંતુ એરે કેટલાક upsides અને downsides છે. 357 00:20:04,000 --> 00:20:06,000 એરે સરસ શા માટે છે? 358 00:20:06,000 --> 00:20:11,000 એક વસ્તુ છે કે જે તમે ઇચ્છો-અંશે તમે એરે એરે-વિશે શું ગમે છે? 359 00:20:11,000 --> 00:20:13,000 શું તેમને વિશે અનુકૂળ છે? શું અનિવાર્ય છે? 360 00:20:13,000 --> 00:20:18,000 અમે પ્રથમ સ્થાને શા માટે ન હતી તેમને દાખલ? 361 00:20:18,000 --> 00:20:20,000 યાહ. 362 00:20:20,000 --> 00:20:27,000 [વિદ્યાર્થી] તેઓ માહિતી ઘણો સ્ટોર કરી શકો છો અને તમે સમગ્ર વસ્તુ ઉપયોગ નથી. 363 00:20:27,000 --> 00:20:29,000 તમે એક વિભાગનો ઉપયોગ કરી શકો છો. 364 00:20:29,000 --> 00:20:32,000 ગુડ, ઝાકઝમાળ તમે દશાંશ માહિતી ઘણો સ્ટોર કરી શકો છો સાથે, 365 00:20:32,000 --> 00:20:35,000 અને તમે જરૂરી તેને તેનો ઉપયોગ નથી, તેથી તમે overallocate કરી શકો છો, 366 00:20:35,000 --> 00:20:39,000 જે અનુકૂળ હોઈ શકે જો તમને અગાઉથી ખબર નથી એવી અપેક્ષા રાખે છે કંઈક કેટલી નથી શકે છે. 367 00:20:39,000 --> 00:20:41,000 >> GetString યોગ્ય ઉદાહરણ છે. 368 00:20:41,000 --> 00:20:44,000 GetString, અમને દ્વારા લેખિત, કોઈ વિચાર કેટલા અક્ષરો અપેક્ષા ધરાવે છે, 369 00:20:44,000 --> 00:20:48,000 તેથી હકીકત એ છે કે અમે સંલગ્ન મેમરી હિસ્સામાં ફાળવી શકે સારો છે. 370 00:20:48,000 --> 00:20:51,000 એરે પણ એક સમસ્યા અમે થોડા અઠવાડિયા પહેલા હવે જોયું ઉકેલવા 371 00:20:51,000 --> 00:20:54,000 જ્યાં તમારો કોડ માટે ખૂબ જ ખરાબ રીતે ડિઝાઇન કરવામાં કોઇ કાર્યમાં એકને શિરેથી ઊતરીને બીજાને શિરે જવું શરૂ થાય છે. 372 00:20:54,000 --> 00:20:57,000 જણાવ્યું હતું કે હું એક વિદ્યાર્થી ડેવિડ કહેવાય માળખું બનાવનાર, 373 00:20:57,000 --> 00:21:00,000 અને પછી તે ખરેખર એક વૈકલ્પિક હતો, અલબત્ત, 374 00:21:00,000 --> 00:21:04,000 એક ચલ કહેવાય નામ અને અન્ય મને લાગે છે કે, ઘર કહેવાય ચલ રહી છે, 375 00:21:04,000 --> 00:21:08,000 અને અન્ય ID ને કહેવાય છે કારણ કે તે આ વાર્તા માં હું પછી કંઈક બીજું દાખલ કરવા માગે છે ચલ 376 00:21:08,000 --> 00:21:11,000 પ્રોગ્રામમાં રોબ છો, તેથી તે પછી હું એક મિનિટ રાહ જુઓ નિર્ણય લીધો, 377 00:21:11,000 --> 00:21:13,000 હું આ ચલો નામ બદલી કરવાની જરૂર છે. 378 00:21:13,000 --> 00:21:16,000 ચાલો NAME1 ખાણ, ID1, house1 કૉલ કરો. 379 00:21:16,000 --> 00:21:20,000 ચાલો રોબ NAME2 ની, house2, ID2 કૉલ કરો. 380 00:21:20,000 --> 00:21:22,000 પરંતુ પછી ટોમી વિશે શું એક મિનિટ રાહ જુઓ! 381 00:21:22,000 --> 00:21:24,000 તો પછી અમે વધુ ત્રણ ચલો હતી. 382 00:21:24,000 --> 00:21:27,000 અમે કોઈએ, ચલો ચાર સેટમાં રજૂઆત કરી હતી. 383 00:21:27,000 --> 00:21:30,000 વિશ્વમાં અવ્યવસ્થિત ખૂબ જ ઝડપથી મેળવી શરૂ, 384 00:21:30,000 --> 00:21:33,000 તેથી અમે સ્ટ્ર્ક્ટ્સ રજૂઆત કરી હતી, અને શું સ્ટ્રક્ટ વિશે અનિવાર્ય છે? 385 00:21:33,000 --> 00:21:39,000 એક સી સ્ટ્રક્ટ શું તમને છે? 386 00:21:39,000 --> 00:21:42,000 તે ખરેખર ત્રાસદાયક છે આજે. 387 00:21:42,000 --> 00:21:44,000 શું >>? [અશ્રાવ્ય વિદ્યાર્થી જવાબ] 388 00:21:44,000 --> 00:21:47,000 અરે વાહ, ખાસ કરીને, typedef તમે નવી માહિતી પ્રકાર બનાવવા માટે પરવાનગી આપે છે, 389 00:21:47,000 --> 00:21:51,000 અને સ્ટ્રક્ટ, તો સ્ટ્રક્ટ કીવર્ડ, તમે પ્રાવૃત માટે પરવાનગી આપે છે 390 00:21:51,000 --> 00:21:54,000 માહિતી કલ્પનાત્મક સંબંધિત મળીને ટુકડાઓ 391 00:21:54,000 --> 00:21:56,000 અને ત્યાર બાદ તેમને વિદ્યાર્થી કંઈક કહી. 392 00:21:56,000 --> 00:21:58,000 >> કે સારા હતા કારણ કે હવે અમે નમૂનારૂપ બની શકે 393 00:21:58,000 --> 00:22:03,000 વધુ જેવું સરળ સુસંગત એક ચલ એક વિદ્યાર્થી કલ્પના 394 00:22:03,000 --> 00:22:07,000 બદલે આપખુદ શબ્દમાળા માટે એક, એક ID માટે આવી રહી છે, અને તેથી આગળ. 395 00:22:07,000 --> 00:22:10,000 એરે સરસ છે કારણ કે તેઓ અમને અમારી કોડ સફાઈ શરૂ કરવા માટે પરવાનગી આપે છે. 396 00:22:10,000 --> 00:22:13,000 પરંતુ શું નુકસાન હવે એક ઍરેની? 397 00:22:13,000 --> 00:22:15,000 તમે શું ન કરી શકો? યાહ. 398 00:22:15,000 --> 00:22:17,000 [વિદ્યાર્થી] તમે જાણતા મોટું તે કેવી રીતે હોય છે. 399 00:22:17,000 --> 00:22:19,000 તમે જાણવા મોટું તે કેવી રીતે હોય છે, જેથી તે પીડા પ્રકારની છે. 400 00:22:19,000 --> 00:22:21,000 તમે તે પહેલાં પ્રોગ્રામિંગ અનુભવ સાથે ખબર ભાષાઓ ઘણો માં, 401 00:22:21,000 --> 00:22:24,000 જાવા જેમ, તમે મેમરી એક ભાગ છે, ખાસ ઝાકઝમાળ પૂછી શકો છો, 402 00:22:24,000 --> 00:22:28,000 મોટું તમે કેવી રીતે હોય છે, લંબાઈ, મિલકત, તેથી વાત સાથે, અને તે ખરેખર અનુકૂળ છે. 403 00:22:28,000 --> 00:22:32,000 સી, તમે પણ સામાન્ય એરે પર strlen નથી કહી શકો છો 404 00:22:32,000 --> 00:22:35,000 strlen કારણ કે, જેમ શબ્દ સૂચિત કરે છે, શબ્દમાળાઓ માટે જ છે, 405 00:22:35,000 --> 00:22:39,000 અને તમે આ માનવ સંમેલન કારણે શબ્દમાળા લંબાઈ આકૃતિ કરી શકો છો 406 00:22:39,000 --> 00:22:43,000 એ \ 0, પરંતુ એક એરે કર્યા અને વધુ સામાન્ય છે, માત્ર મેમરી એક ભાગ છે. 407 00:22:43,000 --> 00:22:46,000 જો તે ints ઝાકઝમાળ છે, ત્યાં કેટલાક વિશિષ્ટ અક્ષર નથી ચાલી રહ્યું છે 408 00:22:46,000 --> 00:22:48,000 ઓવરને અંતે તમે પ્રતીક્ષામાં છે. 409 00:22:48,000 --> 00:22:50,000 તમારે એક એરે લંબાઈ યાદ છે. 410 00:22:50,000 --> 00:22:54,000 ઝાકઝમાળ અન્ય એક નુકસાન પોતે GetString તેના વડા ઉછેર. 411 00:22:54,000 --> 00:22:59,000 ઝાકઝમાળ અન્ય નુકસાન શું છે? 412 00:22:59,000 --> 00:23:01,000 સર, તમે મને અને માત્ર આજે. 413 00:23:01,000 --> 00:23:04,000 [અશ્રાવ્ય વિદ્યાર્થી પ્રતિભાવ] >> તે શું છે? 414 00:23:04,000 --> 00:23:06,000 તે સ્ટેક પર જાહેર કરવામાં આવ્યું છે. 415 00:23:06,000 --> 00:23:09,000 ઠીક છે, સ્ટેક પર જાહેર કરી હતી. તમે કે કેમ નથી ગમતી? 416 00:23:09,000 --> 00:23:13,000 [વિદ્યાર્થી] કારણ કે તે ફરીથી નહીં. 417 00:23:13,000 --> 00:23:15,000 તે ફરીથી નહીં. 418 00:23:15,000 --> 00:23:18,000 ઠીક છે, જો તમે એક એરે વાપરવા માટે મેમરીને ફાળવવા, 419 00:23:18,000 --> 00:23:21,000 તમે, ઉદાહરણ માટે નહિં, તો તે પરત ફરી શકે છે કારણ કે તે સ્ટેક પર છે. 420 00:23:21,000 --> 00:23:23,000 ઠીક છે, કે જે ગેરલાભ છે. 421 00:23:23,000 --> 00:23:25,000 અને કેવી રીતે આશરે એક ઝાકઝમાળ સાથે અન્ય? 422 00:23:25,000 --> 00:23:28,000 એકવાર તમે તેને ફાળવવા, તમે પ્રકારની ખરાબ જો તમને વધુ જગ્યાની જરૂર કરશો 423 00:23:28,000 --> 00:23:30,000 કરતાં કે એરે છે. 424 00:23:30,000 --> 00:23:34,000 >> તો પછી અમે રજૂઆત કરી હતી, સ્મૃતિ, malloc છે, જે અમને એ ગતિશીલ મેમરી ફાળવણી કરવાની ક્ષમતા આપી હતી. 425 00:23:34,000 --> 00:23:37,000 પરંતુ જો આપણે એક અલગ વિશ્વ સંપૂર્ણપણે પ્રયાસ કર્યો? 426 00:23:37,000 --> 00:23:40,000 જો અમે તે સમસ્યાઓ એક દંપતી ઉકેલવા માગે છે 427 00:23:40,000 --> 00:23:45,000 તેથી અમે જગ્યાએ મારું પેન નિદ્રાધીન અહીં ગયો છે 428 00:23:45,000 --> 00:23:51,000 જો આપણે તેને બદલે અનિવાર્યપણે વિશ્વ કે આ જેવા હવે બનાવવા માંગો? 429 00:23:51,000 --> 00:23:56,000 આ ઝાકઝમાળ છે, અને અલબત્ત, આ પ્રકારની ખરાબ એકવાર અમે એરે ઓવરને દબાવો, 430 00:23:56,000 --> 00:24:00,000 અને હવે હું લાંબા સમય સુધી અન્ય પૂર્ણાંક અથવા અન્ય પાત્ર માટે જગ્યા હોય છે. 431 00:24:00,000 --> 00:24:03,000 જો અમે પ્રકારના preemptively સારી કહી, અમે શા માટે આરામ નથી 432 00:24:03,000 --> 00:24:07,000 આ જરૂરિયાત છે કે મેમરી આ બધા ટુકડા પાછળ સંલગ્ન પાછળ હોઇ શકે છે, 433 00:24:07,000 --> 00:24:10,000 અને શા માટે, જ્યારે હું પૂર્ણાંક અથવા ઘરનાં પરચૂરણ કામો કરવાની જરૂર નથી, 434 00:24:10,000 --> 00:24:12,000 ફક્ત મને એક તેમને માટે જગ્યા આપી? 435 00:24:12,000 --> 00:24:14,000 અને જ્યારે હું અન્ય જરૂર છે, મને બીજા જગ્યા આપે છે, 436 00:24:14,000 --> 00:24:16,000 અને જ્યારે હું અન્ય જરૂર છે, મને બીજા જગ્યા આપે છે. 437 00:24:16,000 --> 00:24:19,000 જે લાભ હવે કોઈને જો બીજું છે 438 00:24:19,000 --> 00:24:21,000 અહીં ઉપર મેમરી, કોઈ મોટો સોદો લે છે. 439 00:24:21,000 --> 00:24:25,000 હું મેમરી આ વધારાના ભાગ અહીં છે અને પછી એક આ લઇશું. 440 00:24:25,000 --> 00:24:28,000 >> હવે, માત્ર અહીં કેચ છે કે આ લગભગ લાગે છે કે હું હોય 441 00:24:28,000 --> 00:24:30,000 વિવિધ ચલો સંપૂર્ણ જથ્થો. 442 00:24:30,000 --> 00:24:33,000 આ પાંચ જુદા જુદા સંભવિત ચલો જેમ લાગે છે. 443 00:24:33,000 --> 00:24:36,000 પરંતુ જો આપણે શબ્દમાળાઓ એક વિચાર ચોરી 444 00:24:36,000 --> 00:24:41,000 અમે કોઈક જેમાં આ વસ્તુઓ એકસાથે કલ્પનાત્મક લિંક કરવા માટે, અને જો હું આ હતી? 445 00:24:41,000 --> 00:24:44,000 આ મારું ખૂબ જ ખરાબ રીતે દોરવામાં તીર છે. 446 00:24:44,000 --> 00:24:46,000 ધારવું પરંતુ મેમરી આ હિસ્સામાં દરેક 447 00:24:46,000 --> 00:24:52,000 બીજા જણાવ્યું, અને આ વ્યક્તિ છે, જે પોતાના અધિકાર માટે આ બોલ પર કોઈ બહેન છે, 448 00:24:52,000 --> 00:24:54,000 આવી કોઈ તીર છે. 449 00:24:54,000 --> 00:24:56,000 આ હકીકત શું સંકળાયેલી યાદી તરીકે ઓળખાય છે છે. 450 00:24:56,000 --> 00:25:00,000 આ નવી માહિતી બંધારણ છે કે અમને મેમરી એક ભાગ ફાળવવા માટે પરવાનગી આપે છે, 451 00:25:00,000 --> 00:25:03,000 પછી બીજું, પછી બીજું, અન્ય, તો પછી કોઇ પણ સમયે અમે માંગો છો 452 00:25:03,000 --> 00:25:07,000 એક કાર્યક્રમ દરમિયાન, અને અમે યાદ રાખો કે તેઓ તમામ છો કોઈક સંબંધિત 453 00:25:07,000 --> 00:25:11,000 શાબ્દિક chaining દ્વારા મળીને તેમને, અમે અને તે pictorially એક તીર સાથે અહીં કર્યું હતું. 454 00:25:11,000 --> 00:25:15,000 પરંતુ કોડ છે, શું પદ્ધતિ કે જે દ્વારા તમે કોઈક કનેક્ટ કરી શક્યા હશે, 455 00:25:15,000 --> 00:25:20,000 લગભગ સ્ક્રેચ જેમ, એક બીજા ભાગ માટે ભાગ? 456 00:25:20,000 --> 00:25:22,000 અમે એક નિર્દેશક વાપરવા માટે, જમણી શકે છે? 457 00:25:22,000 --> 00:25:25,000 કારણ કે ખરેખર તીર કે ઉપરી ડાબા ચોરસમાં થી ચાલી રહ્યું છે, 458 00:25:25,000 --> 00:25:31,000 આ એક આ અહીં વ્યક્તિ, અંદર આ સ્ક્વેર ઓફ સમાવી શકે છે 459 00:25:31,000 --> 00:25:34,000 કેટલાક માત્ર ints કેટલાક માત્ર કોલસો બનાવો, પરંતુ જો હું ખરેખર ફાળવવામાં 460 00:25:34,000 --> 00:25:37,000 થોડો વધારે છે, જેથી હવે જગ્યા, 461 00:25:37,000 --> 00:25:41,000 મેમરી મારા હિસ્સામાં દરેક છતાં પણ આ મને ખર્ચ રહ્યું છે, 462 00:25:41,000 --> 00:25:45,000 હવે થોડી વધુ લંબચોરસ લાગે છે જ્યાં એક મેમરીનો હિસ્સામાં ઓફ 463 00:25:45,000 --> 00:25:47,000 છે નંબર માટે વપરાય છે, નંબર 1, જેમ કે 464 00:25:47,000 --> 00:25:50,000 અને પછી જો આ વ્યક્તિ 2 નંબર સ્ટોર કરે છે, 465 00:25:50,000 --> 00:25:52,000 મેમરી આ અન્ય ભાગ એક તીર માટે વપરાય છે, 466 00:25:52,000 --> 00:25:54,000 અથવા વધુ concretely, એક નિર્દેશક. 467 00:25:54,000 --> 00:25:59,000 ધારવું અને હું અહીં ઉપર સંખ્યા 3 સ્ટોર જ્યારે હું આ કે વ્યક્તિ પર નિર્દેશ કરવા માટે ઉપયોગ કરે છે, 468 00:25:59,000 --> 00:26:02,000 અને હવે આ વ્યક્તિ, ચાલો ધારી હું માત્ર મેમરી ત્રણ જેવા હિસ્સામાં કરવા માંગો છો. 469 00:26:02,000 --> 00:26:05,000 હું કે મારફતે લીટી દોરે, નલ સંકેત મળશે. 470 00:26:05,000 --> 00:26:07,000 ત્યાં કોઈ વધારાના પાત્ર છે. 471 00:26:07,000 --> 00:26:10,000 >> ખરેખર, આ છે અમે કેવી રીતે અમલમાં જઈ શકો 472 00:26:10,000 --> 00:26:12,000 કંઈક કે જે સંકળાયેલી યાદી તરીકે ઓળખાય છે. 473 00:26:12,000 --> 00:26:18,000 એક કડી થયેલ યાદી નવી માહિતી માળખું છે, અને તે વેગ તરફ પથ્થર છે 474 00:26:18,000 --> 00:26:21,000 ખૂબ પારખુ માહિતી માળખાં કે સમસ્યાઓ ઉકેલવા શરૂ 475 00:26:21,000 --> 00:26:23,000 ફેસબુક પ્રકારના સમસ્યાઓ લીટીઓ અને Google પ્રકારના સમસ્યાઓ સાથે 476 00:26:23,000 --> 00:26:26,000 જ્યાં તમે વિશાળ ડેટા સેટ્સ ધરાવે છે, અને તે લાંબા સમય સુધી તેને નહીં 477 00:26:26,000 --> 00:26:29,000 માટે બધું નજીકના સંગ્રહવા અને લીનીયર શોધ કંઈક ઉપયોગ 478 00:26:29,000 --> 00:26:31,000 અથવા બાઇનરી શોધ જેવા પણ કંઈક. 479 00:26:31,000 --> 00:26:33,000 તમે હજુ પણ વધુ સારી ચાલી વખત કરવા માંગો છો. 480 00:26:33,000 --> 00:26:37,000 હકીકતમાં, એક પવિત્ર Grails આપણે આ સપ્તાહ પછી અથવા આગામી વિશે વાત કરીશું 481 00:26:37,000 --> 00:26:41,000 અલ્ગોરિધમ ચાલી જેની સમય સતત છે. 482 00:26:41,000 --> 00:26:44,000 અન્ય શબ્દોમાં, તે હંમેશા સમય અને એ જ માત્રામાં કોઈ પદાર્થ લે છે 483 00:26:44,000 --> 00:26:47,000 મોટા કેવી રીતે ઇનપુટ છે, અને ખરેખર અનિવાર્ય હશે, 484 00:26:47,000 --> 00:26:49,000 હજુ પણ વધુ છે તેથી લઘુગુણકીય કંઈક કરતાં. 485 00:26:49,000 --> 00:26:51,000 શું સ્ક્રીન પર આ છે અહીં? 486 00:26:51,000 --> 00:26:55,000 આ લંબચોરસ દરેક બરાબર છે હું શું માત્ર હાથ દ્વારા લખવામાં આવી હતી. 487 00:26:55,000 --> 00:26:59,000 પરંતુ ડાબી પર બધી રીતે વસ્તુ ખાસ ચલ છે. 488 00:26:59,000 --> 00:27:02,000 તે એક નિર્દેશક જ હશે કારણ કે એક gotcha 489 00:27:02,000 --> 00:27:04,000 એક કડી થયેલ યાદી સાથે, આ વસ્તુઓ તરીકે ઓળખાય છે, 490 00:27:04,000 --> 00:27:09,000 છે કે જે તમે યાદીની લિંક એક ઓવરને પર અટકી છે. 491 00:27:09,000 --> 00:27:13,000 >> માત્ર એક શબ્દમાળા સાથે માંગો, તો તમારે પ્રથમ ઘરનાં પરચૂરણ કામો ની સરનામું જાણતા હોય છે. 492 00:27:13,000 --> 00:27:15,000 સંલગ્ન યાદી જ સોદો. 493 00:27:15,000 --> 00:27:19,000 તમે મેમરી પ્રથમ ભાગ ના સરનામું જાણતા હોય છે 494 00:27:19,000 --> 00:27:25,000 ત્યાંથી, કારણ કે તમે દરેક અન્ય એક પહોંચી શકે છે. 495 00:27:25,000 --> 00:27:27,000 નુકસાન. 496 00:27:27,000 --> 00:27:30,000 કિંમત શું અમે ગતિશીલ કર્યા આ વૈવિધ્યતાને માટે ચૂકવવામાં આવે છે 497 00:27:30,000 --> 00:27:34,000 મોટા માહિતી બંધારણ છે કે જો આપણે ક્યારેય વધુ મેમરી જરૂર છે, દંડ, 498 00:27:34,000 --> 00:27:37,000 માત્ર એક વધુ ભાગ ફાળવો અને નિર્દેશક દોરવા માંથી 499 00:27:37,000 --> 00:27:39,000 યાદીમાં નવા પૂંછડી માટે જૂના? 500 00:27:39,000 --> 00:27:41,000 યાહ. 501 00:27:41,000 --> 00:27:43,000 [વિદ્યાર્થી] તે લગભગ બમણું ખૂબ જગ્યા લે છે. 502 00:27:43,000 --> 00:27:45,000 તે બે વાર તેટલી જગ્યા લે છે, જેથી ચોક્કસપણે એક નુકસાન છે, અને અમે આ જોઇ છે 503 00:27:45,000 --> 00:27:48,000 સમય અને જગ્યા અને સાનુકૂળતા વચ્ચે પહેલાં સંતુલિત 504 00:27:48,000 --> 00:27:51,000 જ્યાં હવે, અમે આ નંબરો દરેક માટે 32 બિટ્સ જરૂર નથી. 505 00:27:51,000 --> 00:27:57,000 અમે ખરેખર 64, નંબર માટે 32 અને નિર્દેશક માટે 32 કરવાની જરૂર છે. 506 00:27:57,000 --> 00:27:59,000 પરંતુ હેય, હું RAM ની 2 ગીગાબાઇટ્સ છે. 507 00:27:59,000 --> 00:28:02,000 અન્ય 32 અહીં અને અહીં બિટ્સ ઉમેર્યું હતું કે સોદો મોટા થાય તેમ લાગતું નથી. 508 00:28:02,000 --> 00:28:05,000 પરંતુ મોટા માહિતી સમૂહો માટે, તે ચોક્કસપણે શાબ્દિક બમણી ખૂબ સુધી ઉમેરે છે. 509 00:28:05,000 --> 00:28:09,000 શું બીજું નુકસાન હવે, અથવા લક્ષણ શું આપણે આપી નથી, 510 00:28:09,000 --> 00:28:12,000 જો આપણે એક કડી થયેલ યાદી નથી અને ઝાકઝમાળ સાથે વસ્તુઓ યાદી પ્રતિનિધિત્વ? 511 00:28:12,000 --> 00:28:14,000 [વિદ્યાર્થી] તમે તે પાછળની નથી પસાર કરી શકો છો. 512 00:28:14,000 --> 00:28:16,000 તમે તેને પાછળની નથી પસાર કરી શકો છો, જેથી તમે પ્રકારની ખરાબ છો જો તમે વૉકિંગ કરી રહ્યાં છો 513 00:28:16,000 --> 00:28:19,000 ડાબેથી જમણી લૂપ અથવા જ્યારે લૂપ માટે ઉપયોગ કરવા માટે 514 00:28:19,000 --> 00:28:21,000 અને પછી તમે સમજો, "ઓહ, હું યાદી શરૂઆત પર જાઓ કરવા માંગો છો." 515 00:28:21,000 --> 00:28:26,000 તમે કારણ કે આ પોઇંટરો માત્ર ડાબી બાજુથી જમણી જઇ શકો છો તરીકે તીરો દર્શાવે છે. 516 00:28:26,000 --> 00:28:29,000 >> હવે, તમે બીજા ચલ સાથે યાદી શરૂઆત યાદ કરી શકે છે, 517 00:28:29,000 --> 00:28:31,000 પરંતુ તે માટે ધ્યાનમાં રાખવા જટિલતા છે. 518 00:28:31,000 --> 00:28:35,000 ઝાકઝમાળ, કોઈ બાબત અત્યાર સુધી તમે કેવી રીતે જાય છે, તો તમે હંમેશા બાદ, ઓછા, ઓછા કરવા માટે, શકે બાદ 519 00:28:35,000 --> 00:28:37,000 અને જ્યાંથી તમે આવ્યા માંથી પાછા જાઓ. 520 00:28:37,000 --> 00:28:40,000 અન્ય નુકસાન અહીં શું છે? યાહ. 521 00:28:40,000 --> 00:28:43,000 [અશ્રાવ્ય વિદ્યાર્થી પ્રશ્ન] 522 00:28:43,000 --> 00:28:47,000 તમે, જેથી તમે ખરેખર શકે કર્યા છે માત્ર એક માહિતી સમયમાં બમણું યાદીની લિંક કહેવાય માળખું પ્રસ્તાવ મૂક્યો, 523 00:28:47,000 --> 00:28:50,000 અને ખરેખર, તમે આ લંબચોરસ દરેક અન્ય નિર્દેશક ઉમેરો કરશે 524 00:28:50,000 --> 00:28:53,000 જે અન્ય દિશામાં જાય છે, ઊંધો જે 525 00:28:53,000 --> 00:28:55,000 હવે તમે પાછા અને આગળ પસાર કરી શકો છો, 526 00:28:55,000 --> 00:28:59,000 જે નુકસાન હવે તમે બધી મેમરીનો તરીકે કરી રહ્યાં છે ત્રણ વખત ઉપયોગ અમે ઉપયોગ 527 00:28:59,000 --> 00:29:04,000 અને એ પણ કોડ દ્રષ્ટિએ જટિલતા ઉમેરીને તમે તેને અધિકાર વિચાર લખી હોય છે. 528 00:29:04,000 --> 00:29:08,000 પરંતુ આ બધા કદાચ ખૂબ વાજબી આપલે, જો રિવર્સલ વધારે અગત્યની છે. 529 00:29:08,000 --> 00:29:10,000 યાહ. 530 00:29:10,000 --> 00:29:12,000 [વિદ્યાર્થી] તમે પણ એક 2D સંલગ્ન યાદી હોઈ શકે નહિં. 531 00:29:12,000 --> 00:29:16,000 ગુડ, તમે ખરેખર એક 2D યાદીની લિંક હોઈ શકે નહિં. 532 00:29:16,000 --> 00:29:18,000 તમે કરી શકે. તે લગભગ એક એરે તરીકે સરળ નથી. 533 00:29:18,000 --> 00:29:21,000 ઝાકઝમાળ જેમ, તમે ઓપન કૌંસ, બંધ કૌંસ, ઓપન કૌંસ, કૌંસ બંધ કરવા માટે, 534 00:29:21,000 --> 00:29:23,000 અને તમે કેટલાક માળખું 2-પરિમાણીય મેળવો. 535 00:29:23,000 --> 00:29:26,000 તમે 2-પરિમાણીય યાદીની લિંક અમલ કરી શકે છે 536 00:29:26,000 --> 00:29:29,000 જો તમે વધારાની તરીકે તમે આ બાબતો દરેક ત્રીજા નિર્દેશક એક પ્રસ્તાવ કરવું 537 00:29:29,000 --> 00:29:34,000 અને જો તમે અન્ય યાદી વિશે વિચારો તમને 3D શૈલી આવતા 538 00:29:34,000 --> 00:29:40,000 સ્ક્રીન માંથી અમને તમામ છે, કે જે માત્ર અમુક પ્રકારના અન્ય સાંકળ છે. 539 00:29:40,000 --> 00:29:45,000 અમે તે કરી શકી હોત, પરંતુ તે ઓપન કૌંસ, ચોરસ કૌંસ લખીને તરીકે સરળ નથી. યાહ. 540 00:29:45,000 --> 00:29:48,000 [અશ્રાવ્ય વિદ્યાર્થી પ્રશ્ન] 541 00:29:48,000 --> 00:29:50,000 ગુડ, તેથી આ એક વાસ્તવિક kicker છે. 542 00:29:50,000 --> 00:29:54,000 >> આ ગાણિતીક નિયમો છે કે અમે ઉપર, ઓહ, જેમ કે દ્વિસંગી શોધ pined કરી લીધી છે, 543 00:29:54,000 --> 00:29:57,000 તમે બોર્ડ પર નંબરો ઝાકઝમાળ શોધ કરી શકો છો 544 00:29:57,000 --> 00:30:01,000 અથવા ફોન બુકમાં તેથી વધુ ઝડપથી જો તમે વાપરવા વિભાજિત અને જીતી 545 00:30:01,000 --> 00:30:05,000 અને એક દ્વિસંગી શોધ અલ્ગોરિધમનો, પરંતુ બાઈનરી શોધ બે ધારણા જરૂરી છે. 546 00:30:05,000 --> 00:30:09,000 એક, કે માહિતી છટણી કરવામાં આવી હતી. 547 00:30:09,000 --> 00:30:11,000 હવે, અમે કદાચ આ છટણી રાખી શકો છો, 548 00:30:11,000 --> 00:30:14,000 તેથી કદાચ કે જે ચિંતા નથી, પરંતુ બાઈનરી છે શોધ પણ ધારી 549 00:30:14,000 --> 00:30:18,000 કે તમે નંબરો યાદી રેન્ડમ ઍક્સેસ હતી, 550 00:30:18,000 --> 00:30:21,000 અને ઝાકઝમાળ તમે રેન્ડમ એક્સેસ કરવાની પરવાનગી આપે છે, અને રેન્ડમ એક્સેસ દ્વારા, 551 00:30:21,000 --> 00:30:24,000 હું તેનો અર્થ જો તમે ઝાકઝમાળ આપવામાં કરી રહ્યાં છો, કેટલી સમયે તે તમે લે 552 00:30:24,000 --> 00:30:26,000 માટે 0 કૌંસ મેળવવા? 553 00:30:26,000 --> 00:30:29,000 એક ઓપરેશન, તમે માત્ર [0] ઉપયોગ કરે છે અને તમે ત્યાં છો. 554 00:30:29,000 --> 00:30:33,000 કેટલી પગલાંઓ તે 10 સ્થાન મેળવવા લાગી છે? 555 00:30:33,000 --> 00:30:36,000 એક પગલું, તમે માત્ર [10] પર જાઓ અને તમે ત્યાં છો. 556 00:30:36,000 --> 00:30:40,000 તેનાથી વિપરીત, તમે એક કડી થયેલ યાદીમાં 10 મા પૂર્ણાંક કેવી રીતે મેળવી શકું? 557 00:30:40,000 --> 00:30:42,000 તમે શરૂઆતમાં શરૂ હોય છે કારણ કે તમે માત્ર યાદ કરી રહ્યા છીએ 558 00:30:42,000 --> 00:30:45,000 એક કડી થયેલ યાદી ને શબ્દમાળા જેમ, શરૂઆતમાં યાદ આવી રહી છે 559 00:30:45,000 --> 00:30:48,000 તેના પ્રથમ ચાર રચે છે જે સરનામા દ્વારા, અને તે 10 મી પૂર્ણાંક શોધવા માટે બનાવવા માટે 560 00:30:48,000 --> 00:30:53,000 અથવા સ્ટ્રિંગ છે કે 10 મી પાત્ર, તો તમારે આખી ધુત્કારી કાઢવું ​​વસ્તુ શોધવા હોય છે. 561 00:30:53,000 --> 00:30:55,000 >> ફરીથી, અમે અમારી સમસ્યાઓ બધી હલ કરી રહ્યાં છો. 562 00:30:55,000 --> 00:31:00,000 અમે નવા રજૂઆત કરી રહ્યાં છો, પરંતુ તે ખરેખર તમે શું કરવા માટે ડિઝાઇન પ્રયાસ કરી રહ્યા છો તેના પર આધાર રાખે છે. 563 00:31:00,000 --> 00:31:04,000 આ અમલીકરણ દ્રષ્ટિએ, અમે તે વિદ્યાર્થી માળખું એક વિચાર ઉધાર કરી શકો છો. 564 00:31:04,000 --> 00:31:07,000 વાક્યરચના ખૂબ સમાન હવે સિવાય છે, આ વિચાર થોડો એક અમૂર્ત વધુ છે 565 00:31:07,000 --> 00:31:09,000 કરતાં ઘર અને નામ અને ID ને. 566 00:31:09,000 --> 00:31:13,000 પરંતુ હું પ્રસ્તાવ છે કે અમે સી એ માહિતી બંધારણ કરી શકે છે 567 00:31:13,000 --> 00:31:17,000 કે નોડ તરીકે ઓળખાય છે, સ્લાઇડ પર છેલ્લા શબ્દ સૂચવે છે, 568 00:31:17,000 --> 00:31:21,000 નોડ ની અંદર, અને નોડ ફક્ત કોમ્પ્યુટર વિજ્ઞાન એક સામાન્ય કન્ટેનર છે. 569 00:31:21,000 --> 00:31:25,000 તે સામાન્ય રીતે એક વર્તુળ કે ચોરસ અથવા લંબચોરસ તરીકે અમે કર્યું છે પ્રમાણે ઉઠાવવામાં છે. 570 00:31:25,000 --> 00:31:27,000 અને આ માહિતી માળખું, અમે પૂર્ણાંક, n હોય છે, 571 00:31:27,000 --> 00:31:29,000 જેથી નંબર હું સંગ્રહવા માંગો છો છે. 572 00:31:29,000 --> 00:31:36,000 પરંતુ આ બીજા લાઇન સ્ટ્રક્ટ નોડ આગામી * શું છે? 573 00:31:36,000 --> 00:31:40,000 આ શા માટે છે સાચું, અથવા ભૂમિકા શું આ વસ્તુ નાટક કરે છે, 574 00:31:40,000 --> 00:31:42,000 છતાં પણ તે પ્રથમ નજરમાં થોડી છુપાયેલું છે? 575 00:31:42,000 --> 00:31:44,000 યાહ. 576 00:31:44,000 --> 00:31:46,000 [અશ્રાવ્ય વિદ્યાર્થી જવાબ] 577 00:31:46,000 --> 00:31:50,000 બરાબર છે, તેથી spoils ના * સૉર્ટ કરો કે તે અમુક પ્રકારની એક નિર્દેશક છે. 578 00:31:50,000 --> 00:31:53,000 આ નિર્દેશક નું નામ આપખુદ આગામી છે, 579 00:31:53,000 --> 00:32:00,000 પરંતુ અમે તે કહે કરી શકે કંઈપણ અમે માંગો છો, પરંતુ આ નિર્દેશક બિંદુ શું કરે છે? 580 00:32:00,000 --> 00:32:03,000 [વિદ્યાર્થી] અન્ય નોડ >> એક્ઝેટલી., તે બીજા આવા નોડ નિર્દેશ કરે છે. 581 00:32:03,000 --> 00:32:05,000 >> હવે, આ સી એક જિજ્ઞાસા જેવું છે 582 00:32:05,000 --> 00:32:09,000 જણાવ્યું હતું કે સી કમ્પાઇલર ઉપરથી નીચે સુધી દ્વારા વાંચવામાં આવે છે, ડાબેથી જમણે, 583 00:32:09,000 --> 00:32:13,000 જેનો અર્થ છે કે જો એ આ થોડો અમે શું વિદ્યાર્થી સાથે કર્યું અલગ છે. 584 00:32:13,000 --> 00:32:16,000 જ્યારે અમે વિદ્યાર્થી વ્યાખ્યાયિત, અમે ખરેખર એક શબ્દ ત્યાં આવ્યો ન હતો. 585 00:32:16,000 --> 00:32:18,000 તે માત્ર typedef જણાવ્યું હતું. 586 00:32:18,000 --> 00:32:20,000 તો પછી અમે પૂર્ણાંક id, શબ્દમાળા નામ, શબ્દમાળા મકાન હતું, 587 00:32:20,000 --> 00:32:23,000 અને પછી સ્ટ્રક્ટ તળિયે વિદ્યાર્થી. 588 00:32:23,000 --> 00:32:26,000 આ ઘોષણા થોડું અલગ છે કારણ કે, 589 00:32:26,000 --> 00:32:28,000 ફરીથી, આ C કમ્પાઈલર થોડો મૂંગું છે. 590 00:32:28,000 --> 00:32:30,000 તે માત્ર એ જ ઉપરથી નીચે સુધી વાંચી રહ્યું છે, 591 00:32:30,000 --> 00:32:33,000 જેથી જો તે 2 જી વાક્ય અહીં સુધી પહોંચે 592 00:32:33,000 --> 00:32:37,000 જ્યાં આગામી જાહેર થાય છે અને તે જુએ છે, ઓહ, અહીં એક આગામી કહેવાય ચલ છે. 593 00:32:37,000 --> 00:32:39,000 તે સ્ટ્રક્ટ નોડ માટે નિર્દેશક છે. 594 00:32:39,000 --> 00:32:42,000 આ કમ્પાઈલર સમજવુ શું સ્ટ્રક્ટ નોડ છે જવાની છે? 595 00:32:42,000 --> 00:32:44,000 હું આ પહેલા વસ્તુને ક્યારેય સાંભળ્યું કર્યું છે, 596 00:32:44,000 --> 00:32:47,000 કારણ કે શબ્દ નોડ અન્યથા દેખાશે નહિં શકે 597 00:32:47,000 --> 00:32:49,000 નીચે સુધી, તેથી આ રીડન્ડન્સી છે. 598 00:32:49,000 --> 00:32:53,000 તમે સ્ટ્રક્ટ નોડ અહીં કહે છે, કે જે તમે પછી પાછળથી ટૂંકી કરી શકો છો 599 00:32:53,000 --> 00:32:56,000 નીચે અહીં typedef માટે આભાર, પણ આ કારણ કે 600 00:32:56,000 --> 00:33:02,000 અમે માળખાની અંદર માળખું પોતે સંદર્ભ કરવામાં આવે છે. 601 00:33:02,000 --> 00:33:05,000 કે એક ત્યાં gotcha છે. 602 00:33:05,000 --> 00:33:07,000 >> કેટલીક રસપ્રદ સમસ્યાઓ ઊભી થાય જતાં હોય છે. 603 00:33:07,000 --> 00:33:09,000 અમે નંબરોની યાદી મળી છે. અમે કેવી રીતે તે દાખલ કરી શકું? 604 00:33:09,000 --> 00:33:11,000 અમે તેને કેવી રીતે શોધી શકું? અમે કેવી રીતે તે કાઢી શકું? 605 00:33:11,000 --> 00:33:13,000 ખાસ કરીને હવે કે અમે આ પોઇંટરો તમામ વ્યવસ્થા હોય છે. 606 00:33:13,000 --> 00:33:15,000 તમે વિચાર્યું પોઇંટરો મન-બેન્ડિંગ જેવું હતા 607 00:33:15,000 --> 00:33:17,000 જ્યારે તમે હતા તેમાંના એક માત્ર તે પૂર્ણાંક વાંચવાનો પ્રયાસ. 608 00:33:17,000 --> 00:33:20,000 હવે અમે વર્તમાન યાદી વર્થ ચાલાકી છે. 609 00:33:20,000 --> 00:33:22,000 અમે અમારા વિરામ 5-મિનિટ શા માટે ન લો અહીં, અને પછી અમે લાવવા પડશે 610 00:33:22,000 --> 00:33:34,000 સ્ટેજ પર કેટલાક લોકો છે કે જે ચોક્કસ કરવું. 611 00:33:34,000 --> 00:33:36,000 >> સી વધારે મજા ત્યારે તેને અભિનય કર્યો છે છે. 612 00:33:36,000 --> 00:33:39,000 કોણ શાબ્દિક પ્રથમ થવા માંગો છો? 613 00:33:39,000 --> 00:33:41,000 ઠીક છે, પર આવે છે. તમે પ્રથમ છે. 614 00:33:41,000 --> 00:33:44,000 કોણ 9 થવા માંગો છો? ઠીક, 9. 615 00:33:44,000 --> 00:33:46,000 કેવી રીતે 9 વિશે શું? 17? 616 00:33:46,000 --> 00:33:51,000 થોડું અહીં ક્લિક. 22 અને કે આગળની હરોળ માં 26. 617 00:33:51,000 --> 00:33:53,000 અને પછી કેવી રીતે કોઈને વિશે ત્યાં ઉપર પર નિર્દેશ કરવામાં આવે છે. 618 00:33:53,000 --> 00:33:57,000 તમે 34 છે. ઠીક, પર 34, આવે છે. 619 00:33:57,000 --> 00:33:59,000 પ્રથમ ત્યાં વધારે છે. ઠીક છે, બધા તમે ગાય્સ ચાર. 620 00:33:59,000 --> 00:34:01,000 અને અમે જે 9 માટે કહી હતી? 621 00:34:01,000 --> 00:34:04,000 9 અમારા કોણ છે? 622 00:34:04,000 --> 00:34:07,000 કોણ ખરેખર 9 બનવા માંગે છે? તમામ હક, પર આવો, 9 છે. 623 00:34:07,000 --> 00:34:10,000 અહીં અમે જાઓ. 624 00:34:10,000 --> 00:34:13,000 34, અમે તમને મળવા પર ત્યાં પડશે. 625 00:34:13,000 --> 00:34:17,000 પ્રથમ ભાગ બનાવવા તમે પોતે જ છે કે જેમ દેખાય છે. 626 00:34:17,000 --> 00:34:21,000 26, 22, 17, સારું. 627 00:34:21,000 --> 00:34:25,000 જો તમે બાજુએ ઉભી રહે છે, કારણ કે અમે તમને એક ક્ષણ માં malloc જઈ રહ્યાં છો કરી શકો છો. 628 00:34:25,000 --> 00:34:29,000 >> ગુડ, સારું. 629 00:34:29,000 --> 00:34:32,000 ઠીક છે, ઉત્તમ છે, તેથી આપણે પ્રશ્નો દંપતિ અહીં પૂછો. 630 00:34:32,000 --> 00:34:34,000 અને ખરેખર, તમારું નામ શું છે >> અનિતા. 631 00:34:34,000 --> 00:34:37,000 અનિતા, ઠીક, અહીં ઉપર પર આવે છે. 632 00:34:37,000 --> 00:34:41,000 અનિતા અમારી મદદ માટે પ્રકારના એક પ્રથમ એકદમ સરળ પ્રશ્ન હલ થઈ રહ્યું છે, 633 00:34:41,000 --> 00:34:44,000 જે તમે કેવી રીતે શોધી શકું કે ન કિંમત યાદી છે? 634 00:34:44,000 --> 00:34:48,000 હવે નોટિસ કે, પ્રથમ, લુકાસ દ્વારા અહીં રજૂ, 635 00:34:48,000 --> 00:34:52,000 થોડો અલગ છે, અને તેથી કાગળ તેમના ભાગ ઇરાદાપૂર્વક પડખોપડખ છે 636 00:34:52,000 --> 00:34:55,000 કારણ કે તે તદ્દન તરીકે ઊંચી છે અને નથી અનેક બિટ્સ તરીકે લે નથી, 637 00:34:55,000 --> 00:34:58,000 છતાં પણ ટેકનિકલ રીતે તે કાગળ સમાન કદ માત્ર ફેરવ્યું છે. 638 00:34:58,000 --> 00:35:01,000 પરંતુ તેમણે થોડી જુદી છે કે તેઓ એક નિર્દેશક માટે ફક્ત 32 બિટ્સ છે છે, 639 00:35:01,000 --> 00:35:05,000 અને આ ગાય્સ તમામ 64 બિટ્સ, જેમાંથી અડધા સંખ્યા છે જેમાંથી અડધા એક નિર્દેશક છે. 640 00:35:05,000 --> 00:35:08,000 પરંતુ નિર્દેશક દર્શાવાયા નથી, તેથી છે ગાય્સ તમે કંઈક awkwardly થઇ સકે તો 641 00:35:08,000 --> 00:35:12,000 તમારા ડાબા હાથમાં વાપરવા માટે તમે આગળ વ્યક્તિ પર નિર્દેશ કરે છે. 642 00:35:12,000 --> 00:35:14,000 અને તમે 34 નંબર છો. તમારું નામ શું છે? 643 00:35:14,000 --> 00:35:16,000 અરિ. 644 00:35:16,000 --> 00:35:19,000 અરિ, તેથી વાસ્તવમાં, તમારા જમણા હાથમાં કાગજ, અને ડાબા હાથની રન નોંધાયો નહીં. 645 00:35:19,000 --> 00:35:21,000 તમે ડાબી પર નલ પ્રતિનિધિત્વ કરે છે. 646 00:35:21,000 --> 00:35:24,000 >> હવે અમારી માનવ ચિત્ર ખૂબ સુસંગત છે. 647 00:35:24,000 --> 00:35:26,000 આ વાસ્તવમાં એ કેવી રીતે પોઇંટરો કામ કરે છે. 648 00:35:26,000 --> 00:35:29,000 અને જો તમે થોડો આ રીતે scrunch જેથી હું તમારી રીતે નથી કરી શકો છો. 649 00:35:29,000 --> 00:35:34,000 અહીં અનિતા, મને 22 નંબર શોધવા માટે, 650 00:35:34,000 --> 00:35:40,000 પરંતુ ન હોલ્ડિંગ મનુષ્યો કાગળ ટુકડાઓ એક બળજબરી ધારે, 651 00:35:40,000 --> 00:35:43,000 પરંતુ આ યાદી છે, અને તમે માત્ર લુકાસ સાથે શરૂ કરવા માટે છે 652 00:35:43,000 --> 00:35:46,000 કારણ કે તેઓ ખરેખર પ્રથમ નિર્દેશક છે. 653 00:35:46,000 --> 00:35:51,000 તમે ધારો જાતે નિર્દેશક હોય છે, અને તેથી તમે ખૂબ કંઈક અંતે નિર્દેશ કરવાની ક્ષમતા હોય છે. 654 00:35:51,000 --> 00:35:56,000 તમે ચોકકસ શું લુકાસ તરફ સંકેત છે પોઇન્ટ કરીને કેમ નથી શરૂ કરી શકું? 655 00:35:56,000 --> 00:35:58,000 ગુડ દો, અને મને અહીં પર આ બહાર કાયદો ઘડવો. 656 00:35:58,000 --> 00:36:04,000 જસ્ટ ચર્ચા ખાતર દો, મને એક ખાલી પાનું અહીં ખેંચો. 657 00:36:04,000 --> 00:36:06,000 તમે તમારું નામ કેવી રીતે જોડણી નથી >> અનિતા. 658 00:36:06,000 --> 00:36:08,000 ઠીક છે, અનિતા. 659 00:36:08,000 --> 00:36:18,000 ચાલો નોડ * અનિતા = LUCAS કહો. 660 00:36:18,000 --> 00:36:22,000 વેલ, અમે તમને LUCAS નથી કહી કરીશું. અમે તમને પ્રથમ કૉલ કરીશું. 661 00:36:22,000 --> 00:36:25,000 અહીં વાસ્તવિકતા સાથે સુસંગત વાસ્તવમાં આ શા માટે છે? 662 00:36:25,000 --> 00:36:27,000 એક, પ્રથમ પહેલાથી જ અસ્તિત્વમાં છે. 663 00:36:27,000 --> 00:36:30,000 પ્રથમ કદાચ કરવામાં આવી છે ક્યાંક અહીં ફાળવવામાં આવે છે. 664 00:36:30,000 --> 00:36:35,000 નોડ પ્રથમ *, અને તે યાદી કરવામાં આવ્યું કોઈક ફાળવવામાં આવે છે. 665 00:36:35,000 --> 00:36:37,000 મને ખબર નથી કે કેવી રીતે થયું. કે થયું તે પહેલા વર્ગ શરૂ કર્યું. 666 00:36:37,000 --> 00:36:40,000 મનુષ્યો આ યાદીની લિંક બનાવવામાં આવ્યું છે. 667 00:36:40,000 --> 00:36:44,000 અને હવે વાર્તા-આ તમામ Facebook પર છે દેખીતી રીતે જવું આ બિંદુએ પછીના 668 00:36:44,000 --> 00:36:49,000 વાર્તામાં આ બિંદુએ, અનિતા પ્રથમ સમાન હોવાનું આરંભ છે, 669 00:36:49,000 --> 00:36:51,000 જે અર્થ એ નથી લુકાસ અંતે અનિતા પોઇન્ટ છે. 670 00:36:51,000 --> 00:36:53,000 તેના બદલે, તે તેમણે શું અંતે નિર્દેશ પર નિર્દેશ 671 00:36:53,000 --> 00:36:57,000 કારણ કે તે જ સરનામાં કે લુકાસ 32 બિટ્સ ની અંદર છે - 1, 2, 3 - 672 00:36:57,000 --> 00:37:01,000 હવે પણ અનિતા 32 બિટ્સ ની અંદર - 1, 2, 3. 673 00:37:01,000 --> 00:37:05,000 >> હવે 22 શોધો. તમે આવું વિશે કેવી રીતે જવું છે? 674 00:37:05,000 --> 00:37:07,000 કે >>? ગમે માટે પોઇન્ટ શું છે. 675 00:37:07,000 --> 00:37:11,000 ગમે નિર્દેશિત કરવા માટે, તેથી આગળ વધો અને તે કાર્ય આઉટ શ્રેષ્ઠ તરીકે તમે અહીં કરી શકો છો. 676 00:37:11,000 --> 00:37:15,000 ગુડ, સારું, અને હવે તમે કરી રહ્યાં છો પોઇન્ટ ખાતે-શું 22 સાથે તમારા નામ શું છે? 677 00:37:15,000 --> 00:37:18,000 રોમન. >> રોમન તેથી, રેમોન અપ 22 હોલ્ડિંગ છે. 678 00:37:18,000 --> 00:37:20,000 તમે હવે ચેક કર્યું છે. 679 00:37:20,000 --> 00:37:24,000 નથી રેમોન 22 ==, અને તેથી જો, ઉદાહરણ તરીકે, અમે સાચું પાછા આવી શકો છો. 680 00:37:24,000 --> 00:37:26,000 મને જ્યારે દો આ ગાય્સ અહીં કંઈક awkwardly-ઊભા 681 00:37:26,000 --> 00:37:32,000 દો મને કંઈક bool જેવા ઝડપથી કરવા લાગે છે. 682 00:37:32,000 --> 00:37:37,000 હું આગળ વધો અને કહે જાઉં છું ગાંઠ (* યાદી, પૂર્ણાંક એન). 683 00:37:37,000 --> 00:37:39,000 હું અધિકાર પાછા તમે ગાય્સ સાથે હશો. હું માત્ર અમુક કોડ લખી હોય છે. 684 00:37:39,000 --> 00:37:45,000 અને હવે હું આગળ જાઓ અને આ, નોડ * અનિતા = યાદી કરવા જાઉં છું. 685 00:37:45,000 --> 00:37:51,000 અને હું આગળ વધો અને કહે જાઉં છું જ્યારે (અનિતા = NULL!). 686 00:37:51,000 --> 00:37:57,000 >> અહીં રૂપક થોડો ખેંચાય રહ્યો છે, પરંતુ જ્યારે (અનિતા = NULL!), હું શું કરવા માંગો છો? 687 00:37:57,000 --> 00:38:03,000 હું સંદર્ભ કેટલાક માર્ગ જરૂર 688 00:38:03,000 --> 00:38:05,000 આ પૂર્ણાંક છે કે જે અનિતા તરફ સંકેત છે. 689 00:38:05,000 --> 00:38:08,000 ભૂતકાળમાં, જ્યારે અમે માળખાં હતી, જે એક ગાંઠ છે 690 00:38:08,000 --> 00:38:11,000 અમે કોઈ નોટેશનમાં ઉપયોગ થાય છે, અને અમે કંઈક જેમ કહેવું કરશે 691 00:38:11,000 --> 00:38:15,000 anita.n, પરંતુ સમસ્યા એ છે કે અહીં અનિતા એક સ્ટ્રક્ટ દીઠ સે નથી. 692 00:38:15,000 --> 00:38:17,000 તે શું છે? 693 00:38:17,000 --> 00:38:21,000 તે એક નિર્દેશક, તેથી ખરેખર, જો અમે આ કોઈ ઉપયોગ કરવા માંગો છો નોટેશનમાં- 694 00:38:21,000 --> 00:38:23,000 અને આ માટે ઇરાદાપૂર્વક થોડું જોવા રહ્યું છે છુપાયેલું- 695 00:38:23,000 --> 00:38:28,000 અમે ગમે તે અનિતા ડાબી બાજુ પર જાઓ કંઈક આવું હોય તરફ સંકેત છે 696 00:38:28,000 --> 00:38:31,000 અને પછી n એ કહેવાય ક્ષેત્ર છે. 697 00:38:31,000 --> 00:38:35,000 અનિતા એક નિર્દેશક છે, પરંતુ * અનિતા શું છે? 698 00:38:35,000 --> 00:38:38,000 તમે શું જ્યારે તમે અનિતા શું નિર્દેશ કરતી હોય છે જાઓ શોધી શકું? 699 00:38:38,000 --> 00:38:42,000 એક સ્ટ્રક્ટ, નોડ, અને નોડ રિકોલ, એક n એ કહેવાય ક્ષેત્ર છે 700 00:38:42,000 --> 00:38:47,000 કારણ કે તે યાદ છે,, આ 2 ક્ષેત્રો, આગામી અને n એ, 701 00:38:47,000 --> 00:38:50,000 કે અમે એક ક્ષણ પહેલા અહીં જોવા મળી હતી. 702 00:38:50,000 --> 00:38:53,000 >> ખરેખર કોડ આ નકલ, 703 00:38:53,000 --> 00:39:02,000 અમે આ કરવા માટે અને કહેવું શકે જો ((* અનિતા). n == એન), તો n એ તે હું શોધી રહ્યો છું. 704 00:39:02,000 --> 00:39:04,000 નોંધ કરો કે આ કાર્ય સંખ્યા હું વિશે કાળજી માં પસાર થયો હતો. 705 00:39:04,000 --> 00:39:10,000 પછી હું આગળ વધીશું અને તે કરી શકે છે વળતર કંઈક સાચું. 706 00:39:10,000 --> 00:39:12,000 બાકી, જો કે આ કેસ નથી, હું શું કરવા માંગો છો? 707 00:39:12,000 --> 00:39:19,000 હું કોડ અનિતા શું યાદી મારફતે વૉકિંગ દ્વારા જેથી તર્ક હતી કેવી રીતે અનુવાદિત છે? 708 00:39:19,000 --> 00:39:26,000 હું શું અહીં શું કરવું જોઈએ માટે અનિતા ડાબી તે પગલું લેતા, ડાબી કે પગલું અનુકરણ? 709 00:39:26,000 --> 00:39:28,000 [અશ્રાવ્ય વિદ્યાર્થી પ્રતિભાવ] >> કે શું છે? 710 00:39:28,000 --> 00:39:30,000 [અશ્રાવ્ય વિદ્યાર્થી જવાબ] 711 00:39:30,000 --> 00:39:34,000 ગુડ, ખરાબ નથી વિચાર છે, પરંતુ ભૂતકાળમાં, જ્યારે અમે આ કર્યું છે, તો અમે કર્યું છે અનિતા + + 712 00:39:34,000 --> 00:39:37,000 કારણ કે અનિતા માટે 1 નંબર ઉમેરો કરશે, 713 00:39:37,000 --> 00:39:40,000 જે ખાસ કરીને આગામી વ્યક્તિ અંતે રોમન જેવા થશે નિર્દેશ, 714 00:39:40,000 --> 00:39:44,000 અથવા તેમને આગામી વ્યક્તિ, અથવા તેને માટે નીચે લીટી વ્યક્તિ આગામી. 715 00:39:44,000 --> 00:39:49,000 પરંતુ તે ઘણી સારી અહીં નથી કારણ કે આ વસ્તુ શું મેમરી જેમ લાગતું નથી? 716 00:39:49,000 --> 00:39:54,000 નહીં કે. અમે તે નિષ્ક્રિય છે. 717 00:39:54,000 --> 00:40:00,000 તે મેમરી આ જેવી લાગે છે, અને છતાં પણ હું 1 અને 2 અને 3 બંધ એક બીજા દોરવામાં કરી લીધી છે, 718 00:40:00,000 --> 00:40:03,000 જો આપણે ખરેખર અનુકરણ તમે ગાય્સ આ કરી શકો છો, જ્યારે હજુ પણ એ જ લોકો તરફ સંકેત, 719 00:40:03,000 --> 00:40:07,000 તમે કેટલાક રેન્ડમ પગલું બેક, તમે એક રેન્ડમ પગલું કેટલાક આગળ લઈ શકે છે? 720 00:40:07,000 --> 00:40:10,000 >> આ વાસણ હજી પણ સંલગ્ન યાદી છે, 721 00:40:10,000 --> 00:40:13,000 પરંતુ આ ગાય્સ મેમરી ગમે ત્યાં હોઈ શકે, 722 00:40:13,000 --> 00:40:15,000 જેથી અનિતા + + શા માટે કામ ન રહ્યું છે? 723 00:40:15,000 --> 00:40:19,000 શું સ્થાન અનિતા અંતે છે + +? 724 00:40:19,000 --> 00:40:21,000 કોણ જાણે છે. 725 00:40:21,000 --> 00:40:24,000 તેને કેટલીક અન્ય કિંમત છે કે જે હમણાં જ તેથી interposed શકાય થાય છે 726 00:40:24,000 --> 00:40:28,000 તક દ્વારા આ ગાંઠો તમામ વચ્ચે કારણ કે અમે એક એરે નથી વાપરી રહ્યા છો. 727 00:40:28,000 --> 00:40:30,000 અમે આ ગાંઠો દરેક વ્યક્તિગત રીતે ફાળવવામાં આવે છે. 728 00:40:30,000 --> 00:40:32,000 ઠીક છે, જો તમે ગાય્સ તમે જાતે સાફ બેક અપ કરી શકો છો. 729 00:40:32,000 --> 00:40:37,000 મને પ્રસ્તાવ કે અનિતા + +, અમે તેના બદલે શું અનિતા બદલે નોંધાયો- 730 00:40:37,000 --> 00:40:42,000 સાથે સાથે, શા માટે આપણે ગમે અનિતા નિર્દેશ કરતી હોય છે ન જાય તો શું કરવું અને પછી આગામી. 731 00:40:42,000 --> 00:40:45,000 અન્ય શબ્દોમાં, આપણે રોમન છે, જે 22 નંબર હોલ્ડિંગ છે માટે જાઓ, 732 00:40:45,000 --> 00:40:51,000 અને પછી આગામી છે. જોકે તરીકે અનિતા તેના ડાબા હાથ નિર્દેશક નકલ કરવામાં આવશે. 733 00:40:51,000 --> 00:40:54,000 પરંતુ તે દૂર રોમન કરતાં નથી કારણ કે અમે 22 મળી જશે. 734 00:40:54,000 --> 00:40:56,000 પણ જે વિચાર છે. હવે, આ વાસણ ઇશ્વર ભીષણ છે. 735 00:40:56,000 --> 00:40:59,000 પ્રામાણિકપણે, કોઈ એક ક્યારેય આ વાક્યરચના યાદ રાખવી, અને તેથી thankfully, 736 00:40:59,000 --> 00:41:04,000 તે ખરેખર એક થોડો ઇરાદાપૂર્વકની ઓહ, તમે ખરેખર હું શું લખ્યું નહોતું. 737 00:41:04,000 --> 00:41:08,000 આ વધુ આકર્ષક હોઈ તમે થઇ સકે તો કરશે. વોઇલા Query! 738 00:41:08,000 --> 00:41:10,000 >> પડદા પાછળ, હું સમસ્યા આ રીતે હલ કરવામાં આવી હતી. 739 00:41:10,000 --> 00:41:14,000 અનિતા, ડાબી કે પગલાં, 740 00:41:14,000 --> 00:41:18,000 પ્રથમ, અમે સરનામા માટે જાઓ નથી કે અનિતા તરફ સંકેત છે 741 00:41:18,000 --> 00:41:23,000 અને જ્યાં તે માત્ર નથી n એ, જે અમે ફક્ત સરખામણી ખાતર ચકાસાયેલ મળશે, 742 00:41:23,000 --> 00:41:25,000 આ કિસ્સામાં, - પરંતુ તમે પણ આગામી કરશે શોધવા 743 00:41:25,000 --> 00:41:28,000 માતાનો રોમન ડાબા હાથની યાદીમાં બીજા ગાંઠ તરફ ઇશારો. 744 00:41:28,000 --> 00:41:32,000 પરંતુ આ વાસણ ઇશ્વર ભીષણ માટે જે હું અગાઉ ઉલ્લેખ છે, 745 00:41:32,000 --> 00:41:34,000 પરંતુ તે વળે બહાર સી દે અમને આ સરળ બનાવે છે. 746 00:41:34,000 --> 00:41:40,000 તેના બદલે લેખન (અનિતા *), અમે તેના બદલે માત્ર અનિતા-> n એ લખી શકો છો, 747 00:41:40,000 --> 00:41:45,000 અને તે ચોક્કસ જ વસ્તુ વિધેયાત્મક નથી, પણ તે ખૂબ વધુ છે, 748 00:41:45,000 --> 00:41:48,000 અને તે ઘણો વધુ ચિત્ર સાથે સુસંગત છે કે અમે ચિત્રકામ થઈ છે 749 00:41:48,000 --> 00:41:50,000 આ બધા સમય તીરો મદદથી. 750 00:41:50,000 --> 00:41:57,000 >> છેલ્લે, અમે શું આ કાર્યક્રમ ઓવરને અંતે જરૂર છે? 751 00:41:57,000 --> 00:42:00,000 ત્યાં બાકી કોડ એક વાક્ય છે. 752 00:42:00,000 --> 00:42:02,000 શું વળતર? 753 00:42:02,000 --> 00:42:05,000 ખોટું કારણ કે, જો અમે સમગ્ર મારફતે વિચાર જ્યારે લૂપ 754 00:42:05,000 --> 00:42:10,000 અને અનિતા છે, વાસ્તવમાં, નલ, તેનો અર્થ એ કે તે યાદીમાં ઓવરને બધી રીતે થયું 755 00:42:10,000 --> 00:42:12,000 જ્યાં તેમણે પોઇન્ટ હતો-શું તમારું નામ છે ફરી? 756 00:42:12,000 --> 00:42:15,000 અરિ. >> હિસ્સો એરી ડાબા હાથમાં છે, કે જે નલ છે. 757 00:42:15,000 --> 00:42:18,000 અનિતા હવે નલ, અને હું ખ્યાલ તમે હમણાં અહીં સ્થાયી કરી રહ્યાં છો કેદખાનું માં awkwardly 758 00:42:18,000 --> 00:42:21,000 કારણ કે હું બોલ એકપાત્રી નાટક પર અહીં જાઉં છું, 759 00:42:21,000 --> 00:42:23,000 પરંતુ અમે તમને માત્ર એક ક્ષણ ફરી સમાવેશ પડશે. 760 00:42:23,000 --> 00:42:27,000 અનિતા વાર્તામાં તે સમયે નલ હોવાથી, જ્યારે લૂપ સમાપ્ત કરે છે, 761 00:42:27,000 --> 00:42:30,000 અને અમે ખોટા પાછા છે કારણ કે જો તેણે એરી નલ નિર્દેશક તમામ માર્ગ મળી 762 00:42:30,000 --> 00:42:34,000 તો પછી ત્યાં કોઈ નંબર કે તેમણે યાદી માં કરી હતી. 763 00:42:34,000 --> 00:42:39,000 અમે આ અપ પણ સાફ કરી શકો છો, પરંતુ આ એક સુંદર સારા અમલીકરણ પછી છે 764 00:42:39,000 --> 00:42:43,000 એક છેડાથી બીજા છેડા કાર્ય છે, એક કડી થયેલ યાદી માટે કાર્ય શોધો. 765 00:42:43,000 --> 00:42:48,000 તે હજુ પણ રેખીય શોધ છે, પરંતુ તે + + એક નિર્દેશક તરીકે સરળ નથી 766 00:42:48,000 --> 00:42:52,000 અથવા + + એક હું ચલ કારણ કે હવે અમે નથી ધારી શકો છો 767 00:42:52,000 --> 00:42:54,000 જ્યાં આ ગાંઠો દરેક મેમરી છે. 768 00:42:54,000 --> 00:42:57,000 અમે શાબ્દિક બ્રેડક્રમ્બસમાં ઊંડે સુધી મૂકીને એ પગેરું અનુસરો હોય, અથવા વધારે ચોક્કસ રીતે, 769 00:42:57,000 --> 00:43:00,000 પોઇન્ટર, એક ગાંઠ પરથી બીજા પર મેળવો. 770 00:43:00,000 --> 00:43:02,000 >> હવે આપણે બીજું એક પ્રયાસ કરો. અનિતા, તો તમે અહીં પાછા આવીને કરવા માંગો છો? 771 00:43:02,000 --> 00:43:06,000 અમે આગળ કેમ ન જાય તો અને એક શ્રોતાઓ તરફથી અન્ય વ્યક્તિ ફાળવવા? 772 00:43:06,000 --> 00:43:08,000 Malloc-શું તમારું નામ છે >> રેબેકા. 773 00:43:08,000 --> 00:43:10,000 રેબેકા. રેબેકા પ્રેક્ષકો કરવામાં malloced છે, 774 00:43:10,000 --> 00:43:13,000 અને તે હવે 55 નંબર સ્ટોર કરે છે. 775 00:43:13,000 --> 00:43:17,000 અને હાથ પર ધ્યેય હવે માટે અનિતા દાખલ કરવા માટે 776 00:43:17,000 --> 00:43:22,000 તેની યોગ્ય જગ્યાએ સંકળાયેલા અહીં યાદી માં રેબેકા. 777 00:43:22,000 --> 00:43:24,000 અહીં ઉપર પર એક ક્ષણ માટે આવે છે. 778 00:43:24,000 --> 00:43:28,000 હું આ કંઈક કર્યું છે. 779 00:43:28,000 --> 00:43:32,000 હું નોડ * કર્યું છે. અને તમારું નામ શું છે ફરી? 780 00:43:32,000 --> 00:43:34,000 રેબેકા. >> રીબેક્કા, ઠીક છે. 781 00:43:34,000 --> 00:43:41,000 રેબેકા malloc (sizeof (નોડ)) મળે છે. 782 00:43:41,000 --> 00:43:44,000 જેમ અમે ભૂતકાળમાં વિદ્યાર્થીઓ અને whatnot જેવી વસ્તુઓ ફાળવવામાં આવ્યા છે, 783 00:43:44,000 --> 00:43:46,000 અમે નોડ માપ જરૂર છે, તેથી હવે રેબેકા 784 00:43:46,000 --> 00:43:49,000 છે શું નિર્દેશ કરતી? 785 00:43:49,000 --> 00:43:52,000 રેબેકા તેના ની અંદર બે ક્ષેત્રો, એક જે 55 છે. 786 00:43:52,000 --> 00:43:55,000 ચાલો શું, રેબેકા-> 55 =. 787 00:43:55,000 --> 00:44:00,000 પરંતુ પછી રેબેકા-> આગામી અધિકાર હવે શકાય માંગો જોઈએ, તેમના હાથ કોણ જાણે પ્રકારની છે? 788 00:44:00,000 --> 00:44:03,000 કેટલાક કચરો કિંમત તરફ સંકેત છે, તેથી સારા પગલા શા માટે નથી 789 00:44:03,000 --> 00:44:07,000 અમે ઓછામાં ઓછા આવું કે જેથી ડાબા હાથમાં તેમના બાજુ પર હવે છે. 790 00:44:07,000 --> 00:44:09,000 હવે અનિતા, તે અહીં લે છે. 791 00:44:09,000 --> 00:44:11,000 તમારી પાસે રેબેકા ફાળવવામાં આવ્યો હોય. 792 00:44:11,000 --> 00:44:20,000 આગળ વધો અને શોધવા જ્યાં અમે રેબેકા મૂકવા જોઇએ. 793 00:44:20,000 --> 00:44:25,000 ગુડ, ખૂબ જ સારો. 794 00:44:25,000 --> 00:44:28,000 ઠીક છે, સારુ, અને હવે અમે તમને દિશામાં એક બીટ આપવા માટે જરૂર હોય, 795 00:44:28,000 --> 00:44:30,000 જેથી તમે એરી પહોંચી ગયા છો. 796 00:44:30,000 --> 00:44:33,000 તેના ડાબા હાથ નલ છે, પરંતુ રેબેકા સ્પષ્ટ અધિકાર સંબંધિત છે, 797 00:44:33,000 --> 00:44:36,000 તેથી અમે આ યાદીની લિંક બદલવા કેવી રીતે હોય 798 00:44:36,000 --> 00:44:38,000 ક્રમમાં યોગ્ય જગ્યાએ માં રેબેકા દાખલ કરવા માટે? 799 00:44:38,000 --> 00:44:42,000 જો તમે શાબ્દિક જરૂરી આસપાસ લોકોના ડાબા હાથ ફરી શકે છે, 800 00:44:42,000 --> 00:44:48,000 અમે સમસ્યા કે માર્ગ ઠીક પડશે. 801 00:44:48,000 --> 00:44:52,000 ઠીક સારું, અને ત્યાં છે, રેબેકા ડાબા હાથમાં તેમના બાજુ દ્વારા હવે છે. 802 00:44:52,000 --> 00:44:54,000 >> તે ખૂબ સરળ હતો. 803 00:44:54,000 --> 00:44:57,000 ચાલો allocating-we're પ્રયાસ લગભગ પૂર્ણ, 20. 804 00:44:57,000 --> 00:44:59,000 ઠીક છે, પર આવે છે. 805 00:44:59,000 --> 00:45:04,000 20 ફાળવવામાં આવ્યો છે, તેથી દો મને આગળ વધો અને ફરીથી અહીં કહેવું 806 00:45:04,000 --> 00:45:07,000 અમે ફક્ત નોડ * સાદ કર્યું છે. 807 00:45:07,000 --> 00:45:11,000 અમે malloc હોય (sizeof (નોડ)). 808 00:45:11,000 --> 00:45:16,000 અમે પછી જ ચોક્કસ સિન્ટેક્ષ તરીકે અમે 20 પહેલાં હતી કરવા માટે, 809 00:45:16,000 --> 00:45:20,000 અને હું આગામી = NULL કરવા માટે, અને પડશે હવે અનિતા પર છે 810 00:45:20,000 --> 00:45:23,000 તમને સંકળાયેલા યાદી માં દાખલ કરો, જો તમે તે ચોક્કસ જ ભૂમિકા ભજવી શકે છે. 811 00:45:23,000 --> 00:45:30,000 ચલાવો. 812 00:45:30,000 --> 00:45:32,000 ઠીક છે, સારુ. 813 00:45:32,000 --> 00:45:38,000 હવે કાળજીપૂર્વક વિચારવું તે પહેલાં તમે ડાબી હાથ આસપાસ ખસેડવા શરૂ કરો. 814 00:45:38,000 --> 00:45:46,000 તમે અત્યાર સુધીમાં આજે સૌથી વધુ ત્રાસદાયક ભૂમિકા મળી. 815 00:45:46,000 --> 00:45:59,000 હાથ જેની પ્રથમ ખસેડવામાં આવશે જોઈએ? 816 00:45:59,000 --> 00:46:02,000 ઠીક છે, રાહ જુઓ, હું કેટલાક ની સુનાવણી છું. 817 00:46:02,000 --> 00:46:07,000 જો અમુક લોકો સભ્યતા માટે પ્રતિકૂળ પરિસ્થિતિ અહીં ઉકેલવા મદદ કરવા ઈચ્છો. 818 00:46:07,000 --> 00:46:11,000 જેના ડાબા હાથની પ્રથમ કદાચ સુધારાશે જોઇએ? યાહ. 819 00:46:11,000 --> 00:46:13,000 [વિદ્યાર્થી] સાદ માતાનો. 820 00:46:13,000 --> 00:46:15,000 ઠીક છે, સાદ માતાનો, શા માટે છે, જોકે? 821 00:46:15,000 --> 00:46:17,000 [અશ્રાવ્ય વિદ્યાર્થી જવાબ] 822 00:46:17,000 --> 00:46:19,000 ગુડ, કારણ કે જો અમે ખસેડવા-શું તમારું નામ છે >> માર્શલ?. 823 00:46:19,000 --> 00:46:22,000 માર્શલ, જો આપણે તેમના હાથ નીચે ખસેડો પ્રથમ null, 824 00:46:22,000 --> 00:46:25,000 હવે અમે શાબ્દિક આ યાદીમાં ચાર લોકો અનાથ 825 00:46:25,000 --> 00:46:29,000 કારણ કે તેમણે માત્ર રોમન અને ડાબી દરેકને નિર્દેશ કરતી બાબત હતી, 826 00:46:29,000 --> 00:46:31,000 જેથી નિર્દેશક પ્રથમ અપડેટ ખરાબ હતી. 827 00:46:31,000 --> 00:46:33,000 ચાલો કે પૂર્વવત્ કરો. 828 00:46:33,000 --> 00:46:37,000 ગુડ, અને હવે આગળ વધો અને યોગ્ય ડાબી રોમન નિર્દેશ કરતી બાજુ ખસેડો. 829 00:46:37,000 --> 00:46:39,000 આ થોડો અનાવશ્યક લાગે છે. 830 00:46:39,000 --> 00:46:41,000 હવે બે રોમન નિર્દેશ કરતી લોકો છે, પરંતુ તે દંડ છે 831 00:46:41,000 --> 00:46:43,000 કારણ કે હવે બીજું અમે કેવી રીતે યાદી અપડેટ કરી શકું? 832 00:46:43,000 --> 00:46:48,000 બીજી બાજુ શું ખસેડવા છે? 833 00:46:48,000 --> 00:46:53,000 ઉત્તમ, હવે અમે કોઈ મેમરી ગુમાવી? 834 00:46:53,000 --> 00:46:57,000 ના, તેથી સારા, ચાલો જોવા જો અમે આ વધુ એક વખત નથી તોડી શકે છે. 835 00:46:57,000 --> 00:47:00,000 >> એક છેલ્લા સમય Mallocing, 5 સંખ્યા. 836 00:47:00,000 --> 00:47:04,000 પાછા બધા રીતે, નીચે પર આવે છે. 837 00:47:04,000 --> 00:47:08,000 તે ખૂબ જ આકર્ષક છે. 838 00:47:08,000 --> 00:47:15,000 [વધાવી] 839 00:47:15,000 --> 00:47:17,000 તમારું નામ શું છે >> રોન. 840 00:47:17,000 --> 00:47:19,000 રોન, ઠીક, તમે 5 નંબર તરીકે malloced છે. 841 00:47:19,000 --> 00:47:23,000 અમે હમણાં જ કોડ ચલાવવામાં કર્યું છે કે લગભગ આ સમાન છે 842 00:47:23,000 --> 00:47:26,000 માત્ર એક અલગ નામ સાથે. 843 00:47:26,000 --> 00:47:28,000 ઉત્તમ. 844 00:47:28,000 --> 00:47:38,000 હવે, અનિતા, સારા નસીબ યાદી માં 5 સંખ્યા હવે દાખલ. 845 00:47:38,000 --> 00:47:43,000 ગુડ, અને? 846 00:47:43,000 --> 00:47:47,000 ઉત્તમ છે, જેથી આ ખરેખર ત્રણ કુલ કેસો ત્રીજા છે. 847 00:47:47,000 --> 00:47:49,000 અમે પ્રથમ ઓવરને અંતે કોઈને હતી, રેબેકા. 848 00:47:49,000 --> 00:47:51,000 અમે પછી મધ્યમ કોઇને હતી. 849 00:47:51,000 --> 00:47:53,000 હવે અમે શરૂઆતમાં, અને આ ઉદાહરણ કોઇને હોય છે, 850 00:47:53,000 --> 00:47:56,000 અમે હવે પ્રથમ વખત લુકાસ અપડેટ હતી 851 00:47:56,000 --> 00:48:00,000 કારણ કે યાદીમાં પ્રથમ તત્વ માટે હવે એક નવી ગાંઠ પર નિર્દેશ છે, 852 00:48:00,000 --> 00:48:03,000 જે છેવટે, નોડ 9 નંબર તરફ સંકેત કરે છે. 853 00:48:03,000 --> 00:48:06,000 >> આ એક ખૂબ ત્રાસદાયક નિદર્શન હતી મને ખાતરી છે કે છું, 854 00:48:06,000 --> 00:48:08,000 તેથી આ ગાય્સ માટે વધાવી મોટી રાઉન્ડ જો તમે કરી શકે. 855 00:48:08,000 --> 00:48:11,000 સરસ રીતે કરી શકાય છે. 856 00:48:11,000 --> 00:48:17,000 કે બધા છે. તમે થોડો મેમરી કાગળ તમારી ટુકડાઓ રાખવા શકે છે. 857 00:48:17,000 --> 00:48:22,000 તે તારણ આપે છે કે કોડ માં આવું 858 00:48:22,000 --> 00:48:26,000 તદ્દન તરીકે જ આસપાસ હાથ થતાં સરળ નથી 859 00:48:26,000 --> 00:48:28,000 અને વિવિધ બાબતો પર પોઇન્ટર નિર્દેશ કરતી હશે. 860 00:48:28,000 --> 00:48:31,000 ખ્યાલ પણ છે કે જ્યારે તે કંઈક અમલમાં સમય આવે 861 00:48:31,000 --> 00:48:34,000 એક કડી થયેલ યાદી છે અથવા તેને એક ચલ જો તમે ખરેખર પર ધ્યાન કેન્દ્રિત 862 00:48:34,000 --> 00:48:38,000 આ મૂળભૂત ફંડામેન્ટલ્સ, તો તેના કદ સમસ્યાઓ હું બહાર આકૃતિ હોય છે, 863 00:48:38,000 --> 00:48:43,000 આ બાજુ અથવા આ હાથ છે ખ્યાલ છે કે, શું અન્યથા એકદમ જટિલ પ્રોગ્રામ છે 864 00:48:43,000 --> 00:48:47,000 હકીકતમાં કરી શકો છો, એકદમ સરળ આ જેવી રચનાત્મક ઘટાડી શકાય છે. 865 00:48:47,000 --> 00:48:51,000 >> ચાલો, એક વધુ વ્યવહારદક્ષ દિશામાં વસ્તુઓ હજુ પણ લે છે. 866 00:48:51,000 --> 00:48:53,000 હવે અમે યાદીની લિંક કલ્પના હોય છે. 867 00:48:53,000 --> 00:48:57,000 અમે પણ પાછળ સૂચન ત્યાં એક સમયમાં બમણું કડી થયેલ યાદી માટે હોય છે, આભાર 868 00:48:57,000 --> 00:49:01,000 જે લગભગ એ જ લાગે છે, પરંતુ હવે અમે સ્ટ્રક્ટ ની અંદર બે પોઇન્ટર છે 869 00:49:01,000 --> 00:49:05,000 તેના બદલે એક છે, અને અમે કદાચ તે પોઇંટરો આગલી કહી શકે છે 870 00:49:05,000 --> 00:49:08,000 અથવા ડાબી કે જમણી, પરંતુ અમે હકીકતમાં નથી, તેમાંથી બે જરૂર છે. 871 00:49:08,000 --> 00:49:10,000 આ કોડ થોડું એક સંકળાયેલી વધુ હશે. 872 00:49:10,000 --> 00:49:12,000 અનિતા માટે સ્ટેજ પર વધુ કાર્ય અહીં હતા. 873 00:49:12,000 --> 00:49:15,000 પરંતુ અમે ચોક્કસપણે માળખું તે પ્રકારના અમલ કરી શકે છે. 874 00:49:15,000 --> 00:49:19,000 સમય ચાલી દ્રષ્ટિએ, જોકે, શું ચાલી રહેલ સમય હશે 875 00:49:19,000 --> 00:49:24,000 એક કડી થયેલ યાદીમાં સંખ્યા n હવે શોધવાની અનિતા માટે? 876 00:49:24,000 --> 00:49:27,000 N ના હજુ પણ મોટી ઓ, જેથી તે કોઈ રેખીય શોધ કરતાં વધુ સારી છે. 877 00:49:27,000 --> 00:49:29,000 અમે દ્વિસંગી શોધ નથી, છતાં, ફરી શકો છો. 878 00:49:29,000 --> 00:49:34,000 શા માટે બને કે હતો? તમે આસપાસ ન બાંધી શકે છે. 879 00:49:34,000 --> 00:49:36,000 તેમ છતાં અમે ચોક્કસપણે સ્ટેજ પર તમામ મનુષ્યો જુઓ, 880 00:49:36,000 --> 00:49:39,000 અને અનિતા તે eyeballed હોઈ શકે છે અને કહ્યું હતું કે, "અહીં યાદી મધ્યમાં છે," 881 00:49:39,000 --> 00:49:42,000 તેમણે તે ખબર નથી જો તેણી કમ્પ્યુટર પ્રોગ્રામ કરવામાં આવતું હતું 882 00:49:42,000 --> 00:49:47,000 કારણ કે માત્ર વસ્તુ તેમણે પર દૃશ્ય શરૂઆતમાં લેતું માટે 883 00:49:47,000 --> 00:49:50,000 લુકાસ, જેમણે પ્રથમ નિર્દેશક હતા. 884 00:49:50,000 --> 00:49:53,000 તે આવશ્યકપણે તે લિંક્સને અનુસરો હોવી જોઈએ, 885 00:49:53,000 --> 00:49:56,000 તેના માર્ગ ગણાય છે ત્યાં સુધી તે આશરે મધ્યમ જોવા મળે છે, 886 00:49:56,000 --> 00:49:58,000 અને પણ, તો પછી તે જાણવા માટે જ્યારે તેણી મધ્યમ પહોંચી છે નથી ચાલી રહ્યું છે 887 00:49:58,000 --> 00:50:01,000 જ્યાં સુધી તે ઓવરને બધી રીતે જાય છે માટે બહાર આકૃતિ કેટલી ત્યાં છે, 888 00:50:01,000 --> 00:50:05,000 પછી backtracks કે, અને ખૂબ મુશ્કેલ હોઈ જ્યાં સુધી તમે હતું 889 00:50:05,000 --> 00:50:07,000 અમુક પ્રકારની એક સમયમાં બમણું કડી થયેલ યાદી. 890 00:50:07,000 --> 00:50:10,000 >> કેટલીક સમસ્યાઓ ઉકેલવાની આજે, પરંતુ અન્ય પરિચય કરાવ્યો. 891 00:50:10,000 --> 00:50:12,000 વિવિધ માહિતી માળખું એકસાથે વિશે શું? 892 00:50:12,000 --> 00:50:15,000 આ માથેર હાઉસ ટ્રેમાં એક ફોટોગ્રાફ છે, 893 00:50:15,000 --> 00:50:19,000 અને આ કિસ્સામાં, અમે એ માહિતી બંધારણ અમે પણ પ્રકારની કરી છે પહેલેથી વિશે વાત છે. 894 00:50:19,000 --> 00:50:22,000 અમે મેમરી સંદર્ભમાં સ્ટેક વિશે વાત કરી, 895 00:50:22,000 --> 00:50:26,000 અને તે પ્રકારના ઇરાદાપૂર્વક નામ આપવામાં આવ્યું છે કારણ કે મેમરીનો દ્રષ્ટિએ સ્ટેક 896 00:50:26,000 --> 00:50:31,000 અસરકારક રીતે એ માહિતી બંધારણ છે કે જે વધુ અને વધુ સાથે ટોચ પર સ્તરવાળી સામગ્રી છે. 897 00:50:31,000 --> 00:50:35,000 પરંતુ સ્ટેક વિશે રસપ્રદ બાબત એ છે, વાસ્તવમાં આ કેસ છે, 898 00:50:35,000 --> 00:50:38,000 તે છે કે તે માહિતી માળખું એક ખાસ પ્રકારની છે. 899 00:50:38,000 --> 00:50:42,000 તે માહિતી માળખું છે જેમાં પ્રથમ તત્વ 900 00:50:42,000 --> 00:50:46,000 છેલ્લા તત્વ છે આઉટ. 901 00:50:46,000 --> 00:50:50,000 જો તમે પ્રથમ સ્ટેક મુકવામાં આવે ટ્રે છે, 902 00:50:50,000 --> 00:50:53,000 તમે કમનસીબે છેલ્લા બોલ સ્ટેક લઈ શકાય ટ્રે પ્રયત્ન જઈ રહ્યાં છો, 903 00:50:53,000 --> 00:50:55,000 અને તે એક સારી બાબત હોય તે જરૂરી છે. 904 00:50:55,000 --> 00:50:58,000 તેનાથી વિપરીત, તમે તેના વિશે બીજી રીતે આસપાસ લાગે શકે છે, 905 00:50:58,000 --> 00:51:02,000 છેલ્લા પ્રથમ આઉટ છે. 906 00:51:02,000 --> 00:51:05,000 >> હવે, કોઈ દૃશ્યો માટે વાંધો જ્યાં સ્ટેક કર્યા આવતી નથી 907 00:51:05,000 --> 00:51:08,000 માહિતી બંધારણ છે કે જે તમને જ્યાં મિલકત છે 908 00:51:08,000 --> 00:51:13,000 માં, પ્રથમ બહાર છેલ્લા ના, ખરેખર છે અનિવાર્ય? 909 00:51:13,000 --> 00:51:16,000 કે સારી વસ્તુ છે? કે ખરાબ વસ્તુ છે? 910 00:51:16,000 --> 00:51:19,000 તે ચોક્કસપણે એક ખરાબ વાત છે જો ટ્રે તમામ સમાન ન હતી 911 00:51:19,000 --> 00:51:21,000 અને તેઓ બધા ખાસ અલગ રંગો અથવા whatnot હતા, 912 00:51:21,000 --> 00:51:24,000 અને રંગ તમે કરવા માંગો છો તળિયે તમામ માર્ગ છે. 913 00:51:24,000 --> 00:51:26,000 અલબત્ત, તમે તે મહાન પ્રયાસ વગર મેળવી શકો છો. 914 00:51:26,000 --> 00:51:28,000 તમે ટોચ પરથી શરૂ કરો અને તમારી રીતે કામ નીચે હોય છે. 915 00:51:28,000 --> 00:51:31,000 તેવી જ રીતે, જો તમે આ ચાહક છોકરાઓ હતા 916 00:51:31,000 --> 00:51:34,000 જે બધા માટે એક આઇફોન અને લીટીઓ વિચાર કરવાનો પ્રયાસ રાત રાહ જુએ છે 917 00:51:34,000 --> 00:51:36,000 આ જેવી જગ્યાએ? 918 00:51:36,000 --> 00:51:40,000 સરસ ન હોઈ તે છો જો એપલ સ્ટોર 919 00:51:40,000 --> 00:51:42,000 સ્ટેક માહિતી માળખું હતા? 920 00:51:42,000 --> 00:51:44,000 યે? નાયનું? 921 00:51:44,000 --> 00:51:47,000 તે છેલ્લા શક્ય ઘડીએ માત્ર જે લોકો બતાવે માટે સારું છે 922 00:51:47,000 --> 00:51:50,000 અને પછી બંધ કતાર આમળી છે. 923 00:51:50,000 --> 00:51:52,000 અને હકીકતમાં, હકીકત એ છે કે હું વલણ હતી કતાર કહેવા માટે 924 00:51:52,000 --> 00:51:56,000 ખરેખર આપણે શું માહિતી માળખું આ પ્રકારની કૉલ કરશે સાથે સુસંગત છે, 925 00:51:56,000 --> 00:51:59,000 વાસ્તવમાં જ્યાં હુકમ દ્રવ્યની એક, 926 00:51:59,000 --> 00:52:02,000 અને તમે પ્રથમ એક પ્રથમ એક પ્રયત્ન કરવા માટે કરવા માંગો છો 927 00:52:02,000 --> 00:52:04,000 માત્ર જો માનવ ઔચિત્યની ખાતર. 928 00:52:04,000 --> 00:52:07,000 અમે સામાન્ય રીતે કતાર માહિતી બંધારણ છે કે કહી શકશો. 929 00:52:07,000 --> 00:52:11,000 >> તે તારણ સાથે લિંક યાદીઓ ઉપરાંત, અમે આ જ મૂળભૂત વિચારો મદદથી શરૂ કરી શકો છો 930 00:52:11,000 --> 00:52:15,000 અને સમસ્યાઓના નિરાકરણ નવા અને અલગ પ્રકારના સર્જન કરવાનું શરૂ કરો. 931 00:52:15,000 --> 00:52:19,000 હમણાં પૂરતું, સ્ટેક કિસ્સામાં, અમે સ્ટેક પ્રતિનિધિત્વ કરી શકે છે 932 00:52:19,000 --> 00:52:22,000 આ જેવી માહિતી બંધારણ વાપરી રહ્યા હોય, હું પ્રસ્તાવ થશે. 933 00:52:22,000 --> 00:52:26,000 આ કિસ્સામાં, હું સ્ટ્રક્ટ જાહેર કર્યું છે, અને હું આ માળખાની અંદર જણાવ્યું હતું કર્યા છે 934 00:52:26,000 --> 00:52:30,000 નંબરો ઝાકઝમાળ છે અને પછી એક ચલ કહેવાય માપ છે, 935 00:52:30,000 --> 00:52:33,000 અને હું આ વસ્તુ સ્ટેક કૉલ જાઉં છું. 936 00:52:33,000 --> 00:52:35,000 હવે, શા માટે આ ખરેખર કામ કરે છે? 937 00:52:35,000 --> 00:52:43,000 સ્ટેક કિસ્સામાં, હું એક એરે તરીકે સ્ક્રીન પર આ અસરકારક રીતે ડ્રો કરી શકી. 938 00:52:43,000 --> 00:52:47,000 અહીં મારા સ્ટેક છે. તે મારા નંબરો છે. 939 00:52:47,000 --> 00:52:50,000 અને અમે તેમને આ ડ્રો, આ પડશે, આ, આ, આ. 940 00:52:50,000 --> 00:52:53,000 અને પછી હું કેટલાક અન્ય માહિતી સભ્ય અહીં હોય છે, 941 00:52:53,000 --> 00:52:58,000 જેમાં કદ કહે છે, તેથી આ માપ છે, અને આ નંબરો છે, 942 00:52:58,000 --> 00:53:02,000 અને સામૂહિક, આખી અહીં આઇપેડ એક સ્ટેક માળખું રજૂ કરે છે. 943 00:53:02,000 --> 00:53:07,000 હવે, મૂળભૂત રીતે, કદ કદાચ માટે 0 થી આરંભ થવો મળ્યું છે, 944 00:53:07,000 --> 00:53:11,000 અને શું સંખ્યાની એરે ની અંદર શરૂઆતમાં છે 945 00:53:11,000 --> 00:53:14,000 જ્યારે હું પ્રથમ ઝાકઝમાળ ફાળવવા? 946 00:53:14,000 --> 00:53:16,000 કચરો. કોણ જાણે? અને તે ખરેખર તો કોઈ વાંધો નથી. 947 00:53:16,000 --> 00:53:20,000 તે વાંધો જો આ 1, 2, 3, 4, 5 નથી કરતું નથી, સંપૂર્ણપણે રેન્ડમ 948 00:53:20,000 --> 00:53:25,000 ખરાબ મારા માળખું માં સ્ટોર નસીબ દ્વારા કારણ કે લાંબા જેથી મને ખબર છે કે સ્ટેક કદ 949 00:53:25,000 --> 00:53:29,000 0 છે, તો પછી હું પ્રોગ્રામ જાણો છો, એરે માં તત્વો કોઈપણ અંતે લાગતું નથી. 950 00:53:29,000 --> 00:53:31,000 તે તો કોઈ વાંધો નથી કે શું ત્યાં છે. 951 00:53:31,000 --> 00:53:34,000 તેમને ન જુઓ, તરીકે 0 એક માપ કારણે હશે. 952 00:53:34,000 --> 00:53:38,000 >> પરંતુ હવે કદાચ હું આગળ જાઓ અને સ્ટેક માં કંઈક દાખલ કરો. 953 00:53:38,000 --> 00:53:42,000 હું 5 નંબર દાખલ કરવા માંગો છો, તેથી હું 5 નંબર અહીં મૂકો, 954 00:53:42,000 --> 00:53:45,000 અને પછી હું શું કરી શકું નીચે અહીં મૂકો? 955 00:53:45,000 --> 00:53:48,000 હવે હું ખરેખર નીચે કદ માટે કરશે 1 મૂકી, 956 00:53:48,000 --> 00:53:50,000 અને હવે સ્ટેક કદ 1 નું છે. 957 00:53:50,000 --> 00:53:53,000 જો હું આગળ જાઓ અને નંબર દાખલ કરો દો, કહો કે, 7 આગામી? 958 00:53:53,000 --> 00:53:57,000 આ પછી 2 સુધારાયેલ નહીં, અને તે પછી અમે 9 કરીશ, 959 00:53:57,000 --> 00:54:02,000 અને પછી આ માટે 3 સુધારાશે નહીં. 960 00:54:02,000 --> 00:54:05,000 પરંતુ આ સ્ટેક રસપ્રદ હવે લક્ષણ એ છે કે 961 00:54:05,000 --> 00:54:09,000 હું જે તત્વ દૂર જો હું પૉપ માંગો છો માનવામાં છું 962 00:54:09,000 --> 00:54:12,000 સ્ટેક બંધ કંઈક છે, તેથી વાત કરવા માટે? 963 00:54:12,000 --> 00:54:14,000 9 પ્રથમ જાઓ વસ્તુ હોઈ શકે છે. 964 00:54:14,000 --> 00:54:18,000 ચિત્ર જો હું સ્ટેક બોલ તત્વ પૉપ માંગો છો કેવી રીતે બદલવો જોઈએ, 965 00:54:18,000 --> 00:54:20,000 ખૂબ માથેર એક ટ્રે માંગો છો? 966 00:54:20,000 --> 00:54:22,000 યાહ >> માટે 2 [વિદ્યાર્થી] સેટ માપ.. 967 00:54:22,000 --> 00:54:27,000 બરાબર, બધા હું કદ માટે 2 સુયોજિત છે, અને હું શું એરે સાથે તમે શું કરશો? 968 00:54:27,000 --> 00:54:29,000 હું કશું કરવાનું નથી. 969 00:54:29,000 --> 00:54:32,000 હું, માત્ર ગુદા હોઇ શકે છે, એક ત્યાં 0 અથવા -1 અથવા સૂચક કંઈક મૂકી 970 00:54:32,000 --> 00:54:34,000 કે આ એક વંચાય કિંમત નથી, પણ તે તો કોઈ વાંધો નથી કારણ કે 971 00:54:34,000 --> 00:54:37,000 હું એરે પોતે કેટલા છે બહાર રેકોર્ડ કરી શકો છો 972 00:54:37,000 --> 00:54:41,000 જેથી મને ખબર છે ફક્ત આ એરે પ્રથમ બે તત્વો જુઓ. 973 00:54:41,000 --> 00:54:47,000 હવે, જો હું જાઓ અને આ એરે માટે 8 નંબર ઉમેરો, કેવી રીતે ચિત્ર આગામી ફેરફાર થાય છે? 974 00:54:47,000 --> 00:54:50,000 આ 8 બને છે, અને આ 3 બને છે. 975 00:54:50,000 --> 00:54:52,000 હું થોડા ખૂણાઓ અહીં કાપી રહ્યો છું. 976 00:54:52,000 --> 00:54:56,000 હવે અમે 5, 7, 8, છે અને અમે 3 ના કદ માટે પાછા આવ્યા. 977 00:54:56,000 --> 00:54:58,000 આ એક ખૂબ સુંદર અમલ સરળ છે, 978 00:54:58,000 --> 00:55:06,000 પરંતુ જ્યારે અમે આ ડિઝાઇન નિર્ણય દિલગીરી જવું છે? 979 00:55:06,000 --> 00:55:09,000 વસ્તુઓ માટે ખૂબ, ખૂબ ખોટું જાઓ જ્યારે શરૂ કરી શકું? યાહ. 980 00:55:09,000 --> 00:55:11,000 [અશ્રાવ્ય વિદ્યાર્થી જવાબ] 981 00:55:11,000 --> 00:55:13,000 જ્યારે તમે પાછા જાઓ અને પ્રથમ તત્વ તમે સાઇન મૂકી મેળવવા માંગો છો 982 00:55:13,000 --> 00:55:18,000 >> તે અહીં વળે છે તેમ છતાં સ્ટેક હૂડ નીચે ઝાકઝમાળ છે, 983 00:55:18,000 --> 00:55:21,000 આ માહિતી બંધારણોની અમે વિશે વાત કરવાનું શરૂ કરી દીધું પણ સામાન્ય છે તરીકે પણ ઓળખાય છે 984 00:55:21,000 --> 00:55:25,000 અમૂર્ત માહિતી માળખાં જેમાં તેઓ કેવી રીતે અમલમાં કરી રહ્યા છીએ 985 00:55:25,000 --> 00:55:27,000 આ બિંદુ ઉપરાંત સંપૂર્ણપણે છે. 986 00:55:27,000 --> 00:55:31,000 સ્ટેક જેવા માહિતી બંધારણ માટે આધાર ઉમેરવા માટે માનવામાં આવે છે 987 00:55:31,000 --> 00:55:35,000 દબાણ છે, જે સ્ટેક પર એક ટ્રે કોઈ રન નોંધાયો નહીં જેવી કામગીરી 988 00:55:35,000 --> 00:55:39,000 અને પોપ, કે જે સ્ટેક માંથી તત્વ દૂર કરે છે, અને તે છે. 989 00:55:39,000 --> 00:55:43,000 જો તમે કોઈના કોડ કે જે પહેલાથી જ અમલમાં ડાઉનલોડ હતા 990 00:55:43,000 --> 00:55:46,000 આ વસ્તુ સ્ટેક કહેવાય છે, તે વ્યક્તિ હોય તેવા પરચૂરણ હશે 991 00:55:46,000 --> 00:55:49,000 તમે માત્ર બે વિધેયો દબાણ, અને પોપ, જેનો એકમાત્ર હેતુ જીવન માં 992 00:55:49,000 --> 00:55:51,000 કે બરાબર કરી હશે. 993 00:55:51,000 --> 00:55:54,000 તમે અથવા તેને અથવા તેણીને જે તે કાર્યક્રમની અમલ 994 00:55:54,000 --> 00:55:58,000 સમગ્રપણે નક્કી કેવી રીતે અમલીકરણ કરવા એક કરવામાં આવ્યો હતો 995 00:55:58,000 --> 00:56:00,000 દબાણ અને હૂડ નીચે ધાણી સેમેન્ટિક્સ 996 00:56:00,000 --> 00:56:03,000 અથવા દબાણ અને ધાણી ની કાર્યત્મકતા. 997 00:56:03,000 --> 00:56:07,000 અને હું કંઈક shortsighted નિર્ણય અહીં આવેલ છે 998 00:56:07,000 --> 00:56:10,000 આ સરળ માહિતી માળખું શા માટે મારા સ્ટેક અમલીકરણ દ્વારા? 999 00:56:10,000 --> 00:56:12,000 જ્યારે આ માહિતી માળખું વિરામ કરે છે? 1000 00:56:12,000 --> 00:56:18,000 કયા બિંદુ પર મેં એક ભૂલ પરત જ્યારે વપરાશકર્તા દબાણ કહે છે, હમણાં પૂરતું છે? 1001 00:56:18,000 --> 00:56:20,000 [વિદ્યાર્થી] જો ત્યાં વધુ જગ્યા છે. 1002 00:56:20,000 --> 00:56:23,000 બરાબર, જો ત્યાં વધુ જગ્યા છે, જો હું ક્ષમતા વટાવી દીધી છે, 1003 00:56:23,000 --> 00:56:27,000 જે તમામ કેપ્સ છે કારણ કે તે સૂચવે છે કે વૈશ્વિક સતત કેટલાક પ્રકારની છે. 1004 00:56:27,000 --> 00:56:30,000 વેલ, તો પછી હું ફક્ત હોય જાઉં છું કહી, "માફ કરશો, હું બીજા કિંમત નથી દબાણ કરી શકો છો 1005 00:56:30,000 --> 00:56:32,000 સ્ટેક પર ખૂબ, "માથેર માં ગમે છે. 1006 00:56:32,000 --> 00:56:36,000 >> અમુક બિંદુએ, તેઓ માટે થોડો કેબિનેટ ટોચ ભાગ હિટ રહ્યા છીએ. 1007 00:56:36,000 --> 00:56:39,000 કોઈ વધુ અથવા સ્ટેક જગ્યા ક્ષમતા છે, જે બિંદુએ ત્યાં ભૂલ અમુક પ્રકારની છે. 1008 00:56:39,000 --> 00:56:42,000 તેઓ તત્વ બીજે ક્યાંક મૂકી હોય, તો ટ્રે બીજે ક્યાંક, 1009 00:56:42,000 --> 00:56:44,000 અથવા ક્યાંય અંતે તમામ. 1010 00:56:44,000 --> 00:56:47,000 હવે, કતાર સાથે, અમે તેને અલગ થોડો અમલ કરી શકે છે. 1011 00:56:47,000 --> 00:56:50,000 એક કતાર કે હૂડ નીચે, તે અમલમાં શકાય થોડું અલગ છે 1012 00:56:50,000 --> 00:56:54,000 એક એરે તરીકે, પરંતુ શા માટે, આ કિસ્સામાં, હું પ્રસ્તાવ છું 1013 00:56:54,000 --> 00:56:59,000 પણ એક વડા યાદી વડા રજૂ તત્વ છે, 1014 00:56:59,000 --> 00:57:06,000 યાદી આગળના, એપલ સ્ટોરમાં લીટી માં પ્રથમ વ્યક્તિ કદ ઉપરાંત? 1015 00:57:06,000 --> 00:57:14,000 હું માહિતી વધારાનો ભાગ કેમ નથી અહીં જરૂર છે? 1016 00:57:14,000 --> 00:57:16,000 નંબરો શું છે પાછા વિચારો 1017 00:57:16,000 --> 00:57:18,000 જો હું દોરવામાં કર્યું છે કે તે નીચે પ્રમાણે છે. 1018 00:57:18,000 --> 00:57:21,000 ધારો કે આ હવે સ્ટેક બદલે કતાર છે, 1019 00:57:21,000 --> 00:57:24,000 એપલ ભંડાર કતાર જેવી છે-માત્ર તફાવત વાજબી છે. 1020 00:57:24,000 --> 00:57:27,000 યાદી શરૂઆતમાં આ વાક્ય પ્રથમ વ્યક્તિ, આ કિસ્સામાં 5 નંબર, 1021 00:57:27,000 --> 00:57:30,000 તે અથવા તેણી દુકાન માં દો સૌ પહેલા રહ્યું છે. 1022 00:57:30,000 --> 00:57:32,000 ચાલો કે નથી. 1023 00:57:32,000 --> 00:57:35,000 ધારો કે આ ક્ષણે મારા કતાર રાજ્યના સમય છે અને હવે એપલ સ્ટોર 1024 00:57:35,000 --> 00:57:39,000 ખોલે છે અને પ્રથમ વ્યક્તિ, 5 નંબર, સ્ટોર કરવા તરફ દોર્યું છે. 1025 00:57:39,000 --> 00:57:43,000 હું ચિત્ર કેવી રીતે હમણાં બદલો કે હું તેઓ પ્રથમ વ્યક્તિ DE-કતારબદ્ધ 1026 00:57:43,000 --> 00:57:47,000 રેખાના આ બોલ પર? 1027 00:57:47,000 --> 00:57:50,000 કે શું >>? [વિદ્યાર્થી] એ કતાર બદલો. 1028 00:57:50,000 --> 00:57:52,000 માથા બદલાય છે, તેથી 5 અદૃશ્ય થઈ જાય છે. 1029 00:57:52,000 --> 00:57:56,000 વાસ્તવમાં, તે છતાં કેવી રીતે શ્રેષ્ઠ છે આ કરવા માટે? 1030 00:57:56,000 --> 00:58:00,000 વાસ્તવમાં, તે છતાં તરીકે આ વ્યક્તિ અદૃશ્ય થઈ જાય છે. 1031 00:58:00,000 --> 00:58:03,000 7 નંબર શું ખરેખર સ્ટોર કરતા છો? 1032 00:58:03,000 --> 00:58:05,000 તેઓ એક મોટું પગલું આગળ લેશે. 1033 00:58:05,000 --> 00:58:08,000 >> પરંતુ અમે શું કદર આવ્યા છે જ્યારે તે એરે માટે આવે છે 1034 00:58:08,000 --> 00:58:10,000 અને આસપાસ વસ્તુઓ ખસેડી રહ્યા? 1035 00:58:10,000 --> 00:58:12,000 કે જે તમારી સમય કચરો પ્રકારની અધિકાર છે? 1036 00:58:12,000 --> 00:58:16,000 તમે આવું ગુદા પ્રયત્ન શા માટે હોય એ પ્રથમ વ્યક્તિ હોય 1037 00:58:16,000 --> 00:58:21,000 ભૌતિક મેમરીનો ભાગ શરૂઆતમાં લીટી શરૂઆતમાં? 1038 00:58:21,000 --> 00:58:23,000 કે સંપૂર્ણપણે બિનજરૂરી છે. શા માટે? 1039 00:58:23,000 --> 00:58:26,000 હું શું માત્ર બદલે યાદ શકે >>? [અશ્રાવ્ય વિદ્યાર્થી જવાબ] 1040 00:58:26,000 --> 00:58:30,000 બરાબર, હું હમણાં જ આ વધારાની માહિતી સભ્ય વડા સાથે યાદ કરી શકે છે 1041 00:58:30,000 --> 00:58:34,000 કે જે હવે આ યાદીમાં વડા હવે 0, જે તેને એક ક્ષણ પહેલા હતું. 1042 00:58:34,000 --> 00:58:39,000 હવે તે ખરેખર નંબર 1 છે. આ રીતે, હું થોડો ઓપ્ટિમાઇઝેશન મેળવો. 1043 00:58:39,000 --> 00:58:44,000 જસ્ટ કારણ કે હું કરેલા વાક્ય શરૂઆતમાં એપલ સ્ટોરમાં વાક્યમાંથી કોઈને DE-કતારબદ્ધ 1044 00:58:44,000 --> 00:58:47,000 નથી તેનો અર્થ નથી દરેકને પાળી, સ્મૃતિ કે જે સુરેખ કામગીરી છે. 1045 00:58:47,000 --> 00:58:50,000 હું બદલે સતત સમય માત્ર સમય ગાળી શકે છે 1046 00:58:50,000 --> 00:58:53,000 અને પછી વધુ ઝડપી પ્રતિભાવ હાંસલ કરે છે. 1047 00:58:53,000 --> 00:58:56,000 પરંતુ ભાવ હું ભરવા છું એ છે જે વધારાની કામગીરી કે મેળવવા માટે 1048 00:58:56,000 --> 00:58:58,000 કર્યા નથી અને દરેકને પાળી? 1049 00:58:58,000 --> 00:59:01,000 યાહ. >> [અશ્રાવ્ય વિદ્યાર્થી જવાબ] 1050 00:59:01,000 --> 00:59:04,000 વધુ લોકો ઉમેરી શકો છો, સાથે સાથે, કે જે સમસ્યા ઓર્થોગોનલ છે 1051 00:59:04,000 --> 00:59:07,000 હકીકત એ છે કે અમે લોકો આસપાસ નથી સ્થળાંતર કરી રહ્યાં છે. 1052 00:59:07,000 --> 00:59:11,000 તે હજુ પણ ઝાકઝમાળ છે, તેથી કે નહીં અમે દરેકને પાળી નથી અથવા- 1053 00:59:11,000 --> 00:59:13,000 ઓહ, હું જુઓ તમે શું અર્થ, ઠીક છે. 1054 00:59:13,000 --> 00:59:16,000 ખરેખર, હું તમને શું કહી રહ્યાં છે કે તે લગભગ છતાં તરીકે સાથે સંમત છો 1055 00:59:16,000 --> 00:59:19,000 આપણે હવે જઈ રહ્યાં છો ક્યારેય આ એરે શરૂઆત હવે ઉપયોગ 1056 00:59:19,000 --> 00:59:22,000 કારણ કે જો હું 5 દૂર કરવા માટે, તે પછી હું 7 દૂર કરો. 1057 00:59:22,000 --> 00:59:24,000 પરંતુ હું માત્ર જમણી લોકો મૂકો. 1058 00:59:24,000 --> 00:59:28,000 >> તે જેમ હું જગ્યા બગાડ છું એવું લાગે છે, અને છેવટે મારી કતાર બધા અંતે કશું માં વિઘટિત રહે, 1059 00:59:28,000 --> 00:59:31,000 તેથી અમે ફક્ત લોકો wraparound હોય શકે છે, 1060 00:59:31,000 --> 00:59:35,000 અને અમે આ ઍરેની પરિપત્ર માળખું કેટલાક પ્રકારના ખરેખર લાગે શકે છે, 1061 00:59:35,000 --> 00:59:38,000 પરંતુ અમે સી શું ઓપરેટર વાપરવા માટે wraparound કે પ્રકારની છે? 1062 00:59:38,000 --> 00:59:40,000 [અશ્રાવ્ય વિદ્યાર્થી પ્રતિભાવ] >> આ મોડ્યૂલો ઓપરેટર. 1063 00:59:40,000 --> 00:59:43,000 તે થોડો હેરાન થઈ મારફતે લાગે છે કે કેવી રીતે તમે wraparound કરવું હો, 1064 00:59:43,000 --> 00:59:46,000 પરંતુ અમે તે કરી શક્યું ન હતું અને અમે શું કરીએ લીટી આગળના પ્રયત્ન ઉપયોગ લોકો મૂકવા શરૂ કરી શકે છે, 1065 00:59:46,000 --> 00:59:52,000 પરંતુ અમે ફક્ત આ વડા ચલ લીટી ના વાસ્તવિક વડા જે ખરેખર છે યાદ કરે છે. 1066 00:59:52,000 --> 00:59:57,000 તો શું, તેના બદલે જોકે આખરે અમારા ધ્યેય,,, 1067 00:59:57,000 --> 01:00:00,000 સુધી નંબરો જોવા હતી, કારણ કે અમે અનિતા સાથે સ્ટેજ પર અહીં કર્યું, 1068 01:00:00,000 --> 01:00:02,000 પરંતુ અમે ખરેખર આ બધા વિશ્વનું શ્રેષ્ઠ કરવા માંગો છો? 1069 01:00:02,000 --> 01:00:05,000 અમે વધુ અભિજાત્યપણુ કરતાં એરે માટે પરવાનગી આપે છે કરવા માંગો છો 1070 01:00:05,000 --> 01:00:09,000 કારણ કે અમે માટે ગતિશીલ માહિતી માળખું વધવા ક્ષમતા કરવા માંગો છો. 1071 01:00:09,000 --> 01:00:12,000 પરંતુ અમે કંઈક આશરો કે અમે ધ્યાન દોર્યું હોય નથી માંગતા 1072 01:00:12,000 --> 01:00:15,000 પ્રથમ વ્યાખ્યાન એક શ્રેષ્ઠ અલ્ગોરિધમનો ન હતી, 1073 01:00:15,000 --> 01:00:17,000 રેખીય શોધ કે. 1074 01:00:17,000 --> 01:00:21,000 તે તારણ છે કે જે તમને હકીકતમાં હાંસલ કરી શકો છો, 1075 01:00:21,000 --> 01:00:24,000 અથવા ઓછામાં ઓછું સતત સમય માટે બંધ છે, જેમાં અનિતા જેમ, કોઈને 1076 01:00:24,000 --> 01:00:27,000 જો તેણી માહિતી માળખું રૂપરેખાંકિત કરવા નથી સંકળાયેલી યાદી, 1077 01:00:27,000 --> 01:00:30,000 એક સ્ટેક ન હોઈ પ્રયત્ન નથી, એક કતાર, હકીકતમાં કરી શકતા, 1078 01:00:30,000 --> 01:00:33,000 એ માહિતી બંધારણ છે કે જે તેને વસ્તુઓ જોવા માટે પરવાનગી આપે છે સાથે આવે છે, 1079 01:00:33,000 --> 01:00:37,000 પણ શબ્દો, નંબરો માત્ર નથી, શું આપણે સતત સમય કહી શકશો. 1080 01:00:37,000 --> 01:00:40,000 >> અને હકીકતમાં, આગળ જોઈ રહ્યા છીએ, આ એક વર્ગ માં psets લગભગ હંમેશા 1081 01:00:40,000 --> 01:00:43,000 એક જોડણી તપાસનાર એક અમલીકરણ જેમાં, 1082 01:00:43,000 --> 01:00:46,000 અમે તમને ફરીથી આપી કેટલાક 150,000 ઇંગલિશ શબ્દો અને ધ્યેય છે 1083 01:00:46,000 --> 01:00:51,000 મેમરીમાં લોડ તે અને ઝડપથી કરવા માટે ફોર્મ પ્રશ્નો જવાબ કરવાનો પ્રયત્ન 1084 01:00:51,000 --> 01:00:54,000 આ શબ્દ જોડણી સાચી? 1085 01:00:54,000 --> 01:00:58,000 અને તે ખરેખર જો તમે બધા 150,000 શબ્દો દ્વારા ભારપૂર્વક કહેવું છે કે જવાબ હતો suck કરશે. 1086 01:00:58,000 --> 01:01:02,000 પરંતુ, વાસ્તવમાં, અમે જોશો કે અમે તેને ખૂબ, ખૂબ ઝડપી સમય માં કરી શકો છો. 1087 01:01:02,000 --> 01:01:06,000 અને તે અમલમાં હેશ ટેબલ કહેવાય કંઈક સમાવેશ ચાલી રહ્યું છે, 1088 01:01:06,000 --> 01:01:09,000 અને છતાં પણ પ્રથમ નજરમાં આ હેશ ટેબલ કહેવાય વસ્તુ રહ્યું છે 1089 01:01:09,000 --> 01:01:12,000 અમને પ્રાપ્ત આ સુપર ઝડપી પ્રતિભાવ સમય, 1090 01:01:12,000 --> 01:01:18,000 તે તારણ છે કે વાસ્તવમાં એક સમસ્યા છે. 1091 01:01:18,000 --> 01:01:23,000 જ્યારે તે આ ફરીથી કહેવાય વસ્તુ અમલમાં સમય આવે છે, હું તેને ફરીથી કરી રહ્યો છું. 1092 01:01:23,000 --> 01:01:25,000 હું માત્ર અહીં એક છું. 1093 01:01:25,000 --> 01:01:28,000 જ્યારે તે આવે છે અને આ વસ્તુ અમલમાં સમય હેશ ટેબલ કહે છે, 1094 01:01:28,000 --> 01:01:30,000 અમે નિર્ણય લેવા માટે હોય રહ્યા છીએ. 1095 01:01:30,000 --> 01:01:32,000 મોટા કેવી રીતે આ વસ્તુ વાસ્તવમાં જોઈએ? 1096 01:01:32,000 --> 01:01:36,000 અને જ્યારે અમે આ હેશ કોષ્ટકમાં દાખલ નંબરો શરૂ કરવા માટે, 1097 01:01:36,000 --> 01:01:38,000 અમે તેમને એવી રીતે સ્ટોર કેવી રીતે કરવાના છો 1098 01:01:38,000 --> 01:01:42,000 કે અમે તેમને પાછા વિચાર બહાર શકે તેટલી ઝડપથી અમે તેમને મળી? 1099 01:01:42,000 --> 01:01:45,000 પરંતુ અમે તે પહેલાં લાંબા જોશો કે આ પ્રશ્ન 1100 01:01:45,000 --> 01:01:48,000 જ્યારે દરેક જન્મદિવસ વર્ગ છે તદ્દન પ્રસ્તુત થશે. 1101 01:01:48,000 --> 01:01:51,000 તે તારણ આપે છે કે આ ખંડમાં, આપણે થોડાક સેંકડો લોકો મળી છે, 1102 01:01:51,000 --> 01:01:56,000 આ મતભેદ કે જેથી બે ના હોય એ જ જન્મદિવસ કદાચ ખૂબ ઊંચી છે. 1103 01:01:56,000 --> 01:01:58,000 જો કે આ રૂમમાં અમને માત્ર 40 હતા? 1104 01:01:58,000 --> 01:02:02,000 બે જ જન્મદિવસ કર્યા લોકોની મતભેદ શું છે? 1105 01:02:02,000 --> 01:02:04,000 [વિદ્યાર્થીઓ] 50% બોલ. 1106 01:02:04,000 --> 01:02:06,000 અરે વાહ, 50%. હકીકતમાં, હું પણ ચાર્ટ લાવ્યા. 1107 01:02:06,000 --> 01:02:08,000 તે અને વળે છે અને આ ખરેખર માત્ર એક ઝલક છે પૂર્વદર્શન- 1108 01:02:08,000 --> 01:02:12,000 જો ત્યાં ફક્ત આ ઓરડામાં અમને 58, અમને 2 સંભાવના છે 1109 01:02:12,000 --> 01:02:16,000 એ જ જન્મદિવસ કર્યા ભારે ઊંચું હોય છે, લગભગ 100%, 1110 01:02:16,000 --> 01:02:20,000 અને તે માટે બુધવારના રોજ અમારા માટે એક નુકસાન સમગ્ર જથ્થો કારણ બનશે. 1111 01:02:20,000 --> 01:02:24,000 >> સાથે કહ્યું હતું કે, ચાલો અહીં મોકૂફ રાખવું. અમે તમને બુધવારે જોશો. 1112 01:02:24,000 --> 01:02:28,000 [વધાવી] 1113 01:02:28,000 --> 01:02:30,000 [CS50.TV]