Página 1 de 2 12 ÚltimoÚltimo
+ Responder ao Tópico



  1. Alô galera.

    Achei um exercício interessante na rede para praticar a Linguagem C. Infelizmente não estou conseguindo desenvolvê-lo.
    O Exercício pede para fazer dois programas que permitam respectivamente a codificação e a decodificação de arquivos para a representação em base64. Ou seja, um dos programas deve ser responsável pela codificação e o outro deve ser responsável pela respectiva decodificação.

    A codificação de um arquivo qualquer (origem) para uma representação base64 (destino) deve ser feita da seguinte forma:
    1 - Ler 3 bytes do arquivo origem.
    Ex: 3 bytes => (11110000) (10101010) (00001111)

    2 - Separar esses 3 bytes em 4 blocos contendo 6 bits cada.
    Ex: (11110000) (10101010) (00001111) =>
    => (111100 | 00 ) ( 1010 | 1010 ) ( 00 | 001111) =>
    => (111100) (001010) (101000) (001111).

    OBS. Os bits em negrito pertenciam ao 1o Byte, os em itálico pertenciam ao 2o Byte e os sublinhados pertenciam ao 3o Byte.

    3 - Representar esses 4 blocos usando bytes. Para isso, concatenar esses 4 blocos com dois zeros (0) nos bits mais significantes (bits da esquerda).
    Ex: (111100) (001010) (101000) (001111) =>
    => (00111100) (00001010) (00101000) (00001111)

    OBS. Os bits em negrito foram os zeros (0) inseridos.
    Converter os 4 Bytes resultantes para caracteres (letras) de acordo com a lista decimal-caractere abaixo:
    0 = 'A',
    1 = 'B',
    2 = 'C',
    3 = 'D',
    4 = 'E',
    5 = 'F',
    6 = 'G',
    7 = 'H',
    8 = 'I',
    9 = 'J',
    10 = 'K',
    11 = 'L',
    12 = 'M',
    13 = 'N',
    14 = 'O',
    15 = 'P',
    16 = 'Q',
    17 = 'R',
    18 = 'S',
    19 = 'T',
    20 = 'U','
    21 = V',
    22 = 'W',
    23 = 'X',
    24 = 'Y',
    25 = 'Z',
    26 = 'a',
    27 = 'b',
    28 = 'c',
    29 = 'd',
    30 = 'e',
    31 = 'f',
    32 = 'g',
    33 = 'h',
    34 = 'i',
    35 = 'j',
    36 = 'k',
    37 = 'l',
    38 = 'm',
    39 = 'n',
    40 = 'o',
    'p',
    'q',
    'r',
    's',
    't',
    'u',
    'v',
    'w',
    'x',
    'y',
    'z',
    '0',
    '1',
    '2',
    '3',
    '4',
    '5',
    '6',
    '7',
    '8',
    '9',
    '+',
    '/'

    Ex:
    Binário: (00111100) (00001010) (00101000) (00001111) =
    = Decimal: (60) (10) (40) (15) =
    = Caractere: ('8') ('K') ('o') ('P')

    Sei que talvez seja pedir demais, mas gostaria de analisar algumas ideias do pessoal aqui do forum para tentar entender a lógica.

    Valeu.

  2. #2
    Não Registrado
    Curioso que esse exercício é igual ao exercício de um curso online q estou escrito...



  3. Exercício interessante esse.

    Começa pelo básico. Você sabe abrir e ler um arquivo em C?? Para isso utilize a função fopen: Curso de C

    Ok, aprendido a abrir arquivos e seus vários modos, vc tem que aprender a ler um byte de cada arquivo. Em C um char é um byte, logo vc pode usar a função getc: Curso de C

    Para separar 6 bits em um byte você vai usar quatro funções de operações binárias: << (shift letter right), >> (shift letter left), | (or) e & (and). Aqui tem uma explicação sobre eles: Operadores e Expressões

    Basicamente o desafio do exercício é essa separação. (alterei um pouco o exemplo)
    Ex: (11110010) (10101010) (00001111) =>
    => (111100 | 10) ( 1010 | 1010 ) ( 00 | 001111) =>
    => (111100) (101010) (101000) (001111).
    resultado final:
    (00111100) (00101010) (00101000) (00001111)

    No primeiro byte, você precisa fazer um and com uma máscara para pegar os 2 bits da direita:
    Código :
      [FONT=Courier New]11110010
    & 00000011
      --------
      00000010[/FONT]
    Podemos dizer que o AND "insere" zeros. Dessa forma "apagamos" todos os outros bits. Para pegar somente os 6 bits da direita podemos fazer um shift letter right, que desloca os bits para a direita. Dessa forma se fizermos um deslocamento de 2 bits para a direita iremos obter o seguinte resultado:
    Código :
    [FONT=Courier New]11110010 >> 1 = 0[/FONT][FONT=Courier New]1111001[/FONT]
    [FONT=Courier New]0[/FONT][FONT=Courier New]1111001 >> 1 = 0[/FONT][FONT=Courier New]0[/FONT][FONT=Courier New]111100[/FONT]
    Assim ja temos parte do resultado, primeiro base64: 00111100.


    Agora vamos trabalhar com o segundo byte: 10101010. Primeiro vamos separa os 4 primeiros bits fazendo um deslocamento de 4 bits para a direita :
    Código :
    [FONT=Courier New]  10101010 >> 4 = 00001010
    [/FONT]
    Agora vamos concatenar a parte do primeiro byte (00000010) com essa parte do segundo byte (00001010). Primeiro temos que deslocar a parte do primeiro byte:
    Código :
    [FONT=Courier New]  00000010 << 4 = 00100000
    [/FONT]
    Agora vou "inserir" esses os dois:
    Código :
     [FONT=Courier New] 00100000
    | 00001010
      --------
      00101010
    [/FONT]
    Pronto, temos o segundo base64, 00101010.

    E assim por diante. So tome cuidado de verificar se o arquivo é múltiplo de 3, uma vez que você vai ler de 3 em 3 bytes. Para isso depois de ler verifique se você não recebeu um EOF, se você recebeu um EOF faça um "padding", isto é, preencha os outros bytes com zero.

    Quanto a conversão para chars nos vamos usar a tabela ASCII: ASCII - Wikipédia, a enciclopédia livre

    Basicamente a ideia é o seguinte, se seu byte estiver entre 0 e 25 você some ele ao valor 64, dessa forma:
    0+65=64 (A na tabela ASCII);
    1+65=65 (B na tabela ASCII);
    2+65=66 (C na tabela ASCII);
    ...

    Se o seu byte estiver entre 26 e 51, subtraia 26 dele e some o resultado a 97 para obter o caractere a:
    26-26+97=97 (a na tabela ASCII);
    27-26+97=98 (b na tabela ASCII);
    28-26+97=99 (b na tabela ASCII);
    ...


    Se o seu byte for maior que 51, subtraia ele por 52 e some o resultado a 48 para obter o caractere 0:
    52-52+48=48 (0 na tabela ASCII)
    53-52+48=49 (1 na tabela ASCII)
    54-52+48=50 (2 na tabela ASCII)
    ...

    Acho que é isso ai cara! Qualquer dúvida posta ai!
    Até mais...
    Última edição por Magnun; 09-09-2009 às 07:25.

  4. Cara. Consegui chegar até aqui:

    Código :
    #include <stdio.h>
     
    int main()
    {
    FILE *fp;/* Declaração da estrutura */
    char c;
     
    fp=fopen ("origem.txt","r");  /* o arquivo se chama origem.txt e está localizado no diretório corrente */
     
    if(!fp)
    {
        printf( "Erro na abertura do arquivo");
        exit(0);
    }
    while((c = getc(fp) ) != EOF)  /* Enquanto não chegar ao final do arquivo */
        printf("%c", c);                 /* imprime o caracter lido */
    fclose(fp);
    return 0;
    }

    Não consigo entender como tratar o que foi lido no arquivo de origem, como vou saber até onde vai o arquivo para poder pegar o primeiro byte e como fazer a separação, sou seja, como vou até o primeiro byte para separar?

    Valeu



  5. Mais ou menos assim:
    Código :
    char byte1;
    char byte2;
    char byte3;
     
    int end_flag = 1;
     
    while(end_flag){
        /* Lendo Byte 1*/
        byte1 = getc(fp) 
        if (byte1 == EOF)
            end_flag = 0; 
     
        /* Lendo Byte 2*/
        if (end_flag){
            byte2 = getc(fp) 
            if (byte2 == EOF)
                printf("Arquivo nao multiplo de 3.");
                end_flag = 0; 
        }
     
        /* Lendo Byte 3*/
        if (end_flag){
            byte3 = getc(fp) 
            if (byte3 == EOF)
                printf("Arquivo nao multiplo de 3.");
                end_flag = 0; 
        }
    }
    fclose(fp);






Tópicos Similares

  1. Duvidas Modem Speedy..?
    Por no fórum Servidores de Rede
    Respostas: 1
    Último Post: 04-09-2002, 18:34
  2. Dúvidas Path.
    Por no fórum Servidores de Rede
    Respostas: 1
    Último Post: 21-08-2002, 08:52
  3. Duvidas Ipchains / Iptables!!!
    Por no fórum Servidores de Rede
    Respostas: 2
    Último Post: 20-08-2002, 14:39
  4. Limitar o logon e outra duvida ..
    Por MarcelScan no fórum Servidores de Rede
    Respostas: 1
    Último Post: 28-07-2002, 14:35
  5. Limitar o logon e outra duvida ..
    Por MarcelScan no fórum Servidores de Rede
    Respostas: 1
    Último Post: 24-07-2002, 20:45

Visite: BR-Linux ·  VivaOLinux ·  Dicas-L