Morse Code Decoder Fails on Consecutive Spaces and Special Characters

Heya,

Your issues stem from three things: (1) dict[key] raises KeyError on unknown codes, (2) split(" ") produces empty strings when there are consecutive spaces, and (3) you’re not distinguishing letter separators (single space) from word separators (typically / or multiple spaces).

## The fix

### 1. Use dict.get() instead of dict[...]

dict.get(key, default) returns the default instead of raising KeyError. This alone solves the crash on @.

### 2. Standardize the word separator

The conventional Morse convention is:

• 1 space between letters
• 3 spaces (or a /) between words

Normalize the input first so the parser only deals with one format.

### 3. Parse in two levels: words → letters

Split on the word separator first, then on the letter separator. This makes empty tokens disappear naturally and makes the intent explicit.

---

## Working example

MORSE_CODE_DICT = {
    '.-':   'A', '-...': 'B', '-.-.': 'C', '-..':  'D', '.':    'E',
    '..-.': 'F', '--.':  'G', '....': 'H', '..':   'I', '.---': 'J',
    '-.-':  'K', '.-..': 'L', '--':   'M', '-.':   'N', '---':  'O',
    '.--.': 'P', '--.-': 'Q', '.-.':  'R', '...':  'S', '-':    'T',
    '..-':  'U', '...-': 'V', '.--':  'W', '-..-': 'X', '-.--': 'Y',
    '--..': 'Z',
    '-----':'0', '.----':'1', '..---':'2', '...--':'3', '....-':'4',
    '.....':'5', '-....':'6', '--...':'7', '---..':'8', '----.':'9',
}

def decode_morse(morse: str, unknown: str = '?') -> str:
    # Normalize: treat "/" as a word separator, collapse runs of spaces
    # into the canonical 3-space word break.
    normalized = morse.replace('/', '   ').strip()

    words = [w for w in normalized.split('   ') if w]
    decoded_words = []

    for word in words:
        letters = [MORSE_CODE_DICT.get(code, unknown)
                   for code in word.split(' ') if code]
        decoded_words.append(''.join(letters))

    return ' '.join(decoded_words)

### Test

>>> decode_morse('.... . .-.. .-.. ---   .-- --- .-. .-.. -..')
'HELLO WORLD'

>>> decode_morse('.... . .-.. .-.. ---   .-- --- .-. .-.. -.. @')
'HELLO WORLD?'

>>> decode_morse('.... . .-.. .-.. --- / .-- --- .-. .-.. -..')
'HELLO WORLD'

---

## Why this works

## A couple of further notes

• Strict mode: if you’d rather reject invalid input than substitute ?, raise your own ValueError with the offending token — it’s friendlier than a bare KeyError:

  if code not in MORSE_CODE_DICT:
      raise ValueError(f"Invalid Morse token: {code!r}")
  

• Encoder symmetry: when building the encoder, emit ' ' between letters and ' ' (three spaces) between words so a round-trip decode(encode(x)) == x.upper() holds for supported characters.
• Regex alternative: re.split(r' {3,}', morse.strip()) for words and re.split(r' +', word) for letters also collapses runs gracefully if you prefer not to normalize first.

This pattern — normalize input → split coarse → split fine → lookup with default — generalizes well to any token-stream decoder, not just Morse.

Heya, @benner

Your main issue is that split(" ") treats every single space literally, so consecutive spaces create empty strings, which then trigger KeyError when you look them up. In Morse, single spaces usually separate letters and multiple spaces (often 3) separate words, so you need parsing logic that handles both structure and bad input gracefully.

A more reliable approach is: Use .split(" ") for words first Then .split() for letters inside each word Use .get() instead of direct dict indexing so invalid symbols don’t crash decoding

Hope that this help!

Handle decoding in two steps: split words first, then decode letters. Avoid direct dictionary access because empty strings and unknown symbols will cause KeyError.

Use .get() with a fallback:

for code in morse_input.split():    decoded += MORSE_CODE_DICT.get(code, "?")

For word gaps, treat multiple spaces (commonly 3) as a word separator, not as empty letters. This keeps invalid input from breaking the parser and gives you control over how unknown Morse sequences are handled.