C Imprimir primeira e última letra da string

[immoraesz]

Como faço para imprimir a última letra de uma string? Só consigo imprimir a primeira ou todas as letras da palavra em questão.

Usando "printf("%c", str[i]);" dentro do for, eu imprimo todas as letras. Fora do for (do jeito que está), imprime só a primeira letra e no "Ultimo caractere" imprime a primeira letra novamente em vez da última.

 

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

int main(){
    
    char str[20];
    int i;
    
  	printf("Digite uma palavra: ");
    fgets(str,20,stdin);

        for(i = 0; str[i] != '\0'; i++){
        }
        
    printf("Primeiro caractere: %c\n",str[0]);
    printf("Ultimo caractere: %c\n",str['\0']);
       
    return 0;
}

 

[Alan Flanklyn]

@immoraesz Basicamente inclui a biblioteca stdlib.h que nos dá a função strlen, que com uma string como parâmetro nos retorna o tamanho daquela cadeia de caracteres, sendo assim, subtraindo em 2 a quantidade de espaços vazios, temos a ultima letra da string.

 

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

int main(){
    
    char str[20];
    int i,tam;
    
  	printf("Digite uma palavra: ");
    fgets(str,20,stdin);
    
    tam=strlen(str);
    
      printf("Primeiro caractere: %c\n",str[0]);
      printf("Ultimo caractere: %c\n",str[tam-2]);

    return 0;
}

 

[immoraesz]

@Alan Flanklyn Obrigado, meu patrão! Salvou!

[Alan Flanklyn]

@immoraesz Tmj!

[Lucca Rodrigues]

58 minutos atrás, Alan Flanklyn disse:

inclui a biblioteca stdlib.h que nos dá a função strlen

strlen() é da string.h.

 

58 minutos atrás, Alan Flanklyn disse:

subtraindo em 2 a quantidade de espaços vazios, temos a ultima letra da string

O último caractere da string é o '\0', ele em si serve pra indicar o final da string.

Na documentação da fgets() é dito:

Citação

The newline character, if read, is included in the string.

Se referindo ao índice, não há como garantir que subtrair 2 do valor retornado por strlen() funcionará em todos os casos: se o usuário digitar "dezenove caracteres", a saída será:

Isso é porque foram digitados 20 caracteres ao todo, incluindo o '\n' do Enter teclado ao finalizar a leitura, mas só há espaço para 19 sem incluir o '\0', então o '\n' fica de fora, e por essa você não esperava 

O que se pode fazer é verificar se há um '\n' na penúltima posição da string após ler com fgets(). Caso haja, o substituímos por um '\0', e caso não haja, podemos ler o que resta no fluxo:

char str[101];

if(fgets(str, sizeof(str), stdin) != NULL) {
    if(str[strlen(str) - 1] == '\n') {
        // '\n' na penultima posição da string
        str[strlen(str) - 1] = '\0';
    } else {
        int ch;
        // Lendo o que ha de resto
        while((ch = fgetc(stdin)) != '\n' && ch != EOF);
    }
}

Teste imprimir str[strlen(str) - 1] após a leitura, funcionará em qualquer caso:

 

1 hora atrás, immoraesz disse:

Usando "printf("%c", str[i]);" dentro do for, eu imprimo todas as letras

E entende como isso funciona?

O índice `i` é incrementado partindo de 0 até que seja encontrado o '\0' da string, de modo a imprimir todos os caracteres um a um.

Manualmente, basta escolher um valor de índice:

char str[] = "abcde";
// Imprime o caractere 'e' da string
// Localizado na posicao de indice 4
printf("%c", str[4]);

 

1 hora atrás, immoraesz disse:

printf("Ultimo caractere: %c\n",str['\0']);

Não é assim que funciona, pelo menos não da forma que imagina.

O valor decimal de '\0' é 0, como pode ver na tabela ASCII. Dessa forma você imprime o caractere na posição de índice 0.

[Ansi C]

@immoraesz Olá! Por razão única da entrada

1 hora atrás, Alan Flanklyn disse:

printf("Digite uma palavra: ");

 

Você mesma(o) [quase] responde sua pergunta "na pergunta". Bem aqui

1 hora atrás, immoraesz disse:

for(i = 0; str[i] != '\0'; i++){
        }

 

Qual posição, i, ocupa antes que alcance '\0' desse ‘loop’? A posição da última 'letra' na palavra!

Logo, a última letra é o índice [i - 1]

 

char ola_eu_sou_a_ultima_letra = palavra[i - 1];

[] 

[arfneto]

Em 13/01/2022 às 16:13, Alan Flanklyn disse:

 Basicamente inclui a biblioteca stdlib.h que nos dá a função strlen, que com uma string como parâmetro nos retorna o tamanho daquela cadeia de caracteres, sendo assim, subtraindo em 2 a quantidade de espaços vazios, temos a ultima letra da string.

 

Não entendi o que seria a "quantidade de espaços vazios". 

 

Mas considere que 

• se usa fgets() para ler a tal string pode ser que a última letra seja de fato a penultima posição da string. Porque? porque fgets() só armazena o '\n' se tiver espaço. Esse é um erro comum. Se o usuário digitar 10 para ler 10 não vai ter '\n'. Veja o que disse @Lucca Rodrigues
• não faz muito sentido usar strlen() se pensar bem a respeito. Porque: a letra que você quer obviamente está antes do 0. Assim não precisa chamar uma função para ver onde termina e depois voltar atrás. Use sua própria função que simplesmente te dê o resultado.
• Evite escrever '\0' ao invés do simples 0. Zero é zero. Para que 4 letras, com duas apóstrofes?
• Considere que a string possa estar vazia e assim não pode fazer conta nenhuma: o cara pode só ter teclado ENTER
• Pode ser limitante assumir que a leitura foi feita via fgets(). Se era uma função pode ter sido chamada de outro jeito

EXEMPLO 
 

   ultima_letra("E agora?"); 

 

ao invés de 
 

    unsigned char str[20];
    printf("Digite uma palavra: ");
    fgets(str, 5, stdin);
    unsigned char letra = ultima_letra(str);

 

E aí a última letra está de fato antes do 0.

 

Prefira algo simples como

 

unsigned char ultima_letra(unsigned char* pal)
{
    char* p = pal;
    if (pal == 0) return 0;      // vazia
    if (*pal == '\n') return 0;  // veio so ENTER
    while (*p != 0) p += 1;      // avanca ate o fim
    if (*(p - 1) == '\n') return *(p - 2);
    return *(p - 1);
};

 

que trata os casos limite e vai direto ao assunto.
 

Em 13/01/2022 às 16:59, Lucca Rodrigues disse:

O que se pode fazer é verificar se há um '\n' na penúltima posição da string após ler com fgets(). Caso haja, o substituímos por um '\0', e caso não haja, podemos ler o que resta no fluxo

 

Em geral é melhor não mexer com o que está lá. O resto do programa pode ter planos para o resto do que foi digitado.