C criar código c associando letras a-z e num 1-26 e somar a palavra no final

bilbol · 23 de fevereiro de 2021

é mais ou menos como descrito no titulo, quero criar um código que associe cada numero a letra em ordem crescente a=1, b=2 até z=26;

e ao rodar ele peça para voce digitar uma palavra dai ele faz a soma das letras dessa palavra.

ex.: baba = 6 porque b=2 a=1 =b2 a=1

.if · 23 de fevereiro de 2021

Mostre o que você tentou fazer. Dica: cada letra tem seu código numérico asc-ii. Uma subtração simples converte de letra pro número que você quer.

bilbol · 23 de fevereiro de 2021

51 minutos atrás, .if disse:

Mostre o que você tentou fazer. Dica: cada letra tem seu código numérico asc-ii. Uma subtração simples converte de letra pro número que você quer.

o problema é na hora de ler a palavra e somar, não faço a menor ideia como fazer funcionar de forma que a quantidade de letras fique dinamico sem compremeter o calculo

51 minutos atrás, .if disse:

Mostre o que você tentou fazer. Dica: cada letra tem seu código numérico asc-ii. Uma subtração simples converte de letra pro número que você quer.

@.if <code> #include <stdio.h>

const char numero[]="abcdefghijklmnopqrstuvwxyz";

int main (){
    int i=0;
     int valorfinal[140];
    char a,b,c,d,e,f,g,h;
    int soma;

    while(++i){
        if(numero[i-1]==0) break;
       valorfinal[i+96] = numero[i-1]-('a'-1);

}

printf("meu caro amigo diga o que queres:");
scanf("%c%c%c%c",&a,&b,&c,&d);
soma = valorfinal[a] + valorfinal[b]+ valorfinal[c]+ valorfinal[d];
printf("%d",soma);} <code>

eu sei que meu calculo esta zoado, um exemplo é se voce digitar 3 letras ou menos e deixar um espaço em branco, ele vai bugar, queria saber como resolver isso, só consegui ver o índice do vetor (ex.: valorfinal -> [ ] <- ) como meio pra fazer a associação entre letra e numero e usar como calculo

arfneto · 23 de fevereiro de 2021

31 minutos atrás, bilbol disse:

o problema é na hora de ler a palavra e somar, não faço a menor ideia como fazer funcionar de forma que a quantidade de letras fique dinamico sem compremeter o calculo

apenas uma tabela. x = f(x). São 256 valores possiveis para cada "letra" afinal.

bilbol · 23 de fevereiro de 2021

11 minutos atrás, arfneto disse:

apenas uma tabela. x = f(x). São 256 valores possiveis para cada "letra" afinal.

@arfneto não entendo o que diz, só conheço o básico do c, como if switch while, printf essas coisas

arfneto · 23 de fevereiro de 2021

34 minutos atrás, bilbol disse:

@arfneto não entendo o que diz, só conheço o básico do c, como if switch while, printf essas coisas

É bem mais básico que isso. Não tem nenhum comando. Só uma tabela...

arfneto · 24 de fevereiro de 2021

a bem da verdade, se sabe que s

ó vai usar essas 26 letras e em sequência não precisa de nada. Para cada letra em

    char letra;

o valor será

    int valor = letra - 'a' + 1;

para a entre 'a' e 'z' inclusive, e 0 para qualquer outro valor. Quando letra for 'a' a conta vai dar 'a' - 'a' + 1 que é o esperado 1

Mas na prática como tem que testar todas as letras para ver se estão no intervalo pode ser mais simples e MUITO mais rápido simplesmente usar a tabela.

E uma conta simples. Matemática, uma planilha apenas. y = f(x). Expliquei algo similar aqui hoje: como tem que testar todas as letras pode somar sempre e assim não precisa testar NUNCA.

Vou até postar um exemplo ao final, não como a solução para seu caso mas como uma solução usando uma técnica comum em C e Assembler, porque é muito rápido e não tem contas ou comparações.

De volta ao seu programa

quase nada do que escreveu faz sentido desde esses <code> no meio do código. Não é assim que funciona...

const char numero[]="abcdefghijklmnopqrstuvwxyz";

int main (){
    int i=0;
    int valorfinal[140];
    char a,b,c,d,e,f,g,h;
    int soma;

    while(++i)
    {
       if(numero[i-1]==0) break;
       valorfinal[i+96] = numero[i-1]-('a'-1);
    }

Muito bom ter usado const char[] para o vetor numero: é esperto declarar como tal tudo que sabe que deve ser constante. Mas como vai usar todas as letras em seguida os códigos também estarão em seguida, de 97 a 126 inclusive. Não precisa deles todos, de 'a' = 97 em diante...

Mas

se quer apenas a soma, que d1@b0 pretende com um vetor de 140 int chamado valorfinal?
porque declarou esses 8 char se vai usar apenas um por vez?
porque razão não deu um valor inicial a soma? Tipo 0? Coo vai saber se está certo se não sabe de onde começou?
que pretende com while(i++) se i começa com zero? claro que não vai parar nunca
e essa conta? numero[i-1] é a letra do vetor constante. Se está subtraindo depois de somar porque não comecóu com i igual a 1 e somou depois?
que pretende com scanf() lendo 4 letras por vez? Porque não duas? ou 5? ou 12?
porque não testa o retorno de scanf()? não faz sentido seguir sem ler p0rr@ nenhuma. scanf(%c%c%c%c.....) pode retornar o que? -1, 0, 1, 2 3 ou 4. E aí? Não faz diferença?
e depois soma 4 valores sem saber se leu ao menos 1
e o infeliz que vai ler "meu caro amigo diga o que queres"... Como ele vai adivinhar que ode digitar 4 letras? Percepção extrasensorial?

São muitas coisas para você considerar...

Um exemplo:

Claro que para "a111z" o valor deve ser 27 então esse programa

#include <stdio.h>
char parcela[256]= {0}; // tudo zerado

int main( void )
{
    int soma = 0;
    // arruma o vetor antes de tudo
    for( int i='a'; i <='z';i+=1) parcela[i] = i - 'a' + 1;

    const char* linha_de_teste = "a111z";
    char* p = (char*) linha_de_teste; // a primeira letra, 'a'
    while ( *p != 0 )
    {    // soma o valor correspondente a letra, como esta na tabela
        soma = soma + parcela[ (int) *p ];
        p = p+1; // avanca para a letra seguinte
    };  // while()
    printf("    Para '%s' a soma calculada foi %d\n", linha_de_teste, soma );    
    return 0;
}

Deve mostrar

toninho@DSK-2009:~/projects/um$ gcc -o tst -Wall -std=c17 f.c
toninho@DSK-2009:~/projects/um$ ./tst
    Para 'a111z' a soma calculada foi 27
toninho@DSK-2009:~/projects/um$

Assim é.

Teste seu programa sempre com constantes e valores conhecidos antes de perder tempo lendo valores e escrevendo coisas na tela. Depois de ter alguma esperança do resultado pode colocar a leitura...

Outro exemplo:

Já que funcionou agora pode usar recortar e colar e criar outro programa que lê a string e mostra a soma... Sem destruir o programa anterior. É de graça. Não precisa fazer um programa só. Ninguem vai saber.

#include <stdio.h>
#include <stdlib.h>
char parcela[256]= {0}; // tudo zerado

int main( void )
{
    int soma = 0;
    // arruma o vetor antes de tudo
    for( int i='a'; i <='z';i+=1) parcela[i] = i - 'a' + 1;

    // desta vez vai ler da console ate vir uma linha em branco
    char    linha[80];

    printf("Entre com a linha para ver a soma: ");
    fgets(linha,80,stdin);
    char* p = linha; // p aponta prara a primeira letra
    while ( *p != 0 ) // 0 marca o fim da string
    {
        soma = soma + parcela[ (int) *p ];
        p = p + 1;
    }
    printf("\nA soma calculada foi %d\n", soma );    
    return 0;
}

O loop é o mesmo mas usa fgets() para ler a linha toda...

toninho@DSK-2009:~/projects/um$ gcc -o tst -Wall -std=c17 f2.c
toninho@DSK-2009:~/projects/um$ ./tst
Entre com a linha para ver a soma: a

A soma calculada foi 1
toninho@DSK-2009:~/projects/um$ ./tst
Entre com a linha para ver a soma: a z

A soma calculada foi 27
toninho@DSK-2009:~/projects/um$ ./tst
Entre com a linha para ver a soma: a1111a111a3z

A soma calculada foi 29
toninho@DSK-2009:~/projects/um$ 
toninho@DSK-2009:~/projects/um$

Exemplo 3:

Mais recortar e colar guardando f.c e f2.c

Esse é mais prático, como se espera de um programa em apenas passa o valor na linha de comando, usando aspas se ele tiver espaços, claro:

#include <stdio.h>
#include <stdlib.h>
char parcela[256]= {0}; // tudo zerado

int main( int argc, char** argv )
{
    if ( argc < 2 )
    {
        printf( "passe o valor na linha do programa!!\n");
        return -1;
    };  // if()

    int soma = 0;
    // arruma o vetor antes de tudo
    for( int i='a'; i <='z';i+=1) parcela[i] = i - 'a' + 1;

    char* p = &argv[1][0]; // p aponta para a primeira letra do argumento
    while ( *p != 0 ) // 0 marca o fim da string
    {
        soma = soma + parcela[ (int) *p ];
        p = p + 1;
    }
    printf("\nA soma calculada foi %d\n", soma );    
    return 0;
}

E mostra

toninho@DSK-2009:~/projects/um$ gcc -o tst -Wall -std=c17 f3.c
toninho@DSK-2009:~/projects/um$ ./tst
passe o valor na linha do programa!!
toninho@DSK-2009:~/projects/um$ ./tst abab

A soma calculada foi 6
toninho@DSK-2009:~/projects/um$ ./tst "a a a a 1 1 1 1"

A soma calculada foi 4

.if · 24 de fevereiro de 2021

Olha a tabela asc-ii

Para transformar 'a' em 1 basta subtrair-lhe 96 algo como 'a'-96=1

// Online C compiler to run C program online
#include <stdio.h>
const char numero[]="abcdefghijklmnopqrstuvwxyz";
unsigned char num1,num2,num26;
int main() {
    // Write C code here
    num1=numero[0]-96;
    printf("%d\n",num1);
    num2=numero[1]-96;
    printf("%d\n",num2);
    num26=numero[25]-96;
    printf("%d\n",num26);
    return 0;
}

teste em

https://www.programiz.com/c-programming/online-compiler/

Que lhe sirva de norte

bilbol · 24 de fevereiro de 2021

19 minutos atrás, .if disse:

Olha a tabela asc-ii

Para transformar 'a' em 1 basta subtrair-lhe 96 algo como 'a'-96=1


// Online C compiler to run C program online
#include <stdio.h>
const char numero[]="abcdefghijklmnopqrstuvwxyz";
unsigned char num1,num2,num26;
int main() {
    // Write C code here
    num1=numero[0]-96;
    printf("%d\n",num1);
    num2=numero[1]-96;
    printf("%d\n",num2);
    num26=numero[25]-96;
    printf("%d\n",num26);
    return 0;
}

teste em

https://www.programiz.com/c-programming/online-compiler/

Que lhe sirva de norte

eu ja estou ciente disso eu só não sei como eu faço pra associar a leitura de uma palavra com o calculo da soma tipo printf("Digite um nome"); scanf("%c", nome); printf("%d", somadasletrasdonome);

.if · 24 de fevereiro de 2021

Outro norte...

Um modo minimalista (não testado) ainda usando seu número[ ]

unsigned int i=0,num=0;
while (numero[i++]) num+=numero[i];

... e já ia esquecendo... de nada

arfneto · 24 de fevereiro de 2021

1 hora atrás, .if disse:

Que lhe sirva de norte

Pode ser usado, mas como eu mostrei não precisa da tabela. 'a' vale 'a', basta isso. e a conta é letra - 'a' + 1 apenas, para 'a' entre 97 e 126 inclusive, só que isso não faz diferença. Veja os 3 exemplos que eu mostrei acima...

1 hora atrás, bilbol disse:

eu ja estou ciente disso eu só não sei como eu faço pra associar a leitura de uma palavra com o calculo da soma tipo printf("Digite um nome"); scanf("%c", nome); printf("%d", somadasletrasdonome);

Não leu os 3 exemplos que eu mostrei? E a relação de problemas com seu código inicial? São programas funcionais com a execução logo abaixo...

bilbol · 24 de fevereiro de 2021

@arfneto primeiramente muito obrigado pela resolução, vi que voce colocou funções extras que eu não conhecia e nem pretendia usar como o char * (não sei o porque desse asterisco) e stdin. Então me diga, seria impossivel fazer este código utilizando apenas loop, printf e scanf? e usando somente int e char sem esse asterisco que eu n sei para o que é.

arfneto · 24 de fevereiro de 2021

58 minutos atrás, bilbol disse:

char * (não sei o porque desse asterisco) e stdin. Então me diga, seria impossivel fazer este código utilizando apenas loop, printf e scanf? e usando somente int e char sem esse asterisco que eu n sei para o que é

O modo que te mostrei, e mostrei 3 programas, é o normal. O que vai encontrar nos livros e nas empresas e o que roda mais rápido. stdin é o nome da entradaem C, o teclado. E deve imaginar que você devia saber isso, porque você devia: todo programa em C começa com 3 arquivos abertos, stdin, stdout e stderr, a entrada, a saída e a saída de erro.

char* indica um ponteiro para um char, como int* indicaria um ponteiro para um int. E o asterisco indica o valor que está dentro do endereço. O contrário disso seria o operador &. Então por exemplo

	int     a = 12;
	int*	pInt = &a;
	int     b = *pInt;

a vale 12. e pInt é um ponteiro para int.
O valor inicial dele é o endereço de a.
b é int e o valor inicial dele é o valor de um int cujo endereço está em pInt, e assim b também vale 12

Você não vai conseguir nada em C ou C++ sem entender esse lance de ponteiro e endereço. Ao invés de tentar resolver sem isso estude isso.

Se não entendeu nada dos 3 programas que eu te mostrei pergunte aqui pela linha específica...

.if · 24 de fevereiro de 2021

Encerrando minha participação pois o garoto já reconheceu e agradeceu seu mestre, como deve ser...

A tabela asc-ii foi uma tentativa frustrada para lhe mostrar a origem numérica dos caracteres alfanuméricos. Talvez (só talvez) com sua visualização ele perceberia que poderia converter outros caracteres em números e fazer a matemática que quiser. Mas enfim, já vi que dei com os burros n'água (clique se desejar)

Mas mesmo assim senti vontade testar isso - que penso ser o cerne da dúvida do garoto - pra treinar o tico e teco no aspecto minimalismo... sem comentários

const char *numero="abcde";
usigned int soma=0;

int main() {
printf("soma= ");
while (*numero) soma+=*numero++ - 96;
printf("%d",soma);
  
    return 0;
}

E também pra tentar relembrar o conceito de ponteiros, vetores e afins que pra mim são as entidades mas sinistras do c que até hoje me assustam.

Boa sorte

arfneto · 24 de fevereiro de 2021

3 horas atrás, .if disse:

A tabela asc-ii foi uma tentativa frustrada para lhe mostrar a origem numérica dos caracteres alfanuméricos

Faz todo sentido usar a tabela ASCII --- dos anos 60 como a tabela EBCDIC --- para mostrar que números como 48 para '0' ou '65' para 'A' não são entidades sobrenaturais e tem uma razão de ser. Ainda mais quando o mundo está ficando tão complicado que a tabela atual de caracteres, chamada Unicode, tem capacidade para pouco mais de 1,1 milhão de letras e acho que cerca de 150.000 já estão em uso

Sobre asc-ii

Já vi isso escrito como ASC2 ou ASC-2 também, e já ouvi. No entanto lembro que o 'II' indica Information Interchange e não o número 2 em algarismos romanos como o hífen sugere.

Sobre o programa

@.if espero que não se importe, mas vou usar seu programa para mostrar umas coisas comuns que podem passar despercebidas em C por um tempo quando se está aprendendo

Estas são duas versões do (seu) mesmo programa. Em geral é legal incluir tudo, inclusive os #include, de modo que o usuário do forum possa rapidamente recortar e colar o texto e compilar em sua máquina. Apenas para aproveitar a oportunidade ...

    const char *numero  ="abcde";

Esse vetor na verdade é a palavra que o usuário quer traduzir, e talvez "numero" não seja um bom nome. À direita está como palavra e fica mais claro que o objetivo do programa é obter soma a partir de palavra.

É muito importante evitar o uso de variáveis globais, coisas que foram declaradas fora de main() porque ficam válidas durante toda a execução do programa. Isso é proibido em muitos círculos e é um risco de segurança e gera incontáveis problemas.

No programa à direita as declarações estão dentro de main()

O que se está declarando nessa linha? numero. E numero é const char*. É isso que está sendo declarado. É claro que se numero é um ponteiro para char *numero é um char, e a declaração é entendida pelo compilador. Mas para o leitor, em especial o leitor aluno, é melhor deixar clara a realidade: numero é const char* e declarar

    const char*    numero  ="abcde";

while (*numero) soma+=*numero++ - 96;

Essa linha pode parecer assustadora para iniciantes porque envolve uma série de coisas que muitas vezes o cara não sabe. E omite algumas que o cara pode demorar para entender, como a noção de prioridade de operadores.

a condição de saída do loop: *numero
- qual o tipo de numero? numero é const char*
- então *numero é um char, o char que o programa encontra a partir do valor em numero, a noção de ponteiro afinal. Como um envelope com um valor. Em numero tem um valor, um endereço. E nesse endereço tem um char. E o valor dele é *numero. C.
- Em C 0 e falso e todo o resto é verdadeiro. O loop while então vai rodar enquanto o valor apontado por numero for diferente de zero. Dentro do loop o valor de numero muda, apontando para as sucessivas letras de numero, e fica claro que o nome numero não está bom.
- a condição então seria, por extenso
```
	while ( *numero != 0 )
```
  e isso funciona porque ao final de toda string tem um zero e o compilador monta isso ao ler numero = "abcde" colocando um zero depois do 'e'. Isso desde que dentro do loop o valor de numero seja incrementado
- o corpo do loop: o while vai rodar tudo até o próximo ';', ou seja soma+=*numero++ - 96;
- claro que isso equivale a
```
    while (*numero) { soma+=*numero++ - 96 };
```
  com as chaves deixando claro o intervalo. Linhas em branco não fazem diferença.
- o número mágico 96: as letras tem códigos em sequência como estão na tabela, entre 97 e 126 inclusive. Se 'a' vale 97 na tabela ASCII e o usuário quer atribuir o valor 1 para 'a' então o valor da letra apontada por numero deve ser 97 - 1, que é claro 96. 97 é o código de 'a' então é bem mais claro ler isso como
```
		'a' - 1
```
  e o compilador cuida d etrocar isso por 96. O programa gerado será claro o mesmo.
- 'soma += x' é a mesma coisa que 'soma = soma + x;' apenas é mais compacto em especial se sua variável tiver 12 letras . No entanto é mais difícil de ler.
- *numero++ é folclórico e comum em C. E em C++ está até no nome. Isso quer dizer que vai incrementar o valor depois de atribuir. A posição do ++ ou -- indica se vai operar antes ou depois de usar o valor.
```
    x = 12;
    y = x++;
    // aqui x = 13, mas y = 12
    y = ++x;
    // aqui y = 14, x = 14
  
```
  Não é assim um ganho enorme. É claro compacto mas pouco legível, E pode ter efeitos colaterais que lembram o que deve ser o 1nfern0.
  - Agora com *numero++ o cara tem que saber a prioridade: o programa vai rodar (*numero)++ ou *(*numero)++?
  - O asterisco tem prioridade e vai usar o valor apontado por numero primeiro, e depois somar um em numero adiantando o ponteiro para a próxima letra, e o código equivale a
```
 	// soma+=*numero++ - 96;
	// equivale a 

	soma = soma + *numero + 'a' - 1; // a = 97 em ASCII
	numero += 1; // passa para o proximo char
```
  - o loop todo poderia ser então
```
	while (*numero != 0)
	{
    	    soma = soma + *numero - 'a' + 1;
    	    numero += 1;
	}
```

Não é preciso usar dois printf() separados

O que é const char* p?

	const char* p  ="abcde";

Isso indica que numero aponta para um char, numero é char*. Podia ser declarado assim com o mesmo efeito

const char *numero  ="abcde";
const char igual[]  ="abcde";

mas char* e char[] não são a mesma coisa e isso é uma cosia difícil de C. Não vou discutir aqui porque nada tem a ver e já está muito comprido esse trem.

Mas isso quer dizer que p aponta para um char, e que não pode ser usado para alterar esse char... p não é const.

Exemplo

#include <stdio.h>

int main(void)
{

const char *valor  ="abcde";
const char outro[]  ="ABCDE";

const char* p = valor;
printf("Primeira letra: '%c'\n", *valor );
printf("Primeira letra: '%c' Segunda: '%c'\n", *p, *(p+1) );

p = outro;
printf("Primeira letra: '%c' Segunda: '%c'\n", *p, *(p+1) );
return 0;
}

Mas p não pode alterar nada...

*p = 'C';
valor[1] = 'Y';
outro[0] = 'A';

leva a

toninho@DSK-2009:~/projects/um$ gcc -o if -Wall -std=c17 if.c
if.c: In function ‘main’:
if.c:15:4: error: assignment of read-only location ‘*p’
   15 | *p = 'C';
      |    ^
if.c:16:10: error: assignment of read-only location ‘*(valor + 1)’
   16 | valor[1] = 'Y';
      |          ^
if.c:17:10: error: assignment of read-only location ‘outro[0]’
   17 | outro[0] = 'A';
      |          ^
toninho@DSK-2009:~/projects/um$

Conclusão: p pode apontar para outras coisas mas não pode alterar nada porque p é const char*

E se fosse char* const p = valor; ?

	char* const p = valor; // p = char* const, outra coisa

Aí p é o que? char* const. E é outro bicho: p aponta para char, pode alterar o valor. Mas não pode apontar para outra coisa...

Outro exemplo

#include <stdio.h>

int main(void)
{

char valor[]  = { "abcde" };
char outro[]  = { "abcde" };
char* const p = valor;
printf("Primeira letra: '%c'\n", *valor );
printf("Primeira letra: '%c' Segunda: '%c'\n", *p, *(p+1) );

// p = outro; // essa linha nao compila

*p = 'X';
*(p+1) = 'Y';
printf("Primeira letra: '%c' Segunda: '%c'\n", *p, *(p+1) );

return 0;
}

Esse programa roda ok:

toninho@DSK-2009:~/projects/um$ ./if
Primeira letra: 'a'
Primeira letra: 'a' Segunda: 'b'
Primeira letra: 'X' Segunda: 'Y'

E muda as letras. Mas se tirar o comentário da linha 12...

toninho@DSK-2009:~/projects/um$ gcc -o if -Wall -std=c17 if.c
if.c: In function ‘main’:
if.c:12:3: error: assignment of read-only variable ‘p’
   12 | p = outro; // essa linha nao compila
      |   ^
toninho@DSK-2009:~/projects/um$

E p não pode apontar para outra coisa...

E se usar os dois const?

	const char* const p = valor;

Aí como esperado valem as duas coisas: p só pode apontar para valor, e não pode ser usado para alterar nada.

Usando o programa de antes

#include <stdio.h>

int main(void)
{

char valor[]  = { "abcde" };
char outro[]  = { "abcde" };
const char* const p = valor;
printf("Primeira letra: '%c'\n", *valor );
printf("Primeira letra: '%c' Segunda: '%c'\n", *p, *(p+1) );

p = outro; // essa linha nao compila

*p = 'X';
*(p+1) = 'Y';
printf("Primeira letra: '%c' Segunda: '%c'\n", *p, *(p+1) );

return 0;
}

O compilador se queixa claro das duas situações

toninho@DSK-2009:~/projects/um$ gcc -o if -Wall -std=c17 if.c
if.c: In function ‘main’:
if.c:12:3: error: assignment of read-only variable ‘p’
   12 | p = outro; // essa linha nao compila
      |   ^
if.c:14:4: error: assignment of read-only location ‘*p’
   14 | *p = 'X';
      |    ^
if.c:15:8: error: assignment of read-only location ‘*(p + 1)’
   15 | *(p+1) = 'Y';
      |        ^
toninho@DSK-2009:~/projects/um$

Sugiro ler com cuidado. Mesmo profissionais costumam se enrolar com isso. veja a diferença nas mensagens de erro citando location e pointer no compilador gcc acima.