Java, C/C++, Python, C#, LISP, AutoLisp, AutoCAD e VBA
PHP, Python, C#, JavaScript, Laravel, Google Ads e SEO

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

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

Quantidade 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 tags

Quantidade 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írculos

Quantidade 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 inteiro

Quantidade 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
Resposta/Solução:

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

Você também poderá gostar das dicas e truques de programação abaixo

Nossas 20 dicas & truques de programação mais recentes

Últimos Projetos e Códigos Fonte Liberados Para Apoiadores do Site

Últimos Exercícios Resolvidos

E-Books em PDF

E-Book 650 Dicas, Truques e Exercícios Resolvidos de Python - PDF com 1.200 páginas
Domine lógica de programação e a linguagem Python com o nosso E-Book 650 Dicas, Truques e Exercícios Exercícios de Python, para você estudar onde e quando quiser.

Este e-book contém dicas, truques e exercícios resolvidos abrangendo os tópicos: Python básico, matemática e estatística, banco de dados, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book
E-Book 350 Exercícios Resolvidos de Java - PDF com 500 páginas
Domine lógica de programação e a linguagem Java com o nosso E-Book 350 Exercícios Exercícios de Java, para você estudar onde e quando quiser.

Este e-book contém exercícios resolvidos abrangendo os tópicos: Java básico, matemática e estatística, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book

Linguagens Mais Populares

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


E-Book 650 Dicas, Truques e Exercícios Resolvidos de Python - PDF com 1.200 páginas
Domine lógica de programação e a linguagem Python com o nosso E-Book 650 Dicas, Truques e Exercícios Exercícios de Python, para você estudar onde e quando quiser. Este e-book contém dicas, truques e exercícios resolvidos abrangendo os tópicos: Python básico, matemática e estatística, banco de dados, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book Apenas R$ 32,90

Planilha Web - Planilhas e Calculadoras online para estudantes e profissionais de Engenharia Civil, Engenharia Elétrica e Engenharia Mecânica.


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