\documentclass{article}

\usepackage[portuguese]{babel}
\usepackage[latin1]{inputenc}
\usepackage{amsmath}

\title{Exampe Especial\\ Algoritmos e Estruturas de Dados I}

\pagestyle{empty}	

\author{Prof.: Carlos Camar\~ao}
\date{14 de Julho de 2006}

\begin{document}

\maketitle
\thispagestyle{empty}

\begin{enumerate}

\item Escreva um programa que leia um valor inteiro positivo $n$, 
calcule o valor de $\sum_{i=1}^n (-(i+1)/(i*i))$, e imprima esse
valor. Decomponha o seu programa em tr\^es partes, cada uma delas
implementada por um m\'etodo: leitura, c\'alculo do valor desejado a
partir do valor lido, e impress\~ao do valor calculado.

O programa (isto \'e, o m\'etodo de leitura) deve ler uma cadeia de
caracteres e causar uma exce\c{c}\~ao se essa cadeia n\~ao representar
um n\'umero inteiro positivo. Nesse caso, a exce\c{c}\~ao deve ser
tratada no programa principal, e esse tratamento deve apenas emitir
uma mensagem de erro apropriada, e em seguida a execu\c{c}\~ao do
programa deve ser terminada.

\item Fa\c{c}a um programa que leia dois n\'umeros inteiros positivos,
$n$ e $m$, e $n$ seq\"u\^encias de $m$ valores inteiros, e imprima,
para $i$ variando de 1 a $m$, a soma dos $i$-\'esimos inteiros de cada
uma das $n$ sequ\^encias.

Por exemplo, se os valores fornecidos como entrada forem:
  
  \[ \begin{array}{l}
        3    \\
        2    \\
        10   \\
        5    \\
        2    \\
        20   \\
        3    \\
        30   
      \end{array} \]
o programa deve imprimir o seguinte:
   1: 15
   2: 55

Note que 15 é obtido pela soma (10+2+3) e 55 por (5+20+30).

Em cada situa\c{c}\~ao de entrada de dados, se um valor n\~ao esperado
for fornecido com entrada (por exemplo uma cadeia de caracteres que
n\~ao representa um n\'umero inteiro), uma exce\c{c}\~ao deve ser
causada, e o dado incorreto deve ser fornecido novamente pelo
usu\'ario do programa. 

O processo de nova entrada de dados, depois de uma entrada de um dado
incorreto, deve ser iniciado em um tratador de exceção.

Nota: o m\'etodo {\it parseInt\/} causa uma exce\c{c}\~ao ({\it
NumberFormatException\/}) se a cadeia de caracteres fornecida como
argumento n\~ao representar um n\'umero inteiro.

N\~ao esque\c{c}a de testar se os dois primeiros valores lidos (de $n$
e $m$) são valores positivo, e causar uma exce\c{c}\~ao em caso
contr\'ario.  Voc\^e pode causar e tratar apenas a exce\c{c}\~ao {\it
Exception\/}, pois a exce\c{c}\~ao {\it NumberFormatException\/} \'e
um objeto da classe {\it Exception\/}, e portanto ser\'a tamb\'em
tratada por um tratador que trata (recebe como argumento) uma
exce\c{c}\~ao {\it NumberFormatException\/}.

\item Escreva o corpo do método:

  \[ \text{ {\tt static void jogadaComputador (int[] jogo)} } \]
tal que {\tt jogadaComputador} realize a jogada ``ótima'' do jogo {\tt
Nim}, se essa jogada puder ser feita e, em caso contrário, retire um
símbolo da linha que contém maior número de símbolos.

Lembre-se: como foi explicado em sala de aula e no enunciado do
trabalho, i) a jogada ótima existe se e somente se a soma binária $sb$
(ou-exclusivo da representação binária do número de símbolos) de todas
as linhas for diferente de zero. Nesse caso, ii) a linha de onde se
deve retirar símbolos é qualquer linha $i$ na qual $x = $ {\tt sb \^{}
jogo[i]} é menor do que {\tt jogo[i]} (onde {\tt \^{}} faz o
ou-exclusivo da representação binária dos dois operandos
inteiros). Além disso, iii) o número de símbolos que se deve deixar
nessa linha é {\tt sb \^{} jogo[i]}.

Por exemplo, se temos: 

   \[ \begin{array}{ccr}
        \text{Linha} & \text{Número de símbolos} & \text{Em binário} \\
          0   &    1               &     1	\\
          1   &    2               &    01  	\\
          2   &    3               &    11	\\
          3   &    4               &   100	\\
          4   &    5               &   101      \\
          5   &    6               &   110 	\\
    \end{array}
  \]
A soma binária é 100, e as linhas em que o valor $x$ decresce são as
três últimas. Por exemplo, podemos deixar, na última linha, {\tt 100
\^{} 110 = 010} (2 símbolos), e com isso a soma binária de todas as
linhas vai passar a ser igual a zero.

Nota: o operador {\tt \^{}} da linguagem Java faz a operação de
ou-exclusivo na representação binária dos dois argumentos inteiros.

\end{enumerate}

\end{document}


