C exercício com ponteiros em linguagem c

robson s martins · 17 de abril de 2020

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


 main(){

 char palavra[30],palavra2[30];

 char * pal,*copia;
 int cont=0,i;

 printf("Digite uma palavra:");
 gets(palavra);

 pal = palavra;

for (pal =palavra;*pal;pal++){
    cont++;
    for(copia=palavra2;;copia+=cont){
        copia = pal;
    }


    }
    printf(copia);
}

Preciso de uma ajuda para resolver este exercício:

Escrever um programa que leia uma string e crie uma nova string na qual as letras são replicadas de acordo com sua posição na string lida,
ou seja, a primeira letra é copiada uma vez, a segunda duas vezes, a terceira três vezes, e assim por diante.
Se for lida a string “hora”, por exemplo, a string criada deve ser “hoorrraaaa”. Faça a manipulação com ponteiros, sem usar índices.*/

S ei que a 2 string deve ser preenchida tantas vezes o valos do contador, conforme exemplo acima..

Tentei fazer o código..mas obtive sucesso agora. Alguém com alguma ideia, para me ajudar??

Lucca Rodrigues · 17 de abril de 2020

@robson s martins Achei interessante e tentei fazer meu próprio:

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

int main()
{
    char frase[50];
    int tamanho, i, c;
  
    printf ("Digite uma palavra: ");
    gets (frase);
    
    tamanho = strlen(frase);
    
    printf("\nTotal de letras da frase: %d", tamanho);
    
  	printf ("\nA nova string é:\n");
  
    for (i=0; i<tamanho; i++){
        for (c=i; c>=0; c--){
            putchar (frase[i]);
        }
    }
    
    return 0;
}

O primeiro laço é pra colocar uma letra de cada vez (se não tivesse o segundo, a string criada seria a mesma), e o segundo é pra repetir o putchar o tanto de vezes que corresponde ao contador i.

strlen() é uma função que pega uma string e te da o tamanho dela.

robson s martins · 17 de abril de 2020

sim,assim funciona..contudo conforme o exercicio, NAO se pode usar indice...e também deve-se usar ponteiros.

fora isso muito bom seu codigo

Lucca Rodrigues · 17 de abril de 2020

@robson s martins

5 minutos atrás, robson s martins disse:

conforme o exercicio, NAO se pode usar indice...e também deve-se usar ponteiros.

É aí que você entra.

Como gerar a string que você quer, eu já mostrei, agora é com você.

paulorx10 · 17 de abril de 2020

Codigo com ponteiro e vetores .

#include <stdio.h>
#include<string.h>
main() {
    char palavra[30], palavra2[30];
    char * pal, * copia;
    int cont=0,contj,i,j;
    printf("Digite uma palavra:");
    gets(palavra);
    pal = palavra;
    
    for (i =0; i < strlen(pal); i++){
     
     contj = i;
     
    for (j =contj; j >= 0; j--){
     
      palavra2[j] = palavra[i];
     
      copia = palavra2[j];
      printf("%c", copia);
    
     }
    
    }
  return 0;  
}

arfneto · 17 de abril de 2020

@paulorx10

    char palavra[30], palavra2[30];

Faltam algumas coisas para você considerar.

Não está de fato criando a string porque ela está já declarada aí. Provavelmente se espera que ela seja alocada
esse tamanho não vai ser suficiente.
está duplicando o newline que tem no fim ao invés de suprimir. testou com "hora"?
não pode usar índices. Veja o enunciado
```
    palavra2[j] = palavra[i];
```

@Lucca Rodrigues

Mas você

usou índices e não ponteiros
duplicou o '\n' do final ao invés de tirar
não criou a string

Lucca Rodrigues · 17 de abril de 2020

@arfneto Realmente to curioso pra ver como ficaria seu programa.

De qualquer forma, não era minha intenção fazer o algoritmo pro autor do post.

Como ele disse, "a 2° string deve ser preenchida tantas vezes o valor do contador". Fiz algo parecido. Todavia está errado segundo as especificações da questão, não contradigo isso.

herbertbahia · 17 de abril de 2020

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

int main()
{
    char frase[50];
    int tamanho, i, c;
    char *ponteiro;
    
    printf ("Digite uma palavra: ");
    gets (frase);
    
    tamanho = strlen(frase);
    ponteiro=frase;
  	printf ("\nA nova string:\n");
  
  
    for (i=0; i<tamanho; i++){
        for (c=i; c>=0; c--){
            printf("%c",ponteiro[i]);
        }
    }
}

AdrianoSiqueira · 17 de abril de 2020

Minha vez, eu quero tentar também KKKKKK

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

int main() {
    int tamanho = 30;

    char *palavra = malloc(tamanho * sizeof(char));

    printf("Digite algo: ");
    fgets(palavra, tamanho, stdin);
    palavra[strcspn(palavra, "\n")] = '\0';
    
    for (int i = 1; *palavra != '\0'; ++palavra, ++i) {
        for (int j = 0; j < i; ++j) {
            printf("%c", *palavra);
        }
    }

    return EXIT_SUCCESS;
}

arfneto · 17 de abril de 2020

Citação

leia uma string e crie uma nova string na qual as letras são replicadas de acordo com sua posição na string lida,
ou seja, a primeira letra é copiada uma vez, a segunda duas vezes, a terceira três vezes, e assim por diante.
Se for lida a string “hora”, por exemplo, a string criada deve ser “hoorrraaaa”. Faça a manipulação com ponteiros, sem usar índices.*/

S ei que a 2 string deve ser preenchida tantas vezes o valos do contador, conforme exemplo acima

@Lucca Rodrigues

Eis o que posso dizer sobre o enunciado e o programa que eu eu esperaria que fosse feito se eu o tivesse escrito (o enunciado)

Não fosse o texto começar por "leia uma string" o mais simples seria algo parecido com o que você fez, usando um único loop e gerando um número crescente de réplicas na string de saída, apenas alocando um número pequeno de bytes na entrada e aumentando aos poucos até terminar. E não usando índices, claro. Estão excluídos por definição.

Mas o texto começa por "ler uma string" e uma string é uma sequência de caracteres seguidas por um 0 então pode também ter espaços. Não vou considerar ler a string direto na linha de comando, algo como

programa.exe a string vem aqui toda

ou

programa.exe "a string vem aqui toda"

no windows por exemplo. Isso seria mais prático e fácil mas por algum mistério os professores ignoram a linha de comando e os alunos só usam o IDE... Talvez depois eu escreva isso para mostrar a diferença. É mais simples um pouco, já que o sistema traz as palavras separadas. Por isso eu vou deixar aqui o caso2() apenas

De volta ao programa, do jeito ortodoxo

Tradicionalmente se lê a string usando gets() ou fgets() e essas rotinas vão devolver a string com um '\n' no fim. É claro que você não vai repetir e n-uplicar esse infeliz no final da string então precisa considerar isso no final do loop
Calcular o tamanho da string remete ao ensino fundamental:
hora = hoorrraaaa 4 => 10, mas veja
```
a => a ou 1 => 1
ab => abb 2 => 1 + 2 = 3
abc => abbccc ==> 3 => 1 + 2 + 3 = 6
abcd => abbcccddd ==> 4 => 1 + 2 + 3 + 4 = 10
```
e assim por diante. Há muitos anos sabemos que isso é uma progressão aritmética de razão 1 e a soma é a soma do primeiro com o ultimo multiplicada pelo tamanho da série e divido por 2
```
para 2 =>  ((1+2) * 2) / 2 = 6/2 = 3
para 3 => (1+3) * 3) / 2 = 12/2 = 6
para 4 => (1+4) * 4 / 2 = 20/2 = 10
para n => (1+n)*n) / 2

Sem mistério
```
A string de saída vai ter então esse tamanho mas o 0, o tal null, '\0' do final para que ela seja de fato uma string.

Se você leu a string em palavra, veja essas variáveis meio que auto-explicativas

    char ultima_letra = palavra[strlen(palavra) - 1]; // essa letra deve ser o '\n'
    int ultimo = strlen(palavra) - 1; // na nova string nao tem o '\n'

	// e o limite sera entao
	int limite = (1 + ultimo) * ultimo / 2;

    // e o tamanho a alocar onclui o 0 no fim
    char* nova = (char*)malloc(limite + 1);

	// e em nova vai estar a string
    // se idx_e for o indice da entrada e 
	// ids_s for o da saida 
	// esse loop faz o serviço
    for (int idx_e = 0; idx_e < ultimo; idx_e += 1)
    {
        *(nova + idx_s) = *(palavra + idx_e); // copia a letra
        // avanca a saida
        idx_s += 1; 
        // a posicao indica o numero de replicas
        int nReplicas = idx_e; 
        for (int j = 0; j < nReplicas; j += 1, idx_s += 1)
            *(nova + idx_s) = *(palavra + idx_e); // replica
    };  // for()
    *(nova + idx_s) = 0; // termina a string de saida

Veja a saída de um programa com comentários e um gabarito na saída pra ajudar a contar as posições

Digite uma string: hora
    - Lidas 5 pos.
    - O ultimo valor da frase deve ser o tal newline '\n' codigo 10. Valor = '10'
    - E termina mesmo com newline
    - A entrada tem 4 letras: a saida vai ter 10 mais o '\0' no fim


                 0         1         2         3         4    *    5
                 0    *    0    *    0    *    0    *    0    *    0
Entrada:        [hora]
Saida:          [hoorrraaaa]

Uma saida para uma letra só

Digite uma string: a
    - Lidas 2 pos.
    - O ultimo valor da frase deve ser o tal newline '\n' codigo 10. Valor = '10'
    - E termina mesmo com newline
    - A entrada tem 1 letras: a saida vai ter 1 mais o '\0' no fim


                 0         1         2         3         4    *    5
                 0    *    0    *    0    *    0    *    0    *    0
Entrada:        [a]
Saida:          [a]

Ou para umas letras com espaço no meio

Digite uma string: e aumenta
    - Lidas 10 pos.
    - O ultimo valor da frase deve ser o tal newline '\n' codigo 10. Valor = '10'
    - E termina mesmo com newline
    - A entrada tem 9 letras: a saida vai ter 45 mais o '\0' no fim


                 0         1         2         3         4    *    5
                 0    *    0    *    0    *    0    *    0    *    0
Entrada:        [e aumenta]
Saida:          [e  aaauuuummmmmeeeeeennnnnnnttttttttaaaaaaaaa]

E um programa com muitos comentários e que gera essa saída

#define _CRT_SECURE_NO_WARNINGS

#include "memory.h"
#include "stdio.h"
#include "stdlib.h"
#include "string.h"

int caso2();

int main(int argc, char** argv)
{
    caso2();
    return 0;
}

int caso2()
{
    char palavra[80];
    printf("Digite uma string: ");
    fgets(palavra, 80, stdin);
    printf("    - Lidas %d pos.\n", strlen(palavra));

    char ultima_letra = palavra[strlen(palavra) - 1];
    printf("    - O ultimo valor da frase deve ser o \
tal newline '\\n' codigo 10. Valor = '%d'\n", 
        ultima_letra);
    if (ultima_letra == '\n')
    {
        printf("    - E termina mesmo com newline\n");
    }
    else
    {
        printf("    - Mas termina com outra coisa\n");
    };  // if()

    int ultimo = strlen(palavra) - 1; // na nova string nao tem o '\n'
    palavra[ultimo] = 0; // apaga o tal newline
    // qual vai ser o tamanho da nova string?
    // para 1 letra vai ser igual
    // para 2 vai ser 1 2 2
    // para 3 vai ser 1 2 2 3 3 3 
    int limite = (1 + ultimo) * ultimo / 2;
    printf("    - A entrada tem %d letras: a saida vai \
ter %d mais o '\\0' no fim\n\n\n",
        ultimo, limite);
    // cria a nova string
    char* nova = (char*)malloc(limite + 1);
    // idx_e = indice na entrada
    // idx_s = indice na saida
    int idx_s = 0;
    for (int idx_e = 0; idx_e < ultimo; idx_e += 1)
    {
        *(nova + idx_s) = *(palavra + idx_e); // copia a letra
        // avanca a saida
        idx_s += 1; 
        // a posicao indica o numero de replicas
        int nReplicas = idx_e; 
        for (int j = 0; j < nReplicas; j += 1, idx_s += 1)
            *(nova + idx_s) = *(palavra + idx_e); // replica
    };  // for()
    *(nova + idx_s) = 0; // termina a string de saida
    printf("\t\t 0         1         2         3         4    *    5\n");
    printf("\t\t 0    *    0    *    0    *    0    *    0    *    0\n");
    printf("Entrada:\t[%s]\n", palavra);
    printf("Saida:   \t[%s]\n", nova);
    free(nova);
};  // caso2()

Lucca Rodrigues · 17 de abril de 2020

@arfneto Sim. Agora é sua vez de tentar.

arfneto · 17 de abril de 2020

9 minutos atrás, Lucca Rodrigues disse:

@arfneto Sim. Agora é sua vez de tentar.

Pode ser assim como eu postei. o tal caso2(). depois mostro o outro Espero que ajude

Claro que não precisava de tudo que eu escrevi. Podia só resolver o problema. Mas é um programa para estudantes.

adicionado 24 minutos depois

Isso seria o simples: lê a string, calcula a nova, preenche, mostra e apaga:

int caso2_std()
{
    char palavra[80];
    printf("Digite uma string: ");
    fgets(palavra, 80, stdin);
    char ultima_letra = palavra[strlen(palavra) - 1];
    int ultimo = strlen(palavra) - 1; // na nova string nao tem o '\n'
    palavra[ultimo] = 0; // apaga o tal newline
    int limite = (1 + ultimo) * ultimo / 2;
    char* nova = (char*)malloc(limite + 1); // nova string
    int idx_s = 0; // indice da saida. o da entrada e idx_e claro
    for (int idx_e = 0; idx_e < ultimo; idx_e += 1)
    {
        *(nova + idx_s) = *(palavra + idx_e); // copia a letra
        idx_s += 1;
        int nReplicas = idx_e;
        for (int j = 0; j < nReplicas; j += 1, idx_s += 1)
            *(nova + idx_s) = *(palavra + idx_e); // replica
    };  // for()
    *(nova + idx_s) = 0; // termina a string de saida
    printf("Entrada:\t[%s]\n", palavra);
    printf("Saida:   \t[%s]\n", nova);
    free(nova);
};  // caso2_str()

paulorx10 · 17 de abril de 2020

Esse outro algoritmo tambem retorna a saida do programa porém ainda usa *p = *pal[cont] para pegar os chars.

#include <stdio.h> 
#include<string.h>
int main() {
 char palavra[30], palavra2[30];
 char * pal, * copia, * p;
 int cont=0,contj=0,i,j;
 printf("Digite uma palavra:");
 gets(palavra);
 pal = palavra;

 for (i = 0; i < strlen(palavra); i++){
    
   contj++;
   p = pal[i];
   for (j = contj-1; j >= 0; j--){
    
    copia = p;
   
    printf ("%c", copia);

   }
  
 }
 
 return 0;

}

arfneto · 17 de abril de 2020

@paulorx10

Não pode usar índices...

    p = pal[i];

E não está criando a string de saída direito.
Não calculou o o tamanho. Conforme eu expliquei, com exemplos do ensino médio,para 30 caracteres na entrada a saída vai ter nada menos que 436. Seu programa vai cancelar no 29.

paulorx10 · 17 de abril de 2020

@arfneto @arfneto sim, esse e so um exemplo com a saida correta, usando os recursos do ponteiro. Mas como citou acima realmente para essa questao e preciso extrapolar a matematica.

arfneto · 17 de abril de 2020

40 minutos atrás, paulorx10 disse:

@arfneto @arfneto sim, esse e so um exemplo com a saida correta, usando os recursos do ponteiro. Mas como citou acima realmente para essa questao e preciso extrapolar a matematica.

entendo

Uma nota:

    pal[i];

é a mesma coisa que escrever

    *(pal +i)

então isso trocar os [ ] de acordo

Em relação à matemática, você não precisa lembrar da fórmula do ensino fundamental ou procurar por ela na internet simplesmente. Ou mesmo deduzir: Você pode fazer um programa e calcular num for o tamanho da string de saída e aí colocar de volta em seu programa. Ninguém vai saber.

Veja para os 30 que você usou:

    int limite = 30;
    for (int i = 0; i < limite; i += 1)
        soma = soma + i;
    printf("limite para %d foi %d\n", limite, soma );

e vai ver:

limite para 30 foi 435

e você soma um pro 0 no final e pronto: 436. Você declarou palavra2[30] e não usou porque ia cancelar o programa mesmo

adicionado 2 minutos depois

Claro que é melhor lembrar do ensino médio e escrever (1+29)*29/2...

Mas ninguém vai saber afinal

robson s martins · 17 de abril de 2020

arfnet e paulo rx10 ..acho que pelo exemplo que ambos deram eu vi uma forma de fazer..sem usar o incide..

Lucca, não leve pro pessoal, mas o exemplo que você me mostrou eu já sabia como fazer...eu tinha feito anteriormente,mas não me auto ajudei..dai pedi ajuda..não quis ser descortês com você.

pois só tive 2 aulas de ponteiros, então ainda estou pegando o jeito.

depois posto minha nova versão.