Ir ao conteúdo
  • Cadastre-se
sasaakii

C++ Problemas com operações com vetores

Recommended Posts

Boa tarde!

Para um trabalho, preciso fazer um programa em C++ que faça operações em conjuntos (vetores), tais como adição de elementos e remoção, união, interseção, diferença e etc...

A questão é, o programa está rodando perfeitamente, porém só consigo fazer as operações com números abaixo de 7, ou seja, se eu insiro um número maior que 7 dentro do conjunto (vetor) as operações não funcionam. Alguém sabe o que pode ser isso? Já testei e tudo funciona perfeitamente com valores até 6, independentemente do tamanho do vetor.

Segue abaixo o código.

#include <iostream>

using namespace std;

//Função organizar
void BubbleSort(int vet[], int tam){
	
    int i,j, aux;
    for(i=tam-1; i>0; i--){
        for(j=0; j < i; j++){
            if( vet[j] > vet[j+1] ){
                aux = vet[j];
                vet[j] = vet[j+1];
                vet[j+1] = aux;
            }
        }
    }
}

//Função pertence
bool P(int v[], int x) {
	int i2=0;
	for (int i=0; i<1000; i++) {
		if (v[i]==x) {
			return true;
			i2++;
		}
	}
	if (i2==0) {
		return false;
	}
}

//Função adicionar
void A(int v[], int x, int *tam) {
	int i=0;
	if(!P(v, x)) {
		while (v[i] != -1) {
			i++;
		}
		v[i] = x;
		*tam=(*tam)+1;
	}
}

//Função imprimir
void p(int v[], int tam) {
	int i=0;
	for (int i=0; i<tam; i++) {
		if (v[i]>=0) {
			cout << v[i] << " ";
		}
	}
	cout << endl;
}

//Função diferença
void D(int v1[], int tam1, int v2[], int tam2){
    int i2=0;
    for(int i=0; i<tam1; i++){
        if(!P(v2, v1[i])) {
            cout << v1[i] << " ";
            i2++;
        }
    }
    cout << endl;
}

//Função união
int U(int vA[], int tama, int vB[], int tamb, int vU[]){
    int tamu;
    for(int i=0;i<tama;i++){
        vU[i]=vA[i];
    }
    tamu=tama;

    for(int i=0;i<tamb;i++){
        if( ! P(vU, vB[i])){
            vU[tamu]=vB[i];
            tamu++;
        }
    }
    return tamu;
}

//Função interseção
void I(int vA[], int tama, int vB[], int tamb){
    int tami=0;
    for(int i=0;i<tama;i++){
        if( P(vB, vA[i]) ){
            cout << vA[i] << " ";
        }
    }
    cout << endl;
}

int main() {
	int vA[1000], vB[1000], i, l=0, tama=0, tamb=0, i2, i3, vt, vt1, x, vR[1000], vU[2000], tt, tamu, ip;
	char o, o2, o3, o4, o5, o6, o7, o8, o9, a1;
	
	for (i=0; i<1000; i++) {
		vA[i]=-1;
		vB[i]=-1;
		vR[i]=-1;
		vU[i]=-1;
	}
										
	while (l<1) {
		
		cin >> o;
		if (o=='a' || o=='r' || o=='s' || o=='i' || o=='u' || o=='d' || o=='f') {
			o=toupper(o);
		}
			
			switch (o) {
			
				case 'A':
					cin >> a1;
					//Adiciona elementos ao conjunto A
					if (a1=='a' || a1=='A') {
						cin >> x;
						for (i=0; i<x; i++) {
							cin >> vt;
							A(vA, vt, &tama);
						}
					}
					
					//Adiciona elementos ao conjunto B
					if (a1=='b' || a1=='B') {
						cin >> x;
						for (i=0; i<x; i++) {
							cin >> vt;
							A(vB, vt, &tamb);
						}
					}
					break;
				
				case 'R':
					cin >> o7;
					cin >> x;
					
					for (i=0; i<x; i++) {
						cin >> vR[i];
					}
					//Remove elementos do conjunto A
					if (o7=='a' || o7=='A') {
						for (i=0; i<1000; i++) {
							if (vR[i] >= 0) {
								for(i2=0; i2<1000; i2++) {
									if (vA[i2 >= 0]) {
										if (vR[i]==vA[i2]) {
											vA[i2]=-1;
										}
									}
								}
							}
						}
						tama=tama-x;
					}
					//Remove elementos do conjunto B
					if (o7=='b' || o7=='B') {
						for (i=0; i<1000; i++) {
							if (vR[i] >= 0) {
								for(i2=0; i2<1000; i2++) {
									if (vB[i2 >= 0]) {
										if (vR[i]==vB[i2]) {
											vB[i2]=-1;
										}
									}
								}
							}
						}
						tamb=tamb-x;
					}
					break;
					
				case 'P':
					cin >> x;
					cin >> o5;
					
					//Verifica se os elementos pertencem ao conjunto A
					if (o5=='a' || o5=='A') {											
						if (P(vA, x)) {
							cout << "Elemento " << x << " pertence ao conjunto." << endl;
						} else {
							cout << "Elemento " << x << " nao pertence ao conjunto." << endl;
						}
					}
					
					//Verifica se os elementos pertencem ao conjunto A
					if (o5=='b' || o5=='B') {
						if (P(vB, x)) {
							cout << "Elemento " << x << " pertence ao conjunto." << endl;
						} else {
							cout << "Elemento " << x << " nao pertence ao conjunto." << endl;
						}
					}
					break;
					
				case 'S':
					cin >> o6;
					cin >> o8;
					
					//Verifica se A é subconjunto de B
					if (o6=='a' && o8=='b'|| o6=='A' && o8=='B') {
						i3=0;
						if (tama<tamb || tama==tamb) {
							for (i=0; i<tama; i++) {
								if (vA[i]>=0) {
									for (i2=0; i2<tamb; i2++) {
										if (vA[i]==vB[i2]) {
											i3++;
										}
									}
								}
							}
						if (i3==tama-1 || i3==tama) {
							cout << "Conjunto eh subconjunto." << endl;
						} else {
							cout << "Conjunto nao eh subconjunto." << endl;
						}
						} if (tama>tamb) {
							cout << "Conjunto nao eh subconjunto." << endl;
						}
					}
					
					//Verifica se B é subconjunto de A
					if (o6=='b' && o8=='a'|| o6=='B' && o8=='A') {
						i3=0;
						if (tamb<tama || tama==tamb) {
							for (i=0; i<tamb; i++) {
								if (vB[i]>=0) {
									for (i2=0; i2<tama; i2++) {
										if (vB[i]==vA[i2]) {
											i3++;
										}
									}
								}
							}
						if (i3==tamb-1 || i3==tamb) {
							cout << "Conjunto eh subconjunto." << endl;
						} else {
							cout << "Conjunto nao eh subconjunto." << endl;
						}
						} if (tamb>tama) {
							cout << "Conjunto nao eh subconjunto." << endl;
						}
					}
					break;
				
				//Imprime a interseção dos conjuntos
				case 'I':
					I(vA, tama, vB, tamb);
					break;
					
				//Imprime a união dos conjuntos
				case 'U':
					U(vA, tama, vB, tamb, vU);
					BubbleSort(vU, 1000);
					p(vU, 1000);
					break;
						
				case 'D':
					cin >> o4;
					cin >> o9;
					
					//Imprime a diferença de A em B
					if(o4 == 'a' && o9=='b'|| o4 == 'A' && o9=='B') {
						D(vA, tama, vB, tamb);
					}
					
					//Imprime a diferença de B em A
					if(o4 == 'b' && o9=='a'|| o4 == 'B' && o9=='A') {
						D(vB, tamb, vA, tama);
					}
					
					break;
				
				case 'p':
					cin >> o3;
					
					//Imprime o conjunto A
					if (o3=='a' || o3=='A') {
						BubbleSort(vA, 1000);
						p(vA, 1000);
					}
					
					//Imprime o conjunto A
					if (o3=='b' || o3=='B') {
						BubbleSort(vB, 1000);
						p(vB, 1000);
					}
					break;
					
				//Verifica se os conjuntos são iguais
				case 'e':
					if (tama==tamb) {
						i=0;
						i2=0;
						while (i<tama) {
							if (vA[i]>=0 || vB[i]>=0) {	
								if (vA[i] != vB[i]) {
									i2++;
								} 
							}	
							i++;						
						}
						if (i2==0) {
							cout << "Conjuntos sao iguais." << endl;
						} else {
							cout << "Conjuntos sao diferentes." << endl;
						}
					} else if (tama!=tamb) {
						cout << "Conjuntos sao diferentes." << endl;
					}
					break;
				
				//Termina o programa	
				case 'F':
					l=1;
					break;
				
				default:
					cout << "Comando invalido. Entre com outro comando, ou 'F' para terminar." << endl;
			}
	}	
return 0;
}

Desde já agradeço.

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

@sasaakii     você tem certeza que esse código está funcionando ? ,  pois quando rodei ele, não consegui saber o que fazer pois não tem nenhuma informação explicando o que fazer,  então digitei alguns valores mas não deu em nada .  poste o enunciado desse programa e o que você quer que o programa faça .

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

Boa noite Devair, pois é, o código é assim mesmo, pois vai para um programa que lê parâmetros de entrada e saída padrões, precisam estar desse jeito para serem lidos.

Segue o enunciado:

Citação

Você deve desenvolver um programa para realizar operações básicas sobre conjuntos. No programa, um conjunto A e um conjunto B de números naturais serão simulados, sendo que ambos começam como o conjunto vazio, e tem seu valor alterado conforme as seguintes operações que devem ser implementadas pelo seu programa:

Adiciona elementos (indicado pela letra A): deve-se adicionar ao conjunto especificado uma coleção de N naturais.

Recebe-se como entrada o conjunto, indicado pelo caracter 'A' ou 'B', um número inteiro N e a seguir N números naturais X1, ... , XN, no formato "N X1 X2 ... XN".

Note que os números dados como entrada podem repetir, ou seja, você deve garantir que A continue sendo um conjunto após essa operação.


Remove elementos (indicado pela letra R): deve-se remover do conjunto especificado uma coleção de N inteiros.

Recebe-se como entrada o conjunto, indicado pelo caracter 'A' ou 'B', um número inteiro N e a seguir N números naturais X1, ... , XN, no formato "N X1 X2 ... XN".

Note que os números dados como entrada podem repetir. Você deve remover estes números do conjunto especificado, caso pertençam ao conjunto.


Pertence (indicado pela letra P): deve-se verificar se um elemento X pertence ao conjunto especificado.

Recebe-se como entrada um número natural X representando o elemento a ser procurado e o conjunto, indicado pelo caracter 'A' ou 'B'.

Caso o elemento pertença ao conjunto especificado, deve-se imprimir a mensagem "Elemento X pertence ao conjunto.", caso contrário, "Elemento X nao pertence ao conjunto.", sendo X o elemento pertencente dado como entrada.


Subconjuto (indicado pela letra S): deve-se verificar se o conjunto especificado (A ou B ) é subconjunto de um outro conjunto especificado (A ou B).

Recebe-se como entrada dois conjuntos indicados pelos caracteres 'A' ou 'B', a operação irá verificar se o primeiro conjunto indicado está contido no segundo conjunto.

Caso seja subconjunto, deve-se imprimir a mensagem "Conjunto eh subconjunto.", caso contrário, "Conjunto nao eh subconjunto.".


Interseção (indicado pela letra I): deve-se imprimir a interseção do conjunto A com o conjunto B.

Nenhum conjunto é especificado neste caso, a operação apenas imprime o resultado. A impressão do conjunto resultado deve estar ordenada.


União (indicado pela letra U): deve-se imprimir a união do conjunto A com o conjunto B.

Nenhum conjunto é especificado neste caso, a operação apenas imprime o resultado. A impressão do conjunto resultado deve estar ordenada.

 

Diferença (indicado pela letra D): deve-se imprimir a diferença de um conjunto especificado (A ou B ) para um segundo conjunto especificado (A ou B ).

 

Imprime (indicado pela letra p): deve-se imprimir na tela todos os elementos de um conjunto especificado (o caracter 'A' ou 'B'), em ordem crescente, com um espaço entre cada elemento e uma quebra de linha ao final da impressão. Para ordenar um vetor de inteiros utilize a função bubblesort abaixo, que implementa um algoritmo para ordenação de vetores inteiros.

 

Igualdade (indicado pela letra e): deve-se verificar se o conjunto A é igual ao conjunto B. Caso sejam iguais, deve-se imprimir a mensagem "Conjuntos sao iguais.", caso contrário, "Conjuntos sao diferentes.".

 

O seu programa deve funcionar recebendo esses comandos até que seja recebido como entrada o caractere f ou F. Caso o usuário entre com algum comando inválido, o programa deve imprimir a mensagem "Comando invalido. Entre com outro comando, ou 'F' para terminar.". Em todas as mensagens impressas devem ser acompanhadas de uma quebra de linha.

 

Segue também um exemplo de execução utilizando valores abaixo de 6:

Citação

A A 5 (adiciona 5 elementos ao vetor A)

2 3 4 5 6 (Elementos para adicionar)

p A (imprime o vetor A)

2 3 4 5 6 (Saída da impressão)

A A 5 (adiciona 5 elementos ao vetor A)

5 4 3 2 1 (Adiciona mais elementos ao vetor A, porém somente os não repetidos entrarão no vetor)

p A (Imprime novamente o vetor A)

1 2 3 4 5 6 (Saída da impressão)

A B 5 (adiciona 5 elementos ao vetor B )

1 2 3 4 5 (Elementos para adicionar)

p B (imprime o vetor B )

1 2 3 4 5 (Saída da impressão)

e (Comando para verificar igualdade)

Conjuntos sao diferentes. (Resposta do comando)

R A 1 (Remove do vetor A 1 valor)

1 (Valor a ser removido)

R B 1 (Remove do vetor B 1 valor)

1 (Valor a ser removido)

A B 1 (adiciona 1 elemento ao vetor B )

6 (Valor a ser adicionado)

p A (Imprime o vetor A)

2 3 4 5 6 (Valor impresso)

p B (Imprime o vetor B )

2 3 4 5 6 (Valor impresso)

e (Verifica igualdade)

Conjuntos sao iguais. (Resposta da verificação)

f (Termina o programa)

 

Eu sei que é um pouco confuso, mas o meu problema tem sido somente o fato de ele não trabalhar com valores maiores que 6 por algum motivo, de resto funciona de boa.

 

Valeu!

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora





Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×