{"id":4240,"date":"2023-04-19T09:16:39","date_gmt":"2023-04-19T12:16:39","guid":{"rendered":"https:\/\/elemarjr.com\/clube-de-estudos\/?p=4240"},"modified":"2023-10-21T21:39:28","modified_gmt":"2023-10-22T00:39:28","slug":"aprendendo-sobre-codificacao-de-huffman-como-comprimir-dados-de-forma-eficiente","status":"publish","type":"artigos","link":"https:\/\/elemarjr.com\/clube-de-estudos\/artigos\/aprendendo-sobre-codificacao-de-huffman-como-comprimir-dados-de-forma-eficiente\/","title":{"rendered":"Aprendendo sobre codifica\u00e7\u00e3o de Huffman: Como comprimir dados de forma eficiente"},"content":{"rendered":"\n

A codifica\u00e7\u00e3o de Huffman \u00e9 um algoritmo cl\u00e1ssico para compress\u00e3o de dados, amplamente utilizado em diversas aplica\u00e7\u00f5es que envolvem a transmiss\u00e3o de informa\u00e7\u00f5es. Neste artigo, vamos entender como esse algoritmo funciona e como podemos implement\u00e1-lo de maneira eficiente. Al\u00e9m disso, vamos discutir insights <\/em>importantes que podemos obter a partir da sua implementa\u00e7\u00e3o, que podem nos ajudar a criar c\u00f3digos melhores no dia a dia.<\/p>\n\n\n\n

O que \u00e9 codifica\u00e7\u00e3o de Huffman?<\/h2>\n\n\n\n

A codifica\u00e7\u00e3o de Huffman \u00e9 um m\u00e9todo para codificar dados de maneira eficiente, reduzindo o n\u00famero de bits necess\u00e1rios para represent\u00e1-los. Esse m\u00e9todo \u00e9 baseado na frequ\u00eancia de ocorr\u00eancia de cada caractere no conjunto de dados que queremos codificar. Caracteres que aparecem com mais frequ\u00eancia s\u00e3o codificados com menos bits<\/em>, enquanto que caracteres menos frequentes s\u00e3o codificados com mais bits<\/em>.<\/p>\n\n\n\n

Como implementar o algoritmo de Huffman?<\/h2>\n\n\n\n

A implementa\u00e7\u00e3o do algoritmo de Huffman envolve a cria\u00e7\u00e3o de uma \u00e1rvore bin\u00e1ria, que representa a estrutura de codifica\u00e7\u00e3o dos dados. Para criar essa \u00e1rvore, precisamos seguir os seguintes passos:<\/p>\n\n\n\n

    \n
  1. Calcular a frequ\u00eancia de ocorr\u00eancia de cada caractere no conjunto de dados que queremos codificar.<\/li>\n\n\n\n
  2. Ordenar os caracteres em ordem crescente de frequ\u00eancia.<\/li>\n\n\n\n
  3. Agrupar os dois caracteres com menor frequ\u00eancia e criar um novo n\u00f3 na \u00e1rvore bin\u00e1ria, que representa a soma dessas frequ\u00eancias.<\/li>\n\n\n\n
  4. Repetir o passo 3 at\u00e9 que todos os caracteres estejam agrupados em um \u00fanico n\u00f3 na \u00e1rvore.<\/li>\n\n\n\n
  5. Atribuir um c\u00f3digo bin\u00e1rio para cada caractere na \u00e1rvore, caminhando da raiz at\u00e9 o n\u00f3 que representa o caractere desejado. Um caminho \u00e0 esquerda \u00e9 codificado como 0 e um caminho \u00e0 direita \u00e9 codificado como 1.<\/li>\n\n\n\n
  6. Codificar os dados, substituindo cada caractere pelo seu respectivo c\u00f3digo bin\u00e1rio na \u00e1rvore.<\/li>\n<\/ol>\n\n\n\n

    Por que usar uma \u00e1rvore bin\u00e1ria na implementa\u00e7\u00e3o?<\/h2>\n\n\n\n

    A \u00e1rvore bin\u00e1ria \u00e9 uma estrutura de dados eficiente para representar a estrutura de codifica\u00e7\u00e3o de Huffman, pois permite uma busca r\u00e1pida e eficiente pelo c\u00f3digo bin\u00e1rio de cada caractere. Al\u00e9m disso, a \u00e1rvore bin\u00e1ria pode ser facilmente percorrida de forma recursiva, o que simplifica a implementa\u00e7\u00e3o do algoritmo.<\/p>\n\n\n\n

    A import\u00e2ncia da recursividade na implementa\u00e7\u00e3o do algoritmo de Huffman<\/h2>\n\n\n\n

    A recursividade \u00e9 uma t\u00e9cnica importante na implementa\u00e7\u00e3o do algoritmo de Huffman, pois permite percorrer a \u00e1rvore bin\u00e1ria de forma simples e eficiente. Atrav\u00e9s de uma fun\u00e7\u00e3o recursiva, podemos percorrer todos os n\u00f3s da \u00e1rvore, atribuindo um c\u00f3digo bin\u00e1rio para cada caractere.<\/p>\n\n\n\n

    Exemplo de implementa\u00e7\u00e3o em C#<\/h3>\n\n\n\n

    Segue abaixo uma vers\u00e3o do c\u00f3digo em C# que implementa a codifica\u00e7\u00e3o de Huffman:<\/p>\n\n\n\n

    C#<\/span><\/path><\/path><\/svg><\/span>
    using<\/span> System<\/span>;<\/span><\/span>\nusing<\/span> System.Collections.Generic<\/span>;<\/span><\/span>\nusing<\/span> System.Linq<\/span>;<\/span><\/span>\n<\/span>\nnamespace<\/span> HuffmanCoding<\/span><\/span>\n{<\/span><\/span>\n    <\/span>class<\/span> <\/span>Node<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>public<\/span> <\/span>char<\/span> Symbol <\/span>{<\/span> <\/span>get;<\/span> <\/span>set;<\/span> <\/span>}<\/span><\/span>\n        <\/span>public<\/span> <\/span>int<\/span> Frequency <\/span>{<\/span> <\/span>get;<\/span> <\/span>set;<\/span> <\/span>}<\/span><\/span>\n        <\/span>public<\/span> Node Left <\/span>{<\/span> <\/span>get;<\/span> <\/span>set;<\/span> <\/span>}<\/span><\/span>\n        <\/span>public<\/span> Node Right <\/span>{<\/span> <\/span>get;<\/span> <\/span>set;<\/span> <\/span>}<\/span><\/span>\n<\/span>\n        <\/span>public<\/span> <\/span>Node<\/span>(<\/span>char<\/span> symbol<\/span>,<\/span> <\/span>int<\/span> frequency<\/span>)<\/span><\/span>\n        <\/span>{<\/span><\/span>\n            <\/span>Symbol<\/span> <\/span>=<\/span> <\/span>symbol<\/span>;<\/span><\/span>\n            <\/span>Frequency<\/span> <\/span>=<\/span> <\/span>frequency<\/span>;<\/span><\/span>\n        <\/span>}<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/span>\n    <\/span>class<\/span> <\/span>HuffmanCoding<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>static<\/span> <\/span>void<\/span> <\/span>Main<\/span>(<\/span>string<\/span>[]<\/span> args<\/span>)<\/span><\/span>\n        <\/span>{<\/span><\/span>\n            <\/span>string<\/span> input <\/span>=<\/span> <\/span>"<\/span>example input string<\/span>"<\/span>;<\/span><\/span>\n            Dictionary<\/span><<\/span>char<\/span>,<\/span> <\/span>int<\/span>><\/span> frequencyTable <\/span>=<\/span> <\/span>BuildFrequencyTable<\/span>(<\/span>input<\/span>)<\/span>;<\/span><\/span>\n            Node root <\/span>=<\/span> <\/span>BuildHuffmanTree<\/span>(<\/span>frequencyTable<\/span>)<\/span>;<\/span><\/span>\n            Dictionary<\/span><<\/span>char<\/span>,<\/span> <\/span>string<\/span>><\/span> codeTable <\/span>=<\/span> <\/span>BuildCodeTable<\/span>(<\/span>root<\/span>)<\/span>;<\/span><\/span>\n            <\/span>string<\/span> encoded <\/span>=<\/span> <\/span>Encode<\/span>(<\/span>input<\/span>,<\/span> <\/span>codeTable<\/span>)<\/span>;<\/span><\/span>\n            <\/span>Console<\/span>.<\/span>WriteLine<\/span>(<\/span>"<\/span>Encoded string: <\/span>"<\/span> <\/span>+<\/span> <\/span>encoded<\/span>)<\/span>;<\/span><\/span>\n        <\/span>}<\/span><\/span>\n<\/span>\n        <\/span>static<\/span> Dictionary<\/span><<\/span>char<\/span>,<\/span> <\/span>int<\/span>><\/span> <\/span>BuildFrequencyTable<\/span>(<\/span>string<\/span> input<\/span>)<\/span><\/span>\n        <\/span>{<\/span><\/span>\n            Dictionary<\/span><<\/span>char<\/span>,<\/span> <\/span>int<\/span>><\/span> frequencyTable <\/span>=<\/span> <\/span>new<\/span> Dictionary<\/span><<\/span>char<\/span>,<\/span> <\/span>int<\/span>>()<\/span>;<\/span><\/span>\n            <\/span>foreach<\/span> <\/span>(<\/span>char<\/span> c <\/span>in<\/span> <\/span>input<\/span>)<\/span><\/span>\n            <\/span>{<\/span><\/span>\n                <\/span>if<\/span> <\/span>(<\/span>frequencyTable<\/span>.<\/span>ContainsKey<\/span>(<\/span>c<\/span>))<\/span><\/span>\n                <\/span>{<\/span><\/span>\n                    <\/span>frequencyTable<\/span>[<\/span>c<\/span>]<\/span>++;<\/span><\/span>\n                <\/span>}<\/span><\/span>\n                <\/span>else<\/span><\/span>\n                <\/span>{<\/span><\/span>\n                    <\/span>frequencyTable<\/span>[<\/span>c<\/span>]<\/span> <\/span>=<\/span> <\/span>1<\/span>;<\/span><\/span>\n                <\/span>}<\/span><\/span>\n            <\/span>}<\/span><\/span>\n            <\/span>return<\/span> <\/span>frequencyTable<\/span>;<\/span><\/span>\n        <\/span>}<\/span><\/span>\n<\/span>\n        <\/span>static<\/span> Node <\/span>BuildHuffmanTree<\/span>(<\/span>Dictionary<\/span><<\/span>char<\/span>,<\/span> <\/span>int<\/span>><\/span> frequencyTable<\/span>)<\/span><\/span>\n        <\/span>{<\/span><\/span>\n            List<\/span><<\/span>Node<\/span>><\/span> nodes <\/span>=<\/span> <\/span>new<\/span> List<\/span><<\/span>Node<\/span>>()<\/span>;<\/span><\/span>\n            <\/span>foreach<\/span> <\/span>(<\/span>KeyValuePair<\/span><<\/span>char<\/span>,<\/span> <\/span>int<\/span>><\/span> entry <\/span>in<\/span> <\/span>frequencyTable<\/span>)<\/span><\/span>\n            <\/span>{<\/span><\/span>\n                <\/span>nodes<\/span>.<\/span>Add<\/span>(<\/span>new<\/span> Node<\/span>(<\/span>entry<\/span>.<\/span>Key<\/span>,<\/span> <\/span>entry<\/span>.<\/span>Value<\/span>))<\/span>;<\/span><\/span>\n            <\/span>}<\/span><\/span>\n            <\/span>while<\/span> <\/span>(<\/span>nodes<\/span>.<\/span>Count<\/span> <\/span>><\/span> <\/span>1<\/span>)<\/span><\/span>\n            <\/span>{<\/span><\/span>\n                List<\/span><<\/span>Node<\/span>><\/span> orderedNodes <\/span>=<\/span> <\/span>nodes<\/span>.<\/span>OrderBy<\/span>(<\/span>node <\/span>=><\/span> <\/span>node<\/span>.<\/span>Frequency<\/span>).<\/span>ToList<\/span>()<\/span>;<\/span><\/span>\n                <\/span>if<\/span> <\/span>(<\/span>orderedNodes<\/span>.<\/span>Count<\/span> <\/span>>=<\/span> <\/span>2<\/span>)<\/span><\/span>\n                <\/span>{<\/span><\/span>\n                    List<\/span><<\/span>Node<\/span>><\/span> taken <\/span>=<\/span> <\/span>orderedNodes<\/span>.<\/span>Take<\/span>(<\/span>2<\/span>).<\/span>ToList<\/span>()<\/span>;<\/span><\/span>\n                    Node parent <\/span>=<\/span> <\/span>new<\/span> Node<\/span>(<\/span>'<\/span>*<\/span>'<\/span>,<\/span> <\/span>taken<\/span>[<\/span>0<\/span>].<\/span>Frequency<\/span> <\/span>+<\/span> <\/span>taken<\/span>[<\/span>1<\/span>].<\/span>Frequency<\/span>)<\/span>;<\/span><\/span>\n                    <\/span>parent<\/span>.<\/span>Left<\/span> <\/span>=<\/span> <\/span>taken<\/span>[<\/span>0<\/span>]<\/span>;<\/span><\/span>\n                    <\/span>parent<\/span>.<\/span>Right<\/span> <\/span>=<\/span> <\/span>taken<\/span>[<\/span>1<\/span>]<\/span>;<\/span><\/span>\n                    <\/span>nodes<\/span>.<\/span>Remove<\/span>(<\/span>taken<\/span>[<\/span>0<\/span>])<\/span>;<\/span><\/span>\n                    <\/span>nodes<\/span>.<\/span>Remove<\/span>(<\/span>taken<\/span>[<\/span>1<\/span>])<\/span>;<\/span><\/span>\n                    <\/span>nodes<\/span>.<\/span>Add<\/span>(<\/span>parent<\/span>)<\/span>;<\/span><\/span>\n                <\/span>}<\/span><\/span>\n            <\/span>}<\/span><\/span>\n            <\/span>return<\/span> <\/span>nodes<\/span>.<\/span>FirstOrDefault<\/span>()<\/span>;<\/span><\/span>\n        <\/span>}<\/span><\/span>\n<\/span>\n        <\/span>static<\/span> Dictionary<\/span><<\/span>char<\/span>,<\/span> <\/span>string<\/span>><\/span> <\/span>BuildCodeTable<\/span>(<\/span>Node root<\/span>)<\/span><\/span>\n        <\/span>{<\/span><\/span>\n            Dictionary<\/span><<\/span>char<\/span>,<\/span> <\/span>string<\/span>><\/span> codeTable <\/span>=<\/span> <\/span>new<\/span> Dictionary<\/span><<\/span>char<\/span>,<\/span> <\/span>string<\/span>>()<\/span>;<\/span><\/span>\n            <\/span>TraverseTree<\/span>(<\/span>root<\/span>,<\/span> <\/span>""<\/span>,<\/span> <\/span>codeTable<\/span>)<\/span>;<\/span><\/span>\n            <\/span>return<\/span> <\/span>codeTable<\/span>;<\/span><\/span>\n        <\/span>}<\/span><\/span>\n<\/span>\n        <\/span>static<\/span> <\/span>void<\/span> <\/span>TraverseTree<\/span>(<\/span>Node node<\/span>,<\/span> <\/span>string<\/span> code<\/span>,<\/span> Dictionary<\/span><<\/span>char<\/span>,<\/span> <\/span>string<\/span>><\/span> codeTable<\/span>)<\/span><\/span>\n        <\/span>{<\/span><\/span>\n            <\/span>if<\/span> <\/span>(<\/span>node<\/span> <\/span>==<\/span> <\/span>null<\/span>)<\/span><\/span>\n            <\/span>{<\/span><\/span>\n                <\/span>return;<\/span><\/span>\n            <\/span>}<\/span><\/span>\n            <\/span>if<\/span> <\/span>(<\/span>node<\/span>.<\/span>Symbol<\/span> <\/span>!=<\/span> <\/span>'<\/span>*<\/span>'<\/span>)<\/span><\/span>\n            <\/span>{<\/span><\/span>\n                <\/span>codeTable<\/span>[<\/span>node<\/span>.<\/span>Symbol<\/span>]<\/span> <\/span>=<\/span> <\/span>code<\/span>;<\/span><\/span>\n            <\/span>}<\/span><\/span>\n            <\/span>TraverseTree<\/span>(<\/span>node<\/span>.<\/span>Left<\/span>,<\/span> <\/span>code<\/span> <\/span>+<\/span> <\/span>"<\/span>0<\/span>"<\/span>,<\/span> <\/span>codeTable<\/span>)<\/span>;<\/span><\/span>\n            <\/span>TraverseTree<\/span>(<\/span>node<\/span>.<\/span>Right<\/span>,<\/span> <\/span>code<\/span> <\/span>+<\/span> <\/span>"<\/span>1<\/span>"<\/span>,<\/span> <\/span>codeTable<\/span>)<\/span>;<\/span><\/span>\n        <\/span>}<\/span><\/span>\n<\/span>\n        <\/span>static<\/span> <\/span>string<\/span> <\/span>Encode<\/span>(<\/span>string<\/span> input<\/span>,<\/span> Dictionary<\/span><<\/span>char<\/span>,<\/span> <\/span>string<\/span>><\/span> codeTable<\/span>)<\/span><\/span>\n        <\/span>{<\/span><\/span>\n            <\/span>string<\/span> encoded <\/span>=<\/span> <\/span>""<\/span>;<\/span><\/span>\n            <\/span>foreach<\/span> <\/span>(<\/span>char<\/span> c <\/span>in<\/span> <\/span>input<\/span>)<\/span><\/span>\n            <\/span>{<\/span><\/span>\n                <\/span>encoded<\/span> <\/span>+=<\/span> <\/span>codeTable<\/span>[<\/span>c<\/span>]<\/span>;<\/span><\/span>\n            <\/span>}<\/span><\/span>\n            <\/span>return<\/span> <\/span>encoded<\/span>;<\/span><\/span>\n        <\/span>}<\/span><\/span>\n    <\/span>}<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Fonte: Chat GPT<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    O c\u00f3digo acima come\u00e7a por importar as bibliotecas necess\u00e1rias e definir duas classes: Node<\/code>, que representa um n\u00f3 na \u00e1rvore de Huffman, e HuffmanCoding<\/code>, que cont\u00e9m o m\u00e9todo Main<\/code> e os demais m\u00e9todos necess\u00e1rios para implementar a codifica\u00e7\u00e3o de Huffman.<\/p>\n\n\n\n
    O m\u00e9todo Main<\/code> \u00e9 respons\u00e1vel por chamar os demais m\u00e9todos e executar a codifica\u00e7\u00e3o de Huffman em uma string de exemplo. Primeiramente, ele chama o m\u00e9todo BuildFrequencyTable<\/code>, que recebe uma string e retorna um dicion\u00e1rio contendo a frequ\u00eancia de ocorr\u00eancia de cada caractere na string. <\/p>\n\n\n\n
    Em seguida, ele chama o m\u00e9todo BuildHuffmanTree<\/code>, que recebe esse dicion\u00e1rio e retorna a raiz da \u00e1rvore de Huffman. Depois, ele chama o m\u00e9todo BuildCodeTable<\/code>, que recebe a raiz da \u00e1rvore e retorna um dicion\u00e1rio que associa cada caractere a seu c\u00f3digo bin\u00e1rio na \u00e1rvore. Por fim, ele chama o m\u00e9todo Encode<\/code>, que recebe a string de exemplo e o dicion\u00e1rio de c\u00f3digos, e retorna a string codificada.<\/p>\n\n\n\n
    O m\u00e9todo BuildHuffmanTree<\/code> come\u00e7a por criar uma lista de n\u00f3s, onde cada n\u00f3 representa um caractere e sua frequ\u00eancia de ocorr\u00eancia na string. Em seguida, ele faz um loop at\u00e9 que reste apenas um n\u00f3 na lista. Em cada itera\u00e7\u00e3o do loop, ele ordena a lista pelos valores de frequ\u00eancia dos n\u00f3s e cria um novo n\u00f3 que representa a soma das frequ\u00eancias dos dois n\u00f3s com menor frequ\u00eancia. <\/p>\n\n\n\n
    Esse novo n\u00f3 \u00e9 adicionado \u00e0 lista e os dois n\u00f3s antigos s\u00e3o removidos. O m\u00e9todo retorna a raiz da \u00e1rvore, que ser\u00e1 o \u00faltimo n\u00f3 restante na lista.<\/p>\n\n\n\n
    O m\u00e9todo BuildCodeTable<\/code> \u00e9 recursivo e percorre a \u00e1rvore de Huffman para criar o dicion\u00e1rio de c\u00f3digos. Ele come\u00e7a na raiz da \u00e1rvore e, para cada n\u00f3, adiciona o c\u00f3digo “0” se o n\u00f3 estiver \u00e0 esquerda da raiz e “1” se estiver \u00e0 direita. Quando chega a um n\u00f3 folha (que representa um caractere), ele adiciona o c\u00f3digo completo ao dicion\u00e1rio.<\/p>\n\n\n\n
    O m\u00e9todo Encode<\/code> simplesmente percorre a string de entrada caractere por caractere e adiciona o c\u00f3digo correspondente a cada caractere ao resultado codificado.<\/p>\n\n\n\n
    Esse \u00e9 apenas um exemplo simples de implementa\u00e7\u00e3o da codifica\u00e7\u00e3o de Huffman em C#. H\u00e1 muitas varia\u00e7\u00f5es e otimiza\u00e7\u00f5es poss\u00edveis, dependendo do contexto e dos requisitos de performance e efici\u00eancia.<\/p>\n\n\n\n
    Exemplo de implementa\u00e7\u00e3o em Java<\/h3>\n\n\n\n
    Segue abaixo uma vers\u00e3o do c\u00f3digo em Java equivalente ao exemplo em C# que implementa a codifica\u00e7\u00e3o de Huffman:<\/p>\n\n\n\n
    Java<\/span><\/path><\/path><\/svg><\/span>
    import<\/span> <\/span>java<\/span>.<\/span>util<\/span>.<\/span>*;<\/span><\/span>\n<\/span>\npublic<\/span> <\/span>class<\/span> <\/span>HuffmanCoding<\/span> <\/span>{<\/span><\/span>\n    <\/span>static<\/span> <\/span>class<\/span> <\/span>Node<\/span> <\/span>{<\/span><\/span>\n        <\/span>public<\/span> <\/span>char<\/span> <\/span>symbol<\/span>;<\/span><\/span>\n        <\/span>public<\/span> <\/span>int<\/span> <\/span>frequency<\/span>;<\/span><\/span>\n        <\/span>public<\/span> <\/span>Node<\/span> <\/span>left<\/span>;<\/span><\/span>\n        <\/span>public<\/span> <\/span>Node<\/span> <\/span>right<\/span>;<\/span><\/span>\n<\/span>\n        <\/span>public<\/span> <\/span>Node<\/span>(<\/span>char<\/span> <\/span>symbol<\/span>,<\/span> <\/span>int<\/span> <\/span>frequency<\/span>)<\/span> <\/span>{<\/span><\/span>\n            <\/span>this<\/span>.<\/span>symbol<\/span> <\/span>=<\/span> symbol<\/span>;<\/span><\/span>\n            <\/span>this<\/span>.<\/span>frequency<\/span> <\/span>=<\/span> frequency<\/span>;<\/span><\/span>\n        <\/span>}<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> <\/span>static<\/span> <\/span>void<\/span> <\/span>main<\/span>(<\/span>String<\/span>[]<\/span> <\/span>args<\/span>)<\/span> <\/span>{<\/span><\/span>\n        <\/span>String<\/span> <\/span>input<\/span> <\/span>=<\/span> <\/span>"<\/span>example input string<\/span>"<\/span>;<\/span><\/span>\n        <\/span>Map<\/span><<\/span>Character<\/span>,<\/span> <\/span>Integer<\/span>><\/span> <\/span>frequencyTable<\/span> <\/span>=<\/span> <\/span>buildFrequencyTable<\/span>(<\/span>input<\/span>)<\/span>;<\/span><\/span>\n        <\/span>Node<\/span> <\/span>root<\/span> <\/span>=<\/span> <\/span>buildHuffmanTree<\/span>(<\/span>frequencyTable<\/span>)<\/span>;<\/span><\/span>\n        <\/span>Map<\/span><<\/span>Character<\/span>,<\/span> <\/span>String<\/span>><\/span> <\/span>codeTable<\/span> <\/span>=<\/span> <\/span>buildCodeTable<\/span>(<\/span>root<\/span>)<\/span>;<\/span><\/span>\n        <\/span>String<\/span> <\/span>encoded<\/span> <\/span>=<\/span> <\/span>encode<\/span>(<\/span>input<\/span>,<\/span> codeTable<\/span>)<\/span>;<\/span><\/span>\n        <\/span>System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>"<\/span>Encoded string: <\/span>"<\/span> <\/span>+<\/span> encoded<\/span>)<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> <\/span>static<\/span> <\/span>Map<\/span><<\/span>Character<\/span>,<\/span> <\/span>Integer<\/span>><\/span> <\/span>buildFrequencyTable<\/span>(<\/span>String<\/span> <\/span>input<\/span>)<\/span> <\/span>{<\/span><\/span>\n        <\/span>Map<\/span><<\/span>Character<\/span>,<\/span> <\/span>Integer<\/span>><\/span> <\/span>frequencyTable<\/span> <\/span>=<\/span> <\/span>new<\/span> <\/span>HashMap<\/span><>()<\/span>;<\/span><\/span>\n        <\/span>for<\/span> <\/span>(<\/span>char<\/span> <\/span>c<\/span> <\/span>:<\/span> <\/span>input<\/span>.<\/span>toCharArray<\/span>())<\/span> <\/span>{<\/span><\/span>\n            <\/span>frequencyTable<\/span>.<\/span>put<\/span>(<\/span>c<\/span>,<\/span> <\/span>frequencyTable<\/span>.<\/span>getOrDefault<\/span>(<\/span>c<\/span>,<\/span> <\/span>0<\/span>)<\/span> <\/span>+<\/span> <\/span>1<\/span>)<\/span>;<\/span><\/span>\n        <\/span>}<\/span><\/span>\n        <\/span>return<\/span> frequencyTable<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> <\/span>static<\/span> <\/span>Node<\/span> <\/span>buildHuffmanTree<\/span>(<\/span>Map<\/span><<\/span>Character<\/span>,<\/span> <\/span>Integer<\/span>><\/span> <\/span>frequencyTable<\/span>)<\/span> <\/span>{<\/span><\/span>\n        <\/span>List<\/span><<\/span>Node<\/span>><\/span> <\/span>nodes<\/span> <\/span>=<\/span> <\/span>new<\/span> <\/span>ArrayList<\/span><>()<\/span>;<\/span><\/span>\n        <\/span>for<\/span> <\/span>(<\/span>Map<\/span>.<\/span>Entry<\/span><<\/span>Character<\/span>,<\/span> <\/span>Integer<\/span>><\/span> <\/span>entry<\/span> <\/span>:<\/span> <\/span>frequencyTable<\/span>.<\/span>entrySet<\/span>())<\/span> <\/span>{<\/span><\/span>\n            <\/span>nodes<\/span>.<\/span>add<\/span>(<\/span>new<\/span> <\/span>Node<\/span>(<\/span>entry<\/span>.<\/span>getKey<\/span>(),<\/span> <\/span>entry<\/span>.<\/span>getValue<\/span>()))<\/span>;<\/span><\/span>\n        <\/span>}<\/span><\/span>\n        <\/span>while<\/span> <\/span>(<\/span>nodes<\/span>.<\/span>size<\/span>()<\/span> <\/span>><\/span> <\/span>1<\/span>)<\/span> <\/span>{<\/span><\/span>\n            <\/span>Collections<\/span>.<\/span>sort<\/span>(<\/span>nodes<\/span>,<\/span> <\/span>Comparator<\/span>.<\/span>comparingInt<\/span>(<\/span>node <\/span>-><\/span> <\/span>node<\/span>.<\/span>frequency<\/span>))<\/span>;<\/span><\/span>\n            <\/span>List<\/span><<\/span>Node<\/span>><\/span> <\/span>taken<\/span> <\/span>=<\/span> <\/span>nodes<\/span>.<\/span>subList<\/span>(<\/span>0<\/span>,<\/span> <\/span>2<\/span>)<\/span>;<\/span><\/span>\n            <\/span>Node<\/span> <\/span>parent<\/span> <\/span>=<\/span> <\/span>new<\/span> <\/span>Node<\/span>(<\/span>'<\/span>*<\/span>'<\/span>,<\/span> <\/span>taken<\/span>.<\/span>get<\/span>(<\/span>0<\/span>).<\/span>frequency<\/span> <\/span>+<\/span> <\/span>taken<\/span>.<\/span>get<\/span>(<\/span>1<\/span>).<\/span>frequency<\/span>)<\/span>;<\/span><\/span>\n            <\/span>parent<\/span>.<\/span>left<\/span> <\/span>=<\/span> <\/span>taken<\/span>.<\/span>get<\/span>(<\/span>0<\/span>)<\/span>;<\/span><\/span>\n            <\/span>parent<\/span>.<\/span>right<\/span> <\/span>=<\/span> <\/span>taken<\/span>.<\/span>get<\/span>(<\/span>1<\/span>)<\/span>;<\/span><\/span>\n            <\/span>nodes<\/span>.<\/span>remove<\/span>(<\/span>taken<\/span>.<\/span>get<\/span>(<\/span>0<\/span>))<\/span>;<\/span><\/span>\n            <\/span>nodes<\/span>.<\/span>remove<\/span>(<\/span>taken<\/span>.<\/span>get<\/span>(<\/span>1<\/span>))<\/span>;<\/span><\/span>\n            <\/span>nodes<\/span>.<\/span>add<\/span>(<\/span>parent<\/span>)<\/span>;<\/span><\/span>\n        <\/span>}<\/span><\/span>\n        <\/span>return<\/span> <\/span>nodes<\/span>.<\/span>get<\/span>(<\/span>0<\/span>)<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> <\/span>static<\/span> <\/span>Map<\/span><<\/span>Character<\/span>,<\/span> <\/span>String<\/span>><\/span> <\/span>buildCodeTable<\/span>(<\/span>Node<\/span> <\/span>root<\/span>)<\/span> <\/span>{<\/span><\/span>\n        <\/span>Map<\/span><<\/span>Character<\/span>,<\/span> <\/span>String<\/span>><\/span> <\/span>codeTable<\/span> <\/span>=<\/span> <\/span>new<\/span> <\/span>HashMap<\/span><>()<\/span>;<\/span><\/span>\n        <\/span>traverseTree<\/span>(<\/span>root<\/span>,<\/span> <\/span>""<\/span>,<\/span> codeTable<\/span>)<\/span>;<\/span><\/span>\n        <\/span>return<\/span> codeTable<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> <\/span>static<\/span> <\/span>void<\/span> <\/span>traverseTree<\/span>(<\/span>Node<\/span> <\/span>node<\/span>,<\/span> <\/span>String<\/span> <\/span>code<\/span>,<\/span> <\/span>Map<\/span><<\/span>Character<\/span>,<\/span> <\/span>String<\/span>><\/span> <\/span>codeTable<\/span>)<\/span> <\/span>{<\/span><\/span>\n        <\/span>if<\/span> <\/span>(<\/span>node <\/span>==<\/span> <\/span>null<\/span>)<\/span> <\/span>{<\/span><\/span>\n            <\/span>return;<\/span><\/span>\n        <\/span>}<\/span><\/span>\n        <\/span>if<\/span> <\/span>(<\/span>node<\/span>.<\/span>symbol<\/span> <\/span>!=<\/span> <\/span>'<\/span>*<\/span>'<\/span>)<\/span> <\/span>{<\/span><\/span>\n            <\/span>codeTable<\/span>.<\/span>put<\/span>(<\/span>node<\/span>.<\/span>symbol<\/span>,<\/span> code<\/span>)<\/span>;<\/span><\/span>\n        <\/span>}<\/span><\/span>\n        <\/span>traverseTree<\/span>(<\/span>node<\/span>.<\/span>left<\/span>,<\/span> code <\/span>+<\/span> <\/span>"<\/span>0<\/span>"<\/span>,<\/span> codeTable<\/span>)<\/span>;<\/span><\/span>\n        <\/span>traverseTree<\/span>(<\/span>node<\/span>.<\/span>right<\/span>,<\/span> code <\/span>+<\/span> <\/span>"<\/span>1<\/span>"<\/span>,<\/span> codeTable<\/span>)<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> <\/span>static<\/span> <\/span>String<\/span> <\/span>encode<\/span>(<\/span>String<\/span> <\/span>input<\/span>,<\/span> <\/span>Map<\/span><<\/span>Character<\/span>,<\/span> <\/span>String<\/span>><\/span> <\/span>codeTable<\/span>)<\/span> <\/span>{<\/span><\/span>\n        <\/span>StringBuilder<\/span> <\/span>encoded<\/span> <\/span>=<\/span> <\/span>new<\/span> <\/span>StringBuilder<\/span>()<\/span>;<\/span><\/span>\n        <\/span>for<\/span> <\/span>(<\/span>char<\/span> <\/span>c<\/span> <\/span>:<\/span> <\/span>input<\/span>.<\/span>toCharArray<\/span>())<\/span> <\/span>{<\/span><\/span>\n            <\/span>encoded<\/span>.<\/span>append<\/span>(<\/span>codeTable<\/span>.<\/span>get<\/span>(<\/span>c<\/span>))<\/span>;<\/span><\/span>\n        <\/span>}<\/span><\/span>\n        <\/span>return<\/span> <\/span>encoded<\/span>.<\/span>toString<\/span>()<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Fonte: Chat GPT<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    A estrutura geral do c\u00f3digo em Java \u00e9 a mesma do exemplo em C#: as classes Node<\/code> e HuffmanCoding<\/code> s\u00e3o definidas, assim como os m\u00e9todos para construir a tabela de frequ\u00eancias, a \u00e1rvore de Huffman, a tabela de c\u00f3digos e codificar uma string.<\/p>\n\n\n\n
    As principais diferen\u00e7as entre as duas vers\u00f5es do c\u00f3digo est\u00e3o nas diferen\u00e7as de sintaxe entre C# e Java. Por exemplo, em Java, as cole\u00e7\u00f5es s\u00e3o usadas atrav\u00e9s de interfaces como Map<\/code>, List<\/code> e Set<\/code>, que t\u00eam implementa\u00e7\u00f5es espec\u00edficas em classes como HashMap<\/code>, ArrayList<\/code> e HashSet<\/code>. Al\u00e9m disso, as express\u00f5es lambda e os m\u00e9todos de extens\u00e3o usados em C# n\u00e3o est\u00e3o dispon\u00edveis em Java, ent\u00e3o s\u00e3o usadas outras formas de express\u00e3o, como classes an\u00f4nimas e m\u00e9todos de compara\u00e7\u00e3o.<\/p>\n\n\n\n
    Outra diferen\u00e7a importante \u00e9 que em Java \u00e9 necess\u00e1rio usar o m\u00e9todo getOrDefault<\/code> para acessar o valor de uma chave em um mapa e increment\u00e1-lo caso j\u00e1 exista. Al\u00e9m disso, o m\u00e9todo subList<\/code> \u00e9 usado para obter uma sublista de uma lista em Java, enquanto em C# \u00e9 poss\u00edvel usar o m\u00e9todo Take<\/code>.<\/p>\n\n\n\n
    No geral, no entanto, a estrutura e a l\u00f3gica do c\u00f3digo s\u00e3o bastante semelhantes nas duas linguagens.<\/p>\n\n\n\n
    Exemplo de implementa\u00e7\u00e3o em Python<\/h3>\n\n\n\n
    Segue abaixo uma vers\u00e3o do c\u00f3digo em Python equivalente ao exemplo em C# que implementa a codifica\u00e7\u00e3o de Huffman:<\/p>\n\n\n\n
    Python<\/span><\/path><\/path><\/svg><\/span>
    class<\/span> <\/span>Node<\/span>:<\/span><\/span>\n    <\/span>def<\/span> <\/span>__init__<\/span>(<\/span>self<\/span>,<\/span> <\/span>symbol<\/span>,<\/span> <\/span>frequency<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.<\/span>symbol <\/span>=<\/span> symbol<\/span><\/span>\n        <\/span>self<\/span>.<\/span>frequency <\/span>=<\/span> frequency<\/span><\/span>\n        <\/span>self<\/span>.<\/span>left <\/span>=<\/span> <\/span>None<\/span><\/span>\n        <\/span>self<\/span>.<\/span>right <\/span>=<\/span> <\/span>None<\/span><\/span>\n<\/span>\ndef<\/span> <\/span>main<\/span>():<\/span><\/span>\n    input_str <\/span>=<\/span> <\/span>"<\/span>example input string<\/span>"<\/span><\/span>\n    frequency_table <\/span>=<\/span> <\/span>build_frequency_table<\/span>(<\/span>input_str<\/span>)<\/span><\/span>\n    root <\/span>=<\/span> <\/span>build_huffman_tree<\/span>(<\/span>frequency_table<\/span>)<\/span><\/span>\n    code_table <\/span>=<\/span> <\/span>build_code_table<\/span>(<\/span>root<\/span>)<\/span><\/span>\n    encoded <\/span>=<\/span> <\/span>encode<\/span>(<\/span>input_str<\/span>,<\/span> code_table<\/span>)<\/span><\/span>\n    <\/span>print<\/span>(<\/span>"<\/span>Encoded string:<\/span>"<\/span>,<\/span> encoded<\/span>)<\/span><\/span>\n<\/span>\ndef<\/span> <\/span>build_frequency_table<\/span>(<\/span>input_str<\/span>):<\/span><\/span>\n    frequency_table <\/span>=<\/span> <\/span>{}<\/span><\/span>\n    <\/span>for<\/span> c <\/span>in<\/span> input_str<\/span>:<\/span><\/span>\n        frequency_table<\/span>[<\/span>c<\/span>]<\/span> <\/span>=<\/span> frequency_table<\/span>.<\/span>get<\/span>(<\/span>c<\/span>,<\/span> <\/span>0<\/span>)<\/span> <\/span>+<\/span> <\/span>1<\/span><\/span>\n    <\/span>return<\/span> frequency_table<\/span><\/span>\n<\/span>\ndef<\/span> <\/span>build_huffman_tree<\/span>(<\/span>frequency_table<\/span>):<\/span><\/span>\n    nodes <\/span>=<\/span> <\/span>[<\/span>Node<\/span>(<\/span>symbol<\/span>,<\/span> frequency<\/span>)<\/span> <\/span>for<\/span> symbol<\/span>,<\/span> frequency <\/span>in<\/span> frequency_table<\/span>.<\/span>items<\/span>()]<\/span><\/span>\n    <\/span>while<\/span> <\/span>len<\/span>(<\/span>nodes<\/span>)<\/span> <\/span>><\/span> <\/span>1<\/span>:<\/span><\/span>\n        nodes<\/span>.<\/span>sort<\/span>(<\/span>key<\/span>=lambda<\/span> <\/span>x<\/span>:<\/span> x<\/span>.<\/span>frequency<\/span>)<\/span><\/span>\n        left_node<\/span>,<\/span> right_node <\/span>=<\/span> nodes<\/span>[<\/span>0<\/span>],<\/span> nodes<\/span>[<\/span>1<\/span>]<\/span><\/span>\n        parent_node <\/span>=<\/span> <\/span>Node<\/span>(<\/span>'<\/span>*<\/span>'<\/span>,<\/span> left_node<\/span>.<\/span>frequency <\/span>+<\/span> right_node<\/span>.<\/span>frequency<\/span>)<\/span><\/span>\n        parent_node<\/span>.<\/span>left <\/span>=<\/span> left_node<\/span><\/span>\n        parent_node<\/span>.<\/span>right <\/span>=<\/span> right_node<\/span><\/span>\n        nodes <\/span>=<\/span> nodes<\/span>[<\/span>2<\/span>:]<\/span><\/span>\n        nodes<\/span>.<\/span>append<\/span>(<\/span>parent_node<\/span>)<\/span><\/span>\n    <\/span>return<\/span> nodes<\/span>[<\/span>0<\/span>]<\/span><\/span>\n<\/span>\ndef<\/span> <\/span>build_code_table<\/span>(<\/span>root<\/span>):<\/span><\/span>\n    code_table <\/span>=<\/span> <\/span>{}<\/span><\/span>\n    <\/span>traverse_tree<\/span>(<\/span>root<\/span>,<\/span> <\/span>""<\/span>,<\/span> code_table<\/span>)<\/span><\/span>\n    <\/span>return<\/span> code_table<\/span><\/span>\n<\/span>\ndef<\/span> <\/span>traverse_tree<\/span>(<\/span>node<\/span>,<\/span> <\/span>code<\/span>,<\/span> <\/span>code_table<\/span>):<\/span><\/span>\n    <\/span>if<\/span> node <\/span>is<\/span> <\/span>None<\/span>:<\/span><\/span>\n        <\/span>return<\/span><\/span>\n    <\/span>if<\/span> node<\/span>.<\/span>symbol <\/span>!=<\/span> <\/span>'<\/span>*<\/span>'<\/span>:<\/span><\/span>\n        code_table<\/span>[<\/span>node<\/span>.<\/span>symbol<\/span>]<\/span> <\/span>=<\/span> code<\/span><\/span>\n    <\/span>traverse_tree<\/span>(<\/span>node<\/span>.<\/span>left<\/span>,<\/span> code <\/span>+<\/span> <\/span>"<\/span>0<\/span>"<\/span>,<\/span> code_table<\/span>)<\/span><\/span>\n    <\/span>traverse_tree<\/span>(<\/span>node<\/span>.<\/span>right<\/span>,<\/span> code <\/span>+<\/span> <\/span>"<\/span>1<\/span>"<\/span>,<\/span> code_table<\/span>)<\/span><\/span>\n<\/span>\ndef<\/span> <\/span>encode<\/span>(<\/span>input_str<\/span>,<\/span> <\/span>code_table<\/span>):<\/span><\/span>\n    encoded <\/span>=<\/span> <\/span>""<\/span><\/span>\n    <\/span>for<\/span> c <\/span>in<\/span> input_str<\/span>:<\/span><\/span>\n        encoded <\/span>+=<\/span> code_table<\/span>[<\/span>c<\/span>]<\/span><\/span>\n    <\/span>return<\/span> encoded<\/span><\/span>\n<\/span>\n# Fonte: Chat GPT<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    Em Python, a sintaxe e a estrutura do c\u00f3digo s\u00e3o diferentes em rela\u00e7\u00e3o ao exemplo em C# e Java. As principais diferen\u00e7as incluem a n\u00e3o necessidade de declarar o tipo das vari\u00e1veis, a sintaxe de classe em Python, e a sintaxe diferente de loop e condicionais.<\/p>\n\n\n\n
    Al\u00e9m disso, em Python, os dicion\u00e1rios s\u00e3o usados como a principal estrutura de dados para armazenar as tabelas de frequ\u00eancia e de c\u00f3digos. Tamb\u00e9m \u00e9 poss\u00edvel usar a fun\u00e7\u00e3o sorted<\/code> para ordenar uma lista de n\u00f3s de acordo com a frequ\u00eancia.<\/p>\n\n\n\n
    Por fim, a fun\u00e7\u00e3o join<\/code> \u00e9 usada para concatenar strings em Python, o que \u00e9 uma alternativa mais eficiente em rela\u00e7\u00e3o ao uso do operador +=<\/code> em um loop.<\/p>\n\n\n\n
    Apesar das diferen\u00e7as de sintaxe e estrutura, a l\u00f3gica do c\u00f3digo \u00e9 a mesma em todas as tr\u00eas vers\u00f5es e segue os mesmos passos para implementar a codifica\u00e7\u00e3o de Huffman.<\/p>\n\n\n\n
    Conclus\u00e3o<\/h2>\n\n\n\n
    Atrav\u00e9s da implementa\u00e7\u00e3o do algoritmo de Huffman, podemos extrair insights importantes que podem nos ajudar a criar c\u00f3digos melhores no dia a dia. Entender a import\u00e2ncia da frequ\u00eancia de ocorr\u00eancia de cada caractere na codifica\u00e7\u00e3o de dados pode nos ajudar a criar algoritmos mais eficientes e econ\u00f4micos em termos de uso de recursos. <\/p>\n\n\n\n
    Al\u00e9m disso, a utiliza\u00e7\u00e3o de estruturas de dados eficientes, como a \u00e1rvore bin\u00e1ria, pode ser uma forma de otimizar a implementa\u00e7\u00e3o de algoritmos de compress\u00e3o de dados e outros tipos de processamento de informa\u00e7\u00f5es.<\/p>\n\n\n\n
    Em resumo, a codifica\u00e7\u00e3o de Huffman \u00e9 um algoritmo importante e bastante utilizado na \u00e1rea de processamento de informa\u00e7\u00f5es, permitindo a compress\u00e3o de dados de forma eficiente e econ\u00f4mica. Se voc\u00ea \u00e9 iniciante na \u00e1rea de programa\u00e7\u00e3o, recomenda-se estudar a implementa\u00e7\u00e3o desse algoritmo para adquirir um maior conhecimento sobre estruturas de dados, recursividade e algoritmos de compress\u00e3o de dados.<\/p>\n\n\n\n
    Esse conte\u00fado \u00e9 parte do material disponibilizado para os participantes do meu grupo de estudos de Algoritmos e Estruturas de Dados<\/strong>. Voc\u00ea quer participar desse grupo? Clique aqui e veja como funciona<\/a><\/strong>.<\/p>\n\n\n\n
    D\u00favidas Frequentes<\/h2>\n\n\n\n
    O que \u00e9 codifica\u00e7\u00e3o de Huffman?<\/strong>
    A codifica\u00e7\u00e3o de Huffman \u00e9 um m\u00e9todo para codificar dados de maneira eficiente, reduzindo o n\u00famero de bits necess\u00e1rios para represent\u00e1-los. Esse m\u00e9todo \u00e9 baseado na frequ\u00eancia de ocorr\u00eancia de cada caractere no conjunto de dados que queremos codificar. Caracteres que aparecem com mais frequ\u00eancia s\u00e3o codificados com menos bits, enquanto que caracteres menos frequentes s\u00e3o codificados com mais bits.<\/p>\n\n\n\n
    Por que usar uma \u00e1rvore bin\u00e1ria na implementa\u00e7\u00e3o?<\/strong>
    A \u00e1rvore bin\u00e1ria \u00e9 uma estrutura de dados eficiente para representar a estrutura de codifica\u00e7\u00e3o de Huffman, pois permite uma busca r\u00e1pida e eficiente pelo c\u00f3digo bin\u00e1rio de cada caractere. Al\u00e9m disso, a \u00e1rvore bin\u00e1ria pode ser facilmente percorrida de forma recursiva, o que simplifica a implementa\u00e7\u00e3o do algoritmo.<\/p>\n","protected":false},"featured_media":4241,"parent":0,"template":"","cursos":[5],"class_list":["post-4240","artigos","type-artigos","status-publish","has-post-thumbnail","hentry","cursos-algortimos"],"acf":[],"_links":{"self":[{"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/artigos\/4240","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/artigos"}],"about":[{"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/types\/artigos"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/media\/4241"}],"wp:attachment":[{"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/media?parent=4240"}],"wp:term":[{"taxonomy":"cursos","embeddable":true,"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/cursos?post=4240"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}