I don't understand the logic of the mentor's solution.

Question about the task

Read online about the median of a sample

Resolved

Why does he multiply v1 and v2 with themselves and then multiply the result by 100?

public static Integer[] sort(Integer[] array) {
        final double mediana = getMediana(array);

        Arrays.sort(array, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                double v1 = o1.intValue() - mediana;
                double v2 = o2.intValue() - mediana;
                return (int) ((v1 * v1 - v2 * v2) * 100);
            }
        });

Implement the logic of the sort() method. It must sort the data in the array according to its distance from the median.
Return the array sorted from the least to greatest distance.
If several numbers are equally distant, then sort them in ascending order.

Example input array:

13, 8, 15, 5, 17
The median is 13

Sorted array:

13, 15, 17, 8, 5

Requirements:

The program should not output text to the console.
The program must NOT read data from the console.
The Solution class must have a public static Integer[] sort(Integer[] array) method.
The Solution class's sort(Integer[] array) method must sort the data in the array according to its distance from the median.

package com.codegym.task.task26.task2601; /* Read online about the median of a sample */ import java.util.Arrays; import java.util.Comparator; public class Solution { public static void main(String[] args) { Integer[] array = new Integer[]{13,8,15,5,17}; sort(array); for (Integer integer : array) System.out.println(integer); } public static Integer[] sort(Integer[] array) { // Implement the logic here //identify the median double median = getMedian(array); //System.out.println(median); //least difference from the median first. if difference identical, sort ascending Comparator<Integer> medianComp = new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { return (int) (o1.intValue() - median - o2.intValue() - median); } }; Arrays.sort(array); return array; } public static double getMedian(Integer[] array){ // First we sort the array Arrays.sort(array); // check for even case if (array.length % 2 != 0) return (double)array[array.length / 2]; return (double)(array[array.length / 2 - 1] + array[array.length / 2]) / 2.0; } }

Comments (5)

Popular
New
Old

You must be signed in to leave a comment

Guadalupe Gagnon

Level 37 , Tampa, United States

4 May 2021, 17:08

solution

It forces the values of v1 and v2 to be positive. Take, for example, if you had a median of 13 and number 15 and 11 (both are 2 away from the median). If you did not multiply them then your equation would look like this: (-2 - 2) * 100 or (2 - -2) * 100 [depending on which one was o1 and which was o2] resulting in either -400 or 400. If you do that then one will clearly will be greater than the other, however in this scenario they are both the same. Now if you multiply them both then the equation looks more like this: (4-4) * 100 which results in the correct answer of 0. I don't like the solution however as:

return Double.compare(v1, v2);

works and is way easier to read/understand

Guadalupe Gagnon

Level 37 , Tampa, United States

4 May 2021, 17:10

Also.. if you do not multiply by 100 then any decimal values will be truncated when converted to an int. For example if the result was .25, meaning o1 is greater than o2, then when the conversion to int occurs it will return 0 instead and say that o1 is equal to o2.

Andrei

Level 41

4 May 2021, 17:49

But what if the difference is larger then 100? Do you have to take that into account somehow? Or that isn't possible? Also, what you mean is that this

return Double.compare(v1, v2);

is easier to understand than this? And it does the same thing?

return (int) ((v1 * v1 - v2 * v2) * 100);

Guadalupe Gagnon

Level 37 , Tampa, United States

4 May 2021, 19:12

useful

Nope. The compare method for anything returns - a positive int if the first argument is greater than the second - a negative int if the first argument is less than the second - 0 if both arguments are equal Higher or lower numbers don't matter at all. The only thing that is used is if the number is positive, negative, or 0. The Double.compare(double arg1, double arg2) will return - a positive int if the first argument is greater than the second - a negative int if the first argument is less than the second - 0 if both arguments are equal You also have Integer.compare(), Short.compare(), Boolean.compare(), Long.compare() etc... all do the same exact thing. Also, there is a compareTo() method on classes that implement the Comparable interface that works the same exact way. One example is the String class: "some string".compareTo("some other string") This would return: - a positive int if the first argument is greater than the second - a negative int if the first argument is less than the second - 0 if both arguments are equal Most Java standard objects have the compareTo() method implemented. You can make your own classes that implement this by just adding: class MyClass implements Comparable<MyClass> to your class definition. You then have to write the logic for the compareTo(MyClass o) method keeping in mind that you want to return - a positive int in the case that the object (this) is greater than the compared object (o) - a negative int in the case that the object is less than the compared object - 0 if both objects are identical

Andrei

Level 41

5 May 2021, 07:38

Awesome explanation, I wasn't sure if we have to use the int result of the compare method but you cleared that up for me without even asking ! Thank you! ✌