Given an array arr[] of strings, the task is to reorder the strings lexicographically and print their positions in the original list.
Examples:
Input: arr[] = {“zxc”, “efg”, “jkl”}
Output: 2 3 1
The sorted list will be {“efg”, “jkl”, “zxc”} and their
original positions were 2, 3 and 1 respectively.
Input: arr[] = {“live”, “place”, “travel”, “word”, “sky”}
Output: 1 2 5 3 4
Approach: Assign all the words with an integer number equal to their position in the array. Then they sort the list of words lexicographically and their positions are altered, and therefore, their positions are printed starting from the first word in the sorted list.
Below is the implementation of the above approach:
// CPP implementation of the approach #include <bits/stdc++.h> using namespace std;
// Function to print the ordering of words void reArrange(string words[], int n)
{ // Creating list of words and assigning
// them index numbers
map<string, int > mp;
for ( int i = 0; i < n; i++)
mp[words[i]] = i + 1;
// Sort the list of words
// lexicographically
sort(words, words + n);
// Print the ordering
for ( int i = 0; i < n; i++)
cout << mp[words[i]] << " " ;
} // Driver Code int main()
{ string words[] = { "live" , "place" , "travel" , "word" , "sky" };
int n = sizeof (words) / sizeof (words[0]);
reArrange(words, n);
} // This code is contributed by // Surendra_Gangwar |
// Java implementation of the approach import java.util.*;
class GFG {
// Function to print the ordering of words
static void reArrange(String words[], int n)
{
// Creating list of words and assigning
// them index numbers
HashMap<String, Integer> freq = new HashMap<>();
for ( int i = 0 ; i < n; i++) {
freq.put(words[i], (i + 1 ));
}
// Sort the list of words
// lexicographically
Arrays.sort(words);
// Print the ordering
for ( int i = 0 ; i < n; i++)
System.out.print(freq.get(words[i]) + " " );
}
// Driver Code
public static void main(String[] args)
{
String words[] = { "live" , "place" , "travel" , "word" , "sky" };
int n = words.length;
reArrange(words, n);
}
} |
# Python3 implementation of the approach # Function to print the ordering of words def reArrange(words, n):
# Creating list of words and assigning
# them index numbers
mp = {}
for i in range (n):
mp[words[i]] = i + 1
# Sort the list of words
# lexicographically
words.sort();
# Print the ordering
for i in range (n):
print (mp[words[i]], end = " " )
# Driver Code words = [ "live" , "place" , "travel" , "word" , "sky" ]
n = len (words)
reArrange(words, n); # This code is contributed by # Rajnis09 |
// C# implementation of the approach using System;
using System.Collections.Generic;
class GFG {
// Function to print the ordering of words
static void reArrange(String[] words, int n)
{
// Creating list of words and assigning
// them index numbers
Dictionary<String, int > freq = new Dictionary<String, int >();
for ( int i = 0; i < n; i++) {
freq.Add(words[i], (i + 1));
}
// Sort the list of words
// lexicographically
Array.Sort(words);
// Print the ordering
for ( int i = 0; i < n; i++)
Console.Write(freq[words[i]] + " " );
}
// Driver Code
public static void Main(String[] args)
{
String[] words = { "live" , "place" , "travel" , "word" , "sky" };
int n = words.Length;
reArrange(words, n);
}
} // This code contributed by Rajput-Ji |
<?php // PHP implementation of the approach // Function to print the ordering of words
function reArrange( $words , $n )
{
// Creating list of words and assigning
// them index numbers
$freq = array ();
for ( $i = 0; $i < $n ; $i ++)
{
$freq [ $words [ $i ]] = ( $i + 1) ;
}
// Sort the list of words
// lexicographically
sort( $words );
// Print the ordering
for ( $i = 0; $i < $n ; $i ++)
echo $freq [ $words [ $i ]], " " ;
}
// Driver Code
$words = array ( "live" , "place" , "travel" , "word" , "sky" );
$n = count ( $words );
reArrange( $words , $n );
// This code is contributed by Ryuga
?> |
<script> // Javascript implementation of the approach // Function to print the ordering of words function reArrange(words, n)
{ // Creating list of words and assigning
// them index numbers
var mp = new Map();
for ( var i = 0; i < n; i++)
mp.set(words[i], i + 1);
// Sort the list of words
// lexicographically
words.sort();
// Print the ordering
for ( var i = 0; i < n; i++)
{
document.write(mp.get(words[i])+ " " );
}
} // Driver Code var words = [ "live" , "place" , "travel" , "word" , "sky" ];
var n = words.length;
reArrange(words, n); </script> |
1 2 5 3 4
Time Complexity: O(n * log n)
Auxiliary Space: O(n)
Approach:
The approach is to create a vector of integers representing the original indices of the strings, sort the vector of indices based on the strings using a lambda function that compares the corresponding strings, and then print the sorted vector of indices.
Implementation of the above approach:
#include <bits/stdc++.h> using namespace std;
bool compare(string a, string b) { return a < b; }
void reArrange(string words[], int n)
{ // Create a vector of indices
vector< int > indices(n);
for ( int i = 0; i < n; i++) {
indices[i] = i + 1;
}
// Sort the vector of indices based on the strings
sort(indices.begin(), indices.end(), [&]( int a, int b) {
return compare(words[a - 1], words[b - 1]);
});
// Print the sorted vector of indices
for ( auto index : indices) {
cout << index << " " ;
}
} int main()
{ string words[]
= { "live" , "place" , "travel" , "word" , "sky" };
int n = sizeof (words) / sizeof (words[0]);
reArrange(words, n);
return 0;
} |
import java.util.*;
class GFG {
public static boolean compare(String a, String b)
{
return a.compareTo(b) < 0 ;
}
public static void reArrange(String[] words)
{
// Create an array of indices
Integer[] indices = new Integer[words.length];
for ( int i = 0 ; i < words.length; i++) {
indices[i] = i + 1 ;
}
// Sort the array of indices based on the strings
Arrays.sort(
indices,
(a, b)
-> compare(words[a - 1 ], words[b - 1 ]) ? - 1
: 1 );
// Print the sorted array of indices
for (Integer index : indices) {
System.out.print(index + " " );
}
}
public static void main(String[] args)
{
String[] words
= { "live" , "place" , "travel" , "word" , "sky" };
reArrange(words);
}
} |
def reArrange(words):
n = len (words)
# Create a list of indices
indices = [i + 1 for i in range (n)]
# Sort the list of indices based on the strings
indices.sort(key = lambda x: words[x - 1 ])
# Print the sorted list of indices
for index in indices:
print (index, end = ' ' )
words = [ "live" , "place" , "travel" , "word" , "sky" ]
reArrange(words) |
using System;
using System.Linq;
public class GFG {
static bool Compare( string a, string b)
{
return a.CompareTo(b) < 0;
}
static void reArrange( string [] words, int n)
{
// Create an array of indices
int [] indices = Enumerable.Range(1, n).ToArray();
// Sort the array of indices based on the strings
Array.Sort(indices, (a, b) = > Compare(words[a - 1],
words[b - 1])
? -1
: 1);
// Print the sorted array of indices
Console.WriteLine( string .Join( " " , indices));
}
public static void Main()
{
string [] words
= { "live" , "place" , "travel" , "word" , "sky" };
int n = words.Length;
reArrange(words, n);
}
} // This code is contributed by prasad264 |
function compare(a, b) {
return a.localeCompare(b) < 0;
} function reArrange(words) {
// Create an array of indices
let indices = Array.from({ length: words.length }, (_, i) => i + 1);
// Sort the array of indices based on the strings
indices.sort((a, b) => (compare(words[a - 1], words[b - 1]) ? -1 : 1));
// Print the sorted array of indices
let result = "" ;
for (let index of indices) {
result += index + " " ;
}
console.log(result.trim());
} let words = [ "live" , "place" , "travel" , "word" , "sky" ];
reArrange(words); |
1 2 5 3 4
Time Complexity: O(N log N)
Auxiliary Space: O(1)