¿Cómo encontrar qué valor es el más cercano a un número en C?

Question

tengo el siguiente código en C:

#define CONST 1200 
int a = 900; 
int b = 1050; 
int c = 1400; 

if (A_CLOSEST_TO_CONST) { 
    // do something 
} 

¿Cuál es una manera conveniente de comprobar si si a es el valor más cercano a CONST entre A, B y C?

Editar:

No importa si tengo 3 variables o una matriz como esta (que podría ser más de 3 elementos):

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

Answer 1

Esto funciona para tres variables:

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

Esto funciona con una serie de uno o más elementos, donde n es el número de elementos:

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

ver su funcionamiento en línea: ideone

Answer 2

Es necesario comparar su constante a cada elemento. (Funciona bien para 3 elementos pero es una muy mala solución para una mayor cantidad de elementos, en cuyo caso sugiero usar algún tipo de método de dividir y conquistar). Después de compararlo, tome sus diferencias, la diferencia más baja es la que está más cerca la const)

Answer 3

Compare el valor absoluto de (a-CONST), (b-CONST) y (c-CONST). Cualquiera que sea el valor absoluto más bajo, ese es el más cercano.

Answer 4

Esta respuesta es a una reacción a su edición de la pregunta original y su comentario. (Tenga en cuenta que para determinar el final de la matriz podríamos utilizar diferentes enfoques, la usaré en este escenario particular es la más 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 tried it so there might be a bug lurking somewhere in it. 

const int ArraySize = <your array size>; 
const int YourConstant = <your constant>; 
int values[ArraySize] = { ... <your numbers> ... }; 
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. 

Answer 5

Para un gran conjunto ordenado, debe ser capaz de utilizar una búsqueda binaria para encontrar los dos números que (casos de límite de módulo) bordean el número, uno de ellos tiene que ser el más cercano.

Por lo tanto, podría lograr el rendimiento O (Log n) en lugar de O (n).

Answer 6

Aquí hay un método generalizado. La función min_element() toma una matriz int, tamaño de matriz y puntero a una función de comparación. El predicado de comparación devuelve true si los primeros valores son menos de el segundo valor. Una función que acaba de devolver a < b encontraría el elemento más pequeño en la matriz. El predicado de comparación pinouchon() realiza su comparación de comparación.

#include <stdio.h> 
#include <stdlib.h> 

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

Answer 7

pseudocódigo:

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   

Answer 8

I m añadiendo algo en marcará el código 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]; 
} 

Esta función se llevará a una matriz de enteros y devuelve el número que es el más cercano al CONST.