ponteiros

[suzy]

tenho este problema, e nao sei porque me da lixo, parece que o ponteiro *igual, so tem acesso ao endereço e nao ao conteudo da celula de memoria.

Desenvolva uma função que determine quantos elementos de uma tabela de inteiros são

iguais à média dos seus dois vizinhos. A função recebe como argumentos um ponteiro para o

início da tabela, o número de elementos que esta contém e um ponteiro para uma variável

inteira onde deve ser colocado o resultado (i.e., quantos elementos são iguais à média dos

seus vizinhos). A sua declaração é a seguinte:

void vizinhos(int *tab, int dim, int *igual);

fiz assim 😛

#include<stdio.h>



void vizinhos(int *tab, int dim, int *igual){
              int i, conta=0,media=0,soma=0;
              
              for(i=0;i<dim;i++){
                   soma=*(tab+i)+*(tab+i+2);
                   media=soma/2;
                   
                   if(*(tab+i)==media){
                        conta=conta+1;
                        *igual=conta;
                        }
   
   
   }
   printf(" sao %d\n", *igual);
}

main(){
   int vetor[5]={2,2,4,4,6},x;
   
   vizinhos(vetor,5,&x);
   
   fflush(stdin);
   getchar();
   }

da me lixo, pq? obrigada

[suzy]

?

presumo que o erro seja desta linha

for(i=0;i<dim;i++){
                   soma=*(tab+i)+*(tab+i+2);// aqui esre 2, rebenta com a memoria
                   media=soma/2;

como faço então, qual o raciocinio correcto?

[shumy]

(tab+i+2) vai saltar fora da tabela.

Também não faz sentido efectuar um printf do *igual e ao mesmo tempo retornar o parâmetro. A função não deve imprimir o valor, deve ser efectuado no main.

[nDray]

Primeiro, se tens ponteiros, não sei porque continuas a usar acesso indexado aos arrays...

O problema nisso é que estás a aceder a endereços que não te dizem respeito. se queres comparar com os vizinhos, tens de começar no segundo indice e parar no penultimo.....

#include <stdio.h>



void vizinhos(int *arr, int size, int *count)
{
        size = (int)arr + size * sizeof(int) - sizeof(int); // falha se a soma nao couber num int.
        *count = 0;

        while((int)++arr < size)
        {
                if(*arr == (*(arr - 1) + *(arr + 1)) / 2)
                {
                        (*count)++;
                }
        }

        printf("sao %d\n", *count);
}


int main()
{
        int vect[5] = {2, 3, 4, 5, 6}, x;

        vizinhos(vect, 5, &x);

        getchar();
        return 0;
}

[TheDark]

...

No teu código tens 2 problemas principais:

- Estás a sair do array, como disse o shumy, quando fazes *(tab+i+2), e i é igual a size-1 ou a size. O for devia parar em size-2;

- No if, estás a comparar um elemento com a média dele próprio e de elemento 2 índices à frente, aqui: *(tab+i)

[suzy]

ver se atino com este tipo de raciocionios ?

aqui neste problema tb tenho a mesma dificuldade

Desenvolva um função que determine em que posição de uma tabela de inteiros se encontra

o elemento que regista a maior subida em relação ao elemento anterior. Esta posição deve ser

devolvida como resultado. A função recebe como argumentos um ponteiro para o início da

tabela e o número de elementos que esta contém. A sua declaração é a seguinte:

int maior_subida(int *tab, int dim);

#include<stdio.h>

int maior_subida(int *tab,int dim){
            int i,dif,posicao,maior=-1000;
            for(i=0;i<dim;i++){
               dif=*(tab+i+1)-(*(tab+i));
                if(maior<dif){ 
                  posicao=i;
                }
               
               return i;
               }
            
}

main(){
int vetor[4]={1,5,1,3},total;
total=maior_subida(vetor,4);
printf(" a maior subida se encontra na %d\n",total);
fflush(stdin);
getchar();
}

vou tentar ate dar:( muito obrigada

[mogers]

vou tentar ate dar:( muito obrigada

Isto é sempre uma má ideia... convem ter noção do que fazemos, senão depois criamos mais erros a tentar corrigir outros ^^

esse código está bem excepto no "return i"  que para além de estar dentro do for , não é o "i" que queres devolver.

outra coisa que tens de ter cuidado, é que se "dim" for o número de elementos do array, na ultima iteração acedes à posicao "dim" , quando os endereços são 0.. dim-1

A última coisa, podes simplificar o código: podes tratar o apontador como usas um array normal. Quando usas  vector[2] , no fundo estás a fazer *(vector+2). "vector" é um apontador para o inicio do array.

Assim podes fazer    dif = tab[ i + 1 ] - tab[ i ] ;    sem qualquer problema, desde que não estejas a aceder a limites fora do array.

Bom trabalho 😛

[saunde]

 if(maior<dif){ 
                  posicao=i;
                }

e tens k rever esta parte, pois tens k ir actualizando o maior durante as iterações para poderes no final encontrar a maior diferença.

Já agora começar  maior com -1000 n é boa politica, o melhor k tens a fazer é começar com a primeira diferença de valores, ou então como simplesmente é para retornar a maior subida podes inicializar com 0, valor que irás retornar se não existirem subidas. Apenas uma ideia .. faz pelo melhor 😛