Full Counting Sort

import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.function.*;
import java.util.regex.*;
import java.util.stream.*;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;

class Result {

    /*
     * Complete the 'countSort' function below.
     *
     * The function accepts 2D_STRING_ARRAY arr as parameter.
     */

    public static void countSort(List<List<String>> arr) {
    // Write your code here
    for (int i = 0; i <arr.size()/2; i++){
        arr.get(i).set(1, "-");
    }

    StringBuilder sb = new StringBuilder("");
    /*StringBuilder[] sbArray = new StringBuilder[100];
    for(int i=0;i<100;i++)
    {
        sbArray[i]=new StringBuilder("");
    }*/

    LinkedHashMap<String, StringBuilder> sbMap = new LinkedHashMap<>();
    for (int i = 0; i < 100; i++){
        sbMap.put(String.valueOf(i), new StringBuilder(""));
    }
    //Sort using custom comparator
    /*Collections.sort(arr, new IndexComparator());

    for (List l : arr){
        System.out.print(l.get(1) + " ");
    }*/



    //Iterate over all possible index values
    //Convert to String
    //Iterate over arr and match index to String
    /*for (int i = 0; i < 100; i++){
        String s = String.valueOf(i);
        for (int j = 0; j < arr.size(); j++){
            if (arr.get(j).get(0).equals(s)){
                System.out.print(arr.get(j).get(1));
                System.out.print(" ");
                arr.remove(arr.get(j));
                j--;
            }
        }
    }*/

    //Create a List of List<String>
    //Populate List with 100 empty List<String>
    //Convert indecies to int and add String to relevant index
    /*ArrayList<ArrayList<String>> result = new ArrayList<ArrayList<String>>();
    for (int i = 0 ; i < 100; i++){
        result.add(new ArrayList<String>());
    }

    for (int i = 0; i < arr.size(); i++ ){
        int index = Integer.valueOf(arr.get(i).get(0).toString());
        String s = i < arr.size()/2 ? "-" : arr.get(i).get(1);
        result.get(index).add(s);
    }*/


    //Same as above but convert String to "-" before iteration
    /*for (List l : arr){
        result.get(Integer.valueOf(l.get(0).toString())).add(l.get(1).toString());
    }*/



    /*for (ArrayList l : result){
        for (int i = 0; i < l.size(); i++){
            sb.append(l.get(i));
            sb.append(" ");
        }
    }*/



    //Create a List<Integer>
    //Add all indicies to List
    //Sort List into ascending order
    //remove all duplicates from List<Integer>
    //for-each index, iterate over arr and print all matches
    /*List<Integer> numbers = new ArrayList<>();

    for (List l : arr){
        numbers.add(Integer.valueOf(l.get(0).toString()));
    }

    Collections.sort(numbers);

    numbers = numbers.stream().distinct().collect(Collectors.toList());


    //List <String> result = new ArrayList<>();

    for (Integer i : numbers){
        for (List l : arr){
            if (Integer.valueOf(l.get(0).toString()).equals(i)){
                System.out.print(l.get(1) + " ");

            }
        }
    }*/

    /*String s;

    for (int i = 0; i < 100; i++){
        s = String.valueOf(i);
        for (int j = 0; j < arr.size(); j++){
            if (arr.get(j).get(0).equals(s)){
                if (j < arr.size()/2){
                    sb.append("-");
                } else {
                    sb.append(arr.get(j).get(1));
                }
                sb.append(" ");
            }
        }
    }*/
    String index;
    for (int i = 0; i < arr.size(); i++){
       index = arr.get(i).get(0);
        /*if (i < arr.size()/2){
            sbMap.get(index).append("-");
        } else {*/
            sbMap.get(index).append(arr.get(i).get(1));
        //}
        sbMap.get(index).append(" ");
    }

    for (Map.Entry<String, StringBuilder> entry : sbMap.entrySet()){
        sb.append(entry.getValue());
    }

    System.out.println(sb);

    }

    /*public static class IndexComparator implements Comparator<List<String>>{
        @Override
        public int compare(List<String> first, List<String> second){
            String firstIndex = first.get(0);
            String secondIndex = second.get(0);

            //if (firstIndex.length() != secondIndex.length()){
                int firstI = Integer.parseInt(firstIndex);
                int secondI = Integer.parseInt(secondIndex);
                return Integer.compare(firstI, secondI);
            //}

            //return firstIndex.compareTo(secondIndex);
        }
    }*/

}