Trouvez le plus petit parmi 3 nombres en C++
Existe-t-il un moyen de rendre cette fonction plus élégante? Je suis nouveau en C++, je ne sais pas s'il existe un moyen plus standardisé de le faire. Cela peut-il être transformé en boucle afin que le nombre de variables ne soit pas restreint comme dans mon code?
float smallest(int x, int y, int z) {
int smallest = 99999;
if (x < smallest)
smallest=x;
if (y < smallest)
smallest=y;
if(z < smallest)
smallest=z;
return smallest;
}
Un certain nombre d'améliorations peuvent être apportées.
Vous pouvez utiliser des fonctions standard pour le rendre plus clair:
// Notice I made the return type an int instead of a float,
// since you're passing in ints
int smallest(int x, int y, int z){
return std::min(std::min(x, y), z);
}
Ou mieux encore, comme indiqué dans les commentaires:
int smallest(int x, int y, int z){
return std::min({x, y, z});
}
Si vous voulez qu'il fonctionne sur n'importe quel nombre d'ints, vous pouvez faire quelque chose comme ceci:
int smallest(const std::vector<int>& intvec){
int smallest = std::numeric_limits<int>::max(); // Largest possible integer
// there are a number of ways to structure this loop, this is just one
for (int i = 0; i < intvec.size(); ++i)
{
smallest = std::min(smallest, intvec[i]);
}
return smallest;
}
Vous pouvez également le rendre générique afin qu'il fonctionne sur n'importe quel type, au lieu de simplement ints
template <typename T>
T smallest(const std::vector<T>& vec){
T smallest = std::numeric_limits<T>::max(); // Largest possible integer
// there are a number of ways to structure this loop, this is just one
for (int i = 0; i < vec.size(); ++i)
{
smallest = std::min(smallest, vec[i]);
}
return smallest;
}
Si possible, je recommande d'utiliser C++ 11 ou une version plus récente, ce qui vous permet de calculer le résultat souhaité sans implémenter votre propre fonction ( std :: min ). Comme déjà souligné dans l'un des commentaires, vous pouvez faire
T minimum(std::min({x, y, z}));
ou
T minimum = std::min({x, y, z});
qui stocke le minimum des variables x, y et z dans la variable minimum de type T (notez que x, y et z doivent être du même type ou doivent pouvoir lui être converties implicitement). De manière correspondante, la même chose peut être faite pour obtenir un maximum: std::max({x, y, z}).
apart min, qui vous permet d'écrire return min (x, min (y, z)), il existe un opérateur ternaire:
float smallest(int x, int y, int z){
return x < y ? (x < z ? x : z) : (y < z ? y : z);
}
smallest=(x<((y<z)?y:z)t)?x:((y<z)?y:z);
Supposer,
x is one;
y is two;
z is three;
smallest = (one < ((two < three) ? two:three)) ? one:((two < three) ? two:three)
Il est proposé d'inclure cela dans la bibliothèque C++ sous N2485 . La proposition est simple, j'ai donc inclus le code significatif ci-dessous. Évidemment, cela suppose des modèles variadiques.
template < typename T >
const T & min ( const T & a )
{ return a ; }
template < typename T , typename ... Args >
const T & min ( const T & a , const T & b , const Args &... args )
{ return std :: min ( b < a ? b : a , args ...); }
Vous pouvez les stocker dans un vecteur et utiliser std::min_element sur celui-ci.
Par exemple:
vector<int> values;
values.Push_back(10);values.Push_back(1);values.Push_back(12);
int min = *std::min_element(values.begin(),values.end());
Une petite modification
int smallest(int x, int y, int z){
int smallest = min(x,y);
return min(smallest,z);
}
Dans votre version, vous ne trouvez la plus petite valeur que si elle est inférieure à 99999.
Vous devriez comparer les trois valeurs ensemble. De plus, vous obtenez int mais vous retournez float. Vous pouvez également choisir le type de valeurs que vous souhaitez traiter ou créer une version généralisée compatible avec tous les types pouvant être comparés:
#include <algorithm>
template<class T>
T smallest(T x, T y, T z)
{
return std::min(x, std::min(y, z));
}
MODIFIER:
Deux façons d'améliorer le code en quelque chose qui fonctionne sur une vector:
#include <cstdio>
#include <algorithm>
#include <vector>
// Use a built-in function to retrieve the smallest value automatically
template<class T>
T smallest1(const std::vector<T> &values)
{
return *std::min_element(values.begin(), values.end());
}
// Go through the vector manually
template<class T>
T smallest2(const std::vector<T> &values)
{
// Get the first value, to make sure we're comparing with an actual value
T best_so_far = values.front();
// For all the other values in the vector ...
for(unsigned i = 1; i < values.size(); ++i) {
// ... replace if the new one is better
if(values[i] < best_so_far)
best_so_far = values[i];
}
return best_so_far;
}
int main()
{
// Try out the code with a small vector
std::vector<int> test;
test.Push_back(6);
test.Push_back(5);
test.Push_back(7);
printf("%d\n", smallest1(test));
printf("%d\n", smallest2(test));
return 0;
}
Ou vous pouvez simplement utiliser define pour créer une fonction macro.
#define min(x,y,z) (x < y ? (x < z ? x : z) : (y < z ? y : z))
1) Solution simple:
int smallest(int x, int y, int z)
{
return std::min(std::min(x, y), z);
}
2) Meilleure solution (en termes d'optimisation):
float smallest(int x, int y, int z)
{
return x < y ? (x < z ? x : z) : (y < z ? y : z);
}
3) votre solution modifiée (simple mais pas efficace):
int smallest(int x, int y, int z)
{
int smallest = x;
if (y < smallest)
smallest=y;
if(z < smallest)
smallest=z;
return smallest;
}
4) N'importe quel nombre de nombres:
Pour n nombres, stockez-le dans un tableau (tableau [n]), triez le tableau et prenez le tableau [0] pour devenir le plus petit.
//sort the elements in ascending order
for(int i=0;i<n;i++)
{
if(array[i]>array[i+1])
{
int temp = array[i];
array[i] = array[i+1];
array[i+1] = temp;
}
}
//display smallesst and largest
cout<<"Smallest: "<<array[0];
cout<<"Largest: "<<array[n-1]; //not needed in your case
}