Skip to content
Related Articles

Related Articles

Improve Article

Count distinct strings possible by replacing each character by its Morse code

  • Last Updated : 19 May, 2021

Given an array of strings arr[], the task is to count the number of distinct strings that can be generated from the given array by replacing each character of the strings by its Morse code. Below is the Morse code of all the lowercase alphabets:

Examples:

Input: arr[] = {“gig”, “zeg”, “gin”, “msn”}
Output: 2
Explanation: 
Replacing each character of the strings of the given array to its Morse code: 
gig = “–…–.” 
zeg = “–…–.” 
gin = “–…-.” 
msn = “–…-.” 
Morse code of the strings “gig” and “zeg” are equal. 
Morse code of the strings “gin” and “msn” are equal. 
Therefore, the total count of distinct elements of the given string by replacing the characters to its Morse code is equal to 2. 
 

Input: arr[] = {“geeks”, “for”, “geeks”}
Output: 2



Approach: Follow the steps below to solve the problem:

  • Initialize an array, say morseCode[] to store the Morse code of all lowercase characters.
  • Create a set, say st to store distinct elements of the array by replacing each character to its Morse code.
  • Traverse the array and insert the Morse code of the string of the array into st.
  • Finally, print the count of elements present in st.

Below is the implementation of the above approach.

C++




// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to count unique array elements
// by replacing each character by its Morse code
int uniqueMorseRep(vector<string>& arr)
{
 
    // Stores Morse code of all
    // lowercase characters
    vector<string> morseCode
        = {
            ".-", "-...", "-.-.",
            "-..", ".", "..-.", "--.",
            "....", "..", ".---", "-.-",
            ".-..", "--", "-.", "---",
            ".--.", "--.-", ".-.", "...",
            "-", "..-", "...-", ".--",
            "-..-", "-.--", "--.."
          };
 
    // Stores distinct elements of string by
    // replacing each character by Morse code
    set<string> st;
 
    // Stores length of arr[] array
    int N = arr.size();
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
        // Stores the Morse code
        // of arr[i]
        string temp = "";
 
        // Stores length of
        // current string
        int M = arr[i].length();
 
        for (int j = 0; j < M; j++) {
 
            // Update temp
            temp += morseCode[arr[i][j] - 'a'];
        }
 
        // Insert temp into st
        st.insert(temp);
    }
 
    // Return count of elements
    // in the set
    return st.size();
}
 
// Driver code
int main()
{
    vector<string> arr = { "gig", "zeg",
                           "gin", "msn" };
    cout << uniqueMorseRep(arr) << endl;
}
Java



// Java program to implement
// the above approach
import java.util.*;
class GFG{
 
// Function to count unique
// array elements by replacing
// each character by its Morse code
static int uniqueMorseRep(String[] arr)
{
  // Stores Morse code of all
  // lowercase characters
  String []morseCode = {".-", "-...", "-.-.",
                        "-..", ".", "..-.", "--.",
                        "....", "..", ".---", "-.-",
                        ".-..", "--", "-.", "---",
                        ".--.", "--.-", ".-.", "...",
                        "-", "..-", "...-", ".--",
                        "-..-", "-.--", "--.."};
 
  // Stores distinct elements of
  // String by replacing each
  // character by Morse code
  HashSet<String> st = new HashSet<>();
 
  // Stores length of arr[] array
  int N = arr.length;
 
  // Traverse the array
  for (int i = 0; i < N; i++)
  {
    // Stores the Morse code
    // of arr[i]
    String temp = "";
 
    // Stores length of
    // current String
    int M = arr[i].length();
 
    for (int j = 0; j < M; j++)
    {
      // Update temp
      temp += morseCode[arr[i].charAt(j) - 'a'];
    }
 
    // Insert temp into st
    st.add(temp);
  }
 
  // Return count of elements
  // in the set
  return st.size();
}
 
// Driver code
public static void main(String[] args)
{
  String[] arr = {"gig", "zeg",
                  "gin", "msn"};
  System.out.print(uniqueMorseRep(arr) + "\n");
}
}
 
// This code is contributed by Amit Katiyar
Python3



# Python3 program to implement
# the above approach
 
# Function to count unique
# array elements by replacing
# each character by its Morse
# code
def uniqueMorseRep(arr):
   
    # Stores Morse code of
    # all lowercase characters
    morseCode = [".-", "-...", "-.-.",
                 "-..", ".", "..-.",
                 "--.", "....", "..",
                 ".---", "-.-", ".-..",
                 "--", "-.", "---", ".--.",
                 "--.-", ".-.", "...", "-",
                 "..-", "...-", ".--", "-..-",
                 "-.--", "--.."];
 
    # Stores distinct elements of
    # String by replacing each
    # character by Morse code
    st = set();
 
    # Stores length of arr array
    N = len(arr);
 
    # Traverse the array
    for i in range(N):
       
        # Stores the Morse code
        # of arr[i]
        temp = "";
 
        # Stores length of
        # current String
        M = len(arr[i]);
 
        for j in range(M):
           
            # Update temp
            temp += morseCode[ord(arr[i][j]) -
                              ord('a')];
 
        # Insert temp into st
        st.add(temp);
 
    # Return count of elements
    # in the set
    return len(st);
 
# Driver code
if __name__ == '__main__':
   
    arr = ["gig", "zeg",
           "gin", "msn"];
    print(uniqueMorseRep(arr) , "");
 
# This code is contributed by 29AjayKumar
C#



// C# program to implement
// the above approach
using System;
using System.Collections.Generic;
class GFG{
 
// Function to count unique
// array elements by replacing
// each character by its Morse code
static int uniqueMorseRep(String[] arr)
{
  // Stores Morse code of all
  // lowercase characters
  String []morseCode = {".-", "-...", "-.-.",
                        "-..", ".", "..-.", "--.",
                        "....", "..", ".---", "-.-",
                        ".-..", "--", "-.", "---",
                        ".--.", "--.-", ".-.", "...",
                        "-", "..-", "...-", ".--",
                        "-..-", "-.--", "--.."};
 
  // Stores distinct elements of
  // String by replacing each
  // character by Morse code
  HashSet<String> st = new HashSet<String>();
 
  // Stores length of []arr array
  int N = arr.Length;
 
  // Traverse the array
  for (int i = 0; i < N; i++)
  {
    // Stores the Morse code
    // of arr[i]
    String temp = "";
 
    // Stores length of
    // current String
    int M = arr[i].Length;
 
    for (int j = 0; j < M; j++)
    {
      // Update temp
      temp += morseCode[arr[i][j] - 'a'];
    }
 
    // Insert temp into st
    st.Add(temp);
  }
 
  // Return count of elements
  // in the set
  return st.Count;
}
 
// Driver code
public static void Main(String[] args)
{
  String[] arr = {"gig", "zeg",
                  "gin", "msn"};
  Console.Write(uniqueMorseRep(arr) + "\n");
}
}
 
// This code is contributed by gauravrajput1
Javascript



<script>
 
// Javascript program to implement
// the above approach
 
// Function to count unique array elements
// by replacing each character by its Morse code
function uniqueMorseRep(arr)
{
 
    // Stores Morse code of all
    // lowercase characters
    var morseCode
        = [
            ".-", "-...", "-.-.",
            "-..", ".", "..-.", "--.",
            "....", "..", ".---", "-.-",
            ".-..", "--", "-.", "---",
            ".--.", "--.-", ".-.", "...",
            "-", "..-", "...-", ".--",
            "-..-", "-.--", "--.."];
 
    // Stores distinct elements of string by
    // replacing each character by Morse code
    var st = new Set();
 
    // Stores length of arr[] array
    var N = arr.length;
 
    // Traverse the array
    for (var i = 0; i < N; i++) {
 
        // Stores the Morse code
        // of arr[i]
        var temp = "";
 
        // Stores length of
        // current string
        var M = arr[i].length;
 
        for (var j = 0; j < M; j++) {
 
            // Update temp
            temp += morseCode[arr[i][j].charCodeAt(0) - 'a'.charCodeAt(0)];
        }
 
        // Insert temp into st
        st.add(temp);
    }
 
    // Return count of elements
    // in the set
    return st.size;
}
 
// Driver code
var arr = ["gig", "zeg",
                       "gin", "msn"];
document.write( uniqueMorseRep(arr));
 
</script>
Output: 
2
 
Time Complexity: O(N×M), where N is the size of the array and M is the length of a word.
Auxiliary Space: O(N)
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.



My Personal Notes
arrow_drop_up
Previous
Program to format a number with thousands separator in C/C++
Next

Minimum number of operations required to return to the main folder
Recommended Articles
Page :
Kth character after replacing each character of String by its frequency exactly X times
05, Jul 21
Morse Code Implementation
18, Feb 18
Maximize count of distinct strings generated by replacing similar adjacent digits having sum K with K
16, Dec 20
Count of distinct Strings possible by swapping prefixes of pairs of Strings from the Array
18, Aug 20
Modify string by replacing characters by alphabets whose distance from that character is equal to its frequency
25, Mar 21
Thue-Morse sequence
04, Apr 18
Modify string by replacing all occurrences of given characters by specified replacing characters
14, Apr 21
Count of binary strings of length N having equal count of 0's and 1's and count of 1's ≥ count of 0's in each prefix substring
25, Jul 20
Modify array of strings by replacing characters repeating in the same or remaining strings
15, Mar 21
Convert given Strings into T by replacing characters in between strings any number of times
10, Jul 21
Generate all possible strings formed by replacing letters with given respective symbols
19, Jul 21
Queries to print count of distinct array elements after replacing element at index P by a given element
16, Oct 20
Count of strings that can be formed from another string using each character at-most once
08, Aug 18
Count of distinct possible strings after performing given operations
29, May 20
Count of Distinct strings possible by inserting K characters in the original string
28, Jul 20
Find a string such that every character is lexicographically greater than its immediate next character
24, Jul 18
Count ways to split array into two equal sum subarrays by replacing each array element to 0 once
13, Nov 20
Ways to split string such that each partition starts with distinct character
05, Apr 18
Largest index for each distinct character in given string with frequency K
29, Apr 20
Minimize cost to convert all occurrences of each distinct character to lowercase or uppercase
14, Apr 21
Count permutations possible by replacing '?' characters in a Binary String
03, Mar 21
Printing frequency of each character just after its consecutive occurrences
08, Sep 18
Check if frequency of each character is equal to its position in English Alphabet
20, May 20
Modify string by increasing each character by its distance from the end of the word
16, Sep 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
IshwarGupta
@IshwarGupta
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox