### Challenge: Get Closest Number in an Array

#### Andy Zhao (he/him) on February 20, 2019

Given an array of numbers nums, and a given number given_num: nums = [100, 200, 400, 800, 1600, 3200, 6400, 128000] given_num = 900 Get the n... [Read Full] Javascript:

Let's go for a JS one liner 😉

``````nums.sort((a, b) => Math.abs(given_num - a) - Math.abs(given_num - b))
``````

This causes the original array to have its order changed but I don't think that's against the rules 😅

By including a function to sort by I'm no longer doing an alphabetical sort, which means this problem no longer exists.

``````  console.log([2,3,4,11].sort((a,b)=>a-b));
``````
``````Output:
(4) [2, 3, 4, 11]
``````

The sort() method sorts the elements of an array in place and returns the array. The default sort order is built upon converting the elements into strings, then comparing their sequences of UTF-16 code units values.

developer.mozilla.org/en-US/docs/W...

If it outputs the closest number, it works! :)

Ruby:

``````nums.min_by { |num| (given_num - num).abs }
#=> 800
``````

Shamelessly taken from Stack Overflow 🙃 I was in a much more of a "just give me the answer" mood than "let's figure it out" mood.

This is a job for Reduce!

JavaScript:

``````const nums = [100, 200, 400, 800, 1600, 3200, 6400, 128000]
const given_num = 900

const closestReducer = g => (a, b) =>
Math.abs(g - a) < Math.abs(g - b) ? a : b

nums.reduce(closestReducer(given_num))
//=> 800
``````

Java:

``````        int[] nums = {100, 200, 400, 800, 1600, 3200, 6400, 128000};
int ans = 0;
int given_num = 900;
int minDistance = Integer.MAX_VALUE;
for (int i =0; i < nums.length; i++) {
int curDistance = Math.abs(nums[i] - given_num);
if (curDistance < minDistance) {
ans = nums[i];
minDistance = curDistance;
}
}
System.out.println(ans);
``````

Trying to optimize no of lines with Java 8 Streams and Lambda.

A Python implementation:

``````import numpy as np
def find_nearest(array, value):
array = np.asarray(array)
idx = (np.abs(array - value)).argmin()
return array[idx]

nums = [100, 200, 400, 800, 1600, 3200, 6400, 128000]
given_num = 900

print(find_nearest(nums, given_num))
``````

Using JavaScript `Set`:

``````const closest_num = (nums, given_num) => {
const min_dist = Math.min(...nums.map(num => Math.abs(num - given_num)))
return new Set(nums).has(given_num - min_dist) ? given_num - min_dist : given_num + min_dist
}
``````

Or we can save the intermediate array:

``````const closest_num = (nums, given_num) => {
const absolute_dists = nums.map(num => Math.abs(num - given_num))
const min_absolute_dist = Math.min(...absolute_dists)
return nums[absolute_dists.indexOf(min_absolute_dist)]
}
``````

And there is another perspective, instead of iterating numbers, we can iterate distances. Like:

``````const closest_num = (nums, given_num) => {
const set = new Set(nums)
let i = 0
while (true) {
if (set.has(given_num - i)) return given_num - i
if (set.has(given_num + i)) return given_num + i
i++
}
}
``````

This will normally be slower, but in cases like:

`nums = [10000000, 9999999, 9999998, ..., 1]`
`given_num = 10000001`

It will be much faster than other algorithms.

I have written a benchmark function for this:

``````const benchmark = (func) => {
console.time(func.name)
func.call(this, Array.from({length: 10000000}, (v, idx) => (10000000 - idx)), 10000001)
console.timeEnd(func.name)
}
``````

You can test your function via `benchmark(func)`.

The solution above yields:

`closest_num: 5037.456787109375ms`

in Chrome.

nums = [100, 200, 400, 800, 1600, 3200, 6400, 128000];
given_num = 900

Here is my solution:

``````f = a => (m=Math.min(...nums.map(v=>Math.abs(v-given_num))),nums.find(v=>v==given_num - m || v== m-given_num))
``````

Usage:

``````f(nums)
``````

Result:

``````800
``````

Be careful that `...` can cause a range error:

`RangeError: Maximum call stack size exceeded`

when the `nums` array is very large.

OCaml with list instead of array

``````let rec closest num list = match list with
[] -> failwith "Empty list"
|[n] -> n
|h :: q ->
let closest_q = closest num q in
let val_h = abs (num - h) in
let val_q = abs (num - closest_q) in
if (val_h < val_q) then h else closest_q;;
``````

C++, O(n), no sorting, no extra memory allocation beyond storing the input:

``````#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
vector<int> v{100, 200, 400, 800, 1600, 3200, 6400, 128000};
int given_num = 900;

cout << *min_element(
v.begin(),
v.end(),
[=](int a, int b){ return abs(a - given_num) < abs(b - given_num); }
);

return 0;
}
``````

Here's some C# for everyone:

``````var nums = new int[] { 100, 200, 400, 800, 1600, 3200, 6400, 128000 };
var given_num = 900;

var result =
(
from num in nums
let diff = Math.Abs(given_num - num)
orderby diff
select num
)
.First();
``````

Swift is the most elegant concise and bestest language... ;)

``````nums.reduce(nums) { abs(\$0-given_num) < abs(\$1-given_num) ? \$0 : \$1 }
``````

Of course in actual usage we would make this an extension and check the validity of the array. I came across this post because I needed it so this one's for CGFloat, which is a Swift floating point type (Double, really)

``````extension CGFloat {
func nearest(arr: [CGFloat]) -> CGFloat {
guard arr.count > 0 else {
fatalError("array cannot be empty")
}
return arr.reduce(arr) { abs(\$0-self) < abs(\$1-self) ? \$0 : \$1 }
}
}

let nums: [CGFloat] = [100, 200, 400, 800, 1600, 3200, 6400, 128000]
let given_num = CGFloat(900)

let nearest = given_num.nearest(nums)

``````

With the help of google, I was able to find the answer to this 😅

import numpy as np
def find_nearest(array, value):
array = np.array(array)
z=np.abs(array-value)
y= np.where(z == z.min())
m=np.array(y)
x=m[0,0]
y=m[1,0]
near_value=array[x,y]

``````return near_value
``````

array =np.array([[100, 200, 400, 800, 1600, 3200, 6400, 128000]])
print(array)
value = 900
print(find_nearest(array, value)) Thanks for this challenge! 🍺

Wolfram Language!

``````Nearest[nums, given_num]
``````

I knew that one day my subscription will come in handy...

Hey! Let's do it the Scala way:

``````def closestNumber(x: Int, y: Int, givenNumber: Int): Int = {
if(abs(givenNumber-x) > abs(givenNumber-y)) {
y
} else {
x
}
}

val givenNumber = 900
val nums = List(100, 200, 400, 800, 1600, 3200, 6400, 128000)
println(nums.reduce((x, y) => closestNumber(x, y, givenNumber)))
//==> Prints 800
``````

Thanks for the challenge!

Rust 🦀

``````numbers.iter().min_by_key(|&num| (num - given_num).abs()).unwrap()
``````

Nice, didn't know Rust had similar syntax to Ruby!

What if there are two numbers that are equally close to the given number?
I think you should point this out in the description.

I probably over complicated it, but here's a CodePen link with how I did it in JS and outputted it to the HTML side.

Long as you solved it! 👍

code of conduct - report abuse  