Solution #57393d9b-59e2-47b2-8b3e-e09cbb074c22

def solve(input):
    data = input.get("data", "")
    if not isinstance(data, str) or len(data) == 0:
        return 999.0

    # Implement a simple dictionary-based compression algorithm
    def dictionary_compress(s):
        dictionary = {}
        output = []
        current_substring = ''
        max_dict_size = 256

        for char in s:
            new_substring = current_substring + char
            if new_substring in dictionary:
                current_substring = new_substring
            else:
                if current_substring:
                    output.append(dictionary[current_substring])
                else:
                    output.append(ord(char))
                if len(dictionary) < max_dict_size:
                    dictionary[new_substring] = len(dictionary) + 1
                current_substring = char

        if current_substring:
            if current_substring in dictionary:
                output.append(dictionary[current_substring])
            else:
                output.append(ord(current_substring))

        return output

    def dictionary_decompress(compressed):
        dictionary = {}
        output = []
        current_substring = ''
        inverse_dictionary = {v: k for k, v in dictionary.items()}

        for code in compressed:
            if code in inverse_dictionary:
                entry = inverse_dictionary[code]
            else:
                entry = current_substring + current_substring[0]

            output.append(entry)
            if current_substring:
                new_entry = current_substring + entry[0]
                if len(dictionary) < 256:
                    dictionary[new_entry] = len(dictionary) + 1

            current_substring = entry

        return ''.join(output)

    compressed_data = dictionary_compress(data)
    decompressed_data = dictionary_decompress(compressed_data)

    if decompressed_data != data:
        return 999.0

    original_size = len(data) * 8  # in bits (assuming 8 bits per character)
    compressed_size = len(compressed_data) * 8  # assuming each code is stored in 8 bits

    return compressed_size / float(original_size)