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 Python
Card 1 de 2
A indentação é mesmo obrigatória em Python?

Sim, a linguagem Python exige o uso da indentação como forma de formar blocos de código.

O interpretador Python é informado que um grupo de instruções pertence a um bloco específico por meio da indentação. Em geral, programadores Python usam um ou dois caracteres de tabulação (tecla Tab) como forma de indentar seus blocos de código.

Em todas as linguagens de programação a indentação facilita a leitura e compreensão do código escrito, porém, em Python, ela é um requisito obrigatório.

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# ::: Dicas & Truques ::: Matemática e Estatística

Como calcular porcentagem em C# - Como efetuar cálculos de porcentagem em C#

Quantidade de visualizações: 36435 vezes
Cálculos de porcentagens estão presentes em boa parte das aplicações que desenvolvemos. Porém, há momentos em que a mente trava e não conseguimos lembrar com clareza como estes cálculos são feitos, principalmente em C#.

Esta anotação tem o objetivo de ser uma fonte de pesquisa para os momentos em que suas habilidades matemáticas insistirem em continuar ocultas.

Ex: 1 - Suponhamos que um produto que custe R$ 178,00 sofra um acréscimo de 15%. Qual o valor final do produto? Veja o código em C#:

// Algoritmo que calcula porcentagem em C#
using System;

namespace Estudos {
  class Principal {
    // função principal do programa C#
    static void Main(string[] args) {
      // variáveis usadas na resolução do problema
      double valor, percentual, valor_final;

      valor = 178.00; // valor original
      percentual = 15.0 / 100.0; // 15%
      valor_final = valor + (percentual * valor);

      // mostra o resultado
      Console.WriteLine("O valor final do produto é: " + valor_final);

      // O resultado será 204,70
      
      Console.WriteLine("\n\nPressione uma tecla para sair...");
      Console.ReadKey();
    }
  }
}

Ex: 2 - Um produto, cujo valor original era de R$ 250,00, teve um desconto de 8%. Qual foi seu valor final? Veja o código em C#:

// Algoritmo que calcula porcentagem em C#
using System;

namespace Estudos {
  class Principal {
    // função principal do programa C#
    static void Main(string[] args) {
      // variáveis usadas na resolução do problema
      double valor, percentual, valor_final;

      valor = 250.00; // valor original
      percentual = 8.0 / 100.0; // 8%
      valor_final = valor - (percentual * valor);

      // mostra o resultado
      Console.WriteLine("O valor final do produto é: " + valor_final);

      // O resultado será 230,00

      Console.WriteLine("\n\nPressione uma tecla para sair...");
      Console.ReadKey();
    }
  }
}

Ex: 3 - Em um concurso de perguntas e respostas, um jovem acertou 72 das 90 perguntas apresentadas. Qual foi a porcentagem de acertos? E a porcentagem de erros? Veja o código em C#:

// Algoritmo que calcula porcentagem em C#
using System;

namespace Estudos {
  class Principal {
    // função principal do programa C#
    static void Main(string[] args) {
      // variáveis usadas na resolução do problema
      double perguntas, acertos;

      perguntas = 90.0;
      acertos = 72.0;

      // mostra a porcentagem de acertos
      Console.WriteLine("Porcentagem de acertos: " +
        ((acertos / perguntas) * 100) + "%");

      // mostra a porcentagem de erros
      Console.WriteLine(("Porcentagem de erros: ") +
        (((perguntas - acertos) / perguntas) * 100) + "%");

      // Os resultados serão 80% e 20%

      Console.WriteLine("\n\nPressione uma tecla para sair...");
      Console.ReadKey();
    }
  }
}

Ex: 4 - Um aparelho de CD foi adquirido por R$ 300,00 e revendido por R$ 340,00. Qual foi a porcentagem de lucro na transação? Veja o código em C#:

// Algoritmo que calcula porcentagem em C#
using System;

namespace Estudos {
  class Principal {
    // função principal do programa C#
    static void Main(string[] args) {
      // variáveis usadas na resolução do problema
      double valor_anterior, novo_valor, porcentagem_lucro;

      valor_anterior = 300.0; // valor anterior
      novo_valor = 340.0; // valor novo

      // calcula a porcentagem de lucro
      // efetua o cálculo
      porcentagem_lucro = ((novo_valor * 100) / valor_anterior) - 100;

      Console.WriteLine("A porcentagem de lucro foi de: " +
        porcentagem_lucro + "%");

      // O resultado será 13,33

      Console.WriteLine("\n\nPressione uma tecla para sair...");
      Console.ReadKey();
    }
  }
}

Ex: 5 - Uma loja repassa 5% do lucro a seus vendedores. Se um produto custa R$ 70,00, qual o valor em reais repassado a um determinado vendedor? Veja o código em C#:

// Algoritmo que calcula porcentagem em C#
using System;

namespace Estudos {
  class Principal {
    // função principal do programa C#
    static void Main(string[] args) {
      // variáveis usadas na resolução do problema
      double valor, percentual, comissao;

      valor = 70.0; // valor do produto
      percentual = 5.0 / 100.0; // 5%

      // calcula a comissão
      comissao = percentual * valor;

      // mostra o resultado
      Console.WriteLine("O valor repassado ao vendedor é: " + comissao);

      // O resultado será 3,5

      Console.WriteLine("\n\nPressione uma tecla para sair...");
      Console.ReadKey();
    }
  }
}



Java ::: Desafios e Lista de Exercícios Resolvidos ::: Laços de Repetição

Exercício Resolvido de Java - Calculando e exibindo os números primos entre 2 e 100

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

Um inteiro é um número primo se ele for divisível somente por 1 e por ele mesmo. Assim, 2, 3, 5 e 7 são primos, enquanto 4, 6, 8 e 9 não são. Note que o número 1 não é primo.

Escreva um programa (algorítmo) Java que usa um laço for, while ou do...while para calcular e exibir os números primos entre 2 (incluindo) e 100 (incluindo).

Sua saída deverá ser parecida com:

Numeros primos entre 2 e 100: 
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
Resposta/Solução:

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

package estudos;

public class Estudos {
  public static void main(String[] args) {
    // limite dos números primos (incluindo)
    int limite = 100;
               
    // Lembre-se! O número 1 não é primo
    System.out.println("Numeros primos entre 2 e " + limite + ": ");
  
    // laço que percorre os valores de 2 até o limite desejado
    for(int i = 2; i <= limite; i++){
       boolean primo = true;
                       
       // se o valor de i for 7, a variável j do laço contará
       // de 2 até 7 / 2 (divisão inteira), ou seja, 3. Se o 
       // módulo de 7 por qualquer um dos valores neste intervalo 
       // for igual a 0, então o número não é primo
       for(int j = 2; j <= (i / 2); j++){
         if(i % j == 0){
           primo = false; // não é primo
           break;
         }
       }
    
       if(primo){
         System.out.print(i + " ");
       }
    }
    
    System.out.println();
  }
}



Excel ::: Fórmulas do Excel ::: Trigonometria - Funções Trigonométricas

Como converter graus em radianos no Excel usando a função RADIANOS() - Trigonometria no Excel

Quantidade de visualizações: 905 vezes
Quando estamos trabalhando com trigonometria no Excel, é importante ficarmos atentos ao fato de que todas as funções trigonométricas do Excel, tais como COS(), SEN(), TAN(), etc, recebem seus argumentos em radianos, em vez de graus.

Por isso, antes de chamar estas funções, é importante converter o valor em graus para radianos. No Excel isso pode ser feito por meio da função RADIANOS(). Esta função recebe o valor em graus e retorno o valor em radianos.

Vamos ver um exemplo. Abra uma nova planilha do Excel e cole o código a seguir na célula B1:

=RADIANOS(A1)

Note que o argumento para a função RADIANOS() é o valor da célula A1. Assim, digite 45 na célula A1 e pressione Enter ou Tab. O valor 0,785398163 será exibido automaticamente na célula B1.


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

Regressão linear - Como calcular o coeficiente de correlação linear de Pearson em Java - Java para Machine Learning

Quantidade de visualizações: 908 vezes


No estudo de Machine Learning, uma das primeiras ferramentas que aprendemos é Regressão Linear. E, para o bom entendimento da regressão linear, temos que aprender sobre o coeficiente de correlação linear, mais especificamente o coeficiente de correlação linear de Pearson.

A fórmula do coeficiente de correlação linear de Pearson é:

\[r_\text{xy} = \frac{n \sum x_i y_i - \sum x_i \sum y_i}{\sqrt{n \sum {x_i}^2 - \left(\sum {x_i}\right)^2} \cdot \sqrt{n \sum {y_i}^2 - \left(\sum {y_i}\right)^2}} \]

Onde:

x e y são os conjuntos de valores cuja correlação queremos testar.

É claro que encontraremos algumas variações desta fórmula na internet e também em livros de estatística, mas o resultado é sempre o mesmo.

A correlação de Pearson é uma técnica estatística para medir se duas variáveis estão linearmente relacionadas. Essa técnica também pode ser chamada de r de Pearson, correlação produto-momento de Pearson ou, mais coloquialmente, de correlação de Pearson.

O r de Pearson é uma métrica que expressa a relação linear entre variáveis por meio de um número que vai de -1 a +1. Isto é, quanto mais próximo dos extremos (-1 ou +1), maior é a força da correlação. Por outro lado, valores próximos de zero indicam que a correlação é fraca.

O sinal da correlação, por sua vez, indica a direção da relação entre variáveis. Se a correlação é positiva, então o aumento em uma variável implica o aumento na outra variável. Por outro lado, se a correlação é negativa, então o aumento em uma variável implica o decréscimo na outra variável.

Veja agora o código Java completo no qual calculamps o coeficiente de correlação linear de Pearson a partir de valores x e y, dispostos em dois vetores, ou seja, dois arrays unidimensionais:

package estudos;

public class Estudos {
  public static void main(String[] args) {
    // vamos criar os vetores com os valores x e y
    double x[] = {13, 32, 47, 54, 69, 73};
    double y[] = {208, 184, 145, 14, 65, 32};
    // as variáveis para os somatórios
    double soma_x = 0, soma_y = 0, soma_x_quadrado = 0;
    double soma_y_quadrado = 0, soma_x_vezes_y = 0;
    
    // vamos percorrer os vetores e efetuar as somas
    for (int i = 0; i < x.length; i++) {
      // primeiro o somatório de x
      soma_x = soma_x + x[i];
      // agora o somatório de y
      soma_y = soma_y + y[i];
      // então o somatório de x^2
      soma_x_quadrado = soma_x_quadrado + Math.pow(x[i], 2);
      // e o somatório de y^2
      soma_y_quadrado = soma_y_quadrado + Math.pow(y[i], 2);
      // e finalmente o somatório de x*y 
      soma_x_vezes_y = soma_x_vezes_y + x[i] * y[i];
    }
    
    // vamos obter a quantidade de valores na observação
    int n = x.length;
    
    // e finalmente calculamos o coeficiente de correlação
    // linear
    double r_xy = ((n * soma_x_vezes_y) - (soma_x * soma_y)) /
      (Math.sqrt((n * soma_x_quadrado) - Math.pow(soma_x, 2)) *
      Math.sqrt((n * soma_y_quadrado) - Math.pow(soma_y, 2)));
    
    // e mostramos o resultado
    System.out.println("O coeficiente de correlação é: " +
      r_xy);
  }
}

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

O coeficiente de correlação é: -0.8713675107044452


Java ::: Desafios e Lista de Exercícios Resolvidos ::: Laços de Repetição

Exercícios Resolvidos de Java - Escreva um programa Java que usa o laço for para desenhar um padrão de diamante de estrelas

Quantidade de visualizações: 1790 vezes
Exercício Resolvido de Java - Escreva um programa Java que usa o laço for para desenhar um padrão de diamante de estrelas

Pergunta/Tarefa:

Neste exercício para a prática da linguagem Java você deverá usar o laço for para desenhar o famoso padrão de diamante de estrelas. Você pode também usar o laço while, se assim você o desejar.

O programa deverá pedir que o usuário informe a quantidade de linhas que marcará a metade do diamante.

Seu programa deve apresentar a seguinte saída:

Informe a quantidade de linhas: 5
    *
   ***
  *****
 *******
*********
 *******
  *****
   ***
    *
Resposta/Solução:

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

package exercicio;

import java.util.Scanner;

public class Exercicio {
  public static void main(String[] args) {
    // vamos usar um objeto Scanner para ler a entrada do usuário
    Scanner leitura = new Scanner(System.in);
    
    // vamos pedir a quantidade de linhas 
    System.out.print("Informe a quantidade de linhas: ");
    // vamos ler a entrada do usuário
    int linhas = Integer.parseInt(leitura.nextLine());
    
    int estrelas = 1; // começamos com uma estrela (no topo do diamante)
    int espacos = linhas - 1; // se linhas for igual a 5 nós começamos
    // com 4 espaços
    
    // repete duas vezes a quantidade de linhas informadas
    for(int i = 1; i < linhas * 2; i++){
      // vamos imprimir os espaços
      for(int j = 1; j <= espacos; j++){
        System.out.print(" ");
      }
        
      // agora vamos imprimir estrelas
      for(int j = 1; j < estrelas * 2; j++){
        System.out.print("*");
      }
		    
      // passamos para a próxima linha
      System.out.println();
        
      if(i < linhas){ // é a parte superior do diamante
        espacos--; // diminui os espaços
        estrelas++; // e aumenta as estrelas
      }
      else{ // é a parte inferior do diamente
        espacos++; // aumenta os espaços
        estrelas--; // e diminui as estrelas
      }
    }
  }
}



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 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 Apenas R$ 32,90

Planilha Web - Planilhas e Calculadoras online para estudantes e profissionais de Engenharia Civil, Engenharia Elétrica e Engenharia Mecânica.


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