Skip to content
thecscience
THECSICENCE

Learn everything about computer science

  • Home
  • Human values
  • NCERT Solutions
  • HackerRank solutions
    • HackerRank Algorithms problems solutions
    • HackerRank C solutions
    • HackerRank C++ solutions
    • HackerRank Java problems solutions
    • HackerRank Python problems solutions
thecscience
THECSICENCE

Learn everything about computer science

HackerRank Big Sorting Problem Solution

Yashwant Parihar, April 22, 2023April 28, 2023

In this post, we will solve HackerRank Big Sorting Problem Solution.

Consider an array of numeric strings where each string is a positive number with anywhere from 1 to 106 digits. Sort the array’s elements in non-decreasing, or ascending order of their integer values and return the sorted array.
Example
unsorted = [‘1’, ‘200’, ‘150’, ‘3’]
Return the array [‘1’, ‘3’, ‘150’, ‘200’].

Function Description

Complete the bigSorting function in the editor below.

bigSorting has the following parameter(s):

  • string unsorted[n]: an unsorted array of integers as strings

Returns

  • string[n]: the array sorted in numerical order

Input Format
The first line contains an integer, n, the number of strings in unsorted.
Each of the n subsequent lines contains an integer string, unsorted[i].

Sample Input 0

6
31415926535897932384626433832795
1
3
10
3
5

Sample Output 0

1
3
3
5
10
31415926535897932384626433832795

Explanation 0
The initial array of strings is
unsorted = [31415926535897932384626433832795, 1, 3, 10, 3, 5]. When we order each string by the real-world integer value it represents, we get:
1335 1031415926535897932384626433832795
We then print each value on a new line, from smallest to largest.

Sample Input 1

8
1
2
100
12303479849857341718340192371
3084193741082937
3084193741082938
111
200

Sample Output 1

1
2
100
111
200
3084193741082937
3084193741082938
12303479849857341718340192371
HackerRank Big Sorting Problem Solution
HackerRank Big Sorting Problem Solution

Big Sorting C Solution

#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <limits.h>
#include <stdbool.h>

int cmp(const void *a, const void *b){
    char *sa=*(char **)a;
    char *sb=*(char **)b;
    // cannot do simple strcmp, need to account also for strlen
    int la=strlen(sa), lb = strlen(sb);
    if(la==lb)
        return strcmp(sa,sb);  
    else
        return la<lb ? -1 : la>lb;
}

int main(){
    // Enter your code here. Read input from STDIN. Print output to STDOUT
    int n;
    scanf("%d",&n);
    char **s=malloc(n*sizeof(char *));
    char stemp[1000001];
    for(int i=0;i<n;i++){
        scanf("%s",stemp);
        s[i]=(char *)malloc((strlen(stemp)+1)*sizeof(char));
        strcpy(s[i],stemp);
    }
    qsort(s,n,sizeof(char *),cmp);
    for(int i=0;i<n;i++){
        printf("%s\n",s[i]);
    }   
    return 0;
}

Big Sorting C++ Solution

#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <map>
#include <algorithm>
using namespace std;


int main() {
    /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
    int n;
    cin >> n;
    map<int,vector<string>> m;
    while(n--){
        string s;
        cin >> s;
        m[s.length()].push_back(s);
    }
    for(auto& v : m){
        sort(v.second.begin(),v.second.end());
    }
    for(auto& v : m){
        for(auto& x : v.second){
            cout << x << '\n';
        }
    }
    return 0;
}

Big Sorting C Sharp Solution

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Numerics;
class Solution {
    
    static void Main(String[] args) 
    {
        int n = Convert.ToInt32(Console.ReadLine());
        String [] S = new String[n];
        for(int i = 0; i < n; i++)  S[i] = Console.ReadLine().Trim();   
        Array.Sort(S, StringAsIntegerCompare);
        Console.WriteLine(string.Join(Environment.NewLine, S));
    }
    
    void BigSortingUsingInBuiltQuickSortOP()
    {
        int n = Convert.ToInt32("6");
        string [] S = { "2", "1", "3", "10", "3", "5" };
        Console.WriteLine(string.Join(" ", S));
        Array.Sort(S, StringAsIntegerCompare);
        Console.WriteLine(string.Join(" ", S));
    }

    static int StringAsIntegerCompare(String s1, String s2)
    {
        if(s1.Length > s2.Length) return 1;
        if(s1.Length < s2.Length) return -1;
        for(int i = 0; i < s1.Length; i++)
        {
            if((int)s1[i] > (int)s2[i]) return 1;
            if((int)s1[i] < (int)s2[i]) return -1;
        }
        return 0;
    }
    
    
}

Big Sorting Java Solution

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 'bigSorting' function below.
     *
     * The function is expected to return a STRING_ARRAY.
     * The function accepts STRING_ARRAY unsorted as parameter.
     */

    public static List<String> bigSorting(List<String> unsorted) {
        Map<Integer, List<String>> coll = new TreeMap();
for(String s: unsorted){
    Integer key= s.length();
    if(coll.containsKey(key)){
        coll.get(key).add(s);
    }else{
        List<String> list= new ArrayList<>();
        list.add(s);
        coll.put(key, list);
    }
}
List<String>result= new ArrayList<>();
for(var entry: coll.entrySet()){
    Collections.sort(entry.getValue());
    result.addAll(entry.getValue());
    
}
 return result;

    }
   
}

public class Solution {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));

        int n = Integer.parseInt(bufferedReader.readLine().trim());

        List<String> unsorted = IntStream.range(0, n).mapToObj(i -> {
            try {
                return bufferedReader.readLine();
            } catch (IOException ex) {
                throw new RuntimeException(ex);
            }
        })
            .collect(toList());

        List<String> result = Result.bigSorting(unsorted);

        bufferedWriter.write(
            result.stream()
                .collect(joining("\n"))
            + "\n"
        );

        bufferedReader.close();
        bufferedWriter.close();
    }
}

Big Sorting JavaScript Solution

process.stdin.resume();
process.stdin.setEncoding('ascii');

var input_stdin = "";
var input_stdin_array = "";
var input_currentline = 0;

process.stdin.on('data', function (data) {
    input_stdin += data;
});

process.stdin.on('end', function () {
    input_stdin_array = input_stdin.split("\n");
    main();    
});

function readLine() {
    return input_stdin_array[input_currentline++];
}

/////////////// ignore above this line ////////////////////

function main() {
    var n = parseInt(readLine());
    var unsorted = [];
    for(var unsorted_i = 0; unsorted_i < n; unsorted_i++){
       unsorted[unsorted_i] = readLine();
    }
    // your code goes here
        unsorted.sort(function(a,b) { 
        if (a.length > b.length) {
            return 1;
        } else if (a.length == b.length) {
            var aChars = a.split('');
            var bChars = b.split('');
            
            for (var iter = 0; iter < a.length && iter < b.length; iter++) {
                var currentANum = parseInt(aChars[iter]);
                var currentBNum = parseInt(bChars[iter]);
                
                if (currentANum > currentBNum) {
                    return 1;
                } else if (currentANum < currentBNum) {
                    return -1;
                } else {
                    // Do nothing so that we fall to the next character position comparison
                }
            }
            
            return 0;
        } else {
            return -1;
        }
    });
    
    unsorted.forEach(function(currentItem) {
        console.log(currentItem);
    });

}

Big Sorting Python Solution

#!/bin/python3

import sys


n = int(input().strip())
ordem = {}
unsorted_i = 0
for unsorted_i in range(n):
    unsorted_t = str(input().strip())
    size = len(unsorted_t)
    if size in ordem:
       ordem[size].append(unsorted_t)
    else:
       ordem[size] = [unsorted_t]

tamanhos = sorted(ordem)
for t in tamanhos:
    l = sorted(ordem[t])
    for n in l:
       print(n)
        

Other Solutions

  • HackerRank Super Reduced String Solution
  • HackerRank Intro to Tutorial Challenges Solution
c C# C++ HackerRank Solutions java javascript python CcppCSharpHackerrank Solutionsjavajavascriptpython

Post navigation

Previous post
Next post

Leave a Reply

You must be logged in to post a comment.

  • HackerRank Dynamic Array Problem Solution
  • HackerRank 2D Array – DS Problem Solution
  • Hackerrank Array – DS Problem Solution
  • Von Neumann and Harvard Machine Architecture
  • Development of Computers
©2025 THECSICENCE | WordPress Theme by SuperbThemes