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
}