<!--
Introdução à Programação - 2017 - Prof. Leoônidas de Oliveira Brandão
Introdução ao comando de repetição while
LInE (Laboratory of Informatics in Education) - http://www.usp.br/line
IME - USP
Material didático
Pode usar livrevemente este material para fins não comerciais, devendo sempre fazer referência à autoria.
Sugestões/apontamento são bem vindos: leo@ime.usp.br (favor indicar no assunto "material de introducao 'a programacao")
Prof. Leônidas de Oliveira Brandão
http://www.ime.usp.br/~leo
http://line.ime.usp.br
http://www.matemtica.br
-->
<meta http-equiv='Content-Type' content='text/html; charset=UTF-8'>
<meta name='keywords' content='mac0122, material, professores, leonidas de oliveira brandao'>
<link rel='stylesheet' type='text/css' href='css_img_js_conf/all.css'>
<link rel='stylesheet' type='text/css' href='css_img_js_conf/line_introducao_programacao.css'>
<script src="css_img_js_conf/defineLInE.js"></script> <!-- para referencias 'a documentos internos -->
<div class="pagina">
<!--
<center><p>[
<a href="#" title=""></a> |
<a href="#memoria" title=""></a>
]</p>
</center>
-->
<p class="secao">Introdução ao comando de repetição <tt>while</tt></p>
<p>
Nas seções sobre
<a href="#" onclick="trocaPagina('introducao_var.html')" title="seguir para o texto introdutório sobre variaveis">variáveis</a> e sobre
<a href="#" onclick="trocaPagina('introducao_if.html')" title="introducao ao comando de selecao">comando de seleção</a>, pudemos perceber os conceitos
básicos da computação que nos permite construir sistemas sofisticados.
Com variáveis é possível armazenar e trocar valores e com a seleção (<i>if</i>) pode-se desviar o fluxo de execução
de acordo com valores que as variáveis assumem.
</p>
<p>
Entretanto, falta um conceito essencial para permitir computação significativa, que é a <i>repetição condicionada</i> de comandos.
Quer dizer, é possível <i>repetir um bloco de comandos enquanto uma condição é verdadeira</i>. Depois examinaremos outras formas, como
</i>repetir até determinanda condição se verificar</i> ou <i>repetir um número de vezes</i>.
com os dois conceitos
</p>
<p>
A figura 1 ilustra o <b style="color:#0000aa;">fluxo de execução</b> de um comando do tipo <b style="color:#0000aa;">repita enquanto</b>:
<ol>
<li> testa a <b>condição lógica</b>,</li>
<li> se resultar <b style="color:#00aa00;">verdadeiro</b>, então <b style="color:#0000aa;">entra no laço</b>,
ou seja, segue o caminho indicado pela seta com rótulo <b>sim</b>;</li>
<ol>
<li> executa todos os comandos subordinados ao laço, o <b style="color:#0000aa;">bloco de repetição</b>;</li>
<li> volta ao passo 1, ao início do laço (por isso este é classificado como <b style="color:#0000aa;">laço com condição de entrada</b>);</li>
</ol>
<li> se resultar <b style="color:#00aa00;">falso</b>, então <b style="color:#0000aa;">sai no laço</b>,
ou seja, segue o caminho indicado pela seta com rótulo <b>não</b>;</li>
</li>
</ol>
<center>
<img src="img/pt_fluxo_laco_enquanto_entrada.png" title="Ilustração do fluxo de execução do laço 'repita enquanto'" width="250px"/><!-- 346 x 464 -->
<br/>
<i>Fig. 1. Diagrama de fluxo de execução (a) sem o ramo de <i>senão</i> e (b) com o ramo de <i>senão</i> .</i>.
</center>
</p>
<p>
A estrutura básica do comando de <i>repetição com condição de entrada</i> é formado por 3 partes, uma marca indicando o comando
(<tt>while</tt>), seguido de uma expressão lógica (EXPL) depois o bloco de comandos subordinados. Assim, se tiver apenas um comando
subordinado a sintaxe <i>C</i> e <i>Python</i> são:
<center>
<table class="tbCodeLinCol">
<tr><th>C </th> <th>Python</th></tr>
<tr><td><table class="tbCode">
<tr><td><pre><azul>while</azul> (EXPL) <tt class="com">// em C e' obrigatorio os '(' e ')'</tt>
comando1;</pre></td></tr>
</table></td>
<td><table class="tbCode"><pre><azul>while</azul> (EXPL): <cyan># note que em Python '(' e ')' sao opcionais</cyan>
comando1</pre></td></tr>
</table></td></tr>
</table></center>
</p>
<p>
O significado (semântica) do código acima, durante sua execução, é:
<center><table>
<tr><td>1. </td> <td>Verifica-se a condição <tt>EXPL</tt>,
se o seu resultado for verdadeiro executa-se o <i>passo 2</i>, senao vai para <i>passo 3</i> (final do comando)</td></tr>
<tr><td>2. </td> <td>Executa-se o comando "comando1", depois volta-se a executar o passo 1.</td></tr>
<tr><td>3. </td> <td>Final do bloco de repetição!</td></tr>
</table></center>
</p>
<p class="subsecao">Vários comandos subordinados ao mesmo comando de repetição <tt>while</tt></p>
<p>
Se houver necessidade de vários comandos subordinados ao comando de repetição, então em <i>C</i> deve-se usar as marcas
'{' e '}' para anotar o início e o fim do bloco. Em <i>Python</i> não é necessário devido à <i>indentação</i>
ser obrigatória e por ser capaz de identificar todos os comandos subordinados. Assim, vejamos um trecho de código que
gerar e imprimir os naturais entre 1 e N:
<center>
<table class="tbCodeLinCol">
<tr><th>C </th> <th>Python</th></tr>
<tr><td><table class="tbCode"><tr><td><pre><verd>scanf</verd>("%d", &N); <cyan>// ler valor limite N</cyan>
i = 0; <cyan>// variavel para "contar"</cyan>
<azul>while</azul> (i < N) {
i = i+1; <cyan>// leia-se como: i recebe o valor de i acrescido de 1</cyan>
<verd>print</verd>f("i=%d\n", i);
} <cyan>// final do bloco</cyan>
<verd>print</verd>f("Final!");</pre></td></tr>
</table></td>
<td><table class="tbCode"><tr><td><pre>N = <verm>int</verm>(<verd>input</verd>()); <cyan># ler valor limite N</cyan>
i = 0 <cyan># variavel para "contar"</cyan>
<azul>while</azul> (i < N) :
i = i+1 <cyan># a indentacao indica esta linha</cyan>
<verd>print</verd>("i=", i) <cyan># e a proxima linha como sobordinadas 'a repeticao</cyan>
<cyan># para indicar final do bloco basta a proxima linha estar alinhada com o "while"</cyan>
<verd>print</verd>("Final!")</pre></td></tr>
</table></td>
</table></center>
</p>
<p class="subsecao">Exercitando a compreenção: simulando o código</p>
<p>
É interessante usar <b>simulações</b> para melhor compreender o desenvolvimento dos algoritmos, mais ainda se você detectar
algum erro em seu código, que portanto precisa ser corrigido.
Adotaremos o seguinte esquema de simulação: usaremos uma tabela com as variáveis do código e registraremos cada alteração
em uma linha, seguindo o <i>fluxo de execução</i> de cima para baixo, de modo que o último valor de uma variável
(em qualquer ponto/linha) será o primeiro valor, na coluna da variável, encontrado "olhando" para "cima".
Indicaremos as atribuições com ":=".
</p>
<center><table><tr><td align="left"><pre>
N | i impressoes
---+--- ----------
* leitura para inteiro N 3 | ?
i := 0 | 0
* entra no laco "while" pois 0=i<N=3 |
i := 1 (pois: i recebe i+1=0+1) | 1
* saida: i=1 | i=1
* final do laco "while" volta para condicao |
* entra no laco "while" pois 1=i<N=3 |
i := 2 (pois: i recebe i+1=1+1) | 2
* saida: i=2 | i=2
* final do laco "while" volta para condicao |
* entra no laco "while" pois 2=i<N=3 |
i := 3 (pois: i recebe i+1=2+1) | 3
* saida: i=3 | i=3
* final do laco "while" volta para condicao |
* sai no laco "while" pois 3=i<N=3 = falso!!! | Final!
</pre></td></tr></table></center>
<p>
Para estudar um pouco mais:<ol>
<li><a href="http://www.ime.usp.br/~hitoshi/introducao/04-ComandoDeRepeticao.pdf"
title="comando while em Python">em C siga este apontador</a>;</li>
<li><a href="http://panda.ime.usp.br/pensepy/static/pensepy/07-Iteracao/maisiteracao.html#o-comando-while"
title="comando while em Python">em Python siga este apontador</a>.</li>
</ol>
</p>
<p>
<a href="https://www.ime.usp.br/~leo" target="_blank" title="seguir para a pagina do prof. Leônidas">Leônidas de Oliveira Brandão</a><br/>
<a href="http://www.ime.usp.br/~leo" target="_blank" title="seguir para a página do LInE">http://line.ime.usp.br</a>
</p>
<p class="rodape">
<b>Alterações</b>:<br/>
2020/08/20: acertos formato<br/>
2020/08/11: imagem diagrama de fluxo (e texto), novo formato, pequenas revisões<br/>
2019/03/31: verao 1.1<br/>
2017/04/14: verao 1.0
</p>
</div>