Você está aqui: C# ::: Desafios e Lista de Exercícios Resolvidos ::: C# Básico

Escrever um programa C# que recebe o salário-base de um funcionário, calcule e mostre o salário a receber - Desafio de Programação Resolvido em C#

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

Faça um programa (algoritmo) C# que recebe o salário-base de um funcionário, calcule e mostre o salário a receber, sabendo-se que esse funcionário tem gratificação de 5% sobre o salário-base e paga imposto de 7% sobre o salário-base.

Sua saída deverá ser parecida com:

Informe o salário base: 1450.00
Gratificação: R$ 72,50
Imposto: R$ 101,50
Salário final: R$ 1.421,00

Resposta/Solução:

Veja a resolução comentada deste exercício usando C#:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

using System;

namespace Estudos {
  class Principal {
    static void Main(string[] args) {
      // vamos ler o salario base
      Console.Write("Informe o salário base: ");
      double salario_base = Double.Parse(Console.ReadLine());

      // vamos calcular a gratificação
      double gratificacao = salario_base * (5.0 / 100);

      // vamos calcular o imposto
      double imposto = salario_base * (7.0 / 100);

      // e finalmente calculamos o salário final
      double salario_final = salario_base + gratificacao - imposto;

      // e exibimos o resultado
      Console.WriteLine("Gratificação: " + string.Format("{0:c}", gratificacao));
      Console.WriteLine("Imposto: " + string.Format("{0:c}", imposto));
      Console.WriteLine("Salário final: " + string.Format("{0:c}", salario_final));
      
      Console.WriteLine("\nPressione uma tecla para sair...");
      Console.ReadKey();
    }
  }
}


Link para compartilhar na Internet ou com seus amigos:

C++ ::: Dicas & Truques ::: Trigonometria - Funções Trigonométricas

Como calcular o cateto oposto dadas as medidas da hipotenusa e do cateto adjascente em C++

Quantidade de visualizações: 822 vezes
Todos estamos acostumados com o Teorema de Pitágoras, que diz que "o quadrado da hipotenusa é igual à soma dos quadrados dos catetos". Baseado nessa informação, fica fácil retornar a medida do cateto oposto quando temos as medidas da hipotenusa e do cateto adjascente. Isso, claro, via programação em linguagem C++.

Comece observando a imagem a seguir:



Veja que, nessa imagem, eu já coloquei os comprimentos da hipotenusa, do cateto oposto e do cateto adjascente. Para facilitar a conferência dos cálculos, eu coloquei também os ângulos theta (que alguns livros chamam de alfa) e beta já devidamente calculados. A medida da hipotenusa é, sem arredondamentos, 36.056 metros.

Então, sabendo que o quadrado da hipotenusa é igual à soma dos quadrados dos catetos (Teorema de Pitógoras):

\[c^2 = a^2 + b^2\]

Tudo que temos que fazer é mudar a fórmula para:

\[a^2 = c^2 - b^2\]

Veja que agora o quadrado do cateto oposto é igual ao quadrado da hipotenusa menos o quadrado do cateto adjascente. Não se esqueça de que a hipotenusa é o maior lado do triângulo retângulo.

Veja agora como esse cálculo é feito em linguagem C++:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

#include <iostream>
#include <math.h>
#include <cstdlib>
 
using namespace std;
 
int main(int argc, char *argv[]){
  float c = 36.056; // medida da hipotenusa
  float b = 30; // medida do cateto adjascente
  
  // agora vamos calcular o comprimento da cateto oposto
  float a = sqrt(pow(c, 2) - pow(b, 2));
 
  // e mostramos o resultado
  cout << "A medida do cateto oposto é: " << a << "\n\n";
	 
  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}

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

A medida do cateto oposto é: 20.0009

Como podemos ver, o resultado retornado com o código C++ confere com os valores da imagem apresentada.


Python ::: Dicas & Truques ::: Trigonometria - Funções Trigonométricas

Como calcular o arco cosseno de um número em Python usando o método acos() do módulo math

Quantidade de visualizações: 2982 vezes
O arco cosseno, (também chamado de cosseno inverso) pode ser representado por cos-1 x, arccos x ou acos x. Esta função é a inversa do cosseno, ou seja, se o cosseno é a relação entre o cateto adjacente ao ângulo e a hipotenusa, o arco cosseno parte desta relação para encontrar o valor do ângulo.

Em Python, o arco cosseno de um número pode ser obtido por meio do método acos() da classe Math. Este método recebe um valor double e retorna também um double, na faixa 0 <= x <= PI, onde PI vale 3.1416.

Veja um código Python completo no qual informamos um número e em seguida calculamos o seu arco-cosseno:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

# vamos importar o módulo Math
import math as math

def main():
  numero = 0.5
  print("O arco cosseno de %f é %f" % (numero, math.acos(numero)))
  
if __name__== "__main__":
  main()

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

O arco cosseno de 0.500000 é 1.047198

Não se esqueça de que as funções trigonométricas são usadas para modelar o movimento das ondas e fenômenos periódicos, como padrões sazonais. Elas formam a base para análises avançadas em engenharia elétrica, processamento digital de imagem, radiografia, termodinâmica, telecomunicações e muitos outros campos da ciência e da tecnologia.


Java ::: Dicas & Truques ::: MIDI Musical Instrument Digital Interface, Mapeamento e sequenciamento MIDI, Entrada e saída MIDI

Java para músicos - Como escrever um MIDI Player em Java (código bem simples e fácil de entender)

Quantidade de visualizações: 13672 vezes
Nesta dica apresento uma aplicação completa para um MIDI Player em Java. Trata-se de uma aplicação console que você pode estudar e implementar a mesma idéia em Java Swing ou JavaFX. Para executar o código abaixo, você só precisa definir o caminho e nome de um arquivo MIDI (extensão .mid).

Veja o código completo e divirta-se:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package arquivodecodigos;

import javax.sound.midi.*;
import java.io.*;
 
public class Estudos{
  public static void main(String args[]) {
    // nome do arquivo MIDI
    String arquivo = "amazing_grace.mid";
    
    if(!arquivo.endsWith(".mid")) {
      System.out.println("Este não parece ser um arquivo MIDI válido.");
      System.exit(1);
    }
    File midiFile = new File(arquivo);
    if(!midiFile.exists() || midiFile.isDirectory() || 
        !midiFile.canRead()) {
      System.out.println("Não foi possível acessar o arquivo indicado.");
      System.exit(1);
    }
     
    try{
      Sequencer seq = MidiSystem.getSequencer();
      seq.setSequence(MidiSystem.getSequence(midiFile));
      seq.open();
      seq.start();
       
      while(true){
        if(seq.isRunning()){
          try{
            Thread.sleep(1000);
          } 
          catch(InterruptedException ignore){
            break;
          }
        } 
        else{
          break;
        }
      }
       
      seq.stop();
      seq.close();
    } 
    catch(MidiUnavailableException mue){
      System.out.println("Dispositivo de MIDI indisponível");
    }
    catch(InvalidMidiDataException imde){
      System.out.println("Dados MIDI Inválidos");
    } 
    catch(IOException ioe){
      System.out.println("Erro de I/O");
    } 
  }  
}



Java ::: Projetos Java Completos - Códigos Fonte Completos Java ::: Projetos Java Programação Orientada a Objetos - Exemplos Java

Simulação de Sistema Bancário usando Programação Orientada a Objetos em Java - Projeto completo com código fonte - Versão console

Quantidade de visualizações: 14964 vezes
Sobre este projeto Java

Durante estes anos que tenho trabalhado como freelancer, mais da metade das requisições dos meus clientes foram ajuda para desenvolver idéias de programação orientada a objetos em Java para projeto de faculdades e universidades.

Com isso percebi que boa parte dos alunos e iniciantes em programação orientada a objetos já entendem toda a teoria. O que lhes falta é prática, ou seja, aplicar estes conhecimentos em aplicações do mundo real.

Pensando nisso, apresento a você um projeto muito interessante e que, se bem entendido e praticado, o ajudará a desenvolver qualquer tipo de aplicação, seja comercial ou para solucionar problemas cotidianos.

O projeto Java apresentado nesta dica é uma simulação completa de um Sistema Bancário, tudo com código fonte em Java, comentado, com variáveis em português, em um nível médio de programação, para facilitar o entendimento de todos.

Nesta simulação nós temos a criação de classes Java, construtores, encapsulamento de dados, agregação e composição, métodos com retorno e sem retorno, variáveis estáticas, variáveis públicas e privadas, e relacionamento entre objetos (um para um, um para muitos, muitos para um) usando ArrayList. Sim, o projeto faz uso extensivo de ArrayList, o que o torna muito rico para o aprendizado e fixação dos conhecimentos da linguagem Java e suas classes principais.

O Diagrama de Classes Java

Antes de falarmos mais sobre o projeto, dê uma boa olhada no seu diagrama de classes:



Como a aplicação está estruturada?

Como podemos ver no diagrama de classes, nós temos uma classe Sistema que contém zero ou vários objetos da classe Banco (relacionamento um para muitos). A classe Banco, por sua vez, possui uma ArrayList de objetos da classe Agência, ou seja, mais um relacionamento um para muitos, já que cada agência pertence a um único banco.

Cada agência pode possuir zero ou mais contas, e cada conta possui um ArrayList de objetos da classe Transação, o que nos permite registrar todas as operações nas contas e emitir o extrato bancário, com os débitos, créditos e transferências entre contas.

Tudo isso é feito por meio de vários menus de opções, como podemos ver na imagem a seguir:



Devo usar ArrayList do Java para desenvolver o sistema?

Sim, objetos da classe ArrayList são perfeitos quando precisamos representar relacionamentos um para muitos e muitos para um. É claro que poderíamos usar vetores de objetos (usando array), mas ficaríamos restritos a tamanhos fixos, enquanto o ArrayList nos permite cadastrar quantos bancos, pessoas, agências e contas quisermos.

Dessa forma, veja, por exemplo, o trecho de código que cria um novo banco:

switch(opcao){
  case 1: // vamos cadastrar um novo banco
    System.out.print("\nNúmero do Banco: ");
    String numeroBanco = entrada.nextLine();
    System.out.print("Nome do Banco: ");
    String nomeBanco = entrada.nextLine();
        
    // vamos incrementar o contador de bancos
    Banco.contadorBancos++;
        
    // agora vamos criar um novo objeto da classe Banco
    Banco b = new Banco(Banco.contadorBancos, nomeBanco,
      numeroBanco);
    // e o adicionamos no ArrayList de bancos
    bancos.add(b);
        
    // e finalmente mostramos uma mensagem de sucesso.
    System.out.println("\nO banco criado com sucesso");
        
    break;


Note que este trecho de código é parte do case da opção Novo Banco do menu Gerenciar Bancos. Veja como usamos uma variável estática contadorBancos da classe Banco para criarmos um valor inteiro auto-incremento que nos permite identificadores únicos para cada banco.

Veja agora mais um trecho de código muito interessante. Trata-se

case 3: // vamos pesquisar uma conta
  System.out.print("\nId, número ou nome cliente da conta: ");
  pesquisaConta = entrada.nextLine();
  // chamamos o método que pesquisa a conta
  temp = pesquisarConta(agenciaAtual, pesquisaConta);
  if(temp == null){ // conta não encotrada
    System.out.println("\nConta não encontrada na agência.");  
  }
  else{
    // mostra a conta encontrada
    System.out.println("\nId da conta bancária: " +
      temp.getId());
    System.out.println("Número da conta: " +
      temp.getNumero());
    System.out.println("Cliente: " + 
      temp.getCliente().getNome());
    System.out.println("Agência: " + agenciaAtual.getNumero() +
      " - " + agenciaAtual.getCidade());
    System.out.println("Banco: " + 
      bancoAtual.getNumero() + " - " + bancoAtual.getNome());
    System.out.println("Saldo atual: " + temp.getSaldo());
    System.out.println("Limite atual: " + temp.getLimite());
  }
        
  break;


Viu que código mais lindo? Note como a Programação Orientada a Objetos em Java nos permite desenvolver idéias de forma bem parecida mesmo ao mundo real.

O fechamento com chave de ouro

O produto final da aplicação Java deverá ser um extrato bancário mostrando os dados da conta escolhida, o histórico de transações com data, tipo da transação e valor, e o saldo atual da conta, com ou sem limite. Veja na imagem abaixo a formatação apresentada (mesmo em modo texto):



Como posso obter este código fonte?

Os links para você baixar todas as versões deste projeto estão abaixo:

1) SBJCNB-A - Sistema Bancário em Java com Código Fonte Versão Console - NetBeans IDE - Faça o Download.

2) SBJCNB-B - Sistema Bancário em Java com Código Fonte Versão Console - Lê e salva os dados em arquivo usando serialização (Serializable), ou seja, os métodos readObject() e writeObject() - NetBeans IDE - Faça o Download.

Não se esqueça: Uma boa forma de estudar o código é fazendo pequenas alterações e rodando para ver os resultados. Outra opção é começar um projeto Java do zero e ir adicionando trechos do código fonte para melhor entendimento de suas partes.


Delphi ::: Data Access Controls (Controles de Acesso a Dados) ::: TField e Classes Derivadas

Como usar a classe TField em seus programas Delphi

Quantidade de visualizações: 12052 vezes
A classe TField (na unit DB) é um ancestral comum de todos os componentes que representam os campos de uma tabela no banco de dados (ou um dataset cujos dados foram carregados de um arquivo do tipo texto, binário ou XML). Esta classe encapsula o comportamento comum a todos os demais componentes to tipo field (campo).

Veja sua posição na hierarquia de classes do Delphi:

System.TObject
  Classes.TPersistent
    Classes.TComponent
      DB.TField
Esta classe ainda implementa as interfaces Classes.IInterfaceComponentReference e System.IInterface.

A classe TField apresenta propriedades, eventos e métodos que são usados para as seguintes tarefas:

1) Alterar o valor de um campo em um dataset;

2) Converter o valor de um campo de um tipo para outro tipo;

3) Efetuar validações nos dados informados pelos usuários para determinados campos;

4) Definir como as informações dos campos são mostradas em tempo de exibição ou para edição;

5) Calcular o valor de um campo a partir de código escrito no evento OnCalcFields do dataset;

6) Pesquisar o valor do campo a partir de outro dataset.

Em geral não criamos instâncias da classe TField diretamente. Componentes que descendem de TField são criados automaticamente a cada vez que o dataset é ativado. Estes descendentes podem ser dinâmicos (o padrão) ou persistentes. Componentes campos dinâmicos refletem as colunas dos metadados da tabela a qual pertencem no momento que o dataset é aberto. Componentes campos persistentes são criados em tempo de design usando o editor Fields, que especifica os campos no dataset, suas propriedades e a ordem em que deverão estar.

A criação de componentes de campos persistentes garante que todas as vezes que uma aplicação for executada, ela usará e exibirá as mesmas colunas, na mesma ordem, até mesmo se a estrutura física da base de dados mudar. Se uma coluna em uma tabela na qual um componente de campo persistente é baseado for excluída ou alterada, o IDE gera uma exceção em vez de permitir a abertura do dataset usando um coluna não existente ou incompatível. Se isso acontecer, devemos remover o camponente field para o campo não existente usando o editor Fields.

Um campo (field) em um dataset é sempre tratado como uma das classes descendentes de TField abaixo:

        
TADTField          TDateField         TReferenceField   
TAggregateField    TDateTimeField     TSmallIntField   
TArrayField        TFloatField        TSQLTimeStampField   
TAutoIncField      TFMTBCDField       TStringField   
TBCDField          TGraphicField      TTimeField   
TBinaryField       TGuidField         TVarBytesField   
TBlobField         TIDispatchField    TVariantField   
TBooleanField      TIntegerField      TWideStringField   
TBytesField        TInterfaceField    TWordField   
TCurrencyField     TLargeintField     TDataSetField   
TMemoField     
Veja um trecho de código no qual usamos o método FieldByName() da classe TDataSet para obter uma referência a um determinado campo (field) de um ClientDataSet e usamos sua propriedade AsString para obter o valor do campo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

procedure TForm3.Button3Click(Sender: TObject);
var
  campo: TField;
begin
  // vamos obter o campo com o nome "titulo" do registro atual
  campo := ClientDataSet1.FieldByName('titulo');

  // vamos mostrar o valor do campo
  ShowMessage('O valor do campo é: ' + campo.AsString);
end;

Ao executarmos este código teremos um resultado parecido com:

"O valor do campo é: Programando em Java".

Esta dica foi escrita e testada no Delphi 2009.


Desafios, Exercícios e Algoritmos Resolvidos de Delphi

Veja mais Dicas e truques de Delphi

Dicas e truques de outras linguagens

Códigos Fonte

Programa de Gestão Financeira Controle de Contas a Pagar e a Receber com Cadastro de Clientes e FornecedoresSoftware de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimento
Diga adeus às planilhas do Excel e tenha 100% de controle sobre suas contas a pagar e a receber, gestão de receitas e despesas, cadastro de clientes e fornecedores com fotos e histórico de atendimentos. Código fonte completo e funcional, com instruções para instalação e configuração do banco de dados MySQL. Fácil de modificar e adicionar novas funcionalidades. Clique aqui e saiba mais
Controle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidadesControle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidades
Tenha o seu próprio sistema de controle de estoque web. com cadastro de produtos, categorias, fornecedores, entradas e saídas de produtos, com relatórios por data, margem de lucro e muito mais. Código simples e fácil de modificar. Acompanha instruções para instalação e criação do banco de dados MySQL. Clique aqui e saiba mais

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: Delphi
6º lugar: C
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby



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