Informática Aplicada (LINGUANGEM DE PR OGRAMAÇÃO FORTRAN)

1º Nível, Cursos de Engenharia : 2016 Eléctrica

Hidráulica
Termotécnica

Pelos Docentes: dr. Veca Luis, Eng. Virgílio, Dr. Mazibe, Dr. Edson, Dr. Machel.
Índice
1. Linguagem de Programação (Fortran)....................................................................................................... 3
1.0. Introdução à programação em Fortran ............................................................................................... 3
1.1. Codificação de programa em Fortran (sintaxe do fortran) ................................................................. 3
1.2. Estrutura básica do Fortran................................................................................................................. 4
1.3. Formato Livre ..................................................................................................................................... 4
1.4. Formato Fixo ...................................................................................................................................... 4
2. Tipos e Declaração de Variáveis ............................................................................................................ 5
2.1. Declaração de Variáveis ..................................................................................................................... 5
2.2. Atribuição de Valores ......................................................................................................................... 6
3. Comandos de Entrada/Saída................................................................................................................... 6
3.1. Comandos READ sequências ............................................................................................................. 7
3.2. Comandos WRITE (PRINT) .............................................................................................................. 7
3.3. Comandos WRITE (PRINT) sequências ............................................................................................ 7
3.4. Comando OPEN ................................................................................................................................. 7
3.5. Registos, Arquivos e Unidades........................................................................................................... 7
3.6. Comando CLOSE ............................................................................................................................... 8
4. Comandos de controlo de fluxo ............................................................................................................. 8
4.1. Comandos IF ...................................................................................................................................... 8
4.2. Comando IF lógico ............................................................................................................................. 8
4.3. Comandos IF bloco............................................................................................................................. 8
4.4. Comando DO ...................................................................................................................................... 9
4.5. Comando EXIT .................................................................................................................................. 9
4.6. Comando CYCLE .............................................................................................................................. 9
4.7. Comando CONTINUE ....................................................................................................................... 9
4.8. Comando STOP ................................................................................................................................ 10
4.9. Comando END ................................................................................................................................. 10
4.10. Comando SELECT CASE ............................................................................................................ 10
5. Estruturas Homogéneas ........................................................................................................................ 10
5.1. Atribuição de valores........................................................................................................................ 10
5.2. Declaração: ................................................................................................................................... 11
5.3. Atribuição de valores........................................................................................................................ 11
5.4. Comando de saída (print) com arrays multidimensionais ................................................................ 11

2
6. Ficha 2: Exercícios fortran ................................................................................................................... 13

1. Linguagem de Programação (Fortran)

1.0.Introdução à programação e m Fortran

A linguagem FORTRAN (Formula-Translate) é considerada como a primeira linguagem de
programação de alto nível (surgiu em 1956), foi proposta e implementada para auxiliar os programadores
na codificação de problemas técnicos e científicos cuja solução requer a utilização de computadores
electrónicos. O FORTRAN é uma das linguagens programação mais popular e difundida no meio técnico
e científico, muitas bibliotecas computacionais na área de matemática estão disponíveis nesta linguagem.

1.1.Codificação de programa e m Fortran (sintaxe do fortran)

Programa FORTRAN

Cabeçalho
Conjunto de especificações
Conjunto de instruções de execução
Subprogramas (caso existam)
Instrução de final do programa
O cabeçalho consiste na instrução PROGRAM seguida pelo nome do programa escolhido pelo
programador. O nome do programa deve iniciar-se por uma letra e consiste numa sequência de,
no máximo 31 letras, algarismos ou sublinhados (ex.: PROGRAM ex1_a).

No conjunto de especificações declaram-se os nomes e os tipos de variáveis que são usados para
guardar os valores dos dados, resultados e dos cálculos intermédios.
O conjunto de instruções de execução consiste na sequência de instruções do algoritmo que
permitem resolver o problema em estudo.

A instrução final do programa consiste na instrução END PROGRAM seguida pelo nome do
programa. Ex.

Fortran 95 Pseudocodigo em (Portugol)

program media inicio
implicit none real nota1, nota2,nota3,nota4, med
real:: n1,n2,n3,n4,med escrever "Digite Primeira nota:"
print*, "Digite primeira nota" ler nota1
read*, n1 escrever "Digite Segunda nota:"
print*, "Digite Segunda nota" ler nota2
read*, n2 escrever "Digite Terceira nota:"
print*, "Digite Terceira nota" ler nota3
read*, n3 escrever "Digite Quarta nota:"
print*, "Digite Quarta nota" ler nota4
read*, n4 med<-(nota1+nota2+nota3+nota4)/4
med=(n1+n2+n3+n4)/4 escrever "a sua media é:", med
print*, "A sua média é:", med fim
end program media

3
 1.2. Estrutura básica do Fortran
PROGRAM media// este é o início do programa começando pela palavra program seguido do nome do programa
Implic it none // inibe a possibilidade de, as variáveis não serem declaradas
Integer ::a // Declaração de variáveis
Write *, “Digite um numero” // exibe uma mensagem
Read*, a // leitura de dados
Write*, a // Comando para exibir e invocar valor da variável
Write *, “fim de programa” // mostra uma mensagem
END PROGRAM media // sempre que o programa iniciar tem que terminar com palavras end programa o nome do
programa.

1.3. Formato Livre

Como mostrado nos exemplos há duas maneiras de transferir dados, do teclado para o programa usa ndo
read* (input-entrada), e escrever uma mensagem no ecrã com o comando print* (output-saida). Esta
forma simples de I/O chama-se lista - direccionada de input e output.
Os asteriscos do read* e print*(*) têm o significado de formato livre, isto quer dizer o formato é definido
pelo sistema do computador e não pode ser controlado pelo programador.
O formato dos dados transferidos do teclado para o sistema do computador, podem ser especificados em:
tipo de dados a ser exibido, a quantidade dos dígitos, quantos dígitos depois do ponto decimal e em que
caracteres e número podem se exibidos. Com o código podendo ser escrito a partir da primeira coluna e não
há limite de caracteres por linha.
No formato livre temos a considerar:
 132 caracteres por linha;
 Maiúsculas e minúsculas;
 Nomes até 31 caracteres.

1.4.Formato Fixo
Algumas necessidades em programação, definiram o Fortran77 como uma linguagem obsoleta em relação
às linguagens actuais:
Formato fixo:
 Linhas de instruções, começavam na posição 7 e iam até a 72;
 Somente letras maiúsculas;
 Nomes de variáveis, até 6 caracteres.
 Impossibilidade de determinar operações paralelas;
É uma situação crítica, pois o Fortran é considerado como uma linguagem de alta performance, no
entanto, até o padrão 77 não existia nenhuma instrução que permitisse ao usuário definir regiões do
programa que pudessem executar em paralelo, utilizando os recursos de mais de um processador, como
por exemplo, q compartilha de endereços de memória.
Não é possível a alocação dinâmica de memória;
No Fortran77, o programador é obrigado a declarar vectores com o maior tamanho possível para reservar
memória durante a compilação, ou seja, não era possível utilizar conjuntos de dados temporários durante
a execução.
Não possui representação numérica portável;
Diversos ambientes computacionais criaram extensões do Fotran77 para melhorar a precisão numérica em
suas arquitecturas, o que tornava o código “não portável” para outra arquitetura. No Fortran90, os
diversos recursos de precisão numérica foram padronizados, melhorando a portabilidade.
 Não era possível definir uma nova estrutura de dados pelo usuário.

4
  Não possui recursão explícita;
 Não era possível chamar uma função dentro de outra função. Não havia recursão!

2. Tipos e Declaração de Variáveis

As variáveis podem ser basicamente de quatro tipos: numéricas, caracteres ou lógicas. Os tipos de
variáveis do Fortran são:
INTEGER
Números inteiros
REAL
Números reais
Suporta valores entre 1.0 x 10-45 até 1.0 x 1045
REAL*8
Números reais em dupla precisão suporta valores entre 1.0 x 10-300 até 1.0 x 10300 este tipo de variável
é o tipo mais usado em engenharia e seu uso deve ser preferido dentre as duas formas de número reais
programas mais antigos usavam a declaração: DOUBLE PRECISION para este tipo de variável
CHARACTER*i
Sequência alfanumérica com um máximo de i caracteres não pode ser utilizada em operações
matemáticas
COMPLEX
Números complexos
LOGICAL
Variáveis lógicos
Possui dois valores: .FALSE. (falso) e .TRUE. (verdadeiro) este tipo de variável tem sido
gradativamente substituído por números Inteiros onde 0 se refere a falso e 1 a verdadeiro.

2.1. Declaração de Variáveis

As variáveis podem ser declaradas em grupo ou individualmente. Esta declaração deve vir logo no início
do programa. Individualmente, as variáveis são declaradas listando seus nomes após o tipo da variável,
como por exemplo:
INTEGER :: A, B, C
REAL:: D, E
REAL*8:: F, G, H
CHARACTER*10:: I
COMPLEX ::J
É importante dar nomes representativos para as variáveis, de forma que se possa identificar facilmente
sua função no programa.
EXEMPLO
REAL*8 DENS, VISC para densidade e viscosidade
INTEGER IDX para índice
É comum esquecermos de declarar variáveis no início do programa quando usamos a declaração
individual das variáveis. Para evitar este problema, podemos usar a função IMPLICIT para declarar um
grupo de variáveis baseados em sua letra inicial:
IMPLICIT REAL*8 (A-H,O-Z) esta declaração irá fazer com que todas as variáveis iniciadas em A até H
e em O até Z sejam número reais em dupla precisão. Como consequência, as variáveis iniciadas em I até
N serão números inteiros. Em geral, as letras I a N são utilizadas para denotar números inteiros e as
demais são usadas para números reais (convenção estabelecida), porém isto não impede que se use as
letras I a N para números reais e as outras para inteiros.
Utilizar o comando IMPLICIT não impede a declaração individual de outras variáveis, sendo que
declarações individuais se sobrepõem à declaração feita pelo comando IMPLICIT.
EXEMPLO
IMPLICIT REAL*8 (A-H,O-Z)
REAL*8 NSA

5
 INTEGER P1
CHARACTER*20 ARQUIVO

2.2.Atribuição de Valores
 Formas válidas para núme ros inteiros:
I=0
I = 134
I = -23
 Formas válidas para núme ros reais:
A = 3.1415
A = -0.0012
A = .236
A = +5.0E3
A atribuição 5.0E3 quer dizer: 5.0 x 103
 Formas válidas para núme ros reais em dupla precisão (REAL*8):
A = 3.1415D0
A = -0.0012D0
A = 2.4D-62
A = +5.0D2
A atribuição 5.0D3 quer dizer: 5.0 x 103
Mesmo para números pequenos é importante a colocação do D0 após o número, pois esta atribuição
elimina o risco da variável conter “muitos algarismos” em seu final. A falta do D0 pode levar o número
5.0 a ser armazenado na variável como 5.000000342589485 ou mesmo 4.999999993748758, sendo que
algumas vezes este “algarismos” pode afectar operações com números muito pequenos.
 Formas válidas para núme ros complexos:
A atribuição do número complexo deve ser sempre feita entre parênteses, onde o primeiro número é a
parte real e o segundo número é a parte imaginária.
C = (1,2)
C = (1.70,-8.948)
C = (+502348E5,.999)
 Formas válidas para variável lógica:
L = .TRUE.
L = .FALSE.
Estas são as duas únicas opções para a variável lógica
 Formas válidas para caracteres
O texto alfanumérico pode ser definido entre apostro fes ou entre aspas
S = “Texto”
S = „texto‟
No caso de o apóstrofe ser necessário no meio do texto, pode-se usar as formas:
S = “texto‟s texto”
S = „texto‟‟s texto‟

3. Comandos de Entrada/Saída
- Os "Comandos de Entrada" fornecem um método de transferir dados de um dispositivo periférico (como
um teclado) ou de um arquivo interno para a memória principal. Este processo é chamado de "leitura de
dados".
- Os "Comandos de Saída" fornecem um meio de transferir dados da memória principal para um
dispositivo periférico (como um monitor de vídeo ou impressora) ou um arquivo interno. Este processo é
chamado de "escrita" ou "gravação" de dados.
- Alguns comandos de E/S permitem que se edite os dados durante a sua transferência.

6
- Neste capítulo somente serão apresentados os comandos de E/S que transferem dados
(READ, PRINT, WRITE). Comandos auxiliares não serão discutidos.

3.1.Comandos READ sequências

- As formas aceites dos comandos READ seqüencial são:
read([unit=]u,[fmt=]f) [lista] ou read f [, lista] sendo que "f" pode ser substituído por "*" para designar
uma lista directa. Se "u" for substituído por "*" , a leitura será feita na unidade de entrada padrão.
- Exemplos:
read(unit=3,fmt=100) a,b,c 100 format(3f5.2) é igual a: read(3,100) a,b,c 100 format(3f5.2) que ainda
podem ser simplificados para: read(3,*) a,b,c (lista direta) ou read(*,*) a,b,c (aqui a leitura passa a ser
feita a partir da entrada padrão).

3.2.Comandos WRITE (PRINT)

- Os comandos WRITE (PRINT) transferem dados armazenados na memória do computador para
dispositivos de saída (vídeo, arquivos ou impressora).
- IMPORTANTE: cada novo comando WRITE (PRINT) passa a escrever dados em uma nova linha.

3.3.Comandos WRITE (PRINT) sequências

- As formas aceitas dos comandos WRITE seqüencial são: write([unit=]u,[fmt=]f) [lista] sendo que "f"
pode ser substituído por "*" para lista directa.
- Exemplos: write(unit=7,fmt=200) a,b,c 200 format(3f5.2) ou write(7,200) a,b,c 200 format(3f5.2) (igual
ao comando anterior) ou write(7,200) a,b,c 200 format(3f5.2) (praticamente igual aos comandos
anteriores) ou write(*,*) a,b,c (escreve na saída padrão)
- A diferença entre WRITE e PRINT é que este último somente escreve na saída padrão (o vídeo, no
nosso caso). Por isso PRINT dispensa o especificador de unidade.
- A forma aceita do comando PRINT é: print f [, lista] sendo que "f" pode ser substituído por "*" para
lista directa.
- Exemplos: print 200, a,b,c 200 format(3f5.2) ou print *, a,b,c (lista directa).

3.4.Comando OPEN
- O comando OPEN serve para inicializar um arquivo.
- A forma geral simplificada do comando OPEN é: open([unit=]u[,file='a'][,status='b']) sendo que:
- "u" é o número da unidade.
- 'a' é uma expressão carácter que especifica o nome do arquivo;
- 'b' especifica a condição do arquivo, que pode ser:
-'NEW', para arquivos novos, que vão ser criados pelo programa;
-'OLD', para arquivos já existentes (em geral, arquivos de entrada de dados);
-'SCRATCH', para arquivos que são criados pelo programa e que devem ser apagados no final da
execução deste.
- 'UNKNOWN', para arquivos para os quais não se aplica nenhuma das condições acima discutidas.

3.5.Registos, Arquivos e Unidades

- Um "carácter" é um único símbolo, tal como a letra z, o dígito 4 ou um asterisco *.
- Um "campo" é uma sucessão de caracteres, que representa alguma informação, ta l como ANTONIO ou
128.47.
- Um "registo" é um grupo de campos que reúne informações sobre um único item, tal como: ANTONIO
26-01-1937 6543.21 (nome) (data nasc.) (salário)
- Um "arquivo" é um grupo de registos, tal como: Temos acima um arquivo, com três registos, cada
registo com três campos e comprimento total de 27 caracteres.

7
- Cada comando de E/S opera sobre um único registo.
- Uma unidade de E/S é um meio de se referir a um arquivo. Usa-se números de unidades de E/S para
distinguir um arquivo de outro.
- Certos números de unidades podem ser pré-definidos. Assim, por exemplo, o número 5 pode indicar o
teclado e 6 pode indicar o monitor de vídeo.
- O comando OPEN estabelece a conexão entre o número da unidade e um particular arquivo.

3.6.Comando CLOSE
- O comando CLOSE serve para finalizar um arquivo. É o oposto de OPEN.
- A forma geral simplificada do comando CLOSE é: close([unit=]u) sendo que "u" é o número da
unidade.

4. Comandos de controlo de fluxo

4.1.Comandos IF
- Os comandos IF transferem o controlo do fluxo ou executam outro comando (ou um bloco de
comandos) dependendo do resultado verdadeiro ou falso de uma expressão lógica contida no particular
comando IF. Os três tipos de comandos IF são:
1. IF aritmético.
2. IF lógico.
3. IF bloco.
- Os comandos ELSE, ELSE IF e END IF são também apresentados nesta sessão, pois eles são usados
somente em conjunto com um comando IF bloco.

4.2.Comando IF lógico
- O comando IF lógico calcula uma expressão lógica/relacional e executa ou ignora um comando
executável contido no próprio IF, dependendo do valor (falso ou verdadeiro) dessa expressão.
- A forma geral do comando IF lógico é: if (condicao ) then….endif sendo que: if =se, then=então,
endif=fimse.
Ex:
Portugol fortran
Se (media>14) então if (media>14)then
Escrever “Dispensado” print* “Dispensado”
Fimse endif

4.3.Comandos IF bloco
- O comando IF bloco permite a execução de um determinado bloco de comandos, dependendo do valor
da(s) expressões lógica(s)/relacional(is) nele contido.
- A forma geral do comando IF bloco é:
Ex:
Portugol fortran
Se (media>14) então if (media>14)then
Escrever “Dispensado” print*, “Dispensado”
Senão else
Escrever “Admitido” print*, “Admitido”
Fimse endif

- O comando ENDIF ou END IF finaliza uma estrutura IF bloco. Sua forma geral é simplesmente: end if
- Exemplo:
...
print *,”Digite a nota do aluno: “
read *,nota
if(nota>=5.0) then

8
 print *,”O aluno foi aprovado.”
elseif(nota>=3.5) then
print *,”O aluno foi reprovado mas podera cursar o RE.”
else
print *,”O aluno foi reprovado e nao podera cursar o RE.”
endif

4.4.Comando DO
- O comando DO é um comando de controlo que permite que um bloco de comandos seja repetitivamente
executado. O número de execuções depende da variável de controlo.
- A forma geral do comando DO é:
Fortran portugol
do v = vi , vf [, incr] para v de vi ate vf passo incr
enddo proximo

- Exemplo:
do i=0,100,5 para i de 0 ate 100 passo 5
bloco de comandos bloco de comandos
enddo próximo

- Existem duas estruturas DO:

1) A estrutura DO - END DO (repeat loop) repete um bloco de comandos condicionado ao valor de uma
variável de controlo que deve variar de modo fixo e pré-determinado:
do v=vi,vf,incr
bloco de comandos
end do

2) A estrutura DO WHILE - END DO (while loop) executa o laço DO enquanto uma expressão
lógica/relacional for verdadeira:
do while (media>14)
bloco de comandos
end do

- O comando DO implícito é uma terceira forma do comando DO e somente pode ser usando em
comandos de entrada ou saída de dados.
- Exemplos de uso do comando DO implícito:
print *,(var(i),i=1,10,1)
print *,(var(i,j),j=10,20,2)
read(1,100)(var(i),i=2,8,2)
write((3,200)(var(i,j),j=1,5,1)

4.5.Comando EXIT
- O comando EXIT termina abruptamente um laço DO, direccionando o fluxo do programa para a
primeira linha de comando após o ENDDO daquele respectivo comando DO envolvido.

4.6.Comando CYCLE
- O comando CYCLE reinicia abruptamente um laço DO, direccionando o fluxo do programa para a linha
do comando DO dentro do qual ele está inserido.

4.7.Comando CONTINUE
- O comando CONTINUE é um comando executável que somente passa o controlo para o próximo
comando executável. A forma geral é: continue

9
 4.8. Comando STOP
- O comando STOP termina a execução do programa. Apesar de sua localização dentro do programa em
geral ser a penúltima linha de comando, ele pode ser colocado em qualquer posição dentro do programa.
- A forma geral do comando STOP é: stop [varcar]
Sendo que "varcar" é uma variável carácter que será exibida na saída padrão (em geral, a tela do monitor
do operador).

4.9.Comando END
- O comando END indica o final de uma unidade de programa para o compilador. Sua forma geral é: end
Deve obrigatoriamente ser colocado na última linha do programa.

4.10. Comando SELECT CASE

- A estrutura SELECT CASE permite a execução de apenas uma entre muitas opções possíveis.
- A estrutura SELECT CASE possui a seguinte forma:
select case (var)
case (um_valor_de_var)
bloco de comandos 1
case (outro_valor_de_var)
bloco de comandos 2
case (outro_ainda_valor_de_var)
bloco de comandos 3
...
end select
- Exemplo:
...
print *,'Digite um numero de 1 a 10: '
read *,nu
select case (nu)
case (1:4)
print *,'A opcao foi um numero no intervalo [1,4]'
case (5)
print *,'A opcao foi pelo numero 5'
case (6:10)
print *,'A opcao foi um numero no intervalo [6,10]'
end select

5. Estruturas Homogéneas

Variáveis compostas homogéneas (arrays), Vectores (unidimensionais) e Matrizes (multidimensionais).

Arrays correspondem a posições de memória, identificadas por um único nome, individualizadas por
índice e cujo conteúdo é de um mesmo tipo.
Vectores:
Declaração:
Tipo: Nome: Número de elementos
Exemplos:
real, dimension(50) :: a, b, c
real, dimension (11:60) :: a, b, c
real :: a(50), b(50), c(50)
real, dimension(50) :: a, b, c, x(20), y(20), z
integer, dimension(-20:-1) :: x
logical, dimension(-9:10) :: y

5.1.Atribuição de valores
vetor(3) = 1
vetor = (/ 1,2,3,4,5 /) , onde vector tem cinco elementos
Usando o do implícito:

10
 vetor = (/ i, i=1, 5 /)
vetor = (/ -1, (0, i=2, 49), 1 /)
vetor = (/ -1, (0, i= 1,48), 1 /)
Obs.: nos dois últimos casos, todos elementos são zero, excepto o primeiro e o último. Comandos de entrada (read) e
saída (print) com arrays. Um elemento do array: como se fosse uma variável escalar. Um grupo de elementos do array:
utilizando o do implícito O array todo: apenas o nome do array

Exemplos:
Print *, (p(i), i=1,99,2), q(3), q(4), r
Read *, first, last, (arr(i), i=first, last)
Do i=1, 10
Read *, arr(i)

Matrizes (arrays multidimensionais). Fortran permite até sete dimensões para um array

matmul Produto matricial de duas matrizes, ou de uma matriz e um vetor

eclara
ção:
Semelh
ante a
vectore
s,
conside
rando o número de dimensões

Exemplos:
real, dimension(3,4) :: a
logical :: b(10,4)
integer, dimension (5:7, -10:-1) :: c
integer, dimension(5:8, 0:1, 100, -3:4) :: d

5.3.Atribuição de valores
vetor(3,2) = 1
Utilizando a função intrínseca reshape:
reshape((/ 1,2,3,4,5,6 /), (/ 2,3 /))
1 3 5
2 4 6
integer :: i, j
real, dimension(2,2) :: a
reshape((/ ((10*i+j, i=1,2), j=1,2) /), (/2,2 /))
11 12
21 22

5.4.Comando de saída (print) com arrays multidime nsionais

Se x é um array com 50 linhas e 8 colunas,

print „(8F8.2)‟, x
imprime o array x coluna por coluna
print „(8F8.2)‟, ((x(i,j), j=1,8), i= 1,50)
imprime o array x linha por linha

Funções intrínsecas para vectores e matrizes.

11
dot_product Produto escalar de dois vetores
transpose Transposta de uma matriz
maxval, minval Valor máximo e mínimo, respectivamente, de um array, ou parte deste
product, sum Produto e soma, respectivamente, de um array, ou parte deste

Ex:
matriz_b = tranpose(matriz_a)

matriz_ab = matmul(matriz_a, matriz_b)

max = maxval(matriz_c)

prod = product(vetor_d)

Exemplo: Programa que soma os valores de duas matrizes

program somamat

implicit none

integer, parameter:: lin = 3 , col = 2 !dimensões das matrizes

integer:: linha !variável controladora das linhas nos loops
real:: matriza(lin, col), matrizb(lin, col), matrizc(lin, col)
!arrays bidimensionais

print *, 'Digite os valores da matriz A: '

do linha = 1, lin !leitura dos elementos
read *, matriza(linha, 1: col) !da matriz A
end do

print *
print *, 'Digite os valores da matriz B: '
do linha = 1, lin !leitura dos elementos
read *, matrizb(linha, 1: col) !da matriz B
end do

do linha = 1, lin
matrizc(linha, 1: col) = matriza(linha, 1: col) + matrizb(linha, 1: col)
end do !formação da matriz C atraves da soma dos elementos
!das matrizes A e B
print *
print *, 'Matriz C = A + B: '
do linha = 1, lin
print '(F5.2)', matrizc(linha, 1: col) !visualização da
end do !matriz C
end program FIM

12
 6. Ficha 2: Exercícios fortran

1. Em uma escola, a média final é dada pela média aritmética de três notas. E a mesma tem o
seguinte esquema de avaliação:

Média Situação do aluno

[00-5.0[ Aluno em recuperação
[5.00-7.0[ Aluno em prova final
[7.00-10[ Aluno passado por média

Desenvolva um algoritmo que a partir da entrada das três notas mostre a situação do aluno. No
caso do aluno em recuperação e prova final, mostre também quanto o aluno irá precisar para
passar. No caso da recuperação a nota necessária para passar é dada por 10 – Média + 2 e na prova
final é dado por 10 – Média.

2. Em uma loja e CD´s existem apenas quatro tipos de preços que estão associados a
cores. Assim os CD´s que ficam na loja não são marcados por preços e sim por cores.
Desenvolva o algoritmo que a partir a entrada da cor o software mostre o preço. A loja está
actualmente com a seguinte tabela de preços.

Cor Preço
Verde 10
Azul 20
Amarelo 30
Vermelho 40

3. Desenvolva um algoritmo capaz e encontrar o menor dentre 3 números inteiros quaisquer dados
pelo teclado.

4. Desenvolva um algoritmo capaz de verificar se uns números inteiros, dados como entrada, é par
ou impar.

5. João papo-de-pescador, homem de bem, comprou um microprocessador para controlar o

rendimento diário do seu trabalho, Toda vez que ele traz um peso de peixes maior que o
estabelecido pelo regulamento de pesca da vila de Songo (50 quilos) deve pagar uma multa de
MZM 4,00 por quilo excedente, João precisa que você faça um algoritmo que leia a variável P
(peso de peixes) e verifique se há excesso. Se houver, gravar na variável E (excesso) e na variável
M o valor da multa que João deverá pagar. Caso contrário mostrar tais variáveis com o conteúdo
ZERO.

6. Elabore um algoritmo que leia as variáveis C e N respectivamente código e número de horas

trabalhadas de um operário e calcule o salário sabendo-se que ele ganha MZM 10,00 por hora.
Quando o número de horas exceder a 50 calcule o excesso e pagamento armazenando-o na

13
 variável E, caso contrário zerar tal variável. A hora excedente de trabalho vale MZM 20,00. No
final do processamento imprimir o salário total e o salário excedente.

7. A secretária de Meio Ambiente que controla o índice de poluição mantém 3 grupos que são
altamente poluentes do meio ambiente. O índice de poluição aceitável varia de 0,05 até 0,25. Se o
índice sobe para 0,3 as indústrias do 1º grupo são intimadas a suspenderem suas actividades, se o
índice crescer para 0,4 as indústrias do 1º e 2º grupo são intimadas a suspenderem suas
actividades, se o índice atingir 0,5 todos os grupos devem ser notificados a paralisarem suas
actividades. Faça um algoritmo que leia o índice de poluição medido e emita a notificação
adequada aos diferentes grupos de empresas.

14