Absolute Value Sort

[esthicodes]

Absolute Value Sort

Given an array of integers arr, write a function absSort(arr), that sorts the array according to the absolute values of the numbers in arr. If two numbers have the same absolute value, sort them according to sign, where the negative numbers come before the positive numbers.

Examples:

input:  arr = [2, -7, -2, -2, 0]
output: [0, -2, -2, 2, -7]
Constraints:

[time limit] 5000ms
[input] array.integer arr
0 ≤ arr.length ≤ 10
[output] array.integer

[esthicodes]

// Given an array of integers arr, 
// a function absSort(arr),
// sorts the array according to the absolute values of the numbers in arr. 
// If two numbers have the same absolute value, 
//sort them according to sign, where the negative numbers come before the positive numbers.

// I can read question. 
// can you write the pseudocode? 


// Sure.
// example: input:  arr = [2, -7, -2, -2, 0]
// output: [0, -2, -2, 2, -7] 

/*
Sol #1: Implement comparator. Then sort it.



You don't need to write question.
I can see question in left section

// We can try either a selection sort, or leveraging the sort function in the language library. Do you know selection sort? 

// Yes, I know.
// so we can take the largest unsorted value 
// put it as the next element.
// can you tell the details

// In another view, do you know sort func in Java?
Collections.sort
Arrays.sort

That provide quick sort.
So I can customize sort order.
// sure 
// do you know what do we have to write if you want to know
// which element is the largest? 
// we need to write a custom comparision function
// Yes. Thanks

// In comparator, compare abb number for numbers. 
// Let me write comparator below.
// Below is comparator.
// where could you write a custom comparision function 
// to leverage the sort function in our library
// Just a moment.

// Pleae review below code with custom comparision.
// Does it make sense?

// moment 
// ok my name is esthicodes on Github. you?
*/

import java.io.*;
import java.util.*;
import java.util.stream.*;

class Solution {

	static int[] absSort(int[] arr) {

    
    List<Integer> list = IntStream.of(arr).boxed().collect(Collectors.toList());
    
    Comparator<Integer> cmp = (o1,o2) -> {
      int ret = Integer.compare(Math.abs(o1), Math.abs(o2));
      if( ret != 0) return ret;
      else return Integer.compare(o1, o2);      
    };
    
    Collections.sort(list, cmp);
    
    
    return list.stream().mapToInt(e->e).toArray();
    
    // let's run code
    // It's done.
//    (o1, o2) -> Math.abs(o1) != Math.abs(o2) ? Integer.compare(Math.abs(o1), Math.abs(o2)) : Integer.compare(o1, o2 );
    
//    Arrays.sort(arr, (o1, o2) ->  Integer.compare(Math.abs(o1), Math.abs(o2))  );
  
  
  
    //Arrays.sort(arr);
    
    //return arr; 
    
    // amazing could you explain how? 
    // Do you know Java? Yes a bit
    // In JDK, it provides comparator which used in sort.
    // Comparator return neg, 0, pos number according to rule.
    // So I can custom that rule. Line 68~72
    // Thank you.
    // A JDK is a package right. Yes. 
    // Sort of JDK provide quick sort.
    //  AVG: O(n^Logn) WORST: O(N^2) BEST(nLogn)
    //  So it is better than selection sort that is AVG, WORST is O(N^2)
 
    // or how do we differentiate it?
    // what is the difference between worst and best case in O(N^2) and best(nLogn)? 
    // Please refer sort algorithms in DSA.
    // ok, congratulations, 
    
    
	}

	public static void main(String[] args) {
	}
}```