Comment trouver quelle valeur est la plus proche d’un nombre en C?

J’ai le code suivant en C:

#define CONST 1200 int a = 900; int b = 1050; int c = 1400; if (A_CLOSEST_TO_CONST) { // do something } 

Quel est un moyen pratique de vérifier si a est la valeur la plus proche de CONST parmi a, b et c?

Modifier:

Peu importe si j’ai 3 variables ou un tableau comme celui-ci (il pourrait y avoir plus de 3 éléments):

 int values[3] = {900, 1050, 1400}; 

Cela fonctionne pour trois variables:

 if (abs(a - CONST) <= abs(b - CONST) && abs(a - CONST) <= abs(c - CONST)) { // a is the closest } 

Cela fonctionne avec un tableau d'un ou plusieurs éléments, où n est le nombre d'éléments:

 int is_first_closest(int values[], int n) { int dist = abs(values[0] - CONST); for (int i = 1; i < n; ++i) { if (abs(values[i] - CONST) < dist) { return 0; } } return 1; } 

Voyez-le travailler en ligne: ideone

Comparez les valeurs absolues de (a-CONST), (b-CONST) et (c-CONST). Quelle que soit la valeur absolue la plus basse, celle la plus proche.

Voici une méthode généralisée. La fonction min_element() prend un tableau int, une taille de tableau et un pointeur sur une fonction de comparaison. Le prédicat de comparaison renvoie true si la première valeur est inférieure à la seconde. Une fonction qui vient de renvoyer a < b trouverait le plus petit élément du tableau. Le prédicat de comparaison pinouchon() effectue votre comparaison de proximité .

 #include  #include  #define CONST 1200 int pinouchon(int a, int b) { return abs(a - CONST) < abs(b - CONST); } int min_element(const int *arr, int size, int(*pred)(int, int)) { int i, found = arr[0]; for (i = 1; i < size; ++i) { if (pred(arr[i], found)) found = arr[i]; } return found; } int main() { int values[3] = {900, 1050, 1400}; printf("%d\n", min_element(values, 3, pinouchon)); return 0; } 

J’ajoute quelque chose dans le code de Mark Byres …..

 int is_first_closest(int values[]) { int dist = abs(values[0] - CONST),closest; //calculaing first difference int size = sizeof( values ) //calculating the size of array for (int i = 1; i < size; ++i) { if (abs(values[i] - CONST) < dist) { //checking for closest value dist=abs(values[i] - CONST); //saving closest value in dist closest=i; //saving the position of the closest value } } return values[i]; } 

Cette fonction prendra un tableau d’entiers et retournera le nombre le plus proche de CONST.

Vous devez comparer votre constante à chaque élément. (fonctionne bien pour 3 éléments, mais c’est une très mauvaise solution pour un plus grand nombre d’éléments, auquel cas je suggère d’utiliser une méthode de division et de conquête). Après avoir comparé, prenez leurs différences, la différence la plus basse est celle à laquelle le const est le plus proche)

Cette réponse est une réaction à votre modification de la question initiale et à votre commentaire. (Notez que pour déterminer la fin du tableau, nous pourrions utiliser différentes approches, celle que j’utiliserai dans ce scénario particulier est la plus simple.)

 // I think you need to include math.h for abs() or just implement it yourself. // The code doesn't deal with duplicates. // Haven't sortinged it so there might be a bug lurking somewhere in it. const int ArraySize = ; const int YourConstant = ; int values[ArraySize] = { ...  ... }; int tempMinimum = abs(YourArray[0] - YourConstant); // The simplest way for (int i = 1; i < ArraySize; i++) { // Begin with iteration i = 1 since you have your 0th difference computed already. if (abs(YourArray[i] - YourConstant) < tempMinumum) { tempMinumum = abs(YourArray[i] - YourConstant); } } // Crude linear approach, not the most efficient. 

Pour un grand ensemble sortingé, vous devriez pouvoir utiliser une recherche binary pour trouver les deux nombres qui (bordures modulo) bordent le nombre, l’un d’entre eux devant être le plus proche.

Ainsi, vous pourrez obtenir des performances O (Log n) au lieu de O (n).

pseudocode:

 closest_value := NULL closest_distance := MAX_NUMBER for(value_in_list) distance := abs(value_in_list - CONST) if (distance < closest_distance) closest_value := value_in_list closest_distance := distance print closest_value, closest_distance