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

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

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

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

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

જવાબ:

કોષ્ટક: C લેંગ્વેજના છ કીવર્ડ

કીવર્ડઉપયોગ
intપૂર્ણાંક ડેટા પ્રકાર
floatઅપૂર્ણાંક ડેટા પ્રકાર
ifશરતી નિવેદન
whileલૂપ સ્ટ્રક્ચર
returnફંક્શનમાંથી મૂલ્ય પાછું મેળવવા માટે
voidખાલી રિટર્ન પ્રકાર દર્શાવવા

યાદ રાખવાની રીત: “I Feel When Running Very Ill” (int, float, while, return, void, if)

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

વેરિયેબલની વ્યાખ્યા લખો. C પ્રોગ્રામિંગમાં વેરિયેબલના નામ માટેના નિયમો લખો.

જવાબ:

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

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

નિયમઉદાહરણ
અક્ષર/અંડરસ્કોરથી શરૂ થવું જોઈએname, _value
અક્ષરો, અંકો, અંડરસ્કોર સમાવી શકેuser_1, count99
ખાલી જગ્યા કે વિશેષ અક્ષરો ન હોવા જોઈએ✓: total_sum, ✗: total-sum
કેસ સેન્સિટિવ છેName ≠ name
રિઝર્વ કીવર્ડ્સનો ઉપયોગ ન કરી શકાય✗: int, while
મહત્તમ 31 અક્ષરો (સ્ટાન્ડર્ડ)studentRegistrationNumber

યાદ રાખવાની રીત: “Letters Lead, No Special Keys” (અક્ષરથી શરૂ, વિશેષ અક્ષરો નહીં, કીવર્ડ્સ નહીં)

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

ફ્લોચાર્ટની વ્યાખ્યા લખો. ફ્લોચાર્ટના સિમ્બોલ દોરો અને સમજાવો. નીચેના સમીકરણનો ઉપયોગ કરીને સિમ્પલ ઇન્ટરેસ્ટની ગણતરી કરવા માટેનો પ્રોગ્રામ લખો. I=PRN/100 જ્યાં P=પ્રિન્સીપલ રકમ, R= વ્યાજનો દર અને N= સમયગાળો.

જવાબ:

ફ્લોચાર્ટ: એક પ્રશ્નનો ઉકેલ કરવા માટે જરૂરી ક્રમિક ઓપરેશન્સને દર્શાવવા માટે પ્રમાણભૂત પ્રતીકોનો ઉપયોગ કરીને અલ્ગોરિધમની ગ્રાફિકલ રજૂઆત.

કોષ્ટક: ફ્લોચાર્ટ સિમ્બોલ

સિમ્બોલનામઉપયોગ
Oval
ટર્મિનલશરૂઆત/અંત
Rectangle
પ્રોસેસગણતરી
Parallelogram
ઈનપુટ/આઉટપુટડેટા વાંચવો/દર્શાવવો
Diamond
નિર્ણયશરતો
Arrow
ફ્લો લાઈનક્રમ બતાવે છે

સિમ્પલ ઇન્ટરેસ્ટનું ફ્લોચાર્ટ:

flowchart TD
    A([Start]) --> B[/Input P, R, N/]
    B --> C[Calculate I = P*R*N/100]
    C --> D[/Display I/]
    D --> E([End])

પ્રોગ્રામ:

#include <stdio.h>
void main()
{
    float p, r, n, i;
    
    printf("Enter principal amount: ");
    scanf("%f", &p);
    
    printf("Enter rate of interest: ");
    scanf("%f", &r);
    
    printf("Enter time period in years: ");
    scanf("%f", &n);
    
    i = (p * r * n) / 100;
    
    printf("Simple Interest = %.2f", i);
}

યાદ રાખવાની રીત: “Please Return Nice Interest” (Principal, Rate, Number of years, Interest)

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

અલગોરિધમની વ્યાખ્યા લખો. સિલિન્ડરનું ઘનફળ શોધવા માટેનું અલગોરિધમ લખો. યુઝર પાસેથી સિલિન્ડરની ત્રિજ્યા(R) અને ઊંચાઈ(H) ઈનપુટ લઇ સિલિન્ડરના વોલ્યુમ(V)ની ગણતરી નીચેના સમીકરણનો ઉપયોગ કરીને પ્રિન્ટ કરવા માટેનો પ્રોગ્રામ લખો. V=πR²H

જવાબ:

અલગોરિધમ: મર્યાદિત સમયમાં કોઈ સમસ્યાનો ઉકેલ કરવા માટેની પગલાવાર પ્રક્રિયા.

સિલિન્ડરના ઘનફળ માટેનું અલગોરિધમ:

  1. શરૂ કરો
  2. ત્રિજ્યા (R) અને ઊંચાઈ (H) ઇનપુટ લો
  3. V = π × R² × H સૂત્રનો ઉપયોગ કરીને ઘનફળની ગણતરી કરો
  4. ઘનફળ પ્રદર્શિત કરો
  5. સમાપ્ત

ડાયગ્રામ: સિલિન્ડર

RH

પ્રોગ્રામ:

#include <stdio.h>
void main()
{
    float radius, height, volume;
    float pi = 3.14159;
    
    printf("Enter radius of cylinder: ");
    scanf("%f", &radius);
    
    printf("Enter height of cylinder: ");
    scanf("%f", &height);
    
    volume = pi * radius * radius * height;
    
    printf("Volume of cylinder = %.2f", volume);
}

યાદ રાખવાની રીત: “Round Hat Volume” (Radius, Height, Volume)

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

C પ્રોગ્રામિંગ ભાષામાં સપોર્ટ કરતા વિવિધ ઓપરેટરોની યાદી બનાવો.

જવાબ:

કોષ્ટક: C પ્રોગ્રામિંગમાં ઓપરેટર્સ

ઓપરેટર પ્રકારઉદાહરણોઉપયોગ
એરિથમેટિક+, -, *, /, %ગાણિતિક ઓપરેશન્સ
રિલેશનલ<, >, ==, !=, <=, >=મૂલ્યોની સરખામણી
લોજીકલ&&, ||, !શરતોને જોડવા
એસાઇનમેન્ટ=, +=, -=, *=, /=મૂલ્યો આપવા
ઇનક્રિમેન્ટ/ડિક્રિમેન્ટ++, –1 વધારવું/ઘટાડવું
બિટવાઇઝ&, |, ^, ~, «, »બિટ મેનિપ્યુલેશન
કન્ડિશનલ?:ટૂંકા if-else

યાદ રાખવાની રીત: “All Relationships Lead Ancestors Incrementally Beyond Conditions” (દરેક પ્રકારનો પ્રથમ અક્ષર)

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

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

જવાબ:

પ્રોગ્રામ:

#include <stdio.h>
void main()
{
    int i, sum = 0;
    float avg;
    
    for(i = 1; i <= 50; i++)
    {
        sum = sum + i;
    }
    
    avg = (float)sum / 50;
    
    printf("Sum of numbers from 1 to 50 = %d\n", sum);
    printf("Average of numbers from 1 to 50 = %.2f", avg);
}

પ્રક્રિયા ડાયગ્રામ:

flowchart TD
    A([Start]) --> B[Set sum = 0]
    B --> C[Loop i from 1 to 50]
    C --> D[Add i to sum]
    D --> E{i < 50?}
    E -->|Yes| C
    E -->|No| F[Calculate avg = sum/50]
    F --> G[/Display sum and avg/]
    G --> H([End])

યાદ રાખવાની રીત: “Summing And Dividing” (Sum, Average, Division)

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

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

જવાબ:

એરિથમેટિક ઓપરેટર્સ:

કોષ્ટક: C માં એરિથમેટિક ઓપરેટર

ઓપરેટરઓપરેશનઉદાહરણપરિણામ
+સરવાળો5 + 38
-બાદબાકી7 - 25
*ગુણાકાર4 * 312
/ભાગાકાર8 / 42
%મોડ્યુલસ (બાકી)7 % 31

રિલેશનલ ઓપરેટર્સ:

કોષ્ટક: C માં રિલેશનલ ઓપરેટર

ઓપરેટરઅર્થઉદાહરણપરિણામ
<કરતાં ઓછું5 < 81 (સાચું)
>કરતાં વધુ9 > 31 (સાચું)
==બરાબર4 == 41 (સાચું)
!=અસમાન7 != 31 (સાચું)
<=કરતાં ઓછું અથવા બરાબર4 <= 41 (સાચું)
>=કરતાં વધુ અથવા બરાબર6 >= 90 (ખોટું)

કોડ ઉદાહરણ:

#include <stdio.h>
void main()
{
    int a = 10, b = 5;
    
    // એરિથમેટિક ઓપરેટર્સ
    printf("a + b = %d\n", a + b);   // 15
    printf("a - b = %d\n", a - b);   // 5
    printf("a * b = %d\n", a * b);   // 50
    printf("a / b = %d\n", a / b);   // 2
    printf("a %% b = %d\n", a % b);  // 0
    
    // રિલેશનલ ઓપરેટર્સ
    printf("a < b: %d\n", a < b);    // 0 (ખોટું)
    printf("a > b: %d\n", a > b);    // 1 (સાચું)
    printf("a == b: %d\n", a == b);  // 0 (ખોટું)
    printf("a != b: %d\n", a != b);  // 1 (સાચું)
}

યાદ રાખવાની રીત: “Add Subtract Multiply Divide Remainder” (એરિથમેટિક), “Less Greater Equal Not” (રિલેશનલ)

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

gets(S) અને scanf("%s",S) ફંક્શન વચ્ચેનો તફાવત લખો જ્યાં S સ્ટ્રીંગ છે.

જવાબ:

કોષ્ટક: gets(S) અને scanf("%s",S) વચ્ચેનો તફાવત

લક્ષણgets(S)scanf("%s",S)
સ્પેસ હેન્ડલિંગશબ્દો વચ્ચે સ્પેસ વાંચે છેસ્પેસ પર વાંચવાનું બંધ કરે છે
ઇનપુટ સમાપ્તિન્યૂલાઇન પર સમાપ્ત થાય છેવ્હાઇટસ્પેસ પર સમાપ્ત થાય છે
બફર ઓવરફ્લોઅસુરક્ષિત, લંબાઈ ચકાસણી નથીવિડ્થ લિમિટ સાથે સુરક્ષિત
ઉદાહરણ વર્તન“Hello World” → “Hello World”“Hello World” → “Hello”
સુરક્ષાઓવરફ્લો જોખમને કારણે અવમૂલ્યિતવિડ્થ સ્પેસિફાયર સાથે વધુ સારું

યાદ રાખવાની રીત: “Gets Spaces, Scanf Stops” (gets સ્પેસ વાંચે છે, scanf સ્પેસ પર અટકે છે)

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

બે સંખ્યાની અદલાબદલી કરવાનો પ્રોગ્રામ લખો.

જવાબ:

પ્રોગ્રામ:

#include <stdio.h>
void main()
{
    int a, b, temp;
    
    printf("Enter value of a: ");
    scanf("%d", &a);
    
    printf("Enter value of b: ");
    scanf("%d", &b);
    
    printf("Before swapping: a = %d, b = %d\n", a, b);
    
    // ટેમ્પ વેરિયેબલનો ઉપયોગ કરીને અદલાબદલી
    temp = a;
    a = b;
    b = temp;
    
    printf("After swapping: a = %d, b = %d", a, b);
}

અદલાબદલી ડાયગ્રામ:

flowchart LR
    A["a = 5"] --> |Step 1: temp = a| C["temp = 5"]
    B["b = 10"] --> |Step 2: a = b| A1["a = 10"]
    C --> |Step 3: b = temp| B1["b = 5"]

યાદ રાખવાની રીત: “Temporary Assists Swapping” (ટેમ્પ વેરિયેબલ અદલાબદલી માટે મદદ કરે છે)

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

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

જવાબ:

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

કોષ્ટક: C માં લોજીકલ ઓપરેટર

ઓપરેટરવર્ણનઉદાહરણપરિણામ
&&લોજીકલ AND(5>3) && (8>6)1 (બંને સાચાં)
||લોજીકલ OR(5<3) || (8>6)1 (એક સાચું)
!લોજીકલ NOT!(5>3)0 (સાચાને ખોટામાં ફેરવે)

બિટવાઇઝ ઓપરેટર્સ:

કોષ્ટક: C માં બિટવાઇઝ ઓપરેટર

ઓપરેટરવિગતઉદાહરણબાઇનરી પરિણામ
&બિટવાઇઝ AND5 & 3101 & 011 = 001 (1)
|બિટવાઇઝ OR5 | 3101 | 011 = 111 (7)
^બિટવાઇઝ XOR5 ^ 3101 ^ 011 = 110 (6)
~બિટવાઇઝ NOT~5~0101 = 1010 (-6)
«લેફ્ટ શિફ્ટ5 « 1101 « 1 = 1010 (10)
»રાઇટ શિફ્ટ5 » 1101 » 1 = 10 (2)

કોડ ઉદાહરણ:

#include <stdio.h>
void main()
{
    int a = 5, b = 3;
    
    // લોજીકલ ઓપરેટર્સ
    printf("a>3 && b<5: %d\n", (a>3) && (b<5));  // 1 (સાચું)
    printf("a<3 || b>1: %d\n", (a<3) || (b>1));  // 1 (સાચું)
    printf("!(a>b): %d\n", !(a>b));              // 0 (ખોટું)
    
    // બિટવાઇઝ ઓપરેટર્સ
    printf("a & b: %d\n", a & b);   // 1
    printf("a | b: %d\n", a | b);   // 7
    printf("a ^ b: %d\n", a ^ b);   // 6
    printf("~a: %d\n", ~a);         // -6
    printf("a << 1: %d\n", a << 1); // 10
    printf("a >> 1: %d\n", a >> 1); // 2
}

યાદ રાખવાની રીત: “AND OR NOT” (લોજીકલ ઓપરેટર્સ), “AND OR XOR NOT SHIFT” (બિટવાઇઝ ઓપરેટર્સ)

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

ઉદાહરણ સાથે multiple if-else સ્ટેટમેન્ટ સમજાવો.

જવાબ:

Multiple if-else: શરતોનો ક્રમ અનુસાર ચકાસણી થાય છે જ્યાં સૌથી પહેલી સાચી શરત મળે ત્યાં સુધી.

સ્ટ્રક્ચર:

if (condition1)
    statement1;
else if (condition2)
    statement2;
else if (condition3)
    statement3;
else
    default_statement;

કોડ ઉદાહરણ:

#include <stdio.h>
void main()
{
    int marks;
    
    printf("Enter marks: ");
    scanf("%d", &marks);
    
    if (marks >= 80)
        printf("Grade: A");
    else if (marks >= 70)
        printf("Grade: B");
    else if (marks >= 60)
        printf("Grade: C");
    else if (marks >= 50)
        printf("Grade: D");
    else
        printf("Grade: F");
}

ડાયગ્રામ:

flowchart TD
    A[Start] --> B{marks >= 80?}
    B -->|Yes| C[Grade A]
    B -->|No| D{marks >= 70?}
    D -->|Yes| E[Grade B]
    D -->|No| F{marks >= 60?}
    F -->|Yes| G[Grade C]
    F -->|No| H{marks >= 50?}
    H -->|Yes| I[Grade D]
    H -->|No| J[Grade F]

યાદ રાખવાની રીત: “Check Each Condition in Sequence” (CECS)

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

While લૂપ અને for લૂપનું વર્કિંગ જણાવો.

જવાબ:

કોષ્ટક: While લૂપ vs For લૂપ

લક્ષણWhile લૂપFor લૂપ
સિન્ટેક્સwhile(condition) { statements; }for(init; condition; update) { statements; }
ક્યારે વાપરવુંજ્યારે પુનરાવર્તનની સંખ્યા અજ્ઞાત હોયજ્યારે પુનરાવર્તનની સંખ્યા જાણીતી હોય
ઇનિશિયલાઇઝેશનલૂપની બહારલૂપના ડિક્લેરેશનમાં
અપડેટલૂપ બોડીની અંદર કરવું જોઈએલૂપ ડિક્લેરેશનમાં આપોઆપ થાય છે
એક્ઝિટ કંટ્રોલમાત્ર શરૂઆતમાંમાત્ર શરૂઆતમાં
ઉદાહરણયુઝર ઇનપુટ ચકાસવાનિશ્ચિત વખત પુનરાવર્તન કરવા

While લૂપ ફ્લો:

flowchart TD
    A([Start]) --> B[Initialize]
    B --> C{Condition}
    C -->|True| D[Body]
    D --> C
    C -->|False| E([End])

For લૂપ ફ્લો:

flowchart TD
    A([Start]) --> B[Initialize]
    B --> C{Condition}
    C -->|True| D[Body]
    D --> E[Update]
    E --> C
    C -->|False| F([End])

યાદ રાખવાની રીત: “While Checks Then Acts” (WCTA), “For Initializes Tests Updates” (FITU)

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

આપેલ સંખ્યાના ફેક્ટોરિયલ શોધવા માટેનો પ્રોગ્રામ લખો.

જવાબ:

પ્રોગ્રામ:

#include <stdio.h>
void main()
{
    int num, i;
    unsigned long fact = 1;
    
    printf("Enter a number: ");
    scanf("%d", &num);
    
    if (num < 0)
        printf("Factorial not defined for negative numbers");
    else
    {
        for(i = 1; i <= num; i++)
        {
            fact = fact * i;
        }
        printf("Factorial of %d = %lu", num, fact);
    }
}

ફેક્ટોરિયલ ગણતરી કોષ્ટક: ઉદાહરણ તરીકે, જો num = 5:

પુનરાવર્તનifact = fact * iનવી fact કિંમત
પ્રારંભિક--1
111 * 11
221 * 22
332 * 36
446 * 424
5524 * 5120

ફેક્ટોરિયલ ગણતરી ડાયગ્રામ:

flowchart TD
    A([Start]) --> B[/Input num/]
    B --> C{num < 0?}
    C -->|Yes| D[/Error message/]
    C -->|No| E[fact = 1]
    E --> F[Loop i from 1 to num]
    F --> G[fact = fact * i]
    G --> H{i < num?}
    H -->|Yes| F
    H -->|No| I[/Display fact/]
    I --> J([End])

યાદ રાખવાની રીત: “Find And Count The Numbers!” (FACTN! - Factorial)

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

ઉદાહરણ સાથે switch-case સ્ટેટમેન્ટની કામગીરી સમજાવો.

જવાબ:

Switch-Case: એક પસંદગી નિવેદન જે મૂલ્યોની યાદી (કેસ) સામે વેરિયેબલની સમાનતા ચકાસવાની મંજૂરી આપે છે.

સ્ટ્રક્ચર:

switch(expression) {
    case value1:
        statements1;
        break;
    case value2:
        statements2;
        break;
    default:
        default_statements;
}

કોડ ઉદાહરણ:

#include <stdio.h>
void main()
{
    int day;
    
    printf("Enter day number (1-7): ");
    scanf("%d", &day);
    
    switch(day) {
        case 1:
            printf("Monday");
            break;
        case 2:
            printf("Tuesday");
            break;
        case 3:
            printf("Wednesday");
            break;
        case 4:
            printf("Thursday");
            break;
        case 5:
            printf("Friday");
            break;
        case 6:
            printf("Saturday");
            break;
        case 7:
            printf("Sunday");
            break;
        default:
            printf("Invalid day");
    }
}

Switch-Case ડાયગ્રામ:

flowchart TD
    A[Start] --> B[/Input day/]
    B --> C{Switch day}
    C -->|case 1| D[Monday]
    C -->|case 2| E[Tuesday]
    C -->|case 3| F[Wednesday]
    C -->|case 4| G[Thursday]
    C -->|case 5| H[Friday]
    C -->|case 6| I[Saturday]
    C -->|case 7| J[Sunday]
    C -->|default| K[Invalid day]
    D & E & F & G & H & I & J & K --> L[End]

યાદ રાખવાની રીત: “Select Value, Exit with Break” (SVEB)

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

break અને continue સ્ટેટમેન્ટ ઉપયોગ લખો.

જવાબ:

કોષ્ટક: Break vs Continue Keywords

લક્ષણbreakcontinue
ઉદ્દેશવર્તમાન લૂપ/સ્વિચમાંથી બહાર નીકળે છેવર્તમાન પુનરાવર્તન છોડી, આગલા પુનરાવર્તનમાં જાય છે
લૂપ પર અસરલૂપને સમાપ્ત કરે છેઆગલા પુનરાવર્તનમાં આગળ વધે છે
ક્યાં વપરાય છેલૂપ્સ & સ્વિચ સ્ટેટમેન્ટ્સમાત્ર લૂપ્સમાં
કંટ્રોલ ફ્લોલૂપ પછીના સ્ટેટમેન્ટ પર જાય છેલૂપની શરત ચકાસણી પર જાય છે
ઉપયોગનું ઉદાહરણશરત પૂરી થાય ત્યારે લૂપમાંથી નીકળવુંચોક્કસ પુનરાવર્તનો છોડવા

ફ્લો ડાયગ્રામ - break:

flowchart TD
    A([Start]) --> B[Loop]
    B --> C{Condition}
    C -->|True| D[break]
    C -->|False| E[Loop statements]
    E --> B
    D --> F[Statements after loop]
    F --> G([End])

ફ્લો ડાયગ્રામ - continue:

flowchart TD
    A([Start]) --> B[Loop]
    B --> C{Condition}
    C -->|True| D[continue]
    C -->|False| E[Loop statements]
    D --> B
    E --> B
    B -->|Loop ends| F([End])

યાદ રાખવાની રીત: “Break Exits, Continue Skips” (BECS)

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

કીબોર્ડ પરથી લીટીઓની સંખ્યા (n) વાંચી અને નીચે દર્શાવેલ ત્રિકોણ પ્રિન્ટ કરવા માટેનો પ્રોગ્રામ લખો. ઉદાહરણ તરીકે, n=5

1 2 3 4 5
1 2 3 4
1 2 3
1 2
1

જવાબ:

પ્રોગ્રામ:

#include <stdio.h>
void main()
{
    int n, i, j;
    
    printf("Enter number of lines: ");
    scanf("%d", &n);
    
    for(i = n; i >= 1; i--)
    {
        for(j = 1; j <= i; j++)
        {
            printf("%d ", j);
        }
        printf("\n");
    }
}

પેટર્ન લોજિક કોષ્ટક: n = 5 માટે:

ijઆઉટપુટ
5j=1 થી 51 2 3 4 5
4j=1 થી 41 2 3 4
3j=1 થી 31 2 3
2j=1 થી 21 2
1j=1 થી 11

પેટર્ન વિઝ્યુલાઇઝેશન:

111112222333445

પ્રોગ્રામ ફ્લો:

flowchart TD
    A([Start]) --> B[/Input n/]
    B --> C[outer loop: i = n to 1]
    C --> D[inner loop: j = 1 to i]
    D --> E[/Print j/]
    E --> F{j < i?}
    F -->|Yes| D
    F -->|No| G[/Print newline/]
    G --> H{i > 1?}
    H -->|Yes| C
    H -->|No| I([End])

યાદ રાખવાની રીત: “Decreasing Rows With Increasing Values” (DRWIV)

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

નેસ્ટેડ if-else સ્ટેટમેન્ટ ઉદાહરણ સાથે સમજાવો.

જવાબ:

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

સ્ટ્રક્ચર:

if (condition1) {
    if (condition2) {
        statements1;
    } else {
        statements2;
    }
} else {
    statements3;
}

કોડ ઉદાહરણ:

#include <stdio.h>
void main()
{
    int age, weight;
    
    printf("Enter age: ");
    scanf("%d", &age);
    
    if (age >= 18) {
        printf("Enter weight: ");
        scanf("%d", &weight);
        
        if (weight >= 50) {
            printf("Eligible to donate blood");
        } else {
            printf("Underweight, not eligible");
        }
    } else {
        printf("Age below 18, not eligible");
    }
}

નેસ્ટેડ if-else ડાયગ્રામ:

flowchart TD
    A[Start] --> B{age >= 18?}
    B -->|Yes| C{weight >= 50?}
    B -->|No| D[Not eligible: Age]
    C -->|Yes| E[Eligible]
    C -->|No| F[Not eligible: Weight]
    D & E & F --> G[End]

યાદ રાખવાની રીત: “Check Outside Then Inside” (COTI)

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

Pointer arguments નો ઉપયોગ કરીને બે પૂર્ણાંક સંખ્યાની અદલાબદલી કરવાનો પ્રોગ્રામ લખો.

જવાબ:

પ્રોગ્રામ:

#include <stdio.h>
void main()
{
    int a, b, temp;
    int *p1, *p2;
    
    printf("Enter value of a: ");
    scanf("%d", &a);
    
    printf("Enter value of b: ");
    scanf("%d", &b);
    
    p1 = &a;  // p1 a ને પોઇન્ટ કરે છે
    p2 = &b;  // p2 b ને પોઇન્ટ કરે છે
    
    printf("Before swapping: a = %d, b = %d\n", a, b);
    
    // પોઇન્ટર્સનો ઉપયોગ કરીને અદલાબદલી
    temp = *p1;
    *p1 = *p2;
    *p2 = temp;
    
    printf("After swapping: a = %d, b = %d", a, b);
}

પોઇન્ટર અદલાબદલી ડાયગ્રામ:

abAabfters51w150a0pping:pppp1212

યાદ રાખવાની રીત: “Pointers Exchange Memory Values” (PEMV)

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

Array ની વ્યાખ્યા લખો. One dimensional array નું initialization અને declaration સમજાવો.

જવાબ:

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

કોષ્ટક: Array ડિક્લેરેશન & ઇનિશિયલાઇઝેશન

ઓપરેશનસિન્ટેક્સઉદાહરણ
ડિક્લેરેશનdata_type array_name[size];int marks[5];
ડિક્લેરેશન સમયે ઇનિશિયલાઇઝેશનdata_type array_name[size] = {values};int nums[4] = {10, 20, 30, 40};
આંશિક ઇનિશિયલાઇઝેશનdata_type array_name[size] = {values};int nums[5] = {10, 20};
સાઇઝ વિનાdata_type array_name[] = {values};int nums[] = {10, 20, 30};
વ્યક્તિગત તત્વarray_name[index] = value;marks[0] = 95;

કોડ ઉદાહરણ:

#include <stdio.h>
void main()
{
    // ડિક્લેરેશન
    int marks[5];
    
    // ડિક્લેરેશન પછી ઇનિશિયલાઇઝેશન
    marks[0] = 85;
    marks[1] = 90;
    marks[2] = 78;
    marks[3] = 92;
    marks[4] = 88;
    
    // ડિક્લેરેશન સાથે ઇનિશિયલાઇઝેશન
    int scores[] = {95, 89, 76, 82, 91};
    
    // એરે તત્વો ઍક્સેસ કરવા
    printf("marks[2] = %d\n", marks[2]);
    printf("scores[3] = %d", scores[3]);
}

એરે રજૂઆત:

marks:[805][910][728][932][848](indices)

મેમરી રજૂઆત:

flowchart LR
    A["marks[0]
85"] --- B["marks[1]
90"] B --- C["marks[2]
78"] C --- D["marks[3]
92"] D --- E["marks[4]
88"]

યાદ રાખવાની રીત: “Declare, Initialize, Access With Index” (DIAWI)

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

do while loop ઉદાહરણ સાથે સમજાવો.

જવાબ:

do-while loop: એક લૂપ જે શરતની ચકાસણી કરતા પહેલા ઓછામાં ઓછી એકવાર લૂપ બોડી ચલાવે છે.

સ્ટ્રક્ચર:

do {
    statements;
} while(condition);

કોડ ઉદાહરણ:

#include <stdio.h>
void main()
{
    int num, sum = 0;
    
    do {
        printf("Enter a number (0 to stop): ");
        scanf("%d", &num);
        sum += num;
    } while(num != 0);
    
    printf("Sum of entered numbers = %d", sum);
}

do-while લૂપ ફ્લો:

flowchart TD
    A([Start]) --> B[Body statements]
    B --> C{Condition}
    C -->|True| B
    C -->|False| D([End])

while લૂપથી મુખ્ય તફાવતો:

  • બોડી ઓછામાં ઓછી એકવાર ચલાવે છે
  • સ્ટેટમેન્ટ્સ ચલાવ્યા પછી કંડીશન ચેક કરે છે
  • કંડીશન પછી સેમિકોલોન જરૂરી છે

યાદ રાખવાની રીત: “Do First, Check Later” (DFCL)

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

નીચે આપેલ ફંકશન ઉદાહરણ સાથે સમજાવો: (1) gets() (2) puts() (3) strlen() (4) strcpy()

જવાબ:

કોષ્ટક: C માં સ્ટ્રિંગ ફંકશન્સ

ફંકશનહેતુસિન્ટેક્સઉદાહરણ
gets()સ્પેસ સાથે સ્ટ્રિંગ વાંચે છેgets(string);gets(name);
puts()ન્યૂલાઇન સાથે સ્ટ્રિંગ દર્શાવે છેputs(string);puts(name);
strlen()સ્ટ્રિંગની લંબાઈ આપે છેstrlen(string);n = strlen(name);
strcpy()સોર્સને ડેસ્ટિનેશનમાં કોપી કરે છેstrcpy(dest, src);strcpy(str1, str2);

કોડ ઉદાહરણ:

#include <stdio.h>
#include <string.h>
void main()
{
    char name[50], copy[50];
    int length;
    
    printf("Enter your name: ");
    gets(name);           // સ્પેસ સાથે નામ વાંચે છે
    
    puts("Your name is:"); // ન્યૂલાઇન સાથે દર્શાવે છે
    puts(name);
    
    length = strlen(name); // સ્ટ્રિંગની લંબાઈ મેળવે છે
    printf("Length: %d\n", length);
    
    strcpy(copy, name);    // name ને copy માં કોપી કરે છે
    printf("Copied string: %s", copy);
}

યાદ રાખવાની રીત: “Gets Puts String’s Length and Copies” (GPSLC)

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

Recursion ની વ્યાખ્યા આપી ઉદાહરણ સાથે સમજાવો. Recursion નો ઉપયોગ કરીને આપેલા નંબરનો ફેક્ટોરીયલ શોધવાનો પ્રોગ્રામ લખો.

જવાબ:

Recursion: એક પ્રક્રિયા જેમાં ફંક્શન સીધી કે પરોક્ષ રીતે પોતાને જ ચોક્કસ શરત પૂરી થાય ત્યાં સુધી કૉલ કરે છે.

Recursion ના ઘટકો:

  1. બેઝ કેસ: રિકર્ઝન રોકવા માટેની શરત
  2. રિકર્સિવ કેસ: ફંકશન પોતે જ પોતાને કૉલ કરે છે

કોડ ઉદાહરણ:

#include <stdio.h>

// ફેક્ટોરિયલ શોધવા માટે રિકર્સિવ ફંક્શન
unsigned long factorial(int n)
{
    // બેઝ કેસ
    if (n == 0 || n == 1)
        return 1;
    
    // રિકર્સિવ કેસ
    else
        return n * factorial(n-1);
}

void main()
{
    int num;
    unsigned long result;
    
    printf("Enter a number: ");
    scanf("%d", &num);
    
    if (num < 0)
        printf("Factorial not defined for negative numbers");
    else
    {
        result = factorial(num);
        printf("Factorial of %d = %lu", num, result);
    }
}

રિકર્સિવ ફેક્ટોરિયલ ગણતરી: factorial(5) માટે

કોષ્ટક: રિકર્ઝન ટ્રેસ

કૉલરિટર્નગણતરી
factorial(5)5 × factorial(4)5 × 24 = 120
factorial(4)4 × factorial(3)4 × 6 = 24
factorial(3)3 × factorial(2)3 × 2 = 6
factorial(2)2 × factorial(1)2 × 1 = 2
factorial(1)1બેઝ કેસ

રિકર્ઝન ડાયગ્રામ:

flowchart TD
    A["factorial(5)"] --> B["5 * factorial(4)"]
    B --> C["4 * factorial(3)"]
    C --> D["3 * factorial(2)"]
    D --> E["2 * factorial(1)"]
    E --> F["return 1"]
    F --> G["return 2"]
    G --> H["return 6"]
    H --> I["return 24"]
    I --> J["return 120"]

યાદ રાખવાની રીત: “Function Calling Itself, Bottoming Out” (FCIBO)

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

array અને structure વચ્ચેનો તફાવત લખો.

જવાબ:

કોષ્ટક: Array vs Structure

લક્ષણArrayStructure
ડેટા પ્રકારબધા તત્વો માટે એક જ ડેટા પ્રકારવિવિધ ડેટા પ્રકાર સંગ્રહી શકે છે
ઍક્સેસઇન્ડેક્સનો ઉપયોગ (arr[0])મેમ્બર નામનો ઉપયોગ (s.name)
મેમરી ફાળવણીસળંગસળંગ પરંતુ વિવિધ સાઇઝ
સાઇઝડિક્લેરેશન સમયે ફિક્સ સાઇઝબધા મેમ્બર્સની સાઇઝનો સરવાળો
હેતુસમાન વસ્તુઓનો સંગ્રહવિવિધ પ્રકારના સંબંધિત ડેટાનું ગ્રુપિંગ
ડિક્લેરેશનint arr[5];struct student { int id; char name[20]; };

ડાયગ્રામ:

flowchart LR
    subgraph Array
    A["[0]
int"] --- B["[1]
int"] --- C["[2]
int"] end subgraph Structure D["id
int"] --- E["name
char[]"] --- F["age
int"] end

યાદ રાખવાની રીત: “Arrays for Same, Structures for Different” (ASSD)

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

આપેલ 10 કિંમતમાંથી મહત્તમ કિંમત શોધવાનો C પ્રોગ્રામ array નો ઉપયોગ કરીને લખો.

જવાબ:

પ્રોગ્રામ:

#include <stdio.h>
void main()
{
    int arr[10], i, max;
    
    // 10 કિંમતો ઇનપુટ
    printf("Enter 10 values:\n");
    for(i = 0; i < 10; i++)
    {
        printf("Enter value %d: ", i+1);
        scanf("%d", &arr[i]);
    }
    
    // મહત્તમ કિંમત શોધવી
    max = arr[0];  // પ્રથમ તત્વ મહત્તમ માની લો
    for(i = 1; i < 10; i++)
    {
        if(arr[i] > max)
            max = arr[i];
    }
    
    printf("Maximum value is: %d", max);
}

અલ્ગોરિધમ ફ્લો:

flowchart TD
    A([Start]) --> B[/Input 10 values/]
    B --> C[Set max = first element]
    C --> D[Loop i from 1 to 9]
    D --> E{arr[i] > max?}
    E -->|Yes| F[max = arr[i]]
    E -->|No| G[Continue]
    F & G --> H{i < 9?}
    H -->|Yes| D
    H -->|No| I[/Display max/]
    I --> J([End])

યાદ રાખવાની રીત: “Compare And Replace Maximum” (CARM)

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

Structure ને વ્યાખ્યા લખો. Book નામથી એક structure બનાવો કે જેમાં book વિશેની માહિતી Book title, Name of author, Price and Number of pages સ્ટોર કરી શકાય.

જવાબ:

Structure: વિવિધ ડેટા પ્રકારના સંબંધિત વેરિયેબલ્સને એક જ નામ હેઠળ ગ્રુપ કરતું યુઝર-ડિફાઇન્ડ ડેટા પ્રકાર.

Book Structure કોડ:

#include <stdio.h>

struct book {
    char title[50];
    char author[30];
    float price;
    int pages;
};

void main()
{
    struct book b1;
    
    // પુસ્તકની વિગતો ઇનપુટ
    printf("Enter book title: ");
    gets(b1.title);
    
    printf("Enter author name: ");
    gets(b1.author);
    
    printf("Enter price: ");
    scanf("%f", &b1.price);
    
    printf("Enter number of pages: ");
    scanf("%d", &b1.pages);
    
    // પુસ્તકની વિગતો પ્રદર્શિત
    printf("\nBook Details:\n");
    printf("Title: %s\n", b1.title);
    printf("Author: %s\n", b1.author);
    printf("Price: Rs. %.2f\n", b1.price);
    printf("Pages: %d", b1.pages);
}

Structure મેમરી રજૂઆત:

stapptiurarttigulhceceoest[r5[b03o]0o]k""CD4e53Pn02rn.0oi5gs0""

Structure ડાયગ્રામ:

classDiagram
    class book {
        char title[50]
        char author[30]
        float price
        int pages
    }

યાદ રાખવાની રીત: “Title Author Price Pages” (TAPP)

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

સ્ટ્રીંગ શું છે? સ્ટ્રીંગ ઉપર કયા ઓપરેશન પરફોર્મ થાય છે.

જવાબ:

સ્ટ્રીંગ: NULL કેરેક્ટર ‘\0’ દ્વારા સમાપ્ત થતા અક્ષરોની શ્રેણી.

કોષ્ટક: C માં સ્ટ્રીંગ ઓપરેશન્સ

ઓપરેશનફંક્શનઉદાહરણ
ઇનપુટgets(), scanf()gets(str), scanf("%s", str)
આઉટપુટputs(), printf()puts(str), printf("%s", str)
લંબાઈstrlen()len = strlen(str)
કોપીstrcpy()strcpy(dest, src)
જોડાણstrcat()strcat(str1, str2)
સરખામણીstrcmp()result = strcmp(str1, str2)
શોધstrchr(), strstr()ptr = strchr(str, ‘a’)
રૂપાંતરstrlwr(), strupr()strlwr(str), strupr(str)

સ્ટ્રીંગ રજૂઆત:

Hell\0

યાદ રાખવાની રીત: “Input Output Length Copy Concat Compare Search Convert” (IOLCCSC)

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

A to Z ની ASCII વેલ્યુ પ્રિન્ટ કરવા માટેનો પ્રોગ્રામ લખો.

જવાબ:

પ્રોગ્રામ:

#include <stdio.h>
void main()
{
    char ch;
    
    printf("ASCII values from A to Z:\n");
    printf("Character\tASCII Value\n");
    printf("-----------------------\n");
    
    for(ch = 'A'; ch <= 'Z'; ch++)
    {
        printf("    %c\t\t   %d\n", ch, ch);
    }
}

સેમ્પલ આઉટપુટ કોષ્ટક:

CharacterASCII Value
A65
B66
Z90

ASCII ચાર્ટ રજૂઆત:

AAS(C6I5I)VBa(l6u6e)s:C(67)Z(90)

યાદ રાખવાની રીત: “Alphabets Sequentially Creating Integer Indices” (ASCII)

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

user defined અને library function શું છે? દરેકના બે ઉદાહરણ સાથે સમજાવો.

જવાબ:

Library Functions: C ભાષા દ્વારા પૂરા પાડવામાં આવતા પહેલેથી વ્યાખ્યાયિત ફંક્શન્સ જે ઉપયોગ માટે તૈયાર છે.

User-Defined Functions: પ્રોગ્રામર દ્વારા ચોક્કસ કાર્યો કરવા માટે બનાવેલા ફંક્શન્સ.

કોષ્ટક: Library vs User-Defined Functions

લક્ષણLibrary FunctionsUser-Defined Functions
વ્યાખ્યાહેડર ફાઈલોમાં પહેલેથી વ્યાખ્યાયિતપ્રોગ્રામર દ્વારા બનાવવામાં આવે છે
ડિક્લેરેશનવ્યાખ્યા કરવાની જરૂર નથીવ્યાખ્યા કરવી જ જોઈએ
ઉદાહરણોprintf(), scanf(), strlen()calculateArea(), findMax()
હેડર ફાઇલ્સstdio.h, string.h, math.h, etc.કોઈ હેડર જરૂરી નથી
હેતુસામાન્ય કાર્યોકસ્ટમાઇઝ્ડ કાર્યો

Library Functions ના ઉદાહરણો:

  1. strlen() - સ્ટ્રિંગ લંબાઈ
#include <stdio.h>
#include <string.h>
void main()
{
    char str[] = "Hello";
    int length = strlen(str);  // Library function
    printf("Length of string: %d", length);
}
  1. sqrt() - વર્ગમૂળ
#include <stdio.h>
#include <math.h>
void main()
{
    float num = 25, result;
    result = sqrt(num);  // Library function
    printf("Square root of %.0f = %.2f", num, result);
}

User-Defined Functions ના ઉદાહરણો:

  1. calculateArea() - લંબચોરસનું ક્ષેત્રફળ
#include <stdio.h>

// User-defined function
float calculateArea(float length, float width)
{
    return length * width;
}

void main()
{
    float length = 10.5, width = 5.5, area;
    area = calculateArea(length, width);  // User function call
    printf("Area of rectangle = %.2f", area);
}
  1. findMax() - ત્રણ સંખ્યાઓમાંથી મહત્તમ
#include <stdio.h>

// User-defined function
int findMax(int a, int b, int c)
{
    if(a >= b && a >= c)
        return a;
    else if(b >= a && b >= c)
        return b;
    else
        return c;
}

void main()
{
    int x = 10, y = 25, z = 15, max;
    max = findMax(x, y, z);  // User function call
    printf("Maximum number is: %d", max);
}

યાદ રાખવાની રીત: “Libraries Provide, Users Create” (LPUC)

સંબંધિત

કન્ઝ્યુમર ઇલેક્ટ્રોનિક્સ એન્ડ મેઇન્ટેનન્સ (4341107) - સમર 2023 સોલ્યુશન
19 મિનિટ
અભ્યાસ-સામગ્રી સોલ્યુશન કન્ઝ્યુમર-ઇલેક્ટ્રોનિક્સ 4341107 2023 સમર
ડિજિટલ કોમ્યુનિકેશન (4341102) - સમર 2023 સોલ્યુશન
20 મિનિટ
અભ્યાસ-સામગ્રી સોલ્યુશન ડિજિટલ-કોમ્યુનિકેશન 4341102 2023 સમર
ઔદ્યોગિક ઇલેક્ટ્રોનિક્સ (4331103) - શિયાળુ 2022 સોલ્યુશન
18 મિનિટ
અભ્યાસ-સામગ્રી સોલ્યુશન ઔદ્યોગિક-ઇલેક્ટ્રોનિક્સ 4331103 2022 શિયાળુ
લીનીયર ઇન્ટીગ્રેટેડ સર્કિટ (4341105) - ગ્રીષ્મ 2023 સોલ્યુશન
19 મિનિટ
Study-Material Solutions Linear-Integrated-Circuit 4341105 2023 Summer
એન્ટેના અને વેવ પ્રોપેગેશન (4341106) - સમર 2023 સોલ્યુશન
20 મિનિટ
Study-Material Solutions Antenna Wave-Propagation 4341106 2023 Summer
માઇક્રોપ્રોસેસર અને માઇક્રોકન્ટ્રોલર (4341101) - સમર 2023 સોલ્યુશન
23 મિનિટ
Study-Material Solutions Microprocessor 4341101 2023 Summer Gujarati