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.

Java ::: Desafios e Lista de Exercícios Resolvidos ::: Laços de Repetição

Exercícios Resolvidos de Java - Escreva um programa (algorítmo) Java que usa o laço do...while para ler um número indeterminado de idades. A condição de parada do laço é o valor da idade igual a 0

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

Escreva um programa (algorítmo) Java que usa o laço do...while para ler um número indeterminado de idades de algumas pessoas. A condição de parada do laço é o valor da idade igual a 0. Calcule a escreva a idade média deste grupo de pessoas.

Sua saída deverá ser parecida com:

Informe a idade: 19
Informe a idade: 30
Informe a idade: 21
Informe a idade: 45
Informe a idade: 0
A idade média é: 28.75
Resposta/Solução:

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

package exercicios;

import java.util.Scanner;

public class Exercicios {
  public static void main(String[] args) {
    // vamos efetuar a leitura usando a classe Scanner
    Scanner entrada = new Scanner(System.in);
      
    int idade; // guarda a idade lida de cada indivíduo
    double idade_media; // a idade média calculada
    int soma = 0; // a soma das idades de cada indivíduo
    int contador = 0; // conta as idades lidas
    
    // laço do...while que repetirá até que o valor da idade seja 0
    do{
      System.out.print("Informe a idade: ");
      idade = Integer.parseInt(entrada.nextLine());
      
      // a idade lida é diferente de 0?
      if(idade != 0){
        soma = soma + idade; // soma mais esta idade
        contador++; // aumenta a quantidade de idades lidas
      }
    }while(idade != 0);
    
    // calcula a idade média
    // note que forcei contador para o tipo double antes da divisão
    // isso faz com que o resultado seja do tipo double
    idade_media = soma / (contador * 1.0);
    
    // finalmente mostramos o resultado
    System.out.println("A idade média é: " + idade_media);
  }
}



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

Como calcular o tempo de queda livre de um corpo dada a altura da queda e a aceleração da gravidade usando a linguagem C

Quantidade de visualizações: 3437 vezes
Galileu Galilei fez experimentos para comprovar que o tempo de queda dos objetos não depende de sua massa. Esse importante estudioso abandonava objetos de massas diferentes do alto da torre de Pisa e verificava que o tempo para atingirem o solo sempre era o mesmo para todos os casos.

No Movimento Uniformemente Variado (MUV), o tempo de queda livre de um corpo, quando temos a altura na qual o objeto é abandonado, pode ser calculado por meio da fórmula:

\[ \text{t} = \sqrt{\frac{\text{2} \cdot \text{H}}{\text{g}}} \]

Onde:

t ? tempo da queda (em segundos).

H ? altura em metros na qual o corpo é abandonado.

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

Vamos ver um exemplo? Veja o seguinte enunciado:

1) Um tijolo é largado de uma construção há 10 metros de altura. Calcule o tempo de sua queda, ou seja, o tempo imediatamente antes de o corpo (o tijolo) tocar o chão.

Veja que temos a altura de 10 metros e já sabemos que a aceleração da gravidade terrestre é 9.80665. Assim, tudo que temos que fazer é jogar esses valores na fórmula. Veja o código C completo para este cálculo:

#include <stdio.h>
#include <stdlib.h>
#include <math.h> 
     
int main(int argc, char *argv[]){
  // gravidade terrestre em m/s2
  float gravidade = 9.80665;
  // altura da queda
  float altura = 10; // em metros
  
  // vamos calcular o tempo da queda (em segundos)
  float tempo_queda = sqrt((2 * altura) / gravidade);
  
  // mostramos o resultado
  printf("O tempo da queda livre é: %f segundos",
    tempo_queda);
			  
  printf("\n\n");
  system("PAUSE");
  return 0;
}

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

O tempo da queda livre é: 1.428087 segundos.


C++ ::: STL (Standard Template Library) ::: Vector C++

Como usar a classe/contêiner vector da STL em seus programas C++

Quantidade de visualizações: 9532 vezes
O vetor, ou vector, é uma das classes contêineres mais simples da STL - Standard Template Library do C++. Um vector se comporta como um vetor, ou seja, uma matriz de uma linha e várias colunas, ou seja, seus elementos estão dispostos em posições contiguas na memória. O que diferencia um vector de um array comum é que o tamanho de um vector pode ser modificado dinamicamente.

A especificação do template da classe vector é:

template <class T, class Allocator = allocator<T>> class vector


Aqui T é o tipo de dados sendo armazenado (já ouvir falar em genéricos, não?) e Allocator define o modelo de alocação de armazenagem. Por padrão, o template da classe allocator para o tipo T é usado, o que define o modelo de alocação de memória mais simples e independente de valores.

Objetos da classe vector são úteis nas seguintes situações:

a) Acessar os elementos individualmente usando seus índices (tempo constante);
b) Percorrer os elementos em qualquer ordem (tempo linear);
b) Adicionar ou remover elementos no final do contêiner (tempo constante amortizado).

Para usarmos um vector em nossos programas C++ temos que incluir este contêiner da seguinte forma:

#include <vector>


Veja um trecho de código no qual criamos um vector, inserimos três inteiros e finalmente usamos um iterador para percorrer os elementos e imprimir seus valores:

#include <cstdlib>
#include <iostream>
#include <vector>

using namespace std;

int main(int argc, char *argv[]){
  // um vector vazio que conterá inteiros
  vector<int> valores;

  // vamos inserir três elementos
  valores.push_back(54);
  valores.push_back(13);
  valores.push_back(87);

  // vamos percorrer o vector e exibir os elementos
  vector<int>::iterator it;
  for(it = valores.begin(); it < valores.end(); it++){
    cout << *it << endl;
  }

  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}

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

54
13
87


Python ::: Python para Engenharia ::: Engenharia Civil - Cálculo Estrutural

Como calcular a Posição da Linha Neutra em vigas de concreto armado usando Python - Python para Engenharia Civil - Cálculo Estrutural

Quantidade de visualizações: 770 vezes
O concreto possui excelente resistência à compressão, porém, sua resistência à tração é muito pequena, chegando em torno de 10% da sua resistência à compressão. O aço, por sua vez, apresenta alta resistência à tração.

Por esta razão a combinação destes dois materiais resulta no que conhecemos por concreto armado, no qual o concreto, no caso das vigas, resiste às solicitações de compressão (em geral na parte superior da viga) e o aço se encarrega da tração (na parte inferior da viga).

Entre as forças de compressão e tração da viga de concreto armado existe uma região na qual as tensões são nulas, ou seja, não há nem tração nem compressão. Essa região é conhecida como linha neutra da viga e é usada, entre outras coisas, para verificarmos se a viga se encontra nas condições mínimas de dutibilidade exigidas pela ABNT NBR 6118/2014.

Outra característica muito importante da linha neutra é que ela nos permite indicar em qual domínio de deformação as nossas vigas de concreto armado estão trabalhando.

A posição da linha neutra em vigas de concreto armado pode ser calculada por meio da seguinte fórmula:

\[x = 1,25 \cdot d \cdot \left(1 - \sqrt{1 - \frac{M_d}{0,425 \cdot b_w \cdot d^2 \cdot f_\text{cd}}}\right)\]

Onde:

x é a posição da linha neutra a partir da fibra mais comprimida da viga, em metros (que depois convertemos para cm);

d é a altura útil da viga em metros;

Md é o momento solicitante de cálculo na viga, em kN.m;

bw é a largura da viga, em metros;

fcd é a resistência de cálculo do concreto, em kN/m2;

Veja agora o código Python completo que pede para o usuário informar a altura e largura da viga em centímetros, o momento solicitante na viga em kN.m e o FCK do concreto em Mpa, mostra a posição da linha neutra da viga e informa se ela obedece ao valor máximo imposto pela ABNT NBR 6118/2014 e também o domínio de deformação que ela está atuando:

# precisamos importar o módulo Math
import math

# função principal do programa Python
def main():
  # vamos pedir para o usuário informar a altura da viga
  altura = float(input("Informe a altura H da viga em cm: "))
  # vamos converter de centímetros para metros
  altura = altura / 100.00

  # vamos pedir para o usuário informar a largura da viga
  largura = float(input("Informe a largura bw da viga em cm: "))
  # vamos converter de centímetros para metros
  largura = largura / 100.00

  # vamos calcular a altura útil da viga
  # aqui eu usei 0.9 mas alguns engenheiros usam 0.95
  altura_util = 0.9 * altura

  # vamos pedir para o usuário informar o momento
  # máximo solicitante Mk (calculado no Ftool ou outra ferramenta)
  Mk = float(input("Informe o momento solicitante Mk em kN.m: "))
  # vamos definir o valor do gama f
  yf = 1.4
  # calculamos o md, ou seja, o momento solicitante de cálculo
  Md = Mk * yf

  # vamos pedir para o usuário informar o FCK do concreto
  fck = float(input("Informe o FCK do concreto em Mpa: "))
  # vamos definir o valor do gama c
  yc = 1.4
  # calculamos o fcd, ou seja, a resistência de cálculo do concreto
  fcd = fck / yc

  # finalmente vamos calcular a posição da linha neutra
  # note que converti o fcd de Mpa para kN/m2
  x = 1.25 * altura_util * (1 - math.sqrt(1 - (Md / (0.425 *
    largura * math.pow(altura_util, 2) * (fcd * 1000.0)))))
  
  # vamos mostrar os resultados 
  print("\nA altura útil da viga é: {0} cm ({1} m)".format(
    round(altura_util * 100, 5), round(altura_util, 5)))
  print("O momento solicitante de cálculo é: {0} kN.m".format(
    round(Md, 5)))
  print("O fcd do concreto é: {0} Mpa".format(round(fcd, 5)))
  print("A posição da linha neutra é: {0} cm".format(round(x * 100.0, 5)))
  
  # vamos verificar se a posição da linha neutra está dentro do
  # limite máximo imposto pela ABNT NBR 6118/2014 para FCK até 50 Mpa
  if ((x / altura_util) <= 0.45):
    print("Garante condições mínimas de dutibilidade? SIM")
  else:
    print("Garante condições mínimas de dutibilidade? NÃO")

  # vamos verificar o domínio de deformação da vaga
  temp = x / altura_util
  if (temp <= 0.167):
    print("A viga está trabalhando no domínio 1")
  elif ((temp > 0.167) and (temp <= 0.259)):
    print("A viga está trabalhando no domínio 2")
  elif ((temp > 0.259) and (temp <= 0.628)):
    print("A viga está trabalhando no domínio 3")
  else:
    print("A viga está trabalhando no domínio 4/5")

if __name__ == "__main__":
  main()

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

Informe a altura H da viga em cm: 35
Informe a largura bw da viga em cm: 19
Informe o momento solicitante Mk em kN.m: 32.3
Informe o FCK do concreto em Mpa: 25

A altura útil da viga é: 31.5 cm (0.315 m)
O momento solicitante de cálculo é: 45.22 kN.m
O fcd do concreto é: 17.85714 Mpa
A posição da linha neutra é: 6.81136 cm
Garante condições mínimas de dutibilidade? SIM
A viga está trabalhando no domínio 2


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