usando - Encuentra el más pequeño entre 3 números en C++

factorial de un numero en c++ usando for

Question

Esta pregunta ya tiene una respuesta aquí:

• Problema lógico simple: encontrar el número más grande y más pequeño entre 3 números 5 respuestas

¿Hay alguna manera de hacer esta función más elegante? Soy nuevo en C ++, no sé si hay una forma más estandarizada de hacerlo. ¿Se puede convertir esto en un bucle para que el número de variables no esté restringido como con mi código?

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;
}

Answer 1

1) Solución simple:

int smallest(int x, int y, int z)
{
return std::min(std::min(x, y), z);
}

2) Mejor Solución (en términos de optimización):

float smallest(int x, int y, int z)
{
return x < y ? (x < z ? x : z) : (y < z ? y : z);
}

3) Su solución modificada (simple pero no eficiente):

int smallest(int x, int y, int z)
{
int smallest = x;
if (y < smallest)
smallest=y;
if(z < smallest)
smallest=z;
return smallest;
}

4) Cualquier número de números:

Para n números, guárdelo en una matriz (matriz [n]), Ordene la matriz y tome la matriz [0] para obtener la más pequeña.

 //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
}

Answer 2

En su versión, está encontrando el valor más pequeño solo si es más pequeño que 99999.

Debes comparar los tres valores juntos. Además, estás obteniendo int pero regresando float . O bien, debe decidir qué tipo de valores desea procesar, o puede crear una versión generalizada que funcione con cualquier tipo que se pueda comparar:

#include <algorithm>
template<class T>
T smallest(T x, T y, T z)
{
return std::min(x, std::min(y, z));
}

EDITAR:

Dos formas de mejorar el código en algo que opera en un 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;
}

Answer 3

Hay una propuesta para incluir esto en la biblioteca de C ++ bajo N2485 . La propuesta es simple, por lo que he incluido el código significativo a continuación. Obviamente esto supone plantillas variad.

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 ...); }

Answer 4

Hay una serie de mejoras que se pueden hacer.

Podrías usar funciones estándar para hacerlo más claro:

// 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);
}

O mejor aún, como se señala en los comentarios:

int smallest(int x, int y, int z){
return std::min({x, y, z});
}

Si desea que funcione en cualquier número de ints, podría hacer algo como esto:

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;
}

También puede hacerlo genérico para que funcione en cualquier tipo, en lugar de solo 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;
}

Answer 5

O simplemente puede usar definir, para crear una función de macro.

#define min(x,y,z) (x < y ? (x < z ? x : z) : (y < z ? y : z))

Answer 6

Puede almacenarlos en un vector y usar std::min_element en eso.

Por ejemplo:

vector<int> values;
values.push_back(10);values.push_back(1);values.push_back(12);
int min = *std::min_element(values.begin(),values.end());

Answer 7

Si es posible, recomiendo usar C ++ 11 o una versión más reciente que le permita calcular el resultado deseado sin implementar su propia función ( std::min ). Como ya señalamos en uno de los comentarios, podéis hacer

T minimum(std::min({x, y, z}));

o

T minimum = std::min({x, y, z});

que almacena el mínimo de las variables x , y y z en la variable minimum del tipo T (tenga en cuenta que x , y y z deben tener el mismo tipo o deben ser convertibles implícitamente a él). En consecuencia, se puede hacer lo mismo para obtener un máximo: std::max({x, y, z}) .

Answer 8

Una pequeña modificacion

 int smallest(int x, int y, int z){
int smallest = min(x,y);
return min(smallest,z);
}

Answer 9

aparte min, que te permiten escribir return min (x, min (y, z)) hay un operador ternario:

float smallest(int x, int y, int z){
return x < y ? (x < z ? x : z) : (y < z ? y : z);
}

Answer 10

smallest=(x<((y<z)?y:z)t)?x:((y<z)?y:z);

Suponer,

x is one;
y is two;
z is three;
smallest = (one < ((two < three) ? two:three)) ? one:((two < three) ? two:three)