从统一网格中找到最接近的数字

Question

I have an integer positive number n . Let's say n=5 for example. If we look at multiplies of n , we see these numbers (let's call it n-grid) [... -15, -10, -5, 0, 5, 10, 15, ...]. Now I need to write a function F(n, N) that, given an integer N , outputs a closest number from that n-grid. For instance, F(n, 0) = 0 (for any n). F(5, 4) = 5 , F(5, 7) = 5 , F(5, 8) = 10 , F(5, -13) = -15 and so on.

I've written this function:

int const x = ((::abs(N) + (n / 2)) / n) * n;
if (N > 0)
{
    return x;
}
else
{
    return -x;
}

It seems to work but don't like how it looks. Can anybody suggest any improvement?

Answer 1

You could possibly get rid of the if statement by multiplying x by (N/abs(N)) and returning the calculated value immeadiatelly, without even saving it in x .

I would not do this however, because it would harm readability.

Answer 2

This might be simple to understand and to look even,

int grid(int n, int N){
   if (N == 0) return N; 
   return n * (N > 0 ? (n + N)/n : (n + abs(N))/n );
}

Here is the ideone result.

Answer 3

here is simple math solution :-

F(k,x) = (x/k)*k      if  abs(x-(x/k)*k) <= k/2


       = (x/k)*k + sign(x)*k    otherwise

C Implementation :-

#include<stdio.h> 
#include<math.h>

int func(int k,int x) {

 int a = (x/k)*k; 
 int sign = x/abs(x); 

  if(abs(x-a)<=k/2) 
     return(a); 

  else return(a+sign*k); 

}

int main() {

 printf("%d",func(5,121));
 return 0;
} 

Answer 4

int closest_number(int n,int N)
{
    if(N==0)
        return N;
    else if(N > 0)
    {
       int temp = N % n;
       if(temp > (n/2))
           return (n*((N/n)+1));
       else
           return (n*(N/n));
    }
    else
    {
        int temp = N % n;
        if(abs(temp) > (n/2))
            return (n*((N/n)-1));
        else
            return (n*(N/n));
    }
}

You can find the ideone output for the given set of test cases here http://ideone.com/NlJiPt

Answer 5

You are describing a rounding algorithm ; you need to specify whether rounding is symmetric or not, and then whether it is up or down (or toward/away from zero for symmetric). ideone demo for below code.

                                                       // F(4, 6)    F(4, -6)
int symmetricTowardZero(int n, int N) {
    return n * (int)(N / n);                           //    4         -4
}

int symmetricAwayFromZero(int n, int N) {
    return n * (int)(N / n + (N < 0 ? -0.5 : +0.5));   //    8         -8
}

int unsymmetricDownward(int n, int N) {
    return n * floor((double)N / n);                   //    4         -8
}

int unsymmetricUpward(int n, int N) {
    return n * ceil((double)N / n);                    //    8         -4
}