Ir ao conteúdo
  • Cadastre-se
drandrezinho123

Exercícios c++ Programação Estruturada

Recommended Posts

OLÁ, GALERA, PRECISO MUITO DA AJUDA DE VOCÊS PARA RESOLVER ALGUNS EXERCÍCIOS ESTOU COM DIFICULDADES FICAREI MT GRATO PELA AJUDA!!

 

 

1. Implementar um programa em C que encontre os três maiores elementos primos de três matrizes bidimensionais. A função ehPrimo já é dada. 2. Implementar um programa em C para obter o menor elemento de uma matriz tridimensional.

3. Implementar um programa em C para somar duas matrizes tridimensionais de ordem M por N.

4. Implementar um programa em C para obter o fatorial e Fibonacci são dadas

5. Implementar um programa em C para obter o Fibonacci de um número N.

6.Implementar um programa em C para obter o fatorial dos N primeiros números da série de Fibonacci.

 

 

DEIXAREI DOIS EXEMPLOS ABAIXO PARA OBSERVAR OS MODELOS E FAZER DO JEITO DELES PARA OS EXERCÍCIOS ACIMA!!

 

 

ESSE É DE ALOCAR MATRIZ2D

 

/*--------------------------------------------------------------*/
/* Bibliotecas                                                  */
/*--------------------------------------------------------------*/
#include<stdio.h>
#include<string.h>
#include<math.h>
#include <stdlib.h>
#include <conio.h>
/*--------------------------------------------------------------*/
/* Constante                                                    */
/*--------------------------------------------------------------*/
#define SAIR 0
/*--------------------------------------------------------------*/
/* Vari?veis Globais                                            */
/*--------------------------------------------------------------*/
float **dmatriz;//matriz alocada dinamicamente
int M;//Linhas da matriz
int N;//Colunas da matriz
/*--------------------------------------------------------------*/
/* Variaveis Globais de Controle                                */
/*--------------------------------------------------------------*/
int opcao1;
int opcao2;
int opcao3;
/*--------------------------------------------------------------*/
/* Prot?tipos                                                   */
/*--------------------------------------------------------------*/
void comportamentoInicial();
void menu();
void fgerenciadora(int);
void getCoeficiente();
void esperarTela();
void alocarMatriz();
void dimensionarMatriz();
void obterLinhas();
void obterColunas();
float obterMenorElemento();
void imprimirMenorElemento();
void obterElementos();
void limparMemoria();
/*--------------------------------------------------------------*/
main()
{
  comportamentoInicial();
  menu();
}
 
void comportamentoInicial()
{
  opcao1=0;
  opcao2=0;
  opcao3=0;
}
 
void menu()
{
  int opcao;
  do{      
system("cls");
printf("Digite:\n");
printf("0 - Para Sair do Sistema\n");
printf("1 - Para dimensionar a matriz\n");
printf("2 - Para entrar com os elementos da matriz\n");
printf("3 - Para encontrar o menor elemento da matriz\n");
printf("4 - Para limpar memoria\n");
scanf("%d",&opcao);     
    fgerenciadora(opcao);
  }while(opcao != SAIR);
}
 
void fgerenciadora(int opcao)
{
  switch(opcao)
  {
    case 1: 
      dimensionarMatriz();
      opcao1=1;/* a opcao 1 foi selecionada*/
      break;
    case 2:
           if(opcao1)
           {   
    alocarMatriz();
             obterElementos();
             opcao2=1;  /* a opcao 2 foi selecionada*/
           }
           else
           {
            printf("\nDeve-se dimensionar a matriz antes de entrar com os elementos ...\n");
      }
           break; 
    case 3: 
           if(opcao2)
           {   
        imprimirMenorElemento();
        opcao3=1; /* a opcao 3 foi selecionada*/
      }
           else
             if(!opcao1)
             {
              printf("\nDeve-se dimensionar a matriz antes de entrar com os elementos ...\n");
        }
             else
              if(!opcao2)
             {
              printf("\nDeve-se entrar com os elementos antes de procurar pelo menor elemento...\n");
        }
        break;
    case 4: 
      if(opcao1)       
      {   
    limparMemoria();
    comportamentoInicial();
  }
  else  
    printf("\nA matriz nao foi alocada anteriormente \n");
      break;
 
  }
  esperarTela();
}
 
void alocarMatriz()
{
    int i;
dmatriz=(float **)malloc(sizeof(float)*M);
    for(i=0; i<M;i++)
     dmatriz=(float *)malloc(sizeof(float)*N);
}
   
 
void esperarTela()
{
   printf("\nDigite qualquer tecla para continuar ...\n");
   getch();
}
 
void dimensionarMatriz()
{
  obterLinhas();
  obterColunas();
}
 
void obterLinhas()
{
  printf("Entre com a quantidade de linhas da matriz\n");
  scanf("%d",&M);
}
 
void obterColunas()
{
  printf("Entre com a quantidade de colunas da matriz\n");
  scanf("%d",&N);
}
 
void obterElementos()
{ int i,j;
  for(i=0; i<M; i++)
    for(j=0; j<N; j++)
    {
 printf("\nDigite o elemento matriz[%d][%d]=",i,j);
 scanf("%f",&dmatriz[j]);  
    }
}
 
void imprimirMenorElemento()
{
float menor=obterMenorElemento();
printf("\n\n O menor elemento é: %f\n\n",menor);
}
 
float obterMenorElemento()
  int i,j;
  float menor=dmatriz[0][0];
  for(i=1; i<M; i++)
    for(j=0; j<N; j++)
    {
 if(menor>dmatriz[j])
    menor=dmatriz[j];
    }
    return menor;
}
 
void limparMemoria()
{
free(dmatriz);
printf("\n\n memoria limpa!!!\n\n");
}
 
 
E ESSE  OPERAÇÕESMATRIZES
 
 
 
/*--------------------------------------------------------------*/
/* Bibliotecas                                                  */
/*--------------------------------------------------------------*/
#include<stdio.h>
#include<string.h>
#include<math.h>
#include <stdlib.h>
#include <conio.h>
/*--------------------------------------------------------------*/
/* Constante                                                    */
/*--------------------------------------------------------------*/
#define SAIR 0
/*--------------------------------------------------------------*/
/* Estrutura                                            */
/*--------------------------------------------------------------*/
struct EMatriz
{
  float **dmatriz;//matriz alocada dinamicamente
  int lin;//Linhas da matriz
  int col;//Colunas da matriz
};
/*--------------------------------------------------------------*/
/* Vari?veis Globais                                            */
/*--------------------------------------------------------------*/
struct EMatriz matA;
struct EMatriz matB;
struct EMatriz matR;/*matriz de resultados*/
/*--------------------------------------------------------------*/
/* Variaveis Globais de Controle                                */
/*--------------------------------------------------------------*/
int opcao1;
int opcao2;
int opcao3;
/*--------------------------------------------------------------*/
/* Prot?tipos                                                   */
/*--------------------------------------------------------------*/
void comportamentoInicial();
void menu();
void fgerenciadora(int);
void getCoeficiente();
void esperarTela();
float** alocarMatriz(int, int);
void dimensionarMatriz();
int obterLinhas();
int obterColunas();
float obterMenorElemento(struct EMatriz);
void imprimirMenorElemento();
void obterElementos();
void limparMemoria();
void imprimirMatriz();  
void entrarElementos(struct EMatriz *matAux);
void imprimirElementos(struct EMatriz matAux);
/*--------------------------------------------------------------*/
main()
{
  comportamentoInicial();
  menu();
}
 
void comportamentoInicial()
{
  opcao1=0;
  opcao2=0;
  opcao3=0;
}
 
void menu()
{
  int opcao;
  do{      
system("cls");
printf("Digite:\n");
printf("0 - Para Sair do Sistema\n");
printf("1 - Para dimensionar a matriz \n");
printf("2 - Para entrar com os elementos da matriz\n");
printf("3 - Para encontrar o menor elemento da matriz\n");
printf("4 - Para limpar memoria\n");
printf("5 - Para imprimir os elementos da matriz\n");
scanf("%d",&opcao);     
    fgerenciadora(opcao);
  }while(opcao != SAIR);
}
 
void fgerenciadora(int opcao)
{
  switch(opcao)
  {
    case 1: 
      dimensionarMatriz();
      opcao1=1;/* a opcao 1 foi selecionada*/
      break;
    case 2:
           if(opcao1)
           {       
             obterElementos();
             opcao2=1;  /* a opcao 2 foi selecionada*/
           }
           else
           {
            printf("\nDeve-se dimensionar a matriz antes de entrar com os elementos ...\n");
      }
           break; 
    case 3: 
           if(opcao2)
           {   
        imprimirMenorElemento();
        opcao3=1; /* a opcao 3 foi selecionada*/
      }
           else
             if(!opcao1)
             {
              printf("\nDeve-se dimensionar a matriz antes de entrar com os elementos ...\n");
        }
             else
              if(!opcao2)
             {
              printf("\nDeve-se entrar com os elementos antes de procurar pelo menor elemento...\n");
        }
        break;         
    case 4: 
      if(opcao1)       
      {   
    limparMemoria();
    comportamentoInicial();
  }
  else  
    printf("\nA matriz nao foi alocada anteriormente \n");
      break;
case 5:
{
imprimirMatriz();
}            
  }
  esperarTela();
}
 
float** alocarMatriz(int lin, int col)
{
    float **dmatriz;
int i;
dmatriz=(float **)malloc(sizeof(float)*lin);
    for(i=0; i<lin;i++)
     dmatriz=(float *)malloc(sizeof(float)*col);
    return dmatriz;  
}
   
 
void esperarTela()
{
   printf("\nDigite qualquer tecla para continuar ...\n");
   getch();
}
 
void dimensionarMatriz()
{
int lin, col;
int opcao=0;
system("cls");
printf("Escolha a matriz:\n");
printf("1 - Matriz de Entrada A\n");
printf("2 - Matriz de Entrada B \n");
printf("3 - Matriz de Resultados R \n");
scanf("%d",&opcao);
    if(!(((opcao==1)||(opcao==2))||(opcao==3)))
    {
      printf("\nAs unicas opções validas sao [1], [2]e [3] \n");
      return;
}     
    
lin=obterLinhas();
    col=obterColunas();
    if(opcao==1)
    {
      matA.dmatriz=alocarMatriz(lin, col);
      matA.lin=lin;
      matA.col=col;
      return;
    }
    
    if(opcao==2)
    {
      matB.dmatriz=alocarMatriz(lin, col);
      matB.lin=lin;
      matB.col=col;
      return;
    }
 
    if(opcao==3)
    {
      matR.dmatriz=alocarMatriz(lin, col);
      matR.lin=lin;
      matR.col=col;
    }    
}
 
int obterLinhas()
{
  int lin;
  printf("Entre com a quantidade de linhas da matriz\n");
  scanf("%d",&lin);
  return lin;
}
 
int obterColunas()
{
  int col;
  printf("Entre com a quantidade de colunas da matriz\n");
  scanf("%d",&col);
  return col;
}
 
void obterElementos()
{
  printf("\nMatriz de Entrada A\n");
  entrarElementos(&matA);
  printf("\nMatriz de Entrada B\n");
  entrarElementos(&matB);
}
 
void entrarElementos(struct EMatriz *matAux)
{ int i,j;
  for(i=0; i<(*matAux).lin; i++)
    for(j=0; j<(*matAux).col; j++)
    {
 printf("\nDigite o elemento matriz[%d][%d]=",i,j);
 scanf("%f",&(*matAux).dmatriz[j]);  
    }
}
 
int escolhaMatriz()
{
  int opcao=0;
  system("cls");
  printf("Escolha a matriz:\n");
  printf("1 - Matriz de Entrada A\n");
  printf("2 - Matriz de Entrada B \n");
  scanf("%d",&opcao);
  if(!((opcao==1)||(opcao==2)))
  {
     printf("\nAs unicas opções validas sao [1] e [2] \n");
     return 0;
  }
  return opcao;
}
 
void imprimirMenorElemento()
{
float menor;
int opcao=escolhaMatriz();
    if(!opcao)
  return;
if(opcao==1)
 menor=obterMenorElemento(matA);
    else
 menor=obterMenorElemento(matB);
 
printf("\n\n O menor elemento é: %f\n\n",menor);
}
 
float obterMenorElemento(struct EMatriz matAux)
  int i,j;
  float menor=matAux.dmatriz[0][0];
  for(i=1; i<matAux.lin; i++)
    for(j=0; j<matAux.col; j++)
    {
 if(menor>matAux.dmatriz[j])
    menor=matAux.dmatriz[j];
    }
    return menor;
}
 
void limparMemoria()
{
free(matA.dmatriz);
free(matB.dmatriz);
free(matR.dmatriz);
printf("\n\n memoria limpa!!!\n\n");
}
 
void imprimirMatriz()
{
int opcao=escolhaMatriz();
if(opcao==1)
 imprimirElementos(matA);
else  
 imprimirElementos(matB);
}
  
void imprimirElementos(struct EMatriz matAux)
{
  int i,j;
  
  for(i=0; i<matAux.lin; i++)
    for(j=0; j<matAux.col; j++)
    {  
  printf("\n matriz[%d][%d]=%f",i,j,matAux.dmatriz[j]);
    }    
}
 

ESSES SÃO EXEMPLOS QUE ELE PASSOU PARA FAZER NOS  6 PROBLEMAS ACIMA ESPERO QUE ME AJUDEM PRECISO MT MT mesmo FICAREI SUPER GRATO!!

 

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

×