Unnamed: 0 int64 0 3.55k | id stringlengths 1 13 | title stringlengths 2 50 | difficulty stringclasses 6 values | category stringclasses 15 values | text stringlengths 226 7.79k |
|---|---|---|---|---|---|
100 | 1100 | Movimentos do Cavalo | Médio | GRAFOS | Pedro está fazendo uma pesquisa sobre o problema do movimento do cavalo em um tabuleiro de xadrez e incumbiu você da tarefa de encontrar o menor conjunto de movimentos possíveis, podendo sair de qualquer quadrado a e podendo chegar em qualquer quadrado b dentro do tabuleiro, sendo que a e b são quadrados diferentes. Ele pensa que a parte mais difícil do problema é determinar o menor número de movimentos do cavalo entre 2 quadrados fornecidos e que uma vez que você está comprometido com esta tarefa, encontrar a sequência de movimentos entre estes 2 quadrados será uma tarefa muito fácil.
É claro que você sabe que o movimento é vice versa. Portanto você deve fornecer a Pedro um programa que resolva esta questão.
Seu trabalho então será escrever um programa que, pegando dois quadrados a e b como entrada, determine o número de movimentos para encontrar a rota mais curta de a até b.
Entrada
A entrada contém um ou mais casos de teste. Cada caso de teste consiste de uma linha contendo dois quadrados separados por um espaço. Um quadrado será uma string consistindo de uma letra (a-h) representando a coluna e um dígito (1-8) representando a linha do tabuleiro de xadrez (veja figura acima).
Saída
para cada caso de teste imprima uma linha dizendo "To get from xx to yy takes n knight moves.". No caso xx é a origem, yy é o destino e n é a quantidade de movimentos necessários para ir de xx até yy.
Exemplo de Entrada Exemplo de Saída
e2 e4
a1 b2
b2 c3
a1 h8
a1 h7
h8 a1
b1 c3
f6 f6
To get from e2 to e4 takes 2 knight moves.
To get from a1 to b2 takes 4 knight moves.
To get from b2 to c3 takes 2 knight moves.
To get from a1 to h8 takes 6 knight moves.
To get from a1 to h7 takes 5 knight moves.
To get from h8 to a1 takes 6 knight moves.
To get from b1 to c3 takes 1 knight moves.
To get from f6 to f6 takes 0 knight moves.
Entrada e saída por Neilor |
101 | 1101 | Sequência de Números e Soma | Fácil | INICIANTE | Leia um conjunto não determinado de pares de valores M e N (parar quando algum dos valores for menor ou igual a zero). Para cada par lido, mostre a sequência do menor até o maior e a soma dos inteiros consecutivos entre eles (incluindo o N e M).
Entrada
O arquivo de entrada contém um número não determinado de valores M e N. A última linha de entrada vai conter um número nulo ou negativo.
Saída
Para cada dupla de valores, imprima a sequência do menor até o maior e a soma deles, conforme exemplo abaixo.
Exemplo de Entrada Exemplo de Saída
5 2
6 3
5 0
2 3 4 5 Sum=14
3 4 5 6 Sum=18 |
102 | 1102 | Ataque Fulminante | Muito Difícil | GEOMETRIA COMPUTACIONAL | Desde que o Rei da Nlogônia construiu, décadas atrás, um enorme muro de proteção ao redor de todo o reino, os seus habitantes vivem em segurança. O muro é imponente, extremamente reforçado, e tem o formato de um círculo que envolve todos os domínios do Rei.
No entanto, há algumas semanas os habitantes da Nlogônia estão apreensivos. Há boatos de que cientistas da Quadradônia, um povo bárbaro que habita as vizinhanças da Nlogônia, desenvolveram uma arma mortal, capaz de pulverizar tudo que esteja em sua mirada.
A nova arma é um canhão que emite um feixe de prótons que se espalha com ângulo ø a partir da boca do canhão. A direção do tiro é indicada por um ângulo alpha, medido a partir do eixo x, no sentido anti-horário. A figura abaixo ilustra (a) um exemplo de ataque, (b) o que restaria da Nlogônia e (c) a área que seria destruída.
Dados a coordenada do canhão, a direção do tiro e o ângulo de espalhamento do feixe de prótons, bem como a coordenada do centro e o valor do raio do muro de proteção, você deve escrever um programa para calcular a área da Nlogônia que será destruída.
Entrada
A entrada contém vários casos de teste. Cada caso de teste é composto por duas linhas. A primeira linha contém três números inteiros X, Y , R, com (X, Y ) representando as coordenadas do centro do círculo do muro de proteção (0 ≤ X ≤ 1000 e 0 ≤ Y ≤ 1000), e R o seu raio (1≤R≤100). A segunda linha contém quatro números inteiros P , Q, A e T , com (P, Q) representando as coordenadas da localização do canhão (0≤P≤1000 e 0≤Q≤1000), A representando a direção, em graus, do tiro (0≤A≤359), e T representa o ângulo de espalhamento, também em graus (1≤T≤179). O ângulo A é medido a partir do eixo x no sentido anti-horário, e o canhão está sempre fora dos domínios da Nlogônia, ou seja, a distância entre (X, Y ) e (P, Q) é maior do que R.
O final da entrada é indicado por uma linha que contém três zeros separados por espaços em branco.
Saída
Para cada caso de teste da entrada seu programa deve imprimir uma única linha, contendo um número real, escrito com precisão de uma casa decimal, indicando a área da Nlogônia que seria destruída pelo ataque.
Sample Input Sample Output
1 1 1
3 1 180 90
4 4 3
8 4 90 90
4 4 3
8 4 180 179
0 0 0
3.1
0.2
28.3
Maratona de Programação da SBC 2009 |
103 | 1103 | Alarme Despertador | Fácil | AD-HOC | 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 H 1 , M 1 , H2 e M 2, 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.
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.
Sample Input Sample Output
1 5 3 5
23 59 0 34
21 33 21 10
0 0 0 0
120
35
1417 |
104 | 1104 | Troca de Cartas | Fácil | AD-HOC | Alice e Beatriz colecionam cartas de Pokémon. As cartas são produzidas para um jogo que reproduz a batalha introduzida em um dos mais bem sucedidos jogos de videogame da história, mas Alice e Beatriz são muito pequenas para jogar, e estão interessadas apenas nas cartas propriamente ditas. Para facilitar, vamos considerar que cada carta possui um identificador único, que é um número inteiro.
Cada uma das duas meninas possui um conjunto de cartas e, como a maioria das garotas de sua idade, gostam de trocar entre si as cartas que têm. Elas obviamente não têm interesse emtrocar cartas idênticas, que ambas possuem, e não querem receber cartas repetidas na troca.Além disso, as cartas serão trocadas em uma única operação de troca: Alice dá para Beatriz um sub-conjunto com N cartas distintas e recebe de volta um outro sub-conjunto com N cartas distintas.
As meninas querem saber qual é o número máximo de cartas que podem ser trocadas. Por exemplo, se Alice tem o conjunto de cartas {1, 1, 2, 3, 5, 7, 8, 8, 9, 15} e Beatriz o conjunto {2, 2, 2, 3, 4, 6, 10, 11, 11}, elas podem trocar entre si no máximo quatro cartas. Escreva um programa que, dados os conjuntos de cartas que Alice e Beatriz possuem, determine o número máximo de cartas que podem ser trocadas.
Entrada
A entrada contém vários casos de teste. A primeira linha de um caso de teste contém dois números inteiros A e B, separados por um espaço em branco, indicando respectivamente o número de cartas que Alice e Beatriz possuem (1 ≤ A ≤ 104 e 1 ≤ B ≤ 104). A segunda linha contém A números inteiros Xi, separados entre si por um espaço em branco, cada número indicando uma carta do conjunto de Alice (1 ≤ Xi ≤ 105). A terceira linha contém B números inteiros Yi, separados entre si por um espaço em branco, cada número indicando uma carta do conjunto de Beatriz (1 ≤ Yi ≤ 105). As cartas de Alice e Beatriz são apresentadas em ordem não decrescente.
O final da entrada é indicado por uma linha que contém apenas dois zeros, separados por um espaço em branco.
Saída
Para cada caso de teste da entrada seu programa deve imprimir uma única linha, contendo um numero inteiro, indicando o número máximo de cartas que Alice e Beatriz podem trocar entre si.
Sample Input Sample Output
1 1
1000
1000
3 4
1 3 5
2 4 6 8
10 9
1 1 2 3 5 7 8 8 9 15
2 2 2 3 4 6 10 11 11
0 0
0
3
4
Maratona de Programação da SBC 2009 |
105 | 1105 | Sub-prime | Médio | AD-HOC | A mais recente crise econômica foi em parte causada pela forma como os bancos faziam empréstimos para pessoas que não tinham capacidade de honrá-los e revendiam tais empréstimos para outros bancos (debêntures). Obviamente, quando as pessoas pararam de pagar os empréstimos, o sistema inteiro entrou em colapso.
A crise foi tão profunda que acabou atingindo países do mundo inteiro, inclusive a Nlogônia, onde o honrado primeiro ministro Man Dashuva ordenou que o presidente do Banco Central procurasse uma solução para o problema. Esse, por sua vez, teve uma idéia brilhante: se cada banco fosse capaz de liquidar seus empréstimos somente com suas reservas monetárias, todos os bancos sobreviveriam e a crise seria evitada. Entretanto, com o elevado número de debêntures e bancos envolvidos, essa tarefa é extremamente complicada, e portanto ele pediu a sua ajuda para escrever um programa que, dados os bancos e as debêntures emitidas, determine se é possível que todos os bancos paguem suas dívidas, utilizando suas reservas monetárias e seus créditos.
Entrada
A entrada contém vários casos de teste. A primeira linha de um caso de teste contém dois inteiros B e N, indicando respectivamente o número de bancos (1 ≤ B ≤ 20) e o número de debêntures emitidas pelos bancos (1 ≤ N ≤ 20). Os bancos são identificados por inteiros entre 1 e B. A segunda linha contém B inteiros Ri separados por espaços, indicando as reservas monetárias de cada um dos B bancos (0 ≤ Ri ≤ 104, para 1 ≤ i ≤ B). As N linhas seguintes contêm cada uma três inteiros separados por espaços: um inteiro D, indicando o banco devedor (1 ≤ D ≤ B), um inteiro C, indicando o banco credor (1 ≤ C ≤ B e D ≠ C), e um inteiro V, indicando o valor da debênture (1 ≤ V ≤ 104).
O final da entrada é indicado por uma linha que contém apenas dois zeros, separados por um espaço em branco.
Saída
Para caso de teste, seu programa deve imprimir uma única linha, contendo um único caractere: 'S', se for possível liquidar todos as debêntures sem intervenção do Banco Central da Nlogônia, e 'N', se algum banco precisar de empréstimos do governo para liquidar suas debêntures.
Exemplo de Entrada Exemplo de Saída
3 3
1 1 1
1 2 1
2 3 2
3 1 3
3 3
1 1 1
1 2 1
2 3 2
3 1 4
3 3
1 1 1
1 2 2
2 3 2
3 1 2
0 0
S
N
S
Maratona de Programação da SBC 2009 |
106 | 1106 | Dragster | Difícil | PARADIGMAS | Embora não seja uma modalidade muito popular no Brasil, as corridas de dragsters atraem multidões nos EUA. Os fãs gostam de ver os carros velozes correndo a velocidades de até 400 km/h, mesmo que só por alguns segundos. Muitos competidores são mecânicos amadores que apenas incluiram foguetes e outros artefatos para criarem carros ultra velozes. As competições de dragsters são disputadas em torneios de eliminação, onde cada disputa consiste de dois competidores correndo lado a lado e somente um deles sendo declarado o vencedor (o que chegar primeiro, claro). Os vencedores são então rearranjados em novas partidas, até que no final somente um competidor seja declarado o campeão.
Rubens é um piloto experiente, com carreira em diversas categorias, inclusive a Fórmula 1. Entretanto, após enfrentar alguns contratempos, resolveu dedicar-se a competições de dragsters.
Aproveitando-se da larga experiência que ganhou durante a Fórmula 1, ele consegue, observando os competidores, dizer qual a probabilidade de cada um dos competidores envolvidos ser o vencedor de uma dada disputa.
Embora Rubens seja bom piloto, não é muito bom em matemática nem em programação, e pediu a sua ajuda para, dadas as probabilidades calculadas por Rubens para a disputa entre cada par de pilotos, e a descrição das corridas do torneio, determinar a probabilidade que ele tem de vencer o torneio.
Entrada
A entrada é composta de vários casos de teste. A primeira linha de um caso de teste contém um inteiro N indicando o número de competidores do torneio (2≤N≤300). Na descrição do torneio, os competidores são identificados por inteiros de 1 a N, e as corridas são identificadas por inteiros de N + 1 a 2 × N - 1. Rubens é sempre identificado pelo número 1. As N linhas seguintes descrevem a matriz M de probabilidades calculada por Rubens. A linha i contém N números reais M[i, j] separados por espaços (0 ≤ M[i, j] ≤ 1, para 1 ≤ i ≤ N e 1 ≤ j ≤ N). Cada elemento M[i, j] da matriz indica a probabilidade de o competidor i vencer o confronto com o competidor j (0.001 ≤ M[i, j] ≤ 0.999 e M[i, j] + M[j, i] = 1 para i ≠ j , e M[i, j] = 0 para i = j).
As probabilidades serão sempre dadas com três casas decimais de precisão. Cada uma das N - 1 linhas seguintes contém dois inteiros A, B descrevendo uma corrida, sendo que A e B representam identificadores de competidores ou de corridas (1 ≤ A ≤ 2 x N - 1 e 1 ≤ B ≤ 2 x N - 1). Note que a primeira dessas linhas descreve a corrida identificada por N +1, a segunda linha descreve a corrida identificada por N +2 e assim por diante. Quando um identificador de corrida k aparece na entrada como A, isto significa que o competidor que venceu a corrida k é quem disputará a corrida contra B. Da mesma forma, quando um identificador de corrida k aparece na entrada como B, isto significa que o competidor que venceu a corrida k é quem disputará a corrida contra A.
O final da entrada é indicado por uma linha que contém apenas um número zero.
Saída
Para cada caso de teste da entrada seu programa deve imprimir uma única linha, contendo um número real, escrito com precisão de seis casas decimais, indicando a probabilidade de Rubens vencer o torneio.
Exemplo de Entrada Exemplo de Saída
4
0.000 0.500 0.400 0.400
0.500 0.000 0.500 0.500
0.600 0.500 0.000 0.600
0.600 0.500 0.400 0.000
1 2
3 4
5 6
5
0.000 0.500 0.600 0.600 0.001
0.500 0.000 0.500 0.500 0.500
0.400 0.500 0.000 0.500 0.500
0.400 0.500 0.500 0.000 0.500
0.999 0.500 0.500 0.500 0.000
3 8
9 6
4 5
1 2
0
0.200000
0.225125
Maratona de Programação da SBC 2009 |
107 | 1107 | Escultura à Laser | Fácil | AD-HOC | Desde a sua invenção, em 1958, os raios laser têm sido utilizados em uma imensa variedade de aplicações, como equipamentos eletrônicos, instrumentos cirúrgicos, armamentos, e muito mais.
A figura acima mostra um diagrama esquemático de um equipamento para esculpir, com laser, um bloco de material maciço. Na figura vemos um emissor laser que se desloca horizontalmente para a direita e para a esquerda com velocidade constante. Quando o emissor é ligado durante o deslocamento, uma camada de espessura constante é removida do bloco, sendo vaporizada pelo laser.
A figura abaixo ilustra o processo de escultura a laser, mostrando um exemplo de (a) um bloco, com 5 mm de altura por 8 mm de comprimento, no início do processo, (b) o formato que se deseja que o bloco esculpido tenha, e (c) a sequência de remoção das camadas do bloco durante o processo, considerando que a cada varredura uma camada de espessura de 1 mm é removida.
Na primeira varredura, o pedaço numerado como 1 é removido; na segunda varredura, o pedaço numerado como 2 é removido, e assim por diante. Durante o processo de remoção, o laser foi ligado um total de 7 vezes, uma vez para cada pedaço de bloco removido.
Escreva um programa que, dados a altura do bloco, o comprimento do bloco, e a forma final que o bloco deve ter, determine o número total vezes de que o laser deve ser ligado para esculpir o bloco.
Entrada
A entrada contém vários casos de teste. Cada caso de teste é composto por duas linhas. A primeira linha de um caso de teste contém dois números inteiros A e C, separados por um espaço em branco, indicando respectivamente a altura (1 ≤ A ≤ 104) e o comprimento (1 ≤ C ≤ 104) do bloco a ser esculpido, em milímetros. A segunda linha contém C números inteiros Xi, cada um indicando a altura final, em milímetros, do bloco entre as posições i e i + 1 ao longo do comprimento (0 ≤ Xi ≤ A, para 0 ≤ i ≤ C - 1). Considere que a cada varredura uma camada de espessura 1 milímetro é removida do bloco ao longo dos pontos onde o laser está ligado.
O final da entrada é indicado por uma linha que contém apenas dois zeros, separados por um espaço em branco.
Saída
Para cada caso de teste da entrada seu programa deve imprimir uma única linha, contendo um número inteiro, indicando o número de vezes que o laser deve ser ligado para esculpir o bloco na forma indicada.
Exemplo de Entrada Exemplo de Saída
5 8
1 2 3 2 0 3 4 5
3 3
1 0 2
4 3
4 4 1
0 0
7
3
3
Maratona de Programação da SBC 2009 |
108 | 1108 | Torres de Telefonia Celular | Muito Difícil | GEOMETRIA COMPUTACIONAL | Uma nova operadora de telefonia pretende oferecer serviços de telefone residencial em sua cidade. Os telefones serão residenciais, mas a operadora vai utilizar tecnologia de telefonia celular, com torres de transmissão, para evitar os gastos de construir uma rede de cabos por toda a cidade. A potência do transmissor/receptor colocado em uma torre define o raio de cobertura da torre (que por sua vez define a área de cobertura do equipamento, que é um círculo, já que a cidade é perfeitamente plana). O custo do equipamento instalado em cada torre depende de sua potência, e portanto de seu raio de cobertura. A operadora decidiu que utilizará exatamente duas torres na cidade.
O mesmo tipo de equipamento será instalado nas duas torres, ou seja, as duas torres terão o mesmo raio de cobertura. Como a operadora quer poder oferecer o seu serviço para todas as residências, a área de cobertura das duas torres em conjunto deve englobar todas as resid^encias da cidade. Adicionalmente, o raio de cobertura das duas torres deve ser o menor possível, para miniminar o custo dos equipamentos. A figura abaixo mostra duas possíveis configurações de cobertura das duas torres para uma cidade com dez residências. Tanto (a) quanto (b) oferecem cobertura a todas as residências da cidade, mas (b) é a que utiliza o menor raio de cobertura possível.
Dada a localização de cada residência na cidade, você deve escrever um programa para calcular o menor raio de cobertura das torres, de forma a garantir que todas as residências sejam cobertas.
Entrada
A entrada contém vários casos de teste. A primeira linha de um caso de teste contém um número inteiro N, o número de residências da cidade (3 ≤ N ≤ 40). Cada uma das N linhas seguintes contém dois inteiros X e Y , separados por um espaço em branco (0 ≤ X ≤ 104 e 0 ≤ Y ≤ 104), representando a coordenada de uma residência. Cada residência tem uma localização diferente.
O final da entrada é indicado por uma linha que contém apenas um zero.
Saída
Para cada caso de teste da entrada seu programa deve imprimir uma única linha, contendo um número real, escrito com precisão de duas casas decimais, indicando o raio de cobertura do equipamento a ser utilizado nas duas torres.
O resultado de seu programa deve ser escrito na saída padrão.
Exemplo de Entrada Exemplo de Saída
3
0 0
1 0
0 4
10
0 0
0 3
1 6
2 2
3 5
5 3
6 3
9 5
10 5
11 3
0
0.50
3.05
Maratona de Programação da SBC 2009
Conversão HTML e ajustes by Neilor Tonin |
109 | 1109 | Burlando a Maratona | Muito Difícil | AD-HOC | Pela primeira vez a Escola Livre de Matemática, Filosofia e Lingüística de Skyrim vai receber a Maratona de Expressões Regulares (regex) (RegExCon). A maratona acontece da seguinte forma: os participantes competem sempre contra 1 oponente. Um ganha um perde. No final, só o campeão restará. Em uma disputa os participantes recebem uma lista com várias expressões regulares e para cada uma os participantes devem calcular se várias palavras dadas são reconhecidas ou não por tal regex.
Como membro da Escola Livre você está participando, e quer ganhar. Para garantir sua vitória, você deve escrever um programa para resolver o problema e deixá-lo rodando na sua Máquina Calculadora de Coisas Legais em casa. Como um mago, especialista em Alteração e Ilusão, você pode facilmente controlar sua máquina com a mente, então você consegue usar o programa durante a maratona. É proibido utilizar magia na maratona, mas coincidentemente a Escola de Winterhold vai sediar um Congresso de Magos, então você não precisa se preocupar, use sua magia.
Uma expressão regular é utilizada para descrever uma linguagem (um conjunto de palavras). Considere que o alfabeto de todas linguagens neste problema é {a, b}.
Uma regex R é válida se:
1) R é “a” ou “b”;
2) R é “(P.S)” onde P e S são expressões regulares;
3) R é “(P|S)” onde P e S são expressões regulares;
4) R é “(P*)” onde P é uma expressão regular.
Expressões regulares podem ser aninhadas. Não há operação ternária com os operadores “.” e “|”, nem operação binária com o operator “*”. Palavras sempre comçam com “(“ e terminam com “)”. O conjunto L de palavras reconhecidas por R é formado seguindo estas regras:
1) Se R é “(a)”, L = {a};
2) Se R é “(b)”, L = {b};
3) Se R é “(P.S)”, L = todas palavras que podem ser obtidas a partir da concatenação das palavras p e s, onde p é reconhecida por P e s por S;
4) Se R é “(P|S)”, L = união dos conjuntos de palavras reconhecidas por P e S;
5) Se R é “(P*)”, R reconhece a concatenação de 0 ou mais palavras reconhecidas por P.
Entrada
A entrada é formada por vários casos de teste. A primira linha de um caso de teste contém uma regex (0 < tamanho da regex < 150). A próxima linha contém um inteiro P (1 ≤ P ≤ 100). Cada uma das próximas P linhas contém uma palavra (tamanho < 50) formada por 'a's e 'b's que representa a seguinte questão: “Esta palavra é reconhecida pela regex dada?”.
Saída
Para cada questão descrita anteriormente, responda “Y” (sem aspas) se a resposta é “sim” ou “N” (sem aspas) se a resposta é “não”. Imprima uma linha em branco após cada caso de teste, inclusive após o último.
Exemplo de Entrada Exemplo de Saída
(a)
3
a
b
aa
(a.b)
3
a
ab
b
(a|b)
4
a
b
ab
ba
(a*)
3
a
aaaaaaaaaaa
aaaaabaaaaa
((a*).(b*))
3
bbbaaa
aaabbb
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
Y
N
N
N
Y
N
Y
Y
N
N
Y
Y
N
N
Y
Y
|
110 | 1110 | Jogando Cartas Fora | Fácil | ESTRUTURAS E BIBLIOTECAS | Dada uma pilha de n cartas enumeradas de 1 até n com a carta 1 no topo e a carta n na base.
A seguinte operação é ralizada enquanto tiver 2 ou mais cartas na pilha.
Jogue fora a carta do topo e mova a próxima carta (a que ficou no topo) para a base da pilha.
Sua tarefa é encontrar a sequência de cartas descartadas e a última carta remanescente.
Cada linha de entrada (com exceção da última) contém um número n ≤ 50. A última linha contém 0 e não deve ser processada. Cada número de entrada produz duas linhas de saída. A primeira linha apresenta a sequência de cartas descartadas e a segunda linha apresenta a carta remanescente.
Entrada
A entrada consiste em um número indeterminado de linhas contendo cada uma um valor de 1 até 50. A última linha contém o valor 0.
Saída
Para cada caso de teste, imprima duas linhas. A primeira linha apresenta a sequência de cartas descartadas, cada uma delas separadas por uma vírgula e um espaço. A segunda linha apresenta o número da carta que restou. Nenhuma linha tem espaços extras no início ou no final. Veja exemplo para conferir o formato esperado.
Exemplo de Entrada Exemplo de Saída
7
19
10
6
0
Discarded cards: 1, 3, 5, 7, 4, 2
Remaining card: 6
Discarded cards: 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 4, 8, 12, 16, 2, 10, 18, 14
Remaining card: 6
Discarded cards: 1, 3, 5, 7, 9, 2, 6, 10, 8
Remaining card: 4
Discarded cards: 1, 3, 5, 2, 6
Remaining card: 4
Adaptação, entradas e saídas by Neilor Tonin |
111 | 1111 | Desrugenstein | Difícil | GRAFOS | A cidade de Desrugenstein é uma bagunça completa. Olhando para o mapa ela parece organizada, já que foi criada na forma de uma grade quadrada, mas não há padrões de direções. Cada esquina diz para onde você pode ir a partir de lá (norte, sul, leste, oeste). O prefeito Daniel Cobra é cabeça-dura e preguiçoso o suficiente para deixar tudo como está e proibir qualquer tentativa de mudança. Incapaz de fazer muito, o Conselheiro Espiritual Mestre de Desrugenstein, Giordano Marfyn, te pediu, Conselheiro Espiritual Nível XVII de Desrugenstein, programador-chefe de Desrugenstein, para escrever um programa para calcular o custo de ir de uma esquina (x, y) a outra esquina (z, w), considerando as ruas bagunçadas.
Entrada
O arquivo de entrada possui vários casos de teste. A primeira linha de cada caso de teste contém um inteiro N (1 ≤ N ≤ 10) que representa altura e largura da grade quadrada que mapeia a cidade (uma grade N x N). A entrada termina quando N = 0, caso que não deve ser processado. Cada uma das próximas N linhas representa uma rua da cidade, começando da mais ao norte (N – 1) até a mais ao sul. Em cada uma destas linhas há 4*N inteiros, 4 para cada esquina: A (norte) B (sul) C (oeste) D (leste). Cada um é 0 se não é possível seguir na respectiva direção a partir daquela esquina, ou 1 se é possível.
Depois do mapa da cidade, seu programa deve ler um inteiro P (1 ≤ P ≤ 100). As próximas P linhas contém 4 inteiros cada, x0 y0 x1 y1 representando a questão: “Qual o custo mínimo de ir da esquina (x0 , y0) até a esquina (x1 , y1)?”. O custo de ir de uma esquina para a esquina mais próxima em qualquer direção é 1.
Saída
Para cada questão, responda “Impossible”, se não existe um caminho válido entre as esquinas (respeitando as regras de direções para esquinas), ou o custo mínimo, se há caminho(s). Imprima uma linha em branco após cada caso de teste.
Exemplo de Entrada Exemplo de Saída
4
0 1 0 1 0 0 1 0 0 0 0 1 0 1 0 0
0 0 0 0 1 0 0 1 0 0 0 1 0 1 0 0
1 0 0 0 1 0 1 0 1 1 0 0 0 1 1 0
0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0
5
1 3 0 3
2 3 3 0
2 3 0 0
3 1 3 2
0 3 0 0
0
1
4
7
3
Impossible |
112 | 1112 | Schweisen | Muito Difícil | ESTRUTURAS E BIBLIOTECAS | Conan é um importante membro do Clube Atlético de Desrugenstein, que possui um time de futebol de campo profissional: ele é o responsável pelo gramado do campo onde ocorrem os jogos em casa. Em 2048 anos de história, o campo do CAD sempre esteve em perfeitas condições para os jogos, graças a Conan. Ele já ganhou vários prêmios por isso, sendo o mais importante deles o "Grama de Ouro", prêmio que ganhou 1024 vezes.
Amanhã acontecerá a final do campeonato Universal de futebol, e o CAD é um dos finalistas. Como o jogo será em casa, Conan foi ver o estado do gramado e reparar se necessário. Chegando lá, entrou em desespero ao ver várias schweisen no campo, estragando todo o gramado!!
Sendo assim, Conan precisa de sua ajuda para determinar quanto irá gastar com deswevileutssen para matar todas as schweisen. Cada deswevileutssen mata uma schwisen. Conan pode lhe mandar mensagens de dois tipos: dizendo que encontrou algumas schweisen, ou perguntando quanto ele vai gastar para matar certas schweisen.
Entrada
A entrada possui vários casos de teste. A primeira linha de um caso de teste contém 3 inteiros X (≤ 1000), Y (≤ 1000) e P (≤ 10), que representam, respectivamente, o tamanho (X e Y) do campo e o preço de cada deswevileutssen. A próxima linha contém um inteiro Q (≤ 10000). As próximas Q linhas representam mensagens de Conan para você, e estão em uma das duas seguintes formas:
- A N X Y - “Achei N (≤ 10) schweisen em (X,Y) - (0 ≤ X < Largura), (0 ≤ Y < Altura)”
- P X Y Z W - “Quanto vou gastar para matar todas as schweisen na área retangular de (X,Y) até (Z,W)?”
Considere que no início nenhuma schweisen foi vista.
A entrada termina quando X, Y e P são iguais a 0.
Saída
Para cada mensagem do tipo "P", imprima o valor que responde a pergunta feita. Deixe uma linha em branco após cada caso de teste, inclusive após o último.
Exemplo de Entrada Exemplo de Saída
2 2 10
7
A 5 1 1
A 9 1 0
A 2 0 0
P 1 0 1 1
A 4 0 1
A 7 1 0
P 0 1 1 0
0 0 0
140
270 |
113 | 1113 | Crescente e Decrescente | Muito Fácil | INICIANTE | Leia uma quantidade indeterminada de duplas de valores inteiros X e Y. Escreva para cada X e Y uma mensagem que indique se estes valores foram digitados em ordem crescente ou decrescente.
Entrada
A entrada contém vários casos de teste. Cada caso contém dois valores inteiros X e Y. A leitura deve ser encerrada ao ser fornecido valores iguais para X e Y.
Saída
Para cada caso de teste imprima “Crescente”, caso os valores tenham sido digitados na ordem crescente, caso contrário imprima a mensagem “Decrescente”.
Exemplo de Entrada Exemplo de Saída
5 4
7 2
3 8
2 2
Decrescente
Decrescente
Crescente
Formatação e inserção no portal por Cássio Favaretto. |
114 | 1114 | Senha Fixa | Muito Fácil | INICIANTE | Escreva um programa que repita a leitura de uma senha até que ela seja válida. Para cada leitura de senha incorreta informada, escrever a mensagem "Senha Invalida". Quando a senha for informada corretamente deve ser impressa a mensagem "Acesso Permitido" e o algoritmo encerrado. Considere que a senha correta é o valor 2002.
Entrada
A entrada é composta por vários casos de testes contendo valores inteiros.
Saída
Para cada valor lido mostre a mensagem correspondente à descrição do problema.
Exemplo de Entrada Exemplo de Saída
2200
1020
2022
2002
Senha Invalida
Senha Invalida
Senha Invalida
Acesso Permitido
Formatação e inserção no portal por Cássio Favaretto. |
115 | 1115 | Quadrante | Muito Fácil | INICIANTE | Escreva um programa para ler as coordenadas (X,Y) de uma quantidade indeterminada de pontos no sistema cartesiano. Para cada ponto escrever o quadrante a que ele pertence. O algoritmo será encerrado quando pelo menos uma de duas coordenadas for NULA (nesta situação sem escrever mensagem alguma).
Entrada
A entrada contém vários casos de teste. Cada caso de teste contém 2 valores inteiros.
Saída
Para cada caso de teste mostre em qual quadrante do sistema cartesiano se encontra a coordenada lida, conforme o exemplo.
Exemplo de Entrada Exemplo de Saída
2 2
3 -2
-8 -1
-7 1
0 2
primeiro
quarto
terceiro
segundo
Formatação e inserção no portal por Cássio Favaretto. |
116 | 1116 | Dividindo X por Y | Muito Fácil | INICIANTE | Escreva um algoritmo que leia 2 números e imprima o resultado da divisão do primeiro pelo segundo. Caso não for possível mostre a mensagem “divisao impossivel” para os valores em questão.
Entrada
A entrada contém um número inteiro N. Este N será a quantidade de pares de valores inteiros (X e Y) que serão lidos em seguida.
Saída
Para cada caso mostre o resultado da divisão com um dígito após o ponto decimal, ou “divisao impossivel” caso não seja possível efetuar o cálculo.
Obs.: Cuide que a divisão entre dois inteiros em algumas linguagens como o C e C++ gera outro inteiro. Utilize cast :)
Exemplo de Entrada Exemplo de Saída
3
3 -2
-8 0
0 8
-1.5
divisao impossivel
0.0
Formatado por Cássio Favaretto. |
117 | 1117 | Validação de Nota | Muito Fácil | INICIANTE | Faça um programa que leia as notas referentes às duas avaliações de um aluno. Calcule e imprima a média semestral. Faça com que o algoritmo só aceite notas válidas (uma nota válida deve pertencer ao intervalo [0,10]). Cada nota deve ser validada separadamente.
Entrada
A entrada contém vários valores reais, positivos ou negativos. O programa deve ser encerrado quando forem lidas duas notas válidas.
Saída
Se uma nota inválida for lida, deve ser impressa a mensagem "nota invalida".
Quando duas notas válidas forem lidas, deve ser impressa a mensagem "media = " seguido do valor do cálculo. O valor deve ser apresentado com duas casas após o ponto decimal.
Exemplo de Entrada Exemplo de Saída
-3.5
3.5
11.0
10.0
nota invalida
nota invalida
media = 6.75
Agradecimentos a Cássio F. |
118 | 1118 | Várias Notas Com Validação | Fácil | INICIANTE | Escreva um programa para ler as notas da primeira e a segunda avaliação de um aluno. Calcule e imprima a média semestral. O programa só deverá aceitar notas válidas (uma nota válida deve pertencer ao intervalo [0,10]). Cada nota deve ser validada separadamente.
No final deve ser impressa a mensagem “novo calculo (1-sim 2-nao)”, solicitando ao usuário que informe um código (1 ou 2) indicando se ele deseja ou não executar o algoritmo novamente, (aceitar apenas os código 1 ou 2). Se for informado o código 1 deve ser repetida a execução de todo o programa para permitir um novo cálculo, caso contrário o programa deve ser encerrado.
Entrada
O arquivo de entrada contém vários valores reais, positivos ou negativos. Quando forem lidas duas notas válidas, deve ser lido um valor inteiro X . O programa deve parar quando o valor lido para este X for igual a 2.
Saída
Se uma nota inválida for lida, deve ser impressa a mensagem “nota invalida”. Quando duas notas válidas forem lidas, deve ser impressa a mensagem “media = ” seguido do valor do cálculo.
Antes da leitura de X deve ser impressa a mensagem "novo calculo (1-sim 2-nao)" e esta mensagem deve ser apresentada novamente se o valor da entrada padrão para X for menor do que 1 ou maior do que 2, conforme o exemplo abaixo.
A média deve ser impressa com dois dígitos após o ponto decimal.
Exemplo de Entrada Exemplo de Saída
-3.5
3.5
11.0
10.0
4
1
8.0
9.0
2
nota invalida
nota invalida
media = 6.75
novo calculo (1-sim 2-nao)
novo calculo (1-sim 2-nao)
media = 8.50
novo calculo (1-sim 2-nao)
Agradecimentos a Cássio F. |
119 | 1119 | A Fila de Desempregados | Fácil | ESTRUTURAS E BIBLIOTECAS | Em uma séria tentativa de reduzir a fila de desempregados, o novo Partido Nacional Trabalhista dos Rinocerontes Verdes decidiu uma estratégia pública. Todos os dias, todos os candidatos desempregados serão colocados em um grande círculo, voltados para dentro. Alguém é escolhido arbitrariamente como número 1, e os outros são numerados no sentido horário até N (os quais estarão à esquerda do 1°). Partindo do 1° e movendo-se no sentido horário, um contador oficial do laboratório conta k posições e retira um candidato, enquanto outro oficial começa a partir de N e se move no sentido anti-horário, contando m posições e retirando outro candidato. Os dois que são escolhidos são então enviados como estagiários para a reciclagem e se ambos os funcionários escolherem a mesma pessoa, ela (ele) é enviado para se tornar um político. Cada funcionário, em seguida, começa a contar novamente com a pessoa próxima disponível e o processo continua até que não reste ninguém. Note-se que as duas vítimas (desculpe, estagiários) deixam o anel ao mesmo tempo, por isso é possível que um funcionário conte a pessoa já selecionado pelo outro funcionário.
Entrada
Escreva um programa que leia sucessivamente três números (N, k e m; k, m > 0, 0 < N < 20) e determina a ordem no qual os candidatos são retirados para treinamento . Cada conjunto de três números estará em uma linha distinta e o final da entrada de dados é sinalizado por três zeros (0 0 0).
Saída
Para cada conjunto de três números de entrada, imprima uma linha de números especificando a ordem na qual as pessoas são escolhidas. Cada número pode ter até 3 dígitos. Liste o par escolhido partindo da pessoa escolhida pelo contador do sentido horário. Os pares sucessivos são separados por vírgula (mas não deverá haver vírgula após o último escolhido).
Exemplo de Entrada Exemplo de Saída
10 4 3
0 0 0
4 8, 9 5, 3 1, 2 6, 10, 7
onde representa um espaço. |
120 | 1120 | Revisão de Contrato | Médio | STRINGS | Durante anos, todos os contratos da Associação de Contratos da Modernolândia (ACM) foram datilografados em uma velha máquina de datilografia.
Recentemente Sr. Miranda, um dos contadores da ACM, percebeu que a máquina apresentava falha em um, e apenas um, dos dígitos numéricos. Mais especificamente, o dígito falho, quando datilografado, não é impresso na folha, como se a tecla correspondente não tivesse sido pressionada. Ele percebeu que isso poderia ter alterado os valores numéricos representados nos contratos e, preocupado com a contabilidade, quer saber, a partir dos valores originais negociados nos contratos, que ele mantinha em anotações manuscritas, quais os valores de fato representados nos contratos. Por exemplo, se a máquina apresenta falha no dígito 5, o valor 1500 seria datilografado no contrato como 100, pois o 5 não seria impresso. Note que o Sr. Miranda quer saber o valor numérico representado no contrato, ou seja, nessa mesma máquina, o número 5000 corresponde ao valor numérico 0, e não 000 (como ele de fato aparece impresso).
Entrada
A entrada consiste de diversos casos de teste, cada um em uma linha. Cada linha contém dois inteiros D e N (1 ≤ D ≤ 9, 1 ≤ N < 10100 ), representando, respectivamente, o dígito que está apresentando problema na máquina e o número que foi negociado originalmente no contrato (que podem ser grande, pois Modernolândia tem sido acometida por hiperinflação nas últimas décadas).
O ultimo caso de teste é seguido por uma linha que contém apenas dois zeros separados por espaços em branco.
Saída
Para cada caso de teste da entrada o seu programa deve imprimir uma linha contendo um único inteiro V, o valor numérico representado de fato no contrato.
Exemplo de Entrada Exemplo de Saída
5 5000000
3 123456
9 23454324543423
9 99999999991999999
7 777
0 0
0
12456
23454324543423
1
0
Maratona de Programação da SBC 2010 |
121 | 1121 | Robô Colecionador | Fácil | AD-HOC | Um dos esportes favoritos na Robolândia é o Rali dos Robôs. Este rali é praticado em uma arena retangular gigante de N linhas por M colunas de células quadradas. Algumas das células estão vazias, algumas contêm figurinhas da Copa (muito apreciadas pelas inteligências artificiais da Robolândia) e algumas são ocupadas por pilastras que sustentam o teto da arena. Em seu percurso os robôs podem ocupar qualquer célula da arena, exceto as que contém pilastras, que bloqueiam o seu movimento. O percurso do robô na arena durante o rali é determinado por uma sequência de instruções. Cada instrução é representada por um dos seguintes caracteres: ‘D’, ‘E’ e ‘F’, significando, respectivamente, “gire 90 graus para a direita”, “gire 90 graus para a esquerda” e “ande uma célula para a frente”. O robô começa o rali em uma posição inicial na arena e segue fielmente a sequência de instruções dada (afinal, eles são robôs!). Sempre que o robô ocupa uma célula que contém uma figurinha da Copa ele a coleta. As figurinhas da Copa não são repostas, ou seja, cada figurinha pode ser coletada uma unica vez. Quando um robô tenta andar para uma célula onde existe uma pilastra ele patina, permanecendo na célula onde estava, com a mesma orientação. O mesmo também acontece quando um robô tenta sair da arena.
Dados o mapa da arena, descrevendo a posição de pilastras e figurinhas, e a sequência de instruções de um robô, você deve escrever um programa para determinar o número de figurinhas coletadas pelo robô.
Entrada
A entrada contém vários casos de teste. A primeira linha de um caso de teste contém três números inteiros N, M e S (1 ≤ N, M ≤ 100, 1 ≤ S ≤ 5 × 104 ), separados por espaços em branco, indicando respectivamente o número de linhas e o número de colunas da arena e o número de instruções para o robô. Cada uma das N linhas seguintes da entrada descreve uma linha de células da arena e contém uma cadeia com M caracteres. A primeira linha que aparece na descrição da arena é a que está mais ao Norte; a primeira coluna que aparece na descrição de uma linha de células da arena é a que está mais a Oeste.
Cada célula da arena pode conter um dos seguintes caracteres:
‘.’ — célula normal;
‘*’ — célula que contém uma figurinha da Copa;
‘#’ — célula que contém uma pilastra;
‘N’, ‘S’, ‘L’, ‘O’ — célula onde o robô inicia o percurso (única na arena). A letra representa a orientação inicial do robô (Norte, Sul, Leste e Oeste, respectivamente).
A ultima linha da entrada contém uma sequência de S caracteres dentre ‘D’, ‘E’ e ‘F’, representando as instruções do robô.
O último caso de teste é seguido por uma linha que contém apenas três números zero separados por um espaço em branco.
Saída
Para cada rali descrito na entrada seu programa deve imprimir uma única linha contendo um único inteiro, indicando o número de figurinhas que o robô colecionou durante o rali.
Exemplo de Entrada Exemplo de Saída
3 3 2
***
*N*
***
DE
4 4 5
...#
*#O.
*.*.
*.#.
FFEFF
10 10 20
....*.....
.......*..
.....*....
..*.#.....
...#N.*..*
...*......
..........
..........
..........
..........
FDFFFFFFEEFFFFFFEFDF
0 0 0
0
1
3
Maratona de Programação da SBC 2010 |
122 | 1122 | Livro-Caixa | Difícil | AD-HOC | A FCC (Fundação de Combate à Corrupção) desmontou um grande esquema de corrupção na Nlogônia. Durante a operação, foram apreendidos diversos cadernos e livros com anotações documentando as transações ilícitas realizadas pelo esquema.
Vários desses livros contém páginas com os valores de várias transações em nilogos (a moeda local da Nlogônia, cujo símbolo é N$) e o fluxo de caixa resultante dessas transações. Por exemplo, se em uma página foi registrada uma entrada de N$ 7, uma entrada de N$ 2, uma saída de N$ 3, uma entrada de N$ 1 e outra saída de N$ 11, o fluxo de caixa nesta página é 7 + 2 − 3 + 1 − 11 = −4.
No entanto, para dificultar o trabalho da polícia, os contraventores não anotaram em seus livros qual o tipo de cada transação. No exemplo acima, as anotaçõs na página seriam apenas 7, 2, 3, 1 e 11 (sem indicação se elas são entradas ou saídas). O fluxo de caixa de cada página sempre é anotado normalmente, com o sinal (no caso, -4).
Para obter a condenação dos contraventores, os promotores precisam poder afirmar com certeza se cada operação foi uma entrada ou uma saída. No exemplo acima, a transação de N$ 7 certamente foi uma entrada, e a transação de N$ 11 certamente foi uma saída. Mas, não se pode afirmar nada sobre as transações de N$ 2, N$ 3, e N$ 1. As transações de N$ 2 e N$ 1 poderiam ter sido entradas e a transação de N$ 3 uma saída, ou N$ 2 e N$ 1 poderiam ter sido saídas e a transação de N$ 3 uma entrada.
Muitos cadernos possuem números relativamente grandes, com muitas transações, então é difícil para a polícia reconstruir o histórico de operações. Por isso, eles precisam de um programa que o faça de forma eficiente.
Entrada
A entrada consiste de vários casos de teste. A primeira linha da entrada contém dois inteiros N e F, indicando respectivamente o número de operações na página (2 ≤ N ≤ 40) e o fluxo de caixa para esta página (−16000 ≤ F ≤ 16000). Cada uma das N linhas seguintes contém um inteiro Ti indicando o valor da i-ésima transação (1 ≤ Ti ≤ 1000).
O ultimo caso de teste é seguido por uma linha que contém apenas dois zeros separados por espaços em branco.
Saída
Para cada caso de teste da entrada seu programa deve imprimir uma única linha com N caracteres. O i-ésimo caractere deve ser ‘+’, se for possível afirmar com certeza que a i-ésima operação foi uma entrada, ‘-’, se for possível afirmar com certeza que a i-ésima operação foi uma saída, e ‘?’, se não for possível determinar com certeza qual o tipo da operação.
Caso não exista uma sequência de entradas e saídas que totalize o fluxo de caixa indicado, imprima uma única linha contendo o caractere ‘*’.
Exemplo de Entrada Exemplo de Saída
5 7
1
2
3
4
5
4 15
3
5
7
11
5 12
6
7
7
1
7
0 0
?+??+
*
+??-?
Maratona de Programação da SBC 2010 |
123 | 1123 | Desvio de Rota | Fácil | GRAFOS | O sistema rodoviário de um país interliga todas as suas N cidades de modo que, a partir de uma cidade qualquer, é possível chegar a cada uma das outras cidades trafegando pelas estradas existentes. Cada estrada liga duas cidades distintas, tem mão dupla e um único posto de pedágio (o pedágio é pago nos dois sentidos de tráfego). As estradas não se intersectam a não ser nas cidades. Nenhum par de cidades é interligado por duas ou mais estradas.
A Transportadora Dias oferece um serviço de transporte de encomendas entre as cidades. Cada encomenda deve ser levada de uma cidade A para uma outra cidade B. A direção da Transportadora Dias define, para cada encomenda, uma rota de serviço, composta por C cidades e C−1 estradas: a primeira cidade da rota de serviço é a origem da encomenda, a última o destino da encomenda. A rota de serviço não passa duas vezes pela mesma cidade, e o veículo escolhido para fazer o transporte de uma encomenda pode trafegar apenas pela rota de serviço definida.
Certo dia, no entanto, o veículo que executava uma entrega quebrou e precisou ser levado para conserto em uma cidade que não está entre as cidades de sua rota de serviço. A direção da Transportadora Dias quer saber qual é o menor custo total, em termos de pedágio, para que o veículo entregue a encomenda na cidade destino, a partir da cidade em que foi consertado, mas com uma restrição adicional: se em algum momento o veículo passar por uma das cidades que compõem a sua rota de serviço, ele deve voltar a obedecer a rota de serviço.
Entrada
A entrada contém vários casos de teste. A primeira linha de um caso de teste contém quatro inteiros N, M, C e K (4 ≤ N ≤ 250, 3 ≤ M ≤ N×(N−1)/2, 2 ≤ C ≤ N−1 e C ≤ K ≤ N−1), representando, respectivamente, o número de cidades do país, o número de estradas, o número de cidades na rota de serviço e a cidade em que o veículo foi consertado. As cidades são identificadas por inteiros de 0 a N−1. A rota de serviço é 0, 1, ... , C−1, ou seja, a origem é 0, de 0 passa para 1, de 1 para 2 e assim por diante, até o destino C−1.
As M linhas seguintes descrevem o sistema rodoviário do país. Cada uma dessas linhas descreve uma estrada e contém três inteiros U, V e P (0 ≤ U, V ≤ N−1, U ≠ V, 0 ≤ P ≤ 250), indicando que há uma estrada interligando as cidades U e V com custo de pedágio P. O último caso de teste é seguido por uma linha contendo quatro zeros separados por espaço em branco.
Saída
Para cada caso de teste, o seu programa deve imprimir uma única linha, contendo um único inteiro T, o custo total mínimo necessário, em termos de pedágio, para que o veículo chegue ao destino.
Exemplo de Entrada Exemplo de Saída
4 6 3 3
0 1 10
1 2 10
0 2 1
3 0 1
3 1 10
3 2 10
6 7 2 5
5 2 1
2 1 10
1 0 1
3 0 2
3 4 2
3 5 3
5 4 2
5 5 2 4
0 1 1
1 2 2
2 3 3
3 4 4
4 0 5
0 0 0 0
10
6
6
Maratona de Programação da SBC 2010 |
124 | 1124 | Elevador | Difícil | GEOMETRIA COMPUTACIONAL | A FCC (Fábrica de Cilindros de Carbono) fabrica vários tipos de cilindros de carbono. A FCC está instalada no décimo andar de um prédio, e utiliza os vários elevadores do prédio para transportar os cilindros. Por questão de segurança, os cilindros devem ser transportados na posição vertical; como são pesados, no máximo dois cilindros podem ser transportados em uma única viagem de elevador. Os elevadores têm formato de paralelepípedo e sempre têm altura maior que a altura dos cilindros.
Para minimizar o número de viagens de elevador para transportar os cilindros, a FCC quer, sempre que possível, colocar dois cilindros no elevador. A figura abaixo ilustra, esquematicamente (vista superior), um caso em que isto é possível (a), e um caso em que isto não é possível (b):
Como existe uma quantidade muito grande de elevadores e de tipos de cilindros, a FCC quer que você escreva um programa que, dadas as dimensões do elevador e dos dois cilindros, determine se é possível colocar os dois cilindros no elevador.
Entrada
A entrada contém vários casos de teste. A primeira e única linha de cada caso de teste contém quatro números inteiros L, C, R1 e R2, separados por espaços em branco, indicando respectivamente a largura do elevador (1 ≤ L ≤ 100), o comprimento do elevador (1 ≤ C ≤ 100), e os raios dos cilindros (1 ≤ R1, R2 ≤ 100).
O último caso de teste é seguido por uma linha que contém quatro zeros separados por espaços em branco.
Saída
Para cada caso de teste, o seu programa deve imprimir uma única linha com um único caractere: ‘S’ se for possível colocar os dois cilindros no elevador e ‘N’ caso contrário.
Exemplo de Entrada Exemplo de Saída
11 9 2 3
7 8 3 2
10 15 3 7
8 9 3 2
0 0 0 0
S
N
N
S
Maratona de Programação da SBC 2010 |
125 | 1125 | Fórmula 1 | Fácil | AD-HOC | A temporada de Fórmula 1 consiste de uma série de corridas, conhecidas como Grandes Prêmios, organizados pela Federação Internacional de Automobilismo (FIA). Os resultados de cada Grande Prêmio são combinados para determinar o Campeonato Mundial de Pilotos. Mais especificamente, a cada Grande Prêmio são distribuídos pontos para os pilotos, dependendo da classificação na corrida. Ao final da temporada, o piloto que tiver somado o maior número de pontos é declarado Campeão Mundial de Pilotos.
Os organizadores da Fórmula 1 mudam constantemente as regras da competição, com o objetivo de dar mais emoção às disputas. Uma regra modificada para a temporada de 2010 foi justamente a distribuição de pontos em cada Grande Prêmio. Desde 2003 a regra de pontuação premiava os oito primeiros colocados, obedecendo a seguinte tabela:
Ou seja, o piloto vencedor ganhava 10 pontos, o segundo colocado ganhava 8 pontos, e assim por diante.
Na temporada de 2010, os dez primeiros colocados receberão pontos obedecendo a seguinte tabela:
A mudança no sistema de pontuação provocou muita especulação sobre qual teria sido o efeito nos Campeonatos Mundiais passados se a nova pontuação tivesse sido utilizada nas temporadas anteriores. Por exemplo, teria Lewis Hamilton sido campeão em 2008, já que a diferença de sua pontuação total para Felipe Massa foi de apenas um ponto? Para acabar com as especulações, a FIA contratou você para escrever um programa que, dados os resultados de cada corrida de uma temporada determine Campeão Mundial de Pilotos para sistemas de pontuações diferentes.
Entrada
A entrada contém vários casos de teste. A primeira linha de um caso de teste contém dois números inteiros G e P separados por um espaço em branco, indicando respectivamente o número de Grandes Prêmios (1 ≤ G ≤ 100) e o número de pilotos (1 ≤ P ≤ 100). Os pilotos são identificados por inteiros de 1 a P. Cada uma das G linhas seguintes indica o resultado de uma corrida, e contém P inteiros separados por espaços em branco. Em cada linha, o i-ésimo número indica a ordem de chegada do pilodo i na corrida (o primeiro número indica a ordem de chegada do piloto 1 naquela corrida, o segundo número indica a ordem de chegada do piloto 2 na corrida, e assim por diante). A linha seguinte contém um único número inteiro S indicando o número de sistemas de pontuação (1 ≤ S ≤ 10), e após, cada uma das S linhas seguintes contém a descrição de um sistema de pontuação. A descrição de um sistema de pontuação inicia com um inteiro K (1 ≤ K ≤ P), indicando a última ordem de chegada que receberá pontos, seguido de um espaço em branco, seguido de K inteiros k0, k1, ... , kn−1 (1 ≤ ki ≤ 100) separados por espaços em branco, indicando os pontos a serem atribuídos (o primeiro inteiro indica os pontos do primeiro colocado, o segundo inteiro indica os pontos do segundo colocado, e assim por diante).
O último caso de teste é seguido por uma linha que contém apenas dois números zero separados por um espaço em branco.
Saída
Para cada caso de sistema de pontuação da entrada seu programa deve imprimir uma linha, que deve conter o identificador do Campeão Mundial de Pilotos. Se houver mais de um Campeão Mundial Pilotos (ou seja, se houver empate), a linha deve conter todos os Campeões Mundiais de Pilotos, em ordem crescente de identificador, separados por um espaço em branco.
Exemplo de Entrada Exemplo de Saída
1 3
3 2 1
3
3 5 3 2
3 5 3 1
3 1 1 1
3 10
1 2 3 4 5 6 7 8 9 10
10 1 2 3 4 5 6 7 8 9
9 10 1 2 3 4 5 6 7 8
2
5 5 4 3 2 1
3 10 5 1
2 4
1 3 4 2
4 1 3 2
2
3 3 2 1
3 5 4 2
0 0
3
3
1 2 3
3
3
2 4
4
Maratona de Programação da SBC 2010 |
126 | 1126 | Guerra nas Estrelas | Muito Difícil | GEOMETRIA COMPUTACIONAL | Há muito tempo atrás, em uma galáxia muito, muito distante, havia um império que dominava a todos. Uma aliança rebelde, descontente com essa situação, decidiu lutar contra tais forças, com o objetivo de restaurar a democracia e a paz para todos os povos.
Capitão Cael, um dos comandantes rebeldes, está navegando pelo espaço com seu cruzador espacial, quando de repente percebe a presença de uma nave do Império (de acordo com os padrões estéticos da época, todas as naves são tetraedros). Após ser surpreendido por um ataque inicial do império, Cael percebe que está em posição de disparo e que pode posicionar um canhão em qualquer ponto de sua nave.
Como a potência de sua arma é fixa, Cael quer posicionar seu canhão de forma que a distância percorrida pelo feixe de energia até a nave do Império seja mínima, para evitar perdas. Para isso, ele pediu para que você, sub-capitão Cin Talig, calculasse a menor distância entre a nave rebelde e a nave do Império.
Entrada
A entrada contém vários casos de teste. A primeira linha da entrada contém um inteiro T, indicando o número de casos de teste da entrada. Cada um dos T casos de teste é composto de oito linhas, cada uma descrevendo a coordenada de um vértice de uma nave; as quatro primeiras linhas indicam os vértices da nave rebelde; as quatro linhas seguintes indicam os vértices da nave do Império.
Cada descrição de coordenada é uma linha contendo três inteiros X, Y, Z indicando a coordenada do vértice no espaço (−103 ≤ X ≤ 103, −103 ≤ Y ≤ 103, −103 ≤ Z ≤ 103); os quatro vértices de cada nave sempre definem um tetraedro de volume não nulo e as duas naves são sempre disjuntas.
Saída
Para cada caso de teste da entrada seu programa deve imprimir um único número, indicando a distância entre as duas naves, com duas casas decimais de precisão. A distância entre as duas naves é sempre maior que zero.
Exemplo de Entrada Exemplo de Saída
3
2 -1 -1
0 -1 -3
1 1 -4
1 1 -2
0 5 -1
2 5 1
1 3 2
1 3 0
1 0 -6
-5 0 -4
-2 6 -5
-2 2 -2
1 0 3
-5 0 5
-2 2 7
-2 -4 7
4 -4 -2
-2 -4 -4
1 4 -3
1 0 -4
-2 4 -1
4 4 1
1 -4 0
1 0 -1
2.83
6.03
1.90
Maratona de Programação da SBC 2010 |
127 | 1127 | Plágio Musical | Difícil | AD-HOC | As notas musicais são unidades básicas da música ocidental tradicional. Cada nota está associada a uma frequência. Duas notas musicais cujas frequêcias fundamentais tenham uma relação de potência de 2 (uma metade da outra, uma duas vezes a outra, etc.) são percebidas como muito similar. Por isso, todas as notas com esse tipo de relação recebem o mesmo nome, como descrito a seguir.
Há doze notas básicas, em uma sequência crescente de frequências, cada nota separada da anterior por uma mesma distância na escala musical (essa distância é chamada de meio-tom). Sete dessas doze notas são representadas por letras do alfabeto (A, B, C, D, E, F e G). A tabela abaixo mostra a distância, em meio-tons, entre essas notas.
Note que há cinco notas que não são representadas pelas letras do alfabeto: as que estão entre A e B, entre C e D, entre D e E, entre F e G e entre G e A.
As notas podem ser modificadas por duas alterações cromáticas: sustenido e bemol, representadas respectivamente pelos símbolos ‘#’ e ‘b’. Sustenido altera a nota em meio tom para cima, e bemol altera a nota em meio tom para baixo. Uma nota com alteração cromática é denotada pelo nome da nota seguida pelo símbolo da alteração. Note que com esse esquema conseguimos representar todas as doze notas.
A figura abaixo ilustra o nome das notas, segundo o esquema descrito acima, em um trecho de teclado de piano.
Uma melodia pode ser representada por uma sequência de notas musicais. Por exemplo,
A A D C# C# D E E E F# A D G# A
é uma melodia muito conhecida. Note no entanto que, como as distâncias entre os meios-tons são sempre iguais, a mesma melodia pode ser escrita iniciando em outra nota (dizemos que a melodia está em outro tom):
B B E D# D# E Gb Gb Gb G# B E A# B
Sua vizinha é uma famosa compositora que suspeita que tenham plagiado uma de suas músicas. Ela pediu a sua ajuda para escrever um programa que, dada a sequência de notas da melodia de sua música, e a sequência de notas de um trecho de melodia suspeito, verifique se o trecho supeito ocorre, em algum tom, na música dada.
Entrada
A entrada é composta por vários casos de teste. A primeira linha de um caso de teste contém dois inteiros M e T (1 ≤ M ≤ 100000, 1 ≤ T ≤ 10000, T ≤ M ), indicando respectivamente o número de notas da música e do trecho suspeito de ter sido plagiado. As duas linhas seguintes contém M e T notas, respectivamente, indicando as notas da música e do trecho suspeito.
As notas em cada linha são separadas por espaço; cada nota é uma dentre ‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’ ou ‘G’, possivelmente seguida de um modificador: ‘#’ para um sustenido ou ‘b’ para um bemol.
O último caso de teste é seguido por uma linha que contém apenas dois números zero separados por um espaço em branco.
Saída
Para cada caso de teste, imprima uma única linha contendo um caractere: ‘S’ caso o trecho realmente tenha sido plagiado pela música ou ‘N’ caso contrário.
Exemplo de Entrada Exemplo de Saída
16 4
D G A B C D G G G C D E F# G C C
G G C D
12 2
C C# D D# E F F# G G# A A# B
C D
12 2
C Db D Eb E F Gb G Ab A Bb B
C D
4 3
C E G Bb
D F# A
0 0
S
N
N
S
Maratona de Programação da SBC 2010 |
128 | 1128 | Ir e Vir | Fácil | GRAFOS | Numa certa cidade há N intersecções ligadas por ruas de mão única e ruas com mão dupla de direcão. É uma cidade moderna, de forma que muitas ruas atravessam túneis ou têm viadutos. Evidentemente é necessário que se possa viajar entre quaisquer duas intersecções, isto é, dadas duas intersecções V e W, deve ser possível viajar de V para W e de W para V.
Sua tarefa é escrever um programa que leia a descrição do sistema de tráfego de uma cidade e determine se o requisito de conexidade é satisfeito ou não.
Entrada
A entrada contém vários casos de teste. A primeira linha de um caso de teste contém dois números inteiros N e M, separados por um espaço em branco, indicando respectivamente o número de intersecções (2 ≤ N ≤ 2000) e o número de ruas (2 ≤ M ≤ N(N−1)/2). O caso de teste tem ainda mais M linhas, que contêm, cada uma, uma descrição de cada uma das M ruas. A descrição consiste de três inteiros V, W e P, separados por um espaço em branco, onde V e W são identificadores distintos de intersecções (1 ≤ V, W ≤ N , V ≠ W ) e P pode ser 1 ou 2; se P = 1 então a rua é de mão única, e vai de V para W; se P = 2 então a rua é de mão dupla, liga V e W. Não existe duas ruas ligando as mesmas intersecções.
O ultimo caso de teste é seguido por uma linha que contém apenas dois números zero separados por um espaço em branco.
Saída
Para cada caso de teste seu programa deve imprimir uma linha contendo um inteiro G, onde G é igual a 1 se o requisito de conexidade está satisfeito, ou G é igual a 0, caso contrário.
Exemplo de Entrada Exemplo de Saída
4 5
1 2 1
1 3 2
2 4 1
3 4 1
4 1 2
3 2
1 2 2
1 3 2
3 2
1 2 2
1 3 1
4 2
1 2 2
3 4 2
0 0
1
1
0
0
Maratona de Programação da SBC 2010 |
129 | 1129 | Leitura Ótica | Muito Fácil | AD-HOC | O professor João decidiu aplicar somente provas de múltipla escolha, para facilitar a correção. Em cada prova, cada questão terá cinco alternativas (A, B, C, D e E), e o professor vai distribuir uma folha de resposta para cada aluno. Ao final da prova, as folhas de resposta serão escaneadas e processadas digitalmente para se obter a nota de cada aluno. Inicialmente, ele pediu ajuda a um sobrinho, que sabe programar muito bem, para escrever um programa para extrair as alternativas marcadas pelos alunos nas folhas de resposta. O sobrinho escreveu uma boa parte do software, mas não pode terminá-lo, pois precisava treinar para a Maratona de Programação.
Durante o processamento, a prova é escaneada usando tons de cinza entre 0 (preto total) e 255 (branco total). Após detectar os cinco retângulos correspondentes a cada uma das alternativas, ele calcula a média dos tons de cinza de cada pixel, retornando um valor inteiro correspondente àquela alternativa. Se o quadrado foi preenchido corretamente o valor da média é zero (preto total). Se o quadrado foi deixado em branco o valor da média é 255 (branco total). Assim, idealmente, se os valores de cada quadrado de uma questão são (255, 0, 255, 255, 255), sabemos que o aluno marcou a alternativa B para essa questão. No entanto, como as folhas são processadas individualmente, o valor médio de nível de cinza para o quadrado totalmente preenchido não é necessariamente 0 (pode ser maior); da mesma forma, o valor para o quadrado não preenchido não é necessariamente 255 (pode ser menor). O prof. João determinou que os quadrados seriam divididos em duas classes: aqueles com média menor ou igual a 127 serão considerados pretos e aqueles com média maior a 127 serão considerados brancos.
Obviamente, nem todas as questões das folhas de resposta são marcadas de maneira correta. Pode acontecer de um aluno se enganar e marcar mais de uma alternativa na mesma questão, ou não marcar nenhuma alternativa. Nesses casos, a resposta deve ser desconsiderada.
O professor João necessita agora de um voluntário para escrever um programa que, dados os valores dos cinco retângulos correspondentes às alternativas de uma questão determine qual a alternativa corretamente marcada, ou se a resposta à questão deve ser desconsiderada.
Entrada
A entrada contém vários casos de teste. A primeira linha de um caso de teste contém um número inteiro N indicando o número de questões da folha de respostas (1 ≤ N ≤ 255). Cada uma das N linhas seguintes descreve a resposta a uma questão e contém cinco números inteiros A, B, C, D e E, indicando os valores de nível de cinza médio para cada uma das alternativas da resposta (0 ≤ A, B, C, D, E ≤ 255).
O ultimo caso de teste é seguido por uma linha que contém apenas um número zero.
Saída
Para cada caso de teste da entrada seu programa deve imprimir N linhas, cada linha correspondendo a uma questão. Se a resposta à questão foi corretamente preenchida na folha de resposta, a linha deve conter a alternativa marcada (‘A’, ‘B’, ‘C’, ‘D’ ou ‘E’). Caso contrário, a linha deve conter o caractere ‘*’ (asterisco).
Exemplo de Entrada Exemplo de Saída
3
0 255 255 255 255
255 255 255 255 0
255 255 127 255 255
4
200 200 200 0 200
200 1 200 200 1
1 2 3 4 5
255 5 200 130 205
0
A
E
C
D
*
*
B
Maratona de Programação da SBC 2010 |
130 | 1130 | Jogo da Velha | Muito Difícil | AD-HOC | O jogo da velha é um dos jogos mais antigos da humanidade; os primeiros registros dele são do século I antes de Cristo, no Império Romano. João e Maria jogam bastante jogo da velha, mas depois de algum tempo eles decidiram jogar uma variante do jogo da velha tradicional, o jogo da velha 1-D.
O jogo da velha 1-D é um jogo disputado por dois jogadores em um tabuleiro 1 × N; inicialmente, todas as casas do tabuleiro estão vazias. Os jogadores alternam-se desenhando uma cruz sobre uma casa vazia. O primeiro jogador a completar uma sequência de três ou mais cruzes em casas consecutivas ganha o jogo.
Maria logo percebeu que, dependendo da situação do jogo, sendo sua vez de jogar, ela pode sempre garantir a vitória, independente das jogadas de João. Isto é relativamente fácil para tabuleiros menores, mas para tabuleiros maiores, mesmo após várias jogadas, esta tarefa é mais difícil; por isso, ela pediu que você escrevesse um programa que, dada a situação do tabuleiro, decide se ela tem uma estratégia vencedora.
Entrada
A entrada contém vários casos de teste. A primeira linha de caso de teste contém um inteiro N, indicando o tamanho do tabuleiro (3 ≤ N ≤ 104). A linha seguinte contém uma sequência de N caracteres indicando quais casas do tabuleiro já foram ocupadas: um ‘.’ indica que a casa correspondente está vazia, enquanto um ‘X’ indica que a casa já teve uma cruz desenhada sobre ela. A entrada nunca contém três ‘X’ consecutivos.
O ultimo caso de teste é seguido por uma linha que contém um único número zero.
Saída
Para cada caso de teste da entrada seu programa deve imprimir uma única linha contendo um único caractere: ‘S’ caso Maria possua uma estratégia vencedora e ‘N’ caso contrário.
Exemplo de Entrada Exemplo de Saída
5
.....
5
..X..
6
X.X.X.
12
............
0
S
N
S
N
Maratona de Programação da SBC 2010 |
131 | 1131 | Grenais | Muito Fácil | INICIANTE | A Federação Gaúcha de Futebol contratou você para escrever um programa para fazer uma estatística do resultado de vários GRENAIS. Escreva um programa para ler o número de gols marcados pelo Inter e pelo Grêmio em um GRENAL. Logo após escrever a mensagem "Novo grenal (1-sim 2-nao)" e solicitar uma resposta. Se a resposta for 1, o algoritmo deve ser executado novamente solicitando o número de gols marcados pelos times em uma nova partida, caso contrário deve ser encerrado imprimindo:
- Quantos GRENAIS fizeram parte da estatística.
- O número de vitórias do Inter.
- O número de vitórias do Grêmio.
- O número de Empates.
- Uma mensagem indicando qual o time que venceu o maior número de GRENAIS (ou "Nao houve vencedor", caso termine empatado).
Entrada
O arquivo de entrada contém 2 valores inteiros, correspondentes aos gols marcados pelo Inter e pelo Grêmio respectivamente. Em seguida háverá um inteiro (1 ou 2), correspondente à repetição do programa.
Saída
Após cada leitura dos gols, deve ser impressa a mensagem "Novo grenal (1-sim 2-nao)". Quando o algoritmo for encerrado devem ser mostradas as estatísticas conforme a descrição apresentada acima. Obs: a palavra "Gremio" deve ser impressa sem acento, conforme o exemplo abaixo.
Exemplo de Entrada Exemplo de Saída
3 2
1
2 3
1
3 1
2
Novo grenal (1-sim 2-nao)
Novo grenal (1-sim 2-nao)
Novo grenal (1-sim 2-nao)
3 grenais
Inter:2
Gremio:1
Empates:0
Inter venceu mais
Agradecimentos a Cássio F. |
132 | 1132 | Múltiplos de 13 | Muito Fácil | INICIANTE | Escreva um algoritmo que leia 2 valores inteiros X e Y calcule a soma dos números que não são múltiplos de 13 entre X e Y, incluindo ambos.
Entrada
O arquivo de entrada contém 2 valores inteiros quaisquer, não necessariamente em ordem crescente.
Saída
Imprima a soma de todos os valores não divisíveis por 13 entre os dois valores lidos na entrada, inclusive ambos se for o caso.
Sample Input Sample Output
100
200
13954
Agradecimentos a Cássio F. |
133 | 1133 | Resto da Divisão | Fácil | INICIANTE | Escreva um programa que leia 2 valores X e Y e que imprima todos os valores entre eles cujo resto da divisão dele por 5 for igual a 2 ou igual a 3.
Entrada
O arquivo de entrada contém 2 valores positivos inteiros quaisquer, não necessariamente em ordem crescente.
Saída
Imprima todos os valores conforme exemplo abaixo, sempre em ordem crescente.
Sample Input Sample Output
10
18
12
13
17 |
134 | 1134 | Tipo de Combustível | Muito Fácil | INICIANTE | Um Posto de combustíveis deseja determinar qual de seus produtos tem a preferência de seus clientes. Escreva um algoritmo para ler o tipo de combustível abastecido (codificado da seguinte forma: 1.Álcool 2.Gasolina 3.Diesel 4.Fim). Caso o usuário informe um código inválido (fora da faixa de 1 a 4) deve ser solicitado um novo código (até que seja válido). O programa será encerrado quando o código informado for o número 4.
Entrada
A entrada contém apenas valores inteiros e positivos.
Saída
Deve ser escrito a mensagem: "MUITO OBRIGADO" e a quantidade de clientes que abasteceram cada tipo de combustível, conforme exemplo.
Exemplo de Entrada Exemplo de Saída
8
1
7
2
2
4
MUITO OBRIGADO
Alcool: 1
Gasolina: 2
Diesel: 0
Agradecimentos a Cássio F. |
135 | 1135 | Colônia de Formigas | Difícil | GRAFOS | Um grupo de formigas está muito orgulhoso pois construíram uma grande e magnífica colônia. No entanto, seu enorme tamanho tem se tornado um problema, pois muitas formigas não sabem o caminho entre algumas partes da colônia. Elas precisam de sua ajuda desesperadamente!
A colônia de formigas foi criada como uma série de N formigueiros conectados por túneis. As formigas, obssessivas como são, numeraram os formigueiros sequencialmente à medida que os construiam. O primeiro formigueiro, numerado 0, não necessitava nenhum túnel, mas para cada um dos formigueiros subsequentes, 1 até N-1, as formigas também construíram um único túnel que conectava o novo formigueiro a um dos formigueiros existentes. Certamente, esse túnel era suficiente para permitir que qualquer formiga visitasse qualquer formigueiro já construído, possivelmente passando através de outros formigueiros pelo percurso, portanto elas não se preocupavam em fazer novos túneis e continuavam construindo mais formigueiros.
O seu trabalho é: dada a estrutura de uma colônia e um conjunto de consultas, calcular, para cada uma das consultas, o menor caminho entre pares de formigueiros. O comprimento do caminho é a soma dos comprimentos de todos os túneis que necessitam ser visitados.
Entrada
Cada caso de teste se estende por várias linhas. A primeira linha contém um inteiro N representando a quantidade de formigueiros na colônia (2 ≤ N ≤ 105). Cada uma das próximas N-1 linhas contém dois inteiros que descrevem um túnel. A linha i, para 1 ≤ i ≤ N-1, contém Ai e Li, indicando que o formigueiro i foi conectado diretamente ao formigueiro Ai por um túnel de comprimento Li (0 ≤ Ai ≤ i-1 e 1 ≤ Li ≤ 109). A próxima linha contém um inteiro Q representando o número de consultas que seguem (1 ≤ Q ≤ 105). Cada uma das Q linhas seguintes descreve uma consulta e contém dois inteiros distintos S e T (0 ≤ S,T ≤ N-1), representando, respectivamente, os formigueiros de origem e destino.
O último caso de teste é seguido por uma linha contendo apenas um zero.
Saída
Para cada caso de teste, imprima uma única linha com Q inteiros, os comprimentos do menor caminho entre os dois formigueiros de cada consulta. Escreva os resultados para cada consulta na mesma ordem em que aparecem na entrada.
Exemplo de Entrada Exemplo de Saída
6
0 8
1 7
1 9
0 3
4 2
4
2 3
5 2
1 4
0 3
2
0 1
2
1 0
0 1
6
0 1000000000
1 1000000000
2 1000000000
3 1000000000
4 1000000000
1
5 0
0
16 20 11 17
1 1
5000000000
ACM/ICPC South America Contest 2010. |
136 | 1136 | Bingo! | Fácil | AD-HOC | Albert, Charles e Mary inventaram uma nova versão do clássico jogo de Bingo. Na versão tradicional, o jogo é presidido por um não-jogador conhecido como caller. No começo de cada partida, cada jogador recebe uma carta contendo uma única combinação de números de 0 até N dispostos em colunas e linhas. O caller opera um globo contendo N+1 bolas numeradas de 0 até N. Em cada turno, o caller sorteia uma bola do globo, anuncia o número sorteado aos jogadores e não a coloca novamente no globo. Cada jogador procura pelo número em sua carta e o marca caso o encontre. O primeiro jogador que marcar um padrão pré-definido completo em sua carta (uma linha horizontal, por exemplo) ganha um prêmio.
Na versão Albert-Charles-Mary, em cada turno, o caller sorteia uma primeira bola, coloca-a de volta no globo, sorteia uma segunda bola, coloca-a de volta no globo, e então anuncia a diferença absoluta entre os números das duas bolas. Para aumentar o entusiasmo, antes do início da partida, um subconjunto possivelmente vazio de bolas é retirado do globo, de forma que ao menos duas bolas permaneçam no globo. Eles gostariam de saber se cada número de 0 até N podem ainda ser anunciados utilizando a nova regra de sorteio e considerando apenas as bolas que permaneceram dentro do globo.
Entrada
Cada caso de teste é dado em exatamente duas linhas. A primeira linha contém dois inteiros N e B. O significado de N foi descrito acima (1 ≤ N ≤ 90), enquanto B representa o número de bolas que permaneceram no globo (2 ≤ B ≤ N+1). A segunda linha contém B inteiros distintos bi, indicando as bolas que permaneceram no globo (0 ≤ bi ≤ N).
O último caso de teste é seguido por uma linha contendo dois zeros.
Saída
Para cada caso de teste, imprima uma única linha contendo um único caractere 'Y' se for possível anunciar todos os números de 0 até N, inclusive, ou um único caractere 'N' caso contrário.
Exemplo de Entrada Exemplo de Saída
6 7
2 1 3 4 0 6 5
5 4
5 3 0 1
5 3
1 5 0
0 0
Y
Y
N
ACM/ICPC South America Contest 2010. |
137 | 1137 | Pontos Cocirculares | Difícil | GEOMETRIA COMPUTACIONAL | Você provavelmente sabe o que é um conjunto de pontos colineares: é um conjunto de pontos tal que existe uma linha reta que passa através de todos os pontos. Um conjunto de pontos cocirculares é definido da mesma forma, mas ao invés de uma linha reta, nós queremos saber se existe um círculo tal que todos os pontos do conjunto encontram-se sobre seu perímetro.
A International Collinear Points Center (ICPC) designou a você a seguinte tarefa: dado um conjunto de pontos, calcule o tamanho do maior subconjunto de pontos cocirculares.
Entrada
Cada caso de teste se estende por várias linhas. A primeira linha contém um inteiro N representando o número de pontos no conjunto (1 ≤ N ≤ 100). Cada uma das próximas N linhas contém dois inteiros X e Y representando as coordenadas de um ponto do conjunto (-104 ≤ X,Y ≤ 104). Em cada caso de teste, não haverá dois pontos com mesma localização.
O último caso de teste é seguido por uma linha contendo apenas um zero.
Saída
Para cada caso de teste, imprima uma única linha com um único inteiro representando o número de pontos em um dos maiores subconjuntos da entrada que são cocirculares.
Exemplo de Entrada Exemplo de Saída
7
-10 0
0 -10
10 0
0 10
-20 10
-10 20
-2 4
4
-10000 10000
10000 10000
10000 -10000
-10000 -9999
3
-1 0
0 0
1 0
0
5
3
2
ACM/ICPC South America Contest 2010. |
138 | 1138 | Contagem de Dígitos | Difícil | MATEMÁTICA | Diana escreverá uma lista com todos os inteiros positivos entre A e B, inclusive, na base decimal e sem zeros à esquerda. Ela quer saber quantas vezes cada um dos dígitos irá ser usado.
Entrada
Cada caso de teste é dado em uma única linha que contém dois inteiros A e B (1 ≤ A ≤ B ≤ 108). O último caso de teste é seguido por uma linha contendo dois zeros.
Saída
Para cada caso de teste, imprima uma única linha com 10 inteiros representando o número de vezes que cada dígito é usado ao escrever todos os inteiros entre A e B, inclusive, na base decimal e sem zeros à esquerda. Escreva a contagem de cada dígito em ordem crescente do 0 até o 9.
Exemplo de Entrada Exemplo de Saída
1 9
12 321
5987 6123
12345678 12345679
0 0
0 1 1 1 1 1 1 1 1 1
61 169 163 83 61 61 61 61 61 61
134 58 28 24 23 36 147 24 27 47
0 2 2 2 2 2 2 2 1 1
ACM/ICPC South America Contest 2010. |
139 | 1139 | Necessidades Elétricas | Muito Difícil | AD-HOC | Você irá construir uma nova fábrica na sua cidade. Já que você necessida de muita energia elétrica, ter a fábrica posicionada perto de uma estação de força é importante. Você quer construir uma lista priorizada das possíveis localizações.
A área onde a fábrica precisa ser construída pode ser representada como uma grade retangular de N linhas e M colunas de células. Algumas dessas células contem uma estação de força. A nova fábrica ocupa exatamente uma célula, e pode ser construída em qualquer célula livre (ou seja, qualquer célula que não contém uma estação de força).
Numerando as linhas de 1 até N e as colunas de 1 até M, a localização de uma célula pode ser descrita por dois inteiros. A célula ( i , j ) é a célula na linha i e coluna j. A distância entre as células (i0 , j0) e (i1 , j1) é max( |i0 - i1| , |j0 - j1| ) onde | x | representa o valor absoluto de x. A prioridade elétrica de uma localização é a menor distância até qualquer estação de força.
Com isso em mente, você vai numerar todas as possíveis localizações com inteiros consecutivos começando de 1. Você fará isso em ordem crescente de prioridade elétrica. Dentre locais com a mesma prioridade elétrica, você vai numerá-los em ordem crescente de seu índices de linha. Dentre locais com mesmas prioridade elétrica e índice de linha, você vai listá-los em ordem crescente de seu índices de coluna.
Na figura abaixo você pode ver uma grade 4 x 7. Células pretas são as células onde há uma estação de força. Células cinza escuras possuem prioridade elétrica 1, cinza claras prioridade elétrica 2 e células brancas prioridade elétrica 3. O número dentro de cada célula é o número atribuído por você à célula.
Você receberá inúmeras consultas sobre a lista construída. Em cada consulta será dado um número representando a posição na lista final e você deverá dizer a qual célula foi atribuída a posição dada.
Entrada
Cada caso de teste se estende por várias linhas. A primeira linha contém três inteiros N, M e P, representando o número de linhas e colunas da grade (1 ≤ N,M ≤ 109) e o número de estações de força (1 ≤ P ≤ 20). Cada uma das P linhas seguintes contém dois inteiros R e C representando a linha e a coluna de uma estação de força (1 ≤ R ≤ N e 1 ≤ C ≤ M). Em cada caso de teste, todas as estações de força estão em células distintas. A próxima linha contém um único inteiro Q representando o número de consultas (1 ≤ Q ≤ 50). Então segue uma linha com Q inteiros p1, ... , pQ representando as posições da lista priorizada (1 ≤ pi ≤ N x M - P).
O último caso de teste é seguido de uma linha contendo três zeros.
Saída
Para cada caso de teste, imprima Q+1 linhas. A linha i das primeiras Q linhas devem conter dois inteiros representando a linha e a coluna da localização que foi atribuída ao número pi. A última linha de cada caso deve conter um único caractere '-' (hífen).
Exemplo de Entrada Exemplo de Saída
4 7 2
2 5
4 4
6
1 6 11 16 21 26
1000000000 1000000000 1
1 1
1
999999999999999999
0 0 0
1 4
3 3
4 5
2 7
4 7
4 1
-
1000000000 1000000000
-
ACM/ICPC South America Contest 2010. |
140 | 1140 | Flores Florescem da França | Fácil | AD-HOC | Fiona sempre amou poesia, e recentemente descobriu uma forma poética fascinante. Tautogramas são um caso especial de aliteração, que é a ocorrência da mesma letra no início de palavras adjacentes. Em particular, uma sentença é um tautograma se todas suas palavras começam com a mesma letra.
Por exemplo, as seguintes sentenças são tautogramas:
Flowers Flourish from France
Sam Simmonds speaks softly
Peter pIckEd pePPers
truly tautograms triumph
Fiona quer deslumbrar seu namorado com uma carta romântica repleta desse tipo de sentenças. Por favor, ajude Fiona a verificar se cada sentença que ela escreveu é um tautograma ou não.
Entrada
Cada caso de teste é dado em uma única linha que contém uma frase. Uma frase consiste de uma sequência de no máximo 50 palavras separadas por espaços simples. Uma palavra é uma sequência de no máximo 20 letras do alfabeto inglês (maiúsculas e minúsculas). Uma palavra contém ao menos uma letra e uma sentença contém ao menos uma palavra.
O último caso de teste é seguido de uma linha contendo apenas o caractere '*' (asterisco).
Saída
Para cada caso de teste, imprima uma única linha contendo o caractere 'Y' se a sentença é um tautograma, ou um 'N' caso contrário.
Exemplo de Entrada Exemplo de Saída
Flowers Flourish from France
Sam Simmonds speaks softly
Peter pIckEd pePPers
truly tautograms triumph
this is NOT a tautogram
*
Y
Y
Y
Y
N
ACM/ICPC South America Contest 2010. |
141 | 1141 | Cultivando Strings | Muito Difícil | STRINGS | Gene e Gina possuem um tipo peculiar de fazenda. Ao invés de criar animais e plantar vegetais como acontece em fazendas normais, eles cultivam strings. Uma string é uma sequência de caracteres. As strings, ao crescerem, adicionam caracteres à esquerda e/ou à direita delas mesmas, mas nunca perdem caracteres nem inserem caracteres no meio.
Gene e Gina possuem uma coleção de fotos de algumas strings durante diferentes etapas de seus crescimentos. O problema é que a coleção não é rotulada, portanto eles esqueceram a qual string pertence cada uma das fotos. Eles querem montar um painel para ilustrar os procedimentos do cultivo de strings, mas eles necessitam sua ajuda para encontrar uma sequência de fotos apropriada.
Cada foto ilustra uma string. A sequência de fotos precisa ter a seguinte propriedade: se si aparece imediatamente antes de si+1 na sequência, então si+1 é uma string que pode ter crescido a partir de si (ou seja, si é uma substring contígua de si+1). Além disso, eles não querem usar fotos repetidas, portanto todas as strings na sequência devem ser diferentes.
Dado um conjunto de strings representando todas as fotos disponíveis, sua tarefa é calcular o tamanho da maior sequência que pode ser produzida com as restrições acima.
Entrada
Cada caso de teste se estende por várias linhas. A primeira linha contém um inteiro N representando o número de strings no conjunto (1 ≤ N ≤ 104). Cada uma das próximas N linhas contém uma string não-vazia e única com no máximo 1000 caracteres minúsculos do alfabeto inglês. Em cada caso de teste, a soma dos tamanhos das strings é no máximo 106.
O último caso de teste é seguido de uma linha contendo um zero.
Saída
Para cada caso de teste, imprima uma única linha com um único inteiro representando o tamanho da maior sequência de fotos que pode ser produzida.
Exemplo de Entrada Exemplo de Saída
6
plant
ant
cant
decant
deca
an
2
supercalifragilisticexpialidocious
rag
0
4
2
ACM/ICPC South America Contest 2010. |
142 | 1142 | PUM | Muito Fácil | INICIANTE | Escreva um programa que leia um valor inteiro N. Este N é a quantidade de linhas de saída que serão apresentadas na execução do programa.
Entrada
O arquivo de entrada contém um número inteiro positivo N.
Saída
Imprima a saída conforme o exemplo fornecido.
Exemplo de Entrada Exemplo de Saída
7
1 2 3 PUM
5 6 7 PUM
9 10 11 PUM
13 14 15 PUM
17 18 19 PUM
21 22 23 PUM
25 26 27 PUM |
143 | 1143 | Quadrado e ao Cubo | Muito Fácil | INICIANTE | Escreva um programa que leia um valor inteiro N (1 < N < 1000). Este N é a quantidade de linhas de saída que serão apresentadas na execução do programa.
Entrada
O arquivo de entrada contém um número inteiro positivo N.
Saída
Imprima a saída conforme o exemplo fornecido.
Exemplo de Entrada Exemplo de Saída
5
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
Agradecimentos a Cássio F. |
144 | 1144 | Sequência Lógica | Muito Fácil | INICIANTE | Escreva um programa que leia um valor inteiro N. N * 2 linhas de saída serão apresentadas na execução do programa, seguindo a lógica do exemplo abaixo. Para valores com mais de 6 dígitos, todos os dígitos devem ser apresentados.
Entrada
O arquivo de entrada contém um número inteiro positivo N (1 < N < 1000).
Saída
Imprima a saída conforme o exemplo fornecido.
Exemplo de Entrada Exemplo de Saída
5
1 1 1
1 2 2
2 4 8
2 5 9
3 9 27
3 10 28
4 16 64
4 17 65
5 25 125
5 26 126
Agradecimentos a Cássio F. |
145 | 1145 | Sequência Lógica 2 | Muito Fácil | INICIANTE | Escreva um programa que leia dois valores X e Y. A seguir, mostre uma sequência de 1 até Y, passando para a próxima linha a cada X números.
Entrada
O arquivo de entrada contém dois valores inteiros, (1 < X < 20) e (X < Y < 100000).
Saída
Cada sequência deve ser impressa em uma linha apenas, com 1 espaço em branco entre cada número, conforme exemplo abaixo. Não deve haver espaço em branco após o último valor da linha.
Exemplo de Entrada Exemplo de Saída
3 99
1 2 3
4 5 6
7 8 9
10 11 12
...
97 98 99
Agradecimentos a Cássio F. |
146 | 1146 | Sequências Crescentes | Fácil | INICIANTE | Este programa deve ler uma variável inteira X inúmeras vezes (deve parar quando o valor no arquivo de entrada for igual a zero). Para cada valor lido imprima a sequência de 1 até X, com um espaço entre cada número e seu sucessor.
Obs: cuide para não deixar espaço em branco após o último valor apresentado na linha ou você receberá Presentation Error.
Entrada
O arquivo de entrada contém vários números inteiros. O último número no arquivo de entrada é 0.
Saída
Para cada número N do arquivo de entrada deve ser impressa uma linha de 1 até N, conforme o exemplo abaixo. Não deve haver espaço em branco após o último valor da linha.
Exemplo de Entrada Exemplo de Saída
5
10
3
0
1 2 3 4 5
1 2 3 4 5 6 7 8 9 10
1 2 3 |
147 | 1147 | Fuga do Cavalo | Médio | AD-HOC | Seu amigo Pedro está aprendendo a jogar xadrez. Mas ele ainda não tem segurança de como pode movimentar o Cavalo. Desta forma, ele solicitou a você que desenvolvesse um programa que calcule, em apenas uma jogada, o número de distintos movimentos que o cavalo pode realizar, sem que o mesmo fique sobre o ataque de qualquer um dos 8 peões. Os movimentos do cavalo e dos peões são realizados conforme o jogo de xadrez tradicional, ou seja, o cavalo pode somente andar em “L”, e os peões atacar somente para frente em diagonal. Segue abaixo um exemplo:
Na imagem apresentada, das 8 distintas posições que o cavalo pode movimentar-se no tabuleiro, 2 delas estão sobre ataque (6b e 3e). Nas demais casas, o cavalo pode movimentar-se seguramente, conseguindo fugir do ataque de qualquer um dos peões. Note que na casa 2b já existe um peão, porém ainda é uma jogada válida, já que o cavalo pode movimentar-se nessa mesma casa e “matar” o peão.
Portanto, para o exemplo apresentado, o número de movimentos seguros para o cavalo realizar são 6. Vale lembrar que os peões pretos somente podem se movimentar de cima para baixo no tabuleiro, ou seja, da linha 7 até a linha 1, não sendo permitido o seu retorno.
Entrada
A entrada consiste de diversos casos de teste. Cada caso de teste consiste em 9 linhas de entrada. A primeira linha indica a posição inicial do cavalo. As demais 8 linhas, representam as respectivas posições dos peões.
O final da entrada consiste em uma única linha contendo somente o valor 0 (zero).
Saída
Para cada teste de caso de entrada, seu programa deve imprimir uma única linha, contendo a seguinte descrição:
Caso de Teste #Y: X movimento(s).
onde Y representa o número do respectivo caso de teste, e X representa a quantidade de movimentos possíveis ao cavalo realizar, em uma única rodada, sem que fique sobre ataque de um ou mais peões.
Exemplo de Entrada Exemplo de Saída
4c
2b
2c
3d
4f
5d
7a
7d
7g
0
Caso de Teste #1: 6 movimento(s). |
148 | 1148 | Países em Guerra | Médio | GRAFOS | No ano 2050, após diversas tentativas da ONU de manter a paz no mundo, explode a terceira guerra mundial. Segredos industriais, comerciais e militares obrigaram todos os países a utilizar serviços de espionagem extremamente sofisticados, de forma que em cada cidade do mundo há ao menos um espião de cada país. Esses espiões precisam se comunicar com outros espiões, com informantes e mesmo com as suas centrais durante as suas ações. Infelizmente não existe uma forma segura de um espião se comunicar em um período de guerra, então as mensagens são sempre enviadas em código para que somente o destinatário consiga ler a mensagem e entender o seu significado.
Os espiões utilizam o unico serviço que funciona no período de guerra, os correios. Cada cidade possui uma agência postal onde as cartas são enviadas. As cartas podem ser enviadas diretamente ao seu destino ou a outras agências postais, até que a carta chegue à agência postal da cidade de destino, se isso for possível.
Uma agência postal na cidade A pode enviar diretamente uma carta impressa para a agência postal da cidade B se houver um acordo de envio de cartas, que determina o tempo, em horas, que uma carta leva para chegar da cidade A à cidade B (e não necessariamente o contrário). Se não houver um acordo entre as agências A e B, a agência A pode tentar enviar a carta a quantas agências for necessário para que a carta chegue ao seu destino, se isso for possível.
Algumas agências são interligadas por meios eletrônicos de comunicação, como satélites e fibras ópticas. Antes da guerra, essas ligações atingiam todas as agências, fazendo com que uma carta fosse enviada de forma instantânea, mas durante o período de hostilidades cada país passou a controlar a comunicação eletrônica e uma agência somente pode enviar uma carta a outra agência por meio eletrônico (ou seja, instantaneamente) se ela estiver no mesmo país. Duas agências, A e B, estão no mesmo país se houver uma forma de uma carta impressa enviada de uma das agências ser entregue na outra agência.
O serviço de espionagem do seu país conseguiu obter o conteúdo de todos os acordos de envios de mensagens existentes no mundo e deseja descobrir o tempo mínimo para se enviar uma carta entre diversos pares de cidades. Você seria capaz de ajudá-lo?
Entrada
A entrada contém vários casos de teste. A primeira linha de cada caso de teste contém dois inteiros separados por um espaço, N (1 ≤ N ≤ 500) e E (0 ≤ E ≤ N2), indicando o número de cidades (numeradas de 1 a N) e de acordos de envio de mensagens, respectivamente. Seguem-se, então, E linhas, cada uma com três inteiros separados por espaços, X, Y e H (1 ≤ X, Y ≤ N, 1 ≤ H ≤ 1000), indicando que existe um acordo para enviar uma carta impressa da cidade X à cidade Y , e que tal carta será entregue em H horas.
Em seguida, haverá uma linha com um inteiro K (0 ≤ K ≤ 100), o número de consultas. Finalmente, virão K linhas, cada uma representando uma consulta e contendo dois inteiros separados por um espaço, O e D (1 ≤ O, D ≤ N). Você deve determinar o tempo mínimo para se enviar uma carta da cidade O à cidade D. A entrada termina quando N = E = 0.
Saída
Para cada caso de teste da entrada seu programa deve produzir K linhas na saída. A I-ésima linha deve conter um inteiro M , o tempo mínimo, em horas, para se enviar uma carta na I-ésima consulta. Se não houver meio de comunicação entre as cidades da consulta, você deve imprimir ”Nao e possivel entregar a carta”(sem acentos).
Imprima uma linha em branco após cada caso de teste.
Exemplo de Entrada Exemplo de Saída
4 5
1 2 5
2 1 10
3 4 8
4 3 7
2 3 6
5
1 2
1 3
1 4
4 3
4 1
3 3
1 2 10
2 3 1
3 2 1
3
1 3
3 1
3 2
0 0
0
6
6
0
Nao e possivel entregar a carta
10
Nao e possivel entregar a carta
0 |
149 | 1149 | Somando Inteiros Consecutivos | Muito Fácil | INICIANTE | Faça um algoritmo para ler um valor A e um valor N. Imprimir a soma de A + i para cada i com os valores (0 <= i <= N-1). Enquanto N for negativo ou ZERO, um novo N(apenas N) deve ser lido.
Entrada
A entrada contém somente valores inteiros, podendo ser positivos ou negativos. Todos os valores estão na mesma linha.
Saída
A saída contém apenas um valor inteiro.
Exemplo de Entrada Exemplo de Saída
3 2
7
3 -1 0 -2 2
7
Agradecimentos a Cássio F. |
150 | 1150 | Ultrapassando Z | Muito Fácil | INICIANTE | Faça um programa que leia dois inteiros: X e Z (devem ser lidos tantos valores para Z quantos necessários, até que seja digitado um valor maior do que X para ele). Conte quantos números inteiros devem ser somados em sequência (considerando o X nesta soma) para que a soma ultrapasse a Z o mínimo possível. Escreva o valor final da contagem.
A entrada pode conter, por exemplo, os valores 21 21 15 30. Neste caso, é então assumido o valor 21 para X enquanto os valores 21 e 15 devem ser desconsiderados pois são menores ou iguais a X. Como o valor 30 está dentro da especificação (maior do que X) ele será válido e então deve-se processar os cálculos para apresentar na saída o valor 2, pois é a quantidade de valores somados para se produzir um valor maior do que 30 (21 + 22).
Entrada
A entrada contém somente valores inteiros, um por linha, podendo ser positivos ou negativos. O primeiro valor da entrada será o valor de X. A próxima linha da entrada irá conter Z. Se Z não atender a especificação do problema, ele deverá ser lido novamente, tantas vezes quantas forem necessárias.
Saída
Imprima uma linha com um número inteiro que representa a quantidade de números inteiros que devem ser somadas, de acordo com a especificação acima.
Exemplo de Entrada Exemplo de Saída
3
1
20
5 |
151 | 1151 | Fibonacci Fácil | Muito Fácil | INICIANTE | A seguinte sequência de números 0 1 1 2 3 5 8 13 21... é conhecida como série de Fibonacci. Nessa sequência, cada número, depois dos 2 primeiros, é igual à soma dos 2 anteriores. Escreva um algoritmo que leia um inteiro N (N < 46) e mostre os N primeiros números dessa série.
Entrada
O arquivo de entrada contém um valor inteiro N (0 < N < 46).
Saída
Os valores devem ser mostrados na mesma linha, separados por um espaço em branco. Não deve haver espaço após o último valor.
Exemplo de Entrada Exemplo de Saída
5
0 1 1 2 3
Agradecimentos a Cássio F. |
152 | 1152 | Estradas Escuras | Médio | GRAFOS | Nestes dias se pensa muito em economia, mesmo em Byteland. Para reduzir custos operacionais, o governo de Byteland decidiu otimizar a iluminação das estradas. Até agora, todas as rotas eram iluminadas durante toda noite, o que custava 1 Dólar Byteland por metro a cada dia. Para economizar, eles decidiram não iluminar mais todas as estradas e desligar a iluminação de algumas delas. Para ter certeza que os habitantes de Byteland continuem a se sentirem seguros, eles querem otimizar o sistema de tal forma que após desligar a iluminação de algumas estradas à noite, sempre existirá algum caminho iluminado de qualquer junção de Byteland para qualquer outra junção.
Qual é a quantidade máxima de dinheiro que o governo de Byteland pode economizar, sem fazer os seus habitantes sentirem-se inseguros?
Entrada
A entrada contém vários casos de teste. Cada caso de teste inicia com dois números m (1 ≤ m ≤ 200000) e n (m-1 ≤ n ≤ 200000), que são o número de junções de Byteland e o número de estradas em Byteland, respectivamente. Seguem n conjuntos de três valores inteiros, x, y e z, especificando qual será a estrada bidirecional entre x e y com z metros (0 ≤ x, y < m e x ≠ y).
A entrada termina com m=n=0. O grafo especificado em cada caso de teste é conectado. O tamanho total de todas as estradas em cada caso de teste é menor do que 231.
Saída
Para cada caso de teste imprima uma linha contendo a máxima quantidade diária de dólares de Byteland que o governo pode economizar.
Exemplo de Entrada Exemplo de Saída
7 11
0 1 7
0 3 5
1 2 8
1 3 9
1 4 7
2 4 5
3 4 15
3 5 6
4 5 8
4 6 9
5 6 11
0 0
51
Univeristy of Ulm Local Contest 2009 |
153 | 1153 | Fatorial Simples | Muito Fácil | INICIANTE | Ler um valor N. Calcular e escrever seu respectivo fatorial. Fatorial de N = N * (N-1) * (N-2) * (N-3) * ... * 1.
Entrada
A entrada contém um valor inteiro N (0 < N < 13).
Saída
A saída contém um valor inteiro, correspondente ao fatorial de N.
Exemplo de Entrada Exemplo de Saída
4
24
Agradecimentos a Cassio F. |
154 | 1154 | Idades | Muito Fácil | INICIANTE | Faça um algoritmo para ler um número indeterminado de dados, contendo cada um, a idade de um indivíduo. O último dado, que não entrará nos cálculos, contém o valor de idade negativa. Calcular e imprimir a idade média deste grupo de indivíduos.
Entrada
A entrada contém um número indeterminado de inteiros. A entrada será encerrada quando um valor negativo for lido.
Saída
A saída contém um valor correspondente à média de idade dos indivíduos.
A média deve ser impressa com dois dígitos após o ponto decimal.
Exemplo de Entrada Exemplo de Saída
34
56
44
23
-2
39.25
Agradecimentos a Cassio F. |
155 | 1155 | Sequência S | Muito Fácil | INICIANTE | Escreva um algoritmo para calcular e escrever o valor de S, sendo S dado pela fórmula:
S = 1 + 1/2 + 1/3 + … + 1/100
Entrada
Não há nenhuma entrada neste problema.
Saída
A saída contém um valor correspondente ao valor de S.
O valor deve ser impresso com dois dígitos após o ponto decimal.
Exemplo de Entrada Exemplo de Saída
Agradecimentos a Cassio F. |
156 | 1156 | Sequência S II | Muito Fácil | INICIANTE | Escreva um algoritmo para calcular e escrever o valor de S, sendo S dado pela fórmula:
S = 1 + 3/2 + 5/4 + 7/8 + ... + 39/?
Entrada
Não há nenhuma entrada neste problema.
Saída
A saída contém um valor correspondente ao valor de S.
O valor deve ser impresso com dois dígitos após o ponto decimal.
Exemplo de Entrada Exemplo de Saída
Agradecimentos a Cassio F. |
157 | 1157 | Divisores I | Muito Fácil | INICIANTE | Ler um número inteiro N e calcular todos os seus divisores.
Entrada
O arquivo de entrada contém um valor inteiro.
Saída
Escreva todos os divisores positivos de N, um valor por linha.
Exemplo de Entrada Exemplo de Saída
6
1
2
3
6
Agradecimentos a Cassio F. |
158 | 1158 | Soma de Ímpares Consecutivos III | Muito Fácil | INICIANTE | Leia um valor inteiro N que é a quantidade de casos de teste que vem a seguir. Cada caso de teste consiste de dois inteiros X e Y. Você deve apresentar a soma de Y ímpares consecutivos a partir de X inclusive o próprio X se ele for ímpar. Por exemplo:
para a entrada 4 5, a saída deve ser 45, que é equivalente à: 5 + 7 + 9 + 11 + 13
para a entrada 7 4, a saída deve ser 40, que é equivalente à: 7 + 9 + 11 + 13
Entrada
A primeira linha de entrada é um inteiro N que é a quantidade de casos de teste que vem a seguir. Cada caso de teste consiste em uma linha contendo dois inteiros X e Y.
Saída
Imprima a soma dos consecutivos números ímpares a partir do valor X.
Exemplo de Entrada Exemplo de Saída
2
4 3
11 2
21
24 |
159 | 1159 | Soma de Pares Consecutivos | Muito Fácil | INICIANTE | O programa deve ler um valor inteiro X indefinidas vezes. (O programa irá parar quando o valor de X for igual a 0). Para cada X lido, imprima a soma dos 5 pares consecutivos a partir de X, inclusive o X , se for par. Se o valor de entrada for 4, por exemplo, a saída deve ser 40, que é o resultado da operação: 4+6+8+10+12, enquanto que se o valor de entrada for 11, por exempo, a saída deve ser 80, que é a soma de 12+14+16+18+20.
Entrada
O arquivo de entrada contém muitos valores inteiros. O último valor do arquivo é zero.
Saída
Imprima a saida conforme a explicação acima e o exemplo abaixo.
Exemplo de Entrada Exemplo de Saída
4
11
0
40
80 |
160 | 1160 | Crescimento Populacional | Médio | INICIANTE | Mariazinha quer resolver um problema interessante. Dadas as informações de população e a taxa de crescimento de duas cidades quaisquer (A e B), ela gostaria de saber quantos anos levará para que a cidade menor (sempre é a cidade A) ultrapasse a cidade B em população. Claro que ela quer saber apenas para as cidades cuja taxa de crescimento da cidade A é maior do que a taxa de crescimento da cidade B, portanto, previamente já separou para você apenas os casos de teste que tem a taxa de crescimento maior para a cidade A. Sua tarefa é construir um programa que apresente o tempo em anos para cada caso de teste.
Porém, em alguns casos o tempo pode ser muito grande, e Mariazinha não se interessa em saber exatamente o tempo para estes casos. Basta que você informe, nesta situação, a mensagem "Mais de 1 seculo.".
Entrada
A primeira linha da entrada contém um único inteiro T, indicando o número de casos de teste (1 ≤ T ≤ 3000). Cada caso de teste contém 4 números: dois inteiros PA e PB (100 ≤ PA < 1000000, PA < PB ≤ 1000000) indicando respectivamente a população de A e B, e dois valores G1 e G2 (0.1 ≤ G1 ≤ 10.0, 0.0 ≤ G2 ≤ 10.0, G2 < G1) com um digito após o ponto decimal cada, indicando respectivamente o crescimento populacional de A e B (em percentual).
Atenção: A população é sempre um valor inteiro, portanto, um crescimento de 2.5 % sobre uma população de 100 pessoas resultará em 102 pessoas, e não 102.5 pessoas, enquanto um crescimento de 2.5% sobre uma população de 1000 pessoas resultará em 1025 pessoas. Além disso, não utilize variáveis de precisão simples para as taxas de crescimento.
Saída
Imprima, para cada caso de teste, quantos anos levará para que a cidade A ultrapasse a cidade B em número de habitantes. Obs.: se o tempo for mais do que 100 anos o programa deve apresentar a mensagem: Mais de 1 seculo. Neste caso, acredito que seja melhor interromper o programa imediatamente após passar de 100 anos, caso contrário você poderá receber como resposta da submissão deste problema "Time Limit Exceeded".
Exemplo de Entrada Exemplo de Saída
6
100 150 1.0 0
90000 120000 5.5 3.5
56700 72000 5.2 3.0
123 2000 3.0 2.0
100000 110000 1.5 0.5
62422 484317 3.1 1.0
51 anos.
16 anos.
12 anos.
Mais de 1 seculo.
10 anos.
100 anos. |
161 | 1161 | Soma de Fatoriais | Médio | MATEMÁTICA | Leia dois valores inteiros M e N indefinidamente. A cada leitura, calcule e escreva a soma dos fatoriais de cada um dos valores lidos. Utilize uma variável apropriada, pois cálculo pode resultar em um valor com mais de 15 dígitos.
Entrada
O arquivo de entrada contém vários casos de teste. Cada caso contém dois números inteiros M (0 ≤ M ≤ 20) e N (0 ≤ N ≤ 20). O fim da entrada é determinado por eof.
Saída
Para cada caso de teste de entrada, seu programa deve imprimir uma única linha, contendo um número que é a soma de ambos os fatoriais (de M e N).
Exemplo de Entrada Exemplo de Saída
4 4
0 0
0 2
48
2
3 |
162 | 1162 | Organizador de Vagões | Médio | ESTRUTURAS E BIBLIOTECAS | Na estação de trem você ainda pode encontrar o último dos “organizadores de vagões”. Um Organizador de vagões um empregado cujo trabalho é apenas reordenar os vagões do trem, trocando-os de posição. Uma vez que os vagões são organizados em uma ordem considerada ótima, o condutor pode desconectar cada vagão e colocá-los na estação.
O título “organizador de vagões” é dado à pessoa que realiza esta tarefa, cuja estação fica perto de uma ponte. Ao invés da ponte poder subir ou descer, ela roda sobre um pilar que fica no centro do rio. Após rodar 90 graus, os barcos podem passar na esquerda ou direita dela. O Primeiro organizador de vagões descobriu que girando a ponte 180 graus com dois vagões em cima dela, é possível a troca de lugar entre os dois vagões. Obviamente a ponte pode operar no máximo com dois vagões sobre ela.
Agora que quase todos os organizadores de vagões já faleceram, a estação gostaria de automatizar esta operação. Parte do programa a ser desenvolvido é uma rotina que decide para um dado trem com um determinado número de vagões, o número de trocas entre trens adjacentes que são necessárias para que o trem fique ordenado. Sua tarefa é criar tal rotina.
Entrada
A entrada contém na primeira linha o número de caso de testes (N). Cada caso de teste consiste de duas linhas de entrada. A primeira linha de um caso de teste contém um inteiro L, determinando o tamanho do trem (0 ≤ L ≤ 50). A segunda linha de um caso de teste contém uma permutação dos números 1 até L, indicando a ordem corrente dos vagões. Os vagões devem ser ordenados de forma que o vagão 1 venha por primeiro, depois o 2, etc, com o vagão L vindo por último.
Saída
Para cada caso de teste imprima a sentença: 'Optimal train swapping takes S swaps.' onde S é um inteiro.
Exemplo de Entrada Exemplo de Saída
3
3
1 3 2
4
4 3 2 1
2
2 1
Optimal train swapping takes 1 swaps.
Optimal train swapping takes 6 swaps.
Optimal train swapping takes 1 swaps.
Tradução, entrada e saída por Neilor. |
163 | 1163 | Angry Ducks | Difícil | MATEMÁTICA | Em uma terra distante existem duas cidades, a Nlogônia onde vivem os Nlogoneses, e Ducklogônia onde vivem seus vizinhos os Duckneses, já à algum tempo estas duas cidades estão em guerra e agora em uma tentativa de ganhar a guerra os Duckneses pretendem atacar a cidade da Nlogônia com um bodoque que atira patos, porem para que não haja erro eles pediram que você construa um programa que dados os valores da altura do bodoque (h), os pontos onde inicia (p1) e onde termina (p2) a cidade da Nlogônia, o ângulo do disparo ( α) e a velocidade do lançamento, calcule se o projetil atingira o alvo.
Para os cálculos assuma que a aceleração da gravidade é g = 9.80665 e que π = 3.14159.
Entrada
Existem vários casos de teste, cada caso inicia com 1 valor de ponto flutuante h (1 ≤ h ≤ 150) indicando a altura do bodoque, a próxima linha contem 2 valores inteiros p1 e p2 (1 ≤ p1, p2 ≤ 9999) indicando onde inicia e onde termina a Nlogônia, a linha seguinte contem um inteiro n (1 ≤ n ≤ 100) indicando o numero de tentativas que serão feitas para acertar a Nlogônia, as n linhas seguintes contem dois valores de ponto flutuante com os valores do ângulo α (1 ≤ α ≤ 180) e a velocidade V (1 ≤ V ≤ 150) do disparo.
O final do arquivo de entrada é determinado por EOF.
Saída
Para cada disparo, seu programa deve imprimir uma única linha no seguinte formato, “X -> DUCK” para quando o pato acertar a Nlogônia ou “X -> NUCK” quando o pato não acertar a Nlogônia, onde X eh a distancia máxima que o projetil atingiu até chegar ao chão (Y=0). X deve ser impresso com 5 casas decimais.
Exemplo de Entrada Exemplo de Saída
2.1
368 380
3
42.3 60
30 55
44 60.876842
367.76208 -> NUCK
270.72675 -> NUCK
379.83781 -> DUCK |
164 | 1164 | Número Perfeito | Muito Fácil | INICIANTE | Na matemática, um número perfeito é um número inteiro para o qual a soma de todos os seus divisores positivos próprios (excluindo ele mesmo) é igual ao próprio número. Por exemplo o número 6 é perfeito, pois 1+2+3 é igual a 6. Sua tarefa é escrever um programa que imprima se um determinado número é perfeito ou não.
Entrada
A entrada contém vários casos de teste. A primeira linha da entrada contém um inteiro N (1 ≤ N ≤ 20), indicando o número de casos de teste da entrada. Cada uma das N linhas seguintes contém um valor inteiro X (1 ≤ X ≤ 108), que pode ser ou não, um número perfeito.
Saída
Para cada caso de teste de entrada, imprima a mensagem “X eh perfeito” ou “X nao eh perfeito”, de acordo com a especificação fornecida.
Exemplo de Entrada Exemplo de Saída
3
6
5
28
6 eh perfeito
5 nao eh perfeito
28 eh perfeito |
165 | 1165 | Número Primo | Muito Fácil | INICIANTE | Na matemática, um Número Primo é aquele que pode ser dividido somente por 1 (um) e por ele mesmo. Por exemplo, o número 7 é primo, pois pode ser dividido apenas pelo número 1 e pelo número 7.
Entrada
A entrada contém vários casos de teste. A primeira linha da entrada contém um inteiro N (1 ≤ N ≤ 100), indicando o número de casos de teste da entrada. Cada uma das N linhas seguintes contém um valor inteiro X (1 < X ≤ 107), que pode ser ou não, um número primo.
Saída
Para cada caso de teste de entrada, imprima a mensagem “X eh primo” ou “X nao eh primo”, de acordo com a especificação fornecida.
Exemplo de Entrada Exemplo de Saída
3
8
51
7
8 nao eh primo
51 nao eh primo
7 eh primo |
166 | 1166 | Torre de Hanoi, Novamente! | Muito Fácil | PARADIGMAS | As pessoas pararam de mover discos de uma haste para outra depois que eles descobriram o número de passos necessários para completar a tarefa. Por outro lado, elas não pararam de pensar sobre puzzles similares à Torre de Hanoi. Senhor S, como é conhecido, inventou um pequeno jogo. O jogo consiste de N astes e um MONTE de bolas. As bolas são numeradas 1,2,3... As bolas parecem comum, mas na verdade elas são mágicas. Se a soma dos números de duas bolas não for um quadrado perfeito elas irão se repelir com uma força grande quando estiverem muito perto, portanto, elas NUNCA podem ser colocadas encostando uma na outra.
O jogador deve colocar uma bola no topo de cada haste por vez. Ele deve primeiro tentar a bola 1, então a bola 2, depois a bola 3, assim por diante... Se ele falhar em fazer isto, o jogo termina. O Jogador deve tentar colocar o máximo de bolas possíveis nas hastes. Você pode ver o exemplo da figura acima, que nos mostra o melhor resultado possível de se obter utilizando 4 hastes.
Entrada
A primeira linha de entrada contem um único inteiro T (1 ≤ T ≤ 50), indicando o número de casos de teste Cada caso de teste contém um único inteiro N (1 ≤ N ≤ 50), indicando o número de varetas disponíveis.
Saída
Para cada caso de teste da entrada, imprima uma linha contendo um inteiro que indica o número máximo de bolas que podem ser colocadas. Imprima -1 se um número infinito de bolas pode ser colocado.
Exemplo de Entrada Exemplo de Saída
2
4
25
11
337
Tradução, entrada e saída por Neilor. |
167 | 1167 | Acampamento de Férias | Médio | ESTRUTURAS E BIBLIOTECAS | Nas férias de Julho, várias escolas de uma mesma região resolveram se organizar e levaram uma parte de seus alunos para um acampamento de férias por uma semana. Nestes acampamentos os alunos são divididos em chalés coletivos por gênero e idade, sempre com um supervisor ou supervisora que, além de dormirem com o grupo no chalé, também são responsáveis por criar e executar várias atividades interessantes e animadas, para todas as idades. Dentre as diversas atividades podem-se citar jogos, excursões, Gincana Musical, Gincanas Noturnas, etc. No primeiro dia de acampamento, devido à forte chuva, as atividades recreativas ficaram limitadas e as crianças foram levadas para o ginásio de esportes. Foi realizada uma gincana e uma das atividades da mesma consistiu em agrupar as crianças em um círculo (organizado no sentido anti-horário) do qual seriam retiradas uma a uma até que sobrasse apenas uma criança, que seria a vencedora.
No momento em que entra no círculo, cada criança recebe uma pequena ficha que contém um valor de 1 a 500. Depois que o círculo é formado, conta-se, iniciando na criança que está ao lado da primeira que entrou no círculo, o número correspondente à ficha que a primeira detém. A criança onde o número contado cair, deve ser retirada do grupo, e a contagem inicia novamente segundo a ficha da criança que acabou de ser eliminada. Para ficar mais interessante, quando o valor que consta na ficha é par, a contagem é feita no sentido horário e quando o valor que consta na ficha é ímpar, a contagem é feita no sentido anti-horário.
A brincadeira fez muito sucesso e o administrador do acampamento pediu para que sua equipe desenvolva um programa para que no próximo evento ele saiba previamente qual criança irá ser a vencedora de cada grupo, com base nas informações fornecidas.
Entrada
A entrada contém vários casos de teste. A primeira linha de cada caso de teste contém um inteiro N (1 ≤ N ≤ 100), indicando a quantidade de crianças que farão parte de cada círculo e participarão da brincadeira. Em seguida, as N linhas de cada caso de teste conterão duas informações, o Nome e o Valor (1 ≤ Valor ≤ 500) que consta na ficha de cada criança, separados por um espaço, na ordem de entrada na formação do círculo inicial.
Obs: O Nome de cada criança não deverá ultrapassar 30 caracteres e contém apenas letras maiúsculas e minúsculas, sem acentos, e o caractere “_”. O final da entrada é indicado pelo número zero.
Saída
Para cada caso de teste, deve-se apresentar a mensagem Vencedor(a): xxxxxx, com um espaço após o sinal ":" indicando qual é a criança do grupo que venceu a brincadeira.
Exemplo de Entrada Exemplo de Saída
3
Fernanda 7
Fernando 9
Gustavo 11
5
Maria 7
Pedro 9
Joao_Vitor 5
Isabel 12
Laura 8
3
Maria 4
Pedro 3
Joao 2
0
Vencedor(a): Fernanda
Vencedor(a): Pedro
Vencedor(a): Pedro
XIII Maratona de Programação IME-USP, 2009. |
168 | 1168 | LED | Fácil | STRINGS | João quer montar um painel de leds contendo diversos números. Ele não possui muitos leds, e não tem certeza se conseguirá montar o número desejado. Considerando a configuração dos leds dos números abaixo, faça um algoritmo que ajude João a descobrir a quantidade de leds necessário para montar o valor.
Obs.: Para programadores de Javascript, recomenda-se o uso de "input.trim().split('\n')" para evitar erros conhecidos.
Entrada
A entrada contém um inteiro N, (1 ≤ N ≤ 1000) correspondente ao número de casos de teste, seguido de N linhas, cada linha contendo um número (1 ≤ V ≤ 10100) correspondente ao valor que João quer montar com os leds.
Saída
Para cada caso de teste, imprima uma linha contendo o número de leds que João precisa para montar o valor desejado, seguido da palavra "leds".
Exemplo de Entrada Exemplo de Saída
3
115380
2819311
23456
27 leds
29 leds
25 leds
Agradecimentos a Cassio F. |
169 | 1169 | Trigo no Tabuleiro | Fácil | MATEMÁTICA | Uma rainha requisitou os serviços de um monge e disse-lhe que pagaria qualquer preço. O monge, necessitando de alimentos, perguntou a rainha se o pagamento poderia ser feito em grãos de trigo dispostos em um tabuleiro de damas, de forma que o primeiro quadrado tivesse apenas um grão, e os quadrados subseqüentes, o dobro do quadrado anterior. A rainha considerou o pagamento barato e pediu que o serviço fosse executado, porém, um dos cavaleiros que estava presente e entendia um pouco de matemática alertou-a que seria impossível executar o pagamento, pois a quantidade de grão seria muito alta. Curiosa, a rainha solicitou então a este cavaleiro que era bom em cálculo, que fizesse um programa que recebesse como entrada o número de quadrados a serem usados em um tabuleiro de damas e apresentasse a quantidade de kg de trigo correspondente, sabendo que cada 12 grãos do cereal correspondem a uma grama. Finalmente, o cálculo da quantidade deverá caber em um valor inteiro de 64 bits sem sinal.
Entrada
A primeira linha de entrada contem um único inteiro N (1 ≤ N ≤ 100), indicando o número de casos de teste. Cada caso de teste contém um único inteiro X (1 ≤ X ≤ 64), indicando o número de casas do tabuleiro que serão utilizadas.
Saída
Para cada caso de teste, imprima a quantidade de kgs de trigo que o monge esperava receber.
Exemplo de Entrada Exemplo de Saída
3
7
19
14
0 kg
43 kg
1 kg
Agradecimentos a Cassio F. |
170 | 1170 | Blobs | Fácil | MATEMÁTICA | No planeta Alpha vive a criatura Blobs, que come precisamente 1/2 de seu suprimento de comida disponível todos os dias. Escreva um algoritmo que leia a capacidade inicial de suprimento de comida (em Kg), e calcule quantos dias passarão antes que Blobs coma todo esse suprimento até restar um quilo ou menos.
Entrada
A primeira linha de entrada contem um único inteiro N (1 ≤ N ≤ 1000), indicando o número de casos de teste. As N linhas seguintes contém um valor de ponto flutuante C (1 ≤ C ≤ 1000) correspondente à quantidade de comida disponível para Blobs.
Saída
Para cada caso de teste, imprima uma linha contendo o número de dias que Blobs irá demorar para comer todo seu suprimento de comida, seguido da palavra "dias".
Exemplo de Entrada Exemplo de Saída
3
40.0
200.0
300.0
6 dias
8 dias
9 dias
Agradecimentos a Cassio F. |
171 | 1171 | Frequência de Números | Fácil | AD-HOC | Neste problema sua tarefa será ler vários números e em seguida dizer quantas vezes cada número aparece na entrada de dados, ou seja, deve-se escrever cada um dos valores distintos que aparecem na entrada por ordem crescente de valor.
Entrada
A entrada contém apenas 1 caso de teste. A primeira linha de entrada contem um único inteiro N, que indica a quantidade de valores que serão lidos para X (1 ≤ X ≤ 2000) logo em seguida. Com certeza cada número não aparecerá mais do que 20 vezes na entrada de dados.
Saída
Imprima a saída de acordo com o exemplo fornecido abaixo, indicando quantas vezes cada um deles aparece na entrada por ordem crescente de valor.
Exemplo de Entrada Exemplo de Saída
7
8
10
8
260
4
10
10
4 aparece 1 vez(es)
8 aparece 2 vez(es)
10 aparece 3 vez(es)
260 aparece 1 vez(es) |
172 | 1172 | Substituição em Vetor I | Muito Fácil | INICIANTE | Faça um programa que leia um vetor X[10]. Substitua a seguir, todos os valores nulos e negativos do vetor X por 1. Em seguida mostre o vetor X.
Entrada
A entrada contém 10 valores inteiros, podendo ser positivos ou negativos.
Saída
Para cada posição do vetor, escreva "X[i] = x", onde i é a posição do vetor e x é o valor armazenado naquela posição.
Exemplo de Entrada Exemplo de Saída
0
-5
63
0
...
X[0] = 1
X[1] = 1
X[2] = 63
X[3] = 1
...
Agradecimentos a Cassio F. |
173 | 1173 | Preenchimento de Vetor I | Muito Fácil | INICIANTE | Leia um valor e faça um programa que coloque o valor lido na primeira posição de um vetor N[10]. Em cada posição subsequente, coloque o dobro do valor da posição anterior. Por exemplo, se o valor lido for 1, os valores do vetor devem ser 1,2,4,8 e assim sucessivamente. Mostre o vetor em seguida.
Entrada
A entrada contém um valor inteiro (V<=50).
Saída
Para cada posição do vetor, escreva "N[i] = X", onde i é a posição do vetor e X é o valor armazenado na posição i. O primeiro número do vetor N (N[0]) irá receber o valor de V.
Exemplo de Entrada Exemplo de Saída
1
N[0] = 1
N[1] = 2
N[2] = 4
...
Agradecimentos a Cassio F. |
174 | 1174 | Seleçao em Vetor I | Fácil | INICIANTE | Faça um programa que leia um vetor A[100]. No final, mostre todas as posições do vetor que armazenam um valor menor ou igual a 10 e o valor armazenado em cada uma das posições.
Entrada
A entrada contém 100 valores, podendo ser inteiros, reais, positivos ou negativos.
Saída
Para cada valor do vetor menor ou igual a 10, escreva "A[i] = x", onde i é a posição do vetor e x é o valor armazenado na posição, com uma casa após o ponto decimal.
Exemplo de Entrada Exemplo de Saída
0
-5
63
-8.5
...
A[0] = 0.0
A[1] = -5.0
A[3] = -8.5
...
Agradecimentos a Cassio F. |
175 | 1175 | Troca em Vetor I | Muito Fácil | INICIANTE | Faça um programa que leia um vetor N[20]. Troque a seguir, o primeiro elemento com o último, o segundo elemento com o penúltimo, etc., até trocar o 10º com o 11º. Mostre o vetor modificado.
Entrada
A entrada contém 20 valores inteiros, positivos ou negativos.
Saída
Para cada posição do vetor N, escreva "N[i] = Y", onde i é a posição do vetor e Y é o valor armazenado naquela posição.
Exemplo de Entrada Exemplo de Saída
0
-5
...
63
230
N[0] = 230
N[1] = 63
...
N[18] = -5
N[19] = 0
Agradecimentos a Cassio F. |
176 | 1176 | Fibonacci em Vetor | Fácil | INICIANTE | Faça um programa que leia um valor e apresente o número de Fibonacci correspondente a este valor lido. Lembre que os 2 primeiros elementos da série de Fibonacci são 0 e 1 e cada próximo termo é a soma dos 2 anteriores a ele. Todos os valores de Fibonacci calculados neste problema devem caber em um inteiro de 64 bits sem sinal.
Entrada
A primeira linha da entrada contém um inteiro T, indicando o número de casos de teste. Cada caso de teste contém um único inteiro N (0 ≤ N ≤ 60), correspondente ao N-esimo termo da série de Fibonacci.
Saída
Para cada caso de teste da entrada, imprima a mensagem "Fib(N) = X", onde X é o N-ésimo termo da série de Fibonacci.
Exemplo de Entrada Exemplo de Saída
3
0
4
2
Fib(0) = 0
Fib(4) = 3
Fib(2) = 1
Agradecimentos a Cassio F. |
177 | 1177 | Preenchimento de Vetor II | Muito Fácil | INICIANTE | Faça um programa que leia um valor T e preencha um vetor N[1000] com a sequência de valores de 0 até T-1 repetidas vezes, conforme exemplo abaixo. Imprima o vetor N.
Entrada
A entrada contém um valor inteiro T (2 ≤ T ≤ 50).
Saída
Para cada posição do vetor, escreva "N[i] = x", onde i é a posição do vetor e x é o valor armazenado naquela posição.
Exemplo de Entrada Exemplo de Saída
3
N[0] = 0
N[1] = 1
N[2] = 2
N[3] = 0
N[4] = 1
N[5] = 2
N[6] = 0
N[7] = 1
N[8] = 2
...
Agradecimentos a Cassio F. |
178 | 1178 | Preenchimento de Vetor III | Muito Fácil | INICIANTE | Leia um valor X. Coloque este valor na primeira posição de um vetor N[100]. Em cada posição subsequente de N (1 até 99), coloque a metade do valor armazenado na posição anterior, conforme o exemplo abaixo. Imprima o vetor N.
Entrada
A entrada contem um valor de dupla precisão com 4 casas decimais.
Saída
Para cada posição do vetor N, escreva "N[i] = Y", onde i é a posição do vetor e Y é o valor armazenado naquela posição. Cada valor do vetor deve ser apresentado com 4 casas decimais.
Exemplo de Entrada Exemplo de Saída
200.0000
N[0] = 200.0000
N[1] = 100.0000
N[2] = 50.0000
N[3] = 25.0000
N[4] = 12.5000
... |
179 | 1179 | Preenchimento de Vetor IV | Muito Fácil | INICIANTE | Neste problema você deverá ler 15 valores colocá-los em 2 vetores conforme estes valores forem pares ou ímpares. Só que o tamanho de cada um dos dois vetores é de 5 posições. Então, cada vez que um dos dois vetores encher, você deverá imprimir todo o vetor e utilizá-lo novamente para os próximos números que forem lidos. Terminada a leitura, deve-se imprimir o conteúdo que restou em cada um dos dois vetores, imprimindo primeiro os valores do vetor impar. Cada vetor pode ser preenchido tantas vezes quantas for necessário.
Entrada
A entrada contém 15 números inteiros.
Saída
Imprima a saída conforme o exemplo abaixo.
Exemplo de Entrada Exemplo de Saída
1
3
4
-4
2
3
8
2
5
-7
54
76
789
23
98
par[0] = 4
par[1] = -4
par[2] = 2
par[3] = 8
par[4] = 2
impar[0] = 1
impar[1] = 3
impar[2] = 3
impar[3] = 5
impar[4] = -7
impar[0] = 789
impar[1] = 23
par[0] = 54
par[1] = 76
par[2] = 98 |
180 | 1180 | Menor e Posição | Fácil | INICIANTE | Faça um programa que leia um valor N. Este N será o tamanho de um vetor X[N]. A seguir, leia cada um dos valores de X, encontre o menor elemento deste vetor e a sua posição dentro do vetor, mostrando esta informação.
Entrada
A primeira linha de entrada contem um único inteiro N (1 < N < 1000), indicando o número de elementos que deverão ser lidos em seguida para o vetor X[N] de inteiros. A segunda linha contém cada um dos N valores, separados por um espaço. Vale lembrar que nenhuma entrada haverá números repetidos.
Saída
A primeira linha apresenta a mensagem “Menor valor:” seguida de um espaço e do menor valor lido na entrada. A segunda linha apresenta a mensagem “Posicao:” seguido de um espaço e da posição do vetor na qual se encontra o menor valor lido, lembrando que o vetor inicia na posição zero.
Exemplo de Entrada Exemplo de Saída
10
1 2 3 4 -5 6 7 8 9 10
Menor valor: -5
Posicao: 4 |
181 | 1181 | Linha na Matriz | Fácil | INICIANTE | Neste problema você deve ler um número, indicando uma linha da matriz na qual uma operação deve ser realizada, um caractere maiúsculo, indicando a operação que será realizada, e todos os elementos de uma matriz M[12][12]. Em seguida, calcule e mostre a soma ou a média dos elementos que estão na área verde da matriz, conforme for o caso. A imagem abaixo ilustra o caso da entrada do valor 2 para a linha da matriz, demonstrando os elementos que deverão ser considerados na operação.
Entrada
A primeira linha de entrada contem um número L (0 ≤ L ≤ 11) indicando a linha que será considerada para operação. A segunda linha de entrada contém um único caractere Maiúsculo T ('S' ou 'M'), indicando a operação (Soma ou Média) que deverá ser realizada com os elementos da matriz. Seguem os 144 valores de ponto flutuante que compõem a matriz, sendo que a mesma é preenchida linha por linha, da linha 0 até a linha 11, sempre da esquerda para a direita.
Saída
Imprima o resultado solicitado (a soma ou média), com 1 casa após o ponto decimal.
Exemplo de Entrada Exemplo de Saída
2
S
0.0
-3.5
2.5
4.1
...
12.6 |
182 | 1182 | Coluna na Matriz | Muito Fácil | INICIANTE | Neste problema você deve ler um número que indica uma coluna de uma matriz na qual uma operação deve ser realizada, um caractere maiúsculo, indicando a operação que será realizada, e todos os elementos de uma matriz M[12][12]. Em seguida, calcule e mostre a soma ou a média dos elementos que estão na área verde da matriz, conforme for o caso. A imagem abaixo ilustra o caso da entrada do valor 5 para a coluna da matriz, demonstrando os elementos que deverão ser considerados na operação.
Entrada
A primeira linha de entrada contem um número C (0 ≤ C ≤ 11) indicando a coluna que será considerada para operação. A segunda linha de entrada contém um único caractere Maiúsculo T ('S' ou 'M'), indicando a operação (Soma ou Média) que deverá ser realizada com os elementos da matriz. Seguem os 144 valores de ponto flutuante que compõem a matriz.
Saída
Imprima o resultado solicitado (a soma ou média), com 1 casa após o ponto decimal.
Exemplo de Entrada Exemplo de Saída
5
S
0.0
-3.5
2.5
4.1
...
12.6 |
183 | 1183 | Acima da Diagonal Principal | Fácil | INICIANTE | Leia um caractere maiúsculo, que indica uma operação que deve ser realizada e uma matriz M[12][12]. Em seguida, calcule e mostre a soma ou a média considerando somente aqueles elementos que estão acima da diagonal principal da matriz, conforme ilustrado abaixo (área verde).
Entrada
A primeira linha de entrada contem um único caractere Maiúsculo O ('S' ou 'M'), indicando a operação (Soma ou Média) que deverá ser realizada com os elementos da matriz. Seguem os 144 valores de ponto flutuante que compõem a matriz.
Saída
Imprima o resultado solicitado (a soma ou média), com 1 casa após o ponto decimal.
Exemplo de Entrada Exemplo de Saída
S
1.0
0.0
-3.5
2.5
4.1
...
12.6 |
184 | 1184 | Abaixo da Diagonal Principal | Muito Fácil | INICIANTE | Leia um caractere maiúsculo, que indica uma operação que deve ser realizada e uma matriz M[12][12]. Em seguida, calcule e mostre a soma ou a média considerando somente aqueles elementos que estão abaixo da diagonal principal da matriz, conforme ilustrado abaixo (área verde).
Entrada
A primeira linha de entrada contem um único caractere Maiúsculo O ('S' ou 'M'), indicando a operação (Soma ou Média) que deverá ser realizada com os elementos da matriz. Seguem os 144 valores de ponto flutuante que compõem a matriz.
Saída
Imprima o resultado solicitado (a soma ou média), com 1 casa após o ponto decimal.
Exemplo de Entrada Exemplo de Saída
S
1.0
0.0
-3.5
2.5
4.1
...
12.6 |
185 | 1185 | Acima da Diagonal Secundária | Muito Fácil | INICIANTE | Leia um caractere maiúsculo, que indica uma operação que deve ser realizada e uma matriz M[12][12]. Em seguida, calcule e mostre a soma ou a média considerando somente aqueles elementos que estão acima da diagonal secundária da matriz, conforme ilustrado abaixo (área verde).
Entrada
A primeira linha de entrada contem um único caractere Maiúsculo O ('S' ou 'M'), indicando a operação (Soma ou Média) que deverá ser realizada com os elementos da matriz. Seguem os 144 valores de ponto flutuante que compõem a matriz.
Saída
Imprima o resultado solicitado (a soma ou média), com 1 casa após o ponto decimal.
Exemplo de Entrada Exemplo de Saída
S
1.0
0.0
-3.5
2.5
4.1
...
12.6 |
186 | 1186 | Abaixo da Diagonal Secundária | Fácil | INICIANTE | Leia um caractere maiúsculo, que indica uma operação que deve ser realizada e uma matriz M[12][12]. Em seguida, calcule e mostre a soma ou a média considerando somente aqueles elementos que estão abaixo da diagonal Secundária da matriz, conforme ilustrado abaixo (área verde).
Entrada
A primeira linha de entrada contem um único caractere Maiúsculo O ('S' ou 'M'), indicando a operação (Soma ou Média) que deverá ser realizada com os elementos da matriz. Seguem os 144 valores de ponto flutuante que compõem a matriz.
Saída
Imprima o resultado solicitado (a soma ou média), com 1 casa após o ponto decimal.
Exemplo de Entrada Exemplo de Saída
S
1.0
0.0
-3.5
2.5
4.1
...
12.6 |
187 | 1187 | Área Superior | Fácil | INICIANTE | Leia um caractere maiúsculo, que indica uma operação que deve ser realizada e uma matriz M[12][12]. Em seguida, calcule e mostre a soma ou a média considerando somente aqueles elementos que estão na área superior da matriz, conforme ilustrado abaixo (área verde).
Entrada
A primeira linha de entrada contem um único caractere Maiúsculo O ('S' ou 'M'), indicando a operação (Soma ou Média) que deverá ser realizada com os elementos da matriz. Seguem 144 valores com ponto flutuante de dupla precisão que compõem a matriz.
Saída
Imprima o resultado solicitado (a soma ou média), com 1 casa após o ponto decimal.
Exemplo de Entrada Exemplo de Saída
S
1.0
330.0
-3.5
2.5
4.1
...
112.4 |
188 | 1188 | Área Inferior | Muito Fácil | INICIANTE | Leia um caractere maiúsculo, que indica uma operação que deve ser realizada e uma matriz M[12][12]. Em seguida, calcule e mostre a soma ou a média considerando somente aqueles elementos que estão na área inferior da matriz, conforme ilustrado abaixo (área verde).
Entrada
A primeira linha de entrada contem um único caractere Maiúsculo O ('S' ou 'M'), indicando a operação (Soma ou Média) que deverá ser realizada com os elementos da matriz. Seguem os 144 valores de ponto flutuante de dupla precisão (double) que compõem a matriz.
Saída
Imprima o resultado solicitado (a soma ou média), com 1 casa após o ponto decimal.
Exemplo de Entrada Exemplo de Saída
S
1.0
330.0
-3.5
2.5
4.1
...
112.4 |
189 | 1189 | Área Esquerda | Muito Fácil | INICIANTE | Leia um caractere maiúsculo, que indica uma operação que deve ser realizada e uma matriz M[12][12]. Em seguida, calcule e mostre a soma ou a média considerando somente aqueles elementos que estão na área esquerda da matriz, conforme ilustrado abaixo (área verde).
Entrada
A primeira linha de entrada contem um único caractere Maiúsculo O ('S' ou 'M'), indicando a operação (Soma ou Média) que deverá ser realizada com os elementos da matriz. Seguem os 144 valores de ponto flutuante que compõem a matriz.
Saída
Imprima o resultado solicitado (a soma ou média), com 1 casa após o ponto decimal.
Exemplo de Entrada Exemplo de Saída
S
1.0
330.0
-3.5
2.5
4.1
...
111.4 |
190 | 1190 | Área Direita | Muito Fácil | INICIANTE | Leia um caractere maiúsculo, que indica uma operação que deve ser realizada e uma matriz M[12][12]. Em seguida, calcule e mostre a soma ou a média considerando somente aqueles elementos que estão na área direita da matriz, conforme ilustrado abaixo (área verde).
Entrada
A primeira linha de entrada contem um único caractere Maiúsculo O ('S' ou 'M'), indicando a operação (Soma ou Média) que deverá ser realizada com os elementos da matriz. Seguem os 144 valores de ponto flutuante que compõem a matriz.
Saída
Imprima o resultado solicitado (a soma ou média), com 1 casa após o ponto decimal.
Exemplo de Entrada Exemplo de Saída
S
1.0
330.0
-3.5
2.5
4.1
...
111.4 |
191 | 1191 | Recuperação da Árvore | Médio | GRAFOS | A pequena Valentina gostava muito de brincar com árvores binárias. Seu jogo favorito era construir árvores binárias aleatórias com letras em maiúsculo nos nodos.
Este é um exemplo de uma de suas criações:
D
/ \
/ \
B E
/ \ \
/ \ \
A C G
/
/
F
Para salvar suas árvores para uso futuro, ela escreveu duas strings para cada árvore: o percurso prefixo (raíz, sub-árvore esquerda, sub-árvore direita) e o percurso infixo (sub-árvore esquerda, raíz, sub-árvore direita).
Para o desenho acima o percurso prefixo é DBACEGF e o infixo é ABCDEFG.
Agora, anos depois, olhando para as strings, ela notou que reconstruir as árvores era realmente possível, mas só porque ela não havia usado a mesma letra duas vezes na mesma árvore.
Reconstruir a árvore a mão tornou-se chato.
Então agora ela pede que você escreva um programa que faça o trabalho por ela!
Entrada
A entrada irá conter um ou mais casos de teste. Cada caso de teste consiste em uma linha contendo duas strings representando o percurso prefixo e infixo de uma árvore binária. Ambas as strings consistem de letras maiúsculas, sem repetir. (Então elas não são maiores de 26 caracteres.)
Entrada termina com EOF (fim de arquivo).
Saída
Para cada caso de teste, imprima uma linha com o percurso posfixo (sub-árvore esquerda, sub-árvore direita, raíz).
Exemplo de Entrada Exemplo de Saída
DBACEGF ABCDEFG
BCAD CBAD
ACBFGED
CDAB
Adaptação, entradas e saídas por Jean Bez |
192 | 1192 | O jogo Matemático de Paula | Muito Fácil | AD-HOC | Paula simplesmente adora matemática. Seu maior passatempo é ficar inventando jogos ou atividades que a envolvam para brincar com seus amiguinhos. Obviamente, nem todos eles não são tão apaixonados assim por matemática e têm muita dificuldade para resolver as brincadeiras propostas por ela. Agora Paula inventou um pequeno passatempo que envolve 3 caracteres: um dígito numérico, uma letra e outro dígito numérico.
Se a letra for maiúscula, deve-se subtrair o primeiro dígito do segundo. Se a letra for minúscula, deve-se somar ambos os dígitos e se os DÍGITOS forem iguais, deve-se desconsiderar a letra e mostrar o produto entre os dois dígitos. Ela pediu para seu amigo Marcelo, que é bom em programação, para criar um programa para que encontre a solução para cada uma das sequências que Paula lhe apresentar.
Entrada
A entrada contém vários casos de teste. A primeira linha da entrada contém um inteiro N, indicando o número de casos de teste que virão a seguir. Cada caso de teste é uma sequência de três caracteres criada por Paula. Esta sequência contém na primeira posição um caractere de '0' a '9', na segunda posição uma letra maiúscula ou minúscula do alfabeto e na terceira posição outro caractere de '0' a '9'.
Saída
Para cada caso de teste, deve ser impressa uma linha com um valor inteiro que representa a solução da sequência proposta por Paula.
Exemplo de Entrada Exemplo de Saída
5
4A5
3A3
4f2
2G4
7Z1
1
9
6
2
-6 |
193 | 1193 | Conversão entre Bases | Fácil | MATEMÁTICA | O professor de matemática de Juliano marcou uma prova cujo conteúdo será apenas conversão entre valores decimais, hexadecimais e binários. Uma das coisas mais complexas para Juliano é fazer estas conversões de base entre números. Por mais que estude, tem muita dificuldade para entender. Portanto, como você entende de computação e é amigo(a) de Juliano, ele solicitou a tua ajuda para que faça um programa que verifique se as conversões feitas por ele estão correta.
Entrada
A entrada contém vários casos de teste. A primeira linha da entrada contém um inteiro N, indicando o número de casos de teste que virão a seguir, um por linha. Cada caso de teste contém um valor X (X > 0) seguido de um texto Y com três caracteres, indicando se o valor X está no formato binário, decimal ou hexadecimal. Independente do formato, qualquer dos números deverá caber em um inteiro de 32 bits.
Saída
Para cada caso de teste, você deve apresentar o número de caso de teste seguido por duas linhas, que contém a conversão do valor fornecido para as outras duas bases. A sequência das bases de saída será sempre: decimal, hexadecimal (em minúsculo) e binário, ou seja deve-se respeitar esta ordem excluindo obviamente o formato de entrada.
Obs: deverá ser impressa uma linha em branco após cada caso de teste, inclusive após o último caso de teste.
Exemplo de Entrada Exemplo de Saída
3
101 bin
101 dec
8f hex
Case 1:
5 dec
5 hex
Case 2:
65 hex
1100101 bin
Case 3:
143 dec
10001111 bin |
194 | 1194 | Prefixa, Infixa e Posfixa | Fácil | GRAFOS | Um problema comum em estrutura de dados é determinar o percurso transversal de uma árvore binária.
Há tres formas clássicas de fazer isto:
Prefixa: Você deve visitar a raiz, sub-árvore esquerda e sub-árvore direita.
Infixa: Você deve visitar a sub-árvore esquerda, a raiz e a sub-árvore direita.
Posfixa: Você deve visitar a sub-árvore esquerda, a sub-árvore direita e a raiz.
Veja a figura abaixo:
O percurso prefixo, infixo e posfixo são, respectivamente ABCDEF, CBAEDF and CBEFDA. Neste problema, você deve computar a forma posfixa da árvore dados os percursos infixo e prefixo
Entrada
A primeira linha de entrada contém um número positivo C (C ≤ 2000), que indica o número de casos de teste. Seguem C linhas, uma para cada caso de teste. Cada caso de teste inicia com um número N (1 ≤ N ≤ 52), o número de nodos da árvore binária. Depois haverá duas strings S1 e S2 que descrevem o percurso prefixo e infixo da árvore. Os nodos da árvore são nomeados com diferentes caracteres dentro do intervalo a..z e A..Z. O valor de N, S1 e S2 são separados por um espaço em branco.
Saída
Para cada conjunto de entrada, você deve imprimir uma linha contendo o percurso posfixo da corrente árvore.
Exemplo de Entrada Exemplo de Saída
3
3 xYz Yxz
3 abc cba
6 ABCDEF CBAEDF
Yzx
cba
CBEFDA |
195 | 1195 | Árvore Binária de Busca | Médio | GRAFOS | Em computação, a árvores binária de busca ou árvore binária de pesquisa é uma estrutura baseada em nós (nodos), onde todos os nós da subárvore esquerda possuem um valor numérico inferior ao nó raiz e todos os nós da subárvore direita possuem um valor superior ao nó raiz (e assim sucessivamente). O objetivo desta árvore é estruturar os dados de forma flexível, permitindo a busca binária de um elemento qualquer da árvore.
A grande vantagem das árvores de busca binária sobre estruturas de dados convencionais é que os algoritmos de ordenação (percurso infixo) e pesquisa que as utilizam são muito eficientes.
Para este problema, você receberá vários conjuntos de números e a partir de cada um dos conjuntos, deverá construir uma árvore binária de busca. Por exemplo, a sequência de valores: 8 3 10 14 6 4 13 7 1 resulta na seguinte árvore binária de busca:
Entrada
A entrada contém vários casos de teste. A primeira linha da entrada contém um inteiro C (C ≤ 1000), indicando o número de casos de teste que virão a seguir. Cada caso de teste é composto por 2 linhas. A primeira linha contém um inteiro N (1 ≤ N ≤ 500) que indica a quantidade de números que deve compor cada árvore e a segunda linha contém N inteiros distintos e não negativos, separados por um espaço em branco.
Saída
Cada linha de entrada produz 3 linhas de saída. Após construir a árvore binária de busca com os elementos de entrada, você deverá imprimir a mensagem "Case n:", onde n indica o número do caso de teste e fazer os três percursos da árvore: prefixo, infixo e posfixo, apresentando cada um deles em uma linha com uma mensagem correspondente conforme o exemplo abaixo, separando cada um dos elementos por um espaço em branco.
Obs: Não deve haver espaço em branco após o último item de cada linha e há uma linha em branco após cada caso de teste, inclusive após o último.
Exemplo de Entrada Exemplo de Saída
2
3
5 2 7
9
8 3 10 14 6 4 13 7 1
Case 1:
Pre.: 5 2 7
In..: 2 5 7
Post: 2 7 5
Case 2:
Pre.: 8 3 1 6 4 7 10 14 13
In..: 1 3 4 6 7 8 10 13 14
Post: 1 4 7 6 3 13 14 10 8 |
196 | 1196 | WERTYU | Médio | AD-HOC | Um erro comum de digitação é colocar as mãos no teclado uma posição à direita da correta posição. Desta forma, "Q" é digitado como "W" e "J" é digitado como "K" e assim por diante. Você deve decodificar a mensagem desta maneira.
Entrada
A entrada consiste em várias linhas de texto. Cada linha pode conter dígitos, espaços e letras maiúsculas. (exceto Q, A, Z), ou pontuação, exceto crase (`) conforme mostrado acima. Teclas rotuladas como palavras [Tab, BackSp, Control, etc.] não são representados na entrada. Você deverá repassar cada letra ou símbolo de pontuação pelo símbolo imediatamente à esquerda. Os espaços de entrada simplesmente deverão ser ecoados (impressos) na saída.
Saída
Para cada linha de entrada, imprima uma linha de saída correspondente com a mensagem decodificada.
Exemplo de Entrada Exemplo de Saída
O S, GOMR YPFSU/
I AM FINE TODAY.
Entradas e saídas por Neilor. |
197 | 1197 | Volta à Faculdade de Física | Muito Fácil | MATEMÁTICA | Uma partícula tem velocidade inicial e aceleração constante. Se a sua velocidade após certo momento é v então qual será seu deslocamento no dobro deste tempo?
Entrada
A entrada contém vários casos de teste. Cada linha da entrada é um caso de teste e contém dois inteiros v (-100 ≤ v ≤ 100) e t (0 ≤ t ≤ 200) ( t significa o momento no qual a partícula ganha aquela velocidade). O final da entrada é determinado por EOF.
Saída
Para cada linha de entrada imprima um único inteiro que denota o deslocamento no dobro do tempo fornecido.
Exemplo de Entrada Exemplo de Saída
0 0
5 12
0
120
Agradecimentos a Rezaul Alam Chowdhury |
198 | 1198 | O Bravo Guerreiro Hashmat | Médio | MATEMÁTICA | Hashmat é um guerreiro cujo seu grupo de soldados se move de um local a outro para lutar contra os seus oponentes. Antes da luta ele apenas calcula uma coisa. A diferença entre a quantidade de soldados que possui e a quantidade de soldados oponentes. A partir desta diferença ele decide se vai ou não lutar. Às vezes Hashmat tem mais soldados do que o seu oponente, mas na maioria das vezes não.
Entrada
A entrada contém dois números inteiros em cada linha. Estes dois números denotam respectivamente a quantidade de soldados do exército de Hashmat e do seu oponente. Nenhum número de entrada é maior do que 232. A entrada termina com fim de arquivo (EOF).
Saída
Para cada linha de entrada imprima a diferença entre o número de soldados de Hashmat e do seu oponente. Cada saída deve ser impressa em uma linha separada.
Exemplo de Entrada Exemplo de Saída
10 12
10 14
100 200
2
4
100 |
199 | 1199 | Conversão Simples de Base | Fácil | MATEMÁTICA | Neste problema você é solicitado a escrever um simples programa de conversão de base. A entrada será um valor hexadecimal ou decimal. Você deverá converter cada valor da entrada. Se o valor for hexadecimal, você deve convertê-lo para decimal e vice-versa. O valor hexadecimal inicia sempre com “0x” ou também, é aquele valor cuja segunda casa contém a letra 'x'.
Entrada
A entrada contém vários casos de teste. Cada linha de entrada, com exceção da última, contém um número não-negativo, decimal ou hexa. O valor decimal será menor ou igual a 231. A última linha contém um número negativo que não deve ser processado, indicando o encerramento do programa.
Saída
Para cada linha de entrada (exceto a última) deve ser produzido uma linha de saída. Todo número hexadecimal deve ser precedido na saída por '0x' (zero xis).
Exemplo de Entrada Exemplo de Saída
4
7
44
0x80685
-1
0x4
0x7
0x2C
525957
Entrada e saída por Neilor. |
Subsets and Splits
Random Sample Across Categories
Selects a random sample of up to 4 questions from each category and difficulty level, providing a basic overview without deep insight.