![]() |
|
|
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 ::: Desafios e Lista de Exercícios Resolvidos ::: Estruturas de Dados - Listas Ligadas |
Exercícios Resolvidos de Java - Como inserir no final de uma lista ligada em Java - Escreva um programa Java que pede para o usuário informar váriosQuantidade de visualizações: 1181 vezes |
|
Pergunta/Tarefa: Este exercício Java demonstra como inserir um nó no final de uma lista ligada. Escreva um programa Java que cria uma lista ligada, ou seja, uma lista dinamicamente encadeada, e pede para o usuário informar vários valores inteiros, colocando os valores sempre no final da lista. Seu código deverá interromper a leitura dos valores quando o usuário informar o valor -1. Quando isso acontecer, mostre todos os valores contidos na lista ligada, na mesma ordem que foram inseridos (o último valor lido será o último da lista). Sua saída deve ser parecida com: Inserindo valores no final da lista Informe o valor (-1 para sair): 3 Informe o valor (-1 para sair): 9 Informe o valor (-1 para sair): 1 Informe o valor (-1 para sair): 5 Informe o valor (-1 para sair): 2 Informe o valor (-1 para sair): -1 Valores na lista: 3 -> 9 -> 1 -> 5 -> 2 -> null 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 da classe No
No(int valor, No proximo) {
this.valor = valor;
this.proximo = proximo;
}
}
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;
// agora vamos pedir para o usuário informar
// valores inteiros. O valor -1 sai do laço
int valor;
System.out.println("Inserindo valores no final da lista\n");
do {
System.out.print("Informe o valor (-1 para sair): ");
valor = Integer.parseInt(entrada.nextLine());
if (valor != -1) {
inicio = inserirFinal(inicio, valor);
}
} while(valor != -1);
// vamos exibir os valores na lista ligada
System.out.print("\nValores na lista: ");
exibirLista(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");
}
}
}
|
Delphi ::: Dicas & Truques ::: Arquivos e Diretórios |
Como escrever em um arquivo texto usando as funções Write() e WriteLn() do DelphiQuantidade de visualizações: 29129 vezes |
|
Não há como fugir. Cedo ou tarde precisaremos escrever em um arquivo texto usando Delphi. E esta dica foi escrita com o propósito de facilitar esta tarefa. O primeiro passo para se escrever em um arquivo texto usando Delphi é declarar uma variável do tipo TextFile. Em seguida usamos a procedure AssignFile() para associar a variável TextFile ao arquivo em disco. Como queremos escrever conteúdo novo no arquivo, a função Rewrite() pode ser usada. Esta função cria o arquivo em disco se este ainda não existir. Se o mesmo existir, ele é excluído e a função cria outro com o mesmo nome. E, para escrever conteúdo no arquivo texto, usamos as funções Write() e WriteLn(). A primeira escreve no arquivo enquanto a segunda escreve no arquivo e adiciona o marcador de quebra de linha. Veja o exemplo para um melhor entendimento:
procedure TForm1.Button1Click(Sender: TObject);
var
arquivo: TextFile;
begin
// vamos fazer uma ligação entre a variável arquivo e o
// arquivo que queremos manipular
AssignFile(arquivo, 'C:\arquivo de codigos\dados.txt');
// vamos abrir o arquivo ou criar um novo
Rewrite(arquivo);
// vamos escrever no arquivo agora
WriteLn(arquivo, 'Sou a primeira linha.');
Write(arquivo, 'Sou a segunda linha.');
WriteLn(arquivo, ' E lá vem...');
WriteLn(arquivo, 'A terceira linha');
// hora de fechar o arquivo
CloseFile(arquivo);
// fim
ShowMessage('Operação realizada com sucesso.');
end;
Para fins de compatibilidade, esta dica foi escrita usando Delphi 2009. |
PHP ::: Fundamentos da Linguagem ::: Comentários |
Aprenda a programar em PHP - Como inserir comentários em seus códigos PHPQuantidade de visualizações: 16568 vezes |
|
Comentários em nossos códigos são sempre uma boa idéia. Primeiro porque, no momento que estávamos escrevendo, a lógica está fresca em nossa cabeça. Porém, alguns dias depois podemos não entender muito bem a estratégia usada na resolução de um determinado problema. A outra razão para o uso de comentários é facilitar o trabalho da pessoa que dará manutenção em nossos códigos, ou talvez permitir um melhor entendimento por parte do cliente que nos contratou para desenvolver uma determinada rotina. Comentários em PHP podem ser usados de três formas diferentes. Para comentários de múltiplas linhas, devemos usar a sintáxe da linguagem C/C++: <? /* Este é um exemplo de comentário de múltiplas linhas. Você pode usar quantas linhas quiser neste tipo de comentário. Este tipo de comentário é o mesmo usado na linguagem C/C++. */ $valor = 15; echo "O valor informado é: " . $valor; ?> Podemos usar comentários de uma linha apenas, usando a sintáxe da linguagem C++: <? $valor = 30; // Define o valor da variável echo "O valor informado é: " . $valor; // exibe resultado ?> A terceira forma de comentário usa o modelo de Shell: <? $valor = 120; # Define o valor da variável echo "O valor informado é: " . $valor; # exibe resultado ?> |
CSS ::: Dicas & Truques ::: Cores de Fundo e Imagens de Fundo |
Como definir uma imagem de fundo que se repete apenas verticalmente usando a propriedade background-repeat do CSSQuantidade de visualizações: 7889 vezes |
|
Nesta dica mostrarei como podemos definir uma imagem de fundo para a página HTML e ajustá-la para repetir apenas verticalmente usando a propriedade background-repeat com o valor repeat-y. Note que, para definir a imagem de fundo, nós usamos a propriedade background-image. Veja o código CSS para o exemplo:
<style type="text/css">
<!--
body {background-image: url('fundo.gif');
background-repeat: repeat-y}
//-->
</style>
|
Python ::: Python para Engenharia ::: Cálculo Diferencial e Integral |
Como calcular o limite de uma função usando Python e a biblioteca Sympy - Python para EngenhariaQuantidade de visualizações: 4814 vezes |
|
Como calcular o limite de uma função usando Python e a biblioteca Sympy Citando a Wikipédia: Na matemática, o limite de uma função é um conceito fundamental em cálculo e análise sobre o comportamento desta função quando próxima a um valor particular de sua variável independente. Informalmente, diz-se que __$\text{L}__$ é o limite da função __$\text{f(x)}__$ quando __$\text{x}__$ tende a __$\text{p}__$, escreve-se \[ \lim_{x \to p} f(x) = L \] quando __$\text{f(x)}__$ está arbitrariamente próximo de __$\text{L}__$ para todo __$\text{x}__$ suficientemente próximo de __$\text{p}__$. O conceito de limite pode ser estendido para funções de varias variáveis. A biblioteca SymPy da linguagem Python facilita muito o trabalho de se calcular limites. É claro que é sempre uma boa idéia saber calcular o limite de uma função "na mão" mesmo, até para sabermos se nosso código Python está correto. No entanto, em algumas situações, lançar mão da função limit() da SymPy nos poupará um tempo incrível. Dessa forma, a sintáxe para o cálculo do limite na SymPy segue o padrão limit(função, variável, ponto). Então, se quisermos calcular o limite de f(x) com x tendendo a 0, só precisamos fazer limit(f, x, 0). Vamos colocar esse conhecimento em prática então? Veja o seguinte limite: \[ \lim_{x \to 1} 5x^2 + 2x \] Agora observe o código Python completo que calcula e retorna o limite desta função:
# vamos importar a biblioteca SymPy
from sympy import *
def main():
# vamos definir o símbolo x
x = symbols("x")
# definimos a função
f = (5 * x ** 2) + (2 * x)
# finalmente calculamos o limite
limite = limit(f, x, 1)
# e mostramos o resultado
print("O limite da função é: %f." % limite)
if __name__== "__main__":
main()
Ao executar este código nós teremos o seguinte resultado: O limite da função é: 7.000000. Logo, o limite da função no ponto __$\text{x}__$ = 1 vale 7, em outras palavras, 7 é o valor que __$f(5x^2 + 2x)__$ deveria ter em 1 para ser contínua nesse ponto. Vamos ver mais um exemplo? Observe o seguinte limite: \[ \lim_{x \to 1} \left(\frac{x^2 - 1}{x - 1}\right) \] Aqui temos um situação interessante. Note que temos que fazer uma manipulação algébrica na expressão, fatorando os termos. Porém, mesmo em situações assim o método limit() da Sympy consegue interpretar a expressão simbólica corretamente e nos devolver o limite esperado. Veja o código Python completo:
# vamos importar a biblioteca SymPy
from sympy import *
def main():
# vamos definir o símbolo x
x = symbols("x")
# definimos a função
f = (x ** 2 - 1) / (x - 1)
# finalmente calculamos o limite
limite = limit(f, x, 1)
# e mostramos o resultado
print("O limite da função é: %f." % limite)
if __name__== "__main__":
main()
Ao executar este código Python nós teremos o seguinte resultado: O limite da função é: 2.000000. |
Desafios, Exercícios e Algoritmos Resolvidos de Python |
Veja mais Dicas e truques de Python |
Dicas e truques de outras linguagens |
E-Books em PDF |
||||
|
||||
|
||||
Linguagens Mais Populares |
||||
|
1º lugar: Java |




