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 ConstanteDePrimosGemeos()
{
double produto = 1, fator = 1;
bool gemeo = true;
var contador = new Contador(3, numeroInteiro, 2);
while (contador.Prosseguir)
{
if (somadosdivisores(contador.Valor) == 1)
{
if (gemeo)
{
fator = (contador.Valor * (contador.Valor - 2.0f)) / ((contador.Valor - 1.0f) * (contador.Valor - 1.0f));
produto *= fator;
}
gemeo = true;
}
else
{
gemeo = false;
}
contador.Contar();
}
return(produto);
}
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);
}
public void TransformarParaBinario()
{
WriteLine("Digite um número entre 0 e 64 que quer transformar em binario");
numero = double.Parse(ReadLine());
double nD = numero;
WriteLine(nD + " em Binário é ");
Contador cont = new Contador(0, 6, 1);
while (cont.Prosseguir())
{
double x = Math.Pow(2, 6 - cont.Valor);
if (numero >= x)
{
double elevarA = 6 - cont.Valor;
Write("1");
numero -= Math.Pow(2, 6 - cont.Valor);
}
else
{
Write("0");
}
cont.Contar();
}
}
public int MMC(int outroValor)
{
int oMMC = 0;
int dividendo1 = numeroInteiro;
int dividendo2 = outroValor;
int quociente1 = 0;
int quociente2 = 0;
var umContador = new Contador(2, numeroInteiro * outroValor, 1);
var umMultiplicador = new Produtorio();
while (dividendo1 != 1 || dividendo2 != 1 && umContador.Prosseguir())
{
numeroInteiro = umContador.Valor;
if (Divisores() == $"1, {umContador.Valor}") // O contador é primo?
{
while (dividendo1 % umContador.Valor == 0 || dividendo2 % umContador.Valor == 0)
{
quociente1 = dividendo1 / umContador.Valor;
quociente2 = dividendo2 / umContador.Valor;
umMultiplicador.Multiplicar(umContador.Valor);
if (dividendo1 % umContador.Valor == 0)
{
dividendo1 = quociente1;
}
if (dividendo2 % umContador.Valor == 0)
{
dividendo2 = quociente2;
}
quociente1 = 0;
quociente2 = 0;
}
}
else
{
quociente1 = 0;
quociente2 = 0;
}
umContador.Contar();
}
oMMC = Convert.ToInt32(umMultiplicador.Valor);
return(oMMC);
}
public int Fatorial()
{
var oFatorial = new Produtorio();
var umContador = new Contador(1, numeroInteiro, 1);
while (umContador.Prosseguir())
{
oFatorial.Multiplicar(umContador.Valor);
umContador.Contar(); // gera o próximo número
}
return(Convert.ToInt32(oFatorial.Valor));
}
public double Fatorial()
{
var produtos = new Produtorio();
var contador = new Contador(1, numeroInteiro, 1);
while (contador.Prosseguir)
{
produtos.Multiplicar(contador.Valor);
contador.Contar();
}
return(produtos.Valor);
}
static void Main()
{
Console.WriteLine("DEMO Entropía");
var texto = File.ReadAllText(@"..\..\..\..\el_quijote.txt");
texto = Regex.Replace(texto.ToLower(), @"[^a-z]", "");
var c = new Contador();
c.Contar(texto);
Console.WriteLine($" · Hay {c.Cantidad} simbolos con una entropía de {c.Entropia, 0:N1} bits");
Console.ReadLine();
}
public double Elevado(double a) // exercício 32
{
int x = numeroInteiro;
var prod = new Produtorio();
var cont = new Contador(1, x, 1);
while (cont.Prosseguir)
{
prod.Multiplicar(a);
cont.Contar();
}
return(prod.Valor);
}
public double Elevado(double a)
{
var umContador = new Contador(1, numeroInteiro, 1); // instancia um objeto da classe contador que terá como valor incial 1, valor final um número x digitado pelo usuário e o passo1
var umMultiplicador = new Produtorio(); // instancia um objeto da classe Produtório
while (umContador.Prosseguir()) // esse comando fará com que após a realização dos comandos entre chaves, o fluxo de execução retorne a ele
// o método entre parenteses fará com que se o contador for menor ou igual a número digitado pelo usuário o fluxo de execução entre nos comandos entre parêntese.
{
umMultiplicador.Multiplicar(a); // esse método fa´ra com que o valor presente na variável "a" seja multiplicado pelo valor presente na variável "oProduto".
umContador.Contar();
}
return(umMultiplicador.Valor); // retorna o valor que está na variável "oProduto"
}
public void Sequencia()
{
WriteLine("Digite o número da posiçao que quer sequenciar até");
posicao = int.Parse(ReadLine());
Contador cont = new Contador(1, posicao - 2, 1);
WriteLine('1');
WriteLine('1');
while (cont.Prosseguir())
{
nAtual = nAntesAnterior + nAnterior;
WriteLine(nAtual);
nAntesAnterior = nAnterior;
nAnterior = nAtual;
cont.Contar();
}
}
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 string Divisores()
{
string lista = ""; // inicia variável string com cadeia vazia
int metadeNumero = numeroInteiro / 2;
var possivelDivisor = new Contador(2, metadeNumero, 1);
while (possivelDivisor.Prosseguir())
{
int quociente = numeroInteiro / possivelDivisor.Valor;
int resto = numeroInteiro - quociente * possivelDivisor.Valor;
if (resto == 0)
{
lista = lista + Convert.ToString(possivelDivisor.Valor) + ", ";
}
possivelDivisor.Contar(); // gera próximo potencial divisor
}
return("1, " + lista + numeroInteiro); // concatena inteiros sem conversão
}
public string Divisores()
{
string lista = "";
int metadeNumero = numeroInteiro / 2;
var possivelDivisor = new Contador(2, metadeNumero, 1);
while (possivelDivisor.Prosseguir())
{
int quociente = numeroInteiro / possivelDivisor.Valor;
int resto = numeroInteiro - quociente * possivelDivisor.Valor;
if (resto == 0)
{
lista = lista + Convert.ToString(possivelDivisor.Valor);
}
possivelDivisor.Contar();
}
return("1, " + lista + numeroInteiro);
}
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 int MMC(int y)
{
int numeroInteiro = nInt;
var cont = new Contador(2, int.MaxValue, 1); // contador que será os divisores
var mmc = new Produtorio(); // instancia um produtório que aclculará o MMC
bool jaMultiplicado; // verifica se o valor dividido já foi multiplicado no MMC
while (true)
{
var mat = new Matematica(cont.Valor);
if (mat.EhPrimo()) //verifica se o valor é primo
{
jaMultiplicado = false; // no inicio já foi multiplicado recebe false
if (numeroInteiro % cont.Valor == 0) // verifica se o primeiro valor é divisível por cont.Valor
{
numeroInteiro /= cont.Valor; // divide o premeiro numero
mmc.Multiplicar(cont.Valor);
jaMultiplicado = true; // cont.Valor já foi multiplicado no MMC
}
if (y % cont.Valor == 0) // verifica se o segundo é divisível por cont.Valor
{
if (!jaMultiplicado) // se já foi multiplicado antes, não devemos fazer novamente
{
mmc.Multiplicar(cont.Valor);
}
y /= cont.Valor; // divide o premeiro numero
}
}
if (numeroInteiro % cont.Valor != 0 && y % cont.Valor != 0) // verifica se os valor ainda são divisiveis pelo cont.Valor
{
cont.Contar(); // soma um ao contador
}
if (numeroInteiro == 1 && y == 1) // se os dois valores chegaram a 1, o MMC foi encontrado
{
return((int)mmc.Valor); // retorna o MMC
}
}
}
public double Catalan()
{
bool sinal = false;
var contador = new Contador(3, numeroInteiro * 2 + 3, 2);
double resultado = 1;
while (contador.Prosseguir)
{
if (sinal)
{
resultado += 1.0F / (contador.Valor * contador.Valor);
}
else
{
resultado -= 1.0F / (contador.Valor * contador.Valor);
}
contador.Contar();
sinal = !sinal;
}
return(resultado);
}
private void Exercicio_5_20()
{
Clear();
DateTime horadehoje;
horadehoje = DateTime.Now;
var segundos = new Contador(0, 59, 1);
var minutos = new Contador(0, 59, 1);
var horas = new Contador(0, 23, 1);
segundos.setvalor(horadehoje.Second);
minutos.setvalor(horadehoje.Minute);
horas.setvalor(horadehoje.Hour);
while (KeyAvailable == false)
{
segundos.Contar();
if (segundos.Valor == 59)
{
segundos.Iniciar();
minutos.Contar();
if (minutos.Valor == 59)
{
minutos.Iniciar();
horas.Contar();
}
}
Console.SetCursorPosition(30, 13);
Write(horas.Valor + ":" + minutos.Valor + ":" + segundos.Valor);
Thread.Sleep(1000);
}
Tratador();
}
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 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 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 bool EhPrimo(bool maisRapido) // método sobrecarregado
{
if (numeroInteiro == 2)
{
return(true);
}
if (numeroInteiro % 2 == 0) // número é par?
{
return(false); // não é primo
}
int resto = 1;
var possivelDivisor = new Contador(3, numeroInteiro / 2, 2);
while (resto != 0 && possivelDivisor.Prosseguir)
{
resto = numeroInteiro % possivelDivisor.Valor;
possivelDivisor.Contar();
}
return(resto != 0);
}
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);
}
public int MMC(int outroValor)
{
int A = numeroInteiro;
int B = outroValor;
var mmc = new Produtorio();
var divisor = new Contador(2, int.MaxValue, 1);
while (A != 1 || B != 1) // condição para a continuação das sucessivas divisões
{
int quocA = A / divisor.Valor;
int restoA = A - quocA * divisor.Valor;
int quocB = B / divisor.Valor;
int restoB = B - quocB * divisor.Valor;
if (restoA == 0 || restoB == 0)
{
mmc.Multiplicar(divisor.Valor);
}
if (restoA == 0)
{
A = quocA;
}
if (restoB == 0)
{
B = quocB;
}
if (restoA != 0 && restoB != 0)
{
divisor.Contar();
}
}
return((int)mmc.Valor); // retornao valor do MMC
}
/// <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();
}