Aluísio Eustáquio da Silva

1 Aluísio Eustáquio da Silva SciLab Programável Material didático usado em aulas de Programação de Computadores, Algoritmos e Lógica de Programação Betim Maio de 2012

2 PROGRAMAÇÃO O SciLab permite que se criem programas, que são algoritmos escritos numa linguagem que o computador possa enter e executar. Programa de computador é um conjunto de instruções que são codificadas em linguagem de máquina, a linguagem do computador, por um outro programa, e depois executadas. Existem dois tipos de programas para se criar programas: Compiladores: codificam todo o programa para depois executá-lo Interpretadores: codificam e executam instrução por instrução O SciLab está na categoria dos interpretadores. SCRIPTS São arquivos do tipo texto com um conjunto de instruções a serem executadas. Esses arquivos podem ser gravados e usados toda vez que for necessário, sem necessidade de nova digitação. Os scripts são executadas em ordem sequencial, de cima para baixo. Pode-se acrescentar em um programas estruturas que são executadas depo de certas condições e estruturas que se repetem um número finito de vezes. Para criar um script usaremos o próprio editor de scripts do SciLab que apresenta uma série de facilidades, como por exemplo, a convenção de cores abaixo: Azul claro comandos da linguagem Azul escuro funções da linguagem Verde comentários Marrom strings Rosa parênteses Preto variáveis

3 ESTRUTURA DE UM PROGRAMA Exemplo: Adotaremos alguns padrões, não obrigatórios, para tornar os programas simples, legíveis e funcionais: Todo Programa começará com um comentário onde ficará expresso de forma bem clara qual é o objetivo do mesmo, quem o desenvolveu e a data de confecção. Os comandos (instruções) de um programa serão delimitados em uma função com as palavras chaves do SciLab function e function. As instruções do programa serão escritas, uma por linha Cada linha será alinhada à esquerda, com espaços, entações, nas estruturas de um mesmo nível. As palavras chaves do programa serão obrigatoriamente escritas com letras minúsculas Todo identificador de variável que tiver mais de um caractere se iniciará com letra maiúscula Os identificadores compostos terão cada palavra se iniciando com letra maiúscula e separados por travessão (underline). //EXEMPLO 1 //PROGRAMA PARA CONVERTER POLEGADAS EM MILÍMETROS function Polegadas_Milimetros() //inteiro Numerador_Polegada, Denominador_Polegada //real Milimetros printf("************************************************************"); printf("\nprograma para converter polegadas em milímetros"); printf("\n**********************************************************\n"); //ENTRADA DE DADOS Numerador_Polegada = input("digite o numerador de uma medida em polegadas: "); Denominador_Polegada = input("digite o denominador de uma medida em polegadas: "); //PROCESSAMENTO Milimetros = (Numerador_Polegada / Denominador_Polegada) * 25.4; //SAIDA DE RESULTADOS printf("\npolegadas: %d / %d ", Numerador_Polegada, Denominador_Polegada); printf(" = %4.2f ", Milimetros); return; //RETORNA À FUNÇÃO CHAMADORA function Polegadas_Milimetros(); //FIM PROGRAMA PRINCIPAL

4 ESTRUTURAS SEQUENCIAIS De acordo com a sequência das ações executadas por um programa, suas estruturas podem ser classificadas em: Estrutura Sequencial, Condicional ou de Repetição. Nas estruturas sequenciais os comandos serão executados na ordem em que aparecem. Nas estruturas condicionais os comandos são executados ou não, depo de certas condições verdadeiras ou falsas. E nas estruturas de repetição, sequências de comandos serão repetidas depo de condições verdadeiras ou falsas. Para facilitar o desenvolvimento de programas, escreveremos todos os comandos em uma rotina que em SciLab é denominada function. Depois criaremos um programa que chama essa rotina. Esse programa será chamado de programa principal, apesar desse termo não existir em SciLab. //EXEMPLO 2 //PROGRAMA PARA TRANSFORMAR GRAUS FAHRENHEIT EM GRAUS CELSIUS // PROGRAMA PARA TRANSFORMAR GRAUS CELSIUS EM GRAUS FAHRENHEIT function Fahrenheit_Celsius() //real Fahrenheit, Celsius printf("****************************************************"); printf("\nprograma para converter graus Fahrenheit em Celsius"); printf("\n e"); printf("\nprograma para converter graus Celsius em Fahrenheit"); printf("\n***************************************************\n"); //ENTRADA DE DADOS Fahrenheit = input("digite uma temperatura em graus Fahrenheit: "); //PROCESSAMENTO Celsius =(5/9)*( Fahrenheit -32); //SAÍDA DE RESULTADOS printf("\nfahrenhit: %3.1f ", Fahrenheit); printf("\ncelsius: %3.1f ", Celsius); printf("\n\n"); Celsius = input("digite uma temperatura em graus Celsius --> "); Fahrenheit = 9 * Celsius / 5 + 32; printf("\ncelsius: %3.1f ", Celsius); printf("\nfahrenhit: %3.1f ", Fahrenheit); return; //RETORNA À FUNÇÃO CHAMADORA function // function Fahrenheit_Celsius() Fahrenheit_Celsius(); //FIM PROGRAMA PRINCIPAL

5 ESTRUTURAS CONDICIONAIS Os programas anteriores executaram apenas uma sequência de ações, uma após a outra, em uma ordem pré-estabelecida seguindo o padrão: Declaração de variáveis Entrada de dados pelo teclado, sem validação dos mesmos Processamento sequencial (sem desvios ou repetições) Impressão de valores na tela Nos próximos programas introduziremos comandos para controlar a ordem e o número de vezes que uma tarefa deve ser executa. OPERADORES RELACIONAIS São operadores que estabelecem uma relação entre dois operandos, gerando um resultado verdadeiro ou falso. Matemática Significado SciLab = igual a == diferente de <> ou ~= > maior que > < menor que < menor ou igual a <= maior ou igual a >= OPERADORES LÓGICOS São operadores que estabelecem uma conexão entre expressões lógicas. Utilizaremos três operadores lógicos: NÃO ~ OU E & O operador NÃO (~) tem apenas um operando, o OU ( ) e o E (&) têm dois operandos. Esses operadores produzem um resultado lógico ( True = verdadeiro ou False = falso).

6 Para facilitar o entimento, usa-se fazer uma tabela, chamada tabela verdade, com esses operadores. Sejam duas proposições quaisquer p e q p q ~p p q p & q T T F T T T F F T F F T T T F F F T F F ESTRUTURAS CONDICIONAIS SIMPLES if (condição) then bloco de comandos_1 bloco de comandos_2 Funcionamento Se a condição, entre parênteses, for verdadeira será executado o bloco de comandos_1, e posteriormente o bloco de comandos_2, senão (condição falsa) a execução passará diretamente para o bloco de comandos_2. Exemplo: //EXEMPLO 3 //PROGRAMA PARA VERIFICAR SE UM VALOR É MAIOR OU MENOR QUE OUTRO function Maior_Menor() //real Valor_1, Valor_2 //LÊ UM VALOR DA VARIÁVEL Valor_1 Valor_1 = input ("Digite o primeiro valor: "); //LÊ UM VALOR DA VARIÁVEL Valor_2 Valor_2 = input ("Digite o primeiro valor"); //VERIFICA SE Valor_1 É MAIOR QUE Valor_2 if (Valor_1 > Valor_2) then printf("valor_1 é maior que Valor_2"); //SE A CONDIÇÃO ACIMA É VERDADEIRA //FIM DA ESTRUTURA CONDICIONAL //VERIFICA SE Valor_1 É MENOR QUE Valor_2 if (Valor_1 < Valor_2) then printf("valor_1 é menor que Valor_2 "); //SE A CONDIÇÃO ACIMA É VERDADEIRA //FIM DA ESTRUTURA CONDICIONAL return; function //FIM DO FUNÇÃO Maior_Menor Maior_Menor();

7 ESTRUTURA CONDICIONAL DUPLA if (condição) then Bloco de comandos_1 else Bloco de comandos_2 Funcionamento Se a condição, entre parênteses, for verdadeira será executado o bloco de comandos_1, se for falsa será executado o bloco de comandos_2. Exemplo: //EXEMPLO 4 //PROGRAMA PARA VERIFICAR SE UM VALOR É MAIOR OU MENOR QUE OUTRO //VERSÃO 2 function Maior_Menor2() //inteiro Valor_1, Valor_2 //LÊ O VALOR DA VARIÁVEL Valor_1 Valor_1 = input("digite o primeiro valor: ") //LÊ O VALOR DA VARIÁVEL Valor_2 Valor_2 = input("digite o segundo valor:") //VERIFICA SE Valor_1 É MAIOR QUE Valor_2 if (Valor_1 > Valor_2) then printf("valor_1 é maior que Valor_2") //SE A CONDIÇÃO ACIMA É VERDADEIRA else printf("valor_1 é menor que Valor_2") //SE A CONDIÇÃO ACIMA É FALSA //FIM DA ESTRUTURA CONDICIONAL function Maior_Menor2(); //FIM DO PROGRAMA

8 EXEMPLOS Alguns problemas com estruturas condicionais. Programa para ler um número inteiro e escrevê-lo, caso seja número negativo. Um número é negativo se é menor que zero. //EXEMPLO 5 //FUNÇÃO PARA VERIFICAR SE UM NÚMERO É NEGATIVO, POSITIVO OU NULO function Sinal() //real Numero //ENTRADA DE DADOS Numero = input("digite um número"); //PROCESSAMENTO E SAÍDA DE RESULTADOS printf ("%f é ", Numero) if (Numero < 0) then printf (" é negativo"); else if (Numero > 0) then printf (" positivo"); else printf (" nulo"); return; function Sinal(); //FIM PROGRAMA PRINCIPAL

9 Programa para ler a idade de uma pessoa e verificar se ela é ou não, maior de idade. Uma pessoa é maior de idade se possui 18 anos ou mais. //EXEMPLO 6 //PROGRAMA PARA VERIFICAR SE UMA PESSOA É MAIOR DE IDADE OU NÃO function Maioridade() //inteiro Idade //ENTRADA DE DADOS Idade = input("digite idade :") //PROCESSAMENTO E SAÍDA DE RESULTADOS if (Idade < 18) then printf ("Não é maior de idade"); else printf ("É maior de idade"); return; function Programa Maioridade(); para resolver equação do primeiro grau //FIM DO PROGRAMA PRINCIPAL

10 Programa para resolver equação do primeiro grau //EXEMPLO 7 // PROGRAMA PARA RESOLVER EQUAÇÃO DO PRIMEIRO GRAU function Equacao_Primeiro_Grau() //real a, b, x //ENTRADA DE DADOS a = input("digite o coeficiente a "); b = input("digite o coeficiente b"); //PROCESSAMENTO E SAÍDA DE RESULTADOS if (a <> 0) then x = -b / a; printf("\nx = %4.2f é raiz da equação do primeiro grau %2.1fx + %2.1f = 0", x, a, b); else printf ("Impossível resolver equação com a = 0"); return; function Equacao_Primeiro_Grau(); //FIM PROGRAMA PRINCIPAL 2 ESTRUTURAS DE REPETIÇÃO Uma estrutura de repetição é utilizada quando um comando ou uma sequência de comandos de um programa deve ser repetida. Cada linguagem de programação tem suas estruturas específicas de repetição. Os programas em SciLab oferecem duas estruturas de repetição REPETIÇÕES DEPENDENTES DE CONDIÇÃO NO INÍCIO ESTRUTURA while NOTAÇÃO while (condição) bloco de comandos_1 bloco de comandos_2

11 Funcionamento Enquanto a condição entre parênteses for verdadeira o bloco de comandos_1 será executado e quando for falsa o processamento passará ao bloco de comandos_2. Exemplo Trecho de programa para escrever na tela os números inteiros de 0 a 9. 1. x = 0 //Valor inicial de x 2. while (x < 10) //Verifica se x é menor que 10 3. printf( %f, x) //Se a condição é verdadeira escreve x 4. x = x + 1 //Aumenta x em uma unidade 5. //Termina a repetição quando x = 10 6. //Novos comandos Para facilitar o entimento numeramos as linhas de comandos. Comentários: 1) Atribui o valor inicial (0 zero) à variável x. 2) Comando que verifica o valor da variável x, gerando um valor verdadeiro ou falso, que indicará se o processamento continuará na próxima linha de comandos (linha 3) ou se desviará para a linha 6. 3) escreve o valor de x: 0, 1, 2, 3, 4, 5, 6, 7,8, 9 4) aumenta uma unidade na variável x e coloca o resultado na própria variável x que passará a ser: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 (último valor que será o responsável pelo encerramento da estrutura de repetição). 5) limita os comandos da estrutura de repetição. 6) próximos comandos do programa, fora da estrutura de repetição.

12 PROGRAMAS EXEMPLOS DE ESTRUTURAS DE REPETIÇÃO Programa para escrever na tela os números ímpares de 7 a 15. //EXEMPLO 8 //PROGRAMA PARA ESCREVER NA TELA OS NÚMEROS POSITIVOS ÍMPARES, //MENORES QUE N (lido do teclado) function Impares() //inteiro Numero, N //ENTRADA DE DADOS E VALOR INICIAL Numero = 1; N = input ("Digite um inteiro positivo"); //PROCESSAMENTO E SAÍDA DE RESULTADOS while (Numero <= N) printf("%d\t", Numero); Numero = Numero + 2; function // Impares() Impares(); //FIM DO PROGRAMA PRINCIPAL

13 Programa para escrever as letras maiúsculas de F a Q. //EXEMPLO 9 //PROGRAMA PARA ESCREVER AS LETRAS MAIÚSCULAS DE F A Q. function Escreve_Letras() //literal Letra //inteiro x //VALOR INICIAL ( INICIALIZAÇÃO ) Letra = 'F'; //PROCESSAMENTO E SAÍDA DE RESULTADOS x = ascii(letra); //CODIGO ASCII DA LETRA while (x <= ascii('q') ) printf("%s ", ascii(x)); x = x + 1; //REPETE ENQUANTO LETRA <= Q //ESCREVE LETRA //SOMA 1 NO CODIGO DA LETRA function EscreveLetras(); //FIM DO PROGRAMA PRINCIPAL

14 Leia o nome e a altura de três pessoas. Determine e escreva o nome e a altura da pessoa mais alta //EXEMPLO 10 //LER O NOME E A ALTURA DE TRÊS PESSOAS. //DETERMINAR E ESCREVER O NOME E A ALTURA DA PESSOA //MAIS ALTA function Maior_Altura() //real Altura, Maior_Altura //literal Nome, Nome_do_mais_Alto //inteiro Contador Maior_Altura = 0; Contador = 1; //PROCESSAMENTO E SAÍDA DE RESULTADOS while (Contador <= 3) //ENTRADA DE DADOS printf("%dª pessoa de 3", Contador); Nome = input("digite nome", "string"); Altura = input("digite altura : "); if (Altura > Maior_Altura) Maior_Altura = Altura Nome_do_mais_Alto = Nome; Contador = Contador + 1; //WHILE printf("%s é o mais alto dos 3 e mede %f", Nome_do_mais_Alto, Maior_Altura); function Maior_Altura(); //FIM DO PROGRAMA PRINCIPAL

15 ESTRUTURA DE REPETIÇÃO COM VARIÁVEL DE CONTROLE Quando o número de repetições é conhecido, pode-se usar a estrutura: for (Variável = Valor_Inicial: Passo: Valor_Final) Bloco de comandos_1 Bloco de comandos_2 So Variável uma variável cujo valor inicial é Valor_Inicial e cujo valor final é Valor_Final, e Passo é o acréscimo dado a essa variável. O bloco de comandos_1 será executado para cada valor de Variável. Variável sofre um acréscimo Passo, positivo ou negativo, podo ser omitido se a variável aumenta de 1 em 1 Alguns problemas anteriores podem ser resolvidos usando-se essa estrutura. EXEMPLOS Faça um programa para imprimir a tabuada de multiplicação do número inteiro 9. //EXEMPLO 11 //IMPRIMIR A TABUADA DE 9 (MULTIPLICAÇÃO) function Tabuada_9() //inteiro Multiplicador, Fator_Fixo, Produto //Valor inicial Fator_Fixo = 9; //PROCESSAMENTO E SAÍDA DE RESULTADOS for (Multiplicador = 0: 1: 9) Produto = Multiplicador * Fator_Fixo; printf("\n%d * %d = %d ", Multiplicador, Fator_Fixo, Produto); ; function Tabuada_9(); //FIM DO PROGRAMA PRINCIPAL Escreva um programa para escrever todos os números inteiros palíndromos de 4 algarismos. Um número palíndromo ou frase palíndroma é aquela que é idêntica se lida da direita para a esquerda ou da esquerda para a direita.

16 Exemplos: luz azul, acaiaca, ovo, Ana, arara, socorram-me subi no onibus em marrocos 12321, 2002 Para os números palíndromos de 4 algarismos temos o padrão X Y Y X, onde X é um número inteiro de 1 a 9 e Y um número inteiro de 0 a 9. Assim cada número inteiro palíndromo de 4 algarismos será da forma: 1000 X + 100 Y + 10 Y + X //EXEMPLO 12 //ESCREVER OS NÚMEROS PALÍNDROMOS DE 4 ALGARISMOS function Palindromo() //inteiro Numero, X, Y //PROCESSAMENTO E SAÍDA DE RESULTADOS for (X = 1: 9) for (Y = 0: 9) Numero = 1000 * X + 100 * Y + 10 * Y + X; printf("\t%8d", Numero); ; ; //X = 1 até 9 function Palindromo(); //FIM DO PROGRAMA PRINCIPAL

17 Programa que: Leia um número inteiro e positivo N. Calcule e escreva a soma dos N primeiros termos da seqüência: 1/2, 2/5, 3/8, 4/11, 5/14, 6/17,... //EXEMPLO 13 //PROGRAMA QUE: //LER UM NÚMERO INTEIRO E POSITIVO N. //CALCULAR E ESCREVER A SOMA DOS N PRIMEIROS TERMOS DA //SEQÜÊNCIA: //1/2, 2/5, 3/8, 4/11, 5/14, 6/17,... function SomaSequencia() //inteiro Contador, Numerador, Denominador, N //real Soma Soma =0; Numerador = 1; Denominador = 2; //ENTRADA DE DADOS N = input("numero de termos") //PROCESSAMENTO for (Contador = 1: N) Soma = Soma + Numerador / Denominador; Numerador = Numerador + 1; Denominador = Denominador + 3; ; //FIM FOR //E SAÍDA DE RESULTADOS printf ("%f", Soma); function SomaSequencia(); //FIM DO PROGRAMA PRINCIPAL