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.

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

Exercícios Resolvidos de C - Declarar um vetor de 10 elementos e usar o laço for para solicitar ao usuário que informe os valores dos elementos do vetor

Quantidade de visualizações: 15085 vezes
Exercício Resolvido de C - Declarar um vetor de 10 elementos e usar o laço for para solicitar ao usuário que informe os valores dos elementos do vetor

Pergunta/Tarefa:

Escreva um programa C que declara um vetor (array) de 10 elementos do tipo int. Em seguida use um laço for para solicitar ao usuário que informe 10 valores inteiros e armazene tais valores nos elementos do vetor:

Dica: Use a função scanf() para obter a entrada do usuário.

Resposta/Solução:

Veja abaixo a resolução completa para esta tarefa:

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

int main(int argc, char *argv[])
{
  // vamos declarar um vetor de 10 inteiros
  int valores[10];
  int i;

  // agora vamos solicitar ao usuário que informe os 10 valores para
  // os elementos do vetor. O mais recomendável neste caso é usar um
  // laço for que repetirá 10 vezes e, a cada repetição, solicitaremos
  // um valor
  for(i = 0; i < 10; i++){
    printf("Informe o valor %d: ", (i + 1));
    scanf("%d", &valores[i]);
  }

  // para finalizar vamos exibir os valores informados pelo usuário e
  // presentes nos elementos do vetor
  printf("\nOs valores informados foram:\n");

  for(i = 0; i < 10; i++){
    printf("O valor %d foi: %d\n", (i + 1), valores[i]);
  }
  
  system("PAUSE");	
  return 0;
}



Java ::: Estruturas de Dados ::: Árvore Binária e Árvore Binária de Busca

Estruturas de dados em Java - Como pesquisar um nó em uma árvore binária de busca usando um método recursivo usando Java

Quantidade de visualizações: 3150 vezes
Nesta dica mostraremos um exemplo completo de como pesquisar um valor em uma árvore binária de busca em Java. Note que o exemplo usa apenas inteiros, mas você não terá dificuldades para modificar a classe Nó para os dados que você precisar.

Código para No.java:

package arvore_binaria;

public class No {
  private int valor; // valor armazenado no nó
  private No esquerdo; // filho esquerdo
  private No direito; // filho direito
 
  // construtor do nó
  public No(int valor){
    this.valor = valor;
    this.esquerdo = null;
    this.direito = null;
  }

  public int getValor() {
    return valor;
  }

  public void setValor(int valor) {
    this.valor = valor;
  }

  public No getEsquerdo() {
    return esquerdo;
  }

  public void setEsquerdo(No esquerdo) {
    this.esquerdo = esquerdo;
  }

  public No getDireito() {
    return direito;
  }

  public void setDireito(No direito) {
    this.direito = direito;
  }
}

Código para ArvoreBinariaBusca.java:

package arvore_binaria;

public class ArvoreBinariaBusca {
  private No raiz; // referência para a raiz da árvore
   
  // método usado para inserir um novo nó na árvore
  // retorna true se o nó for inserido com sucesso e false
  // se o elemento
  // não puder ser inserido (no caso de já existir um 
  // elemento igual)
  public boolean inserir(int valor){
    // a árvore ainda está vazia?
    if(raiz == null){
      // vamos criar o primeiro nó e definí-lo como a raiz da árvore
      raiz = new No(valor); // cria um novo nó
    }
    else{
      // localiza o nó pai do novo nó
      No pai = null;
      No noAtual = raiz; // começa a busca pela raiz
  
      // enquanto o nó atual for diferente de null
      while(noAtual != null){
        // o valor sendo inserido é menor que o nó atual?
        if(valor < noAtual.getValor()) {
          pai = noAtual;
          // vamos inserir do lado esquerdo
          noAtual = noAtual.getEsquerdo();
        }
        // o valor sendo inserido é maior que o nó atual
        else if(valor > noAtual.getValor()){
          pai = noAtual;
          // vamos inserir do lado direito
          noAtual = noAtual.getDireito();
        }
        else{
          return false; // um nó com este valor foi encontrado
        }
      }
        
      // cria o novo nó e o adiciona como filho do nó pai
      if(valor < pai.getValor()){
         pai.setEsquerdo(new No(valor));
      }
      else{
        pai.setDireito(new No(valor));
      }
    }
 
    return true; // retorna true para indicar que o novo nó foi inserido
  }
   
  // método que permite pesquisar na árvore binária de busca
  public No pesquisar(int valor){
    return pesquisar(raiz, valor); // chama a versão recursiva do método
  }
 
  // sobrecarga do método pesquisar que recebe dois 
  // parâmetros (esta é a versão recursiva do método)
  private No pesquisar(No noAtual, int valor){
    // o valor pesquisado não foi encontrado....vamos retornar null
    if(noAtual == null){
      return null;
    }
  
    // o valor pesquisado foi encontrado?
    if(valor == noAtual.getValor()){
      return noAtual; // retorna o nó atual
    }  
    // ainda não encontramos...vamos disparar uma nova 
    // chamada para a sub-árvore da esquerda
    else if(valor < noAtual.getValor()){
      return pesquisar(noAtual.getEsquerdo(), valor);
    }
    // ainda não encontramos...vamos disparar uma nova 
    // chamada para a sub-árvore da direita
    else{
      return pesquisar(noAtual.getDireito(), valor);
    }
  }
}

E finalmente o código para a classe principal:

package arvore_binaria;

import java.util.Scanner;

public class ArvoreBinariaTeste {
  public static void main(String[] args) {
    Scanner entrada = new Scanner(System.in);  
       
    // vamos criar um novo objeto da classe ArvoreBinariaBusca
    ArvoreBinariaBusca arvore = new ArvoreBinariaBusca();
    
    // vamos inserir 5 valores na árvore
    for(int i = 0; i < 5; i++){
      System.out.print("Informe um valor inteiro: ");
      int valor = Integer.parseInt(entrada.nextLine());
       
      // vamos inserir o nó e verificar o sucesso da operação
      if(!arvore.inserir(valor)){
        System.out.println("Não foi possível inserir." +
          " Um elemento já contém este valor.");  
      }
    }
     
    // vamos pesquisar um valor na árvore
    System.out.print("\nInforme o valor a ser pesquisado: ");
    int valorPesquisa = Integer.parseInt(entrada.nextLine());
    // obtém um objeto da classe NoArvore a partir do 
    // método pesquisar() da classe ArvoreBinariaBusca
    No res = arvore.pesquisar(valorPesquisa);
    // o valor foi encontrado?
    if(res != null){
      System.out.println("O valor foi encontrado na árvore");
    }
    else{
      System.out.println("O valor não foi encontrado na árvore");  
    }
     
    System.out.println("\n");
  }
}



Ruby ::: Dicas & Truques ::: Programação Orientada a Objetos

Programação Orientada a Objetos em Ruby: Classes, objetos, métodos e variáveis de instância

Quantidade de visualizações: 11634 vezes
A melhor forma de entender a programação orientada a objetos é começar com uma analogia simples. Suponha que você queira dirigir um carro e fazê-lo ir mais rápido pressionado o acelerador. O que deve acontecer antes que você seja capaz de fazer isso?

Bem, antes que você possa dirigir um carro, alguém tem que projetá-lo. Um carro geralmente começa com desenhos feitos pelos engenheiros responsáveis por tal tarefa, tal qual a planta de uma casa. Tais desenhos incluem o projeto de um acelerador que possibilita ao carro ir mais rápido.

O pedal do acelerador "oculta" os mecanismos complexos responsáveis por fazer o carro ir mais rápido, da mesma forma que o pedal de freio "oculta" os mecanismos que fazem o carro ir mais devagar e o volante "oculta" os mecanismos que fazem com que o carro possa virar para a direita ou esquerda. Isso permite que pessoas com pequeno ou nenhum conhecimento de motores possam facilmente dirigir um carro.

Infelizmente, não é possível dirigir o projeto de um carro. Antes que possamos dirigí-lo, o carro deve ser construído a partir do projeto que o descreve. Um carro já finalizado tem um pedal de aceleração de verdade, que faz com que o carro vá mais rápido. Ainda assim, é preciso que o motorista pressione o pedal. O carro não acelerará por conta própria.

Agora vamos usar nosso exemplo do carro para introduzir alguns conceitos de programação importantes à programação orientada a objetos. A execução de uma determinada tarefa em um programa exige um método ou função. O método (ou função) descreve os mecanismos que, na verdade, executam a tarefa.

O método oculta tais mecanismos do usuário, da mesma forma que o pedal de aceleração de um carro oculta do motorista os mecanismos complexos que fazem com que um carro vá mais rápido.

Em Ruby, começamos criando uma unidade de programa chamada classe para abrigar um método, da mesma forma que o projeto de um carro abriga o design do pedal de acelerador. Em uma classe fornecemos um ou mais métodos que são projetados para executar as tarefas da classe.

Por exemplo, a classe que representa uma conta bancária poderia conter muitos métodos, incluindo um método para depositar dinheiro na conta, outro para retirar dinheiro, um terceiro para verificar o saldo, e assim por diante.

Da mesma forma que não podemos dirigir o projeto de um carro, nós não podemos "dirigir" uma classe. Da mesma forma que alguém teve que construir um carro a partir de seu projeto antes que pudessémos dirigí-lo, devemos construir um objeto de uma classe antes de conseguirmos executar as tarefas descritas nela.

Quando dirigimos um carro, o pressionamento do acelerador envia uma mensagem ao carro informando-o da tarefa a ser executada (neste caso informando-o de que queremos ir mais rápido). Da mesma forma, enviamos mensagens aos objetos de uma classe. Cada mensagem é uma chamada de método e informa ao objeto qual ou quais tarefas devem ser executadas.

Até aqui nós usamos a analogia do carro para introduzir classes, objetos e métodos. Já é hora de saber que um carro possui atributos (propriedades) tais como cor, o número de portas, a quantidade de gasolina em seu tanque, a velocidade atual, etc. Tais atributos são representados como parte do projeto do carro. Quando o estamos dirigindo, estes atributos estão sempre associados ao carro que estamos usando, e cada carro construído a partir do projeto sofrerá variações nos valores destes atributos em um determinado momento.
Da mesma forma, um objeto tem atributos associados a ele quando o usamos em um programa. Estes atributos são definidos na classe a partir da qual o objeto é instanciado (criado) e são chamados de variáveis de instância da classe.

Veremos agora como definir uma classe em Ruby e usar um objeto desta classe em um programa. Veja o trecho de código abaixo:

# Definição da classe Cliente
class Cliente
   def definir_nome(nome)
      @nome = nome
   end
    
   def obter_nome
      @nome
   end
end

# Cria uma instância da classe Cliente
cliente = Cliente.new

# Efetua uma chamada ao método definir_nome
cliente.definir_nome("Laura Maria dos Santos")

# Efetua uma chamada ao método obter_nome
print "O nome do cliente é " + cliente.obter_nome

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

O nome do cliente é Laura Maria dos Santos


Python ::: Tkinter GUI Toolkit ::: Formulários e Janelas

Como definir a cor de fundo de uma janela do Tkinter do Python usando a função config()

Quantidade de visualizações: 3893 vezes
A cor de fundo de uma janela do Tkinter do Python pode ser definida por meio de uma chamada à função config() da classe Tk com o valor de uma cor para o parâmetro bg.

Veja uma aplicação Tkinter completa no qual definimos o título da janela e, em seguida, sua cor de fundo:

# vamos importar o módulo Tkinter
import tkinter as tk

# método principal
def main():
  # vamos criar a janela principal da aplicação
  janela = tk.Tk()

  # vamos definir o título da janela
  janela.title("Sistema de Biblioteca")

  # vamos definir a cor de fundo da janela
  janela.config(bg='#F2B33D')

  # entramos no loop de eventos
  janela.mainloop()

if __name__== "__main__":
  main()



Nossas 20 dicas & truques de programação mais populares

Você também poderá gostar das dicas e truques de programação abaixo

Nossas 20 dicas & truques de programação mais recentes

Últimos Projetos e Códigos Fonte Liberados Para Apoiadores do Site

Últimos Exercícios Resolvidos

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á 10 usuários muito felizes estudando em nosso site.