Introdução À Programação de Computadores Com Inter-S: Roberto Vichinsky 2009

Introdução à
Programação de Computadores
com Inter-S
Roberto Vichinsky
2009
Introdução à Programação de Computadores com INTER-S
Sumário
1. Introdução à Programação................................................................................................ 3
1.1. Uma breve história ...................................................................................................... 3

1.2. O processo de criação de um programa ..................................................................... 4
1.3. Métodos para a criação de programas ........................................................................ 4
1.4. A pseudolinguagem .................................................................................................... 5
1.5. Elementos fundamentais de uma linguagem............................................................... 7
1.5.1. Variáveis ............................................................................................................ 7
1.5.2. Constantes ......................................................................................................... 7
1.5.3. Declarações ....................................................................................................... 8
1.5.4. Expressões ........................................................................................................ 9
1.5.5. Operadores ........................................................................................................ 9
2. Usando o Inter-S para a construção de algoritmos....................................................... 11
2.1. Apresentação do Inter-S ........................................................................................... 11

2.2. Download e Instalação .............................................................................................. 11
2.3. Roteiro para a criação de um programa Inter-S......................................................... 11
3. Instruções de Entrada e Saída ........................................................................................ 17
4. Operadores matemáticos e funções matemáticas ........................................................ 20
4.1. Operadores matemáticos .......................................................................................... 20

4.2. Funções matemáticas ............................................................................................... 21
5. Tela de execução do Inter-S............................................................................................ 23
5.1. Instrução POSICIONE............................................................................................... 23

5.2. Instrução MOLDURA................................................................................................. 24
5.3. Instrução CORTEXTO............................................................................................... 26
5.4. Instrução CORFUNDO.............................................................................................. 27
6. Estruturas condicionais .................................................................................................. 28
6.1. Estrutura de decisão Se...Senão............................................................................... 28

6.2. Estrutura de decisão Caso...FimCaso ....................................................................... 33
7. Estruturas de repetição ................................................................................................... 36
7.1. Estrutura Repita...AteQue ......................................................................................... 36

7.2. Estrutura Enquanto...FimEnquanto ........................................................................... 37
7.3. Estrutura Para...FimPara........................................................................................... 38
1
8. Desvios incondicionais ................................................................................................... 40
8.1. Desvio VaPara .......................................................................................................... 40

8.2. Desvio SubRotina ..................................................................................................... 41
9. Gráficos ............................................................................................................................ 43
9.1. Iniciando a janela gráfica........................................................................................... 44

9.2. Desenhando pontos na janela gráfica ....................................................................... 45
9.3. Desenhando linhas, círculos e elipses na janela gráfica............................................ 46
9.3.1. Linhas............................................................................................................... 46
9.3.2. Círculos ............................................................................................................ 48
9.3.3. Elipses.............................................................................................................. 50
10. Arquivos de Dados ........................................................................................................ 52
10.1. Gravação de registros em um arquivo de dados ..................................................... 53

10.2. Leitura de registros de um arquivo de dados........................................................... 56
10.2.1. Leitura sequencial .......................................................................................... 56
10.2.2. Leitura direta .................................................................................................. 57
10.3. Exclusão de registros de um arquivo de dados ....................................................... 58
10.4. Solucionando problemas......................................................................................... 59
2
1. Introdução à Programação
A proposta deste primeiro capítulo é fornecer as noções básicas sobre programação de
computadores. Veremos uma breve história da programação e abordaremos alguns conceitos
introdutórios sobre programas de computador. Ao final, você saberá o que é uma linguagem
de programação, seus elementos básicos e como aplicar a técnica da pseudolinguagem para
o desenvolvimento de algoritmos lógicos.
1.1. Uma breve história

Antes de entrarmos na discussão histórica, é importante sabermos o que é um programa de
computador. Façamos uma breve definição: Programa de computador é um conjunto de
instruções que orientam o computador a realizar uma determinada tarefa. Este conjunto de
instruções deve ser escrito em uma linguagem que o computador entenda, chamada de
linguagem de programação.
Assim como as linguagens naturais servem como ferramenta à comunicação entre seres
humanos, as linguagens de programação servem à comunicação entre o homem e o
computador. Estas linguagens permitem ao homem escrever conjuntos de instruções
(programas) que possam ser executados pelo computador.
Os primeiros computadores eletrônicos eram programados de forma bastante rudimentar. As
instruções eram introduzidas no formato de cadeias de dígitos binários (este tipo de
programação passou a ser chamado de “programação em linguagem de máquina”). O
processo para a produção de programas em linguagem de máquina era muito trabalhoso, o
que tornava a tarefa de programação muito demorada e os resultados pouco confiáveis.
Procurando soluções para gerar maior produtividade na construção de programas,
pesquisadores dirigiram esforços para o desenvolvimento de linguagens de maior nível, ou
seja, linguagens que se assemelhassem mais às linguagens naturais e que pudessem ser
traduzidas automaticamente para a linguagem de máquina e, desta forma, reconhecidas pelo
computador. Chamamos de linguagens de baixo nível aquelas que são mais próximas à
linguagem de máquina e, chamamos de linguagens de alto nível, aquelas mais próximas à
linguagem natural.
Como resultado desse esforço, surgiram as primeiras linguagens conhecidas como
linguagens de montagem. Como exemplo podemos citar a linguagem TRANSCODE,
desenvolvida por Pat Hume e Beatrice Worsley da Universidade de Toronto, no início da
década de 1950.
Em meados de 1950 surgiram as primeiras linguagens de programação orientadas para
problemas, ou seja, elaboradas para uma finalidade específica. Veja abaixo a relação das
principais linguagens desenvolvidas a partir de 1954:
• FORTRAN (FORmula TRANslation system) – Desenvolvida para finalidades

matemáticas e científicas – 1954
• ALGOL (ALGOrithmic Language) – Desenvolvida para finalidades gerais – 1958
• COBOL (COmmon Business Oriented Language) – Desenvolvida para finalidades
comerciais –1959
• BASIC (Beginner’s All-purpose Symbolic Instruction Code) – Desenvolvida para
aplicações gerais e orientada aos principiantes –1965
Em resumo, as linguagens de programação, também chamadas de "linguagens simbólicas",

foram criadas com o objetivo de facilitar a tarefa de programação. São mecanismos que
permitem que as instruções sejam escritas em uma linguagem parecida com a linguagem
natural e que podem ser entendidas pelo computador com o auxílio de ferramentas auxiliares:
compiladores e interpretadores.
3
1.2. O processo de criação de um programa

Na prática, a construção de um programa é uma tarefa bastante simples. Basta o
programador escrever as instruções através de um editor de texto padrão, gravar o arquivo de
instruções e, por meio de um software especial (compilador ou interpretador da linguagem),
abrir e executar o arquivo.
O arquivo texto que contém as instruções é chamado de código-fonte ou programa-fonte. O
editor usado para a criação deste arquivo deve possibilitar a geração de textos puros (sem
formatação). Usa-se, por exemplo, o Notepad (bloco de notas do Windows), o EDIT do MS-
DOS ou qualquer outro editor similar. Porém, a maioria dos compiladores e interpretadores de
linguagem fornecem um ambiente de desenvolvimento próprio, onde é possível escrever os
programas diretamente sem a necessidade de editores externos, como é o caso do Inter-S
que utilizaremos neste curso.
1.3. Métodos para a criação de programas

Já vimos que as linguagens de programação foram criadas com o objetivo de facilitar a tarefa
de programação. Assim como as linguagens naturais (português, inglês, alemão, etc.), as
linguagens de programação possuem seus próprios conjuntos de palavras e regras. Um
programa deve ser escrito obedecendo-se rigorosamente às regras da linguagem, pois a falta
de uma vírgula, por exemplo, acarretará o não funcionamento do mesmo.
Existem várias linguagens de programação (Cobol, Basic, Pascal, C, etc.), cada uma com
seus próprios conjuntos de palavras e regras, porém, a maneira de se criar um programa é
semelhante em todas elas: primeiramente deve ser criado um arquivo contendo as instruções
desejadas (programa fonte). Esse arquivo poderá então ser interpretado ou compilado (como
já visto).
Este processo parece ser muito fácil, no entanto, a elaboração das instruções não é tarefa tão
simples, pois exige do programador muito raciocínio lógico, tendo em vista que o computador
é uma máquina e que as instruções a ele passadas devem ser rigorosamente corretas e
adequadas.
O simples conhecimento de uma linguagem não basta para um programador. Qualquer um
pode decorar as palavras e regras de uma linguagem, assim como podemos decorar palavras
da língua grega. Porém, a elaboração de uma frase em grego, ou a elaboração de uma
instrução em linguagem de programação, por exemplo, requer um raciocínio lógico apurado:
uma lógica que dará sentido à frase ou à instrução.
Para criarmos um programa, seja qual for a linguagem de programação utilizada, devemos
primeiramente definir um algoritmo capaz de resolver o problema. Na realidade, o algoritmo é
a estratégia que usamos para ordenar as idéias que serão posteriormente convertidas em
instruções.
Um bom exemplo para ilustrarmos o conceito de "algoritmo" é uma receita culinária, onde
encontramos uma relação de ingredientes e uma descrição do que deve ser feito com eles
para que possamos chegar ao produto final:
Modo de preparo:
- Junte os ovos, o
leite e a farina em
uma tigela.
- Bata até formar...
Ingredientes Instruções para o preparo Resultado (bolo)
Uma receita culinária (exemplo de algoritmo)
4
Um algoritmo para a resolução de um problema computacional é muito semelhante ao

exemplo da receita culinária. Vamos imaginar que queremos construir um programa para
calcular a média final das quatro notas bimestrais de um aluno. O diagrama para este
problema seria o seguinte:
Nota 1 Instruções:
Nota 2 - Obter 4 notas
bimestrais Média
Nota 3
- Somar e dividir por 4
Nota 4
- Mostrar o resultado
Dados de entrada Procedimentos Dado de saída
O problema da média final
Observe que neste exemplo as 4 notas bimestrais são os "ingredientes", ou seja, os dados de
entrada necessários à resolução do problema; o conjunto de instruções corresponde ao
"modo de preparo", ou seja, são os procedimentos a serem realizados pelo programa e a
média final corresponde ao "produto final", que no caso da receita culinária seria o bolo, e
neste caso é o dado de saída.
Podemos concluir que todo algoritmo requer informações externas (dados de entrada), as
quais são processadas gerando resultados fornecidos como dados de saída.
Existem diversos métodos para a representação de um algoritmo, porém, dentro do nosso
curso usaremos apenas um: a pseudolinguagem
1.4. A pseudolinguagem
Uma boa ferramenta para a representação de algoritmos é a pseudolinguagem : uma maneira
de escrevermos as instruções utilizando a língua portuguesa de uma forma estruturada,
aproximando-a da linguagem de programação.
Observe abaixo o algoritmo para a resolução do problema da média final em
pseudolinguagem:
Rotina
Declare nota1, nota2, nota3, nota4, media Numéricos
Receba nota1
Receba nota2
Receba nota3
Receba nota4
media = (nota1+nota2+nota3+nota4) / 4
Escreva media
FimRotina
Note que o algoritmo apresentado utiliza palavras em português e apresenta um certo nível
de estruturação. Isto caracteriza uma pseudolinguagem.
Não existe um padrão definitivo para a representação de algoritmos em pseudolinguagem,
cada autor ou profissional de desenvolvimento acaba criando o seu próprio padrão, desde
que obedecendo alguns princípios básicos: as instruções devem ser representadas através
de verbos no imperativo; expressões matemáticas devem ser representadas da maneira mais
próxima possível da matemática tradicional; devem utilizar sempre a mesma palavra para
representar operações iguais, etc.
5
Importante:
A pseudolinguagem não é compreendida pelo computador. Trata-se apenas de um recurso
auxiliar que o programador utiliza para a definição da sequência lógica do programa antes de
escrevê-lo em linguagem de programação. Porém, para otimizar o estudo da lógica de
programação, desenvolvemos um software capaz de interpretar e executar algoritmos escritos
em pseudolinguagem: o Inter-S.
O Inter-S foi projetado para servir como ferramenta de apoio ao ensino da lógica e técnicas
de programação, tornando-se uma linguagem ideal e bastante sofisticada para esta
finalidade. Permite que o algoritmo seja "executado" pelo computador, possibilitando ao aluno
a constatação imediata do seu funcionamento.
O algoritmo apresentado como exemplo (cálculo da média) foi escrito em Inter-S. Através
deste exemplo podemos esboçar algumas conclusões:
• Um algoritmo Inter-S deve começar com a palavra Rotina e terminar com a palavra
FimRotina, sendo que as demais linhas devem estar alinhadas em uma margem
mais à direita.
• Observe que algumas palavras estão em negrito. Chamadas de palavras chaves ou

instruções, elas representam uma determinada ação dentro do programa. Note que
algumas palavras chaves são verbos no imperativo (Declare, Receba e Escreva).
• A palavra Declare faz a declaração dos dados que serão manipulados pelo
programa. Estes dados (aqui chamados de variáveis) são as informações de
entrada, de saída e, eventualmente, alguma informação intermediária que não é
recebida nem escrita pelo programa (variáveis auxiliares). A palavra Numéricos,
que aparece no final da linha de declaração, indica o tipo de dado, no nosso
exemplo os dados de entrada (nota1, nota2, nota3 e nota4) são numéricos, assim
como o dado de saída (media). Observe que não utilizamos espaços para
identificar os dados ou palavras chaves.
• A palavra Receba instrui o recebimento de um valor, o qual será armazenado na

variável indicada. A instrução Receba nota1 faz com que um dado seja "lido"
(através da entrada padrão, no nosso caso o teclado do computador) e seja
armazenado na variável nota1. Observe que no programa existem quatro
instruções do tipo Receba, uma para cada variável de entrada (nota1, nota2, nota3
e nota4), isto significa que os quatro dados serão recebidos pelo teclado.
• A expressão media = (nota1+nota2+nota3+nota4)/4 representa um cálculo, onde

o sinal de igualdade (=) indica que a variável à esquerda (media) receberá o
resultado. Observe que a operação de divisão é representada por uma barra (/).
• A instrução Escreva media faz com que o conteúdo armazenado na variável media
(o resultado do cálculo) seja escrito na saída padrão, que no nosso caso é o
monitor de vídeo.
6
1.5. Elementos fundamentais de uma linguagem

No exemplo dado no tópico anterior (cálculo da média final) podemos destacar alguns
elementos existentes na representação do algoritmo em Inter-S. Para que você não precise
voltar à página anterior, copiamos o algoritmo logo abaixo:
Rotina
Receba nota1
Receba nota2
Receba nota3
Receba nota4
Escreva media
FimRotina
Neste exemplo, percebemos a presença dos seguintes itens fundamentais: variáveis,

constantes, declarações, expressões, operadores e instruções. Estes são os elementos
fundamentais de qualquer linguagem de programação, os quais estudaremos a seguir.
1.5.1. Variáveis
São áreas de trabalho que devemos reservar na memória do computador para o

armazenamento das informações tratadas pelo programa. O termo variável vem da
característica dessas áreas: o conteúdo pode variar durante a execução do programa.
Toda variável deve possuir um identificador, ou seja, um nome que a identifique. Este nome é
dado pelo próprio programador, obedecendo-se às seguintes regras:
- Um nome de variável deve começar com uma letra;

- Não pode conter espaços em branco nem caracteres especiais;
- Pode conter qualquer letra do alfabeto inglês (maiúsculas e minúsculas), os dígitos
de 0 a 9 (zero a nove) e o caractere underline (_);
- Não pode conter letras acentuadas.
É uma prática saudável atribuir um nome sugestivo a cada variável, ou seja, um nome que
indique o conteúdo que a mesma receberá. Por exemplo, para "batizar" uma variável que
receberá o valor de um salário poderíamos utilizar o nome VL_SALARIO, desta forma
teríamos um algoritmo melhor documentado, pois o nome da variável já indicaria o seu
conteúdo. No nosso exemplo (cálculo da média) utilizamos 5 variáveis:
nota1 para armazenar a nota do 1º bimestre

media para armazenar o resultado do cálculo da média
1.5.2. Constantes
Assim como as variáveis, constantes são áreas reservadas na memória do computador para
o armazenamento de informações, porém, a característica básica de uma constante é que
seu conteúdo não sofrerá alteração durante a execução do programa, ou seja, seu conteúdo
7
será constante. Podem receber ou não um identificador. Observe no algoritmo a presença da

seguinte linha:
Esta linha corresponde ao cálculo da média, onde os conteúdos das variáveis nota1, nota2,
nota3 e nota4 serão somados e dividido pela constante 4 (/4).
Observe que a constante terá sempre o valor 4, independentemente dos conteúdos atribuídos
às variáveis nota1 a nota4.
Neste nosso exemplo não houve a necessidade de se dar um nome à constante, ela
simplesmente foi colocada na fórmula. Mas poderíamos lhe atribuir um nome, desta forma
teríamos o seguinte algoritmo:
Rotina
Declare divisor Numérico
divisor=4
Receba nota1
Receba nota2
Receba nota3
Receba nota4
media = (nota1+nota2+nota3+nota4) / divisor
Escreva media
FimRotina
Note que foram colocadas duas linhas a mais: Declare divisor Numérico e divisor=4, a
primeira linha declara uma variável numérica com nome divisor, e a segunda linha atribui o
conteúdo 4 a ela. Na fórmula utilizamos o nome da constante em substituição ao seu
conteúdo:
media = (nota1+nota2+nota3+nota4) / divisor
1.5.3. Declarações
Toda variável ou constante deve ser declarada com um nome e um tipo antes de ser utilizada
no algoritmo, com exceção das constantes aplicadas diretamente em uma expressão (como
vimos no exemplo anterior).
Temos apenas uma instrução de declaração: Declare, que é utilizada tanto para a declaração
de variáveis como para a declaração de constantes.
Os tipos para a declaração são Numérico e Caractere, o primeiro indica que a variável ou
constante poderá armazenar apenas informações numéricas (números), e o segundo indica
que a variável ou constante só poderá receber informações do tipo texto (caracteres). Veja
exemplos abaixo:
Declare valor, total Numéricos Declara as variáveis valor e total como numéricas
Declare nome Caractere Declara a variável nome como caractere (texto)
8
1.5.4. Expressões
São combinações de variáveis, constantes e operadores em uma única sentença, que têm
como finalidade a obtenção de um resultado. As expressões mais comuns são as aritméticas.
Observando o nosso algoritmo para o cálculo da média, destacamos a seguinte expressão:
(nota1+nota2+nota3+nota4) / 4
É uma expressão aritmética onde combinamos variáveis (nota1 a nota4), constante (4) e
operadores (+ e /). A finalidade desta expressão é a obtenção da média, que posteriormente
será armazenada na variável media: Veja a instrução completa:
1.5.5. Operadores
São símbolos que representam as operações em uma expressão. Temos três tipos básicos
de operadores: aritméticos, relacionais e lógicos.
Os operadores aritméticos são aqueles utilizados em expressões numéricas. A tabela a
seguir os apresenta na ordem de precedência (prioridade em que são efetuadas as
operações):
Operadores aritméticos
Operação Operador
Exponenciação ^
Multiplicação *
Divisão /
Adição +
Subtração -
Parte inteira da divisão \ ou DIV
Resto da divisão (módulo) % ou MOD
Os operadores relacionais permitem a comparação de 2 valores (constantes ou variáveis) de

mesmo tipo:
Operadores relacionais
Operação Operador
Igual a =
Maior que >
Menor que <
Maior ou igual a >=
Menor ou igual a <=
Diferente de #
9
Operadores lógicos são os que utilizam a lógica booleana para a construção de expressões
condicionais:
Operadores lógicos
Operação Operador
Conjunção E
Disjunção OU
Negação NÃO
NOTA: É natural que você ainda não compreenda ou não enxergue onde e como
utilizar os operadores relacionais e lógicos. Não se assuste com isso (pelo menos
por enquanto!). No decorrer do curso teremos subsídios suficientes para entendê-
los.
Além dos três tipos básicos, temos um outro operador denominado operador de atribuição.
Este operador permite atribuir valores às variáveis. Veja a instrução para o cálculo da média
do nosso exemplo:
Observe que a variável media está recebendo o resultado de uma expressão aritmética. O
operador = (sinal de igualdade) indica que a variável à esquerda é aquela que receberá o
resultado do cálculo (que, neste caso, é a própria variável media).
10
2. Usando o Inter-S para a construção de algoritmos

Neste capítulo será apresentado o Inter-S: um software que permite a criação e execução de
algoritmos em pseudolinguagem.
2.1. Apresentação do Inter-S

O Inter-S é um ambiente de desenvolvimento que permite a criação de programas de
computador utilizando uma linguagem simples, em português, de fácil aprendizado e de fácil
utilização.
Este ambiente oferece um editor de programas e ferramentas para a interpretação, execução
e depuração do algoritmo, além de ferramentas auxiliares como estruturação do programa e
ajuda "on-line".
2.2. Download e Instalação

A instalação do Inter-S é bastante simples: faça o download do programa de instalação
através do endereço http://www.vichinsky.com.br/downloads/IS_setup_GR.exe, em seguida
execute o instalador aceitando todos os parâmetros oferecidos durante o processo de
instalação.
O instalador criará uma pasta chamada "Inter-S" no menu Iniciar/Programas, contendo um
guia de referência e o programa Inter-S (Interpretador de Soluções).
Será criado também, no seu desktop, um atalho para acesso direto ao software:
Nota: Consulte o guia de referência para obter maiores informações sobre o produto.
2.3. Roteiro para a criação de um programa Inter-S

Para ilustrar os procedimentos para a criação de um programa Inter-S, vamos utilizar o
exemplo do cálculo da média visto no capítulo 1. Iremos construir o algoritmo usando o Inter-
S, mostrando o processo passo a passo:
1º Passo – Edição do algoritmo
Abra o Inter-S e digite o programa (algoritmo do cálculo da média):
Rotina
Receba nota1
Receba nota2
Receba nota3
Receba nota4
Escreva media
FimRotina
11
Observe que você não precisa usar a estruturação, ou seja, o deslocamento para a direita das
instruções entre as palavras Rotina e FimRotina. Você pode simplesmente digitar o
algoritmo sem se preocupar com a estruturação, assim como mostra a figura abaixo:
Porém, a estruturação é um procedimento altamente recomendável, pois é ela que dará maior
clareza ao programa. Para que o Inter-S estruture automaticamente o algoritmo, use o
comando "Estruturar" da barra de ferramentas, como mostra a figura abaixo:
Clique aqui para

estruturar o
algoritmo
12
2º Passo – Gravação do algoritmo
Após a digitação e estruturação do algoritmo, você deve gravá-lo. Para este procedimento,
use o menu Arquivo/Salvar ou o comando Salvar da barra de ferramentas:
Menu "Arquivo/Salvar" Comando "Salvar"
Na janela de gravação (janela "Salvar"), escolha a pasta destino (onde o algoritmo ficará
armazenado) e digite um nome para o arquivo. Procure sempre dar um nome sugestivo para
que fique mais fácil a sua localização no futuro. O Inter-S sugere como padrão o nome
"SemNome", que é uma forma de lembrá-lo que o arquivo não possui um nome adequado.
Para este nosso programa, dê o nome "Média" (bem sugestivo, não acha?). Não há
necessidade de digitar o sufixo .ALG, o próprio Inter-S se encarregará disso:
Digite aqui o nome do

programa (Media) e
clique em "Salvar"
Observações:
Para nomes de arquivos, nunca use espaços ou caracteres especiais, procure usar nomes
pequenos e, apesar de possível, evite usar acentuação ou cedilha.
13
3º Passo – Execução do algoritmo
A expressão "executar" ou "rodar" é um termo usado para referenciar o processo através do

qual o computador faz a leitura do algoritmo e executa as instruções nele presentes. Para
acionar esse processo use o menu "Executar/Executar" ou clique sobre o comando
"Executar" da barra de ferramentas:
Menu
"Executar/Executar" Comando "Executar"
Surgirá a tela de execução conforme ilustração abaixo. Clique mais uma vez no local indicado
para iniciar a execução do algoritmo:
Clique aqui para

iniciar a
execução
Observações:
Caso o algoritmo tenha sofrido alguma alteração, o Inter-S pedirá para você gravá-lo
novamente antes da execução.
Você deve ter notado que durante a execução do programa aparece na tela apenas uma
espécie de cursor (_) aguardando a digitação da primeira nota, conforme imagem abaixo:
Cursor
aguardando a
digitação
14
Você deve digitar a primeira nota e teclar Enter. O cursor pulará para a próxima linha e
esperará pela segunda nota. Desta forma, você deve informar todas as notas para que no
final o computador mostre a média:
Após a digitação das

quatro notas, o
computador exibe a
média aritmética
Após a execução, aparecerá dentro de um retângulo amarelo a mensagem "Programa

encerrado normalmente – Tecle algo". Esta mensagem indica que o computador finalizou
normalmente a execução do algoritmo. Caso o computador encontre algum erro no programa,
surgirá um retângulo azul informando onde se encontra esse erro para que você possa
corrigi-lo.
Para melhorar a aparência do programa e torná-lo mais amigável, altere as instruções

Receba e Escreva introduzindo mensagens para orientar o usuário. Faça as alterações
conforme mostra a figura abaixo:
Nas instruções Receba,

inclua uma mensagem
entre aspas e em seguida
coloque uma vírgula
(conforme indicado no
algoritmo)
Faça o mesmo
para a instrução
Escreva
15
Agora salve e execute o algoritmo. Veja como a tela de execução ficará mais amigável:
16
3. Instruções de Entrada e Saída

A partir deste capítulo, iremos estudar todos os recursos que você deve conhecer para
elaborar programas de qualidade em Inter-S. Iniciaremos com o estudo das instruções
RECEBA (entrada) e ESCREVA (saída). Para isto, vamos desenvolver um programa que lê
dois números pelo teclado e mostra a soma dos mesmos. (Nome do programa: ENT_SAI), em
seguida faremos alguns comentários para explicar a programação:
// Programa: ENT_SAI
// Autor : <nome-do-programador>
// Data : 99/99/9999
Rotina
Declare valor1, valor2, resultado Numerico
Receba valor1
Receba valor2
Resultado = valor1 + valor2
Escreva resultado
FimRotina
Comentários:
Observe que as três primeiras linhas do algoritmo em Inter-S começam com duas barras (//).
Essas linhas não são reconhecidas como instruções, são consideradas comentários que
possibilitam ao programador introduzir algumas informações somente para documentar o
programa. Observe que estas linhas trazem as seguintes informações: nome do programa
(ENT_SAI), autor (nome do programador) e data de criação. Porém, o programador pode
escrever o que achar necessário para documentar o programa, desde que as linhas de
documentação (ou comentários) comecem com duas barras (//).
As linhas seguintes expressam o algoritmo propriamente dito. Entre as palavras Rotina e

FimRotina existem as linhas de instruções que estudaremos a seguir:
Declare valor1, valor2, resultado Numérico

A expressão Declare processa a declaração das variáveis que serão utilizadas pela
rotina. Definimos os nomes das variáveis e o tipo de dado que elas armazenarão. Neste
exemplo estamos declarando as variáveis valor1, valor2 e resultado, as quais receberão
valores numéricos.
Receba valor1
Esta instrução faz a leitura da entrada padrão (teclado) e coloca o conteúdo lido na
variável especificada: valor1. Em outras palavras, esta instrução espera que o usuário
digite um valor, colocando-o na variável valor1.
Receba valor2
Instrução semelhante à anterior, mudando apenas a variável que receberá a informação:
valor2.
17

Esta é uma instrução de atribuição: é efetuado um cálculo (valor1+valor2) e o resultado é
colocado na variável resultado, ou seja, a variável resultado receberá a soma dos
conteúdos das variáveis valor1 e valor2.
Escreva resultado
Esta instrução envia uma informação para a saída padrão (vídeo). Escreva resultado faz
com que o conteúdo da variável resultado seja escrito no vídeo.
Instrução correspondente em linguagem C:
Implementando novos recursos no programa ENT_SAI

Se você já construiu o algoritmo ENT_SAI usando o Inter-S, deve ter notado que o programa,
quando executado, não oferece nenhuma informação na tela para que o usuário saiba o que
fazer. Aparece simplesmente uma tela em branco com um ponteiro (cursor) que indica o local
onde o usuário deve digitar o primeiro valor. Porém, se o usuário não conhecer o programa,
ele ficará totalmente perdido, sem saber o que fazer.
Para resolver esse problema, vamos colocar as informações necessárias para que o
programa mostre na tela algumas mensagens para orientar o usuário. Veja como ficará o
nosso algoritmo:
// Programa: ENT_SAI
// Autor <nome-do-programador>
// Data : 99/99/9999
Rotina
Declare valor1, valor2, resultado Numerico
Escreva "Programa ENT_SAI"
Receba "Digite o 1º valor:", valor1
Escreva "Soma dos valores:", resultado
FimRotina
Veja abaixo as explicações dos novos recursos:
Escreva "Programa ENT_SAI"

Já vimos que a instrução Escreva faz com que algo seja escrito na tela. Para que o
computador escreva uma mensagem, devemos informá-la entre aspas. Neste nosso exemplo
queremos que apareça na primeira linha da tela a expressão Programa ENT_SAI, portanto,
devemos informá-la entre aspas logo após a instrução Escreva.

A instrução Receba, que faz com que o computador receba um valor digitado pelo usuário,
também pode apresentar uma mensagem na tela. Veja que a mensagem deve ser colocada
entre aspas antes do nome da variável (aquela que receberá o valor digitado). Devemos
separar a mensagem do nome da variável por meio de uma vírgula. Neste exemplo, o
computador escreverá na tela a expressão Digite o 1º valor: e ficará aguardando a digitação.
Desta forma, o usuário será orientado e saberá o que fazer.
18

Temos aqui uma outra instrução de recebimento que apresenta uma mensagem na tela. Veja
que esta linha é semelhante à linha anterior, porém, preparada para receber o segundo valor
(variável valor2).
Escreva "Soma dos valores:", resultado

Mais uma vez estamos empregando a instrução Escreva, só que desta vez queremos
mostrar duas coisas na tela: uma mensagem e o valor da variável resultado. A mensagem
que se encontra entre aspas tem o objetivo de informar ao usuário a natureza do resultado
que será mostrado, ou seja, queremos que o computador mostre na tela a expressão Soma
dos valores: e em seguida mostre o resultado da soma. Desta forma, o usuário saberá do
que se trata aquele valor.
Veja que a mensagem deve ser colocada entre aspas e o nome da variável vem logo em
seguida, separado por uma vírgula.
IMPORTANTE:
A instrução Escreva pode ser utilizada para escrever até mais do que duas informações. Veja
o exemplo abaixo:
// Programa: DATA
// Autor <nome-do-programador>
// Data : 99/99/9999
Rotina
Declare dia numérico
Declare mes caractere
Declare ano numérico
Receba "Digite o dia:",dia
Receba "Digite o mês:",mes
Receba "Digite o ano:",ano
Escreva "São Paulo ",dia," de ",mes," de ",ano
FimRotina
No programa acima estamos declarando três variáveis: dia (numérico), mes (caractere) e ano
(numérico). Note que a variável mes (sem acento, pois um nome de variável não pode conter
acentuação) foi declarada como caractere para que possa receber o nome do mês (janeiro,
fevereiro, etc.). As outras variáveis (dia e ano) receberão valores numéricos.
Após as declarações existem três instruções para o recebimento dos valores das variáveis
(instruções Receba) e, finalmente, temos uma instrução Escreva um pouco mais complexa
do que aquelas vistas anteriormente, pois, note que ela escreverá 6 (seis) informações na tela
para compor uma única expressão:
Escreva "São Paulo ",dia," de ",mes," de ",ano
1 2 3 4 5 6
Observe que todas as informações estão separadas por vírgula. As informações entre aspas
serão escritas na tela do mesmo jeito que aparecem na instrução. As informações sem aspas
correspondem às variáveis cujos valores serão mostrados na tela. Portando, imaginando que
o usuário tenha informado os valores: 22 (variável dia), janeiro (variável mes) e 2009 (variável
ano), o computador mostrará na tela a seguinte mensagem:
São Paulo 22 de janeiro de 2009
19
4. Operadores matemáticos e funções matemáticas

Além dos operadores aritméticos: soma (+), subtração (-), multiplicação (*) e divisão (/), o
Inter-S permite a utilização de outros operadores matemáticos, assim como algumas funções
matemáticas muito úteis.
Primeiramente vamos estudar os operadores matemáticos.
4.1. Operadores matemáticos

Em qualquer expressão numérica, notamos a presença de dois agentes básicos: os
operadores e os operandos. Os operadores são os sinais que indicam o tipo de operação
(soma, subtração, etc.) e os operandos são os valores que sofrerão as operações. Veja a
expressão abaixo:
M=(A+B)/2
Nesta expressão, a variável M receberá o resultado do cálculo (A + B) / 2, ou seja, receberá o

resultado da soma das variáveis A e B dividida por 2. Veja que os operandos da expressão
são: A, B e 2; e os operadores são: + (soma) e / (divisão)
Existem sete operadores matemáticos disponíveis no Inter-S.
OPERADOR SIGNIFICADO
+ Adição
- Subtração
* Multiplicação
/ Divisão
^ Exponenciação
MOD ou % Módulo (resto da divisão)
DIV ou \ Parte inteira da divisão
Quando mais de um operador se encontram em uma expressão aritmética, as operações são

efetuadas uma de cada vez respeitando algumas regras de precedência: estas regras são as
mesmas da matemática clássica.
Os operadores de multiplicação (*), divisão (/) e módulo (%) têm precedência sobre os
operadores de adição (+) e subtração (-). Entre operadores de mesma precedência as
operações são efetuadas da esquerda para a direita.
Exemplo: Observe nas expressões abaixo o resultado e a ordem das operações efetuadas:
Expressão Resultado Ordem

1 + 2 - 3 0 + -
24 - 3 * 5 9 * -
4 - 2 * 6 / 4 + 1 2 * / - +
6 / 2 + 11 % 3 * 4 11 / % * +
A ordem de precedência dos operadores pode ser quebrada usando-se parênteses: ( ). Os

parênteses são, na verdade, operadores de mais alta precedência e são executados primeiro.
Parênteses internos são executados primeiro que parênteses externos.
20
Exemplo: Observe nas expressões abaixo o resultado e a ordem das operações efetuadas:
Expressão Resultado Ordem
1 + (2 - 3) 0 - +
(24 - 3) * 5 105 - *
(4 - 2 * 6) / 4 + 1 -1 * - / +
6 / ((2 + 11) % 3) * 4 24 + % / *
Note que os operadores e os operandos deste exemplo são os mesmos do exemplo anterior.
Os resultados, porém, são diferentes, pois a ordem de execução das operações foi
modificada pelo uso dos parênteses.
O programa apresentado abaixo ilustra o uso de operadores matemáticos e precedência de
cálculo. Estude-o com atenção:
// Programa: OPERAC
// Autor : < nome-do-programador >
// Data : 99/99/9999
Rotina
Declare A,B,R numéricos
Receba "Digite o valor de A:",A
Receba "Digite o valor de B:",B
R=A+B
Escreva "A soma dos valores é: ",R
R=(A+B)/2
Escreva "A média dos valores é: ",R
R=(A^2)+(B^2)
Escreva "A soma dos quadrados dos valores é: ",R
R=A-(A+B)/2
Escreva "O valor de A menos a média de A e B é: ",R
FimRotina
4.2. Funções matemáticas

Funções são rotinas internas que fazem parte da linguagem de programação e que têm por
objetivo a realização de tarefas específicas. O Inter-S possui as seguintes funções
matemáticas:
Funções matemáticas
Operações de arredondamento e truncagem

Elimina as casas decimais de um número (N), arredondando-o para o seu
Arredonda(N) próximo inteiro. Exemplo: X=Arredonda(5.8) neste caso o valor da variável
X será 6
Arredonda um número fracionário (N) para uma casa decimal. Exemplo:
Arred1(N)
X=Arred1(7.26) neste caso o valor da variável X será 7.3
Arredonda um número fracionário (N) para duas casas decimais. Exemplo:
Arred2(N)
Arredonda um número fracionário (N) para três casas decimais. Exemplo:
Arred3(N)
Arredonda um número fracionário (N) para quatro casas decimais. Exemplo:
Arred4(N)
21
Elimina as casas decimais de um número (N) sem arredondá-lo. Exemplo:

Trunca(N)
X=Trunca(5.8) neste caso o valor da variável X será 5
Operações trigonométricas
Calcula o arco tangente do ângulo R informado em radianos. Exemplo:
Atn(R) X=Atn(3.1416) neste caso o valor da variável X será 1.2626 (arco tangente
de 180°)
Calcula o cosseno do ângulo R informado em radianos. Exemplo:
Cos(R)
X=Cos(3.1416) neste caso o valor de X será –1 (cosseno de 180°)
Calcula o seno do ângulo R informado em radianos. Exemplo: X=Sen(3.1416)
Seno(R)
neste caso o valor de X será 0 (seno de 180°)
Calcula a tangente do ângulo R informado em radianos. Exemplo:
Tan(R)
X=Tan(0.7854) neste caso o valor de X será 1 (tangente de 45°)
Outras
Calcula a base e (logaritmo natural) à potência de N. Exemplo: X=Exp(2)
Exp(N)
neste caso o valor da variável X será 7.3891
Calcula o logaritmo natural (neperiano) de N. Exemplo: X=Log(100) neste
Log(N)
caso o valor de X será 4.6052
Calcula a raiz quadrada do número (N). Exemplo: X=Raiz(9) neste caso o
Raiz(N)
valor da variável X será 3
Para ilustrar o uso das funções, vamos construir um programa para calcular o comprimento
da hipotenusa tendo como valores de entrada os comprimentos dos catetos A e B de um
triângulo retângulo (Teorema de Pitágoras). Primeiramente vamos relembrar a fórmula:
Hipotenusa = A2 + B2
Veja que os operandos da expressão são A e B (os catetos), os operadores são a soma e a
exponenciação e ainda devemos usar a função para calcular a raiz quadrada. Em Inter-S
devemos representar o cálculo por meio da seguinte instrução:
H = Raiz((A^2)+(B^2))
Veja como ficaria o nosso programa:
// Programa: PITAGORAS
// Data : 99/99/9999
Rotina
Declare A,B,H numéricos
Receba "Digite o valor do Cateto A: ", A
Receba "Digite o valor do Cateto B: ", B
H=Raiz((A^2)+(B^2))
Escreva "O valor da Hipotenusa é: ", H
FimRotina
22
5. Tela de execução do Inter-S

Como já sabido, o objetivo de todo e qualquer programa de computador é o processamento
dos dados de entrada de forma a gerar os dados de saída. Desta forma, os comandos de
entrada e saída de informações sempre estarão presentes em nossos programas.
A tela de execução do Inter-S (ou janela de execução) é o canal de comunicação entre o
usuário e o computador durante a execução de um algoritmo (programa). É através desta
tela, também chamada de interface, que o usuário digita as informações de entrada e obtém
as informações de saída. Portanto, a tela de execução tem um papel muito importante: é por
meio dela que conversamos com o computador.
Para que as telas tenham uma aparência melhor, o Inter-S possui um conjunto de instruções
que permite a elaboração de telas mais sofisticadas. Neste capítulo, iremos estudar essas
instruções. Mas antes disso, vamos estudar alguns aspectos da tela de execução:
A tela de execução do Inter-S é considerada "textual", ou seja, ela aceita apenas textos. É
formada por uma matriz de 25 linhas por 80 colunas, onde cada célula pode conter apenas
um caractere.
A matriz de 25 linhas por 80 colunas é invisível, serve apenas como referência para o
posicionamento dos textos.
80 colunas
25 linhas
Vejamos agora o conjunto de instruções do Inter-S que permite explorar a tela de execução:
5.1. Instrução POSICIONE

Esta instrução posiciona o cursor (ponteiro de tela) em uma determinada linha e coluna para
que a próxima instrução de escrita (Escreva) utilize essa posição para escrever a mensagem.
Por exemplo, se você quiser que o texto "Olá pessoal" seja escrito na linha 3 a partir da
coluna 10, basta usar a instrução Posicione 3,10 antes da instrução Escreva "Olá pessoal".
O programa ficaria assim:
23
// Programa: OLA
// Data : 99/99/9999
Rotina
Posicione 3,10
Escreva "Olá pessoal"
FimRotina
Podemos aplicar a instrução Posicione sempre que necessário, basta informar a posição
onde o texto da próxima instrução Escreva deve aparecer, lembrando que a primeira
informação é a linha e a segunda, separada por vírgula, é a coluna.
5.2. Instrução MOLDURA

Esta instrução possibilita o desenho de molduras retangulares na tela.
Uma moldura é uma área retangular que se inicia em uma determinada posição (linha inicial e
coluna inicial) e termina em outra posição (linha final e coluna final), onde a posição inicial é o
canto esquerdo superior e a posição final é o canto direito inferior. Veja a ilustração abaixo:
17
16
63
Note que no exemplo acima a moldura retangular começa na linha 4 e coluna 17 (canto
esquerdo superior) e termina na linha 16 e coluna 63 (canto direito inferior). Para conseguir tal
efeito, devemos utilizar a instrução Moldura da seguinte forma:
Moldura 4,17,16,63,branco
Onde:
4,17 é a posição inicial (linha 4 e coluna 17)
16,63 é a posição final (linha 16 e coluna 63)
branco é a cor de preenchimento do retângulo
24
Veja que devemos definir uma cor de preenchimento. Portanto, o conceito de moldura no
Inter-S é um pouco mais abrangente, na realidade, uma moldura em Inter-S é uma área
retangular emoldurada e preenchida com uma determinada cor. Se a cor de preenchimento
for igual à cor da tela, teremos então um efeito apenas de borda, a qual terá a mesma cor dos
textos (que também pode ser definida – veja como definir a cor dos textos no tópico 3.3 –
instrução CorTexto).
O programa abaixo ilustra o uso da instrução Moldura. Analise-o:
// Programa: MOLDURAS
// Data : 99/99/9999
Rotina
Moldura 2,27,3,37,celeste+
Posicione 2,28
Escreva "Molduras"
Moldura 3,10,5,13,azul+
Moldura 7,10,10,20,vermelho+
Moldura 10,13,15,18,amarelo
Moldura 2,15,8,25,verde
Pausa
FimRotina
Observe que antes da instrução FimRotina existe uma linha com a palavra Pausa. Esta linha
é uma instrução que faz o processamento ser congelado até que o usuário digite uma tecla
qualquer. Ela é muito útil para que o seu programa não termine bruscamente.
A imagem abaixo representa a execução, ou seja, a tela de execução do programa:
25
O formato geral da instrução Moldura é mostrado abaixo (observe que todos as informações
– linhas, colunas e cor – devem estar separadas por vírgula):
Moldura Li, Ci, Lf, Cf, Cor
Onde:
Li é a linha inicial (canto esquerdo superior)
Ci é a coluna inicial (canto esquerdo superior)
Lf é a linha final (canto direito inferior)
Cf é a coluna final (canto direito inferior)
Cor é uma das 16 cores permitidas, de acordo com a tabela abaixo:
BRANCO BRANCO+
AMARELO AZUL
AZUL+ VERMELHO
VERMELHO+ VERDE
VERDE+ CELESTE
CELESTE+ MAGENTA
MAGENTA+ MARROM
CINZA PRETO
Nota: Observe que algumas cores permitem o uso do sinal de mais (+). Este sinal indica que
a cor é mais intensa.
5.3. Instrução CORTEXTO

Você já deve ter reparado que todos os caracteres mostrados na tela de execução do Inter-S
têm a cor preta. Esta é a cor padrão, ou seja, é a cor original que o Inter-S utiliza. Porém, por
meio da instrução CorTexto, podemos alterar a cor das letras. Usando a instrução CorTexto
seguida pelo nome da cor, todas as mensagens de tela, a partir deste momento, serão
escritas com a cor definida.
Além de alterar a cor dos textos, esta instrução também altera a cor das molduras, ou melhor,
das bordas das molduras.
Veja abaixo um programa exemplo e a respectiva tela de execução:
// Programa: TEXTO
// Data : 99/99/9999
Rotina
CorTexto verde
Escreva "Esta mensagem está em verde"
CorTexto vermelho+
Escreva "Esta mensagem está em vermelho+"
CorTexto azul+
Escreva "Esta mensagem está em azul+"
FimRotina
26
O formato geral da instrução CorTexto é o seguinte:
CorTexto cor
Onde:
cor é uma das 16 cores permitidas, de acordo com a tabela abaixo:
BRANCO BRANCO+
AMARELO AZUL
AZUL+ VERMELHO
VERMELHO+ VERDE
VERDE+ CELESTE
CELESTE+ MAGENTA
MAGENTA+ MARROM
CINZA PRETO
5.4. Instrução CORFUNDO

A cor do fundo da tela de execução do Inter-S é branca por padrão, mas, da mesma forma
que podemos alterar a cor do texto, podemos também alterar a cor da janela. A instrução
CorFundo é responsável por isso.
Esta instrução é normalmente usada no início do programa. Veja o exemplo abaixo e a
respectiva tela de execução:
// Programa: FUNDO
// Data : 99/99/9999
Rotina
CorFundo amarelo
Escreva "O fundo da tela é amarelo"
FimRotina
27
O formato geral da instrução CorFundo é o seguinte:
CorFundo cor
Onde:
cor é uma das 16 cores permitidas, de acordo com a tabela abaixo:
BRANCO BRANCO+
AMARELO AZUL
AZUL+ VERMELHO
VERMELHO+ VERDE
VERDE+ CELESTE
CELESTE+ MAGENTA
MAGENTA+ MARROM
CINZA PRETO
6. Estruturas condicionais
Todos os programas vistos até agora continham instruções que eram executadas em uma
sequência linear, ou seja, as instruções eram executadas uma a uma, de cima para baixo,
incondicionalmente.
Uma estrutura condicional, ou estrutura de decisão, permite que o programa faça a escolha
do que executar, de acordo com uma condição. O Inter-S possui duas instruções que nos
permitem trabalhar com dois tipos de estruturas condicionais: Se...Senão e Caso...Fimcaso.
6.1. Estrutura de decisão Se...Senão

A estrutura Se...Senão é a mais simples estrutura de controle do Inter-S. Esta estrutura
permite executar um entre vários blocos de instruções. O controle de qual bloco será
executado é dado por uma condição (expressão lógica ou numérica). Esta estrutura pode se
apresentar de dois modos diferentes: condicional simples ou condicional composta.
Condicional simples - Decisão de um bloco (Se...)
A estrutura de decisão de um bloco permite que se execute (ou não) um bloco de instruções
conforme o valor de uma condição seja verdadeiro ou falso. O fluxograma desta estrutura é
mostrado na figura 4.1.
Condição
Sim
Não Bloco de
instruções
Figura 4.1: Fluxograma da estrutura de decisão Se...
28
O programa abaixo ilustra a utilização de uma estrutura condicional simples. O programa

receberá pelo teclado um número, se o número for positivo será calculada e mostrada sua
raiz quadrada, caso contrário, ou seja, se o número for negativo, nada será feito:
// Programa: RAIZ
// Data : 99/99/9999
Rotina
Declare num, resultado Numérico
Receba "Digite um número: ", num
Se num >= 0 então
resultado = raiz(num)
Escreva "Raiz quadrada: ", resultado
FimSe
FimRotina
A estrutura de decisão demonstrada tem como primeiro comando a avaliação de uma

expressão: Se num >= 0, em seguida encontram-se os comandos que serão executados
caso a avaliação seja verdadeira. Este bloco de comandos é finalizado com a instrução
FimSe. Observe o uso da edentação, ou seja, o bloco de comandos encontra-se alinhado a
partir de uma margem mais à direita. Este procedimento é necessário para garantir um melhor
entendimento do algoritmo.
A instrução Se processa a avaliação da expressão que se encontra à direita, que no nosso

caso é num >= 0 (na realidade é feita uma pergunta: num é maior ou igual a zero?). Se a
resposta for verdadeira, o bloco de instruções que se encontra entre as palavras então e
FimSe será executado; caso a resposta seja falsa, ou seja, se num não for maior ou igual a
zero, o bloco não será executado.
Para um melhor entendimento, vamos representar esta situação graficamente por meio de um
fluxograma. Veja abaixo:
As setas do fluxograma indicam a

sequência ou o fluxo que o
num>=0?
Sim computador seguirá. O losango
representa a instrução Se, ou seja, é
a condição ou pergunta. Se a
Não Resultado=Raiz(num) condição for verdadeira, o fluxo será
Escreva "Raiz quadrada:", resultado desviado para o lado representado
por um "Sim", caso contrário, o fluxo
seguirá pelo lado representado por
um "Não"
29
O formato geral da instrução Se é mostrado abaixo:
Se condição então
instruções
FimSe
Onde:
Se ....................... é a instrução que inicia a estrutura
condição .......... é a pergunta que será feita
então................. indica o que deve ser feito caso a resposta for "sim"
instruções .... é o bloco de instruções que será executado caso a resposta for "sim"
FimSe ................ é o finalizador da estrutura
Condicional composta: Decisão de dois blocos (Se...Senão)
Também é possível escrever uma estrutura que execute um entre dois blocos de instruções.
A figura 4.2 mostra o fluxograma correspondente a esta estrutura de decisão.
Sim Condição Não
Bloco 1 de Bloco 2 de
instruções instruções
Figura 4.2: Fluxograma da estrutura de decisão Se...senão
O programa apresentado a seguir, ilustra a utilização de uma estrutura condicional composta.

O programa receberá pelo teclado um número, se o número for par será exibida a mensagem
"Número par", caso contrário será exibida a mensagem "Número ímpar":
// Programa: PARIMPAR
// Data : 99/99/9999
Rotina
Declare num, resto Numérico
resto = num % 2
Se resto = 0 então
Escreva "Número par"
Senão
Escreva "Número ímpar"
FimSe
FimRotina
30
Inicialmente devemos esclarecer o processo utilizado para descobrir se o número é par ou

ímpar. Você já sabe que os números pares são múltiplos de 2, portanto, se dividirmos um
número par por 2 teremos 0 (zero) como resto da divisão. Se o número for ímpar, teremos 1
(um) como resto da divisão por 2. Observe os exemplos abaixo:
16 2
16 dividido por 2 é igual a 8, com resto 0 (zero) - indica número par.
0 8
15 2
15 dividido por 2 é igual a 7, com resto 1 (um) - indica número ímpar.
1 7
Já vimos que o Inter-S possui um operador matemático que nos retorna o resto de uma
divisão: é o operador módulo, representado pelo caractere % ou pela expressão MOD. As
divisões acima podem ser representadas em Inter-S da seguinte forma:
resto = 16 % 2 a variável resto receberá conteúdo 0 (zero), pois não existe resto
nesta divisão.
resto = 15 % 2 a variável resto receberá conteúdo 1 (um), pois o resto da divisão é 1.
Observe no programa acima que a estrutura de decisão contém dois blocos de comandos. O
primeiro encontra-se logo após a instrução Se, e o segundo após a instrução Senão:
Se resto = 0 então
Escreva "Número par"
Senão
Escreva "Número ímpar"
FimSe
Neste trecho do programa, primeiramente é feita a pergunta: resto = 0 ?. Se a resposta for

verdadeira será executado o primeiro bloco: Escreva "Número par" , caso contrário, ou
seja, se o resto não for igual a zero, será executado o bloco definido logo após a instrução
Senão: Escreva "Número ímpar". Veja que o final da estrutura de decisão é a
instrução FimSe.
O fluxograma abaixo mostra graficamente esse processo:
Sim Resto=0? Não
Escreva "Número par" Escreva "Número ímpar"
31
Para concluirmos este capítulo, estudaremos os operadores relacionais e lógicos, os quais

nos permitem a construção das expressões condicionais requeridas pela instrução Se. Nos
exemplos deste capítulo utilizamos os operadores relacionais de igualdade (=) e maior ou
igual (>=). Vamos conhecer os demais:
Operadores relacionais
Nas expressões que são avaliadas pelo comando Se utilizamos operadores de relação, os
quais nos permitem verificar se um determinado valor é igual ou não a um outro, se é maior
ou menor, etc.
Operadores relacionais verificam a relação de magnitude e igualdade entre dois valores. São
seis os operadores relacionais:
Operador Significado
> maior que
< menor que
>= maior ou igual a (não menor que)
<= menor ou igual a (não maior que)
= igual a
# diferente de
Operadores lógicos
Até aqui ainda não tivemos a oportunidade de utilizar os operadores lógicos. São operadores
que utilizam a lógica booleana para a construção de expressões condicionais. Por exemplo:
se você quiser que uma determinada rotina seja executada somente quando os valores de
duas variáveis (x e y) sejam iguais a zero, você deve construir a seguinte expressão:
Se x = 0 e y = 0 então ...
Por outro lado, se você quiser que uma determinada rotina seja executada quando o valor de
uma das duas variáveis seja igual a zero, ou seja, se x for igual a zero ou y for igual a zero,
você deve construir a seguinte expressão:
Se x = 0 ou y = 0 então ..
São dois os operadores lógicos do Inter-S E e OU. Estes operadores têm a mesma
significação dos operadores lógicos Booleanos AND (e) e OR (ou).
32
6.2. Estrutura de decisão Caso...FimCaso

A estrutura Caso...FimCaso é uma estrutura de decisão que desvia o fluxo da execução do
programa para um determinado ponto de acordo com o resultado de uma expressão. A
expressão é avaliada e, conforme seu resultado, o programa executará a instrução
correspondente a esse resultado. A figura 4.3 mostra o fluxograma lógico desta estrutura.
Expressão
Instrução 1
Resultado 1
Instrução 2
Resultado 2
Resultado 3 Instrução 3
... ...
Resultado N Instrução N
Instrução
padrão
Figura 4.3: Fluxograma da estrutura Caso...FimCaso.
O valor da expressão é avaliado e o fluxo lógico será desviado para a instrução

correspondente ao resultado obtido, sendo que após a execução da instrução, o fluxo será
desviado para fora da estrutura. No caso de o resultado da expressão ser diferente de todos
os resultados previstos, será executada a instrução padrão.
O programa MESES, demonstrado a seguir, ilustra o uso da instrução Caso...FimCaso, onde

o usuário deverá digitar o número de um mês. A estrutura de decisão avaliará o valor da
variável que receberá o número do mês e de acordo com o resultado deverá escrever na tela
o nome desse mês. Por exemplo: se o usuário digitar o número 1, o programa deverá
escrever "Janeiro"; para o número 2, deverá escrever "Fevereiro", e assim por diante. Caso o
usuário digitar um número que não corresponda a nenhum mês, o programa deverá escrever
a mensagem "Mês inválido".
33
// Programa: MESES
// Data : 99/99/9999
Rotina
Declare mes numérico
Receba "Digite o número do mês: ", mes
Caso mes
Seja = 1 Faça Escreva "Janeiro"
Seja = 2 Faça Escreva "Fevereiro"
Seja = 3 Faça Escreva "Março"
Seja = 4 Faça Escreva "Abril"
Seja = 5 Faça Escreva "Maio"
Seja = 6 Faça Escreva "Junho"
Seja = 7 Faça Escreva "Julho"
Seja = 8 Faça Escreva "Agosto"
Seja = 9 Faça Escreva "Setembro"
Seja = 10 Faça Escreva "Outubro"
Seja = 11 Faça Escreva "Novembro"
Seja = 12 Faça Escreva "Dezembro"
CasoNão Faça Escreva "Mês inválido"
FimCaso
FimRotina
Neste exemplo, o programa recebe um número que corresponde ao mês. Se a variável mes
receber valor 1, então será executada a instrução que se encontra na linha correspondente ao
seja = 1, que neste caso é Escreva "Janeiro", caso receba o valor 2, a instrução Escreva
"Fevereiro" será executada, e assim por diante. Caso a variável mes receba um valor menor
que 1 ou maior que 12, será executada a instrução que se encontra na linha CasoNão, que
neste caso é Escreva "Mês inválido".
O formato geral da instrução Caso...FimCaso é mostrado abaixo:
Caso expressão
Seja condição faça instrução
...
CasoNão faça instrução
FimSe
Onde:
Caso .................. é a instrução que inicia a estrutura
expressão ....... é a expressão ou a variável que será avaliada
Seja ................... indica cada uma das a condições ou resultados da avaliação
condição ......... é a pergunta que verifica o resultado da expressão
faça.................... é o direcionamento para a instrução se o resultado for igual à
condição
instrução ....... é a instrução que deverá ser executada se a condição for verdadeira
CasoNão ............ indica o que deve ser feito no caso de nenhuma das condições ser
verdadeira
FimCaso ............ é o finalizador da estrutura
34
Vejamos um outro exemplo: o programa apresentado a seguir é uma pequena calculadora,

onde o usuário digitará 2 números (n1 e n2) e um operador matemático (+, -, * ou /). De
acordo com o operador, o programa deverá mostrar a soma dos números (se o operador for o
sinal de mais), a subtração do primeiro pelo segundo número (se o operador for o sinal de
menos), a multiplicação dos números (se o operador for o sinal de vezes) ou a divisão do
primeiro pelo segundo número (se o operador for o sinal de divisão).
// Programa: CALC
// Data : 99/99/9999
Rotina
Declare n1, n2, resultado numéricos
Declare operador caractere
Receba "Digite o primeiro número: ", n1
Receba "Digite o segundo número.: ", n2
Receba "Operação (+, -, *, /)...: ", operador
Caso operador
Seja = "+" Faça resultado=n1+n2
Seja = "-" Faça resultado=n1-n2
Seja = "*" Faça resultado=n1*n2
Seja = "/" Faça resultado=n1/n2
CasoNão Faça Escreva "Operador inválido"
FimCaso
Escreva "Resultado...............: ", resultado
FimRotina
Algumas informações importantes:
Observe que no programa acima (CALC) estamos declarando três variáveis numéricas (n1,
n2 e resultado). A variável n1 será responsável pelo recebimento do primeiro valor; a
variável n2 se responsabilizará pelo recebimento do segundo valor e a variável resultado
armazenará o resultado da operação.
Temos uma quarta variável declarada como operador. Esta variável é do tipo caractere, pois
deverá receber um dos sinais matemáticos (+, -, * ou /), portanto, ela não pode ser numérica.
Como os conteúdos das variáveis do tipo caractere são tratados como texto, todas as
referências a estes conteúdos devem usar aspas, como podemos observar nas linhas das
instruções Seja. Note que a os conteúdos a serem verificados estão entre aspas:
Seja = "+" Faça resultado=n1+n2

Seja = "-" Faça resultado=n1-n2
Seja = "*" Faça resultado=n1*n2
Seja = "/" Faça resultado=n1/n2
35
7. Estruturas de repetição
Estruturas de repetição permitem que um bloco de instruções seja executado, repetidamente,
uma quantidade controlada de vezes. O Inter-S possui três tipos de estruturas de repetição:
Repita...AtéQue, Enquanto...FimEnquanto e Para...FimPara.
7.1. Estrutura Repita...AteQue

Esta é uma estrutura básica de repetição condicional. Permite a execução de um bloco de
instruções repetidamente até que uma determinada condição se torne verdadeira. Seu
formato geral é o seguinte:
Repita
Instruções
AtéQue condição
onde: Instruções correspondem ao bloco de instruções que será executado

condição é uma expressão lógica (pergunta)
Esta estrutura faz com que um bloco de instruções seja executado pelo menos uma vez. Após
a execução do bloco, a condição é avaliada. Se a condição for verdadeira, o bloco será
executado outra vez, caso contrário a repetição é terminada. O fluxograma desta estrutura é
mostrado na figura 5.1:
bloco
condição? V
Figura 5.1: Fluxograma da estrutura Repita..AtéQue
O programa QUADRA1, demonstrado a seguir, utiliza uma estrutura Repita...AtéQue para

receber um número pelo teclado e mostrar o quadrado do mesmo. A estrutura será encerrada
quando o número digitado for menor ou igual a zero, ou seja, o bloco de instruções será
executado enquanto o número informado pelo teclado for maior que zero:
36
// Programa: QUADRA1
// Data : 99/99/9999
Rotina
Declare num Numérico
Repita
Escreva "Quadrado: "
Escreva num^2
AtéQue num <= 0
FimRotina
Observe que as instruções existentes entre as linhas Repita e AtéQue serão executadas
enquanto o valor da variável num for maior que zero.
Note que o final da estrutura é representado pela expressão AtéQue, ou seja, a estrutura será
repetida até que algo seja verdadeiro. Neste caso, quando o valor da variável num for menor
ou igual a zero (num <= 0), a estrutura será encerrada.
7.2. Estrutura Enquanto...FimEnquanto

A estrutura de repetição condicional Enquanto...FimEnquanto é semelhante à estrutura
Repita...AtéQue. Seu formato geral é o seguinte:
Enquanto condição faça

Instruções
FimEnquanto
onde: condição é uma expressão lógica (pergunta)

Instruções correspondem ao bloco de instruções que será executado
Esta estrutura faz com que a condição seja avaliada em primeiro lugar. Se a condição for
verdadeira, o bloco de instruções será executado uma vez e a condição será avaliada
novamente. No caso de a condição ser falsa, a repetição será terminada sem a execução do
bloco de instruções. Observe que nesta estrutura, ao contrário da estrutura Repita...AtéQue,
o bloco de instruções pode não ser executado nenhuma vez, basta que a condição seja
inicialmente falsa. O fluxograma desta estrutura é mostrado na figura 5.2:
V
Condição Bloco
Figura 5.2: Fluxograma da estrutura Enquanto.
37
O programa QUADRA2, demonstrado abaixo, ilustra a utilização de uma estrutura

Enquanto...FimEnquanto. O programa faz o mesmo que o programa anterior (QUADRA1),
mudando apenas a estrutura de repetição:
// Programa: QUADRA2
// Data : 99/99/9999
Rotina
Num = 1
Enquanto num > 0 Faça
Escreva "Quadrado: "
Escreva num^2
FimEnquanto
FimRotina
Observe que o programa acima tem o mesmo objetivo do programa QUADRA1: recebe um
número pelo teclado e mostra o quadrado do mesmo enquanto o número for maior que zero.
Note também que a variável num foi iniciada com o valor 1 (num = 1), isto foi necessário
para que a estrutura pudesse ser iniciada, pois se o valor de num, na primeira vez, fosse
menor ou igual a zero, a estrutura não seria executada e o programa terminaria.
7.3. Estrutura Para...FimPara

A estrutura Para...FimPara é muito semelhante às estruturas de repetição vistas
anteriormente, entretanto, costuma ser utilizada quando se quer um número determinado de
ciclos (repetições). A contagem dos ciclos é feita por uma variável chamada contador. A
estrutura Para...FimPara é, às vezes, chamada de estrutura de repetição com contador.
Seu formato geral é o seguinte:
Para contador = valor_inicial até valor_final faça

Instruções
FimPara
onde: contador é a variável que fará a contagem das repetições.

valor_inicial é o valor com o qual o contador será iniciado
valor_final é o valor limite do contador (que determinará o fim da estrutura)
Instruções é um conjunto de instruções a ser executado.
Esta estrutura executa um número determinado de repetições usando um contador de

repetições. O contador é iniciado com um valor (valor_inicial) antes da primeira repetição. Por
exemplo: i=0; ou cont=20, então o bloco será executado. Depois de cada execução, o
contador é incrementado em um (será somado 1 ao valor do contador). Em seguida o valor do
contador será verificado: se for menor ou igual ao valor limite (valor_final) a estrutura terá
continuidade, caso contrário, ou seja, se o valor do contador for superior ao valor limite, a
estrutura será encerrada.
38
O programa CONTA, demonstrado abaixo, ilustra a utilização da estrutura Para...FimPara. O

contador cont é iniciado com o valor 1. O bloco de instruções será repetido até que o valor
do contador seja igual a dez (até 10). O bloco de instruções contém apenas uma instrução
para escrever na tela o valor do contador. Este programa, portanto, mostra na tela os
números de 1 a 10:
// Programa: CONTA
// Data : 99/99/9999
Rotina
Declare cont Numérico
Para cont=1 Até 10 Faça
Escreva cont
FimPara
FimRotina
É interessante notar que a mesma estrutura lógica pode ser implementada usando as
estruturas Repita...AtéQue ou Enquanto...FimEnquanto:
Exemplo: Os programas abaixo são plenamente equivalentes, ou seja, realizam a mesma

tarefa (mostram na tela os números de 1 a 10), apesar de usarem estruturas de repetição
diferentes:
Repita…AtéQue Enquanto...FimEnquanto
Rotina Rotina
Declare cont Numérico Declare cont Numérico
cont=1 cont=1
Repita Enquanto cont<=10 faça
Escreva cont Escreva cont
cont=cont+1 cont=cont+1
AtéQue cont>10 FimEnquanto
FimRotina FimRotina
Incremento da variável contadora – Instrução Passo
Vimos que a variável contadora da estrutura Para...Fimpara é incrementada de um em um ao

final de cada repetição, ou seja, quando o bloco de instruções é finalizado, o valor da variável
contadora é aumentado em um antes de começar uma nova repetição (o computador
automaticamente soma mais um ao valor da variável). Este processo se repete até que a
variável contadora atinja o limite definido.
Porém, o valor do incremento (cujo padrão é um) pode ser alterado, por exemplo, podemos
criar uma estrutura onde a variável contadora seja incrementada de 2 em 2, de 3 em 3, etc.
Para alterar o valor do incremento usamos a instrução Passo, por meio da qual informamos o
novo valor. Veja alguns exemplos a seguir:
39
Programa Comentários
Rotina Este programa exibe na tela os
Declare cont Numérico números pares de 2 a 10.
Passo 2 Veja que o incremento é 2 (Passo 2)
Para cont = 2 Até 10 Faça
Escreva cont
FimPara
FimRotina
Rotina Este programa exibe na tela os
Declare cont,P,A,B Numéricos números múltiplos de três,
P=3 começando por 3 até 30.
A=3
B=30 Temos aqui uma outra novidade: veja
Passo P que todos os parâmetros usados no
Para cont = A Até B Faça programa são variáveis:
Escreva cont P é o valor do incremento (3)
FimPara A é o valor inicial do contador (3)
FimRotina B é o valor limite (30)
Rotina Este programa recebe um número
Declare cont,n Numéricos digitado pelo usuário e mostra na tela
Receba "Digite o número: ", n a tabuada desse número.
Para cont = 1 Até 10 Faça Veja que a estrutura de repetição vai
Escreva n,"x",cont,"=",n*cont de 1 a 10, com incremento 1, pois
FimPara não existe a instrução Passo.
FimRotina
8. Desvios incondicionais
Desvios incondicionais são instruções que desviam a sequência de execução do programa
para um outro ponto especificado, sem a necessidade de uma condição. Temos no Inter-S
basicamente dois tipos de desvios incondicionais: VaPara e SubRotina.
8.1. Desvio VaPara

Esta instrução é chamada de desvio de fluxo. A instrução desvia a execução para um rótulo
ou um ponto especificado dentro do programa. São raros os casos onde a instrução VaPara é
necessária, pois podem ser substituídas com vantagem pelas estruturas de repetição. No
entanto, existem circunstâncias onde ela pode ser útil.
O formato geral da instrução VaPara é o seguinte:
VaPara rótulo
...
[rótulo]
...
onde rótulo é um nome dado pelo programador para indicar um ponto de desvio.
40
O programa MEDIA1, demonstrado abaixo, mostra um laço de repetição onde o programa

recebe uma série de valores. Quando o usuário informar um valor menor ou igual a zero, o
programa encerrará o processo de repetição e mostrará na tela a média aritmética dos
valores informados (sem considerar o valor menor ou igual a zero) e terminará o programa.
Foram usadas duas instruções VaPara:
// Programa: MEDIA1
// Data : 99/99/9999
Rotina
Declare val, soma Numéricos
[Inicio]
Receba "Valor: ", val
Se val <= 0 Então
VaPara Fim
FimSe
num = num + 1
soma = soma + val
VaPara Inicio
[Fim]
Escreva "Média: ", soma / num
FimRotina
Observe a existência de dois rótulos no programa acima: Inicio e Fim (note que os rótulos
devem ser escritos entre colchetes). Para processar um desvio basta utilizar a instrução
VaPara indicando o rótulo do ponto para onde queremos desviar o fluxo.
8.2. Desvio SubRotina

Diferente do que ocorre com um desvio do tipo VaPara, um desvio SubRotina sempre
retorna ao ponto de chamada após a execução das instruções definidas naquele
procedimento.
O programa MEDIA2, demonstrado a seguir, ilustra a utilização de duas funções. A primeira,

preparar_tela, é um procedimento que não requer parâmetros, ou seja, não necessita de
nenhuma informação para que as instruções nele existentes sejam executadas. A segunda,
media, é um procedimento que requer dois parâmetros para que seja executado. Observe o
programa e em seguida faremos os devidos comentários:
41
// Programa: MEDIA2
// Data : 99/99/9999
Rotina
Declare valor1, valor2, y Numérico
Declare media Numérico
Processe Preparar_tela
Processe Media
Escreva "Media: ", y
FimRotina
SubRotina Preparar_tela
Limpa
Escreva "Programa MEDIA2"
FimSubRotina
SubRotina Media
y = (valor1 + valor2) / 2
FimSubRotina
Comentários
No programa apresentado acima utilizamos 2 subrotinas: Preparar_tela e Media. Observe

que as subrotinas devem ser escritas após a rotina principal, ou seja, após a instrução
FimRotina.
Para definir uma subrotina devemos usar a instrução SubRotina e em seguida declarar um
nome para ela. As linhas subseqüentes devem conter as instruções que serão executadas
quando a subrotina for chamada. Para finalizá-la devemos usar a instrução FimSubRotina.
A primeira subrotina (Preparar_tela) contém a instrução Limpa, a qual promove a limpeza de

tela. Em seguida, por meio da instrução Escreva, coloca o texto "Programa MEDIA2" na tela.
A segunda (Media), calcula a média aritmética dos valores das variáveis valor1 e valor2 e a
armazena na variável y.
Veja que na rotina principal existem duas linhas com a instrução Processe. A primeira
(Processe Preparar_tela) faz a chamada da subrotina Preparar_tela. Neste momento,
as instruções da subrotina chamada serão executadas e o programa continua com a próxima
linha da rotina principal.
A outra instrução Processe (Processe Media) faz a chamada da subrotina Media. Neste
instante, o computador executará a instrução da subrotina e retornará à rotina principal.
42
9. Gráficos
Vimos que a tela de execução do Inter-S é uma janela que permite apenas textos, ou seja,
não é possível produzir gráficos (com exceção das molduras). Porém, existe um conjunto de
instruções que possibilita a habilitação de uma janela gráfica nos padrões cartesianos, na
qual podemos desenhar linhas, pontos, círculos e elipses.
Como exemplo, a figura abaixo mostra a tela de execução de um programa que usa a janela
gráfica para a montagem da parábola de uma função do segundo grau. Veja que a janela
gráfica aparece à direita da tela e representa o plano cartesiano.
Agora vamos conhecer o conjunto de instruções gráficas para que você possa aplicar em
seus programas. Temos abaixo uma pequena descrição das funções que estudaremos neste
capítulo:
INSTRUÇÃO DESCRIÇÃO
Escala N ............................ Determina a escala da área gráfica, onde N é o valor máximo.

Gráfico............................... Habilita a área gráfica assumindo a escala definida pela instrução
Escala.
FechaGrafico ..................... Desabilita (fecha) a área gráfica.
LimpaGrafico ..................... Processa a limpeza da área gráfica.
CorPonto S ........................ Define a cor dos elementos gráficos, onde S é o nome da cor.
TamanhoPonto N............... Define o tamanho do ponto, onde N é o tamanho (de 1 a 4).
Ponto X,Y .......................... Plota um ponto gráfico na coordenada X,Y.
Circulo X,Y,R ..................... Desenha um círculo na área gráfica, onde X,Y é o centro e R é o
raio.
Elipse X,Y,rx,ry .................. Desenha uma elipse, onde X,Y é o centro, rx é o raio x e ry é o
raio y.
Linha X1,Y1/X2,Y2 ............ Traça uma linha entre os pontos X1,Y1 e X2,Y2.
43
9.1. Iniciando a janela gráfica

Para habilitar a janela gráfica, devemos primeiramente definir a escala por meio da instrução
Escala e em seguida aplicar a instrução Gráfico. O programa abaixo exemplifica este
processo:
// Programa: GRAF1
// Data : 99/99/9999
Rotina
Escala 10
Gráfico
Pausa
Fechagráfico
FimRotina
Quando o programa for executado, surgirá uma janela gráfica à direita da tela de execução,
representando o plano cartesiano. Os eixos X e Y, neste exemplo, apresentarão uma
graduação de –10 (dez negativo) a 10 (dez positivo), pois, observe que atribuímos o valor 10
na instrução Escala.
O programa acima demonstra apenas a maneira para habilitarmos a janela gráfica. Note que
após a instrução Gráfico, existe uma instrução Pausa que congela a execução e aguarda o
pressionamento de uma tecla qualquer. Em seguida observamos a instrução FechaGráfico,
que tem a função de desabilitar a janela gráfica. Portanto, o programa não tem funcionalidade
nenhuma, é apenas um exemplo que apresentará a seguinte tela:
Notas: Se você mover o mouse sobre a janela gráfica, poderá observar a coordenada (pontos
x e y) no rodapé da tela (informação entre parêntesis à esquerda).
Para que a numeração (escala) apareça ao longo dos eixos X e Y, você pode habilitar
a caixa de checagem "Rótulos" localizada no rodapé da tela, à direita.
44
A escala de uma janela gráfica, por padrão, é 10 (dez), ou seja, se você não usar a instrução
Escala, o Inter-S assumirá o valor 10. Portanto, o programa abaixo fará a mesma coisa que o
programa anterior, mesmo não usando a instrução Escala:
// Programa: GRAF1
// Data : 99/99/9999
Rotina
Gráfico
Pausa
Fechagráfico
FimRotina
9.2. Desenhando pontos na janela gráfica

Desenhar pontos na janela gráfica é uma tarefa bastante simples: primeiramente devemos
estabelecer a escala e em seguida habilitar a tela gráfica (instruções Escala e Gráfico), como
vimos no tópico anterior. A partir deste momento, podemos aplicar a instrução Ponto,
definindo os valores de X e Y (coordenada). No exemplo abaixo, temos um pequeno
programa que desenha um ponto vermelho na coordenada 5,4 (x=5 e y=4):
// Programa: PONTO1
// Data : 99/99/9999
Rotina
Escala 10
Gráfico
TamanhoPonto 4
CorPonto vermelho+
Ponto 5,4
Pausa
FimRotina
Veja que antes da instrução Ponto estamos determinando o tamanho e a cor do ponto
gráfico:
TamanhoPonto 4
CorPonto vermelho+
A instrução TamanhoPonto determina o tamanho do ponto gráfico. O tamanho pode ser um

valor entre 1 a 4. Neste exemplo estamos usando o tamanho máximo (4).
A instrução CorPonto define a cor do ponto gráfico. Podemos usar qualquer uma das cores
padrões do Inter-S, conforme tabela abaixo:
BRANCO BRANCO+ AMARELO

AZUL AZUL+ VERMELHO
VERMELHO+ VERDE VERDE+
CELESTE CELESTE+ MAGENTA
MAGENTA+ MARROM CINZA
PRETO
45
Após a definição do tamanho e da cor, empregamos a instrução Ponto para finalmente

colocarmos um ponto em uma determinada coordenada. Neste exemplo, o ponto será
colocado na coordenada 5,4 (onde 5 corresponde ao eixo X e 4 ao eixo Y):
Ponto 5,4
Vejamos agora um programa exemplo mais sofisticado, onde o usuário informará as

coordenadas (X e Y) por meio de instruções Receba dentro de uma estrutura de repetição
montada com a instrução VaPara. Desta forma, o programa receberá a coordenada pelo
teclado e colocará um ponto no local correspondente, e assim repetidamente:
// Programa: PONTO2
// Data : 99/99/9999
Rotina
Declare x,y numéricos
Escala 10
Gráfico
TamanhoPonto 4
CorPonto vermelho+
[recebimento]
Limpa
Receba "Valor de x: ", x
Receba "Valor de y: ", y
Ponto x,y
VaPara recebimento
FimRotina
9.3. Desenhando linhas, círculos e elipses na janela gráfica

Além de pontos, podemos desenhar linhas, círculos e elipses com bastante facilidade no
Inter-S. Vamos estudar separadamente cada uma destas instruções.
9.3.1. Linhas
Para desenhar uma linha devemos aplicar a instrução Linha e informar dois parâmetros: o
ponto inicial (início da linha) e o ponto final (fim da linha). O programa abaixo é um pequeno
exemplo que demonstra o uso desta instrução, desenhando uma linha que se inicia na
coordenada -5,-4 e termina na coordenada 8,15:
// Programa: LINHA1
// Data : 99/99/9999
Rotina
Escala 10
Gráfico
TamanhoPonto 2
CorPonto azul+
Linha -5,-4/8,15
Pausa
FimRotina
46
Veja que as coordenadas da linha devem ser representadas por valores que correspondem
às posições dos eixos X e Y e não necessariamente devem estar dentro da escala definida,
ou seja, uma linha pode começar ou terminar em um ponto fora da área de visão, como neste
exemplo. Observe também que as coordenadas devem estar separadas por barra (/):
Linha -5,-4/8,15
Coordenada final (8,15)
Coordenada inicial (-5,-4)
A figura abaixo representa a tela de execução do nosso programa exemplo:
Coordenada Coordenada
inicial (-5,-4) final (8,15) –
fora do campo
de visão
Temos na próxima página um programa exemplo mais complexo, onde o usuário informará
por meio de instruções Receba os valores x1 e y1 da coordenada inicial e os valores x2 e y2
da coordenada final, as quais correspondem às coordenadas da linha a ser desenhada.
Observe que as instruções estão dispostas dentro de uma estrutura de repetição montada
com a instrução VaPara. Desta forma, o programa poderá desenhar tantas linhas quanto o
usuário desejar:
47
// Programa: LINHA2
// Data : 99/99/9999
Rotina
Declare x1,y1,x2,y2 numéricos
Escala 10
Gráfico
TamanhoPonto 3
CorPonto vermelho+
[recebimento]
Limpa
Receba "Valor de x inicial: ", x1
Receba "Valor de y inicial: ", y1
Receba "Valor de x final : ", x2
Receba "Valor de y final : ", y2
Linha x1,y1/x2,y2
VaPara recebimento
FimRotina
9.3.2. Círculos
Para o desenho de círculos na janela gráfica, o Inter-S dispõe da instrução Círculo, a qual
possui o seguinte formato geral:
Círculo x,y,raio
Onde:
x é o valor de x da coordenada central do círculo
y é o valor de y da coordenada central do círculo
raio é o comprimento do raio do círculo
O programa abaixo demonstra o uso da instrução para desenhar um círculo com centro na
coordenada 2,3 e com comprimento do raio de 4 unidades:
// Programa: CIRC1
// Data : 99/99/9999
Rotina
Escala 10
Gráfico
TamanhoPonto 4
CorPonto verde
Círculo 2,3,4
Pausa
FimRotina
48
O programa exemplo CIRC1 gerará a seguinte tela de execução:
O raio do
círculo é 4
(medida entre o
centro e a
borda)
O centro do
círculo é
definido pela
coordenada 2,3
O programa abaixo demonstra o uso da instrução Círculo dentro de uma estrutura de

repetição, onde o usuário deverá informar os valores de x e y da coordenada central e o valor
do raio:
// Programa: CIRC2
// Data : 99/99/9999
Rotina
Declare x,y,r numéricos
Escala 10
Gráfico
TamanhoPonto 2
CorPonto verde
[recebimento]
Limpa
Receba "Valor de x: ", x
Receba "Valor de y: ", y
Receba "Raio : ", r
Círculo x,y,r
VaPara recebimento
FimRotina
49
9.3.3. Elipses
O desenho de elipses é muito semelhante ao desenho de círculos, a diferença está no fato de
que as elipses possuem dois raios: um horizontal e outro vertical. O inter-S disponibiliza a
instrução Elipse, cujo formato geral é o seguinte:
Elipse X,Y,rx,ry
Onde:
X é o valor de x da coordenada central da elipse
Y é o valor de y da coordenada central da elipse
rx é o comprimento do raio ao longo do eixo X (raio horizontal)
ry é o comprimento do raio ao longo do eixo Y (raio vertical)
O programa abaixo demonstra o uso da instrução para desenhar uma elipse com centro na
coordenada 0,0 e com raio horizontal de 2 unidades e raio vertical de 4 unidades:
// Programa: ELIPSE1
// Data : 99/99/9999
Rotina
Escala 10
Gráfico
TamanhoPonto 2
CorPonto vermelho+
Elipse 0,0,2,4
Pausa
FimRotina
A tela de execução do programa ELIPSE1 terá a seguinte aparência:
O raio
vertical é 4
O centro da
elipse é 0,0
O raio
horizontal é 2
50
O programa abaixo demonstra o uso da instrução Elipse dentro de uma estrutura de

repetição, onde o usuário deverá informar os valores de x e y da coordenada central e os
valores dos raios horizontal e vertical:
// Programa: ELIPSE2
// Data : 99/99/9999
Rotina
Declare x,y,rx,ry numéricos
Escala 10
Gráfico
TamanhoPonto 2
CorPonto vermelho+
[recebimento]
Limpa
Receba "Valor de x : ", x
Receba "Valor de y : ", y
Receba "Raio horizontal: ", rx
Receba "Raio vertical : ", ry
Elipse x,y,rx,ry
VaPara recebimento
FimRotina
51
10. Arquivos de Dados

Os programas vistos até agora trabalham com informações que são armazenadas em
variáveis de memória. As variáveis conservam seus conteúdos somente enquanto o programa
está sendo executado, quando o programa é finalizado, todos os dados manipulados por ele
são perdidos.
Porém, existem situações em que necessitamos armazenar as informações de forma
permanente, para que não sejam perdidas quando o programa for encerrado. Vamos imaginar
que você queira construir um programa para armazenar os dados de seus amigos - uma
agenda telefônica de amigos. Para este feito será necessário o armazenamento permanente
das informações, pois você não deseja perdê-las quando o programa for encerrado. Como
fazer isto?
Bem, podemos começar com uma rotina que recebe as informações dos amigos:
// Programa: AGENDA
// Data : 99/99/9999
Rotina
Declare codigo numérico
Declare nome, telefone caracteres
Declare resp caractere
resp="S"
Enquanto resp = "S" Faça
Limpa
Receba "Código do amigo..: ",codigo
Receba "Nome.............: ",nome
Receba "Telefone.........: ",telefone
Receba "Continua (S/N)? ",resp
FimEnquanto
FimRotina
O programa acima (AGENDA) começa com a declaração de 4 variáveis: codigo (numérico),

nome, telefone e resp (caracteres). Em seguida devemos iniciar a variável resp com a letra S,
pois, esta variável será usada para receber a resposta do usuário mediante à pergunta
“Continua (S/N)?”, porém, no primeiro momento devemos iniciá-la com “S” (sim) para que a
estrutura de repetição Enquanto seja iniciada. Os dados codigo, nome e telefone do amigo
são recebidos pelo teclado através das instruções Receba. Em seguida, a mensagem
"Continua (S/N)?" é mostrada na tela através de outra instrução Receba e a variável resp é
solicitada pelo teclado. Se o usuário digitar S ou s a estrutura de repetição Enquanto será
executada novamente, caso contrário, o programa será encerrado.
Se você digitar e executar este programa, perceberá que o seu funcionamento é perfeito: ele
receberá as informações pelo teclado e as armazenará nas variáveis declaradas. Mas existirá
um problema: as variáveis conservarão seus conteúdos até que outro conteúdo seja atribuído
a elas, ou seja, este programa não faz o armazenamento permanente dos dados recebidos,
portanto, não serve para absolutamente nada!
Qual a saída para que os dados digitados sejam armazenados permanentemente?

A resposta é simples: armazenando-os em um arquivo de dados!
52
Um arquivo de dados é um conjunto de informações armazenado em um meio magnético,

óptico ou eletrônico (disquete, disco rígido, fita, CD, PenDrive etc.) onde permanecerá
gravado e disponível para quaisquer futuras utilizações.
Para ilustrar este conceito, vamos imaginar que a nossa agenda de amigos tenha as
seguintes informações:
Agenda de amigos
Código Nome Telefone
1 Antonio Laurentino Miguel 1234-5678
2 Bianco Branco de Assis Moreira 8765-4321
3 Juarez João Columbiano Mattos 9999-7777
4 Pedro Pedreira Rocha 0001-1110
5 Zé Mané 1000-1234
Estas informações, da forma que estão estruturadas, caracterizam um arquivo de dados.

Podemos através disto tirar algumas definições:
- Um arquivo de dados deve possuir um nome. No nosso caso o nome é "Agenda de

amigos", mas em Inter-S o nome deve possuir no máximo 8 (oito) caracteres e um
sufixo com no máximo 3 (três), vamos usar "AMIGOS.DAT" (o sufixo deve aparecer
após um ponto final e deve informar o tipo de arquivo; estamos utilizando a expressão
DAT, que é uma abreviação de data - dado em inglês - mas poderíamos utilizar
qualquer sufixo desejado).
- Um arquivo de dados deve possuir uma estrutura bem definida, observe as linhas e
colunas, que nos dão a idéia de uma matriz ou tabela: cada uma da linhas armazena
os dados de um amigo, e cada coluna indica um dado (código, nome ou telefone).
- Tecnicamente chamamos as linhas de registros e as colunas de campos.
- Todos os registros possuem os mesmos campos e, portanto, o mesmo tamanho.
Com estas definições básicas, podemos concluir que:
• Um arquivo de dados é um conjunto de informações formado por registros e campos.

• Um registro é um conjunto de campos que armazena os dados de um item do arquivo.
• Um campo é um dado individual do registro.
5 Zé Mané 1000-1234
Campo 1 Campo 2 (nome) Campo 3 (telefone)

(código)
Registro
Já temos uma noção do que é um arquivo de dados, vamos ver agora como fazer para que os
dados dos nossos amigos sejam gravados em um arquivo.
10.1. Gravação de registros em um arquivo de dados

Primeiro passo: Declaração
Para utilizar um arquivo de dados em um programa, o primeiro passo é fazer a sua
declaração. Devemos indicar a unidade, o nome da pasta e o nome do arquivo para que o
53
Inter-S possa acessá-lo (ou criá-lo, se ainda não existir). Esta declaração é feita por meio da
instrução Declare Arquivo, cujo formato geral é o seguinte:
Declare Arquivo(nome-do-arquivo) Chave(campo-chave)
Onde:
nome-do-arquivo é o caminho (unidade e pasta) e o nome do arquivo de dados
campo-chave é o nome do campo que servirá de chave para buscas
Importante: antes da abertura dos parêntesis não deve existir espaço.
Em seguida devemos definir a estrutura do registro, ou seja, devemos definir os campos que
o arquivo possuirá. No nosso exemplo do arquivo AMIGOS.DAT (agenda de amigos) temos
os campos: codigo, nome e telefone, portanto, devemos construir uma estrutura que os
defina. Para este feito, utilizamos a instrução Registro com a seguinte sintaxe:
Registro(codigo numérico [04]

nome caractere [30]
telefone caractere [15])
Observe que devemos utilizar a instrução Registro e entre parêntesis indicar os nomes, os
tipos e os tamanhos de cada um dos campos do arquivo (note que os tamanhos devem ser
colocados entre colchetes). Os campos devem ser indicados individualmente, cada um em
uma única linha. Entre a instrução Registro e a abertura de parêntesis não deve existir
espaço.
Segundo passo: Abertura

Antes de qualquer operação de gravação ou leitura de um arquivo de dados, é necessário
que o arquivo esteja aberto. Para este feito, devemos usar a instrução Abra e indicar a
unidade, pasta e o nome do arquivo. Neste nosso exemplo, a linha de instrução deve ser a
seguinte:
Abra c:\amigos.dat
Note que o nosso arquivo AMIGOS.DAT está localizado na pasta raiz da unidade C.
Desta forma, o nosso programa AGENDA deverá possuir as seguintes linhas iniciais:
// Programa: AGENDA
// Data : 99/99/9999
Rotina
Declare Arquivo(c:\amigos.dat) Chave(codigo)
nome caractere [30]
Abra c:\amigos.dat
...
54
Terceiro passo: Gravação dos dados

No primeiro passo realizamos a declaração e a definição da estrutura do arquivo de dados, ou
seja, definimos o local e o nome do arquivo e a estrutura de seu registro. No segundo passo
realizamos a abertura. Agora só falta aprendermos como gravar os dados. Para isto, devemos
receber as informações pelo teclado e transferi-las para o arquivo.
Devemos, portanto, utilizar instruções Receba para que o usuário possa introduzir os dados a
serem gravados e em seguida usar a instrução Grave Item, cujo formato geral é mostrado a
seguir:
Grave Item[campo-chave] nome-do-arquivo
Onde:
campo-chave é o nome do campo definido como chave
nome-do-arquivo é a identificação da unidade, pasta e nome do arquivo de dados
Importante: antes da abertura do colchete ([) não deve existir espaço.
Aplicando as instruções de recebimento e gravação do arquivo, o nosso programa ficará

assim:
// Programa: AGENDA
// Data : 99/99/9999
Rotina
nome caractere [30]
Abra c:\amigos.dat
resp="S"
Limpa
Receba "Código do amigo..: ",codigo
Receba "Nome.............: ",nome
Receba "Telefone.........: ",telefone
Grave Item[codigo] c:\amigos.dat
FimEnquanto
Feche c:\amigos.dat
FimRotina
Note que antes do encerramento do programa estamos empregando a instrução Feche. Esta
instrução deve sempre ser empregada após um processo de manipulação de arquivos.
Digite o programa e execute-o. Grave alguns amigos para testar e, após finalizar a rotina,
abra o gerenciador de arquivos (windows explorer) e veja que o arquivo AMIGOS.DAT está
presente na pasta raiz.
55
10.2. Leitura de registros de um arquivo de dados

Com certeza você notou que o programa AGENDA não tem sentido nenhum se não tivermos
um programa que faça a leitura do arquivo de dados e que nos mostre os registros gravados.
Temos até dúvidas se os registros estão sendo gravados ou não! Bem, esta dúvida até que é
fácil de se sanar, como vimos no tópico anterior. Basta você verificar que na pasta raiz da
unidade C existe agora um arquivo com o nome AMIGOS.DAT, este arquivo armazena os
dados que você digitou.
Vejamos agora duas maneiras para ler este arquivo.
10.2.1. Leitura sequencial

Imagine que você queira ver todos os dados gravados, ou seja, que você queira "listar" todos
os seus amigos na tela, um a um. Este procedimento é chamado de leitura sequencial.
Temos abaixo um programa que ilustra este processo de leitura:
// Programa: LEIA1
// Data : 99/99/9999
Rotina
nome caractere [30]
Abra c:\amigos.dat
Leia proximo registro c:\amigos.dat
Enquanto Nao FDA Faça
Escreva "Código do amigo..: ",codigo
Escreva "Nome.............: ",nome
Escreva "Telefone.........: ",telefone
Escreva "Tecle algo para ver o próximo"
Pausa
Limpa
Leia proximo registro c:\amigos.dat
FimEnquanto
Feche c:\amigos.dat
FimRotina
Comentários sobre o programa:
Após a declaração e abertura do arquivo C:\AMIGOS.DAT, devemos aplicar a instrução Leia

próximo registro para obter a primeira informação (primeiro registro), em seguida abrimos
uma estrutura de repetição Enquanto não FDA que tem por objetivo a execução das
instruções para exibir os dados enquanto não for fim do arquivo (a cláusula FDA significa Fim
Do Arquivo). Note que após a exibição dos dados através das instruções Escreva, existe uma
outra instrução de leitura (Leia próximo registro) que é responsável pela leitura dos registros
subsequentes dentro da estrutura de repetição. Desta forma, todos os registros do arquivo
serão lidos e mostrados na tela, sequencialmente.
56
10.2.2. Leitura direta

Imagine agora que você deseja localizar um determinado amigo através de seu código, ou
seja, você deseja informar o código para que o computador localize o amigo correspondente.
Este processo é chamado de leitura direta, onde por meio do campo chave, o comutador
localiza o registro. Temos abaixo um programa que ilustra este processo de leitura direta:
// Programa: LEIA2
// Data : 99/99/9999
Rotina
nome caractere [30]
Abra c:\amigos.dat
resp="S"
Limpa
Receba "Código do amigo: ", codigo
Leia Item[codigo] c:\amigos.dat
Se FDA Entao
Escreva "Amigo não encontrado"
Senão
FimSe
FimEnquanto
Feche c:\amigos.dat
FimRotina
Dentro de uma estrutura de repetição (Enquanto resp = “S”), que será repetida enquanto o
usuário informar “S” (sim) para continuar, existe um conjunto de instruções que primeiramente
recebe o código do amigo informado pelo usuário. Em seguida, a instrução Leia Item[codigo]
c:\amigos.dat faz a leitura do arquivo na tentativa de localizar o registro cujo campo chave
(código) seja igual ao código informado pelo usuário. Se o registro não for encontrado, ou
seja, se o FDA (Fim Do Arquivo) for verdadeiro, o programa escreverá na tela “Amigo não
encontrado”, caso contrário, os dados do amigo serão exibidos e o programa perguntará se o
usuário deseja continuar a pesquisa.
57
10.3. Exclusão de registros de um arquivo de dados

Para excluirmos, ou seja, apagarmos um registro do arquivo de dados, devemos usar a
instrução Apague informando o campo chave. O formato geral da instrução é o seguinte:
Apague Item[campo-chave] nome-do-arquivo
Onde:
campo-chave é o nome do campo definido como chave
nome-do-arquivo é a identificação da unidade, pasta e nome do arquivo de dados
// Programa: EXCLUI
// Data : 99/99/9999
Rotina
Declare resp, confirma caractere
Registro(codigo numerico [04]
nome caracter [30]
telefone caracter [15])
Abra c:\amigos.dat
resp="S"
Limpa
Receba "Código do amigo: ", codigo
Leia Item[codigo] c:\amigos.dat
Se FDA Entao
Escreva "Amigo não encontrado"
Senão
Receba "Deseja excluir (S/N)? ",confirma
Se confirma = "S" Então
Apague Item[codigo] c:\amigos.dat
FimSe
FimSe
FimEnquanto
Feche c:\amigos.dat
FimRotina
Dentro de uma estrutura de repetição (Enquanto resp = “S”), que será repetida enquanto o
usuário informar “S” (sim) para continuar com o processo de exclusão, existe um conjunto de
instruções que primeiramente recebe o código do amigo a ser excluído. Em seguida, a
instrução Leia Item[codigo] c:\amigos.dat faz a leitura do arquivo na tentativa de localizar o
registro cujo campo chave (código) seja igual ao código informado pelo usuário. Se o registro
não for encontrado, ou seja, se o FDA (Fim Do Arquivo) for verdadeiro, o programa escreverá
na tela “Amigo não encontrado”, caso contrário, os dados do amigo serão exibidos e o
programa pedirá uma confirmação para excluí-lo. Se o usuário digitar “S” (sim), será
58
executada a instrução Apague Item[codigo] c:\amigos.dat, a qual deletará

permanentemente o registro.
10.4. Solucionando problemas

Durante o desenvolvimento de um programa para tratamento de um arquivo de dados, pode
acontecer que você precise alterar a estrutura do arquivo, como por exemplo, imagine que
você precisa incluir um novo campo na estrutura do registro. Isto é possível, porém, se o seu
arquivo já possuir informações gravadas, esta alteração gerará um erro quando o programa
for executado.
Para corrigir este problema, você precisa apagar o arquivo de dados para que a nova versão
do programa possa recriá-lo considerando a nova estrutura. Para apagar o arquivo, use o
gerenciador de arquivos (windows explorer).
Este procedimento é recomendável para corrigir quaisquer erros não identificados
decorrentes da abertura, gravação, leitura ou exclusão de registros.
59

Introdução À Programação de Computadores Com Inter-S: Roberto Vichinsky 2009

Enviado por

Dados do documento

Título original

Direitos autorais

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Introdução À Programação de Computadores Com Inter-S: Roberto Vichinsky 2009

Título original:

Enviado por

Direitos autorais:

Introdução à

1.1. Uma breve história ...................................................................................................... 3

2. Usando o Inter-S para a construção de algoritmos....................................................... 11

2.1. Apresentação do Inter-S ........................................................................................... 11

3. Instruções de Entrada e Saída ........................................................................................ 17

4. Operadores matemáticos e funções matemáticas ........................................................ 20

4.1. Operadores matemáticos .......................................................................................... 20

5. Tela de execução do Inter-S............................................................................................ 23

5.1. Instrução POSICIONE............................................................................................... 23

6. Estruturas condicionais .................................................................................................. 28

6.1. Estrutura de decisão Se...Senão............................................................................... 28

7. Estruturas de repetição ................................................................................................... 36

7.1. Estrutura Repita...AteQue ......................................................................................... 36

8. Desvios incondicionais ................................................................................................... 40

8.1. Desvio VaPara .......................................................................................................... 40

9.1. Iniciando a janela gráfica........................................................................................... 44

10. Arquivos de Dados ........................................................................................................ 52

10.1. Gravação de registros em um arquivo de dados ..................................................... 53

1.1. Uma breve história

• FORTRAN (FORmula TRANslation system) – Desenvolvida para finalidades

Em resumo, as linguagens de programação, também chamadas de "linguagens simbólicas",

1.2. O processo de criação de um programa

1.3. Métodos para a criação de programas

Ingredientes Instruções para o preparo Resultado (bolo)

Uma receita culinária (exemplo de algoritmo)

Um algoritmo para a resolução de um problema computacional é muito semelhante ao

Dados de entrada Procedimentos Dado de saída

O problema da média final

• Observe que algumas palavras estão em negrito. Chamadas de palavras chaves ou

• A palavra Receba instrui o recebimento de um valor, o qual será armazenado na

• A expressão media = (nota1+nota2+nota3+nota4)/4 representa um cálculo, onde

1.5. Elementos fundamentais de uma linguagem

Neste exemplo, percebemos a presença dos seguintes itens fundamentais: variáveis,

São áreas de trabalho que devemos reservar na memória do computador para o

- Um nome de variável deve começar com uma letra;

nota1 para armazenar a nota do 1º bimestre

será constante. Podem receber ou não um identificador. Observe no algoritmo a presença da

media = (nota1+nota2+nota3+nota4) / divisor

Os operadores relacionais permitem a comparação de 2 valores (constantes ou variáveis) de

2. Usando o Inter-S para a construção de algoritmos

2.1. Apresentação do Inter-S

2.2. Download e Instalação

2.3. Roteiro para a criação de um programa Inter-S

1º Passo – Edição do algoritmo

Abra o Inter-S e digite o programa (algoritmo do cálculo da média):

Clique aqui para

2º Passo – Gravação do algoritmo

Menu "Arquivo/Salvar" Comando "Salvar"

Digite aqui o nome do

3º Passo – Execução do algoritmo

A expressão "executar" ou "rodar" é um termo usado para referenciar o processo através do

Clique aqui para

Após a digitação das

Após a execução, aparecerá dentro de um retângulo amarelo a mensagem "Programa

Para melhorar a aparência do programa e torná-lo mais amigável, altere as instruções

Nas instruções Receba,

3. Instruções de Entrada e Saída

As linhas seguintes expressam o algoritmo propriamente dito. Entre as palavras Rotina e

Declare valor1, valor2, resultado Numérico

Resultado = valor1 + valor2

Implementando novos recursos no programa ENT_SAI

Veja abaixo as explicações dos novos recursos:

Escreva "Programa ENT_SAI"

Receba "Digite o 1º valor:", valor1

Receba "Digite o 2º valor:", valor2