 |
|
Você está aqui: C ::: Dicas & Truques ::: Geometria, Trigonometria e Figuras Geométricas |
Como calcular o ponto médio entre dois pontos no plano usando C - Geometria com CQuantidade de visualizações: 428 vezes |
|
Nesta dica mostrarei como é possível usar um trecho de código C para obter o ponto médio entre dois pontos quaisquer no plano, ou seja, no R2. Em mais dicas dessa seção você aprenderá como isso pode ser feito no R3 (espaço) Comece analisando a figura abaixo, na qual temos dois pontos A e B, com suas coordenadas correspondentes, e o ponto médio M:  Assim, dados dois pontos A = (2, 9) e B = (10, 2) no plano cartesiano R2, as coordenadas x e y do ponto médio são calculadas por meio da seguinte fórmula: \[x = \frac{x_1 + x_2}{2}\] \[y = \frac{y_1 + y_2}{2}\] Colocando na fórmula os valores que já temos: \[x = \frac{2 + 10}{2} = \frac{12}{2} = 6 \] \[y = \frac{9 + 2}{2} = \frac{11}{2} = 5.5 \] Assim, as coordenadas do ponto médio será (x = 6, y = 5.5). E agora veja o código C completo para calcular as coordenadas do ponto médio a partir de dois pontos no plano cartesiano (plano 2D ou R2): ----------------------------------------------------------------------
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>
#include <locale.h>
int main(int argc, char *argv[]){
float x1, y1, x2, y2, x, y;
setlocale(LC_ALL,""); // para acentos do português
// x e y do primeiro ponto
printf("Coordenada x do primeiro ponto: ");
scanf("%f", &x1);
printf("Coordenada y do primeiro ponto: ");
scanf("%f", &y1);
// x e y do segundo ponto
printf("Coordenada x do segundo ponto: ");
scanf("%f", &x2);
printf("Coordenada y do segundo ponto: ");
scanf("%f", &y2);
// vamos calcular as coordenadas x e y do ponto médio
x = (x1 + x2) / 2;
y = (y1 + y2) / 2;
// vamos mostrar o resultado
printf("As coordenadas do ponto médio são: (x = %f, y = %f)", x, y);
printf("\n\n");
system("PAUSE");
return 0;
}
Ao executarmos este código C nós teremos o seguinte resultado: Coordenada x do primeiro ponto: 2 Coordenada y do primeiro ponto: 9 Coordenada x do segundo ponto: 10 Coordenada y do segundo ponto: 2 As coordenadas do ponto médio são: (x = 6.0, y = 5.5) |
 Link para compartilhar na Internet ou com seus amigos: |
Java ::: Pacote java.awt.image ::: BufferedImage |
Como desenhar um BufferedImage em um JComponent do JavaQuantidade de visualizações: 10733 vezes |
Neste exemplo nós usamos o método drawImage() da classe Graphics para desenhar o conteúdo de um BufferedImage (que contém uma imagem JPG) em uma JFrame do Java Swing:----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
import java.awt.*;
import java.io.*;
import java.awt.image.*;
import java.awt.event.*;
import javax.swing.*;
import javax.imageio.*;
public class Estudos extends JFrame{
private BufferedImage imagem;
public Estudos(){
super("Estudos Java");
Container c = getContentPane();
c.setLayout(new FlowLayout());
JButton btn = new JButton("Carregar Imagem");
btn.addActionListener(
new ActionListener(){
public void actionPerformed(ActionEvent e){
imagem = null;
try{
imagem = ImageIO.read(
new File("imagens/fundo.jpg"));
}
catch(IOException exc){
JOptionPane.showMessageDialog(null,
"Erro ao carregar a imagem: " +
exc.getMessage());
}
if(imagem != null){
desenhar();
}
}
}
);
c.add(btn);
setSize(400, 300);
setVisible(true);
}
public void desenhar(){
// desenha a imagem no JFrame
Graphics g = getGraphics();
g.drawImage(imagem, 0, 0, this);
}
public static void main(String args[]){
Estudos app = new Estudos();
app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
|
Java ::: Java para Engenharia ::: Geometria Analítica e Álgebra Linear |
Como calcular a transposta de uma matriz em Java - Java para Geometria Analítica e Álgebra LinearQuantidade de visualizações: 2788 vezes |
|
A matriz transposta de uma matriz A é a matriz AT. Tal matriz é obtida quando copiamos os elementos da matriz A para uma outra matriz (ou para ela mesma) e trocamos de posição as linhas e colunas. Dessa forma, a primeira linha da matriz A se transforma na primeira coluna da matriz transposta, a segunda linha da matriz A se transforma na segunda coluna da matriz transposta e assim por diante. Em termos de notação, podemos dizer, de forma algébrica, que: ATji = Aij Onde i representa as linhas e j representa as colunas, tanto na matriz original quanto na matriz transposta. É importante estar atento à quantidade de linhas e colunas na matriz original e na matriz transposta equivalente. Assim, se a matriz original for 3x2, a matriz transposta será 2x3. Antes de vermos o código Java, dê uma olhada na seguinte matriz de duas linhas e três colunas: \[A = \left[\begin{matrix} 3 & 5 & 7 \\ 1 & 2 & 9 \end{matrix}\right] \] Sua matriz transposta correspondente é: \[A^T = \left[\begin{matrix} 3 & 1 \\ 5 & 2 \\ 7 & 9 \end{matrix}\right] \] E agora veja o código Java que declara uma matriz 2x3 e gera a matriz transposta 3x2: ----------------------------------------------------------------------
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[]){
// vamos declarar e construir uma matrix
// 2x3 (duas linhas e três colunas
int matriz[][] = {{3, 5, 7}, {1, 2, 9}};
// vamos exibir os valores da matriz
System.out.println("Elementos da matriz:");
for(int i = 0; i < matriz.length; i++){
for(int j = 0; j < matriz[0].length; j++){
System.out.printf("%5d ", matriz[i][j]);
}
System.out.println();
}
// como temos uma matriz 2x3, a transposta deverá ser
// 3x2, ou seja, três linhas e duas colunas
int linhas = matriz.length; // linhas da matriz original
int colunas = matriz[0].length; // colunas da matriz original
int transposta[][] = new int[colunas][linhas];
// e agora vamos preencher a matriz transposta
for(int i = 0; i < matriz.length; i++){
for(int j = 0; j < matriz[0].length; j++){
transposta[j][i] = matriz[i][j];
}
}
// vamos exibir os valores da matriz transposta
System.out.println("Elementos da matriz transposta:");
for(int i = 0; i < transposta.length; i++){
for(int j = 0; j < transposta[0].length; j++){
System.out.printf("%5d ", transposta[i][j]);
}
System.out.println();
}
}
}
Ao executar este código Java nós teremos o seguinte resultado:
Elementos da matriz:
3 5 7
1 2 9
Elementos da matriz transposta:
3 1
5 2
7 9
|
Java ::: Pacote java.lang ::: StringBuffer |
Curso completo de Java - Como usar a classe StringBuffer da linguagem JavaQuantidade de visualizações: 8703 vezes |
|
A classe StringBuffer, no pacote java.lang, representa uma sequencia de caracteres mutável e segura em relação a threads. Um objeto StringBuffer é parecido com uma String, com a diferença que um StringBuffer pode ser modificado in-place, ou seja, modificações em seu conteúdo não geram uma nova cópia, como acontece com objetos da classe String. Veja a posição desta classe na hierarquia de classes Java: java.lang.Object java.lang.StringBuffer A qualquer momento um StringBuffer contém uma sequencia de caracteres em particular, mas o tamanho e o conteúdo da sequencia pode ser alterado por meio de certas chamadas de métodos. Objetos StringBuffer são seguros para acesso em um ambiente de múltiplas threads. Os métodos são sincronizados (synchronized) onde necessário de forma a garantir que todas as operações em uma instância em particular se comportem como se estivessem em ordem serial, ou seja, sejam consistentes com a ordem das chamadas de métodos feitas por cada uma das threads envolvidas. As operações principais de um StringBuffer são os métodos append() e insert(), que são sobrecarregados para aceitar dados de qualquer tipo. Cada um destes métodos converte a informação fornecida em string e então acrescenta ou insere os caracteres desta string no string buffer. O método append() sempre adiciona os caracteres no final do buffer. O método insert(), por sua vez, adiciona os caracteres em um determinado ponto. Por exemplo, se z se refere a um objeto string buffer cujo conteúdo é "start", então a chamada de método z.append("le") faria com que o string buffer tivesse agora ""startle"", enquanto z.insert(4, "le") alteraria o conteúdo do string buffer para "starlet". Em geral, se sb se refere a uma instância de StringBuffer, então sb.append(x) tem o mesmo efeito que sb.insert(sb.length(), x). Sempre que uma operação ocorre envolvendo uma sequencia de fonte (por exemplo, adicionar ou inserir a partir de uma outra sequencia), esta classe sincroniza somente o string buffer no qual a operação está sendo feita. Todo string buffer possui uma capacidade (capacity). Enquanto o comprimento da sequencia de caracteres contida no string buffer não exceder a capacidade do mesmo, não há necessidade de alocar uma nova matriz interna de buffer. Se o buffer interno for sobrecarregado, ele será automaticamente expandido. A partir do Java 5, esta classe foi suplementada com uma classe equivalente criada para o uso em ambiente de thread única: StringBuilder. A classe StringBuilder deve ser usada em vez de StringBuffer, uma vez que ela suporta as mesmas operações mas é mais rápida por não executar sincronização. |
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: 3893 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): ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
<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: ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
<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): ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
<!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á:  |
Delphi ::: Dicas & Truques ::: Matemática e Estatística |
Como calcular MDC em DelphiQuantidade de visualizações: 11814 vezes |
|
Como calcular o MDC (Máximo Divisor Comum) em Delphi Atualmente a definição de Máximo Divisor Comum (MDC) pode ser assim formalizada: Sejam a, b e c números inteiros não nulos, dizemos que c é um divisor comum de a e b se c divide a (escrevemos c|a) e c divide b (c|b). Chamaremos D(a,b) o conjunto de todos os divisores comum de a e b. O trecho de código abaixo mostra como calcular o MDC de dois números informados: ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
// função personalizada que permite calcular o MDC de dois
// valores inteiros
function MDC(a, b: Integer): Integer;
var
resto: Integer;
begin
while b <> 0 do
begin
resto := a mod b;
a := b;
b := resto;
end;
Result := a;
end;
procedure TForm3.Button1Click(Sender: TObject);
var
x, y: Integer;
begin
x := StrToInt(Dialogs.InputBox('MDC',
'Informe o primeiro valor:', ''));
y := StrToInt(Dialogs.InputBox('MDC',
'Informe o segundo valor:', ''));
// vamos mostrar o resultado
ShowMessage('O Máximo Divisor Comum de ' + IntToStr(x) +
' e ' + IntToStr(y) + ' é ' + IntToStr(MDC(x, y)));
end;
Para fins de compatibilidade, esta dica foi escrita usando Delphi 2009. |
Desafios, Exercícios e Algoritmos Resolvidos de Delphi |
Veja mais Dicas e truques de Delphi |
Dicas e truques de outras linguagens |
|
Java - Estruturas de dados em Java - Como obter a quantidade de nós em uma árvore binária usando Java Delphi - Delphi para iniciantes - Como criar uma data e hora em Delphi usando a função EncodeDateTime() |
Códigos Fonte |
 Software de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimentoDiga 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 funcionalidadesTenha 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 |
