C# ::: Dicas & Truques ::: Geometria, Trigonometria e Figuras Geométricas |
Como calcular o coeficiente angular de uma reta em C# dados dois pontos no plano cartesianoQuantidade de visualizações: 1802 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 C# 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:
using System;
using System.Collections;
namespace Estudos {
class Program {
static void Main(string[] args) {
// x e y do primeiro ponto
Console.Write("Informe a coordenada x do primeiro ponto: ");
double x1 = double.Parse(Console.ReadLine());
Console.Write("Informe a coordenada y do primeiro ponto: ");
double y1 = double.Parse(Console.ReadLine());
// x e y do segundo ponto
Console.Write("Informe a coordenada x do segundo ponto: ");
double x2 = double.Parse(Console.ReadLine());
Console.Write("Informe a coordenada y do segundo ponto: ");
double y2 = double.Parse(Console.ReadLine());
// agora vamos calcular o coeficiente angular
double m = (y2 - y1) / (x2 - x1);
// e mostramos o resultado
Console.WriteLine("O coeficiente angular é: " + m);
Console.WriteLine("\nPressione qualquer tecla para sair...");
// pausa o programa
Console.ReadKey();
}
}
}
Ao executar este código em linguagem C# nós teremos o seguinte resultado: 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__$):
using System;
using System.Collections;
namespace Estudos {
class Program {
static void Main(string[] args) {
// x e y do primeiro ponto
Console.Write("Informe a coordenada x do primeiro ponto: ");
double x1 = double.Parse(Console.ReadLine());
Console.Write("Informe a coordenada y do primeiro ponto: ");
double y1 = double.Parse(Console.ReadLine());
// x e y do segundo ponto
Console.Write("Informe a coordenada x do segundo ponto: ");
double x2 = double.Parse(Console.ReadLine());
Console.Write("Informe a coordenada y do segundo ponto: ");
double y2 = double.Parse(Console.ReadLine());
// vamos obter o comprimento do cateto oposto
double cateto_oposto = y2 - y1;
// e agora o cateto adjascente
double cateto_adjascente = x2 - x1;
// vamos obter o ângulo tetha, ou seja, a inclinação da hipetunesa
// (em radianos, não se esqueça)
double tetha = Math.Atan2(cateto_oposto, cateto_adjascente);
// e finalmente usamos a tangente desse ângulo para calcular
// o coeficiente angular
double tangente = Math.Tan(tetha);
// e mostramos o resultado
Console.WriteLine("O coeficiente angular é: " + tangente);
Console.WriteLine("\nPressione qualquer tecla para sair...");
// pausa o programa
Console.ReadKey();
}
}
}
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. |
jQuery ::: Dicas & Truques ::: Manipulação e Conteúdo Dinâmico |
Como usar a função text() do jQuery para obter o conteúdo de um elemento HTML desconsiderando as tagsQuantidade de visualizações: 10423 vezes |
Enquanto o método html() nos permite obter o conteúdo de um elemento HTML incluindo as tags, o método text() permite a mesma operação, porém, desconsiderando quaisquer tags HTML que forem encontradas. Considere o elemento DIV a seguir:<div id="div_1"> <button>Clique Aqui</button> </div> Veja agora o código JavaScript que obtém o conteúdo entre as tags <div> e </div>:
<script type="text/javascript">
<!--
function obterTexto(){
var texto = $('#div_1').text();
window.alert(texto);
}
//-->
</script>
Veja que enquato o método html() retorna a string "<button>Clique Aqui</button>", o método text() retorna apenas "Clique Aqui". Observe também que o método text() atuará em todos os elementos retornados em uma determinada condição. O retorno deste método é uma string. |
HTML5 ::: HTML5 + JavaScript ::: Canvas |
Como usar o método arc() do objeto Canvas do HTML5 para desenhar arcos, curvas e círculosQuantidade de visualizações: 4559 vezes |
O método arc() do objeto Canvas do HTML5 nos permite criar figuras tais como arcos, curvas e círculos. Para isso é importante entender os seus parâmetros:arc(x, y, radius, ang1, ang2, direction); Os parâmetros x e y indicam as coordenadas do centro do círculo. O parâmetro radius indica o raio do círculo. Os parâmetros ang1 e ang2 indicam o ângulo inicial e o ângulo final. O parâmetro direction indica a direção do desenho. Se o valor true for informado, a direção será anti-horário. Se for false, o desenho será no sentido horário. É importante observar que os ângulos são medidos em radianos, não em graus. Assim, o ângulo 0 representa a posição 3 horas no relógio. A posição de 9 horas é (1 * PI), 12 horas é (1.5 * PI) e 6 horas é (0.5 * PI). Portanto, se você quiser desenhar um círculo completo, deverá sair do ângulo 0 e ir até (2 * PI). Veja um trecho de código que desenha um arco equivalente a um quarto de uma pizza, ou seja, 25%, saindo do ângulo 90º (em graus) e indo até 180º (graus):
<html>
<head>
<meta charset="utf-8">
<title>Estudos HTML5</title>
</head>
<body>
<Canvas id="canvas1" width="500" height="350"></Canvas>
<script type="text/javascript">
// obtemos uma referência ao elemento Canvas
var canvas = document.getElementById("canvas1");
// obtemos o contexto de desenho
var contexto = canvas.getContext("2d");
// vamos desenhar um arco sem preenchimento com raio de 80
contexto.beginPath(); // início um novo caminho
// o arco começa no x = 100, y = 100, começa no ângulo 90 (em graus)
// e vai até o ânculo 180 (graus)
// as medidas na função arc() são em radianos, não em graus
contexto.arc(100, 100, 80, Math.PI, 1.5 * Math.PI, false);
contexto.lineWidth = 2; // largura da linha
contexto.strokeStyle = '#990000'; // cor da linha
contexto.stroke(); // realiza o desenho
</script>
</body>
</html>
Execute este código e veja que o arco realmente foi desenhado. Seu resultado deverá ser parecido com: ![]() No entanto, para parecer um pedação de pizza, ou seja, o ponto de partida para um gráfico de pizza, é preciso que tenhamos duas linhas ligado esse arco ao centro do círculo. Veja a modificação que fiz:
<html>
<head>
<meta charset="utf-8">
<title>Estudos HTML5</title>
</head>
<body>
<Canvas id="canvas1" width="500" height="350"></Canvas>
<script type="text/javascript">
// obtemos uma referência ao elemento Canvas
var canvas = document.getElementById("canvas1");
// obtemos o contexto de desenho
var contexto = canvas.getContext("2d");
// vamos desenhar um arco sem preenchimento com raio de 80
contexto.beginPath(); // início um novo caminho
// primeiro movemos a caneta de desenho para o centro do círculo
contexto.moveTo(100, 100);
// o arco começa no x = 100, y = 100, começa no ângulo 90 (em graus)
// e vai até o ânculo 180 (graus)
// as medidas na função arc() são em radianos, não em graus
contexto.arc(100, 100, 80, Math.PI, 1.5 * Math.PI, false);
contexto.lineWidth = 2; // largura da linha
contexto.strokeStyle = '#990000'; // cor da linha
// agora desenhamos uma linha de volta para o arco
contexto.lineTo(100, 100);
contexto.stroke(); // realiza o desenho
</script>
</body>
</html>
Execute novamente e veja que agora o efeito ficou bem melhor. Seu resultado deverá ser parecido com: ![]() Para finalizar, vamos colorir o pedação de pizza. Veja a nova versão (com o código completo):
<!doctype html>
<html>
<head>
<title>O objeto Canvas do HTML5</title>
</head>
<body>
<Canvas id="canvas1" width="500" height="350"></Canvas>
<script type="text/javascript">
// obtemos uma referência ao elemento Canvas
var canvas = document.getElementById("canvas1");
// obtemos o contexto de desenho
var contexto = canvas.getContext("2d");
// vamos desenhar um arco sem preenchimento com raio de 80
contexto.beginPath(); // início um novo caminho
// primeiro movemos a caneta de desenho para o centro do círculo
contexto.moveTo(100, 100);
// o arco começa no x = 100, y = 100, começa no ângulo 90 (em graus)
// e vai até o ânculo 180 (graus)
// as medidas na função arc() são em radianos, não em graus
contexto.arc(100, 100, 80, Math.PI, 1.5 * Math.PI, false);
contexto.lineWidth = 2; // largura da linha
contexto.strokeStyle = '#990000'; // cor da linha
// agora desenhamos uma linha de volta para o arco
contexto.lineTo(100, 100);
// vamos preencher o gráfico
contexto.fillStyle = "#CCCCCC"; // cor do preenchimento
contexto.fill(); // preenche de fato
contexto.stroke(); // realiza o desenho
</script>
</body>
</html>
Agora o resultado será: ![]() |
Python ::: Desafios e Lista de Exercícios Resolvidos ::: Python Básico |
Exercícios Resolvidos de Python - Escreva um programa em Python que usa a função log10() para informar a quantidade de dígitos em um número inteiroQuantidade de visualizações: 805 vezes |
|
Pergunta/Tarefa: Escreva um algorítmo em Python que peça para o usuário informar um número inteiro de qualquer tamanho, ou seja, qualquer quantidade de dígitos. Em seguida seu código deverá informar a quantidade de dígitos contida no número inteiro digitado pelo usuário. Seu programa deverá, obrigatoriamente, usar a função log10() do módulo Math. Sua saída deverá ser parecida com: Informe um número inteiro de qualquer tamanho: 847 O número informado possui 3 dígitos Veja a resolução comentada deste exercício usando Python:
# vamos importar o módulo Math
import math
# método principal
def main():
# vamos pedir para o usuário informar um número inteiro
numero = int(input("Informe um número inteiro de qualquer tamanho: "))
# agora vamos obter a quantidade de dígitos no
# número informado
tamanho = int(math.log10(numero)) + 1
# mostramos o resultado
print("O número informado possui {0} dígitos".format(tamanho))
if __name__== "__main__":
main()
|
Nossas 20 dicas & truques de programação mais populares |
|
Delphi - Como calcular MDC em Delphi |
Você também poderá gostar das dicas e truques de programação abaixo |
|
Java - Como quebrar (separar) uma string em palavras usando um objeto da classe StringTokenizer do Java |
Nossas 20 dicas & truques de programação mais recentes |
Últimos Projetos e Códigos Fonte Liberados Para Apoiadores do Site |
|
Python - Como criar o jogo Pedra, Papel, Tesoura em Python - Jogo completo em Python com código comentado |
Últimos Exercícios Resolvidos |
E-Books em PDF |
||||
|
||||
|
||||
Linguagens Mais Populares |
||||
|
1º lugar: Java |









