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


int main(){ int vetor[MAX],i,j,aux;


//ordenar o vetor for (i=1;i<=MAX-1;i++) { aux = vetor[i]; j=i-1; while ((j>=0) && (aux<vetor[j])) { vetor[j+1] = vetor[j]; j--; } vetor[j+1]=aux; }


Ordenação Merge Sort


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 10int main(){ int vetor[MAX],i,j,aux;


//ordenar o vetor for (i=0;i<=MAX-2;i++) { for (j=i+1;j<=MAX-1;j++) { if (vetor[i] > vetor[j]) { aux = vetor[i]; vetor[i]=vetor[j]; vetor[j]=aux; } } }


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


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; printf ("Digite um numero: "); 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; printf ("Digite um numero: "); 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 71 32 13 23 44 53 52 53 51 31 23 2

10

1 22 10 0

Output:Teste 13

Teste 21 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;}

5474. Alarme Despertador

11

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 523 59 0 3421 33 21 100 0 0 0

Saída:120

12

351417

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 <= A1 <= Y <= AX != 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;}

1386. Bafo

13

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:21 52 330 04 710 00

Saída:Teste 1

14

Beto

Teste 2Aldo

Restrições

1 <= R <= 1000 (R = 0 apenas para indicar o final da entrada)0 <= A <= 1000 <= 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;}

812. Bits Trocados

15

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:1720

Saída:Teste 10 0 0 1

Teste 21 2 0 2

Restrições

16

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

Resolução


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;}

1334. Calculando

17

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 Entrada33+7-2235-10-77101+2+3+4+5+6+7+8+9+100

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ídaTeste 1-12

18

Teste 2-82

Teste 355

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

Restrições

1 ≤ m ≤ 1000 ≤ 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; } printf ("Teste %d\n",teste); teste++; printf("%d\n\n",total); scanf ("%d",&m); } return 0;}

1850. Conte os Fatores

19

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:2893849308876927786369167477942383368853877604935166506414220

Saída:289384 : 3930887 : 2692778 : 5636916 : 4747794 : 3238336 : 3885387 : 2760493 : 2516650 : 3641422 : 3

Resolução

20

#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

Entrada5 1mariajoaocarlosvanessajose

Saídacarlos

Entrada5 5mariajoaocarlosvanessa

22

jose

Saídavanessa

Entrada5 3mariajoaocarlosvanessajose

Saídajose

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;}

840. Cofrinhos da Vó Vitória

23

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

A entrada é composta de vários conjuntos de teste. A primeira linha de um 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:320 2510 510 1040 512 00 2017 10

24

Saída:

Teste 1-500

Teste 2-57-133

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]); printf ("Teste %d\n", teste); 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; }

8777. Cometa

Problema: COMETA2

25

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 ≤ 104), 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

Entrada2010

Saída2062

Entrada10000

Saída10042

Entrada2062

Saída2138

Resolução

#include <stdio.h>

int main (){

26

int a,ano=1986; scanf ("%d",&a); while (ano<=a) { ano+=76; } printf ("%d",ano); return 0;}

8703. Conta de água

Problema: CONTA1

27

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é 1011 a 30

31 a 100101 em diante

incluído na franquiaR$ 1R$ 2R$ 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.

Exemplo

Entrada8

Saída7

Entrada14

28

Saída11

Entrada42

Saída51

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;}

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

29

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.

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

30

Entrada:ababbaaaaabbbbaabbabbb

Saída:Palavra 10

Palavra 21

Palavra 31

Palavra 42

Palavra 50

Palavra 615

Palavra 73

Palavra 87

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];

31

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;}

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ã.

32

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

Seu programa deve imprimir uma única linha, contendo a letra identificadora da equipe campeã.

Exemplo

Entrada4 11 00 43 12 31 2

33

2 00 21 24 30 13 23 41 41 0

SaídaF

Entrada2 01 02 11 01 01 21 21 02 11 00 10 22 11 02 1

SaídaA

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;

34

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++; } }

scanf ("%d %d",&m,&n); 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]++; } }


35



scanf ("%d %d",&m,&n); if (m>n) { for (i=0;i<4;i++) { if (vet[i]==2) vet[i]++; } } else { for (i=4;i<8;i++) { if (vet[i]==2) vet[i]++;

36

} }

scanf ("%d %d",&m,&n); 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]++; } }

scanf ("%d %d",&m,&n); 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; } } }

if (campeao==0) printf ("A"); else if (campeao==1) printf ("B"); else if (campeao==2) printf ("C"); else if (campeao==3)

37

printf ("D"); else if (campeao==4) printf ("E"); else if (campeao==5) printf ("F"); else if (campeao==6) printf ("G"); else if (campeao==7) printf ("H"); else if (campeao==8) printf ("I"); else if (campeao==9) printf ("J"); else if (campeao==10) printf ("K"); else if (campeao==11) printf ("L"); else if (campeao==12) printf ("M"); else if (campeao==13) printf ("N"); else if (campeao==14) printf ("O"); else if (campeao==15) printf ("P");

return 0;}

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:

38

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

Entrada4 4 6 2 3 5 3 55 5 4 30 0 0 0

Saída102

Resolução

39

#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;}

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

40

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

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. A segunda linha deve conter o número de pedaços de papel obtidos depois de cortar a dobradura, calculado 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

Entrada:10-1

Saída:Teste 19

41

Teste 24

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

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.

42

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

510001000258840002587

Saída

1000

Entrada

44000350040004000

Saída

4000

Resolução

#include <stdio.h>

int compare (const void * a, const void * b){ return ( *(int*)a - *(int*)b );}

int main (){

43

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

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.

44

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

Entrada5 100 52 73 35 27 0

SaídaN

Entrada5 100 30 50 23 46 4

SaídaS

Entrada6 40 53 54 51 0

45

1 11 1

SaídaS

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;}

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

46

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-HOMEMY-MISERABLE-JOB

Saída:1-4663-79338-466369-647372253-562

Resolução

#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')

47

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"); }}

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.

48

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:31 852 913 73512300 8112601 9915023 7610111 99212 990

Saída:Turma 12

Turma 212601 10111 212

Restrições

0 <= N <= 1000 (N = 0 apenas para indicar o fim da entrada)1 <= C <= 200000 <= M <= 100

Resolução

#include <stdio.h>

49

#define MAX_ALUNOS 1000int 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;}

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

50

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:500910

Saída:f91(500) = 490f91(91) = 91

Resolução

#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;}

51

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

52

0 ≤ N ≤ 12

Exemplo

Entrada

3

Saída

6

Resolução


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;}

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.

53

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

2

1

8

0

Saída para o exemplo de entrada

5

1

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);

54

} return 0;}

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

55

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

Entrada7 410020020015030524942

Saída942524200200

Entrada2 140002000

Saída4000

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; }

56

} } for (i=0;i<m;i++) printf ("%d\n",flip[i]); return 0;}

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.

57

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

Entrada:1.20 2.30 10.00 15.00

Saída:A

Exemplo 2

Entrada:1.00 1.00 9.00 9.01

Saída:G

Exemplo 3

Entrada:1.00 1.00 11.00 11.00

Saída:G

Restrições

0.01 <= A <= 10.000.01 <= G <= 10.000.01 <= Ra <= 20.000.01 <= Rg <= 20.00

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;}

58

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

59

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

Entrada2 3500 700700 500 5002 2200 400200 10003 4530 510 490480 470 50 3100 0

SaídaNYN

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)

60

cond++; }

if (cond>=2) printf ("N\n"); else printf ("Y\n"); } return 0;}

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.

61

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

Entrada301020

Saída30

Entrada5510172030

Saída35

Entrada3123

Saída12

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++) {

62

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]; } printf ("%d",total); return 0;}

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

63

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

Entrada310 56 83 3

Saída5

Entrada410 68 85 1100 100

Saída7

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; } printf ("%d",total); return 0;}

64

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).

65

Saída

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

Exemplo

Entrada3018

Saída12

Entrada2727

Saída0

Entrada2730

Saída-3

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).

66

Saída

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

Exemplo

Entrada3018

Saída12

Entrada2727

Saída0

Entrada2730

Saída-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;}

67

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).

68

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

Entrada33 2 5

SaídaN

Entrada55 5 5

SaídaS

Entrada915 9 10

SaídaS

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;}

69

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

70

A entrada é composta de vários conjuntos de teste. A primeira linha de um 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

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 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

Entrada:4 2-5-12067 435-35510010050500 0

Saída:Teste 1-8 3

Teste 226 75

Restrições

0 <= N <= 10000 (N = 0 apenas para indicar o fim da entrada)-200 <= Temperatura <= 2001 <= M <= N

71

Resolução

#include <stdio.h>

int main (){ int n, m, i, j, max, min, teste=1, media, soma; scanf ("%d %d",&n,&m); 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];

72

media = soma/m; if (media >= max) max = media; if (media <= min) min = media; }

printf ("Teste %d\n",teste++); printf ("%d %d\n\n",min, max); scanf ("%d %d",&n,&m); } return 0;}

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

73

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 entrada2 4 5 121 23 32 4 3 231 12 23 30 0 0 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. A segunda linha deve conter o número de meteoritos que caíram dentro da fazenda. A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.

Exemplo de saídaTeste 11

Teste 22


Restrições

0 ≤ N ≤ 10.0000 ≤ X ≤ 10.0000 ≤ Y ≤ 10.0000 ≤ X1 < X2 ≤ 10.0000 ≤ 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)

74

{ 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;}

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

75

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.

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

Entrada:3 481 28 240 1040 10 100 24020 180 110 35

Saída:450

Exemplo 2

Entrada:4 11001100100

Saída:310

Restrições

1 <= N <= 1001 <= M <= 1000 <= Produtividade de uma célula <= 5000 <= Produtividade de uma linha ou coluna de células <= 50000

76

Resolução

#include <stdio.h>

int main (){ int n,m,i,j,max=0,soma; scanf ("%d %d",&n,&m); 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)

77

{ if (soma > max) max = soma; } } }

printf ("%d",max); return 0;}

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

78

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

Entrada3 5 7

Saída10

Entrada14 15 22

Saída44

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;

}

79

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.

80

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.

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 -10000 0-2000 -10000-999 -10010

SaídaNEdivisaNOdivisaNESOSE

81

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;}

82

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-sefim

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.

83

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 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:120

SaídaTeste 11

Teste 23

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; printf ("Teste %d\n",teste); teste++; printf ("%d \n\n",mov); scanf ("%d",&n); } return 0;}

84

1390. Mini-Poker

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 exemplo, se as cartas recebidas são 10, 4, 4, 10 e 4, a pontuação é 164 pontos.

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 exemplo, se as cartas recebidas são 2, 3, 2, 2 e 13, a pontuação é 142 pontos.

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.

85

Tafefa

Escreva um programa que, fornecidas as cartas dadas a um jogador, calcule pontuação do jogador naquela jogada.

Entrada

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:212 3 10 3 121 2 3 5 4

Saída:Teste 162

Teste 2201

Restrições

1 <= N <= 1001 <= 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;

86

for (i=0;i<n_cartas;i++) { scanf("%d",&carta[i]); } for (i=0;i<n_cartas;i++) { 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 { for(i=0;i<n_cartas-2;i++) { if((carta[i]==carta[i+1]) && (carta[i+1]==carta[i+2]))

87

{ achei=1; i=n_cartas; } } if(achei) pontuacao=140+carta[2]; else //Dois Pares { x=y=0; for(i=0;i<n_cartas-1;i++) { 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;}

88

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

A entrada é composta de vários conjuntos de teste. A primeira linha de um 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:4Zezinho100 123 133 333 400 300 129 200 360 340 200 600Luizinho60 50 120 250 170 190 190 220 260 270 290 300Carlinhos10 10 20 10 10 10 10 20 20 20 20 20

89

Joaozinho200 300 400 400 500 500 500 600 650 650 700 8103Pedrinho100 100 200 200 300 300 400 400 500 500 600 600Huguinho50 100 200 200 300 300 500 500 400 400 600 700Zezinho100 100 100 100 100 100 100 100 100 100 100 1000

Saída:Teste 11 5200 Joaozinho2 2518 Zezinho3 2020 Luizinho4 150 Carlinhos

Teste 21 3500 Huguinho1 3500 Pedrinho3 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++) {

90

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],&tetris[i].pontos[9],&tetris[i].pontos[10],&tetris[i].pontos[11]); } 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;

91

col2 = 2; for (i=1;i<j;i++) { if (tetris[i].soma == tetris[i-1].soma) { tetris[i].posicao = col; col2++; } else { tetris[i].posicao = col2; col = col2; col2++; } } printf ("Teste %d\n",teste++); 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;}

92

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 Xi, 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

3

1 0 4

3 1 2

93

9

0 2 2 4 2 1 2 0 4

1 2 3 4 5 0 1 2 3

0

Exemplo de saída

0

3

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;}

94

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

11223330800293732345569350382971122340

Exemplo de Saída

112233 is a multiple of 11.30800 is a multiple of 11.2937 is a multiple of 11.323455693 is a multiple of 11.5038297 is a multiple of 11.112234 is not a multiple of 11.

95

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;}

96

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:UFRNcontestAcM

Saída:It is a prime word.It is not a prime word.It is not a prime word.

97

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;}

98

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 entrada3PedroPaulo2 43 51 02ClaudioCarlos1 52 30

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

99

Teste 1PedroPedroPaulo

Teste 2ClaudioCarlos


Restrições

0 <= N <= 1000 (N = 0 apenas para indicar o fim da entrada)0 <= A <= 50 <= B <= 51 <= 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]); } printf ("Teste %d\n", teste); 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;}

100

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

1210210

Exemplo de Saída

The parity of 1 is 1 (mod 2).The parity of 10 is 1 (mod 2).The parity of 1010 is 2 (mod 2).The parity of 10101 is 3 (mod 2).

101

Resolução

#include <stdio.h>

int main(){ int n, i, total,count; while (scanf("%d",&n) && n!=0) { 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;}

102

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

Entrada20 02 2

Saída2.828

Entrada5100 -80-9000 100-200 100500 -915214 5

Saída142.201

Resolução

103

#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;}

104

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 ≤ 104), 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

Entrada111 371 10

Saída141

Entrada100 303 14

Saída342

Entrada20 709 17

105

Saída180

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); printf ("%d",total); return 0;}

1734. Quem vai ser reprovado

106

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:4cardonha 9infelizreprovado 3marcel 9 infelizaprovado 3

Saída:

107

Instancia 1infelizreprovado

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;}

2839. Popularidade

108

Problema: POPULARAutor: 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

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

109

Entrada:31 0 10 1 11 0 151 1 1 0 01 1 0 1 11 0 1 0 10 1 0 1 00 1 1 1 131 0 00 1 00 0 10

Saída:341

Resolução

#include <stdio.h>

int main(){ int n,i,j,maior; while (scanf("%d",&n) && n!=0) { 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); }}

3828. Primo

Problema: PRIMO

Tarefa

110

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

Entrada7

Saídasim

Entrada10

Saídanao

Resolução


int main (){ int i, a, cont = 0;

111

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;}

3829. Quadrados

Problema: QUADRAD2

Dado um inteiro N, determine quanto vale N2.

Entrada

112

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

Entrada1

Saída1

Entrada4

Saída16

Entrada2

Saída4

Resolução


int main (){ int a; scanf ("%d",&a); a = a*a; printf ("%d",a); return 0;}

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

113

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

A entrada é composta de vários conjuntos de teste. A primeira linha de um 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

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 número do ingresso do ganhador, conforme determinado 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

Entrada:44 5 3 1109 8 7 6 1 4 3 2 12 100

Saída:Teste 13

Teste 210

Restrições

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

114

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;}

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,

115

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:1071 2 3 4 5 6 7

Saída:Instancia 10

Instancia 23

Resolução

#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]);

116

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;}

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

117

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

A entrada é composta de vários conjuntos de teste. A primeira linha de um 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

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 31 2 102 3 103 1 105 6

118

1 2 151 3 122 4 132 5 53 2 63 4 60 0

Saída:Teste 11 21 3

Teste 21 32 32 53 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

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

119

}

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; }

printf ("Teste %d\n",teste++); 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;}

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.

120

Restrições

0 ≤ N ≤ 50 |X| ≤ 5000

Exemplo

Entrada3153

Saída9

Resolução


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;}

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

121

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 84 9 8 | 2 6 1 | 3 7 57 5 6 | 3 8 4 | 2 1 9------+-------+------6 4 3 | 1 5 8 | 7 9 25 2 1 | 7 9 3 | 8 4 69 8 7 | 4 2 6 | 5 3 1------+-------+------2 1 4 | 9 3 5 | 6 8 73 6 5 | 8 1 7 | 9 2 48 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:21 3 2 5 7 9 4 6 84 9 8 2 6 1 3 7 57 5 6 3 8 4 2 1 96 4 3 1 5 8 7 9 25 2 1 7 9 3 8 4 69 8 7 4 2 6 5 3 12 1 4 9 3 5 6 8 73 6 5 8 1 7 9 2 48 7 9 6 4 2 1 5 31 3 2 5 7 9 4 6 84 9 8 2 6 1 3 7 57 5 6 3 8 4 2 1 96 4 3 1 5 8 7 9 25 2 1 7 9 3 8 4 69 8 7 4 2 6 5 3 12 1 4 9 3 5 6 8 73 6 5 8 1 7 9 2 48 7 9 6 4 2 1 3 5

Saída:Instancia 1SIM

Instancia 2NAO

Resolução


static short flag;

122

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;

} elsev[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 colunasfor (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 linhasif (vL[matriz[i][j]] != 0)

flag = 0;else

vL[matriz[i][j]]++;// Verificas as Colunasif (vC[matriz[j][i]] != 0)

flag = 0;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++);

elseprintf("Instancia %d\nNAO\n", instancia++);

}return 0;

}

123

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

124

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:110 7450 240 230 460 4515 36 312 370 571 10

Saída:132

Resolução

#include <stdio.h>

int main(){ int n,i,temp,retangulos,soma; while (scanf("%d",&n) && n!=0) { 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];

125

} retangulos = soma/4; printf ("%d\n",retangulos); } return 0;}

126

Problem As

Documents

Transcript of Problem As