\documentclass{beamer}

\usepackage[utf8]{inputenc}
\usepackage[brazil,british]{babel}
\usetheme{default} 
\usecolortheme{beaver}
\usepackage{graphicx}
\usepackage{clrscode}
\usepackage{hyperref}
% \usecolortheme{dove}
\usepackage{tikz}
\usetikzlibrary{positioning}
\title{Aula 02}
\author{David Déharbe \\
  Universidade Federal do Rio Grande do Norte \\
  Centro de Ciências Exatas e da Terra \\
  Departamento de Informática e Matemáica Aplicada}
\date{10 de fevereiro de 2015}

\newcounter{ProblemCtr}

\begin{document}
\selectlanguage{brazil}
\begin{frame}
  \titlepage
\end{frame}

\section{Nosso primeiro problema}

\begin{frame}

  \frametitle{Tomadas}
  \framesubtitle{OBI2013 - Programação Júnior, fase 1}

A Olimpíada Internacional de Informática (IOI, no original em Inglês)
é a mais prestigiada competição de programação para alunos de ensino
médio; seus aproximadamente 300 competidores se reúnem em um país
diferente todo ano para os dois dias de prova da competição.
Naturalmente, os competidores usam o tempo livre para acessar a
Internet, programar e jogar em seus notebooks, mas eles se depararam
com um problema: o saguão do hotel só tem uma tomada.

Felizmente, os quatro competidores da equipe brasileira da IOI
trouxeram cada um uma régua de tomadas, permitindo assim ligar vários
notebooks em uma tomada só; eles também podem ligar uma régua em outra
para aumentar ainda mais o número de tomadas disponíveis. No entanto,
como as réguas têm muitas tomadas, eles pediram para você escrever um
programa que, dado o número de tomadas em cada régua, determina
quantas tomadas podem ser disponibilizadas no saguão do hotel.

\end{frame}

\begin{frame}

\frametitle{Tomadas}

\begin{description}
\item[Entrada] A entrada consiste de uma linha com quatro inteiros
  positivos $T_1$, $T_2$, $T_3$, $T_4$, indicando o número de tomadas
  em cada uma das quatro réguas.
\item[Saída] Seu programa deve imprimir uma única linha contendo um
  único número inteiro, indicando o número máximo de notebooks que
  podem ser conectados num mesmo instante.
\item[Restrições] $2 \le T_i \le 6$.
\item[Exemplos]
\begin{itemize}
\item Entrada: \texttt{2 4 3 2}, saída: \texttt{8}
\item Entrada: \texttt{6 6 6 6}, saída: \texttt{21}
\end{itemize}
\end{description}
\end{frame}

\begin{frame}

\frametitle{Solução em C}

\begin{center}
\includegraphics[width=.8\textwidth]{tomadas.png}
\end{center}

\end{frame}

\begin{frame}

\frametitle{Roteiro da explicação}

\begin{itemize}

\item preâmbulo: uma visão simplificada do computador

\item inclusão de arquivo cabeçalho

\item rotina principal

\begin{itemize}

\item variáveis

\item leitura dos dados

\item cálculo

\item impressão do resultado

\end{itemize}

\end{itemize}

\end{frame}

\begin{frame}

\frametitle{Uma visão simplificada do computador}

\begin{enumerate}

\item \alert<3>{processador}
\only<3>{
  \begin{itemize}
  \item uma máquina que executa (rápido) comandos (simples) seguindo a ordem de uma sequência;
  \item combina dados (soma);
  \item compara dados (menor que);
  \item lê um dado da memória;
  \item escreve um dado na memória;
  \item vá executar a partir de uma outra posição na sequência;
  \item utiliza os dispositivos de leitura e escrita.
  \end{itemize}
}

\item \alert<2>{memória}
\only<2>{
\begin{itemize}
  \item armazem de dados;
  \item dividido em uma fileira de compartimentos;
  \item cada compartimento tem um endereço único;
  \item um dado pode ocupar vários compartimentos consecutivos.
\end{itemize}
}
\item \alert<4>{dispositivo de leitura}
\only<4>{
  \begin{itemize}
    \item entrada: onde dados entram no programa;
    \item entrada padrão: teclado;
    \item lê o que for digitado na entrada padrão;
    \item os dados lidos são armazenados em memória.
  \end{itemize}
}

\item \alert<5>{dispositivo de escrita}
\only<5>{
\begin{itemize}
  \item saída: onde os resultados saem do programa;
  \item saída padrão: terminal (linha de comando);
  \item escreve valores informados pelo processador.
\end{itemize}
}
\end{enumerate}

\end{frame}

\begin{frame}

\frametitle{Inclusão de arquivo cabeçalho}

\includegraphics{include.png}

\begin{itemize}

\item \emph{include}: o programa utilizará recursos pré-definidos
  (biblioteca de serviços disponíveis).
\item \textit{\textbf{st}an\textbf{d}ard
  \textbf{i}nput-\textbf{o}utput}: comandos padrões de leitura e escrita
\item dispositivo de leitura $\longleftrightarrow$ entrada
\item dispositivo de escrita $\longleftrightarrow$ saída
\end{itemize}

\end{frame}

\begin{frame}
\frametitle{Programa principal}

\includegraphics[height=.4\textheight]{main.png}

\begin{itemize}

\item \texttt{int main (void) \{}

  início do programa

\item \texttt{ ... }

  comandos que o computador vai executar quando o programa será lançado

\item \texttt{return 0;}

  Valor que o programa retorna ao sistema operacional (ignorar)

\item \texttt{\}}

  término do programa

\end{itemize}

\end{frame}

\begin{frame}
  \frametitle{Declaração de variáveis}

  \includegraphics{variaveis.png}

  \begin{itemize}
    \item Variáveis = compartimentos da memória onde são armazenados os valores lidos
      e calculados pelo programa.
    \item \texttt{int} todos os dados são \emph{números inteiros}.
    \item \texttt{T1}, ... \texttt{T4} armazenarão os dados lidos pelo
      programa;
    \item \texttt{tomadas} armazenará o número total de tomadas;
    \item \texttt{notebooks} armazenará o número tomadas disponíveis, 

      que é o número de notebooks que poderão ser conectados, 

      que é a saída do programa.

  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Variáveis}

  \begin{itemize}
    \item nome: nome escolhido pelo programador 

      \alert{\texttt{T1}};
    \item endereço: qual é o endereço do compartimento de memória 
      que corresponde àquela variável

      \alert{\texttt{\&T1}};
    \item valor: qual o dado que está neste compartimento de memória

      \alert{inicialmente indeterminado};
    \item tipo: qual a natureza dos dados que são armazenados pelo
      programa nesta variável

      \alert{int};

    \item escopo: quais partes do programa está variável pode ser utilizada,
      ou seja, lida ou escrita

      \alert{após a declaração}.
  \end{itemize}

\end{frame}

\begin{frame}
  \frametitle{Leitura}

  \includegraphics{leitura.png}

  \begin{itemize}
    \item \alert{\texttt{scanf}}

      Comando para ler da entrada padrão (declarado em \texttt{stdio.h})

    \item \alert{\texttt{"\%i \%i \%i \%i"}}

      Devem ser lidos quatro números inteiros (\texttt{"\%i"}),
      separados por espaço branco.

    \item Cada número lido é armazenado na memória nos endereços 
      \alert{\texttt{\&T1}},
      \alert{\texttt{\&T2}}, 
      \alert{\texttt{\&T3}}, 
      \alert{\texttt{\&T4}}.

    \item Note os parênteses, vírgulas e ponto-e-vírgula, que fazem parte do
      comando.

  \end{itemize}
\end{frame}

\begin{frame}

\frametitle{Cálculo do resultado}

\includegraphics{calculo.png}

\begin{itemize}
\item \texttt{tomadas = T1 + T2 + T3 + T4;}

  \begin{itemize}
  \item Os valores inteiros armazenados nos compartimentos de memória 
    \texttt{T1}, \texttt{T2}, \texttt{T3} e \texttt{T4} são somados;
  \item O resultado é armazenado no compartimento de memória \texttt{tomadas}.
  \item Isto é um \emph{comando de atribuição}
        
    (não é igualdade)
  \end{itemize}
\item \texttt{notebooks = tomadas - 3;}
  \begin{itemize}
  \item O valor 3 é subtraído do valor armazenado no compartimento \texttt{tomadas};
  \item O resultado é atribuído ao compartimento de memória \texttt{notebooks}.
  \end{itemize}
\end{itemize}
\end{frame}

\begin{frame}

\frametitle{Escrita do resultado}

\includegraphics{escrita.png}

\begin{itemize}
\item \alert{\texttt{printf}}

  Comando para escrever na saída padrão 
  
\item \alert{\texttt{"\%i{\textbackslash}n"}}

  Será impresso um número inteiro \alert{\texttt{\%i}}, 
  seguido de uma quebra de linha \alert{\texttt{\textbackslash n}}.

\item \alert{\texttt{notebooks}}

  o número inteiro a imprimir é aquele armazenado
  no compartimento de memória \texttt{notebooks}.

\end{itemize}

\end{frame}

\begin{frame}

  \frametitle{Simulação da execução do programa}

%  No quadro!
\only<1-2>{
\begin{tikzpicture}[
    varint/.style={
      %  The shape:
      rectangle,
      %  The size:
      minimum size=10mm,
      %  The border:
      very thick,
      draw=red!50!black!50,
      %  The filling:
      top color=white,
      bottom color=red!50!black!20, %  and something else at the bottom
      %  Font
      font=\itshape
    }]
  \node (T1) [varint] {?};
  \node (T2) [varint,right=of T1] {?};
  \node (T3) [varint,right=of T2] {?};
  \node (T4) [varint,right=of T3] {?};
  \node (tomadas) [varint,right=of T4] {?};
  \node (notebooks) [varint,right=of tomadas] {?};

  \node [above] at (T1.north) {\texttt{T1}};
  \node [above] at (T2.north) {\texttt{T2}};
  \node [above] at (T3.north) {\texttt{T3}};
  \node [above] at (T4.north) {\texttt{T4}};
  \node [above] at (tomadas.north) {\texttt{tomadas}};
  \node [above] at (notebooks.north) {\texttt{notebooks}};
\end{tikzpicture}
}
\only<3>{
\begin{tikzpicture}[
    varint/.style={
      %  The shape:
      rectangle,
      %  The size:
      minimum size=10mm,
      %  The border:
      very thick,
      draw=red!50!black!50,
      %  The filling:
      top color=white,
      bottom color=red!50!black!20, %  and something else at the bottom
      %  Font
      font=\itshape
    }]
  \node (T1) [varint] {2};
  \node (T2) [varint,right=of T1] {4};
  \node (T3) [varint,right=of T2] {3};
  \node (T4) [varint,right=of T3] {2};
  \node (tomadas) [varint,right=of T4] {?};
  \node (notebooks) [varint,right=of tomadas] {?};

  \node [above] at (T1.north) {\texttt{T1}};
  \node [above] at (T2.north) {\texttt{T2}};
  \node [above] at (T3.north) {\texttt{T3}};
  \node [above] at (T4.north) {\texttt{T4}};
  \node [above] at (tomadas.north) {\texttt{tomadas}};
  \node [above] at (notebooks.north) {\texttt{notebooks}};
\end{tikzpicture}

}

\only<4>{
\begin{tikzpicture}[
    varint/.style={
      %  The shape:
      rectangle,
      %  The size:
      minimum size=10mm,
      %  The border:
      very thick,
      draw=red!50!black!50,
      %  The filling:
      top color=white,
      bottom color=red!50!black!20, %  and something else at the bottom
      %  Font
      font=\itshape
    }]
  \node (T1) [varint] {2};
  \node (T2) [varint,right=of T1] {4};
  \node (T3) [varint,right=of T2] {3};
  \node (T4) [varint,right=of T3] {2};
  \node (tomadas) [varint,right=of T4] {11};
  \node (notebooks) [varint,right=of tomadas] {?};

  \node [above] at (T1.north) {\texttt{T1}};
  \node [above] at (T2.north) {\texttt{T2}};
  \node [above] at (T3.north) {\texttt{T3}};
  \node [above] at (T4.north) {\texttt{T4}};
  \node [above] at (tomadas.north) {\texttt{tomadas}};
  \node [above] at (notebooks.north) {\texttt{notebooks}};
\end{tikzpicture}

}
\only<5-6>{
\begin{tikzpicture}[
    varint/.style={
      %  The shape:
      rectangle,
      %  The size:
      minimum size=10mm,
      %  The border:
      very thick,
      draw=red!50!black!50,
      %  The filling:
      top color=white,
      bottom color=red!50!black!20, %  and something else at the bottom
      %  Font
      font=\itshape
    }]
  \node (T1) [varint] {2};
  \node (T2) [varint,right=of T1] {4};
  \node (T3) [varint,right=of T2] {3};
  \node (T4) [varint,right=of T3] {2};
  \node (tomadas) [varint,right=of T4] {11};
  \node (notebooks) [varint,right=of tomadas] {8};

  \node [above] at (T1.north) {\texttt{T1}};
  \node [above] at (T2.north) {\texttt{T2}};
  \node [above] at (T3.north) {\texttt{T3}};
  \node [above] at (T4.north) {\texttt{T4}};
  \node [above] at (tomadas.north) {\texttt{tomadas}};
  \node [above] at (notebooks.north) {\texttt{notebooks}};
\end{tikzpicture}
}
\pause
\texttt{scanf("\%i \%i \%i \%i", \&T1, \&T2, \&T3, \&T4);}

\pause
$$
\Longleftarrow \mathtt{2~4~3~2}
$$
\pause
\texttt{tomadas = T1 + T2 + T3 + T4;}
\pause

\texttt{notebooks = tomadas - 3;}
\pause

\texttt{printf("\%i{\textbackslash}n", notebooks);}

$$
\Longrightarrow \mathtt{8}
$$

\end{frame}

\begin{frame}

\frametitle{Solução alternativa}

\begin{center}
\includegraphics[width=.8\textwidth]{tomadas-bis.png}
\end{center}

\end{frame}

\begin{frame}

\frametitle{Mais uma solução alternativa}

\begin{center}
\includegraphics[width=.8\textwidth]{tomadas-ter.png}
\end{center}

\end{frame}

\stepcounter{ProblemCtr}
\begin{frame}

\frametitle{Prática (\theProblemCtr)}

\begin{itemize}

\item Criar um arquivo, nomeado \texttt{"notebooks.c"}.
\item Escrever uma das soluções apresentadas no arquivo.
\item Abrir uma linha de comando (terminal).
\item Compilar o arquivo.
  \begin{itemize}
    \item comando: \texttt{gcc notebooks.c -Wall -o notebooks}
  \end{itemize}
\item Executar o programa obtido algumas vezes e verificar se o resultado
  é correto.
  \begin{itemize}
    \item comando: \texttt{./notebooks}
  \end{itemize}
\end{itemize}

\end{frame}

\stepcounter{ProblemCtr}

\begin{frame}

\frametitle{Prática (\theProblemCtr) : Pneu}
\framesubtitle{OBI2010 - Programação Júnior, fase 1}

Calibrar os pneus do carro deve ser uma tarefa cotidiana de todos os
motoristas. Para isto, os postos de gasolina possuem uma bomba de ar. A maioria
das bombas atuais são eletrônicas, permitindo que o motorista indique a pressão
desejada num teclado. Ao ser ligada ao pneu, a bomba primeiro lê a pressão atual
e calcula a diferença de pressão entre a desejada e a lida. Com esta diferença
ela esvazia ou enche o pneu para chegar na pressão correta.  

Sua ajuda foi requisitada para desenvolver o programa da próxima bomba da SBC –
Sistemas de Bombas Computadorizadas.

\end{frame}

\begin{frame}

\frametitle{Dicas}

\begin{itemize}
\item \texttt{+} soma  \alert{\texttt{7 + 3}} \pause \alert{$\rightarrow$ \texttt{10}}
\item \texttt{*} multiplicação  \alert{\texttt{7 * 3}} \pause \alert{$\rightarrow$ \texttt{21}}
\item \texttt{-} subtração, oposto  \alert{\texttt{7 - 3}} \pause \alert{$\rightarrow$ \texttt{4}}
\item \texttt{/} quociente da divisão  \alert{\texttt{7 / 3}} \pause \alert{$\rightarrow$ \texttt{2}}
\item \texttt{\%} resto da divisão  \alert{\texttt{7 \% 3}} \pause \alert{$\rightarrow$ \texttt{1}}
\end{itemize}

\end{frame}

\begin{frame}

\frametitle{Prática (\theProblemCtr) : Pneu}
\framesubtitle{OBI2010 - Programação Júnior, fase 1}

\begin{itemize}

\item Entrada

  A primeira linha da entrada contém um inteiro $N$ que indica a pressão
  desejada pelo motorista ($1 \le N \le 40$). A segunda linha contém um inteiro
  $M$ que indica a pressão lida pela bomba ($1 \le M \le 40$).

\item Saída

  Seu programa deve imprimir uma única linha, contendo a diferença entre a
  pressão desejada e a pressão lida.

\item Exemplos:

  \begin{tabular}{l|l|l}
  Entrada \hspace*{1cm} & Entrada \hspace*{1cm} & Entrada \\
  \texttt{30} & \texttt{27} & \texttt{27} \\
  \texttt{18} & \texttt{27} & \texttt{30} \\
  Saída & Saída & Saída \\
  \texttt{12} & \texttt{0} & \texttt{-3}
  \end{tabular}
\end{itemize}

\end{frame}

\begin{frame}

\frametitle{Prática (\theProblemCtr)}

Desenvolve uma solução para este problema.
\begin{itemize}
\item Quantos valores serão lidas (entradas)?
\item Quais cálculos são necessários para obter o resultado?
\item Quantos compartimentos de memória vão ser necessários?
\item Como ler as entradas e armazenar em memória?
\item Qual sequência de atribuições deve ser feita para obter o resultado?
\item Como escrever o resultado (saída)?
\end{itemize}

\end{frame}

\stepcounter{ProblemCtr}

\begin{frame}

\frametitle{Prática (\theProblemCtr) : Busca na internet}
\framesubtitle{OBI2012 - Programação Júnior, fase 1}

João fez uma pesquisa em seu site de busca predileto, e encontrou a resposta que
estava procurando no terceiro link listado.  Além disso, ele viu, pelo site, que
$t$ pessoas já haviam clicado neste link antes.  João havia lido anteriormente,
também na Internet, que o número de pessoas que clicam no segundo link listado é
o dobro de número de pessoas que clicam no terceiro link listado.  Nessa
leitura, ele também descobriu que o número de pessoas que clicam no segundo link
é a metade do número de pessoas que clicam no primeiro link.  João está
intrigado para saber quantas pessoas clicaram no primeiro link da busca, e, como
você é amigo dele, quer sua ajuda nesta tarefa.

\end{frame}

\begin{frame}

\frametitle{Prática (\theProblemCtr) : Busca na internet}
\framesubtitle{OBI2012 - Programação Júnior, fase 1}

\begin{itemize}

\item Entrada

Cada caso de teste possui apenas um número, $t$, que representa o número de
pessoas que clicaram no terceiro link da busca.

\item Saída

  Para cada caso de teste imprima apenas uma linha, contendo apenas um inteiro,
  indicando quantas pessoas clicaram no primeiro link, nessa busca.

\item Restrições

  $1 \le t \le 100$

\item Exemplos:

  \begin{tabular}{l|l}
    \hline
    Entrada \hspace*{2cm} & Entrada \hspace*{2cm} \\
    \texttt{2} & \texttt{25} \texttt{76} \\
    Saída & Saída \\
    \texttt{8} & \texttt{100} \\
    \hline
  \end{tabular}
\end{itemize}

\end{frame}


\stepcounter{ProblemCtr}
\begin{frame}

\frametitle{Prática (\theProblemCtr) : Transporte de contêineres}
\framesubtitle{OBI2011 - Programação júnior, fase 1}

A Betalândia é um país que apenas recentemente se abriu para o comércio exterior
e está preparando agora sua primeira grande exportação.  A Sociedade Betalandesa
de Comércio (SBC) ficou encarregada de conduzir a exportação e determinou que,
seguindo os padrões internacionais, a carga será transportada em contêineres,
que são, por sua vez, colocados em grandes navios para o transporte
internacional.

\end{frame}

\begin{frame}

\frametitle{Prática (\theProblemCtr) : Transporte de contêineres}
\framesubtitle{OBI2011 - Programação júnior, fase 1}

\begin{center}
\includegraphics[width=.8\textwidth]{conteineres.png}
\end{center}

Todos os contêineres betalandeses são idênticos, medindo $A$ metros de largura,
$B$ metros de comprimento e $C$ metros de altura. 
Um navio porta-contêineres pode ser visto como um retângulo horizontal de $X$
metros de largura e $Y$ metros de comprimento, sobre o qual os contêineres são
colocados. 
Nenhuma parte de contêiner pode ficar para fora do navio. Além disso,
para possibilitar a travessia de pontes, a altura máxima da carga no navio não
pode ultrapassar $Z$ metros.  

\end{frame}

\begin{frame}

\frametitle{Prática (\theProblemCtr) : Transporte de contêineres}
\framesubtitle{OBI2011 - Programação júnior, fase 1}

Devido a limitações do guindaste utilizado, os
contêineres só podem ser carregados alinhados com o navio. Ou seja, os
contêineres só podem ser colocados sobre o navio de tal forma que a largura e o
comprimento do contêiner estejam paralelos à largura e ao comprimento do navio,
respectivamente.  A SBC está com problemas para saber qual a quantidade máxima
de contêineres que podem ser colocados no navio e pede sua ajuda. Sua tarefa,
neste problema, é determinar quantos contêineres podem ser carregados no navio
respeitando as restrições acima.

\end{frame}

\begin{frame}

\frametitle{Prática (\theProblemCtr) : Transporte de contêineres}
\framesubtitle{OBI2012 - Programação 1, fase 1}

\begin{itemize}

\item Entrada

  A entrada consiste de duas linhas: a primeira contém três inteiros $A$,
  $B$ e $C$ (as dimensões dos contêineres) e a segunda os três
  inteiros $X$, $Y$ e $Z$ (as dimensões do navio).

\item Saída

  Seu programa deve imprimir uma só linha com um inteiro: o máximo de contêineres que o navio consegue transportar.

\item Restrições

  $1 \le A, B, C, X, Y, Z \le 10^6$

  É garantido que a maior resposta será menor ou igual a $10^6$.

\item Exemplos:

  \begin{tabular}{l|l}
    \hline
    Entrada \hspace*{2cm} & Entrada \hspace*{2cm} \\
    \texttt{1 1 1} & \texttt{1 2 5} \\
    \texttt{1 1 1} & \texttt{9 6 11} \\
    Saída & Saída \\
    \texttt{1} & \texttt{54} \\
    \hline
  \end{tabular}
\end{itemize}

\end{frame}


\stepcounter{ProblemCtr}
\begin{frame}

\frametitle{Prática (\theProblemCtr) : Corrida}
\framesubtitle{OBI2012 - Programação 1, fase 1}

Leo é um corredor que participa de campeonatos. O tamanho das pistas não é
padronizado e Leo resolveu fixar seu treino em $C$ metros, ao invés de um número
fixo de voltas na pista. Leo quer deixar uma garrafa de água no ponto da pista
onde ele termina o seu treino.  Sabendo o comprimento da pista, ele resolveu
pedir sua ajuda para calcular o ponto do término do treino. O ponto de término é
o local da pista onde ele termina o percurso de $C$ metros considerando que ele
parte do ponto de partida e se movimenta sempre na mesma direção. O ponto de
término é dado pelo número de metros entre o ponto de partida e o local onde Leo
termina seu treino, contados na direção do percurso. Leo quer deixar sua garrafa
de água neste ponto.  Por exemplo, se a pista tem 12 metros e Leo fixou seu
treino em 22 metros, o ponto de término é 10.  Sua tarefa é, dado o número $C$
de metros que Leo pretende correr e o comprimento $N$ em metros da pista,
determinar o ponto de término de seu treino.

\end{frame}


\begin{frame}

\frametitle{Prática (\theProblemCtr) : Corrida}
\framesubtitle{OBI2012 - Programação 1, fase 1}

\begin{itemize}

\item Entrada

  A entrada consiste em apenas uma linha contendo dois inteiros $C$ e $N$ que
  indicam, respectivamente, o número de metros que Leo pretende correr e o
  comprimento da pista.

\item Saída

  Seu programa deve imprimir apenas uma linha, contendo apenas um inteiro,
  indicando o ponto de término do treino de Leo.

\item Restrições

  $1 \le C \le 10^8$, $1 \le N \le 100$

\item Exemplos:

  \begin{tabular}{l|l}
    \hline
    Entrada \hspace*{2cm} & Entrada \hspace*{2cm} \\
    \texttt{7000} \texttt{100} & \texttt{918} \texttt{76} \\
    Saída & Saída \\
    \texttt{0} & \texttt{6} \\
    \hline
  \end{tabular}
\end{itemize}


\end{frame}

\stepcounter{ProblemCtr}

\begin{frame}

\frametitle{Prática (\theProblemCtr) : Cometa}
\framesubtitle{OBI2010 - Programação 1, fase 2}

O cometa Halley é um dos cometas de menor período do Sistema Solar, completando
uma volta em torno do Sol a cada 76 anos; na última ocasião em que ele tornou-se
visível do planeta Terra, em 1986, várias agências espaciais enviaram sondas
para coletar amostras de sua cauda e assim confirmar teorias sobre suas
composições químicas.

Escreva um programa que, dado o ano atual, determina qual o próximo ano em que o
cometa Halley será visível novamente do planeta Terra. Se o ano atual é um ano
de passagem do cometa, considere que o cometa já passou nesse ano (ou seja,
considere sempre o próximo ano de passagem, não considerando o ano atual).

\end{frame}

\begin{frame}

\frametitle{Prática (\theProblemCtr) : Cometa}
\framesubtitle{OBI2010 - Programação 1, fase 2}

\begin{itemize}

\item Entrada

  A única linha da entrada contém um único inteiro $A$ ($2010 \le A 10^{4}$),
  indicando o ano atual.

\item Saída

  Seu programa deve imprimir uma única linha, contendo um número inteiro,
  indicando o próximo ano em que o cometa Halley será visível novamente do
  planeta Terra.

\item Exemplos:

  \begin{tabular}{l|l|l}
    \hline
    Entrada \hspace*{2cm} & Entrada \hspace*{2cm} & Entrada \hspace*{2cm} \\
    \texttt{2010} & \texttt{10000} & \texttt{2062} \\
    Saída & Saída & Saída \\
    \texttt{2062} & \texttt{10042} & \texttt{2138} \\
    \hline
  \end{tabular}

\end{itemize}

\end{frame}

\end{document}