#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>

using namespace std;

string decodeTransmission(const string& s, const unordered_map<string, string>& codeMap) {
    if (s.empty() || codeMap.empty()) {
        return s;
    }

    // Find the maximum key length to limit substring checks
    size_t maxKeyLen = 0;
    for (const auto& pair : codeMap) {
        if (pair.first.length() > maxKeyLen) {
            maxKeyLen = pair.first.length();
        }
    }

    string result;
    result.reserve(s.length() * 2); // Reserve space for potential expansion

    for (size_t i = 0; i < s.length(); ) {
        bool matched = false;
        // Check for matches starting at position i, from longest to shortest key
        for (size_t len = min(maxKeyLen, s.length() - i); len >= 1; --len) {
            string key = s.substr(i, len);
            auto it = codeMap.find(key);
            if (it != codeMap.end()) {
                result += it->second;
                i += len;
                matched = true;
                break;
            }
        }
        if (!matched) {
            result += s[i];
            i++;
        }
    }

    return result;
}

int main() {
    string s = "X1_Y2_Z3";
    unordered_map<string, string> codeMap = {{"X1", "Alpha"}, {"Y2", "Beta"}, {"Z3", "Gamma"}};
    cout << decodeTransmission(s, codeMap) << endl;
    return 0;
}

import java.util.HashMap;
import java.util.Map;

public class Main {
    /**
     * Decodes a galactic transmission string by replacing keys from codeMap.
     * 
     * @param s The raw transmission string.
     * @param codeMap A map of alien identifiers to human-readable strings.
     * @return The decoded string.
     */
    public static String decodeTransmission(String s, Map<String, String> codeMap) {
        if (s == null || s.isEmpty() || codeMap == null || codeMap.isEmpty()) {
            return s;
        }

        // Find the maximum key length to limit substring checks
        int maxKeyLen = 0;
        for (String key : codeMap.keySet()) {
            if (key.length() > maxKeyLen) {
                maxKeyLen = key.length();
            }
        }

        StringBuilder result = new StringBuilder();
        int i = 0;

        while (i < s.length()) {
            boolean matched = false;
            // Check for matches starting at position i, from longest to shortest key
            for (int len = Math.min(maxKeyLen, s.length() - i); len >= 1; --len) {
                String key = s.substring(i, i + len);
                if (codeMap.containsKey(key)) {
                    result.append(codeMap.get(key));
                    i += len;
                    matched = true;
                    break;
                }
            }
            if (!matched) {
                result.append(s.charAt(i));
                i++;
            }
        }

        return result.toString();
    }

    public static void main(String[] args) {
        String s = "X1_Y2_Z3";
        Map<String, String> codeMap = new HashMap<>();
        codeMap.put("X1", "Alpha");
        codeMap.put("Y2", "Beta");
        codeMap.put("Z3", "Gamma");
        System.out.println(decodeTransmission(s, codeMap));
    }
}

from typing import Dict


def decode_transmission(s: str, code_map: Dict[str, str]) -> str:
    """
    Decodes a galactic transmission string by replacing keys from code_map.
    
    Args:
        s: The raw transmission string.
        code_map: A map of alien identifiers to human-readable strings.
    
    Returns:
        The decoded string.
    """
    if not s or not code_map:
        return s

    # Find the maximum key length to limit substring checks
    max_key_len = max(len(key) for key in code_map)

    result = []
    i = 0

    while i < len(s):
        matched = False
        # Check for matches starting at position i, from longest to shortest key
        for length in range(min(max_key_len, len(s) - i), 0, -1):
            key = s[i:i + length]
            if key in code_map:
                result.append(code_map[key])
                i += length
                matched = True
                break
        if not matched:
            result.append(s[i])
            i += 1

    return ''.join(result)


# Example usage
if __name__ == "__main__":
    s = "X1_Y2_Z3"
    code_map = {"X1": "Alpha", "Y2": "Beta", "Z3": "Gamma"}
    print(decode_transmission(s, code_map))

/**
 * Decodes a galactic transmission string by replacing keys from codeMap.
 * 
 * @param {string} s - The raw transmission string.
 * @param {Object} codeMap - A map of alien identifiers to human-readable strings.
 * @return {string} The decoded string.
 */
function decodeTransmission(s, codeMap) {
    if (!s || Object.keys(codeMap).length === 0) {
        return s;
    }

    // Find the maximum key length to limit substring checks
    let maxKeyLen = 0;
    for (const key in codeMap) {
        if (key.length > maxKeyLen) {
            maxKeyLen = key.length;
        }
    }

    let result = "";
    let i = 0;

    while (i < s.length) {
        let matched = false;
        // Check for matches starting at position i, from longest to shortest key
        for (let len = Math.min(maxKeyLen, s.length - i); len >= 1; --len) {
            const key = s.substring(i, i + len);
            if (codeMap.hasOwnProperty(key)) {
                result += codeMap[key];
                i += len;
                matched = true;
                break;
            }
        }
        if (!matched) {
            result += s[i];
            i++;
        }
    }

    return result;
}

// Example usage
const s = "X1_Y2_Z3";
const codeMap = { "X1": "Alpha", "Y2": "Beta", "Z3": "Gamma" };
console.log(decodeTransmission(s, codeMap));