Fundao CECIERJ - Vice Presidncia de Educao Superior a Distncia

Curso de Tecnologia em Sistemas de Computao

Disciplina Fundamentos de Programao
AD1 2 semestre de 2006.

IMPORTANTE:
As respostas (programas) devero ser entregues em papel e em disquete para serem testados.
1a Questo (1,0 ponto): Escreva um programa que leia do teclado um inteiro n, maior ou igual a 1, e
que apresente no vdeo n linhas da forma abaixo. Por exemplo, as seguintes linhas devem ser
apresentadas se n = 5.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Se n < 1, uma mensagem de erro deve ser apresentada no vdeo.
Resposta:

program quest_01_AD1(input{teclado}, output{vdeo});

procedure ler_valor_n (var n{s}: integer);
begin
write(output, 'Informe valor de n: ');
readln(input, n);
if n < 1 then
writeln(output, 'O valor de n deve ser maior ou igual a 1.');
end;
procedure imprimir_linhas (n{e}: integer);
var
i,j,k: integer;
begin
k:=1;
for i:=1 to n do
begin
for j:=1 to i do
begin
write(output, k, ' ');
K:=K+1
end;
writeln(output)
end
end;

var
n: integer;
begin
ler_valor_n(n);
imprimir_linhas(n)
end.

2a Questo (2,0 pontos): Faa um programa para encontrar: (a) o valor mdio dos N elementos
inteiros de um vetor V (Const N = 50) e (b) os m elementos mais prximos deste valor mdio.
Considere que todos os N elementos de V so distintos e que m < N. O valor m e os N elementos
inteiros do vetor devem ser lidos do teclado. O valor mdio e seus m elementos mais prximos devem
ser apresentados no vdeo.
Resposta:

program quest_02_AD1 (input{teclado}, output{vdeo}); { Esta resposta poderia ser mais eficiente se
o aluno j tivesse estudado algoritmos de ordenao,ou, pelo menos, insero ordenada.}
const
N = 50;
type
T_Dominio = 1 .. N;
T_Vetor = array[T_Dominio] of integer;
T_Vetor2 = array[T_Dominio] of real;
procedure ler_vetor_e_m (var V{s}: T_Vetor; var m{s}: integer);
var
ind: integer;
begin
write(output, 'Informe valor de m: ');
readln(input, m);
for ind:= 1 to N do
begin
write(output, 'V[', ind, ']=');
readln(input, V[ind]);
end
end;
procedure localiza_maior_dif_de_R (R{e}: T_Vetor; var posicao_maior_dif_de_R: integer;
media{e}: real; m{e}: integer);
{ Esta rotina localiza a maior diferena no vetor R.}
var
i: integer;
maior_dif_de_R: real;
begin
maior_dif_de_R := abs(R[1]-media);
for i := 2 to m do

if abs(R[i]-media) > maior_dif_de_R then

maior_dif_de_R := abs(R[i]-media)
end;
procedure identificar_media_e_mais_proximos (V{e}: T_Vetor; m{e}: integer;
var R{s}: T_Vetor; var md{s}: real);
{ As m primeiras posies do vetor R devero conter os m elementos mais prximos da mdia.}
var
i: integer;
soma: integer;
Dif: T_Vetor2;
maior_dif_de_R: real;
posicao_maior_dif_de_R: integer;
begin
soma:=0;
for i:=1 to N do
soma := soma + V[i];
md := soma / N;
{ Calcula as diferenas entre todos elementos e a mdia.}
for i:=1 to N do
Dif[i] := abs(V[i]-md);
{As m primeiras posies de R recebero os m primeiros valores de V.}
maior_dif_de_R := Dif[1];
posicao_maior_dif_de_R := 1;
for i:=1 to m do
begin
R[i] := V[i];
if Dif[i] > maior_dif_de_R then
begin
maior_dif_de_R := Dif[i];
posicao_maior_dif_de_R := i
end
end;
{Percorrer os demais valores de V procurando por aqueles com uma diferena menor do que o
elemento que possui a maior diferena em R. Havendo, dever ocorrer a troca.}
for i:=m+1 to N do
if Dif[i] < maior_dif_de_R then
begin
maior_dif_de_R := Dif[i];
R[posicao_maior_dif_de_R] := V[i];
localiza_maior_dif_de_R (R, posicao_maior_dif_de_R, md, m);
end
end;
procedure imprimir_resultado (m{e}:integer; R{e}:T_Vetor; md{e}:real);
var

ind: integer;
begin
writeln(output, 'A mdia dos N elementos : ', md:2:2);
write(output, 'Os ', m, 'elementos mais prximos so: ');
for ind:=1 to m do
write(output, R[ind], ' ')
end;
var
V,R: T_Vetor;
m: integer;
md: real;
begin
ler_vetor_e_m(V,m);
identificar_media_e_mais_proximos(V,m,R,md);
imprimir_resultado(m,R,md)
end.

3a Questo (2,0 pontos): Implemente, de forma recursiva, a busca binria de um elemento inteiro b
em um vetor V de N elementos inteiros (Const N = 100). Considere que todos os N elementos de V
so distintos. O valor b e os N elementos inteiros do vetor devem ser lidos do teclado. A posio do
vetor em que o elemento b se encontra deve ser apresentada no vdeo. Caso o elemento b no
aparea no vetor V, o valor zero deve ser apresentado.
Resposta:

program quest_03_AD1 (input{teclado}, output{vdeo});

const
N = 50;
type
T_Dominio = 1 .. N;
T_Vetor = array[T_Dominio] of integer;
procedure ler_vetor_e_b (var V{s}: T_Vetor; var b{s}: integer);
var
ind: integer;
begin
write(output, 'Informe valor de b: ');
readln(input, b);
for ind:= 1 to N do
begin
write(output, 'V[', ind, ']=');
readln(input, V[ind]);
end
end;

function busca_binaria (V{e}: T_Vetor; inicio, fim{e}: integer; b{e}: integer): integer;
var
meio: integer;
begin
if inicio = fim then
if V[inicio] = b then
busca_binaria := inicio
else
busca_binaria := 0
else
begin
meio := (inicio + fim) div 2;
if V[meio] = b then
busca_binaria := meio
else
if V[meio] < b then
begin
inicio := meio + 1;
busca_binaria := busca_binaria (V, inicio, fim, b)
end
else
begin
fim := meio - 1;
busca_binaria := busca_binaria (V, inicio, fim, b)
end
end
end;

procedure imprimir_posicao (b,p{e}:integer);

begin
write(output, 'A posio do elemento ', b, ' ', p);
end;
var
V: T_Vetor;
b, p: integer;
begin
ler_vetor_e_b(V,b);
p := busca_binaria(V,1,N,b);
imprimir_posicao(b,p)
end.

4a Questo (1,0 ponto): Faa um programa que leia strings do teclado e diga se cada string lida
uma palndroma. Uma string ser palndrome se e somente se a seqncia de caracteres do incio
para o final for idntica a seqncia de caracteres do final para o incio. Exemplos de palndromas:
aba, omo, abcdcba, abarraba e 1245421. Seu programa deve terminar quando a string lida for
uma string vazia .
Resposta:

program quest_04_AD1(input{teclado}, output{vdeo});

const
parada = '';
function palindroma(x{e}: string): boolean;
begin
if x=parada then palindroma:= true
else
palindroma:= (x[1]=x[length(x)])and palindroma(copy(x,2,length(x)-2))
end;
var
Str: string;
begin
write(output, 'Diga uma string: ');
readln(input, Str);
while Str<>parada do
begin
if palindroma(Str) then writeln(output, 'Sim ', Str, ' uma palndroma');
write(output, 'Diga uma string: ');
readln(input, Str);
end;
end.

5a Questo (2,0 pontos): Faa um programa para compactar strings conforme exemplificado a seguir:
String lida: aaaaaaaaaaaabbbbbbbbbbaaaaacccccccccbbbb
String compactada: a12b10a5c9b4
String lida: abacaxi
String compactada: a1b1a1c1a1x1i1
Resposta:

program quest_05_AD1(input{teclado}, output{vdeo});

const
vazia = '';
function compacta(x{e}: string): string;
var
conta: integer;
resp, contagem: string;
primeiro: char;
begin
resp:= vazia;
if x<>vazia then
repeat
primeiro:= x[1];
conta:= 1;
delete(x,1,1);
while (x<>vazia) and (primeiro=x[1]) do
begin
conta:= conta+1;
delete(x,1,1);
end;
str(conta, contagem);
resp:= resp+primeiro+contagem;
until x=vazia;
compacta:= resp
end;
var
Cadeia: string;
begin
write(output, 'Diga uma string: ');
readln(input, Cadeia);
writeln(output, compacta(Cadeia));
end.

6a Questo (2,0 pontos): Faa um programa que leia strings contendo expresses aritmticas
(apenas soma) e calcula o valor correspondente expresso lida. Veja exemplos:
Expresso lida: 12.4+0.01+13
Valor calculado: 25.41
Expresso lida: 13
Valor calculado: 13
Resposta:

program quest_06_AD1(input{teclado}, output{vdeo});

const
operador = '+';
function avalia(x{e}: string): real;
{Comentrio: supomos a expresso x bem formada e sem espaos em branco}
var
erro, onde: integer;
numero: real;
resp: real;
begin
resp:= 0;
val(x, numero, erro);
while erro<>0 do
begin
onde:= pos(operador, x); {localiza o '+' na string}
val(copy(x,1,onde-1), numero, erro); {pega o nmero antes do '+'}
resp:= resp+numero;
delete(x, 1, onde); {reduz a string at o primeiro '+'}
val(x, numero, erro);
end;
avalia:= resp+numero;
end;
var
Expressao: string;
begin
write(output, 'Diga uma expresso aritmtica: ');
readln(input, Expressao);
writeln(output, avalia(Expressao):7:2);
end.