🐍 Python Weekly Coding Challenge - The space explorer’s journey

[mecodeatlas]

This is the first of four challenges designed to test and improve your Python skills. Each week, you'll tackle a new problem focusing on logic, data manipulation, and efficiency. Engage with others, share your ideas, and collaborate to find creative solutions—this is a space to learn and grow together! 🚀

General rules

• Project sharing: Personal projects are not allowed. Only solutions related to the challenges can be shared.
• Programming language: Challenges must be solved exclusively in Python (version 3.6 or later).
• Code quality: Your code should be well-structured, readable, and include explanatory comments.
• Submission: Solutions must be submitted until the end of each week, following the provided instructions. Please, share the link to the repository containing the challenge solved.

Evaluation criteria (Total: 100 points)

• Correctness (40 points): Does the solution meet the challenge requirements and produce the expected results?
• Efficiency (20 points): Is the code optimized in terms of time and resource usage, especially for large inputs?
• Readability & Idiomatic (20 points): Is the code clear, well-organized, and following Python’s PEP 8 style guide?
• Documentation (10 points): Does the code include useful and explanatory comments?
• Creativity (10 points): Does the solution showcase innovative approaches or optimizations?

Now, let’s dive into the first challenge! 🔥

The space explorer’s journey

You are a space explorer who has discovered an encrypted alien message. To decipher it and understand what the aliens are communicating, you must develop an efficient decoder.

Objective

Write a program that decodes a message following a specific encoding pattern.

Input & Output

Input: A string where each letter is followed by a number indicating its position in the decoded message.

Example:

input_string = "x2e1m4a3"

Expected output:

exam

Rules

• The encoded message contains only lowercase letters and numbers.
• No repeated characters in the encoded message.
• The position is 1-based (i.e., counting starts from 1).
• Each letter is followed by a number that indicates its position in the decoded message.
• To avoid ambiguities, the numbers indicating positions should be separated by a delimiter such as : (colon).

Good luck!

Guidelines

• I have read and understood this category's guidelines before making this post.

[mohnate]

Hey @mecodeatlas , this was a fun challenge!
Here’s how I approached it:
I noticed that every letter in the encoded string is followed by a number, which represents its position in the final message.
So, the idea is simple:

1. Extract all letter-number pairs.
2. Place the letters in the correct order based on their positions.
3. Join everything together to get the decoded message.

def decode_message(encoded: str) -> str:
    import re
    pairs = re.findall(r'([a-z])(\d+)', encoded)
    decoded = [''] * len(pairs)
    for letter, pos in pairs:
        decoded[int(pos) - 1] = letter
    return ''.join(decoded)

It runs efficiently since we only go through the input once.
Let me know if you see any edge cases I might have missed.

[YuheshPandian]

My solution for this problem:

code:

# this function returns a dictionary which contains the characters and the number following them
def generate_decode_dictionary(string):
    decode_dictionary: dict = {}
    for n in range(0, len(string), 2):
        # adjacent pairs: n, n+1
        character, position = string[n], string[n + 1]
        # add the numbers as keys and characters as values
        decode_dictionary[position] = character

    return decode_dictionary


# this function helps in sorting the dictionary based on keys
def sort_dictionary(dictionary):
    return dict(sorted(dictionary.items()))


decoded_dictionary = generate_decode_dictionary("x2e1m4a3")
sorted_decoded_dictionary = sort_dictionary(decoded_dictionary)

print("".join(sorted_decoded_dictionary.values()))

my approach:

• My approach was no to use any module and figure out the easiest way to solve the problem and efficiently.
• First, I split the input into adjacent pairs and use it to create a dictionary that holds the alphabet as value and the number following them as keys.
• Then I sort the dictionary based on the number to arrange them in numerical ascending order to encode the string.
• Finally, I join all the values (which are the alphabetical characters present in given string) present in dictionary to produce the decoded string

[BigZhou888]

my code:

code = input()
code_let = ''
code_num = ''
for i in range(len(code)//2):
    code_let += code[i * 2]
    code_num += code[i * 2 + 1]
fin = ''
for i in code_num:
    fin += code_let[int(i) - 1]

print(fin)

approach:

• my idea is to make 2 string, one is for numbers and the other one for letter and then use a for loop to solve

[imDarshanGK]

Hi @mecodeatlas,
My solution is:

    '''
    def decode(s):
        parts = [(s[i], int(s[i+1])) for i in range(0, len(s), 2)]
        max_pos = max(p[1] for p in parts)
        decoded = [''] * max_pos
        for char, pos in parts:
            decoded[pos - 1] = char
        return ''.join(decoded)
    print(decode("x2e1m4a3"))
    '''

Approach

Extract letters and their positions from the string
Sort the letters by their positions (1-based index)
Join the letters in order to form the decoded message

[newtakit]

c = input()
p= c.split(":")
cp = []
for p in ps:
if len(p) >= 2 and p[1:].isdigit():
letter = p[0]
position = int(p[1:])
cp.append((position, letter))
s = sorted(char_positions, key=lambda item: item[0])
d = "".join([char for pos, char in s])
print(d)

Approach
Receive Input , Split str ,Sort Position ,Message