Draw.io - Instalador
45 |
46 |
47 |
48 |
49 |
--------------------------------------------------------------------------------
/02_logica/04_portugol.md:
--------------------------------------------------------------------------------
1 |
Portugol
2 |
3 |
4 |
5 | Portugol, também conhecido como Português estruturado, é um pseudocódigo escrito em português. Apesar de não ser uma linguagem de programação real, o Portugol nos possibilitará escrever nossos pseudocódigos obedecendo a estrutura de algoritmos. Estrutura esta a partir da qual escreveremos instruções de entrada, saída e processamento dos dados. Tais instruções representam as ações que ocorrem em um sistema real.
6 |
7 |
1.1. Estrutura Básica
8 |
9 | Um programa escrito em Portugol tem a seguinte estrutura básica:
10 |
11 | ```pseudocode
12 | programa
13 | {
14 | //Importa as Bibliotecas
15 | funcao inicio()
16 | {
17 | // Algoritmo
18 | }
19 | }
20 |
21 | ```
22 |
23 | 1. A estrutura **programa { }** indica o inicio e o fim do programa
24 | 2. A estrutura **inicio() { }**, localizada dentro da estrutura **programa { }**, é a função responsável por iniciar o programa. A maior parte dos **nossos algoritmos serão escritos dentro da função inicio()**. Todo o programa escrito em Portugol **obrigatoriamente deve ter a função inicio()**. No conteúdo: Funções em Portugol, veremos que é possível criar outras funções, além da função inicio().
25 |
26 | > ## CURIOSIDADES SOBRE O PORTUGOL
27 | >
28 | > Você sabia que o nome Portugol deriva da junção de três palavras? Pois é, o nome vem do Português, e das linguagens de programação **Algol e PascaL**, assim, **PORTU**GUÊS + AL**GO**L + PASCA**L** = **PORTUGOL**.
29 | >
30 | > **Algol** é uma linguagem de programação da qual descende o Pascal. A linguagem de programação Algol foi muita usada em *mainframes* (computadores de grande porte). E foi também uma linguagem muito importante na década de 60, época em que foi desenvolvida.
31 | >
32 | > Esta linguagem cujo nome vem de “*Algorithmic Language*” é considerada uma linguagem de programação de alto nível, sendo voltada principalmente para aplicações científicas.
33 | >
34 | > O Portugol foi criado pelos professores Antônio Carlos Nicolodi (brasileiro) e Antônio Mannso (português). Eles o desenvolveram pensando justamente em quem está começando a programar. Criaram então uma forma de ensinar programação sem que a estrutura de uma linguagem pesasse sobre os ombros da pessoa programadora iniciante.
35 |
36 |
2. Portugol Studio
37 |
38 | O **Portugol Studio** é a Interface Gráfica de Desenvolvimento de programas, ou seja, é o programa que iremos utilizar para criar e executar os nossos pseudocódigos (algoritmos) desenvolvidos em Portugol.
39 |
40 | Ao abrir o programa pela primeira vez, será exibida a janela **Dicas**. Recomendamos fortemente que você leia essas dicas em algum momento. Elas vão te ajudar a entender melhor o Portugol Studio.
41 |
42 |
43 |
44 | Para que janela **Dicas** não seja exibida todas as vezes em que você abrir o Portugol Studio, desmarque a opção **Mostrar Dicas ao Iniciar** antes de fechar a janela, conforme indicado na imagem acima pela seta amarela.
45 |
46 | Depois de fechar a janela de Dicas, será aberta a janela principal do Portugol Studio, como vemos na imagem abaixo:
47 |
48 |
49 |
50 | Vamos conhecer os principais recursos:
51 |
52 |
2.1. Árvore de Exemplos
53 |
54 | Localizada no lado direito da tela, a Árvore de exemplos oferece uma série de pseudocódigos exemplo, para complementar os seus estudos.
55 |
56 |
57 |
58 | Na raiz da árvore, há um ícone de uma lâmpada. Os exemplos ficam abaixo dela e estão organizados em pastas. Clicando em um exemplo, você vê uma descrição do exemplo e um botão para explorá-lo. Alternativamente, você pode clicar no exemplo duas vezes para ver o código do exemplo e executá-lo.
59 |
60 |
2.2. Barra de Ferramentas Principal
61 |
62 | Na parte superior da tela, temos a Barra de Ferramentas Principal, composta por 4 ícones: **Novo Arquivo, Abrir Arquivo, Ajuda e Plugins**.
63 |
64 |
65 |
66 | O ícone Plugins serve para instalar programas complementares no Portugol Studio. Durante o nosso curso não será necessário instalar plugins adicionais.
67 |
68 |
2.3. Barra de Ferramentas Inferior
69 |
70 | Na parte inferior da tela, existe uma Barra de Ferramentas com os seguintes itens:
71 |
72 | - **Dicas da Interface (F3):** Exibe a janela Dicas e troca o tema do Portugol Studio;
73 | - **Atalhos do Teclado (F11):** Exibe uma lista contendo os atalhos do Portugol;
74 | - **Relatar um Bug:** Permite enviar o relato de um bug no programa para as pessoas desenvolvedoras.
75 | - **Contribuir:** Abre a página do projeto no Github.
76 | - **Sobre (F12):** Conta um pouco mais sobre o projeto.
77 |
78 |
79 |
80 |
81 |
82 |
3. Criando o primeiro projeto
83 |
84 | Chegou o momento de criarmos o nosso primeiro código, o HelloWorld!
85 |
86 | 1. Na janela principal do Portugol Studio, clique no ícone Novo Arquivo, como mostra a imagem abaixo:
87 |
88 |
89 |
90 | 2. Observe que será criado um novo programa, com a mensagem Olá Mundo! (Hello World em Português).
91 |
92 |
93 |
94 | Antes de executarmos o código, vamos conhecer os recursos do **Editor de código do Portugol Studio**:
95 |
96 |
3.1. Barra de Ferramentas Lateral
97 |
98 | A Barra de Ferramentas Lateral é composta pelos seguintes comandos:
99 |
100 |
101 |
102 |  |
103 | Executar programa |
104 |
105 |
106 | | Executar programa linha a linha (Debug) |
107 |
108 |
109 | | Parar a execução do programa |
110 |
111 |
112 | | Salvar o programa |
113 |
114 |
115 | | Salvar o programa em outra pasta e/ou outro nome |
116 |
117 |
118 | | Abrir um programa salvo |
119 |
120 |
121 | | Abrir a ajuda |
122 |
123 |
124 |
125 |
3.2. Console
126 |
127 | No console veremos o resultado da execução do nosso código e faremos também a entrada de dados via teclado.
128 |
129 |
130 |
131 |
3.3. Painel Utiltários
132 |
133 | O Painel Utilitários é dividido em 3 partes:
134 |
135 |
136 |
137 | 1. **Painel Bibliotecas:** Contém a lista com as Bibliotecas da Linguagem Portugol, que podem ser utilizadas para adicionar novas funcionalidades ao nossos pseudocódigos.
138 | 2. **Painel Localizar:** Cria uma lista contendo todas as variáveis criadas no seu programa. Esta lista é atualizada automaticamente.
139 | 3. **Painel Inspeção:** Ao executar o programa no modo linha a linha, é possível acompanhar as mudanças de valor em cada variável, a cada nova linha executada, no Painel de Inspeção.
140 |
141 |
4. Executar o Programa
142 |
143 | Agora que já conhecemos Editor de código do Portugol Studio, vamos executar o nosso programa, clicando no ícone Executar
. O resultado você confere no **Console**.
144 |
145 |
146 |
147 | Será exibida a mensagem **Olá Mundo** no **Console**, como mostra a imagem acima.
148 |
149 | Para exibir a mensagem, foi utilizado o comando **escreva()**, que será detalhado no conteúdo: **Entrada e Saída de dados**.
150 |
151 |
152 |
153 |
5. Portugol WEB Studio
154 |
155 | Além do Portugol Studio, existe também a versão WEB da ferramenta, que pode ser acessada através do Navegador da Internet. O **Portugol WEB Studio** possui praticamente todos os recursos da versão desktop, exceto a execução passo a passo (debug).
156 |
157 | Para utilizar o **Portugol WEB Studio**, acesse o endereço: **https://portugol-webstudio.cubos.io/ide**
158 |
159 |
160 |
161 |
162 |
163 |
164 |
--------------------------------------------------------------------------------
/02_logica/05_variaveis_constantes.md:
--------------------------------------------------------------------------------
1 |
Variáveis e Constantes
2 |
3 |
4 |
5 | No Conteúdo Introdução a Programação, vimos que:
6 |
7 | **VARIÁVEL**: Uma variável é um tipo de armazenamento de dados em memória, que possui o conteúdo variável durante a execução de um algoritmo ou programa. Uma variável pode assumir vários valores diferentes ao longo da execução do programa, mas, em um determinado momento, possui apenas um valor.
8 |
9 | **CONSTANTE**: Uma constante é um tipo de armazenamento de dados em memória, que possui um valor fixo e imutável, durante a execução de um algoritmo ou programa.
10 |
11 | As Variáveis devem possuir um tipo de dado, que pode ser:
12 |
13 | 1. Numérico;
14 | 2. Literal;
15 | 3. Lógico.
16 |
17 | Toda a variável possui um **Identificador**, que representa o nome escolhido para rotular a variável.
18 |
19 | Após recapitularmos estes pontos, vamos compreender como o Portugol trabalha com as variáveis:
20 |
21 |
1. Tipos de dados em Portugol
22 |
23 | Na tabela abaixo, temos um resumo dos tipos de dados utilizados em Portugol:
24 |
25 | | Tipo de dado | Descrição | Exemplos |
26 | | ------------ | ------------------------------------------------------------ | ----------------------- |
27 | | **inteiro** | Armazena qualquer número inteiro, negativo, nulo ou positivo. | -2, -1, 0, 1, 2 |
28 | | **real** | Armazena qualquer número real, negativo, nulo ou positivo. | 2.5, 3.1 |
29 | | **caracter** | Armazena apenas um caractere alfanumérico. | 'a', 'b', 'c' |
30 | | **cadeia** | Armazena uma cadeia de caracteres alfanuméricos de qualquer tamanho. | "casa", "lógica", "123" |
31 | | **logico** | Tipo especial, que armazena apenas os valores VERDADEIRO e FALSO. | |
32 |
33 |
34 |
35 |
2. Identificadores
36 |
37 | Diferentemente das palavras do mundo real, na programação não se pode separar as palavras que fazem parte do identificador de uma variável com espaço. Ao invés disso, usa-se:
38 |
39 | - O underline (**snake_case**). **Exemplo:** *nome_da_variavel*
40 | - Uma letra maiúscula no começo de cada palavra, exceto a primeira (**camelCase**). **Exemplo:** *nomeDaVariavel*
41 |
42 | No Portugol, existem outras restrições aos identificadores de variáveis, tais como:
43 |
44 | - Não é possível começar um nome de variável com um dígito;
45 | - É possível começar um nome de variável com um underline ou uma letra;
46 | - Os identificadores não permitem que se use letras com acentos, cedilhas, tremas, crases ou caracteres especiais.
47 |
48 | |
|
**ATENÇÃO:** O identificador da variável deve expressar exatamente o seu conteúdo. Evite utilizar nomes genéricos como v1, variavel_01, entre outros.
|
49 | | ------------------------------------------------------------ | ------------------------------------------------------------ |
50 |
51 |
52 |
53 |
2.1. Palavras Reservadas
54 |
55 | Geralmente, as linguagens costumam ter palavras-chaves reservadas, que não podem ser usadas como nomes de variáveis, porque elas são parte da sintaxe da linguagem. O Portugol não é diferente e também possui a sua lista de palavras reservadas que não devem ser utilizadas para identificar variáveis. Na tabela abaixo, temos uma tabela com as principais palavras reservadas:
56 |
57 |
58 |
59 | | programa |
60 | algoritmo |
61 | inicio |
62 | funcao |
63 |
64 |
65 | | inteiro |
66 | real |
67 | caracter |
68 | const |
69 |
70 |
71 | | tipo |
72 | inicio |
73 | se |
74 | senao |
75 |
76 |
77 | | enquanto |
78 | repita |
79 | faca |
80 | e |
81 |
82 |
83 | | ou |
84 | nao |
85 | caso |
86 | ate |
87 |
88 |
89 | | funcao |
90 | leia |
91 | escreva |
92 | escolha |
93 |
94 |
95 | | para |
96 | pare |
97 | |
98 | |
99 |
100 |
101 |
102 |
103 |
3. Declaração de Variáveis
104 |
105 | Consiste na definição dos tipos, nomes (identificadores) e valores das variáveis que serão utilizadas pelo algoritmo, antes da sua utilização. Portugol utiliza **Tipagem Estática**, ou seja, a variável deve ser declarada com o tipo do dado que será armazenado. Existem 3 formas de declarar variáveis no Portugol:
106 |
107 |
3.1. Declaração de uma variável sem atribuição de valor
108 |
109 |
**Exemplo 01 - Declaração de Variáveis sem atribuição de valor:**
110 |
111 | ```pseudocode
112 | inteiro quantidade
113 | real altura
114 | caracter tipo
115 | cadeia frase
116 | logico resposta
117 | ```
118 |
119 | Quando declaramos uma variável sem valor, o valor da variável deve ser atribuído posteriormente.
120 |
121 |
3.2. Declaração de uma variável com atribuição de valor
122 |
123 |
**Exemplo 02 - Declaração de Variáveis com atribuição de valor:**
124 |
125 | ```pseudocode
126 | inteiro quantidade = 10
127 | real altura = 1.75
128 | real media = 10.0
129 | caracter letra = 'F'
130 | cadeia frase = "O dia está ensolarado!"
131 | cadeia numero = "10"
132 | logico resposta = verdadeiro
133 | ```
134 |
135 | **Observações importantes:**
136 |
137 | - Ao atribuir um valor para uma variável do tipo real, as casas decimais devem ser informadas, mesmo que seja zero;
138 | - Diferente da língua portuguesa que utiliza a virgula como separador de casas decimais, o Portugol utiliza o ponto (padrão americano);
139 | - Ao atribuir um valor para uma variável do tipo caracter, o valor deve estar entre aspas simples (apóstrofos);
140 | - Ao atribuir um valor para uma variável do tipo cadeia, o valor deve estar entre aspas duplas;
141 | - Quando adicionamos um valor numérico em uma variável do tipo cadeia, o Portugol interpretará o valor como texto e não como um numero.
142 |
143 |
3.3. Declaração de múltiplas variáveis sem valor
144 |
145 |
**Exemplo 03 - Declaração de Múltiplas Variáveis:**
146 |
147 | ```pseudocode
148 | inteiro quantidade, codigo
149 | real altura, peso, valor
150 | caracter letra, tipo
151 | cadeia frase, conteudo
152 | logico resposta, status
153 | ```
154 |
155 | Quando declaramos múltiplas variáveis sem valor, o valor destas variáveis devem ser atribuídos posteriormente.
156 |
157 |
4. Declaração de Constantes
158 |
159 | No Portugol a declaração de uma constante é bem parecida com a declaração de uma variável. Basta colocar a palavra reservada **const** antes da variável:
160 |
161 |
**Exemplo 04 - Declaração de Constantes:**
162 |
163 | ```pseudocode
164 | const inteiro quantidade = 10
165 | const real altura = 1.80
166 | const caracter tipo = 'A'
167 | const cadeia frase = "O dia está ensolarado!"
168 | const logico resposta = falso
169 | ```
170 |
171 | Quando declaramos uma constante, o valor da constante deve ser obrigatoriamente atribuído.
172 |
173 |
174 |
175 |
176 |
--------------------------------------------------------------------------------
/02_logica/06_entrada_saida.md:
--------------------------------------------------------------------------------
1 |
Entrada e Saída de dados
2 |
3 |
4 |
5 | Existem basicamente duas instruções principais em algoritmos que são o **Leia (entrada)** e o **Escreva (saída)**.
6 |
7 |
1. Escreva
8 |
9 | A instrução Escreva é utilizada para mostrar informações na tela do computador, ou seja, é um Comando de Saída de Dados em tela.
10 |
11 |
1.2. Escrevendo instruções
12 |
13 | Usa-se a instrução Escreva quando é necessário mostrar algum dado do algoritmo ou mensagem na tela do usuário. A instrução de saída de dados (escreva) será responsável pela exibição dos dados da variável, constante ou expressão na tela do computador.
14 |
15 | **Sintaxe:**
16 |
17 | ```pseudocode
18 | // Exibir na tela apenas um texto
19 | escreva("Texto")
20 |
21 | // Exibir na tela apenas uma variável ou função
22 | escreva(nome_da_variável)
23 |
24 | // Exibir na tela um texto e o valor de uma variável
25 | escreva("Texto: ", nome_da_variavel)
26 | ```
27 |
28 | Observe que é possível além de exibir um texto na tela, também é possível exibir o valor de uma variável ao lado do texto, separando o texto da variável através de uma virgula. O texto deve sempre estar sempre entre aspas. Vejamos alguns exemplos:
29 |
30 |
**Exemplo 01 - Hello World!**
31 |
32 |
**Fluxograma:**
33 |
34 |
35 |
36 | **Código no Portugol:**
37 |
38 | ```pseudocode
39 | programa
40 | {
41 |
42 | funcao inicio()
43 | {
44 | escreva("Olá Mundo")
45 | }
46 | }
47 |
48 | ```
49 |
50 |
**Resultado do Algoritmo:**
51 |
52 |
53 |
54 |
55 |
56 |
57 |
58 |
59 |
60 |
**Exemplo 02 - Exibe os dados das Variáveis na tela - Versão 01**
61 |
62 | ```pseudocode
63 | programa
64 | {
65 |
66 | funcao inicio()
67 | {
68 | inteiro numero = 10
69 | real numeroReal = 20.0
70 | cadeia frase = "Generation Brasil"
71 | caracter letra = 'a'
72 | logico resposta = verdadeiro
73 |
74 | escreva(numero)
75 | escreva(numeroReal)
76 | escreva(frase)
77 | escreva(letra)
78 | escreva(resposta)
79 |
80 | }
81 | }
82 |
83 | ```
84 |
85 |
**Resultado do Algoritmo:**
86 |
87 |
88 |
89 |
90 |
91 |
92 |
93 |
94 |
95 | Observe na imagem acima, que todas as variáveis foram exibidas em uma única linha, se tornando difícil a leitura.
96 |
97 | Vamos resolver este problema utilizando um recurso chamado **Sequências de Escape**, que são instruções inseridas geralmente no começo ou no final de um texto, para sinalizar uma interpretação alternativa de uma série de caracteres. No Portugol, **um caractere precedido por uma barra invertida \ é uma sequência de escape**. Veja a lista na tabela abaixo:
98 |
99 | | Sequência de Escape | Descrição |
100 | | :-----------------: | ------------------------------------------------------------ |
101 | | **\t** | Insere um Tab na linha, ou seja, seria o equivalente a pressionar a tecla Tab do seu teclado. |
102 | | **\n** | Pula uma linha. |
103 |
104 |
**Exemplo 03 - Exibe os dados das Variáveis na tela - Versão 02**
105 |
106 | ```pseudocode
107 | programa
108 | {
109 |
110 | funcao inicio()
111 | {
112 | inteiro numero = 10
113 | real numeroReal = 20.0
114 | cadeia frase = "Generation Brasil"
115 | caracter letra = 'a'
116 | logico resposta = verdadeiro
117 |
118 | escreva("\nO valor armazenado na Variável numero é: ", numero)
119 | escreva("\nO valor armazenado na Variável numeroReal é: ", numeroReal)
120 | escreva("\nO valor armazenado na Variável frase é: ", frase)
121 | escreva("\nO valor armazenado na Variável letra é: ", letra)
122 | escreva("\nO valor armazenado na Variável resposta é: ", resposta)
123 |
124 | }
125 | }
126 | ```
127 |
128 |
**Resultado do Algoritmo:**
129 |
130 |
131 |
132 | Observe na imagem acima, que **todas as variáveis foram exibidas uma em cada linha**, graças a **Sequência de Escape \n**. Além disso, adicionamos um texto (rótulo) ao lado de cada variável, **separando o texto da variável com uma virgula**, para identificar o conteúdo na hora de exibir na tela.
133 |
134 |
135 |
136 |
137 |
138 |
139 |
140 |
2. Leia
141 |
142 | A instrução Leia é utilizada quando se deseja obter informações do usuário por meio do teclado, ou seja, é um Comando de Entrada de Dados.
143 |
144 |
2.1. Lendo instruções
145 |
146 | Usa-se a instrução Leia, quando é necessário que o usuário digite algum dado. A instrução de entrada de dados (Leia) será responsável pela leitura e armazenamento desses dados na variável indicada.
147 |
148 | **Sintaxe:**
149 |
150 | ```pseudocode
151 | leia (nome_da_variavel);
152 | ```
153 |
154 |
**Exemplo 04 - Entrada de dados - simples**
155 |
156 |
**Fluxograma:**
157 |
158 |
159 |
160 | **Código no Portugol:**
161 |
162 | ```pseudocode
163 | programa
164 | {
165 |
166 | funcao inicio()
167 | {
168 | cadeia frase
169 |
170 | escreva("\nDigite uma frase: ")
171 | leia(frase)
172 |
173 | escreva("\nO valor armazenado na Variável frase é: " + frase)
174 | }
175 | }
176 | ```
177 |
178 |
**Resultado do Algoritmo:**
179 |
180 |
181 |
182 |
183 |
184 |
185 |
186 |
187 |
188 | Vamos atualizar o Exemplo 03 inserindo a entrada de dados:
189 |
190 |
**Exemplo 05 - Exibe os dados das Variáveis com Entrada de dados - Versão 03**
191 |
192 | ```pseudocode
193 | programa
194 | {
195 |
196 | funcao inicio()
197 | {
198 | inteiro numero
199 | real numeroReal
200 | cadeia frase
201 | caracter letra
202 | logico resposta
203 |
204 | escreva("\nDigite um numero inteiro: ")
205 | leia(numero)
206 |
207 | escreva("\nDigite um numero real: ")
208 | leia(numeroReal)
209 |
210 | escreva("\nDigite uma frase: ")
211 | leia(frase)
212 |
213 | escreva("\nDigite uma letra: ")
214 | leia(letra)
215 |
216 | escreva("\nDigite verdadeiro ou falso: ")
217 | leia(resposta)
218 |
219 | escreva("\nO valor armazenado na Variável numero é: " + numero)
220 | escreva("\nO valor armazenado na Variável numeroReal é: " + numeroReal)
221 | escreva("\nO valor armazenado na Variável frase é: " + frase)
222 | escreva("\nO valor armazenado na Variável letra é: " + letra)
223 | escreva("\nO valor armazenado na Variável resposta é: " + resposta)
224 |
225 | }
226 | }
227 | ```
228 |
229 |
**Resultado do Algoritmo:**
230 |
231 |
232 |
233 | Observe na imagem acima que:
234 |
235 | - O Portugol Studio indica que existem dados para serem digitados (seta verde);
236 | - Observe que foram solicitados a digitação dos dados nas 5 variáveis (seta amarela). Para concluir a digitação de cada um, pressione a tecla enter do seu teclado;
237 | - Observe que foi exibido na tela em cada variável exatamente o valor que foi digitado (seta azul).
238 |
239 |
240 |
241 |
242 |
243 |
244 |
245 |
3. Comentários no código
246 |
247 | A inserção de comentários no decorrer do algoritmo facilita a leitura deste por você e por outras pessoas desenvolvedoras. Os comentários são uma excelente alternativa para auxiliar nos estudos, porque ajudam a relembrar o como você implementou o seu código.
248 |
249 | **Sintaxe:**
250 |
251 | ```pseudocode
252 | // Meu Comentário
253 | ```
254 |
255 |
**Exemplo 05 - Exibe os dados das Variáveis na tela com Entrada de dados e Comentários - Versão 04**
256 |
257 | ```pseudocode
258 | programa
259 | {
260 |
261 | funcao inicio()
262 | {
263 | // Cria uma variável do tipo inteira chamada numero
264 | inteiro numero
265 |
266 | // Cria uma variável do tipo real chamada numeroReal
267 | real numeroReal
268 |
269 | // Cria uma variável do tipo cadeia chamada frase
270 | cadeia frase
271 |
272 | // Cria uma variável do tipo caracter chamada letra
273 | caracter letra
274 |
275 | // Cria uma variável do tipo logica chamada resposta
276 | logico resposta
277 |
278 | // Insere um texto (rótulo) informando o que deve ser digitado
279 | escreva("\nDigite um numero inteiro: ")
280 |
281 | // Lê (aguarda a digitação) um valor inteiro via teclado e
282 | // aramazena na variável numero
283 | leia(numero)
284 |
285 | // Insere um texto (rótulo) informando o que deve ser digitado
286 | escreva("\nDigite um numero real: ")
287 |
288 | // Lê (aguarda a digitação) um valor real via teclado e
289 | // aramazena na variável numeroReal
290 | leia(numeroReal)
291 |
292 | // Insere um texto (rótulo) informando o que deve ser digitado
293 | escreva("\nDigite uma frase: ")
294 |
295 | // Lê (aguarda a digitação) um valor do tipo cadeia via teclado e
296 | // aramazena na variável frase
297 | leia(frase)
298 |
299 | // Insere um texto (rótulo) informando o que deve ser digitado
300 | escreva("\nDigite uma letra: ")
301 |
302 | // Lê (aguarda a digitação) um valor do tipo caracter via teclado e
303 | // aramazena na variável letra
304 | leia(letra)
305 |
306 | // Insere um texto (rótulo) informando o que deve ser digitado
307 | escreva("\nDigite verdadeiro ou falso: ")
308 |
309 | // Lê (aguarda a digitação) um valor logico (Verdadeiro ou Falso) via teclado e
310 | // aramazena na variável resposta
311 | leia(resposta)
312 |
313 | // Exibe na tela o valor da armazenado na variável numero
314 | escreva("\nO valor armazenado na Variável numero é: " + numero)
315 |
316 | // Exibe na tela o valor da armazenado na variável numeroReal
317 | escreva("\nO valor armazenado na Variável numeroReal é: " + numeroReal)
318 |
319 | // Exibe na tela o valor da armazenado na variável frase
320 | escreva("\nO valor armazenado na Variável frase é: " + frase)
321 |
322 | // Exibe na tela o valor da armazenado na variável letra
323 | escreva("\nO valor armazenado na Variável letra é: " + letra)
324 |
325 | // Exibe na tela o valor da armazenado na variável resposta
326 | escreva("\nO valor armazenado na Variável resposta é: " + resposta)
327 |
328 | }
329 | }
330 |
331 | ```
332 |
333 | Observe que todas as linhas do código possuem comentários. A Execução do programa não mudou nada, porque o Portugol ignora tudo que estiver comentado.
334 |
335 |
336 |
337 |
338 |
339 |
340 |
341 |
4. Limpar o Console
342 |
343 | O comando **limpa()** tem a função de limpar todas as mensagens do exibidas no Console.
344 |
345 | **Sintaxe:**
346 |
347 | ```pseudocode
348 | limpa()
349 | ```
350 |
351 |
**Exemplo 06 - Limpar o Console**
352 |
353 | ```pseudocode
354 | programa
355 | {
356 |
357 | funcao inicio()
358 | {
359 | // Exibe a mensagem Olá Mundo!
360 | escreva("Olá Mundo")
361 |
362 | // Limpa o Console
363 | limpa()
364 |
365 | // Exibe uma nova mensagem no Console
366 | escreva("O Console está limpo!")
367 |
368 | }
369 | }
370 |
371 | ```
372 |
373 | Observe que a mensagem **Olá Mundo** foi apagada e uma nova mensagem foi exibida no seu lugar.
374 |
375 |
376 |
377 |
378 |
379 |
380 |
381 |
382 |
383 |
--------------------------------------------------------------------------------
/02_logica/07_operadores.md:
--------------------------------------------------------------------------------
1 |
Operadores
2 |
3 |
4 |
5 | Operadores são símbolos que representam atribuições, cálculos e ordem dos dados. Os Operadores são elementos funcionais, que atuam (Processamento) sobre os operandos (Entrada de dados), e produzem um determinado resultado (Saída de dados). Por exemplo, a expressão 3 + 2 relaciona dois operandos (os números 3 e 2) por meio do operador (+) que representa a operação de adição.
6 |
7 | Em relação ao tipo de dados, os Operadores são classificados como:
8 |
9 | - Operadores Aritméticos;
10 |
11 | - Operadores de Atribuição;
12 |
13 | - Operadores Relacionais.
14 |
15 | - Operadores Lógicos.
16 |
17 |
1. Operadores Aritméticos
18 |
19 | Os **Operadores Aritméticos** são um conjunto de símbolos que representam as operações básicas da matemática (Soma, Subtração e etc). Esses operadores somente poderão ser utilizados entre variáveis com os tipos de dados Numéricos Inteiros e/ou Numéricos Reais.
20 |
21 | | Operador | Operação |
22 | | -------- | --------------- |
23 | | + | Soma |
24 | | - | Subtração |
25 | | * | Multiplicação |
26 | | / | Divisão |
27 | | % | Módulo ou Resto |
28 | | ++ | Incremento |
29 | | -- | Decremento |
30 | | - Numero | Numero Negativo |
31 |
32 | Os Operadores Aritméticos obedecem às regras matemáticas comuns:
33 |
34 | - As expressões de dentro de parênteses são sempre resolvidas antes das expressões fora dos parênteses;
35 | - Quando existe um parêntese dentro de outro, a solução sempre inicia do parêntese mais interno até o mais externo (de dentro para fora);
36 | - Quando duas ou mais expressões tiverem a mesma prioridade, a solução é sempre iniciada da expressão mais à esquerda até a mais à direita.
37 |
38 | | Operador | Operação | Prioridade |
39 | | :------: | :-----------: | :--------: |
40 | | / | Divisão | 2 |
41 | | * | Multiplicação | 2 |
42 | | + | Soma | 3 |
43 | | - | Subtração | 3 |
44 |
45 |
**Exemplo 01 - Operadores Aritméticos:**
46 |
47 | ```pseudocode
48 | programa
49 | {
50 |
51 | funcao inicio()
52 | {
53 | inteiro x = 4
54 | inteiro y = 2
55 | inteiro z = 3
56 | inteiro w = -5
57 |
58 | escreva("Soma (4+2): ", (x + y))
59 | escreva("\nSoma com numero negativo (4 + (-5)): ", (x + w))
60 | escreva("\nSubtração (4-2): ", (x - y))
61 | escreva("\nMultiplicação (4*2): ", (x * y))
62 | escreva("\nDivisão (4/2): ", (x / y))
63 | escreva("\nMódulo (resto da divisão): ", (x % 2))
64 | escreva("\nMódulo (resto da divisão): ", (z % 2))
65 | escreva("\nIncrementar: ", (z ++))
66 | escreva("\nDecrementar: ", (x --))
67 | }
68 | }
69 |
70 | ```
71 |
72 |
**Resultado do Algoritmo:**
73 |
74 |
75 |
76 | Neste exemplo foram realizadas algumas operações matemáticas simples, utilizando os Operadores Matemáticos.
77 |
78 |
79 |
80 |
81 |
82 |
83 |
84 |
1.1. Operador + com cadeias
85 |
86 | O **Operador + (soma)** quando utilizado com **variáveis do tipo cadeia**, ao invés de realizar uma Operação Matemática (soma), ele realiza uma operação chamada de **Concatenação**.
87 |
88 | **Concatenação** é um termo usado em computação para designar a operação de unir o conteúdo de duas cadeias (Strings), transformando em uma única cadeia.
89 |
90 | Por exemplo, considerando as cadeias "Generation" e "Brasil" a concatenação da primeira com a segunda gera a cadeia "GenerationBrasil" (sem espaço entre as cadeias).
91 |
92 |
**Exemplo 02 - Concatenação de cadeias (Strings):**
93 |
94 | ```pseudocode
95 | programa
96 | {
97 |
98 | funcao inicio()
99 | {
100 | cadeia texto01 = "Generation"
101 | cadeia texto02 = "Brasil"
102 | cadeia texto03 = " "
103 |
104 | escreva("Concatenar texto01 e texto02: ", texto01 + texto02)
105 | escreva("\nConcatenar texto02 e texto01: ", texto02 + texto01)
106 | escreva("\nConcatenar texto01, texto03 e texto02: ", texto01 + texto03 + texto02)
107 |
108 | }
109 | }
110 | ```
111 |
112 |
**Resultado do Algoritmo:**
113 |
114 |
115 |
116 | Neste exemplo foram realizadas algumas operações de concatenação de texto, utilizando o Operador +.
117 |
118 |
119 |
120 |
121 |
122 |
123 |
124 |
2. Operadores de Atribuição
125 |
126 | Os **Operadores de Atribuição** têm como função retornar um valor atribuído de acordo com a operação indicada. A operação é feita entre os dois operandos, sendo atribuído o resultado ao primeiro.
127 |
128 | | Operador | Descrição |
129 | | -------- | ---------------------------- |
130 | | = | Atribuição simples |
131 | | += | Atribuição com soma |
132 | | -= | Atribuição com subtração |
133 | | *= | Atribuição com multiplicação |
134 | | /= | Atribuição com divisão |
135 | | %= | Atribuição com módulo |
136 |
137 |
138 |
139 |
**Exemplo 04 - Operadores de Atribuição:**
140 |
141 | ```pseudocode
142 | programa
143 | {
144 |
145 | funcao inicio()
146 | {
147 | inteiro x = 4
148 | inteiro y = 2
149 | inteiro z = 1
150 |
151 | z = y
152 | escreva("Atribuição simples (z = 2): ", z)
153 |
154 | x += y
155 | escreva("\nAtribuição com soma (4 + 2): ", x)
156 |
157 | x -= z
158 | escreva("\nAtribuição com subtração (6 - 2): ", x)
159 |
160 | x *= y
161 | escreva("\nAtribuição com multiplicação (4 * 2): ", x)
162 |
163 | x /= y
164 | escreva("\nAtribuição com divisão (8 / 2): ", x)
165 |
166 | }
167 | }
168 | ```
169 |
170 |
171 |
172 |
**Resultado do Algoritmo:**
173 |
174 |
175 |
176 | Neste exemplo foram realizadas algumas operações simples, utilizando os Operadores de Atribuição.
177 |
178 |
179 |
180 |
181 |
182 |
183 |
184 |
3. Operadores Relacionais
185 |
186 | Os **Operadores Relacionais** são utilizados para comparar valores entre variáveis e expressões do mesmo tipo e criar declarações condicionais. Esses operadores são usados com o intuito de criar expressões do tipo **verdadeiro** (TRUE) ou **falso** (FALSE), fundamentais para as declarações condicionais. O **retorno da comparação é sempre um valor do tipo Lógico**.
187 |
188 |
189 |
190 |
191 |
192 | | Operador | Descrição |
193 | | -------- | ---------------------- |
194 | | **>** | Maior do que |
195 | | **>=** | Maior do que ou igual |
196 | | **<** | Menor do que |
197 | | **<=** | Menor do que ou igual |
198 | | **==** | Igual |
199 | | **!=** | Diferente |
200 |
201 |
202 | |
| **ATENÇÃO:** Não confunda o Operador Relacional (==) com o Operador de Atribuição (=).
O Operador de Atribuição (=) tem por objetivo atribuir uma valor para uma variável.
O Operador Relacional (==) tem por objetivo checar se os valores entre duas variáveis são iguais. |
203 | | ------------------------------------------------------------ | :----------------------------------------------------------- |
204 |
205 |
206 |
207 |
**Exemplo 05 - Operadores Relacionais:**
208 |
209 | ```pseudocode
210 | programa
211 | {
212 |
213 | funcao inicio()
214 | {
215 | inteiro x = 10
216 | inteiro y = 5
217 | inteiro z = 20
218 | inteiro w = 5
219 | logico resposta
220 |
221 | resposta = x > y
222 | escreva("O valor de x é maior do que o valor de y? ", resposta)
223 |
224 | resposta = z >= y
225 | escreva("\nO valor de z é maior ou igual ao valor de y? ", resposta)
226 |
227 | resposta = x < z
228 | escreva("\nO valor de x é menor do que o valor de z? ", resposta)
229 |
230 | resposta = z <= w
231 | escreva("\nO valor de z é menor ou igual ao valor de w? ", resposta)
232 |
233 | resposta = x == z
234 | escreva("\nO valor de x é igual ao valor de z? ", resposta)
235 |
236 | resposta = z != w
237 | escreva("\nO valor de z é diferente do valor de w? ", resposta)
238 | }
239 | }
240 | ```
241 |
242 |
243 |
244 |
**Resultado do Algoritmo:**
245 |
246 |
247 |
248 | Neste exemplo foram realizadas algumas operações simples, utilizando os Operadores Relacionais.
249 |
250 |
251 |
252 |
253 |
254 |
255 |
256 |
4. Operadores lógicos
257 |
258 | Os Operadores Lógicos são utilizados para realizar comparações e validações, criando expressões condicionais complexas.
259 |
260 | Assim como podemos comparar objetos e lugares, dentro de um software também podemos comparar dados. Podemos, por exemplo, verificar se o e-mail e a senha digitados são iguais aos cadastrados no sistema, se a idade informada pelo usuário é maior ou igual a 18 anos, se um campo do formulário foi preenchido ou está vazio, entre outras tantas comparações que precisamos fazer para o bom funcionamento de uma aplicação.
261 |
262 | Esses operadores são usados com o intuito de criar expressões do tipo **verdadeiro** (TRUE) ou **falso** (FALSE), mas o seu funcionamento é um pouquinho mais complexo.
263 |
264 |
265 |
266 |
267 | | Operação Lógica | Operador | Descrição |
268 | | --------------- | :------: | ------------------------------------------------------------ |
269 | | **Conjunção** | **e** | Valida se dois dados são verdadeiros. É escrito uma letra **e** entre duas proposições. |
270 | | **Disjunção** | **ou** | Válida se um dos dois dados apresentados são verdadeiros, ou se os dois são verdadeiros. É escrito com a palavra **ou** entre as duas proposições. |
271 | | **Negação** | **nao** | Inverte o valor, o que é verdadeiro passa a ser falso, o que é falso passa a ser verdadeiro. É a negação de uma sentença. É escrito com a palavra **nao** antes da proposição. |
272 |
273 |
274 | Antes de aplicarmos os Operadores Lógicos no código, vamos compreender como funcionam estes operadores. Para simplificar o nosso aprendizado vamos fazer o uso de **proposições**, **que são frases e/ou sentenças que podem ser tomadas como verdadeiras ou falsas (premissas)**, para testar algumas validações e comparações, e assim desenvolver ainda mais nossa consciência para um desenvolvimento de uma linha de raciocínio que nos permite escrever códigos mais objetivos para atingir as nossas metas.
275 |
276 |
4.1. Proposições simples
277 |
278 | Vamos começar com proposições simples:
279 |
280 | Podemos afirmar que as seguintes frases ou sentenças são proposições:
281 |
282 | **A 🡪** *Sou participante do Bootcamp da Generation.*
283 | **B 🡪** *O Vale Refeição tem um valor diário de R$ 30,00*
284 | **C 🡪** *Chove em Guaianazes.*
285 |
286 | Todas as frases acima são proposições, pois podemos validar se se trata de uma informação verdadeira ou falsa. Por
287 | expressar um valor que pode ser confirmado ou negado.
288 |
289 | **D 🡪** *Vai estudar hoje?*
290 | **E 🡪** *Outro dia*
291 | **F 🡪** *Aquelu participante*
292 |
293 | As frases D, E e F não são proposições. Por quê?
294 |
295 | A frase **D** é uma pergunta, logo não pode ser validada por verdadeiro ou falso, para ser uma proposição precisa ser uma afirmação ou negação.
296 |
297 | As frases **E** e **F** não indicam qual é o dia e quem é a pessoa participante, respectivamente, logo não podemos validar como sendo uma sentença verdadeira ou falsa, portanto não é uma proposição.
298 |
299 |
4.1.1. Negação da Proposição
300 |
301 | Quando aplicamos a negação a uma proposição, ela deixa de ser verdadeira e se torna falsa ou deixa de ser falsa e se torna verdadeira. A negação, nega toda a ideia inicial dessa proposição.
302 |
303 | **A 🡪** *Sou participante do Bootcamp da Generation.*
304 |
305 | Essa proposição é verdadeira, caso tenha passado pelo processo seletivo da Generation e feito sua inscrição e seguido todas as orientações. Como ficaria se aplicássemos o operador não a essa proposição?
306 |
307 | **nao A 🡪** *Não sou participante do Bootcamp da Generation.*
308 |
309 | |
|
**ATENÇÃO:** Observe que foi acrescentado antes da proposição o **nao (lógico)**, para negar a proposição.
|
310 | | ------------------------------------------------------------ | ------------------------------------------------------------ |
311 |
312 |
313 |
314 | |
|
**ATENÇÃO:** Na maioria das Linguagens de Programação a negação é representada por: ! antes da variável.
|
315 | | ------------------------------------------------------------ | ------------------------------------------------------------ |
316 |
317 |
318 |
319 |
4.2. Proposições compostas
320 |
321 |
4.2.1. Conjuntiva E
322 |
323 | São proposições formadas por duas ou mais sentenças que podem ser validadas como verdadeiras ou falsas. Para as proposições compostas conjuntivas utilizaremos o operador **e (lógico)**:
324 |
325 | **Exemplo:**
326 |
327 | **G 🡪** *Chove e faz frio em SP.*
328 |
329 |
330 | Na proposição G temos duas sentenças que podem ser validadas como verdadeiras ou falsas:
331 |
332 | **Chove:** Podemos validar se é verdadeiro ou falso observando o tempo e o clima atual.
333 | **Faz frio em SP:** Podemos validar se é verdadeiro ou falso observando o tempo e o clima atual.
334 |
335 | |
|
**ATENÇÃO:** Note que entre as duas sentenças temos um conector que é o **E (lógico)**.
|
336 | | ------------------------------------------------------------ | ------------------------------------------------------------ |
337 |
338 |
339 |
340 | |
|
**ATENÇÃO:** Na maioria das Linguagens de Programação a conjunção é representada por: && entre as duas condições que serão testadas.
|
341 | | ------------------------------------------------------------ | ------------------------------------------------------------ |
342 |
343 |
344 |
345 |
4.2.2. Disjuntiva OU
346 |
347 | Para as proposições compostas disjuntivas utilizaremos o operador **ou (lógico)**:
348 |
349 | **H 🡪** *Chego tarde em casa ou pego um ônibus cheio.*
350 |
351 | **Chego tarde em casa:** Podemos avaliar se é verdadeiro ou falso, eu chego tarde em casa é uma proposição verdadeira ou falsa pra mim?
352 | **Pego um ônibus cheio:** Podemos avaliar se é verdadeiro ou falso, eu pego o ônibus cheio?
353 |
354 | |
|
**ATENÇÃO:** Note que entre as duas sentenças temos um conector que é o **OU (lógico)**.
|
355 | | ------------------------------------------------------------ | ------------------------------------------------------------ |
356 |
357 |
358 |
359 | |
|
**ATENÇÃO:** Na maioria das Linguagens de Programação a disjunção é representada por: \|\| entre as duas condições que serão testadas.
|
360 | | ------------------------------------------------------------ | ------------------------------------------------------------ |
361 |
362 |
363 |
364 | |
|
**DICA:** *Lembre-se de revisar esse conteúdo sempre que tiver dúvidas na leitura de uma condicional em seu algoritmo*
|
365 | | ------------------------------------------------------------ | ------------------------------------------------------------ |
366 |
367 |
368 |
369 |
4.3. Tabela verdade
370 |
371 | A **Tabela Verdade** é um tipo de tabela matemática, amplamente utilizada em lógica, para determinar se uma fórmula é válida. Ela nos ajuda a entender melhor como esses operadores podem agir em um algoritmo, pois eles apresentam um padrão de resposta, que nos permite já prever quais os possíveis resultados ao utilizá-los.
372 |
373 | **Orientações:**
374 |
375 | 1. Entenda A sendo uma proposição e !A a negativa de A
376 | 2. Entenda B sendo uma segunda proposição
377 | 3. Entenda V como verdadeiro
378 | 4. Entenda F como falso
379 | 5. Proposição A -> Toda pessoa desenvolvedora gosta de café
380 | 6. proposição B -> Toda pessoa desenvolvedora Java gosta de chocolate
381 |
382 |
4.3.1. Tabela Verdade da Negação
383 |
384 | | A | !A |
385 | | :--: | :--: |
386 | | V | F |
387 | | F | V |
388 |
389 |
390 | Aplicando a Tabela Verdade da Negação:
391 |
392 | - Se proposição A é verdade a sua negativa seria falsa, porque se toda pessoa desenvolvedora gosta de café,
393 | logo nenhuma pessoa deveria não gostar de café!
394 | - Se a proposição A é falsa, logo entendemos que Alguma pessoa desenvolvedora não gosta de café, pois para
395 | ser negativa a proposição A, basta uma única pessoa desenvolvedora não gostar do café.
396 |
397 | Na sequência, vamos ver um algoritmo aplicando o Operador Lógico - Negação:
398 |
399 |
**Exemplo 06 - Operadores Lógicos - Negação**
400 |
401 | ```pseudocode
402 | programa
403 | {
404 |
405 | funcao inicio()
406 | {
407 | inteiro x = 10
408 | inteiro y = 5
409 | logico proposicao_01
410 | logico proposicao_02
411 | logico resposta
412 |
413 | proposicao_01 = x > y
414 | escreva("\nA proposicao_01 é: ", proposicao_01)
415 |
416 | proposicao_02 = x < y
417 | escreva("\nA proposicao_02 é: ", proposicao_02)
418 |
419 | escreva("\n\nNegação\n")
420 |
421 | resposta = nao proposicao_01
422 | escreva("\nA Negação da proposicao_01 é: ", resposta)
423 |
424 | resposta = nao proposicao_02
425 | escreva("\nA Negação da proposicao_02 é: ", resposta)
426 |
427 | }
428 | }
429 | ```
430 |
431 |
432 |
433 |
**Resultado do Algoritmo:**
434 |
435 |
436 |
437 | Neste exemplo foram realizadas algumas operações simples, utilizando o Operador Lógico - Negação (NAO).
438 |
439 |
440 |
441 |
442 |
443 |
444 |
445 |
4.3.2. Tabela Verdade da Conjunção
446 |
447 | | A | B | A e B |
448 | | :--: | :--: | :--: |
449 | | V | V | V |
450 | | V | F | F |
451 | | F | V | F |
452 | | F | F | F |
453 |
454 | Aplicando a Tabela Verdade da Conjunção:
455 |
456 | - Se a proposição A é verdadeira e que a proposição B também seja verdadeira, o resultado da conjunção será verdadeiro. Se toda a pessoa desenvolvedora gosta de café e toda pessoa desenvolvedora Java gosta de chocolate! Não há como alguma pessoa desenvolvedora não gostar de café e nem como alguma pessoa desenvolvedora não gostar de chocolate.
457 | - Se a proposição A é verdadeira e a proposição B é falsa, o resultado da conjunção será falso, pois uma conjunção depende de duas verdades para ser verdadeira.
458 | - Se Toda pessoa desenvolvedora gosta de café e alguma pessoa desenvolvedora Java não gosta de chocolate, assumindo que a proposição A é falsa e assumindo que a proposição B também seja falsa, o resultado da conjunção será falso, pois uma conjunção depende de duas verdades para ser verdadeira.
459 | - Se Alguma pessoa desenvolvedora não gosta de café e Alguma pessoa desenvolvedora Java não gosta de
460 | chocolate a conjunção será falsa, pois uma conjunção depende de duas verdades para ser verdadeira.
461 |
462 | Na sequência, vamos ver um algoritmo aplicando o Operador Lógico - Conjunção:
463 |
464 |
465 |
466 |
**Exemplo 07 - Operadores Lógicos - Conjunção**
467 |
468 | ```pseudocode
469 | programa
470 | {
471 |
472 | funcao inicio()
473 | {
474 | inteiro x = 10
475 | inteiro y = 5
476 | logico proposicao_01
477 | logico proposicao_02
478 | logico proposicao_03
479 | logico proposicao_04
480 | logico resposta
481 |
482 | proposicao_01 = x > y
483 | escreva("\nA proposicao_01 é: ", proposicao_01)
484 |
485 | proposicao_02 = x < y
486 | escreva("\nA proposicao_02 é: ", proposicao_02)
487 |
488 | proposicao_03 = x != y
489 | escreva("\nA proposicao_03 é: ", proposicao_03)
490 |
491 | proposicao_04 = x == y
492 | escreva("\nA proposicao_04 é: ", proposicao_04)
493 |
494 | escreva("\n\nConjunção\n")
495 |
496 | resposta = proposicao_01 e proposicao_03
497 | escreva("\nA proposicao_01 e proposicao_03 são verdadeiras? ", resposta)
498 |
499 | resposta = proposicao_02 e proposicao_04
500 | escreva("\nA proposicao_02 e proposicao_04 são verdadeiras? ", resposta)
501 |
502 | resposta = proposicao_01 e proposicao_02
503 | escreva("\nA proposicao_01 e proposicao_02 são verdadeiras? ", resposta)
504 |
505 | resposta = proposicao_03 e proposicao_04
506 | escreva("\nA proposicao_03 e proposicao_04 são verdadeiras? ", resposta)
507 |
508 | }
509 | }
510 | ```
511 |
512 |
513 |
514 |
**Resultado do Algoritmo:**
515 |
516 |
517 |
518 | Neste exemplo foram realizadas algumas operações simples, utilizando o Operador Lógico - Conjunção (E).
519 |
520 |
521 |
522 |
523 |
524 |
525 |
526 |
4.3.3. Tabela Verdade da Disjunção
527 |
528 | | A | B | A e B |
529 | | :--: | :--: | :---: |
530 | | V | V | V |
531 | | V | F | V |
532 | | F | V | V |
533 | | F | F | F |
534 |
535 | Aplicando a Tabela Verdade da Disjunção:
536 |
537 | - Se a proposição A é verdadeira e assumindo que a proposição B também é verdadeira, o resultado da disjuntiva será verdadeiro. Para uma condição verdadeira da disjunção precisamos que uma de suas proposições seja verdadeira, sendo as duas verdadeiras temos um resultado verdadeiro.
538 |
539 | - Se a proposição A é verdade e assumindo que a proposição B é falsa, o resultado da disjuntiva será verdadeiro. Mesmo que uma das proposições seja falsa para a disjuntiva OU temos um resultado verdadeiro. OU (A) é verdadeiro OU (B) é verdadeiro.
540 | - Se a proposição A é falsa e assumindo que a proposição B é falsa, o resultado da disjuntiva será falso. Por não ter nenhuma proposição que valide a operação, podemos dizer que esta se torna falsa.
541 |
542 | Na sequência, vamos ver um algoritmo aplicando o Operador Lógico - Disjunção:
543 |
544 |
545 |
546 |
**Exemplo 08 - Operadores Lógicos - Disjunção**
547 |
548 | ```pseudocode
549 | programa
550 | {
551 |
552 | funcao inicio()
553 | {
554 | inteiro x = 10
555 | inteiro y = 5
556 | logico proposicao_01
557 | logico proposicao_02
558 | logico proposicao_03
559 | logico proposicao_04
560 | logico resposta
561 |
562 | proposicao_01 = x > y
563 | escreva("\nA proposicao_01 é: ", proposicao_01)
564 |
565 | proposicao_02 = x < y
566 | escreva("\nA proposicao_02 é: ", proposicao_02)
567 |
568 | proposicao_03 = x != y
569 | escreva("\nA proposicao_03 é: ", proposicao_03)
570 |
571 | proposicao_04 = x == y
572 | escreva("\nA proposicao_04 é: ", proposicao_04)
573 |
574 | escreva("\n\nDisjunção\n")
575 |
576 | resposta = proposicao_01 ou proposicao_03
577 | escreva("\nA proposicao_01 e proposicao_03 são verdadeiras? ", resposta)
578 |
579 | resposta = proposicao_01 ou proposicao_02
580 | escreva("\nA proposicao_01 e proposicao_02 são verdadeiras? ", resposta)
581 |
582 | resposta = proposicao_03 ou proposicao_04
583 | escreva("\nA proposicao_03 e proposicao_04 são verdadeiras? ", resposta)
584 |
585 | resposta = proposicao_02 ou proposicao_04
586 | escreva("\nA proposicao_02 e proposicao_04 são verdadeiras? ", resposta)
587 | }
588 | }
589 | ```
590 |
591 |
592 |
593 |
**Resultado do Algoritmo:**
594 |
595 |
596 |
597 | Neste exemplo foram realizadas algumas operações simples, utilizando o Operador Lógico - Disjunção (OU).
598 |
599 |
600 |
601 |
602 |
603 |
604 |
605 |
606 |
--------------------------------------------------------------------------------
/02_logica/08_teste_mesa.md:
--------------------------------------------------------------------------------
1 |
Teste de Mesa
2 |
3 | O Teste de mesa é uma simulação da execução de um programa passo a passo, ou seja, linha a linha, para identificar possíveis inconsistências e erros de lógica em nosso Algoritmo. Não existem regras específicas para criar um teste de mesa, mas geralmente ele é realizado de duas formas:
4 |
5 | - Manual
6 | - Automatizado
7 |
8 | Para demonstrar o Teste de Mesa, utilizaremos o código abaixo:
9 |
10 | ```pseudocode
11 | programa
12 | {
13 |
14 | funcao inicio()
15 | {
16 | inteiro n1, n2, soma, subtracao
17 |
18 | escreva("Digite o primeiro numero inteiro\n")
19 | leia(n1)
20 |
21 | escreva("Digite o segundo numero inteiro\n")
22 | leia(n2)
23 |
24 | soma = n1 + n2
25 | subtracao = n1 - n2
26 |
27 | escreva("\nA soma dos dois números é: ", soma)
28 | escreva("\nA diferença dos dois números é: ", subtracao)
29 | }
30 | }
31 | ```
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
1. Método manual
40 |
41 | Em uma tabela, na primeira linha, insere o número da linha na primeira coluna e em seguida coloca-se todas as variáveis que se deseja acompanhar o valor nas colunas seguintes.
42 |
43 | Na primeira coluna, insira as linhas onde as variáveis terão o seu valor alterado. Na segunda coluna, insira uma breve descrição da ação. Nas colunas seguintes, preencha com os valores que cada variável terá após a execução da linha, para simular a execução do programa. A tabela toda corresponde a uma execução do programa. Veja o exemplo na tabela abaixo:
44 |
45 | | Linha | Ação | n1 | n2 | soma | subtracao |
46 | | :----: | ------------------------ | :--: | :--: | :--: | :-------: |
47 | | **9** | Digitar um valor para n1 | 10 | | | |
48 | | **12** | Digitar um valor para n2 | 10 | 5 | | |
49 | | **14** | Calcular a soma | 10 | 5 | 15 | |
50 | | **15** | Calcular a subtração | 10 | 5 | 15 | 5 |
51 |
52 | Observe que no Teste de Mesa o foco são nas linhas que farão alguma modificação no valor de uma variável ou algum tipo de processamento. Veja na animação abaixo, o processo passo a passo:
53 |
54 |
55 |
56 |
57 |
58 |
2. Executar linha a linha (Debug)
59 |
60 | Toda a Linguagem de Programação possui uma ferramenta de execução linha a linha, popularmente conhecida como **Debug**, que permite executar o código linha a linha, criando um teste de mesa. No Portugol Studio temos a ferramenta Executar linha a linha. Vamos entender como esta ferramenta funciona na prática:
61 |
62 | 1. Crie um novo programa no Portugol Studio e insira o mesmo código utilizado no teste de mesa manual;
63 | 2. Arraste as variáveis que você deseja inspecionar do **Painel Localizar** para o **Painel de Inspeção**, como mostra a animação abaixo:
64 |
65 |
66 |
67 | 3. Na sequência, clique no ícone
(**Executar programa linha a linha** ), localizado na Barra de Ferramentas Lateral, do Editor de código.
68 | 4. Observe que a linha 6 será selecionada.
69 | 5. Para executar a próxima linha será preciso clicar mais 3 vezes, porquê esta linha cria 4 variáveis (1 clique para cada variável), como vemos na animação abaixo:
70 |
71 |
72 |
73 | 6. Após os 4 cliques no ícone
, No próximo clique será exibida a mensagem solicitando a digitação de um valor para a variável n1 e no próximo clique será solicitada a digitação do valor. Este processo será repetido com a variável n2, como vemos na animação abaixo:
74 |
75 |
76 |
77 | 7. Observe no **Painel de Inspeção** que:
78 |
79 | - Ao digitar um valor para a varável n1, o valor será exibido no Painel de Inspeção ao lado da variável n1;
80 | - Ao digitar um valor para a varável n2, o valor será exibido no Painel de Inspeção ao lado da variável n2;
81 |
82 | 8. Após digitar valores inteiros para as variáveis n1 e n2, nos próximos cliques no ícone
, serão executadas as operações soma e subtração, como vemos na animação abaixo:
83 |
84 |
85 |
86 | 9. Observe no **Painel de Inspeção** que:
87 |
88 | - Ao executar a operação de soma, o resultado da soma será exibido no Painel de Inspeção ao lado da variável soma;
89 | - Ao executar a operação de subtração, o resultado da subtração será exibido no Painel de Inspeção ao lado da variável subtracao.
90 |
91 | 10. Nos próximos 2 cliques, o resultado final das 2 operações serão exibidos na tela e o programa será finalizado, como podemos observar na animação acima.
92 |
93 | Através da **Execução linha a linha** é possível fazer um teste de mesa no próprio código. Este recurso é muito útil para resolver problemas em trechos de códigos que não estão funcionando corretamente ou simplesmente para entender o funcionamento de um algoritmo.
94 |
95 |
96 |
97 |
98 |
--------------------------------------------------------------------------------
/02_logica/09_lacos_condicionais.md:
--------------------------------------------------------------------------------
1 |
Laços Condicionais
2 |
3 |
4 |
5 | Os Laços Condicionais, também chamados por Estrutura de Decisão, são estruturas que ajudam na tomada de decisão utilizando de premissas informadas em seu algoritmo. Através dessa estrutura é possível realizar testes lógicos e validar ou não um ou mais dados.
6 |
7 | Os Laços Condicionais são usados para que sejam estabelecidos caminhos diferentes de instruções, a serem percorridos a partir de tomadas de decisão.
8 |
9 | Como pessoa desenvolvedora, você deverá utilizar os Laços Condicionais sempre que tiver de estruturar sequências de ações que poderão ser executadas ou não, a depender de um resultado frente a uma ou mais condições.
10 |
11 |
1. Tipos de Laços Condicionais
12 |
13 | Existem 3 estruturas de Laços Condicionais:
14 |
15 | 1. **Estrutura SE**
16 |
17 | 2. **Estrutura SE e SENAO**
18 |
19 | 3. **Estrutura Caso**
20 |
21 | A aplicação de cada uma irá depender do contexto de utilização.
22 |
23 | Vale lembrar que essas estruturas também permitem inserir, dentro dos seus blocos, a execução de:
24 |
25 | - Cálculos;
26 | - Outros Laços Condicionais;
27 | - Entre outras operações...
28 |
29 |
1.1. O Laço Condicional SE
30 |
31 | O Laço Condicional **SE** é utilizado em situações em que se faz necessário **testar uma única condição e/ou variável**, que caso seja verdadeira, irá desencadear a execução de um ou mais processamentos ou saídas de dados.
32 |
33 | **Sintaxe:**
34 |
35 | ```pseudocode
36 | se (condição)
37 | {
38 | //faça alguma coisa se a condição for verdadeira
39 | }
40 | ```
41 |
42 | Neste Laço Condicional temos basicamente um teste (condição) e um grupo de ações que só acontecerão se a resposta for verdadeira. Na imagem abaixo, temos o Fluxograma básico do Laço Condicional SE:
43 |
44 |
45 |
46 | Observe que o comando A será executado somente se a condição for verdadeira (Sim) e na sequência os comandos B e C também serão executados. Caso a condição seja falsa (Não), o fluxo do programa continua normalmente executando apenas os comandos B e C.
47 |
48 | Como exemplo prático vamos escrever um algoritmo que **valida se o valor da variável lógica X é verdadeiro**.
49 |
50 | A condição do Se esta informada dentro do conjunto de parênteses ( *condição* ), tudo que esta informado dentro do parênteses precisa ser verdadeiro para que o bloco do **SE** seja processado, caso não seja verdadeira a condição do SE, esse bloco será ignorado/ pulado no momento da execução do código.
51 |
52 |
**Exemplo 01 - Laço Condicional Condicional SE**
53 |
54 |
**Fluxograma:**
55 |
56 |
57 |
58 | **Código no Portugol:**
59 |
60 | ```pseudocode
61 | programa
62 | {
63 |
64 | funcao inicio()
65 | {
66 | logico x = verdadeiro
67 | logico y = falso
68 |
69 | se (x)
70 | {
71 | escreva ("X é verdadeiro")
72 | }
73 |
74 | se (y)
75 | {
76 | escreva ("O valor de Y é verdadeiro")
77 | }
78 | }
79 | }
80 | ```
81 | No código acima, a primeira condição: **Se o valor de x for verdadeiro** será testada. Caso esta condição seja **verdadeira**, **o bloco de comandos que está dentro das chaves { }** será executado.
82 |
83 | Na sequência, a segunda condição: **Se o valor de y for verdadeiro** será testada. Caso esta condição seja **verdadeira**, **o bloco de comandos que está dentro das chaves { }** será executado.
84 |
85 | > Na programação, as 2 chaves { } são chamadas de **escopo**.
86 |
87 | Observe que cada bloco de código da estrutura se, **tem o seu inicio e fim delimitados por 2 chaves { }**, como mostra a imagem abaixo:
88 |
89 | 
90 |
91 |
92 |
93 |
**Teste de Mesa**
94 |
95 |
96 |
97 | | Entrada |
98 | Processamento |
99 | Saída |
100 |
101 |
102 | | x = verdadeiro |
103 | se x é verdadeiro |
104 | X é verdadeiro |
105 |
106 |
107 | | y = falso |
108 | se y é falso |
109 | -- NÃO TEREMOS NENHUMA SAÍDA -- |
110 |
111 |
112 |
113 |
114 |
**Resultado do Algoritmo:**
115 |
116 | 
117 |
118 |
119 |
120 |
121 |
122 |
123 |
124 | Note que o segundo SE, **não exibiu o seu texto no console**, porque a **segunda condição SE não é verdadeira**. Observe que a variável **y** foi inicializada com o valor **falso**.
125 |
126 | |
| **DESAFIO:** *Altere o valor da variável y para verdadeiro, execute o programa novamente e veja como o programa se comporta. * |
127 | | ------------------------------------------------------------ | :----------------------------------------------------------- |
128 |
129 | Se você fez o Desafio acima, deve ter observado que cada estrutura SE do código acima é independente, ou seja, não há relação entre elas e por isso são avaliadas e executadas isoladamente.
130 |
131 | |
|
**DICA:** *Os Operadores utilizados para comparar e/ou escrever as condições da Estrutura SE estão disponíveis no conteúdo:
Operadores. Caso você tenha alguma dúvida, não deixe de rever este conteúdo!*
|
132 | | ------------------------------------------------------------ | ------------------------------------------------------------ |
133 |
134 |
135 |
136 | Vamos reescrever o exemplo 01, utilizando o Operador Lógico **NAO**, que irá negar o valor das variáveis, ou seja, Verdadeiro passará a ser Falso e vice-versa:
137 |
138 |
**Exemplo 02 - Laço Condicional Condicional SE - Versão 02**
139 |
140 |
**Fluxograma:**
141 |
142 |
143 |
144 | **Código no Portugol:**
145 |
146 | ```pseudocode
147 | programa
148 | {
149 | funcao inicio()
150 | {
151 | //declaração da variável com e atribuição do valor verdadeiro para a mesma
152 | logico x = verdadeiro
153 | logico y = falso
154 |
155 | se(nao x)
156 | {
157 | escreva ("o valor de x não é verdadeiro")
158 | }
159 |
160 | se(nao y)
161 | {
162 | escreva ("o valor de y não é verdadeiro")
163 | }
164 | }
165 | }
166 | ```
167 |
168 | No código acima, a primeira condição: **Se o valor de x não for verdadeiro** será testada. Caso esta condição seja **verdadeira, ou seja, x for falso**, **o bloco de comandos que está dentro das chaves { }** será executado.
169 |
170 | Na sequência, a segunda condição: **Se o valor de y não for verdadeiro** será testada. Caso esta condição seja **verdadeira, ou seja, x for verdadeiro o bloco de comandos que está dentro das chaves { }** será executado.
171 |
172 |
**Teste de Mesa**
173 |
174 |
175 |
176 | | Entrada |
177 | Processamento |
178 | Saída |
179 |
180 |
181 | | x = lógico |
182 | se x NÃO é verdadeiro |
183 | -- NÃO TEREMOS NENHUMA SAÍDA -- |
184 |
185 |
186 | | y = falso |
187 | se y NÃO é verdadeiro |
188 | o valor de x não é verdadeiro |
189 |
190 |
191 |
192 |
193 |
**Resultado do Algoritmo:**
194 |
195 | 
196 |
197 | Note que o operador **nao**, inverteu o resultado do **Exemplo 01**. Nesta segunda versão foi o primeiro **SE** que **não exibiu o seu texto no console**, porque a **primeira condição SE não é verdadeira**. Observe que a variável **x** foi inicializada com o valor **verdadeiro**, entretanto o operador **NAO** transformou o valor **Verdadeiro em Falso**. O mesmo aconteceu com **y** (o valor Falso se transformou em Verdadeiro).
198 |
199 |
200 |
201 |
202 |
203 |
204 |
205 | |
| **DESAFIO:** *Altere o valor da variável x para falso, execute o programa novamente e veja como o programa se comporta.* |
206 | | ------------------------------------------------------------ | :----------------------------------------------------------- |
207 |
208 | Se você fez o Desafio acima, deve ter observado que cada estrutura SE do código acima, assim como no **Exemplo 01**, é independente, ou seja, não há relação entre elas e por isso são avaliadas e executadas isoladamente.
209 |
210 | |
|
**DICA:** *Os Operadores utilizados para comparar e/ou escrever as condições da Estrutura SE estão disponíveis no conteúdo:
Operadores. Caso você tenha alguma dúvida, não deixe de rever este conteúdo!*
|
211 | | ------------------------------------------------------------ | ------------------------------------------------------------ |
212 |
213 |
214 |
215 | Vamos a mais um exemplo do Laço Condicional **SE**, desta vez utilizando os Operadores Relacionais:
216 |
217 |
**Exemplo 03 - Laço Condicional SE e os Operadores Relacionais**
218 |
219 |
**Fluxograma:**
220 |
221 |
222 |
223 | **Código no Portugol:**
224 |
225 | ```pseudocode
226 | programa
227 | {
228 | funcao inicio()
229 | {
230 | inteiro n1 = 4, n2 = 3, n3 = 4
231 |
232 | se(n1 <5)
233 | {
234 | escreva("O número 1 é menor do que 5\n")
235 | }
236 |
237 | se(n1 < n2)
238 | {
239 | escreva("O número 1 é menor do que o número 2\n")
240 | }
241 |
242 | se(n1 == n3)
243 | escreva("O número 1 e o número 3 são iguais\n")
244 |
245 | }
246 | }
247 | ```
248 |
249 | No código acima, no primeiro Laço Condicional **SE**, se o valor da variável **n1 for menor que 5**, será exibido o texto do comando **escreva()** no console. No segundo Laço Condicional SE, se o valor da variável **n1 for menor que o valor da variável n2**, será exibido o texto do comando **escreva()** no console. No terceiro Laço Condicional SE, se o valor da variável **n1 for igual ao valor da variável n3**, será exibido o texto do comando **escreva()** no console.
250 |
251 | Observe neste exemplo, que o Laço Condicional **SE** foi escrito **sem o uso das chaves (escopo) para delimitar o bloco de código**. Neste caso, o algoritmo entende que *caso a condição seja verdadeira, apenas a primeira linha após o Laço Condicional deve ser executada* e apenas essa linha é condicionada ao SE.
252 |
253 | **Sintaxe:**
254 |
255 | ```pseudocode
256 | // Laço Condicional Se com apenas uma ação - sem o escopo { }
257 |
258 | se (condição)
259 | //faça apenas uma ação se a condição for verdadeira
260 |
261 | // Laço Condicional Se com mais de uma ação - com o escopo { }
262 |
263 | se (condição)
264 | {
265 | //faça a primeira ação se a condição for verdadeira
266 | //faça a segunda ação se a condição for verdadeira
267 | }
268 | ```
269 |
270 |
271 |
272 | |
|
**DICA:** *Os Operadores utilizados para comparar e/ou escrever as condições da Estrutura SE estão disponíveis no conteúdo:
Operadores. Caso você tenha alguma dúvida, não deixe de rever este conteúdo!*
|
273 | | ------------------------------------------------------------ | ------------------------------------------------------------ |
274 |
275 |
276 |
277 |
**Teste de Mesa**
278 |
279 |
280 |
281 | | Entrada |
282 | Processamento |
283 | Saída |
284 |
285 |
286 | | n1 = 4 |
287 | se n1 < 5 |
288 | O número 1 é menos que 5 |
289 |
290 |
291 | | n1 = 4 e n2 = 3 |
292 | se n1 é menor n2 |
293 | -- NÃO TEREMOS NENHUMA SAÍDA -- |
294 |
295 |
296 | | n1 = 4 e n3 = 4 |
297 | se valor de n1 é igual ao valor do n3 |
298 | Os valores de Número1 e Número3 são iguais |
299 |
300 |
301 |
302 |
303 |
**Resultado do Algoritmo:**
304 |
305 |
306 |
307 | Observe que apenas as saídas do primeiro e do terceiro Laço Condicional SE foram exibidos no console, pois a segunda condição não é verdadeira.
308 |
309 |
310 |
311 |
312 |
313 |
314 |
315 | |
| **DESAFIO:** *Altere o valor das variáveis n1, n2 e n3, execute o programa novamente e veja como o programa se comporta.* |
316 | | ------------------------------------------------------------ | :----------------------------------------------------------- |
317 |
318 | Se você fez o Desafio acima, deve ter observado que cada estrutura SE do código acima é independente, ou seja, não há relação entre elas e por isso são avaliadas e executadas isoladamente.
319 |
320 |
321 |
322 |
Exercício Resolvido
323 |
324 | Crie um algoritmo que receba duas notas digitadas pelo usuário e calcula a média entre esses valores. **Se o valor da média for maior ou igual a 6**, o usuário receberá a seguinte mensagem no console: **Parabéns, você foi aprovade!**
325 |
326 |
**Resultado esperado do Algoritmo:**
327 |
328 |
329 |
330 | **Como resolver???**
331 |
332 | Ao resolver um algoritmo é necessário analisar o que se pede antes de começar a escrever o código. Para a analisar o algoritmo proposto, podemos separar as informações do enunciado do exercício em 3 etapas fundamentais:
333 |
334 |
335 |
336 |
337 |
338 |
**Teste de Mesa**
339 |
340 | | Quais são as entradas? | Qual é o processamento? | Qual será a saída? |
341 | | ------------------------------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
342 | | Nota1 e Nota2
(ambas digitadas pelo usuário) | 1.Cálculo de média
2.Checar Se a media é maior ou igual do que 6 | 1.Resultado do cálculo de média
2.Caso a média seja maior ou igual a 6 - escrever: Parabéns, você foi aprovade! |
343 |
344 | Veja o teste de mesa em ação na animação abaixo:
345 |
346 |
347 |
348 | Note que durante o desenvolvimento do algoritmo foi identificada a necessidade de criar mais uma variável para guardar o resultado da média e por isso já indicamos essa variável na fase 03 do nosso teste de mesa.
349 |
350 | **Código no Portugol:**
351 |
352 | ```pseudocode
353 | programa
354 | {
355 | funcao inicio()
356 | {
357 | real nota1, nota2, media
358 |
359 | escreva("Digite a primeira nota\n")
360 | leia(nota1)
361 |
362 | escreva("Digite a segunda nota\n")
363 | leia(nota2)
364 |
365 | media = (nota1+nota2)/2
366 |
367 | se(media>=6){
368 | escreva("Parabéns, você foi aprovade!")
369 | }
370 | }
371 | }
372 | ```
373 |
374 |
375 |
376 |
377 |
378 |
379 |
380 |
1.2. Laço Condicional SE e SENAO
381 |
382 | A estrutura **SE** também permite a execução de um ou mais processamentos ou saídas de dados para o caso falso (Não), através da instrução **SENAO**. A instrução **SENAO**, em conjunto com a estrutura **SE**, permite criar uma resposta caso a condição verdadeira não seja satisfeita, ou seja, uma ação para a condição falsa.
383 |
384 | **Sintaxe:**
385 |
386 | ```pseudocode
387 | se (condição)
388 | {
389 | //faça alguma coisa se a condição for verdadeira
390 | }
391 | senao
392 | {
393 | //faça alguma coisa se a condição for falsa
394 | }
395 | ```
396 |
397 | Este Laço Condicional é utilizado em situações em que se faz necessário testar uma única condição/variável, que caso seja verdadeira, irá desencadear a realização de um ou mais comandos e caso seja falsa, irá desencadear um outro grupo de ações. Temos então um teste e dois grupos de ações possíveis: um que acontecerá se a condição for verdadeira, e outro que acontecerá se a condição for falsa. Veja o Fluxograma básico desta estrutura:
398 |
399 |
400 |
401 | Observe que o comando A será executado somente se a condição for verdadeira (Sim) e na sequência o comando C também será executado. O comando B será executado somente se a condição for falsa (Não) e na sequência o comando C também será executado.
402 |
403 | Como exemplo prático vamos adicionar uma nova condição no **Exercício Resolvido**:
404 |
405 |
**Exemplo 04 - Laço Condicional SE e SENAO**
406 |
407 |
**Fluxograma:**
408 |
409 |
410 |
411 | **Código no Portugol:**
412 |
413 | ```pseudocode
414 | programa
415 | {
416 | funcao inicio()
417 | {
418 | real nota1, nota2, media
419 |
420 | escreva("Digite a primeira nota\n")
421 | leia(nota1)
422 |
423 | escreva("Digite a segunda nota\n")
424 | leia(nota2)
425 |
426 | media = (nota1+nota2)/2
427 | se(media>=6)
428 | {
429 | escreva("Parabéns, você foi aprovade!\n")
430 | }
431 | senao
432 | {
433 | escreva("Infelizmente devo informar que foi reprovade...\n")
434 | }
435 |
436 | }
437 |
438 | }
439 | ```
440 |
441 | No exemplo acima, a condição **se a média for maior ou igual a 6**, resultará na saída: **Parabéns, você foi aprovade!** **Caso essa condição não seja atendida**, o bloco onde temos o **SENÃO** será executado e resultará na saída: **Infelizmente devo informar que foi reprovade...**
442 |
443 | Observe que apenas uma das duas saídas será executada e o **SENÃO** só pode ser utilizado em um código onde previamente foi declarada a condição de um **SE**. Se a condição **media>=6 for verdadeira**, a **condição SENÃO não será executada**.
444 |
445 | Para comprovar o que foi passado aqui, faça dois testes no algoritmo acima:
446 |
447 | **I.** *Execute o algoritmo digitando notas onde o resultado da média seja menor do que 6;*
448 | **II.** *Execute novamente o algoritmo digitando notas onde o resultado da média seja maior ou igual a 6.*
449 |
450 |
**Teste de Mesa**
451 |
452 |
453 |
454 | |
455 | Entrada |
456 | Processamento |
457 | Resultado |
458 | Saída |
459 |
460 |
461 | | I |
462 | nota1 = 7 e nota2 = 9 |
463 | se media >=6 |
464 | Condição verdadeira |
465 | Parabéns, você foi aprovade! |
466 |
467 |
468 | | II |
469 | nota1 = 3 e nota2 = 4 |
470 | se media >=6 |
471 | Condição falsa |
472 | Infelizmente devo informar que foi reprovade... |
473 |
474 |
475 |
476 | > **Calculo da média I:** *(7+9)/2 => média = 8*
477 | >
478 | > **Calculo da média II:** *(3+4)/2 => média = 3.5*
479 |
480 |
**Resultado esperado do Algoritmo - Teste I:**
481 |
482 |
483 |
484 |
485 |
486 |
487 |
488 |
489 |
490 |
1.2.1. Acrescentando mais opções - SE encadeado
491 |
492 | Pode-se incluir em um algoritmo quantos "SE's" forem necessários, mas nesse caso o SENÃO será sempre uma condição que será considerada após todas as condições anteriores já terem sido descartadas por serem condições falsas. Sendo assim vamos dar sequencia no exemplo anterior acrescentando mais uma condição: **Alune em exame!**.
493 |
494 | **Condição:** *Para receber a mensagem: Alune de exame, a média deve ser igual a 5.*
495 |
496 |
497 |
498 |
**Exemplo 05 - Laço Condicional SE Encadeado**
499 |
500 |
**Fluxograma:**
501 |
502 |
503 |
504 | **Código no Portugol:**
505 |
506 | ```pseudocode
507 | programa
508 | {
509 | funcao inicio()
510 | {
511 | real nota1, nota2, media
512 |
513 | escreva("Digite a primeira nota\n")
514 | leia(nota1)
515 |
516 | escreva("Digite a segunda nota\n")
517 | leia(nota2)
518 |
519 | media = (nota1+nota2)/2
520 |
521 | se(media>=6)
522 | {
523 | escreva("Parabéns, você foi aprovade!\n")
524 | }
525 | senao se(media ==5){
526 | escreva("Alune de exame!\n")
527 | }
528 | senao
529 | {
530 | escreva("Infelizmente devo informar que foi reprovade...\n")
531 | }
532 |
533 | }
534 |
535 | }
536 | ```
537 |
538 | Observe o código acima, que ele possui 3 condições:
539 |
540 | **I.** *Se a condição **media maior ou igual a 6 for verdadeira**, será exibida a mensagem: **Parabéns, você foi aprovade!***
541 | **II.** *Se a condição: **media igual a 5** for verdadeira, será exibida a mensagem: **Alune de exame!***
542 | **III.** *Se **as duas condições anteriores forem falsas** (SENÃO), será exibida a mensagem: **Infelizmente devo informar que foi reprovado...***
543 |
544 |
**Teste de Mesa**
545 |
546 |
547 |
548 | |
549 | Entrada |
550 | Processamento |
551 | Resultado |
552 | Saída |
553 |
554 |
555 | | I |
556 | nota1 = 7 e nota2 = 9 |
557 | se media >=6 |
558 | Condição verdadeira |
559 | Parabéns, você foi aprovade! |
560 |
561 |
562 | | II |
563 | nota1 = 6 e nota2 = 4 |
564 | condição anterior falsa e se media == 5 |
565 | Condição verdadeira |
566 | Alune de exame |
567 |
568 |
569 | | III |
570 | nota1 = 3 e nota2 = 4 |
571 | |
572 | todas as anteriores falsa |
573 | Infelizmente devo informar que foi reprovade... |
574 |
575 |
576 | > **Calculo da média I:** *(7+9)/2 => média = 8*
577 | >
578 | > **Calculo da média II:** *(6+4)/2 => média = 5*
579 | >
580 | > **Calculo da média III:** *(3+4)/2 => média = 3.5*
581 |
582 |
**Resultado esperado do Algoritmo - Teste II:**
583 |
584 |
585 |
586 |
587 |
588 |
589 |
590 |
591 |
592 |
1.3. Laço Condicional ESCOLHA CASO
593 |
594 | **Escolha Caso**, também é um laço condicional, ou seja, uma estrutura de decisão, onde podemos através de premissas indicar qual ação deve-se ter conforme a opção escolhida.
595 |
596 | **Sintaxe:**
597 |
598 | ```pseudocode
599 | escolha(opcao)
600 | {
601 | caso 1:
602 | //faça alguma coisa se a condição for verdadeira
603 | pare
604 | caso 2:
605 | //faça alguma coisa se a condição for verdadeira
606 | pare
607 | caso 3:
608 | //faça alguma coisa se a condição for verdadeira
609 | pare
610 | caso contrario:
611 | // Opcional - faça alguma coisa se todas as condições forem falsas
612 | }
613 | ```
614 |
615 | O Laço Condicional **ESCOLHA CASO** representa de uma maneira mais simples o encadeamento de estruturas **SE**. É uma forma de reduzir a complexidade de várias estruturas **SE** encadeadas. O conteúdo da **variável** da cláusula **ESCOLHA** é comparado com os valores constantes das cláusulas **CASO**, e caso uma das comparações seja verdadeira, o comando associado é executado (somente esse comando). Caso nenhuma comparação seja Verdadeira, a estrutura executará a cláusula **CASO CONTRARIO**. Este laço é muito utilizado na construção de Menus de opções, onde o usuário digita uma letra ou um número para a escolher um item do Menu.
616 |
617 | É importante atentar-se que para cada caso teremos um comando **PARE**, para indicar que acabou as ações para essa opção. A única opção que não adicionaremos o **PARE**, é a opção **CASO CONTRARIO**, que só será executada caso todas as opções anteriores sejam falsas. A opção **CASO CONTRARIO** não é obrigatória.
618 |
619 |
620 |
621 | Observe que o comando A será executado somente se o Caso valor 1 for verdadeiro (Sim). O comando B será executado somente se o Caso valor 2 for verdadeiro (Sim). O comando C será executado somente se o Caso valor 1 e o Caso valor 2 forem falsos (Não)
622 |
623 | **Algumas regras importantes para instruções ESCOLHA CASO:**
624 |
625 | - Valores de caso duplicados não são permitidos.
626 | - O valor para um caso deve ser do mesmo tipo de dados que a variável na instrução escolha.
627 | - O valor para um caso deve ser uma constante ou literal. Variáveis não são permitidas.
628 | - A instrução pare é usada dentro do caso para encerrar uma sequência de instruções.
629 | - A instrução pare é opcional. Se omitido, a execução continuará no próximo caso.
630 | - A instrução caso contrario é opcional.
631 |
632 | Vamos construir no exemplo 6 um Menu com 3 opções. De acordo com o numero digitado, uma resposta diferente será exibida na tela:
633 |
634 |
**Exemplo 06 - Laço Condicional ESCOLHA CASO**
635 |
636 |
**Fluxograma:**
637 |
638 |
639 |
640 | **Código no Portugol:**
641 |
642 | ```pseudocode
643 | programa
644 | {
645 |
646 | funcao inicio()
647 | {
648 | inteiro opcao
649 |
650 | escreva("# ## ### #### ######### Menu ########## #### ### ## #\n")
651 |
652 | escreva("--Digite 1 para ver indicação de um livro--\n")
653 | escreva("--Digite 2 para ver ler uma frase motivacional--\n")
654 | escreva("--Digite 3 para receber uma indicação de música--\n")
655 | leia(opcao)
656 |
657 | escolha(opcao)
658 | {
659 | caso 1:
660 | escreva("Livro:\nO Lápis mágico de Malala")
661 | pare
662 | caso 2:
663 | escreva("Frase motivacional:\nTudo o que um sonho precisa para ser realizado \né alguém que acredite que ele possa ser realizado.")
664 | pare
665 | caso 3:
666 | escreva("Música:\nAURORA - Exist For Love.")
667 | pare
668 |
669 | }
670 |
671 | }
672 | }
673 | ```
674 |
675 | Observe no código acima, que o comando **ESCOLHA**, recebe a **variável opcao**, que receberá o numero da opção escolhida pelo usuário.
676 |
677 | Na sequência, cada um dos comandos **CASO** receberá uma das opções do menu:
678 |
679 | - Caso escolhida a opção 1 então exiba o livro
680 |
681 | - Caso escolhida a opção 2 então exiba a frase
682 | - Caso escolhida a opção 3 então exiba a música
683 |
684 | Note que temos apenas 3 opções para esse menu, mas poderíamos dar mais opções de escolha para o usuário.
685 |
686 |
**Resultado esperado do Algoritmo - Caso 01:**
687 |
688 |
689 |
690 |
691 |
692 | Vale lembrar que nesse exemplo acima, se o usuário digitar **outro numero diferente de 1, 2 ou 3**, o programa será finalizado sem retornar nada.
693 |
694 |
**Resultado esperado do Algoritmo - Opção diferente de 1, 2 ou 3:**
695 |
696 |
697 |
698 |
699 |
700 |
701 |
702 |
703 |
704 |
1.3.1. CASO CONTRARIO
705 |
706 |
707 | Para resolver o problema do processamento sem resposta, podemos reescrever o código acima adicionando a opção **CASO CONTRARIO**, que vai exibir alguma mensagem na tela ou efetuar algum processamento sempre que o usuário digitar qualquer numero diferente de 1, 2 ou 3. Esta opção funciona como uma opção padrão (default).
708 |
709 |
710 |
711 |
**Exemplo 07 - Laço Condicional ESCOLHA CASO - CASO CONTRARIO**
712 |
713 |
**Fluxograma:**
714 |
715 |
716 |
717 | **Código no Portugol:**
718 |
719 | ```pseudocode
720 | programa
721 | {
722 | funcao inicio()
723 | {
724 | inteiro opcao
725 |
726 | escreva("# ## ### #### ######### Menu ########## #### ### ## #\n")
727 |
728 | escreva("--Digite 1 para ver indicação de um livro--\n")
729 | escreva("--Digite 2 para ver ler uma frase motivacional--\n")
730 | escreva("--Digite 3 para receber uma indicação de música--\n")
731 | leia(opcao)
732 |
733 | escolha(opcao)
734 | {
735 | caso 1:
736 | escreva("Livro:\nO Lápis mágico de Malala")
737 | pare
738 | caso 2:
739 | escreva("Frase motivacional:\nTudo o que um sonho precisa para ser realizado \né alguém que acredite que ele possa ser realizado.")
740 | pare
741 | caso 3:
742 | escreva("Música:\nAURORA - Exist For Love.")
743 | pare
744 | caso contrario:
745 | escreva("Opção inválida!")
746 |
747 | }
748 |
749 | }
750 |
751 | }
752 | ```
753 |
754 | Observe no código acima, que caso a opção digitada seja diferente dos números aceitos nos casos anteriores, será exibida na tela a mensagem: **Opção inválida!**
755 |
756 | Note que no comando **CASO CONTRARIO** não utilizamos o comando **PARE**.
757 |
758 |
759 |
760 | | Entrada |
761 | Processamento |
762 | Saída |
763 |
764 |
765 | | opcao = 1 |
766 | caso 1 |
767 | Livro: O Lápis mágico de Malala |
768 |
769 |
770 | | opcao = 2 |
771 | caso 2 |
772 | Frase motivacional: Tudo o que um sonho ... |
773 |
774 |
775 | | opcao = 3 |
776 | caso 3 |
777 | Música: AURORA - Exist For Love. |
778 |
779 |
780 | | opcao = 8 |
781 | caso contrario |
782 | Opção inválida! |
783 |
784 |
785 |
786 |
**Resultado esperado do Algoritmo - CASO CONTRARIO:**
787 |
788 |
789 |
790 |
791 |
792 |
793 |
794 |
795 |
796 |
797 |
--------------------------------------------------------------------------------
/02_logica/10_lacos_repeticao.md:
--------------------------------------------------------------------------------
1 |
Laços de Repetição
2 |
3 | Laços de Repetição, também conhecidos como loops, são estruturas que permitem a repetição de um trecho de código dentro de sua estrutura, até que uma determinada condição seja satisfeita, ou infinitamente.
4 |
5 | |
|
**ATENÇÃO:** A condição infinita deve ser evitada, porque ela pode gerar o travamento do seu sistema.
|
6 | | ------------------------------------------------------------ | ------------------------------------------------------------ |
7 |
8 | Como pessoa desenvolvedora, você deverá conhecer e utilizar os Laços de Repetição sempre que tiver de estruturar sequências de ações que deverão ser executadas repetidamente. Apenas não esqueça de estabelecer uma condição para que o loop seja finalizado.
9 |
10 |
Por que utilizamos estruturas de repetição?
11 |
12 | Imagine que uma determinada sequencia de execuções/processamentos devem ser repetidos por um número N de vezes, ou ainda, até que alguma condição seja satisfeita, indicando que a repetição deve parar. Essa é a função dos Laços de Repetição.
13 |
14 |
1. Tipos de Laços de Repetição
15 |
16 | Existem 3 Laços de Repetição no Portugol:
17 |
18 | 1. **Para**
19 | 2. **Enquanto**
20 | 3. **Faça ... Enquanto**
21 |
22 | Assim como nos Laços Condicionais, a aplicação de cada uma irá depender do contexto de utilização.
23 |
24 | Vale lembrar que essas estruturas também permitem inserir dentro dos seus blocos, a execução de:
25 |
26 | - Cálculos;
27 | - Laços Condicionais;
28 | - Outros Laços de Repetição
29 | - Entre outras operações...
30 |
31 |
1.1. Para
32 |
33 | A estrutura **PARA** deve receber 3 parâmetros, sendo:
34 |
35 | 1) O **valor inicial**;
36 | 2) A **condição limite**;
37 | 3) O **contador**.
38 |
39 | **Sintaxe:**
40 |
41 | ```pseudocode
42 | para (valor inicial; condição limite; contador)
43 | {
44 | //Bloco de comandos (corpo do laço de repetição)
45 | }
46 | ```
47 |
48 | **Onde:**
49 |
50 | 1. O **valor inicial**, deve ser uma variável do tipo inteiro. Esse valor inicial pode ser 0 ou qualquer outro número para iniciar a contagem, que pode ser incremental ou decremental.
51 |
52 | 2. A **condição limite**, é a condição escrita com os Operadores Relacionais, que define o limite do valor que pode ser atingido pela nossa variável iniciada no para. Nesta expressão, temos que testar a condição. Se a condição for avaliada como verdadeira, executaremos o **corpo do laço de repetição** e **atualizaremos o valor do contador**. Caso contrário, sairemos do laço.
53 |
54 | 3. Na variável **contador**, nós podemos ter 2 situações:
55 |
56 | - Caso o contador inicie em 0, podemos somar um valor no contador até que o limite seja atingido. Para isso utilizaremos o Operador de incremento (++).
57 |
58 | - Caso o contador inicie em 10, podemos subtrair um valor no contador até que o limite seja atingido (provavelmente 0). Para isso utilizaremos o Operador de decremento (--).
59 |
60 | Na imagem abaixo, podemos visualizar o fluxograma básico do Laço de Repetição **PARA**:
61 |
62 |
63 |
64 |
65 | **Como o Laço de Repetição PARA é executado?**
66 |
67 | 1. O Laço de Repetição **PARA** é inicializado e o **valor inicial** é definido (variável inteira);
68 | 2. O fluxo salta para a **condição limite**;
69 | 3. A **condição limite** é testada;
70 | 1. Se a Condição for verdadeira, o fluxo vai para o **corpo do laço de repetição**;
71 | 2. Se a Condição for falsa, o fluxo **sai do laço**.
72 | 4. Caso a condição seja verdadeira, **as instruções dentro do corpo do laço de repetição são executadas**;
73 | 5. Após executar as operações do corpo do laço, o fluxo vai para o **contador e atualiza o seu valor** através do Operador de incremento ou decremento;
74 | 6. Na sequência, o fluxo vai para a etapa 3, testa a condição e repete o fluxo caso a condição seja verdadeira;
75 | 7. Caso a condição seja falsa, o Laço Condicional PARA é finalizado e o fluxo sai do laço.
76 |
77 | > **Fluxo** é a sequência de comandos que devem ser executados dentro do programa. Lembre-se que todo programa escrito em Portugol tem um inicio e um final, o que está entre eles é o fluxo.
78 |
79 |
**Exemplo 01 - Laço de Repetição PARA**
80 |
81 | Neste exemplo vamos criar um algoritmo que deve receber via teclado os nomes de 3 pessoas e exibir na tela.
82 |
83 | Primeiro, vamos criar uma primeira versão do código, sem utilizar o Laço de repetição. Na sequência, vamos criar a segunda versão do código, utilizando o Laço de repetição, para compararmos as 2 soluções:
84 |
85 | **Código no Portugol sem o uso do Laço de Repetição**
86 |
87 | ```pseudocode
88 | programa
89 | {
90 | funcao inicio()
91 | {
92 | cadeia nome1, nome2, nome3
93 |
94 | escreva("Digite o 1º nome\n")
95 | leia(nome1)
96 | escreva("\nO 1º nome é: ", nome1, "\n")
97 |
98 | escreva("\nDigite o 2º nome\n")
99 | leia(nome2)
100 | escreva("\nO 2º nome é: ", nome2, "\n")
101 |
102 | escreva("\nDigite o 3º nome\n")
103 | leia(nome3)
104 | escreva("\nO 3º nome é: ", nome3)
105 | }
106 |
107 | }
108 | ```
109 |
110 | Observe que nesta primeira versão do código, sem o Laço de repetição, foi necessário criar uma variável para cada nome, além dos comandos de entrada e saída, deixando o nosso código extenso e consumindo memória desnecessária com tantas variáveis.
111 |
112 |
113 |
114 |
115 |
116 |
117 |
118 | Na sequência, vamos desenvolver a segunda versão, utilizando o Laço de Repetição:
119 |
120 |
**Teste de Mesa - Versão com Laço de Repetição:**
121 |
122 |
123 |
124 | | Entrada |
125 | Processamento |
126 | Saída |
127 |
128 |
129 | | cadeia nome, contador = 1 |
130 | condição contador <= 3 |
131 | O 1º nome é: [nome digitado] |
132 |
133 |
134 | | cadeia nome, contador = 2 |
135 | condição contador <= 3 |
136 | O 2º nome é: [nome digitado] |
137 |
138 |
139 | | cadeia nome, contador = 3 |
140 | condição contador <= 3 |
141 | O 3º nome é: [nome digitado] |
142 |
143 |
144 |
145 |
**Fluxograma - Versão com Laço de Repetição:**
146 |
147 |
148 |
149 |
150 |
151 | **Código no Portugol - Versão com Laço de Repetição PARA:**
152 |
153 | ```pseudocode
154 | programa
155 | {
156 | funcao inicio()
157 | {
158 | cadeia nome
159 | para(inteiro contador =1; contador <4; contador ++)
160 | {
161 | escreva("\nDigite o ", contador, "º nome\n")
162 | leia(nome)
163 | escreva("\nO ", contador, "º nome é: ", nome, "\n")
164 | }
165 | }
166 | }
167 | ```
168 |
169 |
170 |
171 |
**Resultado do Algoritmo:**
172 |
173 |
174 |
175 | Observe que nesta segunda versão do código, com o Laço de repetição, foi necessário criar apenas uma variável para receber os nomes, além de reduzir os comandos de entrada e saída, deixando o nosso código mais simples.
176 |
177 |
178 |
179 |
180 |
181 |
182 |
183 | Ao executar os dois códigos acima, veremos que ambos estão realizando a mesma operação:
184 |
185 | - Lê os 3 nomes via teclado;
186 |
187 | - Exibe os 3 nomes na tela.
188 |
189 | Comparando as 2 versões, Imagine se precisássemos escrever um algoritmo que receberá 30 nomes?, ou 120 nomes? Você acredita que seria viável utilizar o modelo sem o Laço de Repetição?
190 |
191 | Sempre que pudermos utilizar os recursos da linguagem, que evitam caminhos mais longos e códigos extensos, devemos avaliar e aplicar essas soluções, afinal é muito mais simples você ler um código com 15 linhas, do que ler um código com 600 linhas.
192 |
193 | Observe no código acima, escrito com o Laço de Repetição, que:
194 |
195 | 1. A **variável contador, foi inicializada com o valor 1**.
196 | 2. A condição **enquanto contador for menor do que 4** é a **condição** que será testada para definir se o fluxo continua o processamento do corpo do laço de repetição, ou sai do laço.
197 | 3. A operação incremental, **somar mais 1 ao valor anterior do contador**, sempre será executada depois que a condição for validada, mas note que antes ele executa todo o bloco do Laço de Repetição **PARA**.
198 |
199 | Vale lembrar que na instrução **contador ++**, o **++** é o Operador de incremento, que soma 1 ao valor da variável, ou seja, é o mesmo que escrevermos **contador = contador + 1**, ou **contador +=1**.
200 |
201 | |
|
**DICA:** *Os Operadores utilizados para comparar e/ou escrever as condições do Laço de Repetição PARA estão disponíveis no conteúdo:
Operadores. Caso você tenha alguma dúvida, não deixe de rever este conteúdo!*
|
202 | | ------------------------------------------------------------ | ------------------------------------------------------------ |
203 |
204 | Dentro do bloco **PARA**, temos as instruções que devem ser repetidas, enquanto a nossa condição (**contador < 4**) for verdadeira. Observe que o **corpo do laço de repetição** é um **bloco de comandos escritos dentro das chaves { }**.
205 |
206 | > Na programação, as 2 chaves { } são chamadas de **escopo**.
207 |
208 | Observe que o bloco de código do Laço de Repetição **PARA**, **tem o seu inicio e fim delimitados por 2 chaves { }**, como mostra a imagem abaixo:
209 |
210 |
211 |
212 |
213 |
214 | Quando a condição (**contador < 4**) deixará de ser verdadeira?
215 |
216 | *A condição deixará de ser verdadeira a partir do momento que o valor da variável contador for igual a 4.*
217 |
218 | |
| **DESAFIO:** *Altere a condição contador < 4 para contador < 6, execute o programa novamente e veja como o programa se comporta.* |
219 | | ------------------------------------------------------------ | :----------------------------------------------------------- |
220 |
221 | Se você fez o desafio, observará que **ao invés de pedir 3 nomes, serão solicitados 5 nomes**.
222 |
223 | Vamos escrever outro exemplo com o Laço de Repetição **PARA**.
224 |
225 |
**Exemplo 02 - Laço de Repetição PARA - Tabuada**
226 |
227 | Neste exemplo, vamos construir um Algoritmo que recebe um numero inteiro via teclado e exibe na tela a tabuada deste numero.
228 |
229 |
**Fluxograma:**
230 |
231 |
232 |
233 |
**Teste de Mesa**
234 |
235 | | Entrada | Processamento | Saída |
236 | | ------------------------- | ------------------------------ | ---------------------- |
237 | | numero = 5 | | |
238 | | numero = 5, contador = 1 | contador é menor ou igual a 10 | numero * contador = 5 |
239 | | numero = 5, contador = 2 | contador é menor ou igual a 10 | numero * contador = 10 |
240 | | numero = 5, contador = 3 | contador é menor ou igual a 10 | numero * contador = 15 |
241 | | numero = 5, contador = 4 | contador é menor ou igual a 10 | numero * contador = 20 |
242 | | numero = 5, contador = 5 | contador é menor ou igual a 10 | numero * contador = 25 |
243 | | numero = 5, contador = 6 | contador é menor ou igual a 10 | numero * contador = 30 |
244 | | numero = 5, contador = 7 | contador é menor ou igual a 10 | numero * contador = 35 |
245 | | numero = 5, contador = 8 | contador é menor ou igual a 10 | numero * contador = 40 |
246 | | numero = 5, contador = 9 | contador é menor ou igual a 10 | numero * contador = 45 |
247 | | numero = 5, contador = 10 | contador é menor ou igual a 10 | numero * contador = 50 |
248 |
249 | **Código no Portugol**
250 |
251 | ```pseudocode
252 | programa
253 | {
254 |
255 | funcao inicio()
256 | {
257 | inteiro numero
258 |
259 | escreva("Digite a Tabuada que você deseja calcular: \n")
260 | leia(numero)
261 |
262 | para(inteiro contador=1; contador<=10; contador++)
263 | {
264 |
265 | escreva("\n", numero, " x ", contador, " = ", numero * contador)
266 |
267 | }
268 |
269 | }
270 | }
271 | ```
272 |
273 |
**Resultado do Algoritmo:**
274 |
275 |
276 |
277 | Observe no código acima, que para calcular a tabuada **multiplicamos o numero digitado pelo contador**. A **variável X (variável contadora), foi inicializada com o valor 1**. A condição que será testada é **enquanto X for menor ou igual 10** (Tabuada inicia em 1 e termina em 10). A operação incremental **somar mais 1 ao valor anterior de X** é o nosso **contador**.
278 |
279 |
280 |
281 |
282 |
283 |
284 |
285 |
2. ENQUANTO
286 |
287 | **ENQUANTO** é um Laço de Repetição, geralmente utilizado quando não conhecemos o valor final da condição dessa repetição.
288 |
289 | **Sintaxe:**
290 |
291 | ```pseudocode
292 | enquanto (condição limite)
293 | {
294 | //Bloco de comandos (corpo do laço de repetição)
295 | }
296 | ```
297 |
298 | O Laço de Repetição **ENQUANTO** permite que o código seja executado repetidamente com base em uma determinada condição booleana. Ele pode ser considerado uma instrução **SE** de repetição. Observe que diferente do Laço de Repetição **PARA**, o laço **ENQUANTO** possui apenas a **condição limite**. Na imagem abaixo, podemos visualizar o fluxograma básico do Laço de Repetição **ENQUANTO**:
299 |
300 |
301 |
302 | |
|
**ALERTA DE BSM:** *Mantenha a Atenção aos Detalhes. Os exemplos apresentados com o Laço PARA, também podem ser resolvidos com o Laço ENQUANTO. O inverso não é verdadeiro, porque a maioria dos casos resolvidos com o Laço ENQUANTO não podem ser resolvidos com o Laço PARA.*
|
303 | | ------------------------------------------------------------ | ------------------------------------------------------------ |
304 |
305 |
306 |
307 |
**Exemplo 03 - Laço de Repetição ENQUANTO**
308 |
309 | Escreva um algoritmo que leia dois valores via teclado e efetue a soma dos dois valores. O algoritmo deve exibir na tela o resultado da soma e perguntar se deseja realizar uma nova soma com outros 2 números. Este processo deve ser repetido até que o usuário digite a letra '**n**' na resposta da pergunta acima, indicando que não deseja mais realizar novos cálculos.
310 |
311 |
**Fluxograma:**
312 |
313 |
314 |
315 |
**Teste de Mesa**
316 |
317 |
318 |
319 | | Entrada |
320 | Condição |
321 | Processamento |
322 | Saída |
323 |
324 |
325 | inteiro N1, N2,Resultado
caracter continua = 's' |
326 | continua != 'n' |
327 | Leia o valor de n1
Leia o valor de n2
resultado = n1+n2 |
328 | Exibir resultado
Leia continua |
329 |
330 |
331 | **Código no Portugol**
332 |
333 | ```pseudocode
334 | programa
335 | {
336 | funcao inicio()
337 | {
338 | caracter continua = 's'
339 | inteiro numero1, numero2, resultado
340 |
341 | enquanto(continua != 'n')
342 | {
343 | escreva("\nDigite primeiro valor: ")
344 | leia(numero1)
345 | escreva("\nDigite segundo valor: ")
346 | leia(numero2)
347 |
348 | resultado = numero1 + numero2
349 |
350 | escreva("\nO resultado da soma é: ", resultado)
351 |
352 | escreva("\n++++++++++++++++MENU++++++++++++++++++\n")
353 | escreva("\nDeseja somar dois valores?")
354 | escreva("\nDigite S para sim OU digite N para não: ")
355 | leia(continua)
356 | escreva("++++++++++++++++++++++++++++++++++\n")
357 | }
358 | }
359 | }
360 | ```
361 |
362 |
**Resultado do Algoritmo:**
363 |
364 | 
365 |
366 | Observe que criamos e inicializamos a variável continua fora do Laço de Repetição **ENQUANTO**, para criar a condição de saída do laço, diferente do Laço de Repetição **PARA**, onde a variável foi criada no próprio laço. Isso nos permite, por exemplo, iniciar a nossa variável um valor ou ler via teclado um valor que indicará quando a repetição deve parar.
367 |
368 | Também é possível utilizar essa estrutura para executar por N vezes a repetição, semelhante ao Laço de Repetição **PARA**.
369 |
370 |
Exercício Resolvido
371 |
372 | Escreva um algoritmo que leia 3 números via teclado, multiplique cada numero por 3 e mostre na tela o resultado de cada cálculo.
373 |
374 |
**Resultado esperado do Algoritmo:**
375 |
376 |
377 |
378 | **Como resolver???**
379 |
380 | Ao resolver um algoritmo é necessário analisar o que se pede antes de começar a escrever o código. Para a analisar o algoritmo proposto, podemos separar as informações do enunciado do exercício em 4 etapas fundamentais:
381 |
382 | 1. **Entrada**
383 | 2. **Condição**
384 | 3. **Processamento**
385 | 4. **Saída**
386 |
387 |
388 |
389 |
**Teste de Mesa**
390 |
391 | | Quais são as entradas? | Qual é a condição? | Qual é o processamento? | Qual será a saída? |
392 | | ------------------------ | -------------------------------- | -------------------------- | --------------------------------------- |
393 | | Numero
Contador = 1 | Contador deve ser menor do que 4 | 1.Cálculo da multiplicação | 1.Resultado do cálculo da multiplicação |
394 |
395 | Veja o código sendo executado passo a passo na animação abaixo:
396 |
397 |
398 |
399 |
400 |
401 | |
|
**DICA:** *Caso você tenha alguma dívida sobre a opção Executar o código Passo a passo do Portugol Studio, consulte o conteúdo:
Teste de Mesa.*
|
402 | | ------------------------------------------------------------ | ------------------------------------------------------------ |
403 |
404 |
405 |
406 | **Código no Portugol:**
407 |
408 | ```pseudocode
409 | programa
410 | {
411 | funcao inicio()
412 | {
413 | inteiro contador =1 , resultado, numero
414 |
415 | enquanto(contador<4)
416 | {
417 | escreva("\nDigite o ", contador, "º número:\n")
418 | leia(numero)
419 |
420 | resultado = numero * 3
421 | escreva("\n", numero, " x 3 = ", resultado)
422 | escreva("\n++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n")
423 |
424 | contador ++
425 | }
426 | escreva("\t\t_________Fim do programa_________")
427 | }
428 | }
429 | ```
430 |
431 | Observe que na declaração das variáveis, inicializamos a variável **contador** com o **valor 1**. Essa variável é equivalente ao **contador** do laço **PARA**. Como não temos o item contador dentro da instrução **enquanto**, precisamos atender essa necessidade fora dela, para que o nosso algoritmo consiga identificar a quantidade de repetições e parar dentro da condição indicada. É importante reforçar que o valor do contador pode ser iniciado com qualquer número inteiro, conforme a necessidade do seu algoritmo.
432 |
433 | Note que dentro da instrução **enquanto** estamos definindo a seguinte condição: **enquanto o contador for menor do que 4, continue lendo valores via teclado e multiplicando cada valor por 3**, ou seja, a repetição acontecerá enquanto o contador possuir os valores 1, 2 ou 3.
434 |
435 | Observe que dentro do bloco do laço **ENQUANTO**, após as ações de leitura do número e do cálculo da multiplicação, foi incluído o incremento da variável contador (**contador ++**), para controlar o numero de vezes que o laço deve ser repetido.
436 |
437 |
438 |
439 |
440 |
441 |
442 |
443 |
1.3. Faça ... Enquanto
444 |
445 | Todos nós já tivemos uma pessoa próxima que primeiro faz e depois pergunta, correto. Essa pessoa é o **FAÇA ENQUANTO**, ele executa ao menos uma vez o código, isso porque ele primeiro executa o laço a primeira vez e depois verifica a condição.
446 |
447 | **Sintaxe:**
448 |
449 | ```pseudocode
450 | faca
451 | {
452 | //Bloco de comandos (corpo do laço de repetição)
453 | }enquanto (condição limite)
454 | ```
455 |
456 | Observe na Sintaxe do laço, que comparando com os outros Laços de Repetição, o **FAÇA ENQUANTO** possui a estrutura invertida.
457 |
458 | Para entendermos melhor essa diferença, vamos escrever um algoritmo com o laço **ENQUANTO** e na sequência vamos reescrever o mesmo algoritmo com o laço **FACA ENQUANTO**, para visualizar as diferenças entre os comportamentos dos dois laços.
459 |
460 |
461 |
462 |
**Exemplo 04 - Laço de Repetição FACA...ENQUANTO**
463 |
464 | Escreva um algoritmo que leia um numero via teclado e multiplica ele por 5, até o contador atingir o valor limite menor ou igual a 2, iniciando o nosso contador em 3.
465 |
466 |
**Fluxograma:**
467 |
468 |
469 |
470 |
**Teste de Mesa**
471 |
472 | | Quais são as entradas? | Qual é a condição? | Qual é o processamento? | Qual será a saída? |
473 | | --------------------------------------- | ------------------------------------ | -------------------------- | --------------------------------------- |
474 | | inteiro contador = 3, numero, resultado | Contador deve ser menor ou igual a 3 | 1.Cálculo da multiplicação | 1.Resultado do cálculo da multiplicação |
475 |
476 | **Código no Portugol - Laço de Repetição ENQUANTO**
477 |
478 |
479 | ```pseudocode
480 | programa
481 | {
482 | funcao inicio()
483 | {
484 | inteiro contador = 3, numero, resultado
485 |
486 | enquanto(contador<=2)
487 | {
488 | escreva("\nDigite um número inteiro: ")
489 | leia(numero)
490 | resultado = numero*5
491 | escreva("\nO resultado da multiplicação é: ", resultado)
492 | }
493 | }
494 | }
495 | ```
496 |
497 |
**Resultado esperado do Algoritmo:**
498 |
499 |
500 |
501 | Observe que o código acima irá falhar! Por um simples motivo: a variável contador é maior do que 2. Logo o Laço não será executado.
502 |
503 |
504 |
505 |
506 |
507 |
508 |
509 | **Código no Portugol - Laço de Repetição FACA...ENQUANTO**
510 |
511 | ```pseudocode
512 | programa
513 | {
514 | funcao inicio()
515 | {
516 | inteiro contador = 3, numero, resultado
517 | faca
518 | {
519 | escreva("\nDigite um número inteiro: ")
520 | leia(numero)
521 | resultado = numero*5
522 | escreva("\nO resultado da multiplicação é: ", resultado)
523 | }enquanto(contador<=2)
524 | }
525 | }
526 | ```
527 |
**Resultado esperado do Algoritmo:**
528 |
529 |
530 |
531 | Ao executar o código acima, teremos o bloco de código dentro do laço **FACA**, que será executado pelo menos uma vez, mesmo que o valor da condição seja falsa. Essa estrutura é válida quando precisamos gerar um processamento ou uma saída na tela pelo menos uma vez, antes de testar a condição. Após executar o laço uma vez, a condição da instrução **enquanto** será validada.
532 |
533 | Um exemplo prático do mundo real, seria escrever um algoritmo que possua um formulário contendo o campo telefone, que deve ser exibido ao menos uma vez, mas ainda assim podemos repetir mais campos de telefone caso o usuário queira registrar mais de um número de telefone.
534 |
535 |
536 |
537 |
538 |
539 |
540 |
541 | |
|
**ALERTA DE BSM:** *Mantenha a Orientação ao Futuro. Realizar a prática dos exercícios aqui apresentados vai tornar seu aprendizado ainda mais assertivo. Não deixe de praticar e experimentar fazer mudanças nos parâmetros dos exemplos, para compreender o funcionamento dos Laços de Repetição.**
|
542 | | ------------------------------------------------------------ | ------------------------------------------------------------ |
543 |
544 |
545 |
546 |
547 |
--------------------------------------------------------------------------------
/02_logica/11_vetores_matrizes.md:
--------------------------------------------------------------------------------
1 |
Vetores e Matrizes
2 |
3 |
4 |
5 |
1. Vetores
6 |
7 | Os vetores são estruturas de dados que permitem o acesso a uma grande quantidade de dados em memória usando-se somente um nome de variável. Esta variável especial é declarada de tal maneira que o programador passa a ter acesso à muitas posições de memória, de maneira controlada.
8 |
9 | Um vetor sempre será composto por elementos do mesmo tipo (cadeia, inteiro, real, entre outros), que podem ser referenciados como um todo. Ao declararmos um vetor, estamos reservando na memória principal do computador uma série de células para uso da variável daquele tipo. O nome do vetor aponta para a base das células e o seu início dá a posição relativa do elemento referenciado ao primeiro (base). Para identificar os elementos do vetor utilizaremos o **índice**.
10 |
11 |
12 |
13 | No exemplo acima, temos um vetor com **5 posições alocadas na memória**. Observe que o **índice inicia em 0**. Os dados ficam alocados em cada posição de memória.
14 |
15 | Os vetores podem ser **unidimensionais** ou **multidimensionais** (matrizes). Um vetor unidimensional, como uma lista de notas dos alunos de uma turma, por exemplo, tem apenas um índice.
16 |
17 | **Sintaxe:**
18 |
19 | ```pseudocode
20 | [tipo do vetor] identificador_do_vetor[tamanho] = {valores separados por virgula}
21 | ```
22 |
23 |
1.1. Tipo do vetor
24 |
25 | Este parâmetro define o tipo de dado que será armazenado no vetor. Assim como uma variável, o tipo do vetor pode ser: *inteiro, real, cadeia, caractere ou logico*.
26 |
27 |
1.2. Identificador do vetor
28 |
29 | O nome do vetor é o identificador do vetor, assim como fazemos com as variáveis. O nome do vetor segue as mesmas regras que utilizamos para os nomes de variáveis:
30 |
31 | - Não se pode separar as palavras que fazem parte do nome de um vetor com espaço. Ao invés disso, usa-se:
32 | - O underline (**snake_case**). **Exemplo:** *nome_da_variavel*
33 | - Uma letra maiúscula no começo de cada palavra, exceto a primeira (**camelCase**). **Exemplo:** *nomeDaVariavel*
34 | - O nome do vetor não pode ser iniciado com um dígito;
35 | - O nome do vetor pode ser iniciado com um underline ou uma letra;
36 | - O nome do vetor não pode conter letras com acentos, cedilhas, tremas, crases ou caracteres especiais;
37 | - Não utilize as palavras reservadas do Portugol no nome do vetor.
38 |
39 |
40 | |
|
**ATENÇÃO:** O nome do vetor deve expressar exatamente o seu conteúdo. Evite utilizar nomes genéricos como vetor1, vetor_01, entre outros.
|
41 | | ------------------------------------------------------------ | ------------------------------------------------------------ |
42 |
43 |
44 |
45 |
1.3. Declarando vetores
46 |
47 | Vamos entender como declarar um vetor:
48 |
49 | **Exemplo 01 - Vetor com dados do tipo inteiro**
50 |
51 | ```pseudocode
52 | inteiro vetorInteiros[5] = {10, 15, 35, 70, 140}
53 | ```
54 |
55 |
56 |
57 | Na imagem acima, vemos a alocação de memória para o vetor de números inteiros. Observe que cada valor está em uma posição do vetor.
58 |
59 | **Exemplo 02 - Vetor com dados do tipo cadeia**
60 |
61 | ```pseudocode
62 | cadeia vetorCadeias[5] = {"Boxer", "Pastor Alemão", "Pinscher", "Husky Siberiano", "Corgi"}
63 | ```
64 |
65 |
66 |
67 | Na imagem acima, vemos a alocação de memória para o vetor composto por cadeias de caracteres. Observe que cada cadeia está em uma posição do vetor.
68 |
69 | **Exemplo 03 - Vetor vazio**
70 |
71 | ```pseudocode
72 | real vetorReal[5]
73 | ```
74 |
75 |
76 |
77 | Na imagem acima, vemos a alocação de memória para um vetor do tipo Real, vazio. Observe que todas as posições do vetor estão vazias. Neste caso, para inserir dados no vetor seria necessário utilizar o **comando de entrada leia()** para inserir dados no vetor.
78 |
79 |
1.4. Acessar uma posição do vetor
80 |
81 | Para acessar os dados armazenados em uma posição do vetor utilizaremos o **nome do vetor seguido por colchetes**. Dentro dos colchetes, informaremos o **índice do vetor**, ou seja, a posição que desejamos obter os dados armazenados.
82 |
83 | **Sintaxe:**
84 |
85 | ```pseudocode
86 | nome_do_vetor[indice]
87 | ```
88 |
89 |
**Exemplo 04 - Exibindo os dados do vetor**
90 |
91 | ```pseudocode
92 | programa
93 | {
94 |
95 | funcao inicio()
96 | {
97 |
98 | inteiro vetorInteiros[5] = {10, 20, 30, 40, 50}
99 |
100 | escreva("1º Numero: ", vetorInteiros[0], "\n")
101 | escreva("2º Numero: ", vetorInteiros[1], "\n")
102 | escreva("3º Numero: ", vetorInteiros[2], "\n")
103 | escreva("4º Numero: ", vetorInteiros[3], "\n")
104 | escreva("5º Numero: ", vetorInteiros[4], "\n")
105 |
106 | }
107 | }
108 | ```
109 |
110 |
**Resultado do Algoritmo:**
111 |
112 |
113 |
114 | Neste exemplo, os dados do vetor foram exibidos na tela acessando posição por posição.
115 |
116 |
117 |
118 |
119 |
120 |
121 |
122 | Será que existe uma forma mais simples de construirmos este Algoritmo?
123 |
124 | Observe que o índice é uma sequência numérica e o comando escreva é repetido por 5 vezes com o mesmo conteúdo, mudando apenas o índice do vetor. O Algoritmo não ficaria mais simples se utilizarmos um Laço de Repetição? Observe o exemplo abaixo:
125 |
126 |
**Exemplo 05 - Exibindo os dados do vetor - Versão 02**
127 |
128 | ```pseudocode
129 | programa
130 | {
131 |
132 | funcao inicio()
133 | {
134 |
135 | inteiro vetorInteiros[5] = {10, 20, 30, 40, 50}
136 |
137 | para(inteiro indice=0; indice < 5; indice ++){
138 | escreva(indice + 1, "º Numero: ", vetorInteiros[indice], "\n")
139 | }
140 |
141 | }
142 | }
143 |
144 | ```
145 |
146 |
**Resultado do Algoritmo:**
147 |
148 |
149 |
150 | Observe que o resultado é o mesmo, escrevendo menos código.
151 |
152 |
153 |
154 |
155 |
156 |
157 |
158 |
1.5. Entrada de dados - Vetor vazio
159 |
160 | Para inserir os dados em um vetor, via teclado, utilizaremos o comando **leia()**. Como parâmetro do comando leia(), vamos passar o **nome do vetor com o índice do vetor**, ou seja, a posição que desejamos guardar os dados digitados.
161 |
162 | **Sintaxe:**
163 |
164 | ```pseudocode
165 | leia(nome_do_vetor[indice])
166 | ```
167 |
168 |
**Exemplo 06 - Inserindo dados no vetor via teclado**
169 |
170 | ```pseudocode
171 | programa
172 | {
173 |
174 | funcao inicio()
175 | {
176 |
177 | inteiro vetorInteiros[5]
178 |
179 | para(inteiro indice=0; indice < 5; indice ++){
180 | escreva("Digite o ", indice + 1, "º Numero: \n")
181 | leia(vetorInteiros[indice])
182 | }
183 |
184 | escreva("\nOs Numeros digitados foram: \n")
185 |
186 | para(inteiro indice=0; indice < 5; indice ++){
187 | escreva(indice + 1, "º Numero: ", vetorInteiros[indice], "\n")
188 | }
189 |
190 | }
191 | }
192 | ```
193 |
194 |
**Resultado do Algoritmo:**
195 |
196 |
197 |
198 | Neste exemplo, o vetor foi preenchido com dados obtidos via teclado e ao finalizar o preenchimento do vetor, os dados foram exibidos na tela.
199 |
200 |
201 |
202 |
203 |
204 |
205 |
206 |
1.6. Ordenar um vetor
207 |
208 | Vamos criar um Algoritmo para Ordenar o nosso vetor de números inteiros em Ordem Crescente:
209 |
210 |
**Exemplo 07 - Ordenação de um vetor**
211 |
212 | ```pseudocode
213 | programa
214 | {
215 |
216 | funcao inicio()
217 | {
218 |
219 | // Vetor não Ordenado
220 | inteiro vetorInteiros[10] = {5, 9, 1, 3, 7, 2, 8, 6, 4, 10}, j, i, copia, tamanho
221 |
222 | // Informa o tamanho do vetor
223 | tamanho = 10
224 |
225 | // Algoritmo de Ordenação
226 | para(i = 0; i < tamanho - 1; i++){
227 | para(j = 0; j < tamanho - 1 - i; j++){
228 | se(vetorInteiros[j] > vetorInteiros[j+1]){
229 | copia = vetorInteiros[j]
230 | vetorInteiros[j] = vetorInteiros[j+1]
231 | vetorInteiros[j+1] = copia
232 | }
233 | }
234 | }
235 |
236 | escreva("\nVetor de Numeros Inteiros Ordenados: \n")
237 |
238 | para(inteiro indice=0; indice < tamanho; indice ++){
239 | escreva(indice + 1, "º Numero: ", vetorInteiros[indice], "\n")
240 | }
241 |
242 | }
243 | }
244 |
245 | ```
246 |
247 |
**Resultado do Algoritmo:**
248 |
249 |
250 |
251 | A ideia básica deste Algoritmo de Ordenação, popularmente conhecido como **Bubble Sort** (Método das Bolhas), é para cada elemento na **posição (índice) i**, comparar com o elemento seguinte na **posição (índice) j**. Se o elemento da posição i for maior do que o elemento da posição j, trocamos os elementos de posição, ou seja, **o elemento da posição i vai para a posição j e vice e versa**. Veja na animação abaixo, utilizando um vetor com 5 elementos, como funciona o algoritmo de ordenação:
252 |
253 |
254 |
255 |
256 |
257 |
258 |
259 |
260 |
261 |
2. Matrizes
262 |
263 | As Matrizes são estruturas de dados, que assim como os vetores, permitem o acesso a uma grande quantidade de dados em memória usando-se somente um nome de variável, que diferem de um vetor pelo fato de possuir 2 dimensões, ou seja, possui uma estrutura composta por linhas e colunas. As Matrizes também são conhecidas como **vetores ou arrays bidimensionais**.
264 |
265 |
266 |
267 | No exemplo acima, temos uma Matriz 3x3, ou seja, com **3 linhas por 3 colunas**. Observe que o **índice das linhas e das colunas iniciam em 0**. Os dados ficam alocados em cada posição de memória identificada pelo par (linha, coluna).
268 |
269 | **Sintaxe:**
270 |
271 | ```pseudocode
272 | [tipo da matriz] identificador_da_Matriz[linhas][colunas] = {{valores da linha separados por virgula}, {valores da linha separados por virgula}}
273 | ```
274 |
275 |
2.1. Tipo da matriz
276 |
277 | Este parâmetro define o tipo de dado que será armazenado na Matriz. Assim como uma variável, o tipo da matriz pode ser: *inteiro, real, cadeia, caractere ou logico*.
278 |
279 |
2.2. Identificador da Matriz
280 |
281 | O nome da matriz é o identificador da matriz, assim como fazemos com as variáveis. O nome da matriz segue as mesmas regras que utilizamos para os nomes de variáveis:
282 |
283 | - Não se pode separar as palavras que fazem parte do nome de uma matriz com espaço. Ao invés disso, usa-se:
284 | - O underline (**snake_case**). **Exemplo:** *nome_da_variavel*
285 | - Uma letra maiúscula no começo de cada palavra, exceto a primeira (**camelCase**). **Exemplo:** *nomeDaVariavel*
286 | - O nome do vetor não pode ser iniciado com um dígito;
287 | - O nome da matriz pode ser iniciado com um underline ou uma letra;
288 | - O nome da matriz não pode conter letras com acentos, cedilhas, tremas, crases ou caracteres especiais;
289 | - Não utilize as palavras reservadas do Portugol no nome da matriz.
290 |
291 |
292 | |
|
**ATENÇÃO:** O nome da matriz deve expressar exatamente o seu conteúdo. Evite utilizar nomes genéricos como matriz1, matriz_01, entre outros.
|
293 | | ------------------------------------------------------------ | ------------------------------------------------------------ |
294 |
295 |
296 |
297 |
2.3. Declarando matrizes
298 |
299 | Vamos conhecer 3 formas de declarar um vetor:
300 |
301 | **Exemplo 08 - Matriz com dados do tipo inteiro**
302 |
303 | ```pseudocode
304 | inteiro matrizInteiros[3][3] = {{10, 15, 35}, {70, 120, 140}, {50, 100, 150}}
305 | ```
306 |
307 |
308 |
309 | Na imagem acima, vemos a alocação de memória para uma matriz 3x3, de números inteiros. Observe que cada valor está em uma posição da matriz.
310 |
311 | **Exemplo 09 - Matriz vazia**
312 |
313 | ```pseudocode
314 | real matrizReal[3][3]
315 | ```
316 |
317 |
318 |
319 | Na imagem acima, vemos a alocação de memória para uma matriz do tipo Real, vazia. Observe que todas as posições da matriz estão vazias. Neste caso, para inserir dados matriz seria necessário utilizar o **comando de entrada leia()**.
320 |
321 |
2.4. Acessar uma posição da matriz
322 |
323 | Para acessar os dados armazenados em uma posição da matriz utilizaremos o **nome da matriz seguido por 2 colchetes**. Dentro dos colchetes, informaremos o **índice da linha no primeiro colchete e o índice da coluna no segundo colchete**, ou seja, a posição que desejamos obter os dados armazenados. Veja a imagem abaixo:
324 |
325 |
326 |
327 | Observe que cada posição da Matriz, **possui o par formado pelo índice da linha e o índice da coluna**.
328 |
329 | **Sintaxe:**
330 |
331 | ```pseudocode
332 | nome_da_matriz[indice_linha][indice_coluna]
333 | ```
334 |
335 |
**Exemplo 10 - Exibindo os dados da Matriz**
336 |
337 | ```pseudocode
338 | programa
339 | {
340 |
341 | funcao inicio()
342 | {
343 | inteiro matrizInteiros[3][3] = {{10, 15, 35}, {70, 120, 140}, {50, 100, 150}}, tamanhoI, tamanhoJ
344 |
345 | tamanhoI = 3
346 | tamanhoJ = 3
347 |
348 | para(inteiro indiceI=0; indiceI < tamanhoI; indiceI++){
349 |
350 | para(inteiro indiceJ=0; indiceJ < tamanhoJ; indiceJ++){
351 |
352 | escreva("\nO valor armazenado na posição [", indiceI, "][", indiceJ, "] é: ", matrizInteiros[indiceI][indiceJ])
353 |
354 | }
355 |
356 | }
357 | }
358 | }
359 | ```
360 |
361 |
**Resultado do Algoritmo:**
362 |
363 |
364 |
365 | Neste exemplo, os dados do vetor foram exibidos na tela acessando posição por posição.
366 |
367 |
368 |
369 |
370 |
371 |
372 |
373 |
2.5. Entrada de dados - Matriz vazia
374 |
375 | Para inserir os dados em uma matriz, via teclado, utilizaremos o comando **leia()**. Como parâmetro do comando leia(), vamos passar o **nome da matriz com os respectivos índices da linha e da coluna**, ou seja, a posição que desejamos guardar os dados digitados.
376 |
377 | **Sintaxe:**
378 |
379 | ```pseudocode
380 | leia(nome_da_matriz[indice_linha][indice_coluna]
381 | ```
382 |
383 |
**Exemplo 11 - Inserindo dados na matriz via teclado**
384 |
385 | ```pseudocode
386 | programa
387 | {
388 |
389 | funcao inicio()
390 | {
391 | inteiro matrizInteiros[3][3], tamanhoI, tamanhoJ
392 |
393 | tamanhoI = 3
394 | tamanhoJ = 3
395 |
396 | para(inteiro indiceI=0; indiceI < tamanhoI; indiceI++){
397 |
398 | para(inteiro indiceJ=0; indiceJ < tamanhoJ; indiceJ++){
399 |
400 | escreva("Digite um valor para a posição [", indiceI, "][", indiceJ, "]: ")
401 | leia(matrizInteiros[indiceI][indiceJ])
402 |
403 | }
404 |
405 | }
406 |
407 | para(inteiro indiceI=0; indiceI < tamanhoI; indiceI++){
408 |
409 | para(inteiro indiceJ=0; indiceJ < tamanhoJ; indiceJ++){
410 |
411 | escreva("\nO valor armazenado na posição [", indiceI, "][", indiceJ, "] é: ", matrizInteiros[indiceI][indiceJ])
412 |
413 | }
414 |
415 | }
416 |
417 | }
418 | }
419 | ```
420 |
421 |
**Resultado do Algoritmo:**
422 |
423 |
424 |
425 | Neste exemplo, a matriz foi preenchida com dados obtidos via teclado e ao finalizar o preenchimento da matriz, os dados foram exibidos na tela.
426 |
427 |
428 |
429 |
430 |
431 |
432 |
433 |
2.6. Operações Matemáticas com Matrizes
434 |
435 | Vamos criar um Algoritmo para Somar todos os elementos inteiros de cada coluna da Matriz. Para guardar o resultados das somas das colunas, vamos utilizar um vetor auxiliar do tipo inteiro.
436 |
437 |
**Exemplo 12 - Somas das colunas da matriz**
438 |
439 | ```pseudocode
440 | programa
441 | {
442 |
443 | funcao inicio()
444 | {
445 | //Cria uma Matriz 5x4
446 | inteiro matrizInteiros[5][4], tamanhoI, tamanhoJ, soma=0, vetorSoma[4]
447 |
448 | // Define a quantidade de linhas e colunas para delimitar os laços de repetição
449 | tamanhoI = 5
450 | tamanhoJ = 4
451 |
452 | // Insere os dados na matriz
453 | para(inteiro indiceI=0; indiceI < tamanhoI; indiceI++){
454 |
455 | para(inteiro indiceJ=0; indiceJ < tamanhoJ; indiceJ++){
456 |
457 | escreva("Digite um valor para a posição [", indiceI, "][", indiceJ, "]: ")
458 | leia(matrizInteiros[indiceI][indiceJ])
459 |
460 | }
461 |
462 | }
463 |
464 | // Como desejamos somar as colunas, invertemos os índices nos laços de repetição
465 | // Compare com os laços de repetição acima
466 | para(inteiro indiceJ=0; indiceJ < tamanhoJ; indiceJ++){
467 |
468 | para(inteiro indiceI=0; indiceI < tamanhoI; indiceI++){
469 |
470 | // Armazena a soma dos elementos da coluna na variável
471 | soma += matrizInteiros[indiceI][indiceJ]
472 |
473 | }
474 |
475 | // Guarda a soma no vetor auxiliar
476 | vetorSoma[indiceJ] = soma
477 |
478 | // Zera a variável soma, para receber a soma dos elementos da próxima coluna
479 | soma = 0
480 |
481 | }
482 |
483 | // Mostra na tela o resultado da soma dos elementos de cada coluna da Matriz
484 | para(inteiro indiceJ=0; indiceJ < tamanhoJ; indiceJ++){
485 |
486 | escreva("\nSoma de todos os elementos da coluna ", indiceJ + 1, " é: ", vetorSoma[indiceJ])
487 |
488 | }
489 |
490 | }
491 | }
492 |
493 | ```
494 |
495 |
**Resultado do Algoritmo:**
496 |
497 |
498 |
499 |
500 |
501 | Leia os comentários no código para compreender o algoritmo.
502 |
503 |
504 |
505 |
506 |
507 |
508 |
509 |
510 |
511 |
512 |
--------------------------------------------------------------------------------
/02_logica/12_funcoes.md:
--------------------------------------------------------------------------------
1 |
Funções
2 |
3 |
4 |
5 | Uma **função** é um pedaço de código que faz alguma tarefa específica, que pode ser chamada de qualquer parte do programa quantas vezes forem necessárias. Criamos e utilizamos funções em um programa com 3 objetivos principais:
6 |
7 | - **Clareza do código**: separando o código em pequenos trechos, reduziremos a verbosidade da função inicio(), simplificando o entendimento sobre cada parte do código. Dividir o código em funções também facilita a busca por erros.
8 | - **Reutilização**: muitas vezes queremos executar uma certa tarefa várias vezes ao longo do programa. Repetir todo o código para essa operação em diversos trechos do programa, torna a implementação trabalhosa e a manutenção uma tarefa muito complexa, porque se acharmos um erro, teremos que corrigir o erro em todas as repetições do código. Chamar uma função diversas vezes contorna contorna todos estes problemas.
9 | - **Independência**: uma função é relativamente independente do código que a chamou. Uma função pode modificar variáveis, mas limitando-se aos dados fornecidos pela chamada de função. Uma função deve ser construída de forma que ela possa ser alterada sem modificar todo o resto do programa.
10 |
11 | **Sintaxe:**
12 |
13 | ```pseudocode
14 | funcao [tipo de retorno da função] nome_da_função (1º parâmetro, 2º parâmetro, …) {
15 |
16 | // Código da função
17 |
18 | }
19 | ```
20 |
21 | Em Portugol, toda a função sempre começará a ser definida (assinada) com a palavra reservada **funcao**, seguida do tipo de retorno (se houver), o nome e os Parênteses. Caso a função necessite de parâmetros, os mesmos devem ser inseridos dentro dos parênteses.
22 |
23 | Uma função deve ser declarada dentro do **Bloco programa e fora da função inicio()**, como mostra o exemplo abaixo:
24 |
25 | ```pseudocode
26 | programa
27 | {
28 |
29 | funcao inicio()
30 | {
31 | // Implementação da função inicio
32 | }
33 |
34 | funcao teste()
35 | {
36 | // Implementação da função teste
37 | }
38 |
39 | }
40 |
41 | ```
42 |
43 |
44 |
45 |
1.1. Nome da função
46 |
47 | O nome da função é o identificador que será utilizado para chamar a função no código. O nome da função segue as mesmas regras que utilizamos para os nomes de variáveis:
48 |
49 | - Não se pode separar as palavras que fazem parte do nome de uma função com espaço. Ao invés disso, usa-se:
50 | - O underline (**snake_case**). **Exemplo:** *nome_da_variavel*
51 | - Uma letra maiúscula no começo de cada palavra, exceto a primeira (**camelCase**). **Exemplo:** *nomeDaVariavel*
52 | - O nome da função não pode ser iniciado com um dígito;
53 | - O nome de função pode ser iniciado com um underline ou uma letra;
54 | - O nome da função não pode conter letras com acentos, cedilhas, tremas, crases ou caracteres especiais;
55 | - Não utilize as palavras reservadas do Portugol no nome da função.
56 |
57 |
58 | |
|
**ATENÇÃO:** O nome da função deve expressar exatamente o seu conteúdo. Evite utilizar nomes genéricos como func1, funcl_01, entre outros.
|
59 | | ------------------------------------------------------------ | ------------------------------------------------------------ |
60 |
61 |
62 |
63 |
1.2. Tipo de retorno de uma função
64 |
65 |
66 |
67 | Imagine uma função que calcula a soma de 2 números. Após efetuar o cálculo da soma, espera-se que a função retorne o resultado da soma. O resultado desta soma é chamado de **valor de retorno** da função.
68 |
69 | Este parâmetro é opcional. Caso não seja declarado um tipo de retorno na função, dizemos que a função é um **Procedimento**, ou seja, **não retorna um valor específico**. O tipo de retorno da função pode ser: *inteiro, real, cadeia, caractere ou logico*. Para retornar o valor da função, utilizaremos a palavra chave **retorne**, como mostra o exemplo abaixo:
70 |
71 | **Exemplo 01 - Função com retorno de valor:**
72 |
73 | ```pseudocode
74 | funcao inteiro retornarNumero(){
75 | inteiro numero = 100
76 | retorne numero
77 | }
78 | ```
79 |
80 | Observe no exemplo acima, que através da palavra chave **retorne**, o valor da variável **numero está sendo retornado pela função**, ou seja, ao executar a função **retornaNumero()**, o resultado da função será o numero 100.
81 |
82 | Para observamos a diferença entre função e procedimento, vamos analisar o exemplo de um procedimento no código abaixo:
83 |
84 | **Exemplo 02 - Função sem retorno de valor (Procedimento):**
85 |
86 | ```pseudocode
87 | funcao exibirTexto(){
88 | escreva("\nGeneration Brasil!")
89 | }
90 | ```
91 |
92 | Observe no exemplo acima, que nenhuma variável está sendo retornada (não foi inserida a palavra retorne no final), porquê esta função apenas exibe um texto na tela, logo ela não está devolvendo um valor, que poderá ser utilizado no programa principal.
93 |
94 |
95 |
96 |
1.3. Parâmetros da função:
97 |
98 |
99 |
100 | Um parâmetro é um ou mais valores que é fornecido à função quando ela é chamada. Os parâmetros de uma função podem ser acessados da mesma forma que as variáveis locais. Da mesma forma que as variáveis, modificar um argumento não modifica o valor original no contexto da chamada da função, pois, ao dar um argumento numa chamada de função, ele é copiado como uma variável local da função.
101 |
102 | Para declarar a presença de parâmetros, inserimos a *lista de parâmetros* dentro dos parênteses, com os parâmetros separados por vírgulas. Cada declaração de parâmetro é feita da mesma forma que a declaração de variáveis. Vamos analisar o exemplo abaixo:
103 |
104 | **Exemplo 03 - Função com parâmetros:**
105 |
106 | ```pseudocode
107 | funcao inteiro somar(inteiro numero1, inteiro numero2){
108 | retorne numero1 + numero2
109 | }
110 | ```
111 |
112 | Observe que a função acima recebe 2 parâmetros inteiros e retorna a soma dos 2 numeros.
113 |
114 |
1.4. Chamadas de funções
115 |
116 | Para executar uma função, fazemos uma **chamada de função**, que é uma instrução composta pelo nome da função, seguido pela lista de argumentos entre parênteses:
117 |
118 | **Sintaxe:**
119 |
120 | ```pseudocode
121 | nome_da_função (arg1, arg2, ...)
122 | ```
123 |
124 | Os argumentos são definidos na assinatura da função. Lembre-se que ao chamar uma função todos os seus argumentos devem ser preenchidos respeitando o tipo de cada argumento. Vamos analisar o exemplo abaixo:
125 |
126 | **Exemplo 04 - Chamada das funções:**
127 |
128 | ```pseudocode
129 | funcao inicio()
130 | {
131 | inteiro numero1, numero2
132 |
133 | escreva("Digite o primeiro numero: ")
134 | leia(numero1)
135 |
136 | escreva("Digite o primeiro numero: ")
137 | leia(numero2)
138 |
139 | // Chamando a função sem parâmetros com retorno de um numero inteiro
140 | escreva("O numero retornado é: ", retornarNumero())
141 |
142 | // Chamando a função sem parâmetros e sem retorno
143 | exibirTexto()
144 |
145 | // Chamando a função com parâmetros
146 | escreva("\nA soma dos números 1 e 3 é: ", somar(1, 3))
147 |
148 | // Chamando a função com parâmetros, com variáveis na passagem dos parâmetros
149 | escreva("\nA soma dos números ", numero1, " e ", numero2, " é: ", somar(numero1, numero2))
150 |
151 |
152 | }
153 | ```
154 |
155 | Observe que o código acima chama 3 funções: **retornarNumero()**, **exibirTexto()** e **somar(numero1, numero2)**. Na última linha da função inicio(), observe que inserimos na mensagem as variáveis **numero1** e **numero2**, desta forma independente do valor que for digitado para cada variável, os valores irão aparecer na mensagem.
156 |
157 |
**Exemplo 05 - Código completo:**
158 |
159 | ```pseudocode
160 | programa
161 | {
162 |
163 | funcao inicio()
164 | {
165 |
166 | inteiro numero1, numero2
167 |
168 | escreva("Digite o primeiro numero: ")
169 | leia(numero1)
170 |
171 | escreva("Digite o primeiro numero: ")
172 | leia(numero2)
173 |
174 | // Chamando a função sem parâmetros com retorno de um numero inteiro
175 | escreva("O numero retornado é: ", retornarNumero())
176 |
177 | // Chamando a função sem parâmetros
178 | exibirTexto()
179 |
180 | // Chamando a função com parâmetros
181 | escreva("\nA soma dos números 1 e 3 é: ", somar(1, 3))
182 |
183 | // Chamando a função com parâmetros, com variáveis na passagem dos parâmetros
184 | escreva("\nA soma dos números ", numero1, " e ", numero2, " é: ", somar(numero1, numero2))
185 |
186 | }
187 |
188 | funcao inteiro retornarNumero(){
189 | inteiro numero = 100
190 | retorne numero
191 | }
192 |
193 | funcao exibirTexto(){
194 | escreva("\nGeneration Brasil!")
195 | }
196 |
197 | funcao inteiro somar(inteiro numero1, inteiro numero2){
198 | retorne numero1 + numero2
199 | }
200 | }
201 |
202 | ```
203 |
204 |
**Resultado do Algoritmo:**
205 |
206 |
207 |
208 |
209 |
210 |
211 |
212 |
213 |
214 |
**Exemplo 06 - Cadastro de Colaboradore:**
215 |
216 | ```pseudocode
217 | programa
218 | {
219 |
220 | funcao inicio()
221 | {
222 | cadeia nome
223 | inteiro ano, cargo
224 |
225 | escreva("Nome do colaboradore: ")
226 | leia(nome)
227 |
228 | escreva("Ano do Nascimento: ")
229 | leia(ano)
230 |
231 | escreva("Cargo (1 - Gerente / 2 - Vendedore): ")
232 | leia(cargo)
233 |
234 |
235 | escreva("\nA idade do colaboradore é: ", calculaIdade(ano))
236 | escreva("\nO cargo do colaboradore é: ", exibirCargo(cargo))
237 | }
238 |
239 | funcao inteiro calcularIdade(inteiro anoNascimento){
240 | retorne 2022 - anoNascimento
241 | }
242 |
243 | funcao cadeia exibirCargo(inteiro cargo){
244 | se (cargo == 1){
245 | retorne "Gerente"
246 | }senao{
247 | retorne "Vendedore"
248 | }
249 | }
250 |
251 | }
252 | ```
253 |
254 |
**Resultado do Algoritmo:**
255 |
256 |
257 |
258 |
259 |
260 | Neste exemplo, serão solicitados os dados de um colaboradore e a partir dos dados digitados, calcula a idade e exibe o cargo, através dos Métodos **calcularIdade()** e **exibirCargo()**.
261 |
262 |
263 |
264 |
265 |
266 |
267 |
268 |
269 |
--------------------------------------------------------------------------------
/02_logica/13_bibliotecas.md:
--------------------------------------------------------------------------------
1 |
Bibliotecas
2 |
3 |
4 |
5 | Uma **Biblioteca** é uma coleção de subprogramas utilizados no desenvolvimento de software. Bibliotecas contém código e dados auxiliares, que provém serviços a programas independentes, o que permite o compartilhamento e a alteração de código e dados de forma modular. o Portugol possui algumas bibliotecas, que simplificam algumas tarefas para nós. Vamos conhecer as principais:
6 |
7 |
1. Biblioteca Matematica
8 |
9 | A Biblioteca Matematica oferece as funções Matemáticas mais comuns, que podem ser utilizadas no nosso Pseudocódigo. Para usar esta Biblioteca é necessário declarar no inicio do programa através do comando:
10 |
11 | ```pseudocode
12 | inclua biblioteca Matematica
13 | ```
14 |
15 |
16 |
17 | | Função | Operação |
18 | | --------------------------------------------------------- | ------------------------------------------------------------ |
19 | | Matematica.raiz(real valor, real indice) | Calcula a Raiz de um numero real (quadrada, cúbica, entre outras) |
20 | | Matematica.potencia(real valor, real expoente) | Calcula a Potência de um numero real (ao quadrado, ao cubo, entre outras) |
21 | | Matematica.valor_absoluto(real valor) | Retorna o valor absoluto de um numero real. |
22 | | Matematica.arredondar(real valor, inteiro casas_decimais) | Arredonda o valor de um numero real. O segundo parâmetro é o numero de casas decimais. |
23 | | Matematica.maior_numero(real valor_1, real valor_2) | Indica entre 2 números reais, qual deles é o maior. |
24 | | Matematica.menor_numero(real valor_1, real valor_2) | Indica entre 2 números reais, qual deles é o menor. |
25 |
26 |
27 | |
|
**DICA:** *No Anexo
Revisão de Matemática, temos uma breve revisão sobre alguns conceitos e operações da Matemática. Caso você tenha alguma dúvida, não deixe de ler!*
|
28 | | ------------------------------------------------------------ | ------------------------------------------------------------ |
29 |
30 |
31 |
32 |
**Exemplo 01 - Biblioteca Matemática:**
33 |
34 | ```pseudocode
35 | programa
36 | {
37 | inclua biblioteca Matematica
38 |
39 | funcao inicio()
40 | {
41 | real x = 4.0
42 | real y = 7.75
43 |
44 | escreva("Radiciação: ", Matematica.raiz(x, 2.0))
45 | escreva("\nPotenciação: ", Matematica.potencia(x, 3.0))
46 | escreva("\nValor Absoluto: ", Matematica.valor_absoluto(x))
47 | escreva("\nValor Arredondado: ", Matematica.arredondar(y, 1))
48 | escreva("\nMaior valor entre 2 numeros: ", Matematica.maior_numero(x, y))
49 | escreva("\nMenor valor entre 2 numeros: ", Matematica.maior_numero(x, y))
50 |
51 | }
52 | }
53 | ```
54 |
55 |
56 |
57 |
**Resultado do Algoritmo:**
58 |
59 |
60 |
61 | Neste exemplo foram realizadas algumas operações matemáticas utilizando a Biblioteca Matematica do Portugol.
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
2. Biblioteca Texto
70 |
71 | A Biblioteca **Texto** oferece uma série de funções para **manipular variáveis do tipo cadeia**. Para usar esta Biblioteca é necessário declarar no inicio do programa através do comando:
72 |
73 | ```pseudocode
74 | inclua biblioteca Texto
75 | ```
76 |
77 | Vamos conhecer as principais funções da Biblioteca texto:
78 |
79 |
2.1. Caixa Alta
80 |
81 | Converte todos os caracteres da cadeia para letras maiúsculas.
82 |
83 | **Sintaxe:**
84 |
85 | ```pseudocode
86 | Texto.caixa_alta(cadeia texto)
87 | ```
88 |
89 |
2.2. Caixa Baixa
90 |
91 | Converte todos os caracteres da cadeia para letras minúsculas.
92 |
93 | **Sintaxe:**
94 |
95 | ```pseudocode
96 | Texto.caixa_baixa(cadeia texto)
97 | ```
98 |
99 |
2.3. Numero de caracteres
100 |
101 | Conta o numero de caracteres da cadeia, ou seja o tamanho da cadeia.
102 |
103 | **Sintaxe:**
104 |
105 | ```pseudocode
106 | Texto.numero_caracteres(cadeia texto)
107 | ```
108 |
109 |
2.4. Extrair Subtexto
110 |
111 | Extrai uma parte do texto da cadeia de caracteres delimitada pela posição inicial e pela a posição final, onde o caractere da posição final não será levado em consideração.
112 |
113 | **Sintaxe:**
114 |
115 | ```pseudocode
116 | Texto.extrair_subtexto(cadeia texto, inteiro posicao_inicial, inteiro posicao_final)
117 | ```
118 |
119 | Para entender esta função, primeiramente precisamos compreender uma cadeia de caracteres como um vetor (array), onde cada caractere da cadeia é uma posição deste vetor, como mostra o exemplo abaixo:
120 |
121 | | Posição | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 |
122 | | --------- | :--: | :--: | :--: | :--: | :--: | :--: | :--: | :--: | :--: | :--: | ---- | ---- | ---- | ---- | ---- | ---- | ---- |
123 | | **texto** | G | E | N | E | R | A | T | I | O | N | | B | R | A | S | I | L |
124 |
125 | Observe que cada letra tem a sua posição no vetor e como todo o vetor, a 1º posição é a posição 0.
126 |
127 | Para extrair apenas as 3 primeiras letras da cadeia texto (**GEN**), a função **extrair_subtexto** ficaria da seguinte forma:
128 |
129 | ```pseudocode
130 | Texto.extrair_subtexto(texto, 0, 3)
131 | ```
132 |
133 | ***Extraia da cadeia texto, a partir da posição 0 até a posição 3, ignorando o caractere da posição 3.***
134 |
135 | Para extrair apenas cadeia **BRA** da cadeia texto, a função **extrair_subtexto** ficaria da seguinte forma:
136 |
137 | ```pseudocode
138 | Texto.extrair_subtexto(texto, 11, 14)
139 | ```
140 | ***Extraia da cadeia texto, a partir da posição 3 até a posição 7, ignorando o caractere da posição 7.***
141 |
142 | Para extrair apenas a palavra **BRASIL**, a função **extrair_subtexto** ficaria da seguinte forma:
143 |
144 | ```pseudocode
145 | Texto.extrair_subtexto(texto, 11, 17)
146 | ```
147 | ***Extraia da cadeia texto, a partir da posição 7 até a posição 10, ignorando o caractere da posição 10.***
148 |
149 | Observe neste último exemplo, que a posição 10 não existe na nossa cadeia, entretanto se inserirmos o valor 9 na posição final, o último caractere da cadeia não será selecionado. O Portugol considera a posição 10 como vazia.
150 |
151 |
2.5. Substituir texto
152 |
153 | Da mesma forma que podemos Extrair uma parte do texto da cadeia de caracteres, o Portugol também permite substituir um determinado texto em uma cadeia.
154 |
155 | **Sintaxe:**
156 |
157 | ```pseudocode
158 | Texto.substituir(cadeia texto, cadeia pesquisada, cadeia cadeia_substituta)
159 | ```
160 |
161 | Para substituir a palavra **BRASIL** por **GLOBAL**, a função **substituir** ficaria da seguinte forma:
162 |
163 | ```pseudocode
164 | Texto.substituir(texto, "Brasil", "Global")
165 | ```
166 |
167 | Se na cadeia texto a palavra Brasil estivesse repetida várias vezes, todas as repetições da palavra seriam substituídas pela palavra Global.
168 |
169 | Veja o código abaixo, com todos os exemplos da Biblioteca Texto implementados:
170 |
171 |
**Exemplo 02 - Biblioteca Texto:**
172 |
173 | ```pseudocode
174 | programa
175 | {
176 | inclua biblioteca Texto
177 |
178 | funcao inicio()
179 | {
180 | cadeia texto = "Generation Brasil"
181 |
182 | // Converter cadeia para Caixa Alta
183 | escreva("\nCadeia texto em caixa alta (letras maiúsculas): ", Texto.caixa_alta(texto))
184 |
185 | // Converter cadeia para Caixa Baixa
186 | escreva("\nCadeia texto em caixa baixa (letras minúsculas): ", Texto.caixa_baixa(texto))
187 |
188 | // Obter Tamanho da cadeia
189 | escreva("\nTamanho da Cadeia (numero de caracteres): ", Texto.numero_caracteres(texto))
190 |
191 | // Extrair Subtexto da cadeia
192 | escreva("\nExtrair os 3 primeiros caracteres da cadeia texto: ", Texto.extrair_subtexto(texto, 0, 3))
193 | escreva("\nExtrair a cadeia BRA da cadeia texto: ", Texto.extrair_subtexto(texto, 11, 14))
194 | escreva("\nExtrair palavra Brasil da cadeia texto: ", Texto.extrair_subtexto(texto, 11, 17))
195 |
196 | // Substituir uma cadeia de texto
197 | escreva("\nSubstituir a palavra Brasil por Global: ", Texto.substituir(texto, "Brasil", "Global"))
198 | }
199 | }
200 | ```
201 |
202 |
**Resultado do Algoritmo:**
203 |
204 |
205 |
206 |
207 |
208 |
209 |
210 |
211 |
212 |
3. Biblioteca Util
213 |
214 | A Biblioteca **Util** oferece uma série de funções para **interagir com vetores e matrizes, além de algumas funções auxiliares**. Para usar esta Biblioteca é necessário declarar no inicio do programa através do comando:
215 |
216 | ```pseudocode
217 | inclua biblioteca Util
218 | ```
219 |
220 | Vamos conhecer as principais funções da Biblioteca Util:
221 |
222 | | Função | Descrição |
223 | | --------------------------- | ------------------------------------------------------------ |
224 | | **Util.numero_linhas()** | Retorna o numero de linhas da Matriz |
225 | | **Util.numero_colunas()** | Retorna o numero de colunas da Matriz |
226 | | **Util.numero_elementos()** | Retorna o numero de elementos de um vetor |
227 | | **Util.sorteia()** | Sorteia um numero aleatório dentro de um intervalo de numeros |
228 |
229 | Veja o código abaixo, com todos os exemplos da Biblioteca Texto implementados:
230 |
231 |
**Exemplo 03 - Biblioteca Util:**
232 |
233 | ```pseudocode
234 | programa
235 | {
236 | inclua biblioteca Util
237 |
238 | funcao inicio()
239 | {
240 | inteiro vetorInteiros[5], matrizInteiros[3][3]
241 |
242 | para(inteiro indice=0; indice < Util.numero_elementos(vetorInteiros); indice ++){
243 | vetorInteiros[indice] = Util.sorteia(1, 100)
244 | escreva(indice + 1, "º Numero: ", vetorInteiros[indice], "\n")
245 | }
246 |
247 | para(inteiro indiceI=0; indiceI < Util.numero_linhas(matrizInteiros); indiceI++){
248 |
249 | para(inteiro indiceJ=0; indiceJ < Util.numero_colunas(matrizInteiros); indiceJ++){
250 | matrizInteiros[indiceI][indiceJ] = Util.sorteia(1, 100)
251 | escreva("\nO valor armazenado na posição [", indiceI, "][", indiceJ, "] é: ", matrizInteiros[indiceI][indiceJ])
252 |
253 | }
254 |
255 | }
256 | }
257 | }
258 |
259 | ```
260 |
261 |
**Resultado do Algoritmo:**
262 |
263 |
264 |
265 | Observe no código acima que o vetor e a matriz forma preenchidos com números inteiros aleatórios, entre 1 e 100, através da função sorteia(). No laço de repetição do vetor, o tamanho do vetor obtido pela função numero_elementos(). Nos 2 laços de repetição da matriz, o numero de linhas e colunas foram obtidos pelas funções numero_linhas() e numero_colunas(). Através da Biblioteca Util, as variáveis contendo o tamanho do vetor e numero de linhas e colunas da matriz foram dispensadas, deixando o processamento mais automatizado.
266 |
267 |
268 |
269 |
270 |
271 |
272 |
273 |
274 |
275 |
4. Biblioteca Tipos
276 |
277 | A Biblioteca **Util** oferece uma série de funções para **interagir com vetores e matrizes, além de algumas funções auxiliares**. Para usar esta Biblioteca é necessário declarar no inicio do programa através do comando:
278 |
279 | ```pseudocode
280 | inclua biblioteca Tipos
281 | ```
282 |
283 | Vamos conhecer as principais funções da Biblioteca Util:
284 |
285 | | Função | Descrição |
286 | | ------------------------------- | ---------------------------------------------------- |
287 | | **Tipos.cadeia_para_inteiro()** | Converte uma cadeia de números para números inteiros |
288 | | **Tipos.cadeia_para_real()** | Converte uma cadeia de números para números reais |
289 | | **Tipos.inteiro_para_cadeia()** | Converte números inteiros para uma cadeia |
290 | | **Tipos.real_para_cadeia()** | Converte números reais para uma cadeia |
291 |
292 |
293 |
294 | |
|
**ATENÇÃO:** Existem outros conversores dentro da Biblioteca Tipos. Para mais detalhes, consulte a Ajuda do Portugol Studio, no item Bibliotecas.
|
295 | | ------------------------------------------------------------ | ------------------------------------------------------------ |
296 |
297 |
298 |
299 | Veja o código abaixo, um exemplo de uso da Biblioteca Texto implementados:
300 |
301 |
**Exemplo 04 - Biblioteca Tipos:**
302 |
303 | ```pseudocode
304 | programa
305 | {
306 | inclua biblioteca Tipos
307 |
308 | funcao inicio()
309 | {
310 | cadeia numeros
311 | inteiro convertidoInteiro
312 | real convertidoReal
313 |
314 | numeros = "123456"
315 |
316 | convertidoInteiro = Tipos.cadeia_para_inteiro(numeros, 10)
317 |
318 | convertidoReal = Tipos.cadeia_para_real(numeros)
319 |
320 | escreva("\nCadeia convertida para numero Inteiro: ", convertidoInteiro)
321 |
322 | escreva("\nCadeia convertida para numero Real: ", convertidoReal)
323 | }
324 | }
325 | ```
326 |
327 |
**Resultado do Algoritmo:**
328 |
329 |
330 |
331 |
332 |
333 | Observe no código acima que o numero inserido na cadeia numeros, foi convertido para inteiro e real.
334 |
335 |
336 |
337 |
338 |
339 |
340 |
341 |
342 |
--------------------------------------------------------------------------------
/02_logica/README.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
Lógica de Programação
5 |
6 |
7 |
8 | 1.
Introdução a Lógica
9 | 2.
Introdução a Programação
10 | 3.
Introdução a Fluxograma
11 | 4.
Introdução ao Portugol
12 | 5.
Variáveis e Constantes
13 | 6.
Entrada e Saída de dados
14 | 7.
Operadores
15 | 8.
Teste de Mesa
16 | 9.
Laços Condicionais
17 | 10.
Laços de repetição
18 | 11.
Vetores e Matrizes
19 | 12.
Funções
20 | 13.
Bibliotecas Portugol
21 |
22 |
23 |
24 |
Anexos
25 |
26 | 01.
Revisão de Matemática
27 |
28 |
29 |
30 |
31 |
32 |
Home
33 |
--------------------------------------------------------------------------------
/02_logica/revisao_matematica.md:
--------------------------------------------------------------------------------
1 |
Revisão de Matemática
2 |
3 |
1. Potenciação
4 |
5 | A **Potenciação** (ou **Exponenciação**) é uma das operações básicas da Matemática, onde um dado Número Natural, ele é multiplicado por ele mesmo, uma quantidade *n* de vezes. Lembrando que para representar a soma de várias parcelas iguais, usamos a multiplicação, mas podemos recorrer à potenciação para expressar o produto de vários fatores iguais.
6 |
7 |
8 |
9 | **Onde:**
10 |
11 | - a = base sempre será o valor do fator;
12 | - n = expoente é a quantidade de vezes que o fator repete;
13 | - b = potência é o resultado do produto.
14 |
15 | **Exemplo:**
16 |
17 |
18 |
19 | Uma potência ***a*** de grau *n* é o produto de *n* fatores iguais a ***a***. Em outras palavras, dizemos que a está elevado à enésima potência.
20 |
21 |
: dizemos que a está elevado à primeira potência.
22 |
23 |
: dizemos que a está elevado à segunda potência. Potências com expoente igual a 2 são conhecidas como “quadrado”.
24 |
25 |
: dizemos que a está elevado à terceira potência. Potências com expoente igual a 3 são conhecidas como “cubo”.
26 |
27 |
28 |
29 |
1.1 Definições
30 |
31 |
32 |
33 | 1) Potência com expoente zero
34 |
35 | Todo número elevado à zero é igual a um
36 |
37 |
38 |
39 | 2. Potência com expoente 1
40 |
41 | Qualquer número, elevado a 1 será igual a ele mesmo
42 |
43 |
44 |
45 | 3. Toda potência de base 1 é igual ao próprio 1
46 |
47 | Nas potências com base 1, dados por , sendo ***n*** pertencente aos reais, independente do valor de "n", o resultado será sempre 1.
48 |
49 |
50 |
51 | 4. Potências com base igual a 0
52 |
53 | Toda potência com base igual a 0 ,
, será igual a zero.
54 |
55 |
56 |
57 |
58 |
59 |
2. Radiciação
60 |
61 |
62 |
63 | A Radiciação é a operação matemática que nos permite **encontrar a raiz de um número**.
64 |
65 | Você deve se lembrar que o oposto da adição é a subtração e que o oposto da multiplicação é a divisão.
66 |
67 | Da mesma forma, **a Radiciação é a operação oposta à** **Potenciação**. Se a **radiciação é o contrário da Potenciação**, então **definimos que:**
68 |
69 | “*A Radiciação é uma operação em que descobrimos qual foi o número multiplicado por ele mesmo numa certa quantidade de vezes, para chegar ao número que já nos foi dado.*”
70 |
71 | A radiciação serve para **responder às perguntas do tipo:** “Qual é o número que multiplicado por ele mesmo 3 vezes resulta em 125?” Por tentativa, podemos descobrir que é o número 5, mas há uma forma de representar isso em potências e raízes.
72 |
73 |
74 |
75 | **Onde:**
76 |
77 | - n = é chamado de **índice**, ele indica quantas vezes o número que estamos procurando foi multiplicado por ele mesmo;
78 | - x = é chamado de **radicando**, ele indica o resultado da potenciação feita, normalmente é o número que já nos foi dado;
79 | - y = é o resultado, o número que estamos procurando e que foi a antiga base da potenciação realizada.
80 |
81 | **Exemplo:**
82 |
83 |
84 |
85 | No exemplo acima, como não foi indicado o índice, ele será 2, ou seja, uma raiz quadrada. O resultado da operação será 2, porquê o numero multiplicado por ele mesmo 2 vezes, que resulta em 4 é o 2 (2 x 2 = 4).
86 |
87 |
88 |
89 |
2.1 Como calcular uma raiz? (Fatoração)
90 |
91 |
92 |
93 | Até agora ficou tudo muito fácil porque tínhamos a potência escrita e bastava transformar no contrário.
94 |
95 | Mas o que fazer quando nos for pedido a raiz de um número e não soubermos a potência?
96 |
97 | Neste caso, **fazemos a fatoração** do número!
98 |
99 | Nesse processo, pegamos o valor e vamos **dividindo ele e seus resultados pelos menores número primos** que conseguirmos, **até que chegue a 1.** Vejamos o exemplo abaixo:
100 |
101 | **Determine a raiz quadrada de 144:**
102 |
103 |
104 |
105 | Fatorando o numero 144, teremos:
106 |
107 |
108 |
109 | Agora que já está fatorado, precisamos ver **quais números se repetem em grupos de 2** (pares). Isso porque a raiz é quadrada (índice 2).
110 |
111 | Por fim, vemos que que há **2 pares** de número “2” e **1 par** de número “3”.
112 |
113 | Com isso, vamos **multiplicar os pares formados**: 2 x 2 x 3 = 12.
114 |
115 | O resultado foi **12**, então sabemos que **a raiz quadrada de 144 é 12**
116 |
117 |
118 |
119 |
3.Módulo - Resto da divisão
120 |
121 |
122 |
123 | Na maioria das linguagens de programação, o **Operador Módulo** é representado pelo caractere "%". Sua função é retornar o resto de uma divisão inteira.
124 |
125 | Por exemplo, se dividirmos 11 por 2, trabalhando apenas com Números Inteiros, temos que o resultado da divisão é 5, com resto igual a 1. Observe que ao invés de exibir o resultado da divisão (5), a operação módulo exibirá o resto da divisão (1).
126 |
127 | Agora se dividirmos 10 por 2, trabalhando apenas com Números Inteiros, temos que o resultado da divisão é 5, entretanto o resto será igual a 0.
128 |
129 | O Módulo verifica se um numero inteiro é divisível ou não por outro número inteiro. Caso o resto seja 0 (zero) o número inteiro é divisível pelo outro, caso o resto seja 1 (um), o número inteiro não é divisível pelo outro.
130 |
131 | Exemplos:
132 |
133 | ```portugol
134 | 9 % 3 = 0 // 9 é divisível por 3
135 |
136 | 8 % 3 = 1 // 8 não é divisível por 3
137 | ```
138 |
139 | Uma aplicação clássica da operação módulo é identificar se um número é par ou ímpar. Nos primeiros exemplos acima, concluímos que 10 é um número par porquê ele é um numero inteiro divisível por 2, enquanto o 11 é um número ímpar porquê ele não é um numero inteiro divisível por 2.
140 |
141 |
4. Soma e Subtração de números negativos
142 |
143 | Dentro dos conjuntos numéricos existem os números inteiros, que se caracterizam pela existência de números positivos e negativos. Provavelmente você consegue responder rapidamente qual é o resultado de operações matemáticas simples com números positivos como: **2 + 2** ou **3 – 1**, mas e a adição e a subtração de números negativos? Será que você sabe como calcular: **(– 2) + (-2)** ou **(– 3) – (– 1)**?
144 |
145 | Nós demonstraremos esses cálculos por meio da reta numerada do Plano Cartesiano, conhecida como eixo x.
146 |
147 |
148 |
149 | Independentemente do cálculo, sempre partiremos do ZERO. Vejamos os casos que podem aparecer:
150 |
151 | - Se o número for **positivo,** andaremos a quantidade de casas indicadas para a **direita (→);**
152 | - Se o número for **negativo**, andaremos para a **esquerda (←)**;
153 | - Se estivermos fazendo uma subtração de números inteiros, andaremos para o lado contrário ao que falamos;
154 | - Se for uma adição de números inteiros, não mudará nada!
155 |
156 | Pode até parecer complicado, mas na prática é muito simples! Vejamos alguns exemplos:
157 |
158 | **1° Exemplo: (– 3) + (– 2)**
159 |
160 | Saindo do zero, andaremos duas casas para a esquerda, parando no **– 3** (seta laranja). Em seguida, andaremos outras duas casas para a esquerda, parando no **– 5** (seta roxa). Então, **(– 3) + (– 2) = – 5.**
161 |
162 |
163 |
164 | **2° Exemplo: (– 3) – (– 2)**
165 |
166 | Saindo do zero, andaremos 3 casas para a esquerda, parando no **– 3** (seta laranja). Deveríamos andar 2 casas para a esquerda, mas como é uma **subtração,** invertemos o lado e andamos duas casas para a **direita**, parando no **– 1** (seta roxa). Logo, **(– 3) - (– 2) = – 1.**
167 |
168 |
169 |
170 | **3° Exemplo: (– 1) + (+ 4)**
171 |
172 | Saindo do zero, andaremos uma casa para a esquerda, parando no **– 1** (seta laranja). Em seguida, andaremos outras quatro casas para a esquerda, parando no **+ 3** (seta roxa). Então, **(– 1) + (+ 4) = 3**.
173 |
174 |
175 |
176 | **4° Exemplo: (+ 3) – (– 2)**
177 |
178 | Saindo do zero, andaremos três casas para a direita, parando no **+3** (seta laranja). Deveríamos andar duas casas para a esquerda, mas como é uma **subtração,** invertemos o lado e andamos duas casas para a **direita**, parando no **+ 5** (seta roxa). Então, **(+ 3) – (– 2) = 5**
179 |
180 |
181 |
182 |
183 |
184 |
185 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
Introdução a Lógica
5 |
6 |
Conteúdos
7 |
8 |
18 |
19 |
--------------------------------------------------------------------------------
42 |
43 | 
| **Terminal:** Indica o início e o final do fluxo de um algoritmo. |
18 | | 
| **Fluxo de dados:** Indica o sentido do fluxo de dados e conecta os blocos. |
19 | | 
| **Processamento:** Pode ser utilizado em operações de processamento de dados, cálculos Matemáticos e atribuição de valores. |
20 | | 
| **Entrada e Saída / Leitura e Gravação de dados ou saídas**. |
21 | | 
| **Entrada de dados:** Entrada (leitura) de dados via teclado. |
22 | | 
| **Saída de dados:** Indica a saída de dados impresso |
23 | | 
| **Display:** Corresponde à instrução de saída de dados. Os dados serão exibidos na tela do computador. |
24 | | 
| **Desvio Condicional:** Divide o fluxo do programa em dois caminhos, dependendo do teste lógico que fica dentro do losango. |
25 | | 
| **Desvio / Conector:** Utilizado para criar um desvio para outro ponto do Fluxograma. |
26 | | 
| **Conector de páginas:** Permite continuar um fluxograma em uma segunda ou N páginas que o fluxo necessitar. |
27 |
28 | Na imagem abaixo temos um exemplo de um Fluxograma de um sistema de autenticação (login), que verifica se o usuário e senha estão corretos:
29 |
30 | 
Voltar