ఈ రిలేషనల్ ఆపరేషన్లు చాలా ఉపయోగకరంగా ఉన్నాయి. కానీ ఒక వేరియబుల్ మరొకదాని కంటే పెద్దదా లేదా చిన్నదా అని మాత్రమే కాకుండా, దాని విలువను పొందడానికి కూడా మనం తెలుసుకోవలసిన సందర్భాలు ఉన్నాయి. ఇది 'if' స్టేట్‌మెంట్‌లు మరియు సాధారణ రిలేషనల్ ఆపరేషన్‌లతో సులభంగా చేయబడినప్పటికీ, C లాంగ్వేజ్ రెండు వేరియబుల్స్ మధ్య గరిష్ట లేదా కనిష్ట విలువను అందించే ఫంక్షన్‌లతో మాక్రోలను కూడా అందిస్తుంది.
ఈ Linuxhint కథనంలో, మీరు రెండు వేరియబుల్స్ యొక్క కనీస విలువను కనుగొనడానికి మాక్రో MIN()ని ఎలా ఉపయోగించాలో నేర్చుకుంటారు. మేము మీకు సింటాక్స్, కాలింగ్ పద్ధతి మరియు అది ఆమోదించే డేటా రకాన్ని చూపుతాము. తర్వాత, ఇది ఎలా పని చేస్తుందనే దానిపై మేము వివరణను పరిశీలిస్తాము మరియు ఈ మాక్రో వర్తించే వ్యక్తీకరణ మరియు సూత్రాన్ని సమీక్షిస్తాము.
మేము మాక్రో MIN()కి ఇన్‌పుట్‌లుగా వివిధ డేటా రకాలతో కనిష్టాన్ని ఎలా కనుగొనాలో చూపించే కోడ్ స్నిప్పెట్‌లు మరియు చిత్రాలను కలిగి ఉన్న ఆచరణాత్మక ఉదాహరణలో నేర్చుకున్న వాటిని వర్తింపజేస్తాము.
సి భాషలో MIN() మాక్రో యొక్క సింటాక్స్
MIN ( a , బి )సి భాషలో MIN() మాక్రో యొక్క వివరణ
మాక్రో MIN() 'a' మరియు 'b' వేరియబుల్స్ మధ్య కనిష్ట విలువను అందిస్తుంది. మాక్రో MIN() ద్వారా ప్రదర్శించబడే వ్యక్తీకరణ నిజమైన/తప్పు పరిస్థితి, ఇక్కడ 'a' మరియు 'b' వేరియబుల్స్ మధ్య రిలేషనల్ ఆపరేషన్ '<' వర్తించబడుతుంది. “a” “b” కంటే తక్కువగా ఉంటే, “a” అందించబడుతుంది. “b” “a” కంటే తక్కువగా ఉంటే, “b” తిరిగి ఇవ్వబడుతుంది.
#నిర్వచించండి MIN(a,b) (((a)<(b))?(a):(b))
మాక్రో MIN() దాని ఇన్‌పుట్‌లు మరియు అవుట్‌పుట్‌లలోని అన్ని డేటా రకాలతో పని చేస్తుంది, రెండు ఇన్‌పుట్ వేరియబుల్స్ తప్పనిసరిగా సంఖ్యా విలువలుగా ఉండాలి.
ఈ మాక్రో 'sys' ఫోల్డర్‌లోని 'param.h' హెడర్‌లో నిర్వచించబడింది. దీన్ని ఉపయోగించడానికి, మేము దానిని ఈ క్రింది విధంగా మా కోడ్‌లో చేర్చాలి:
#include
మాక్రో MIN()తో రెండు పూర్ణాంకాల వేరియబుల్స్ మధ్య కనిష్టాన్ని ఎలా కనుగొనాలి
ఈ ఉదాహరణలో, మేము ఏకపక్ష విలువను కేటాయించే టైప్ int యొక్క “a” మరియు “b” వేరియబుల్‌లను సృష్టిస్తాము మరియు మాక్రో MIN()కి కాల్ చేయడం ద్వారా కనిష్టాన్ని కనుగొంటాము. మేము printf() ఫంక్షన్‌ని ఉపయోగించి తిరిగి వచ్చిన విలువను అవుట్‌పుట్ చేస్తాము.
దీన్ని చేయడానికి, మేము “stdio.h” మరియు “param.h” హెడర్‌లను చేర్చుతాము మరియు శూన్య రకం యొక్క ప్రధాన() ఫంక్షన్‌ను తెరుస్తాము. దానిలో, మేము 'a' మరియు 'b' పూర్ణాంకాలను నిర్వచించాము మరియు వాటిని యాదృచ్ఛిక విలువతో కేటాయిస్తాము. మేము ఫలితాన్ని నిల్వ చేయడానికి “c” పూర్ణాంకాన్ని కూడా నిర్వచించాము.
అప్పుడు, మేము మాక్రో MIN() అని పిలుస్తాము మరియు “a” మరియు “b”లను ఇన్‌పుట్ ఆర్గ్యుమెంట్‌లుగా మరియు “c”ని అవుట్‌పుట్ ఆర్గ్యుమెంట్‌లుగా పాస్ చేస్తాము. మేము printf() ఫంక్షన్‌కి కాల్ చేయడం ద్వారా తిరిగి వచ్చిన ఫలితాన్ని ప్రదర్శిస్తాము. ఈ ఉదాహరణ కోసం క్రింది కోడ్:
##include
శూన్యం ప్రధాన ( ) {
int a = 32 ;
int బి = 14 ;
int సి ;
సి = MIN ( a , బి ) ;
printf ( ' \n కనిష్టం %i \n ' , సి ) ;
}
తరువాత, మేము ఈ కోడ్ యొక్క సంకలనం మరియు అమలుతో ఒక చిత్రాన్ని చూస్తాము. మనం చూడగలిగినట్లుగా, మాక్రో MIN() ఈ సందర్భంలో “b” విలువను అందిస్తుంది.
మనం డబుల్ టైప్ యొక్క వేరియబుల్స్ ఉపయోగిస్తే అదే జరుగుతుంది.
##include
శూన్యం ప్రధాన ( ) {
రెట్టింపు a = 3 ;
రెట్టింపు బి = 1 ;
రెట్టింపు సి ;
సి = MIN ( a , బి ) ;
printf ( ' \n కనిష్ట డబుల్స్ a మరియు b %f \n ' , సి ) ;
}
ఫ్లోటింగ్ పాయింట్ వేరియబుల్స్‌తో కనిష్ట మరియు గరిష్టం
స్థూల MIN() అనేది ఒక ఉపయోగకరమైన ఫంక్షన్, కానీ ఫ్లోటింగ్ పాయింట్ విలువలను ఉపయోగించే వేరియబుల్స్ కోసం దీని ఉపయోగం సిఫార్సు చేయబడదు. ఈ రకమైన కనీస విలువలను కనుగొనడానికి, గణిత లైబ్రరీ 'math.h' హెడర్‌లో నిర్వచించబడిన ఫంక్షన్‌ల సమితిని అందిస్తుంది. ఈ సెట్‌లో fmin(), fminf(), మరియు fminl() ఫంక్షన్‌లు ఉంటాయి. ఈ ఫంక్షన్లలో ప్రతిదాని కోసం క్రింది వాక్యనిర్మాణాన్ని చూద్దాం:
రెట్టింపు fmin ( రెట్టింపు x , రెట్టింపు మరియు ) ;తేలుతుంది fminf ( తేలుతుంది x , తేలుతుంది మరియు ) ;
పొడవు రెట్టింపు fminl ( పొడవు రెట్టింపు x , పొడవు రెట్టింపు మరియు ) ;
fmin() ఫంక్షన్ ఫ్లోటింగ్ పాయింట్‌తో టైప్ డబుల్ (8 బైట్లు) డేటాపై పనిచేస్తుంది. fminf() ఫంక్షన్ టైప్ ఫ్లోట్ (4 బైట్లు) డేటాతో పని చేస్తుంది, అయితే fminl() టైప్ లాంగ్ డబుల్ (16 బైట్లు) డేటాతో పనిచేస్తుంది. అలాగే, ఈ విధులు సంఖ్యేతర విలువలను (NaN) ప్రాసెస్ చేస్తాయి.
ముగింపు
ఈ Linuxhint కథనంలో, రెండు వేరియబుల్స్ మధ్య కనీస విలువను కనుగొనడానికి మాక్రో MIN()ని ఉపయోగించడానికి మీరు తెలుసుకోవలసిన ప్రతి విషయాన్ని మేము వివరించాము. మేము ఈ స్థూల యొక్క వాక్యనిర్మాణం మరియు నిర్వచనాన్ని అలాగే రెండు ఇన్‌పుట్ వేరియబుల్స్ మధ్య 'తక్కువ' ఆపరేషన్ (<) కోసం నిజమైన/తప్పు షరతును వర్తించే సూత్రాన్ని పరిశీలించాము.
వివిధ రకాల డేటాతో ఎలా పని చేయాలో మీకు చూపించడానికి కోడ్ స్నిప్పెట్‌లు మరియు చిత్రాలను ఉపయోగించి మేము నేర్చుకున్న సిద్ధాంతాన్ని ఆచరణాత్మక ఉదాహరణకి వర్తింపజేసాము. MIN()ని ఉపయోగించడం సిఫార్సు చేయని ఫ్లోటింగ్ పాయింట్ నంబర్‌లతో వ్యవహరించడానికి మేము మీకు సిఫార్సు చేసిన ఎంపికలను కూడా చూపించాము.