Comparar vectores

[cerejas]

Boas, foi me proposto este exercicio:

Desenvolva uma função, que receba dois vectores de inteiros (e respectiva dimensão) e

verifique se estes são iguais. A função deve devolver 1 se os dois vectores forem iguais

ou devolver 0 se forem diferentes. Considere que dois vectores são iguais se, na mesma

posição, tiverem elementos com o mesmo valor.

Dentro da minha "noobice" consegui fazer algo parecido, consegui fazer com que apareça no ecrã um valor(0 ou 1) para cada uma das comparações feitas, mas o exercicio pede apenas para apresentar um 0 se o vector for diferente ou um 1 se o vector for igual :S nao estou a perceber como é que posso fazer isso. Alguem me pode ajudar a modificar o meu codigo?

CODIGO ALTERADO 🙂

#include <stdio.h>
#define TAM 5

int igualdade(int v1[], int v2[], int tam){
int i, j, contador=0, devolve;
for(i=0, j=0; i<TAM, j<TAM; i++, j++){

if(v1[i]==v2[j]){
contador=contador+1;
}

else{
contador=0;
}
}
if(contador==tam){
devolve=1;
}
else {
devolve=0;
}
return devolve;
}
int main(){
int v1[TAM] = {2, 4, 6, 8, 9};
int v2[TAM] = {2, 4, 6, 8, 10};
int result;

result=igualdade(v1, v2, 5);
printf("%d\n", result);

}

Edited January 20, 2014 at 06:29 PM by thoga31
Tags code + GeSHi

[thoga31]

Isto de C++ não tem nada. Tópico movido para o quadro de C.

É por estas e por outras que entendo quem defenda a iniciação em Haskell - não há vícios de I/O.

Porque raio estás a fazer printf na função? O enunciado pede-te que faças printf lá dentro? O que é que o enunciado te pede?

O que ele te pede é para retornar 1 caso sejam iguais, ou 0 caso sejam diferentes.

Questão: onde é que a função está a retornar isso?

Por último, basta que os vectores tenham um valor igual para a função dar 1, e não devia. Verifica o algoritmo.

[dipo]

Realmente prints nas funções nunca é boa ideia...

A minha sugestão para resolveres o problema é arranjares um contador que vá sendo incrementado sempre que uma posição for igual, depois comparas esse contador com o tamanho do vector e se forem iguais retornas 1, quando verificas que uma posição não é igual, podes logo fazer o return 0, pois já sabes que os vectores não são iguais..

[HappyHippyHippo]

A minha sugestão para resolveres o problema é ...

uma sugestão de quem está a aprender, e como tal, a minha resposta é então para os dois ...

- o que te impede de terminar a execução do função a meio desta ?

ps : a funcionalidade que pretendes já existe (se bem que um bocadinho diferente):

#include <string.h>

int comparray(int v1[], int v2[], int tam) {
 return memcmp(v1, v2, sizeof(int) * tam) == 0;
}

só que se apresentares esta solução, terás zero valores por estares a subverter o objectivo do exercício.

[cerejas]

Obrigado a todos pelas respostas, ajudaram. Dipo resolveste o meu bloqueio cerebral. So nao percebi porque é que nao devo utilizar printf dentro das funçoes

[HappyHippyHippo]

Obrigado a todos pelas respostas, ajudaram. Dipo resolveste o meu bloqueio cerebral. So nao percebi porque é que nao devo utilizar printf dentro das funçoes

se foi para resolver um bloqueio mental, então ok, mas digo-te já que a solução apresentada pelo @dipo é de longe a solução pretendida.

podes usar os printf's onde quiseres, no entanto não quer dizer que os utilizes sem mais nem menos.

em programação, os blocos de código são criados com um objectivo quase independente uns dos outros, e fazer output de dados é normalmente algo que se deve separar de código que faz o trabalho per-se, como neste caso.

conclusão : cria a função, retorna o valor e só fazes printf no bloco de código correspondente.

[thoga31]

Eu tinha-te colocado as tags CODE com highlight do código. Porque as foste apagar? Bastava-te alterar o código dentro delas!

Uma das coisas que o Haskell ensina muito bem é que as funções devem ser o mais puras possíveis. Outra coisa que o Paradigma Estruturado nos ensina, do qual fazem parte o C ou o Pascal, é que as funções devem ser, sempre que possíveis, reutilizáveis.

Posto isto, o que todos nós queremos dizer é que este género de funções não deve ter qualquer género de I/O. Imagina que eu te peço uma função que retorne o cubo de um número inteiro não negativo. Ora, está subentendido que a função deve receber o número e retornar o cubo, e ponto final. As operações I/O ficam fora deste bloco. Exemplo:

• Errado, não se deve fazer assim.
  

  unsigned long ncube(unsigned int n) {
    printf("Resultado: %lu", (unsigned long) n*n*n);
    // tu não estavas a retornar um resultado na tua função!!
  }
  

  
  

• Correcto, a função é reutilizável.
  

  unsigned long ncube(unsigned int n) {
    return (unsigned long) n*n*n;
  }
  

  
  

Porque é que a função é reutilizável? Porque, se usar a primeira, vou levar sempre com aquele printf... mas e se eu não quiser aquele output?

Isto parece teórico, mas faz parte das boas práticas de programação.

Portanto, no teu caso, a função deverá ter este esqueleto:

int igualdade(int v1[], int v2[], int tam) {
  // calcula "resultado"
  return resultado;
}

Isto já o fizeste, e está bem.

Quanto ao algoritmo em si, o @Happy deu um conselho tanto a ti como ao @dipo, que também está a aprender. Essa solução não é a melhor. Para vectores maiores, é mesmo extremamente ineficiente, e passo a explicar porquê.

Imaginemos que temos dois vectores de 30.000 números. No 3º elemento, eles diferem, mas todos os outros são iguais. Vocês vão percorrer os 30.000 valores, quando apenas bastava percorrer os 3 primeiros - assim que encontram um que é diferente, interrompe-se o processo e indica-se que os vectores são diferentes. Para que são as outras 29.997 comparações? Só se for para aquecer a CPU. 😉

Esse código pode ser reduzido para 6/7 linhas.

Edited January 20, 2014 at 06:36 PM by thoga31

[cerejas]

Eu tinha-te colocado as tags CODE com highlight do código. Porque as foste apagar? Bastava-te alterar o código dentro delas!

Uma das coisas que o Haskell ensina muito bem é que as funções devem ser o mais puras possíveis. Outra coisa que o Paradigma Estruturado nos ensina, do qual fazem parte o C ou o Pascal, é que as funções devem ser, sempre que possíveis, reutilizáveis.

Posto isto, o que todos nós queremos dizer é que este género de funções não deve ter qualquer género de I/O. Imagina que eu te peço uma função que retorne o cubo de um número inteiro não negativo. Ora, está subentendido que a função deve receber o número e retornar o cubo, e ponto final. As operações I/O ficam fora deste bloco. Exemplo:

• Errado, não se deve fazer assim.
  

  unsigned long ncube(unsigned int n) {
    printf("Resultado: %lu", (unsigned long) n*n*n);
    // tu não estavas a retornar um resultado na tua função!!
  }
  

  
  

• Correcto, a função é reutilizável.
  

  unsigned long ncube(unsigned int n) {
    return (unsigned long) n*n*n;
  }
  

  
  

Porque é que a função é reutilizável? Porque, se usar a primeira, vou levar sempre com aquele printf... mas e se eu não quiser aquele output?

Isto parece teórico, mas faz parte das boas práticas de programação.

Portanto, no teu caso, a função deverá ter este esqueleto:

int igualdade(int v1[], int v2[], int tam) {
  // calcula "resultado"
  return resultado;
}

Isto já o fizeste, e está bem.

Quanto ao algoritmo em si, o @Happy deu um conselho tanto a ti como ao @dipo, que também está a aprender. Essa solução não é a melhor. Para vectores maiores, é mesmo extremamente ineficiente, e passo a explicar porquê.

Imaginemos que temos dois vectores de 30.000 números. No 3º elemento, eles diferem, mas todos os outros são iguais. Vocês vão percorrer os 30.000 valores, quando apenas bastava percorrer os 3 primeiros - assim que encontram um que é diferente, interrompe-se o processo e indica-se que os vectores são diferentes. Para que são as outras 29.997 comparações? Só se for para aquecer a CPU. 😉

Esse código pode ser reduzido para 6/7 linhas.

Entendido 😉 obrigado

[HappyHippyHippo]

visto que o criador do tópico alterou o código no primeiro post do qual foi referido que é uma solução fraquinha, aqui fica a solução pretendida:

// solução 1 : já apresentada antes mas não é a pretendida
int comparray1(int v1[], int v2[], int tam) {
 return memcmp(v1, v2, sizeof(int) * tam) == 0;
}

// solução 2 : a pretendida pelo exercício (perceber o funcionamento de ciclos)
int comparray2(int v1[], int v2[], int tam) {
 int i;
 for (i = 0; i < tam; i++)
   if (v1[i] != v2[i])
     return 0;
 return 1;
}