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

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