Problem As

Arquivo
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE *fp;
char c;
int count=0;
fp = fopen ("codigo.txt","r");
if (fp==0)
{
printf ("Arquivo nao encontrado!");
exit(fp);
}
while ((c=getc(fp)) != EOF)
count++;
printf ("Total de caracteres no arquivo: %d",count);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE *fp;
char c;
char str[100];
int count=0,i;
fp = fopen ("arquivo.txt","a");
if (!fp)
{
printf ("Arquivo nao encontrado!");
exit(fp);
}
printf ("Digite uma frase a ser gravada no arquivo: ");
gets (str);
fputs(str,fp);
putc ('\n',fp);
//for (i=0;str[i];i++)
// putc (str[i],fp);
fclose(fp);
fp = fopen ("arquivo.txt","r");
while ((c=getc(fp)) != EOF)
count++;
printf ("Total de caracteres no arquivo: %d",count);
fclose(fp);
return 0;
}
1
DEFINE
#include <stdio.h>
#define ret(a) ((a%2) ? (0):(1));
int main ()
{
int n;
printf ("Digite um numero: ");
scanf ("%d",&n);
n = ret(n);
printf ("%d",n);
return 0;
}
Ordenação Bubble Sort

#include <stdio.h>
#define MAX 10
int main()
{
int vetor[MAX],i,j,aux;
//preencher o vetor
for (i=0;i<MAX;i++)
scanf ("%d",&vetor[i]);
//ordenar o vetor
for (i=0;i<=MAX-2;i++)
{
for (j=0;j<=MAX-2-i;j++)
{
if (vetor[j] > vetor[j+1])
{
aux = vetor[j];
vetor[j]=vetor[j+1];
vetor[j+1]=aux;
}
}
}
//mostrar o vetor
printf ("\n");
for (i=0;i<MAX;i++)
printf ("%d ",vetor[i]);
return 0;
}
2
Ordenação Inserção
#include <stdio.h>
#define MAX 10
int main()
{
//preencher o vetor
for (i=0;i<MAX;i++)
//ordenar o vetor
{
aux = vetor[i];
j=i-1;
while ((j>=0) && (aux<vetor[j]))
{
vetor[j+1] = vetor[j];
j--;
}
vetor[j+1]=aux;
}
//mostrar o vetor
printf ("\n");
for (i=0;i<MAX;i++)
return 0;
}
Ordenação Merge Sort

#include <stdio.h>
#define MAX 10
int A[MAX],B[MAX];
void mergesort(int begin, int end);
int main()
{
int i;
//preencher o vetor
for (i=0;i<MAX;i++)
scanf ("%d",&A[i]);
//ordenar o vetor
mergesort(0,MAX-1);
3
//mostrar o vetor
printf ("\n");
for (i=0;i<MAX;i++)
printf ("%d ",A[i]);
return 0;
}
void mergesort(int begin, int end)

{
int left = 0, right = 0, middle = 0;
int i = 0;
if(begin == end)
return;
middle = (begin + end)/2;
mergesort(begin,middle);
mergesort(middle + 1,end);
left = begin;
right = middle + 1;
for(i = begin;i <= end;i++)

{
if(right > end || (left <= middle && A[left] <= A[right]))
{
B[i] = A[left];
left++;
}
else
{
B[i] = A[right];
right++;
}
}
for(i = begin;i <= end;i++)
A[i] = B[i];
}
4
Ordenação Seleção Direta
#include <stdio.h>
#define MAX 10
int main()
{
//preencher o vetor
for (i=0;i<MAX;i++)
//ordenar o vetor
{
for (j=i+1;j<=MAX-1;j++)
{
if (vetor[i] > vetor[j])
{
aux = vetor[i];
vetor[i]=vetor[j];
vetor[j]=aux;
}
}
}
//mostrar o vetor
printf ("\n");
for (i=0;i<MAX;i++)
return 0;
}
5
Ordenação Quick Sort
#include <stdio.h>
int compare (const void * a, const void * b)

{
return ( *(int*)a - *(int*)b );
}
int main ()
{
int n;
scanf ("%d",&n);
int votos[n];
for (i=0;i<n;i++)
scanf ("%d",&votos[i]);
qsort (votos, n, sizeof(int), compare);
for (i=0;i<n;i++)
printf ("%d",votos[i]);
return 0;
}
Ordenação Struct Quick

#include <stdio.h>
#include <stdlib.h>
typedef int (*compfn)(const void*, const void*);
struct animal { int number;

char name[15];
};
struct animal array[10] = { { 1, "Anaconda" },

{ 5, "Elephant" },
{ 8, "Hummingbird" },
{ 4, "Dalmatian" },
{ 3, "Canary" },
{ 9, "Llama" },
{ 2, "Buffalo" },
{ 6, "Flatfish" },
{ 10, "Zebra" },
{ 7, "Giraffe" } };
void printarray(void);
int compare(struct animal *, struct animal *);
6
void main(void)
{
printf("List before sorting:\n");
printarray();
qsort((void *) &array, // Beginning address of array

10, // Number of elements in array
sizeof(struct animal), // Size of each element
(compfn)compare ); // Pointer to compare function
printf("\nList after sorting:\n");

printarray();
}
int compare(struct animal *elem1, struct animal *elem2)

{
if ( elem1->number < elem2->number)
return -1;
else if (elem1->number > elem2->number)

return 1;
else
return 0;
}
void printarray(void)
{
int i;
for (i = 0; i < 10; i++)

printf("%d: Number %d is a %s\n",
i+1, array[i].number, array[i].name);
}
7
Recursividade
Fatorial
#include <stdio.h>
int fat (int n)

{
return n ? n*fat(n-1):1;
}
int main ()
{
int n;
scanf ("%d",&n);
printf ("Fatorial de %d %c: %d",n,130,fat(n));
return 0;
}
Soma
#include <stdio.h>
int soma (int n)

{
return n ? n+=soma(n-1):0;
}
int main ()
{
int n;
scanf ("%d",&n);
printf ("A soma de 0 a %d %c: %d",n,130,soma(n));
return 0;
}
8
Fim de Arquivo
int main ()
{
char palavra[21] ; //declara a variavel
while (scanf ("%s",&palavra) != EOF)
{
//code
}
return 0;
}
Unsigned long long int

#include <stdio.h>
int main()
{
unsigned long long int x = 1234567890123456789;
printf("The 64 bit number is: %I64d\n",x);
return 0;
}
818. Aeroporto
9
Problema: AERO
A crescente utilização do transporte aéreo preocupa os especialistas, que prevêem

que o congestionamento em aeroportos poderá se tornar um grande problema no
futuro. Os números atuais já são alarmantes: relatórios oficiais demonstram que na
Europa, em junho de 2001, houve uma média de 7.000 atrasos de vôos por dia.
Preocupada com a previsão dos seus especialistas em tráfego aéreo, a Associação
de Transporte Aéreo Internacional (ATAI) está começando um estudo para
descobrir quais são os aeroportos onde o tráfego aéreo pode vir a ser mais
problemático no futuro.
Tarefa
Como programador recém contratado pela ATAI você foi encarregado de escrever
um programa para determinar, a partir de uma listagem de aeroportos e vôos, qual
aeroporto possui maior probabilidade de congestionamento no futuro. Como
medida da probabilidade de congestionamento será utilizado neste estudo o
número total de vôos que chegam ou que partem de cada aeroporto.
Entrada
A entrada é composta de vários conjuntos de teste. A primeira linha de um

conjunto de teste contém dois números inteiros A e V, que indicam
respectivamente o número de aeroportos e o número de vôos. Os aeroportos são
identificados por inteiros de 1 a A. As V linhas seguintes contêm cada uma a
informação de um vôo, representada por um par de números inteiros positivos X e
Y, indicando que há um vôo do aeroporto X para o aeroporto Y. O final da entrada é
indicado quando A = V = 0.
Saída
Para cada conjunto de teste da entrada seu programa deve produzir três linhas. A
primeira linha identifica o conjunto de teste, no formato “Teste n”, onde n é
numerado a partir de 1. A segunda linha deve conter o identificador do aeroporto
que possui maior tráfego aéreo. Caso mais de um aeroporto possua este valor
máximo, você deve listar todos estes aeroportos, em ordem crescente de
identificação, e separados por pelo menos um espaço em branco. A terceira linha
deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve
ser seguida rigorosamente.
Exemplo
Entrada:
5 7
1 3
2 1
3 2
3 4
4 5
3 5
2 5
3 5
1 3
10
1 2
3 2
1 2
2 1
0 0
Output:
Teste 1
3
Teste 2
1 2
Resolução
#include <stdio.h>
int main ()
{
int a, v, i, x, y, maior, teste=1;
scanf ("%d %d",&a,&v);
while (a!=0 && v!=0)
{
a = a+1;
maior = 0;
int destino[a];
for (i=0;i<a;i++)
{
destino[i] = 0;
}
for (i=0;i<v;i++)
{
scanf ("%d %d",&x,&y);
destino[x] += 1;
destino[y] += 1;
}
for (i=0;i<a;i++)
{
if (destino[i] > maior)
maior = destino[i];
}
printf ("Teste %d\n",teste);
teste++;
for (i=0;i<a;i++)
{
if (destino[i] == maior)
printf ("%d ",i);
}
printf ("\n\n");
scanf ("%d %d",&a,&v);
}
return 0;
}
11
5474. Alarme Despertador
Problema: ALADES
Daniela é enfermeira em um grande hospital, e tem os horários de trabalho muito

variáveis.Para piorar, ela tem sono pesado, e uma grande dificuldade para acordar
com relógios despertadores.
Recentemente ela ganhou de presente um relógio digital, com alarme com vários
tons, e tem esperança que isso resolva o seu problema. No entanto, ela anda muito
cansada e quer aproveitar cada momento de descanso. Por isso, carrega seu
relógio digital despertador para todos os lugares, e sempre que tem um tempo de
descanso procura dormir, programando o alarme despertador para a hora em que
tem que acordar. No entanto, com tanta ansiedade para dormir, acaba tendo
dificuldades para adormecer e aproveitar o descanso.
Um problema que a tem atormentado na hora de dormir é saber quantos minutos

ela teria de sono se adormecesse imediatamente e acordasse somente quando o
despertador tocasse. Mas ela realmente não é muito boa com números, e pediu sua
ajuda para escrever um programa que, dada a hora corrente e a hora do alarme,
determine o número de minutos que ela poderia dormir.
Entrada
A entrada contém vários casos de teste. Cada caso de teste é descrito em uma
linha, contendo quatro números inteiros H1, M1, H2 e M2, com H1:M1
representando a hora e minuto atuais, e H2:M2 representando a hora e minuto
para os quais o alarme despertador foi programado (0≤H1≤23, 0≤M1≤59,
0≤H2≤23, 0≤M2 ≤59).
O final da entrada é indicado por uma linha que contém apenas quatro zeros,
separados por espaços em branco.
Os dados devem ser lidos da entrada padrão.
Saída
Para cada caso de teste da entrada seu programa deve imprimir uma linha, cada
uma contendo um número inteiro, indicando o número de minutos que Daniela tem
para dormir.
O resultado de seu programa deve ser escrito na saída padrão.
Exemplo
Entrada:
1 5 3 5
23 59 0 34
21 33 21 10
0 0 0 0
Saída:
12
120
35
1417
Restrições
0 <= A <= 100 (A = 0 apenas para indicar o fim da entrada)

0 <= V <= 10000 (V = 0 apenas para indicar o fim da entrada)
1 <= X <= A
1 <= Y <= A
X != Y
Resolução
#include <stdio.h>
int main ()
{
int h1, m1, h2, m2, time;
while (scanf("%d %d %d %d",&h1,&m1,&h2,&m2))
{
if (!h1 && !m1 && !h2 && !m2)
return 0;
else
{
if ((h1==h2) && (m1==m2))
time=0;
else if ((h1==h2) && (m1<m2))
time=m2-m1;
else if ((h1==h2) && (m1>m2))
time=1440-(m1-m2);
else if ((h1<h2) && (m1<m2))
time=((h2-h1)*60)+(m2-m1);
else if ((h1<h2) && (m1>m2))
time=((h2-h1)*60)-(m1-m2);
else if ((h1<h2) && (m1==m2))
time=(h2-h1)*60;
else if ((h1>h2) && (m1<m2))
time=((24-h1)*60)+(h2*60)+(m2-m1);
else if ((h1>h2) && (m1>m2))
time=((24-h1)*60)+(h2*60)-(m1-m2);
else if ((h1>h2) &&(m1==m2))
time=((24-h1)*60)+(h2*60);
printf ("%d\n",time);
}
}
return 0;
}
13
1386. Bafo
Problema: BAFO
Álbuns de figurinhas – sejam de times de futebol, princesas ou super-heróis – têm

marcado gerações de crianças e adolescentes. Conseguir completar um álbum é
uma tarefa muitas vezes árdua, envolvendo negociações com colegas para a troca
de figurinhas. Mas a existência das figurinhas propicia uma outra brincadeira, que
foi muito popular entre crianças no século passado: o jogo de bater figurinhas (o
famoso “Bafo”). O jogo é muito simples, mas divertido (e muito competitivo). No
início de uma partida, cada criança coloca em uma pilha um certo número de
figurinhas. Uma partida é composta de rodadas; a cada rodada as crianças batem
com a mão sobre a pilha de figurinhas, tentando virá-las com o vácuo formado pelo
movimento da mão. As crianças jogam em turnos, até que a pilha de figurinhas
esteja vazia. Ganha a partida a criança que conseguir virar mais figurinhas.
Aldo e Beto estão jogando bafo com todas as suas figurinhas e pediram sua ajuda
para calcular quem é o vencedor.
Tarefa
Você deve escrever um programa que, dada a quantidade de figurinhas que Aldo e
Beto viraram em cada rodada, determine qual dos dois é o vencedor.
Entrada
A entrada é composta de vários casos de teste, cada um correspondendo a uma

partida entre Aldo e Beto. A primeira linha de um caso de teste contém um número
inteiro R que indica quantas rodadas ocorreram na partida. Cada uma das R linhas
seguintes contém dois inteiros, A e B, que correspondem, respectivamente, ao
número de figurinhas que Aldo e Beto conseguiram virar naquela rodada. Em todos
os casos de teste há um único vencedor (ou seja, não ocorre empate). O final da
entrada é indicado por R = 0.
Saída
Para cada caso de teste da entrada, seu programa deve produzir três linhas na
saída. A primeira linha deve conter um identificador do caso de teste, no formato
“Teste n”, onde n é numerado seqüencialmente a partir de 1. A segunda linha deve
conter o nome do vencedor (Aldo ou Beto). A terceira linha deve ser deixada em
branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida
rigorosamente.
Exemplo
Entrada:
2
1 5
2 3
3
0 0
4 7
10 0
0
14
Saída:
Teste 1
Beto
Teste 2
Aldo
Restrições
1 <= R <= 1000 (R = 0 apenas para indicar o final da entrada)

0 <= A <= 100
0 <= B <= 100
Resolução
#include <stdio.h>
int main ()
{
int n, i, teste = 1, conta = 0, contb = 0;
scanf("%d",&n);
while (n!=0)
{
int a[n], b[n];
for (i=0;i<n;i++)
{
scanf ("%d %d",&a[i],&b[i]);
conta = conta + a[i];
contb = contb + b[i];
}
printf ("Teste %d\n", teste);
teste++;
if (contb > conta)
printf ("Beto\n");
else
printf ("Aldo\n");
printf ("\n");
conta = 0;
contb = 0;
scanf("%d",&n);
}
return 0;
}
15
812. Bits Trocados
Problema: BIT
As Ilhas Weblands formam um reino independente nos mares do Pacífico. Como é

um reino recente, a sociedade é muito influenciada pela informática. A moeda
oficial é o Bit; existem notas de B$ 50,00, B$10,00, B$5,00 e B$1,00. Você foi
contratado(a) para ajudar na programação dos caixas automáticos de um grande
banco das Ilhas Weblands.
Tarefa
Os caixas eletrônicos das Ilhas Weblands operam com todos os tipos de notas
disponíveis, mantendo um estoque de cédulas para cada valor (B$ 50,00, B$10,00,
B$5,00 e B$1,00). Os clientes do banco utilizam os caixas eletrônicos para efetuar
retiradas de um certo número inteiro de Bits.
Sua tarefa é escrever um programa que, dado o valor de Bits desejado pelo cliente,
determine o número de cada uma das notas necessário para totalizar esse valor, de
modo a minimizar a quantidade de cédulas entregues. Por exemplo, se o cliente
deseja retirar B$50,00, basta entregar uma única nota de cinquenta Bits. Se o
cliente deseja retirar B$72,00, é necessário entregar uma nota de B$50,00, duas
de B$10,00 e duas de B$1,00.
Entrada
A entrada é composta de vários conjuntos de teste. Cada conjunto de teste é

composto por uma única linha, que contém um número inteiro positivo V, que
indica o valor solicitado pelo cliente. O final da entrada é indicado por V = 0.
Saída
Para cada conjunto de teste da entrada seu programa deve produzir três linhas na
saída. A primeira linha deve conter um identificador do conjunto de teste, no
formato “Teste n”, onde n é numerado a partir de 1. Na segunda linha devem
aparecer quatro inteiros I, J, K e L que representam o resultado encontrado pelo
seu programa: I indica o número de cédulas de B$50,00, J indica o número de
cédulas de B$10,00, K indica o número de cédulas de B$5,00 e L indica o número
de cédulas de B$1,00. A terceira linha deve ser deixada em branco. A grafia
mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
Exemplo
Entrada:
1
72
0
Saída:
Teste 1
0 0 0 1
Teste 2
1 2 0 2
16
Restrições
0 <= V <= 10000 (V = 0 apenas para indicar o fim da entrada)
Resolução
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int valor=1,i,j,k,l,teste=1;
while (valor!= 0)
{
scanf("%d",&valor);
if(valor != 0)
{
i = valor/50;
valor = valor - (i*50);
j = valor/10;
valor = valor - (j*10);
k = valor/5;
valor = valor - (k*5);
l = valor/1;
valor = valor - (l*1);
printf("Teste %d\n",teste);
printf("%d %d %d %d",i,j,k,l);
printf("\n\n");
teste++;
valor = 1;
}
}
system ("PAUSE");
return 0;
}
17
1334. Calculando
Problema: CALCULA
A disseminação dos computadores se deve principalmente à capacidade de eles se

comportarem como outras máquinas, vindo a substituir muitas destas. Esta
flexibilidade é possível porque podemos alterar a funcionalidade de um computador,
de modo que ele opere da forma que desejarmos: essa é a base do que chamamos
programação.
Tarefa
Sua tarefa é escrever um programa que faça com que o computador opere como
uma calculadora simples. O seu programa deve ler expressões aritméticas e
produzir como saída o valor dessas expressões, como uma calculadora faria. O
programa deve implementar apenas um subconjunto reduzido das operações
disponíveis em uma calculadora: somas e subtrações.
Entrada
A entrada é composta de vários conjuntos de testes. A primeira linha de um

conjunto de testes contém um número inteiro m (1 ≤ m ≤ 100), indicando o
número de operandos da expressão a ser avaliada. A segunda linha de um conjunto
de testes contém a expressão aritmética a ser avaliada, no seguinte formato:
X1 s1 X2 s2 ... Xm-1 sm-1 Xm
onde
 Xi, 1 ≤ i ≤ m, é um operando (0 ≤ Xi ≤ 100);

 sj, 1 ≤ j <m, é um operador, representado pelos símbolos '+’ ou '-’;
 não há espaços em branco entre operandos e operadores.
O final da entrada é indicado pelo valor m = 0.
Exemplo de Entrada
3
3+7-22
3
5-10-77
10
1+2+3+4+5+6+7+8+9+10
0
Saída
Para cada conjunto de testes da entrada seu programa deve produzir três linhas. A
primeira linha deve conter um identificador da expressão, no formato "Teste n",
onde n é numerado a partir de 1. Na segunda linha deve aparecer o resultado
encontrado pelo seu programa. A terceira linha deve ser deixada em branco. A
grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
Exemplo de Saída
18
Teste 1
-12
Teste 2
-82
Teste 3
55
(esta saída corresponde ao exemplo de entrada acima)
Restrições
1 ≤ m ≤ 100
0 ≤ Xi ≤ 100 para todo 1 ≤ i ≤ m
Resolução
#include <stdio.h>
int main ()
{
int num, m, total, i, teste = 1;
scanf("%d",&m);
while (m!=0)
{
total = 0;
for (i=0;i<m;i++)
{
scanf("%d",&num);
total = total+num;
}
teste++;
printf("%d\n\n",total);
scanf ("%d",&m);
}
return 0;
}
19
1850. Conte os Fatores
Problema: CFATORES
Escreva um programa que computa o número de diferentes fatores primos de um

inteiro positivo.
Entrada
A entrada consistirá de uma série de inteiros positivos. Cada linha possui somente
um número. O valor máximo de um número é 1000000. O fim da entrada é indicado
por um número igual a 0. Esse número não deve ser considerado como parte do
conjunto de teste.
Saída
O programa deve imprimir cada resultado em uma linha diferente, seguindo o

formado dado no exemplo de saída.
Exemplo
Entada:
289384
930887
692778
636916
747794
238336
885387
760493
516650
641422
0
Saída:
289384 : 3
930887 : 2
692778 : 5
636916 : 4
747794 : 3
238336 : 3
885387 : 2
760493 : 2
516650 : 3
641422 : 3
20
Resolução
#include <stdio.h>
int main ()
{
int val,j,n,i,nprimo,achei,count;
while (scanf("%d",&n) && n!=0)
{
nprimo=0;
achei=0;
val=n;
i=1;
while (n!=1)
{
if ((n%i==0) && i>1)
{
n/=i;
if (achei)
{
nprimo++;
achei=0;
}
}
else
{
i++;
achei=1;
}
}
printf ("%d : %d\n",val,nprimo);
}
return 0;
}
21
8707. Chamada
Problema: CHAMADA1
Tia Joana é uma respeitada professora e tem vários alunos. Em sua última aula, ela
prometeu que iria sortear um aluno para ganhar um bônus especial na nota final:
ela colocou N pedaços de papel numerados de 1 a N em um saquinho e sorteou um
determinado número K; o aluno premiado foi o K-ésimo aluno na lista de chamada.
O problema é que a Tia Joana esqueceu o diário de classe, então ela não tem como
saber qual número corresponde a qual aluno. Ela sabe os nomes de todos os
alunos, e que os números deles, de 1 até N, são atribuídos de acordo com a ordem
alfabética, mas os alunos dela estão muito ansiosos e querem logo saber quem foi
o vencedor.
Dado os nomes dos alunos da Tia Joana e o número sorteado, determine o nome
do aluno que deve receber o bônus.
Tarefa
Dado os nomes dos alunos da Tia Joana e o número sorteado, determine o nome
do aluno que deve receber o bônus.
Entrada
A primeira linha contém dois inteiros N e K separados por um espaço em branco (1

≤ K ≤ N ≤ 100). Cada uma das N linhas seguintes contém uma cadeia de
caracteres de tamanho mínimo 1 e máximo 20 representando os nomes dos alunos.
Os nomes são compostos apenas por letras minúsculas de 'a' a 'z'.
Saída
Seu programa deve imprimir uma única linha, contendo o nome do aluno que deve
receber o bônus
Exemplo
Entrada
5 1
maria
joao
carlos
vanessa
jose
Saída
carlos
Entrada
5 5
maria
joao
22
carlos
vanessa
jose
Saída
vanessa
Entrada
5 3
maria
joao
carlos
vanessa
jose
Saída
jose
Resolução
#include <stdio.h>
int main ()
{
int i,j,n,k;
scanf ("%d %d",&n,&k);
char nomes[n][22],temp[22];
for (i=0;i<n;i++)
scanf ("%s",&nomes[i]);
for(i = 1; i < n; i++)
for (j = 0; j < n -1 ; j++)
if(strcmp(nomes[j],nomes[j+1]) > 0)
{
strcpy(temp,nomes[j]);
strcpy(nomes[j],nomes[j+1]);
strcpy(nomes[j+1],temp);
}
printf ("%s",nomes[k-1]);
return 0;
}
23
840. Cofrinhos da Vó Vitória
Problema: COFRE
Vó Vitória mantém, desde o nascimento dos netos Joãozinho e Zezinho, um ritual

que faz a alegria dos meninos. Ela guarda todas as moedas recebidas como troco
em dois pequenos cofrinhos, um para cada neto. Quando um dos cofrinhos fica
cheio, ela chama os dois netos para um alegre almoço, ao final do qual entrega aos
garotos as moedas guardadas nos cofrinhos de cada um.
Ela sempre foi muito zelosa quanto à distribuição igualitária do troco arrecadado.
Quando, por força do valor das moedas, ela não consegue depositar a mesma
quantia nos dois cofrinhos, ela memoriza a diferença de forma a compensá-la no
próximo depósito.
Tarefa
Vó Vitória está ficando velha e tem medo que deslizes de memória a façam cometer
injustiças com os netos, deixando de compensar as diferenças entre os cofrinhos.
Sua tarefa é ajudar Vó Vitória, escrevendo um programa de computador que
indique as diferenças entre os depósitos, de forma que ela não tenha que
preocupar-se em memorizá-las.
Entrada

conjunto de teste contém um número inteiro N, que indica o número de depósitos
nos cofrinhos. As N linhas seguintes descrevem cada uma um depósito nos
cofrinhos; o depósito é indicado por dois valores inteiros J e Z, separados por um
espaço em branco, representando respectivamente os valores, em centavos,
depositados nos cofres de Joãozinho e Zezinho. O final da entrada é indicado por N
= 0.
Saída
Para cada conjunto de teste da entrada seu programa deve produzir um conjunto
de linhas na saída. A primeira linha deve conter um identificador do conjunto de
teste, no formato “Teste n”, onde n é numerado seqüencialmente a partir de 1. A
seguir seu programa deve escrever uma linha para cada depósito do conjunto de
testes. Cada linha deve conter um inteiro que representa a diferença (em centavos)
entre o valor depositado nos cofrinhos do Joãozinho e do Zezinho. Deixe uma linha
em branco ao final de cada conjunto de teste. A grafia mostrada no Exemplo de
Saída, abaixo, deve ser seguida rigorosamente.
Exemplo
Entrada:
3
20 25
10 5
10 10
4
0 5
24
12 0
0 20
17 1
0
Saída:
Teste 1
-5
0
0
Teste 2
-5
7
-13
3
Restrições
0 <= N <= 100 (N = 0 apenas para indicar o fim da entrada)

0 <= J <= 100 (valor de cada depósito no cofre de Joãozinho)
0 <= Z <= 100 (valor de cada depósito no cofre de Zezinho)
Resolução
#include <stdio.h>
int main ()
{
int n=1, i, teste = 1;;
while (n!=0)
{
scanf ("%d",&n);
if (n!=0)
{
int j[n], z[n], saldo[n];
saldo[0] = 0;
for (i=0;i<n;i++)
scanf ("%d %d",&j[i],&z[i]);
teste++;
for (i=0;i<n;i++)
{
if (i==0)
saldo[i] = (j[i]-z[i]);
else
saldo[i] = saldo[i-1]+(j[i]-z[i]);
printf ("%d\n", saldo[i]);
}
printf ("\n");
}
}
return 0;
25
}
8777. Cometa
Problema: COMETA2
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.
Tarefa
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).
Entrada
A única linha da entrada contém um único inteiro A (2010 ≤ A ≤ 10 4), indicando o

ano atual.
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.
Exemplo
Entrada
2010
Saída
2062
Entrada
10000
Saída
10042
Entrada
2062
Saída
2138
26
Resolução
#include <stdio.h>
int main ()
{
int a,ano=1986;
scanf ("%d",&a);
while (ano<=a)
{
ano+=76;
}
printf ("%d",ano);
return 0;
}
27
8703. Conta de água
Problema: CONTA1
A empresa local de abastecimento de água, a Saneamento Básico da Cidade (SBC),

está promovendo uma campanha de conservação de água, distribuindo cartilhas e
promovendo ações demonstrando a importância da água para a vida e para o meio
ambiente.
Para incentivar mais ainda a economia de água, a SBC alterou os preços de seu
fornecimento de forma que, proporcionalmente, aqueles clientes que consumirem
menos água paguem menos pelo metro cúbico. Todo cliente paga mensalmente
uma assinatura de R$ 7, que inclui uma franquia de 10 m³ de água. Isto é, para
qualquer consumo entre 0 e 10 m³ , o consumidor paga a mesma quantia de R$ 7
reais (note que o valor da assinatura deve ser pago mesmo que o consumidor não
tenha consumido água). Acima de 10 m³ cada metro cúbico subsequente tem um
valor diferente, dependendo da faixa de consumo. A SBC cobra apenas por
quantidades inteiras de metros cúbicos consumidos. A tabela abaixo especifica o
preço por metro cúbico para cada faixa de consumo:
Faixa de consumo (m³) Preço (m³)

até 10 incluído na franquia
11 a 30 R$ 1
31 a 100 R$ 2
101 em diante R$ 5
Assim, por exemplo, se o consumo foi de 120 m³ , o valor da conta é:
 7 reais da assinatura básica;

 20 reais pelo consumo no intervalo 11 - 30 m³;
 140 reais pelo consumo no intervalo 31 - 100 m³;
 100 reais pelo consumo no intervalo 101 - 120 m³.
Logo o valor total da conta de água é R$ 267.
Tarefa
Escreva um programa que, dado o consumo de uma residência em m3 , calcula o

valor da conta de água daquela residência.
Entrada
A única linha da entrada contém um único inteiro N, indicando o consumo de água

da residência, em m³ (0 ≤ N ≤ 10³).
Saída
Seu programa deve imprimir uma única linha, contendo o valor da conta de água
daquela residência.
28
Exemplo
Entrada
8
Saída
7
Entrada
14
Saída
11
Entrada
42
Saída
51
Resolução
#include <stdio.h>
int main ()
{
int n, i, total=7;
scanf ("%d",&n);
for (i=0;i<=n;i++)
{
if (i>=11 && i<=30)
total+=1;
else if (i>=31 && i<=100)
total+=2;
else if (i>=101)
total+=5;
}
printf ("%d",total);
return 0;
}
29
1735. Não é Mais um Joguinho Canadense
Problema: CONTAGEM
O Canadá é um país muito frio. Em 8 meses por ano as temperaturas praticamente

impedem que as ruas sejam ocupadas por vida inteligente, restando apenas
criaturas resistentes ao frio como alces, ursos e canadenses (He he he,
brincadeirinha...). Nestes longos meses de inverno famílias buscam diversão em
frente de suas lareiras (ou, para as mais corajosas, ao redor de suas fogueiras). A
família Smith, de Banff, inventou o jogo que descrevemos a seguir.
A brincadeira começa com uma das crianças desenhando um diagrama com estados
(representados por bolinhas) ligados por transições (flechas ligando os estados).
Cada transição tem uma letra e um número associados. Podemos fazer diversos
passeios neste diagrama, partindo de um estado inicio caminhando por suas
transições e terminando em um estado final. Um passeio forma uma palavra
(obtida da concatenação das letras das transições percorridas) e tem um custo (que
é dado pelo produto dos números destas transições).
Exemplo. Considere o diagrama abaixo.
.--- .---. --.

1b | | p | | 1a
'-> '---' <-'
|
| 1b
|
V
.-- .---. --.
2b | | q | | 2a
'-> '---' <-'
Todos os passeios iniciam no estado p e terminam em q.
O passeio que segue pelas transições (p,1a), (p,1a), (p,1b) e termina no

estado q forma a palavra aab concatenando as letras de cada transição tem custo 1
(produto dos números destas transições).
O passeio que segue pelas transições (p,1a), (p,1a), (p,1b), (q,2b) e termina
no estado q forma a palavra aabb e tem custo 2.
O jogo inventado pelo papai Smith era o seguinte. Depois de desenhar um

diagrama como esse, um dos membros da família falava uma palavra, e os outros
deveriam descobrir a soma dos custos de todos os passeios no diagrama que
formam a palavra dada tais que iniciam no estado p e terminam no estado q. No
caso do exemplo do diagrama acima, se o Sr. Smith pedisse a palavra aba a
resposta deveria ser 2.
Entrada
A entrada é composta de diversas palavras (o diagrama é sempre o da figura).

Cada instância é dada por uma linha contendo uma palavra. Uma palavra é uma
seqüência de letras [a,b] com no máximo 60 letras.
30
A entrada termina com final de arquivo.
Saída
Para cada instância, você deverá imprimir um identificador Palavra k, onde k é o

número da instância atual. Na linha seguinte imprima a soma dos custos.
Após cada instância imprima uma linha em branco.
Exemplo
Entrada:
a
b
ab
ba
aaaa
bbbb
aabb
abbb
Saída:
Palavra 1
0
Palavra 2
1
Palavra 3
1
Palavra 4
2
Palavra 5
0
Palavra 6
15
Palavra 7
3
Palavra 8
7
31
Resolução
#include <iostream.h>
#include <math.h>
#include <string.h>
int main()
{
int i, tamanho, palavra=1,potencia;
unsigned long long int resultado=0;
char nome[62];
while (cin >> nome)
{
tamanho=strlen(nome);
for(i=0;i<tamanho;i++)
{
if(nome[i]=='b')
{
resultado += (1ll << ( tamanho-i ));
}
}
resultado /= 2;
cout << "Palavra " << palavra++ << "\n" << resultado << "\n\n";
resultado=0;
}
return 0;
}
32
8704. Copa do mundo
Problema: COPA1
Este ano tem Copa do Mundo! O país inteiro se prepara para torcer para a equipe
canarinho conquistar mais um título, tornando-se hexacampeã.
Na Copa do Mundo, depois de uma fase de grupos, dezesseis equipes disputam a

Fase final, composta de quinze jogos eliminatórios. A figura abaixo mostra a tabela
de jogos da Fase final:
Na tabela de jogos, as dezesseis equipes finalistas são representadas por letras

maiúsculas (de A a P), e os jogos são numerados de 1 a 15. Por exemplo, o jogo 3
é entre as equipes identificadas por E e F; o vencedor desse jogo enfrentará o
vencedor do jogo 4, e o perdedor será eliminado. A equipe que vencer os quatro
jogos da Fase final será a campeã (por exemplo, para a equipe K ser campeã ela
deve vencer os jogos 6, 11, 14 e 15.
Tarefa
Dados os resultados dos quinze jogos da Fase final, escreva um programa que
determine a equipe campeã.
Entrada
A entrada é composta de quinze linhas, cada uma contendo o resultado de um

jogo. A primeira linha contém o resultado do jogo de número 1, a segunda linha o
resultado do jogo de número 2, e assim por diante. O resultado de um jogo é
representado por dois números inteiros M e N separados por um espaço em branco,
indicando respectivamente o número de gols da equipe representada à esquerda e
à direita na tabela de jogos (0 ≤ M ≤ 20, 0 ≤ N ≤ 20 e M ≠ N).
Saída
33
Seu programa deve imprimir uma única linha, contendo a letra identificadora da
equipe campeã.
Exemplo
Entrada
4 1
1 0
0 4
3 1
2 3
1 2
2 0
0 2
1 2
4 3
0 1
3 2
3 4
1 4
1 0
Saída
F
Entrada
2 0
1 0
2 1
1 0
1 0
1 2
1 2
1 0
2 1
1 0
0 1
0 2
2 1
1 0
2 1
Saída
A
34
Resolução
#include <stdio.h>
int main ()
{
int i, j, m, n, count=0, campeao=0;
int vet[16];
for (i=0;i<16;i++)
vet[i]=0;
for (i=0;i<8;i++)
{
scanf ("%d %d",&m,&n);
if (m>n)
{
vet[count]=1;
count+=2;
}
else
{
count++;
vet[count]=1;
count++;
}
}

if (m>n)
{
for(j=0;j<2;j++)
{
if(vet[j]==1)
vet[j]++;
}
}
else
{
for(j=2;j<4;j++)
{
if(vet[j]==1)
vet[j]++;
}
}

if (m>n)
{
for(j=4;j<6;j++)
{
if(vet[j]==1)
35
vet[j]++;
}
}
else
{
for(j=6;j<8;j++)
{
if(vet[j]==1)
vet[j]++;
}
}

if (m>n)
{
for(j=8;j<10;j++)
{
if(vet[j]==1)
vet[j]++;
}
}
else
{
for(j=10;j<12;j++)
{
if(vet[j]==1)
vet[j]++;
}
}

if (m>n)
{
for(j=12;j<14;j++)
{
if(vet[j]==1)
vet[j]++;
}
}
else
{
for(j=14;j<16;j++)
{
if(vet[j]==1)
vet[j]++;
}
}

if (m>n)
{
for (i=0;i<4;i++)
36
{
if (vet[i]==2)
vet[i]++;
}
}
else
{
for (i=4;i<8;i++)
{
if (vet[i]==2)
vet[i]++;
}
}

if (m>n)
{
for (i=8;i<12;i++)
{
if (vet[i]==2)
vet[i]++;
}
}
else
{
for (i=12;i<16;i++)
{
if (vet[i]==2)
vet[i]++;
}
}

if (m>n)
{
for (j=0;j<8;j++)
{
if (vet[j]==3)
{
vet[j]++;
campeao=j;
}
}
}
else
{
for (j=8;j<16;j++)
{
if (vet[j]==3)
{
vet[j]++;
campeao=j;
37
}
}
}
if (campeao==0)
printf ("A");
else if (campeao==1)
printf ("B");
printf ("C");
printf ("D");
printf ("E");
printf ("F");
printf ("G");
printf ("H");
printf ("I");
printf ("J");
printf ("K");
printf ("L");
printf ("M");
printf ("N");
printf ("O");
printf ("P");
return 0;
}
38
3240. Dama
Problema: DAMA
O jogo de xadrez possui várias peças com movimentos curiosos: uma delas é a
dama, que pode se mover qualquer quantidade de casas na mesma linha, na
mesma coluna, ou em uma das duas diagonais, conforme exemplifica a figura
abaixo:
O grande mestre de xadrez Kary Gasparov inventou um novo tipo de problema de

xadrez: dada a posição de uma dama em um tabuleiro de xadrez vazio (ou seja,
um tabuleiro 8 × 8, com 64 casas), de quantos movimentos, no mínimo, ela precisa
para chegar em outra casa do tabuleiro?
Kary achou a solução para alguns desses problemas, mas teve dificuldade com
outros, e por isso pediu que você escrevesse um programa que resolve esse tipo de
problema.
Entrada
A entrada contem vários casos de teste. A primeira e única linha de cada caso de
teste contém quatro inteiros X1, Y1 , X2 e Y2 (1 <= X1 , Y1 , X2 , Y2 <= 8).
A dama começa na casa de coordenadas (X1 , Y1), e a casa de destino é a casa de
coordenadas (X2 , Y2). No tabuleiro, as colunas são numeradas da esquerda para
a direita de 1 a 8 e as linhas de cima para baixo também de 1 a 8. As coordenadas
de uma casa na linha X e coluna Y são (X, Y).
O final da entrada é indicado por uma linha contendo quatro zeros.
Saída
Para cada caso de teste da entrada seu programa deve imprimir uma unica linha na
saída, contendo um número inteiro, indicando o menor número de movimentos
necessários para a dama chegar em sua casa de destino.
Exemplo
Entrada
4 4 6 2
39
3 5 3 5
5 5 4 3
0 0 0 0
Saída
1
0
2
Resolução
#include<stdio.h>
int main()
{
int x1,y1,x2,y2,mov=0;
while(scanf("%d %d %d %d",&x1,&y1,&x2,&y2) && x1!=0 && y1!=0 && x2!=0 && y2!=0)
{
if(x1==x2&&y1==y2)
mov=0;
else if(x1==x2||y1==y2)
mov=1;
else if((x1-x2==y1-y2) || (x1-x2==y2-y1) || (x2-x1==y1-y2) || (x2-x1==y2-y1))
mov=1;
else
mov=2;
printf ("%d\n",mov);
}
return 0;
}
40
817. Dobradura
Problema: DOBRA
Tarefa
Zezinho tem aulas de Iniciação Artística em sua escola, e recentemente aprendeu a

fazer dobraduras em papel. Ele ficou fascinado com as inúmeras possibilidades de
se dobrar uma simples folha de papel. Como Zezinho gosta muito de matemática,
resolveu inventar um quebra-cabeça envolvendo dobraduras. Zezinho definiu uma
operação de dobradura D que consiste em dobrar duas vezes uma folha de papel
quadrada de forma a conseguir um quadrado com 1/4 do tamanho original,
conforme ilustrado na figura.
Depois de repetir N vezes esta operação de dobradura D sobre o papel, Zezinho

cortou o quadrado resultante com um corte vertical e um corte horizontal,
conforme a figura abaixo.
Zezinho lançou então um desafio aos seus colegas: quem adivinha quantos pedaços
de papel foram produzidos?
Entrada
A entrada é composta de vários conjuntos de teste. Cada conjunto de teste é

composto de uma única linha, contendo um número inteiro N que indica o número
de vezes que a operação de dobradura D foi aplicada. O final da entrada é indicado
por N = -1.
Saída
formato “Teste n”, onde n é numerado a partir de 1. A segunda linha deve conter o
número de pedaços de papel obtidos depois de cortar a dobradura, calculado pelo
41
seu programa. A terceira linha deve ser deixada em branco. A grafia mostrada no
Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
Exemplo
Entrada:
1
0
-1
Saída:
Teste 1
9
Teste 2
4
Restrições
-1 <= N <= 15 (N = -1 apenas para indicar o fim da entrada)
Resolução
#include <stdio.h>
#include <math.h>
int main ()
{
int n, d, teste = 1;
scanf ("%d",&n);
while (n!=-1)
{
d = (pow(2,n))+1;
d = d*d;
printf ("Teste %d\n",teste++);
printf ("%d\n\n",d);
scanf ("%d",&n);
}
return 0;
}
3773. Eleições
42
Problema: ELEICOES
O prefeito de Piraporinha do Sul foi afastado de seu cargo, devido a acusações de

corrupção em contratos da prefeitura, e por isso foram convocadas novas eleições
para prefeito. Procurando uma renovação política, a comissão eleitoral permitiu que
mesmo candidatos de fora da cidade concorressem ao cargo de prefeito.
Devido a essa nova regra, houve uma quantidade muito grande de candidatos à
prefeitura. O software da comissão eleitoral de Piraporinha do Sul não estava
preparado para isso, e por isso você foi contratado para escrever um programa
que, dados os votos lançados pelos habitantes da cidade, decide qual candidato
ganhou.
Entrada
A entrada é composta de um único caso de teste. A primeira linha contém um

inteiro N representando o número de votos. Nas próximas N linhas, haverá um
inteiro Xi, que representa o i-ésimo voto (os candidatos são identificados por
inteiros).
Saída
Para cada conjunto de teste da entrada seu programa deve produzir uma única
linha, contendo o número do candidato que venceu (aquele que obteve mais
votos). Você pode supor que existe apenas um vencedor.
Restrições
 1 ≤ N ≤ 100000
 1 < Xi ≤ 1000000000
Exemplo
Entrada
5
1000
1000
2588
4000
2587
Saída
1000
Entrada
4
4000
3500
4000
4000
43
Saída
4000
Resolução
#include <stdio.h>
int compare (const void * a, const void * b)

{
return ( *(int*)a - *(int*)b );
}
int main ()
{
int n, i, cont=0, max=0, ganhador=0;
scanf ("%d",&n);
int votos[n];
for (i=0;i<n;i++)
scanf ("%d",&votos[i]);
qsort (votos, n, sizeof(int), compare);
cont = 0;
for (i=0;i<n-1;i++)
{
if (votos[i]==votos[i+1])
{
cont++;
if (cont>max)
{
max = cont;
ganhador = votos[i];
}
}
else
cont=0;
}
printf ("%d",ganhador);
return 0;
}
8778. Elevador
44
Problema: ELEVADO2
A Subindo Bem Confortavelmente (SBC) é uma empresa tradicional, com mais de

50 anos de experiência na fabricação de elevadores. Todos os projetos da SBC
seguem as mais estritas normas de segurança, mas infelizmente uma série de
acidentes com seus elevadores manchou a reputação da empresa.
Ao estudar os acidentes, os engenheiros da companhia concluíram que, em vários

casos, o acidente foi causado pelo excesso de passageiros no elevador. Por isso, a
SBC decidiu fiscalizar com mais rigor o uso de seus elevadores: foi instalado um
sensor em cada porta que detecta a quantidade de pessoas que saem e entram em
cada andar do elevador.
A SBC tem os registros do sensor de todo um dia de funcionamento do elevador

(que sempre começa vazio). Eles sabem que as pessoas são educadas e sempre
deixam todos os passageiros que irão sair em um andar saírem antes de outros
passageiros entrarem no elevador, mas ainda assim eles têm tido dificuldade em
decidir se a capacidade máxima do elevador foi excedida ou não.
Tarefa
Escreva um programa que, dada uma sequência de leituras do sensor e a

capacidade máxima do elevador, determina se a capacidade máxima do elevador
foi excedida em algum momento.
Entrada
A primeira linha da entrada contém dois inteiros N e C, indicando o número de

leituras realizadas pelo sensor e a capacidade máxima do elevador,
respectivamente (1 ≤ N ≤ 1000 e 1 ≤ C ≤ 1000). As N linhas seguintes contêm,
cada uma, uma leitura do sensor. Cada uma dessas linhas contém dois inteiros S e
E, indicando quantas pessoas saíram e quantas pessoas entraram naquele andar,
respectivamente (0 ≤ S ≤ 1000 e 0 ≤ E ≤ 1000)
Saída
Seu programa deve imprimir uma única linha contendo o caractere 'S', caso a
capacidade do elevador tenha sido excedida em algum momento, ou o caractere 'N'
caso contrário.
Exemplo
Entrada
5 10
0 5
2 7
3 3
5 2
7 0
Saída
N
45
Entrada
5 10
0 3
0 5
0 2
3 4
6 4
Saída
S
Entrada
6 4
0 5
3 5
4 5
1 0
1 1
1 1
Saída
S
Resolução
#include <stdio.h>
int main()
{
int n, c, e, s, i, total=0, verif=0;
scanf ("%d %d",&n,&c);
{
for (i=0;i<n;i++)
{
scanf ("%d %d",&s,&e);
total=(total-s)+e;
if (total>c)
verif=1;
}
}
if (verif)
printf("S");
else
printf("N");
return 0;
}
46
2280. Encontre o telefone
Problema: ENCOTEL
Em alguns lugares é comum lembrar um número do telefone associando seus

dígitos a letras. Dessa maneira a expressão MY LOVE significa 69 5683. Claro que
existem alguns problemas, uma vez que alguns números de telefone não formam
uma palavra ou uma frase e os dígitos 1 e 0 não estão associados a nenhuma letra.
Sua tarefa é ler uma expressão e encontrar o número de telefone correspondente

baseado na tabela abaixo. Uma expressão é composta por letras maiúsculas (A-Z),
hifens (-) e os números 1 e 0.
Letras Número
ABC 2
DEF 3
GHI 4
JKL 5
MNO 6
PQRS 7
TUV 8
WXYZ 9
Entrada
A entrada consiste de um conjunto de expressões. Cada expressão está sozinha em

uma linha e possui C caracteres, onde 1 ≤ C ≤ 30. A entrada é terminada por fim
de arquivo (EOF).
Saída
Para cada expressão você deve imprimir o número de telefone correspondente.
Exemplo
Entrada:
1-HOME-SWEET-HOME
MY-MISERABLE-JOB
Saída:
1-4663-79338-4663
69-647372253-562
Resolução
47
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main()
{
char tel[31];
int i,tam;
while (scanf ("%s",&tel) != EOF)
{
i=0;
tam=strlen(tel);
while(i<tam)
{
if(tel[i]=='1')
printf ("1");
else if(tel[i]=='-')
printf ("-");
else if(tel[i]=='0')
printf ("0");
else if((tel[i]=='A') || (tel[i]=='B') || (tel[i]=='C'))
printf ("2");
else if((tel[i]=='D') || (tel[i]=='E') || (tel[i]=='F'))
printf ("3");
else if((tel[i]=='G') || (tel[i]=='H') || (tel[i]=='I'))
printf ("4");
else if((tel[i]=='J') || (tel[i]=='K') || (tel[i]=='L'))
printf ("5");
else if((tel[i]=='M') || (tel[i]=='N') || (tel[i]=='O'))
printf ("6");
else if((tel[i]=='P') || (tel[i]=='Q') || (tel[i]=='R') || (tel[i]=='S'))
printf ("7");
else if((tel[i]=='T') || (tel[i]=='U') || (tel[i]=='V'))
printf ("8");
else if((tel[i]=='W') || (tel[i]=='X') || (tel[i]=='Y') || (tel[i]=='Z'))
printf ("9");
i++;
}
printf("\n");
}
}
48
841. Estágio
Problema: ESTAGIO
Você conseguiu um estágio para trabalhar como programador na secretaria da sua

escola. Como primeira tarefa, Dona Vilma, a coordenadora, solicitou que você
aprimore um programa que foi desenvolvido pelo estagiário anterior. Esse
programa tem como entrada uma lista de nomes e de médias finais dos alunos de
uma turma, e determina o aluno com a maior média na turma. Dona Vilma
pretende utilizar o programa para premiar o melhor aluno de cada turma da escola.
O programa desenvolvido pelo estagiário anterior encontra-se no final (em C, C++
e Pascal).
Como você pode verificar, o programa na forma atual tem uma imperfeição: no
caso de haver alunos empatados com a melhor média na turma, ele imprime
apenas o primeiro aluno que aparece na lista.
Tarefa
Dona Vilma deseja que você altere o programa para que ele produza uma lista com
todos os alunos da turma que obtiveram a maior média, e não apenas um deles.
Você consegue ajudá-la nesta tarefa?
Entrada
A entrada é constituída de vários conjuntos de teste, representando várias turmas.

A primeira linha de um conjunto de testes contém um número inteiro N (1 <= N <=
1000) que indica o total de alunos na turma. As N linhas seguintes contêm, cada
uma, um par de números inteiros C (1 <= C <= 20000) e M (0 <= M <= 100),
indicando respectivamente o código e a média de um aluno. O final da entrada é
indicado por uma turma com N = 0.
Saída
Para cada turma da entrada seu programa deve produzir três linhas na saída. A
primeira linha deve conter um identificador do conjunto de teste, no formato
“Turma n”, onde n é numerado a partir de 1. A segunda linha deve conter os
códigos dos alunos que obtiveram a maior média da turma. Os códigos dos alunos
devem aparecer na mesma ordem da entrada, e cada um deve ser seguido de um
espaço em branco. A terceira linha deve ser deixada em branco. O formato
mostrado no exemplo de saída abaixo deve ser seguido rigorosamente.
Exemplo
Entrada:
3
1 85
2 91
3 73
5
12300 81
12601 99
15023 76
10111 99
49
212 99
0
Saída:
Turma 1
2
Turma 2
12601 10111 212
Restrições
0 <= N <= 1000 (N = 0 apenas para indicar o fim da entrada)

1 <= C <= 20000
0 <= M <= 100
Resolução
#include <stdio.h>
#define MAX_ALUNOS 1000
int main()
{
int i, indice_melhor, n;
int turma=1;
struct
{
int codigo, media;
} alunos[MAX_ALUNOS];
/* le numero de alunos da primeira turma */
scanf("%d", &n);
while (n > 0)
{
/* le dados dos alunos */
for (i = 0; i < n; i++)
scanf("%d %d", &alunos[i].codigo, &alunos[i].media);
/* procura aluno de maior media */
indice_melhor = 0;
for (i = 0; i < n; i++)
if (alunos[i].media > indice_melhor)
indice_melhor = alunos[i].media;
/* escreve resposta */
printf("Turma %d\n",turma++);
for (i=0;i<n;i++)
{
if (alunos[i].media == indice_melhor)
printf("%d ",alunos[i].codigo);
}
printf ("\n\n");
/* le numero de alunos da proxima turma */
scanf("%d", &n);
}
return 0;
}
50
1831. f91
Problema: F91
McCarthy é um teórico famoso de ciência da computação. No seu trabalho, ele

definiu uma função recursiva, chamada f91, que recebe como entrada um inteiro N
e retorna um inteiro positivo definido como a seguir:
 Se N ≤ 100, então f91 (N) = f91 (f91 (N + 11));

 Se N ≥ 101, então f91 (N) = N - 10.
Escreva um programa que computa a função f91 de McCarthy.
Entrada
O arquivo de entrada consiste de uma série de inteiros positivos, cada inteiro é no

máximo 1.000.000. Há no máximo 250.000 casos de teste. Cada linha possui
somente um número. O fim da entrada é alcançada quando o número 0 é
encontrado. O número 0 não deve ser considerado como parte do conjunto de
teste.
Saída
O programa deve imprimir cada resultado em uma linha, seguindo o formato

fornecido no exemplo de saída.
Exemplo
Entrada:
500
91
0
Saída:
f91(500) = 490
f91(91) = 91
Resolução
51
#include <stdio.h>
int f91(int n)
{
return n<=100 ? f91(f91(n+11)) : n-10;
}
int main()
{
int x;
while(scanf("%d", &x) > 0 && x > 0)

printf("f91(%d) = %d\n", x, f91(x));
return 0;
}
52
3774. Fatorial
Problema: FATORIA2
Dado um inteiro N, determine quanto vale N fatorial (escreve-se N!). O fatorial de

um número é o produto de todos os números entre 1 e N, inclusive. Por exemplo,
5! = 5 × 4 × 3 × 2 × 1 = 120.
Entrada
A entrada é composta por uma única linha que contém o inteiro N.
Saída
A saída deve consistir de apenas uma linha contendo o valor de N!.
Restrições
 0 ≤ N ≤ 12
Exemplo
Entrada
Saída
Resolução
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int n, fat=1, i;
scanf ("%d",&n);
if (n != 0)
{
for (i=n;i>0;i--)
{
fat = fat*i;
}
printf ("%d",fat);
}
else
printf ("1");
return 0;
}
53
3742. Feynman
Problema: FEYNMAN
Richard Phillips Feynman era uma físico americando muito famoso e ganhador do
Prêmio Nobel de Física. Ele trabalhava em física teórica e também foi pioneiro no
campo da computação quântica. Ele visitou a América do Sul por dez meses, dando
palestras e aproveitando a vida nos trópicos. Ele também é conhecido pelos livros
"Surely You’re Joking, Mr. Feynman!" e "What Do You Care What Other People
Think?", que inclui algumas de suas aventuras abaixo do equador.
Sua paixão da vida inteira era resolver e criar quebra-cabeças, trancas e códigos.
Recentemente, um fazendeiro idoso da América do Sul, que hospedou o jovem
físico em 1949, achou alguns papéis e notas que acredita-se terem pertencido a
Feynman. Entre anotações sobre mesóns e eletromagnetismo, havia um
guardanapo onde ele escreveu um simples desafio: "quantos quadrados diferentes
existem em um quadriculado de N x N quadrados?".
No mesmo guardanapo havia um desenho, que está reproduzido abaixo, mostrando

que para N = 2, a resposta é 5.
Entrada
A entrada contém diversos casos de teste. Cada caso de teste é composto de uma
única linha, contendo apenas um inteiro N, representando o número de quadrados
em cada lado do quadriculado (1 <= N <= 100).
O final da entrada é indicado por uma linha contendo apenas um zero.
Saída
Para cada caso de teste na entrada, seu programa deve imprimir uma única linha,
contendo o número de diferentes quadrados para a entrada correspondente.
Exemplo de entrada
54
Saída para o exemplo de entrada
204
Resolução
#include <stdio.h>
int main ()
{
int n,total,i;
while ((scanf("%d",&n)) && n!=0)
{
total=0;
for (i=n;i>0;i--)
total+=i*i;
printf ("%d\n",total);
}
return 0;
}
55
3775. Fliperama
Problema: FLIPERAM
Bebe-bebe é um jogo muito popular de fliperama. E, como a maioria dos jogos de

fliperama, ele deve mostrar as maiores pontuações. Para esse fim, a companhia
Otori te contratou.
Escreva um programa que, dada a lista de todas as pontuações dos jogos de Bebe-
bebe, mostra os melhores placares em ordem decrescente.
Entrada
A entrada é composta de um único caso de teste. A primeira linha consiste de dois

inteiros N e M, dizendo quantas partidas foram jogadas de Bebe-bebe e quantas
linhas cabem no mostrador de melhores rankings. As N linhas seguintes contêm
cada uma um inteiro indicando a pontuação obtida em cada jogo.
Saída
Seu programa deve imprimir M linhas, contendo as M maiores pontuações em ordem

decrescente.
Restrições
 1 ≤ N ≤ 10000
 1 ≤ M ≤ 500
 M ≤ N
Exemplo
Entrada
7 4
100
200
200
150
30
524
942
Saída
942
524
200
200
Entrada
2 1
4000
2000
Saída
4000
56
Resolução
#include <stdio.h>
int main ()
{
int n,m,i,j,aux;
scanf ("%d %d",&n,&m);
int flip[n];
for (i=0;i<n;i++)
scanf ("%d",&flip[i]);
for (i=0;i<n;i++)
{
for (j=0;j<n-1;j++)
{
if(flip[j]<flip[j+1])
{
aux = flip[j];
flip[j] = flip[j+1];
flip[j+1] = aux;
}
}
}
for (i=0;i<m;i++)
printf ("%d\n",flip[i]);
return 0;
}
57
2606. Frota de Táxi
Problema: FROTATAX
A Companhia de Táxi Tabajara (CTT) é uma das maiores empresas de transporte

do país. Possui uma vasta frota de carros e opera em todas as grandes cidades.
Recentemente a CTT modernizou a sua frota, adquirindo um lote de 500 carros bi-
combustíveis (carros que podem utilizar como combustível tanto álcool quanto
gasolina). Além do maior conforto para os passageiros e o menor gasto com
manutenção, com os novos carros é possível uma redução adicional de custo: como
o preço da gasolina está sujeito a variações muito bruscas e pode ser vantagem,
em certos momentos, utilizar álcool como combustível. Entretanto, os carros
possuem um melhor desempenho utilizando gasolina, ou seja, em geral, um carro
percorre mais quilômetros por litro de gasolina do que por litro de álcool.
Tarefa
Você deve escrever um programa que, dados o preço do litro de álcool, o preço do
litro de gasolina e os quilômetros por litro que um carro bi-combustível realiza com
cada um desses combustíveis, determine se é mais econômico abastecer os carros
da CTT com álcool ou com gasolina. No caso de não haver diferença de custo entre
abastecer com álcool ou gasolina a CTT prefere utilizar gasolina.
Entrada
A entrada é composta por uma linha contendo quatro números reais com precisão
de duas casas decimais A, G, Ra e Rg , representando respectivamente o preço por
litro do álcool, o preço por litro da gasolina, o rendimento (km/l) do carro utilizando
álcool e o rendimento (km/l) do carro utilizando gasolina.
Saída
A saída deve ser composta por uma única linha contendo o caractere ‘A’ se é mais
econômico abastecer a frota com álcool ou o caractere ‘G’ se é mais econômico ou
indiferente abastecer a frota com gasolina.
Exemplo 1 Exemplo 2 Exemplo 3
Entrada: Entrada: Entrada:

1.20 2.30 10.00 15.00 1.00 1.00 9.00 9.01 1.00 1.00 11.00 11.00
Saída: Saída: Saída:

A G G
Restrições
0.01 <= A <= 10.00

0.01 <= G <= 10.00
0.01 <= Ra <= 20.00
0.01 <= Rg <= 20.00
58
Resolução
#include <stdio.h>
int main ()
{
float a, g, ra, rg, totala, totalg;
scanf ("%f %f %f %f",&a,&g,&ra,&rg);
totala = ra/a;
totalg = rg/g;
if (totala > totalg)
printf ("A");
else
printf ("G");
return 0;
}
59
2928. Ele está impedido
Problema: IMPEDIDO
A Rede do Hemisfério é a maior rede de televisão de Tumbolia, um pequeno país

situado a leste da América do Sul (ou sul da América do Leste). O esporte mais
popular em Tumbolia, obviamente, é o futebol; muitos jogos são transmitidos toda
semana em Tumbolia.
A Rede do Hemisfério recebe muitos pedidos para repassar lances polêmicos;

normalmente esses acontecem quando um jogador é dito impedido pelo juíz. Um
jogador atacante está impedido se ele está mais próximo da linha do gol do
oponente do que o penúltimo adversário. Um jogador não está impedido se
 ele está na mesma linha que o penúltimo adversário ou

 ele está na mesma linha que os dois últimos adversários.
Através do uso de tecnologia de computação gráfica, a Rede do Hemisfério

consegue tirar uma foto do campo e determinar as distâncias dos jogadores até a
linha do gol do time defensor, mas eles ainda precisam de um programa que, dadas
essas distâncias, decida se um jogador está impedido.
Entrada
O arquivo de entrada contém vários casos de teste. A primeira linha de cada caso
de teste contém dois inteiros A e D separados por um espaço indicando,
respectivamente, o número de jogadores atacantes e defensores envolvidos na
jogada (2 <= A, D <= 11). A próxima linha contém A inteiros Bi separados por um
espaço, indicando as distâncias dos jogadores atacantes até a linha do gol (1 <= Bi
<= 10^4 ). A próxima linha contém D inteiros Ci separados por um espaço,
indicando as distâncias dos defensores até a linha do gol (1 <= Ci <= 10^4). O
final da entrada é dado por A = D = 0.
Saída
Para cada caso de teste na entrada imprima uma linha contendo um único
caractere: “Y” (maiúsculo) se existe um jogador atacante impedido, e “N”
(maiúsculo) caso contrário.
Exemplo
Entrada
2 3
500 700
700 500 500
2 2
200 400
200 1000
3 4
530 510 490
480 470 50 310
0 0
Saída
N
60
Y
N
Resolução
#include <stdio.h>
int main ()
{
int a, d, i, minimo, cond, pos;
while ((scanf("%d %d",&a,&d)) && a!=0 && d!=0)
{
minimo=100000;
cond=0;
for (i=0;i<a;i++)
{
scanf("%d",&pos);
if (pos<minimo)
minimo=pos;
}
for (i=0;i<d;i++)
{
scanf("%d",&pos);
if (pos<=minimo)
cond++;
}
if (cond>=2)
printf ("N\n");
else
printf ("Y\n");
}
return 0;
}
61
8700. Escada
Problema: JESCADA
O Shopping Boas Compras - SBC, através de sua política ambiental, está

preocupado com o consumo de energia e, resolveu trocar todas as escadas rolantes
por modelos mais modernos, que se desligam caso ninguém esteja utilizando,
poupando energia.
A nova escada rolante possui um sensor no início. Toda vez que ela está vazia e
alguém passa pelo sensor, a escada começa a funcionar, parando de funcionar
novamente após 10 segundos se ninguém mais passar pelo sensor. Estes 10
segundos representam o tempo suficiente para levar alguém de um nível ao outro.
Preocupados em saber exatamente quanto de energia o shopping está

economizando, o gerente pediu sua ajuda. Como eles sabem qual era o consumo
da escada rolante antiga, eles te pediram para calcular o tempo que a nova escada
ficou funcionando.
Tarefa
Dados os instantes, em segundos, em que passaram pessoas pela escada rolante,

você deve calcular quantos segundos ela ficou ligada.
Entrada
A A primeira linha da entrada contém um inteiro N que indica o número de pessoas

que o sensor detectou (1 ≤ N ≤ 1.000). As N linhas seguintes representam o
instante em que a i-ésima pessoa passou pelo sensor e contém um inteiro T (0 ≤ T
≤ 10.000). Os tempos estão em ordem crescente, sem repetições. (1 ≤ K ≤ N ≤
100).
Saída
Seu programa deve imprimir uma única linha, contendo o tempo que a escada
rolante ficou ligada.
Exemplo
Entrada
3
0
10
20
Saída
30
Entrada
5
5
10
17
20
30
62
Saída
35
Entrada
3
1
2
3
Saída
12
Resolução
#include <stdio.h>
int main ()
{
int i,n,total=0;
scanf ("%d",&n);
int segundos[n];
if (n!=0)
total+=10;
for (i=0;i<n;i++)
{
scanf ("%d",&segundos[i]);
}
for (i=1;i<n;i++)
{
if(segundos[i]-10>=segundos[i-1])
total += 10;
else
total += segundos[i]-segundos[i-1];
}
return 0;
}
63
8698. Garçom
Problema: JGARCOM
Parte do treinamento de um novo garçom é carregar uma grande bandeja com

várias latas de bebidas e copos e entregá-las todas numa mesa do restaurante.
Durante o treinamento é comum que os garçons deixem cair as bandejas,
quebrando todos os copos.
A SBC - Sociedade Brasileira de Copos - analisou estatísticas do treinamento de

diversos garçons e descobriu que os garçons em treinamento deixam cair apenas
bandejas que têm mais latas de bebidas que copos.
Por exemplo, se uma bandeja tiver 10 latas e 4 copos, certamente o garçom em

treinamento a deixar&aacut;e cair, quebrando os 4 copos. Já se a bandeja tiver 5
latas e 6 copos, ele conseguirá entregá-la sem deixar cair
Tarefa
Escreva um programa que, dado o número de latas e copos em cada bandeja que o
garçom tentou entregar, imprime o total de copos que ele quebrou.
Entrada
A primeira linha da entrada contém um inteiro N (1 ≤ N ≤ 100) representando o

número de bandejas que o garçom tentou entregar. As N linhas seguintes
representam as N bandejas. Cada linha contém dois inteiros L e C, indicando o
número de latas e o número de copos naquela bandeja, respectivamente (0 ≤ L, C
≤ 100).
Saída
Seu programa deve imprimir uma única linha, contendo um único inteiro, indicando
o número total de copos que o garçom quebrou.
Exemplo
Entrada
3
10 5
6 8
3 3
Saída
5
Entrada
4
10 6
8 8
5 1
100 100
64
Saída
7
Resolução
#include <stdio.h>
int main ()
{
int i, c, l, n, total=0;
scanf ("%d",&n);
for (i=0;i<n;i++)
{
scanf ("%d %d",&l,&c);
if (l>c)
total+=c;
}
return 0;
}
65
8697. Pneu
Problema: JPNEU
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 BombasComputadorizadas
Tarefa
Escreva um programa que, dada a pressão desejada digitada pelo motorista e a

pressão do pneu lida pela bomba, indica a diferença entre a pressão desejada e a
pressão lida.
Entrada
A primeira linha da entrada contém um inteiro N que indica a pressão desejada pelo
motorista (1 ≤ N ≤ 40). A segunda linha contém um inteiro M que indica a pressão
lida pela bomba (1 ≤ M ≤ 40).
Saída
Seu programa deve imprimir uma única linha, contendo a diferença entre a pressão
desejada e a pressão lida.
Exemplo
Entrada
30
18
Saída
12
Entrada
27
27
Saída
0
Entrada
27
30
Saída
-3
66
8697. Pneu
Problema: JPNEU
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 BombasComputadorizadas
Tarefa
Escreva um programa que, dada a pressão desejada digitada pelo motorista e a

pressão do pneu lida pela bomba, indica a diferença entre a pressão desejada e a
pressão lida.
Entrada
A primeira linha da entrada contém um inteiro N que indica a pressão desejada pelo
motorista (1 ≤ N ≤ 40). A segunda linha contém um inteiro M que indica a pressão
lida pela bomba (1 ≤ M ≤ 40).
Saída
Seu programa deve imprimir uma única linha, contendo a diferença entre a pressão
desejada e a pressão lida.
Exemplo
Entrada
30
18
Saída
12
Entrada
27
27
Saída
0
Entrada
27
30
Saída
67
-3
Resolução
#include <stdio.h>
int main()
{
int desejada, lida, dif;
scanf ("%d %d",&desejada,&lida);
dif = desejada-lida;
printf ("%d",dif);
return 0;
}
68
8696. Sedex
Problema: JSEDEX
A Copa do Mundo de 2010 será realizada na áfrica do Sul. Bolas de futebol são
muito fáceis de transportar, já que elas saem das fábricas vazias e só são enchidas
somente pelas lojas ou pelos consumidores finais.
Infelizmente o mesmo não pode ser dito das bolas de boliche. Como elas são
completamente sólidas, elas só podem ser transportadas embaladas uma a uma,
em caixas separadas.
A SBC - Só Boliche Cascavel - é uma fábrica de bolas de boliche que trabalha

somente através de encomendas e envia todas as bolas por SEDEX. Como as bolas
têm tamanhos diferentes, a SBC tem vários tamanhos de caixas diferentes para
transportá-las
Tarefa
Escreva um programa que, dado o diâmetro de uma bola e as 3 dimensões de uma

caixa (altura, largura e profundidade), diz se a bola de boliche cabe dentro da caixa
ou não.
Entrada
A primeira linha da entrada contém um inteiro N (1 ≤ N ≤ 10.000) que indica o

diâmetro da bola de boliche. A segunda linha da entrada contém 3 números inteiros
separados por um espaço cada: a altura A (1 ≤ A ≤ 10.000), seguida da largura L
(1 ≤ L ≤ 10.000) e da profundidade P (1 ≤ P ≤ 10.000).
Saída
Seu programa deve imprimir uma única linha, contendo a letra 'S' caso a bola de
boliche caiba dentro da caixa ou 'N' caso contrário
Exemplo
Entrada
3
3 2 5
Saída
N
Entrada
5
5 5 5
Saída
S
Entrada
9
15 9 10
69
Saída
S
Resolução
#include <stdio.h>
int main ()
{
int bola, alt, lar, prof;
scanf ("%d %d %d %d",&bola,&alt,&lar,&prof);
if (bola>alt || bola>lar || bola>prof)
printf ("N");
else
printf ("S");
return 0;
}
70
815. Temperatura Lunar
Problema: LUA
Sem as proteções da atmosfera e do cinturão magnético que existem na Terra, a

Lua fica exposta ao ataque do Sol, que é um astro em constante explosão atômica.
As explosões do Sol emitem ondas letais de partículas. Uma pessoa que ficasse
desprotegida na superfície da Lua, num lugar onde o Sol incidisse diretamente,
sofreria um bombardeio radioativo tão intenso quanto se estivesse nas imediações
da usina russa de Chernobyl no momento do acidente que matou 31 pessoas, em
1986. Além da radiação solar, outro efeito desta falta de proteção contra o Sol que
existe na Lua é a enorme variação de temperatura. Nas regiões próximas do
equador lunar, a variação de temperatura é brutal, passando de cerca de 130 graus
positivos durante o dia a 129 graus negativos à noite.
Para estudar com mais precisão as variações de temperatura na superfície da Lua,

a NASA enviou à Lua uma sonda com um sensor que mede a temperatura de 1 em
1 minuto. Um dado importante que os pesquisadores desejam descobrir é como se
comporta a média da temperatura, considerada em intervalos de uma dada
duração (uma hora, meia hora, oito horas, etc.). Por exemplo, para a seqüência de
medições 8, 20, 30, 50, 40, 20, -10, e intervalos de quatro minutos, as médias são
respectivamente 108/4=27, 140/4=35, 140/4=35 e 100/4=25.
Tarefa
Você foi recentemente contratado pela NASA, e sua primeira tarefa é escrever um
programa que, conhecidos a seqüência de temperaturas medidas pelo sensor, e o
tamanho do intervalo desejado, informe qual a maior e qual a menor temperatura
média observadas, considerando o tamanho do intervalo dado.
Entrada

conjunto de teste contém dois números inteiros positivos N e M, que indicam
respectivamente o número total de medições de temperatura de uma seqüência
obtida pelo sensor, e o tamanho dos intervalos, em minutos, em que as médias
devem ser calculadas. As N linhas seguintes contêm um número inteiro cada,
representando a seqüência de medidas do sensor. O final da entrada é indicado
quando N = M = 0.
Saída
primeira linha identifica o conjunto de teste, no formato “Teste n”, onde n é
numerado a partir de 1. A segunda linha deve conter dois números inteiros X e Y,
separados por ao menos um espaço em branco, representando respectivamente os
valores da menor e da maior média de temperatura, conforme determinado pelo
seu programa. O valor da média deve ser truncado, se a média não for um número
inteiro (ou seja, deve ser impressa apenas a parte inteira). A terceira linha deve ser
deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser
seguida rigorosamente.
Exemplo
71
Entrada:
4 2
-5
-12
0
6
7 4
35
-35
5
100
100
50
50
0 0
Saída:
Teste 1
-8 3
Teste 2
26 75
Restrições

-200 <= Temperatura <= 200
1 <= M <= N
72
Resolução
#include <stdio.h>
int main ()
{
int n, m, i, j, max, min, teste=1, media, soma;
while (n!=0 && m!=0)
{
int temp[n];
soma = 0;
max = -200;
min = 200;
for (i=0;i<n;i++)
scanf ("%d",&temp[i]);
for (i=0;i<m;i++)
{
soma += temp[i];
}
media = soma/m;
if (media >= max)
max = media;
if (media <= min)
min = media;
for (i=0;i<(n-m);i++)
{
soma = (soma-temp[i])+temp[i+m];
media = soma/m;
if (media >= max)
max = media;
if (media <= min)
min = media;
}

printf ("%d %d\n\n",min, max);
}
return 0;
}
73
1330. Meteoros
Problema: METEORO
Em noites sem nuvens pode-se muitas vezes observar pontos brilhantes no céu que
se deslocam com grande velocidade, e em poucos segundos desaparecem de vista:
são as chamadas estrelas cadentes, ou meteoros. Meteoros são na verdade
partículas de poeira de pequenas dimensões que, ao penetrar na atmosfera
terrestre, queimam-se rapidamente (normalmente a uma altura entre 60 120
quilômetros). Se os meteoros são suficientemente grandes, podem não queimar-se
completamente na atmosfera e dessa forma atingem a superfície terrestre: nesse
caso são chamados de meteoritos.
Zé Felício é um fazendeiro que adora astronomia e descobriu um portal na Internet

que fornece uma lista das posições onde caíram meteoritos. Com base nessa lista,
e conhecendo a localização de sua fazenda, Zé Felício deseja saber quantos
meteoritos caíram dentro de sua propriedade. Ele precisa de sua ajuda para
escrever um programa de computador que faça essa verificação automaticamente.
Tarefa
São dados:
 uma lista de pontos no plano cartesiano, onde cada ponto corresponde à

posição onde caiu um meteorito;
 as coordenadas de um retângulo que delimita uma fazenda.
As linhas que delimitam a fazenda são paralelas aos eixos cartesianos. Sua tarefa é
escrever um programa que determine quantos meteoritos caíram dentro da fazenda
(incluindo meteoritos que caíram exatamente sobre as linhas que delimitam a
fazenda).
Entrada
Seu programa deve ler vários conjuntos de testes. A primeira linha de um conjunto
de testes quatro números inteiros X1, Y1, X2 e Y2, onde (X1, Y1) é a coordenada
do canto superior esquerdo e (X2, Y2) é a coordenada do canto inferior direito do
retângulo que delimita a fazenda. A segunda linha contém um inteiro, N, que indica
o número de meteoritos. Seguem-se N linhas, cada uma contendo dois números
inteiros X e Y, correspondendo às coordenadas de cada meteorito. O final da
entrada é indicado por X1 = Y1 = X2 = Y2 = 0.
Exemplo de entrada
2 4 5 1
2
1 2
3 3
2 4 3 2
3
1 1
2 2
3 3
0 0 0 0
74
Saída
formato “Teste n”, onde n é numerado a partir de 1. A segunda linha deve conter o
número de meteoritos que caíram dentro da fazenda. A terceira linha deve ser
Exemplo de saída
Teste 1
1
Teste 2
2
Restrições
0 ≤ N ≤ 10.000
0 ≤ X ≤ 10.000
0 ≤ Y ≤ 10.000
0 ≤ X1 < X2 ≤ 10.000
0 ≤ Y2 < Y1 ≤ 10.000
Resolução
#include <stdio.h>
int main ()
{
int x1=1, x2=1, y1=1, y2=1, n, i, cont = 0, teste = 1;
while (x1!=0, x2!=0, y1!=0, y2!=0)
{
scanf ("%d %d %d %d",&x1,&y1,&x2,&y2);
if (x1!=0, x2!=0, y1!=0, y2!=0)
{
scanf ("%d",&n);
int x[n], y[n];
for (i=0;i<n;i++)
scanf("%d %d",&x[i],&y[i]);
for (i=0;i<n;i++)
if (x[i] >= x1 && x[i] <= x2)
if (y[i] <= y1 && y[i] >= y2)
cont ++;
printf ("Teste %d\n%d\n\n",teste, cont);
teste++;
cont = 0;
}
}
return 0;
}
75
2607. Campo de Minhocas
Problema: MINHOCA
Minhocas são muito importantes para a agricultura e como insumo para produção
de ração animal. A Organização para Bioengenharia de Minhocas (OBM) é uma
entidade não governamental que promove o aumento da produção, utilização e
exportação de minhocas.
Uma das atividades promovidas pela OBM é a manutenção de uma fazenda

experimental para pesquisa de novas tecnologias de criação de minhocas. Na
fazenda, a área destinada às pesquisas é de formato retangular, dividida em células
quadrangulares de mesmo tamanho. As células são utilizadas para testar os efeitos,
na produção de minhocas, de variações de espécies de minhocas, tipos de terra, de
adubo, de tratamento, etc. Os pesquisadores da OBM mantêm um
acompanhamento constante do desenvolvimento das minhocas em cada célula, e
têm uma estimativa extremamente precisa da produtividade em cada uma das
células. A figura abaixo mostra um mapa da fazenda, mostrando a produtividade
estimada de cada uma das células.
Um pesquisador da OBM inventou e construiu uma máquina colhedeira de

minhocas, e quer testá- la na fazenda. A máquina tem a largura de uma célula, e
em uma passada pelo terreno de uma célula colhe todas as minhocas dessa célula,
separando-as, limpando-as e empacotando-as. Ou seja, a máquina eliminara uma
das etapas mais intensivas de mão de obra no processo de produção de minhocas.
A máquina, porém, ainda está em desenvolvimento e tem uma restrição: não faz
curvas, podendo movimentar-se somente em linha reta.
Decidiu-se então que seria efetuado um teste com a máquina, de forma a colher o
maior número possível de minhocas em uma unica passada, em linha reta, de lado
a lado do campo de minhocas. Ou seja, a máquina deve colher todas as minhocas
de uma ‘coluna’ ou de uma ‘linha’ de células do campo de minhocas (a linha ou
coluna cuja soma das produtividades esperadas das células é a maior possível).
Tarefa
Escreva um programa que, fornecido o mapa do campo de minhocas, descrevendo

a produtividade estimada em cada célula, calcule o número esperado total de
minhocas a serem colhidas pela máquina durante o teste, conforme descrito acima.
Entrada
A primeira linha da entrada contém dois números inteiros N e M, representando

respectivamente o número de linhas (1 <= N <= 100) e o número de colunas (1
<= M <= 100) de células existentes no campo experimental de minhocas. Cada
uma das N linhas seguintes contém M inteiros, representando as produtividades
estimadas das células correspondentes a uma linha do campo de minhocas.
76
Saída
A saída deve ser composta por uma unica linha contendo um inteiro, indicando o
número esperado total de minhocas a serem colhidas pela máquina durante o teste.
Exemplo 1 Exemplo 2
Entrada:
Entrada:
4 1
3 4
100
81 28 240 10
110
40 10 100 240
0
20 180 110 35
100
Saída:
Saída:
450
310
Restrições
1 <= N <= 100

1 <= M <= 100
0 <= Produtividade de uma célula <= 500
0 <= Produtividade de uma linha ou coluna de células <= 50000
77
Resolução
#include <stdio.h>
int main ()
{
int n,m,i,j,max=0,soma;
int mat[n][m];
for (i=0;i<n;i++)
{
for (j=0;j<m;j++)
scanf ("%d",&mat[i][j]);
}
for (i=0;i<n;i++)
{
soma = 0;
for (j=0;j<m;j++)
{
soma=soma+mat[i][j];
if (j == m-1)
{
if (soma > max)
max = soma;
}
}
}
for (i=0;i<m;i++)
{
soma = 0;
for (j=0;j<n;j++)
{
soma=soma+mat[j][i];
if (j == n-1)
{
if (soma > max)
max = soma;
}
}
}
printf ("%d",max);
return 0;
}
78
3826. Miojo
Problema: MIOJO
João é um fanático por miojos; ele os adora, e, como era de se esperar, ele levou
vários pacotes quando foi acampar com seus colegas. Como João só gosta de
miojos feitos com o tempo exato, ele se deseperou ao perceber que havia
esquecido seu relógio em casa.
Por sorte, ele conseguiu, no caminho, comprar duas ampulhetas de durações

diferentes. Por exemplo, se o miojo precisa de 3 minutos para ficar pronto, e João
tiver uma ampulheta de 5 minutos e outra de 7, uma possível forma de cozinhar o
miojo é:
1. João começa virando as duas ampulhetas ao mesmo tempo.

2. Quando a areia da ampulheta de 5 minutos se esgotar, João torna a virá-la.
3. João começa a preparar o miojo quando a areia da ampulheta de 7 minutos
acabar.
4. João tira o miojo do fogo quando a ampulheta de 5 minutos acabar
novamente.
Dessa forma, o miojo ficará 3 minutos no fogo (do minuto 7 ao minuto 10). Assim,
apesar do miojo levar apenas três minutos para ser cozido, ele precisa de 10
minutos para ficar pronto.
Faça um programa que, dado o tempo de preparo do miojo, e os tempos das duas
ampulhetas (ambos maiores que o tempo do miojo), determina o tempo mínimo
necessário para o miojo ficar pronto. Você pode supor que sempre é possível
cozinhar o miojo no tempo correto.
Entrada
A entrada contém um único caso de teste, composto por uma única linha, que
contém três inteiros T, A e B, representando o tempo necessário para o preparo do
miojo, o tempo da primeira ampulheta e o tempo da segunda ampulheta
respectivamente.
Saída
Seu programa deve produzir uma única linha na saída, contendo o tempo mínimo
para o preparo do miojo.
Restrições
 0 ≤ T ≤ 10000
 T < A, B ≤ 40000
Exemplo
Entrada
3 5 7
Saída
10
79
Entrada
14 15 22
Saída
44
Resolução
#include <stdio.h>
int main(void) {
int t, a, b, menor, maior, tempo = 0;
scanf("%d %d %d", &t, &menor, &maior);
a = maior;
b = menor;
while (1) {
if (a < b) {
tempo += a;
if (a == t)
break;
b -= a;
a = maior;
} else {
tempo += b;
if (b == t)
break;
a -= b;
b = menor;
}
}
printf("%d", tempo);
return 0;
}
80
3244. Divisão da Nlogônia
Problema: NLOGONIA
Depois de séculos de escaramuças entre os quatro povos habitantes da Nlogônia, e

de dezenas de anos de negociações envolvendo diplomatas, políticos e as forças
armadas de todas as partes interessadas, com a intermediação da ONU, OTAN, G7
e SBC, foi finalmente decidida e aceita por todos a maneira de dividir o país em
quatro territórios independentes.
Ficou decidido que um ponto, denominado ponto divisor, cujas coordenadas foram
estabelecidas nas negociações, definiria a divisão do país da seguinte maneira.
Duas linhas, ambas contendo o ponto divisor, uma na direção norte-sul e uma na
direção leste-oeste, seriam traçadas no mapa, dividindo o país em quatro novos
países. Iniciando no quadrante mais ao norte e mais ao oeste, em sentido horário,
os novos países seriam chamados de Nlogônia do Noroeste, Nlogônia do Nordeste,
Nlogônia do Sudeste e Nlogônia do Sudoeste.
A ONU determinou que fosse disponibilizada uma página na Internet para que os
habitantes pudessem consultar em qual dos novos países suas residências estão, e
você foi contratado para ajudar a implementar o sistema.
Entrada
A entrada contém vários casos de teste. A primeira linha de um caso de teste

contém um inteiro K indicando o número de consultas que serão realizadas (0 < K
<= 10^3). A segunda linha de um caso de teste contém dois números inteiros N e M
representando as coordenadas do ponto divisor (−10^4 < N, M < 10^4). Cada uma
das K linhas seguintes contém dois inteiros X e Y representando as coordenadas de
uma residência (−10^4 <= X, Y <= 10^4). Em todas as coordenadas dadas, o
primeiro valor corresponde à direção leste-oeste, e o segundo valor corresponde à
direção norte-sul.
O final da entrada é indicado por uma linha que contém apenas o número zero.
81
Saída
Para cada caso de teste da entrada seu programa deve imprimir uma linha
contendo:
a palavra divisa se a residência encontra-se em cima de uma das linhas divisórias

(norte-sul ou leste-oeste);
NO se a residência encontra-se na Nlogônia do Noroeste;
NE se a residência encontra-se na Nlogônia do Nordeste;
SE se a residência encontra-se na Nlogônia do Sudeste;
SO se a residência encontra-se na Nlogônia do Sudoeste.
Exemplo
Entrada
3
2 1
10 10
-10 1
0 33
4
-1000 -1000
-1000 -1000
0 0
-2000 -10000
-999 -1001
0
Saída
NE
divisa
NO
divisa
NE
SO
SE
82
Resolução
#include <stdio.h>
int main ()
{
int k,x,y,i;
scanf ("%d",&k);
while (k!=0)
{
scanf("%d %d",&x,&y);
int x1[k],y1[k];
for (i=0;i<k;i++)
{
scanf ("%d %d",&x1[i],&y1[i]);
}
for (i=0;i<k;i++)
{
if((x1[i]==x) || (y1[i]==y))
printf("divisa\n");
if((x1[i]>x) && (y1[i]>y))
printf("NE\n");
if((x1[i]>x) && (y1[i]<y))
printf("SE\n");
if((x1[i]<x) && (y1[i]>y))
printf("NO\n");
if((x1[i]<x) && (y1[i]<y))
printf("SO\n");
}
scanf("%d",&k);
}
return 0;
}
83
842. Torres de Hanói
Problema: OBIHANOI
O quebra-cabeças Torres de Hanoi é muito antigo e conhecido, sendo constituído de

um conjunto de N discos de tamanhos diferentes e três pinos verticais, nos quais os
discos podem ser encaixados.
Cada pino pode conter uma pilha com qualquer número de discos, desde que cada
disco não seja colocado acima de outro disco de menor tamanho. A configuração
inicial consiste de todos os discos no pino 1. O objetivo do quebra-cabeças é mover
todos os discos para um dos outros pinos, sempre obedecendo à restrição de não
colocar um disco sobre outro menor.
Um algoritmo para resolver este problema é o seguinte.
procedimento Hanoi(N, Orig, Dest, Temp)

se N = 1 então
mover o menor disco do pino Orig para o pino Dest;
senão
Hanoi(N-1, Orig, Temp, Dest);
mover o N-ésimo menor disco do pino Orig para o pino Dest;
Hanoi(N-1, Temp, Dest, Orig);
fim-se
fim
Tarefa
Sua tarefa é escrever um programa que determine quantos movimentos de trocar

um disco de um pino para outro serão executados pelo algoritmo acima para
resolver o quebra-cabeça.
Entrada
A entrada possui vários conjuntos de teste. Cada conjunto de teste é composto por
uma única linha, que contém um único número inteiro N (0 <= N <= 30), indicando
o número de discos. O final da entrada é indicado por N = 0.
Saída
Para cada conjunto de teste, o seu programa deve escrever três linhas na saída. A
primeira linha deve conter um identificador do conjunto de teste, no formato “Teste
n”, onde n é numerado seqüencialmente a partir de 1. A segunda linha deve conter
o número de movimentos que são executados pelo algoritmo dado para resolver o
84
problema das Torres de Hanói com N discos. A terceira linha deve ser deixada em
branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida
rigorosamente.
Exemplo
Entrada:
1
2
0
Saída
Teste 1
1
Teste 2
3
Restrições
0 <= N <= 30 (N = 0 apenas para indicar o final da entrada)
Resolução
#include <stdio.h>
int main ()
{
int n,mov,teste = 1;
scanf("%d",&n);
while (n!=0)
{
mov = (pow(2,n))-1;
teste++;
printf ("%d \n\n",mov);
scanf ("%d",&n);
}
return 0;
}
1390. Mini-Poker
85
Problema: OBIPOKER
Mini-Poker é o nome de um jogo de cartas que é uma simplificação de Poker, um

dos mais famosos jogos de cartas do mundo. Mini-Poker é jogado com um baralho
normal de 52 cartas, com quatro naipes (copas, paus, espadas e ouro), cada naipe
compreendendo treze cartas (Ás, 2, 3, 4, 5, 6, 7, 8, 9, 10, Valete, Dama, Rei).
No início do jogo, cada jogador recebe cinco cartas. O conjunto de cinco cartas vale
um certo número de pontos, de acordo com as regras descritas abaixo.
Diferentemente do jogo de Poker normal, em Mini-Poker o naipe das cartas é
desconsiderado. Assim, para simplificar a descrição do jogo, vamos utilizar os
números de 1 a 13 para identificar as cartas do baralho, na ordem dada acima.
Uma outra diferença é que pode ocorrer empate entre mais de um vencedor; nesse
caso os vencedores dividem o prêmio.
As regras para pontuação em Mini-Poker são as seguintes:
1. Se as cinco cartas estão em seqüência a partir da carta x (ou seja, os valores

das cartas são x, x+1, x+2, x+3 e x+4), a pontuação é x+200 pontos. Por
exemplo, se as cartas recebidas são 10, 9, 8, 11 e 12, a pontuação é 208 pontos.
2. Se há quatro cartas iguais x (uma quadra, ou seja, os valores das cartas são x,
x, x, x e y), a pontuação é x+180 pontos. Por exemplo, se as cartas recebidas são
1, 1, 1, 10 e 1, a pontuação é 181 pontos.
3. Se há três cartas iguais x e duas outras cartas iguais y (uma trinca e um par, ou
seja, os valores das cartas são x, x, x, y e y), a pontuação é x + 160 pontos. Por
4. Se há três cartas iguais x e duas outras cartas diferentes y e z (uma trinca, ou

seja, os valores das cartas são x, x, x, y e z), a pontuação é x + 140 pontos. Por
5. Se há duas cartas iguais x, duas outras cartas iguais y (x != y) e uma outra

carta distinta z (dois pares, ou seja, os valores das cartas são x, x, y, y e z), a
pontuação é 3 × x + 2 × y + 20 pontos, em que x > y. Por exemplo, se as cartas
recebidas são 12, 7, 12, 8 e 7, a pontuação é 70 pontos.
6. Se há apenas duas cartas iguais x e as outras são todas distintas (um par, ou
seja, os valores das cartas são x, x, y, z e t), a pontuação é x pontos. Por exemplo,
se as cartas recebidas são 12, 13, 5, 8 e 13, a pontuação é 13 pontos.
7. Se todas as cartas são distintas, não há pontuação.
Tafefa
Escreva um programa que, fornecidas as cartas dadas a um jogador, calcule

pontuação do jogador naquela jogada.
Entrada
86
A entrada é composta por vários casos de teste, cada um correspondendo a uma
jogada. A primeira linha da entrada contém um inteiro N que indica o número de
casos de teste (1 <= N <= 100). Cada uma das N linhas seguintes contém cinco
números inteiros C1,C2,C3,C4 e C5, representando as cinco cartas recebidas por
um jogador (1 <= C1,C2,C3,C4,C5 <= 13).
Saída
Para cada caso de teste da entrada, seu programa deve produzir três linhas na
saída. A primeira linha deve conter um identificador do caso de teste, no formato
“Teste n”, onde n é numerado seqüencialmente a partir de 1. A segunda linha deve
conter a pontuação do jogador considerando as cinco cartas recebidas. A terceira
linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo,
deve ser seguida rigorosamente.
Exemplo
Entrada:
2
12 3 10 3 12
1 2 3 5 4
Saída:
Teste 1
62
Teste 2
201
Restrições
1 <= N <= 100

1 <= C1,C2,C3,C4,C5 <= 13
Resolução
#include<stdio.h>
#define n_cartas 5
int main()
{
int aux, carta[n_cartas],a,n,i,j,x=0,y=0,pontuacao,teste=1,achei;
scanf("%d",&n);
for (a=0;a<n;a++)
{
pontuacao = 0;
achei = 1;
for (i=0;i<n_cartas;i++)
{
scanf("%d",&carta[i]);
}
for (i=0;i<n_cartas;i++)
{
87
for(j=0;j<n_cartas-1;j++)
{
if (carta[j] > carta[j+1])
{
aux = carta[j];
carta[j] = carta[j+1];
carta[j+1] = aux;
}
}
}
for(i=0;i<n_cartas-1;i++) //Sequencia
{
if (carta[i+1]-carta[i] != 1)
{
achei=0;
i=n_cartas;
}
}
if(achei)
pontuacao = 200+carta[0];
else //Quadra
{
achei =0;
for(i=0;i<n_cartas-3;i++)
{
if ((carta[i]==carta[i+1]) && (carta[i+1]==carta[i+2]) && (carta[i+2]==carta[i+3]))
{
achei=1;
i=n_cartas;
}
}
if (achei)
pontuacao = 180+carta[2];
else //Full House
{
if((carta[0]==carta[1]) && carta[1]==carta[2] && carta[3]==carta[4])
achei=1;
else if ((carta[0]==carta[1]) && carta[2]==carta[3] && carta[3]==carta[4])
achei=1;
if(achei)
pontuacao=160+carta[2];
else //Trinca
{
{
if((carta[i]==carta[i+1]) && (carta[i+1]==carta[i+2]))
{
achei=1;
i=n_cartas;
}
}
if(achei)
88
pontuacao=140+carta[2];
else //Dois Pares
{
x=y=0;
{
if(carta[i]==carta[i+1])
{
y=x;
x=carta[i];
}
}
if (y)
pontuacao = (3*x)+(2*y)+20;
else //Par
{
for (i=0;i<n_cartas-1;i++)
{
if(carta[i]==carta[i+1])
{
achei=1;
x=i;
i=n_cartas;
}
}
if(achei)
pontuacao=carta[x];
}
}
}
}
}
printf("Teste %d\n%d\n\n",teste++,pontuacao);
}
return 0;
}
89
845. Tetris
Problema: OBITETRI
A sua turma do colégio resolveu organizar um campeonato de tetris. Após

discussão sobre as regras, ficou definido que cada aluno jogaria um total de 12
partidas. Das 12 pontuações obtidas por um aluno, a maior e a menor são
descartadas, e as demais são somadas, resultando na pontuação final do aluno.
Tarefa
Como você possui conhecimentos de programação, acabou sendo designado pela

turma para escrever um programa para imprimir a classificação final do
campeonato, a partir das pontuações de cada jogador.
Entrada

conjunto de testes contém um número inteiro J, que indica o número de jogadores
que participaram do campeonato. A seguir, para cada jogador há duas linhas na
entrada: a primeira possui o nome do jogador (formado apenas por letras, sendo
apenas a inicial em maiúscula, e com no máximo 15 letras), e a segunda possui as
12 pontuações que o jogador obteve, separadas por espaço. As pontuações são
inteiros entre 0 e 1000. O final da entrada é indicado por um conjunto de teste com
J = 0.
Saída
Para cada conjunto de teste, o seu programa deve escrever uma linha contendo o
identificador do conjunto de teste, no formato “Teste n”, onde n é numerado
seqüencialmente a partir de 1. A seguir, o seu programa deve escrever a
classificação final no campeonato, utilizando uma linha para cada participante. Cada
linha deve conter três informações, separadas por um espaço em branco: a
classificação do jogador, a sua pontuação final, e o seu nome. A classificação de um
jogador é igual a 1 mais o número de jogadores que obtiveram pontuação maior do
que a sua. Em caso de empate, os jogadores devem ser ordenados em ordem
alfabética. Depois de toda a classificação, deve ser deixada uma linha em branco. O
formato do exemplo de saída abaixo deve ser seguido rigorosamente.
Exemplo
Entrada:
4
Zezinho
100 123 133 333 400 300 129 200 360 340 200 600
Luizinho
60 50 120 250 170 190 190 220 260 270 290 300
Carlinhos
10 10 20 10 10 10 10 20 20 20 20 20
Joaozinho
200 300 400 400 500 500 500 600 650 650 700 810
3
Pedrinho
100 100 200 200 300 300 400 400 500 500 600 600
Huguinho
90
50 100 200 200 300 300 500 500 400 400 600 700
Zezinho
100 100 100 100 100 100 100 100 100 100 100 100
0
Saída:
Teste 1
1 5200 Joaozinho
2 2518 Zezinho
3 2020 Luizinho
4 150 Carlinhos
Teste 2
1 3500 Huguinho
1 3500 Pedrinho
3 1000 Zezinho
Restrições
0 <= J <= 1000 (J = 0 apenas para indicar final da entrada)

0 <= pontuação em uma partida <= 1000
1 <= tamanho dos nomes, em número de letras <= 15
Resolução
#include <stdio.h>
#include <string.h>
struct campeonato
{
char nome[17];
int pontos[12];
int soma;
int posicao;
};
int main ()
{
int j, i, k, min, max, teste = 1, aux, col, col2;
char aux2[17];
scanf("%d",&j);
while (j!= 0)
{
min = 1001;
max = -1;
struct campeonato tetris[j];
for (i=0;i<j;i++)
{
scanf ("%s",&tetris[i].nome);
scanf ("%d %d %d %d %d %d %d %d %d %d %d
%d",&tetris[i].pontos[0],&tetris[i].pontos[1],&tetris[i].pontos[2],&tetris[i].pontos[3],&tetris[i].
pontos[4],&tetris[i].pontos[5],&tetris[i].pontos[6],&tetris[i].pontos[7],&tetris[i].pontos[8],&tet
ris[i].pontos[9],&tetris[i].pontos[10],&tetris[i].pontos[11]);
91
}
for (i=0;i<j;i++)
{
min = 1001;
max = -1;
tetris[i].soma = 0;
for (k=0;k<12;k++)
{
tetris[i].soma += tetris[i].pontos[k];
if (tetris[i].pontos[k] < min)
min = tetris[i].pontos[k];
if (tetris[i].pontos[k] > max)
max = tetris[i].pontos[k];
if (k == 11)
tetris[i].soma -= (min+max);
}
}
for (i=0;i<j;i++)
{
for (k=0;k<j-1;k++)
{
if (tetris[k].soma < tetris[k+1].soma)
{
aux = tetris[k].soma;
tetris[k].soma = tetris[k+1].soma;
tetris[k+1].soma = aux;
strcpy (aux2,tetris[k].nome);
strcpy (tetris[k].nome,tetris[k+1].nome);
strcpy (tetris[k+1].nome,aux2);
}
if (tetris[k].soma == tetris[k+1].soma)
{
if(strcmp(tetris[k].nome,tetris[k+1].nome) > 0)
{
aux = tetris[k].soma;
tetris[k].soma = tetris[k+1].soma;
tetris[k+1].soma = aux;
strcpy (aux2,tetris[k].nome);
strcpy (tetris[k].nome,tetris[k+1].nome);
strcpy (tetris[k+1].nome,aux2);
}
}
}
}
tetris[0].posicao = 1;
col = 1;
col2 = 2;
for (i=1;i<j;i++)
{
if (tetris[i].soma == tetris[i-1].soma)
{
92
tetris[i].posicao = col;
col2++;
}
else
{
tetris[i].posicao = col2;
col = col2;
col2++;
}
}
for (i=0;i<j;i++)
printf ("%d %d %s\n",tetris[i].posicao,tetris[i].soma,tetris[i].nome);
printf ("\n");
scanf ("%d",&j);
}
return 0;
}
93
3597. Par ou Ímpar
Problema: ODDOREVE
Existem muitas versões do Par ou Ímpar, um jogo jogado por competidores para
decidir questões aletórias (Tais como "Quem codificará este problema?"). Em uma
das versões, para dois jogadores, o jogo inicia com cada jogador dizendo par ou
ímpar. Então eles contam até três (algumas pessoas dizem "Um, dois, três, VAI!").
No três, ambos jogadores mostram uma das mãos, mostrando um número de
dedos (de zero a cinco). Se a soma dos dedos resulta em um número par, então a
pessoa que disse par ganha. Se a soma dos dedos for um número ímpar, então a
pessoa que disse ímpar ganha.
John e Mary jogaram muitas vezes jogos de Par ou Ímpar. Em todos os jogos John
escolheu ímpar (e, conseqüentemente, Mary escolheu par). Durante os jogos cada
jogador escreveu, em pequenos cartões, quantos dedos ele/ela mostraram, usando
uma carta para cada jogo - Mary usou cartões azuis, John usou cartões vermelhos.
O objetivo deles era ser capar de re-checar os resultados depois, procurando pelos
cartões de cada jogo. Entretanto, no fim do dia John derrubou o deque de cartões,
e após terem separados os cartões por cor, eles agora perderam a ordem.
Dado o conjunto de números escritos nos cartões vermelhos e azuis, você deve
escrever um programa para determinar o número mínimo de jogos que Mary
certamente ganhou.
Entrada
A entrada contém vários casos de teste. A primeira linha de cada caso de teste
contém um inteiro N representando o numero de jogos jogados (1<=N<=100). A
segunda linha de um caso de teste contém N inteiros X i, indicando o numero de
dedos mostrados por Mary em cada um dos jogos (0<=Xi =5, para 1<=i<=N). A
terceira linha de cada caso de teste contém N inteiros Y i, indicando o número de
dedos mostrados por John em cada um dos jogos (0<=Yi<=5, para 1<=i<=N). O fim
da entrada é indicado por N=0.
Saída
Para cada caso de teste, seu programa deve escrever uma linha, contendo um
inteiro, indicando o número mínimo de jogos que Mary certamente ganhou.
Exemplo de entrada
1 0 4
3 1 2
0 2 2 4 2 1 2 0 4
94
1 2 3 4 5 0 1 2 3
Exemplo de saída
Resolução
#include <stdio.h>
int main ()
{
int n,i,total,k,min;
while ((scanf("%d",&n)) && n!=0)
{
int john[n],mary[n];
total=0;
min=0;
for (i=0;i<n;i++)
{
scanf ("%d",&mary[i]);
}
for (i=0;i<n;i++)
{
scanf ("%d",&john[i]);
}
for (i=0;i<n;i++)
for (k=0;k<n;k++)
if (john[k]<=5)
if((mary[i]+john[k])%2 != 0)
{
total++;
john[k]=6;
break;
}
min = n-total;
printf ("%d\n",min);
}
return 0;
}
95
2844. Você pode dizer 11
Problema: ONZE
A sua tarefa é, dado um número positivo N, determinar se ele é um múltiplo de

onze.
Entrada
A entrada é um arquivo onde cada linha contém um número positivo. Uma linha
contendo o número 0 sinaliza o fim da entrada. Os números dados podem conter
até 1000 dígitos.
Saída
A saída do programa deve indicar, para cada número da entrada, se ele é um

múltiplo de onze ou não.
Exemplo de Entrada
112233
30800
2937
323455693
5038297
112234
0
Exemplo de Saída
112233 is a multiple of 11.

112234 is not a multiple of 11.
96
Resolução
#include <stdio.h>
int main ()
{
char n[1001];
int i,somapar,somaimpar,dif,flag;
while (scanf("%s",&n))
{
flag=0;
somapar=0;
somaimpar=0;
for (i=0;n[i];i++)
{
if(n[i]!='0')
{
flag=1;
break;
}
}
if (!flag)
return 0;
else
{
for (i=0;n[i];i++)
{
if(i%2==0)
somaimpar += n[i]-48;
else
somapar += n[i]-48;
}
dif = somaimpar-somapar;
printf("%s %s",n,((dif%11==0) || dif==0)?"is a multiple of 11.\n":"is not a multiple of
11.\n");
}
}
return 0;
}
97
2284. Palavras primas
Problema: PAPRIMAS
Um número primo é um número que possui somente dois divisores: ele mesmo e o
número 1. Exemplos de números primos são: 1, 2, 3, 5, 17, 101 e 10007.
Neste problema você deve ler um conjunto de palavras, onde cada palavra é
composta somente por letras no intervalo a-z e A-Z. Cada letra possui um valor
específico, a letra a vale 1, a letra b vale 2 e assim por diante, até a letra z, que
vale 26. Do mesmo modo, a letra A vale 27, a letra B vale 28 e a letra Z vale 52.
Você deve escrever um programa para determinar se uma palavra é uma palavra
prima ou não. Uma palavra é uma palavra prima se a soma de suas letras é um
número primo.
Entrada
A entrada consiste de um conjunto de palavras. Cada palavra está sozinha em uma

linha e possui L letras, onde 1 ≤ L ≤ 20. A entrada é terminada por fim de arquivo
(EOF).
Saída
Para cada palavra você imprimir: It is a prime word., se a soma das letras da
palavra é um número primo, caso contrário você deve imprimir It is not a prime
word..
Exemplo
Entrada:
UFRN
contest
AcM
Saída:
It is a prime word.
It is not a prime word.
It is not a prime word.
98
Resolução
#include <stdio.h>
#include <string.h>
int main ()
{
int soma,tamanho,i,primo;
char palavra[21] ;
while (scanf ("%s",&palavra) != EOF)
{
soma=0;
primo=0;
tamanho = strlen(palavra);
for (i=0;i<tamanho;i++)
{
if (palavra[i]<91)
soma+=palavra[i]-38;
else
soma+=palavra[i]-96;
}
for (i=1;i<=soma/2;i++)
{
if (soma%i==0)
primo++;
if (primo==2)
i=soma/2;
}
if (primo==1)
printf ("It is a prime word.\n");
else if (soma==1)
printf ("It is a prime word.\n");
else
printf ("It is not a prime word.\n");
}
return 0;
}
99
1363. Par ou ímpar
Problema: PAR
Muitas crianças gostam de decidir todas as disputas através do famoso jogo de Par
ou Ímpar. Nesse jogo, um dos participantes escolhe Par e o outro Ímpar. Após a
escolha, os dois jogadores mostram, simultaneamente, uma certa quantidade de
dedos de uma das mãos. Se a soma dos dedos das mãos dos dois jogadores for
par, vence o jogador que escolheu Par inicialmente, caso contrário vence o que
escolheu Ímpar.
Tarefa
Dada uma seqüência de informações sobre partidas de Par ou Ímpar (nomes dos
jogadores e números que os jogadores escolheram), você deve escrever um
programa para indicar o vencedor de cada uma das partidas.
Entrada
A entrada é composta de vários conjuntos de testes. A primeira linha de um

conjunto de testes contém um inteiro N, que indica o número de partidas de Par ou
Ímpar que aconteceram. As duas linhas seguintes contêm cada uma um nome de
jogador. Um nome de jogador é uma cadeia de no mínimo um e no máximo dez
letras (maiúsculas e minúsculas), sem espaços em branco. As N linhas seguintes
contêm cada uma dois inteiros A e B que representam o número de dedos que cada
jogador mostrou em cada partida (0 <= A <= 5 e 0 <= B <= 5). Em todas as
partidas, o primeiro jogador sempre escolhe Par. O final da entrada é indicado por N
= 0.
Exemplo de entrada
3
Pedro
Paulo
2 4
3 5
1 0
2
Claudio
Carlos
1 5
2 3
0
Saída
Para cada conjunto de teste da entrada, seu programa deve produzir a saída da
seguinte forma. A primeira linha deve conter um identificador do conjunto de teste,
no formato "Teste n", onde n é numerado seqüencialmente a partir de 1. As
próximas N linhas devem indicar o nome do vencedor de cada partida. A próxima
linha deve ser deixada em branco. A grafia mostrada no Exemplo de 3 Saída,
abaixo, deve ser seguida rigorosamente.
Exemplo de Saída
Teste 1
100
Pedro
Pedro
Paulo
Teste 2
Claudio
Carlos
Restrições

0 <= A <= 5
0 <= B <= 5
1 <= comprimento do nome de jogador <= 10
Resolução
#include <stdio.h>
int main ()
{
int n, i, teste = 1;
scanf("%d",&n);
while (n!=0)
{
int a[n], b[n];
char nome1[12], nome2[12];
scanf ("%s",&nome1);
scanf ("%s",&nome2);
for (i=0;i<n;i++)
{
scanf ("%d %d",&a[i],&b[i]);
}
teste++;
for (i=0;i<n;i++)
{
if ((a[i]+b[i])%2 == 0)
printf ("%s\n",nome1);
else
printf ("%s\n",nome2);
}
printf ("\n");
scanf("%d",&n);
}
return 0;
}
101
2846. Paridade
Problema: PARIDADE
Definimos a paridade de um inteiro n como a soma dos seus bits em representação

binária computada módulo dois. Como exemplo, o número 21 = 101012 possui três
1s na sua representação binária e portanto ele possui paridade 3 (mod 2), ou 1.
Neste problema, você deverá calcular a paridade de um inteiro 1 ≤ I ≤

2147483647.
Entrada
Cada linha da entrada possui um inteiro I e o fim da entrada é indicado por uma
linha onde I = 0, a qual não deve ser processada.
Saída
Para cada inteiro I na entrada você deve imprimir uma linha The parity of B is P
(mod 2)., onde B é a representação binária de I.
Exemplo de Entrada
1
2
10
21
0
Exemplo de Saída
The parity of 1 is 1 (mod 2).

102
Resolução
#include <stdio.h>
int main()
{
int n, i, total,count;
{
char b[32];
total=0;
i=0;
count=0;
while (n>0)
{
if (n%2==0)
b[i++]='0';
else
{
b[i++]='1';
total++;
}
n/=2;
count++;
}
printf ("The parity of ");
for (i=count-1;i>=0;i--)
printf ("%c",b[i]);
printf (" is %d (mod 2).\n",total);
}
return 0;
}
103
3827. Pontos
Problema: PARPROX
Escreva um programa que, dados vários pontos no plano, imprima a distância do

par de pontos mais próximos.
Entrada
A entrada é contém um único caso de teste. A primeira linha contém um número

inteiro positivo N, que indica o número de pontos a serem considerados. As N linhas
seguintes contêm dois números inteiros cada, representando as coordenadas X e Y
de cada ponto.
Saída
Seu programa deve imprimir uma única linha, contendo um número que
corresponde a distância do par de pontos mais próximos, com precisão na terceira
casa decimal.
Restrições
 0 ≤ N ≤ 1000
 -2000000 ≤ X, Y ≤ 2000000
Exemplo
Entrada
2
0 0
2 2
Saída
2.828
Entrada
5
100 -80
-9000 100
-200 100
500 -915
214 5
Saída
142.201
104
Resolução
#include <stdio.h>
#include <math.h>
int main ()
{
int n, p1, p2, i, j, x, y;
double min = 4000001;
float dist;
scanf ("%d",&n);
int x1[n], y1[n];
for (i=0;i<n;i++)
{
scanf ("%d %d",&x1[i],&y1[i]);
}
for (i=0;i<n;i++)
{
for (j=0;j<n;j++)
{
if (j != i)
{
x = (x1[j])-(x1[i]);
y = (y1[j])-(y1[i]);
dist = hypot(x,y);
if (dist < min)
min = dist;
}
}
}
printf ("%.3lf",min);
return 0;
}
105
8705. Pedágio
Problema: PEDAGIO1
A invenção do carro tornou muito mais rápido e mais barato realizar viagens de
longa distância. Realizar uma viagem rodoviária tem dois tipos de custos: cada
quilômetro percorrido na rodovia tem um custo associado (não só devido ao
consumo de combustível mas também devido ao desgaste das peças do carro,
pneus, etc.), mas também é necessário passar por vários pedágios localizados ao
longo da rodovia.
Os pedágios são igualmente espaçados ao logo da rodovia; o começo da estrada

não possui um pedágio, mas o seu final pode estar logo após um pedágio (por
exemplo, se a distância entre dois pedágios consecutivos for de 37 km e a estrada
tiver 111 km, o motorista deve pagar um pedágio aos 37 km, aos 74 km e aos 111
km, logo antes de terminar a sua viagem)
Tarefa
Dadas as características da rodovia e os custos com gasolina e com pedágios,

calcule o custo total da viagem.
Entrada
A entrada consiste de duas linhas. A primeira linha da entrada contém dois inteiros
L e D (1 ≤ L, D ≤ 10 4), indicando o comprimento da estrada e a distância entre
pedágios, respectivamente. A segunda linha contém dois inteiros K e P (1 ≤ K, P ≤
10 4 ), indicando o custo por quilômetro percorrido e o valor de cada pedágio. O
primeiro pedágio está localizado no quilômetro D da estrada (ou seja, a distância
do início da estrada para o primeiro pedágio é D quilômetros).
Saída
Seu programa deve imprimir uma única linha contendo um único inteiro, indicando
o custo total da viagem.
Exemplo
Entrada
111 37
1 10
Saída
141
Entrada
100 30
3 14
Saída
342
Entrada
20 70
9 17
106
Saída
180
Resolução
#include <stdio.h>
int main()
{
int pedagio, rodovia, val_ped, val_gas, total=0;
scanf ("%d %d",&rodovia,&pedagio);
pedagio = rodovia/pedagio;
scanf ("%d %d",&val_gas,&val_ped);
total=total+(rodovia*val_gas)+(pedagio*val_ped);
return 0;
}
107
1734. Quem vai ser reprovado
Problema: PLACAR
Prof. Wallywow da Universidade da Columbia Britânica está muito preocupado com

a queda do nível de atenção de seus estudantes. Ele já tentou várias técnicas
mundialmente conhecidas para incentivar os alunos a prestar atenção nas suas
aulas e fazer as tarefas que ele passa para a turma: deu nota para os alunos mais
participativos, ofereceu chocolates aos alunos, levou seu karaokê e cantava nas
aulas etc. Como tais medidas não levaram a uma melhora no comparecimento às
aulas (a idéia do karaokê, inclusive, mostrou-se bastante infeliz... na segunda aula
com karaokê a turma reduziu-se a um aluno -- que tinha problemas auditivos) ele
teve uma brilhante idéia: faria uma competição entre os alunos.
Prof. Wallywow passou um conjunto de problemas aos alunos, e deu um mês para
que eles os resolvessem. No final do mês os alunos mandaram o número de
problemas resolvidos corretamente. A promessa do brilhante didata era reprovar
sumariamente o último colocado da competição. Os alunos seriam ordenados
conforme o número de problemas resolvidos, com empates resolvidos de acordo
com a ordem alfabética dos nomes (não há homônimos na turma). Isso fez com
que alunos com nomes iniciados nas últimas letras do alfabeto se esforçassem
muito nas tarefas, e não compartilhassem suas soluções com colegas
(especialmente aqueles cujos nomes começassem com letras anteriores). Sua
tarefa neste problema é escrever um programa que lê os resultados dos alunos do
Prof. Wallywow e imprime o nome do infeliz reprovado.
Qualquer semelhança entre o Prof. Wallywow e o Prof. Carlinhos é mera

coincidência.
Entrada
A entrada é composta de diversas instâncias. A primeira linha de cada instância

consiste em um inteiro n (1 <= n <= 100) indicando o número de alunos na
competição. Cada uma das n linhas seguintes contém o nome do aluno e o número
de problemas resolvidos por ele. O nome consiste em uma seqüência de letras [a-
z] com no máximo 20 letras e cada time resolve entre 0 a 10 problemas.
Saída
Para cada instância, você deverá imprimir um identificador Instancia k, onde k é

o número da instância atual. Na linha seguinte imprima o nome do infeliz
reprovado.
Exemplo
Entrada:
4
cardonha 9
infelizreprovado 3
marcel 9
108
infelizaprovado 3
Saída:
Instancia 1
infelizreprovado
Resolução
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
struct notas
{
int nota;
char nome[22];
};
int main()
{
int n,i,instancia=1, nota, verif;
while (scanf ("%d", &n) != EOF)
{
nota = 11;
struct notas val[n];
for (i=0;i<n;i++)
{
scanf ("%s %d",&val[i].nome,&val[i].nota);
if (val[i].nota < nota)
{
verif = i;
nota = val[i].nota;
}
if (val[i].nota == nota)
{
if(strcmp(val[verif].nome,val[i].nome) < 0)
{
verif = i;
nota = val[i].nota;
}
}
}
printf ("Instancia %d\n",instancia++);
printf ("%s\n\n",val[verif].nome);
}
return 0;
}
109
2839. Popularidade
Problema: POPULAR
Autor: Tiago Mota
Uma escola está promovendo uma eleição de popularidade, para determinar,

naturalmente, quem é o aluno mais popular. Foi definido, então, que cada aluno
deverá votar nos alunos de quem gosta. A quantidade de votos dados por cada
aluno é variável, isto é, cada aluno pode votar em quantos alunos desejar, de
acordo com suas preferências. O vencedor será aquele que receber mais votos, ou
seja, aquele para o qual mais alunos indicaram que gostam dele.
Para realizar a eleição, cada aluno receberá uma cédula eleitoral contendo os
nomes de todos os alunos da escola (inclusive ele próprio), na qual deverá
preencher os quadrados ao lado dos nomes dos alunos que gosta, utilizando caneta
esferográfica azul ou preta. Após o término do período de votação, as cédulas serão
colocadas numa máquina, a qual é capaz de informar quais quadrados foram
preenchidos em cada cédula.
Você, estagiário da escola em questão, ficou responsável por apresentar um

protótipo do sistema que recebe as informações da máquina e contabiliza os dados
da eleição. Por se tratar de um protótipo, sua tarefa é apenas escrever um
programa que, dadas as informações sobre simulações de preenchimento das
cédulas, informe quantos votos recebeu o vencedor da eleição.
Você pode assumir que os alunos da escola são participativos, de forma que todos
compareceram à votação e cada um preencheu exatamente uma cédula eleitoral.
Você pode assumir, ainda, que os alunos não sofrem por conflitos internos, de
modo que cada aluno gosta de si mesmo e vota em si mesmo. Note, porém, que a
relação gostar de'' não é simétrica, ou seja, se o aluno A gosta do aluno B, não
necessariamente o aluno B gosta do aluno A.
Entrada
A entrada é composta por vários casos de teste, cada um correspondendo a uma

simulação de eleição.
A primeira linha de um caso de teste contém apenas um inteiro, n (1 <= n <=

100), indicando a quantidade de alunos da escola (identificados por inteiros de 1 a
n) e, por conseqüência, a quantidade de cédulas preenchidas. A seguir há n linhas,
cada uma correspondendo a uma cédula processada.
Cada linha contém n inteiros, onde o j-ésimo inteiro da i-ésima linha é igual a 1,
caso o j-ésimo quadrado da cédula i esteja preenchido (ou seja, o aluno de
identificador i votou no aluno de identificador j); ou é igual a 0, caso contrário (o
aluno de identificador i não votou no aluno de identificador j).
A entrada termina quando n = 0.
Saída
110
Para cada caso de teste, seu programa deve imprimir uma linha, contendo apenas
um inteiro, correspondente à quantidade de votos recebidos pelo vencedor da
eleição.
Exemplo
Entrada:
3
1 0 1
0 1 1
1 0 1
5
1 1 1 0 0
1 1 0 1 1
1 0 1 0 1
0 1 0 1 0
0 1 1 1 1
3
1 0 0
0 1 0
0 0 1
0
Saída:
3
4
1
Resolução
#include <stdio.h>
int main()
{
int n,i,j,maior;
{
int candidato,votos[n];
maior = 0;
for (i=0;i<n;i++)
votos[i]=0;
for (i=0;i<n;i++)
{
for (j=0;j<n;j++)
{
scanf("%d",&candidato);
if (candidato)
votos[j] += 1;
if (votos[j]>maior)
maior=votos[j];
}
}
printf ("%d\n",maior);
}
}
111
3828. Primo
Problema: PRIMO
Tarefa
Dado um inteiro N, verifique se N é primo.
Entrada
A entrada é composta por um único caso de teste, composto por uma única linha
que contém o inteiro N.
Saída
Seu programa deve produzir uma única linha, contendo a palavra "sim", se N for
primo, e "nao", caso contrário (note a ausência de acentuação).
Restrições
 |N| < 231
Exemplo
Entrada
7
Saída
sim
Entrada
10
Saída
nao
112
Resolução
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int i, a, cont = 0;
scanf ("%d",&a);
if (a == 0)
printf ("sim");
else if (a<0)
a = a*(-1);
{
for (i=1;i<=a;i++)
{
if (a%i == 0)
cont++;
}
if (cont == 2)
printf ("sim");
else
printf ("nao");
}
return 0;
}
113
3829. Quadrados
Problema: QUADRAD2
Dado um inteiro N, determine quanto vale N2.
Entrada
A entrada é composta por um único caso de teste, composto por uma única linha
que contém o inteiro N.
Saída
Seu programa deve produzir uma única linha, contendo o valor de N2.
Restrições
 |N| ≤ 10000
Exemplo
Entrada
1
Saída
1
Entrada
4
Saída
16
Entrada
2
Saída
4
Resolução
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int a;
scanf ("%d",&a);
a = a*a;
printf ("%d",a);
return 0;
}
114
811. Quermesse
Problema: QUERM
Os alunos do último ano resolveram organizar uma quermesse para arrecadar

fundos para a festa de formatura. A festa prometia ser um sucesso, pois o pai de
um dos formandos, Teófilo, dono de uma loja de informática, decidiu doar um
computador para ser sorteado entre os que comparecessem. Os alunos prepararam
barracas de quentão, pipoca, doces, ensaiaram a quadrilha e colocaram à venda
ingressos numerados sequencialmente a partir de 1. O número do ingresso serviria
para o sorteio do computador. Ficou acertado que Teófilo decidiria o método de
sorteio; em princípio o sorteio seria, claro, computadorizado.
O local escolhido para a festa foi o ginásio da escola. A entrada dos participantes foi
pela porta principal, que possui uma roleta, onde passa uma pessoa por vez. Na
entrada, um funcionário inseriu, em uma lista no computador da escola, o número
do ingresso, na ordem de chegada dos participantes. Depois da entrada de todos os
participantes, Teófilo começou a trabalhar no computador para preparar o sorteio.
Verificando a lista de presentes, notou uma característica notável: havia apenas um
caso, em toda a lista, em que o participante que possuia o ingresso numerado com
i, havia sido a i-ésima pessoa a entrar no ginásio. Teófilo ficou tão encantado com
a coincidência que decidiu que o sorteio não seria necessário: esta pessoa seria o
ganhador do computador.
Tarefa
Conhecendo a lista de participantes, por ordem de chegada, sua tarefa é

determinar o número do ingresso premiado, sabendo que o ganhador é o único
participante que tem o número do ingresso igual à sua posição de entrada na festa.
Entrada

conjunto de teste contém um número inteiro positivo N que indica o número de
participantes da festa. A linha seguinte contém a sequência, em ordem de entrada,
dos N ingressos das pessoas que participaram da festa. O final da entrada é
indicado quando N = 0. Para cada conjunto de teste da entrada haverá um único
ganhador.
Saída
primeira linha identifica o conjunto de teste, no formato "Teste n", onde n é
numerado a partir de 1. A segunda linha deve conter o número do ingresso do
ganhador, conforme determinado pelo seu programa. A terceira linha deve ser
Exemplo
Entrada:
4
4 5 3 1
10
115
9 8 7 6 1 4 3 2 12 10
0
Saída:
Teste 1
3
Teste 2
10
Restrições
Resolução
#include <stdio.h>
int main ()
{
int n=1,i,teste=1;
while (n != 0)
{
scanf("%d",&n);
int v[n+1];
for (i=1; i<=n; i++)
{
scanf("%d",&v[i]);
}
for (i=1; i<=n; i++)

{
if (v[i] == i)
{
printf("Teste %d\n",teste);
printf("%d",v[i]);
printf("\n\n");
teste++;
}
}
}
return 0;
}
116
1745. Recuperação
Problema: RECUPERA
A nossa grandiosa Professora Cris no último aquecimento ficou conhecida como a

grande maquiavélica do IME. Para quem não está a par do assunto, a digníssima
professora exigiu que os alunos formassem uma fila em ordem lexicográfica (pelo
nome) com no máximo k permutações. Isto fez com que muitos alunos nem sequer
entrassem na sala para fazer a prova. No entanto, nesta seletiva ela resolveu se
redimir perante seus alunos, e resolveu aplicar um probleminha para recuperação.
Sua tarefa, mesmo não tendo sido reprovado, é dado uma sequência de n inteiros
a1, a2, .., an, onde -30 <= aj <= 30 para j = 1, 2, .., n, imprima, se existir,
um inteiro ak tal que ak = a1 + a2 + .. + ak-1. Se houver mais de um inteiro que
satisfaça esta condição, imprima o que aparece primeiro na seqüência.
Cris: "Meninos, lembrem-se que a soma de nenhum número é zero! Tá?"
Entrada
A entrada é composta de diversas instâncias. A primeira linha de cada instância

consiste em um inteiro n (1 <= n <= 100) indicando o número de inteiros da linha
seguinte devem ser processados.
Saída
Para cada instância, você deverá imprimir um identificador Instancia k, onde k é o

número da instância atual. Na linha seguinte imprima o inteiro que satisfaça a
restrição descrita acima. Caso não exista tal inteiro imprima nao achei.
Exemplo
Entrada:
1
0
7
1 2 3 4 5 6 7
Saída:
Instancia 1
0
Instancia 2
3
Resolução
117
#include <stdio.h>
int main()
{
int n,i,instancia=1,temp,achei,val;
while (scanf("%d",&n)!=EOF)
{
int vet[n];
achei = 0;
for (i=0;i<n;i++)
{
scanf("%d",&vet[i]);
if (!i)
temp=vet[i];
else if (temp==vet[i]&& !achei)
{
val=vet[i];
achei=1;
}
else
temp+=vet[i];
}
printf ("Instancia %d\n",instancia++);
if ((n==1) && (!vet[0]))
printf ("0\n\n");
else if (((n==1) && (vet[0])) || (!achei))
printf ("nao achei\n\n");
else
printf ("%d\n\n",val);
}
return 0;
}
118
810. Rede ótica
Problema: REDOTICA
Os caciques da região de Tutuaçu pretendem integrar suas tribos à chamada

“aldeia global”. A primeira providência foi a distribuição de telefones celulares a
todos os pajés. Agora, planejam montar uma rede de fibra ótica interligando todas
as tabas. Esta empreitada requer que sejam abertas novas picadas na mata,
passando por reservas de flora e fauna. Conscientes da necessidade de preservar o
máximo possível o meio ambiente, os caciques encomendaram um estudo do
impacto ambiental do projeto. Será que você consegue ajudá-los a projetar a rede
de fibra ótica?
Tarefa
Vamos denominar uma ligação de fibra ótica entre duas tabas de um ramo de rede.
Para possibilitar a comunicação entre todas as tabas é necessário que todas elas
estejam interligadas, direta (utilizando um ramo de rede) ou indiretamente
(utilizando mais de um ramo). Os caciques conseguiram a informação do impacto
ambiental que causará a construção dos ramos. Alguns ramos, no entanto, nem
foram considerados no estudo ambiental, pois sua construção é impossível.
Sua tarefa é escrever um programa para determinar quais ramos devem ser
construídos, de forma a possibilitar a comunicação entre todas as tabas, causando
o menor impacto ambiental possível.
Entrada

conjunto de teste contém dois números inteiros positivos N e M que indicam,
respectivamente, o número de tabas e o número de ramos de redes possíveis. As
tabas são numeradas de 1 a N. As M linhas seguintes contêm três inteiros positivos
X, Y e Z, que indicam que o ramo de rede que liga a taba X à taba Y tem impacto
ambiental Z. Com os conjuntos de teste dados sempre é possível interligar todas as
tabas. O final da entrada é indicado quando N = 0.
Saída
119
Para cada conjunto de teste da entrada seu programa deve produzir uma lista dos
ramos de redes que devem ser construídos. A lista deve ser precedida de uma linha
que identifica o conjunto de teste, no formato "Teste n", onde n é numerado a
partir de 1. A lista é composta por uma sequência de ramos a serem construídos,
um ramo por linha. Um ramo é descrito por um par de tabas X e Y , com X < Y. Os
ramos de rede podem ser listados em qualquer ordem, mas não deve haver
repetição. Se houver mais de uma solução possível, imprima apenas uma delas. O
final de uma lista de ramos deve ser marcado com uma linha em branco. A grafia
mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
Exemplo
Entrada:
3 3
1 2 10
2 3 10
3 1 10
5 6
1 2 15
1 3 12
2 4 13
2 5 5
3 2 6
3 4 6
0 0
Saída:
Teste 1
1 2
1 3
Teste 2
1 3
2 3
2 5
3 4
Restrições
0 ≤ N ≤ 100 (N = 0 apenas para indicar o fim da entrada)

1 ≤ M ≤ N(N-1)/2
1 ≤ X ≤ 100
1 ≤ Y ≤ 100
1 ≤ Z ≤ 100
120
Resolução
#include <stdio.h>
int main ()
{
int arestas, vertices, de, para, valor, i, k, j, minimo, teste=1;
while ((scanf ("%d %d",&vertices,&arestas)) && vertices!=0)
{
vertices=vertices+1;
int tabas[vertices];
int grafo[vertices][vertices];
for (i=0;i<vertices;i++) //preenche o vetor de tabas e o grafo com infinito

{
tabas[i]=0; //vetor de tabas
for (k=0;k<vertices;k++)
grafo[i][k]=200; //grafo
}
for (i=0;i<arestas;i++) //recebe as ligações e seus valores e adiciona no grafo

{
scanf ("%d %d %d",&de,&para,&valor);
grafo[de][para]=valor;
grafo[para][de]=valor;
}

k=1;
do //inicia o prim
{
tabas[k]=1;
minimo=200;
for (i=1;i<vertices;i++)
if(tabas[i])
for(j=1;j<vertices;j++)
if(!tabas[j] && grafo[i][j]<minimo)
{
minimo=grafo[i][j];
k=j;
de=i;
para=j;
}
if (de<para && minimo!=200)
printf ("%d %d\n",de,para);
else if (de>para && minimo!=200)
printf ("%d %d\n",para,de);
}while(minimo!=200);
printf ("\n");
}
return 0;
}
121
3830. Soma
Problema: SOMA
Dada uma lista de N inteiros, encontre a soma de todos eles.
Entrada
A entrada é composta de um único caso de teste. A primeira linha contém um

inteiro positivo N. As N linhas seguintes contêm cada uma um inteiro X,
representando os N números a serem somados.
Saída
Seu programa deve produzir uma única linha na saída, contendo a soma de todos
os N inteiros.
Restrições
 0 ≤ N ≤ 50
 |X| ≤ 5000
Exemplo
Entrada
3
1
5
3
Saída
9
Resolução
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int aux, soma=0, n, i;
scanf ("%d",&n);
for (i=1;i<=n;i++)
{
scanf ("%d",&aux);
soma = soma + aux;
}
printf ("%d",soma);
return 0;
}
122
1763. Sudoku
Problema: SUDOIME
O jogo de Sudoku espalhou-se rapidamente por todo o mundo, tornando-se hoje o

passatempo mais popular em todo o planeta. Muitas pessoas, entretanto,
preenchem a matriz de forma incorreta, desrespeitando as restrições do jogo. Sua
tarefa neste problema é escrever um programa que verifica se uma matriz
preenchida é ou não uma solução para o problema.
A matriz do jogo é uma matriz de inteiros 9 x 9 . Para ser uma solução do

problema, cada linha e coluna deve conter todos os números de 1 a 9. Além disso,
se dividirmos a matriz em 9 regiões 3 x 3, cada uma destas regiões também deve
conter os números de 1 a 9. O exemplo abaixo mostra uma matriz que é uma
solução do problema.
Entrada
São dadas várias instâncias. O primeiro dado é o número n > 0 de matrizes na

entrada. Nas linhas seguintes são dadas as n matrizes. Cada matriz é dada em 9
linhas, em que cada linha contém 9 números inteiros.
1 3 2 | 5 7 9 | 4 6 8
4 9 8 | 2 6 1 | 3 7 5
7 5 6 | 3 8 4 | 2 1 9
------+-------+------
6 4 3 | 1 5 8 | 7 9 2
5 2 1 | 7 9 3 | 8 4 6
9 8 7 | 4 2 6 | 5 3 1
------+-------+------
2 1 4 | 9 3 5 | 6 8 7
3 6 5 | 8 1 7 | 9 2 4
8 7 9 | 6 4 2 | 1 5 3
Saída
Para cada instância seu programa deverá imprimir uma linha dizendo Instancia k,
onde k é o número da instância atual. Na segunda linha, seu programa deverá
imprimir SIM se a matriz for a solução de um problema de Sudoku, e NAO caso
contrário. Imprima uma linha em branco após cada instância.
Exemplo
Entrada:
2
1 3 2 5 7 9 4 6 8
4 9 8 2 6 1 3 7 5
7 5 6 3 8 4 2 1 9
6 4 3 1 5 8 7 9 2
5 2 1 7 9 3 8 4 6
9 8 7 4 2 6 5 3 1
2 1 4 9 3 5 6 8 7
3 6 5 8 1 7 9 2 4
8 7 9 6 4 2 1 5 3
1 3 2 5 7 9 4 6 8
123
4 9 8 2 6 1 3 7 5
7 5 6 3 8 4 2 1 9
6 4 3 1 5 8 7 9 2
5 2 1 7 9 3 8 4 6
9 8 7 4 2 6 5 3 1
2 1 4 9 3 5 6 8 7
3 6 5 8 1 7 9 2 4
8 7 9 6 4 2 1 3 5
Saída:
Instancia 1
SIM
Instancia 2
NAO
Resolução
#include <stdio.h>
#include <stdlib.h>
static short flag;
void verificaQuadrados(int m[9][9], int l_off, int c_off) {

int i, j, v[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
for (i = 0; i < 3; ++i) {
for (j = 0; j < 3; ++j) {
if (v[m[i + l_off][j + c_off]] != 0) {
flag = 0;
return;
} else
v[m[i + l_off][j + c_off]]++;
}
}
int main(void) {
int n, i, j, instancia = 1;
scanf("%d%*c", &n);
while (n-- > 0) {
int matriz[9][9];
flag = 1;
for (i = 0; i < 9; ++i)
for (j = 0; j < 9; ++j)
scanf("%d%*c", &matriz[i][j]);
// Verifica as linhas e colunas

for (i = 0; (i < 9) && (flag); ++i) {
int vL[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
vC[10] = { 0, 0, 0,
0, 0, 0, 0, 0, 0, 0 };
for (j = 0; (j < 9) && (flag); ++j) {
// Verifica as linhas
if (vL[matriz[i][j]] != 0)
flag = 0;
else
vL[matriz[i][j]]++;
// Verificas as Colunas
if (vC[matriz[j][i]] != 0)
flag = 0;
124
else
vC[matriz[j][i]]++;
}
}
for (i = 0; i < 9; i += 3)
for (j = 0; j < 9; j += 3)
verificaQuadrados(matriz, i, j);
if (flag)
printf("Instancia %d\nSIM\n", instancia++);
else
printf("Instancia %d\nNAO\n", instancia++);
}
return 0;
}
125
1894. Jogo de Varetas
Problema: VARETAS
Há muitos jogos divertidos que usam pequenas varetas coloridas. A variante usada
neste problema envolve a construção de retângulos. O jogo consiste em, dado um
conjunto de varetas de comprimentos variados, desenhar retângulos no chão,
utilizando as varetas como lados dos retângulos, sendo que cada vareta pode ser
utilizada em apenas um retângulo, e cada lado de um retângulo é formado por uma
única vareta. Nesse jogo, duas crianças recebem dois conjuntos iguais de varetas.
Ganha o jogo a criança que desenhar o maior número de retângulos com o
conjunto de varetas.
Dado um conjunto de varetas de comprimentos inteiros, você deve escrever um

programa para determinar o maior número de retângulos que é possível desenhar.
Entrada
A entrada contém vários casos de teste. A primeira linha de um caso de teste

contém um inteiro N que indica o número de diferentes comprimentos de varetas (1
≤ N ≤ 1.000) no conjunto. Cada uma das N linhas seguintes contém dois números
inteiros Ci e Vi, representando respectivamente um comprimento (1 ≤ Ci ≤
10.000) e o número de varetas com esse comprimento (1 ≤ Vi ≤ 1.000). Cada
comprimento de vareta aparece no máximo uma vez em um conjunto de teste (ou
seja, os valores Ci são distintos). O final da entrada é indicado por N = 0.
A entrada deve ser lida da entrada padrão.
Saída
Para cada caso de teste da entrada seu programa deve produzir uma única linha na
saída, contendo um número inteiro, indicando o número máximo de retângulos que
podem ser formados com o conjunto de varetas dado.
A saída deve ser escrita na saída padrão.
Exemplo
Entrada:
1
10 7
4
50 2
40 2
30 4
60 4
5
15 3
6 3
12 3
70 5
71 1
0
126
Saída:
1
3
2
Resolução
#include <stdio.h>
int main()
{
int n,i,temp,retangulos,soma;
{
int vet[n];
soma=0;
for (i=0;i<n;i++)
{
scanf ("%d %d",&temp,&vet[i]);
if (vet[i]%2!=0)
vet[i]--;
soma += vet[i];
}
retangulos = soma/4;
printf ("%d\n",retangulos);
}
return 0;
}
127

Idioma

Problem As

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Problem As

Enviado por

Direitos autorais:

Formatos disponíveis

Arquivo

Ordenação Bubble Sort

Ordenação Merge Sort

void mergesort(int begin, int end)

middle = (begin + end)/2;

for(i = begin;i <= end;i++)

int compare (const void * a, const void * b)

qsort (votos, n, sizeof(int), compare);

Ordenação Struct Quick

typedef int (*compfn)(const void*, const void*);

struct animal { int number;

struct animal array[10] = { { 1, "Anaconda" },

qsort((void *) &array, // Beginning address of array

printf("\nList after sorting:\n");

int compare(struct animal *elem1, struct animal *elem2)

else if (elem1->number > elem2->number)

for (i = 0; i < 10; i++)

int fat (int n)

int soma (int n)

Unsigned long long int

A crescente utilização do transporte aéreo preocupa os especialistas, que prevêem

A entrada é composta de vários conjuntos de teste. A primeira linha de um

Daniela é enfermeira em um grande hospital, e tem os horários de trabalho muito

Um problema que a tem atormentado na hora de dormir é saber quantos minutos

Os dados devem ser lidos da entrada padrão.

O resultado de seu programa deve ser escrito na saída padrão.

0 <= A <= 100 (A = 0 apenas para indicar o fim da entrada)

Álbuns de figurinhas – sejam de times de futebol, princesas ou super-heróis – têm

A entrada é composta de vários casos de teste, cada um correspondendo a uma

1 <= R <= 1000 (R = 0 apenas para indicar o final da entrada)

As Ilhas Weblands formam um reino independente nos mares do Pacífico. Como é

A entrada é composta de vários conjuntos de teste. Cada conjunto de teste é

0 <= V <= 10000 (V = 0 apenas para indicar o fim da entrada)

A disseminação dos computadores se deve principalmente à capacidade de eles se

A entrada é composta de vários conjuntos de testes. A primeira linha de um

X1 s1 X2 s2 ... Xm-1 sm-1 Xm

 Xi, 1 ≤ i ≤ m, é um operando (0 ≤ Xi ≤ 100);

O final da entrada é indicado pelo valor m = 0.

(esta saída corresponde ao exemplo de entrada acima)

Escreva um programa que computa o número de diferentes fatores primos de um

O programa deve imprimir cada resultado em uma linha diferente, seguindo o

A primeira linha contém dois inteiros N e K separados por um espaço em branco (1

Vó Vitória mantém, desde o nascimento dos netos Joãozinho e Zezinho, um ritual

A entrada é composta de vários conjuntos de teste. A primeira linha de um

0 <= N <= 100 (N = 0 apenas para indicar o ﬁm da entrada)

O cometa Halley é um dos cometas de menor período do Sistema Solar,

A única linha da entrada contém um único inteiro A (2010 ≤ A ≤ 10 4), indicando o

A empresa local de abastecimento de água, a Saneamento Básico da Cidade (SBC),

Faixa de consumo (m³) Preço (m³)

Assim, por exemplo, se o consumo foi de 120 m³ , o valor da conta é:

 7 reais da assinatura básica;

Logo o valor total da conta de água é R$ 267.

Escreva um programa que, dado o consumo de uma residência em m3 , calcula o

A única linha da entrada contém um único inteiro N, indicando o consumo de água

O Canadá é um país muito frio. Em 8 meses por ano as temperaturas praticamente

Exemplo. Considere o diagrama abaixo.

.--- .---. --.

Todos os passeios iniciam no estado p e terminam em q.

O passeio que segue pelas transições (p,1a), (p,1a), (p,1b) e termina no

O jogo inventado pelo papai Smith era o seguinte. Depois de desenhar um

A entrada é composta de diversas palavras (o diagrama é sempre o da figura).

Para cada instância, você deverá imprimir um identificador Palavra k, onde k é o

Após cada instância imprima uma linha em branco.

typedef int (compfn)(const void, const void*);

int compare(struct animal elem1, struct animal elem2)