how to find near value? - c

Question

Iam trying to see if there is a shorter method in being able to find the nearest value in a linear search algorithm if the value you are searching for doesnt exist,without using any searching / sorting built in methods. Thank you.
Here is my current method below,although my attempt seems inefficent.
(iam assuming the array is already sorted)
public void LinearSearchNearest(int[] data, int target, string dataname)
{
Console.WriteLine(dataname + ": ");
int StepsNearest = 0;
int n = data.Length;
StepsNearest++;
// Check for corner cases (check the value is actually within range of the array)
if (target < data[0])
{
Console.WriteLine($"Closest value : {data[0]}, Position : {1} (value outside of array bounds) ");
Console.WriteLine($"Num of Steps is : {StepsNearest}");
return;
}
if (target > data[n - 1])
{
Console.WriteLine($"Closest value : {data[n - 1]}, Position : {n} (value outside of array bounds) ");
Console.WriteLine($"Num of Steps is : {StepsNearest}");
return;
}
int closestVal = 0;
int position = 0;
int found = 0;
int targetCount = 0;
Console.Write("Value is at positions : ");
for (int i = 0; i < data.Length; i++)
{
StepsNearest++;
if (data[i] == target)
{
targetCount++;
found++;
Console.Write($"{i + 1}, ");
}
else
{
StepsNearest++;
// Compare closest value currently to new value to see which one is closer to target
long along = data[i];
long blong = closestVal;
long clong = target;
var distanceA = Math.Abs(clong - along);
var distanceB = Math.Abs(clong - blong);
if (distanceA < distanceB)
{
closestVal = data[i];
position = i + 1;
}
}
}
// Check if target value was found or not in the array given
string result = (found == 0) ? $"Closest value : {closestVal}, Position : {position} " +
$"\nNum of Steps is : {StepsNearest}" : $"\nNum of Steps is : {StepsNearest}";
Console.WriteLine(result);
}
UPDATE CODE
public void LinearSearchNearest(int[] data, int target, string dataname)
{
Console.WriteLine(dataname + ": ");
StepsNearest = 0;
int closestVal = 0;
int position = 0;
int found = 0;
int minDistance = int.MaxValue;
Console.Write("Value is at positions : ");
for (int i = 0; i < data.Length; i++)
{
StepsNearest++;
if (data[i] == target)
{
found = 1;
Console.Write($"{i + 1}, ");
}
else
{
StepsNearest++;
// Compare closest value currently to new value to see which one is closer to target
int distance = System.Math.Abs(data[i] - target);
if (distance < minDistance)
{
minDistance = distance;
closestVal = data[i];
position = i + 1;
}
}
}
// Check if target value was found or not in the array given
string result = (found == 0) ? $"Closest value : {closestVal}, Position : {position} " +
$"\nNum of Steps is : {StepsNearest}" : $"\nNum of Steps is : {StepsNearest}";
Console.WriteLine(result);
}

Answer 1

If the array is assumed to be sorted as you said in the comments, then you could just walk through the array until you find a value that's equal to or larger than the target. If the value is equal, then of course we'd return that index.
If the value is larger, then we compare the difference of this value and the target with the difference of the previous value and the target, and return the index of the value with the smallest difference.
If we never find an equal or larger value, then we return the last index:
public int GetIndexOfNearest(int[] data, int target)
{
if (data == null) throw new ArgumentNullException(nameof(data));
if (target <= data[0]) return 0;
if (target >= data[data.Length - 1]) return data.Length - 1;
for (int i = 0; i < data.Length; i++)
{
// If we find a match, return that index
if (data[i] == target) return i;
// If this value is greater than the target then we either
// return this index or the previous index, depending
// on which one has the smallest diff with the target
if (data[i] > target)
{
var thisDiff = Math.Abs(data[i] - target);
var prevDiff = Math.Abs(data[i - 1] - target);
if (thisDiff < prevDiff) return i;
else return i - 1;
}
}
// We should never get here, since this is the case where all the items are smaller
// than the target, which we checked in the third line, but the compiler requires it
return data.Length - 1;
}

Answer 2

You can do all in one iteration. This will either find the first exact match or the nearest element to the search value in an UNORDERED array. If there are multiple elements with the same distance to the search value, it will find the first one.
let values = [...]; //your value list
let search = ...; //your value to search
let index = 0; //index where element is found
for (let i = 0; i < values.length; i++) {
// if the current element is an exact match, set the index to i
// and break the loop
if (values[i] == search) {
index = i;
break;
}
// else if current element is "nearer" to the searchvalue than
// the previously remembered, remember the current index
else if (abs(values[i] - search) < abs(values[index] - search)) {
index = i;
}
}
If you assume, that your array is already sorted you could do it as follows
let values = [...]; //your value list
let search = ...; //your value to search
let index = 0; //index where element is found
for (let i = 0; i < values.length; i++) {
// if the current element is an exact match, set the index to i
// and break the loop
if (values[i] == search) {
index = i;
break;
}
// while the current value is less then the search value,
// just remember the index
else if (values[i] < search) {
index = i;
}
// if the current value is greater then the search value
// check whether the previous or the current element is nearer to the search value
else if (values[i] > search) {
index = abs(search - values[i]) < abs(search - values[index])
? i
: index;
break;
}
}

Answer 3

Shorter? Maybe. What I have to offer is (hopefully) faster.
Let's summarize what you are looking for:
IN: Array of int, sorted (ascending order)
IN: target int value.
OUT: Array of all indices with values with minimal distance to target.
Given, that the data contains sorted data allows us to pick an algorithm, which performs more quickly than linear search. Linear search (O(N)) would be our only choice were the data in the array not sorted.
But as data is sorted, we can do binary search, which has O(log n) runtime.
With the help of binary search, we can find 1 or 2 candidates, which have the minimal distance to target.
Then, it is just a matter of looping towards the left and towards the right as long as there are values with that same minimal distance as our minimal candidate had.
A wall of code says more than 1000 words, right? Here we go:
using System;
using System.Linq;
using System.Collections.Generic;
namespace nearest
{
class Program
{
static int BinarySearchClosest( int[] data, int target, int left, int right)
{
if (right < left)
throw new ArgumentException(nameof(right));
if ((right - left) < 2)
return left;
var mid = left + (right - left) / 2;
if ( target > data[mid])
return BinarySearchClosest(data,target, mid, right);
else
return BinarySearchClosest(data,target, left, mid);
}
static int IndexOfClosestExistingValue( int[] data, int target) {
if (null == data) throw new ArgumentNullException(nameof(data));
if (0 == data.Length)
return -1;
// 1.Do a binary search to get within the same zip code of what
// we are looking for.
var ballpark = BinarySearchClosest(data, target, 0, data.Length);
// 2. we are close. The real minimum distance is either
// Math.Abs(data[ballpark]-target) or
// (Math.Abs(data[ballpark+1]-target) IFF (ballpark+1) < data.Length).
var minDist = Math.Abs(data[ballpark]-target);
var imin = ballpark;
if (((imin+1) < data.Length) && (Math.Abs(data[imin+1]-target) < minDist)) {
minDist = Math.Abs(data[imin+1]-target);
imin = imin + 1;
}
return imin;
}
static int[] IndicesOfClosestExistingValues( int[] data, int target)
{
List<int> result = new List<int>();
var imin = IndexOfClosestExistingValue(data, target);
if (imin >= 0) {
var minDist = Math.Abs(data[imin]-target);
result.Add(imin);
// Add equally good matches to the left of imin to the result.
for (var i = imin - 1;
i >= 0 && Math.Abs(data[i]-target) == minDist; i--) {
result.Add(i);
}
// Add equally good matches to the right of imin to the result.
for (var i = imin +1;
i < data.Length && Math.Abs(data[i]-target) == minDist; i++) {
result.Add(i);
}
}
return result.ToArray();
}
internal struct TestCase {
internal int[] data;
internal int target;
internal int[] expected;
}
static string TestCaseToString( TestCase tc) {
var sb = new System.Text.StringBuilder();
sb.AppendFormat(
"TestCase{{ data = {{{0}}}, target = {1}, expected = {{{2}}}}}",
string.Join(", ", tc.data),
tc.target,
string.Join(", ", tc.expected));
return sb.ToString();
}
static void Main(string[] args)
{
TestCase[] testCases =
{ new TestCase{
data = new int[]{},
target = 42,
expected = new int[]{} }, // data.Length == 0
new TestCase{
data = new int[]{1},
target = 42,
expected = new int[]{0} }, // data.Length == 1
new TestCase{
data = new int[]{1, 41, 45, 99},
target = 42,
expected = new int[]{1} }, // somewhere in the middle
new TestCase{
data = new int[]{100,101,102},
target = 42,
expected = new int[]{0} }, // far left
new TestCase{
data = new int[]{1,2,3},
target = 42,
expected = new int[]{2} }, // far right
new TestCase{
data = new int[]{1,1,1,1},
target = 42,
expected = new int[]{3,2,1,0} }, // multiple matches left
new TestCase{
data = new int[]{100,100,100,100},
target = 42,
expected = new int[]{0,1,2,3} }, // multiple matches right
new TestCase{
data = new int[]{41,41,41,41,43,43,43,43},
target = 42,
expected = new int[]{3,2,1,0,4,5,6,7} }, // multiple matches both sides
new TestCase{
data = new int[]{4,6},
target = 5,
expected = new int[]{0,1} } // multiple disjoint matches
};
int failCounter = 0;
int testCaseIndex = 0;
foreach ( var tc in testCases ) {
try {
int[] actual =
IndicesOfClosestExistingValues(tc.data, tc.target);
bool verdict = Enumerable.SequenceEqual(actual, tc.expected);
if (false == verdict)
failCounter++;
Console.WriteLine(
"{1}: {0}, actual = {{{2}}}",
TestCaseToString(tc),
verdict == true ? "OK" : "FAILED",
string.Join(", ", actual));
}
catch (FormatException) {
Console.WriteLine("{0}: FAULTED", testCaseIndex);
}
catch (ArgumentNullException) {
Console.WriteLine("{0}: FAULTED (argument null)", testCaseIndex);
}
finally {
testCaseIndex++;
}
}
Console.WriteLine("Done. ({0} tests failed.)", failCounter);
}
}
}
I did not use C# in many years and if you want to explore algorithms without a lot of lines of code and typing, I strongly recommend to use a more terse language (unless you really want to learn C#). F# is an attractive alternative as it uses the same run time, has the same default libraries and is much more easy on your fingers.