1
00:00:00,000 --> 00:00:00,720

2
00:00:00,720 --> 00:00:03,190
>> ડેવિડ જે MALAN: હું માંગો છો ધારો કે
પૂછે છે કે એક કાર્યક્રમ અમલમાં

3
00:00:03,190 --> 00:00:06,650
પછી શબ્દમાળા માટે વપરાશકર્તા અને આગળ
તેમના ઇનપુટ ઉઠાવે,

4
00:00:06,650 --> 00:00:09,790
કોઈ પણ નાના અક્ષરો રૂપાંતર
તેઓ મોટા કરવા માટે, લખો કે.

5
00:00:09,790 --> 00:00:11,770
ઠીક છે, આપણે આગળ જાઓ અને
કે કાર્યક્રમ અમલમાં.

6
00:00:11,770 --> 00:00:18,760
>> પ્રથમ cs50.h અનુસરવામાં સમાવેશ કરો
દ્વારા stdio.h સમાવેશ થાય છે.

7
00:00:18,760 --> 00:00:23,990
અને તેથી અમે, strlen ઉપયોગ કરી શકો છો
માતાનો string.h સમાવેશ થાય છે.

8
00:00:23,990 --> 00:00:29,860
>> આગામી મુખ્ય તરીકે પૂર્ણાંક મુખ્ય રદબાતલ જાહેર કરો
અને હવે પૂછવા આગળ વધવા દો

9
00:00:29,860 --> 00:00:31,600
શબ્દમાળા માટે વપરાશકર્તા.

10
00:00:31,600 --> 00:00:34,840
Printf, ચાલો તેમને પૂછવા દો
કેટલાક ઇનપુટ માટે.

11
00:00:34,840 --> 00:00:36,460
હવે આપણે શબ્દમાળા જાહેર દો -

12
00:00:36,460 --> 00:00:37,630
અમે તેને ઓ કહી શકશો -

13
00:00:37,630 --> 00:00:44,010
અને તે ફોન પરિણામ સંગ્રહ
CS50 પુસ્તકાલય કાર્ય GetString.

14
00:00:44,010 --> 00:00:48,850
>> હવે દરેક ઉપર ફરી વળવું આગળ વધવા દો
એસ, અક્ષરો માં અક્ષરો

15
00:00:48,850 --> 00:00:50,650
અમે જુઓ કે કોઈ પણ નાના અક્ષરો.

16
00:00:50,650 --> 00:00:53,630
પૂર્ણાંક માટે, હું 0 વિષે.

17
00:00:53,630 --> 00:00:58,780
પણ સમાન હોવાથી n એ જાહેર કરીએ
ઓ શબ્દમાળા લંબાઈ અમે કરી શકો છો કે જેથી

18
00:00:58,780 --> 00:01:03,590
n એ ત્યાં સુધી હું ઉપર ફરી વળવું, આ
એ લંબાઈ, અને દરેક પર

19
00:01:03,590 --> 00:01:05,760
પુનરાવૃત્તિ વધારતી હું.

20
00:01:05,760 --> 00:01:09,970
>> અને પછી આ લૂપની અંદર, ચાલો
પ્રથમ ચેક વર્તમાન પત્ર છે -

21
00:01:09,970 --> 00:01:12,270
ઓ-i મી અક્ષર છે, તેથી વાત કરવા માટે -

22
00:01:12,270 --> 00:01:14,170
એક નાના અક્ષર.

23
00:01:14,170 --> 00:01:23,090
એ કૌંસ હું કરતાં વધારે અથવા સમાન હોય
એક લોઅરકેસ, અને તે ઓછી છે માટે

24
00:01:23,090 --> 00:01:26,900
કરતાં અથવા લોઅરકેસ z માટે સમાન -

25
00:01:26,900 --> 00:01:30,860
હવે અમે એક લોઅરકેસ કન્વર્ટ કરવા માંગતા હોય તો
મોટા અક્ષર, કે જે પ્રથમ યાદ

26
00:01:30,860 --> 00:01:35,810
તે ASCII એક લોઅરકેસ 97 છે
અને મોટા એક 65 છે.

27
00:01:35,810 --> 00:01:41,020
દરમિયાન, એક નાના બી, 98 છે
અને મોટા બી 66 છે.

28
00:01:41,020 --> 00:01:44,180
>> અમે તે પેટર્ન જોવા માટે ચાલુ છે,
અમે જોશો કે લોઅરકેસ

29
00:01:44,180 --> 00:01:49,240
અક્ષરો ઊંચા હંમેશા 32 કિંમતો છે
પાંચ મોટા અક્ષરો કરતાં.

30
00:01:49,240 --> 00:01:53,490
તેથી અમે લોઅરકેસ કન્વર્ટ કરવા માંગતા હોય તો
મોટા કરવા માટે, તે જોઈએ

31
00:01:53,490 --> 00:01:57,210
બાદબાકી માટે, ખરેખર, પૂરતો
વપરાશકર્તાની ઇનપુટ થી 32.

32
00:01:57,210 --> 00:02:01,330
અથવા વધુ સામાન્ય રીતે, ફક્ત બાદબાકી કે
એક લોઅરકેસ અને વચ્ચે તફાવત

33
00:02:01,330 --> 00:02:02,310
મૂડી એ

34
00:02:02,310 --> 00:02:03,410
>> કે વ્યક્ત કેવી રીતે?

35
00:02:03,410 --> 00:02:04,640
વેલ, જે કોડમાં તે કરવા દો.

36
00:02:04,640 --> 00:02:09,960
પ્રિન્ટ માટે printf, ભાવ, અવતરણ ચિહ્નો પૂરાં કરવાં "% C"
ત્યાર બાદ વર્તમાન પાત્ર,

37
00:02:09,960 --> 00:02:18,500
એ કૌંસ હું ઓછા માં ગમે પ્રિન્ટીંગ
લોઅરકેસ કરી પરિણામ

38
00:02:18,500 --> 00:02:22,660
બાદ અર્ધવિરામ મોટા.

39
00:02:22,660 --> 00:02:27,010
અન્ય શબ્દોમાં, આ parenthetical
અભિવ્યક્તિ, ઓછી એક બાદ મોટી એક, છે

40
00:02:27,010 --> 00:02:29,360
પર અમને પરત ચાલી
દિવસ 32 ઓવરને.

41
00:02:29,360 --> 00:02:31,230
પરંતુ હું યાદ નથી
તે 32 કે.

42
00:02:31,230 --> 00:02:34,150
હું કોમ્પ્યુટર આકૃતિ પરવાનગી આપી શકે છે
શું લોઅરકેસ વચ્ચે તફાવત

43
00:02:34,150 --> 00:02:35,990
એ અને મૂડી છે.

44
00:02:35,990 --> 00:02:39,610
>> દરમિયાન, એક વખત હું કે તફાવત ખબર
હું એ તેને બાદબાકી કરી શકો છો

45
00:02:39,610 --> 00:02:43,710
શું લેશે કૌંસ હું જે
એ કદાચ એક નાના અક્ષર

46
00:02:43,710 --> 00:02:48,100
ઓછી કિંમત, નકશા કે નામ અનુસાર નીચેની
એક મોટા સમકક્ષ પર.

47
00:02:48,100 --> 00:02:51,240
સંકલન, ચાલો હવે સંગ્રહ કરીએ,
અને આ કાર્યક્રમ ચલાવો.

48
00:02:51,240 --> 00:02:57,760
કોઈ સ્લેશ ઉઠાવે કેપીટલ કરો.

49
00:02:57,760 --> 00:03:01,290
અને મારા ઇનપુટ હેલો હશે.

50
00:03:01,290 --> 00:03:02,920
અને આ રહ્યું હેલો, છે.

51
00:03:02,920 --> 00:03:05,570
>> હવે મારા પ્રોમ્પ્ટ પર, એ સાચું છે કે છે
અમે કર્યું થોડી નીચ, કારણ કે

52
00:03:05,570 --> 00:03:07,810
પ્રિન્ટીંગ એક બીટ અવગણવામાં.

53
00:03:07,810 --> 00:03:09,370
અને પાછા જાઓ અને તે ઉમેરો.

54
00:03:09,370 --> 00:03:12,890
આ કાર્યક્રમ ખૂબ જ તળિયે,
હું ખૂબ જ સરળ છે, અને મોટા ભાગે માટે છું

55
00:03:12,890 --> 00:03:18,440
કલાત્મક હેતુ છે printf ઉમેરવા જતાં,
ભાવ, અવતરણ ચિહ્નો પૂરાં કરવાં બેકસ્લેશ n એ.

56
00:03:18,440 --> 00:03:22,330
માતાનો આ ફાઈલની resave દો,
, પુનઃ ચલાવો પુનઃકમ્પાઈલ.

57
00:03:22,330 --> 00:03:28,090
>> ઉઠાવે છે, કોઈ સ્લેશ ઉઠાવે.

58
00:03:28,090 --> 00:03:32,540
ફરીથી, ઇનપુટ માટે હું "હેલો" પ્રદાન કરીશું
બધા નાના અક્ષરોમાં અને હવે, Enter દબાવો

59
00:03:32,540 --> 00:03:34,550
અને "હેલો," ઘણી વધુ સ્વચ્છ મુદ્રણ.

60
00:03:34,550 --> 00:03:36,432