Article

EDP

C & DS

Engg.Chemistry

Engg.Physics



'సీ' లో లూప్ లు ఏం చేస్తాయి?
క statements గ్రూప్ ను రిపీటెడ్ గా రన్ చేసేందుకు loop లను వాడతారు. loopలు అనేవి high level programming లాంగ్వేజీలో ఉండే ముఖ్యమైన ఫీచర్. C లాంగ్వేజి లో మూడు రకాల loop లు ఉన్నాయి. వాటి గురించి ఈ పాఠంలో నేర్చుకుందాం.
1. while loop
2. do-while loop
3. for loop

1 The while loop
ఈ కింద ఇచ్చిన బొమ్మ while loop ఎలా పని చేస్తుందో చూపిస్తుంది. EXPR విలువ true గా ఉన్నంతవరకు while బ్లాక్ ( { మరియు } మధ్యలో ఉన్న statements ) లో ఉన్నstatements రిపీటెడ్ గా execute చేస్తుంది. EXPR విలువ false అయినప్పుడు లేదా while బ్లాక్ లోపల break statement ను execute చేసినప్పుడు program control loop లో నుంచి బయటకు, అంటే Statement కు వస్తుంది.
     

ముఖ్యంగా while loop బిహేవియర్ ను, EXPRలో వాడే variables ( వీటిని control variables అని అంటారు), వాటి మొదటి (initial) విలువస్, లూప్ లోపల వాటి విలువ మార్చే statements ( వాటినే Modifierలు అంటారు), కలసి control చేస్తాయి. ఇంకా, while loop బ్లాక్ లో ఒక్క statement మాత్రమే వుంటే, {, మరియు }లను తీసివేయవచ్చు.

Example 1: ఈ కింది ప్రోగ్రాం while loop ఎలా పని చేస్తుందో విశదీకరిస్తుంది.
#include<stdio.h>
int main()
{
     int i, n; (here, “i, n” are loop control variables)
     printf(“Enter an integer\n”);
     scanf(“%d”, &n);
     i=0; (Initialization Statement)
     while(i<n) (Condition)
          { _
          _
          i++; (Modifier)
          }
     return (0);
}
పైన ఇచ్చిన ప్రోగ్రాంలో, లూప్ ఎలా పని చేస్తుందో ఈ కింది పట్టిక ద్వారా step-by-step పరిశీలించి తెలుసుకుందాం.

     

ప్రోగ్రాంలో ఉన్న లూప్ ను పరిశీలించడం ద్వారా , మనకు కొన్ని విషయాలు తెలిసాయి. అవి , ఆ లూప్ లో ఉన్న statements అయిదు సార్లు రన్ అయ్యాయి; అది కూడా n విలువ 5 కాబట్టి మొత్తంగా ఈ లూప్ n సార్లు రన్ అవుతుందని చెప్పవచ్చు. అంతేకాక, i++ లేకపోయినా, లేదా i++ స్థానంలో i--వాడినా, లూప్ నిరంతరం (infinite) రన్ అయ్యేది . అలాగే, ఈ కింద చూపిన విధంగా, బ్రాకెట్ తర్వాత ; వాడినా లూప్ నిరంతరం (infinite) గా రన్ అవుతుంది. ఎందుకంటే ; ను while loop బ్లాక్ లాగా తీసుకుంటుంది. దానినే మనం do nothing బ్లాక్ అని కూడా అనవచ్చు. అంటే, i<n అయ్యేంతవరకూ ఏమీ చేయవద్దు (do nothing) అని. దీనిని operating systems సబ్జెక్టులో busy wait అని అంటారు.
while (i<n);

మరియూ లూప్ control variablesను initialize చెయ్యకపోతే, లూప్ ఒక్కోసారి రన్ అవుతుంది, కొన్ని సార్లు మనం అనుకొన్న దానికంటే ఎక్కువ సార్లు రన్ అవుతుంది, కొన్ని సార్లు అసలు రన్ కూడా అవ్వదు.

Example 2: ఈ ప్రోగ్రాం తరగతిలో ఎంత మంది విద్యార్థులు ఉన్నారో రీడ్ చేసి, వారి మార్కులను రీడ్ చేసి సరాసరి ప్రింట్ చేస్తుంది.
Solution: పైన వివరించిన while loopనే ఈ exampleలో కూడా వాడుతున్నాం. అంటే n సార్లు, ఎంతమంది విద్యార్థులు ఉంటే అన్ని సార్లు రన్ అయ్యే లూప్ వాడి, ప్రతీ సారీ ఒక విద్యార్థి మార్కులను రీడ్ చేసి మొత్తాన్ని కనుక్కొని ఆ తర్వాత సరాసరి కనుక్కొంటుంది.

#include<stdio.h>
int main()
{
     int n, i, m, s;
     printf(“Enter how students average you want\n”);
     scanf(“%d”, &n);

     i=0;
     s=0;
     while(i<n){
     printf(“Enter a student mark\n”);
     scanf(“%d”, &m);
     s=s+m;
     i++;
     }

   printf(“Average= %d\n”, s/n);
   return 0;
}
ఈ కింది పట్టిక ద్వారా ఈ ప్రోగ్రాంను step-by-step పరిశీలించి చేస్తే మనకు ఇది ఎలా పనిచేస్తుందో అర్ధమవుతుంది.

     
పైన ఇచ్చిన ప్రోగ్రాంను రన్ చేసినప్పుడు కంప్యూటరు మీద ఈ విధంగా ఉంటుంది.
     

Example 3: ఈ ప్రోగ్రాం తరగతిలో ఎంత మంది విద్యార్థులు ఉన్నారో రీడ్ చేసి, వారి మార్కులను రీడ్ చేసి ఉత్తీర్ణులైన విద్యార్థి ల మార్కుల సరాసరిను ప్రింట్ చేస్తుంది. పాస్ కావాలంటే 35 మార్కులు రావాలి.
Solution: పైన డిస్కస్ చేసిన while loopనే ఈ exampleలో కూడా వాడుతున్నాం. అంటే ఎంతమంది విద్యార్థులు ఉంటే అన్ని సార్లు రన్ అయ్యే లూప్ వాడి, ప్రతీ సారీ ఒక విద్యార్థి మార్కులను రీడ్ చేసి, దానిని 35తో పోల్చి ఎక్కువ అయితే మొత్తం(s)కు add చేసి npను 1 పెంచుతాం. అంటే ఉత్తీర్ణులైన వారి మొత్తంమార్క్స్, ఎంత మంది పాస్ అయ్యారో కనుక్కొంటాం. Program execution లూప్ బయటకు వచ్చిన తర్వాత, సరాసరి కనుక్కొని ప్రింట్ చేస్తాం. సరాసరి కనుక్కొనేటప్పుడు, Divided by Zero అనే error రాకుండా, np విలువ సున్నా కాకపోతేనే సరాసరి ను ప్రింట్ చేస్తున్నాం, లేకపోతే ఒక మెసేజీ వచ్చేవిధంగా చేస్తున్నాం.

#include<stdio.h>
int main()
{
     int n, i, m, sp = 0, np = 0;
     printf(“Enter Number of Students\n”);
     scanf(“%d”, &n);
     i=0;
     while(i<n)
          {
          printf(“Enter next student mark\n”);
          scanf(“%d”, &m);
          if(m>=35){
          sp += m;
          np++;
          }
     i++;
     }
     if(np)
     printf(“Average of Passed Students=%d\n”, sp/np);
     else
     printf(“Seems All GEMS. Don’t Know How to Handle!!!!\n”);
     return (0);
}

ఈ ప్రోగ్రాంకు మనం పైన చేసిన విధంగా పరిశీలించి పట్టికను తయారు చెయ్యండి.
పైన ఇచ్చిన ప్రోగ్రాంను రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా ఉంటుంది.
     

Example 4: ఈ ప్రోగ్రాం ఒక విద్యార్థి మార్కులను n టెస్ట్ లలో రీడ్ చేసి అతని క్లాస్ ను ఈ కింద ఇచ్చిన నియమాల ప్రకారం ప్రింట్ చేస్తుంది.

Solution: పైన వివరించిన while loopనే ఈ exampleలో కూడా వాడుతున్నాం. అంటే ఎన్ని టెస్టు లు ఉంటే అన్ని సార్లు రన్ అయ్యే లూప్ వాడి, ప్రతీ సారీ ఒక టెస్టు మార్క్ రీడ్ చేసి టొటల్ కు add చేస్తున్నాం. అంతే కాకుండా, ఆ టెస్ట్ లో ఉత్తీర్ణులైతే, అంటే 35 కంటే ఎక్కువ వస్తే, np విలువను ఒకటి పెంచుతున్నాం. ప్రతీ టెస్ట్ లో ఉత్తీర్ణులైతేనే ఏదయినా క్లాస్ ఇస్తాం. ఈ np value n తో సమానం అయితే, అన్ని టెస్ట్ లలో ఉత్తీర్ణులైనట్లు. ఆ తర్వాత, యావరేజ్ ను తీసుకొని క్లాస్ ప్రింట్ చేస్తా0.

#include<stdio.h>
int main()
{
     int n, i, m, s=0,np=0;
     printf(“Enter number of tests\n”);
     scanf(“%d”, &n);

     i=0;
     while(i<n){
     printf(“Enter next test mark\n”);
     scanf(“%d”, &m);
     s+=m;
     if(m>=35)np++;
     i++;
     }
     if(np==5){
     s=s/n;
     if(s>=60)
     printf(“First class\n”);
     else if(s>=50)
     printf(“Second class\n”);
     else
     printf(“Third class\n”);
     }
     else
     printf(“Failed\n”);
     return (0);
}
పైన ఇచ్చిన ప్రోగ్రాం రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా ఉంటుంది.

     

Example 5: ఈ ప్రోగ్రాం తరగతిలో ఎంత మంది విద్యార్థిలు ఉన్నారో రీడ్ చేసి, వారి మార్కులను రీడ్ చేసి సరాసరి, standard Deviation ప్రింట్ చేస్తుంది.
Solution: విద్యార్థి మార్కులను x1, x2, x3,….,xn అనుకుంటే, mean, standard deviation లను కనుకోవడానికి ఈ కింది సూత్రాలను వాడతాం.

పైన వివరించిన while loopనే ఈ exampleలో కూడా వాడుతున్నాం. అంటే ఎంతమంది విద్యార్థులు ఉంటే అన్ని సార్లు రన్ అయ్యే లూప్ వాడి, ప్రతీ సారీ ఒక విద్యార్థి మార్క్ రీడ్ చేసి దానిని మొత్తం(s) కు, దాని స్క్వేర్ ను
s కు add చేస్తున్నాము. లూప్ లోనుంచి బయటకు వచ్చిన తర్వాత, సరాసరి, standard Deviation కాలిక్యులేట్ చేసి ప్రింట్ చేస్తున్నాం.

#include<stdio.h>
#include<math.h>
int main()
{
     float s=0, ss = 0;
     int n, i, m;
     printf(“Enter number of Students\n”);
     scanf(“%d”, &n);

     i = 0;
     while(i<n){
     printf(“Enter a student mark\n”);
     scanf(“%d”, &m);
     s = s + m;
     ss = ss + m*m;
     i++;
     }
     s=s/n;
     ss=sqrt((ss/n)-(s*s));
     printf(“Mean=%f Standard Deviation=%f\n”, s, ss);
     return (0);
}
పైన ఇచ్చిన ప్రోగ్రం రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా ఉంటుంది.

     
     

Example 6: ఈ ప్రోగ్రాం తరగతిలో ఎంత మంది విద్యార్థులు ఉన్నారో రీడ్ చేసి, వారి మార్కులను రీడ్ చేసి, largest and the second largest మార్కులను ప్రింట్ చేయడానికి ఉద్దేశించినది.

Solution: ఇందులో కూడా విద్యార్థులు ఎంత మంది ఉంటే అన్ని సార్లు రన్ అయ్యే లూప్ వాడి, ప్రతీ సారీ ఒక విద్యార్థి మార్క్(m) రీడ్ చేస్తాం. ముందుగా m max1, max2 అనే రెండింటిని తీసుకొని max1కు ముందుగా సున్నా ఇస్తాం. మనం తీసుకొన్న విద్యార్థి మార్క్(m) max1 కంటే ఎక్కువ అయితే max1 విలువను max2కు ఇచ్చి, ప్రస్తుతం తీసుకొన్న విద్యార్థి మార్క్(m)ను max1 ఇస్తాం. లేకపోతే ప్రస్తుతం తీసుకొన్న విద్యార్థి మార్క్(m) max2 కంటే ఎక్కువ అయితే దానిని max2కు ఇస్తాం. తీసుకొన్న ప్రతీ విద్యార్థి మార్కుల తో ఈ విధంగా చేస్తాం. లూప్ లోనుంచి బయటకి వచ్చిన తర్వాత, max1, max2లను ప్రింట్ చేస్తాం.

#include<stdio.h>
int main()
{
     int n,i,m,max1=0,max2;
     printf(“Enter number of students\n”);
     scanf(“%d”, &n);

     i = 0;
     while(i<n){
     printf(“Enter next student mark\n”);
     scanf(“%d”, &m);
     if(m>max1){
     max2 = max1;
     max1=m;
     }
     else if(m>max2&&m<max1) max2=m;
     i++;
     }
     printf(“Highest=%d Second Highest=%d\n”, max1, max2);
     return (0);
}
పైన ఇచ్చిన ప్రోగ్రాం రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా వుంటుంది.
     

Example 7: ఈ ప్రోగ్రాం ఒక nteger ‘n’ ను రీడ్ చేసి దానికి సంబంధించిన ఎక్కము ప్రింట్ చేస్తుంది. ఉదాహరణకు, 7 ఇస్తే, ఏడో ఎక్కము కింద ఇచ్చిన విధముగా ప్రింట్ చెయ్యాలి.

          7 X 1=7
          7 X 2=14
          7 X 3=21
          --------
          --------
          7 X 20=140

Solution: పైన రావల్సిన ఫలితాన్నిచూస్తే మనకు ఒక విషయం అర్థమవుతుంది. అదేమిటంటే, 1 నుంచి 20 దాకా మారే ఒక లూప్ కావాలని. దానిని వాడుకొని కింద ఇచ్చిన ప్రోగ్రాం రాద్దాం.

#include<stdio.h>
int main()
{
     int n, i;
     printf(“Enter an integer whose multiplication table is needed\n”);
     scanf(“%d”, &n);

     i=1;
     while(i<=20){
     printf(“%d X %d = %d\n”, n, i, n*i);
     i++;
     }
     return (0);
}
పైన ఇచ్చిన ప్రోగ్రాం రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా వుంటుంది.
     

Example 8: ఈ ప్రోగ్రాం ఒక integer (n)ను రీడ్ చేసి దాని factorial విలువను లెక్కిస్తుంది.
Solution: ఒక integer (n) factorial value అనగా: 1x2x3x…xn. అంటే, ఇక్కడ కూడా 1 నుంచి n దాకా మారే ఒక లూప్ కావాలి. దానిని వాడుకొని కింద ఇచ్చిన ప్రోగ్రాం రాద్దాం.
#include<stdio.h>
int main()
{
     int n, i, f ;
     printf(“Enter an integer\n”);
     scanf(“%d”, &n);
     f=1;
     i=1;
     while(i<=n){
     f = f*i;
     i++;
     }
     printf(“Factorial Value of %d=%d\n”,n, f);
     return (0);
}
పైన ఇచ్చిన ప్రోగ్రామును రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా ఉంటుంది.
     

Example 9: ఈ ప్రోగ్రాం ఒక integer (n)ను రీడ్ చేసి దానిలో ఉండే సంఖ్యల మొత్తంను లెక్కిస్తుంది.
Solution: ఒర పూర్ణ సంఖ్యకు 10 తో modulus operator అప్లై చేస్తే ఆఖరి సంఖ్య వస్తుంది, అదే 10తో divide చేస్తే ఆఖరి సంఖ్య తీసేయగా మిగిలిన పూర్ణసంఖ్య వస్తుంది. ఉదాహరణకు, 1889 కు 10తో modulus operator అప్లై చేస్తే 9 వస్తుంది, అదే 10తో divide చేస్తే 188 వస్తుంది. ఇదే లాజిక్ ను 188 మీద అప్లై చేస్తే 8 మరియ 18 వస్తాయి. ఇలా, ప్రతీసారి ఓ డిజిట్ ను లాగి మొత్తానికి కలుపుతాం. ఇక్కడ, while(n) అనే లూప్ యొక్క కండిషను, విలువ సున్నా అయ్యేంత వరకు ట్రూ అవుతుంది.
#include<stdio.h>
int main()
{
     int n, s=0, dig;
     printf(“Enter a integer\n”);
     scanf(“%d”, &n);

     while(n){
     dig = n%10;
     s = s + dig;
     n = n/10;
     }
     printf(“%d\n”, s);
     return (0);
}
ఈ కింది పట్టిక ద్వారా ఈ ప్రోగ్రాంను step-by-step పరిశీలించి చేస్తే మనకు ఇది ఎలా పనిచేస్తుందో అర్ధమవుతుంది.

     
పైన ఇచ్చిన ప్రోగ్రాం రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా ఉంటుంది.
     

1.1 The break statement
ఈ break statement ను వాడి మనం ఎప్పుడైనా లూప్ లోనుంచి బయటకు రావచ్చు. దీనిని వేరే లూప్ లలో కూడా వాడవచ్చు.

Example 10: ఈ ప్రోగ్రాం ఒక integer (n)ను రీడ్ చేసి అది ప్రధాన సంఖ్యా (Prime number) కాదా ప్రింట్ చేస్తుంది.
Solution: ప్రధాన సంఖ్య అనాలి అంటే అది 1 మరియూ దాని చేత మాత్రమే divide అవ్వాలి. వేరే ఏ నంబరూ దానిని divide చెయ్యకూడదు. అందుకని 2 నుంచి మనం ఇచ్చిన సంఖ్య లోపల ఉండే ప్రతీ సహజ సంఖ్యను తీసుకొని అది ఇచ్చిన సంఖ్యను divide చేస్తుందా అని ఓ లూప్ ద్వారా టెస్ట్ చేస్తాం. ఏదయినా సహజసంఖ్య మనం ఇచ్చిన సంఖ్య divide చేస్తే break statement ను వాడి లూప్ లోనుంచి బయటకు వచ్చి, అది ప్రధాన సంఖ్య కాదు అని ప్రింట్ చేస్తాం. ఆదే మామూలుగా లూప్ లోనుంచి బయటకు వస్తే అది ప్రధానసంఖ్య (Prime number).

#include<stdio.h>
int main()
{
     int i, n;
     printf(“Enter an integer\n”);
     scanf(“%d”, &n);
     i=2;
     while(i<n){
     if(n%i==0) break;
     i++;
     }

     (i==n)?printf(“ప్రధాన Number\n”): printf(“Not a ప్రధాన number\n”);
     return (0);
}
పైన ఇచ్చిన ప్రోగ్రాం రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా ఉంటుంది.

     

1.2. The exit function
ఇది standard library లోని ఒక function. దీనిని call చేస్తే program లోనుంచి బయటకు వస్తాం. దానినే ప్రోగ్రాం టెర్మినేట్ చేయడం అని అనవచ్చు. దీనికి మనం ఒక integerను argument లాగా ఇవ్వాలి.
పై ప్రోగ్రాంను ఈ exit function వాడి కింది విధముగా రాయవచ్చు.
#include<stdio.h>
int main()
{
     int i, n;
     printf(“Enter an integer\n”);
     scanf(“%d”, &n);
     i=2;
     while(i<n)
     {
     if(n%i==0)
     {
     printf(“Not a ప్రధాన number\n”);
     exit(-1);
     }
     i++;
     }
     printf(“ప్రధాన number\n”);
     return (0);
}
పైన ఇచ్చిన ప్రోగ్రాం రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా ఉంటుంది.
     

1.3 Continue Statement
ఈ “continue” statement ను while loop లో వాడితే దీని తర్వాత ఉండే statements ను execute చేయకుండా లూప్ కంట్రోలు కండిషన్ చెకింగుకు వెళుతుంది. దీనిని వేరే లూప్ లలో కూడా వాడవచ్చు.

Example 11: ఈ ప్రోగ్రాంలో “continue” statement ను while loop లో వాడితే ఏమవుతుందో చూద్దాం. ఇక్కడ ఒక infinite loop( while(1)), అనే దానిని వాడాం. దీనిలో ప్రతీ సారి ఓ సంఖ్య రీడ్ అవుతుంది. కాబట్టి 0 అయితే లూప్ లోనుంచి break statement ను వాడి బయటకు వచ్చేస్తాం. ఇది కాబట్టి బేసి సంఖ్య అయితే “continue” statement ను వాడి next iterationకు వెళుతుంది. లేకపోతే ఇచ్చిన సంఖ్యను s కు add అవుతుంది. అలా ఈ ప్రోగ్రాం 0 ఇచ్చే లోపల మనం ఇచ్చిన సరి సంఖ్యల మొత్తాన్ని కనుక్కొని, వాటి సరాసరిని ప్రింట్ చేస్తుంది.
#include<stdio.h>
int main()
{
     int n=0, s=0, m;
     while(1)
     {
     printf(“Enter a student mark\n”);
     scanf(“%d”, &m);
     if(m==0) break;
     else if(m%2) continue;
     s=s+m;
     n++;
     }
     printf(“%d\n”, s/n);
     return (0);
}
పైన ఇచ్చిన ప్రోగ్రామును రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా ఉంటుంది.
     

1.4. Nested While Loops
మనం while loopలోపల while loopలను వాడవచ్చు. వీటిని nested while loops అని అంటారు.

Example 12: ఈ ప్రోగ్రాం nested while loops వాడటము ఎలాగో చూపిస్తుంది.
#include<stdio.h>
int main()
{
     int i,j,n;
     printf("Enter a positive Integer\n");
     scanf("%d", &n);
     i=1;
     while(i<=n)
     {
     j=1;
     while(j<=i){
     printf(“%d”, j);
     j++;
     }
     printf(“\n”);
     i++;
     }
     return 0;
}

Output:
1
12
123
ఈ కింది పట్టిక ద్వారా ఈ ప్రోగ్రాంను కూడా step-by-step పరిశీలించి చేస్తే మనకు ఇది ఎలా పనిచేస్తుందో అర్ధమవుతుంది.

     

పైన ఇచ్చిన ప్రోగ్రామును రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా ఉంటుంది.
     

2 The do-while Loop
C లాంగ్వేజీలో do-while loop అనే మరొక లూప్ కూడా ఉంది. దీని execution flow ఈ కింద ఇచ్చిన బొమ్మలో చూడవచ్చు. ఇది ముందు బ్లాక్ ను రన్ చేసి ఆ తర్వాత కండిషను (EXPR) చెక్ చేస్తుంది. అది ట్రూ అయితే మరలా బ్లాక్ ను రన్ చేస్తుంది, ఫాల్స్ అయితే లూప్ లోనుంచి బయటకు, అనగా Statementకు వస్తుంది. దీనికీ, ఇంతకు ముందు లూప్ కు ముఖ్యమైన తేడా ఏమిటంటే, ఇది బ్లాక్ ను ఒక్కసారైనా రన్ చేస్తుంది. ఇందులో కూడా మనం break, continue statement లు వాడవచ్చు.

     
Example 13: ఈ కింది ప్రోగ్రాం do-while loop ఎలా పని చేస్తుందో చూపిస్తుంది.

#include<stdio.h>
int main()
{
     int i, n;
     printf(“Enter a value for n\n”);
     scanf(“%d”, &n);
     i=0;
     do{
     printf(“%d\n”, i);
     i++;
     }
     while(i<n);
     return (0);
}

ఈ కింది పట్టిక పై ప్రోగ్రాంను trace చేయగా వచ్చింది.
     
పైన ఇచ్చిన ప్రోగ్రామును రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా ఉంటుంది.

     

Example 14: ఈ కింది ప్రోగ్రాం, 0-100 లోపల ఉన్న సంఖ్య ఇస్తేనే లూప్ లోపలనుంచి బయటకు వచ్చేవిధంగా రాసింది.
#include<stdio.h>
int main()
{
     int n;
     do
     {
     printf(“Enter a number between 0-100\n”);
     scanf(“%d”, &n);

     }
     while(n<0 || n>100);
     printf(“Number Entered=%d\n”, n);
     return (0);
}
పైన ఇచ్చిన ప్రోగ్రామును రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా ఉంటుంది.

     

3. The FOR Loop

C లాంగ్వేజీలో ఉన్న మరొక ముఖ్యమైన లూప్ ఇది. దీనికీ while లూప్ కు ఏ తేడా లేదు. ఇందులో, initialization statements, condition statements, modifier statements, అన్నింటినీ ఒక దగ్గర, అంటే ఒక లైనులో రాస్తాం. అందుచేత ప్రోగ్రాం సులభంగా అర్ధమవుతుంది. ఈ కింద,లూప్ execution trace చూపించాం. ఇక్కడ కూడా లూప్ బ్లాక్, EXPR2 ట్రూ గా ఉన్నంత వరకు రన్ అవుతుంది, అది ఫాల్స్ అయితే లూప్ లోనుంచి బయటకు అంటే Statement కు వస్తాం.
     
ఇందులో, EXPR1, EXPR2, EXPR3 లు కామాలతో ఉన్న statementలు లేదా empty statementలు కూడా కావచ్చు. ఈ కింద ఇచ్చినది infinite లూప్ లా పని చేస్తుంది.
for( ; ; )
{
}
Example 15: ఈ కింది ప్రోగ్రాం for loop ఎలా పని చేస్తుందో చూపిస్తుంది.
#include<stdio.h>
int main()
{
     int i, n;
     printf(Enter an integer\n”);
     scanf(“%d”, &n);
     for(i=0; i<n; i++){
     printf(“%d\n”, i);
     }
     return (0);
}
ఈ కింది పట్టిక ద్వారా పై ప్రోగ్రాంను step-by-step ట్రేస్ చేద్దాం.

     
పైన ఇచ్చిన ప్రోగ్రాంను రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా ఉంటుంది.
     

Example 16: ఈ ప్రోగ్రాం ఒక integer (n)ను రీడ్ చేసి దాని factorial విలువను లెక్కిస్తుంది. ఇది అంతకు ముందు చేసినదే. కానీ ఇక్కడ for loop వాడాం.ఇక్కడ ప్రోగ్రాం చిన్నదిగా ఉంది.
#include<stdio.h>
int main()
{
     int i, n, F;
     printf(“Enter an integer\n”);
     scanf(“%d”, &n);

     for(F=1, i=1; i<=n; i++) F = F*i;

     printf(“Factorial Value oof %d=%d\n”,n, F);
     return (0);
}
పైన ఇచ్చిన ప్రోగ్రాంను రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా ఉంటుంది.

     

Example 17: ఈ ప్రోగ్రాం curve యొక్క heightను ‘n’ unitly spaced points దగ్గర రీడ్ చేసి curve కింద ఉన్న area ను trapezoidal rule వాడి లెక్కిస్తుంది.
Formula: (h/2)[Y1 + Yn + 2( Y2 +Y3 + …….. + Yn-1)] (Here, h value is taken as 1)
          
Solution: ముందు మొదటి, ఆఖరి points దగ్గర height రీడ్ చేస్తాం. ఆ తర్వాత, n-2 సార్లు రన్ అయ్యే ఒక లూప్ రాసి, ప్రతీసారి ఒక point height రీడ్ చేసి, మొత్తానికి కలుపుతాం. లూప్ లోనుంచి బయటకు వచ్చిన తర్వాత, ఫార్ములా వాడి areaను trapezoidal rule వాడి లెక్కిస్తాం.

#include<stdio.h>
int main()
{
     float y1, yn, y, area = 0;
     int i,n;
     printf(“Enter number of points\n”);
     scanf(“%d”, &n);
     printf(“Enter first point height\n”);
     scanf(“%f”,&y1);
     for(i=0;i<n-2;i++)
     {
     printf(“Enter next point height \n”);
     scanf(“%f”, &y);
     area += y;
     }
     printf(“Enter last point height\n”);
     scanf(“%f”, &yn);
     area = 0.5*(y1+yn+(2*area));
     printf(“Area=%f”, area);
     return (0);
}
పైన ఇచ్చిన ప్రోగ్రాంను రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా ఉంటుంది.

     

Example 18: ఈ ప్రోగ్రాం కూడా curve heightను ‘n’ unitly spaced points దగ్గర రీడ్ చేసి curve కింద ఉన్న areaను Simpson rule వాడి లెక్కిస్తుంది.
Simpson Formula ప్రకారము
area = (h/3)[Y1 + Yn + 4( Y2 +Y4 + …….. ) + 2 ( Y3 +Y5 + …….. +)]

ఇక్కడ కూడా, ముందు మొదటి, ఆఖరి points దగ్గర height రీడ్ చేస్తాం. ఆ తర్వాత, n-2 సార్లు రన్ అయ్యే ఒక లూప్ రాసి, ప్రతీసారి ఒక point height రీడ్ చేస్తాం. అది సరి index ఉండే point అయితే, దానిని ae కు లేకపోతే ao కు కలుపుతాం. లూప్ లోనుంచి బయటకు వచ్చిన తర్వాత, ఫార్ములా వాడి areaను లెక్కిస్తాం.

#include<stdio.h>
int main()
{
     float y1, yn, y, area = 0, ao=0, ae=0;
     int i,n;
     printf(“Enter number of points\n”);
     scanf(“%d”, &n);

     printf(“Enter first point height\n”);
     scanf(“%f”,&y1);

     for(i=0;i<n-2;i++)
     {
     printf(“Enter next point height \n”);
     scanf(“%f”, &y);
     if(i%2) ao +=y ;
     else ae += y;
     }
     printf(“Enter last point height\n”);
     scanf(“%f”, &yn);
     area = 0.333333*(y1+yn+2*ao + 4* ae);
     printf(“Area=%f”, area);
     return (0);
}
పైన ఇచ్చిన ప్రోగ్రాంను రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా ఉంటుంది.

     

4 Conclusions
ఈ పాఠంలో వివిధ రకాలయిన లూప్ లను ఎలా వాడాలో నేర్చుకున్నాం. ఒక లూప్ ఎలా పని చేస్తుందో తెలుసుకునేందుకు, దానిని పరిశీలించి పట్టిక ఎలా తయారు చెయ్యాలో కూడా నేర్చుకున్నాం.

NB Venkateswarlu
M.Tech(IIT-Kanpur)
Ph.D (BITS),PDF(UK),
Sr.Prof., CSE, AITAM, Tekkali

  • Industry      Interaction

    Higher Education

    Job Skills

    Soft Skills

    Comm. English

    Mock Test

    E-learning