




                                CAPTULO 2                  
            
                         ENTRADA E SADA DE DADOS        
            
                 Os comandos  de entrada  ou sada  fazem a  comunicao
            entre o  programa que  est sendo executado e os perifricos
            de entrada  (teclado, disco)  ou os  de sada (vdeo, disco,
            impressora).
                 A entrada  ou sada de dados para um disco ser tratada
            em captulo posterior.
            
            2.1. COMANDOS DE ENTRADA         
            
                 Um comando  de entrada,  tambm chamado  de comando  de
            leitura, transfere dados do dispositivo de entrada (teclado)
            para uma  ou mais  variveis na memria, funcionando como um
            comando  de  atribuio.  Os  dados  que  entram  devem  ser
            compatveis com os tipos das variveis.
                 Dois dos  comandos de  entradas do  Pascal so  READ  e
            READLN, cujas sintaxes so:
            
            READ(Var1, Var2, ...);   ---> Transfere   dados   para   as
                                          variveis   Var1,   Var2,  ...
            
            READLN(Var1, Var2, ...); ---> Transfere   dados    para   as
                                          variveis  Var1,   Var2,   ...
                                          e,  aps a leitura dos  dados,
                                          posiciona  o  cursor no incio
                                          da prxima linha da tela.
            
                 Cada   comando    de   leitura   deve   ser   encerrado
            pressionando-se a tecla ENTER.
                 Caso haja  mais de um dado a ser lido por um comando de
            leitura, deve-se  separ-los por  pelo menos  um  espao  em
            branco.
            
            Exemplo: Suponhamos  que A e B sejam duas variaveis reais de
            um programa.  Quando a  execuo do  programa chegar  em  um
            comando como
                                Read(A, B);
            ento o computador ficar esperando que sejam digitados dois
            nmeros reais  para que sejam atribudos s variveis A e B.
            Por exemplo, digitando-se uma linha como
                                3.05   -5.17
            e pressionando-se  ENTER ao  final da digitao dos nmeros,
            sero atribudos  os valores 3.05 a A e -5.17 a B.  como se
            o programa contivesse as atribuies
                           A := 3.05; B := -5.17;
            
            2.2. COMANDOS DE SADA           
            
                 Um comando de sada transfere dados para um dispositivo
            de  sada  (vdeo,  impressora).  Os  dados  que  podem  ser

                                        - 15 -





            transferidos so valores ou expresses envolvendo constantes
            ou variveis.
                 Dois comandos  de sada  bastante usados  so  WRITE  e
            WRITELN que tm sintaxes:
            
            WRITE(v1, v2, ...);   ---> Mostra na tela os valores de v1,
                                       v2, ...
            
            WRITELN(v1, v2, ...); ---> Mostra na tela os valores de v1,
                                       v2, ...  e posiciona o cursor no
                                       incio da prxima linha na tela.
            
                 v1, v2,  ...  acima  podem  ser  expresses  envolvendo
            variveis ou  constantes  do  tipo  inteiro,  real,  string,
            booleano ou char.
            
            Exemplo: Suponhamos  que X  seja uma  variavel inteira de um
            programa, com  valor 15  no momento  em que  for executado o
            comando
                      WRITELN('O valor encontrado foi ', X);
                 Neste caso, o computador mostrar na tela algo como
            
                      O valor encontrado foi 15
            
            e posicionar o cursor no incio da linha seguinte a essa na
            tela. Observe que a mensagem "O valor encontrado foi "  uma
            constante do tipo string. Portanto, neste exemplo, o comando
            de sada  mostra os  valores  de  uma  constante  e  de  uma
            varivel.
            
            Exemplo: Suponhamos  que X,  Y, Z,  A, B e C sejam variaveis
            com valores  respectivamente iguais a ' Antonio ', ' Jose ',
            ' Maria ', 60, 75 e 90. Ento, o comando
            
                           WRITELN(x, a, y, b, z, c);
            
            mostrar na tela algo como
            
             Antonio 60 Jose 75 Maria 90
            
            A seqncia de comandos
            
                      WRITELN(x); WRITELN(a); WRITELN(y);
                      WRITELN(b); WRITELN(z); WRITELN(c);
            
            mostrar algo como
            
             Antonio
            60
             Jose
            75
             Maria
            90
            

                                        - 16 -





            enquanto que
                            WRITELN(x, y, z); WRITELN(a, b, c);
            
            mostrar
            
             Antonio Jose Maria
            607590
            
                 Em cada um desses casos, o cursor ficar posicionado no
            incio de uma nova linha.
            
            Exemplo: Vamos  elaborar   agora   nosso  primeiro  programa
            completo. Queremos  digitar dois nmeros inteiros no teclado
            e desejamos que o computador mostre sua soma no vdeo.
                 Sejam Num1  e Num2  os  nomes  das  variveis  que  vo
            guardar na  memria os  valores  dos  nmeros  digitados  no
            teclado.
                 A atribuio de valores a Num1 e Num2, neste caso, ser
            feita por um comando como
            
                           READ(Num1, Num2);
            ou como
                           READLN(Num1, Num2);
            
                 No entanto,  quando o  computador executar esse tipo de
            comando, em  momento nenhum  ele lhe  indicar se  ele  est
            esperando um,  dois, trs ou mais nmeros. Tampouco indicar
            o tipo  de dado  que est  sendo  esperado,  se    um  dado
            numrico ou  no. Devido  a isso,  recomendado que antes de
            qualquer comando  READ ou  READLN, o  programa contenha  uma
            linha anterior  com um  WRITE ou WRITELN para mostrar alguma
            mensagem que oriente o usurio.
                 Neste caso, colocaremos um comando WRITE para mostrar a
            mensagem "Forneca dois numeros inteiros : "
            
                      WRITE('Forneca dois numeros inteiros : ');
            
            Uma vez  introduzidos os  valores de Num1 e Num2, para som-
            los e  mostrar o  resultado da soma na tela, basta colocar a
            expresso Num1 + Num2 em um comando de sada:
            
                      WRITELN('Soma = ', Num1 + Num2);
            
            Observe que neste WRITELN temos uma constante do tipo string
            'Soma = ' e uma expresso aritmtica Num1 + Num2.
            
            Nosso programa fica, ento, com o seguinte aspecto:
            
            
                           PROGRAM SomaDeDoisInteiros;
            
                           VAR
                             Num1, Num2: integer;
            

                                        - 17 -





                           BEGIN
                             WRITE('Forneca dois numeros inteiros : ');
                             READLN(Num1, Num2);
                             WRITELN('Soma = ', Num1 + Num2);
                           END.
            
                 Estamos  atribuindo   o  nome  "SomaDeDoisInteiros"  ao
            programa. Observe  que os  comandos do  programa  (WRITE...,
            READLN..., ...)  devem ficar  na seo principal do programa
            delimitados pelas  palavras BEGIN  e END.  .  No  pode  ser
            omitido o  ponto aps  o END.  O bloco  VAR de declarao de
            variveis deve vir antes da seo principal.
                  comum  se  deslocar  para  a  direita  as  linhas  de
            comandos compreendidas entre um BEGIN e um END. Esse tipo de
            deslocamento  chamado endentao.
                 Uma   vez    digitado    este    programa,    pressione
            simultaneamente as  teclas CTRL  e  F9  para  que  ele  seja
            executado.
                 O Pascal  normalmente trabalha  com 3 janelas: a janela
            de edio (onde voce digita os programas), a janela de watch
            (que aparece  na parte  inferior da  tela)  e  uma  terceira
            janela "por  trs" dessas  duas que  a janela do usurio. 
            na janela  do usurio onde  mostrado o que voc espera como
            resultado da  execuo de  um programa. Para ver a janela do
            usurio voc pressiona simultaneamente as teclas ALT e F5.
            No caso  deste programa, voc ver em uma parte da tela algo
            parecido com
            
            Forneca dois numeros inteiros :  11  27
            Soma = 38
            _
            
                 O caracter  de sublinhado  _ acima representa a posio
            do cursor  na tela. Qualquer outra sada de dado posterior 
            execuo do programa seria feita a partir dessa posio.
                 Se a seo principal deste programa fosse
            
                      BEGIN
                        WRITELN('Forneca dois numeros inteiros : ');
                        READLN(Num1, Num2);
                        WRITE('Soma = ', Num1 + Num2);
                      END.
            
            ento teramos uma tela como
            
            Forneca dois numeros inteiros :
            11  27
            Soma = 38_
            
                 Observe a diferena na posio final do cursor.
            
            Observao:            sem parmetros,  ou seja,  s  o  nome  do  comando  seguido
            imediatamente de um ponto e vrgula.

                                        - 18 -





                 Um WRITELN  sem parmetros  causa a  impresso  de  uma
            linha em branco. Por exemplo,
                           WRITELN; WRITELN; WRITELN;
            causa a impresso de trs linhas em branco.
                 Um  READLN   sem  parmetros  faz  o  computador  ficar
            esperando  que   se  pressione  a  tecla  ENTER  para  poder
            continuar. Temos  assim, uma  maneira de causar uma pausa na
            execuo de um programa.
                 Durante a execuo do fragmento de programa a seguir, o
            computador   coloca    uma   mensagem    na   tela    ("Para
            continuar..."), e  pra temporariamente  a execuo  at ser
            pressionado ENTER.
            
                      ...      ...
                      WRITE('Para continuar, pressione [ENTER]');
                      READLN;
                      ...      ...
            
            2.3. FORMATAO            2.3. FORMATAO
            
                 A impresso  dos valores a serem impressos por um WRITE
            ou WRITELN  pode ser  formatada atravs  da especificao da
            largura  do  campo  de  impresso  ou  do  nmero  de  casas
            decimais.
            
            2.3.1. Para  valores do  tipo inteiro,  booleano, string  ou
            char, basta  colocar o  tamanho  do  campo  de  impresso  
            direita do  valor a  ser impresso.  Neste caso,  o valor e o
            tamanho do campo devem estar separados por dois pontos (:).
            
            WRITE(V:n)  ou  WRITELN(V:n) ---> Imprime o valor de V em um
                                              campo de n espaos
            
                 Se  o  valor  de  n  for  maior  do  que  a  quantidade
            necessria para  a impresso  do valor de V, ento a largura
            do campo ser completada com espaos em branco adicionados 
            esquerda.
            
            Exemplo: Consideremos  x1, x2,  s1, s2 variaveis com valores
            definidos pelas atribuies
            
                           x1 :=  8;  s1 := 'A';
                           x2 := 19;  s2 := '*';
            
                 Para cada  comando WRITE  abaixo,  temos  as  seguintes
            sadas mostradas na tela:
            
                  Comando                                Sada
                 ---------------------------------------------------
                  WRITE(x1)                              8
                  WRITE(x1:2)                            ^8
                  WRITE(x1:10)                           ^^^^^^^^^8
                  WRITE(x1, s1, x2, s2)                  8A19*
                  WRITE(x1, ' ', s1, ' ', x2, ' ', s2)   8^19^*

                                        - 19 -





                  WRITE(x1, s1:2, x2:5, s2:3)            8^^^19^^*
                  WRITE(x1:6, x2:2)                      ^^^^^819
                  WRITE(x1, ' ':5, x2)                   8^^^^^19
                 ---------------------------------------------------
            
                 O smbolo  ^ na  tabela acima  assinala os  espaos  em
            branco.
                   Em  um comando  WRITE ou  WRITELN, a  impresso de  n
            espaos em branco pode ser feita acrescentando-se  lista de
            valores a  serem impressos  uma expresso  da forma   ' ':n,
            como no ltimo exemplo da tabela acima.
                 O tamanho  do campo de impresso pode ser uma expresso
            aritmtica.  Por   exemplo,  WRITE(dado:5)    o  mesmo  que
            WRITE(dado:(11 - 9 + 3)).
            
            2.3.2. Para  se formatar a impresso de um valor real, devem
            ser fornecidos  dois inteiros que correspondem ao tamanho do
            campo de  impresso e  quantidade de casas decimais a serem
            impressas.
            
            WRITE(x:M:N) ou WRITELN(x:M:N) ---> Imprime o valor de x em
                                                um campo de largura  M,
                                                com N casas decimais.
            
                 Se  o  valor  de  M  for  maior  do  que  a  quantidade
            necessria para  a impresso  do valor de x, ento a largura
            do campo ser completada com espaos em branco adicionados 
            esquerda. O  ponto decimal  ou o  sinal negativo  ocupam  um
            espao do campo de impresso.
                 O tamanho do campo de impresso e a quantidade de casas
            decimais  podem   ser  fornecidos   em  forma  de  expresso
            aritmtica.
                  Valores reais sem formatao so impressos em forma de
            potncias de 10.
            
            Exemplo: Consideremos  Pi e  X constantes  reais com valores
            respectivamente iguais  a   3.1415926535 e -1991. A tabela a
            seguir mostra  as diversas  sadas geradas  pelo  respectivo
            comando WRITE. Denotamos os espaos em branco por ^ .
            
                           Comando           Sada
                      -------------------------------------
                        WRITE(X:9:3)     -1991.000
                        WRITE(X:15:2)    ^^^^^^^-1991.00
                        WRITE(X:10:2)    ^^-1991.00
                        WRITE(X)         -1.9910000000E+03
                        WRITE(Pi)        3.1415926535E+00
                        WRITE(Pi:4:2)    3.14
                        WRITE(Pi:7:2)    ^^^3.14
                        WRITE(Pi:10:3)   ^^^^^3.141
                        WRITE(Pi:10:6)   ^^3.141592
                        WRITE(Pi:10:8)   3.14159265
                        WRITE(Pi:5:0)    ^^^^3
                      -------------------------------------

                                        - 20 -





            
            Exemplo: Vamos construir agora  um programa que solicita  ao
            usurio a medida de um ngulo em graus (um nmero inteiro) e
            mostra na  tela o  seno, o  cosseno e  a tangente  do ngulo
            fornecido.
                 As  funes   trigonomtricas  pr-definidas  SIN(x)  e
            COS(x) operam  com um ngulo x em radianos. Logo, o programa
            deve ser  esperto o  suficiente para transformar o ngulo em
            graus, fornecido  pelo usurio, para um valor equivalente em
            radianos. Isto   feito  atravs de  uma  multiplicao  por
            Pi/180. O Pascal tem o valor de Pi pr-definido com 19 casas
            decimais.
                 Vamos usar  trs variveis  reais "seno",  "cosseno"  e
            "tangente" para guardar os valores desejados.
                 Vamos exigir  que a  impresso dos  valores seja  em um
            campo com 8 espaos e 4 casas decimais.
            
            
            PROGRAM Sen_Cos_Tg;
            
            { Calculo  do  seno,  cosseno  e  tangente de um angulo }
            
            VAR
              AnguloEmGraus: INTEGER;
              seno, cosseno, tangente, AnguloEmRadianos: REAL;
            
            BEGIN { inicio da secao principal }
            
              WRITE('Forneca a medida de um angulo (em graus) : ');
              READLN(AnguloEmGraus);
              WRITELN; { gera uma linha em branco }
            
              AnguloEmRadianos := AnguloEmGraus*Pi/180;   { transforma
                                                     graus em radianos }
            
              seno := SIN(AnguloEmRadianos);     { Calculo dos valores }
              cosseno := COS(AnguloEmRadianos);  { desejados.  Lembre- }
                                                 { se que o Pascal nao }
              tangente := seno/cosseno;          { tem funcao tangente }
                                                 { pr-definida       }
            
              { Saida dos resultados }
              WRITELN('Seno de ', AnguloEmGraus, ' = ', seno:8:4);
              WRITELN('Cosseno de ', AnguloEmGraus, ' = ', cosseno:8:4);
              WRITELN('Tangente de ',AnguloEmGraus,' = ', tangente:8:4);
            
            END. { fim da secao principal }
            
            
                 Executando-se esse  programa (aps  a digitao correta
            deve-se pressionar  CTRL-F9 e  ALT-F5), vemos  na tela  algo
            parecido com:
            
            

                                        - 21 -





            Forneca a medida de um angulo (em graus) : 50
                                                            <----------+
            Seno de 50 =   0.7660                                      |
            Cosseno de 50 =   0.6428                                   |
            Tangente de 50 =   1.1918                                  |
                                                                       |
                                                                       |
                 Linha em branco gerada pelo WRITELN; -----------------+
            
            Exemplo: Vamos reformular  o  programa anterior  de modo que
            ele passe a gerar a medida em graus aleatoriamente, ao invs
            de esperar que o usurio digite um valor.
                 Queremos tambm  que o  programa fique  sendo executado
            repetidas  vezes.   Entre  cada  execuo,  queremos  que  o
            programa espere  que seja pressionada a tecla ENTER antes de
            continuar. Precisamos ento de um comando que desvie o fluxo
            do programa  do fim  para o  incio, para  que o programa ao
            chegar  ltima linha, volte ao incio e reinicie novamente.
            Esse comando  chamado de GOTO e sua sintaxe :
            
                                GOTO rtulo;
            
            onde o  rtulo dever  ter sido declarado em um bloco LABEL.
            Para demarcar  um determinado  comando do programa, o rtulo
            deve ser escrito  esquerda do comando e entre o comando e o
            rtulo dever ter um sinal de dois pontos:
            
                                rtulo: Comando;
            
                 Para gerar  nmeros inteiros  aleatoriamente, o  Pascal
            dispe de  um  comando  chamado  RANDOMIZE  para  iniciar  o
            gerador de  nmeros aleatrios  e de  uma funo RANDOM cuja
            sintaxe 
            
                 RANDOM(n) ---> Gera aleatoriamente um nmero inteiro
                                de 0  a  n - 1. Um comando RANDOMIZE;
                                precisa  ser  executado  ao  se  usar
                                esta funo  pela primeira vez em  um
                                programa.
            
                 Esses geradores  de nmeros  aleatrios so  teis, por
            exemplo,  para   testar  programas.   Podemos  us-los  para
            "chutar" nmeros  inteiros quando  no quisermos  nos dar ao
            trabalho de digit-los no teclado.
            
            PROGRAM Sen_Cos_Tg_2;
            
            { ======================================================== }
            {     CALCULO DE SENOS, COSSENOS E TANGENTES - VERSAO 2    }
            { ======================================================== }
            
            VAR
              AnguloEmGraus: INTEGER;
              seno, cosseno, tangente, AnguloEmRadianos: REAL;

                                        - 22 -





            
            LABEL
              Inicio; { Rotulo que marcar uma das linhas }
            
            BEGIN
            
              RANDOMIZE; { Ativa o gerador de numeros aleatorios }
            
              Inicio: AnguloEmGraus := RANDOM(360);             { Linha
                                        demarcada pelo rotulo "Inicio".
                                        RANDOM(360) gera aleatoriamente
                                        um inteiro de 0 a 359 }
            
              AnguloEmRadianos := AnguloEmGraus*Pi/180;
            
              { Calculo dos valores desejados }
              seno := SIN(AnguloEmRadianos);
              cosseno := COS(AnguloEmRadianos);
              tangente := seno/cosseno;
            
              { Saida dos resultados }
              WRITELN('Angulo (em graus) = ', AnguloEmGraus);
              WRITELN;
              WRITELN('Seno de ', AnguloEmGraus, ' = ', seno:8:4);
              WRITELN('Cosseno de ', AnguloEmGraus, ' = ', cosseno:8:4);
              WRITELN('Tangente de ',AnguloEmGraus,' = ', tangente:8:4);
            
              WRITELN;
              WRITELN('--------------------------------------');
              WRITELN;
              WRITELN('Para continuar, pressione ENTER.');
              READLN; { pausa }
            
              GOTO Inicio; { Desvio incondicional para a linha que tiver
                             o rotulo "Inicio" }
            END.
            
                 Ao  ser   executado,  este   programa  gerar  na  tela
            mensagens como:
            
            
            Angulo (em graus) = 325
            
            Seno de 325 =  -0.5736
            Cosseno de 325 =   0.8192
            Tangente de 325 =  -0.7002
            
            --------------------------------------
            
            Para continuar, pressione ENTER.
            
                 Para encerrar a execuo de um programa como esses, que
            se    repete     indefinidamente,     deve-se     pressionar
            simultaneamente as teclas CTRL e BREAK.

                                        - 23 -





                 Esta foi  a nica  vez em  que usamos  um  rtulo  e  o
            comando GOTO.  Outros comandos  do Pascal  permitem algo bem
            mais eficiente.
            
            2.3. O COMANDO CLRSCR          
            
                 A partir  da verso  4, o  Pascal passou  a agrupar  os
            comandos em unidades. Todos os comandos que usamos at agora
            (READ, WRITE,  SIN, COS,  ...) fazem parte da unidade padro
            chamada SYSTEM.  A unidade SYSTEM no precisa ser mencionada
            no programa; podemos usar seus comandos  vontade.
                 Sempre que  algum comando  de  uma  outra  unidade  for
            usado, o  nome da  unidade precisa  ter sido declarado em um
            comando USES,  que deve  ficar logo  abaixo do  cabealho do
            programa. A sintaxe do USES 
            
                 USES Nome_da_unidade_1, Nome_da_unidade_2, ...;
            
                 Um comando  que faz  parte  da  unidade  CRT  e  que  
            bastante usado,   o  comando  CLRSCR  (Clear  Screen)  cuja
            finalidade, como o prprio nome sugere,  limpar a tela.
                 Muitos  dos   livros  sobre   Pascal   disponveis   em
            Portugus, referem-se  s verses  anteriores    4.  Nesses
            livros, no  feita referncia  unidade CRT.
            
            Exemplo: Queremos fornecer  tres  numeros reais  a, b e c ao
            computador e  queremos que  ele nos  fornea, com trs casas
            decimais, o  valor da rea do tringulo cujos lados medem a,
            b e  c. Vamos  querer tambm  que  o  computador  se  d  ao
            trabalho de limpar a tela antes de pedir os valores de a, b,
            c.
                 Vamos usar  a frmula  da Geometria  Plana que diz que,
            neste caso, a rea  desejada    igual    raiz quadrada  de
            p(p - a)(p - b)(p - c) onde p  a metade da soma a + b + c.
            
            
            PROGRAM AreaDoTriangulo;
            
            {
               Dados os nmeros reais a, b,   fornecida o valor
               da rea do tringulo cujos lados tm essas medidas.
            }
            
            USES CRT;  { Permite o uso de comandos da unidade CRT, como
                        o CLRSCR. Deve ser colocado nesta posio, logo
                        abaixo do cabealho }
            
            VAR
              a, b,  p, area: REAL;
            
            BEGIN
              CLRSCR; { Limpa a tela }
            
            

                                        - 24 -





              { Leitura dos valores de a, b e c }
              WRITE('Valor de a: '); READLN(a);
              WRITE('Valor de b: '); READLN(b);
              WRITE('Valor de c: '); READLN(c);
            
              { Calculo da area }
              p := (a + b + c)/2;
              area := SQRT(p*(p - a)*(p - b)*(p - c));
            
              { Impressao dos resultados na tela }
              WRITELN;
              WRITELN('A area do triangulo cujos lados medem');
              WRITELN(a:7:3, ',', b:7:3, ' e ',c:7:3,' ' ', area:7:3);
            
            END.
            
                 A impresso  de um apstrofo  obtida colocando-se dois
            apstrofos consecutivos  como  parte  da  constante  string.
            Assim, WRITELN(' e '' ') tem como sada na tela um "", que
            no chega a ser um "e" acentuado, mas ajuda na leitura.
                 No lugar dos trs READLN acima, poderamos ter colocado
            apenas um READLN(a, b, c).
                 Este programinha  no   inteligente o  suficiente para
            rejeitar na  entrada valores  negativos ou valores invlidos
            como a = 3, b = 5, c = 11.
                 Aps sua  execuo com  os valores  a =  5, b = 7 e c =
            8,4, temos as seguintes mensagens na tela:
            
            
            Valor de a: 5
            Valor de b: 7
            Valor de c: 8.4
            
            A area do triangulo cujos lados medem
              5.000,  7.000 e   8.400   17.479
            
            
            2.4. SADA DE DADOS PARA A IMPRESSORA 
            
                 Para o  Pascal, a  impressora   um dispositivo chamado
            LST e  seu uso  s   permitido quando  se declara o nome da
            unidade PRINTER em um comando USES.
                 Para se  fazer referncia  impressora, deve-se colocar
            um LST como primeiro parmetro de um WRITE ou WRITELN. Todos
            os dados de um WRITE ou WRITELN que se inicie com LST, sero
            enviados para a impressora.

            Exemplo:

            WRITE(x, y, z);        ---> Mostra na tela x, y e z
            WRITE(LST, x, y, z);   ---> Imprime x, y e z no papel
            WRITELN(LST);          ---> Imprime linha em branco no papel

            Exemplo:
                                        - 25 -






            PROGRAM TesteDeImpressao;

            {
               Usa a impressora para imprimir os valores de duas
               constantes famosas: PI e E.
            }

            USES PRINTER;

            BEGIN
              WRITELN(LST, 'O valor de PI e'' ', Pi:13:10);
              WRITELN(LST, 'e o valor de E e'' ', Exp(1):13:10);
            END.


            2.5. EXERCCIOS            2.5. EXERCCIOS

            1) Considere as seguintes constantes:

                      x: real = 2.8317;
                      telefone: longint = 2247200;
                      a: string[4] = 'UFPB';

            Descreva o que cada comando WRITE abaixo mostra na tela:

            a) WRITE(x, ' ':3, telefone);
            b) WRITE(x:8:2, telefone:10);
            c) WRITE('O telefone da ', a, ' e'' ', telefone);

            2) Detecte os 3 erros do seguinte programa:

               PROGRAM Errado;

               { Programa que tem mais erros do que acertos }

               VAR
                 x: REAL

               BEGIN
                 CLRSCR;
                 x := 2;
                 WRITELN('Raiz quadrada de 2 = ', SQRT(x):8:3);
               END;

            3)  Elabore   um  programa   que  solicite   do  usurio  as
            coordenadas   de     dois  vetores  do   R3,   v = (a, b, c)
            e w = (x, y, z), e mostre na tela o valor do produto interno
                                 v.w = ax + by + cz
            e o valor do produto vetorial
                      v x w = ( bz - cy,  cx - az,  ay - bx ) .
                 Na impresso  de  v  x  w,  devero  ser  impressos  as
            vrgulas e os parnteses, como na forma usual.

                                        - 26 -
