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

Question

¿Hay alguna manera de hacer que esta función sea más elegante? Soy nuevo en C++, no sé si hay una forma más estandarizada de hacerlo. ¿Se puede convertir esto en un ciclo así 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

una pequeña modificación

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

Answer 2

Hay una serie de mejoras que se pueden hacer.

Usted podría utilizar las 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 ha señalado en los comentarios:

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

Si desea que le permite operar en cualquier número de enteros , 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 podría hacerlo genérico para que funcione e en cualquier tipo, en lugar de sólo 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 3

aparte min, que le permiten escribir min retorno (x, min (y, z)) hay operador ternario:

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

Answer 4

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

Debe comparar los tres valores juntos. Además, obtiene int pero devuelve float. O bien, usted debe decidir qué tipo de valores que desee procesar, o usted podría crear una versión generalizada que funciona con cualquier tipo que puede ser comparada:

#include <algorithm> 

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

EDIT:

Dos maneras de mejorar el código en algo que funciona 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 5

hay una propuesta para incluir esto en la biblioteca de C++ en N2485. La propuesta es simple, así que he incluido el código significativo a continuación. Obviamente, esto supone plantillas variadas.

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 6

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

Supongamos,

x is one; 
y is two; 
z is three; 

smallest = (one < ((two < three) ? two:three)) ? one:((two < three) ? two:three) 

Answer 7

1) Solución simple:

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

2) solución mejor (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, almacenarlo en una matriz (array [n]), Sort la matriz y toman 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 8

O puede simplemente 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 9

Si es posible, recomiendo el uso de C++ 11 o más nuevo que le permite calcular el resultado deseado w/a la implementación de su propia función (std::min). Como ya se ha señalado en uno de los comentarios, puede hacerlo

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 de tipo T (nota que x, y y z deben tener el mismo tipo o deben ser implícitamente convertibles a él). En consecuencia, lo mismo se puede hacer para obtener un máximo: std::max({x, y, z}).

Answer 10

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());