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.

Você está aqui: Cards de Engenharia Civil - Estruturas de Aço e Madeira
Card 0 de 0
O filtro aplicado não retornou nenhum resultado. Clique o botão Remover Filtro ou experimente um filtro diferente.

Filtrar Cards
Use esta opção para filtrar os cards pelos tópicos que mais lhe interessam.
Termos:
Aviso Importante: Nos esforçamos muito para que o conteúdo dos cards e dos testes e conhecimento seja o mais correto possível. No entanto, entendemos que erros podem ocorrer. Caso isso aconteça, pedimos desculpas e estamos à disposição para as devidas correções. Além disso, o conteúdo aqui apresentado é fruto de conhecimento nosso e de pesquisas na internet e livros. Caso você encontre algum conteúdo que não deveria estar aqui, por favor, nos comunique pelos e-mails exibidos nas opções de contato.
Link para compartilhar na Internet ou com seus amigos:

Delphi ::: Dicas & Truques ::: Data e Hora

Como obter a quantidade de dias para um determinado ano usando a função DaysInAYear() do Delphi

Quantidade de visualizações: 11938 vezes
Quando estamos trabalhando com datas, geralmente precisamos saber a quantidade de dias que um determinado ano possui, ou seja, alguns anos possuem 365 dias, outros possuem 366. A unit DateUtils possui uma função chamada DaysInAYear() que serve para este propósito. Ela aceita um inteiro representando o ano desejado e retorna um inteiro representando a quantidade de dias que tal ano possui. Veja o exemplo:

procedure TForm1.Button1Click(Sender: TObject);
var
  ano, dias_ano: Integer;
begin
  ano := 2010;

  // vamos obter a quantidade de dias para o
  // ano de 2010
  dias_ano := DaysInAYear(ano);

  // exibe o resultado
  ShowMessage('O ano informado contém ' + IntToStr(dias_ano) +
    ' dias');
end;

Este trecho de código nos informará que o ano de 2010 possui 365 dias. Note que o argumento para a função DaysInAYear() deve estar entre 1 e 9999 (inclusive).

Para fins de compatibilidade, esta dica foi escrita usando Delphi 2009.


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

Como calcular a energia cinética de um corpo dado sua massa e sua velocidade usando a linguagem C

Quantidade de visualizações: 1895 vezes
Energia Cinética é a forma de energia relacionada aos corpos em movimento e é diretamente proporcional ao quadrado da velocidade do corpo. Sendo uma grandeza física escalar, a energia cinética possui como unidade de medida, de acordo com as unidades do SI (Sistema Internacional de Medidas), o joule.

A energia cinética é a capacidade de algum corpo em movimento realizar trabalho, modificando o estado de movimento dos corpos ao seu redor ou deformando-os. Quanto maior é a velocidade e a massa do corpo, maior é a sua capacidade de realizar trabalho quando estiver em movimento. De forma análoga, podemos pensar que um corpo que apresenta uma grande energia cinética necessita de uma grande quantidade de energia para cessar o seu movimento.

A fórmula para obtenção da Energia Cinética de um corpo, quando temos a sua massa e a sua velocidade é:

\[ E_c = \frac{\text{m} \cdot v^2}{\text{2}} \]

Onde:

Ec ? energia cinética (em joule, J).

m ? massa do corpo (em kg).

v ? velocidade do corpo (em m/s).

É comum, também, encontrarmos essa fórmula escrita da seguinte forma:

\[ E_c = \frac{1}{2} \text{m} \cdot v^2 \]

É importante observarmos que, caso um corpo se encontre em repouso, a energia cinética a ele associada é nula, ou seja, zero. Além disso, a energia cinética depende da velocidade desse corpo ao quadrado. Sendo assim, ao duplicarmos a velocidade de um corpo, sua energia cinética aumenta quatro vezes e, ao triplicá-la, a energia cinética desse corpo fica nove vezes maior.

Vamos ver um exemplo agora? Observe o seguinte enunciado:

1) Um ciclista e sua bicicleta possuem uma massa total de 100kg, e uma velocidade de 54km/h. Calcule sua energia cinética.

O exercício já nos dá a massa total em kg, mas precisamos converter km/h em m/s antes de realizar o cálculo da energia cinética. Fique atento(a). Veja o código C completo que efetua este cálculo e exibe a energia cinética resultante:

#include <stdio.h>
#include <stdlib.h>
#include <math.h> 
     
int main(int argc, char *argv[]){
  // a massa total
  float massa = 100; // em kg
  // velocidade (em m/s)
  float velocidade = 54 / 3.6; // converti de km/h para m/s
  
  // agora calculamos a energia cinética
  float energia_cinetica = (massa * pow(velocidade, 2)) / 2;
  
  // mostramos o resultado
  printf("A energia cinética é: %fJ",
    energia_cinetica);
			  
  printf("\n\n");
  system("PAUSE");
  return 0;
}

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

A energia cinética é: 11250.000000J


C# ::: Windows Forms ::: TextBox

C# Windows Forms Avançado - Como rolar as linhas de um TextBox para cima uma de cada vez usando a API do Windows

Quantidade de visualizações: 8076 vezes
Em algumas situações gostaríamos de rolar para cima o conteúdo de um TextBox de múltiplas linhas uma linha de cada vez. Para isso podemos usar a API do Windows, mais especificamente a mensagem WM_VSCROLL com o valor SB_LINEUP para seu parâmetro wParam. O valor do parâmetro lParam é zero.

Veja um trecho de código que rola para cima o conteúdo de um TextBox uma linha de cada vez. Antes de executar este exemplo, tenha a certeza de ter um TextBox de múltiplas, com barras de rolagem e conteúdo que force o aparecimento das barras de rolagem.

Comece adicionando a linha:

using System.Runtime.InteropServices;

na seção de usings do seu formulário ou classe. Em seguida adicione o trecho de código abaixo no corpo da classe, como um método:

[DllImport("user32.dll", EntryPoint = "SendMessage", 
  CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, 
  IntPtr wParam, IntPtr lParam);

Finalmente coloque o código abaixo no evento Click de um botão:

private void button2_Click(object sender, EventArgs e){
  // antes de executar este exemplo certifique-se de que
  // a propriedade Multiline do TextBox esteja definida
  // como true e a propriedade ScrollBars contenha o valor
  // Vertical ou Both
  textBox1.Multiline = true;
  textBox1.ScrollBars = ScrollBars.Vertical;
    
  // constante para a mensagem WM_VSCROLL
  const uint WM_VSCROLL = 0x115;
  // constante para o parâmetro wParam
  const int SB_LINEUP = 0;
  
  // handle para a caixa de texto
  IntPtr handle = textBox1.Handle;
  IntPtr wParam = (IntPtr)SB_LINEUP;
  IntPtr lParam = IntPtr.Zero;
  
  // vamos fazer com que o TextBox role uma linha para cima
  SendMessage(textBox1.Handle, WM_VSCROLL, wParam, lParam);
}



Java ::: Desafios e Lista de Exercícios Resolvidos ::: Estruturas de Dados - Árvores Binárias e Árvores Binárias de Busca

Exercícios Resolvidos de Java - Travessia de uma árvore binária de busca usando o percurso em-ordem (in-order, In-ordem ou ordem simétrica)

Quantidade de visualizações: 3342 vezes
Pergunta/Tarefa:

O percurso em ordem (em-ordem, in-order, In-ordem ou ordem simétrica) é usado quando queremos exibir os valores dos nós da árvore binária de busca em ordem ascendente.

Neste tipo de percurso nós visitamos primeiramente a sub-árvore da esquerda, então o nó atual e finalmente a sub-árvore à direita do nó atual. É importante notar que esta travessia é feita por meio de uma função recursiva.

Escreva um programa Java que contenha uma árvore binária de busca cujos nós guardarão, além das referências para o filho esquerdo e o filho direito, apenas um valor inteiro. Forneça uma função inserir() que permitirá inserir os valores na árvore. Em seguida forneça uma função recursiva que permitirá fazer a travessia in-order da árvore.

Sua saída deverá ser parecida com:

Informe um valor inteiro: 7
Informe um valor inteiro: 3
Informe um valor inteiro: 18
Informe um valor inteiro: 4
Informe um valor inteiro: 9

Percurso em ordem:
3 4 7 9 18
Resposta/Solução:

Veja a resolução comentada deste exercício usando Java:

Código para NoArvore.java:

package estudos;

public class NoArvore {
  int valor; // valor armazenado no nó
  NoArvore esquerdo; // filho esquerdo
  NoArvore direito; // filho direito

  // construtor do nó
  public NoArvore(int valor){
    this.valor = valor;
  }
}

Código para ArvoreBinariaBusca.java:

package estudos;

public class ArvoreBinariaBusca {
  private NoArvore raiz; // referência para a raiz da árvore
  
  // método usado para inserir um novo nó na árvore
  // retorna true se o nó for inserido com sucesso e false
  // se o elemento não puder ser inserido (no caso de já
  // existir um elemento igual)
  public boolean inserir(int valor){
    // a árvore ainda está vazia?
    if(raiz == null){
      // vamos criar o primeiro nó e definí-lo como a raiz da árvore
      raiz = new NoArvore(valor); // cria um novo nó
    }
    else{
      // localiza o nó pai
      NoArvore pai = null;
      NoArvore noAtual = raiz; // começa a busca pela raiz
 
      // enquanto o nó atual for diferente de null
      while(noAtual != null){
        if(valor < noAtual.valor) {
          pai = noAtual;
          noAtual = noAtual.esquerdo;
        }
        else if(valor > noAtual.valor){
          pai = noAtual;
          noAtual = noAtual.direito;
        }
        else{
          return false; // um nó com este valor foi encontrado
        }
      }
       
      // cria o novo nó e o adiciona ao nó pai
      if(valor < pai.valor){
         pai.esquerdo = new NoArvore(valor);
      }
      else{
        pai.direito = new NoArvore(valor);
      }
    }

    return true; // retorna true para indicar que o novo nó 
    // foi inserido
  }
  
  // método que permite disparar a travessia em-ordem
  public void emOrdem(){
    emOrdem(raiz);
  }

  // sobrecarga do método emOrdem com uma parâmetro (esta é a
  // versão recursiva do método)
  private void emOrdem(NoArvore raiz){
    if(raiz == null){ // condição de parada
      return;
    }
    
    // visita a sub-árvore da esquerda
    emOrdem(raiz.esquerdo);
    // visita o nó atual
    System.out.print(raiz.valor + " ");
    // visita a sub-árvore da direita
    emOrdem(raiz.direito);
  }
}

E aqui está o código para a classe que permite testar a árvore:

package estudos;

import java.util.Scanner;

public class Estudos {
  public static void main(String[] args) {
    Scanner entrada = new Scanner(System.in);  
      
    // vamos criar um novo objeto da classe ArvoreBinariaBusca
    ArvoreBinariaBusca arvore = new ArvoreBinariaBusca();
   
    // vamos inserir 5 valores na árvore
    for(int i = 0; i < 5; i++){
      System.out.print("Informe um valor inteiro: ");
      int valor = Integer.parseInt(entrada.nextLine());
      
      // vamos inserir o nó e verificar o sucesso da operação
      if(!arvore.inserir(valor)){
        System.out.println("Erro. Um elemento já contém este valor.");  
      }
    }
    
    // vamos exibir os nós da árvore usando o percurso em ordem
    System.out.println("\nPercurso em ordem:");
    arvore.emOrdem();
    
    System.out.println("\n");
  }
}



Java ::: Desafios e Lista de Exercícios Resolvidos ::: Java Básico

Exercício Resolvido de Java - Como ler um número inteiro e imprimir seu sucessor e seu antecessor em Java

Quantidade de visualizações: 1809 vezes
Pergunta/Tarefa:

Escreva um programa Java para ler um número inteiro e imprimir seu sucessor e seu antecessor. O usuário poderá informar um valor positivo ou negativo.

Sua saída deverá ser parecida com:

Informe um número inteiro: 16
O número informado foi: 16
O antecessor é 15
O sucessor é: 17
Resposta/Solução:

Veja a resolução comentada deste exercício usando Java:

package estudos;
 
import java.util.Scanner;

public class Estudos{
  public static void main(String[] args) {
    // para ler a entrada do usuário
    Scanner entrada = new Scanner(System.in);
    
    // vamos pedir para o usuário informar um número inteiro
    System.out.print("Informe um número inteiro: ");
    int numero = Integer.parseInt(entrada.nextLine());
    
    // vamos calcular o sucessor do número informado
    int sucessor = numero + 1;
    
    // vamos calcular o antecessor do número informado
    int antecessor = numero - 1;
    
    // e agora mostramos os resultados
    System.out.println("O número informado foi: " + numero);
    System.out.println("O antecessor é " + antecessor);
    System.out.println("O sucessor é: " + sucessor);
  }
}



Mais Desafios de Programação e Exercícios e Algoritmos Resolvidos de Java

Veja mais Dicas e truques de Java

Dicas e truques de outras linguagens

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 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 Apenas R$ 19,90


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