1
00:00:00,000 --> 00:00:01,940
[Powered by Google Translate] [Walkthrough - પ્રોબ્લેમ 2 સેટ]

2
00:00:01,940 --> 00:00:04,130
[Zamyla ચાન - હાર્વર્ડ યુનિવર્સિટી]

3
00:00:05,170 --> 00:00:07,490
[આ CS50 છે. CS50.TV]

4
00:00:07,490 --> 00:00:10,750
અધિકાર છે. હેલો, દરેકને, અને 2 Walkthrough સ્વાગત છે.

5
00:00:10,750 --> 00:00:14,330
પ્રથમ, હું તમને 1 pset ક્રમે માટે અભિનંદન કરવા માંગો છો.

6
00:00:14,330 --> 00:00:18,140
હું જાણું છું કે તે તમને કેટલાક માટે થોડી કઠિન રહી શકે છે,

7
00:00:18,140 --> 00:00:20,460
તમારા પ્રથમ કમ્પ્યુટર પ્રોગ્રામ છે જે તમે લખ્યું કરવામાં આવી છે શકે છે,

8
00:00:20,460 --> 00:00:24,500
પરંતુ ફક્ત આ ઓવરને અંતે કે યાદ રાખો કે, જ્યારે તમે સત્ર ઓવરને અંતે પાછળ જુઓ,

9
00:00:24,500 --> 00:00:29,820
તમે 1 pset જોવા અને તમે કહી, "અરે, હું જ આ કરી શકે છે કે જેઓ 5 મિનિટમાં." પડશે પડશે

10
00:00:29,820 --> 00:00:35,700
તેથી જાણો છો અને વિશ્વાસ કરો કે આ ઓવરને અંતે તમે ચોક્કસપણે 1 pset શોધવા એકદમ સરળ પડશે.

11
00:00:35,700 --> 00:00:40,640
પરંતુ હવે તે એક મોટી સિદ્ધિ છે, અને રહ્યું કર્યું માટે બદલ ધન્યવાદ.

12
00:00:40,640 --> 00:00:44,010
હવે ઝડપી નોંધ, પણ પહેલાં અમે walkthrough ના માંસ માં મેળવો.

13
00:00:44,010 --> 00:00:48,340
હું માત્ર એક ઝડપી નોંધ બનાવવા માંગો છો કે હું ક્યારેક પૂરતો સમય નથી

14
00:00:48,340 --> 00:00:52,500
આ વૉકથ્રૂઝ દરમ્યાન સમસ્યા સેટ કરવાથી દરેક એક માર્ગ મારફતે પસાર થવા માટે

15
00:00:52,500 --> 00:00:56,140
અને તેના બદલે માત્ર કદાચ અમલીકરણ 1 અથવા 2 પ્રકારની પર કેન્દ્રિત છે,

16
00:00:56,140 --> 00:00:57,750
માર્ગો કે જે તમે આ કરી શકે.

17
00:00:57,750 --> 00:01:01,970
પરંતુ તે માટે કહે છે કે તમે તેને બીજી રીતે કરવાથી પ્રતિબંધિત છે નથી.

18
00:01:01,970 --> 00:01:05,980
ઘણી વાર, કોમ્પ્યુટર વિજ્ઞાન સાથે, વસ્તુઓ કરવાથી અસંખ્ય રીતે,

19
00:01:05,980 --> 00:01:12,190
અને તેથી નિશ્ચિતપણે ઉકેલ વિવિધ પ્રકાર કરતાં હું પ્રસ્તુત થઇ શકે છે ઉપયોગ મફત લાગે.

20
00:01:12,190 --> 00:01:14,520
[2 pset: ક્રિપ્ટો - Zamyla ચાન - zamyla@cs50.net]

21
00:01:14,520 --> 00:01:17,160
[Pset2 - 0. પ્રશ્નો એક વિભાગ - 1. સીઝર - 2. Vigenere]

22
00:01:17,160 --> 00:01:20,650
અધિકાર છે. તેથી સમસ્યા 2 સેટ: ક્રિપ્ટો એક મજા છે.

23
00:01:20,650 --> 00:01:24,500
ફરીથી, દરેક pset સાથે તમે પ્રશ્નો વિભાગ સાથે શરૂ કરી શકશો

24
00:01:24,500 --> 00:01:29,600
કે તમારા વિભાગો તમારા સોંપાયેલ શિક્ષણ સાથી સાથે હાથ ધરવામાં આવે બનશે.

25
00:01:29,600 --> 00:01:31,670
અમે walkthrough પર આ પસાર ન જવું છે,

26
00:01:31,670 --> 00:01:35,100
પરંતુ તેઓ ચોક્કસપણે તમને મદદ કરશે pset પૂર્ણ કરો.

27
00:01:35,100 --> 00:01:38,100
જેથી સમસ્યા સેટ પ્રથમ ભાગ સીઝર છે.

28
00:01:38,100 --> 00:01:43,470
અને તેથી સીઝર કોઇને તમે પૂર્ણાંક સાથે કી પસાર થશે,

29
00:01:43,470 --> 00:01:48,420
અને તમે લખાણ એક શબ્દમાળા કે તેઓ તમને પૂરી પાડે છે એન્ક્રિપ્ટ કરશે

30
00:01:48,420 --> 00:01:50,670
અને તેમને આપી પાછા એનક્રિપ્ટ થયેલ વસ્તુ.

31
00:01:50,670 --> 00:01:56,050
જો કોઈને અ ક્રિસમસ સ્ટોરી જોયા, ત્યાં ત્યાં છે કે એક ઉદાહરણ છે.

32
00:01:56,050 --> 00:01:59,090
પછી સમસ્યા સેટ બીજો ભાગ Vigenere છે,

33
00:01:59,090 --> 00:02:01,790
જે વધુ આધુનિક એનક્રિપ્શન પદ્ધતિ છે.

34
00:02:01,790 --> 00:02:05,640
અને તેથી અમે લખાણ એક ટુકડો ચિહ્નિત કરો જઈ રહ્યાં છો,

35
00:02:05,640 --> 00:02:09,600
તેના બદલે માત્ર એક પૂર્ણાંક સાથે સિવાય, અમે ખરેખર તેને બેવડી જઈ રહ્યાં છો

36
00:02:09,600 --> 00:02:13,340
મુખ્ય શબ્દ છે કે જેને વપરાશકર્તા અમને પૂરી પાડે છે સાથે.

37
00:02:16,270 --> 00:02:22,090
ઠીક છે, જેથી શોધો આજે પ્રથમ સાધન વાસ્તવમાં ઉપકરણ અપડેટ કરી રહ્યું છે.

38
00:02:22,090 --> 00:02:26,430
ચર્ચા બોર્ડ પર અમે વસ્તુઓ જેમ જુઓ, "શા માટે? આ કામ નથી મળશે"

39
00:02:26,430 --> 00:02:28,110
"50 વર્ક શા સબમિટ નથી?"

40
00:02:28,110 --> 00:02:31,830
અને ઘણી વખત ઉકેલ ખરેખર ફક્ત તમારા ઉપકરણ અપડેટ કરો.

41
00:02:31,830 --> 00:02:36,730
અને તેથી જો તમે ફક્ત તમારા ઉપકરણ sudo માટે yum-y માં ટર્મિનલ વિન્ડોમાં ચલાવો -

42
00:02:36,730 --> 00:02:40,040
કે જે હા કહેતા ધ્વજ છે, બધું જ સુધારો - સુધારા,

43
00:02:40,040 --> 00:02:42,280
પછી તમારા ઉપકરણ જો જરૂર હોઈ અપડેટ કરવામાં આવશે.

44
00:02:42,280 --> 00:02:46,960
અને જો તમે પહેલાથી જ સાધન સૌથી તાજેતરનું સંસ્કરણ પર નથી નુકસાન નથી.

45
00:02:46,960 --> 00:02:51,280
પછી તે માત્ર કોઇ નવા સુધારાઓ ઉપલબ્ધ કહે અને તમે સાથે કામ ચાલુ રાખી શકો છો.

46
00:02:51,280 --> 00:02:55,800
પરંતુ આ સારૂં છે પણ દર વખતે કે તમે ઉપકરણ ખોલી ચલાવો

47
00:02:55,800 --> 00:02:57,140
કારણ કે અમે હજી પણ ઘણો -

48
00:02:57,140 --> 00:03:00,320
તે ઉપકરણ માં સુધારવા - ક્યારેક જો અમે ભૂલ આવી.

49
00:03:00,320 --> 00:03:03,180
જેથી ખાતરી કરો કે તમે ઉપકરણ એકદમ આવૃત્તિ હોય કરો

50
00:03:03,180 --> 00:03:07,710
સ્કોર અને તે ત્યાં સુધારો.

51
00:03:07,710 --> 00:03:14,360
અધિકાર છે. તેથી અમે અક્ષરો સાથે વ્યવહાર કરી રહ્યાં છે અને બદલાતી, વસ્તુઓ enciphering,

52
00:03:14,360 --> 00:03:20,410
અમે ખરેખર અમારી ASCII ચાર્ટ સાથે સારા મિત્રો બની ગયા માંગો છો જઈ રહ્યાં છો.

53
00:03:20,410 --> 00:03:24,350
ત્યાં અનેક મુદ્દાઓ પર ઓનલાઇન છે, જો તમે શોધો. કદાચ તમારા પોતાના પણ બનાવે છે.

54
00:03:24,350 --> 00:03:29,950
હકીકતે, દરેક અક્ષર અને દરેક નંબર અને દરેક પાત્ર સાથે

55
00:03:29,950 --> 00:03:32,210
ત્યાં તેમની સાથે સંકળાયેલ સંખ્યા છે,

56
00:03:32,210 --> 00:03:38,670
અને તેથી તે સારું છે કે જે વાસ્તવિક પત્ર સાથે તેમના ASCII કિંમતો જુઓ.

57
00:03:38,670 --> 00:03:42,310
જેનાથી તમે સમસ્યા સેટ કરવામાં મદદ કરશે.

58
00:03:42,310 --> 00:03:45,750
એક વસ્તુ છે કે જે ખરેખર મને આ સમસ્યા સેટ મદદ કરી વાસ્તવમાં તે પ્રિન્ટ આઉટ થયો,

59
00:03:45,750 --> 00:03:48,380
અને હું પસાર થઇ રહ્યા હતા, હું ખરેખર તેના પર દોરવા માંગો છો,

60
00:03:48,380 --> 00:03:51,150
લખો, "જો આ ત્યાં જવા માટે છે, તો પછી ..."

61
00:03:51,150 --> 00:03:55,270
પ્રકારની તેના પર દોરે છે અને તેને માર્ક અપ, તમારા ASCII ટેબલ સાથે શ્રેષ્ઠ મિત્રો બને છે.

62
00:03:57,240 --> 00:04:00,750
તો પછી અમે અમારી નિકાલ ખાતે થોડા અન્ય સાધનો હોય છે.

63
00:04:00,750 --> 00:04:03,750
આ જગ્યાએ સમય વાસ્તવમાં તેમની ઇનપુટ તમામ માટે વપરાશકર્તાને પૂછવાની

64
00:04:03,750 --> 00:04:05,230
અમે ભેગા કરવા જઇ રહ્યા છો.

65
00:04:05,230 --> 00:04:06,880
અમે તેમને કેટલાક ઇનપુટ માટે પૂછવા માટે જઈ રહ્યાં છો,

66
00:04:06,880 --> 00:04:11,350
પરંતુ અમે પણ માત્ર આદેશ વાક્ય દલીલો ઉપયોગ જઈ રહ્યાં છો.

67
00:04:11,350 --> 00:04:15,600
તેથી જ્યારે તેઓ તેમના કાર્યક્રમ ચલાવવા માટે, સામાન્ય રીતે તમે કહો. / હેલ્લો, ઉદાહરણ તરીકે,

68
00:04:15,600 --> 00:04:17,310
જો તમારા કાર્યક્રમ hello.c હતી.

69
00:04:17,310 --> 00:04:22,500
પરંતુ આ જગ્યાએ સમય માત્ર આપતા જણાવ્યું છે કે, તેઓ શબ્દો, દલીલો પછીથી મૂકી શકો છો.

70
00:04:22,500 --> 00:04:27,210
અને તેથી અમે વાપરવા માટે જઈ રહ્યાં છો તેઓ જે તેમના ઇનપુટ તરીકે અમારા માટે તેમજ પસાર કરવા માટે,

71
00:04:27,210 --> 00:04:31,720
જેથી માત્ર પૂર્ણાંક માટે પૂછવાની બહાર ખસેડવા પણ આદેશ વાક્ય દલીલો મદદથી.

72
00:04:31,720 --> 00:04:36,590
અને પછી અમે એરે અને શબ્દમાળાઓ, જે અમે પુષ્કળ ઉપયોગ કરી શકશો તેમજ જાય પડશે.

73
00:04:41,460 --> 00:04:44,810
અહીં માત્ર 1 મિની ASCII ચાર્ટ એક ઉદાહરણ છે.

74
00:04:44,810 --> 00:04:48,460
હું જણાવ્યું હતું કે, દરેક અક્ષર માટે સંખ્યાબંધ અનુલક્ષે,

75
00:04:48,460 --> 00:04:52,510
અને તેથી જાતે સાથે પરિચિત થાઓ. તે હાથમાં આવશે.

76
00:04:52,510 --> 00:04:55,610
અને પછી જ્યારે અમે કેટલાક નંબરો સાથે વ્યવહાર ASCIIMath કરવાનું શરૂ -

77
00:04:55,610 --> 00:05:00,110
ઉમેરીને, તેમને બાદબાકી - તો પછી ચોક્કસપણે આ ચાર્ટ નો સંદર્ભ લો સારું.

78
00:05:02,860 --> 00:05:06,920
કંઈક કે જે તમારી સાથે ભજવ્યો હોઈ શકે છે - તેથી અહીં સીઝર સાઇફરનો એક ઉદાહરણ છે.

79
00:05:06,920 --> 00:05:11,190
તે માત્ર એક ચક્ર છે. આવશ્યકપણે, ત્યાં એક બાહ્ય મૂળાક્ષર છે અને પછી ત્યાં આંતરિક મૂળાક્ષરો છે.

80
00:05:11,190 --> 00:05:15,290
તેથી ઠીક અહીં સીઝર સાઇફરનો પરંતુ 0 ની કી સાથે એક ઉદાહરણ છે.

81
00:05:15,290 --> 00:05:21,540
આવશ્યકપણે, એક એક સાથે સંકળાયેલુ છે, બી બી સાથે ગોઠવાયેલ છે, ઝેડ તમામ અપ માર્ગ

82
00:05:21,540 --> 00:05:26,590
પરંતુ પછી કહેવું અમે હમણાં પૂરતું 3 એક કી, માગે છે.

83
00:05:26,590 --> 00:05:33,280
પછી અમે આંતરિક વ્હીલ ફેરવવા કે જેથી એ હવે ડી, વગેરે સાથે ગોઠવે થશે

84
00:05:33,280 --> 00:05:35,250
અને તેથી આ અનિવાર્યપણે છે અમે શું રહ્યા છીએ.

85
00:05:35,250 --> 00:05:38,340
અમે એક ચક્ર નથી, પરંતુ અમે કરવા જઈ રહ્યાં છો શું અમારી કાર્યક્રમ બનાવવા છે

86
00:05:38,340 --> 00:05:44,490
પ્રકારની નંબરો ચોક્કસ રકમ સાથે અમારી સાથે મૂળાક્ષરમાંથી પાળી.

87
00:05:44,490 --> 00:05:48,650
જેથી હું પહેલા કહ્યું હતું કે, અમે આદેશ વાક્ય દલીલો સાથે વ્યવહાર કરવામાં જઈ રહ્યાં છો

88
00:05:48,650 --> 00:05:50,390
તેમજ પૂર્ણાંક મેળવવુ.

89
00:05:50,390 --> 00:05:55,050
જેથી માર્ગ છે કે જે વપરાશકર્તાને તમારી સીઝર કાર્યક્રમ ચાલશે કહેતા હોય છે. / સીઝર

90
00:05:55,050 --> 00:05:58,090
અને પછી તે પછી નંબર દાખલ.

91
00:05:58,090 --> 00:06:01,130
અને જે નંબર કી, જે પાળી રજૂ કરે છે,

92
00:06:01,130 --> 00:06:06,740
કેટલી વખત તમે તમારી સીઝર સાઇફર આંતરિક વ્હીલ ફરતી કરી રહ્યા છીએ.

93
00:06:06,740 --> 00:06:08,390
અને તેથી તમે અહીં એક ઉદાહરણ જુઓ.

94
00:06:08,390 --> 00:06:14,550
જો અમે અમારી સીઝર સાઇફર માં એ એલ ના અક્ષરો દાખલ કરેલ હોય,

95
00:06:14,550 --> 00:06:19,520
પછી તે ઓ દ્વારા ડી ઇનપુટ કારણ કે દર 3 ગણો બદલાયું પત્ર છે છો,

96
00:06:19,520 --> 00:06:22,080
ફક્ત ચક્ર કે હું તમને દર્શાવ્યું ઉદાહરણ જેવા હોય છે.

97
00:06:22,080 --> 00:06:25,300
તેથી પછી જો તમે દાખલ કરેલ હોય, દાખલા તરીકે, આ CS50 છે!

98
00:06:25,300 --> 00:06:27,960
પછી તેને પણ અક્ષરો તમામ ખસેડશે.

99
00:06:27,960 --> 00:06:31,040
અને તે બંને સીઝર અને Vigenere એક મહત્વપૂર્ણ વાત છે

100
00:06:31,040 --> 00:06:34,890
છે કે અમે કોઇ પણ બિન અક્ષરો અવગણો રહ્યા છીએ.

101
00:06:34,890 --> 00:06:39,160
તેથી કોઈ જગ્યાઓ, અક્ષરો, વગેરે, નંબરો, અમે તેમને જ રાખવા જઈ રહ્યાં છો.

102
00:06:39,160 --> 00:06:42,920
અમે ફક્ત આ સ્થિતિમાં અક્ષરો પાળી રહ્યા છીએ.

103
00:06:42,920 --> 00:06:45,870
જેથી તમે ચક્ર જોવા, અમે માત્ર અમને ઉપલબ્ધ અક્ષરો ધરાવે છે,

104
00:06:45,870 --> 00:06:50,150
તેથી અમે ફક્ત અક્ષરો પાળી અને અક્ષરો એનક્રિપ્ટ કરવા માંગો છો.

105
00:06:51,370 --> 00:06:56,720
પ્રથમ બાબત તેથી, તમે જોયું છે કે સમસ્યા માં સીઝર માટે વપરાશ 2 સેટ

106
00:06:56,720 --> 00:07:05,280
માટે સીઝર ચલાવો અને પછી નંબર દાખલ ત્યારે તમે તેને ટર્મિનલમાં ચાલે છે.

107
00:07:05,280 --> 00:07:10,940
તેથી અમે જરૂર શું કોઈક કે જે કી વિચાર અને તેને ઍક્સેસ છે.

108
00:07:10,940 --> 00:07:14,730
અને તેથી અમે કોઈક તેને બીજા આદેશ વાક્ય દલીલ થઈ રહ્યું છે તે જોવા માંગો છો.

109
00:07:14,730 --> 00:07:20,950
પ્રથમ એક સીઝર. / પ્રયત્ન રહ્યું છે, અને આગામી એક કી સંખ્યા હોવી રહ્યું છે.

110
00:07:22,190 --> 00:07:29,200
તેથી પહેલાં તો અમે પૂર્ણાંક મુખ્ય (રદબાતલ) અમારા સી કાર્યક્રમો શરૂ કરી હતી.

111
00:07:29,200 --> 00:07:31,790
અમે પાછા છાલ એક થોડો સ્તર માટે જઈ રહ્યાં છો

112
00:07:31,790 --> 00:07:34,720
અને ખરેખર જોશો કે તેના બદલે રદબાતલ અમારી મુખ્ય કાર્ય માટે પસાર ના

113
00:07:34,720 --> 00:07:37,920
અમે ખરેખર 2 પરિમાણો સાથે કામ કરીએ છીએ.

114
00:07:37,920 --> 00:07:44,070
અમે એક argc નામવાળી પૂર્ણાંક હોય છે અને પછી શબ્દમાળાઓ ઝાકઝમાળ argv કહેવાય છે.

115
00:07:44,070 --> 00:07:46,030
તેથી argc પૂર્ણાંક છે,

116
00:07:46,030 --> 00:07:49,640
અને તે તમારા કાર્યક્રમ માં પસાર દલીલો સંખ્યા પ્રતિનિધિત્વ કરે છે.

117
00:07:49,640 --> 00:07:53,590
અને પછી argv વાસ્તવમાં પસાર દલીલોને યાદી છે.

118
00:07:53,590 --> 00:08:00,820
દલીલો બધા શબ્દમાળાઓ છે, અને તેથી argv ઝાકઝમાળ, શબ્દમાળાઓ યાદી છે, જે દર્શાવે છે.

119
00:08:01,830 --> 00:08:03,990
ચાલો થોડો એરે વિશે વાત કરો.

120
00:08:03,990 --> 00:08:05,940
એરે અનિવાર્યપણે નવી માહિતી માળખું છે.

121
00:08:05,940 --> 00:08:09,660
અમે ints હોય તો અમે ડબલ્સ છે, અમે શબ્દમાળાઓ ધરાવે છે, અને હવે અમે એરે હોય છે.

122
00:08:09,660 --> 00:08:13,820
એરે માહિતી માળખાં કે સમાન પ્રકારની બહુવિધ કિંમતો પકડી શકે છે,

123
00:08:13,820 --> 00:08:18,320
જેથી અનિવાર્યપણે, પ્રકાર ગમે તમે ઇચ્છો યાદી.

124
00:08:18,320 --> 00:08:24,400
આવશ્યકપણે, જો તમે 1 ચલ તમામ પૂર્ણાંકો યાદી માગતા હતા,

125
00:08:24,400 --> 00:08:29,090
પછી તમે નવા ચલ છે કે જે પ્રકાર પૂર્ણાંક એરે હતું બની જશે.

126
00:08:29,090 --> 00:08:34,450
તેથી એરે શૂન્ય સૂચિત છે, જેનો અર્થ છે કે જે એરે પ્રથમ તત્વ 0 અનુક્રમણિકા છે.

127
00:08:34,450 --> 00:08:41,799
જો એરે 4 આ ઉદાહરણ તરીકે, લંબાઈ, છે, તે પછી તમારા છેલ્લા તત્વ 3 અનુક્રમણિકા પર હશે,

128
00:08:41,799 --> 00:08:44,810
1 - જે 4 છે.

129
00:08:45,940 --> 00:08:48,420
તેથી એરે બનાવવા માટે, તમે આ કંઈક આવું કરશે.

130
00:08:48,420 --> 00:08:51,440
કહો તમે ડબલ એરે માગે છે.

131
00:08:51,440 --> 00:08:56,520
આ માહિતી પ્રકાર કોઈપણ પ્રકાર માટે જોકે જાય.

132
00:08:56,520 --> 00:09:00,210
તેથી કહેવું તમે ડબલ એરે કરવા માંગો છો. કહો તો તમે તેને મેઈલબોક્સ કૉલ કરવા માંગો છો.

133
00:09:00,210 --> 00:09:04,760
જેમ તમે કોઈપણ અન્ય ડબલ પ્રારંભ કરશે,

134
00:09:04,760 --> 00:09:09,760
તમે ડબલ અને પછી નામ કહેવું, પરંતુ આ સમયે અમે ચોરસ કૌંસ મૂકી,

135
00:09:09,760 --> 00:09:13,570
અને પછી નંબર ત્યાં એરે લંબાઈ હશે.

136
00:09:13,570 --> 00:09:16,840
નોંધ કરો કે એરે આપણે ક્યારેય લંબાઈ બદલી શકતાં નથી,

137
00:09:16,840 --> 00:09:21,230
તેથી તમે હંમેશા વ્યાખ્યાયિત અને કેટલી બોક્સ પસંદ કરો છે,

138
00:09:21,230 --> 00:09:25,440
કેટલા કિંમતો તમારા એરે માટે પકડી રહ્યું છે.

139
00:09:25,440 --> 00:09:31,820
તેથી તમારા એરે માં અલગ અલગ કિંમતો સુયોજિત કરો, તો તમે આ નીચેના વાક્યરચના વાપરે જઈ રહ્યાં છો,

140
00:09:31,820 --> 00:09:33,200
કારણ કે તમે સ્લાઇડ પર જુઓ.

141
00:09:33,200 --> 00:09:37,620
તમારી પાસે મેઈલબોક્સ અનુક્રમણિકા 0 1.2 સુયોજિત થઈ જશે,

142
00:09:37,620 --> 00:09:42,180
મેઈલબોક્સ અનુક્રમણિકા 1 2.4 માટે સેટ, વગેરે

143
00:09:42,180 --> 00:09:47,910
તેથી હવે અમે એરે થોડી સમીક્ષા કરી છે, ચાલો argc અને argv પર પાછા જાઓ.

144
00:09:47,910 --> 00:09:52,220
અમે જાણીએ છીએ કે argv હવે શબ્દમાળાઓ ઝાકઝમાળ છે.

145
00:09:52,220 --> 00:09:55,080
તેથી જ્યારે વપરાશકર્તા પસાર થાય છે - કહેવું છે કે તેઓ એક કાર્યક્રમ ચલાવી રહ્યા છો -

146
00:09:55,080 --> 00:09:58,740
તેઓ કહે છે. / હેલ્લો ડેવિડ Malan,

147
00:09:58,740 --> 00:10:05,160
કાર્યક્રમ શું તમે પહેલાથી જ ખરેખર argc અને argv શું છે તેની સાથે થવું કરશે.

148
00:10:05,160 --> 00:10:07,620
તેથી તમે તે અંગે ચિંતા કરવાની જરૂર નથી.

149
00:10:07,620 --> 00:10:14,370
આ કિસ્સામાં Argc 3 કારણ કે તે 3 અલગ સ્પેશ થી અલગ શબ્દો જુએ કરશે.

150
00:10:14,370 --> 00:10:18,850
અને તેથી તે પછી આ કિસ્સામાં એરે, પ્રથમ અનુક્રમણિકા છે. / હેલ્લો હો,

151
00:10:18,850 --> 00:10:21,770
આગામી એક ડેવિડ, આગામી એક Malan.

152
00:10:21,770 --> 00:10:25,640
શું કોઇને અધિકાર દૂર શું argv વચ્ચે સંબંધ જોવા,

153
00:10:25,640 --> 00:10:28,990
 એરે, અને argc છે?

154
00:10:32,820 --> 00:10:38,090
યાહ. અમે તે માં args.c. એક ઉદાહરણ મળશે

155
00:10:38,090 --> 00:10:42,880
ચાલો જોવા જો અમે 2 વચ્ચેનો સંબંધ લાભ લઈ શકે છે.

156
00:10:42,880 --> 00:10:46,550
અહીં તમે ઉપકરણ કે મેળવી શકો છો મૂળભૂત અરજી

157
00:10:46,550 --> 00:10:49,450
માટે કેચ. ફાઇલો ખોલવા ક્યારેક Emacs.

158
00:10:49,450 --> 00:10:54,660
પરંતુ અમે gedit સાથે કામ કરવા માંગો છો જેથી તમે શું કરી શકો છો એ છે જે તમે યોગ્ય તમારા સી ફાઇલ પર ક્લિક કરી શકો છો,

159
00:10:54,660 --> 00:11:04,580
ગુણધર્મો પર જાઓ, સાથે ખોલો, અને પછી gedit, ડિફોલ્ટ તરીકે સેટ કરો પસંદ કરો,

160
00:11:04,580 --> 00:11:13,020
અને હવે તમારા કાર્યક્રમ બદલે gedit Emacs ખોલવા કરીશું.

161
00:11:14,710 --> 00:11:16,290
પરફેક્ટ.

162
00:11:17,120 --> 00:11:25,520
અહીં હું એક કાર્યક્રમ છે કે જે હું બહાર દરેક આદેશ વાક્ય દલીલ પ્રિન્ટ માંગો તો.

163
00:11:25,520 --> 00:11:32,050
ગમે તે યુઝર ઇનપુટ્સ તેથી, હું અનિવાર્યપણે તે પરત ફરી એક નવી લાઇન પર તેમને કરવા માંગો છો.

164
00:11:32,050 --> 00:11:36,710
તેથી માળખું કે અમે ઉપર કંઈક ફરી વળવું ઉપયોગ કરી શકો છો શું છે -

165
00:11:36,710 --> 00:11:40,380
કંઈક કે જે તમે કદાચ તમારા pset 1 ઉપયોગમાં લેવાતી?

166
00:11:40,380 --> 00:11:45,840
જો તમે વસ્તુઓ એક સેટ નંબર મારફતે જાઓ કરવા માંગો છો? >> લૂપ માટે [વિદ્યાર્થી].

167
00:11:45,840 --> 00:11:48,910
લૂપ છે. બરાબર. તેથી આપણે લૂપ માટે સાથે શરૂ કરો.

168
00:11:48,910 --> 00:11:56,900
અમે પૂર્ણાંક હું = 0 માટે હોય છે. ચાલો માત્ર એક પ્રમાણભૂત આરંભ ચલ સાથે શરૂ કરો.

169
00:11:56,900 --> 00:12:02,370
હું એક સમૂહ માટે શરત છોડી અને પછી કહેવું હું + +, વસ્તુઓ ત્યાં કરવા જાઉં જાઉં છું.

170
00:12:02,370 --> 00:12:04,090
અધિકાર છે.

171
00:12:04,090 --> 00:12:11,590
તેથી argv પાછા વિચારવાનો, જો argv માં કાર્યક્રમને પસાર દલીલો યાદી છે

172
00:12:11,590 --> 00:12:15,380
અને argc પ્રોગ્રામમાં દલીલો સંખ્યા છે,

173
00:12:15,380 --> 00:12:21,280
પછી તે અર્થ એ થાય કે argc અનિવાર્યપણે argv લંબાઇ, અધિકાર છે,

174
00:12:21,280 --> 00:12:28,970
કારણ કે ત્યાં argc મૂલ્ય તરીકે અનેક દલીલો તરીકે હશે આવે છે.

175
00:12:28,970 --> 00:12:35,910
તેથી જો આપણે ઉપર argv દરેક તત્વ ફરી વળવું માંગો છો,

176
00:12:35,910 --> 00:12:43,290
અમે દરેક સમયે આપેલ અનુક્રમણિકા પર argv માં ચલ ઍક્સેસ કરવા માંગો છો જઈ રહ્યાં છો.

177
00:12:43,290 --> 00:12:49,060
કે જે આ સાથે રજૂ કરી શકાય અધિકાર?

178
00:12:49,060 --> 00:12:53,430
આ અહીં ચલ આ બાબતમાં ચોક્કસ શબ્દમાળા પ્રતિનિધિત્વ

179
00:12:53,430 --> 00:12:57,030
કારણ કે તે એક શબ્દમાળા એરે છે - કે જે આપેલ અનુક્રમણિકા પર ચોક્કસ શબ્દમાળા.

180
00:12:57,030 --> 00:13:00,690
અમે શું કરવા માંગો છો, આ કિસ્સામાં અમે તેને છાપી આઉટ કરવા માંગો છો, તેથી આપણે printf કહો.

181
00:13:00,690 --> 00:13:04,680
અને હવે argv એક સ્ટ્રિંગ છે, જેથી અમે તે પ્લેસહોલ્ડર ત્યાં મૂકી કરવા માંગો છો.

182
00:13:04,680 --> 00:13:08,430
અમે હવે એક નવો માત્ર બનાવવા માટે તે સારું દેખાવું લીટી કરવા માંગો છો.

183
00:13:08,430 --> 00:13:12,530
અહીં આપણે એક માટે લૂપ છે. અમે સ્થિતિ હજુ સુધી નથી.

184
00:13:12,530 --> 00:13:20,020
તેથી હું 0 પર શરૂ થાય છે અને પછી દરેક વખતે તે આપવામાં શબ્દમાળા છાપી રહ્યું છે

185
00:13:20,020 --> 00:13:22,980
એરે કે ખાસ અનુક્રમણિકા છે.

186
00:13:22,980 --> 00:13:28,410
તેથી જ્યારે અમે બહાર એરે માં તત્વો છાપવા રોકવા માંગો છો?

187
00:13:28,410 --> 00:13:35,720
જ્યારે અમે પૂર્ણ કરી લો છો, અધિકાર? જ્યારે આપણે એરે ઓવરને પહોંચી ગયા છો.

188
00:13:35,720 --> 00:13:38,870
તેથી અમે એરે લંબાઈ ભૂતકાળ કરતાં વધી નથી માંગતા,

189
00:13:38,870 --> 00:13:43,700
અને અમે જાણીએ છીએ કે અમે પહેલાથી જ ખરેખર સક્રિય શોધવા argv લંબાઈ શું છે જરૂર નથી

190
00:13:43,700 --> 00:13:47,520
કારણ કે અમને આપવામાં આવ્યું છે તે છે, અને તે શું છે? Argc. બરાબર.

191
00:13:47,520 --> 00:13:56,640
તેથી અમે વખત આ પ્રક્રિયા argc નંબર કરવા માંગો છો.

192
00:13:56,640 --> 00:13:59,550
હું અધિકાર ડિરેક્ટરીમાં નથી.

193
00:14:02,100 --> 00:14:03,490
અધિકાર છે.

194
00:14:03,490 --> 00:14:08,990
હવે આપણે વિકલ્પોલેછે બનાવે છે. કોઈ ભૂલો છે, કે જે મહાન છે.

195
00:14:08,990 --> 00:14:11,430
તેથી આપણે માત્ર વિકલ્પોલેછે ચલાવો.

196
00:14:11,430 --> 00:14:15,130
આ શું અમને પાછા જવું છે? તે માત્ર તેને છાપી પાછા જવાનું છે.

197
00:14:15,130 --> 00:14:18,320
"તમે કાર્યક્રમમાં વિકલ્પોલેછે ઇનપુટ; હું તેને તમને પાછા આપી જાઉં છું."

198
00:14:18,320 --> 00:14:23,170
તેથી આપણે કહેવું અમે વિકલ્પોલેછે પછી foo બાર કહેવું કરવા માંગો છો.

199
00:14:23,170 --> 00:14:26,570
તેથી તે પછી તેને છાપે બહાર પાછા અમને. અધિકાર બધા?

200
00:14:26,570 --> 00:14:30,790
તેથી તમે કેવી રીતે argc અને argv ઉપયોગ કરી શકો છો એક ઉદાહરણ છે

201
00:14:30,790 --> 00:14:33,460
કે argc જાણીને argv લંબાઈ દર્શાવે છે.

202
00:14:33,460 --> 00:14:42,750
ખાતરી કરો કે તમે ક્યારેય એરે એક વપરાશ સાથે એરે લંબાઈ બહાર નથી બનાવો

203
00:14:42,750 --> 00:14:45,140
કારણ કે સી ચોક્કસપણે તમે પોકાર કરશે.

204
00:14:45,140 --> 00:14:47,560
તમે સેગ્મેન્ટેશન ક્ષતિમાં કહેવાય કંઈક મળશે,

205
00:14:47,560 --> 00:14:52,470
જે મજા, ક્યારેય મૂળભૂત કહેતા તમે કંઈક ઍક્સેસ કરવાનો પ્રયાસ કરી રહ્યાં છો

206
00:14:52,470 --> 00:14:55,000
જે અસ્તિત્વમાં નથી, તમે ને અનુલક્ષતું નથી.

207
00:14:55,000 --> 00:14:59,430
જેથી ખાતરી કરો, અને શૂન્ય ઈન્ડેક્સીંગ સાથે ખાસ કરીને, અમે નથી માંગતા -

208
00:14:59,430 --> 00:15:02,390
દાખલા તરીકે જેમ, જો આપણે 4 લંબાઈ ઝાકઝમાળ છે,

209
00:15:02,390 --> 00:15:07,240
કે એરે 4 અનુક્રમણિકા કારણ કે અમે 0 અંતે શૂન્ય અનુક્રમણિકા પર શરૂ અસ્તિત્વમાં નથી.

210
00:15:07,240 --> 00:15:11,730
તે બીજા પ્રકૃતિ આંટીઓ માટે જેમ બને છે જ્યારે આપણે 0 શરૂ કરશે.

211
00:15:11,730 --> 00:15:13,610
તેથી માત્ર કે ધ્યાનમાં રાખો.

212
00:15:13,610 --> 00:15:22,590
તમે ક્યારેય ઝાકઝમાળ છે કે જે તમારી પહોંચ બહારના છે જે ઇન્ડેક્સ ઍક્સેસ કરવા નથી માંગતા.

213
00:15:26,710 --> 00:15:32,560
તેથી અમે હવે જુઓ અમે ઍક્સેસ પ્રકારની કેવી રીતે શકો છો

214
00:15:32,560 --> 00:15:35,930
આદેશ વાક્ય દલીલો કે સાઇન પસાર થાય છે

215
00:15:35,930 --> 00:15:41,330
પરંતુ તમે શબ્દમાળા જોયું, તે argv ખરેખર એક શબ્દમાળા એરે છે.

216
00:15:41,330 --> 00:15:45,740
તેથી તે ખરેખર હજી છે, નથી એ પૂર્ણાંક છે પરંતુ સીઝર માં અમે પૂર્ણાંકો સાથે કામ કરવા માંગો છો.

217
00:15:45,740 --> 00:15:54,430
સદભાગ્યે, ત્યાં અમને માટે બનાવવામાં કાર્ય કે જે વાસ્તવમાં પૂર્ણાંક માટે શબ્દમાળા કન્વર્ટ કરી શકો છો.

218
00:15:54,430 --> 00:15:58,710
પણ અહીં અમે વપરાશકર્તા ઈનપુટ સાથે વ્યવહાર જ્યાં અમે તેમને પૂછવાની કરી રહ્યાં છે

219
00:15:58,710 --> 00:16:03,740
કી માટે અહીં ઇનપુટ માટે, તેથી અમે ખરેખર નથી અને reprompt કહેવું કરી શકો છો,

220
00:16:03,740 --> 00:16:07,840
"ઓહ, મને અન્ય પૂર્ણાંક આપવા માટે, જેમ કે, જો તે માન્ય નથી."

221
00:16:07,840 --> 00:16:10,540
પરંતુ અમે હજુ પણ યોગ્ય વપરાશ માટે તપાસ કરવાની જરૂર નથી.

222
00:16:10,540 --> 00:16:13,520
સીઝર માં તેઓ માત્ર નંબર 1 માં પસાર કરવાની પરવાનગી છે,

223
00:16:13,520 --> 00:16:18,030
અને તેથી તેઓ સીઝર. / run હોય છે અને તે પછી તેઓ તમને નંબર આપી છે.

224
00:16:18,030 --> 00:16:23,660
તેથી argc કરવા માટે અમુક ચોક્કસ નંબર છે.

225
00:16:23,660 --> 00:16:29,060
નંબર શું છે કે જો તેઓ તમને એ /. સીઝર અને પછી કી પાસે પસાર થશે?

226
00:16:29,060 --> 00:16:32,920
Argc શું છે? >> [2 વિદ્યાર્થી]. બે. >> બરાબર.

227
00:16:32,920 --> 00:16:35,490
જેથી તમે ખાતરી કરો કે argc 2 એ બનાવવા માંગો છો.

228
00:16:35,490 --> 00:16:39,620
અન્યથા તમે મૂળભૂત માટે કાર્યક્રમ ચલાવો ઇનકાર કર્યો છે.

229
00:16:39,620 --> 00:16:43,040
મુખ્ય તે કાર્ય કે પૂર્ણાંક મુખ્ય કહે છે,

230
00:16:43,040 --> 00:16:47,360
જેથી તે પછી સફળ કાર્યક્રમ ઓવરને અંતે સારી પ્રથા વળતર 0 હંમેશા અમે.

231
00:16:47,360 --> 00:16:50,840
તેથી, જો કહે, તેઓ તમને 3 આદેશ વાક્ય બદલે દલીલો 2 આપવા

232
00:16:50,840 --> 00:16:54,350
અથવા તમે 1 આપો, ઉદાહરણ માટે, પછી તમે કરીશ શું છે તમે તે ચકાસવા માટે કરવા માંગો છો પડશે

233
00:16:54,350 --> 00:16:59,900
અને પછી 1 પાછા જણાવ્યું હતું કે, ના, હું આ કાર્યક્રમ સાથે પ્રક્રિયા કરી શકતું નથી.

234
00:16:59,900 --> 00:17:03,190
[વિદ્યાર્થી] તમારા લખાણ માં જગ્યા ન હોઈ શકે. >> મને બદલ ખેદ છે?

235
00:17:03,190 --> 00:17:06,780
[વિદ્યાર્થી] આ લખાણ તમે એનક્રિપ્ટ પ્રયાસ કરી રહ્યા છો એક જગ્યા ન હોઈ શકે.

236
00:17:06,780 --> 00:17:08,480
આહ!

237
00:17:08,480 --> 00:17:11,280
લખાણ કે અમે એનક્રિપ્ટ પ્રયાસ કરી રહ્યા છો દ્રષ્ટિએ, તે વાસ્તવમાં પછી આવે છે

238
00:17:11,280 --> 00:17:13,970
જ્યારે અમે કે લખાણ આપે છે.

239
00:17:13,970 --> 00:17:18,260
તેથી હમણાં અમે આદેશ દલીલો તરીકે સ્વીકારી રહ્યાં છો તે વાસ્તવિક સંખ્યા,

240
00:17:18,260 --> 00:17:21,579
સીઝર એનક્રિપ્શન માટે વાસ્તવિક પાળી.

241
00:17:21,579 --> 00:17:27,569
[વિદ્યાર્થી] તમે 2 જરૂર શા તરીકે ફક્ત 1 argc વિરોધ? ત્યાં ચોક્કસપણે નંબર 1 છે.

242
00:17:27,569 --> 00:17:32,200
અધિકાર. કારણ શા માટે આપણે argc માટે 2 જરૂર બદલે 1

243
00:17:32,200 --> 00:17:36,260
જ્યારે તમે કાર્યક્રમ ચલાવો અને કહે છે કારણ કે છે. / સીઝર / અથવા. હેલ્લો,

244
00:17:36,260 --> 00:17:38,280
કે જે વાસ્તવમાં આદેશ વાક્ય દલીલ તરીકે ગણે છે.

245
00:17:38,280 --> 00:17:43,020
તેથી પછી તે પહેલાથી જ લઈ જાય છે અને તેથી તે પછી અમે 1 1 વધારાના inputting કરી રહ્યાં છો.

246
00:17:45,030 --> 00:17:49,440
તેથી તમે ખરેખર આદેશ વાક્ય દલીલ એક શબ્દમાળા inputting કરી રહ્યાં છો.

247
00:17:49,440 --> 00:17:52,730
તમે શું કરવા માંગો છો, સીઝર માટે અમે પૂર્ણાંક સાથે કામ કરવા માંગો છો,

248
00:17:52,730 --> 00:17:57,180
તેથી તમે આ atoi વિધેય વાપરી શકે છે.

249
00:17:57,180 --> 00:18:02,850
અને મૂળભૂત, તો તમે તેને શબ્દમાળા પાસ અને પછી તેને તમે પાછા પાછા પૂર્ણાંક કરશે

250
00:18:02,850 --> 00:18:06,070
જો તે શક્ય છે કે પૂર્ણાંક માં કે જેઓ શબ્દમાળા બનાવે છે.

251
00:18:06,070 --> 00:18:10,960
હવે યાદ જ્યારે અમે જેમ printf અથવા GetString, વસ્તુઓ સાથે કામ કરીએ છીએ,

252
00:18:10,960 --> 00:18:13,390
અમે લાઈબ્રેરીઓ કે અમને ચોક્કસ સમાવેશ થાય છે.

253
00:18:13,390 --> 00:18:19,450
જેથી શરૂઆતમાં અમે હેશ કે ટેગ ધોરણ કંઈક I / O, એચ., સાથે શરૂ કરો.

254
00:18:19,450 --> 00:18:22,430
વેલ, atoi એક તે લાઇબ્રેરીઓ અંદર નથી,

255
00:18:22,430 --> 00:18:26,600
તેથી અમે હોય તો શું છે અમે તે માટે યોગ્ય પુસ્તકાલય સમાવેશ થાય છે.

256
00:18:26,600 --> 00:18:32,720
તેથી 1 Walkthrough જ્યાં હું જાતે કાર્ય ચર્ચા પાછા યાદ અપાવે છે.

257
00:18:32,720 --> 00:18:37,110
તમે તમારા ટર્મિનલમાં માણસ લખો અને પછી એક કાર્ય નું નામ છે.

258
00:18:37,110 --> 00:18:39,720
અને તેથી કે જે તેના વપરાશ સંપૂર્ણ યાદી લાવશે,

259
00:18:39,720 --> 00:18:42,890
પરંતુ સાથે સાથે તેને આવવું પુસ્તકાલય જે મળશે.

260
00:18:42,890 --> 00:18:47,000
તેથી હું કે જે તમે છોડી atoi સાથે જાતે વિધેય વાપરી શકશો

261
00:18:47,000 --> 00:18:53,360
અને બહાર આકૃતિ પુસ્તકાલય જે તમે કરવા માટે atoi વિધેય વાપરી કરવાનો પ્રયત્ન સમાવેશ કરવાની જરૂર છે.

262
00:18:54,450 --> 00:18:57,670
તેથી અમે કી મળી છે અને હવે તેને સાદી લખાણ મેળવવામાં આવે છે,

263
00:18:57,670 --> 00:19:01,820
અને તેથી જે ખરેખર વપરાશકર્તા ઈનપુટ હોઈ શકે કે જ્યાં તમે પૂછવા રહ્યું છે.

264
00:19:01,820 --> 00:19:05,540
અમે GetInt અને GetFloat સાથે સંકળાયેલા છે, અને તેથી જ દિશામાં

265
00:19:05,540 --> 00:19:07,670
અમે GetString સાથે વ્યવહાર કરવામાં જઈ રહ્યાં છો.

266
00:19:07,670 --> 00:19:12,440
પરંતુ આ કિસ્સામાં અમે કોઇપણ ડુ નથી જરૂર છે જ્યારે અથવા તો જ્યારે આંટીઓ તપાસવા માટે.

267
00:19:12,440 --> 00:19:14,480
GetString ચોક્કસપણે અમને શબ્દમાળા આપશે,

268
00:19:14,480 --> 00:19:17,630
અને અમે એનક્રિપ્ટ ગમે તે વપરાશકર્તા અમને આપે જઈ રહ્યાં છો.

269
00:19:17,630 --> 00:19:23,770
તેથી તમે ધારણ કરી શકે છે કે આ વપરાશકર્તા ઇનપુટ શબ્દમાળાઓ તમામ યોગ્ય છે.

270
00:19:23,770 --> 00:19:24,670
સરસ.

271
00:19:24,670 --> 00:19:27,270
તેથી પછી એકવાર તમે કી મળી છે અને એક વાર તમે લખાણ મળી છે,

272
00:19:27,270 --> 00:19:31,660
હવે શું બાકી છે છે તમે સાદી ભાષા ચિહ્નિત કરો હોય છે.

273
00:19:31,660 --> 00:19:36,530
જસ્ટ ઝડપથી વિદેશી ભાષા પર આવરી માટે બનાવવા માટે, સાદી ભાષા છે જે વપરાશકર્તા તમે કયા આપે છે,

274
00:19:36,530 --> 00:19:41,030
અને ગૂઢ છે તમે શું તેમને આવો.

275
00:19:42,450 --> 00:19:45,850
શબ્દમાળાઓ તેથી, પત્ર દ્વારા વાસ્તવમાં પત્ર પસાર કરવાનો પ્રયત્ન કરવા માટે

276
00:19:45,850 --> 00:19:48,550
કારણ કે અમે દરેક અક્ષર પાળી છે,

277
00:19:48,550 --> 00:19:51,390
અમે તે શબ્દમાળાઓ સમજવું હોય તો, પાછા સ્તર છાલ અમે પ્રકારની,

278
00:19:51,390 --> 00:19:54,130
અમે જુઓ કે તેઓ માત્ર ખરેખર અક્ષરો યાદી છો.

279
00:19:54,130 --> 00:19:55,930
એક અન્ય પછી આવે છે.

280
00:19:55,930 --> 00:20:01,690
અને તેથી અમે એરે તરીકે શબ્દમાળાઓ સારવાર કારણ કે તેઓ અક્ષરો એરે શકો છો.

281
00:20:01,690 --> 00:20:05,640
તેથી કહેવું તમે લખાણ નામવાળી શબ્દમાળા હોય છે,

282
00:20:05,640 --> 00:20:09,400
અને તે ચલ લખાણ અંદર સંગ્રહાય છે આ CS50 છે.

283
00:20:09,400 --> 00:20:15,680
પછી 0 અનુક્રમણિકા પર લખાણ એ મૂડી ટી હશે, 1 ઇન્ડેક્સ-h, વગેરે હશે

284
00:20:17,530 --> 00:20:23,970
અને પછી એરે સાથે args.c માં argc ઉદાહરણમાં,

285
00:20:23,970 --> 00:20:27,090
અમે જોયું છે કે અમે ઉપર ઝાકઝમાળ ભારપૂર્વક કહેવું હતું

286
00:20:27,090 --> 00:20:32,440
અને તેથી અમે હું માંથી = 0 ફરી વળવું અપ સુધી હું લંબાઈ કરતા ઓછી છે હતા.

287
00:20:32,440 --> 00:20:35,560
તેથી અમે figuring અમારા શબ્દમાળા લંબાઈ શું છે અમુક રીતે જરૂર

288
00:20:35,560 --> 00:20:37,090
જો અમે તેને ઉપર ફરી વળવું રહ્યા છીએ.

289
00:20:37,090 --> 00:20:42,300
સદભાગ્યે ફરી, ત્યાં અમને માટે ત્યાં કાર્ય CS50 જોકે પાછળથી છે,

290
00:20:42,300 --> 00:20:45,860
તમે ચોક્કસપણે અમલ કરવા માટે અને તમારા પોતાના કાર્ય કરી શકશો

291
00:20:45,860 --> 00:20:48,260
કે જે શબ્દમાળા લંબાઈ ગણતરી કરી શકે છે.

292
00:20:48,260 --> 00:20:52,120
પરંતુ હવે અમે શબ્દમાળા લંબાઈ, તેથી strlen ઉપયોગ જઈ રહ્યાં છો.

293
00:20:52,120 --> 00:21:00,440
તમે એક શબ્દમાળા માં પસાર કરવા માટે, અને પછી તેને તમે પૂર્ણાંક છે કે જે તમારા શબ્દમાળા લંબાઈ રજૂ આપશે.

294
00:21:00,440 --> 00:21:05,840
ચાલો અમે કેવી રીતે પર શબ્દમાળા દરેક અક્ષર ફરી વળવું કરવાનો પ્રયત્ન કરી શકે છે તેનું ઉદાહરણ જોવા

295
00:21:05,840 --> 00:21:08,470
અને તે સાથે જ કંઈક.

296
00:21:08,470 --> 00:21:13,250
અમે કરવા માંગો છો શું છે ઉપર શબ્દમાળા દરેક અક્ષર ફરી વળવું,

297
00:21:13,250 --> 00:21:19,150
અને અમે કરવા માંગો છો શું છે અમે પાછા 1 દ્વારા દરેક 1 અક્ષર છાપો

298
00:21:19,150 --> 00:21:22,060
સિવાય અમે તેને આગળ કંઈક ઉમેરો.

299
00:21:22,060 --> 00:21:27,020
તેથી આપણે લૂપ માટે સાથે શરૂ કરો. ઈન્ હું = 0.

300
00:21:27,020 --> 00:21:30,070
અમે પરિસ્થિતિ માટે જગ્યા છોડી રહ્યા છીએ.

301
00:21:32,700 --> 00:21:36,840
અમે ભારપૂર્વક કહેવું માંગો છો ત્યાં સુધી અમે શબ્દમાળા ઓવરને સુધી પહોંચવા અધિકાર?

302
00:21:36,840 --> 00:21:41,340
તેથી પછી કાર્ય શું અમારી શબ્દમાળા લંબાઈ આપે છે?

303
00:21:41,340 --> 00:21:43,160
[અશ્રાવ્ય વિદ્યાર્થી જવાબ]

304
00:21:43,160 --> 00:21:46,420
કે આદેશ વાક્ય દલીલો લંબાઈ છે.

305
00:21:46,420 --> 00:21:50,650
પરંતુ શબ્દમાળા માટે અમે એક કાર્ય છે કે અમને શબ્દમાળા લંબાઈ આપે છે ઉપયોગ કરવા માંગો છો.

306
00:21:50,650 --> 00:21:53,090
જેથી શબ્દમાળા લંબાઈ છે.

307
00:21:53,090 --> 00:21:57,130
અને તેથી તે પછી તમે તેને શબ્દમાળા પાસ હોય છે.

308
00:21:57,130 --> 00:21:59,760
તે જાણવા માટે શબ્દમાળા તે માટે લંબાઈ ગણતરી જરૂર જરૂર છે.

309
00:21:59,760 --> 00:22:03,160
તેથી પછી આ કિસ્સામાં અમે શબ્દમાળા ઓ સાથે વ્યવહાર કરી રહ્યા છો.

310
00:22:04,790 --> 00:22:05,860
સરસ.

311
00:22:05,860 --> 00:22:10,770
તેથી તો અમે શું કરવા માંગો છો, તો printf દો.

312
00:22:10,770 --> 00:22:14,850
હવે, અમે અક્ષરો સાથે કામ કરવા માંગો છો. અમે બહાર દરેક વ્યક્તિગત અક્ષર છાપો કરવા માંગો છો.

313
00:22:14,850 --> 00:22:22,150
જ્યારે તમે તેને એક ફ્લોટ પ્રિન્ટ કરવા માંગો છો, તો તમે% એફ જેમ પ્લેસહોલ્ડર ઉપયોગ કરશે.

314
00:22:22,150 --> 00:22:24,580
પૂર્ણાંક સાથે તમે% d નો ઉપયોગ કરશે.

315
00:22:24,580 --> 00:22:30,890
અને તેથી એ જ રીતે, એક અક્ષર સાથે તમે% C વાપરવા માટે કહે છે કે હું એક અક્ષર છાપવા કરી જાઉં છું

316
00:22:30,890 --> 00:22:34,570
કે જે ચલ અંદર સંગ્રહિત છે.

317
00:22:34,570 --> 00:22:40,840
તેથી અમે આ હોય છે, અને આપણે એક સમય અને તે જગ્યા ઉમેરો.

318
00:22:40,840 --> 00:22:45,430
અક્ષર જે અમે ઉપયોગ કરી રહ્યા છો?

319
00:22:45,430 --> 00:22:49,780
અમે ઉપયોગ કરી અક્ષર ગમે અમે શબ્દમાળાને અંતે છો જઈ રહ્યાં છો.

320
00:22:49,780 --> 00:22:52,890
તેથી તે પછી અમે શબ્દમાળા સાથે કંઈક ઉપયોગ કરી રહ્યા છીએ,

321
00:22:52,890 --> 00:22:56,420
પરંતુ અમે અમુક ચોક્કસ અક્ષર ઍક્સેસ કરી ત્યાં માંગો છો.

322
00:22:56,420 --> 00:23:02,740
તેથી જો શબ્દમાળા માત્ર એક વ્યૂહરચના છે, તો પછી અમે એરે તત્વો કેવી રીતે કરી શકું?

323
00:23:02,740 --> 00:23:06,480
અમે તે ચોરસ કૌંસ હોય છે, અને તે પછી અમે ત્યાં ઇન્ડેક્સ પુટ.

324
00:23:06,480 --> 00:23:11,820
તેથી અમે ચોરસ કૌંસ છે. આ કિસ્સામાં અમારા અનુક્રમણિકા અમે ફક્ત હું વાપરી શકો છો. બરાબર.

325
00:23:15,290 --> 00:23:22,370
અહીં આપણે કહી રહ્યાં અમે એક અક્ષર છાપવા કરી કોઈ અને એક જગ્યા દ્વારા અનુસરવામાં જઈ રહ્યાં છો,

326
00:23:22,370 --> 00:23:30,870
અને તે અક્ષર અમારી શબ્દમાળા ઓ માં ઇથ પત્ર પ્રયત્ન રહ્યું છે.

327
00:23:32,920 --> 00:23:39,330
હું માત્ર કે સેવ જાઉં છું. ઠીક છે.

328
00:23:42,510 --> 00:23:46,840
હવે હું શબ્દમાળા લંબાઈ સ્કોર જાઉં છું.

329
00:23:46,840 --> 00:23:53,440
તેથી અમે OMG કહેવાય શબ્દમાળા હતી, અને હવે તે વધુ ભાર મૂક્યો છે.

330
00:23:53,440 --> 00:23:57,870
તેવી જ રીતે, ચાલો આપણે કહેવું ખરેખર વપરાશકર્તા માંથી શબ્દમાળા મેળવવા માંગો છો.

331
00:23:57,870 --> 00:23:59,580
અમે આ કેવી રીતે કરવું પડી શકે છે?

332
00:23:59,580 --> 00:24:01,610
પહેલાં, અમે પૂર્ણાંક કેવી રીતે કરી?

333
00:24:01,610 --> 00:24:08,040
અમે GetInt અધિકાર જણાવ્યું હતું? પરંતુ આ પૂર્ણાંક નથી, તેથી આપણે GetString.

334
00:24:11,780 --> 00:24:17,770
ચાલો શબ્દમાળા લંબાઈ બનાવે છે. અહીં અમે ચોક્કસ પ્રોમ્પ્ટ દાખલ કર્યું નથી.

335
00:24:17,770 --> 00:24:19,940
તેથી મને ખબર નથી.

336
00:24:19,940 --> 00:24:23,820
હું અહીં મારું નામ મૂકવા જાઉં છું અને તેથી હું એક પછી તે વસ્તુઓ કરી શકો છો

337
00:24:23,820 --> 00:24:29,600
જ્યાં હું દરેક અથવા જેમ પત્ર કંઈક માટે એક શબ્દ સોંપો. સરસ.

338
00:24:29,600 --> 00:24:31,900
જેથી શબ્દમાળા લંબાઈ છે.

339
00:24:33,000 --> 00:24:34,640
તેથી અમે સીઝર પાછા છો.

340
00:24:34,640 --> 00:24:38,620
અમે કેવી રીતે અમે શબ્દમાળા ઉપર ફરી વળવું પર થોડા સાધનો હોય છે,

341
00:24:38,620 --> 00:24:41,250
અમે કેવી રીતે દરેક વ્યક્તિગત તત્વ ઍક્સેસ કરો.

342
00:24:41,250 --> 00:24:44,720
તેથી હવે અમે પાછા કાર્યક્રમ મેળવી શકો છો.

343
00:24:44,720 --> 00:24:48,650
હું પહેલાં, તે ASCII કોષ્ટકમાં, તમારા શ્રેષ્ઠ મિત્ર, તમારો ઉલ્લેખ કર્યો છે

344
00:24:48,650 --> 00:24:52,300
તમે જે નંબરો કે દરેક અક્ષર સાથે સંકળાયેલા છે તે જોવા જઈ રહ્યાં છો.

345
00:24:52,300 --> 00:24:55,900
તેથી અહીં કહેવું અમારા સાદી ભાષા છે હું અતિશય ઊંચું છું!

346
00:24:55,900 --> 00:25:01,090
તો પછી આ અક્ષરો દરેક માટે નંબર અને તે ASCII તેની સાથે સંકળાયેલ હોય રહ્યું છે,

347
00:25:01,090 --> 00:25:04,710
પણ એપોસ્ટ્રોફી, પણ જગ્યા, પણ આશ્ચર્યચિહ્ન,

348
00:25:04,710 --> 00:25:06,600
તેથી તમારે ધ્યાનમાં રાખવા માંગો છો કે પડશે.

349
00:25:06,600 --> 00:25:12,360
તેથી અમારા કી જણાવે છે કે તેમના આદેશ વાક્ય દલીલ સમાવવામાં વપરાશકર્તા 6 છે.

350
00:25:12,360 --> 00:25:17,770
કે પ્રથમ અક્ષર છે, જે હું છે જે 73 દ્વારા રજૂ થાય છે માટે એનો અર્થ એ થાય

351
00:25:17,770 --> 00:25:25,610
તમે તેમને પાછા પત્ર ગમે 73 + 6 ના ASCII કિંમત દ્વારા રજૂ થાય છે કરવા માંગો છો.

352
00:25:25,610 --> 00:25:29,020
આ કિસ્સામાં કે 79 હશે.

353
00:25:30,840 --> 00:25:35,040
હવે અમે આગલા અક્ષર પર જાઓ કરવા માંગો છો.

354
00:25:35,040 --> 00:25:40,960
તેથી સાદાલખાણ 1 નું ઇન્ડેક્સમાં આગામી એપોસ્ટ્રોફી હશે.

355
00:25:40,960 --> 00:25:46,780
યાદ પરંતુ અમે ફક્ત અક્ષરો ચિહ્નિત કરો માંગો છો.

356
00:25:46,780 --> 00:25:50,040
તેથી અમે ખાતરી કરો કે એપોસ્ટ્રોફી ખરેખર જ રહે બનાવવા માંગો છો,

357
00:25:50,040 --> 00:25:54,310
કે અમે 39 થી 45 કંઈપણ નથી બદલી નથી.

358
00:25:54,310 --> 00:25:57,150
અમે તેને એપોસ્ટ્રોફી તરીકે રાખવા માંગો છો.

359
00:25:57,150 --> 00:26:00,780
તેથી અમે માત્ર અક્ષરો ચિહ્નિત કરો યાદ કરવા માંગો છો

360
00:26:00,780 --> 00:26:04,560
કારણ કે અમે અન્ય પ્રતીકો અમારી તમામ કાર્યક્રમ યથાવત રહેવા માટે કરવા માંગો છો.

361
00:26:04,560 --> 00:26:07,130
અન્ય વસ્તુ કે અમે કરવા માંગો છો કેપિટલાઈઝેશન સાચવવાની છે.

362
00:26:07,130 --> 00:26:10,250
તેથી જ્યારે તમે એક મોટા અક્ષર છે, તે મોટા તરીકે રહેવા જોઈએ.

363
00:26:10,250 --> 00:26:12,830
Lowercases લોઅરકેસ તરીકે રહેવા જોઈએ.

364
00:26:13,620 --> 00:26:19,480
તેથી કેટલીક ઉપયોગી કાર્યો માટે માત્ર enciphering અક્ષરો સાથે વ્યવહાર કરવાનો પ્રયત્ન કરવા માટે

365
00:26:19,480 --> 00:26:22,380
અને વસ્તુઓના કેપિટલાઈઝેશન સાચવીને રાખવા

366
00:26:22,380 --> 00:26:25,130
આ isalpha, isupper, islower વિધેયો છે.

367
00:26:25,130 --> 00:26:29,270
અને તેથી આ વિધેયો કે જે તમે બુલિયન કિંમત પાછી આવે છે.

368
00:26:29,270 --> 00:26:34,180
મૂળભૂત રીતે, જે સાચું અથવા ખોટું. આ એક મોટા છે? આ આલ્ફાન્યૂમેરિક છે?

369
00:26:34,180 --> 00:26:37,180
આ એક પત્ર છે અનિવાર્યપણે.

370
00:26:37,180 --> 00:26:41,070
અહીં તમે કેવી રીતે છે કે વિધેય વાપરી શકે 3 ઉદાહરણો છે.

371
00:26:41,070 --> 00:26:47,060
મૂળભૂત રીતે, તમે ચકાસવા માટે કરી શકે છે કે શું કિંમત છે કે જે કાર્ય દ્વારા તમને પાછી સાચી કે ખોટી છે

372
00:26:47,060 --> 00:26:49,400
કે ઇનપુટ પર આધારિત છે.

373
00:26:49,400 --> 00:26:54,880
ક્યાં નથી ચિહ્નિત કરો કંઈક અથવા તેને સાઇફર અથવા ખાતરી કરે છે કે તે મોટા, વગેરે જ કરવું

374
00:26:54,880 --> 00:27:01,080
[વિદ્યાર્થી] તમે થોડી વધારે છે અને તમને તેમને કેવી રીતે ઉપયોગ કરવો તે સમજાવવા કરી શકું? >> યાહ, ખાતરી કરો કે માટે.

375
00:27:01,080 --> 00:27:08,470
તેથી જો અમે પાછા જુઓ, અહીં આપણે એક મૂડી હું અધિકાર છે?

376
00:27:08,470 --> 00:27:14,550
તેથી આપણે જાણીએ છીએ કે હું O જાય છે કારણ કે હું 6 + ઓ છે

377
00:27:14,550 --> 00:27:18,740
પરંતુ અમે ખાતરી કરવા માટે કે જે ઓ માટે મૂડી ઓ પ્રયત્ન રહ્યું છે બનાવવા માંગો છો

378
00:27:18,740 --> 00:27:22,940
જેથી મૂળભૂત છે, કે જે અમારા ઇનપુટ ફેરફાર કરી પ્રકારની છે.

379
00:27:22,940 --> 00:27:26,870
તેથી શું તે મોટા છે અથવા તો જે રીતે કરે છે કે અમે તેની સાથે વ્યવહાર બદલી પ્રકારની નથી.

380
00:27:26,870 --> 00:27:32,360
તેથી પછી જો આપણે ચોક્કસ અનુક્રમણિકા પર isupper કાર્ય વાપરવા માટે,

381
00:27:32,360 --> 00:27:36,480
તેથી ("હું") isupper કે, અમને સાચું માટે આપે છે, તેથી આપણે જાણીએ છીએ કે તે ઉચ્ચ છે.

382
00:27:36,480 --> 00:27:40,360
તેથી આધારિત પર પછી, પાછળથી અમે સૂત્ર જાય પડશે

383
00:27:40,360 --> 00:27:42,750
કે જે તમે સીઝર વસ્તુઓ પાળી ઉપયોગ કરી શકશો,

384
00:27:42,750 --> 00:27:46,560
જેથી તે પછી મૂળભૂત રીતે, ત્યાં કોઈ થોડા અલગ સૂત્ર જ હશે જો તે મોટા છે

385
00:27:46,560 --> 00:27:50,670
તરીકે લોઅરકેસ વિરોધ કર્યો હતો. અર્થમાં બનાવીએ?

386
00:27:51,020 --> 00:27:52,760
યાહ. કોઈ ચિંતાઓ.

387
00:27:54,900 --> 00:27:58,990
હું એક પત્ર, જે તદ્દન અર્થમાં નથી થી 6 ઉમેરવા વિશે થોડી વાત

388
00:27:58,990 --> 00:28:05,500
જ્યારે અમે પ્રકારની સમજવા સિવાય કે આ અક્ષરો

389
00:28:05,500 --> 00:28:08,920
પૂર્ણાંકો સાથે વિનિમયક્ષમ પ્રકારની હોય છે.

390
00:28:08,920 --> 00:28:11,250
અમે શું આપણે ઉપયોગ ગર્ભિત કાસ્ટિંગ પ્રકારની છે.

391
00:28:11,250 --> 00:28:18,100
અમે નિર્ણાયક એક થોડીવાર પછી તમે જ્યાં કિંમત લઇ શકશો જાઓ અને તમે તેને અલગ પ્રકાર મા ફેરવાઇ જાય છે

392
00:28:18,100 --> 00:28:20,440
કરતાં તે મૂળ હતી.

393
00:28:20,440 --> 00:28:25,910
પરંતુ આ pset સાથે અમે પ્રકારની એકબીજાના અક્ષરો વાપરવા માટે સક્ષમ થશો

394
00:28:25,910 --> 00:28:30,880
અને તેમના લગતાવળગતા પૂર્ણાંક કિંમતો.

395
00:28:30,880 --> 00:28:35,140
તેથી જો તમે ખાલી ખાલી એક જ અવતરણચિહ્નો સાથે એક અક્ષર ડબામાં બંધ કરવું,

396
00:28:35,140 --> 00:28:40,390
તો પછી તમારે પૂર્ણાંકો સાથે તેની સાથે કામ કરે છે, પૂર્ણાંક તરીકે તેની સાથે વ્યવહાર કરવાનો પ્રયત્ન કરીશું.

397
00:28:40,390 --> 00:28:48,040
તેથી મૂડી સી 67 સંબંધિત છે. લોઅરકેસ એફ 102 સાથે સંબંધિત છે.

398
00:28:48,040 --> 00:28:51,480
ફરીથી, જો તમે આ કિંમતો જાણવા માગો છો, તો તમારા ASCII ટેબલ પર જુઓ.

399
00:28:51,480 --> 00:28:56,160
તેથી આપણે કેવી રીતે તમે સબ્ટ્રેક્ટ અને ઉમેરો કરવાનો પ્રયત્ન કરી શકે છે કેટલાંક ઉદાહરણો જાય,

400
00:28:56,160 --> 00:29:03,130
તમે કેવી રીતે વાસ્તવમાં ખરેખર આ અક્ષરો સાથે કામ કરી શકે છે, તેમને એકબીજાના વાપરો.

401
00:29:03,870 --> 00:29:11,350
હું કહે છે કે ASCIIMath એક પૂર્ણાંક એક પાત્રની વધુમાં ગણતરી રહ્યું છે

402
00:29:11,350 --> 00:29:17,590
અને પછી ફલસ્વરૂપ તેમજ ફલસ્વરૂપ ASCII કિંમત પાત્ર દર્શાવે છે.

403
00:29:17,590 --> 00:29:22,290
અને તેથી હું કહી રહ્યો છું - આ ભાગ સાથે we'll સોદો પછી -

404
00:29:22,290 --> 00:29:29,100
પરંતુ મૂળભૂત રીતે, હું કહી રહ્યો છું કે જે વપરાશકર્તા સ્કોર ASCIIMath કી સાથે કહેવું જોઈએ,

405
00:29:29,100 --> 00:29:30,880
અને હું કહી રહ્યો છું કે જે કી સંખ્યા હોવી રહ્યું છે

406
00:29:30,880 --> 00:29:34,600
જેની સાથે અમે આ પાત્ર ઉમેરી રહ્યા છીએ.

407
00:29:34,600 --> 00:29:38,560
તેથી અહીં નોટિસ કે હું એક કી માગણી છું,

408
00:29:38,560 --> 00:29:40,590
કારણ કે હું છું કે તેઓ મને માગણી 1 વસ્તુ આપીને કરી રહ્યાં છો,

409
00:29:40,590 --> 00:29:45,600
હું ફક્ત /. Asciimath અને કી સ્વીકારવા માંગો છો.

410
00:29:45,600 --> 00:29:49,330
તેથી હું એવી માગ કરી કે argc 2 સમાન છે જાઉં છું.

411
00:29:49,330 --> 00:29:54,360
જો તે નથી, તો પછી હું 1 પાછા આવો અને કાર્યક્રમ બહાર થશે જાઉં છું.

412
00:29:55,070 --> 00:29:58,540
તેથી હું કહી રહ્યો છું કી પ્રથમ આદેશ વાક્ય દલીલ ન રહ્યું છે,

413
00:29:58,540 --> 00:30:05,080
તે બીજા એક જ હશે, અને તમે અહીં જુઓ,

414
00:30:05,080 --> 00:30:11,790
હું એ પૂર્ણાંક છે કે જે માં ચાલુ જાઉં છું.

415
00:30:15,740 --> 00:30:19,230
પછી હું એક અક્ષર સુયોજિત કરવા માટે r પ્રયત્ન જાઉં છું.

416
00:30:19,230 --> 00:30:23,970
નોંધ કરો કે આ ચલ chr પ્રકાર ખરેખર એક પૂર્ણાંક છે.

417
00:30:23,970 --> 00:30:30,480
જે રીતે હું પૂર્ણાંક તરીકે r ઉપયોગ કરવાનો છું તે આ એક જ અવતરણચિહ્નો સાથે encasing છે.

418
00:30:33,850 --> 00:30:40,560
તેથી અમારા printf કથન પાછળ જ્યાં અમે એક અક્ષર માટે એક પ્લેસહોલ્ડર છે

419
00:30:40,560 --> 00:30:43,590
અને પછી એ પૂર્ણાંક માટે એક પ્લેસહોલ્ડર,

420
00:30:43,590 --> 00:30:49,450
અક્ષર chr દ્વારા રજૂ થાય છે, અને પૂર્ણાંક કી છે.

421
00:30:49,450 --> 00:30:54,320
અને તેથી તે પછી અમે પરિણામ 2 ના મળીને ઉમેરો રહ્યા છીએ.

422
00:30:54,320 --> 00:30:58,420
તેથી અમે r ઉમેરવા જઈ રહ્યાં છો + + ગમે તે કી છે,

423
00:30:58,420 --> 00:31:03,520
અને પછી અમે તે પરિણામ છાપી રહ્યા છીએ.

424
00:31:06,210 --> 00:31:14,220
તેથી આપણે asciimath બનાવે છે. તે તારીખ સુધી, તેથી આપણે માત્ર asciimath ચલાવો.

425
00:31:14,220 --> 00:31:18,290
ઓહ જુએ છે, પરંતુ, તે કંઇ નથી કારણ કે અમે ખરેખર તે નથી કી આપી નહોતી નથી.

426
00:31:18,290 --> 00:31:23,850
તેથી જ્યારે તે માત્ર 1, અમારી મુખ્ય કાર્ય ફર્યા, તે માત્ર અમને પાછા ફર્યા.

427
00:31:23,850 --> 00:31:29,250
તેથી પછી ચાલો કી માં પસાર કરે છે. કોઇએ મને એક નંબર આપે છે. >> [વિદ્યાર્થી] 4.

428
00:31:29,250 --> 00:31:30,920
4. ઠીક છે.

429
00:31:30,920 --> 00:31:39,280
તેથી r 4 અમને વિરુદ્ધ છે, જે 118 ની ASCII કિંમત અનુલક્ષે આપી રહ્યું છે દ્વારા વધારો થયો છે.

430
00:31:39,280 --> 00:31:43,880
તેથી તો તે પ્રકારની છે કે જે અર્થમાં બનાવે છે -

431
00:31:43,880 --> 00:31:51,250
ખરેખર, હું તમને પૂછવા કરી શકો છો, તમે શું વિચારો છો r ની ASCII કિંમત છે જો + + r 4 118 છે?

432
00:31:53,070 --> 00:31:55,470
હા, તો પછી r 114 છે.

433
00:31:55,470 --> 00:32:03,010
તેથી જો તમે તે ASCII ટેબલ પર પછી જુઓ, તો ખાતરી કરો કે પર્યાપ્ત, તમે જોશો કે r 114 દ્વારા રજૂ થાય છે.

434
00:32:03,010 --> 00:32:08,610
તેથી હવે આપણે જાણીએ છીએ કે અમે પૂર્ણાંકો અક્ષરો ઉમેરી શકો છો, આ ખૂબ સરળ લાગે છે.

435
00:32:08,610 --> 00:32:12,740
અમે માત્ર પર શબ્દમાળા ફરી વળવું જેમ અમે પહેલા ઉદાહરણ માં જોયું હતું રહ્યા છીએ.

436
00:32:12,740 --> 00:32:17,170
અમે જો તે અક્ષર છે તપાસ કરીશું.

437
00:32:17,170 --> 00:32:20,420
જો તે હોય, તો પછી અમે તેને ગમે તે કી છે દ્વારા પાળી પડશે.

438
00:32:20,420 --> 00:32:23,650
સુંદર, સરળ, જ્યારે તમે આ કરવા માંગો વિચાર સિવાય,

439
00:32:23,650 --> 00:32:32,140
તમે જુઓ કે z, 122 દ્વારા રજૂ, પછી તમે એક અલગ અક્ષર આપશે.

440
00:32:32,140 --> 00:32:37,770
અમે ખરેખર અમારી મૂળાક્ષર અંદર રહેવા માંગો છો અધિકાર?

441
00:32:37,770 --> 00:32:43,180
તેથી અમે બહાર આસપાસ રેપિંગ પ્રકારની કેટલીક રીતે આકૃતિ જરૂર છે.

442
00:32:43,180 --> 00:32:47,190
, જ્યારે તમે ઝેડના સુધી પહોંચવા અને તમે અમુક ચોક્કસ નંબર દ્વારા વધારો કરવા માંગો છો

443
00:32:47,190 --> 00:32:51,230
તમે તે ASCII મૂળાક્ષર વિભાગ બહાર જાય માગતા નથી;

444
00:32:51,230 --> 00:32:54,140
તમે પાછા એ બધી રીતે લપેટી માંગો છો

445
00:32:54,140 --> 00:32:58,550
પરંતુ ધ્યાનમાં રાખો તો તમે હજુ પણ કેસ સાચવીને કરી રહ્યાં છો.

446
00:32:58,550 --> 00:33:00,980
જેથી અક્ષરો જાણીને પ્રતીકો ન બની શકે છે

447
00:33:00,980 --> 00:33:05,290
પ્રતીકો જેમ જ માટે પણ બદલાતી શકાતી નથી જવાનું છે.

448
00:33:05,290 --> 00:33:08,170
છેલ્લા pset તમે નિશ્ચિતપણે જરૂર ન હતી,

449
00:33:08,170 --> 00:33:14,310
પરંતુ એક વિકલ્પ માટે મોડ્યૂલ્સ કાર્ય ઉપયોગ કરીને તમારી લોભી pset અમલમાં હતી.

450
00:33:14,310 --> 00:33:17,230
પરંતુ હવે અમે ખરેખર માટે મોડ્યૂલ્સ ઉપયોગ કરવાની જરૂર જઈ રહ્યાં છો,

451
00:33:17,230 --> 00:33:19,900
તેથી આપણે ફક્ત આ થોડો પર જાઓ.

452
00:33:19,900 --> 00:33:26,920
આવશ્યકપણે, જ્યારે તમે એક્સ મોડ્યૂલો વાય છે, કે જે તમે વાય દ્વારા વિભાજી એક્સ બાકીની આપે છે.

453
00:33:26,920 --> 00:33:30,930
અહીં કેટલીક અહીં ઉદાહરણો છે. અમે 27% 15 હોય છે.

454
00:33:30,930 --> 00:33:36,200
મૂળભૂત રીતે, જ્યારે તમે નકારાત્મક મેળવવામાં વગર 27 થી 15 શક્ય હોય તેટલી વાર સબ્ટ્રેક્ટ

455
00:33:36,200 --> 00:33:39,060
પછી તમે 12 ડાબી વિચાર પર.

456
00:33:39,060 --> 00:33:44,650
જેથી જેવા પ્રકારની ગણિતના સંદર્ભમાં છે, પરંતુ અમે ખરેખર આ કેવી રીતે ઉપયોગ કરી શકું?

457
00:33:44,650 --> 00:33:47,100
તે અમારા wrapover માટે ઉપયોગી થઇ રહ્યું છે.

458
00:33:47,100 --> 00:33:55,420
આ માટે આપણે માત્ર કહી હું તમને બધી કહ્યું 3 જૂથો વિભાજીત.

459
00:33:55,420 --> 00:33:58,010
ક્યારેક તમે જૂથો અને તે કંઈક આ કરવા માટે.

460
00:33:58,010 --> 00:34:01,320
માનો કે મેં કહ્યું, "ઠીક છે, હું તમને બધી માંગો છો 3 વિભાજિત કરી શકાય."

461
00:34:01,320 --> 00:34:04,240
કે જે તમને કેવી રીતે શકે?

462
00:34:04,240 --> 00:34:06,810
[અશ્રાવ્ય વિદ્યાર્થી પ્રતિભાવ] અરે વાહ, બરાબર. બંધ ગણક. ઠીક છે.

463
00:34:06,810 --> 00:34:10,260
માતાનો વાસ્તવમાં કે દો. શું તમે શરૂ કરવા માંગો છો?

464
00:34:10,260 --> 00:34:13,810
1, 2, 3, 4 [વિદ્યાર્થીઓ બોલ ગણતરી].

465
00:34:13,810 --> 00:34:16,620
યાદ પણ ... >> [વિદ્યાર્થી] ઓહ, માફ.

466
00:34:16,620 --> 00:34:18,730
કે જે ખરેખર સારા બિંદુ છે.

467
00:34:18,730 --> 00:34:24,130
તમે 4 જણાવ્યું હતું, પરંતુ અમે તમને ખરેખર 1 કહેવા માગો છો કારણ કે અમે માત્ર 3 જૂથો કરવા માંગો છો.

468
00:34:24,130 --> 00:34:30,159
તેથી, તો પછી કેવી રીતે - ના, કે જે ખરેખર સારું ઉદાહરણ છે કારણ કે તો પછી તમે કેવી રીતે કહી શકે 1?

469
00:34:30,159 --> 00:34:33,370
4 અને 1 વચ્ચે શું સંબંધ છે?

470
00:34:33,370 --> 00:34:36,760
વેલ, 4 3 1 મોડ છે.

471
00:34:36,760 --> 00:34:41,460
તેથી જો તમે ચાલુ રાખો, તો તમારે 2 હશે.

472
00:34:41,460 --> 00:34:44,540
તેથી અમે 1, 2, 3, 1, 2 છે.

473
00:34:44,540 --> 00:34:49,420
ફરીથી, તમે ખરેખર 5 વ્યક્તિ છો. તમે 2 બદલે 5 કહેવું કેવી રીતે જાણી શકું?

474
00:34:49,420 --> 00:34:53,760
તમે કહી 5 3 મોડ 2 છે.

475
00:34:53,760 --> 00:34:59,100
હું કેટલી 3 જૂથો બાકી છે કરવા માંગો છો, તો પછી કયા ક્રમમાં આઇ છું

476
00:34:59,100 --> 00:35:02,860
અને તેથી તે પછી જો આપણે સમગ્ર ખંડ સાથે ચાલુ રહ્યો,

477
00:35:02,860 --> 00:35:07,760
તો પછી અમે જુઓ કે આપણે હંમેશા ખરેખર રહ્યાં છો જાતને માટે મોડ કાર્ય અરજી

478
00:35:07,760 --> 00:35:09,990
માટે પ્રકારની બોલ ગણતરી.

479
00:35:09,990 --> 00:35:14,490
કે કેવી રીતે તમે મોડ્યૂલો ઉપયોગ શકે મૂર્ત ઉદાહરણ વધુ પ્રકારની છે

480
00:35:14,490 --> 00:35:17,960
કારણ કે મને ખાતરી છે કે છું અમને મોટા ભાગના કદાચ તે પ્રક્રિયા મારફતે ચાલ્યા ગયા છે

481
00:35:17,960 --> 00:35:19,630
જ્યાં અમે બોલ ગણતરી હતી.

482
00:35:19,630 --> 00:35:21,840
મોડ્યૂલો પર કોઈપણ પ્રશ્ન છે?

483
00:35:21,840 --> 00:35:25,360
તે ખૂબ મહત્વપૂર્ણ બનવા માટે આ વિભાવનાઓને સમજવામાં આવશે,

484
00:35:25,360 --> 00:35:28,640
તેથી હું તેની ખાતરી કરવા માટે તમે ગાય્સ સમજી બનાવવા માંગો છો.

485
00:35:28,640 --> 00:35:34,660
[વિદ્યાર્થી] જો ત્યાં કોઈ શેષ છે, તો તે તમને તે વાસ્તવિક સંખ્યા આપો છો?

486
00:35:34,660 --> 00:35:40,430
જો તેમાંનુ એક પ્રથમ 3 તે કર્યું છે, તે તેમને આપવામાં હોત તેઓ શું ખરેખર હતા,

487
00:35:40,430 --> 00:35:43,310
અથવા તે તેમને આપવામાં હોત [અશ્રાવ્ય] >> તે એક સારો પ્રશ્ન છે.

488
00:35:43,310 --> 00:35:48,750
જ્યારે ત્યાં મોડ્યૂલો માટે આ બોલ પર કોઈ બાકીની છે - જેથી કહેવું તમે 6 3 મોડ હોય -

489
00:35:48,750 --> 00:35:52,340
કે ખરેખર તમે આપે પાછા 0.

490
00:35:53,670 --> 00:35:57,290
અમે પછી થોડી છે કે જે વિશે વાત કરશે.

491
00:35:58,810 --> 00:36:07,720
ઓહ હા, હમણાં પૂરતું, 3 જી વ્યક્તિ - 3 3 મોડ ખરેખર 0 પરંતુ તેણીએ 3 જણાવ્યું હતું.

492
00:36:07,720 --> 00:36:14,900
જેથી આંતરિક કેચ જેવા પ્રકારની છે, હમણાં પૂરતું છે,

493
00:36:14,900 --> 00:36:17,620
ઠીક જેમ, જો મોડ પછી 0 છે હું 3 જી વ્યક્તિ પ્રયત્ન જાઉં છું.

494
00:36:17,620 --> 00:36:22,740
પરંતુ અમે કેવી રીતે અમે 0 પાછળથી સાથે વ્યવહાર શકો છો પ્રકારની પ્રવેશ મળશે.

495
00:36:22,740 --> 00:36:32,750
તેથી હવે અમે કોઈક અધિકાર પત્ર માટે ઝેડ મૅપ એક રસ્તો હોય છે.

496
00:36:32,750 --> 00:36:34,920
તેથી હવે અમે આ ઉદાહરણો પસાર કર્યો છે,

497
00:36:34,920 --> 00:36:37,880
અમે પ્રકારની કેવી રીતે સીઝર કામ કરી શકે છે.

498
00:36:37,880 --> 00:36:42,640
તમે 2 મૂળાક્ષરો જુઓ અને પછી તમે તેમને સ્થળાંતર જુઓ.

499
00:36:42,640 --> 00:36:44,430
તેથી આપણે પ્રયાસ અને સૂત્ર દ્રષ્ટિએ કે વ્યક્ત.

500
00:36:44,430 --> 00:36:46,940
આ સૂત્ર ખરેખર સ્પેક છે તમે આપેલ હોય,

501
00:36:46,940 --> 00:36:52,070
પરંતુ દરેક ચલ શું અર્થ થાય છે મારફતે લેટ્સ દેખાવ પ્રકારની.

502
00:36:52,070 --> 00:36:55,000
અમારા અંતિમ પરિણામ માટે ગૂઢ પ્રયત્ન રહ્યું છે.

503
00:36:55,000 --> 00:36:58,300
તેથી આ કહે છે કે સાઇફર ટેક્સટ ના ઇથ અક્ષર

504
00:36:58,300 --> 00:37:02,500
છે સાદી ભાષા ના ઇથ પાત્ર અનુલક્ષે જઈ રહી છે.

505
00:37:02,500 --> 00:37:08,130
તે અર્થમાં બનાવે છે કારણ કે અમે હંમેશા આ બાબતો ઉપર આવરણ શકાય માંગો છો.

506
00:37:08,130 --> 00:37:13,480
તેથી તે ગૂઢ વત્તા કે, જે આપણા કી છે ઇથ અક્ષર જ હશે -

507
00:37:13,480 --> 00:37:17,230
તે અર્થમાં બનાવે છે - અને તે પછી અમે આ 26 મોડ છે.

508
00:37:17,230 --> 00:37:19,860
પાછા યાદ રાખો જ્યારે અમે ઝેડ હતી

509
00:37:19,860 --> 00:37:24,190
અમે અક્ષર પ્રવેશ મેળવવા ઇચ્છતા ન હતા તેથી અમે તેને mod માગે છે

510
00:37:24,190 --> 00:37:26,540
મૂળાક્ષરમાંથી આસપાસ અને કામળો પ્રકારની.

511
00:37:26,540 --> 00:37:33,430
ઝેડ તમે જશે, બી, સી, ડી, જ્યાં સુધી તમે યોગ્ય નંબર મેળવ્યો.

512
00:37:33,430 --> 00:37:44,690
તેથી આપણે જાણીએ છીએ કે ઝેડ, જો 6 +, અમને એફ આપી કારણ કે પછી ઝેડ એક, એફ B, C, ડી, ઇ, આવે કરશે.

513
00:37:44,690 --> 00:37:52,530
તેથી આપણે યાદ રાખવું અમને ખાતરી છે કે માટે જાણો છો કે ઝેડ + + 6 અમને એફ આપી રહ્યું છે.

514
00:37:52,530 --> 00:38:03,530
તે ASCII કિંમતો, z 122 છે અને એફ 102 છે.

515
00:38:03,530 --> 00:38:10,570
જેથી અમે અમારા સીઝર સૂત્ર બનાવવા કેટલાક માર્ગ શોધી અમને 102 આપી

516
00:38:10,570 --> 00:38:13,590
122 માં લીધા બાદ.

517
00:38:13,590 --> 00:38:19,550
તેથી જો આપણે ફક્ત આ સૂત્ર છે, ('z' 6 +) 26% છે, જે વાસ્તવમાં તમે 24 આપે અરજી કરવી

518
00:38:19,550 --> 00:38:25,980
કારણ કે 122 + 6 128 છે; 128 26% તમે 24 શેષ આપે છે.

519
00:38:25,980 --> 00:38:29,140
પરંતુ ખરેખર એફ અર્થ એ નથી. જેનાથી 102 નથી.

520
00:38:29,140 --> 00:38:33,590
કે જેઓ પણ મૂળાક્ષરમાં 6 ઠ્ઠી પત્ર નથી.

521
00:38:33,590 --> 00:38:41,550
તેથી દેખીતી રીતે, અમે આ થોડો tweaking કેટલાક માર્ગ જરૂર પડે છે.

522
00:38:42,970 --> 00:38:51,340
નિયમિત મૂળાક્ષર શરતો માં, આપણે જાણીએ છીએ કે z 26 અક્ષર હોય છે અને એફ 6 ઠ્ઠી છે.

523
00:38:51,340 --> 00:38:55,460
પરંતુ અમે કોમ્પ્યુટર વિજ્ઞાન છો, તેથી અમે 0 અંતે ઇન્ડેક્સ રહ્યા છીએ.

524
00:38:55,460 --> 00:39:00,690
તેથી પછી તેની જગ્યાએ z અને 26 નંબર હોવાની, અમે તે નંબર 25 કહેવું જઈ રહ્યાં છો

525
00:39:00,690 --> 00:39:02,630
કારણ કે એક 0 છે.

526
00:39:02,630 --> 00:39:04,770
તેથી હવે આપણે આ સૂત્ર લાગુ પડે છે.

527
00:39:04,770 --> 00:39:11,710
અમે હોય z 25 + 6 દ્વારા રજૂ, કે જે તમને 31 આપે છે.

528
00:39:11,710 --> 00:39:15,790
અને 31 26 mod તમે શેષ 5 આપે છે.

529
00:39:15,790 --> 00:39:20,500
સંપૂર્ણ છે કારણ કે આપણે જાણીએ છીએ કે એફ મૂળાક્ષરમાંથી માં 5 અક્ષર છે.

530
00:39:20,500 --> 00:39:26,400
પરંતુ તે હજુ f, અધિકાર નથી? તે હજી પણ 102 નથી.

531
00:39:26,400 --> 00:39:32,730
તેથી પછી આ pset માટે એક પડકાર બહાર સંબંધ શોધવાનો પ્રયાસ કરવામાં આવશે

532
00:39:32,730 --> 00:39:36,910
આ તે ASCII મૂલ્યો અને મૂળાક્ષર ઇન્ડેક્સ વચ્ચે રૂપાંતર વચ્ચે.

533
00:39:36,910 --> 00:39:40,280
આવશ્યકપણે, તમે શું કરવા માંગો છો પડશે, તો તમે તે ASCII કિંમતો સાથે પ્રારંભ કરવા માગો છો,

534
00:39:40,280 --> 00:39:45,390
પરંતુ તે પછી તમે કોઈક એક મૂળાક્ષર અનુક્રમણિકા માં કે અનુવાદિત કરવા માંગો છો

535
00:39:45,390 --> 00:39:52,610
પછી ગણતરી અક્ષર તે પ્રયત્ન કરીશું - મૂળભૂત, તેના મૂળાક્ષર ઇન્ડેક્સ શું છે

536
00:39:52,610 --> 00:39:57,660
આ સાઇફર પાત્ર - પછી તે પાછી ASCII કિંમતો માટે અનુવાદ.

537
00:39:57,660 --> 00:40:04,870
તેથી જો તમે તમારા ASCII ટેબલ ચાબુક, પછી પ્રયત્ન કરો અને વચ્ચે સંબંધો શોધવા માટે, જેમ કે, 102 અને 5

538
00:40:04,870 --> 00:40:10,440
અથવા 122 અને 25.

539
00:40:12,140 --> 00:40:15,690
અમે આદેશ વાક્ય દલીલો અમારા કી મેળવેલ કર્યું છે, અમે સાદી ભાષા મેળવેલ કરી લીધી છે,

540
00:40:15,690 --> 00:40:17,520
અમે તેને enciphered કર્યું છે.

541
00:40:17,520 --> 00:40:19,820
હવે અમે શું બાકી છે તે છાપો.

542
00:40:19,820 --> 00:40:22,040
અમે આ અલગ અલગ રીતે એક દંપતિ કરી શકે.

543
00:40:22,040 --> 00:40:24,570
અમે કરી શકે શું ખરેખર આપણે સાથે જાઓ છાપી છે.

544
00:40:24,570 --> 00:40:28,250
, આપણે ઉપર શબ્દમાળા માં અક્ષરો ફરી વળવું

545
00:40:28,250 --> 00:40:31,660
અમે ફક્ત બરાબર પછી છાપી શકે છે જ્યારે અમે તે ગણતરી.

546
00:40:31,660 --> 00:40:36,030
વૈકલ્પિક રીતે, તમે પણ તે એરે માં સંગ્રહે શકે અને અક્ષરો ઝાકઝમાળ છે

547
00:40:36,030 --> 00:40:39,280
અને અંતે તે સમગ્ર એરે પર ફરી વળવું અને તે પ્રિન્ટ આઉટ.

548
00:40:39,280 --> 00:40:40,980
તેથી કે જે તમને માટે વિકલ્પો થોડા હોય છે.

549
00:40:40,980 --> 00:40:47,280
યાદ છે અને તે% સી એક અક્ષર છાપવા માટે પ્લેસહોલ્ડર પ્રયત્ન રહ્યું છે.

550
00:40:47,280 --> 00:40:50,420
તેથી અમે સીઝર હોય છે, અને હવે અમે Vigenere પર ખસેડો,

551
00:40:50,420 --> 00:40:57,580
જે અત્યંત સીઝર માટે સમાન છે, પરંતુ ફક્ત થોડી વધારે જટિલ છે.

552
00:40:57,580 --> 00:41:03,310
તેથી Vigenere સાથે અનિવાર્યપણે તમે કીવર્ડ માં પસાર કરી છે જઈ રહ્યાં છો.

553
00:41:03,310 --> 00:41:06,510
તેથી તેના બદલે એક નંબર, તમે એક શબ્દમાળા છે જઈ રહ્યાં છો,

554
00:41:06,510 --> 00:41:09,200
અને જેથી તમારા કીવર્ડ તરીકે કામ ચાલી રહ્યું છે.

555
00:41:09,200 --> 00:41:14,440
પછી, સામાન્ય તરીકે, તમે શબ્દમાળા માટે વપરાશકર્તા માંથી પ્રોમ્પ્ટ મેળવવા જઈ રહ્યાં છો

556
00:41:14,440 --> 00:41:19,050
અને પછી તેને ચિહ્નિત કરો અને પછી તેમને ગૂઢ પાછા આપે છે.

557
00:41:19,050 --> 00:41:24,650
જેથી મેં કહ્યું હતું, તે ખૂબ જ સીઝર માટે સમાન બદલે ચોક્કસ સંખ્યા દ્વારા સ્થળાંતર ઓફ સિવાય, છે,

558
00:41:24,650 --> 00:41:30,620
સંખ્યા ખરેખર અક્ષર અક્ષર પર દર વખતે બદલી રહ્યું છે.

559
00:41:30,620 --> 00:41:34,890
કે વાસ્તવિક સંખ્યા પ્રતિનિધિત્વ કરવા માટે પાળી, તે કીબોર્ડ અક્ષરો દ્વારા રજૂ કરવામાં આવ્યું છે.

560
00:41:34,890 --> 00:41:43,150
તેથી જો તમે એક છે, હમણાં પૂરતું પાળી દાખલ કરો, પછી કે 0 ની પાળી અનુલક્ષે કરશે.

561
00:41:43,150 --> 00:41:45,900
જેથી તે ફરીથી છે મૂળાક્ષર અનુક્રમણિકા નહીં.

562
00:41:45,900 --> 00:41:49,100
શું ઉપયોગી હોઈ શકે જો તમને જોઈ રહ્યાં છો કે અમે ખરેખર તે ASCII કિંમતો સાથે કામ કરીએ છીએ શકે છે

563
00:41:49,100 --> 00:41:51,790
તેમજ પત્રો, તેમજ મૂળાક્ષર અનુક્રમણિકા તરીકે,

564
00:41:51,790 --> 00:41:58,020
કદાચ શોધવા અથવા તમારા પોતાના ASCII કોષ્ટક કે જે 25 મારફતે 0 મૂળાક્ષર અનુક્રમણિકા બતાવે બનાવવા માટે,

565
00:41:58,020 --> 00:42:03,750
કે જેથી z મારફતે, અને તે ASCII કિંમતો તમે પ્રકારની સંબંધ જોઈ શકો છો

566
00:42:03,750 --> 00:42:07,020
અને રેખાચિત્ર અને પ્રયાસ અને કેટલાક પેટર્ન શોધો.

567
00:42:07,020 --> 00:42:11,010
તેવી જ રીતે, જો તમે ચોક્કસ ઉદાહરણ અંતે એફ દ્વારા રહ્યા હતા -

568
00:42:11,010 --> 00:42:21,110
અને ક્યાં તો લોઅરકેસ અથવા મોટા એફ છે - પછી તે 5 અનુલક્ષે કરશે.

569
00:42:21,110 --> 00:42:24,180
આપણે અત્યાર સુધી સારો?

570
00:42:25,770 --> 00:42:30,050
Vigenere માટે સૂત્ર થોડી અલગ છે.

571
00:42:30,050 --> 00:42:32,960
મૂળભૂત રીતે, તમે જુઓ છો કે તે સીઝર જેમ જ છે,

572
00:42:32,960 --> 00:42:37,390
ને બદલે સિવાય માત્ર k અમે k અનુક્રમણિકા જ હોય ​​છે.

573
00:42:37,390 --> 00:42:44,810
નોંધ કરો કે આપણે હું કારણ કે અનિવાર્યપણે નથી ઉપયોગ કરી રહ્યાં છો, મુખ્ય શબ્દ ની લંબાઈ

574
00:42:44,810 --> 00:42:49,850
છે તે જરૂરી નથી અમારી ગૂઢ લંબાઈ.

575
00:42:49,850 --> 00:42:56,130
આ એક બીટ સ્પષ્ટ હોય ત્યારે આપણે એક ઉદાહરણ કે હું બીટ પર પછીથી હોય જોશો.

576
00:42:56,130 --> 00:43:03,160
મૂળભૂત રીતે, જો તમે ohai એક કીવર્ડ સાથે તમારા કાર્યક્રમ ચલાવવા માટે,

577
00:43:03,160 --> 00:43:08,560
પછી તે અર્થ એ થાય કે દર વખતે, ohai તમારા પાળી પ્રયત્ન રહ્યું છે.

578
00:43:08,560 --> 00:43:11,060
તેથી તેના આધારે સ્થિતિ શું તમે તમારા કીવર્ડ છે પર,

579
00:43:11,060 --> 00:43:15,800
તમે તે રકમ દ્વારા તમારા ચોક્કસ ગૂઢ અક્ષર પાળી રહ્યા છીએ.

580
00:43:15,800 --> 00:43:19,630
ફરીથી, સીઝર જેમ જ, અમે ખાતરી કરવા માટે કે આપણે વસ્તુઓના કેપિટલાઈઝેશન બચાવવા બનાવવા માંગો છો

581
00:43:19,630 --> 00:43:22,900
અને અમે માત્ર ચિહ્નિત કરો, અક્ષરો અથવા ખાલી જગ્યાઓ નથી અક્ષરો.

582
00:43:22,900 --> 00:43:26,330
તેથી સીઝર પાછળ વિધેયો કે જે તમે ઉપયોગ કર્યો હોઈ શકે પર જુઓ,

583
00:43:26,330 --> 00:43:32,570
કે જે રીતે તમે નક્કી કર્યું છે કે કેવી રીતે વસ્તુઓ પાળી માટે, અને તમારા કાર્યક્રમ માટે કે અહીં લાગુ પડે છે.

584
00:43:32,570 --> 00:43:35,260
તેથી આ બહાર મેપ દો.

585
00:43:35,260 --> 00:43:39,680
અમે સાદાલખાણ કે અમે વપરાશકર્તાના GetString માંથી મેળવેલ કર્યું છે પાસે

586
00:43:39,680 --> 00:43:44,090
આ કહેતા ... CS50 છે!

587
00:43:44,090 --> 00:43:47,090
તો પછી અમે ohai એક કીવર્ડ છે.

588
00:43:47,090 --> 00:43:50,930
પ્રથમ 4 અક્ષરો ખૂબ સરળ હોય છે.

589
00:43:50,930 --> 00:43:55,580
અમે જાણીએ છીએ કે ટી ​​ઓ દ્વારા ખસેડાયેલો શકાય રહ્યું છે,

590
00:43:55,580 --> 00:44:01,990
પછી h,-h દ્વારા ખસેડાયેલો શકાય રહ્યું છે, હું એક ખસેડવામાં આવશે રહ્યું છે.

591
00:44:01,990 --> 00:44:04,610
અહીં તમે જુઓ કે જે 0 રજૂ કરે છે,

592
00:44:04,610 --> 00:44:11,940
જેથી તે પછી ઓવરને કિંમત ખરેખર માત્ર પહેલાની જેમ જ અક્ષર છે.

593
00:44:11,940 --> 00:44:15,250
પછી ઓ આઇ દ્વારા ખસકી ગયેલ છે.

594
00:44:15,250 --> 00:44:19,370
પરંતુ તે પછી તમે આ સમયગાળા અહીં છે.

595
00:44:19,370 --> 00:44:25,960
અમે ચિહ્નિત કરો કે, તેથી તે પછી અમે તેને કંઈપણ દ્વારા ફેરફાર કરતી નથી નથી માંગતા

596
00:44:25,960 --> 00:44:31,280
અને બસ બદલ્યા સમય છાપો.

597
00:44:31,280 --> 00:44:38,020
[વિદ્યાર્થી] હું કેવી રીતે તમે જાણો છો કે આ દ્વારા ખસેડાયેલો નથી નથી - તમે ક્યાં હતી - >> ઓહ, માફ.

598
00:44:38,020 --> 00:44:41,620
અહીં ટોચ પર છે કે જે તમને આદેશ વાક્ય દલીલ અહીં ohai જુઓ,

599
00:44:41,620 --> 00:44:43,740
કે મુખ્ય શબ્દ જ હશે.

600
00:44:43,740 --> 00:44:49,550
અને તેથી મૂળભૂત, તો તમે કીવર્ડ માં અક્ષરો પર રાખતા રહ્યા છો.

601
00:44:49,550 --> 00:44:52,020
[વિદ્યાર્થી] તેથી ઓ એ જ સ્થળાંતર કરી રહ્યું છે -

602
00:44:52,020 --> 00:44:56,260
તેથી ઓ મૂળાક્ષરો એક ચોક્કસ નંબર અનુલક્ષે છે.

603
00:44:56,260 --> 00:44:58,400
[વિદ્યાર્થી] અધિકાર. પરંતુ જ્યાં તમે CS50 ભાગ વિચાર નહીં?

604
00:44:58,400 --> 00:45:02,540
ઓહ. કે GetString જ્યાં તમે જેમ, છીએ છે "મને એક બેવડી શબ્દમાળા આપો."

605
00:45:02,540 --> 00:45:07,510
[વિદ્યાર્થી] તેઓ તમારા કે દ્વારા પાળી દલીલ આપી રહ્યા છીએ

606
00:45:07,510 --> 00:45:09,380
અને પછી તમે તમારા પ્રથમ શબ્દમાળા માટે કહીશું. >> યાહ.

607
00:45:09,380 --> 00:45:12,440
તેથી જ્યારે તેઓ કાર્યક્રમ ચલાવો, તેઓ કીવર્ડ સમાવેશ જઈ રહ્યાં છો

608
00:45:12,440 --> 00:45:14,740
તેમના આદેશ વાક્ય દલીલો જ્યારે તેઓ તેને ચલાવો.

609
00:45:14,740 --> 00:45:19,740
પછી એક વાર તમે ચેક કર્યું છે કે તેઓ ખરેખર તમે 1 આપી છે અને વધુ, ઓછા નથી,

610
00:45:19,740 --> 00:45:23,750
પછી તમે તેમને શબ્દમાળા માટે પૂછવા માટે જઈ રહ્યાં છો કહે, "મને એક શબ્દમાળા આપો."

611
00:45:23,750 --> 00:45:27,630
તેથી કે જ્યાં આ કિસ્સામાં તેઓ તમને આ આપી છે ... CS50 છે!

612
00:45:27,630 --> 00:45:32,090
તેથી પછી તમે તે વાપરો અને ohai ઉપયોગ અને ફરી વળવું રહ્યા છીએ.

613
00:45:32,090 --> 00:45:38,200
નોંધ કરો કે અહીં અમે પૂર્ણવિરામ એનક્રિપ્ટ પર છોડવામાં આવી,

614
00:45:38,200 --> 00:45:51,660
પરંતુ અમારા પોઝિશન ohai, આગામી એક માટે દ્રષ્ટિએ અમે ઓ ઉપયોગ થાય છે.

615
00:45:51,660 --> 00:45:54,990
આ કિસ્સામાં તે બીટ મુશ્કેલ છે કારણ કે તે જોવા માટે કે 4 છે,

616
00:45:54,990 --> 00:45:57,710
તેથી આપણે થોડી ચાલુ રાખો. જસ્ટ મારી સાથે અહીં વળગી.

617
00:45:57,710 --> 00:46:02,960
તો પછી અમે i અને ઓ, કે જે પછી ઓ અને ક દ્વારા કરવામાં આવે છે અનુક્રમે ભાષાંતર હોય છે.

618
00:46:02,960 --> 00:46:09,370
ત્યાર બાદ અમે એક જગ્યા હોય છે, અને તેથી તે પછી આપણે જાણીએ છીએ કે અમે જગ્યાઓ ચિહ્નિત કરો નથી જઈ રહ્યા છે.

619
00:46:09,370 --> 00:46:18,930
પરંતુ સૂચના બદલે આ સ્થળ એક માટે અહીં જવાની,

620
00:46:18,930 --> 00:46:28,330
અમે દ્વારા એનક્રિપ્ટ કરી રહ્યા છીએ - અહીં - હું જો તમે જોઈ શકો છો કે જે જાણતા નથી.

621
00:46:28,330 --> 00:46:33,710
તેથી તે ગમે તમે ખરેખર પૂર્વનિર્ધારિત નથી, કહે છે, ઓ અહીં જાય છે, ક અહીં જાય છે,

622
00:46:33,710 --> 00:46:39,200
અહીં એક જાય છે, હું અહીં જાય, ઓ,-h, એ, ઓ, આઇ,-h, એક હું. કે જે તમને નથી કરતી.

623
00:46:39,200 --> 00:46:43,760
તમે ફક્ત મુખ્ય શબ્દ તમારા સ્થિતિ પાળી

624
00:46:43,760 --> 00:46:51,020
જ્યારે તમે જાણો છો કે તમે ખરેખર વાસ્તવિક પત્ર એનક્રિપ્ટ કરી રહ્યા છીએ.

625
00:46:51,020 --> 00:46:53,920
કરતું નથી તે પ્રકારના અર્થમાં છે?

626
00:46:53,920 --> 00:46:55,800
ઠીક છે.

627
00:46:56,490 --> 00:46:58,500
જેથી માત્ર કેટલીક રીમાઇન્ડર્સ.

628
00:46:58,500 --> 00:47:03,760
તમે ખાતરી કરો કે તમે ફક્ત તમારા કીવર્ડ આગામી પત્ર આગળ બનાવવા માંગો છો

629
00:47:03,760 --> 00:47:06,390
જો તમારી સાદી ભાષા માં અક્ષર એક પત્ર છે.

630
00:47:06,390 --> 00:47:09,120
તેથી કહેવું અમે ઓ પર છો.

631
00:47:09,120 --> 00:47:19,310
અમે નોંધ્યું છે કે આગામી પાત્ર, જે સાદી ભાષા ના હું અનુક્રમણિકા, એક નંબર છે, હમણાં પૂરતું છે.

632
00:47:19,310 --> 00:47:31,630
તો પછી અમે જ, અમારા કીવર્ડ માટે ઇન્ડેક્સ આગળ ન હોય, તો ત્યાં સુધી આપણે બીજું પત્ર પહોંચે છે.

633
00:47:31,630 --> 00:47:36,230
ફરીથી, તમે પણ કીવર્ડ શરૂઆતમાં ખાતરી કરો કે તમે wraparound બનાવવા માંગો છો

634
00:47:36,230 --> 00:47:37,770
જ્યારે તમે તેને ઓવરને અંતે છો.

635
00:47:37,770 --> 00:47:42,030
જો તમે જોઈ અહીં અમે હું પર છો, તો આગામી એક ઓ પ્રયત્ન છે.

636
00:47:42,030 --> 00:47:47,690
જેથી તમે તમારા કીવર્ડ શરૂઆતમાં wraparound માટે સક્ષમ હોવાની કેટલાક માર્ગ શોધવા માંગો છો

637
00:47:47,690 --> 00:47:49,470
દરેક સમય છે કે જે તમે ઓવરને પહોંચે છે.

638
00:47:49,470 --> 00:47:55,040
અને તેથી ફરી ઓપરેટર પ્રકારની શું આસપાસ રેપિંગ માટે તે કિસ્સામાં ઉપયોગી છે?

639
00:47:56,630 --> 00:47:59,840
ઉદાહરણ બોલ ગણતરી માં ગમે છે.

640
00:47:59,840 --> 00:48:03,710
[વિદ્યાર્થી] ટકા સાઇન. >> અરે વાહ, આ ટકા સાઇન છે, કે જે મોડ્યૂલો છે.

641
00:48:03,710 --> 00:48:11,250
તેથી મોડ્યૂલો હાથમાં અહીં આવે છે જ્યારે તમે ઉપર તમારી ohai માં ઇન્ડેક્સ લપેટી કરવા માંગો છો કરશે.

642
00:48:11,250 --> 00:48:17,700
અને માત્ર એક ઝડપી હિંટ: આ ગણતરી બોલ જેવા બીટ મુખ્ય શબ્દ પર રેપિંગ લાગે છે પ્રયાસ કરો,

643
00:48:17,700 --> 00:48:23,590
જ્યાં જો ત્યાં 3 જૂથો, 4 થી વ્યક્તિ છે,

644
00:48:23,590 --> 00:48:30,610
તેમની સંખ્યા કે તેઓ જણાવ્યું હતું કે 4 3 મોડ છે, કે જે 1 હતી.

645
00:48:30,610 --> 00:48:32,880
તેથી પ્રયત્ન કરો અને તે વિચારે છે કે રસ્તો.

646
00:48:34,770 --> 00:48:42,740
જેમ તમે સૂત્ર માં થયો હતો, જ્યારે પણ તમે સીઆઇ અને પછી પાઇ છે પણ પછી કેજે,

647
00:48:42,740 --> 00:48:44,700
તમે ખાતરી કરો કે તમે તે ટ્રેક રાખવા બનાવવા માંગો છો.

648
00:48:44,700 --> 00:48:47,580
તમે તેને હું કહી કરવાની જરૂર નથી, તો તમે તેને જ કૉલ કરવાની જરૂર નથી,

649
00:48:47,580 --> 00:48:53,270
પરંતુ તમે ખાતરી કરો કે તમે પદ કે તમે તમારા સાદાલખાણ ખાતે ટ્રેક રાખવા બનાવવા માંગો છો

650
00:48:53,270 --> 00:48:55,790
તરીકે સ્થિતિ તેમજ જે તમે તમારા કીવર્ડ ખાતે છો

651
00:48:55,790 --> 00:48:59,840
કારણ કે તે જરૂરી જ નથી જવાનું છે.

652
00:48:59,840 --> 00:49:06,400
માત્ર કીવર્ડ કરે છે - તે તમારા સાદી ભાષા કરતાં સંપૂર્ણપણે અલગ લંબાઈ હોઈ શકે છે.

653
00:49:06,400 --> 00:49:09,140
પણ, તમારા સાદી ભાષા, ત્યાં નંબર્સ અને અક્ષરો છે,

654
00:49:09,140 --> 00:49:14,450
તેથી તે માટે સંપૂર્ણપણે અપ મળીને મેળ ખાતી નથી ચાલી રહ્યું છે. હા.

655
00:49:14,450 --> 00:49:19,280
[વિદ્યાર્થી] ત્યાં એક કેસ બદલી કાર્ય છે?

656
00:49:19,280 --> 00:49:24,530
તમે એક મૂડી માટે ફેરફાર કરી શકો છો? >> અરે વાહ, અહીં ચોક્કસપણે છે.

657
00:49:24,530 --> 00:49:27,890
તમે તપાસી શકો છો - હું તે toupper, બધા 1 શબ્દ માને છે.

658
00:49:30,650 --> 00:49:36,310
પરંતુ, જ્યારે તમે વસ્તુઓ સાઇફર અને લખાણ સાચવવા પ્રયાસ કરી રહ્યા છો

659
00:49:36,310 --> 00:49:39,350
તે શ્રેષ્ઠ મૂળભૂત કરવા માટે અલગ કિસ્સાઓમાં હોય છે.

660
00:49:39,350 --> 00:49:42,040
જો તે એક મોટા છે, તો પછી તમે આ દ્વારા પાળી માંગો છો

661
00:49:42,040 --> 00:49:46,460
કારણ કે તમારા સૂત્રમાં, જ્યારે તમે પાછા જોવા અમે કેવી રીતે જઇ પ્રકારની હોય

662
00:49:46,460 --> 00:49:50,900
પરસ્પર નંબરો રજૂ ની ASCII માર્ગ વચ્ચે

663
00:49:50,900 --> 00:49:55,020
અને વાસ્તવિક મૂળાક્ષર અનુક્રમણિકા, અમે ખાતરી કરવા માંગો છો

664
00:49:55,020 --> 00:50:01,850
ત્યાં પેટર્ન અમુક પ્રકારની છે કે જે તમે ઉપયોગ કરવા જઈ રહ્યાં છો જ હશે.

665
00:50:01,850 --> 00:50:04,580
પેટર્ન પર બીજી નોંધ ખરેખર.

666
00:50:04,580 --> 00:50:07,250
તમે ચોક્કસપણે નંબરો સાથે વ્યવહાર કરવામાં જઈ રહ્યાં છો.

667
00:50:07,250 --> 00:50:11,280
જાદુ નંબર્સ ઉપયોગ કરવાનો પ્રયાસ કરો, કે જે શૈલી એક ઉદાહરણ છે.

668
00:50:11,280 --> 00:50:18,470
તેથી કહેવું તમને ગમે દ્વારા દર વખતે પાળી કંઈક કરવા માંગો છો -

669
00:50:18,470 --> 00:50:22,400
ઠીક છે, સંકેત, જેથી અન્ય સ્પોઇલર છે જ્યારે તમે કંઈક ફરતું કરી રહ્યા છીએ

670
00:50:22,400 --> 00:50:26,310
ચોક્કસ રકમ દ્વારા માટે એક વાસ્તવિક નંબર દ્વારા કે પ્રતિનિધિત્વ કરવાનો પ્રયાસ કરો

671
00:50:26,310 --> 00:50:32,810
પરંતુ પ્રયત્ન કરો અને જુઓ જો તમે તે ASCII કિંમત છે, કે જે પ્રકારની વધુ અર્થમાં કરશે વાપરી શકો છો.

672
00:50:32,810 --> 00:50:35,470
બીજી નોંધ: અમે સૂત્રો સાથે કામ કરીએ છીએ,

673
00:50:35,470 --> 00:50:41,200
ભલે તમારી ટીએફ પ્રકારની ખબર પેટર્ન શું તમે ઉપયોગ કરી શકે છે,

674
00:50:41,200 --> 00:50:44,430
તમારી ટિપ્પણીઓ પ્રકારની કરવા માટે શ્રેષ્ઠ તર્કશાસ્ત્ર, ગમે સમજાવવું,

675
00:50:44,430 --> 00:50:51,880
"હું કારણ કે આ પેટર્ન ઉપયોગ કરું છું ..." અને પ્રકારની પેટર્ન સંક્ષિપ્તમાં સમજાવો તમારી ટિપ્પણીઓમાં.

676
00:50:54,090 --> 00:50:58,990
[આ 2 walkthrough હતું] જો કોઇ અન્ય પ્રશ્નો છે, તો પછી હું ફક્ત થોડો માટે અહીં રહેવા પડશે.

677
00:50:58,990 --> 00:51:04,370
ક્રિપ્ટો અને આગામી માટે આભાર: તમારા 2 pset સાથે શુભેચ્છા.

678
00:51:06,070 --> 00:51:08,620
[વિદ્યાર્થી] આપનો આભાર. >> આભાર.

679
00:51:09,220 --> 00:51:10,800
[મીડિયા ઑફલાઇન પ્રસ્તાવના]