# Nearest Value Challenge

Nearest Value - python coding challenges - Py.CheckiO

I saw this same challenge posted but they went about it a different way.
I am trying to use a dictionary to sort the values by their difference from the given integer
The problem I am having is that if two values are the same distance apart you must pick the lower value. My code returns the higher value and to me it seems arbitrary?

You are given a list of values as set form and a value for which you need to find the nearest one.

For example , we have the following set of numbers: 4, 7, 10, 11, 12, 17, and we need to find the nearest value to the number 9. If we sort this set in the ascending order, then to the left of number 9 will be number 7 and to the right - will be number 10. But 10 is closer than 7, which means that the correct answer is 10.

A few clarifications:

• If 2 numbers are at the same distance, you need to choose the smallest one;
• The set of numbers is always non-empty, i.e. the size is >=1;
• The given value can be in this set, which means that it’s the answer;
• The set can contain both positive and negative numbers, but they are always integers;
• The set isn’t sorted and consists of unique numbers.

Input: Two arguments. A list of values in the set form. The sought value is an int.

Output: Int.

``````def nearest_value(values: set, y: int):
new_dict = {}
for x in values:
new_dict.update({abs(y-x): x})
new_list = sorted(new_dict.keys())
return new_dict[new_list[0]]
``````

I think you’ll have a little trouble here with dictionary keys, consider printing out that dictionary for situations where you can have equal spacing so you know exactly what’s in it at that point.

Thanks for the response! Yeah, I have tried printing the dictionary to see what is going on. It simply doesn’t include the lower value if there are two values equidistant from the given integer. I may try going about it in a different way altogether.

Sounds like a good plan, dictionary keys must be unique so you’ll lose one or more of your results when there are multiple values the same distance apart from the target. Always worth getting a print or something in your code to see what’s what when things aren’t behaving as expected.

Ah, of course. Yeah, how could you use a dictionary with duplicate keys. However, I actually figured out away around it. I just reverse ordered the given set so that it gives precedence to the lower value. It may still have exceptions but it passed all the challenge’s assertions! Thanks for your time, I’m still very new at this.

``````def nearest_value(values: set, y: int):
new_dict = {}
values = list(values)
values.sort(reverse=True)
for x in values:
new_dict.update({abs(y-x): x})
new_list = sorted(new_dict.keys())
return new_dict[new_list[0]]
``````