મુખ્ય સામગ્રી પર જાઓ
  1. સંસાધનો/
  2. અભ્યાસ સામગ્રી/
  3. ઇલેક્ટ્રોનિક્સ અને કમ્યુનિકેશન એન્જિનિયરિંગ/
  4. ઇસીઇ સેમેસ્ટર 3/

પ્રોગ્રામિંગ ઇન સી (4331105) - વિન્ટર 2023 સોલ્યુશન

16 મિનિટ· ·
Study-Material Solutions Programming C-Language 4331105 2024 Winter
મિલવ ડબગર
લેખક
મિલવ ડબગર
ઇલેક્ટ્રિકલ અને ઇલેક્ટ્રોનિક મેન્યુફેક્ચરિંગ ઉદ્યોગમાં અનુભવી લેક્ચરર. એમ્બેડેડ સિસ્ટમ્સ, ઈમેજ પ્રોસેસિંગ, ડેટા સાયન્સ, મેટલેબ, પાયથન, STM32માં કુશળ. એલ.ડી. કોલેજ ઓફ એન્જિનિયરિંગ - અમદાવાદથી કમ્યુનિકેશન સિસ્ટમ્સ એન્જિનિયરિંગમાં માસ્ટર્સ ડિગ્રી ધરાવતા મજબૂત શિક્ષણ વ્યાવસાયિક.
અનુક્રમણિકા

પ્રશ્ન 1(a) [3 ગુણ]
#

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

જવાબ:

વર્ગકીવર્ડ
ડેટા ટાઈપ્સint, float, char
કંટ્રોલ ફ્લોif, for, return

મ્નેમોનિક: “I Find Clever Reasons For Results”

પ્રશ્ન 1(b) [4 ગુણ]
#

ઓપરેટરની વ્યાખ્યા આપી operand ના આધારે તેના પ્રકાર જણાવો.

જવાબ:

ઓપરેટર: એવું ચિહ્ન કે જે ઓપરન્ડ્સ પર કામ કરીને પરિણામ આપે છે.

પ્રકારવિગતઉદાહરણ
યુનરીએક ઓપરન્ડ++, –, !
બાઇનરીબે ઓપરન્ડ+, -, *, /, %
ટર્નરીત્રણ ઓપરન્ડ?:

મ્નેમોનિક: “U-B-T: Use Binary Then Ternary”

પ્રશ્ન 1(c) [7 ગુણ]
#

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

જવાબ:

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

ફ્લોચાર્ટના સામાન્ય ચિહ્નો:

ચિહ્નઅર્થ
ઓવલશરૂઆત/અંત
પેરાલેલોગ્રામઇનપુટ/આઉટપુટ
લંબચોરસપ્રક્રિયા
ડાયમંડનિર્ણય
એરોફ્લો દિશા

N1 અને N2 માંથી નાનો નંબર શોધવા માટેનો ફ્લોચાર્ટ:

flowchart TD
    A([Start]) --> B[/Input N1, N2/]
    B --> C{N1 < N2?}
    C -->|Yes| D[Min = N1]
    C -->|No| E[Min = N2]
    D --> F[/Display Min/]
    E --> F
    F --> G([End])

મ્નેમોનિક: “SPADE: Start-Process-Arrow-Decision-End”

પ્રશ્ન 1(c) OR [7 ગુણ]
#

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

જવાબ:

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

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

  1. શરૂઆત
  2. ત્રિજ્યા r ઇનપુટ કરો
  3. PI = 3.14159 સેટ કરો
  4. ક્ષેત્રફળ = PI × r × r ગણો
  5. પરિઘ = 2 × PI × r ગણો
  6. ક્ષેત્રફળ અને પરિઘ દર્શાવો
  7. અંત

ઉપયોગિત સૂત્રોનો કોષ્ટક:

માપનસૂત્ર
ક્ષેત્રફળπ × r²
પરિઘ2 × π × r

મ્નેમોનિક: “RICARD: Radius Input, Calculate Area, Reveal Dimensions”

પ્રશ્ન 2(a) [3 ગુણ]
#

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

જવાબ:

લક્ષણprintf()scanf()
હેતુસ્ક્રીન પર ડેટા આઉટપુટ કરેકીબોર્ડથી ડેટા ઇનપુટ કરે
દિશાઆઉટપુટ ફંક્શનઇનપુટ ફંક્શન
ફોર્મેટ સ્પેસિફાયરજરૂરીજરૂરી
પેરામીટરવાસ્તવિક મૂલ્યોચલનું સરનામું (&)

મ્નેમોનિક: “OIAD: Output-Input, Actual-Destination”

પ્રશ્ન 2(b) [4 ગુણ]
#

1 થી n સુધીનો સરવાળો અને સરેરાશ પ્રિન્ટ કરવા માટે પ્રોગ્રામ C લખો.

જવાબ:

#include <stdio.h>

int main() {
    int n, i, sum = 0;
    float avg;
    
    printf("Enter n: ");
    scanf("%d", &n);
    
    for(i = 1; i <= n; i++) {
        sum += i;
    }
    
    avg = (float)sum / n;
    
    printf("Sum = %d\n", sum);
    printf("Average = %.2f\n", avg);
    
    return 0;
}

મુખ્ય બિંદુઓ:

  • ઇનિશિયલાઇઝેશન: sum = 0
  • પુનરાવર્તન: 1 થી n સુધી for લૂપ
  • ટાઇપ કાસ્ટિંગ: સાચા સરેરાશ માટે (float)

મ્નેમોનિક: “SIAP: Sum Initialize, Add in loop, Print results”

પ્રશ્ન 2(c) [7 ગુણ]
#

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

જવાબ:

1. એરિથમેટિક ઓપરેટર:

ઓપરેટરઓપરેશનઉદાહરણપરિણામ
+સરવાળો5 + 38
-બાદબાકી5 - 32
*ગુણાકાર5 * 315
/ભાગાકાર5 / 22 (પૂર્ણાંક)
%મોડ્યુલો (શેષ)5 % 21

2. રિલેશનલ ઓપરેટર:

ઓપરેટરઅર્થઉદાહરણપરિણામ
<કરતાં નાનું5 < 30 (ખોટું)
>કરતાં મોટું5 > 31 (સાચું)
<=નાનું અથવા સમાન5 <= 51 (સાચું)
>=મોટું અથવા સમાન3 >= 50 (ખોટું)
==સમાન5 == 51 (સાચું)
!=અસમાન5 != 31 (સાચું)

કોડ ઉદાહરણ:

int a = 5, b = 3;
printf("a + b = %d\n", a + b);     // આઉટપુટ: 8
printf("a > b is %d\n", a > b);    // આઉટપુટ: 1 (સાચું)

મ્નેમોનિક: “ASMDR for Arithmetic, LEGENE for Relational”

પ્રશ્ન 2(a) OR [3 ગુણ]
#

get(S) અને scanf("%s",S) વચ્ચેનો તફાવત સમજાવો.

જવાબ:

લક્ષણgets(S)scanf("%s",S)
વ્હાઇટસ્પેસ હેન્ડલિંગસ્પેસ વાંચે છેવ્હાઇટસ્પેસ પર બંધ થાય છે
બફર ઓવરફ્લોબાઉન્ડરી ચેક નથીવિડ્થ લિમિટ સાથે સલામત
રિટર્ન ટાઇપchar*વાંચેલા આઇટમની સંખ્યા
ઉપયોગ સુરક્ષાડેપ્રિકેટેડ, અસુરક્ષિતફોર્મેટ કંટ્રોલ સાથે સલામત

મ્નેમોનિક: “WBRU: Whitespace-Boundary-Return-Usage”

પ્રશ્ન 2(b) OR [4 ગુણ]
#

બે નંબરોના મૂલ્યની અદલાબદલી (એક્સચેન્જ) કરવા માટે C પ્રોગ્રામ લખો.

જવાબ:

#include <stdio.h>

int main() {
    int a, b, temp;
    
    printf("Enter two numbers: ");
    scanf("%d %d", &a, &b);
    
    printf("Before swap: a = %d, b = %d\n", a, b);
    
    temp = a;
    a = b;
    b = temp;
    
    printf("After swap: a = %d, b = %d\n", a, b);
    
    return 0;
}

ડાયાગ્રામ:

flowchart LR
    subgraph Before
    A1[a = 5] --- B1[b = 10]
    end
    subgraph Step1
    A2[a = 5] --- T[temp = 5]
    B2[b = 10]
    end
    subgraph Step2
    A3[a = 10] --- T2[temp = 5]
    B3[b = 10]
    end
    subgraph After
    A4[a = 10] --- B4[b = 5]
    end
    Before --> Step1
    Step1 --> Step2
    Step2 --> After

મ્નેમોનિક: “TAB: Temp-Assign-Backfill”

પ્રશ્ન 2(c) OR [7 ગુણ]
#

બુલિયન ઓપરેટર અને લોજિકલ ઓપરેટર ઉદાહરણ સાથે સમજાવો.

જવાબ:

1. બુલિયન ઓપરેટર:

ઓપરેટરઓપરેશનઉદાહરણપરિણામ
&બિટવાઇઝ AND5 & 31
|બિટવાઇઝ OR5 | 37
^બિટવાઇઝ XOR5 ^ 36
~બિટવાઇઝ NOT~5-6
«લેફ્ટ શિફ્ટ5 « 110
»રાઇટ શિફ્ટ5 » 12

2. લોજિકલ ઓપરેટર:

ઓપરેટરઅર્થઉદાહરણપરિણામ
&&લોજિકલ AND(5>3) && (2<4)1 (સાચું)
||લોજિકલ OR(5<3) || (2<4)1 (સાચું)
!લોજિકલ NOT!(5>3)0 (ખોટું)

ઉદાહરણ:

int a = 5, b = 3;
printf("a & b = %d\n", a & b);           // આઉટપુટ: 1 (બિટવાઇઝ AND)
printf("a > b && b < 10 is %d\n", a > b && b < 10);  // આઉટપુટ: 1 (સાચું)

બિટ રિપ્રેઝન્ટેશન (5 & 3):

5 = 101
3 = 011
& = 001 (1 in decimal)

મ્નેમોનિક: “BOXNRL for Boolean, AON for Logical”

પ્રશ્ન 3(a) [3 ગુણ]
#

Entry controlled અને exit controlled લૂપની ઉદાહરણ સાથે સરખામણી કરો.

જવાબ:

લક્ષણEntry ControlledExit Controlled
શરત ચકાસણીઅમલ પહેલાઅમલ પછી
ન્યૂનતમ પુનરાવર્તનશૂન્યએક
ઉદાહરણwhile, fordo-while
ઉપયોગપ્રી-ચેક જરૂરી હોયઓછામાં ઓછું એક વાર અમલ જરૂરી હોય

મ્નેમોનિક: “BCME: Before-Check-Multiple-Examples”

પ્રશ્ન 3(b) [4 ગુણ]
#

સ્વીચ કેસનો ઉપયોગ કરીને બે નંબરોના સરવાળા અને બાદબાકી દર્શાવવા માટેનો C પ્રોગ્રામ લખો.

જવાબ:

#include <stdio.h>

int main() {
    int a, b, choice, result;
    
    printf("Enter two numbers: ");
    scanf("%d %d", &a, &b);
    
    printf("1. Addition\n2. Subtraction\n");
    printf("Enter choice (1/2): ");
    scanf("%d", &choice);
    
    switch(choice) {
        case 1:
            result = a + b;
            printf("Addition: %d\n", result);
            break;
        case 2:
            result = a - b;
            printf("Subtraction: %d\n", result);
            break;
        default:
            printf("Invalid choice\n");
    }
    
    return 0;
}

ફ્લોચાર્ટ:

flowchart TD
    A([Start]) --> B[/Input a, b/]
    B --> C[/Input choice/]
    C --> D{switch(choice)}
    D -->|case 1| E[result = a + b]
    D -->|case 2| F[result = a - b]
    D -->|default| G[Display Invalid]
    E --> H[/Display Addition/]
    F --> I[/Display Subtraction/]
    H --> J([End])
    I --> J
    G --> J

મ્નેમોનિક: “CIRCA: Choice-Input-Result-Calculate-Action”

પ્રશ્ન 3(c) [7 ગુણ]
#

સિન્ટેક્સ, ફ્લોચાર્ટ અને ઉદાહરણ સાથે multiple if-else સ્ટેટમેન્ટ સમજાવો.

જવાબ:

multiple if-else સિન્ટેક્સ:

if (condition1) {
    // code block 1
} 
else if (condition2) {
    // code block 2
} 
else if (condition3) {
    // code block 3
} 
else {
    // default code block
}

ફ્લોચાર્ટ:

flowchart TD
    A([Start]) --> B{condition1?}
    B -->|True| C[Execute block 1]
    B -->|False| D{condition2?}
    D -->|True| E[Execute block 2]
    D -->|False| F{condition3?}
    F -->|True| G[Execute block 3]
    F -->|False| H[Execute default block]
    C --> I([End])
    E --> I
    G --> I
    H --> I

ઉદાહરણ:

#include <stdio.h>

int main() {
    int marks;
    
    printf("Enter marks: ");
    scanf("%d", &marks);
    
    if (marks >= 80) {
        printf("Grade: A\n");
    } 
    else if (marks >= 70) {
        printf("Grade: B\n");
    } 
    else if (marks >= 60) {
        printf("Grade: C\n");
    } 
    else {
        printf("Grade: F\n");
    }
    
    return 0;
}

મ્નેમોનિક: “TEST: Try Each Statement Then default”

પ્રશ્ન 3(a) OR [3 ગુણ]
#

break અને continue કીવર્ડનો ઉપયોગ જણાવો.

જવાબ:

કીવર્ડહેતુઅસરસામાન્ય ઉપયોગ
breakલૂપ/સ્વિચ ટર્મિનેટ કરેવર્તમાન લૂપ/સ્વિચ છોડી દેશરત પૂરી થાય ત્યારે બહાર નીકળવા
continueઇટરેશન છોડેઆગામી ઇટરેશન પર જાયચોક્કસ મૂલ્યો છોડવા

ઉદાહરણ કોડ:

// break ઉદાહરણ
for(i=1; i<=10; i++) {
    if(i == 5) break; // i=5 પર લૂપ છોડે
    printf("%d ", i);  // 1 2 3 4 પ્રિન્ટ કરે
}

// continue ઉદાહરણ
for(i=1; i<=5; i++) {
    if(i == 3) continue; // i=3 છોડે
    printf("%d ", i);  // 1 2 4 5 પ્રિન્ટ કરે
}

મ્નેમોનિક: “EXIT-SKIP: EXit IT or SKIP iteration”

પ્રશ્ન 3(b) OR [4 ગુણ]
#

આપેલ સંખ્યા એકી છે કે બેકી તે ચકાસવા માટે C પ્રોગ્રામનો લખો.

જવાબ:

#include <stdio.h>

int main() {
    int num;
    
    printf("Enter a number: ");
    scanf("%d", &num);
    
    if (num % 2 == 0) {
        printf("%d is even.\n", num);
    } 
    else {
        printf("%d is odd.\n", num);
    }
    
    return 0;
}

ડાયાગ્રામ:

flowchart TD
    A([Start]) --> B[/Input num/]
    B --> C{num % 2 == 0?}
    C -->|Yes| D[/Display "Even"/]
    C -->|No| E[/Display "Odd"/]
    D --> F([End])
    E --> F

મુખ્ય બિંદુઓ:

  • ચકાસણી: મોડ્યુલો (%) ઓપરેટરનો ઉપયોગ
  • નિર્ણય: 2 સાથેના શેષ પર આધારિત
  • આઉટપુટ: શેષ 0 હોય તો બેકી, અન્યથા એકી

મ્નેમોનિક: “MODE: MODulo Equals zero for even”

પ્રશ્ન 3(c) OR [7 ગુણ]
#

સિન્ટેક્સ, ફ્લોચાર્ટ અને ઉદાહરણ સાથે switch-case statement સ્ટેટમેન્ટ સમજાવો.

જવાબ:

switch-case સિન્ટેક્સ:

switch (expression) {
    case constant1:
        // code block 1
        break;
    case constant2:
        // code block 2
        break;
    ...
    default:
        // default code block
}

ફ્લોચાર્ટ:

flowchart TD
    A([Start]) --> B[Evaluate expression]
    B --> C{matches case 1?}
    C -->|Yes| D[Execute block 1]
    C -->|No| E{matches case 2?}
    E -->|Yes| F[Execute block 2]
    E -->|No| G{matches case n?}
    G -->|Yes| H[Execute block n]
    G -->|No| I[Execute default block]
    D --> J[break?]
    F --> K[break?]
    H --> L[break?]
    J -->|Yes| M([End])
    K -->|Yes| M
    L -->|Yes| M
    I --> M
    J -->|No| E
    K -->|No| G
    L -->|No| M

ઉદાહરણ:

#include <stdio.h>

int main() {
    char grade;
    
    printf("Enter grade (A-D): ");
    scanf(" %c", &grade);
    
    switch (grade) {
        case 'A':
            printf("Excellent!\n");
            break;
        case 'B':
            printf("Good job!\n");
            break;
        case 'C':
            printf("Satisfactory\n");
            break;
        case 'D':
            printf("Needs improvement\n");
            break;
        default:
            printf("Invalid grade\n");
    }
    
    return 0;
}

મ્નેમોનિક: “CEBID: Compare-Execute-Break-If-Done”

પ્રશ્ન 4(a) [3 ગુણ]
#

સ્ટ્રિંગ વ્યાખ્યાયિત કરો. સ્ટ્રિંગ પર કરી શકાય તેવા વિવિધ ઓપરેશન્સની યાદી આપો.

જવાબ:

સ્ટ્રિંગ: કેરેક્ટર્સનો એરે જે NULL કેરેક્ટર ‘\0’ થી સમાપ્ત થાય છે.

ઓપરેશનવિગતફંક્શન
ઇનપુટ/આઉટપુટસ્ટ્રિંગ વાંચવી/લખવીgets(), puts()
કોપીએક સ્ટ્રિંગને બીજી સ્ટ્રિંગમાં કોપી કરવીstrcpy()
જોડાણબે સ્ટ્રિંગ જોડવીstrcat()
સરખામણીબે સ્ટ્રિંગની સરખામણીstrcmp()
લંબાઈસ્ટ્રિંગની લંબાઈ શોધવીstrlen()
શોધસબસ્ટ્રિંગ શોધવીstrstr()

મ્નેમોનિક: “ICCLS: Input-Copy-Concatenate-Length-Search”

પ્રશ્ન 4(b) [4 ગુણ]
#

અપરકેસ આલ્ફાબેટને લોઅરકેસ આલ્ફાબેટમાં કન્વર્ટ કરવા માટે C પ્રોગ્રામ લખો.

જવાબ:

#include <stdio.h>

int main() {
    char ch;
    
    printf("Enter an uppercase letter: ");
    scanf(" %c", &ch);
    
    if (ch >= 'A' && ch <= 'Z') {
        char lowercase = ch + 32;  // ASCII તફાવત 32 છે
        printf("Lowercase: %c\n", lowercase);
    } 
    else {
        printf("Not an uppercase letter\n");
    }
    
    return 0;
}

ASCII ટેબલનો અંશ:

કેરેક્ટરASCII મૂલ્ય
A65
a97
Z90
z122
તફાવત32

મ્નેમોનિક: “COOL: Character Offset Of Lowercase”

પ્રશ્ન 4(c) [7 ગુણ]
#

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

જવાબ:

For Loop સિન્ટેક્સ:

for (initialization; condition; increment/decrement) {
    // code block
}

ફ્લોચાર્ટ:

flowchart TD
    A([Start]) --> B[Initialization]
    B --> C{Condition?}
    C -->|True| D[Execute code block]
    D --> E[Increment/Decrement]
    E --> C
    C -->|False| F([End])

For Loop ઘટકો:

  1. ઇનિશિયલાઇઝેશન: શરૂઆતમાં એક વખત અમલ
  2. શરત: દરેક પુનરાવર્તન પહેલાં ચકાસાય
  3. વૃદ્ધિ/ઘટાડો: દરેક પુનરાવર્તન પછી અમલ
  4. બોડી: શરત સાચી હોય તો અમલ

ઉદાહરણ:

#include <stdio.h>

int main() {
    int i;
    
    for (i = 1; i <= 5; i++) {
        printf("%d ", i);
    }
    // આઉટપુટ: 1 2 3 4 5
    
    return 0;
}

અમલીકરણનો પ્રવાહ:

  1. i = 1 પ્રારંભિક
  2. શરત ચકાસો (1 <= 5) - સાચું
  3. બોડી અમલ - 1 પ્રિન્ટ
  4. i ને 2 માં વૃદ્ધિ
  5. શરત ચકાસો (2 <= 5) - સાચું
  6. અને એ રીતે આગળ i = 6 થાય ત્યાં સુધી

મ્નેમોનિક: “ICE-T: Initialize, Check, Execute, Then increment”

પ્રશ્ન 4(a) OR [3 ગુણ]
#

એરે વ્યાખ્યાયિત કરો. એરે પર કરી શકાય તેવા વિવિધ ઓપરેશન્સની યાદી આપો.

જવાબ:

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

ઓપરેશનવિગતઉદાહરણ
ઘોષણાએરે બનાવોint arr[5];
ઇનિશિયલાઇઝેશનમૂલ્ય આપોarr[0] = 10;
ટ્રેવર્સલતમામ તત્વો એક્સેસ કરોfor loop
ઇન્સર્શનનવું તત્વ ઉમેરોarr[pos] = value;
ડિલીશનતત્વ દૂર કરોતત્વો શિફ્ટ કરો
સર્ચિંગતત્વ શોધોલિનિયર/બાઇનરી શોધ
સોર્ટિંગતત્વો ગોઠવોબબલ/સિલેક્શન સોર્ટ

મ્નેમોનિક: “DITIDSS: Declare-Initialize-Traverse-Insert-Delete-Search-Sort”

પ્રશ્ન 4(b) OR [4 ગુણ]
#

pointer વ્યાખ્યાયિત કરો. ઉદાહરણ સાથે સમજાવો.

જવાબ:

પોઇન્ટર: એવું ચલ જે અન્ય ચલના મેમરી સરનામાને સંગ્રહિત કરે છે.

કન્સેપ્ટવિગતસિન્ટેક્સ
ઘોષણાપોઇન્ટર બનાવોint *ptr;
એડ્રેસ ઓપરેટરસરનામું મેળવો&variable
ડિરેફરન્સિંગસરનામા પર મૂલ્ય એક્સેસ કરો*ptr
એસાઇનમેન્ટપોઇન્ટરમાં સરનામું સંગ્રહોptr = &variable;

ઉદાહરણ:

#include <stdio.h>

int main() {
    int num = 10;
    int *ptr;
    
    ptr = &num;  // num નું સરનામું ptr માં સંગ્રહો
    
    printf("Value of num: %d\n", num);           // 10
    printf("Address of num: %p\n", &num);        // num નું સરનામું
    printf("Value of ptr: %p\n", ptr);           // સમાન સરનામું
    printf("Value pointed by ptr: %d\n", *ptr);  // 10
    
    *ptr = 20;   // પોઇન્ટર દ્વારા મૂલ્ય બદલો
    printf("New value of num: %d\n", num);       // 20
    
    return 0;
}

ડાયાગ્રામ:

flowchart LR
    subgraph Memory
    A[ptr: 1001] -->|contains| B[1000]
    C[num: 1000] -->|contains| D[10]
    end
    B -.->|points to| C

મ્નેમોનિક: “SAVD: Store Address, Value through Dereferencing”

પ્રશ્ન 4(c) OR [7 ગુણ]
#

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

જવાબ:

While Loop સિન્ટેક્સ:

while (condition) {
    // code block
}

ફ્લોચાર્ટ:

flowchart TD
    A([Start]) --> B{Condition?}
    B -->|True| C[Execute code block]
    C --> D[Update control variable]
    D --> B
    B -->|False| E([End])

While Loop ઘટકો:

  1. ઇનિશિયલાઇઝેશન: લૂપની પહેલાં
  2. શરત: દરેક પુનરાવર્તન પહેલાં ચકાસાય
  3. બોડી: શરત સાચી હોય તો અમલ
  4. અપડેટ: બોડીની અંદર કરવું જરૂરી

ઉદાહરણ:

#include <stdio.h>

int main() {
    int i = 1;
    
    while (i <= 5) {
        printf("%d ", i);
        i++;
    }
    // આઉટપુટ: 1 2 3 4 5
    
    return 0;
}

અમલીકરણનો પ્રવાહ:

  1. i = 1 પ્રારંભિક (લૂપ પહેલાં)
  2. શરત ચકાસો (1 <= 5) - સાચું
  3. બોડી અમલ - 1 પ્રિન્ટ
  4. i ને 2 માં અપડેટ
  5. શરત ચકાસો (2 <= 5) - સાચું
  6. અને એ રીતે આગળ i = 6 થાય ત્યાં સુધી

મ્નેમોનિક: “CHECK-UPDATE: CHECK before entering, UPDATE before repeating”

પ્રશ્ન 5(a) [3 ગુણ]
#

નીચેના functions નો ઉપયોગ જણાવો. (1) strcat() (2) strlen() (3) strcpy()

જવાબ:

ફંક્શનહેતુસિન્ટેક્સઉદાહરણ
strcat()સ્ટ્રિંગ્સ જોડે છેstrcat(dest, src)“Hello” + “World” -> “HelloWorld”
strlen()સ્ટ્રિંગની લંબાઈ આપે છેstrlen(str)“Hello” -> 5
strcpy()સ્ટ્રિંગ કોપી કરે છેstrcpy(dest, src)src -> dest

કોડ ઉદાહરણ:

#include <string.h>

char str1[20] = "Hello";
char str2[20] = "World";
char str3[20];

strcat(str1, str2);    // str1 "HelloWorld" બને છે
int len = strlen(str1); // len 10 બને છે
strcpy(str3, str1);    // str3 "HelloWorld" બને છે

મ્નેમોનિક: “CLS: Concatenate-Length-Source copy”

પ્રશ્ન 5(b) [4 ગુણ]
#

પુસ્તકની માહિતી સંગ્રહિત કરવા માટે એક સ્ટ્રક્ચર બનાવો: 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() {
    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: %.2f\n", book1.book_price);
    
    return 0;
}

સ્ટ્રક્ચર મેમરી લેઆઉટ:

flowchart TD
    subgraph "struct Book"
    A[book_no: 4 bytes] --> B[book_title: 50 bytes]
    B --> C[book_author: 30 bytes]
    C --> D[book_price: 4 bytes]
    end

મ્નેમોનિક: “NTAP: Number-Title-Author-Price”

પ્રશ્ન 5(c) [7 ગુણ]
#

એરે અને એરે initialization સમજાવો. ઉદાહરણ આપો.

જવાબ:

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

એરે ઇનિશિયલાઇઝેશન પદ્ધતિઓ:

પદ્ધતિસિન્ટેક્સઉદાહરણ
ઘોષણા સમયેdatatype array_name[size] = {values};int arr[5] = {10, 20, 30, 40, 50};
આંશિકdatatype array_name[size] = {values};int arr[5] = {10, 20}; // બાકીના 0 છે
બધા શૂન્યdatatype array_name[size] = {0};int arr[5] = {0};
તત્વ દર તત્વarray_name[index] = value;arr[0] = 10; arr[1] = 20;
સાઇઝ અનુમાનdatatype array_name[] = {values};int arr[] = {10, 20, 30}; // સાઇઝ 3

ઉદાહરણ:

#include <stdio.h>

int main() {
    // પદ્ધતિ 1: પૂર્ણ ઇનિશિયલાઇઝેશન
    int arr1[5] = {10, 20, 30, 40, 50};
    
    // પદ્ધતિ 2: આંશિક ઇનિશિયલાઇઝેશન (બાકીના તત્વો 0 થાય છે)
    int arr2[5] = {10, 20};  // arr2[2], arr2[3], arr2[4] શૂન્ય થાય છે
    
    // પદ્ધતિ 3: તત્વ દર તત્વ
    int arr3[3];
    arr3[0] = 100;
    arr3[1] = 200;
    arr3[2] = 300;
    
    // પદ્ધતિ 4: સાઇઝ અનુમાન
    int arr4[] = {1, 2, 3, 4, 5};  // સાઇઝ આપોઆપ 5 થાય છે
    
    // તત્વો એક્સેસ
    printf("arr1[2] = %d\n", arr1[2]);  // આઉટપુટ: 30
    
    // એરે ટ્રેવર્સલ
    printf("arr4 elements: ");
    for(int i = 0; i < 5; i++) {
        printf("%d ", arr4[i]);  // આઉટપુટ: 1 2 3 4 5
    }
    
    return 0;
}

મેમરી રિપ્રેઝન્ટેશન:

flowchart LR
    subgraph "arr1[5]"
    A[arr1[0]: 10] --- B[arr1[1]: 20] --- C[arr1[2]: 30] --- D[arr1[3]: 40] --- E[arr1[4]: 50]
    end

મ્નેમોનિક: “CAPES: Complete, Automatic, Partial, Element, Size-inferred”

પ્રશ્ન 5(a) OR [3 ગુણ]
#

array અને structure ઉદાહરણ સાથે સરખામણી કરો.

જવાબ:

લક્ષણArrayStructure
ડેટા ટાઇપસમાન પ્રકારના તત્વોઅલગ પ્રકારના તત્વો
એક્સેસઇન્ડેક્સનો ઉપયોગ (arr[i])ડોટ ઓપરેટરનો ઉપયોગ (s.member)
મેમરીક્રમિક, ફિક્સ સાઇઝક્રમિક, પેડિંગ હોઈ શકે
એસાઇનમેન્ટતત્વ દર તત્વસીધું જ સુસંગત સ્ટ્રક્ચર સાથે
હેતુસમાન આઇટમોનો સંગ્રહસંબંધિત ડેટાનો સમૂહ

એરે ઉદાહરણ:

int marks[5] = {85, 90, 78, 92, 88};
printf("%d", marks[2]);  // ઇન્ડેક્સ 2 (78) પર તત્વ એક્સેસ

સ્ટ્રક્ચર ઉદાહરણ:

struct Student {
    int roll_no;
    char name[20];
    float percentage;
};

struct Student s1 = {101, "Raj", 85.5};
printf("%s", s1.name);  // name મેમ્બર ("Raj") એક્સેસ

મ્નેમોનિક: “DAMPA: Datatype-Access-Memory-Purpose-Assignment”

પ્રશ્ન 5(b) OR [4 ગુણ]
#

User Defined Function વ્યાખ્યાયિત કરો. ઉદાહરણ સાથે સમજાવો.

જવાબ:

User Defined Function: પ્રોગ્રામર દ્વારા લખાયેલ કોડનો બ્લોક જે ચોક્કસ કાર્ય કરે છે અને તેને વારંવાર કોલ કરી શકાય છે.

ઘટકવિગતઉદાહરણ
રિટર્ન ટાઇપપરત થતા ડેટાનો પ્રકારint, float, void
ફંક્શન નેમઅનન્ય ઓળખકર્તાsum, findMax
પેરામીટર્સઇનપુટ ડેટા(int a, int b)
બોડીસ્ટેટમેન્ટ સમૂહ{ return a+b; }

ઉદાહરણ:

#include <stdio.h>

// ફંક્શન ઘોષણા
int sum(int a, int b);

int main() {
    int num1 = 10, num2 = 20, result;
    
    // ફંક્શન કોલ
    result = sum(num1, num2);
    
    printf("Sum = %d\n", result);
    
    return 0;
}

// ફંક્શન વ્યાખ્યા
int sum(int a, int b) {
    return a + b;
}

ફંક્શન ફ્લો:

flowchart TD
    A[main function] -->|Call sum(10, 20)| B[sum function]
    B -->|Return 30| A
    B -->|a = 10, b = 20| C[return a + b]

મ્નેમોનિક: “DPCR: Declaration-Parameters-Call-Return”

પ્રશ્ન 5(c) OR [7 ગુણ]
#

એરેમાંથી મહત્તમ અને લઘુત્તમ element શોધવા માટે C પ્રોગ્રામનો લખો.

જવાબ:

#include <stdio.h>

int main() {
    int arr[100], n, i;
    int max, min;
    
    printf("Enter number of elements: ");
    scanf("%d", &n);
    
    printf("Enter %d integers: ", n);
    for(i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }
    
    // max અને min પ્રથમ તત્વ સાથે પ્રારંભિક કરો
    max = min = arr[0];
    
    // max અને min શોધો
    for(i = 1; i < n; i++) {
        if(arr[i] > max) {
            max = arr[i];
        }
        if(arr[i] < min) {
            min = arr[i];
        }
    }
    
    printf("Maximum element: %d\n", max);
    printf("Minimum element: %d\n", min);
    
    return 0;
    }

અલ્ગોરિધમ:

  1. એરે સાઇઝ અને તત્વો ઇનપુટ કરો
  2. max અને min ને પ્રથમ તત્વ સાથે પ્રારંભિક કરો
  3. દરેક બાકીના તત્વ માટે:
    • જો તત્વ > max, max અપડેટ કરો
    • જો તત્વ < min, min અપડેટ કરો
  4. max અને min ને દર્શાવો

ફ્લોચાર્ટ:

flowchart TD
    A([Start]) --> B[/Input n/]
    B --> C[/Input array elements/]
    C --> D[max = min = arr[0]]
    D --> E[i = 1]
    E --> F{i < n?}
    F -->|Yes| G{arr[i] > max?}
    G -->|Yes| H[max = arr[i]]
    G -->|No| I{arr[i] < min?}
    H --> I
    I -->|Yes| J[min = arr[i]]
    I -->|No| K[i++]
    J --> K
    K --> F
    F -->|No| L[/Display max, min/]
    L --> M([End])

મ્નેમોનિક: “FILLS: First Initialize, Loop through, Look for Small/large”

સંબંધિત

ઇલેક્ટ્રોનિક કોમ્યુનિકેશનના સિદ્ધાંતો (4331104) - વિન્ટર 2023 સોલ્યુશન
20 મિનિટ
Study-Material Solutions Electronic-Communication 4331104 2023 Winter
ઇલેક્ટ્રોનિક સર્કિટ્સ અને નેટવર્ક્સ (4331101) - શિયાળો 2023 સોલ્યુશન
15 મિનિટ
Study-Material Solutions Electronic-Circuits Networks 4331101 2023 Winter
ઇલેક્ટ્રોનિક કોમ્યુનિકેશનના સિદ્ધાંતો (4331104) - શિયાળો 2022 સોલ્યુશન
20 મિનિટ
Study-Material Solutions Electronic-Communication 4331104 2022 Winter
ઇલેક્ટ્રોનિક કમ્યુનિકેશનના સિદ્ધાંતો (4331104) - ગ્રીષ્મ 2023 સોલ્યુશન
23 મિનિટ
Study-Material Solutions Electronic-Communication 4331104 2023 Summer
ઇલેક્ટ્રોનિક મેઝરમેન્ટ્સ એન્ડ ઇન્સ્ટ્રુમેન્ટ્સ (4331102) - સમર 2023 સોલ્યુશન
24 મિનિટ
Study-Material Solutions Electronic-Measurements 4331102 2023 Summer
પાયથોન પ્રોગ્રામિંગ (1323203) - શિયાળુ 2023 સોલ્યુશન
22 મિનિટ
Study-Material Solutions Python-Programming 1323203 2023 Winter