కనుగొనడం కనీస మరియు గరిష్టంగా C ప్రోగ్రామింగ్ భాషలోని మూలకాల శ్రేణి నుండి విలువలు ఒక సాధారణ అభ్యాసం మరియు అనేక ప్రోగ్రామ్‌లలో ఉపయోగించబడుతుంది. కాబట్టి, సి ప్రోగ్రామింగ్ ప్రారంభకులు ఈ అభ్యాసాన్ని ఉపయోగించడం నేర్చుకోవడం అవసరం. Cలో నిమి మరియు గరిష్టానికి సంబంధించిన సహాయం కోసం వెతుకుతున్నది మీరే అయితే, ఈ కథనం మార్గదర్శకాలను అనుసరించండి.
C లో కనిష్ట మరియు గరిష్టం
సి ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో, కనుగొనడానికి రెండు ఎక్కువగా ఉపయోగించే ఫంక్షన్‌లు ఉన్నాయి నిమి మరియు గరిష్టంగా విలువలు, ఇవి క్రింది విధంగా ఉన్నాయి:
1: వినియోగదారు నిర్వచించిన విధులు
C భాషలో వినియోగదారు నిర్వచించిన విధులు వినియోగదారు స్వయంగా సృష్టించినవి. ఈ ఫంక్షన్లలో వేరియబుల్ డేటా రకం, అర్రే, ఫ్లోట్‌లు మరియు మరిన్నింటిని నిర్వచించడం ఉంటుంది. ఈ రకమైన ఫంక్షన్లలో ఫర్ లూప్ మరియు శ్రేణిలోని ప్రతి మూలకాన్ని ఒక్కొక్కటిగా సరిపోల్చడానికి ప్రధాన ప్రక్రియ ఉంటుంది. చివరి పునరావృతాన్ని పూర్తి చేసిన తర్వాత, ఫంక్షన్ “printf” ఫంక్షన్‌ని ఉపయోగించి శ్రేణి నుండి min మరియు max విలువలను ప్రింట్ చేస్తుంది.
అటువంటి వినియోగదారు నిర్వచించిన ఫంక్షన్ల యొక్క ఉదాహరణ క్రింద ఇవ్వబడింది:
#
పూర్ణాంక కాల్కారే ( int x [ ] , int n )
{
int min,max,y;
నిమి = గరిష్టంగా =x [ 0 ] ;
కోసం ( మరియు = 1 ; మరియు < n; మరియు++ )
{
ఉంటే ( నిమి > x [ మరియు ] )
నిమి =x [ మరియు ] ;
ఉంటే ( గరిష్టంగా < x [ మరియు ] )
గరిష్టంగా =x [ మరియు ] ;
}
printf ( 'కనిష్ట శ్రేణి : %d' ,నిమి ) ;
printf ( ' \n గరిష్ట శ్రేణి : %d' ,గరిష్టంగా ) ;
}
పూర్ణాంక ప్రధాన ( )
{
int x [ 1000 ] ,y,n, మొత్తం ;
printf ( 'శ్రేణి పరిమాణాన్ని నమోదు చేయండి :' ) ;
స్కాన్ఎఫ్ ( '%d' , & n ) ;
printf ( 'అరేలో మూలకాలను నమోదు చేయండి: \n ' ) ;
కోసం ( మరియు = 0 ; మరియు < n; మరియు++ )
{
స్కాన్ఎఫ్ ( '%d' , & x [ మరియు ] ) ;
}
కాల్కార్రే ( x,n ) ;
}
ది కాల్కారే () ఈ కోడ్‌లోని ఫంక్షన్ శ్రేణిని నిర్ణయిస్తుంది కనీస మరియు గరిష్టంగా విలువలు. శ్రేణి, శ్రేణి పరిమాణం మరియు విలువ పారామీటర్‌లుగా పంపబడతాయి కాల్కారే () ప్రధాన() ఫంక్షన్‌లో ఫంక్షన్. ది కాల్కారే () ఫంక్షన్ పోల్చింది నిమి మరియు గరిష్టంగా శ్రేణి అంశాలతో విలువలు మరియు విలువలను అవుట్‌పుట్ చేస్తుంది కనీస మరియు గరిష్టంగా శ్రేణి విలువలు.
అవుట్‌పుట్
2: అంతర్నిర్మిత విధులు
వినియోగదారు నిర్వచించిన ఫంక్షన్ ప్రారంభకులకు అనువైనది కావచ్చు, ఎందుకంటే వారు శ్రేణి నుండి కనిష్ట మరియు గరిష్ట విలువను లెక్కించడానికి దశల వారీ ప్రక్రియను నేర్చుకుంటారు. అయినప్పటికీ, ఒక వినియోగదారు వివరణాత్మక ప్రక్రియలోకి వెళ్లకూడదనుకుంటే, వారు C లోని అంతర్నిర్మిత ఫంక్షన్‌లను ఉపయోగించుకోవచ్చు 'fmin()' ’ మరియు 'fmax() ’. ఈ విధులు పొందుతాయి నిమి లేదా గరిష్టంగా శ్రేణి యొక్క నిర్దిష్ట ఉపసమితి లేదా పరిధి నుండి మూలకం. ఉపయోగించడానికి ' fmin' మరియు ' fmax' విధులు, మొదట తనిఖీ చేయవలసిన విలువలతో ఒక శ్రేణి సృష్టించబడుతుంది. అప్పుడు ' fmin' మరియు ' fmax' విధులు అంటారు మరియు శ్రేణి యొక్క పరిధి లేదా ఉపసమితి వాటికి పంపబడుతుంది. ది ' fmin' మరియు ' fmax' విధులు తిరిగి కనీస లేదా గరిష్టంగా వరుసగా అంశాలు. అటువంటి రకమైన ఫంక్షన్ యొక్క ఉదాహరణ క్రింద చూపబడింది:
#include#include
పూర్ణాంక ప్రధాన ( ) {
printf ( 'fmax(223, 422) = %f \n ' , fmax ( 223 , 422 ) ) ;
printf ( 'fmin(9.9, 2.8) = %f \n ' , fmin ( 9.9 , 2.8 ) ) ;
తిరిగి 0 ;
}
ఈ కోడ్‌లో, అంతర్నిర్మిత విధులు, fmax() మరియు fmin() తో ఉపయోగించబడతాయి printf లెక్కించడానికి ప్రకటనలు గరిష్టంగా 223 మరియు 422 నుండి విలువలు మరియు లెక్కించండి కనీస 9.9 మరియు 2.8 నుండి విలువలు.
అవుట్‌పుట్
ముగింపు
వినియోగదారు నిర్వచించిన ఫంక్షన్ లేదా Cలోని అంతర్నిర్మిత ఫంక్షన్‌ని ఉపయోగించి వినియోగదారులు శ్రేణి నుండి కనిష్ట మరియు గరిష్ట విలువలను లెక్కించవచ్చు. వినియోగదారు నిర్వచించిన ఫంక్షన్ అంతర్నిర్మిత ఫంక్షన్‌తో పోలిస్తే మరిన్ని దశలను తీసుకుంటుంది, ఇది ప్రారంభకులకు సహాయపడుతుంది. మరోవైపు, అంతర్నిర్మిత ఫంక్షన్‌లు వినియోగదారులకు మరింత ఆశాజనకంగా ఉన్నాయి, ఎందుకంటే అవి వేగవంతమైన రేటుతో అమలు చేయబడతాయి.