# Reorder the position of the words in alphabetical order

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:

## C++

 `// CPP implementation of the approach` `#include ` `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 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

 `// 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 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

 `# 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#

 `// 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 freq = ``new` `Dictionary();` `        ``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

 ``

## Javascript

 ``

Output

`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:

## C++

 `#include ` `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;` `}`

## Java

 `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);` `    ``}` `}`

## Python3

 `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)`

## C#

 `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`

## Javascript

 `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);`

Output

`1 2 5 3 4 `

Time Complexity: O(N log N)

Auxiliary Space: O(1)

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next