Ajuda em criação do código

[AkromaclouD]

Boa noite galera, novo aqui no forum... rsr

Estou com um trabalho da faculdade para criação de um código do seguinte enunciado que o prof. que passou:

-Utilizando um vetor de N posições. Solicitar ao usuário quantas posições ele quer usar do vetor. O intervalo será de no mínimo 10 e no máximo 20 posições.

-Caso seja menor ou maior que isso informar ao usuario que ele esta fora da quantidade máxima ou mínima de posições.

-Ler os números fornecidos pelo usuário e gravar nas posições do vetor. Imprimir o vetor fornecido pelo usuário.

-Primeiro Calculo: verificar cada posição do vetor pegar o conteúdo de cada posição e fazer fatorial do mesmo.

Imprimir os resultados.

-Segundo Cálculo: utilizando o resultado do primeiro calculo verificar quais numeros são primos. Imprimir os numeros na tela.

alguém pode me dar uma luz ? To mal nessa matéria. ;/

No aguardo.

[mJi]

Me parece bem simples... peça para o usuário digitar o tamanho do vetor. Se o valor digitado for maior que 20 ou menor que 10, dê um aviso e peça para o usuário digitar outro valor. Se estiver entre 10 e 20, declare um vetor com o número de posições que o usuário escolheu.

Através de um laço, peça para que o usuário vá digitando números, e vá colocando nas posições do vetor até enchê-lo.

Para imprimir o vetor, também use um laço.

Para o cálculo de fatorial, basta multiplicar o número pelos seus antecessores até o número 1. Para o saber se um número é primo, basta efetuar restos de divisões dele por 2 até a metade dele. Se houver uma divisão sem resto, não é primo.

[AkromaclouD]

mJi

não me ajudou muito não, hauhusah .

Como fica que fica o codigo disso ?

[mJi]

Ao menos tente fazer e poste aqui.

[jotâo]

:wub:

Amigão,

Boa Noite!!!!

A ideia consiste no respectivo desenvolvimento:

Vamos contemplar um vetor dentro do conceito - dicotomia classe/objeto,onde primeiramente entenderemos os fragmentos do problema propostos

Um vetor possui:

* um intervalo inicial( que geralmente inicializa com o fator zero( 0 ) ou um( 1 ),conforme for o caso;

* um intervalo final( que estabelecerá o limite minimo ou maximo pretendido, no caso 10 a 20, obº quantidade de numeros de elementos do vetor/matriz;

* uma variável do tipo subscrito, que por convenção geralmente e representado pela letra ( x );

* e finalmente um nome identificador do suposto vetor, qualquer coisa que seja vetorA, vtA, do tipo inteiro;

Algoritimamente falando essa parte ficaria assim:

inteiro: intervalo_inicial <- 0;

inteiro: intervalo_final <- 0;

inteiro: x;

inteiro: vetorA[intervalo_final]; "Aqui estamos estabelecendo apenas que o vetor não contém ou recebe nenhum elemento ainda"

O Vetor passará a existir e será povoado apartir deste fragmento, onde iremos declarar uma variavel para que possa capturar a quantidade especifica pelo usuario:

inteiro quantidade_de_elementos;

A instrução de comando ficaria dessa forma:

escreva:"Informe a quantidade de elementos pretendida:";

leia: quantidade_de_elementos;

Feito isto, aí é que faremos o teste condicional do se, senão....blá, blá, blá, faça alguma coisa.

se(quantidade_de_elemento for menor ( > ) que 10) E (quantidade_de_elementos for maior que ( < ) 20) então

escreva:"Limite digitalizado fora de faixa digite um valor que esteja entre 10 e 20";

senão

se(quantidade_de_elementos for maior igual a 10 ( <= ) E (quantidade_de_elementos for menor igual a 20 ( >= ) então

intervalo_final <- quantidade_de_elementos;

Aqui determinamos o limite final para o vetor; iremos povoa-lo neste momento, eu tenho costume de desenvolver o laço ou loop do vetor com uma variavel fator para receber o valor do elemento.

inteiro fator <- 0;

Laço For algoritimicamente falando:

Para: ( x <- intervalo_inicial; ate x < (intervalo_final); de x Passo x + 1) Faça

escreva:"Informe o valor do elemento:"

leia: fator;

vetorA[x] <- fator;

Imprimindo o vetor:

Para:( x <- (intervalo_inicial); até x < (intervalo_final); de x Passo (x+1) Faça

escreva: vetorA[x];

Efetuando o Primeiro calculo do Fatorial

variaveis:

inteiro: y;

inteiro:fatorial;

inteiro: vetorFatorial[intervalo_final];

Para(x <- (intervalo_inicial); ate x < (intervalo_final); de x Passo(x+1) Faca

fatorial <- 1;

Para( y <- (intervalo_inicial + 1) ate y (vetorA[x]); de y Passo(y + 1) Faca;

fatorial <- (fatorial * y);

vetorFatorial[x] <- fatorial;

Imprimindo o Vetor com o Calculo do Fatorial:

Para(x <-(intervalo_inicial); ate x < (intervalo_final); de x Passo(x+1)Faca;

escreva: vetorFatorial[x];

Quanto ao numero primo, é considerado numero primo aquelo q. e divido por 1 e por ele mesmo e resulte como resto 0, pelo que sabemos que o unico numero primo par é o 2, que é divisivel por 1 e por

ele mesmo, então logicamente que a maior parte dos numeros impares seriam primos.

Tente dentro deste contexto desenvolver a sua logica baseado nos fragmentos da resolução do problema acima.

Amanhã te passo o código em C++ e o restante do problema resolvido.

Jotão!

[AkromaclouD]

No aguardo Jotao!

[jotâo]

B)

Desenvolvimento da Primeira Operação: Calculo do Factorial.

Segundo Fragmento do exercicio/Problema Proposto.

#include<conio.h>

#include<iostream>
using namespace std;
using std::cout;
using std::cin;
using std::endl;

#if !defined( z )
#define z 0
#endif

#if !defined( u )
#define u 1
#endif

#if !defined(int_inferior)
#define int_inferior 1
#endif

#if !defined(int_superior)
#define int_superior 20
#endif

unsigned long int function_calcularFactorial(unsigned long int,unsigned long int);

unsigned long int main()
{
 system("CLS");

  unsigned long int subs_x = ( z );
  unsigned long int input_value_factor = ( z );
  unsigned long int array_factors[int_superior];
  unsigned long int array_factorials[int_superior];
  unsigned long int elemento_factorial = ( z );
  unsigned long int calcular_factorial = ( z );
  unsigned long int resposta_calculo_factorial = ( z );
  
   for(subs_x = (int_inferior);subs_x < (int_superior);subs_x = (subs_x + u))
   {
    array_factors[subs_x] = ( z );
   }
    
   for(subs_x = (int_inferior);subs_x < (int_superior);subs_x = (subs_x + u))
   {
    array_factorials[subs_x] = ( z );
   }

   for(subs_x = (int_inferior);subs_x < (int_superior);subs_x = (subs_x + u))
   {
    cout <<"\nInforme no campo abaixo o valor do: " <<subs_x <<"º Inteiro Numerico: " <<endl;
    cout <<"\nValor Numerico: ";
    cin >>input_value_factor;
    array_factors[subs_x] = (input_value_factor);
    cout <<endl;
   }

   for(subs_x = (int_inferior);subs_x < (int_superior);subs_x = (subs_x + u))
   {
    elemento_factorial = (array_factors[subs_x]);
    resposta_calculo_factorial = function_calcularFactorial(elemento_factorial,calcular_factorial);
    array_factorials[subs_x] = (resposta_calculo_factorial);
   }
    
    cout <<"\nResultado do Calculo do Factorial:" <<endl;
    for(subs_x = (int_inferior);subs_x < (int_superior);subs_x = (subs_x + u))
    {
     cout <<"!"<<array_factors[subs_x] <<" = " <<array_factorials[subs_x] <<endl; 
    }

 system("PAUSE");

 return(NULL);

}

unsigned long int function_calcularFactorial(unsigned long int elemento,unsigned long int calculo_factorial)
{
 unsigned long int subs_f = ( z );
 unsigned long int elemento_factorial = ( z );
 unsigned long int factorial = ( u );

 if(elemento <= u )
 {
  calculo_factorial = ( u );
  return(calculo_factorial);
 }
 else
  if(elemento > u )
  {
   for(subs_f = (elemento);subs_f >= (int_inferior); (subs_f = subs_f - u))
   {
    elemento_factorial = (subs_f);
    factorial = (factorial * elemento_factorial);
   }
  }
  calculo_factorial = (factorial);
  return(calculo_factorial);
}

Apenas uma pequena idéia.

Editado Novembro 26, 2011 por jotâo

[mJi]

Ah, pra calcular fatorial, uma funçãosinha bem simples resolve...

int fatorial(int num){
    int fat=1;

    for(;num>1;num--)
        fat *= num;
        return(fat);
}

Ou se preferir recursiva...

int fatorialr(int num){
    if(num-1)
        return(num * fatorialr(num-1));
   else
        return(1);
}

Editado Novembro 27, 2011 por mJi