Representação de dados

Computadores digitais representam dados usando dois estados lógicos, escritos como 1 e 0. Um sistema que usa apenas dois dígitos é chamado binário (base 2).

Todo tipo de dado — números, texto, som e imagens — deve ser convertido para binário antes que um computador possa usá-lo. O computador processa esse binário usando portas lógicas e armazena-o em registros (pequenos e rápidos armazenamento dentro do processador).

Um sistema numérico é uma forma de escrever números usando um conjunto fixo de dígitos. Você precisa de três deles.

• denário é o sistema normal de contagem (também chamado decimal).
• binário usa apenas 0 e 1.
• hexadecimal (hex) usa dezesseis dígitos: 0–9, depois A, B, C, D, E, F representam 10, 11, 12, 13, 14, 15.

A base indica quantos dígitos diferentes um sistema utiliza.

Valor posicional

Cada coluna em um número tem um valor posicional. No binário, os valores posicionais dobram da direita para a esquerda. Para um número de 8 bits, eles são:

128  64  32  16  8  4  2  1

Um bit é um único 0 ou 1. Oito bits formam um byte. Quatro bits (metade de um byte) é um nibble.

Conversão entre sistemas numéricos

Decimal → Binário. Escreva os valores posicionais. Coloque um 1 sob cada valor necessário para somar seu número; coloque 0 nos demais.

Exemplo: mude decimal 150 para binário. $150 = 128 + 16 + 4 + 2$.

128 64 32 16 8 4 2 1
  1  0  0  1 0 1 1 0

Então $150$ = 10010110.

Binário → Decimal. Some os valores posicionais onde há um 1. 10010110 $= 128 + 16 + 4 + 2 = 150$.

Hexadecimal → Binário. Converta cada dígito hex para seu próprio grupo de 4 bits (um nibble).

Exemplo: hex F08. $F = 1111$, $0 = 0000$, $8 = 1000$, então F08 = 1111 0000 1000.

Binário → Hexadecimal. Agrupe os bits em nibbles de 4, começando da direita. Converta cada nibble para um dígito hex.

Decimal → Hexadecimal. A maneira fácil é mudar para binário primeiro, depois binário para hex.

Esta tabela ajuda com as letras hex:

Questões da Cambridge usam números binários de até 16 bits de comprimento.

Exemplo resolvido. Converta decimal 100 para binário de 8 bits, depois para hexadecimal.

$100 = 64 + 32 + 4$, então o binário é 01100100. Dividindo em nibbles, 0110 0100 $= 6$ e $4$, então o hexadecimal é 64.

Exemplo resolvido (hexadecimal → decimal). Converta o número hexadecimal 2C para decimal. Os valores posicionais em hexadecimal são $16$ e $1$. 2 vale $2 \times 16 = 32$ e C vale $12$, então 2C $= 32 + 12 = 44$. Confira por meio do sistema binário: 0010 1100 $= 32 + 8 + 4 = 44$.

Por que hexadecimal é usado

Hex é mais curto que binário e mais fácil para pessoas lerem e escreverem. Um dígito hex substitui 4 dígitos binários, assim você comete menos erros. O valor não muda — hex é apenas uma forma mais curta de mostrar o mesmo binário.

Cientistas da computação usam hex para:

• Endereços MAC e endereços IPv6
• Códigos de cores em HTML (por exemplo, #FF0000 é vermelho)
• endereços de memória e códigos de erro
• exibição do conteúdo da memória (um “despejo de memória”)

Você pode somar dois números binários de 8 bits, coluna por coluna da direita, assim como o decimal. As regras para uma coluna são:

Quando um carregamento também entra, $1 + 1 + 1 = 1$ com um carregamento de 1.

Exemplo: some 01110110 (118) e 00110000 (48).

  0 1 1 1 0 1 1 0    (118)
+ 0 0 1 1 0 0 0 0    (48)
-------------------
  1 0 1 0 0 1 1 0    (166)

Transbordamento

Quando interpretado como um inteiro sem sinal, um registro de 8 bits armazena valores de 0 a 255. Se uma adição resultar em um valor acima de 255, a resposta precisará de um 9 bit. O registro não pode armazenar esse bit extra, então ele é perdido. Isso é chamado transbordamento (erro de transbordamento). Ocorre quando um valor ultrapassa o limite que o registro pode armazenar.

Exemplo: 11001000 (200) $+$ 01001000 (72) $= 272$. Em binário isso é 1 00010000, que precisa de 9 bits. O 1 inicial não caberá em 8 bits, então a resposta armazenada estará errada.

Um deslocamento lógico binário move todos os bits para a esquerda ou direita por um certo número de posições.

• Bits que saem da extremidade do registrador são perdidos.
• Zeros são adicionados na extremidade vazia.

Para um inteiro sem sinal, um deslocamento para a esquerda multiplica por 2 para cada posição movida se nenhum bit não nulo for perdido. Um deslocamento lógico para a direita fornece o resultado inteiro da divisão por 2 para cada posição; os bits mais à direita (os bits menos significativos) são perdidos.

Exemplo: deslocar à esquerda 00110101 (53) em 2 posições.

start:         0 0 1 1 0 1 0 1
left shift 2:  1 1 0 1 0 1 0 0

O resultado é 11010100 (212), que é $53 \times 4$. Os dois bits mais à esquerda foram perdidos e dois zeros entraram pela direita. Se um 1 for empurrado para fora, essa informação está perdida para sempre.

Exemplo resolvido (deslocamento à direita). Desloque 10110100 (180) 3 posições para a direita. Dê o resultado em binário e decimal e diga qual é o efeito do deslocamento.

start:          1 0 1 1 0 1 0 0
right shift 3:  0 0 0 1 0 1 1 0

Os três bits mais à direita (100) são perdidos e três zeros entram à esquerda: 00010110 $= 16 + 4 + 2 = 22$. Deslocar 3 posições para a direita divide por $2^3 = 8$: $180 \div 8 = 22.5$, e o deslocamento mantém apenas a parte inteira, $22$. O valor $0.5$ era representado pelo bit 1 perdido.

Exemplo resolvido (um deslocamento à esquerda que dá errado). Desloque 01100100 (100) 2 posições para a esquerda. O resultado é 10010000 $= 144$, não $400$: um 1 foi descartado pela extremidade esquerda, e $400$ é grande demais para 8 bits de qualquer forma. Um deslocamento à esquerda multiplica corretamente apenas enquanto nenhum bit 1 é perdido.

Até agora, os números foram positivos. Complemento de dois permite que um registrador de 8 bits armazene também números negativos.

No complemento de dois, o bit mais à esquerda (bit mais significativo, ou MSB) tem um valor posicional negativo:

-128  64  32  16  8  4  2  1

• Se o MSB for 0, o número é zero ou positivo.
• Se o MSB for 1, o número é negativo.

Para tornar um número positivo negativo: escreva o binário positivo, inverter cada bit (0↔1), depois some 1.

Exemplo: tornar $-40$ negativo.

• $+40$ = 00101000
• inverter os bits = 11010111
• somar 1 = 11011000

Então $-40$ = 11011000. Verifique somando os valores posicionais: $-128 + 64 + 16 + 8 = -40$.

Para ler um número no complemento de dois negativo, basta somar os valores posicionais (o MSB conta como $-128$). A faixa de um número de complemento de dois de 8 bits é de $-128$ a $+127$.

Exemplo resolvido. Converta o número em complemento de dois 10011010 para decimal. O bit mais significativo é 1, então o número é negativo: $-128 + 16 + 8 + 2 = -102$. Confira pelo outro método: inverta os bits (01100101) e some 1 (01100110 $= 102$), então o número é $-102$.

Os computadores armazenam texto atribuindo um número a cada caractere e, em seguida, armazenando esse número em binário. O conjunto de caracteres que um computador pode usar, junto com seus números, é um conjunto de caracteres.

ASCII usa códigos de caractere de 7 bits, fornecendo $N = 2^b = 2^7 = 128$ códigos diferentes. Inclui letras do inglês, dígitos e símbolos comuns; nem todos os 128 códigos são letras. Unicode representa uma gama muito maior de caracteres, incluindo diferentes idiomas e emojis.

Tente — codifique uma mensagem curta. Este trecho do ASCII mostra A = 65, B = 66, C = 67 e espaço = 32. Escreva os quatro grupos de 7 bits para CAB , incluindo seu espaço final. Depois, decodifique os grupos 1000010 1000001 1000011.

Resolução exemplificada. Consulte cada caractere, depois converta seu código para binário:

Portanto, CAB é 1000011 1000001 1000010 0100000. A segunda mensagem decodifica para BAC. Um espaço também possui um código; não se trata de ausência de dados armazenados. O remetente e o destinatário devem usar o mesmo mapeamento de códigos de caracteres para interpretar a mensagem corretamente.

Por que uma faixa maior importa. ASCII não pode representar diretamente um nome chinês. Unicode inclui caracteres chineses, além de caracteres ingleses e muitos outros idiomas. Para a comparação do programa de estudos, explique que uma faixa maior exige códigos binários distintos maiores, requerendo mais bits por caractere do que o modelo ASCII de 7-bits.

Tente — compare os modelos de armazenamento declarados. Armazene os quatro caracteres CAB usando (A) 7 bits por caractere e (B) 16 bits por caractere. Suponha que os bits estejam empacotados sem preenchimento ou informações extras de arquivo. Encontre o tamanho dos dados de texto em cada modelo. O valor de 16-bits é uma suposição para este exemplo, não uma regra de que todos os caracteres Unicode ocupam 16 bits.

Resposta trabalhada. Com o mesmo número de caracteres, multiplique pelos bits declarados por caractere:

O Modelo B usa mais armazenamento para este exemplo porque sua largura de código declarada é maior. Use a largura fornecida em uma questão de exame. Em arquivos reais, o codificador também importa: UTF-8 armazena caracteres ASCII nos mesmos bytes de um arquivo ASCII, então o texto Unicode nem sempre ocupa mais bytes. Você não precisa das regras detalhadas de UTF-8 para esta comparação do programa de estudos.

Uma onda sonora é suave e está sempre mudando. Para armazená-la, o computador mede a altura da onda em momentos regulares. Isso é chamado de amostragem, e cada medição é uma amostra.

• taxa de amostragem é o número de amostras coletadas por segundo (medido em Hz).
• resolução de amostra é o número de bits usados para cada amostra. A altura da onda em um ponto de amostra é sua amplitude.

Uma taxa de amostragem maior e uma resolução de amostragem maior fornecem uma gravação mais precisa, mas resultam em um arquivo maior.

Uma imagem de computador é composta por uma grade de pequenos pontos chamados pixels.

• resolução é o número de pixels na imagem (por exemplo, $1920 \times 1080$).
• profundidade de cor é o número de bits usados para armazenar a cor de cada pixel.

Uma resolução maior e uma profundidade de cor maior proporcionam uma imagem de melhor qualidade, mas resultam em um arquivo maior.

A profundidade de cor determina quantas cores diferentes cada pixel pode ter: com $n$ bits há $2^n$ cores. Uma profundidade de cor de 1 bit produz 2 cores (preto e branco), 8 bits produzem $2^8 = 256$ cores e 24 bits produzem mais de 16 milhões.

Exemplo resolvido. Uma imagem usa 64 cores diferentes. Qual é a menor profundidade de cor que ela pode ter? Encontre o menor $n$ com $2^n \geqslant 64$: $2^6 = 64$, portanto 6 bits por pixel. Se usasse 65 cores, precisaria de 7 bits, porque 6 bits podem produzir apenas 64 padrões diferentes.

O armazenamento de dados é medido nas unidades abaixo. Um nibble tem 4 bits e um byte tem 8 bits; a partir do kibibyte para cima, cada unidade é 1024 vezes a anterior (porque $1024 = 2^{10}$, que se encaixa no binário).

Tamanho do arquivo de imagem (em bits) $=$ resolução $\times$ profundidade de cor $=$ largura $\times$ altura $\times$ profundidade de cor.

Exemplo: uma imagem tem $1024 \times 1024$ pixels com profundidade de cor de 2 bytes ($= 16$ bits).

• bits $= 1024 \times 1024 \times 16 = 16\,777\,216$ bits
• bytes $= \div 8 = 2\,097\,152$ bytes
• KiB $= \div 1024 = 2048$ KiB
• MiB $= \div 1024 = 2$ MiB

Tamanho do arquivo de som (em bits) $=$ taxa de amostragem $\times$ resolução de amostragem $\times$ duração em segundos.

Estas fórmulas contam dados não compactados sem cabeçalhos de arquivo. A fórmula de áudio é para um canal; multiplique pela contagem de canais se a questão especificar mais canais.

Sempre divida por 1024 (não 1000) para converter para KiB, MiB e assim por diante. Dê sua resposta na unidade solicitada pela questão.

Exemplo resolvido. Um som é gravado por 30 segundos a uma taxa de amostragem de 8,000 Hz com uma resolução de amostra de 16 bits. Encontre o tamanho do arquivo em kibibytes (KiB).

• bits $= 8\,000 \times 16 \times 30 = 3\,840\,000$ bits
• bytes $= 3\,840\,000 \div 8 = 480\,000$ bytes
• KiB $= 480\,000 \div 1024 \approx 469$ KiB

Compactação torna um arquivo menor. Um arquivo menor:

• ocupa menos espaço de armazenamento,
• precisa de menos largura de banda (a quantidade de dados que uma conexão pode transportar),
• leva menos tempo para ser enviado (um tempo de transmissão mais curto).

Existem dois tipos.

Compactação sem perdas

Compactação sem perda torna o arquivo menor com nenhuma perda permanente de dados. O arquivo original pode ser reconstruído exatamente.

Um método é a codificação por comprimento de sequência (RLE). Ela substitui uma sequência de valores repetidos por uma cópia do valor e uma contagem de quantas vezes ele se repete. Por exemplo, WWWWWWWW (8 brancos) é armazenado como “8 W”. Isso funciona bem quando os dados têm muitas repetições.

Exemplo resolvido. Uma linha de uma imagem em preto e branco é B B B B B W W B B B B B B B B B (16 pixels). Comprima-a com RLE e diga se houve economia de espaço quando cada contagem e cada cor são armazenadas em um byte.

As sequências são 5 pretos, 2 brancos, 9 pretos, então os dados em RLE são 5 B 2 W 9 B: 6 bytes em vez de 16 bytes do original (um byte por pixel). Há economia de espaço porque a linha tem sequências longas. Uma linha que muda de cor a cada pixel, B W B W …, se tornaria 1 B 1 W 1 B 1 W …, duas vezes maior que a original: RLE só ajuda quando os dados se repetem.

Compactação com perdas

Compactação com perda torna o arquivo muito menor removendo permanentemente alguns dados. Os dados removidos não podem ser recuperados. Por exemplo:

• reduzir a resolução ou profundidade de cor de uma imagem,
• reduzir a taxa de amostragem ou a resolução de amostragem de um som.

Use compactação sem perdas quando você precisar manter cada detalhe (arquivos de texto e programas). Use compactação com perdas para fotos, música e vídeo, onde uma pequena perda de qualidade vale um arquivo muito menor.

• Converta decimal → binário subtraindo os valores posicionais (128, 64, 32 …); binário → decimal somando os valores posicionais que contêm um 1.
• Para converter para hexadecimal, agrupe o binário em nibbles de 4 bits da direita; cada nibble corresponde exatamente a um dígito hexadecimal.
• Transbordamento ocorre quando um resultado está fora da faixa da representação escolhida. Inteiros sem sinal de oito bits armazenam 0–255; inteiros de complemento de dois de oito bits armazenam −128–127.
• Tamanho do arquivo em bits: para uma imagem, largura × altura × profundidade de cor; para som, taxa de amostragem × resolução × segundos. Divida por 8 para bytes, depois por 1024 para cada unidade maior.
• Compactação sem perdas mantém todos os bits (texto; codificação por comprimento de corrida); compactação com perdas remove dados permanentemente (fotos, música) para um arquivo muito menor.