intr_prog/introducao_vetores.html

<!--
 Introdução à Programação - 2017 - Prof. Leoônidas de Oliveira Brandão
 Introdução aos vetores e listas
 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 vetores e listas</p>

<center><p>[
  <a href="#vetores" title="Vetores: sequência contígua de variáveis">Vetores</a> &nbsp; | &nbsp;
  <a href="#vetC" title="Vetores em C">Vetores em <i>C</i></a> &nbsp; | &nbsp;
  <a href="#vetpython" title="Vetores em Python">Vetores em <i>Python</i></a> &nbsp;
 ]</p>
</center>


<p>
  Nesta seção examinaremos resumidamente como utilizar vetores tanto em <em>C</em> quanto em <em>Python</em>,
  mas iniciamos com a questão essencial: por que usar vetor (ou lista, outro possível nome, apesar desse segundo
  poder implicar em operadores especiais).
</p>

<a name="porque"><span style="color: #0050A0;font-size:1.1em">Por que precisamos de vetores?</span></a>

<p>
Pense em um problema simples, muito comum, que é extrair informações sobre o comportamento médio de um "conjunto" de dados,
mas apenas a média pode ser pouco informativo (e.g., metade tem valor <i>10</i> e a outra metade <i>0</i>).
Assim, estamos interessados em um <i>software</i> que compute a <i>média</i> e o <i>desvio padrão</i> de um "conunto" de dados.
<br/>
Lembrando a definição de <i>desvio padrão (DP)</i>:
<center>
<tt>DP(v<sub>0</sub>, v<sub>1</sub>,... v<sub>n-1</sub>) = 
((v<sub>0</sub>-med)<sup>2</sup>+(v<sub>1</sub>-med)<sup>2</sup>+(v<sub>n-1</sub>-med)<sup>2</sup>)<sup>1/2</sup></tt>
</center>
<br/>
Então não é viável usar variáveis "simples", pois não sabemos <i>a priori</i> quantos dados o sistema receberá, além disso
não parece razoável investir tempo para desenvolver um sistema que compute a média e desvio padrão para apenas <i>5</i>,
<i>15</i> ou qualquer número fixo de valores; mesmo que "hoje" precisemos conhecer da informação apenas para este número fixo,
podemos pensar em reaproveitar o <i>software</i> "amanhã".
<br/>
Mas suponhamos ainda que o responsável pelo desenvolvimento desconheça o conceito de <i>vetores</i> (algo improvável),
neste caso, ele poderia tentar ler <i>n</i> e depois, em um laço, os <i>n</i> valores para computar a média:
<center><table>
<tr><td><tt>s:=0;</tt></td></tr>
<tr><td><tt>repetir para i entre 0 e n { ler(x); s:=s+x; }</tt></td></tr>
<tr><td><tt><verm>imprimir</verm>(s/n); <cyan>//# med = s/n</cyan></tt></td></tr></table>
<tr><td><i>Algoritmo 1. Tentativa de obter a méida (sem guardar todos os dados).</i></td></tr></table>
</center>
Desse modo conseguiria a média (digamos na variável <tt>med</tt>), mas agora para obter o <i>desvio padrão</i> seria
necessário obter uma soma do quadrado da distância entre cada valor à média!
<br/>
Mas no algoritmo 1 os dados foram lidos, um a um, usados para computar a soma e ao final, teríamos apenas o último valor lido
(em <tt>x</tt>).
<br/>
A saĩda é o conceito de <b>vetor</b>, que é implementado por todas as linguagens de programação de propósito geral,
a ideia é reservar uma variável que tenha acesso à várias posições de memória, como exploraremos a seguir.
Com o vetor podemos guardar todos os dados lidos no algoritmo 1, possibilitando o calculo do desvio padrão.
</p>


<a name="vetores"><span style="color: #0050A0;font-size:1.1em">Vetores: sequência contígua de variáveis</span></a>

<p>
  Usualmente um <i>vetor</i> é um agregado de dados de um mesmo tipo básico ocupando posições consecutivas de memória.
  Isso significa que é possível pegar alternadamente o valor armazenado em qualquer das posições do vetor,
  Usualmente isso é implementado nas linguagens por uma <i>indexamentos</i>,
  ou seja, sendo <i>vet</i> o nome da variável agregada, pode-se pegar o primeiro elemento fazendo
  <i>vet[0]</i>, o segundo com <i>vet[1]</i> e assim por diante.
</p>

<center>
  <img src="img/img_vet_memoria.png" title="ilustracao de vetor em memoria" width="500px" />
  <br/>
  <i>Fig. 1. Representação da <i title="Read Only Memory">RAM</i> com um vetor de 4 posições.</i>.
</center>

<p>
  Na figura acima representamos a memória do computador com um vetor (agregado) de variáveis (usando 8 <i>bits</i> apenas) e de
  tamanho 4, ou seja, um vetor para armazenar 4 valores do tipo dado.
</p>

<p>
  Como citado na <a href="#" onclick="trocaPagina('introducao_funcoes.html#porque')" title="sobre funcoes">explicação sobre funções</a>,
  uma grande vantagem de ter um algoritmo implementado como uma função separada é que o código do programa fica
  mais organizado e pode-se invocar esse algoritmo (a partir da função) em qualquer outro trecho do programa.
  Por isso, alguns funções muito úteis são implementadas pelos desenvolvedores para ficarem disponíveis dentro 
  dos ambientes de programação.
</p>

<p>
  Retomando o exemplo do cálculo da <i>média aritmética</i> e do <i>desvio padrão</i> de <i>n</i> valores,
  poderíamos implementar a função <tt>calcula_media</tt> e a função <tt>calcula_dp</tt>, como abaixo.
</p>

<center><div class="codigo"><pre><verm>inteiro</verm> calcula_media (vetor, n) { <cyan>//# declara funcao que devolve 'inteiro'</cyan>
  s := 0; <cyan>//# <b>atencao</b>, dependendo da linguagem, e' melhor declarar ser to tipo "real"</cyan>
  repetir para i entre 0 e n { s := s+vetor[i]; }
  devolve s/n; <cyan>//# a media - <b>atencao</b>, dependendo da linguagem precisa de alguma forma forcar tratar-se de "reais"</cyan>
  }</tt></td></tr>
<verm>real</verm> calcula_dp (vetor, med, n) { <cyan>//# declara funcao que devolve 'real'</cyan>
  s := 0;
  repetir para i entre 0 e n {
    aux := med-vetor[i]; <cyan>//# pequeno truque para melhorar desempenho do algoritmo...</cyan>
    s := s + aux*aux; <cyan>//# nao precisa computar 2 vezes med-vetor[i]</cyan>
    } 
  devolve raiz_quadrada(s); <cyan>//# raiz_quadrada(s) devolve s<sup>1/2</sup></cyan>
  }</pre></div><br/>
<i>Algoritmo 2. Calcula média e desvio padrão em funções separadas.</i>
</center>

<p>
  Por exemplo, tanto em <i>C</i> quanto em <i>Python</i> existem implementações para funções matemáticas
  úteis, como <i>seno</i>,  <i>cosseno</i> ou <i>raíz quadrada</i> (respectivamente, <tt>sin</tt>, <tt>cos</tt> e
  <tt>sqrt</tt>). Mas é preciso indicar ao ambiente que ele deve carregar essas funções, isso é feito com os
  comandos <tt>#include &lt;math.h&gt;</tt> em <i>C</i> e <tt>import "math"</tt>.
</p>


<a name="vetC"><span style="color: #0050A0;font-size:1.1em">Vetores em <i>C</i></span></a>

<p>
  Como em <i>C</i> deve-se sempre declarar o tipo da variável, no caso de vetor deve-se declarar seu tipo e seu tamanho.
  No exemplo abaixo ilustramos declaração e uso de vetores dos tipos básicos <i>int</i>, <i>char</i> e <i>float</i>.
</p>


<p><center>
<table class="tbCodeLinCol">
 <tr><th colspan="3">Vetores em <i>C</i> </th> </tr>
 <tr> 
     <th>Vetor de inteiros</th>
     <th>Vetor de caracteres</th>
     <th>Vetor de flutuantes</th></tr>
 <tr valign="top"><td><table class="tbCode">
   <tr><td><div class="codigo"><pre><tt class="def">#include</tt> &lt;stdio.h&gt;
<tt class="def">#define<;tt> M 20 <cyan>// usado para constante</cyan></tt>
<verm>int</verm> main (void) {
  <verm>int</verm> i; <cyan>// auxiliar, para indexar os vetores</cyan></tt>
  <verm>int</verm> nI; <cyan>// tamanho util dos vetores</cyan></tt>
  <verm>int</verm>  vetI[M]; <cyan>// Vetor para inteiros (ate' M elementos)</cyan></tt>
  scanf("%d", &nI);
  <azul>for</azul> (i=0; i&lt; nI; i++) <cyan>// "Ler" nI inteiros</cyan></tt>
    scanf("%d", &vetI[i]);
  <azul>for</azul> (i=0; i&lt; nI; i++) <cyan>// "Imprimir" os elementos</cyan></tt>
    <tt class="fnc">printf</tt>("%d\n", vetI[i]);
  return 0;
  }</pre></div></td>
 </table></td>
   <td><div class="codigo"><pre><tt class="def">#include</tt> &lt;stdio.h&gt;
#define M 20 <cyan>// usado para constante</cyan></tt>
<verm>int</verm> main (void) {
  <verm>int</verm> i; <cyan>// auxiliar, para indexar os vetores</cyan></tt>
  <verm>int</verm> nC; <cyan>// tamanho util dos vetores</cyan></tt>
  char vetC[M]; <cyan>// Vetor para caracteres</cyan></tt>
  scanf("%d", &nC);
  <azul>for</azul> (i=0; i&lt; nC; i++) <cyan>// ler nC caracteres</cyan></tt>
    scanf(" %c ", &vetC[i]); <cyan>// USAR branco antes de %c</cyan></tt>
  <azul>for</azul> (i=0; i&lt; nC; i++)
    <tt class="fnc">printf</tt>("%c\n", vetC[i]);
  return 0;
  }</pre></div></td>
   <td><div class="codigo"><pre><tt class="def">#include</tt> &lt;stdio.h&gt;
#define M 20 <cyan>// usado para constante</cyan></tt>
<verm>int</verm> main (void) {
  <verm>int</verm> i; <cyan>// Auxiliar, para indexar os vetores</cyan></tt>
  <verm>int</verm> iF; <cyan>// Tamanho util dos vetores</cyan></tt>
  float vetF[M]; <cyan>// Vetor para flutuantes</cyan></tt>
  scanf("%d", &nF);
  <azul>for</azul> (i=0; i&lt; nF; i++) <cyan>// "Ler" nF "floats"</cyan></tt>
    scanf("%f", &vetF[i]);
  <azul>for</azul> (i=0; i&lt; nF; i++)
    <tt class="fnc">printf</tt>("%f4.1\n", vetF[i]); <cyan>// Usar 4 posicoes</cyan></tt>
  return 0;                     <cyan>// e 1 para pto dec.</cyan></tt>
  }</pre></div></td></tr>
   </table></td></tr>
</table></center>
</p>

<p> 
  <!--
  <tt>stdio.h</tt> que tem as funções onipresente para entrada (<tt>scanf</tt>) e para saída (<tt><tt class="fnc">printf</tt></tt>) de dados,
  -->
  Como já examinado, em <i>C</i> geralmente deve-se carregar a biblioteca <tt>stdio</tt>
  mas existem outras, como a <tt>stdlib.h</tt> que dispõe, entre outras, da função
  <tt>qsort(void *base, size_t nitems, size_t size, int (*compar)(const void *, const void*))</tt>
  que implementa o método ordenador eficiente denominado
  <a href="https://pt.wikipedia.org/wiki/Quicksort" title="explicacao na WikiPedia"><i>Quick Sort</i></a>
  (ou
  <a href="http://www.ime.usp.br/~leo/mac/mac122/ordena_rapido.html" title="ver uma implementacao em C"><i>Ordenador Rápido</i></a>).
  Veja um exemplo de código usando o <tt>qsort</tt>:
  <div class="codigo"><pre><tt class="def">#include</tt> &lt;stdio.h&gt; <cyan>// para funcao '<tt class="fnc">printf</tt>'</cyan></tt>
<tt class="def">#include</tt> &lt;stdlib.h&gt; <cyan>// para a funcao 'qsort(void *base, size_t nitems, size_t size, int (*compar)(const void *, const void*))'</cyan></tt>
<verm>int</verm> vetor[] = { 3, 9, 1, 7, 0, 4, 6, 5, 2, 8 }; <cyan>// por simplicidade usar globais e manter fixo</cyan></tt>
<verm>int</verm> N = 10;

void imprime (<verm>int</verm> vet[], <verm>int</verm> n) { <cyan>// funcao para imprimir em mesma linha</cyan></tt>
  <verm>int</verm> i;
  <azul>for</azul> (i=0; i&lt;n; i++)
     <tt class="fnc">printf</tt>(" %d", vet[i]);
  <tt class="fnc">printf</tt>("\n");
  }

<cyan>// Esta e' a funcao comparadora: pode-se comparar qualquer coisa, basta codificar seu comparador</cyan></tt>
<verm>int</verm> comparador (const void *a, const void *b) { <cyan>// precisa de 2 parametros a serem depois comparados</cyan></tt>
  return ( *(int*)a - *(int*)b );
  }

<verm>int</verm> main (void) {
  <tt class="fnc">printf</tt>("Testar 'qsort' da biblioteca 'stdlib'\n");
  <tt class="fnc">printf</tt>("Antes: ");
  imprime(vetor, N);
  <tt class="fnc">printf</tt>("Inicio: invocar 'qsort' da biblioteca 'stdlib'\n");
  <cyan>// Parametros para 'qsort': vetor de dados, numero de elementos no vetor, tamanho em bytes de cada elemento, endereco da funcao comparadora</cyan></tt>
  qsort(vetor, N, sizeof(int), &comparador);
  <tt class="fnc">printf</tt>("Ordenado: ");
  imprime(vetor, N);
  return 0;
  }</pre></div>
</p>

<p>
  <b>Atenção</b>.
  No <i>C</i> padrão NÃO é possível declarar o vetor usando a variável que será usada para informar o número
  efetivo de posições a serem usadas, ou seja, <b>não</b> tente fazer algo como <tt>int n; float vetF[n];</tt>.
  A razão disso é que <i>C</i> é uma linguagem compilada e ao compilar deve-se reservar o espaço máximo a ser
  usado pelo vetor. Já a variável <tt>n</tt> só será conhecida durante a execução do programa.
</p>

<p>
  Apesar de algumas implementações de compiladores <i>C</i> permitirem, NÃO usem sob pena de seu programa não funcionar
  em outros compiladores.
</p>


<a name="vetpython"><span style="color: #0050A0;font-size:1.1em">Vetores/listas em <i>Python</i></span></a>

<p>
  Geralmente, na literatura de <i>programação</i>, o termo <i>vetor</i> refere-se a um agregado de dados,
  de mesmo tipo e em posições consecutivas de memória. Como em <i>Python</i>, pode-se misturar tipos, então usa-se o
  termo <b>lista</b> (ou <b>tuple</b>).
  Por exemplo, pode-se declarar
  <tt>lista = (1, 2, "tres", "VI");</tt> ou <tt>tupla = [1, 2, "tres", "VI"];</tt>
  e alterar ou imprimir um elemento, como em:
  <tt>lista[3] = 3; tupla[3] = 3; <verm>print</verm>("lista=%s, tupla=%s, lista[3]=%d" % (lista,tupla, lista[3]);</tt>.
</p>

<p>
  Como citado na <a href="#" onclick="trocaPagina('introducao_funcoes.html#porque')" title="sobre funcoes">explicação sobre funções</a>,
  uma grande vantagem de ter um algoritmo genericamente implementado como uma função separada
  é que o código do programa fica mais organizado e pode-se invocar a função em qualquer outro trecho do programa.
  Por isso, alguns funções muito úteis acabam sendo implementadas pelos desenvolvedores nos ambientes
  de programação.
</p>

<p>
  Por exemplo, em <i>Python</i> existe a função <tt>sorted(.)</tt> que ordena listas (e tuplas),
  mas também existe um método sobre lista (não sobre tupla) que também ordena lista:
  <div class="codigo"><pre>  lista = ["tres", "quatro", "um", "dois"];
  <verm>print</verm>("Ordenado via 'sorted': %s" % sorted(lista)); <cyan># ['dois', 'quatro', 'tres', 'um']</cyan></tt>
  lista.sort(); <cyan># nao tente imprimir direto "lista.sort()" senao aparece "None"</cyan></tt>
  <verm>print</verm>("Ordenado via 'lista.sort()': %s" % lista); <cyan># ['dois', 'quatro', 'tres', 'um']</cyan></tt></pre></div>
  Note que o resultado em <tt>lista</tt> será
  <tt>['dois', 'quatro', 'tres', 'um']</tt>, pois a ordem é lexicográfica (do dicionário).
</p>

<p>
  Outra observação importante, o método <i>sort()</i> <b>não</b> está definido para <i>tuplas</i>,
  ou seja, os comandos
  <tt>lista = ("tres", "quatro", "um", "dois"); lista.sort(); <verm>print</verm>(lista);</tt>
  resultaria erro (<tt>AttributeError: 'tuple' object has no attribute 'sort'</tt>).
</p>

<p>
  No exemplo abaixo ilustramos a declaração e uso de <i>listas</i> dos tipos básicos <i>int</i>, <i>char</i> e <i>float</i>.
  Nesses exemplos utilizamos uma técnica de pré-alocar todo o espaço para a lista, utilizando um valor máximo
  para o número de posições a serem utilizadas (o <tt>M = 20;</tt>).
  Depois solicitamos que o usuário digite o número de elementos que ele deseja inserir na lista
  (não fazemos um teste, mas nessa técnica esse valor <b>tem que ser menor que M</b>),
  então utilizamos um laço para solicitar a "entrada" de cada elemento, inserindo-o na posição adequada da lista.
</p>

<p><center>
<table class="tbCodeLinCol">
 <tr><th colspan="3">Listas em <i>Python</i> com alocação inicial de todo o espaço à <i>priori</i></th> </tr>
 <tr> 
     <th>Vetor de caracteres</th>
     <th>Vetor de inteiros</th>
     <th>Vetor de flutuantes</th></tr>
 <tr valign="top">
   <td><div class="codigo"><pre>M = 20 <cyan># usado para dimensionar os vetores</cyan></tt>
<verm>def</verm> main () :
  vetC = list(range(0,M)); <cyan># Vetor para inteiros (M elementos)</cyan></tt>
  nC = <verm>int</verm>(input());       <cyan># Ler quem definira' tamanho</cyan></tt>
  <azul>for</azul> i in range(0, nC) : <cyan># Para ler nC caracteres</cyan></tt>
    vetI[i] = <verm>raw_input</verm>(); <cyan># no Python 3 usar 'input()'</cyan></tt>
  <azul>for</azul> i in range(0, nC) : <cyan># imprimir os elementos</cyan></tt>
    <verm>print</verm>(vetI[i]);</pre></div></td>
   <td><div class="codigo"><pre>M = 20 <cyan># usado para dimensionar vetores</cyan></tt>
<verm>def</verm> main () :
  vetI = list(range(0,M)); <cyan># Vetor de inteiros (M elementos)</cyan></tt>
  nI = <verm>int</verm>(input());       <cyan># Ler quem definira' tamanho</cyan></tt>
  <azul>for</azul> i in range(0, nI) : <cyan># Para ler nI inteiros</cyan></tt>
    vetI[i] = <verm>int</verm>(input())
  <azul>for</azul> i in range(0, nI) : <cyan># Imprimir os elementos</cyan></tt>
    <verm>print</verm>(vetI[i]);</pre></div></td>
   <td><div class="codigo"><pre>M = 20 <cyan># Para dimensionar os vetores</cyan></tt>
<verm>def</verm> main () :
  vetF = list(range(0,M)); <cyan># Vetor para inteiros (M elementos)</cyan></tt>
  nF = <verm>int</verm>(input());       <cyan># Ler quem definira' tamanho</cyan></tt>
  <azul>for</azul> i in range(0, nF) : <cyan># Para ler nF inteiros</cyan></tt>
    vetI[i] = float(input());
  <azul>for</azul> i in range(0, nI) : <cyan># Imprimir os elementos</cyan></tt>
    <verm>print</verm>(vetI[i]);</pre></div></td>
</tr>
   </table></td></tr>
</table></center>
</p>

<p>
  Vale notar que, como em <i>Python</i> o espaço para o vetor é reservado durante a execução, não é necessário
  pré-dimensionar o espaço para o "vetor" como nos 3 códigos acima, e pode-se usar como linhas 3 e 4:
  <tt>nI = <verm>int</verm>(input()); vetI = list(range(0,nI));</tt>.
</p>


<p>
  Por fim, vale destacar um detalhe a respeito de como "digitar" os dados usando o comando <i>input</i>.
  No <i>Python 2</i>, 
  Nos códigos acima, se o usuário digitar
  <tt>SyntaxError: invalid syntax</tt>.
</p>

<p>
  Podemos adotar outra técnica para registro dos dados na lista, desta vez não usando alocação <i>a priori</i>
  de espaço e sim estendendo a lista a cada novo elemento digitado. Mas ainda usando a técnica que obriga o usuário
  a digitar um único valor por vez (que dizer, digitar um inteiro e teclar <tt>ENTER</tt>).
  Esse exemplo está à esquerda da tabela abaixo.
</p>

<p>
  Na coluna da direita da tabela mostramos um exemplo distinto, no qual não é necessário digitar <i>a priori</i>
  o número de inteiros que comporão a lista. O usuário deverá digitar todos os dados em uma mesma linha, com um
  único <tt>ENTER</tt> ao final, e o código decompõe a "string" digitada, utilizando como separadores
  <i>espaço em branco</i> para deduzir quais são os inteiros.
</p>

<p><center>
<table class="tbCodeLinCol">
 <tr><th colspan="3">Listas em <i>Python</i> com alocação dinâmica de espaço e tipos de digitação</th> </tr>
 <tr> 
     <th>Digitando um elemento por vez</th>
     <th>Digitando todos os elementos de uma vez</th></tr>
 <tr valign="top">
   <td><div class="codigo"><pre><verm>def</verm> alocacaodinamica1por_linha () :
  vetI = []; <cyan># Aloca um "vetor" vazio</cyan></tt>
  <cyan># nI = <verm>int</verm>(input());</cyan></tt>
  nI = M;
  <azul>for</azul> i in range(0, nI) : <cyan># ler nI inteiro</cyan></tt>
    vetI.append(<verm>int</verm>(input())); <cyan># le novo elemento e estende a lista</cyan></tt>
  <verm>print</verm>("Lista: ", end=""); <cyan># imprimir sem mudar de linha</cyan></tt>
  <azul>for</azul> i in range(0, nI) : <cyan># imprimir os elementos</cyan></tt>
    <verm>print</verm>("%d " % vetI[i], end=""); <cyan># imprimir sem mudar de linha</cyan></tt>
  <verm>print</verm>(); <cyan># quebrar a linha ao final</pre></div></td></cyan></tt>
   <td><div class="codigo"><pre><verm>def</verm> alocacaodinamica_varios_por_linha () :
  <cyan># como leremos por linha, pode-se deduzir depois o tamanho da lista</cyan></tt>
  linha = <verm>raw_input</verm>(); <cyan># ler como caracteres para poder pegar uma linha inteira - no Python 3 usar 'input()'</cyan></tt>
  vetI = map(<verm>int</verm>, linha.split()); <cyan># decomponha a linha em itens e faz um mapeamento, passando cada item para inteiro</cyan></tt>
  nI = len(vetI); <cyan># pegar tamanho da lista digitada</cyan></tt>
  <verm>print</verm>("Lista: ", end=""); <cyan># imprimir sem mudar de linha</cyan></tt>
  <azul>for</azul> i in range(0, nI) : <cyan># imprimir os elementos</cyan></tt>
    <verm>print</verm>("%d " % vetI[i], end=""); <cyan># imprimir sem mudar de linha</cyan></tt>
  <verm>print</verm>(); <cyan># quebrar a linha ao final</cyan></tt></pre></div></td>
</tr>
   </table></td></tr>
</table></center>
</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: acertos no formato<br/>
  2020/08/11: acerto formato, pequenos acertos no texto<br/>
  2020/05/05: acrescentada subseção <i>Por que precisamos de vetores?</i><br/>
  2019/06/11: detalhes de forma;<br/>
  2019/06/04: revisão geral.
</p>

</div>