![]() |
|
|
Planilha de Dimensionamento de Tubulações
Hidráulicas Água Fria e Água Quente CompletaNossa 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 AutoCAD Civil 3D |
||
|
||
|
|
||
Java ::: Estruturas de Dados ::: Pilhas |
Como criar uma pilha em Java usando um vetor (array) - Estruturas de Dados em JavaQuantidade de visualizações: 2992 vezes |
A Pilha é uma estrutura de dados do tipo LIFO - Last-In, First-Out (Último a entrar, primeiro a sair). Neste tipo de estrutura, o último elemento a ser inserido é o primeiro a ser removido. Veja a imagem a seguir:![]() Embora seja mais comum a criação de uma estrutura de dados do tipo Pilha de forma dinâmica (usando ponteiros e referências), nesta dica eu mostrarei como podemos criá-la em Java usando um array, ou seja, um vetor. No exemplo eu usei inteiros, mas você pode modificar para o tipo de dados que você achar mais adequado. Veja o código completo para uma classe Pilha usando um vetor de ints. Veja que o tamanho do vetor é informado no construtor da classe. Note também a lógica empregada na construção dos métodos empilhar(), desempilhar() e imprimirPilha(): Código para Pilha.java:
package estudos;
public class Pilha {
private int elementos[]; // elementos na pilha
private int topo; // o elemento no topo da pilha
private int maximo; // a quantidade máxima de elementos na pilha
// construtor da classe Pilha
public Pilha(int tamanho) {
// constrói o vetor
this.elementos = new int[tamanho];
// define o topo como -1
this.topo = -1;
// ajusta o tamanho da pilha para o valor recebido
this.maximo = tamanho;
}
// método usado para empilhar um novo elemento na pilha
public void empilhar(int item) {
// a pilha já está cheia?
if (this.topo == (this.maximo - 1)) {
System.out.println("\nA pilha está cheia\n");
}
else {
// vamos inserir este elemento no topo da pilha
this.elementos[++this.topo] = item;
}
}
// méodo usado para desempilhar um elemento da pilha
public int desempilhar() {
// a pilha está vazia
if (this.topo == -1) {
System.out.println("\nA pilha está vazia\n");
return -1;
}
else {
System.out.println("Elemento desempilhado: " + elementos[topo]);
return this.elementos[this.topo--];
}
}
// método que permite imprimir o conteúdo da pilha
public void imprimirPilha() {
// pilha vazia
if (this.topo == -1) {
System.out.println("\nA pilha está vazia\n");
}
else {
// vamos percorrer todos os elementos da pilha
for (int i = 0; i <= this.topo; i++) {
System.out.println("Item[" + (i + 1) + "]: " + this.elementos[i]);
}
}
}
}
Veja agora o código para a classe principal, ou seja, a classe Main usada para testar a funcionalidade da nossa pilha: Código para Principal.java:
package estudos;
public class Estudos{
public static void main(String[] args){
// vamos criar uma nova pilha com capacidade para 5 elementos
Pilha p = new Pilha(5);
// vamos empilhar 3 elementos
p.empilhar(34);
p.empilhar(52);
p.empilhar(18);
// vamos mostrar os elementos na pilha
System.out.println("Itens presentes na Pilha\n");
p.imprimirPilha();
// agora vamos remover e retornar dois elementos da pilha
System.out.println();
p.desempilhar();
p.desempilhar();
// vamos mostrar os elementos na pilha novamente
System.out.println("\nItens presentes na Pilha\n");
p.imprimirPilha();
}
}
Ao executar este código Java nós teremos o seguinte resultado: Itens presentes na Pilha Item[1]: 34 Item[2]: 52 Item[3]: 18 Elemento desempilhado: 18 Elemento desempilhado: 52 Itens presentes na Pilha Item[1]: 34 |
Fórmulas da Física ::: Mecânica ::: Fórmulas de Cinemática |
Fórmula da Velocidade - Como calcular a velocidade quando temos a distância percorrida e o tempo gastoQuantidade de visualizações: 1805 vezes |
|
Nesta dica mostrarei a fórmula básica para o cálculo da velocidade dados a distância e o tempo. Esta situação é comum quando, em uma conversa, alguém diz que percorreu uma determinada distância em um determinado tempo e quer saber a velocidade com a qual este percurso foi feito. Note que não estamos falando de velocidade média, que possui uma fórmula bem semelhante, mas adiciona alguns detalhes. Assim, a fórmula simples para o cálculo da velocidade dados a distância e o tempo é: \[v = \frac{d}{t} \] Onde: v é a velocidade em metros por segundo (m/s); d é a distância percorrida em metros (m); t é o tempo em segundos (s); Embora metros e segundos sejam as medidas mais adequadas para a resolução deste tipo de problema (por serem as unidades padrões do SI - Sistema Internacional de Medidas), você pode usar quilômetros em vez de metros, desde que o tempo seja medido em horas, com a velocidade em Km/h (quilômetros por hora). Vamos ver um exemplo? 1) Joana saiu de Goiânia com destino a uma fazenda de amigos, localizada a 180km de distância. Para este percurso ela gastou 3h. Qual foi a velocidade empregada do percurso? Resolução: Vamos começar anotando que a distância está em quilômetros e o tempo em horas. Como as informações são compatíveis, não há a necessidade de se converter para metros e segundos. Dessa forma, só precisamos jogar os valores na fórmula. Veja: \[v = \frac{d}{t} \] \[v = \frac{180}{3} \] \[v = 60 \] Ou seja, a velocidade (que pode ser vista como velocidade média neste problema) é de 60km/h. |
Java ::: Coleções (Collections) ::: Stack |
Como criar uma pilha em Java usando a classe Stack - Java CollectionsQuantidade de visualizações: 13767 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 |
R ::: Dicas de Estudo e Anotações ::: Variáveis e Constantes |
Regras para a escolha de nomes de variáveis na linguagem RQuantidade de visualizações: 2098 vezes |
|
A linguagem R, assim como quase todas as linguagens de programação, impõe algumas regras sobre os nomes que podemos escolher para nossos identificadores (variáveis, funções, nomes de classes, etc). Em R, nomes de variáveis devem seguir as seguintes regras: 1) Variáveis podem ter nomes curtos, tais como x, y, z, ou nomes mais descritivos, tais idade, valor_boleto, velocidade_total, etc. 2) Nomes de variáveis em R devem sempre começar com uma letra (ou o ponto) e pode ser uma combinação de letras, números, ponto (.) e underline (_). Se o nome da variável começar com um ponto (.), ele não poderá ser seguido por um número. 3) O nome de uma variável não pode começar com um número ou o caractere de underline (_). 4) Nomes de variáveis em R são case-sensitive, ou seja, há diferenciação de maiúsculas e minúsculas. Dessa forma, nome, Nome e NOME são três variáveis diferentes. 5) As palavras reservadas da linguagem (if, NULL, TRUE, FALSE, etc) não podem ser usados como nomes de variáveis, funções, nomes de classes e objetos. Veja a seguir exemplos de declaração e uso de variáveis em R: > x <- 10 [ENTER] > nome <- "Osmar" [ENTER] > pago <- TRUE [ENTER] > y <- x + 15 [ENTER] > x [ENTER] [1] 10 > nome [ENTER] [1] "Osmar" > y [ENTER] [1] 25 > pago [ENTER] [1] TRUE > |
Ruby ::: Dicas & Truques ::: Strings e Caracteres |
Como acessar os caracteres individuais de uma string em Ruby usando o método slice() da classe StringQuantidade de visualizações: 7791 vezes |
|
O método slice() da classe String da linguagem Ruby se torna realmente útil quando precisamos acessar os caracteres individuais de uma string. Neste caso, só precisamos fornecer o índice do caractere a ser acessado e o número 1. O retorno do método é uma nova string ou nulo. Veja o exemplo a seguir: nome = "Arquivo de Códigos" # vamos acessar os caracteres individualmente usando # o método slice for i in (0..nome.length - 1) letra = nome.slice(i, 1) print letra + " " end Ao executar este código Ruby nós teremos o seguinte resultado: A r q u i v o d e C ó d i g o s |
Desafios, Exercícios e Algoritmos Resolvidos de Ruby |
Veja mais Dicas e truques de Ruby |
Dicas e truques de outras linguagens |
E-Books em PDF |
||||
|
||||
|
||||
Linguagens Mais Populares |
||||
|
1º lugar: Java |





