3 年之前 · 37b0bd41fc
--- a/base_textos.html
+++ b/base_textos.html
@@ -0,0 +1,93 @@
 
				+<!DOCTYPE html>
			
 
				+<html class="yui3-js-enabled" dir="ltr" xml:lang="pt-br" lang="pt-br">
			
 
				+ <head>
			
 
				+  <title>Titulo</title>
			
 
				+  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
			
 
				+  <meta name="keywords" content="moodle, mac2166_web_2017: Mini-tutorial sobre o editor &quot;online&quot;: como fazer, editar e verificar se um programa foi enviado">
			
 
				+  <link rel="stylesheet" type="text/css" href="css_img_js_conf/all.css">
			
 
				+  <script id="firstthemesheet" type="text/css">/** Required in order to fix style inclusion problems in IE with YUI **/</script>
			
 
				+ </head>
			
 
				+
			
 
				+<body id="page-mod-page-view" class="format-topics gecko lang-pt_br pagelayout-incourse">
			
 
				+
			
 
				+<div id="page-wrapper">
			
 
				+
			
 
				+  <header role="banner" class="pos-f-t navbar navbar-full navbar-light bg-faded navbar-static-top">
			
 
				+
			
 
				+    <div class="container-fluid navbar-nav">
			
 
				+
			
 
				+      <a href="../index.html" class="navbar-brand">Início</a><!-- botao fundo azul -->
			
 
				+
			
 
				+      <!-- user_menu -->
			
 
				+      <div class="usermenu">
			
 
				+      <div class="action-menu moodle-actionmenu nowrap-items" id="action-menu-1" data-enhance="moodle-core-actionmenu">
			
 
				+      <div class="menubar" id="action-menu-1-menubar" role="menubar">
			
 
				+
			
 
				+      <div class="dropdown">
			
 
				+        <a href="http://www.ime.usp.br/~leo" title="sitio pessoal autor" role="button">
			
 
				+          <span class="userbutton">
			
 
				+            <span class="usertext">Leônidas de Oliveira Brandão</span>
			
 
				+             <span class="avatars">
			
 
				+              <span class="avatar current"><img src="css_img_js_conf/icone_leo.png" alt="Imagem de Leônidas de Oliveira Brandão" title="Imagem de Leônidas de Oliveira Brandão" class="userpicture" role="presentation" height="35" width="35"></span>
			
 
				+             </span>
			
 
				+          </span>
			
 
				+        </a>      
			
 
				+    </div>
			
 
				+  </header>
			
 
				+
			
 
				+
			
 
				+  <div id="page" class="container-fluid">
			
 
				+    <header id="page-header" class="row">
			
 
				+      <div class="col-xs-12 p-a-1">
			
 
				+        <div class="card">
			
 
				+          <div class="card-block">          
			
 
				+            <h1>Titulo mais extenso</h1>
			
 
				+            <!-- caminho -->
			
 
				+            <div class="clearfix w-100 pull-xs-left" id="page-navbar">
			
 
				+              <div class="breadcrumb-nav">
			
 
				+                <nav role="navigation">
			
 
				+                  <ol class="breadcrumb">
			
 
				+                    <li class="breadcrumb-item"><a href="http://www.ime.usp.br/~leo/">Página inicial</a></li>
			
 
				+                    <li class="breadcrumb-item">Material de apoio didático/li>
			
 
				+                  </ol>
			
 
				+                </nav>
			
 
				+              </div>
			
 
				+            </div>
			
 
				+          </div>
			
 
				+        </div>
			
 
				+      </div>
			
 
				+    </header>
			
 
				+
			
 
				+
			
 
				+    <div id="page-content" class="row">
			
 
				+      <div id="region-main-box" class="col-xs-12">
			
 
				+
			
 
				+        <section id="region-main">
			
 
				+          <div class="card card-block">
			
 
				+            <div class="region_main_settings_menu_proxy"></div>
			
 
				+          <span class="notifications" id="user-notifications"></span>
			
 
				+          <div role="main"><span id="maincontent"></span>
			
 
				+            <h2>Sub-titulo</h2>
			
 
				+            <div class="box generalbox center clearfix p-y-1">
			
 
				+
			
 
				+    
			
 
				+            </div>
			
 
				+            <div class="modified">Última atualização: terca, 08 Ago 2017, 14:00</div></div>
			
 
				+          </div>
			
 
				+        </section>
			
 
				+      </div>
			
 
				+    </div>
			
 
				+  </div>
			
 
				+
			
 
				+  
			
 
				+  </div>
			
 
				+
			
 
				+<footer id="page-footer" class="bg-inverse">
			
 
				+  <div class="container">
			
 
				+    <div id="course-footer"></div>
			
 
				+      <p class="helplink">Material didático - Prof. Leônidas de Oliveira Brandão</p>
			
 
				+  </div>
			
 
				+</footer>
			
 
				+
			
 
				+
			
 
				+</body></html>
			
--- a/c_introducao_apontadores.html
+++ b/c_introducao_apontadores.html
@@ -0,0 +1,264 @@
 
				+
			
 
				+<!--
			
 
				+ Introducao `a Programacao - desde 2017 - Prof. Leo^nidas de Oliveira Branda~o
			
 
				+ Introducao ao apontadores em C
			
 
				+ LInE (Laboratory of Informatics in Education) - http://www.usp.br/line
			
 
				+ IME - USP
			
 
				+ Material dida'tico
			
 
				+ Pode usar livrevemente este material para fins nao comerciais, devendo sempre fazer referencia `a autoria.
			
 
				+ Sugestoes/apontamento são bem vindos: leo@ime.usp.br (favor indicar no assunto "Material de introducao 'a programacao")
			
 
				+ Autoria: Prof. Leo^nidas de Oliveira Branda~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="memoria" title="sobre memoria, bits e bytese">Memória</a> &nbsp; | &nbsp;
			
 
				+  <a href="#variaveis" title="variaveis inteiras e reais">Variáveis</a> &nbsp; | &nbsp;
			
 
				+  <a href="#expressoes" title="expressoes aritmetics">Expressões</a> &nbsp; | &nbsp;
			
 
				+  <a href="#contexto" title="resultado de uma expressao depende do contexto">Contexto</a> &nbsp; &nbsp;
			
 
				+ ]</p>
			
 
				+</center>
			
 
				+-->
			
 
				+
			
 
				+<p class="secao">Introdução aos apontadores em C</p>
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+Nesta seção apresentaremos o conceito de apontadores na linguagem <i>C</i>.
			
 
				+</p>
			
 
				+
			
 
				+<a name="padrao">
			
 
				+<p class="subsecao">Lembrete do tratamento padrão para variáveis em praticamente todas as linguagens de programação</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+Usualmente, em qualquer linguagem de programação, sempre que usamos em um código uma variável, significa que deve-se pegar o valor armazenado nesta variável.
			
 
				+Assim, um trecho com <tt>10*b</tt>, implica em pegar o valor corrente armazenado na variável <tt>b</tt> e
			
 
				+multiplicá-lo por <tt>10</tt>.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+<a name="porque">
			
 
				+<p class="subsecao">Por que precisamos de apontadores</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+Uma boa razão é que na linguagem <i>C</i> as funções devolvem apenas valores simples (como inteiro ou real, mas nunca uma estrutura).
			
 
				+Então imagina precisarmos de uma função que computa dois ou mais valores, sem apontador seria impossível devolver de alguma forma
			
 
				+ambos os valores!
			
 
				+Mas com apontadores podemos passar para esta função os apontadores para duas variáveis locais (i.e., seus <i>endereços</i> ou suas
			
 
				+<i>referências</i>) e, dentro da função registrar as alterações na variável apontada.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Um exemplo onipresente de apontadores na linguagem <i>C</i> é a função de leitura <tt>scanf</tt> usada para providenciar leitura de dados.
			
 
				+Isso é feito via apontadores, por exemplo, o comando para ler e guardar em uma variável inteira é:
			
 
				+<tt>scanf("%d", &a);</tt>.
			
 
				+<br/>
			
 
				+Cujo significado é: pegar <i>bytes</i> até encontrar um separador ou finalizador <tt>ENTER</tt>, interpretar os <i>bytes</i> como
			
 
				+um número inteiro e guardá-lo no endereço indicado da variável <tt>a</tt>.
			
 
				+<br/>
			
 
				+<b>O operador <tt>&</tt> devolve o endereço de uma variável.</b>
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="como">
			
 
				+<p class="subsecao">Ideia de apontadores</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+Assim a ideia básica de um <b>apontador</b> é que a linguagem deve dispor de um recurso de dois passos para pegar um conteúdo,
			
 
				+uma <i>indireção</i>. 
			
 
				+Para ficar mais claro, comparemos com as variáveis "usuais":
			
 
				+invocar o nome desta variável "usual" pegamos diretamente seu conteúdo,
			
 
				+mas ao tentar pegar o conteúdo apontado por uma variável apontadora, 
			
 
				+precisamos <u>primeiro</u> pegar o que ele guarda (um endereço) e <u>depois</u>
			
 
				+ir para este endereço e dali pegar efetivamente o conteúdo (seria o <i>conteúdo apontado</i>).
			
 
				+Existe um operador especial para esta indireção, que é o operador <tt>*</tt>.
			
 
				+<br/>
			
 
				+<b>O <b style="color:#00aa00">operador <tt>*</tt></b> só pode ser aplicado à <i>variáveis apontadoras</i> (ou para declarar uma) e
			
 
				+devolve o conteúdo guardado na variável apontada.</b>
			
 
				+<br/>
			
 
				+Da mesma forma, existe um operador "inverso" ao <tt>*</tt>, o operador <tt>&</tt> que devolve o <i>endereço ocupado por uma variável</i>.
			
 
				+<br/>
			
 
				+<b>O <b style="color:#00aa00">operador <tt>&</tt></b> indica que deve-se pegar o endereço da variável</b>.
			
 
				+<br/>
			
 
				+Logo, usando a declaração <tt><verm>int</verm> *a, b=-2, c = 3;</tt>, o código <tt>a = &c; *a = b;</tt> indica, respectivamente, que:
			
 
				+<tt>a</tt> receberá o endereço de <tt>c</tt> e depois,
			
 
				+a variável apontada por <tt>a</tt> (no caso <tt>c</tt>) receberá o valor guardado em <tt>b</tt>.
			
 
				+Ou seja, ao final <tt>b</tt> e <tt>c</tt> estarão com o mesmo valor <tt>-2</tt>.
			
 
				+Na fig. 1 está a situação após executar a instrução <tt>a = &c;</tt> e antes de executar a instrução <tt>*a = b;</tt>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+<center><!--  style="float: left; margin-right: 1%; margin-bottom: 0.5em;justify-content: center;" -->
			
 
				+<img src="img/img_introd_apontador.png"
			
 
				+     title="memoria com variaveis a, b, p1 e p2"/><br/>
			
 
				+<i>Fig. 1: Representação da memória RAM com espaços para as variáveia <tt>a</tt>, <tt>b</tt>, <tt>c</tt>, <tt>p1</tt> e <tt>p2</tt>.
			
 
				+</center>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Por exemplo, vamos imaginar outra situação que a figura 1 poderia ilustrar.
			
 
				+Suponha que precisemos alterar os valores das variáveis inteiras <tt>b</tt> e de <tt>c</tt>
			
 
				+dentro de uma função <tt>f</tt> (que nada devolve, logo <tt><verm>void</verm></tt>).
			
 
				+<br/>
			
 
				+<bloco1>
			
 
				+Desse modo, a declaração da função deveria ser <tt><verm>void</verm> f (<verm>int</verm> *p1, <verm>int</verm> *p2)</tt> e sua chamada deveria ser <tt>f(&b, &c)</tt>.
			
 
				+<br/>
			
 
				+Lembrando: <tt>p1</tt> e <tt>p2</tt> são parâmetros formais, que receberão valores vindo dos <i>parâmetros efetivos</i>, que são
			
 
				+<tt>&b</tt> e <tt>&c</tt>.
			
 
				+<br/>
			
 
				+Isso quer dizer que <tt>p1</tt> e <tt>p2</tt> serão <b>variáveis apontadoras para <tt>b</tt> e <tt>c</tt></b>, ou seja,
			
 
				+deverão <i style="color:#0000aa">guardar os endereços de variáveis inteiras</i> e não valores inteiros!
			
 
				+<br/>
			
 
				+Suponha ainda que os resultados que <tt>b</tt> e <tt>c</tt> deveriam receber dentro da função <tt>f</tt> sejam,
			
 
				+respectivamente, os valores guardados nas variáveis <tt>v1</tt> e <tt>v2</tt> (variáveis locais declaradas na função <tt>f</tt>).
			
 
				+<br/>
			
 
				+Então a função <tt>f</tt> deveria ter como últimas duas linhas os comandos
			
 
				+<tt>*p1 = v1;</tt> e <tt>*p2 = v2;</tt>.
			
 
				+<br/>
			
 
				+Como o operador <b><tt>*</tt></b> indica
			
 
				+<i style="color:#0000aa">pegar o valor no endereço que é apontado</i>, então <tt>*p1 = v1; *p2 = v2;</tt> resulta em:
			
 
				+<i style="color:#0000aa">guarde em <tt>b</tt> o valor que encontra-se em <tt>v1</tt></i> e
			
 
				+<i style="color:#0000aa">guarde em <tt>c</tt> o valor que encontra-se em <tt>v2</tt></i> 
			
 
				+(pois <i style="color:#0000aa"><tt>p1</tt> <b>aponta para <tt>b</tt></b> (guarda o endereço de <tt>b</tt>) e
			
 
				+ <tt>p2</tt> <b>aponta para <tt>c</tt></b></i>).
			
 
				+</bloco1>
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="exemploA">
			
 
				+<p class="subsecao">Exemplo inicial de apontadores</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+Vamos examinar um exemplo simples: usar um apontador para alterar o valor guardado em outra variável.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+<pre><incl1>#include</incl1> &lt;stdio.h&gt;
			
 
				+<verm>int</verm> main (<verm>void</verm>) {
			
 
				+  <verm>int</verm> *a, b, c; <cyan>// a deve guardar endereco de variavel inteira (nao e' o mesmo que guardar inteiro)</cyan>
			
 
				+  b = 5; c = 11;
			
 
				+  <verd>printf</verd>("b=%d, c=%d\n", b, c); <cyan>// deve resultar na tela: b=5, c=11</cyan>
			
 
				+  a = &c; <cyan>// a recebe endereco de c</cyan>
			
 
				+  *a = b; <cyan>// que e' apontado por a recebe valor guardado em b</cyan>
			
 
				+  <verd>printf</verd>("b=%d, c=%d\n", b, c); <cyan>// deve resultar na tela: b=5, c=5  (por que?)</cyan>
			
 
				+  }</pre>
			
 
				+<i>Algoritmo 1. A variável apontadora <tt>a</tt> receberá o endereço da variável <tt>c</tt>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Antes de continuar a leitura, copie o código acima, cole em seu editor preferido, grave, compile e rode.
			
 
				+Verá que o resultado é o indicado nos comentários. Por que?
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Resposta: vamos examinar as linhas chaves e traduzir o que elas fazem.<br/>
			
 
				+1. <tt>a = &c;</tt>: nesta linha a <u>variável apontadora</u> <tt>a</tt> recebe <b>o endereço da variável inteira <tt>c</tt></b>;
			
 
				+<br/>
			
 
				+2. <tt>*a = b;</tt>: nesta linha existe a "indireção", o conteúdo guardado em <tt>b</tt> será atribuido à
			
 
				+   <u>variável apontada</u> por <tt>a</tt>, que é a variável <tt>c</tt>, logo <tt>c</tt> receberá o que está em <tt>b</tt>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Portanto, poderíamos trocar os comandos 1 e 2 acima, por um equivalente mais simples: <tt>c = b;</tt>
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="exemploB">
			
 
				+<p class="subsecao">Exemplo de apontadores como parâmetros (parâmetros por referência)</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+Vamos retomar a figura 1 com um exemplo que se adequa bem a ela: uma função para trocar os conteúdos de duas variáveis.
			
 
				+</p>
			
 
				+
			
 
				+<pre><incl1>#include</incl1> &lt;stdio.h&gt;
			
 
				+<verm>void</verm> troca (<verm>int</verm> *p1, <verm>int</verm> *p2) {
			
 
				+  <verm>int</verm> aux; <cyan>// para trocar o conteudo e' obrigatorio termos mais uma variavel (senao perdemos um dos valores)</cyan>
			
 
				+  aux = *p1; <cyan>// aux recebe o conteudo da variavel apontada por p1</cyan>
			
 
				+  *p1 = *p2; <cyan>// a variavel apontada por p1 recebe o conteudo da variavel apontada por p2</cyan>
			
 
				+  *p2 = aux; <cyan>// a variavel apontada por p2 recebe o conteudo em aux</cyan>
			
 
				+  }
			
 
				+<verm>int</verm> main (<verm>void</verm>) {
			
 
				+  <verm>int</verm> a = 5, b = 11;
			
 
				+  <verd>printf</verd>("a=%d, b=%d\n", a, b); <cyan>// deve resultar na tela: a=5, b=11</cyan>
			
 
				+  troca(&a, &b); <cyan>// passa os parametros por referencia (ou endereco)</cyan>
			
 
				+  <verd>printf</verd>("a=%d, b=%d\n", a, b); <cyan>// deve resultar na tela: a=11, b=5</cyan>
			
 
				+  }</pre>
			
 
				+<i>Algoritmo 2. Uso de passagem de parâmetro por referência (ou endereço).
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="exemploB">
			
 
				+<p class="subsecao">Exemplo da recursividade do conceito e implementação em <i>C</i> de apontadores</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+Da mesma forma que pode-se declarar <i>vetor de vetor de vetor...</i> (<tt>int vet[D0][D1][D2]...</tt>),
			
 
				+pode-se fazer a mesma coisa com <i>apontador de apontador de apontador...</i>.
			
 
				+Claro que isso só é recomendável em situações muito especiais. Só implemente apontadores níveis mais altos se estiver muito
			
 
				+seguro de que isso é necessário.
			
 
				+<br/>
			
 
				+O código no <i>algoritmo 3</i> apresenta a possibilidade de um número arbitrário de indireções com 3 níveis de indireção
			
 
				+e a figura 2 ilusta esse algoritmo.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+<center><!--  style="float: left; margin-right: 1%; margin-bottom: 0.5em;justify-content: center;" -->
			
 
				+<img src="img/img_introd_apontador_apontador_apontador.png"
			
 
				+     title="memoria com variaveis apontador para apontador para apontador"/><br/>
			
 
				+<i>Fig. 2: Representação da memória RAM com variáveis apontadoras de até 3 níveis.
			
 
				+</center>
			
 
				+</p>
			
 
				+
			
 
				+<pre><incl1>#include</incl1> &lt;stdio.h&gt;
			
 
				+<verm>int</verm> main (<verm>void</verm>) {
			
 
				+  <verm>int</verm> ***a, **b, *c, d = 11, e = 3; <cyan>// declara apontadores de varios niveis - tem que ser compativeis!</cyan>
			
 
				+  c = &d; <cyan>// c aponta para d</cyan>
			
 
				+  b = &c; <cyan>// b aponta para c = b aponta para quem aponta para c</cyan>
			
 
				+  a = &b; <cyan>// a aponta para b = b aponta para quem aponta para quem aponta para c</cyan>
			
 
				+  <verd>printf</verd>("***a=%d, **b=%d, *c=%d, d=%d, e=%d\n", ***a, **b, *c, d, e);
			
 
				+  <cyan>// printf acima deve resultar em: ***a=11, **b=11, *c=11, d=11, e=3</cyan>
			
 
				+  ***a = e; <cyan>// apontado por apontado por apontado por a recebe e => d recebe valor em e</cyan>
			
 
				+  <verd>printf</verd>("***a=%d, **b=%d, *c=%d, d=%d, e=%d\n", ***a, **b, *c, d, e);
			
 
				+  <cyan>// printf acima deve resultar em: ***a=3, **b=3, *c=3, d=3, e=3</cyan>
			
 
				+  }</pre>
			
 
				+<i>Algoritmo 3. Exemplo da recursividade da definição de apontador.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+Novamente, experimente o código do algoritmo 2 até estar seguro de compreendê-lo.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+
			
 
				+  <p class="autoria">
			
 
				+    <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/10/16: explicações adicionais e novo exemplo de apontador em diversos níveis<br/>
			
 
				+     2020/08/20: acerto no formato<br/>
			
 
				+     2020/05/05: primeira versão do texto<br/>
			
 
				+</p>
			
 
				+
			
 
				+</div>
			
--- a/c_introducao_funcoes.html
+++ b/c_introducao_funcoes.html
@@ -0,0 +1,251 @@
 
				+<!--
			
 
				+ Introdução à Programação - 2017 - Prof. Leoônidas de Oliveira Brandão
			
 
				+ Introdução ao uso de funções em C: variáveis locais, globais e aninhamento de funções
			
 
				+ 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">
			
 
				+
			
 
				+
			
 
				+<p class="secao">Introdução ao uso de funções em C: variáveis locais, globais e aninhamento de funções</p>
			
 
				+
			
 
				+<p class="subsecao">Sobre o aninhamento de funções na linguagem <i>C</i></p>
			
 
				+
			
 
				+<p>
			
 
				+  Nesta seção apresento um conceito mais "sutil" de programação, para entendê-lo é essencial que você copie os códigos apresentados,
			
 
				+  "cole" em seu editor preferido e os teste até que esteja tudo claro.
			
 
				+  Experimente alterar os exemplos e criar outros: grave-os, compile-os e os <i>rode</i>.
			
 
				+  <b style="color:#0000aa">Para prender programação é preciso programar!</b>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Em várias linguagens de programação, <i>C</i> em particular, é possível declarar função dentro de função (<b>aninhar</b>).
			
 
				+  Por exemplo, dentro de uma função de nome <i>funcao2</i>, pode-se declarar outra função de nome <i>funcao3</i>.
			
 
				+  O resultado é que, dentro da primeira função, pode-se invocar a segunda, mas em nenhum outro local do código seria possível
			
 
				+  invocar esssa função <i>funcao3</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Mas vale destacar que esse recurso só é efetivamente útil se a função interna (<i>funcao3</i>) só fizer sentido dentro da função que a contém.
			
 
				+  Pois em caso contrário, você poderia invocar a função interna em outros contextos.
			
 
				+  Um exemplo dessa situação é ilustrado no parágrafo seguinte, a função <i>fatorial</i> poderia ficar melhor se declarada fora da função <i>combinacao</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Um exemplo simples de função contendo outra função, poderia ser o caso do cálculo da combinação de <i>n</i>, tomados <i>k</i>-a-<i>k</i>:
			
 
				+  <i>C<sub>n,k</sub> = n!/(k!(n-k)!)</i>.
			
 
				+  Como para o calculo de <i>C<sub>n,k</sub></i> é necessário invocar o cálculo do fatorial 3 vezes, podemos desejar fazer um implementação que
			
 
				+  deixe essa dependência clara, definindo uma função de nome <i>combinacao</i> e, dentro dela, declarar a função
			
 
				+  <i>fatorial</i>. Vide exemplo 1.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Porém, como anteriormente comentado, como a função <i>fatorial</i> tem potencial de aplicação mais amplo, ela ficaria melhor se declarada
			
 
				+  <b style="color:#0000aa">fora</b> da função <i>combinacao</i>
			
 
				+  (vide a crítica a esse organização de código logo após o exemplo 1).
			
 
				+</p>
			
 
				+
			
 
				+<div class="exemplo"><i>Exemplo 1</i>. Declaração aninhada de funções.
			
 
				+</div><!-- class="exemplo" -->
			
 
				+<div class="codigo"><pre><verm>int</verm> combinacao (<verm>int</verm> n, <verm>int</verm> k) { <cyan>// combinacao de n, k-a-k</cyan>
			
 
				+  <verm>int</verm> fatorial (<verm>int</verm> n) { <cyan>// fatorial de n (supondo n natural)</cyan>
			
 
				+    <verm>int</verm> i, fat = 1;
			
 
				+    for (i=2; i&lg;=n; i++)
			
 
				+      fat *= i;
			
 
				+    return fat;
			
 
				+    }
			
 
				+  return fatorial(n) / (fatorial(k)*fatorial(n-k));
			
 
				+  }
			
 
				+
			
 
				+<verm>void</verm> main (<verm>void</verm>) :
			
 
				+  <verm>int</verm> n = 5, k = 3;
			
 
				+  <verd>printf</verd>("Combinacao %d, %d-a-%d = %d\n", n, k, k, combinacao(n,k));
			
 
				+  <cyan>// Problema de declarar 'fatorial()' dentro de 'combinacao()': a linha abaixo daria erro!</cyan>
			
 
				+  <cyan>// Erro: exemplo_funcao_aninhada.c:(.text+0xd3): undefined reference to fatorial'</cyan>
			
 
				+  <cyan>// <verd>printf</verd>("fat(0)=%d, fat(1)=%d, fat(2)=%d, fat(3)=%d", fatorial(0), fatorial(1), fatorial(2), fatorial(3));</cyan>
			
 
				+  }</pre>
			
 
				+</div>
			
 
				+
			
 
				+<p> 
			
 
				+  Note que o código acima apresenta a linha comentada
			
 
				+  <tt><verd>printf</verd>("fat(0)=%d, fat(1)=%d, fat(2)=%d, fat(3)=%d", fatorial(0), fatorial(1), fatorial(2), fatorial(3));</tt>.
			
 
				+  A razão é que ela resultaria erro, pois a função <i>fatorial</i> foi declarada dentro da função <i>combinacao</i>
			
 
				+  e portanto só pode ser usando (invocada) dentro dessa segunda!
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Uma vez que o uso do cálculo de fatorial é muito comum e pensando que o código acima seria parte de um maior,
			
 
				+  então provavelmente o desenho de código usado não é bom, pois implicaria em precisarmos definir outra função <i>fatorial</i>,
			
 
				+  essa fora do contexto da função <i>combinacao</i>.
			
 
				+  Nesse sentido, poderia ser melhor usar o código (pensando que ele seja o início de um sistema maior) do
			
 
				+  exemplo a seguir.
			
 
				+</p>
			
 
				+
			
 
				+<div class="exemplo"><i>Exemplo 2</i>. Declaração de funções sem aninhamento.
			
 
				+</div><!-- class="exemplo" -->
			
 
				+<div class="codigo"><pre><verm>int</verm> fatorial (<verm>int</verm> n) { <cyan>// fatorial de n (supondo n natural)</cyan>
			
 
				+  <verm>int</verm> i, fat = 1;
			
 
				+  for (i=2; i&lg;=n; i++)
			
 
				+    fat *= i;
			
 
				+  return fat;
			
 
				+  }
			
 
				+
			
 
				+<verm>int</verm> combinacao (<verm>int</verm> n, <verm>int</verm> k) { <cyan>// combinacao de n, k-a-k</cyan>
			
 
				+  return fatorial(n) / (fatorial(k)*fatorial(n-k));
			
 
				+  }
			
 
				+
			
 
				+<verm>void</verm> main (<verm>void</verm>) :
			
 
				+  <verm>int</verm> n = 5, k = 3;
			
 
				+  <verd>printf</verd>("Combinacao %d, %d-a-%d = %d\n", n, k, k, combinacao(n,k));
			
 
				+  <cyan>// Note que agora pode-se invocar 'fatorial()' dentro da 'main'</cyan>
			
 
				+  <verd>printf</verd>("fat(0)=%d, fat(1)=%d, fat(2)=%d, fat(3)=%d", fatorial(0), fatorial(1), fatorial(2), fatorial(3));
			
 
				+  }</pre>
			
 
				+</div>
			
 
				+
			
 
				+<a name="variaveis">
			
 
				+<p class="subsecao">Variáveis globais e locais</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+  Outro conceito importante relacionado com funções é o de declaração de variáveis.
			
 
				+  Assim, uma variável é <b>local</b> se declarada dentro de uma função qualquer, quer dizer,
			
 
				+  essa variável será "conhecida" (poderá ser usada) apenas dentro dessa função.
			
 
				+  Por exemplo, no <i>exemplo 2</i> acima, a variável <i>fat</i> é conhecida apenas dentro da função
			
 
				+  <i>fatorial</i>, portanto seu uso deve-se restringir a esse contexto.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Por outro lado, pode-se usar o mesmo nome para variáveis que estão em contextos distintos.
			
 
				+  Por exemplo, no código do <i>exemplo 1</i>, se fosse necessário poderíamos usar o nome de variável
			
 
				+  local <i>i</i> dentro da função <i>combinacao</i> e não haveria qualquer colisão com a variável
			
 
				+  <i>i</i> de <i>fatorial</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Entretanto é necessário um critério que elimine <i>ambiguidades</i>, isto é, que permita identificar
			
 
				+  unicamente cada uma das variáries. Para isso usa-se o <b>princípio da proximidade</b> (ou da <b>localidade</b>),
			
 
				+  quer dizer, ao usar uma variável considera-se como sua declarção aquela mais próxima.
			
 
				+  Por isso, que poderiamos usar <i>i</i> tanto em <i>combinacao</i>, quanto em <i>fatorial</i>,
			
 
				+</p>
			
 
				+
			
 
				+<center>
			
 
				+  <img src="img/funcoes_var_locais.png" title="imagem ilustrando principio da localidade"/>
			
 
				+  <br/>
			
 
				+  <i>Fig. 1. Imagem de código ilustrando o princípio da localidade, variável <tt>var1</tt> dentro de <tt>funcao2</tt> é a declarada localmente.
			
 
				+</center>
			
 
				+
			
 
				+<p>
			
 
				+  Já uma variável <b>global</b> pode ser acessada em qualquer ponto do código.
			
 
				+  Mas por essa mesma razão deve evitada, sendo necessária apenas para casos excepcionais,
			
 
				+  sempre com um nome significativo, que evite qualquer confusão.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Em <i>C</i>, toda variável declarar fora do contexto de qualquer função, é uma variável <b>global</b>, ou seja, uma variável
			
 
				+  que pode ser acessada em qualquer ponto do código (em qualquer função).
			
 
				+  A ideia de variável global é ilustrado no próximo exemplo.
			
 
				+</p>
			
 
				+
			
 
				+<div class="exemplo"><i>Exemplo 3</i>. Declaração de variável global.
			
 
				+</div><!-- class="exemplo" -->
			
 
				+<div class="codigo"><pre><verm>char</verm> var_global1[] = "essa variavel e' uma variavel global";
			
 
				+
			
 
				+<verm>int</verm> funcao () {
			
 
				+  <verd>printf</verd>("funcao1: var_global1 = %s\n", var_global1);
			
 
				+  }
			
 
				+
			
 
				+<verm>void</verm> main (void) {
			
 
				+  <verd>printf</verd>("main   : var_global1 = %s\n", var_global1); <cyan>// uso da global</cyan>
			
 
				+  funcao();
			
 
				+  }</pre>
			
 
				+</div>
			
 
				+
			
 
				+
			
 
				+<p class="subsecao">Aninhando funções e variáveis locais e globais</p>
			
 
				+
			
 
				+<p>
			
 
				+  Deve-se notar que é possível aninhar tantas funções quantas forem necessárias e o mesmo para variáveis locais.
			
 
				+  O exemplo abaixo ilustra esses aninhamentos e o princípio da proximidade.
			
 
				+  Examine-o com atenção, copie-o em seu computador, utilizando um compilador <i>C</i>
			
 
				+  e altere seu código, compile-o e rode-o até que esteja certo de ter assimilado os conceitos.
			
 
				+</p>
			
 
				+
			
 
				+<div class="exemplo"><i>Exemplo 4</i>. Declaração de variáveis locais, usando globais e aninhamento de funções.
			
 
				+</div><!-- class="exemplo" -->
			
 
				+
			
 
				+<div class="codigo"><pre style="font-size:0.8em;">#include &lt;stdio.h&gt;
			
 
				+
			
 
				+<verm>char</verm> glob1[] = "glob1: variavel global, conhecida em qualquer local";
			
 
				+
			
 
				+<verm>void</verm> funcao1 () {
			
 
				+  <verm>char</verm> loc1[] = "loc1: conhecida apenas dentro da funcao 'funcao1'";
			
 
				+  <verm>char</verm> glob1[] = "funcao1.glob1: declarada dentro de 'funcao1' => uma variavel local `a funcao 'funcao1'";
			
 
				+  <verd>printf</verd>("funcao1: loc1 = %s\n", loc1); <cyan>// note que: pode haver m</cyan>
			
 
				+  <verd>printf</verd>("funcao1: glob1 = %s\n\n", glob1);
			
 
				+  }
			
 
				+
			
 
				+<verm>void</verm> funcao2 (param1) {
			
 
				+  <verm>char</verm> loc1[] = "loc1: conhecida apenas dentro da funcao 'funcao2 - NAO sou a 'funcao1.loc1'!'";
			
 
				+  <verm>char</verm> loc2[] = "loc2: conhecida apenas dentro da funcao 'funcao2'";
			
 
				+  <verm>void</verm> funcao3 () { <cyan>// essa funcao so' e' conhecida dentro de 'funcao2'!</cyan>
			
 
				+    <verm>char</verm> loc1[] = "loc1: conhecida apenas dentro da funcao 'funcao3' - NAO sou a 'funcao1.loc1' e nem a 'funcao2.loc1'!";
			
 
				+    <verm>char</verm> glob1[] = "funcao3.glob1: declarada dentro de 'funcao3' => var. local `a funcao 'funcao3' - NAO e' global 'glob1' e nem 'funcao1.glob1'!";</cyan> <!-- " -->
			
 
				+    <verd>printf</verd>("funcao3: loc1 = %s\n", loc1); <cyan>// note que: e' local com outra com esse nome; "principio do mais proximo" em acao!</cyan>
			
 
				+    <verd>printf</verd>("funcao3: loc2 = %s\n", loc2); <cyan>// note que: e' local `a funcao 'funcao2' - variavel declarada fora de funcao3!</cyan>
			
 
				+    <verd>printf</verd>("funcao3: glob1 = %s\n", glob1);
			
 
				+    }
			
 
				+  <verd>printf</verd>("funcao2: param1 = %s\n", param1);
			
 
				+  <verd>printf</verd>("funcao2: loc1 = %s\n", loc1); <cyan>// note que: e' local com outra com esse nome; "principio do mais proximo" em acao!</cyan>
			
 
				+  <verd>printf</verd>("funcao2: loc2 = %s\n", loc2); <cyan>// note que: e' local</cyan>
			
 
				+  <verd>printf</verd>("funcao2: glob1 = %s\n", glob1);
			
 
				+  <verd>printf</verd>("funcao2: chama funcao3\n\n");
			
 
				+  funcao3();
			
 
				+  <verd>printf</verd>("funcao2: chama funcao1\n\n");
			
 
				+  funcao1();
			
 
				+  }
			
 
				+
			
 
				+<verm>void</verm> main () {
			
 
				+  <verm>char</verm> loc1[] = "loc1: conhecida apenas dentro da funcao 'main'";
			
 
				+  <verd>printf</verd>("main   : loc1 = %s\n", loc1); <cyan>// note que: e' local com outra com esse nome; "principio do mais proximo" em acao!</cyan>
			
 
				+
			
 
				+  <verd>printf</verd>("main   : glob1 = %s\n", glob1);
			
 
				+
			
 
				+  <verd>printf</verd>("main   : chama funcao1\n\n");
			
 
				+  funcao1();
			
 
				+  <verd>printf</verd>("main   : chama funcao2\n\n");
			
 
				+  funcao2("parametro efetivo passado para a funcao 'funcao2'");
			
 
				+
			
 
				+  <cyan>// Atencao: como a funcao 'funcao3' foi declarada dentro da funcao 'funcao2', entao ela so' pode se invocada em 'funcao2'</cyan>
			
 
				+  <cyan>// Por exemplo, a linha abaixo resultaria no erro: sobre_variaveis_global_local.c:(.text+0x4d2): undefined reference to funcao3'</cyan>
			
 
				+  <cyan>// funcao3();</cyan>
			
 
				+  }</pre>
			
 
				+</div>
			
 
				+
			
 
				+
			
 
				+  <p class="autoria">
			
 
				+    <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/15: novo formato, pequenas revisões<br/>
			
 
				+    2020/08/09: formato, revisão geral;<br/>
			
 
				+    2018/05/22: pequenas alterações<br/>
			
 
				+    2018/05/21: pequenas alterações
			
 
				+  </p>
			
 
				+
			
 
				+</div>
			
--- a/c_introducao_leituras.html
+++ b/c_introducao_leituras.html
@@ -0,0 +1,301 @@
 
				+<!--
			
 
				+Introdução à entrada de dados em C
			
 
				+m, n = map(int, raw_input().split());
			
 
				+href: line_introducao_float.html ; line_introducao_char.html
			
 
				+-->
			
 
				+
			
 
				+  <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> <!-- referencia documentos internos -->
			
 
				+<div class="pagina">
			
 
				+
			
 
				+
			
 
				+<!--
			
 
				+declaracao
			
 
				+io_simples
			
 
				+ex_io_simples
			
 
				+io_composto
			
 
				+-->
			
 
				+
			
 
				+<a name="declaracao">
			
 
				+<p class="secao">Qual a diferença entre <i>declarar</i> e usar uma variável?</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+  Uma <a href=#" onclick="trocaPagina('introducao_var.html#declaracao')" "introducao_var.html#declaracao" title="ver explicacao">variável</a>
			
 
				+  nada mais é que um nome associado à uma posição de <i>memória</i> do computador:
			
 
				+  a posição de seu <i>bit</i> inicial e o número de <i>bits</i> usados para representar aquele tipo de variável.
			
 
				+  Como a linguagem <i>C</i> é <b style="color:#0000aa" title="Necessário traduzir tudo para linguagem da máquina">compilada</b>,
			
 
				+  nela é necessário <b style="color:#0000aa" title="Reservar espaço na memória e associar esse espaço a um nome">declarar</b> cada variável
			
 
				+  e isso (geralmente) é feito no início da função.
			
 
				+  Uma vez que variável foi declarada, pode-se usá-la (recebendo valores ou em expressões).
			
 
				+  <pre style="font-size:0.9em"><verm>int</verm> main (<verm>void</verm>) {
			
 
				+  <verm>int</verm> n, i=0; <cyan>// declara 2 variaveis para inteiro de nome 'n' e 'i' (i sendo iniciada com valor 0)</cyan>
			
 
				+  <verm>float</verm> x = 0.5, y; <cyan>// declara 2 variaveis para inteiro de nome 'x' e 'y' (x sendo iniciada com valor 0.5)</cyan>
			
 
				+  ...
			
 
				+  }</pre>
			
 
				+  <i>Cód. 1. Código ilustrando a declaração de variáveis inteiras e flutuantes.</i>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Outro conceito essencial às variáveis é o de
			
 
				+  <b style="color:#0000aa" title="Alterar o valor guardado pela variável">atribuição</b> de valor.
			
 
				+  Sua sintaxe em <i>C</i>, e em muitas outras linuguagens, é usar do
			
 
				+  <b style="color:#0000aa" title="lado esquerdo da atribuição">lado esquerdo</b> da atribuição um nome de variável e do
			
 
				+  <b style="color:#0000aa" title="lado direito da atribuição">lado direito</b> da atribuição uma expressão aritméitca válida.
			
 
				+  No código 1, <tt>i=0</tt> e <tt>x=0.5</tt> são atribuições, tendo como <i>lado esquerdo</i> as variáveis <i>i</i> e <i>x</i>
			
 
				+  e como <i>lado direito</i> as expressões constantes <i>0</i> e <i>0.5</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Ainda usando como estrutura o código 1, outro exemplo de atribuição poderia ser <tt>i = n/2</tt>, que tem como
			
 
				+  <i>lado direito</i> a expressão <i>n/2</i>.
			
 
				+  Como no código 1 a variável <i>n</i> é do tipo inteiro, o mesmo para a constante <i>2</i> (se desejasse <i>flutuante</i> deveria usar <i>2.0</i>),
			
 
				+  então seu resultado é o <b style="color:#00aa00" title="a/b = q &#8658; q é o quociente">quociente da divisão inteira da divisão</b>.
			
 
				+  Mas vale adiantar outra possibilidade de "forçar" o resultado a ser <i>flutuante</i>, usar o coversor de tipo:
			
 
				+  <tt style="color:#00aa00" title="o valor de n é convertido para float, daí o restante da conta usa flutuante">x = (<verm>float</verm>)n/2</tt>.
			
 
				+  <!--
			
 
				+   &#11013; black left arrow
			
 
				+   &#11013; black right arrow
			
 
				+   &#8658;  Rightwards Double Arrow
			
 
				+  -->
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  A figura 1 ilustra a associação de espaço em memória (<i>RAM</i>) para duas variáveis,
			
 
				+  são associados 16 <i>bits</i> à variável de nome <i>n</i> para valores inteiros, seguido da associação de
			
 
				+  32 <i>bits</i> para a variável de nome <i>x</i>, que deve guardar valores "reais".
			
 
				+  Nota-se que a variável "real" tem um esquema mais "complicado", ela implementa o conceito
			
 
				+  de <a href="#" onclick="trocaPagina('introducao_float.html')" title="clique aqui para estudar ponto flutuante" targe="_blank">ponto flutuante</a>,
			
 
				+  usando o padrão 
			
 
				+  <a href="https://en.wikipedia.org/wiki/Integer_%28computer_science%29" title="ler a respeito IEEE 754 na WikiPedia" target="_blank">
			
 
				+  IEEE 754</a> (o primeiro <i>bit</i> é o sinal <i>s</i>; os 8 <i>bits</i>
			
 
				+  seguintes correspondente ao expoente <i>e</i> e os últimos 23 à mantissa <i>m</i> - valor de <i>x</i> é s x m x 10<sup>e</sup>, sendo
			
 
				+  <i>m</i> entre 0 e 1).
			
 
				+</p>
			
 
				+
			
 
				+<center><img src="img/var_memoria1.jpg" title="Ilustracao de inteiro de 16 bits e do modelo float IEEE 754 com 32 bits em memoria"/>
			
 
				+<br/>
			
 
				+<i>Fig. 1. Representação da memória com agrupamentos em <i>bytes</i> (8 <i>bits</i>).</i>
			
 
				+</center>
			
 
				+
			
 
				+<!--
			
 
				+https://en.wikipedia.org/wiki/Integer_%28computer_science%29
			
 
				+int = -32,768 to 32,767, from -(2^15) to 2^15-1 
			
 
				+https://en.wikipedia.org/wiki/Single-precision_floating-point_format
			
 
				+  float = 32 bits
			
 
				+  IEEE 754 single-precision binary floating-point format: binary32
			
 
				+  Sign bit: 1 bit ; Exponent width: 8 bits ; Significand precision: 24 bits (23 explicitly stored)
			
 
				+  float = 0/1 0.mantissa x 10^e
			
 
				+              24 bits      8
			
 
				+-->
			
 
				+
			
 
				+
			
 
				+<a name="io_simples">
			
 
				+<p class="secao">O que são "entradas de dados" e "saídas de dados"?</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+  Um <b>algoritmo</b> é uma sequência finita de passos, que ao ser aplicado à um conjunto de dados (<b>entradas</b>) deve produzir sempre as mesmas
			
 
				+  <b>saídas</b>.
			
 
				+  Por exemplo, o algoritmo da divisão ao ser aplicado sobre valores fixados <i>a</i> e <i>b</i>, deve
			
 
				+  produzir sempre o mesmo valor <i>q</i> (de tal forma que <i>q * b = a</i>).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Por outro lado, um 
			
 
				+  <b style="color:#0000aa" title="um algoritmo implementado em alguma linguagem">programa</b>, em <i>C</i> ou em qualquer outra linguagem,
			
 
				+  nada mais é que a implementação de um <b>algoritmo</b> na referida linguagem.
			
 
				+  Desse modo, para este programa ser usado, o
			
 
				+  <b style="color:#0000aa" title="quem usa o programa">usuário</b> (aquele que está executando) deve fornecer um conjunto de 
			
 
				+  <b>dados de entrada</b>, na ordem adequada (pois <i>a/b</i> geralmente não é o mesmo que <i>b/a</i>), para que o
			
 
				+  programa possa ser executado e produzir as <b>saída</b> desejadas.
			
 
				+</p>
			
 
				+
			
 
				+<center><img src="img/img_computador_io.png" title="ilustracao processamento entradas x saidas"/>
			
 
				+<br/><i>Fig. 2. Ilustração da existência de um algoritmo que aplicado sobre as entradas produz as respectivas saídas.</i>
			
 
				+</center>
			
 
				+
			
 
				+<p>
			
 
				+  Podemos usar o mesmo exemplo da divisão para ilustar a necessidade dos <i>dados de entrada</i> adequados.
			
 
				+  Para que um algoritmo para a divisão de dois números reais seja adequadamente executado,
			
 
				+  devem ser fornecidos os dois valores reais, o primeiro será o
			
 
				+  <b style="color:#0000aa" title="em a/b &#8658; parte de cima é o numerador &#8658; a é o numerador">numerador</b> e o segundo será o
			
 
				+  <b style="color:#0000aa" title="em a/b &#8658; parte de baixo é o denominador &#8658; b é o denominador">denominador</b>.
			
 
				+  Assim, se o <i>usuário</i> digitar apenas um valor, o programa ficará parado até
			
 
				+  <!--  &#8658; = Rightwards Double Arrow -->
			
 
				+  que ele digite o segundo valor.
			
 
				+</p>
			
 
				+
			
 
				+<sabermais title="para saber um pouco mais">
			
 
				+  Vale observar que, usando uma linguagem como <i>C</i>, não existe a necessidade de implementar algo tão básico (a <i>divisão</i>, pois
			
 
				+  isso é feito por um algoritmo implementado no processador do computador.
			
 
				+  Na verdade, desde a proposta inicial do matemática
			
 
				+  <a href="https://en.wikipedia.org/wiki/John_von_Neumann" target="_blank" title="Examinar a página sobre John von Neumann na WikiPedia em Inglês"
			
 
				+  >John von Neumann</a>, existe uma
			
 
				+  <a href="https://en.wikipedia.org/wiki/Arithmetic_logic_unit" target="_blank" title="Examinar a página ULA na WikiPedia em Inglês"
			
 
				+  ><b style="color:#0000aa">unidade lógico/aritmética</b></a> especialmente projetada para realizar as
			
 
				+  operações lógicas e aritméticas.
			
 
				+  Embora, o modelo inicialmente proposto por <i>von Neumann</i> preconizase o uso de
			
 
				+  <i>ponto fixo</i>, não o <i>flutuante</i>.
			
 
				+</sabermais>
			
 
				+<br/>
			
 
				+
			
 
				+
			
 
				+<a name="ex_io_simples">
			
 
				+<p class="secao">Saídas de dados simples: inteiro, real e texto em <i>C</i></p>
			
 
				+</a>
			
 
				+<!-- ./introducao/codigos/testes/teste_input.c -->
			
 
				+
			
 
				+<p>
			
 
				+  A linguagem <i>C</i> preconiza o uso de <b style="color:#00aa00">formatador</b> para cada tipo de variável, tanto
			
 
				+  para as <i>entradas</i> quanto para as <i>saídas</i>.
			
 
				+  Os formatadores básicos são:
			
 
				+  <center><i>Tab. 1. Formatadores de acordo com tipo, com exemplo para entra e para saída em <i>C</i></i><br/>
			
 
				+<table class="tableCode thBg">
			
 
				+ <tr>
			
 
				+   <th class="thBg" >Tipo de variável</th><th class="thBg" >Tipo em <i>C</i></th>
			
 
				+   <th class="thBg" >Leitura</th><th class="thBg" >Impressão</th></tr>
			
 
				+  <tr>
			
 
				+ <tr>
			
 
				+   <td>Inteiro</td><td class="code"><verm>int</verm> a, b;</td>
			
 
				+   <td class="code"><verd>scanf</verd>("%d %d", &a, &b);</td><td class="code"><verd>printf</verd>("%d %d\n", a, b);</td></tr>
			
 
				+ <tr>
			
 
				+   <td>Caractere</td><td class="code">char a, b;</td>
			
 
				+   <td class="code"><verd>scanf</verd>("%c %c", &a, &b);</td><td class="code"><verd>printf</verd>("%c %c\n", a, b);</td></tr>
			
 
				+ <tr>
			
 
				+   <td>Flutuante</td><td class="code"><verm>float</verm> a, b;</td>
			
 
				+   <td class="code"><verd>scanf</verd>("%f %f", &a, &b);</td><td class="code"><verd>printf</verd>("%f %f\n", a, b);</td></tr>
			
 
				+ <tr>
			
 
				+   <td>Duplo</td><td class="code">double a, b;</td>
			
 
				+   <td class="code"><verd>scanf</verd>("%lf %lf", &a, &b);</td><td class="code"><verd>printf</verd>("%lf %lf\n", a, b);</td></tr>
			
 
				+</table></center>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Em <i>C</i> a conversão entre inteiros e caracteres é direta, basta trocar o formatador.
			
 
				+  Isso é possível devido à conversão inteiro-binário e binário-caractere.
			
 
				+  Para isso utiliza-se a primeira tabela de representação de caracteres que se popularizou, a tabela
			
 
				+  <b style="color:#00aa00" title="American Standard Code for Information Interchange: código de 8 bits para caracteres">ASCII</b>.
			
 
				+  Para saber mais consulte o texto
			
 
				+  <a href="#" onclick="trocaPagina('introducao_char.html')" title="seguir para introdução aos caracteres">introdutório sobre caracteres</a>.
			
 
				+  Na tabela 1, o código à esquerda ilustra como testar a tabela <i>ASCII</i>.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<!-- ∑ N-Ary Summation
			
 
				+     HTML-code:      &#8721; -->
			
 
				+<!-- ./introducao/codigos/introducao_leituras_c.c -->
			
 
				+<p>
			
 
				+<center><i>Tab. 1. Exemplo de códigos para entrada e saída de inteiros e "reais" para o C 2</i><br/>
			
 
				+<table class="tableCode thBg">
			
 
				+ <tr>
			
 
				+   <th>Exemplo de tabela
			
 
				+       <b style="color:#00aa00" title="American Standard Code for Information Interchange: código de 8 bits para caracteres">ASCII</b></th>
			
 
				+   <th>Exemplo de tabela numérica &#8721;<sub>i=0</sub><sup>10</sup> 0.5<sup>i</sup></th></tr>
			
 
				+ <tr>
			
 
				+   <td><pre style="font-size: 0.8em;">#include &lt;stdio.h&gt;
			
 
				+
			
 
				+<verm>void</verm> main (<verm>void</verm>) {
			
 
				+  <verm>int</verm> i;
			
 
				+  <verd>printf</verd>("Int | ASCII\n");
			
 
				+  for (i=48; i<91; i++) {
			
 
				+    <verd>printf</verd>(" %2d |  '%2c'\n", i, i);
			
 
				+    <cyan>// "Pular" os caracteres:</cyan>
			
 
				+    if (i==57) <cyan>// 58=':' 59=';' 60='<' 61='='</cyan>
			
 
				+      i = 64;  <cyan>// 62='>' 63='?' 64='@'</cyan>
			
 
				+    }
			
 
				+  }</pre></td>
			
 
				+  <td><pre style="font-size: 0.8em;">#include &lt;stdio.h&gt;
			
 
				+<verm>void</verm> main (<verm>void</verm>) {
			
 
				+  <verm>float</verm> soma = 0, pot = 1;
			
 
				+  <verm>int</verm> i;
			
 
				+  <verd>printf</verd>("Int | Soma 0.5^0+...+0.5^i\n");
			
 
				+  for (i=0; i<11; i++) {
			
 
				+    soma += pot;
			
 
				+    <verd>printf</verd>(" %2d |             %8.2f\n", i, soma);
			
 
				+    pot *= 0.5 * pot;
			
 
				+    }
			
 
				+  }</pre></td></tr>
			
 
				+</table></center>
			
 
				+</p>
			
 
				+
			
 
				+<p>  
			
 
				+  Se o <i>usuário</i>
			
 
				+  desejar inserir outra coisa (em geral uma <i>cadeia de caracteres</i> - "<i>string</i>")
			
 
				+  deve-se usar uma função especial (vide <tt>raw_input</tt> a seguir).
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="io_composto">
			
 
				+<p class="secao">Entradas de dados em <i>C</i></p>
			
 
				+</a>
			
 
				+<!-- ./introducao/codigos/testes/teste_input.py -->
			
 
				+
			
 
				+<p>
			
 
				+  Em <i>C</i> o processo para <i>leitura</i> de valores via teclado é tratado em <i>lote</i>, quer dizer,
			
 
				+  durante a execução de um programa, a cada momento que o usuário <i>digitar</i> uma sequẽncia de valores e pressionar
			
 
				+  a tecla para registro (<i>Enter</i>), todos os valores digitados serão armazenador em um <i>reservatório</i>
			
 
				+  (em Inglês <i>buffer</i>) e a cada momento que o programa encontrar um comando para <i>leitura</i> será usado a
			
 
				+  próxima parte disponível do <i>reservatório</i>.
			
 
				+  <br/>
			
 
				+  Para verficar a existência do <i>reservatório</i>, experimente testar o código 2, de dois modos:
			
 
				+  <ol>
			
 
				+  <li> digitando todos os valores e um único <i>Enter</i> (<tt>CR</tt>) ao final (i.e. algo como
			
 
				+    <tt style="color:#00aa00" title="digitar '2 3 ABD D E 0.5 2.3' (sem apóstrofe) e teclar Enter">2 3 ABD D E 0.5 2.3 CR</tt>)
			
 
				+    </li>
			
 
				+  <li> digitando cada um dos 9 itens teclando <i>Enter</i> em diferentes locais
			
 
				+    (e.g. como:
			
 
				+    <tt style="color:#00aa00" title="digitar '2' depois CR, '3' depois CR, 'ABD' depois CR e assim por diante"
			
 
				+        >2 CR 3 CR ABD CR D CR E CR 0.5 CR 2.3 CR</tt>).
			
 
				+    </li>
			
 
				+  </ol>
			
 
				+  Você deverá notar que em ambos os modos todos os valores serão corretamente capturados, com qualquer variação de <i>Enter</i>
			
 
				+  (<tt>CR</tt>)
			
 
				+  <i style="color:#00aa00" title="Por exemplo, não é adequado teclar CR no meio do '0.5', ou seja, não pode ser '0. CR 5'">adequado</i>,
			
 
				+  os valores serão armazenados nas variáveis <i>i1, i1, c1, c2, c3, c4, c5, x</i> e <i>y</i> da mesma forma.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+<center><i>Tab. 2. Exemplo de código para entrada de valors, caracteres e "reais"</i><br/>
			
 
				+<table class="tableCode thBg">
			
 
				+ <tr>
			
 
				+   <th>Exemplo de código para entrada em <i>C</i></th></tr>
			
 
				+ <tr>
			
 
				+   <td><pre style="font-size: 0.8em;">#include &lt;stdio.h&gt;
			
 
				+<verm>void</verm> main (<verm>void</verm>) {
			
 
				+  <verm>float</verm> x, y;
			
 
				+  <verm>int</verm> i1, i2;
			
 
				+  char c1, c2, c3, c4, c5;                  
			
 
				+  <verd>printf</verd>("Digite 9 itens, separados por espaco em branco (2 int, 5 char, 2 float): "); <cyan>// neste ordem: inteiro, inteiro</cyan>
			
 
				+  <verd>scanf</verd>("%d %d %c %c %c %c %c %f %f", &i1, &i2, &c1, &c2, &c3, &c4, &c5, &x, &y);
			
 
				+  <cyan>// Experimente comentar a linha acima e testar com variacoes como abaixo (sera igual)</cyan>
			
 
				+  <cyan>// <verd>scanf</verd>("%d %d", &i1, &i2);</cyan>
			
 
				+  <cyan>// <verd>scanf</verd>("%c %c %c %c %c", &c1, &c2, &c3, &c4, &c5);</cyan>
			
 
				+  <cyan>// <verd>scanf</verd>("%f %f", &x, &y);</cyan>
			
 
				+  <verd>printf</verd>("i1=%d, i2=%d, c1=%c, c1=%c, c1=%c, c1=%c, c1=%c, x=%f, y=%f\n", i1, i2, c1, c2, c3, c4, c5, x, y);
			
 
				+  }</pre></td></tr>
			
 
				+</table></center>
			
 
				+</p>
			
 
				+
			
 
				+<p>  
			
 
				+  Experimente copiar e colar cada um dos códigos acima em seu ambiente para programação <i>C</i> preferido.
			
 
				+  Procure alterar o código até que esteja certo de ter assimilado a sintaxe e os detalhes de cada conceito aqui explorado.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+
			
 
				+<p class="autoria">
			
 
				+ <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/17: primeira versão do texto
			
 
				+</p>
			
 
				+
			
 
				+</div>
			
--- a/c_introducao_vetores.html
+++ b/c_introducao_vetores.html
@@ -0,0 +1,486 @@
 
				+<!--
			
 
				+ Introdução à Programação - 2017 - Prof. Leoônidas de Oliveira Brandão
			
 
				+ Introdução aos vetores em C
			
 
				+ 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 aos vetores em <i>C</i></p>
			
 
				+
			
 
				+<p>
			
 
				+  Como explicado no
			
 
				+  <a href="#" onclick="trocaPagina('introducao_vetores.html')" title="introducao aos vetores">texto introdutório ao conceito de vetores</a>,
			
 
				+  um vetor é uma sequência de dados ocupando posições consecutivas de memória e por isso existe uma ordem
			
 
				+  natural entre seus elementos, o primeiro elemento, o segundo e assim por diante.
			
 
				+  A grande vantagem de usar vetor é poder trabalhar com muitas variáveis utilizando um único
			
 
				+  nome para esse "agregado" de variáveis.
			
 
				+  Para isso existe uma sintaxe especial para pegar cada elemento do vetor, em posições específicas, como o primeiro elemento ou o décimo elemento.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  A linguagem <i>C</i> trata o conceito de vetor de um modo bastante próximo ao modo como é possível implementar esse conteito.
			
 
				+  Ilustraremos isso mostrando que podemos usar
			
 
				+  <i><a href="#" onclick="trocaPagina('introducao_apontadores_c.html')" title="ver apontadores em C">apontadores</a></i> para pegar elementos dos
			
 
				+  vetores.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<bloco1>Neste texto:
			
 
				+   <a class="" title="definir e imprimir um vetor" href="#define">definir/imprimir vetor</a>;
			
 
				+   <a class="" title="definir e imprimir string" href="#string">definir "string"</a>;
			
 
				+   <a class="" title="funcoes da biblioteca string.h" href="#strcmp">funções para "string"</a>;
			
 
				+   <a class="" title="vetor e apontadores" href="#apontador">vetor e apontador</a>;
			
 
				+   <a class="" title="definir e imprimir uma matriz" href="#matriz">definir/imprimir matriz</a>;
			
 
				+   <a class="" title="trabalhr com vetor/matriz dinamica (via apontador)" href="#dinamica">vetor/matriz dinâmicas</a>.
			
 
				+</bloco1>
			
 
				+
			
 
				+
			
 
				+<!-- secao -->
			
 
				+<a name="define">
			
 
				+<p class="secao">1. Definindo e imprimindo um vetor</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+  Pode-se construir um vetor em <i>C</i> fornecendo todos seus elementos, como em:
			
 
				+  <tt><verm>int</verm> vet[] = {21, 22, 23, 24};</tt>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+   Pode-se também construir de modo "dinâmico", dependendo dos valores que variáveis assumem em meio ao código.
			
 
				+   Para isso deve-se declarar o máximo de posições que o vetor ocupará (como <tt><def>#define</def> MAX 10 ... <verm>int</verm> vet[MAX];</tt>)
			
 
				+   e depois define-se cada elemento, por exemplo, usando um comando de atribuição, como:
			
 
				+  <tt>vet[i] = 10+i;</tt>, que define o valor do elemento na posição <i>i</i> como o valor <tt>10+i</tt>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  No exemplo a seguir construímos um vetor com <i>MAX</i> elementos,
			
 
				+  iniciando no <i>10+i</i> e seguindo até o <i>10+n-1</i>.
			
 
				+  Nesse exemplo indicamos, em um comentário, como usar apontador (<i>*(v+i)=10+i</i>) para definir os elementos de um vetor
			
 
				+  (usando <i>aritmética de ponteiros</i>).
			
 
				+</p>
			
 
				+
			
 
				+<div class="exemplo"><i>Exemplo 1</i>. Construir um vetor e imprimir seus elementos.
			
 
				+</div><!-- class="exemplo" -->
			
 
				+<div class="codigo">
			
 
				+  <pre><incl1>#include</incl1> &lt;stdio.h&gt;
			
 
				+// Declarar uma constante (para ser usada como dimensao maxima do vetor)
			
 
				+<def>#define</def> MAX  10
			
 
				+
			
 
				+// Funcao para imprimir elementos de vetor em uma mesma linha
			
 
				+// Nao precisa saber do total alocado para o vetor efetivo, pois para pegar o elemento i basta 
			
 
				+// saber a primeira posicao, digamos 'apont' e pegar '*(apont + i)'
			
 
				+<verm>void</verm> imprime_vetor1 (<verm>int</verm> vet[], <verm>int</verm> tam) {
			
 
				+  <verm>int</verm> i;
			
 
				+  for (i=0; i&lt;tam; i++)
			
 
				+    <verd>printf</verd>("%d ", vet[i]);
			
 
				+  <verd>printf</verd>("\n"); <cyan>// ao final quebre a linha</cyan>
			
 
				+  }
			
 
				+
			
 
				+// Esta funcao define os valores para o vetor (passagem por referencia/endereco)
			
 
				+// Lembrando: todo vetor e' passado por referencia 'a funcao (logo
			
 
				+// alterar seus valores localmente implica em alterar os valores do
			
 
				+// parametro efetivo!
			
 
				+// Por ser vetor como parametro, nao precisa declarar a dimensao (nao precisa reservar espaco, e' apenas uma referencia)
			
 
				+// Mas se fosse matriz precisaria saber dimensao coluna
			
 
				+<verm>void</verm> definirVetor (<verm>int</verm> v[], <verm>int</verm> tam) {
			
 
				+  <verm>int</verm> i;
			
 
				+  for (i=0; i&lt;tam; i++) <cyan>// definir vetor/lista com: (10,11,12,13,...10+n-1)</cyan>
			
 
				+    v[i] = 10+i; <cyan>// Aqui altera' o 'parametro efetivo'! Tambem pode-se usar como apontador: *(v+i) = 10+i;</cyan>
			
 
				+  }
			
 
				+
			
 
				+<verm>int</verm> main (<verm>void</verm>) {
			
 
				+  <verm>int</verm> n=10, vet[MAX];    <cyan>// alocar MAX posicoes para o vetor 'vet' (pode-se usar menos)</cyan>
			
 
				+
			
 
				+  definirVetor(vet, n); <cyan>// parametro efetivo 'vet' por ser vetor, se alterado na funcao, altera o efetivo!</cyan>
			
 
				+
			
 
				+  <cyan>// Imprime o vetor/lista de uma so' vez (na mesma linha)</cyan>
			
 
				+  <verd>printf</verd>("\nO vetor: ");
			
 
				+  imprime_vetor1(vet, n); <cyan>// em C NAO e' possivel imprimir todos os dados de um vetor => fazer uma funcao...</cyan>
			
 
				+  return 0;
			
 
				+  }</pre>
			
 
				+</div><!-- class="codigo" -->
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+  <b>Importante</b>.
			
 
				+  Em <i>C</i>, usar um <i>vetor como parâmetro (formal) em função</i> implica que esta usando <b>passagem por referência (ou endereço)</b>!
			
 
				+  <br/>
			
 
				+  Portanto, dentro da função, se alterar o valor de qualquer elemento do vetor (<i>parâmetro formal</i>), isso implicará que, durante a execução,
			
 
				+  o seu <i>parâmetro efetivo</i> (aquele que é <i>passado efetivamente</i> para função) terá o elemento correspondente alterado.
			
 
				+  Por este motivo, no exemplo acima, ao fazer uma atribuição dentro da função (<tt>v[i] = 10+i;</tt>), estamos na verdade
			
 
				+  alterando os valores do <i>parâmetro efetivo</i> <tt>vet</tt>,
			
 
				+  por esse motivo usamos o nome <b style="color:#0000aa">passagem por referência (ou endereço)</b>,
			
 
				+  é como se o <i>parâmetro formal</i> <tt>v[]</tt> fosse uma <b>referência</b> (um "apelido") para o <i>parâmetro efetivo</i> <tt>vet[]</tt>.
			
 
				+  <br/>
			
 
				+  Se tiver dúvidas, 
			
 
				+  <a href="#" onclick="trocaPagina('introducao_parametros_funcoes.html')" title="examine o texto sobre parametros de funcoes">reveja o texto sobre
			
 
				+  parâmetros de funções</a>.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<!-- secao -->
			
 
				+<a name="string">
			
 
				+<p class="secao">2. Defininido uma <i>cadeia de caracteres</i> ("string")</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+  Em <i>C</i> é possível definir um vetor com caracteres, formando uma palavra, ou seja, uma <i>cadeia de caracteres</i>,
			
 
				+  que abreviadamente é denominada "<i>string</i>".
			
 
				+  Para isso pode-se fazer uma atribuição como constante ou ler os dados como palavra. Isso é ilustrado no exemplo abaixo.
			
 
				+</p>
			
 
				+
			
 
				+<div class="exemplo"><i>Exemplo 2</i>. Trabalhando com "strings". Uma "string" fixa e digitar uma frase, imprimindo o número
			
 
				+  de caracteres nela.
			
 
				+</div><!-- class="exemplo" -->
			
 
				+<div class="codigo">
			
 
				+<pre><incl1>#include</incl1> &lt;stdio.h&gt;
			
 
				+<incl1>#include</incl1> &lt;string.h&gt; <cyan>// para usar a funcao 'strlen(...)'</cyan>
			
 
				+<verm>void</verm> main (<verm>void</verm>) {
			
 
				+  <verm>int</verm> i;
			
 
				+  <verm>char</verm> string[] = "0123456789abcdefghih"; <cyan>// (1) - define a "string"</cyan>
			
 
				+  <cyan>// Imprimir cada caractere da string com seu codigo ASCII</cyan>
			
 
				+  <verd>printf</verd>("Imprime caracteres e seus codigos ASCII na forma de tabela\nColuna 1 => caractere; coluna 2 => seu codigo ASCII\n"); <!--" -->
			
 
				+  for (i=0; i&lt;strlen(string); i++)
			
 
				+    <verd>printf</verd>("%20c : %3d\n", string[i], string[i]); <cyan>// em C inteiro pode ser "lido" como caractere e vice-versao (via codigo ASCII)</cyan>
			
 
				+  <cyan>// Pode-se imprimir como uma frase toda usando o formatador %s</cyan>
			
 
				+  <verd>printf</verd>("Frase: %s\n", string);
			
 
				+  <cyan>// A string tem 20 caracteres, testando os caracteres 19 'h' e 20 '\n'</cyan>
			
 
				+  <verd>printf</verd>("A string tem 20 caracteres, testando os caracteres 19 '%c' e 20 '\\n' em ASCII=%d\n", string[19], string[20]);
			
 
				+  }</pre>
			
 
				+</div><!-- class="codigo" -->
			
 
				+
			
 
				+<p>
			
 
				+  Deve-se notar que em <i>C</i>, ao fazer a leitura de uma "string" (por exemplo, via teclado com <tt><verd>scanf</verd>("%s", &string);</tt>),
			
 
				+  automaticamente é inserido o caractere '\0' ao final da "string".
			
 
				+  Assim, no exemplo acima ao declarar a "string" com o comando
			
 
				+  <tt><verm>char</verm> string = "0123456789abcdefghih";</tt>, essa terá 20 caracteres "úteis" (a última posição "útil" será a posição 19,
			
 
				+  com o caractere 'h') e na posição 20 existirá o caractere '\0' (cujo código ASCII é o zero - 0).
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<!-- secao -->
			
 
				+<a name="apontador">
			
 
				+<p class="secao">3. Vetores e apontadores</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+  Uma vantagem didática da utilização da linguagem <i>C</i> em um curso introdutório de programação é que
			
 
				+  essa é uma linguagem que não esconde muitos detalhes de como os conceitos são implementados.
			
 
				+  Isso possibilita mostrarmos os fundamentos da computação, os
			
 
				+  princípios elementares que permitem a construção de sistemas mais sofisticados.
			
 
				+  Nesse sentido o conceito de vetor é ilustrativo, pois sua implementação depende da existência de apontadores.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Ao declarar um vetor, significa que associamos um nome de variável (o "nome do vetor") a uma sequência de
			
 
				+  posições de memória, todas de mesmo tipo (logo de mesmo tamanho).
			
 
				+  Na verdade essa variável guarda o endereço inicial do vetor, o endereço de seu primeiro elemento.
			
 
				+  <center>
			
 
				+   <img src="img/int_vet_apontador_menor.png" title="representacao de vetor em memoria com indicacao de endereco ocupado"/>
			
 
				+  </center>
			
 
				+</p>
			
 
				+
			
 
				+<p><sabermais title="Para quem deseja saber como funciona">
			
 
				+  Por exemplo, ao declarar o vetor com <tt><verm>int</verm> v[5];</tt>, são reservadas 5 posições de memória, cada uma com o número de <i>bytes</i>
			
 
				+  suficientes para armazenar um dado do tipo <i>int</i> (cada <i>int</i> geralmente ocupa 2 <i>bytes</i> ou 16 <i>bits</i>).
			
 
				+  Vamos supor que <i>sizeof(int)</i> devolve o número de <i>bytes</i> ocupados por qualquer número inteiro
			
 
				+  (essa função existe precisamente com este sentido na biblioteca <tt>stdlib.h</tt>).
			
 
				+  Assim, se o primeiro elemento do vetor está na posição de memória <i>X</i>, então o endereço do segundo será <i>X+sizeof(int)</i> e assim
			
 
				+  por diante até o último desses 5 elementos, que estaria na posição <i>X+5*sizeof(int)</i>.
			
 
				+</sabermais></p>
			
 
				+
			
 
				+<p>
			
 
				+  O nome de um vetor em <i>C</i> é na verdade uma variável
			
 
				+  <i><a href="#" onclick="trocaPagina('introducao_apontadores_c.html')" title="ver apontadores em C">apontadora</a></i>
			
 
				+  e esse fato retoma a observação de <i>C</i> não esconder detalhes.
			
 
				+  Além disso a linguagem permite calculemos a posição de um elemento de vetor somando ao seu endereço inicial o número de elementos que
			
 
				+  desejamos pular (e.g. <tt>v+3</tt>).
			
 
				+  Fazendo isso, automaticamente o compilador traduz essa expressão deslocando o número de <i>bytes</i> do tipo envolvido
			
 
				+  e por isso, fazer <tt>v+3</tt>, é o mesmo que pegar o elemento da posição 3 ou <tt>v[3]</tt>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Como a declaração de uma variável apontadora é feita usando um asterisco (como em <tt><verm>int</verm> *apont;</tt>),
			
 
				+  vamos apresentar um código simples que declara um vetor e depois usamos um apontador para mostrar que, com ele, 
			
 
				+  também podemos "passear" por todos os elementos do vetor.
			
 
				+</p>
			
 
				+
			
 
				+<div class="exemplo"><i>Exemplo 3</i>. Construindo um vetor e imprimindo seus elementos via um apontador.
			
 
				+</div><!-- class="exemplo" -->
			
 
				+<div class="codigo">
			
 
				+<pre><incl1>#include</incl1> &lt;stdio.h&gt;
			
 
				+<verm>void</verm> imprimeVetor (<verm>int</verm> *apont, <verm>int</verm> n) {
			
 
				+  <verm>int</verm> i;
			
 
				+  <verd>printf</verd>("Vetor:");            <cyan>// supondo X ser o primeiro endereco em 'apont'</cyan>
			
 
				+  for (i=0; i&lt;n; i++)
			
 
				+    <verd>printf</verd>(" %d", *(apont+i)); <cyan>// pegar elemento na posicao 'X + i*sizeof(int) - isso e' o mesmo que apont[i]</cyan>
			
 
				+  <verd>printf</verd>("\n");
			
 
				+  }
			
 
				+
			
 
				+<verm>int</verm> main (<verm>void</verm>) {
			
 
				+  <verm>int</verm> vet1[] = { 5, 4, 3, 2, 1 }; <cyan>// define vetor com 5 posicoes de 0 ate' 4</cyan>
			
 
				+  <verm>int</verm> *apont;
			
 
				+  <verm>int</verm> N = 5;
			
 
				+  imprimeVetor(vet1, N); <cyan>// passa para "apont" o endereco inicial do vetor</cyan>
			
 
				+  return 0;
			
 
				+  }</pre>
			
 
				+</div><!-- class="codigo" -->  
			
 
				+
			
 
				+<p>
			
 
				+  Assim, também é possível alterar os valores em qualquer posição do vetor a partir do endereço.
			
 
				+  Por exemplo, se fizermos<br/>
			
 
				+  <tt>
			
 
				+  &nbsp; <verm>int</verm> vet1[5], i; <cyan>// no lugar de linha 1 da main</cyan><br/>
			
 
				+  &nbsp; apont = vet1; <cyan>// ou apont = &vet1; ou apont = &vet1[0];</cyan><br/>
			
 
				+  &nbsp; for (i=0; i&lt;5; i++) *(apont+i) = 5-i;</tt><br/>
			
 
				+  geraríamos novamente o vetor <tt>vet1 = { 5, 4, 3, 2, 1}</tt>.
			
 
				+  Experimente!
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+
			
 
				+<!-- secao -->
			
 
				+<p class="secao">4. Funções úteis da biblioteca <i>string.h</i></p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+  A implementação da função <tt>strlen</tt> (que está na biblioteca <tt>string.h</tt>) usa esse fato, a existência de um
			
 
				+  caractere especial que só pode ser utilizado em "string" como finalizador para encontrar o tamanho da "string".
			
 
				+  Assim, se fizer um comando como <tt>string[10] = '\0'; <verd>printf</verd>("%s\n", string);</tt>, será impresso na tela
			
 
				+  <tt>0123456789</tt>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Existem outras funções na biblioteca <tt>string.h</tt>, uma delas é a <tt>strcpy(str1,str2)</tt> que copia o conteúdo da "string"
			
 
				+  <i>str2</i> sobre a <i>str1</i>, desde que a declaração delas seja compatível (ou seja, <i>str2</i> não pode ter mais 
			
 
				+  caracteres do que a declaração inicial de <i>str1</i>).
			
 
				+  Outra função bastante útil é a <tt>strcmp</tt> que compara lexicograficamente (ordem dos dicionários) duas "strings",
			
 
				+  do seguinte modo, o comando <tt>strcmp(str1, str2)</tt> devolve
			
 
				+  <ul>
			
 
				+    <li>negativo, se <i>str1</i> menor lexicograficamente que <i>str2</i></li>
			
 
				+    <li>zero, se <i>str1</i> igual a <i>str2</i></li>
			
 
				+    <li>positivo, se <i>str1</i> maior lexicograficamente que <i>str2</i></li>
			
 
				+  </ul>
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<!-- secao -->
			
 
				+<a name="matriz">
			
 
				+<p class="secao">5. Defininido vetor de vetor (ou matriz)</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+  Uma vez que um vetor/lista é armazenado consecutivamente na memória, então podemos armazenar
			
 
				+  vários vetores também consecutivamente para obter algo que represente (e seja tratado como) uma
			
 
				+  <b style="color:#00aa00">matriz</b>.
			
 
				+  Como na imagem abaixo, em que cada alocamos <i>nl</i> vetores consecutivos na memória, 
			
 
				+  cada vetor com <i>nc</i> posições de memória, desde <tt>vet[0]</tt> até <tt>vet[nc-1]</tt>.
			
 
				+  Assim, podemos ver este agregado de dados como uma matriz <tt>mat[][]</tt>, cuja primeira linha é
			
 
				+  o primeiro vetor e assim por diante. Isso está ilustrado na imagem abaixo.
			
 
				+  <center>
			
 
				+   <img src="img/int_vet_vet_representacao.png" title="representacao matriz e como fica em memoria como vetor de vetor"/>
			
 
				+  </center>   
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Desse modo obtemos uma estrutura com dois índices que pode ser manipulada como uma matriz (como em <i>mat[i][j]</i>).
			
 
				+  No exemplo abaixo ilustramos isso de dois modos, imprimindo as linhas da matriz
			
 
				+  e mostrando que pode-se passar como parâmetro uma linha de matriz para uma função que
			
 
				+  tenha como <i>parâmetro formal</i> um vetor.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<div class="exemplo"><i>Exemplo 4</i>. Construindo matriz como vetor de vetor e ilustrando que cada linha dela
			
 
				+  é um vetor, podendo portanto ser usado para chamar uma função que tem como parâmetro um vetor.
			
 
				+</div><!-- class="exemplo" -->
			
 
				+<div class="codigo">
			
 
				+<pre><incl1>#include</incl1> &lt;stdio.h&gt;
			
 
				+
			
 
				+<def>#define</def> MAXL 10 <cyan>// declarar constantes (para ser usada como dimensoes maximas da matriz)</cyan>
			
 
				+<def>#define</def> MAXC 10
			
 
				+
			
 
				+<cyan>// Funcao que soma elementos no vetor (precisa do numero de elementos no vetor para saber quando parar)</cyan>
			
 
				+<verm>int</verm> soma_linha (<verm>int</verm> linha[], <verm>int</verm> n) { <cyan>// usando como parametro um vetor (NAO precisa da dimensa, explicacao abaixo)</cyan>
			
 
				+  <verm>int</verm> i, soma = 0;
			
 
				+  for (i=0; i&lt;n; i++)
			
 
				+    soma += linha[i];
			
 
				+  return soma;
			
 
				+  }
			
 
				+
			
 
				+<cyan>// Copiar aqui a funcao do exemplo 1: imprime_vetor1</cyan>
			
 
				+
			
 
				+<cyan>// Funcao para imprimir linhas de matriz (linha por linha): usa 'imprime_vetor1(...)' para imprimir uma linha</cyan>
			
 
				+<cyan>// Precisa do numero de colunas pois na pratica os elementos estao em linhas de MAXC elementos</cyan>
			
 
				+<verm>void</verm> imprime_matriz (<verm>int</verm> mat[][MAXC], <verm>int</verm> numLinhas, <verm>int</verm> numColunas) {
			
 
				+  <verm>int</verm> i;
			
 
				+  for (i=0; i&lt;numLinhas; i++)
			
 
				+    imprime_vetor1(mat[i], numColunas); <cyan>// para pegar inicio de 'mat[i]' usa-se o valor de MAX</cyan>
			
 
				+  }
			
 
				+
			
 
				+<verm>void</verm> main (<verm>void</verm>) {
			
 
				+  <verm>int</verm> mat1[MAXL][MAXC]; <cyan>// alocar MAXL*MAXC posicoes para a matriz 'mat1' ('mat1' e' um vetor de vetor)</cyan>
			
 
				+  <verm>int</verm> n = 10, i, j, nl, nc, prim, seg;
			
 
				+
			
 
				+  <cyan>// Vetor de vetor ou matriz</cyan>
			
 
				+  nl = 3; nc = 4;
			
 
				+  for (i=0; i&lt;nl; i++)    <cyan>// foram alocados na memoria MAXL*MAXC</cyan>
			
 
				+    for (j=0; j&lt;nc; j++)  <cyan>// mas usaremos apenas nl*nc</cyan>
			
 
				+      mat1[i][j] = i*nc + j;
			
 
				+
			
 
				+  <cyan>// Pegando o primeiro e segundo elemento da terceira linha de mat1: mat1[2][1]</cyan>
			
 
				+  prim = mat1[2][0]; seg = mat1[2][1]; <cyan>// pegar primeiro e segundo elemento da linha mat1[2]</cyan>
			
 
				+  <verd>printf</verd>("O primeiro e segundo elemento da terceira linha da matriz: %d e %d\n", prim, seg);
			
 
				+
			
 
				+  <cyan>// Imprime a matriz</cyan>
			
 
				+  <verd>printf</verd>("\nA matriz: \n"); <cyan>// informe o que vira impresso a seguir (na mesma linha devido ao parametro end=""</cyan>
			
 
				+  imprime_matriz(mat1, nl, nc);
			
 
				+
			
 
				+  <cyan>// Verifique que cada linha da matriz e' de fato um vetor</cyan>
			
 
				+  <cyan>// Usar a funcao 'somalinha(...)' que soma elementos em vetor</cyan>
			
 
				+  for (i=0; i&lt;nl; i++)
			
 
				+    <verd>printf</verd>("Soma da linha %2d = %3d\n", i, soma_linha(mat1[i], nc)); <cyan>// note que cada linha 'mat1[i]' tem 'nc' elementos uteis</cyan>
			
 
				+  }
			
 
				+</pre>
			
 
				+</div><!-- class="codigo" -->
			
 
				+
			
 
				+
			
 
				+<!-- secao -->
			
 
				+<a name="dinamica">
			
 
				+<p class="secao">6. Defininido vetor de vetor (ou matriz) de modo dinâmico.</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+  Uma vez que um vetor é armazenado consecutivamente na memória, então podemos armazenar
			
 
				+  vetores de modo consecutivo para obter algo que represente (e seja tratado como) <i>matriz</i>.
			
 
				+  Neste caso obtemos uma estrutura com dois índices (como em <i>mat[i][j]</i>).
			
 
				+  No exemplo abaixo ilustramos isso de dois modos, imprimindo as linhas da matriz
			
 
				+  e mostrando que pode-se passar como parâmetro uma linha de matriz para uma função que
			
 
				+  tenha como <i>parâmetro formal</i> um vetor.
			
 
				+</p>
			
 
				+
			
 
				+<div class="exemplo"><i>Exemplo 5</i>. Construindo matriz como vetor de vetor e ilustrando que cada linha dela
			
 
				+  é um vetor, podendo portanto ser usado para chamar uma função que tem como parâmetro um vetor.
			
 
				+</div><!-- class="exemplo" -->
			
 
				+<div class="codigo">
			
 
				+  <pre><incl1>#include</incl1> &lt;stdio.h&gt;
			
 
				+<incl1>#include</incl1> &lt;stdlib.h&gt; <cyan>// para 'malloc' e 'free'</cyan>
			
 
				+
			
 
				+<def>#define</def> MAXL 10 <cyan>// declarar constantes (para ser usada como dimensoes maximas da matriz)</cyan>
			
 
				+<def>#define</def> MAXC 10
			
 
				+
			
 
				+// Copiar aqui a funcao do exemplo 1: imprime_vetor1
			
 
				+
			
 
				+// Funcao para imprimir elementos de vetor em uma mesma linha - usando aritmetica de ponteiro
			
 
				+<verm>void</verm> imprime_vetor2 (<verm>int</verm> *pont, <verm>int</verm> tam) {
			
 
				+  <verm>int</verm> i;
			
 
				+  for (i=0; i&lt;tam; i++)       <cyan>// "*(pont+i)" significa, pegar a posicao do primeiro elemento</cyan>
			
 
				+    <verd>printf</verd>("%d ", *(pont+i)); <cyan>// (em 'linha') e deslocar i posicoes (do tipo 'int')</cyan>
			
 
				+  <verd>printf</verd>("\n"); <cyan>// ao final quebre a linha</cyan>
			
 
				+  }
			
 
				+
			
 
				+// Funcao que soma elementos no vetor: outra versao tratando o vetor como apontador
			
 
				+<verm>int</verm> soma_linha (<verm>int</verm> *linha, <verm>int</verm> n) { <cyan>// usando como parametro apontador para inteiro</cyan>
			
 
				+  <verm>int</verm> i, soma = 0;
			
 
				+  <cyan>// Uma vez que um vetor e' na verdade uma sequencia de posicoes de memoria, C</cyan>
			
 
				+  <cyan>// simplesmente anota o endereco da primeira posicao no nome do vetor 'linha',</cyan>
			
 
				+  <cyan>// por isso e' a mesma coisa que declarar como parametro formal o apontador '<verm>int</verm> *linha'</cyan>
			
 
				+  for (i=0; i&lt;n; i++)
			
 
				+    soma += *(linha + i);
			
 
				+  return soma;
			
 
				+  }
			
 
				+
			
 
				+// Funcao para imprimir linhas de matriz (linha por linha): usa funcao 'imprime_vetor1(...)'
			
 
				+// Precisa do numero de colunas pois na pratica os elementos estao em linhas de MAXC elementos
			
 
				+<verm>void</verm> imprime_matriz (<verm>int</verm> mat[][MAXC], <verm>int</verm> numLinhas, <verm>int</verm> numColunas) {
			
 
				+  <verm>int</verm> i;
			
 
				+  for (i=0; i&lt;numLinhas; i++)
			
 
				+    imprime_vetor2(mat[i], numColunas); <cyan>// para pegar inicio de 'mat[i]' usa-se o valor de MAX</cyan>
			
 
				+  }
			
 
				+
			
 
				+<verm>void</verm> main (<verm>void</verm>) {
			
 
				+  <verm>int</verm> *vet2; <cyan>// declara um apontador para inteiro que depois apontara' para o vetor dinamico</cyan>
			
 
				+  <verm>int</verm> mat1[MAXL][MAXC];   <cyan>// alocar MAX*MAX posicoes para a matriz 'mat1' ('mat1' e' um vetor de vetor)</cyan>
			
 
				+  <verm>int</verm> (*apontador)[MAXC]; <cyan>// declara um apontador para linhas com MAXC elementos, se usar apenas '<verm>int</verm> *apontador',</cyan>
			
 
				+                          <cyan>// '*(apontador[i]+j) = i*nc+j;' poderia resultar advertencia indicada em (1)</cyan>
			
 
				+  <verm>int</verm> n = 10, i, j, nl, nc, prim, seg;
			
 
				+
			
 
				+  <cyan>// Vetor de vetor ou matriz</cyan>
			
 
				+  <cyan>// Definir a amtriz de 2 modos (com indices de matriz ou como apontador)</cyan>
			
 
				+  nl = 3; nc = 4;
			
 
				+  apontador = mat1; <cyan>// pegue o endereco inicial da matriz - (1) se usar "int *apontador", na declaracao</cyan>
			
 
				+                    <cyan>// acima, poderia resultar advertencia: "warning: assignment from incompatible pointer type"</cyan>
			
 
				+  for (i=0; i&lt;nl; i++)
			
 
				+    for (j=0; j&lt;nc; j++) <cyan>// ilustra 2 forma de manipular matriz/vetor</cyan>
			
 
				+      if (j%2) <cyan>// se j impar => definir com indices</cyan>
			
 
				+        mat1[i][j] = i*nc + j;
			
 
				+      else     <cyan>// se j par   => definir com apontador</cyan>
			
 
				+        *(apontador[i] + j) = i*nc + j; <cyan>// deslocar i linhas (i*MAXC) e depois deslocar j elementos</cyan>
			
 
				+
			
 
				+  <cyan>// Pegando o primeiro e segundo elemento da terceira linha de mat1: mat1[2][1]</cyan>
			
 
				+  prim = mat1[2][0]; seg = mat1[2][1]; <cyan>// pegar primeiro e segundo elemento da linha mat1[2]</cyan>
			
 
				+  <verd>printf</verd>("O primeiro e segundo elemento da terceira linha da matriz: %d e %d\n", prim, seg);
			
 
				+
			
 
				+  <cyan>// Imprime a matriz</cyan>
			
 
				+  <verd>printf</verd>("\nA matriz: \n"); <cyan>// informe o que vira impresso a seguir (na mesma linha devido ao parametro end=""</cyan>
			
 
				+  imprime_matriz(mat1, nl, nc);
			
 
				+
			
 
				+  <cyan>// Verifique que cada linha da matriz e' de fato um vetor</cyan>
			
 
				+  <cyan>// Usar a funcao 'somalinha(...)' que soma elementos em vetor</cyan>
			
 
				+  for (i=0; i&lt;nl; i++)
			
 
				+    <verd>printf</verd>("Soma da linha %2d = %3d\n", i, soma_linha(mat1[i], nc)); <cyan>// note que cada linha 'mat1[i]' tem 'nc' elementos uteis</cyan>
			
 
				+
			
 
				+  <cyan>// Agora definindo vetor com tamanho dinamico</cyan>
			
 
				+  n  = 6;
			
 
				+  vet2 = malloc(sizeof(int) * n); <cyan>// aloca dinamicamente n posicoes para inteiros ('Memory ALLOCation')</cyan>
			
 
				+
			
 
				+  <cyan>// Define vetor com n elementos exatamente</cyan>
			
 
				+  for (i=0; i&lt;n; i++)
			
 
				+    *(vet2+i) = 10 + i;
			
 
				+  <cyan>// Imprime o vetor/lista de uma so' vez (na mesma linha)</cyan>
			
 
				+  <verd>printf</verd>("\nO vetor definido via alocacao dinamica: ");
			
 
				+  imprime_vetor1(vet2, n); <cyan>// em C NAO e' possivel imprimir todos os dados de um vetor => fazer uma funcao...</cyan>
			
 
				+
			
 
				+  free(vet2); <cyan>// depois de usar pode-se devolver as posicoes para sistema operacional</cyan>
			
 
				+  }
			
 
				+</pre>
			
 
				+</div><!-- class="codigo" -->
			
 
				+
			
 
				+  <p class="autoria">
			
 
				+    <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/10/20: pequenos acertos léxicos e na introdução da seção 3 (ajuda da Priscila Lima), acerto em comentário no código "Exemplo 2" (ajuda do Felipe C. Lourenço)<br/>
			
 
				+     <!-- Exemplo 2: eliminado 'ord(.)' -->
			
 
				+     2020/08/13: novo formato, pequenas revisões<br/>
			
 
				+     domingo, 17 May 2020, 18:30<br/>
			
 
				+     segunda, 03 May 2018, 16:00
			
 
				+</p>
			
 
				+
			
 
				+</div>
			
--- a/cabecalho_rodape.html
+++ b/cabecalho_rodape.html
@@ -0,0 +1,123 @@
 
				+
			
 
				+<!--
			
 
				+ Introducao `a Programacao - desde 2017 - Prof. Leo^nidas de Oliveira Branda~o
			
 
				+ MATERIAL_PROGRAMACAO
			
 
				+ LInE (Laboratory of Informatics in Education) - http://www.usp.br/line
			
 
				+ IME - USP
			
 
				+ Material dida'tico
			
 
				+ Pode usar livrevemente este material para fins nao comerciais, devendo sempre fazer referencia `a autoria.
			
 
				+ Sugestoes/apontamento são bem vindos: leo@ime.usp.br (favor indicar no assunto "Material de introducao 'a programacao")
			
 
				+ Autoria: Prof. Leo^nidas de Oliveira Branda~o
			
 
				+ http://www.ime.usp.br/~leo
			
 
				+ http://line.ime.usp.br
			
 
				+ http://www.matemtica.br
			
 
				+-->
			
 
				+
			
 
				+<!DOCTYPE html>
			
 
				+<html dir='ltr' xml:lang='pt-br' lang='pt-br'>
			
 
				+ <head>
			
 
				+  <title>MATERIAL_PROGRAMACAO</title>
			
 
				+  <meta http-equiv='Content-Type' content='text/html; charset=UTF-8'>
			
 
				+
			
 
				+  <meta name='keywords' content='mac0122, material, professore, 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/carregar_pagina.js"></script>
			
 
				+  </style>
			
 
				+ </head>
			
 
				+
			
 
				+<body onload="carregar('.html')" class='gecko lang-pt_br'><!-- MATERIAL_PROGRAMACAO: colocar aqui endereco HTML -->
			
 
				+
			
 
				+<div id='page-wrapper'>
			
 
				+
			
 
				+  <header role='banner' class='navbar navbar-full navbar-light bg-faded navbar-static-top'>
			
 
				+    <div class='container-fluid navbar-nav'>
			
 
				+      <a href='index.html' class='navbar-brand' title="Início do material para Introdução à Programação">Introdução</a><!-- botao fundo azul -->
			
 
				+      <!-- user_menu -->
			
 
				+      <div class='usermenu'>
			
 
				+        <div class='menubar' id='action-menu-1-menubar' role='menubar'>
			
 
				+          <a href='http://www.ime.usp.br/~leo' title='seguir para sitio pessoal do autor' role='button'>
			
 
				+           <span class='userbutton'>
			
 
				+             <span class='usertext'>Leônidas de Oliveira Brandão</span>
			
 
				+             <span class='avatars 'avatar current'>
			
 
				+               <img src='css_img_js_conf/icone_leo.png' alt='Imagem de Leônidas de Oliveira Brandão'
			
 
				+                    title='Imagem de Leônidas de Oliveira Brandão' class='userpicture' role='presentation' height='35' width='35'>
			
 
				+             </span>
			
 
				+           </span>
			
 
				+          </a>
			
 
				+        </div>
			
 
				+      </div>
			
 
				+    </div><!-- class='container-fluid navbar-nav' -->
			
 
				+  </header>
			
 
				+
			
 
				+  <div id='page' class='container-fluid'>
			
 
				+
			
 
				+   <header id='page-header' class='row'>
			
 
				+
			
 
				+    <div class='col-xs-12 p-a-1'>
			
 
				+     <div class='card card-block'>
			
 
				+       <h1>Material didático para Introdução à Programação</h1>
			
 
				+       <!-- caminho -->
			
 
				+       <div class='clearfix w-100 pull-xs-left' id='page-navbar'>
			
 
				+        <div class='breadcrumb-nav'>
			
 
				+         <nav role='navigation'>
			
 
				+          <ol class='breadcrumb'>
			
 
				+           <li class='breadcrumb-item'><a href='http://www.ime.usp.br/~leo/'>Página inicial</a></li>
			
 
				+           <li class='breadcrumb-item'><a href='index.html' title='inicio material'>Material de apoio didático</a></li>
			
 
				+          </ol>
			
 
				+         </nav>
			
 
				+        </div>
			
 
				+       </div>
			
 
				+     </div>
			
 
				+    </div><!-- class='col-xs-12 p-a-1' -->
			
 
				+
			
 
				+    <div class='col-xs-12 p-a-1'><!-- class='col-xs-12 p-a-1' -->
			
 
				+     <div class='card'><!-- class='card' -->
			
 
				+       <div class='card-block' id="textoConteudo"><!-- class='card-block' -->
			
 
				+
			
 
				+<!--
			
 
				+<center><p>[
			
 
				+  <a href="#" title=""></a> &nbsp; | &nbsp;
			
 
				+  <a href="#memoria" title=""></a> &nbsp; &nbsp;
			
 
				+ ]</p>
			
 
				+</center>
			
 
				+-->
			
 
				+
			
 
				+<p class="secao">MATERIAL_PROGRAMACAO</p>
			
 
				+
			
 
				+
			
 
				+<!-- Conteudo ............................................... -->
			
 
				+<a href=""
			
 
				+   title="">Se o JavaScript falhar, por favor, clique aqui para ver o conteudo sem cabecalho ou rodapé.</a>
			
 
				+
			
 
				+<!-- Conteudo ............................................... -->
			
 
				+
			
 
				+</div><!-- class='card-block' -->
			
 
				+
			
 
				+  <p class="autoria">
			
 
				+    <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/15: novo formato, pequenas revisões<br/>
			
 
				+  </p>
			
 
				+
			
 
				+  <footer id='page-footer' class='bg-inverse'>
			
 
				+    <div class='container'><div id='course-footer'></div>
			
 
				+      <p class='helplink'>Material didático - Prof. Leônidas de Oliveira Brandão</p>
			
 
				+    </div>
			
 
				+  </footer>
			
 
				+
			
 
				+</div><!-- class='card' -->
			
 
				+</div><!-- class='col-xs-12 p-a-1' -->
			
 
				+
			
 
				+</header><!-- id='page-header' class='row'-->
			
 
				+
			
 
				+</div><!-- id='page' class='container-fluid' -->
			
 
				+
			
 
				+</div><!-- id='page-wrapper' -->
			
 
				+
			
 
				+</body>
			
 
				+</html>
			
--- a/css_img_js_conf/all.css
+++ b/css_img_js_conf/all.css
--- a/css_img_js_conf/carregar_pagina.js
+++ b/css_img_js_conf/carregar_pagina.js
@@ -0,0 +1,43 @@
 
				+/*
			
 
				+ Material didatico: Introducao 'a Programacao
			
 
				+ Prof. Leo^nidas de Oliveira Branda~o
			
 
				+ http://www.ime.usp.br/~leo
			
 
				+ http://line.ime.usp.br
			
 
				+ */
			
 
				+
			
 
				+
			
 
				+// Remover ultima parte da URL atual
			
 
				+function pegarURL () {
			
 
				+  strUrl = window.location.href;
			
 
				+  ind = strUrl.lastIndexOf("/");
			
 
				+  subStrigURL = strUrl.substring(0, ind);
			
 
				+  // alert("carregar_pagina.js: " + subStrigURL);
			
 
				+  return subStrigURL;
			
 
				+  }
			
 
				+
			
 
				+
			
 
				+// Carregar pagina
			
 
				+// ATENCAO: o arquivo 'line_*.html' em sua linha 76: <div class='card-block' id="textoConteudo">
			
 
				+function carregar (pagina) {
			
 
				+  var txtFile = new XMLHttpRequest(); // https://forums.tumult.com/t/importing-content-from-a-text-file-txt/2004/16
			
 
				+  //108       txtFile.open("GET", "http://www.usp.br/line/ivprog/manual_pt/" + pagina, true);
			
 
				+  //localhost txtFile.open("GET", "http://localhost/ivprog/manual_pt/" + pagina, true);
			
 
				+  url = pegarURL();
			
 
				+  txtFile.open("GET", url + "/" + pagina, true);
			
 
				+  // alert("carregar: " + url + "/" + pagina);
			
 
				+  txtFile.onreadystatechange = function () {
			
 
				+    if (txtFile.readyState === 4) {  // Makes sure the document is ready to parse.
			
 
				+      if (txtFile.status === 200) {  // Makes sure it's found the file.
			
 
				+        allText = txtFile.responseText;
			
 
				+        //lines = txtFile.responseText.split("\n"); // Will separate each line into an array
			
 
				+        var customTextElement = document.getElementById('textoConteudo');
			
 
				+        customTextElement.innerHTML = txtFile.responseText;
			
 
				+        }
			
 
				+      }
			
 
				+    }
			
 
				+  txtFile.send(null);
			
 
				+  }
			
 
				+
			
 
				+
			
 
				+// defineLInE.js: usa 'prefixo' para construir URL para HREF
			
 
				+var prefixo = "line_"; // se vier de 'line_*.html' faz 'definePrefixo()'
			
--- a/css_img_js_conf/defineLInE.js
+++ b/css_img_js_conf/defineLInE.js
@@ -0,0 +1,39 @@
 
				+/*
			
 
				+ Material didatico: Introducao 'a Programacao
			
 
				+ Prof. Leo^nidas de Oliveira Branda~o
			
 
				+ http://www.ime.usp.br/~leo
			
 
				+ http://line.ime.usp.br
			
 
				+ */
			
 
				+
			
 
				+// Se precisar pegar URL da pagina
			
 
				+// A pagina "line_url.html" deve ter uma chamada 'defineEndereco(url1)' para cada url1 de href que tiver
			
 
				+// var prefixo; // 'carregar_pagina.js': se vier de 'line_*.html' define 'var prefixo = "line_"'
			
 
				+var endereco = window.location.href;
			
 
				+var enderecoFinal1 = window.location.href;
			
 
				+
			
 
				+function defineEndereco (url1) {
			
 
				+  var str = "";
			
 
				+  try { // se vier de "line_*.html", entao "var prefixo" e' definido em 'carregar_pagina.js'
			
 
				+    if (prefixo === "undefined") str = "";
			
 
				+    else str = "line_";
			
 
				+  } catch (error) {
			
 
				+    } // truque para evitar erro quando vindo de pagina via Moodle
			
 
				+  ind = endereco.lastIndexOf("/");
			
 
				+  enderecoFinal1 = str + endereco.substring(0, ind) + "/" + url1;
			
 
				+  // alert(enderecoFinal1);
			
 
				+  return enderecoFinal1;
			
 
				+  }
			
 
				+
			
 
				+
			
 
				+// Na pagina 'introducao_*.html' usar: <a href="#" onclick="trocaPagina('introducao_*.html')"...>
			
 
				+function trocaPagina (url1) {
			
 
				+  var str = "";
			
 
				+  try { // se vier de "line_*.html", entao "var prefixo" e' definido em 'carregar_pagina.js'
			
 
				+    if (prefixo === "undefined") str = "";
			
 
				+    else str = "line_";
			
 
				+  } catch (error) {
			
 
				+    } // truque para evitar erro quando vindo de pagina via Moodle
			
 
				+  javascript:window.location.href = str + url1;
			
 
				+  }
			
 
				+
			
 
				+// http://milanesa.ime.usp.br/line/intro_prog/line_http://milanesa.ime.usp.br/line/intro_prog/introducao_inteiros.html
			
--- a/css_img_js_conf/folder.svg
+++ b/css_img_js_conf/folder.svg
@@ -0,0 +1,3 @@
 
				+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" [
			
 
				+	<!ENTITY ns_flows "http://ns.adobe.com/Flows/1.0/">
			
 
				+]><svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 -1.3 16 16" preserveAspectRatio="xMinYMid meet" overflow="visible"><path d="M8 2.5c-.5 0-1-.5-1-1V1c0-.5-.5-1-1-1H1C.5 0 0 .5 0 1v11.5c0 .5.5 1 1 1h14c.5 0 1-.5 1-1v-9c0-.5-.5-1-1-1H8z" fill="#999"/></svg>
			
--- a/css_img_js_conf/icone_leo.png
+++ b/css_img_js_conf/icone_leo.png
--- a/css_img_js_conf/index.html
+++ b/css_img_js_conf/index.html
--- a/css_img_js_conf/line_introducao_programacao.css
+++ b/css_img_js_conf/line_introducao_programacao.css
@@ -0,0 +1,70 @@
 
				+/*
			
 
				+ 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
			
 
				+*/
			
 
				+
			
 
				+.tbCodeLinCol { border-collapse:collapse; }
			
 
				+.tbCodeLinCol th { background-color:#8aaada; }
			
 
				+.tbCodeLinCol td, .tbCodeLinCol th { padding:5px;border:1px solid #000; font: 10px/12px Arial, Helvetica, sans-serif; }
			
 
				+.tbCode td, .tb th { border: 0; font: 10px/12px Arial, Helvetica, sans-serif; }
			
 
				+.tableCd { border-collapse:collapse; }
			
 
				+.thBg th { background-color:#8aaada; padding-left:5px; padding-right:5px;}
			
 
				+.trCd td, .tbCd td, .tbCd th { vertical-align: top; padding:5px; border-right:1px solid #000;  font-family: courier }
			
 
				+
			
 
				+table.tableCode { padding-left:5px; padding-right:5px; border:1px solid #000;}
			
 
				+th.tableCode { background-color:#8aaada; }
			
 
				+table.tableCode td { border:1px solid #000; }
			
 
				+.code { font-family:courier; font-size:0.9em; }
			
 
				+
			
 
				+.tableCode tr, td { padding-left:5px; padding-right:5px; boder:1px solid #000; }
			
 
				+
			
 
				+.tdR tr, th { border: 1px solid black; }
			
 
				+.tdR td { border-right: 1px solid black; }
			
 
				+.cmd { color: #0000AA; }
			
 
				+.def { color: #9D009D; }
			
 
				+.fnc { color: #008866; }
			
 
				+.head { color: #000000; }
			
 
				+.var { color: #009A00; }
			
 
				+.tipo { color: #005A5A; }
			
 
				+.com { color: #AA0000; }
			
 
				+.versao { font-size: .6em; }
			
 
				+.rodape { font-size: .8em; margin-left: 5px; }
			
 
				+.pagina { background-color: white; padding-left:5px; }
			
 
				+.secao { font-size: 1.2em; color:#0055AA; font-weight: bold; }
			
 
				+.subsecao { font-size: 1.1em; color:#0000aa; font-weight: bold; }
			
 
				+.subsubsecao { color:#0000aa; font-weight: bolder; }
			
 
				+
			
 
				+div.exemplo {color:#006f3f;}
			
 
				+div.codigo {font-size:0.85em;color:#3f3f3f;margin-left:10x;margin-right:5px; display: inline-block; text-align:left}
			
 
				+
			
 
				+.imgDir {float: right; padding: 0 10px 0 0;}
			
 
				+/* introducao/img/img_estrutura_basica_terminal_topo.png : 882 x 47 */
			
 
				+.imgTermTopo { right: 0; top: 0; padding-top: 27px; display: block; width: 882px;
			
 
				+ background: url(../img/img_estrutura_basica_terminal_topo.png) no-repeat; background-color: black; color: #ffffff;
			
 
				+ text-indent: -999em; }
			
 
				+bloco1{padding-left:5px;padding-right:5px;border:1px solid#aaaaaa;display:block;width:100%;}
			
 
				+porque{background: linear-gradient(#bfdfff, white);padding-left:5px;padding-right:5px;border:1px solid#0000aa;display:block;width:100%}
			
 
				+.porque{background: linear-gradient(#bfdfff, white);padding-left:5px;padding-right:5px;border:1px solid#0000aa;display:block;width:100%}
			
 
				+sabermais{background:#eaeaea;padding-left:5px;padding-right:5px;border:1px solid#0000aa;display:block;width:100%;}
			
 
				+center.sabermais{text-align:center;}
			
 
				+codigo1 { padding-left:1px;padding-right:1px;border:1px solid#000;background:#efefef;font-family: monospace; }
			
 
				+codigo2 { white-space: pre; font-family: monospace; display: block; unicode-bidi: embed; } /* evitar <pre></pre> dentro 'sabermais' */
			
 
				+.autoria{ padding-top:5px;padding-left:5px;padding-right:5px; display:block;width:100% }
			
 
				+
			
 
				+.que.calculated .answer{padding:.3em;display:inline}.que.calculated .answer input[type="text"]{width:30%}
			
 
				+.sabermais2{background:#efefef;padding-left:5px;padding-right:5px;border:1px solid#0000aa;}
			
 
				+
			
 
				+azul { color: #0000BA; } /* while, for */
			
 
				+azul2 { color: #00007A; }
			
 
				+verd { color: #00BA00; } /* scanf, printf, input, print */
			
 
				+verm { color: #BA0000; } /* int, float, void, def */
			
 
				+cyan { color: #458A8A; }
			
 
				+def { color: #a500a5; } /* #define */
			
 
				+incl1 { color: #a500a5; } /* #define, #include, import, from */
			
--- a/css_img_js_conf/navigationitem.svg
+++ b/css_img_js_conf/navigationitem.svg
@@ -0,0 +1,3 @@
 
				+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" [
			
 
				+	<!ENTITY ns_flows "http://ns.adobe.com/Flows/1.0/">
			
 
				+]><svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="-5 -5 16 16" preserveAspectRatio="xMinYMid meet" overflow="visible"><path d="M6 5c0 .5-.5 1-1 1H1c-.5 0-1-.5-1-1V1c0-.5.5-1 1-1h4c.5 0 1 .5 1 1v4z" fill="#999"/></svg>
			
--- a/evitar_entrada_saida_em_funcao.html
+++ b/evitar_entrada_saida_em_funcao.html
@@ -0,0 +1,574 @@
 
				+<!--
			
 
				+ Introducao 'a Programacao - desde 2017 - Prof. Leo^nidas de Oliveira Branda~o
			
 
				+ Por que evitar entrada/saida de dados em funcoes?
			
 
				+ LInE (Laboratory of Informatics in Education) - http://www.usp.br/line
			
 
				+ IME - USP
			
 
				+ Material didatico
			
 
				+ Pode usar livrevemente este material para fins nao comerciais, devendo sempre fazer referencia `a autoria.
			
 
				+ Sugestões/apontamento são bem vindos: leo@ime.usp.br (favor indicar no assunto "material de introducao 'a programacao")
			
 
				+ Autor: Prof. Leo^nidas de Oliveira Branda~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">
			
 
				+
			
 
				+<p class="secao">Por que evitar entrada/saida de dados em funções</p>
			
 
				+
			
 
				+<p>
			
 
				+  A razão principal para se <b>evitar comandos de entrada e de saída dentro da definição de uma função</b> é conseguir
			
 
				+  maior flexibilidade para uso dessas funções, como explico a seguir.
			
 
				+  Evidentemente isso não se aplica quando a função for desenhada especificamente para providenciar a entrada (leitura) ou
			
 
				+  para a saída (impressão de dados. Por exemplo, o segundo caso ocorre na função <tt>imprime_comb</tt>
			
 
				+  Entretanto,
			
 
				+
			
 
				+Para explicar as razões pelas quais deve-se <b>evitar comandos de entrada e de saída dentro da definição de uma função</b>,
			
 
				+devemos primeiro enfatizar o que é a uma função em linguagens como <i>C</i> ou  <i>Python</i>:
			
 
				+<ul>
			
 
				+  <li>é um código que recebe seus <em>dados de entrada</em> a partir de uma <i>lista de parâmetros</i> (<i class="def">parâmetros formais</i>);</li>
			
 
				+  <li>é um código que processa os dados de entrada e geralmente devolve algum valor como resposta (em seu comando <tt class="cmd">return</tt>);</li>
			
 
				+  <li>é um código que pode ser invocado a partir de outros trechos do programa, que providenciam os valores para os parâmetros
			
 
				+      (<i class="def">parâmetros efetivos</i>).</li>
			
 
				+</ul>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Desse modo, usando como exemplo a <i>função fatorial</i> (<i>fat(0)=1</i> e <i>fat(n)=n*fat(n-1), n&gt;0</i>), a razão para
			
 
				+se evitar comandos de entrada e de saída dentro da definição da função pode ser resumida em:
			
 
				+<ul>
			
 
				+  <li><i>Facilita o reúso de código</i>, ou seja, sempre que precisar de um algoritmo que compute o fatorial,
			
 
				+      basta copiar o código que já implementou (e testou);</li>
			
 
				+  <li><i>Facilita o desenvolvimento de programas maiores</i>, pois pode-se agrupar os blocos lógicos que tenham um propósito bem definido como
			
 
				+      uma função.</li>
			
 
				+</ul>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  A fim de ficar mais clara a vantagem de <i>passar os valores via parâmetro</i>, vamos examinar um exemplo matemático,
			
 
				+  <b style="color:#0000aa">computar o número de combinações de <i>n</i>, tomados <i>k</i> a <i>k</i></b>
			
 
				+  <a href="#comb" title="ver referência sobre combinação">[1]</a>.
			
 
				+  Vamos lembrar a combinatória usualmente estudada no <i>Ensino Médio</i>.
			
 
				+  Este problema pode ser traduzido em um exemplo do tipo "loteria":
			
 
				+  de quantas maneiras distintas é possível combinar <i>n=99</i> números (dentre <i>01</i> e <i>99</i>) tomando-se
			
 
				+  <i>k=5</i> deles? A resposta geral é dada pela expressão <i>C<sub>n,k</sub>=n!/((n-k)!k!)</i>, que com os dados de interesse
			
 
				+  resultaria em <i>C<sub>100,5</sub>=100!/((100-5)!5!) = 75.287.520</i>.
			
 
				+  <br/>
			
 
				+  Portanto, se você comprar um único bilhete dessa loteria por semana, em média precisaria de mais de 75 milhões de semanas para conseguir
			
 
				+  ter um bilhete premiado.
			
 
				+  <br/>
			
 
				+  <sabermais title="para saber um pouco mais">
			
 
				+  Como seria dificílimo tentar enumerar as mais de 75 milhões de possibilidade para verificar a corretuda da fórmula
			
 
				+  acima estão corretos, vamos testar com uma combinção menor, como combinar
			
 
				+  <i>n=5</i> valores <i>3</i> a <i>3</i>, neste caso a fórmula diz que teríamos<br/>
			
 
				+  &nbsp; &nbsp; &nbsp; &nbsp; <i>C<sub>5,3</sub>=5!/((5-3)!3!) = 5*4/2 = 10</i>
			
 
				+  <br/>
			
 
				+  e, de fato, existem <i>10</i> combinações:
			
 
				+  <i>{1,2,3}, {1,2,4}, {1,2,5},
			
 
				+     {1,3,4}, {1,3,5},
			
 
				+     {1,4,5},
			
 
				+     {2,3,4}, {2,3,5},
			
 
				+     {2,4,5},
			
 
				+     {3,4,5}</i>.
			
 
				+  </sabermais>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Nesse contexto, imaginemos o uso
			
 
				+  <i style="color:#aa5555" title="conceitualmente errônea, como tento explicar a seguir">errôneo</i> de uma leitura do valor <i>n</i>
			
 
				+  dentro da função <tt class="var">fat</tt>.
			
 
				+  Então, se precisar computar a combinação de <tt>n</tt>, tomados <tt>k</tt> a <tt>k</tt> (<i>C<sub>n,k</sub>=n!/((n-k)!k!)</i>),
			
 
				+  esse valor <b>não</b> poderá ser computado usando a expressão seguinte (com chamada à função <tt class="var">fat</tt>):
			
 
				+  <tt class="var">fat(n)/(fat(n-k)fat(k))</tt>.
			
 
				+  <br/>
			
 
				+  <b style="color:#0000aa">Por que mesmo?</b>
			
 
				+  <br/>
			
 
				+  <porque>
			
 
				+    Se não percebe o <i style="color:#aa5555" title="erro conceitual">erro de programação</i>, vale a pena fazer uma simulação.
			
 
				+    Suponha que você tenha implementado o fatorial como uma função com comando de leitura, em "Portugol" <br/>
			
 
				+    &nbsp; &nbsp;
			
 
				+    <tt><verm>inteiro</verm> fat (n) {
			
 
				+      <verm>inteiro</verm> i=2, f=1; <verd>leia</verd>(n); <azul2>repita_enquanto</azul2> (i&lt;=n) { f = f*i; i = i+1; } devolva f; }</tt>
			
 
				+    <br/>
			
 
				+    e deseje saber <i>C<sub>5,2</sub>=5!/((5-2)!2!)</i>.
			
 
				+    <br/>
			
 
				+    Então, ao entrar na função para computar <tt>fat(5)</tt> o usuário terá que digitar o valor <tt>5</tt>, para computar
			
 
				+    <tt>fat(3)</tt>, será obrigado a digitar o valor 3 e, para computar <tt>fat(2)</tt>, terá também que digitar o valor <tt>2</tt>.
			
 
				+    <br/>
			
 
				+    Mas vamos tornar o <i style="color:#aa5555">erro</i> (ou <i style="color:#aa5555">problema</i>) mais óbvio.
			
 
				+    Vamos supor que desejamos imprimir várias combinações (<i title="do Latin, exempli gratia">e.g.</i>, para computar o triângulo de Pascal).
			
 
				+    Por exemplo, examine como ficaria o calculo de <i>C<sub>10,1</sub>, C<sub>10,2</sub></i>, assim por diante até <i>C<sub>10,10</sub></i>
			
 
				+    (vide a função <tt>fat</tt> da tabela 1).
			
 
				+    Seria necessário que o "sofrido" usuário tenha que ficar digitando 10 triplas! (<i>10,9,1</i>; <i>10,8,2</i>; <i>10,7,3</i>;
			
 
				+    <i>10,6,4</i>; <i>10,5,5</i>; <i>10,4,6</i>; <i>10,3,7</i>; <i>10,2,8</i>; <i>10,1,9</i>; e <i>10,0,10</i>).
			
 
				+    Mas bastaria exigir que o usuário digitasse apenas um valor, <i>10</i>, se o programador (você) tivesse implementado o fatorial via
			
 
				+    parâmetro e sem leituras dentro dessa função. Bastaria usar um laço (vide a função <tt>main</tt> da tabela 3).
			
 
				+    <br/>
			
 
				+    Ou seja, não faz sentido obrigar o usuário a digitar dezenas, centenas, milhares, ou mais vezes, quando bastaria digitar um único valor.
			
 
				+    Se não estiver convencido da inviabilidade do uso de leitura dentro da função fatorial, copie os códigos da tabela 1 e o experimente.
			
 
				+  </porque>
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+  Assim, em exercícios que apresentam o conceito de função (portanto envolvendo um bloco lógico com propósito bem definido),
			
 
				+  procure, sempre que possível, <b>não</b> usar comandos de entrada ou de saída de dados <b>dentro da função</b>.
			
 
				+  Esse é um <i>bom hábito de programação</i>, no sentido de reduzir erros e facilitar que reaproveite sues códigos em outras
			
 
				+  situações.
			
 
				+  <br/>
			
 
				+  Mas vale lembrar que existem exceções: em uma função desenhada especificamente para "ler" dados, é necessá comandos para entrada e
			
 
				+  uma função específica para imprimir o <i>Triângulo de Pascal</i> precisa de comando de impressão.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+<!-- F<sub>0</sub>=1, F<sub>1</sub>=1, F<sub>k</sub> = F<sub>k-1</sub> + F<sub>k-2</sub>, k&gt;2 -->
			
 
				+Entretanto, existem as exceções, exemplos nos quais é útil usar comando de entrada ou de saída dentro da função. Ilustraremos
			
 
				+o caso de utilidade de um comando de saída dentro da função, isso ocorre se desejamos computar (e imprimir) os <tt>n</tt> primeiros termos da
			
 
				+<i title="F_{0}=1, F_{1}=1, F_{k} = F_{k-1} + F_{k-2}, k&gt;1">sequência de Fibonacci</i>.
			
 
				+Então, naturalmente precisaremos do comando de impressão/saída e como isso pode ser feito para qualquer
			
 
				+<tt>n</tt> é adequado agrupar esse código na forma de um procedimento separado (no caso uma função <b>sem</b> valor de retorno).
			
 
				+<br/>
			
 
				+Porém se o objetivo fosse conhecer apenas o termo <tt>n</tt> da sequência, a função <b>não deveria ter o comando de saída</b>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+<center>
			
 
				+<i>Tab. 1. Códigos "errôneos" para imprimir o Triângulo de Pascal via fórmula de combinação</i>
			
 
				+<table class="tableCd">
			
 
				+ <tr><td></td><td bgcolor="8aaada"><i>C</i>              <td bgcolor="8aaada"><i>Python</i></td></tr>
			
 
				+  <tr><td><table class=""><tr class="trCd" valign="top"><td><pre style="font-size:0.8em"> 1
			
 
				+ 2
			
 
				+ 3
			
 
				+ 4
			
 
				+ 5
			
 
				+ 6
			
 
				+ 7
			
 
				+ 8
			
 
				+ 9
			
 
				+10
			
 
				+11
			
 
				+12
			
 
				+13
			
 
				+14
			
 
				+15
			
 
				+16
			
 
				+17
			
 
				+18
			
 
				+19
			
 
				+20
			
 
				+21
			
 
				+22
			
 
				+23
			
 
				+24
			
 
				+25
			
 
				+26
			
 
				+27
			
 
				+28
			
 
				+29
			
 
				+20
			
 
				+</pre></td></tr></table></td>
			
 
				+  <td><table class=""><tr class="trCd" valign="top"><td><pre style="font-size:0.8em"><verm>int</verm> fat (<verm>int</verm> n) { <cyan>// define funcao com 1 parametro</cyan>
			
 
				+  <verm>int</verm> ft = 1, i=2;
			
 
				+  <cyan>// Experimente com esta linha,</cyan>
			
 
				+  <verd>scanf</verd>("%d", &n); <cyan>// depois sem ela</cyan>
			
 
				+  <azul2>while</azul2> (i &lt;= n) {
			
 
				+    i = i + 1;
			
 
				+    ft = ft * i;
			
 
				+    }
			
 
				+  return ft;
			
 
				+  }
			
 
				+<verm>void</verm> imprime_comb (<verm>int</verm> n) {
			
 
				+  <verm>int</verm> i=0, aux;
			
 
				+  <cyan>// Com mais a leitura abaixo o codigo ficaria</cyan>
			
 
				+  <cyan>// scanf("%d", &n); // "absurdo" ao quadrado!</cyan>
			
 
				+  <azul2>while</azul2> (i &lt;= n) {
			
 
				+    aux = fat(n)/(fat(n-i)*fat(i));
			
 
				+    <verd>printf</verd>("%3d ", aux);
			
 
				+    i++;
			
 
				+    }
			
 
				+  <verd>printf</verd>("\n");
			
 
				+  }
			
 
				+<verm>void</verm> main (void) {
			
 
				+  <verm>int</verm> i=0, n;
			
 
				+  <cyan>// Experimente com n pequeno, digamos n=3, assim ja'</cyan>
			
 
				+  <verd>scanf</verd>("%d", &n); <cyan>// percebera' o absurdo da leitura</cyan>
			
 
				+  <azul2>while</azul2> (i&lt;=n) {
			
 
				+    imprime_comb(i);
			
 
				+    i++;
			
 
				+    }
			
 
				+  }</pre></td></tr></table></td>
			
 
				+  <td><table class=""><tr class="trCd" valign="top"><td><pre style="font-size:0.8em"><cyan># Python2 para 'print' sem pular linha : print("*" , end = "");</cyan>
			
 
				+from __future__ import print_function
			
 
				+
			
 
				+<verm>def</verm> fat (n) :
			
 
				+  <cyan># Experimente com esta linha,</cyan>
			
 
				+  n = int(<verd>input</verd>()); <cyan># depois sem ela</cyan>
			
 
				+  f = 1;
			
 
				+  i = 2;
			
 
				+  <azul2>while</azul2> (i&lt;=n) :
			
 
				+    f *= i;
			
 
				+    i += 1;
			
 
				+  return f;
			
 
				+
			
 
				+<verm>def</verm> imprime_comb (n) :
			
 
				+  <cyan># Com mais a leitura abaixo o codigo ficaria</cyan>
			
 
				+  <cyan># n = int(<verd>input</verd>()); # "absurdo" ao quadrado!</cyan>
			
 
				+  i=0;
			
 
				+  <azul2>while</azul2> (i&lt;=n) :
			
 
				+    <cyan># C(n,k) = n!/((n-k)!*k!)</cyan>
			
 
				+    val = fat(n)/(fat(n-i)*fat(i));
			
 
				+    <cyan># print("C(%d,%d)=%d" % (n,i,val));</cyan>
			
 
				+    <verd>print</verd>("%3d " % (val), end="");
			
 
				+    i += 1;
			
 
				+
			
 
				+<verm>def</verm> main () :
			
 
				+  n = int(<verd>input</verd>());
			
 
				+  for i in range(n+1) :
			
 
				+    imprime_comb(i);
			
 
				+    <verd>print</verd>();
			
 
				+
			
 
				+main();
			
 
				+</pre></td></tr></table></td></tr>
			
 
				+  </table>
			
 
				+</center>
			
 
				+</p>
			
 
				+
			
 
				+<span style="color: #0055AA;font-size:1.1em">Exemplo 1. Dados naturais <tt>n</tt> e <tt>k</tt>, computar a combinação de <tt>n</tt> <tt>k-a-k</tt></span>
			
 
				+
			
 
				+<p>
			
 
				+Suponha que precisemos fazer um programa para computar
			
 
				+quantas são as combinações de <tt>n</tt> termos combinados <tt>k</tt>-a-<tt>k</tt>, ou seja, tendo <tt>n</tt> elementos,
			
 
				+desejamos saber de quantos modos distintos podemos formar grupos com <tt>k</tt> dos elementos.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Esse conceito aparece em <i>probabilidade</i> e em <i>combinatória</i>, sabemos que esta combinação corresponde ao agrupamentos de
			
 
				+elementos nos quais a ordem não importa (tanto faz a ordem dos <tt>k</tt> elementos do tipo <tt>a</tt>) e que a fórmula que fornece
			
 
				+o total desses subconjuntos é a seguinte:
			
 
				+<center><a href="https://en.wikipedia.org/wiki/Binomial_theorem" title="explicacao mais detalhada na WikiPedia">C(n,k) = n! / ((n-k)! k!)</a>.</center>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Por exemplo, combinar <tt>6</tt> valores distintos, tomados <tt>2</tt> a <tt>2</tt> resulta <tt>15=6!/((6-2)!2!)=6!/(4!2!)</tt>, que
			
 
				+são os <tt>15</tt> subconjuntos: 
			
 
				+ <tt>(6,5)</tt>, <tt>(6,4)</tt>, <tt>(6,3)</tt>, <tt>(6,2)</tt>, <tt>(6,1)</tt>, 
			
 
				+ <tt>(5,4)</tt>, <tt>(5,3)</tt>, <tt>(5,2)</tt>, <tt>(5,1)</tt>,
			
 
				+ <tt>(4,3)</tt>, <tt>(4,2)</tt>, <tt>(4,1)</tt>,
			
 
				+ <tt>(3,2)</tt>, <tt>(3,1)</tt>,
			
 
				+ <tt>(2,1)</tt>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Assim, existem duas possibilidades de implementar esse código, uma implementando a função fatorial (<tt>fat(n)</tt>) que seria
			
 
				+invocada três vezes pelo programa principal (com algo como  <tt><verd>imprima</verd>(fat(n) / (fat(k) * fat(n-k))</tt>.
			
 
				+Outra possibilidade é implementar também o cômputo de <tt>fat(n) / (fat(k) * fat(n-k))</tt> também como uma função.
			
 
				+Apesar dessa segunda possibilidade não ajudar tanto na organização do código (pois a segunda função (<tt>comb(n,k)</tt>) seria muito
			
 
				+simples, ilustraremos dessa forma por ela usar função chamando função que chama função (a principal chama <tt>comb(n,k)</tt> e essa
			
 
				+chama <tt>fat(n)</tt>).
			
 
				+Veja como ficaria o código em uma <i>pseudo-linguagem</i> de programação:
			
 
				+
			
 
				+<pre style="font-size:0.8em"><verm>inteiro</verm> fat(n) { <cyan>//# estou supondo que o valor digitado pelo usuario seja um natural maior ou igual a 0 (n>=0)</cyan>
			
 
				+  <verm>inteiro</verm> valfat = 1;
			
 
				+  <verm>inteiro</verm> cont = 2;
			
 
				+  <azul2>repita_enquanto</azul2> (cont&lt;=n) { <cyan>//# continue computando enquanto nao chegar ao valor cont==n</cyan>
			
 
				+    valfat = valfat * cont;
			
 
				+    cont = cont + 1;
			
 
				+    }
			
 
				+  devolva valfat;
			
 
				+  }
			
 
				+<verm>inteiro</verm> comb(n, k) {
			
 
				+  devolva fat(n) / (fat(n-k)*fat(k));
			
 
				+  }
			
 
				+<verm>vazio</verm> principal() {
			
 
				+  <verm>inteiro</verm> N, k; <cyan>//# note que os nomes de variaveis daqui NAO tem qualquer relacao com aqueles em 'fat'</cyan>
			
 
				+  <verm>inteiro</verm> a, b, c; <cyan>//# para uma segunda versao</cyan>
			
 
				+  <verd>leia</verd>(N, k); <cyan>//# leia 2 valores naturais e armazene-os respectivamente em N e em k (espera-se que digite N>=k)</cyan>
			
 
				+  <cyan>//# pode-se invocar seguidamente 'fat' 3 vezes como abaixo:</cyan>
			
 
				+  <verd>imprima</verd>(comb(N,k);
			
 
				+  <cyan>//# pode-se invocar a funcao 'fat' quanta vezes forem necessarias, aqui fazermos 3 vezes, armazenando cada resultado</cyan>
			
 
				+  a = fat(N);
			
 
				+  b = fat(k);
			
 
				+  c = fat(N-k);
			
 
				+  <verd>imprima</verd>(a/( b * c))); <cyan>//# usamos os 3 resultados de chamada de 'fat' para compor a resposta final N!/(k!*(N-k)!)</cyan>
			
 
				+  }</pre>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  A figura 1 ilustra os desvios no <i>fluxo de execução</i> do código acima.
			
 
				+  Note o destaque da instrução 2, que é uma atribuição que define o valor para a variável <i>c</i>, a ordem de construção é a
			
 
				+  usual de expressão, primeiro computa-se o <i>lado direito</i> da expressão e o resultado dela é armazenado na variável
			
 
				+  (que é o <i>lado esquerdo</i> da atribuição).  Como o <i>lado direito</i> contém uma chamada de função, para computá-lo,
			
 
				+  desvia-se o <i>fluxo de execução</i> (seta que "sai" de <i>fat(k);</i>) para a execução da função <i>fat(.)</i>, inicia-se
			
 
				+  a variável local (na verdade declarada como parâmetro) <i>n</i> com o valor vindo de <i>k</i> (<i>parâmetro efetivo</i>),
			
 
				+  segue-se executando as instrução de <i>fat(.)</i> e, no exemplo, a última instrução indica que deve-se devolver para local
			
 
				+  que <i>invocou</i> <i>fat(.)</i> o valor atual na variável (local) <i>ft</i>.
			
 
				+</p>
			
 
				+
			
 
				+<center>
			
 
				+  <img src="img/exemplo_exec_funcao.jpg" title="exemplo de execucao da funcao"/>
			
 
				+  <br/>
			
 
				+  <i>Fig. 1. Diagrama esquemática indicando desvio de execução função e local de retorno.</i>
			
 
				+</center>
			
 
				+
			
 
				+<p>
			
 
				+Novamente para enfatizar as desvantagens de usar leitura ou impressão dentro de funções, 
			
 
				+procure implementar o código acima, em sua linguagem favorita, e colocar nele comandos para
			
 
				+leitura ou saída dentro da função <tt>fat(n)</tt>, como discutido abaixo.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<span style="color: #0055AA;font-size:1.1em">Observação 1. Vantagem de uso de função sem comandos de entrada/saída - combinação n, k-a-k</span>
			
 
				+
			
 
				+<p>
			
 
				+  Note que, <b>se</b> dentro da função <tt>fat</tt> exitisse um comando do tipo <tt><verd>leia</verd>(n);</tt>,
			
 
				+  a função NÃO poderia ser usada para computar o fatorial de algum valor já registrado em alguma variável, pois ao ser invocada,
			
 
				+  digamos <tt>fat(n)</tt>, seria necessário que o usuário <i style="color: #AA0000;">digitasse novamente</i> o valor para calculo
			
 
				+  do fatorial e valor para o qual desejava-se o fatorial (na variável <tt>n</tt>) seria descartado.
			
 
				+  No exemplo do código associado à figura 1, na primeira chamada para <i>N</i>, o usuário teria que digitar algum valor
			
 
				+  para calcular fatorial (e provavelmente nem saberia qual o valor guardado em <i>N</i>),
			
 
				+  na segunda chamada, para o valor para <i>k</i> ocorreria o mesmo, e por fim, o mesmo para o valor <i>N-k</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  De forma análoga, se a função <i>fat</i> tivesse algum comando de saída, ao usar a função 3 vezes, o usuário
			
 
				+  receberia informações confusas: ele deseja a combinação de <i>n</i>, tomado <i>k</i>-a-<i>k</i>, mas
			
 
				+  receberia 4 infomações: na primeira chamada <i>fat(.)</i> imprimiria <i>n!</i>,
			
 
				+  segunda imprimiria <i>k!</i>, na terceira imprimiria o resultado de <i>(n-k)!</i> e, ao voltar
			
 
				+  para o código que invocou <i>fat(.)</i>, imprimiria finalmente a única coisa que o usuário desejava saber,
			
 
				+  <i>n!/(k! (n-k)!)</i>.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<span style="color: #0055AA;font-size:1.1em">Observação 2. Propriedade interessante de C(n,k) - Triângulo de Pascal</span>
			
 
				+
			
 
				+<p>
			
 
				+Vamos aproveitar o código que computa a combinação de <i>n</i>, <i>k-a-k</i>, <i>C(n,k) = n!/(k!*(n-k)!)</i>, para computar
			
 
				+a seguinte sequência de valores: <i>C(n,0)</i>, <i>C(n,1)</i>, <i>C(n,2)</i> e assim por diante, até <i>C(n,n)</i>.
			
 
				+Mais ainda, vamos fazer isso para <i>n=1</i>, <i>n=2</i>, <i>n=3</i> e <i>n=4</i>.
			
 
				+</p>
			
 
				+
			
 
				+<center>
			
 
				+<i>Tab. 2. Triângulo de Pascal, como combinação e de modo direto</i>
			
 
				+<table class="tableCd"><tr><td>
			
 
				+<pre>Linha | Combinacoes C(n,0) ate C(n,n)                         | As saidas
			
 
				+    0 | C(0,0)                                                |   1
			
 
				+    1 | C(1,0) C(1,1)                                         |   1   1 
			
 
				+    2 | C(2,0) C(2,1) C(2,2)                                  |   1   2   1 
			
 
				+    3 | C(3,0) C(3,1) C(3,2) C(3,3)                           |   1   3   3   1 
			
 
				+    4 | C(4,0) C(4,1) C(4,2) C(4,3) C(4,4)                    |   1   4   6   4   1 
			
 
				+    5 | C(5,0) C(5,1) C(5,2) C(5,3) C(5,4) C(5,5)             |   1   5  10  10   5   1 
			
 
				+    6 | C(6,0) C(6,1) C(6,2) C(6,3) C(6,4) C(6,5) C(6,6)      |   1   6  15  20  15   6   1</pre>
			
 
				+</td></tr></table>
			
 
				+</center>
			
 
				+
			
 
				+<p>
			
 
				+Ou seja, na tabela acima, a linha <i>0</i>, tem uma única saída, a saber <i>C(0,0)</i>.
			
 
				+A linha <i>1</i> tem duas saídas, <i>C(1,0)</i> e <i>C(1,1)</i>.
			
 
				+A linha <i>2</i> tem três saídas, <i>C(2,0)</i>, <i>C(2,1)</i> e <i>C(2,2)</i>.
			
 
				+Assim, por diante, até a linha <i>6</i> que tem sete saídas.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  O que é interessante, é que no <i>triângulo</i> (na coluna das saídas) aparece uma propriedade interessante:
			
 
				+  o elemento da linha <i>k</i>, na coluna <i>j</i> é igual à soma do elemento da
			
 
				+  linha <i>k-1</i>, na coluna <i>j-1</i>, com o elemento da
			
 
				+  linha <i>k-1</i>, na coluna <i>j</i>.
			
 
				+  Ou seja, vale a propriedade
			
 
				+  <i>C(k,j) = C(k-1,j-1) + C(k-1,j)</i> (sempre que <i>k&gt;0</i> e <i>j</i> estiver entre <i>1</i> e <i>k</i>,
			
 
				+  essa é a relação de <i title="Michael Stifel (ca. 1487 1567)">Stifel</i>
			
 
				+  [<a href="#boyer" title="examinar referencia 2 - Boyer">2</a>, <a href="#dantzig" title="examinar referencia 2 - Dantzig">3</a>],
			
 
				+  e aquele é o
			
 
				+  <b title="Atribuido a Blaise Pascal (1623 1662) mas já conhecido por Yang Hui (fl. ca. 1261 1275) e Michael Stifel (ca. 1487 1567)">
			
 
				+    Triângulo de Pascal</b>.
			
 
				+  Veja por exemplo o
			
 
				+  <a href="https://en.wikipedia.org/wiki/Pascal%27s_triangle" title="seguir para WikiPedia">Triângulo de Pascal</a>
			
 
				+  <a href="#boyer" title="examinar referência Boyer">[2]</a>
			
 
				+  na <i>WikiPedia</i>.
			
 
				+</p>
			
 
				+
			
 
				+<!--
			
 
				+<pre>1 0
			
 
				+---
			
 
				+1 1
			
 
				+1 0
			
 
				+---
			
 
				+2 0
			
 
				+2 1
			
 
				+2 2
			
 
				+---
			
 
				+3 0
			
 
				+3 1
			
 
				+3 2
			
 
				+3 3
			
 
				+---
			
 
				+4 0
			
 
				+4 1
			
 
				+4 2
			
 
				+4 3
			
 
				+4 4</pre>
			
 
				+
			
 
				+<p>
			
 
				+Examinando as saídas (última coluna) notamos uma propriedade interessante:
			
 
				+o elemento da linha <tt>n+1</tt>, coluna <tt>k+1</tt> = o elemento da linha <tt>n</tt>, coluna <tt>k</tt> + o elemento da linha <tt>n</tt>, coluna </tt>k+1</tt>.
			
 
				+Veja por exemplo, a última linha, linha <tt>4</tt>: o segundo elemento = <tt>4</tt> = <tt>1 + 3</tt> (da linha acima).
			
 
				+</p>
			
 
				+-->
			
 
				+
			
 
				+<!-- https://pt.wikipedia.org/wiki/Produtos_not%C3%A1veis -->
			
 
				+
			
 
				+<!--
			
 
				+<span style="color: #0055AA;font-size:1.1em">Exemplo 2. Coeficientes da expansão do produto notável <tt>(a+b)^n</tt></span>
			
 
				+
			
 
				+<p>
			
 
				+Suponhamos que precisemos fazer um programa que computa os termos dos coeficientes da expansão de <tt>(a+b)^n</tt>.
			
 
				+Ou seja, desejamos um programa que dado <tt>n</tt> liste quantos termos do tipo <tt>a^i x b^j</tt> existe, para cada
			
 
				+<tt>i</tt> e cada <tt>j</tt> tais que <tt>i+j=n</tt>.
			
 
				+
			
 
				+  o valor da combinação de <i>N</i> tomado <i>k</i> a <i>k</i>, ou seja,
			
 
				+C(N,k) = N! / ( k! (N-k)!).
			
 
				+Para isso percebe-se que é necessário implementar o cômputo de fatorial que será utilizado 3 vezes.
			
 
				+Para facilitar a compreensão, podemos escrever um código com 3 variáveis auxiliares para armazenar, respectivamente,
			
 
				+<i>N!</i>, <i>k!</i> e <i>(N-k)!</i>.
			
 
				+</p>
			
 
				+
			
 
				+<pre>(a+b)^0                                                         = 1 a^0 b^0
			
 
				+(a+b)^1 = (a+b) (0 a^0 b^0 + 0 a^0 b^0)                         = 1 a^1 b^0 + 1 a^0 b^0 
			
 
				+(a+b)^2 = (a+b) (1 a^1 b^0 + 0 a^0 b^1)                         = 1 a^2 b^0 + 2 a^1 b^1 + 1 a^0 b^2
			
 
				+(a+b)^3 = (a+b) (1 a^2 b^0 + 2 a^1 b^1 + 1 a^0 b^2)             = 1 a^3 b^0 + 3 a^2 b^1 + 3 a^1 b^2 + 1 a^0 b^3
			
 
				+(a+b)^4 = (a+b) (1 a^3 b^0 + 3 a^2 b^1 + 3 a^1 b^2 + 1 a^0 b^3) = 1 a^4 b^0 + 4 a^3 b^1 + 6 a^2 b^2 + 4 a^1 b^3 + 1 a^0 b^3a
			
 
				+</pre>
			
 
				+<pre>1
			
 
				+1 1
			
 
				+1 2 1
			
 
				+1 3 3 1
			
 
				+1 4 6 4 1
			
 
				+</pre>
			
 
				+-->
			
 
				+
			
 
				+
			
 
				+<span style="color: #0055AA;font-size:1.1em;">Implementações para gerar o "Triângulo de Pascal" em <i>C</i> e em <i>Python</i></span>
			
 
				+
			
 
				+<p>
			
 
				+Abaixo apresento uma implementação para gerar o "Triângulo de Pascal" (como apresentado acima), nas linguagens
			
 
				+<i>C</i> e <i>Python</i>.
			
 
				+<center>
			
 
				+  <i>Tab. 3. Outra versão de códigos para imprimir o Triângulo de Pascal via fórmula de combinação.</i>
			
 
				+  <br/>
			
 
				+ <table>
			
 
				+  <tr><td>Gerando "Triângulo de Pascal" em <i>C</i></td> <td>&nbsp;</td> <td>Gerando "Triângulo de Pascal" em <i>Python</i></td></tr>
			
 
				+<tr>
			
 
				+<td><pre style="font-size:0.8em">#include &lt;stdio.h&gt;
			
 
				+<verm>int</verm> fat (<verm>int</verm> n) { <cyan>// supondo usuario digite natural n&gt;=0)</cyan>
			
 
				+  <verm>int</verm> valfat = 1;
			
 
				+  <verm>int</verm> cont = 2;
			
 
				+  <azul2>while</azul2> (cont&lt;=n) { <cyan>// continue enquanto nao chegar a cont==n</cyan>
			
 
				+    valfat = valfat * cont;
			
 
				+    cont++;
			
 
				+    }
			
 
				+  return valfat;
			
 
				+  }
			
 
				+
			
 
				+<verm>int</verm> comb (<verm>int</verm> n, <verm>int</verm> k) { return fat(n) / (fat(n-k)*fat(k)); }
			
 
				+
			
 
				+<verm>void</verm> main (void) {
			
 
				+  <verm>int</verm> N, k; <cyan>//  usa inteiros N, k</cyan>
			
 
				+  <verm>int</verm> a, b, c, n;
			
 
				+  <verd>printf</verd>("Digite N - para computar C(N,0), C(N,1), ..., C(N,N): ");
			
 
				+  <verd>scanf</verd>("%d",  &N);
			
 
				+  <cyan>// pode-se invocar seguidamente 'fat' 3 vezes como abaixo:</cyan>
			
 
				+  for (n=0; n&gt;N; n++) {
			
 
				+    for (k=0; k&lt;=n; k++) {
			
 
				+      a = fat(n);
			
 
				+      b = fat(k);
			
 
				+      c = fat(n-k);
			
 
				+      <cyan>// usamos resultados de 'fat' para resposta N!/(k!*(N-k)!)</cyan>
			
 
				+      <verd>printf</verd>("%3d ", a/(b * c));
			
 
				+      }
			
 
				+    <verd>printf</verd>("\n");
			
 
				+    }
			
 
				+  }
			
 
				+</pre></td> <td>&nbsp;</td> 
			
 
				+<td><pre style="font-size:0.8em"><cyan># Python2 para 'print' sem pular linha : print("*" , end = "");</cyan>
			
 
				+from __future__ import print_function
			
 
				+
			
 
				+<verm>def</verm> fat (n) : <cyan># supondo usuario digite natural n&gt;=0)</cyan>
			
 
				+  valfat = 1;
			
 
				+  cont = 2;
			
 
				+  <azul2>while</azul2> (cont&lt;=n) : <cyan># continue enquanto nao chegar a cont==n</cyan>
			
 
				+    valfat = valfat * cont;
			
 
				+    cont = cont + 1;
			
 
				+  return valfat;
			
 
				+
			
 
				+<verm>def</verm> comb(n, k) :
			
 
				+  return fat(n) / (fat(n-k)*fat(k));
			
 
				+
			
 
				+<verm>def</verm> main () :
			
 
				+  <cyan># usa inteiros N, k</cyan>
			
 
				+  <verd>print</verd>("Digite N - para computar C(N,0), C(N,1), ..., C(N,N): ");
			
 
				+  N = int(<verd>input</verd>());
			
 
				+  <cyan># pode-se invocar seguidamente 'fat' 3 vezes como abaixo:</cyan>
			
 
				+  for n in range(N) :
			
 
				+    for k in range(n+1) :
			
 
				+      a = fat(n);
			
 
				+      b = fat(k);
			
 
				+      c = fat(n-k);
			
 
				+      <cyan># usamos resultados de 'fat' para resposta N!/(k!*(N-k)!)</cyan>
			
 
				+      <verd>print</verd>("%3d " % (a/(b * c)), end="");
			
 
				+    <verd>print</verd>();
			
 
				+
			
 
				+main();
			
 
				+</pre></td>
			
 
				+</tr></table>
			
 
				+</center>
			
 
				+</p>
			
 
				+
			
 
				+<span style="color: #0055AA;font-size:1.1em">Referências bibliográficas sobre "Triângulo de Pascal"</span>
			
 
				+
			
 
				+
			
 
				+<ol type="1">
			
 
				+ <li> <a name="comb">[1]</a>
			
 
				+   <a href="https://en.wikipedia.org/wiki/Binomial_coefficient" title="examinar combinação na WikiPedia"
			
 
				+      target="_blank">https://en.wikipedia.org/wiki/Binomial_coefficient</a>.</li>
			
 
				+ <li> <a name="boyer">[2] Uta C. Merzbach e Carl B. Boyer</a>,
			
 
				+      "A History of Mathematics", third edition, John Wiley & Sons, Inc., 2011 (primeira edicao de 1968)
			
 
				+ </li>
			
 
				+ <li> <a name="dantzig">[3] Tobias Dantzig</a>, "NUMBER: The Language of Science", Pi Press, New Yourk, 2005
			
 
				+ </li>
			
 
				+</ol>
			
 
				+
			
 
				+ <!--
			
 
				+ Boyer, Carl B. (Carl Benjamin), 1906 1976.
			
 
				+ pg 184. "The Jade Mirror opens with a diagram of the arithmetic triangle,
			
 
				+  inappropriately known in the West as “Pascal’s triangle.” (See the fol-
			
 
				+  lowing illustration.) In Zhu’s arrangement, we have the coefficients of"
			
 
				+ -->
			
 
				+ <!--
			
 
				+ republicacao da 4a edicao de 1954
			
 
				+ (primeira edicao de 1930)
			
 
				+ pg. 71. "It is significant that we owe the first explicit formulation of
			
 
				+ the principle of recurrence to the genius of Blaise Pascal, a contem-
			
 
				+ porary and friend of Fermat. Pascal stated the principle in a tract
			
 
				+ called The Arithmetic Triangle which appeared in 1654. Yet it was"
			
 
				+ pg 279. "FIG 2. THE ARITHMETIC TRIANGLE OF PASCAL"
			
 
				+ -->
			
 
				+
			
 
				+  <p class="autoria">
			
 
				+    <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/09: revisão do formato e ampla revisão do texto;<br/>
			
 
				+  2019/06/06: vários pequenos acertos ao longo do texto;<br/>
			
 
				+  2019/04/07: versao 2 (acrescentado novos paragrafos, melhorando explicacoes e frases);<br/>
			
 
				+  2017/04/06: primeira versao.
			
 
				+</p>
			
 
				+
			
 
				+</div>
			
--- a/evitar_entrada_saida_em_funcao_2018_04_07.html
+++ b/evitar_entrada_saida_em_funcao_2018_04_07.html
@@ -0,0 +1,279 @@
 
				+
			
 
				+<!--
			
 
				+Por que evitar entrada/saida de dados em funções?
			
 
				+http://saw.atp.usp.br/mod/page/view.php?id=
			
 
				+-->
			
 
				+
			
 
				+<!DOCTYPE html>
			
 
				+<html itemscope itemtype="http://schema.org/QAPage">
			
 
				+
			
 
				+<head>
			
 
				+  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
			
 
				+  <title>Por que evitar entrada/saida de dados em funções?</title>
			
 
				+  <style type="text/css">
			
 
				+   .tbCodeLinCol { border-collapse:collapse; }
			
 
				+   .tbCodeLinCol th { background-color:#8aaada; }
			
 
				+   .tbCodeLinCol td, .tbCodeLinCol th { padding:5px;border:1px solid #000; font: 10px/12px Arial, Helvetica, sans-serif; }
			
 
				+   .tbCode td, .tb th { border: 0; font: 10px/12px Arial, Helvetica, sans-serif; }
			
 
				+   .tableCd { border-collapse:collapse; }
			
 
				+   .thBg th { background-color:#8aaada; }
			
 
				+   /* .trCd td, .tbCd td, .tbCd th { vertical-align: top; padding:5px; border-right:1px solid #000; font-family: courier } */
			
 
				+   .trCd td, .tbCd td, .tbCd th { vertical-align: top; padding:5px; border-right:1px solid #000; border-bottom:1px solid #000; font-family: courier }
			
 
				+   .cmd { color: #0000AA; }
			
 
				+   .fnc { color: #00AAAA; }
			
 
				+   .head { color: #000000; }
			
 
				+   .var { color: #009A00; }
			
 
				+   .tipo { color: #005A5A; }
			
 
				+   .com { color: #AA0000; }
			
 
				+   .def { color: #008181; font-weight: bold; } /* definicao */   
			
 
				+   .versao { font-size: .6em; }
			
 
				+  </style>
			
 
				+
			
 
				+</head>
			
 
				+
			
 
				+<body>
			
 
				+
			
 
				+<span style="color: #0055AA;font-size:1.2em"><b>Por que evitar entrada/saida de dados em funções</b></span>
			
 
				+      
			
 
				+<p>
			
 
				+Para explicar as razões pelas quais deve-se <b>evitar comandos de entrada e de saída dentro da definição de uma função</b>,
			
 
				+devemos primeiro enfatizar o que é a uma função em linguagens como <i>C</i> ou  <i>Python</i>:
			
 
				+<ul>
			
 
				+  <li>é um código que recebe seus <em>dados de entrada</em> a partir de uma <i>lista de parâmetros</i> (<i class="def">parâmetros formais</i>);</li>
			
 
				+  <li>é um código que processa os dados de entrada e geralmente devolve algum valor como resposta (em seu comando <tt class="cmd">return</tt>);</li>
			
 
				+  <li>é um código que pode ser invocado a partir de outros trechos do programa, que providenciam os valores para os parâmetros
			
 
				+      (<i class="def">parâmetros efetivos</i>).</li>
			
 
				+</ul>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Desse modo, usando como exemplo a <i>função fatorial</i> (<i>fat(0)=1</i> e <i>fat(n)=n*fat(n-1), n&gt;0</i>), a razão para
			
 
				+se evitar comandos de entrada e de saída dentro da definição da função pode ser resumida em:
			
 
				+<ul>
			
 
				+  <li><i>Facilita o reúso de código</i>, ou seja, sempre que precisar de um algoritmo que compute o fatorial,
			
 
				+      basta copiar o código que já implementou (e testou);</li>
			
 
				+  <li><i>Facilita o desenvolvimento de programas maiores</i>, pois pode-se agrupar os blocos lógicos que tenham um propósito bem definido como
			
 
				+      uma função.</li>
			
 
				+</ul>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+A fim de ficar mais clara a vantagem de <i>passar os valores via parâmetro</i>, pense na implementação <i>errônea</i> da função
			
 
				+<tt class="var">fat</tt>, suponha que em seu código tenha sido usado um comando para <i>leitura</i> (via teclado) dos dados.
			
 
				+Então, se precisar computar a combinação de <tt>n</tt>, tomados <tt>k</tt> a <tt>k</tt> (<i>C<sub>n,k</sub>=n!/((n-k)!k!)</i>),
			
 
				+esse valor <b>não</b> poderá ser computado usando a expressão seguinte (com chamada à função <tt class="var">fat</tt>):
			
 
				+<tt class="var">fat(n)/(fat(n-k)fat(k))</tt>.
			
 
				+<br/>
			
 
				+Por que mesmo? Porque, os valores a partir dos quais desejamos saber a combinação já são <b>dados</b>, <b>não</b> faz sentido obrigar
			
 
				+o usuário a digitar os valores de <tt>n</tt>, de <tt>n-k</tt> e de <tt>k</tt> (além disso ele pode digitar errado!).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Assim, nos exercícios que apresentam o conceito de função (portanto envolvendo um bloco lógico com propósito bem definido),
			
 
				+exigiremos que o aprendiz <b>não</b> use comandos de entrada ou de saída de dados <b>dentro da função</b>.
			
 
				+Com isso esperamos que ele adquira <i>bons hábitos de programação</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+<!-- F<sub>0</sub>=1, F<sub>1</sub>=1, F<sub>k</sub> = F<sub>k-1</sub> + F<sub>k-2</sub>, k&gt;2 -->  
			
 
				+Entretanto, existem as exceções, exemplos nos quais é útil usar comando de entrada ou de saída dentro da função. Ilustraremos
			
 
				+o caso de utilidade de um comando de saída dentro da função, isso ocorre se desejamos computar (e imprimir) os <tt>n</tt> primeiros termos da
			
 
				+<i title="F_{0}=1, F_{1}=1, F_{k} = F_{k-1} + F_{k-2}, k&gt;1">sequência de Fibonacci</i>.
			
 
				+Então, naturalmente precisaremos do comando de impressão/saída e como isso pode ser feito para qualquer
			
 
				+<tt>n</tt> é adequado agrupar esse código na forma de um procedimento separado (no caso uma função <b>sem</b> valor de retorno).
			
 
				+<br/>
			
 
				+Porém se o objetivo fosse conhecer apenas o termo <tt>n</tt> da sequência, a função <b>não deveria ter o comando de saída</b>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Uma última observação sobre os exercícios envolvendo funções. <b>O programa principal sempre deve ter ao menos um comando para entrada
			
 
				+e ao menos um para saída de dados</b>. Sem eles não seria possível testar se a função do exercício foi implementada corretamente ou não.
			
 
				+</p>
			
 
				+
			
 
				+<span style="color: #0055AA;font-size:1.1em">Exemplo 1. Dados naturais <tt>n</tt> e <tt>k</tt>, computar a combinação de <tt>n</tt> <tt>k-a-k</tt></span>
			
 
				+
			
 
				+<p>
			
 
				+Suponha que precisemos fazer um program para computar
			
 
				+quantas são as combinações de <tt>n</tt> termos combinados <tt>k</tt>-a-<tt>k</tt>, ou seja, tendo <tt>n</tt> elementos,
			
 
				+desejamos saber de quantos modos distintos podemos formar grupos com <tt>k</tt> dos elementos.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Esse conceito aparece em <i>probabilidade</i> e em <i>combinatória</i>, sabemos que esta combinação corresponde ao agrupamentos de
			
 
				+elementos nos quais a ordem não importa (tanto faz a ordem dos <tt>k</tt> elementos do tipo <tt>a</tt>) e que a fórmula que fornece
			
 
				+o total desses subconjuntos é a seguinte:
			
 
				+<center><a href="https://en.wikipedia.org/wiki/Binomial_theorem" title="explicacao mais detalhada na WikiPedia">C(n,k) = n! / ((n-k)! k!)</a>.</center>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Por exemplo, combinar <tt>6</tt> valores distintos, tomados <tt>2</tt> a <tt>2</tt> resulta <tt>15=6!/((6-2)!2!)=6!/(4!2!)</tt>, que
			
 
				+são os <tt>15</tt> subconjuntos: 
			
 
				+ <tt>(6,5)</tt>, <tt>(6,4)</tt>, <tt>(6,3)</tt>, <tt>(6,2)</tt>, <tt>(6,1)</tt>, 
			
 
				+ <tt>(5,4)</tt>, <tt>(5,3)</tt>, <tt>(5,2)</tt>, <tt>(5,1)</tt>,
			
 
				+ <tt>(4,3)</tt>, <tt>(4,2)</tt>, <tt>(4,1)</tt>,
			
 
				+ <tt>(3,2)</tt>, <tt>(3,1)</tt>,
			
 
				+ <tt>(2,1)</tt>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Assim, existem duas possibilidades de implementar esse código, uma implementando a função fatorial (<tt>fat(n)</tt>) que seria
			
 
				+invocada três vezes pelo programa principal (com algo como  <tt>imprima(fat(n) / (fat(k) * fat(n-k))</tt>.
			
 
				+Outra possibilidade é implementar também o cômputo de <tt>fat(n) / (fat(k) * fat(n-k))</tt> também como uma função.
			
 
				+Apesar dessa segunda possibilidade não ajudar tanto na organização do código (pois a segunda função (<tt>comb(n,k)</tt>) seria muito
			
 
				+simples, ilustraremos dessa forma por ela usar função chamando função que chama função (a principal chama <tt>comb(n,k)</tt> e essa
			
 
				+chama <tt>fat(n)</tt>).
			
 
				+Veja como ficaria o código em uma <i>pseudo-linguagem</i> de programação:
			
 
				+<pre>int fat(n) { //# estou supondo que o valor digitado pelo usuario seja um natural maior ou igual a 0 (n>=0)
			
 
				+  valfat = 1;
			
 
				+  cont = 2;
			
 
				+  enquanto (cont&lt;=n) { //# continue computando enquanto nao chegar ao valor cont==n
			
 
				+    valfat = valfat * cont;
			
 
				+    cont = cont + 1;	    
			
 
				+    }
			
 
				+  devolva valfat;
			
 
				+  }
			
 
				+int comb(n, k) {
			
 
				+  devolva fat(n) / (fat(n-k)*fat(k));
			
 
				+  }
			
 
				+principal() {
			
 
				+  declara_inteiros N, k; //# note que os nomes de variaveis daqui tem relacao NULA com os usados em 'fat'
			
 
				+  declara_inteiros a, b, c; //# para uma segunda versao
			
 
				+  leia(N, k); //# leia 2 valores naturais e armazene-os respectivamente em N e em k (espera-se que digite N>=k)
			
 
				+  //# pode-se invocar seguidamente fat 3 vezes como abaixo:
			
 
				+  imprima(comb(N,k);
			
 
				+  //# pode-se invocar a funcao fat 3 vezes e armazenar cada resultado e depois "imprimir"
			
 
				+  a = fat(N);
			
 
				+  b = fat(k);
			
 
				+  c = fat(N-k);
			
 
				+  imprima(a/( b * c))); //# este exemplo e' ilustrado na figura abaixo
			
 
				+  }</pre>
			
 
				+</p>
			
 
				+
			
 
				+<center><img src="img/exemplo_exec_funcao.jpg" title="exemplo de execucao da funcao"/>
			
 
				+</center>
			
 
				+
			
 
				+<p>
			
 
				+Novamente para enfatizar as desvantagens de usar leitura ou impressão dentro de funções, 
			
 
				+procure implementar o código acima, em sua linguagem favorita, e colocar nele comandos para
			
 
				+leitura ou saída dentro da função <tt>fat(n)</tt>, como discutido abaixo.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<span style="color: #0055AA;font-size:1.1em">Observação 1. Vantagem de uso de função sem comandos de entrada/saída - combinação n, k-a-k</span>
			
 
				+
			
 
				+<p>
			
 
				+Note que se dentro da função <tt>fat</tt> houvesse um comando do tipo <tt>leia(n);</tt>
			
 
				+a função NÃO poderia ser usada, pois ao ser invocada as 3 vezes, em cada uma delas exigiria que o
			
 
				+usuário digitasse novamente o valor para <tt>N</tt> inicialmente (estragando o valor de <tt>N</tt> passado para a função),
			
 
				+depois exigiria a digitação novamente do <tt>k</tt> e por último haveria o absurdo de exigir que o usuário
			
 
				+digitasse o valor para <tt>N-k</tt>.
			
 
				+</p>  
			
 
				+
			
 
				+<p>
			
 
				+De forma análoga, se a função <tt>fat</tt> tivesse algum comando de saída, ao usar a função 3 vezes, o usuário
			
 
				+receberia informações confusas: ele deseja a combinação de <tt>n</tt> combinados <tt>k</tt>-a-<tt>k</tt>, mas
			
 
				+receberia 4 infomações (<tt>n!</tt>, <tt>k!</tt>, <tt>(n-k)!</tt> e <tt>n!/(k! (n-k)!))))</tt>).
			
 
				+</p>
			
 
				+
			
 
				+<span style="color: #0055AA;font-size:1.1em">Observação 2. Propriedade interessante de C(n,k) - Triângulo de Pascal</span>
			
 
				+
			
 
				+<p>
			
 
				+Se rodarmos este programa seguidamente, na ordem das colunas (primeiro a única entrada de <tt>Entradas 0</tt>, depois a primeira
			
 
				+linha de <tt>Entradas 1</tt>, depois sua segunda linha e assim por diante até a última linha de <tt>Entradas 4</tt>) e
			
 
				+agruparmos as saídas de cada coluna em uma única linha, obteremos a tabela na última coluna abaixo (<tt>Saídas (cada linha um dos blocos de entradas)</tt>).
			
 
				+Destacamos três dos valores para mostrar a relação do
			
 
				+<a href="https://en.wikipedia.org/wiki/Pascal%27s_triangle" title="seguir para WikiPedia">Triângulo de Pascal</a>
			
 
				+
			
 
				+<table class="tableCd">
			
 
				+ <tr class="trCd" valign="top">
			
 
				+   <td>Linhas &nbsp;&nbsp;</td><td>Entradas 0&nbsp;&nbsp;</td><td>Entradas 1&nbsp;&nbsp;</td><td>Entradas 2&nbsp;&nbsp;</td>
			
 
				+   <td>Entradas 3&nbsp;&nbsp;</td><td>Entradas 4&nbsp;&nbsp;</td>
			
 
				+   <td>Saídas (cada linha um dos blocos de entradas)</td></tr>
			
 
				+ <tr class="trCd" valign="top"><td><pre>   0
			
 
				+   1
			
 
				+   2
			
 
				+   3
			
 
				+   4</pre></td><td><pre> 1   0</pre></td>   <td><pre> 1   1
			
 
				+ 1   0</pre></td><td><pre> 2   0
			
 
				+ 2   1
			
 
				+ 2   2</pre></td><td><pre> 3   0
			
 
				+ 3   1
			
 
				+ 3   2
			
 
				+ 3   3</pre></td><td><pre> 4   0
			
 
				+ 4   1
			
 
				+ 4   2
			
 
				+ 4   3
			
 
				+ 4   4</pre></td><td><pre> 1
			
 
				+ 1   1
			
 
				+ 1   2   1
			
 
				+[1] [3]   3   1
			
 
				+ 1  [4]   6   4   1</pre></td></tr></table></p>
			
 
				+
			
 
				+<p>
			
 
				+Examinando as saídas (ũltima coluna) notamos uma propriedade interessante:
			
 
				+o elemento da linha <tt>n+1</tt>, coluna <tt>k+1</tt> = o elemento da linha <tt>n</tt>, coluna <tt>k</tt> + o elemento da linha <tt>n</tt>, coluna </tt>k+1</tt>.
			
 
				+Veja por exemplo, a última linha, linha <tt>4</tt>: o segundo elemento = <tt>4</tt> = <tt>1 + 3</tt> (da linha acima).
			
 
				+</p>
			
 
				+
			
 
				+<!--
			
 
				+<pre>1 0
			
 
				+---
			
 
				+1 1
			
 
				+1 0
			
 
				+---
			
 
				+2 0
			
 
				+2 1
			
 
				+2 2
			
 
				+---
			
 
				+3 0
			
 
				+3 1
			
 
				+3 2
			
 
				+3 3
			
 
				+---
			
 
				+4 0
			
 
				+4 1
			
 
				+4 2
			
 
				+4 3
			
 
				+4 4</pre>
			
 
				+-->
			
 
				+
			
 
				+<!-- https://pt.wikipedia.org/wiki/Produtos_not%C3%A1veis -->
			
 
				+
			
 
				+<!--
			
 
				+<span style="color: #0055AA;font-size:1.1em">Exemplo 2. Coeficientes da expansão do produto notável <tt>(a+b)^n</tt></span>
			
 
				+
			
 
				+<p>
			
 
				+Suponhamos que precisemos fazer um program que computa os termos dos coeficientes da expansão de <tt>(a+b)^n</tt>.
			
 
				+Ou seja, desejamos um programa que dado <tt>n</tt> liste quantos termos do tipo <tt>a^i x b^j</tt> existe, para cada
			
 
				+<tt>i</tt> e cada <tt>j</tt> tais que <tt>i+j=n</tt>.
			
 
				+
			
 
				+  o valor da combinação de <i>N</i> tomado <i>k</i> a <i>k</i>, ou seja,
			
 
				+C(N,k) = N! / ( k! (N-k)!).
			
 
				+Para isso percebe-se que é necessário implementar o cômputo de fatorial que será utilizado 3 vezes.
			
 
				+Para facilitar a compreensão, podemos escrever um código com 3 variáveis auxiliares para armazenar, respectivamente,
			
 
				+<i>N!</i>, <i>k!</i> e <i>(N-k)!</i>.
			
 
				+</p>
			
 
				+
			
 
				+<pre>(a+b)^0                                                         = 1 a^0 b^0
			
 
				+(a+b)^1 = (a+b) (0 a^0 b^0 + 0 a^0 b^0)                         = 1 a^1 b^0 + 1 a^0 b^0 
			
 
				+(a+b)^2 = (a+b) (1 a^1 b^0 + 0 a^0 b^1)                         = 1 a^2 b^0 + 2 a^1 b^1 + 1 a^0 b^2
			
 
				+(a+b)^3 = (a+b) (1 a^2 b^0 + 2 a^1 b^1 + 1 a^0 b^2)             = 1 a^3 b^0 + 3 a^2 b^1 + 3 a^1 b^2 + 1 a^0 b^3
			
 
				+(a+b)^4 = (a+b) (1 a^3 b^0 + 3 a^2 b^1 + 3 a^1 b^2 + 1 a^0 b^3) = 1 a^4 b^0 + 4 a^3 b^1 + 6 a^2 b^2 + 4 a^1 b^3 + 1 a^0 b^3a
			
 
				+</pre>
			
 
				+<pre>1
			
 
				+1 1
			
 
				+1 2 1
			
 
				+1 3 3 1
			
 
				+1 4 6 4 1
			
 
				+</pre>
			
 
				+-->
			
 
				+
			
 
				+<p>
			
 
				+Leônidas de Oliveira Brandão<br/>
			
 
				+http://line.ime.usp.br
			
 
				+<!--
			
 
				+ 2017/04/06: primeira versao
			
 
				+ 2019/04/07: versao 2 (acrescentado novos paragrafos, melhorando explicacoes e frases)
			
 
				+-->
			
 
				+</p>
			
 
				+</body>
			
--- a/img/comando_selecao_expr_logica.jpg
+++ b/img/comando_selecao_expr_logica.jpg
--- a/img/exemplo_exec_funcao.jpg
+++ b/img/exemplo_exec_funcao.jpg
--- a/img/funcoes_var_locais.png
+++ b/img/funcoes_var_locais.png
--- a/img/icn_editor_101.png
+++ b/img/icn_editor_101.png
--- a/img/icn_editor_128.png
+++ b/img/icn_editor_128.png
--- a/img/icn_planilha_101.png
+++ b/img/icn_planilha_101.png
--- a/img/icn_planilha_128.png
+++ b/img/icn_planilha_128.png
--- a/img/ihanoi.png
+++ b/img/ihanoi.png
--- a/img/ihanoi1.png
+++ b/img/ihanoi1.png
--- a/img/ihanoi2.png
+++ b/img/ihanoi2.png
--- a/img/ihanoi3.png
+++ b/img/ihanoi3.png
--- a/img/ihanoi4.png
+++ b/img/ihanoi4.png
--- a/img/img_calc.png
+++ b/img/img_calc.png
--- a/img/img_computador_io.png
+++ b/img/img_computador_io.png
--- a/img/img_conj_a_contido_b.png
+++ b/img/img_conj_a_contido_b.png
--- a/img/img_conj_nao_a.png
+++ b/img/img_conj_nao_a.png
--- a/img/img_conj_nao_a_e_b.png
+++ b/img/img_conj_nao_a_e_b.png
--- a/img/img_eficiencia_cos_trig.png
+++ b/img/img_eficiencia_cos_trig.png
--- a/img/img_estrutura_basica_terminal_topo.png
+++ b/img/img_estrutura_basica_terminal_topo.png
--- a/img/img_expressoes.png
+++ b/img/img_expressoes.png
--- a/img/img_fatorial_def.png
+++ b/img/img_fatorial_def.png
--- a/img/img_fatorial_fat3.png
+++ b/img/img_fatorial_fat3.png
--- a/img/img_intr_char_memoria.png
+++ b/img/img_intr_char_memoria.png
--- a/img/img_intr_var_1.png
+++ b/img/img_intr_var_1.png
--- a/img/img_introd_apontador.png
+++ b/img/img_introd_apontador.png
--- a/img/img_introd_apontador_apontador_apontador.png
+++ b/img/img_introd_apontador_apontador_apontador.png
--- a/img/img_invisivel.png
+++ b/img/img_invisivel.png
--- a/img/img_precisao_x_velocidade.png
+++ b/img/img_precisao_x_velocidade.png
--- a/img/img_real_ponto_fixo.png
+++ b/img/img_real_ponto_fixo.png
--- a/img/img_recorrencia_exp_arit_1.jpg
+++ b/img/img_recorrencia_exp_arit_1.jpg
--- a/img/img_recorrencia_exp_arit_2.jpg
+++ b/img/img_recorrencia_exp_arit_2.jpg
--- a/img/img_recursividade1_pos.png
+++ b/img/img_recursividade1_pos.png
--- a/img/img_recursividade1_pre.png
+++ b/img/img_recursividade1_pre.png
--- a/img/img_recursividade_arvore_binaria.png
+++ b/img/img_recursividade_arvore_binaria.png
--- a/img/img_vet_memoria.png
+++ b/img/img_vet_memoria.png
--- a/img/img_visivel.png
+++ b/img/img_visivel.png
--- a/img/index.html
+++ b/img/index.html
--- a/img/int_mat_representacao.png
+++ b/img/int_mat_representacao.png
--- a/img/int_vet_apontador.png
+++ b/img/int_vet_apontador.png
--- a/img/int_vet_apontador_menor.png
+++ b/img/int_vet_apontador_menor.png
--- a/img/int_vet_vet_representacao.png
+++ b/img/int_vet_vet_representacao.png
--- a/img/moodle_vpl3.1.4_avaliar.png
+++ b/img/moodle_vpl3.1.4_avaliar.png
--- a/img/moodle_vpl3.1.4_gravar.png
+++ b/img/moodle_vpl3.1.4_gravar.png
--- a/img/moodle_vpl3.2.4_avaliar.png
+++ b/img/moodle_vpl3.2.4_avaliar.png
--- a/img/moodle_vpl3.2.4_gravar.png
+++ b/img/moodle_vpl3.2.4_gravar.png
--- a/img/moodle_vpl_debug1.jpg
+++ b/img/moodle_vpl_debug1.jpg
--- a/img/ordenacao_vetor.png
+++ b/img/ordenacao_vetor.png
--- a/img/ordenacao_vetor_bolha.png
+++ b/img/ordenacao_vetor_bolha.png
--- a/img/ordenacao_vetor_insercao1.png
+++ b/img/ordenacao_vetor_insercao1.png
--- a/img/ordenacao_vetor_insercao2.png
+++ b/img/ordenacao_vetor_insercao2.png
--- a/img/ordenacao_vetor_selecao.png
+++ b/img/ordenacao_vetor_selecao.png
--- a/img/pt_fluxo_laco_enquanto_entrada.png
+++ b/img/pt_fluxo_laco_enquanto_entrada.png
--- a/img/pt_fluxo_laco_n_vezes.png
+++ b/img/pt_fluxo_laco_n_vezes.png
--- a/img/pt_fluxo_se.png
+++ b/img/pt_fluxo_se.png
--- a/img/pt_fluxo_se_senao.png
+++ b/img/pt_fluxo_se_senao.png
--- a/img/recorrencia_fractal_tetracirculo.gif
+++ b/img/recorrencia_fractal_tetracirculo.gif
--- a/img/recorrencia_tela.png
+++ b/img/recorrencia_tela.png
--- a/img/recorrencia_tela_menor.png
+++ b/img/recorrencia_tela_menor.png
--- a/img/recorrencia_tela_menor_limpa.png
+++ b/img/recorrencia_tela_menor_limpa.png
--- a/img/sobre_exerc_online_editar_avaliar_3.jpg
+++ b/img/sobre_exerc_online_editar_avaliar_3.jpg
--- a/img/var_memoria1.jpg
+++ b/img/var_memoria1.jpg
--- a/img/var_memoria2.jpg
+++ b/img/var_memoria2.jpg
--- a/index.html
+++ b/index.html
@@ -0,0 +1,366 @@
 
				+<!DOCTYPE html>
			
 
				+<html dir='ltr' xml:lang='pt-br' lang='pt-br'>
			
 
				+ <head>
			
 
				+  <title>Introdução à Programação :: Prof. Leônidas O. Brandão (LInE/IME/USP)</title>
			
 
				+  <meta http-equiv='Content-Type' content='text/html; charset=UTF-8' />
			
 
				+
			
 
				+<!--
			
 
				+Apostila Intrudução à Resolução de Problemas via Algoritmos [Arquivo PDF]
			
 
				+Sobre a estrutura básica de um programa em C ou em Python [Pagina Moodle] -> URL
			
 
				+Sobre a linguagem a ser usada e sobre os exercícios com avaliação automática [Pagina Moodle] ->
			
 
				+Veja exemplos de erros no avaliador automático e como evitá-los (FAQ) [Pagina Moodle]
			
 
				+Sobre nova versão do avaliador automático de exercícios de programacão (2017/05/10)
			
 
				+
			
 
				+Aparencia baseada em modelo do Moodle 3.X
			
 
				+ * css_img_js_conf/icone_leo.png
			
 
				+ * css_img_js_conf/folder.svg
			
 
				+ * css_img_js_conf/all.css
			
 
				+
			
 
				+Mini-tutorial sobre o editor "online": como fazer, editar e verificar se um programa foi enviado - [URL] tutor_sobre_editor_vpl/
			
 
				+Sobre a estrutura básica de um programa em C ou em Python                                        - [URL] introducao_estrutura_basica_c_python.html
			
 
				+Introdução às variáveis e expressões aritméticas                                                 - [URL] introducao_var.html
			
 
				+Introdução à entrada de dados em Python 2                                                        - [URL] introducao_leituras_python.html
			
 
				+Introdução ao comando de seleção e às expressões lógicas                                         - [URL] introducao_if.html
			
 
				+Introdução elementar à Lógica                                                                    - [URL] introducao_logica.html
			
 
				+Introdução às técnicas básicas de depuração de código                                            - [URL] introducao_depuracao_codigos.html
			
 
				+Introdução ao comando de repetição while                                                         - [URL] introducao_while.html
			
 
				+Introdução ao uso de funções em C e em Python                                                    - [URL] introducao_funcoes.html 
			
 
				+Introdução ao uso de funções em C: variáveis locais, globais e aninhamento de funções            - [URL] introducao_funcoes_c.html           2018/05/21
			
 
				+Introdução ao uso de funções em Python: variáveis locais, globais e aninhamento de funções       - [URL] introducao_funcoes_python.html      2018/05/21
			
 
				+Introdução ao comando de repeticao for em C e em Python                                          - [URL] introducao_for.html
			
 
				+Introdução ao conceito de indicador de passagem                                                  - [URL] indicador_passagem.html
			
 
				+Introdução ao conceito de eficiência de algoritmos                                               - [URL] introducao_eficiencia_algoritmos.html
			
 
				+Introdução à ordenação                                                                           - [URL] introducao_ordenacao.html           2019/06/16
			
 
				+Por que evitar entrada/saida de dados em funções?                                                - [URL] evitar_entrada_saida_em_funcao.html
			
 
				+Introdução ao uso de matrizes                                                                    - [URL] introducao_matrizes.html
			
 
				+
			
 
				+-->
			
 
				+
			
 
				+
			
 
				+  <meta name='keywords' content='mac0122, material, professore, 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' />
			
 
				+  </style>
			
 
				+ </head>
			
 
				+
			
 
				+<body class='format-topics gecko lang-pt_br pagelayout-incourse'>
			
 
				+
			
 
				+<div id='page-wrapper'>
			
 
				+
			
 
				+  <header role='banner' class='navbar navbar-full navbar-light bg-faded navbar-static-top'>
			
 
				+    <div class='container-fluid navbar-nav'>
			
 
				+      <a href='index.html' class='navbar-brand' title="Início do material para Introdução à Programação">Introdução</a><!-- botao fundo azul -->
			
 
				+      <!-- user_menu -->
			
 
				+      <div class='usermenu'>
			
 
				+        <div class='menubar' id='action-menu-1-menubar' role='menubar'>
			
 
				+          <a href='http://www.ime.usp.br/~leo' title='seguir para sitio pessoal do autor' role='button'>
			
 
				+           <span class='userbutton'>
			
 
				+             <span class='usertext'>Leônidas de Oliveira Brandão</span>
			
 
				+             <span class='avatars 'avatar current'>
			
 
				+               <img src='css_img_js_conf/icone_leo.png' alt='Imagem de Leônidas de Oliveira Brandão'
			
 
				+                    title='Imagem de Leônidas de Oliveira Brandão' class='userpicture' role='presentation' height='35' width='35'>
			
 
				+             </span>
			
 
				+           </span>
			
 
				+          </a>
			
 
				+        </div>
			
 
				+      </div>
			
 
				+    </div><!-- class='container-fluid navbar-nav' -->
			
 
				+  </header>
			
 
				+
			
 
				+  <div id='page' class='container-fluid'>
			
 
				+
			
 
				+   <header id='page-header' class='row'>
			
 
				+
			
 
				+    <div class='col-xs-12'>
			
 
				+     <div class='card card-block titulo'>
			
 
				+       <h1>Material didático para Introdução à Programação</h1>
			
 
				+       <!-- caminho -->
			
 
				+       <div class='clearfix w-100 pull-xs-left' id='page-navbar'>
			
 
				+        <div class='breadcrumb-nav'>
			
 
				+         <nav role='navigation'>
			
 
				+          <ol class='breadcrumb'>
			
 
				+           <li class='breadcrumb-item'><a href='http://www.ime.usp.br/~leo/'>Página inicial</a></li>
			
 
				+           <li class='breadcrumb-item'><a href='index.html' title='inicio material'>Material de apoio didático</a></li>
			
 
				+          </ol>
			
 
				+         </nav>
			
 
				+        </div>
			
 
				+       </div>
			
 
				+     </div>
			
 
				+    </div><!-- class='col-xs-12 p-a-1' -->
			
 
				+
			
 
				+    <div class='col-xs-12 p-a-1'><!-- class='col-xs-12 p-a-1' -->
			
 
				+     <div class='card card-itens'><!-- class='card' -->
			
 
				+      <div class='card-block'><!-- class='card-block' -->
			
 
				+
			
 
				+    <div id="page-content" class="row">
			
 
				+      <div id="region-main-box" class="col-xs-12">
			
 
				+
			
 
				+        <section id="region-main">
			
 
				+          <div class="card-itens">
			
 
				+
			
 
				+          <div role="main">
			
 
				+            <h2>Material didático de apoio aos cursos introdutórios de programação</h2>
			
 
				+            <div class="box generalbox center clearfix p-y-1">
			
 
				+
			
 
				+              <!-- Itens -->
			
 
				+              <div class="media-group list-group"> <!-- Lista de material -->
			
 
				+
			
 
				+                <!-- diretorios -->
			
 
				+                <a href="tutor_sobre_editor_vpl/index.html" class="list- group-item">
			
 
				+                <p>
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/folder.svg" />
			
 
				+                  Mini-tutorial sobre o editor "online": como fazer, editar e verificar se um programa foi enviado
			
 
				+                </p>
			
 
				+                </a>
			
 
				+                <!-- arquivos -->
			
 
				+                <a href="line_introducao_estrutura_basica_c_python.html" class="list-group-item">
			
 
				+                <p>
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg" />
			
 
				+                  Sobre a estrutura básica de um programa em C ou em Python
			
 
				+                </p>
			
 
				+                </a>
			
 
				+
			
 
				+                <a href="line_introducao_var.html" class="list-group-item">
			
 
				+                <p>
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Introdução às variáveis e expressões aritméticas
			
 
				+                </p>
			
 
				+                </a>
			
 
				+
			
 
				+                <p>
			
 
				+                <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Declarar/usar variáveis e modos para entrada/saída:
			
 
				+                  <a class="" title="Ver E/S em Python 2" href="line_introducao_leituras_python2.html" class="list-group-item">
			
 
				+                     em Python 2</a>;
			
 
				+                  <a class="" title="Ver E/S em C" href="line_introducao_leituras_c.html" class="list-group-item">
			
 
				+                     em C</a>
			
 
				+                </p>
			
 
				+
			
 
				+                <a href="line_introducao_logica.html" class="list-group-item">
			
 
				+                <p>
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Introdução elementar à lógica
			
 
				+                </p>
			
 
				+                </a>
			
 
				+
			
 
				+                <a href="line_introducao_depuracao_codigos.html" class="list-group-item">
			
 
				+                <p>
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Introdução às técnicas básicas de depuração de código
			
 
				+                </p>
			
 
				+                </a>
			
 
				+
			
 
				+                <a href="line_introducao_inteiros.html" class="list-group-item">
			
 
				+                <p>
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Introdução aos números inteiros
			
 
				+                </p>
			
 
				+                </a>
			
 
				+
			
 
				+                <a href="line_introducao_float.html" class="list-group-item">
			
 
				+                <p>
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Introdução aos números "reais" (ponto flutuante)
			
 
				+                </p>
			
 
				+                </a>
			
 
				+
			
 
				+                <a href="line_introducao_inteiro_float.html" class="list-group-item">
			
 
				+                <p>
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Introdução à conversão inteiro/float e divisões
			
 
				+                </p>
			
 
				+                </a>
			
 
				+
			
 
				+                <a href="line_introducao_char.html" class="list-group-item">
			
 
				+                <p>
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Introdução aos caracteres
			
 
				+                </p>
			
 
				+                </a>
			
 
				+
			
 
				+                <a href="line_introducao_if.html" class="list-group-item">
			
 
				+                <p>
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Introdução ao comando de seleção e às expressões lógicas
			
 
				+                </p>
			
 
				+                </a>
			
 
				+
			
 
				+                <a href="line_introducao_while.html" class="list-group-item">
			
 
				+                <p>
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Introdução ao comando de repetição while
			
 
				+                </p>
			
 
				+                </a>
			
 
				+
			
 
				+                <a href="line_introducao_funcoes.html" class="list-group-item">
			
 
				+                <p>
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Introdução ao uso de funções em C e em Python
			
 
				+                </p>
			
 
				+                </a>
			
 
				+
			
 
				+                <a href="line_evitar_entrada_saida_em_funcao.html" class="list-group-item">
			
 
				+                <p>
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Por que evitar entrada/saida de dados em funções?
			
 
				+                </p>
			
 
				+                </a>
			
 
				+
			
 
				+                <a href="line_introducao_parametros_funcoes.html" class="list-group-item">
			
 
				+                <p>
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Introdução ao conceito de parâmetros para funções
			
 
				+                </p>
			
 
				+                </a>
			
 
				+
			
 
				+                <a href="line_introducao_funcoes_python.html" class="list-group-item">
			
 
				+                <p>
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Introdução ao uso de funções em Python: variáveis locais, globais e aninhamento de funções
			
 
				+                </p>
			
 
				+                </a>
			
 
				+
			
 
				+                <a href="line_introducao_funcoes_c.html" class="list-group-item">
			
 
				+                <p>
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Introdução ao uso de funções em C: variáveis locais, globais e aninhamento de funções
			
 
				+                </p>
			
 
				+                </a>
			
 
				+
			
 
				+
			
 
				+                <p>
			
 
				+                <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Vetores, matrizes e "strings":
			
 
				+                  <a class="" title="Ver introdução ao conceito" href="line_introducao_vetores.html" class="list-group-item">
			
 
				+                     introdução</a>;
			
 
				+                  <a class="" title="Alguns detalhes em Python" href="line_introducao_vetores_python.html" class="list-group-item">
			
 
				+                    alguns detalhes em <i>Python</i></a>; e
			
 
				+                  <a class="" title="Alguns detalhes em C" href="line_introducao_vetores_c.html" class="list-group-item">
			
 
				+                    alguns detalhes em <i>C</i></a>
			
 
				+                </p>
			
 
				+
			
 
				+                <a href="line_introducao_apontadores_c.html" class="list-group-item">
			
 
				+                <p>
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Introdução aos apontadores com a linguagem <i>C</i>
			
 
				+                </p>
			
 
				+                </a>
			
 
				+
			
 
				+                <a href="line_introducao_matrizes.html" class="list-group-item">
			
 
				+                <p>
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Introdução ao uso de matrizes
			
 
				+                </p>
			
 
				+                </a>
			
 
				+
			
 
				+                <a href="line_introducao_for.html" class="list-group-item">
			
 
				+                <p>
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Introdução ao comando de repetição <i>for</i><!-- em <i>C</i> e em <i>Python</i>-->
			
 
				+                </p>
			
 
				+                </a>
			
 
				+
			
 
				+                <a href="line_indicador_passagem.html" class="list-group-item">
			
 
				+                <p>
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Introdução ao conceito de indicador de passagem
			
 
				+                </p>
			
 
				+                </a>
			
 
				+
			
 
				+                <a href="line_introducao_eficiencia_algoritmos.html" class="list-group-item">
			
 
				+                <p>
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Introdução ao conceito de eficiência de algoritmos
			
 
				+                </p>
			
 
				+                </a>
			
 
				+
			
 
				+                <a href="line_introducao_ordenacao.html" class="list-group-item">
			
 
				+                <p>
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Introdução à ordenação
			
 
				+                </p>
			
 
				+                </a>
			
 
				+
			
 
				+                <a href="line_introducao_recursividade.html" class="list-group-item">
			
 
				+                <p>
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Introdução ao conceito de algoritmos recursivos (ou recorrentes)
			
 
				+                </p>
			
 
				+                </a>
			
 
				+
			
 
				+
			
 
				+                <a href="line_introducao_recursividade_exemplos.html" class="list-group-item">
			
 
				+                <p class="ultimo"><!-- precisa para linha final -->
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Mais exemplos de algoritmos recursivos (ou recorrentes)
			
 
				+                </p>
			
 
				+                </a>
			
 
				+
			
 
				+
			
 
				+<!--
			
 
				+                <p>
			
 
				+                <a href="line_">
			
 
				+                <p>
			
 
				+                  <img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg">
			
 
				+                  Sobre...
			
 
				+                </p>
			
 
				+                </a>
			
 
				+-->
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+              </div><!-- class="media-group list-group" --> <!-- Lista de material -->
			
 
				+              </div><!-- Itens -->
			
 
				+            </div><!-- class="box generalbox center clearfix p-y-1" -->
			
 
				+          </div><!-- role="main" -->
			
 
				+          </div><!--  -->
			
 
				+        </section><!-- id="region-main" -->
			
 
				+      </div><!-- id="region-main-box" class="col-xs-12" -->
			
 
				+    </div><!-- id="page-content" class="row" -->
			
 
				+
			
 
				+  <p class="autoria">
			
 
				+    <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">
			
 
				+     Última atualização: domingo, 16 Ago 2020: nova estrutura (HTML com JavaScript), ampla revisão na maioria dos textos.
			
 
				+     <!--
			
 
				+       domingo, 16 Ago 2020, 16:00 - nova estrutura (HTML com JavaScript), ampla revisão na maioria dos textos
			
 
				+       sexta,   14 Ago 2020, 23:00 - nova estrutura, novo CSS
			
 
				+       segunda, 06 Jul 2020, 23:30 - novo texto sobre indicador de variáveis e entradas em Python 2 'introducao_leituras_python.html'
			
 
				+       quarta,  08 May 2019, 23:55 - novo texto sobre indicador de passagem 'indicador_passagem.html'
			
 
				+       sexta,   15 Jun 2018, 18:00 - novo texto sobre recorrencia 'introducao_recursividade_exemplos.html'
			
 
				+       domingo, 03 Jun 2018, 19:00 - revisao texto recorrencia 'introducao_recursividade.html'
			
 
				+       segunda, 21 May 2018, 19:00
			
 
				+       segunda, 21 May 2018, 19:00 - novos textos 'introducao_funcoes_c.html,introducao_funcoes_python.html'
			
 
				+       terca,   08 May 2018, 12:00 - revisao dos textos; sobre vetor, matriz e "string"; de eficiencia; de char_float (detalhe); de funcoes
			
 
				+       terca,   08 May 2018, 12:00 - revisao dos textos; sobre vetor, matriz e "string"; de eficiencia; de char_float (detalhe); de funcoes
			
 
				+       sexta,   04 May 2018, 00:00 - novos textos sobre vetor, matriz e "string"
			
 
				+       sexta,   27 Abr 2018, 11:00 - alteracoes grandes no texto sobre comando for
			
 
				+       terca,   23 Abr 2018, 12:00 - novo texto sobre parametros de funcoes
			
 
				+       domingo, 15 Abr 2018, 21:00
			
 
				+       domingo, 15 Abr 2018, 21:00 - introducao_inteiros.html e introducao_float.html
			
 
				+       segunda, 20 Mar 2017, 17:02
			
 
				+     -->
			
 
				+  </p>
			
 
				+
			
 
				+  <footer id='page-footer' class='bg-inverse'>
			
 
				+    <div class='container'><div id='course-footer'></div>
			
 
				+      <p class='helplink'>Material didático - Prof. Leônidas de Oliveira Brandão</p>
			
 
				+    </div>
			
 
				+  </footer>
			
 
				+
			
 
				+</div><!-- class='card-block' 3 -->
			
 
				+</div><!-- class='card' -->
			
 
				+</div><!-- class='col-xs-12 p-a-1' -->
			
 
				+
			
 
				+</header><!-- id='page-header' class='row' -->
			
 
				+
			
 
				+</div><!-- id='page' class='container-fluid' -->
			
 
				+  
			
 
				+</div><!-- id='page-wrapper' -->
			
 
				+
			
 
				+</body>
			
 
				+</html>
			
--- a/index_mac2166_2017.html
+++ b/index_mac2166_2017.html
@@ -0,0 +1,182 @@
 
				+<!--
			
 
				+Aparencia baseada em modelo do Moodle 3.X
			
 
				+
			
 
				+ * css_img_js_conf/icone_leo.png
			
 
				+ * css_img_js_conf/folder.svg
			
 
				+ * css_img_js_conf/all.css
			
 
				+
			
 
				+Apostila Intrudução à Resolução de Problemas via Algoritmos [Arquivo PDF]
			
 
				+Sobre a estrutura básica de um programa em C ou em Python [Pagina Moodle] -> URL
			
 
				+Sobre a linguagem a ser usada e sobre os exercícios com avaliação automática [Pagina Moodle] ->
			
 
				+Veja exemplos de erros no avaliador automático e como evitá-los (FAQ) [Pagina Moodle]
			
 
				+Sobre nova versão do avaliador automático de exercícios de programacão (2017/05/10)
			
 
				+
			
 
				+Mini-tutorial sobre o editor "online": como fazer, editar e verificar se um programa foi enviado - [URL] tutor_sobre_editor_vpl/
			
 
				+Introdução às variáveis e expressões aritméticas                                                 - [URL] introducao_var.html
			
 
				+Introdução ao comando de seleção e às expressões lógicas                                         - [URL] introducao_if.html
			
 
				+Introdução ao comando de repetição while                                                         - [URL] introducao_while.html
			
 
				+Introdução ao uso de funções em C e em Python                                                    - [URL] introducao_funcoes.html 
			
 
				+Por que evitar entrada/saida de dados em funções?                                                - [URL] evitar_entrada_saida_em_funcao.html
			
 
				+Introdução ao uso de matrizes                                                                    - [URL] introducao_matrizes.html
			
 
				+
			
 
				+TAB = 8 espacos
			
 
				+-->
			
 
				+<!DOCTYPE html>
			
 
				+<html class="yui3-js-enabled" dir="ltr" xml:lang="pt-br" lang="pt-br">
			
 
				+ <head>
			
 
				+  <title>mac2166_web_2017: Mini-tutorial sobre o editor "online": como fazer, editar e verificar se um programa foi enviado</title>
			
 
				+  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
			
 
				+  <meta name="keywords" content="moodle, mac2166_web_2017: Mini-tutorial sobre o editor &quot;online&quot;: como fazer, editar e verificar se um programa foi enviado">
			
 
				+  <link rel="stylesheet" type="text/css" href="css_img_js_conf/all.css">
			
 
				+  <script id="firstthemesheet" type="text/css">/** Required in order to fix style inclusion problems in IE with YUI **/</script>
			
 
				+ </head>
			
 
				+
			
 
				+<body id="page-mod-page-view" class="format-topics gecko lang-pt_br pagelayout-incourse">
			
 
				+
			
 
				+<div id="page-wrapper">
			
 
				+
			
 
				+  <header role="banner" class="pos-f-t navbar navbar-full navbar-light bg-faded navbar-static-top">
			
 
				+
			
 
				+    <div class="container-fluid navbar-nav">
			
 
				+
			
 
				+      <a href="../index.html" class="navbar-brand">Início</a><!-- botao fundo azul -->
			
 
				+
			
 
				+      <!-- user_menu -->
			
 
				+      <div class="usermenu">
			
 
				+      <div class="action-menu moodle-actionmenu nowrap-items" id="action-menu-1" data-enhance="moodle-core-actionmenu">
			
 
				+      <div class="menubar" id="action-menu-1-menubar" role="menubar">
			
 
				+
			
 
				+      <div class="dropdown">
			
 
				+        <a href="http://www.ime.usp.br/~leo" title="sitio pessoal autor" role="button">
			
 
				+          <span class="userbutton">
			
 
				+            <span class="usertext">Leônidas de Oliveira Brandão</span>
			
 
				+             <span class="avatars">
			
 
				+              <span class="avatar current"><img src="css_img_js_conf/icone_leo.png" alt="Imagem de Leônidas de Oliveira Brandão" title="Imagem de Leônidas de Oliveira Brandão" class="userpicture" role="presentation" height="35" width="35"></span>
			
 
				+             </span>
			
 
				+          </span>
			
 
				+        </a>      
			
 
				+    </div>
			
 
				+  </header>
			
 
				+
			
 
				+
			
 
				+  <div id="page" class="container-fluid">
			
 
				+    <header id="page-header" class="row">
			
 
				+      <div class="col-xs-12 p-a-1">
			
 
				+        <div class="card">
			
 
				+          <div class="card-block">          
			
 
				+            <h1>Material didático para introdução à Computação</h1>
			
 
				+            <!-- caminho -->
			
 
				+            <div class="clearfix w-100 pull-xs-left" id="page-navbar">
			
 
				+              <div class="breadcrumb-nav">
			
 
				+                <nav role="navigation">
			
 
				+                  <ol class="breadcrumb">
			
 
				+                    <li class="breadcrumb-item"><a href="http://www.ime.usp.br/~leo/">Página inicial</a></li>
			
 
				+                    <li class="breadcrumb-item">Material de apoio didático/li>
			
 
				+                  </ol>
			
 
				+                </nav>
			
 
				+              </div>
			
 
				+            </div>
			
 
				+          </div>
			
 
				+        </div>
			
 
				+      </div>
			
 
				+    </header>
			
 
				+
			
 
				+
			
 
				+    <div id="page-content" class="row">
			
 
				+      <div id="region-main-box" class="col-xs-12">
			
 
				+
			
 
				+        <section id="region-main">
			
 
				+          <div class="card card-block">
			
 
				+            <div class="region_main_settings_menu_proxy"></div>
			
 
				+          <span class="notifications" id="user-notifications"></span>
			
 
				+          <div role="main"><span id="maincontent"></span>
			
 
				+            <h2>Material didático de apoio aos cursos ministrados</h2>
			
 
				+            <div class="box generalbox center clearfix p-y-1">
			
 
				+
			
 
				+              <!-- span class="media-left" : para nao mudar de linha -->
			
 
				+              <nav class="list-group"> <!-- Lista de material : nav class="list-group" -->
			
 
				+
			
 
				+                <!-- diretorios -->
			
 
				+                <a class="list-group-item list-group-item-action " href="tutor_sobre_editor_vpl/index.html">
			
 
				+                  <span class="media-left"><img class="icon smallicon" alt="" src="css_img_js_conf/folder.svg"></span>
			
 
				+                  <span class="media-body">Mini-tutorial sobre o editor "online": como fazer, editar e verificar se um programa foi enviado</span>
			
 
				+                </a>
			
 
				+<!--
			
 
				+                <a class="list-group-item list-group-item-action " href="">
			
 
				+                  <span class="media-left"><img class="icon smallicon" alt="" src="css_img_js_conf/folder.svg"></span>
			
 
				+                  <span class="media-body"> aqui 1 bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla, bla</span>
			
 
				+                </a>
			
 
				+-->		
			
 
				+		
			
 
				+                <!-- arquivos -->
			
 
				+                <a class="list-group-item list-group-item-action " href="introducao_estrutura_basica_c_python.html">
			
 
				+                  <span class="media-left"><img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg"></span>		  
			
 
				+                  <span class="media-body"><div class="m-l-0">Sobre a estrutura básica de um programa em C ou em Python</div></span>
			
 
				+                </a>
			
 
				+
			
 
				+                <a class="list-group-item list-group-item-action " href="introducao_var.html">
			
 
				+                  <span class="media-left"><img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg"></span>		  
			
 
				+                  <span class="media-body"><div class="m-l-0">Introdução às variáveis e expressões aritméticas</div></span>
			
 
				+                </a>
			
 
				+
			
 
				+                <a class="list-group-item list-group-item-action " href="introducao_char_float.html">
			
 
				+                  <span class="media-left"><img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg"></span>		  
			
 
				+                  <span class="media-body"><div class="m-l-0">Introdução aos caracteres e ponto flutuante</div></span>
			
 
				+                </a>
			
 
				+
			
 
				+                <a class="list-group-item list-group-item-action " href="introducao_if.html">
			
 
				+                  <span class="media-left"><img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg"></span>		  
			
 
				+                  <span class="media-body"><div class="m-l-0">Introdução ao comando de seleção e às expressões lógicas</div></span>
			
 
				+                </a>
			
 
				+
			
 
				+                <a class="list-group-item list-group-item-action " href="introducao_while.html">
			
 
				+                  <span class="media-left"><img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg"></span>		  
			
 
				+                  <span class="media-body"><div class="m-l-0">Introdução ao comando de repetição while</div></span>
			
 
				+                </a>
			
 
				+
			
 
				+                <a class="list-group-item list-group-item-action " href="introducao_funcoes.html">
			
 
				+                  <span class="media-left"><img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg"></span>		  
			
 
				+                  <span class="media-body"><div class="m-l-0">Introdução ao uso de funções em C e em Python</div></span>
			
 
				+                </a>
			
 
				+
			
 
				+                <a class="list-group-item list-group-item-action " href="evitar_entrada_saida_em_funcao.html">
			
 
				+                  <span class="media-left"><img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg"></span>		  
			
 
				+                  <span class="media-body"><div class="m-l-0">Por que evitar entrada/saida de dados em funções?</div></span>
			
 
				+                </a>
			
 
				+
			
 
				+                <a class="list-group-item list-group-item-action " href="introducao_matrizes.html">
			
 
				+                  <span class="media-left"><img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg"></span>		  
			
 
				+                  <span class="media-body"><div class="m-l-0">Introdução ao uso de matrizes</div></span>
			
 
				+                </a>
			
 
				+
			
 
				+<!--
			
 
				+                <a class="list-group-item list-group-item-action " href="">
			
 
				+                  <span class="media-left"><img class="icon smallicon" alt="" src="css_img_js_conf/navigationitem.svg"></span>		  
			
 
				+                  <span class="media-body"><div class="m-l-0">Sobre...</div></span>
			
 
				+                </a>
			
 
				+-->		
			
 
				+              </nav> <!-- Lista de material : nav class="list-group" -->
			
 
				+    
			
 
				+            </div>
			
 
				+            <div class="modified">Última atualização: segunda, 20 Mar 2017, 17:02</div></div>
			
 
				+          </div>
			
 
				+        </section>
			
 
				+      </div>
			
 
				+    </div>
			
 
				+  </div>
			
 
				+
			
 
				+<!--
			
 
				+  <li class="breadcrumb-item"><!-- a href="http://www.ime.usp.br/~leo/mac2166/2017-1/tutor_sobre_editor_vpl/" title=""-->Mini-tutorial sobre o editor "online": como fazer, editar e verificar se um programa foi enviado<!--/a--></li>
			
 
				+-->
			
 
				+  
			
 
				+  </div>
			
 
				+
			
 
				+<footer id="page-footer" class="bg-inverse">
			
 
				+  <div class="container">
			
 
				+    <div id="course-footer"></div>
			
 
				+      <p class="helplink">Material didático - Prof. Leônidas de Oliveira Brandão</p>
			
 
				+  </div>
			
 
				+</footer>
			
 
				+
			
 
				+
			
 
				+</body></html>
			
--- a/indicador_passagem.html
+++ b/indicador_passagem.html
@@ -0,0 +1,192 @@
 
				+<!--
			
 
				+ Introdução à Programação - 2017 - Prof. Leoônidas de Oliveira Brandão
			
 
				+ Introdução ao conceito de indicador de passagem
			
 
				+ 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 conceito de indicador de passagem</p>
			
 
				+
			
 
				+<p>
			
 
				+  Nesta seção será apresentado o conceito de <i>indicador de passagem</i>, bastante útil em algoritmos que precisem detectar
			
 
				+  a ocorrência de um evento, não importanto quantos vezes ele ocorre,
			
 
				+  como saber se todos os elementos de uma sequência são <i>pares</i>, bastaria um valor <i>ímpar</i> para caracterizar
			
 
				+  a resposta como <i>negativa</i>.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p class="secao">Ideia que se <i>repetem</i></p>
			
 
				+
			
 
				+<p>
			
 
				+Em matemática é comum a existência de ideias que são usadas para resolver variados
			
 
				+problemas, como a <i>soma telescópica</i> (<i>soma<sub>i=1</sub><sup>n</sup> 1/(i (i+1)) =
			
 
				+soma<sub>i=1</sub><sup>n</sup> (1/i - 1/(n+1)) = soma<sub>i=1</sub><sup>n</sup> = (1-1/2) + (1/2 - 1/3) + ... + (1/n - 1/(n+1)) =
			
 
				+1 - 1/(n+1)</i>).
			
 
				+<!-- <i>1+2+3+...+n = (1/2)(1+2+...+n+1+2+...+n) = (1/2)((n+1)+(n+1)+...+(n+1)) = (1/2) (n x (n+1))</i> -->
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Em desenvolvimento de <i>software</i> (programas computacionais) esse princípio do "reaproveitamento" de ideias é ainda mais usado.
			
 
				+O primeiro exemplo que você deve ter notado desse "reaproveitamento" é a ideia de <i>contador</i>
			
 
				+(sempre que executar determinada instrução, <i>acrescentar 1 ao contador</i>).
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p class="secao">Ideia de <i>indicador de passagem</i></p>
			
 
				+
			
 
				+<p>
			
 
				+A ideia de <b style="color: #0000AA;">indicador de passagem</b> é utilizar uma variável que será usada
			
 
				+para registrar se <i>determinado evento ocorreu</i>.
			
 
				+Por exemplo, deseja-se saber se entre os valores digitados algum deles é negativo, então pode-se implementar
			
 
				+um semelhante ao indicado abaixo (em uma linguagem <i>Portugol</i>):
			
 
				+<pre>
			
 
				+ <tt class="com">// O indicador de passagem recebera o nome sugestivo 'existeNegativo'</tt>
			
 
				+ existeNegativo = 0; <tt class="com">// 0 =&gt; "ate' aqui" nenhum negativo - ou, "em principio, nao existem negativos"</tt>
			
 
				+ <tt class="cmd">repita</tt> N <tt class="cmd">vezes</tt>
			
 
				+   <tt class="fnc">leia</tt>(x);
			
 
				+   <tt class="cmd">se</tt> (x &lt; 0)
			
 
				+   <tt class="cmd">entao</tt> existeNegativo = 1; <tt class="com">// existe negativo! ("nunca mais" elimine o 1 dessa variavel indicadora)</tt>
			
 
				+ <tt class="com">// terminado o laco a resposta e' dada olhando se ocorreu o evento (ao menos uma vez)</tt>
			
 
				+ <tt class="cmd">se</tt> (existeNegativo == 1)
			
 
				+ <tt class="cmd">entao</tt> <tt class="fnc">imprima</tt>("Existe(m) negativo(s)");
			
 
				+ <tt class="cmd">senao</tt> <tt class="fnc">imprima</tt>("NAO existe sequer um valor negativo na sequencia digitada!");
			
 
				+</pre>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Portanto, esse <i>modelo solução</i> (ou <i>padrão</i>) é útil sempre que estiver interessado em
			
 
				+detectar se um evento ocorre ao menos uma vez.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p class="secao">Cuidado com um erro comum ao tentar usar indicadores</p>
			
 
				+
			
 
				+<p>
			
 
				+Um erro bastante comum para os iniciantes na <i>arte de programar</i> é, a cada passo, alterar o valor da variável indicadora.
			
 
				+Por exemplo, poder-se-ia "estragar" o código acima se for acrescentado um comando
			
 
				+<tt class="cmd">senao</tt> dentro do laço, do sguinte modo
			
 
				+<center><table><tr><td><pre>
			
 
				+ <tt class="com">// <b>Contra-exemplo</b> NAO implemente desse modo!</tt>
			
 
				+ existeNegativo = 0; <tt class="com">// 0 =&gt; "ate' aqui" nenhum negativo - ou, "em principio, nao existem negativos"</tt>
			
 
				+ <tt class="cmd">repita</tt> N <tt class="cmd">vezes</tt>
			
 
				+   <tt class="fnc">leia</tt>(x);
			
 
				+   <tt class="cmd">se</tt> (x &lt; 0)
			
 
				+   <tt class="cmd">entao</tt> existeNegativo = 1; <tt class="com">// existe negativo! ("nunca mais" elimine o 1 dessa variavel indicadora)</tt>
			
 
				+   <tt class="cmd">senao</tt> existeNegativo = 0; <tt class="com">// <b>NAO</b> use uma linha dessa (ela "desfaz" o indicador)!!!!</tt>
			
 
				+ <tt class="com">// terminado o laco a resposta SERIA dada olhando se ocorreu o evento</tt>
			
 
				+ <tt class="cmd">se</tt> (existeNegativo == 1)
			
 
				+ <tt class="cmd">entao</tt> <tt class="fnc">imprima</tt>("Existe(m) negativo(s)");
			
 
				+ <tt class="cmd">senao</tt> <tt class="fnc">imprima</tt>("NAO existe sequer um valor negativo na sequencia digitada!");
			
 
				+</pre></td></tr></table></center>
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+Simule a pseudo-solução acima, usando os seguintes dados como entrada: <tt>N=4</tt> e a sequência de 4 dados como sendo
			
 
				+<tt>2, -1, -3, 4</tt>. Será usado <tt>i</tt> para indicar o número de dados digitados (auxiliar, faria parte do código
			
 
				+se for usado um comando <tt>for</tt> do <i>C</i> ou <i>Python</i>).
			
 
				+<center><table><tr><td><pre> i |  x | existeNegativo
			
 
				+ 1 |  2 |              0
			
 
				+ 2 | -1 |              1
			
 
				+ 3 | -3 |              1
			
 
				+ 4 |  2 |              0</pre></td></tr></table></center>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Note que ao final da simulação, <tt>existeNegativo</tt> está com o valor 0, que indicaria a não existência de
			
 
				+  negativos na sequência, mas existem 2 negativos! Logo, solução errada!
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Na verdade, na implementação <i style="color:#aa0000">errônea</i> acima, a resposta será definida exclusivamente pela
			
 
				+  última iteração do laço. Por que?
			
 
				+  <br/>
			
 
				+  A razão é que, a cada passo a variável <tt>existeNegativo</tt> receberá um valor (esse é o <i style="color:#aa0000">erro</i>),
			
 
				+  pois se a condição for <i>verdadeira</i> executa-se
			
 
				+  a atribuição <tt>existeNegativo = 1</tt> e se for <i>falsa</i> executa-se
			
 
				+  a atribuição <tt>existeNegativo = 0</tt>.
			
 
				+  <br/>
			
 
				+  Portanto, não importa quais sejam os <tt>N-1</tt> primeiros valores digitados, o único usado para definir o
			
 
				+  valor final de <tt>existeNegativo</tt> seria o último! <i style="color:#aa0000">Erro</i>!
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p class="secao">Códigos em <i>C</i> e em <i>Python</i> para o exemplo acima de <i>indicador de passagem</i></p>
			
 
				+
			
 
				+<p>
			
 
				+Abaixo está indicado em <i>C</i> e em <i>Python</i> o código para digitar <i>N</i> valores (inteiros)
			
 
				+e imprimir se algum negativo foi ou não registrado (digitado).
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<center><table><tr>
			
 
				+<td bgcolor="8aaada"><i>C</i>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</td>
			
 
				+<td bgcolor="8aaada"><i>Python</i></td></tr>
			
 
				+<tr><td colspan="2"><pre>
			
 
				+  <tt class="tipo">int</tt> n, i;                             <tt class=""></tt>
			
 
				+  <tt class="fnc">scanf</tt>("%d", &n);                      n = <tt class="fnc">int</tt>(<tt class="fnc">input</tt>());
			
 
				+  <tt class="">existeNegativo = 0;                   existeNegativo = 0;
			
 
				+  <tt class="cmd">for</tt> (i=0; i&lt; n; i++)                  <tt class="cmd">for</tt> i in range(n) :
			
 
				+    <tt class="cmd">if</tt> (x &lt; 0 )                           <tt class="cmd">if</tt> (x &lt; 0 ) :</tt>
			
 
				+      <tt class="">existeNegativo = 1;                   <tt class="">existeNegativo = 1;</tt>
			
 
				+  <tt class="cmd">if</tt> (existeNegativo == 1)              <tt class="cmd">if</tt> (existeNegativo == 1) :
			
 
				+    <tt class="fnc">printf</tt>("Existe(m) negativo(s)\n");    <tt class="fnc">print</tt>("Existe(m) negativo(s)");
			
 
				+  <tt class="cmd">else</tt> <tt class="fnc">printf</tt>("NAO existe!\n");         <tt class="cmd">else</tt> : <tt class="fnc">print</tt>("NAO existe!");
			
 
				+</pre></td></tr></table></center>
			
 
				+
			
 
				+
			
 
				+<p class="secao">Outros exemplos de uso do conceito de <i>indicador de passagem</i></p>
			
 
				+
			
 
				+<p>
			
 
				+Existe uma quantidade arbitrária de exemplos em que o conceito de <i>indicador de passagem</i> é útil.
			
 
				+Abaixo listo apenas alguns exemplos simples:
			
 
				+<ul>
			
 
				+<li>Verificar se existe algum débito em um extrato bancário (identificar negativo em uma sequência);</li>
			
 
				+<li>Verificar se uma sequência é crescente;</li>
			
 
				+<li>Verificar se uma sequência é ou não uma <i>progressão aritmética (PA)</i> (o candidato à razão poderia ser a diferença do primeiro par);</li>
			
 
				+<li>Verificar se algum dos valores é raíz de determinada equação;</li>
			
 
				+<li>Verificar se um vetor é solução de um sistema linear (sequência seriam os produtos linha vetor candidato).</li>
			
 
				+<!--li></li-->
			
 
				+</ul>
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+
			
 
				+  <p class="autoria">
			
 
				+    <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/15: novo formato, pequenas revisões<br/>
			
 
				+    2020/08/12: novo formato, pequenas revisões<br/>
			
 
				+    2019/05/08: primeira versão
			
 
				+  </p>
			
 
				+
			
 
				+
			
 
				+</div>
			
--- a/introducao_algoritmos.html
+++ b/introducao_algoritmos.html
@@ -0,0 +1,199 @@
 
				+<!--
			
 
				+2018 - Prof. Leo^nidas de Oliveira Branda~o
			
 
				+Introducao `a programacao/algoritmos
			
 
				+-->
			
 
				+
			
 
				+<!DOCTYPE html>
			
 
				+<html itemscope itemtype="http://schema.org/QAPage">
			
 
				+
			
 
				+<head>
			
 
				+  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
			
 
				+  <title>Introdução à Programaćão / algoritmos</title>
			
 
				+  <link rel="stylesheet" type="text/css" href="css/estilo.css" />
			
 
				+</head>
			
 
				+
			
 
				+<body>
			
 
				+
			
 
				+<div class="titulo1"><b>Introdução à Programaćão / algoritmos</b></div>
			
 
				+
			
 
				+<p>
			
 
				+<b>Versão 0</b>: 19/12/2019
			
 
				+<!--<b>Alterações</b>: 14/04/2017 - adicionados novos itens (como explicação adicional sobre expressões aritméticas).-->
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Nesta seção apresentaremos os conceito fundamentais de algoritmos e sua implementaćão na forma de um programa.
			
 
				+</p>
			
 
				+
			
 
				+<div class="item1">O que é um algoritmo?</div>
			
 
				+
			
 
				+<p>
			
 
				+Um <i>algoritmo</i> descreve um processo repetitivo e é tão antiga quanto a área da Matemática.
			
 
				+Um primeiro exemplo de algoritmo matemático útil é a <i>soma</i> de números com vários dígitos,
			
 
				+por maior que sejam dois números, aplicando corretamente os passos do algoritmo da soma, conseguiremos
			
 
				+somá-los (mesmo desconhendo o nome desses números gigantes!).
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<div class="desafio">
			
 
				+Antes de continuar a leitura, tente descrever o algoritmo da soma de dois números inteiros de vários dígitos.
			
 
				+</div>
			
 
				+
			
 
				+<p>
			
 
				+<div class="tit_code">Código 1.</div>
			
 
				+Uma possível descrićão seria, simplificando para caso em que ambos os números tenham o mesmo número de dígitos:
			
 
				+<div class="code">
			
 
				+1. ajusta-se os números à direita (por que?);<br/>
			
 
				+2. define-se uma variável auxiliar <tt>vai_um</tt> com valor nulo;<br/>
			
 
				+3. soma-se os dois dígitos mais à direita (menos significativos),<br/>
			
 
				+   &nbsp;&nbsp;  se resultar mais que <tt>9</tt>,<br/>
			
 
				+   &nbsp;&nbsp;&nbsp;&nbsp; escreva o resultado menos <tt>10</tt> (um único dígito)<br/>
			
 
				+   &nbsp;&nbsp;&nbsp;&nbsp; define-se <tt>vai_um</tt> com valor <tt>1</tt> (por que?),<br/>
			
 
				+   &nbsp;&nbsp; senão<br/>
			
 
				+   &nbsp;&nbsp;&nbsp;&nbsp; escreva o resultado (um único dígito)<br/>
			
 
				+   &nbsp;&nbsp;&nbsp;&nbsp; define-se <tt>vai_um</tt> com valor <tt>0</tt> (por que?),<br/>
			
 
				+4. se não existem mais dígitos, <b>pare</b><br/>
			
 
				+5. soma-se os próximos dois dígitos e o <tt>vai_um</tt>,<br/>
			
 
				+   &nbsp;&nbsp;  se resultar mais que <tt>9</tt>,<br/>
			
 
				+   &nbsp;&nbsp;&nbsp;&nbsp; escreva o resultado menos <tt>10</tt> (um único dígito)<br/>
			
 
				+   &nbsp;&nbsp;&nbsp;&nbsp; define-se <tt>vai_um</tt> com valor <tt>1</tt> (por que?),<br/>
			
 
				+   &nbsp;&nbsp; senão<br/>
			
 
				+   &nbsp;&nbsp;&nbsp;&nbsp; escreva o resultado (um único dígito)<br/>
			
 
				+   &nbsp;&nbsp;&nbsp;&nbsp; define-se <tt>vai_um</tt> com valor <tt>0</tt> (por que?),<br/>
			
 
				+6. volta-se ao passo passo 4 avanćando à esquerda um dígito.
			
 
				+</div>
			
 
				+</p>
			
 
				+
			
 
				+</p>
			
 
				+Note que os passos 4, 5 e 6 são repetidos várias vezes, constituindo o núcleo desse algoritmo.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<div class="item1">O que é um programa de computador?</div>
			
 
				+
			
 
				+
			
 
				+AQUI!!!!
			
 
				+
			
 
				+<p>
			
 
				+E qual a relação disso com variável? Bem, por exemplo, é necessário contar e, para fazer usando o computador
			
 
				+Basicamente é uma sequência de instrućões 
			
 
				+precisamos pegar uma sequência de <i>bytes</i> interpretá-lo como inteiro, somar 1 e registrar o valor
			
 
				+alterado. Isso é feito utilizando a mesma posição de memória, que está assim <i>variando</i>, dai o nome
			
 
				+<i>variável</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p>  
			
 
				+De um ponto de vista mais elevado (<i>alto-nivel</i>), utilizando uma linguagem de programação com <i>C</i> ou <i>Python</i>,
			
 
				+uma variável é representada por um nome, sem caracteres especiais (exceto "barra baixa" '_' que é permitido)
			
 
				+e que não seja o nome de um comando da linguaguem (denominado de modo geral por <i>palavra reservada</i>).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Além disso uma variável deve ter um tipo associado, os tipos básicos que examinaremos nesta seção são o
			
 
				+inteiro (<i>int</i>) e o flutuante (<i>float</i>), este último para representar os valores reais.
			
 
				+A partir da explicação acima sobre interpretar os <i>bytes</i> como número ou caractere explica a necessidade
			
 
				+de cada variável ter o seu tipo conhecido.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Para explicar melhor a necessidade de tipos, suporemos que o computador considerado utilize para uma variável
			
 
				+<i>int</i> e para uma do tipo <i>float</i>, respectivamente, 2 e 4 <i title="cada byte tem 8 bits">bytes</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Desse modo, quando o citado computador precisa devolver o valor armazenado em uma variável do tipo inteiro, ele
			
 
				+acessará a posição de memória associada à variável, pegará a partir dessa posição os próximos 16 <i>bits</i> e
			
 
				+o interpretará como um valor inteiro.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Do ponto de vista prático, vejamos como se usa variáveis do tipo <i>int</i> e do tipo <i>float</i> nas linguagens
			
 
				+<i>C</i> e <i>Python</i>.
			
 
				+</p>
			
 
				+
			
 
				+<center><table>
			
 
				+  <tr><td></td><td bgcolor="8aaada"><i>C</i>              <td bgcolor="8aaada"><i>Python</i></td></tr>
			
 
				+  <tr><td>1</td><td>int n1,n2;                            <td># desnecessário declarar em <i>Python</i></td></tr>
			
 
				+  <tr><td>2</td><td>n1 = 1;                               <td>n1 = 1</td></tr>
			
 
				+  <tr><td>3</td><td>scanf("%d", &n2);                     <td>n2 = int(input())</td></tr>
			
 
				+  <tr><td>4</td><td>printf("n1=%d e n2=%d\n", n1, n2);    <td>print "n1=", n1, " e n2=", n2  # Python 2</td></tr>
			
 
				+  <tr><td>5</td><td>                                      <td>print("n1=", n1, " e n2=", n2) # Python 3</td></tr>
			
 
				+</table></center>
			
 
				+
			
 
				+<p>
			
 
				+Note as diferenças entre <i>C</i> e <i>Python</i>:
			
 
				+<ul>
			
 
				+ <li> De modo geral, todo comando em <i>C</i> precisa de ';' como finalizador.
			
 
				+      </li>
			
 
				+ <li> Na linha 1 percebe-se que em <i>C</i> é obrigatório <b>declarar</b> as variáveis, enquanto que em <i>Python</i> não.
			
 
				+ <li> Na linha 3 nota-se que <i>C</i> utiliza a função pré-definida de nome <i>scanf</i> para pegar valores digitados
			
 
				+ pelo usuário enquanto <i>Python</i> usa o <i>input</i>. O <i>scanf</i> usa o formatador especial '%d' para forçar
			
 
				+ o computador a interpretar os <i>bytes</i> como um inteiro, enquanto o <i>input</i> pega os <i>bytes</i>
			
 
				+ digitados e o submete à outra função pré-definida <i>Python</i>, o <i>int(...)</i>, que converte os <i>bytes</i> lidos para um inteiro.
			
 
				+      </li>
			
 
				+ <li> Na linha 4 nota-se o mesmo tipo de diferença, <i>C</i> utiliza a função <i>printf</i> para imprimir também com
			
 
				+ o formatador para inteiro '%d', além de separar em 2 blocos, o primeiro para formatar a saída, que é cercado
			
 
				+ por aspas dupla e o segunda, uma lista de variáveis compatíveis com o formatador.
			
 
				+ Já em <i>Python</i>, usa-se os caracteres entre aspas e as variáveis misturados, separador por vírgula.
			
 
				+      </li>
			
 
				+ <li> Vale destacar que a linha 4 apresenta a sintaxe do <i>Python</i> antes da versão 3, enquanto que alinha 5 apresenta
			
 
				+ o mesmo resultado mas para o <i>Python</i> a partir da sua versão 3.
			
 
				+      </li>
			
 
				+</ul>
			
 
				+</p>
			
 
				+
			
 
				+<div class="item1">Expressões aritméticas</div>
			
 
				+
			
 
				+<p>
			
 
				+Do mesmo modo que em matemática é essencial efetuarmos operações aritméticas com valores numéricos,
			
 
				+o mesmo ocorre com o computador, na verdade efetuar contas de modo
			
 
				+rápido e "sem erro" (na verdade existem erros numéricos, mas este é
			
 
				+outro assunto) foi a grande motivação para se construir os computadores.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Neste, os agrupamentos de valores, variáveis e operadores aritméticos  recebem o nome de  <i>expressão aritmética</i>.
			
 
				+De modo geral, podemos conceituar uma <i>expressão aritmética</i> <b>EA</b> como:
			
 
				+<ol>
			
 
				+ <li>EA := K: uma constante numérica é uma <i>expressão aritmética</i></li>
			
 
				+ <li>EA := EA + EA | EA - EA | EA * EA | EA / EA: uma <i>expressão aritmética</i> seguida de um <b>operador binário</b>
			
 
				+     (com 2 itens) e seguida por outra <i>expressão aritmética</i> é uma <i>expressão aritmética</i></li>
			
 
				+</ol>
			
 
				+Os <b>operadores artiméticos binários</b>, tanto em <i>C</i> quanto em <i>Python</i> são:
			
 
				+</p>
			
 
				+
			
 
				+<center><table>
			
 
				+  <tr><td bgcolor="8aaada">Operação</td><td bgcolor="8aaada">Operador <td bgcolor="8aaada">Exemplo</td></tr>
			
 
				+  <tr><td>soma         </td><td> +           <td> 2 + 4                          </td></tr>
			
 
				+  <tr><td>subtração    </td><td> -           <td> n1 + 1                         </td></tr>
			
 
				+  <tr><td>multiplicação</td><td> *           <td> 3 * n2                         </td></tr>
			
 
				+  <tr><td>divisão      </td><td> /           <td> n1 / n2                        </td></tr>
			
 
				+</table></center>
			
 
				+
			
 
				+<p>
			
 
				+Note que foi usado espaço em branco entre os operando e operadores, mas isso não é obrigatório.
			
 
				+</p>
			
 
				+
			
 
				+<div class="item1">O resultado de uma expressão aritmética depende do contexto</div>
			
 
				+
			
 
				+<p>
			
 
				+É importante observar que dependendo do contexto o resultado de uma expressão é um ou outro, quer dizer,
			
 
				+se os valores envolvidos forem todos eles inteiros, o resultado será inteiro, entretanto havendo um valor
			
 
				+real, a resposta final será real.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+A importância disso fica clara ao examinar dois exemplos simples: <i>3 / 2 * 2</i> e <i>3.0 / 2 * 2</i>.
			
 
				+A primeira expressão resulta o valor <i>2</i>, enquanto a segunda <i>3.0</i>. Isso mesmo.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+A razão é que no primeiro caso todos valores são inteiros, então o cômputo é realizado com aritmética de precisão inteira,
			
 
				+ou seja, ao realizar o primeiro cômputo <i>3/2</i>, o resultado é <i>1</i> (e não <i>1.5</i> como no segundo caso), daí
			
 
				+o segundo operador é feito com os valores <i>1 * 2</i> resultando o valor <i>2</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Leônidas de Oliveira Brandão<br/>
			
 
				+http://line.ime.usp.br
			
 
				+</p>
			
--- a/introducao_caracteres.html
+++ b/introducao_caracteres.html
@@ -0,0 +1,376 @@
 
				+<!--
			
 
				+Introdução aos caracteres
			
 
				+Prof. Leônidas de Oliveira Brandão
			
 
				+Material didático para apoio aos cursos de Introdução à Programação
			
 
				+Direitos reservados
			
 
				+Pode ser usado mediante citação de autoria (Prof. Leônidas de Oliveira Brandão) e origem (https://www.ime.usp.br/~leo/mac2166/introducao/)
			
 
				+Versao 2 [2018/04/28] Revisao, acerto no 2^8 (que estava 512...)
			
 
				+Versao 1 [2017/05/01]
			
 
				+-->
			
 
				+
			
 
				+ <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">
			
 
				+
			
 
				+
			
 
				+<p class="secao">Introdução aos caracteres</p>
			
 
				+
			
 
				+<!--
			
 
				+<center><p>[
			
 
				+ <a href="#erro">Erros</a> |
			
 
				+ <a href="#pontoflutuante">Ponto flutuante</a> | 
			
 
				+ <a href="#exemplo">Exemplo</a> | 
			
 
				+ <a href="#io">Entrada/saída</a></a>
			
 
				+ ]</p>
			
 
				+</center>
			
 
				+-->
			
 
				+
			
 
				+<p>
			
 
				+  Nesta seção examinaremos resumidamente como utilizar caracteres tanto em <em>C</em> quanto em <em>Python</em>.
			
 
				+  Desse modo, quem está aprendendo uma das linguagens poderá aprender o funcionamento equivalente na outra.
			
 
				+</p>
			
 
				+
			
 
				+<a name="caracteres"><span style="color: #0050A0">Representação como caractere</span></a>
			
 
				+
			
 
				+<p>
			
 
				+Como citado na seção sobre 
			
 
				+<a href="#" onclick="trocaPagina('introducao_var.html')" title="variaveis">variáveis</a>, a informação básica
			
 
				+nos computadores digitais é uma sequência de <i>bits</i> e o contexto é quem indica como estes <i>bits</i> devem ser
			
 
				+interpretados.
			
 
				+Por exemplo, a sequência com 6 <i>bits</i> <tt>100001</tt>, poderia ser interpretada como um valor inteiro e
			
 
				+neste caso seria o valor 33, pois <tt>1*2^5 + 0*2^4 + 0*2^3 + 0*2^3 + 0*2^2 + 0*2^1 + 1*2^0 = 32+1 = 33</tt>.
			
 
				+Por outro lado, a mesma sequência poderia ser interpretada como um caractere, no caso o <tt>'!'</tt> (exclamação).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+<!-- Um exemplo do problema numérico está ilustrado no exemplo abaixo, quando tentamos imprimir as somas de <tt>0.1</tt> -->
			
 
				+Assim as linguagens de programação possibilita a interpretação de uma sequência de <i>bits</i> como um caractere
			
 
				+(e.g. como uma letra ou um dígito).
			
 
				+Deste modo para apresentá-lo é preciso estabelecer uma tabela de conversão, por exemplo, que indique que a sequência
			
 
				+<tt>110000</tt> deve ser interpretada como o caracteres <tt>'0'</tt>, que corresponde ao decimal
			
 
				+<tt>1*2^5 + 1*2^4 + 0*2^3 + 0*2^3 + 0*2^2 + 0*2^1 + 0*2^0 = 32+16 = 48</tt>.
			
 
				+</p>
			
 
				+
			
 
				+<a name="ascii">
			
 
				+<p class="subsecao">Código ASCII</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+Um primeiro padrão para representar os caracteres é o 
			
 
				+<a href="https://en.wikipedia.org/wiki/ASCII" title="ver detalhes na WikiPedia"
			
 
				+   target="_blank"><b>American Standard Code for Information Interchange</b></a>.
			
 
				+O padrão ASCII é bastante antigo, ainda da década de 1960 e por isso utiliza um número reduzido de <i>bits</i>,
			
 
				+somente 8, o que possibilita a codificação de apenas <i>2<sup>8</sup>=256</i> símbolos distintos.
			
 
				+<!-- codigos/ -->
			
 
				+</p>
			
 
				+
			
 
				+<center>
			
 
				+<a name="tab1">
			
 
				+<i>Tab. 1. Os 20 primeiros números naturais na base binária (0, 1) e correspondente decimal</i>
			
 
				+</a>
			
 
				+<br/>
			
 
				+<table><tr><td>
			
 
				+<table class="tbCodeLinCol">
			
 
				+ <tr><th>Binário</th> <th>Decimal</th></tr>
			
 
				+   <tr><td><tt>00000000</tt></td><td align="right"><tt>       0</tt></td></tr>
			
 
				+   <tr><td><tt>00000001</tt></td><td align="right"><tt>       1</tt></td></tr>
			
 
				+   <tr><td><tt>00000010</tt></td><td align="right"><tt>       2</tt></td></tr>
			
 
				+   <tr><td><tt>00000011</tt></td><td align="right"><tt>       3</tt></td></tr>
			
 
				+   <tr><td><tt>00000100</tt></td><td align="right"><tt>       4</tt></td></tr>
			
 
				+   <tr><td><tt>00000101</tt></td><td align="right"><tt>       5</tt></td></tr>
			
 
				+   <tr><td><tt>00000110</tt></td><td align="right"><tt>       6</tt></td></tr>
			
 
				+   <tr><td><tt>00000111</tt></td><td align="right"><tt>       7</tt></td></tr>
			
 
				+   <tr><td><tt>00001000</tt></td><td align="right"><tt>       8</tt></td></tr>
			
 
				+   <tr><td><tt>00001001</tt></td><td align="right"><tt>       9</tt></td></tr>
			
 
				+</table></td>
			
 
				+<td>    
			
 
				+<table class="tbCodeLinCol">
			
 
				+ <tr><th>Binário</th> <th>Decimal</th></tr>
			
 
				+   <tr><td><tt>00001010</tt></td><td align="right"><tt>      10</tt></td></tr>
			
 
				+   <tr><td><tt>00001011</tt></td><td align="right"><tt>      11</tt></td></tr>
			
 
				+   <tr><td><tt>00001100</tt></td><td align="right"><tt>      12</tt></td></tr>
			
 
				+   <tr><td><tt>00001101</tt></td><td align="right"><tt>      13</tt></td></tr>
			
 
				+   <tr><td><tt>00001110</tt></td><td align="right"><tt>      14</tt></td></tr>
			
 
				+   <tr><td><tt>00001111</tt></td><td align="right"><tt>      15</tt></td></tr>
			
 
				+   <tr><td><tt>00010000</tt></td><td align="right"><tt>      16</tt></td></tr>
			
 
				+   <tr><td><tt>00010001</tt></td><td align="right"><tt>      17</tt></td></tr>
			
 
				+   <tr><td><tt>00010010</tt></td><td align="right"><tt>      18</tt></td></tr>
			
 
				+   <tr><td><tt>00010011</tt></td><td align="right"><tt>      19</tt></td></tr>
			
 
				+</table></td></tr>
			
 
				+</table></center>
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+Como o padrão <i>ASCII</i> foi criado nos Estados Unidos e a lingua Inglesa não utiliza símbolos especiais,
			
 
				+na pratica eles utilizavam apenas 7 <i>bits</i>, ou seja, usavam 128 diferentes caracteres.
			
 
				+<!--
			
 
				+Como o código ASCII foi baseado no alfabeto em lingua Inglesa, eles presentam apenas caracteres sem acentos.
			
 
				+Usualmente associamos um natural a cada símbolo, assim no ASCII pode-se associar caracteres aos <b>códigos ASCII</b>
			
 
				+0 até 256. -->
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Como exemplos de código ASCII a letra 'A' é associada ao natural 65, o 'B' ao 66 e assim por diante.
			
 
				+Do mesmo modo, o 'a' é associada ao natural 97 e o caractere 'z' ao 122.
			
 
				+Já o natural 48 é associado do dígito '0', o 49 ao '1' e assim por diante até o 57 associado '9'.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="io">
			
 
				+<p class="subsecao">Entrada e saída de caracteres em <i>C</i> e em <i>Python</i></p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+Como já citado nas outras seções, o contexto deve definir como sequências de <i>bits</i> devem ser tratadas.
			
 
				+Para tratar um conjunto <i>bits</i> como caractere deve-se indicar isso ao computador de alguma forma.
			
 
				+Por exemplo, as linguagens de programação geralmente dispõem de um tipo de variável especial para caracteres.
			
 
				+<!--
			
 
				+Tanto a linguagem <i>C</i> como a linguagem <i>Python</i> dispõe um tipo especial variável para tratar com caracteres.
			
 
				+-->
			
 
				+</p>
			
 
				+
			
 
				+<p> 
			
 
				+Na linguagem <i>C</i> existe o tipo <tt>char</tt> e tanto para leitura quanto para impressão, utiliza-se o formatador
			
 
				+<tt>%c</tt>. Mas pode-se imprimir uma variável <tt>char</tt> como se fosse um número inteiro e vice-versa,
			
 
				+neste caso usa-se seu código ASCII.
			
 
				+</p>
			
 
				+
			
 
				+<p> 
			
 
				+Já em <i>Python 2</i> é preciso de uma função especial para leitura de caracteres, a função <tt>raw_input()</tt>.
			
 
				+Na impressão, se não for usada impressões especiais, não é preciso qualquer diferenciação, pois o <i>Python</i>
			
 
				+aplica um filtro para tratar se a variávem sendo impressa é inteira, flutuante ou caractere.
			
 
				+Vide  <a href="#tab2">tabela</a> abaixo.
			
 
				+</p>
			
 
				+<center>
			
 
				+<a name="tab2">
			
 
				+<i>Tab. 2. Sobre a leitura de caracteres em <i>C</i> e em <i>Python</i></i>
			
 
				+</a>
			
 
				+<br/>
			
 
				+<table class="tbCodeLinCol">
			
 
				+ <tr><th>C </th> <th>Python 2</th> <th>Python 3</th></tr>
			
 
				+ <tr valign="top"><td><table class="tbCode">
			
 
				+   <tr><td><pre>char x; // declaracao de variavel para armazenar caracteres
			
 
				+scanf("%c", &x); // leia como "caractere"
			
 
				+printf("%c", x); // imprima como "caractere"
			
 
				+</pre></td></tr>
			
 
				+ </table></td>
			
 
				+ <td><table class="tbCode"><pre># Vale notar: se o usuario digitar uma "string", como
			
 
				+# "nome", a variavel x recebera' a "string" toda
			
 
				+x = raw_intput(); # leia como "caractere"
			
 
				+print(x);
			
 
				+
			
 
				+</pre></td></tr>
			
 
				+   </table></td>
			
 
				+ <td><table class="tbCode"><pre># Vale notar: se o usuario digitar uma "string", como
			
 
				+# "nome", a variavel x recebera' a "string" toda
			
 
				+x = intput(); # leia como "caractere"
			
 
				+print(x);
			
 
				+
			
 
				+</pre></td></tr>
			
 
				+   </table></td>
			
 
				+   </tr>
			
 
				+</table></center>
			
 
				+</p>
			
 
				+
			
 
				+<a name="constantes">
			
 
				+<p class="subsecao">Constantes do tipo caractere em <i>C</i> e em <i>Python</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+Assim como várias outras linguagens, <i>C</i> e <i>Python</i>, adotam o uso de apóstrofes para
			
 
				+indicar que deve pegar o caractere entre os apóstrofes.
			
 
				+Por exemplo, para atribuir a constante 'a' à uma variável do tipo caractere, de nome <tt>varc</tt>,
			
 
				+deve-se usar
			
 
				+<center><tt>varc = 'a';</tt> (o finalizador ';' é opcional em <i>Python</i>).</center>
			
 
				+<br/>
			
 
				+A necessidade de um marcador pode ser facilmente entendida ao escrevermos o código
			
 
				+<tt>varc = a;</tt>, que corresponde a guardar o valor atual da variável <i>a</i> na variável <i>varc</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p> 
			
 
				+Abaixo um exemplo de código que imprime primeiro o caractere associado ao código ASCII dado e depois
			
 
				+o contrário. Ao rodar este código será impresso os caracteres de código 48, 49, 97, 98, 65 e 66, respectivamente
			
 
				+'0', '1', 'a', 'b', 'A' e 'B'.
			
 
				+<center>
			
 
				+<i>Tab. 3. Sobre conversão entre o caractere ASCII e seu código inteiro</i>
			
 
				+<br/>
			
 
				+<table class="tbCodeLinCol">
			
 
				+ <tr><th>C </th> <th>Python 2</th></tr>
			
 
				+ <tr valign="top"><td><table class="tbCode">
			
 
				+   <tr><td><pre>#include &lt;stdio.h&gt;
			
 
				+int main (void) {
			
 
				+  int          // Criando 6 variaveis como (implicitamente) do tipo "int".
			
 
				+    val1 = 48, // Cada variavel recebera um valor inteiro que depois sera'
			
 
				+    val2 = 49, // interpretado como caractere.
			
 
				+    num1 = 97, //
			
 
				+    num2 = 98, //
			
 
				+    Num1 = 65, //
			
 
				+    Num2 = 66; //
			
 
				+  char            // Declarando variaveis tipo caractere
			
 
				+    charN1 = '0', // NOTE que para constantes do tipo
			
 
				+    charN2 = '1', // caractere, deve-se usar aspa simples
			
 
				+    Char1  = 'A', //
			
 
				+    Char2  = 'B', //
			
 
				+    char1  = 'a', //
			
 
				+    char2  = 'b'; //
			
 
				+  printf(" int | codigo\n"); // '\n' usado para forcar quebra de linha na impressao
			
 
				+  printf("  %d | %c\n", val1, val1);
			
 
				+  printf("  %d | %c\n", val2, val2);
			
 
				+  printf("  %d | %c\n", num1, num1);
			
 
				+  printf("  %d | %c\n", num2, num2);
			
 
				+  printf("  %d | %c\n", Num1, Num1);
			
 
				+  printf("  %d | %c\n", Num2, Num2);
			
 
				+  printf(" int | codigo\n");
			
 
				+  printf(" %c | %d\n", charN1, charN1);
			
 
				+  printf(" %c | %d\n", charN2, charN2);
			
 
				+  printf(" %c | %d\n", char1,  char1);
			
 
				+  printf(" %c | %d\n", char2,  char2);
			
 
				+  printf(" %c | %d\n", Char1,  Char1);
			
 
				+  printf(" %c | %d\n", Char2,  Char2);
			
 
				+  return 0;
			
 
				+  }</pre></td></tr>
			
 
				+ </table></td>
			
 
				+ <td><table class="tbCode"><pre>def main():
			
 
				+  val1 = 48 # Criando 6 variaveis como (implicitamente) do tipo "int".
			
 
				+  val2 = 49 # Cada variavel recebera um valor inteiro que depois sera'
			
 
				+  num1 = 97 # interpretado como caractere.
			
 
				+  num2 = 98 #
			
 
				+  Num1 = 65 #
			
 
				+  Num2 = 66 #
			
 
				+  print(" int | codigo")
			
 
				+  print(" ", val1, " | ", chr(val1)) # A funcao chr(...) devolve
			
 
				+  print(" ", val2, " | ", chr(val2)) # o caractere associado ao
			
 
				+  print(" ", num1, " | ", chr(num1)) # codigo ASCII dado
			
 
				+  print(" ", num2, " | ", chr(num2))
			
 
				+  print(" ", Num1, " | ", chr(Num1))
			
 
				+  print(" ", Num2, " | ", chr(Num2))
			
 
				+  charN1 = '0' # NOTE que para constantes do tipo
			
 
				+  charN2 = '1' # caractere, deve-se usar aspa simples
			
 
				+  Char1 = 'A' #
			
 
				+  Char2 = 'B' #
			
 
				+  char1 = 'a' #
			
 
				+  char2 = 'b' #
			
 
				+  print(" int | codigo")
			
 
				+  print("  ", charN1, " | ", ord(charN1)) # A funcao ord(...) devolve
			
 
				+  print("  ", charN2, " | ", ord(charN2)) # o codigo ASCII do caractere dado
			
 
				+  print("  ", char1, " | ", ord(char1))
			
 
				+  print("  ", char2, " | ", ord(char2))
			
 
				+  print("  ", Char1, " | ", ord(Char1))
			
 
				+  print("  ", Char2, " | ", ord(Char2))
			
 
				+main()</pre></td></tr>
			
 
				+   </table></td></tr>
			
 
				+</table></center>
			
 
				+</p>
			
 
				+
			
 
				+<a name="tabela">
			
 
				+<p class="subsecao">Como gerar uma tabelas ASCII em <i>C</i> e em <i>Python</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+  Vale destacar que a codificação dos caracteres segue uma organização lógica, uma vez que o código para o
			
 
				+  caractere <i>0</i> é o <i>48</i>, então o <i>49</i> é para o <i>1</i> e assim por diante. Do mesmo modo, sendo
			
 
				+  <i>65</i> o código do caractere <i>A</i>, <i>66</i> é o caractere <i>B</i> e assim por diante.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Assim, podemos fazer um código para gerar tabelas dos caracteres e seu código ASCII, como ilustrado
			
 
				+  abaixo. Experimente alterar os limites do controle do laço, mas cuidado com os caracteres especiais, alguns
			
 
				+  podem "quebrar" linhas ou corresponder a outros caracteres de controle que podom deixar a tela "suja".
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Em <i>C</i> a converção entre inteiro ou caractere é praticamente direta, bastando usar o formatador correto
			
 
				+  (<tt>%d</tt> para inteiro ou <tt>%c</tt> para caractere). Entretanto em <i>Python</i> é necessário
			
 
				+  usar duas funções pré-definidas para isso, <tt>ord(inteiro)</tt> e <tt>chr(caractere)</tt>:
			
 
				+  sendo <tt>i</tt> inteiro, <tt>chr(i)</tt> fornece o caractere cujo código é <tt>i</tt>;
			
 
				+  sendo <tt>c</tt> caractere, <tt>ord(c)</tt> fornece o código do caractere <tt>c</tt>.
			
 
				+</p>
			
 
				+
			
 
				+<center>
			
 
				+Tab. 4. Como imprimir uma tabela código ASCII e o correspondente caractere<br/>
			
 
				+<table class="tbCodeLinCol">
			
 
				+ <tr><th>C </th> <th>Python 2</th></tr>
			
 
				+ <tr valign="top"><td><table class="tbCode">
			
 
				+   <tr><td><pre>#include &lt;stdio.h&gt;
			
 
				+int main (void) {
			
 
				+  int i, ini = 48, fim = 58;
			
 
				+  printf("cod. : car.\n");
			
 
				+  for (i=ini; i&lt;fim; i++)
			
 
				+    printf(" %3d :  %3c\n", i, i);
			
 
				+  printf("------------\n");
			
 
				+  ini = 65; fim = 91;
			
 
				+  for (i=ini; i&lt;fim; i++)
			
 
				+    printf(" %3d :  %3c\n", i, i);
			
 
				+  printf("------------\n");
			
 
				+  ini = 97; fim = 123;
			
 
				+  for (i=ini; i&lt;fim; i++)
			
 
				+    printf(" %3d :  %3c\n", i, i);
			
 
				+  printf("------------\n");   
			
 
				+  return 0;
			
 
				+  }</pre></td></tr>
			
 
				+ </table></td>
			
 
				+ <td><table class="tbCode"><pre>def main () :
			
 
				+  ini = 48; fim = 58;
			
 
				+  print("cod. : car.\n");
			
 
				+  for i in range(ini, fim) :
			
 
				+    print(" %3d :  %3c" % (i, chr(i)));
			
 
				+  print("------------\n");
			
 
				+  ini = 65; fim = 91;
			
 
				+  for i in range(ini, fim) :
			
 
				+    print(" %3d :  %3c" % (i, chr(i)));
			
 
				+  print("------------");
			
 
				+  ini = 97; fim = 123;
			
 
				+  for i in range(ini, fim) :
			
 
				+    print(" %3d :  %3c" % (i, chr(i)));
			
 
				+  print("------------");
			
 
				+     
			
 
				+main();</pre></td></tr>
			
 
				+   </table></td></tr>
			
 
				+</table></center>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Primeiro notem que usamos os formatadores <tt>%3d</tt> e <tt>%3c</tt> para ajustar 3 colunas à
			
 
				+  direita, o que é bastante útil para imprimir tabelas.
			
 
				+  O <tt>%d</tt> é utilizado para imprimir inteiro, enquanto <tt>%c</tt> para caractere,
			
 
				+  tanto em <i>C</i>, quanto em <i>Python</i>.
			
 
				+  Logo após a cadeia de caracteres, com eventuais valores a serem substituidos, deve vir uma
			
 
				+  lista de variáveis/valores compatíveis. No exemplo, a cadeia era formada por
			
 
				+  <tt>" %3d :  %3c"</tt>, portanto deveria vir a seguir 2 valores, o primeiro inteiro e o segundo caractere.
			
 
				+</p>
			
 
				+<p> 
			
 
				+  Entretanto existe uma diferença na sintaxe das duas linguagens, em <i>C</i> a lista de parâmetros vem
			
 
				+  separadas por vírgula simples, mas em <i>Python</i> precisa do símbolo de percentagem (<tt>%</tt>) após
			
 
				+  a cadeia de caracteres
			
 
				+  (<tt>" %3d :  %3c"</tt>) e, havendo mais de um valor a substituir, deve-se usar a sintaxe de
			
 
				+  <i>lista</i> (<tt>(i, chr(i))</tt>).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Note que o <i>Python</i> precisa de uma função especial para conveter inteiro em caractere,
			
 
				+  <tt>chr(i)</tt>, que devolve o caractere cujo código seja o valor armazenado na variável <i>i</i>
			
 
				+  (que deve ser inteira).
			
 
				+  Para fazer o oposto deve-se usar a função <tt>ord(varc)</tt> que é a função que devolve o código
			
 
				+  ASCII (<i>ord</i>enado) do caractere armazenado na variável <i>varc</i> (que neste caso deve ser
			
 
				+  para caractere - <i>char</i>).
			
 
				+</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/19: novo formato, pequenas correções<br/>
			
 
				+    2019/04/18: acerto '0010'=4 para '100001'=33, explicita funções <tt>ord</tt> e <tt>chr</tt>)<br/>
			
 
				+    2018/04/28: acertos no texto (valor 2^8) e cortada a parte sobre numero em ponto flutuante<br/>
			
 
				+    2017/05/01: primeira versão
			
 
				+</p>
			
 
				+
			
 
				+</div>
			
--- a/introducao_char.html
+++ b/introducao_char.html
@@ -0,0 +1,253 @@
 
				+<!--
			
 
				+ Introdução à Programação - 2017 - Prof. Leoônidas de Oliveira Brandão
			
 
				+ Introdução aos caracteres
			
 
				+ 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">
			
 
				+
			
 
				+
			
 
				+<p class="secao">Introdução aos caracteres</p>
			
 
				+
			
 
				+
			
 
				+<center><p>[
			
 
				+  <a href="#caracteres" title="Introdução aos caracteres">Erros</a> |
			
 
				+  <a href="#ascii" title="O código ASCII para representar caracteres">Código ASCII</a> |
			
 
				+  <a href="#io" title="Entrada/saída de caracteres">Entrada/saída</a></a>
			
 
				+ ]</p>
			
 
				+</center>
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+Nesta seção examinaremos resumidamente como utilizar caracteres tanto em <em>C</em> quanto em <em>Python</em>.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="caracteres">
			
 
				+<p class="secao">Interpretando sequência de <i>bits</i> como número ou caractere</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+  Como citado na seção sobre 
			
 
				+  <a href="#" onclick="trocaPagina('introducao_var.html')" title="variaveis">variáveis</a>, a informação básica
			
 
				+  nos computadores digitais é uma sequência de <i>bits</i> e o contexto é quem indica como estes <i>bits</i> devem ser interpretados.
			
 
				+  exemplo, a sequência <tt>1000001</tt> poderia ser interpretada como um valor inteiro (neste caso seria o valor
			
 
				+  <i>65 = 1*2<sup>6</sup>+1*2<sup>0</sup></i>) ou como um caractere (nesse caso a letra <i>A</i>, vide abaixo explicação
			
 
				+  sobre código <i>ASCII</i>).
			
 
				+  De modo semelhante, se a sequência <tt>110000</tt> deve ser interpretada como caractere, seria o dígito <i>0</i>,
			
 
				+  por outro lado, se for interpretada como inteiro (desconsiderando a questão do sinal), seria o
			
 
				+  <i>48 = 1*2<sup>5</sup>+1*2<sup>4</sup> = 32 + 16</i>).
			
 
				+  Ou seja, existe uma tabela associando valor numérico e caractere, como explicado na seção abaixo.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Resumidamente o tratamento de dados em um computador digital, se resume à processar sequências de digitos.
			
 
				+  Assim, ao tentar examinar determinado dado em memória, deve-se saber em que posição da memória o dado está em um quanto <i>bits</i> tem tal dado.
			
 
				+  A figura ilustra isso, com 3 variáveis de tamanho 1 <i>bytes</i> (<i>a</i>, <i>b</i> e <i>c</i>) e uma ocupando 2 <i>bytes</i> (<i>x</i>).
			
 
				+  No caso de caracteres (símbolos que devem ser apresentados, como é o caso dos <i>dígitos</i> e das <i>letras</i>), basta existir
			
 
				+  uma <i>associação</i> (ou <i>mapeamento</i>) entre os <i>bits</i> e o símbolo a ser mostrado. Claro que está associação depende também do tamanho,
			
 
				+  quanto <i>bits</i> são usados para representar cada símbolo.
			
 
				+  Na seção seguinte apresento a primeira tabela de associação entre <i>bits</i> e símbolos, a
			
 
				+  <a href="#ascii" title="seguir para seção da tabela ASCII">tabela ASCII</a>.
			
 
				+</p>
			
 
				+
			
 
				+<center>
			
 
				+  <img src="img/img_intr_char_memoria.png" title="Ilustracao de RAM com variável 'a' no endereço P, 'b' iniciando em P+1 e assim por diante"/>
			
 
				+  <br/>
			
 
				+  <i>Fig. 1. Representação da memória, com 3 variáveis usando 1 <i>bytes</i> (8 <i>bits</i>) e outra usando 2 <i>bytes</i>.</i>
			
 
				+</center>
			
 
				+
			
 
				+<p>
			
 
				+  Mas o tratamento de números <i>reais</i> apresentam questões mais difíceis, para começar não existem valores que,
			
 
				+  por maior que seja a precisão do equipamento, seria impossível representá-los.
			
 
				+  Um exemplo simples é o valor correspondente à fração <i>1/3</i>, que é uma <i>dízima periódica</i>, portanto com
			
 
				+  dígitos (<i>0.3333...</i>).
			
 
				+  Além disso existe a dificuldade de representar número grande e número muito próximos de zero.
			
 
				+  O truque usual para <i>simular</i> reais (representação em <i>ponto flutuante</i>), estude esse assunto no texto sobre
			
 
				+  <a href="#" onclick="trocaPagina('introducao_float.html')" title="seguir para secao sobre ponto flutuante">representação em ponto flutuante</a>.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+
			
 
				+<a name="ascii">
			
 
				+<p class="secao">Código ASCII</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+Um primeiro padrão para representar os caracteres é o 
			
 
				+<a href="https://en.wikipedia.org/wiki/ASCII" title="ver detalhes na WikiPedia"
			
 
				+   target="_blank" i><b>American Standard Code for Information Interchange</b></a>.
			
 
				+O padrão ASCII é bastante antigo, ainda da década de 1960 e por isso utiliza apenas 8 <i>bits</i> para representar todos os possíveis
			
 
				+caracteres, o que resultava em um número reduzidíssimo de 512 códigos/símbolos distintos.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Como o código ASCII foi baseado no alfabeto em lingua Inglesa, eles presentam apenas caracteres sem acentos.
			
 
				+Usualmente associamos um natural a cada símbolo, assim no ASCII pode-se associar caracteres aos <b>códigos ASCII</b>
			
 
				+0 até 512.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Como exemplos de código ASCII a letra 'A' é associada ao natural 65, o 'B' ao 66 e assim por diante.
			
 
				+Do mesmo modo, o 'a' é associada ao natural 97 e o caractere 'z' ao 122.
			
 
				+Já o natural 48 é associado do dígito '0', o 49 ao '1' e assim por diante até o 57 associado '9'.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="io">
			
 
				+<p class="secao">Entrada e saída de caracteres em <i>C</i> e em <i>Python</i></p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+Como já citado nas outras seções, o contexto deve definir como sequências de <i>bits</i> devem ser tratadas.
			
 
				+Para tratar como caractere deve-se indicar isso ao computador de alguma forma.
			
 
				+Tanto a linguagem <i>C</i> como a linguagem <i>Python</i> dispõe um tipo especial variável para tratar com caracteres.
			
 
				+</p>
			
 
				+
			
 
				+<p> 
			
 
				+Na linguagem <i>C</i> tem o tipo <tt>char</tt>, que precisa do formatador <tt>%c</tt>, mas pode-se imprimir uma
			
 
				+variável <tt>char</tt> como inteiro e vice-versa, neste caso usa-se seu código ASCII.
			
 
				+Já em <i>Python 2</i> é preciso de uma função especial para leitura (a <tt>raw_input()</tt>) e na impressão
			
 
				+não é preciso qualquer diferenciação, pois <i>Python</i> aplica um filtro para tratar se a variávem sendo impressa
			
 
				+é inteira, flutuante ou caractere. Vide  <a href="#tab2">tabela 1</a> abaixo.
			
 
				+</p>
			
 
				+<center>
			
 
				+<a name="tab2">
			
 
				+Tab. 1. Sobre a leitura de caracteres em <i>C</i> e em <i>Python</i></a>
			
 
				+<br/>
			
 
				+<table class="tbCodeLinCol">
			
 
				+ <tr><th>C </th> <th>Python 2</th> <th>Python 3</th></tr>
			
 
				+ <tr valign="top"><td><table class="tbCode">
			
 
				+   <tr><td><pre>char x; // declaracao de variavel em "ponto flutuante"
			
 
				+scanf("%c", &x); // leia como "caractere"
			
 
				+<verd>printf</verd>("%c", x); // imprima como "caractere"
			
 
				+</pre></td></tr>
			
 
				+ </table></td>
			
 
				+ <td><table class="tbCode"><pre># Vale notar: se o usuario digitar uma "string", como
			
 
				+# "nome", a variavel x recebera' a "string" toda
			
 
				+x = raw_input(); # leia como "caractere"
			
 
				+<verd>print</verd>(x);
			
 
				+
			
 
				+</pre></td></tr>
			
 
				+   </table></td>
			
 
				+ <td><table class="tbCode"><pre># Vale notar: se o usuario digitar uma "string", como
			
 
				+# "nome", a variavel x recebera' a "string" toda
			
 
				+x = input(); # leia como "caractere"
			
 
				+<verd>print</verd>(x);
			
 
				+
			
 
				+</pre></td></tr>
			
 
				+   </table></td>
			
 
				+   </tr>
			
 
				+</table></center>
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+Vale notar que para atribuir constantes do tipo caractere, é
			
 
				+necessário que um único caractere esteja cercado por aspas simples.
			
 
				+Por exemplo, para atribuir a constante 'a' à uma variável do tipo
			
 
				+caractere de nome <tt>varc</tt> deve-se usar: <tt>varc = 'a';</tt> (o
			
 
				+finalizador ';' é opcional em <i>Python</i>).
			
 
				+</p>
			
 
				+
			
 
				+<p> 
			
 
				+Abaixo um exemplo de código que imprime primeiro o caractere associado ao código ASCII dado e depois
			
 
				+o contrário. Ao rodar este código será impresso os caracteres de código 48, 49, 97, 98, 65 e 66, respectivamente
			
 
				+'0', '1', 'a', 'b', 'A' e 'B'.
			
 
				+<center>
			
 
				+Tab. 2. Sobre conversão entre o caractere ASCII e seu código inteiro<br/>
			
 
				+<table class="tbCodeLinCol">
			
 
				+ <tr><th>C </th> <th>Python 2</th></tr>
			
 
				+ <tr valign="top"><td><table class="tbCode">
			
 
				+   <tr><td><pre>#include &lt;stdio.h&gt;
			
 
				+<verm>int</verm> main (void) {
			
 
				+  <verm>int</verm>          <cyan>// Criando 6 variaveis como (implicitamente) do tipo "int".</cyan>
			
 
				+    val1 = 48, <cyan>// Cada variavel recebera um valor inteiro que depois sera'</cyan>
			
 
				+    val2 = 49, <cyan>// interpretado como caractere.</cyan>
			
 
				+    num1 = 97, 
			
 
				+    num2 = 98, 
			
 
				+    Num1 = 65, 
			
 
				+    Num2 = 66; 
			
 
				+  <verm>char</verm>            <cyan>// Declarando variaveis tipo caractere</cyan>
			
 
				+    charN1 = '0', <cyan>// NOTE que para constantes do tipo</cyan>
			
 
				+    charN2 = '1', <cyan>// caractere, deve-se usar aspa simples</cyan>
			
 
				+    Char1  = 'A', 
			
 
				+    Char2  = 'B', 
			
 
				+    char1  = 'a', 
			
 
				+    char2  = 'b'; 
			
 
				+  <verd>printf</verd>(" int | codigo\n"); <cyan>// '\n' usado para forcar quebra de linha na impressao</cyan>
			
 
				+  <verd>printf</verd>("  %d | %c\n", val1, val1);
			
 
				+  <verd>printf</verd>("  %d | %c\n", val2, val2);
			
 
				+  <verd>printf</verd>("  %d | %c\n", num1, num1);
			
 
				+  <verd>printf</verd>("  %d | %c\n", num2, num2);
			
 
				+  <verd>printf</verd>("  %d | %c\n", Num1, Num1);
			
 
				+  <verd>printf</verd>("  %d | %c\n", Num2, Num2);
			
 
				+  <verd>printf</verd>(" int | codigo\n");
			
 
				+  <verd>printf</verd>(" %c | %d\n", charN1, charN1);
			
 
				+  <verd>printf</verd>(" %c | %d\n", charN2, charN2);
			
 
				+  <verd>printf</verd>(" %c | %d\n", char1,  char1);
			
 
				+  <verd>printf</verd>(" %c | %d\n", char2,  char2);
			
 
				+  <verd>printf</verd>(" %c | %d\n", Char1,  Char1);
			
 
				+  <verd>printf</verd>(" %c | %d\n", Char2,  Char2);
			
 
				+  return 0;
			
 
				+  }</pre></td></tr>
			
 
				+ </table></td>
			
 
				+ <td><table class="tbCode"><pre><verm>def</verm> main():
			
 
				+  val1 = 48 <cyan># Criando 6 variaveis como (implicitamente) do tipo "int".</cyan>
			
 
				+  val2 = 49 <cyan># Cada variavel recebera um valor inteiro que depois sera'</cyan>
			
 
				+  num1 = 97 <cyan># interpretado como caractere.</cyan>
			
 
				+  num2 = 98 
			
 
				+  Num1 = 65 
			
 
				+  Num2 = 66 
			
 
				+  <verd>print</verd>(" int | codigo")
			
 
				+  <verd>print</verd>(" ", val1, " | ", chr(val1)) <cyan># A funcao chr(...) devolve</cyan>
			
 
				+  <verd>print</verd>(" ", val2, " | ", chr(val2)) <cyan># o caractere associado ao</cyan>
			
 
				+  <verd>print</verd>(" ", num1, " | ", chr(num1)) <cyan># codigo ASCII dado</cyan>
			
 
				+  <verd>print</verd>(" ", num2, " | ", chr(num2))
			
 
				+  <verd>print</verd>(" ", Num1, " | ", chr(Num1))
			
 
				+  <verd>print</verd>(" ", Num2, " | ", chr(Num2))
			
 
				+  charN1 = '0' <cyan># NOTE que para constantes do tipo</cyan>
			
 
				+  charN2 = '1' <cyan># caractere, deve-se usar aspa simples</cyan>
			
 
				+  Char1 = 'A' 
			
 
				+  Char2 = 'B' 
			
 
				+  char1 = 'a' 
			
 
				+  char2 = 'b' 
			
 
				+  <verd>print</verd>(" int | codigo")
			
 
				+  <verd>print</verd>("  ", charN1, " | ", ord(charN1)) <cyan>#</cyan> A funcao ord(...) devolve</cyan>
			
 
				+  <verd>print</verd>("  ", charN2, " | ", ord(charN2)) <cyan>#</cyan> o codigo ASCII do caractere dado</cyan>
			
 
				+  <verd>print</verd>("  ", char1, " | ", ord(char1))
			
 
				+  <verd>print</verd>("  ", char2, " | ", ord(char2))
			
 
				+  <verd>print</verd>("  ", Char1, " | ", ord(Char1))
			
 
				+  <verd>print</verd>("  ", Char2, " | ", ord(Char2))
			
 
				+main()</pre></td></tr>
			
 
				+   </table></td></tr>
			
 
				+</table></center>
			
 
				+</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/10: nova versão, sem a parte de "float";<br/>
			
 
				+  2019/07/31: acerto no formato da página e em várias frases;<br/>
			
 
				+  2017/05/01: versão inicial
			
 
				+</p>
			
 
				+
			
 
				+</div>
			
--- a/introducao_depuracao_codigos.html
+++ b/introducao_depuracao_codigos.html
@@ -0,0 +1,413 @@
 
				+<!--
			
 
				+Introdução às técnicas básicas de depuração de código
			
 
				+-->
			
 
				+
			
 
				+  <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'>
			
 
				+<div class="pagina">
			
 
				+
			
 
				+
			
 
				+<p class="secao">Por que devemos saber depurar o código?</p>
			
 
				+
			
 
				+<p>
			
 
				+  Se você já está envolvido com o aprendizado de <i>programação</i> há algum tempo, então muito provavelmente já recebeu
			
 
				+  <font color="#aa0000">mensagens de erro</font>, algumas <b>sintáticas</b> (quando existe algum erro na <i>sintaxe</i> de seu código)
			
 
				+  mas outras, geralmente mais difíceis de resolver, na <i>lógica da execução</i>, neste caso um erro <b>semântico</b> (o programa não faz
			
 
				+  o que era esperado que ele fizesse).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Outra situação desagradável quanto é utilizado um ambiente para teste automático do código (caso é o caso do uso do
			
 
				+  <i>Moodle</i> com <i>VPL</i> ou com o <i>iTarefa/iVProg</i>), é o aprendiz conseguir (aparentemente) rodar com sucesso em seu ambiente,
			
 
				+  mas ao passar para o ambiente de seu curso, recebe alguma mensagem de erro...
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Então o que você faz? Olha todas as linhas do código e nada, tudo parece estar como deveria.
			
 
				+  O código parece correto, "não tem motivo algum para a saída ser diferente da esperada, certamente o
			
 
				+  <font color="#aa0000">sistema do curso tem erro</font>" é o que você pensa.
			
 
				+  <!--O avaliador automático deve estar com problema.-->
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Esta é uma reação natural, porém
			
 
				+  <font color="#000088">nem sempre "lemos" o que está codificado, mas o que pensamos ter codificado</font>,
			
 
				+  talvez você já tenha passado por isso ao escrever um redação...
			
 
				+  Nestes casos, o problema é nao darmos a devida atenção para todos os detalhes, mas em códigos mais complexos, eventualmente não
			
 
				+  examinamos algumas situações que os <i>casos-de-teste</i> estão preparados para testar.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Portanto, seja por falta de atenção, paciência ou complexidade do código, erros são comuns.
			
 
				+  Então o que devemos fazer para achar e corrigir estes erros?
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Primeiro devemos entender a natureza do erro, existem duas grandes categorias,
			
 
				+<font color="#008800"<i>erro sintático</i></font> ou <font color="#008800"<i>erro semântico</i></font>.
			
 
				+</p>
			
 
				+
			
 
				+<ul>
			
 
				+  <li><b>Erro Sintático</b>:
			
 
				+  É um erro na sintaxe da linguagem, em sua gramática, como por exemplo, usar letra maiúscula inicial para o <i>comando de seleção</i>
			
 
				+  (o sistema não reconhecerá como "comando de seleção", tentará como uma "atribuição", mas como "atribuição" também não estará correta).
			
 
				+  Neste caso, seu programa <font color="#aa0000">não</font> poderá ser "rodado".
			
 
				+  <!--de escrita, em geral o próprio compilador avisa, seja como <i>erro</i> (seu programa não irá compilar) ou <i>avisos</i> (um problema "corrigivel" pelo compilador)-->
			
 
				+  </li>
			
 
				+
			
 
				+  <li><b>Erro semântico</b>:
			
 
				+    É um erro na "lógica de seu código", em sua <i>semântica</i>, o código está sintaticamente correto, porém não faz o que se esperava dele.
			
 
				+    Por isso, este tipo de erro é geralmente mais difícil de ser identificado e corrigido.
			
 
				+    Para isso algumas técnicas básicas, como as apresentadas a seguir, podem ser de grande valia.
			
 
				+  <!-- Como o código está escrito seguindo a sintaxe correta, o compilador não acusa erro. -->
			
 
				+  </li>
			
 
				+</ul>
			
 
				+
			
 
				+
			
 
				+<p class="secao">Como tratar erros sintáticos?</p>
			
 
				+
			
 
				+<p>
			
 
				+  Como estes erros são acusados pelo próprio compilador são mais fáceis de identificar. Em geral, a mensagem de erro gerada indica a linha
			
 
				+  onde ocorreu o erro. Então é preciso calma e uma leitura cuidadosa para entender o significado da mensagem.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p class="subsecao">1. Leia as mensagens de erro geradas pelo compilador/interpretador</p>
			
 
				+
			
 
				+<p>
			
 
				+As mensagens de erro indicam qual o problema encontrado e porque a compilação/execução falhou. Por exemplo, considere os
			
 
				+códigos <i>C</i> e <i>Python</i> a seguir:
			
 
				+</p>
			
 
				+<center>
			
 
				+<i>Tab. 1. Exemplos de códigos com erros sintáticos (nome errado para o comando de impressão).</i>
			
 
				+<table ><tr style="border-bottom: 1px solid #000;"><td style="border-right: 1px solid #000;"><i>C</i></td><td>&nbsp; <i>Python</i></td></tr>
			
 
				+<tr><td style="border-right: 1px solid #000;">
			
 
				+<pre>#include &lt;stdio.h&gt;
			
 
				+int main (void) {
			
 
				+  <font color="#aa0000">prit</font>("Hello World\n"); 
			
 
				+  }</pre>
			
 
				+
			
 
				+<p>
			
 
				+A mensagem de erro (ou advertência) recebida ao tentar compilar:
			
 
				+</p>
			
 
				+<pre style="font-size:0.8em">main.c:2:1: warning: implicit declaration of function ‘<font color="#aa0000">prit</font>’ [-Wimplicit-function-declaration]
			
 
				+  main.c: undefined reference to `prit'
			
 
				+</pre></td><td><pre> def main () :
			
 
				+   <font color="#aa0000">prit</font>("Hello World");
			
 
				+ main();</pre>
			
 
				+
			
 
				+<p>
			
 
				+ &nbsp; A mensagem de erro recebida:
			
 
				+<pre style="font-size:0.8em"> Traceback (most recent call last):
			
 
				+ File "teste2.py", line 3, in <module>
			
 
				+   main();
			
 
				+ File "teste2.py", line 2, in main
			
 
				+   <font color="#aa0000">prit</font>("teste");
			
 
				+ NameError: global name 'prit' is not defined</pre></td></tr></table>
			
 
				+</center> 
			
 
				+
			
 
				+<p>
			
 
				+  Examinando as mensagens recebidas, podemos perceber que a linha com a "tentativa" de comando <tt><font color="#aa0000">prit</font></tt>
			
 
				+  está com problema.
			
 
				+  Se prestarmos atenção, nesta linha está escrito <tt><font color="#aa0000">prit</font></tt> ao invés de
			
 
				+  <tt><font color="#008800">printf</font></tt> para a linguagem <i>C</i>
			
 
				+  e <tt><font color="#008800">print</font></tt> para a linguagem <i>Python</i>.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+  Infelizmente nem sempre os erros são tão claros e simples como este. Como programação também é uma tarefa de exploração, as vezes
			
 
				+  utilizamos ferramentas que não estamos habituados, portanto apenas a leitura do erro não é suficiente.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p class="subsecao">2. Procurar na <i>Internet</i></p>
			
 
				+
			
 
				+<p>
			
 
				+  Provavelmente você não é a primeira pessoa a receber esta mensagem de erro, nem será a última, então, se fizer uma busca pela
			
 
				+  <i>Web</i>, provavelmente encontrará uma mensagem relatando erro semelhante e poderá estudar as proposta de correção.
			
 
				+  <!-- com uma busca rápida em fóruns, você conseguirá achar outra pessoa que passou por esta mesma situação e como ela solucionou. -->
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Em geral basta copiar o <i>mensagem de erro</i> e colar na barra de pesquisa do seu "buscador" preferido
			
 
				+  (experimente o <a href="https://duckduckgo.org/?q=%22debugging+program%22+%22find+out%22+error&t=h_&ia=web"
			
 
				+                    title="Um buscador que tem por princípio NAO persegui-lo! Não vender seus dados...">duckduckgo.org</a>).
			
 
				+</p>
			
 
				+<!--
			
 
				+teste_c/usar_pacote_assert.c
			
 
				+http://www.cs.yale.edu/homes/aspnes/pinewiki/C(2f)Debugging.html
			
 
				+-->
			
 
				+
			
 
				+
			
 
				+<p class="secao">Como tratar erros semânticos?</p>
			
 
				+
			
 
				+<p>
			
 
				+Como são erros de "lógica de programação", <!-- ou seja, seu programa executa, --> então existe ao menos um <i>conjunto de entradas</i>
			
 
				+para as quais a saída não é a esperada.
			
 
				+Isto nos deixa em uma situação que requer mais atenção e nem sempre será uma solução fácil.
			
 
				+Muitas vezes requerem reescrita parcial ou total do código.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p class="subsecao">1. Procure <i>simular</i> seu código</p>
			
 
				+
			
 
				+<p>
			
 
				+Se o seu algoritmo não é muito grande, pode-se fazer uma simulação dele para entender exatamente o que está fazendo e com isso identificar 
			
 
				+o momento que o primeiro erro aparece.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Para simular, construa uma tabela com todas variáveis de seu código (ou apenas aquelas que deseja rastrear),
			
 
				+sendo que cada variável terá sua coluna.
			
 
				+A cada instrução que altere o valor de determinada variáveis, deve-se registrar o novo valor na coluna correspondente,
			
 
				+na linha seguinte à última linha que teve um valor registrado, ou seja, as linhas da tabela indicam a ordem de execução
			
 
				+(uma entrada mais acima indica que a instrução que alterou a variável correspondente ocorreu "mais cedo").
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+<b>ATENÇÃO</b>, é essencial seguir precisamente a ordem de execução dos comandos e deve-se simular/executar 
			
 
				+<b>exatamente</b> o que está redigido (e não como "acha que deveria estar")!
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<center>
			
 
				+<p>
			
 
				+<i>Tab. 2. Exemplo de simulação de um código (sem erro): imprimir a somas dos naturais</i>. Usando "pseudo-código".</i>
			
 
				+<table><tr><td><pre style="font-size:0.8em">
			
 
				+#  Codigo                                   |    N  | soma |   i    | Impressoes | Explicacoes (por linha)
			
 
				+--------------------------------------------+-----------------------+------------+--------------------------
			
 
				+1  variaveis N, soma=0, i=0;                |    ?  |   0  |   0    |            | 1 : valores iniciais (N desconhecido!)
			
 
				+2  N = leia(); // ler valor e guardar em N  |    3  |      |        |            | 2 : ler valor e guardar em N (supor 3)
			
 
				+3  enquanto (i &lt; N) {                       |       |      |        |            | 3 : 0 &lt; 3 verdadeiro =&gt; entra no laco
			
 
				+4    soma = soma + i;                       |       |   0  |        |            | 4 : acumular i em soma
			
 
				+5    i = i + 1;                             |       |      |   1    |            | 5 : acumular 1 em i
			
 
				+6    }                                      |       |      |        |            | 6 : final laco, voltar 'a linha 3
			
 
				+7  escreva("fim");                          |       |      |        |            | 3 : 1 &lt; 3 verdadeiro =&gt; entra no laco
			
 
				+                                            |       |   1  |        |            | 4 : acumular i em soma
			
 
				+                                            |       |      |   2    |            | 5 : acumular 1 em i
			
 
				+                                            |       |      |        |            | 6 : final laco, voltar 'a linha 3
			
 
				+                                            |       |      |        |            | 3 : 2 &lt; 3 verdadeiro =&gt; entra no laco
			
 
				+                                            |       |   3  |        |            | 4 : acumular i em soma
			
 
				+                                            |       |      |   3    |            | 5 : acumular 1 em i
			
 
				+                                            |       |      |        |            | 6 : final laco, voltar 'a linha 3
			
 
				+                                            |       |      |        |            | 3 : 3 &lt; 3 falso =&gt; vai para final do laco
			
 
				+                                            |       |      |        |      3     | 7 : escrever valor em soma</pre>
			
 
				+</td></tr></table></p>
			
 
				+</center>
			
 
				+
			
 
				+
			
 
				+<p class="subsecao">2. Releia o código</p>
			
 
				+
			
 
				+<p>
			
 
				+Eventualmente existe um erro de lógica que "salte aos olhos", podendo deste modo encontrá-lo rapidamente.
			
 
				+Vejamos dois casos clássicos de erros semânticos (e que portanto podem rapidamente ser identificados), um
			
 
				+na linguagem <i>C</i> e outro na linguagem <i>Python</i>.
			
 
				+</p>
			
 
				+
			
 
				+<center>
			
 
				+  <i>Tab. 3. Um exemplo de erro semânticos clássico em <i>C</i> e um em <i>Python</i>.</i>
			
 
				+  <br/>
			
 
				+<table ><tr style="border-bottom: 1px solid #000;"><td style="border-right: 1px solid #000;">Erro semântico "clássico" em <i>C</i></td>
			
 
				+<td>&nbsp;</td>
			
 
				+<td>Erro semântico "clássico" em <i>Python</i></td></tr><tr><td style="border-right: 1px solid #000;"></td></tr>
			
 
				+<tr><td style="border-right: 1px solid #000;">
			
 
				+<pre>if (x = 0) // supondo que x chegue aqui com valor 0
			
 
				+  printf("O valor e' nulo\n");</pre>
			
 
				+<p>
			
 
				+Entretanto, a mensagem <b>não</b> é impressa!
			
 
				+A razão é que em <i>C</i> uma <i>expressão lógica</i> é uma <i>expressão aritmética</i> que é comparada com o valor nulo,
			
 
				+se for zero, então o resultado é <b>falso</b>, senão é <b>verdadeiro</b>.
			
 
				+Como a <i>expressão lógica</i> que aparece é <tt>x = 0</tt>, na verdade é um <i>comando de atribuição</i>, 
			
 
				+significando que a variável <tt>x</tt> receberá (novamente) o valor nulo
			
 
				+e o resultado da <i>expressão aritmética</i> é precisamente o zero! 
			
 
				+Ou seja, o resultado lógico será <i>falso</i> e o comando subordinado <b>não</b> será impresso!<br/>
			
 
				+Assim, correção é simples:
			
 
				+</p>
			
 
				+<p>
			
 
				+<pre>if (x == 0) // correcao: usar "=="
			
 
				+  printf("O valor e' nulo\n");</pre></td>
			
 
				+<td>&nbsp;</td>
			
 
				+<td>
			
 
				+<pre>if (x==0) : # supondo que x chegue aqui com valor 1
			
 
				+  y = 2;
			
 
				+print("O valor e' nulo");</pre>
			
 
				+</p>
			
 
				+</center>
			
 
				+
			
 
				+<p>
			
 
				+Entretanto, a mensagem é <b>incorretamente</b> impressa!
			
 
				+A razão é que em <i>Python</i> a <i>subordinação</i> de comandos é definida por <i>indentações</i>, ou seja,
			
 
				+para que o <tt>print("O valor e' nulo")</tt> estivesse corretamente subordinado ao comando <tt>if</tt> ele precisaria estar
			
 
				+alinhado ao comando <tt>y = 2;</tt>.<br/>
			
 
				+Assim, correção é simples:
			
 
				+<pre> if (x == 0) :
			
 
				+   y = 2;
			
 
				+   print("O valor e' nulo"); # correcao, alinhar com a linha acima</pre></td></tr></table>
			
 
				+</center>
			
 
				+
			
 
				+<p>
			
 
				+Porém, nem sempre é realista reler o código todo, então foque em partes críticas,
			
 
				+<!--
			
 
				+Partes críticas são limites entre
			
 
				+trechos de código, portanto devemos ter bastante atenção para <b>seleção</b> (if), <b>condicional de laços</b>
			
 
				+(while, for, do while), <b>atribuições</b> e <b>chamadas de função</b>.
			
 
				+-->
			
 
				+aquelas partes em que o erro acontece. Geralmente o erro encontra-se em algum comando de <b>seleção</b> (<tt>if</tt>),
			
 
				+em <b>condicional de laço</b> (<tt>while</tt>, <tt>for</tt> ou outros), em <b>atribuições</b> ou em <b>chamadas de função</b>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Este método requer maior conhecimento do programador para saber qual a parte crítica do código, elas podem ser diferentes para cada problema.
			
 
				+Além disto é necessário um entendimento maior do problema.
			
 
				+<!-- , conseguindo identificar a quais comandos são necessários e em qual ordem devem ser executados. -->
			
 
				+Então a técnica seguinte pode ajudar.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="bandeiras">
			
 
				+<p class="subsecao">3. Utilizar "bandeiras" (flags) </p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+  Nem sempre é possível identificar tudo apenas relendo o código, principalmente em códigos mais complexos. Portanto precisamos de
			
 
				+  mais ferramentas. Esta técnica ajuda a encontrar as <i>partes críticas</i> de seu código e consiste em imprimir algumas variáveis
			
 
				+  ao longo do código.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Se você não tem a mínima ideia de onde o erro esteja, pode colocar uma impressão de uma lista de variáveis como primeira instrução
			
 
				+  dentro de cada comando de <i>seleção</i> ou em cada comando de <i>repetição</i>.
			
 
				+  No caso de laço infinito (um erro muito comum!), o uso de uma "bandeira" como primeira instrução do <i>comando de repetição</i>
			
 
				+  lhe indicará claramente o problema, <i>laço infinito</i>!
			
 
				+<!--
			
 
				+Esta técnica consiste em imprimir os valores de variáveis em um momento importante, em geral, logo antes dela ser utilizada.
			
 
				+Através dessa impressão podemos comparar nossa expectativa, qual o valor que a variável deveria
			
 
				+ter, com a realidade, qual valor ela tem.
			
 
				+-->
			
 
				+</p>
			
 
				+
			
 
				+<!--
			
 
				+<p>
			
 
				+Desta forma devemos criar casos de teste nos quais saibamos os valores que as variáveis devem assumir durante a execução do código.
			
 
				+</p>
			
 
				+-->
			
 
				+
			
 
				+<p>
			
 
				+Considere o seguinte problema: <i>Escreva um programa que imprima a frase "hello world" 10 vezes</i>.
			
 
				+Suponha que um colega tenha apresentado a seguinte solução (em <i>C</i> à esquerda e em <i>Python</i> à direita).
			
 
				+</p>
			
 
				+
			
 
				+<center>
			
 
				+<i>Tab. 4. Um exemplo de erro semântico clássico: laço infinito.</i> 
			
 
				+<table ><tr style="border-bottom: 1px solid #000;"><td style="border-right: 1px solid #000;"><i>C</i></td><td>&nbsp; <i>Python</i></td></tr>
			
 
				+<tr><td style="border-right: 1px solid #000;">
			
 
				+<pre>#include &lt;stdio.h&gt;
			
 
				+int main (void) {
			
 
				+  int i=0;
			
 
				+  while (i &lt; 10) {
			
 
				+    printf("hello world\n");
			
 
				+    }
			
 
				+  }</pre>
			
 
				+</td><td><pre> def main () :
			
 
				+  i = 0;
			
 
				+  while (i &lt; 10) :   
			
 
				+    print("Hello World");</pre>
			
 
				+</td></tr></table>
			
 
				+</center> 
			
 
				+
			
 
				+<p>
			
 
				+Ao executar o código, a frase fica sendo impressa indefinidamente (portanto <i>laço infinito</i>), neste caso, qual o melhor local para inserirmos uma bandeira?
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Como o problema está relacionado à frase ser impressa muitas vezes, fica natural colocar a <i>bandeira</i> como primeira instrução do <i>comando de repetição</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p style="color:#00aa00">
			
 
				+  Mas qual variável imprimir?
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  No exemplo acima (tab. 4), não é difícil deduzir, pois o laço usa a variável <tt>i</tt> como controle (e não tem outra...).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Ao fazer isto e executarmos o código percebemos que além da frase, o valor de <tt>i</tt> está sempre com o valor nulo.
			
 
				+  Portanto o que falta é o incremento na variável de controlo, antes de testar a <i>condição de entrada</i>.
			
 
				+  <br/>
			
 
				+  Ou seja, identificamos que não existe uma atribuição para incrementar a variável de controle.
			
 
				+</p>
			
 
				+
			
 
				+<p style="color:#00aa00">
			
 
				+  O que fazer em códigos maiores?
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Quando seu código for grande, será necessário identificar cada "bandeira", por exemplo, usando a linguagem "Portugol",
			
 
				+  use algo parecido com:
			
 
				+  <tt>imprima("1: alguma informacao daqui");... imprima("2: algo daqui");...imprima("10: algo daqui");...</tt>.
			
 
				+</p>
			
 
				+  
			
 
				+<p>
			
 
				+  Mas vale a pena fazer uma análise geral de seu código e da resposta obtida, isso pode indicar um provável local de erro,
			
 
				+  neste caso, concentre-se neste trecho, colocando uma "bandeira" em cada comando de <i>seleção</i> e em todos os inícios
			
 
				+  de <i>laços</i>.
			
 
				+  Neste caso vale a pena diferenciar as mensagens, por exemplo, com:
			
 
				+  <tt>imprima("se 1: i=%d", i); ... imprima("laco 1: j=%d", j); ... </tt>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Esta técnica é muito utilizada por ser rápida e extremamente efetiva.
			
 
				+  Mas lembre-se: sempre apague/comente as "bandeiras" depois de utilizá-las,
			
 
				+  você não quer que a execução do seu código final fique poluída com a impressão de várias "bandeiras".
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p class="subsecao">4. Explique o código para alguém:</p>
			
 
				+
			
 
				+<p>
			
 
				+  Esta técnica é conhecida como
			
 
				+  "<a href="https://rubberduckdebugging.com/" title="mais detalhes sobre RDD">Rubber duck debugging" (RDD - "depuração pato de borracha")</a>,
			
 
				+  que está associada a ideias bastante antigas
			
 
				+  (como "tente ensinar para aprender") e outras nem tanto, como a técnica "pensamento em voz alta" (<i>think aloud</i>).
			
 
				+  A RDD consiste em explicar, linha por linha, o código para uma outra pessoa, ou na falta de uma pessoa explique para um objeto
			
 
				+  (como o "pato de borracha").
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Pode-se adotar uma abordagem hierárquica, procurando explicar de modo mais geral o que seu programa deveria fazer e depois ir detalhando.
			
 
				+  Primeiro explique os objetivos do problema, o que você deseja fazer e quais ideias tem para resolvê-lo. Eventualmente pode haver um
			
 
				+  problema de entendimento de enunciado.
			
 
				+  <br/>
			
 
				+  Se o problema estiver nos detalhes, tente explicar cada trecho de seu código e, em cada um, o que que cada linha dele faz.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Ao explicar o trabalho para outra pessoa que não tem a mesma familiaridade com o problema ou com seu código,
			
 
				+  eventualmente você poderá compreender melhor o fez ou o que deveria fazer.
			
 
				+  <!-- acaba entrando em detalhes que pareciam óbvios ou irrelevantes, sendo por vezes a causa da dor de cabeça.-->
			
 
				+</p>
			
 
				+
			
 
				+  <p class="autoria">
			
 
				+    <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/15: novo formato, pequenas revisões<br/>
			
 
				+    2020/08/07: Sexta, 07 Agosto 2020, 20:15<br/>
			
 
				+    2020/03/30: Segunda, 30 Março 2020, 21:15
			
 
				+  </p>
			
 
				+
			
 
				+<!--
			
 
				+Para entender melhor esta história clique aqui</a>.
			
 
				+https://rubberduckdebugging.com/
			
 
				+https://www.techopedia.com/definition/31880/rubber-duck-debugging
			
 
				+http://lists.ethernal.org/oldarchives/cantlug-0211/msg00174.html
			
 
				+  -->
			
 
				+
			
 
				+</div>
			
--- a/introducao_eficiencia_algoritmos.html
+++ b/introducao_eficiencia_algoritmos.html
@@ -0,0 +1,634 @@
 
				+<!--
			
 
				+ Introdução à Programação - 2017 - Prof. Leoônidas de Oliveira Brandão
			
 
				+ Introdução à eficiência de algoritmos
			
 
				+ 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">
			
 
				+
			
 
				+        
			
 
				+<p class="secao">Introdução à eficiência de algoritmos</p>
			
 
				+
			
 
				+<center><p>[
			
 
				+  <a href="#precisao" title="Problema de precisao numerica">Precisão</a> &nbsp; | &nbsp; 
			
 
				+  <a href="#tempo" title="Eficiencia em relacao ao tempo de execucao">Velocidade</a> &nbsp; | &nbsp; 
			
 
				+  <a href="#cosseno" title="Eficiencia: examinando a funcao transcendente <i>cosseno</i>">Cosseno</a> &nbsp; | &nbsp; 
			
 
				+  <a href="#muitoingenuo" title="Uma primeira solucao nada eficiente para a funcao <i>cosseno</i>">Solução ineficiente</a> &nbsp; | &nbsp; 
			
 
				+  <a href="#ingenuo" title="Uma segunda solucao para a funcao <i>cosseno</i>: ainda ineficaz">Solução</a> &nbsp; | &nbsp; 
			
 
				+  <a href="#eficiente" title="Uma solucao eficiente para a funcao <i>cosseno</i>">Solução eficiente</a>
			
 
				+ ]</p>
			
 
				+</center>
			
 
				+
			
 
				+<!--
			
 
				+<p>
			
 
				+<b>Alterações</b>: //2017  <i>C</i> e <i>Python</i>)
			
 
				+</p>
			
 
				+-->
			
 
				+
			
 
				+<p>
			
 
				+  Nesta seção examinaremos uma questão essencial à computação, se o algoritmo é ou não eficiente para resolver o problema de interesse.
			
 
				+  Sobre isso existem vários aspectos que podem ser considerados, aqui examinaremos dois: a <b>precisão</b> e a <b>velocidade</b>.
			
 
				+  <center>
			
 
				+  <img src="img/img_precisao_x_velocidade.png" title="Gráfico ilustrando que geralmente precisão varia inversamente com a velocidade"/>
			
 
				+  <br/>
			
 
				+  <i>Fig. 1. Representação de que maior velocidade de execução geralmente implica em menor precisão numérica.</i>
			
 
				+</center>
			
 
				+
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  A <b style="color:#0000aa;">precisão</b> diz respeito à "qualidade" da resposta, é necessário que ela seja
			
 
				+  <b style="color:#00aa00;">suficientemente próxima da real solução</b> para o problema considerado.
			
 
				+  Para ilustrar podemos considerar um exemplo <i>numérico</i>, por exemplo, tentar encontrar a raíz para determinada
			
 
				+  função <i>f(.)</i>, ou seja, encontrar (se existir) algum <i>x</i> para o qual <i>f(x)=0</i>.
			
 
				+  Nesse caso, se o interesse estiver em pontos dentro do intervalo <i>[0, 1]</i>, seria inútil se o ponto devolvido
			
 
				+  tivesse um <i style="color:#aa0000;" title="pois se a resposta foi 1/2, na verdade a raíz poderia ser desde o ponto 0 até o ponto 1!">erro
			
 
				+  maior que <i>0,5</i></i> (i.e., <i>|f(x)| > 0,5</i>).
			
 
				+  <br/>
			
 
				+  Outro exemplo numérico é computar uma
			
 
				+  <a href="https://pt.wikipedia.org/wiki/Fun%C3%A7%C3%A3o_transcendente" target="_blank"
			
 
				+     title="função que não pode ser escrita com operações algébricas - ver na WikiPedia">função transcendente</a> como o <i>cosseno</i> de valor real.
			
 
				+  Uma vez as operações que um computador digita consegue efetivamente realizar são aquelas diretamente derivadas da soma, é preciso encontrar um
			
 
				+  algoritmo que compute uma <i>boa aproximação</i> para o <i>cosseno(x)</i>, qualquer que seja o valor real <i>x</i>.
			
 
				+  Neste texto examinaremos as implementações para as funções <i>seno</i> e <i>cosseno</i> empregando o conceito matemático
			
 
				+  <a href="https://pt.wikipedia.org/wiki/S%C3%A9rie_de_Taylor" target="_blank">
			
 
				+  <b style="color:#00aa00;"
			
 
				+     title="um somatório com infinitos termos que aproxima a função por meio de um
			
 
				+  polinômio cuja propriedade é que suas derivadas, de todas as ordens, 
			
 
				+  coincidem com as derivadas da função aproximada no ponto dado">série de Taylor</b></a>. <!-- " -->
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Quanto à <b style="color:#0000aa;">velocidade</b>, ela diz respeito ao <i>tempo que o algoritmo leva para computar a resposta</i>.
			
 
				+  É preciso que o tempo seja viável para o contexto, quer dizer que ao obter a resposta, essa ainda seja útil.
			
 
				+  Para ilustrar podemos considerar novamente o exemplo <i>numérico</i> da determinação da raíz da função <i>f(.)</i> (se existir, encontrar
			
 
				+  algum <i>x</i> para o qual <i>f(x)=0</i>).
			
 
				+  Digamos que o interessado seja uma industria de produção de tintas e que a raíz representa o melhor momento para interromper a
			
 
				+  produção de cada um de seus 300 pigmentos distintos.
			
 
				+  Nesse caso, se a resposta para cada função/pigmento demorar cerca de 10 minutos, então o método empregado é
			
 
				+  inviável, pois seria <i style="color:#aa0000;" title="pois levaria mais de 2 dias para obter a produção ideal para aquele dia!">necessário
			
 
				+  cerca de 50 horas para obter as 300 raízes</i> (<i>50 x 10 min = 3000 min</i>).
			
 
				+  <br/>
			
 
				+  Um exemplo de outra natureza seria o contexto de planejamentos de pousos e aterrissagens em um grande aeroporto, após a ocorrência
			
 
				+  de algum evento não esperado, deve-se gerar uma nova escala para as próxima
			
 
				+  aterrissagens e decolagens muito rapidamente, antes que acabe o combustível de alguma aeronave em sobrevoo.
			
 
				+  
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="precisao">
			
 
				+<p class="secao">Problema de precisão numérica</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+  Como discutido no <a href="#" onclick="trocaPagina('introducao_float.html')" title="examinar o texto sobre ponto flutuante">texto sobre
			
 
				+  <i>ponto flutuante</i></a>, o problema de precisão numérica inicia-se na impossibilidade de representar valores
			
 
				+  <i style="color:#00aa00;" title="Impossível representar todos os dígitos de Pi (pois são infinitos)!">irracionais</i>
			
 
				+  e mesmo
			
 
				+  <i style="color:#00aa00;" title="Impossível representar todos os dígios de 1/3 (pois são infinitos)!">dizimas periódicas</i> que precisam
			
 
				+  ser <b style="color:#0000aa;" title="Por exemplo, representar 1/3 por 0,3333 (truncando na quarta casa decimal)">truncados</b>.
			
 
				+  Mas existe outra questão de eficiência, que é a precisão numérica do algoritmo utilizado para o cômputo.
			
 
				+  Um exemplo ilustrativo é acumular valores que crescem muito rapidamente (como funções exponenciais ou fatoriais) ou
			
 
				+  dividir por valores que aproximam-se de zero, ambos podem produzir resultados "ruins":
			
 
				+  <b style="color:#0000aa;" title="estourar o maior valor que o computador tem capacidade para representar (overflow)">estouro</b>
			
 
				+  (ou <i>transbordamento</i>).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Como citado acima, um problema computacional é conseguir implementar funções que não podem ser escritas a partir de operações elementares
			
 
				+  de soma e multiplicação, com é o caso da função <i>cosseno</i> (que por isso é transcendental).
			
 
				+  Hoje, este não parece ser um problema, pois qualquer computador de bolso tem uma calculadora implementada que é capaz de computar boas
			
 
				+  aproximações para a função <i>cosseno</i>.
			
 
				+  Entretanto, isso só é possível por implementarem algum algoritmo eficiente, a partir de somas e multiplicações.
			
 
				+  No caso das <i>funções trigonométicas</i>, isso é feito usando a técnica matemática da
			
 
				+  <i title="Na verdade com um truque para tratar todos os períodos">série de Taylor</i>.
			
 
				+  Isso será ilustrado nas tabelas <a href="#solucaoruim" title="seguir para implementação ruim">1 (implementação ineficiente)</a>
			
 
				+  e <a href="#solucaoboa" title="seguir para implementação boa">2 (implementação eficiente)</a>.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="tempo">
			
 
				+<p class="secao">Eficiência em relação ao tempo de execução</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+  Existem problemas que sabidamente são intratáveis no sentido de sabermos, matematicamente, que é impossível existir
			
 
				+  um algoritmo que consegue resolvê-lo (como o <i>problema da parada</i>: não existe algoritmo que possa decidir se um algoritmo qualquer pára ou
			
 
				+  após um tempo finito de execução).
			
 
				+</p>
			
 
				+
			
 
				+<!--p class="sabermais" title="Para quem deseja saber um pouco mais 'como funciona'"-->
			
 
				+<p><sabermais title="Para quem deseja saber um pouco mais 'como funciona'">
			
 
				+  Existem outros tipos de problemas que supomos <b style="color:#aa0000;">não</b> ser possível resolvê-los eficientemente, ou seja,
			
 
				+  todas suas soluções conhecidas são ineficientes
			
 
				+  (tempo proporcional à uma função exponencial, de base maior que a unidade).
			
 
				+  Um exemplo nessa categoria, que denominada
			
 
				+  <a href="https://en.wikipedia.org/wiki/NP-completeness" target="_blank" title="Examinar texto na WikiPedia em Inglês">NP-Completo</a>, é o
			
 
				+  <a href="https://pt.wikipedia.org/wiki/Problema_de_satisfatibilidade_booliana" target="_blank"
			
 
				+     title="examinar a explicação na WikiPedia sobre o problema da satisfatibilidade"><i>problema da satisfatibilidade</i></a>:
			
 
				+  encontrar valores para cada uma de suas variáveis, que são <i>booleanas</i>, de modo a tornar a expressão lógica verdadeira,
			
 
				+  como em <i>f(b<sub>1</sub>, b<sub>2</sub>, b<sub>3</sub>) = b<sub>1</sub> E (b<sub>2</sub> OU não b<sub>3</sub>)</i>.
			
 
				+  Para esse caso, por ser uma instância pequena do problema, é fácil perceber que a resposta é <i>sim</i>, basta tomar
			
 
				+  <i>b<sub>1</sub></i> e <i>b<sub>2</sub></i> como <i>verdadeiro</i> (não importando o valor de <i>b<sub>3</sub></i>
			
 
				+  pode ser <i>verdadeiro</i> ou <i>falso</i>).
			
 
				+  A solução conhecida para a <i>satisfatibilidade</i> é tentar todas as <i>2<sup>n<sup></i> possibilidades para as <i>n</i>
			
 
				+  variáveis! Se o <i>n</i> for grande, é inviável esperar por uma resposta.
			
 
				+  Exemplo para <i>n=3</i>: testar com
			
 
				+  <codigo2>  &nbsp; &nbsp; <i>f(verdadeiro,verdadeiro,verdadeiro)</i>, <i>f(verdadeiro,verdadeiro,falso)</i>,
			
 
				+  &nbsp; &nbsp; <i>f(verdadeiro,falso,     verdadeiro)</i>, <i>f(verdadeiro,falso,     falso)</i>,
			
 
				+  &nbsp; &nbsp; <i>f(falso,     verdadeiro,verdadeiro)</i>, <i>f(falso,     verdadeiro,falso)</i>,
			
 
				+  &nbsp; &nbsp; <i>f(falso,     falso,     verdadeiro)</i>, <i>f(falso,     falso,     falso)</i>.</codigo2>
			
 
				+</sabermais>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Na seção seguinte examinaremos um particular problema, conseguir um valor aproximado para a função trigonométrica <i>cosseno</i>,
			
 
				+  explorando tanto a questão da eficiência numérica (precisão) quanto a de tempo de execução (velocidade).
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="cosseno">
			
 
				+<p class="secao"><i>Série de Taylor</i> e a função <i>cosseno</i></p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+  A função <i>cosseno</i>, assim como várias outras, não pode ser computada de modo exato em um computador digital,
			
 
				+  em razão de ser uma
			
 
				+  <a href="https://pt.wikipedia.org/wiki/Função_transcendente" title="sobre funcao transcendente">função <i>transcendente</i></a>
			
 
				+  (basicamente, significa que não pode ser computada a partir de somas).
			
 
				+  Então usamos uma
			
 
				+  <a href="https://en.wikipedia.org/wiki/Taylor_series" target="_blank"
			
 
				+     title="examinar a explicação na WikiPedia sobre séries de Taylor">teoria matemática apresentada em 1715</a>,
			
 
				+  aproximá-la por uma função polinomial que tem como propriedade ter todas as derivadas
			
 
				+  coincidindo com as derivadas da função a ser aproximada, considerando determinado ponto fixado.
			
 
				+  Esse polinômio de infinitos termos, recebeu o nome de
			
 
				+  <a href="https://pt.wikipedia.org/wiki/S%C3%A9rie_de_Taylor" title="sobre serie de Taylor na WikiPedia"><b>série de Taylor</b></a>,
			
 
				+  devido seu proponente Brook Taylor.
			
 
				+</p>
			
 
				+
			
 
				+</p>
			
 
				+  O <i>polinômio de Taylor</i> que aproxima a função cosseno quando aplicada ao ponto <i>x</i> é:
			
 
				+  <center>
			
 
				+   <i>cos(x) = 1 - x<sup>2</sup> /2! + x<sup>4</sup> /4! - x<sup>6</sup> /6! + x<sup>8</sup> /8! + ...</i>
			
 
				+  </center>
			
 
				+  Se estiver interessado entender a Matemática para se construir a demostração desse polinômio, estude o bloco abaixo.
			
 
				+<p>
			
 
				+
			
 
				+<p>
			
 
				+<sabermais title="Para quem deseja saber um pouco mais: mas precisa conhecer Cálculo Diferencial">
			
 
				+  Como a função <i>cosseno</i> é periódica, de período <i title="letra grega Pi, representa a irracional 3.1415926535897932384626433...">2*&Pi;</i>
			
 
				+  e além disso os valores em cada quadrante coincidem em módulo, podemos computar apenas para primeiro caso, para <i>x</i> entre
			
 
				+  <i>0</i> e <i>&Pi;/2</i>.
			
 
				+  <img class="imgDir" src="img/img_eficiencia_cos_trig.png" title="Imagem (do iGraf) da função trigonométrica cosseno indicando o período 2*&Pi;">
			
 
				+  Desse modo, podemos usar um caso particular da <b>série de Taylor</b>, a séria aplicada ao ponto <i>x=0</i>, que neste caso é chamada
			
 
				+  de
			
 
				+  <a href="https://en.wikipedia.org/wiki/Colin_Maclaurin"
			
 
				+     title="sobre serie de MacLaurin na WikiPedia"><b style="color:#0000aa">série de MacLaurin</b></a>.
			
 
				+  Fixado um valor real <i>x</i> entre <i>0</i> e <i title="letra grega Pi, representa a irracional 3.1415926535897932384626433...">&Pi;/2</i>,
			
 
				+  a <i>série de MacLaurin</i> que aproxima o cosseno aplicado ao ponto <i>x=0</i>, <i>cos(x)</i>, é o polinômio (de infinitos termos)
			
 
				+  
			
 
				+  <i>p(x)=a<sub>0</sub>+a<sub>1</sub>x<sup>1</sup>+a<sub>2</sub>x<sup>2</sup>+a<sub>3</sub>x<sup>3</sup>+...</i>
			
 
				+
			
 
				+  de tal forma que
			
 
				+  a <i>k</i>-ésima derivada de <i>p(0)</i> coincide com a <i>k</i>-ésima derivada de <i>cos(0)</i>, ou seja,
			
 
				+  <i>cos(0)=p(0)</i>, <i>cos'(0)=p'(0)</i>, <i>cos''(0)=p''(0)</i> e assim por diante.
			
 
				+<br/>
			
 
				+<br/>
			
 
				+  Assim, no caso da função cosseno, escrevendo o polinômio candidato
			
 
				+  <i>p(x) = a<sub>0</sub> x<sup>0</sup> + a<sub>1</sub> x<sup>1</sup> + a<sub>2</sub> x<sup>2</sup> +...</i>
			
 
				+  e estabelecendo as identidades para cada derivada e usando <i>x=0</i> e sabendo que
			
 
				+  <i>cos(0)=1</i>, <i>sen(0)=0</i>, que
			
 
				+  <i>cos'(x)=-sen(x)</i> e que <i>sen'(x)=cos(x)=</i>, obtém-se
			
 
				+  <br/>
			
 
				+  &nbsp; &nbsp; <i>p(0)=a<sub>0</sub>
			
 
				+    &rArr; a<sub>0</sub> = 1<br/>
			
 
				+  &nbsp; &nbsp; <i>p'(0)=a<sub>1</sub>+2a<sub>2</sub>x<sup>1</sup>+3a<sub>3</sub>x<sup>2</sup>+...</i>|x=0
			
 
				+    &rArr; p'(0)=a<sub>1</sub>
			
 
				+    &rArr; a<sub>1</sub> = p'(0)= -sen(0) = 0
			
 
				+    &rArr; a<sub>1</sub> = 0<br/>
			
 
				+  &nbsp; &nbsp; <i>p''(0)=2a<sub>2</sub>+6a<sub>3</sub>x<sup>1</sup>+12a<sub>4</sub>x<sup>2</sup>+...</i>|x=0
			
 
				+    &rArr; (1/2)p''(0)=a<sub>2</sub>
			
 
				+    &rArr; a<sub>2</sub> = (1/2)(-cos(0)) = -1
			
 
				+    &rArr; a<sub>2</sub> = -1/2<br/>
			
 
				+  &nbsp; &nbsp; <i>p'''(0)=6a<sub>3</sub>+24a<sub>4</sub>x<sup>1</sup>+...</i>|x=0
			
 
				+    &rArr; (1/6)p'''(0)=a<sub>3</sub>
			
 
				+    &rArr; a<sub>3</sub> = (1/6)(cos'''(0)) = (1/3!)(-sen''(0)) = (1/3!)(-cos'(0)) = (1/3!)sen(0) = (1/3!)0
			
 
				+    &rArr; a<sub>3</sub> = 0<br/>
			
 
				+  e assim, por diante, obtendo-se o polinômio aproximador:
			
 
				+  <br/>
			
 
				+  &nbsp; &nbsp; &nbsp; &nbsp;
			
 
				+  <i>cos(x) = 1 - x<sup>2</sup> /2! + x<sup>4</sup> /4! - x<sup>6</sup> /6! + x<sup>8</sup> /8! + ...</i>
			
 
				+</sabermais>
			
 
				+</p>
			
 
				+
			
 
				+<!--
			
 
				+&rArr; = implica
			
 
				+&sime; aproximado
			
 
				+&check;
			
 
				+ -->
			
 
				+
			
 
				+<a name="cosseno">
			
 
				+<p class="secao">Eficiência: examinando a função transcendente <i>cosseno</i></p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+  A implementação da aproximação da função <i>cosseno</i>, próximo do valor nulo, por <i>série de Taylor</i> produz um bom exemplo
			
 
				+  para ilustrar <i>ineficiência</i> e <i>eficiência</i> de algoritmos, quanto ao tempo de execução e quanto à precisão numérica.
			
 
				+  Uma primeira observação é que é necessário truncar a série por duas razões:
			
 
				+  é impossível computar infinitos termos; além disso a partir de determinado termo, todos os seguintes resultam zero (devido à
			
 
				+  precisão finita de qualquer computador).
			
 
				+  Portanto, devemos <i>truncar</i> a <i>série de Taylor</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Analisando o polinômio de Taylor para o <i>cosseno</i>, talvez um aprendiz na arte da programação perceba
			
 
				+  que é possível escrever cada termos do somatório com
			
 
				+  <i>(-1)<sub>k</sub>(1/2k!)x<sup>2k</sup></i>, <i>k=0,1,2,...</i>.
			
 
				+  Ou seja, cada termo tem no numerador um cálculo de exponencial (<i>x<sup>2k</sup></i>) e no denominador um cálculo de fatorial (<i>2k!</i>).
			
 
				+  Daí poderia-se desenhar um laço acumulando cada um desses termos.
			
 
				+  <br/>
			
 
				+  Entretanto, essa solução tem um claro problema (que aparecerá no primeiro teste):
			
 
				+  o computo de exponencial (se maior que um) e de fatorial, ambos crescem muito rápido!
			
 
				+  Isso resultará em valores nada próximos do esperado.
			
 
				+  Isso é ilustrado abaixo.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="taylor">
			
 
				+<p class="secao">Uma primeira solução nada eficiente para a função <i>cosseno</i></p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+A partir da série de Taylor para o cosseno, percebe-se que pode-se elaborar um laço que a cada passo computa um dos termos da série, primeiro
			
 
				+<i>1=x<sup>0</sup>/0!</i>, depois <i>x<sup>2</sup>/2!</i> e assim por diante, para um passo genérico <i>k</i> seria,
			
 
				+<i>-1<sup>k</sup>x<sup>2k</sup>/(2k!)</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Desse modo uma primeira solução, seria  implementar duas funções auxiliares, uma para computar a potência (<i>pot</i>) e uma para o
			
 
				+fatorial (<i>fat</i>), a cada passo invocando as funções auxiliares.
			
 
				+Vamos simplificar a condição de parada, fixando a <i>priori</i> o número de termos calculados, digamos <i>NT=10</i>.
			
 
				+<center>
			
 
				+<a name="solucaoruim">
			
 
				+<i>Tab. 1. Uma implementação muito ineficiente para a Série de Taylor que aproxima <i>cosseno</i>.</i>
			
 
				+</a>
			
 
				+<br/>
			
 
				+<table class="tbCodeLinCol">
			
 
				+ <tr class="tbCodeLinColH"><th colspan="2">Algoritmo muito ineficiente para cômputo do cosseno</th></tr>
			
 
				+ <tr><th>C </th> <th>Python</th></tr>
			
 
				+ <tr valign="top"><td><table class="tbCode">
			
 
				+   <tr><td><pre>i = 0;
			
 
				+while (i&lt;2*NT) { <cyan>// Ineficiente! Nao implemente assim!</cyan>
			
 
				+     soma = soma + pot(-1, 2*i) * pot(x, 2*i) / fat(2*i);
			
 
				+     i += 2;
			
 
				+     }</pre></td></tr>
			
 
				+ </table></td>
			
 
				+ <td><table class="tbCode"><pre>i = 0;
			
 
				+while (i&lt;2*NT) : <cyan># Ineficiente! Nao implemente assim!</cyan>
			
 
				+     soma = soma + pot(-1, 2*i) * pot(x, 2*i) / fat(2*i);
			
 
				+     i += 2;
			
 
				+     
			
 
				+  return soma;</pre></td></tr>
			
 
				+   </table></td></tr>
			
 
				+</table></center>
			
 
				+<p>
			
 
				+
			
 
				+<p>
			
 
				+  Testando-se o algoritmo acima, percebe-se rapidamente que o método não é eficiente. Por exemplo, examinando a tabela 1, na qual listamos
			
 
				+  os resultados para vários valores de <i>x</i> empregando o método acima, um método eficiente (vistao abaixo) e a função <i>cosseno</i>
			
 
				+  da biblioteca da linguagem.
			
 
				+  Nota-se que já na segunda linha, para <i>x=0.05</i>, o método ineficiente gera o valor <i>1.0012</i> enquanto o eficiente e a biblioteca
			
 
				+  <i>0.9988</i>, uma diferença nada desprezível.
			
 
				+  Isso vai piorando com o aumento de <i>x</i>, para o último tabelado, <i>x=0.45</i>, a diferença já está em quase <i>0.2</i>!
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+<b>Ineficiência 1</b>.
			
 
				+  Fazendo um rápido exame da solução notamos um primeiro item de ineficiência:
			
 
				+  computar <i>pot(-1, 2*i)</i> a cada passo.
			
 
				+  Isso é completamente desnecessário, pois de um passo ao outro deve-se apenas inverter o sinal, então bastaria usar uma variável
			
 
				+  <tt>sinal</tt>,
			
 
				+  que a cada passo fizesse <tt>sinal = -sinal</tt>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+<b>Ineficiência 2</b>.
			
 
				+  Note que a mesma ineficiência do sinal ocorre com  <tt>pot</tt> e <tt>fat</tt>, pois a cada passo ignora-se que uma potência e um fatorial
			
 
				+  parcial já foi computado, calculando tudo desde o primeiro valor.
			
 
				+  Se ainda não está claro que pode ser melhorado, vamos examinar os passos <tt>k=2</tt> e  <tt>k=3</tt>:
			
 
				+  <br/>
			
 
				+  - <tt>k=2</tt>: computa-se <tt>pot(x, 2*2)=pot(x, 4)</tt> e <tt>fat(2*2)=fat(4)</tt>; e<br/>
			
 
				+  - <tt>k=3</tt>: computa-se <tt>pot(x, 2*3)=pot(x, 6)</tt> e <tt>fat(2*3)=fat(6)</tt>.<br/>
			
 
				+  Mas, se usarmos uma variável <tt>pot1</tt> para manter a potência e <tt>fat1</tt> para manter o fatorial,
			
 
				+  <!--
			
 
				+  <i>x<sup>2k</sup></i> (<tt>pot(x, 2*k)</tt>) e
			
 
				+  <tt>fat1</tt> para manter <i>2k!</i> (<tt>fat(2*k)</tt>),
			
 
				+  -->
			
 
				+  então, ao final do passo <tt>k=2</tt>,
			
 
				+  <tt>pot1</tt> estaria com o valor <i>x<sup>2k</sup>=x<sup>4</sup></i> e <tt>fat1</tt> com o valor <i>2k!=4!=24</i>.
			
 
				+  <br/>
			
 
				+  Portanto, no passo <tt>k=3</tt>, bastaria fazer:
			
 
				+  <center>
			
 
				+    <tt>pot1 = pot1 * x * x</tt> &nbsp; e &nbsp; <tt>fat1 = fat1 * 5 * 6</tt>,
			
 
				+  </center>
			
 
				+  pois dessa forma, conseguiríamos
			
 
				+  <center><!-- &rArr; = implica -->
			
 
				+    <tt>pot1 &larr; pot1 * x * x  &rArr; pot1 &larr; x<sup>4</sup> x<sup>2</sup> = x<sup>6</sup></tt> &nbsp; &nbsp; &nbsp; &nbsp; e
			
 
				+    <br/>
			
 
				+    <tt>fat1 &larr; fat1 * 5 * 6  &rArr; fat1 &larr; 4! * 5 * 6 = 6!</tt>.
			
 
				+  </center>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Outro problema da solução da tabela 1 é que potência e fatorial crescem muito rápido
			
 
				+  (se <i>x &gt; 1</i>, mas se <i>x &lt; 1</i>, então decresce muito rápido).
			
 
				+  Isso também pode resultar ineficiência numérica.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Portanto, esta solução 1 é muito ineficaz, tanto em termos de velocidade quanto de precisão.
			
 
				+  A discussão da razão de sua ineficácia já indica um caminho de melhoria, examinado a seguir.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="ingenuo">
			
 
				+<p class="secao">Uma segunda solução para a função <i>cosseno</i>: ainda ineficaz numericamente</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+Uma solução um pouco melhor, mas numericamente ainda ingênua, seria eliminar a grande ineficiência citada acima, a cada passo
			
 
				+aproveitando a potência e o fatorial anterior.  
			
 
				+Usando como critério de parada que as diferenças entre o cômputo do termo da série seja menor que um dado limiar <i>Lim</i>,
			
 
				+o código pode ficar como o mostrado abaixo. Suporemos a existëncia de uma função que devolve o módulo de um valor "flutuante", de nome <i>valor_absoluto</i>:
			
 
				+<center>
			
 
				+<a name="solucaomedia">
			
 
				+<i>Tab. 2. Uma implementação não tão ineficiente para a Série de Taylor que aproxima <i>cosseno</i>.</i>
			
 
				+</a>
			
 
				+<br/>
			
 
				+<table class="tbCodeLinCol">
			
 
				+ <tr class="tbCodeLinColH"><th colspan="2">Algoritmo ineficiente para cômputo do cosseno</th></tr>
			
 
				+ <tr><th>C </th> <th>Python</th></tr>
			
 
				+ <tr valign="top"><td><table class="tbCode">
			
 
				+  <tr><td><pre><verm>float</verm> cossInef (<verm>float</verm> x) {
			
 
				+  <verm>float</verm> pot = 1, soma = 0;
			
 
				+  <verm>float</verm> termo0 = 2, termo = 1;
			
 
				+  <verm>int</verm> fat = 1, i = 1, sinal = 1;
			
 
				+  while (valor_absoluto(termo0-termo)>Lim) {
			
 
				+     soma = soma + termo;
			
 
				+     pot *= x * x; <cyan>// compute potencia 2i de x</cyan>
			
 
				+     fat *= (i+1) * (i+2); <cyan>// compute fatorial de 2i</cyan>
			
 
				+     termo0 = termo;
			
 
				+     termo = sinal * pot / fat;
			
 
				+     i += 2;
			
 
				+     sinal = -sinal;
			
 
				+     }
			
 
				+  return soma;
			
 
				+  }</pre></td></tr>
			
 
				+ </table></td>
			
 
				+ <td><table class="tbCode"><pre><verm>def</verm> cossInef (x) :
			
 
				+  pot = 1; soma = 0;
			
 
				+  termo0 = 2; termo = 1;
			
 
				+  fat = 1; i = 0; sinal = 1;
			
 
				+  while (valor_absoluto(termo0-termo)>Lim) :
			
 
				+     soma = soma + termo;
			
 
				+     pot *= x * x; <cyan># compute potencia 2i de x</cyan>
			
 
				+     fat *= (i+1) * (i+2); <cyan># compute fatorial de 2i</cyan>
			
 
				+     termo0 = termo;
			
 
				+     termo = sinal * pot / fat;
			
 
				+     i += 2;
			
 
				+     sinal = -sinal;
			
 
				+  return soma;</pre></td></tr>
			
 
				+   </table></td></tr>
			
 
				+</table></center>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Rodando este algoritmo e comparando-o com a implementação interna das linguagens <b>C</b> e <b>Python</b>, mesmo para valores
			
 
				+próximos de zero (como <i>0.1</i>) nota-se uma diferença significativa de <i>0.01</i> (veja a tabela abaixo onde comparamos o algoritmo
			
 
				+acima, sua versão mais eficiente e a implementação interna da linguagem).
			
 
				+Isso indica que o método acima <b>não</b> é eficiente.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Analisando-se o algoritmo, percebe-se que o potencial problema é que a variável <i>termo</i> é resultado da divisão de 2 valores que tem
			
 
				+tem potencial de crescimento enorme (as variáveis <i>pot</i> e <i>fat</i> - com valor <i>x</i> próximo de zero,  <i>pot</i> na verdade
			
 
				+aproxima-se muito rápido é do zero).
			
 
				+<p>
			
 
				+
			
 
				+</p>
			
 
				+Outra observação importante: a diferença entre 2 passos no laço para a variável <i>termo</i> é multiplicar por <i>x * x / (i+1)*(i+2)</i>.
			
 
				+Assim, poderia-se tentar a cada passo multiplicar diretamente por esta "diferença" e não acumular a potência e o fatorial!
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="eficiente">
			
 
				+<p class="secao">Uma solução eficiente para a função <i>cosseno</i></p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+Usando esta ideia produz-se o algoritmo seguinte que é bem mais eficiente. Nele aproveitamos para ilustrar o uso
			
 
				+de medição de tempo de execução tanto em <b>C</b> quanto em <b>Python</b>,
			
 
				+<center>
			
 
				+<a name="solucaoboa">
			
 
				+<i>Tab. 3. Uma implementação bem eficiente para a Série de Taylor que aproxima <i>cosseno</i>.</i>
			
 
				+</a>
			
 
				+<br/>
			
 
				+<table class="tbCodeLinCol">
			
 
				+ <tr class="tbCodeLinColH"><th colspan="2">Algoritmo eficiente para cômputo do cosseno - comparação com o ineficiente e o interno</th></tr>
			
 
				+ <tr><th>C </th> <th>Python</th></tr>
			
 
				+ <tr valign="top"><td><table class="tbCode">
			
 
				+  <tr><td><pre><cyan>// Leo^nidas O. Brandao - 2017/06/19</cyan>
			
 
				+<cyan>// cos(x) = 0! x^0 - x^2 /2! + x^4 /4! - x^6 /6! + x^8 /8! + ...</cyan>
			
 
				+<cyan>//        = 1 - x^2 /2! + x^4 /4! - x^6 /6! + x^8 /8! + ...</cyan>
			
 
				+<cyan>// gcc -lm -o introducao_eficiencia_algoritmos_cosseno introducao_eficiencia_algoritmos_cosseno.c</cyan>
			
 
				+
			
 
				+<incl1>#include</incl1> &lt;stdio.h&gt;
			
 
				+<incl1>#include</incl1> &lt;math.h&gt; <cyan>// cos(x)</cyan>
			
 
				+<incl1>#include</incl1> &lt;time.h&gt; <cyan>// clock_t, clock()</cyan>
			
 
				+
			
 
				+<def>#define</def> Lim 0.001
			
 
				+
			
 
				+<verm>float</verm> valor_absoluto (<verm>float</verm> x) {
			
 
				+  if (x&gt;=0) return x;
			
 
				+  return -x;
			
 
				+  }
			
 
				+
			
 
				+<cyan>// Cosseno implementado de modo ineficiente</cyan>
			
 
				+<verm>float</verm> cossInef (<verm>float</verm> x) { ... } <cyan>// copiar aqui o codigo C do ineficiente acima</cyan>
			
 
				+
			
 
				+<cyan>// Cosseno implementado de modo mais eficiente</cyan>
			
 
				+<verm>float</verm> cossEfic (<verm>float</verm> x) {
			
 
				+  <verm>float</verm> pot = 1, soma = 0;
			
 
				+  <verm>float</verm> termo0 = 2, termo = 1;
			
 
				+  <verm>int</verm> i = 0, sinal = 1;
			
 
				+  while (valor_absoluto(termo0-termo)&gt;Lim) {
			
 
				+     soma = soma + termo;
			
 
				+     termo0 = termo;
			
 
				+     termo *= -1 * x * x / ((i+1) * (i+2)); <cyan>// compute potencia 2i de x e fatorial de 2i</cyan>
			
 
				+     i += 2;
			
 
				+     }
			
 
				+  return soma;
			
 
				+  }
			
 
				+
			
 
				+<verm>int</verm> main (void) {
			
 
				+  <verm>float</verm> x, cosx, auxcI, auxcE;
			
 
				+  <verm>int</verm> i;
			
 
				+  clock_t tempo_inicial = clock(); <cyan>// "dispara o cronometro"...</cyan>
			
 
				+  <verd>printf</verd>("    x | ineficiente | eficiente | math cos(x) | dist inef. | dist efic.\n");
			
 
				+  x = 0.0;
			
 
				+  for (i=0; i&lt;10; i++) {
			
 
				+    cosx = cos(x);
			
 
				+    auxcI = cossInef(x);
			
 
				+    auxcE = cossEfic(x);
			
 
				+    <verd>printf</verd>(" %3.2f | %11.4f | %9.4f | %11.4f | %10.4f | %10.4f\n",
			
 
				+           x, auxcI, auxcE, cosx, valor_absoluto(auxcI-cosx), valor_absoluto(auxcE-cosx));
			
 
				+    x += 0.05;
			
 
				+    }
			
 
				+  clock_t tempo_final = clock();
			
 
				+  <verd>printf</verd>("Tempo em segundos: %f\n", (double)(tempo_final - tempo_inicial) / CLOCKS_PER_SEC);
			
 
				+
			
 
				+  return 1;
			
 
				+  }</pre></td></tr>
			
 
				+ </table></td>
			
 
				+ <td><table class="tbCode"><pre><cyan># Leo^nidas O. Brandao - 2017/06/19</cyan>
			
 
				+<cyan># cos(x) = 0! x^0 - x^2 /2! + x^4 /4! - x^6 /6! + x^8 /8! + ...</cyan>
			
 
				+<cyan>#        = 1 - x^2 /2! + x^4 /4! - x^6 /6! + x^8 /8! + ...</cyan>
			
 
				+
			
 
				+<cyan># Invocar execucao com linha de comando: python introducao_eficiencia_algoritmos_cosseno.py</cyan>
			
 
				+
			
 
				+<incl1>import</incl1> math; <cyan># para cos(x)</cyan>
			
 
				+<incl1>import</incl1> time; <cyan># para tempo 'time.time()'</cyan>
			
 
				+
			
 
				+Lim = 0.001
			
 
				+
			
 
				+<verm>def</verm> valor_absoluto (x) :
			
 
				+  if (x>=0) : return x;
			
 
				+  return -x;
			
 
				+
			
 
				+<cyan># Cosseno implementado de modo mais eficiente</cyan>
			
 
				+<verm>def</verm> cossInef (x) : <cyan># Copiar aqui a implementacao de cosseno ineficiente</cyan>
			
 
				+  ...
			
 
				+		
			
 
				+<cyan># Cosseno implementado de modo mais eficiente</cyan>
			
 
				+<verm>def</verm> cossEfic (x) :
			
 
				+  pot = 1; soma = 0;
			
 
				+  termo0 = 2; termo = 1;
			
 
				+  i = 0; sinal = 1;
			
 
				+  while (valor_absoluto(termo0-termo)>Lim) :
			
 
				+     soma = soma + termo;
			
 
				+     termo0 = termo;
			
 
				+     termo *= -1 * x * x / ((i+1) * (i+2)); <cyan># compute potencia 2i de x e fatorial de 2i</cyan>
			
 
				+     i += 2;
			
 
				+  return soma;
			
 
				+
			
 
				+<verm>def</verm> main () :
			
 
				+  tempo_inicial = time.time(); <cyan># "dispara o cronometro"...</cyan>
			
 
				+  <verd>print</verd>("    x | ineficiente | eficiente | math cos(x) | dist inef. | dist efic.");
			
 
				+  x = 0.0;
			
 
				+  for i in range(0, 10) :
			
 
				+    cosx = math.cos(x);
			
 
				+    auxcI = cossInef(x);
			
 
				+    auxcE = cossEfic(x);
			
 
				+    <verd>print</verd>(" %3.2f | %11.4f | %9.4f | %11.4f | %10.4f | %10.4f" %
			
 
				+         ( x, auxcI, auxcE, cosx, valor_absoluto(auxcI-cosx), valor_absoluto(auxcE-cosx) ));
			
 
				+    x += 0.05;
			
 
				+
			
 
				+  tempo_final = time.time();
			
 
				+  <verd>print</verd>("Tempo em segundos: %f\n" % (tempo_final - tempo_inicial));
			
 
				+
			
 
				+main();</pre></td></tr>
			
 
				+   </table></td></tr>
			
 
				+</table></center>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Experimente rodar em sua máquina o código acima (completanto com o código da função <i>cossInef</i>, implementada na tab. 1).
			
 
				+  Na máquina usada em 2017 para o primeiro teste desse código, tanto rodando <i>C</i> quanto <i>Python</i>, produzem como resultado a tabela abaixo.
			
 
				+  Note que a medida
			
 
				+  que o <i>x</i> se afasta da origem, aparece mais erro, entretanto os erros são consistentemente maiores ao usar
			
 
				+  a implementação ingênua.
			
 
				+
			
 
				+<center>
			
 
				+ <i>Tab. 4. As saídas geradas pelos códigos ineficientes e eficientes (da tabela 3) para aproximar <i>cosseno</i>.</i>
			
 
				+ <pre>    x | ineficiente | eficiente | math cos(x) | dist inef. | dist efic.
			
 
				+ 0.00 |      1.0000 |    1.0000 |      1.0000 |     0.0000 |     0.0000
			
 
				+ 0.05 |      1.0012 |    0.9988 |      0.9988 |     0.0025 |     0.0000
			
 
				+ 0.10 |      1.0050 |    0.9950 |      0.9950 |     0.0100 |     0.0000
			
 
				+ 0.15 |      1.0112 |    0.9888 |      0.9888 |     0.0225 |     0.0000
			
 
				+ 0.20 |      1.0199 |    0.9801 |      0.9801 |     0.0399 |     0.0000
			
 
				+ 0.25 |      1.0311 |    0.9689 |      0.9689 |     0.0622 |     0.0000
			
 
				+ 0.30 |      1.0447 |    0.9553 |      0.9553 |     0.0893 |     0.0000
			
 
				+ 0.35 |      1.0606 |    0.9394 |      0.9394 |     0.1213 |     0.0000
			
 
				+ 0.40 |      1.0789 |    0.9211 |      0.9211 |     0.1579 |     0.0000
			
 
				+ 0.45 |      1.0996 |    0.9004 |      0.9004 |     0.1991 |     0.0000</pre></center>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Os resultados numéricos são os mesmos comparando o executável a partir do código <i>C</i> ou a interpretação do <i>Python</i>,
			
 
				+  Entretanto, os tempos de execução diferem,
			
 
				+  sendo significativamente menores utilizando a versão compilada (compilador <b>Gnu GCC</b>).
			
 
				+  Usando a mesma máquina (um PC com 2 processadores AMD Phenom II rodando Linux/Debian 8.8),
			
 
				+  os menores resultados de tempo de execução (dentre 100 testes) para o executável via <i>C</i> e o interpretado
			
 
				+  <i>Python</i>: <center><pre>
			
 
				+                   C          Python      
			
 
				+Tempo em segundos: 0.000079   0.000220</pre></center>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Em novos testes, desta vez usando um computador de dois núcleos com processador <i>Intel Core i5-6400 CPU @ 2.70GHz</i>,
			
 
				+  com sistema <i>Debian GNU/Linux 9.12</i>, rodando 400 vezes, eliminando-se as linhas com comando de impressão
			
 
				+  (pois as saídas poderiam uniformizar os resultados por serem significativamente mais lentas),
			
 
				+  os resultados numéricos do executável (compilação <i>Gnu GCCC</i>) mostra um bastante superior ao interpretador <i>Python</i>.
			
 
				+  Os tempos médios das 400 rodadas, do menor tempo de execução e do maior tempo, para a versão compilada e interpretada foram
			
 
				+  (em segundos):
			
 
				+  <center><pre>
			
 
				+              C          Python
			
 
				+Tempo medio:  0.000520   0.008276
			
 
				+Tempo minimo: 0.000016   0.000076
			
 
				+Tempo maximo: 0.000945   0.016031</pre></center>
			
 
				+</p>
			
 
				+
			
 
				+<!--
			
 
				+2020/08/13 - /proc/cpuinfo = 2 x Intel(R) Core(TM) i5-6400 CPU @ 2.70GHz
			
 
				+C
			
 
				+-->
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+Este é apenas um resumo para apresentar o assunto de eficiência de algoritmos, seu aprofundamente demanda muito mais tempo.  
			
 
				+Por exemplo, no IME-USP existe um curso (usualmente de segundo ano) cujo objeto de estudo é precisamente
			
 
				+discutir efeciência de algoritmos, o curso
			
 
				+<a href="http://uspdigital.usp.br/jupiterweb/obterDisciplina?sgldis=MAC0122&verdis=2"
			
 
				+   title="ver ementa">MAC0122 - Princípios de Desenvolvimento de Algoritmos</a>.
			
 
				+No programa de Verão do IME-USP temos o curso
			
 
				+<a href="http://www.ime.usp.br/verao/index.php/turmas/apresentacao.php"
			
 
				+   title="ver lista de cursos do ultimo Verao">Tópicos de Programação</a>.
			
 
				+</p>
			
 
				+
			
 
				+  <p class="autoria">
			
 
				+    <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/15: novo formato, pequenas revisões<br/>
			
 
				+    2020/08/13: ampla revisão (introdução nova, com imagem), novo formato;<br/>
			
 
				+    2019/04/24: primeira versão
			
 
				+  </p>
			
 
				+
			
 
				+
			
 
				+</div>
			
--- a/introducao_entrada_saida_dados.html
+++ b/introducao_entrada_saida_dados.html
@@ -0,0 +1,192 @@
 
				+<!--
			
 
				+Introdução à entrada e saída de dados
			
 
				+Prof. Leônidas de Oliveira Brandão
			
 
				+Material didático para apoio aos cursos de Introdução à Programação
			
 
				+Direitos reservados
			
 
				+Pode ser usado mediante citação de autoria (Prof. Leônidas de Oliveira Brandão) e origem (https://www.ime.usp.br/~leo/mac2166/introducao/)
			
 
				+-->
			
 
				+
			
 
				+ <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">
			
 
				+
			
 
				+
			
 
				+<p class="secao">Introdução à entrada e saída de dados</a>
			
 
				+
			
 
				+<!--
			
 
				+importancia
			
 
				+io_simples
			
 
				+ex_io_simples
			
 
				+io_composto
			
 
				+-->
			
 
				+
			
 
				+<a name="algoritmo">
			
 
				+<p class="secao">O que é um algoritmo?</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+Para entender o papel das <i>entradas</i> e <i>saídas</i> de dados é preciso estar claro quem atua sobre estes dados, quer dizer,
			
 
				+como é feito o processamento desses dados.
			
 
				+Quem faz isso é um <b style="color:#0000aa">algoritmo</b>, <i>uma sequência finita de passos, que ao ser aplicado sobre um conjunto
			
 
				+de dados (as <b>entradas</b>), deve produzir sempre as mesmas <b>saídas</b></i>.
			
 
				+Por exemplo, o algoritmo da divisão ao ser aplicado sobre valores fixados <i>a</i> e <i>b</i>, deve
			
 
				+produzir sempre o mesmo valor <i>d</i> (de tal forma que <i>d * b = a</i>).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Por outro lado, um <b style="color:#0000aa">programa</b>, nada mais é que a implementação de um <b>algoritmo</b> em uma linguagem específica
			
 
				+(como as linguagens <i>C</i> ou <i>Python</i>).
			
 
				+Desse modo, para este programa funcionar o <b style="color:#0000aa">usuário</b> (aquele que está executando) deve fornecer um
			
 
				+conjunto de <b style="color:#00aa00">dados de entrada</b>, na ordem adequada (pois <i>a/b</i> geralmente não é o mesmo que <i>b/a</i>),
			
 
				+para que o programa possa ser executado e produzir as <b style="color:#00aa00">saída</b> desejadas.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Por exemplo, para que a implementação de um algoritmo para a divisão de dois números reais seja adequadamente executado,
			
 
				+devem ser fornecidos os dois valores reais. Se o <i>usuário</i> digitar apenas um valor, o programa ficará parado até
			
 
				+que ele digite o segundo valor.
			
 
				+</p>
			
 
				+
			
 
				+<center><img src="img/img_computador_io.png" title="ilustracao processamento entradas x saidas"/>
			
 
				+<br/><i>Fig. 1. Ilustração da existência de um algoritmo que aplicado sobre as entradas produz as respectivas saídas.</i>
			
 
				+</center>
			
 
				+
			
 
				+<!--
			
 
				+https://en.wikipedia.org/wiki/Integer_%28computer_science%29
			
 
				+int = -32,768 to 32,767, from -(2^15) to 2^15-1 
			
 
				+https://en.wikipedia.org/wiki/Single-precision_floating-point_format
			
 
				+float = 32 bits
			
 
				+IEEE 754 single-precision binary floating-point format: binary32
			
 
				+Sign bit: 1 bit ; Exponent width: 8 bits ; Significand precision: 24 bits (23 explicitly stored)
			
 
				+float = 0/1 0.mantissa x 10^e
			
 
				+            24 bits      8
			
 
				+-->
			
 
				+
			
 
				+<a name="importancia">
			
 
				+<p class="secao">Qual a importância da <i>entrada/leitura</i> e da <i>saída/impressão</i> de dados?</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+A grande importância de mecanismos para <i>entrar</i> dados (ou realizar a <i>leitura</i>), para que um programa computacional os
			
 
				+processe, é possibilitar que determinado algoritmo implementado possa atuar sobre esses dados, produzindo resultados personalizados,
			
 
				+no sentido de serem do interesse do usuário.
			
 
				+Por exemplo, um usuário, que é professor, está interessado em saber quais as médias de cada um de seus alunos.
			
 
				+Então o programa implementa um algoritmo que computa as médias dos <i>dados personalizados</i>, que são todas as notas de todos
			
 
				+seus alunos. Esses são os <b style="color:#00aa00">dados de entrada</b>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Por outro lado, o professor precisa receber de alguma os dados que foram gerados, no exemplo, as médias de seus alunos.
			
 
				+Então é preciso haver uma forma de apresentar os <b style="color:#00aa00">dados de saída</b>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Portanto, sem um mecanismo para <i>entradas</i> de dados, um algoritmo não pode ser usado (exceto se for um algoritmo que produz
			
 
				+sempre a mesma coisa, como uma função constante).
			
 
				+De forma análoga, sem um mecanismo <i>saída</i> dos dados de resposta, o algoritmo é inútil.
			
 
				+</p>
			
 
				+
			
 
				+<a name="mecanismos">
			
 
				+<p class="secao">Exemplo de mecanismos para "entradas de dados" e para "saídas de dados"</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+Existem vários mecanismos para <i>entrada</i> e para a <i>saída</i> de dados.
			
 
				+Um dos primeiro exemplo de <i>dispositivo para entrada de dados</i> é o <i>teclado</i>, mas existem outros, como os <i>mouses</i>.
			
 
				+Por exemplo, se o usuário der um "clique" duplo em um ícone associado a um arquivo de texto
			
 
				+<img src="img/icn_editor_101.png" width="30" height="30" title="ícone de arquivo para editor de texto"/>, o sistema gráfico "sabe"
			
 
				+que deve abrir o <i>programa editor de texto</i> e, dentro dele, abrir o referido texto.
			
 
				+Mas se o "clique" for sobre o ícone de um arquivo associado à uma planilha eletrônica
			
 
				+<img src="img/icn_planilha_101.png" width="30" height="30" title="ícone de arquivo para planilha"/>, o sistema gráfico "sabe" que
			
 
				+deve abrir o <i>programa planilha eletrônica</i> e, dentro dele, abrir com os dados daquele aquivo (que, por simplicidade, nos
			
 
				+referimos como uma "planilha").
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Quanto aos mecanismos para <i>saída</i> dos dados processados, o mais comum é a <i>tela</i> (<i>ecrã</i>).
			
 
				+Um outro exemplo interessante de mecanismo de saída são os alto-falantes, eles podem receber dados, produzindo sons.
			
 
				+Para um usuário que for cego, provavelmente este será o meio de saída mais usado.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+
			
 
				+<a name="exemplos">
			
 
				+<p class="secao">Exemplos de códigos em <i>C</i> e em <i>Python</i> com entradas/saídas</p>
			
 
				+</a>
			
 
				+<!-- ./introducao/codigos/testes/intr_entrada_saida.* -->
			
 
				+
			
 
				+<p>
			
 
				+A tabela abaixo apresenta código para computar a média aritmética de valores a serem digitados pelo usuário.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+<center><i>Tab. 1. Exemplo de códigos para entrada e saída de inteiros e "reais"</i><br/>
			
 
				+<table class="tableCd">
			
 
				+ <tr>
			
 
				+ <td></td><td bgcolor="8aaada"><i>C</i>: média de valores</td>
			
 
				+ <td bgcolor="8aaada"><i>Python</i>: média de valores</td></tr>
			
 
				+<tr><td><table class=""><tr class="trCd" valign="top"><td><pre> 1
			
 
				+ 2
			
 
				+ 3
			
 
				+ 4
			
 
				+ 5
			
 
				+ 6
			
 
				+ 7
			
 
				+ 8
			
 
				+ 9
			
 
				+10
			
 
				+11
			
 
				+12</pre></td></tr></table></td>
			
 
				+  <td><table class=""><tr class="trCd" valign="top"><td><pre style="font-size: 0.8em;">//C: computa media
			
 
				+#include <stdio.h>
			
 
				+void main (void) {
			
 
				+int i, n; // declara variaveis
			
 
				+float nota, soma = 0.0; // declara variavel para soma
			
 
				+printf("Digite o numero de notas desse aluno: ");
			
 
				+scanf("%d", &n); // comando para entrada via teclado
			
 
				+for (i=0; i&lt;; i++) {
			
 
				+  printf("Digite valor %d: ", i); scanf("%f", &nota);
			
 
				+  soma = soma + nota; // acumule
			
 
				+  }
			
 
				+printf("A media desse aluno e': %f\n", soma/n);
			
 
				+}
			
 
				+</pre></td></tr></table></td>
			
 
				+<td><table class=""><tr class="trCd" valign="top"><td><pre style="font-size: 0.8em;"># Python: computa media
			
 
				+def main () :
			
 
				+soma = 0.0; # declara variavel para somar
			
 
				+print("Digite o numero de notas desse aluno: ");
			
 
				+n = int(input());
			
 
				+for i in range(n) :
			
 
				+  print("Digite valor %d: " % i);
			
 
				+  soma = soma + float(input()); # acumule
			
 
				+print("A media desse aluno e': %f" % (soma/n));
			
 
				+
			
 
				+main();
			
 
				+
			
 
				+
			
 
				+</pre></td></tr></table></td></tr>
			
 
				+</table></center>
			
 
				+</p>
			
 
				+
			
 
				+<p>  
			
 
				+Neste exemplo existem dois tipos de <i>dados para entrada</i>, um primeiro inteiro (variável <i>n</i> que será usada para
			
 
				+guardar o número de notas que cada "aluno" tem. Depois o <i>usuário</i> deve digitas nas <i>n</i> para o "aluno".
			
 
				+Note que foi necessário usar uma variável para acumular cada nota digitada, a variável <i>soma</i>.
			
 
				+Ao final, basta apresentar como <i>dado de saída</i> a média do referido "aluno".
			
 
				+</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/19: pequenas correções<br/>
			
 
				+    2020/08/07: primeira versão
			
 
				+</p>
			
 
				+
			
 
				+</div>
			
--- a/introducao_estrutura_basica_c_python.html
+++ b/introducao_estrutura_basica_c_python.html
@@ -0,0 +1,288 @@
 
				+
			
 
				+<!--
			
 
				+ Introducao 'a Programacao - desde 2017 - Prof. Leo^nidas de Oliveira Branda~o
			
 
				+ Sobre a estrutura basica de um programa em C ou em Python
			
 
				+ LInE (Laboratory of Informatics in Education) - http://www.usp.br/line
			
 
				+ IME - USP
			
 
				+ Material didatico
			
 
				+ Pode usar livrevemente este material para fins nao comerciais, devendo sempre fazer referencia `a autoria.
			
 
				+ Sugestões/apontamento são bem vindos: leo@ime.usp.br (favor indicar no assunto "material de introducao 'a programacao")
			
 
				+ Autor: Prof. Leo^nidas de Oliveira Branda~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'>
			
 
				+<div class="pagina">
			
 
				+
			
 
				+<!--
			
 
				+<center><p>[
			
 
				+  <a href="#" title=""></a> &nbsp; | &nbsp;
			
 
				+  <a href="#memoria" title=""></a> &nbsp; &nbsp;
			
 
				+ ]</p>
			
 
				+</center>
			
 
				+-->
			
 
				+
			
 
				+<p class="secao">Sobre a estrutura básica de um programa em <i>C</i> ou em <i>Python</i>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Antes de apresentar a estrutura dos programas, segue a primeira dica para um "bom código": utilizar "indentação" e comentários adequados.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p class="secao">1. Comentários em meio ao código e o uso adequado de "indentação".</p>
			
 
				+
			
 
				+<p>
			
 
				+  Toda linguagem de programação apresenta o conceito de <b style="color:#0000aa">comentário</b>, que serve para indicar ao
			
 
				+  compilador (<i>C</i>) ou ao interpretador (<i>Python</i>) que o texto em <i>comentário</i>
			
 
				+  <b style="color:#aa0000">não</b> deve ser <i>compilado</i> ou <i>interpretado</i>, respectivamente.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Geralmente a linguagem oferece dois modos para comentários, um para <i>comentar apenas o trecho final de uma linha</i> e outro para
			
 
				+  <i>comentar várias linhas</i>. Os comentário do primeiro tipo em <i>C</i> e em <i>Python</i> usem os símbolos
			
 
				+  <tt><cyan>// ignore o restante desta linha</cyan></tt> e <tt><cyan># ignore o restante desta linha</cyan></tt>, respectivamente.
			
 
				+  <br/>
			
 
				+  Já os comentários maiores, que sugiro usar <b>apenas</b> nas primeiras linhas de seu código (assim, se houve necessidade de comentar
			
 
				+  um bloco código poderá fazê-lo, pois <b style="color:#aa0000">não</b> funcionar comentário dentro de comentário), em
			
 
				+  em <i>C</i> e em <i>Python</i> são respectivamente:
			
 
				+  <br/>
			
 
				+  <tt><cyan>/* Ignore todas as linhas entre estas marcas ... */</cyan></tt>
			
 
				+  <br/>
			
 
				+  <tt><cyan>""" Ignore todas as linhas entre estas marcas ... """</cyan></tt>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Vale a pena ressaltar a impossibilidade "comentários dentro de comentário" comparando com o princípio matemática das chaves e parênteses.
			
 
				+  Quer dizer, uma expressão matemática permite "parênteses dentro de parênteses", como em "<tt>(2 * (3+4))</tt>", mas
			
 
				+  nem <i>C</i> e nem <i>Python</i> permite que se use comentário dentro de comentário. Exemplifico o erro que resultaria.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p class="subsecao">1.1 Comentários dentro de comentário <b style="color:#aa0000">não</b> é possível em <i>Python</i>.</p>
			
 
				+
			
 
				+<p>
			
 
				+  Em <i>Python</i> o "comentários em várias linhas" é iniciado com e fechado com a sequência de 3 aspas dupla '<tt>"""</tt>'.
			
 
				+  Assim, se o programador colocar em seu código <i>Python</i> as próximas 4 linhas:
			
 
				+</p> <!-- " -->
			
 
				+
			
 
				+<p><center><!-- codigos/introducao_estrutura_bas.py -->
			
 
				+<pre style="text-align:left" title="Ilustração de um terminal com as saídas para o código 1">
			
 
				+<pre><cyan>"""
			
 
				+ Esta e' uma tentativa de colocar comentario dentro de comentario, mas NAO funciona!
			
 
				+ """ Ao encontrar o proximo fecha, ele correspondera' ao primeiro abre, """</cyan>
			
 
				+ logo esta linha NAO mais sera' comentario resultando erro de compilacao!
			
 
				+ Assim, comentarios encaixados NAO sao permitidos!
			
 
				+"""</pre><i>Cód. 1. Código ilustrando o erro ao supor que existe comentários aninhados em <i>Python</i>.</i>
			
 
				+</center></p>
			
 
				+
			
 
				+<p>
			
 
				+  Ao tentar fazer o computador interpretar o código acima, o interpretador indicará o erro, como indicado na figura 1.
			
 
				+  Experimente em seu interpretador.
			
 
				+</p>
			
 
				+
			
 
				+<p><center>
			
 
				+<div class="imgTermTopo">
			
 
				+<pre style="text-align:left" title="Ilustração de um terminal com as saídas para o código 1">
			
 
				+
			
 
				+  $ python py_teste_comentario.py
			
 
				+  File "py_teste_comentario.py", line 4
			
 
				+  """ Ao encontrar o proximo fecha, ele correspondera' ao primeiro abre, """
			
 
				+       ^</pre>
			
 
				+</div>
			
 
				+<i>Fig. 1. Ilustração do erro ao supor que existe comentários aninhados em <i>Python</i>.</i>
			
 
				+</center></p>
			
 
				+
			
 
				+<p>
			
 
				+  A razão é que o <b style="color:#0000aa">aninhamento</b> de comentários <b style="color:#aa0000">não</b> existe na
			
 
				+  configuração padrão <i>Python</i>, assim as 3 aspas da linha 2 fecha o comentário aberto na linha 1, ou seja,
			
 
				+  <b style="color:#0000aa">não</b> abre um novo bloco de comentários.
			
 
				+</p>
			
 
				+
			
 
				+<p>  
			
 
				+  Por esta razão recomendo que em seus programas utilize comentários em várias linhas apenas no início do programa (para por exemplo,
			
 
				+  identificar-se e explicá-lo). Deste modo, fica fácil isolar um bloco grande de seu código (como comentário), o que é útil para
			
 
				+  encontrar erros de sintaxe (mais simples) ou de semântica.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+
			
 
				+<p class="subsecao">1.2 Comentários dentro de comentário <b style="color:#aa0000">não</b> é possível em <i>C</i>.</p>
			
 
				+
			
 
				+<p>
			
 
				+  Em <i>C</i> o "comentários em várias linhas" é iniciado com a dupla de caracteres '<tt>/*</tt>' e fechado com a dupla '<tt>*/</tt>'.
			
 
				+  Assim, se o programador colocar em seu código <i>C</i> as próximas 4 linhas
			
 
				+</p> <!--  -->
			
 
				+
			
 
				+<p><center><!-- codigos/introducao_estrutura_bas.c -->
			
 
				+<pre style="text-align:left" title="Ilustração de um terminal com as saídas para o código 1">
			
 
				+<pre><cyan>/* Esta e' uma tentativa de colocar comentario dentro de comentario, mas NAO funciona!
			
 
				+ /* Ao encontrar o proximo fecha, ele correspondera' ao primeiro abre, */</cyan>
			
 
				+ logo esta linha NAO mais sera' comentario resultando erro de compilacao!
			
 
				+ Assim, comentarios encaixados NAO sao permitidos!
			
 
				+*/</pre><i>Cód. 2. Código ilustrando o erro ao supor que existe comentários aninhados em <i>C</i>.</i>
			
 
				+</center></p>
			
 
				+
			
 
				+<p>
			
 
				+  Ao tentar fazer o computador interpretar o código acima, o interpretador indicará o erro, como indicado na figura 2.
			
 
				+  Experimente em seu compilador.
			
 
				+</p>
			
 
				+
			
 
				+<p><center>
			
 
				+<div class="imgTermTopo">
			
 
				+<pre style="text-align:left" title="Ilustração de um terminal com as saídas para o código 2">
			
 
				+
			
 
				+$ gcc -o introducao_estrutura_bas.o introducao_estrutura_bas.c
			
 
				+introducao_estrutura_bas.c:7:2: error: unknown type name ‘logo’
			
 
				+  logo esta linha NAO mais sera' comentario resultando erro de compilacao!
			
 
				+  ^</pre>
			
 
				+</div>
			
 
				+<i>Fig. 2. Ilustração do erro ao supor que existe comentários aninhados em <i>Python</i>.</i>
			
 
				+</center></p>
			
 
				+
			
 
				+<p>
			
 
				+  A razão é que o <b style="color:#0000aa">aninhamento</b> de comentários <b style="color:#aa0000">não</b> existe na
			
 
				+  configuração padrão <i>Python</i>, assim as 3 aspas da linha 2 fecha o comentário aberto na linha 1, ou seja,
			
 
				+  <b style="color:#0000aa">não</b> abre um novo bloco de comentários.
			
 
				+</p>
			
 
				+
			
 
				+<p>  
			
 
				+  Por esta razão recomendo que em seus programas utilize comentários em várias linhas apenas no início do programa (para por exemplo,
			
 
				+  identificar-se e explicá-lo). Deste modo, fica fácil isolar um bloco grande de seu código (como comentário), o que é útil para
			
 
				+  encontrar erros de sintaxe (mais simples) ou de semântica.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p class="secao">2. Uso adequado de "indentação".</p>
			
 
				+
			
 
				+<p>
			
 
				+  Entenda-se por <b style="color:#0000aa">"indentação"</b> o deslocamento horizontal de trechos de código, o que é usado para indicar claramente uma subordinação de
			
 
				+  comandos (ou <b style="color:#0000aa">aninhamento</b>). Por exemplo, se um comando de seleção "<tt>se</tt>" tiver dois comandos subordinados à ele, pode-se usar 2
			
 
				+  espaços em branco a mais nesses comandos subordinados. Veja este exemplo uma linguagem semelhante ao Português:
			
 
				+  <pre> se (x>0)<br/>   S = S+1;<br/>   imprima(S);</pre>
			
 
				+  Para evitar que meus códigos fiquem muito "longos" (não cabendo uma linha inteira na tela), eu utilizo apenas 2 espaços para indicar subordinação (como no
			
 
				+  extrato de código acima).
			
 
				+
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Assim, se determinado comando começa na coluna <i>X</i> ("indentação" de <i>X</i> espaços), então todos os comandos subordinados a ele
			
 
				+  terão deslocamento de ao menos <i>X+2</i> espaços em branco. Digo "ao menos", pois dentre estes comandos pode existir outras subordinações.
			
 
				+  Isso é ilustrado no exemplo abaixo, no qual os comandos das linhas 2 até 5 estão subordinados ao "<tt>repita enquanto</tt>", tendo
			
 
				+  portanto deslocamento
			
 
				+  <i>X+2</i> ou mais espaços, mas o comando "<tt>imprima</tt>" da linha 4 tem deslocamento <i>X+4</i>, pois ele está subordinado ao "<tt>se</tt>"
			
 
				+  que já tinha deslocamento <i>X+2</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  A seguir um exemplo com mais linhas e mais subordinações. Nele será usado uma linguagem parecida com o Português, que por isso pode ser
			
 
				+  denominada <b style="color:#0000aa">Portugol</b>:
			
 
				+</p>
			
 
				+
			
 
				+<pre>Linha  Código
			
 
				+1      repita enquanto (cont &lt; N)
			
 
				+2         imprima(cont)
			
 
				+3         se ("cont for par") <cyan>// precisa implementar esta condicao, como "cont % 2 == 0"</cyan>
			
 
				+4           imprima(cont)
			
 
				+5         incremente(cont)</pre>
			
 
				+<p>
			
 
				+  Note que no código acima, os comandos "<tt>imprima(cont)</tt>" e "<tt>incremente(cont)</tt>" estão deslocados 2 espaços à direita para
			
 
				+  indicar que ambos estão sobordinados ao comando de repetição "<tt>repita enquanto (cont &lt; N)</tt>" (repetição será explicado em outra aula).
			
 
				+  Já o comando da linha 4 está subordinado ao comando da linha 3 ("<tt>se</tt>"), por isso o uso do deslocamento adicional de
			
 
				+  dois espaços em branco.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p class="secao">3. Estrutura básica de um programa em <i>C</i>.</p>
			
 
				+
			
 
				+<p>
			
 
				+  Abaixo ilustro a estrutura básica de um programa em <i>C</i>, utilizando indentação para deixar o código mais claro, o que é importante
			
 
				+  para você detectar problemas em seu código e essencial para receber uma boa nota por parte do monitor que analisará seu programa.
			
 
				+</p>
			
 
				+<pre style="font-size:0.8em;"><cyan>/*
			
 
				+ O programa abaixo serve apenas para ilustrar a estrutura basica de um programa em <i>C</i>.
			
 
				+ Neste primeiro exemplo existe:
			
 
				+ - Carrega o cabecalho para os comandos (ou funcoes) para entrada e saida de dados: biblioteca "stdio.h"
			
 
				+ - Definicao do codigo principal (por onde devera ser iniciada a execucao de seu codigo): funcao "main"
			
 
				+ - Comandos para leitura e para saida de dados: respectivamente, "scanf" e "printf"
			
 
				+   * Para declarar 2 variaveis que armazenarao valores inteiros, utilizar o "int" como abaixo
			
 
				+   * Para ler valores (usuario digita) e armazenar na variavel usando a funcao predefinida "scanf"
			
 
				+   * O "scanf" deve sempre 2 grupos, o primeiro entre aspas e o segundo uma lista de variaveis precedias do '&amp;'
			
 
				+     dentro das aspas, '%d' indica que o valor lido sera' tratado como inteiro
			
 
				+     na lista de variaveis, o uso de '&amp;' e' obrigatorio para conseguir guardar o valor lido corretamente na variavel
			
 
				+     (experimente eliminar um dos '&amp;' no programa abaixo e veja o que ocorre)
			
 
				+   * O "printf" adota a mesma estrutura do "scanf" com os 2 blocos, mas nele NAO usar o '&amp;' antes da variavel,
			
 
				+     senao sera' impresso o endereco de memoria da variavel, nao o valor que ela guarda)
			
 
				+     O '\n' e' serve para que, apos imprimir "n1+n2", "pular" de linha (ou seja, proxima impressao inicia-se na seguinte)
			
 
				+   * Os formatadores (como '%d') serao explicados noutra aula, eles podem ser usados para imprimir tabelas
			
 
				+*/</cyan>
			
 
				+
			
 
				+<incl1>#include</incl1> &lt;stdio.h&gt; <cyan>// coloque esta linha em TODOS seus programas <i>C</i> (a mesno que ele NAO tenha nem entrada, nem saidas!)</cyan>
			
 
				+<verm>int</verm> main (<verm>void</verm>) {  <cyan>// obrigatorio em todo programa <i>C</i> (noutra aula explicamos por que usar "void" aqui)</cyan>
			
 
				+  <verm>int</verm> n1, n2;               <cyan>// declarando o uso de 2 variaves para armazenar apenas valores inteiros</cyan>
			
 
				+  <verd>scanf</verd>("%d %d", &amp;n1, &amp;n2); <cyan>// leia 2 valores inteiros, guarde o primeiro em n1 e o outro em n2 (depois veremos '%d' e o '&amp;')</cyan>
			
 
				+  <verd>printf</verd>("%d\n", n1+n2);    <cyan>// imprima um unico valor (soma dos valores guardados em n1 e em n2)</cyan>
			
 
				+  }</stdio.h></pre>
			
 
				+
			
 
				+
			
 
				+<p class="secao">4. Estrutura básica de um programa em <i>Python</i>.</p>
			
 
				+
			
 
				+<p>
			
 
				+  Abaixo ilustro a estrutura básica de um programa em <i>Python</i>, utilizando indentação que deixa o código mais claro e é
			
 
				+  <b style="color:#00aa00">obrigatório</b> em <i>Python</i>.
			
 
				+  <br/>
			
 
				+  Para tentar, desde cedo, indicar aos aprendizes de programação em <i>Python</i> que procurem organizar seus código,
			
 
				+  sugerimos usar sempre uma função principal, que nominaremos como <tt style="color:#00aa00">main</tt>.
			
 
				+  Sugerimos que sempre que implementar uma função, faça isso no início de seu código, deixando qualquer declaração de função
			
 
				+  antes (acima) do trecho que a invoque.
			
 
				+</p>
			
 
				+<pre style="font-size:0.8em;"><cyan>"""<!-- " -->
			
 
				+ O programa abaixo serve apenas para ilustrar a estrutura basica de um programa em Python.
			
 
				+ Neste primeiro exemplo existe:
			
 
				+ - Definicao de uma funcao de nome "main": nao e' obrigatorio em Python, mas usaremos desta forma
			
 
				+ - Comandos para leitura e para saida de dados: respectivamente, "input" e "print"
			
 
				+   * Para declarar 2 variaveis que armazenarao valores inteiros, utilizar o "int" como abaixo
			
 
				+   * Para ler valores (usuario digita) e armazenar na variavel usando a funcao predefinida "input"
			
 
				+   * O "input" pode ter um argumento que e' uma mensagem (como 'input("Digite: ")'), mas nao usaremos devido
			
 
				+     ao avaliador automatico (voce nao vera as mensagens e elas poderiam provocar erro na avaliacao)
			
 
				+   * A funcao "int(...)" deve ter como parametro uma expressao numerica, devolvendo a parte inteira dela
			
 
				+     por exemplo, 'int(3.5+2)' devolvera' o valor inteiro 5
			
 
				+   * O "print" serve para imprimir respostas e pode ter como parametros um sequencia de "frase" e expressoes,
			
 
				+     por exemplo, supondo que as variaveis num1 e num2 guardem 2 e 3, o comando
			
 
				+         print(num1,"+", num2, "=", num1+num2);
			
 
				+     No Python 3 resultaria na seguinte impressao na tela
			
 
				+         2 + 3 = 5
			
 
				+     Mas no Python 2, resultaria em uma impressao "menos" elegante
			
 
				+         (2, '+', 3, '=', 5)
			
 
				+   * Existe um modo de impressao mais poderoso, que funciona da mesma forma tanto no Python 2 quanto no 3,:
			
 
				+         print("%d + %d = %d" % (num1,num2,(num1+num2)));
			
 
				+     que sempre resulta na primeira forma acima: 2 + 3 = 5
			
 
				+     Em outra aula sera' explicado o uso de formatadores (como o '%d') para construcao de tabelas.
			
 
				+"""</cyan><!-- " -->
			
 
				+<verm>def</verm> main () : <cyan># Pode usar outro nome que nao "main", mas convencionaremos "main"</cyan>
			
 
				+  num1 = int(<verd>input</verd>())
			
 
				+  num2 = int(<verd>input</verd>())
			
 
				+  <verd>print</verd>(num1+num2)
			
 
				+<cyan># note a indentacao dessa linha =&gt; NAO pertence ao bloco de comandos da funcao "main"</cyan>
			
 
				+main()</pre>
			
 
				+
			
 
				+<p class="autoria">
			
 
				+ <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/19: várias pequenas correções, nova seção 1.2 para <i>C</i> (existia uma correspondente apenas para <i>Python</i>)<br/>
			
 
				+  2020/08/14: novo formato, pequenas revisões<br/>
			
 
				+  2020/03/31: detalhes<br/>
			
 
				+  2017/08/08: pesquenos acertos<br/>
			
 
				+  2017/03/20: segunda, 20 Mar 2017, 17:02<br/>
			
 
				+</p>
			
 
				+
			
 
				+</div>
			
--- a/introducao_float.html
+++ b/introducao_float.html
@@ -0,0 +1,329 @@
 
				+<!--
			
 
				+ Introdução à Programação - 2017 - Prof. Leoônidas de Oliveira Brandão
			
 
				+ Introdução aos números em ponto flutuantes
			
 
				+ 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
			
 
				+
			
 
				+ href="#" id="url1" onclick="trocaPagina('introducao_inteiros.html')"
			
 
				+
			
 
				+-->
			
 
				+
			
 
				+  <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">
			
 
				+
			
 
				+
			
 
				+<p class="secao">Introdução aos números em ponto flutuantes</p>
			
 
				+
			
 
				+<p>
			
 
				+  Nesta seção examinaremos resumidamente como o computador representa números reais.
			
 
				+  A seção seguinte foi redigida para aqueles que desejam conhecer mais, estudando-a pode-se compreender a matemática associada
			
 
				+  ao conteito de representação de números em um computador digital e a razão do termo <b>ponto flutuante</b>.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+  Normalmente deve-se utilizar um número fixo de <i>bits</i> para representar cada número.
			
 
				+  Por exemplo, se determinado computador usar apenas 2 <i>bytes</i> (ou 16 <i>bits</i>) para
			
 
				+  representar um real e convencionar-se que o primeiro <i>byte</i> armazena a parte inteira e o segundo
			
 
				+  <i>byte</i> a parte decimal, teríamos uma variabilidade pequena de números.
			
 
				+  Como visto no texto
			
 
				+  <!-- a href="introducao_inteiros.html" title="examinar o texto sobre inteiros">introdutório sobre inteiros</a -->
			
 
				+  <a href="#" onclick="trocaPagina('introducao_inteiros.html')" title="examinar o texto sobre inteiros">introdutório sobre inteiros</a>,
			
 
				+  com 8 <i>bits</i>, teríamos (simplificadamente) desde o <i>11111111</i> (primeiro <i>bit</i> indica negativo) até o
			
 
				+  <i>01111111</i>, que em decimal seriam desde <i>-127</i> até o <i>127</i>, pois
			
 
				+  <center>
			
 
				+    <i>
			
 
				+      1111111<sub>2</sub> = 
			
 
				+      2<sup>7</sup> + 2<sup>6</sup> + 2<sup>5</sup> + 2<sup>4</sup> + 2<sup>3</sup> + 2<sup>2</sup> + 2<sup>1</sup> + 2<sup>0</sup> =
			
 
				+      128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255 &nbsp; &nbsp; (1)
			
 
				+    </i>
			
 
				+  </center>    
			
 
				+  <!-- 
			
 
				+  na verdade, usando a técnica prática de <i>complemento de dois</i>, iria desde <i>-128</i> até o <i>127</i>
			
 
				+  -->
			
 
				+</p>
			
 
				+
			
 
				+<center><p>[
			
 
				+  <a href="#pontofixo" title="Estudar este outro modelo de representação de real para entender a razão do uso de ponto flutuante">Ponto fixo</a> | 
			
 
				+  <a href="#pontoflutuante" title="Estudar os fundamentos do uso de ponto flutuante para representar reais">Ponto flutuante (PF)</a> | 
			
 
				+  <a href="#pontoflutuanteSimples" title="se estiver interessado em uma explicação super simplificada, começe por aqui">PF super simplificado</a> | 
			
 
				+  <a href="#exemplo" title="Um exmplo simplificado da representação em ponto flutuante">Exemplo</a> | 
			
 
				+  <a href="#erro" title="Erros numéricos devido à representação em ponto flutuante">Erros</a> |
			
 
				+  <a href="#io" title="Exemplos para impressões mais interessantes de ponto flutuante">Entrada/saída</a></a>
			
 
				+ ]</p>
			
 
				+</center>
			
 
				+
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+<a name="pontofixo"></a>
			
 
				+</p>
			
 
				+<span style="color: #0055AA">Um primeiro modelo (ineficiente) para representar valores reais: ponto fixo</span>
			
 
				+
			
 
				+<p>
			
 
				+  Para apresentar o conceito que interessa, de <i>ponto flutuante</i>, apresentarei sua contra-parte, como seria uma representação em <b>ponto fixo</b>.
			
 
				+  Vamos continuar usando 2 <i>bytes</i> (logo 16 <i>bits</i>) e considerar 3 agrupamentos:
			
 
				+  P1. o primeiro <i>bit</i> para representar o sinal do número (<i>s=0</i> para positivo e <i>s=1</i> para negativo);
			
 
				+  P2. os próximos 7 como a parte "decimal" (após vírgula decimal); e
			
 
				+  P3. os últimos 8 <i>bits</i> para o valor inteiro do número.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Assim, para obter o maior valor positivo que poderia ser representado nesta notação, deveríamos deixar o primeiro <i>bit</i> em zero
			
 
				+  (para ser positivo) e todos os seguintes "ligados": <tt>0 1111111 11111111</tt> (deixei espaço em branco para indicar os 3 agrupamentos).
			
 
				+  <br/>
			
 
				+  Assim, a parte "decimal" P2 (<tt>1111111</tt>) corresponde em decimal:
			
 
				+  <center>
			
 
				+    <i>2<sup>-1</sup> + 2<sup>-2</sup> + 2<sup>-3</sup> + 2<sup>-4</sup> + 2<sup>-5</sup> + 2<sup>-6</sup> + 2<sup>-7</sup> =
			
 
				+      0.5 + 0.25 + 0.125 + 0.0625 + 0.03125 + 0.015625 + 0.007812 = 0.992188</i> &nbsp; &nbsp; (2)
			
 
				+  </center><br/>
			
 
				+
			
 
				+  Portanto o maior positivo, convertendo para decimal, seria a soma de (1) e (2): &nbsp; <i>255.992188</i>. Desse modo, em <b>ponto fixo</b>:
			
 
				+  <br/>
			
 
				+  <center>
			
 
				+   <i>Tab. 1. Maior e menor positivo que pode-se obter com a representação em <i>ponto fixo</i>
			
 
				+   <br/>
			
 
				+   <table><tr><td>
			
 
				+   &nbsp; &nbsp; &nbsp; - maior valor positivo em binário <tt>00111111 01111111<sub>2</sub></tt> = <i>255.992188</i> em decimal;<br/>
			
 
				+   &nbsp; &nbsp; &nbsp; - menor valor estritamente positivo em binário <tt>00000001 00000000<sub>2</sub></tt> = <i>0.007812</i> em decimal.
			
 
				+   </td></tr></table>
			
 
				+  </center>
			
 
				+</p>
			
 
				+   
			
 
				+<p>
			
 
				+<a name="pontoflutuante"></a>
			
 
				+<span style="color: #0055AA">Um modelo de representação para real mais eficiente: ponto flutuante</span>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Uma alternativa mais eficiente e amplamente utilizada na prática é a representação em <b style="color: #0000aa;">ponto flutuante</b>.
			
 
				+  Nessa representação também quebramos o número em três agrupamentos, a primeira sendo o <b>sinal</b> <i>s</i>, a segunda
			
 
				+  o <b style="color: #0000aa;">expoente</b> <i>e</i>
			
 
				+  e a terceira sendo <b style="color: #0000aa;">mantissa</b> <i>m</i>, assim o valor do número seria <i>s x m x b<sup>e</sup></i>.
			
 
				+  Se a mantissa tiver <i>p</i> dígitos, o número é:
			
 
				+  <tt>s x d<sub>0</sub>d<sub>1</sub>...d<sub>p-1</sub> x b<sup>e</sup></tt>.
			
 
				+</p>
			
 
				+
			
 
				+<p><center>
			
 
				+ <img src="img/img_real_ponto_fixo.png" title="Imagem representando a memória com representação de ponto fixo"/>
			
 
				+ <br/>
			
 
				+ <i>Fig. 1. Representação em memória para <i>ponto fixo</i> para representar reais, com 7 <i>bits</i> de expoente e 8 <i>bits</i> para mantissa.
			
 
				+</i>
			
 
				+</center></p>
			
 
				+
			
 
				+<p>
			
 
				+  Assim, nota-se que a diferença entre a representações em <i>ponto flutuante</i> e em <i>ponto fixo</i> é o tratamento do segundo agrupamento.
			
 
				+  Para poder comparar ambas as representações, vamos novamente supor um computador com reais usando apenas 2 <i>bytes</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Desse modo, o <i>maior real positivo</i> nesse <i>ponto flutuante</i> é obtido usando a maior potência e maior mantissa possiveis, respectivamente
			
 
				+  <i>0111111</i> e <i>11111111</i>, que em decimal são,
			
 
				+  <center>
			
 
				+    2<sup>6</sup> + 2<sup>5</sup> + 2<sup>4</sup> + 2<sup>3</sup> + 2<sup>2</sup> + 2<sup>1</sup> + 2<sup>0</sup> =
			
 
				+    64 + 32 + 16 + 8 + 4 + 2 + 1 = 127 &nbsp; &nbsp; (3)
			
 
				+    <br/>    
			
 
				+    2<sup>8</sup> + 2<sup>7</sup> + 2<sup>6</sup> + 2<sup>5</sup> + 2<sup>4</sup> + 2<sup>3</sup> + 2<sup>2</sup> + 2<sup>1</sup> + 2<sup>0</sup> =
			
 
				+    256 + 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 511 &nbsp; &nbsp; (4)
			
 
				+  </center>
			
 
				+  <br/>
			
 
				+  Portanto, o <i>maior real positivo</i> nesse <i>ponto flutuante</i> é <i>511 x 2<sup>127</sup></i>, um número gigantesto
			
 
				+  (maior que <i title="170 141 183 000 000 002 920 328 542 032 742 055 936.0">1.70141183 x 10<sup>38</sup></i>).
			
 
				+  <!--
			
 
				+               2^127 = 170 141 183 460 469 231 731 687 303 715 884 105 728
			
 
				+  1.70141183 * 10^38 = 170 141 183 000 000 002 920 328 542 032 742 055 936.000000
			
 
				+  1.70141184 * 10^38 = 170 141 183 999 999 980 188 862 898 952 269 201 408.000000
			
 
				+  -->
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  De forma análoga, podemos computar o <i>menor valor estritamente positivo</i> que conseguimos com essa representação.
			
 
				+  Como são 7 <i>bits</i> para expoente e 8 <i>bits</i> para a mantissa, devemos pegar no agrupamento P2 a sequência
			
 
				+  <i>1111111</i> (maior potência negativa possível) e no agrupamento P3 o menor valor positivo, que seja maior que zero, portanto <i>00000001</i>.
			
 
				+  Convertendo <i title="-2^6">1111111</i> para decimal, temos o valor <i>-64</i>, logo o menor positivo é:
			
 
				+  <i>2<sup>-64</sup></i> que é aproximadamente <i>5.42101086243e-20</i> (tremendamente pequeno).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Portanto o maior positivo e o menor , convertendo para decimal, seria a soma de (1) e (2): &nbsp; <i>255.992188</i>. Desse modo, em <b>ponto fixo</b>:
			
 
				+  <center>
			
 
				+   <i>Tab. 2. Maior e menor positivo que pode-se obter com a representação em <i>ponto flutuante</i>
			
 
				+   <br/>
			
 
				+   <table><tr><td>
			
 
				+   &nbsp; &nbsp; &nbsp; - maior valor positivo em binário <tt>00111111 01111111<sub>2</sub></tt> > <i>1.70141183 * 10<sup>38</sup></i> em decimal;<br/>
			
 
				+   &nbsp; &nbsp; &nbsp; - menor valor estritamente positivo em binário <tt>1111111 00000001<sub>2</sub></tt> ~=
			
 
				+                          <i title="notação científica: 3e-20 equivale a 3*(2.7183^-20)">5.42101086243e-20</i> em decimal.
			
 
				+   </td></tr></table>
			
 
				+  </center>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Comparando os resultados de <i>ponto flutuante</i> com <i>ponto fixo</i>, tabelas 1 e 2, percebemo que
			
 
				+  <i>ponto flutuante</i> produz resultados muito melhores em termos de capacidade de "simular" os números reais.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+<a name="pontoflutuantesimples"><span style="color: #0050A0">Representação em ponto flutuante</span></a>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Esta técnica de representação é a mais utilizada nos computadores, ela utiliza um <em>bit</em> para sinal,
			
 
				+  uma quantidade pequena de <em>bits</em> para o expoente e uma quantidade maior de <em>bits</em> para a parte "principal" do
			
 
				+  número. Em um dos padrões de representação (IEEE 754) o número é representado com 11 <em>bits</em> para o expoente e
			
 
				+  52 <em>bits</em> para a mantissa.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+<a name="exemplo"><span style="color: #0050A0">Exemplo de representação em ponto flutuante</span></a>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Para ilustrar o funcionamento de ponto flutuante, suponha um computador que use representação em decimal
			
 
				+  (os computadores na verdade usam base <i>binária</i>), tendo apenas 3 dígitos para mantissa e o expoente sendo de <i>-4</i> até <i>-4</i>, assim
			
 
				+  teríamos <tt>p=3</tt> e <tt>-4<u><</u>e<u><</u>4</tt>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Deste modo, o maior valor real que pode ser representado seria o <tt>999000</tt>, pois tomando a maior mantissa e maior
			
 
				+  expoente, teríamos <tt>10<sup>3</sup> x 999 = 999000</tt>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Já o menor valor estritamente positivo que conseguiríamos seria o <tt>0.001</tt>, pois tomando a menor mantissa positiva e menor expoente possível (-3),
			
 
				+  teríamos <tt>10<sup>-3</sup> x 1 = 0.001</tt>.
			
 
				+</p>
			
 
				+        
			
 
				+<p>
			
 
				+  Desse modo, nesse computador simples, a variação de números "reais" que poderiam ser representados nesse computador, seria:
			
 
				+  <center>
			
 
				+   <i>Tab. 3. Maior e menor positivo que pode-se obter com a representação em <i>ponto flutuante</i> em decimal.
			
 
				+   <br/>
			
 
				+   <table><tr><td>
			
 
				+    &nbsp; &nbsp; &nbsp; - maior valor positivo: <i>999 x 10<sup>3</sup> = 999000<i>;<br/>
			
 
				+    &nbsp; &nbsp; &nbsp; - menor valor estritamente positivo: <i>1 x 10<sup>-3</sup> = 0.001<i>.
			
 
				+   </td></tr></table>
			
 
				+  </center>
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+<a name="erro"><span style="color: #0050A0">Erros numéricos</span></a>
			
 
				+</p>
			
 
				+
			
 
				+<!--
			
 
				+que corresponde ao decimal <i>31=2<sup>5</sup>-1</i>, portanto o menor real positivo
			
 
				+seria <i>1 x 10<sup>-31</sup></i> que é um número muito menor que o <i>1/255</i> da representação em <i>ponto fixo</i>.
			
 
				+-->
			
 
				+
			
 
				+<p>
			
 
				+A primeira questão que aparece ao tratar números não inteiros no computador digital é a perda de precisão ou os erros numéricos.
			
 
				+Por exemplo, mesmo em notação decimal o valor 1/3 não será representado perfeitamente, ele será registrado com algo semelhante
			
 
				+a <tt>0.3333</tt> (se o computador utilizar 4 dígitos).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Um exemplo do problema numérico está ilustrado no exemplo abaixo, quando tentamos imprimir as somas de <tt>0.1</tt>
			
 
				+até <tt>0.9</tt>. Experimente copiar este trecho de código e roder em <em>C</em> ou em <em>Python</em>, você verá
			
 
				+que o algoritmo nunca parará! Isso mesmo, laço infinito, pois como o computador utiliza notação binário e como o decimal
			
 
				+<tt>0.1</tt> em binário corresponde a um binário periódico (como a dízima periódica resultante do <tt>1/3</tt> que é
			
 
				+<tt>0.3...</tt>).
			
 
				+<center>
			
 
				+<i>Tab. 4. Cuidado com a aritmética de ponto flutuante! Nem tudo é o que parece ser...</i>
			
 
				+<br/>
			
 
				+<table class="tbCodeLinCol">
			
 
				+ <tr><th>C </th> <th>Python</th></tr>
			
 
				+ <tr valign="top"><td><table class="tbCode">
			
 
				+   <tr><td><pre>x = 0.1;
			
 
				+while (x!=1.0) {
			
 
				+  <verd>printf</verd>("%f\n", x);
			
 
				+  x += 0.1;
			
 
				+  }
			
 
				+<verd>printf</verd>("Final!\n");</pre></td></tr>
			
 
				+ </table></td>
			
 
				+ <td><table class="tbCode"><pre>x = 0.1
			
 
				+while (x!=1.0) :
			
 
				+  <verd>print</verd>(x)
			
 
				+  x += 0.1
			
 
				+<verd>print</verd>("Final!")</pre></td></tr>
			
 
				+   </table></td></tr>
			
 
				+</table>
			
 
				+</center>
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+<a name="io"><span style="color: #0050A0">Entrada e saída de flutuantes em <i>C</i> e em <i>Python</i></span></a>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Em <i>C</i> deve-se utilizar o formatador <tt>%f</tt> para indicar que os <em>bits</em> devem ser tratados como número
			
 
				+em ponto flutuante, enquanto em <i>Python</i> deve-se utilizar a função <tt>float(...)</tt>, como indicado no exemplo
			
 
				+abaixo.
			
 
				+<center>
			
 
				+<i>Tab. 5. Como imprimir números em ponto flutuante.</i>
			
 
				+<br/>
			
 
				+<table class="tbCodeLinCol">
			
 
				+ <tr><th>C </th> <th>Python</th></tr>
			
 
				+ <tr valign="top"><td><table class="tbCode">
			
 
				+   <tr><td><pre><verm>float</verm> x; <cyan>// declaracao de variavel em "ponto flutuante"</cyan>
			
 
				+<verd>scanf</verd>("%f", &x); <cyan>// leia como "ponto flutuante"</cyan>
			
 
				+<verd>printf</verd>("%f\n", x); <cyan>// imprima como "ponto flutuante"</cyan>
			
 
				+<cyan>// Usar formatador %N.kf para usar N posicoes ajustadas 'a direita e k decimais</cyan>
			
 
				+<verd>printf</verd>("Tab.\nx=%3.2f\nx=%3.2f", x, x); <cyan>// imprima com 2 casas decimais</cyan>
			
 
				+</pre></td></tr>
			
 
				+ </table></td>
			
 
				+ <td><table class="tbCode"><pre>x = <verm>float</verm>(<verd>input</verd>()) <cyan># leia e transforme em "ponto flutuante"</cyan>
			
 
				+<verd>print</verd>(x); <cyan># impressao simples</cyan>
			
 
				+<cyan># Util para colocar frases mais "sofisticadas"</cyan>
			
 
				+<verd>print</verd>("x=%f - frases mais \"sofisticadas\"" % x); <cyan># impressoes mais sofisticadas</cyan>
			
 
				+<cyan># Assim e' util para construir tabelas.</cyan>
			
 
				+<verd>print</verd>("Tab.\nx=%3.2f\nx=%3.2f" % (x,x)); <cyan># o \n quebra linha</cyan>
			
 
				+
			
 
				+</pre></td></tr>
			
 
				+   </table></td></tr>
			
 
				+</table></center>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Aos alunos estudando com a linguagem <i>C</i>, tomem um cuidado adicional: o compilador <i>C</i> aceita utilizar o formatador
			
 
				+de inteiro na leitura e na impressão de uma variável em flutuante. Ele trunca o valor, assim se tiver <tt>float x=1.5;</tt>
			
 
				+e fizer <tt><verd>printf</verd>("x=%d\n", x);</tt>, não haverá erro de compilação e será impresso <tt>x=1</tt>.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+Uma boa fonte para pesquisar é
			
 
				+examinar o texto na <a href="https://en.wikipedia.org/wiki/Floating-point_arithmetic" title="examinar WikiPedia: floating-point">WikiPedia: floating-point</a>.
			
 
				+<!-- https://en.wikipedia.org/wiki/Single-precision_floating-point_format -->
			
 
				+</p>
			
 
				+
			
 
				+  <p class="autoria">
			
 
				+    <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/10: novas seções iniciais;<br/>
			
 
				+  2020/04/18: inserido nomes nas tabelas, correcao tab. 1 ("x+=1.0"->"x+=0.1")<br/>
			
 
				+  2017/04/14: primeira versão
			
 
				+</p>
			
 
				+
			
 
				+</div>
			
 
				+
			
 
				+<script src="css_img_js_conf/defineLInE.js"></script> <!-- function defineEndereco (url1) -->
			
--- a/introducao_for.html
+++ b/introducao_for.html
@@ -0,0 +1,236 @@
 
				+<!--
			
 
				+Introdução ao comando de repetição for
			
 
				+-->
			
 
				+
			
 
				+<!-- center><p>[
			
 
				+  <a href="memoria" title="sobre memoria, bits e bytese">Memória</a> &nbsp; | &nbsp;
			
 
				+  <a href="#variaveis" title="variaveis inteiras e reais">Variáveis</a> &nbsp; | &nbsp;
			
 
				+  <a href="#expressoes" title="expressoes aritmetics">Expressões</a> &nbsp; | &nbsp;
			
 
				+  <a href="#contexto" title="resultado de uma expressao depende do contexto">Contexto</a> &nbsp; &nbsp;
			
 
				+ ]</p>
			
 
				+</center -->
			
 
				+
			
 
				+  <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">
			
 
				+
			
 
				+
			
 
				+<p class="secao">Introdução ao comando de repetição for</p>
			
 
				+
			
 
				+<p>
			
 
				+  Nesta seção examinaremos um novo comando de repetição, bastante útil quando o número de
			
 
				+  <i>passos</i> (cada repetição de um bloco de comandos)
			
 
				+  é conhecido à priori, ou seja, conhecido ao iniciar o laço.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Em várias <i>linguagens de programação</i> (com <em>C</em> e em <em>Python</em>) esse comando recebe o nome de
			
 
				+  <b><tt class="cmd">for</tt></b> (<i>para</i>).
			
 
				+  Além disso ele deve sempre dispor de um <b>enumerador</b> (ou <i>iterador</i>), ou seja, uma
			
 
				+  variável que será utilizada para controlar o número de repetições do bloco de comandos subordinado ao <i>for</i>.
			
 
				+  Esse <i>enumerador</i> pode ser usado em comandos do bloco.
			
 
				+</p>
			
 
				+
			
 
				+<a name="caracteres"><span style="color: #0050A0">Comando <i>for</i> em <em>C</em></span></a>
			
 
				+
			
 
				+<p>
			
 
				+  Em <em>C</em> a sintaxe do comando é:
			
 
				+  
			
 
				+  <center>
			
 
				+    <table class="tbCodeLinCol">
			
 
				+      <tr><th>Comando <tt>for</tt></th><th>Equivalente usando <tt>while</tt></th></tr>
			
 
				+      <tr valign="top">
			
 
				+	<td><pre><tt class="cmd">for</tt> (varint=valorIni, condicao, incremento)
			
 
				+  comandoSubordinado;</pre></td>
			
 
				+        <td><pre>varint = valorIni;
			
 
				+<tt class="cmd">while</tt>  (condicao) {
			
 
				+  comandoSubordinado;
			
 
				+  incremento; <tt class="com">// geralmente algo como: varint += passo;</tt>
			
 
				+  }</pre></td></tr>
			
 
				+    </table>
			
 
				+  </center>
			
 
				+  
			
 
				+  Note que dentro da definição do comando também deve-se utilizar o separador ponto-e-vírgula (';').
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Por exemplo, o programa abaixo que imprime a soma dos <tt>n</tt> primeiros naturais,
			
 
				+  mas somando-os em ordem invertida, começando com o <tt>n</tt>, depois somando-se <tt>n-1</tt> e, assim por diante,
			
 
				+  até o <tt>1</tt>.
			
 
				+  <pre><tt class="head">#include &lt;stdio.h&gt;</tt>
			
 
				+int main (void) {
			
 
				+  int n, i; <tt class="com">// declarando o indexador i do comando for e o tamanho do laco n</tt>
			
 
				+  int soma = 0;
			
 
				+  <tt class="fnc">scanf</tt>("%d", &n); <tt class="com">// ler a quantia desejada de naturais</tt>
			
 
				+  <tt class="cmd">for</tt> (i=n; i&gt;0; i--) {
			
 
				+    soma += i; <tt class="com">// acumula o atual natural em i</tt>
			
 
				+    <tt class="fnc">printf</tt>("%d : %d\n", i, soma); <tt class="com">// imprime contador e a soma parcial
			
 
				+    // apos ultimo comando subordinado ao for, executa-se o incremento do contador (ou seja, i &lt;- i-1, entao
			
 
				+    // a execucao retorna ao inicio do for e testa se continua (i<u>&gt;</u>0),
			
 
				+    // se for repete-se os comandos subordinados, senao finaliza o for</tt>
			
 
				+    }
			
 
				+  <tt class="fnc">printf</tt>("Soma dos %d primeiros naturais eh igual a %d\n", n, soma);
			
 
				+  return 1; <tt class="com">// se foi algum outro programa que invocou este, devolva o valor 1</tt>
			
 
				+  }</pre>
			
 
				+</p>
			
 
				+
			
 
				+<a name="caracteres"><span style="color: #0050A0">Comando <i>for</i> em <em>Python</em></span></a>
			
 
				+
			
 
				+<p>
			
 
				+  Em <em>Python</em> é necessário usar um <i>iterador</i>, isso pode ser feito com a função
			
 
				+  <tt><tt class="fnc">range</tt>(...)</tt> que pode ter 1, 2 ou 3 parâmetros do tipo número natural.
			
 
				+  Se tiver apenas um parâmetro significa que deve gerar os n primeiros naturais.
			
 
				+  Se tiver dois parâmetros naturais, neste caso significa os naturais entre ambos, mas
			
 
				+  também pode ter três parâmetros e neste caso o último é o tamanho do passo.
			
 
				+  Abaixo a forma geral do comando <tt>for</tt>, com um exemplo de <tt>range(...)</tt> usando apenas um parâmetro.
			
 
				+  <center><tt><tt class="cmd">for</tt> varint in <tt class="fnc">range</tt>(numeroIteracoes) comandoSubordinado</tt></center>
			
 
				+  Nesse exemplo, o <tt>comandoSubordinado</tt> será executado <tt>numeroIteracoes</tt>, na primeira com
			
 
				+  <tt>i</tt> valendo <tt>0</tt>, depois <tt>i</tt> valendo <tt>1</tt> e assim por diante, até <tt>i</tt> valendo <tt>numeroIteracoes-1</tt>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Também pode-se fazer o <tt>i</tt> ter outro valor inicial e tamanho de passo diferente, mesmo passos "negativos".
			
 
				+  Por exemplo, para imprimir os <tt>n/2</tt> primeiros ímpares pode fazer:
			
 
				+  <table>
			
 
				+   <tr><td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</td>
			
 
				+                <td><tt class="cmd">for i in <tt class="fnc">range</tt>(1, n, 2) : print("%d " % i, end="");</tt></td></tr>
			
 
				+   <tr><td></td><td><tt>print();</tt></table>
			
 
				+  Se <tt>n=10</tt>, esse código geraria <tt>1 3 5 7 9</tt>, na mesma linha. Ou seja,
			
 
				+  o segundo parâmetro do <tt>range(...)</tt> (o controle <tt>n</tt>), é o limite, "repete-se enquanto" <tt>i <u>&lt;</u>10</tt>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Por exemplo, o programa abaixo que imprime a soma dos <tt>n</tt> primeiros naturais,
			
 
				+  mas somando-os em ordem invertida, começando com o <tt>n</tt>, depois somando-se <tt>n-1</tt> e, assim por diante,
			
 
				+  até o <tt>1</tt>.
			
 
				+  <pre>def main () :
			
 
				+  <tt class="com">#inteiros: n, i; :: usaremos como indexador i para o comando for e o tamanho do laco n</tt>
			
 
				+  soma = 0;
			
 
				+  n = int(<tt class="fnc">input</tt>()); <tt class="com"># ler a quantia desejada de naturais</tt>
			
 
				+  <tt class="cmd">for</tt> i in <tt class="fnc">range</tt>(n, 0, -1) :
			
 
				+    soma += i; <tt class="com"># acumula o atual natural em i</tt>
			
 
				+    <tt class="fnc">print</tt>("%d : %d" % (i,soma)); <tt class="com"># imprime contador e a soma parcial</tt>
			
 
				+    # desse ponto, incrementa-se i (ou seja, i &lt;- i-1, entao a execucao retorna ao inicio do for e se i<u>&gt;</u>0,
			
 
				+    # repete-se os comandos subordinados ao for
			
 
				+  <tt class="fnc">print</tt>("Soma dos %d primeiros naturais eh igual a %d" % (N,soma));
			
 
				+main()</pre>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Note que no exemplo acima usamos o marcador <tt><b>%d</b></tt> dentro da função <tt class="fnc">print</tt>,
			
 
				+  isso significa que no lugar do primeiro <tt>%d</tt> deverá ser impresso o valor da primeira variável, encontrada
			
 
				+  após fechar aspas e após o caractere <tt>%</tt> (i.e., <tt>i</tt>) e no lugar do <tt>%d</tt> deverá ser impresso o valor da
			
 
				+  segunda variável (i.e., <tt>soma</tt>).
			
 
				+  O <tt>%d</tt> está associado à inteiros, se precisar de caractere deve-se usar o formator <tt>%c</tt>,
			
 
				+  se precisar de ponto flutuante deve-se usar o <tt>%f</tt> e se for usar uma variável que guarda caracteres (<i>string</i>),
			
 
				+  deve-se usar o formatador <tt>%s</tt>.
			
 
				+  <!--
			
 
				+  Entretanto, como no exemplo, se existir mais que uma variável/valor, então é obrigatório que esses venham
			
 
				+  com a sintaxe de <i>lista</i> e na ordem correspondentes a cada formatador <tt><b>%d</b></tt>, ou seja,
			
 
				+  a lista cercada por abre e fecha parênteses.
			
 
				+  -->
			
 
				+</p>
			
 
				+
			
 
				+<span style="color: #0055AA;font-size:1.em"><b>Exercitando a compreensão: simulando o código</b></span>
			
 
				+
			
 
				+<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>
			
 
				+<!--
			
 
				+3
			
 
				+0 : 0
			
 
				+1 : 1
			
 
				+2 : 3
			
 
				+Soma dos 3 primeiros naturais eh igual a 3
			
 
				+-->
			
 
				+<center><table><tr><td align="left"><pre>
			
 
				+                                                    n | soma | i     impressoes
			
 
				+                                                   ---+------+---    ----------
			
 
				+soma := 0                                           ? |    0 | ? 
			
 
				+* leitura para inteiro n                            3 |      |
			
 
				+i := 0 (primeiro da lista (0,1,2)                     |      | 0
			
 
				+* entra no laco "for" pois 0=i&lt;n=3                    |      |
			
 
				+soma := 0 (pois: soma recebe soma+i=0+1)              |    0 | 
			
 
				+* saida: 0 : 0                                        |      |       0 : 0
			
 
				+i := 1 (segundo da lista (0,1,2))                     |      | 1
			
 
				+* entra no laco "for" pois 1=i&lt;n=3                    |      |
			
 
				+soma := 1 (pois: soma recebe soma+i=0+1)              |    1 | 
			
 
				+* saida: 1 : 1                                        |      |       1 : 1
			
 
				+i := 2 (terceiro da lista (0,1,2))                    |      | 2
			
 
				+* entra no laco "for" pois 2=i&lt;n=3                    |      |
			
 
				+soma := 3 (pois: soma recebe soma+i=1+2)              |    3 | 
			
 
				+* saida: 2 : 3                                        |      |       2 : 3
			
 
				+* nao tem elemento na lista (0,1,2) apos o 2          |      |
			
 
				+* final do laco "for" (sem mais elementos)            |      |
			
 
				+* executa primeira instrucao apos laco "for"          |      |       
			
 
				+* saida: Soma dos 3 primeiros naturais eh igual a 3   |      |       Soma dos 3 primeiros naturais eh igual a 3
			
 
				+</pre></td></tr></table></center>
			
 
				+
			
 
				+<!-- img/img_invisivel.png e img/img_visivel.png -->
			
 
				+<img src="img/img_invisivel.png" onClick="fnc_mostrar('mais_range', 'olho');" id="olho"
			
 
				+     title="Clique para ver explicacao adicional sobre 'range'" />
			
 
				+<div class="mais" id="mais_range">
			
 
				+<p>
			
 
				+  Em relação à função <tt>range(...)</tt> existe uma diferença interessante entre o <em>Python 2</em> e o
			
 
				+  <em>Python 3</em>. No 2 ao usar por exemplo, <tt><tt class="fnc">range</tt>(10)</tt> é gerada uma lista com os
			
 
				+  10 primeiros naturais, assim imediatamente após invocar a função é necessário alocar espaço de
			
 
				+  memória para os 10 elemento.
			
 
				+  Já no <em>Python 3</em> os elementos são gerados a medida que se precisa deles.
			
 
				+<p>
			
 
				+<!--a href="." onMouseOver="fnc_mostrar_esconder('mais_range');"-->
			
 
				+<p>
			
 
				+  Vejamos como funcionam os parâmetros em <tt class="fnc">range</tt>:
			
 
				+
			
 
				+  <center>
			
 
				+    <table class="tbCodeLinCol">
			
 
				+      <tr><th># parâmetros</th><th>função</th><th>resultado</th></tr>
			
 
				+      <tr valign="top">
			
 
				+        <th>1 parâmetro</th>
			
 
				+	<td><pre>lst = <tt class="fnc">range</tt>(10)</pre>
			
 
				+	<td>Gera uma lista com os naturais <tt>0,1,2,3,4,5,6,7,8,9<tt></td>
			
 
				+      </tr>
			
 
				+      <tr valign="top">
			
 
				+        <th>2 parâmetros</th>
			
 
				+	<td><pre>lst = <tt class="fnc">range</tt>(0,10)</pre>
			
 
				+	<td>Gera uma lista com os naturais <tt>0,1,2,3,4,5,6,7,8,9<tt></td>
			
 
				+      </tr>
			
 
				+      <tr valign="top">
			
 
				+        <th>2 parâmetros</th>
			
 
				+	<td><pre>lst = <tt class="fnc">range</tt>(1,10)</pre>
			
 
				+	<td>Gera uma lista com os naturais <tt>1,2,3,4,5,6,7,8,9,10<tt></td>
			
 
				+      </tr>
			
 
				+      <tr valign="top">
			
 
				+        <th>3 parâmetros</th>
			
 
				+	<td><pre>lst = <tt class="fnc">range</tt>(0,10,2)</pre>
			
 
				+	<td>Gera uma lista com os naturais <tt>0,2,4,6,8<tt></td>
			
 
				+      </tr>      
			
 
				+    </table>
			
 
				+  </center>
			
 
				+</p>
			
 
				+</div>
			
 
				+
			
 
				+
			
 
				+
			
 
				+  <p class="autoria">
			
 
				+    <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/15: novo formato, pequenas revisões<br/>
			
 
				+    2019/07/28: Versão 1.2 (vários acertos)<br/>
			
 
				+    2019/03/31: Versão 1.1<br/>
			
 
				+    2017/05/03: versão 1.0
			
 
				+  </p>
			
 
				+
			
 
				+
			
 
				+</div>
			
--- a/introducao_funcao_global.html
+++ b/introducao_funcao_global.html
@@ -0,0 +1,161 @@
 
				+<!--
			
 
				+
			
 
				+Introdução às funções, parâmetros e variáveis globais
			
 
				+http://saw.atp.usp.br/mod/page/view.php?id=13302
			
 
				+
			
 
				+
			
 
				+---
			
 
				+Trocar end. imagem para:
			
 
				+
			
 
				+<center><img alt="memoria e variaveis" src="http://saw.atp.usp.br/draftfile.php/31/user/draft/650565435/memoria1.jpg" title="ilustracao de 4 sequencias de 8 bits em memoria" height="71" width="342" /></center>
			
 
				+
			
 
				+<i></i>
			
 
				+
			
 
				+---
			
 
				+-->
			
 
				+<!DOCTYPE html>
			
 
				+<html itemscope itemtype="http://schema.org/QAPage">
			
 
				+
			
 
				+<head>
			
 
				+  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
			
 
				+  <title>Introdução às funções, parâmetros e variáveis globais</title>
			
 
				+</head>
			
 
				+
			
 
				+<body>
			
 
				+
			
 
				+<span style="color: #0055AA">Introdução às funções, parâmetros e variáveis globais</span>
			
 
				+
			
 
				+<p>
			
 
				+Uma função em linguagens alto-nível com <i>C</i> e <i>Python</i> deve ser entendida como um
			
 
				+bloco de comandos que podem ser invocados (chamados) em qualquer momento, resultando que o
			
 
				+referido bloco será executado (ou interpretado) e após sua execução, o fluxo continua do
			
 
				+ponto em que estava. Isso é esquematizado na figura abaixo.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Em última análise, os dados presentes na memória do computador é uma sequência de <i>bits</i> e um <i>bit</i>
			
 
				+corresponde a uma posição de memória que pode armazenar o valor 0 ou o valor 1. No início da computação moderna
			
 
				+a menor quantidade de <i>bits</i> que podia acessar eram 8, que foi denominado por <i>byte</i>.
			
 
				+</p>
			
 
				+
			
 
				+<center><img src="img/var_memoria1.jpg" title="ilustracao de 4 sequencias de 8 bits em memoria"/>
			
 
				+</center>
			
 
				+
			
 
				+<p>
			
 
				+Desse modo, toda informação armazenada no computador é uma sequência de <i>bytes</i> e tratamento de cada
			
 
				+que se dá para cada sequência de <i>bytes</i> pode variar. Ou seja, de acordo com o <b>contexto</b> pode-se
			
 
				+interpretar esta sequência como um número inteiro, como um valor real ou como um caractere.
			
 
				+</p>
			
 
				+
			
 
				+<span style="color: #0055AA">Variáveis inteiras e reais</span>
			
 
				+
			
 
				+<p>
			
 
				+E qual a relação disso com variável? Bem, por exemplo, é necessário contar e, para fazer usando o computador
			
 
				+precisamos pegar uma sequência de <i>bytes</i> interpretá-lo como inteiro, somar 1 e registrar o valor
			
 
				+alterado. Isso é feito utilizando a mesma posição de memória, que está assim <i>variando</i>, dai o nome
			
 
				+<i>variável</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p>  
			
 
				+De um ponto de vista mais elevado (<i>alto-nivel</i>), utilizando uma linguagem de programação com <i>C</i> ou <i>Python</i>,
			
 
				+uma variável é representada por um nome, sem caracteres especiais (exceto "barra baixa" '_' que é permitido)
			
 
				+e que não seja o nome de um comando da linguaguem (denominado de modo geral por <i>palavra reservada</i>).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Além disso uma variável deve ter um tipo associado, os tipos básicos que examinaremos nesta seção são o
			
 
				+inteiro (<i>int</i>) e o flutuante (<i>float</i>), este último para representar os valores reais.
			
 
				+A partir da explicação acima sobre interpretar os <i>bytes</i> como número ou caractere explica a necessidade
			
 
				+de cada variável ter o seu tipo conhecido.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Para explicar melhor a necessidade de tipos, suporemos que o computador considerado utilize para uma variável
			
 
				+<i>int</i> e para uma do tipo <i>float</i>, respectivamente, 2 e 4 <i title="cada byte tem 8 bits">bytes</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Desse modo, quando o citado computador precisa devolver o valor armazenado em uma variável do tipo inteiro, ele
			
 
				+acessará a posição de memória associada à variável, pegará a partir dessa posição os próximos 16 <i>bits</i> e
			
 
				+o interpretará como um valor inteiro.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Do ponto de vista prático, vejamos como se usa variáveis do tipo <i>int</i> e do tipo <i>float</i> nas linguagens
			
 
				+<i>C</i> e <i>Python</i>.
			
 
				+</p>
			
 
				+
			
 
				+<center><table>
			
 
				+  <tr><td></td><td bgcolor="8aaada"><i>C</i>              <td bgcolor="8aaada"><i>Python</i></td></tr>
			
 
				+  <tr><td>1</td><td>int n1,n2;                            <td># desnecessário declarar em <i>Python</i></td></tr>
			
 
				+  <tr><td>2</td><td>n1 = 1;                               <td>n1 = 1</td></tr>
			
 
				+  <tr><td>3</td><td>scanf("%d", &n2);                     <td>n2 = int(input())</td></tr>
			
 
				+  <tr><td>4</td><td>printf("n1=%d e n2=%d\n", n1, n2);    <td>print "n1=", n1, " e n2=", n2  # Python 2</td></tr>
			
 
				+  <tr><td>5</td><td>                                      <td>print("n1=", n1, " e n2=", n2) # Python 3</td></tr>
			
 
				+</table></center>
			
 
				+
			
 
				+<p>
			
 
				+Note as diferenças entre <i>C</i> e <i>Python</i>. De modo geral, todo comando em <i>C</i> precisa de ';' como finalizador.
			
 
				+Na linha 1 percebe-se que em <i>C</i> é obrigatório <b>declarar</b> as variáveis, enquanto que em <i>Python</i> não.
			
 
				+<br/>
			
 
				+Na linha 3 nota-se que <i>C</i> utiliza a função pré-definida de nome <i>scanf</i> para pegar valores digitados
			
 
				+pelo usuário enquanto <i>Python</i> usa o <i>input</i>. O <i>scanf</i> usa o formatador especial '%d' para forçar
			
 
				+o computador a interpretar os <i>bytes</i> como um inteiro, enquanto o <i>input</i> pega os <i>bytes</i>
			
 
				+digitados e o submete à outra função pré-definida <i>Python</i>, o <i>int(...)</i>, que converte o valor para inteiro.
			
 
				+<br/>
			
 
				+Na linha 4 nota-se o mesmo tipo de diferença, <i>C</i> utiliza a função <i>printf</i> para imprimir também com
			
 
				+o formatador para inteiro '%d', além de separar em 2 blocos, o primeiro para formatar a saída, que é cercado
			
 
				+por aspas dupla e o segunda, uma lista de variáveis compatíveis com o formatador.
			
 
				+Já em <i>Python</i>, usa-se os caracteres entre aspas e as variáveis misturados, separador por vírgula.
			
 
				+<br/>
			
 
				+Vale destacar que a linha 4 apresenta a sintaxe do <i>Python</i> antes da versão 3, enquanto que alinha 5 apresenta
			
 
				+o mesmo resultado mas para o <i>Python</i> a partir da sua versão 3.
			
 
				+</p>
			
 
				+
			
 
				+<span style="color: #0055AA">Expressões aritméticas</span>
			
 
				+
			
 
				+<p>
			
 
				+Do mesmo modo que em matemática é essencial efetuamos operações aritméticas com valores numéricos,
			
 
				+o mesmo ocorre com o computador, na verdade efetuar contas de modo rápido e sem erro foi a grande
			
 
				+motivação para se construir os computadores.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Neste, os agrupamentos de valores, variáveis e operadores aritméticos recebem o nome de  <i>expressão aritmética</i>.
			
 
				+Os operadores artiméticos, tanto em <i>C</i> quanto em <i>Python</i> são:
			
 
				+</p>
			
 
				+
			
 
				+<center><table>
			
 
				+  <tr><td bgcolor="8aaada">Operação</td><td bgcolor="8aaada">Operador <td bgcolor="8aaada">Exemplo</td></tr>
			
 
				+  <tr><td>soma         </td><td> +           <td> 2 + 4                          </td></tr>
			
 
				+  <tr><td>subtração    </td><td> -           <td> n1 + 1                         </td></tr>
			
 
				+  <tr><td>multiplicação</td><td> *           <td> 3 * n2                         </td></tr>
			
 
				+  <tr><td>divisão      </td><td> /           <td> n1 / n2                        </td></tr>
			
 
				+</table></center>
			
 
				+
			
 
				+<p>
			
 
				+Note que foi usado espaço em branco entre os operando e operadores, mas isso não é obrigatório.
			
 
				+</p>
			
 
				+
			
 
				+<span style="color: #0055AA">O resultado de uma expressão aritmética depende do contexto</span>
			
 
				+
			
 
				+<p>
			
 
				+É importante observar que dependendo do contexto o resultado de uma expressão é um ou outro, quer dizer,
			
 
				+se os valores envolvidos forem todos eles inteiros, o resultado será inteiro, entretanto havendo um valor
			
 
				+real, a resposta final será real.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+A importância disso fica clara ao examinar dois exemplos simples: <i>3 / 2 * 2</i> e <i>3.0 / 2 * 2</i>.
			
 
				+A primeira expressão resulta o valor <i>2</i>, enquanto a segunda <i>3.0</i>. Isso mesmo.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+A razão é que no primeiro caso todos valores são inteiros, então o cômputo é realizado com aritmética de precisão inteira,
			
 
				+ou seja, ao realizar o primeiro cômputo <i>3/2</i>, o resultado é <i>1</i> (e não <i>1.5</i> como no segundo caso), daí
			
 
				+o segundo operador é feito com os valores <i>1 * 2</i> resultando o valor <i>2</i>.
			
 
				+</p>
			
 
				+
			
 
				+Leônidas de Oliveira Brandão
			
 
				+http://line.ime.usp.br
			
 
				+</body>
			
--- a/introducao_funcoes.html
+++ b/introducao_funcoes.html
@@ -0,0 +1,310 @@
 
				+<!--
			
 
				+Introdução ao uso de funções em C e em Python
			
 
				+http://saw.atp.usp.br/mod/page/view.php?id=
			
 
				+-->
			
 
				+
			
 
				+  <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">
			
 
				+
			
 
				+
			
 
				+<p class="secao">O que é uma função em linguagens de programação</p>
			
 
				+
			
 
				+<p>
			
 
				+  A ideia básica de uma função, implementada em alguma linguagem de programação, é <i>encapsular</i> um código
			
 
				+  que poderá ser invocado/chamado por qualquer outro trecho do programa.
			
 
				+  Seu significado e uso é muito parecido com o de funções matemáticas, ou seja, existe um nome, uma definição
			
 
				+  e posterior invocação à função.
			
 
				+</p>
			
 
				+
			
 
				+<p> 
			
 
				+  Explicitando o paralelo com a matemática, tomemos como exemplo a função trigométrica <i>cosseno(x)</i>:
			
 
				+  deve-se definir a função (declará-la, seguindo a sintaxe correta: <tt>definir cosseno (parametro_real x): ...devolve valor;</tt>),
			
 
				+  depois pode-se <i>invocá-la</i> com parâmetros efetivos, valores específicos, como: <tt>cosseno(0)</tt> ou <tt>cosseno(0.5)</tt>.
			
 
				+  <br/>
			
 
				+  <b>Para quem deseja saber mais</b>: Esta é uma função que é impossível de ser implementada de <b>modo exato</b> em um
			
 
				+  computador digital, entretanto é viável obter boas aproximações utilizando o conceito de
			
 
				+  <a href="#" onclick="trocaPagina('introducao_eficiencia_algoritmos.html#taylor')"
			
 
				+     title="ver explicaco sobre serie de Taylor e funcao cosseno"><i>série de Taylor</i></a>.
			
 
				+  Do ponto de vista prático, a série que aproxima a função <i>cosseno</i>, para valores de <tt>x</tt> próximo à origem é:
			
 
				+    <i>(1) cos(x) = 1 - x<sup>2</sup> /2! + x<sup>4</sup> /4! - x<sup>6</sup> /6! + x<sup>8</sup> /8! + ...</i>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Note que o <i>lado direito</i> da equação (1) é a definição da função e ela está escrita em termos
			
 
				+  do <b>parâmetro formal</b> <i>x</i>.
			
 
				+  Ao "chamarmos" a função com <b>parâmetros efetivos</b>, é sobre o valor desses parâmetros que computamos
			
 
				+  o lado direito da expressão, por exemplo, computar <i>cos(0.1)</i> ou de <i>cos(1.1)</i>.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="porque">
			
 
				+<p class="secao">Por que usar o conceito de função?</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+  Assim, implementar códigos com objetivos específicos (como computar o <i>cosseno</i> de qualquer valor)
			
 
				+  apresentam três grandes vantagens:
			
 
				+  <ol>
			
 
				+    <li>
			
 
				+      Facilita o desenvolvimento (<i>desenvolvimento modular</i>): implementa-se uma <i>particular unidade</i>, um trecho menor,
			
 
				+      concentrando-se nele, até que ele esteja funcionando com alto grau de <i>confiabilidade</i>;
			
 
				+    </li>
			
 
				+    <li>
			
 
				+      Organização: o código fica melhor organizado e portanto mais fácil de manter;
			
 
				+    </li>
			
 
				+    <li>
			
 
				+      Reaproveitamento: sempre que precisar aplicar o código encapsulado em qualquer outro trecho de código
			
 
				+      (ou noutro código), pode-se utilizar aquele que já foi implementado e é <i>confiável</i>.
			
 
				+    </li>
			
 
				+  </ol>
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="aplicacao">
			
 
				+<p class="subsubsecao">Um exemplo de aplicação do conceito de função: conseguir deduzir algitmos complexos</p>
			
 
				+</a>
			
 
				+
			
 
				+<!--
			
 
				+aplicando o princípio do <em>passo da indução finita</em>
			
 
				+  -->
			
 
				+
			
 
				+<p>
			
 
				+  Uma aplicação interessante das 3 vantagens acima citadas é possibilitar <b>quebrar</b> o problema, tentar perceber alguma estrutura
			
 
				+  do problema que permita quebrá-lo em tarefas menores (e mais simples!).
			
 
				+  Eesta abordagem é conhecida em Matemática como a técnica <b style="color:#0000aa;">dividir para conquistar</b>.
			
 
				+  <br/>
			
 
				+  Em atividades mais sofisticadas (geralmente aquelas envolvendo laços "duplos" ou mais - i.e., "laço dentro de laço")
			
 
				+  esta abordagem pode fazer a diferença entre conseguir deduzir um solução ou não conseguir.<br/>
			
 
				+  Um exemplo básico da abordagem: deduzir um <i style="color:#0000aa;">algoritmo para ordenar um vetor</i> com <em>N</em> valores.
			
 
				+  <ol type="A">
			
 
				+    <li value=””>Podemos imaginar um laço percorrendo as <em>N</em> posições do vetor <em>V[]</em>, sequencialmente desde
			
 
				+        <em>V[0]</em> até <em>V[N-2]</em>:
			
 
				+    <ol type="a">
			
 
				+      <li value=””>Para cada posição <em>i</em> supor existir uma função que encontra e devolve o índice <em>ind_min</em>
			
 
				+          do menor valor entre <em>V[i]</em> e <em>V[N-1]</em>;
			
 
				+      </li>
			
 
				+      <li value=””>Como isso foi feito sucessivamente desde a posição <em>i=0</em>, então (por indução), temos neste momento:
			
 
				+          <em>V[0]<u>&lt;</u>V[1]<u>&lt;</u> ... V[i-1]<u>&lt;</u> V[ind_min]<u>&lt;</u></em> e
			
 
				+          <em>V[ind_min]<u>&lt;</u>V[k]</em> para todo <em>k=i, i+1, ..., N-1</em> (supondo que a função acima funcionou).<br/>
			
 
				+          Portanto, basta trocar o elemento atual da posição <em>i</em> com aquele da posição <em>ind_min</em>
			
 
				+          (que tem o menor dentre <em>V[i]</em>, <em>V[i+1]</em>, ..., <em>V[N-1]</em>.<br/>
			
 
				+          Deste modo estendemos a ordenação: <em>V[0]<u>&lt;</u>V[1]<u>&lt;</u> ... V[i-1]<u>&lt;</u> V[i]<u>&lt;</u></em>.
			
 
				+      </li>
			
 
				+    </ol>
			
 
				+    </li>
			
 
				+  </ol>
			
 
				+  Uma vez que o problema foi <b>quebrado</b> e uma parte importante dele resolvida, deve-se tentar resolver a parte que falta, o parte "a".
			
 
				+  Então pode-se tentar resolver a parte "a", deduzindo um algoritmo que encontre o índice do menor valor
			
 
				+  (<em>V[i]</em> e <em>V[N-1]</em>).
			
 
				+  Uma vez resolvida também esta parte, este código pode ser incorporado adequadamente ao item "a" para
			
 
				+  finalmente <b>conquistarmos</b> a solução completa.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Note que, em termos práticos, o algoritmo da parte "a" pode ser implementado como função, mas também pode-se
			
 
				+  implementá-lo diretamente no código (sem função, porém neste caso resultará em um código ficará "menos organizado").
			
 
				+  <br/>
			
 
				+  Experimente!
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p class="secao">Introdução ao uso de funções em <i>C</i> e em <i>Python</i></p>
			
 
				+   
			
 
				+<p>
			
 
				+  Assim, agrupar trechos com objetivos específicos e implementá-los na forma de uma <i>função</i>
			
 
				+  que ajuda bastante o desenvolvimento e a organização dos códigos em programação.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Do ponto de vista prático, a estrutura básica de uma função em uma linguagem de programação está representada abaixo,
			
 
				+  com a <i>declaração da função</i> e sua <i>lista de parâmetros formais</i>, seguido de sua invocação
			
 
				+  (quando providenciamos os <i>parâmetro efetivos</i>).
			
 
				+<table>
			
 
				+  <tr valign="top"><td>Declaração:</td>
			
 
				+    <td>
			
 
				+    <tt>[enventual tipo de retorno] nome_da_funcao (lista_parametros_formais)<br/>
			
 
				+        comando1<br/>
			
 
				+        ...<br/>
			
 
				+        comandoN<br/>
			
 
				+        return EXP <cyan>//# devolve o valor em EXP para quem chamou a funcao</cyan></tt></td></tr>
			
 
				+  <tr valign="top"><td>Uso:</td><td>
			
 
				+    <tt>var = nome_da_funcao(lista_parametros_efetivos)</tt></td></tr>
			
 
				+</table>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Atenção ao <b><tt>return</tt></b>, este é um comando especial, se ele for alcançado (e.g., ele pode estar subordinado a um comando de seleção <tt>if</tt>)
			
 
				+  então a execução da função é <b>interrompida</b>, retornando-se ao ponto imediatamente após o ponto de chamada da função.
			
 
				+  No caso do comando ter uma expressão qualquer, como indicado no exemplo <tt>return EXP</tt>, o valor de <tt>EXP</tt> é devolvido ao ponto de chamada,
			
 
				+  neste caso a chamada deve estar dentro de uma expressão (lógica ou artimética de acordo com o tipo de <tt>EXP</tt>) ou ser o lado direito de
			
 
				+  uma <i>atribuição</i>. Este último é o caso ilustrado na figura 1.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+A <i>lista de parâmetros</i> pode conter vários nomes de variáveis, geralmente, separadas por vírgula.
			
 
				+Por exemplo, se houver necessidade de uma função que realiza vários cálculos com três variáveis pode-se usar como
			
 
				+declaração da função algo como: 
			
 
				+<tt>nome_da_funcao (var1, var2, var3)</tt>.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p class="subsubsecao">Parâmetros formais e efetivos</p>
			
 
				+
			
 
				+<p>
			
 
				+De modo geral, a diferença entre os <i> parâmetros formais</i> e <i>efetivos</i> é que o primeiro corresponde ao
			
 
				+nome da variável utilizada dentro da função, enquanto o segundo é o nome da variável que será usado para iniciar o parâmetro
			
 
				+formal ao iniciar a execução da função.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Assim durante a execução, ao encontrar uma chamada à função <tt>nome_da_funcao</tt>, o fluxo de execução segue
			
 
				+a partir do código da função.
			
 
				+Mas antes de executar a primeira linha de código da função, os valores dos <i>parâmetros efetivos</i> servem para inicializar
			
 
				+os parâmetros formais (que são também variáveis locais à função). Após esta inicialização, inicia-se a execução do código
			
 
				+da função e geralmente ao final, encontra-se um comando do tipo "retorne devolvendo um valor" (<i>return</i>).
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p class="subsubsecao">Ilustrando a execução de um trecho de programa com 3 chamadas à mesma função</p>
			
 
				+
			
 
				+<p>
			
 
				+Suponhamos que precisemos computar o valor da combinação de <i>N</i> tomado <i>k</i> a <i>k</i>, ou seja,
			
 
				+C(N,k) = N! / ( k! (N-k)!).
			
 
				+Para isso percebe-se que é necessário implementar o cômputo de fatorial que será utilizado 3 vezes.
			
 
				+Para facilitar a compreensão, podemos escrever um código com 3 variáveis auxiliares para armazenar, respectivamente,
			
 
				+<i>N!</i>, <i>k!</i> e <i>(N-k)!</i>.
			
 
				+<p>
			
 
				+
			
 
				+
			
 
				+<center>
			
 
				+ <p>
			
 
				+  <img src="img/exemplo_exec_funcao.jpg" title="exemplo de execucao da funcao"/>
			
 
				+  <br/>
			
 
				+  <i>Fig. 1. Ilustração do fluxo de execução ao <b>invocar</b> uma função para computar o <b>fatorial</b> de um natural.</i>
			
 
				+ </p>
			
 
				+</center>
			
 
				+
			
 
				+<p>
			
 
				+Na figura acima ilustra a execução do código para computar <i>C(N,k)</i>, com o retângulo à esquerda contendo
			
 
				+o código que invoca a função <i>fat</i> e à direita a função <i>fat</i>.
			
 
				+Para entender o fluxo de execução destaremos a execução da linha 2, <tt>b = fat(k);</tt>.
			
 
				+Como <tt>b = fat(k);</tt> é uma atribuição, primeiro computa-se o valor do <i>lado direito</i> da atribuição
			
 
				+e só depois atribui-se à variável do <i>lado esquerdo</i> da atribuição o seu valor, ou seja,<br/>
			
 
				+ &nbsp; 1. primeiro executa-se o cômputo de <tt>fat(k)</tt>, para isso<br/>
			
 
				+ &nbsp; 2. pega-se o valor do <i>parâmetro efetivo</i> <tt>k</tt> e usa-o para iniciar o <i>parâmetro formal</i> <tt>n</tt> da função<br/>
			
 
				+ &nbsp; 3. então inicia-se a execução da função <tt>fat</tt><br/>
			
 
				+ &nbsp; 4. ao final da função <tt>fat</tt>, pega-se o valor da variável local <tt>ft</tt> e <br/>
			
 
				+ &nbsp; 5. atribui-se este valor para a variável <tt>b</tt><br/>
			
 
				+ &nbsp; 6. então segue-se execução da próxima linha (3).<br/>
			
 
				+Vale notar que a execução da atribuição <tt>c = fat(N-k);</tt> seguirá um fluxo análogo aos 6 passos acima.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Uma vez entendido como é executado uma chamada á função, podemos novamente comparar com o conceito usual
			
 
				+de função matemática. Existe a declaração da função, com seu parâmetro formal
			
 
				+<pre>
			
 
				+   fat : IN -> IN  (nome 'fat', com domínio e imagem nos naturais)
			
 
				+   fat(n) = { 1, se n=0, n x fat(n-1), se n>0 }</pre>
			
 
				+E existe o uso da função, como em
			
 
				+<pre>
			
 
				+   C(N,k) = fat(N) / (fat(k) x fat(N-k)</pre>
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p class="subsubsecao">Exemplo concreto em <i>C</i> e em <i>Python</i></p>
			
 
				+
			
 
				+<p> 
			
 
				+Para ilustrar o uso e sintaxe de funções em <i>C</i> e em <i>Python</i>, examinemos um exemplo em que implementamos uma
			
 
				+função para cômputo do fatorial de um natural <i>n</i>, que será o nome de seu único parâmetro formal.
			
 
				+</p>
			
 
				+
			
 
				+<center><table class="tableCd">
			
 
				+ <tr><td></td><td bgcolor="8aaada"><i>C</i>              <td bgcolor="8aaada"><i>Python</i></td></tr>
			
 
				+  <tr><td><table class=""><tr class="trCd" valign="top"><td><pre> 1
			
 
				+ 2
			
 
				+ 3
			
 
				+ 4
			
 
				+ 5
			
 
				+ 6
			
 
				+ 7
			
 
				+ 8
			
 
				+ 9
			
 
				+10
			
 
				+11</pre></td></tr></table></td>
			
 
				+  <td><table class=""><tr class="trCd" valign="top"><td><pre><verm>int</verm> fat (<verm>int</verm> n) { <cyan>// define funcao com 1 parametro</cyan>
			
 
				+  <verm>int</verm> ft = 1; <verm>int</verm> i=1;
			
 
				+  <azul>while</azul> (i &lt; n) {
			
 
				+    i = i + 1; 
			
 
				+    ft = ft * i;  
			
 
				+    }   
			
 
				+  return ft;
			
 
				+  } <cyan>// chave indica final da funcao 'fat(...)'</cyan>
			
 
				+...
			
 
				+<cyan>// supondo existir neste contexto variaveis: N e k</cyan>
			
 
				+<verd>printf</verd>("Combinacao = %f\n", fat(N) / (fat(k) * fat(N-k));</pre></td></tr></table></td>
			
 
				+  <td><table class=""><tr class="trCd" valign="top"><td><pre><verm>def</verm> fat (<verm>int</verm> n) : <cyan># define funcao com 1 parametro</cyan>
			
 
				+  ft = 1; <verm>int</verm> i=1 
			
 
				+  <azul>while</azul> (i &lt; n) {
			
 
				+    i = i + 1;  
			
 
				+    ft = ft * i;
			
 
				+  return ft;
			
 
				+  <cyan># Final da funcao 'fat(...)' - em Python,</cyan>
			
 
				+  <cyan># basta a indentacao da proxima linha ser recuada</cyan>
			
 
				+...
			
 
				+<cyan># supondo existir neste contexto variaveis: N e k</cyan>
			
 
				+<verd>print</verd>("Combinacao = ", fat(N) / (fat(k) * fat(N-k))
			
 
				+  </pre></td></tr></table></td></tr>
			
 
				+</table></center>   
			
 
				+
			
 
				+
			
 
				+<p class="subsubsecao">Variáveis locais</p>
			
 
				+
			
 
				+<p>
			
 
				+Note na linha 2 do código acima que são declaradas duas novas variáveis, <i>ft</i> e <i>i</i>, dentro da fução <i>fat</i>.
			
 
				+Isso significa que as variáveis <i>ft</i> e <i>i</i> são <b>variáveis locais</b> à função, ou seja,
			
 
				+pode-se utilizar variáveis com os mesmos nomes em outras funções sendo que elas não terão qualquer relação.
			
 
				+Em particular, na 11 do código em <i>C</i> ou na 9 do código em <i>Python</i>, poderia-se usar uma variável com nome <i>n</i>,
			
 
				+<i>ft</i> ou <i>i</i> e ainda assim, está variável não teria qualquer relação com as correspondentes da função <i>fat</i>.
			
 
				+</p>  
			
 
				+
			
 
				+
			
 
				+<p class="subsubsecao">Para que serve função?</p>
			
 
				+
			
 
				+<p>
			
 
				+A partir do exemplo acima, para cômputo de <i>C(n,k) = n! / (k! (n-k)!)</i>,
			
 
				+imagine como seria o código para computar a combinção se a linguagem de programação NÂO dispusesse do conceito
			
 
				+de funções: em resumo, precisariamos repetir as linhas 2 a 5 (ou 6), que computam fatorial, três vezes.
			
 
				+Portanto, o uso de função simplifica o código.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Mas existe uma outra razão para usar funções, que não tão óbvia, a maior facilidade para escrever um programa.
			
 
				+E isso se deve à vários fatores, mas principalmente à quebra de um problema maior em vários menores.
			
 
				+Isso facilita o desenvolvimento e reduz a incidência de erros de programação.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Por exemplo, pode-se implementar a função separadamente, testando-a até que ela fique pronta e sem erros.
			
 
				+Assim, o código fica mais fácil de ser entendido, pois ao usar a função pode-se abstrair, o trecho fica curto (apenas a chamada à função)
			
 
				+e pode-se concentrar em saber se o restante do código está correto.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+  <p class="autoria">
			
 
				+    <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/15: novo formato, pequenas revisões<br/>
			
 
				+    2020/08/09: Sábado, 09 de Agosto 2020, 14:00<br/>
			
 
				+    2020/04/13: Segunda, 13 Abril 2020, 12:30
			
 
				+  </p>
			
 
				+
			
 
				+
			
 
				+</div>
			
--- a/introducao_if.html
+++ b/introducao_if.html
@@ -0,0 +1,469 @@
 
				+
			
 
				+<!--
			
 
				+ Introducao `a Programacao - desde 2017 - Prof. Leo^nidas de Oliveira Branda~o
			
 
				+ Introdução ao comando de seleção e às expressões lógicas
			
 
				+ LInE (Laboratory of Informatics in Education) - http://www.usp.br/line
			
 
				+ IME - USP
			
 
				+ Material dida'tico
			
 
				+ Pode usar livrevemente este material para fins nao comerciais, devendo sempre fazer referencia `a autoria.
			
 
				+ Sugestoes/apontamento são bem vindos: leo@ime.usp.br (favor indicar no assunto "Material de introducao 'a programacao")
			
 
				+ Autoria: Prof. Leo^nidas de Oliveira Branda~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">
			
 
				+
			
 
				+<p class="secao">Introdução ao comando de seleção e às expressões lógicas</p>
			
 
				+
			
 
				+<center><p>[
			
 
				+ <a href="#explog" title="Expressão e valor lógico em C">Expressão em C</a> |
			
 
				+ <a href="#exp-py" title="Expressão e valor lógico em Python">Expressão em Python</a> | 
			
 
				+ <a href="#oper" title="Operadores lógicos">Operadores</a> | 
			
 
				+ <a href="#if-else" title="Comando de seleção">Seleção</a> | 
			
 
				+ <a href="#if-else-varios" title="<i>if-else</i> aninhados">Seleções</a> | 
			
 
				+ <a href="#par-impar" title="decidir se par ou ímpar">Exemplo</a> | 
			
 
				+ <a href="#divint" title="por que par">Par ou ímpar</a>
			
 
				+ ]</p>
			
 
				+</center>
			
 
				+
			
 
				+&nbsp;<br/>
			
 
				+
			
 
				+<p>
			
 
				+<table style="border: 1px solid black;"><tr><td>
			
 
				+<b>Como ler este texto</b>.
			
 
				+Aqui procuro explicar os fundamentos do comando de seleção <tt>if-else</tt> tanto para as linguagens <i>C</i> quanto <i>Python</i>.
			
 
				+Em várias seções apresento os conceitos básicos ilustrando-os em tabelas, com uma coluna ou linha para cada linguagem.
			
 
				+Mas existe uma seção em que apresento o conceito de expressão lógica separandamente, assim, se lhe interessar
			
 
				+apenas uma das linguagens, leia apenas a seção correspondente.
			
 
				+</td></tr></table>
			
 
				+</p>
			
 
				+
			
 
				+&nbsp;<br/>
			
 
				+
			
 
				+<p>
			
 
				+Na seção sobre 
			
 
				+<a href="#" onclick="trocaPagina('introducao_var.html')" title="examinar introducao as variaveis">variáveis</a>, ressaltamos a importância de
			
 
				+poder variar os valores armazenados em determinada posição de memória, por intermédio das <i>variáveis</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Entretanto se não fosse possível executar uma ação específica apenas quando determinada condição ocorrer,
			
 
				+de acordo com o valor de algumas variáveis, não se poderia fazer muito com o computador.
			
 
				+Isso pode ser feito efetuando-se uma conta e verificando se o resultado é nulo ou não, sendo nulo segue-se
			
 
				+determinado "caminho" no código e em caso negativo, segue-se outro (executa outros comando).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Mas a explicação acima está quase ao nível do <i>hardware</i>, portanto <b>baixo-nível</b>.
			
 
				+De um ponto de vista mais elevado (<b>alto-nível</b>), as linguagens de programação como <i>C</i> e <i>Python</i>
			
 
				+dispõem de um comando que permite tal <b>seleção</b> de <b>caminho de execução</b> é o comando <b><tt>if-else</tt></b>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  A figura 1.a e 1.b ilustram o <b style="color:#0000aa;">desvio do fluxo de execução</b> de acordo com o resultado da <b>condição</b>,
			
 
				+  do resultado da <b>condição lógica</b>, se <b style="color:#00aa00;">verdadeiro</b> segue o caminho indicado pela seta com rótulo <b>sim</b> e
			
 
				+  se <b style="color:#00aa00;">falso</b> segue outro.
			
 
				+  Adicionalmente, nota-se que o comando de <i>seleção</i> (ou <i>desvio de fluxo</i>) pode explicitar um caminho para o caso
			
 
				+  da expressão lógica resultar <i>falso</i>, figura 1.b, ou simplesmente apresentar o caminho no caso de <i>verdadeiro</i>, na figura 1.a.
			
 
				+  <center>
			
 
				+    <img src="img/pt_fluxo_se.png" title="Ilustração do desvio de fluxo com comando de seleção sem opção de 'senão'" width="250px"/><!-- 339 x 487 -->
			
 
				+    <img src="img/pt_fluxo_se_senao.png" title="Ilustração do desvio de fluxo com comando de seleção COM opção de 'senão'" width="445px" /><!-- 583 x 422 -->
			
 
				+    <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 name="explog"><span class="subsecao">Expressão lógica em <i>C</i></span></a>
			
 
				+</p>
			
 
				+
			
 
				+<p><!-- <b>Expressões lógicas em <i>C</i></b>-->
			
 
				+Na linguagem <i>C</i>, qualquer expressão (mesmo que aritmética) dentro de abre e fecha parênteses <tt>(...)</tt> é
			
 
				+interpretado como uma <i>expressão lógica</i>, como nos dois exemplos de comandos abaixo:
			
 
				+<center><table><tr><td>
			
 
				+ <pre>if (a==b) <verm>printf</verm>("%d == %d\n", a, b);
			
 
				+while (i &lt; N) { <verm>printf</verm>("i = %d\n", i); i++; }</pre></td></tr></table>
			
 
				+<i>Cód. 1. Exemplos de expressão lógica em <i>C</i></i>.
			
 
				+</center>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Ou seja, o tratamento de expressões é mais um exemplo de que o <i>contexto</i> pode mudar a forma como os dados
			
 
				+são interpretados.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Mas vale a pena notar que a linguagem <i>C</i> permite construções cujo processamento é uma pouco mais rápido, mas menos intuitivo,
			
 
				+é permitido usar qualquer expressão aritmética (como <tt>a-b</tt>) dentro do contexto de expressão lógica!
			
 
				+Isso é possível a partir do seguinte "truque":
			
 
				+ calcula-se o resultado da expressão aritmética,
			
 
				+ se o seu resultado for diferente de <i>0</i>, ele é interpretado como sendo o valor lógico <i>verdeiro</i>,
			
 
				+ caso contrário como <i>falso</i>.
			
 
				+Desse modo, no comando seguinte, sempre que a variável inteira <i>N</i> tiver valor não nulo,
			
 
				+será "impresso" <i>OK</i> e se o valor for nulo será "impresso" <i>NAO</i>:
			
 
				+<center>
			
 
				+  <tt>if (N) <verm>printf</verm>("OK\n"); else <verm>printf</verm>("NAO\n");</tt>.
			
 
				+  <br/>
			
 
				+  <i>Cód. 2. Exemplos de expressão aritmética tratada como expressão lógica em <i>C</i></i>.
			
 
				+</center></p>
			
 
				+
			
 
				+</p>
			
 
				+<b>Negação em <i>C</i></b>. 
			
 
				+Pode-se usar o operador <tt>!</tt> (exclamação) para <i>negar</i> o resultado da expressão lógica (que esteja à sua direita).
			
 
				+Por exemplo, os seguintes trechos de código são equivalentes em <i>C</i>:<br/>
			
 
				+<center><table><tr><td>
			
 
				+ <table><tr><td>
			
 
				+  <tt><!-- varlog = a == b; // ou: varlog = (a == b)<br/>-->
			
 
				+  if (a==b) <verm>printf</verm>("OK");<br/>
			
 
				+  else <verm>printf</verm>("NAO");</tt></td></tr></table></td>
			
 
				+ <td>&nbsp;&nbsp;</td><td style="border-right: solid 1px #000000;"></td><td>&nbsp; &nbsp;</td>
			
 
				+ <td><table><tr><td>
			
 
				+  <tt><!--varlog = (a - b); // ou: varlog = a - b<br/>-->
			
 
				+  if (!(a-b)) <verm>printf</verm>("OK");<br/>
			
 
				+  else <verm>printf</verm>("NAO");</tt></td></tr></table>
			
 
				+  </td></tr></table>
			
 
				+ <i>Cód. 3. Exemplos de uso de negação em expressão lógica em <i>C</i></i>.
			
 
				+ </center>
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+Fica fácil entender a razão dos dois códigos serem equivalente ao observarmos que
			
 
				+<i>a == b</i> é a mesma coisa que <i>a - b == 0</i> e, usando a negação,
			
 
				+<i>a != b</i> é a mesma coisa que <i>a - b != 0</i> e essa última expressão equivale à expressão
			
 
				+<i>!((a - b) == 0)</i> (negar que <i>(a - b) == 0</i>).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Portanto, a expressão <tt>a-b</tt> é interpretada como expressão lógica, do seguinte modo:
			
 
				+seu resultado é <i>verdadeiro</i> se, e somente se <tt>a-b!=0</tt> (<tt>a-b</tt> não nulo),
			
 
				+por isso usamos a negação para inverter o resultado, ou seja, <tt>!(a-b)</tt> equivale a negar <tt>a-b</tt>
			
 
				+(e portanto negar <tt>a-b!=0</tt>).
			
 
				+</p>
			
 
				+
			
 
				+<p><porque>
			
 
				+  <b>Atenção <i>programadores <i>C</i></i></b>, um <b style="color:#aa0000;">erro bastante comum</b> ao tentar
			
 
				+  usar o operador relacional <tt>==</tt> é acabar <b style="color:#aa0000;">digitando apenas <tt>=</tt></b>.
			
 
				+  Em função da explicação acima, não existe qualquer erro sintático, o código será gerado, mas ao rodar, pode
			
 
				+  ser muito difícil detectar esse <b>erro semântico</b>.
			
 
				+  <br/>
			
 
				+  O resultado de um comando como <tt>if (a=b) <verm>printf</verm>("Sao iguais\n");</tt> é que,
			
 
				+  se <tt>a</tt> estiver com qualquer valor diferente de zero, a mensagem será impressa.
			
 
				+  <br/>
			
 
				+  Para descobrir este tipo de erro uma boa técnica é usar 
			
 
				+  <a href="#" onclick="trocaPagina('introducao_depuracao_codigos.html#bandeiras')" title="Examinar texto sobre depuração de código">bandeiras</a>.
			
 
				+</porque></p>
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+<a name="exp-py"><span class="subsecao">Expressão e valor lógicos em <i>Python</i></span></a>
			
 
				+</p>
			
 
				+
			
 
				+<p><!-- <b>Expressões lógicas em <i>Python</i></b>-->
			
 
				+Em <i>Python</i> existem um particular tipo de variável que é <i>booleano</i>, sendo que uma
			
 
				+variável boleana pode ter apenas os valores: <i>True</i> e <i>False</i>.
			
 
				+</p>
			
 
				+
			
 
				+</p>
			
 
				+Assim, uma expressão lógica em <i>Python</i> deve sempre resultar nos valores lógicos
			
 
				+<i>True</i> ou <i>False</i>. Deste modo os três blocos de comandos abaixo podem ser usados e são
			
 
				+equivalente, entretanto o primeiro (mais à esquerda) é mais eficiente:<br/>
			
 
				+<center><table style="font-size:0.8em;"><tr><td>
			
 
				+ <table><tr><td>
			
 
				+  <tt>varlog = a == b <cyan># ou: varlog = (a == b)</cyan><br/>
			
 
				+  if (varlog) : <verm>print</verm>("OK")<br/>
			
 
				+  else : <verm>print</verm>("NAO")</tt></td></tr></table></td>
			
 
				+ <td>&nbsp;&nbsp;</td><td style="border-right: solid 1px #000000;"></td><td>&nbsp;&nbsp;</td>
			
 
				+ <td><table><tr><td>
			
 
				+  <tt>varlog = (a == b) <cyan># ou: varlog = a == b</cyan><br/>
			
 
				+  if (varlog == True) : <verm>print</verm>("OK")<br/>
			
 
				+  else : <verm>print</verm>("NAO")</tt></td></tr></table>
			
 
				+ <td>&nbsp;&nbsp;</td><td style="border-right: solid 1px #000000;"></td><td>&nbsp;&nbsp;</td>
			
 
				+ <td><table><tr><td>
			
 
				+  <tt>varlog = (a == b) <cyan># ou: varlog = a == b</cyan><br/>
			
 
				+  if (not (varlog == False)) : <verm>print</verm>("OK")<br/>
			
 
				+  else : <verm>print</verm>("NAO")</tt></td></tr></table>
			
 
				+  </td></tr></table>
			
 
				+ <i>Cód. 4. Exemplos de uso de negação em expressão lógica em <i>C</i></i>.
			
 
				+</center>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Note que no exemplo acima mais à direita usamos <tt>not (varlog == False)</tt> que equivale a <tt>varlog == True</tt>, que portanto também
			
 
				+equivale a <tt>varlog</tt> (pois está armazenando valore booleanos).
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="oper">
			
 
				+  <p class="secao">Operadores lógicos em <i>C</i> e em <i>Python</i></p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+Os operadores lógicos e relacionais básicos são os mesmo tanto em <i>C</i> quanto em <i>Python</i>.
			
 
				+Os <b>operadores relacionais</b> (<i>relações entre expressões aritméticas</i>) são:
			
 
				+</p>
			
 
				+
			
 
				+<center>
			
 
				+ <i>Tab. 1. Tabela dos operadores relacionais.</i> 
			
 
				+  <table class="tdR">
			
 
				+  <tr><th style="background-color:#8aaada;">Operação</th><th style="background-color:#8aaada;">Operador <th style="background-color:#8aaada;">Exemplo</th></tr>
			
 
				+  <tr><td>iguais        </td><td> ==          <td> n1 == 4                        </td></tr>
			
 
				+  <tr><td>diferentes    </td><td> !=          <td> n1 != 4                        </td></tr>
			
 
				+  <tr><td>maior         </td><td> >           <td> n1 > n2                        </td></tr>
			
 
				+  <tr><td>menor         </td><td> <           <td> n2 < n1                        </td></tr>
			
 
				+  <tr><td>maior ou igual</td><td> >=          <td> n1 >= 3                        </td></tr>
			
 
				+  <tr><td>menor ou igual</td><td> <=          <td> n1 <= 33                       </td></tr>
			
 
				+</table>
			
 
				+</center>
			
 
				+<br/>
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+Os <b>operadores lógicos</b> principais em <i>C</i> e em  <i>Python</i> são
			
 
				+<center>
			
 
				+  <i>Tab. 2. Tabela dos operadores lógicos em <i>C</i> e em <i>Python</i>.</i>
			
 
				+  <table class="tdR" style="border: 1px solid black;">
			
 
				+  <tr><th style="background-color:#8aaada;border-right: 1px solid black;">Operação </th>
			
 
				+    <th style="background-color:#8aaada;border-right: 1px solid black;" colspan="2">Operador </th>
			
 
				+    <th style="background-color:#8aaada;" colspan="2">Exemplo</th></tr>
			
 
				+  <tr><th style="background-color:#8aaada;border-right: 1px solid black;"></th>
			
 
				+    <th style="background-color:#8aaada;align:center;">C</th>
			
 
				+    <th style="background-color:#8aaada;align:center;border-right: 1px solid black;">Python</th>
			
 
				+    <th style="background-color:#8aaada;align:center;">C</th>
			
 
				+    <th style="background-color:#8aaada;align:center;">Python</th></tr>
			
 
				+  <tr><td>conjunção (<tt>e</tt>)         </td><td> &nbsp; &nbsp; && &nbsp; &nbsp;              </td><td>&nbsp; &nbsp;and &nbsp; &nbsp; </td>
			
 
				+      <td> &nbsp; (n1 &gt; 1 && n1 &lt; 10) &nbsp;   </td><td> &nbsp; (n1 &gt; 1 and n1 &lt; 10) &nbsp;    </td></tr>
			
 
				+  <tr><td>disjunção (<tt>ou</tt>)   &nbsp; &nbsp;
			
 
				+                                                     </td><td> &nbsp; &nbsp; || &nbsp; &nbsp;              </td><td>&nbsp; &nbsp; or &nbsp; &nbsp; </td>
			
 
				+     <td> &nbsp; (n1 &gt; 1) || (n1 &lt; 10)  &nbsp; </td><td> &nbsp; (n1 &gt; 1) or (n1 &lt; 10) &nbsp;   </td></tr>
			
 
				+  <tr><td>negação (<tt>não</tt>)         </td><td> &nbsp; &nbsp; !  &nbsp; &nbsp;              </td><td>&nbsp; &nbsp; not &nbsp; &nbsp; </td>
			
 
				+     <td> &nbsp; !(n1 &gt; 1 || n1 &lt; 10) &nbsp;   </td><td> &nbsp; not(n1 &gt; 1 or n1 &lt; 10)  &nbsp; </td></tr>
			
 
				+  </table>
			
 
				+</center>
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="if-else">
			
 
				+  <p class="secao">Comando de seleção <tt>if-else</tt> em <i>C</i> e em <i>Python</i></p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+  O <b>comando de seleção</b> é essencial para qualquer <i>software</i>, é ele que permite que o programa desvie seu fluxo de execução de acordo com
			
 
				+  os valores dos dados (as já citadas <i>variáveis</i>).
			
 
				+  Ele está presente em qualquer linguagem de programação e está baseado no cômputo de uma <i>expressão lógica</i> (<b>EXPLOG</b>),
			
 
				+  se o resultado dela for <i>verdadeiro</i>, o fluxo segue por um "caminho",
			
 
				+  senão segue por outro.
			
 
				+  Essa estrutura está ilustrada na figura abaixo:
			
 
				+  <center>
			
 
				+    <img src="img/comando_selecao_expr_logica.jpg" title="imagem ilustrando fluxo de execucao com comando de selecao" width="400" height="325"/>
			
 
				+    <br/>
			
 
				+    <i>Fig. 2. Diagrama de fluxo de execucação do comando de seleção.</i>    
			
 
				+  </center>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Existem outras duas características de comando de seleção (em qualquer linguagem) que são:
			
 
				+  <ol>
			
 
				+    <li>permitir a execução de comandos mutuamente exclusivo, ou seja, se a expressão lógica resultar verdadeira executa-se determinado comando,
			
 
				+      senão executa-se outro comando ("comando alternativo") - mas a existência do "senão" é opcional;</li>
			
 
				+    <li>possível subordinar mais de uma instrução ao comando "se" ou ao comando "senão", 
			
 
				+      mas cada linguagem tem a sua sintaxe particular para isso (marcadores '{' e '}' em <i>C</i> e alinhamento em <i>Python</i>).</li>
			
 
				+  </ol>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Tanto a linguagem <i>C</i> quanto na linguagem <i>Python</i>, usam as masmas <i>palavras reservadas</i> (palavras que <i>não</i>
			
 
				+  podem ser usados como nomes para variáveis): as palavras <tt>if</tt> e o <tt>else</tt>. A sintaxe de ambas é ilustrada na
			
 
				+  tabela abaixo.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Além disso, as linguagens <i>C</i> e <i>Python</i> permitem que vários comandos (<b>bloco de comandos</b>) sejam subordinados à
			
 
				+  uma seleção.
			
 
				+  Em <i>C</i> deve-se usar abre e fecha chaves (<tt>{...}</tt>) para delimitar os blocos,
			
 
				+  enquanto que na linguagem <i>Python</i> isso é feito com o deslocamento horizontal de linhas, ou seja, com "<b>indentação</b>".
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  A tabela a seguir ilustra a sintaxe do comando de seleção tanto em <i>C</i> quanto em <i>Python</i>:
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<center>
			
 
				+  <i>Tab. 3. Comandos de seleção em <i>C</i> e em <i>Python</i>.</i>
			
 
				+  <table >
			
 
				+  <tr><th style="background-color:#8aaada;border: solid 1px #000000;">Linguagem </th>
			
 
				+    <th style="background-color:#8aaada;border: solid 1px #000000;">Apenas 1 comando </th>
			
 
				+    <th style="background-color:#8aaada;border: solid 1px #000000;">Vários comandos</th></tr>
			
 
				+  <tr><td style="border: solid 1px #000000;">C<br/><br/><br/><br/>     </td>
			
 
				+    <td style="border: solid 1px #000000;"><pre> if (EXPR) comando1;<br/> else comando2;<br/><br/><br/></pre></td>
			
 
				+    <td style="border: solid 1px #000000;"><pre> if (EXPR) { comando1;<br/>   comando2; }<br/> else { comando3;<br/>   comando4; }</pre></td></tr>
			
 
				+  <tr style="border-top:1px solid black;">
			
 
				+    <td style="border: solid 1px #000000;">Python<br/><br/><br/><br/><br/><br/></td>
			
 
				+    <td style="border: solid 1px #000000;"><pre> if (EXPR) : comando1;<br/> else : comando2;<br/><br/><br/><br/><br/></pre></td>
			
 
				+    <td style="border: solid 1px #000000;"><pre> if (EXPR) :<br/>   comando1;<br/>   comando2;<br/> else :<br/>   comando3;<br/>   comando4;</pre></td></tr>
			
 
				+</table></center>
			
 
				+<br/>
			
 
				+
			
 
				+<p>
			
 
				+  Vale destacar que o comando <tt>else</tt> é opcional (como já citado), ou seja, não existindo ação a ser executada caso
			
 
				+  a condição seja falsa, não é necessário usar um <tt>else</tt> com algum comando.
			
 
				+  Assim é correto em <i>C</i> escrever <tt>if (1==1) <verm>printf</verm>("ok");</tt> e
			
 
				+  escrever <tt>if (1==1) : <verm>print</verm>("ok")</tt> em <i>Python</i>. 
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Em <i>Python</i> os parênteses não são obrigatórios em expressões, quer dizer é válido redigir o comando
			
 
				+  <tt>if n1==n2 : comando1</tt> (assim como <tt>if (n1==n2) : comando1</tt>).
			
 
				+  Deste modo para o interpretador <i>Python</i> conseguir traduzir corretamente o comando, lançou-se mão dos dois pontos para indicar final
			
 
				+  de expressão (<tt>if EXPR :</tt>) e no <tt>else</tt>, e por uniformidade, os <tt>:</tt> também é obrigatório no <tt>else :</tt>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Outro item em que <i>C</i> e <i>Python</i> diferem é no modo como indicam a existência de um bloco de comandos
			
 
				+  subordinados a outro comando. Em <i>C</i> utiliza-se abre e fecha chaves, enquanto em <i>Python</i> usa-se a "indentação".
			
 
				+  Experimente em <i>Python</i> eliminar o deslocamento horizontal e deixe, e.g., o <tt>comando1</tt> alinhado com o <tt>if</tt>
			
 
				+  e tente rodar o programa. Você receberá uma mensagem de erro.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="if-else-varios">
			
 
				+  <p class="secao">Comandos de seleção <tt>if-else</tt> aninhados em <i>C</i> e em <i>Python</i></p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+  Em geral, toda linguagem de programação de alto-nível permite que os comandos <tt>if-else</tt> sejam utilizados
			
 
				+  de modo aninhado, ou seja, qualquer dos <tt>comando1</tt> acima podem ser um novo <tt>if-else</tt>. Por exemplo:
			
 
				+  <center>
			
 
				+    <i>Tab. 4. Comandos de seleção aninhados em <i>C</i> e em <i>Python</i>.</i>    
			
 
				+    <table class="tdR">
			
 
				+   <tr><th style="background-color:#8aaada;">Linguagem</th><th style="background-color:#8aaada;">if aninhado</th></tr>
			
 
				+   <tr><td>C<br/><br/><br/><br/><br/>     </td><td>
			
 
				+<pre>if (a&lt;b) { <cyan>// este exemplo nao trata todos os casos...</cyan>
			
 
				+  if (b&lt;c) <verm>printf</verm>("O menor e': %d\n", a);
			
 
				+  }
			
 
				+else if (b&gt;=c)
			
 
				+  <verm>printf</verm>("O maior e': %d\n", a);</pre></td></tr>
			
 
				+   <tr style="border-top:1px solid black;">
			
 
				+      <td>Python<br/><br/><br/><br/> </td> <td>
			
 
				+<pre>if (a&lt;b) : <cyan># este exemplo nao trata todos os casos...</cyan>
			
 
				+  if (b&lt;c) : <verm>print</verm>("O menor e': %d" % a);
			
 
				+elif (b&gt;=c) : <cyan># usar "elif" para economizar "indentacao"</cyan>
			
 
				+  <verm>print</verm>("O maior e': %d" % a);</pre></td></tr>
			
 
				+ </table></center>
			
 
				+<br/>
			
 
				+
			
 
				+  
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Note que a regra para associar um "else" a um "if" é por proximidade (o "else" é associado ao "if" mais próximo),
			
 
				+  e em caso que precisamos que o "else" seja associado a um "if" mais longe, somos obrigados a usar os blocos de comandos.
			
 
				+  Isso está ilustrado nos exemplos acima, o primeiro "else" está associado ao <tt>if (a&lt;b)</tt> e não ao mais "próximo".
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="par-impar">
			
 
				+  <p class="subsecao">Um exemplo para decidir se uma variável inteira armazena um valor par ou ímpar</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+Utilizando a divisão inteira (quer dizer <tt>7/2</tt> resultando <tt>3</tt>) pode-se conseguir determinar se um inteiro
			
 
				+é ou não par. Nos códigos abaixo ilustramos este método, mas note que existe uma diferença sensível entre as versões
			
 
				+<i>Python 2</i> e <i>Python 3</i>, este último obriga o uso de "duas barras" (<tt>//</tt>) para indicar divisão inteira.
			
 
				+Vejamos os códigos abaixo:
			
 
				+</p>
			
 
				+
			
 
				+<center>
			
 
				+  <i>Tab. 5. Exemplo de expressão aritmética em expressão lógica para decidir se valor é par em <i>C</i> e em <i>Python</i>.</i>      
			
 
				+  <table class="tdR">
			
 
				+  <tr><th style="background-color:#8aaada;"><i>C</i></th>
			
 
				+  <th style="background-color:#8aaada;"><i>Python 2</i></th>
			
 
				+  <th style="background-color:#8aaada;"><i>Python 3</i></th></tr>
			
 
				+  <tr>
			
 
				+    <td><pre>if (n1/2*2==n1)
			
 
				+  <verm>printf</verm>("%d eh par\n", n1);
			
 
				+else
			
 
				+  <verm>printf</verm>("%d eh impar\n", n1);</pre></td>
			
 
				+    <td><pre>if (n1/2*2==n1) :
			
 
				+   <verm>print</verm>(n1, " eh par\n")
			
 
				+else :
			
 
				+   <verm>print</verm>(n1, " eh impar\n")</pre></td>
			
 
				+    <td><pre>if (n1//2*2==n1) :
			
 
				+   <verm>print</verm>(n1, " eh par\n")
			
 
				+else :
			
 
				+   <verm>print</verm>(n1, " eh impar\n")</pre>
			
 
				+</td></tr></table></center>
			
 
				+<br/>
			
 
				+
			
 
				+<p>
			
 
				+Mas pode-se obter o mesmo resultado utilizando o operador binário <tt>%</tt> que é "resto da divisão inteira".
			
 
				+Este operador devolve o resto da divisão, por exemplo, <tt>7%2</tt> resulta <tt>1</tt> (o quociente é 
			
 
				+<tt>3</tt>: <tt>3 * 2 + 1 = 7</tt>).
			
 
				+Assim o código fica:
			
 
				+</p>
			
 
				+
			
 
				+<center>
			
 
				+  <i>Tab. 6. Exemplos de comandos para decidir se valor é ímpar ou par em <i>C</i> e em <i>Python</i>.</i>      
			
 
				+  <table class="tdR">
			
 
				+  <tr><th style="background-color:#8aaada;"><i>C</i></th>
			
 
				+  <th style="background-color:#8aaada;"><i>Python</i></th></tr>
			
 
				+  <tr>
			
 
				+    <td><pre>if (n1%2==0)
			
 
				+   <verm>printf</verm>("%d eh par\n", n1);
			
 
				+else
			
 
				+   <verm>printf</verm>("%d eh impar\n", n1);</pre></td>
			
 
				+    <td><pre>if (n1%2==0) :
			
 
				+   <verm>print</verm>(n1, " eh par\n")
			
 
				+else :
			
 
				+   <verm>print</verm>(n1, " eh impar\n")</pre>
			
 
				+</td></tr></table></center>
			
 
				+<br/>
			
 
				+
			
 
				+
			
 
				+<a name="divint">
			
 
				+<p class="subsecao">Mas por que razão "n1/2*2==n1" é suficiente para decidir se n1 é ou não par?</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+Bem, isso é um <i>truque computacional</i> baseado em como o computador interpreta e trata os valores numéricos
			
 
				+de acordo com seu tipo. Quanto todos os valores (variáveis) são inteiros, é utilizada uma aritmética de precisão inteira,
			
 
				+como examinamos ao final da seção sobre
			
 
				+<a href="#" onclick="trocaPagina('introducao_var.html')" title="seguir para o texto sobre variáveis">variáveis e expressões</a>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Lembre-se que em <i>C</i> sempre que fizer divisão entre inteiros o resultado é inteiro (ou seja, <tt>7/2</tt> resulta <tt>3</tt>) e
			
 
				+em <i>Python</i> é análogo, entretanto no <i>Python 3</i> é preciso usar o operador <tt>//</tt> (<tt>7/2</tt> resulta erro, deve-se
			
 
				+usar <tt>7//2</tt>) e no <i>Python 2</i> pode-se usar <tt>7/2</tt> (resultando <tt>3</tt>).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Novamente é o contexto determinando o resultado.
			
 
				+</p>
			
 
				+
			
 
				+  <p class="autoria">
			
 
				+    <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: revisado formato, pequenas correções;<br/>
			
 
				+  2020/08/10: novo formato, pequenas correções;<br/>
			
 
				+  2019/06/06: vários pequenos acertos;<br/>
			
 
				+  2019/01/13: pequenas melhorias de frases e mudanca no CSS<br/>
			
 
				+  2018/04/16: pequenos acertos<br/>
			
 
				+  2018/03/28: melhorado quadro de operadores lógicos <i>C</i> e <i>Python</i>, reescrita a seção "Comandos de seleção ao if-else aninhados em C e em Python"<br/>
			
 
				+  2017/04/14: adicionados novos itens (como <tt>True/False</tt> e <tt>//</tt> do <i>Python</i> e <tt>%</tt> <i>C</i> e <i>Python</i>)
			
 
				+</p>
			
 
				+
			
 
				+</div>
			
--- a/introducao_inteiro_float.html
+++ b/introducao_inteiro_float.html
@@ -0,0 +1,282 @@
 
				+
			
 
				+<!--
			
 
				+ Introducao `a Programacao - desde 2017 - Prof. Leo^nidas de Oliveira Branda~o
			
 
				+ Introdução à conversão inteiro/flutuante e divisões
			
 
				+ LInE (Laboratory of Informatics in Education) - http://www.usp.br/line
			
 
				+ IME - USP
			
 
				+ Material dida'tico
			
 
				+ Pode usar livrevemente este material para fins nao comerciais, devendo sempre fazer referencia `a autoria.
			
 
				+ Sugestoes/apontamento são bem vindos: leo@ime.usp.br (favor indicar no assunto "Material de introducao 'a programacao")
			
 
				+ Autoria: Prof. Leo^nidas de Oliveira Branda~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="declaracao" title="sobre declaracao de variaveis e tipos"
			
 
				+     onclick="frames['iFrame'].document.getElementById('declaracao').scrollIntoView();return false">Declaração</a> &nbsp; | &nbsp;
			
 
				+  <a href="#C" title="conversao entre tipo inteiro-flutuante em C"
			
 
				+     onclick="frames['iFrame'].document.getElementById('C').scrollIntoView();return false">Conversão</a> &nbsp; | &nbsp;
			
 
				+  <a href="#python" title="conversao de tipo inteiro-flutuante em Python"
			
 
				+     onclick="frames['iFrame'].document.getElementById('python').scrollIntoView();return false">Python</a> &nbsp; &nbsp;
			
 
				+ ]</p>
			
 
				+</center>
			
 
				+
			
 
				+
			
 
				+<p class="secao">Introdução à conversão inteiro/flutuante e divisões</p>
			
 
				+
			
 
				+<!-- p>
			
 
				+<b>Alterações</b>:  - .
			
 
				+</p -->
			
 
				+
			
 
				+<p>
			
 
				+  Nesta seção apresentaremos a conversão entre variáveis inteiras e flutuantes, além de destacar como
			
 
				+  obter o quociente e o resto da divisão entre inteiros.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Na seção seguinte apresentamos um resumo sobre variáveis inteiras e flutuantes tanto em <i>C</i> quanto
			
 
				+  em <i>Python</i> e nas duas seções seguintes individualizamos as explicações para cada uma das duas linguagens.
			
 
				+</p>
			
 
				+
			
 
				+<a name="declaracao" id="declaracao"></a>
			
 
				+<span style="color: #0055AA;font-size:1.2em">Declaração de tipo <i>inteiro</i> e <i>flutuante</i> em <i>C</i> e em <i>Python</i></span>
			
 
				+
			
 
				+<p>
			
 
				+  Como o próprio nome diz, uma variável inteira pode representar apenas números inteiros, mas o significado de uma variável
			
 
				+  em <i>ponto flutuante</i> não é tão óbvio, mas simplificadamente, podemos entender que é o tipo de variável que
			
 
				+  permite trabalhar com valores "reais", por exemplo, para podermos armazenar valores como <tt>5/2 = 2.5</tt>.
			
 
				+  As explicações sobre a razão desse tipo de variável ser denotada por <i>ponto flutuante</i> é
			
 
				+  <a href="#" onclick="trocaPagina('introducao_float.html')" title="seguir para explicacao de float">explicada em outro texto</a>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  <span style="color: #0055AA">Variável = posição de memória + tamanho (em <i>bits</i>).</span>
			
 
				+  Como explicado em outros textos, uma variável está associada à determinada posição de memória e à uma quantidade
			
 
				+  conhecida de <i>bits</i>, pois desse modo pode-se interpretar corretamente o valor ali representado.
			
 
				+  Desse modo podemos dizer que cada variável é de um <b>tipo</b> especĩfico, como <i>tipo inteiro</i> ou <i>tipo real/flutuante</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  <span style="color: #0055AA">Definição de tipo.</span>
			
 
				+  Na linguagem <i>Python</i>, o <i>tipo</i> é definido na primeira vez que a variável é interpretada, por exemplo, 
			
 
				+  se ela recebe um valor inteiro, será inteira.
			
 
				+  Já na linguagem <i>C</i>, como é obrigatório declarar todas as variáveis que serão usadas, a associação é feita no momento dé
			
 
				+</p>
			
 
				+
			
 
				+<p><span style="color: #0055AA">Formatador de tipo.</span>
			
 
				+  Para se conseguir registrar um valar digitado pelo usuário ou, inversamente, para se imprimir um valor, deve-se também
			
 
				+  saber como estão organizados os <i>bits</i> associados ao valor, alẽm de saber quantos <i>bits</i> determinada variável usa.
			
 
				+  Ou seja, existe um algoritmo interno para converter os <i>bits</i> para o valor legível (usualmente em decimal).
			
 
				+  Para isso as linguagens <i>C</i> e <i>Python</i>, dispõe de um <i>formatador</i> que indica qual o tipo a ser <b>impresso</b>
			
 
				+  (<i>saída</i>). A linguagem <i>C</i> também precisa desse formatador para a <b>leitura</b> (<i>entrada</i>).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  O <b>formatador para inteiro é o <tt>%d</tt></b> e o <b>formatador para flutuante é o <tt>%f</tt></b>.
			
 
				+  Entretanto não é acusado erro de compilação (<i>C</i>) ou interpretação (<i>Python</i>) se usar um formatador
			
 
				+  errado para imprimir uma variável, embora em <i>C</i> o efeito é desagradável, tanto imprimir inteiro com flutuante,
			
 
				+  quanto imprimir flutuante como inteiro, produz valores "estranhos" (por <i>Python</i> ser mais dinâmico, quase não
			
 
				+  se percebe essa dificuldade de conversão).
			
 
				+  Os demais tipos de variáveis tem outros formatadores.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Nos três exemplos a seguir ilustramos como é a leitura e impressão de variáveis inteiras e flutuantes.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  <b>Exemplo 1 [<i>C</i>]</b>: ler 1 valor inteiro, ler 1 valor "real", imprimir na mesma linha os 2 valores lidos.
			
 
				+  <pre><verm>int</verm> v1; <verm>float</verm> v2; <verd>scanf</verd>("%d %f", &v1. &v2); <verd>printf</verd>("v1=%d, v2=%f\n", v1, v2);</pre>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Na linguagem <i>Python</i> não é necessário declarar as variáveis, mas ao ler um valor é preciso convertê-lo para o tipo
			
 
				+  a ser trabalhado, além disso, em impressões pode-se usar os formatadores para <tt>%d</tt> para inteiro e  <tt>%f</tt> para flutuante.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  <b>Exemplo 2 [<i>Python</i>]</b>: ler 1 valor inteiro, ler 1 valor "real", imprimir em linhas separadas os 2 valores lidos.
			
 
				+  <pre style="font-size:0.8em">v1 = int(<verd>input</verd>()); v2 = float(<verd>input</verd>()); <cyan># ler 2 valores, o primeiro como int, o segundo como float</cyan>
			
 
				+<verd>print</verd>("v1=", v1); <verd>print</verd>("v2=", v2); <cyan># note que neste caso havera uma quebra de linha entre v1 e v2</cyan>
			
 
				+</pre>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  <b>Exemplo 3 [<i>Python</i>]</b>: ler 1 valor inteiro, ler 1 valor "real", imprimir na mesma linha os 2 valores lidos
			
 
				+    (usando diferente técnicas).
			
 
				+  <pre style="font-size:0.8em"><cyan># No Python pode-se imprimir sem mudar de linha usando o parametro ' , end = ""' assim: <verd>print</verd>("Algo ", end = "");</cyan>
			
 
				+<cyan># mas para isso precisa carregar a biblioteca 'print_function' como na linha abaixo</cyan>
			
 
				+from __future__ import print_function <cyan># no Python 3 esta linha e' desnecessaria...</cyan>
			
 
				+
			
 
				+<verm>der</verm> main () : <cyan># declara uma funcao de nome 'main'</cyan>
			
 
				+  v1 = 2; v2 = 5.0; 
			
 
				+  <cyan># Tecnica 1 para imprimir na mesma linha: mais facil</cyan>
			
 
				+  <verd>print</verd>("v1=", v1, "v2=", v2);
			
 
				+
			
 
				+  <cyan># Tecnica 2: o %d e %f indica que ali virao valores 'int' e 'float', respectivamente,</cyan>
			
 
				+  <cyan>#            e o ultimo % indica que a seguir deve vir uma lista com os valores para %d e %f (nessa ordem)</cyan>
			
 
				+  <verd>print</verd>("v1=%d, v2=%f\nxxx" % (v1, v2)); <cyan># dentro das aspas o \n forca uma quebra de linha => o xxx vai para a prox linha</cyan>
			
 
				+
			
 
				+  <cyan># Tecnica 3: permite fazer uma impressao e NAO quebrar a linha, ou seja, o proximo 'print' vai para a mesma linha</cyan>
			
 
				+  <verd>print</verd>("v1=", v1, ", v2=", v2, end = ""); <cyan># o ultimo parametro 'end=""' manda nao quebrar a linha</cyan>
			
 
				+  <verd>print</verd>(" ***");                           <cyan># portanto, esses asteriscos irao para a mesma linha do 'v1= 5, v2= 2'</cyan>
			
 
				+
			
 
				+main(); <cyan># invoque a funcao 'main()'</cyan>
			
 
				+</pre>
			
 
				+</p>
			
 
				+
			
 
				+<a name="C" id="C"></a>
			
 
				+<span style="color: #0055AA;font-size:1.2em">Conversão de tipo em <i>C</i> (inteiro e "real")</span>
			
 
				+
			
 
				+<p>
			
 
				+  Em <i>C</i> é preciso cuidado ao realizar operações com variáveis, por exemplo se realizar uma divisão entre
			
 
				+  variáveis (ou constante) inteiras, o resultado é um valor inteiro, mesmo que a variável armazenando o resultado
			
 
				+  seja "real" (flutuante).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  <b>Exemplo 4</b>: usar variáveis <tt><verm>int</verm> v1</tt> e <tt><verm>float</verm> v2</tt> e fazê-las receber o resultado de <tt>5 / 2</tt>.
			
 
				+  <pre style="font-size:0.8em">#include &lt;stdio.h&gt;
			
 
				+<verm>int</verm> main (void) {
			
 
				+  <verm>int</verm> v1;
			
 
				+  <verm>float</verm> v2;
			
 
				+  v1 = 5/2; <cyan>// como 5 e 2 sao inteiro => faz-se a divisao inteira!</cyan>
			
 
				+  v2 = 5/2; <cyan>// idem! (ou seja, o fato de v2 ser float nao altera o resultado)</cyan>
			
 
				+  <verd>printf</verd>("v1=%d, v2=%f\n", v1, v2); <cyan>// o resultado sera': v1=2, v2=2.000000</cyan>
			
 
				+  return 1; <cyan>// se foi algum outro programa que invocou este, devolva o valor 1</cyan>
			
 
				+  }</pre>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Assim, se o desejado é que <tt>v2</tt> receba o valor <tt>2.5</tt>, então deve-se usar um conversor de tipo
			
 
				+  (<i>type cast</i>), convertendo ou o <tt>5</tt> ou o <tt>2</tt> para <i>float</i>.
			
 
				+  Assim:
			
 
				+  <tt>v2 = (float)5 / 2; <cyan>// ou v2 = 5 / (float) 2</tt>.</cyan>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Agora se o interesse for obter o resto da divisão inteira, não é preciso de um truque "matemático", basta usar o
			
 
				+  operador especial <tt>%</tt>, como indicado no exemplo 5 abaixo.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+  <b>Exemplo 5</b>: um programa para imprimir o resto da divisão inteira entre dois inteiros.
			
 
				+  <pre style="font-size:0.8em">#include &lt;stdio.h&gt;
			
 
				+<verm>int</verm> main (void) {
			
 
				+  <verm>int</verm> v1, v2;
			
 
				+  <verd>scanf</verd>("%d %d", &v1. &v2); <cyan>// solicita que sejam digitados 2 valores inteiros</cyan>
			
 
				+
			
 
				+  <verd>printf</verd>("v1=%d, v2=%f\n", v1, v2); <cyan>// imprime o que foi digitado</cyan>
			
 
				+
			
 
				+  <cyan>// Supondo que foi digitado 5 para v1 e 2 para v2, o proximo 'printf' imprime: resto da divisao entre 5 e 2 e': 1</cyan>
			
 
				+  <verd>printf</verd>("resto da divisao entre %d e %d e': %d\n", v1, v2, v1 % v2); <cyan>// note o "v1 % v2"</cyan>
			
 
				+
			
 
				+  <cyan>// pode-se fazer a impressao ou armazenar o resto da divisao usando constantes</cyan>
			
 
				+  <verd>printf</verd>("%d\n", 5%2); <cyan>// imprime: 1</cyan>
			
 
				+  v1 = 5%2;            <cyan>// v1 recebe o resto da divisao inteira de 5 por 2 (ou seja, recebe 1)</cyan>
			
 
				+  return 1;
			
 
				+  }</pre>
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+
			
 
				+<a name="python" id="python"></a>
			
 
				+<span style="color: #0055AA;font-size:1.2em">Conversão de tipo em <i>Python</i> (inteiro e "real")</span>
			
 
				+
			
 
				+<p>
			
 
				+  Em <i>Python</i> existem vários opções para impressão, mas deve-se tomar cuidado com as variáveis/valores, pois
			
 
				+  dependendo do "tipo", o valor pode ser truncado.
			
 
				+  Outro cuidado que deve-se tomar é que, ao solicitar que o usuário digite um valor numérico, deve-se convertë-lo
			
 
				+  para o tipo desejado.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  <b>Exemplo 6</b>: usar variáveis <tt>v1</tt> e <tt>v2</tt>, a primeira para inteiro (<i>int</i>) e a segunda para "real"
			
 
				+  (ou ponto flutuante, (<i>float</i>)
			
 
				+  e fazê-las receber o resultado de <tt>5 / 2</tt>.
			
 
				+  <pre style="font-size:0.8em"><verm>der</verm> main () :
			
 
				+  v1 = 5/2;         <cyan># o resultado e' 2</cyan>
			
 
				+  v2 = float(5)/2); <cyan># obrigatorio converter um dos operandos para conseguir 2.5 - veja que "float(5/2)" resulta "2.0"</cyan>
			
 
				+
			
 
				+  <cyan># imprimir de modo mais simples</cyan>
			
 
				+  <verd>print</verd>("v1=", v1, "v2=", v2);       <cyan># resultado: v1=2, v2=2.5</cyan>
			
 
				+
			
 
				+  <cyan># agora imprimindo usando formatadores %d e %f e uma lista de valores (v1, v2)</cyan>
			
 
				+  <verd>print</verd>("v1=%d, v2=%d" % (v1, v2));  <cyan># resultado: v1=2, v2=2</cyan>
			
 
				+  <verd>print</verd>("v1=%f, v2=%f" % (v1, v2));  <cyan># resultado: v1=2.000000, v2=2.500000</cyan>
			
 
				+  <verd>print</verd>("v1=%d, v2=%f" % (v1, v2));  <cyan># resultado: v1=2, v2=2.500000</cyan>
			
 
				+main();
			
 
				+</pre>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Note que no exemplo acima, aparece <tt>(v1, v2)</tt> que é uma <b>lista</b> do <i>Python</i>, no caso com dois
			
 
				+  valores numéricos, o primeiro deles será lançado sobre o formatador (no caso o <tt>%d</tt>)
			
 
				+  e o segundo deles irá para o segundo formatador (no caso o <tt>%f</tt>).
			
 
				+</p>
			
 
				+<p>  
			
 
				+  Outra nota deve ser feita sobre o significado dos <i>formatadores</i>, o <tt>%d</tt> prepara uma saída do tipo
			
 
				+  <i>int</i>, enquanto o <tt>%f</tt> é para saída de valores "reais" (na verdade <i>float</i>).
			
 
				+  Assim, mesmo que determinada variável (<tt>v2</tt> no caso) armazene <i>float</i>
			
 
				+  se usar o formatador <tt>%d</tt> será impressa a parte inteira do número (ou seja, ele é <b>truncado</b>).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  No exemplo abaixo, fazemos a leitura de um valor inteiro e de um valor "real".
			
 
				+  Precisamos usar as funções conversoras de tipo <tt>int(...)</tt> e <tt>float(...)</tt>,
			
 
				+  respectivamente para converter os valores lidos para <tt>int</tt> e para <tt>float</tt>, respectivamente.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  <b>Exemplo 7</b>: usar variáveis <tt><verm>int</verm> v1</tt> e <tt><verm>float</verm> v2</tt>.
			
 
				+  <pre style="font-size:0.8em"><verm>der</verm> main () :
			
 
				+  v1 = int(<verd>input</verd>());    <cyan># ler um valor do tipo inteiro</cyan>
			
 
				+  v2 = float(intput()); <cyan># ler um valor do tipo "float"</cyan>
			
 
				+  <verd>print</verd>("v1=%d, v2=%d" % (v1, v2));  <cyan># imprimir assim, o v2 sera' truncado para inteiro</cyan>
			
 
				+  <verd>print</verd>("v1=%d, v2=%f" % (v1, v2));  <cyan># aqui imprime corretamente v1 como "int" e v2 como "float"</cyan>
			
 
				+  <verd>print</verd>("v1=" + str(v1) + ", v2=" + str(v2)); <cyan># pode-se imprimir concatenando "strings" - a funcao "str(...)" converte valor para "string"</cyan>
			
 
				+main();
			
 
				+</pre>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Do mesmo modo que <i>C</i>, a linguagem <i>Python</i> tem um operador que permite obter o resto da divisão inteira,
			
 
				+  que é o operador especial <tt>%</tt>, como indicado no exemplo 8 abaixo.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+  <b>Exemplo 8</b>: um programa para imprimir o resto da divisão inteira entre dois inteiros.
			
 
				+  <pre style="font-size:0.8em"><verm>der</verm> main () :
			
 
				+  v1 = int(<verd>input</verd>());    <cyan># ler um valor do tipo inteiro</cyan>
			
 
				+  v2 = float(intput()); <cyan># ler um valor do tipo "float"</cyan>
			
 
				+  <verd>print</verd>("v1=%d, v2=%d" % (v1, v2));  <cyan># o que foi digitado</cyan>
			
 
				+
			
 
				+  <verd>print</verd>("resto da divisao entre %d e %d e': %d" % (v1, v2, v1 % v2)); <cyan># apos o '%' deve vir uma lista (v1,v2,v1%v2)</cyan>
			
 
				+
			
 
				+main();</pre>
			
 
				+</p>
			
 
				+
			
 
				+  <p class="autoria">
			
 
				+    <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/>
			
 
				+  2019/07/31: redesenhada a estrutura da página e vários pequenas correções;<br/>
			
 
				+  2018/04/02: versão inicial;
			
 
				+</p>
			
 
				+
			
 
				+</div>
			
--- a/introducao_inteiro_impressoes.html
+++ b/introducao_inteiro_impressoes.html
@@ -0,0 +1,186 @@
 
				+<!--
			
 
				+ Introdução à Programação - 2017 - Prof. Leoônidas de Oliveira Brandão
			
 
				+ Introdução à impressão de inteiros em mesma linha
			
 
				+ 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'>
			
 
				+
			
 
				+<div class="pagina">
			
 
				+
			
 
				+<span style="color: #0055AA"><b>Introdução à impressão de inteiros em mesma linha</b></span>
			
 
				+
			
 
				+<!-- p>
			
 
				+<b>Alterações</b>:  - .
			
 
				+</p -->
			
 
				+
			
 
				+<p>
			
 
				+  Nesta seção apresentaremos algumas dicas sobre como imprimir em mesma linha usando diferentes comandos de impressão.
			
 
				+  Também mostraremos como ajustar impressóes de inteiros "automaticamente" à direita (útil para imprimir tabelas).
			
 
				+  Faremos isso separando mas duas seções seguintes, um para 
			
 
				+  <a href="#c" title="ir direto para codigos em C"><i>C</i></a> e outra para
			
 
				+  <a href="#python" title="ir direto para codigos em Python"><i>Python</i></a>.
			
 
				+</p>
			
 
				+
			
 
				+<a name="c">
			
 
				+<hr/>
			
 
				+<span style="color: #0055AA">Impressão de frases e inteiros em <i>C</i></span>
			
 
				+</a>
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+  O comando para impressão em <i>C</i> é o <tt>printf</tt> e para ele funcionar você precisa carregar uma biblioteca
			
 
				+  de <i>cabeçalhos</i>, isso deve ser feitos nas primeiras linhas de seu código com a seguinte linha:
			
 
				+  <pre><tt class="cmd">#include</tt> <tt class="head">&lt;stdlib.h&gt;</tt>
			
 
				+  </pre>
			
 
				+  Deve-se obrigatoriamente digitar como acima, o <tt>#include</tt> é uma diretiva para incluir as definições que
			
 
				+  são encontradas no arquivo de nome <tt>stdlib.h</tt> (ele encontra-se na diretório de seu compilador <i>C</i>).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  A função pré-definida da linguagem <i>C</i> para <b>impressões</b> (saída de dados) é o  <tt class="cmd">printf</tt>.
			
 
				+  O que se deseja imprimir deve estar entre aspas e eventuais variáveis devem estar após esse primeiro <b>parâmetro</b>, após uma
			
 
				+  vírgula, daí pode vir uma lista de variáveis, cada uma deverá ter um <b>formatador</b> correspondente no primeiro parâmetro.
			
 
				+  No exemplo abaixo, existe um código <i>C</i> completo para ilustrar a sintaxe.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  <b>Exemplo 1 [<i>C</i>]</b>: ler 1 valor inteiro e imprimir esse valor.
			
 
				+  <pre><tt class="cmd">#include</tt> <tt class="head">&lt;stdlib.h&gt;</tt>
			
 
				+<tt class="">int main (void) {</tt> <tt class="com">// declaracao da funcao principal - comeca a rodar aqui!</tt>
			
 
				+  <tt class="tipo">int</tt> <tt class="var">n</tt>;
			
 
				+  <tt class="cmd">printf("Digite um valor inteiro: ");</tt>  <tt class="com">// imprime mensagem (e NAO muda de linha)</tt>  
			
 
				+  <tt class="cmd">scanf("%d", &n);</tt> <tt class="com">// 'scanf' e' funcao para entrada de dados, cuja definicao tambem esta no 'stdio.h'</tt>
			
 
				+  <tt class="cmd">printf("Atencao!\nValor digitado = %d\n", n);</tt>  <tt class="com">// imprime "Atencao", quebra a linha, depois o valor digitado e "quebre" a linha</tt>
			
 
				+  }</pre>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  No exemplo acima deve-se notar que o formatador <tt class="tipo">%d</tt> serve para indicar ao compilador <i>C</i> que deve
			
 
				+  produzir instruções para pegar o valor a ser digitado como um inteiro. Esse código executável fica incumbido de agrupar os
			
 
				+  <i>bytes</i> digitados para formar o inteiro correspondente. Geralmente se o usuário usar um espaço em branco, esse
			
 
				+  delimitará o final do inteiro, por exemplo, se ele digitar <tt class="tipo">1032 320</tt> (seguido de <tt class="var">ENTER</tt>)
			
 
				+  então a variável <tt class="var">n</tt> receberá o valor <tt class="var">1032</tt>, sendo o <tt class="var">320</tt> ignorado
			
 
				+  (ou usado como entrada de um <tt class="cmd">scanf</tt> seguinte, se existisse no código).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  No exemplo abaixo ilustramos como imprimir uma tabela com o valor digitado e o seu quadrado.
			
 
				+  Note o uso de um inteiro entre o símbolo <tt class="cmd">%</tt> e a letra <tt class="cmd">d</tt>,
			
 
				+  ele é usado para indicar quantas colunas devem seu usadas para o inteiro, no exemplo usamos 
			
 
				+  <tt class="cmd">%5d</tt> e <tt class="cmd">%6d</tt>, logo o primeiro manda ajudar cinco (5) casas à direita
			
 
				+  e segundo seis casas. Atenção: se o inteiro tiver mais dígitos que o valor (5 ou 6), o ajuste à direita será <b>sem efeito</b>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  <b>Exemplo 2 [<i>C</i>]</b>: ler valores inteiros (não nulos) e imprimir esse valor e o seu quadrado.
			
 
				+  <pre><tt class="cmd">#include</tt> <tt class="head">&lt;stdlib.h&gt;</tt>
			
 
				+<tt class="">int main (void) {</tt>
			
 
				+  <tt class="tipo">int</tt> <tt class="var">n</tt> = 1;
			
 
				+  <tt class="cmd">while</tt> (n!=0) { <tt class="com">// enquanto nao digitar 0, continue...</tt>
			
 
				+    <tt class="cmd">scanf("%d", &n);</tt>
			
 
				+    <tt class="cmd">printf("%5d :: %6d\n", n, n*n);</tt>  <tt class="com">// imprime primiro valor ajustado `a direita 5 casas, o segundo 6 casas</tt>
			
 
				+    }
			
 
				+  }</pre>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Em resumo, na linguagem <i>C</i> é muito simples fazer ou não quebras de linhas em comandos consecutivos:
			
 
				+  para quebrar uma linha deve usar o caractere especial <b><tt class="com">\n</tt></b>.
			
 
				+  Ou seja, se usar o comando <tt class="cmd">printf</tt> sem qualquer <tt class="com">\n</tt>, não haverá "quebra" de linha,
			
 
				+  todas impressões seguirão em uma mesma linha.
			
 
				+</p>
			
 
				+
			
 
				+<br/>
			
 
				+
			
 
				+<a name="python">
			
 
				+<hr/>
			
 
				+<span style="color: #0055AA">Impressão de frases e inteiros em <i>Python</i></span>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+  Na linguagem <i>Python</i> a cada impressão deve existir uma "quebra" de linha, exceto se o programador usar um
			
 
				+  parâmetro adicional <tt class="com">end=""</tt> dentro do comando de impressão.
			
 
				+  Entretanto, se o seu interpretador <i>Python</i> for da versão <b>2</b>, para esse parâmetro funcionar, será necessário uma linha inicial
			
 
				+  em seu código: <tt class="cmd">from __future__ import print_function</tt>.
			
 
				+  Essa linha permite a carga de uma biblioteca especial para impressão.
			
 
				+  Se estiver usando o <i>Python</i> for da versão <b>3</b> isso não é necessário, mas o interpretador não
			
 
				+  reclamará do uso da diretiva de inclusão, coloque sempre essa linha e não receberá advertência de erros!
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  O exemplo abaixo apresentamos um código que solicita que o usuário digite um valor, a ser interpretado como inteiro e imprime uma mensagem
			
 
				+  em duas linhas, na primeira um <tt class="var">Atencao!</tt>, "quebra" a linha (ou seja, pula para uma próxima linha) e 
			
 
				+  na seguinte imprime o valor digitado (com uma mensagem auxiliar).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  <b>Exemplo 1 [<i>Python</i>]</b>: ler 1 valor inteiro e imprimir esse valor.
			
 
				+  <pre><tt class="cmd">from __future__ import print_function</tt> <tt class="com"># Obrigatorio para Python 2 para 'print' sem pular linha</tt>
			
 
				+<tt class="cmd">def</tt> main () :</tt> <tt class="com"># define uma funcao de nome "main"</tt>
			
 
				+  <tt class="cmd">print("Digite um valor inteiro: ", end="");</tt>  <tt class="com"># imprime mensagem (e NAO muda de linha)</tt>
			
 
				+  <tt class="var">n</tt> = <tt class="cmd">int(input());</tt> <tt class="com"># 'input' permite pegar o que foi digitado e a funcao 'int' interpreta os bytes para inteiro</tt>
			
 
				+  <tt class="cmd">print("Atencao!\nValor digitado = %d\n" % n);</tt>  <tt class="com"># imprime "Atencao", quebra a linha e depois o valor digitado</tt>
			
 
				+  <tt class="com"># As linhas abaixo fazem a mesma coisa usando outra sintaxe, mas atencao pode imprimir com apostrofes! ('Atencao!')</tt>
			
 
				+  <tt class="cmd">print("Atencao!");</tt>
			
 
				+  <tt class="cmd">print("Valor digitado = ", n);</tt>  <tt class="com"># note que por nao usarmos o formatador %d NAO precisou do '%', mas de um separador ','!!!</tt>
			
 
				+main(); <tt class="com"># comeca aqui (chama a funcao de nome 'main')</tt></pre>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  No exemplo abaixo ilustramos como imprimir uma tabela com o valor digitado e o seu quadrado.
			
 
				+  Note o uso de um inteiro entre o símbolo <tt class="cmd">%</tt> e a letra <tt class="cmd">d</tt>,
			
 
				+  ele é usado para indicar quantas colunas devem seu usadas para o inteiro, no exemplo usamos 
			
 
				+  <tt class="cmd">%5d</tt> e <tt class="cmd">%6d</tt>, logo o primeiro manda ajudar cinco (5) casas à direita
			
 
				+  e segundo seis casas. Atenção: se o inteiro tiver mais dígitos que o valor (5 ou 6), o ajuste à direita será <b>sem efeito</b>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  <b>Exemplo 2 [<i>Python</i>]</b>: ler valores inteiros (não nulos) e imprimir esse valor e o seu quadrado.
			
 
				+  <pre><tt class="cmd">from __future__ import print_function</tt> <tt class="com"># Obrigatorio para Python 2 para 'print' sem pular linha</tt>
			
 
				+<tt class="">def main () :</tt>
			
 
				+  <tt class="var">n</tt> = 1;
			
 
				+  <tt class="cmd">while</tt> (n!=0) : <tt class="com"># enquanto nao digitar 0, continue...</tt>
			
 
				+    <tt class="var">n</tt> = <tt class="cmd">int(input());</tt>
			
 
				+    <tt class="cmd">print("%5d :: %6d\n" % (n, n*n));</tt>  <tt class="com">// imprime primiro valor ajustado `a direita 5 casas, o segundo 6 casas</tt>
			
 
				+
			
 
				+main();</pre>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Atenção a um "detalhe" do comando de impressão no <i>Python</i>, para usar a impressão de vários valores (sem o "risco" de aparecer
			
 
				+  apóstrofes) deve-se usar os formatadores (<tt class="cmd">%d</tt> para inteiros), como como temos mais que um,
			
 
				+  é necessário o separador <tt class="var">%</tt> e usar os valores como uma lista (<tt class="cmd">(n, n*n))</tt>. 
			
 
				+  Sem isso, imprimiria "estranho" (experimente usar a forma <tt class="cmd">print("%5d :: %6d\n", n, n*n);</tt>).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Em resumo, na linguagem <i>Python</i> sempre que usar o comando <tt class="com">print</tt> sem o parâmetro
			
 
				+  <tt class="com">, end=""</tt>, a próxima impressão sairá na linha seguinte (com "quebra").
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+
			
 
				+<p class="autoria">
			
 
				+ <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/21: novo formato<br/>
			
 
				+  2019/03/25: versão inicial
			
 
				+</p>
			
 
				+
			
 
				+</div>
			
--- a/introducao_inteiros.html
+++ b/introducao_inteiros.html
@@ -0,0 +1,173 @@
 
				+<!--
			
 
				+Introdução aos números inteiros
			
 
				+-->
			
 
				+
			
 
				+  <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">
			
 
				+
			
 
				+
			
 
				+<p class="secao">Introdução aos números inteiros</p>
			
 
				+
			
 
				+<!--
			
 
				+<p>
			
 
				+<b>Alterações</b>: //2017  <i>C</i> e <i>Python</i>)
			
 
				+</p>
			
 
				+-->
			
 
				+
			
 
				+<p>
			
 
				+Nesta seção examinaremos a representação de <i>números inteiros</i> no computador.
			
 
				+</p>
			
 
				+
			
 
				+<a name="bytes"><span style="color: #0050A0">Sequência de <i>bits</i> (e <i>bytes</i>) para representar um inteiro</span></a>
			
 
				+
			
 
				+<p>
			
 
				+Toda informação no computador digital é composta por <i>bits</i>, em
			
 
				+particular todo símbolo ou <b>caractere</b> é representado por um número fixo de <i>bits</i>,
			
 
				+sendo que geralmente usa-se uma quantidade fixa de <i>bits</i> para
			
 
				+representar qualquer caractere, por exemplo, a sequência binária <tt>1000001</tt>
			
 
				+equivale ao caractere <tt>A</tt> ('a' maiúsculo).
			
 
				+Mas o binário <tt>1000001</tt> é correspondente ao número decimal
			
 
				+<!-- <i>2^6+2^0 = 64+1 = 65</i> -->
			
 
				+<i>2<sup>6</sup>+2<sup>0</sup> = 64+1 = 65</i>,
			
 
				+assim o caractere <tt>A</tt> está associado ao número
			
 
				+<tt>65</tt> 
			
 
				+(<a href="#" onclick="trocaPagina('introducao_caracteres.html')" title="examinar o conceito de caracteres">vide explicação sobre código ASCII</a>).
			
 
				+</p>
			
 
				+<!--
			
 
				+1000001 => 1 2^6 + 0 2^5 + 0 2^4 + 0 2^3 + 0 2^2 + 0 2^1 + 1 2^0 = 2^6 + 1 = 64 + 1 = 65
			
 
				+-->
			
 
				+
			
 
				+<a name="umbyte"><span style="color: #0050A0">Quantos inteiros conseguimos com 8 <i>bits</i></span></a>
			
 
				+
			
 
				+<p>
			
 
				+Assim, o número de <i>bits</i> utilizados para representar os inteiros define o intervalo de inteiro que podemos conseguir.
			
 
				+Por exemplo, se dispomos de 8 <i>bits</i>, que é denominado um <b>bytes</b>, podemos conseguir até <i>2<sup>8</sup></i>
			
 
				+diferentes valores, pois podemos usar desde <tt>00000000</tt> até o binário <tt>11111111</tt>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Portanto, se o computador tivesse apenas 8 <i>bits</i> para representar inteiros positivos, poderíamos ter
			
 
				+  desde o <tt>00000000</tt> (correspondendo ao decimal <i>0</i>) até o binário <tt>11111111</tt>,
			
 
				+  que correspondente ao decimal
			
 
				+  <i title="Lembrando: S=r^0+r^1+...+r^n =&gt; rS-S = r^(n+1)-r^0 &gt; S = r^(n+1)-1 / (r-1) "
			
 
				+  >2<sup>0</sup> + 2<sup>1</sup> + 2<sup>2</sup> +  2<sup>3</sup> + 2<sup>4</sup> + 2<sup>5</sup> + 2<sup>6</sup> +
			
 
				+  2<sup>7</sup> = 1+2+4+8+16+32+64+128 = 256-1 = 255</i>.
			
 
				+  <!--  >2^0 + 2^1 + 2^2 +  2^3 + 2^4 + 2^5 + 2^6 + 2^7 = 1+2+4+8+16+32+64+128 = 256-1 = 255 -->
			
 
				+</p>
			
 
				+
			
 
				+<div class="ladoalado">
			
 
				+  <div id="ladoesquerdo">
			
 
				+    <p>
			
 
				+    Mas se precisarmos dos inteiros negativos, poderíamos usar o primeiro <i>bit</i> para o sinal
			
 
				+    (<i>1</i> indicando negativo) ou fazer o complemento binário ("invertendo" os <i>bits</i>).
			
 
				+    No primeiro caso, com os mesmos <i>8</i> <i>bits</i>, poderíamos ir desde <tt>-127</tt>
			
 
				+    (<i>-2<sup>6</sup>-2<sup>5</sup>-...-2<sup>1</sup>-2<sup>0</sup></i>) até
			
 
				+    <tt>127</tt>, mas perderíamos uma entrada (tanto <tt>10000000</tt>, quanto <tt>00000000</tt> poderiam ser associadas ao <i>0</i>).
			
 
				+    Essa associação, que não é utilizada na prática, está ilustrada na terceira coluna da tabela ao lado.
			
 
				+    </p>
			
 
				+    <p>
			
 
				+    A outra opção, denominada <b>complemento de dois</b>, podemos variar de <tt>-128</tt> até <tt>127</tt>, como indicado na segunda
			
 
				+    coluna da tabela ao lado.
			
 
				+    Nessa representação para obter o negativo de um número deve-se aplicar dois passos:
			
 
				+    <ol>
			
 
				+     <li> Inverter os <i>bits</i> do número e depois somar um.<br/>
			
 
				+          <i>Exemplo 1.</i> Para o <i>127</i> cujo binário é <tt>01111111</tt>:
			
 
				+          inverte <tt>10000000</tt> e soma-se um, resultando <tt>10000001</tt> (<i>-127</i>).</br>
			
 
				+          <i>Exemplo 2.</i> Para o <i>126</i> cujo binário é <tt>01111110</tt>:
			
 
				+          inverte <tt>10000001</tt> e soma-se um, resultando <tt>10000010</tt> (<i>-126</i>).</br>
			
 
				+          <i>Exemplo 3.</i> Para o <i>1</i> cujo binário é <tt>00000001</tt>:
			
 
				+          inverte <tt>11111110</tt> e soma-se um, resultando <tt>11111111</tt> (<i>-1</i>).</li>
			
 
				+    </ol>
			
 
				+    Assim, nessa representação existe um negativo a mais, no caso o <i>-128</i>, que é <tt>10000000</tt>, pois
			
 
				+    ao somar <tt>10000000</tt> com <tt>01111111</tt> (que é o decimal <i>127</i>) obtém-se <tt>11111111</tt> que
			
 
				+    é o decimal <i>-1</i> (exemplo 3), ou seja,
			
 
				+    <i>-128 + 127 = -1</i>.
			
 
				+    <center>
			
 
				+     <table>
			
 
				+      <tr><td><tt>01111111</tt></td></tr>
			
 
				+      <tr><td align="right"><tt>       +</tt></td></tr>
			
 
				+      <tr><td><tt>10000000</tt></td></tr>
			
 
				+      <tr><td><tt>--------</tt></td></tr>
			
 
				+      <tr><td><tt>11111111</tt></td></tr>    
			
 
				+     </table>
			
 
				+    </center>
			
 
				+  </div>
			
 
				+
			
 
				+<p>
			
 
				+<p>
			
 
				+  Na tabela 1 apresentamos os binários entre <i>00000000</i> e <i>11111111</i>, mostrando seu correspondente decimal usando
			
 
				+  a técnica de <i>complemento de dois</i> (coluna do meio) e a conversão usual para decimal (coluna da direita).
			
 
				+  Na conversão matemática usual, deve-se usar o valor do <i>bit</i> (<i>digito</i>) multiplicado por sua potência.
			
 
				+  Por exemplo, o primeiro binário <i>00000000</i> é <i>0</i>, pois é <i>0 x 2<sup>k</sup> para todo natural <i>k</i>, por outro
			
 
				+  lado o binário <i>00010011</i> é <i>19</i>, pois é <i>1 x 2<sup>4</sup> + 1 x 2<sup>1</sup> + 1 x 2<sup>0</sup> = 16 + 2 + 1 = 19</i>.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+  <div id="ladodireito">
			
 
				+  <center>
			
 
				+   <i>Tab. 1. Exemplo de números binários e seu correspondente decimal usando <i>complemento de dois</i> e decimal usual</i>
			
 
				+   <br/>
			
 
				+   <table class="tbCodeLinCol trB">
			
 
				+    <tr><th>Número binário</th>
			
 
				+    <th>decimal com sinal (complemento)</th>
			
 
				+    <th>decimal sem sinal</th>
			
 
				+    </tr>
			
 
				+      <tr><td><tt>00000000</tt></td><td><tt>   0</tt></td> <td><tt>  0</tt></td></tr>
			
 
				+          <td><tt>00000001</tt></td><td><tt>   1</tt></td> <td><tt>  1</tt></td></tr>
			
 
				+          <td><tt>00000010</tt></td><td><tt>   2</tt></td> <td><tt>  2</tt></td></tr>
			
 
				+          <td><tt>00000011</tt></td><td><tt>   3</tt></td> <td><tt>  3</tt></td></tr>
			
 
				+          <td><tt>00000100</tt></td><td><tt>   4</tt></td> <td><tt>  4</tt></td></tr>
			
 
				+          <td><tt>00000101</tt></td><td><tt>   5</tt></td> <td><tt>  5</tt></td></tr>
			
 
				+          <td><tt>...</tt></td><td><tt>...</tt></td> <td><tt>  ...</tt></td></tr>
			
 
				+          <td><tt>01111110</tt></td><td><tt> 126</tt></td> <td><tt> 126</tt></td></tr>
			
 
				+          <td><tt>01111111</tt></td><td><tt> 127</tt></td> <td><tt> 127</tt></td></tr>
			
 
				+          <td><tt>10000000</tt></td><td><tt>-128</tt></td> <td><tt> 128</tt></td></tr>
			
 
				+          <td><tt>10000001</tt></td><td><tt>-127</tt></td> <td><tt> 129</tt></td></tr>
			
 
				+          <td><tt>10000010</tt></td><td><tt>-126</tt></td> <td><tt> 130</tt></td></tr>
			
 
				+          <td><tt>10000011</tt></td><td><tt>-125</tt></td> <td><tt> 131</tt></td></tr>
			
 
				+          <td><tt>...</tt></td><td><tt>...</tt></td> <td><tt>  ...</tt></td></tr>	  
			
 
				+          <td><tt>11111101</tt></td><td><tt>  -3</tt></td> <td><tt> 253</tt></td></tr>
			
 
				+          <td><tt>11111110</tt></td><td><tt>  -2</tt></td> <td><tt> 254</tt></td></tr>
			
 
				+          <td><tt>11111111</tt></td><td><tt>  -1</tt></td> <td><tt> 255</tt></td></tr>
			
 
				+   </table>
			
 
				+</center>
			
 
				+</div>
			
 
				+
			
 
				+<br/>&nbsp;<br/>
			
 
				+
			
 
				+<a name="doisbytes"><span style="color: #0050A0">Inteiros com dois <i>bytes</i> (ou 16 <i>bits</i>)</span></a>
			
 
				+<!--
			
 
				+-32 768 a +32 767
			
 
				+-->
			
 
				+
			
 
				+<p>
			
 
				+Claramente <i>8</i> <i>bits</i> (que equivale a um <i><b>byte</b></i>) resulta em um intervalo para trabalho bastante limitado.
			
 
				+Se dobrarmos o número de <i>bits</i>, passando a usar <i>16</i> <i>bits</i>, ou dois <i>bytes</i>,
			
 
				+melhoramos bastante o intervalo de inteiros que podemos usar.
			
 
				+Nesse caso, o número de possibilidades distintas é de <i>2<sup>16</sup>=65536</i>, o que
			
 
				+possibilita os inteiros sem sinal desde o <tt>0</tt> até o <tt>65535</tt>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Considerando inteiros negativos, usando a representação com <i>complemento de dois</i>, conseguimos representar
			
 
				+desde o <i>-32768</i> até o <i>32767</i>.
			
 
				+<!--
			
 
				+https://en.wikipedia.org/wiki/Signed_number_representations
			
 
				+-->
			
 
				+</p>
			
 
				+
			
 
				+  <p class="autoria">
			
 
				+    <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/15: novo formato, pequenas revisões<br/>
			
 
				+  </p>
			
 
				+
			
 
				+</div>
			
--- a/introducao_logica.html
+++ b/introducao_logica.html
@@ -0,0 +1,233 @@
 
				+<!--
			
 
				+Introdução elementar à Lógica
			
 
				+Prof. Leônidas de Oliveira Brandão
			
 
				+Material didático para apoio aos cursos de Introdução à Programação
			
 
				+Direitos reservados
			
 
				+Pode ser usado mediante citação de autoria (Prof. Leônidas de Oliveira Brandão) e origem (https://www.ime.usp.br/~leo/mac2166/introducao/)
			
 
				+-->
			
 
				+
			
 
				+  <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">
			
 
				+
			
 
				+
			
 
				+<p class="secao">Introdução elementar à Lógica</p>
			
 
				+
			
 
				+<p>
			
 
				+  O <a href="#" onclick="trocaPagina('introducao_if.html')" title="examinar o desvio de fluxo de execução: comando 'se'">desvio de fluxo de execução</a>
			
 
				+  é essencial para a construção de algoritmos, esse tipo de comando permite algoritmos cujo "comportamento" é alterado de
			
 
				+  acordo com os
			
 
				+  <a href="#" onclick="trocaPagina('introducao_entrada_saida_dados.html')" title="examinar o que é entrada/saida de dados">dados de entrada</a>.
			
 
				+
			
 
				+  
			
 
				+  Na seção apresento os princípios da lógica <i>booleana</i>, lembrando o que é <i>tabela verdade</i>
			
 
				+  e as leis de De Morgan.
			
 
				+  <!--
			
 
				+  Augustus De Morgan -  27 June 1806 – 18 March 1871 - https://en.wikipedia.org/wiki/Augustus_De_Morgan
			
 
				+  https://www.ime.usp.br/~bianconi/recursos/lo.pdf
			
 
				+  -->
			
 
				+</p>
			
 
				+
			
 
				+<span style="color: #0055AA"><b>Sentenças lógicas e conjuntos</b></span>
			
 
				+
			
 
				+<p>
			
 
				+  A lógica é essencial para a matemática como ciência, ela ajuda a estruturar a linguagem matemática.
			
 
				+  Pode-se considerar cada afirmação matemática como uma sentança lógica, um teorema pode ser visto como uma
			
 
				+  sentença do tipo <i>A implica B</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Existem três operadores básicos para lógica, a
			
 
				+  <b style="color:#0000aa;" title="!A verdade <=> A falso">negação</b>, a
			
 
				+  <b style="color:#0000aa;" title="(A e B) verdade <=> A verdade e B verdade">conjunção</b> e a
			
 
				+  <b style="color:#0000aa;" title="(A ou B) verdade <=> A verdade ou B verdade">disjunção</b>,
			
 
				+  respectivamente os operadores <b>não</b>, <b>e</b> e <b>ou</b>. Seu significado pode ser entendido pelas <b>tabelas verdade</b>, vide tabela 1.
			
 
				+  <br/>
			
 
				+  <i>Nota sobre a linguagem C</i>: os operadores lógicos em <i>C</i> são respectivamente <tt>!</tt>, <tt>&&</tt> e <tt>||</tt>.<br/>
			
 
				+     Exemplo <i>C</i>: <tt>if (!(a>b) && (b&lt;c)) <cyan>// equivale que a<=b e b>c, ou seja, b e' maximo</cyan></tt>.
			
 
				+  <br/>
			
 
				+  <i>Nota sobre a linguagem Python</i>: os operadores lógicos em <i>Python</i> são respectivamente <tt>not</tt>, <tt>and</tt> e <tt>or</tt>.<br/>
			
 
				+     Exemplo <i>Python</i>: <tt>if (!(a>b) && (b&lt;c)) <cyan># equivale que a<=b e b>c, ou seja, b e' maximo</cyan></tt>.  
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  De outra parte, cada sentença lógica pode ser examinada sob o de vista de conjuntos.
			
 
				+  No exemplo <i>A implica B</i>, se entendermos <i>A</i> e <i>B</i> como conjuntos, a implicação indica que
			
 
				+  o conjunto <i>A</i> está contido no conjunto <i>B</i>. Isso está ilustrado na figura <i>1.a</i>, na qual usamos
			
 
				+  <a href="https://pt.wikipedia.org/wiki/Diagrama_de_Venn" title="Estudar diagrama de Venn na WikiPedia" target="_blank"><b>diagrama de Venn</b></a>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Assim a sentença <i>não A</i> pode ser entendida como o complemento do conjunto <i>A</i>, ilustrado na figura <i>1.b</i>.
			
 
				+  E podemos compor as sentenças, por exemplo, criando a sentença <i>não A e B</i>, ou seja, como conjunto, os elementos
			
 
				+  que não estão em <i>A</i> e que simultaneamente estão em <i>B</i>, como ilustrado na figura <i>1.c</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+A figura <i>1.a</i> apresenta o conjunto <i>B</i> (azul mais claro), contendo o conjunto <i>A</i>.
			
 
				+A figura <i>1.b</i> apresenta o <b>complemento</b> ao conjunto <i>A</i> (azul mais claro), ou seja,
			
 
				+os elementos que não estão em <i>A</i>.
			
 
				+A figura <i>1.c</i> mostra a interseção (equivalente à disjunção) entre o complemento ao conjunto <i>A</i> interseção com o conjunto <i>B</i>
			
 
				+(azul mais claro), ou seja, os elementos que estão no complemento de <i>A</i> com aqueles que
			
 
				+estão em <i>B</i>.
			
 
				+<center>
			
 
				+  <img src="img/img_conj_a_contido_b.png" title="imagem ilustrando conjunto A contido no conjunto B"/>
			
 
				+  <img src="img/img_conj_nao_a.png" title="imagem ilustrando conjunto nao A"/>
			
 
				+  <img src="img/img_conj_nao_a_e_b.png" title="imagem ilustrando conjunto nao A e B"/>
			
 
				+  <br/>
			
 
				+  <i title="Representação gráfica para operações com conjuntos">
			
 
				+    Fig. 1. Representação gráfica com conjuntos: (a) A contido em B; (b) complemento de A; e (c) B\A (em B, mas não em A).</i>
			
 
				+</center>
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="explog"><span style="color: #0050A0">Tabela verdade</span></a>
			
 
				+
			
 
				+<p>
			
 
				+  Do ponto de vista da lógica, cada <i>sentença</i> deve ser ou <i>verdadeira</i> ou </i>falsa</i>
			
 
				+  (isto é, pode ocorrer apenas uma das duas opções, sendo um "ou exclusivo").
			
 
				+  Em termos práticos para a <i>programação</i>, o que interessa é a construção de
			
 
				+  <b style="color:#0000aa" title="EL = verdadeiro | falso | não EL | EL e EL | EL ou EL">expressões lógicas (EL)</b>,
			
 
				+  de modo análogo às <i>expressões aritméticas (EA)</i>.
			
 
				+  Assim, a <i>EL</i> mais elementar é aquela com a constante <i>verdadeiro</i> ou <i>falso</i>, como uma <i>EA</i> elementar
			
 
				+  seria um <i>número</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Os operadores lógicos são a <b style="color:#0000aa" title="não A">negação</b> inverte o valor lógico da expressão,
			
 
				+  a <b style="color:#0000aa" title="A e B">conjunção (e)</b> resulta verdadeiro se, e somente se, ambos os operandos são verdadeiro e
			
 
				+  a <b style="color:#0000aa" title="A ou B">disjunção (ou)</b> resulta falso se, e somente se, ambos os itens forem falsos.
			
 
				+  O resultado de cada um desses operadores é dado por sua
			
 
				+  <b style="color:#0000aa" title="Tabela definindo os resultados das operações lógicas">tabela verdade</b>, como indicada abaixo.
			
 
				+  <!-- https://pt.wikipedia.org/wiki/Tabela-verdade -->
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  As tabelas abaixo representam as sentenças das operações básicas <i>não A</i>, <i>A e B</i> e <i>A ou B</i>.
			
 
				+  Simplificaremos escrevendo "verd" para "verdadeiro" (<i>1</i> em <i>C</i> e <i>true</i> em <i>Python</i>) e
			
 
				+  "fals" para "falso" (<i>0</i> em <i>C</i> e <i>false</i> em <i>Python</i>).
			
 
				+  <center>
			
 
				+  <i>Tab. 1. Tabela verdade para (a) negação, para (b) conjunção <i>e</i> e para (c) disjunção <i>ou</i>.</i>
			
 
				+  <table><tr>
			
 
				+    <td>
			
 
				+    <table class="tbCodeLinCol">
			
 
				+     <tr><th>A</th> <th>não A</th></tr>
			
 
				+     <tr><td>verd</td><td>fals</td></tr>
			
 
				+     <tr><td>fals</td><td>verd</td></tr>
			
 
				+    </table></td>
			
 
				+    <td> &nbsp; </td>
			
 
				+    <td>
			
 
				+    <table class="tbCodeLinCol">
			
 
				+     <tr><th>A</th> <th>B</th> <th>A e B</th></tr>
			
 
				+     <tr><td>verd</td><td>verd</td><td>verd</td></tr>
			
 
				+     <tr><td>verd</td><td>fals</td><td>fals</td></tr>
			
 
				+     <tr><td>fals</td><td>verd</td><td>fals</td></tr>
			
 
				+     <tr><td>fals</td><td>fals</td><td>fals</td></tr>
			
 
				+    </table></td>
			
 
				+    <td> &nbsp; </td>
			
 
				+    <td>
			
 
				+    <table class="tbCodeLinCol">
			
 
				+     <tr><th>A</th> <th>B</th> <th>A ou B</th></tr>
			
 
				+     <tr><td>verd</td><td>verd</td><td>verd</td></tr>
			
 
				+     <tr><td>verd</td><td>fals</td><td>verd</td></tr>
			
 
				+     <tr><td>fals</td><td>verd</td><td>verd</td></tr>
			
 
				+     <tr><td>fals</td><td>fals</td><td>fals</td></tr>
			
 
				+    </table></td>
			
 
				+    <td> &nbsp; </td>
			
 
				+    </tr>
			
 
				+  </table>
			
 
				+  </center>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  De modo geral, para cada <i>sentença</i>, ou <i>expressão lógica</i>, pode-se construir sua corresponde <i>tabela-verdade</i>.
			
 
				+  Assim, dada uma <i>sentença</i> formada com <i>k</i> itens lógicos (ou <i>sentenças elementares</i>),
			
 
				+  pode-se fazer uma tabela com <i>k+1</i> colunas, sendo a primeira formada pelo item 1,
			
 
				+  a segunda pelo item 2 e assim por diante.
			
 
				+
			
 
				+  Por exemplo,  e nas demais <i>k=3</i>.
			
 
				+  Por exemplo, se a sentença tem apenas um item (como na tabela 1.(a), <i>k=1</i>), existem <i>2<sup>1</sup></i> linhas e
			
 
				+  na última coluna está precisamente o valor da expressão.
			
 
				+  Se a sentença tiver dois itens (como na tabela 1.(b), <i>k=2</i>), então teremos <i>2<sup>2</sup>=4</i> linhas e o valor lógico
			
 
				+  resultante na última coluna.
			
 
				+  <br/>
			
 
				+  Generalizando, uma <i>expressão lógica</i> com <i>k</i> itens terá (além da linha título) <i>2<sup>k</sup></i> linhas,
			
 
				+  cada linha terá uma das possíveis <i>combinações</i> para os valores <i>verdadeiro</i> ou </i>falso</i> e em sua última
			
 
				+  coluna <i>k+1</i> o resultado da <i>sentença</i> completa.
			
 
				+  <br/>
			
 
				+  Portanto, a tabela terá <i>2<sup>k</sup></i> linhas, cada linha terá uma <i>combinação</i>
			
 
				+  possível para os valores <i>verdadeiro</i> ou </i>falso</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Assim, dada uma sentença formada com <i>k</i> itens lógicos (ou sentenças elementares),
			
 
				+  pode-se fazer uma tabela com <i>k+1</i> colunas, sendo a primeira formada pelo item 1,
			
 
				+  a segunda pelo item 2 e assim por diante. A coluna <i>k+1</i> representa a sentença completa.
			
 
				+  Nesse caso a tabela terá <i>2<sup>k</sup></i> linhas, cada linha terá uma <i>combinação</i>
			
 
				+  possível para os valores <i>verdadeiro</i> ou </i>falso</i>.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+  Note que tanto a disjunção quanto a conjunção são operações comutativas e associativas.
			
 
				+  Comutativas:
			
 
				+    <i>A e B</i> é o mesmo que <i>B e A</i> (produz a mesma tabela verdade);
			
 
				+    <i>A ou B</i> é o mesmo que <i>B ou A</i>.
			
 
				+  Associativas:
			
 
				+    <i>A e (B e C)</i> é o mesmo que <i>(A e B) e C</i>;
			
 
				+    <i>A ou (B ou C)</i> é o mesmo que <i>(A ou B) ou C</i>.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="exp-py"><span style="color: #0050A0">Leis de De Morgan</span></a>
			
 
				+
			
 
				+<p>
			
 
				+  Do mesmo modo que na aritmética podemos compor expressões com diferentes operadores (como '+' e '-'),
			
 
				+  também podemos compor sentenças misturando os três operadores.
			
 
				+  Para isso é interessante perceber que valem as seguintes equivalências, denominadas
			
 
				+  <i><a href="https://en.wikipedia.org/wiki/Augustus_De_Morgan" title="examinar WikiPedia sobre Augustus De Morgan">leis de De Morgan</a></i>:
			
 
				+  <center>
			
 
				+    <b>não (A e B)</b> &equiv; <b>(não A) ou (não B)</b><br/>
			
 
				+    <b>não (A ou B)</b> &equiv; <b>(não A) e (não B)</b><br/>
			
 
				+  </center>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Se não estiver clara a equivalência, monte as tabelas verdade para cada par de sentença e observe que ambas
			
 
				+  produzem os mesmo resultados.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+  Algumas fontes para aprofundamento:
			
 
				+  na <i>WikiPedia</i> examinar os vocábulos
			
 
				+  <a href="https://en.wikipedia.org/wiki/De_Morgan%27s_laws" title="seguir para o vocabulo De_Morgan na WikiPedia em Ingles">
			
 
				+  De_Morgan%27s_laws</a> ou
			
 
				+  <a href="https://pt.wikipedia.org/wiki/Teoremas_de_De_Morgan" title="seguir para o vocabulo De_Morgan na WikiPedia em Portugues">
			
 
				+  Teoremas_de_De_Morgan</a>.
			
 
				+  Se desejar aprofundar o entendimento sobre a linguagem matemática
			
 
				+  pegue a apostila do professor
			
 
				+  <a href="https://www.ime.usp.br/~bianconi/recursos/lo.pdf" title="pegar a apostila sobre logica de Bianconi">
			
 
				+  Ricardo Bianconi</a>.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p class="autoria">
			
 
				+ <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/19: várias pequenas correções, texto da seção "Tabela verdade" completamente reescrito<br/>
			
 
				+  2020/08/15: novo formato, pequenas revisões<br/>
			
 
				+  2020/08/07: revisão geral<br/>
			
 
				+  2018/04/16: primeira versão
			
 
				+</p>
			
 
				+
			
 
				+</div>
			
--- a/introducao_matrizes.html
+++ b/introducao_matrizes.html
@@ -0,0 +1,592 @@
 
				+<!--
			
 
				+ Introdução à Programação - 2017 - Prof. Leoônidas de Oliveira Brandão
			
 
				+ Introdução às matrizes
			
 
				+ 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">
			
 
				+
			
 
				+<p class="secao">Introdução às matrizes</p>
			
 
				+
			
 
				+<center><p>[
			
 
				+  <a href="#sequencia" title="matriz = sequencia contigua de variaveis em memoria">Memória</a> &nbsp; | &nbsp;
			
 
				+  <a href="#parametros" title="matriz como parametro de funcao">Parâmetros</a> &nbsp; | &nbsp;
			
 
				+  <a href="#vetores" title="linha = um vetor">Vetores</a> &nbsp; | &nbsp;
			
 
				+  <a href="#c-python" title="diferencas em C e em Python">C/Python</a> &nbsp; | &nbsp;
			
 
				+  <a href="#C" title="matrizes em C">C</a> &nbsp; | &nbsp;
			
 
				+  <a href="#Python" title="matrizes em Python">Python</a> &nbsp; &nbsp;
			
 
				+ ]</p>
			
 
				+</center>
			
 
				+
			
 
				+<p>
			
 
				+Nesta seção examinaremos resumidamente como utilizar matrizes tanto em <em>C</em> quanto em <em>Python</em>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Da mesma forma que o conceito de <i>vetor</i> é útil quando necessita-se de uma grande quantidade de valores
			
 
				+  associados, todos eles, a um mesmo tipo de dado (como as várias notas de determinado aluno),
			
 
				+  o conceito de <b style="color:#0000aa;">matriz</b> é útil quando naturalmente os dados considerados apresentam
			
 
				+  duas dimensões.
			
 
				+  Um exemplo é quando precisamos processar dados de um grupo de indivíduos (e.g. alunos), cada um deles com várias
			
 
				+  medidas (e.g. notas - vide figura 1).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Também vale a pena destacar que, tanto em <em>C</em> quanto em <em>Python</em>, a implementação de matriz é
			
 
				+  feita por meio de vetor de vetores.
			
 
				+  Desse modelo, em ambas pode-se tratar cada linha como um vetor.
			
 
				+  Por exemplo, se a matriz recebe o nome de <tt>M</tt>, então <tt>M[0]</tt> é sua primeira linha,
			
 
				+  <tt>M[1]</tt> a segunda linha e assim por diante.
			
 
				+  Se for necessário pegar um elemento específico da matriz, deve-se usar dois colcetes, como em
			
 
				+  <tt>M[i][j]</tt>, que devolve o valor da linha <i>i</i> na coluna <i>j</i>
			
 
				+  (e.g. <tt>M[0][0]</tt> devolve o valor da primeira posição da matriz e <tt>M[1][0]</tt> devolve o valor do
			
 
				+  primeiro elemento sua segunda linha).
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="sequencia">
			
 
				+<p class="secao">Matrizes: sequência contígua de variáveis</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+Do ponto de vista computacional a implementação de matrizes segue o princípio dos <i>vetores</i>, uma <i>matriz</i> ocupa
			
 
				+uma porção contígua da memória do computador, servindo para representar o conceito matemático associado.
			
 
				+Lembrando que ao representar um <i>vetor</i> o acesso ao elemento da posição <i>i</i> pode ser feito por meio da sintaxe
			
 
				+<i>vet[i]</i>, no caso de <i>matriz</i> é necessário indicar em qual linha <i>i</i> e em qual coluna <i>j</i> o elemento está,
			
 
				+por exemplo, se a variável tem por nome <i>Mat</i>, usaria <i>Mat[i][j]</i>.
			
 
				+</p>
			
 
				+<p>
			
 
				+Este tipo de estrutura de dados é natural quando os dados apresentam 2 atributos. Por exemplo, em uma sala de aula,
			
 
				+o professor precisa manter informações dos resultados obtidos pelos alunos em várias atividades, assim pode-se utilizar uma
			
 
				+matriz para representar estes dados: as atividades de cada aluno estão em uma única linha da matriz <i>Mat</i>
			
 
				+(e.g., <i>Mat[i][0]</i> é o resultado da atividade <i>0</i> para o aluno <i>i</i>).
			
 
				+</p>
			
 
				+
			
 
				+<center>
			
 
				+  <img src="img/int_mat_representacao.png" title="ilustracao de matriz em memoria"/>
			
 
				+  <br/>
			
 
				+  <i>Fig. 1. Ilustração de como uma matriz é representada na "memória" do computador.</i>
			
 
				+</center>
			
 
				+
			
 
				+<p>
			
 
				+Mas como é possível implementar computacionalmente esse tipo de estrutura?
			
 
				+Na figura acima está representado uma matriz conceitual, com a ideia de alunos e notas, e à direita como estes dados estão
			
 
				+na memória do computador, supondo-se M+1 alunos e N+1 atividades.
			
 
				+Se na representação computacional, o nome da matriz for <i>Mat</i>, então os dados correspondentes ao
			
 
				+<i>aluno 0</i> são: <i>Mat[0][1]</i>, <i>Mat[0][1]</i> e assim por diante até o <i>Mat[0][N]</i>.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="parametros">
			
 
				+<p class="subsecao">Matrizes: como parâmetro de função</p>  
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+Do mesmo modo que vetores, ao passar uma matriz como parâmetro de uma função, este funcionará como <b>parâmetro por referência</b>
			
 
				+(ou por <b>endereço</b>). Ou seja, é passada uma referência ao <i>parâmetro efetivo</i> (em que chamou a função)
			
 
				+de modo que qualquer alteração dentro da função, no <i>parâmetro formal</i>, significará que o valor na matriz
			
 
				+que foi passada como parämetro (no local que chamou a função e portanto o <i>parâmetro efetivo</i>) será alterado.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+Tanto em <em>C</em> quanto em <em>Python</em> as matrizes (e vetores) são passados por referência. O exemplo abaixo ilustra
			
 
				+que alterar os dados de uma matriz dentro de uma função implica em alterar a matriz que lhe foi passada (parâmetro efetivo).
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p><center>
			
 
				+<i>Tab. 1. Matrizes passadas via parâmetro para funções (equivale à uma referência à uma matriz "externa").</i>
			
 
				+<br/>           
			
 
				+<table class="tbCodeLinCol">
			
 
				+ <tr><th colspan="3">Função com computa soma de 2 matrizes em <i>C</i> e em  <i>Python</i> </th> </tr>
			
 
				+ <tr> 
			
 
				+     <th>Exemplo em <i>C</i></th>
			
 
				+     <th>Exemplo em <i>Python</i></th>
			
 
				+ </tr>
			
 
				+ <tr valign="top"><td><table class="tbCode">
			
 
				+   <tr><td><pre><incl1>#include</incl1> &lt;stdio.h&gt;
			
 
				+<def>#define</def> NL 20 <cyan>// constante para maximo de linhas</cyan>
			
 
				+<def>#define</def> NC 20 <cyan>// constante para maximo de colunas</cyan>
			
 
				+<cyan>// Funcao para gerar nova matriz MA + MB</cyan>
			
 
				+<tt class="tipo">void</tt> somaMat (<verm>int</verm> MA[][NC], <verm>int</verm> MB[][NC], <verm>int</verm> MC[][NC], <verm>int</verm> nL, <verm>int</verm> nC) {
			
 
				+  <verm>int</verm> i, j; <cyan>// auxiliar, para indexar os matrizes</cyan>
			
 
				+  <azul>for</azul> (i=0; i&lt; nL; i++)   <cyan>// "Ler" nL x nC valores </cyan>
			
 
				+    <azul>for</azul> (j=0; j&lt; nC; j++) <cyan>// inteiros armazenando-os</cyan>
			
 
				+      MC[i][j] = MA[i][j] + MB[i][j];
			
 
				+  }
			
 
				+<cyan>// Funcao para entrar matriz nL x nC, linha por linha</cyan>
			
 
				+<tt class="tipo">void</tt> lerMatriz (<verm>int</verm> mat[][NC], <verm>int</verm> nL, <verm>int</verm> nC) {
			
 
				+  <verm>int</verm> i,j; <cyan>// declara indices</cyan>
			
 
				+  <azul>for</azul> (i=0; i&lt;nL; i++)   <cyan>// i entre 0 e nL-1</cyan>
			
 
				+    <azul>for</azul> (j=0; j&lt;nC; j++) <cyan>// j entre 0 e nC-1</cyan>
			
 
				+      <tt class="fnc">scanf</tt>("%d", &mat[i][j]);
			
 
				+  }
			
 
				+<cyan>// Funcao para imprimir matriz nL x nC, linha por linha</cyan>
			
 
				+<tt class="tipo">void</tt> imprimeMatriz (<verm>int</verm> mat[][NC], <verm>int</verm> nL, <verm>int</verm> nC) {
			
 
				+  <verm>int</verm> i,j; <cyan>// declara indices</cyan>
			
 
				+  <azul>for</azul> (i=0; i&lt; nL; i++) { <cyan>// i entre 0 e nL-1</cyan>
			
 
				+    <verm>printf</verm>("%2d: ", i); <cyan>// "Imprime" numero desta linha</cyan>
			
 
				+    <azul>for</azul> (j=0; j&lt; nC; j++) <cyan>// j entre 0 e nC-1</cyan>
			
 
				+      <verm>printf</verm>("%3d ", mat[i][j]); <cyan>// em 3 espacos</cyan>
			
 
				+    <verm>printf</verm>("\n"); <cyan>// Mude de linha</cyan>
			
 
				+    }
			
 
				+  }
			
 
				+<verm>int</verm> main (void) {
			
 
				+  <verm>int</verm> i, j; <cyan>// auxiliar, para indexar os matrizes</cyan>
			
 
				+  <verm>int</verm> m, n; <cyan>// tamanho util das matrizes</cyan>
			
 
				+  <verm>int</verm> matA[NL][NC], matB[NL][NC], matC[NL][NC]; <cyan>// Matriz para inteiros (ate' NL*NC elementos)</cyan>
			
 
				+  <tt class="fnc">scanf</tt>("%d %d", &m, &n);
			
 
				+  <verm>printf</verm>("Entra matriz A:\n"); lerMatriz(matA, m, n);
			
 
				+  <verm>printf</verm>("Entra matriz B:\n"); lerMatriz(matB, m, n);
			
 
				+  <verm>printf</verm>("Gera matriz C:\n"); somaMat(matA, matB, matC, m, n); <cyan>// parametros efetivos</cyan>
			
 
				+
			
 
				+  <verm>printf</verm>("Matriz A:\n"); imprimeMatriz(matA, m, n); <cyan>// 'matA' e' parametro efetivo</cyan>
			
 
				+  <verm>printf</verm>("Matriz B:\n"); imprimeMatriz(matB, m, n); <cyan>// aqui e' 'matB'</cyan>
			
 
				+  <verm>printf</verm>("Matriz C:\n"); imprimeMatriz(matC, m, n); <cyan>// aqui e' 'matC'</cyan>
			
 
				+  return 0;
			
 
				+  }</pre></td>
			
 
				+ </table></td>
			
 
				+   <td><pre><incl1>from</incl1> __future__ import print_function; <cyan># imprime sem mudar linha Python 2</cyan>
			
 
				+<cyan># Funcao para gerar nova matriz MA + MB</cyan>
			
 
				+<verm>def</verm> somaMat (MA, MB, nL, nC) :
			
 
				+  MC = []; <cyan># inicia matriz que sera devolvida</cyan>
			
 
				+  linha = []; <cyan># inicia vetor para compor linha de MC</cyan>
			
 
				+  <azul>for</azul> i in range(nL) : <cyan># i varia entre 0 e nL-1</cyan>
			
 
				+    <azul>for</azul> j in range(nC) : <cyan># j varia entre 0 e nC-1</cyan>
			
 
				+      linha.append(MA[i][j] + MB[i][j]); <cyan># novo elemento de "linha"</cyan>
			
 
				+    MC.append(linha); <cyan># para conseguir estrutura adequada</cyan>
			
 
				+  return MC;
			
 
				+<cyan># Funcao para entrar matriz nL x nC, linha por linha</tt> 
			
 
				+<verm>def</verm> lerMatriz (mat, nL, nC) :
			
 
				+  <azul>for</azul> i in range(nL) :
			
 
				+    linha = [];
			
 
				+    <azul>for</azul> j in range(nC) :
			
 
				+      linha.append(<tt class="fnc">input</tt>());
			
 
				+    mat.append(linha);
			
 
				+<cyan># Funcao para imprimir matriz nL x nC, linha por linha</cyan>
			
 
				+<verm>def</verm> imprimeMatriz (mat, nL, nC) :
			
 
				+  <azul>for</azul> i in range(0, nL) : <cyan># i entre 0 e nL-1</cyan>
			
 
				+    <verm>print</verm>("%2d: " % i, end=""); <cyan># "Imprime" numero desta linha</cyan>
			
 
				+    <azul>for</azul> j in range(0, nC) :
			
 
				+      <verm>print</verm>("%3d " % mat[i][j], end=""); <cyan># em 3 espacos</cyan>
			
 
				+    <verm>print</verm>(); <cyan># Mude de linha</cyan>
			
 
				+<verm>def</verm> main () :
			
 
				+  matA = [];
			
 
				+  matB = [];
			
 
				+  linha = <tt class="fnc">raw_input</tt>(); <cyan># ler linha em Python 2 (no 3 usar apenas "input()")</cyan>
			
 
				+  m, n = map(int, linha.split()); <cyan># quebrar entrada em 2 inteiros</cyan>
			
 
				+  <verm>print</verm>("Matriz A:"); lerMatriz(matA, m, n);
			
 
				+  <verm>print</verm>("Matriz B:"); lerMatriz(matB, m, n);
			
 
				+
			
 
				+  matC = somaMat(matA, matB, m, n); <cyan># parametros efetivos</cyan>
			
 
				+
			
 
				+  <verm>print</verm>("Matriz A:"); imprimeMatriz(matA, m, n); <cyan># 'matA' e' parametro efetivo</cyan>
			
 
				+  <verm>print</verm>("Matriz B:"); imprimeMatriz(matB, m, n); <cyan># aqui e' 'matB'</cyan>
			
 
				+  <verm>print</verm>("Matriz C:"); imprimeMatriz(matC, m, n); <cyan># aqui e' 'matC'</cyan>
			
 
				+
			
 
				+main();</pre></td>
			
 
				+   </tr>
			
 
				+   </table></td></tr>
			
 
				+</table></center>
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="vetores">
			
 
				+<p class="subsecao">Matrizes: uma linha equivale a um vetor</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+Uma vez que os elementos em uma linha da matriz estão em posições contíguas da memória, eles podem ser
			
 
				+olhados como um vetor, novamente o <i>contexto</i> determina o significado dos dados.
			
 
				+Assim, se tivermos uma função <i>soma_vetor</i> que recebe como parâmetro um vetor (e sua dimensão) e que gera a soma de seus elementos,
			
 
				+pode-se fazer a seguinte chamada: <i>soma_vetor(mat[i],n)</i>, para qualquer <i>i</i> entre <i>0</i> e <i>M</i> do exemplo acima.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Desse modo, o exemplo abaixo ilustra uma função preparada para somar elementos de um vetor (<tt>soma += vet[i];</tt>) sendo usada para
			
 
				+somar as linhas de uma matriz.
			
 
				+<!--
			
 
				+Vamos supor que no trecho de código que invoca a função <i>soma_vetor</i>, usa-se como <i>parämetro efetivo</i> a linha <i>k</i>
			
 
				+(nesse caso entre <i>0 <u><</u> k <u><</u> M</i>) da matriz <i>mat</i>.-->
			
 
				+Então, na execução do laço dentro função, o comando usando o <i>parâmetro formal</i> <i>soma</i>, <tt>soma += vet[i]</tt> equivalerá
			
 
				+ao código <tt>soma += mat[k][i];</tt> no trecho que invocou a função <i>soma_vetor</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p><center>
			
 
				+<i>Tab. 2. Uma linha de um matriz é na verdade um vetor.</i>
			
 
				+<br/>           
			
 
				+<table class="tbCodeLinCol">
			
 
				+ <tr><th colspan="3">Função de função para somar elementos de vetor sendo usado com linhas de matrizes em <i>C</i> e em  <i>Python</i> </th> </tr>
			
 
				+ <tr> 
			
 
				+     <th>Exemplo em <i>C</i></th>
			
 
				+     <th>Exemplo em <i>Python</i></th>
			
 
				+ </tr>
			
 
				+ <tr valign="top"><td><table class="tbCode">
			
 
				+   <tr><td><pre><incl1>#include</incl1> &lt;stdio.h&gt;
			
 
				+...
			
 
				+<verm>int</verm> soma_vetor (int vet[], int n) {
			
 
				+  <verm>int</verm> i, soma = 0;
			
 
				+  <azul>for</azul> (i=0; i &lt; n; i++)
			
 
				+    soma += vet[i];
			
 
				+  return soma;
			
 
				+  }
			
 
				+<verm>int</verm> main (void) {
			
 
				+  <verm>int</verm> mat[NL][NC]; ...
			
 
				+  ...
			
 
				+    <verm>print</verm>("soma linha %d : %d\n", i, soma_vetor(mat[i], n));
			
 
				+  ...
			
 
				+  return 0;
			
 
				+  }</pre></td>
			
 
				+ </table></td>
			
 
				+   <td><pre><incl1>from</incl1> __future__ import print_function; <cyan># imprime sem mudar linha Python 2</cyan>
			
 
				+<verm>def</verm> soma_vetor (vet, n) :
			
 
				+  soma = 0;
			
 
				+  <azul>for</azul> i in range(n) :
			
 
				+    soma += vet[i];
			
 
				+  return soma;
			
 
				+
			
 
				+<verm>def</verm> main () :
			
 
				+  ...
			
 
				+  <verm>print</verm>("soma linha %d : %d\n" % (i, soma_vetor(mat[i], n)));
			
 
				+  ...
			
 
				+
			
 
				+main();</pre></td>
			
 
				+   </tr>
			
 
				+   </table></td></tr>
			
 
				+</table></center>
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p class="subsecao">Diferença entre linguagem compilada (<i>C</i>) e linguagem interpretada (<i>Python</i>)</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+Uma grande diferença entre as linguagens <i>C</i> e <i>Python</i> é que a primeira é
			
 
				+<b>compilada</b> enquanto a segunda é <b>interpretada</b>.
			
 
				+</p>
			
 
				+
			
 
				+<p>Uma linguagem <b>compilada</b> (como <i>C</i>) implica na existência de um programa (<b>compilador</b>) que traduz o texto do
			
 
				+programa na linguagem referida, gerando um código equivalente em <b>linguagem de máquina</b>. Desse modo, existem dois momentos
			
 
				+muito distintos, o <i>tempo da compilação</i> e o <i>tempo da execução</i>.
			
 
				+Além disso, é preciso que cada "máquina"
			
 
				+(que significa o computador/CPU e o sistema operacional - como o <i>Linux</i>) tenha o compilador para aquela linguagem.
			
 
				+Isso funciona como se traduzir um texto de uma lingua (como Inglês) para outra (como o Português)
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Em uma linguagem <b>interpretada</b> (como <i>Python</i>), existe um
			
 
				+programa executável (para a máquina específica em que roda), que é o <b>interpretador</b> para a linguagem específica
			
 
				+(e.g. <i>Python</i>).
			
 
				+Assim, a tradução e a execução é feita praticamente ao mesmo tempo,
			
 
				+como em uma tradução simultänea de uma conferência em Inglës para o Português.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+  Outra diferença grande entre <i>C</i> e <i>Python</i> é que a primeira é muito mais "estável", sua definição não sofre 
			
 
				+  alterações há anos, enquanto a segunda está em constante mudança.
			
 
				+  Por outro lado, os interpretadores <i>Python</i>, em geral, apresentam uma vasta gama de pacotes integrados,
			
 
				+  trazendo muitos recursos préviamente programadas, facilitando a "vida do programador"
			
 
				+  (e dificultando a dos professores que precisam ficar vetando recursos para poder fazer os aprendizes entenderem que
			
 
				+  tudo foi programada e poderem entender como o básico...).
			
 
				+  <br/>
			
 
				+  Um bom exemplo são os pacotes para tratamento do protocolo <i>HTTP</i>.
			
 
				+  Existem também para <i>C</i> pacotes livres para fazer implementações para serviços <i>Web</i> (usando <i>HTTP</i>), mas
			
 
				+  geralmente eles não estão integrados aos compiladores.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="C">
			
 
				+<p class="subsecao">Matrizes em <i>C</i></p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+Como em <i>C</i> deve-se sempre declarar o tipo da variável, no caso de matriz deve-se declarar seu tipo e seu tamanho.
			
 
				+No exemplo abaixo ilustramos as declarações e uso de matrizes dos tipos básicos <i>int</i>, <i>char</i> e <i>float</i>.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p><center>
			
 
				+<i>Tab. 3. Exemplos de tratamento de matrizes em <i>C</i> (com inteiros, caracteres e "flutuantes").</i>
			
 
				+<br/>           
			
 
				+<table class="tbCodeLinCol">
			
 
				+ <tr><th colspan="3">Matrizes em <i>C</i> </th> </tr>
			
 
				+ <tr> 
			
 
				+     <th>Matriz de inteiros</th>
			
 
				+     <th>Matriz de caracteres</th>
			
 
				+     <th>Matriz de flutuantes</th></tr>
			
 
				+ <tr valign="top"><td><table class="tbCode">
			
 
				+   <tr><td><pre><incl1>#include</incl1> &lt;stdio.h&gt;
			
 
				+<def>#define</def> NL 20 <cyan>// constante para maximo de linhas</cyan>
			
 
				+<def>#define</def> NC 20 <cyan>// constante para maximo de colunas</cyan>
			
 
				+<verm>int</verm> main (void) {
			
 
				+  <verm>int</verm> i, j; <cyan>// auxiliar, para indexar os matrizes</cyan>
			
 
				+  <verm>int</verm> nL, nC; <cyan>// tamanho util das matrizes</cyan>
			
 
				+  <verm>int</verm>  mat[NL][NC]; <cyan>// Matriz para inteiros (ate' NL*NC elementos)</cyan>
			
 
				+  <tt class="fnc">scanf</tt>("%d %d", &nL, &nC);
			
 
				+  <azul>for</azul> (i=0; i&lt; nL; i++)   <cyan>// "Ler" nL x nC valores </cyan>
			
 
				+    <azul>for</azul> (j=0; j&lt; nC; j++) <cyan>// inteiros armazenando-os</cyan>
			
 
				+      <tt class="fnc">scanf</tt>("%d", &mat[i][j]);  <cyan>// na matriz</cyan>
			
 
				+  <azul>for</azul> (i=0; i&lt; nL; i++) { <cyan>// "Imprimir" os nL x nC</cyan>
			
 
				+    <verm>printf</verm>("%2d: ", i); <cyan>// "Imprime" numero desta linha</cyan>
			
 
				+    <azul>for</azul> (j=0; j&lt; nL; j++)   <cyan>// valores inteiros, ajustando</cyan>
			
 
				+      <verm>printf</verm>("%3d ", mat[i][j]); <cyan>// em 3 espacos</cyan>
			
 
				+    <verm>printf</verm>("\n"); <cyan>// Mude de linha</cyan>
			
 
				+    }
			
 
				+  return 0;
			
 
				+  }</pre></td>
			
 
				+ </table></td>
			
 
				+   <td><pre><incl1>#include</incl1> &lt;stdio.h&gt;
			
 
				+<def>#define</def> NL 20 <cyan>// constante para maximo de linhas</cyan>
			
 
				+<def>#define</def> NC 20 <cyan>// constante para maximo de colunas</cyan>
			
 
				+<verm>int</verm> main (void) {
			
 
				+  <verm>int</verm> i, j; <cyan>// auxiliar, para indexar os matrizes</cyan>
			
 
				+  <verm>int</verm> nL, nC; <cyan>// tamanho util dos matrizes</cyan>
			
 
				+  char matC[NL][NC]; <cyan>// Matriz para caracteres</cyan>
			
 
				+  <tt class="fnc">scanf</tt>("%d %d", &nL, &nC);
			
 
				+  <azul>for</azul> (i=0; i&lt; nL; i++)   <cyan>// "Ler" nL x nC valores</cyan>
			
 
				+    <azul>for</azul> (j=0; j&lt; nC; j++) <cyan>// tipo "char" armazenando-os</cyan>
			
 
				+      <tt class="fnc">scanf</tt>("%c", &matC[i][j]);  <cyan>// na matriz</cyan>
			
 
				+  <azul>for</azul> (i=0; i&lt; nL; i++) { <cyan>// "Imprimir" os nL x nC</cyan>
			
 
				+    <verm>printf</verm>("%2d: ", i); <cyan>// "Imprime" numero desta linha</cyan>
			
 
				+    <azul>for</azul> (j=0; j&lt; nC; j++)       <cyan>// valores tipo "char",</cyan>
			
 
				+      <verm>printf</verm>("%2c", matC[i][j]); <cyan>// ajustando em 2 espacos</cyan>
			
 
				+    <verm>printf</verm>("\n"); <cyan>// Mude de linha</cyan>
			
 
				+    }       
			
 
				+  return 0;
			
 
				+  }</pre></td>
			
 
				+   <td><pre><incl1>#include</incl1> &lt;stdio.h&gt;
			
 
				+<def>#define</def> M 20 <cyan>// usado para constante</cyan>
			
 
				+<verm>int</verm> main (void) {
			
 
				+  <verm>int</verm> i, j; <cyan>// auxiliar, para indexar os matrizes</cyan>
			
 
				+  <verm>int</verm> nL, nC; <cyan>// tamanho util dos matrizes</cyan>
			
 
				+  float matF[NL][NC]; <cyan>// Matriz para caracteres</cyan>
			
 
				+  <tt class="fnc">scanf</tt>("%d %d", &nL, &nC);
			
 
				+  <azul>for</azul> (i=0; i&lt; nL; i++)      <cyan>// "Ler" nL x nC valores </cyan>
			
 
				+    <azul>for</azul> (j=0; j&lt; nC; j++)    <cyan>// tipo "char" armazenando-os</cyan>
			
 
				+      <tt class="fnc">scanf</tt>("%f", &matF[i][j]); <cyan>// na matriz</cyan>
			
 
				+  <azul>for</azul> (i=0; i&lt; nL; i++) { <cyan>// "Imprimir" os nL x nC</cyan>
			
 
				+    <verm>printf</verm>("%2d: ", i); <cyan>// "Imprime" numero desta linha</cyan>
			
 
				+    <azul>for</azul> (j=0; j&lt; nC; j++)      <cyan>// valores tipo "float",</cyan>
			
 
				+       <verm>printf</verm>("%5.1f", matF[i][j]); <cyan>// usando 5 esp. e 1 dec.</cyan>
			
 
				+    <verm>printf</verm>("\n"); <cyan>// Mude de linha</cyan>
			
 
				+    }
			
 
				+  return 0;
			
 
				+  }</pre></td></tr>
			
 
				+   </table></td></tr>
			
 
				+</table></center>
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+No <i>C</i> padrão NÃO é possível declarar as dimensões da matriz usando a variável que será usada para
			
 
				+informar o número efetivo de posições "úteis" na matriz, ou seja, <b>não</b> tente fazer algo como:
			
 
				+<tt><font color="#a000">int m, n; float mat[m][n];</font></tt>.
			
 
				+A razão disso é que <i>C</i>, por ser uma linguagem compilada, durante a <b>fase de compilação</b> deve-se reservar o
			
 
				+espaço máximo a ser usado pelo matriz.
			
 
				+Já as variáveis <tt>m</tt> e <tt>n</tt> só serão conhecidas durante a <b>execução</b> do programa.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Apesar de algumas implementações de compiladores <i>C</i> permitirem esse tipo de declarção "dinâmica",
			
 
				+NÃO usem sob pena de seu programa não funcionar em outros compiladores.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Vejamos o exemplo da função <i>soma_vetor</i> sendo chamada com cada linha de uma matriz, com código completo em <i>C</i>.
			
 
				+
			
 
				+<div class="codigo"><pre><cyan>// Exemplo de matriz em Python passando linha em funcao que trabalha com vetor</cyan>
			
 
				+<incl1>#include</incl1> &lt;stdio.h&gt;
			
 
				+
			
 
				+<def>#define</def> MAXL  20 <cyan>// usar no maximo 20 linhas</cyan>
			
 
				+<def>#define</def> MAXC  20 <cyan>// usar no maximo 20 colunas</cyan>
			
 
				+
			
 
				+<verm>int</verm> soma_vet (<verm>int</verm> vet[], <verm>int</verm> n) {
			
 
				+  <verm>int</verm> soma = 0, i;
			
 
				+  <azul>for</azul> (i=0; i&lt;n; i++)
			
 
				+    soma += vet[i];
			
 
				+  return soma;
			
 
				+  }
			
 
				+
			
 
				+<verm>int</verm> main (void) {
			
 
				+  <verm>int</verm> mat[MAXL][MAXC]; <cyan>// declara que existira uma matriz (vetor de vetor)</cyan>
			
 
				+  <verm>int</verm> i, j, m = 3, n = 4; <cyan>// dimensoes fixas por simplicidade</cyan>
			
 
				+  <azul>for</azul> (i=0; i&lt;m; i++) {
			
 
				+    <azul>for</azul> (j=0; j&lt;n; j++) {
			
 
				+      mat[i][j] = i*n + j; <cyan>// como ja' existe espaco reservado atribua "i*m + j" para a posicao linha i e coluna j</cyan>
			
 
				+      <verm>printf</verm>(" %3d", mat[i][j]); <cyan>// imprime sem mudar de linha</cyan>
			
 
				+      }
			
 
				+    <verm>printf</verm>("\n"); <cyan>// muda de linha</cyan>
			
 
				+    }
			
 
				+
			
 
				+  <verm>printf</verm>("Imprime somas das linhas\n");
			
 
				+  <azul>for</azul> (i=0; i&lt;m; i++)
			
 
				+    <verm>printf</verm>("Linha %d tem soma: %3d\n", i, soma_vet(mat[i], n)); <cyan>// %3d ajusta 3 casas 'a direita</cyan>
			
 
				+  return 1;
			
 
				+  }
			
 
				+</pre></div>
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="Python">
			
 
				+<p class="subsecao">Matrizes em <i>Python</i></p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+Em <i>Python</i> pode-se gerar listas de variadas maneiras, a forma sugerida abaixo é gerar uma lista de listas,
			
 
				+sendo que a segunda lista será uma linha da matriz. No código abaixo ilustramos isso.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p class="subsecao">A linha de uma matriz é na verdade um vetor</p>
			
 
				+
			
 
				+<p>
			
 
				+O exemplo abaixo ilustra a declaração e uso de matrizes, ccom os tipos básicos <i>int</i>, <i>char</i> e <i>float</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p><center>
			
 
				+<i>Tab. 4. Exemplos de tratamento de matrizes em <i>Python</i> (com inteiros, caracteres e "flutuantes").</i>
			
 
				+<br/>           
			
 
				+<table class="tbCodeLinCol">
			
 
				+ <tr><th colspan="3">Matrizes em <i>Python</i> </th> </tr>
			
 
				+ <tr> 
			
 
				+     <th>Matriz de inteiros</th>
			
 
				+     <th>Matriz de caracteres</th>
			
 
				+     <th>Matriz de flutuantes</th></tr>
			
 
				+ <tr valign="top"><td><table class="tbCode">
			
 
				+   <tr><td><pre><verm>def</verm> main () :
			
 
				+  nL = int(<tt class="fnc">input</tt>()); nC = int(<tt class="fnc">input</tt>()); <cyan># "Ler" dimensoes nL, nc</cyan>
			
 
				+  mat = []; <cyan># Matriz: iniciar uma lista vazia</cyan>
			
 
				+  <azul>for</azul> i in range(0, nL) :
			
 
				+    linha = [];	<cyan># iniciar lista vazia para a linha atual</cyan>
			
 
				+    <azul>for</azul> j in range(0, nC) : <cyan># ler nI inteiros</cyan>
			
 
				+      linha.append(int(<tt class="fnc">input</tt>())); # anexar mais um elemento</cyan>
			
 
				+     mat.append(linha); <cyan># anexar a linha `a matriz</cyan>
			
 
				+  <cyan># Em Python para imprimir de modo mais "bonito" a matriz,</cyan>
			
 
				+  <cyan># pode-se fazer impressao dos elementos da linha sem "quebre",</cyan>
			
 
				+  <cyan># ou compondo uma "string". Neste exemplo usamos o segundo "truque".</cyan>
			
 
				+  <azul>for</azul> i in range(0, nL) :
			
 
				+    strLinha = ""; <cyan># Truque: compor um "string" com a linha i toda</cyan>
			
 
				+    <azul>for</azul> j in range(0, nC) :
			
 
				+      strLinha += "%3i" % mat[i][j]; <cyan># formatar ajustando 3 pos.</cyan>
			
 
				+    <verm>print</verm>("%2i: " % i + strLinha); <cyan># "Imprimir" a linha i</cyan>
			
 
				+
			
 
				+main();</pre></td>
			
 
				+ </table></td>
			
 
				+   <td><pre><verm>def</verm> main () :
			
 
				+  nL = int(<tt class="fnc">input</tt>()); nC = int(<tt class="fnc">input</tt>()); <cyan># "Ler" dimensoes nL, nc</cyan>
			
 
				+  mat = []; <cyan># Matriz: iniciar uma lista vazia</cyan>
			
 
				+  <azul>for</azul> i in range(0, nL) :
			
 
				+    linha = []; <cyan># iniciar lista vazia para a linha atual</cyan>
			
 
				+    <azul>for</azul> j in range(0, nC) : <cyan># ler nI inteiros</cyan>
			
 
				+      linha.append(<tt class="fnc">raw_input</tt>()); <cyan># anexar mais um elemento</cyan>
			
 
				+    mat.append(linha); # anexar a matriz a linha</cyan>
			
 
				+  <cyan># Nesse exemplo imprimimos usando a biblioteca "print_function"</cyan>
			
 
				+  <cyan># para nao "quebrar" linha entre 2 impressoes.</cyan>
			
 
				+  <azul>for</azul> i in range(0, nL) :
			
 
				+    <verm>print</verm>("%2i: " % i, end=""); <cyan># parametro "end" impede a quebra</cyan>
			
 
				+    <azul>for</azul> j in range(0, nC) :
			
 
				+      <verm>print</verm>("%4c" % mat[i][j], end="");
			
 
				+    <verm>print</verm>(); <cyan># agora "quebre" a linha (final linha i)!</cyan>
			
 
				+
			
 
				+main();</pre></td>
			
 
				+   <td><pre><verm>def</verm> main () :
			
 
				+  nL = int(<tt class="fnc">input</tt>()); nC = int(<tt class="fnc">input</tt>()); <cyan># "Ler" dimensoes nL, nc</cyan>
			
 
				+  mat = []; <cyan># Matriz: iniciar uma lista vazia</cyan>
			
 
				+  <azul>for</azul> i in range(0, nL) :
			
 
				+    linha = []; <cyan># iniciar lista vazia para a linha atual</cyan>
			
 
				+    <azul>for</azul> j in range(0, nC) : <cyan># ler nI inteiros</cyan>
			
 
				+      linha.append(float(<tt class="fnc">input</tt>())); <cyan># anexar mais um elemento</cyan>
			
 
				+    mat.append(linha); <cyan># anexar a matriz a linha</cyan>
			
 
				+  <cyan># Neste exemplo usamos novamente o "truque" de usar</cyan>
			
 
				+  <cyan># "string" para imprimir cada linha da matriz</cyan>
			
 
				+  <azul>for</azul> i in range(0, nL) :
			
 
				+    strLinha = ""; <cyan># Truque para imprimir "por linha"</cyan>
			
 
				+    <azul>for</azul> j in range(0, nC) :
			
 
				+      strLinha += "%5.1f" % mat[i][j]; <cyan># usar 5 espacos, 1 pto dec.</cyan>
			
 
				+    <verm>print</verm>("%2i: " % i + strLinha); <cyan># "Imprimir" esta linhalinha = [];</cyan>
			
 
				+
			
 
				+main();</pre></td>
			
 
				+</tr>
			
 
				+   </table></td></tr>
			
 
				+</table></center>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+No segundo exemplo acima, utilizamos recurso da biblioteca <tt>print_function</tt>, assim
			
 
				+no <i>Python 2</i> é obrigatório incluir esta biblioteca, como indicado nas primeiras linhas
			
 
				+do exemplo abaixo. No caso do <i>Python 3</i> a inclusão é desnecessária.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+O exemplo abaixo ilustra outro conceito importante: cada linha da matriz comporta-se como lista e portanto
			
 
				+pode-se aplicar sobre cada linha da matriz, qualquer função que tenha como parâmetro formal uma lista.
			
 
				+O exemplo será aquele da função <i>soma_vetor</i>, que soma os elementos de um vetor.
			
 
				+
			
 
				+<div class="codigo"><pre><cyan># Exemplo de matriz em Python passando linha em funcao que trabalha com vetor</cyan>
			
 
				+
			
 
				+<cyan># Python2 para 'print' sem pular linha : print("*" , end = "");</cyan>
			
 
				+<incl1>from</incl1> __future__ import print_function
			
 
				+
			
 
				+<verm>def</verm> soma_vet (vet, n) :
			
 
				+  soma = 0;
			
 
				+  <azul>for</azul> i in range(0,n) :
			
 
				+    soma += vet[i];
			
 
				+  return soma;
			
 
				+
			
 
				+mat = []; <cyan># declara que existira uma "lista" (que sera' lista de lista - ou vetor de vetor)</cyan>
			
 
				+m = 3; n = 4; <cyan># dimensoes fixas por simplicidade</cyan>
			
 
				+<azul>for</azul> i in range(0,m) :
			
 
				+  linha = []; <cyan># declara um "lista" (ou vetor) que sera' um linha da matriz 'mat[][]'</cyan>
			
 
				+  <azul>for</azul> j in range(0,n) :
			
 
				+    linha.append(i*n + j); <cyan># equivale a fazer "mat[i][j] = i*m + j" (mas assim resulta erro em Python)</cyan>
			
 
				+    <verm>print</verm>(" %3d" % linha[j], end=""); <cyan># imprime sem mudar de linha</cyan>
			
 
				+  <verm>print</verm>(); <cyan># muda de linha</cyan>
			
 
				+  mat.append(linha); <cyan># define a linha i da matriz (algo como mat[i] = linha)</cyan>
			
 
				+
			
 
				+<verm>print</verm>("Imprime somas das linhas");
			
 
				+<azul>for</azul> i in range(0,m) :
			
 
				+  <verm>print</verm>("Linha %d tem soma: %3d" % (i, soma_vet(mat[i], n))); <cyan># %3d ajusta 3 casas 'a direita</cyan></pre>
			
 
				+</div>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Muita atenção ao método usado para construir a matriz, usando uma
			
 
				+lista auxiliar <tt>linha</tt> e a necessidade de anexar cada linha separadamente (<tt>mat.append(linha);</tt>.
			
 
				+Se isso não está suficientemente claro, sugiro que peguem
			
 
				+<a href="codigos/introducao_matrizes_teste_linhas.py" title="exemplo ilustrativo de construcao de matriz">este exemplo</a>
			
 
				+e "brinquem" com ele, até entendê-lo bem.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Bem, em resumo é isso.</p>
			
 
				+
			
 
				+
			
 
				+  <p class="autoria">
			
 
				+    <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/15: novo formato, pequenas revisões<br/>
			
 
				+    2020/05/18: inserido um código <i>Python</i> explicando como criar matrizes.<br/>
			
 
				+    2019/06/06: vários pequenos acertos ao longo do texto.
			
 
				+    <!-- 201?/??/??: primeira versão. -->
			
 
				+  </p>
			
 
				+
			
 
				+
			
 
				+</div>
			
--- a/introducao_ordenacao.html
+++ b/introducao_ordenacao.html
@@ -0,0 +1,438 @@
 
				+<!--
			
 
				+ Introdução à Programação - 2017 - Prof. Leoônidas de Oliveira Brandão
			
 
				+ Introdução à ordenação
			
 
				+ 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 à ordenação</p>
			
 
				+
			
 
				+<p>
			
 
				+Nesta seção examinaremos os algoritmos mais básicos para ordenação de uma lista de dados (vetores).
			
 
				+Os algoritmos examinados aqui não são eficientes e por isso para aplicações reais usualmente são implementados outros
			
 
				+(como <i>Ordenação Rápida/Quick Sort</i>, <i>Ordenação por Fusão/Merge Sort</i> ou <i>Ordenação por Monte/Heap Sort</i>).
			
 
				+O último a ser examinado (<a href="#insercao" title="metodo da insercao direta">Inserção</a>), é mais eficiente,
			
 
				+principalmente se os dados estiverem "quase-ordenados".
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+O problema é, dada uma sequência de valores (em lista ou vetor), ordenar crescente (ou decrescente) essa sequência.
			
 
				+Por exemplo, na figura abaixo, inicialmente os dados não estão ordenados <tt>{4, 2, 3, 0, 9, 3, 5, 7}</tt>.
			
 
				+Um algoritmo de ordenação que recebesse esse vetor com <tt>n=8</tt> valores, deveria trocar os valores
			
 
				+de posição de modo a conseguir a seguinte situação final para o vetor: <tt>{0, 2, 3, 3, 4, 5, 7, 9}</tt>.
			
 
				+</p>
			
 
				+<center><img src="img/ordenacao_vetor.png" title="vetor nao ordenado acima, abaixo o mesmo em ordem crescente"/>
			
 
				+  <br/>
			
 
				+  <i>Fig. 1. Ilustração dos dados na configuração inicial e na final (já ordenado
			
 
				+  <tt>V[0]<u>&lt;</u>V[1]<u>&lt;</u>...<u>&lt;</u>V[n-1]</tt>).</i><br/>&nbsp;<br/>
			
 
				+</center>
			
 
				+<p>
			
 
				+Para simplificar as explicações fixaremos um nome para o vetor e usaremos a notação <tt>V[i]</tt> para indicar o valor que está na posição <tt>i</tt> do vetor.
			
 
				+Também convencionaremos que a primeira posição do vetor seja <tt>V[0]</tt>, logo um vetor com <i>N</i> elementos terá o último deles na posição <tt>V[N-1]</tt>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Os métodos que examinaremos são os conhecidos:
			
 
				+<i>Método da Bolha (Buble Sort)</i>, <i>Seleção Direta</i> e <i>Inserção Direta</i>.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="bolha">
			
 
				+<p class="secao">Método da Bolha (ou "Pedregulho")</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+A ideia do <b>método da Bolha</b> é inicia comparando os dois últimos elementos, o menor fica à esquerda, então comparar os
			
 
				+dois anteriores e fazer a mesma coisa, desse modo o <b>menor vai movendo-se para cima</b> (como as bolhas).
			
 
				+Mas também podemos fazer o "inverso", seguir empurrando o maior para baixo e assim, poderíamos apelidar essa variante de
			
 
				+<b>método do Pedregulho</b>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Vamos detalhar a primeira fase do <b>método do Pedregulho</b>, nessa fase empurramos o maior do <tt>N</tt> elementos para a última posição.
			
 
				+O primeiro passo é comparar <tt>V[0]</tt> com <tt>V[1]</tt>,
			
 
				+se o valor em <tt>V[0]</tt> for maior que o valor em <tt>V[1]</tt>, troque seus valores (diremos apenas <tt>Se (V[0] &gt; V[1], troque-os</tt>).
			
 
				+O passo 2 é: <tt>Se (V[1] &gt; V[2], troque-os</tt> (logo <tt>V[2]</tt> terá o maior dos 3 primeiros).
			
 
				+O passo 3 é: <tt>Se (V[2] &gt; V[3], troque-os</tt> (logo <tt>V[3]</tt> terá o maior dos 4 primeiros).
			
 
				+Segue comparando 
			
 
				+<tt>V[i]</tt> com <tt>V[i+1]</tt>, até
			
 
				+o passo N-1: <tt>Se (V[N-2] &gt; V[N-1], troque-os</tt> (logo <tt>V[N-1]</tt> terá o maior dos 4 primeiros).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+A figura abaixo ilustra os <i>7</i> primeiros passos, na <b>etapa 1</b>, do algoritmo para levar o maior elemento (considerando <i>N=8</i>) para a posição <i>8</i>.
			
 
				+</p>
			
 
				+
			
 
				+<center><img src="img/ordenacao_vetor_bolha.png" title="primeira fase ordenacao Bolha: empurrar o maior"/>
			
 
				+  <br/>
			
 
				+  <i>Fig. 2. Ilustração do Método do Pedregulho, coluna da esquerda as quatro primeiras "descida" do tipo
			
 
				+  <tt>V[i]<u>&lt;</u>V[i+1]</tt>.</i><br/>
			
 
				+</center>
			
 
				+
			
 
				+<p>
			
 
				+Note que na primeira imagem (acima, esquerda), existem os <i>8</i> na ordem inicial <tt>{4, 2, 3, 0, 9, 3, 5, 7}</tt>.
			
 
				+Cada passo de comparação dos pares de vizinhos está indicado por duas setas sobre os valores a serem comparados.
			
 
				+Na representação seguinte, o vetor é novamente apresentado, eventualmente tendo sido trocados os (se <tt>V[i]&gt;V[i+1]</tt>).
			
 
				+Na passo <i>7</i>, usamos apenas uma seta para indicar que o maior dentre todos os elementos foi para a última posição.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Mas, como o objetivo é ordenar, não apenas descobrir o maior, podemos usar a mesma ideia (de modo <i>indutivo</i>):
			
 
				+aplica-se o mesmo algoritmo (empurrar o maior para a última posição), mas considerando agora apenas os <i>7</i> primeiro elementos,
			
 
				+pois o maior já está na posição <i>8</i>.
			
 
				+Novamente, isso resultará no <i>segundo maior</i> na posição <i>7</i>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Mais uma vez (em geral) o vetor <b>não</b> está ordenado, mas podemos aplicar a mesma ideia mas <i>5</i> vezes:
			
 
				+para <tt>V[0]..V[6]</tt> (maior deles para <tt>V[6]</tt>);
			
 
				+para <tt>V[0]..V[5]</tt> (maior deles para <tt>V[6]</tt>);
			
 
				+para <tt>V[0]..V[4]</tt> (maior deles para <tt>V[6]</tt>);
			
 
				+para <tt>V[0]..V[3]</tt> (maior deles para <tt>V[6]</tt>);
			
 
				+para <tt>V[0]..V[2]</tt> (maior deles para <tt>V[6]</tt>);
			
 
				+para <tt>V[0]..V[1]</tt> (maior deles para <tt>V[1]</tt>).
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Desse modo obtém-se o vetor em ordem crescente! Abaixo apresentamos o algoritmo do <i>Pedregulho (Bolha)</i> em <i>C</i> e em <i>Python</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p><center>
			
 
				+<table class="tbCodeLinCol">
			
 
				+ <tr><th colspan="3">Método de ordenação Bolha/Pedregulo em <i>C</i> e em  <i>Python</i> </th> </tr>
			
 
				+ <tr> 
			
 
				+     <th>Exemplo em <i>C</i></th>
			
 
				+     <th>Exemplo em <i>Python</i></th>
			
 
				+ </tr>
			
 
				+ <tr valign="top"><td><table class="tbCode">
			
 
				+   <tr><td><pre><tt class="com">// Ordena bolha/pedregulho</tt>
			
 
				+<tt class="com">#include</tt> &lt;stdio.h&gt;
			
 
				+<tt class="def">void</tt> imprimir (<tt class="tipo">int</tt> X[], <tt class="tipo">int</tt> n) {
			
 
				+  <tt class="tipo">int</tt> i;
			
 
				+  <tt class="fnc">printf</tt>("(");
			
 
				+  <tt class="cmd">for</tt> (i=0; i&lt;n; i++) <tt class="fnc">printf</tt>("%3d ", X[i]);</tt>
			
 
				+  <tt class="fnc">printf</tt>(")\n");
			
 
				+  }
			
 
				+<tt class="def">void</tt> ordPedregulho (<tt class="tipo">int</tt> V[], <tt class="tipo">int</tt> n) {
			
 
				+  <tt class="tipo">int</tt> i, j, aux;
			
 
				+  <tt class="cmd">for</tt> (i=0; i&lt;n; i++)
			
 
				+    <tt class="cmd">for</tt> (j=0; j&lt;n-i-1; j++)
			
 
				+      <tt class="cmd">if</tt> (V[j]>V[j+1]) { <tt class="com">// troque-os</tt>
			
 
				+        aux = V[j]; <tt class="com">// presevar V[j]</tt>
			
 
				+        V[j] = V[j+1];
			
 
				+        V[j+1] = aux; }
			
 
				+  }
			
 
				+<tt class="tipo">int</tt> main (void) {
			
 
				+  <tt class="tipo">int</tt> Y[] = { 4, 2, 3, 0, 9, 3, 5, 7 }; <tt class="com">// definir vetor dados</tt>
			
 
				+  <tt class="fnc">imprimir</tt>(Y, 8);</tt>
			
 
				+  ordPedregulho(Y, 8);</tt>
			
 
				+  <tt class="fnc">imprimir</tt>(Y, 8);</tt>
			
 
				+  }
			
 
				+   </tr></pre></td>
			
 
				+ </table></td>
			
 
				+   <td><pre><tt class="com"># Ordena bolha/pedregulho</tt>
			
 
				+<tt class="def">from</tt> __future__ import print_function; <tt class="com"># imprime sem mudar linha Python 2</tt>
			
 
				+<tt class="def">def</tt> imprimir (X, n) :
			
 
				+  <tt class="fnc">print</tt>("(", end="");
			
 
				+  <tt class="cmd">for</tt> i in range(n) :
			
 
				+    <tt class="fnc">print</tt>("%3d " % X[i], end="");</tt>
			
 
				+  <tt class="fnc">print</tt>(")");
			
 
				+
			
 
				+<tt class="def">def</tt> ordPedregulho (V, n) :
			
 
				+  <tt class="cmd">for</tt> i in range(n) :</tt>
			
 
				+    <tt class="cmd">for</tt> j in range(n-i-1) :</tt>
			
 
				+      <tt class="cmd">if</tt> (V[j]>V[j+1]) : <tt class="com"># troque-os</tt>
			
 
				+        aux = V[j]; # preservar V[j]</tt>
			
 
				+        V[j] = V[j+1];</tt>
			
 
				+        V[j+1] = aux;</tt>
			
 
				+
			
 
				+<tt class="fnc">def</tt> main () :
			
 
				+  V = [4, 2, 3, 0, 9, 3, 5, 7]; <tt class="com"># definir vetor dados</tt> 
			
 
				+  <tt class="fnc">imprimir</tt>(V,8);</tt>
			
 
				+  ordPedregulho(V, 8);</tt>
			
 
				+  <tt class="fnc">imprimir</tt>(V,8);</tt>
			
 
				+
			
 
				+main();</pre></td>
			
 
				+   </tr>
			
 
				+   </table></td></tr>
			
 
				+</table></center>
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="selecao">
			
 
				+<p class="secao">Método da Seleção Direta</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+A ideia o <b>método da Seleção Direta</b> é novamente deixar na última posição o maior elemento (ou o menor na primeira),
			
 
				+mas diferentemente do método da Bolha, nesse mantém-se fixado o último elemento, comparando-o com o primeiro, com o segundo e
			
 
				+assim por diante.
			
 
				+Considerando novamente um vetor com <i>8</i> elementos, após <i>7</i> comparações (e eventuais trocas), o maior deles estará na posição <i>8</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Esse método está ilustrado na figura abaixo. Na primeira coluna estão os <i>7</i> passos para obter o maior elemento em <tt>V[7]</tt>.
			
 
				+Na coluna 2 estão os <i>6</i> passos para obter o segundo maior para <tt>V[6]</tt>.
			
 
				+Na coluna 3 estão os <i>5</i> passos para obter o terceiro maior para <tt>V[5]</tt> e
			
 
				+na coluna 4 estão os <i>4</i> passos para obter o quarto maior para <tt>V[6]</tt>.
			
 
				+Para finalizar o algoritmo deve-se fazer mais duas sequências de passos (ou <i>laços</i>),
			
 
				+fixando-se o elemento <i>3</i> para obter o 5-ésimo (<i>5=8-3</i>) maior e
			
 
				+fixando-se o elemento <i>2</i> para obter o 6-ésimo (<i>6=8-2</i>) maior.
			
 
				+</p>
			
 
				+
			
 
				+<center><img src="img/ordenacao_vetor_selecao.png" title="primeira fase ordenacao Bolha: empurrar o maior"/>
			
 
				+  <br/>
			
 
				+  <i>Fig. 3. Ilustração do Método da Seleção Direta, coluna da esquerda os primeiros passos (na <b>etapa 1</b>),
			
 
				+  resultando em
			
 
				+  <tt>V[i]<u>&lt;</u>V[n-1]</tt>, <tt>i<u>&lt;</u>n-1</tt> (</tt>n=8</tt>).</i><br/>&nbsp;<br/>
			
 
				+</center>
			
 
				+
			
 
				+<p>
			
 
				+Abaixo está uma implementação do método <i>Seleção Direta</i> em <i>C</i> e em <i>Python</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p><center>
			
 
				+<table class="tbCodeLinCol">
			
 
				+ <tr><th colspan="3">Método de ordenação Bolha/Pedregulo em <i>C</i> e em  <i>Python</i> </th> </tr>
			
 
				+ <tr> 
			
 
				+     <th>Exemplo em <i>C</i></th>
			
 
				+     <th>Exemplo em <i>Python</i></th>
			
 
				+ </tr>
			
 
				+ <tr valign="top"><td><table class="tbCode">
			
 
				+   <tr><td><pre><tt class="com">// Ordena Selecao Direta</tt>
			
 
				+<tt class="com">#include</tt> &lt;stdio.h&gt;
			
 
				+<tt class="def">void</tt> imprimir (<tt class="tipo">int</tt> X[], <tt class="tipo">int</tt> n) {
			
 
				+  <tt class="tipo">int</tt> i;
			
 
				+  <tt class="fnc">printf</tt>("(");
			
 
				+  <tt class="cmd">for</tt> (i=0; i&lt;n; i++) <tt class="fnc">printf</tt>("%3d ", X[i]);</tt>
			
 
				+  <tt class="fnc">printf</tt>(")\n");
			
 
				+  }
			
 
				+<tt class="def">void</tt> ordSelecao (<tt class="tipo">int</tt> V[], <tt class="tipo">int</tt> n) {
			
 
				+  <tt class="tipo">int</tt> i, j, aux;
			
 
				+  <tt class="cmd">for</tt> (i=n-1; i&gt;0; i--)
			
 
				+    <tt class="cmd">for</tt> (j=0; i&lt;i; j++)
			
 
				+      <tt class="cmd">if</tt> (V[j]>V[i]) { <tt class="com">// troque-os</tt>
			
 
				+        aux = V[j]; <tt class="com">// presevar V[j]</tt>
			
 
				+        V[j] = V[i];
			
 
				+        V[i] = aux;
			
 
				+        }
			
 
				+  }
			
 
				+<tt class="tipo">int</tt> main (void) {
			
 
				+  <tt class="tipo">int</tt> Y[] = { 4, 2, 3, 0, 9, 3, 5, 7 }; <tt class="com">// definir vetor dados</tt>
			
 
				+  <tt class="fnc">imprimir</tt>(Y, 8);</tt>
			
 
				+  ordSelecao(Y, 8);</tt>
			
 
				+  <tt class="fnc">imprimir</tt>(Y, 8);</tt>
			
 
				+  }
			
 
				+   </tr></pre></td>
			
 
				+ </table></td>
			
 
				+   <td><pre><tt class="com"># Ordena Selecao Direta</tt>
			
 
				+<tt class="def">from</tt> __future__ import print_function; <tt class="com"># imprime sem mudar linha Python 2</tt>
			
 
				+<tt class="def">def</tt> imprimir (X, n) :
			
 
				+  <tt class="fnc">print</tt>("(", end="");
			
 
				+  <tt class="cmd">for</tt> i in range(n) : 
			
 
				+    <tt class="fnc">print</tt>("%3d " % X[i], end="");</tt>
			
 
				+  <tt class="fnc">printf</tt>(")");
			
 
				+
			
 
				+<tt class="def">def</tt> ordSelecao (V, n) :
			
 
				+  <tt class="cmd">for</tt> i in range(n-1, 0, -1) :</tt>
			
 
				+    <tt class="cmd">for</tt> j in range(i) :</tt>
			
 
				+      <tt class="cmd">if</tt> (V[j]>V[i]) : <tt class="com"># troque-os</tt>
			
 
				+        aux = V[j]; <tt class="com"># preservar V[j]</tt>
			
 
				+        V[j] = V[i];
			
 
				+        V[i] = aux;
			
 
				+
			
 
				+<tt class="fnc">def</tt> main () :
			
 
				+  V = [4, 2, 3, 0, 9, 3, 5, 7]; <tt class="com"># definir vetor dados</tt> 
			
 
				+  <tt class="fnc">imprimir</tt>(V,8);</tt>
			
 
				+  ordSelecao(V, 8);</tt>
			
 
				+  <tt class="fnc">imprimir</tt>(V,8);</tt>
			
 
				+
			
 
				+main();</pre></td>
			
 
				+   </tr>
			
 
				+   </table></td></tr>
			
 
				+</table></center>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Note que os comandos para trocar os conteúdos entre <tt>V[j]</tt> e <tt>V[i]</tt>
			
 
				+(subordinado ao <tt>if (V[j]&gt;V[i])</tt>) poderia ser evitado, bastaria mais duas variáveis auxiliares,
			
 
				+<tt>imax</tt> e <tt>max</tt>, respectivamente, para armazenar o índice do maior valor e o maior valor
			
 
				+(<tt>max = V[imax]</tt>).
			
 
				+Assim, ao final laço <tt>for j</tt> faríamos apenas uma troca (entre <tt>V[i]</tt> e <tt>V[imax]</tt>).
			
 
				+Nessa variante do algoritmo, o número de passos e de comparações é o mesmo, entretanto o número de trocas (geralmente) seria bem menor!
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<a name="insercao">
			
 
				+<p class="secao">Método da Inserção Direta</p>
			
 
				+</a>
			
 
				+
			
 
				+<p>
			
 
				+A ideia o <b>método da Inserção Direta</b> é um pouco diferentes do Bolha e Seleção, naqueles após cada laço interno um elemento maior
			
 
				+ficava em sua posição "definitiva", no Inserção não.
			
 
				+A ideia do <b>Inserção</b> é (na <b>etapa i de ordenação</b>): suponha que <tt>V[0]</tt> até <tt>V[i-1]</tt> esteja ordenado, então podemos estender a ordem
			
 
				+localizando o primeiro elemento, da direita para a esqueda, que <b>não</b> seja maior que <tt>V[i]</tt>, digamos que seja o
			
 
				+<tt>V[j]</tt>, então move-se todos eles uma posição para a sua direita, abrindo a posição <tt>V[j]</tt> para <b>inserir</b> o <tt>V[i]</tt>.
			
 
				+Esse princípio é ilustrado abaixo com <tt>j=3</tt>:
			
 
				+ <table><tr><td> &nbsp; &nbsp; </td> <td>
			
 
				+  1. <tt>V[0]<u>&lt;</u>V[1]<u>&lt;</u>V[2]</tt> odernados;<br/>
			
 
				+  2. <tt>V[3]</tt> libera seu espaço (cópia em <tt>aux</tt>);<br/>
			
 
				+  3. todos os elementos com valor estritamente maior que <tt>aux</tt> "dão um passo para a direita";<br/>
			
 
				+  4. a posição <tt>i=0</tt> é liberada para inserir ali <tt>aux</tt> (estendendo a ordenação para 4 elementos).
			
 
				+  </td>
			
 
				+  <td> &nbsp; &nbsp; <img src="img/ordenacao_vetor_insercao1.png" title="ideia da Insercao Direta"/>
			
 
				+  <br/>
			
 
				+  <i>Fig. 4. Ilustração dos "deslocamentos" para <b>inserir</b> a chave (inicialmente) na posição <tt>V[3]</tt> 
			
 
				+  para a posição correta (<tt>V[0]<u>&lt;</u>V[1]<u>&lt;</u>V[2]<u>&lt;</u>V[3]</tt>.</i>  
			
 
				+  </tr></table>
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+Esse método está ilustrado na figura abaixo. Na primeira coluna estão as <i>3</i> instruções para 
			
 
				+obter uma ordenação com os <i>2</i> primeiros elementos.
			
 
				+Na coluna 2 estão as <i>4</i> instruções para obter ordenação dos <i>4</i> primeiros elementos e
			
 
				+na coluna 3 estão as <i>5</i> instruções para obter ordenação dos <i>5</i> primeiros elementos.
			
 
				+</p>
			
 
				+
			
 
				+<center><img src="img/ordenacao_vetor_insercao2.png" title="os 3 primeiros blocos de passos para ordenacao por Insercao"/>
			
 
				+<br/>
			
 
				+<i>Fig. 5. Ilustração do Inserção Direta: na primeira coluna representa a <b>etapa 1 de ordenação</b> a chave
			
 
				+é o <tt>2</tt> na posição <tt>V[1]</tt>; na segunda a chave
			
 
				+é o <tt>0</tt> na posição <tt>V[3]</tt>.</i><br/>&nbsp;<br/>
			
 
				+</center>
			
 
				+
			
 
				+<p>
			
 
				+É importante notar que se os dados estiverem já ordenados, serão realizadas apenas <tt>n=7</tt> operações!
			
 
				+De modo geral, se a <i>etapa de ordenação i</i> resultar em ordenação completa dos dados, deste ponto em diante,
			
 
				+serão feitas apenas <i>n-i-1</i> comparações e nenhuma troca (!).
			
 
				+Pode-se usar uma 
			
 
				+<a href="#" onclick="trocaPagina('introducao_depuracao_codigos.html#bandeiras')" title="ver conceito de bandeiras">bandeira</a>
			
 
				+para identificar tal fato e finalizar o algoritmo.
			
 
				+<br/>
			
 
				+Por exemplo, na última coluna da figura 5, se o valor em <tt>V[4]</tt> fosse <tt>5</tt> (ou qualquer outro valor maior),
			
 
				+haveria apenas três instruções (independe do valor <i>5</i>):
			
 
				+copiar <tt>V[3]</tt> para <tt>aux</tt>,
			
 
				+comparar <tt>aux</tt> com <tt>V[2]</tt> e, como <tt>aux</tt> é maior (ou igual), finalizaria,
			
 
				+copiando <tt>aux</tt> novamente para <tt>V[3]</tt>.
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+Abaixo está uma implementação do método <i>Inserção Direta</i> em <i>C</i> e em <i>Python</i>.
			
 
				+</p>
			
 
				+
			
 
				+<p><center>
			
 
				+<table class="tbCodeLinCol">
			
 
				+ <tr><th colspan="3">Método de ordenação Inserção Direta em <i>C</i> e em  <i>Python</i> </th> </tr>
			
 
				+ <tr> 
			
 
				+     <th>Exemplo em <i>C</i></th>
			
 
				+     <th>Exemplo em <i>Python</i></th>
			
 
				+ </tr>
			
 
				+ <tr valign="top"><td><table class="tbCode">
			
 
				+   <tr><td><pre><tt class="com">// Ordena Insercao Direta</tt>
			
 
				+<tt class="com">#include</tt> &lt;stdio.h&gt;
			
 
				+<tt class="def">void</tt> imprimir (<tt class="tipo">int</tt> X[], <tt class="tipo">int</tt> n) {
			
 
				+  <tt class="tipo">int</tt> i;
			
 
				+  <tt class="fnc">printf</tt>("(");
			
 
				+  <tt class="cmd">for</tt> (i=0; i&lt;n; i++) <tt class="fnc">printf</tt>("%3d ", X[i]);</tt>
			
 
				+  <tt class="fnc">printf</tt>(")\n");
			
 
				+  }
			
 
				+<tt class="def">void</tt> ordInsercao (<tt class="tipo">int</tt> V[], <tt class="tipo">int</tt> n) {
			
 
				+  <tt class="tipo">int</tt> i, j, aux;
			
 
				+  <tt class="cmd">for</tt> (i=1; i&lt;n; i++) {
			
 
				+    aux = V[i]; <tt class="com">// "abrir espaco" copiando V[i]</tt>
			
 
				+    j = i-1;
			
 
				+    <tt class="cmd">while</tt> (j &gt; -1 && V[j] &gt; aux) { <tt class="com">// mova para direita os maiores que aux</tt>
			
 
				+      V[j+1] = V[j]; <tt class="com">// mover para direita V[j]</tt>
			
 
				+      j -= 1;
			
 
				+      }
			
 
				+    V[j+1] = aux; <tt class="com">// coloque aux na posicao correta</tt>
			
 
				+    }
			
 
				+  }
			
 
				+<tt class="tipo">int</tt> main (void) {
			
 
				+  <tt class="tipo">int</tt> Y[] = { 4, 2, 3, 0, 9, 3, 5, 7 }; <tt class="com">// definir vetor dados</tt>
			
 
				+  <tt class="fnc">imprimir</tt>(Y, 8);</tt>
			
 
				+  ordInsercao(Y, 8);</tt>
			
 
				+  <tt class="fnc">imprimir</tt>(Y, 8);</tt>
			
 
				+  }
			
 
				+   </tr></pre></td>
			
 
				+ </table></td>
			
 
				+   <td><pre><tt class="com"># Ordena Insercao Direta</tt>
			
 
				+<tt class="def">from</tt> __future__ import print_function; <tt class="com"># imprime sem mudar linha Python 2</tt>
			
 
				+<tt class="def">def</tt> imprimir (X, n) :
			
 
				+  <tt class="fnc">print</tt>("(", end="");
			
 
				+  <tt class="cmd">for</tt> i in range(n) :
			
 
				+    <tt class="fnc">print</tt>("%3d " % X[i], end="");</tt>
			
 
				+  <tt class="fnc">printf</tt>(")");
			
 
				+
			
 
				+<tt class="def">def</tt> ordInsercao (V, n) :
			
 
				+  <tt class="cmd">for</tt> i in range(1, n) :</tt>
			
 
				+    aux = V[i]; <tt class="com"># "abrir espaco" copiando V[i]</tt>
			
 
				+    j = i-1;
			
 
				+    <tt class="cmd">while</tt> (j &gt; -1 and V[j] &gt; aux) : <tt class="com"># "mova" para direita os maiores que aux</tt>
			
 
				+        V[j+1] = V[j]; <tt class="com"># mover para direita V[j]</tt>
			
 
				+        j -= 1;
			
 
				+    V[j+1] = aux; <tt class="com"># coloque aux na posicao correta</tt>
			
 
				+
			
 
				+<tt class="fnc">def</tt> main () :
			
 
				+  V = [4, 2, 3, 0, 9, 3, 5, 7]; <tt class="com"># definir vetor dados</tt> 
			
 
				+  <tt class="fnc">imprimir</tt>(V,8);</tt>
			
 
				+  ordInsercao(V, 8);</tt>
			
 
				+  <tt class="fnc">imprimir</tt>(V,8);</tt>
			
 
				+
			
 
				+main();</pre></td>
			
 
				+   </tr>
			
 
				+   </table></td></tr>
			
 
				+</table></center>
			
 
				+</p>
			
 
				+
			
 
				+<p>
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+
			
 
				+<p>
			
 
				+  Bem, em resumo é isso. Experimente copiar esses códigos, tente algumas modificações, teste até estar seguro de ter compreendido.
			
 
				+</p>
			
 
				+
			
 
				+
			
 
				+  <p class="autoria">
			
 
				+    <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: acerto no formato<br/>
			
 
				+    2020/08/15: novo formato, pequenas revisões<br/>
			
 
				+    2020/08/12: novo formato, pequenas revisões<br/>
			
 
				+    2020/06/14: inserção de rótulos para as figuras<br/>
			
 
				+    2019/06/16: versão inicial
			
 
				+  </p>
			
 
				+
			
 
				+
			
 
				+</div>
			
--- a/introducao_parametros_funcoes.html
+++ b/introducao_parametros_funcoes.html