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 Concreto Armado
Card 1 de 40
Segurança e Estados Limites Ações nas Estruturas de Concreto Armado

As combinações últimas normais e as combinações últimas de construção ou especiais se diferem apenas pelo coeficiente ψ, que é ψ0 para as combinações normais últimas e pode ser ψ0 ou ψ2 para as combinações últimas de construção ou especiais, dependendo da duração da ação variável principal.

Nas combinações últimas excepcionais, a ação excepcional é considerada em seu valor característico, isto é, não majorada.

As ações variáveis são consideradas com seus valores quase permanentes pela multiplicação pelo fator de redução ψ2.

Nas combinações frequentes de serviço, existe uma ação variável principal considerada no seu valor frequente pela multiplicação pelo fator ψ1, e as demais consideradas em seus quase permanentes, pela multiplicação por ψ2.

Já, nas combinações raras de serviço, a variável principal se encontra em seu valor característico, ao passo que as demais ações variáveis são consideradas em seus valores frequentes, pela multiplicação por ψ1.

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:

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

Como retornar uma referência ao último elemento de um vector C++ usando a função back()

Quantidade de visualizações: 7563 vezes
O último elemento de um contêiner STL vector pode ser acessado por meio da função back(). Como esta função é sobrecarregada, temos duas opções:

reference back();
const_reference back() const;  
A primeira versão é do tipo T&, ou seja, retorna uma referência ao último elemento. Veja:

#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 obter o valor do último elemento do vector
  // Note que back() pode ser usada dos dois lados
  // de uma operação de atribuição
  int valor = valores.back();
  cout << "Último elemento: " << valor << endl;

  // vamos alterar o valor do último elemento
  valores.back() = 102;

  // vamos testar o resultado
  cout << "Último elemento: " << valores.back() << endl;

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

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

Último elemento: 87
Último elemento: 102

Note que aqui nós usamos:

int valor = valores.back();

para guardar o valor do último elemento na variável valor. Poderíamos também usar:

int& valor = valores.back();
valor = 102;

Agora valor é uma referência direta ao último elemento do vector. Desta forma, qualquer alteração no valor da variável valor afetará também o último elemento do vector.

Observe agora o seguinte trecho de código:

int valor = valores.back(); // o último elemento é 87
valores.back() = 20;
cout << "Último elemento: " << valor << endl;

Aqui nós acessamos o valor do último elemento, guardarmos-o na variável valor e atribuímos o valor 20 à valores.back(). Porém, ao imprimirmos a variável valor o seu conteúdo ainda é 87. De fato, o que gostaríamos é que uma alteração em valores.back() afetasse também a variável valor. Assim:

int& valor = valores.back(); // o último elemento é 87
valores.back() = 20;
cout << "Último elemento: " << valor << endl;

Mas, como evitar alterações diretas na variável valor? Podemos declarar valor como uma referência constante, ou seja, usar a segunda versão da função back(), a saber const T&, que retorna uma referência constante. Veja:

const int& valor = valores.back(); // o último elemento é 87
valores.back() = 20;
valor = 300; // esta linha não compila
cout << "Último elemento: " << valor << endl;

Agora o efeito que queríamos é alcançado. Alterações em valores.back() afetam a variável valor, mas, não podemos alterar valor diretamente, já que esta variável é uma referência constante agora.


C# ::: Windows Forms ::: TextBox

Como definir a cor do texto de uma caixa de texto TextBox do C# Windows Forms via código

Quantidade de visualizações: 13465 vezes
Nesta dica mostrarei como podemos usar a propriedade ForeColor da classe Control do C# Windows Forms para definir a cor do texto de um componente TextBox. Note que criei uma caixa de texto com o nome textBox1 e chamei o código que altera a cor do texto a partir do evento Click de um botão Button.

Veja o trecho de código a seguir:

private void button1_Click(object sender, EventArgs e) {
  // vamos definir o azul para a cor do texto
  textBox1.ForeColor = Color.Blue;
}



Java ::: Desafios e Lista de Exercícios Resolvidos ::: Recursão (Recursividade)

Exercícios Resolvidos de Java - Como contar de 10 até 0 usando recursividade em Java - Funções recursivas em Java

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

Escreva um método recursivo em Java que conta e exibe os valores de 10 até 0. Seu método deverá possuir a seguinte assinatura:

public static void contarRecursivamente(int n){
  // sua implementação aqui
}
Veja que o método deverá receber o valor 10 e efetuar novas chamadas a si mesmo até que os valores de 10 até 0 sejam exibidos. O ponto de parada da recursividade é a exibição do valor 0.

Sua saída deverá ser parecida com:

10 9 8 7 6 5 4 3 2 1 0
Resposta/Solução:

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

package exercicio;

public class Exercicio {
  public static void main(String[] args) {
    // efetua uma chamada ao método recursivo
    // fornecendo o primeiro valor
    contarRecursivamente(10);
  }
  
  // método recursivo que conta de 10 até 0;
  public static void contarRecursivamente(int n){
    // vamos exibir o número atual
    System.out.print(n + "  ");
    
    // devemos prosseguir com a recursividade?
    if(n > 0){
      // decrementa o valor de n
      n--;  
      // e faz uma nova chamada recursiva
      contarRecursivamente(n);
    }
  }
}



Java ::: Dicas & Truques ::: Matemática e Estatística

Como arredondar um número para cima em Java usando a função ceil() da classe Math

Quantidade de visualizações: 10717 vezes
Em várias situações nós precisamos arredondar um valor real para cima, ou seja, para o valor inteiro maior ou igual ao argumento fornecido. Para isso nós podemos usar a função ceil() da classe Math da linguagem Java.

Esta função recebe um valor double e retorna um outro valor inteiro (como double) maior ou igual ao argumento fornecido.

Veja um exemplo Java completo no qual pedimos para o usuário informar um valor com casas decimais e devolvemos o valor arredondado para cima:

package estudos;

import java.util.*;

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
    // real com casas decimais
    System.out.print("Informe um número com casas decimais: ");
    // vamos ler o número informado
    double a = Double.parseDouble(entrada.nextLine());
    
    // agora vamos arredondar o valor para cima
    double b = Math.ceil(a);
    
    // e mostramos o resultado
    System.out.println("O número arredondado para cima é: " + b);
  }
}

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

Informe um número com casas decimais: 6.31
O número arredondado para cima é: 7.0


Java ::: Desafios e Lista de Exercícios Resolvidos ::: Estruturas de Controle

Exercícios Resolvidos de Java - Um programa que lê duas notas, calcula a média aritmética e exibe uma mensagem de reprovado, exame ou aprovado

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

Escreva um programa Java que leia duas notas (como double), calcule e mostre a média aritmética e uma mensagem de acordo com as seguintes regras:

1) Se a média for inferior a 4,0 escreva "Reprovado";
2) Se a média for igual ou superior a 4,0 e inferior a 7,0 escreva "Exame";
3) Se a média for igual ou superior a 7,0 escreva "Aprovado".

Sua saída deverá ser parecida com:

Informe a primeira nota: 8
Informe a segunda nota: 7.4
A média obtida foi: 7.7
Aprovado
Resposta/Solução:

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

package estudos;

import java.util.Scanner;

public class Estudos {
  public static void main(String[] args) {
    Scanner entrada = new Scanner(System.in);  
    
    // vamos solicitar as duas notas do aluno
    double n1, n2, media;
    System.out.print("Informe a primeira nota: ");
    n1 = Double.parseDouble(entrada.nextLine());
    System.out.print("Informe a segunda nota: ");
    n2 = Double.parseDouble(entrada.nextLine());
    
    // vamos calcular a média aritmética
    media = (n1 + n2) / 2;
    System.out.println("A média obtida foi: " + media);
    
    // vamos verificar se o aluno foi reprovado, está de exame ou aprovado
    if(media < 4.0){ // reprovado
      System.out.println("Reprovado");
    }
    else if((media >= 4.0) && (media < 7.0)){ // exame
      System.out.println("Exame");
    }
    else{
      System.out.println("Aprovado");  
    }
    
    System.out.println("\n");
  }
}



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