2007 Beneficente 1

II Maratona Beneficente de Programação
Beneficente UFMA 2007

Departamento de Informática – 21 de Dezembro de 2007
Problema A – Quebra-cabeça
Nome do arquivo fonte: quebra.c ou quebra.cpp ou quebra.java ou
quebra.pas
Você foi contratado por uma fábrica de quebra-cabeças para determinar se algum quebra-cabeça do
estoque está com defeito. Um quebra-cabeça está com defeito quando ao colocarmos todas as peças
falta ou sobra pelo menos uma. O Gerente da fábrica te informa que todas as peças dos quebra-
cabeças são quadradas e cada lado de uma peça tem 1cm.
Entrada
A entrada é composta por vários casos de testes. Cada caso de teste é dado em uma linha. Iniciando-
se com um inteiro 0 <= X <= 5000, informando quantas peças tem o quebra cabeça. Segue-se a
altura do quebra-cabeça dada em centímetros e a largura do quebra-cabeça também dada em
centímetros, onde 0 <= largura, altura <= 5000. Se o numero de peças é igual a zero o programa é
encerrado, não produzindo saída para este caso de testes. Leia da entrada padrão.
Saída
Será impresso "APROVADO!!" caso o quebra-cabeça não esteja com defeito e "REPROVADO!!"
caso contrario. Use a saída padrão.
Exemplo de entrada Respectiva saída

1 1 1 APROVADO!!
2 1 2 APROVADO!!
2 2 2 REPROVADO!!
6 2 3 APROVADO!!
0 0 0
Autor do Problema: Inácio Bouéres, finalista da Maratona de Programação da SBC 2006.
© Departamento de Informática, UFMA 1

Problema B - Dividindo a Pizza
Nome do arquivo fonte: pizza.c, pizza.cpp, pizza.java ou pizza.pas
Tiago é um garoto cheio de amigos e muito justo. Ele sempre trata todos os seus amigos de forma
igual (ou quase igual). Um dia, em sua casa, em uma reunião com vários de seus colegas, Tiago
pediu uma pizza. E ao chegar a pizza, foi que veio a dúvida: como ele iria dividir a pizza entre todos
os seus colegas.
Depois de pensar, pensar e pensar, Tiago chegou a conclusão de que nem todos precisariam receber
um pedaço do mesmo tamanho, mas que ele queria dividir a pizza, fazendo X cortes e gerando o
máximo de pedaços que fosse possível.
Se você fosse amigo de Tiago, poderia ajudá-lo fazendo um programa de computador que dada uma
pizza e sabendo que serão realizados n cortes nela, diga a quantidade máxima de pedaços que podem
ser gerados com estes n cortes.
Mesmo você não conhecendo Tiago, você seria capaz de fazer este programa?
Entrada
A entrada é composta por vários casos de testes. Cada caso de teste é composto de uma linha, com
um inteiro 0 <= N <= 20000, representando o número de cortes que deverão ser feitos na pizza. Um
caso de teste com N = 0 indica que a entrada acabou, sendo que esta não deve ser processada. Leia
a entrada da entrada padrão.
Saída
Como saída, para cada caso de testes seu programa deve imprimir em uma linha, um número C que
indica o número de pedaços que podem ser feitos com aqueles N cortes. Use a saída padrão.

1 2
2 4
20 211
500 125251
0
Autor do Problema: Roberto Gerson, finalista da Maratona de Programação da SBC 2006.

Problema C - Antenado
Nome do arquivo fonte: antena.c ou antena.cpp ou antena.java ou
antena.pas
A empresa de Televisão DEINFTV está com um projeto de expansão de suas antenas para a região agrária da
cidade de São Luís. Entretanto os engenheiros estão com problemas para escolher o melhor lugar para colocar a
antena, com um menor custo.
Sabe-se que a antena consome Energia Elétrica proporcional à Potência que utiliza para as transmissões.
Também sabe-se que quanto maior for a distância que este sinal precisa percorrer da fonte (a antena) até as
casas, maior é a Potência necessária nas transmissões.
A prefeitura ofereceu alguns lugares possíveis para a instalação da nova antena da DEINFTV e cabe a você dizer
qual o lugar que custa menos (em termos de energia elétrica consumida pela antena depois de instalada) para
instalar a antena. Não esqueça que o sinal é enviado em todas as direções ao mesmo tempo.
Entrada
A entrada é composta por vários casos de testes. Cada caso de teste inicia-se com uma linha com um inteiro 0
<= N<= 50 que indica o número de locais oferecido pela prefeitura para instalação da antena. Seguem-se
então N linhas composta cada uma por dois inteiros X, Y, que indicam a posição de um possível local de
instalação da antena. Depois existe um inteiro na entrada 0 <= NC <= 50 que indica o número de casas nas
quais a transmissão deve chegar. Seguem-se então NC inteiros, cada um compostos de dois inteiros XC, YC
que indica a posição de uma casa. Você pode assumir que todos os valores da entrada cabem em um inteiro de
32 bits. A entrada termina quando N = 0 e NC = 0. Leia da entrada padrão.
Saída
Para cada caso de teste, deve ser impresso na saída em uma linha isolada dois inteiros X, Y que indiquem o
local no qual a antena deve ser instalada com o menor custo. Caso dois locais onde pode ser instalada a antena
tenham o mesmo custo, imprima o que aparece primeiro na entrada. Use a saída padrão.

1 0 0
0 0 1 1
2
1 1
2 1
3
0 0
1 0
1 1
4
2 0
2 2
0 2
2 1
0
0

Problema D - Merge-Sort
Nome do arquivo fonte: merge.c, merge.cpp, merge.java ou merge.pas
Algoritmos de ordenação são muito úteis em computação. Conhecer e saber qual o melhor algoritmo
de ordenação para usar em cada situação é a diferença entre um programa que funciona e um
programa que funciona Bem. Aqui conheceremos um destes algoritmos e o analisaremos.
O Mergesort é um algoritmo recursivo baseado na estratégia de dividir para conquistar, cujo objetivo
é ordenar uma seqüência, dada como entrada. O algoritmo é baseado na intercalação de
subseqüências ordenadas, de forma a gerar uma seqüência também ordenada. Os três passos da
estratégia de dividir para conquistar presentes no Mergesort são:
1. Dividir: Dividir os dados em subsequências pequenas;
2. Conquistar: Classificar as duas metades recursivamente aplicando o Mergesort;
3. Combinar: Juntar as duas metades em um único conjunto já classificado.
A seguir apresentamos uma implementação em pseudocódigo do Mergesort. Para fazer a intercalação
das duas subseqüências utilizaremos uma função chamada MERGE, como segue:
MERGE (A, P, q, r) MERGE-SORT(A, p, r)
1. n1 <- q-p+1; 1. se p < r então
2. n2 <- r-q; 2. q <- menor_inteiro_maior_ou_igual [ (p+r)/2 ]
3. criar arranjos L[1..n1+1] e R[1..n2+1]; 3. MERGE-SORT (A, p, q);
4. para i de 1 até n1 faça 4. MERGE-SORT (A, q+1, r)
5. L[i] <- A[p+i-1]; 5. MERGE (A, p, q, r);
6. para j de 1 até n2 faça
7. R[j] <- A[q+j]
8. L[n1+1] <- infinito
9. L[n2+1] <- infinito
10. i <- 1
11. j <- 1
12. para k de p até r faça
13. se L[i] <= R[j] então
14. A[k] <- L[i]
15. i <- i+1
16. senão
17. A[k] <- R[j]
18. j <- j+1
A figura a seguir ilustra o funcionamento recursivo do algoritmo, o qual pode ser visto como uma
árvore.

Ao analisarmos o MergeSort é interessante saber o número de nós na árvore gerada pela recursão
(conforme acima), ou seja, o número de vezes que executamos a função MERGE-SORT. Sua tarefa é,
dado o número de elementos de uma seqüência que se deseja ordenar, determinar o número de
vezes que a função MERGE-SORT é chamada e a altura da árvore que será formada pelas chamadas
recursivas. Veja no exemplo acima que para 8 elementos no array da entrada temos uma árvore de
altura 4 e 15 nós. Para simplificar todos os valores de n estão entre 1 e 2^64 sendo sempre
uma potência de 2.
Entrada
A entrada inicia-se com uma linha contendo um inteiro 1<= C<= 1000, indicando o número de casos
de testes que seguirão. Seguem-se então C linhas, cada uma contendo um inteiro 1<=N<=2^64, que
índica o número de elementos da seqüência que se deseja ordenar. Leia a entrada da entrada
padrão.
Saída
Para cada N lido na entrada deve ser produzida uma linha na saída com 2 inteiros X, Y, separados por
um espaço em branco. O inteiro X indica a altura da árvore que a chamada recursiva ao MERGESORT
daqueles N elementos gera e o inteiro Y o número de vezes que a função MERGE-SORT é chamada.
Imprima a saída da saída padrão.

4
1 1 1
8 4 15
64 7 127
128 8 255

Problema E - Quem quer moeda?
Nome do arquivo fonte: moeda.c, moeda.cpp, moeda.java ou moeda.pas
Fábio é um garoto muito fã de moedas. Geralmente, ao fazer suas compras ele tenta usar o menor número de
moedas possível para que possa ficar com a maior quantidade possível. Embora com poucas moedas seja fácil
descobrir apenas olhando, quando o número de moedas e o valor aumentam fica mais difícil descobrir qual a
configuração que dará o menor número de moedas.
Ele descobriu que você é um exímio programador e resolveu pedir sua ajuda para resolver o problema de uma
forma simplificada (pelo menos, por enquanto!). Neste problema, Fábio dirá a você quais os valores de moedas
que existem no seu país e também qual o valor que ele tem que pagar. Você deverá responder qual a
quantidade de moedas mínima, baseado nestes valores, que Fábio poderá conseguir. Observe que ele não
informa nem quantas e nem quais moedas ele possui em mãos. Você pode assumir que ele possui
moedas ilimitadas de todos os valores que existem.
Entrada
A entrada é composta por vários casos de teste. Cada caso de teste é composto por duas linhas. A
primeira linha contém dois inteiros N e S menores do que 1000 e maiores ou igual a 0, onde N
representa a quantidade de moedas de valores diferentes que existem e S o valor que Fábio deseja
pagar. Na segunda linha seguem-se N inteiros que informam quais os valores de moedas existentes. A
entrada termina quando N=S=0. Leia da entrada padrão.
Saída
Para cada caso de testes de entrada você deve produzir uma linha na saída. Imprima um inteiro na
saída que é a quantidade de moedas mínimas que Fábio precisa para alcançar aquele valor. Caso não
exista nenhuma configuração de moedas que satisfaça, imprima “impossivel”. Imprima na saída
padrão.

3 11 3
1 3 5 4
10
3 11 impossivel
1 2 3
5 50
1 2 3 4 5
3 6
4 5 9
0 0

Problema F - Palavras Antônimas
Nome do arquivo fonte: antonima.c, antonima.cpp, antonima.java ou
antonima.pas
Palavras antônimas são aquelas que possuem significados opostos. Isso todo mundo sabe. Agora vem
o problema: como dizer isso a um computador??
Essa não é uma tarefa nem um pouco trivial, mas acho que você é capaz de fazê-la. Para começar
vamos simplificar um pouco. Em português, existem alguns prefixos que indicam a negação de uma
determinada palavra. Aqui estamos interessados em 3 deles: 'a', 'in', 'des'. Seu objetivo é dado duas
palavras e baseando-se nestes prefixos, dizer se elas são antônimas ou não.
Veja alguns exemplos de palavras antônimas: normal, anormal; feliz, infeliz; conhecido,
desconhecido; arrumado, desarrumado;
Observe que embora possam existir palavras que não são realmente antônimas, ao se basear nestes
critérios seu programa deverá dizer que elas são antônimas. É o caso por exemplo de forma e
informa, seus significados não são opostos, mas o seu programa deve dizer que elas são antônimas.
Entrada
A entrada inicia-se com um inteiro 0 <= N <=1000. Seguem-se então N casos de teste. Cada caso de
teste é composto por uma linha contendo duas string S1 e S2, separadas por um espaço simples.
Você pode assumir que as palavras são compostas apenas por letras do alfabeto português [a-z][A-Z]
e tem no máximo 1001 caracteres. A entrada deve ser lida da entrada padrão.
Saída
Para cada caso de testes da entrada você deve produzir uma linha na saída. Imprima “sao
antonimas”, caso as palavras sejam antônimas, ou “nao sao antonimas” caso elas não sejam
antônimas segundo os critérios acima. Imprima na saída padrão.

6
forma informa sao antonimas
mar Amar sao antonimas
ovo corvo nao sao antonimas
informado DeSinformado sao antonimas
Massa amassa sao antonimas
acender ascender nao sao antonimas

Problema G - Ajudando o Carteiro
Nome do arquivo fonte: carta.c, carta.cpp, carta.java ou carta.pas
João é um carteiro de uma cidade do interior do Maranhão. Todos os dias ele sai para entregar as
cartas na mesma vizinhança. Até hoje, ele sempre entregou suas cartas sem nenhum método, as
vezes passando mais de uma vez pela mesma rua. Contudo, ele sempre achou que poderia fazer este
caminho de uma forma mais inteligente, sem precisar passar duas vezes pela mesma rua, mas
nunca soube como. Pelo menos até Hoje!! Que tal ajudar João?
Você vai receber como entrada, a descrição da vizinhança que João deve entregar suas cartas, iremos
numerar todos os cruzamentos de 1...N e depois informaremos quais cruzamentos ligam-se com
quais cruzamentos (você pode supor que existe cartas para entregar nesta rua, ou seja, João tem que
passar nesta rua). Uma rua aqui é definida como a ligação entre dois cruzamentos.
Sua tarefa é dizer se é possível fazer o que João quer: entregar todas as cartas sem passar
novamente por nenhuma rua. Caso seja possível você também deve informar qual o tamanho
desta rota que João deverá fazer. Assuma que a distância entre dois cruzamentos que se ligam
diretamente é 1.
João sempre parte de um cruzamento, anda por todas as ruas
possíveis e volta para aquele cruzamento. Veja a figura ao lado, onde
as setas mostram um caminho possível para que João passe por
todas as ruas. Ele ao chegar em um cruzamento só pode ir para as
ruas que saem daquele cruzamento. Observe que as ruas são de
duplo sentido. Ou seja, se existe uma rua de 1 para 2,
automaticamente esta rua pode ser usada para ir de 2 para 1.
Observe também que ele pode passar mais de uma vez por um
cruzamento, mas nunca duas vezes pela mesma rua.
Entrada
A entrada é composta por vários casos de testes. Cada caso de teste inicia-se com dois inteiros 0 <=
N e M <= 100, indicando, respectivamente, o número de cruzamentos e o número de ruas. Seguem-
se então, M linhas, indicando em quais ruas o carteiro deve passar. Uma rua é sempre uma ligação
entre dois cruzamentos. A entrada termina quando M = N = 0. Leia a entrada da entrada padrão.
Saída
Imprima “impossivel”, caso não seja possível João efetuar o caminho da forma que ele deseja. Ou
então, imprima “possivel N”, onde N é o tamanho do percurso que João irá fazer. Use a saída
padrão.

9 9 possivel 9
1 2 impossivel
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 1
3 1
1 2
0 0

Problema H - Números Binários Negativos
Nome do arquivo fonte: binario.c ou binario.cpp ou binario.java ou
binario.pas
Para representar números negativos em base binária, geralmente o que se faz é usar o Complemento
de Dois. O Complemento de dois é baseado no Complemento de Um, o qual estamos interessados
aqui. Uma vantagem da utilização da representação em complemento é que a subtração entre dois
números pode ser substituída pela sua soma em complemento.
Para representarmos números inteiros positivos em complemento um não efetuamos qualquer
alteração.
A representação dos números inteiros negativos é obtida efetuando-se: (base - 1) menos cada
algarismo do número.
Veja exemplos Decimal Hexadecimal
999 FFFF
-297 -3A7E
Complemento ---> 702 C581
Faça um programa que receba um número binário e calcule o seu negativo em complemento de um.
Entrada
A entrada inicia-se com uma linha contendo um inteiro N <= 1000. Seguem-se então N casos de
teste. Cada caso de teste é composto por uma linha que contém um número binário de no máximo
1000 algarismos. Leia da entrada padrão.
Saída
Para cada caso de teste, deve ser impresso na saída o complemento um do número da entrada, em
uma linha, também em binário. Use a saída padrão.

5
1 0
10 01
11110000 00001111
00001111 11110000
10101010 01010101

Problema I – Seis é igual a 101?
Nome do arquivo fonte: soma.c ou soma.cpp ou soma.java ou soma.pas
Em uma galáxia muito distante, há muito tempo atrás, um povo bem feio e esquisito usava um
sistema de contagem tão esquisito quanto eles. O sistema deles era baseado em letras e frases. Cada
letra [a-z][A-Z] possui um valor a=1, A=2, b=3, B=4, c=5, C=6, d=7, D=8, e=9, E=10.... Para
representar um número qualquer eles utilizavam uma frase. Este número então seria a soma de todas
as letras que estivessem na frase. São exemplos: aba = 5, Aba = 6, Baba = 9.
Sua tarefa é dada uma frase determinar qual o valor dela. Você pode assumir que este valor sempre
pode ser representado por um inteiro de 32 bits.
Entrada
A entrada inicia-se com um inteiro 0 <= N <= 5000, informando o número de casos de testes que
seguem. A seguir seguem-se N linhas, onde cada linha contém uma frase de no máximo 1000
caracteres. Observe que não obrigatoriamente temos só letras na entrada, todos os outros caracteres
que não os representados acima, possuem valor zero. Leia da entrada padrão.
Saída
Para cada frase lida da entrada você deve imprimir um inteiro na saída informando o valor daquela
frase. Use a saída padrão.

4
aba 5
Aba 6
Baba 9
Aba e a Baba 25
Autores do Problema: Inácio Bouéres e Roberto Gerson, finalistas da Maratona de Programação da SBC
2006.

Problema J – Enfim, Lançamento de mísseis
Nome do arquivo fonte: misseis.c ou misseis.cpp ou misseis.java ou
misseis.pas
Um país gostaria de testar os mísseis que contém em seu arsenal, para
isso você é contratado para implementar um programa que simule o
lançamento desses mísseis.
No teste serão lançados N mísseis ao mesmo tempo em um ambiente
simulado 2D com um vento que exerce uma aceleração A sobre os
mísseis. Os mísseis são sempre lançados do solo. Cada um deles possui
uma posição inicial S, uma velocidade inicial V e o seu ângulo de
lançamento θ.
Sua tarefa é determinar, onde e quando os mísseis cairão.
Entrada
A entrada é dado pelo número de mísseis lançados (1 <= N <= 100), seguido pela aceleração que o vento
exerce sobre eles (-50 <= A <= 50) em m/s2 (se a aceleração é positiva ela leva o míssil para a direita se for
negativa para a esquerda), e então N linhas contendo a posição inicial (-1000 <= S <= 1000) em m, a
velocidade de lançamento (0 <= V <= 10000) em m/s e o ângulo (θ) em graus de cada míssil entre -1000 e
1000, inclusive. A entrada termina com (N = 0). Leia da entrada padrão.
Saída
Para cada caso de testes da entrada deve-se imprimir N linhas na saída. Cada linha deve ter o número do míssil
(de 1 a N, seqüencialmente, como dado na entrada), o local em metros onde ele caiu e o tempo em segundos
que ele levou para cair separado por espaços e com precisão de duas casas decimais (no exemplo: 3° míssil
do 2° caso de testes onde seria 5.19615 só é impresso 5.19). Deve-se imprimir uma linha em branco
depois de cada caso de teste. Use a saída padrão.
Dados Importante:
- Pode-se assumir que os mísseis não se interceptam.
- O ambiente não contem atrito;
- A aceleração da gravidade é de 10 m/s2;
- PI = 3,1415926535897932384626433832795;
- Para um Movimento Uniformemente Variado: s = s0 + v0*t + (a*t2)/2 e v = v0 +a*t

1 1 10.00 6.00
0
10 30 90 1 91.44 3.00
2 117.00 4.24
3 3 118.44 5.19
3
0 30 30
0 30 45
0 30 60
Autor do Problema: Inácio Bouéres, finalistas da Maratona de Programação da SBC 2006.

2007 Beneficente 1

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

2007 Beneficente 1

Hochgeladen von

Copyright:

Verfügbare Formate

II Maratona Beneficente de Programação

Beneficente UFMA 2007

Exemplo de entrada Respectiva saída

© Departamento de Informática, UFMA 1

Exemplo de entrada Respectiva saída

© Departamento de Informática, UFMA 2

Exemplo de entrada Respectiva saída

© Departamento de Informática, UFMA 3

© Departamento de Informática, UFMA 4

Exemplo de entrada Respectiva saída

Autor do Problema: Roberto Gerson, finalista da Maratona de Programação da SBC 2006.

© Departamento de Informática, UFMA 5

Exemplo de entrada Respectiva saída

© Departamento de Informática, UFMA 6

Exemplo de entrada Respectiva saída

© Departamento de Informática, UFMA 7

© Departamento de Informática, UFMA 8

© Departamento de Informática, UFMA 9

Exemplo de entrada Respectiva saída

© Departamento de Informática, UFMA 10

Exemplo de entrada Respectiva saída

© Departamento de Informática, UFMA 11

© Departamento de Informática, UFMA 12

Autor do Problema: Inácio Bouéres, finalistas da Maratona de Programação da SBC 2006.

© Departamento de Informática, UFMA 13

Das könnte Ihnen auch gefallen