Morse Code Translator - Problem

Build a bidirectional Morse code translator that can both encode text to Morse code and decode Morse code back to text.

Your translator should:

Encode: Convert alphabetic characters (A-Z, case insensitive) to Morse code
Decode: Convert Morse code back to uppercase letters
Handle spaces: Single space between Morse letters, double space between words
Ignore: Non-alphabetic characters during encoding

Use the standard International Morse Code mapping where A = '.-', B = '-...', etc.

Input & Output

Example 1 — Encoding Text to Morse

$ Input: text = "HELLO WORLD", mode = "encode"

› Output: .... . .-.. .-.. --- .-- --- .-. .-.. -..

💡 Note: Each letter is converted to its Morse code: H=...., E=., L=.-.., L=.-.., O=---. Single spaces separate letters, double spaces separate words.

Example 2 — Decoding Morse to Text

$ Input: text = ".... . .-.. .--.", mode = "decode"

› Output: HELP

💡 Note: Each Morse pattern is converted back: ....=H, .=E, .-..=L, .--.=P

Example 3 — Multiple Words

$ Input: text = "... --- ... -- --- .-. ... .", mode = "decode"

› Output: SOS MORSE

💡 Note: Double spaces indicate word boundaries. First word: S=..., O=---, S=... gives 'SOS'. Second word gives 'MORSE'.

Constraints

1 ≤ text.length ≤ 1000
text contains only letters, spaces, dots, and dashes
mode is either "encode" or "decode"

Visualization

Tap to expand

Asked in

M Meta 15 M Microsoft 12 a Amazon 8

The key insight is using hash maps for bidirectional translation - one map for letter→morse encoding and another for morse→letter decoding. This provides O(1) lookup time per character instead of O(26) linear search. Best approach uses Hash Map Lookup. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force Linear Search

⏱️ Time: O(n × 26) Space: O(1)

For each character, iterate through the alphabet to find its position and corresponding Morse code. For decoding, search through all Morse patterns to find matches.

Hash Map Lookup

⏱️ Time: O(n) Space: O(1)

Create two hash maps: one for encoding (letter→morse) and one for decoding (morse→letter). This eliminates the need to search through arrays.

Brute Force Linear Search — Algorithm Steps

For each character, scan through alphabet A-Z
Find matching position and lookup corresponding Morse code
For decoding, split by spaces and search Morse patterns linearly

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Character

Take character 'H' from input text

Linear Search

Scan A,B,C,D,E,F,G,H... until finding 'H' at position 7

Get Morse Code

Use position 7 to get morse code '....' from morse array

Code -

solution.c — C

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

char* solution(char* text, char* mode) {
    char* morseCodes[] = {".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--.."};
    char* alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    char* result = (char*)malloc(1000 * sizeof(char));
    result[0] = '\0';
    
    if (strcmp(mode, "encode") == 0) {
        int len = strlen(text);
        for (int i = 0; i < len; i++) {
            char c = toupper(text[i]);
            if (c == ' ') {
                strcat(result, "  ");
            } else if (isalpha(c)) {
                // Linear search for character position
                for (int j = 0; j < 26; j++) {
                    if (alphabet[j] == c) {
                        if (strlen(result) > 0 && result[strlen(result)-1] != ' ') {
                            strcat(result, " ");
                        }
                        strcat(result, morseCodes[j]);
                        break;
                    }
                }
            }
        }
    } else { // decode
        char* textCopy = (char*)malloc((strlen(text) + 1) * sizeof(char));
        strcpy(textCopy, text);
        char* word = strtok(textCopy, "\t"); // Using tab as double space substitute
        // Manual double space split
        char* pos = strstr(text, "  ");
        if (pos != NULL) {
            // Implement double space splitting manually
            char words[100][100];
            int wordCount = 0;
            int start = 0;
            int len = strlen(text);
            for (int i = 0; i <= len; i++) {
                if (i == len || (i < len - 1 && text[i] == ' ' && text[i+1] == ' ')) {
                    strncpy(words[wordCount], text + start, i - start);
                    words[wordCount][i - start] = '\0';
                    wordCount++;
                    if (i < len) {
                        start = i + 2; // Skip double space
                        i++; // Skip second space
                    }
                }
            }
            
            for (int w = 0; w < wordCount; w++) {
                if (w > 0) strcat(result, " ");
                char* letter = strtok(words[w], " ");
                while (letter != NULL) {
                    // Linear search for morse code
                    for (int j = 0; j < 26; j++) {
                        if (strcmp(morseCodes[j], letter) == 0) {
                            char temp[2] = {alphabet[j], '\0'};
                            strcat(result, temp);
                            break;
                        }
                    }
                    letter = strtok(NULL, " ");
                }
            }
        }
        free(textCopy);
    }
    return result;
}

int main() {
    char text[1000], mode[20];
    fgets(text, sizeof(text), stdin);
    fgets(mode, sizeof(mode), stdin);
    text[strcspn(text, "\n")] = 0;
    mode[strcspn(mode, "\n")] = 0;
    
    char* result = solution(text, mode);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 26)

For n characters, each requires linear scan through 26 letters

✓ Linear Growth

Space Complexity

O(1)

Only using variables, no extra data structures

✓ Linear Space

25.4K Views

Medium Frequency

~15 min Avg. Time

890 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

Morse Code Translator - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Linear Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler