C# União entre dois vetores

[Maria_epbn]

Crie uma função que receba como parâmetros dois vetores de inteiros: x1 e x2 e as suas respectivas quantidades de elementos n1 e n2. A função deverá retornar um ponteiro para um terceiro vetor x3, alocado dinamicamente, contendo a união de x1 e x2 e usar o ponteiro qtd para retornar o tamanho de x3.

•  Eu fiz a função mas na hora de compilar não aparece todos os elementos de x3, está aparecendo apenas os 5 primeiros.                                     

                          ex.:

                                     Vetor 1:         1         3        5        6        7

                                     Vetor 2:         1         3        4        6        8

                                     Vetor união:   1         3        5        4        6

int *uniao (int *x1, int *x2, int n1, int n2, int *qtd)
{ int i=0, j=0, *x3;


   x3 = (int*)malloc((n1+n2) * sizeof(int));
   
   if (x3 == NULL)
   {    printf("\n\nImpossível alocar memória.\n\n");
        return 0;
   }
   
 
  for(i=0; i<(n1+n2); i++)
  { if(*(x1+i)== *(x2+i))
    { *(x3+j) = *(x1+i);
        j++;
    }
    else if(*(x1+i)<*(x2+i))
    {    *(x3+j) = *(x1+i);
         *(x3+j+1) = *(x2+i);
          j=j+2;
    }
    else if (*(x1+i)>*(x2+i))
    { *(x3+j) = *(x1+i);
        *(x3+j+1) = *(x2+i);
        j=j+2;
    }
    

  }
return (x3);
}

 

[Ansi C]

Olá@Maria_epbn !

Ao olhar para seu código comecei a fazer uma experimento metal (jargão de física) de sua execução.

 

Primeiro alerta que surgi vem deste fragmento logo abaixo:

for (i= 0; i < (n1 + n2); ++i ){ if( (* (x1 + i)) == (* (x2 + i)) )

Observe atentamente a partir de agora o que você escreveu ali. O que tem de errado nisso? A matemática que não bate! Pois se i é o indexador dos dois vetores simultaneamente e seus limites é numericamente iguais  / ou / a soma de elementos nos dois vetores. Isso não é errado se os dois vetores têm o tamanho da sua soma ^{{ EITAAA }}, para isso n1 é igual n2 que é igual (n1 + n2). Assim sendo, só existe uma situação segura para esse panorama especifico ^... n1 é igual à 0! Para qualquer outro valor diferente de 0 seu programa pode ser finalizado com segmentation fault. Mesmo se não finalizar, isso está logicamente inadequado.

 

Então o que você vai fazer agora?

Alguma pergunta?

 

 

---

19:40 Atualização

4 horas atrás, Maria_epbn disse:

Eu fiz a função mas na hora de compilar não aparece todos os elementos de x3, está aparecendo apenas os 5 primeiros.

Mais nem deveria ter tido tudo isso ainda querida, deveria ter finalizado logo após no número 7. Provavelmente os dois vetores tem origem na pilha do sistema, porque se fossem alocados seria crashed. Se seu professor (estou supondo que você esteja curso) ver essa implementação ela vai tira ponto no quesito segurança. 

 

4 horas atrás, Maria_epbn disse:

Vetor 1:         1         3        5        6        7

Vetor 2:         1         3        4        6        8

Vetor união:   1         3        5        4        6

Eu não entendi a regra para união de vetores! Você pode falar um pouco mais sobre isso, e por que 8 e 7 ficam de fora do Vetor união?

[Maria_epbn]

Olá,@AnsiC, este é o erro do programa. Os elementos 8 e 7 deveriam estar inclusos no vetor união mas quando compilo o programa só aparecem os elementos 1         3        5        4        6.

 

meu programa está assim:

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

int *uniao (int *x1, int *x2, int n1, int n2, int *qtd);

int main()
{ int i, x1[]={1,3,5,6,7}, x2[]={1,3,4,6,8}, *x3, tam1, tam2, tam3;

  tam1 = 5;
  tam2 = 5;
  tam3 = tam1 + tam2;

  if (x1==NULL)
  { printf("\n\nImpossível alocar memória.\n\n");
    return 1;
  }
  


  if (x2==NULL)
  { printf("\n\nImpossível alocar memória.\n\n");
    return 1;
  }
  

  

  // IMPRIMINDO OS VETORES

  printf("\n\nVetor 1: ");
  for(i=0; i<tam1; i++)
  { printf("\t%d", *(x1+i));
  }

  printf("\n\n");  

   printf("\n\nVetor 2: ");
  for(i=0; i<tam2; i++)
  { printf("\t%d", *(x2+i));
  }
 
  x3 = (int*)malloc(tam3*sizeof(int));

  x3 = uniao(x1,x2,tam1,tam2,x3);

  printf("\n\nVetor união: ");
  for(i=0; i<tam1; i++)
  { printf("\t%d", *(x3+i));
  }

  printf("\n\n");


} 

int *uniao (int *x1, int *x2, int n1, int n2, int *qtd)
{ int i=0, j=0, *x3;


   x3 = (int*)malloc((n1+n2) * sizeof(int));
   
   if (x3 == NULL)
   {    printf("\n\nImpossível alocar memória.\n\n");
        return 0;
   }
   
 
  for(i=0; i<(n1+n2); i++)
  { if(*(x1+i)== *(x2+i))
    { *(x3+j) = *(x1+i);
        j++;
    }
    else if(*(x1+i)<*(x2+i))
    {    *(x3+j) = *(x1+i);
         *(x3+j+1) = *(x2+i);
          j=j+2;
    }
    else if (*(x1+i)>*(x2+i))
    { *(x3+j) = *(x1+i);
           *(x3+j+1) = *(x2+i);
           j=j+2;
    }


  }

return (x3);
}

 

[GBMelkor]

1 hora atrás, Maria_epbn disse:

printf("\n\nVetor união: "); for(i=0; i<tam1; i++) { printf("\t%d", *(x3+i)); }

O Erro está no tamanho de "Tam1", note que se você aumentá-lo em 2, ele exibirá o 7 e 8.

 

Substitua as linhas de exibição por esta:

tam1 = tam1 + 2;

printf("\n\nVetor união: ");
for(i=0; i<tam1; i++) 
  printf("\t%d", *(x3+i));

 

[Ansi C]

Não se engane com o resultado, pois os fins não justifica os meios. Vai tomar um bruta zero se apresenta esse programa. Isso se o professor não for um ordinário.

[GBMelkor]

Ao usar o tam1, você desconsidera o tamanho de VetUnião.

 

Eu criaria uma variável TLU, representando o tamanho lógico de VetUnião, e incrementaria sempre que um elemento fosse inserido neste. Dessa forma, você tem a segurança de que exibirá todos os elementos de VetUnião, e sem a gambiarra que mencionei acima.

[Ansi C]

Como eu resolveria o exercício:

1- Faria uma função que localiza um inteiro em um vetor de inteiros.

2- Depois uma função que faz copia de vetores.

3- Por última uso as duas primeiras funções para implementação daquela que será terceira função, a função que une os 2 vetores em um terceiro vetor retornando o apontador da união deles. Sou da filosófica de que se um código passou de 20 linhas, então, é a memória do programador e não do computador, ou seja, deve-se fazer mais funções.

 

@Maria_epbn Então, eu já emiti meu juízo com relação e não mudo minha opinião.@GBMelkor  mostro que é possível sim imprimir os 2 elementos restantes sem fazer nada além de adicionar 2 ao problema de tamanho. Tudo vai depender agora do professor. Se ele vai zombar dos seus esforços ou não.

 

 

[Maria_epbn]

@AnsiC o professor pediu apenas uma função.

 

 Enunciado: Crie uma função que receba como parâmetros dois vetores de inteiros: x1 e x2 e as suas respectivas quantidades de elementos n1 e n2. A função deverá retornar um ponteiro para um terceiro vetor, x3, alocado dinamicamente, contendo a união de x1 e x2 e usar o ponteiro qtd para retornar o tamanho de x3. Sendo x1={1,3,5,6,7} e x2={1,3,4,6,8}, x3 irá conter {1,3,4,5,6,7,8}. Imprima x3 na main.

  Protótipo: int* uniao (int *x1, int *x2, int n1, int n2, int *qtd);

 

 

[Ansi C]

@Maria_epbn

11 minutos atrás, Maria_epbn disse:

Crie uma função que receba como parâmetros dois vetores de inteiros: x1 e x2 e as suas respectivas quantidades de elementos n1 e n2.

Essa é a minha terceira função, perceba que ele disse: Crie uma função, destaque para o artigo definido indefinido, depois ele define como é essa função dizendo o que ela faz e não como ela faz; o como ela faz é outra coisa completamente diferente. Agora se ele tem dito. Crie somente uma função ... ai sim ficaria feliz em não descorda discordar.

 

É como disse antes! Isso vai da interpretação de cada um.

[Maria_epbn]

@AnsiC ok, vou tentar fazer.

 

@GBMelkor e @AnsiC muito obrigada pela ajuda!

[Ansi C]

Quase 24 horas e nada! Exemplifica o meu ponto de vista logo abaixo:

uniao

Spoiler

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

/* copia -- espelha os elementos da matriz / vetor 'ovtor' para 'dvtor' */
int * copia( int * dvtor, const int *ovtor, int otamanho );

/* busca -- localiza um elemento dentro da matriz */
int * busca( const int * vtor, int tamanho, int elemento );

/* uniao -- retorna os elementos existentes em pelo menos um dos vetores */ 
int * uniao( int * avtor, int * bvtor, int atamanho, int btamanho, int * utamanho );


int main(void)
{ int avtor []= { 1, 2, 3, 4, 5, 6, 7 };     /* A vetor */
  int bvtor []= { 8, 9, 10 };                /* B vetor */
  
  int utamanho= 0; /* Tamanho do vetor União */
  int * uvtor=  uniao( avtor, bvtor, 7, 3, (& utamanho) ); /* criar união  */
  
  /* imprimir a união */
  for (int u= 0; u < utamanho; ++u ) printf( " %d", (* (uvtor + u)) );
  
  /* livra-se de memória sem utilidade */
  free( uvtor );
  return 0;
}


int * busca( const int * vtor, int tamanho, int elemento )
{ int * v= ((void *)(vtor + tamanho)); /* fazendo casting const int para int */
  while ( v --> vtor && (* v) != elemento ){/*  */};
  return v; /* Ou seja, se o elemento não é encontrado, a função retorna um 
  apontador abaixo do identificador, se foi, o apontador da primeira ocorrência
  desse elemento é que será retornado */
}


int * copia( int * dvtor, const int * ovtor, int dtamanho )
{ /* são dos ponteiros de vetor, dvtor é o apontador do vetor destino, ovtor é o 
   * apontador do vetor original. A instrução FOR percorre cada elemento 
   * incrementando antes do valor em dtamanho que é o tamanho do vetor destino.
   */
  for (int el= 0; el < dtamanho; ++el ) dvtor [el]= ovtor [el]; /* copiando ... */
  return dvtor; /* retorna o apontador do vetor destino */
}


int * uniao( int * avtor, int * bvtor, int atamanho, int btamanho, int * utamanho )
{ /* inicialmente se declara um vetor união com tamanho máximo que a soma dos
   * tamanho em avtor e bvtor. Porém o tamanho do vetor união (utamanho) ainda 
   * não pode ser definido porque há possibilidade de que exitam 1 ou mais
   * elementos comuns, disso o tamanho ainda é indefinido.
   */
  int uvtor [atamanho + btamanho];
  
  /* No primeiro instante se faz a cópia dos elementos do primeiro vetor porque
   * neste instante ainda não tem sentido a preocupação com os elementos comuns
   * somente depois disso é que os elementos repetidos / comuns vão ser ignorados   
   */
  copia( uvtor, avtor, atamanho );
  (* utamanho)= atamanho;
  
  /* Agora que já temos os elementos do vetor a, vamos compra o seu conteúdo com
   * o conteúdo no vetor b, e copia para o vetor u apenas os elementos que não estão
   * no vetor b, e ignorar os elementos que são comuns nos vetores uvtor e bvtor.
   * Só lembrando que uvtor ainda neste momentos é igual avtor, mas pode ter um ou
   * mais elementos que são diferentes em bvtor, esses elementos são os que 
   * preciso copiar.
   */
  for ( int b= 0; b < btamanho; ++b ) /* vai percorrer e copiar os diferentes */
    if ( uvtor > busca(uvtor, (* utamanho), bvtor [b]) ) 
    { uvtor [(* utamanho)++]= bvtor [b]; }
    
  /* agora aloca-se dinamicamente a quantidade de memória exata para o vetor união
   * lembrando que até o momento o uvtor foi salvo na pilha do sistema com o valor
   * máximo que é a soma dos dois tamanhos de vetores. Agora vamos definir o uvtor
   * que será retornado com a resposta.
   */
  int * rvtor= malloc( sizeof (int [(* utamanho)]) );
  if ( (rvtor == NULL) || (utamanho == 0) )
  { puts( "Aviso: Memoria insuficiente!" ); /* Esse aviso nem é necessário porque 
    a variável utamanho volta com valor 0 também então essa questão pode, se 
    quiser, ser tratada no escopo da função chamariz. */
    
    return ( (* utamanho)= 0, NULL);
  } /*  */
  copia( rvtor, uvtor, (* utamanho) );
  return ( rvtor ); /* retorna o ponteiro */
}

 

Obrigado.