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:

Python ::: NumPy Python Library (Biblioteca Python NumPy) ::: Arrays e Matrix (Vetores e Matrizes)

Como gerar vetores e matrizes com números inteiros aleatórios usando a função random.randint() da biblioteca NumPy para - Machine Learning com Python

Quantidade de visualizações: 1210 vezes
Veremos nessa dica como podemos usar o método random.randint() da biblioteca NumPy para gerar vetores e matrizes já preenchidos com números inteiros aleatórios.

Note que a criação de vetores e matrizes preenchidos com números randômicos é uma parte importante para o desenvolvimento de modelos de teste (test models) em Inteligência Artificial (IA), Machine Learning e outras áreas de estudo que envolvem Data Science.

Vamos começar com a forma mais simples do uso da função random.randint() para gerar um vetor de 10 elementos contendo números aleatórios de 0 até 10 (não incluído):

# importamos o módulo random da bibliteca NumPy
from numpy import random

def main():
  # vamos gerar um vetor de números inteiros aleatórios
  #  de 0 (incluído) à 10 (não incluído) 
  valores = random.randint(10, size=10)
  print("O vetor gerado foi: ", valores)  

if __name__== "__main__":
  main()


Ao executar este código teremos um resultado parecido com:

O vetor gerado foi: [0 3 2 3 8 9 3 9 6 4]

Aqui nós informamos o limite alto do valor aleatório a ser gerado (mas ele não é incluído). Se quisermos limitar a faixa inferior, podemos tirar proveito dos parâmetros low e high da função randint(). Veja:

# importamos o módulo random da bibliteca NumPy
from numpy import random

def main():
  # vamos gerar um vetor de números inteiros aleatórios
  #  de 50 (incluído) à 101 (não incluído) 
  valores = random.randint(50, 101, 10)
  print("O vetor gerado foi: ", valores)  

if __name__== "__main__":
  main()

Agora o resultado será parecido com:

O vetor gerado foi: [92 89 66 52 61 77 55 58 72 55]

Para gerarmos uma matriz, por exemplo, de 2 linhas e 4 colunas, só precisamos gerar o vetor de números aleatórios e em seguida usar o método reshape(), também da biblioteca NumPy para converter a matriz de uma dimensão (vetor) em uma matriz de duas dimensões. Veja:

from numpy import random

def main():
  # vamos gerar um vetor de números inteiros aleatórios
  #  de 1 (incluído) à 21 (não incluído) 
  valores = random.randint(1, 21, 8)
  
  # agora vamos converter o vetor para uma matriz
  # de 2 linhas e 4 colunas 
  valores = valores.reshape(2, 4)

  print("A matriz gerada foi: ", valores)  

if __name__== "__main__":
  main()

Quando executamos este código nós temos um resultado parecido com:

A matriz gerada foi:  [[17  5  2  9]
 [14 10 10 19]]

A partir da versão 1.19 da NumPy, os desenvolvedores da biblioteca recomendam o uso do método integers() do módulo default_rng().


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


Java ::: Coleções (Collections) ::: Stack

Como criar uma pilha em Java usando a classe Stack - Java Collections

Quantidade de visualizações: 13568 vezes
A classe Stack é usada quando precisamos de uma estrutura de dados LIFO (last-in-first-out). Neste tipo de estrutura temos uma pilha de objetos, na qual o último elemento inserido na pilha é sempre o primeiro a sair.

A classe Stack extende a classe Vector com a adição de cinco operações próprias da estrutura de dados pilha. As dicas nesta seção mostram a você como usar cada uma destas operações. Antes, veja a posição da classe Stack na hierarquia de classes Java:

java.lang.Object
  java.util.AbstractCollection<E>
    java.util.AbstractList<E>
      java.util.Vector<E>
        java.util.Stack<E> 


Esta classe implementa as interfaces: Serializable, Cloneable, Iterable<E>, Collection<E>, List<E> e RandomAccess. Veja um trecho de código que cria uma Stack de inteiros, insere três elementos e usa o método pop() para remover o elemento no topo da pilha:

import java.util.*;

public class Estudos{ 
  public static void main(String args[]){ 
    // Cria uma Stack
    Stack<Integer> pilha = new Stack<Integer>();
    
    // adiciona três elementos na pilha
    pilha.push(34);
    pilha.push(12);
    pilha.push(83);

    // remove o elemento no topo da pilha
    int topo = pilha.pop();

    System.out.println("Elemento removido do " +
     "topo da pilha: " + topo);
  } 
}

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

Elemento removido do topo da pilha: 83


Java ::: Dicas & Truques ::: Geometria, Trigonometria e Figuras Geométricas

Como testar se um ponto está dentro de um círculo em Java - Desenvolvimento de Games com Java

Quantidade de visualizações: 1072 vezes
Quando estamos trabalhando com computação gráfica, geometria e trigonometria ou desenvolvimento de jogos em Java, é comum precisarmos verificar se um determinado ponto (uma coordenada x, y) está contido dentro de um círculo.

Para melhor entendimento, veja a imagem a seguir:



Veja que temos um círculo com raio igual a 115 e com centro nas coordenadas (x = 205; y = 166). Temos também dois pontos. O ponto vermelho está nas coordenadas (x = 140; y = 90) e o ponto azul está nas coordenadas (x = 330; y = 500.

Como podemos ver na imagem, o ponto vermelho está dentro do círculo, enquanto o ponto azul está fora. E nosso intenção nesta dica é escrever o código Java que permite fazer essa verificação. Tenha em mente que está técnica é muito útil para o teste de colisões no desenvolvimento de games.

Veja o código completo para o exemplo:

package estudos;

// vamos declarar a classe Circulo
class Circulo{
  double xc;
  double yc;
  double raio;
  
  public Circulo(double xc, double yc, double raio){
    this.xc = xc; // x do centro
    this.yc = yc; // y do centro
    this.raio = raio; // raio do círculo
  }
}
  
// agora vamos declarar a classe Ponto
class Ponto{
  double x;
  double y;
  
  public Ponto(double x, double y){
    this.x = x; // coordenada x
    this.y = y; // coordenada y	
  }
}

// classe principal da aplicação
public class Estudos{
  public static void main(String[] args){
    // vamos criar um objeto Circulo
    Circulo c = new Circulo(205, 166, 115);
    // vamos criar um objeto Ponto
    Ponto p = new Ponto(140, 90);
  
    // vamos verificar se o ponto está dentro do
    // círculo
    double dx = p.x - c.xc;
    double dy = p.y - c.yc;
    if((Math.pow(dx, 2) + Math.pow(dy, 2)) < Math.pow(c.raio, 2)){
      System.out.println("O ponto está dentro do círculo");  
    }
    else{
      System.out.println("O ponto NÃO está dentro do círculo");  
    }
  }
}

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

O ponto está dentro do círculo.

Experimente com círculos de raios e coordenadas centrais diferentes e também com pontos em várias coordenadas e veja como os resultados são interessantes.


C ::: Desafios e Lista de Exercícios Resolvidos ::: Arrays e Matrix (Vetores e Matrizes)

Vetores e Matrizes - Exercícios Resolvidos de C - Declarar um vetor de 10 elementos, usar um laço for para inicializar os elementos e exibí-los na vertical

Quantidade de visualizações: 15559 vezes
Vetores e Matrizes - Exercício Resolvido de C - Declarar um vetor de 10 elementos, usar um laço for para inicializar os elementos e exibí-los na vertical

Pergunta/Tarefa:

Escreva um programa C que declara um vetor de 10 elementos do tipo int. Em seguida use um laço for para inicializar os elementos com os valores de 1 até 10. Para finalizar exiba os valores dos elementos da matriz na vertical. Seu programa deverá exibir a seguinte saída:

1
2
3
4
5
6
7
8
9
10

Resposta/Solução:

A resolução desta tarefa passa pela declaração da matriz. Veja como isso pode ser feito:

// vamos declarar uma matriz de 10 ints
// neste momento seus elementos terão, todos, 
// valores aleatórios
int valores[10];


Veja a resolução completa do exercício:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
  // vamos declarar uma matriz de 10 ints
  // neste momento seus elementos terão, todos, 
  // valores aleatórios
  int valores[10];
  int i;
  
  // vamos usar o laço for para inicializar seus elementos
  // com os valores de 1 até 10
  for(i = 0; i < 10; i++){
    // aqui nós usamos o valor da variável i para acessar o
    // elemento da matriz e também para atribuir o valor de i + 1
    // ao elemento sendo acessado
    valores[i] = (i + 1);
  }

  // só nos resta exibir os valores de todos os elementos
  for(i = 0; i < 10; i++){
    printf("%d\n", valores[i]);
  }
  
  system("PAUSE");	
  return 0;
}



Mais Desafios de Programação e 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 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


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