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 ::: Desafios e Lista de Exercícios Resolvidos ::: Estruturas de Dados - Listas Ligadas

Exercícios Resolvidos de Java - Como inserir um nó em qualquer posição de uma lista ligada em Java - Escreva um programa Java que cria uma lista dinamicamente encadeada

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

Escreva um programa Java que cria uma lista dinamicamente encadeada (lista singularmente encadeada) e pede para o usuário inserir 5 elementos do tipo inteiro. Em seguida peça para o usuário informar um índice e um novo elemento e insira tal elemento no índice informado.

Faça a validação dos índices para que ele não saia da faixa permitida.

Sua saída deve ser parecida com:

Inserindo 5 valores na lista

Informe o 1.o valor: 8
Informe o 2.o valor: 2
Informe o 3.o valor: 4
Informe o 4.o valor: 7
Informe o 5.o valor: 3

Valores na lista: 8 -> 2 -> 4 -> 7 -> 3 -> null

Inserindo um elemento no índice k

Informe o índice desejado: 2
Informe o valor do nó: 9

Valores na lista: 8 -> 2 -> 9 -> 4 -> 7 -> 3 -> null
Resposta/Solução:

Na saída podemos ver que o índice 2 corresponde ao terceiro elemento da lista ligada. Por isso o valor 4 foi empurrado para a frente para abrir espaço para o valor 9. Se o índice 0 fosse informado, o número 8 seria empurrado para a frente e o nó com valor 9 passaria a ser o início da lista ligada.

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

package estudos;
  
import java.util.Scanner;

// classe interna usada para representar um
// nó na lista ligada
class No {
  int valor; // valor do nó
  No proximo; // aponta para o novo nó
 
  // construtor cheio da classe No
  public No(int valor, No proximo) {
    this.valor = valor;
    this.proximo = proximo;
  }
  
  // construtor vazio da classe No
  public No() {
    this.valor = 0;
    this.proximo = null;
  }
}

public class Estudos { 
  public static void main(String args[]){
    // para ler a entrada do usuário
    Scanner entrada = new Scanner(System.in);
    
    // vamos criar uma referência para o início da lista
    No inicio = null;
    
    // vamos inserir 5 valores inteiros na lista ligada
    int valor;
    System.out.println("Inserindo 5 valores na lista\n");
    for (int i = 0; i < 5; i++) {
      System.out.print("Informe o " + (i + 1) + ".o valor: ");
      valor = Integer.parseInt(entrada.nextLine());
      // vamos inserir este valor no final da lista
      inicio = inserirFinal(inicio, valor);
    }
    
    // vamos exibir os valores na lista ligada
    System.out.print("\nValores na lista: ");
    exibirLista(inicio);
    
    // vamos inserir um novo elemento no índice informado
    System.out.println("\nInserindo um elemento no índice k\n");
    System.out.print("Informe o índice desejado: ");
    int indice = Integer.parseInt(entrada.nextLine());
    
    // o índice é válido?
    if ((indice < 0) || (indice > tamanhoLista(inicio) - 1)) {
      System.out.println("O índice é inválido.");
    }
    else {
      // vamos inserir o novo nó no índice indicado
      System.out.print("Informe o valor do nó: ");
      valor = Integer.parseInt(entrada.nextLine());
      inicio = inserirIndice(inicio, indice, valor);
      
      // vamos exibir os valores na lista ligada
      System.out.print("\nValores na lista: ");
      exibirLista(inicio);
    }
  }
  
  // função que permite adicionar um nó em uma determinada
  // posição da lista ligada
  public static No inserirIndice(No inicio, int indice, int valor) {
    // vamos apontar para o nó inicial
    No atual = inicio;
    // criamos um novo nó
    No novo = criarNo(valor);
    
    // a lista ligada ainda está vazia?
    if (atual == null){
      // inicio recebe o novo nó
      inicio = novo;
    }
    else if (indice == 0) {
      // o índice é igual a 0? vamos inserir
      // o nó no início da lista ligada
      novo.proximo = inicio;
      inicio = novo;
    }
    else {
      // vamos procurar o local adequado para inserção
      // primeiro criamos um nó temporário
      No temp = new No();
      // apontamos o nó temporário para o início da lista
      temp = inicio;
      // e percorremos os nós até encontrar a posição
      // de inserção
      for(int i = 1; i < indice; i++) {
        if (temp != null) {
          // passa para o próximo nó
          temp = temp.proximo;
        }
      }
   
      // concluimos a inserção
      novo.proximo = temp.proximo;
      temp.proximo = novo;
    }
    
    // e retornamos o início da lista
    return inicio;
  }

  // função que permite adicionar um nó no final da
  // lista ligada
  public static No inserirFinal(No inicio, int valor) {
    // vamos apontar para o nó inicial
    No atual = inicio;
    // criamos um novo nó
    No novo = criarNo(valor);
  
    // a lista ligada ainda está vazia?
    if (atual == null){
      // inicio recebe o novo nó
      inicio = novo;
    }    
    else { // temos um ou mais nós na lista ligada
      // vamos localizar o último nó
      while (atual.proximo != null) {
        atual = atual.proximo;
      }
       
      // encontramos o último nó. Agora vamos inserir
      // o novo nó depois dele
      atual.proximo = novo;
    }
     
    // e retornamos o início da lista
    return inicio;
  }
  
  // função usada para construir e retornar um novo nó
  public static No criarNo(int valor) {
    // cria o novo nó
    No no = new No(valor, null);
    // retorna o nó criado
    return no;
  }
  
  // função usada para percorrer a lista ligada e
  // exibir os valores contidos em seus nós
  public static void exibirLista(No inicio) {
    // vamos apontar para o início da lista
    No temp = inicio;
    
    // a lista está vazia?
    if (temp == null) {
      System.out.println("A lista está vazia.");
    }
    else {
      // esse laço se repete enquanto tempo for
      // diferente de null
      while (temp != null) {
        // vamos mostrar o valor desse nó
        System.out.print(temp.valor + " -> ");
        // avança para o próximo nó
        temp = temp.proximo;
      }
    
      // mostra o final da lista
      System.out.println("null");
    }
  }
  
  // função que retorna a quantidade de nós na lista ligada
  public static int tamanhoLista(No inicio) {
    int tamanho = 0;
    
    // vamos apontar para o início da lista
    No temp = inicio;
    
    // a lista está vazia?
    if (temp == null) {
      return 0;
    }
    else {
      // esse laço se repete enquanto tempo for
      // diferente de null
      while (temp != null) {
        // vamos incrementar o tamanho
        tamanho++;
        // avança para o próximo nó
        temp = temp.proximo;
      }
    }
    
    return tamanho;
  }
}



Java ::: Dicas & Truques ::: Arquivos e Diretórios

Como adicionar conteúdo a um arquivo texto existente em Java usando BufferedWriter e FileWriter

Quantidade de visualizações: 5 vezes
Nesta dica mostrarei como podemos usar as classes BufferedWriter e FileWriter da linguagem Java para adicionar mais conteúdo a um arquivo texto já existente. Veja que só precisamos fornecer o valor true para o segundo parâmetro do construtor da classe FileWriter.

Eis o código completo para o exemplo:

package estudos;

import java.io.*;

public class Estudos {

  public static void main(String[] args) {
    try {
      BufferedWriter out = new BufferedWriter(
        new FileWriter("C:\\estudos_java\\conteudo.txt", true));
      out.write("Esta é a primeira linha de texto\r\n");
      out.write("Esta é a segunda linha de texto");
      out.close();
    } 
    catch (IOException e) {
      System.out.println("Err: " + e.getMessage());
    }

    System.out.println("Acabei de adicionar conteúdo ao arquivo");

    System.exit(0);
  }
}

Execute este código Java algumas vezes e veja como o novo conteúdo é adicionado ao conteúdo já existente no arquivo texto.


PHP ::: Dicas & Truques ::: Strings e Caracteres

Como inverter o conteúdo de uma string usando a função strrev() do PHP

Quantidade de visualizações: 2 vezes
Em algumas situações nós precisamos inverter, ou seja, mostrar de forma contrária o conteúdo de uma palavra, frase ou texto. Para isso podemos usar a função strrev() da linguagem PHP. Ela recebe uma string e a devolve invertida.

Veja o código completo para o seu uso:

<html>
<head>
  <title>Estudos PHP</title>
</head>
 
<body>

<?php  
  $frase = "Gosto de PHP";
  echo $frase . "<br>";
  echo strrev($frase);
?>  

</body>
</html>

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

Gosto de PHP
PHP ed otsoG


C++ ::: C++ para Engenharia ::: Geometria Analítica e Álgebra Linear

Como calcular a norma ou módulo de vetores nos espaços R2 e R3 usando C++ - Geometria Analítica e Álgebra Linear usando C++

Quantidade de visualizações: 2662 vezes
Em Geometria Analítica e Álgebra Linear, a magnitude, norma, comprimento, tamanho ou módulo (também chamado de intensidade na Física) de um vetor é o seu comprimento, que pode ser calculado por meio da distância de seu ponto final a partir da origem, no nosso caso (0,0).

Considere o seguinte vetor no plano, ou seja, no espaço bidimensional, ou R2:

\[\vec{v} = \left(7, 6\right)\]

Aqui este vetor se inicia na origem (0, 0) e vai até as coordenadas (x = 7) e (y = 6). Veja sua plotagem no plano 2D:



Note que na imagem já temos todas as informações que precisamos, ou seja, o tamanho desse vetor é 9 (arredondado) e ele faz um ângulo de 41º (graus) com o eixo x positivo. Em linguagem mais adequada da trigonometria, podemos dizer que a medida do cateto oposto é 6, a medida do cateto adjacente é 7 e a medida da hipotenusa (que já calculei para você) é 9.

Note que já mostrei também o ângulo theta (__$\theta__$) entre a hipotenusa e o cateto adjacente, o que nos dá a inclinação da reta representada pelos pontos (0, 0) e (7, 6).

Relembrando nossas aulas de trigonometria nos tempos do colegial, temos que o quadrado da hipotenusa é a soma dos quadrados dos catetos, ou seja, o Teorema de Pitágoras:

\[a^2 = b^2 + c^2\]

Como sabemos que a potenciação é o inverso da radiciação, podemos escrever essa fórmula da seguinte maneira:

\[a = \sqrt{b^2 + c^2}\]

Passando para os valores x e y que já temos:

\[a = \sqrt{7^2 + 6^2}\]

Podemos comprovar que o resultado é 9,21 (que arredondei para 9). Não se esqueça da notação de módulo ao apresentar o resultado final:

\[\left|\vec{v}\right| = \sqrt{7^2 + 6^2}\]

E aqui está o código C++ que nos permite informar os valores x e y do vetor e obter o seu comprimento, tamanho ou módulo:

#include <string>
#include <iostream>
#include <math.h>
 
using namespace std;
  
int main(int argc, char *argv[]){
  float x, y, norma;
  // vamos ler os valores x e y
  cout << "Informe o valor de x: ";
  cin >> x;
  cout << "Informe o valor de y: ";
  cin >> y;
  
  // vamos calcular a norma do vetor
  norma = sqrt(pow(x, 2) + pow(y, 2));
    
  // mostra o resultado
  cout << "A norma do vetor é: " << norma; 
 
  cout << "\n\n";
  system("PAUSE");
  return 0;
}

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

Informe o valor de x: 7
Informe o valor de y: 6
A norma do vetor é: 9.219544457292887

Novamente note que arredondei o comprimento do vetor para melhor visualização no gráfico. Para calcular a norma de um vetor no espaço, ou seja, no R3, basta acrescentar o componente z no cálculo.


C# ::: Windows Forms ::: CheckBox

Como marcar ou desmarcar uma CheckBox do C# Windows Forms via código

Quantidade de visualizações: 15236 vezes
É possível marcar ou desmarcar uma CheckBox do C# Windows Forms via código. Para isso só precisamos manipular sua propriedade Checked. Se quisermos que a CheckBox seja marcada, basta fornecermos o valor true para esta propriedade. Veja:

private void button1_Click(object sender, EventArgs e){
  // vamos marcar a CheckBox
  checkBox1.Checked = true;
}

Se quisermos desmarcar, basta fornecermos o valor false. Veja:

private void button1_Click(object sender, EventArgs e){
  // vamos desmarcar a CheckBox
  checkBox1.Checked = false;
}



Desafios, Exercícios e Algoritmos Resolvidos de C#

Veja mais Dicas e truques de C#

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