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 - Construção Civil
Card 1 de 28
Fases de uma obra

A Planta de Localização (escala usual 1:200) identifica a posição da obra no terreno. Serve para implantar o projeto.

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:

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: 1431 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.


JavaScript ::: Dicas & Truques ::: Data e Hora

Como calcular a quantidade de dias restantes para o fim do ano em JavaScript

Quantidade de visualizações: 9688 vezes
Desde a época que criamos o site, muitos usuários nos perguntam como escrever um código JavaScript que calcula e mostra a quantidade de dias restantes para o fim do ano. Nesta dica eu mostro como isso pode ser feito. É claro que você pode alterá-lo para calcular a quantidade de dias restantes para qualquer data.

Veja a página HTML completa para o exemplo:

<!doctype html>
<html>
<head>
  <title>Datas em JavaScript</title>
</head>
<body>

<script type="text/javascript">
  // vamos obter a data de hoje
  var hoje = new Date();
  
  // vamos construir a data do final do ano
  var fim_ano = new Date(hoje.getFullYear(), 11, 31);
  
  // quantidade de milisegundos em um dia
  var milisegundos_dia = 1000 * 60 * 60 * 24;
  
  // calculamos os dias restantes para o fim do ano
  var dias_restantes = Math.ceil((fim_ano.getTime() -
    hoje.getTime()) / (milisegundos_dia));
  
  // e mostramos o resultado
  document.write("Hoje é: " + hoje.toString() + "<br>");
  document.write("Faltam " + dias_restantes + 
    " dias para o fim do ano.");
</script>
  
</body>
</html>

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

Hoje é: Sat Feb 04 2023 12:47:50 GMT-0300 (Horário Padrão de Brasília)
Faltam 330 dias para o fim do ano.


Java ::: Classes, Controles e Componentes ::: JSplitPane

Java Swing - Como usar a classe JSplitPane para dividir o espaço ocupado pelos componentes de suas aplicações Java Swing

Quantidade de visualizações: 11264 vezes
A classe JSplitPane é usada quando precisamos controlar o espaço ocupado por dois ou mais componentes. Objetos desta classe podem ser redimensionados, de modo a aumentar ou diminuir a área ocupada por um dos componentes. Veja a posição desta classe na hierarquia de classes Java:

java.lang.Object
  java.awt.Component
    java.awt.Container
      javax.swing.JComponent
        javax.swing.JSplitPane
Esta classe implementa as interfaces ImageObserver, MenuContainer, Serializable e Accessible.

No trecho de código abaixo você verá como é possível dividir a área ocupada por duas áreas de texto (JTextArea). Execute a aplicação e experimente aumentar ou diminuir o espaço ocupado pelos componentes:

import javax.swing.*;
import java.awt.*;
 
public class Estudos extends JFrame{
  public Estudos(){
    super("Como usar a classe JSplitPane");
 
    // primeira área de texto
    JTextArea textArea1 = new JTextArea(5, 30);
    textArea1.setText("Sou a área de texto 1.");
    JScrollPane sPane1 = new JScrollPane(textArea1);    
 
    // segunda área de texto
    JTextArea textArea2 = new JTextArea(5, 30);
    textArea2.setText("Sou a área de texto 2.");    
    JScrollPane sPane2 = new JScrollPane(textArea2);
 
    // Cria o JSplitPane
    JSplitPane splitPane = new JSplitPane(
      JSplitPane.HORIZONTAL_SPLIT, sPane1, sPane2);
 
    add(splitPane, BorderLayout.CENTER);
 
    setSize(300, 150);
    setVisible(true);    
  }
 
  public static void main(String args[]){
    Estudos app = new Estudos();
    app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
}

Ao executar esta aplicação Java Swing nós teremos o seguinte resultado:




C# ::: Dicas & Truques ::: Arquivos e Diretórios

Apostila C# para iniciantes - Como listar todos os arquivos de um diretório usando C#

Quantidade de visualizações: 5 vezes
Nesta dica eu mostro como é possível usar o método GetFiles() da classe Directory para listar todos os arquivos de um determinado diretório. Note como usei o caractere "*" para informar o padrão de arquivos a serem exibidos.

Veja o código completo:

using System;
using System.IO;

namespace Estudos{
  class Program{
    static void Main(string[] args) {
      string diretorio = @"C:\estudos_dart";
      string padrao = "*";

      if (args.Length > 0) {
        diretorio = args[0];
      }
      if (args.Length > 1) {
        padrao = args[1];
      }

      string[] arquivos = Directory.GetFiles(diretorio,
        padrao);

      foreach (string arquivo in arquivos) {
        Console.WriteLine(arquivo);
      }
    }
  }
}

Ao executar este código nós teremos uma saída parecida com:

C:\estudos_dart\condicional_if_else.dart
C:\estudos_dart\DICA.txt
C:\estudos_dart\laco_do_while.dart
C:\estudos_dart\laco_for.dart
C:\estudos_dart\laco_while.dart
C:\estudos_dart\primeira.dart


Java ::: Classes e Componentes ::: JTree

Java Swing - Como obter o texto do ítem selecionado na JTree

Quantidade de visualizações: 11791 vezes
Nesta dica veremos como usar o método getLastSelectedPathComponent() da classe JTable do Java Swing para obter o texto do item (nó) selecionado na árvore. Veja como fazemos um cast (conversão) para um objeto da classe DefaultMutableTreeNode antes de podermos acessar o nó retornado.

O resultado será igual ao que temos na imagem abaixo:



Veja o código Java Swing completo para este exemplo:

package arquivodecodigos;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.tree.*;
 
public class Estudos extends JFrame{
  JTree arvore;  
 
  public Estudos(){
    super("Exemplo de uma JTree simples");
     
    DefaultMutableTreeNode raiz = montarArvore();
    arvore = new JTree(raiz);  
 
    JButton btn = new JButton("Obter Texto");
    btn.addActionListener(
      new ActionListener(){
        @Override
        public void actionPerformed(ActionEvent e){
          if(!arvore.isSelectionEmpty()){
            DefaultMutableTreeNode no = (DefaultMutableTreeNode)
              arvore.getLastSelectedPathComponent();
 
            JOptionPane.showMessageDialog(null,
          "Texto do ítem selecionado: " + no.toString(), 
          "JTree", JOptionPane.INFORMATION_MESSAGE);
          }
        }
      }
    );
 
    Container c = getContentPane();
    c.setLayout(new FlowLayout());
             
    JScrollPane scrollPane = new JScrollPane(arvore);
    c.add(scrollPane);
    c.add(btn);
     
    setSize(400, 300);
    setVisible(true);
  }
     
  public static void main(String args[]){
    Estudos app = new Estudos();
    app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
 
  private DefaultMutableTreeNode montarArvore(){ 
    DefaultMutableTreeNode raiz = new DefaultMutableTreeNode("Cidades"); 
    DefaultMutableTreeNode regiao = new DefaultMutableTreeNode("Região"); 
    regiao.add(new DefaultMutableTreeNode("Centro-Oeste"));
    regiao.add(new DefaultMutableTreeNode("Norte"));
    regiao.add(new DefaultMutableTreeNode("Sul"));     
          
    raiz.add(regiao); 
    return raiz; 
  }
}



Desafios, 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á 12 usuários muito felizes estudando em nosso site.