\documentclass[brazil]{article}

\usepackage[utf8]{inputenc}
\usepackage[portuguese]{babel}
%\usepackage[margin=1.5cm,nohead]{geometry}
\usepackage{amsmath}

\title{Prova de Algoritmos e Estruturas de Dados I}

\author{\ }

\date{01 de Junho de 2011}

\pagestyle{empty}

\begin{document}

\maketitle
\newcommand{\ordmasculine}{{\rm {\underline{o}}}}
\newcommand{\ordmasculines}{{\rm {\underline{os}}}}

\begin{enumerate}

\item (6 pontos) Escreva um programa que leia, repetidamente, um valor
  inteiro $s$ e, em seguida, diversos valores inteiros $k_1, \ldots,
  k_n$, até que algum valor $k_i$ menor ou igual a zero seja lido,
  para algum $i$, e imprima, para cada $s$ e sequência
  $k_1,\ldots,k_n$ lidos, uma mensagem indicando se existe ou não um
  par de valores consecutivos $k_j, k_{j+1}$ tais que $k_j + k_{j+1}$
  seja igual a $s$. Se existir tal par de valores, eles devem ser
  mostrados, na mensagem impressa. A execução do programa deve
  terminar quando um valor $s$ menor ou igual a zero for lido.

   O programa deve ler os valores da entrada padrão e imprimir na
   saída padrão. Ele deve funcionar para entradas não interativas. Ou
   seja, a entrada pode estar em arquivo, especificado por
   redirecionamento da entrada padrão.

\item (7 pontos) Escreva um programa que leia, repetidamente, um valor
  inteiro $n$ e imprima, para cada valor lido, o valor do somatório:

   \[ \frac{1}{1} - \frac{2}{3} + \frac{3}{6} - \frac{4}{10} + \frac{5}{15} - \ldots \]
  calculado com $n$ parcelas. O programa deve terminar quando
  um valor menor ou igual a zero for lido.

   Note que: i) o numerador é incremendado de 1 em 1; ii) o
   denominador é incrementado de um valor que cresce de 1 em 1: ou
   seja, o denominador é incrementado de 2 da primeira para segunda
   parcela, de 3 da segunda para a terceira, de 4 da terceira para a
   quarta etc.

   Os valores devem ser lidos do dispositivo de entrada padrão e
   impressos no dispositivo de saída padrão. 

   Use numerador e denominador inteiros, mas faça conversão para
   número de ponto flutuante para fazer a divisão no cálculo de cada
   parcela.

\item (12 pontos) O mínimo múltiplo comum ({\it mmc\/}) entre dois ou
  mais números é (como o próprio nome diz) o menor inteiro que é
  múltiplo de todos eles. Por exemplo, {\tt {\it mmc\/}(4,6)} é igual
  a {\tt 12}. O máximo divisor comum ({\it mdc\/}) de dois ou mais
  números inteiros é (como o próprio nome diz) o maior divisor de
  todos eles (i.e.~o maior valor que divide exatamente os
  números). Por exemplo, {\tt {\it mdc\/}(4,6)} é igual a {\tt 2}.

  Escreva um programa que leia uma sequência qualquer de números
  inteiros positivos e imprima o mínimo múltiplo comum entre eles.

  O programa deve ler os valores da entrada padrão e imprimir o
  resultado na saída padrão. Ele deve funcionar para entradas não
  interativas. Ou seja, a entrada pode estar em arquivo, especificado
  por redirecionamento da entrada padrão. O programa deve terminar com
  o fim dos dados de entrada (i.e.~o término da entrada é indicado
  pelo valor retornado por {\tt scanf}).

  O seu programa deve ser baseado nos fatos de que:

  \begin{enumerate}

  \item $\textit{mmc\/}(a,b) = \bigl(a/\textit{mdc\/}(a,b)\bigr)
    \times b$

   Ou seja, use o valor de $\textit{mdc\/}(a,b)$ para calcular
   $\textit{mmc\/}(a,b)$, dividindo $a$ por $\textit{mdc\/}(a,b)$ e
   multiplicando por $b$.

  \item {\it mmc\/} de três ou mais números pode ser calculado usando
    o fato de que: $\textit{mmc\/}(a,b,c) =
    \textit{mmc\/}(\textit{mmc\/}(a, b), c)$. 

  Ou seja: para calcular {\it mmc\/} de três ou mais números, obtenha
  o {\it mmc\/} do resultado de calcular o {\it mmc\/} dos primeiros
  com o último.

  \item O cálculo do {\it mdc\/} de dois números $a$ e $b$ deve ser
    feito usando o algoritmo a seguir:

     \[ \textit{mdc\/}(a,b) = \left\{ \begin{array}{ll}
           a                                      & \text{se $b=0$}\\
           \textit{mdc\/}(b, a \mbox{{\tt \%}} b) & \text{caso contr\'ario} 
           \end{array} \right. 
   \]

    O operador {\tt \%} \'e usado acima como em {\tt C}, ou seja,
    $a\texttt{\%}b$ representa o resto da divis\~ao de $a$ por $b$
    (sendo $a$ e $b$ inteiros).

   Note que esse algoritmo funciona se $a \geq b$ ou em caso
   contr\'ario. Se $a < b$, a chamada recursiva simplesmente troca $a$
   por $b$ (por exemplo, $\textit{mdc\/}(20,30)$ faz com que
   $\textit{mdc\/}(30,20)$ seja calculado).

  \end{enumerate}

\end{enumerate}

\end{document}
