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

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

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

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

C લેંગ્વેજના બેઝીક ડેટા ટાઈપ તેની રેંજ સાથે લખો

જવાબ:

ડેટા ટાઈપસાઈઝ (બાઈટ્સ)રેંજ
char1-128 થી 127
int2 અથવા 4-32,768 થી 32,767 (2 બાઈટ્સ) અથવા -2,147,483,648 થી 2,147,483,647 (4 બાઈટ્સ)
float43.4E-38 થી 3.4E+38
double81.7E-308 થી 1.7E+308

યાદ રાખવાની યુક્તિ: “CIFD - Computer Is Fundamentally Digital”

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

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

જવાબ:

નિયમઉદાહરણ
અક્ષર અથવા અંડરસ્કોરથી શરૂ થવું જોઈએમાન્ય: _count, name / અમાન્ય: 1score
અક્ષરો, અંકો, અંડરસ્કોર ધરાવી શકેમાન્ય: user_1 / અમાન્ય: user-1
કીવર્ડ્સનો ઉપયોગ ન થઈ શકેમાન્ય: integer / અમાન્ય: int
કેસ સેન્સિટિવtotal અને TOTAL અલગ છે

આકૃતિ:

V[aAr-iZa,blae-zN,am_i]ngR[uAl-eZs,a-z,0-9,_]*

યાદ રાખવાની યુક્તિ: “LUCK - Letters Underscore Case Keywords”

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

ફ્લોચાર્ટની વ્યાખ્યા લખો. બે પૂર્ણાંક નંબર 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[/Output min/]
    E --> F
    F --> G([End])
  • ફ્લોચાર્ટ સિમ્બોલ્સ: તાર્કિક પગલાંઓની દૃશ્ય રજૂઆત
  • નિર્ણય ડાયમંડ: શરત તપાસીને વહેણ પથ નક્કી કરે છે
  • પ્રોસેસ બોક્સેસ: ગણતરી અથવા ઓપરેશન્સ ધરાવે છે

યાદ રાખવાની યુક્તિ: “FAST - Flow Analysis Shown Through-charts”

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

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

જવાબ:

અલગોરિધમ એ કોઈ ચોક્કસ સમસ્યાને ઉકેલવા માટેની સ્પષ્ટ રીતે વ્યાખ્યાયિત સૂચનાઓની પરિમિત ક્રમમાં પગલે-પગલાની પ્રક્રિયા છે.

વર્તુળની ગણતરી માટેનો અલગોરિધમ:

1. START
2. Input radius r
3. Calculate area = π * r * r
4. Calculate circumference = 2 * π * r
5. Output area, circumference
6. STOP
પગલુંઓપરેશનફોર્મ્યુલા
1ત્રિજ્યા મેળવોInput r
2ક્ષેત્રફળની ગણતરીA = π × r²
3પરિઘની ગણતરીC = 2 × π × r
4પરિણામ દર્શાવોOutput A, C

યાદ રાખવાની યુક્તિ: “SICS - Steps In Clear Sequence”

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

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

જવાબ:

ફીચરprintf()scanf()
ઉદ્દેશસ્ક્રીન પર ડેટા આઉટપુટ કરે છેકીબોર્ડથી ડેટા ઇનપુટ લે છે
ફોર્મેટprintf(“format”, variables)scanf(“format”, &variables)
રિટર્નછાપેલા અક્ષરોની સંખ્યાસફળતાપૂર્વક વાંચેલી આઇટમોની સંખ્યા
એડ્રેસિંગવેરિએબલ્સના નામનો ઉપયોગ કરે છેવેરિએબલ્સના એડ્રેસનો ઉપયોગ કરે છે (&var)

યાદ રાખવાની યુક્તિ: “IO-AR - Input Output-Address Returns”

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

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

જવાબ:

#include <stdio.h>

int main() {
    int num1, num2, max;
    
    printf("Enter two numbers: ");
    scanf("%d %d", &num1, &num2);
    
    max = (num1 > num2) ? num1 : num2;
    
    printf("Maximum number is: %d", max);
    
    return 0;
}

આકૃતિ:

Innupmu1t,num2>Cnounmd1it>ionnum2?>Omuatxput

યાદ રાખવાની યુક્તિ: “CTO - Condition Then Output”

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

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

જવાબ:

પ્રકારઓપરેટર્સઉદાહરણપરિણામ
એરીથમેટીક ઓપરેટર્સ
સરવાળો+5 + 38
બાદબાકી-5 - 32
ગુણાકાર*5 * 315
ભાગાકાર/5 / 31 (પૂર્ણાંક ભાગાકાર)
મોડ્યુલસ%5 % 32 (શેષ)
રીલેશનલ ઓપરેટર્સ
સમાન==5 == 30 (ખોટું)
અસમાન!=5 != 31 (સાચું)
મોટું>5 > 31 (સાચું)
નાનું<5 < 30 (ખોટું)
મોટું અથવા સમાન>=5 >= 51 (સાચું)
નાનું અથવા સમાન<=5 <= 30 (ખોટું)

યાદ રાખવાની યુક્તિ: “ASMDCRO - Add Subtract Multiply Divide Compare Return Output”

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

જો (25/3) * 4 – 10 % 3 + 9/2 સમીકરણને ઉકેલવામાં આવે તો ઓપરેટરોની અગ્રીમતાને ધ્યાને લઇ દરેક સ્ટેપ અને અંતિમ જવાબ લખો.

જવાબ:

પગલુંઓપરેશનગણતરીપરિણામ
1કૌંસ (25/3)25/3 = 8 (પૂર્ણાંક ભાગાકાર)8
2મોડ્યુલસ 10 % 310 % 3 = 11
3ભાગાકાર 9/29/2 = 4 (પૂર્ણાંક ભાગાકાર)4
4ગુણાકાર 8 * 48 * 4 = 3232
5બાદબાકી 32 - 132 - 1 = 3131
6સરવાળો 31 + 431 + 4 = 3535

અંતિમ જવાબ = 35

યાદ રાખવાની યુક્તિ: “PEMDAS - Parentheses, Exponents, Multiplication/Division, Addition/Subtraction”

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

એલ્જેબ્રીક સમીકરણના ઉકેલ માટેનો C પ્રોગ્રામ લખો.

જવાબ:

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

int main() {
    float a, b, c;
    float discriminant, root1, root2;
    
    printf("Enter coefficients a, b, c: ");
    scanf("%f %f %f", &a, &b, &c);
    
    discriminant = b*b - 4*a*c;
    
    if (discriminant > 0) {
        root1 = (-b + sqrt(discriminant)) / (2*a);
        root2 = (-b - sqrt(discriminant)) / (2*a);
        printf("Roots: %.2f and %.2f", root1, root2);
    } else if (discriminant == 0) {
        root1 = -b / (2*a);
        printf("Root: %.2f", root1);
    } else {
        printf("No real roots");
    }
    
    return 0;
}

આકૃતિ:

flowchart TD
    A[Input a,b,c] --> B[Calculate d = b²-4ac]
    B --> C{d > 0?}
    C -->|Yes| D[Two real roots]
    C -->|No| E{d = 0?}
    E -->|Yes| F[One real root]
    E -->|No| G[No real roots]

યાદ રાખવાની યુક્તિ: “QDR - Quadratic Discriminant Roots”

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

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

જવાબ:

પ્રકારઓપરેટર્સઉદાહરણપરિણામ
લોજીકલ ઓપરેટર્સ
લોજીકલ AND&&(5>3) && (4<7)1 (સાચું)
લોજીકલ OR||(5<3) || (4<7)1 (સાચું)
લોજીકલ NOT!!(5>3)0 (ખોટું)
બિટવાઈઝ ઓપરેટર્સ
બિટવાઈઝ AND&5 & 3 (101 & 011)1 (001)
બિટવાઈઝ OR|5 | 3 (101 | 011)7 (111)
બિટવાઈઝ XOR^5 ^ 3 (101 ^ 011)6 (110)
બિટવાઈઝ NOT~5 ( 00000101)-6 (11111010)
લેફ્ટ શિફ્ટ«5 « 1 (101 « 1)10 (1010)
રાઈટ શિફ્ટ»5 » 1 (101 » 1)2 (10)

યાદ રાખવાની યુક્તિ: “LAND BORNS - Logical AND OR NOT, Bitwise OR AND NOT Shift”

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

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

જવાબ:

goto સ્ટેટમેન્ટ પ્રોગ્રામમાં લેબલ કરેલા સ્ટેટમેન્ટ પર બિનશરતી જમ્પની મંજૂરી આપે છે.

#include <stdio.h>

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

આકૃતિ:

gpior+ti+onStist(Etai<nar)drt5Nt?oYes

યાદ રાખવાની યુક્તિ: “JUMP - Just Unconditionally Move Program-counter”

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

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

જવાબ:

#include <stdio.h>

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

આકૃતિ:

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

યાદ રાખવાની યુક્તિ: “MODE - Modulo Odd-Even Determination”

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

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

જવાબ:

else-if લેડર કધામ શરતોને ક્રમમાં ચકાસવાની મંજૂરી આપે છે, પ્રથમ સાચી શરત સાથે જોડાયેલા બ્લોકને એક્ઝીક્યુટ કરે છે.

flowchart TD
    A([Start]) --> B[/Input marks/]
    B --> C{marks >= 90?}
    C -->|Yes| D[grade = A]
    C -->|No| E{marks >= 80?}
    E -->|Yes| F[grade = B]
    E -->|No| G{marks >= 70?}
    G -->|Yes| H[grade = C]
    G -->|No| I{marks >= 60?}
    I -->|Yes| J[grade = D]
    I -->|No| K[grade = F]
    D & F & H & J & K --> L[/Output grade/]
    L --> M([End])
#include <stdio.h>

int main() {
    int marks;
    char grade;
    
    printf("Enter marks: ");
    scanf("%d", &marks);
    
    if (marks >= 90)
        grade = 'A';
    else if (marks >= 80)
        grade = 'B';
    else if (marks >= 70)
        grade = 'C';
    else if (marks >= 60)
        grade = 'D';
    else
        grade = 'F';
        
    printf("Grade: %c", grade);
    
    return 0;
}
  • એકાધિક શરતો: ક્રમાનુસાર શરતો તપાસે છે
  • પ્રથમ મિલાન: માત્ર પ્રથમ સાચી શરત માટે કોડ એક્ઝિક્યુટ કરે છે
  • ડિફોલ્ટ કેસ: છેલ્લો else બાકીના બધા કેસને સંભાળે છે

યાદ રાખવાની યુક્તિ: “CAFE - Condition Assess First Eligible”

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

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

જવાબ:

સ્ટેટમેન્ટહેતુઅસર
breakલૂપ અથવા સ્વિચમાંથી બહાર નીકળવુંતરત જ સમગ્ર લૂપ છોડી દે છે
continueવર્તમાન પુનરાવર્તન છોડવુંલૂપના આગલા પુનરાવર્તન પર જાય છે
// break ઉદાહરણ
for(int i=1; i<=10; i++) {
    if(i == 6)
        break;      // i=6 થાય ત્યારે લૂપમાંથી બહાર નીકળે છે
    printf("%d ", i); // આઉટપુટ: 1 2 3 4 5
}

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

આકૃતિ:

EbLxroieotap123kLoopbreakItcNeoLernoxatottip123inounecontinue

યાદ રાખવાની યુક્તિ: “BEST - Break Exits, Skip with conTinue”

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

૧ થી ૧૦ નંબરનો સરવાળો પ્રિન્ટ કરવા માટેનો C પ્રોગ્રામ ફોર લૂપનો ઉપયોગ કરીને લખો.

જવાબ:

#include <stdio.h>

int main() {
    int i, sum = 0;
    
    for(i = 1; i <= 10; i++) {
        sum += i;
    }
    
    printf("Sum of numbers from 1 to 10: %d", sum);
    
    return 0;
}

આકૃતિ:

flowchart TD
    A([Start]) --> B[sum = 0]
    B --> C[i = 1]
    C --> D{i <= 10?}
    D -->|Yes| E[sum = sum + i]
    E --> F[i++]
    F --> D
    D -->|No| G[/Print sum/]
    G --> H([End])

યાદ રાખવાની યુક્તિ: “SILA - Sum Increment Loop Add”

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

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

જવાબ:

સ્વિચ સ્ટેટમેન્ટ વેરિએબલની વેલ્યુના આધારે એકાધિક વિકલ્પોમાંથી એક કોડ બ્લોક પસંદ કરે છે.

flowchart TD
    A([Start]) --> B[/Input choice/]
    B --> C{switch choice}
    C -->|case 1| D[/Print Addition/]
    C -->|case 2| E[/Print Subtraction/]
    C -->|case 3| F[/Print Multiplication/]
    C -->|case 4| G[/Print Division/]
    C -->|default| H[/Print Invalid/]
    D & E & F & G & H --> I([End])
#include <stdio.h>

int main() {
    int choice;
    
    printf("Enter operation (1-4): ");
    scanf("%d", &choice);
    
    switch(choice) {
        case 1:
            printf("Addition selected");
            break;
        case 2:
            printf("Subtraction selected");
            break;
        case 3:
            printf("Multiplication selected");
            break;
        case 4:
            printf("Division selected");
            break;
        default:
            printf("Invalid choice");
    }
    
    return 0;
}
  • એક્સપ્રેશન: ઇન્ટિજર અથવા કેરેક્ટર એક્સપ્રેશન લે છે
  • કેસ લેબલ્સ: કોન્સ્ટન્ટ એક્સપ્રેશન હોવા જોઈએ
  • બ્રેક સ્ટેટમેન્ટ: આગલા કેસમાં પ્રવેશ થતો અટકાવે છે
  • ડિફોલ્ટ: કોઈપણ કેસ મેચ ન થાય તો હેન્ડલ કરે છે

યાદ રાખવાની યુક્તિ: “SCBD - Switch Cases Break Default”

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

મોટા કેપિટલ મૂળાક્ષરોને નાના મૂળાક્ષરોમાં રૂપાંતર કરવા માટેનો C પ્રોગ્રામ લખો.

જવાબ:

#include <stdio.h>

int main() {
    char upper, lower;
    
    printf("Enter uppercase letter: ");
    scanf("%c", &upper);
    
    lower = upper + 32;
    // વૈકલ્પિક: lower = tolower(upper);
    
    printf("Lowercase letter: %c", lower);
    
    return 0;
}

આકૃતિ:

IAAOnSSupCCtuIIptI6I9u57t'ccAo+o''d3dae2e'

યાદ રાખવાની યુક્તિ: “ASCII-32 - Add 32 to Shift Characters Into Lowercase”

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

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

જવાબ:

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

કોન્સેપ્ટસિન્ટેક્સવિગત
ડેક્લેરેશનint *p;ઇન્ટ પ્રકારનો પોઇન્ટર p ડિક્લેર કરે છે
ઇનિશિયલાઇઝેશનp = &var;var નું એડ્રેસ p માં સ્ટોર કરે છે
ડિરેફરન્સિંગ*p = 10;પોઇન્ટ થયેલી વેલ્યુને એક્સેસ/મોડિફાય કરે છે
પોઇન્ટર એરિથમેટિકp++આગલા મેમરી લોકેશન પર જાય છે
#include <stdio.h>

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

આકૃતિ:

Memoryn(:u1m0)1000(*1p0t0r0)2000

યાદ રાખવાની યુક્તિ: “SAID - Store Address to Indirectly Dereference”

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

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

જવાબ:

ફોર લૂપનો ઉપયોગ કોડના બ્લોકને નિર્દિષ્ટ સંખ્યામાં વાર રિપીટ કરવા માટે થાય છે.

flowchart TD
    A([Start]) --> B[Initialization: i=1]
    B --> C{Condition: i<=5?}
    C -->|True| D[Body: Print i]
    D --> E[Update: i++]
    E --> C
    C -->|False| F([End])
#include <stdio.h>

int main() {
    int i;
    
    // સિન્ટેક્સ: for(initialization; condition; update)
    for(i = 1; i <= 5; i++) {
        printf("%d ", i);
    }
    // આઉટપુટ: 1 2 3 4 5
    
    return 0;
}
  • ઇનિશિયલાઇઝેશન: લૂપ શરૂ થતાં પહેલાં એક વાર એક્ઝિક્યુટ થાય છે
  • કન્ડિશન: દરેક પુનરાવર્તન પહેલાં ચેક થાય છે
  • અપડેટ: દરેક પુનરાવર્તન પછી એક્ઝિક્યુટ થાય છે
  • બોડી: કોડ બ્લોક જે રિપીટ થાય છે

યાદ રાખવાની યુક્તિ: “ICU-B - Initialize, Check, Update, Body”

પ્રશ્ન 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", 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])

યાદ રાખવાની યુક્તિ: “BHA - Base times Height divided by two equals Area”

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

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

જવાબ:

ઓપરેશનસિન્ટેક્સઉદાહરણવિગત
ડેક્લેરેશનdatatype *pointer_name;int *ptr;પોઇન્ટર વેરિએબલ બનાવે છે
ઇનિશિયલાઇઝેશનpointer_name = &variable;ptr = &num;પોઇન્ટરને એડ્રેસ સોંપે છે
કોમ્બાઇન્ડdatatype *pointer_name = &variable;int *ptr = &num;ડેક્લેરેશન સાથે ઇનિશિયલાઇઝેશન
NULL પોઇન્ટરpointer_name = NULL;ptr = NULL;જ્યારે એડ્રેસ ઉપલબ્ધ ન હોય ત્યારે સુરક્ષિત ઇનિશિયલાઇઝેશન
#include <stdio.h>

int main() {
    int num = 10;           // સામાન્ય વેરિએબલ
    int *ptr1;              // માત્ર ડેક્લેરેશન
    int *ptr2 = &num;       // ડેક્લેરેશન સાથે ઇનિશિયલાઇઝેશન
    
    ptr1 = &num;            // ptr1 નું ઇનિશિયલાઇઝેશન
    
    printf("num value: %d\n", num);
    printf("num address: %p\n", &num);
    printf("ptr1 value: %p\n", ptr1);
    printf("ptr2 value: %p\n", ptr2);
    printf("Value via ptr1: %d\n", *ptr1);
    printf("Value via ptr2: %d\n", *ptr2);
    
    return 0;
}

આકૃતિ:

PPooiiipnnnttttreer*r=pDtI&ernnc;iultmai;raaltiizoant:ion:num(10)

યાદ રાખવાની યુક્તિ: “PAIN - Pointer Allocate, Initialize, Navigate”

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

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

જવાબ:

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

flowchart TD
    A([Start]) --> B[i = 1]
    B --> C{i <= 5?}
    C -->|True| D[/Print i/]
    D --> E[i++]
    E --> C
    C -->|False| F([End])
#include <stdio.h>

int main() {
    int i = 1;
    
    // સિન્ટેક્સ: while(condition) { body }
    while(i <= 5) {
        printf("%d ", i);
        i++;
    }
    // આઉટપુટ: 1 2 3 4 5
    
    return 0;
}
  • ઇનિશિયલાઇઝેશન: લૂપ પહેલાં કરવું જરૂરી છે
  • કન્ડિશન: દરેક પુનરાવર્તનની શરૂઆતમાં મૂલ્યાંકન થાય છે
  • બોડી: માત્ર જો શરત સાચી હોય તો જ એક્ઝિક્યુટ થાય છે
  • અપડેટ: લૂપ બોડીની અંદર હોવું જોઈએ

યાદ રાખવાની યુક્તિ: “CUBE - Condition check, Update inside Body, Exit when false”

પ્રશ્ન 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[50];
    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.50;
    
    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", book1.book_price);
    
    return 0;
}

આકૃતિ:

strbbbbuoooocooootkkkk____Bntapooiurottiklhceoer((((iccfnhhltaao)rra[[t55)00]]))

યાદ રાખવાની યુક્તિ: “SNAP - Structure Needs All Properties”

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

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

જવાબ:

ફંક્શનલાઇબ્રેરીહેતુઉદાહરણ
sqrt()math.hવર્ગમૂળ ગણે છેsqrt(16) આઉટપુટ 4.0
pow()math.hપાવર ગણે છેpow(2, 3) આઉટપુટ 8.0
strlen()string.hસ્ટ્રિંગની લંબાઈ શોધે છેstrlen("hello") આઉટપુટ 5
strcpy()string.hસ્ટ્રિંગની કોપી કરે છેstrcpy(dest, "hello") dest માં “hello” કોપી કરે છે
#include <stdio.h>
#include <math.h>
#include <string.h>

int main() {
    double sqrtResult = sqrt(25);
    double powResult = pow(2, 4);
    char str[] = "Programming";
    char dest[20];
    int length = strlen(str);
    
    strcpy(dest, str);
    
    printf("sqrt(25) = %.2f\n", sqrtResult);
    printf("pow(2, 4) = %.2f\n", powResult);
    printf("Length of '%s' = %d\n", str, length);
    printf("Copied string: %s\n", dest);
    
    return 0;
}

યાદ રાખવાની યુક્તિ: “SPSS - Square-root Power String-length String-copy”

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

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

જવાબ:

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

પદ્ધતિસિન્ટેક્સઉદાહરણ
ડેક્લેરેશનdata_type array_name[size];int marks[5];
ડેક્લેરેશન સમયે ઇનિશિયલાઇઝેશનdata_type array_name[size] = {values};int marks[5] = {95, 80, 85, 75, 90};
વ્યક્તિગત એલિમેન્ટarray_name[index] = value;marks[0] = 95;
આંશિક ઇનિશિયલાઇઝેશનint arr[5] = {1, 2};બાકીના એલિમેન્ટ્સ 0 હોય છે
સાઇઝ વગરint arr[] = {1, 2, 3};સાઇઝ એલિમેન્ટ્સ દ્વારા નક્કી થાય છે
#include <stdio.h>

int main() {
    // એરે ડેક્લેરેશન અને ઇનિશિયલાઇઝેશન
    int numbers[5] = {10, 20, 30, 40, 50};
    
    // એરે એલિમેન્ટ્સ એક્સેસ કરવા
    printf("First element: %d\n", numbers[0]);
    printf("Third element: %d\n", numbers[2]);
    
    // એરે એલિમેન્ટ બદલવી
    numbers[1] = 25;
    
    // બધા એલિમેન્ટ્સ પ્રિન્ટ કરવા
    printf("Array elements: ");
    for(int i = 0; i < 5; i++) {
        printf("%d ", numbers[i]);
    }
    
    return 0;
}

આકૃતિ:

Arr1a00yin201memo3r02y:403504indices

યાદ રાખવાની યુક્તિ: “CASED - Contiguous Arrangement of Similar Elements with Direct-access”

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

એરે અને સ્ટ્રક્ચર નો તફાવત લખો.

જવાબ:

ફીચરએરેસ્ટ્રક્ચર
ડેટા ટાઈપ્સમાત્ર એક જ ડેટા ટાઈપઅલગ અલગ ડેટા ટાઈપ્સ મંજૂર
એક્સેસઇન્ડેક્સ દ્વારા: arr[0]ડોટ ઓપરેટર દ્વારા: emp.id
મેમરીસતત ફાળવણીસતત ન પણ હોઈ શકે
સાઇઝડેક્લેરેશન સમયે ફિક્સ્ડસભ્યોના સાઇઝનો સરવાળો
ઇનિશિયલાઇઝેશનint arr[3] = {1,2,3};struct emp e = {101,"John",5000};
હેતુસમાન આઇટમ્સનો સંગ્રહસંબંધિત આઇટમ્સનો સંગ્રહ

આકૃતિ:

Arr1ianyt:2int3intStrinsiudaanc:mltteau1:rr0yce1":h:Jao5rh0[n0]"0.0float

યાદ રાખવાની યુક્તિ: “HASDIP - Homogeneous vs. Assorted, Same vs. Different, Index vs. Point”

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

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

જવાબ:

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

કોમ્પોનન્ટવિગતઉદાહરણ
રિટર્ન ટાઇપફંક્શન દ્વારા પરત કરવામાં આવતા ડેટાનો પ્રકારint, void, વગેરે
ફંક્શન નામફંક્શન માટેનું આઇડેન્ટિફાયરsum, findMax
પેરામીટર્સકૌંસમાં ઇનપુટ વેલ્યુઝ(int a, int b)
ફંક્શન બોડીકર્લી બ્રેસિસ અંદરનો કોડ{ return a+b; }
#include <stdio.h>

// ફંક્શન ડેક્લેરેશન
int sum(int a, int b);

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

// ફંક્શન ડેફિનિશન
int sum(int a, int b) {
    return a + b;
}

આકૃતિ:

flowchart TD
    A[Main function] -->|Call with arguments| B[User-defined function]
    B -->|Return result| A

યાદ રાખવાની યુક્તિ: “CRPB - Create, Return, Pass, Body”

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

એરેના ઘટકોનો સરવાળો અને સરેરાશ શોધવા માટેનો C પ્રોગ્રામ લખો.

જવાબ:

#include <stdio.h>

int main() {
    int arr[100], n, i;
    int sum = 0;
    float avg;
    
    printf("Enter number of elements: ");
    scanf("%d", &n);
    
    printf("Enter %d elements:\n", n);
    for(i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
        sum += arr[i];  // દરેક એલિમેન્ટને સરવાળામાં ઉમેરો
    }
    
    avg = (float)sum / n;  // સરેરાશની ગણતરી
    
    printf("Sum of array elements: %d\n", sum);
    printf("Average of array elements: %.2f", avg);
    
    return 0;
}

આકૃતિ:

flowchart TD
    A([Start]) --> B[/Input size n/]
    B --> C[/Input n elements/]
    C --> D[sum = 0]
    D --> E[i = 0]
    E --> F{i < n?}
    F -->|Yes| G[sum += arr[i]]
    G --> H[i++]
    H --> F
    F -->|No| I[avg = sum / n]
    I --> J[/Output sum, avg/]
    J --> K([End])

પગલુંઓપરેશનઉદાહરણ (એરે [5,10,15,20] માટે)
1ઇનપુટ એરે[5,10,15,20]
2sum = 0 ઇનિશિયલાઇઝsum = 0
3દરેક એલિમેન્ટ ઉમેરોsum = 0+5+10+15+20 = 50
4સંખ્યા વડે વિભાજીત કરોavg = 50/4 = 12.5

યાદ રાખવાની યુક્તિ: “LISA - Loop, Increment, Sum, Average”

સંબંધિત

ઇલેક્ટ્રોનિક સર્કિટ્સ એન્ડ નેટવર્ક્સ (4331101) - વિન્ટર 2022 સોલ્યુશન
18 મિનિટ
Study-Material Solutions Electronic-Circuits Networks 4331101 2022 Winter
ડિજિટલ ઇલેક્ટ્રોનિક્સ (4321102) - શિયાળો 2023 સોલ્યુશન
15 મિનિટ
Study-Material Solutions Digital-Electronics 4321102 2023 Winter
ફંડામેંટલ્સ ઓફ ઇલેક્ટ્રોનિક્સ (4311102) - વિન્ટર 2023 સોલ્યુશન
20 મિનિટ
Study-Material Solutions Electronics 4311102 2023 Winter
ઇલેક્ટ્રોનિક સર્કિટ્સ એન્ડ એપ્લિકેશન્સ (4321103) - વિન્ટર 2023 સોલ્યુશન
16 મિનિટ
Study-Material Solutions Electronics 4321103 2023 Winter
ઇલેક્ટ્રોનિક કોમ્યુનિકેશનના સિદ્ધાંતો (4331104) - શિયાળો 2022 સોલ્યુશન
20 મિનિટ
Study-Material Solutions Electronic-Communication 4331104 2022 Winter
ઔદ્યોગિક ઇલેક્ટ્રોનિક્સ (4331103) - શિયાળુ 2022 સોલ્યુશન
18 મિનિટ
અભ્યાસ-સામગ્રી સોલ્યુશન ઔદ્યોગિક-ઇલેક્ટ્રોનિક્સ 4331103 2022 શિયાળુ