Estruturas de Repetição 1 - Curso de Algoritmos #09 - Gustavo Guanabara

♫ Música de abertura ♫ Olá, seja bem vindo a mais uma aula do seu curso de algoritmo. O meu nome é Gustavo Guanabara, eu sou seu professor. .

. . .

. e agora nós chegamos à nona aula. E esse momento é um momento em que as pessoas começam a se enrolar nos cursos de algoritmo.

Quem ainda não tem muita experiência, começa a se enrolar um pouquinho, e eu vou tentar tornar isso mais simples. Agora, entramos no momento em que nós chegamos às nossas estruturas de repetição. E nós vamos começar bem devagarinho, com um exemplo bem simples.

E mais simples é impossível! Eu vou mostrar pra você, o que eu consigo fazer. Olha só!

Tá vendo? Troca! Viu?

Não sei se você percebeu qual foi a jogada do negócio. . .

. . .

mas eu vou fazer de novo. Ó! Troca!

É isso! É simples! Aprender estrutura de repetição é tão simples, quanto trocar.

E essa brincadeira que eu fiz é pra você entender o seguinte: Eu vou querer fazer esse mesmo procedimento de troca 5 vezes! O meu primeiro passo é: contar até 5. E todo mundo sabe contar até 5!

Mas, a cada vez que eu somar um dedo na minha mão, eu vou fazer a troca. Eu vou demonstrar pra você! E você vai entender do que eu to falando.

Então. . .

eu sei fazer, o procedimento de troca. Eu fiz aqui, 2 vezes. E se eu quiser fazer 5 vezes, dessa maneira?

Troca! Troca! Troca!

Troca! Troca! Viu como foi simples?

Então, a cada vez que eu somei um dedo. . .

Eu comecei com nenhum dedo. Fiz 1 dedo, 2, 3, 4 e 5. .

. . e a cada vez que eu coloquei, eu fiz a troca.

O procedimento é exatamente esse! Eu vou tentar descrever, isso tudo que eu acabei de fazer em forma de um algoritmo genérico. Então.

. . .

. . basicamente, a estrutura que eu criei foi a seguinte: Pra troca dos dois personagens eu fiz o seguinte algoritmo: Eu utilizei uma variável chamada 'mão'.

Nesse caso aqui, como é um algoritmo genérico eu botei até acentuação. E eu começo então com a minha mão valendo zero. Isso significa que estou com a mão fechada.

O próximo comando é o 'Enquanto'. Enquanto a mão for menor ou igual a 5, faça. .

. Isso é: eu estou com zero, e zero é menor ou igual a 5. O próximo comando é o comando de troca.

Isso vai fazer com que os personagens sejam trocados. Logo, em seguida, 'mão' recebe 'mão + 1' O que significa isso? 'mão', que estava com zero, vai receber o 'mão', que é zero + 1.

0 + 1 = 1 Então, o novo valor para 'mão' é 1. Isso faz a seguinte alteração: Basta você verificar, que a minha mão, que estava lá em baixo, fechada. .

. . .

. agora está com número 1. O próximo comando é 'FimEnquanto'.

Ao chegar nesse comando, ele vai procurar qual é o 'Enquanto' relativo a ele. No caso, é o único que a gente tem na tela. Então, ele vai voltar pra aquela linha.

A minha mão, que estava com zero, agora está com 1. E eu vou verificar: Enquanto a minha 'mão' for menor ou igual a 5, faça: Nesse caso, a minha mão está com 1. E 1 é menor ou igual a cinco.

Logo, o próximo comando. . .

. . .

vai ser executado. Troca! a troca foi feita logo em seguida a minha 'mão' recebe 'mão' que é 1, basta você verificar lá em baixo mais 1.

1 + 1. . .

2. 'FimEnquanto' e mais uma vez, quando ele chega nessa estrutura ele volta pro Enquanto nesse meu caso, mais uma vez 'mão', que está com 2 é menor ou igual a 5. Então ele vai fazer, novamente, esse bloco de 2 comandos: troca e 'mão' recebe 'mão' + 1.

Deu pra entender a lógica da coisa? E se você prestar bem atenção você vai ver que essa minha rotina não vai executar 5 vezes e sim 6 por que minha mão começou fechada. Mas o princípio da repetição está sendo exemplificado aqui.

E nós já vimos repetição anteriormente, quando nós utilizamos o Scratch e fizemos o gato dar uma andada. Vamos ver mais um exemplo no Scratch que utilize estruturas de repetição. Então estou aqui com um projeto novo do Scratch.

Eu vou mudar o palco aqui só pra fazer uma coisa. Mostrar algo novo Vou carregar esse fundo aqui, que já vem como padrão que é o x y grid (plano cartesiano) Ele vai ter lá um plano (x,y) pra você entender. O gato sempre vem parado no ponto (0,0).

Então vamos. . .

clicar 2 vezes no gato, vamos em Comandos e vamos lá nos controles. Quando a bandeira for clicada, eu vou fazer um movimento, que é o deslize para x , y. Então, aqui no caso, eu vou querer que o y vá até ao 100 aqui.

Esse é o y. Eu vou até ao 100. Então em um segundo ele vai deslizar até ao 100.

vou usar um 'Vá para' no início, para ele sempre ir para a posição(0,0). Então assim, independente da posição onde o gato esteja, ele vai pra (0,0). E, logo em seguida, ele desliza.

Ao clicar na bandeira, ele vai deslizar. Esqueci de botar 10 , não, 100. Clicando na bandeira de novo, ele leva um segundo pra subir.

Vejo um segundo, vou botar 0. . .

ponto. . .

2. Clicando na bandeira, ele subiu em dois décimos de segundo até ao y=100. Vou em seguida deslizar em +0, 2 segundos para (0,0).

Então clicando na bandeira, ele sobe e desce. Então esse aqui, que é o bloco que eu vou destacar, é o procedimento que eu quero repetir. Vou vir aqui na área de Controle e vou mandar ele repetir dez vezes isso daqui.

Então vou fazer ele subir e descer dez vezes. Vou clicar na bandeira, ele vai subir e descer exatamente dez vezes. E aí fica simples, né?

Você entende que ele faz fazer um Repita e essa estrutura vai repetir dez vezes. No algorítmo é um pouquinho mais complexo porque precisa da coisa da mão precisa de contar quantas vezes você quer fazer algo. Mas algoritmos de repetição acontecem diariamente na sua vida também.

Vamos ver mais alguns exemplos. A sintaxe do comando Enquanto no algoritmo é a seguinte: enquanto uma expressão for verdadeira faça um bloco e FimEnquanto. Então, ao entrar no Enquanto, a cada vez ele vai testar uma expressão se essa expressão for verdadeira ele executa um bloco, que pode ter quantos comandos você quiser, e ao atingir o FimEnquanto, ele vai voltar pro comando Enquanto.

O nome desse processo é conhecido como looping e lembra o trajeto que os aviões fazem na hora de fazer um looping. Como eu falei estruturas de repetição acontecem no seu dia-a-dia. Vamos ver um exemplo simples.

A sua mãe chega pra você e fala o seguinte: "enquanto não arrumar o quarto, ele fica de castigo". Então, enquanto você não arrumar o quarto, você vai ficar de castigo. Quando chegar o FimEnquanto, ele vai entrar em looping e vai verificar se você já arrumou o quarto.

Enquanto não arrumar, você continua de castigo. Aí vamos supor que você arruma o seu quarto. quando ela chegar lá em cima para verificar, vai verificar que: você já arrumou e aí o looping é desfeito e os próximos comandos serão executados.

O comando nesse caso seria você liberado pra fazer o que quiser saindo do castigo. Viu como é simples? !

Então não necessariamente você precisa contar alguma coisa. A sua mãe pode te dar a ordem. Enquanto você não arrumar o quarto você não vai sair do castigo.

E esse é um princípio muito importante da repetição. Você não precisa ter um limite específicado, mas nesses primeiros exercícios é melhor que a gente tenha esse limite. E eu sempre vou utilizar contadores, no caso aqui a minha mão, que utilizei pra contar quantas vezes eu quiser.

Vamos a alguns exemplos práticos, pra você poder entender isso. Então, a primeira prática que eu proponho é contar de 0 a 10. Vamos ver como isso é feito utilizando Visualg.

Então estou aqui com Visualg, um programa novo vou lhe chamar de. . .

"conteAté10" e eu vou começar o meu programa. Eu vou precisar da minha variável vou chamar de 'mão', que é a mão que vai contar. Eu vou precisar de uma variável que conte os passos.

Eu vou precisar de uma variável que conte. Então vou chamar ela de 'contador'. Então, a variável 'contador' vai começar a contagem.

Então eu quero um contador de 0 até 10. Então primeiro, o meu contador começa com 0. Vou tem que vir aqui em cima declarar a variável .

contador'. Como é um número vou declarar como 'Inteiro'. E vamos à estrutura de repetição.

'Enquanto' o meu contador for menor (<) ou igual (=) a 10, porque eu quero contar até dez, faça Vou ter o 'FimEnquanto'. Sempre que eu abrir o 'Enquanto', eu vou fechar o 'Enquanto'. Sempre que eu abrir uma estrutura, e ela tiver fechamento, imediatamente eu vou tentar lembrar de fechar a essa estrutura.

Dentro do 'Enquanto' vamos colocar 'contador' que é o caso da mão, recebe (<-) o 'contador' mais um (+1). Isso é, ele começava com zero, depois vai passar depois da passar pra 1, pra 2, pra 3. .

e assim até 10. Em cada um dos passos vou dar um 'EscrevaL' , vou mostrar o contador. simples.

objetivo. Mais uma vez, em vez de eu executar clicando aqui em Executar, eu vou clicar no 'Executar com time' (tempo). Então o meu programa começa.

Vou declarar a variável. O meu contador vai começar com zero e nós vamos ver a estrutura de repetição funcionando pra ver se ele vai contar de 0 até 10. Vamos lá?

. . .

. . 0.

. . .

1. . .

. . .

2. . .

. . .

3. . .

4. . .

5. . .

Note no canto esquerdo que a estrutura de repetição está acontecendo e a variável que tá lá em baixo contadora está modificando até 10 mostrou 10 na tela e finalizou a execução. E agora, perceba um detalhe muito importante da variável contadora: a gente pensa que ela vai parar em 10, na verdade, o 10 vai ser exibido na tela. Mas a variável que conta vá até um valor a mais que no caso é o 11 pois eu estou somando mais um.

Preste atenção no Visualg e você vai entender. Se você olhar na tela preta, você vai ver que teve a contagem de 0 a 10 que foi exatamente o que eu queria mas se você olhar aqui, na parte de baixo da esquerda, você vai ver que a variável contadora foi pra 11. Isso acontece porque, enquanto o contador for menor ou igual (<=) a10 ele vai escrever na tela.

Quando ele passar de 10, que, no nosso caso, somando +1 vai ser 11 aí sim ele vai parar e vai finalizar o algoritmo. Só pra mostrar a finalização, vou colocar mais uma vez aqui fazer ele contar até 5 e no final eu vou mandar escrever (EscrevaL) "Terminei de contar". vamos executar de novo a variável foi declarada.

E agora vou começar a minha contagem de 0 a 5 nesse caso agora. 0. .

. 1. .

. 2 3 4 vai parar 5 e agora terminei de contar. Isso demonstra exatamente aqueles dois caminhos que eu mostre: o caminho do looping e o caminho de saída executando os comandos que estão logo abaixo Deu pra entender?

Então faça os seus testes aí. Faça contar, por exemplo, de 10 a 0. Tenta contar de zero a cem ah.

. pulando de 10 em 10. Então, faça os seus testes mostrando que você 'tá aprendendo as suas estruturas de repetição.

depois que você fizer todos os seus testes, vamos pra nossa segunda prática, que começa agora. Então a primeira prática foi contar de 0 até 10. Ela foi cumprida.

Vamos à segunda, que é contar de 10 até 0. E, nesse caso, eu vou utilizar o mesmo programa feito anteriormente, fazendo algumas alterações. Nesse caso, 'conte até dez' o meu contador começa com 0 e iria até 10.

Somando +1 a cada interação. Vamos fazer agora ele conta de 10 a 0. Nesse meu o caso aqui, o meu contador começava com zero e agora ele vai ter que começar pelo 10.

A cada interação, em vez de somar mais um, eu vou ter que tirar um. Enquanto o meu contador for maior ou igual (>=) a zero. ele vai mostrar o contador.

Então perceba o seguinte: eu começo o contador com 10 enquanto ele for maior ou igual a zero, que é o valor final que eu quero, já que eu estou contando de forma retroativa ele vai mostrar e eliminar 1. No final, terminei de contar. Vamos executar e ver como é que isso funciona.

Declarei a variável e vai começar a minha contagem. Começando por 10, 9, 8, 7 perceba aí, a repetição. .

. . você pode ver esse vídeo várias vezes.

Perceba que a cada vez ele tira uma unidade da variável contadora até chegar a zero e terminar a contagem. Se eu, por acaso, quisesse começar de 10, e tirar duas unidades a cada vez, ele mostraria apenas os números pares de dez até zero. Então ele vai-me mostrar: 10 em seguida, 8 depois 6 4 2 finalmente, 0 e termina a contagem.

E não se esqueça que, como você 'tá vendo esse vídeo no YouTube, você pode pausar o vídeo, voltar, assistir mais de uma vez, pra você pode entender, fazer o exercício no seu computador e ver os resultados. Teste, experimente novos valores, experimente novas situações que você entre. E por falar em situação, vamos a terceira prática, que eu vou propor a voc, nessa primeira aula de estruturas de repetição.

A terceira prática é contar de zero até onde o usuário quiser. E aí você pode me perguntar: "mas poxa Guanabara, como é que pedir pro usuário dizer até onde ele vai? " Lembra dos comandos 'Escreva' e 'Leia'?

Todos os comandos que você viu até agora podem ser utilizados com estruturas de repetição. Não é porque você terminou a aula 8 que os comandos não vão funcionar na aula 9. Inclusive, podemos utilizar estruturas condicionais junto com estrutura e repetição.

Então vamo' ver uma proposta, pra ver como é que ficaria o resultado dessa prática que eu acabei de dizer pra você. Então eu voltei aqui ao meu algoritmo pra contar de 0 a 10 e vamos fazer alguma alteração aqui. No meu caso, esse programa está contando de 0 a 10.

A minha proposta é contar de 0 até ao valor que o usuário quiser. Então eu vou declarar uma variável aqui chamada' valor'. Então vou declarar aqui uma variável valor' também do tipo 'Inteiro'.

E essa variável 'valor' vai ser lida antes do 'Enquanto'. "Quer contar até quanto? " E eu vou ler 'valor'.

que foi a variável que eu acabei de criar aqui em cima. Aqui, no nosso caso, ele vai somando mais um até chegar a dez. No meu caso, eu quero que ele comece com zero e somar mais um até chegar ao valor que o usuário digitar aqui.

Então, basta colocar a variável 'valor' dentro da expressão. Vamos executar e ver se vai funcionar. Quero contar até 4.

Ele contou de 0 a 4. Vamos a mais uma. Quero contar até 18.

Contou de 0 a 18. Ficou claro? São variações do mesmo tema.

Por exemplo aqui: se não quiser contar de um em um, se eu quiser deixar o usuário decidir qual será o passo, qual será cada salto. Vamos fazer uma alteração. Então eu vou criar uma variável 'salto' e vou ler esse valor.

"Qual será o valor do salto? " Leia (salto) e aqui, contador recebe 'contador + 1'. .

No meu caso, vai ser 'contador + salto'. Executando. .

. eu quero contar de zero a 10 pulando de dois em dois. De zero a dez pulando de dois em dois.

Se eu quiser aqui, mais uma vez, de zero a cem pulando de dez em dez, ele fez 10, 20, 30 até ao 100. Eu acho que agora ficou mais claro ainda, né? Mas mesmo assim você ainda pode praticar mais coisas, mais possibilidades.

E perceba que as minhas leituras foram feitas antes do 'Enquanto'. Se eu colocar um 'Leia' desse dentro 'Enquanto', ele vai ler várias vezes a mesma coisa. Como esse não é o meu objetivo, eu coloquei fora da estrutura.

Mas você tem que ter claro na sua cabeça a posição onde os comandos vão estar. No algoritmo não existe fórmula. Não é porque eu utilizei as primeiras linhas 'Escreva' e 'Leia' até agora, que todos os meus programas vão começar com elas.

Nesse caso aqui não começa. Então você vai ter que utilizar a sua lógica, o seu raciocínio, pois algoritmo não é receita de bolo, apesar de receita de bolo ser um algoritmo. eu espero que você tenha entendido.

Vamos ver então exatamente esse ponto que eu acabei de apontar que é a diferença entre ler fora do laço ou dentro do laço, fora da estrutura 'Enquanto' ou dentro da estrutura 'Enquanto'. A Prática 4 é um pouco diferente. Eu quero ler dez números e somá-los.

Note aqui uma diferença: no exemplo anterior eu quis ler quantas vezes vai acontecer, quis ler uma vez só. Quantas vezes ia acontecer e repetir várias vezes quantas forem solicitadas. Agora eu já sei que são 10 repetições mas a cada repetição eu vou pedir um número e vou somar esses números.

Vamos ver como isso funciona: Vou começar um programa novo ele vai se chamar somador numérico "somadorNumerico" e vou até lá. Eu quero um programa que repita dez vezes. Se ele vai repetir dez vezes eu vou ter que ter um contador que é 'Inteiro' esse meu contador vai começar com 1.

Enquanto esse contador for menor ou igual a 10 faça vou fazer Vou botar o 'FimEnquanto' aqui. . .

vou ter que somar mais um no contador. Note que é a mesma estrutura que nós fizemos até então. A ideia do algoritmo não é escrever de cima pra baixo, é fazer ele funcionar.

Então nesse caso aqui eu fiz um contador interagir por dez vezes. A cada vez que ele repetir eu vou ler um número. Então vou ter uma variável 'N' e vou ler essa variável.

"Digite um valor:". Leia (N) Vamos executar e ver como é que funciona. Ele 'tá pedindo um valor.

Eu vou digitar, ele pediu de novo. Vou digitar. ele vai pedir de novo.

Ele vai fazer isso dez vezes. Vou fazer uma alteração aqui ó: só pra ficar mais bonitinho. "Digite o " vou botar "cont um ozinho com um ponto, valor.

Então ele ficar lá ó: "Digite o primeiro valor:" o 2º 3º o 4º o 5º o 6º, 7º, 8º, o 9º e o 10º. Então, ele fez exatamente o que o solicitei. Só que agora, eu quero somar esses valores.

Pra isso, eu vou ter uma variável Soma, que comece o meu programa valendo zero. Isso porque, no início o programa, eu somei nenhum valor, então a soma 'ta valendo zero. A cada vez que eu ler N, eu vou fazer com que esse N entra na soma.

Então se eu li o valor três, ele vai pegar esse três, somar com o zero e fazer com que o resultado passe a valer S. Então na verdade o que eu quero fazer é fazer a soma somar com o valor N. Isso vai ser atribuído à própria variável Soma.

Então: Soma recebe soma mais N. No final do algoritmo, eu vou mandar escrever "A soma de todos os valores foi" vou mandar mostrar, S. Vamos executar.

Vou fazer o seguinte: vou diminuir aqui para 5 valores, só pra gente ter mais prática e menos repetição , menos menos demora no vídeo. Executar. Agora ele vai ler 5 valores apenas.

3 com dois 5 com 4, 9 com 2, 11 com 4, 15. Então quando eu apertar Enter, ele vai ter que somar, ele tem que mostrar o valor 15. A soma dos valores foi 15.

Ficou claro? Eu vou mais uma vez avisar: se você não entendeu direito, assiste o vídeo de novo, pratique, mostre no seu computador. Pratique, digite o código no seu computador pra você poder entender o funcionamento desse algoritmo.

Então o que eu fiz foi o seguinte: eu tinha a soma, a minha soma estava vazia eu li um número a minha soma é o que 'tá vazio mais o número que eu acabei de ler. depois que eu ler um segundo valor, a minha soma vai ser o que eu tenho, que é o S mais o número que eu li. Então a minha soma vai ser uma acumulação do que ela estava anteriormente.

por isso a fórmula é S recebe S+N. E eu tenho uma proposta pra melhorar ainda mais essa prática 4: Além de somar os valores, eu tenho um adicional que é mostrar qual foi o maior valor digitado. Pra isso, eu vou precisar de uma outra variável.

Eu vou voltar aqui ao meu programa, e vou digitar uma variável chamada 'maior'. Vai guardar o valor maior. O que eu vou fazer é: a cada vez que eu ler N, eu vou verificar se o N foi maior do que o maior valor que está guardado.

Se for, então, o meu maior valor, passa a ser o número atual. Tem que ter o Fim de Se. E essa é a estrutura.

Perceba o seguinte: eu acabei de ler um número, se esse número for maior do que o maior número que eu tenho, então o maior número passa a ser o N. que foi o número que eu acabei de digitar. Vamos executar, e ver funcionando.

3 6 5 9 e 1 A soma foi 24 e o maior valor digitado foi 9. Vamos verificar se realmente ele está guardado na variável maior. Olhando aqui no canto esquerdo, a minha variável maior está com nove que, realmente, foi o maior número de digitado entre 3 e 6 5 9 e 1.

Podemos fazer aqui ele mostrar na tela um EscrevaL "o maior valor digitado foi", maior Vamos executar mais uma vez, fazer mais um exemplo. . .

Entre 9 8, 1 4 e 7 mais uma vez o maior valor digitado foi 9 pressionando Enter. A soma entre os valores foi 29, e o maior valor digitado foi 9. Ficou claro?

Mais uma proposta que eu tenho: tente mostrar ,além do maior valor digitado, o menor valor digitado. Você vai ver como é fácil de fazer. E perceba que eu utilizei uma estrutura condicional dentro de uma estrutura de de repetição.

Algorítmos mais complexos podem assustar mas eles não são difíceis de compreender se você praticar bastante. Vamos a mais um exercício. A última prática que eu vou propor aqui é a prática 5.

E é fazer a conversão de moedas quatro vezes. E você deve lembrar do algoritmo da conversão de moedas que nós já fizemos em algumas aulas anteriores principalmente que era um problema da Creuza. Que era a nossa personagem fictícia, naquela nossa aula sobre exercícios.

Vamos relembrar como foi feito aquele exercício. Então nesse caso aqui, eu tenho o algoritmo de conversor de moedas antigo que é o seguinte: o valor em reais, por exemplo, se eu tenho 100 reais, com a cotação do dólar a 2 e 20 eu vou ter convertido 45 dólares e 45 cents. O problema é que agora eu quero fazer essa conversão quatro vezes.

Pra isso eu vou ter uma variável contadora , que eu vou chamar de C, ela vai começar o meu programa valendo 1, e enquanto essa variável C for menor ou igual a 4, que é a quantidade de vezes que eu quero fazer, ele vai fazer esse bloco. Note que eu estou utilizando a indentação (organização dos comandos) pra fazer com que essa conversão toda ocorra dentro da estrutura 'Enquanto'. Mais uma vez dizendo, a indentação é opcional, mas ela é muito importante para os bons programadores.

Falta ainda somar mais um no contador e vamos executar. Valor em reais: 50 Deixa eu botar só um ' EscrevaL' aqui. .

. para ficar mais fácil. .

. 50 reais vai dar 22 dólares. 30 reais dá 13 dólares, 19 reais dá 8 dólares.

500 reais dá 227 dólares. Então ele fez a conversão quatro vezes, exatamente como eu solicitei. E eu quero também propor uma alteração nessa 5ª prática, que é: Perguntar ao usuário quantas conversões serão realizadas.

Não quero que sejam feitas quatro conversões, eu quero que o usuário digite quantas serã. o Pra fazer isso, vou criar uma variável. .

. Nossa eu declarei C como 'Real'. .

. vamos colocar C como 'Inteiro', né? E vou declarar uma variável uma variável Q que é a quantidade, 'Inteiro'.

Vou solicitar aqui fora do 'Enquanto' se eu perguntar dentro, ele vai repetir 4 vezes, não é isso? Então vou botar aqui "Quantas vezes você quer converter? " O usuário vai digitar, vai ficar guardado na variável Q.

Enquanto o C for menor ou igual ao Q, ele vai somar mais um e fazer a conversão. Vamos ver. Eu quero converter duas vezes apenas 1 e 8.

ele fez somente duas vezes. Agora, eu vou querer fazer uma vez só 50 reais 22 dólares e finalizou execução do programa. Deu pra entender o conceito?

Antes de terminar essa aula eu quero mostrar um problema que é muito comum quando você aprende estruturas de repetição, que que é quando o programa entra num looping infinito. Eu vou mostrar o problema e como resolver ele. Pra exemplificar, eu abri o meu primeiro exercício que é o contar de 0 até 10.

E eu vou esquecer propositalmente a linha que soma mais um na variável contador. Eliminei ela. Vou executar em vez de clicar aqui no Executar vou clicar no Executar com timer.

Vamos começar o programa. Ele mostrou 0, em seguida 0, em seguida 0,. .

. mais 0. .

. e zero. .

. e vai fazer isso sempre. Isso acontece porque o seu programa entrou em looping.

Poque o seu contador começou com zero e enquanto ele for menor que 10 ele escreve o contador mas não soma mais um nele e aí você vai pensar "Ah, mas é simples Guanabara, é só você vir aqui clicar nesse botão vermelho e fechar a janela. Quando você fizer isso você vai perceber que o programa continua em execução, independente aquilo que você queira mas não precisa se desesperar. Você tem como parar o programa clicando aqui em 'Algoritmo' logo em seguida 'Parar'.

Se quiser, pode até clicar aqui também. Ou pressionar CTRL F2. Assim, o seu programa é finalizado e você pode seguir desenvolvendo.

Existem alunos que entram num desespero tão grande que chegam a desligar a máquina achando que ela tinha travado. Mas não se preocupe, se seu programa entrar em looping, basta clicar em Algoritmo, Parar CTRL F2 ou no botãozinho de parar. Pra finalizar essa aula, como sempre, eu vou deixar dois exercícios que eu vou mostrar pra você funcionando você vai ter que fazer na sua casa a partir de agora.

O primeiro exercício sugerido é o seguinte: uma contagem inteligente. A contagem inteligente vai funcionar da seguinte maneira: se eu colocar de 1 a 6, ele vai contar de 1 a 6. Se eu puser de 8 a 0, ele vai detectar que o início é maior do que o fim e vai mostrar uma contagem regressiva.

Então o seu programa vai ser uma contagem inteligente. Se o menor valor estiver no início você faz uma contagem progressiva. Senão, você faz uma contagem regressiva.

E só de falar essa frase, eu já te dei parte da resposta. O segundo e último exercício que eu proponho a você é o melhor aluno da turma. Vamos ver ele funcionando.

Colocou lá Escola Santa Paciência, "Quantos alunos a turma tem? " Então, o primeiro passo de seu algoritmo vai ser perguntando quantos alunos têm dentro de uma turma. Vou colocar que tem quatro alunos, uma tuma bem pequena.

O meu aluno 1 tem o nome josé e a nota do José é 8. 5. Tem um segundo aluno, que é o Paulo.

O Paulo, tirou nota cinco e meia. E o último aluno, é a aluna Ana, que tirou 7. Entre esses três alunos, a maior nota foi a de José.

Obviamente, nós já fizemos um programa para detectar qual o maior valor de digitado dentro de uma série. Só que acontece, Que eu não quero apenas o valor da nota de José. Eu quero fazer isso, ó tem mais um 4º aluno, eu esqueci.

. . Então o Gustavo, tirou 0.

Eh. . No fim de quatro alunos, ele vai me mostrar qual é o melhor aluno da classe Olhando agora, você vê claramente que é o José.

E eu quero que o seu algoritmo faça exatamente isso. O melhor aproveitamento foi de José. com a nota 8.

5. E esse último exercício pode até assustar um pouco mas ele é bem mais simples do que se pode imaginar então praticando, exercitando e dando uma olhadinha na resposta caso você sinta alguma dificuldade, você vai conseguir fácil. Para conseguir a resposta é simples basta acessar cursoemvideo.

com, fazer a inscrição no curso de algoritmo e ir até a aula 9 e ver a resposta dos exercícios. Não se esqueça também de clicar aqui, e assinar o canal, pois todas as vezes que sair vídeo você será avisado e clicando aqui você vai ter acesso a todas as aulas de algoritmo passo a passo desde a primeira até a última. No caso do curso de algoritmo dê preferência por acessar o site www.

cursoemvideo. com pois lá, você tem um material de apoio, se tem um material de download basta fazer uma inscrição, é simples, é rápido, não custa nada, é de graça e você vai ter acesso a todas as aulas com todo material de apoio queria mais uma vez agradecer a todo mundo que tá compartilhando, mostrando para os amigos o curso de algoritmo ele só cresce, está crescendo bastante, mas é tudo por culpa de vocês Um forte abraço, bons estudos, boas práticas e até lá! Olá!

Seja bem vindo a mais uma aula! e eu vou apresentar para vocês um amigo meu aqui. Fazer a inscrição no vídeo.

. . e mais simples é impossível, eu vou mostrar para vocês que eu consigo fazer mágica olha só tá vendo?

Troca!