Dúvidas, comentários e doaçoes: +55 62 9 8513 2505

Planilha de Dimensionamento de Tubulações Hidráulicas Água Fria e Água Quente Completa
Nossa planilha automática de dimensionamento de tubulações de água fria e quente é uma ferramenta desenvolvida para auxiliar engenheiros e projetistas no cálculo rápido e preciso das redes hidráulicas de edificaçoes. Por meio da inserçao de dados como vazao, diâmetro da tubulaçao, comprimento da rede, material do tubo e coeficientes hidráulicos, a planilha realiza automaticamente os cálculos necessários para verificar velocidade da água, perda de carga e dimensionamento adequado das tubulaçoes.

C ::: C para Engenharia ::: Física - Mecânica

Como calcular a Energia Potencial Gravitacional de um corpo dado a sua massa e altura em C

Quantidade de visualizações: 2944 vezes
A Energia Potencial Gravitacional ou Energia Gravitacional é a energia potencial que um objeto massivo tem em relação a outro objeto massivo devido à gravidade. É a energia potencial associada ao campo gravitacional, que é parcialmente convertida em energia cinética quando os objetos caem uns contra os outros. A energia potencial gravitacional aumenta quando dois objetos são separados.

A fórmula para obtenção da Energia Potencial Gravitacional de um corpo em relação à sua massa e distância do chão, ou seja, da superfície terrestre, é:

\[ E_\text{pg} = \text{m} \cdot \text{g} \cdot \text{h} \]

Onde:

Epg: energia potencial gravitacional (em joule, J).

m: massa do corpo (em kg).

g: aceleração da gravidade (m/s2).

h: altura do objeto em relação ao chão (em metros).

Como podemos ver, a Energia Potencial Gravitacional está diretamente relacionada à distância do corpo em relação à superfície terrestre. Dessa forma, quanto mais distante da terra o objeto estiver, maior a sua energia gravitacional. Isso nós diz também que, um objeto de altura zero possui Energia Potencial Gravitacional nula.

Vamos ver um exemplo agora? Observe o seguinte enunciado:

1) Uma pessoa levanta um tijolo com peso de 2 quilogramas à distância de 1,5 metros do chão. Qual é a Energia Potencial Gravitacional deste corpo?

Como o exercício nos dá a massa do objeto em kg e a distância dele em relação ao chão já está em metros, tudo que temos a fazer é jogar na fórmula. Veja o código C completo para o cálculo:

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

// função principal do programa
int main(int argc, char *argv[]){
  // gravidade terrestre em m/s2
  float gravidade = 9.80665;
  // massa do corpo
  float massa = 2; // em kg
  // altura do corpo em relação ao chão
  float altura = 1.5; // em metros
  
  // vamos calcular a energia potencial gravitacional
  float epg = massa * gravidade * altura;
  
  // mostramos o resultado
  printf("A Energia Potencial Gravitacional é: %fJ", epg);
  
  printf("\n\n");
  system("PAUSE");
  return 0;
}

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

A Energia Potencial Gravitacional é: 29.419950J


Ruby ::: Dicas & Truques ::: Strings e Caracteres

Como acessar os caracteres individuais de uma string em Ruby usando o método slice() da classe String

Quantidade de visualizações: 7901 vezes
O método slice() da classe String da linguagem Ruby se torna realmente útil quando precisamos acessar os caracteres individuais de uma string. Neste caso, só precisamos fornecer o índice do caractere a ser acessado e o número 1. O retorno do método é uma nova string ou nulo.

Veja o exemplo a seguir:

nome = "Arquivo de Códigos"

# vamos acessar os caracteres individualmente usando
# o método slice
for i in (0..nome.length - 1)
  letra = nome.slice(i, 1) 
  print letra + " "
end

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

A r q u i v o   d e   C ó d i g o s



VB.NET ::: Dicas & Truques ::: Matemática e Estatística

Como verificar se um número é par ou ímpar em VB.NET

Quantidade de visualizações: 21409 vezes
Em várias situações nós lidamos com códigos VB.NET nos quais precisamos verificar se um determinado valor é par ou ímpar. Para efetuar este teste, nós só precisamos usar o operador Mod, que retorna o resto de uma divisão envolvendo inteiros. Assim, se o resto da divisão for 0, sabemos que o número é par e, em caso contrário, será ímpar.

Veja o código completo para o exemplo que lê um número e informa se ele é par ou ímpar:

Imports System

Module Program
  Sub Main(args As String())
    Dim valor As Integer

    Console.Write("Informe um número inteiro: ")
    valor = Val(Console.ReadLine())

    If valor Mod 2 = 0 Then
      Console.WriteLine("O número é par")
    Else
      Console.WriteLine("O número é ímpar")
    End If

    Console.WriteLine("\nPressione qualquer tecla para sair...")
    ' pausa o programa
    Console.ReadKey()
  End Sub
End Module

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

Informe um número inteiro: 38
O número é par
Pressione qualquer tecla para sair...


Java ::: Estruturas de Dados ::: Árvore Binária e Árvore Binária de Busca

Como percorrer uma árvore binária em Java usando o algorítmo depth-first search (DFS) de forma iterativa

Quantidade de visualizações: 1430 vezes
Nesta dica mostrarei como podemos implementar o algorítmo da Busca em Profundidade (DFS, do inglês depth-first search) em Java de forma iterativa, ou seja, sem usar recursão. Não farei a busca, mas sim o percurso, para que você entenda como a lógica dessa busca funciona.

Antes de iniciarmos, veja a árvore binária que vamos usar no exemplo:



Note que esta árvore possui seis nós. O nó 5 é o nó raiz, e possui como filhos os nós 4 e 9. O nó 4, por sua vez, possui apenas um filho, o nó 2, ou seja, o filho da esquerda. O nó 9 possui dois filhos: o nó 3 é o filho da esquerda e o nó 12 é o filho da direita. Os filhos da árvore binária que não possuem outros filhos são chamados de folhas.

Com a abordagem da busca em profundidade, começamos com o nó raiz e viajamos para baixo em uma única ramificação. Se o nó desejado for encontrado naquela ramificação, ótimo. Do contrário, continuamos subindo e pesquisando por nós não visitados. Esse tipo de busca também tem uma notação big O de O(n).

Vamos à implementação? Veja o código para a classe No, que representa um nó na árvore binária:

// implementação da classe No
class No{
  public int valor; // o valor do nó
  public No esquerdo; // o filho da esquerda
  public No direito; // o filho da direita
  
  public No(int valor){
    this.valor = valor;
    this.esquerdo = null;
    this.direito = null;
  }
}

Veja agora o código completo para o exemplo. Note que usei uma implementação não-recursiva, na qual todos os nós expandidos recentemente são adicionados a uma pilha, para realizar a exploração. O uso da pilha permite o retrocesso (backtracking) de forma a reiniciarmos o percurso ou busca no próximo nó.

Para manter o código o mais simples possível, eu usei a classe Stack do Java, juntamente com seus métodos push() e pop() para simular a pilha. Usei também uma ArrayList para guardar os valores da árvore binária na ordem depth-first.

Eis o código:

package estudos;

import java.util.ArrayList;
import java.util.Stack;

// implementação da classe No
class No{
  public int valor; // o valor do nó
  public No esquerdo; // o filho da esquerda
  public No direito; // o filho da direita
  
  public No(int valor){
    this.valor = valor;
    this.esquerdo = null;
    this.direito = null;
  }
}

public class Estudos{
  public static void main(String[] args){
    // vamos criar os nós da árvore
    No cinco = new No(5); // será a raiz da árvore
    No quatro = new No(4);
    No nove = new No(9);
    No dois = new No(2);
    No tres = new No(3);
    No doze = new No(12);
    
    // vamos fazer a ligação entre os nós
    cinco.esquerdo = quatro;
    cinco.direito = nove;
    quatro.esquerdo = dois;
    nove.esquerdo = tres;
    nove.direito = doze;
    
    // agora já podemos efetuar o percurso depth-first
    ArrayList<Integer> valores = percursoDepthFirst(cinco);
    System.out.println("Os valores na ordem Depth-First são: " + valores);
  }
  
  public static ArrayList<Integer> percursoDepthFirst(No no){
    // vamos usar uma ArrayList para retornar os elementos
    // na ordem Depth-First
    ArrayList<Integer> valores = new ArrayList<>();
    
    // vamos criar uma nova instância de uma pilha
    Stack<No> pilha = new Stack<>();
    // já vamos adicionar o primeiro nó recebido, que é a raiz
    pilha.push(no);
    
    // enquanto a pilha não estiver vazia
    while(pilha.size() > 0){
      // vamos obter o elemento no topo da pilha
      No atual = pilha.pop();
      // adicionamos este valor no ArrayList
      valores.add(atual.valor);
	  
      // vamos colocar o filho direito na pilha
      if(atual.direito != null){
        pilha.push(atual.direito);
      }
      
      // vamos colocar o filho esquerdo na pilha
      if(atual.esquerdo != null){
        pilha.push(atual.esquerdo);
      }
    }
    
    return valores; // retorna os valores da árvore
  }
}

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

Os valores na ordem Depth-First são: [5, 4, 2, 9, 3, 12]

Compare estes valores com a imagem vista anteriormente para entender ainda melhor o percurso ou busca Depth-First.


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.


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