Soluções

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

solu�_es/3a Leva/Ex_07.pdf
Exercício 07
passo i i i < 2 passo j j j > 10 i * j
1 5 F 1 1 F 5
2 2 F 10
3 3 F 15
4 4 F 20
5 5 F 25
6 6 F 30
7 7 F 35
8 8 F 40
9 9 F 45
10 10 F 50
11 11 V
2 4 F 1 1 F 4
2 2 F 8
3 3 F 12
4 4 F 16
5 5 F 20
6 6 F 24
7 7 F 28
8 8 F 32
9 9 F 36
10 10 F 40
11 11 V
4 * 7 = 28
4 *8 = 32
4 * 9 = 36
4 * 10 = 40
4 * 1 = 4
4 * 2 = 8
4 * 3 = 12
4 * 4 = 16
4 * 5 = 20
4 * 6 = 24
5 * 6 = 30
5 * 7 = 35
5 * 8 = 40
5 * 9 = 45
5 * 10 = 50
Saída
5 * 1 = 5
5 * 2 = 10
5 * 3 = 15
5 * 4 = 20
5 * 5 = 25
passo i i i < 2 passo j j j > 10 i * j Saída
3 3 F 1 1 F 3
2 2 F 6
3 3 F 9
4 4 F 12
5 5 F 15
6 6 F 18
7 7 F 21
8 8 F 24
9 9 F 27
10 10 F 30
11 11 V
4 2 F 1 1 F 2
2 2 F 4
3 3 F 6
4 4 F 8
5 5 F 10
6 6 F 12
7 7 F 14
8 8 F 16
9 9 F 18
10 10 F 20
11 11 V
5 1 V
2 * 9 = 18
2 * 10 = 20
2 * 3 = 6
2 * 4 = 8
2 * 5 = 10
2 * 6 = 12
2 * 7 = 14
2 *8 = 16
3 *8 = 24
3 * 9 = 27
3 * 10 = 30
2 * 1 = 2
2 * 2 = 4
3 * 2 = 6
3 * 3 = 9
3 * 4 = 12
3 * 5 = 15
3 * 6 = 18
3 * 7 = 21
3 * 1 = 3
solu�_es/3a Leva/Ex_05_e_06.pdf
Exercício 05
passo i j m i > j i - j m + 1
1 25 7 0 V 18 1
2 18 7 1 V 11 2
3 11 7 2 V 4 3
4 4 7 3 F
Exercício 06
passo m m*m*m m-1 m = 0
1 5 125 4 F
2 4 64 3 F
3 3 27 2 F
4 2 8 1 F
5 1 1 0 V1 elevado ao cubo = 1
Saída
5 elevado ao cubo = 125
4 elevado ao cubo = 64
3 elevado ao cubo = 27
2 elevado ao cubo = 8
solu�_es/3a Leva/Ex_08.pdf
Exercício 08
passo i i i < 2 passo j j j > i passo k k k < 1 i * j * k
1 5 F 1 2 F 1 2 F 20
2 1 F 10
3 0 V
2 3 F 1 3 F 45
2 2 F 30
3 1 F 15
4 0 V
3 4 F 1 4 F 80
2 3 F 60
3 2 F 40
4 1 F 20
5 0 V
4 5 F 1 5 F 125
2 4 F 100
3 3 F 75
4 2 F 50
5 1 F 25
6 0 V
5 6 V
5 * 5 * 4 = 100
5 * 5 * 3 = 75
5 * 5 * 2 = 50
5 * 5 * 1 = 25
5 * 4 * 4 = 80
5 * 4 * 3 = 60
5 * 4 * 2 = 40
5 * 4 * 1 = 20
5 * 5 * 5 = 125
5 * 2 * 1 = 10
5 * 3 * 3 = 45
5 * 3 * 2 = 30
5 * 3 * 1 = 15
Saída
5 * 2 * 2 = 20
passo i i i < 2 passo j j j > i passo k k k < 1 i * j * k Saída
2 4 F 1 2 F 1 2 F 16
2 1 F 8
3 0 V
2 3 F 1 3 F 36
2 2 F 24
3 1 F 12
4 0 V
3 4 F 1 4 F 64
2 3 F 48
3 2 F 32
4 1 F 16
5 0 V
4 5 V
4 * 4 * 4 = 64
4 * 4 * 3 = 48
4 * 4 * 2 = 32
4 * 4 * 1 = 16
4 * 2 * 2 = 16
4 * 2 * 1 = 8
4 * 3 * 3 = 36
4 * 3 * 2 = 24
4 * 3 * 1 = 12
passo i i i < 2 passo j j j > i passo k k k < 1 i * j * k Saída
3 3 F 1 2 F 1 2 F 12
2 1 F 6
3 0 V
2 3 F 1 3 F 27
2 2 F 18
3 1 F 9
4 0 V
2 4 V
4 2 F 1 2 F 1 2 F 8
2 1 F 4
3 0 V
2 3 V
5 1 V
3 * 3 * 1 = 9
2 * 2 * 2 = 8
2 * 2 * 1 = 4
3 * 2 * 2 = 12
3 * 2 * 1 = 6
3 * 3 * 3 = 27
3 * 3 * 2 = 18
solu�_es/1a Leva/Ex_01.lpr
{
------------------------------------------------------------------
 Este programa lê um número inteiro de quatro dígitos e o escreve
 em ordem invertida. Por exemplo, se o número lido for 2583, o
 programa o escreve como 3852.
------------------------------------------------------------------
}
program Ex_01;
{
------------------------------------------------------------------
 O programa precisa isolar cada dígito do número informado, a fim
 de inverter sua posição relativa aos demais.
 Para isso, o programa utiliza o seguinte algoritmo:
 <> para pegar o dígito do milhar(m), ele executa uma divisão inteira
 do número informado por 1000 e registra seu quociente.
 Suponha que o número informado seja 3864.
 Ao dividir este valor por 1000, o quociente será 3.
 <> para pegar o dígito da centena(c), ele multiplica o valor de m por
 1000 e subtrai o resultado do número informado, a fim de obter o
 valor de suas centenas. Em seguida, ele executa uam divisão inteira
 deste valor por 100 e registra seu quociente.
 Continuando com o exemplo acima, ele multiplica o valor do dígito
 obtido na operação anterior (=3) por 1000 e subtrai o resultado
 (3000) do valor informado (=3864). O resultado (=864) é então
 dividido por 100. O quociente desta divisão inteira (=8) é
 registrado como sendo o dígito da centena.
 <> para pegar o dígito da dezena(d), ele multiplica o valor de c por
 100 e subtrai o resultado da expressão (m * 1000 + c * 100), a fim
 de obter o valor de suas dezenas.Em seguida, ele executa uam divisão
 inteira deste valor por 10 e registra seu quociente.
 Continuando com o exemplo acima, ele multiplica o valor do dígito
 da milhar (=3) por 1000 e do dígito da centena (=8) por 100; soma
 os dois valores e subtrai o resultado (3800) do valor informado (=3864).
 O resultado (=64) é então dividido por 10 e o quociente (=6) é
 registrado como sendo o dígito da dezena.
 <> para pegar o dígito da unidade(u), ele subtrai o resultado da expressão
 (m * 1000 + c * 100 + d * 10) do número informado, a fim de obter o valor
 de suas unidades.
 Continuando com o exemplo acima, ele multiplica o valor do dígito
 da milhar (=3) por 1000; do dígito da centena (=8) por 100 e do dígito
 da dezena (=6) por 10; soma esses três valores e subtrai o resultado
 (3860) do valor informado (=3864). O resultado (=4) é então
 registrado como sendo o dígito da unidade.
 <> Finalmente, o programa calcula a seginte expressão:
 (u * 100 + d * 100 + c * 10 + m) para produzir o resultado final.
------------------------------------------------------------------
}
{$mode objfpc}{$H+}
uses
 {$IFDEF UNIX}{$IFDEF UseCThreads}
 cthreads,
 {$ENDIF}{$ENDIF}
 Classes
 { you can add units after this };
{$R *.res}
var m, // dígito da milhar
 c, // dígito da centena
 d, // dígito da dezena
 u, // dígito da unidade
 n, // número informado pelo usuário
 ni: integer; // número invertido
begin
//
// Solicita a entrada do número e assegura que ele tenha 4 dígitos
//
 repeat
 write('Escreva um numero de 4 digitos: ');
 readln(n)
 until (n>=1000) and (n<=9999);
// pega o dígito da milhar
 m := (n div 1000);
// pega o dígito da centena
 c := (n-m*1000)div 100;
// pega o dígito da dezena
 d := (n - (m * 1000 + c * 100)) div 10;
// pega o dígito da unidade
 u := n-(m*1000 + c * 100 + d * 10);
// inverte o número informado
 ni := u*1000 + d*100 + c * 10 + m;
{--------------------------------------------------------------------
 Alternativamente, vocês poderiam pegar esses dígitos através das
 seguintes expressões;
 m := (n div 1000);
 c := (n mod 1000) div 100;
 d := (n mod 100) div 10;
 u := (n mod 10);
---------------------------------------------------------------------}
// escreve o número invertido
 writeln;
 writeln;
 writeln('O numero ',n,' invertido e igual a: ',ni);
 writeln;
 writeln;
 writeln('Pressione <Enter> para encerrar.');
 readln;
end.
solu�_es/1a Leva/Ex_12.lpi
solu�_es/1a Leva/Ex_20.lpr
{
--------------------------------------------------
 Exemplo de uso do comando FOR e do comando IF
---------------------------------------------------
}
program Ex_20;
{
---------------------------------------------------------
 Este programa lê 20 números reais e, ao final, informa
 quantos deles estão no intervalo [60; 180].
---------------------------------------------------------
}
{$mode objfpc}{$H+}
uses
 {$IFDEF UNIX}{$IFDEF UseCThreads}
 cthreads,
 {$ENDIF}{$ENDIF}
 Classes
 { you can add units after this };
{$R *.res}
var
 i, contador: integer;
 x: real;
begin
 contador := 0;
 for i:=1 to 20 do
 begin
 write ('Entre com um numero: ');
 readln(x);
 if (x >= 60) and (x <= 180) then
 contador := contador + 1;
 end;
 writeln;
 writeln('Dos 20 valores lidos, ', contador, ' pertencem ao intervalo [60,180].');
 writeln;
 writeln('Pressione <enter> para encerrar.');
 readln;
end.
solu�_es/1a Leva/Ex_03.lpr
{
----------------------------------------------------------------------
 Este programa determina o consumo médio de uma frota de 5 veículos,
 com base na distância percorrida por cada um deles e no total de
 combustível gasto durante esse percurso. Para isso, o programa
 lê o código de identificação de cada veículo; a distância por ele
 percorrida; bem como a quantidade de combustível que ele consumiu.
 Na saída, o programa produz uma linha para cada veículo, contendo
 as informações fornecidas pelo usuário e o valor correspondente a
 seu consumo médio de combustível. No final, ele produz uma linha
 resumo informando o consumo médio da frota como um todo.
 Notas:
 (1) O código de identificação de veículo é um número inteiro.
 (2) O código de identificação de veículo não pode ter duplicatas.
 (3) As distâncias deverão ser informadas em Quilômetros (Km).
 (4) O consumo de combustível deverá ser informado em litros (l).
 (5) Os dados de distância e consumo admitem valores fracionários.
------------------------------------------------------------------
}
program Ex_03;
{
------------------------------------------------------------------------
 O programa deve ler um conjunto de três valores para cada um dos
 veículos pertencentes à frota, quais sejam:
 <> código de identificação do veículo (inteiro).
 <> distância percorrida em quilômetros (real).
 <> consumo de combustível em litros (real).
 Como são 5 veículos, o programa utiliza a estrutura de repetição
 FOR, pois o número de repetições é conhecido a priori.
 Este exemplo também ilustra o uso de arrays e uma técnica de produção
 de relatórios em Pascal.
------------------------------------------------------------------------
}
{$mode objfpc}{$H+}
uses
 Crt,
 {$IFDEF UNIX}{$IFDEF UseCThreads}
 cthreads,
 {$ENDIF}{$ENDIF}
 Classes
 { you can add units after this };
{$R *.res}
var
// definição da estrutura de dados para armazenar os ids dos 5 veículos
 id: array[1..5] of integer;
// definição da estrutura de dados para armazenar as distâncias percorridas
// por cada um dos 5 veículos.
 distancia: array[1..5] of real;
// definição da estrutura de dados para armazenar o consumo de combustível
// de cada um dos 5 veículos.
 consumo: array[1..5] of real;
// definição da variável que armazena a distância total percorrida
// pelos 5 veículos.
 distanciaTotal: real;
// definição da variável que armazena o consumo total dos 5 veículos.
 consumoTotal: real;
// definição das variáveis de controle das estruturas de repetição "for"
 i, j: integer;
// definição da variável de sinalização de id duplicata.
 flag: boolean;
begin
{
----------------------------------------------------------------------------
 Inicialmente, o programa zera as variáveis que acumulam a distâcia total
 percorrida pelos 5 veículos e o consumo total de combustíveis.
 Esta operação também poderia ser realizada no momento da definição das
 respectivas variáveis, de acordo com a seguinte declaração:
 distanciaTotal: real = 0;
 consumoTotal: real = 0;
----------------------------------------------------------------------------
}
 distanciaTotal := 0;
 consumoTotal := 0;
{
----------------------------------------------------------------------------
 Em seguida, o programa solicita ao usuário que entre com os 5 conjuntos
 de dados relativos a cada veículo. A cada iteração, o programa armazena
 os valores lidos nas devidas posições dos arrays correspondentes às três
 diferentes categorias de dados.
 ----------------------------------------------------------------------------
}
 writeln ('Informe, para cada veiculo:');
 writeln;
 writeln ('<> seu codigo de identificacao,');
 writeln;
 writeln ('<> a distancia por ele percorrida (em Km) e,');
 writeln;
 writeln ('<> o seu consumo de combustivel (em litros).');
 writeln;
 writeln ('Entre com esse valores em 5 passos distintos,');
 writeln;
 writeln ('uma vez para cada um dos 5 veiculos da frota.');
 writeln;
 for i := 1 to 5 do
 begin
 //------------------------------------------------------------------------
 // A cada passo desta estrutura de repetição, o programa primeiro solicita
 // ao usuário o valor da identificação do veículo.
 //
 // Após a leitura desse código, o programa verifica se o valor digitado
 // já foi informado anteriormente, uma vez que não pode haver ids
 // duplicatas.
 //
 // Vale lembrar que o valor da variável i indica a que carro da frota
 // correspondem os dados que estão sendo fornecidos pelo usuário, i.e.:
 // i=1 -> primeiro carrro
 // i=2 -> segundo carrro
 // e assim por diante.
 //
 // Assim sendo, o programa compara o valor de id[i] com todos os
 // valores que já foram lidos até então, i.e.: desde id[1] até id[i-1].
 //
 // Para isso, é preciso utilizar uma outra estrutura de repetição
 // FOR, cuja variável de controle (j) varia desde 1 até (i-1).
 //
 // Caso o valor de id[i] venha a ser igual a um dos valores informados
 // anteriormente, o programa seta uma variável booleana de sinalização
 // (flag) com o valor True.
 //
 // Evidentemente, antes dessa estrutura FOR, a variável flag deve ser
 // inicializada com o valor False, uma vez que ainda não se sabe se o
 // último valor informado é ou não duplicata.
 //
 // Ao encontrar um valor duplicata, além de setar a variável flag com
 // o valor True, o programa interrompe a repetição da estrutura FOR
 // interna, por meio do comando break.
 //
 // Essa operação é, então, repetida até que a variável flag possua
 // o valor False.
 //
 // Isso significa, que a nova estrutura FOR deve estar
 // embutida numa outra estrutura de repeitção (repeat...until) que
 // assegura que a estrutura FOR interna seja executada até que o
 // usuário informe um valor válido (não duplicata).
 //
 // Em seguida, o programa solicita ao usuário que entre com os
 // valores correspondentes à distância percorrida pelo veículo
 // e ao seu consumo de combustível.
 //------------------------------------------------------------------------
 repeat
 writeln;
 write ('Entre com a identificacao do veiculo ', i, ': ');
 readln (id [i]);
 flag := False;
 for j:= 1 to (i-1) do
 if id[i] = id[j] then
 begin
 flag := True;
 break;
 end;
 until (flag = False);
 writeln;
 writeln ('Entre com os valores correspondentes aa distancia percorrida pelo veiculo ');
 writeln;
 writeln (i, ' (em Km) e ao seu consumo de combustivel (em litros), separando esses ');
 writeln;
 writeln ('valores com um ou mais espacos.');
 writeln;
 readln (distancia
[i], consumo [i]);
 // Finalmente, o programa acumula a distancia percorrida e o consumo
 // de combustível associados ao veículo corrente, em suas respectivas
 // variáveis de totalização.
 distanciaTotal := distanciaTotal + distancia [i];
 consumoTotal := consumoTotal + consumo [i];
 end;
{
-----------------------------------------------------------------------
 Neste momento, o programa começa a gerar o relatório de saída,
 escrevendo seu cabeçalho.
 -----------------------------------------------------------------------
}
 clrscr;
 writeln; // gera uma linha em branco antes do cabeçalho
 writeln ('--------------------------------------------------------');
 writeln ('VEICULO DISTANCIA CONSUMO REAL CONSUMO MEDIO');
 writeln ('--------------------------------------------------------');
{
-----------------------------------------------------------------------
 A seguir, o programa emite uma linha de saída para cada um dos 5
 veículos.
 -----------------------------------------------------------------------
}
 for i := 1 to 5 do
 begin
 writeln (id[i]:7, distancia[i]:11:1, ' Km', consumo[i]:15:1,
 ' l', distancia[i]/consumo[i]:13:1, ' Km/l');
 end;
{
-----------------------------------------------------------------------
 Após essas linhas, o programa emite uma linha de separação antes de
 emitir a linha de resumo.
 -----------------------------------------------------------------------
}
 writeln ('--------------------------------------------------------');
{
-----------------------------------------------------------------------
 Fianlmente, o programa emite a linha de resumo, informando o consumo
 médio de cobustível de toda frota.
-----------------------------------------------------------------------
}
 writeln ('TOTAL',
 distanciaTotal:13:1, ' Km',
 consumoTotal:15:1, ' l',
 distanciaTotal/consumoTotal:13:1, ' Km/l');
 writeln;
 writeln;
 writeln('Pressione <Enter> para encerrar.');
 readln;
end.
solu�_es/1a Leva/Ex_10.lpi
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
solu�_es/1a Leva/Ex_11.lpi
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
solu�_es/1a Leva/Ex_02.lpr
{
------------------------------------------------------------------
 Este programa converte temperaturas em graus Celsius para graus
 Fahrenheit, utilizando a seguinte fórmula da Física:
 (F-32)/9 = C/5 isto é,
 F = (9*C)/5 + 32
 A fim de aumentar sua utilidade ficará convertendo temperaturas
 para o usuário até que ele entre com o valor 9999.
------------------------------------------------------------------
}
program Ex_02;
{$mode objfpc}{$H+}
uses
 {$IFDEF UNIX}{$IFDEF UseCThreads}
 cthreads,
 {$ENDIF}{$ENDIF}
 Classes
 { you can add units after this };
{$R *.res}
var t_c, // temperatura em Celsius
 t_f: real; // temperatura em Fahrenheit
begin
//
// Solicita a entrada da primeira temperatura a ser convertida
//
 write('Temperatura em graus Celsius : ');
 readln(t_c);
 while (t_c <> 9999) do
 begin
 t_f := 9 * t_c / 5 + 32;
 writeln('Temperatura em graus Fahrenheit: ', t_f:0:1);
 writeln;
 write('Temperatura em graus Celsius : '); // solicita mais uma temperatura
 readln(t_c);
 end;
 writeln;
 writeln;
 writeln('Pressione <Enter> para encerrar.');
 readln;
end.
solu�_es/1a Leva/Ex_01.lpi
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
solu�_es/1a Leva/Ex_12.lpr
{
-----------------------------------------------------------------------------
 Este programa determina a soma dos 50 primeiros termos da
 série de Fibonacci.
 Esta série é definida da seguinte forma:
 F1 = 0 ............ primeiro termo (por definição)
 F2 = 1 ............ segundo termo (por definição)
 A partir do terceiro, cada termo é igual à soma
 dos termos que o antecedem, ou seja:
 F3 = F1 + F2 ......... F3 = 0 + 1 = 1
 F4 = F2 + F3 ......... F4 = 1 + 1 = 2
 F5 = F3 + F4 ......... F5 = 1 + 2 = 3
 e assim por diante.
 Assim sendo, precisamos de uma variável para armazenar o valor do termo
 anterior (f1) e outra para armazenar o novo termo (f2).
 Como, por definição, o primeiro termo da série é igual a zero e o segundo
 igual a um, devemos, inicialmente, inicializar as variáveis f1 e f2, i.e.:
 f1 := 0; // termo anterior
 f2 := 1; // termo novo
-----------------------------------------------------------------------------
}
program Ex_12;
{$mode objfpc}{$H+}
uses
 {$IFDEF UNIX}{$IFDEF UseCThreads}
 cthreads,
 {$ENDIF}{$ENDIF}
 Classes
 { you can add units after this };
{$R *.res}
 var i:integer; // variável de controle da estrutura "for".
 f1, f2: real; // variáveis que armazenam os dois últimos termos da série
 soma: real; // variável que armazena a soma dos termos da série
begin
// inicializa os dois primeiros termos da série e acumula seus valores
 f1 := 0;
 f2 := 1;
 soma := f1 + f2;
// escreve os dois primeiros termos
 writeln('f 1 = ', f1:10:0);
 writeln;
 writeln('f 2 = ', f2:10:0);
// determina os termos restantes, a partir do terceiro
 for i:= 3 to 50 do
 begin
 writeln;
 f2 := f2 + f1; // Ao fazer isso, eu perco o valor antigo de f2
 f1 := f2 - f1; // Ao fazer isso, eu recupero o valor antigo de f2
 soma := soma + f2;
 writeln('f',i:2, ' = ', f2:10:0);
 end;
 writeln;
 writeln;
 writeln('A soma dos 50 primeiros termos de Fibonacci e: ', soma:12:0);
 writeln;
 writeln;
 writeln;
 writeln('Pressione
<Enter> para Encerrar.');
 readln;
end.
solu�_es/1a Leva/Ex_03.lpi
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
solu�_es/1a Leva/Ex_10.lpr
{
----------------------------------------------------------------------
 Este programa lê dois números inteiros entre 2 e 100 (x e y)
 e calcula o valor da operção que eleva o primeiro número
 à potência equivalente ao valor do segundo número, isto é:.
 x elevado a y (x ^ y).
 O intervalo [2, 100] foi estabelecido para evitar que o valor
 da operação ultrapasse a capacidade de armazenamento da memória
 do computador.
 A estratégia de solução é a seguinte:
 x ^ 1 = 1 * x = (x ^ 0) * x
 x ^ 2 = (x ^ 1) * x
 x ^ 3 = (x ^ 2) * x
 ............................
 x ^ y = (x ^ (y-1)) * x
 ----------------------------------------------------------------------
}
program Ex_10;
{
------------------------------------------------------------------------
 O programa faz uso da técnica de depuração dos dados fornecidos pelo
 usuário e também dos comandos REPEAT..UNTIL e FOR
------------------------------------------------------------------------
}
{$mode objfpc}{$H+}
uses
 {$IFDEF UNIX}{$IFDEF UseCThreads}
 cthreads,
 {$ENDIF}{$ENDIF}
 Classes
 { you can add units after this };
{$R *.res}
var x, y: real; // variáveis que armazenam os números lidos
 xx, yy: integer; // variáveis que armazenam os números truncados
 i: integer; // variável de controle da estrutura "for".
 m: integer; // variável que armazena o valor da potenciação
begin
 repeat
 write('Entre com dois numeros inteiros entre 2 e 100: ');
 readln(x, y);
 until ((x>=2) and (x<=100)) and ((y>=2) and (y<=100));
{------------------------------------------------------------------
 caso o usuário tenha entrado com números reais em vez de inteiros,
 é preciso truncar suas casas decimais por meio da função TRUNC:
 ------------------------------------------------------------------}
 xx := trunc(x);
 yy := trunc(y);
 m := 1 ; // equivale à (x ^ 0)
 for i:= 1 to yy do
 m := m * xx;
 writeln;
 writeln('O valor de ', xx, ' elevado a ', yy, ' = ', m);
 writeln;
 writeln('Pressione <Enter> para Encerrar.');
 readln;
end.
solu�_es/1a Leva/Ex_20.lpi
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
solu�_es/1a Leva/Ex_11.lpr
{
--------------------------------------------------------------
 Este programa calcula e escreva a soma de todos os números
 ímpares positivos menores do que 100.
--------------------------------------------------------------
}
program Ex_11;
{$mode objfpc}{$H+}
uses
 {$IFDEF UNIX}{$IFDEF UseCThreads}
 cthreads,
 {$ENDIF}{$ENDIF}
 Classes
 { you can add units after this };
{$R *.res}
 var i, // variável de controle da estrutura "for".
 soma: integer; // variável que armazena o valor da soma
begin
 soma := 0;
 for i:= 1 to 99 do
 if (i mod 2) <> 0 then // testa se i é ímpar (resto da div por 2 <> 0)
 soma := soma + i;
 writeln('A soma dos numeros impares menores do que 100 e: ', soma);
 writeln;
 writeln('Pressione <Enter> para Encerrar.');
 readln;
end.
solu�_es/1a Leva/Ex_02.lpi
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
solu�_es/2a leva/lib/i386-win32/Ex_24.res
solu�_es/2a leva/lib/i386-win32/Ex_24.or
solu�_es/2a leva/lib/i386-win32/Ex_24.o
solu�_es/2a leva/lib/i386-win32/Ex_24.compiled
 
 
 
solu�_es/4a leva/lib/i386-win32/Ex_18.res
solu�_es/4a leva/lib/i386-win32/Ex_14.o
solu�_es/4a leva/lib/i386-win32/Ex_18.o
solu�_es/4a leva/lib/i386-win32/Ex_18.or
solu�_es/4a leva/lib/i386-win32/Ex_14.or
solu�_es/4a leva/lib/i386-win32/Ex_18.compiled
 
 
 
solu�_es/4a leva/lib/i386-win32/Ex_14.compiled
 
 
 
solu�_es/4a leva/lib/i386-win32/Ex_14.res
solu�_es/4a Leva/Ex_18.lpr
program Ex_18;
{$mode objfpc}{$H+}
uses
 {$IFDEF UNIX}{$IFDEF UseCThreads}
 cthreads,
 {$ENDIF}{$ENDIF}
 Classes
 { you can add units after this };
{$R *.res}
var
 num: real;
 resp: string;
 erro: integer;
begin
 repeat
 writeln;
 write('Entre um numero qualquer: ');
 readln(resp);
 val(resp, num, erro);
 until erro = 0;
 writeln;
 if num < 0 then
 writeln('O numero ', num:0:2, ' e'' negativo.')
 else if num <= 25 then
 writeln('O numero ', num:0:2, ' pertence ao intervalo [0; 25].')
 else if num <= 40 then
 writeln('O numero ', num:0:2, ' pertence ao intervalo (25; 40].')
 else if num <= 90 then
 writeln('O numero ', num:0:2, ' pertence ao intervalo (40; 90].')
 else
 writeln('O numero ', num:0:2, ' e'' maior do que 90.');
 writeln;
 writeln;
 writeln('Pressione <Enter> para encerrar.');
 readln;
end.
solu�_es/4a Leva/Ex_04.lpr
program Ex_04;
{
------------------------------------------------------------------------------
 Este programa lê o custo de fabricação de um veículo e calcula o seu preço
 final, através da seguinte fórmula:
 preco_base := 1.28 * custo_fabr
 preco_final := 1.45 * preco_base
------------------------------------------------------------------------------
}
 {$mode objfpc}{$H+}
uses
 {$IFDEF UNIX}{$IFDEF UseCThreads}
 cthreads,
 {$ENDIF}{$ENDIF}
 Classes
 { you can add units after this };
{$R *.res}
var
 custo_fabr,
 preco_base,
 preco_final: real;
 resp: string;
 erro: integer;
begin
// leitura do custo de fabricacao
 repeat
 write ('Entre com o custo de fabricacao do veiculo: ');
 readln(resp);
 val(resp, custo_fabr, erro);
 until erro = 0;
// cálculo do preço base
 preco_base := 1.28 * custo_fabr;
// cálculo do preço final
 preco_final := 1.45 * preco_base;
 writeln;
 writeln('O preco final do veiculo = ', preco_final:0:2);
 writeln;
 writeln;
 writeln('Pressione <enter> para encerrar.');
 readln;
end.
solu�_es/4a Leva/Ex_16.lpi
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
solu�_es/4a Leva/Ex_19.lpr
program Ex_19;
{$mode objfpc}{$H+}
uses
 {$IFDEF UNIX}{$IFDEF UseCThreads}
 cthreads,
 {$ENDIF}{$ENDIF}
 Classes
 { you can add units after this };
{$R *.res}
var
 sal_minimo: real;
 sal_atual: real;
 sal_novo: real;
 percentual: real;
 reajuste: real;
 total: real = 0;
 resp: string;
 nome: string;
 erro: integer;
 i: integer;
begin
 repeat
 writeln;
 write('Entre o valor do salario minimo: ');
 readln(resp);
 val(resp, sal_minimo, erro);
 until erro = 0;
 writeln;
 for i:= 1 to 2 do
 begin
 write('Entre o nome do funcionario: ');
 readln(nome);
 repeat
 writeln;
 write('Entre o salario do funcionario: ');
 readln(resp);
 val(resp, sal_atual, erro);
 until erro = 0;
 if sal_atual < (3*sal_minimo) then
 percentual := 0.50
 else if sal_atual <= (10*sal_minimo) then
 percentual := 0.20
 else if sal_atual <= (20*sal_minimo) then
 percentual := 0.15
 else
 percentual := 0.10;
 writeln;
 reajuste := percentual * sal_atual;
 sal_novo := sal_atual + reajuste;
 writeln('------------------------------------------------------------');
 writeln('Nome: ':15, nome);
 writeln('Salario Atual: ', sal_atual:0:2);
 writeln('Reajuste: ':15, reajuste:0:2);
 writeln('Salario Novo: ':15, sal_novo:0:2);
 writeln('------------------------------------------------------------');
 total := total + reajuste;
 writeln;
 writeln;
 end;
 writeln;
 writeln('Total de reajustes: ', total:0:2);
 writeln;
 writeln;
 writeln('Pressione <Enter> para encerrar.');
 readln;
end.
solu�_es/4a Leva/Ex_14.lpi
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
solu�_es/4a Leva/Ex_15.lpi
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
solu�_es/4a Leva/Ex_09.lpi
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
solu�_es/4a Leva/Ex_04.lpi
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
solu�_es/4a Leva/Ex_18.lpi
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
solu�_es/4a Leva/Ex_19.lpi
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
solu�_es/4a Leva/Ex_16.lpr
program Ex_16;
{$mode objfpc}{$H+}
uses
 {$IFDEF UNIX}{$IFDEF UseCThreads}
 cthreads,
 {$ENDIF}{$ENDIF}
 Classes
 { you can add units after this };
{$R *.res}
var
 num: integer;
 resp: string;
 erro: integer;
begin
 repeat
 repeat
 writeln;
 write('Entre um numero inteiro de 1 a 10: ');
 readln(resp);
 val(resp, num, erro);
 until erro = 0;
 writeln;
 case num of
 1: writeln('Nominal: 1 Cardinal:
Um Ordinal: Primeiro');
 2: writeln('Nominal: 2 Cardinal: Dois Ordinal: Segundo');
 3: writeln('Nominal: 3 Cardinal: Tres Ordinal: Terceiro');
 4: writeln('Nominal: 4 Cardinal: Quatro Ordinal: Quarto');
 5: writeln('Nominal: 5 Cardinal: Cinco Ordinal: Quinto');
 6: writeln('Nominal: 6 Cardinal: Seis Ordinal: Sexto');
 7: writeln('Nominal: 7 Cardinal: Sete Ordinal: Setimo');
 8: writeln('Nominal: 8 Cardinal: Oito Ordinal: Oitavo');
 9: writeln('Nominal: 9 Cardinal: Nove Ordinal: Nono');
 10: writeln('Nominal: 10 Cardinal: Dez Ordinal: Decimo');
 else
 begin
 writeln('Valor invalido. Tente novamente.');
 erro := 99;
 end;
 end;
 until erro = 0;
 writeln;
 writeln;
 writeln('Pressione <Enter> para encerrar.');
 readln;
end.
solu�_es/4a Leva/Ex_14.lpr
program Ex_14;
{
------------------------------------------------------------------------------
 Este programa lê dois números reais e determina se eles são iguais ou
 diferentes. Neste caso, o programa indica qual o maior e o menor.
------------------------------------------------------------------------------
}
 {$mode objfpc}{$H+}
uses
 {$IFDEF UNIX}{$IFDEF UseCThreads}
 cthreads,
 {$ENDIF}{$ENDIF}
 Classes
 { you can add units after this };
{$R *.res}
var
 x, y: real;
 resp: string;
 erro: integer;
begin
// leitura do número x
 repeat
 write ('Entre um numero qualquer: ');
 readln(resp);
 val(resp, x, erro);
 until erro = 0;
// leitura do número y
 repeat
 write ('Entre outro numero: ');
 readln(resp);
 val(resp, y, erro);
 until erro = 0;
 writeln;
 writeln;
 // teste de igualdade
 if (x = y) then
 writeln('Os numeros lidos sao iguais (',x:0:1,'). ')
 else if (x < y) then
 writeln('Dentre os numeros informados, o menor eh ', x:0:1, ' e o maior eh ', y:0:1)
 else
 writeln('Dentre os numeros informados, o menor eh ', y:0:1, ' e o maior eh ', x:0:1);
 writeln;
 writeln;
 writeln('Pressione <enter> para encerrar.');
 readln;
end.
solu�_es/4a Leva/Ex_09.lpr
program Ex_09;
{
------------------------------------------------------------------------------
 Este programa lê dois números inteiros e calcula o produto entre eles sem
 utilizar a operação de multiplicação, apenas adições.
 Assim, x * Y pode ser calculado somando-se x, y vezes, ou somando-se y,
 x vezes.
------------------------------------------------------------------------------
}
 {$mode objfpc}{$H+}
uses
 {$IFDEF UNIX}{$IFDEF UseCThreads}
 cthreads,
 {$ENDIF}{$ENDIF}
 Classes
 { you can add units after this };
{$R *.res}
var
 x, y: integer;
 resp: string;
 erro: integer;
 i: integer;
 prod: integer;
begin
// leitura do número x
 repeat
 write ('Entre com um numero inteiro: ');
 readln(resp);
 val(resp, x, erro);
 until erro = 0;
// leitura do número y
 repeat
 write ('Entre com outro numero inteiro: ');
 readln(resp);
 val(resp, y, erro);
 until erro = 0;
// inicializar a variável que armazerá o produto x*y
 prod := 0;
// calcula do produto
 for i:=1 to y do
 prod := prod + x;
// escreve o resultado
 writeln;
 writeln(x, ' * ', y, ' = ', prod);
 writeln;
 writeln;
 writeln('Pressione <enter> para encerrar.');
 readln;
end.
solu�_es/4a Leva/Ex_15.lpr
program Ex_15;
{$mode objfpc}{$H+}
uses
 {$IFDEF UNIX}{$IFDEF UseCThreads}
 cthreads,
 {$ENDIF}{$ENDIF}
 Classes
 { you can add units after this };
{$R *.res}
var
 idade: integer;
 resp: string;
 erro: integer;
begin
 repeat
 write('Entre a idade do nadador (entre 99 para encerrar): ');
 readln(resp);
 val(resp, idade, erro);
 until erro = 0;
 while (idade <> 99) do
 begin
 writeln;
 writeln;
 case idade of
 5.. 7: writeln('O nadador pertence aa categoria "Infantil A"');
 8..10: writeln('O nadador pertence aa categoria "Infantil B"');
 11..13: writeln('O nadador pertence aa categoria "Juvenil A"');
 14..17: writeln('O nadador pertence aa categoria "Juvenil B"');
 18..25: writeln('O nadador pertence aa categoria "Senior"');
 else
 writeln('Idade fora da faixa etaria.');
 end;
 writeln;
 writeln;
 repeat
 write('Entre a idade do nadador (entre 99 para encerrar): ');
 readln(resp);
 val(resp, idade, erro);
 until erro = 0;
 end;
end.
solu�_es/4a leva/backup/Ex_18.lpi.bak
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
solu�_es/4a leva/backup/Ex_18.lpr.bak
program Ex_18;
{$mode objfpc}{$H+}
uses
 {$IFDEF UNIX}{$IFDEF UseCThreads}
 cthreads,
 {$ENDIF}{$ENDIF}
 Classes
 { you can add units after this };
{$R *.res}
var
 num: integer;
 resp: string;
 erro: integer;
begin
 repeat
 writeln;
 write('Entre um numero qualquer: ');
 readln(resp);
 val(resp, num, erro);
 until erro = 0;
 writeln;
 if num < 0 then
 writeln('O numero ', num, ' e'' negativo.')
 else if num <= 25 then
 writeln('O numero ', num, ' pertence ao intervalo [0; 25].')
 else if num <= 40 then
 writeln('O numero ', num, ' pertence ao intervalo (25; 40].')
 else if num <= 90 then
 writeln('O numero ', num, ' pertence ao intervalo (40; 90].')
 else
 writeln('O numero ', num, ' e'' maior do que 90.');
 writeln;
 writeln;
 writeln('Pressione <Enter> para encerrar.');
 readln;
end.
solu�_es/4a leva/backup/Ex_14.lpi.bak
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
solu�_es/4a leva/backup/Ex_14.lpr.bak
program Ex_14;
{
------------------------------------------------------------------------------
 Este programa lê dois números reais e determina se eles são iguais ou
 diferentes. Neste caso, o programa indica qual o maior e o menor.
------------------------------------------------------------------------------
}
 {$mode objfpc}{$H+}
uses
 {$IFDEF UNIX}{$IFDEF UseCThreads}
 cthreads,
 {$ENDIF}{$ENDIF}
 Classes
 { you can add units after this };
{$R *.res}
var
 x, y: real;
 resp: string;
 erro: integer;
begin
// leitura do número x
 repeat
 write ('Entre um numero qualquer: ');
 readln(resp);
 val(resp, x, erro);
 until erro = 0;
// leitura do número y
 repeat
 write ('Entre outro numero: ');
 readln(resp);
 val(resp, y, erro);
 until erro = 0;
// teste de igualdade
 if (x = y) then
writeln('Os numeros lidos sao iguais (',x:0:2,'). ')
 else if (x < y) then
 writeln('Dentre os numeros informados, o menor eh ', x:0:2, ' e o maior eh ', y:0:2)
 else
 writeln('Dentre os numeros informados, o menor eh ', y:0:2, ' e o maior eh ', x:0:2);
 writeln;
 writeln;
 writeln('Pressione <enter> para encerrar.');
 readln;
end.
solu�_es/2a Leva/Ex_17.lpr
{
------------------------------------------------------------------------------
 Este programa lê quatro inteiros e os coloca em ordem decrescente sem
 utilizar arrays. Ele utiliza o seguinte algoritmo:
 (1) comparamos os dois primeiros números lidos e armazenamos o valor do
 maior deles na variável maior1 e o menor na variável menor1.
 (2) fazemos o mesmo com os dois outros números lidos, mas armazenado o
 maior deles na variável maior2 e o menor na variável menor2.
 (3) em seguida, comparamos os valores de maior1 e de maior2, trocando seus
 valores, caso maior1 < maior2 (lembrem-se que a ordem pedida é a
 decrescente).
 (4) finalmente, comparamos os valores de menor1 e de maior2, trocando seus
 valores, caso menor1 > maior2.
 Depois disso, as variável maior1, maior2, menor1 e menor2 conterão os valores
 lidos em ordem decrescente. Basta então escrevê-los na tela.
 Este programa também utiliza a técnica de validação de dados de leitura.
 ------------------------------------------------------------------------------
}
program Ex_17;
 {$mode objfpc}{$H+}
uses
 {$IFDEF UNIX}{$IFDEF UseCThreads}
 cthreads,
 {$ENDIF}{$ENDIF}
 Classes
 { you can add units after this };
{$R *.res}
var
 maior1, menor1: integer;
 maior2, menor2: integer;
 x1, x2, x3, x4, temp: integer;
 resp: string;
 erro: integer;
begin
// leitura do primeiro número
 repeat
 write ('Entre com um numero inteiro: ');
 readln(resp);
 val(resp, x1, erro);
 until erro = 0;
// leitura do segundo número
 repeat
 write ('Entre com um numero inteiro: ');
 readln(resp);
 val(resp, x2, erro);
 until erro = 0;
// leitura do primeiro número
 repeat
 write ('Entre com um numero inteiro: ');
 readln(resp);
 val(resp, x3, erro);
 until erro = 0;
// leitura do segundo número
 repeat
 write ('Entre com um numero inteiro: ');
 readln(resp);
 val(resp, x4, erro);
 until erro = 0;
 if x1 > x2 then // comparação entre os 2 primeiros números lidos
 begin
 maior1 := x1;
 menor1 := x2;
 end
 else begin
 maior1 := x2;
 menor1 := x1;
 end ;
 if x3 > x4 then // comparação entre o terceiro e o quarto números lidos
 begin
 maior2 := x3;
 menor2 := x4;
 end
 else begin
 maior2 := x4;
 menor2 := x3;
 end ;
// descoberta do maior de todos os números
 if maior1 < maior2
 then begin
 temp := maior1;
 maior1 := maior2;
 maior2 := temp;
 end;
// descoberta do segundo maior número
 if menor1 > maior2
 then begin
 temp := menor1;
 menor1 := maior2;
 maior2 := temp;
 end;
 writeln;
 writeln('Os numeros lidos, em ordem decrescente, sao: ', maior1, ', ', maior2, ', ', menor1, ', ', menor2);
 writeln;
 writeln('Pressione <enter> para encerrar.');
 readln;
end.
solu�_es/2a Leva/Ex_21.lpr
program Ex_21;
{$mode objfpc}{$H+}
uses
 {$IFDEF UNIX}{$IFDEF UseCThreads}
 cthreads,
 {$ENDIF}{$ENDIF}
 Classes
 { you can add units after this };
{$R *.res}
var
 combustivel: array[1..3] of string = ('Alcool', 'Gasolina', 'Flex');
 desconto: array[1..3] of integer = (25, 20, 15);
 precoOriginal, precoFinal, valorDesconto, descontoTotal: real;
 resp: string;
 i, erro: integer;
begin
// leitura do primeiro número
 repeat
 write ('Entre com o preco do veiculo: ');
 readln(resp);
 val(resp, precoOriginal, erro);
 until erro = 0;
 descontoTotal := 0;
 while (precoOriginal <> 0) do
 begin
 repeat
 write ('Entre com o tipo de combustivel: ');
 readln(resp);
 until (resp = 'Alcool') or (resp = 'alcool') or
 (resp = 'Gasolina') or (resp = 'gasolina') or
 (resp = 'Flex') or (resp = 'flex');
 Case resp of
 'Alcool', 'alcool' : i := 1;
 'Gasolina', 'gasolina': i := 2;
 'Flex', 'flex' : i := 3;
 end;
 valorDesconto := (precoOriginal * desconto[i])/100;
 precoFinal := precoOriginal - valorDesconto;
 descontoTotal := descontoTotal + valorDesconto;
 writeln('Preco: ', precoOriginal:1:2,
 ' Combustivel: ', resp, ' Preco Final: ', precoFinal:1:2);
 writeln;
 repeat
 write ('Entre com o preco do veiculo: ');
 readln(resp);
 val(resp, precoOriginal, erro);
 until erro = 0;
 end;
 writeln;
 writeln('O valor total de descontos concedidos eh: ', descontoTotal:1:2);
 writeln;
 write('Pressione <Enter> para encerrar.');
 readln;
end.
solu�_es/2a Leva/Ex_23.lpr
program Ex_23;
{$mode objfpc}{$H+}
uses
 {$IFDEF UNIX}{$IFDEF UseCThreads}
 cthreads,
 {$ENDIF}{$ENDIF}
 Classes
 { you can add units after this };
{$R *.res}
var
 aliquota: array[1..5] of real = (0.0, 7.5, 15.0, 22.5, 27.5);
 deducao: array[1..5] of real = (0.0, 112.43, 280.94, 505.62, 692.78);
 renda, imposto: real;
 resp: string;
 i, erro: integer;
begin
 repeat
 write ('Entre com sua renda mensal: ');
 readln(resp);
 val(resp, renda, erro);
 until erro = 0;
 if (renda <= 1500) then i := 1
 else if (renda <= 2250) then i := 2
 else if (renda <= 3000) then i := 3
 else if (renda <= 3800) then i := 4
 else i := 5;
 imposto := ( renda * aliquota[i] ) / 100 - deducao[i];
 writeln('Voce devera recolher o valor de ', imposto:1:2,
 ' como imposto de renda.');
 writeln;
 write('Pressione <Enter> para encerrar.');
 readln;
end.
solu�_es/2a Leva/Ex_13.lpi
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
solu�_es/2a Leva/Ex_24.lpi
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
solu�_es/2a Leva/Ex_21.lpi
solu�_es/2a Leva/Ex_17.lpi
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
solu�_es/2a Leva/Ex_13.lpr
program Ex_13;
{
 Este programa calcula x^y (i.e. x elevado a y) sem usar a operação
 de multiplicação.
 Primeiramente, precisamos reconhecer que:
 (1) para calcularmos (x^2) precisamos somar x, x vezes, isto é:
 x^2 = x + x + x + x + ........ + x ou seja, x vezes x
 (2) para calcularmos (x^3) precisamos somar (x^2), x vezes, isto é:
 x^3 = (x^2) + (x^2) + (x^2) +.... + (x^2) ou seja, (x^2) vezes x)
 (3) para calcularmos (x^4) precisamos somar (x^3), x vezes, isto é:
 x^4 = (x^3) + (x^3) + (x^3) +.... + (x^3) ou seja, (x^3) vezes x)
 e assim por diante.
 Em suma:
 x^2 = (x) * x
 x^3 = (x^2) * x
 x^4 = (x^3) * x
 ---------------
 x^y = [x^(y-1)]*x
 Reparem que, a cada vez, estamos somando x vezes uma parcela diferente.
 Na primeira vez, a parcela é (x). Na segunda, é (x^2). Na terceira, é (x^3)
 e por aí vai até a última vez, quando estaremos somando x^(y-1) x vezes.
 Assim, precisamos de uma estrutura de repetição para produzir a somatória
 calculada a cada vez e de outra estrutura para repetir o processo para cada
 uma das diferentes parcelas:
 Para saber o número de parcelas, basta reparar que para obter (x^2), só
 precisamos de uma parcela (x). Para obter (x^3), nós precisamos de (x^2) que,
 por sua vez, precisa de (x), isto é, (x^3) requer duas parcelas. Ou seja, o
 número de parcelas corresponde ao expoente menos 1, isto é, precisamos de
 (y-1) parcelas para gerar (x^y).
 A cada vez temos de produzir uma somatória e, portanto, a variável que vai
 acumular a soma deverá ser zerada antes de se começar a soma a parcela
 da vez, x vezes.
 Precisamos também de uma variável para armazenar o valor da parcela da hora.
}
 {$mode objfpc}{$H+}
uses
 {$IFDEF UNIX}{$IFDEF UseCThreads}
 cthreads,
 {$ENDIF}{$ENDIF}
 Classes
 { you can add units after this };
{$R *.res}
var
 x, y: integer;
 i, j: integer;
 soma, parcela: integer;
 resp: string;
 erro: integer;
begin
// leitura de x
 repeat
 write ('Entre com um numero inteiro: ');
 readln(resp);
 val(resp, x, erro);
 until erro = 0;
// leitura de y
 repeat
 write ('Entre com um numero inteiro: ');
 readln(resp);
 val(resp, y, erro);
 until erro = 0;
 parcela := x; // parcela inicial
 for i:=1 to (y-1) do // controla o número de parcelas
 begin
 soma := 0; // zera a variável antes de começar a somatória da vez
 for j:=1 to x do // soma a parcela da vez, x vezes.
 soma := soma + parcela;
 parcela := soma; // Assim que a somatória da vez é produzida,
 // ela passa a ser a parcela a ser somada na
 // vez seguinte.
 end;
 writeln;
 writeln(x,'^', y, ' = ', soma);
 writeln;
 writeln;
 writeln('Pressione <enter> para encerrar.');
 readln;
end.
solu�_es/2a Leva/Ex_23.lpi
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
solu�_es/2a Leva/Ex_24.lpr
program Ex_24;
{$mode objfpc}{$H+}
uses
 {$IFDEF UNIX}{$IFDEF UseCThreads}
 cthreads,
 {$ENDIF}{$ENDIF}
 Classes
 { you can add units after this };
{$R *.res}
var
 aliquota: array[1..5] of real = (0.0, 7.5, 15.0, 22.5, 27.5);
 deducao: array[1..5] of real = (0.0, 112.43, 280.94, 505.62, 692.78);
 renda: integer;
 imposto: real;
 resp: string;
 i, erro: integer;
begin
// leitura do primeiro número
 repeat
 write ('Entre com sua renda mensal: ');
 readln(resp);
 val(resp, renda, erro);
 until erro = 0;
 case renda of
 0..1500: i := 1;
 1501..2250: i := 2;
 2251..3000: i := 3;
 3001..3800: i := 4;
 else
 i := 5;
 end;
 imposto := ( renda * aliquota[i] ) / 100 - deducao[i];
 writeln('Voce devera recolher o valor de ', imposto:1:2,
 ' como imposto de renda.');
 writeln;
 write('Pressione <Enter> para encerrar.');
 readln;
end.
solu�_es/2a leva/backup/Ex_24.lpi.bak
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
solu�_es/2a leva/backup/Ex_24.lpr.bak
program Ex_24;
{$mode objfpc}{$H+}
uses
 {$IFDEF UNIX}{$IFDEF UseCThreads}
 cthreads,
 {$ENDIF}{$ENDIF}
 Classes
 { you can add units after this };
{$R *.res}
var
 aliquota: array[1..5] of real = (0.0, 7.5, 15.0, 22.5, 27.5);
 deducao: array[1..5] of real = (0.0, 112.43, 280.94, 505.62, 692.78);
 renda, imposto: real;
 resp: string;
 i, erro: integer;
begin
// leitura do primeiro número
 repeat
 write ('Entre com sua renda mensal: ');
 readln(resp);
 val(resp, renda, erro);
 until erro = 0;
 case renda of
 0..1500: i := 1;
 1501..2250: i := 2;
 2251..3000: i := 3;
 3001..3800: i := 4;
 else
 i := 5;
 end;
 imposto := ( renda * aliquota[i] ) / 100 - deducao[i];
 writeln('Voce devera recolher o valor de ', imposto:1:2,
 ' como imposto de renda.');
 writeln;
 write('Pressione <Enter> para encerrar.');
 readln;
end.