SHARE
TWEET

Trabalho de Programação II

ihateanimes Apr 19th, 2019 (edited) 78 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <locale.h> //necessário para usar acentuação
  4.  
  5. void inserir(int conjunto[101],int qnt,char p){
  6.     //Função que insere um elemento dentro de um conjunto
  7.     int i=0,n=0;
  8.     //Entrada do elemento que será inserido no final do conjunto
  9.     printf("\nDigite o elemento que deseja inserir no conjunto %c: ",p);
  10.     scanf("%d",&n);
  11.     //Insere o elemento na ultima posição do conjunto
  12.     conjunto[qnt]=n;
  13.     //Impressão do conjunto
  14.     printf("\n%c = ",p);
  15.     if (qnt==0){
  16.         printf("{ %d }\n",conjunto[0]);
  17.     }
  18.     else{
  19.         for(i=0;i<qnt+1;i++){
  20.             if (i==0)
  21.                 printf("{ %d , ",conjunto[i]);
  22.             else if (i==qnt){
  23.                 printf("%d }",conjunto[qnt]);
  24.                 break;
  25.             }
  26.             else{
  27.                 printf("%d , ",conjunto[i]);
  28.             }
  29.  
  30.         }
  31.     }
  32. }
  33.  
  34. void remover(int conjunto[100],int qnt,char p){
  35.     //Função que le e remove um elemento de um conjunto
  36.     int i=0,n=0;
  37.     printf("\nDigite o elemento que deseja remover do conjunto %c: ",p);//Entrada do elemento que será removido do conjunto
  38.     scanf("%d",&n);
  39.     //Processo de remoção do elemento
  40.     for(i=0;i<qnt;i++){
  41.         if(conjunto[i]==n){
  42.                 qnt=qnt-1;
  43.                 while(i<qnt){
  44.                     conjunto[i]=conjunto[i+1];
  45.                     i++;
  46.                 }
  47.                 break;
  48.         }
  49.     }
  50.     //Impressão do conjunto
  51.     printf("\n%c = ",p);
  52.     if (qnt==1){
  53.         printf("{ %d }",conjunto[0]);
  54.     }
  55.     else if(qnt==0)
  56.         printf("Vázio\n");
  57.     else{
  58.             for(i=0;i<qnt;i++){
  59.             if (i==0)
  60.                 printf("{ %d , ",conjunto[i]);
  61.             else if (i+1==qnt){
  62.                 printf("%d }",conjunto[qnt]);
  63.                 break;
  64.             }
  65.             else{
  66.                 printf("%d , ",conjunto[i]);
  67.             }
  68.  
  69.         }
  70.     }
  71.  
  72. }
  73.  
  74.  
  75. int pertence(int conjunto[100],int qnt,char p){
  76.     //Função que verifica se um elemento pertence à um conjunto
  77.     int n=0,i;
  78.     //Leitura do elemento que será avaliado
  79.     printf("\nDigite o elemento que deseja verificar se pertence ao conjunto %c: ",p);
  80.     scanf("%d",&n);
  81.     //Processo de avaliação
  82.     for(i=0;i<qnt;i++){
  83.         if(conjunto[i]==n){
  84.             printf("\nO elemento %d pertence à %c!\n",n,p);
  85.             return 0;
  86.         }
  87.     }
  88.     printf("\nO elemento %d não pertence à %c!\n",n,p);
  89.     return 0;
  90. }
  91.  
  92. int subconjunto(int conjunto1[100],int conjunto2[100],int qnt1,int qnt2){
  93.     //Função que verifica se um conjunto B é subconjunto de um conjunto A
  94.     int i1,i2;
  95.     //Repetidores que verificam se o conjunto B pertence à A
  96.     for(i2=0;i2<qnt2;i2++){
  97.         for(i1=0;i1<qnt1;i1++){
  98.             if (conjunto2[i2]==conjunto1[i1])
  99.                 break;
  100.             else if((i1+1==qnt1) && (conjunto2[i2]!=conjunto1[i1+1]) ){
  101.                 printf("\nB não é subconjunto de A\n!");
  102.                 return 0;
  103.             }
  104.         }
  105.  
  106.     }
  107.     printf("\nB é subconjunto de A\n!");
  108.  
  109. }
  110.  
  111. void uniao(int conjunto1[100],int conjunto2[100],int qnt1,int qnt2){
  112.     //Função que realiza a união de um conjunto A e um conjunto B
  113.     int conjunto3[200],qnt3=0,i1,i2,i3=0;
  114.     if (qnt1>=qnt2){
  115.     //O conjunto resultante ja é preenchido com os elementos do conjunto com maior tamanho
  116.         for(i3=0;i3<qnt1;i3++){
  117.             conjunto3[i3]=conjunto1[i3];
  118.         }
  119.     //Bastando apenas colocar apenas os elementos que estão no menor tamanho no maior
  120.         for(i2=0;i2<qnt2;i2++){
  121.             for(i3=0;i3<qnt1;i3++){
  122.                 if(i3+1==qnt1){
  123.                     if(conjunto2[i2]==conjunto3[i3+1])
  124.                         break;
  125.                     conjunto3[qnt1]=conjunto2[i2];
  126.                     qnt1++;
  127.                     break;
  128.                 }
  129.                 if(conjunto2[i2]==conjunto3[i3]){
  130.                     break;
  131.                 }
  132.             }
  133.         }
  134.         qnt3=qnt1;
  135.     }
  136.     else if (qnt2>qnt1){
  137.         //O conjunto resultante ja é preenchido com os elementos do conjunto com maior tamanho
  138.         for(i3=0;i3<qnt2;i3++){
  139.             conjunto3[i3]=conjunto2[i3];
  140.         }
  141.         //Bastando apenas colocar apenas os elementos que estão no menor tamanho no maior
  142.         for(i1=0;i1<qnt1;i1++){
  143.             for(i3=0;i3<qnt2;i3++){
  144.                 if(i3+1==qnt2){
  145.                     if(conjunto1[i1]==conjunto3[i3+1])
  146.                         break;
  147.                     conjunto3[qnt2]=conjunto1[i1];
  148.                     qnt2++;
  149.                     break;
  150.                 }
  151.                 if(conjunto1[i1]==conjunto3[i3]){
  152.                     break;
  153.                 }
  154.             }
  155.         }
  156.         qnt3=qnt2;
  157.     }
  158.     //Impressão do conjunto resultante
  159.     printf("A união entre A e B é: ");
  160.     if(qnt3==0){
  161.         printf("Vázio\n");
  162.     }
  163.     else if(qnt3==1){
  164.         printf("{ %d }\n",conjunto3[0]);
  165.     }
  166.     else{
  167.         for(i3=0;i3<qnt3;i3++){
  168.             if (i3==0)
  169.                 printf("{ %d , ",conjunto3[i3]);
  170.             else if(i3+1==qnt3){
  171.                 printf("%d }",conjunto3[i3]);
  172.                 break;
  173.             }
  174.             else{
  175.                 printf("%d , ",conjunto3[i3]);
  176.             }
  177.         }
  178.     }
  179. }
  180.  
  181. void intersecao(int conjunto1[100],int conjunto2[100],int qnt1,int qnt2){
  182.     //Função que realiza a interseção entre um conjunto A e um conjunto B
  183.     int conjunto3[100],qnt3=0,i1,i2,i3=0;
  184.  
  185.     //O conjunto resultante receberá apenas os elementos que pertencem à A e B
  186.     for(i1=0;i1<qnt1;i1++){
  187.         for(i2=0;i2<qnt2;i2++){
  188.             if(conjunto1[i1]==conjunto2[i2]){
  189.                 conjunto3[i3]=conjunto1[i1];
  190.                 i3++;
  191.                 qnt3++;
  192.                 break;
  193.             }
  194.         }
  195.     }
  196.     //Impressão do conjunto resultante
  197.     printf("\nA interseção entre A e B é: ");
  198.     if(qnt3==0)
  199.         printf("Vázio\n");
  200.     else if(qnt3==1){
  201.         printf("{ %d }",conjunto3[0]);
  202.     }
  203.     else{
  204.         for(i3=0;i3<qnt3;i3++){
  205.             if (i3==0)
  206.                 printf("{ %d , ",conjunto3[i3]);
  207.             else if(i3+1==qnt3){
  208.                 printf("%d }",conjunto3[i3]);
  209.                 break;
  210.             }
  211.             else{
  212.                 printf("%d , ",conjunto3[i3]);
  213.             }
  214.         }
  215.     }
  216.  
  217. }
  218.  
  219. void subtracao(int conjunto1[100],int conjunto2[100],int qnt1,int qnt2){
  220.     //Função que realiza a operação A - B
  221.     int conjunto3[100],qnt3=0,i1,i2,i3=0;
  222.     //Realiza a comparação entre os elementos de A e B
  223.     for(i1=0;i1<qnt1;i1++){
  224.         for(i2=0;i2<qnt2;i2++){
  225.             if(conjunto1[i1]==conjunto2[i2])
  226.                 break;
  227.             else if((conjunto1[i1]!=conjunto2[i2]) && (i2+1==qnt2)){
  228.                 //Caso um elemento n pertença à A e não pertença à B, ele entra no conjunto resultante
  229.                 conjunto3[i3]=conjunto1[i1];
  230.                 i3++;
  231.                 qnt3++;
  232.                 break;
  233.             }
  234.         }
  235.     }
  236.     if (qnt2==0){
  237.         qnt3=qnt1;
  238.         for(i3=0;i3<qnt3;i3++){
  239.             conjunto3[i3]=conjunto1[i3];
  240.         }
  241.     }
  242.     //Impressão do conjunto resultante
  243.     printf("A - B = ");
  244.     if (qnt3==0)
  245.         printf("Vázio\n");
  246.     else if(qnt3==1)
  247.         printf("{ %d }",conjunto3[0]);
  248.     else{
  249.         for(i3=0;i3<qnt3;i3++){
  250.             if (i3==0)
  251.                 printf("{ %d , ",conjunto3[i3]);
  252.             else if(i3+1==qnt3){
  253.                 printf("%d }",conjunto3[i3]);
  254.                 break;
  255.             }
  256.             else{
  257.                 printf("%d , ",conjunto3[i3]);
  258.             }
  259.         }
  260.     }
  261. }
  262. void produto_cartesiano(int conjunto1[100],int conjunto2[100],int qnt1,int qnt2){
  263.     int c1,c2;
  264.     printf("\nA x B = ");
  265.     if (qnt1==0 || qnt2==0)
  266.         printf("Vázio\n");
  267.  
  268.     else{
  269.         //Realiza a Operação do produto cartesiano
  270.         for(c1=0;c1<qnt1;c1++){
  271.             for(c2=0;c2<qnt2;c2++){
  272.                 if (c2==0 && c1==0)
  273.                     printf("{ (%d,%d) , ",conjunto1[c1],conjunto2[c2]);
  274.                 else if ((c2+1==qnt2) && (c1+1==qnt1)){
  275.                     printf("(%d,%d) }\n",conjunto1[c1],conjunto2[c2]);
  276.                     break;
  277.                 }
  278.                 else
  279.                     printf("(%d,%d) , ",conjunto1[c1],conjunto2[c2]);
  280.             }
  281.         }
  282.     }
  283. }
  284.  
  285.  
  286. void imprimir(int conjunto[100],int qnt,char c){
  287.     //Função que apenas imprimi os elementos de um conjunto A
  288.     int i;
  289.     //Imprime o conjunto A
  290.     printf("\n\nConjunto %c: ",c);
  291.     if (qnt==0)
  292.         printf("Vázio\n");
  293.     else if(qnt==1){
  294.         printf("{ %d }",conjunto[0]);
  295.     }
  296.     else{
  297.         for(i=0;i<qnt;i++){
  298.             if (i==0)
  299.                 printf("{ %d , ",conjunto[i]);
  300.             else if(i+1==qnt){
  301.                 printf("%d }",conjunto[i]);
  302.                 break;
  303.             }
  304.             else{
  305.                 printf("%d , ",conjunto[i]);
  306.             }
  307.         }
  308.     }
  309. }
  310. int main(){
  311.     //Função menu, atráves dela todas as operaçoes são realizadas
  312.     setlocale(LC_ALL, "Portuguese");//Comando necessario para usar a acentuação e caracteres especificos da lingua portuguesa
  313.     int conjunto1[100],conjunto2[100],conjunto3[100],qnt1=0,qnt2=0,qnt3=0,i1,i2,i3=0,o=0;
  314.     char r='S',p='N';
  315.  
  316.     //Leitura dos elementos e da quantidade de elementos dos conjuntos A e B respectivamente
  317.     printf("\nDigite a quantidade de elementos do conjunto A: ");
  318.     scanf("%d",&qnt1);
  319.     printf("\nDigite os elementos do conjunto A: \n");
  320.     for(i1=0;i1<qnt1;i1++){
  321.         scanf("%d",&conjunto1[i1]);
  322.     }
  323.     printf("\nDigite a quantidade de elementos do conjunto B: ");
  324.     scanf("%d",&qnt2);
  325.     printf("\nDigite os elementos do conjunto B: \n");
  326.     for(i2=0;i2<qnt2;i2++){
  327.         scanf("%d",&conjunto2[i2]);
  328.     }
  329.     //Repetidor para continuar fazendo operações
  330.     while(r=='S' || r=='s'){
  331.         printf("_______________________________________________________________\n");
  332.         printf("| Código |                     Operação                        |\n");
  333.         printf("|--------|-----------------------------------------------------|\n");
  334.         printf("|   01   |  Inserir um elemento em um conjunto                 |\n");
  335.         printf("|   02   |  Remover um elemento de um conjunto                 |\n");
  336.         printf("|   03   |  Verificar se um elemento pertence à um conjunto    |\n");
  337.         printf("|   04   |  Verificar se um conjunto é subconjunto de outro    |\n");
  338.         printf("|   05   |  Realizar a união de dois conjuntos                 |\n");
  339.         printf("|   06   |  Realizar a interseção entre dois conjuntos         |\n");
  340.         printf("|   07   |  Realizar a diferênca entre dois conjuntos          |\n");
  341.         printf("|   08   |  Realizar o produto cartesiano entre dois conjuntos |\n");
  342.         printf("|   09   |  Imprimir os elementos de um conjunto               |\n");
  343.         printf("|   10   |  Sair                                               |\n");
  344.         printf("|________|_____________________________________________________|\n\n");
  345.  
  346.         printf("\nDigite o código correspondente a operação que deseja realizar: ");
  347.         scanf("%d",&o);
  348.         //Switch case para o menu de opções
  349.         switch(o){
  350.         case(1):
  351.             while((p!='A') && (p!='a') && (p!='B') && (p!='b')){
  352.                 printf("\nCom qual dos conjuntos deseja realizar a operação ? ");
  353.                 scanf(" %c",&p);
  354.                 if (p=='A' || p=='a'){
  355.                     inserir(conjunto1,qnt1,'A');
  356.                     qnt1=qnt1+1;
  357.                 }
  358.                 else if ((p=='B') || (p=='b')){
  359.                     inserir(conjunto2,qnt2,'B');
  360.                     qnt2=qnt2+1;
  361.                 }
  362.                 else
  363.                     printf("\nConjunto inválido!\n");
  364.             }
  365.             break;
  366.         case(2):
  367.             while((p!='A') && (p!='a') && (p!='B') && (p!='b')){
  368.                 printf("\nCom qual dos conjuntos deseja realizar a operação ? ");
  369.                 scanf(" %c",&p);
  370.                 if (p=='A' || p=='a'){
  371.                     remover(conjunto1,qnt1,'A');
  372.                     qnt1=qnt1-1;
  373.                 }
  374.                 else if ((p=='B') || (p=='b')){
  375.                     remover(conjunto2,qnt2,'B');
  376.                     qnt2=qnt2-1;
  377.                 }
  378.                 else
  379.                     printf("\nConjunto inválido!\n");
  380.             }
  381.             break;
  382.         case(3):
  383.             while((p!='A') && (p!='a') && (p!='B') && (p!='b')){
  384.                 printf("\nCom qual dos conjuntos deseja realizar a operação ? ");
  385.                 scanf(" %c",&p);
  386.                 if (p=='A' || p=='a')
  387.                     pertence(conjunto1,qnt1,'A');
  388.                 else if ((p=='B') || (p=='b'))
  389.                     pertence(conjunto2,qnt2,'B');
  390.                 else
  391.                     printf("\nConjunto inválido!\n");
  392.             }
  393.             break;
  394.         case(4):
  395.             subconjunto(conjunto1,conjunto2,qnt1,qnt2);
  396.             break;
  397.         case(5):
  398.             uniao(conjunto1,conjunto2,qnt1,qnt2);
  399.             break;
  400.         case(6):
  401.             intersecao(conjunto1,conjunto2,qnt1,qnt2);
  402.             break;
  403.         case(7):
  404.             subtracao(conjunto1,conjunto2,qnt1,qnt2);
  405.             break;
  406.         case(8):
  407.             produto_cartesiano(conjunto1,conjunto2,qnt1,qnt2);
  408.             break;
  409.         case(9):
  410.             imprimir(conjunto1,qnt1,'A');
  411.             imprimir(conjunto2,qnt2,'B');
  412.             break;
  413.         case(10):
  414.             return 0;
  415.         default:
  416.             printf("\nOperação inválida!\n\n");
  417.         }
  418.         printf("\n\nDeseja realizar outra operação ?\n");
  419.         scanf(" %c",&r);
  420.         if ((r=='S') || (r=='s')){
  421.             system("cls");
  422.             imprimir(conjunto1,qnt1,'A');
  423.             imprimir(conjunto2,qnt2,'B');
  424.             printf("\n\n");
  425.             p='N';
  426.         }
  427.     }
  428. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top