📋

Unidade 5 Sub Rotinas

Resumo do Documento 📝
Existem quatro tipos de sub-rotinas: 🧮
Sub-rotinas
O documento explica os quatro tipos de sub-rotinas, que são blocos de instruções
que realizam tarefas específicas dentro de um algoritmo¹. As sub-rotinas podem ser
sem parâmetros, com parâmetros, sem retorno ou com retorno.

Fluxograma e Pseudocódigo
O documento mostra como representar algoritmos em fluxograma, que é um
diagrama gráfico, e em pseudocódigo, que é uma linguagem simplificada. O
documento também utiliza a ferramenta VisualG para testar os algoritmos.

📤
1. Sem parâmetros e sem retorno: 🚫📥🚫
Unidade 5 Sub Rotinas 1
 Este tipo de sub-rotina não recebe nenhum valor de entrada e não retorna
nenhum valor.

Ela é usada para executar uma tarefa específica que não requer entrada ou
saída.

graph LR
Start(Início) --> Operation{Executar uma tarefa específica}
Operation --> End(Fim)

algoritmo "SemParametrosSemRetorno"
inicio
escreval("Este é um exemplo de sub-rotina sem parâmetros e sem retorno.")
escreval("Ela é usada para executar uma tarefa específica que não requer entrada o
u saída.")
fimalgoritmo

Explicação Sem parâmetros e sem retorno

algoritmo "SemParametrosSemRetorno"

Este é o nome do algoritmo. É chamado de “SemParametrosSemRetorno”.

inicio
escreval("Este é um exemplo de sub-rotina sem parâmetros e sem retorno.")
escreval("Ela é usada para executar uma tarefa específica que não requer entra
da ou saída.")
fimalgoritmo

Este é o corpo principal do algoritmo. Ele começa imprimindo “Este é um

exemplo de sub-rotina sem parâmetros e sem retorno.” e “Ela é usada para

Unidade 5 Sub Rotinas 2

 executar uma tarefa específica que não requer entrada ou saída.”. Essas são
mensagens informativas que descrevem o propósito deste algoritmo.

📤
2. Com parâmetros e sem retorno: ✅📥🚫
Este tipo de sub-rotina recebe um ou mais valores de entrada, mas não retorna
nenhum valor.

Ela é usada para executar uma tarefa que requer entrada, mas não produz uma
saída.

graph LR
Start(Inicio) --> Input{Receber Entrada}
Input --> Operation{Executar uma tarefa}
Operation --> End(Fim)

algoritmo "ComParametrosSemRetorno"
var
entrada: inteiro
procedimento ExecutarTarefa(entrada: inteiro)
inicio
escreval("Executando uma tarefa com a entrada: ", entrada)
fimprocedimento

inicio
escreva("Digite um número: ")
leia(entrada)
ExecutarTarefa(entrada)
fimalgoritmo|

Explicação Com parâmetros e sem retorno

Unidade 5 Sub Rotinas 3

 algoritmo "ComParametrosSemRetorno"

Este é o nome do algoritmo. É chamado de “ComParametrosSemRetorno”.

var
entrada: inteiro

Aqui, estamos declarando uma variável chamada entrada do tipo inteiro.

procedimento ExecutarTarefa(entrada: inteiro)

inicio
escreval("Executando uma tarefa com a entrada: ", entrada)
fimprocedimento

Este é um procedimento chamado ExecutarTarefa que recebe um parâmetro de

entrada do tipo inteiro. O procedimento imprime "Executando uma tarefa com a
entrada: " seguido pelo valor de entrada .

inicio
escreva("Digite um número: ")
leia(entrada)
ExecutarTarefa(entrada)
fimalgoritmo

Este é o corpo principal do algoritmo. Ele começa pedindo ao usuário para

digitar um número. Em seguida, lê o valor digitado pelo usuário e armazena na
variável entrada . O procedimento ExecutarTarefa é então chamado com entrada
como parâmetro.

📤
3. Sem parâmetros e com retorno: 🚫📥✅

Unidade 5 Sub Rotinas 4

 Este tipo de sub-rotina não recebe nenhum valor de entrada, mas retorna um
valor.

Ela é usada para executar uma tarefa que produz uma saída, mas não requer
entrada.

graph LR
Start[(Início)] --> Operation{Executar uma tarefa}
Operation --> Output{Produzir Saída}
Output --> End(Fim)

algoritmo "SemParametrosComRetorno"
var
saida: inteiro
funcao ExecutarTarefa(): inteiro
inicio
retorne 42
fimfuncao

inicio
saida := ExecutarTarefa()
escreval("A saída da tarefa é: ", saida)
fimalgoritmo

Explicação Sem Parâmetros e com retorno

algoritmo "SemParametrosComRetorno"

Este é o nome do algoritmo. É chamado de “SemParametrosComRetorno”.

var
saida: inteiro

Aqui, estamos declarando uma variável chamada saida do tipo inteiro.

Unidade 5 Sub Rotinas 5

 funcao ExecutarTarefa(): inteiro
inicio
retorne 42
fimfuncao

Esta é uma função chamada ExecutarTarefa que não recebe nenhum parâmetro
de entrada, mas retorna um valor do tipo inteiro. A função retorna o número 42.

inicio
saida := ExecutarTarefa()
escreval("A saída da tarefa é: ", saida)
fimalgoritmo

Este é o corpo principal do algoritmo. Ele começa chamando a função

ExecutarTarefae armazena o resultado na variável saida . Finalmente, o
algoritmo imprime "A saída da tarefa é: " seguido pelo valor de saida .

📤
4. Com parâmetros e com retorno: ✅📥✅
Este tipo de sub-rotina recebe um ou mais valores de entrada e retorna um
valor.

Ela é usada para executar uma tarefa que requer entrada e produz uma saída.

graph LR
Start[(Início)] --> Input{Receber Entrada}
Input --> Operation{Executar uma tarefa}
Operation --> Output{Produzir Saída}
Output --> End[(Fim)]

Unidade 5 Sub Rotinas 6

 algoritmo "ComParametrosComRetorno"
var
entrada, saida: inteiro
funcao ExecutarTarefa(entrada: inteiro): inteiro
inicio
retorne entrada * 2
fimfuncao

inicio
escreva("Digite um número: ")
leia(entrada)
saida := ExecutarTarefa(entrada)
escreval("O dobro do número que você digitou é: ", saida)
fimalgoritmo

Explicaçao Com parâmetros e com retorno

algoritmo "ComParametrosComRetorno"

Este é o nome do algoritmo. É chamado de “ComParametrosComRetorno”.

var
entrada, saida: inteiro

Aqui, estamos declarando duas variáveis, entrada e saida , ambas do tipo

inteiro.

funcao ExecutarTarefa(entrada: inteiro): inteiro

inicio
retorne entrada * 2
fimfuncao

Esta é uma função chamada ExecutarTarefa que recebe um parâmetro de

entrada do tipo inteiro e retorna um valor do tipo inteiro. A função retorna o
dobro do valor de entrada.

inicio
escreva("Digite um número: ")
leia(entrada)
saida := ExecutarTarefa(entrada)
escreval("O dobro do número que você digitou é: ", saida)
fimalgoritmo

Unidade 5 Sub Rotinas 7

 Este é o corpo principal do algoritmo. Ele começa pedindo ao usuário para
digitar um número. Em seguida, lê o valor digitado pelo usuário e armazena na
variável entrada . A função ExecutarTarefa é então chamada com entrada como
parâmetro e o resultado é armazenado na variável saida . Finalmente, o
algoritmo imprime "O dobro do número que você digitou é: " seguido pelo valor
de saida .

Unidade 5 Sub Rotinas 8

 graph LR
Start[(Início)] --> Input1{Digite o primeiro número}
Input1 --> Input2{Digite o segundo número}
Input2 --> Operation1{Executar a tarefa de soma}
Operation1 --> Operation2{Executar a tarefa de subtração}
Operation2 --> Operation3{Executar a tarefa de multiplicação}
Operation3 --> Operation4{Executar a tarefa de divisão}
Operation4 --> End[(Fim)]

algoritmo "ExemploComplexo"
var
numero1, numero2: real
procedimento somar(n1, n2: real)
var s: real
inicio
s <- n1 + n2
escreval("A soma é: ", s)
fimprocedimento

procedimento subtrair(n1, n2: real)

var sb: real
inicio
sb <- n1 - n2
escreval("A subtração é: ", sb)
fimprocedimento

procedimento multiplicar(n1, n2: real)

var m: real
inicio
m <- n1 * n2
escreval("A multiplicação é: ", m)
fimprocedimento

procedimento dividir(n1, n2: real)

var d: real
inicio
se (n2 <> 0) entao
d <- n1 / n2
escreval("A divisão é: ", d)
senao
escreval("Erro! Divisão por zero.")
fimse
fimprocedimento

Unidade 5 Sub Rotinas 9

 inicio
escreva("Digite o primeiro número: ")
leia(numero1)
escreva("Digite o segundo número: ")
leia(numero2)
somar(numero1, numero2)
subtrair(numero1, numero2)
multiplicar(numero1, numero2)
dividir(numero1, numero2)
fimalgoritmo

Explicaçao

algoritmo "ExemploComplexo corrigido"

Este é o nome do algoritmo. É chamado de “ExemploComplexo corrigido”.

var
numero1, numero2: real

Aqui, estamos declarando duas variáveis, numero1 e numero2 , ambas do tipo

real.

procedimento somar(n1, n2: real)

var s: real
inicio
s <- n1 + n2
escreval("A soma é: ", s)
fimprocedimento

Este é um procedimento chamado somar que recebe dois parâmetros de

entrada do tipo real e realiza a soma deles. O resultado é armazenado na
variável s e então impresso na tela.

procedimento subtrair(n1, n2: real)

var sb: real
inicio
sb <- n1 - n2
escreval("A subtração é: ", sb)
fimprocedimento

Unidade 5 Sub Rotinas 10

 Este é um procedimento chamado subtrair que recebe dois parâmetros de
entrada do tipo real e realiza a subtração deles. O resultado é armazenado na
variável sb e então impresso na tela.

procedimento multiplicar(n1, n2: real)

var m: real
inicio
m <- n1 * n2
escreval("A multiplicação é: ", m)
fimprocedimento

Este é um procedimento chamado multiplicar que recebe dois parâmetros de

entrada do tipo real e realiza a multiplicação deles. O resultado é armazenado
na variável m e então impresso na tela.

procedimento dividir(n1, n2: real)

var d: real
inicio
se (n2 <> 0) entao
d <- n1 / n2
escreval("A divisão é: ", d)
senao
escreval("Erro! Divisão por zero.")
fimse
fimprocedimento

Este é um procedimento chamado dividir que recebe dois parâmetros de

entrada do tipo real. Ele verifica se o segundo parâmetro é zero antes de
realizar a divisão para evitar uma divisão por zero. Se o segundo parâmetro for
zero, ele imprime “Erro! Divisão por zero”. Caso contrário, realiza a divisão e
imprime o resultado.

inicio
escreva("Digite o primeiro número: ")
leia(numero1)
escreva("Digite o segundo número: ")
leia(numero2)
somar(numero1, numero2)
subtrair(numero1, numero2)
multiplicar(numero1, numero2)
dividir(numero1, numero2)
fimalgoritmo

Unidade 5 Sub Rotinas 11

 Este é o corpo principal do algoritmo. Ele começa pedindo ao usuário para
digitar dois números. Em seguida, lê os valores digitados pelo usuário e
armazena nas variáveis numero1 e numero2 . Os procedimentos somar , subtrair ,
multiplicar e dividir são então chamados com numero1 e numero2 como
parâmetros.

codigo Complexo

primeiro exemplo 😝
algoritmo "mandado para no pdf"
var
n1, n2: real

procedimento somar(n1, n2: real)

var s: real
inicio
s <- n1 + n2
escreval ("soma = " , s)
fimprocedimento

procedimento subtrair(n1, n2: real)

var sb : real
inicio
sb <- n1 - n2
escreval ("subtração = " , sb)
fimprocedimento

procedimento multiplicar(n1, n2: real)

var m: real
inicio
m <- n1 * n2
escreval ("multiplicação = " , m)
fimprocedimento

procedimento dividir(n1, n2: real)

var d: real
inicio
se (n2 = 0) entao
escreval ("impossível dividir por zero")
senao
inicio
d <-n1 / n2
escreval ("divisão = " ,d)
fim
fimse
fimprocedimento

Unidade 5 Sub Rotinas 12

 // inicio do programa principal
inicio
escreval ("digite o primeiro número")
leia(n1)

escreval ("digite o segundo número")

leia(n2)

somar(n1, n2)
subtrair(n1, n2)
multiplicar(n1, n2)
dividir(n1, n2)
fimalgoritmo

Unidade 5 Sub Rotinas 13