Find the top 5 closest rather than just the closest? - text-processing

Question

How would you find 5 numbers in a column of numbers that are the closest to a $VariableNumber?
For example, if the $VariableNumber = 30 then:
Example input file:
50
100
70
40
20
10
65
41
92
Example output:
20
40
41
10
50
there's an answer that someone’s posted elsewhere before that finds the closest number match in a specific column on a specific line to a given value, which goes as follows:
awk -v col_num="3" -v value="$Number" '
func abs(x) { return (x<0) ? -x : x }
{
distance = abs($col_num - value)
}
NR==1 || distance<shortest_distance {
shortest_distance = distance
nearest_value = $col_num
}
END {
print nearest_value
}
'
But I haven't been able to adapt it

Answer 1

I'd just sort the entries by distance to n and select the first ones like:
awk -v n=30 '
function abs(x) {return x < 0 ? -x : x}
{print abs($0 - n) "\t" $0}' < file |
sort -n |
head -n 5 |
cut -f 2-

Answer 2

As usual, Stéphane’s answer is very good;
simple and straightforward. 
But, if you really really want to do it entirely in awk,
and you have GNU awk (a.k.a. gawk), you can do this:
awk -v t="$VariableNumber" '
{
d = $1 - t
if (d < 0) d = -d
e = d "#" $1
if (NR <= 5) {
a[NR] = e
} else {
a[5+1] = e
asort(a, a, "#val_num_asc")
delete a[5+1]
}
}
END {
print "---"
if (NR <= 5) asort(a, a, "#val_num_asc")
for (i in a) { gsub(".*#", "", a[i]); print a[i]; }
}
'
For each input value,
this computes d as the absolute difference
between that value and the target value,
t (which is set on the command line to the value of $VariableNumber,
which, as per your example, might be 30). 
It then constructs an array entry, e,
consisting of the difference,
concatenated with a # and the original number. 
This array entry is then added to the array a. 
The first five input values are simply put into array elements 1 through 5.
After that, each number is appended to the array
by being put into element 6.  Then the array is sorted. 
Since the array entries start with the difference value,
numbers that are close to the target
(for which the difference value is low)
are sorted to the beginning of the array,
and numbers that are far from the target
are sorted to the end of the array. 
(Specify "#val_num_asc"
to sort the values as numbers rather than strings. 
Without this, differences of 10 and 20 will sort below 3 and 4.) 
Then the 6th element (the one that is farthest from the target) is deleted.
Finally (upon reaching the END of the data), we
Check whether the number of records is ≤ 5. 
If it is, sort the array,
because it is still in the order of the input data. 
(Arguably, this step is optional.)
For each element is the array,
strip off the difference and the #
by searching for the regular expression .*#
and substituting (gsub) nothing. 
Then print the original value.
Obviously, if you want to look at a column other the first one,
you can change all the occurrences of $1 in the script. 
(The script you show in your question
demonstrates how to allow the column number to be specified at run time.) 
And, if you want some number other than the closest five,
just change all appearances of 5. 
(I could have referred to a[6] in lines 9 and 11;
I wrote a[5+1] to facilitate simple-minded parameterization.)

Answer 3

Another, for all awks (tested with gawk, mawk, Debian's original-awk and Busybox awk):
$ awk -v v=30 -v n=5 ' # v is the central value,
function abs(d) { # n is the number of wanted values
return (d<0?-d:d) # d is distance, c array index, va value array
} # da distance array, max is greatest of smallest
((d=abs(v-$1))<max) && c==n { # if we find distance < max of top n smallest
da[maxc]=d # replace max in distance array
va[maxc]=$1 # and in value array
max=0 # set max to min to find new max distance
for(ct in da)
if(da[ct]>max) { # find the new max in the top n smallest
max=da[ct]
maxc=ct
}
if(max==0) # if max is 0, all are 0s so might as well exit
exit
next
}
c<n { # we need n first distances
da[++c]=d # fill distance array with them
va[c]=$1 # related values to value array
if(d>max) { # look for max
max=d
maxc=c
}
}
END { # in the end or exit
for(c in va) # get all values in value array
print va[c] # and output them
}' file
Output (in no particular order, array implementation related):
50
10
41
40
20
Execution time is linear, worst case is size of value array times record count so still linear (right? :).