Você está aqui: JavaScript ::: Dicas & Truques ::: Arrays e Matrix (Vetores e Matrizes) |
|
Como adicionar um elemento ao final de um arrayQuantidade de visualizações: 8266 vezes |
|
<script language="javascript"> <!-- var valores = new Array(1, 2, 3, 4, 5); document.write("Valores no Array: " + valores + "<br>"); valores.push(6); document.write("Adicionei um novo elemento ao final do array<br>"); document.write("Valores no Array: " + valores); //--> </script> |
|
Link para compartilhar na Internet ou com seus amigos: | |
VisuAlg ::: Dicas & Truques ::: Geometria, Trigonometria e Figuras Geométricas |
Como calcular o coeficiente angular de uma reta em VisuAlg dados dois pontos no plano cartesianoQuantidade de visualizações: 378 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 VisuAlg 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: algoritmo "Calcular o coeficiente angular de uma reta em VisuAlg" var // coordenadas dos dois pontos x1, y1, x2, y2: real // guarda o coeficiente angular m: real inicio // x e y do primeiro ponto escreva("Coordenada x do primeiro ponto: ") leia(x1) escreva("Coordenada y do primeiro ponto: ") leia(y1) // x e y do segundo ponto escreva("Coordenada x do segundo ponto: ") leia(x2) escreva("Coordenada y do segundo ponto: ") leia(y2) // vamos calcular o coeficiente angular m <- (y2 - y1) / (x2 - x1) // mostramos o resultado escreva("O coeficiente angular é: ", m) fimalgoritmo Ao executar este código VisuAlg 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__$): algoritmo "Calcular o coeficiente angular de uma reta em VisuAlg" var // coordenadas dos dois pontos x1, y1, x2, y2: real // guarda os comprimentos dos catetos oposto e adjascente cateto_oposto, cateto_adjascente: real // guarda o ângulo tetha (em radianos) e a tangente tetha, tangente: real inicio // x e y do primeiro ponto escreva("Coordenada x do primeiro ponto: ") leia(x1) escreva("Coordenada y do primeiro ponto: ") leia(y1) // x e y do segundo ponto escreva("Coordenada x do segundo ponto: ") leia(x2) escreva("Coordenada y do segundo ponto: ") leia(y2) // 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 <- ArcTan(cateto_oposto / cateto_adjascente) // e finalmente usamos a tangente desse ângulo para calcular // o coeficiente angular tangente <- Tan(tetha) // mostramos o resultado escreva("O coeficiente angular é: ", tangente) fimalgoritmo 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 ::: Dicas & Truques ::: Threads |
Threads em Java - O que são threads e como usá-las em seus programas JavaQuantidade de visualizações: 13180 vezes |
Uma thread é um fluxo de execução de uma determinada tarefa em um programa. Na programação tradicional, temos apenas um fluxo de execução que começa a executar no início do programa e vai até o final. Com o uso de threads podemos ter várias tarefas sendo executadas ao mesmo tempo, cada uma independente da outra. Em programas que contêm interfaces gráficas, o uso de múltiplos fluxos de execução (ou threads) é muito comum. Enquanto digitamos em uma caixa de texto, uma animação pode estar sendo executada ou um arquivo sendo baixado. O Java permite que tenhamos várias threads sendo executadas ao mesmo tempo. Cada tarefa (ou thread) é uma instância da interface Runnable. Esta interface descreve apenas um método: public void run(); // criamos uma classe que servirá como thread class MinhaThread extends Thread{ private String nome; public MinhaThread(String nome){ this.nome = nome; } public void run(){ for(int i = 1; i <= 20; i++){ System.out.println(nome + ": " + i); } } } public class Estudos{ public static void main(String[] args){ // vamos criar duas threads MinhaThread t1 = new MinhaThread("Thread 1"); t1.start(); // chamamos o método start() e não run() MinhaThread t2 = new MinhaThread("Thread 2"); t2.start(); // chamamos o método start() e não run() System.exit(0); } } Salve este código como Estudos.java, compile e execute. Veja que cada thread escreverá de 1 a 20 na tela. Observe como as duas threads se alternam em suas tarefas, ou seja, de tempos em tempos uma cede lugar para que a outra seja executada. Note também que, embora nossa classe tenha um método run() nós não o chamamos. O que fazemos é chamar o método start(), que torna a thread elegível para ser executada a qualquer momento. Uma outra forma de criarmos uma thread é fazer com que nossa classe implemente a interface Runnable. Veja: // criamos uma classe que servirá como thread class MinhaThread implements Runnable{ private String nome; public MinhaThread(String nome){ this.nome = nome; } public void run(){ for(int i = 1; i <= 20; i++){ System.out.println(nome + ": " + i); } } } public class Estudos{ public static void main(String[] args){ // vamos criar duas threads MinhaThread mt1 = new MinhaThread("Thread 1"); Thread t1 = new Thread(mt1); t1.start(); MinhaThread mt2 = new MinhaThread("Thread 2"); Thread t2 = new Thread(mt2); t2.start(); System.exit(0); } } O funcionamento do código é o mesmo. A diferença é que agora, a classe usada como thread implementa a interface Runnable. A forma de criação da thread também foi alterada. Agora nós criamos instâncias de Thread fornecendo nossa classe thread como argumento e chamamos o método start da classe Thread e não de nossa própria classe, como fizemos anteriormente. |
Java ::: Estruturas de Dados ::: Pilhas |
Como criar uma pilha em Java usando um vetor (array) - Estruturas de Dados em JavaQuantidade de visualizações: 1918 vezes |
A Pilha é uma estrutura de dados do tipo LIFO - Last-In, First-Out (Último a entrar, primeiro a sair). Neste tipo de estrutura, o último elemento a ser inserido é o primeiro a ser removido. Veja a imagem a seguir: Embora seja mais comum a criação de uma estrutura de dados do tipo Pilha de forma dinâmica (usando ponteiros e referências), nesta dica eu mostrarei como podemos criá-la em Java usando um array, ou seja, um vetor. No exemplo eu usei inteiros, mas você pode modificar para o tipo de dados que você achar mais adequado. Veja o código completo para uma classe Pilha usando um vetor de ints. Veja que o tamanho do vetor é informado no construtor da classe. Note também a lógica empregada na construção dos métodos empilhar(), desempilhar() e imprimirPilha(): Código para Pilha.java: package estudos; public class Pilha { private int elementos[]; // elementos na pilha private int topo; // o elemento no topo da pilha private int maximo; // a quantidade máxima de elementos na pilha // construtor da classe Pilha public Pilha(int tamanho) { // constrói o vetor this.elementos = new int[tamanho]; // define o topo como -1 this.topo = -1; // ajusta o tamanho da pilha para o valor recebido this.maximo = tamanho; } // método usado para empilhar um novo elemento na pilha public void empilhar(int item) { // a pilha já está cheia? if (this.topo == (this.maximo - 1)) { System.out.println("\nA pilha está cheia\n"); } else { // vamos inserir este elemento no topo da pilha this.elementos[++this.topo] = item; } } // méodo usado para desempilhar um elemento da pilha public int desempilhar() { // a pilha está vazia if (this.topo == -1) { System.out.println("\nA pilha está vazia\n"); return -1; } else { System.out.println("Elemento desempilhado: " + elementos[topo]); return this.elementos[this.topo--]; } } // método que permite imprimir o conteúdo da pilha public void imprimirPilha() { // pilha vazia if (this.topo == -1) { System.out.println("\nA pilha está vazia\n"); } else { // vamos percorrer todos os elementos da pilha for (int i = 0; i <= this.topo; i++) { System.out.println("Item[" + (i + 1) + "]: " + this.elementos[i]); } } } } Veja agora o código para a classe principal, ou seja, a classe Main usada para testar a funcionalidade da nossa pilha: Código para Principal.java: package estudos; public class Estudos{ public static void main(String[] args){ // vamos criar uma nova pilha com capacidade para 5 elementos Pilha p = new Pilha(5); // vamos empilhar 3 elementos p.empilhar(34); p.empilhar(52); p.empilhar(18); // vamos mostrar os elementos na pilha System.out.println("Itens presentes na Pilha\n"); p.imprimirPilha(); // agora vamos remover e retornar dois elementos da pilha System.out.println(); p.desempilhar(); p.desempilhar(); // vamos mostrar os elementos na pilha novamente System.out.println("\nItens presentes na Pilha\n"); p.imprimirPilha(); } } Ao executar este código Java nós teremos o seguinte resultado: Itens presentes na Pilha Item[1]: 34 Item[2]: 52 Item[3]: 18 Elemento desempilhado: 18 Elemento desempilhado: 52 Itens presentes na Pilha Item[1]: 34 |
PHP ::: Dicas & Truques ::: Data e Hora |
Datas e horas em PHP - Como obter o timestamp do primeiro dia do mês e ano informadosQuantidade de visualizações: 9732 vezes |
Nesta dica eu mostrarei como é possível obter o timestamp do primeiro dia de um determinado mês e ano. O "Unix timestamp" contém o número de segundos entre a "Unix Epoch" (1 de janeiro de 1970, às 00:00:00 GMT) e o tempo decorrido desde então. Veja o código PHP completo para o exemplo: <html> <head> <title>Estudando PHP</title> </head> <body> <?php $mes = 1; // 1 = janeiro; $ano = 2021; $primeiro_dia = mktime(0, 0, 0, $mes, 1, $ano); echo "O timestamp do primeiro dia do mês e ano informado é: " . $primeiro_dia; ?> </body> </html> Ao executar este código nós teremos o seguinte resultado O timestamp do primeiro dia do mês e ano informado é: 1609455600 |
GNU Octave ::: Dicas & Truques ::: Trigonometria - Funções Trigonométricas |
Como converter graus em radianos usando a função deg2rad() do GNU Octave - GNU Octave para Geometria Analítica e Álgebra LinearQuantidade de visualizações: 1275 vezes |
Quer aprender como calcular radianos ou como converter graus em radianos? Veja a fórmula nessa dica. Quando estamos trabalhando com trigonometria no software GNU Octave, é importante ficarmos atentos ao fato de que todos os métodos e funções trigonométricas nessa linguagem recebem seus argumentos em radianos, em vez de graus. Nesta dica veremos como converter graus em radianos (sem a chatice de ficar relembrando regra de três). Veja a fórmula abaixo: \[Radianos = Graus \times \frac{\pi}{180}\] Agora veja como esta fórmula pode ser escrita no GNU Octave. Primeiro vamos usar a fórmula dada e depois veremos a função deg2rad(). Assim, digite a expressão a seguir na janela de comandos do GNU Octave: >> 30 * (pi / 180) [Enter] ans = 0.5236 >> Agora veja como podemos obter o mesmo resultado usando a função deg2rad(): >> deg2rad(30) [Enter] ans = 0.5236 >> Finalmente, veja como usar esta função em um script do GNU Octave: graus = input("Informe o ângulo em graus: "); radianos = deg2rad(graus); fprintf("O ângulo em radianos é %f\n", radianos); Execute este script e teremos o seguinte resultado na janela de comandos: Informe o ângulo em graus: 30 [Enter] O ângulo em radianos é 0.523599 >> |
Veja mais Dicas e truques de GNU Octave |
Dicas e truques de outras linguagens |
Delphi - Como calcular MDC em Delphi |
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 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 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 |