12

私の 8 歳の姪は、昨日学校でモールス信号のレッスンを受けました。彼女の課題は、さまざまなフレーズをモールス信号に変換することでした。フレーズの 1 つに彼女の年齢が含まれていまし---..3-2.。この初歩的な「圧縮アルゴリズム」が私の好奇心をかき立てたので、それを実装するためのコードを少し書きました。

ただし、途中でいくつかの変更を加えました。私は彼女に、あなたが単に と書いた場合、その書き手が を意図していたのか、それとも.....-----を意図していたのかを判断する方法はないことを指摘しました。実際には、各単語の各文字とすべての単語の間に一時停止があるため、これは問題にはなりませんが、私たちのスキームにはそれがありませんでした。私は方眼紙をいくつか取り出し、コーディングを容易にし、スキームからあいまいさを取り除くために、各シンボルのモールス符号を別のシンボルでパディングすることを提案しました。私のいい人は、「誰もそれらを文章で書いたことがない」ので、使用を提案しました。(ああ、私は最近数学の学位を取得して卒業しましたが、十分公平です。)50eeeeettttt+

私たちの何人かで書き、+全員がハイフンとピリオド/ドットを使用していますが、これはモールス信号の標準的な定義と矛盾するため、これらの記号はそれぞれph、 に置き換えられdます。もちろん、これにより、拡張モールス信号で定義されていない記号をどうするかという問題が生じます。私の姪は単にそれらを無視したかったので、それが私たちがしたことです。テキストメッセージの大文字と小文字を区別して保存するために、大文字はコード内で小文字になりません。それらはそのまま実行され、 で埋められ+ます。

アルゴリズムの要約:

  1. モールス信号は、右に 5 文字までパディングされます。+
  2. モールス信号を拡張して、 、 、を置き換えpました。+d.h-
  3. 「拡張」モールス符号で定義されていない記号は、そのまま渡されます。
  4. 連続する文字が 1 つしかない場合は、数字が省略されます。

潜在的な落とし穴:

  1. 私のパディングスキームは、おそらく圧縮の有効性を低下させます。
  2. 5 文字を超えるブロックを使用すると、圧縮率が向上する場合があります
  3. 私の姪または私が圧縮アルゴリズムについて何か知っていれば、おそらくそれを使用してそれらを成功させることができたでしょう.
  4. これは明らかに生産には適していませんが、そのような目的のための効率的な圧縮アルゴリズムが多数あるため、当面はその問題を無視しています。
  5. ???

例:

私たちのアルゴリズムでは、「Hello, World」は次のように変換されます

H++++.++++.-..+.-..+---++,+++++++++W++++---++.-.++.-..+-..++

圧縮して

H4+.4+.-2.+.-2.+3-2+,9+W4+3-2+.-.2+.-2.+-2.2+

一緒に投げたPythonコードは次のとおりです。

#!/usr/bin/python3

import itertools
import string

class MorseString(str):
    def __init__(self, string):
        # or, pad values during iteration but this seems neater
        self._char_morse_map = {"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":"-----",
                                " ":"+++++", ".":"d++++", "+":"p++++", "-":"h++++"}
        
        self._morse_char_map = dict()
        for letter, code in self._char_morse_map.items():
            self._morse_char_map[code] = letter

        self._string = string

        # convert the string to "Morse code". Could also use c.lower()
        self._morse_string = "".join([self._char_morse_map.get(c, c.ljust(5, "+")) for c in self._string])

    def compress(self):
        def grouper(n, k):
            return str(n) + k if n > 1 else k

        # could just use lambda
        return "".join([grouper(len(list(g)), k) for k, g in itertools.groupby(self._morse_string)])

    def decompress(self):
        i = 0
        start = 0
        chars = list()
        sc = self.compress()
        while i < len(sc):
            curr = sc[i]
            i += 1
            if not(curr in string.digits):
                num = 1 if start + 1 == i else int(sc[start:i-1])
                chars.append("".join(curr * num))
                start = i

        code = "".join(chars)
        chars = list()

        for i in range(0, len(code), 5):
            piece = "".join(code[i:i+5])
            chars.append(self._morse_char_map.get(piece, piece[0]))
            
        return "".join(chars)


def main():
    s0 = "Hello, World"
    ms0 = MorseString(s0)
    print(ms0._morse_string)
    print(ms0.compress())
    assert(s0 == ms0.decompress())
    
    s1 = "Hello  2 world."
    ms1 = MorseString(s1)
    assert(s1 == ms1.decompress())

    s2 = "The quick brown fox jumped over the lazy dog."
    ms2 = MorseString(s2)
    assert(s2 == ms2.decompress())

    s3 = "abc  -.+"
    ms3 = MorseString(s3)
    ms3
    assert(s3 == ms3.decompress())

if __name__ == "__main__":
    main()

a) アルゴリズムを改善し、b) 8 歳の姪に比較的簡単に説明できる簡単な方法は何ですか? 最後の点は明らかに主観的なものですが、それでも私は彼女の好奇心を可能な限り甘やかそうとしています。

コードの改善も歓迎します。コードの構造が非常によくないためです (実際には、構造がかなり貧弱であると確信していますが、速くて汚いです)。 Python (まだ) を使用します。

アップデート

これは、アルゴリズムに対する user1884905 の変更と、コード自体に対する Karl の改善の両方を組み込むことを試みる、コードの更新バージョンです。

import itertools
import string

_char_morse_map = {"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":"-----",
                   " ":"", ".":"d", "+":"p", "-":"h"}

_morse_char_map = {
    code: letter
    for letter, code in _char_morse_map.items()
}


def encode(s):
    return "".join(_char_morse_map.get(c, c) + "+" for c in s)

def decode(encoded):
    return "".join(decode_gen(encoded))

def decode_gen(encoded):
    word = ""
    for c in encoded:
        if c != "+":
            word += c
        else:
            yield _morse_char_map.get(word, word) if word != "" else " "
            word = ""

def compress(s):
    def grouper(n, k):
        return str(n) + k if n > 1 else k

    return "".join(grouper(len(list(g)), k) for k, g in itertools.groupby(s))

def decompress(compressed):
    return "".join(decompress_gen(compressed))

def decompress_gen(compressed):
    digits = ""
    for c in compressed:
        if c in string.digits:
            digits += c
        else:
            number = int(digits) if digits else 1
            yield "".join(c * number)
            digits = ""
4

2 に答える 2

4

出力を圧縮するための簡単な変更 (少なくともほとんどの場合) は、2 つの文字の間の一時停止の概念を維持し、-+記号がこの一時停止を示すようにすることです (つまり、プラスは新しい文字として使用されます-文字をパディングとして使用する代わりに)。

これにより、すべての数字が0-91 文字長くなりますが、よく使用されるかなりの数の文字が短くなります。

たとえば、、aおよびは、、、およびの代わりに、、eおよびになります。(andの代わりに表記することができます)it.-+.+..+-+.-+++.++++..+++-++++space++++++

したがって、あなたのHello, World例は次のようになります。

H+.+.-..+.-..+---+,++W+---+.-.+.-..+-..+

それ以外の

H++++.++++.-..+.-..+---++,+++++++++W++++---++.-.++.-..+-..++

圧縮して

H+.+.-2.+.-2.+3-+,2+W+3-+.-.+.-2.+-2.+

それ以外の

H4+.4+.-2.+.-2.+3-2+,9+W4+3-2+.-.2+.-2.+-2.2+

この理由を理解すると、ハフマン エンコーディングは自然な次のステップのように思えます。基本的な考え方は、最も一般的な文字ができるだけ少ないスペースしか占有しないようにすることです。

編集:

ツリーの最上部近くに最も一般的に出現する文字を示す二分法検索テーブルのこのウィキペディア画像も参照してください。

モールス符号の木

于 2013-03-28T08:58:53.180 に答える
2

私はこれのためのクラスを作りません。現状では、各文字列のマッピングを再作成します。これはクラスで回避できますが、実際には、これらのマッピングをセットアップしてから、文字列をエンコードする単純な関数を作成する方が簡単です。「モールス符号文字列」は、プレーンな文字列と根本的に異なるわけではなく、それに圧縮機能と解凍機能を追加しても意味がありません。たくさんの関数を書くだけです。本当に意味のある抽象化がある場合、OOP について心配する必要はありません。

書かれているように、解凍機能は意味がありません。圧縮は解凍の一部ではなく、同じ関数でモールス信号の解凍とプレーン文字列へのデコードを組み合わせました。これは混乱です。


self._morse_char_map = dict()
for letter, code in self._char_morse_map.items():
    self._morse_char_map[code] = letter

これは、辞書内包表記でよりきれいに書かれています。

self._morse_char_map = {
    code: letter
    for letter, code in self._char_morse_map.items()
}

"".join([...])

ここでは角括弧は不要です。代わりにジェネレーター式をフィードするだけjoinで、特別な構文規則を利用できます。


chars = list()

これはよりきちんと書かれchars = []ていますが、これをより高いレベルで改善してみましょう...


while i < len(sc):
    curr = sc[i]
    i += 1
    if not(curr in string.digits):
        num = 1 if start + 1 == i else int(sc[start:i-1])
        chars.append("".join(curr * num))
        start = i

テクニック: 空のリストを設定して繰り返し累積する''.joinのではなく、ジェネレーターを作成し、代わりに結果を渡すようにします。ロジックを独自の関数に適切に分離すると、これは簡単になります。

def decompress(compressed):
    return ''.join(decompress_gen(compressed))


def decompress_gen(compressed):
    start = 0
    i = 0
    while i < len(compressed):
        curr = compressed[i]
        i += 1
        if not(curr in string.digits):
            num = 1 if start + 1 == i else int(compressed[start:i-1])
            yield "".join(curr * num)
            start = i

ここで、ループを使用してcompressedシンボルを繰り返し処理したいだけであることは明らかです。for手動でインデックスをインクリメントするのは本当にひどいようです。これを機能させるには、一度に 1 文字ずつデータを見て、既に見た数字の部分を覚えておく必要があります。intそのまま計算を行うこともできますが、代わりにカウントの一部である文字のバッファーを構築することで、 の使用を維持しましょう。

def decompress_gen(compressed):
    number_digits = ''
    for char in compressed:
        if char in string.digits:
            number_digits += char
        else:
            number = int(number_digits) if number_digits else 1
            yield "".join(char * number)
            number_digits = ''

chars = list()

for i in range(0, len(code), 5):
    piece = "".join(code[i:i+5])
    chars.append(self._morse_char_map.get(piece, piece[0]))

return "".join(chars)

この時点で、codeは文字列であるため、''.joinを作成する際に は必要ありませんpiece。しかし、繰り返しになりますが、ここではジェネレーター (つまり、ジェネレーター式) を使用することもできます。

return ''.join(
    self._morse_char_map.get(piece, piece[0])
    for piece in (
        code[i: i + 5]
        for i in range(0, len(code), 5)
    )        
)
于 2013-03-28T05:09:40.827 に答える