1
00:00:00,000 --> 00:00:02,670
[Powered by Google Translate] વિભાગ સમસ્યા 2 સેટ કરો: હેકર આવૃત્તિ

2
00:00:02,670 --> 00:00:04,910
રોબ બોડેન, હાર્વર્ડ યુનિવર્સિટી

3
00:00:04,910 --> 00:00:07,410
આ CS50 છે. CS50.TV

4
00:00:07,410 --> 00:00:15,770
તેથી, હું રોબ છું. હું કિર્કલૅંડ એક વરિષ્ઠ છું. આ મારું ત્રીજું CS50 TFing વર્ષ છે.

5
00:00:15,770 --> 00:00:22,220
તે પ્રથમ વખત કે અમે વિભાગ પરંપરાગત-વ્યાખ્યાન-શૈલી ફેરફાર થાય છે,

6
00:00:22,220 --> 00:00:25,610
જ્યાં અમે સમીક્ષા ફક્ત પ્રકારની વ્યાખ્યાન થયું શું અને તે પછી તમે ગાય્સ પ્રશ્નો પૂછી,

7
00:00:25,610 --> 00:00:32,250
હવે ખૂબ સમસ્યા આધારિત છે, જ્યાં અમે સ્પેસીસ ઉપયોગ કરવા માટે, અને -

8
00:00:32,250 --> 00:00:37,410
ઓહ, તેથી આ વિચારને તે લિંક હું તમને મોકલવામાં પર જાઓ અને પછી તમે મારા સ્પેસ માં હશો.

9
00:00:37,410 --> 00:00:42,410
શું કોઇને લેપટોપ નથી? ઠીક છે.

10
00:00:42,410 --> 00:00:47,050
તેથી અમે આ ઉપયોગ કરી રહ્યા છીએ, અને અમે સમસ્યાઓ કરી શકાય જઈ રહ્યાં છો વિભાગમાં રહે છે

11
00:00:47,050 --> 00:00:50,740
અને તેમને ચર્ચા અને બહાર figuring શું ખોટું છે

12
00:00:50,740 --> 00:00:56,390
અને હું તમારો કોડ કેટલાક ખેંચે છે, હોઈ શકે છે અને હું તમારા વિચારો ચર્ચા થઈ શકે છે.

13
00:00:56,390 --> 00:01:02,140
તેથી કોઈને પણ મુશ્કેલી ધરાવે છે?

14
00:01:02,140 --> 00:01:07,000
તમે બાજુ પર ચેટ કરી શકે છે; હું જો અમે તે માટે કારણ હશે ખબર નથી.

15
00:01:07,000 --> 00:01:12,270
હવે, જે અગાઉના supersection જેમ, જો તમે તે વર્ગ હતા, તમે જાણો છો કે શું વિશે છે.

16
00:01:12,270 --> 00:01:19,200
પી સેટ બધી પર ત્યાં આ વિભાગો જ હશે.

17
00:01:19,200 --> 00:01:22,550
2 પી સેટ તેથી, સ્પષ્ટીકરણો, હું માનું તમે 1 પી સેટ પર તે પહેલેથી જ જોવા મળી હતી.

18
00:01:22,550 --> 00:01:27,400
પરંતુ અમે 2 પી સેટ પર અમે શું આજે પર જઈને કરી રહ્યા છીએ જોવા માટે કરી શકો છો.

19
00:01:27,400 --> 00:01:29,460
અને તમે પ્રશ્નો વિભાગમાં જોઈ શકશો.

20
00:01:29,460 --> 00:01:37,530
તેથી આ પી સેટની તમામ હશે; ત્યાં પ્રશ્નો વિભાગ હશો.

21
00:01:37,530 --> 00:01:41,340
અત્યાર સુધી અમે જણાવ્યું હતું કે, છે "એક પ્રેક્ટિસ તક આ નક્કી કરો."

22
00:01:41,340 --> 00:01:44,940
તમે આ કાર્યક્રમ સબમિટ કરી નથી પૂછવામાં આવશે.

23
00:01:44,940 --> 00:01:48,480
આ વિચાર એ છે કે આ મદદ તમે સમસ્યા સમૂહ સાથે પ્રારંભ પ્રકારની અપેક્ષા છે.

24
00:01:48,480 --> 00:01:53,220
હું હેકર આવૃત્તિ પર ધારી, તેમને ઘણો જ નવું, રસપ્રદ શીખવા માટે વસ્તુઓ હશે તેવું માનવામાં આવે છે.

25
00:01:53,220 --> 00:01:58,590
તેઓ સીધા સમસ્યા સમૂહને લાગુ ન પણ હોય.

26
00:01:58,590 --> 00:02:01,810
અને હમણાં અમે કર્યા તમે તેમને submit નથી છીએ, પરંતુ સિદ્ધાંતમાં,

27
00:02:01,810 --> 00:02:07,480
બાદમાં સમસ્યા સમૂહો માટે, તો તમે તેને સબમિટ કરો, અને શકે છે આમ તો તમે ક્યાં તો વિભાગમાં આવી શકે

28
00:02:07,480 --> 00:02:10,380
અથવા વિભાગ જોવા માટે જવાબો મેળવવા માટે, અથવા તો તમે ફક્ત તેને તમારી પોતાની પર વિચાર કરી શકે છે

29
00:02:10,380 --> 00:02:16,350
જો તમે મારી હાજરી માણવા જેવું લાગે છે નથી.

30
00:02:16,350 --> 00:02:21,010
અત્યાર - મને લાગે છે કે આ પ્રથમ એક છે.

31
00:02:21,010 --> 00:02:29,280
ઓહ. પણ, પ્રશ્નો આ વિભાગો હેઠળ અમે પણ તમને શોર્ટ્સ વિશે પ્રશ્નો પૂછી છે.

32
00:02:29,280 --> 00:02:33,440
તેથી હું માનું છું, સિદ્ધાંતમાં, તમે કલમ આવતા પહેલા આ જોઈ માનવામાં કરી રહ્યાં છો,

33
00:02:33,440 --> 00:02:38,550
પરંતુ તે દંડ છે જો તમે ન કરતા; અમે તેમને પર કોઈપણ રીતે જવું પડશે.

34
00:02:38,550 --> 00:02:42,590
તેથી અમે આ સાથે શરૂ કરી શકો છો: "જ્યારે લૂપ ડુ-જ્યારે લૂપ કેવી રીતે અલગ પડે છે?

35
00:02:42,590 --> 00:02:46,210
બાદમાં જ્યારે એ ખાસ કરીને ઉપયોગી છે? "

36
00:02:46,210 --> 00:02:49,390
જેથી કોઇ પણ વ્યકિત કોઇ હોય -?

37
00:02:49,390 --> 00:02:52,730
[વિદ્યાર્થી] આ ડુ-જ્યારે લૂપ હંમેશા ઓછામાં ઓછું એક વાર ચલાવવા કરશે.

38
00:02:52,730 --> 00:03:02,950
હા. જેથી તફાવત છે. જ્યારે લૂપ - I'll માત્ર તેને અહીં પર શું - લૂપ, જ્યારે અમે આ પરિસ્થિતિ છે

39
00:03:02,950 --> 00:03:19,760
અહીં, જ્યારે ડુ-જ્યારે તમે એક શરત નથી ત્યાં સુધી અમે નીચે અહીં વિચાર નથી.

40
00:03:19,760 --> 00:03:24,130
અને તેથી, જ્યારે તમારું કાર્યક્રમ ચલાવી છે અને તે જ્યારે લૂપ મળે,

41
00:03:24,130 --> 00:03:26,380
તે તુરંત જ ચકાસે જો આ સ્થિતિ સાચું છે.

42
00:03:26,380 --> 00:03:30,710
જો કે પરિસ્થિતિ સાચું નથી, તે માત્ર પર લૂપ સંપૂર્ણપણે છોડી દો.

43
00:03:30,710 --> 00:03:34,390
શું-જ્યારે લૂપ, કારણ કે કાર્યક્રમ ચલાવવા છે, તે "નથી." નોંધાયો નહીં

44
00:03:34,390 --> 00:03:37,920
નથીંગ આ બિંદુએ થાય છે, માત્ર અમલ ચાલુ છે.

45
00:03:37,920 --> 00:03:42,690
પછી જ્યારે તેને ", જ્યારે" બનાવ્યા જો શરત સાચું છે, તો લૂપ બેકઅપ અને તેને ફરીથી કરીશ

46
00:03:42,690 --> 00:03:46,730
અને ફરીથી અને ફરીથી ત્યાં સુધી આ પરિસ્થિતિ સાચું છે અને પછી માત્ર મારફતે પડે નથી.

47
00:03:46,730 --> 00:03:50,600
તેથી તફાવત છે, કે જે આ અધિકાર ખૂબ શરૂઆતથી અવગણી શકો છો.

48
00:03:50,600 --> 00:03:56,770
આ જરુરી એકવાર ચલાવે છે અને પછી વધુ વાર ચલાવો જો સ્થિતિ હજુ પણ સાચું શકે છે.

49
00:03:56,770 --> 00:04:03,720
તેથી જ્યારે લૂપ માત્ર એક વખત તે શું કરશે, અથવા - જ્યારે લૂપ - અમે તેને બધી નથી જરૂર પડી શકે છે,

50
00:04:03,720 --> 00:04:07,900
જલદી અમે તેને મેળવવા થી, જો શરત ખોટી છે, અમે માત્ર તે પર અધિકાર અવગણો પડશે.

51
00:04:07,900 --> 00:04:11,770
જ્યારે આવું ત્યારે લૂપ, અમે એક વખત તે અમલ કરે છે, એવું જરૂરી રહેશે.

52
00:04:11,770 --> 00:04:14,560
ત્યાર બાદ, જ્યારે અમે આ પરિસ્થિતિ મેળવવા માટે, અમે તપાસ જો તે સાચું કે ખોટું છે.

53
00:04:14,560 --> 00:04:19,790
જો તે સાચું છે, તો અમે તેને ફરીથી કરીશ; જો તે ખોટા છે, અમે માત્ર જઈને કરવાનું ચાલુ રાખીશું.

54
00:04:19,790 --> 00:04:24,680
તેથી જ્યારે બાદમાં છે એ ખાસ કરીને ઉપયોગી?

55
00:04:24,680 --> 00:04:31,190
તેથી હું 4 વર્ષ પૂર્ણ, 3 વર્ષ, ગમે તે કહે કરી શકો છો,

56
00:04:31,190 --> 00:04:38,780
કે હું પ્રોગ્રામિંગ થઈ, હું આ ઉપયોગ કર્યો છે, જેમ કે 10 વખત હેઠળ.

57
00:04:38,780 --> 00:04:43,140
અને કદાચ 5 તેમને CS50 છે ત્યારે અમે-જ્યારે આંટીઓ રજૂઆત કરી રહ્યાં છે.

58
00:04:43,140 --> 00:04:47,510
તેથી જ્યારે તમે આમ કરો ત્યારે આંટીઓ ઉપયોગ કરી શકું?

59
00:04:47,510 --> 00:04:49,510
હા - એ ક્યારે છે

60
00:04:49,510 --> 00:04:53,180
[વિદ્યાર્થી] જ્યારે તમે વપરાશકર્તા ઈનપુટ કરવા માટે, અથવા કંઈક તમે ચકાસવા માંગો છો વિચાર કરવાનો પ્રયાસ કરી રહ્યા છીએ -

61
00:04:53,180 --> 00:04:59,700
યાહ. આવું ત્યારે આંટીઓ, ઇનપુટ વપરાશકર્તા મોટી છે.

62
00:04:59,700 --> 00:05:03,160
જે પ્રથમ દંપતી સમસ્યા સેટ પર શા માટે છે, જ્યારે તમે વપરાશકર્તા પૂછો, પસંદ કરવા માંગો છો,

63
00:05:03,160 --> 00:05:08,520
"મને એક શબ્દમાળા આપો," તમે જ્યાં સુધી તમે કે જેઓ શબ્દમાળા વિચાર નથી ચાલુ રાખી શકો છો.

64
00:05:08,520 --> 00:05:12,980
અને તેથી તમે, જરૂરી છે, શબ્દમાળા માટે ઓછામાં ઓછી એક વાર પૂછી જરૂર છે.

65
00:05:12,980 --> 00:05:16,950
પરંતુ પછી જો તેઓ કંઈ ખરાબ જવાબ, પછી તમે લૂપ પાછા જરૂર છે અને ફરીથી પૂછો.

66
00:05:16,950 --> 00:05:20,810
પરંતુ વપરાશકર્તા ઈનપુટ કરતાં અન્ય, તે ખૂબ જ દુર્લભ છે કે હું કેસ અનુભવી

67
00:05:20,810 --> 00:05:27,170
જ્યાં હું લૂપ માટે "ઓછામાં ઓછું એક વાર" કરવા માંગો છો પરંતુ કદાચ વધુ.

68
00:05:27,170 --> 00:05:33,370
પ્રશ્નો અથવા -? છે કોઇ ડુ-જ્યારે લૂપ ક્યાંય ઉપયોગ થયો નથી?

69
00:05:33,370 --> 00:05:36,780
ઠીક છે. જેથી આગામી એક છે, "શું ઓળખકર્તા અઘોષિત નથી

70
00:05:36,780 --> 00:05:43,310
સામાન્ય રીતે જો રણકાર દ્વારા outputted સૂચવે છે? "

71
00:05:43,310 --> 00:05:47,380
તેથી શું પ્રકારની કોડ માટે હું વિચાર લખી શકે છે 'બિનજાહેર ઓળખકર્તા?'

72
00:05:47,380 --> 00:05:49,550
[વિદ્યાર્થી] તે x 2 =?

73
00:05:49,550 --> 00:05:52,650
તેથી અમે તેને અહીં પ્રયત્ન કરી શકો છો, x 2 =.

74
00:05:52,650 --> 00:06:04,830
અમે આ સ્કોર કરીશું - ઓહ, હું તેને ક્લિક ન કરો નહોતો. તમામ હક છે - તેથી અહીં અમે મેળવો.

75
00:06:04,830 --> 00:06:07,100
"બિનજાહેર ઓળખકર્તા x ની વાપરો."

76
00:06:07,100 --> 00:06:11,610
જેથી બિનજાહેર ઓળખકર્તા, એક ચલ છે.

77
00:06:11,610 --> 00:06:13,910
તે વારંવાર એક ચલ એક ઓળખકર્તા કૉલ કરશે.

78
00:06:13,910 --> 00:06:17,300
તેથી તે જાણીએ છીએ કે તે ખરેખર એક ચલ નથી શકે છે; તે ખબર નથી તે શું છે.

79
00:06:17,300 --> 00:06:19,380
તેથી તે ઓળખકર્તા છે.

80
00:06:19,380 --> 00:06:26,060
શા માટે તેથી તે અઘોષિત છે? યાહ.

81
00:06:26,060 --> 00:06:32,190
તેથી શબ્દાવલિ ચલની ઘોષણા પર સ્પષ્ટ થઈ

82
00:06:32,190 --> 00:06:37,360
છે જ્યારે તમે "પૂર્ણાંક એક્સ," અથવા "શબ્દમાળા વાય," ગમે તે કહો.

83
00:06:37,360 --> 00:06:41,910
આ ચલ ઓફ આરંભ, અથવા ચલની સોંપણી,

84
00:06:41,910 --> 00:06:44,510
જ્યારે પણ તમે કહી "x = 2 છે."

85
00:06:44,510 --> 00:06:52,950
તેથી અમે અલગ પગલાં આ કરી શકો છો, પૂર્ણાંક X, X = 2, અને ત્યાં સુધી - અમે અહીં સામગ્રી સમૂહ કરી શકો છો -

86
00:06:52,950 --> 00:07:00,350
પરંતુ ત્યાં સુધી આ રેખા થાય છે, એક્સ હજી પણ uninitialized છે પરંતુ તે જાહેર કરવામાં આવ્યું છે.

87
00:07:00,350 --> 00:07:06,760
અને તેથી અમે ચોક્કસપણે તેને 1 લીટી માં કરી શકો છો, અને હવે અમે જાહેર છે અને પ્રારંભ.

88
00:07:06,760 --> 00:07:10,730
પ્રશ્નો?

89
00:07:10,730 --> 00:07:18,390
અને છેલ્લે, "સીઝર સાઈફર કેમ છે ખૂબ જ સુરક્ષિત નથી?"

90
00:07:18,390 --> 00:07:23,830
પ્રથમ તેથી, કોઈને પણ કહે છે કે સીઝર સાઈફર શું છે કરવા માંગો છો કરે છે?

91
00:07:23,830 --> 00:07:28,100
[વિદ્યાર્થી] સીઝર સાઈફર માત્ર એ છે કે તમે મેપ, તમે દરેક અક્ષર પાળી,

92
00:07:28,100 --> 00:07:34,420
અક્ષરો ચોક્કસ નંબર ઉપર જાય છે, અને પાછા ખસેડવા માટે, અને તે ખૂબ જ સુરક્ષિત નથી કારણ કે

93
00:07:34,420 --> 00:07:42,260
ત્યાં માત્ર 26 શક્ય વિકલ્પો છે અને તમે માત્ર તે 1 દરેક પ્રયાસ છે જ્યાં સુધી તમે તેને મળે છે.

94
00:07:42,260 --> 00:07:45,470
ઓહ. તેથી, હું પુનરાવર્તન કરવું જોઈએ?

95
00:07:45,470 --> 00:07:51,600
આ સીઝર સાઈફર, it's - હું તેનો અર્થ, તમે કે જે તમને સમસ્યા પર તેની સાથે વ્યવહાર કરવામાં આવશે -

96
00:07:51,600 --> 00:07:56,110
અથવા હું સમસ્યા સમૂહ કે હેકર આવૃત્તિ પર નથી પ્રમાણભૂત આવૃત્તિ ધારી.

97
00:07:56,110 --> 00:08:01,550
જેથી સમસ્યા સમૂહ પ્રમાણભૂત આવૃત્તિ પર, તમે જેમ, સંદેશ વિચાર "વિશ્વ હેલો,"

98
00:08:01,550 --> 00:08:08,410
અને તમે પણ 6 જેવા અનેક હોય છે, અને તમે તે સંદેશ લેવા અને દરેક વ્યક્તિગત પાત્ર,

99
00:08:08,410 --> 00:08:11,310
તમે તેને મૂળાક્ષરમાં 6 જગ્યાઓ ફેરવવા.

100
00:08:11,310 --> 00:08:16,560
જેથી 'h', 'હેલો માં-h-i જ-k-l-મીટર-n બની જશે.

101
00:08:16,560 --> 00:08:19,600
જેથી પ્રથમ અક્ષર n હશે. અમે ઈ સાથે જ વાત કરે છે.

102
00:08:19,600 --> 00:08:23,530
જો આપણે એક છે, પસંદ, z અથવા કંઈક, પછી અમે પાછા ફરતે વીંટળાય છે ત્યારે 'એક.'

103
00:08:23,530 --> 00:08:29,280
પરંતુ દરેક અક્ષર જગ્યા 6 અક્ષરો પાછળથી મૂળાક્ષરમાં, નહીં અને તે ખૂબ જ સુરક્ષિત નથી

104
00:08:29,280 --> 00:08:35,440
કારણ કે કેટલા રીતે તમે એક પત્ર લપેટી શકે માત્ર 26 શક્યતાઓ છે.

105
00:08:35,440 --> 00:08:42,919
જેથી તમે માત્ર તેમને 26 તમામ પ્રયાસ કરી શકો છો અને, કદાચ એક પર્યાપ્ત લાંબા સમય સુધી સંદેશા માટે,

106
00:08:42,919 --> 00:08:46,860
માત્ર તે શક્ય 26 વસ્તુઓ 1 થી વંચાય પ્રયત્ન રહ્યું છે,

107
00:08:46,860 --> 00:08:50,300
અને વંચાય એવા એક મૂળ સંદેશો પ્રયત્ન રહ્યું છે.

108
00:08:50,300 --> 00:08:56,240
તેથી તે કંઇ બધા એનક્રિપ્ટ એક ખૂબ જ સારો માર્ગ નથી.

109
00:08:56,240 --> 00:08:59,070
, તે શોર્ટ્સ સાથે સંબંધિત નથી "શું કરે છે?"

110
00:08:59,070 --> 00:09:03,370
તેથી કાર્ય શું છે? હા.

111
00:09:03,370 --> 00:09:11,640
[વિદ્યાર્થી] તે કોડ અલગ ભાગ કે જે તમે મારફતે જાઓ અને પછી ગમે પરત કિંમત વિચાર કહી શકો છો જેવું છે.

112
00:09:11,640 --> 00:09:18,160
યાહ. પણ માત્ર આગામી એક જવાબ આપીને અથવા વારંવાર - તેથી હું તે આગામી જવાબ દ્વારા જવાબ પડશે.

113
00:09:18,160 --> 00:09:22,410
તમે વિધેયો ની જગ્યાએ વાપરવું માત્ર નકલ અને પેસ્ટ કરી શકો છો કોડ ઓવર એન્ડ ઓવર અગેઇન.

114
00:09:22,410 --> 00:09:27,200
જસ્ટ કે કોડ લે છે, તે fuction મૂકવામાં, અને પછી તમે ફક્ત કાર્ય કહી શકે છે

115
00:09:27,200 --> 00:09:29,870
તમારી પાસે ગમે ત્યાં નકલ કરવામાં આવી અને પેસ્ટ.

116
00:09:29,870 --> 00:09:33,350
તેથી કાર્યો ઉપયોગી છે.

117
00:09:33,350 --> 00:09:35,860
તેથી હવે અમે વાસ્તવિક સમસ્યાઓ કરવું પડશે.

118
00:09:35,860 --> 00:09:46,490
પ્રથમ એક. જેથી પ્રથમ એક વિચાર છે, તો તમે તેને શબ્દમાળા પસાર કરવા માટે, અને અનુલક્ષીને -

119
00:09:46,490 --> 00:09:52,060
અથવા તે બધા લોઅરકેસ કહેવું છે? તે બધા લોઅરકેસ નથી કહેવું નથી.

120
00:09:52,060 --> 00:09:57,730
જેથી સંદેશો કંઈપણ હોઈ શકે છે, અને - ઓહ નં. તે કરે છે.

121
00:09:57,730 --> 00:10:01,610
"સરળતા માટે, તમે કે વપરાશકર્તા માત્ર કરશે લોઅરકેસ અક્ષરો અને જગ્યાઓ ઇનપુટ. ધારે શકે છે"

122
00:10:01,610 --> 00:10:08,180
કે જેથી અમે તેને માત્ર નાના અક્ષરો સાથે સંદેશ પસાર અને પછી અમે એકના

123
00:10:08,180 --> 00:10:15,450
મૂડી અને લોઅરકેસ વચ્ચે - અમે શબ્દમાળા મૂડી અને લોઅરકેસ માટે, વૈકલ્પિક બદલો.

124
00:10:15,450 --> 00:10:22,920
તેથી પહેલાં તો અમે તમને એક પણ સમસ્યા ડાઇવ બીજા આપવા માટે,

125
00:10:22,920 --> 00:10:32,420
પ્રથમ વસ્તુ કે અમે જરૂર શું છે?

126
00:10:32,420 --> 00:10:36,900
ઓહ, હું શું માત્ર નહોતો પર ક્લિક કરો? ઓહ, હું હમણાં જ અહીં ઇમેઇલ પર ક્લિક કર્યું છે.

127
00:10:36,900 --> 00:10:42,870
જેથી પ્રથમ વસ્તુ અમે જરૂર - હું ખોટું એક જોઈ રહ્યો છું?

128
00:10:42,870 --> 00:10:49,320
આ એક ભાગ છે?

129
00:10:49,320 --> 00:10:51,320
ના, તે ત્યાં હજુ પણ છતાં છે.

130
00:10:51,320 --> 00:10:55,160
ઠીક છે, હજુ પણ અહીં છે.

131
00:10:55,160 --> 00:11:03,160
- હવે અમે નથી ધારણ કરી શકે છે? હા. અહીં અમે નથી ધારણ કરી શકે છે કે તે માત્ર નાના અને જગ્યાઓ છે.

132
00:11:03,160 --> 00:11:07,770
તેથી હવે અમે એ હકીકત છે કે જે અક્ષરો હોઈ શકે છે ગમે અમે તેમને પ્રયત્ન કરવા માંગો છો સાથે કામ હોય છે.

133
00:11:07,770 --> 00:11:11,910
અને તેથી પ્રથમ વસ્તુ અમે કરવા માંગો છો ફક્ત સંદેશો વિચાર છે.

134
00:11:11,910 --> 00:11:19,790
અમે હમણાં જ એક શબ્દમાળા જરૂર હોય, શબ્દમાળા ઓ = GetString, ઠીક છે.

135
00:11:19,790 --> 00:11:24,890
હવે આ સમસ્યા છે, ત્યાં આમ માર્ગો એક દંપતી છે.

136
00:11:24,890 --> 00:11:29,840
પરંતુ અમે માટે bitwise ઓપરેટરો અહીં ઉપયોગ કરવા માંગો છો જવું છે.

137
00:11:29,840 --> 00:11:35,280
ત્યાં છે લોકો ક્યાં તો supersection ન હતા,

138
00:11:35,280 --> 00:11:37,480
અથવા કંઈક જાણે છે, અને ન bitwise ઓપરેટરો શું છે?

139
00:11:37,480 --> 00:11:41,710
અથવા તેઓ કેવી રીતે કોઈપણ રીતે તે ASCII સંબંધિત?

140
00:11:41,710 --> 00:11:45,650
[વિદ્યાર્થી] હું supersection અંતે ન હતી, પરંતુ હું જાણું છું bitwise ઓપરેટરો શું છે.

141
00:11:45,650 --> 00:11:49,560
ઠીક છે. તેથી પછી હું તેમને મૂળભૂત પર જાઓ નથી, પરંતુ હું સમજાવવું પડશે

142
00:11:49,560 --> 00:11:51,830
અમે શું કરીએ અહીં ઉપયોગ કરવા માંગો છો જઈ રહ્યાં છો.

143
00:11:51,830 --> 00:11:59,680
તેથી 'એ': એક મૂડી દ્વિસંગી રજૂઆત સંખ્યા 65 છે.

144
00:11:59,680 --> 00:12:07,560
હું માત્ર જોવા જાઉં છું - 41 માટે 01000001 પ્રયત્ન રહ્યું છે.

145
00:12:07,560 --> 00:12:14,170
જેથી 65 રેખાંશ હોવો જોઈએ; તેથી આ પાત્ર મૂડી એ નું બાઈનરી રજૂઆત છે

146
00:12:14,170 --> 00:12:19,440
હવે, અક્ષર નું બાઈનરી રજૂઆત 'એ' લોઅરકેસ

147
00:12:19,440 --> 00:12:33,350
છે એ જ વાત હોય, લગભગ જઈ રહી છે. કે છે - 6, હા. આ અધિકાર છે.

148
00:12:33,350 --> 00:12:37,670
તેથી દ્વિસંગી મૂડી એ, દ્વિસંગી લોઅરકેસ 'એક.'

149
00:12:37,670 --> 00:12:43,940
તેથી નોંધ્યું છે કે એ અને 'એ' આ એક બીટ છે. વચ્ચે તફાવત

150
00:12:43,940 --> 00:12:49,440
અને આ 32 બીટ, જે 32 નંબર રજૂ બીટ બને છે.

151
00:12:49,440 --> 00:12:53,910
અને તે અર્થમાં બનાવે છે કારણ કે એ 65 છે; 'એ' 97 છે.

152
00:12:53,910 --> 00:12:56,610
તેમની વચ્ચે તફાવત 32 છે.

153
00:12:56,610 --> 00:13:03,770
તેથી હવે અમે જાણીએ છીએ કે અમે એ માટે 'એ' ના એક લેતી દ્વારા રૂપાંતરિત કરી શકો છો

154
00:13:03,770 --> 00:13:09,710
અને bitwise તે ORing સાથે - કે જે 1 જેમ દેખાય છે.

155
00:13:09,710 --> 00:13:20,900
આ એક bitwise અથવા 00100000 છે, અને તે અમને આપીશું 'એક.'

156
00:13:20,900 --> 00:13:26,850
અને અમે 'એ' થી bitwise ANDing દ્વારા મેળવી શકો છો

157
00:13:26,850 --> 00:13:33,700
11, કે સ્થળ, 11111 માં 0 સાથે.

158
00:13:33,700 --> 00:13:43,840
તેથી આ પછી અમને આપો ચોકકસ શું 'એ' હતું નહીં; પરંતુ આ વ્યક્તિગત બીટ રદ કરવા માટે,

159
00:13:43,840 --> 00:13:50,070
તેથી અમે 01000001 પડશે; હું જો હું યોગ્ય ગણાશે જાણતા નથી.

160
00:13:50,070 --> 00:13:56,750
પરંતુ bitwise ORing આ ટેકનિક મૂડી મેળવી કરવા માટે લોઅરકેસ,

161
00:13:56,750 --> 00:14:02,080
અને bitwise માટે લોઅરકેસ મૂડી મેળવવા ANDing એ માટે અનન્ય નથી

162
00:14:02,080 --> 00:14:06,510
અક્ષરો તમામ વિ k કે, Z વિ z,

163
00:14:06,510 --> 00:14:10,080
તે બધા માત્ર આ એક બીટ દ્વારા અલગ પડે જતાં હોય છે.

164
00:14:10,080 --> 00:14:16,290
અને તેથી તમે આ ઉપયોગ કોઈપણ લોઅરકેસ પત્ર માંથી કોઇપણ મૂડી પત્ર અને ઊલટું બદલી શકો છો.

165
00:14:16,290 --> 00:14:26,670
ઠીક છે. તેથી આ મેળવવાની એક સરળ રસ્તો છે - તેથી બદલે કર્યા

166
00:14:26,670 --> 00:14:32,170
બહાર લખી 1011111 ગમે છે - આ નંબર રજૂ એક સરળ રસ્તો છે, અને આ એક નથી

167
00:14:32,170 --> 00:14:39,710
કે હું supersection માં ઉપર ગયા, પરંતુ ઝૂલતો ડેશ (~) અન્ય bitwise ઓપરેટર છે.

168
00:14:39,710 --> 00:14:42,520
કરે ~ શું છે તે બીટ પ્રતિનિધિત્વ અંતે જુએ છે.

169
00:14:42,520 --> 00:14:45,630
ચાલો કોઈપણ નંબર લે છે.

170
00:14:45,630 --> 00:14:53,130
આ માત્ર કેટલાક બાયનરી નંબર છે, અને શું ~ છે એ નથી કે તે માત્ર બિટ્સ તમામ flips.

171
00:14:53,130 --> 00:15:00,630
તેથી આ એક 1 હતી, હવે 0, આ 0 છે, હવે 1 એક, 010100.

172
00:15:00,630 --> 00:15:08,320
તેથી કે તમામ ~ કરે છે. કે છૂટકારો મેળવવા - તો 32 માટે નંબર રહ્યું છે -

173
00:15:08,320 --> 00:15:23,320
જેથી 32 માટે 00100000 નંબર રહ્યું છે, અને તેથી આ ~ થઇ રહ્યું છે

174
00:15:23,320 --> 00:15:29,980
આ અહીં નંબર કે હું સાથે 'એ' ANDed.

175
00:15:29,980 --> 00:15:35,600
નથી દરેકને કે જુઓ છો? આ એક ખૂબ સુંદર સામાન્ય જ્યારે તમે બહાર આકૃતિ માંગો છો, જેમ છે

176
00:15:35,600 --> 00:15:40,740
પાછળથી વસ્તુઓ છે કે જે અમે, જોયા હોઈ શકે છે જ્યારે અમે જો જોવા માંગો છો માટે -

177
00:15:40,740 --> 00:15:44,710
અથવા આપણે 1 સિવાય બધું, દરેક એક બીટ સેટ કરવા માંગો છો

178
00:15:44,710 --> 00:15:47,910
તમે બીટ કે અમે સેટ જોઈતો નથી ઓફ ~ નથી કરતા હોય છે.

179
00:15:47,910 --> 00:15:53,090
તેથી અમે 32 બીટ સેટ નથી માંગતા તેથી, અમે 32 ના ~ નથી.

180
00:15:53,090 --> 00:15:57,790
ઠીક છે. તેથી અમે તે બધી અહીં ઉપયોગ કરી શકો છો.

181
00:15:57,790 --> 00:16:03,000
બધા હક છે, તેથી તેને દંડ જો તમે ન થઈ જાવ, ત્યારે અમે ધીમે ધીમે ઉપર એકસાથે ચાલવા રહેશે,

182
00:16:03,000 --> 00:16:11,870
અથવા આ પર ચાલવું, તેથી - આ મારફતે. આ લઈ જવામાં.

183
00:16:11,870 --> 00:16:20,790
જેથી અમે અમારા શબ્દમાળા ધરાવે છે, અને અમે તે શબ્દમાળા દરેક અક્ષર પર લૂપ કરવા માંગો છો અને શું કરવું તે કંઈક.

184
00:16:20,790 --> 00:16:26,710
તેથી અમે કેવી રીતે શબ્દમાળા પર લૂપ છે? અમે શું ઉપયોગ કરવો જોઇએ?

185
00:16:26,710 --> 00:16:30,980
હું તે કરી અહીં નથી માંગવાનો. યાહ.

186
00:16:30,980 --> 00:16:42,940
જેથી હું મારા iterator હોય છે, અને તે તેમણે જણાવ્યું હતું કે, પણ હું કેવી રીતે જાણી શકું કેટલા અક્ષરો શબ્દમાળા છે?

187
00:16:42,940 --> 00:16:47,030
Strlen (ઓ), પછી હું + +.

188
00:16:47,030 --> 00:16:49,860
તેથી હું અહીં કર્યું છે શું વસ્તુઓ કરવાનું શ્રેષ્ઠ રસ્તો નથી.

189
00:16:49,860 --> 00:16:51,860
શું કોઇને ખબર શા માટે?

190
00:16:51,860 --> 00:16:55,290
કારણ કે તમે શબ્દમાળા દરેક એક સમય ભાષા ચકાસણી કરી રહ્યા છીએ.

191
00:16:55,290 --> 00:17:06,859
તેથી અમે માટે strlen ખસેડવા માંગો છો જવું છે, હું અહીં કહેવું શકે છે, પૂર્ણાંક લંબાઈ strlen = (ઓ),

192
00:17:06,859 --> 00:17:11,900
અને પછી હું લંબાઈ <નથી, અને કદાચ તમને તે પહેલા જોઇ તે નથી,

193
00:17:11,900 --> 00:17:20,410
હું પણ પૂર્ણાંક હું = 0 લંબાઈ, strlen = (ઓ). કરી શકે

194
00:17:20,410 --> 00:17:25,010
અને તેથી આ કંઈક બહેતર છે, હવે ત્યારથી હું અવકાશ પ્રતિબંધિત કરી છે

195
00:17:25,010 --> 00:17:29,150
આ ચલ લંબાઈ ફક્ત લૂપ 'માટે' આ બદલે, તે પહેલાં તેને જાહેર

196
00:17:29,150 --> 00:17:34,990
અને તે હંમેશા હાજર હોય, અને કદાચ તમને શા માટે છે કે ખરાબ નથી પકડી નહોતી,

197
00:17:34,990 --> 00:17:39,410
અથવા મૂળ ખરાબ, it's શા માટે હતી - લૂપ માટે શરૂ થાય છે.

198
00:17:39,410 --> 00:17:43,380
હું શરત ચકાસાયેલ. છે મને ઓ લંબાઈ <?

199
00:17:43,380 --> 00:17:46,790
તેથી ઓ લંબાઈ, ચાલો સાથે "હેલો" સમગ્ર સમય કામ કરે છે.

200
00:17:46,790 --> 00:17:49,670
ઓ જેથી લંબાઈ,-h ઈ-l-l-o. લંબાઈ 5 છે.

201
00:17:49,670 --> 00:17:57,580
તેથી હું = 0 લંબાઈ, 5 છે, તેથી હું 5 <ન હોવાથી, લૂપ ચાલુ રહે છે.

202
00:17:57,580 --> 00:18:02,750
તો પછી અમે ફરી જાઓ. અમે સ્થિતિ તપાસો. છે મને હેલો લંબાઈ <?

203
00:18:02,750 --> 00:18:08,390
તેથી આપણે હેલ્લો લંબાઈ તપાસો. H-ઈ-l-l-o. જે 5 છે; i 5 <નથી, તેથી અમે ફરીથી ચાલુ રાખો.

204
00:18:08,390 --> 00:18:13,330
તેથી અમે ગણતરી કરવામાં આવે છે, અમે હેલ્લો ગણતરી કરવામાં આવે છે લૂપ દરેક ઇટરેશન માટે,

205
00:18:13,330 --> 00:18:17,380
પણ એવું બદલવા માટે ક્યારેય ચાલી રહ્યું છે; તે હંમેશા માટે 5 જ હશે.

206
00:18:17,380 --> 00:18:22,530
તેથી અમે ફક્ત ફ્રન્ટ અપ 5 યાદ રાખો, અને હવે બધું સારું.

207
00:18:22,530 --> 00:18:24,990
જેથી સમગ્ર શબ્દમાળા પર વારો.

208
00:18:24,990 --> 00:18:31,470
માટે અમે શું શબ્દમાળા દરેક અક્ષર માટે શું કરવા માંગો છો?

209
00:18:31,470 --> 00:18:38,510
[વિદ્યાર્થી બોલવા, દુર્બોધ]

210
00:18:38,510 --> 00:18:47,000
યાહ. તેથી, જો અક્ષર બિન આલ્ફાબેટીક છે, તો પછી અમે માત્ર તે ઉપર છોડી દેવા માગો છો.

211
00:18:47,000 --> 00:18:52,300
કારણ કે અમે માત્ર આલ્ફાબેટીક અક્ષરો વિશે કાળજી; અમે નંબર ન લખવા કરી શકો છો.

212
00:18:52,300 --> 00:19:10,850
તેથી અમે કેવી રીતે કરી શકો છો? અમારી સ્થિતિ તેથી, તેથી જો આપણે કંઈક કરવા માંગો છો - તપાસ જો તે મૂળાક્ષર છે.

213
00:19:10,850 --> 00:19:14,060
કેવી રીતે અમે આ તપાસ કરી શકું?

214
00:19:14,060 --> 00:19:18,720
[વિદ્યાર્થી] તમે ફક્ત વિધેય વાપરી શકે છે આલ્ફા છે.

215
00:19:18,720 --> 00:19:23,160
છે કે આ ક્યાં, અથવા કોઇ પણ સમાવેશ થાય છે જેમ char.h, અથવા કંઈક સમાવેશ થાય છે?

216
00:19:23,160 --> 00:19:32,710
તેથી અમે [i] ઓ હોય છે, - ચાલો આલ્ફા કાર્ય છે, અને સ્પષ્ટ ઉપયોગ ન ઉપયોગ

217
00:19:32,710 --> 00:19:40,460
કે ઓ ના આઠમા અક્ષર છે તો યાદ રાખો કે એક શબ્દમાળા અક્ષરો ઝાકઝમાળ છે,

218
00:19:40,460 --> 00:19:43,180
s ની આઠમી પાત્ર રહે છે.

219
00:19:43,180 --> 00:19:49,280
હવે, જો તે મૂડી પત્ર છે, અમે જાણીએ છીએ કે તે એક ચોક્કસ શ્રેણી હોવી જોઇએ.

220
00:19:49,280 --> 00:19:54,370
અને તે શ્રેણી શું છે?

221
00:19:54,370 --> 00:20:07,860
યાહ. તેથી જો ઓ [i] 65 ≥, અને ઓ છે [i] 90 ≤ છે, હું શું તેના બદલે શું કરવું જોઈએ?

222
00:20:07,860 --> 00:20:18,470
યાહ. તેથી તમે ચોક્કસપૂર્વક માટે ક્યારેક પણ ના ASCII કિંમતો ખબર પણ ક્યારેય જરૂર કરીશું.

223
00:20:18,470 --> 00:20:25,640
લાગે છે ક્યારેય 65 નંબરો, 90, 97 અને 102, અથવા તે ગમે છે.

224
00:20:25,640 --> 00:20:32,470
112 - - તમે જરૂર નથી? તમે બધા અંતે તે જાણવું જરૂરી નથી. કે ખોટું પણ છે.

225
00:20:32,470 --> 00:20:41,940
માત્ર એક જ ક્વોટ અક્ષરો, એક ક્વોટ સ્થિરાંકો વાપરો. તેથી 'એ' અને 90 કરતાં ઓછી 'ઝેડ' છે

226
00:20:41,940 --> 00:20:47,930
અને આ નોંધપાત્ર સારું છે - હું બોલ મારા માથા ઉપરની કે Z 90 નથી જાણી શકશે.

227
00:20:47,930 --> 00:20:52,690
હું બોલ મારા માથા ઉપરની કે 'Z' મૂડી ઝેડ છે ખબર નથી

228
00:20:52,690 --> 00:21:02,100
તેથી લાંબા તરીકે આ મૂડી એ મૂડી Z, અમે અથવા શ્રેણી છે લોઅરકેસ માટે ચકાસણી કરી શકો છો,

229
00:21:02,100 --> 00:21:17,010
અથવા જો તે શ્રેણીમાં છે ≥ 'એ' અને ≤ z.

230
00:21:17,010 --> 00:21:19,010
જેથી અમારી શરત છે.

231
00:21:19,010 --> 00:21:22,520
જ્યાં આ વસ્તુઓ મૂકી કરવા માટે શૈલી બદલાય છે.

232
00:21:22,520 --> 00:21:29,520
હું આ જેવા કરવું પડશે.

233
00:21:29,520 --> 00:21:31,520
હવે, અમે શું કરવા માંગો છો?

234
00:21:31,520 --> 00:21:39,530
અમે જાણીએ છીએ કે આ પત્ર એક અક્ષર છે, એક મૂળાક્ષર અક્ષર.

235
00:21:39,530 --> 00:21:46,270
તેથી અમે શું આ હવે મૂડી પત્ર અથવા લોઅરકેસ પત્ર પ્રયત્ન કરીશું વચ્ચે આવનજાવન કરવાની જરૂર છે.

236
00:21:46,270 --> 00:21:48,820
અમે ટ્રેક એક છે જે આપણે તેને કેવી રીતે કરવા માંગો છો રાખવા છે?

237
00:21:48,820 --> 00:21:55,520
[વિદ્યાર્થી અવાજો, દુર્બોધ]

238
00:21:55,520 --> 00:21:59,150
તેથી હા દો, પરંતુ મને તપાસો.

239
00:21:59,150 --> 00:22:04,910
0-2 મોડ્યુલ કહ્યું હતું, તો બહાર ફેંકી સૂચન હતું, અને હું સાથે સંમત છો.

240
00:22:04,910 --> 00:22:11,780
સૂચના સિવાય કે, જેમ - આ કેસ છે? યાહ.

241
00:22:11,780 --> 00:22:18,270
તે દરેક અન્ય એક છે, પરંતુ અમને i ની 2 મોડ્યુલ કરી શકો છો, અથવા i 2 મોડ, કારણ

242
00:22:18,270 --> 00:22:22,950
નોંધ્યું છે કે ઇ રાજધાની છે અને 'એ' લોઅરકેસ છે? પરંતુ તેમને અલગ જગ્યા છે?

243
00:22:22,950 --> 00:22:27,150
તેથી તેઓ એ જ 2 મોડ પ્રયત્ન જઈ રહ્યાં છો, પરંતુ તેઓ અલગ કિસ્સાઓમાં છો.

244
00:22:27,150 --> 00:22:29,150
[વિદ્યાર્થી પ્રશ્ન, દુર્બોધ]

245
00:22:29,150 --> 00:22:34,690
યાહ. તેથી અમે માત્ર એક ગણતરી રાખી રહ્યા છીએ.

246
00:22:34,690 --> 00:22:38,730
અમે પણ અહીં કે કરી શકે જો આપણે ઇચ્છતા; કે થોડો અતિભારે વિચાર કરી શકે છે

247
00:22:38,730 --> 00:22:41,300
લૂપ જાહેરાતો માટે છે; હું તેને મૂકવા અહીં પડશે.

248
00:22:41,300 --> 00:22:48,840
તેથી પૂર્ણાંક ગણતરી = 0 અંતે શરૂ થાય છે.

249
00:22:48,840 --> 00:22:54,070
અને તેથી હવે, હું ગણતરી કેટલા મૂળાક્ષર અક્ષરો અમે પડ્યું જાઉં છું.

250
00:22:54,070 --> 00:22:59,550
તેથી અમે અનાવશ્યક ગણતરી + + થી આપણે બીજું મૂળાક્ષર અક્ષર મળી રહ્યા છીએ.

251
00:22:59,550 --> 00:23:09,130
પરંતુ, તેથી હવે તમે જો ગણતરી 2 મોડ કહી રહ્યાં છે.

252
00:23:09,130 --> 00:23:12,590
તેથી શું ગણતરી 2 મોડ જો? ઓહ. હું હવે માટે 0 == કરવું પડશે.

253
00:23:12,590 --> 00:23:21,740
અમે પણ તપાસવું કે પડશે. તેથી ગણતરી 2 મોડ 0 == જો, પછી શું?

254
00:23:21,740 --> 00:23:27,830
[જવાબ વિદ્યાર્થીઓ, દુર્બોધ]

255
00:23:27,830 --> 00:23:32,750
તેથી અમે તે મોટા અંત કરવા માંગો છો.

256
00:23:32,750 --> 00:23:37,520
ત્યાં 2 કિસ્સાઓમાં છે; મોટા અને નાના એ 2 કેસો છે.

257
00:23:37,520 --> 00:23:40,990
તેથી જો આપણે નાના છો તો અમે તેને મોટા કરવાની જરૂર છે.

258
00:23:40,990 --> 00:23:43,710
જો તે મોટા અમે કંઈ પણ કરવા માટે જરૂર નથી.

259
00:23:43,710 --> 00:23:50,760
પરંતુ, ત્યાં એક રસ્તો છે - shouldn't ઘસવું છે -

260
00:23:50,760 --> 00:23:54,800
કે અમે પણ તપાસો કે તે અપરકેસ અથવા લોઅરકેસ નથી જરૂર છે?

261
00:23:54,800 --> 00:24:02,240
માટે અમે શું હંમેશા ખાતરી કરો કે આપણે હંમેશા મોટા અંતે અંત બનાવવા કરી શકો છો?

262
00:24:02,240 --> 00:24:07,830
તેથી નોટિસ આપણે શું લોઅરકેસ 'એ' માટે કર્યું; શું જો અમે આ જ ચોક્કસ વસ્તુ હતી એ મોટા?

263
00:24:07,830 --> 00:24:11,900
ફેરફારથી મોટા કરે છે, અથવા કિંમત ફેરફાર કરે છે?

264
00:24:11,900 --> 00:24:23,100
યાહ. તેથી કોઈપણ મૂડી પત્ર 32 ~ સાથે ANDed bitwise માટે તે જ મોટા અક્ષર હોવો રહ્યું છે

265
00:24:23,100 --> 00:24:29,220
કારણ કે કોઇ પણ મોટા અક્ષર માટે 32 મા બીટ સેટ નથી.

266
00:24:29,220 --> 00:24:40,920
તેથી જો આપણે પાત્ર ઓ [i], અમે તેને લોઅરકેસ અથવા મોટા બનવા માટે કરવા માંગો છો લાવવા માંગો છો.

267
00:24:40,920 --> 00:24:46,890
તેથી જો તે લોઅરકેસ હતું, તે હવે મોટા, જો તે મોટા હતું, તે હજુ મોટા, અને તે છે.

268
00:24:46,890 --> 00:24:54,290
હું supersection આ જણાવ્યું હતું કે: તમે 32 વાપરો જો તમે ઇચ્છો કરી શકો છો, પરંતુ હું 'એ' કરી પસંદ કરે છે - એ,

269
00:24:54,290 --> 00:25:01,150
માત્ર સાદા 32 બદલે, કારણ કે તે અન્ય કોઈપણ બિટ હોઈ શકે છે.

270
00:25:01,150 --> 00:25:03,610
આ 32 બીટ કર્યા પછી, તે આ કોઇ હોઇ શકે, અથવા અમારી પાસે પર્યાપ્ત નહિ

271
00:25:03,610 --> 00:25:05,840
આ અક્ષરો તમામ પ્રતિનિધિત્વ નંબરો.

272
00:25:05,840 --> 00:25:09,110
તેથી જો તમે 32 બીટ વિચાર, તે 64 બીટ હોઇ શકે છે, તે 128 બીટ હોઈ શકે છે.

273
00:25:09,110 --> 00:25:13,990
તે બિટ્સની કોઈપણ બિટ કે મોટા અને નાના વચ્ચે અલગ હોઈ શકે છે.

274
00:25:13,990 --> 00:25:18,350
હું જાણું છું કે તે 32 બીટ નથી કરવો જોઈએ.

275
00:25:18,350 --> 00:25:27,130
હું આ 'એ' નો ઉપયોગ કરી શકો છો - બિટ કે બે વચ્ચે અલગ પડે છે વિચાર

276
00:25:27,130 --> 00:25:33,000
આ જાદુ નંબર છે કે જે 32 છે પર આધાર રાખે જરૂર વગર.

277
00:25:33,000 --> 00:25:38,770
અને તેથી હવે, બીજું ગણતરી વિચિત્ર હતી, અને તેથી હું શું કરવા માંગો છો?

278
00:25:38,770 --> 00:25:43,920
[વિદ્યાર્થી જવાબો, દુર્બોધ]

279
00:25:43,920 --> 00:25:45,920
[વિદ્યાર્થી] કે શું છે?

280
00:25:45,920 --> 00:25:49,850
હું તેને 1 સેકન્ડમાં કરશે.

281
00:25:49,850 --> 00:25:55,690
તેથી હવે જો હું કરવા માંગો છો - હું ખાતરી કરવા માટે અક્ષર હવે નાના બનાવવા માંગો છો,

282
00:25:55,690 --> 00:26:04,140
અને તેથી હું અથવા 32 દ્વારા કરી શકો છો, અને 32 અર્થ 'એ' - એ

283
00:26:04,140 --> 00:26:06,510
પરંતુ પાછલા એક જેવી જ તર્ક દ્વારા નોટિસ કે, જો

284
00:26:06,510 --> 00:26:11,670
અક્ષર પહેલાથી જ લોઅરકેસ, પછી ORing 32 દ્વારા માત્ર રાખે તે લોઅરકેસ.

285
00:26:11,670 --> 00:26:16,220
તે મૂળ અક્ષર નથી બદલાઈ ગયેલ છે.

286
00:26:16,220 --> 00:26:19,910
પરંતુ હવે હું એ કહીને કે, "જો તે લોઅરકેસ છે, ફક્ત તે વિશે ભૂલી જાઓ ટાળવા નથી,

287
00:26:19,910 --> 00:26:23,650
જો તે મોટા છે, પછી તે બદલો. "

288
00:26:23,650 --> 00:26:26,900
તે વધુ અનુકૂળ આ કરવા માટે છે.

289
00:26:26,900 --> 00:26:33,190
[વિદ્યાર્થી] આ લોઅરકેસ વર્ક ના મોટા બાદબાકી જો તે 32 ન હતા કે વ્યૂહરચના વૂડ?

290
00:26:33,190 --> 00:26:35,330
જો તે, પસંદ, 34 અથવા કંઈક?

291
00:26:35,330 --> 00:26:41,840
તેથી, તમે જાણો છો કે આ 2 વચ્ચે તફાવત હોય છે જરૂર -? >> Bit 1.

292
00:26:41,840 --> 00:26:49,840
તેને 1 કરતાં વધુ બીટ હોઇ શકે છે, જ્યાં સુધી આ સ્થિતિ નીચે બિટ્સ તમામ સમાન છે શકે છે.

293
00:26:49,840 --> 00:26:58,500
તેથી અમે 26 ઓછામાં ઓછા અક્ષરો જરૂર છે - અથવા, ત્યાં 26 અક્ષરો છે.

294
00:26:58,500 --> 00:27:04,590
તેથી અમે 26 ઓછામાં ઓછા નંબરો જરૂર તફાવત પ્રતિનિધિત્વ -

295
00:27:04,590 --> 00:27:07,650
A અને 'એ' માટે 26 ઓછામાં ઓછા ધરાવે છે, વચ્ચે તફાવત

296
00:27:07,650 --> 00:27:10,760
અથવા અન્ય અમે તમામ મૂડી નંબરો ન રજૂ કરશે.

297
00:27:10,760 --> 00:27:18,630
એટલે કે એ, જો આપણે 1 શરૂ થાય છે, તે આ બિટ્સ ઉપયોગ કરો ચાલી રહ્યું છે,

298
00:27:18,630 --> 00:27:23,900
આ પહેલાં 5 બિટ્સ માટે ઝેડ મારફતે બધું પ્રતિનિધિત્વ તમામ

299
00:27:23,900 --> 00:27:32,170
જે આગામી શા માટે બીટ, અથવા આ બીટ છે, આગામી બીટ એ છે કે જે માટે અને વચ્ચે તફાવત પસંદ છે છે 'એક.'

300
00:27:32,170 --> 00:27:40,930
કે શા માટે પણ છે, તે ASCII કોષ્ટકમાં, ત્યાં 5 લોઅરકેસ અક્ષરો મૂડી અક્ષરો અલગ પ્રતીક છે.

301
00:27:40,930 --> 00:27:49,050
ત્યારથી તે સંકેતો, વધારાની 5 કે લાવે તો તેમને 32 વચ્ચે તફાવત રહેલા છે.

302
00:27:49,050 --> 00:27:51,840
[વિદ્યાર્થી] તેથી અમે તેને કરવા માટે, કારણ કે તે ASCII કે માર્ગ રચાયેલ છે શકે છે.

303
00:27:51,840 --> 00:27:57,280
હા. પરંતુ તે ASCII - તફાવત પણ આ બિટ્સ બંને હોઈ શકે છે.

304
00:27:57,280 --> 00:28:12,040
જેમ કે, જો એ 10000001 હતા, અને 'એ' 11100001 હતા - મને ભૂલી જાઓ, ગમે.

305
00:28:12,040 --> 00:28:18,100
એ - પરંતુ જો તે આ હતા, તો પછી અમે 'એ' હજી પણ ઉપયોગ કરી શકે છે

306
00:28:18,100 --> 00:28:22,650
તે માત્ર હવે એ અને 'એ' હજુ પણ આ 2 બીટ્સ વચ્ચે તફાવત છે.

307
00:28:22,650 --> 00:28:32,240
મને લાગે છે કે તે 48 લખાયેલો છે. તે 32 + 64? મને લાગે છે કે તે શું છે?

308
00:28:32,240 --> 00:28:40,160
દરેક એક અક્ષર, પસંદ, Z અને z કે, અને k; તે હજુ 2 બીટ્સ હશે

309
00:28:40,160 --> 00:28:45,160
તેઓ હજુ પણ એ જ ચોક્કસ તે 2 બીટ્સ સિવાય સેટ બિટ્સ હશે.

310
00:28:45,160 --> 00:28:48,870
તેથી લાંબા તે હંમેશા સાચું, અનુલક્ષીને જો આપણે તે ASCII અથવા અમુક અન્ય સિસ્ટમની મદદથી કરી રહ્યા છો,

311
00:28:48,870 --> 00:28:53,050
સુધી ત્યાં માત્ર બિટ્સ કે દરેક અક્ષર માટે અલગ છે સમૂહ નંબર છે,

312
00:28:53,050 --> 00:28:55,050
પછી તે દંડ કામ કરે છે.

313
00:28:55,050 --> 00:29:06,110
તે માત્ર છે કે 32 સેટ કરવામાં આવી હતી કારણ કે તે પ્રથમ એક અમે કદાચ તેનો ઉપયોગ કરી શકે છે. કૂલ. >>

314
00:29:06,110 --> 00:29:14,520
હું પ્રાધાન્ય આપો, તો કદાચ તમને જોઈ નથી, જો બ્લોક માત્ર એક જ વાક્ય છે છે છે,

315
00:29:14,520 --> 00:29:24,280
તમે સર્પાકાર કૌંસ છૂટકારો મેળવી શકે છે; તેથી હું આ કરી પસંદ કરે છે.

316
00:29:24,280 --> 00:29:34,010
પણ, તમને ખબર કેવી રીતે અમે ઓ [i] + = 1 જેવી વસ્તુઓ કરી શકો છો?

317
00:29:34,010 --> 00:29:41,090
તમે પણ ઓ [i] bitwise અને 32 =. કરી શકો છો

318
00:29:41,090 --> 00:29:46,400
અને bitwise અથવા 32 =.

319
00:29:46,400 --> 00:29:51,490
પણ, 2 મોડ == 0 ગણતરી.

320
00:29:51,490 --> 00:30:00,900
જેથી યાદ - હું તે નથી લખશે - કોઈપણ કિંમત બિન શૂન્ય સાચું છે, અને 0 ખોટું છે.

321
00:30:00,900 --> 00:30:07,880
તેથી "ગણતરી 2 મોડ જો 0 ==" કહેતા તરીકે જ છે, "જો 2 મોડ ગણતરી નથી."

322
00:30:07,880 --> 00:30:11,580
હું કદાચ ફક્ત રેખાઓ ઉલટી થશે અને કહ્યું કે, "જો ગણતરી 2 મોડ,

323
00:30:11,580 --> 00:30:15,350
તે અથવા 1, બીજું એ અને 1, તો "કે જેથી હું જરૂર ન આપી નથી". "

324
00:30:15,350 --> 00:30:18,650
પરંતુ આ જ રીતે કામ કરે.

325
00:30:18,650 --> 00:30:25,660
અને બીજું શું હું અહીં શું કરી શકો છો?

326
00:30:25,660 --> 00:30:29,060
તમે તેમને ત્રણ ભાગનું બનેલું સાથે ભેગા જો તમે ઇચ્છતા હતા, પરંતુ પછી શકે કે જે હમણાં જ વસ્તુઓ messier કરો છો

327
00:30:29,060 --> 00:30:33,770
અને કદાચ વધુ વાંચો મુશ્કેલ છે, તેથી અમે તે કરીશું નહીં.

328
00:30:33,770 --> 00:30:37,330
કોઈપણ કોઈપણ અન્ય સૂચનો છે?

329
00:30:37,330 --> 00:30:41,580
છે કે બધી સમસ્યા માટે પૂછવામાં? હા ઓહ.

330
00:30:41,580 --> 00:30:51,070
તેથી આ ખાલી લીટીઓ છૂટકારો મેળવવા માટે, હવે અમે એફ,% s છાપો પડશે શબ્દમાળાઓ માટે એક છે,

331
00:30:51,070 --> 00:30:56,620
અમે એફ છાપો, ઓ આવશે.

332
00:30:56,620 --> 00:30:59,330
હવે આપણે તેના ચલાવો. શું હું કશું ખોટું છે?

333
00:30:59,330 --> 00:31:03,200
કે જે \ છે "; હું n માંગો છો.

334
00:31:03,200 --> 00:31:07,840
ઠીક છે. હવે અમે તેને ચલાવવા પડશે. તે કદાચ મને અંતે કિકિયારી પડશે.

335
00:31:07,840 --> 00:31:11,250
Strlen string.h છે.

336
00:31:11,250 --> 00:31:14,290
તેથી આ છે રણકાર વિશે સરસ વસ્તુ છે તે તમને કહે છે તે શું કરે છે,

337
00:31:14,290 --> 00:31:19,140
તેના બદલે GCC ને જે ફક્ત કહે છે, "અરે, તમે કંઈક ભૂલી ગયા છો, મને ખબર છે કે તે શું હતું નહિં."

338
00:31:19,140 --> 00:31:29,220
, પરંતુ આ મને કહેશે "તમે string.h સમાવેશ થતો હતો."

339
00:31:29,220 --> 00:31:32,130
તેથી મેં કંઈપણ કરવા માટે પૂછતી નહોતી, તેથી તે કંઇ નથી કહેતા છે.

340
00:31:32,130 --> 00:31:42,540
પરંતુ, "4 ઉમેરો આભાર" અમે તેમની ઉદાહરણ કરવું પડશે.

341
00:31:42,540 --> 00:31:47,880
તે બરાબર દેખાય છે. હુરે.

342
00:31:47,880 --> 00:31:52,370
તેથી તમારા મુખ્ય પરત, હું લગભગ તે ક્યારેય નથી.

343
00:31:52,370 --> 00:31:57,110
તે વૈકલ્પિક છે. અને મુખ્ય માત્ર કાર્ય જેના માટે તે વૈકલ્પિક છે.

344
00:31:57,110 --> 00:32:07,140
જો તમે કંઈપણ મુખ્ય નથી પાછા નથી, એવું મનાય છે કે જે તમે 0 પાછા હતા.

345
00:32:07,140 --> 00:32:13,070
પ્રશ્નો?

346
00:32:13,070 --> 00:32:20,980
ઠીક છે. તેથી હવે બીજા સમસ્યા.

347
00:32:20,980 --> 00:32:24,810
"પસાર કરીને સપ્તાહ હિસ્સો 2 બીજા વ્યાખ્યાન કે 2 'ચલો કિંમતો જેઓ માંથી રિકોલ

348
00:32:24,810 --> 00:32:30,780
એક કાર્ય (જો સ્વેપ તરીકે ઓળખાય છે) તે 2 ચલો બરાબર ઓછામાં ઓછા વિના નથી, કામ 'પોઇન્ટર.' નથી "

349
00:32:30,780 --> 00:32:37,020
અને પોઇંટરો અવગણો સુધી અમે તેમને મેળવો.

350
00:32:37,020 --> 00:32:40,070
અમે 2 ચલો સ્વેપ કરવા માંગો છો; અમે કાર્ય નથી વાપરી તે કરવા કરી રહ્યા છો.

351
00:32:40,070 --> 00:32:43,410
અમે હજુ પણ મુખ્ય કરતા હો તે કહે રહ્યા છીએ.

352
00:32:43,410 --> 00:32:48,360
પરંતુ તે 2 ચલો વાપરવા માટે, અમે એક કામચલાઉ ચલ વાપરવા માંગો નહિં.

353
00:32:48,360 --> 00:32:50,770
ત્યાં 2 આ કરવા માટે માર્ગો છે.

354
00:32:50,770 --> 00:32:56,310
તમે તે કરી તમારા પરંપરાગત દ્વિસંગી ઓપરેટર્સનો ઉપયોગ કરી શકો છો.

355
00:32:56,310 --> 00:33:00,180
તેથી તે કોઈપણ કરવાનું ઝડપી અને ગંદા રીતે ખબર નથી?

356
00:33:00,180 --> 00:33:07,650
વાસ્તવમાં તે વિચારના એક મિનિટ લાગી શકે છે. હું હોય તો -

357
00:33:07,650 --> 00:33:12,130
હું સમસ્યા સુયોજિત જેમ તેઓ કહીશું. તેથી જો હું 2 ચલો છે, એ છે, કે જે ફક્ત એક પૂર્ણાંક છે

358
00:33:12,130 --> 00:33:17,800
કે તેઓ મને આપે છે, અને રકમ ચલ બી, જે અન્ય પૂર્ણાંક છે કે જે હું છું આપવામાં આવે છે.

359
00:33:17,800 --> 00:33:22,700
તેથી જો હું આ 2 ચલો છે, હવે હું તેમને સ્વેપ કરવા માંગો છો.

360
00:33:22,700 --> 00:33:31,550
પરંપરાગત, તમારા નિયમિત દ્વિસંગી ઓપરેટર્સનો ઉપયોગ, હું તેનો અર્થ, +, જેમ કે -, ÷.

361
00:33:31,550 --> 00:33:36,630
જવાબ નથી bitwise ઓપરેટરો કે જે બાઈનરી પર કામ કરે છે.

362
00:33:36,630 --> 00:33:39,600
, +, ÷, બધા અને તે છે - તેથી મદદથી.

363
00:33:39,600 --> 00:33:52,980
અમે કંઈક કરવાથી સ્વેપ કરી શકે છે = એક + b, અને b = એક - બો, એક = એક - બી.

364
00:33:52,980 --> 00:34:04,260
તેથી, સેનીટી ચકાસો, અને પછી અમે તે શા માટે કામ કરે છે જોશો.

365
00:34:04,260 --> 00:34:13,320
હવે કહો કે એક = 7, બી = 3, પછી + b થી 10 પ્રયત્ન રહ્યું છે.

366
00:34:13,320 --> 00:34:18,820
તેથી અમે હવે = 10 સુયોજિત કરી રહ્યાં છો, અને પછી અમે બો = એક કરી રહ્યા છીએ - બી.

367
00:34:18,820 --> 00:34:30,250
તેથી અમે કરી રહ્યા છીએ બો = એક - બો છે, કે જે 7 હોઇ શકે રહ્યું છે, અને b = એક - ફરી બો,

368
00:34:30,250 --> 00:34:38,650
અથવા = એક - બી. 7 જે 3 છે - જે 10 પ્રયત્ન રહ્યું છે.

369
00:34:38,650 --> 00:34:44,850
તેથી હવે યોગ્ય રીતે 'એ', 7 હતી, બો 3 હતું, અને હવે બોલ્ડ 7 છે અને 'એ' 3 છે.

370
00:34:44,850 --> 00:34:48,679
જેથી પ્રકારની અર્થમાં બનાવે છે; 'એ' એ 2 નંબરો મિશ્રણ છે.

371
00:34:48,679 --> 00:34:53,000
આ બિંદુએ 'એ', સંયોજન છે, અને પછી અમે મૂળ બો બાદબાકી કરી રહ્યાં છો,

372
00:34:53,000 --> 00:34:56,860
અને પછી અમે બાદબાકી કરી રહ્યાં છો શું મૂળ હતી 'એક.'

373
00:34:56,860 --> 00:35:01,150
પરંતુ આ બધી સંખ્યાઓ માટે કામ કરતું નથી.

374
00:35:01,150 --> 00:35:08,880
આ જુઓ, ચાલો સિસ્ટમ ગણે છે; જેથી અમે સામાન્ય રીતે 32 બિટ્સ તરીકે પૂર્ણાંકોના વિચારો.

375
00:35:08,880 --> 00:35:13,050
ચાલો કંઈક છે જે 4 બીટ્સ જેવી માત્ર પર કામ કરે છે.

376
00:35:13,050 --> 00:35:15,450
આસ્થાપૂર્વક હું એક સારું ઉદાહરણ સાથે હમણાં આવે છે.

377
00:35:15,450 --> 00:35:18,680
તેથી મને ખબર છે, આ સરળ હશે.

378
00:35:18,680 --> 00:35:26,720
હવે કહો કે અમારી 2 નંબરો 1111, અને 1111 છે; જેથી અમે દ્વિસંગી માં હમણાં છો.

379
00:35:26,720 --> 00:35:34,630
વાસ્તવિક દશાંશ માં, જો તમે તેને તે રીતે લાગે કરવા માંગતા હો, 15 = અને = b 15.

380
00:35:34,630 --> 00:35:37,630
અને તેથી અમે અપેક્ષા, પછી અમે તેમને સ્વેપ - તેઓ પણ એ જ નંબર ન હોય,

381
00:35:37,630 --> 00:35:41,140
પરંતુ મેં આ રીતે કર્યું હતું.

382
00:35:41,140 --> 00:35:47,100
ચાલો તેમને જ નંબરો કરી નથી. હિસ્સો 1111 અને 0001 દો.

383
00:35:47,100 --> 00:35:51,860
તેથી = 15 અને બોલ્ડ = 1.

384
00:35:51,860 --> 00:35:57,670
પછી અમે તેમને સ્વેપ, અમે 'એ' માટે 1 પ્રયત્ન અને બોલ્ડ 15 હોઈ અપેક્ષા.

385
00:35:57,670 --> 00:36:01,780
તેથી અમારા પ્રથમ પગલું છે = એક + + બી.

386
00:36:01,780 --> 00:36:08,770
અમારા નંબરો માત્ર 4 બિટ્સ વિશાળ છે, તેથી 'એક' છે, જે 1111 છે + b, જે 0001 છે,

387
00:36:08,770 --> 00:36:16,780
છે અંત 10000 હોવાની જવાનું, પરંતુ અમે માત્ર 4 બિટ્સ હોય છે.

388
00:36:16,780 --> 00:36:22,540
તેથી હવે = 0.

389
00:36:22,540 --> 00:36:34,080
બો - - વાસ્તવમાં, આ હજી પણ સંપૂર્ણપણે કામ કરે છે અને હવે અમે સુયોજિત બો = એક કરવા માંગો છો.

390
00:36:34,080 --> 00:36:39,630
એક = એક - બાય - ચાલો જોવા જો આ બહાર સંપૂર્ણપણે કામ કરે છે.

391
00:36:39,630 --> 00:36:53,720
તેથી પછી બો = 0 - 1, કે જે હજુ પણ 15 રહેશે અને તે પછી એક = એક - બો છે, કે જે 1 હશે.

392
00:36:53,720 --> 00:36:56,210
કદાચ આ કામ કરે છે.

393
00:36:56,210 --> 00:36:59,020
મને લાગે છે કે ત્યાં એક કારણ તે નિયમિત ઉપયોગ કરીને કામ કરતું નથી છે.

394
00:36:59,020 --> 00:37:06,400
ઠીક છે, જેથી ધારણા છે કે તે નિયમિત દ્વિસંગી કામગીરી સાથે કાર્ય કરતું નથી ઉપર કામ

395
00:37:06,400 --> 00:37:15,040
અને હું જોવા માટે કરશે - હું જોવા માટે જો તે સાચું છે Google આવશે.

396
00:37:15,040 --> 00:37:23,490
તેથી અમે તે કરવા bitwise ઓપરેટર્સનો ઉપયોગ કરવા માંગો છો, અને અંહિ ચાવી XOR છે.

397
00:37:23,490 --> 00:37:28,780
તેથી, XOR (^) દાખલ જો તમે તેને હજુ સુધી જોઇ ન હોય.

398
00:37:28,780 --> 00:37:34,610
તે છે, ફરી એક bitwise ઓપરેટર તેથી તે બીટ, અને it's દ્વારા બીટ કામ કરે છે -

399
00:37:34,610 --> 00:37:39,910
જો તમે 0 અને 1 બિટ્સ હોય, તો પછી આ 1 હશે.

400
00:37:39,910 --> 00:37:45,230
જો તમે 1 બિટ્સ અને 0 હોય, તો તેને 1 હશો, તો તમે 0 બિટ્સ અને 0 0 હશો તે હોય,

401
00:37:45,230 --> 00:37:47,640
અને જો તમે 1 બિટ્સ અને 1 ધરાવે છે તે 0 હશો.

402
00:37:47,640 --> 00:37:56,180
તેથી તે જેમ છે અથવા. જો બિટ્સની ક્યાં સાચું હોય, તો તે 1, પરંતુ અથવા વિપરીત, તે બંને બીટ્સ કે સાચું છે ન હોઈ શકે.

403
00:37:56,180 --> 00:37:59,320
અથવા આ છે 1 હશે, XOR હશે આ 0 છે.

404
00:37:59,320 --> 00:38:02,250
તેથી અમે માટે XOR અહીં ઉપયોગ કરવા માંગો છો જઈ રહ્યાં છો.

405
00:38:02,250 --> 00:38:09,960
એક મિનિટ માટે તે વિશે વિચારો; હું Google પર જાઉં છું.

406
00:38:09,960 --> 00:38:16,230
વેલ, તમે તે વાંચી શકો છો; હું XOR સ્વેપ અલ્ગોરિધમનો પૃષ્ઠ પર હાલમાં છું.

407
00:38:16,230 --> 00:38:21,340
આસ્થાપૂર્વક આ શા માટે હું can't સમજાવશે -

408
00:38:21,340 --> 00:38:34,190
આ બરાબર અલગોરિધમ કે અમે હમણાં જ કર્યું છે.

409
00:38:34,190 --> 00:38:37,330
હું હજુ પણ શા માટે દેખાય નહિં - હું માત્ર એક ખરાબ ઉદાહરણ છે લેવામાં જોઇએ,

410
00:38:37,330 --> 00:38:44,940
પરંતુ આ કિસ્સામાં જ્યાં 'એ' માટે 0 બની જાય છે, 5 બિટ્સ માટે મેળવવામાં પછી, તેથી હવે 'એ' 0 છે થયું,

411
00:38:44,940 --> 00:38:48,730
એટલે કે શું કહે છે "પૂર્ણાંક ઓવરફ્લો."

412
00:38:48,730 --> 00:38:54,370
વિકિપીડિયા અનુસાર, "આ XOR સ્વેપ જેમ નહિં પણ, આ તફાવત માટે જરૂરી છે કે તેમાં કેટલીક પદ્ધતિઓ વાપરે છે

413
00:38:54,370 --> 00:38:59,780
ગેરંટી આપવી કે એક્સ + + વાય પૂર્ણાંક ઓવરફ્લો થતા નથી. "

414
00:38:59,780 --> 00:39:08,350
તેથી આ સમસ્યા હોય છે; આ પૂર્ણાંક ઓવરફ્લો હતી, પરંતુ હું કંઇક ખોટું કર્યું.

415
00:39:08,350 --> 00:39:10,520
મને ખાતરી છે કે નથી. હું એક બીજા સાથે આવવા પ્રયાસ કરીશું.

416
00:39:10,520 --> 00:39:13,640
[વિદ્યાર્થી] સારું, પૂર્ણાંક ઓવરફ્લો જ્યારે તમે ત્યાં એક નંબર મૂકવા પ્રયાસ કરી રહ્યા છો નથી

417
00:39:13,640 --> 00:39:16,640
બિટ્સ જથ્થો તમે ફાળવવામાં કરતાં મોટી?

418
00:39:16,640 --> 00:39:23,730
યાહ. અમે 4 બિટ્સ હોય છે. That's - અમે 4 બિટ્સ હતી, અમે પછી તે માટે 1 ઉમેરવા પ્રયત્ન કરો, જેથી અમે 5 બિટ્સ સાથે અંત.

419
00:39:23,730 --> 00:39:26,690
પરંતુ પાંચમી બીટ માત્ર કાપી નહીં, હા.

420
00:39:26,690 --> 00:39:28,970
વાસ્તવમાં તે કદાચ -

421
00:39:28,970 --> 00:39:33,010
[વિદ્યાર્થી] કે તમે શું ભૂલ ફેંકવું, અથવા તે કરે છે - જે એક ભૂલ ફેંકવું છો?

422
00:39:33,010 --> 00:39:40,720
નંબર તો ત્યાં કોઈ ભૂલ છે. જ્યારે તમે વિધાનસભા સ્તર મેળવવા માટે, ખાસ બીટ

423
00:39:40,720 --> 00:39:47,020
ક્યાંક સેટ છે કે જણાવ્યું હતું કે ત્યાં એક ઓવરફ્લો હતી, પરંતુ સી તમે પ્રકારની માત્ર કે સાથે વ્યવહાર નથી.

424
00:39:47,020 --> 00:39:55,160
તમે ખરેખર તેની સાથે વ્યવહાર નથી જ્યાં સુધી તમે સી ખાસ વિધાનસભા સૂચનો ઉપયોગ કરી શકો છો

425
00:39:55,160 --> 00:39:58,110
ચાલો XOR સ્વેપ વિશે વિચારો.

426
00:39:58,110 --> 00:40:02,220
અને મને લાગે છે કે વિકિપીડિયા લેખ પણ શકે કરવામાં કહેતા છે કે -

427
00:40:02,220 --> 00:40:07,310
તેથી તે પણ મોડ્યુલર અંકગણિત લાવવામાં, તેથી મને લાગ્યું કે હું હતો, સિદ્ધાંત મુજબ, મોડ્યુલર અંકગણિત કરી

428
00:40:07,310 --> 00:40:11,160
જ્યારે હું જણાવ્યું હતું કે, 0 - 1 15 ફરી છે.

429
00:40:11,160 --> 00:40:15,410
જેથી ખરેખર કદાચ - 1 = 15 - એક નિયમિત પ્રોસેસર છે કે 0 કરે છે.

430
00:40:15,410 --> 00:40:20,430
કારણ કે આપણે 0 અંતે અંત, અમે 1 સબ્ટ્રેક્ટ છે, તેથી તે પછી તે માત્ર આસપાસ 1111 પર પાછા વિંટાળે છે.

431
00:40:20,430 --> 00:40:28,930
તેથી આ અલ્ગોરિધમનો ખરેખર કામ કરે છે, એક + b, એક શકે છે - બો, બી - એક; કે દંડ થઇ શકે છે.

432
00:40:28,930 --> 00:40:34,030
પરંતુ અમુક પ્રોસેસરો જે નથી, અને તેથી તે તે ચોક્કસ મુદ્દાઓ માં દંડ નહિં હોય.

433
00:40:34,030 --> 00:40:39,880
XOR સ્વેપ કોઈપણ પ્રોસેસર પર કામ કરશે. ઠીક છે.

434
00:40:39,880 --> 00:40:42,280
આ વિચાર એ છે કે તે એ જ હોઇ શકે છે, જોકે માનવામાં આવે છે.

435
00:40:42,280 --> 00:40:50,120
અમે XOR જ્યાં વાપરી રહ્યા હોય કોઈક 1 ચલો બની બંને ની માહિતી મેળવી,

436
00:40:50,120 --> 00:40:54,120
અને પછી વ્યક્તિગત વેરિયેબલ્સ માહિતી ફરીથી ખેંચો.

437
00:40:54,120 --> 00:41:04,330
તેથી કોઈને વિચારો / જવાબ નથી?

438
00:41:04,330 --> 00:41:14,540
[વિદ્યાર્થી જવાબ, દુર્બોધ]

439
00:41:14,540 --> 00:41:22,220
તેથી આ કામ કરે છે, અને તે પણ, XOR પરિવર્તનીય છે કરીશું.

440
00:41:22,220 --> 00:41:27,620
અનુલક્ષીને ક્રમ કે જેના આ 2 નંબરો માટે અહીં હોવા થાય છે,

441
00:41:27,620 --> 00:41:30,100
આ પરિણામ એ જ પ્રયત્ન રહ્યું છે.

442
00:41:30,100 --> 00:41:35,800
તેથી ^ બો છે બો ^ એ.

443
00:41:35,800 --> 00:41:51,860
તમે પણ જુઓ આ પરચૂરણ શકે છે એક ^ = b, બી ^ = એક, એક ^ = ફરીથી બી.

444
00:41:51,860 --> 00:42:00,200
તેથી આ અધિકાર છે, અને તે જોવા માટે આ શા માટે કામ કરે છે, બિટ્સ લાગે છે.

445
00:42:00,200 --> 00:42:10,400
એક smallish નંબરનો ઉપયોગ કરીને, ચાલો 11001, અને 01100 કહો.

446
00:42:10,400 --> 00:42:12,790
તેથી આ 'એ' હોય છે; આ બોલ્ડ છે.

447
00:42:12,790 --> 00:42:15,540
તેથી ^ = બો.

448
00:42:15,540 --> 00:42:22,380
અમે સુયોજિત આ 2 વસ્તુઓ ના XOR માટે 'એ' = શકાય જઈ રહ્યાં છો.

449
00:42:22,380 --> 00:42:32,920
1 તેથી 0 ^ 1 છે; 1 ^ 1 0 છે; 0 ^ 1 1 છે, અને 0 ^ 0 0 છે; 1 ^ 0 1 છે.

450
00:42:32,920 --> 00:42:37,380
તેથી 'એક,' જો તમે રેખાંશ નંબર પર જુઓ, તે જ હશે -

451
00:42:37,380 --> 00:42:41,160
તમે મૂળ 'એ' અને નવા વચ્ચે સંબંધ ખૂબ જોવા નથી જવું 'એક' કરી રહ્યાં છો

452
00:42:41,160 --> 00:42:45,600
પરંતુ બિટ્સ જોઈ 'એ', જે માહિતી એક જાળીદાર જેમ હવે

453
00:42:45,600 --> 00:42:49,970
બંને મૂળ 'એ' અને મૂળ બો.

454
00:42:49,970 --> 00:42:57,930
તેથી જો આપણે બો ^ એક, અમે જુઓ કે અમે મૂળ અંતે અંત પડશે 'એક.' લઇ

455
00:42:57,930 --> 00:43:08,910
અને જો આપણે લઇ મૂળ 'એ' ^ નવા 'એક,' અમે જોવા અમે મૂળ બો અંતે અંત.

456
00:43:08,910 --> 00:43:18,380
તેથી (એક ^ ખ) ^ બો = મૂળ 'એક.'

457
00:43:18,380 --> 00:43:27,910
(અને ^ ખ) ^ એક = મૂળ બો.

458
00:43:27,910 --> 00:43:37,010
ત્યાં છે - જોઈને આ કંઈપણ XOR પોતે છે બીજી રીતે હંમેશા 0 હોય છે.

459
00:43:37,010 --> 00:43:45,020
1101 તેથી 1101 ^, બધા બિટ્સ જ હશે આવે છે.

460
00:43:45,020 --> 00:43:47,920
તેથી ત્યાં એક કેસ જ્યાં 1 છે 0 અને 1 અન્ય છે ક્યારેય ચાલી રહ્યું છે.

461
00:43:47,920 --> 00:43:51,080
તેથી આ 0000 છે.

462
00:43:51,080 --> 00:43:57,240
આ સાથે જ. (એક ^ ખ) ^ બો જેવી છે ^ (બો ^ ખ).

463
00:43:57,240 --> 00:44:03,680
(ખ બો ^) માટે 0 હશે છે; 0 ^ માત્ર પ્રયત્ન 'એક' રહ્યું છે કારણ કે બધા બિટ્સ 0 છે.

464
00:44:03,680 --> 00:44:08,050
જેથી માત્ર મુદ્દાઓ કે જે પ્રયત્ન જવું છે જ્યાં 'એ' મૂળ હતી 1 એક - મુદ્દાઓ હતા.

465
00:44:08,050 --> 00:44:12,070
અને તે જ અહીં વિચાર; હું ખૂબ ખાતરી કરો કે તે પણ પરિવર્તનીય છું.

466
00:44:12,070 --> 00:44:17,590
યાહ. હું કહું છું કે નહોતી તે પહેલાં પરિવર્તનીય હતી.

467
00:44:17,590 --> 00:44:24,680
આ ^ 'એક' અને તે સાહચર્યાત્મક છે, તેથી હવે (ખ ^) એક ^ એ.

468
00:44:24,680 --> 00:44:28,970
અને અમે બો ^ (^ ની એક). કરી શકો છો

469
00:44:28,970 --> 00:44:31,540
અને તેથી ફરી, અમે મૂળ બો મેળવો.

470
00:44:31,540 --> 00:44:37,120
તેથી 'એ' હવે 'એ' બોલ્ડ અને એકસાથે સંયોજન છે.

471
00:44:37,120 --> 00:44:49,660
અમારા નવા કોમ્બો ઉપયોગ કરીને 'એ', અમે કહીએ છીએ બો = કોમ્બો 'એ' ^ મૂળ બો, અમે મૂળ વિચાર 'એક.'

472
00:44:49,660 --> 00:45:05,170
અને હવે = કોમ્બો 'એ' ^ નવા બો છે, જે મૂળ હતો - અથવા જે હવે શું 'એ' અથવા બો હતી.

473
00:45:05,170 --> 00:45:13,620
કે આ કેસ અહીં નહીં. આ = b, જૂની બો છે.

474
00:45:13,620 --> 00:45:16,550
તેથી હવે બધું તો સ્વૅપ ક્રમમાં પાછળ છે.

475
00:45:16,550 --> 00:45:22,960
જો આપણે ખરેખર બિટ્સ તપાસ્યા હતા, બો = એક ^ બોલ્ડ માટે 2 આ XOR રહ્યું છે,

476
00:45:22,960 --> 00:45:33,920
અને જવાબ માટે આ પ્રયત્ન રહ્યું છે, અને પછી એક = એક ^ બો આ 2 XORing છે અને જવાબ આ છે.

477
00:45:33,920 --> 00:45:41,090
પ્રશ્નો? ઠીક છે. જેથી છેલ્લા એક કેટલેક અંશે નોંધપાત્ર મુશ્કેલ છે.

478
00:45:41,090 --> 00:45:43,180
[વિદ્યાર્થી] હું માનું છે કે તે તેના વિશે પ્રશ્ન છે. >> ઓહ, માફ.

479
00:45:43,180 --> 00:45:49,380
[વિદ્યાર્થી] શું ખરેખર છે ઝડપી? જો તમે આ XOR વાપરો, અથવા તે છે જો તમે નવી ચલ જાહેર?

480
00:45:49,380 --> 00:45:55,190
તેથી શું ખરેખર ઝડપી છે, એક નવી ચલ જાહેર અથવા XOR મદદથી સ્વેપ?

481
00:45:55,190 --> 00:45:59,600
જવાબ બધા શક્યતા છે, એક હંગામી ચલ.

482
00:45:59,600 --> 00:46:05,780
અને કારણ કે એકવાર તે નીચે સંકલિત છે - એસેમ્બલી સ્તરે તેથી,

483
00:46:05,780 --> 00:46:12,320
ત્યાં કોઈ સ્થાનિક ચલો, અથવા કોઇ કામચલાઉ ચલો અથવા આ સામગ્રી કોઈપણ જેમ કે વાત છે.

484
00:46:12,320 --> 00:46:16,060
તેઓ માત્ર માંગો કરી રહ્યા છીએ - ત્યાં મેમરી છે, અને ત્યાં રજીસ્ટર છે.

485
00:46:16,060 --> 00:46:20,920
રજિસ્ટર્સ છે જ્યાં વસ્તુઓ સક્રિય થાય છે.

486
00:46:20,920 --> 00:46:24,750
તમે મેમરી 2 માં વસ્તુઓ ઉમેરી નથી; તમે રજીસ્ટર 2 માં વસ્તુઓ ઉમેરો.

487
00:46:24,750 --> 00:46:28,160
અને તમે રજીસ્ટર માં મેમરી માંથી વસ્તુઓ લાવવા માટે પછી તેમને ઉમેરવા માટે,

488
00:46:28,160 --> 00:46:33,180
અને પછી તમે તેમને પાછી ફેરવી મેમરીમાં શકે છે, પરંતુ તમામ ક્રિયા રજિસ્ટર બને.

489
00:46:33,180 --> 00:46:38,750
તેથી જ્યારે તમે કામચલાઉ ચલ અભિગમ ઉપયોગ કરી રહ્યાં છો, સામાન્ય રીતે થાય છે શું છે

490
00:46:38,750 --> 00:46:42,810
આ 2 નંબરો રજિસ્ટર પહેલેથી જ છે.

491
00:46:42,810 --> 00:46:46,570
અને પછી, પછી તમે તેમને સ્વૅપ કર્યું છે કે બિંદુ પરથી,

492
00:46:46,570 --> 00:46:51,540
તે માત્ર અન્ય રજીસ્ટર મદદથી શરૂ કરી શકશો.

493
00:46:51,540 --> 00:46:56,510
તમે ગમે ત્યાં બો નો ઉપયોગ કર્યો હતો, તે ફકત રજિસ્ટર કે જેઓ પહેલાથી સ્ટોર કરવામાં આવ્યું હતું ઉપયોગ કરશો 'એક.'

494
00:46:56,510 --> 00:47:02,180
તેથી તે માટે ખરેખર સ્વેપ કરવા કંઇપણ જરૂર નથી. યાહ?

495
00:47:02,180 --> 00:47:05,690
[વિદ્યાર્થી] પરંતુ તે પણ વધુ મેમરી અધિકાર લે છે,?

496
00:47:05,690 --> 00:47:10,280
તે માત્ર ત્યારે જ વધુ મેમરી લેવાં જોઈએ, જો કે કામચલાઉ ચલ સ્ટોર કરવાની જરૂર પડશે.

497
00:47:10,280 --> 00:47:14,830
ગમે જો તમે તે પછી કામચલાઉ ચલ ફરી ક્યાંક વાપરવા માટે,

498
00:47:14,830 --> 00:47:18,920
પછી - અથવા તમે કે કામચલાઉ ચલ કંઈક સોંપો.

499
00:47:18,920 --> 00:47:24,630
તેથી સમય 'એક' કામચલાઉ નોકર માં બો કોઈપણ બિંદુએ જો અલગ મૂલ્યો અથવા કંઈક હોય છે,

500
00:47:24,630 --> 00:47:30,680
પછી તે મેમરીમાં અલગ સ્થળોએ હોય ચાલી રહ્યું છે, પરંતુ તે વાત સાચી છે કે

501
00:47:30,680 --> 00:47:34,800
ત્યાં ઘણા સ્થાનિક ચલો કે જે માત્ર રજિસ્ટર માં હાજર હોય છે.

502
00:47:34,800 --> 00:47:44,370
, કે જે કિસ્સામાં તે મેમરીમાં ક્યારેય મૂકી છે અને જેથી તમે ક્યારેય મેમરી બગાડ કરી રહ્યા છો.

503
00:47:44,370 --> 00:47:58,620
ઠીક છે. છેલ્લા પ્રશ્ન થોડો વધુ છે.

504
00:47:58,620 --> 00:48:04,850
અહીં, આ CS50 સાધન છે, ત્યાં એક શબ્દકોશ છે.

505
00:48:04,850 --> 00:48:12,390
અને આ કારણ છે કારણ કે [? B66] એક સ્પેલચેકરરૂપરેખાંંકિતકરો જ્યાં તમે લખી આવશે છે

506
00:48:12,390 --> 00:48:15,780
હેશ કોષ્ટકો અથવા પ્રયત્નોમાં અથવા અમુક માહિતી માળખું મદદથી.

507
00:48:15,780 --> 00:48:22,660
તમે એક સ્પેલચેકરરૂપરેખાંંકિતકરો લખી શકાય જઈ રહ્યાં છો, અને તમે આ શબ્દકોશ ઉપયોગ કરી કે શું રહ્યા છીએ.

508
00:48:22,660 --> 00:48:28,280
પરંતુ આ સમસ્યા માટે, અમે માત્ર લુકઅપ માટે જુઓ જો એક શબ્દ કોશ છે જવું છે.

509
00:48:28,280 --> 00:48:31,250
તેથી તેના બદલે અમુક માહિતી માળખું સમગ્ર શબ્દકોશ સ્ટોર કરવાનો

510
00:48:31,250 --> 00:48:35,180
અને પછી સમગ્ર દસ્તાવેજ પર શોધી જોવા માટે જો કાંઇ ખોટીજોડણીવાળું છે,

511
00:48:35,180 --> 00:48:38,490
અમે ફક્ત માટે 1 શબ્દ શોધવા માંગો છો. તેથી અમે માત્ર સમગ્ર શબ્દકોશ સ્કેન કરી શકે છે

512
00:48:38,490 --> 00:48:44,300
અને જો આપણે સમગ્ર શબ્દકોશ શબ્દ શોધવા ક્યારેય, પછી તે ત્યાં ન હતો.

513
00:48:44,300 --> 00:48:52,150
જો અમે સમગ્ર શબ્દકોશ ઉપર સ્કૅન અને શબ્દ નથી, જુઓ તો અમે સારા છીએ, અમે તેને જોવા મળે છે.

514
00:48:52,150 --> 00:48:56,580
અહીં કહે છે કે અમે સી કાર્ય ફાઈલ હેન્ડલિંગ જોઈ શરૂ કરવા માંગો છો,

515
00:48:56,580 --> 00:48:59,930
કારણ કે અમે શબ્દકોશ વાંચી માંગો છો,

516
00:48:59,930 --> 00:49:07,680
પરંતુ હું કાર્યો તમે લાગે કરીશું કે જે તરીકે સંકેતની અહીં આપશે.

517
00:49:07,680 --> 00:49:11,510
હું તેમને સ્પેસીસ પર લખી શકશો.

518
00:49:11,510 --> 00:49:20,490
તેથી મુખ્ય તમે જેના માટે ખુલ્લા અને પછી એફ, સ્વાભાવિકપણે, એફ બંધ જોવા માંગો છો પડશે,

519
00:49:20,490 --> 00:49:26,540
કે જે તમારી કાર્યક્રમ ઓવરને અંતે જાઓ, અને એફ સ્કેન એફ.

520
00:49:26,540 --> 00:49:31,060
તમે પણ ઉપયોગ કરી શકે છે એફ વાંચી પરંતુ તમે કદાચ નથી માંગતા

521
00:49:31,060 --> 00:49:34,200
કારણ કે - તમે ન અંત છે કે જરૂર નથી.

522
00:49:34,200 --> 00:49:41,880
એફ સ્કેન એફ છે તમે શું કરવા પર શબ્દકોશ સ્કેન ઉપયોગ કરી રહ્યા છીએ.

523
00:49:41,880 --> 00:49:46,370
અને તેથી તમે આ ઉકેલ કોડ જરૂર નથી, માત્ર પ્રયાસ અને સ્યુડો કોડ માંગો તમારા માર્ગ

524
00:49:46,370 --> 00:50:05,200
ઉકેલ માટે અને પછી અમે તેને ચર્ચા કરીશું.

525
00:50:05,200 --> 00:50:14,110
અને ખરેખર, કારણ હું પહેલેથી જ તમને આ આપ્યો હતો, જો તમે કોઈપણ ટર્મિનલ અથવા તમારા ઉપકરણ શેલ જાય,

526
00:50:14,110 --> 00:50:18,250
હું કરશે - સામાન્ય રીતે હું - જો તમે હજુ સુધી જોઇ ન હોય, મને ખબર નથી જો તમે વર્ગ કર્યું હતું,

527
00:50:18,250 --> 00:50:23,490
પરંતુ માણસ છે, તેથી મદદ પાનાંઓ, ખૂબ ખૂબ ખૂબ કોઈપણ કાર્ય જોઈ માટે ઉપયોગી છે.

528
00:50:23,490 --> 00:50:27,330
તેથી હું, પસંદ કરી શકો છો, માણસ એફ, સ્કેન એફ.

529
00:50:27,330 --> 00:50:32,300
આ હવે વિધેયોને સ્કેન એફ કુટુંબ વિશે માહિતી છે.

530
00:50:32,300 --> 00:50:37,070
હું પણ માણસ એફ, ઓપન કરી શકે છે, અને તે મને કે વિગતો આપીશું.

531
00:50:37,070 --> 00:50:40,750
તેથી જો તમને ખબર કાર્ય શું તમે નો ઉપયોગ કરવામાં આવે છે, અથવા તો તમે કોડ વાંચન કરી રહ્યા છીએ

532
00:50:40,750 --> 00:50:43,000
અને તમે અમુક કાર્ય જુઓ અને તમે છો, જેમ કે "આ શું કરે છે?"

533
00:50:43,000 --> 00:50:45,280
જસ્ટ માણસ કાર્ય કે નામ.

534
00:50:45,280 --> 00:50:47,340
ત્યાં વિચિત્ર ઉદાહરણો એક દંપતિ જ્યાં તમે કહેવા શકે છે

535
00:50:47,340 --> 00:50:51,620
ગમે છે. કે કાર્ય નામ, અથવા 3 માણસ કે વિધેય નામ, 2 માણસ

536
00:50:51,620 --> 00:50:58,230
પરંતુ તમે માત્ર કરવા કે જો માણસ કાર્ય નામ સાથે પ્રથમ વખત કામ ન થાય છે.

537
00:50:58,230 --> 00:51:03,010
[વિદ્યાર્થી] તેથી હું ઓપન માટે મદદ પાનું વાંચી રહ્યો છું, પરંતુ હું હજુ પણ તે કેવી રીતે અને કાર્યક્રમ વાપરવા પર મૂંઝવણમાં છું.

538
00:51:03,010 --> 00:51:06,170
ઠીક છે. મદદ પાનાંઓ ઘણાં મદદરૂપ કરતા ઓછી હોય છે.

539
00:51:06,170 --> 00:51:08,470
તેઓ વધુ મદદરૂપ છો જો તમે પહેલાથી જ ખબર તેઓ શું કરી

540
00:51:08,470 --> 00:51:12,670
અને પછી તમે માત્ર દલીલો અથવા કંઈક ક્રમ યાદ કરવાની જરૂર છે.

541
00:51:12,670 --> 00:51:17,640
અથવા તેઓ તમને એક સામાન્ય ઝાંખી આપે શકો છો, પરંતુ તેમને કેટલાક ખૂબ જબરજસ્ત છે.

542
00:51:17,640 --> 00:51:22,220
એફ સ્કેન એફ જેમ, પણ. તે તમને આ તમામ કાર્યોને માટે માહિતી આપે છે,

543
00:51:22,220 --> 00:51:28,120
અને રેખા 1 નીચે અહીં કહેવું થાય છે, "એફ સ્કેન એફ શબ્દમાળા બિંદુ અથવા સ્ટ્રીમ પરથી વાંચે છે."

544
00:51:28,120 --> 00:51:32,360
પરંતુ એફ ખોલો. તેથી, અમે એફ ઓપન કેવી રીતે ઉપયોગ કરશો?

545
00:51:32,360 --> 00:51:38,470
એક કાર્યક્રમ છે કે જે ફાઇલ કરવાની જરૂર ના વિચાર I / O એ છે કે

546
00:51:38,470 --> 00:51:45,070
તમે પ્રથમ ફાઇલ સાથે તમે વસ્તુઓ કરવા માંગો છો ખોલવા જરૂર છે, અને અનાવશ્યક,

547
00:51:45,070 --> 00:51:51,220
તે ફાઇલ માંથી વસ્તુઓ વાંચી અને તેમની સાથે સામગ્રી નથી.

548
00:51:51,220 --> 00:51:55,350
વધુ ખુલ્લું છે, આપણે શું કરવા માટે ફાઇલ ખોલવા વાપરો.

549
00:51:55,350 --> 00:52:04,190
આ વસ્તુ અમે પાછા, જેથી ફાઈલ શું અમે ખોલવા માંગો છો, તો અમને આપે છે -

550
00:52:04,190 --> 00:52:11,970
અહીં તેને "/ વપરાશકર્તા / શેર / dict / શબ્દો." કહે છે

551
00:52:11,970 --> 00:52:16,740
આ ફાઈલ કે અમે ખોલવા માંગો છો છે, અને અમે તેને ખોલવા માંગો છો -

552
00:52:16,740 --> 00:52:21,440
અમે સ્પષ્ટપણે ઉલ્લેખ કરે છે કે અમે તેને વાંચવામાં અથવા જો અમે ખોલવા માંગો છો તે લખવા માટે ખોલવા માંગો છો છે.

553
00:52:21,440 --> 00:52:26,490
ત્યાં સંયોજનો અને સામગ્રી એક દંપતી છે, પરંતુ અમે વાંચન માટે આ ખોલવા માંગો છો.

554
00:52:26,490 --> 00:52:29,380
અમે ફાઇલ વાંચવામાં કરવા માંગો છો.

555
00:52:29,380 --> 00:52:34,290
તેથી આ વળતર શું કરે છે? એ એક ફાઈલ તારો (*) આપે છે,

556
00:52:34,290 --> 00:52:37,260
અને હું માત્ર ચલ એફ બધું છે, તેથી * બતાવીશું,

557
00:52:37,260 --> 00:52:40,840
ફરી, તે નિર્દેશક છે, પરંતુ અમે પોઇન્ટર સાથે કામ કરવા નથી માંગતા.

558
00:52:40,840 --> 00:52:46,470
તમે એફ લાગે છે કે, એફ હવે ચલ તમે ફાઈલ પ્રતિનિધિત્વ ઉપયોગ જઈ રહ્યાં છો છે.

559
00:52:46,470 --> 00:52:49,850
તેથી જો તમે ફાઇલને વાંચવામાં કરવા માંગો છો, તો તમે એફ માંથી વાંચી શકાય છે.

560
00:52:49,850 --> 00:52:54,820
જો તમે ફાઈલ બંધ કરવા માંગો છો, તો તમે એફ બંધ કરો.

561
00:52:54,820 --> 00:53:00,350
તેથી કાર્યક્રમ ઓવરને અંતે જ્યારે અમે અનાવશ્યક ફાઇલ બંધ કરવા માંગો છો, તો આપણે શું કરવું જોઈએ?

562
00:53:00,350 --> 00:53:06,750
અમે એફ બંધ કરવા માંગો છો.

563
00:53:06,750 --> 00:53:12,600
તેથી હવે છેલ્લા ફાઈલ કાર્ય કે અમે ઉપયોગ કરવા માંગો છો જઈ રહ્યાં છો f, એફ સ્કેન એફ સ્કેન છે.

564
00:53:12,600 --> 00:53:20,930
અને કરે છે જે શું છે તે એક સાથે મેળ પેટર્ન શોધી ફાઈલ પર સ્કેન કરે છે.

565
00:53:20,930 --> 00:53:39,100
માણસ અહીં પાનું અંતે છીએ, અમે પૂર્ણાંક એફ સ્કેન એફ જુઓ, હવે માટે વળતર કિંમત અવગણો.

566
00:53:39,100 --> 00:53:45,230
પ્રથમ દલીલ ફાઈલ * સ્ટ્રીમ છે તેથી, પ્રથમ દલીલ અમે પસાર કરવા માંગો છો જઈ રહ્યાં છો એફ છે.

567
00:53:45,230 --> 00:53:47,900
અમે એફ પર સ્કેન કરી રહ્યા છીએ.

568
00:53:47,900 --> 00:53:53,680
બીજી દલીલ બંધારણમાં શબ્દમાળા છે.

569
00:53:53,680 --> 00:53:58,310
હું તમને એક ફોર્મેટ સ્ટ્રિંગ હમણાં આપશે.

570
00:53:58,310 --> 00:54:05,180
મને લાગે છે કે અમે કહે, 127s \ n એ, કે જે બિનજરૂરી છે ઘણો થાય છે.

571
00:54:05,180 --> 00:54:12,490
કે ફોર્મેટ સ્ટ્રિંગ શું છે આ વિચાર છે, તમે સ્કેન એફ ઓફ પ્રિન્ટ એફ ના વિરુદ્ધ તરીકે વિચાર કરી શકો છો.

572
00:54:12,490 --> 00:54:17,160
તેથી પ્રિન્ટ એફ, પ્રિન્ટ એફ અમે પણ ફોર્મેટ પેરામીટર આ પ્રકારના ઉપયોગ કરો છો,

573
00:54:17,160 --> 00:54:25,000
પરંતુ પ્રિન્ટ એફ શું આપણે કરી રહ્યા છે - ચાલો સમકક્ષ જુઓ.

574
00:54:25,000 --> 00:54:32,550
તેથી એફ છાપો, અને ત્યાં ખરેખર પણ એફ એફ પ્રિન્ટ, જ્યાં પ્રથમ દલીલ એફ પ્રયત્ન રહ્યું છે છે.

575
00:54:32,550 --> 00:54:40,980
જ્યારે તમે એફ છાપો, અમે કંઈક જેમ કહેવું શકે છે, "પ્રિન્ટ 127s \ n" અને પછી તો અમે તેને કેટલીક શબ્દમાળા પસાર કરવા માટે,

576
00:54:40,980 --> 00:54:44,050
તે આ છે અને પછી એક નવી લાઇન શબ્દમાળા છાપી રહ્યું છે.

577
00:54:44,050 --> 00:54:49,690
127 અર્થ શું, હું ખૂબ ખાતરી છું, પરંતુ હું મારી જાતે તે ક્યારેય પ્રતિબંધિત કરી છે,

578
00:54:49,690 --> 00:54:52,470
તમે પણ પ્રિન્ટ એફ માં '127 'કહેવું નથી જરૂર,

579
00:54:52,470 --> 00:54:57,090
પરંતુ તેનો અર્થ શું પ્રથમ 127 અક્ષરો છાપી છે.

580
00:54:57,090 --> 00:54:59,350
તેથી હું ખૂબ ખાતરી કરો કે કેસ છે છું. તમે તે માટે Google કરી શકો છો.

581
00:54:59,350 --> 00:55:03,000
પરંતુ આગામી એક હું લગભગ હકારાત્મક તે અર્થ છે છું.

582
00:55:03,000 --> 00:55:08,880
તેથી આ પ્રથમ 127 અક્ષરો, નવી લાઇન દ્વારા અનુસરવામાં છાપો.

583
00:55:08,880 --> 00:55:14,680
એફ સ્કેન હવે એફ, તેના બદલે એક ચલ જોઈ અને તે પ્રિન્ટિંગ,

584
00:55:14,680 --> 00:55:22,620
તે કેટલાક શબ્દમાળા જોવા, અને ચલ માં પેટર્ન સ્ટોર ચાલી રહ્યું છે.

585
00:55:22,620 --> 00:55:26,360
ચાલો ખરેખર એક અલગ ઉદાહરણમાં સ્કેન એફ વાપરો.

586
00:55:26,360 --> 00:55:31,670
તેથી આપણે કહેવું અમે કેટલીક પૂર્ણાંક હતી, એક્સ = 4,

587
00:55:31,670 --> 00:55:41,110
અને અમે બનાવવામાં શબ્દમાળા બનાવવા માંગો - જે શબ્દમાળા બનાવવા માંગો

588
00:55:41,110 --> 00:55:44,250
હતી, જેમ કે આ ઉપર ઘણી પાછળથી આવશે,

589
00:55:44,250 --> 00:55:49,020
કંઈક કે 4.jpg જેમ જ છે.

590
00:55:49,020 --> 00:55:51,870
તેથી આ એક કાર્યક્રમ છે કે જ્યાં તમે રકમ કાઉન્ટર હશે શકો છો,

591
00:55:51,870 --> 00:55:56,420
હું સામે સરવાળો, અને તમે છબીઓ સમૂહ સાચવવા માંગો છો.

592
00:55:56,420 --> 00:56:02,430
જેથી તમે i.jpg, જ્યાં i તમારા લૂપ કેટલાક પુનરાવૃત્તિ છે સાચવવા માંગો છો.

593
00:56:02,430 --> 00:56:05,500
તેથી અમે કેવી રીતે કે JPEG માટે આ શબ્દમાળાને કરો છો?

594
00:56:05,500 --> 00:56:11,720
જો તમે 4.jpg છાપો માગતા હતા, અમે ફક્ત પ્રિન્ટ એફ,% d.jpg કહેવું શકે છે,

595
00:56:11,720 --> 00:56:14,410
અને પછી તે JPEG માટે છાપો કરશે.

596
00:56:14,410 --> 00:56:20,050
પરંતુ જો આપણે માટે શબ્દમાળા 4.jpg સાચવવા માંગો છો, અમે સ્કૅન એફ વાપરો.

597
00:56:20,050 --> 00:56:30,860
શબ્દમાળા ઓ તેથી - ખરેખર અમે can't - પાત્ર, ઘરનાં પરચૂરણ કામો ઓ, ચાલો 100 જાઓ.

598
00:56:30,860 --> 00:56:35,400
તેથી હું માત્ર 100 અક્ષરો કેટલાક એરે જાહેર

599
00:56:35,400 --> 00:56:39,830
અને કે અમે શું ખચીત કે JPEG સ્ટોર કરી સાઇન જઈ રહ્યાં છો

600
00:56:39,830 --> 00:56:47,920
તેથી અમે સ્કૅન એફ ઉપયોગ જઈ રહ્યાં છો, અને બંધારણ, અમે કેવી રીતે% d.jpg કહેવું કરશે

601
00:56:47,920 --> 00:56:54,980
ક્રમમાં 4.jpg છાપો માટે, આ ફોર્મેટમાં% d.jpg પ્રયત્ન રહ્યું છે.

602
00:56:54,980 --> 00:57:04,020
તેથી બંધારણ% d.jpg, અમે સાથે% d બદલવા માંગો છો તે x છે,

603
00:57:04,020 --> 00:57:06,590
અને હવે અમે તે શબ્દમાળા ક્યાંક સ્ટોર કરવાની જરૂર છે.

604
00:57:06,590 --> 00:57:12,500
અને જ્યાં અમે આ શબ્દમાળા સંગ્રહવા જઈ રહ્યાં છો એરે ઓ છે.

605
00:57:12,500 --> 00:57:21,640
તેથી કોડ છે, ઓ આ વાક્ય પછી, જો આપણે એફ, આ ચલ s માંથી% s છાપો,

606
00:57:21,640 --> 00:57:26,280
તે 4.jpg છાપી રહ્યું છે.

607
00:57:26,280 --> 00:57:38,930
તેથી એફ સ્કેન એફ સ્કેન એફ જેમ જ હવે તે આ ફાઇલ પર જોઈ છે, અપવાદરૂપે છે

608
00:57:38,930 --> 00:57:43,600
શું માટે s માં સંગ્રહે છે.

609
00:57:43,600 --> 00:57:46,160
કે છેલ્લા દલીલ શું હોવું રહ્યું છે.

610
00:57:46,160 --> 00:57:54,170
બંને ફોર્મેટ પ્રમાણે નીચે પ્રયાસ કર્યો કાર્યો સ્કેન ની "સ્કેન એફ કુટુંબ - અમે સંગ્રહવા માંગો છો.

611
00:57:54,170 --> 00:58:02,450
જો કોઈપણ સ્થાન પોઇન્ટ સંગ્રહાયેલ છે તમે પાછા શકે છે - "

612
00:58:02,450 --> 00:58:12,910
ના, અમે સારી પણ હોઈ શકે છે. દો મને એક બીજા માટે વિચારો.

613
00:58:12,910 --> 00:58:26,350
આ હેક શું કાર્ય જે કરે છે - જેથી સ્કેન એફ નથી?

614
00:58:26,350 --> 00:58:31,650
તેથી સ્કેન એફ એક પૂર્ણાંક લેવા અને કોઈ jpg નથી જઈ રહ્યું છે.

615
00:58:31,650 --> 00:58:43,490
તે [mumbles] જવાની છે.

616
00:58:43,490 --> 00:58:49,360
શબ્દમાળા પૂર્ણાંક સી માં પૂર્ણાંક ચલ સાચવો

617
00:58:49,360 --> 00:58:55,940
આ ચલ શું છે, અથવા આ કાર્ય શું છે જેને?

618
00:58:55,940 --> 00:59:04,950
હા. That's - હા. તેથી હું તમને વ્યાખ્યાયિત કરવામાં આવ્યો હતો તે પહેલાં ઓ પ્રિન્ટ એફ હતી,

619
00:59:04,950 --> 00:59:09,820
જે - જે વધુ સમજદારીવાળું છે, શા માટે હું જણાવ્યું હતું કે તે ખૂબ પ્રિન્ટ એફ જેવું હતું બનાવે છે.

620
00:59:09,820 --> 00:59:14,700
સ્કેન એફ હજુ પ્રિન્ટ એફ જેવા પ્રકારની હોય છે, પરંતુ ઓ પ્રિન્ટ એફ તેને સ્કેન ઉપર રહ્યું છે

621
00:59:14,700 --> 00:59:17,510
અને ચલો બદલો અને હવે તે એક શબ્દમાળા માં સંગ્રહે.

622
00:59:17,510 --> 00:59:19,620
તેના બદલે તે પ્રિન્ટિંગ, તો તે એક શબ્દમાળા માં સંગ્રહે છે.

623
00:59:19,620 --> 00:59:25,070
જેથી સંપૂર્ણ અવગણના કરે છે. તમે હજુ પણ પ્રિન્ટમાં એફ જેમ તરીકે ફોર્મેટ specifier વિચાર કરી શકો છો.

624
00:59:25,070 --> 00:59:34,510
તેથી હવે, જો આપણે 4.jpg વસ્તુ કરવા માગતા હતા, અમે ઓ પ્રિન્ટ એફ કરવા માટે, આ એક્સ કરશે.

625
00:59:34,510 --> 00:59:38,520
તેથી સ્કેન એફ કરી છે શું - શું ને તમારા પ્રશ્નનો હશે?

626
00:59:38,520 --> 00:59:40,820
[વિદ્યાર્થી] હું માત્ર અમે શું કરીએ અધિકાર અહીં પ્રયાસ કરી રહ્યા છો પર મૂંઝવણમાં છું

627
00:59:40,820 --> 00:59:43,450
કે JPEG સાથે. તમે કે 1 વધુ સમય સમજાવે છે?

628
00:59:43,450 --> 00:59:52,710
તેથી આ હતો - તે ઓછી એફ સ્કેન હવે એફ માટે સંબંધિત છે; આસ્થાપૂર્વક, તે પાછા માર્ગ અમુક પ્રકારનો ટાઇ થશે.

629
00:59:52,710 --> 01:00:02,240
પરંતુ હું શરૂઆતમાં બતાવવા માટે ઇરાદો કરવામાં આવ્યો હતો કે શું હતું - આ ખરેખર સીધા આ [સંબંધિત? F5]

630
01:00:02,240 --> 01:00:08,520
તમે ઓ પ્રિન્ટ એફ ઉપયોગ કરી રહ્યા છીએ, જ્યાં કહેવું, અમે 100 ઈમેજો છે,

631
01:00:08,520 --> 01:00:13,630
અને તમે 1.jpg ઈમેજ, 2.jpg, 3.jpg વાંચી માંગો છો.

632
01:00:13,630 --> 01:00:21,520
તેથી ક્રમમાં છે કે જે કરવું હોય, તો તમે એફ ઓપન કરવાની જરૂર છે, અને તે પછી તમે શબ્દમાળા કે જે તમે ખોલવા માંગો છો પાસ હોય છે.

633
01:00:21,520 --> 01:00:30,020
તેથી અમે 1.jpg ખોલવા માંગો છો; ક્રમમાં શબ્દમાળા કે 1.jpg છે બનાવવા માટે,

634
01:00:30,020 --> 01:00:37,660
અમે ઓ કરવું% ની પ્રિન્ટ એફ d.jpg-અમે પૂર્ણાંક હું = 0 માટે ન હતી.

635
01:00:37,660 --> 01:00:46,580
હું 40 <, હું + +.

636
01:00:46,580 --> 01:00:51,130
તેથી ઓ પ્રિન્ટ એફ% i ની d.jpg.

637
01:00:51,130 --> 01:00:56,320
તેથી આ વાક્ય પછી, હવે ચલ અથવા એરે ઓ 1.jpg માટે જઈ રહ્યો છે.

638
01:00:56,320 --> 01:01:10,610
અથવા, 0.jpg, 1.jpg, 2.jpg. અને તેથી અમે, બાદમાં ખોલો, વાંચન માટે દરેક ઇમેજ કરી શકો છો.

639
01:01:10,610 --> 01:01:19,550
જેથી છે ઓ શું છાપવું એફ કરે છે. શું તમે જુઓ ઓ શું એફ હવે કરવાનું છે છાપી?

640
01:01:19,550 --> 01:01:25,720
[વિદ્યાર્થી] ઠીક છે, તેથી તેને લઈ રહ્યો છે - તે શબ્દમાળા બનાવે છે, something.jpg, અને પછી તેને સંગ્રહ કરે છે.

641
01:01:25,720 --> 01:01:30,360
હા. તે બનાવે છે - આ એ બીજા ફોર્મેટ સ્ટ્રિંગ સ્કેન એફ અને પ્રિન્ટ એફ જેમ જ છે,

642
01:01:30,360 --> 01:01:37,530
જ્યાં બીજી દલીલ તેને ચલો બધા દાખલ, ઓ તરીકે હું વિરોધ હોઈ શકે છે.

643
01:01:37,530 --> 01:01:42,280
કદાચ - મારા કહેવાનો અર્થ છે કે કેસ છે. પરંતુ ગમે દલીલો ક્રમ છે.

644
01:01:42,280 --> 01:01:45,440
તે ફોર્મેટ સ્ટ્રિંગ માં ચલો બધા દાખલ રહ્યું છે

645
01:01:45,440 --> 01:01:52,250
અને પછી અમારી બફર માં સંગ્રહિત; આપણે કહી છે કે બફર, તે જ્યાં અમે શબ્દમાળા સ્ટોર કરી રહ્યાં છે.

646
01:01:52,250 --> 01:02:00,750
તેથી અમે ઓ ની અંદર સંગ્રહિત છે યોગ્ય રીતે ફોર્મેટ સ્ટ્રિંગ,% d 4 સાથે બદલાઈ હતી.

647
01:02:00,750 --> 01:02:08,080
[વિદ્યાર્થી] તેથી જો અમે આ કર્યું, જે ચલ માત્ર તેમની સોંપણી થઈ જતાં એફ છે?

648
01:02:08,080 --> 01:02:18,110
હા. તેથી અમે આમ પહેલાં મૂળ એફ બંધ કરીશું.

649
01:02:18,110 --> 01:02:22,810
પરંતુ - અને પછી પણ, જો ત્યાં એક એફ અહીં ખોલી શકતા હતા, પછી અમે કહી જરૂર -

650
01:02:22,810 --> 01:02:29,280
યાહ. પરંતુ તે એક સો અલગ ફાઇલો ખોલવા કરશે.

651
01:02:29,280 --> 01:02:37,360
ઠીક - [વિદ્યાર્થી] પરંતુ અમે ઍક્સેસ કરવા અથવા શકશે નહીં.

652
01:02:37,360 --> 01:02:44,230
ઠીક છે. તેથી સ્કેન f, એફ સ્કેન એફ, આ જ વિચાર પ્રકારની છે,

653
01:02:44,230 --> 01:02:53,610
પરંતુ બદલે, તેના બદલે એક શબ્દમાળા માં સંગ્રહિત છે, તો તે તમને હવે જેવા વધુ છે

654
01:02:53,610 --> 01:03:02,420
એક ડંખ અને પેટર્ન છે કે જેઓ શબ્દમાળા સામે બંધબેસતા પર જવું અને ચલો માં પરિણામો સ્ટોર.

655
01:03:02,420 --> 01:03:11,290
તમે સ્કેન એફ વાપરવા માટે 4.jpg કંઈક પર પાર્સ, અને રકમ પૂર્ણાંક એક્સ માં પૂર્ણાંક 4 સ્ટોર કરી શકો છો.

656
01:03:11,290 --> 01:03:13,430
કે અમે શું સ્કેન એફ વાપરી શકો છો.

657
01:03:13,430 --> 01:03:16,300
એફ સ્કેન એફ આદેશ વાક્ય પર કે શું થઈ રહ્યું છે.

658
01:03:16,300 --> 01:03:19,200
હું ખરેખર છું ખૂબ ખાતરી કરો કે આ છે CS50 પુસ્તકાલય શું કરે છે.

659
01:03:19,200 --> 01:03:29,050
તેથી જ્યારે તમે કહી, "પૂર્ણાંક વિચાર" તે ઉપર એફ-ing સ્કેન છે - સ્કેન એફ રીતે તમે વપરાશકર્તા ઈનપુટ વિચાર છે.

660
01:03:29,050 --> 01:03:34,670
એફ સ્કેન એફ એ જ વસ્તુ કરવા જઈ રહ્યો છે પરંતુ ફાઇલનો ઉપયોગ પર સ્કેન કરે છે.

661
01:03:34,670 --> 01:03:41,090
અહીં, અમે આ ફાઇલ પર સ્કેનીંગ કરવામાં આવે છે.

662
01:03:41,090 --> 01:03:45,460
આ પેટર્ન અમે સાથે મેળ કરવાનો પ્રયાસ કરી રહ્યા કેટલાક શબ્દમાળા કે 127 અક્ષરો લાંબી છે

663
01:03:45,460 --> 01:03:48,100
નવી લાઇન દ્વારા અનુસરવામાં

664
01:03:48,100 --> 01:03:54,770
તેથી હું ખૂબ ખાતરી કરો કે અમે પણ માત્ર કહી શકે છું "ઓ સાથે મેળ ખાય," શબ્દકોશમાં થી

665
01:03:54,770 --> 01:03:57,770
અમે હોય થાય છે, અમે ખાતરી આપી રહ્યા છો, તે શબ્દ કે લાંબો છે,

666
01:03:57,770 --> 01:04:03,310
અને પણ એફ સ્કેન એફ મને લાગે છે કે, નવા વાક્ય પર કોઈ બાબત શું કરવાનું બંધ કરશે.

667
01:04:03,310 --> 01:04:06,970
પરંતુ અમે આ મેચમાં નવી લીટી સમાવો, અને કરીશું -

668
01:04:06,970 --> 01:04:13,960
[વિદ્યાર્થી] જો અમે નવી લાઇન સમાવેશ થયો ન હતો, તે શબ્દ ભાગો શોધવા માગો છો?

669
01:04:13,960 --> 01:04:22,900
દરેક - તે - શબ્દકોશ જોઈ -

670
01:04:22,900 --> 01:04:26,200
તેથી શબ્દકોશ, આ અમારી બધા જ શબ્દો છે.

671
01:04:26,200 --> 01:04:30,500
દરેક એક નવી લાઇન પર છે.

672
01:04:30,500 --> 01:04:32,510
આ સ્કેન એફ માટે આ શબ્દ બનાવ્યો રહ્યું છે.

673
01:04:32,510 --> 01:04:38,750
જો અમે નવા વાક્ય સમાવેશ થતો નથી, પછી તે શક્ય છે કે આગામી સ્કેન એફ ફક્ત નવા વાક્ય વાંચવા આવશે.

674
01:04:38,750 --> 01:04:44,180
પરંતુ નવી લાઇન સહિત પછી ફક્ત નવી લાઇન નજરઅંદાજ કરશે.

675
01:04:44,180 --> 01:04:49,440
પરંતુ અમે એક શબ્દ ભાગ ક્યારેય વિચાર છે, કારણ કે અમે હંમેશા નવા વાક્ય આવે છે, reading કોઈ બાબત શું કરશો.

676
01:04:49,440 --> 01:04:54,530
[વિદ્યાર્થી] પરંતુ જો તમારી પાસે એક શબ્દ "cissa," cissa જેવા શોધવા માટે.

677
01:04:54,530 --> 01:04:57,380
તે મળી શકશે, અને કહે છે કે તે મેચ છે?

678
01:04:57,380 --> 01:05:05,110
અહીં અમે - તેને વાંચી હશે - આ ખરેખર સારા બિંદુ છે.

679
01:05:05,110 --> 01:05:10,660
અમે વર્તમાન ક્યારેય ઉપયોગ કરી રહ્યાં છો - શબ્દ અમે શોધી રહ્યાં છો તે પ્રથમ આદેશ વાક્ય દલીલ છે.

680
01:05:10,660 --> 01:05:16,460
તેથી શબ્દમાળા શબ્દ = 1 argv.

681
01:05:16,460 --> 01:05:20,020
તેથી શબ્દમાળા અમે શોધી રહ્યાં છો તે 1 argv છે.

682
01:05:20,020 --> 01:05:23,290
અમે અમારા સ્કેન એફ તમામ ખાતે શબ્દ માટે નથી જોઈ રહ્યા છીએ.

683
01:05:23,290 --> 01:05:28,030
અમે સ્કૅન એફ સાથે કરી રહ્યા હતા શું શબ્દકોશમાં દરેક શબ્દ રહ્યો છે,

684
01:05:28,030 --> 01:05:34,320
અને પછી એક વાર અમે તે શબ્દ અમે strcmp વાપરવા માટે તેમને સરખાવવા જઈ રહ્યાં છો છે.

685
01:05:34,320 --> 01:05:39,210
અમે અમારી શબ્દ સરખાવવા જઈ રહ્યાં છો અને અમે શું માત્ર સાઇન વાંચો

686
01:05:39,210 --> 01:05:45,110
તેથી ખચીત, અમે અંત સ્કેન fs સમૂહ કરી રહ્યા છીએ

687
01:05:45,110 --> 01:05:52,130
ત્યાં સુધી તે માત્ર જેથી બને છે કે સ્કેન એફ આપશે -

688
01:05:52,130 --> 01:05:54,800
તે એક પાછા ફરવા માટે, લાંબા સમય સુધી તે એક નવો શબ્દ સાથે મેળ ખાતી છે કરશે,

689
01:05:54,800 --> 01:06:01,360
અને તે કંઈક બીજું જલદી તે શબ્દ સાથે મેળ કરવામાં નિષ્ફળ જાય છે આપશે.

690
01:06:01,360 --> 01:06:08,440
અમે સમગ્ર શબ્દકોશ પર વાંચી રહ્યા છો, લાઇન દ્વારા લીટી દરેક શબ્દ સ્ટોર આ ચલ ઓ માં.

691
01:06:08,440 --> 01:06:17,240
તો પછી અમે ઓ સાથે શબ્દ સરખામણી કરવામાં આવે છે, અને સરખામણી 0 == જો,

692
01:06:17,240 --> 01:06:21,650
strcmp માટે 0 લાવવા જો મેચ કરવામાં આવ્યું હતું બને છે.

693
01:06:21,650 --> 01:06:31,510
તેથી જો તે 0 હતો, તો પછી અમે એફ છાપી, મેળ ખાતી કરી શકો છો,

694
01:06:31,510 --> 01:06:35,370
અથવા શબ્દ કોશ છે, અથવા જે તમે એફ પ્રિન્ટ માંગો છો.

695
01:06:35,370 --> 01:06:41,450
અને પછી - અમે એફ ઉપર બંધ કરો અને ફરીથી કરવા નથી માંગતા.

696
01:06:41,450 --> 01:06:50,410
આ વસ્તુ પ્રકાર અમે કરવા માંગો છો છે, અને અમે ફક્ત શબ્દકોશ શબ્દ માટે નથી જોઈ રહ્યા છીએ.

697
01:06:50,410 --> 01:06:56,660
તેથી અમે તે કરવા માટે, જો આપણે તેમના પેટર્ન, cissa જોવા માટે માગે છે શકે છે, જેમ કે તમે પહેલાં જણાવ્યું હતું કે,

698
01:06:56,660 --> 01:07:00,260
જો અમે તે પેટર્ન જોવા માટે માગે છે, પછી તે કિસ્સામાં નિષ્ફળ જશે

699
01:07:00,260 --> 01:07:08,010
જે ખરેખર એક શબ્દ નથી, પરંતુ એક શબ્દકોશમાં શબ્દો તેને તે ધરાવે છે કારણ કે.

700
01:07:08,010 --> 01:07:13,560
તેથી તે આ શબ્દ સાથે મેળ ખાય, પરંતુ આ જ શબ્દ ઉપગણ એક શબ્દ નથી.

701
01:07:13,560 --> 01:07:17,250
પરંતુ અમે કેવી રીતે ઉપયોગ કરી રહ્યાં છો તે નથી; આપણે દરેક શબ્દ વાંચન કરી રહ્યાં છો

702
01:07:17,250 --> 01:07:19,740
અને પછી શબ્દ અમે તે શબ્દ સાથે હોય સરખામણી કરો.

703
01:07:19,740 --> 01:07:25,780
તેથી અમે હંમેશા સંપૂર્ણ શબ્દો સરખામણી કરી રહ્યા છો.

704
01:07:25,780 --> 01:07:29,620
હું બહાર અંતિમ ઓપ ઉકેલો પછી પણ મોકલી શકો છો.

705
01:07:29,620 --> 01:07:32,050
આ લગભગ અધિકાર જવાબ પ્રકારની છે, મને લાગે છે.

706
01:07:32,050 --> 01:07:34,720
[વિદ્યાર્થી ટિપ્પણી દુર્બોધ]

707
01:07:34,720 --> 01:07:40,870
ઓહ, હું કે છૂટકારો મળ્યો તે પહેલાં? ચાર ઓ, હું માનું અમે 127 કહ્યું - હું ભૂલી જાઓ સૌથી મોટો શું છે.

708
01:07:40,870 --> 01:07:44,100
અમે હમણાં જ 128 કરીશ; જેથી હવે ઓ લાંબા પર્યાપ્ત છે.

709
01:07:44,100 --> 01:07:46,570
અમે કંઈપણ પ્રિન્ટ કરવાની જરૂર નથી.

710
01:07:46,570 --> 01:07:56,440
અમે પણ અમારી ફાઈલ બંધ માંગો છો જઈ રહ્યાં છો, અને તે યોગ્ય જવાબ વિશે પ્રયત્ન કરીશું.

711
01:07:56,440 --> 01:07:59,440
CS50.TV