[Resolvido] uniao vetor

Crie um vetor C, ele irá auxiliar, assim na hora que for fazer a inserção nele, verifica se já existe ;D

[]s

>
Crie um vetor C, ele irá auxiliar, assim na hora que for fazer a inserção nele, verifica se já existe ;D

[]s

Boa ideia quitZAUMMM, vo fazer a alteração depois posto aqui, valew pela dica

quitZAUMMM, tentei fazer como você falou, fiz so o a parte que compara os valores digitados dentro do vetor A, testei aqui e funcionou, mas achei meio bagunçado. Voce poderia fazer do seu jeito para eu ver?

// Seção de Comandos
para i <- 1 ate 5 faca
escreval("digite um numero ")
leia(a[i])
para j <- 1 ate 5 faca
enquanto a[i] = c[j] faca
escreval("Numero ja digitado, digite outro ")
leia(a[i])
fimenquanto
fimpara
c[i] <- a[i]
fimpara
para i <- 1 ate 5 faca
escreval(a[i])
fimpara
fimalgoritmo

Bom a lógica é assim:

Leia (vetorA); //claro foi exemplo, precisa fazer um loop e tal.

Leia (VetorB) e já verifica se esse valor está no vetorA, se tiver verifica se está no vetorC se não estiver adiciona.

Chego a entender?

[]s

>
Leia (vetorA); //claro foi exemplo, precisa fazer um loop e tal.

Leia (VetorB) e já verifica se esse valor está no vetorA, se tiver verifica se está no vetorC se não estiver adiciona.

Depois é só mostrar o vetorC que já vai ser o conjunto união certo?

Se eu entendi direito seria algo assim?

var
a, b, c : vetor[1..5] de inteiro
i, j, k : inteiro
inicio
// Seção de Comandos
para i <- 1 ate 5 faca
escreval("Digite um numero para o conjunto A")
leia(a[i])
fimpara
para i <- 1 ate 5 faca
escreval("Digite um numero para o conjunto B")
leia(b[i])
para j <- 1 ate 5 faca
se (b[i] = a[j]) entao
para k <- 1 ate 5 faca
se (b[i] <> c[k]) entao
c[i] <- b[i]
fimse
fimpara
fimse
fimpara
fimpara
para i <- 1 ate 5 faca
escreval(c[i])
fimpara
fimalgoritmo

Só q ta dando erro, se tiver dois numeros iguais no vetorB ele aparece repetido no vetorC, e acho q da forma q montei ele pode acabar pulando alguma posição no vetorC ficando vazio, o q você acha?

Aqui está minha implementação em C:

#include <stdio.h>

#define TAMANHO(vetor) (sizeof vetor / sizeof *vetor)
#define INIT 0

// Retorna o último índice do vetor manipulado após
// a inserção (ou não) do elemento dado

unsigned int inserir(int elemento, int vetor[])
{

 static unsigned int indice_uniao;
 int i;

 for (i = 0; i <= indice_uniao; i++)
 if (vetor[i] == elemento)
 return (indice_uniao == 0 && elemento == INIT) ? indice_uniao++ : indice_uniao;

 vetor[ indice_uniao++ ] = elemento;
 return indice_uniao;
}

int main(void)
{
int vetor_1[] = { 0, 1, 2, 3, 4 },
vetor_2[] = { 3, 4, 5, 6, 7 },
uniao[ TAMANHO(vetor_1) + TAMANHO(vetor_2) ] = { INIT },
i,

 ultimo_indice;

 for (i = 0; i < TAMANHO(vetor_1); i++)
 ultimo_indice = inserir(vetor_1[i], uniao);

 for (i = 0; i < TAMANHO(vetor_2); i++)
 ultimo_indice = inserir(vetor_2[i], uniao);

 for (i = 0; i < ultimo_indice - 1; i++)
 printf("%d, ", uniao[i]);
 printf("%d.", uniao[i]);

 return 0;
}

 

 Para o caso especial em que o vetor uniao está vazio e o elemento a ser inserido tem mesmo valor que o usado nas inicializações do vetor uniao, a função de inserção deve incrementar seu contador de elementos, caso contrário o elemento em questão será apagado na próxima inserção. Esta é a desvantagem da implementação em C, que ocorre em conseqüência da minha vontade de eliminar do código a condição de que nenhum dos vetores sobre os quais operamos possuam elementos com mesmo valor que o de inicialização. Não dediquei muito tempo à resolução do problema, portanto se alguém tiver alguma idéia melhor que não torne o código dependente de algum valor indicando vazio, por favor compartilhem.

 

 As vantagens da implementação são duas:

 

 1. A função de inserção não percorre o vetor todo a cada chamada - apenas considera a quantidade de elementos atualmente no vetor resultado (uniao);

 

 2. O programa pode ser facilmente adaptado para uniões de mais vetores;

 

 

 Aos que forem brincar com o código, tomar cuidado com o fato de que, em inicializações de vetores, cada elemento cujo valor não é especificado é inicializado como se tivesse static storage (neste caso, recebem valor 0), ao invés do que pode parecer dada a inicialização de uniao via { INIT }. Exemplos:

int vetor[30] = { 0 }; // 30 posições contendo 0
int vetor[30] = { 1 }; // primeira posição contendo 1, as outras 29 contendo 0

Ulfreitas de uma olhada no tópico "problemas com algoritmo no visualg" do fernando_souza, é um problema parecido talvez você encontre a sua resposta la ;D abraço

guidjos obrigado, ainda nao tive tempo mas vou dar uma olhada no codigo.

Johnny eu vi meio por cima o problema com algoritmo, é bem parecido, a diferença é q o meu tem q mostrar apenas os q se repetem, mas vou analisar o codigo q você forneceu tambem e ver o q eu consigo adaptar obrigado

Depois eu posto o resultado ;)

Ae Ulysses, bom cara eu achei uma forma de resolver esse seu problema não sei se é a melhor,não dediquei muito tempo, de qualquer maneira vou postar dê uma olhada e se achar melhor mude o codigo e poste ai pra galera :D

algoritmo "Uniao vetor"
// Função :
// Autor : Johnny Willer Gasperi Gonçalves
// Data : 11/08/2011
// Seção de Declarações

var
vet_a, vet_b, vet_c: vetor [1..25] de inteiro
x, y, i: inteiro
terminado: logico

inicio
// Seção de Comandos
para i de 1 ate 5 faca
escrevaL (" Digite o ", i, "º número para o Vetor A")
leia (vet_a[i])
escrevaL (" Digite o ", i, "º número para o Vetor B")
leia (vet_b[i])
fimpara
i <- 1
y <- 1
x <- 1

enquanto terminado = falso faca
se vet_a[i] = vet_b[x] entao
vet_c[y] <- vet_a[i]
y <- y + 1
fimse
i <- i + 1
se i > 5 entao
i <- 1
x <- x + 1
fimse
se x > 5 entao
terminado <- verdadeiro
fimse
fimenquanto
x <- 5
y <- 1
terminado <- falso
enquanto terminado = falso faca
para i de 1 ate x faca
se vet_c[y + i] = vet_c[y] entao
vet_c[y + i] <- 0
fimse
se i = x entao
y <- y + 1
x <- x - 1
fimse
se y > 5 entao
terminado <- verdadeiro
fimse
fimpara
fimenquanto

escrevaL ("---------------------- VETOR A ----------------------")

para i de 1 ate 5 faca
escreva (vet_a[i], " ")
fimpara

escrevaL ("")
escrevaL ("")
escrevaL ("---------------------- VETOR B ----------------------")

para i de 1 ate 5 faca
escreva (vet_b[i], " ")
fimpara

escrevaL ("")
escrevaL ("")
escrevaL ("---------------------- VETOR C ----------------------")

para i de 1 ate 5 faca
se vet_c[i] <> 0 entao
escreva (vet_c[i], " ")
fimse
fimpara

fimalgoritmo

Ei Johnny blza?

É isso ai mesmo, ta funcionando aqui.

valew kra ajudou muito :joia: