Home Explore Help
Sign In
ggrc
/
intr_prog
1
0
Fork 0
Files Issues 0 Pull Requests 0 Wiki
Browse Source

Files

Gustavo Grancieiro 3 years ago
parent
af4cefe9a6
commit
37b0bd41fc
100 changed files with 9717 additions and 0 deletions
Unified View Show Diff Stats
  1. 93 0
      base_textos.html
  2. 264 0
      c_introducao_apontadores.html
  3. 251 0
      c_introducao_funcoes.html
  4. 301 0
      c_introducao_leituras.html
  5. 486 0
      c_introducao_vetores.html
  6. 123 0
      cabecalho_rodape.html
  7. 684 0
      css_img_js_conf/all.css
  8. 43 0
      css_img_js_conf/carregar_pagina.js
  9. 39 0
      css_img_js_conf/defineLInE.js
  10. 3 0
      css_img_js_conf/folder.svg
  11. BIN
      css_img_js_conf/icone_leo.png
  12. 0 0
      css_img_js_conf/index.html
  13. 70 0
      css_img_js_conf/line_introducao_programacao.css
  14. 3 0
      css_img_js_conf/navigationitem.svg
  15. 574 0
      evitar_entrada_saida_em_funcao.html
  16. 279 0
      evitar_entrada_saida_em_funcao_2018_04_07.html
  17. BIN
      img/comando_selecao_expr_logica.jpg
  18. BIN
      img/exemplo_exec_funcao.jpg
  19. BIN
      img/funcoes_var_locais.png
  20. BIN
      img/icn_editor_101.png
  21. BIN
      img/icn_editor_128.png
  22. BIN
      img/icn_planilha_101.png
  23. BIN
      img/icn_planilha_128.png
  24. BIN
      img/ihanoi.png
  25. BIN
      img/ihanoi1.png
  26. BIN
      img/ihanoi2.png
  27. BIN
      img/ihanoi3.png
  28. BIN
      img/ihanoi4.png
  29. BIN
      img/img_calc.png
  30. BIN
      img/img_computador_io.png
  31. BIN
      img/img_conj_a_contido_b.png
  32. BIN
      img/img_conj_nao_a.png
  33. BIN
      img/img_conj_nao_a_e_b.png
  34. BIN
      img/img_eficiencia_cos_trig.png
  35. BIN
      img/img_estrutura_basica_terminal_topo.png
  36. BIN
      img/img_expressoes.png
  37. BIN
      img/img_fatorial_def.png
  38. BIN
      img/img_fatorial_fat3.png
  39. BIN
      img/img_intr_char_memoria.png
  40. BIN
      img/img_intr_var_1.png
  41. BIN
      img/img_introd_apontador.png
  42. BIN
      img/img_introd_apontador_apontador_apontador.png
  43. BIN
      img/img_invisivel.png
  44. BIN
      img/img_precisao_x_velocidade.png
  45. BIN
      img/img_real_ponto_fixo.png
  46. BIN
      img/img_recorrencia_exp_arit_1.jpg
  47. BIN
      img/img_recorrencia_exp_arit_2.jpg
  48. BIN
      img/img_recursividade1_pos.png
  49. BIN
      img/img_recursividade1_pre.png
  50. BIN
      img/img_recursividade_arvore_binaria.png
  51. BIN
      img/img_vet_memoria.png
  52. BIN
      img/img_visivel.png
  53. 0 0
      img/index.html
  54. BIN
      img/int_mat_representacao.png
  55. BIN
      img/int_vet_apontador.png
  56. BIN
      img/int_vet_apontador_menor.png
  57. BIN
      img/int_vet_vet_representacao.png
  58. BIN
      img/moodle_vpl3.1.4_avaliar.png
  59. BIN
      img/moodle_vpl3.1.4_gravar.png
  60. BIN
      img/moodle_vpl3.2.4_avaliar.png
  61. BIN
      img/moodle_vpl3.2.4_gravar.png
  62. BIN
      img/moodle_vpl_debug1.jpg
  63. BIN
      img/ordenacao_vetor.png
  64. BIN
      img/ordenacao_vetor_bolha.png
  65. BIN
      img/ordenacao_vetor_insercao1.png
  66. BIN
      img/ordenacao_vetor_insercao2.png
  67. BIN
      img/ordenacao_vetor_selecao.png
  68. BIN
      img/pt_fluxo_laco_enquanto_entrada.png
  69. BIN
      img/pt_fluxo_laco_n_vezes.png
  70. BIN
      img/pt_fluxo_se.png
  71. BIN
      img/pt_fluxo_se_senao.png
  72. BIN
      img/recorrencia_fractal_tetracirculo.gif
  73. BIN
      img/recorrencia_tela.png
  74. BIN
      img/recorrencia_tela_menor.png
  75. BIN
      img/recorrencia_tela_menor_limpa.png
  76. BIN
      img/sobre_exerc_online_editar_avaliar_3.jpg
  77. BIN
      img/var_memoria1.jpg
  78. BIN
      img/var_memoria2.jpg
  79. 366 0
      index.html
  80. 182 0
      index_mac2166_2017.html
  81. 192 0
      indicador_passagem.html
  82. 199 0
      introducao_algoritmos.html
  83. 376 0
      introducao_caracteres.html
  84. 253 0
      introducao_char.html
  85. 413 0
      introducao_depuracao_codigos.html
  86. 634 0
      introducao_eficiencia_algoritmos.html
  87. 192 0
      introducao_entrada_saida_dados.html
  88. 288 0
      introducao_estrutura_basica_c_python.html
  89. 329 0
      introducao_float.html
  90. 236 0
      introducao_for.html
  91. 161 0
      introducao_funcao_global.html
  92. 310 0
      introducao_funcoes.html
  93. 469 0
      introducao_if.html
  94. 282 0
      introducao_inteiro_float.html
  95. 186 0
      introducao_inteiro_impressoes.html
  96. 173 0
      introducao_inteiros.html
  97. 233 0
      introducao_logica.html
  98. 592 0
      introducao_matrizes.html
  99. 438 0
      introducao_ordenacao.html
  100. 0 0
      introducao_parametros_funcoes.html

+ 93 - 0
base_textos.html
View File 

@@ -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>

+ 264 - 0
c_introducao_apontadores.html
View File 

@@ -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>

+ 251 - 0
c_introducao_funcoes.html
View File 

@@ -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>

+ 301 - 0
c_introducao_leituras.html
View File 

@@ -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>

+ 486 - 0
c_introducao_vetores.html
View File 

@@ -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>

+ 123 - 0
cabecalho_rodape.html
View File 

@@ -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>

File diff suppressed because it is too large
+ 684 - 0
css_img_js_conf/all.css


+ 43 - 0
css_img_js_conf/carregar_pagina.js
View File 

@@ -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()'

+ 39 - 0
css_img_js_conf/defineLInE.js
View File 

@@ -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

+ 3 - 0
css_img_js_conf/folder.svg
View File 

@@ -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>

BIN
css_img_js_conf/icone_leo.png
View File


+ 0 - 0
css_img_js_conf/index.html
View File


+ 70 - 0
css_img_js_conf/line_introducao_programacao.css
View File 

@@ -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 */

+ 3 - 0
css_img_js_conf/navigationitem.svg
View File 

@@ -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>

+ 574 - 0
evitar_entrada_saida_em_funcao.html
View File 

@@ -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>

+ 279 - 0
evitar_entrada_saida_em_funcao_2018_04_07.html
View File 

@@ -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>

BIN
img/comando_selecao_expr_logica.jpg
View File


BIN
img/exemplo_exec_funcao.jpg
View File


BIN
img/funcoes_var_locais.png
View File


BIN
img/icn_editor_101.png
View File


BIN
img/icn_editor_128.png
View File


BIN
img/icn_planilha_101.png
View File


BIN
img/icn_planilha_128.png
View File


BIN
img/ihanoi.png
View File


BIN
img/ihanoi1.png
View File


BIN
img/ihanoi2.png
View File


BIN
img/ihanoi3.png
View File


BIN
img/ihanoi4.png
View File


BIN
img/img_calc.png
View File


BIN
img/img_computador_io.png
View File


BIN
img/img_conj_a_contido_b.png
View File


BIN
img/img_conj_nao_a.png
View File


BIN
img/img_conj_nao_a_e_b.png
View File


BIN
img/img_eficiencia_cos_trig.png
View File


BIN
img/img_estrutura_basica_terminal_topo.png
View File


BIN
img/img_expressoes.png
View File


BIN
img/img_fatorial_def.png
View File


BIN
img/img_fatorial_fat3.png
View File


BIN
img/img_intr_char_memoria.png
View File


BIN
img/img_intr_var_1.png
View File


BIN
img/img_introd_apontador.png
View File


BIN
img/img_introd_apontador_apontador_apontador.png
View File


BIN
img/img_invisivel.png
View File


BIN
img/img_precisao_x_velocidade.png
View File


BIN
img/img_real_ponto_fixo.png
View File


BIN
img/img_recorrencia_exp_arit_1.jpg
View File


BIN
img/img_recorrencia_exp_arit_2.jpg
View File


BIN
img/img_recursividade1_pos.png
View File


BIN
img/img_recursividade1_pre.png
View File


BIN
img/img_recursividade_arvore_binaria.png
View File


BIN
img/img_vet_memoria.png
View File


BIN
img/img_visivel.png
View File


+ 0 - 0
img/index.html
View File


BIN
img/int_mat_representacao.png
View File


BIN
img/int_vet_apontador.png
View File


BIN
img/int_vet_apontador_menor.png
View File


BIN
img/int_vet_vet_representacao.png
View File


BIN
img/moodle_vpl3.1.4_avaliar.png
View File


BIN
img/moodle_vpl3.1.4_gravar.png
View File


BIN
img/moodle_vpl3.2.4_avaliar.png
View File


BIN
img/moodle_vpl3.2.4_gravar.png
View File


BIN
img/moodle_vpl_debug1.jpg
View File


BIN
img/ordenacao_vetor.png
View File


BIN
img/ordenacao_vetor_bolha.png
View File


BIN
img/ordenacao_vetor_insercao1.png
View File


BIN
img/ordenacao_vetor_insercao2.png
View File


BIN
img/ordenacao_vetor_selecao.png
View File


BIN
img/pt_fluxo_laco_enquanto_entrada.png
View File


BIN
img/pt_fluxo_laco_n_vezes.png
View File


BIN
img/pt_fluxo_se.png
View File


BIN
img/pt_fluxo_se_senao.png
View File


BIN
img/recorrencia_fractal_tetracirculo.gif
View File


BIN
img/recorrencia_tela.png
View File


BIN
img/recorrencia_tela_menor.png
View File


BIN
img/recorrencia_tela_menor_limpa.png
View File


BIN
img/sobre_exerc_online_editar_avaliar_3.jpg
View File


BIN
img/var_memoria1.jpg
View File


BIN
img/var_memoria2.jpg
View File


+ 366 - 0
index.html
View File 

@@ -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>

+ 182 - 0
index_mac2166_2017.html
View File 

@@ -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>

+ 192 - 0
indicador_passagem.html
View File 

@@ -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>

+ 199 - 0
introducao_algoritmos.html
View File 

@@ -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>

+ 376 - 0
introducao_caracteres.html
View File 

@@ -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>

+ 253 - 0
introducao_char.html
View File 

@@ -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>

+ 413 - 0
introducao_depuracao_codigos.html
View File 

@@ -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>

+ 634 - 0
introducao_eficiencia_algoritmos.html
View File 

@@ -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>

+ 192 - 0
introducao_entrada_saida_dados.html
View File 

@@ -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>

+ 288 - 0
introducao_estrutura_basica_c_python.html
View File 

@@ -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>

+ 329 - 0
introducao_float.html
View File 

@@ -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) -->

+ 236 - 0
introducao_for.html
View File 

@@ -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>

+ 161 - 0
introducao_funcao_global.html
View File 

@@ -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>

+ 310 - 0
introducao_funcoes.html
View File 

@@ -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>

+ 469 - 0
introducao_if.html
View File 

@@ -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>

+ 282 - 0
introducao_inteiro_float.html
View File 

@@ -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>

+ 186 - 0
introducao_inteiro_impressoes.html
View File 

@@ -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>

+ 173 - 0
introducao_inteiros.html
View File 

@@ -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>

+ 233 - 0
introducao_logica.html
View File 

@@ -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>

+ 592 - 0
introducao_matrizes.html
View File 

@@ -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>

+ 438 - 0
introducao_ordenacao.html
View File 

@@ -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>

+ 0 - 0
introducao_parametros_funcoes.html
View File


Some files were not shown because too many files changed in this diff