Você está aqui: Portugol ::: Dicas & Truques ::: Matemática e Estatística

Como resolver uma equação do segundo grau em Portugol - Como calcular Bhaskara em Portugol

Quantidade de visualizações: 1834 vezes
Como resolver uma equação do 2º grau usando Portugol

Nesta dica mostrarei como encontrar as raízes de uma equação quadrática, ou seja, uma equação do 2º usando um algoritmo escrito na ferramenta Portugol Studio, uma das preferidas para o aprendizado de algoritmos e lógica de programação.

Definimos como equação do 2º grau ou equações quadráticas qualquer equação do tipo ax² + bx + c = 0 em que a, b e c são números reais e a ≠ 0. Ela recebe esse nome porque, no primeiro membro da igualdade, há um polinômio de grau dois com uma única incógnita.

Note que, dos coeficientes a, b e c, somente o a é diferente de zero, pois, caso ele fosse igual a zero, o termo ax² seria igual a zero, logo a equação se tornaria uma equação do primeiro grau: bx + c = 0.

Independentemente da ordem da equação, o coeficiente a sempre acompanha o termo x², o coeficiente b sempre acompanha o termo x, e o coeficiente c é sempre o termo independente.

Como resolver uma equação do 2º grau

Conhecemos como soluções ou raízes da equação ax² + bx + c = 0 os valores de x que fazem com que essa equação seja verdadeira. Uma equação do 2º grau pode ter no máximo dois números reais que sejam raízes dela. Para resolver equações do 2º grau completas, existem dois métodos mais comuns:

a) Fórmula de Bhaskara;
b) Soma e produto.

O primeiro método é bastante mecânico, o que faz com que muitos o prefiram. Já para utilizar o segundo, é necessário o conhecimento de múltiplos e divisores. Além disso, quando as soluções da equação são números quebrados, soma e produto não é uma alternativa boa.

Como resolver uma equação do 2º grau usando Bhaskara

Como nosso algoritmo Portugol vai resolver a equação quadrática usando a Fórmula de Bhaskara, o primeiro passo é encontrar o determinante. Veja:

\[\Delta =b^2-4ac\]

Nem sempre a equação possui solução real. O valor do determinante é que nos indica isso, existindo três possibilidades:

a) Se determinante > 0, então a equação possui duas soluções reais.
b) Se determinante = 0, então a equação possui uma única solução real.
c) Se determinante < 0, então a equação não possui solução real.

Encontrado o determinante, só precisamos substituir os valores, incluindo o determinante, na Fórmula de Bhaskara:

\[x = \dfrac{- b\pm\sqrt{b^2- 4ac}}{2a}\]

Vamos agora ao código Portugol (escrevi e testei no Portugol Webstudio). Nossa aplicação vai pedir para o usuário informar os valores dos três coeficientes a, b e c e, em seguida, vai apresentar as raizes da equação:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

// "Como resolver uma equação do 2º grau usando Portugol
programa {
  // inclui a biblioteca Matematica
  inclua biblioteca Matematica --> mat

  // função principal do programa
  funcao inicio() {
    // variáveis usadas na resolução do problema
    // os coeficientes
    real a, b, c
    // as duas raizes, a imaginaria e o discriminante
    real raiz1, raiz2, imaginaria, discriminante

    // vamos pedir para o usuário informar os valores dos coeficientes
    escreva("Valor do coeficiente a: ")
    leia(a)
    escreva("Valor do coeficiente b: ")
    leia(b)
    escreva("Valor do coeficiente c: ")
    leia(c)

    // vamos calcular o discriminante
    discriminante = (b * b) - (4 * a * c)

    // a equação possui duas soluções reais?
    se (discriminante > 0) {
      raiz1 = ((b * -1) + mat.raiz(discriminante, 2.0)) / (2 * a)
      raiz2 = ((b * -1) - mat.raiz(discriminante, 2.0)) / (2 * a)
      escreva("Duas raizes: x1 = ", raiz1, " e x2 = ", raiz2)
    }
    // a equação possui uma única solução real?
    senao se (discriminante == 0){
      raiz1 = (b * -1) / (2 * a)
      raiz2 = (b * -1) / (2 * a)
      escreva("Duas raizes iguais: x1 = ", raiz1, " e x2 = ", raiz2)
    }
    // a equação não possui solução real?
    senao{
      raiz1 = (b * -1) / (2 * a)
      raiz2 = (b * -1) / (2 * a)
      imaginaria = mat.raiz((discriminante * -1), 2.0) / (2 * a)
      escreva("Existem duas raízes complexas: ")
      escreva("x1 = ", raiz1, " + " ,imaginaria, " e x2 = ", raiz2, " - ", imaginaria)
    }
  }
}

Ao executar este código Portugol nós teremos o seguinte resultado:

Valor do coeficiente a: 1
Valor do coeficiente b: 2
Valor do coeficiente c: -3
Existem duas raizes: x1 = 1.0 e x2 = -3.0

Link para compartilhar na Internet ou com seus amigos:

Java ::: Dicas & Truques ::: Formatação de datas, strings e números

Como usar o método System.out.printf() do Java para converter um valor na base decimal para hexadecimal

Quantidade de visualizações: 10340 vezes
Nesta dica mostrarei como podemos tirar proveito do método System.out.printf() do Java 5.0 em diante para converter um valor na base decimal para hexadecimal e exibí-lo na tela.

Veja o código completo para o exemplo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package arquivodecodigos;

public class Estudos{
  public static void main(String[] args){
    int num = 35;
   
    // exibe o valor na base hexadecimal
    System.out.printf("O decimal %d convertido para hexadecimal é %x", 
      num, num);
  }
}

Ao executar este código nós teremos o seguinte resultado:

O decimal 35 convertido para hexadecimal é 23


C ::: Fundamentos da Linguagem ::: Estruturas de Controle

Apostila C para iniciantes - Como usar o laço for em C

Quantidade de visualizações: 38462 vezes
O laço for é usado quando queremos executar um bloco de instruções um determinado número de vezes. Este laço é composto de três partes:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

for(inicialização; teste; incremento/decremento){
  bloco de instruções
}

Na parte inicialização nós definimos o valor inicial da variável de controle. Na parte teste nós usamos o valor da variável de controle para testar a continuidade ou interrupção do laço. Finalmente, na parte incremento/decremento nós alteramos o valor da variável de controle para cima ou para baixo. Veja um exemplo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
 
int main(int argc, char *argv[])
{
  int i;

  for(i = 1; i <= 10; i++){
    printf("%d  ", i);
  }

  printf("\n\n");
  system("PAUSE");
  return 0;
}

O incremento/decremento da variável de controle não precisa ser necessariamente em 1. Podemos usar qualquer expressão. Veja um trecho de código que exibe os números pares de 0 à 10:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

int main(int argc, char *argv[])
{
  int i;

  for(i = 0; i <= 10; i += 2){
    printf("%d  ", i);
  }

  printf("\n\n");
  system("PAUSE");
  return 0;
}

Observe que "i += 2" é o mesmo que "i = i + 2".

Com exceção da parte de testes, podemos inserir múltiplas expressões nas demais partes de um laço for. Veja:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
  int i, x;

  for(i = 0, x = 2; i <= 10; printf("%d  ", i * x), i++);

  printf("\n\n");
  system("PAUSE");
  return 0;
}

Este último código é um pouco exótico, mas muito fácil de ser encontrado por aí.


Python ::: Dicas & Truques ::: Data e Hora

Datas e horas em Python - Como obter o nome do dia da semana no formato longo (segunda-feira, terça-feira, etc) usando a função strftime() do Python

Quantidade de visualizações: 8550 vezes
Nesta dica eu mostro como podemos usar a função strftime() da linguagem Python para obter e exibir o nome do dia da semana no formato longo e em português, ou seja, segunda-feira, terça-feira, quarta-feira, etc.

Veja o código completo para o exemplo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

from datetime import datetime
import locale

# função principal do programa
def main():
  # Configurações do usuário
  locale.setlocale(locale.LC_ALL, '')
 
  # Obtém um datatime da data e hora atual
  hoje = datetime.today()
 
  # Exibe o nome do dia da semana no formato
  # longo
  print("O dia da semana é:", hoje.strftime("%A"))
 
if __name__== "__main__":
  main()

Ao executarmos este código nós teremos o seguinte resultado:

O dia da semana é: quinta-feira


Java ::: Dicas & Truques ::: Geometria, Trigonometria e Figuras Geométricas

Como calcular o coeficiente angular de uma reta em Java dados dois pontos no plano cartesiano

Quantidade de visualizações: 1357 vezes
O Coeficiente Angular de uma reta é a variação, na vertical, ou seja, no eixo y, pela variação horizontal, no eixo x. Sim, isso mesmo. O coeficiente angular de uma reta tem tudo a ver com a derivada, que nada mais é que a taxa de variação de y em relação a x.

Vamos começar analisando o seguinte gráfico, no qual temos dois pontos distintos no plano cartesiano:



Veja que o segmento de reta AB passa pelos pontos A (x=3, y=6) e B (x=9, y=10). Dessa forma, a fórmula para obtenção do coeficiente angular m dessa reta é:

\[\ \text{m} = \frac{y_2 - y_1}{x_2 - x_1} = \frac{\Delta y}{\Delta x} = tg \theta \]

Note que __$\Delta y__$ e __$\Delta x__$ são as variações dos valores no eixo das abscissas e no eixo das ordenadas. No triângulo retângulo que desenhei acima, a variação __$\Delta y__$ se refere ao comprimento do cateto oposto e a variação __$\Delta y__$ se refere ao comprimento do cateto adjascente.

Veja agora o trecho de código na linguagem Java que solicita as coordenadas x e y dos dois pontos, efetua o cálculo e mostra o coeficiente angular m da reta que passa pelos dois pontos:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package arquivodecodigos;
 
import java.util.Scanner;

public class Estudos{
  public static void main(String args[]){
    // para ler a entrada do usuário
    Scanner entrada = new Scanner(System.in);
    // coordenadas dos dois pontos
    double x1, y1, x2, y2;
    // guarda o coeficiente angular
    double m; 
       
    // x e y do primeiro ponto
    System.out.print("Coordenada x do primeiro ponto: ");
    x1 = Double.parseDouble(entrada.nextLine());
    System.out.print("Coordenada y do primeiro ponto: ");
    y1 = Double.parseDouble(entrada.nextLine());
    
    // x e y do segundo ponto
    System.out.print("Coordenada x do segundo ponto: ");
    x2 = Double.parseDouble(entrada.nextLine());
    System.out.print("Coordenada y do segundo ponto: ");
    y2 = Double.parseDouble(entrada.nextLine());   
     
    // vamos calcular o coeficiente angular
    m = (y2 - y1) / (x2 - x1);
     
    // mostramos o resultado
    System.out.println("O coeficiente angular é: " + m);
    
    System.out.println("\n\n");
    System.exit(0);
  }
} 

Ao executar este código Java nós teremos o seguinte resultado:

Coordenada x do primeiro ponto: 3
Coordenada y do primeiro ponto: 6
Coordenada x do segundo ponto: 9
Coordenada y do segundo ponto: 10
O coeficiente angular é: 0.6666666666666666

Veja agora como podemos calcular o coeficiente angular da reta que passa pelos dois pontos usando o Teorema de Pitágoras. Note que agora nós estamos tirando proveito da tangente do ângulo Theta (__$\theta__$), também chamado de ângulo Alfa ou Alpha (__$\alpha__$):

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package arquivodecodigos;
 
import java.util.Scanner;

public class Estudos{
  public static void main(String args[]){
    // para ler a entrada do usuário
    Scanner entrada = new Scanner(System.in);
    // coordenadas dos dois pontos
    double x1, y1, x2, y2;
    // guarda os comprimentos dos catetos oposto e adjascente
    double cateto_oposto, cateto_adjascente;
    // guarda o ângulo tetha (em radianos) e a tangente
    double tetha, tangente; 
       
    // x e y do primeiro ponto
    System.out.print("Coordenada x do primeiro ponto: ");
    x1 = Double.parseDouble(entrada.nextLine());
    System.out.print("Coordenada y do primeiro ponto: ");
    y1 = Double.parseDouble(entrada.nextLine());
    
    // x e y do segundo ponto
    System.out.print("Coordenada x do segundo ponto: ");
    x2 = Double.parseDouble(entrada.nextLine());
    System.out.print("Coordenada y do segundo ponto: ");
    y2 = Double.parseDouble(entrada.nextLine());   
     
    // vamos obter o comprimento do cateto oposto
    cateto_oposto = y2 - y1;
    // e agora o cateto adjascente
    cateto_adjascente = x2 - x1;
    // vamos obter o ângulo tetha, ou seja, a inclinação da hipetunesa
    // (em radianos, não se esqueça)
    tetha = Math.atan2(cateto_oposto, cateto_adjascente);
    // e finalmente usamos a tangente desse ângulo para calcular
    // o coeficiente angular
    tangente = Math.tan(tetha);
     
    // mostramos o resultado
    System.out.println("O coeficiente angular é: " + tangente);
    
    System.out.println("\n\n");
    System.exit(0);
  }
} 

Ao executar este código você verá que o resultado é o mesmo. No entanto, fique atento às propriedades do coeficiente angular da reta:

1) O coeficiente angular é positivo quando a reta for crescente, ou seja, m > 0;

2) O coeficiente angular é negativo quando a reta for decrescente, ou seja, m < 0;

3) Se a reta estiver na horizontal, ou seja, paralela ao eixo x, seu coeficiente angular é zero (0).

4) Se a reta estiver na vertical, ou seja, paralela ao eixo y, o coeficiente angular não existe.


Java ::: Desafios e Lista de Exercícios Resolvidos ::: Arrays e Matrix (Vetores e Matrizes)

Exercícios Resolvidos de Java - Como usar o laço for para percorrer os elementos de um array e exibí-los na ordem original e invertidos

Quantidade de visualizações: 14623 vezes
Pergunta/Tarefa:

Considere o seguinte array de inteiros:

// um array de inteiros contendo sete elementos
int valores[] = {6, 9, 12, 34, 83, 20, 17};
Escreva um programa Java console que usa um laço for para percorrer todos os elementos deste vetor duas vezes e exibí-los na ordem original e invertidos (somente na exibição, ou seja, não é necessário alterar a ordem dos elementos no array).

Seu programa deverá exibir a seguinte saída:

Ordem original:
6  9  12  34  83  20  17  

Ordem inversa:
17  20  83  34  12  9  6 
Resposta/Solução:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

public static void main(String[] args){
  // um vetor de inteiros contendo sete elementos
  int valores[] = {6, 9, 12, 34, 83, 20, 17};
    
  // primeiro vamos exibir os valores do vetor na ordem original
  System.out.println("Ordem original:\n");

  for(int i = 0; i < valores.length; i++){
    System.out.print(valores[i] + "  ");
  }

  // agora vamos exibir na ordem inversa
  System.out.println("\n\nOrdem inversa:\n");

  for(int i = valores.length - 1; i >= 0; i--){
    System.out.print(valores[i] + "  ");
  }
}



Mais Desafios de Programação e Exercícios e Algoritmos Resolvidos de Java

Veja mais Dicas e truques de Java

Dicas e truques de outras linguagens

Códigos Fonte

Programa de Gestão Financeira Controle de Contas a Pagar e a Receber com Cadastro de Clientes e FornecedoresSoftware de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimento
Diga adeus às planilhas do Excel e tenha 100% de controle sobre suas contas a pagar e a receber, gestão de receitas e despesas, cadastro de clientes e fornecedores com fotos e histórico de atendimentos. Código fonte completo e funcional, com instruções para instalação e configuração do banco de dados MySQL. Fácil de modificar e adicionar novas funcionalidades. Clique aqui e saiba mais
Controle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidadesControle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidades
Tenha o seu próprio sistema de controle de estoque web. com cadastro de produtos, categorias, fornecedores, entradas e saídas de produtos, com relatórios por data, margem de lucro e muito mais. Código simples e fácil de modificar. Acompanha instruções para instalação e criação do banco de dados MySQL. Clique aqui e saiba mais

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: Delphi
6º lugar: C
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby



© 2024 Arquivo de Códigos - Todos os direitos reservados
Neste momento há 66 usuários muito felizes estudando em nosso site.