પ્રોગ્રામિંગ ઈન સી (4331105) - સમર 2024 સોલ્યુશન

પ્રશ્ન 1(અ) [3 માર્કસ]

#

કીવર્ડની વ્યાખ્યા લખો. C લેંગ્વેજના કોઈપણ ૪ કીવર્ડ લખો.

જવાબ: કીવર્ડ એ C ભાષામાં પૂર્વનિર્ધારિત, અનામત શબ્દ છે જેનો કમ્પાઇલર દ્વારા વિશેષ અર્થ હોય છે અને તેનો ઓળખકર્તા તરીકે ઉપયોગ કરી શકાતો નથી.

કોષ્ટક: સામાન્ય C કીવર્ડ્સ

• અનામત શબ્દો: કીવર્ડનો વેરિએબલ નામ તરીકે ઉપયોગ કરી શકાતો નથી
• પૂર્વનિર્ધારિત: તેમનો ભાષામાં નિશ્ચિત અર્થ છે
• કેસ-સેન્સિટિવ: બધા કીવર્ડ્સ લોઅરકેસમાં હોવા જોઈએ

મ્નેમોનિક: “If VoId FoR WhIle” (મહત્વપૂર્ણ કીવર્ડના પ્રથમ અક્ષરો)

પ્રશ્ન 1(બ) [4 માર્કસ]

#

વેરીએબલના નામ માટેના નિયમો સમજાવો.

જવાબ: C માં વેરીએબલ્સ માન્ય ઓળખકર્તા હોવા માટે ચોક્કસ નિયમોનું પાલન કરવું આવશ્યક છે.

કોષ્ટક: C માં વેરીએબલ નામકરણ નિયમો

• વર્ણનાત્મક નામો: હેતુ દર્શાવતા અર્થપૂર્ણ નામોનો ઉપયોગ કરો
• સુસંગત શૈલી: સુસંગત નામકરણ પદ્ધતિનું પાલન કરો
• સ્પેસ નહીં: સ્પેસને બદલે અંડરસ્કોર અથવા camelCase નો ઉપયોગ કરો

મ્નેમોનિક: “FLASKS” (First Letter, Letters/digits, Avoid keywords, Sensitive case, Keep meaningful, Skip special chars)

પ્રશ્ન 1(ક) [7 માર્કસ]

#

ફ્લોચાર્ટની વ્યાખ્યા લખો. ત્રણ પૂર્ણાંક નંબર N1, N2 અને N3 માંથી નાનો નંબર શોધવા માટેનો ફ્લોચાર્ટ દોરો.

જવાબ: ફ્લોચાર્ટ એ એલ્ગોરિધમનું ગ્રાફિકલ નિરૂપણ છે જે પગલાંઓને બોક્સ તરીકે દર્શાવે છે અને તેમના ક્રમને તીરથી જોડીને દર્શાવે છે.

ડાયાગ્રામ:

flowchart TD
    A([Start]) --> B[/Input N1, N2, N3/]
    B --> C{Is N1 < N2?}
    C -->|Yes| D[min = N1]
    C -->|No| E[min = N2]
    D --> F{Is min < N3?}
    E --> F
    F -->|Yes| G[min remains same]
    F -->|No| H[min = N3]
    G --> I[/Output min/]
    H --> I
    I --> J([End])

• ઉપયોગ કરેલા સિમ્બોલ: ઓવલ (શરુઆત/અંત), સમાંતર ચતુષ્કોણ (ઇનપુટ/આઉટપુટ), હીરા (નિર્ણય), આયત (પ્રક્રિયા)
• નિર્ણય બિંદુઓ: મૂલ્યોની વ્યવસ્થિત સરખામણી
• તર્કસંગત પ્રવાહ: તીર કાર્યોનો ક્રમ દર્શાવે છે

મ્નેમોનિક: “Start-Input-Compare-Output-End” (SICOE)

પ્રશ્ન 1(ક) OR [7 માર્કસ]

#

અલગોરિધમની વ્યાખ્યા લખો. ત્રણ પૂર્ણાંક નંબર N1, N2 અને N3 માંથી નાનો નંબર શોધવા માટેનો અલગોરિધમ લખો.

જવાબ: અલગોરિધમ એ પગલાવાર પ્રક્રિયા અથવા ચોક્કસ સમસ્યાને ઉકેલવા માટેની સુવ્યાખ્યાયિત સૂચનાઓનો પરિમિત સમૂહ છે.

ત્રણ સંખ્યાઓમાંથી ન્યૂનતમ શોધવા માટેનો અલગોરિધમ:

પગલું 1: શરૂ કરો
પગલું 2: ત્રણ સંખ્યાઓ N1, N2, અને N3 ઇનપુટ કરો
પગલું 3: min = N1 સેટ કરો (પ્રથમ સંખ્યા લઘુત્તમ માની લો)
પગલું 4: જો N2 < min, તો min = N2 સેટ કરો
પગલું 5: જો N3 < min, તો min = N3 સેટ કરો
પગલું 6: min ને લઘુત્તમ સંખ્યા તરીકે આઉટપુટ કરો
પગલું 7: અંત

કોષ્ટક: અલગોરિધમ લક્ષણો

• અનુક્રમિક પગલાં: તાર્કિક ક્રમનું પાલન કરે છે
• તુલનાત્મક અભિગમ: વ્યવસ્થિત રીતે લઘુત્તમ શોધે છે
• સરળતા: સમજવા અને અમલમાં મૂકવામાં સરળ

મ્નેમોનિક: “FIDEO” (Finiteness, Input, Definiteness, Effectiveness, Output)

પ્રશ્ન 2(અ) [3 માર્કસ]

#

gets() અને puts() વચ્ચેનો તફાવત સમજાવો.

જવાબ: gets() અને puts() એ C માં સ્ટ્રિંગ્સ સાથે ઇનપુટ અને આઉટપુટ ઓપરેશન્સ માટેના સ્ટાન્ડર્ડ લાઇબ્રેરી ફંક્શન્સ છે.

કોષ્ટક: gets() અને puts() ની તુલના

• ઇનપુટ/આઉટપુટ: gets() ઇનપુટ માટે, puts() આઉટપુટ માટે
• ટર્મિનેશન: gets() ન્યુલાઇન પર અટકે છે, puts() ન્યુલાઇન ઉમેરે છે
• સિક્યોરિટી: gets() બફર લિમિટ ચેક કરતું નથી

મ્નેમોનિક: “Gets In, Puts Out” (gets વાંચે છે, puts લખે છે)

પ્રશ્ન 2(બ) [4 માર્કસ]

#

કન્ડીશનલ ઓપરેટરનો ઉપયોગ કરીને લીધેલ નંબર એકી છે કે બેકી તે શોધવા માટે C પ્રોગ્રામ બનાવો.

જવાબ: આ પ્રોગ્રામ કન્ડિશનલ ઓપરેટરનો ઉપયોગ કરીને નંબર એકી કે બેકી છે તે તપાસે છે.

#include <stdio.h>

int main() {
    int num;
    
    printf("Enter a number: ");
    scanf("%d", &num);
    
    // કન્ડિશનલ ઓપરેટરનો ઉપયોગ કરીને એકી-બેકી તપાસો
    (num % 2 == 0) ? printf("%d is even\n", num) : printf("%d is odd\n", num);
    
    return 0;
}

ડાયાગ્રામ:

flowchart TD
    A([Start]) --> B[/Input num/]
    B --> C{"num % 2 == 0?"}
    C -->|True| D[/Output "num is even"/]
    C -->|False| E[/Output "num is odd"/]
    D --> F([End])
    E --> F

• કન્ડિશનલ ઓપરેટર: ? : એ ટ્રિનેરી ઓપરેટર છે
• મોડ્યુલસ ઓપરેશન: % ભાગાકાર પછી બાકી આપે છે
• ટેસ્ટ કન્ડિશન: num % 2 == 0 બેકી સંખ્યા માટે તપાસે છે

મ્નેમોનિક: “REMinder 0 = Even” (બાકી 0 એટલે બેકી)

પ્રશ્ન 2(ક) [7 માર્કસ]

#

લોજીકલ અને રીલેશનલ ઓપરેટરો ઉદાહરણ સાથે સમજાવો.

જવાબ: લોજીકલ અને રીલેશનલ ઓપરેટરો C પ્રોગ્રામમાં શરતો બનાવવા અને નિર્ણયો લેવા માટે વપરાય છે.

કોષ્ટક: રીલેશનલ ઓપરેટરો

કોષ્ટક: લોજીકલ ઓપરેટરો

કોડ ઉદાહરણ:

int age = 20;
int score = 75;

// રીલેશનલ અને લોજીકલ ઓપરેટરોનો ઉપયોગ
if ((age >= 18) && (score > 70)) {
    printf("Eligible");
}

• તુલના: રીલેશનલ ઓપરેટરો મૂલ્યોની તુલના કરે છે
• શરતોનું જોડાણ: લોજીકલ ઓપરેટરો અનેક શરતોને જોડે છે
• સત્ય મૂલ્ય: બધા ઓપરેટરો 1 (સાચું) અથવા 0 (ખોટું) પાછા આપે છે

મ્નેમોનિક: “CORNL” (Compare with relational, OR/AND/NOT with logical)

પ્રશ્ન 2(અ) OR [3 માર્કસ]

#

જો 16 + ( 216 / ( ( 3 + 6 ) * 12 ) ) -10 સમીકરણને ઉકેલવામાં આવે તો ઓપરેટરોની અગ્રીમતાને ધ્યાને લઇ દરેક સ્ટેપ અને અંતિમ જવાબ લખો.

જવાબ: ચાલો 16 + ( 216 / ( ( 3 + 6 ) * 12 ) ) - 10 એક્સપ્રેશનને ઓપરેટર પ્રિસિડન્સને અનુસરીને પગલેવાર મૂલ્યાંકન કરીએ.

કોષ્ટક: પગલેવાર મૂલ્યાંકન

અંતિમ જવાબ: 8

ડાયાગ્રામ:

flowchart TD
    A[16 + ( 216 / ( ( 3 + 6 ) * 12 ) ) - 10] --> B[16 + ( 216 / ( 9 * 12 ) ) - 10]
    B --> C[16 + ( 216 / 108 ) - 10]
    C --> D[16 + 2 - 10]
    D --> E[18 - 10]
    E --> F[8]

• પ્રથમ કૌંસમાં: સૌથી અંદરના કૌંસનું મૂલ્યાંકન પહેલા કરાય છે
• ગુણાકાર પછી ભાગાકાર: ડાબેથી જમણે ગણતરી કરો
• સરવાળો અને બાદબાકી છેલ્લે: ડાબેથી જમણે ક્રમમાં

મ્નેમોનિક: “PEMDAS” (Parentheses, Exponents, Multiplication/Division, Addition/Subtraction)

પ્રશ્ન 2(બ) OR [4 માર્કસ]

#

વર્તુળનું ક્ષેત્રફળ અને પરિઘ શોધવા માટેનો C પ્રોગ્રામ લખો.

જવાબ: આ પ્રોગ્રામ વર્તુળની ત્રિજ્યાના આધારે વર્તુળનું ક્ષેત્રફળ અને પરિઘ ગણે છે.

#include <stdio.h>
#define PI 3.14159

int main() {
    float radius, area, circumference;
    
    printf("Enter the radius of circle: ");
    scanf("%f", &radius);
    
    // ક્ષેત્રફળ અને પરિઘની ગણતરી કરો
    area = PI * radius * radius;
    circumference = 2 * PI * radius;
    
    printf("Area of circle = %.2f square units\n", area);
    printf("Circumference of circle = %.2f units\n", circumference);
    
    return 0;
}

ડાયાગ્રામ:

flowchart TD
    A([Start]) --> B[/Input radius/]
    B --> C[area = PI * radius * radius]
    C --> D[circumference = 2 * PI * radius]
    D --> E[/Output area and circumference/]
    E --> F([End])

• ફોર્મ્યુલા: ક્ષેત્રફળ = π × r² અને પરિઘ = 2π × r
• કોન્સ્ટન્ટ ડેફિનિશન: PI માટે #define નો ઉપયોગ
• ફ્લોટ વેરિએબલ્સ: દશાંશ ચોકસાઈ માટે

મ્નેમોનિક: “PIR²” ક્ષેત્રફળ માટે, “2PIR” પરિઘ માટે

પ્રશ્ન 2(ક) OR [7 માર્કસ]

#

એરીથમેટીક અને બીટ-વાઈસ ઓપરેટરો ઉદાહરણ સાથે સમજાવો.

જવાબ: એરીથમેટીક ઓપરેટરો ગાણિતિક ઓપરેશન કરે છે જ્યારે બિટ-વાઈસ ઓપરેટરો ઇન્ટીજરના અલગ બિટ્સ સાથે કામ કરે છે.

કોષ્ટક: એરીથમેટીક ઓપરેટરો

કોષ્ટક: બિટવાઈઝ ઓપરેટરો

કોડ ઉદાહરણ:

int a = 5, b = 3;
printf("a + b = %d\n", a + b);      // 8
printf("a & b = %d\n", a & b);      // 1
printf("a << 1 = %d\n", a << 1);    // 10

• ગાણિતિક ઓપરેશન્સ: એરીથમેટીક ઓપરેટરો ગણતરી માટે
• બિટ મેનિપ્યુલેશન: બિટવાઈઝ ઓપરેટરો બાઇનરી લેવલ પર કામ કરે છે
• કાર્યક્ષમતા: બિટવાઈઝ ઓપરેશન્સ અમુક કાર્યો માટે વધુ ઝડપી છે

મ્નેમોનિક: “SAME BARON” (Subtraction Addition Multiplication, Bitwise AND/OR/NOT)

પ્રશ્ન 3(અ) [3 માર્કસ]

#

‘go to’ સ્ટેટમેન્ટનો ઉપયોગ ઉદાહરણ સાથે સમજાવો.

જવાબ: goto સ્ટેટમેન્ટનો ઉપયોગ પ્રોગ્રામ કંટ્રોલને બિનશરતી રીતે લેબલવાળા સ્ટેટમેન્ટ પર ટ્રાન્સફર કરવા માટે થાય છે.

#include <stdio.h>

int main() {
    int num, sum = 0;
    
    printf("Enter a positive number: ");
    scanf("%d", &num);
    
    if (num <= 0) {
        goto error;
    }
    
    sum = num * (num + 1) / 2;
    printf("Sum of first %d numbers = %d\n", num, sum);
    goto end;
    
    error:
        printf("Error: Please enter a positive number!\n");
    
    end:
        return 0;
}

ડાયાગ્રામ:

flowchart TD
    A([Start]) --> B[/Input num/]
    B --> C{num <= 0?}
    C -->|Yes| D[/Output error message/]
    C -->|No| E[Calculate sum]
    E --> F[/Output sum/]
    D --> G([End])
    F --> G

• લેબલ ડિક્લેરેશન: લેબલ્સ કોલન (:) સાથે સમાપ્ત થાય
• જમ્પ સ્ટેટમેન્ટ: goto કંટ્રોલને લેબલ પર ટ્રાન્સફર કરે છે
• સાવધાની: વધારે ઉપયોગ “સ્પેગેટી કોડ” બનાવે છે

મ્નેમોનિક: “JUMPing LABEL” (લેબલવાળા સ્ટેટમેન્ટ પર જમ્પ)

પ્રશ્ન 3(બ) [4 માર્કસ]

#

વિદ્યાર્થીએ ૫ અલગ અલગ વિષયોમાં મેળવેલ માર્ક્સને કીબોર્ડથી ઈનપુટમાં લો. વિધાથીને આ નિયમો પ્રમાણે ગ્રેડ મળે છે: ૯૦ કે તેથી વધુ ટકા માટે- ગ્રેડ A. ૮૦ થી ૮૯ સુધીના ટકા માટે- ગ્રેડ B. ૭૦ થી ૭૯ સુધીના ટકા માટે- ગ્રેડ C. ૬૦ થી ૬૯ સુધીના ટકા માટે- ગ્રેડ D. ૫૦ થી ૫૯ સુધીના ટકા માટે- ગ્રેડ E. ૫૦ થી ઓછા ટકા માટે- ગ્રેડ F. વિદ્યાર્થીએ મેળવેલ ગ્રેડને ડિસ્પ્લે કરવા માટેનો C પ્રોગ્રામ લખો.

જવાબ: આ પ્રોગ્રામ 5 વિષયોમાં મેળવેલ માર્ક્સના સરેરાશના આધારે ગ્રેડ ગણે છે.

#include <stdio.h>

int main() {
    int marks[5], total = 0, i;
    float percentage;
    char grade;
    
    // 5 વિષયો માટે માર્ક્સ ઇનપુટ
    for (i = 0; i < 5; i++) {
        printf("Enter marks for subject %d (out of 100): ", i+1);
        scanf("%d", &marks[i]);
        total += marks[i];
    }
    
    // ટકાવારી ગણો
    percentage = total / 5.0;
    
    // ગ્રેડ નક્કી કરો
    if (percentage >= 90)
        grade = 'A';
    else if (percentage >= 80)
        grade = 'B';
    else if (percentage >= 70)
        grade = 'C';
    else if (percentage >= 60)
        grade = 'D';
    else if (percentage >= 50)
        grade = 'E';
    else
        grade = 'F';
    
    printf("Percentage: %.2f%%\n", percentage);
    printf("Grade: %c\n", grade);
    
    return 0;
}

કોષ્ટક: ગ્રેડિંગ માપદંડ

• ઇનપુટ એરે: 5 વિષયોના માર્ક્સ સ્ટોર કરે છે
• ટકાવારી ગણતરી: સરવાળો વિષયોની સંખ્યા દ્વારા ભાગીને
• ગ્રેડ નિર્ધારણ: if-else લેડરનો ઉપયોગ કરીને

મ્નેમોનિક: “ABCDEF-90-80-70-60-50” (ગ્રેડ્સ તેમની ટકાવારી થ્રેશોલ્ડ સાથે)

પ્રશ્ન 3(ક) [7 માર્કસ]

#

Nested if-else નો ફ્લોચાર્ટ દોરી ઉદાહરણ સાથે સમજાવો.

જવાબ: નેસ્ટેડ if-else એ એક કંટ્રોલ સ્ટ્રક્ચર છે જ્યાં if અથવા else સ્ટેટમેન્ટમાં બીજું if-else સ્ટેટમેન્ટ સમાયેલ હોય છે.

ડાયાગ્રામ:

flowchart TD
    A([Start]) --> B[/Input age, score/]
    B --> C{age >= 18?}
    C -->|Yes| D{score >= 60?}
    C -->|No| E[/Output "Not eligible: Age criteria not met"/]
    D -->|Yes| F[/Output "Eligible for admission"/]
    D -->|No| G[/Output "Not eligible: Score criteria not met"/]
    E --> H([End])
    F --> H
    G --> H

કોડ ઉદાહરણ:

#include <stdio.h>

int main() {
    int age, score;
    
    printf("Enter age: ");
    scanf("%d", &age);
    printf("Enter score: ");
    scanf("%d", &score);
    
    if (age >= 18) {
        if (score >= 60) {
            printf("Eligible for admission");
        } else {
            printf("Not eligible: Score criteria not met");
        }
    } else {
        printf("Not eligible: Age criteria not met");
    }
    
    return 0;
}

• બહુવિધ શરતો: અનુક્રમે કેટલીક શરતોની તપાસ કરે છે
• શ્રેણીબદ્ધ નિર્ણય: અંદરની શરત માત્ર ત્યારે જ મૂલ્યાંકિત થાય છે જો બહારની શરત સાચી હોય
• ઇન્ડેન્ટેશન: યોગ્ય ઇન્ડેન્ટેશન સ્ટ્રક્ચર સમજવામાં મદદ કરે છે

મ્નેમોનિક: “CONE” (Check Outer, Nest Evaluation inside)

પ્રશ્ન 3(અ) OR [3 માર્કસ]

#

continue અને break સ્ટેટમેન્ટનો ઉપયોગ સમજાવો.

જવાબ: break અને continue સ્ટેટમેન્ટ્સ અલગ અલગ રીતે લૂપના પ્રવાહને નિયંત્રિત કરે છે.

કોષ્ટક: break અને continue ની તુલના

break સાથે ઉદાહરણ:

for (int i = 1; i <= 10; i++) {
    if (i == 5)
        break;    // i 5 થાય ત્યારે લૂપથી બહાર નીકળો
    printf("%d ", i);  // આઉટપુટ: 1 2 3 4
}

continue સાથે ઉદાહરણ:

for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0)
        continue;  // બેકી સંખ્યાઓ છોડો
    printf("%d ", i);  // આઉટપુટ: 1 3 5 7 9
}

• લૂપ કંટ્રોલ: બંને લૂપ એક્ઝિક્યુશન મેનેજ કરવા માટે વપરાય છે
• Break બહાર નીકળે છે: સંપૂર્ણપણે લૂપ અટકાવે છે
• Continue છોડે છે: માત્ર વર્તમાન પુનરાવર્તન છોડે છે

મ્નેમોનિક: “BEC” (Break Exits Completely, Continue only current)

પ્રશ્ન 3(બ) OR [4 માર્કસ]

#

નીચે આપેલી પેટર્ન પ્રિન્ટ કરવા માટેનો C પ્રોગ્રામ ફોર લૂપનો ઉપયોગ કરીને લખો.

1
1 2
1 2 3
1 2 3 4

જવાબ: આ પ્રોગ્રામ નેસ્ટેડ ફોર લૂપનો ઉપયોગ કરીને નંબર્સની પેટર્ન પ્રિન્ટ કરે છે.

#include <stdio.h>

int main() {
    int i, j;
    
    // બહારની લૂપ રો માટે (1 થી 4)
    for (i = 1; i <= 4; i++) {
        // અંદરની લૂપ કોલમ માટે (1 થી i)
        for (j = 1; j <= i; j++) {
            printf("%d ", j);
        }
        printf("\n");  // દરેક રો પછી નવી લાઈન
    }
    
    return 0;
}

ડાયાગ્રામ:

flowchart TD
    A([Start]) --> B[i = 1]
    B --> C{i <= 4?}
    C -->|Yes| D[j = 1]
    D --> E{j <= i?}
    E -->|Yes| F[/Print j/]
    F --> G[j++]
    G --> E
    E -->|No| H[/Print newline/]
    H --> I[i++]
    I --> C
    C -->|No| J([End])

• નેસ્ટેડ લૂપ્સ: બહારની લૂપ રો માટે, અંદરની કોલમ માટે
• ડાયનેમિક લિમિટ: અંદરની લૂપ j=1 થી વર્તમાન i સુધી ચાલે છે
• ઇન્ક્રિમેન્ટલ પેટર્ન: દરેક રોમાં એક વધુ નંબર હોય છે

મ્નેમોનિક: “RICI” (Row Increases, Column Increases based on row number)

પ્રશ્ન 3(ક) OR [7 માર્કસ]

#

સ્વીચ સ્ટેટમેન્ટ ફ્લોચાર્ટ દોરી ઉદાહરણ સાથે સમજાવો.

જવાબ: સ્વિચ સ્ટેટમેન્ટ એક મલ્ટિ-વે ડિસિઝન મેકર છે જે વેરિએબલને વિવિધ કેસ વેલ્યુઝ સાથે ટેસ્ટ કરે છે.

ડાયાગ્રામ:

flowchart TD
    A([Start]) --> B[/Input choice/]
    B --> C{Switch choice}
    C -->|case 1| D[/Output "Option 1 selected"/]
    C -->|case 2| E[/Output "Option 2 selected"/]
    C -->|case 3| F[/Output "Option 3 selected"/]
    C -->|default| G[/Output "Invalid option"/]
    D --> H([End])
    E --> H
    F --> H
    G --> H

કોડ ઉદાહરણ:

#include <stdio.h>

int main() {
    int choice;
    
    printf("Menu:\n");
    printf("1. Add\n");
    printf("2. Subtract\n");
    printf("3. Multiply\n");
    printf("Enter your choice (1-3): ");
    scanf("%d", &choice);
    
    switch (choice) {
        case 1:
            printf("Addition selected\n");
            break;
        case 2:
            printf("Subtraction selected\n");
            break;
        case 3:
            printf("Multiplication selected\n");
            break;
        default:
            printf("Invalid choice\n");
    }
    
    return 0;
}

• મલ્ટિપલ કેસિઝ: એક વેરિએબલને અનેક વેલ્યુઝ સાથે ટેસ્ટ કરે છે
• બ્રેક સ્ટેટમેન્ટ: આગલા કેસમાં પડતા અટકાવે છે
• ડિફોલ્ટ કેસ: કોઈપણ કેસ સાથે મેચ ન થતા વેલ્યુઝને સંભાળે છે
• કેસ ઓર્ડર: કોઈપણ ક્રમમાં હોઈ શકે, ડિફોલ્ટ સામાન્ય રીતે છેલ્લે હોય

મ્નેમોનિક: “CASED” (Check All Switch Expression’s Destinations)

પ્રશ્ન 4(અ) [3 માર્કસ]

#

fahrenheit= ((celsius*9)/5)+32 સમીકરણથી સેલ્સિયસમાં આપેલા તાપમાનને ફેરનહીટમાં રૂપાંતર કરવા માટેનો C પ્રોગ્રામ લખો.

જવાબ: આ પ્રોગ્રામ તાપમાન મૂલ્યને સેલ્સિયસથી ફેરનહાઇટમાં રૂપાંતરિત કરે છે.

#include <stdio.h>

int main() {
    float celsius, fahrenheit;
    
    printf("Enter temperature in Celsius: ");
    scanf("%f", &celsius);
    
    // સેલ્સિયસને ફેરનહાઇટમાં રૂપાંતરિત કરો
    fahrenheit = ((celsius * 9) / 5) + 32;
    
    printf("%.2f Celsius = %.2f Fahrenheit\n", celsius, fahrenheit);
    
    return 0;
}

ડાયાગ્રામ:

flowchart TD
    A([Start]) --> B[/Input celsius/]
    B --> C[fahrenheit = ((celsius * 9) / 5) + 32]
    C --> D[/Output celsius and fahrenheit/]
    D --> E([End])

• ફોર્મ્યુલા: F = ((C × 9) ÷ 5) + 32
• ફ્લોટ વેરિએબલ્સ: દશાંશ ચોકસાઈ માટે
• ફોર્મેટેડ આઉટપુટ: બે દશાંશ સ્થાન માટે %.2f નો ઉપયોગ

મ્નેમોનિક: “C95+32=F” (સેલ્સિયસ × 9 ÷ 5 + 32 = ફેરનહાઇટ)

પ્રશ્ન 4(બ) [4 માર્કસ]

#

પોઈન્ટર એટલે શું? ઉદાહરણ સાથે સમજાવો.

જવાબ: પોઈન્ટર એ એક વેરિએબલ છે જે અન્ય વેરિએબલના મેમરી એડ્રેસને સ્ટોર કરે છે.

ડાયાગ્રામ:

મેમરી:
+--------+      +--------+
| ptr    |----->| var    |
| 0x1000 |      | 0x2000 |
+--------+      +--------+
  એડ્રેસ          મૂલ્ય: 10
  0x2000
  ધરાવે છે

કોડ ઉદાહરણ:

#include <stdio.h>

int main() {
    int var = 10;    // સામાન્ય વેરિએબલ
    int *ptr;        // પોઈન્ટર વેરિએબલ
    
    ptr = &var;      // var નું એડ્રેસ ptr માં સ્ટોર કરો
    
    printf("Value of var: %d\n", var);       // આઉટપુટ: 10
    printf("Address of var: %p\n", &var);    // આઉટપુટ: મેમરી એડ્રેસ
    printf("Value of ptr: %p\n", ptr);       // આઉટપુટ: એજ મેમરી એડ્રેસ
    printf("Value at address stored in ptr: %d\n", *ptr); // આઉટપુટ: 10
    
    // પોઈન્ટરનો ઉપયોગ કરીને મૂલ્ય બદલો
    *ptr = 20;
    printf("New value of var: %d\n", var);   // આઉટપુટ: 20
    
    return 0;
}

કોષ્ટક: પોઈન્ટર ઓપરેશન્સ

• મેમરી એડ્રેસ: પોઈન્ટર મૂલ્ય નહીં પણ સ્થાન સ્ટોર કરે છે
• ઇન્ડાયરેક્શન: એડ્રેસનો ઉપયોગ કરીને પરોક્ષ રીતે મૂલ્ય એક્સેસ કરે
• મેમરી મેનિપ્યુલેશન: ડાયનેમિક મેમરી એક્સેસની મંજૂરી આપે છે

મ્નેમોનિક: “ADA” (Address Dereferencing Access)

પ્રશ્ન 4(ક) [7 માર્કસ]

#

ડૂ-વાઇલ લૂપ ફ્લોચાર્ટ દોરી ઉદાહરણ સાથે સમજાવો.

જવાબ: ડૂ-વાઇલ લૂપ એક પોસ્ટ-ટેસ્ટ લૂપ છે જે શરત તપાસતા પહેલા ઓછામાં ઓછી એક વખત તેના બોડીને એક્ઝિક્યુટ કરે છે.

ડાયાગ્રામ:

flowchart TD
    A([Start]) --> B[/Initialize counter i = 1/]
    B --> C[/Execute loop body: Print i/]
    C --> D[/Increment i: i++/]
    D --> E{i <= 5?}
    E -->|Yes| C
    E -->|No| F([End])

કોડ ઉદાહરણ:

#include <stdio.h>

int main() {
    int i = 1;
    
    do {
        printf("%d ", i);
        i++;
    } while (i <= 5);  // પ્રથમ એક્ઝિક્યુશન પછી શરત ચેક થાય છે
    
    // આઉટપુટ: 1 2 3 4 5
    
    return 0;
}

કોષ્ટક: ડૂ-વાઇલ લૂપની લાક્ષણિકતાઓ

• પોસ્ટ-ટેસ્ટ લૂપ: લૂપ બોડી પછી શરત મૂલ્યાંકન
• ગેરંટેડ એક્ઝિક્યુશન: લૂપ બોડી હંમેશા ઓછામાં ઓછી એક વખત ચાલે છે
• સેમિકોલોન: વાઇલ કન્ડિશન પછી જરૂરી છે

મ્નેમોનિક: “DECAT” (Do Execute Check After That)

પ્રશ્ન 4(અ) OR [3 માર્કસ]

#

ત્રિકોણનું ક્ષેત્રફળ (૧/૨ * પાયો * ઉંચાઈ) શોધવા માટેનો C પ્રોગ્રામ લખો.

જવાબ: આ પ્રોગ્રામ ક્ષેત્રફળ = ½ × પાયો × ઉંચાઈ સૂત્રનો ઉપયોગ કરીને ત્રિકોણનું ક્ષેત્રફળ ગણે છે.

#include <stdio.h>

int main() {
    float base, height, area;
    
    printf("Enter base of triangle: ");
    scanf("%f", &base);
    printf("Enter height of triangle: ");
    scanf("%f", &height);
    
    // ક્ષેત્રફળ ગણો
    area = 0.5 * base * height;
    
    printf("Area of triangle = %.2f square units\n", area);
    
    return 0;
}

ડાયાગ્રામ:

flowchart TD
    A([Start]) --> B[/Input base, height/]
    B --> C[area = 0.5 * base * height]
    C --> D[/Output area/]
    D --> E([End])

• ફોર્મ્યુલા: ક્ષેત્રફળ = ½ × પાયો × ઉંચાઈ
• ફ્લોટ વેરિએબલ્સ: દશાંશ ચોકસાઈ માટે
• યુઝર ઇનપુટ: યુઝર પાસેથી પાયો અને ઉંચાઈ મેળવે છે

મ્નેમોનિક: “Half-BH” (અડધો ગુણા પાયો ગુણા ઉંચાઈ)

પ્રશ્ન 4(બ) OR [4 માર્કસ]

#

પોઈન્ટરનું ડીકલેરેશન અને ઈનીશ્યલાઈઝેશન સમજાવો.

જવાબ: પોઈન્ટર ડિક્લેરેશન અને ઇનિશિયલાઇઝેશનમાં પોઈન્ટર વેરિએબલ બનાવવાનો અને તેને મેમરી એડ્રેસ સોંપવાનો સમાવેશ થાય છે.

કોષ્ટક: પોઈન્ટર ડિક્લેરેશન અને ઇનિશિયલાઇઝેશન

કોડ ઉદાહરણ:

#include <stdio.h>

int main() {
    // ડિક્લેરેશન
    int *ptr1;
    
    // ડિક્લેરેશન અને ઇનિશિયલાઇઝેશન એકસાથે
    int num = 10;
    int *ptr2 = &num;
    
    // NULL સાથે ઇનિશિયલાઇઝેશન
    int *ptr3 = NULL;
    
    printf("Value at address ptr2: %d\n", *ptr2);  // આઉટપુટ: 10
    
    return 0;
}

• એસ્ટરિસ્ક સિન્ટેક્સ: * નો ઉપયોગ ડિક્લેરેશનમાં પોઈન્ટર બનાવવા માટે
• એડ્રેસ ઓપરેટર: & વેરિએબલનું એડ્રેસ મેળવે છે
• NULL ઇનિશિયલાઇઝેશન: વાઈલ્ડ પોઈન્ટર્સ ટાળવા માટે સુરક્ષિત પદ્ધતિ
• પોઈન્ટર ટાઈપ: જે ડેટા ટાઈપને પોઈન્ટ કરે છે તેને મેચ કરવું જોઈએ

મ્નેમોનિક: “DINA” (Declare, Initialize with NULL or Address)

પ્રશ્ન 4(ક) OR [7 માર્કસ]

#

વાઇલ લૂપ ફ્લોચાર્ટ દોરી ઉદાહરણ સાથે સમજાવો.

જવાબ: વાઇલ લૂપ એક પ્રી-ટેસ્ટ લૂપ છે જે શરત સાચી રહે ત્યાં સુધી તેના બોડીને વારંવાર એક્ઝિક્યુટ કરે છે.

ડાયાગ્રામ:

flowchart TD
    A([Start]) --> B[/Initialize counter i = 1/]
    B --> C{i <= 5?}
    C -->|Yes| D[/Execute loop body: Print i/]
    D --> E[/Increment i: i++/]
    E --> C
    C -->|No| F([End])

કોડ ઉદાહરણ:

#include <stdio.h>

int main() {
    int i = 1;
    
    while (i <= 5) {  // દરેક એક્ઝિક્યુશન પહેલા શરત ચેક થાય છે
        printf("%d ", i);
        i++;
    }
    
    // આઉટપુટ: 1 2 3 4 5
    
    return 0;
}

કોષ્ટક: વાઇલ લૂપની લાક્ષણિકતાઓ

• પ્રી-ટેસ્ટ લૂપ: લૂપ બોડી પહેલા શરત મૂલ્યાંકન
• શૂન્ય પુનરાવર્તન શક્ય: જો શરત પ્રારંભમાં ખોટી હોય તો બોડી ક્યારેય એક્ઝિક્યુટ ન થઈ શકે
• લૂપ વેરિએબલ: લૂપ પહેલા ઇનિશિયલાઇઝ થવું જોઈએ
• ઇન્ફિનિટ લૂપ: જો શરત ક્યારેય ખોટી ન થાય તો થાય છે

મ્નેમોનિક: “CELT” (Check, Execute, Loop, Terminate)

પ્રશ્ન 5(અ) [3 માર્કસ]

#

બુકની આપેલ માહિતી સ્ટોર કરવાનું સ્ટ્રક્ચર બનાવો: book_no, book_title, book_author, book_price

જવાબ: આ પ્રોગ્રામ સ્પષ્ટ કરેલા ફિલ્ડ્સ સાથે પુસ્તક માહિતી સંગ્રહ કરવા માટે સ્ટ્રક્ચર બનાવે છે.

#include <stdio.h>
#include <string.h>

// પુસ્તક માહિતી માટે સ્ટ્રક્ચર ડેફિનેશન
struct Book {
    int book_no;
    char book_title[50];
    char book_author[30];
    float book_price;
};

int main() {
    // Book સ્ટ્રક્ચરના વેરિએબલની ઘોષણા
    struct Book book1;
    
    // સ્ટ્રક્ચર મેમ્બર્સને મૂલ્યો સોંપો
    book1.book_no = 101;
    strcpy(book1.book_title, "Programming in C");
    strcpy(book1.book_author, "Dennis Ritchie");
    book1.book_price = 450.75;
    
    // પુસ્તક માહિતી પ્રદર્શિત કરો
    printf("Book No: %d\n", book1.book_no);
    printf("Title: %s\n", book1.book_title);
    printf("Author: %s\n", book1.book_author);
    printf("Price: Rs. %.2f\n", book1.book_price);
    
    return 0;
}

ડાયાગ્રામ:

+----------------+
| struct Book    |
+----------------+
| int book_no    |
| char book_title|
| char book_author|
| float book_price|
+----------------+

• સ્ટ્રક્ચર ડેફિનિશન: કંપોઝિટ ડેટા પ્રકાર વ્યાખ્યાયિત કરવા struct કીવર્ડનો ઉપયોગ કરે છે
• મેમ્બર એક્સેસ: સભ્યો એક્સેસ કરવા માટે ડોટ (.) ઓપરેટરનો ઉપયોગ કરે છે
• સ્ટ્રિંગ કોપિંગ: કેરેક્ટર એરે માટે strcpy()

મ્નેમોનિક: “NTAP” (Number, Title, Author, Price)

પ્રશ્ન 5(બ) [4 માર્કસ]

#

(1)sqrt() (2)pow() (3)strlen() (4)strcpy() ફંક્શનો ઉદાહરણ સાથે સમજાવો.

જવાબ: આ ફંક્શન C માં ગણિત ગણતરી અને સ્ટ્રિંગ મેનિપ્યુલેશન માટે વપરાતા સ્ટાન્ડર્ડ લાઇબ્રેરી ફંક્શન્સ છે.

કોષ્ટક: લાઇબ્રેરી ફંક્શન્સ

કોડ ઉદાહરણ:

#include <stdio.h>
#include <math.h>
#include <string.h>

int main() {
    // sqrt() અને pow() ઉદાહરણો
    printf("Square root of 25: %.2f\n", sqrt(25));
    printf("2 raised to power 4: %.2f\n", pow(2, 4));
    
    // strlen() ઉદાહરણ
    char str[] = "C Programming";
    printf("Length of string: %d\n", strlen(str));
    
    // strcpy() ઉદાહરણ
    char source[] = "Hello";
    char destination[10];
    strcpy(destination, source);
    printf("Copied string: %s\n", destination);
    
    return 0;
}

• મેથ ફંક્શન્સ: ગાણિતિક ગણતરી માટે sqrt() અને pow()
• સ્ટ્રિંગ ફંક્શન્સ: સ્ટ્રિંગ મેનિપ્યુલેશન માટે strlen() અને strcpy()
• હેડર ફાઈલ્સ: આ ફંક્શન્સ વાપરવા જરૂરી છે
• રિટર્ન ટાઈપ્સ: sqrt() અને pow() double આપે છે, strlen() size_t આપે છે

મ્નેમોનિક: “MPSL” (Math Power and String Length)

પ્રશ્ન 5(ક) [7 માર્કસ]

#

એરે અને એરેનું ઈનીશ્યલાઈઝેશન ઉદાહરણ સાથે સમજાવો.

જવાબ: એરે એ એક જ ડેટા પ્રકારના એલિમેન્ટ્સનો સમૂહ છે જે લગાતાર મેમરી લોકેશન્સમાં સ્ટોર થયેલા હોય છે.

કોષ્ટક: એરે પ્રકારો અને ઇનિશિયલાઇઝેશન પદ્ધતિઓ

કોડ ઉદાહરણ:

#include <stdio.h>

int main() {
    // એરે ડિક્લેરેશન અને ઇનિશિયલાઇઝેશન
    int numbers[5] = {10, 20, 30, 40, 50};
    
    // એરે એલિમેન્ટ્સ એક્સેસ અને ડિસ્પ્લે
    printf("Array elements: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");
    
    // એરે એલિમેન્ટ મોડીફાય કરવું
    numbers[2] = 35;
    printf("Modified element at index 2: %d\n", numbers[2]);
    
    return 0;
}

ડાયાગ્રામ:

એરે: numbers[5]
+-----+-----+-----+-----+-----+
| 10  | 20  | 30  | 40  | 50  |
+-----+-----+-----+-----+-----+
  [0]   [1]   [2]   [3]   [4]

• ઝીરો-બેઝ્ડ ઇન્ડેક્સિંગ: પ્રથમ એલિમેન્ટ ઇન્ડેક્સ 0 પર
• કન્ટિગ્યુઅસ મેમરી: એલિમેન્ટ્સ લાગલાગટ સ્ટોર થાય છે
• ફિક્સ્ડ સાઇઝ: સાઇઝ કમ્પાઇલ ટાઇમે નક્કી થાય છે
• એલિમેન્ટ એક્સેસ: સ્ક્વેર બ્રેકેટ્સ સાથે ઇન્ડેક્સનો ઉપયોગ કરીને

મ્નેમોનિક: “DICE” (Declaration, Initialization, Contiguous storage, Element access)

પ્રશ્ન 5(અ) OR [3 માર્કસ]

#

સ્ટ્રક્ચરનું ડીકલેરેશન ઉદાહરણ સાથે સમજાવો.

જવાબ: C માં સ્ટ્રક્ચર ડિક્લેરેશનમાં એક નવો ડેટા પ્રકાર વ્યાખ્યાયિત કરવાનો સમાવેશ થાય છે જે વિવિધ ડેટા પ્રકારોને એક નામ હેઠળ જોડે છે.

કોષ્ટક: સ્ટ્રક્ચર ડિક્લેરેશન પદ્ધતિઓ

કોડ ઉદાહરણ:

#include <stdio.h>

// સ્ટ્રક્ચર ડિક્લેરેશન
struct Student {
    int id;
    char name[30];
    float percentage;
};

int main() {
    // સ્ટ્રક્ચર વેરિએબલ ડિક્લેર
    struct Student s1;
    
    // સ્ટ્રક્ચર મેમ્બર્સને મૂલ્યો સોંપો
    s1.id = 101;
    strcpy(s1.name, "John");
    s1.percentage = 85.5;
    
    // સ્ટ્રક્ચર મેમ્બર્સ ડિસ્પ્લે
    printf("Student ID: %d\n", s1.id);
    printf("Name: %s\n", s1.name);
    printf("Percentage: %.2f%%\n", s1.percentage);
    
    return 0;
}

• સ્ટ્રક્ચર કીવર્ડ: નવો ડેટા પ્રકાર વ્યાખ્યાયિત કરવા struct નો ઉપયોગ
• મેમ્બર એક્સેસ: મેમ્બર્સ એક્સેસ કરવા માટે . (ડોટ) ઓપરેટર
• વિષમ ડેટા: વિવિધ ડેટા પ્રકારોને જોડી શકે છે
• કસ્ટમ ડેટા પ્રકાર: યુઝર-ડિફાઇન્ડ ડેટા પ્રકાર બનાવે છે

મ્નેમોનિક: “SMUVT” (Structure Mostly Uses Various Types)

પ્રશ્ન 5(બ) OR [4 માર્કસ]

#

યુઝર ડીફાઈન ફંક્શન એટલે શું? ઉદાહરણ સાથે સમજાવો.

જવાબ: યુઝર-ડિફાઇન્ડ ફંક્શન એ પ્રોગ્રામર દ્વારા લખાયેલો કોડનો બ્લોક છે જે ચોક્કસ કાર્ય કરે છે અને પ્રોગ્રામના અન્ય ભાગોથી કોલ કરી શકાય છે.

કોષ્ટક: ફંક્શન કોમ્પોનન્ટ્સ

કોડ ઉદાહરણ:

#include <stdio.h>

// યુઝર-ડિફાઇન્ડ ફંક્શન ડિક્લેરેશન
int findMax(int a, int b);

int main() {
    int num1 = 10, num2 = 20, max;
    
    // ફંક્શન કોલ
    max = findMax(num1, num2);
    
    printf("Maximum between %d and %d is %d\n", num1, num2, max);
    
    return 0;
}

// ફંક્શન ડેફિનિશન
int findMax(int a, int b) {
    // ફંક્શન બોડી
    if (a > b)
        return a;
    else
        return b;
}

ડાયાગ્રામ:

flowchart TD
    A[main function] -->|calls with num1, num2| B[findMax function]
    B -->|returns maximum value| A

• મોડ્યુલર કોડ: મોટા પ્રોગ્રામને નાના ભાગોમાં વિભાજિત કરે છે
• રીયુઝેબિલિટી: ફંક્શનને અલગ અલગ જગ્યાએથી અનેક વખત કોલ કરી શકાય
• ડિક્લેરેશન vs ડેફિનિશન: ડિક્લેરેશન કમ્પાઇલરને ફંક્શન વિશે જણાવે છે, ડેફિનિશનમાં ખરેખર કોડ હોય છે
• પેરામીટર્સ: ફંક્શન કોલ કરતી વખતે મૂલ્યો પાસ કરે છે

મ્નેમોનિક: “CDRP” (Create, Define, Return, Pass)

પ્રશ્ન 5(ક) OR [7 માર્કસ]

#

૧૦ નંબરવાળા એરેના ઘટકોને ચઢતા ક્રમમાં ગોઠવવા માટેનો C પ્રોગ્રામ લખો.

જવાબ: આ પ્રોગ્રામ બબલ સોર્ટ અલ્ગોરિધમનો ઉપયોગ કરીને 10 ઇન્ટીજરના એરેને ચઢતા ક્રમમાં સોર્ટ કરે છે.

#include <stdio.h>

int main() {
    int arr[10], i, j, temp;
    
    // એરે એલિમેન્ટ્સ ઇનપુટ કરો
    printf("Enter 10 integers: \n");
    for (i = 0; i < 10; i++) {
        scanf("%d", &arr[i]);
    }
    
    // ચઢતા ક્રમ માટે બબલ સોર્ટ અલ્ગોરિધમ
    for (i = 0; i < 9; i++) {
        for (j = 0; j < 9 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                // જો વર્તમાન એલિમેન્ટ આગળના કરતાં મોટું હોય તો સ્વેપ કરો
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    
    // સોર્ટેડ એરે ડિસ્પ્લે કરો
    printf("Array in ascending order: \n");
    for (i = 0; i < 10; i++) {
        printf("%d ", arr[i]);
    }
    
    return 0;
}

ડાયાગ્રામ:

flowchart TD
    A([Start]) --> B[/Input 10 array elements/]
    B --> C[i = 0]
    C --> D{i < 9?}
    D -->|Yes| E[j = 0]
    E --> F{j < 9-i?}
    F -->|Yes| G{arr[j] > arr[j+1]?}
    G -->|Yes| H[Swap arr[j] and arr[j+1]]
    G -->|No| I[j++]
    H --> I
    I --> F
    F -->|No| J[i++]
    J --> D
    D -->|No| K[/Output sorted array/]
    K --> L([End])

• બબલ સોર્ટ: બાજુના એલિમેન્ટની સરખામણી કરે અને જરૂર હોય તો સ્વેપ કરે
• નેસ્ટેડ લૂપ્સ: બહારની લૂપ પાસ માટે, અંદરની તુલના માટે
• ઓપ્ટિમાઇઝેશન: દરેક પાસ ઓછામાં ઓછા એક એલિમેન્ટને ફિક્સ કરે છે, તેથી અંદરની લૂપ ઓછી વખત ચાલે છે
• ટેમ્પરરી વેરિએબલ: એલિમેન્ટ્સ સ્વેપ કરવા માટે ઉપયોગ થાય છે

મ્નેમોનિક: “BSCOT” (Bubble Sort Compares and Orders Things)