Decode the Morse Code

From Code Wars:

This kata is part of a series on the Morse code. After you solve this kata, you may move to the next one.

In this kata you have to write a simple Morse code decoder. While the Morse code is now mostly superceded by voice and digital data communication channels, it still has its use in some applications around the world.
The Morse code encodes every character as a sequence of "dots" and "dashes". For example, the letter A is coded as ·−, letter Q is coded as −−·−, and digit 1 is coded as ·−−−−. The Morse code is case-insensitive, traditionally capital letters are used. When the message is written in Morse code, a single space is used to separate the character codes and 3 spaces are used to separate words. For example, the message HEY JUDE in Morse code is ···· · −·−− ·−−− ··− −·· ·.

NOTE: Extra spaces before or after the code have no meaning and should be ignored.

In addition to letters, digits and some punctuation, there are some special service codes, the most notorious of those is the international distress signal SOS (that was first issued by Titanic), that is coded as ···−−−···. These special codes are treated as single special characters, and usually are transmitted as separate words.

Your task is to implement a function that would take the morse code as input and return a decoded human-readable string.

For example:

decodeMorse('.... . -.-- .--- ..- -.. .')
#should return "HEY JUDE"


NOTE: For coding purposes you have to use ASCII characters . and -, not Unicode characters.

The Morse code table is preloaded for you as a dictionary, feel free to use it:

Coffeescript/C++/Go/JavaScript/PHP/Python/Ruby/TypeScript: MORSE_CODE['.--']

C#: MorseCode.Get(".--") (returns string)

Elixir: morse_codes variable

Haskell: morseCodes ! ".--" (Codes are in a Map String String)

Java: MorseCode.get(".--")

Kotlin: MorseCode[".--"] ?: "" or MorseCode.getOrDefault(".--", "")

Rust: self.morse_code

All the test strings would contain valid Morse code, so you may skip checking for errors and exceptions. In C#, tests will fail if the solution code throws an exception, please keep that in mind. This is mostly because otherwise the engine would simply ignore the tests, resulting in a "valid" solution.

MORSE_CODE['.--']

MorseCode.Get(".--")

morse_codes

morseCodes ! ".--"

MorseCode.get(".--")

MorseCode[".--"] ?: ""

MorseCode.getOrDefault(".--", "")

self.morse_code

Good luck!

After you complete this kata, you may try yourself at Decode the Morse code, advanced.

I wrote a program that works, but it was essentially done with ad hoc patches to cover the edge cases/exceptions the program initially didn't cover. I'd appreciate a critique of my code, such as best practices and the program logic itself.

# "Code Wars: Decode the Morse Code"

def decodeMorse(morse_code):
clear_text = ''
char = ''
index = 0
length = len(morse_code)
delim1 = " " # Next character delimiter.
delim2 = " " # Next word delimiter.
while index < (length):
if morse_code[index] != delim1:
# Build the character to be added to the clear text.
char += morse_code[index]
else:
# When the delimiter is encountered.
if char != '':
# To cover the program encountering erroneous whitespace.
clear_text += MORSE_CODE[char]
# Add said character to clear text
char = ''
# Reset "char".
if index < (length-2):
# If it is possible to encounter a space.
if morse_code[index:(index+3)] == delim2:
# When a space is encountered.
clear_text += " "
index += 2
if index == length-1:
# If the last character in the code is a space, assign a control value to "char"
char = ""
index += 1

if char != "":
# If the last character isn't a space.
clear_text += MORSE_CODE[char]
# Add the final character to the clear text.
return clear_text


2 Answers
2

In Python if you find yourself writing something like:

while index < (length):


There is good chance you are not writing Pythonic code. Looping over an index is just not needed that often. I will start with showing some ways to improve your code. And then at the end will show a more Pythonic solution.

I would suggest changing your looping statement to:

for index, di_dah in enumerate(morse_code.strip() + ' '):


enumerate() is used to iterate over an object and give the index of of the current element. The str.strip() removes leading and trailing spaces, and the + ' ' at the end removes the need special casing after the loop. This fairly simple change can greatly simplify the code needed inside the loop:

enumerate()

str.strip()

+ ' '

def decodeMorse2(morse_code):
clear_text = ''
char = ''

for index, di_dah in enumerate(morse_code.strip() + ' '):
if di_dah != ' ':
char += di_dah
elif char:
clear_text += MORSE_CODE[char]
char = ''
if index < len(morse_code) - 2:
if morse_code[index: index + 3] == ' ':
clear_text += " "

return clear_text


I don't have access to the test cases, but I read the spec I think this would do the job:

def decodeMorse(morse_code):
return ' '.join(
''.join(MORSE_CODE[char] for char in word.split())
for word in morse_code.strip().split(' ')
)


This code uses two nested loops in the form of generator expressions. It uses str.split() to initially split the words in the outer loop and then again to split the characters in the inner loop. Then does a character lookup and finally uses str.join() to build the sentence.

str.split()

str.join()

enumerate

str.split()

str.join()

words

join

word

.split()

word

word

words

join

Since strings in Python are an immutable sequence type, building strings using += is not good practice, because it can lead to poor performance. Such concatenation may require the interpreter to allocate a new string and copy both the old and new parts into the new string (though CPython tries to avoid that when possible).

+=

I'd think of this as a string substitution exercise. String substitutions based on patterns can be done using regular expressions. The solution could be greatly simplified using re.sub():

re.sub()

import re

def decodeMorse(morse_code):
return re.sub(
'([.-]+)|(?<=[.-])( )(?=[.-])| *',
lambda code: MORSE_CODE[code.group(1)] if code.group(1) else
' ' if code.group(2) else '',
morse_code
)


The code above says:

([.-]+)

MORSE_CODE[…]

(?<=[.-])( )(?=[.-]) — For any sequence of three spaces that is…

(?<=[.-])( )(?=[.-])

(?<=[.-])

(?=[.-])

… then replace that group with a single space.

 *

It's unfortunate that the lookbehind and lookahead assertions are necessary, because the online test cases expect you to discard leading and trailing spaces. (An alternate technique you could use is to .strip() the input or the output.)

.strip()

Thanks for contributing an answer to Code Review Stack Exchange!

But avoid …

Use MathJax to format equations. MathJax reference.

To learn more, see our tips on writing great answers.

Some of your past answers have not been well-received, and you're in danger of being blocked from answering.

Please pay close attention to the following guidance:

But avoid …

To learn more, see our tips on writing great answers.

Required, but never shown

Required, but never shown

By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service, privacy policy and cookie policy, and that your continued use of the website is subject to these policies.