├── bash ├── helloWorld.sh ├── mostraData.sh ├── backup.sh ├── argumentos.sh ├── README.md ├── arquivos │ ├── abrirArquivos.sh │ ├── escreverArquivo.sh │ └── lerConteudoArquivo.sh ├── converteDiaSemana.sh ├── usaTeclado.sh ├── anoBissexto.sh ├── declaraVar.sh ├── escopo.sh ├── lacos.sh ├── vetores.sh └── condicoes.sh ├── mysql ├── README.md ├── populaTabelas.sql ├── funcaoMySQL.sql ├── criaTabelas.sql ├── procedureMySQL.sql └── selecionaDados.sql ├── java ├── README.md ├── MostraData.java ├── Argumentos.java ├── VerificaPostivoNegativo.java ├── arquivos │ ├── EscreverArquivo.java │ ├── AbrirArquivos.java │ ├── LerConteudoArquivo.java │ ├── Arquivo.java │ └── CadastroClientesArquivo.java ├── DeclaraVar.java ├── InverteNumero.java ├── DeclaraVarNumber.java ├── ImprimeNumeros.java ├── Tabuada.java ├── ConverteDiaSemana.java ├── NumerosDivisiveis.java ├── UsaTeclado.java ├── AnoBissexto.java ├── Potencia.java ├── ConsumoCombustivel.java ├── MinhaCalculadora.java ├── PotenciaComum.java ├── CalculadoraTeclado.java ├── Operadores.java ├── Marceneiro.java ├── VetoresCaracteres.java ├── CalculaParcelas.java ├── TipoLiterais.java ├── MinhaCalculadoraArray.java ├── DescobreIndiceVetor.java ├── DeclaraVarOutros.java ├── NumerosDivisiveisFuncao.java ├── NumerosDivisiveisProcedimento.java ├── DeclaraVetores.java ├── VetoresNumeros.java ├── OrdenaVetorBubbleSort.java └── MegaSena.java ├── python ├── argumentos.py ├── inverteNumero.py ├── mostraData.py ├── README.md ├── verificaPostivoNegativo.py ├── arquivos │ ├── escreverArquivo.py │ ├── lerConteudoArquivo.py │ ├── abrirArquivos.py │ └── cadastroClientesArquivo.py ├── declaraVar.py ├── usaTeclado.py ├── anoBissexto.py ├── imprimeNumeros.py ├── tabuada.py ├── numerosDivisiveis.py ├── potencia.py ├── calculadoraTeclado.py ├── minhaCalculadora.py ├── declaraVarNumber.py ├── operadores.py ├── consumoCombustivel.py ├── converteDiaSemana.py ├── vetoresCaracteres.py ├── numerosDivisiveisFuncao.py ├── tipoLiterais.py ├── minhaCalculadoraArray.py ├── marceneiro.py ├── declaraVetores.py ├── calculaParcelas.py ├── declaraVarOutros.py ├── numerosDivisiveisProcedimento.py ├── descobreIndiceVetor.py ├── vetoresNumeros.py ├── ordenaVetorBubbleSort.py └── megaSena.py ├── javascript ├── README.md ├── undefined.html ├── mostraData.html ├── anoBissexto.html ├── tiposDinamicos.html ├── declaraVar.html ├── declaraVarOutros.html ├── usaTeclado.html ├── converteDiaSemana.html ├── valoresEspeciais.html ├── funcoesVetores.html ├── operadoresLogicos.html ├── numerosDivisiveis.html ├── condicoes.html ├── tabuada.html ├── tiposVar.html ├── calculaParcelas.html ├── escopo.html ├── imprimeVetores.html ├── ordenaVetorBubbleSort.html ├── potencia.html ├── soma.html └── vetores.html └── README.md /bash/helloWorld.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Script Bash imprime um texto no na console. 4 | # 5 | # Módulo: Lógica de programação 6 | # Author: Eder Magalhães 7 | 8 | echo "Programando em bash - Hello world" 9 | 10 | -------------------------------------------------------------------------------- /bash/mostraData.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Script Bash demonstra como recuperar a data atual (máquina). 4 | # 5 | # Módulo: Lógica de programação 6 | # Author: Eder Magalhães 7 | 8 | echo 'Data (original): '$(date) 9 | 10 | HOJE=`date +%d/%m/%Y` 11 | echo "Data formatada: " $HOJE 12 | 13 | echo "Data outro formado: " $(date +%D) 14 | 15 | -------------------------------------------------------------------------------- /bash/backup.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Script Bash faz o backup da pasta corrente, coloca o conteúdo em tar.gz na pasta raiz do usuário. 4 | # Utiliza o programa tar. 5 | # 6 | # Módulo: Lógica de programação 7 | # Author: Eder Magalhães 8 | 9 | SRC=* 10 | DEST=~/ 11 | FILE=backup-$(date +%Y%m%d).tar.gz 12 | 13 | tar -czf $DEST$FILE $SRC 14 | 15 | echo "Backup realizado com sucesso!" 16 | -------------------------------------------------------------------------------- /bash/argumentos.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Script Bash demonstra como trabalhar com argumentos passados na console. 4 | # Exemplo de uso: $./argumentos Programa escrito em Bash 5 | # 6 | # Módulo: Lógica de programação 7 | # Author: Eder Magalhães 8 | 9 | # imprime a quantidade de argumentos 10 | echo Número de argumentos: $# 11 | 12 | # imprime todos os argumentos 13 | echo Argumentos: $@ 14 | 15 | -------------------------------------------------------------------------------- /bash/README.md: -------------------------------------------------------------------------------- 1 | Bash (Shell) 2 | ===================== 3 | 4 | Nessa pasta coloquei o código fonte de alguns scripts escritos em Bash. 5 | 6 | A grande maioria desses programas são complementares ao módulo Lógica de Programação do curso Academia do Programador. 7 | 8 | O código fonte pode ser visualizado em qualquer editor texto. 9 | 10 | Esses programas são simples, acionados via terminal. 11 | 12 | -------------------------------------------------------------------------------- /mysql/README.md: -------------------------------------------------------------------------------- 1 | MySQL 2 | ===================== 3 | 4 | Nessa pasta você encontra scripts SQL com comandos para construir instância de banco, tabelas, e gerar os dados para preencher essas tabelas. 5 | 6 | Além das tabelas, também disponibilizei exemplos de procedimentos e funções no MySQL. 7 | 8 | Esses scripts são complementares ao estudo do módulo Banco de dados do curso Academia do Programador. 9 | 10 | -------------------------------------------------------------------------------- /bash/arquivos/abrirArquivos.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Script Bash define uma função para criar e carregar o arquivo teste.txt 4 | # 5 | # Módulo: Lógica de programação 6 | # Author: Eder Magalhães 7 | 8 | # cria um novo arquivo, ou substitui se já existir 9 | > teste.txt 10 | 11 | # se existir mantém o conteúdo, senão cria um novo arquivo 12 | >> teste.txt 13 | 14 | echo "Programa carregou 2x o arquivo teste.txt" 15 | 16 | -------------------------------------------------------------------------------- /bash/arquivos/escreverArquivo.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Script Bash adiciona conteúdo ao arquivo teste.txt. 4 | # 5 | # Módulo: Lógica de programação 6 | # Author: Eder Magalhães 7 | 8 | nomeArquivo="teste.txt"; 9 | 10 | echo "Olá, este é meu primeiro arquivo" >> $nomeArquivo; 11 | echo "Testando gravação de dados em arquivo texto (em Bash)." >> $nomeArquivo; 12 | 13 | echo "Conteúdo foi armazenado no arquivo " $nomeArquivo "!"; 14 | 15 | -------------------------------------------------------------------------------- /java/README.md: -------------------------------------------------------------------------------- 1 | Java 2 | ===================== 3 | 4 | Nessa pasta coloquei o código fonte de alguns programas escritos com a linguagem Java. 5 | 6 | A grande maioria desses programas são complementares ao módulo Lógica de Programação do curso Academia do Programador. 7 | 8 | O código fonte pode ser visualizado em qualquer editor texto. 9 | 10 | Esses programas são simples, eles devem ser acionados via terminal (console) ou sua IDE preferida. 11 | 12 | -------------------------------------------------------------------------------- /python/argumentos.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # Programa Python demonstra como trabalhar com argumentos passados na console. 4 | # Exemplo de uso: $ python argumentos.py Programa escrito em Python 5 | # 6 | # Módulo: Lógica de programação 7 | # Author: Eder Magalhães 8 | 9 | import sys 10 | () 11 | # imprime a quantidade de argumentos 12 | print "Número de argumentos: ", len(sys.argv) 13 | 14 | # imprime todos os argumentos 15 | print 'Argumentos: ', str(sys.argv); 16 | 17 | -------------------------------------------------------------------------------- /python/inverteNumero.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # Programa Python demonstra como inverter um número inteiro. 4 | # 5 | # Acesse e execute esse código Python em: http://pythonfiddle.com/inverte-numero-ap/ 6 | # 7 | # Módulo: Lógica de programação 8 | # Author: Eder Magalhães 9 | 10 | numero = int(raw_input("Entre com o nũmero... ")); 11 | print "Número informado ",numero 12 | 13 | numeroInvertido = int(str(numero)[::-1]); 14 | 15 | print "O número invertido: ",numeroInvertido 16 | 17 | 18 | -------------------------------------------------------------------------------- /bash/arquivos/lerConteudoArquivo.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Script Bash le o conteúdo do arquivo teste.txt. 4 | # 5 | # Módulo: Lógica de programação 6 | # Author: Eder Magalhães 7 | 8 | nomeArquivo="teste.txt"; 9 | 10 | echo -e "Início do conteúdo do arquivo " $nomeArquivo ".\n" 11 | echo "--------------------------------------" 12 | 13 | cat $nomeArquivo | while read line 14 | do 15 | echo $line 16 | done 17 | 18 | echo "--------------------------------------" 19 | echo -e "\nFim do conteúdo do arquivo " nomeArquivo "." 20 | -------------------------------------------------------------------------------- /javascript/README.md: -------------------------------------------------------------------------------- 1 | JavaScript 2 | ===================== 3 | 4 | Nessa pasta coloquei o código fonte de alguns programas escritos com a linguagem JavaScript. 5 | 6 | A grande maioria desses programas são complementares ao módulo Lógica de Programação e Redes e Internet do curso Academia do Programador. 7 | 8 | Os programas foram escritos em arquito html (tag 24 | 25 | 26 | 27 | 28 | 29 | -------------------------------------------------------------------------------- /python/potencia.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # Programa Python calcula a potência a partir de um nro base e expoente. 4 | # O calcula de potência desse programa só se aplica a nros positivos. 5 | # 6 | # Demonstra como utilizar recursividade. 7 | # 8 | # Objetivos: 9 | # - exercício de lógica; 10 | # 11 | # Acesse e execute esse código Python em: http://pythonfiddle.com/potencia-positivos-ap/ 12 | # 13 | # Módulo: Lógica de programação 14 | # Author: Eder Magalhães 15 | 16 | def calculaPotencia(exp, base): 17 | if (exp == 0): 18 | return 1; 19 | 20 | exp -= 1; 21 | return base * calculaPotencia(exp, base); 22 | 23 | base = int(raw_input("Informe a base: ")); 24 | expoente = int(raw_input("Informe o expoente: ")); 25 | 26 | if (base < 0): 27 | print "Programa só calcula com base positiva!"; 28 | else: 29 | resultado = calculaPotencia(expoente, base); 30 | print "\nResultado de ", base, " ^ ", expoente, " = ", resultado; 31 | 32 | -------------------------------------------------------------------------------- /javascript/mostraData.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | JavaScript - Exemplo como recuperar a data da máquina (navegador) 6 | 7 | 21 | 22 | 23 | 24 | 25 | 26 | -------------------------------------------------------------------------------- /python/calculadoraTeclado.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # Programa Python implementa uma calculadora simples, com entrada via teclado. 4 | # Objetivos: 5 | # - uso do teclado e múltiplas condições. 6 | # 7 | # Módulo: Lógica de programação 8 | # Author: Eder Magalhães 9 | 10 | x = int(raw_input("Informe o operando 1:\n")); 11 | 12 | operacao = raw_input("Entre com a operacao, escolha os símbolos + - * /\n"); 13 | 14 | y = int(raw_input("Informe o operando 2:\n")); 15 | 16 | if operacao == '+': 17 | resultado = x + y; 18 | nomeOperacao = "soma"; 19 | elif operacao == '-': 20 | resultado = x - y; 21 | nomeOperacao = "subtracao"; 22 | elif operacao == '*': 23 | resultado = x * y; 24 | nomeOperacao = "multiplicacao"; 25 | elif operacao == '/': 26 | resultado = x / y; 27 | nomeOperacao = "divisao"; 28 | else: 29 | resultado = 0; 30 | nomeOperacao = "operacao invalida"; 31 | 32 | print "Resultado da %s = %s" % (nomeOperacao, resultado); 33 | 34 | -------------------------------------------------------------------------------- /java/arquivos/EscreverArquivo.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java usa o componente Arquivo para escrever (adicionar) conteúdo no arquivo teste.txt 3 | * O arquivo manipulado por esse programa fica contido no diretório corrente. 4 | * 5 | * Objetivos: 6 | * - escrever conteúdo no arquivo da pasta corrente. 7 | * 8 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 9 | * Author: Eder Magalhães 10 | */ 11 | 12 | public class EscreverArquivo { 13 | 14 | public static void main(String[] args) { 15 | String nomeArquivo = "teste.txt"; 16 | Arquivo meuArquivo = Arquivo.abrirEscrita(nomeArquivo, "append"); 17 | 18 | Arquivo.escrever(meuArquivo, "Olá, este é meu primeiro arquivo"); 19 | Arquivo.escrever(meuArquivo, "Testando gravação de dados em arquivo texto (em Java)."); 20 | 21 | Arquivo.fechar(meuArquivo); 22 | 23 | System.out.println("Conteúdo foi armazenado no arquivo " + nomeArquivo + "!"); 24 | } 25 | 26 | } 27 | -------------------------------------------------------------------------------- /python/minhaCalculadora.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # Programa Python implementa uma calculadora, com uma função para cada operação básica. 4 | # Objetivos: 5 | # - uso de funções, variáveis e escopo; 6 | # 7 | # Módulo: Lógica de programação 8 | # Author: Eder Magalhães 9 | 10 | def somar(x, y): 11 | resultado = x + y; 12 | return resultado; 13 | 14 | def subtrair(x, y): 15 | resultado = x - y; 16 | return resultado; 17 | 18 | def dividir(y, x): 19 | div = y / x; 20 | return div; 21 | 22 | def multiplicar(a, b): 23 | return a * b; 24 | 25 | 26 | x = somar(10, 20); 27 | print "Resultado da 1a soma: ", x 28 | 29 | y = somar(30, 40); 30 | print "Resultado da 2a soma: ", y 31 | 32 | total = somar(x, y); 33 | print "Resultado final: ", total 34 | 35 | a = subtrair(50, 2); 36 | print "Resultado da divisão: ", a 37 | 38 | w = multiplicar(15, 3); 39 | print "Resultado da multiplicação: ", w 40 | 41 | z = subtrair(5, 7); 42 | print "Resultado da subtração: ", z; 43 | -------------------------------------------------------------------------------- /bash/declaraVar.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Script demonstra como declarar variáveis em Bash. 4 | # 5 | # Módulo: Lógica de programação 6 | # Author: Eder Magalhães 7 | 8 | # define as variáveis com atribuição (sem declare) 9 | NUMERO=10 10 | TEXTO="Bash Script"; 11 | OUTRO_TEXTO='Programando'; 12 | CONDICAO=true 13 | VETOR=('B','A','S','H'); 14 | TAXA=5.6; 15 | 16 | # imprime o conteúdo das variáveis na console 17 | echo $NUMERO; 18 | echo $TEXTO 19 | echo $OUTRO_TEXTO; 20 | echo $CONDICAO; 21 | echo $VETOR; 22 | echo $TAXA; 23 | 24 | # variável não declarada, imprime vazio... 25 | echo $MINHA_VAR; 26 | 27 | # instruções declaram variavel antes de atribuir 28 | declare -i X; # inteiro 29 | echo "X=$X" 30 | X=1; # atribui 31 | echo "X=$X" 32 | let "X=2" # atribui com o comando let 33 | echo "X=$X" 34 | 35 | declare -r LEITURA='Read-only'; #var somente leitura 36 | echo $LEITURA; 37 | # LEITURA='x'; # não permite 38 | 39 | # declara e atribui o home do usuário 40 | declare | grep HOME 41 | echo $HOME 42 | 43 | -------------------------------------------------------------------------------- /javascript/anoBissexto.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | JavaScript - Exemplo de função que verifica se o ano é bissexto no JavaScript 6 | 7 | 26 | 27 | 28 | 29 | 30 | 31 | -------------------------------------------------------------------------------- /python/declaraVarNumber.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # Programa Python demonstra como declarar variáveis numéricas: inteira e ponto flutuante. 4 | # Note que em Python não é necessário definir a variável e seu tipo! 5 | # Python é uma linguagem tipada dinamicamente. 6 | # 7 | # Objetivos: 8 | # - declaração de variáveis numéricas; 9 | # 10 | # Módulo: Lógica de programação 11 | # Author: Eder Magalhães 12 | 13 | # numeros inteiros, todos int 14 | idade = 40; 15 | kmDistancia = 600; 16 | qtdeClientes = 39000; 17 | habitantesChina = int(1300000000); 18 | 19 | print "Idade: ", idade; 20 | print "kmDistancia: ", kmDistancia; 21 | print "Qtde de clientes: ", qtdeClientes; 22 | print "Habitantes na china (aproximadamente): ", habitantesChina; 23 | print 24 | 25 | # numeros ponto flutuante, todos float 26 | nota = 7.56; 27 | salario = float(2500.7); 28 | 29 | print "Nota: ", nota; 30 | print "Salario: ", salario; 31 | 32 | # mudança do tipo da variável em Python ... 33 | idade = 39.8; 34 | print "Nova idade: ", idade 35 | 36 | -------------------------------------------------------------------------------- /bash/escopo.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Script Bash demonstra como funciona o escopo de variáveis (global e local). 4 | # 5 | # Módulo: Lógica de programação 6 | # Author: Eder Magalhães 7 | 8 | declare VAR_GLOBAL; 9 | 10 | function funcaoInicial() { 11 | local VAR_INICIAL="Variável declarada em funcaoInicial."; 12 | echo "$VAR_INICIAL"; 13 | } 14 | 15 | function funcaoFinal() { 16 | local VAR_FINAL="Variável declara em funcaoFinal"; 17 | VAR_GLOBAL="Modificada em funcaoFinal"; 18 | VAR_X=1 19 | return 1; 20 | } 21 | 22 | echo "VAR_GLOBAL = " $VAR_GLOBAL # vazio 23 | echo 24 | 25 | echo 'Chamando a funcaoInicial' 26 | resultado=$(funcaoInicial); # uma das formas de recuperar o retorno da função 27 | echo "resultado = " $resultado; 28 | echo "VAR_INICIAL = "$VAR_INICIAL; # vazio 29 | echo 30 | 31 | echo 'Atribuindo teste p/ a variável VAR_GLOBAL'; 32 | VAR_GLOBAL='teste'; 33 | echo "VAR_GLOBAL = " $VAR_GLOBAL 34 | echo 35 | 36 | echo 'Chamando a funcaoFinal' 37 | funcaoFinal; 38 | echo "VAR_GLOBAL = " $VAR_GLOBAL 39 | -------------------------------------------------------------------------------- /java/DeclaraVar.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa demonstra opções para declarar variáveis em Java. 3 | * 4 | * Objetivos: 5 | * - declaração de variáveis; 6 | * 7 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 8 | * Author: Eder Magalhães 9 | */ 10 | public class DeclaraVar { 11 | 12 | public static void main(String[] args) { 13 | int numero; //definição 14 | numero = 10; 15 | 16 | int contador = 1; //definição e atribuição 17 | 18 | //definição de múltiplas variáveis do mesmo tipo 19 | int a, b, c; 20 | a = b = c = 2; //atribuição do mesmo valor 21 | 22 | //exibe o conteúdo das variáveis 23 | System.out.println("Numero = " + numero); 24 | System.out.println("Contador = " + contador); 25 | System.out.println("a = " + a + ", b = " + b + ", c = " + c); 26 | 27 | //definição e atribuição de multiplas vars 28 | int x = 5, y = 7, z = 9; 29 | System.out.println("x = " + x + ", y = " + y + ", z = " + z); 30 | } 31 | 32 | } 33 | -------------------------------------------------------------------------------- /java/InverteNumero.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java demonstra um algoritmo simples para inverter um número inteiro. 3 | * 4 | * Objetivos: 5 | * - uso de comando for (repetição); 6 | * - operações matemáticas simples; 7 | * - uso do printf para formatar o valor inteiro 8 | * 9 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 10 | * Author: Eder Magalhães 11 | */ 12 | 13 | import java.util.Scanner; 14 | 15 | public class InverteNumero { 16 | 17 | public static void main(String[] args) { 18 | Scanner teclado = new Scanner(System.in); 19 | 20 | System.out.print("Entre com o nũmero... "); 21 | int numero = teclado.nextInt(); 22 | System.out.printf("Número informado %s%n", numero); 23 | 24 | int numeroInvertido = 0; 25 | while (numero > 0) { 26 | numeroInvertido *= 10; 27 | numeroInvertido += (numero % 10); 28 | numero /= 10; 29 | } 30 | 31 | System.out.printf("O número invertido: %s%n", numeroInvertido); 32 | } 33 | 34 | } 35 | -------------------------------------------------------------------------------- /javascript/tiposDinamicos.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | JavaScript - Exemplo de como funciona a tipagem dinâmica em JS 6 | 7 | 27 | 28 | 29 | 30 | 31 | 32 | -------------------------------------------------------------------------------- /python/operadores.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # Programa Python demonstra o uso de operadores em variáveis. 4 | # 5 | # Objetivos: 6 | # - declaração de variáveis; 7 | # - uso de operadores básicos; 8 | # 9 | # Módulo: Lógica de programação 10 | # Author: Eder Magalhães 11 | 12 | x = 5 + 3 * 4 / 2 - 1; 13 | print "5 + 3 * 4 / 2 - 1 = ", x; 14 | 15 | a, b, c = 5, 2, 2 * 2; 16 | 17 | resultado1 = a * 6 + b * 5; 18 | print "5 * 6 + 2 * 5 = ", resultado1; 19 | 20 | resultado2 = a * (6 + b) * 5; 21 | print "5 * (6 + 2) * 5 = ", resultado2; 22 | 23 | resultado3 = a * (6 + b * 5); 24 | print "5 * (6 + 2 * 5) = ", resultado3; 25 | 26 | resultado4 = 20 / b * 3; 27 | print "20 / 2 * 3 = ", resultado4; 28 | 29 | # divisao de inteiro, gera inteiro 30 | divInteiro = 7 / 2; 31 | print "7 / 2 = ", divInteiro; 32 | 33 | restoDivInteiro = 7 % 2; 34 | print "resto de 7 / 2 = ", restoDivInteiro; 35 | 36 | # divisao de float, gera float 37 | divFlutuante = float(7.0) / 2; 38 | print "7.0 / 2 = ", divFlutuante; 39 | 40 | x += 1; 41 | print "Incremento de x = ", x 42 | -------------------------------------------------------------------------------- /bash/lacos.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Script Bash demonstra como utilizar laços (repetições). 4 | # 5 | # Módulo: Lógica de programação 6 | # Author: Eder Magalhães 7 | 8 | echo 'Testando for in:' 9 | # for in com nros pre-definidos 10 | for index in 1 2 3 4 5 11 | do 12 | printf "\t%s\n" "${index}" 13 | done 14 | 15 | declare -i CONTADOR; 16 | CONTADOR=10 17 | 18 | echo -e '\nTestando while:' 19 | # usa o operador 'maior que' 20 | while [ $CONTADOR -gt 0 ]; do 21 | printf "\tContador: %s\n" $CONTADOR 22 | ((CONTADOR--)); 23 | done 24 | 25 | echo -e -n "\nTestando until: " 26 | var=0; 27 | until ((var > 10)) 28 | do 29 | echo -n "$var " 30 | (( var++ )) 31 | done 32 | 33 | echo 34 | 35 | echo -e -n '\nTestando for in com letras: ' 36 | # usa a função echo, que já resolve a impressão de letras em sequência 37 | for l in `echo {a..f}`; 38 | do 39 | echo -n "$l " 40 | done 41 | echo 42 | 43 | # lista o conteudo do diretorio home 44 | echo -e "\n Conteúdo do diretório home do usuário" 45 | for f in $( ls ~ ); do 46 | echo -e "\t" $f 47 | done 48 | 49 | -------------------------------------------------------------------------------- /java/DeclaraVarNumber.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java demonstra como declarar variáveis numéricas: inteira e ponto flutuante. 3 | * 4 | * Objetivos: 5 | * - declaração de variáveis numéricas; 6 | * 7 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 8 | * Author: Eder Magalhães 9 | */ 10 | public class DeclaraVarNumber { 11 | 12 | public static void main(String[] args) { 13 | //definição de variáveis numéricas, c/ os 4 tipos inteiros 14 | byte idade = 40; 15 | short kmDistancia = 600; 16 | int qtdeClientes = 39000; 17 | long habitantesChina = 1300000000L; 18 | 19 | System.out.println("Idade: " + idade); 20 | System.out.println("kmDistancia: " + idade); 21 | System.out.println("Qtde de clientes: " + qtdeClientes); 22 | System.out.println("Habitantes na china (aproximadamente): " + habitantesChina); 23 | 24 | float nota = 7.56f; 25 | double salario = 2500.7; 26 | 27 | System.out.println("Nota: " + nota); 28 | System.out.println("Salario: " + salario); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /javascript/declaraVar.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | JavaScript - Exemplo de declaração de variáveis básicas 6 | 7 | 27 | 28 | 29 | 30 | 31 | 32 | -------------------------------------------------------------------------------- /javascript/declaraVarOutros.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | JavaScript - Exemplo de declaração de variáveis complementares 6 | 7 | 26 | 27 | 28 | 29 | 30 | 31 | -------------------------------------------------------------------------------- /mysql/populaTabelas.sql: -------------------------------------------------------------------------------- 1 | /* 2 | * Script SQL com comandos (DML) para preencher a base de dados de clientes e pedidos. 3 | * 4 | * Módulo: Banco de dados 5 | * Autor: Eder Magalhães 6 | */ 7 | 8 | USE ap; 9 | 10 | /* Inserção de 3 clientes. */ 11 | INSERT INTO cliente (nome, email) VALUES ('Carlos Jose', 'carlos@uol.com.br'); 12 | INSERT INTO cliente (nome, email) VALUES ('Maria Paula', 'paula@gmail.com'); 13 | INSERT INTO cliente (nome, email) VALUES ('Claudia', 'claudia@ig.com.br'); 14 | 15 | /* Insere 2 pedidos, o primeiro do Carlos Jose e o segundo da Maria Paula. */ 16 | INSERT INTO pedido (dataPedido, idCliente) VALUES (SYSDATE(), 1); /* carlos */ 17 | INSERT INTO pedido (dataPedido, idCliente) VALUES (SYSDATE(), 2); /* maria */ 18 | 19 | /* Insere um item no pedido do Carlos Jose */ 20 | INSERT INTO pedido_item (descricao, preco, idPedido) VALUES ('Camisa', 120.5, 1); 21 | 22 | /* Insere dois itens no pedido da Maria Paula */ 23 | INSERT INTO pedido_item (descricao, preco, idPedido) VALUES ('Livro', 50.7, 2); 24 | INSERT INTO pedido_item (descricao, preco, idPedido) VALUES ('Calça', 220.2, 2); 25 | 26 | -------------------------------------------------------------------------------- /python/consumoCombustivel.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # Programa Python calcula o consumo médio de um carro (km por hora) a partir das informações: 4 | # - quantidade de gasolina no tanque; 5 | # - quantidade de horas percorridas; 6 | # - velocidade média; 7 | # 8 | # Acesse e execute esse código Python em: http://pythonfiddle.com/consumo-combustivel-ap/ 9 | # 10 | # Objetivos: 11 | # - exercício de lógica; 12 | # 13 | # Módulo: Lógica de programação 14 | # Author: Eder Magalhães 15 | 16 | tanqueGasolina = int(raw_input("Informe a quantidade de gasolina no tanque: ")); 17 | 18 | horasPercorridas = int(raw_input("Ok, agora informe quantas horas foram precorridas: ")); 19 | 20 | velocidadeMedia = int(raw_input("Por fim me diga qual era a velocidade média: ")); 21 | 22 | if (tanqueGasolina < 1 or horasPercorridas < 1 or velocidadeMedia < 1): 23 | print "Entre com dados validos!"; 24 | else : 25 | #calculo para descobrir o valor 26 | kmMedia = velocidadeMedia * horasPercorridas / float(tanqueGasolina); 27 | 28 | print "\nO consumo médio foi de ", kmMedia, " km percorridos por litro"; 29 | 30 | -------------------------------------------------------------------------------- /javascript/usaTeclado.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | JavaScript - Exemplo de como entrar com os dados no JavaScript 6 | 7 | 25 | 26 | 27 | 28 | 29 | 30 | -------------------------------------------------------------------------------- /java/ImprimeNumeros.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java imprime um determinado intervalo de números. 3 | * 4 | * Objetivos: 5 | * - uso de repetições com o comando while; 6 | * - uso dos operadores de pós incremento (+1) e decremento (-1); 7 | * 8 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 9 | * Author: Eder Magalhães 10 | */ 11 | public class ImprimeNumeros { 12 | 13 | public static void main(String args[]) { 14 | int numeroInicio = 1; 15 | int numeroFim = 10; 16 | 17 | System.out.println("Os numeros de "+numeroInicio+" até "+numeroFim+" (ascendente):"); 18 | //logica: enquanto o nro inicial for menor ou igual ao nro final 19 | while (numeroInicio <= numeroFim) { 20 | System.out.println("\t "+numeroInicio++); 21 | } 22 | 23 | //volta o valor da variavel inicial 24 | numeroInicio = 1; 25 | 26 | System.out.println("\nOs numeros de "+numeroInicio+" até "+numeroFim+" (descendente):"); 27 | while (numeroFim >= numeroInicio) { 28 | System.out.println("\t "+numeroFim--); 29 | } 30 | } 31 | 32 | } 33 | -------------------------------------------------------------------------------- /python/converteDiaSemana.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # Programa Python retorna o dia da semana em extenso. Domingo igual 1 e Sábado 7. 4 | # Python não possui switch, utilizo if c/ elif no lugar. 5 | # Objetivos: 6 | # - uso de multiplas condições boolean; 7 | # 8 | # Acesse e execute esse código Python em: http://pythonfiddle.com/converte-dia-semana-ap/ 9 | # 10 | # Módulo: Lógica de programação 11 | # Author: Eder Magalhães 12 | 13 | # modifique essa variável para testar o programa 14 | diaSemana = 2; 15 | dia = ""; 16 | 17 | if diaSemana == 1: 18 | dia = "Domingo"; 19 | elif diaSemana == 2: 20 | dia = "Segunda-feira"; 21 | elif diaSemana == 3: 22 | dia = "Terça-feira"; 23 | elif diaSemana == 4: 24 | dia = "Quinta-feira"; 25 | elif diaSemana == 5: 26 | dia = "Quarta-feira"; 27 | elif diaSemana == 6: 28 | dia = "Sexta-feira"; 29 | elif diaSemana == 7: 30 | dia = "Sabado"; 31 | else: 32 | dia = "Dia invalido!"; 33 | 34 | # complementa, armazena se é dia útil ou fim de semana 35 | if diaSemana in (2, 3, 4, 5): 36 | dia += " (dia útil)" 37 | elif diaSemana in (1,7): 38 | dia += " (fim de semana)" 39 | 40 | print dia 41 | 42 | -------------------------------------------------------------------------------- /python/vetoresCaracteres.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # Programa Python demonstra como declarar e navegar vetores de caracteres. 4 | # Um dos diferenciais do Python é a flexibilidade em lidar com vetores. 5 | # 6 | # Objetivos: 7 | # - uso de arrays que armazenam caracteres; 8 | # - uso do comando for para preencher arrays; 9 | # - uso da função xrange para definir os limites do for; 10 | # 11 | # Acesse e execute esse código Python em: http://pythonfiddle.com/vetores-caracteres-ap/ 12 | # 13 | # Módulo: Lógica de programação 14 | # Author: Eder Magalhães 15 | 16 | vogais = [ 'a', 'e', 'i', chr(111), 'u' ]; 17 | 18 | # imprime o array de forma natural 19 | print vogais; 20 | 21 | # array inicialmente está vazio, é carregado no for abaixo 22 | alfabetoMaiusculo = []; 23 | 24 | for l in xrange(ord('Z'), ord('A')-1, -1): 25 | alfabetoMaiusculo.append(chr(l)); 26 | 27 | # usa a função join da string pra concatenar o conteúdo do array 28 | print "Conteúdo do array alfabetoMaiusculo: ", ' '.join(alfabetoMaiusculo); 29 | 30 | palavras = ["Programando", "arrays", "em", "Python"]; 31 | 32 | print "Conteúdo do array palavras: ", ' '.join(palavras); 33 | 34 | -------------------------------------------------------------------------------- /java/arquivos/AbrirArquivos.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java usa o componente Arquivo para abrir o arquivo teste.txt de várias formas. 3 | * O arquivo manipulado por esse programa fica contido no diretório corrente. 4 | * 5 | * Objetivos: 6 | * - carregar arquivo na pasta corrente. 7 | * 8 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 9 | * Author: Eder Magalhães 10 | */ 11 | 12 | public class AbrirArquivos { 13 | 14 | public static void main(String[] args) { 15 | //cria e abre um novo arquivo 16 | Arquivo a = Arquivo.abrirEscrita("teste.txt", "new"); 17 | 18 | //abre um arquivo que ja existia, e limpa seu conteudo 19 | Arquivo b = Arquivo.abrirEscrita("teste.txt", "truncate"); 20 | 21 | //abre um arquivo que ja existia e mantem seu conteudo 22 | Arquivo c = Arquivo.abrirEscrita("teste.txt", "append"); 23 | 24 | Arquivo d = Arquivo.abrirLeitura("teste.txt"); 25 | 26 | //fecha os arquivos 27 | Arquivo.fechar(a); 28 | Arquivo.fechar(b); 29 | Arquivo.fechar(c); 30 | Arquivo.fechar(d); 31 | 32 | System.out.println("Programa carregou e fechou 4x o arquivo teste.txt"); 33 | } 34 | 35 | } 36 | -------------------------------------------------------------------------------- /python/numerosDivisiveisFuncao.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # Programa Python demonstra como é possível utilizar uma função (function) 4 | # para calcular números divisiveis em um determinado range de valores. 5 | # 6 | # Lembre-se que em Python a identação é fundamental para delimitar início e fim dos blocos. 7 | # 8 | # Objetivos: 9 | # - uso de funções para realizar um cálculo; 10 | # 11 | # Módulo: Lógica de programação 12 | # Author: Eder Magalhães 13 | 14 | # inicio da função 15 | def calculaDivisiveis(minimo, maximo, divisor): 16 | contador = 0; 17 | 18 | for n in range(minimo, maximo+1): 19 | if n % divisor == 0: 20 | contador += 1; 21 | 22 | return contador; 23 | # fim da função 24 | 25 | valorMinimo = 10; 26 | valorMaximo = 1000; 27 | div = 10; 28 | 29 | print "Identificando divisiveis por 10 entre 100 e 1000"; 30 | 31 | # chama a função 32 | total = calculaDivisiveis(valorMinimo, valorMaximo, div); 33 | 34 | print "\nQtos números são divisiveis por", div, " ? ", total; 35 | 36 | print "\nIdentificando divisiveis por 2 entre 1 e 10" 37 | 38 | # chama função, com argumentos diferentes, na hora de imprimir 39 | print "\nQtos números são divisiveis por 2 ? ", calculaDivisiveis(1, 10, 2); 40 | 41 | -------------------------------------------------------------------------------- /python/tipoLiterais.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # Programa Python demonstra opções de literais suportas pela linguagem. 4 | # Python permite trabalhar com números utilizando literais decimal, octal e binária. 5 | # Com strings Python suporta unicode. 6 | # 7 | # Objetivos: 8 | # - uso de literais suportadas pelo Python; 9 | # 10 | # Acesse e execute esse código Python em: http://pythonfiddle.com/tipos-literais-ap/ 11 | # 12 | # Módulo: Lógica de programação 13 | # Author: Eder Magalhães 14 | 15 | decimal = 10; # literal decimal 16 | octal = 012; # literal octal, base 8 17 | hexadecimal = 0xA; # literal hexadecimal, base 16 18 | binario = 0b1010; # literal binaria 19 | 20 | print "octal = ", octal; # imprime como decimal 21 | print "hexadecimal = ", hexadecimal; # tb imprime como decimal 22 | print "binario = ", binario 23 | 24 | print "10 em hexadecimal: ", hex(decimal); 25 | print "10 em binário: ", bin(decimal); 26 | print "10 em octal: ", oct(decimal); 27 | 28 | letraA = chr(65); # codigo ASCII 29 | letraB = 'B'; # literal char 30 | letraC = u'\u0043'; # literal Unicode 31 | especial = u'\u262F'; 32 | 33 | print "letraA = ", letraA; 34 | print "letraB = ", letraB 35 | print "letraC = ", letraC 36 | print "especial = ", especial 37 | 38 | -------------------------------------------------------------------------------- /javascript/converteDiaSemana.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | JavaScript - Exemplo mostra o nome do dia por extenso com JavaScript 6 | 7 | 32 | 33 | 34 | 35 | 36 | 37 | -------------------------------------------------------------------------------- /java/Tabuada.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java calcula a taboada de um determinado número. 3 | * 4 | * Objetivos: 5 | * - exercício de lógica; 6 | * - uso do comando for (repetição); 7 | * 8 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 9 | * Author: Eder Magalhães 10 | */ 11 | 12 | import java.util.Scanner; 13 | 14 | public class Tabuada { 15 | 16 | public static void main(String[] args) { 17 | Scanner teclado = new Scanner(System.in); 18 | 19 | System.out.print("Informe o número para calcular a tabuada: "); 20 | int numero = teclado.nextInt(); 21 | calculaTabuada(numero); 22 | } 23 | 24 | /* 25 | * Calcula da tabuada do número informado como argumento. 26 | */ 27 | static void calculaTabuada(int n) { 28 | if (n <= 0) { 29 | System.out.println("Informe um número válido para calcular a tabuada!"); 30 | return; 31 | } 32 | 33 | System.out.println("Calculando tabuada do " + n + "..."); 34 | 35 | for (int multiplicador = 1; multiplicador <= 10; multiplicador++) { 36 | int resultado = multiplicador * n; 37 | System.out.println(n+" x "+multiplicador+" = "+resultado); 38 | } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /java/arquivos/LerConteudoArquivo.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java usa o componente Arquivo para ler o conteúdo do arquivo teste.txt 3 | * O arquivo manipulado por esse programa fica contido no diretório corrente. 4 | * 5 | * Objetivos: 6 | * - ler o conteúdo no arquivo da pasta corrente. 7 | * 8 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 9 | * Author: Eder Magalhães 10 | */ 11 | public class LerConteudoArquivo { 12 | 13 | public static void main(String[] args) { 14 | String nomeArquivo = "teste.txt"; 15 | Arquivo meuArquivo = Arquivo.abrirLeitura(nomeArquivo); 16 | 17 | System.out.println("Início do conteúdo do arquivo " + nomeArquivo + ".\n"); 18 | System.out.println("--------------------------------------"); 19 | 20 | String linha = Arquivo.lerLinha(meuArquivo); 21 | //enquanto existir conteúdo, imprima 22 | while (linha != null) { 23 | System.out.println(linha); 24 | linha = Arquivo.lerLinha(meuArquivo); 25 | } 26 | 27 | Arquivo.fechar(meuArquivo); 28 | System.out.println("--------------------------------------"); 29 | System.out.println("\nFim do conteúdo do arquivo " + nomeArquivo + "."); 30 | } 31 | 32 | } 33 | -------------------------------------------------------------------------------- /javascript/valoresEspeciais.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | JavaScript - Exemplo de uso de null, undefined e vazio em JavaScript 6 | 7 | 28 | 29 | 30 | 31 | 32 | 33 | -------------------------------------------------------------------------------- /python/minhaCalculadoraArray.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # Programa Python implementa uma calculadora, com uma função para cada operação básica. 4 | # Objetivos: 5 | # - uso de funções, variáveis e escopo; 6 | # 7 | # Módulo: Lógica de programação 8 | # Author: Eder Magalhães 9 | 10 | # Soma todos os elementos contidos no array. 11 | def somar(numeros): 12 | # é possível utilizar uma função pré-definida do python 13 | return sum(numeros); 14 | 15 | # Considera o 1o elemento e subtrai o restante. 16 | def subtrair(nros): 17 | if len(nros) == 0: 18 | return 0; 19 | 20 | resultado = nros[0]; 21 | 22 | for n in range(1, len(nros)): 23 | resultado -= nros[n]; 24 | return resultado; 25 | 26 | x = [10, 20, 5]; 27 | totalSoma = somar(x); 28 | print "Resultado da 1a soma: ", totalSoma; 29 | 30 | totalSoma = somar([2, 3]); 31 | print "Resultado da 2a soma: ", totalSoma; 32 | 33 | y = []; # array vazio 34 | print "Resultado da 3a soma: ", somar(y); 35 | 36 | w = [5, 3, 1]; 37 | totalSubtrair = subtrair(w); 38 | print "Resultado da 1a subtração: ", totalSubtrair; 39 | 40 | totalSubtrair = subtrair([50, 25, 30, 5]); 41 | print "Resultado da 2a subtração: ", totalSubtrair; 42 | 43 | # array vazio 44 | print "Resultado da 3a subtração: ", subtrair([]); 45 | 46 | -------------------------------------------------------------------------------- /java/ConverteDiaSemana.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java retorna o dia da semana em extenso. Domingo igual 1 e Sábado 7. 3 | * 4 | * Objetivos: 5 | * - uso de variáveis e switch (múltiplas condições); 6 | * 7 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 8 | * Author: Eder Magalhães 9 | */ 10 | public class ConverteDiaSemana { 11 | 12 | public static void main(String[] args) { 13 | //modifique essa variável para testar o programa 14 | int diaSemana = 2; 15 | String dia = ""; 16 | 17 | //armazena o dia 18 | switch(diaSemana) { 19 | case 1: dia = "Domingo"; break; 20 | case 2: dia = "Segunda-feira"; break; 21 | case 3: dia = "Terça-feira"; break; 22 | case 4: dia = "Quarta-feira"; break; 23 | case 5: dia = "Quinta-feira"; break; 24 | case 6: dia = "Sexta-feira"; break; 25 | case 7: dia = "Sabado"; break; 26 | default: dia = "Dia invalido!"; 27 | } 28 | 29 | //armazena se é dia útil ou fim de semana 30 | switch(diaSemana) { 31 | case 2: 32 | case 3: 33 | case 4: 34 | case 5: 35 | case 6: dia += " (dia útil)"; break; 36 | case 1: 37 | case 7: dia += " (fim de semana)"; break; 38 | } 39 | System.out.println(dia); 40 | } 41 | 42 | } 43 | 44 | -------------------------------------------------------------------------------- /java/NumerosDivisiveis.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java realiza comparações em um determinado range de números. 3 | * 4 | * Objetivos: 5 | * - uso de variáveis, while (repetição), if (condicional) e escopo; 6 | * 7 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 8 | * Author: Eder Magalhães 9 | */ 10 | public class NumerosDivisiveis { 11 | 12 | public static void main(String[] args) { 13 | int numeroDe = 100; 14 | int numeroAte = 2556; 15 | 16 | System.out.println("Resumo de divisiveis entre " + numeroDe + " e " + numeroAte); 17 | 18 | int pares = 0; 19 | int impares = 0; 20 | int divPorCinco = 0; 21 | 22 | while (numeroDe <= numeroAte) { 23 | //verifica se o nro é par 24 | if (numeroDe % 2 == 0) { 25 | pares++; 26 | } else { 27 | impares++; 28 | } 29 | 30 | //verifica se o nro é 31 | if (numeroDe % 5 == 0) { 32 | divPorCinco++; 33 | } 34 | 35 | numeroDe++; 36 | } 37 | 38 | System.out.println("\t- Números pares: " + pares); 39 | System.out.println("\t- Números impares: " + impares); 40 | System.out.println("\t- Números divisiveis por 5: " + divPorCinco); 41 | } 42 | 43 | } 44 | -------------------------------------------------------------------------------- /javascript/funcoesVetores.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | JavaScript - Exemplo de como utilizar as funções especiais para vetores do JS 6 | 7 | 29 | 30 | 31 | 32 | 33 | 34 | -------------------------------------------------------------------------------- /python/marceneiro.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # Programa Python otimiza o trabalho do Marceneiro, uma vez definido o tamanho da peça (pedaço) o 4 | # programa calculas quantas peças dentro uma metragem maior (taboas). Dessa forma o Marceiro 5 | # pode escolher qual a melhor metragem de taboa. 6 | # 7 | # Acesse e execute esse código Python em: http://pythonfiddle.com/calculo-marceneiro-ap/ 8 | # 9 | # Módulo: Lógica de programação 10 | # Author: Eder Magalhães 11 | 12 | pedaco = 45; 13 | 14 | # Procedimento recebe o tamanho da taboa (em centímetros), calcula quantas peças podem 15 | # cortadas e quanto sobra. 16 | # Início do procedimento 17 | def calcularPedacosPorMetros(taboa): 18 | global pedaco; 19 | 20 | if (taboa <= 0): 21 | print "Valor inválido, entre com maior que 0!"; 22 | else: 23 | pedacosPorMetros = taboa / pedaco; 24 | print "Quantos pedaços existem por ", (taboa/100.0), " metros? ", pedacosPorMetros, " peças"; 25 | 26 | sobras = taboa % pedaco; 27 | print "Qtde sobra por ", (taboa/100.0),"m: ", sobras,"cm"; 28 | # Fim do procedimento 29 | 30 | 31 | print "Cada peça tem ", pedaco, "cm\n"; 32 | 33 | calcularPedacosPorMetros(100); 34 | calcularPedacosPorMetros(400); 35 | calcularPedacosPorMetros(500); 36 | calcularPedacosPorMetros(600); 37 | calcularPedacosPorMetros(1000); 38 | 39 | -------------------------------------------------------------------------------- /java/UsaTeclado.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java utiliza entrada de informações pelo teclado. 3 | * 4 | * Objetivos: 5 | * - uso entrada pelo teclado e printf. 6 | * 7 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 8 | * Author: Eder Magalhães 9 | */ 10 | 11 | import java.util.Scanner; 12 | 13 | public class UsaTeclado { 14 | 15 | public static void main(String args[]) { 16 | Scanner teclado = new Scanner(System.in); 17 | 18 | //pede para o usuario entrar com o nome, idade e salario da linha de comando 19 | System.out.println("Informe um nome (String) qualquer, depois precione ENTER..."); 20 | String nome = teclado.next(); 21 | 22 | System.out.println("Agora informe a idade (int)..."); 23 | int idade = teclado.nextInt(); 24 | 25 | System.out.println("E pra encerrar informe o salario (double)..."); 26 | double salario = teclado.nextDouble(); 27 | 28 | System.out.println("------------------------------"); 29 | //com printf eh possível imprimir dados com maior eficiencia 30 | System.out.printf("Nome informado: %s %n",nome); //%s string, %n quebra linha 31 | System.out.printf("Idade informada: %d %n",idade); //%d int (decimal) 32 | System.out.printf("Salario informado: %.2f %n",salario); //%f double ou float 33 | } 34 | 35 | } 36 | -------------------------------------------------------------------------------- /python/declaraVetores.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # Programa Python demonstra como declarar e navegar vetores de caracteres. 4 | # Em Python um array é na verdade uma lista que pode conter diferente tipos de objetos. 5 | # Para adicionar um elemento usamos a função append. Os elementos podem ser acessados 6 | # via index (o primeiro indice é 0). 7 | # 8 | # Objetivos: 9 | # - uso de arrays; 10 | # 11 | # Módulo: Lógica de programação 12 | # Author: Eder Magalhães 13 | 14 | numeros = [4, 5, 3, 2, 1]; # cria o array com os dados 15 | 16 | algunsPares = []; 17 | algunsPares.append(4); 18 | algunsPares.append(6); 19 | algunsPares.append(8); 20 | algunsPares.append(10); 21 | algunsPares.append(12); 22 | algunsPares.append(14); 23 | algunsPares.append(16); 24 | algunsPares.append(algunsPares[6] + 2); # 18 25 | algunsPares.append(algunsPares[4] * 2); 26 | 27 | # insere item no começo do array, os elementos são realocados 28 | algunsPares.insert(0, 2); 29 | 30 | qtd = 100; 31 | multiplos2 = []; 32 | 33 | # carrega o array via for 34 | for i in range(0, qtd): 35 | multiplos2.append((i+1) * 2); 36 | 37 | palavra = ['P', 'y', 't', 'h', 'o', 'n']; 38 | outraPalavra = ['O','l','a']; 39 | 40 | # é muito simples somar o conteúdo de 2 arrays em outro! 41 | frase = outraPalavra + palavra; 42 | 43 | arrayVazio = []; 44 | 45 | print 'Pronto, criamos alguns vetores no Python!'; 46 | 47 | -------------------------------------------------------------------------------- /python/calculaParcelas.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # Programa Python calcula simula o valor de parcelamento de uma compra, a partir de um preço e nro total de parcelas. 4 | # 5 | # Objetivos: 6 | # - uso de comando for (repetição); 7 | # - operações matemáticas simples; 8 | # 9 | # Acesse e execute esse código Python em: http://pythonfiddle.com/calculadora-parcelas-ap/ 10 | # 11 | # Módulo: Lógica de programação 12 | # Author: Eder Magalhães 13 | 14 | preco = 1000.2; 15 | totalParcelas = 10; 16 | intervaloDias = 30; 17 | 18 | # exibe parcelas sem acrescimento 19 | print "Pagamento de ", preco, " em ", totalParcelas, " (sem ascrecimo)"; 20 | 21 | for parcela in range(1, totalParcelas+1): 22 | valorParcela = preco / parcela; 23 | dias = intervaloDias * parcela; 24 | print "\tparcela %02d no valor de %.2f, pagto em %s dias" % (parcela, valorParcela, dias); 25 | 26 | taxaMes = .5; 27 | # reajusta o preco de acordo com a taxa 28 | juros = taxaMes * totalParcelas; 29 | preco += preco * (juros / 100); 30 | 31 | # exibe parcelas com acrescimento 32 | print "\nPagamento de ", preco, " em ", totalParcelas, " (com ascrecimo de ", juros, "%)"; 33 | 34 | for parcela in range(1, totalParcelas+1): 35 | valorParcela = preco / parcela; 36 | dias = intervaloDias * parcela; 37 | print "\tparcela %02d no valor de %.2f, pagto em %s dias" % (parcela, valorParcela, dias); 38 | 39 | -------------------------------------------------------------------------------- /java/AnoBissexto.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java define uma função para verificar se um determinado ano é ou não Bissexto. 3 | * 4 | * Objetivos: 5 | * - uso de funções; 6 | * - uso de expressões booleanas (c/ if); 7 | * - uso de repetições com o comando for; 8 | * 9 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 10 | * Author: Eder Magalhães 11 | */ 12 | public class AnoBissexto { 13 | 14 | public static void main(String args[]) { 15 | //verifica um range de anos, a partir de 2005 até 2015 16 | for (int anoInformado = 2005; anoInformado <= 2015; anoInformado++){ 17 | boolean resultado = ehBissexto(anoInformado); 18 | System.out.println("Ano "+anoInformado+" é bissexto? "+resultado); 19 | } 20 | } 21 | 22 | /* 23 | * Função recebe como argumento o ano, e retorna boolean indicando se ou nao bissexto. 24 | */ 25 | static boolean ehBissexto(int ano) { 26 | return ano % 4 == 0 && ano % 100 != 0 || ano % 400 == 0; 27 | 28 | //o trecho a seguir (comentado) é uma outra solução para verificar bissexto, com ifs: 29 | 30 | /* 31 | if (ano % 4 == 0 && ano % 100 !=0) { 32 | return true; 33 | } else if (ano % 400 == 0) { 34 | return true; 35 | } else { 36 | return false; 37 | } 38 | */ 39 | } 40 | 41 | } 42 | 43 | -------------------------------------------------------------------------------- /java/Potencia.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java calcula a potência a partir de um nro base e expoente. 3 | * O calculo de potência desse programa só se aplica a nros positivos. 4 | * 5 | * Demonstra como utilizar recursividade. 6 | * 7 | * Objetivos: 8 | * - exercício de lógica com recursividade; 9 | * 10 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 11 | * Author: Eder Magalhães 12 | */ 13 | 14 | import java.util.Scanner; 15 | 16 | public class Potencia { 17 | 18 | public static void main(String[] args) { 19 | Scanner teclado = new Scanner(System.in); 20 | 21 | System.out.print("Informe a base: "); 22 | int base = teclado.nextInt(); 23 | 24 | System.out.print("Informe o expoente: "); 25 | int expoente = teclado.nextInt(); 26 | 27 | if (base < 0) { 28 | System.out.println("Programa só calcula com base positiva!"); 29 | return; 30 | } 31 | 32 | int resultado = calculaPotencia(expoente, base); 33 | System.out.println("\nResultado de "+base+" ^ "+expoente+" = "+resultado); 34 | } 35 | 36 | /* 37 | * Função recursiva, realiza o calculo de potência. 38 | */ 39 | static int calculaPotencia(int exp, int base) { 40 | if (exp == 0) 41 | return 1; 42 | 43 | return base * calculaPotencia(--exp, base); 44 | } 45 | } 46 | 47 | -------------------------------------------------------------------------------- /java/ConsumoCombustivel.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java calcula o consumo médio de um carro (km por hora) a partir das informações: 3 | * - quantidade de gasolina no tanque; 4 | * - quantidade de horas percorridas; 5 | * - velocidade média; 6 | * 7 | * Objetivos: 8 | * - exercício de lógica; 9 | * 10 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 11 | * Author: Eder Magalhães 12 | */ 13 | 14 | import java.util.Scanner; 15 | 16 | public class ConsumoCombustivel { 17 | 18 | public static void main(String args[]) { 19 | Scanner teclado = new Scanner(System.in); 20 | 21 | System.out.print("Informe a quantidade de gasolina no tanque: "); 22 | int tanqueGasolina = teclado.nextInt(); 23 | 24 | System.out.print("Ok, agora informe quantas horas foram precorridas: "); 25 | int horasPercorridas = teclado.nextInt(); 26 | 27 | System.out.print("Por fim me diga qual era a velocidade média: "); 28 | int velocidadeMedia = teclado.nextInt(); 29 | 30 | if (tanqueGasolina < 1 || horasPercorridas < 1 || velocidadeMedia < 1) { 31 | System.out.println("Entre com dados validos!"); 32 | return; 33 | } 34 | 35 | //calculo para descobrir o valor 36 | double kmMedia = (double) velocidadeMedia * horasPercorridas / tanqueGasolina; 37 | 38 | System.out.println("\nO consumo médio foi de "+kmMedia+" km percorridos por litro"); 39 | } 40 | 41 | } 42 | -------------------------------------------------------------------------------- /python/declaraVarOutros.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # Programa Python demonstra como declarar variáveis do tipo String e Boolean. 4 | # Note que em Python não é necessário definir a variável e seu tipo! 5 | # Python é uma linguagem tipada dinamicamente. 6 | # 7 | # Objetivos: 8 | # - declaração de variáveis que armazenam texto e boolean; 9 | # 10 | # Módulo: Lógica de programação 11 | # Author: Eder Magalhães 12 | 13 | pagamentoAprovado = True; 14 | 15 | letraA = 'a'; #String com aspas simples 16 | 17 | palavra = 'Python'; 18 | 19 | print "pagamentoAprovado = ", pagamentoAprovado; 20 | print "letraA = ", letraA; 21 | print "palavra = ", palavra; 22 | print; 23 | 24 | qdteProdutos = 0; 25 | 26 | # atribui a condição boolean 27 | temEstoque = qdteProdutos > 0; 28 | 29 | # pega o codigo ASCII de 'a' e soma 1 30 | letraB = chr(ord(letraA)+1); 31 | 32 | #converte inteiro para string 33 | letraC = chr(99); 34 | 35 | frase = "Ola "+palavra; # o operador '+' concatena conteúdo das strings 36 | 37 | print "temEstoque ", temEstoque 38 | print "letraB = ", letraB 39 | print "letraC = ", letraC 40 | print "frase = ", frase 41 | print 42 | 43 | outraFrase = "Conteudo 'entre aspas'"; 44 | print "outraFrase = ", outraFrase; 45 | print "Qtde de letras na outraFrase: ", len(outraFrase); 46 | print; 47 | 48 | texto = """Uma frase no começo. 49 | Outra no fim..."""; 50 | 51 | print "texto = ", texto, "\n"; 52 | 53 | nada = None; #String (objeto) nula 54 | print "nada = ", nada; 55 | -------------------------------------------------------------------------------- /bash/vetores.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Script Bash demonstra como declarar e navegar vetores. 4 | # 5 | # Módulo: Lógica de programação 6 | # Author: Eder Magalhães 7 | 8 | NUMEROS=(4, 5, 3, 2, 1); 9 | 10 | echo 'Quantidade de elementos armazenados no array (vetor) numeros:' ${#NUMEROS[@]}; 11 | 12 | # a opção -e habilita interpretação de caracter especiais 13 | echo -e '\nNavega e imprime os elementos do array' 14 | 15 | # for tradicional em bash, acessa os elementos do array 16 | for (( i = 0; i < ${#NUMEROS[@]}; i++ )); 17 | do 18 | echo -e "\t- posição " $i " do vetor numeros o conteúdo é: " ${NUMEROS[$i]} 19 | done 20 | 21 | declare -a VETOR_DECLARADO; 22 | echo -e "\nVETOR_DECLARADO = ${VETOR_DECLARADO}" 23 | 24 | LETRAS=('B', 'A', 'S', 'H'); 25 | 26 | echo -e '\nNavegando em array com for in'; 27 | 28 | # for in em bash 29 | for i in "${LETRAS[@]}" 30 | do 31 | echo -e '\t' $i 32 | done 33 | 34 | NUMEROS_TEXTO=( zero one two three four ) # sem aspas 35 | 36 | echo "\${NUMEROS_TEXTO[@]:0} " ${NUMEROS_TEXTO[@]:0} # imprime todos os elementos do array 37 | echo "\${NUMEROS_TEXTO:1}" ${NUMEROS_TEXTO:1} # imprime o 1o elemento do array, a partir do 1o caracter 38 | echo "\${#NUMEROS_TEXTO} " ${#NUMEROS_TEXTO} # tamanho do primeiro elemento (zero = 4 caracteres) 39 | echo "\${#NUMEROS_TEXTO[*]}" ${#NUMEROS_TEXTO[*]} # outra forma de verificar o tamanho do array 40 | echo "\${NUMEROS_TEXTO[@]:1:2}" ${NUMEROS_TEXTO[@]:1:2} # imprime o segundo (1) e terceiro (2) elemento 41 | 42 | -------------------------------------------------------------------------------- /java/MinhaCalculadora.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java implementa uma calculadora, com uma função para cada operação básica. 3 | * 4 | * Objetivos: 5 | * - uso de funções, variáveis e escopo; 6 | * 7 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 8 | * Author: Eder Magalhães 9 | */ 10 | public class MinhaCalculadora { 11 | 12 | public static void main(String[] args) { 13 | int x = somar(10, 20); 14 | System.out.println("Resultado da 1a soma: " + x); 15 | 16 | int y = somar(30, 40); 17 | System.out.println("Resultado da 2a soma: " + y); 18 | 19 | int total = somar(x, y); 20 | System.out.println("Resultado final: " + total); 21 | 22 | int a = dividir(50, 2); 23 | System.out.println("Resultado da divisão: " + a); 24 | 25 | int w = multiplicar(15, 3); 26 | System.out.println("Resultado da multiplicação: " + w); 27 | 28 | int z = subtrair(5, 7); 29 | System.out.println("Resultado da subtração: " + z); 30 | } 31 | 32 | static int somar(int x, int y) { 33 | int resultado = x + y; 34 | return resultado; 35 | } 36 | 37 | static int subtrair(int x, int y) { 38 | int resultado = x - y; 39 | return resultado; 40 | } 41 | 42 | static int dividir(int y, int x) { 43 | int div = y / x; 44 | return div; 45 | } 46 | 47 | static int multiplicar(int a, int b) { 48 | return a * b; 49 | } 50 | 51 | } 52 | -------------------------------------------------------------------------------- /python/numerosDivisiveisProcedimento.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # Programa Python demonstra como é possível utilizar um procedimento (procedure) 4 | # para computar números divisiveis em um determinado range de valores. 5 | # 6 | # Lembre-se que em Python a identação é fundamental para delimitar início e fim dos blocos. 7 | # 8 | # Em Python diferente de uma função, o procedimento não indica retorno no final do bloco. 9 | # 10 | # Objetivos: 11 | # - uso de procedimento para computar instruções; 12 | # 13 | # Módulo: Lógica de programação 14 | # Author: Eder Magalhães 15 | 16 | contador = 0; # variável global 17 | 18 | # inicio do procedimento 19 | def imprimeDivisiveis(minimo, maximo, divisor): 20 | global contador; # indica o uso da variável global 21 | contador = 0; 22 | 23 | for n in range(minimo, maximo+1): 24 | if n % divisor == 0: 25 | contador += 1; 26 | print "\tO número ", n," é divisível por ",divisor 27 | # fim do procedimento 28 | 29 | valorMinimo = 10; 30 | valorMaximo = 1000; 31 | div = 10; 32 | 33 | print "Identificando divisiveis por 10 entre 100 e 1000"; 34 | 35 | # chama a procedure 36 | imprimeDivisiveis(valorMinimo, valorMaximo, div); 37 | 38 | print "\nQtos números são divisiveis por", div, " ? ", contador; 39 | 40 | print "\nIdentificando divisiveis por 2 entre 1 e 10" 41 | 42 | # outra chamada, com argumentos diferentes 43 | imprimeDivisiveis(1, 10, 2); 44 | 45 | print "\nQtos números são divisiveis por 2 ? ", contador; 46 | -------------------------------------------------------------------------------- /java/PotenciaComum.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java calcula a potência a partir de um nro base e expoente. 3 | * O calculo de potência desse programa só se aplica a nros positivos. 4 | * 5 | * O nome PotenciaComum, diferencia do outro programa Pontencia.java. 6 | * Esse algoritmo, diferentemente do outro, não utiliza recursividade! 7 | * 8 | * Objetivos: 9 | * - exercício de lógica; 10 | * 11 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 12 | * Author: Eder Magalhães 13 | */ 14 | 15 | import java.util.Scanner; 16 | 17 | public class PotenciaComum { 18 | 19 | public static void main(String[] args) { 20 | Scanner teclado = new Scanner(System.in); 21 | 22 | System.out.print("Informe a base: "); 23 | int base = teclado.nextInt(); 24 | 25 | System.out.print("Informe o expoente: "); 26 | int expoente = teclado.nextInt(); 27 | 28 | if (base < 0) { 29 | System.out.println("Programa só calcula com base positiva!"); 30 | return; 31 | } 32 | 33 | int resultado; 34 | 35 | if (expoente == 0) { 36 | resultado = 1; 37 | } else { 38 | resultado = base; 39 | } 40 | 41 | //resolve a potencia com repetição 42 | for (int x = 1; x < expoente; x++) { 43 | resultado *= base; 44 | } 45 | 46 | System.out.println("\nResultado de "+base+" ^ "+expoente+" = "+resultado); 47 | } 48 | 49 | } 50 | 51 | -------------------------------------------------------------------------------- /java/CalculadoraTeclado.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java implementa uma calculadora simples, com entrada via teclado. 3 | * 4 | * Objetivos: 5 | * - uso do teclado e switch. 6 | * 7 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 8 | * Author: Eder Magalhães 9 | */ 10 | 11 | import java.util.Scanner; 12 | 13 | public class CalculadoraTeclado { 14 | 15 | public static void main(String args[]) { 16 | Scanner teclado = new Scanner(System.in); 17 | 18 | int x, y, resultado; 19 | String nomeOperacao; 20 | 21 | System.out.println("Informe o operando 1:"); 22 | x = teclado.nextInt(); 23 | 24 | char operacao; 25 | System.out.println("Entre com a operacao, escolha os símbolos + - * /"); 26 | operacao = teclado.next().charAt(0); 27 | 28 | System.out.println("Informe o operando 2:"); 29 | y = teclado.nextInt(); 30 | 31 | switch (operacao) { 32 | default: resultado = 0; nomeOperacao = "operacao invalida"; break; 33 | case '+': resultado = x + y; nomeOperacao = "soma"; break; 34 | case '-': resultado = x - y; nomeOperacao = "subtracao"; break; 35 | case '*': resultado = x * y; nomeOperacao = "multiplicacao"; break; 36 | case '/': resultado = x / y; nomeOperacao = "divisao"; break; 37 | } 38 | 39 | System.out.printf("Resultado da %s = %s \n", nomeOperacao, resultado); 40 | } 41 | 42 | } 43 | -------------------------------------------------------------------------------- /python/descobreIndiceVetor.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # Programa Python utiliza a entrada via teclado para criar e preencher um array de inteiros. 4 | # Depois de preencher o array, o usuário indica um dado valor para o programa descobrir 5 | # a posição (indice) dele no array. 6 | # Objetivos: 7 | # - uso do teclado; 8 | # - uso de array (vetor); 9 | # - uso do comando for (repetição) e if (condicional); 10 | # 11 | # Acesse e execute esse código Python em: http://pythonfiddle.com/descobre-indice-vetor-ap/ 12 | # 13 | # Módulo: Lógica de programação 14 | # Author: Eder Magalhães 15 | 16 | # Função recebe o array e o valor. Objetivo é retornar qual o indice do valor no array. 17 | # Caso o valor não seja encontrado retorna -1. 18 | # Início da função 19 | def obtemIndice(nros, valor): 20 | # poderia utilizar a função index do array, ex: nros.index(valor) 21 | for i in range(0, len(nros)): 22 | if valor == nros[i]: 23 | return i; 24 | return -1; 25 | # Fim da função 26 | 27 | tamanhoArray = int(raw_input("Indique o tamanho do array ...\n")); 28 | numeros = []; 29 | 30 | # preenche o array (teclado) 31 | for r in range(0, tamanhoArray): 32 | valor = int(raw_input("Informe o número " + str(r+1) + "\n")); 33 | numeros.append(valor); 34 | 35 | valorDescobrir = int(raw_input("Informe o valor (int) pra descobrir o indice\n")) 36 | # verifica a posição 37 | x = obtemIndice(numeros, valorDescobrir); 38 | print "Qual a posicao de ", valorDescobrir, " no array? ", x; 39 | 40 | -------------------------------------------------------------------------------- /javascript/operadoresLogicos.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | JavaScript - Exemplo do uso de operadores lógicos no JavaScript 6 | 7 | 31 | 32 | 33 | 34 | 35 | 36 | -------------------------------------------------------------------------------- /mysql/funcaoMySQL.sql: -------------------------------------------------------------------------------- 1 | /* 2 | * Script SQL com um exemplo de function, um bloco de código que acessa/manipula os registros no banco 3 | * e no final retorna um resultado para quem o chamou. 4 | * 5 | * Essa função tem como objetivo devolver o valor da venda (ou compra) de um determinado cliente. 6 | * Por isso como entrada ele recebe o argumento com identificador do cliente, e retorna um valor 7 | * double representando o valor total dos itens do pedido. 8 | * 9 | * No MySQL é possível chamar essa função sozinha, ou atrelada a um resultado de SELECT, veja os exemplos: 10 | * SELECT calculaValorVenda(1) AS totalVenda; --aciona a função exclusivamente para o cliente 1 11 | * SELECT c.nome, calculaValorVenda(c.id) FROM cliente c; -- aciona a função para cada registro da consulta 12 | * 13 | * Módulo: Banco de dados 14 | * Autor: Eder Magalhães 15 | */ 16 | 17 | USE ap; 18 | 19 | DELIMITER $$ 20 | 21 | DROP FUNCTION IF EXISTS calculaValorVenda$$ 22 | /* Recebe como argumento o código do cliente (id) e retorna um double, o valor da venda*/ 23 | CREATE FUNCTION calculaValorVenda (codCliente INT) RETURNS DOUBLE 24 | BEGIN 25 | -- define a variável que irá armazenar o total da venda 26 | DECLARE somaVenda DOUBLE; 27 | 28 | -- soma os precos de cada item comprado pelo cliente 29 | SELECT SUM(i.preco) INTO somaVenda 30 | FROM pedido p, pedido_item i WHERE i.idPedido = p.id AND p.idCliente = codCliente; 31 | 32 | -- retorna o resultado da consulta 33 | RETURN somaVenda; 34 | 35 | END$$ 36 | 37 | DELIMITER ; 38 | -------------------------------------------------------------------------------- /java/Operadores.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java demonstra o uso de operadores em variáveis. 3 | * 4 | * Objetivos: 5 | * - declaração de variáveis; 6 | * - uso de operadores básicos; 7 | * 8 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 9 | * Author: Eder Magalhães 10 | */ 11 | public class Operadores { 12 | 13 | public static void main(String args[]) { 14 | int x = 5 + 3 * 4 / 2 - 1; 15 | System.out.println("5 + 3 * 4 / 2 - 1 = " + x); 16 | 17 | int a = 5, b = 2, c = 2 * 2; 18 | 19 | int resultado1 = a * 6 + b * 5; 20 | System.out.println("5 * 6 + 2 * 5 = " + resultado1); 21 | 22 | int resultado2 = a * (6 + b) * 5; 23 | System.out.println("5 * (6 + 2) * 5 = " + resultado2); 24 | 25 | int resultado3 = a * (6 + b * 5); 26 | System.out.println("5 * (6 + 2 * 5) = " + resultado3); 27 | 28 | int resultado4 = 20 / b * 3; 29 | System.out.println("20 / 2 * 3 = " + resultado4); 30 | 31 | //divisao de inteiro, gera inteiro 32 | int divInteiro = 7 / 2; 33 | System.out.println("7 / 2 = " + divInteiro); 34 | 35 | int restoDivInteiro = 7 % 2; 36 | System.out.println("resto de 7 / 2 = " + restoDivInteiro); 37 | 38 | //divisao de float, gera float 39 | float divFlutuante = 7.0F / 2; 40 | System.out.println("7.0 / 2 = " + divFlutuante); 41 | 42 | //pos-incremento, similar x = x + 1 ou x+=1 43 | x++; 44 | System.out.println("Incremento de x = " + x); 45 | } 46 | 47 | } 48 | -------------------------------------------------------------------------------- /javascript/numerosDivisiveis.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | JavaScript - Exemplo demonstra como iterar e calcular números no JavaScript 6 | 7 | 46 | 47 | 48 | 49 | 50 | 51 | -------------------------------------------------------------------------------- /python/vetoresNumeros.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # Programa Python demonstra como declarar e navegar vetores de números. 4 | # Um dos diferenciais do Python é a flexibilidade em lidar com vetores. 5 | # 6 | # Objetivos: 7 | # - uso de arrays que armazenam caracteres; 8 | # - uso do comando for para preencher e navegar em arrays; 9 | # - uso da função len, pra indicar o tamanho do array; 10 | # - uso da função range para definir os limites do for; 11 | # 12 | # Acesse e execute esse código Python em: http://pythonfiddle.com/vetores-numeros-ap/ 13 | # 14 | # Módulo: Lógica de programação 15 | # Author: Eder Magalhães 16 | 17 | numeros = [4, 5, 3, 2, 1]; 18 | 19 | print "Quantidade de elementos armazenados no array (vetor) numeros: ", len(numeros); 20 | 21 | print "\nA seguir o conteúdo armazenado no array numeros:"; 22 | 23 | for i in range(0, len(numeros)): 24 | n = numeros[i] 25 | print "\t- posição ", i," do vetor numeros o conteúdo é: ",n; 26 | 27 | print "\nOutra forma de apresentar os elementos do array numeros:"; 28 | 29 | # navega nos elementos em ordem inversa, do ultimo para o primeiro 30 | for i in xrange(len(numeros)-1, -1, -1): 31 | n = numeros[i] 32 | print "\t- posição ", i," do vetor numeros o conteúdo é: ",n; 33 | 34 | # como preencher um array com for em Python 35 | outrosNumeros = [n for n in range(1,6)]; 36 | 37 | print "outrosNumeros = %s " % outrosNumeros; 38 | 39 | # outra opção seria inverter a ordem do array, em Python isso é simples 40 | outrosNumeros.reverse(); 41 | 42 | # imprime os dados do array sem mostrar [] 43 | print "outrosNumeros invertidos ",str(outrosNumeros)[1:-1]; 44 | 45 | -------------------------------------------------------------------------------- /java/Marceneiro.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java otimiza o trabalho do Marceneiro, uma vez definido o tamanho da peça (pedaço) o 3 | * programa calculas quantas peças dentro uma metragem maior (taboas). Dessa forma o Marceiro 4 | * pode escolher qual a melhor metragem de taboa. 5 | * 6 | * Objetivos: 7 | * - exercício de lógica; 8 | * 9 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 10 | * Author: Eder Magalhães 11 | */ 12 | public class Marceneiro { 13 | 14 | static int pedaco = 45; 15 | 16 | public static void main(String[] args) { 17 | System.out.println("Cada peça tem "+pedaco+"cm\n"); 18 | 19 | calcularPedacosPorMetros(100); 20 | calcularPedacosPorMetros(400); 21 | calcularPedacosPorMetros(500); 22 | calcularPedacosPorMetros(600); 23 | calcularPedacosPorMetros(1000); 24 | } 25 | 26 | /* 27 | * Procedimento recebe o tamanho da taboa (em centímetros), calcula quantas peças podem 28 | * cortadas e quanto sobra. 29 | */ 30 | static void calcularPedacosPorMetros(int taboa) { 31 | if (taboa <= 0) { 32 | System.out.println("Valor inválido, entre com maior que 0!"); 33 | } else { 34 | System.out.print("Quantos pedaços existem por "+(taboa/100.0)+" metros? "); 35 | 36 | int pedacosPorMetros = taboa / pedaco; 37 | System.out.print(pedacosPorMetros+" peças\n"); 38 | 39 | System.out.print("Qtde sobra por "+(taboa/100.0)+"m: "); 40 | int sobras = taboa % pedaco; 41 | System.out.print(sobras+"cm\n"); 42 | } 43 | } 44 | 45 | } 46 | -------------------------------------------------------------------------------- /mysql/criaTabelas.sql: -------------------------------------------------------------------------------- 1 | /* 2 | * Script SQL com comandos (DDL) para criação de tabelas, chaves primárias e estrangeiras no MySQL. 3 | * 4 | * Simulação de um sistema de vendas, inicialmente com duas entidades principais: Cliente e Pedido. 5 | * 6 | * Pequena analise sobre as tabelas definidas nesse script SQL: 7 | * - Um cliente possui 0 ou muitos (n) pedidos - Many To One; 8 | * - Cada pedido possui 1 ou muitos (n) itens - Many To One; 9 | * 10 | * Módulo: Banco de dados 11 | * Autor: Eder Magalhães 12 | */ 13 | 14 | /* Cria uma nova instância no MySQL, se ainda não existir. */ 15 | CREATE DATABASE IF NOT EXISTS ap /*!40100 DEFAULT CHARACTER SET latin1 */; 16 | USE ap; 17 | 18 | /* Primeiro elimina a tabela caso ela exista. */ 19 | DROP TABLE IF EXISTS cliente; 20 | 21 | /* Depois cria a tabela para armazenar dados do cliente. */ 22 | CREATE TABLE cliente ( 23 | id INT(10) not null auto_increment, 24 | nome VARCHAR(50), 25 | email VARCHAR(70), 26 | PRIMARY KEY (id) 27 | ); 28 | 29 | DROP TABLE IF EXISTS pedido; 30 | 31 | /* Cria a tabela para armazenar os pedidos do cliente (compra). */ 32 | CREATE TABLE pedido ( 33 | id INT(10) not null auto_increment, 34 | idCliente INT(10), /* ligação com a tabela cliente */ 35 | dataPedido DATETIME, 36 | PRIMARY KEY (id), 37 | CONSTRAINT FOREIGN KEY (idCliente) REFERENCES cliente (id) 38 | ); 39 | 40 | DROP TABLE IF EXISTS pedido_item; 41 | 42 | /* Cria a tabela para armazenar os itens de um pedido. */ 43 | CREATE TABLE pedido_item ( 44 | id INT(10) not null auto_increment, 45 | idPedido INT(10), /* ligação com a tabela pedido */ 46 | descricao VARCHAR(50), 47 | preco DOUBLE, 48 | PRIMARY KEY (id), 49 | CONSTRAINT FOREIGN KEY (idPedido) REFERENCES pedido (id) 50 | ); 51 | 52 | -------------------------------------------------------------------------------- /java/VetoresCaracteres.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java demonstra como declarar e navegar vetores de caracteres. 3 | * 4 | * Objetivos: 5 | * - uso de arrays que armazenam caracteres (char e String); 6 | * - uso do comando for para preencher e percorrer arrays; 7 | * - todo array possui a propriedade length, que indica q qtde de elementos armazenados; 8 | * 9 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 10 | * Author: Eder Magalhães 11 | */ 12 | public class VetoresCaracteres { 13 | 14 | public static void main(String[] args) { 15 | char[] vogais = { 'a', 'e', 'i', 111, 'u' }; //111 é 'o' em ASCII 16 | 17 | //com println é possível imprimir os elementos de um array char 18 | System.out.println(vogais); 19 | 20 | /* 21 | * Trecho a seguir cria um vetor que armazena o alfabeto, 22 | * com as letras Maísculas em ordem decrescente (de Z a A). 23 | */ 24 | char[] alfabetoMaiusculo = new char[27]; 25 | char letra = 'Z'; 26 | int i = 0; 27 | 28 | while(letra >= 'A') { 29 | alfabetoMaiusculo[i++] = letra--; 30 | } 31 | 32 | //trecho para imprimir o conteudo do array alfabetoMaiusculo 33 | System.out.print("Conteúdo do array alfabetoMaiusculo: "); 34 | for (char l: alfabetoMaiusculo) { 35 | System.out.print(l+" "); 36 | } 37 | System.out.println(); 38 | 39 | String[] palavras = new String[] {"Programando", "arrays", "em", "Java"}; 40 | System.out.print("Conteúdo do array palavras: "); 41 | 42 | //foreach, mais simples 43 | for (String s: palavras) { 44 | System.out.print(s+" "); 45 | } 46 | System.out.println(); 47 | } 48 | 49 | } 50 | -------------------------------------------------------------------------------- /java/CalculaParcelas.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java calcula simula o valor de parcelamento de uma compra, a partir 3 | * de um preço e nro total de parcelas. 4 | * 5 | * Objetivos: 6 | * - uso de comando for (repetição); 7 | * - operações matemáticas simples; 8 | * - uso do printf para formatar o valor da parcela 9 | * 10 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 11 | * Author: Eder Magalhães 12 | */ 13 | 14 | public class CalculaParcelas { 15 | 16 | public static void main(String[] args) { 17 | float preco = 1000.2f; 18 | int totalParcelas = 10; 19 | int intervaloDias = 30; 20 | 21 | //exibe parcelas sem acrescimento 22 | System.out.println("Pagamento de " + preco + " em " + totalParcelas + " (sem ascrecimo)"); 23 | 24 | for (int parcela = 1; parcela <= totalParcelas; parcela++) { 25 | float valorParcela = preco / parcela; 26 | int dias = intervaloDias * parcela; 27 | System.out.printf("\tparcela %02d no valor de %.2f, pagto em %d dias\n", parcela, valorParcela, dias); 28 | } 29 | 30 | float taxaMes = .5f; 31 | //reajusta o preco de acordo com a taxa 32 | float juros = taxaMes * totalParcelas; 33 | preco += preco * (juros / 100); 34 | 35 | //exibe parcelas com acrescimento 36 | System.out.println("\nPagamento de " + preco + " em " + totalParcelas + " (com ascrecimo de " + juros + "%)"); 37 | 38 | for (int parcela = 1; parcela <= totalParcelas; parcela++) { 39 | float valorParcela = preco / parcela; 40 | int dias = intervaloDias * parcela; 41 | System.out.printf("\tparcela %02d no valor de %.2f, pagto em %d dias\n", parcela, valorParcela, dias); 42 | } 43 | } 44 | 45 | } 46 | -------------------------------------------------------------------------------- /bash/condicoes.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Script Bash demonstra o uso de comando if (condicional) em diversas situações. 4 | # 5 | # Módulo: Lógica de programação 6 | # Author: Eder Magalhães 7 | 8 | if [ 1 ]; then 9 | echo "if [ 1 ]; é true" 10 | else 11 | echo "if [ 1 ]; é false" 12 | fi 13 | 14 | echo 15 | 16 | declare -i NUMERO; 17 | 18 | echo "If compara NUMERO sem valor" 19 | 20 | if [ $NUMERO ]; then 21 | echo 'if [ $NUMERO ]; é true' 22 | else 23 | echo 'if [ $NUMERO ]; é false' # variavel não tem valor 24 | fi 25 | 26 | echo 27 | 28 | NUMERO=0; 29 | echo "NUMERO = $NUMERO"; 30 | if [ $((NUMERO)) ]; then #$((NUMERO)) é o mesmo de $NUMERO 31 | echo 'if [ $((NUMERO)) ]; é true' # variavel tem valor 32 | else 33 | echo 'if [ $((NUMERO)) ]; é false' 34 | fi 35 | 36 | echo 37 | 38 | # usa o pos-incremento (+1) 39 | X=$((++NUMERO)); 40 | 41 | echo "Compara X ($X) e NUMERO ($NUMERO)" 42 | if [ $NUMERO -eq $X ]; then 43 | echo 'if [ $NUMERO -eq $X ]; é true' # mesmo valor 44 | else 45 | echo 'if [ $NUMERO -eq $X ]; é false' 46 | fi 47 | 48 | echo 49 | 50 | # sinal de comparacao (-eq ou =) 51 | 52 | if [ "oi" = "tchau" ]; then 53 | echo 'if [ "oi" = "tchau" ]; é true' 54 | else 55 | echo 'if [ "oi" = "tchau" ]; é false' 56 | fi 57 | 58 | echo 59 | 60 | if [ false ]; then 61 | echo "if [ false ]; é true" # considera false como texto (string), com conteúdo 62 | else 63 | echo "if [ false ]; é false" 64 | fi 65 | 66 | echo 67 | 68 | if [ false = true ]; then 69 | echo "if [ false = true ]; é true" 70 | else 71 | echo "if [ false = true ]; é false" # compara o conteudo, resultado esperado 72 | fi 73 | 74 | echo 75 | 76 | file="./condicoes.sh" 77 | # verifica se o arquivo condicoes.sh existe 78 | if [ -e $file ]; then 79 | echo "Arquivo $file existe" 80 | else 81 | echo "Arquivo $file existe" 82 | fi 83 | 84 | -------------------------------------------------------------------------------- /javascript/condicoes.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | JavaScript - Exemplo de uso de if no JavaScript 6 | 7 | 57 | 58 | 59 | 60 | 61 | 62 | -------------------------------------------------------------------------------- /javascript/tabuada.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | JavaScript - Exemplo de como calcular a tabuada com JavaScript 6 | 7 | 41 | 42 | 43 | 44 |
45 | 46 | 47 | 48 | 49 | 51 | 52 |
Informe o número:
53 |
54 |

55 | 56 |
57 | 58 | 59 | -------------------------------------------------------------------------------- /javascript/tiposVar.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | JavaScript - Exemplo de como identificar tipos das variáveis 6 | 7 | 39 | 40 | 41 | 42 | 43 | 44 | -------------------------------------------------------------------------------- /java/TipoLiterais.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java demonstra opções de literais suportas pela linguagem. 3 | * É possível atribuir valores para numeros, utilizando: decimal, octal, hexadecimal e binário. 4 | * Já para char além do tradicional é possível utilizar essas 4 opções. 5 | * O Java suporta Unicode, portanto podemos declarar conteúdo char com código Unicode. 6 | * 7 | * Objetivos: 8 | * - uso de literais suportadas pelo Java; 9 | * 10 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 11 | * Author: Eder Magalhães 12 | */ 13 | public class TipoLiterais { 14 | 15 | public static void main(String[] args) { 16 | int decimal = 10; 17 | int octal = 012; //octal = base 8, inicia com 0 18 | int hexadecimal = 0xA; //hexadecimal = base 16, inicia com 0x 19 | //int binario = 0b1010; //binario (a partir do Java 7) 20 | 21 | System.out.println("octal = "+octal); //imprime como decimal 22 | System.out.println("hexadecimal = "+hexadecimal); //tb imprime como decimal 23 | 24 | //forma de exibir o conteúdo de uma variável em hexadecimal 25 | System.out.println("10 em hexadecimal: "+Integer.toHexString(decimal)); 26 | System.out.println("10 em binário: "+Integer.toBinaryString(decimal)); 27 | System.out.println("10 em octal: "+Integer.toOctalString(decimal)); 28 | 29 | long numeroGrande = 123L; //L indica a literal do tipo long 30 | float ponto = 1.2F; //F indica a literal do tipo float 31 | 32 | //literais caracter 33 | char letraA = 65; //codigo ASCII 34 | char letraB = 'B'; //literal char 35 | char letraC = '\u0043'; //exemplo de definição com código Unicode 36 | char especial = '\u262F'; 37 | 38 | System.out.println("letraA = " + letraA); 39 | System.out.println("letraB = " + letraB); 40 | System.out.println("letraC = " + letraC); 41 | System.out.println("especial = " + especial); 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /java/MinhaCalculadoraArray.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java implementa uma calculadora com as operações matemáticas básicas usando array. 3 | * 4 | * Objetivos: 5 | * - uso de funções e arrays; 6 | * 7 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 8 | * Author: Eder Magalhães 9 | */ 10 | public class MinhaCalculadoraArray { 11 | 12 | public static void main(String[] args) { 13 | int[] x = {10, 20, 5}; 14 | int totalSoma = somar(x); 15 | System.out.println("Resultado da 1a soma: " + totalSoma); 16 | 17 | totalSoma = somar(new int[]{2, 3}); 18 | System.out.println("Resultado da 2a soma: " + totalSoma); 19 | 20 | int[] y = {}; //array vazio 21 | System.out.println("Resultado da 3a soma: " + somar(y)); 22 | 23 | int[] w = new int[]{5, 3, 1}; 24 | int totalSubtrair = subtrair(w); 25 | System.out.println("Resultado da 1a subtração: " + totalSubtrair); 26 | 27 | totalSubtrair = subtrair(new int[] {50, 25, 30, 5}); 28 | System.out.println("Resultado da 2a subtração: " + totalSubtrair); 29 | 30 | //array vazio 31 | System.out.println("Resultado da 3a subtração: " + subtrair(new int[]{})); 32 | } 33 | 34 | /* 35 | * Soma os elementos contidos no array. 36 | */ 37 | static int somar(int[] numeros) { 38 | int resultado = 0; 39 | //for each 40 | for (int n: numeros) { 41 | resultado += n; 42 | } 43 | return resultado; 44 | } 45 | 46 | /* 47 | * Considera o 1o elementos e subtrai pelo restante. 48 | */ 49 | static int subtrair(int[] nros) { 50 | if (nros.length == 0) { 51 | return 0; //se o array é vazio retorna 0! 52 | } 53 | 54 | int resultado = nros[0]; 55 | //foreach 56 | for (int i = 1; i < nros.length; i++) { 57 | resultado -= nros[i]; 58 | } 59 | return resultado; 60 | } 61 | 62 | } 63 | -------------------------------------------------------------------------------- /java/DescobreIndiceVetor.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java utiliza a entrada via teclado para criar e preencher um array de inteiros. 3 | * Depois de preencher o array, o usuário indica um dado valor para o programa descobrir 4 | * a posição (indice) dele no array. 5 | * 6 | * Objetivos: 7 | * - uso do teclado; 8 | * - uso de array (vetor); 9 | * - uso do comando for (repetição) e if (condicional); 10 | * 11 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 12 | * Author: Eder Magalhães 13 | */ 14 | 15 | import java.util.Scanner; 16 | 17 | public class DescobreIndiceVetor { 18 | 19 | public static void main(String[] args) { 20 | Scanner teclado = new Scanner(System.in); 21 | 22 | System.out.println("Indique o tamanho do array ..."); 23 | int tamanhoArray = teclado.nextInt(); 24 | int numeros[] = new int[tamanhoArray]; 25 | 26 | //preenche o array (teclado) 27 | for (int r = 0; r < tamanhoArray; r++){ 28 | System.out.println("Informe o número "+ (r+1) ); 29 | numeros[r] = teclado.nextInt(); 30 | } 31 | 32 | System.out.println("Informe o valor (int) pra descobrir o indice"); 33 | int valorDescobrir = teclado.nextInt(); 34 | //verifica a posição 35 | int x = obtemIndice(numeros, valorDescobrir); 36 | 37 | System.out.println("Qual a posicao de "+valorDescobrir+" no array? "+x); 38 | } 39 | 40 | /* 41 | * Função recebe o array e o valor. O objetivo e descobrir e retornar a qual posição 42 | * da valor no array de inteiro. 43 | * Se o valor não existir retorna -1. 44 | */ 45 | static int obtemIndice(int[] nros, int valor) { 46 | for (int i = 0; i < nros.length; i++) { 47 | if (valor == nros[i]) { 48 | //se ele entrou no if, quer dizer encontrou o valor 49 | return i; 50 | } 51 | } 52 | return -1; 53 | } 54 | 55 | } 56 | -------------------------------------------------------------------------------- /java/DeclaraVarOutros.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java demonstra como declarar variáveis de tipos: boolean, char e String. 3 | * 4 | * Objetivos: 5 | * - declaração de variáveis; 6 | * 7 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 8 | * Author: Eder Magalhães 9 | */ 10 | public class DeclaraVarOutros { 11 | 12 | public static void main(String[] args) { 13 | boolean pagamentoAprovado = true; 14 | 15 | char letraA = 'a'; 16 | 17 | String palavra = "Java"; 18 | 19 | System.out.println("pagamentoAprovado = " + pagamentoAprovado); 20 | System.out.println("letraA = " + letraA); 21 | System.out.println("palavra = " + palavra); 22 | System.out.println(); 23 | 24 | int qdteProdutos = 0; 25 | 26 | //atribui a condição boolean 27 | boolean temEstoque = qdteProdutos > 0; 28 | 29 | //pega o codigo ASCII de 'a' e soma 1 30 | char letraB = ++letraA; 31 | 32 | //o tipo char suporte nros inteiros (aprox. no limite de short) 33 | char letraC = 99; 34 | 35 | String frase = "Ola "+palavra;//o operador '+' concatena o conteúdo das strings 36 | 37 | System.out.println("temEstoque " + temEstoque); 38 | System.out.println("letraB = " + letraB); 39 | System.out.println("letraC = " + letraC); 40 | System.out.println("frase = " + frase); 41 | System.out.println(); 42 | 43 | String outraFrase = "Conteudo \'entre aspas\'"; 44 | System.out.println("outraFrase = " + outraFrase); 45 | 46 | //exibe a qtde de letras na frase 47 | System.out.println("Qtde de letras na outraFrase: " + outraFrase.length()); 48 | System.out.println(); 49 | 50 | String texto = "Uma frase no começo.\nOutra no fim..."; 51 | System.out.println("texto = " + texto+"\n"); 52 | 53 | String nada = null; //String (objeto) nula 54 | System.out.println("nada = " + nada); 55 | } 56 | 57 | } 58 | -------------------------------------------------------------------------------- /mysql/procedureMySQL.sql: -------------------------------------------------------------------------------- 1 | /* 2 | * Script SQL com um exemplo de procedure, um bloco de código que manipula os registros no banco. 3 | * Diferente de uma function, a procedure não devolve resultado no fim do processamento. 4 | * 5 | * Essa procedure define um bloco de código com a capacidade de inserir registros nas tabelas: 6 | * cliente, pedido e pedido_item; 7 | * Uma alternativa interessante para simular um determinado número de cadastros. 8 | * 9 | * No MySQL para chamar uma procedure é necessário o comando call, por exemplo: 10 | * call preencheBasePedidos(10); 11 | * 12 | * Módulo: Banco de dados 13 | * Autor: Eder Magalhães 14 | */ 15 | 16 | USE ap; 17 | 18 | DELIMITER $$ 19 | 20 | DROP PROCEDURE IF EXISTS preencheBasePedidos$$ 21 | /* Recebe como argumento a quantidade de registros deve ser inserida em cada tabela. */ 22 | CREATE PROCEDURE preencheBasePedidos (qtd INT) 23 | BEGIN 24 | 25 | --definição de algumas variáveis da procedure. 26 | DECLARE $nome VARCHAR(50); 27 | DECLARE $email VARCHAR(70); 28 | DECLARE $descricao VARCHAR(50); 29 | DECLARE $preco DOUBLE; 30 | 31 | DECLARE x INT; 32 | 33 | -- inicializa a variável de controle do loop 34 | SET x = 1; 35 | 36 | -- de 1 até o valor informado no argumento qtd 37 | WHILE x <= qtd DO 38 | -- a cada iteração do loop, insere um registro em cada tabela 39 | SET $nome = CONCAT('Cliente ',x); 40 | SET $email = CONCAT('cliente',x,'gmail.com'); 41 | 42 | INSERT INTO cliente(nome, email) VALUES($nome, $email); 43 | 44 | -- LAST_INSERT_ID informa o último valor de id (auto_increment) gerado pelo MySQL. 45 | INSERT INTO pedido(idCliente, dataPedido) VALUES(LAST_INSERT_ID(), SYSDATE()); 46 | 47 | SET $descricao = CONCAT('Produto ',x); 48 | SET $preco = 10 * x; --10, 20, 30 ... 49 | 50 | INSERT INTO pedido_item(idPedido, descricao, preco) VALUES(LAST_INSERT_ID(), $descricao, $preco); 51 | 52 | -- incrementa a variável de controle do loop 53 | SET x = x + 1; 54 | END WHILE; 55 | 56 | END$$ 57 | 58 | DELIMITER ; 59 | -------------------------------------------------------------------------------- /javascript/calculaParcelas.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | JavaScript - Exemplo simula o parcelamento de um pagto em JavaScript 6 | 7 | 47 | 48 | 49 | 50 | 51 | 52 | -------------------------------------------------------------------------------- /java/NumerosDivisiveisFuncao.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java demonstra como é possível utilizar uma função (function) 3 | * para calcular números divisiveis em um determinado range de valores. 4 | * 5 | * Em Java uma "função" é um bloco de código que processa instruções, 6 | * e no fim (conclusão) retorna um resultado para quem o acionou. 7 | * 8 | * Na verdade em Java não tem suporte nativo a funções (pelo menos até o Java 7), 9 | * o bloco de código é o método. 10 | * 11 | * Objetivos: 12 | * - uso de funções para realizar um cálculo; 13 | * 14 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 15 | * Author: Eder Magalhães 16 | */ 17 | public class NumerosDivisiveisFuncao { 18 | 19 | public static void main(String[] args) { 20 | System.out.println("Identificando divisiveis por 10 entre 100 e 1000"); 21 | 22 | int valorMinimo = 10; 23 | int valorMaximo = 1000; 24 | int div = 10; 25 | 26 | //chama a função 27 | int total = calculaDivisiveis(valorMinimo, valorMaximo, div); 28 | System.out.println("\nQtos números são divisiveis por "+ div +" ? " + total); 29 | 30 | System.out.println("Identificando divisiveis por 2 entre 1 e 10"); 31 | 32 | //chama a função, com outros argumentos, na hora de imprimir 33 | System.out.println("\nQtos números são divisiveis por 2 ? " + calculaDivisiveis(1, 10, 2)); 34 | } 35 | 36 | /* 37 | * Bloco de código que centraliza as instruções que calculam os divisores de um número. 38 | * Ao chamar essa função, é necessário informar o número minimo e maximo que devem ser analisados, 39 | * além do divisor. 40 | * Exemplo int x = calculaDivisiveis(1, 10, 2) -> calcula os divisiveis por 2 de 1 a 10. 41 | */ 42 | static int calculaDivisiveis(int minimo, int maximo, int divisor) { 43 | int contador = 0; 44 | 45 | for (int n = minimo; n <= maximo; n++) { 46 | if (n % divisor == 0) { 47 | contador++; 48 | } 49 | } 50 | return contador; //resultado da função 51 | } 52 | } 53 | 54 | -------------------------------------------------------------------------------- /javascript/escopo.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | JavaScript - Exemplo demonstra como funcionam o escopo de variáveis do JavaScript 6 | 7 | 56 | 57 | 58 | 59 | 60 | 61 | -------------------------------------------------------------------------------- /javascript/imprimeVetores.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | JavaScript - Exemplo de como acessar elementos contidos em vetores no JS 6 | 7 | 55 | 56 | 57 | 58 | 59 | 60 | -------------------------------------------------------------------------------- /java/NumerosDivisiveisProcedimento.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java demonstra como é possível utilizar um procedimento (procedure) 3 | * para computar números divisiveis em um determinado range de valores. 4 | * 5 | * Em Java um "procedimento" é um bloco de código que processa instruções, 6 | * mas no fim (conclusão) não retorna resultado. 7 | * 8 | * Java não tem suporte a procedimentos, na verdade criamos um método com 9 | * tipo de retorno 'void'. 10 | * 11 | * Objetivos: 12 | * - uso de procedimento para computar instruções; 13 | * - uso de escopo de variável global (programa); 14 | * 15 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 16 | * Author: Eder Magalhães 17 | */ 18 | public class NumerosDivisiveisProcedimento { 19 | 20 | //variavel global, acessível em todo arquivo (programa). 21 | static int contador; 22 | 23 | public static void main(String[] args) { 24 | System.out.println("Identificando divisiveis por 10 entre 100 e 1000"); 25 | 26 | int valorMinimo = 10; 27 | int valorMaximo = 1000; 28 | int div = 10; 29 | 30 | //chama a procedure 31 | imprimeDivisiveis(valorMinimo, valorMaximo, div); 32 | System.out.println("\nQtos números são divisiveis por "+ div +" ? " + contador); 33 | 34 | System.out.println("\nIdentificando divisiveis por 2 entre 1 e 10"); 35 | 36 | //outra chamada, com argumentos diferentes 37 | imprimeDivisiveis(1, 10, 2); 38 | 39 | System.out.println("\nQtos números são divisiveis por 2 ? " + contador); 40 | } 41 | 42 | /* 43 | * Bloco de código que centraliza as instruções que calculam possíveis divisores de um número. 44 | * Ao chamar esse procedimento, é necessário informar o número minimo e maximo que devem ser analisados, 45 | * além do divisor. 46 | * Exemplo imprimeDivisiveis(1, 10, 2) -> computa os divisiveis por 2 de 1 a 10. 47 | */ 48 | static void imprimeDivisiveis(int minimo, int maximo, int divisor) { 49 | contador = 0; 50 | 51 | for (int n = minimo; n <= maximo; n++) { 52 | if (n % divisor == 0) { 53 | contador++; 54 | System.out.println("\tO número "+ n +" é divisível por "+divisor); 55 | } 56 | } 57 | } 58 | } 59 | 60 | -------------------------------------------------------------------------------- /mysql/selecionaDados.sql: -------------------------------------------------------------------------------- 1 | /* 2 | * Script SQL com comandos de consulta das informações na base de dados de clientes e pedidos. 3 | * 4 | * Módulo: Banco de dados 5 | * Autor: Eder Magalhães 6 | */ 7 | 8 | USE ap; 9 | 10 | /* Consulta basica, de todos os clientes cadastrados. */ 11 | SELECT * FROM cliente; 12 | 13 | 14 | /* Consulta o email de clientes que possuem nome começando com Maria. */ 15 | SELECT email FROM cliente WHERE nome like 'Maria %'; 16 | 17 | 18 | /* Mesma consulta definindo alias (apelido) para a tabela e tratando letras minusculas/maisculas. */ 19 | SELECT c.email FROM cliente c WHERE UPPER(c.nome) like 'MARIA %'; 20 | 21 | 22 | /* Consulta utilizando funções do MySQL para formatar dados. 23 | * Nesse consulta todos os clientes cadastros e exibe os campos: 24 | * - nome com todas as letras maíusculas - Função do MySQL: UPPER; 25 | * - informa o tamanho do campo de email - Função do MySQL: LENGTH; 26 | * - inverte os caracteres que formam o nome do cliente - Função do MySQL: REVERSE; 27 | */ 28 | SELECT UPPER(c.nome), LENGTH(c.email), REVERSE(c.nome) FROM cliente c; 29 | 30 | 31 | /* Verifica a quantidade de clientes cadastrados. Note o alias (apelido) no resultado (AS qtde). */ 32 | SELECT COUNT(c.id) AS qtde FROM cliente c; 33 | 34 | 35 | /* Consulta informações do pedido, item e clientes, de todos os clientes que compraram. (join requerido) */ 36 | SELECT c.nome, p.dataPedido, i.descricao, i.preco 37 | FROM cliente c, pedido p, pedido_item i 38 | WHERE p.idCliente = c.id --liga a tabela pedido com cliente, soh traz os clientes que possuem pedido 39 | AND i.idPedido = p.id; --liga a tabela de itens com a pedido 40 | 41 | 42 | /* 43 | * Consulta traz o nome e data de compra (pedido). Mas é preciso considerar todos os cliente! 44 | * Os clientes que não compraram devem aparecer, mas o campo de data deve ficar vazio. 45 | * O inner join não atende essa situação, por isso utilizamos o LEFT OUTER JOIN (join opcional). 46 | */ 47 | SELECT c.nome, p.dataPedido 48 | FROM cliente c LEFT OUTER JOIN pedido p ON p.idCliente = c.id; 49 | 50 | 51 | /* Utilizando funções do MySQL para extrair informações do banco, sem o uso de tabelas: */ 52 | SELECT SYSDATE(); --retorna a data atual no servidor MySQL 53 | 54 | SELECT CONCAT('Consulta',' no ', 'MySQL') AS texto; --devolve um registro, com o texto passado na função 55 | 56 | 57 | -------------------------------------------------------------------------------- /javascript/ordenaVetorBubbleSort.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | JavaScript - Exemplo de ordenação de array com BubbleSort em JS 6 | 7 | 63 | 64 | 65 | 66 | 67 | 68 | -------------------------------------------------------------------------------- /javascript/potencia.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | JavaScript - Exemplo de como calcular a potencia com JavaScript 6 | 7 | 48 | 49 | 50 | 51 |
52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 |
Informe a base:
Informe o expoente:
65 |
66 |

67 | 68 |
69 | 70 | 71 | -------------------------------------------------------------------------------- /java/DeclaraVetores.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java demonstra como declarar e preencher vetores (array). 3 | * Um array é uma variável que pode armazenar vários valores, organizados por um índice. 4 | * No Java a capacidade de um array é estática, ou seja, uma vez definida a capacidade 5 | * de um array não pode mudar. Portanto, adicionar ou remover elementos podem requerer 6 | * a criação de um novo array, com capacidade maior ou menor. 7 | * 8 | * Objetivos: 9 | * - uso de arrays; 10 | * 11 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 12 | * Author: Eder Magalhães 13 | */ 14 | public class DeclaraVetores { 15 | 16 | public static void main(String[] args) { 17 | int[] numeros; //define 18 | numeros = new int[] {4, 5, 3, 2, 1}; //atribui os valores 19 | 20 | //definição e atribuição dos valores 21 | int notas[] = {8, 7, 9, 5}; 22 | 23 | int[] vetorNros = new int[] {1, 3, 5, 7, 9}; 24 | 25 | 26 | int[] algunsPares = new int[10]; //array 'zerado' 27 | 28 | //atribuição posição a posição... 29 | //primeiro valor fica sempre no índice (posição) 0 30 | algunsPares[0] = 2; 31 | algunsPares[1] = 4; 32 | algunsPares[2] = 6; 33 | algunsPares[3] = 8; 34 | algunsPares[4] = 10; 35 | algunsPares[5] = 12; 36 | algunsPares[6] = 14; 37 | algunsPares[7] = 16; 38 | algunsPares[8] = algunsPares[7] + 2; //18 39 | //última posição é sempre o tamanho do array - 1 (10-1) 40 | algunsPares[9] = algunsPares[4] * 2; //20 41 | 42 | 43 | int qtd = 100; 44 | int[] multiplos2 = new int[qtd]; 45 | //carrega o array via for 46 | for (int i = 0; i < qtd; i++) { 47 | multiplos2[i] = (i+1) * 2; 48 | } 49 | 50 | char palavra[] = {'J','a','v','a'}; 51 | char[] novaPalavra = new char[] {'O','l','a'}; 52 | char[] frase = new char[7]; 53 | //copia os dados do array novaPalavra 54 | for (int i = 0; i < 3; i++) { 55 | frase[i] = novaPalavra[i]; 56 | } 57 | 58 | //copia os dados do array novaPalavra 59 | for (int i = 0; i < 4; i++) { 60 | frase[3+i] = palavra[i]; 61 | } 62 | 63 | //exemplo de um array vazio (0 elementos) 64 | long[] arrayVazio = new long[0]; //{} 65 | 66 | System.out.println("Pronto, criamos alguns vetores no Java!"); 67 | } 68 | 69 | } 70 | -------------------------------------------------------------------------------- /javascript/soma.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | JavaScript - Exemplo do uso operador + no JavaScript 6 | 7 | 61 | 62 | 63 | 64 | 65 | 66 | -------------------------------------------------------------------------------- /javascript/vetores.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | JavaScript - Exemplo de declaração de vetores em JS 6 | 7 | 55 | 56 | 57 | 58 | 59 | 60 | -------------------------------------------------------------------------------- /java/VetoresNumeros.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java demonstra como declarar e navegar vetores de números. 3 | * 4 | * Objetivos: 5 | * - uso de arrays que armazenam números; 6 | * - uso do comando for para preencher e percorrer arrays; 7 | * - todo array possui a propriedade length, que indica q qtde de elementos armazenados; 8 | * 9 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 10 | * Author: Eder Magalhães 11 | */ 12 | public class VetoresNumeros { 13 | 14 | public static void main(String[] args) { 15 | int[] numeros = {4, 5, 3, 2, 1}; 16 | 17 | System.out.println("Quantidade de elementos armazenados no array (vetor) numeros: " + numeros.length); 18 | 19 | System.out.println("\nA seguir o conteúdo armazenado no array numeros:"); 20 | //itera (navega) sob os elementos do array a partir do indice 0 21 | for (int i = 0; i < numeros.length; i++) { //i faz o papel do indice 22 | int n = numeros[i]; 23 | System.out.println("\t- posição " + i +" do vetor numeros o conteúdo é: "+n); 24 | } 25 | 26 | System.out.println("\nOutra forma de apresentar os elementos do array numeros:"); 27 | //itera (navega) sob os elementos do array a partir do último indice 28 | for (int i = numeros.length-1; i >= 0; i--) { 29 | int n = numeros[i]; 30 | System.out.println("\t- posição " + i +" do vetor numeros o conteúdo é: "+n); 31 | } 32 | 33 | float[] notas = {6.7f, 7f, 8.2f, 5.74f}; 34 | 35 | System.out.print("\nConteúdo do array de notas: "); 36 | //o Java define o comando for each, mais simples de iterar sob os elementos do array 37 | for (float n: notas) { 38 | //nessa caso não existe uma váriavel de controle (indice)... 39 | System.out.print(n+", "); 40 | } 41 | System.out.println(); 42 | 43 | /* 44 | * A seguir um exemplo de codigo que define e carrega um array com nros pares. 45 | * O maior nro armazenado é 100, o processamento ocorre na ordem: 100, 98, 96, 94... 46 | * Os nros são mantidos em ordem ascendente (2, 4, 6, 8...), note a lógica inversa 47 | */ 48 | int maiorPar = 100; 49 | int[] nrosPares = new int[50]; 50 | for (int i = nrosPares.length-1; i >= 0; i--) { 51 | nrosPares[i] = maiorPar; 52 | maiorPar -= 2; 53 | } 54 | 55 | System.out.print("\nConteúdo do array de nrosPares (até 100): "); 56 | for (int p: nrosPares) { 57 | System.out.print(p+", "); 58 | } 59 | System.out.println(); 60 | } 61 | 62 | } 63 | -------------------------------------------------------------------------------- /python/ordenaVetorBubbleSort.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # Programa Python utiliza a entrada via teclado para criar e preencher um array de inteiros. 4 | # Depois de preencher o array, o programa coloca os números contidos no array em ordem 5 | # numérica natural (ascendente). 6 | # 7 | # Na computação existem vários algoritmos para ordenação dos dados. As diferenças são 8 | # basicamente: complexidade, consumo de memória e tempo de processamento. 9 | # 10 | # Nesse programa utilizamos o algoritmo Bubble Sort. Um algoritmo relativamente simples, 11 | # com a performance satisfatória quando o array não tem uma capacidade muito grande. 12 | # - uso de procedimentos para organizar o código; 13 | # - uso de algoritmos para resolver o problema de ordenação de dados; 14 | # - demonstrar como implementar o algoritmo Bubble Sort em Python; 15 | # 16 | # Acesse e execute esse código Python em: http://pythonfiddle.com/ordena-vetor-bubblesort-ap/ 17 | # 18 | # Módulo: Lógica de programação 19 | # Author: Eder Magalhães 20 | 21 | # Procedimento responsável preencher o array a partir dos dados coletados via teclado. 22 | # Início do procedimento 23 | def preenche(numeros, tamanho): 24 | for i in range (0, tamanho): 25 | valor = int(raw_input("Informe o número " + str(i+1) + "\n")); 26 | numeros.append(valor); 27 | # Fim do procedimento 28 | 29 | # Procedimento responsável por imprimir os dados contidos no array. 30 | # Início do procedimento 31 | def imprime(numeros): 32 | print str(numeros)[1:-1], "\n"; 33 | # Fim do procedimento 34 | 35 | # Procedimento responsável por ordenar o array, utilizando o algoritmo Bubble Sort. 36 | # No fim do procedimento os números contidos no array estarão em ordem numérica. 37 | # Início do procedimento 38 | def ordena(numeros): 39 | houveTroca = True; 40 | 41 | while (houveTroca): 42 | houveTroca = False; 43 | for i in range(0, len(numeros)-1): 44 | # compara o elemento atual (i) c/ o proximo (i+1) 45 | if (numeros[i] > numeros[i+1]): 46 | #faz a troca 47 | aux = numeros[i]; 48 | numeros[i] = numeros[i+1]; 49 | numeros[i+1] = aux; 50 | 51 | #indica que o array deve ser analisado novamente (while) 52 | houveTroca = True; 53 | 54 | # Fim do procedimento 55 | 56 | tamanhoArray = int(raw_input("Indique o tamanho do array ...\n")); 57 | vetor = []; 58 | 59 | preenche(vetor, tamanhoArray); 60 | 61 | print "\nConteúdo do array antes de ordenar..."; 62 | imprime(vetor); 63 | 64 | # coloca os valores do array em ordem numérica (ascende) 65 | ordena(vetor); 66 | 67 | print "\nConteúdo do array depois de ordenar..."; 68 | imprime(vetor); 69 | 70 | -------------------------------------------------------------------------------- /python/arquivos/cadastroClientesArquivo.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # Programa Python implementa um cadastro de clientes, com entrada via teclado 4 | # e armazenamento em arquivo texto. 5 | # 6 | # Objetivos: 7 | # - manipular dados em um arquivo texto. 8 | # 9 | # Módulo: Lógica de programação 10 | # Author: Eder Magalhães 11 | 12 | import os; 13 | 14 | # Apresenta um menu com as opções do cadastro 15 | def montaMenu(): 16 | print 17 | print "0 - Apagar cliente"; 18 | print "1 - Novo cliente"; 19 | print "2 - Lista clientes"; 20 | print "3 - Finalizar"; 21 | print "Digite a opcao desejada: "; 22 | 23 | # Insere os dados do cliente no arquivo 24 | def grava(nome, cpf): 25 | f = open(nomeArquivo, 'a'); 26 | # mantem um cliente por linha no arquivo, ex: 01232|Jose da Silva 27 | f.write(cpf + "|" + nome + "\n"); 28 | f.close(); 29 | 30 | # Imprime todos os clientes (linhas) cadastrados no arquivo. 31 | def lista(): 32 | f = open(nomeArquivo, 'r'); 33 | for line in f: 34 | dados = line.strip().split("|"); 35 | print "Cliente: ", dados[1], ", CPF: " + dados[0] 36 | 37 | # Remove o registro do cliente (linha) do arquivo, se existir. 38 | def remove(cpfRemover): 39 | #renomea o arquivo original 40 | os.rename(nomeArquivo, "clientes.temp"); 41 | arquivoOriginal = open("clientes.temp", 'r'); 42 | 43 | novo = open(nomeArquivo, 'w'); 44 | removeu = False; 45 | 46 | for line in arquivoOriginal: 47 | dados = line.strip().split("|"); 48 | cpf = dados[0]; 49 | if (cpf == cpfRemover): 50 | removeu = True; 51 | else: 52 | novo.write(line); 53 | 54 | if removeu: 55 | print "Removeu o cliente com cpf ", cpfRemover; 56 | 57 | arquivoOriginal.close(); 58 | novo.close(); 59 | # remove o arquivo temporario 60 | os.remove("clientes.temp"); 61 | 62 | nomeArquivo = "clientes.txt"; 63 | 64 | while (True): 65 | montaMenu(); 66 | opcao = int(raw_input()); 67 | 68 | if opcao == 1: 69 | print "cadastrar..."; 70 | print "-- Inserindo clientes no arquivo", '-' * 10; 71 | 72 | nome = raw_input("Informe o Nome:\n"); 73 | cpf = raw_input("Informe o CPF:\n") 74 | 75 | # grava dados no arquivo 76 | grava(nome, cpf); 77 | print '-' * 40; 78 | 79 | elif opcao == 2: 80 | print "-- Listando clientes do arquivo", '-' * 10; 81 | lista(); 82 | print '-' * 40; 83 | 84 | elif opcao == 3: 85 | print "-- Finalizando programa", '-' * 20 86 | break; # encerra while 87 | elif opcao == 0: 88 | print "-- Apagando cliente do arquivo ", '-' * 10; 89 | cpfRemover = raw_input("CPF do cliente: \n"); 90 | remove(cpfRemover); 91 | else: 92 | print "Opção inválida!"; 93 | 94 | 95 | -------------------------------------------------------------------------------- /python/megaSena.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # Programa Python simula o sorteio e aposta da Mega Sena. 4 | # O programa sorteia seis números randomicos, sem repetição. O usuário entra com seis números 5 | # de sua aposta. Por fim o programa avalia quantos acertos o usuário obteve! 6 | # 7 | # Objetivos: 8 | # - exercício de lógica; 9 | # - usar a entrada de dados via teclado; 10 | # - uso de funções para organizar o código; 11 | # - uso dos comandos de repetição for e while. 12 | # - uso da API do Python para geração de números randômicos. 13 | # 14 | # Acesse e execute esse código Python em: http://pythonfiddle.com/mega-sena-ap/ 15 | # 16 | # Módulo: Lógica de programação 17 | # Author: Eder Magalhães 18 | 19 | from random import randint; 20 | import sys; 21 | 22 | NUMERO_DEZENAS = 6; 23 | 24 | # Função indica se o n existe no array numeros. 25 | # Início da função 26 | def existeNumero(numeros, n): 27 | return n in numeros; 28 | # Fim da função 29 | 30 | # Função comparada cada número apostado, com os números sorteados. 31 | # Por fim retorna a quantidade de acertos. 32 | # Início da função 33 | def contaAcertos(sorteio, aposta): 34 | global NUMERO_DEZENAS; 35 | acertos = 0; 36 | for i in range(0, NUMERO_DEZENAS): 37 | nroAposta = aposta[i]; 38 | 39 | # compara cada nro apostado com os sorteados 40 | if (existeNumero(sorteio, nroAposta)): 41 | acertos += 1; 42 | 43 | return acertos; 44 | # Fim da função 45 | 46 | # Função retorna uma array com 6 números gerados randomicamente (API do Python), 47 | # sem duplicidade, representando o sorteio da megasena. 48 | # Início da função 49 | def sorteaSena(): 50 | global NUMERO_DEZENAS; 51 | resultado = []; 52 | 53 | for i in range(0, NUMERO_DEZENAS): 54 | repetido = False; 55 | 56 | # Python não possui do while... 57 | while True: 58 | sorteado = randint(1, 60); #nro aleatório de 1 a 60 59 | if not existeNumero(resultado, sorteado): 60 | break; 61 | 62 | resultado.append(sorteado); 63 | 64 | return resultado; 65 | # Fim da função 66 | 67 | 68 | sorteio = sorteaSena(); 69 | aposta = []; 70 | 71 | # trecho processa a aposta 72 | print "Faça sua aposta: "; 73 | 74 | for i in range (0, NUMERO_DEZENAS): 75 | 76 | while True: 77 | nroAposta = int(raw_input("Informe a dezena "+ str(i+1) +": ")); 78 | if (nroAposta <= 0): 79 | print "Número inválido, aposta cancelada!"; 80 | sys.exit(); # encerra o programa 81 | 82 | if (existeNumero(aposta, nroAposta)): 83 | print "Ops, número repetido!"; 84 | else: 85 | break; 86 | 87 | aposta.append(nroAposta); 88 | 89 | print "\nConfira sua aposta: ", str(aposta)[1:-1] 90 | 91 | print "\nResultado do sorteio: ", str(sorteio)[1:-1] 92 | 93 | nroAcertos = contaAcertos(sorteio, aposta); 94 | print "\nNúmero de acertos: ", nroAcertos; 95 | 96 | if nroAcertos == 4: 97 | print "Parabéns. Você acertou a quadra!"; 98 | elif nroAcertos == 5: 99 | print "Parabéns. Você acertou a quina!"; 100 | elif nroAcertos == 6: 101 | print "Parabéns. Você é campeão da MegaSena!"; 102 | else: 103 | print "Não foi dessa vez. Tente novamente!"; 104 | -------------------------------------------------------------------------------- /java/OrdenaVetorBubbleSort.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java utiliza a entrada via teclado para criar e preencher um array de inteiros. 3 | * Depois de preencher o array, o programa coloca os números contidos no array em ordem 4 | * numérica natural (ascendente). 5 | * 6 | * Na computação existem vários algoritmos para ordenação dos dados. As diferenças são 7 | * basicamente: complexidade, consumo de memória e tempo de processamento. 8 | * 9 | * Nesse programa utilizamos o algoritmo Bubble Sort. Um algoritmo relativamente simples, 10 | * com a performance satisfatória quando o array não tem uma capacidade muito grande. 11 | * 12 | * Objetivos: 13 | * - uso de procedimentos para organizar o código; 14 | * - uso de algoritmos para resolver o problema de ordenação de dados; 15 | * - demonstrar como implementar o algoritmo Bubble Sort em Java; 16 | * 17 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 18 | * Author: Eder Magalhães 19 | */ 20 | 21 | import java.util.Scanner; 22 | 23 | public class OrdenaVetorBubbleSort { 24 | 25 | static Scanner teclado; 26 | 27 | public static void main(String[] args) { 28 | teclado = new Scanner(System.in); 29 | 30 | System.out.println("Indique o tamanho do array ..."); 31 | int tamanhoArray = teclado.nextInt(); 32 | int vetor[] = new int[tamanhoArray]; 33 | 34 | preenche(vetor); 35 | 36 | System.out.println("\nConteúdo do array antes de ordenar..."); 37 | imprime(vetor); 38 | 39 | //coloca os valores do array em ordem numérica (ascende) 40 | ordena(vetor); 41 | 42 | System.out.println("\nConteúdo do array depois de ordenar..."); 43 | imprime(vetor); 44 | } 45 | 46 | /* 47 | * Procedimento responsável preencher o array a partir dos dados coletados via teclado. 48 | */ 49 | static void preenche(int[] numeros) { 50 | for (int i = 0; i < numeros.length; i++){ 51 | System.out.println("Informe o número "+ (i+1) ); 52 | numeros[i] = teclado.nextInt(); 53 | } 54 | } 55 | 56 | /* 57 | * Procedimento responsável por imprimir os dados contidos no array. 58 | */ 59 | static void imprime(int[] numeros) { 60 | for (int i = 0; i < numeros.length; i++) { 61 | System.out.print(numeros[i]+" "); 62 | } 63 | System.out.println(); 64 | } 65 | 66 | /* 67 | * Procedimento responsável por ordenar o array, utilizando o algoritmo Bubble Sort. 68 | * No fim do procedimento os números contidos no array estarão em ordem numérica. 69 | */ 70 | static void ordena(int[] numeros) { 71 | boolean houveTroca = true; 72 | int aux; 73 | 74 | while (houveTroca) { 75 | houveTroca = false; 76 | for (int i = 0; i < numeros.length - 1; i++){ 77 | //compara o elemento atual (i) c/ o proximo (i+1) 78 | if (numeros[i] > numeros[i+1]) { 79 | //faz a troca 80 | aux = numeros[i]; 81 | numeros[i] = numeros[i+1]; 82 | numeros[i+1] = aux; 83 | 84 | //indica que o array deve ser analisado novamente (while) 85 | houveTroca = true; 86 | } 87 | } 88 | } 89 | } 90 | 91 | } 92 | -------------------------------------------------------------------------------- /java/MegaSena.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java simula o sorteio e aposta da Mega Sena. 3 | * O programa sorteia seis números randomicos, sem repetição. O usuário entra com seis números 4 | * de sua aposta. Por fim o programa avalia quantos acertos o usuário obteve! 5 | * 6 | * Objetivos: 7 | * - exercício de lógica; 8 | * - usar a entrada de dados via teclado; 9 | * - uso de funções para organizar o código; 10 | * - uso dos comandos de repetição for e do while. 11 | * - uso da API do Java para geração de números randômicos. 12 | * 13 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 14 | * Author: Eder Magalhães 15 | */ 16 | 17 | import java.util.Scanner; 18 | 19 | public class MegaSena { 20 | 21 | static int NUMERO_DEZENAS = 6; 22 | 23 | public static void main(String[] args) { 24 | Scanner teclado = new Scanner(System.in); 25 | 26 | int[] sorteio = sorteaSena(); 27 | int[] aposta = new int[NUMERO_DEZENAS]; 28 | 29 | //trecho processa a aposta 30 | System.out.println("Faça sua aposta: "); 31 | for (int i = 0; i < NUMERO_DEZENAS; i++) { 32 | int nroAposta; 33 | boolean repetido = false; 34 | 35 | do { 36 | System.out.print("Informe a dezena "+(i+1)+": "); 37 | nroAposta = teclado.nextInt(); 38 | if (nroAposta <= 0) { 39 | System.out.println("Número inválido, aposta cancelada!"); 40 | return; 41 | } 42 | repetido = existeNumero(aposta, nroAposta); 43 | if (repetido) { 44 | System.out.println("Ops, número repetido!"); 45 | } 46 | } while(repetido); // evita repetição de número 47 | 48 | aposta[i] = nroAposta; 49 | } 50 | 51 | System.out.println("\nConfira sua aposta: "); 52 | for (int i = 0; i < aposta.length; i++) { 53 | System.out.print(aposta[i] + " "); 54 | } 55 | 56 | System.out.println("\nResultado do sorteio: "); 57 | for (int i = 0; i < sorteio.length; i++) { 58 | System.out.print(sorteio[i] + " "); 59 | } 60 | 61 | int nroAcertos = contaAcertos(sorteio, aposta); 62 | System.out.println("\nNúmero de acertos: "+nroAcertos); 63 | 64 | switch (nroAcertos) { 65 | case 4: System.out.println("Parabéns. Você acertou a quadra!"); break; 66 | case 5: System.out.println("Parabéns. Você acertou a quina!"); break; 67 | case 6: System.out.println("Parabéns. Você é campeão da MegaSena!"); break; 68 | default: System.out.println("Não foi dessa vez. Tente novamente!"); break; 69 | } 70 | } 71 | 72 | /* 73 | * Função retorna uma array com 6 números gerados randomicamente (API do Java), 74 | * sem duplicidade, representando o sorteio da megasena. 75 | */ 76 | static int[] sorteaSena() { 77 | int[] resultado = new int[NUMERO_DEZENAS]; 78 | 79 | for (int i = 0; i < NUMERO_DEZENAS; i++) { 80 | int sorteado; 81 | boolean repetido = false; 82 | 83 | do { 84 | sorteado = (int) (Math.random()*60)+1; //nro aleatorio de 1 a 60 85 | repetido = existeNumero(resultado, sorteado); 86 | } while(repetido); // evita repetição de número 87 | 88 | resultado[i] = sorteado; 89 | } 90 | return resultado; 91 | } 92 | 93 | /* 94 | * Função comparada cada número apostado, com os números sorteados. 95 | * Por fim retorna a quantidade de acertos. 96 | */ 97 | static int contaAcertos(int[] sorteio, int[] aposta) { 98 | int acertos = 0; 99 | for (int i = 0; i < NUMERO_DEZENAS; i++) { 100 | int nroAposta = aposta[i]; 101 | 102 | //compara cada nro apostado com os sorteados 103 | if (existeNumero(sorteio, nroAposta)) { 104 | acertos++; 105 | } 106 | } 107 | return acertos; 108 | } 109 | 110 | /* 111 | * Função indica se o n existe no array numeros. 112 | * Útil para validar duplicadade de dados. 113 | */ 114 | static boolean existeNumero(int[] numeros, int n) { 115 | for (int i = 0; i < numeros.length; i++) { 116 | if (numeros[i] == n) { 117 | return true; 118 | } 119 | } 120 | return false; 121 | } 122 | 123 | } 124 | -------------------------------------------------------------------------------- /java/arquivos/Arquivo.java: -------------------------------------------------------------------------------- 1 | import java.io.BufferedReader; 2 | import java.io.BufferedWriter; 3 | import java.io.File; 4 | import java.io.FileReader; 5 | import java.io.FileWriter; 6 | import java.io.IOException; 7 | import java.io.Reader; 8 | import java.io.Writer; 9 | import java.util.StringTokenizer; 10 | 11 | /** 12 | * Componente (objeto) reune as operações (funcionalidades) para manipulação em arquivo texto. 13 | * 14 | * Esse componente é utilizado em diversas demonstrações no material da Academia do Programador. 15 | * 16 | * Author: Globalcode 17 | */ 18 | public class Arquivo { 19 | 20 | private String nomeArquivo; 21 | private Reader in; 22 | private Writer out; 23 | private BufferedReader leitor; 24 | 25 | private Arquivo(String nomeArquivo) { 26 | this.nomeArquivo = nomeArquivo; 27 | } 28 | 29 | public static Arquivo abrirLeitura(String nomeArquivo) { 30 | Arquivo a; 31 | try { 32 | a = new Arquivo(nomeArquivo); 33 | a.in = new FileReader(new File(nomeArquivo)); 34 | a.leitor = new BufferedReader(a.in); 35 | log("Arquivo aberto para leitura", nomeArquivo); 36 | } catch (IOException e) { 37 | a = null; 38 | log("Problema ao tentar abrir arquivo para leitura", nomeArquivo); 39 | } 40 | return a; 41 | } 42 | 43 | public static Arquivo abrirEscrita(String nomeArquivo, String operacao) { 44 | Arquivo a; 45 | File f = new File(nomeArquivo); 46 | try { 47 | a = new Arquivo(nomeArquivo); 48 | boolean append = false; 49 | if (operacao.equalsIgnoreCase("new")) { 50 | f.createNewFile(); 51 | } else if (operacao.equalsIgnoreCase("truncate")) { 52 | append = false; 53 | } else if (operacao.equalsIgnoreCase("append")) { 54 | append = true; 55 | } 56 | a.out = new FileWriter(f, append); 57 | log("Arquivo aberto para escrita", nomeArquivo); 58 | } catch (IOException e) { 59 | a = null; 60 | log("Problema ao tentar abrir arquivo para escrita", nomeArquivo); 61 | } 62 | return a; 63 | } 64 | 65 | public static void escrever(Arquivo a, String texto) { 66 | if (a != null) { 67 | try { 68 | BufferedWriter b = new BufferedWriter(a.out); 69 | b.write(texto); 70 | b.newLine(); 71 | b.flush(); 72 | log("Texto escrito no arquivo : " + texto, a.nomeArquivo); 73 | } catch (IOException e) { 74 | log("Problema ao tentar escrever no arquivo", a.nomeArquivo); 75 | } 76 | } else { 77 | log("Arquivo nao esta aberto para escrita.", ""); 78 | } 79 | } 80 | 81 | public static String lerLinha(Arquivo a) { 82 | if (a != null) { 83 | String texto = null; 84 | try { 85 | texto = a.leitor.readLine(); 86 | } catch (IOException e) { 87 | log("Problema ao tentar ler do arquivo", a.nomeArquivo); 88 | } 89 | return texto; 90 | } else { 91 | log("Arquivo nao esta aberto para leitura.", ""); 92 | } 93 | return null; 94 | } 95 | 96 | public static void fechar(Arquivo a) { 97 | if (a != null) { 98 | try { 99 | if (a.in != null) { 100 | a.in.close(); 101 | } 102 | } catch (IOException e) { } 103 | try { 104 | if (a.out != null) { 105 | a.out.close(); 106 | } 107 | } catch (IOException e) { } 108 | log("Fechando arquivo", a.nomeArquivo); 109 | } else { 110 | log("Arquivo nao esta aberto.", ""); 111 | } 112 | } 113 | 114 | public static String[] separaTokens(String linha, String separador) { 115 | StringTokenizer s = new StringTokenizer(linha, separador); 116 | String[] tokens = new String[s.countTokens()]; 117 | for (int i = 0; s.hasMoreTokens(); i++) { 118 | tokens[i] = s.nextToken(); 119 | } 120 | return tokens; 121 | } 122 | 123 | public static void renomear(String nomeArquivo1, String nomeArquivo2) { 124 | File f1 = new File(nomeArquivo1); 125 | if (f1.exists()) { 126 | File f2 = new File(nomeArquivo2); 127 | f1.renameTo(f2); 128 | log("Renomeando arquivo", nomeArquivo1); 129 | } else { 130 | log("Arquivo nao existe.", nomeArquivo1); 131 | } 132 | } 133 | 134 | public static void apagar(String nomeArquivo) { 135 | File f = new File(nomeArquivo); 136 | if (f.exists()) { 137 | f.delete(); 138 | log("Apagando arquivo.", nomeArquivo); 139 | } 140 | 141 | } 142 | 143 | private static void log(String texto, String nomeArquivo) { 144 | //System.out.println("log - " + nomeArquivo + " - " + texto); 145 | } 146 | } 147 | -------------------------------------------------------------------------------- /java/arquivos/CadastroClientesArquivo.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa Java implementa um cadastro de clientes, com entrada via teclado 3 | * e armazenamento em arquivo texto. 4 | * 5 | * Esse programa utiliza o componente Arquivo.java. 6 | * 7 | * Objetivos: 8 | * - manipular dados em um arquivo texto. 9 | * 10 | * Módulo: Lógica de programação | Capítulo: XXX | Página: XXX 11 | * Author: Eder Magalhães 12 | */ 13 | 14 | import java.util.Scanner; 15 | 16 | public class CadastroClientesArquivo { 17 | //nome do arquivo em que os dados sao armazenadoss 18 | static String nomeAquivo = "clientes.txt"; 19 | 20 | public static void main(String[] args) { 21 | Scanner teclado = new Scanner(System.in); 22 | //habilita a tecla enter como separador de conteúdo 23 | teclado.useDelimiter(System.getProperty("line.separator")); 24 | 25 | int opcao; 26 | 27 | do { 28 | //exibe o menu de navegação do usúario 29 | montaMenu(); 30 | opcao = teclado.nextInt(); 31 | 32 | switch (opcao) { 33 | case 1: 34 | System.out.println("-- Inserindo clientes no arquivo --------"); 35 | System.out.println("Informe o Nome: "); 36 | String nome = teclado.next(); 37 | 38 | System.out.println("Informe o CPF: "); 39 | String cpf = teclado.next(); 40 | 41 | // grava dados no arquivo 42 | grava(nome, cpf); 43 | System.out.println("-----------------------------------------"); 44 | break; 45 | case 2: 46 | System.out.println("-- Listando clientes do arquivo ---------"); 47 | // Le dados do arquivo 48 | lista(); 49 | System.out.println("-----------------------------------------"); 50 | break; 51 | //remover esse case (lab opcional) 52 | case 0: 53 | System.out.println("-- Apagando cliente do arquivo ----------"); 54 | System.out.println("CPF do cliente: "); 55 | String cpfRemover = teclado.next(); 56 | remove(cpfRemover); 57 | System.out.println("-----------------------------------------"); 58 | break; 59 | case 3: 60 | System.out.println("-- Finalizando programa -----------------"); 61 | break; 62 | default: 63 | System.out.println("Opção inválida!"); 64 | break; 65 | } 66 | 67 | } while (opcao != 3); 68 | 69 | } 70 | 71 | /* 72 | * Procedimento monta na console um menu de navegação. 73 | */ 74 | static void montaMenu() { 75 | System.out.println(""); 76 | System.out.println("0 - Apagar cliente"); //lab opcional 77 | System.out.println("1 - Novo cliente"); 78 | System.out.println("2 - Lista clientes"); 79 | System.out.println("3 - Finalizar"); 80 | System.out.println("Digite a opcao desejada: "); 81 | System.out.println(""); 82 | } 83 | 84 | /* 85 | * Procedimento responsável por cadastrar os dados do cliente no arquivo. 86 | */ 87 | static void grava(String nome, String cpf) { 88 | Arquivo a = Arquivo.abrirEscrita(nomeAquivo, "append"); 89 | //mantem um cliente por linha no arquivo, ex: 01232|Jose da Silva 90 | Arquivo.escrever(a, cpf + "|" + nome); 91 | Arquivo.fechar(a); 92 | } 93 | 94 | /* 95 | * Procedimento responsável por imprimir todos os clientes (linhas) cadastrados no arquivo. 96 | */ 97 | static void lista() { 98 | Arquivo a = Arquivo.abrirLeitura(nomeAquivo); 99 | String linha; 100 | while ((linha = Arquivo.lerLinha(a)) != null) { 101 | String[] dados = Arquivo.separaTokens(linha, "|"); 102 | String cpf = dados[0]; 103 | String nome = dados[1]; 104 | System.out.println("Cliente: " + dados[1] + ", CPF: " + dados[0]); 105 | } 106 | Arquivo.fechar(a); 107 | } 108 | 109 | /* 110 | * Procedimento remove o registro do cliente (linha) do arquivo, se existir. 111 | */ 112 | static void remove(String cpfRemover) { 113 | //renomeia o arquivo original 114 | Arquivo.renomear(nomeAquivo, "clientes.temp"); 115 | Arquivo original = Arquivo.abrirLeitura("clientes.temp"); 116 | Arquivo novo = Arquivo.abrirEscrita(nomeAquivo, "new"); 117 | String linha; 118 | boolean removeu = false; 119 | //copia do original todos os clientes com cpf diferente do informado 120 | while ((linha = Arquivo.lerLinha(original)) != null) { 121 | String[] dados = Arquivo.separaTokens(linha, "|"); 122 | String cpf = dados[0]; 123 | if (cpf.equals(cpfRemover)) { 124 | removeu = true; 125 | } else { 126 | Arquivo.escrever(novo, linha); 127 | } 128 | } 129 | if (removeu) { 130 | System.out.println("Removeu o cliente com cpf "+cpfRemover); 131 | } 132 | 133 | Arquivo.fechar(original); 134 | Arquivo.fechar(novo); 135 | 136 | Arquivo.apagar("clientes.temp"); 137 | } 138 | 139 | } 140 | --------------------------------------------------------------------------------