Discussion on The Full Counting Sort Challenge

Sort 658 Discussions, By:

2 weeks ago+ 0 comments

def countSort(arr):
    n = len(arr)
    mid = n // 2
    ar = [''] * n
    for i in range(n):
        ar[int(arr[i][0])] += "- " if i < mid else arr[i][1] + " "

    for i in range(n):
        print(ar[i], end='')

3 weeks ago+ 0 comments

I'm trying to replicate the Full Counting Sort question with a really small change, which some of you may have seen.

In my adaptation, I expect everything to work exactly like the Full Counting Sort problem, with the only difference being that instead of a "-"being shown, I would expect a "lol" instead.

So let me run you through my thought process here.

We are given a List of Lists List<List<String>> like this [['1','a'],['3','c'],['2','b'],['4','d']] and we are to convert it into a string (How it is done is explained via the link above).

So my thought process was to

Create a hashmap from the inputs provided, where x[0] would be the keys (In my example List, x[0] would be'1','2','3','4' would be the keys and the string associates with them would be the values
Firstly, (before sorting), change the keys of the first half elements of the Hashmap to "lol" similar to how the instructions on the site require us to change it to "-".
Change the data type of the keys from string to ints, to facilitate with sorting. This is done by copying the data from the original hashmap to a new hashmap, changing the data type during the conversion.
Sort the array using the keys, which are now ints, using a treemap.
Create a stringbuilder and then iterate over the tree map and append the treemap values to the stringbuilder.

Now that I've explained my thought process, here is my code.

public class hackkerankstuff {
    public static void countSort(List<List<String>> arr) {
        //taking the input List<List<String>> and storing it as a Hashmap
        HashMap<String, String> p = new HashMap<>();
        for (List<String> mapping : arr) {
            p.put(mapping.get(0), mapping.get(1));
        }
        //converting the values of the first half of the keys to a "lol"
        int maxiterations = p.keySet().size() / 2;
        Iterator<String> iterator = p.keySet().iterator();
        for (int i=0; i < maxiterations; i++) {
            if (iterator.hasNext()) {
                String key = iterator.next();
                p.replace(key, "lol");
            }
        }
        //Converting data type of key to int
        Map<Integer, String> map2= new HashMap<>();
        for(Map.Entry<String, String> entry : p.entrySet())
            map2.put(Integer.parseInt(entry.getKey()), entry.getValue());

        //sort the map based on the keys, since they are now ints
        TreeMap<Integer, String> sorted = new TreeMap<>();
        sorted.putAll(map2);

        //create a stringbuilder to add the Treemap values to the stringbuilder
        StringBuilder s = new StringBuilder();
        for (Map.Entry<Integer, String>
                entry : sorted.entrySet()) {
            s.append(entry.getValue()).append(" ");
        }

        //after running the program, s should return the string as expected.

Is there any way I could change this to improve this code or are there any edits necessary to be made based on what you see?

Thank you.

Is there any way I could change this to improve this code or are there any edits necessary to be made based on what you see?

Thank you.

4 weeks ago+ 0 comments

Here is The Full Counting Sort problem solution in Python Java C++ and C programming - https://programs.programmingoneonone.com/2021/05/hackerrank-the-full-counting-sort-solution.html

1 month ago+ 0 comments

A Java solution (works in Java 15 because in Java 8 Testcase 5 has timeout error):

public static void countSort(List<List<String>> arr) {
        // change the first half of the strings to "-"
        for (int i = 0; i < arr.size() / 2; i++) {
            List<String> tempList = arr.get(i);
            tempList.set(1, "-");
            arr.set(i, tempList);
        }
        // order the list
        arr.sort(Comparator.comparingInt(s -> Integer.parseInt(s.get(0))));
        // make a stringJoiner
        StringJoiner stringJoiner = new StringJoiner(" ");
        for (List<String> element : arr) {
            stringJoiner.add(element.get(1));
        }
        System.out.println(stringJoiner);
    }

2 months ago+ 0 comments

Just a few lines if you guys write in Ruby. TBH, the time it took me to understand the description of this problem is many times larger than the time it took me to write the code. I also use both Leetcode and Hackerrank, but the time it took me to understand the description of Leetcode's problem is just 2-3 minutes. Is my English too bad :(

def countSort(arr)
  bucket = []
  arr.each.with_index do |el, i|
    num = el[0].to_i
    str = i < arr.length / 2 ? '-' : el[1]
    bucket[num] = [] if bucket[num].nil?
    bucket[num] << str
  end
  puts bucket.compact.map { |el| el.join(' ') }.join(' ')
end

Load more conversations