private void Exercicio_5_23()
{
Clear();
int Limite;
Write(" Digite ate onde você quer saber a soma dos numeros -> ");
Limite = int.Parse(ReadLine());
Contador contador = new Contador(1, Limite, 1);
Somatoria somatoria = new Somatoria();
while (contador.Prosseguir())
{
WriteLine();
Write(contador.Valor);
WriteLine();
somatoria.Somar(contador.Valor);
}
Write("\n\n============================\n\n");
WriteLine(" SOMA TOTAL = {0} ", somatoria.Valor);
Tratador();
}
public int ParaBinario()
{
int dividendo = numeroInteiro;
int quociente = 0;
int resto = 0;
int soma;
int numeroBinario = 0;
var umContador = new Contador(0, int.MaxValue, 1);
var umSomador = new Somatoria();
while (quociente != 1 && dividendo != 1)
{
quociente = dividendo / 2;
resto = dividendo - quociente * 2;
umSomador.Somar(resto * Pow(10, umContador.Valor));
dividendo = quociente;
umContador.Contar();
}
umSomador.Somar(1 * Pow(10, umContador.Valor));
numeroBinario = Convert.ToInt32(umSomador.Valor);
return(numeroBinario);
}
public double Cosseno(double anguloEmGraus)
{
// convertemos angulo em graus para medida em radianos
double x = anguloEmGraus * Math.PI / 180;
int sinal = 1;
var soma = new Somatoria();
var i = new Contador(0, 2 * numeroInteiro, 2);
while (i.Prosseguir)
{
var meuMat = new Matematica(i.Valor);
double potenciaDeX = meuMat.Elevado(x);
double fat = meuMat.Fatorial();
double umTermo = potenciaDeX / fat;
soma.Somar(sinal * umTermo);
sinal = -sinal;
i.Contar();
}
return(soma.Valor);
}
private void Exercicio_5_7()
{
Clear();
int Limite;
Write(" Digite ate onde você quer contar : ");
Limite = int.Parse(ReadLine());
Contador contador1 = new Contador(1, Limite, 1);
Somatoria somatoria = new Somatoria();
while (contador1.Prosseguir())
{
WriteLine();
Write(contador1.Valor);
somatoria.Somar(contador1.Valor);
}
WriteLine();
WriteLine("======================");
Write(" SOMA = {0} | MEDIA = {1} ", somatoria.Valor, somatoria.MediaAritmetica());
Tratador();
}
private static void LerArquivo()
{
Clear();
WritePos(2, 2, "Insira o nome do arquivo texto: ");
WritePos(2, 3, "(localizado na pasta root do projeto)");
WritePos(2, 4, @"..\..\ .txt");
SetCursorPosition(8, 4);
string caminho;
try // executa o código verificando por exceções
{
string arquivo = ReadLine();
if (arquivo.EndsWith(".txt")) // verifica se o usuário inseriu ".txt" no fim do
{ // nome do arquivo, se não, insere automaticamente
caminho = @"..\..\" + arquivo;
}
else // também é feita uma concatenação, completando o nome
{ // do arquivo com um comando para voltar duas pastas no
caminho = @"..\..\" + arquivo + ".txt"; // sistema de arquivos, de modo a encontrar o arquivo na
} // pasta root do projeto, e não em "\bin\Debug"
var reader = new StreamReader(caminho); // instancia um StreamReader usando a string concatenada com o arquivo
var somaGeral = new Somatoria(); // somatória de todos os números lidos
var somaV = new Somatoria(); // somatória dos valores V lidos com peso P
var somaP = new Somatoria(); // somatória apenas dos valores P lidos
var prodGeral = new Produtorio(); // produtório de todos os números lidos
var somaInversos = new Somatoria(); // somatória dos inversos de todos os números lidos
while (!reader.EndOfStream)
{
string linhaLida = reader.ReadLine(); // lê a linha e divide os valores em
double v = double.Parse(linhaLida.Substring(0, 8)); // v,
double p = double.Parse(linhaLida.Substring(8, 8)); // p
somaGeral.Somar(v); // adiciona v e p à soma geral
somaGeral.Somar(p);
somaV.Somar(v * p); // adiciona v com peso p à somaV
somaP.Somar(p); // adiciona p à somaP
prodGeral.Multiplicar(v); // adiciona v e p ao produtório geral
prodGeral.Multiplicar(p);
somaInversos.Somar(1 / v); // adiciona os inversos de v e p à soma dos inversos
somaInversos.Somar(1 / p);
} // repete até o fim do arquivo
var mat = new MatematicaDouble(prodGeral.Valor);
WritePos(2, 6, $"RMQ = {Math.Sqrt(somaGeral.MediaAritmetica())}"); // calcula RMQ como a raiz da MA
WritePos(2, 7, $"MA = {somaGeral.MediaAritmetica()}"); // calcula MA
WritePos(2, 8, $"MP = {somaV.Valor / somaP.Valor}"); // calcula MP como média entre V com peso e P
WritePos(2, 9, $"MG = {mat.NEsimaRaiz(prodGeral.Qtos)}"); // calcula MG como a n-ésima raiz do produto geral
WritePos(2, 10, $"MH = {somaGeral.Valor / somaInversos.Valor}"); // calcula MH como a soma geral dividida pela soma dos inversos
}
catch (Exception e) // se houver exceção, recebê-la e escrever sua mensagem
{
WritePos(2, 5, "O arquivo não pode ser lido:\n\n");
WritePos(2, 6, e.Message);
WriteLine();
}
EsperarEnterEstilo();
}
public double SinH(double x)
{
var n = new Contador(0, nInt - 1, 1);
var soma = new Somatoria();
while (n.Prosseguir())
{
var mat = new Matematica(2 * n.Valor + 1);
soma.Somar(1.0 / mat.Fatorial() * mat.Elevado(x));
}
return(soma.Valor);
}
public int SomaDeQuadrados()
{
var somaValores = new Somatoria();
var contador = new Contador(1, numeroInteiro, 1);
while (contador.Prosseguir())
{
int umQuadrado = contador.Valor * contador.Valor;
somaValores.Somar(umQuadrado);
}
return((int)somaValores.Valor);
}
public double Wallis()
{
int sinal = 1;
var soma = new Somatoria();
var cont = new Contador(1, numeroInteiro, 1);
while (cont.Prosseguir())
{
double termo = 1.0 / (2 * cont.Valor - 1);
soma.Somar(sinal * termo);
sinal = -sinal;
}
return(soma.Valor);
}
public double F(double x)
{
int sinal = 1;
var soma = new Somatoria();
var cont = new Contador(2, numeroInteiro, 1);
while (cont.Prosseguir())
{
double termo = Math.Pow(x, cont.Valor - 1) / (2 * cont.Valor - 1);
soma.Somar(sinal * termo);
sinal = -sinal;
}
return(soma.Valor);
}
public int SomaDosDigitos()
{
var somaDig = new Somatoria();
int numeroADecompor = numeroInteiro;
while (numeroADecompor > 0)
{
int quoc = numeroADecompor / 10;
int digito = numeroADecompor - quoc * 10;
somaDig.Somar(digito);
numeroADecompor = quoc;
}
return((int)somaDig.Valor);
}
public double SinH(double x)
{
double fatorial;
var soma = new Somatoria();
var cont = new Contador(0, numeroInteiro, 1);
while (cont.Prosseguir())
{
Matematica umValor = new Matematica(2 * cont.Valor + 1);
fatorial = umValor.Fatorial();
double termo = (1 / fatorial) * Math.Pow(x, 2 * cont.Valor + 1);
soma.Somar(termo);
}
return(soma.Valor);
}
public int SomaDosDigitos() // exercício 31
{
var soma = new Somatoria();
int oNumero = numeroInteiro;
while (oNumero > 0)
{
int quociente = oNumero / 10;
int resto = oNumero - 10 * quociente; // resto --> dígito separado
soma.Somar(resto); // soma.Valor acumula a soma de cada dígito separado
oNumero = quociente; // o numero original ficou com um digito a menos
}
return((int)soma.Valor);
}
public int SomaDosDigitos()
{
var soma = new Somatoria();
int n = nInt;
while (n > 0)
{
int quo = n / 10;
int digito = n - 10 * quo;
soma.Somar(digito);
n = quo;
}
return((int)soma.Valor);
}
// Exercício 5.31
public int SomaDosDigitos()
{
var umaSoma = new Somatoria();
int numero = numeroInteiro;
while (numero > 0)
{
int quociente = numero / 10;
int digito = numero - 10 * quociente; // cálculo do resto da divisão por 10
umaSoma.Somar(digito);
numero = quociente;
}
return((int)umaSoma.Valor);
}
public double Pi()
{
int sinal = 1;
var soma = new Somatoria();
var i = new Contador(1, numeroInteiro * 2, 2);
while (i.Prosseguir())
{
double termo = 1.0 / (i.Valor * i.Valor * i.Valor);
soma.Somar(sinal * termo);
sinal = -sinal; // alterna o sinal para calcular o próximo termo
}
double pi = Math.Pow(32 * soma.Valor, 1.0 / 3.0);
return(pi);
}
static void LerArquivo()
{
int N = 0;
double result = 0, result2 = 0;
Clear();
ForegroundColor = ConsoleColor.DarkCyan;
WritePos(5, 1, "=============================================================================");
WritePos(5, 2, " Estatística de uma lista de valores lidos de um arquivo texto ");
WritePos(5, 3, "=============================================================================");
WritePos(8, 7, "Por favor digite o nome do arquivo desejado: ");
string arquivo = ReadLine();
var soma = new Somatoria();
var leitor = new StreamReader(arquivo);
var produto = new Produtorio();
while (!leitor.EndOfStream) // leitura de cada linha e chamada de cálculos sobre estas
{
string linha = leitor.ReadLine();
V = Convert.ToDouble(linha.Substring(inicioV, tamanhoV));
P = Convert.ToDouble(linha.Substring(inicioP, tamanhoP));
soma.Somar(V + P);
produto.Multiplicar(V + P);
soma.SomarComPeso(V, int.Parse(P + ""));
soma.SomarInversos(V + P);
}
leitor.Close();
double mediaAritmeticaCalculada = soma.MediaAritmetica();
double mediaGeometricaCalculada = produto.MediaGeometrica();
double raizMediaQuadraticaCalculada = soma.RaizMediaQuadratica();
double mediaPonderadaCalculada = soma.MediaPonderada();
double mediaHarmonicaCalculada = soma.MediaHarmonica();
WritePos(8, 12, $"O valor da média aritmética é " + mediaAritmeticaCalculada); //exibição de resultados
WritePos(8, 14, $"O valor da média geométrica é " + mediaGeometricaCalculada); //exibição de resultados
WritePos(8, 16, $"O valor da raiz média quadrática é " + raizMediaQuadraticaCalculada); //exibição de resultados
WritePos(8, 18, $"O valor da média ponderada é " + mediaPonderadaCalculada); //exibição de resultados
WritePos(8, 20, $"O valor da média harmônica é " + mediaHarmonicaCalculada); //exibição de resultados
WritePos(8, 25, "Pressione [Enter] para prosseguir");
ReadLine();
}
public int SomaDivisores() // exercício 33
{
var soma = new Somatoria();
soma.Somar(1 + numeroInteiro);
var cont = new Contador(2, numeroInteiro / 2, 1);
while (cont.Prosseguir)
{
int resto = numeroInteiro % cont.Valor; // calcula resto de divisão inteira
if (resto == 0) // houve divisão exata
{
soma.Somar(cont.Valor); // o divisor é acumulado na soma
}
cont.Contar(); // gera próximo possível divisor
}
return((int)soma.Valor);
}
public int SomaDosDivisores()
{
var somaDiv = new Somatoria(); // aqui somaremos os divisores
int metade = numeroInteiro / 2;
var possivelDivisor = new Contador(2, metade, 1);
while (possivelDivisor.Prosseguir())
{
int restoDaDivisao = numeroInteiro %
possivelDivisor.Valor;
if (restoDaDivisao == 0)
{
somaDiv.Somar(possivelDivisor.Valor);
}
}
somaDiv.Somar(1 + numeroInteiro);
return((int)somaDiv.Valor); // (int) converte o tipo para inteiro
}
//================================================================
// PROJETO
public double Catalan()
{
var meuSoma = new Somatoria();
var i = new Contador(1, numeroInteiro * 2, 2);
int sinal = 1;
while (i.Prosseguir())
{
double expressao = 1.0 / (i.Valor * i.Valor);
meuSoma.Somar(sinal * expressao);
sinal = -sinal;
}
return(meuSoma.Valor);
}
public double SomaDivisores()
{
int metadeNumero = numeroInteiro / 2;
var possivelDivisor = new Contador(2, metadeNumero, 1);
var umSomador = new Somatoria();
while (possivelDivisor.Prosseguir())
{
int quociente = numeroInteiro / possivelDivisor.Valor;
int resto = numeroInteiro - quociente * possivelDivisor.Valor;
if (resto == 0)
{
umSomador.Somar(possivelDivisor.Valor);
}
possivelDivisor.Contar();
}
return(umSomador.Valor + 1 + numeroInteiro);
}
public void SomarCentrais()
{
WriteLine("Digite o valor inicial:");
vI = int.Parse(ReadLine());
WriteLine("Digite o valor final:");
vF = int.Parse(ReadLine());
Contador cont = new Contador(vI, vF, 1);
Somatoria soma = new Somatoria();
while (cont.Prosseguir())
{
double pD = cont.Valor / 1000;
double sD = cont.Valor / 100;
double tD = cont.Valor / 10;
pDigito = Math.Floor(pD);//divide o numero por 1000 e arredonda pra baixo, assim pega o primeiro digito
sDigito = Math.Floor(sD) - pDigito * 10;
tDigito = Math.Floor(tD) - (pDigito * 100 + sDigito * 10);
soma.Somar(sDigito + tDigito);
cont.Contar();
}
WriteLine(soma.Soma);
}
public double Pi()
{
double pi;
var umContador = new Contador(1, numeroInteiro, 2);
var umSomador = new Somatoria();
int positivoNegativo = 1;
while (umContador.Prosseguir())
{
umSomador.Somar(positivoNegativo / Pow(umContador.Valor, 3));
positivoNegativo = positivoNegativo * -1;
umContador.Contar();
}
pi = Pow(32 * umSomador.Valor, (1.0 / 3.0));
return(pi);
}
public void Calcular()
{
WriteLine("Digite o número da posiçao que quer sequenciar até");
qtosValores = int.Parse(ReadLine());
Contador cont = new Contador(1, qtosValores, 1);
Somatoria soma = new Somatoria();
while (cont.Prosseguir())
{
n = int.Parse(ReadLine());
if (cont.Valor == 1)
{
vMenor = n;
}
if (n % 2 == 0)
{
pares++;
}
if (n % 2 != 0)
{
impares++;
}
if (n > vMaior)
{
vMaior = n;
}
if (n < vMenor)
{
vMaior = n;
}
soma.Somar(n);
cont.Contar();
}
double MediaA = soma.MediaAritmetica();
WriteLine("Soma é: " + (soma.Soma) + " Média é " + MediaA + " A quantidade de impares é " + impares + " A quantidade de pares " + pares + " O maior valor "
+ vMaior + " E o menor " + vMenor);
}
public double Cosseno(double anguloEmGraus)
{
double cosseno = 1;
double anguloEmRadianos = (PI * anguloEmGraus) / 180.0; // Converte o valor do angulo em graus para o angulo em Radianos
var umContador1 = new Contador(2, 2 * numeroInteiro, 2);
var umSomador = new Somatoria();
int positivoNegativo = -1;
while (umContador1.Prosseguir())
{
var umContador2 = new Contador(1, umContador1.Valor, 1);
var oFatorial = new Produtorio();
while (umContador2.Prosseguir())
{
oFatorial.Multiplicar(umContador2.Valor);
umContador2.Contar();
}
umSomador.Somar(positivoNegativo * (Pow(anguloEmRadianos, umContador1.Valor) / oFatorial.Valor));
positivoNegativo = positivoNegativo * (-1);
umContador1.Contar();
}
cosseno = cosseno + umSomador.Valor;
return(cosseno);
}
/// <summary>
/// ///////////////////
/// </summary>
private void Exercicio_5_31()
{
Clear();
int Numero, Resto;
var somatoria = new Somatoria();
var conta = new Contador(1, 5, 1);
Write(" DIGITE UM NUMERO DE 5 DIGITES PARA SOMALOS : ");
Numero = int.Parse(ReadLine());
if (Numero < 10000 || Numero > 99999)
{
WriteLine("\n SEU NUMERO NÃO TEM 5 DIGITOS !!!");
Tratador();
}
else
{
while (conta.Prosseguir())
{
Resto = Numero % 10;
Numero = Numero / 10;
somatoria.Somar(Resto);
}
WriteLine($" \n A SOMA DOS DIGITOS É { somatoria.Valor } ");
Tratador();
}
}
public int SomaDivisore()
{
double resultado;
var possivelDivisor = new Contador(1, numeroInteiro / 2, 1);
var Soma = new Somatoria();
while (possivelDivisor.Prosseguir())
{
int resto = numeroInteiro % possivelDivisor.Valor;
if (resto == 0)
{
resultado = possivelDivisor.Valor;
Soma.Somar(resultado);
}
}
resultado = Soma.Valor;
return((int)resultado);
}
public double Cosseno(double anguloEmGraus)
{
double x = anguloEmGraus * Math.PI / 180; // cpnverte medida em graus para medida em radianos
var somaDosTermos = new Somatoria();
int sinal = 1;
var contador = new Contador(0, numeroInteiro * 2, 2);
while (contador.Prosseguir())
{
double potencia = Math.Pow(x, contador.Valor);
var fat = new Matematica(contador.Valor);
double fatorial = fat.Fatorial(); // já temos essa função pronta na classe Matematica
double termo = potencia / fatorial;
somaDosTermos.Somar(sinal * termo);
sinal = -sinal;
}
return(somaDosTermos.Valor);
}
static void ExercicioD()
{
Clear();
// O Nome do Arquivo de Texto é : teste.txt
WriteLine("Digite o nome do arquivo desejado?");
StreamReader leitor = new StreamReader(ReadLine());
var soma = new Somatoria(); // para passar os as notas para classe somatoria
int qtdAprovados = 0, qtadRecuperacao = 0, qtdRetidos = 0;
string melhorAluno = "";
double maiorNota = 0;
Aluno alunoAtual = null;
Aluno alunoAnterior = null;
while (!leitor.EndOfStream) // Enquanto não for o Fim do Arquivo vai executar.
{
alunoAnterior = alunoAtual; // Vai receber o Aluno anterio para Verificar se é o Atual
alunoAtual = Aluno.LerDados(leitor.ReadLine()); // Aluno vai ser lido do arquivo
if (alunoAnterior != null) // Verifica se tem o Aluno anterior for nulo ele inicia
{
if (alunoAtual.Classe != alunoAnterior.Classe)
{
WriteLine("Total da classe " + alunoAnterior.Classe + ":");
WriteLine("Média Harmônica: " + Math.Round(soma.MediaHarmonica, 2));
soma = new Somatoria(); // Construtor da Classe Somatoria.
WriteLine("Aprovados: " + qtdAprovados + " Em recuperação: " + qtadRecuperacao + " Retidos " + qtdRetidos);
WriteLine("Aluno com melhor desempenho: " + melhorAluno + " (" + Math.Round(maiorNota, 2) + ")");
qtdAprovados = qtadRecuperacao = qtdRetidos = 0;
melhorAluno = "";
maiorNota = 0;
WriteLine("-----------------------------\n Classe: " + alunoAtual.Classe + "\nRA Nota");
}
if (alunoAtual.Ra == alunoAnterior.Ra) // Vai Somar as Notas caso o Aluno anterior for o Aluno Atual (Se os RA's forem iguais)
{
soma.Somar(alunoAtual.Nota); // Aqui estamos passando a nota para o método somar
WriteLine(alunoAtual.Nota.ToString().PadLeft(11));
}
else
{
double media = soma.MediaAritmetica;
//Math.Round(media, 2);
Write("Media: " + Math.Round(media, 2).ToString().PadRight(9)); // Math.Round é para Mostrar apenas duas Casas após a Virgula.
// Faz a Verificação da Média, se for Menor que 3 Retido, se for maior que 5 Aporovado, Senão Recuperação
if (media < 3)
{
WriteLine("Retido");
qtdRetidos++;
}
else
if (media >= 5)
{
WriteLine("Aprovado");
qtdAprovados++;
}
else
{
WriteLine("Recuperação");
qtadRecuperacao++;
}
if (media > maiorNota)
{
maiorNota = media;
melhorAluno = alunoAnterior.Ra;
}
soma.Valor = 0;
soma.Quantos = 0;
soma.SomaInversos(media); // Executa com a Media a Soma dos Inversos
WriteLine(alunoAtual.Ra.PadRight(7) + alunoAtual.Nota);
soma.Somar(alunoAtual.Nota);
}
}
else
{
soma.Somar(alunoAtual.Nota);
WriteLine("-----------------------------\n Classe: " + alunoAtual.Classe + "\nRA Nota");
WriteLine(alunoAtual.Ra.PadRight(7) + alunoAtual.Nota);
}
}
}
/// <summary>
/// ////////////////////////////////////////////////////////
/// </summary>
///
private void Exercicio_5_25()
{
Clear();
int Limite;
int numeroAtual;
Write(" Digite quantos numeros você vai escrever -> ");
Limite = int.Parse(ReadLine());
Write("\n=============================================\n");
Contador contador = new Contador(1, Limite, 1);
Contador Tipo1 = new Contador(0, int.MaxValue, 1);
Contador Tipo2 = new Contador(0, int.MaxValue, 1);
Contador Tipo3 = new Contador(0, int.MaxValue, 1);
Contador Tipo4 = new Contador(0, int.MaxValue, 1);
Contador Tipo5 = new Contador(0, int.MaxValue, 1);
Contador Tipo6 = new Contador(0, int.MaxValue, 1);
Somatoria somatoria1 = new Somatoria();
Somatoria somatoria2 = new Somatoria();
Somatoria somatoria3 = new Somatoria();
Somatoria somatoria4 = new Somatoria();
Somatoria somatoria5 = new Somatoria();
Somatoria somatoria6 = new Somatoria();
while (contador.Prosseguir())
{
Write(" Digite o seu {0}° a Comparar -> ", contador.Valor);
numeroAtual = int.Parse(ReadLine());
if (numeroAtual <= 0)
{
Tipo1.Contar();
somatoria1.Somar(numeroAtual);
}
if (numeroAtual >= 0 && numeroAtual <= 25)
{
Tipo2.Contar();
somatoria2.Somar(numeroAtual);
}
if (numeroAtual >= 26 && numeroAtual <= 50)
{
Tipo3.Contar();
somatoria3.Somar(numeroAtual);
}
if (numeroAtual >= 51 && numeroAtual <= 75)
{
Tipo4.Contar();
somatoria4.Somar(numeroAtual);
}
if (numeroAtual >= 76 && numeroAtual <= 100)
{
Tipo5.Contar();
somatoria5.Somar(numeroAtual);
}
if (numeroAtual >= 100)
{
Tipo6.Contar();
somatoria6.Somar(numeroAtual);
}
}
Write(" \n------------------------------------------------------------- \n");
if (Tipo1.Valor > 0)
{
WriteLine(" [ -infinito, 0 ] = {0} MEDIA = {1} ", Tipo1.Valor, somatoria1.MediaAritmetica());
}
if (Tipo2.Valor > 0)
{
WriteLine(" [0, 25] = {0} MEDIA = {1} ", Tipo2.Valor, somatoria2.MediaAritmetica());
}
if (Tipo3.Valor > 0)
{
WriteLine(" [26,50] = {0} MEDIA = {1} ", Tipo3.Valor, somatoria3.MediaAritmetica());
}
if (Tipo4.Valor > 0)
{
WriteLine(" [51,75] = {0} MEDIA = {1} ", Tipo4.Valor, somatoria4.MediaAritmetica());
}
if (Tipo5.Valor > 0)
{
WriteLine(" [76,100] = {0} MEDIA = {1} ", Tipo5.Valor, somatoria5.MediaAritmetica());
}
if (Tipo6.Valor > 0)
{
WriteLine(" [100,+infinito] = {0} MEDIA = {1} ", Tipo6.Valor, somatoria6.MediaAritmetica());
}
Tratador();
}
