1
00:00:00,000 --> 00:00:11,960

2
00:00:11,960 --> 00:00:13,750
>> રોબ બોડેન: હાય, હું રોબ છું.

3
00:00:13,750 --> 00:00:17,360
અને રોમમાં, કાર્યક્રમ દો ત્યારે
રોમનો જેમ.

4
00:00:17,360 --> 00:00:22,280
તેથી, અમે જરૂર પ્રથમ વસ્તુ ચેક છે
ખાતરી કરો કે વપરાશકર્તા ખરેખર દાખલ કરેલ બનાવવા માટે

5
00:00:22,280 --> 00:00:26,670
અમે દરેક ફેરવવા માંગો છો કે સંખ્યા
આદેશ વાક્ય પર દ્વારા પાત્ર.

6
00:00:26,670 --> 00:00:27,740
>> તેથી, અમે તપાસ કરો.

7
00:00:27,740 --> 00:00:30,180
2 argc સમાન છે?

8
00:00:30,180 --> 00:00:34,190
જો તે નથી, કે જે ક્યાં તો વપરાશકર્તા અર્થ એ થાય
પાંચ ખાતે સંખ્યા દાખલ કર્યું નથી

9
00:00:34,190 --> 00:00:37,770
આદેશ વાક્ય અથવા તેઓ ઘણા દાખલ કર્યો
આદેશ વાક્ય પર વસ્તુઓ, જેમાં

10
00:00:37,770 --> 00:00:40,560
કેસ અમે શું કરવું તે ખબર નથી
વસ્તુઓ બાકીના સાથે.

11
00:00:40,560 --> 00:00:45,750
તેથી, જ્યાં સુધી argc બે હતી, અમે કરી શકો છો
કાર્યક્રમ બાકીના સાથે ચાલુ રાખો.

12
00:00:45,750 --> 00:00:49,610
>> હવે, કે argv યાદ
1 હંમેશા શબ્દમાળા છે.

13
00:00:49,610 --> 00:00:52,490
પરંતુ અમે પૂર્ણાંક તરીકે સારવાર કરવા માંગો છો.

14
00:00:52,490 --> 00:00:57,550
તેથી, અમે છે કે atoi વિધેય વાપરી
કન્વર્ટ જણાવ્યું પૃષ્ઠ સેટ સ્પેક પાંચ

15
00:00:57,550 --> 00:01:02,330
પૂર્ણાંક માટે શબ્દમાળા argv 1,
અને અમે કી માં કે સ્ટોર કરે છે.

16
00:01:02,330 --> 00:01:06,050
અમે ખાતરી બનાવવા માંગો છો પૂર્ણાંક
કે દાખલ થયો હતો નકારાત્મક નથી.

17
00:01:06,050 --> 00:01:09,490
તે તો, આપણે માટે કે પ્રિન્ટ માંગો છો
તેઓ અનુમતિ નથી વપરાશકર્તા કે જેણે

18
00:01:09,490 --> 00:01:11,980
કે કરવા માટે, અને પાછા.

19
00:01:11,980 --> 00:01:15,100
>> તેથી, હવે અમે કોઈ માન્ય છે
વપરાશકર્તામાંથી નંબર.

20
00:01:15,100 --> 00:01:19,780
પરંતુ અમે માંથી શબ્દમાળા મેળવવા જરૂર
અમે એનક્રિપ્ટ કરવા માંગો છો તે વપરાશકર્તા.

21
00:01:19,780 --> 00:01:25,340
તેથી અમે લૂપ જ્યારે કરે છે અને વિચાર ઉપયોગ કરવા માટે વપરાય
આ આ શબ્દમાળા મેળવવા શબ્દમાળા

22
00:01:25,340 --> 00:01:29,190
વપરાશકર્તા, અને શબ્દમાળા મેળવવામાં ચાલુ
તેઓ ખરેખર ત્યાં સુધી

23
00:01:29,190 --> 00:01:31,270
માન્ય શબ્દમાળા દાખલ કરો.

24
00:01:31,270 --> 00:01:34,400
>> અમે તે શબ્દમાળા છે, એટલે હંમેશાં
તેને એનક્રિપ્ટ કરવા માટે પર જઈ શકે છે.

25
00:01:34,400 --> 00:01:38,120
તેથી, આ માટે લૂપ કરી છે
કે એનક્રિપ્શન.

26
00:01:38,120 --> 00:01:43,250
અમે હું થી વારો કરી રહ્યાં છો નોંધ કરો કે
0 ટી બધી રીતે હું સમકક્ષ સુધી જેટલી જ થાય છે

27
00:01:43,250 --> 00:01:47,790
n ના લંબાઈ તરીકે વ્યાખ્યાયિત થયેલ છે n એ,
સંદેશ છે કે જ્યાં અમારા સંદેશ,

28
00:01:47,790 --> 00:01:50,260
વપરાશકર્તા દ્વારા દાખલ કરાયેલી શબ્દમાળા.

29
00:01:50,260 --> 00:01:54,330
>> તેથી આપણે બધા પર વારો કરી રહ્યાં છો
શબ્દમાળા માં અક્ષરો.

30
00:01:54,330 --> 00:01:59,740
અને એક અક્ષર મોટા છે, તો પછી
અમે આ મદદથી પાળી રહ્યા છીએ

31
00:01:59,740 --> 00:02:01,860
ફોર્મ્યુલા, જે અમે પડશે
બીજા પર મેળવો.

32
00:02:01,860 --> 00:02:05,260
અને તે લોઅરકેસ હતી, તો પછી
અમે આ છે નો ઉપયોગ કરીને તેને પાળી પડશે

33
00:02:05,260 --> 00:02:07,290
ખૂબ સમાન સૂત્ર.

34
00:02:07,290 --> 00:02:10,850
અને તે એક મોટા કે ન તો તો
એક લોઅરકેસ પત્ર - ઉદાહરણ તરીકે, તે

35
00:02:10,850 --> 00:02:15,370
એક નંબર અથવા પ્રતીક હોઈ શકે છે - તો પછી આપણે
તે કંઈ પણ કરવા માટે જતા હોય છે.

36
00:02:15,370 --> 00:02:18,220
>> તેથી, આ સૂત્રો શું છે?

37
00:02:18,220 --> 00:02:22,090
વેલ, અમે કેવી રીતે અક્ષર એક પાળી છે?

38
00:02:22,090 --> 00:02:27,250
અમે પાત્ર સારવાર કરવા માંગો છો
એક નંબર 0 રિલીઝ.

39
00:02:27,250 --> 00:02:30,710
અને અમે પાત્ર સારવાર કરવા માંગો છો
તેથી પર નંબર 1, અને બી.

40
00:02:30,710 --> 00:02:35,170
તે આ zeroth અને પ્રથમ અક્ષરો છે
મૂળાક્ષર અને તેથી.

41
00:02:35,170 --> 00:02:42,900
>> અહીં, સંદેશ હું ઓછા એક માનવામાં આવે છે
ચાલો ઓફ આંકડાકીય સ્થાન આપવા

42
00:02:42,900 --> 00:02:44,400
મૂળાક્ષરમાં પત્ર.

43
00:02:44,400 --> 00:02:48,080
તેથી સંદેશ તો શું હું, આ છે
અમને 0 આપી રહ્યું છે.

44
00:02:48,080 --> 00:02:52,880
હવે, અમે કે ઍડ કરવા માંગો છો
વપરાશકર્તા કરવા માંગે છે કે જે નંબર

45
00:02:52,880 --> 00:02:54,840
આ અક્ષર ફેરવવા.

46
00:02:54,840 --> 00:03:03,280
તેથી, તેઓ 3 પ્રવેશ કર્યો હોય, તો પછી જો સંદેશ
હું હતી, આ અમને 0 આપે છે અને વત્તા કરશે

47
00:03:03,280 --> 00:03:05,400
કી બનાવવામાં 3 આપશે.

48
00:03:05,400 --> 00:03:09,450
>> તેથી હવે, અમે વિચારી રહ્યાં છે
મૂળાક્ષર ત્રીજા સ્થાને.

49
00:03:09,450 --> 00:03:12,810
અમે mod જરૂર શા માટે અમે જોશો
બીજા NUM અક્ષરો દ્વારા.

50
00:03:12,810 --> 00:03:18,700
પરંતુ છેલ્લે, અમે પર ઉમેરવા માંગો
આ પાછું અમને પાળી ફરી એક અંત

51
00:03:18,700 --> 00:03:22,020
આ અક્ષરો માટે ASCII કિંમતો
બદલે માં આંકડાકીય સ્થળો

52
00:03:22,020 --> 00:03:24,260
આ અક્ષરો મૂળાક્ષર.

53
00:03:24,260 --> 00:03:26,580
>> તેથી, શા માટે આપણે NUM અક્ષરો દ્વારા mod છે?

54
00:03:26,580 --> 00:03:29,960
અમે આસપાસ લપેટી માંગો છો યાદ રાખો કે
આ કરવા માટે મૂળાક્ષરના અંતમાં થી

55
00:03:29,960 --> 00:03:31,470
મૂળાક્ષર શરૂ.

56
00:03:31,470 --> 00:03:38,530
તેથી વપરાશકર્તા પ્રવેશ કર્યો તો ઝેડ, તો પછી
કે બાદબાકી એક રહ્યું છે

57
00:03:38,530 --> 00:03:40,520
અમને 25 આપે છે.

58
00:03:40,520 --> 00:03:44,800
અને પછી કી, 3 તો
અમે 28 હોય રહ્યા છીએ.

59
00:03:44,800 --> 00:03:53,000
પરંતુ ઝેડ તેથી, એબીસી આસપાસ લપેટી જોઈએ 28
હેશ વ્યાખ્યાયિત કરવામાં આવે છે, જે મોડ NUM અક્ષરો,

60
00:03:53,000 --> 00:04:01,890
26 રાખી શકાય છે, કારણ કે આપી રહ્યું છે
સી ના બીજા અક્ષર છે જ્યાં અમને 2,

61
00:04:01,890 --> 00:04:05,880
મૂળાક્ષરો, તમે એક યાદ રાખો કે જો
મૂળાક્ષર ના zeroth અક્ષર.

62
00:04:05,880 --> 00:04:09,210
>> અમે જરૂર શા તેથી કે
NUM અક્ષરો દ્વારા મોડ.

63
00:04:09,210 --> 00:04:13,540
હવે, અમે જ ચોક્કસ વસ્તુ કરવા માટે જરૂરી
નાના અક્ષરો, સિવાય માટે

64
00:04:13,540 --> 00:04:17,240
યાદ છે કે અમે સાથે કામ કરીએ છીએ ત્યારે
નાના અક્ષરો, તેઓ અલગ અલગ છે

65
00:04:17,240 --> 00:04:18,579
તે ASCII કિંમતો.

66
00:04:18,579 --> 00:04:24,550
અને તેથી અમે બાદબાકી અને એક પર ઉમેરવાની જરૂર છે
લોઅરકેસ થી નીચે પાળી

67
00:04:24,550 --> 00:04:30,020
પછી તે ASCII મૂલ્યો અને પાછા માટે
મૂળ લોઅરકેસ ASCII કિંમતો.

68
00:04:30,020 --> 00:04:33,140
>> અને છેલ્લે, તે અમને આપી શકશો
અમારા એનક્રિપ્ટ થયેલ સંદેશો.

69
00:04:33,140 --> 00:04:37,780
અને અંતે, અમે માત્ર છાપો
તે સંદેશ, અને તે છે.

70
00:04:37,780 --> 00:04:39,875
મારું નામ રોબ છે, અને સીઝર હતો.

71
00:04:39,875 --> 00:04:49,856