Print all Unique Strings present in a given Array
Last Updated :
21 Mar, 2023
Given an array of strings arr[], the task is to print all unique strings that are present in the given array.
Examples:
Input: arr[] = { "geeks", "geek", "ab", "geek" "code", "karega" }
Output: geeks ab code karega
Explanation:
The frequency of the string "geeks" is 1.
The frequency of the string "geek" is 2.
The frequency of the string "ab" is 1.
The frequency of the string "code" is 1.
The frequency of the string "karega" is 1.
Therefore, the required output is "geeks ab code karega"
Input: arr[] = { "abcde", "abcd", "abcd", "co" "", "code" }
Output: abcde co code
Naive Approach: The simplest approach to solve this problem is to traverse the array for every string encountered, check if that string occurs in the remaining array or not. Print those strings which are occurring only once in the array.
Time Complexity: O(N2 * M), where M is the maximum length of the string
Auxiliary Space: O(1)
Efficient Approach using STL:
Another approach to print all the unique elements in array is by using unordered_map.
Steps involved in this approach are as follows:
- In first step an unordered_map(freqMap) is declared, which will be used to store the frequency of each string in the array.
- Then we run a for loop for all the elements of the array. In each iteration, the frequency of the i-th string in the array is incremented in the map.
- Then we iterate through this unordered_map and print all the strings which is present only one time in the array.
Below is the code for the above approach.
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to Print all Unique Strings
// present in a given Array
void printUniqueStrings(vector<string> arr) {
unordered_map<string, int> freqMap;
// Count the frequency of each string in arr
for (auto str : arr) {
++freqMap[str];
}
// Print unique strings in arr
for (auto p : freqMap) {
if (p.second == 1) {
std::cout << p.first << " ";
}
}
}
int main() {
vector<string> arr = {"geeks", "for",
"geek", "ab", "geek",
"for", "code", "karega"};
printUniqueStrings(arr);
return 0;
}
// This code is contributed by Vaibhav
// Java code
import java.util.*;
public class Main {
// Function to Print all Unique Strings
// present in a given Array
static void printUniqueStrings(String[] arr) {
Map<String, Integer> freqMap = new HashMap<>();
// Count the frequency of each string in arr
for (String str : arr) {
freqMap.put(str, freqMap.getOrDefault(str, 0) + 1);
}
// Print unique strings in arr
for (Map.Entry<String, Integer> entry : freqMap.entrySet()) {
if (entry.getValue() == 1) {
System.out.print(entry.getKey() + " ");
}
}
}
public static void main(String[] args) {
String[] arr = {"geeks", "for", "geek", "ab", "geek", "for", "code", "karega"};
printUniqueStrings(arr);
}
}
# Function to Print all Unique Strings
# present in a given Array
def printUniqueStrings(arr):
freqMap = {}
# Count the frequency of each string in arr
for str in arr:
freqMap[str] = freqMap.get(str, 0) + 1
# Print unique strings in arr
for key, value in freqMap.items():
if value == 1:
print(key, end=" ")
arr = ["geeks", "for", "geek", "ab", "geek", "for", "code", "karega"]
printUniqueStrings(arr)
using System;
using System.Collections.Generic;
class MainClass
{
// Function to Print all Unique Strings
// present in a given Array
static void printUniqueStrings(string[] arr) {
Dictionary<string, int> freqMap = new Dictionary<string, int>();
// Count the frequency of each string in arr
foreach (string str in arr) {
freqMap[str] = freqMap.GetValueOrDefault(str, 0) + 1;
}
// Print unique strings in arr
foreach (KeyValuePair<string, int> entry in freqMap) {
if (entry.Value == 1) {
Console.Write(entry.Key + " ");
}
}
}
public static void Main(string[] args) {
string[] arr = {"geeks", "for", "geek", "ab", "geek", "for", "code", "karega"};
printUniqueStrings(arr);
}
}
function printUniqueStrings(arr) {
let freqMap = {};
// Count the frequency of each string in arr
for (let str of arr) {
freqMap[str] = (freqMap[str] || 0) + 1;
}
// Print unique strings in arr
for (let [key, value] of Object.entries(freqMap)) {
if (value === 1) {
console.log(key + " ");
}
}
}
let arr = ["geeks", "for", "geek", "ab", "geek", "for", "code", "karega"];
printUniqueStrings(arr);
Outputkarega code ab geeks
Time Complexity: O(N*M) where N is the number of strings in the array and M is the maximum length of the strings.
Space Complexity: O(N*M)
Efficient Approach: The above approach can be optimized using Trie. The idea is to traverse the array and for every ith string in the array, check if arr[i] is present in the Trie or not. If found to be true, then mark arr[i] as duplicate array element. Otherwise, mark arr[i] as unique array element and insert arr[i] into the trie. Follow the steps below to solve the problem:
- Initialize an array, say isUniq[], to check if an array element is unique or not.
- Create a Trie having a root node, say root, to store the characters of each string present in the given array.
- Traverse the array using variable i and for every ith element, check if arr[i] is present in the Trie or not. IF found to be true, then update isUniq[i] to false.
- Otherwise, update isUniq[i] to true and insert arr[i] into the Trie.
- Finally, traverse the isUniq[] array using variable i and for every ith element, check if isUniq[i] is true or not. If found to be true, then print arr[i].
Below is the implementation of the above approach:
C++
// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
// Structure of
// a Trie node
struct TrieNode {
// Stores index
// of string
int idx;
// Check if a character is
// present in the string or not
TrieNode* child[26];
// Initialize a TrieNode
TrieNode()
{
// Idx = -1: String is not
// present in TrieNode
idx = -1;
// Initialize all child nodes
// of a TrieNode to NULL
for (int i = 0; i < 26; i++) {
// Update child[i]
child[i] = NULL;
}
}
};
// Function to insert a string into Trie
void Insert(TrieNode* root,
string str, int i)
{
// Stores length of the string
int N = str.length();
// Traverse the string str
for (int i = 0; i < N; i++) {
// If str[i] not present in
// a Trie at current index
if (!root->child[str[i] - 'a']) {
// Create a new node of Trie.
root->child[str[i] - 'a']
= new TrieNode();
}
// Update root
root = root->child[str[i] - 'a'];
}
// Store index of str
// in the TrieNode
root->idx = i;
}
// Function to check if string str present
// in the Trie or not
int SearchString(TrieNode* root, string str)
{
// Stores length of
// the string
int N = str.length();
// Traverse the string
for (int i = 0; i < N; i++) {
// If a character not present
// in Trie at current index
if (!root->child[str[i] - 'a']) {
// Return str as
// unique string
return -1;
}
// Update root
root
= root->child[str[i] - 'a'];
}
// Return index of str
return root->idx;
}
// Utility function to find the unique
// string in array of strings
void UtilUniqStr(vector<string>& arr, int N)
{
// Stores root node of the Trie
TrieNode* root = new TrieNode();
// isUniq[i]: Check if i-th string
// is unique or not
bool isUniq[N];
// Initialize isUniq[] to false
memset(isUniq, false, sizeof(isUniq));
// Insert arr[0] into the Trie
Insert(root, arr[0], 0);
// Mark arr[0] as unique string
isUniq[0] = true;
// Traverse the given array
for (int i = 1; i < N; i++) {
// Stores previous 1st index
// of arr[i] in the array
int idx = SearchString(root,
arr[i]);
// If arr[i] not present
// in the Trie
if (idx == -1) {
// Mark i-th string
// as unique string
isUniq[i] = true;
// Insert arr[i] into Trie
Insert(root, arr[i], i);
}
// If arr[i] already present
// in the Trie
else {
// Mark i-th string as
// duplicate string in Trie
isUniq[idx] = false;
}
}
// Traverse the array
for (int i = 0; i < N; i++) {
// If i-th string is unique,
// then print the string
if (isUniq[i]) {
cout << arr[i] << " ";
}
}
}
// Driver Code
int main()
{
vector<string> arr = { "geeks", "for",
"geek", "ab", "geek",
"for", "code", "karega" };
int N = arr.size();
UtilUniqStr(arr, N);
return 0;
}
// Java program to implement
// the above approach
import java.util.*;
public class GFG
{
// Structure of
// a Trie node
static class TrieNode {
// Stores index
// of String
int idx;
// Check if a character is
// present in the String or not
TrieNode []child = new TrieNode[26];
// Initialize a TrieNode
TrieNode()
{
// Idx = -1: String is not
// present in TrieNode
idx = -1;
// Initialize all child nodes
// of a TrieNode to null
for (int i = 0; i < 26; i++) {
// Update child[i]
child[i] = null;
}
}
};
// Function to insert a String into Trie
static void Insert(TrieNode root,
String str, int i)
{
// Stores length of the String
int N = str.length();
// Traverse the String str
for (int j = 0; j < N; j++) {
// If str[i] not present in
// a Trie at current index
if (root.child[str.charAt(j) - 'a']==null) {
// Create a new node of Trie.
root.child[str.charAt(j) - 'a']
= new TrieNode();
}
// Update root
root = root.child[str.charAt(j) - 'a'];
}
// Store index of str
// in the TrieNode
root.idx = i;
}
// Function to check if String str present
// in the Trie or not
static int SearchString(TrieNode root, String str)
{
// Stores length of
// the String
int N = str.length();
// Traverse the String
for (int i = 0; i < N; i++) {
// If a character not present
// in Trie at current index
if (root.child[str.charAt(i) - 'a'] == null) {
// Return str as
// unique String
return -1;
}
// Update root
root
= root.child[str.charAt(i) - 'a'];
}
// Return index of str
return root.idx;
}
// Utility function to find the unique
// String in array of Strings
static void UtilUniqStr(String[] arr, int N)
{
// Stores root node of the Trie
TrieNode root = new TrieNode();
// isUniq[i]: Check if i-th String
// is unique or not
boolean []isUniq = new boolean[N];
// Insert arr[0] into the Trie
Insert(root, arr[0], 0);
// Mark arr[0] as unique String
isUniq[0] = true;
// Traverse the given array
for (int i = 1; i < N; i++) {
// Stores previous 1st index
// of arr[i] in the array
int idx = SearchString(root,
arr[i]);
// If arr[i] not present
// in the Trie
if (idx == -1) {
// Mark i-th String
// as unique String
isUniq[i] = true;
// Insert arr[i] into Trie
Insert(root, arr[i], i);
}
// If arr[i] already present
// in the Trie
else {
// Mark i-th String as
// duplicate String in Trie
isUniq[idx] = false;
}
}
// Traverse the array
for (int i = 0; i < N; i++) {
// If i-th String is unique,
// then print the String
if (isUniq[i]) {
System.out.print(arr[i]+ " ");
}
}
}
// Driver Code
public static void main(String[] args)
{
String[] arr = { "geeks", "for",
"geek", "ab", "geek",
"for", "code", "karega" };
int N = arr.length;
UtilUniqStr(arr, N);
}
}
// This code is contributed by 29AjayKumar
# Python3 program to implement
# the above approach
root = None
# Structure of
# a Trie node
class TrieNode:
# Stores index
# of string
def __init__(self):
self.idx = -1
self.child = [None]*26
# Function to insert a string into Trie
def Insert(str, i):
global root
# Stores length of the string
N = len(str)
root1 = root
# Traverse the string str
for i in range(N):
# If str[i] not present in
# a Trie at current index
if (not root1.child[ord(str[i]) - ord('a')]):
# Create a new node of Trie.
root1.child[ord(str[i]) - ord('a')] = TrieNode()
# Update root
root1 = root1.child[ord(str[i]) - ord('a')]
# Store index of str
# in the TrieNode
root1.idx = i
return root1
# Function to check if string str present
# in the Trie or not
def SearchString(str):
global root
root1 = root
# Stores length of
# the
N = len(str)
# Traverse the
for i in range(N):
# If a character not present
# in Trie at current index
if (not root1.child[ord(str[i]) - ord('a')]):
# Return str as
# unique
return -1
# Update root
root1 = root1.child[ord(str[i]) - ord('a')]
# Return index of str
return root1.idx
# Utility function to find the unique
# string in array of strings
def UtilUniqStr(arr, N):
global root
# Stores root node of the Trie
root = TrieNode()
d = {}
for i in arr:
d[i] = d.get(i, 0) + 1
# isUniq[i]: Check if i-th string
# is unique or not
isUniq = [False] * N
# Initialize isUniq[] to false
# memset(isUniq, false, sizeof(isUniq));
# Insert arr[0] into the Trie
Insert(arr[0], 0)
# Mark arr[0] as unique string
isUniq[0] = True
# print(root.child[6].child)
# Traverse the given array
for i in range(1, N):
# Stores previous 1st index
# of arr[i] in the array
idx = SearchString(arr[i])
# If arr[i] not present
# in the Trie
if (idx == -1 and d[arr[i]] == 1):
# Mark i-th string
# as unique string
isUniq[i] = True
# Insert arr[i] into Trie
Insert(arr[i], i)
# If arr[i] already present
# in the Trie
else:
# Mark i-th string as
# duplicate string in Trie
isUniq[idx] = False
# Traverse the array
for i in range(N):
# If i-th string is unique,
# then print the string
if (isUniq[i]):
print(arr[i], end = " ")
# Driver Code
if __name__ == '__main__':
arr = ["geeks", "for","geek", "ab", "geek","for", "code", "karega"]
N = len(arr)
UtilUniqStr(arr, N)
# This code is contributed by mohit kumar 29
// C# program to implement
// the above approach
using System;
class GFG
{
// Structure of
// a Trie node
class TrieNode {
// Stores index
// of String
public int idx;
// Check if a character is
// present in the String or not
public TrieNode []child = new TrieNode[26];
// Initialize a TrieNode
public TrieNode()
{
// Idx = -1: String is not
// present in TrieNode
idx = -1;
// Initialize all child nodes
// of a TrieNode to null
for (int i = 0; i < 26; i++) {
// Update child[i]
child[i] = null;
}
}
};
// Function to insert a String into Trie
static void Insert(TrieNode root,
String str, int i)
{
// Stores length of the String
int N = str.Length;
// Traverse the String str
for (int j = 0; j < N; j++) {
// If str[i] not present in
// a Trie at current index
if (root.child[str[j] - 'a'] == null) {
// Create a new node of Trie.
root.child[str[j] - 'a']
= new TrieNode();
}
// Update root
root = root.child[str[j] - 'a'];
}
// Store index of str
// in the TrieNode
root.idx = i;
}
// Function to check if String str present
// in the Trie or not
static int SearchString(TrieNode root, String str)
{
// Stores length of
// the String
int N = str.Length;
// Traverse the String
for (int i = 0; i < N; i++) {
// If a character not present
// in Trie at current index
if (root.child[str[i] - 'a'] == null) {
// Return str as
// unique String
return -1;
}
// Update root
root
= root.child[str[i] - 'a'];
}
// Return index of str
return root.idx;
}
// Utility function to find the unique
// String in array of Strings
static void UtilUniqStr(String[] arr, int N)
{
// Stores root node of the Trie
TrieNode root = new TrieNode();
// isUniq[i]: Check if i-th String
// is unique or not
bool []isUniq = new bool[N];
// Insert arr[0] into the Trie
Insert(root, arr[0], 0);
// Mark arr[0] as unique String
isUniq[0] = true;
// Traverse the given array
for (int i = 1; i < N; i++) {
// Stores previous 1st index
// of arr[i] in the array
int idx = SearchString(root,
arr[i]);
// If arr[i] not present
// in the Trie
if (idx == -1) {
// Mark i-th String
// as unique String
isUniq[i] = true;
// Insert arr[i] into Trie
Insert(root, arr[i], i);
}
// If arr[i] already present
// in the Trie
else {
// Mark i-th String as
// duplicate String in Trie
isUniq[idx] = false;
}
}
// Traverse the array
for (int i = 0; i < N; i++) {
// If i-th String is unique,
// then print the String
if (isUniq[i]) {
Console.Write(arr[i] + " ");
}
}
}
// Driver Code
public static void Main(String[] args)
{
String[] arr = { "geeks", "for",
"geek", "ab", "geek",
"for", "code", "karega" };
int N = arr.Length;
UtilUniqStr(arr, N);
}
}
// This code is contributed by 29AjayKumar
<script>
// JavaScript program to implement
// the above approach
// Structure of
// a Trie node
class TrieNode
{
constructor()
{
this.idx = -1;
this.child = new Array(26);
for (let i = 0; i < 26; i++) {
// Update child[i]
this.child[i] = null;
}
}
}
// Function to insert a String into Trie
function Insert(root,str,i)
{
// Stores length of the String
let N = str.length;
// Traverse the String str
for (let j = 0; j < N; j++) {
// If str[i] not present in
// a Trie at current index
if (root.child[str[j].charCodeAt(0) -
'a'.charCodeAt(0)]==null) {
// Create a new node of Trie.
root.child[str[j].charCodeAt(0) -
'a'.charCodeAt(0)]
= new TrieNode();
}
// Update root
root = root.child[str[j].charCodeAt(0) -
'a'.charCodeAt(0)];
}
// Store index of str
// in the TrieNode
root.idx = i;
}
// Function to check if String str present
// in the Trie or not
function SearchString(root,str)
{
// Stores length of
// the String
let N = str.length;
// Traverse the String
for (let i = 0; i < N; i++) {
// If a character not present
// in Trie at current index
if (root.child[str[i].charCodeAt(0) -
'a'.charCodeAt(0)] == null) {
// Return str as
// unique String
return -1;
}
// Update root
root
= root.child[str[i].charCodeAt(0) -
'a'.charCodeAt(0)];
}
// Return index of str
return root.idx;
}
// Utility function to find the unique
// String in array of Strings
function UtilUniqStr(arr,N)
{
// Stores root node of the Trie
let root = new TrieNode();
// isUniq[i]: Check if i-th String
// is unique or not
let isUniq = new Array(N);
// Insert arr[0] into the Trie
Insert(root, arr[0], 0);
// Mark arr[0] as unique String
isUniq[0] = true;
// Traverse the given array
for (let i = 1; i < N; i++) {
// Stores previous 1st index
// of arr[i] in the array
let idx = SearchString(root,
arr[i]);
// If arr[i] not present
// in the Trie
if (idx == -1) {
// Mark i-th String
// as unique String
isUniq[i] = true;
// Insert arr[i] into Trie
Insert(root, arr[i], i);
}
// If arr[i] already present
// in the Trie
else {
// Mark i-th String as
// duplicate String in Trie
isUniq[idx] = false;
}
}
// Traverse the array
for (let i = 0; i < N; i++) {
// If i-th String is unique,
// then print the String
if (isUniq[i]) {
document.write(arr[i]+ " ");
}
}
}
// Driver Code
let arr=["geeks", "for",
"geek", "ab", "geek",
"for", "code", "karega" ];
let N = arr.length;
UtilUniqStr(arr, N);
// This code is contributed by patel2127
</script>
Outputgeeks ab code karega
Time Complexity: O(N * M), where M is the maximum length of the string
Auxiliary Space: O(N * 26)
Similar Reads
Print all unique elements present in a sorted array
Given a sorted array arr[] of size N, the task is to print all the unique elements in the array. An array element is said to be unique if the frequency of that element in the array is 1. Examples: Input: arr[ ] = {1, 1, 2, 2, 3, 4, 5, 5}Output: 3 4Explanation: Since 1, 2, 5 are occurring more than o
5 min read
Print all Unique permutations of a given string.
Given a string that may contain duplicates, the task is find all unique permutations of given string in any order.Examples: Input: "ABC"Output: ["ABC", "ACB", "BAC", "BCA", "CAB", "CBA"]Explanation: Given string ABC has 6 unique permutations as "ABC", "ACB", "BAC", "BCA", "CAB" and "CBA".Input: "AAA
12 min read
Print all distinct strings from a given array
Given an array of strings arr[] of size N, the task is to print all the distinct strings present in the given array. Examples: Input: arr[] = { "Geeks", "For", "Geeks", "Code", "Coder" } Output: Coder Code Geeks For Explanation: Since all the strings in the array are distinct, the required output is
5 min read
Check if an encoding represents a unique binary string
Given an encoding of a binary string of length k, the task is to find if the given encoding uniquely identifies a binary string or not. The encoding has counts of contiguous 1s (separated by 0s). For example, encoding of 11111 is {5}, encoding of 01101010 is {2, 1, 1} and encoding of 111011 is {3, 2
6 min read
Determine if a string has all Unique Characters
Given a string, determine if the string has all unique characters. Examples : Input : abcd10jk Output : true Input : hutg9mnd!nk9 Output : false Approach 1 - Brute Force technique: Run 2 loops with variable i and j. Compare str[i] and str[j]. If they become equal at any point, return false. C++ // C
15+ min read
Print all Distinct (Unique) Elements in given Array
Given an integer array arr[], print all distinct elements from this array. The given array may contain duplicates and the output should contain every element only once.Examples: Input: arr[] = {12, 10, 9, 45, 2, 10, 10, 45}Output: {12, 10, 9, 45, 2}Input: arr[] = {1, 2, 3, 4, 5}Output: {1, 2, 3, 4,
11 min read
Print all unique words of a String
Write a function that takes a String as an argument and prints all unique words in it. Examples: Input: Java is great. Grails is also greatOutput: Java Grails also Approach: The idea is to use the map to keep track of words already occurred. But first, we have to extract all words from a String, as
7 min read
Print all the duplicate characters in a string
Given a string S, the task is to print all the duplicate characters with their occurrences in the given string.Example:Input: S = "geeksforgeeks"Output: e, count = 4 g, count = 2 k, count = 2 s, count = 2 Explanation: g occurs 2 times in the string, k occurs 2 times in the string, s occurs 2 times i
7 min read
Create a string with unique characters from the given N substrings
Given an array arr[] containing N substrings consisting of lowercase English letters, the task is to return the minimum length string that contains all given parts as a substring. All characters in this new answer string should be distinct. If there are multiple strings with the following property p
11 min read
Frequency of a string in an array of strings
You are given a collection of strings and a list of queries. For every query there is a string given. We need to print the number of times the given string occurs in the collection of strings. Examples: Input : arr[] = {wer, wer, tyu, oio, tyu} q[] = {wer, tyu, uio}Output : 2 2 0Explanation : q[0] a
15 min read