15,347,523 members
See more:
Python
```import math
import sys
global probabilities
probabilities = []

class HuffmanCode:
def __init__(self,probability):
self.probability = probability

def position(self, value, index):
for j in range(len(self.probability)):
if(value >= self.probability[j]):
return j
return index-1

def characteristics_huffman_code(self, code):
length_of_code = [len(k) for k in code]

mean_length = sum([a*b for a, b in zip(length_of_code, self.probability)])

print("Average length of the code: %f" % mean_length)
print("Efficiency of the code: %f" % (entropy_of_code/mean_length))

def compute_code(self):
num = len(self.probability)
huffman_code = ['']*num

for i in range(num-2):
val = self.probability[num-i-1] + self.probability[num-i-2]
if(huffman_code[num-i-1] != '' and huffman_code[num-i-2] != ''):
huffman_code[-1] = ['1' + symbol for symbol in huffman_code[-1]]
huffman_code[-2] = ['0' + symbol for symbol in huffman_code[-2]]
elif(huffman_code[num-i-1] != ''):
huffman_code[num-i-2] = '0'
huffman_code[-1] = ['1' + symbol for symbol in huffman_code[-1]]
elif(huffman_code[num-i-2] != ''):
huffman_code[num-i-1] = '1'
huffman_code[-2] = ['0' + symbol for symbol in huffman_code[-2]]
else:
huffman_code[num-i-1] = '1'
huffman_code[num-i-2] = '0'

position = self.position(val, i)
probability = self.probability[0:(len(self.probability) - 2)]
probability.insert(position, val)
if(isinstance(huffman_code[num-i-2], list) and isinstance(huffman_code[num-i-1], list)):
complete_code = huffman_code[num-i-1] + huffman_code[num-i-2]
elif(isinstance(huffman_code[num-i-2], list)):
complete_code = huffman_code[num-i-2] + [huffman_code[num-i-1]]
elif(isinstance(huffman_code[num-i-1], list)):
complete_code = huffman_code[num-i-1] + [huffman_code[num-i-2]]
else:
complete_code = [huffman_code[num-i-2], huffman_code[num-i-1]]

huffman_code = huffman_code[0:(len(huffman_code)-2)]
huffman_code.insert(position, complete_code)

huffman_code[0] = ['0' + symbol for symbol in huffman_code[0]]
huffman_code[1] = ['1' + symbol for symbol in huffman_code[1]]

if(len(huffman_code[1]) == 0):
huffman_code[1] = '1'

count = 0
final_code = ['']*num

for i in range(2):
for j in range(len(huffman_code[i])):
final_code[count] = huffman_code[i][j]
count += 1

final_code = sorted(final_code, key=len)
return final_code

string = input("Enter the string to compute Huffman Code: ")

freq = {}
for c in string:
if c in freq:
freq[c] += 1
else:
freq[c] = 1

freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)
length = len(string)

probabilities = [float("{:.2f}".format(frequency[1]/length)) for frequency in freq]
probabilities = sorted(probabilities, reverse=True)

huffmanClassObject = HuffmanCode(probabilities)
P = probabilities

huffman_code = huffmanClassObject.compute_code()

print(' Char | Huffman code ')
print('----------------------')

for id,char in enumerate(freq):
if huffman_code[id]=='':
print(' %-4r |%12s' % (char[0], 1))
continue
print(' %-4r |%12s' % (char[0], huffman_code[id]))

huffmanClassObject.characteristics_huffman_code(huffman_code)```

What I have tried:

could anyone convert the code to a C++ code
Posted
Updated 19-Dec-20 11:31am
v2
Rick York 19-Dec-20 17:04pm

Yes.
CPallini 20-Dec-20 11:50am

Writing (a complete rewrite, not a blind translation of Python code) Huffman algorithm with C++ could be fun. Let's try it.

## Solution 1

Quote:
could anyone convert the code to a C++ code

Translating from Python to C++ is not just adapting code because of slight syntax differences, it is a complete rewrite because dynamic arrays are completely difference beast in both languages, one have to recreate features or rethink code to match features of C++, and it is real work.
CPallini 20-Dec-20 11:48am

5.
Patrice T 20-Dec-20 12:16pm

Thank you.

## Solution 2

This is not a code conversion service: we are not here to translate code for you.
Even if we did, what you would end up with would not be "good code" in the target language – they are based on very different frameworks, and what makes something work in one language does not always "translate" directly into another.
So what you end up with is very poor code, that is difficult if not impossible to maintain, that can’t be upgraded nicely, and that will cause you immense headaches if the original is changed. And it’ll be a nightmare to debug if it doesn’t work "straight out of the box".
Instead, use the source code as a specification for a new app written in and for the target language / framework and write it from scratch using the original as a "template". You will get a much, much better result that will save you a lot of time in the long run.
CPallini 20-Dec-20 11:48am

5.