เจเฉเจฐเจธ เจฆเฉ เจธเจผเฉเจฐเฉเจเจค เจคเฉเจ เจชเจนเจฟเจฒเจพเจ เจคเฉเจนเจพเจกเฉ เจฒเจ เจเฉฑเจ เจนเฉเจฐ เจเจชเจฏเฉเจเฉ เจธเจฎเฉฑเจเจฐเฉ เจฆเจพ เจ เจจเฉเจตเจพเจฆ เจคเจฟเจเจฐ เจเฉเจคเจพ เจเจฟเจ เจนเฉเฅค
เจนเจซเจฎเฉเจจ เจเฉเจกเจฟเฉฐเจ เจเฉฑเจ เจกเฉเจเจพ เจเฉฐเจชเจฐเฉเจธเจผเจจ เจเจฒเจเฉเจฐเจฟเจฆเจฎ เจนเฉ เจเฉ เจซเจพเจเจฒ เจเฉฐเจชเจฐเฉเจธเจผเจจ เจฆเฉ เจฎเฉเจฒ เจตเจฟเจเจพเจฐ เจจเฉเฉฐ เจคเจฟเจเจฐ เจเจฐเจฆเจพ เจนเฉเฅค เจเจธ เจฒเฉเจ เจตเจฟเฉฑเจ, เจ เจธเฉเจ เจซเจฟเจเจธเจก เจ เจคเฉ เจตเฉเจฐเฉเจเจฌเจฒ เจฒเฉฐเจฌเจพเจ เจเฉฐเจเฉเจกเจฟเฉฐเจ, เจตเจฟเจฒเฉฑเจเจฃ เจคเฉเจฐ 'เจคเฉ เจกเฉเจเฉเจก เจเจฐเจจ เจฏเฉเจ เจเฉเจก, เจ เจเฉเจคเจฐ เจจเจฟเจฏเจฎเจพเจ, เจ เจคเฉ เจนเจซเจฎเฉเจจ เจเฉเจฐเฉ เจฌเจฃเจพเจเจฃ เจฌเจพเจฐเฉ เจเฉฑเจฒ เจเจฐเจพเจเจเฉเฅค
เจ เจธเฉเจ เจเจพเจฃเจฆเฉ เจนเจพเจ เจเจฟ เจนเจฐเฉเจ เจ เฉฑเจเจฐ 0 เจ เจคเฉ 1 เจฆเฉ เจเฉเจฐเจฎ เจตเจเฉเจ เจธเจเฉเจฐ เจเฉเจคเจพ เจเจพเจเจฆเจพ เจนเฉ เจ เจคเฉ 8 เจฌเจฟเฉฑเจ เจฒเฉเจเจฆเจพ เจนเฉเฅค เจเจธ เจจเฉเฉฐ เจซเจฟเจเจธเจก เจฒเฉฐเจฌเจพเจ เจเฉฐเจเฉเจกเจฟเฉฐเจ เจเจฟเจนเจพ เจเจพเจเจฆเจพ เจนเฉ เจเจฟเจเจเจเจฟ เจนเจฐเฉเจ เจ เฉฑเจเจฐ เจธเจเฉเจฐ เจเจฐเจจ เจฒเจ เจฌเจฟเฉฑเจเจพเจ เจฆเฉ เจเฉฑเจเฉ เจจเจฟเจธเจผเจเจฟเจค เจธเฉฐเจเจฟเจ เจฆเฉ เจตเจฐเจคเฉเจ เจเจฐเจฆเจพ เจนเฉเฅค
เจฎเฉฐเจจ เจฒเจ เจเจฟ เจธเจพเจจเฉเฉฐ เจเฉเจเจธเจ เจฆเจฟเฉฑเจคเจพ เจเจฟเจ เจนเฉเฅค เจ เจธเฉเจ เจเฉฑเจ เจ เฉฑเจเจฐ เจจเฉเฉฐ เจธเจเฉเจฐ เจเจฐเจจ เจฒเจ เจฒเฉเฉเฉเจเจฆเฉ เจฅเจพเจ เจฆเฉ เจฎเจพเจคเจฐเจพ เจจเฉเฉฐ เจเจฟเจตเฉเจ เจเจเจพ เจธเจเจฆเฉ เจนเจพเจ?
เจฎเฉเฉฑเจ เจตเจฟเจเจพเจฐ เจตเฉเจฐเฉเจเจฌเจฒ เจฒเฉฐเจฌเจพเจ เจเฉฐเจเฉเจกเจฟเฉฐเจ เจนเฉเฅค เจ เจธเฉเจ เจเจธ เจคเฉฑเจฅ เจฆเฉ เจตเจฐเจคเฉเจ เจเจฐ เจธเจเจฆเฉ เจนเจพเจ เจเจฟ เจเฉเจเจธเจ เจตเจฟเฉฑเจ เจเฉเจ เจ เฉฑเจเจฐ เจฆเฉเจเจฟเจเจ เจจเจพเจฒเฉเจ เจตเฉฑเจง เจ เจเจธเจฐ เจนเฉเฉฐเจฆเฉ เจนเจจ () เจเฉฑเจ เจเจฒเจเฉเจฐเจฟเจฆเจฎ เจตเจฟเจเจธเจฟเจค เจเจฐเจจ เจฒเจ เจเฉ เจเฉฑเจ เจฌเจฟเฉฑเจเจพเจ เจตเจฟเฉฑเจ เจ เฉฑเจเจฐเจพเจ เจฆเฉ เจธเจฎเจพเจจ เจเฉเจฐเจฎ เจจเฉเฉฐ เจฆเจฐเจธเจพเจเจเจพเฅค เจตเฉเจฐเฉเจเจฌเจฒ เจฒเฉฐเจฌเจพเจ เจเจจเจเฉเจกเจฟเฉฐเจ เจตเจฟเฉฑเจ, เจ เจธเฉเจ เจ เฉฑเจเจฐเจพเจ เจจเฉเฉฐ เจฌเจฟเฉฑเจเจพเจ เจฆเฉ เจเฉฑเจ เจชเจฐเจฟเจตเจฐเจคเจจเจธเจผเฉเจฒ เจธเฉฐเจเจฟเจ เจจเจฟเจฐเจงเจพเจฐเจค เจเจฐเจฆเฉ เจนเจพเจ, เจเจน เจเจธ เจเฉฑเจฒ 'เจคเฉ เจจเจฟเจฐเจญเจฐ เจเจฐเจฆเจพ เจนเฉ เจเจฟ เจเจน เจฆเจฟเฉฑเจคเฉ เจเฉเจเจธเจ เจตเจฟเฉฑเจ เจเจฟเฉฐเจจเฉ เจตเจพเจฐ เจฆเจฟเจเจพเจ เจฆเจฟเฉฐเจฆเฉ เจนเจจเฅค เจ เฉฐเจค เจตเจฟเฉฑเจ, เจเฉเจ เจ เฉฑเจเจฐ 1 เจฌเจฟเฉฑเจ เจฆเฉ เจฐเฉเจช เจตเจฟเฉฑเจ เจเฉฑเจ เจฒเฉ เจธเจเจฆเฉ เจนเจจ, เจเจฆเฉเจ เจเจฟ เจฆเฉเจธเจฐเฉ 2 เจฌเจฟเฉฑเจ, 3 เจเจพเจ เจตเฉฑเจง เจฒเฉ เจธเจเจฆเฉ เจนเจจเฅค เจตเฉเจฐเฉเจเจฌเจฒ เจฒเฉฐเจฌเจพเจ เจเจจเจเฉเจกเจฟเฉฐเจ เจฆเฉ เจธเจฎเฉฑเจธเจฟเจ เจธเจฟเจฐเจซ เจเฉเจฐเจฎ เจฆเฉ เจฌเจพเจ เจฆ เจฆเฉ เจกเฉเจเฉเจกเจฟเฉฐเจ เจนเฉเฅค
เจฌเจฟเฉฑเจเจพเจ เจฆเฉ เจเฉเจฐเจฎ เจจเฉเฉฐ เจเจพเจฃเจฆเฉ เจนเฉเจ, เจเจธเจจเฉเฉฐ เจ เจธเจชเจธเจผเจ เจฐเฉเจช เจตเจฟเฉฑเจ เจกเฉเจเฉเจก เจเจฟเจตเฉเจ เจเจฐเฉเจ?
เจฒเจพเจเจจ 'เจคเฉ เจเฉเจฐ เจเจฐเฉ "abacdab". เจเจธ เจตเจฟเฉฑเจ 8 เจ เฉฑเจเจฐ เจนเจจ, เจ เจคเฉ เจเฉฑเจ เจจเจฟเจธเจผเจเจฟเจค เจฒเฉฐเจฌเจพเจ เจจเฉเฉฐ เจเจจเจเฉเจกเจฟเฉฐเจ เจเจฐเจฆเฉ เจธเจฎเฉเจ, เจเจธเจจเฉเฉฐ เจธเจเฉเจฐ เจเจฐเจจ เจฒเจ 64 เจฌเจฟเฉฑเจเจพเจ เจฆเฉ เจฒเฉเฉ เจนเฉเจตเฉเจเฉเฅค เจจเฉเจ เจเจฐเฉ เจเจฟ เจชเฉเจฐเจคเฉเจ เจฌเจพเจฐเฉฐเจฌเจพเจฐเจคเจพ "เจ", "เจฌเฉ", "เจธเฉ" ะธ "เจกเฉ" เจเฉเจฐเจฎเจตเจพเจฐ 4, 2, 1, 1 เจฆเฉ เจฌเจฐเจพเจฌเจฐ เจนเฉเฅค เจฆเฉ เจเจฒเจชเจจเจพ เจเจฐเจจ เจฆเฉ เจเฉเจธเจผเจฟเจธเจผ เจเจฐเฉเจ "abacdab" เจเฉฑเจ เจฌเจฟเฉฑเจ, เจเจธ เจคเฉฑเจฅ เจฆเฉ เจตเจฐเจคเฉเจ เจเจฐเจฆเฉ เจนเฉเจ "เจคเฉเจ" เจจเจพเจฒเฉเจ เจเจผเจฟเจเจฆเจพ เจตเจพเจฐ เจนเฉเฉฐเจฆเจพ เจนเฉ "เจฌเฉ"เจ เจคเฉ "เจฌเฉ" เจจเจพเจฒเฉเจ เจเจผเจฟเจเจฆเจพ เจตเจพเจฐ เจนเฉเฉฐเจฆเจพ เจนเฉ "c" ะธ "เจกเฉ". เจเจ เจเฉเจกเจฟเฉฐเจ เจฆเฉเจเจฐเจพ เจธเจผเฉเจฐเฉ เจเจฐเฉเจ "เจคเฉเจ" 0 เจฆเฉ เจฌเจฐเจพเจฌเจฐ เจเฉฑเจ เจฌเจฟเฉฑเจ เจจเจพเจฒ, "เจฌเฉ" เจ เจธเฉเจ เจฆเฉ-เจฌเจฟเฉฑเจ เจเฉเจก 11 เจจเจฟเจฐเจงเจพเจฐเจค เจเจฐเจพเจเจเฉ, เจ เจคเฉ เจคเจฟเฉฐเจจ เจฌเจฟเฉฑเจ 100 เจ เจคเฉ 011 เจฆเฉ เจตเจฐเจคเฉเจ เจเจฐเจเฉ เจ เจธเฉเจ เจเจจเจเฉเจก เจเจฐเจพเจเจเฉ "c" ะธ "เจกเฉ".
เจจเจคเฉเจเฉ เจตเจเฉเจ, เจ เจธเฉเจ เจชเฉเจฐเจพเจชเจค เจเจฐเจพเจเจเฉ:
a
0
b
11
c
100
d
011
เจเจธ เจฒเจ เจฒเจพเจเจจ "abacdab" เจ เจธเฉเจ เจเจธ เจคเจฐเฉเจนเจพเจ เจเจจเจเฉเจก เจเจฐเจพเจเจเฉ 00110100011011 (0|0|11|0|100|011|0|11)เจเจชเจฐเฉเจเจค เจเฉเจกเจพเจ เจฆเฉ เจตเจฐเจคเฉเจ เจเจฐเจฆเฉ เจนเฉเจ. เจนเจพเจฒเจพเจเจเจฟ, เจฎเฉเฉฑเจ เจธเจฎเฉฑเจธเจฟเจ เจกเฉเจเฉเจกเจฟเฉฐเจ เจตเจฟเฉฑเจ เจนเฉเจตเฉเจเฉเฅค เจเจฆเฉเจ เจ เจธเฉเจ เจธเจคเจฐ เจจเฉเฉฐ เจกเฉเจเฉเจก เจเจฐเจจ เจฆเฉ เจเฉเจธเจผเจฟเจธเจผ เจเจฐเจฆเฉ เจนเจพเจ 00110100011011, เจธเจพเจจเฉเฉฐ เจเฉฑเจ เจ เจธเจชเจธเจผเจ เจจเจคเฉเจเจพ เจฎเจฟเจฒเจฆเจพ เจนเฉ, เจเจฟเจเจเจเจฟ เจเจธเจจเฉเฉฐ เจเจธ เจคเจฐเฉเจนเจพเจ เจฆเจฐเจธเจพเจเจ เจเจพ เจธเจเจฆเจพ เจนเฉ:
0|011|0|100|011|0|11 adacdab
0|0|11|0|100|0|11|011 aabacabd
0|011|0|100|0|11|0|11 adacabab
...
เจ
เจคเฉ เจเจธ เจคเจฐเจพเจ เจนเฉ.
เจเจธ เจ เจธเจชเจธเจผเจเจคเจพ เจคเฉเจ เจฌเจเจฃ เจฒเจ, เจธเจพเจจเฉเฉฐ เจเจน เจฏเจเฉเจจเฉ เจฌเจฃเจพเจเจฃเจพ เจเจพเจนเฉเจฆเจพ เจนเฉ เจเจฟ เจธเจพเจกเฉ เจเจจเจเฉเจกเจฟเฉฐเจ เจ เจเจฟเจนเฉ เจงเจพเจฐเจจเจพ เจจเฉเฉฐ เจธเฉฐเจคเฉเจธเจผเจ เจเจฐเจฆเฉ เจนเฉ เจเจฟเจตเฉเจ เจเจฟ เจ เจเฉเจคเจฐ เจจเจฟเจฏเจฎ, เจเฉ เจฌเจฆเจฒเฉ เจตเจฟเฉฑเจ เจเจน เจฆเจฐเจธเจพเจเจเจฆเจพ เจนเฉ เจเจฟ เจเฉเจกเจพเจ เจจเฉเฉฐ เจธเจฟเจฐเจซเจผ เจเฉฑเจ เจตเจฟเจฒเฉฑเจเจฃ เจคเจฐเฉเจเฉ เจจเจพเจฒ เจกเฉเจเฉเจก เจเฉเจคเจพ เจเจพ เจธเจเจฆเจพ เจนเฉเฅค เจ เจเฉเจคเจฐ เจจเจฟเจฏเจฎ เจเจน เจฏเจเฉเจจเฉ เจฌเจฃเจพเจเจเจฆเจพ เจนเฉ เจเจฟ เจเฉเจ เจตเฉ เจเฉเจก เจฆเฉเจเฉ เจฆเจพ เจ เจเฉเจคเจฐ เจจเจนเฉเจ เจนเฉเฅค เจเฉเจก เจฆเฉเจเจฐเจพ, เจธเจพเจกเจพ เจฎเจคเจฒเจฌ เจเฉฑเจ เจเจพเจธ เจ เฉฑเจเจฐ เจจเฉเฉฐ เจฆเจฐเจธเจพเจเจฃ เจฒเจ เจตเจฐเจคเฉ เจเจพเจเจฆเฉ เจฌเจฟเฉฑเจ เจนเจจเฅค เจเจชเจฐเฉเจเจค เจเจฆเจพเจนเจฐเจจ เจตเจฟเฉฑเจ 0 เจเฉฑเจ เจ เจเฉเจคเจฐ เจนเฉ 011, เจเฉ เจ เจเฉเจคเจฐ เจจเจฟเจฏเจฎ เจฆเฉ เจเจฒเฉฐเจเจฃเจพ เจเจฐเจฆเจพ เจนเฉเฅค เจเจธ เจฒเจ, เจเฉเจเจฐ เจธเจพเจกเฉ เจเฉเจก เจ เจเฉเจคเจฐ เจจเจฟเจฏเจฎ เจจเฉเฉฐ เจชเฉเจฐเจพ เจเจฐเจฆเฉ เจนเจจ, เจคเจพเจ เจ เจธเฉเจ เจตเจฟเจฒเฉฑเจเจฃ เจคเฉเจฐ 'เจคเฉ เจกเฉเจเฉเจก เจเจฐ เจธเจเจฆเฉ เจนเจพเจ (เจ เจคเฉ เจเจธเจฆเฉ เจเจฒเจ)เฅค
เจเจ เจเจชเจฐเฉเจเจค เจเจฆเจพเจนเจฐเจจ 'เจคเฉ เจฎเฉเฉ เจตเจฟเจเจพเจฐ เจเจฐเฉเจเฅค เจเจธ เจตเจพเจฐ เจ เจธเฉเจ เจเจฟเฉฐเจจเฉเจนเจพเจ เจฒเจ เจจเจฟเจฐเจงเจพเจฐเจค เจเจฐเจพเจเจเฉ "เจ", "เจฌเฉ", "เจธเฉ" ะธ "เจกเฉ" เจเฉเจก เจเฉ เจชเฉเจฐเฉเจซเจฟเจเจธ เจจเจฟเจฏเจฎ เจจเฉเฉฐ เจชเฉเจฐเจพ เจเจฐเจฆเฉ เจนเจจเฅค
a
0
b
10
c
110
d
111
เจเจธ เจเฉฐเจเฉเจกเจฟเฉฐเจ เจจเจพเจฒ, เจธเจคเจฐ "abacdab" เจฆเฉ เจฐเฉเจช เจตเจฟเฉฑเจ เจเจจเจเฉเจก เจเฉเจคเจพ เจเจพเจตเฉเจเจพ 00100100011010 (0|0|10|0|100|011|0|10). เจ เจคเฉ เจเฉฑเจฅเฉ 00100100011010 เจ เจธเฉเจ เจชเจนเจฟเจฒเจพเจ เจนเฉ เจ เจธเจชเจธเจผเจ เจคเฉเจฐ 'เจคเฉ เจกเฉเจเฉเจก เจเจฐเจจ เจฆเฉ เจฏเฉเจ เจนเฉเจตเจพเจเจเฉ เจ เจคเฉ เจเจชเจฃเฉ เจ เจธเจฒ เจธเจเฉเจฐเจฟเฉฐเจ 'เจคเฉ เจตเจพเจชเจธ เจเจพเจตเจพเจเจเฉ "abacdab".
เจนเจซเจฎเฉเจจ เจเฉเจกเจฟเฉฐเจ
เจนเฉเจฃ เจเจฆเฉเจ เจ เจธเฉเจ เจตเฉเจฐเฉเจเจฌเจฒ เจฒเฉฐเจฌเจพเจ เจเฉฐเจเฉเจกเจฟเฉฐเจ เจ เจคเฉ เจชเฉเจฐเฉเจซเจฟเจเจธ เจจเจฟเจฏเจฎ เจจเจพเจฒ เจจเจเจฟเฉฑเจ เจฒเจฟเจ เจนเฉ, เจเจ เจนเจซเจฎเฉเจจ เจเจจเจเฉเจกเจฟเฉฐเจ เจฌเจพเจฐเฉ เจเฉฑเจฒ เจเจฐเฉเจเฅค
เจตเจฟเจงเฉ เจฌเจพเจเจจเจฐเฉ เจฐเฉเฉฑเจเจพเจ เจฆเฉ เจฐเจเจจเจพ 'เจคเฉ เจ เจงเจพเจฐเจค เจนเฉเฅค เจเจธ เจตเจฟเฉฑเจ, เจจเฉเจก เจ เฉฐเจคเจฎ เจเจพเจ เจ เฉฐเจฆเจฐเฉเจจเฉ เจนเฉ เจธเจเจฆเจพ เจนเฉ. เจธเจผเฉเจฐเฉ เจตเจฟเฉฑเจ, เจธเจพเจฐเฉ เจจเฉเจกเจพเจ เจจเฉเฉฐ เจชเฉฑเจคเฉ (เจเจฐเจฎเฉเจจเจฒ) เจฎเฉฐเจจเจฟเจ เจเจพเจเจฆเจพ เจนเฉ, เจเฉ เจเจชเจฃเฉ เจเจช เจจเฉเฉฐ เจชเฉเจฐเจคเฉเจ เจ เจคเฉ เจเจธเจฆเฉ เจญเจพเจฐ เจจเฉเฉฐ เจฆเจฐเจธเจพเจเจเจฆเฉ เจนเจจ (เจ เจฐเจฅเจพเจค, เจตเจพเจชเจฐเจจ เจฆเฉ เจฌเจพเจฐเฉฐเจฌเจพเจฐเจคเจพ)เฅค เจ เฉฐเจฆเจฐเฉเจจเฉ เจจเฉเจกเจพเจ เจตเจฟเฉฑเจ เจ เฉฑเจเจฐ เจฆเจพ เจญเจพเจฐ เจนเฉเฉฐเจฆเจพ เจนเฉ เจ เจคเฉ เจฆเฉ เจเฉฑเจคเจฐเจพเจงเจฟเจเจพเจฐเฉ เจจเฉเจกเจพเจ เจฆเจพ เจนเจตเจพเจฒเจพ เจฆเจฟเฉฐเจฆเฉ เจนเจจเฅค เจเจฎ เจธเจฎเจเฉเจคเฉ เจฆเฉเจเจฐเจพ, เจฌเจฟเฉฑเจ "0" เจเฉฑเจฌเฉ เจธเจผเจพเจเจพ เจจเฉเฉฐ เจฆเจฐเจธเจพเจเจเจฆเจพ เจนเฉ, เจ เจคเฉ "1" - เจธเฉฑเจเฉ เจชเจพเจธเฉ. เจชเฉเจฐเฉ เจฐเฉเฉฑเจ เจตเจฟเฉฑเจ N เจชเฉฑเจคเฉ เจ เจคเฉ N-1 เจ เฉฐเจฆเจฐเฉเจจเฉ เจจเฉเจกเจธ. เจเจน เจธเจฟเจซเจพเจฐเจธเจผ เจเฉเจคเฉ เจเจพเจเจฆเฉ เจนเฉ เจเจฟ เจเจฆเฉเจ เจเฉฑเจ เจนเจซเจฎเฉเจจ เจเฉเจฐเฉ เจฌเจฃเจพเจเจเจฆเฉ เจนเฉ, เจ เจจเฉเจเฉเจฒ เจฒเฉฐเจฌเจพเจ เจฆเฉ เจเฉเจก เจชเฉเจฐเจพเจชเจค เจเจฐเจจ เจฒเจ เจ เจฃเจตเจฐเจคเฉ เจเจฟเฉฐเจจเฉเจนเจพเจ เจจเฉเฉฐ เจฐเฉฑเจฆ เจเจฐ เจฆเจฟเฉฑเจคเจพ เจเจพเจเจฆเจพ เจนเฉเฅค
เจ เจธเฉเจ เจเฉฑเจ เจนเจซเจฎเฉเจจ เจเฉเจฐเฉ เจฌเจฃเจพเจเจฃ เจฒเจ เจเฉฑเจ เจคเจฐเจเฉเจน เจเจคเจพเจฐ เจฆเฉ เจตเจฐเจคเฉเจ เจเจฐเจพเจเจเฉ, เจเจฟเฉฑเจฅเฉ เจธเจญ เจคเฉเจ เจเฉฑเจ เจฌเจพเจฐเฉฐเจฌเจพเจฐเจคเจพ เจตเจพเจฒเฉ เจจเฉเจก เจจเฉเฉฐ เจธเจญ เจคเฉเจ เจตเฉฑเจง เจคเจฐเจเฉเจน เจฆเจฟเฉฑเจคเฉ เจเจพเจตเฉเจเฉเฅค เจเจธเจพเจฐเฉ เจฆเฉ เจเจฆเจฎ เจนเฉเจ เจพเจ เจฆเจฟเฉฑเจคเฉ เจเจ เจนเจจ:
- เจนเจฐเฉเจ เจ เฉฑเจเจฐ เจฒเจ เจเฉฑเจ เจฒเฉเจซ เจจเฉเจก เจฌเจฃเจพเจ เจ เจคเฉ เจเจนเจจเจพเจ เจจเฉเฉฐ เจคเจฐเจเฉเจนเฉ เจเจคเจพเจฐ เจตเจฟเฉฑเจ เจธเจผเจพเจฎเจฒ เจเจฐเฉเฅค
- เจเจฆเฉเจ เจเจคเจพเจฐ เจตเจฟเฉฑเจ เจเฉฑเจ เจคเฉเจ เจตเฉฑเจง เจธเจผเฉเจ เจนเจจ, เจคเจพเจ เจนเฉเจ เจพเจ เจฆเจฟเฉฑเจคเฉ เจเฉฐเจฎ เจเจฐเฉ:
- เจเจคเจพเจฐ เจคเฉเจ เจธเจญ เจคเฉเจ เจตเฉฑเจง เจคเจฐเจเฉเจน (เจธเจญ เจคเฉเจ เจเฉฑเจ เจฌเจพเจฐเฉฐเจฌเจพเจฐเจคเจพ) เจตเจพเจฒเฉ เจฆเฉ เจจเฉเจกเจพเจ เจจเฉเฉฐ เจนเจเจพเจ;
- เจเฉฑเจ เจจเจตเจพเจ เจ เฉฐเจฆเจฐเฉเจจเฉ เจจเฉเจก เจฌเจฃเจพเจ, เจเจฟเฉฑเจฅเฉ เจเจน เจฆเฉ เจจเฉเจก เจฌเฉฑเจเฉ เจนเฉเจฃเจเฉ, เจ เจคเฉ เจตเจพเจชเจฐเจจ เจฆเฉ เจฌเจพเจฐเฉฐเจฌเจพเจฐเจคเจพ เจเจนเจจเจพเจ เจฆเฉ เจจเฉเจกเจพเจ เจฆเฉ เจฌเจพเจฐเฉฐเจฌเจพเจฐเจคเจพ เจฆเฉ เจเฉเฉ เจฆเฉ เจฌเจฐเจพเจฌเจฐ เจนเฉเจตเฉเจเฉเฅค
- เจคเจฐเจเฉเจนเฉ เจเจคเจพเจฐ เจตเจฟเฉฑเจ เจเฉฑเจ เจจเจตเจพเจ เจจเฉเจก เจธเจผเจพเจฎเจฒ เจเจฐเฉเฅค
- เจธเจฟเจฐเจซ เจฌเจพเจเฉ เจฌเจเจฟเจ เจจเฉเจก เจฐเฉเจ เจนเฉเจตเฉเจเจพ, เจ เจคเฉ เจเจน เจฐเฉเฉฑเจ เจฆเฉ เจเจธเจพเจฐเฉ เจจเฉเฉฐ เจชเฉเจฐเจพ เจเจฐเฉเจเจพ.
เจเจฒเจชเจจเจพ เจเจฐเฉ เจเจฟ เจธเจพเจกเฉ เจเฉเจฒ เจเฉเจ เจเฉเจเจธเจ เจนเฉ เจเจฟเจธ เจตเจฟเฉฑเจ เจธเจฟเจฐเจซเจผ เจ เฉฑเจเจฐ เจนเจจ "เจ เจฌ เจธ เจก" ะธ "เจ เจคเฉ", เจ เจคเฉ เจเจนเจจเจพเจ เจฆเฉ เจฎเฉเจเฉเจฆเจเฉ เจฆเฉ เจฌเจพเจฐเฉฐเจฌเจพเจฐเจคเจพ เจเฉเจฐเจฎเจตเจพเจฐ 15, 7, 6, 6, เจ เจคเฉ 5 เจนเฉเฅค เจนเฉเจ เจพเจ เจเจน เจเจฟเฉฑเจคเจฐ เจนเจจ เจเฉ เจเจฒเจเฉเจฐเจฟเจฆเจฎ เจฆเฉ เจเจฆเจฎเจพเจ เจจเฉเฉฐ เจฆเจฐเจธเจพเจเจเจฆเฉ เจนเจจเฅค
เจฐเฉเจ เจคเฉเจ เจเจฟเจธเฉ เจตเฉ เจธเจฟเจฐเฉ เจฆเฉ เจจเฉเจก เจคเฉฑเจ เจฆเจพ เจเฉฑเจ เจฎเจพเจฐเจ เจเจธ เจธเจฟเจฐเฉ เจฆเฉ เจจเฉเจก เจจเจพเจฒ เจธเฉฐเจฌเฉฐเจงเจฟเจค เจ
เฉฑเจเจฐ เจจเจพเจฒ เจธเฉฐเจฌเฉฐเจงเจฟเจค เจ
เจจเฉเจเฉเจฒ เจชเฉเจฐเฉเจซเจฟเจเจธ เจเฉเจก (เจเจฟเจธ เจจเฉเฉฐ เจนเจซเจฎเฉเจจ เจเฉเจก เจตเฉ เจเจฟเจนเจพ เจเจพเจเจฆเจพ เจนเฉ) เจจเฉเฉฐ เจธเจเฉเจฐ เจเจฐเฉเจเจพเฅค
เจนเจซเจฎเฉเจจ เจฆเจพ เจฐเฉเฉฑเจ
เจนเฉเจ เจพเจ เจคเฉเจธเฉเจ C++ เจ เจคเฉ Java เจตเจฟเฉฑเจ เจนเจซเจฎเฉเจจ เจเฉฐเจชเจฐเฉเจธเจผเจจ เจเจฒเจเฉเจฐเจฟเจฆเจฎ เจจเฉเฉฐ เจฒเจพเจเฉ เจเจฐเฉเจเฉ:
#include <iostream>
#include <string>
#include <queue>
#include <unordered_map>
using namespace std;
// A Tree node
struct Node
{
char ch;
int freq;
Node *left, *right;
};
// Function to allocate a new tree node
Node* getNode(char ch, int freq, Node* left, Node* right)
{
Node* node = new Node();
node->ch = ch;
node->freq = freq;
node->left = left;
node->right = right;
return node;
}
// Comparison object to be used to order the heap
struct comp
{
bool operator()(Node* l, Node* r)
{
// highest priority item has lowest frequency
return l->freq > r->freq;
}
};
// traverse the Huffman Tree and store Huffman Codes
// in a map.
void encode(Node* root, string str,
unordered_map<char, string> &huffmanCode)
{
if (root == nullptr)
return;
// found a leaf node
if (!root->left && !root->right) {
huffmanCode[root->ch] = str;
}
encode(root->left, str + "0", huffmanCode);
encode(root->right, str + "1", huffmanCode);
}
// traverse the Huffman Tree and decode the encoded string
void decode(Node* root, int &index, string str)
{
if (root == nullptr) {
return;
}
// found a leaf node
if (!root->left && !root->right)
{
cout << root->ch;
return;
}
index++;
if (str[index] =='0')
decode(root->left, index, str);
else
decode(root->right, index, str);
}
// Builds Huffman Tree and decode given input text
void buildHuffmanTree(string text)
{
// count frequency of appearance of each character
// and store it in a map
unordered_map<char, int> freq;
for (char ch: text) {
freq[ch]++;
}
// Create a priority queue to store live nodes of
// Huffman tree;
priority_queue<Node*, vector<Node*>, comp> pq;
// Create a leaf node for each character and add it
// to the priority queue.
for (auto pair: freq) {
pq.push(getNode(pair.first, pair.second, nullptr, nullptr));
}
// do till there is more than one node in the queue
while (pq.size() != 1)
{
// Remove the two nodes of highest priority
// (lowest frequency) from the queue
Node *left = pq.top(); pq.pop();
Node *right = pq.top(); pq.pop();
// Create a new internal node with these two nodes
// as children and with frequency equal to the sum
// of the two nodes' frequencies. Add the new node
// to the priority queue.
int sum = left->freq + right->freq;
pq.push(getNode('', sum, left, right));
}
// root stores pointer to root of Huffman Tree
Node* root = pq.top();
// traverse the Huffman Tree and store Huffman Codes
// in a map. Also prints them
unordered_map<char, string> huffmanCode;
encode(root, "", huffmanCode);
cout << "Huffman Codes are :n" << 'n';
for (auto pair: huffmanCode) {
cout << pair.first << " " << pair.second << 'n';
}
cout << "nOriginal string was :n" << text << 'n';
// print encoded string
string str = "";
for (char ch: text) {
str += huffmanCode[ch];
}
cout << "nEncoded string is :n" << str << 'n';
// traverse the Huffman Tree again and this time
// decode the encoded string
int index = -1;
cout << "nDecoded string is: n";
while (index < (int)str.size() - 2) {
decode(root, index, str);
}
}
// Huffman coding algorithm
int main()
{
string text = "Huffman coding is a data compression algorithm.";
buildHuffmanTree(text);
return 0;
}import java.util.HashMap;
import java.util.Map;
import java.util.PriorityQueue;
// A Tree node
class Node
{
char ch;
int freq;
Node left = null, right = null;
Node(char ch, int freq)
{
this.ch = ch;
this.freq = freq;
}
public Node(char ch, int freq, Node left, Node right) {
this.ch = ch;
this.freq = freq;
this.left = left;
this.right = right;
}
};
class Huffman
{
// traverse the Huffman Tree and store Huffman Codes
// in a map.
public static void encode(Node root, String str,
Map<Character, String> huffmanCode)
{
if (root == null)
return;
// found a leaf node
if (root.left == null && root.right == null) {
huffmanCode.put(root.ch, str);
}
encode(root.left, str + "0", huffmanCode);
encode(root.right, str + "1", huffmanCode);
}
// traverse the Huffman Tree and decode the encoded string
public static int decode(Node root, int index, StringBuilder sb)
{
if (root == null)
return index;
// found a leaf node
if (root.left == null && root.right == null)
{
System.out.print(root.ch);
return index;
}
index++;
if (sb.charAt(index) == '0')
index = decode(root.left, index, sb);
else
index = decode(root.right, index, sb);
return index;
}
// Builds Huffman Tree and huffmanCode and decode given input text
public static void buildHuffmanTree(String text)
{
// count frequency of appearance of each character
// and store it in a map
Map<Character, Integer> freq = new HashMap<>();
for (int i = 0 ; i < text.length(); i++) {
if (!freq.containsKey(text.charAt(i))) {
freq.put(text.charAt(i), 0);
}
freq.put(text.charAt(i), freq.get(text.charAt(i)) + 1);
}
// Create a priority queue to store live nodes of Huffman tree
// Notice that highest priority item has lowest frequency
PriorityQueue<Node> pq = new PriorityQueue<>(
(l, r) -> l.freq - r.freq);
// Create a leaf node for each character and add it
// to the priority queue.
for (Map.Entry<Character, Integer> entry : freq.entrySet()) {
pq.add(new Node(entry.getKey(), entry.getValue()));
}
// do till there is more than one node in the queue
while (pq.size() != 1)
{
// Remove the two nodes of highest priority
// (lowest frequency) from the queue
Node left = pq.poll();
Node right = pq.poll();
// Create a new internal node with these two nodes as children
// and with frequency equal to the sum of the two nodes
// frequencies. Add the new node to the priority queue.
int sum = left.freq + right.freq;
pq.add(new Node('', sum, left, right));
}
// root stores pointer to root of Huffman Tree
Node root = pq.peek();
// traverse the Huffman tree and store the Huffman codes in a map
Map<Character, String> huffmanCode = new HashMap<>();
encode(root, "", huffmanCode);
// print the Huffman codes
System.out.println("Huffman Codes are :n");
for (Map.Entry<Character, String> entry : huffmanCode.entrySet()) {
System.out.println(entry.getKey() + " " + entry.getValue());
}
System.out.println("nOriginal string was :n" + text);
// print encoded string
StringBuilder sb = new StringBuilder();
for (int i = 0 ; i < text.length(); i++) {
sb.append(huffmanCode.get(text.charAt(i)));
}
System.out.println("nEncoded string is :n" + sb);
// traverse the Huffman Tree again and this time
// decode the encoded string
int index = -1;
System.out.println("nDecoded string is: n");
while (index < sb.length() - 2) {
index = decode(root, index, sb);
}
}
public static void main(String[] args)
{
String text = "Huffman coding is a data compression algorithm.";
buildHuffmanTree(text);
}
}เจจเฉเจ: เจเจจเจชเฉเจ เจธเจเฉเจฐเจฟเฉฐเจ เจฆเฉเจเจฐเจพ เจตเจฐเจคเฉ เจเจ เจฎเฉเจฎเฉเจฐเฉ 47 * 8 = 376 เจฌเจฟเฉฑเจ เจนเฉ เจ เจคเฉ เจเจจเจเฉเจก เจเฉเจคเฉ เจธเจเฉเจฐเจฟเฉฐเจ เจธเจฟเจฐเจซ 194 เจฌเจฟเฉฑเจ เจนเฉ เจฏเจพเจจเฉ. เจกเฉเจเจพ เจจเฉเฉฐ เจฒเจเจญเจ 48% เจฆเฉเจเจฐเจพ เจธเฉฐเจเฉเจเจฟเจค เจเฉเจคเจพ เจเจฟเจ เจนเฉเฅค เจเฉฑเจชเจฐ เจฆเจฟเฉฑเจคเฉ C++ เจชเฉเจฐเฉเจเจฐเจพเจฎ เจตเจฟเฉฑเจ, เจ เจธเฉเจ เจชเฉเจฐเฉเจเจฐเจพเจฎ เจจเฉเฉฐ เจชเฉเฉเจนเจจเจฏเฉเจ เจฌเจฃเจพเจเจฃ เจฒเจ เจเจจเจเฉเจก เจเฉเจคเฉ เจธเจเฉเจฐเจฟเฉฐเจ เจจเฉเฉฐ เจธเจเฉเจฐ เจเจฐเจจ เจฒเจ เจธเจเฉเจฐเจฟเฉฐเจ เจเจฒเจพเจธ เจฆเฉ เจตเจฐเจคเฉเจ เจเจฐเจฆเฉ เจนเจพเจเฅค
เจเจฟเจเจเจเจฟ เจเฉเจธเจผเจฒ เจคเจฐเจเฉเจน เจเจคเจพเจฐ เจกเฉเจเจพ เจขเจพเจเจเฉ เจฒเจ เจชเฉเจฐเจคเฉ เจธเฉฐเจฎเจฟเจฒเจจ เจฆเฉ เจฒเฉเฉ เจนเฉเฉฐเจฆเฉ เจนเฉ O(เจฒเฉเจ(N)) เจธเจฎเจพเจ, เจชเจฐ เจจเจพเจฒ เจเฉฑเจ เจชเฉเจฐเฉ เจฌเจพเจเจจเจฐเฉ เจเฉเจฐเฉ เจตเจฟเฉฑเจ N เจชเฉฑเจคเฉ เจฎเฉเจเฉเจฆ เจนเจจ 2N-1 เจจเฉเจกเจธ, เจ เจคเฉ เจนเจซเจฎเฉเจจ เจเฉเจฐเฉ เจเฉฑเจ เจชเฉเจฐเจจ เจฌเจพเจเจจเจฐเฉ เจเฉเจฐเฉ เจนเฉ, เจซเจฟเจฐ เจเจฒเจเฉเจฐเจฟเจฆเจฎ เจเฉฑเจฒเจฆเจพ เจนเฉ O(Nlog(N)) เจธเจฎเจพเจ, เจเจฟเฉฑเจฅเฉ N - เจ เฉฑเจเจฐเฅค
เจธเจฐเฉเจค:
เจธเจฐเฉเจค: www.habr.com