เดเตเดดเตโเดธเต เดเดฐเดเดญเดฟเดเตเดเตเดจเตเดจเดคเดฟเดจเต เดฎเตเดฎเตเดชเต เดเดชเดฏเตเดเดชเตเดฐเดฆเดฎเดพเดฏ เดฎเดฑเตเดฑเตเดฐเต เดฎเตเดฑเตเดฑเตเดฐเดฟเดฏเดฒเดฟเดจเตเดฑเต เดตเดฟเดตเตผเดคเตเดคเดจเด เดจเดฟเดเตเดเตพเดเตเดเดพเดฏเดฟ เดคเดฏเตเดฏเดพเดฑเดพเดเตเดเดฟ.
เดซเดฏเตฝ เดเดเดชเตเดฐเดทเดจเตเดฑเต เด เดเดฟเดธเตเดฅเดพเดจ เดเดถเดฏเด เดฐเตเดชเดชเตเดชเตเดเตเดคเตเดคเตเดจเตเดจ เดเดฐเต เดกเดพเดฑเตเดฑ เดเดเดชเตเดฐเดทเตป เด เตฝเดเตเดฐเดฟเดคเด เดเดฃเต เดนเดซเตเดฎเดพเตป เดเตเดกเดฟเดเดเต. เด เดฒเตเดเดจเดคเตเดคเดฟเตฝ, เดซเดฟเดเตเดธเดกเต, เดตเตเดฐเดฟเดฏเดฌเดฟเตพ เดฒเตเดเตเดคเต เดเตปเดเตเดกเดฟเดเดเต, เด เดฆเตเดตเดฟเดคเตเดฏเดฎเดพเดฏเดฟ เดกเตเดเตเดกเต เดเตเดฏเตเดฏเดพเดตเตเดจเตเดจ เดเตเดกเตเดเตพ, เดชเตเดฐเดฟเดซเดฟเดเตเดธเต เดจเดฟเดฏเดฎเดเตเดเตพ, เดเดฐเต เดนเดซเตเดฎเดพเตป เดเตเดฐเต เดจเดฟเตผเดฎเตเดฎเดฟเดเตเดเตฝ เดเดจเตเดจเดฟเดตเดฏเตเดเตเดเตเดฑเดฟเดเตเดเต เดจเดฎเตเดฎเตพ เดธเดเดธเดพเดฐเดฟเดเตเดเตเด.
เดเดฐเต เดชเตเดฐเดคเตเดเดตเตเด 0 เดฏเตเดเตเดฏเตเด 1 เดจเตเดฑเตเดฏเตเด เดเดฐเต เดเตเดฐเดฎเดฎเดพเดฏเดฟ เดธเดเดญเดฐเดฟเดเตเดเตเดเดฏเตเด 8 เดฌเดฟเดฑเตเดฑเตเดเตพ เดเดเตเดเตเดเตเดเดฏเตเด เดเตเดฏเตเดฏเตเดจเตเดจเตเดตเตเดจเตเดจเต เดจเดฎเตเดเตเดเดฑเดฟเดฏเดพเด. เดเดฐเต เดชเตเดฐเดคเตเดเดตเตเด เดธเดเดญเดฐเดฟเดเตเดเดพเตป เดเดฐเต เดจเดฟเดถเตเดเดฟเดค เดเดฃเตเดฃเด เดฌเดฟเดฑเตเดฑเตเดเตพ เดเดชเดฏเตเดเดฟเดเตเดเตเดจเตเดจเดคเดฟเดจเดพเตฝ เดเดคเดฟเดจเต เดซเดฟเดเตเดธเดกเต เดฒเตเดเตเดคเต เดเตปเดเตเดกเดฟเดเดเต เดเดจเตเดจเต เดตเดฟเดณเดฟเดเตเดเตเดจเตเดจเต.
เดจเดฎเตเดเตเดเต เดตเดพเดเดเด เดจเตฝเดเดฟเดฏเตเดจเตเดจเต เดชเดฑเดฏเดพเด. เดเดฐเต เดชเตเดฐเดคเตเดเด เดธเดเดญเดฐเดฟเดเตเดเตเดจเตเดจเดคเดฟเดจเต เดเดตเดถเตเดฏเดฎเดพเดฏ เดธเตเดฅเดฒเดคเตเดคเดฟเดจเตเดฑเต เด เดณเดตเต เดเดเตเดเดจเต เดเตเดฑเดฏเตเดเตเดเดพเด?
เดตเตเดฐเดฟเดฏเดฌเดฟเตพ เดฒเตเดเตเดคเต เดเตปเดเตเดกเดฟเดเดเดพเดฃเต เดชเตเดฐเดงเดพเดจ เดเดถเดฏเด. เดตเดพเดเดเดคเตเดคเดฟเดฒเต เดเดฟเดฒ เดชเตเดฐเดคเตเดเดเตเดเตพ เดฎเดฑเตเดฑเตเดณเตเดณเดตเดฏเตเดเตเดเดพเตพ เดเตเดเตเดคเตฝ เดคเดตเดฃ เดธเดเดญเดตเดฟเดเตเดเตเดจเตเดจเต เดเดจเตเดจ เดตเดธเตเดคเตเดค เดจเดฎเตเดเตเดเต เดเดชเดฏเตเดเดฟเดเตเดเดพเด () เดเตเดฑเดเตเดเต เดฌเดฟเดฑเตเดฑเตเดเดณเดฟเตฝ เดชเตเดฐเดคเตเดเดเตเดเดณเตเดเต เด เดคเต เดถเตเดฐเตเดฃเดฟเดฏเต เดชเตเดฐเดคเดฟเดจเดฟเดงเตเดเดฐเดฟเดเตเดเตเดจเตเดจ เดเดฐเต เด เตฝเดเตเดฐเดฟเดคเด เดตเดฟเดเดธเดฟเดชเตเดชเดฟเดเตเดเตเดจเตเดจเดคเดฟเดจเต. เดตเตเดฐเดฟเดฏเดฌเดฟเตพ เดฒเตเดเตเดคเต เดเตปเดเตเดกเดฟเดเดเดฟเตฝ, เดจเตฝเดเดฟเดฏเดฟเดฐเดฟเดเตเดเตเดจเตเดจ เดตเดพเดเดเดคเตเดคเดฟเตฝ เดเดคเตเดฐ เดคเดตเดฃ เดชเตเดฐเดคเตเดฏเดเตเดทเดชเตเดชเตเดเตเดจเตเดจเต เดเดจเตเดจเดคเดฟเดจเต เดเดถเตเดฐเดฏเดฟเดเตเดเต เดเดเตเดเตพ เดชเตเดฐเดคเตเดเดเตเดเตพเดเตเดเต เดเดฐเต เดตเตเดฐเดฟเดฏเดฌเดฟเตพ เดเดฃเตเดฃเด เดฌเดฟเดฑเตเดฑเตเดเตพ เดจเตฝเดเตเดจเตเดจเต. เดเดคเตเดฏเดจเตเดคเดฟเดเดฎเดพเดฏเดฟ, เดเดฟเดฒ เดชเตเดฐเดคเตเดเดเตเดเตพ 1 เดฌเดฟเดฑเตเดฑเต เดตเดฐเต เดเดเตเดคเตเดคเตเดเตเดเดพเด, เดฎเดฑเตเดฑเตเดณเตเดณเดตเตผ 2 เดฌเดฟเดฑเตเดฑเตเดเดณเต 3 เด เดฒเตเดฒเตเดเตเดเดฟเตฝ เด เดคเดฟเตฝ เดเตเดเตเดคเดฒเต เดเดเตเดคเตเดคเตเดเตเดเดพเด. เดตเตเดฐเดฟเดฏเดฌเดฟเตพ เดฒเตเดเตเดคเต เดเตปเดเตเดกเดฟเดเดเดฟเดจเตเดฑเต เดชเตเดฐเดถเตเดจเด เดธเตเดเตเดตเตปเดธเดฟเดจเตเดฑเต เดคเตเดเตผเดจเตเดจเตเดณเตเดณ เดกเตเดเตเดกเดฟเดเดเต เดฎเดพเดคเตเดฐเดฎเดพเดฃเต.
เดเดเตเดเดจเตเดฏเดพเดฃเต, เดฌเดฟเดฑเตเดฑเตเดเดณเตเดเต เดเตเดฐเดฎเด เด เดฑเดฟเดฏเตเดจเตเดจเดคเต, เด เดคเต เด เดตเตเดฏเดเตเดคเดฎเดพเดฏเดฟ เดกเตเดเตเดกเต เดเตเดฏเตเดฏเตเดจเตเดจเดคเต?
เดฒเตเตป เดชเดฐเดฟเดเดฃเดฟเดเตเดเตเด "abacdab". เดเดคเดฟเดจเต 8 เดชเตเดฐเดคเตเดเดเตเดเดณเตเดฃเตเดเต, เดเดฐเต เดจเดฟเดถเตเดเดฟเดค เดฆเตเตผเดเตเดฏเด เดเตปเดเตเดกเต เดเตเดฏเตเดฏเตเดฎเตเดชเตเตพ, เด เดคเต เดธเดเดญเดฐเดฟเดเตเดเดพเตป 64 เดฌเดฟเดฑเตเดฑเตเดเตพ เดเดตเดถเตเดฏเดฎเดพเดฃเต. เดเดฟเดนเตเดจ เดเดตเตเดคเตเดคเดฟ เดเดจเตเดจเดคเต เดถเตเดฐเดฆเตเดงเดฟเดเตเดเตเด "เด", "เดฌเดฟ", "เดธเดฟ" ะธ "เดกเดฟ" เดฏเดฅเดพเดเตเดฐเดฎเด 4, 2, 1, 1 เดจเต เดคเตเดฒเตเดฏเดฎเดพเดฃเต. เดจเดฎเตเดเตเดเต เดธเดเตเดเตฝเดชเตเดชเดฟเดเตเดเดพเตป เดถเตเดฐเดฎเดฟเดเตเดเดพเด "abacdab" เดเตเดฑเดเตเดเต เดฌเดฟเดฑเตเดฑเตเดเตพ, เดเดจเตเดจ เดตเดธเตเดคเตเดค เดเดชเดฏเตเดเดฟเดเตเดเต "เดเต" เดเดจเตเดจเดคเดฟเดจเตเดเตเดเดพเตพ เดชเดคเดฟเดตเดพเดฏเดฟ เดธเดเดญเดตเดฟเดเตเดเตเดจเตเดจเต "เดฌเดฟ"เดเดชเตเดชเด "เดฌเดฟ" เดเดจเตเดจเดคเดฟเดจเตเดเตเดเดพเตพ เดชเดคเดฟเดตเดพเดฏเดฟ เดธเดเดญเดตเดฟเดเตเดเตเดจเตเดจเต "เดธเดฟ" ะธ "เดกเดฟ". เดจเดฎเตเดเตเดเต เดเตเดกเดฟเดเดเดฟเดฒเตเดเต เดเดฐเดเดญเดฟเดเตเดเดพเด "เดเต" 0 เดจเต เดคเตเดฒเตเดฏเดฎเดพเดฏ เดเดฐเต เดฌเดฟเดฑเตเดฑเต เดเดชเดฏเตเดเดฟเดเตเดเต, "เดฌเดฟ" เดเดเตเดเตพ เดฐเดฃเตเดเต-เดฌเดฟเดฑเตเดฑเต เดเตเดกเต 11 เดจเตฝเดเตเด, เดเตเดเดพเดคเต เดฎเตเดจเตเดจเต เดฌเดฟเดฑเตเดฑเตเดเตพ 100, 011 เดเดจเตเดจเดฟเดต เดเดชเดฏเตเดเดฟเดเตเดเต เดเดเตเดเตพ เดเตปเดเตเดกเต เดเตเดฏเตเดฏเตเด "เดธเดฟ" ะธ "เดกเดฟ".
เดซเดฒเดฎเดพเดฏเดฟ, เดจเดฎเตเดเตเดเต เดฒเดญเดฟเดเตเดเตเด:
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