![]() |
|
|
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 Python |
||
|
||
|
|
||
Java ::: Coleções (Collections) ::: ArrayList |
Como rotacionar os elementos de uma ArrayList do Java para frente ou para trás usando o método rotate()Quantidade de visualizações: 11934 vezes |
Nesta dica mostrarei como podemos usar o método rotate() da classe Collections da linguagem Java para rotacionar os elementos de uma ArrayList. Veja sua assinatura:void rotate(List<?> list, int distance) Este método faz com que um elemento na posição i seja movido para a posição (distance + i) % list.size(). Se você quiser inverter a ordem da rotação, forneça um valor negativo para o argumento distance. Veja o código completo para o exemplo:
package estudos;
import java.util.ArrayList;
import java.util.Collections;
public class Estudos{
public static void main(String[] args){
// cria uma ArrayList que conterá strings
ArrayList<String> nomes = new ArrayList<String>();
// adiciona itens na lista
nomes.add("Carlos");
nomes.add("Maria");
nomes.add("Fernanda");
nomes.add("Osmar");
// exibe os elementos da ArrayList
System.out.println("Antes da rotação:\n");
for(int i = 0; i < nomes.size(); i++)
System.out.println(nomes.get(i));
// Vamos rotacionar os elementos uma posição
Collections.rotate(nomes, 1);
// exibe os elementos da ArrayList
System.out.println("\nDepois da rotação:\n");
for(int i = 0; i < nomes.size(); i++)
System.out.println(nomes.get(i));
System.exit(0);
}
}
Ao executar este código Java nós teremos o seguinte resultado: Antes da rotação: Carlos Maria Fernanda Osmar Depois da rotação: Osmar Carlos Maria Fernanda |
Java ::: Desafios e Lista de Exercícios Resolvidos ::: Java Básico |
Exercícios Resolvidos de Java - Como calcular salário líquido em Java - Calculando o salário líquido de um professorQuantidade de visualizações: 11267 vezes |
|
Pergunta/Tarefa: Escreva um programa Java que calcule o salário líquido de um professor. Seu programa deverá solicitar que o usuário informe o valor da hora aula (como double), o número de horas trabalhadas no mês (como inteiro) e o percentual de desconto do INSS (como double). Em seguida mostre o salário líquido, formatado de acordo com a moeda brasileira em vigor (na resolução eu usei o Real). Sua saída deverá ser parecida com: Informe o valor da hora aula: 28 Informe o número de horas trabalhadas no mês: 12 Informe o percentual de desconto do INSS: 8 Salário Bruto: R$ 336,00 Total de Descontos: R$ 26,88 Salário Líquido: R$ 309,12 Veja a resolução comentada deste exercício usando Java console:
package estudos;
import java.text.NumberFormat;
import java.util.Scanner;
public class Estudos{
public static void main(String[] args) {
// vamos fazer a leitura usando a classe Scanner
Scanner entrada = new Scanner(System.in);
// vamos ler o valor do hora aula
System.out.print("Informe o valor da hora aula: ");
double valorHoraAula = Double.parseDouble(entrada.nextLine());
// vamos ler o número de horas trabalhadas no mês
System.out.print("Informe o número de horas trabalhadas no mês: ");
int horasTrabalhadas = Integer.parseInt(entrada.nextLine());
// vamos ler o percentual de desconto do INSS
System.out.print("Informe o percentual de desconto do INSS: ");
double percentualDescontoINSS = Double.parseDouble(entrada.nextLine());
// vamos calcular o salário bruto
double salarioBruto = valorHoraAula * horasTrabalhadas;
// agora calculamos o total do desconto
double totalDesconto = (percentualDescontoINSS / 100) * salarioBruto;
// finalmente calculamos o salário líquido
double salarioLiquido = salarioBruto - totalDesconto;
// mostramos o resultado
NumberFormat formato = NumberFormat.getCurrencyInstance();
System.out.println("Salário Bruto: " + formato.format(salarioBruto));
System.out.println("Total de Descontos: " + formato.format(totalDesconto));
System.out.println("Salário Líquido: " + formato.format(salarioLiquido));
}
}
|
Ruby ::: Dicas & Truques ::: Arrays e Matrix (Vetores e Matrizes) |
Como remover elementos repetidos de um array em Ruby usando as funções uniq e uniq!Quantidade de visualizações: 10994 vezes |
|
Em algumas situações nós precisamos excluir os itens duplicados de um array em Ruby. Para isso nós podemos usar as funções uniq e uniq!. A função uniq remove os itens duplicados e retorna um novo array, enquanto uniq! opera no array original, ou seja, modificando seus valores. Veja o código Ruby completo para o exemplo: # Cria um array de inteiros com duplicações valores = [2, 3, 3, 5, 5, 6, 3] # Exibe os valores do array original puts "Os valores do array são:\n" valores.each do | valor | print valor.to_s + " " end # Obtém um novo array sem as duplicações valores2 = valores.uniq puts "\n\nO novo array sem repetições:\n" valores2.each do | valor | print valor.to_s + " " end # Remove as duplicações do array original valores.uniq! puts "\n\nO array original sem repetições:\n" valores.each do | valor | print valor.to_s + " " end Ao executar este código Ruby nós teremos o seguinte resultado: Os valores do array são: 2 3 3 5 5 6 3 O novo array sem repetições: 2 3 5 6 O array original sem repetições: 2 3 5 6 |
C ::: C para Engenharia ::: Física - Mecânica |
Como calcular a massa de um corpo dada sua energia cinética e sua velocidade usando a linguagem CQuantidade de visualizações: 2989 vezes |
|
Na Física, a energia cinética em um objeto é a energia que ele possui devido ao seu movimento. Isso é definido como o trabalho necessário para acelerar um corpo de massa em repouso para que este adquira velocidade. Tendo ganho essa energia durante a aceleração, o corpo mantém essa energia cinética a menos que a sua velocidade mude. A mesma quantidade de trabalho é produzida por um corpo desacelerando da sua velocidade atual para um estado de repouso. Os carros de uma montanha-russa atingem sua energia cinética máxima quando estão no fundo de sua trajetória. Quando eles começam a subir, a energia cinética começa a ser convertida em energia potencial gravitacional, mas, se forem assumidos atritos insignificantes e outros fatores de atraso, a quantidade total de energia no sistema permanece constante. A fórmula para obtenção da massa de um corpo, quando temos a sua energia cinética e a sua velocidade é: \[ \text{m} = \frac{\text{2} \cdot E_c}{v^2} \] Onde: m ? massa do corpo (em kg). Ec ? energia cinética (em joule, J). v ? velocidade do corpo (em m/s). Vamos ver um exemplo agora? Observe o seguinte enunciado: 1) Uma bola de golfe está viajando a uma velocidade de 50m/s, e possui energia cinética de 75J. Qual é a sua massa? Note que o exercício nos dá a velocidade já em m/s, evitando a necessidade da conversão de km/h para m/s. Temos também a energia cinética já em sua medida apropriada. Assim, só precisamos jogar 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[]){
// velocidade (em m/s)
float velocidade = 50; // em m/s
// energia cinética
float energia_cinetica = 75; // em joule
// e então calculamos a massa do corpo
float massa = (2 * energia_cinetica) / pow(velocidade, 2);
// mostramos o resultado
printf("A massa do corpo é: %fkg", massa);
printf("\n\n");
system("PAUSE");
return 0;
}
Ao executar este código C nós teremos o seguinte resultado: A massa do corpo é: 0.060000kg (ou 0.060000 x 1000 = 60 gramas). |
Java ::: Estruturas de Dados ::: Lista Ligada Simples |
Estruturas de dados em Java - Introdução às listas ligadas em JavaQuantidade de visualizações: 229 vezes |
|
Então você se interessou pelo assunto de listas ligadas em Java? Recomendo que leia esta anotação com muita atenção. É o ponto de partida para o entendimento e implementação desta estrutura de dados tão importante. Uma lista singularmente ou duplamente ligada (singly or doubly linked list) é uma lista dinâmica no sentido de que ela pode crescer ou diminuir de acordo com as necessidades do programa. As matrizes (arrays) comuns também têm seu papel assegurado no estudo das estruturas de dados. No entanto, uma de suas limitações é que seus elementos são dispostos lado a lado na memória. Isso torna a inserção de um novo elemento no meio do array uma tarefa dispendiosa, visto que os demais elementos precisam ser movidos para outras posições. Em uma lista dinâmica isso não acontece. O conceito principal das listas ligadas é a capacidade de um nó (cada elemento da lista é chamado de nó) poder apontar para um outro nó com estrutura semelhante. Veja a estrutura típica de um nó em uma lista ligada:
// classe No
public class No{
public int valor;
public No proximo;
}
// fim da classe No
Note que esta classe contém dois campos: um campo do tipo int que guarda o valor do nó e um campo do tipo referência apontando para um objeto do mesmo tipo que o nó atual. Isso permite a circularidade das listas, ou seja, um nó apontando para um elemento de seu mesmo tipo. Com este conhecimento já podemos criar o início de uma lista singularmente ligada, para isso só precisamos declarar uma variável do tipo No. Veja: // declara o início da lista No inicio; Até agora temos uma lista ligada vazia. A criação do primeiro elemento da lista pode ser feito da seguinte forma:
public class Lista{
// declara o início da lista
static No inicio = null;
public static void main(String args[]){
// verifica se a lista está vazia
if(inicio == null){
// reserva memória para o novo nó
inicio = new No();
// a memória foi alocada com sucesso?
if(inicio != null){
inicio.valor = 150;
// é o primeiro nó...seu campo proximo não deve
// apontar para lugar nenhum
inicio.proximo = null;
}
}
System.out.println(inicio.valor);
System.exit(0);
}
}
Aqui nós temos a criação do primeiro nó de uma lista singularmente ligada. Note como usamos a palavra-chave new para alocar memória para o nó atual. Veja também que o valor null é fornecido para o campo próximo do nó. Isso aconteceu porque temos apenas um nó. Em outras dicas desta seção abordaremos como inserir os demais nós e também listar todos os nós existentes na lista. Até lá. |
Desafios, Exercícios e Algoritmos Resolvidos de Java |
Veja mais Dicas e truques de Java |
E-Books em PDF |
||||
|
||||
|
||||
Linguagens Mais Populares |
||||
|
1º lugar: Java |



