Article

EDP

C & DS

Engg.Chemistry

Engg.Physics



లాజికల్ ఆపరేటర్లను ఎలా ఉపయోగించాలి?
నం ఇంతకు ముందు పాఠంలో ‘సీ’ లాంగ్వేజీలో చాలా ఆపరేటర్లను ఉపయోగించి ప్రోగ్రామ్ లు రాయడం నేర్చుకున్నాం. ఇప్పడు లాజికల్ ఆపరేటర్ల గురించి తెలుసుకొని వాటిని ప్రాక్టికల్ గా ప్రోగ్రామ్ లో ఎలా ఉపయోగించాలో తెలుసుకుందాం.

‘సీ’ లాంగ్వేజీ లో రెండు లాజికల్ ఆపరేటర్లు ఉన్నాయి. అవి, లాజికల్ AND, లాజికల్ OR. వాటి సింబల్స్ &&, ||. ఇవి రెండూ కూడా బైనరీ ఆపరేటర్లు. అంటే వాటికి రెండు ఆపరాండ్స్ ఉంటాయి. అవి, వేరియబుల్స్ అయినా, కాన్ స్టెంట్ లు అయినా, e expressions అయినా కావచ్చు; ఏ టైపువి అంటే integer, float అయినా కావచ్చు.

రెండూ ఆపరాండ్ లు ట్రూ అయితే లాజికల్ AND ఫలితం ట్రూ (సత్యం) అవుతుంది. లేకపొతే ఫాల్స్ (అసత్యం) అవుతుంది. అలాగే, రెండూ ఆపరాండ్ లలో ఏ ఒక్కటి అయినా ట్రూ అయితే లాజికల్ OR ఫలితం ట్రూ అవుతుంది. లేకపొతే ఫాల్స్ అవుతుంది.
IIఈ క్రింది టేబుల్ చూడండి. ఇక్కడ, A, B లు రె0డు ఆపరాండ్ లు


ఇక్కడ మనం ఇంతకు ముందు తెలుసుకున్న విషయాన్ని గుర్తు తెచ్చుకోవాలి. ఏ పాజిటివ్ వాల్యూ అయినా నెగటివ్ వాల్యూ అయినా ట్రూ లాగా తీసుకుంటుంది, సున్నా అంటే ఫాల్స్ లాగా తీసుకుంటుంది.

ముందు పాఠంలో, మనం రెండు కండిషనులు జాయిన్ చేయడానికి *, + లు ఉపయోగించి రాశాం. ఇప్పుడు వాటి బదులు లాజికల్ AND, లాజికల్ OR లు వాడవచ్చు. నిజానికి, లాజికల్ ఎక్స్ ప్రెష్ నులలో లాజికల్ AND, లాజికల్ OR లు *, + వాడవచ్చు. కానీ, arithmetic ఎక్స్ ప్రెష్ నులలో *, + laలలో లాజికల్ AND, లాజికల్ OR లు వాడలేం.

ఉదాహరణ 1
ఈ కింది ప్రోగ్రామ్, పైన చెప్పిన దానిని ప్రదర్శిస్తుంది. మనం, కింద ఇచ్చిన స్క్రీన్ లను కూడా గమనించవచ్చు. మనం, 10, 70 ఇస్తే *, లాజికల్ AND, రెండూ కూడా Yes అని ప్రింట్ చేశాయి. అదే, 0, 70 *, లాజికల్ AND, రెండూ కూడా No అని ప్రింట్ చేశాయి. అంటే, రె0డూ లాజికల్ గా ఒకే లాగా పని చేస్తున్నాయి. కానీ, c, d వాల్యూస్ చూస్తే ఒకటి కాదు. అంటే, రెండూ arithmetic గా ఒకటి కాదు.
#include<stdio.h>
int main()
{
     int a,b,c,d;
     printf("Enter two integers\n");
     scanf("%d%d",&a,&b);
     (a&&b )?printf("Yes\n"):printf("No\n");
     (a*b)?printf("Yes\n"):printf("No\n");
     c=a*b;
     d=a&&b;
     printf("c=%d\td=%d\n",c,d);
   return 0;
}


ఉదాహరణ 2
ఒక triangle మూడు భుజాల కొలతలు తీసుకొని, అది equilateral triangle అవునా కాదా అని ప్రింట్ చేయడానికి ప్రోగ్రాం ఇది. మనం a,b,c లను మూడు భుజాలు అని అనుకుంటే, మూడు ఒకటే అయితే, Yes అని రావాలి, లేకపోతే No అని రావాలి. మనం, మాథ్స్ లో a=b=c, కాబట్టి equilateral triangle అని రాస్తాం. కానీ, ఇక్కడ మనం మొదటి రెండూ ఒకటేనా అని, తరువాతి రెండూ ఒకటేనా అని చూస్తాం. దీనినే, ఇంకో విధంగా కూడా చేయవచ్చు. అది ముందు పాఠంలో చేశాం. ఇక్కడ లాజికల్ AND వాడి చేస్తున్నాం. ఈ కింది ప్రోగ్రాం పైన చెప్పిన విధంగా పని చేస్తుంది.
#include<stdio.h>
int main()
{
     float a, b, c;
     printf("Enter three sides of a traingle\n");
     scanf("%f%f%f", &a,&b, &c);
     ( ( a==b) && (a==c)) ? printf("Yes\n"):printf("No\n");
   return 0;
}
పై ప్రోగ్రాంను రన్ చేస్తూ వివిధ రకాలైన ఇన్ పుట్ లు ఇస్తే ఏమవుతుందో ఈ కింది స్క్రీన్ లు చూపిస్తాయి.

ఉదాహరణ 3
మూడు integers ను ఇన్ పుట్ లాగా తీసుకొని వాటిలో maximum వాల్యూను ప్రింట్ చేయడానికి ఈ ప్రోగ్రాం రాశాం. దీనిని ఇంతకు ముందే సాల్వ్ చేశాం. ఇప్పుడు ఇంకో రకంగా చేద్దాం.
ముందు, మొదటి నంబరు మిగతా రెండింటికన్నా పెద్దదా కాదా అని చెక్ చేస్తాం. పెద్దది అయితే, దానినే మూడింటిలోకెల్లా పెద్దది అని అంటాం. లేకపోతే, మిగతా రెండింటిలో పెద్దదాన్నే మూడింటిలోకెల్లా పెద్దది అని అంటాం.
#include<stdio.h>
int main()
{
     int a,b,c;
     printf("Enter three numbers\n");
     scanf("%d%d%d", &a,&b,&c);
     ( (a>b)&& (a>c) ) ? printf("%d\n",a):printf("%d",(b>c?b:c) );
   return 0;
}
పై ప్రోగ్రాంను రన్ చేస్తూ ఇన్ పుట్ ఇస్తే ఏమవుతుందో ఈ కింది స్క్రీన్ చూపిస్తుంది.

ఉదాహరణ 4
ఈ ప్రోగ్రాం, సంవత్సరం నంబర్ ను ఇన్ పుట్ లాగా తీసుకొని అది లీప్ సంవత్సరం అవునా కాదా అని చెబుతుంది. ఒక సంవత్సరం లీప్ సంవత్సరం కావాలి అంటే, ఈ కింది వాటిలో ఏదో ఒకటి ట్రూ (సత్యం) కావాలి.
1. 400 తో ఆ ఇన్ పుట్ divide కావాలి.
2. 4 తో అది divide కావాలి, ఇంకా 100 తో divide కాకూడదు.
దీనిని మనం ముందు పాఠంలో కూడా చేశాం. మనం మొదట రెండు లాజికల్ expressions మధ్యలో OR వాడాలి. అలాగే, రెండో దానిలో ఉండే రెండు లాజికల్ expressions మధ్యలో AND వాడాలి. ఈ కింద పూర్తి ప్రోగ్రాం ఇచ్చాం.
#include<stdio.h>
int main()
{
     int y;
     printf("Enter year number\n");
     scanf("%d", &y);
     ( ( y%400==0) || ( (y%4==0) && ( y%100!=0) ) ) ? printf("Yes\n"):printf("No\n");
   return 0;
}
పై ప్రోగ్రాంను రన్ చేస్తూ వివిధ రకాలైన ఇన్ పుట్ లు ఇస్తే ఏమవుతుందో ఈ స్క్రీన్ లు చూపిస్తాయి.


ఉదాహరణ 5
ఈ ప్రోగ్రాంలో ఒక విద్యార్థికి సంబంధించిన అయిదు పరీక్షల మార్కులను ఇన్ పుట్ గా తీసుకొని అతడు పాసయ్యాడా లేదా ఫెయిల్ అయ్యాడా చెప్పాలి.
పాస్ అవ్వాలి అంటే, ప్రతి టెస్ట్ లో 35 రావాలి. దీనిని మనం యింతకు ముందు పాఠంలో చేశాం. ఇప్పుడు దీనిని ఇంకో రకంగా చేస్తున్నాం. మొత్తం మీద పాస్ అవ్వాలి అంటే, మొదటి టెస్ట్ లో 35 కన్నా ఎక్కువ రావాలి, రెండో దానిలో కూడా 35 కన్నా ఎక్కువ రావాలి. అలాగే ప్రతి టెస్ట్ లో 35 కన్నా ఎక్కువ రావాలి. దానినే, && వాడి కింద విధంగా రాశాం. అంటే, ప్రతి టెస్ట్ లో 35 వచ్చాయా లేదా అని చూసే లాజికల్ expressions మధ్యలో && వాడాం.
#include<stdio.h>
int main()
{
     int a,b,c,d,e;
     printf("Enter a student marks in five tests\n");
     scanf("%d%d%d%d%d",&a,&b,&c,&d,&e);
     ((a>=35) && (b>=35) && (c>=35) && ( d>=35) && (e>=35) )? printf("Passed\n"): printf("Failed\n");
   return 0;
}
పై ప్రోగ్రాంను రన్ చేస్తూ వివిధ రకాలైన ఇన్ పుట్ లు ఇస్తే ఏమవుతుందో ఈ కింది స్క్రీన్ లు చూపిస్తాయి.

ఉదాహరణ 6
ఒక triangle మూడు భుజాల కొలతలు తీసుకొని, అది right angled triangle అవునా కాదా అని ప్రింట్ చేసే ప్రోగ్రాం ఇది. మనం మూడు భుజాలను a, b, c లు అని అనుకొంటే, Eఏ రెండూ భుజాల squares మొత్తం మూడో దాని square కు సమానం అయితే, అది right angled triangle అవుతుంది. అంటే, మనం మూడు combinations ను చెక్ చేయాలి. అవి, a2+b2==c2, a2+c2==b2, b2+c2==a2. ఇలా చేసేటప్పుడు రెండు రిలేషనల్ ఎక్సఫ్రెషనుల మధ్యలో || పెడతాం. ఈ ప్రోగ్రాంను ముందు పాఠంలో ఇంకో విధంగా + వాడి చేసాం.

#include<stdio.h>
int main()
{
     float a, b, c;
     printf("Enter three sides of a traingle\n");
     scanf("%f%f%f", &a,&b, &c);
     a*=a;
     b*=b;
     c*=c;
     ( ((a+b)==c) || ((a+c)==b) || ( (b+c)==a) ) ? printf("Yes\n"):printf("No\n");
   return 0;
}

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

లాజికల్ AND ను ఎవాల్యుయేట్ చేస్తున్నప్పుడు, మొదటి ఆపరాండ్ ఫాల్స్ అయితే రెండో దానిని ఎవాల్యుయేట్ చేయదు. ఎందుకంటే, రెండోది ట్రూ అయినా ఫాల్స్ అయినా ఫైనల్ రిజల్ట్ ఫాల్స్ కాబట్టి. అలాగే, లాజికల్ OR ను ఎవాల్యుయేట్ చేస్తున్నప్పుడు, మొదటి ఆపరాండ్ ట్రూ అయితే రెండో దానిని ఎవాల్యుయేట్ చేయదు. ఎందుకంటే, రెండోది ట్రూ అయినా ఫాల్స్ అయినా ఫైనల్ రిజల్ట్ ట్రూ కాబట్టి.

ఉదాహరణ 7
పైన చెప్పిన పాయింట్ ను ప్రాక్టికల్ గా చూపించడానికి ఈ ప్రోగ్రాం ఇచ్చాం. ఈ ప్రోగ్రాంలో కూడా, ఒక విద్యార్థికి సంబంధించిన అయిదు సబ్జెక్టుల మార్కులు తీసుకొని, అతడు పాసయ్యాడా లేదా ఫెయిల్ అయ్యాడా చెప్పాలి. అంతే కాకుండా అతడి మొత్తం మార్కులు ప్రింట్ చేయాలి. ఇక్కడ కూడా పాస్ అవ్వాలి అ0టే, ప్రతి టెస్ట్ లో 35 మార్కులు రావాలి. మొత్తం మీద పాస్ అవ్వాలి అంటే, మొదటి టెస్ట్ లో 35 కన్నా ఎక్కువ రావాలి, రెండో దానిలో కూడా 35 కన్నా ఎక్కువ రావాలి. అలాగే ప్రతి టెస్ట్ లో 35 కన్నా ఎక్కువ రావాలి. దానినే, && వాడి పై ఉదాహరణలాగానే కింది విధంగా రాశాం. అంటే, ప్రతి టెస్ట్ లో 35 వచ్చాయా అని చూసే లాజికల్ expressions మధ్యలో && వాడాం. ఆఖరున (s=a+b+c+d+e) అనే దానిని కూడా వాడాం. దీన్ని ఎప్పుడు ఎవాల్యూయేట్ చేస్తుందంటే, ముందు ఉన్న అన్ని లాజికల్ AND ఆపరేటర్లు ట్రూ అయితే. లేకపొతే s వాల్యూ ముందుగా ఇచ్చిన సున్నా లాగా ఉంటుంది.
#include<stdio.h>
int main()
{
     int a,b,c,d,e,s=0;
     printf("Enter a student marks in five tests\n");
     scanf("%d%d%d%d%d",&a,&b,&c,&d,&e);
     ((a>=35) && (b>=35) && (c>=35) && ( d>=35) && (e>=35)&&(s=a+b+c+d+e) )? printf("Passed\n"): printf("Failed\n");
     printf("Total=%d\n",s);

   return 0;
}
ఈ స్ర్రీన్ మనం మార్కులు 80, 90, 90, 90, 80 ఇస్తే ఏమవుతుందో చూపిస్తుంది. అన్నీ 35 కన్నా ఎక్కువ కాబట్టి, అంటే లాజికల్ AND లు అన్నీ ట్రూలు. కాబట్టి మొత్తాన్ని లెక్కించి ప్రింట్ చేస్తుంది.

అదే మనం, 90, 80, 30, 70, 90 ఇస్తే టోటల్ సున్నా ఇస్తుంది. ఎందుకంటే, మూడో లాజికల్ AND ఫాల్స్ కాబట్టి. తర్వాత ఉండే వాటిని ఎవాల్యూయేట్ చేయదు.

#include<stdio.h>
int main()
{
     int a,b,c,d,e,s=0;
     printf("Enter a student marks in five tests\n");
     scanf("%d%d%d%d%d",&a,&b,&c,&d,&e);
     ((a>=35) && (b>=35) && (c>=35) && ( d>=35) && (e>=35)&&(s=a+b+c+d+e) )? printf("Class %d\n", (4-(s>=360)-(s>=250)-(s>=175) ) ): printf("Failed\n");

   return 0;
}

ఉదాహరణ 8
ఈ ప్రోగ్రాంలో కూడా ఒక విద్యార్థి కి సంబంధించిన అయిదు సబ్జెక్టుల మార్కులు తీసుకొని, పాస్ అయితే ఏ క్లాసో ప్రింట్ చేయాలి. ఈ కింది రూల్స్ ఫాలో అవ్వాలి. ఇక్కడ కూడా పాస్ అవ్వాలి అంటే, ప్రతీ టెస్ట్ లో కనీసం 35 మార్కులు రావాలి.

ఈ కింది ప్రోగ్రాం, మనకు కావాల్సిన రిజల్ట్ ఇస్తుంది. ఇక్కడ పైన వాడిన లాజిక్ వాడాం. అదనంగా, ఏ క్లాసో చెప్పడానికి ఇంకో లాజిక్ వాడాం. మీరు ఆనాలిసిస్ చేస్తే ఇది ఎలా పని చేస్తుందో తెలుస్తుంది.
#include<stdio.h>
int main()
{
     int a,b,c,d,e,s=0;
     printf("Enter a student marks in five tests\n");
     scanf("%d%d%d%d%d",&a,&b,&c,&d,&e);
     ((a>=35) && (b>=35) && (c>=35) && ( d>=35) && (e>=35)&&(s=a+b+c+d+e) )? printf("Class %d\n", (4-(s>=300)-(s>=250)-(s>=175) ) ): printf("Failed\n");

   return 0;
}

ఈ కింది స్క్రీన్ లు ఈ ప్రోగ్రాం ఎలా పని చేస్తుందో చూపిస్తాయి. ఇచ్చిన వాల్యూస్ అన్నీ 35 కన్నా ఎక్కువ కాబట్టి మొత్తం 450 అవుతుంది. అప్పుడు, (4-(s>=300)-(s>=250)-(s>=175) ) అనేది ( 4- (450>=300) – ( 450>=250) –(4>=175)) లాగా అవుతుంది. అది, (4-1-1-1)=1 లాగా అవుతుంది. కాబట్టి మనకు, Class 1 అని స్క్రీన్ మీద వస్తుంది.

దీంతో ఈ పాఠం ద్వారా లాజికల్ AND, OR అనే ఆపరేటర్లను వాడి ప్రోగ్రాంలు రాయడం నేర్చుకున్నాం.

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