C++ Um pequeno erro a ser corrigido c++

Rodrigo Diamond · 16 de abril de 2020

Olá, eu estou tentando descobrir quantas vogais contém nesta palavra que eu digito, e está dando 0, se alguém puder me ajudar ficaria grato!

OBS: não sei o que estou fazendo de errado, gostaria de algum auxílio, por favor !!

Cordas · 17 de abril de 2020

Opa, teu programa tá em C.

Antes de postar uma pergunta verifica se já tem algo pena net. Eu olhei justamente esse programa ontem nesse link

https://www.programiz.com/cpp-programming/examples/vowel-consonant-frequency-string

É justamente o que você procura.

Rodrigo Diamond · 17 de abril de 2020

@Cordas desculpa, não prestei atenção nisso ! Muito obrigado, vou dar uma olhada.

arfneto · 17 de abril de 2020

Você tem um livro-texto? Sua escola adota um? Você tem uma apostila?

Que pretende com esse comando?

Ponha seu programa inteiro no post usando o botão code lá em cima, basta selecionar seu programa inteiro no editor e colar aqui dentro do tal code ...

Você declarou

    char a,e,i,o,u;

e magino que gostaria que lá dentro elas tivessem esses valores, as vogais. Só que você não colocou nada lá.

e esse comando

    while(vogais[nome] == a,e,i,o,u)...

mostra grande esperança na capacidade de compreensão do compilador.

Você declarou

    int vogais = 0;

Então esse é um int que vai ser o contador das tais vogais. E nome era char[40] e lá vai estar a frase afinal.

Então você quer comparar as letras em nome[] que podem ir de 0 até 38 na verdade, e ver quantas delas são iguais a uma vogal.

Mas você não inicializou as vogais com as vogais. Desculpe o trocadilho. Tipo a = 'a', b= 'b' e tal
Não considerou as possíveis vogais maiúsculas
usou vogais[nome] ao invés de nome[algo] já que o índice não pode ser o próprio int vogais ou vai zoar tudo

Está muito longe de funcionar. Muito mesmo. Corrija isso ao menos e leia um pouco sobre os comandos

AdrianoSiqueira · 17 de abril de 2020

O jeito mais simples na minha opinião é usar um switch:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

int main() {
    char palavra[100] = "";     // Palavra digitada

    int quantidade = sizeof(palavra) / sizeof(palavra[0]);  // Quantidade maxima de letras
    int letras = 0;         // Quantidade de letras da palavra
    int vogais = 0;         // Quantidade de vogais
    int consoantes = 0;     // Quantidade de consoantes
    int espacos = 0;        // Quantidade de espacos em branco
    int desconhecidos = 0;  // Conta o que nao foi contado anteriormente

    // Entrada de dados
    printf("Digite a palavra: ");
    fgets(palavra, quantidade, stdin);
    palavra[strcspn(palavra, "\n")] = '\0';     // Remove o '\n' do fgets

    // Conta a quantidade de letras da palavra
    letras = (int) strlen(palavra);

    // Percorre cada letra da palavra contabilizando-a
    for (int i = 0; i < letras; ++i) {
        switch (toupper(palavra[i])) {
            case 'A':
            case 'E':
            case 'I':
            case 'O':
            case 'U':
                vogais += 1;
                break;
            case 'B':
            case 'C':
            case 'D':
            case 'F':
            case 'G':
            case 'H':
            case 'J':
            case 'K':
            case 'L':
            case 'M':
            case 'N':
            case 'P':
            case 'Q':
            case 'R':
            case 'S':
            case 'T':
            case 'V':
            case 'W':
            case 'X':
            case 'Y':
            case 'Z':
                consoantes += 1;
                break;
            case ' ':
                espacos += 1;
                break;
            default:
                desconhecidos += 1;
                break;
        }
    }

    // Exibe o relatorio
    printf("-------------------------------------------------- \n");
    printf("      Palavra: %s \n", palavra);
    printf("       Letras: %i \n", letras);
    printf("       Vogais: %i \n", vogais);
    printf("   Consoantes: %i \n", consoantes);
    printf("      Espacos: %i \n", espacos);
    printf("Desconhecidos: %i \n", desconhecidos);
    printf("-------------------------------------------------- \n");

    return EXIT_SUCCESS;
}

Cordas · 18 de abril de 2020

13 horas atrás, AdrianoSiqueira disse:

O jeito mais simples na minha opinião é usar um switch:


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

int main() {
    char palavra[100] = "";     // Palavra digitada

    int quantidade = sizeof(palavra) / sizeof(palavra[0]);  // Quantidade maxima de letras
    int letras = 0;         // Quantidade de letras da palavra
    int vogais = 0;         // Quantidade de vogais
    int consoantes = 0;     // Quantidade de consoantes
    int espacos = 0;        // Quantidade de espacos em branco
    int desconhecidos = 0;  // Conta o que nao foi contado anteriormente

    // Entrada de dados
    printf("Digite a palavra: ");
    fgets(palavra, quantidade, stdin);
    palavra[strcspn(palavra, "\n")] = '\0';     // Remove o '\n' do fgets

    // Conta a quantidade de letras da palavra
    letras = (int) strlen(palavra);

    // Percorre cada letra da palavra contabilizando-a
    for (int i = 0; i < letras; ++i) {
        switch (toupper(palavra[i])) {
            case 'A':
            case 'E':
            case 'I':
            case 'O':
            case 'U':
                vogais += 1;
                break;
            case 'B':
            case 'C':
            case 'D':
            case 'F':
            case 'G':
            case 'H':
            case 'J':
            case 'K':
            case 'L':
            case 'M':
            case 'N':
            case 'P':
            case 'Q':
            case 'R':
            case 'S':
            case 'T':
            case 'V':
            case 'W':
            case 'X':
            case 'Y':
            case 'Z':
                consoantes += 1;
                break;
            case ' ':
                espacos += 1;
                break;
            default:
                desconhecidos += 1;
                break;
        }
    }

    // Exibe o relatorio
    printf("-------------------------------------------------- \n");
    printf("      Palavra: %s \n", palavra);
    printf("       Letras: %i \n", letras);
    printf("       Vogais: %i \n", vogais);
    printf("   Consoantes: %i \n", consoantes);
    printf("      Espacos: %i \n", espacos);
    printf("Desconhecidos: %i \n", desconhecidos);
    printf("-------------------------------------------------- \n");

    return EXIT_SUCCESS;
}

Essa é a menor solução possível em C?

AdrianoSiqueira · 18 de abril de 2020

10 horas atrás, Cordas disse:

Essa é a menor solução possível em C?

Eu não disse menor, eu disse simples, ou seja, fácil de entender, sem muitas firulas, você bate o olho e vê o que está acontecendo.

arfneto · 18 de abril de 2020

Olá! Espero que tenha corrigido os erros todos já. E esse erro de concordância na mensagem do total deveria sumir também, afinal total é singular.

12 horas atrás, Cordas disse:

Essa é a menor solução possível em C?

2 horas atrás, AdrianoSiqueira disse:

Eu não disse menor, eu disse simples, ou seja, fácil de entender, sem muitas firulas, você bate o olho e vê o que está acontecendo

Assim é: menor não significa muito. Legibilidade em especial num projeto grande conta muito. Num programa de estudante também. Mas no fim eficiência em termos de uso de memória e em tempo de execução são as condições que decidem como implementar um programa real.

Esse exemplo:

Um caso como esse geralmente é mais eficiente resolver com uma tabela de referência. É assim que os compiladores fazem, os processadores e tal. Você cria uma tabela e não compara mais. Só pega o resultado na tabela. look-up table é o que costuma aparecer nos livros.

Uma solução comum seria assim:

#define _CRT_SECURE_NO_WARNINGS
#include "memory.h"
#include "stdio.h"

int main(int argc, char** argv)
{
    char ref[256];
    memset(ref, 0, 256);
    int n_vogais = 0;
    int n_espacos = 0;
    ref['a'] = ref['e'] = ref['i'] = ref['o'] = ref['u'] = 1;
    ref['A'] = ref['E'] = ref['I'] = ref['O'] = ref['U'] = 1;
    ref[' '] = 2;
    char palavra[80];
    printf("Digite uma string: ");
    fgets(palavra, 80, stdin);
    int len = strlen(palavra) - 1;
    palavra[len] = 0;
    printf("Palavra: [%s] tamanho: '%d'\n", palavra, len);
    for (int i = 0; i < (int)strlen(palavra); i += 1)
        if (ref[palavra[i]] == 1)
            n_vogais += 1;
        else
            if (ref[palavra[i]] == 2)
                n_espacos += 1;
    printf("Sao %d vogais e %d espacos\n", n_vogais, n_espacos);
    return 0;
};  // o_comum

Mas pode melhorar um pouco... está chamando strlen() duas vezes, e uma delas é no teste do for() então vai chamar isso para cada letra da string:

    for (int i = 0; i < (int)strlen(palavra); i += 1)

E tem esse if()

        if (ref[palavra[i]] == 1)
            n_vogais += 1;
        else
            if (ref[palavra[i]] == 2)
                n_espacos += 1;

onde está consultando a tabela duas vezes e calculando dois índices: primeiro palavra e depois ref[palavra] e é claro que não precisa. Pode ser que o compilador perceba e otimize isso mas pode ser que não.

Algo bem melhor

#define _CRT_SECURE_NO_WARNINGS

#include "memory.h"
#include "stdio.h"

int main(int argc, char** argv)
{
    char ref[256];
    memset(ref, 0, 256);
    ref['a'] = ref['e'] = ref['i'] = ref['o'] = ref['u'] = 1;
    ref['A'] = ref['E'] = ref['I'] = ref['O'] = ref['U'] = 1;
    ref[' '] = 2;
    char palavra[80];
    printf("Digite uma string: ");
    fgets(palavra, 80, stdin);
    int len = strlen(palavra) - 1;
    palavra[len] = 0;
    printf("Palavra: [%s] tamanho: '%d'\n", palavra, len);

    int n_vogais = 0;
    int n_espacos = 0;
    char letra = 0;
    for (int i = 0; i < len; i += 1)
    {
        letra = ref[palavra[i]];
        if (letra == 1)
            n_vogais += 1;
        else
            if (letra == 2)
                n_espacos += 1;
    };  // for()
    printf("Sao %d vogais e %d espacos\n", n_vogais, n_espacos);
    return 0;
};  // main()

Muito melhor assim: declara uma variável letra fora do loop e dentro faz a conta uma vez só. E o for() tem um valor constante na condição de saída e não um strlen().

Mas estamos usando strings e usando int. Não é preciso e pode sair caro em termos de memória e tempo de pesquisa. Podemos usar apenas char.

Algo melhor ainda

#define _CRT_SECURE_NO_WARNINGS

#include "memory.h"
#include "stdio.h"

int main(int argc, char** argv)
{
    char ref[256];
    memset(ref, 0, 256);
    ref['a'] = ref['e'] = ref['i'] = ref['o'] = ref['u'] = 1;
    ref['A'] = ref['E'] = ref['I'] = ref['O'] = ref['U'] = 1;
    ref[' '] = 2;
    char palavra[80];
    printf("Digite uma string: ");
    fgets(palavra, 80, stdin);
    char len = strlen(palavra) - 1;
    palavra[len] = 0;
    printf("Palavra: [%s] tamanho: '%d'\n", palavra, len);

    char n_vogais = 0;
    char n_espacos = 0;
    char letra = 0;
    for (char i = 0; i < len; i += 1)
    {
        letra = ref[palavra[i]];
        if (letra == 1)
            n_vogais += 1;
        else
            if (letra == 2)
                n_espacos += 1;
    };  // for()
    printf("Sao %d vogais e %d espacos\n", n_vogais, n_espacos);
    return 0;
};  // outro()

Assim usa um byte e não 4 como um int e as comparações ficam mais rápidas com tudo operando em bytes.
Se precisasse rodar em um mínimo de tempo acho que seria essa a opção.
Se precisa avaliar mais condições você apenas altera o if e a tabela. É comum usar valores em potência de 2 e são chamados bit masks na literatura. Isso porque assim você pode testar por várias condições no mesmo valor usando operadores lógicos and &, or &, xor ^^ , not ! ...

Cordas · 18 de abril de 2020

2 horas atrás, arfneto disse:

Olá! Espero que tenha corrigido os erros todos já. E esse erro de concordância na mensagem do total deveria sumir também, afinal total é singular.

Assim é: menor não significa muito. Legibilidade em especial num projeto grande conta muito. Num programa de estudante também. Mas no fim eficiência em termos de uso de memória e em tempo de execução são as condições que decidem como implementar um programa real.

Esse exemplo:

Um caso como esse geralmente é mais eficiente resolver com uma tabela de referência. É assim que os compiladores fazem, os processadores e tal. Você cria uma tabela e não compara mais. Só pega o resultado na tabela. look-up table é o que costuma aparecer nos livros.

Uma solução comum seria assim:


#define _CRT_SECURE_NO_WARNINGS
#include "memory.h"
#include "stdio.h"

int main(int argc, char** argv)
{
    char ref[256];
    memset(ref, 0, 256);
    int n_vogais = 0;
    int n_espacos = 0;
    ref['a'] = ref['e'] = ref['i'] = ref['o'] = ref['u'] = 1;
    ref['A'] = ref['E'] = ref['I'] = ref['O'] = ref['U'] = 1;
    ref[' '] = 2;
    char palavra[80];
    printf("Digite uma string: ");
    fgets(palavra, 80, stdin);
    int len = strlen(palavra) - 1;
    palavra[len] = 0;
    printf("Palavra: [%s] tamanho: '%d'\n", palavra, len);
    for (int i = 0; i < (int)strlen(palavra); i += 1)
        if (ref[palavra[i]] == 1)
            n_vogais += 1;
        else
            if (ref[palavra[i]] == 2)
                n_espacos += 1;
    printf("Sao %d vogais e %d espacos\n", n_vogais, n_espacos);
    return 0;
};  // o_comum

Mas pode melhorar um pouco... está chamando strlen() duas vezes, e uma delas é no teste do for() então vai chamar isso para cada letra da string:


    for (int i = 0; i < (int)strlen(palavra); i += 1)

E tem esse if()


        if (ref[palavra[i]] == 1)
            n_vogais += 1;
        else
            if (ref[palavra[i]] == 2)
                n_espacos += 1;

onde está consultando a tabela duas vezes e calculando dois índices: primeiro palavra e depois ref[palavra] e é claro que não precisa. Pode ser que o compilador perceba e otimize isso mas pode ser que não.

Algo bem melhor


#define _CRT_SECURE_NO_WARNINGS

#include "memory.h"
#include "stdio.h"

int main(int argc, char** argv)
{
    char ref[256];
    memset(ref, 0, 256);
    ref['a'] = ref['e'] = ref['i'] = ref['o'] = ref['u'] = 1;
    ref['A'] = ref['E'] = ref['I'] = ref['O'] = ref['U'] = 1;
    ref[' '] = 2;
    char palavra[80];
    printf("Digite uma string: ");
    fgets(palavra, 80, stdin);
    int len = strlen(palavra) - 1;
    palavra[len] = 0;
    printf("Palavra: [%s] tamanho: '%d'\n", palavra, len);

    int n_vogais = 0;
    int n_espacos = 0;
    char letra = 0;
    for (int i = 0; i < len; i += 1)
    {
        letra = ref[palavra[i]];
        if (letra == 1)
            n_vogais += 1;
        else
            if (letra == 2)
                n_espacos += 1;
    };  // for()
    printf("Sao %d vogais e %d espacos\n", n_vogais, n_espacos);
    return 0;
};  // main()

Muito melhor assim: declara uma variável letra fora do loop e dentro faz a conta uma vez só. E o for() tem um valor constante na condição de saída e não um strlen().

Mas estamos usando strings e usando int. Não é preciso e pode sair caro em termos de memória e tempo de pesquisa. Podemos usar apenas char.

Algo melhor ainda


#define _CRT_SECURE_NO_WARNINGS

#include "memory.h"
#include "stdio.h"

int main(int argc, char** argv)
{
    char ref[256];
    memset(ref, 0, 256);
    ref['a'] = ref['e'] = ref['i'] = ref['o'] = ref['u'] = 1;
    ref['A'] = ref['E'] = ref['I'] = ref['O'] = ref['U'] = 1;
    ref[' '] = 2;
    char palavra[80];
    printf("Digite uma string: ");
    fgets(palavra, 80, stdin);
    char len = strlen(palavra) - 1;
    palavra[len] = 0;
    printf("Palavra: [%s] tamanho: '%d'\n", palavra, len);

    char n_vogais = 0;
    char n_espacos = 0;
    char letra = 0;
    for (char i = 0; i < len; i += 1)
    {
        letra = ref[palavra[i]];
        if (letra == 1)
            n_vogais += 1;
        else
            if (letra == 2)
                n_espacos += 1;
    };  // for()
    printf("Sao %d vogais e %d espacos\n", n_vogais, n_espacos);
    return 0;
};  // outro()

Assim usa um byte e não 4 como um int e as comparações ficam mais rápidas com tudo operando em bytes.
Se precisasse rodar em um mínimo de tempo acho que seria essa a opção.
Se precisa avaliar mais condições você apenas altera o if e a tabela. É comum usar valores em potência de 2 e são chamados bit masks na literatura. Isso porque assim você pode testar por várias condições no mesmo valor usando operadores lógicos and &, or &, xor ^^ , not ! ...

Cara, você é professor de programação? Muito bem esclarecedor.

Eu aproveito o gancho dessa questão mas para outro contexto. No caso com array.

Vê esse exemplo. A intenção é somente imprimir os dias da semana e indicar que os dias estão baseados na posição do array. Está correto dessa maneira?

#include <iostream>

int main(){

char * dayWeek[] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
for(int i = 0; i <= 6; ++i){
    std::cout << +i << " " << dayWeek[i] << std::endl;
}
return 0;
}

Saída:

AdrianoSiqueira · 18 de abril de 2020

5 horas atrás, arfneto disse:

ref['a'] = ref['e'] = ref['i'] = ref['o'] = ref['u'] = 1;

Um vetor que usa char como índice? Isso eu nunca vi... Como eu disse em outro tópico: Coisas que não se aprende na faculdade.

arfneto · 18 de abril de 2020

3 horas atrás, Cordas disse:
Cara, você é professor de programação? Muito bem esclarecedor.

Eu aproveito o gancho dessa questão mas para outro contexto. No caso com array.

Vê esse exemplo. A intenção é somente imprimir os dias da semana e indicar que os dias estão baseados na posição do array. Está correto dessa maneira?
#include <iostream>

int main(){

char * dayWeek[] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
for(int i = 0; i <= 6; ++i){
    std::cout << +i << " " << dayWeek[i] << std::endl;
}
return 0;
}
Saída:

A resposta curta é sim. Está correto.

Em C++ use a classe string e vector e tal. Conforme seus programas ficarem maiores vai achar mais simples e produtivo

Veja esse resultado

Sunday
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday

Com o indice

0 Sunday
1 Monday
2 Tuesday
3 Wednesday
4 Thursday
5 Friday
6 Saturday

Desse programa

#include <iostream>
#include <vector>

int main() {

    std::vector<std::string> dayWeek =
    { 
        "Sunday",
        "Monday",
        "Tuesday", 
        "Wednesday", 
        "Thursday",
        "Friday", 
        "Saturday"
    };

    for (auto day : dayWeek)
        std::cout << day << std::endl;

    std::cout << "\nCom o indice\n" << std::endl;

    for (auto i = 0; i<dayWeek.size(); i+=1)
        std::cout <<
            i << " " << dayWeek[i] << std::endl;

    return 0;
}

Que faz duas vezes a mesma coisa só para mostrar o for com iteração automática e o vector faz muito mais coisas que o char*.

--- --- ---

Então @AdrianoSiqueira na verdade não era pra ser confuso. É uma técnica comum. A multiplicação por exemplo usa tabelas nos processadores. A tabela de referência na verdade é essa ref[]

    char ref[256];
    memset(ref, 0, 256);
    ref['a'] = ref['e'] = ref['i'] = ref['o'] = ref['u'] = 1;
    ref['A'] = ref['E'] = ref['I'] = ref['O'] = ref['U'] = 1;
    ref[' '] = 2;

E normalmente você teria os 256 na tabela e com os valores já arrumadinhos para a lógica. Só aqui são só 11 e aí bate uma preguiça de preencher a tabela toda...

Na verdade o índice é a tabela. Nessa linha está o processamento todo:

        letra = ref[palavra[i]];

e em um char tem 256 posições então na tabela tem o resultado de cada possível conteúdo de letra...

Entendeu que é melhor usar um char para guardar a letra do que fazer toda essa referência duas vezes não?

Eu poderia ter colocado tipo ref[32] = 2 para o espaço, mas fica mais difícil de ler...

Cordas · 18 de abril de 2020

39 minutos atrás, arfneto disse:


#include <iostream>
#include <vector>

int main() {

    std::vector<std::string> dayWeek =
    { 
        "Sunday",
        "Monday",
        "Tuesday", 
        "Wednesday", 
        "Thursday",
        "Friday", 
        "Saturday"
    };

    for (auto day : dayWeek)
        std::cout << day << std::endl;

    std::cout << "\nCom o indice\n" << std::endl;

    for (auto i = 0; i<dayWeek.size(); i+=1)
        std::cout <<
            i << " " << dayWeek[i] << std::endl;

    return 0;
}

Que faz duas vezes a mesma coisa só para mostrar o for com iteração automática e o vector faz muito mais coisas que o char*.

rpz isso é massa d+. Valeu vou dar uma estudada nisso também.

AdrianoSiqueira · 18 de abril de 2020

1 hora atrás, arfneto disse:

na verdade não era pra ser confuso.

1 hora atrás, arfneto disse:

e em um char tem 256 posições

Me esqueci que char é compatível com int .

Então você declara um vetorzão que contém posições suficientes para referenciar qualquer valor que o código ASCII do char possa pedir? Aí você inicia só as posições que importam?

Midori · 18 de abril de 2020

...

arfneto · 18 de abril de 2020

30 minutos atrás, AdrianoSiqueira disse:

Me esqueci que char é compatível com int .

char short int long tem a mesma codificação. Só muda o sizeof().

32 minutos atrás, AdrianoSiqueira disse:

Então você declara um vetorzão que contém posições suficientes para referenciar qualquer valor que o código ASCII do char possa pedir

Exato. Mas...No caso são só 256 o que é nada. E é muito, mas muito mais rápido que usar funções. Pode ser centenas ou milhares de vezes mais rápido dependendo das operações que você faz. Acessar e manipular bytes em processadores é a coisa mais rápida e fundamental que se faz

33 minutos atrás, AdrianoSiqueira disse:

Aí você inicia só as posições que importam?

Não. Você inicializa absolutamente todas sempre ou vai dar m. Nesse caso aqui os valores são zero, 1 ou 2. É que (256 - 11) eram 0 e usei um memset() que é ultra-rápido. E atribui nos outros casos. É só um brinquedo. Se fosse um programa de produção você entraria com a tabela pronta em tempo de compilação para economizar ainda mais um tempinho...

Algo assim, que eu copiei de um programa claro

const char ref[256] =
{
  0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
  1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
  1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
  1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
  3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
  1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
  3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
  3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
  3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
  4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
};

Seria só trocar todos de acordo. Sei que já entendeu. E gente como nós faz um programa para gerar um trecho de código certinho e alinhado.

Você já conhece a tabela então não vai esperar rodar o programa para atribuir o que você já sabe.

E pode combinar condições usando os bits dentro da tabela. Veja o caso da tabela ASCII: a diferença entre maiúscula e minúscula é 32. A diferença de você apertar Control é zerar os primeiros 3 bits: control A é 1, control Z 26.

Então

    letra = 'a';

    letra_minuscula = letra | 0x20;

    control_letra = letra & 0x3F;

coisas assim. Essa função C para Windows abaixo por exemplo nem vou dizer o que ela faz. Faz parte de um conjunto que eu escrevi para meu uso em último caso. Veja os bitmasks lá no meio...

void	mensagem_em_video_reverso(char* mensagem)
{
	HANDLE	H = GetStdHandle(STD_OUTPUT_HANDLE);
	CONSOLE_SCREEN_BUFFER_INFO		info;
	GetConsoleScreenBufferInfo(H, &info);
	WORD foreground = info.wAttributes & 0xF;
	WORD background = info.wAttributes & 0xF0;
	text_color(background, foreground);
	printf("%s", mensagem);
	text_color(foreground, background);
	return;
}