All SolutionsAll Solutions
☎️
Some Mars
Week 15, 2026
Python two-step solution | Alexevi | Python Solutions
def main() -> None:
msg = "☀️ ❄️☀️☀️❄️ ☀️❄️ ❄️❄️ ☀️❄️❄️☀️ ☀️❄️☀️☀️ ☀️"
smsg = []
s = 0
el = ""
for c in msg:
if s == 3:
smsg.append(el)
el = c
s = 0
elif c != ' ':
el += c
s = 0
else:
s += 1
smsg.append(el)
result = ""
code_morse = {".-": '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', ".----": '1', "..---": '2', "...--": '3', "....-": '4',
".....": '5', "-....": '6', "--...": '7', "---..": '8', "----.": '9',
"-----": '0'}
for el in smsg:
if el != ' ':
result += code_morse[el.replace('❄️', '-').replace('☀️', '.')]
else:
result += ' '
print(result)
main()
Python - Morse Converter | BMC | Python Solutions
data_base = {
# data sourced from wikipedia + moratech.com/aviation/morsecode.html
# NOTE: International Morse Code
# letters
'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': '--..',
# integers
'0': '-----',
'1': '.----',
'2': '..---',
'3': '...--',
'4': '....-',
'5': '.....',
'6': '-....',
'7': '--...',
'8': '---..',
'9': '----.',
# punctuation
'.': '.-.-.-',
',': '--..--',
'?': '..--..',
"'": '.----.',
'!': '-.-.--',
'/': '-..-.',
'(': '-.--.',
')': '-.--.-',
':': '---...',
';': '-.-.-.',
'=': '-...-',
'-': '-....-',
'_': '..--.-',
'"': '.-..-.',
'@': '.--.-.'
}
def convertToMorse(aString: str) -> str:
newMsg = ""
for char in aString:
if char == " ": newMsg += " "
if char == "☀": newMsg += "."
if char == "❄": newMsg += "-"
return newMsg
def converToText(aMorseString: str) -> str:
global data_base
data_base_reverse = {v: k for k, v in data_base.items()}
morse_list = [m for m in aMorseString.split()]
words = []
temp = ""
for morse in morse_list:
if morse != "/": temp += data_base_reverse[morse]
else:
words.append(temp)
temp = ""
words.append(temp)
return " ".join(words)
# main
msg = "❄️ ☀️☀️☀️☀️ ☀️ ☀️❄️❄️ ❄️❄️❄️ ☀️❄️☀️ ☀️❄️☀️☀️ ❄️☀️☀️ ❄️☀️❄️☀️ ☀️☀️☀️☀️ ☀️❄️ ❄️☀️ ❄️❄️☀️ ☀️ ❄️☀️☀️ ☀️❄️❄️ ☀️☀️☀️☀️ ☀️ ❄️☀️ ☀️☀️☀️ ☀️❄️ ❄️❄️ ☀️☀️❄️ ☀️ ☀️❄️☀️☀️ ❄️❄️ ❄️❄️❄️ ☀️❄️☀️ ☀️☀️☀️ ☀️ ☀️☀️☀️ ☀️ ❄️☀️ ❄️ ❄️ ☀️☀️☀️☀️ ☀️ ☀️☀️❄️☀️ ☀️☀️ ☀️❄️☀️ ☀️☀️☀️ ❄️ ☀️❄️☀️☀️ ❄️❄️❄️ ❄️☀️ ❄️❄️☀️ ❄️☀️☀️ ☀️☀️ ☀️☀️☀️ ❄️ ☀️❄️ ❄️☀️ ❄️☀️❄️☀️ ☀️ ❄️❄️ ☀️ ☀️☀️☀️ ☀️☀️☀️ ☀️❄️ ❄️❄️☀️ ☀️ ☀️❄️❄️ ☀️☀️☀️☀️ ☀️❄️ ❄️ ☀️☀️☀️☀️ ☀️❄️ ❄️ ☀️☀️☀️☀️ ❄️❄️☀️ ❄️❄️❄️ ❄️☀️☀️ ☀️❄️❄️ ☀️❄️☀️ ❄️❄️❄️ ☀️☀️❄️ ❄️❄️☀️ ☀️☀️☀️☀️ ❄️ ☀️☀️☀️☀️❄️ ☀️☀️☀️☀️❄️ ❄️❄️ ☀️☀️ ☀️❄️☀️☀️ ☀️ ☀️☀️☀️ ❄️☀️☀️☀️ ☀️ ❄️ ☀️❄️❄️ ☀️ ☀️ ❄️☀️ ☀️❄️❄️ ☀️❄️ ☀️☀️☀️ ☀️☀️☀️☀️ ☀️☀️ ❄️☀️ ❄️❄️☀️ ❄️ ❄️❄️❄️ ❄️☀️ ☀️❄️ ❄️☀️ ❄️☀️☀️ ❄️☀️☀️☀️ ☀️❄️ ☀️❄️☀️☀️ ❄️ ☀️☀️ ❄️❄️ ❄️❄️❄️ ☀️❄️☀️ ☀️ ☀️❄️ ☀️❄️☀️☀️ ❄️❄️❄️ ❄️☀️ ❄️❄️☀️ ☀️❄️ ❄️ ☀️ ☀️❄️☀️☀️ ☀️ ❄️❄️☀️ ☀️❄️☀️ ☀️❄️ ☀️❄️❄️☀️ ☀️☀️☀️☀️ ☀️❄️☀️☀️ ☀️☀️ ❄️☀️ ☀️ ❄️❄️❄️ ❄️☀️ ☀️☀️❄️❄️❄️ ☀️☀️☀️☀️❄️ ❄️❄️ ☀️❄️ ❄️☀️❄️❄️ ☀️❄️❄️❄️❄️ ❄️❄️❄️☀️☀️ ☀️☀️☀️☀️❄️ ☀️☀️☀️☀️❄️ ❄️ ❄️❄️❄️ ☀️❄️ ☀️❄️☀️☀️ ☀️☀️❄️☀️ ☀️❄️☀️ ☀️ ❄️☀️☀️ ☀️☀️☀️❄️ ☀️❄️ ☀️☀️ ☀️❄️☀️☀️"
print(converToText(convertToMorse(msg)))
Convert sun/snow to morse to text | Draw6 | C++ Solutions
#include <iostream>
#include <map>
//using namespace std;
void morseToText(std::string morseCode);
int main()
{
std::string morseCode
= "- .... . / .-- --- .-. .-.. -.. / -.-. .... .- -. --. . -.. / .-- .... . -. / ... .- -- ..- . .-.. / -- --- .-. ... . / ... . -. - / - .... . / ..-. .. .-. ... - / .-.. --- -. --. / -.. .. ... - .- -. -.-. . / -- . ... ... .- --. . / .-- .... .- - / .... .- - .... / --. --- -.. / .-- .-. --- ..- --. .... - / ....- ....- / -- .. .-.. . ... / -... . - .-- . . -. / .-- .- ... .... .. -. --. - --- -. / .- -. -.. / -... .- .-.. - .. -- --- .-. . / .- .-.. --- -. --. / .- / - . .-.. . --. .-. .- .--. .... / .-.. .. -. . / --- -. / ..--- ....- / -- .- -.-- / .---- ---.. ....- ....- / - --- / .- .-.. ..-. .-. . -.. / ...- .- .. .-..";
morseToText(morseCode);
return 0;
}
void morseToText(std::string morseCode)
{
std::map<std::string, char> morseCodeDict
= { { ".-", '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' },
{ "/", ' ' } };
size_t pos = 0;
while ((pos = morseCode.find(' '))
!= std::string::npos)
{
std::string token = morseCode.substr(0, pos);
if (morseCodeDict.find(token) != morseCodeDict.end())
{
std::cout << morseCodeDict[token];
}
else
{
std::cout << " ";
}
morseCode.erase(0, pos + 1);
}
std::cout << morseCodeDict[morseCode] << std::endl;
}
python | Peiran D | Python Solutions
import re
MORSE = {
'.-': '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',
'.----': '1', '..---': '2', '...--': '3', '....-': '4', '.....': '5',
'-....': '6', '--...': '7', '---..': '8', '----.': '9', '-----': '0'
}
text = (
"❄️ ☀️☀️☀️☀️ ☀️ ☀️❄️❄️ ❄️❄️❄️ ☀️❄️☀️ ☀️❄️☀️☀️ ❄️☀️☀️ "
"❄️☀️❄️☀️ ☀️☀️☀️☀️ ☀️❄️ ❄️☀️ ❄️❄️☀️ ☀️ ❄️☀️☀️ ☀️❄️❄️ ☀️☀️☀️☀️ ☀️ ❄️☀️ "
"☀️☀️☀️ ☀️❄️ ❄️❄️ ☀️☀️❄️ ☀️ ☀️❄️☀️☀️ ❄️❄️ ❄️❄️❄️ ☀️❄️☀️ ☀️☀️☀️ ☀️ "
"☀️☀️☀️ ☀️ ❄️☀️ ❄️ ❄️ ☀️☀️☀️☀️ ☀️ ☀️☀️❄️☀️ ☀️☀️ ☀️❄️☀️ ☀️☀️☀️ ❄️ "
"☀️❄️☀️☀️ ❄️❄️❄️ ❄️☀️ ❄️❄️☀️ ❄️☀️☀️ ☀️☀️ ☀️☀️☀️ ❄️ ☀️❄️ ❄️☀️ ❄️☀️❄️☀️ ☀️ "
"❄️❄️ ☀️ ☀️☀️☀️ ☀️☀️☀️ ☀️❄️ ❄️❄️☀️ ☀️ ☀️❄️❄️ ☀️☀️☀️☀️ ☀️❄️ ❄️ "
"☀️☀️☀️☀️ ☀️❄️ ❄️ ☀️☀️☀️☀️ ❄️❄️☀️ ❄️❄️❄️ ❄️☀️☀️ ☀️❄️❄️ ☀️❄️☀️ ❄️❄️❄️ ☀️☀️❄️ "
"❄️❄️☀️ ☀️☀️☀️☀️ ❄️ ☀️☀️☀️☀️❄️ ☀️☀️☀️☀️❄️ ❄️❄️ ☀️☀️ ☀️❄️☀️☀️ ☀️ ☀️☀️☀️ "
"❄️☀️☀️☀️ ☀️ ❄️ ☀️❄️❄️ ☀️ ☀️ ❄️☀️ ☀️❄️❄️ ☀️❄️ ☀️☀️☀️ ☀️☀️☀️☀️ ☀️☀️ "
"❄️☀️ ❄️❄️☀️ ❄️ ❄️❄️❄️ ❄️☀️ ☀️❄️ ❄️☀️ ❄️☀️☀️ ❄️☀️☀️☀️ ☀️❄️ ☀️❄️☀️☀️ "
"❄️ ☀️☀️ ❄️❄️ ❄️❄️❄️ ☀️❄️☀️ ☀️ ☀️❄️ ☀️❄️☀️☀️ ❄️❄️❄️ ❄️☀️ ❄️❄️☀️ "
"☀️❄️ ❄️ ☀️ ☀️❄️☀️☀️ ☀️ ❄️❄️☀️ ☀️❄️☀️ ☀️❄️ ☀️❄️❄️☀️ ☀️☀️☀️☀️ "
"☀️❄️☀️☀️ ☀️☀️ ❄️☀️ ☀️ ❄️❄️❄️ ❄️☀️ ☀️☀️❄️❄️❄️ ☀️☀️☀️☀️❄️ ❄️❄️ ☀️❄️ "
"❄️☀️❄️❄️ ☀️❄️❄️❄️❄️ ❄️❄️❄️☀️☀️ ☀️☀️☀️☀️❄️ ☀️☀️☀️☀️❄️ ❄️ ❄️❄️❄️ "
"☀️❄️ ☀️❄️☀️☀️ ☀️☀️❄️☀️ ☀️❄️☀️ ☀️ ❄️☀️☀️ ☀️☀️☀️❄️ ☀️❄️ ☀️☀️ ☀️❄️☀️☀️"
)
text = text.replace('☀️', '.').replace('❄️', '-')
text = text.replace(' ', ' / ')
text = text.replace(' ', ' ')
words = text.split(' / ')
decoded_words = []
for word in words:
letters = word.split()
decoded_letters = [MORSE[code] for code in letters if code in MORSE]
decoded_words.append(''.join(decoded_letters))
message = ' '.join(decoded_words)
print(message)
Simple look up table | greenya | Odin Solutions
package main
import "core:fmt"
import "core:strings"
MESSAGE := #load("message.txt", string)
DOT :: "☀️"
DASH :: "❄️"
CODE_BREAK :: " " // 3 spaces
WORD_BREAK :: " " // 7 spaces
main :: proc () {
message_trimmed := strings.trim_space(MESSAGE)
fmt.println("---- INPUT ----")
fmt.println(message_trimmed)
morse_lut := gen_morse_lut()
sb := strings.builder_make()
for word in strings.split(message_trimmed, WORD_BREAK) {
for code in strings.split(word, CODE_BREAK) {
fmt.assertf(code in morse_lut, "Unexpected code `%s`", code)
strings.write_byte(&sb, morse_lut[code])
}
strings.write_byte(&sb, ' ')
}
fmt.println("---- OUTPUT ----")
fmt.println(strings.to_string(sb))
}
// https://upload.wikimedia.org/wikipedia/commons/b/b5/International_Morse_Code.svg
gen_morse_lut :: proc (allocator := context.allocator) -> map [string] u8 {
m := make(map [string] u8, allocator)
m[DOT+DASH] = 'a'
m[DASH+DOT+DOT+DOT] = 'b'
m[DASH+DOT+DASH+DOT] = 'c'
m[DASH+DOT+DOT] = 'd'
m[DOT] = 'e'
m[DOT+DOT+DASH+DOT] = 'f'
m[DASH+DASH+DOT] = 'g'
m[DOT+DOT+DOT+DOT] = 'h'
m[DOT+DOT] = 'i'
m[DOT+DASH+DASH+DASH] = 'j'
m[DASH+DOT+DASH] = 'k'
m[DOT+DASH+DOT+DOT] = 'l'
m[DASH+DASH] = 'm'
m[DASH+DOT] = 'n'
m[DASH+DASH+DASH] = 'o'
m[DOT+DASH+DASH+DOT] = 'p'
m[DASH+DASH+DOT+DASH] = 'q'
m[DOT+DASH+DOT] = 'r'
m[DOT+DOT+DOT] = 's'
m[DASH] = 't'
m[DOT+DOT+DASH] = 'u'
m[DOT+DOT+DOT+DASH] = 'v'
m[DOT+DASH+DASH] = 'w'
m[DASH+DOT+DOT+DASH] = 'x'
m[DASH+DOT+DASH+DASH] = 'y'
m[DASH+DASH+DOT+DOT] = 'z'
m[DOT+DASH+DASH+DASH+DASH] = '1'
m[DOT+DOT+DASH+DASH+DASH] = '2'
m[DOT+DOT+DOT+DASH+DASH] = '3'
m[DOT+DOT+DOT+DOT+DASH] = '4'
m[DOT+DOT+DOT+DOT+DOT] = '5'
m[DASH+DOT+DOT+DOT+DOT] = '6'
m[DASH+DASH+DOT+DOT+DOT] = '7'
m[DASH+DASH+DASH+DOT+DOT] = '8'
m[DASH+DASH+DASH+DASH+DOT] = '9'
m[DASH+DASH+DASH+DASH+DASH] = '0'
return m
}
