1
00:00:00,000 --> 00:00:00,930

2
00:00:00,930 --> 00:00:04,030
>> ચાન: માતાનો ધપાવવું દો અમારા
Vigenère સાઇફર સાથે રમત.

3
00:00:04,030 --> 00:00:06,710
Vigenère સાઇફર છે
ખૂબ જ સીઝર માટે સમાન છે,

4
00:00:06,710 --> 00:00:11,060
સીઝર સિવાય અમે પસાર
અમારા કી તરીકે એક પૂર્ણાંક.

5
00:00:11,060 --> 00:00:14,100
Vigenere અમે જઈ રહ્યાં છો
શબ્દ માં પસાર કરે છે.

6
00:00:14,100 --> 00:00:19,400
તેથી, પાળી જો હું ઈચ્છતો
સાઇફર ટેક્સટ આ 50 સીએસ ohai છે,

7
00:00:19,400 --> 00:00:23,260
પછી તે અર્થ એ થાય દરેક અક્ષર કે
ohai કી તરીકે સેવા આપવા માટે જતા હોય છે,

8
00:00:23,260 --> 00:00:27,160
અને હું ઉપર ખસેડવા માટે જઇ રહ્યો છું
મારા પાળી માટે કે મુખ્ય શબ્દ

9
00:00:27,160 --> 00:00:31,930
સાઇફર ટેક્સટ બનાવે
ઘણો મુશ્કેલ ડિકોડ.

10
00:00:31,930 --> 00:00:34,540
>> તે શું અર્થ છે
કીવર્ડ દ્વારા પાળી?

11
00:00:34,540 --> 00:00:38,610
વેલ, શબ્દ એક સ્ટ્રિંગ છે
જ્યાં દરેક અક્ષર અનુલક્ષે

12
00:00:38,610 --> 00:00:41,080
કેટલાક પૂર્ણાંક પાળી.

13
00:00:41,080 --> 00:00:49,310
તેથી હે 14 કી અનુલક્ષે,
7 એક કી એચ, 0 કી છે,

14
00:00:49,310 --> 00:00:54,670
જેથી કંઈપણ બદલી ન હોત,
અને પછી હું 8 કી છે.

15
00:00:54,670 --> 00:01:00,000
>> હું સાથે Vigenere એક ચાલી કહો
સાદા લખાણ આ CS50 સારી છે,

16
00:01:00,000 --> 00:01:02,800
કે ફક્ત આપશે
મને એક યથાવત શબ્દમાળા.

17
00:01:02,800 --> 00:01:08,170
નોંધ કરો કે આ માટે સમકક્ષ હોય છે
શૂન્ય કી સાથે સીઝર ચાલી રહ્યું છે.

18
00:01:08,170 --> 00:01:12,070
હકીકતમાં, ચાલી Vigenere
કોઈ એક પાત્ર સાથે

19
00:01:12,070 --> 00:01:17,070
ચાલી સમકક્ષ હશે
તે જ પૂર્ણાંક સાથે સીઝર.

20
00:01:17,070 --> 00:01:20,400
>> બધા હક છે, તેથી,
જેથી તેઓ સમાન હું હો

21
00:01:20,400 --> 00:01:24,300
ખરેખર ભલામણ છે કે જો તમે
તમે ફક્ત તમારા સીઝર નકલ કરી શકો છો

22
00:01:24,300 --> 00:01:26,932
તમારા Vigenere કોડમાં કોડ.

23
00:01:26,932 --> 00:01:28,640
વસ્તુઓ બદલાશે
પરંતુ ઓછામાં ઓછા તમે છે

24
00:01:28,640 --> 00:01:31,110
કેટલાક કરોડરજ્જુ કે તમારી સાથે કામ કરી શકો છો.

25
00:01:31,110 --> 00:01:36,410
કારણ કે Todos જ અમે માંગો છો
કી મેળવવા માટે, સાદા લખાણ,

26
00:01:36,410 --> 00:01:40,690
ચિહ્નિત કરો કે સાદા લખાણ,
અને પછી તે છાપે.

27
00:01:40,690 --> 00:01:44,980
>> જસ્ટ સીઝર જેવા કી રહ્યું છે
બીજા આદેશ વાક્ય તરીકે પસાર કરી

28
00:01:44,980 --> 00:01:50,540
દલીલ argv ઇન્ડેક્સ સમાયેલ
1, પરંતુ તે આ સમયે અલગ છે

29
00:01:50,540 --> 00:01:52,560
કારણ કે તે મૂળાક્ષર હોવા જ જોઈએ.

30
00:01:52,560 --> 00:01:56,390
તેથી, અમે દરેક ઉપર ફરી વળવું જરૂર
તે કી માં એક પાત્ર

31
00:01:56,390 --> 00:02:00,800
વપરાશકર્તા પસાર, અને ખાતરી કરો કે
દરેક અક્ષર આલ્ફાબેટીક છે કે

32
00:02:00,800 --> 00:02:02,800
ચાલુ રાખવા માટે ક્રમમાં.

33
00:02:02,800 --> 00:02:05,560
>> એકવાર અમે તે પછી કર્યું અમે
વપરાશકર્તા માંથી શબ્દમાળા મેળવવા કરી શકો છો,

34
00:02:05,560 --> 00:02:07,560
જેમ આપણે પહેલાં કર્યું હતું.

35
00:02:07,560 --> 00:02:10,520
અને હવે, અમે હૃદય આવે
Vigenere માટે સમસ્યા,

36
00:02:10,520 --> 00:02:14,665
જે ફક્ત સીઝર, કેવી રીતે જેવી છે
enciphering પેટર્ન બહાર આકૃતિ

37
00:02:14,665 --> 00:02:19,760
અને સમીકરણ, અને ચિહ્નિત કરો
સમગ્ર સાદી ભાષા.

38
00:02:19,760 --> 00:02:23,280
>> તેથી, જો તમે કે નોટિસ પડશે
Vigenere પાળી માટે સમીકરણ

39
00:02:23,280 --> 00:02:25,610
ખૂબ જ સીઝર એક સમાન છે.

40
00:02:25,610 --> 00:02:29,780
માત્ર એટલો જ તફાવત છે કે
તેના બદલે એક ચલ K ના

41
00:02:29,780 --> 00:02:37,270
પહેલાં, હવે K એક સબસ્ક્રિપ્ટ છે,
કી jth પત્ર સૂચવે છે.

42
00:02:37,270 --> 00:02:39,560
>> ચાલો એક ઉદાહરણ લઈ જવામાં દો.

43
00:02:39,560 --> 00:02:43,830
તમે એક ગુપ્ત પસાર કરવા માગે છે
તમારા ક્રસ પર સંદેશ, હું તમને ગમે છે.

44
00:02:43,830 --> 00:02:46,325
વેલ, તમારા કી માટે તમે
કંઈક કે જે પસંદ કરો તે તમારી

45
00:02:46,325 --> 00:02:49,790
ખબર ક્રશ જાણે છે કે તમને ગમે છે, Pandas.

46
00:02:49,790 --> 00:02:52,290
બધા હક છે, તેથી અમે કેવી રીતે આ પાળી શકું?

47
00:02:52,290 --> 00:02:55,500
>> વેલ, અમે અમારા સાદી ઇન્ડેક્સ છે.

48
00:02:55,500 --> 00:02:59,160
જે પ્રથમ અક્ષર પર છે અને
જેથી અમારી કી અનુક્રમણિકા છે

49
00:02:59,160 --> 00:03:02,830
જે પી, પ્રથમ છે
અમારા પાન્ડા શબ્દ પત્ર.

50
00:03:02,830 --> 00:03:08,590
તેથી, પી દ્વારા હું સ્થળાંતર અમને એક્સ આપે છે,
પછી અમે સાદી ઇન્ડેક્સ આગળ.

51
00:03:08,590 --> 00:03:10,460
આ એક જગ્યા માટે અમને નહીં.

52
00:03:10,460 --> 00:03:13,540
હવે, જગ્યા પાત્ર
બિન આલ્ફાબેટીક છે,

53
00:03:13,540 --> 00:03:16,930
જેથી અર્થ એ થાય કે, તે માત્ર
અધિકાર સાઇફર ટેક્સટ પર પરિવહન,

54
00:03:16,930 --> 00:03:23,430
આપણે ત્યાં એક જગ્યા મૂકી, અને અમે શું
અમારા કી માટે ઇન્ડેક્સ આગળ.

55
00:03:23,430 --> 00:03:25,820
તેથી, અમે આ સમયે પી હજુ પણ છો.

56
00:03:25,820 --> 00:03:30,130
>> અમે આગામી પર આગળ
અમારા સાદી ભાષા ઇન્ડેક્સ.

57
00:03:30,130 --> 00:03:34,030
અને હવે, કારણ કે તે છે
એક પત્ર, લોઅરકેસ એલ,

58
00:03:34,030 --> 00:03:37,920
અમે તે પાળી
અમારા કી આગામી ઇન્ડેક્સ.

59
00:03:37,920 --> 00:03:42,360
જે છે, જે એક શૂન્ય છે
પાળી કે જેથી માત્ર બની જાય છે

60
00:03:42,360 --> 00:03:44,370
અમારા સાઇફર ટેક્સટ માં એલ.

61
00:03:44,370 --> 00:03:51,120
પછી, અમે બંને સાદી આગળ, અને
કી ઇન્ડેક્સ કારણ કે તે આલ્ફાબેટીક છે.

62
00:03:51,120 --> 00:03:56,210
તેથી તો અમે ચાલુ રાખવા
ત્યાં સુધી અમે જેવા ઈ મળે છે.

63
00:03:56,210 --> 00:04:01,090
>> બધા હક છે, તેથી જો તમે આ નોટિસ પડશે
નિર્દેશ કરે છે કે અમારા કી ઇન્ડેક્સ દ્રષ્ટિએ,

64
00:04:01,090 --> 00:04:03,940
અમે અંત સુધી પહોંચી ગયા છો
પાંડા શબ્દ છે, તેથી શું

65
00:04:03,940 --> 00:04:08,750
થાય છે જ્યારે અમે આગામી મેળવવા
સાદી ભાષા આલ્ફાબેટીક પત્ર?

66
00:04:08,750 --> 00:04:12,180
વેલ, બધા આવું થાય છે અમે છે
શરૂઆતમાં આસપાસ લપેટી,

67
00:04:12,180 --> 00:04:14,710
અમારા કી પ્રથમ ઇન્ડેક્સ.

68
00:04:14,710 --> 00:04:19,570
તેથી, તો પછી અમે કે પાળી
પી દ્વારા વાય અમને n આપે છે.

69
00:04:19,570 --> 00:04:26,860
અને પછી, અમે એન્કોડિંગ પૂર્ણ ચાલુ
અમારા સાદી એક્સ lvne Noh વિચાર.

70
00:04:26,860 --> 00:04:29,300
>> આ ઉદાહરણ પ્રતિ, હું
દર્શાવે છે કે અમે માત્ર અગાઉથી

71
00:04:29,300 --> 00:04:33,140
શબ્દ આગામી પત્ર
જો સાદા લખાણમાં પાત્ર

72
00:04:33,140 --> 00:04:37,480
જેથી isalpha એક પત્ર છે
કાર્ય હાથમાં અહીં આવશે.

73
00:04:37,480 --> 00:04:43,030
અને, સીઝર તરીકે, અમે કરવા માંગો છો
કેસ, isupper અને islower જાળવણી કરે છે.

74
00:04:43,030 --> 00:04:46,100
તેથી, આ થોડો ઉમેરો
તમારા સ્યુડોકોડનો માં.

75
00:04:46,100 --> 00:04:48,510
>> તેથી અમે કેવી રીતે કી પાળી બહાર આકૃતિ નથી?

76
00:04:48,510 --> 00:04:53,030
વેલ, તમે અમારી ચર્ચા યાદ તો
સીઝર મૂળાક્ષર સૂચકાંક પર

77
00:04:53,030 --> 00:04:55,370
સમસ્યા છે, તે જ છે.

78
00:04:55,370 --> 00:05:01,130
>> જ્યાં એક એક ASCII અનુલક્ષે
65 ની કિંમત પરંતુ 0 ની પાળી,

79
00:05:01,130 --> 00:05:03,550
અને પછી છેલ્લો પત્ર
મૂળાક્ષરમાં, Z,

80
00:05:03,550 --> 00:05:06,940
25 એક પાળી અનુલક્ષે છે.

81
00:05:06,940 --> 00:05:10,320
તમે પાળી કે નોટિસ પડશે
સમાન છે કે નહીં

82
00:05:10,320 --> 00:05:14,880
પત્ર અપર કેસ અથવા નીચલા કેસ છે.

83
00:05:14,880 --> 00:05:17,700
>> ઠીક છે, તેથી હવે તમે તે
ખબર કેવી રીતે બહાર આકૃતિ

84
00:05:17,700 --> 00:05:21,470
આંકડાકીય પાળી કે
એક પાત્ર અનુલક્ષે

85
00:05:21,470 --> 00:05:24,050
અમારા સમીકરણ પાછા જવા દો.

86
00:05:24,050 --> 00:05:28,180
કારણ કે અમે બે અલગ અલગ હોય છે
અહીં સબસ્ક્રીપ્ટ્સ, હું અને જે,

87
00:05:28,180 --> 00:05:32,130
કે હિંટ કે અમે ટ્રેક રાખવા માંગો છો છે
બંને સાદી અમારા સ્થિતિ

88
00:05:32,130 --> 00:05:36,600
તેમજ કીવર્ડ અમારા સ્થિતિ તરીકે,
તેથી તે બે અલગ ચલો છે

89
00:05:36,600 --> 00:05:39,010
અમે એક પકડ રાખવા માંગો છો.

90
00:05:39,010 --> 00:05:42,580
>> હવે, આપણા સાદી ભાષા સ્થિતિ
દરેક સમય વધારવા માટે ચાલે છે,

91
00:05:42,580 --> 00:05:45,530
કે જેથી હોઈ ચાલે છે
થોડી વધુ સીધા આગળ

92
00:05:45,530 --> 00:05:49,750
સ્થિતિ કીવર્ડ વિરોધ,
જે આપણે જાણીએ છીએ આસપાસ લપેટી છે,

93
00:05:49,750 --> 00:05:52,910
અને ક્યારેક વધારો,
ક્યારેક જ રહે છે.

94
00:05:52,910 --> 00:05:55,430
તેથી, અમે કેવી રીતે અમલ કરી શકું
કાર્યક્ષમતા

95
00:05:55,430 --> 00:05:59,820
આસપાસ લપેટી
કિવર્ડ માટે અનુક્રમણિકા?

96
00:05:59,820 --> 00:06:01,640
>> હું બોલ ગણતરી ઉદાહરણ નો ઉપયોગ કરવા જઇ રહ્યો છું.

97
00:06:01,640 --> 00:06:06,100
બોલ ગણતરી લોકપ્રિય માર્ગ છે
જૂથો માં લોકો વિભાજિત કરવા માટે.

98
00:06:06,100 --> 00:06:10,660
કહો હું 5 લોકો હતા અને હું કરવા માંગતો
ત્રણ જૂથો માં તેમને વિભાજિત,

99
00:06:10,660 --> 00:06:13,640
વેલ પછી હું આ બોલ પર ગણતરી દ્વારા શરૂ કરશે.

100
00:06:13,640 --> 00:06:16,980
પ્રથમ વ્યક્તિ કરશે
કહે છે કે હું ટીમ માટે નંબર એક છું,

101
00:06:16,980 --> 00:06:21,030
આગામી વ્યક્તિ ટીમ નંબર હશે
બે, ત્રીજી વ્યક્તિ ટીમ નંબર

102
00:06:21,030 --> 00:06:21,910
ત્રણ.

103
00:06:21,910 --> 00:06:25,910
હવે, હું માત્ર ત્રણ જૂથો જેથી માંગો છો
ચોથી વ્યક્તિ ખરેખર કરશે

104
00:06:25,910 --> 00:06:30,160
શરૂઆતમાં શરૂ છે અને કહે છે,
વેલ, હું ટીમ નંબર વન છું,

105
00:06:30,160 --> 00:06:32,890
અને આગામી વ્યક્તિ
ટીમ બે નંબર હશે.

106
00:06:32,890 --> 00:06:37,660
અને, ત્યાંથી, તેઓ પછી કરી શકો છો
તેમના જૂથોમાં અલગ પાડો.

107
00:06:37,660 --> 00:06:41,130
>> તેથી, હું કેવી રીતે મોડ્યૂલો ઉપયોગ કરી શકે છે
મને અમલ કરવા માટે મદદ માટે

108
00:06:41,130 --> 00:06:44,160
આ કાર્ય આસપાસ કામળો બંધ ગણતરી?

109
00:06:44,160 --> 00:06:50,140
વેલ, પ્રથમ વ્યક્તિ
નંબર 1, ફેરફારની 3 અમને 1 આપે છે.

110
00:06:50,140 --> 00:06:54,690
2 મોડ 3 અમને 2 આપે છે,
અને 3 મોડ 3 અમને 0 આપે છે.

111
00:06:54,690 --> 00:07:02,140
>> ચોથી વ્યક્તિ, નંબર 4, ફેરફારની 3
અમને 1 આપે છે, અને પછી 5 ફેરફારની 3 અમને 2 આપે છે.

112
00:07:02,140 --> 00:07:05,370
તેથી, જો તમે નોંધ્યું છે કે કરશે તેમ છતાં
મારી પાસે જે લોકોની સંખ્યા

113
00:07:05,370 --> 00:07:11,210
વધે છે, અને ઉપર છે
3, કારણ કે હું 3 modding છું

114
00:07:11,210 --> 00:07:15,250
હું હંમેશા નંબરો 0, 1, અને 2 મળે છે.

115
00:07:15,250 --> 00:07:19,040
હું 3 કરતાં મોટી વિચાર ક્યારેય.

116
00:07:19,040 --> 00:07:22,630
તેથી, જો હું 10 હતી
લોકો, પછી તે બધા લોકોને

117
00:07:22,630 --> 00:07:27,430
હજુ જૂથો 1, 2, અથવા 0 અંદર હશે.

118
00:07:27,430 --> 00:07:33,560
>> તેથી, હવે આપણે જાણીએ છીએ કે જો આપણે એક જૂથ છે
5 અને અમે 3 દ્વારા તે બધા ફેરફારની,

119
00:07:33,560 --> 00:07:38,180
પછી અમે ક્યારેય જઈ રહ્યાં છો
જૂથો 0, 1, અથવા 2 વધી.

120
00:07:38,180 --> 00:07:43,430
તેથી, અમે ક્યારેય એક જૂથ વિચાર જઈ રહ્યાં છો
નંબર છે કે જે 3 અથવા ઉપર બરાબર છે.

121
00:07:43,430 --> 00:07:46,980
તેથી, હું પાંચ વધુ ઉમેરો તો પણ
લોકો, પછી તેમને બધા

122
00:07:46,980 --> 00:07:53,150
હજુ જૂથો સોંપેલ આવશે
0, 1, અથવા 2 કારણ કે હું 3 modding છું.

123
00:07:53,150 --> 00:07:56,510
હું ક્યારેય કેપ વધી જાઉં છું.

124
00:07:56,510 --> 00:08:00,800
>> ઠીક છે, તેથી ચાલો જોઈએ કે આપણે કરીએ
મોડ્યૂલો મદદથી આ વિચાર

125
00:08:00,800 --> 00:08:03,710
આસપાસ લપેટી
જૂથ નંબરો અને લાગુ

126
00:08:03,710 --> 00:08:08,000
તે Vigenère અમે કરવા માંગો છો જ્યાં
મોડ્યૂલો વાપરવા માટે આસપાસ લપેટી

127
00:08:08,000 --> 00:08:10,220
કિવર્ડ માટે ઇન્ડેક્સ.

128
00:08:10,220 --> 00:08:12,830
પણ અમે incrementing કરી રહ્યાં છો છતાં
ઇન્ડેક્સ અમે હંમેશા

129
00:08:12,830 --> 00:08:17,260
ખાતરી કરો કે અમે હંમેશા બનાવવા માંગો છો
ખૂબ જ શરૂઆત આસપાસ લપેટી

130
00:08:17,260 --> 00:08:20,050
ક્યારેય ઓળંગી
શબ્દમાળા લંબાઈ.

131
00:08:20,050 --> 00:08:23,510
>> ઠીક છે, તેથી હું તે હોઈ શકે છે ખબર
થોડી જબરજસ્ત.

132
00:08:23,510 --> 00:08:26,670
ત્યાં ઘણા બધા આ પી સેટ વધુ કરવા માટે છે.

133
00:08:26,670 --> 00:08:30,050
તેથી, ખાતરી કરો કે તમે લખી બનાવવા
તમારા માટે એક સારા સ્યુડોકોડનો

134
00:08:30,050 --> 00:08:32,870
કે તમે સમજો છો અને
તે કામ કર્યું નહીં.

135
00:08:32,870 --> 00:08:35,580
પ્રયત્ન કરો અને દરેક સંબોધવા
એક વાક્ય સ્વતંત્ર

136
00:08:35,580 --> 00:08:38,370
બહાર figuring બધા લિટલ
પઝલ નાના ટુકડાઓ

137
00:08:38,370 --> 00:08:40,260
તે એક સાથે મૂકે તે પહેલાં.

138
00:08:40,260 --> 00:08:43,110
>> ખાતરી કરો કે તમે વિચાર કરી
આદેશ વાક્ય માંથી કી

139
00:08:43,110 --> 00:08:46,780
અને ખાતરી કરો કે તે આલ્ફાબેટીક છે,
વપરાશકર્તા સાદા લખાણ,

140
00:08:46,780 --> 00:08:51,010
અને પછી enciphering, તમે ખાતરી કરો કે
ખબર કેવી રીતે એક અક્ષર ચિહ્નિત કરો,

141
00:08:51,010 --> 00:08:56,130
અને પછી સમગ્ર શબ્દમાળા માટે પ્રગતિ
કાર્યો આસપાસ કામળો બધા સાથે.

142
00:08:56,130 --> 00:08:59,610
છેલ્લે, જો તમે સાઇફર ટેક્સટ છાપી શકો છો.

143
00:08:59,610 --> 00:09:04,050
>> મારું નામ, એક Zamyla છે
અને આ Vigenere હતી.

144
00:09:04,050 --> 00:09:07,757