Unique Morse Code Words - Practice Coding Problems

Unique Morse Code Words - Problem

Imagine you're a radio operator during World War II, intercepting secret messages transmitted in Morse code! Each letter has its unique pattern of dots and dashes - 'a' becomes ".-", 'b' becomes "-...", and so on.

You've intercepted an array of words, and you need to determine how many unique transformations exist when each word is converted to its complete Morse code representation.

For example, the word "cab" transforms to "-.-..--..." by concatenating:

'c' → "-.-."
'a' → ".-"
'b' → "-..."

Your mission: Count how many different Morse code transformations you can create from all the given words.

The complete Morse code alphabet is: [".-","-...","-.-.","-.."."."."..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."]

Input & Output

example_1.py — Basic Case

$ Input: ["gin","zen","gig","msg"]

› Output: 2

💡 Note: "gin" → "--...-.", "zen" → "--...-.", "gig" → "--...--.", "msg" → "--...--.". There are 2 unique transformations: "--...-." and "--...--."

example_2.py — All Unique

$ Input: ["a", "z", "b"]

› Output: 3

💡 Note: "a" → ".-", "z" → "--..", "b" → "-...". All three words produce different Morse code transformations.

example_3.py — Single Word

$ Input: ["hello"]

› Output: 1

💡 Note: Only one word means only one unique transformation: "hello" → "......-..-.-----"

Visualization

Tap to expand

Understanding the Visualization

Setup Code Book

Prepare the Morse code mapping for all 26 letters

Transform Messages

Convert each word into its secret Morse code

Track Unique Codes

Use hash set to automatically count unique transformations

Report Count

Return the number of different code patterns found

Key Takeaway

🎯 Key Insight: Hash sets are perfect for counting unique items - they automatically handle duplicates and give us the count in O(1) time!

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

Visit each word once (n), transform each character (m average word length)

✓ Linear Growth

Space Complexity

O(n × m)

Hash set stores at most n unique transformations, each of average length m

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 12
words[i] consists of lowercase English letters only
Each letter maps to exactly one Morse code pattern

Asked in

G Google 15 a Amazon 12 f Facebook 8 ⊞ Microsoft 6

The optimal solution uses a hash set to automatically handle uniqueness. Transform each word to its Morse code representation and add to the set. The final set size equals the number of unique transformations. Time complexity: O(n×m) where n is number of words and m is average word length.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Set (Optimal)	O(n × m)	O(n × m)	Transform words to Morse code and add to hash set in single pass
Brute Force (Compare All Transformations)	O(n² × m)	O(n × m)	Transform all words to Morse code, then compare each transformation with all others

One-Pass Hash Set (Optimal) — Algorithm Steps

Create Morse code mapping array
Initialize empty hash set
For each word, transform to Morse code and add to set
Return size of hash set

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Set

Create empty hash set

Transform & Add

Convert each word and add to set

Count Unique

Set size equals unique transformations

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_WORDS 100
#define MAX_LENGTH 200

int uniqueMorseRepresentations(char** words, int wordsSize) {
    char* morse[] = {".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."};
    
    char uniqueTransformations[MAX_WORDS][MAX_LENGTH];
    int uniqueCount = 0;
    
    for (int i = 0; i < wordsSize; i++) {
        // Transform word to morse code
        char morseWord[MAX_LENGTH] = "";
        for (int j = 0; words[i][j] != '\0'; j++) {
            strcat(morseWord, morse[words[i][j] - 'a']);
        }
        
        // Check if already exists
        int exists = 0;
        for (int k = 0; k < uniqueCount; k++) {
            if (strcmp(uniqueTransformations[k], morseWord) == 0) {
                exists = 1;
                break;
            }
        }
        
        // Add if new
        if (!exists) {
            strcpy(uniqueTransformations[uniqueCount], morseWord);
            uniqueCount++;
        }
    }
    
    return uniqueCount;
}

int main() {
    char* words[] = {"gin", "zen", "gig", "msg"};
    printf("%d\n", uniqueMorseRepresentations(words, 4));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

Visit each word once (n), transform each character (m average word length)

✓ Linear Growth

Space Complexity

O(n × m)

Hash set stores at most n unique transformations, each of average length m

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 12
words[i] consists of lowercase English letters only
Each letter maps to exactly one Morse code pattern

95.0K Views

Medium Frequency

~8 min Avg. Time

3.2K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass Hash Set (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler