\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}
  
  
  ewcounter{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
      }]
    
  ode (T1) [varint] {?};
    
  ode (T2) [varint,right=of T1] {?};
    
  ode (T3) [varint,right=of T2] {?};
    
  ode (T4) [varint,right=of T3] {?};
    
  ode (tomadas) [varint,right=of T4] {?};
    
  ode (notebooks) [varint,right=of tomadas] {?};
  
    
  ode [above] at (T1.north) {\texttt{T1}};
    
  ode [above] at (T2.north) {\texttt{T2}};
    
  ode [above] at (T3.north) {\texttt{T3}};
    
  ode [above] at (T4.north) {\texttt{T4}};
    
  ode [above] at (tomadas.north) {\texttt{tomadas}};
    
  ode [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
      }]
    
  ode (T1) [varint] {2};
    
  ode (T2) [varint,right=of T1] {4};
    
  ode (T3) [varint,right=of T2] {3};
    
  ode (T4) [varint,right=of T3] {2};
    
  ode (tomadas) [varint,right=of T4] {?};
    
  ode (notebooks) [varint,right=of tomadas] {?};
  
    
  ode [above] at (T1.north) {\texttt{T1}};
    
  ode [above] at (T2.north) {\texttt{T2}};
    
  ode [above] at (T3.north) {\texttt{T3}};
    
  ode [above] at (T4.north) {\texttt{T4}};
    
  ode [above] at (tomadas.north) {\texttt{tomadas}};
    
  ode [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
      }]
    
  ode (T1) [varint] {2};
    
  ode (T2) [varint,right=of T1] {4};
    
  ode (T3) [varint,right=of T2] {3};
    
  ode (T4) [varint,right=of T3] {2};
    
  ode (tomadas) [varint,right=of T4] {11};
    
  ode (notebooks) [varint,right=of tomadas] {?};
  
    
  ode [above] at (T1.north) {\texttt{T1}};
    
  ode [above] at (T2.north) {\texttt{T2}};
    
  ode [above] at (T3.north) {\texttt{T3}};
    
  ode [above] at (T4.north) {\texttt{T4}};
    
  ode [above] at (tomadas.north) {\texttt{tomadas}};
    
  ode [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
      }]
    
  ode (T1) [varint] {2};
    
  ode (T2) [varint,right=of T1] {4};
    
  ode (T3) [varint,right=of T2] {3};
    
  ode (T4) [varint,right=of T3] {2};
    
  ode (tomadas) [varint,right=of T4] {11};
    
  ode (notebooks) [varint,right=of tomadas] {8};
  
    
  ode [above] at (T1.north) {\texttt{T1}};
    
  ode [above] at (T2.north) {\texttt{T2}};
    
  ode [above] at (T3.north) {\texttt{T3}};
    
  ode [above] at (T4.north) {\texttt{T4}};
    
  ode [above] at (tomadas.north) {\texttt{tomadas}};
    
  ode [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}