intr_prog/introducao_while.html

<!--
 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> &nbsp; | &nbsp;
  <a href="#memoria" title=""></a> &nbsp; &nbsp;
 ]</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 &lt; 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 &lt; 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&lt;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&lt;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&lt;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&lt;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>