Vetores - Elementos não comuns. visualg

Morgtuns · 9 de abril de 2017

Criar um algoritmo que leia dois conjuntos de números inteiros, tendo cada um 5 e 10 elementos e apresentar os elementos que não são comuns aos dois conjuntos.

Olá pessoas! Não entendo o problema com esse algoritmo. Fiz um parecido com o qual apenas tinha que colocar os elementos em comum entre os vetores, mas quando esse algoritmo faz a verificação no "se (con[i ] <> con2[j]) ele mostra todos os valores do conjunto 1 repetidos quatro vezes ao invés de mostrar os elementos que não possuem em comum. Poderiam me ajudar a resolver isso? obg :DD

var
   con : Vetor[1..10] de Inteiro
   con2 : Vetor[1..5] de Inteiro
   aux: vetor[1..10] de Inteiro
   i, j: Inteiro
inicio
      Escreval("PRIMEIRO CONJUNTO")
      Para i de 1 ate 10 faca
        Escreva("Digite o ", I, "º valor: ")
        Leia(con[i])
      FimPara
      
      LimpaTela
      EscrevaL("SEGUNDO CONJUNTO")
      Para i de 1 ate 5 faca
        Escreva("Digite o ", i, "º valor: ")
        Leia(con2[i])
      FimPara
      
      LimpaTela
      Para I de 1 ate 10 faca
       Para J de 1 ate 5 faca
        Se(con[i] <> con2[j]) então
         Escreva(con[i])
        FimSe
      FimPara
     FimPara
fimalgoritmo

devair1010 · 9 de abril de 2017

@Morgtuns o que está acontecendo é que ele verifica todos os números do con2

com cada um de con, então se um número for igual ele não escreve o número, mas

os outros quatro números serão diferentes e aí ele escreve o número em con[ i ] e

como o loop repete cinco vezes, ele escreve o mesmo número em con2 quatro vezes.

para resolver isso é preciso fazer uma verificação antes, e precisa verificar também no

outro vetor . aqui seu código com essas modificações :

Algoritmo "num diferente"
var
   con  : Vetor[1..10] de Inteiro
   con2 : Vetor[1..5]  de Inteiro
   aux  : vetor[1..10] de Inteiro
   i,j,g: Inteiro
inicio
      Escreval("PRIMEIRO CONJUNTO")
      Para i de 1 ate 10 faca
        Escreva("Digite o ", I, "º valor: ")
        Leia(con[i])
      FimPara

      LimpaTela
      EscrevaL("SEGUNDO CONJUNTO")
      Para i de 1 ate 5 faca
        Escreva("Digite o ", i, "º valor: ")
        Leia(con2[i])
      FimPara

      LimpaTela
      Para I de 1 ate 10 faca
        g:=0                      // controla o que escrever
        Para J de 1 ate 5 faca
          se con[i]=con2[j] ENTÃO//verifica todos os numeros de con2 com cada um de con
            g:=1                 //se algum numero for igual
          fimse
        FimPara
        se g=0 ENTÃO      //se nenhum numero não for igual
          escreva(con[i]) //escreve ele
        fimse
      FimPara
      Para I de 1 ate 5 faca
        g:=0              // controla o que escrever
        Para J de 1 ate 10 faca
          se con[j]=con2[i] ENTÃO//verif todos num de con com cada um de con2
            g:=1          //se algum numero for igual
          fimse
        FimPara
        se g=0 ENTÃO      //se nenhum numero for igual
          escreva(con2[i])//escreve ele
        fimse
      FimPara
fimalgoritmo

Simon Viegas · 9 de abril de 2017

Olá a todos...

Só tentando refinar o código:

1) DECLARAÇÃO DE VARIÁVEIS

A variável aux não está sendo utilizada, precisa apagar ela.

2) CONCEITO DE FLAG

Essa variável g utilizada no código de @devair1010 está funcionando como uma flag, ou seja, uma "bandeira" que servirá para indicar algo, nesse contexto seria algo como "se o número atual de um vetor é igual algum número que está em um segundo vetor". A vantagem ou o objetivo de utilizar uma flag, é que mesmo que se encontrar um mesmo valor em outra posição, não vai fazer diferença, pois a flag continuará com o mesmo valor (de "encontrado igual").

Um comentário extra: perceba que analisando o objetivo desse passo de "verificar números iguais", ao encontrar um numero igual, nem era mais necessário continuar analisando, entende? pois sendo igual a qualquer um, esse número já pode ser descartado (pois só interessa o que é diferente). Logo, poderia-se então parar o laço de repetição para esse número e ir para o próximo! Entretanto, como são pouco passos, esse "desperdício de esforço" pode ser ignorado.

Obs.: caso deseje, posteriormente essa questão pode ser analisada com mais calma. (eu acho que vale a pena)

3) REORGANIZAÇÃO DAS ETAPAS

Peguei esse código de @devair1010 e tentei reorganizar o fluxo... tentando identificar cada passo do processo... vejam se ficou bom:

obs.: como exemplificação, alterei o g por igual:, e mudei o tipo de inteiro para logico, pois como só existem duas possibilidades (antes 0 e 1), esse tipo (logico) se encaixa melhor (só tem duas possibilidades). Veja, poderia ser qualquer tipo, como inteiro, real, caractere etc... o que importa é o conceito, ou seja, que a variável funcione como uma flag...

Nesse código abaixo, mudei a ordem de algumas coisas... o ideal seria tentar comparar ele com o anterior e analisar o que foi alterado...

Algoritmo "num diferente"
var
   con1 : Vetor[1..10] de Inteiro
   con2 : Vetor[1..5]  de Inteiro
   i,j  : Inteiro
   IGUAL: logico   //FLAG - se encontrou algum igual (verdadeiro ou falso)
inicio
Escreval("PRIMEIRO CONJUNTO")
Para i de 1 ate 10 faca
   Escreva("Digite o ",i,"º valor: ")
   Leia(con1[i])
FimPara

LimpaTela
EscrevaL("SEGUNDO CONJUNTO")
Para i de 1 ate 5 faca
   Escreva("Digite o ",i,"º valor: ")
   Leia(con2[i])
FimPara

LimpaTela
//verifica todos os numeros de con1 com cada um de con2
Para i de 1 ate 10 faca //para todos os números de con1
   IGUAL <- falso //inicializa a flag como "não encontrado igual"
   Para j de 1 ate 5 faca //para todos os números de con2
      se con1[i]=con2[j] então
         IGUAL <- verdadeiro //marca a flag como "encontrou um igual"
      fimse
   FimPara
   se NÃO IGUAL então //se número atual em con1 não é igual aos de con2
      escreva(con1[i]) //escreve ele
   fimse
FimPara

//verifica todos os numeros de con2 com cada um de con1
Para j de 1 ate 5 faca //para todos os números de con2
   IGUAL <- falso //inicializa a flag como "não encontrado igual"
   Para i de 1 ate 10 faca //para todos os números de con1
      se con2[j]=con1[i] então
         IGUAL <- verdadeiro //marca a flag como "encontrou um igual"
      fimse
   FimPara
   se NÃO IGUAL então //se número atual em con2 não é igual aos de con1
      escreva(con2[i])//escreve ele
   fimse
FimPara

fimalgoritmo

Obs.:perceba que, por exemplo, eu inverti a ordem dos vetores no último se (de con1[i ]=con2[2], para con2[j]=con1[i ]). Na prática não tem diferença nenhuma, só que fica mais didático, pois o foco do laço está ma verificação do con2...

Obs2.: outro ponto interessante: não faz diferença em usar i ou i para um vetor ou outro... tanto que na parte da leitura, utilizamos o i para os dois... (talvez seria mais coerente mudar mudar para j para ler o con2.. fiquei na dúvida, rs)

***

No aguardo.

Morgtuns · 9 de abril de 2017

@devair1010, @Simon Viegas, Brigadão mesmo. Eu entendi perfeitamente com a explicação dos dois, não conhecia esse conceito de "flag". Normalmente, quando se usa o Flag? se eu entendi bem, sempre que precisa verificar os elementos de 2 ou mais vetores, certo?

Simon Viegas · 10 de abril de 2017

Oi...

Não sei explicar uma regra de uso específica... é apenas um conceito.

Imagine uma flag como um bandeira em si... Por exemplo, numa "guerra", ao "inimigo" balançar uma bandeira branca, poderiam-se supor que ela (a flag) está informando que eles estão se rendendo. Ou seja, a flag servirá para indicar algo... (e por lógica, que esse algo será usando para alguma coisa). Pensando como um programa seria algo assim:

var
  bandeira_branca_oponente: inteiro  //0=não levantada  1=levantada
INICIO
....
....
se (bandeira_branca_oponente = 1) então
    escrevel("Inimigo se rendeu!!! Saimos vencedor")
senao
   escreval("Continua atacando")
...
...
fimAlgoritmo

A bandeira branca é uma flag que indica o fim da guerra.

Peguei um vídeo aleatório que fala do tema também, veja o exemplo nele:

Nesse exemplo, a flag (bandeira) está servindo para "saber se quer continuar repetindo ou não", ou seja, a flag foi previamente inicializada com um valor "S", e ao chegar no enquanto, verificará que está flamulando para continuar (ou no caso iniciar o laço de repetição). Daí durando o fluxo do laço de repetição, será feito algo para verificar se a flag deverá continuar com "S" ou não... Caso mude para "N" (especificamente qualquer valor diferente de "S"), ao voltar para o enquanto, verificará que ela não é mais igual a "S", logo não irá repetir novamente... e fluxo passará a executar a próxima linha após o fimEnquanto.

Já no seu contexto... o objetivo é:

Em 08/04/2017 às 22:36, Morgtuns disse:

...apresentar os elementos que não são comuns aos dois conjuntos.

Logo, o @devair1010 pode ter imaginado algo assim: "oras! eu pego cada posição do primeiro vetor e compara com cada posição do segundo vetor. Se a posição atual (que estou verificando) for diferente de todas posições do segundo vetor, eu imprimo ele na tela. Após faço o mesmo com o segundo vetor, ou seja, comparo todas as suas posições com os valores do primeiro vetor". Veja, aqui já sabemos "o problema", e @devair1010 tentou implementar o que achou que seria válido para "uma solução desse problema". Até aqui, beleza?

Daí, entra: "como posso fazer essa comparação?". A forma encontrada foi criar um laço de repetição que compara justamente posição por posição... mas como o que interessa é não achar algum igual no outro vetor, a flag servirá para "marcar", caso encontre, que já encontrou. Após é só verifica o estado dessa flag.

Abaixo fiz um código que "ao encontrar um valor no outro vetor, para de procurar e passa para o próximo" (economizar passos).

Para testar, por exemplo use: 1,2,3,4,5,6,7,8,9,10 e 1,2,0,3,4

Deverá exibir: 5,6,7,8,9,10 e 0

Algoritmo "num diferente"
var
   con1 : Vetor[1..10] de Inteiro
   con2 : Vetor[1..5]  de Inteiro
   i,j  : Inteiro
   IGUAL: logico   //FLAG - se encontrou algum igual (verdadeiro ou falso)
inicio
Escreval("PRIMEIRO CONJUNTO")
Para i de 1 ate 10 faca
   Escreva("Digite o ",i,"º valor: ")
   Leia(con1[i])
FimPara

LimpaTela
EscrevaL("SEGUNDO CONJUNTO")
Para i de 1 ate 5 faca
   Escreva("Digite o ",i,"º valor: ")
   Leia(con2[i])
FimPara

LimpaTela
//verifica todos os numeros de con1 com cada um de con2
para i de 1 ate 10 faca //para todos os números de con1
   IGUAL <- falso //inicializa a flag como "não encontrado igual"
   j<-1 //inicializa o "controlador de posição do vetor"
   enquanto ((j<=5) E (NÃO IGUAL)) faca //enquanto não chegar ao fim E nenhum for igual
      se con1[i]=con2[j] ENTÃO
         IGUAL <- verdadeiro //marca a flag como "encontrou um igual"
      fimse
      j<-j+1 //atualiza o "controlador de posição do vetor"
   fimEnquanto
   se NÃO IGUAL ENTÃO //se número atual em con1 não é igual aos de con2
      escreva(con1[i]) //escreve ele
   fimse
fimPara

//verifica todos os numeros de con2 com cada um de con1
para j de 1 ate 5 faca //para todos os números de con2
   IGUAL <- falso //inicializa a flag como "não encontrado igual"
   i<-1 //inicializa o "controlador de posição do vetor"
   enquanto ((i<=10) E (NÃO IGUAL)) faca //enquanto não chegar ao fim E nenhum for igual
      se con2[j]=con1[i] ENTÃO
         IGUAL <- verdadeiro //marca a flag como "encontrou um igual"
      fimse
      i<-i+1 //atualiza o "controlador de posição do vetor"
   fimEnquanto
   se NÃO IGUAL ENTÃO //se número atual em con1 não é igual aos de con2
      escreva(con2[j]) //escreve ele
   fimse
fimPara
fimalgoritmo

Aqui o mesmo código, mas exibindo na telas algumas informações, para demonstrar como funciona... Para testar, por exemplo use: 1,2,3,4,5,6,7,8,9,10 e 1,2,0,3,4

Deverá exibir: 5,6,7,8,9,10,0

Algoritmo "num diferente"
var
   con1 : Vetor[1..10] de Inteiro
   con2 : Vetor[1..5]  de Inteiro
   i,j  : Inteiro
   IGUAL: logico   //FLAG - se encontrou algum igual (verdadeiro ou falso)
   diferentes: caractere
inicio
Escreval("PRIMEIRO CONJUNTO")
Para i de 1 ate 10 faca
   Escreva("Digite o ",i,"º valor: ")
   Leia(con1[i])
FimPara

LimpaTela
EscrevaL("SEGUNDO CONJUNTO")
Para i de 1 ate 5 faca
   Escreva("Digite o ",i,"º valor: ")
   Leia(con2[i])
FimPara

LimpaTela
//verifica todos os numeros de con1 com cada um de con2
para i de 1 ate 10 faca //para todos os números de con1
   IGUAL <- falso //inicializa a flag como "não encontrado igual"
   j<-0 //inicializa o "controlador de posição do vetor"
   enquanto ((j<5) E (NÃO IGUAL)) faca //enquanto não chegar ao fim E nenhum for igual
       j<-j+1 //atualiza o "controlador de posição do vetor"
      escreval("Posição que tô olhando",i," ",j) //PARA TESTES - exibe na tela as cordenadas de cada vetor
      se con1[i]=con2[j] ENTÃO
         IGUAL <- verdadeiro //marca a flag como "encontrou um igual"
         escreval("O",con1[i]," TEM TAMBÉM NO VETOR2, NÃO SERVE!... VOU PRO PRÓXIMO") //PARA TESTES - exibe que encontrou
      fimse
   fimEnquanto
   se NÃO IGUAL ENTÃO //se número atual em con1 não é igual aos de con2
      //escreva(con1[i])
       escreval("OPA!!! NÚMERO DIFERENTE:",con1[i])
       escreval()
      diferentes<-diferentes+" "+numpcarac(con1[i])
   fimse
fimPara

//verifica todos os numeros de con2 com cada um de con1
para j de 1 ate 5 faca //para todos os números de con2
   IGUAL <- falso //inicializa a flag como "não encontrado igual"
   i<-0 //inicializa o "controlador de posição do vetor"
   enquanto ((i<10) E (NÃO IGUAL)) faca //enquanto não chegar ao fim E nenhum for igual
      i<-i+1 //atualiza o "controlador de posição do vetor"
      escreval("Posição que tô olhando",i," ",j) //PARA TESTES - exibe na tela as cordenadas de cada vetor
      se con2[j]=con1[i] ENTÃO
         IGUAL <- verdadeiro //marca a flag como "encontrou um igual"
         escreval("O",con2[j]," TEM TAMBÉM NO VETOR1, NÃO SERVE!... VOU PRO PRÓXIMO") //PARA TESTES - exibe que encontrou
      fimse
   fimEnquanto
   se NÃO IGUAL ENTÃO //se número atual em con1 não é igual aos de con2
      //escreva(con2[j])
      escreval("OPA!!!NÚMERO DIFERENTE:",con2[j])
      escreval()
      diferentes<-diferentes+" "+numpcarac(con2[j])
   fimse
fimPara
escreval
escreval("DIFERENTES: ",diferentes)
fimalgoritmo

No aguardo.