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 |
|---|---|---|---|---|---|
1,300 | 2314 | Indentador | Difícil | STRINGS | Nishi é um aluno do 1º semestre de uma faculdade na área de computação, um amante da linguagem C e possui a certa mania de programar tudo em uma só linha de código. Lúcius, seu professor, manda quinzenalmente um EP (Exercício projeto) e desconta 10% da nota a cada indentação errada. Com medo da reprovação na matéria de LP(Linguagem de Programação), Nishi pediu a sua ajuda com um programa que indente o código automaticamente, já que ele tem que montar seu EP e não terá tempo de fazer um programa para indentar o seu próprio código.
Nishi possui certos padrões na hora de programar:
- A sintaxe utilizada será baseada na linguagem C;
- As “bibliotecas” e “defines” são postas normalmente, com uma quebra de linha;
Exemplo:
#include<stdio.h>
#define MAX 1000001
- Fora as bibliotecas e defines, o restante do código se encontra em apenas uma linha;
Exemplo:
#include<stdio.h>
int main(void){printf(“Hello World\n”);return 0;}
- Ele utiliza somente os comandos de operações aprendidos até o momento (if,else,for,while,switch), funções, defines, printf, scanf, ;
- Não é usada nenhuma variável com nomes semelhantes a comandos;
- É garantida a presença de ‘;’ somente no comando “for” e nos finais de comandos, conforme a sintaxe da linguagem C;
Exemplo de comando que não será utilizado:
printf(“;”);
Exemplo de comando válido:
for(i=0;i<10;i++){printf(“Hello World”);}
- Não será utilizado operadores ternários, considere somente os comandos citados anteriormente;
Os padrões de indentação:
- Todo comando (if,else,for,while,switch) é iniciado com ‘{‘ na linha seguinte, e finalizado com ‘}’ na linha seguinte, mesmo se tiver uma única instrução; (Note que existe uma quebra de linha após o ‘}’)
Exemplo:
if(1)
{
....printf(“Hello World\n”);
}
- Todo conteúdo dentro das chaves de abertura e de fechamento deverá ter uma tabulação a direita, a regra vale para as sub-chaves também;
Entrada
A entrada contém várias linhas e termina com EOF. Cada linha poderá ter até 2000 caracteres (0 < C < 2000). As entradas obedecem aos padrões exigidos por Nishi, como citados anteriormente
Saída
A saída deverá seguir a indentação (feita com quatro pontos "....",representando uma tabulação a direita) segundo os padrões de Nishi, o último ‘}’ de todo bloco é finalizado com uma quebra de linha, conforme o modelo abaixo.
Exemplos de Entrada Exemplos de Saída
#include <stdio.h>
#include <string.h>
#include <ctype.h>
int main(void){if(1){printf("in\n");}else{printf("out\n");}while(1){printf("in\n");break;}printf("out\n");int i;for(i=0;i<10;i++){printf("Hello World\n");}return 0;}
#include <stdio.h>
#include <string.h>
#include <ctype.h>
int main(void)
{
....if(1)
....{
........printf("in\n");
....}
....else
....{
........printf("out\n");
....}
....while(1)
....{
........printf("in\n");
........break;
....}
....printf("out\n");
....int i;
....for(i=0;i<10;i++)
....{
........printf("Hello World\n");
....}
....return 0;
}
#include <stdio.h>
#include <string.h>
#include <ctype.h>
int i;int fib(int x){i++;if(x==0){return 0;}else{if(x==1){return 1;}}else{return(fib(x-1)+fib(x-2));}}int main(void){int n,x;scanf("%d",&n);i=0;while(n--){i=0;scanf("%d",&x);printf("fib(%d) = %d calls = %d\n", x, i-1,fib(x));}return(0);}
#include <stdio.h>
#include <string.h>
#include <ctype.h>
int i;
int fib(int x)
{
....i++;
....if(x==0)
....{
........return 0;
....}
....else
....{
........if(x==1)
........{
............return 1;
........}
....}
....else
....{
........return(fib(x-1)+fib(x-2));
....}
}
int main(void)
{
....int n,x;
....scanf("%d",&n);
....i=0;
....while(n--)
....{
........i=0;
........scanf("%d",&x);
........printf("fib(%d) = %d calls = %d\n", x, i-1,fib(x));
....}
....return(0);
}
|
1,301 | 2315 | Diferença Fácil Entre Datas | Muito Fácil | AD-HOC | Seu programa deve ler duas datas (dia e mês) e calcular a diferença entre elas, em dias. Considere se tratar de um ano não bissexto (fevereiro com 28 dias).
Entrada
A entrada contem duas linhas contendo dois inteiros cada, representando o dia e o mês da primeira e da segunda data. A primeira data será sempre menor (anterior no ano) ou igual à segunda.
Saída
A saída deverá conter o número de dias entre a primeira e a segunda data.
Exemplos de Entrada Exemplos de Saída
21 2
1 3
8
28 7
29 7
1
15 5
1 8
78 |
1,302 | 2316 | Autorama | Médio | AD-HOC | Seu Diniz possui uma pista de autorama profissional. Nessa pista a marcação de tempo é feita com sensores que fazem leitura da passagem de cada cada carrinho pelo ponto onde o sensor está instalado. K sensores são distribuídos ao longo da pista nos chamados postos de checagem.
Durante uma corrida, os carrinhos devem passar pelos postos de checagem na ordem pré-estabelecida, ou seja, primeiro no posto de checagem 1, depois no 2, até o posto de checagem K, quando ele deve retornar ao posto de checagem 1 para completar uma volta. Entretanto, às vezes, quando os carrinhos saem da pista os competidores os recolocam mais à frente na pista, pulando alguns postos de checagem. Nesse caso, todas as passagens daquele carrinho por postos de checagem devem ser ignoradas até que ele passe pelo posto de checagem correto.
A posição de um carrinho na corrida é determinada pelo número de postos de checagem que ele passou na ordem correta. Caso dois carrinhos tenham passado pelo mesmo número de postos de checagem, a ordem utilizada é a ordem cronológica, ou seja, está mais à frente o carrinho que passou pelo último posto de checagem primeiro.
A pista de autorama do Seu Diniz possui um computador central que recebe os sinais lidos pelos sensores, mas ainda não possui um programa que permita determinar a posição dos carrinhos ao final da corrida.
Escreva um programa que, dado uma lista de leituras feitas pelos sensores, determine a classificação dos carrinhos na corrida.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha da entrada contêm três inteiros, K, N e M. K representa o número de postos de checagem (1 ≤ K ≤ 100), N o número de carrinhos (1 ≤ N ≤ 100) e M o número de leituras feitas pelos sensores (1 ≤ M ≤ 10000). Os carrinhos são identificados por inteiros de 1 a N e os postos de checagem por inteiros de 1 a K. As M linhas seguintes contêm cada uma dois inteiros X e Y, separados por espaço. Eles indicam que o carrinho número X (1 ≤ X ≤ N) passou pelo posto de checagem Y (1 ≤ Y ≤ K). Os eventos são apresentados na ordem cronológica. Sempre é possível determinar a classificação de todos os pilotos com os dados fornecidos.
Saída
Seu programa deve imprimir, na saída padrão, uma linha contendo N inteiros, sendo que o i-ésimo inteiro representa o carrinho que ocupa a posição i na corrida. Ou seja, o primeiro inteiro é o que ocupa o primeiro lugar, o segundo inteiro é o carrinho que ocupa o segundo lugar, e assim por diante.
Cada inteiro I contendo o número do carrinho que ocupa a posição de número I na corrida: o primeiro colocado ocupa a posição de número 1, o segundo colocado a posição de número 2, etc.
Exemplos de Entrada Exemplos de Saída
3 3 6
3 1
1 1
2 1
3 2
3 3
2 2
3 2 1
2 2 5
2 1
2 1
1 1
2 1
1 2
1 2
4 4 21
3 1
2 1
4 2
4 3
4 4
4 1
1 1
1 2
1 3
3 2
3 3
2 2
2 3
3 4
2 4
3 1
1 4
2 1
4 3
2 2
3 2
2 3 1 4
OBI - Olimpíada Brasileira de Informática 2006 Fase 2 Nível 1 |
1,303 | 2317 | Lobo Mau | Difícil | AD-HOC | Na fazenda do Sr. Amarante existe um certo número de ovelhas. Enquanto elas estão dormindo profundamente, alguns lobos famintos tentam invadir a fazenda e atacar as ovelhas. Ovelhas normais ficariam indefesas diante de tal ameaça, mas felizmente as ovelhas do Sr. Amarante são praticantes de artes marciais e conseguem defender-se adequadamente.
A fazenda possui um formato retangular e consiste de campos arranjados em linhas e colunas. Cada campo pode conter uma ovelha (representada pela letra ‘k’), um lobo (letra ‘v’), uma cerca (símbolo ‘#’) ou simplesmente estar vazio (símbolo ‘.’). Consideramos que dois campos pertencem a um mesmo pasto se podemos ir de um campo ao outro através de um caminho formado somente com movimentos horizontais ou verticais, sem passar por uma cerca. Na fazenda podem existir campos vazios que não pertencem a nenhum pasto. Um campo vazio não pertence a nenhum pasto se é possível “escapar” da fazenda a partir desse campo (ou seja, caso exista um caminho desse campo até a borda da fazenda).
Durante a noite, as ovelhas conseguem combater os lobos que estão no mesmo pasto, da seguinte forma: se em um determinado pasto houver mais ovelhas do que lobos, as ovelhas sobrevivem e matam todos os lobos naquele pasto. Caso contrário, as ovelhas daquele pasto são comidas pelos lobos, que sobrevivem. Note que caso um pasto possua o mesmo número de lobos e ovelhas, somente os lobos sobreviverão, já que lobos são predadores naturais, ao contrário de ovelhas.
Escreva um programa que, dado um mapa da fazenda do Sr. Amarante indicando a posição das cercas, ovelhas e lobos, determine quantas ovelhas e quantos lobos estarão vivos na manhã seguinte.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha da entrada contém dois inteiros R e C que indicam o número de linhas (3 ≤ R ≤ 250) e de colunas (3 ≤ C ≤ 250) de campos da fazenda. Cada uma das R linhas seguintes contém C caracteres, representando o contéudo do campo localizado naquela linha e coluna (espaço vazio, cerca, ovelha ou lobo).
Saída
Seu programa deve imprimir, na saída padrão, uma única linha, contendo dois inteiros, sendo que o primeiro representa o número de ovelhas e o segundo representa o número de lobos que ainda estão vivos na manhã seguinte.
Exemplos de Entrada Exemplos de Saída
6 6
...#..
.##v#.
#v.#.#
#.k#.#
.###.#
...###
0 2
8 8
.######.
#..k...#
#.####.#
#.#v.#.#
#.#.k#k#
#k.##..#
#.v..v.#
.######.
3 1
9 12
.###.#####..
#.kk#...#v#.
#..k#.#.#.#.
#..##k#...#.
#.#v#k###.#.
#..#v#....#.
#...v#v####.
.####.#vv.k#
.......####
3 5
OBI - Olimpíada Brasileira de Informática 2006 Fase 2 Nível 1 |
1,304 | 2318 | Quadrado Mágico | Difícil | AD-HOC | Senhor Coelho é conhecido mundialmente pela fabricação de quadrados mágicos de dimensôes 3 × 3. Um quadrado é chamado mágico quando a soma dos elementos de uma determinada linha, coluna ou diagonal é sempre igual.
Infelizmente, assaltantes invadiram recentemente a oficina do Sr. Coelho e roubaram alguns dos números de seus quadrados mágicos. Felizmente os meliantes não conseguiram roubar mais do que 3 números de cada quadrado. Desesperado, pois devia entregar os quadrados naquele dia, o Sr. Coelho veio procurar a sua ajuda para tentar completar os quadrados com os números faltantes.
Escreva um programa que, dado um quadrado mágico com alguns números faltando, determine qual era o quadrado mágico original.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A entrada contém três linhas, cada uma contendo três inteiros N (0 ≤ N ≤ 20000). O número zero representa os digitos que foram roubados. Existem no máximo três números zero na entrada.
Saída
Seu programa deve imprimir, na saída padrão, três linhas, cada uma contendo três inteiros, descrevendo a configuração original do quadrado mágico.
Exemplos de Entrada Exemplos de Saída
4 9 2
3 0 7
8 1 6
4 9 2
3 5 7
8 1 6
0 12 12
16 10 0
8 8 14
6 12 12
16 10 4
8 8 14
495 468 0
0 522 414
441 0 549
495 468 603
630 522 414
441 576 549
OBI - Olimpíada Brasileira de Informática 2006 Fase 2 Nível 1 |
1,305 | 2319 | Penalidade Mínima | Muito Difícil | AD-HOC | A Sra. Bastos é uma elaboradora de passatempos matemáticos e pediu para que você criasse um programa que conseguisse jogar de forma eficiente a sua mais nova criação.
O jogo consiste em um tabuleiro formado por casas dispostas em N linhas por N colunas. Cada casa contém um inteiro não-negativo. No começo do jogo, uma peça é colocada na casa localizada no canto superior esquerdo, ou seja, na posição (1,1). O objetivo do jogo é mover a peça até a casa localizada no canto inferior direito (posição (N,N)) somente movendo um único quadrado para baixo ou para a direita em cada passo. Além disso, a peça não pode ser colocada em nenhum quadrado que contenha o número zero.
O custo do caminho utilizado para percorrer o tabuleiro corresponde ao produto de todos os números das casas percorridos no caminho. A penalidade é definida utilizando a representação decimal do custo, sendo representada pelo número de dígitos zeros, contados da direita para a esquerda, antes do primeiro dígito diferente de zero. Por exemplo, um custo igual a 501000 tem penalidade 3, e um custo igual a 501 tem penalidade zero.
O objetivo do jogo é conseguir chegar à casa (N,N) através de um caminho “otimizado”. Dizemos que o caminho foi otimizado se a penalidade for mínima.
Escreva um programa que, dado um tabuleiro, determine a penalidade do custo otimizado.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha da entrada contém um inteiro N que indica o número de linhas e colunas do tabuleiro (1 ≤ N ≤ 1000). As N linhas seguintes contêm N inteiros I cada (1 ≤ I ≤ 1000000), que representam o valor da casa do tabuleiro naquela posição. Existe pelo menos uma solução possível para todos os casos de teste.
Saída
Seu programa deve imprimir, na saída padrão, uma única linha, contendo a penalidade do custo “otimizado”.
Exemplos de Entrada Exemplos de Saída
3
1 2 3
4 5 6
7 8 9
0
3
5 7 6
4 0 1
3 2 5
1
4
1 3 0 0
0 8 2 25
6 5 0 3
0 15 7 4
2
Olimpíada Brasileira de Informática 2010 Fase 2 Modalidade Nível 2 |
1,306 | 2320 | Subsequência | Médio | AD-HOC | Uma subsequência de uma sequência de caracteres S é definida como uma sequência de caracteres de S, não necessariamente consecutivos, na mesma ordem em que eles ocorrem na sequência original.
Dadas duas sequências de caracteres, S1 e S2, dizemos que S1 possui grau N de independência em relação a S2 se, dada qualquer subsequência de tamanho N de S1, não ´e possível formar tal subsequência a partir de S2.
Por exemplo, o grau de independência da sequência S1=‘ababaa’ em relação à sequência S2=‘abbaa’ é igual a 3, pois todas as subsequências de S1 de tamanho 1 (‘a’, ‘b’) e todas as subsequências de tamanho 2 (‘aa’, ‘ab’, ‘ba’, ‘bb’) podem ser formadas a partir de S2, mas a subsequência ‘bab’, de tamanho 3, não pode ser formada a partir de S2.
Escreva um programa que, dadas duas sequências S1 e S2, determine o grau N de independência de S1 em relação a S2.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A entrada contém três linhas. A primeira linha contém dois inteiros N e M que indicam respectivamente o comprimento da sequência S1 (1 ≤ N ≤ 2000) e o comprimento da sequência S2 (1 ≤ M ≤ 2000). A segunda linha contém a sequência S1 e a terceira linha contém a sequência S2. As sequências são formadas somente pelas letras minúsculas sem acento (’a’ - ’z’). As sequências possuem no máximo 2000 caracteres. Sempre existe uma solução para os casos de teste fornecidos.
Saída
Seu programa deve imprimir, na saída padrão, uma única linha, contendo o grau N de indepedência de S1 em relação a S2.
Exemplos de Entrada Exemplos de Saída
5 5
cbbca
ccabc
2
10 5
ababaaaaaa
ababa
4
10 11
bcbcccacab
baaabcbaaca
3
OBI - Olimpíada Brasileira de Informática 2006 Fase 2 Nível 2 |
1,307 | 2321 | Detectando Colisões | Médio | AD-HOC | Detecção de colisão é uma das operações mais comuns (e importantes) em jogos eletrônicos. O objetivo, basicamente, é verificar se dois objetos quaisquer colidiram, ou seja, se a interseção entre eles é diferente de vazio. Isso pode ser usado para saber se duas naves colidiram, se um monstro bateu numa parede, se um personagem pegou um item, etc.
Para facilitar as coisas, muitas vezes os objetos são aproximados por figuras geométricas simples (esferas, paralelepípedos, triângulos etc). Neste problema, os objetos são aproximados por retângulos num plano 2D.
Escreva um programa que, dados dois retângulos, determine se eles se interceptam ou não.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). Cada caso de teste contém duas linhas. Cada linha contém quatro inteiros (x0, y0, x1, y1, sendo 0 ≤ x0 < x1 ≤ 1.000.000 e 0 ≤ y0 < y1 ≤ 1.000.000) separados por um espaço em branco representando um retângulo. Os lados do retângulo são sempre paralelos aos eixos x e y.
Saída
Seu programa deve imprimir, na saída padrão, uma única linha para cada caso de teste, contendo o número 0 (zero) caso não haja interseção ou o número 1 (um) caso haja.
Exemplos de Entrada Exemplos de Saída
0 0 1 1
0 0 1 1
1
0 0 2 2
1 1 3 3
1
0 0 1 1
2 2 3 3
0
OBI - Olimpíada Brasileira de Informática 2007 Fase 1 Nível 1 |
1,308 | 2322 | Peça Perdida | Fácil | AD-HOC | Joãozinho adora quebra-cabeças, essa é sua brincadeira favorita. O grande problema, porém, é que às vezes o jogo vem com uma peça faltando. Isso irrita bastante o pobre menino, que tem de descobrir qual peça está faltando e solicitar uma peça de reposição ao fabricante do jogo. Sabendo que o quebra-cabeças tem N peças, numeradas de 1 a N e que exatamente uma está faltando, ajude Joãozinho a saber qual peça ele tem de pedir.
Escreva um programa que, dado um inteiro N e N - 1 inteiros numerados de 1 a N, descubra qual inteiro está faltando.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A entrada contém 2 linhas. A primeira linha contém um inteiro N (2 ≤ N ≤ 1.000). A segunda linha contém N - 1 inteiros numerados de 1 a N (sem repetições).
Saída
Seu programa deve imprimir, na saída padrão, uma única linha, contendo o número que está faltando na sequência dada.
Exemplos de Entrada Exemplos de Saída
3
3 1
2
5
1 2 3 5
4
4
2 4 3
1
OBI - Olimpíada Brasileira de Informática 2007 Fase 1 Nível 1 |
1,309 | 2323 | Móbile | Médio | AD-HOC | Móbiles são objetos muito populares hoje em dia, sendo encontrados até em berços, para diversão de bebês, mas foram concebidos há muito tempo (em 1931) pelo então jovem artista americano Alexander Calder como esculturas em movimento. Um móbile é uma estrutura composta de peças unidas por fios. O móbile é preso por um fio a uma argola pela qual ele é suspenso, permitindo que a estrutura movimente-se livremente. A argola é presa a uma única peça, chamada de peça-raiz do móbile. A peça-raiz pode ter zero ou mais sub-móbiles pendurados nela, cada sub-móbile sendo composto por uma peça-raiz na qual por sua vez podem estar pendurados zero ou mais sub-móbiles, e assim sucessivamente. Abaixo podemos ver dois exemplos de móbiles:
Victor é dono de uma fabrica de móbiles que emprega centenas de artesãos. Cada móbile produzido na fábrica é confeccionado por um artesão, que cria móbiles de acordo com o seu gosto pessoal, utilizando peças de formatos distintos. Entretanto, Victor tem notado que nem todos os seus artesãos possuem a mesma habilidade artística, de forma que às vezes o móbile produzido nem sempre é bem balanceado, segundo a sua concepção. Para Victor, um móbile é bem balanceado se, para cada peça, todos os sub-móbiles pendurados nela são compostos pelo mesmo número de peças. O número de peças de um sub-móbile é determinado contando-se o número de peças que o compõe, incluindo a sua peça-raiz. Note que cada peça do móbile, exceto a peça-raiz, é pendurada em exatamente uma outra peça.
Por exemplo, o móbile da figura (a) acima é um móbile bem balanceado: a peça-raiz possui um único sub-móbile, que por sua vez possui três sub-móbiles, todos com o mesmo número de peças (uma única). Já o móbile da figura (b) é um móbile mal balanceado: a peça-raiz possui dois sub-móbiles, um com o total de duas peças e outro com o total de uma peça.
Dada a descrição de um móbile, você deve escrever um programa para determinar se o móbile está bem balanceado ou não.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha da entrada contém um inteiro N que indica o número de peças utilizadas no móbile (1 ≤ N ≤ 10.000). As peças são identificadas por inteiros de 1 a N . Cada uma das N linhas seguintes contém dois números inteiros I e J , indicando que a peça de número I está pendurada na peça de número J (a peça raiz está pendurada na argola, que é identificada pelo o número 0).
Saída
Seu programa deve imprimir, na saída padrão, uma única linha, contendo a palavra bem se o móbile estiver bem balanceado ou mal caso esteja mal balanceado. A palavra deve ser escrita com todas as letras em minúsculas.
Exemplos de Entrada Exemplos de Saída
3
1 0
2 1
3 2
bem
5
1 0
2 1
4 2
3 2
5 2
bem
7
2 0
1 2
3 1
4 3
5 4
6 4
7 5
mal
OBI - Olimpíada Brasileira de Informática 2007 Fase 1 Nível 2 |
1,310 | 2324 | Pastas | Difícil | AD-HOC | Estela é uma secretária dedicada da OBI (Organização Burocrática Internacional), um megaconglomerado empresarial voltado a criação de documentos e preenchimento de formulários. Todo dia ela recebe milhares de pastas suspensas e seu objetivo é organizá-las de uma forma que seja simples recuperar uma pasta do arquivo.
Cada pasta possui uma pequena aba, que fica anexada à pasta e é visível quando a pasta está suspensa em seu arquivo. Todo funcionário fixa a aba em uma das posições especificadas pelo manual de fixação de abas, embora ele possa escolher, ao acaso, qualquer uma das posições descritas no manual. Tais posições são numeradas de 1 até P .
Estela notou que fica consideravelmente mais fácil encontrar as pastas se elas forem arquivadas da seguinte forma: primeiro uma pasta com aba na posição 1, depois uma com aba na posição 2, e assim sucessivamente, até que uma pasta com aba na posição P seja arquivada. Logo após, repete-se o processo, arquivando uma pasta com aba na posição 1. Para Estela, um conjunto de pastas é arquivado de forma perfeita se todas as pastas desse conjunto forem arquivadas da forma descrita anteriormente, ou seja:
Imediatamente após toda pasta com aba na posição I , I < P , existe uma pasta com aba na posição I + 1 ou não há nenhuma pasta.
Imediatamente após toda pasta com aba na posição P , existe uma pasta com aba na posição 1 ou não há nenhuma pasta.
Todas as pastas do conjunto são armazenadas.
Dado um conjunto de pastas e a posição de suas abas, determinar se é possível arquivar esse conjunto de pastas de forma perfeita.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha da entrada contém dois inteiros P e N que indicam, respectivamente, o número de posições possíveis para se colar as abas (1 ≤ P ≤ 1.000) o número pastas a serem armazenadas (1 ≤ N ≤ 1.000.000). As N linhas seguintes contém um inteiro I (1 ≤ I ≤ P ) cada representando a posição onde a aba da I -ésima pasta foi colada.
Saída
Seu programa deve imprimir, na saída padrão, uma única linha, contendo a letra S se for possível fazer um arquivamento perfeito ou N caso contrário.
Exemplos de Entrada Exemplos de Saída
2 2
1
2
S
3 6
1
2
3
1
2
1
N
4 7
1
1
2
2
3
3
4
S
OBI - Olimpíada Brasileira de Informática 2007 Fase 1 Nível 2 |
1,311 | 2325 | Repositórios | Médio | AD-HOC | Uma das boas práticas ao administrar um conjunto de computadores é manter os aplicativos sempre atualizados. Entretanto, em uma grande corporação com milhares de aplicativos instalados, a simples verificação do que precisa ser atualizado pode tornar-se uma tarefa bem complicada. Para facilitar isso, alguns fabricantes armazenam todos os aplicativos existentes em grandes bases de dados chamadas repositórios e um programa é responsável por verificar esse repositório e atualizar as versões dos aplicativos.
M.V.Lzr, um administrador de sistemas e rapper nas horas vagas, trabalha em uma empresa que, infelizmente, não utiliza um sistema com repositórios. Para facilitar sua vida, ele decidiu que era a hora de ter o seu próprio sistema e pediu a sua ajuda.
Periodicamente ele varre a Internet em busca das páginas que possam conter os aplicativos e constrói uma lista com as versões dos aplicativos que deseja instalar disponíveis em cada página. Um programa deve verificar então qual a versão de cada programa instalado nos computadores (todos eles possuem os mesmos aplicativos instalados e nas mesmas versões) e instalar todos aqueles que ainda não foram instalados ou cuja versão instalada seja anterior à versão mais recente. Como ele não sabe programar direito, ele pediu sua ajuda.
Dada uma lista de aplicativos instaladas nos computadores da empresa, com suas respectivas versões e uma lista de aplicativos disponíveis na internet que devem ser instalados, determinar quais devem ser instalados e em quais versões.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha da entrada contém dois inteiros C (1 ≤ C ≤ 10.000) e N (1 ≤ N ≤ 1.000) que representam o número total de programas instalados na empresa, e o número total de aplicativos e versões disponíveis na internet, respectivamente. As C linhas seguintes possuem dois inteiros cada, Pc (1 ≤ Pc ≤ 1.000.000.000) e Vc (1 ≤ Vc ≤ 1.000.000.000), representando o número do programa e o número da versão instalada nos computadores. Todo aplicativo está instalado uma única vez em cada máquina e em uma única versão. Em seguida, as As N linhas seguintes possuem dois inteiros cada, Pn (1 ≤ Pn ≤ 1.000.000.000) e Vn (1 ≤ Vn ≤ 1.000.000.000), representando o número do programa e o número da versão disponível na internet. Um dado programa pode estar disponível em mais de uma versão na internet.
Saída
Seu programa deve imprimir, na saída padrão, diversas linhas, cada uma contendo dois inteiros, Ps e Vs com o número do programa e a versão que deve ser instalada. Em todo caso de teste existe pelo menos um programa que deve ser instalado
Exemplos de Entrada Exemplos de Saída
1 1
5215 1
5215 3
5215 3
3 2
1640 1
2540 4
1870 3
2540 1
1640 4
1640 4
2 5
2000 4
2001 5
2000 1
2001 4
2001 6
2000 2
2000 3
2001 6
OBI - Olimpíada Brasileira de Informática 2007 Fase 1 Nível 2 |
1,312 | 2326 | Sacoleiro | Difícil | AD-HOC | Seu amigo sacoleiro pediu sua ajuda num problema que ele está enfrentando. Ele tem um mapa de cidades que ele já conhece e que são interessantes para ele, além das rotas entre as mesmas. Ele pretende fazer uma viagem para comprar presentes para seu filho e para sua filha. O problema é que nem todos os presentes têm o mesmo preço, alguns são obviamente mais caros que os outros, e ele não quer ser injusto dando presentes mais caros para um ou para outro. O objetivo é fazer com que diferença entre a soma dos valores dos presentes seja a menor possível (de preferência que sejam iguais, naturalmente). Há, também, um limite de quanto ele pode gastar na viagem.
O sacoleiro tem um mapa com N cidades e as rotas que as ligam. Além disso, cada cidade pertence ao grupo A ou ao grupo B. No grupo A estão as cidades em que há presentes para o filho, enquanto que no grupo B estão as cidades com presentes para a filha. Sempre que ele para numa cidade ele pode comprar ou não o presente, mesmo que ele já tenha estado lá antes, inclusive pode comprar mais de uma unidade do mesmo presente (enquanto tiver dinheiro disponível, naturalmente). As cidades são numeradas de 0 a N - 1. O trajeto deve sempre começa na cidade 0. O tamanho do percurso não importa para o sacoleiro. O total disponível de dinheiro para os presentes é T. O sacoleiro não pode terminar a viagem sem ter comprado pelo menos um presente para algum dos filhos.
Escreva um programa que, dadas N cidades, as rotas entre elas e os valores de presentes de cada cidade, retorne qual a diferença mínima possível entre a soma dos presentes do grupo A e a soma dos presentes do grupo B.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha da entrada contém um inteiro N (2 ≤ N ≤ 30) que indica a quantidade de cidades. A segunda linha contém um inteiro T (10 ≤ T ≤ 100) que indica a quantidade de dinheiro que o sacoleiro tem para gastar. As N linhas seguintes contêm a descrição cada cidade. Cada uma dessas linhas tem o formato XPCKV0V1...VK-1, onde X é um inteiro que representa a cidade (numeradas de 0 a N - 1); P é um inteiro (1 ≤ P ≤ 10) que indica o valor do presente da cidade X; C é um caractere A ou B, indicando a que grupo a cidade X pertence; K é um inteiro (0 ≤ K < N ) que indica quantas rotas saem da cidade X; e cada Vi é um inteiro indicando um dos possíveis destinos a partir da cidade X. Note que as rotas não são bidirecionais. Uma cidade nunca terá rota para ela mesma e pode-se assumir que i ≠ j => Vi ≠ Vj.
Saída
Seu programa deve imprimir, na saída padrão, uma única linha com um inteiro representando a menor diferença possível de valores entre os presentes comprados para o grupo A e para o grupo B.
Exemplo de Entrada Exemplo de Saída
4
20
0 9 A 2 1 2
1 8 B 1 2
2 7 A 1 3
3 6 B 1 1
1
OBI - Olimpíada Brasileira de Informática 2007 Fase 1 Nível 2 |
1,313 | 2327 | Quadrados | Fácil | AD-HOC | Chama-se de quadrado mágico um arranjo, na forma de um quadrado, de N × N números inteiros tal que todas as linhas, colunas e diagonais têm a mesma soma.
Por exemplo, o quadrado abaixo
2 7 6
9 5 1
4 3 8
é um quadrado mágico de soma 15, pois todas as linhas (2 + 7 + 6 = 15, 9 + 5 + 1 = 15 e 4 + 3 + 8 = 15), colunas (2 + 9 + 4 = 15, 7 + 5 + 3 = 15 e 6 + 1 + 8 = 15) e diagonais (2 + 5 + 8 = 15 e 6 + 5 + 4 = 15) têm a mesma soma (15).
Escreva um programa que, dado um quadrado, determine se ele é magico ou não e qual a soma dele (caso seja mágico).
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha da entrada de cada caso de teste contém um inteiro N (2 < N < 10). As N linhas seguintes contêm N inteiros cada, separados por exatamente um espaço em branco. Os inteiros dentro do quadrado são todos maiores que 0 (zero) e menores que 1.000.
Saída
Seu programa deve imprimir, na saída padrão, uma única linha com um inteiro representando a soma do quadrado mágico ou −1 caso o quadrado não seja mágico.
Exemplos de Entrada Exemplos de Saída
3
2 7 6
9 5 1
4 3 8
15
3
1 2 3
4 5 6
7 8 9
-1
4
16 3 2 13
5 10 11 8
9 6 7 12
4 15 14 1
34
OBI - Olimpíada Brasileira de Informática 2007 Fase 1 Nível 1 |
1,314 | 2328 | Chocolate | Muito Fácil | AD-HOC | Juliana é uma famosa doceira reconhecida internacionalmente pelos seus bombons, exportados para todo o mundo. Embora não revele a ninguém as suas receitas, ela já deu entrevistas contando alguns de seus segredos. Sua fábrica de bombons utiliza somente chocolates comprados de um único produtor suíço, que envia barras gigantescas que são cortadas por grandes máquinas.
Dada uma barra grande de chocolate, Juliana realiza divisões sucessivas da barra até obter uma barra que contém a quantidade exata de chocolate para aquela receita. Após cada divisão, ela seleciona um dos pedaços resultantes e armazena os demais para uso futuro. As divisões são determinadas por critérios técnicos relacionados ao tamanho das barras e aos equipamentos disponiveis em um dado momento.
Por exemplo, se ela deseja obter uma barra de 100g de chocolate a partir de uma barra de 3Kg, primeiro ela divide a barra ao meio. Em seguida, um dos pedaços é dividido em cinco partes iguais e por fim, um desses pedaços de 300g é dividido em 3 pedaços, resultando no pedaço de 100g necessário para a receita. Nesse processo, 1 pedaço é utilizado para a receita e 7 pedaços de diferentes tamanhos serão guardados para uso futuro. A figura abaixo ilustra esse cenário.
Dada uma sequência de divisões realizadas por Juliana em uma barra de chocolate, determinar quantos pedaços serão armazenados em estoque para uso futuro.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha da entrada contém um inteiro N que indica o número de divisões feitas na barra de chocolate original (1 ≤ N ≤ 1.000). A linha seguinte contém N inteiros I (2 ≤ I ≤ 10) representando o número de pedaços em que o pedaço atual foi dividido. Sempre que é feita uma divisão, um pedaço é utilizado para a próxima divisão e os demais são separados para serem armazenados em estoque.
Saída
Seu programa deve imprimir, na saída padrão, uma única linha, contendo o número de pedaços de chocolate que serão armazenados em estoque.
Exemplos de Entrada Exemplos de Saída
3
2 3 5
7
5
2 2 2 3 3
7
7
2 3 4 5 6 7 8
28
OBI - Olimpíada Brasileira de Informática 2007 Fase 1 Nível 2 |
1,315 | 2329 | Pão a Metro | Médio | AD-HOC | Pão a metro é um tipo de sanduíche gigante que é uma excelente opção de lanche para torneios de programação, embora a experiência já tenha mostrado que o oferecimento de sanduiches pode gerar reclamação dos competidores. Outro grande problema é que algumas pessoas são mais gulosas que outras e, dessa maneira, acabam pegando pedaços maiores que os pedaços dos outros. Para a final da OBI, a coordenação estava pensando em providenciar pão a metro para os competidores, porém tais problemas os fizeram recuar na idéia.
Embora a idéia tenha sido momentaneamente abandonada, uma idéia simples surgiu: cortar previamente o pão em fatias de tamanho iguais e distribuí-las entre as pessoas. O único problema com tal idéia é que se o número de pessoas for muito grande, fica impraticável ter apenas um pão. Por exemplo, se quiséssemos que 1.000 pessoas recebam 20 centímetros de sanduíche, seria necessário um sanduíche de 20.000 centímetros, ou 200 metros!
Alguém levantou a seguinte hipótese: se houvesse N pessoas e fossem encomendados K sanduíches de empresas diferentes, cada qual com uma determinada metragem (tamanho) Mi (1 ≤ i ≤ K), seria possível retirar desses pães N fatias de mesmo tamanho, possivelmente sobrando partes não utilizadas. A questão seria: qual o tamanho inteiro máximo que essas fatias poderão ter?
Por exemplo, se tivermos K = 4, com os tamanhos (em centímetros) M1 = 120, M2 = 89, M3 = 230 e M4 = 177 e N = 10, podemos retirar N fatias iguais de tamanho máximo 57, pois assim conseguimos 2 fatias no primeiro pão, 1 no segundo, 4 no terceiro e 3 no quarto, totalizando as 10 fatias necessárias. Se tentarmos cortar fatias de tamanho 58, só será possível obter 3 fatias do terceiro pão, totalizando 9 e, portanto, 57 é realmente o melhor que podemos obter. Note que não podemos usar duas ou mais fatias menores de diferentes pães para formarmos uma fatia do tamanho selecionado. (ficaria muito deselegante dar um lanche recortado às pessoas).
Escreva um programa que, dados os tamanhos de pão disponíveis (em centímetros) e a quantidade de pessoas a serem atendidas, retorne o tamanho inteiro máximo (em centímetros) da fatia que pode ser cortada de maneira a atender todas as pessoas.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha da entrada contém um inteiro N que indica a quantidade pessoas (1 ≤ N ≤ 10.000). A segunda linha contém um inteiro K (1 ≤ K ≤ 10.000) que é a quantidade de sanduíches disponível. Na terceira linha há K inteiros M (1 ≤ M ≤ 10.000) separados por um espaço em branco representando o tamanho de cada pão.
Saída
Seu programa deve imprimir, na saída padrão, uma única linha, contendo o tamanho inteiro máximo da fatia que pode ser cortada.
Exemplos de Entrada Exemplos de Saída
10
4
120 89 230 177
57
3
2
45 85
42
7
7
100 98 99 505 102 97 101
101
OBI - Olimpíada Brasileira de Informática 2007 Fase 2 Nível 1 |
1,316 | 2330 | Telemarketing | Médio | AD-HOC | O telemarketing foi patenteado em 1982 pelo empresário Nadji Tehrani e consiste em vender produtos através do telefone. Uma das formas de venda utilizadas hoje em dia é obter-se uma lista de possíveis compradores para os produtos vendidos e seus respectivos telefones e utilizar um time de vendedores para ligar para esse conjunto de pessoas.
Bo Ber Man é um empresário estrangeiro dono da Mar Ato Na, cujos ideogramas em seu idioma significam "Empresa Nacional de Telemarketing". Sua empresa realiza vendas dos produtos mais variados para diversas companhias.
Ele possui um time de N vendedores e uma lista de ligações a serem feitas. Para cada ligação sabe-se o tempo T em minutos que ela vai durar. Os vendedores são identificados por números de 1 a N e fazem as ligações da seguinte forma:
Inicialmente, todos os vendedores estão inativos.
Sempre que um vendedor realizar uma ligação, ele ficará ocupado pelos T minutos descritos na lista para aquela ligação. O tempo entre duas ligações consecutivas as do mesmo vendedor é desprezível.
Um vendedor não pode fazer mais de uma ligação ao mesmo tempo.
Um vendedor que esteja inativo deverá fazer a ligação que estiver no topo da lista. Caso mais de um vendedor esteja inativo no mesmo instante, o vendedor com o menor identificador dentre os vendedores inativos deverá fazer a ligação que estiver no topo da lista.
Assim que uma ligação é atribuída a um vendedor, ela é removida da lista.
Um vendedor fica inativo sempre que termina uma ligação.
Por exemplo, suponha que um time de 4 vendedores deve fazer 6 ligações, cujos tempos sejam 5, 2, 3, 3, 4, 9. Como inicialmente nenhum vendedor está ocupado, o primeiro vendedor fará a ligação de 5 minutos, o segundo vendedor a ligação de 2 minutos e os vendedores de número 3 e 4 farão ligações de 3 minutos. Como o segundo vendedor terminará a sua ligação antes dos demais, ele fará a quinta ligação, de 4 minutos e, por fim, o terceiro vendedor (cujo tempo é igual ao do quarto vendedor, mas o número é menor) fará a sexta ligaçao, de 9 minutos.
Escreva um programa que, dados o número de vendedores, o número de ligações e a duração de cada ligação, determine o número de ligações feitas por cada vendedor.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha da entrada contém dois inteiros, N e L indicando o número de vendedores e o número de ligações a serem realizadas (1 ≤ N ≤ 1.000, 1 ≤ L ≤ 1.000.000). As L linhas seguintes contêm um inteiro T cada (1 ≤ T ≤ 30), em que T representa a duração de cada ligação.
Saída
Seu programa deve imprimir, na saída padrão, N linhas, uma para cada vendedor, contendo dois inteiros I e P representando o número do vendedor e o número de ligações realizadas por este vendedor. Os vendedores devem ser apresentados em ordem crescente de identificador, começando a partir de 1.
Exemplos de Entrada Exemplos de Saída
5 3
2
2
1
1 1
2 1
3 1
4 0
5 0
4 6
5
2
3
3
4
9
1 1
2 2
3 2
4 1
3 9
3
5
1
1
1
1
1
1
1
1 3
2 1
3 5
OBI - Olimpíada Brasileira de Informática 2007 Fase 2 Nível 1 |
1,317 | 2331 | Uiquipédia | Médio | AD-HOC | A Uiquipédia (Wikipedia em inglês), fundada em 2001 por Jimmy Wales e Larry Sanger, é um site onde qualquer pessoa pode editar os artigos, fazendo correções ou ampliando seu conteúdo.
Uma das grandes vantagens da Uiquipédia sobre enciclopédias de papel é a facilidade de seguir referências; com um simples clique, é possível ir de um artigo para outro relacionado. Essas referências são chamadas de referências diretas. Também é possível navegar a Uiquipédia sequencialmente: cada artigo possui referência para o artigo anterior e para o posterior, na ordem alfabética. Essas referências são chamadas de referências sequenciais.
Por exemplo, um artigo para o termo "Elefante" pode ter uma referencia direta para "Mamiferos" em seu texto, desta forma pode-se chegar de "Elefante" a "Mamiferos" em um clique. Observe que pode não existir a referência direta contrária, ou seja, de "Mamiferos" para "Elefante". Adicionalmente se "Elevador" é o próximo artigo depois de "Elefante", na ordem alfabética, pode-se ir com um clique de "Elefante" para "Elevador" e de "Elevador" para "Elefante", pois há uma referência sequencial entre eles.
Paulo e André são dois amigos que contribuem para a Uiquipédia. Muitas vezes, André edita um artigo e quer que Paulo o ajude a revisar a modificação. A conexão de Paulo à Internet é discada, e por isso ele quer chegar na página que André editou usando o menor número de cliques possível, começando do artigo em que está, e navegando apenas por referências, diretas ou sequenciais.
Escreva um programa que, dados todas as referências diretas existentes na Uiquipédia, a página onde Paulo está, e a página editada por André, determina de quantos cliques Paulo precisa, no mínimo, para ver a página que foi modificada por André, utilizando as referências diretas e sequenciais.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha contém um único inteiro, N , que é o número de referências da Uiquipédia (1 ≤ N ≤ 1.000). As N linhas contém cada uma duas strings X e Y , separadas por um espaço, que são os nomes de duas páginas da Uiquipédia conectadas por uma referência direta (de X para Y ). Todo artigo existente na Uiquipédia aparece pelo menos uma vez na descrição das referencias diretas, permitindo que as referencias sequenciais sejam extraídas das informações dadas. Note que uma referência direta pode ligar duas páginas que estariam ligadas também por uma referência sequencial.
Depois da descrição das referências, há uma linha em branco, e a linha seguinte contém duas cadeias de caracteres, P e A, que são a página atual de Paulo e a página editada por André. O nome de cada página é limitado a 100 caracteres e contém somente letras maiúsculas, letras minusculas e o símbolo '_'. Observe que na ordem alfabética o simbolo '_' é anterior às letras maiúsculas, que por sua vez são anteriores às letras minusculas
Saída
Seu programa deve imprimir, na saída padrão, uma única linha, contendo um único inteiro, que diz o número mínimo de cliques que são necessários para ir da página atual de Paulo até a página editada por André. Sempre é possível navegar de um artigo a outro.
Exemplos de Entrada Exemplos de Saída
3
Pink_Floyd O_Lado_Escuro_Da_Lua
Pink_Floyd O_Muro
O_Muro Muro_de_Berlim
O_Muro O_Lado_Escuro_Da_Lua
1
4
Chaves Quico
Quico Chiquinha Professor_Girafales Dona_Florinda
Chaves Dona_Clotilde
Chaves Chiquinha
1
OBI - Olimpíada Brasileira de Informática 2007 Fase 2 Nível 1 |
1,318 | 2332 | Jogo do Labirinto | Difícil | AD-HOC | Um amigo seu está muito empolgado com um novo joguinho que baixou em seu celular. O jogo consiste em uma espécie de labirinto que pode ser representado por um quadriculado de células quadradas com N linhas e M colunas. Cada célula do labirinto contém uma plataforma que está a uma determinada altura do chão, que pode ser representada por um inteiro a que varia de 0 (a mais baixa) a 9 (a mais alta). Você inicia na célula (1, 1) (canto superior esquerdo) e o objetivo é chegar na saída do labirinto que fica na célula (N, M) (canto inferior direito).
Para sair do labirinto, você deve fazer movimentos entre células adjacentes. O problema é que seu bonequinho não consegue pular muito alto, então se a célula destino estiver duas ou mais unidades acima da sua altura atual, você não consegue movê-lo. Mais especificamente, a cada turno você pode mover para uma das 4 células adjacentes (cima, baixo, direita, esquerda) caso a altura da célula destino seja menor ou igual à altura da sua célula atual mais uma unidade. Ou seja, se a altura da sua célula for A, você só pode mover a uma célula adjacente caso a altura dela seja menor ou igual a A + 1.
Para complicar um pouco mais o jogo, a cada turno, após o jogador realizar sua ação, cada célula aumenta em uma unidade sua altura, até o valor máximo de 9. Caso a altura de uma determinada célula seja 9, ela passa a ser 0. Note que, em um dado turno, o jogador não é obrigado a se mover, ele pode simplesmente esperar as plataformas subirem ou descerem. Além disso, repare que nem todas as células têm 4 vizinhos, uma vez que não é permitido ao jogador se mover para fora dos limites do labirinto.
Você, como bom programador que é, resolve escrever um programa que calcule a menor quantidade de turnos possível para chegar à saída de um dado labirinto.
Escreva um programa que, dado um labirinto, retorne a menor quantidade de turnos necessária para chegar à saída, de acordo com as restrições dadas.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha da entrada contém dois inteiros N e M (2 ≤ N, M ≤ 50) separados por um espaço em branco, que representam, respectivamente, a quantidade de linhas e colunas do labirinto. As N linhas seguintes contêm, cada uma, M inteiros que representam a altura inicial (no turno 0) da respectiva plataforma. As alturas estão sempre entre 0 e 9 (inclusive).
Saída
Seu programa deve imprimir, na saída padrão, uma única linha, contendo a menor quantidade de turnos possível para sair do labirinto.
Exemplos de Entrada Exemplos de Saída
4 3
0 0 0
0 0 0
0 0 0
0 0 0
5
3 3
1 2 3
4 5 6
7 8 9
12
3 5
1 3 1 1 1
1 3 1 3 1
1 1 1 3 1
10
OBI - Olimpíada Brasileira de Informática 2007 Fase 2 Nível 2 |
1,319 | 2333 | Pizza | Difícil | AD-HOC | Rodrigo pediu uma pizza de mussarela de N fatias, uma parte somente com cebola e o resto somente com azeitonas. Entretanto, ao receber a pizza em casa, notou que o motoqueiro que a entregou não foi cuidadoso o suficiente, pois tanto as tiras de cebola quanto as azeitonas estavam espalhadas por toda a pizza. Para piorar, como a pizza era de mussarela, as tiras de cebola e as azeitonas estavam grudadas na pizza.
Como gosta mais de cebola do que de azeitona, Rodrigo deseja pegar fatias consecutivas da pizza de tal forma que estas contenham a maior diferença possível entre tiras de cebola e azeitonas. Para isso, ele contou quantas tiras e quantas azeitonas tinham em cada fatia e subtraiu os dois valores, nessa ordem. Assim, sempre que uma fatia contiver mais cebolas que azeitonas, ela recebe um número positivo, e caso contrário, um número negativo. Uma fatia cujo número seja zero contém o mesmo número de tiras de cebolas e azeitonas.
Por exemplo, supondo que as fatias contenham as seguintes diferenças: 5, −3, −3, 2, −1, 3, pode-se pegar uma fatia consecutiva com 9 cebolas a mais que azeitonas, utilizando as fatias com as diferenças 2, −1, 3, 5 (lembre-se de que estamos tratando de um círculo e, portanto, a fatia com diferença 5 é vizinha da fatia com diferença 3 e vice-versa).
Como Rodrigo não entende de programação, ele resolveu contar com seus serviços.
OBS: repare que é melhor não escolher nenhuma fatia caso somente seja possível escolher fatias consecutivas com mais azeitonas que cebolas.
Escreva um programa que, dados as diferenças entre as quantidades de cebolas e azeitonas em cada fatia de pizza, retorne a maior quantidade possível de cebolas que Rodrigo pode comer a mais do que a quantidade de azeitonas utilizando somente fatias consecutivas de pizza. (lembrando que a primeira fatia é adjacente à última e vice-versa).
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha da entrada contém um inteiro N que indica o número de fatias de pizza (1 ≤ N ≤ 100.000). A segunda linha contém N inteiros K (−100 ≤ K ≤ 100) separados por um espaço em branco com as diferenças entre as quantidades de cebolas e de azeitonas.
Saída
Seu programa deve imprimir, na saída padrão, uma única linha, contendo a maior quantidade de cebolas que Rodrigo pode comer a mais do que azeitonas.
Exemplos de Entrada Exemplos de Saída
6
5 -3 -3 2 -1 3
9
7
1 -2 2 -1 4 1 -5
6
2
-3 -10
0
OBI - Olimpíada Brasileira de Informática 2007 Fase 2 Nível 2 |
1,320 | 2334 | Patinhos | Fácil | INICIANTE | Cinco patinhos foram passear. Além das montanhas. Para brincar. A mamãe gritou: quá, quá, quá, quá. Mas só quatro patinhos voltaram de lá. Quatro patinhos foram passear. Além das montanhas. Para brincar. A mamãe gritou: quá, quá, quá, quá. Mas só três patinhos voltaram de lá. Três patinhos foram passear. Além das montanhas. Para brincar. A mamãe gritou: quá, quá, quá, quá. Mas só dois patinhos voltaram de lá. Dois patinhos foram passear. Além das montanhas. Para brincar. A mamãe gritou: quá, quá, quá, quá. Mas só um patinho voltou de lá. Um patinho foi passear. Além das montanhas. Para brincar. A mamãe gritou: quá, quá, quá, quá. Mas nenhum patinho voltou de lá.
A mamãe patinha ficou tão triste naquele dia que resolveu pedir sua ajuda para procurar além das montanhas, na beira do mar, quantos patinhos não voltaram de lá.
Entrada
Haverá vários casos de testes, a primeira linha de cada caso de teste contém um inteiro (0 ≤ P ≤ 1019) representando a quantidade total de patos, a entrada termina com P = -1.
Saída
O arquivo de saída deve conter a quantidade de patinhos que retornaram.
Exemplo de Entrada Exemplo de Saída
0
1
10000000000000000000
-1
0
0
9999999999999999999 |
1,321 | 2335 | O Desafio de Arquibaldo | Muito Difícil | MATEMÁTICA | Arquibaldo é um menino muito inteligente conhecido por ser o “bam-bam-bam” das questões matemáticas relacionadas a figuras geométricas. Cálculo de áreas, perímetros, medidas de lados, Arquibaldo já estava cansado de pequenos desafios. Para ele, era tudo muito fácil. Sua tia Helena, no entanto, sendo professora de matemática, resolveu passar um desafio ao seu sobrinho, um pouco acima dos com que ele estava acostumado a lidar. Helena lhe mostrou quatro triângulos retângulos idênticos e formou com eles um quadrado tal que seus lados eram as medidas das hipotenusas dos triângulos escolhidos. Então ela disse ao sobrinho que dependendo das medidas dos triângulos retângulos, pode ou não haver um segundo quadrado menor no centro do maior. As ilustrações abaixo mostram com clareza estes casos:
Ela então o desafiou: “Se eu te der os lados dos quadrados interno e externo, l1 e l2, por exemplo, você consegue me dizer qual a medida, em graus, do menor ângulo interno do triângulo retângulo que formaria com outros três triângulos idênticos um quadrado de lado l1 e outro de lado l2?”. Arquibaldo, começou a tentar resolver o desafio. Como ele não poderia usar calculadora, sua tia foi boazinha e permitiu que apenas a resposta inteira fosse apresentada, ou seja, sem casas decimais. Assim, Arquibaldo teria agora que encontrar a maior medida inteira do menor ângulo do triângulo retângulo tal que o lado do
quadrado interno formado por esse novo triângulo (com medidas de ângulos internos inteiras) seja maior ou igual ao lado do quadrado interno dado, ou seja, este deveria “caber” no novo quadrado interno. Por exemplo: se os lados dos quadrados interno e externo tiverem medidas 1 e 5, respectivamente, então, o menor ângulo terá medida aproximada de 36,87º, porém, a maior medida inteira é 36º, pois um conjunto de quatro triângulos retângulos de angulação 36º e 54º(complemento) formam quadrados de lado 5 e 1,10 unidades de medida, ou seja, o quadrado fornecido de lado 1 “caberia” em um quadrado de lado 1,10, com esta angulação.
“Atente também para a existência do triângulo! Lembre-se: agora as medidas dos ângulos só podem ser inteiras!”, alertou Helena a Arquibaldo para possíveis erros porque ela é brother. No exemplo acima, o triângulo existe, pois tem ângulos de 36º, 54º e 90º. Sabendo, que você é um programador (não foi informado à Helena se você era bom ou não), Helena pediu a você que faça um programa que informe o gabarito dos valores fornecidos por ela ao seu sobrinho, para saber se ele realmente soube resolver o desafio.
Entrada
A entrada é composta de vários casos de teste. Cada caso corresponde a uma linha que contém os valores dos lados dos quadrados interno e externo, L1 e L2 (1 <= L1, L2 <= 105), não necessariamente nesta ordem.
Saída
Para cada caso de teste, imprima a maior medida inteira do menor ângulo interno do triângulo retângulo, respeitando as condições acima. Se o triângulo do ângulo em questão não existir, imprima a mensagem “Nao existe tal triangulo.”.
Exemplo de Entrada Exemplo de Saída
102 100
100 101
40 40
2 1
1 5
1 10
32293 22321
1
Nao existe tal triangulo.
Nao existe tal triangulo.
24
36
40
15 |
1,322 | 2336 | ABC | Difícil | STRINGS | No ramo da matemática e computação existem inúmeras formas de se representar um número, a estas formas denotamos o nome base, as quais podemos representar de várias maneiras, cada uma com sua devida utilidade e peculiaridades como, por exemplo, a base decimal comumente utilizada na matemática ou a base binária representada apenas por 0’ s e 1’ s e até mesmo a base hexadecimal composta por números de 0 a 9 juntamente com os caracteres A, B, C, D, E e F.
Algumas pessoas são apaixonadas por binário, outras preferem a mesmice e continuam na base decimal e há quem prefira o ABC. O ABC consiste em uma base formada pelos caracteres do alfabeto em caixa alta, ou seja, A, B, C, ..., X, Y, Z atrinuindo-se o valor 0 para o caractere A, 1 para o caractere B até Z valendo 25. Tendo isso em mente sua tarefa é, dada uma string S, 0 < |S| ≤10³, pertencente à base ABC, convertê-la para a base decimal, mas lembre-se, o valor representado por S pode ser muito grande então seu resultado deve ser módulo 109+7.
Entrada
A entrada é composta por uma linha contendo a string nos padrões informados e termina com EOF.
Saída
A saída será composta de uma linha por caso de teste contendo o valor da string dada em decimal módulo 109 + 7.
Exemplo de Entrada Exemplo de Saída
GAPA
UMAFRASEMEIOGRANDE
105846
114397416 |
1,323 | 2337 | Pro Habilidade | Fácil | MATEMÁTICA | Francisco é um grande fã do jogo “Cara ou Coroa” e adora brincar disso com sua moeda da sorte, mas Francisco tem algumas condições de jogo. Ele sempre escolhe “Cara” e em cada partida do jogo pode haver vários arremessos de moeda. Outra coisa é que Francisco odeia quando a moeda cai com a face “Coroa” em dois arremessos consecutivos. Curioso, Francisco quer saber qual a probabilidade de, em uma partida de “Cara ou Coroa”, não ocorra “Coroa” em dois arremessos consecutivos, contudo, como ele só gosta de jogar, pediu a você que fizesse um programa que calculasse isso pra ele.
Entrada
A entrada contém vários casos de testes, cada linha da entrada deverá conter um número inteiro N (0<N≤40) que representará a quantidade de arremessos de uma única partida.
Saída
Para cada linha de entrada deverá haver apenas uma linha de saída. A saída deverá conter a probabilidade de não ocorrer “Coroa” em dois arremessos consecutivos. A resposta deve estar na forma de fração irredutível.
Exemplo de Entrada Exemplo de Saída
1
10
1/1
9/64
Obrigado Wesley Rocha e William Azevedo pelo nome da questão. |
1,324 | 2338 | Morse | Fácil | ESTRUTURAS E BIBLIOTECAS | Todos os seus amigos estão loucos pelo filme "Interstellar". Agora eles estão postando textos no Facebook em Código Morse. Você precisa escrever um código para decodificar Morse!
Este Código Morse contém somente letras minúsculas (a-z) e espaços em branco.
Nota - Código Morse é uma forma de codificar caracteres em uma sequências de pontos e traços. Cada caracter tem uma codificação fixa. Um exemplo bem famoso é o Morse de SOS "...---..." . S é codificado como "..." (ponto ponto ponto) e O é codificado como "---" (traço traço traço).
Neste problema, um ponto é denotado por "=" e um traço por "===". Símbolos são separados por "." , letras são separadas por "..." e palavras são separadas por "......." .
Sendo assim, SOS é codificado como =.=.=...===.===.===...=.=.=
Codificações para todos os caracteres podem ser encontradas no link abaixo.
http://morsecode.scphillips.com/morse2.html
Entrada
A entrada consiste em múltiplos casos de teste.
A primeira linha de cada entrada contém o número de casos de teste (t)(1 <= t <= 10).
As próximas t linhas contém os Códigos Morse. O tamanho de cada código é menor que 1000 caracteres.
Saída
A saída é divida em linhas, que representam a mensagem decodificada de cada caso de teste.
Exemplo de Entrada Exemplo de Saída
2
===.===.=...===.===.=
=.=.=...===.===.===...=.=.=
gg
sos
https://en.wikipedia.org/wiki/Morse_code |
1,325 | 2339 | Aviões de Papel | Muito Fácil | AD-HOC | Para descontrair os alunos após as provas da OBI, a Diretora da escola organizou um campeonato de aviões de papel. Cada aluno participante receberá uma certa quantidade de folhas de um papel especial para fazer os seus modelos de aviões. A quantidade de folhas que cada aluno deverá receber ainda não foi determinada: ela será decidida pelos juízes do campeonato.
A diretora convidou, para atuarem como juízes, engenheiros da Embraer, uma das mais bem sucedidas empresas brasileiras, que vende aviões com tecnologia brasileira no mundo todo. O campeonato está programado para começar logo após a prova da OBI, mas os juízes ainda não chegaram à escola. A diretora está aflita, pois comprou uma boa quantidade de folhas de papel especial, mas não sabe se a quantidade comprada vai ser suficiente.
Considere, por exemplo, que a Diretora comprou 100 folhas de papel especial, e que há 33 competidores. Se os juízes decidirem que cada competidor tem direito a três folhas de papel, a quantidade comprada pela diretora é suficiente. Mas se os juízes decidirem que cada competidor tem direito a quatro folhas, a quantidade comprada pela diretora não seria suficiente.
Você deve escrever um programa que, dados o número de competidores, o número de folhas de papel especial compradas pela Diretora e o número de folhas que cada competidor deve receber, determine se o número de folhas comprado pela Diretora é suficiente.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). O arquivo de entrada contém três números inteiros C (1 ≤ C ≤ 1000), P (1 ≤ P ≤ 1000) e F (1 ≤ F ≤ 1000) representando respectivamente o número de competidores, a quantidade de folhas de papel especial compradas pela Diretora e a quantidade de folhas de papel especial que cada competidor deve receber.
Saída
Seu programa deve imprimir, na saída padrão, o caractere ‘S’ se a quantidade de folhas compradas pela Diretora é suficiente, ou o caractere ‘N’ caso contrário. Note que os caracteres devem ser letras maiúsculas.
Exemplos de Entrada Exemplos de Saída
10 100 10
S
10 90 10
N
5 40 2
S
OBI - Olimpíada Brasileira de Informática 2009 Fase 1 Nível 1 |
1,326 | 2340 | Feira de Bactérias | Médio | AD-HOC | Bruno é um biólogo apaixonado por sua profissão. Sua especialidade é estudar o comportamento de bactérias. Por isso, ele possui em seu laboratório centenas de colônias de diferentes tipos desses microorganismos.
Nesta semana ele viu o anúncio de um evento inusitado: uma feira de bactérias. Nessa feira, vários fornecedores estarão vendendo diferentes tipos de bactérias. Cada tipo de bactéria é vendido em uma placa de vidro, já preparada para a formação de uma colônia de bactérias. Cada placa de vidro é vendida com apenas uma bactéria inicialmente.
Bruno deu uma olhada no catálogo com os tipos de bactérias que estarão à venda na feira, e notou algumas coisas interessantes:
Todos os tipos de bactérias à venda terão o mesmo preço.
Todas as bactérias (de todos os tipos) se subdividem todas as noites para gerar outras bactérias. Por exemplo, a bactéria da colônia de tipo X se subdivide em 2 outras bactérias todas as noites. Assim, no primeiro dia teremos só uma bactéria na colônia. No dia seguinte, teremos 2, e no próximo, 4. A quantidade de divisões de uma bactéria depende do seu tipo.
O crescimento da colônia cessa após um determinado número de dias, por causa da escassez de alimento. A quantidade de dias em que uma colônia cresce depende do tipo de bactéria.
É final de mês e Bruno já gastou quase todo o seu dinheiro. Assim, resolveu que irá comprar apenas uma colônia de bactérias. No entanto, ele pretende comprar a colônia que forneça a maior quantidade de bactérias ao final do período de crescimento da mesma.
Ele tem um catálogo mostrando os tipos de bactérias à venda. Para cada tipo de bactéria, o catálogo informa a quantidade de bactérias geradas por uma bactéria desse tipo a cada divisão e por quantos dias a população da colônia crescerá. Porém, a calculadora que ele tem em casa não é suficiente para que ele faça os cálculos necessários para decidir qual é a melhor colônia a comprar.
Bruno pediu sua ajuda para decidir qual é o melhor tipo de bactéria para a compra. Lembre que para Bruno o melhor tipo de bactéria é aquele cuja colônia, ao final do período de crescimento, terá a maior quantidade de bactérias.
Você deve supor que não haverá duas colônias com a mesma população final de bactérias.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado).
A primeira linha da entrada contém um inteiro N (1 ≤ N ≤ 50.000) representando a quantidade tipos de bactérias no catálogo. Cada uma das N linhas seguintes contém informações sobre um tipo de bactéria: a primeira dessas linhas contém a informação da bactéria de tipo 0, a segunda dessas linhas contém a informação sobre a bactéria de tipo 1, e assim por diante. A última dessas linhas contém a informação da bactéria de tipo N − 1.
A informação para cada tipo de bactéria é composta por dois números inteiros D e C (1 ≤ D ≤ 2.000 e 1 ≤ C ≤ 5.000), onde D é quantidade de bactérias que cada bactéria deste tipo gera ao se dividir numa noite, e C é a quantidade de dias que a população de bactérias crescerá.
Saída
Seu programa deve imprimir, na saída padrão, um número inteiro entre 0 e N − 1 representando o tipo da bactéria que Bruno deverá comprar.
Exemplos de Entrada Exemplos de Saída
2
2 5
3 4
1
5
2 1
4 5
30 4
20 6
2 154
4
4
145 15
2 4999
3 3211
135 20
2
OBI - Olimpíada Brasileira de Informática 2009 Fase 1 Nível 1 |
1,327 | 2341 | Número de Envelopes | Fácil | AD-HOC | Aldo é um garoto muito esperto que adora promoções e sorteios. Como já participou de muitas promoções da forma “para participar, envie n rótulos de produtos ...”, Aldo tem o costume de guardar o rótulo de todos os produtos que compra. Dessa forma, sempre que uma empresa faz uma promoção ele já tem um monte de rótulos para mandar.
A SBC (Super Balas e Caramelos) está fazendo uma nova promoção, e, como era de se esperar, Aldo quer participar. Para participar da promoção é preciso enviar um envelope contendo um rótulo de cada tipo de bala que a SBC produz. Por exemplo, se a SBC produz 3 tipos de balas, A, B, C, e uma pessoa tem 3 rótulos de A, 3 de B e 2 de C, ela pode enviar no máximo 2 envelopes, já que falta um rótulo de C para compor o terceiro envelope. Não há limite para o número de envelopes que uma pessoa pode enviar.
Balas são a segunda coisa de que Aldo mais gosta (a primeira como você sabe são promoções). Por causa disso a quantidade de rótulos de balas que ele tem é muito grande, e ele não está conseguindo determinar a quantidade máxima de envelopes que ele pode enviar.
Como você é o melhor amigo de Aldo ele pediu sua ajuda para fazer o cálculo, de modo que ele compre o número exato de envelopes.
Você deve escrever um programa que, a partir da lista de rótulos de Aldo, calcula o número máximo de envelopes válidos que ele pode enviar.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado).
A primeira linha contém dois números inteiros N (1 ≤ N ≤ 1000000) e K (1 ≤ K ≤ 1000) representando respectivamente a quantidade de rótulos de balas que Aldo possui e o número de tipos diferentes de bala que a SBC produz. Os tipos de balas são identificados por inteiros de 1 a K. A segunda linha contém N números inteiros Xi, cada um representando um rótulo de bala que Aldo possui (1 ≤ Xi ≤ K, para 1 ≤ i ≤ N).
Saída
Seu programa deve imprimir, na saída padrão, o número máximo de envelopes válidos que Aldo pode enviar.
Exemplos de Entrada Exemplos de Saída
10 2
1 1 1 1 1 2 2 2 2 2
5
20 5
1 2 3 4 1 2 3 4 1 2 3 4 5 1 2 3 4 5 4 4
2
OBI - Olimpíada Brasileira de Informática 2009 Fase 1 Nível 1 |
1,328 | 2342 | Overflow | Muito Fácil | AD-HOC | Os computadores foram inventados para realizar cálculos muito rapidamente, e atendem a esse requisito de maneira extraordinária. Porém, nem toda conta pode ser feita num computador, pois ele não consegue representar todos os números dentro de sua memória. Em um computador pessoal atual, por exemplo, o maior inteiro que é possível representar em sua memória é 4.294.967.295. Caso alguma conta executada pelo computador dê um resultado acima desse número, ocorrerá o que chamamos de overflow, que é quando o computador faz uma conta e o resultado não pode ser representado, por ser maior do que o valor máximo permitido (em inglês overflow significa trasbordar).
Por exemplo, se um computador só pode representar números menores do que 1023 e mandamos ele executar a conta 1022 + 5, vai ocorrer overflow.
Dados o maior número que um computador consegue representar e uma expressão de soma ou multiplicação entre dois inteiros, determine se ocorrerá overflow.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado).
A primeira linha da entrada contém um inteiro N (1 ≤ N ≤ 500.000) representando o maior número que o computador consegue representar. A segunda linha contém um inteiro P (0 ≤ P ≤ 1000), seguido de um espaço em branco, seguido de um caractere C (que pode ser ‘+’ ou ‘*’, representando os operadores de adição e multiplicação, respectivamente), seguido de um espaço em branco, seguido de um outro inteiro Q (0 ≤ Q ≤ 1000). Essa linha representa a expressão P + Q, se o caractere C for ‘+’, ou P × Q, se o caractere C for ‘*’.
Saída
Seu programa deve imprimir, na saída padrão, a palavra ‘OVERFLOW’ se o resultado da expressão causar um overflow, ou a palavra ‘OK’ caso contrário. Ambas as palavras devem ser escritas com letras maiúsculas.
Exemplos de Entrada Exemplos de Saída
10
5 + 5
OK
44
23 * 2
OVERFLOW
323500
42 * 35
OK
OBI - Olimpíada Brasileira de Informática 2009 Fase 1 Nível 1 |
1,329 | 2343 | Caçadores de Mitos | Médio | AD-HOC | Jorge é um apresentador de televisão que comanda a versão brasileira do grande sucesso Caçadores de Mitos, onde se estuda um mito para descobrir se é fato ou apenas um boato.
No próximo episódio, Jorge deverá apresentar o mito que diz que ”os raios não caem duas vezes no mesmo lugar”, referindo-se aos raios das tempestades de chuva.
Para isso, foi até a cidade de Eletrolândia, que é a cidade com maior ocorrência de raios no mundo. O prefeito tem tanto orgulho desse título que mandou criar um sistema para registrar os raios. Jorge conseguiu um relatório com as ocorrências de cada raio que caiu na cidade nos últimos anos.
O mapa de Eletrolândia é um retângulo. Para o sistema de registro a cidade é subdividida em quadrados de um metro de lado, denominados quadrantes. Assim, se a cidade tem 300 metros de largura e 1000 de comprimento, ela será subdividida em 300.000 quadrantes. O sistema de registro armazena o quadrante em que o raio caiu. Cada quadrante é identificado pelas suas coordenadas X e Y, conforme ilustra a figura abaixo, que exemplifica um mapa de uma cidade com oito metros de comprimento por cinco metros de largura (quarenta quadrantes).
Como os quadrantes são relativamente pequenos, Jorge decidiu que se dois raios caíram no mesmo quadrante, pode-se considerar que caíram no mesmo lugar.
Sua missão é escrever um programa que receba as coordenadas dos raios que caíram em Eletrolândia nos últimos anos e determine se o mito estudado é realmente apenas um mito ou pode ser considerado verdade.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado).
A primeira linha da entrada contém um número inteiro N (2 ≤ N ≤ 500.000) representando o número de registros de raios no relatório. Cada uma das N linhas seguintes contém 2 números inteiros X, Y (0 ≤ X, Y ≤ 500), representando o registro de um raio que caiu no quadrante cujas coordenadas são (X, Y).
Saída
Seu programa deve imprimir, na saída padrão, o número 0 se nenhum raio caiu no mesmo lugar, ou o número 1 caso contrário. Note que você deve imprimir o número 1 mesmo que haja mais do que 1 par de raios que caíram no mesmo lugar.
Exemplos de Entrada Exemplos de Saída
5
1 1
2 3
3 3
4 2
4 4
0
8
1 1
2 2
2 3
4 4
2 3
6 5
9 11
10 10
1
OBI - Olimpíada Brasileira de Informática 2009 Fase 1 Nível 2 |
1,330 | 2344 | Notas da Prova | Muito Fácil | INICIANTE | Rosy é uma talentosa professora do Ensino Médio que já ganhou muitos prêmios pela qualidade de sua aula. Seu reconhecimento foi tamanho que foi convidada a dar aulas em uma escola da Inglaterra. Mesmo falando bem inglês, Rosy ficou um pouco apreensiva com a responsabilidade, mas resolveu aceitar a proposta e encará-la como um bom desafio.
Tudo ocorreu bem para Rosy até o dia da prova. Acostumada a dar notas de 0 (zero) a 100 (cem), ela fez o mesmo na primeira prova dos alunos da Inglaterra. No entanto, os alunos acharam estranho, pois na Inglaterra o sistema de notas é diferente: as notas devem ser dadas como conceitos de A a E. O conceito A é o mais alto, enquanto o conceito E é o mais baixo.
Conversando com outros professores, ela recebeu a sugestão de utilizar a seguinte tabela, relacionando as notas numéricas com as notas de conceitos:
O problema é que Rosy já deu as notas no sistema numérico, e terá que converter as notas para o sistema de letras. Porém, Rosy precisa preparar as próximas aulas (para manter a qualidade que a tornou reconhecida), e não tem tempo suficiente para fazer a conversão das notas manualmente.
Você deve escrever um programa que recebe uma nota no sistema numérico e determina o conceito correspondente.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A entrada contém uma única linha com um número inteiro N (0 ≤ N ≤ 100), representando uma nota de prova no sistema numérico.
Saída
Seu programa deve imprimir, na saída padrão, uma letra (A, B, C, D, ou E em maiúsculas) representando o conceito correspondente à nota dada na entrada.
Exemplos de Entrada Exemplos de Saída
12
D
87
A
0
E
OBI - Olimpíada Brasileira de Informática 2009 Fase 1 Nível 2 |
1,331 | 2345 | Assigning Teams | Muito Fácil | AD-HOC | Four friends are playing table tennis. Each of them has a skill level which is represented by an integer number: the higher the number, the better the player is.
The four friends want to form two teams of two players each. For the game to be more exciting, they want the skill level of the teams to be as close as possible. The skill level of a team is the sum of the skill levels of the players in that team.
Although they are very good table tennis players, these friends are not so good at other things, like Math or Computing. Can you help them find the smallest possible difference between the teams’ skill levels?
Input
The input consists of a single line that contains four integers A, B, C and D, representing the skill levels of the four players (0 ≤ A ≤ B ≤ C D ≤ 104).
Output
Output a line with an integer representing the smallest difference between the skill levels for both teams.
Input Samples Output Samples
4 7 10 20
7
0 0 1 1000
999
1 2 3 4
0
ACM/ICPC South America Contest 2016 |
1,332 | 2346 | Back to the Future | Difícil | AD-HOC | Doctor Emmet is working on a safer device to travel in time. He gathered N different and rare pieces of metal. Each piece may be compatible with some other different pieces. He has a complete list with M distinct pairs of compatible metals. Any pair of metals that is not on the list is incompatible.
In order for the device to work, he must choose a set of metals such that each of them is compatible with at least A others in that set. However, in order to preserve some balance, they must also be incompatible with at least B others in that set.
More metals mean more energy and a safer device. This is why Doctor Emmet needs your help, he wants to know the size of the largest set he can choose that meets these criteria.
Input
The first line contains four integers N, M, A and B, representing respectively how many different pieces of metal exist (1 ≤ N ≤ 105), how many compatibilities there are (1 ≤ M ≤ 105) and the variables A and B described in the problem statement (0 ≤ A,B < N). The different metals are conveniently numbered from 1 to N. Each of the following M lines contains two integers X and Y corresponding to a pair of compatible metals (1 ≤ X, Y ≤ N with X ≠Y). There are no repeated pairs in the input.
Output
Output a line with one integer representing the size of the largest set of metals satisfying the requirements specified in the problem statement.
Input Samples Output Samples
3 1 1 0
1 2
2
3 1 1 1
1 2
0
7 12 2 2
1 2
2 3
3 1
4 5
5 6
6 4
3 4
7 1
2 7
3 7
4 7
5 7
6
ACM/ICPC South America Contest 2016 |
1,333 | 2347 | Counting Self-Rotating Subsets | Difícil | AD-HOC | A set of points in the plane is self-rotating if there is a point P, the center, and an angle α, expressed in degrees, where 0 < α < 360, such that the rotation of the plane, with center P and angle , maps every point in the set to some point also in the set.
You are given a set of N distinct points, all having integer coordinates. Find the number of distinct subsets of size 1, 2, . . . ,N that are self-rotating. Two subsets are considered distinct if one contains a point that the other does not contain.
Input
The first line of the input contains one integer N representing the number of points in the input set (1 ≤ N ≤ 1000). Each of the following N lines describes a different point of the set, and contains two integers X and Y giving its coordinates in a Cartesian coordinate system (−109 ≤ X, Y ≤ 109). All points in the input set are distinct.
Output
Output a single line containing N integers S1, S2, . . . , SN. For i = 1, 2, . . . ,N the integer Si must be the number of subsets of i points of the input set that are self-rotating. Since these numbers can be very big, output them modulo 109 + 7.
Input Samples Output Samples
3
1 1
2 2
1 0
3 3 0
7
-2 0
-1 1
0 2
0 0
2 0
1 -1
0 -2
7 21 5 5 3 1 1
1
-1000000000 1000000000
1
ACM/ICPC South America Contest 2016 |
1,334 | 2348 | Dating On-Line | Muito Fácil | AD-HOC | Alex registered in an online dating system to search for the perfect partner. The system requires each of its members to fill a form specifying how much they enjoy N different activities, grading them on a scale from 0 to 100. To present this information to potential dates, the system creates a profile featuring a special kind of polygon called “radial diagram”.
A radial diagram for N activities is drawn by marking N points on the plane. Starting from the vertical direction, the i-th point in clockwise order represents the i-th activity specified by the member, and is a distance Si away from the center of the diagram, where Si is the score given by the member for the corresponding activity. The angle sustained at the center of the diagram from each pair of consecutive points is always the same, and the polygon is formed by drawing the segments whose endpoints are consecutive points. Note that for the purposes of the radial diagram, the first and last points are considered to be consecutive.
For example, if N = 6 Alex might specify the following activities: singing with score S1 = 10, running with score S2 = 60, listening to music with score S3 = 70, traveling with score S4 = 70, eating out with score S5 = 80, and visiting museums with score S6 = 80. Then the corresponding radial diagram would be as shown in the figure below.
The area of a radial diagram depends on the order in which the different activities are specified, and Alex suspects that a profile depicting a radial diagram with greater area might be more successful. For example, the radial diagram in the following figure features the same activities and scores as the example above, but has a greater area.
Alex has asked you to write a program to find the maximum possible area of a radial diagram given a list of activities graded with scores between 0 and 100.
Input
The first line contains an integer N representing the number of activities (3 ≤ N ≤ 105). The second line contains N integers S1, S2, . . . , SN representing the scores given by Alex to each activity (0 ≤ Si ≤ 100 for i = 1, 2, . . . , N).
Output
Output a line with a rational number representing the maximum possible area of a radial diagram featuring the scores given in the input. The result must be output as a rational number with exactly 3 digits after the decimal point, rounded if necessary.
Input Samples Output Samples
6
10 60 70 70 80 80
10002.593
3
100 100 100
12990.381
7
16 37 50 35 12 39 24
2772.765
ACM/ICPC South America Contest 2016 |
1,335 | 2349 | Farm Robot | Muito Fácil | AD-HOC | To discourage birds such as crows and sparrows from feeding on his crops a farmer needed to put some scarecrows in his corn field. His nephew really likes robots, and suggested that he should use a robot scarecrow instead: “A single robot scarecrow can better protect the whole corn field and will last way more than ten traditional ones!”, he said.
Since the farmer thinks his nephew is a smart boy, he took his advice and bought a robot scarecrow. The robot moves along a pathway that surrounds the corn field. In the pathway there are N unmanned charging stations, numbered sequentially in clockwise order starting from 1. The figure below shows an example with eight charging stations.
The robot begins every day at station number 1, and is issued a sequence of commands that are to be performed in order during the day. These commands are generated based on advanced machine learning algorithms that work on data collected by sensors spread through the corn field, ensuring an optimal coverage of the crop. Each command results in the robot moving to another charging station next to the one it is currently at, either in clockwise or counter-clockwise direction.
Despite the promises of optimal coverage by the robot, at the end of a certain day the farmer found part of his crop devastated. To figure out what might have happened the farmer wants to know how many times the robot was at the charging station closest to the devastated area. Given the number of the station closest to the devastated area and the sequence of commands for a single day, can you help the farmer find this number?
Input
The first line contains three integers N , C and S representing respectively the number of posts (2 ≤ N ≤ 100), the number of commands (1 ≤ C ≤ 1000) and the charging station closest to the devastated area (1 ≤ S ≤ N ). The second line contains C integers X1, X2, . . . , XC, representing the sequence of commands received by the robot scarecrow. For i = 1, 2, . . . , C, if Xi is 1 then the i-th command means “move to the next charging station in clockwise order”, whereas if Xi is -1 then the i-th command means “move to the next charging station in counter-clockwise order”. The robot always starts at station number 1.
Output
Output a line with an integer representing the number of times the robot was at station number S during the day.
Input Samples Output Samples
8 8 3
1 -1 1 1 1 -1 1 1
2
5 4 1
1 1 1 1
1
2 1 1
1
1
2 1 2
1
1
2 2 1
-1 1
2
2 2 1
-1 -1
2
ACM/ICPC South America Contest 2016 |
1,336 | 2350 | Game of Matchings | Muito Difícil | AD-HOC | Adam and Carol are having a great time playing the Game of Matchings. The game is played on a string S composed of |S| lowercase English letters, s1s2 . . . s|S|. The goal is to find all matchings of a special kind of pattern P in S. The pattern has length N and is defined by a sequence of integers between 1 and 26.
We consider a contiguous substring sisi+1 . . . si+N−1 starting at position i of S a matching of pattern P if there is a mapping from the numbers in P to lowercase English letters such that the pattern is mapped to sisi+1...si+N−1 but no two distinct numbers are mapped to the same letter.
For instance, if S is ”awawww” and P is [10, 21, 10], the matchings of P are the substrings of S of length three starting at positions 1 and 2: ”awa” and ”waw”. Note that ”www” is not an occurence because pattern numbers 10 and 21 would both map to ’w’.
Adam and Carol lost the answer sheet and are not sure if they are finding all occurrences for some of the strings in the game. Given S and P can you find the number of matchings for them?
Input
The first line contains a non-empty string S of at most 5 × 105 characters. Each character of S is a lowercase English letter from ’a’ to ’z’. The second line contains an integer N representing the size of the pattern (1 ≤ N ≤ |S|). The third line contains N integers P1, P2, . . . , PN denoting the pattern (1 ≤ Pi ≤ 26 for i = 1, 2, . . . ,N).
Output
Output a line with one integer representing the number of matchings of P found in S.
Input Samples Output Samples
awawww
3
10 21 10
2
abcdefghij
10
1 2 3 4 5 6 7 8 9 1
0
abbabaabbaababba
4
1 2 2 1
5
aabcddabccefkkgem
5
10 10 3 14 9
4
ACM/ICPC South America Contest 2016 |
1,337 | 2351 | Hotel Rewards | Difícil | AD-HOC | You are planning to spend your holidays touring Europe, staying each night in a different city for N consecutive nights. You have already chosen the hotel you want to stay in for each city, so you know the price Pi of the room you’ll be staying at during the i-th night of your holidays, for i = 1, . . . ,N.
You will book your accommodation through a website that has a very convenient rewards program, which works as follows. After staying for a night in a hotel you booked through this website you are awarded one point, and at any time you can exchange K of these points in your account for a free night in any hotel (which will however not give you another point).
For example, consider the case with N = 6 and K = 2 where the prices for the rooms are P1 = 10, P2 = 3, P3 = 12, P4 = 15, P5 = 12 and P6 = 18. After paying for the first four nights you would have four points in your account, which you could exchange to stay for free the remaining two nights, paying a total of P1 + P2 + P3 + P4 = 40 for your accommodation. However, if after the first three nights you use two of the three points you earned to stay the fourth night for free, then you can pay for the fifth night and use the final two points to get the sixth one for free. In this case, the total cost of your accommodation is P1 + P2 + P3 + P5 = 37, so this option is actually more convenient.
You want to make a program to find out what the minimum possible cost for your holidays’ accommodation is. You can safely assume that all hotels you want to stay always will have a room available for you, and that the order of the cities you are going to visit cannot be altered.
Input
The first line of input contains two integers N and K, representing the total number of nights your holidays will last, and the number of points you need in order to get a free night (1 ≤ N,K ≤ 105). The second line contains N integers P1, P2, . . . , PN, representing the price of the rooms you will be staying at during your holidays (1 ≤ Pi ≤ 104 for i = 1, 2, . . . ,N).
Output
Output a line with one integer representing the minimum cost of your accommodation for all of your holidays.
Input Samples Output Samples
6 2
10 3 12 15 12 18
37
6 1
10 3 12 15 12 18
25
5 5
1 2 3 4 5
15
ACM/ICPC South America Contest 2016 |
1,338 | 2352 | Internet Trouble | Médio | AD-HOC | The government is planning to provide internet to people in remote areas, in this case small towns that developed on the side of a long and busy highway. There are N towns located side by side along the highway, each taking up exactly one kilometer of highway. The towns are numbered consecutively along the highway from 1 to N . To provide an internet connection, the government is going to place access-point stations with satellite links, which will provide wired connections for the towns.
The stations are to be placed in one or more different towns, being B the cost to build each station. Since the government wants to provide extremely good service, each house will be connected directly to one of these stations. When connecting a house in town i, we must choose a station in town j for connecting that house. The connection cost is then |i − j| × C, where C is the cost of a kilometer of cable. Notice that the intra-town cable cost is small enough to be ignored, so in particular houses in a town where a station is placed do not incur in any cabling cost when connected to that station.
Given N, B, C and the number of houses in each town, write a program to determine the minimum total cost of providing an internet connection for every house in every town, including the cost of building the stations and laying the cabling for each house. Because the government hasn’t decided yet on the final number of access -point stations to be built, you should calculate the minimum cost when there are 1, 2, . . . , N stations.
Input
The first line contains three integers N , B and C representing the number of towns, the cost of building one access-point station and the cost of one kilometer of cable, respectively (1 ≤ N ≤ 6000, 1 ≤ B ≤ 109 and 1 ≤ C ≤ 100). The second line contains N integers H1, H2, . . . , HN, where Hi represents the number of houses in the i-th town (1 ≤ Hi ≤ 109 for i = 1, 2, . . . , N).
Output
Output a line with N integers representing the minimum total cost of providing an internet connection for every house in every town when building 1, 2, . . . , N access-point stations.
Input Samples Output Samples
5 6 1
1 2 3 4 5
21 20 22 25 30
6 8 1
9 10 3 2 7 6
69 36 35 37 42 48
ACM/ICPC South America Contest 2016 |
1,339 | 2353 | Just in Time | Médio | AD-HOC | Hello contestant, I want to play a game. Your coach is in the contest room with a bomb about to explode in his hands. This bomb will be set to detonate in T seconds, and if it detonates in the contest room it is going to explode only your team’s balloons.
I can tell you that the contest room is inside a building that contains N rooms in total. From each room there is exactly one direct tunnel to another room, which can only be used in one direction. For example if room A connects to room B, then you can walk from room A to room B, but not from room B to room A, unless of course room B has a direct tunnel to room A.
The bomb has a special mechanism that detects if your coach stops moving, and if so it immediately triggers the detonation taking all your team’s balloons down. For that reason your coach will constantly walk between the rooms, taking exactly one second to move through each tunnel. The only way for your team to save its balloons is for your coach not to be in the contest room when the bomb detonates.
You don’t have the building map in hand, all I can tell you is that the tunnels are chosen uniformly at random. However, I will give you the possibility to set T , which must be an integer between 2 and N inclusive. Your job is to choose T in such a way that it maximizes your balloons’ chance to survive this riddle.
Let the game begin.
Input
The input consists of a single line that contains one integer N , representing how many rooms there are in the building (2 ≤ N ≤ 109 ).
Output
Output a line with one integer representing the value of T that maximizes your balloons’ chance to survive the riddle.
Input Samples Output Samples
3
3
12
11
ACM/ICPC South America Contest 2016 |
1,340 | 2354 | Kill the Werewolf | Difícil | AD-HOC | In the popular board game One Night Werewolf, players are distributed randomly in the roles of villagers and Werewolves. The goal of the villagers is to decide together on one person to kill during the night – hopefully they will kill a Werewolf. Werewolves pose as villagers in the hope that the person killed is a villager, not a Werewolf.
In the variation Uncertain Werewolf, only one Werewolf exists and the game consists of two phases. During the first phase the players are still uncertain about who they should vote to kill, so each of them chooses two other players as possible victims. After the first phase the Werewolf reveals himself, and then in the second phase each player has to decide which one of their two initial choices they will vote to kill. The Werewolf is the last one to decide between his two initial choices, doing so after all the other players have decided already.
The Werewolf then loses the game if he has more votes than anyone else. If there is a draw, the Werewolf wins.
You are given the votes of N players after the first phase of the game. You should answer how many players could reveal themselves at this point as the Werewolf and still win the game if the other players chose their votes optimally to kill the Werewolf.
Input
The first line contains an integer N (3 ≤ N ≤ 50), the number of players in the game. Each of the following N lines contains two integers, ai and bi (1 ≤ ai , bi ≤ N , ai ≠ bi), the index of the players the i-th player decided to kill in the first voting phase. No player will try to kill himself.
Output
Output a line with one integer representing the number of players that could win the game if they were the Werewolf and everyone played optimally.
Input Samples Output Samples
5
3 4
1 3
2 4
1 3
2 3
4
4
3 4
1 4
4 1
3 1
2
ACM/ICPC South America Contest 2016 |
1,341 | 2355 | Brasil e Alemanha | Fácil | AD-HOC | Brasil e Alemanha foi um jogo inesquecível. Neste jogo a Alemanha marcou 7 gols em 90 minutos, e o Brasil apenas 1. Por ser uma importante marca na história do futebol brasileiro, Leonardo resolveu fazer uma página web para que todos os brasileiros nunca se esquecessem desse dia magnífico.
A página mostrará qual o placar do jogo caso a partida ainda estivesse acontecendo desde aquele fatídico 8 de julho de 2014, considerando que a taxa de gols fosse mantida (Como mostra a figura abaixo). Para facilitar seu trabalho, Leonardo pede sua ajuda para calcular o placar que deverá ser mostrado na página web.
Observações
Como o objetivo do site é chocar o torcedor. Os gols sofridos pelo Brasil devem ser arredondado para cima enquanto os gols sofridos pela Alemanha devem ser arredondados para baixo.
Entrada
A entrada é composta por um número N (90 ≤ N ≤ 109) que indica quantos minutos se passaram desde o apito inicial da partida. A entrada termina quando N = 0.
Saída
A saida deve ser escrita em apenas uma linha: “Brasil B x Alemanha A” onde B e A são inteiros que indicam a quantidade de gols sofridos por Brasil e Alemanha respectivamente.
Exemplo de Entrada Exemplo de Saída
90
100
180
0
Brasil 1 x Alemanha 7
Brasil 1 x Alemanha 8
Brasil 2 x Alemanha 14
Seletiva UFMG 2014 |
1,342 | 2356 | Bactéria I | Fácil | STRINGS | Dr. Henrique realmente adora suas pesquisas com bactérias. Na tentativa de criar bactérias mais resistentes a antibióticos, avaliou o DNA de algumas delas e percebeu uma semelhança nas bactérias que eram mais resistentes do que as demais. Todas elas possuiam uma parte do código genético igual (composto pelas proteínas A, C, G, T). Logo constatou que aquele trecho de código genético é o que define se uma bactéria é resistente ou não. Assim, Dr. Henrique pediu para que você fizesse um programa que avalie se uma bactéria é resistente dado seu DNA e o código genético que leva a resistência.
Entrada
Cada caso teste contém duas strings, D e S, cada qual em uma linha, e representam o DNA da bactéria e a sequência de código genético que leva a resistência. 1 ≤ |D|, |S| ≤ 100. As strings são compostas apenas pelos caracteres: A, C, G, T.
Saída
Imprima uma linha por cada caso teste, contendo a string "Resistente" (sem aspas) caso a bactéria possua o código genético requerido em seu DNA, ou a string "Nao resistente" (sem aspas) caso contrário.
Exemplo de Entrada Exemplo de Saída
ACGTC
CGT
CCCT
AG
Resistente
Nao resistente
Seletiva UFMG 2014 |
1,343 | 2357 | Violência em Sildávia | Muito Difícil | GRAFOS | Rei Leonardo II está muito preocupado com a violência em Sildávia. Todos estão apavorados, dizendo que a situação está para acabar com a vida de todos. Por isso, Leonardo II pediu para seus assessores (de maior nível) refazerem o mapa das estradas do Reino de Sildávia, de maneira que não seja mais possível ir de uma cidade a outra por mais do que um caminho (pode até não haver maneira de ir de uma cidade a outra, o que não pode é haver mais de uma).
Assim, Rei Leonardo II de Sildávia pediu que você fizesse um programa que verifique se o mapa criado por seus assessores é seguro ou não. E sim, ele pediu para você fazer, pois você está aí mesmo 5 horas programando, não lhe custa nada fazer esse pequeno programa. E Leonardo II mandou dizer que caso prefira, o Reino também está precisando de gente para formatar os computadores dos assessores....
Observações
Todas as vias que conectam as cidades são de mão-dupla. Não é garantido que o grafo de entrada seja conexo. Pode haver mais de uma via ligando o mesmo par de cidades.
Entrada
A entrada é composta por diversos casos teste separados por uma linha em branco. Cada caso teste inicia com dois inteiros, N e M, que representam o número de cidades e as estradas respectivamente (1 ≤ N ≤ 10000, 1 ≤ M ≤ (N * (N-1)) ÷ 2). As próximas M linhas contém dois inteiros, A e B, que significam que há uma estrada que liga as cidades A e B (1 ≤ A, B ≤ N).
Saída
Para cada caso teste imprima uma linha contendo a string "Seguro" se o mapa de Sildávia é seguro segundo Leonardo II ou "Inseguro" caso contrário.
No último caso, existe dois caminhos possíveis, para sair da cidade 1 e chegar nela mesma. O primeiro é permanecer nela, o segundo é caminhar pela estrada que liga a ela própria. Por isso esse mapa é inseguro.
Exemplo de Entrada Exemplo de Saída
6 5
1 2
2 3
2 4
4 5
4 6
3 3
1 2
2 3
3 1
2 1
1 1
Seguro
Inseguro
Inseguro
Seletiva UFMG 2014 |
1,344 | 2358 | Bactéria II | Muito Difícil | STRINGS | Recentemente contratado pelo ICPC (Instituto Computacional de Pesquisas Científicas), Doutor Henrique está precisando de sua ajuda novamente! Chefiando um projeto super secreto para o Reino de Sildávia, Dr. Henrique enfrenta um grande problema. As bactérias envolvidas no projeto estão sendo destruídas após serem contaminadas por um tipo de vírus muito raro. Este vírus é capaz de destruir qualquer trecho de código genético das bactérias que seja igual ao seu RNA (código genético do vírus). Sabendo disso, Dr. Henrique quer criar um tipo de bactéria que seja resistente a este tipo de vírus, porém, quer preservar a maior quantidade de código genético das bactérias originais.
O seu objetivo é encontrar a maior substring genética (contém apenas as proteínas A, C, G, T) entre um grupo de bactérias contaminadas. Acompanhemos um exemplo:
Suponhamos que o RNA do vírus é a sequência TCGA. E supomos também que Dr. Henrique possua 3 bactérias de DNA's:
Bactéria 1: GCTTTCGACGAT
Bactéria 2: GATCGAGCTTCGAA
Bactéria 3: GGTCTAGCTAAT
Após a infecção, o vírus irá procurar o primeiro trecho de código a partir do início do DNA da bactéria que seja igual ao seu RNA e irá destruí-lo. E irá repetir o processo até que não haja mais código para ser destruído.
Bactéria 1: GCTTTCGACGAT ⇒ GCTTCGAT ⇒ GCTT
Bactéria 2: GATCGAGCTTCGAA ⇒ GAGCTTCGAA ⇒ GAGCTA
Bactéria 3: GGTCTAGCTAAT
Agora que todas as bactérias estão infectadas, iremos encontrar a maior substring comum a todas, que será o DNA da bactéria que Dr. Henrique tanto procura:
Bactéria 1: GCTT
Bactéria 3: GAGCTA
Bactéria 3: GGTCTAGCTAAT
DNA resultante: GCT
Observações
É importante ressaltar que o vírus sempre avalia o DNA da bactéria infectada a partir do início. Sempre haverá pelo menos uma resposta.
Entrada
A entrada é composta por diversos casos teste. Cada caso contém uma linha com o número N que representa a quantidade de bactérias (1 ≤ N ≤ 20). Em seguida N linhas contendo uma string Si (1 ≤ |Si| ≤ 10000) que representa o código genético de cada bactéria. A N+2 linha contém uma string R (1 ≤ |R| ≤ 1000) que é o RNA do vírus infeccioso. Todas as strings são compostas apenas pelos caracteres: A, C, G, T.
Saída
Uma string por linha para cada caso teste que representa o DNA da bactéria final. Caso haja mais de uma solução, imprima a menor lexicograficamente.
Exemplo de Entrada Exemplo de Saída
3
GCTTTCGACGAT
GATCGAGCTTCGAA
GGTCTAGCTAAT
TCGA
GCT
Seletiva UFMG 2014 |
1,345 | 2359 | Alocando Ambulâncias | Muito Difícil | GRAFOS | Existem muitas cidades no reino de Sildávia, mas nem todas possuem hospitais (muitas são bem pequenas, como vilarejos). Assim, quando uma pessoa necessita de atendimento urgente, o hospital mais próximo envia uma ambulância para socorro (e esta percorre o caminho mínimo para a cidade em que está localizado o paciente). O governador de Sildávia está muito preocupado com esta situação, e deseja saber qual é o tempo máximo que uma pessoa em Sildávia leva para ser socorrida, e pediu para que você respondesse isso para ele.
Observações
O tempo de atendimento tal como o tempo que a ambulância demora para percorrer dentro de uma cidade é desprezado.
Entrada
A entrada consiste de diversos casos teste. Cada caso teste contém três inteiros: N, M e Q (1 ≤ N ≤ 1000, N-1 ≤ M ≤ (N * (N-1)) ÷ 2, 1 ≤ Q ≤ N), que representam o número de cidades em Sildávia, as rodovias que ligam as cidades (duplo-sentido) e o número de cidades que contém um hospital respectivamente. As próximas M linhas contém três inteiros: A, B e W (1 ≤ A, B ≤ N, 1 ≤ W ≤ 50) representando que uma ambulância demora W horas para percorrer uma rodovia que liga as cidades A e B. As outras Q linhas contém um inteiro X (1 ≤ X ≤ N), indicando que na cidade X há um hospital. Não há mais de uma rodovia ligando o mesmo par de cidades. É garantido que uma ambulância pode sair de qualquer cidade e chegar a todas as demais.
Saída
Para cada caso teste, imprima uma única linha com um inteiro que representa o tempo máximo que um habitante de Sildávia demora para ser socorrido por uma ambulância.
Exemplo de Entrada Exemplo de Saída
4 4 1
1 2 3
2 3 1
4 2 2
4 3 4
4
5 8 5
1 2 1
2 3 2
5 4 3
1 4 4
1 5 5
2 5 6
4 3 7
2 4 8
1
2
3
4
5
5
0
Seletiva UFMG 2014 |
1,346 | 2360 | Centrais de Controle | Muito Difícil | PARADIGMAS | Sildávia é um reino muito grande, como todos vocês já devem conhecer. Para controlar todo o sistema de transporte, energia, água, e etc. Sildávia possui centrais de controle para cada uma de suas regiões. Tudo ocorria muito bem, até a chegada da crise economica.
Com a crise, o governador de Sildávia decidiu cortar custos. Para isto, instalou fibra ótica entre as regiões, conectando diversos pares de centrais, de maneira em que cada central conectou-se com as demais direta ou indiretamente. Como o governador não possuia muito dinheiro, ele decidiu utilizar para as N regiões, apenas N-1 cabos. É válido lembrar que nenhuma central ficou desconectada. Com a ligação de fibra ótica, cada central é capaz de controlar uma ou mais centrais que ela está diretamente ligada. Em outras palavras, agora centrais eram capazes de controlar não apenas só sua região, como suas vizinhas ligadas diretamente.
Assim, é possível que algumas centrais de controle em Sildávia possam ser desligadas (pois seriam controladas por centrais em outras regiões), então o governador contratou você para saber de quantas maneiras possíveis podemos desligar centrais de tal forma que todo o reino de Sildávia ainda esteja sobre controle.
Observações
Manter todo o reino de Sildávia sobre controle significa que cada região de Sildávia será controlada por sua central, ou alguma outra central que esteja ligada a sua.
Entrada
A entrada consiste de diversos casos teste. Cada caso possui um inteiro N que é a quantidade de regiões em Sildávia (1 ≤ N ≤ 1000). As próximas N-1 linhas contém as ligações entre as centrais, dois inteiros A e B (1 ≤ A, B ≤ N).
Saída
Para cada caso teste imprima um inteiro que é a quantidade de formas de controlar Sildávia módulo 109+7.
Exemplo de Entrada Exemplo de Saída
1
3
1 2
2 3
5
1 2
1 3
1 4
1 5
1
5
17
No primeiro caso teste, temos apenas uma região em Sildávia. Logo, para termos o controle total, a única forma é deixar a central de controle desta região ligada. No segundo caso, se deixarmos a região 2 ligada, podemos desligar as outras demais, deixar apenas a região 1 ligada, ou deixar apenas a região 3 ligada, ou deixar ambas ligadas, o que nos dá 4 formas. A outra forma é deixar a região 1 e 3 ligada (assim controlamos a região 2) e desligar a 2. Total: 5 formas de controlar Sildávia.
Seletiva UFMG 2014 |
1,347 | 2361 | Entradas e Saídas | Difícil | PARADIGMAS | Alexandre, Dilson, Filipe e Lucas precisavam elaborar questões para a Seletiva da UFMG para a Maratona de 2014 e pensaram no seguinte problema.
Luiz é o mais novo estagiário de uma empresa que desenvolve equipamentos eletrônicos. Uma de suas primeiras tarefas é ligar os pinos de dois componentes, usando ligações em linha reta. Cada um dos dois compoentes possui N pinos, numerados de 1 a N. Os pinos de mesmo número devem ser ligados por uma linha reta. A figura abaixo mostra um exemplo.
Os pinos do componente a esquerda sempre são numerados de cima para baixo. Infelizmente, o mesmo não acontece com os pinos do componente da direita e é necessário que ligações se cruzem. Luiz precisa computar qual é a maior quantidade de ligações que podem ser feitas, de forma que duas ligações não se cruzem, que é 3 no exemplo. Luiz não sabe programar e pediu a sua ajuda para realizar essa tarefa. A entrada consiste no número de pinos, N, e na sequência de numeração dos pinos do segundo componente.
Os ilustríssimos criadores desse problema andam muito ocupados ultimamente e não tiveram tempo de gerar casos de teste. Por isso, sua tarefa é gerar casos de teste com N pinos em que a resposta do problema seja K. Assim, na próxima seletiva, seu gerador de casos de teste pode ser usado e o problema poderá ser utilizado.
Entrada
A entrada contém dois inteiros, N e K (1 ≤ K ≤ N ≤ 106), indicando o número de pinos e a resposta desejada. O final da entrada é indicado por N=K=0.
Saída
Para cada caso de teste, imprima uma linha contendo uma sequência de N inteiros separados por espaço. Essa sequência deve representar a numeração do componente mais a direita que faz com que a resposta do problema criado seja K. Caso existam várias soluções possíveis, imprima a menor lexicograficamente.
Exemplo de Entrada Exemplo de Saída
5 2
0 0
1 5 4 3 2
Seletiva UFMG 2014 |
1,348 | 2362 | Invasão Alienígena | Médio | GEOMETRIA COMPUTACIONAL | Os alienígenas invadiram a terra e vão aniquilar a raça humana, a não ser que você consiga detê-los. Recentemente, o S.B.C. (Sistema Brasileiro de Combate) foi equipado com uma arma laser muito poderosa, que será usada para destruir os inimigos alienígenas. Essa arma é poderosa a ponto de poder destruir tudo dentro de qualquer região circular. Felizmente, é possível controlar milimétricamente os disparos dessa arma, de forma que é possível escolher o centro e o raio da região circular que será destruída.
Isso mesmo, é possível realizar um disparo com raio de destruição grande o suficiente para destruir todos os alienígenas. Infelizmente, não é tão simples assim. Ao fazer isso, é possível que toda a humanidade também seja destruída. Decidiu-se, então, que nenhuma vida humana deveria ser tirada por essa arma laser. É claro que ainda queremos destruir os inimigos alienígenas, oras. Por isso, você foi contratado pela S.B.C.. Seu trabalho é determinar qual é o maior número de alienígenas que podem ser destruídos por um único disparo da arma laser, de forma que nenhum ser humano seja destruído.
Observações
Indivíduos na borda da região de destruição da arma laser também são destruídos. É improvável que meio ser humano consiga sobreviver. Esperamos que seja assim com alienígenas também.
Entrada
A entrada contém vários casos de teste. Cada caso de teste começa com uma linha contendo dois inteiros, N e M (1 ≤ N, M ≤ 100), descrevendo o número de alienígenas e de humanos, respectivamente. Cada uma das N linhas seguintes contém dois inteiros, Xi e Yi (-106 ≤ Xi, Yi ≤ 106), representado as coordenadas de um dos alienígenas. Da mesma forma, cada uma das M linhas seguintes contém dois inteiros, Xi e Yi (-106 ≤ Xi, Yi ≤ 106), representado as coodenadas de um dos seres humanos. Mesmo se tratando de alienígenas, é claro que dois indivíduos não podem ocupar o mesmo lugar. O final da entada é indicado por N=M=0.
Saída
Para cada caso de teste, imprima um inteiro indicando o maior número de alienígenas que podem ser destruídos por um único disparo, sem que nenhum ser humano seja destruído.
Exemplo de Entrada Exemplo de Saída
5 1
0 0
1 0
2 0
1 1
1 -1
3 3
4 1
0 0
2 0
1 1
1 -1
1 0
5 2
0 0
2 2
3 3
4 4
6 6
1 1
5 5
0 0
5
2
3
Seletiva UFMG 2014 |
1,349 | 2363 | Brincando com Transformações | Médio | PARADIGMAS | Luiz é um menino bem diferente dos demais em Sildávia. Ele gosta mesmo é de brincar com sequências de números inteiros. Cansado de brincar sempre com a mesma sequência (de 1 a N), Luiz propos algumas transformações:
PAR(S) e IMPAR(S) são duas transformações que filtram as posições pares ou ímpares de uma sequência S, retornando a nova sequência.
REC(S) = REC(PAR(S)) + REC(IMPAR(S)). Essa transformação recursiva concatena duas sequências de acordo com o operador ( + ), filtrando ambas pelas transformações anteriores.
Como as sequências são muito grandes, Luiz deseja saber apenas o somatório de um intervalo [A, B] módulo 109+7.
Observações
REC(S) = S para |S| = 1. Ou seja, se a sequência possui apenas um elemento, REC dessa sequência é ela própria.
Entrada
A entrada consiste por diversos casos teste. Cada caso possui três inteiros N, A e B que representam o tamanho da sequência original (de 1 a N), e o intervalo [A, B] da transformação REC na sequência original em que se deseja saber sua soma. (1 ≤ A ≤ B ≤ N ≤ 1018).
Saída
Para cada caso teste imprima o somatório em uma única linha módulo 109+7.
Exemplo de Entrada Exemplo de Saída
5 2 4
1000000000 1 1000000000
10
21
No primeiro caso, inicialmente Luiz possuí uma sequência S = {1, 2, 3, 4, 5}. Seja S1 = PAR(S) = {2, 4} e S2 = IMPAR(S) = {1, 3, 5}, então REC(S) = REC(S1) + REC(S2). Para calcular REC(S1) precisamos calcular PAR(S1) = {4} e IMPAR(S1) = {2}. Como REC({4}) = {4} e REC({2}) = {2}, então REC(S1) = {4, 2}. Agora vamos calcular REC(S2). Para isso, seja S21 = PAR(S2) = {3} e S22 = IMPAR(S2) = {1, 5}, então REC(S21) = {3} e como você deve ter notado, REC(S22) = {5, 1}. Logo, REC(S2) = {3, 5, 1}. Assim, REC(S) = REC(S1) + REC(S2) = {4, 2} + {3, 5, 1} = {4, 2, 3, 5, 1}. Como queremos saber apenas o somatório do segundo ao quarto elemento ([2, 4]), então fazemos 2 + 3 + 5 = 10.
Seletiva UFMG 2014 |
1,350 | 2364 | Henrique | Médio | PARADIGMAS | Nos primórdios da computação, os professores exigiam que trabalhos práticos de Algoritmos e Estruturas de Dados II (AEDs II) fossem feitos em uma linguagem chamada DCCembly. Infelizmente, apenas um aluno era insano o bastante para fazer trabalhos a partir do zero utilizando essa linguagem. Esse aluno se chamava Henrique. Os demais alunos copiavam trabalhos de semestres anteriores, o que sempre acabava introduzindo pequenos erros.
Nesse problema, você deve escrever um programa que ajude a detectar essas cópias. Seu programa deve receber como entrada dois programas válidos escritos em DCCembly e retornar como saída a quantidade de entradas (módulo 109 + 7) para as quais ambos os programas retornem a mesma resposta.
Valores de Retorno: [Ii R v]
Para o programa e retorna o valor booleano v ∈{0,1} como saída.
Desvios condicionais: [Ii D j Ik Il]
Lê o valor de entrada xj e desvia a execução para a instrução de rótulo Ik se xj = 1 e Il se xj = 0.
Denotaremos por var(Ii) a variável considerada por uma instrução. Assim, se [Ii D j Ik Il] é uma instrução, var(Ii) = j. Para instruções com valores de retorno como [Ii R v], assumiremos que var(Ii) = M + 1.
Todo programa válido em DCCembly deve satisfazer as seguinte propriedades:
Para toda instrução de rótulo Ii, existe uma entrada X = (x1, …, xM) tal que Ii seja executada quando o programa recebe X.
Para toda instrução de desvio [Ii D j Ik Il], temos var(Ii) < var(Ik) e var(Ii) < var(Il).
Uma instrução de desvio só pode ter como destinos instruções que apareceram previamente no código.
A execução se inicia pela última instrução.
Os identificadores de instruções são únicos dentro de um único programa.
Escreva um programa que receba dois códigos válidos em DCCembly como entrada e retorne o número de entradas distintas para as quais os dois programas tem como saída o mesmo valor. Como a resposta pode ser muito grande, basta computa-la módulo 109 + 7.
Entrada
A entrada é composta por multiplos casos de teste e deve ser lida da entrada padrão. Cada caso de teste começa com uma linha contendo 3 inteiros: M, L0 e L1. O inteiro M (1 ≤ M ≤ 106 ) denota a quantidade de variáveis de entrada. Já L0 corresponde ao número de instruções no primeiro programa (1 ≤ L0 ≤ 1000) e L1 corresponde ao número de instruções no segundo (1 ≤ L1 ≤ 1000).
Em seguida, há L0 linhas contendo o primeiro programa. Instruções de desvio do tipo [Ii D j Ik Il] são denotadas por um identificador Ii (1 ≤ Ii ≤ L0) seguido do caractere “D” e de três inteiros j, Ik, e Il. O inteiro j indica que a variável xj é considerada pelo desvio (1 ≤ j ≤ M). Já os inteiros Ik e Il (1 ≤ Ik, Il ≤ L0) indicam as instruções de destino do desvio caso xj=1 e caso xj = 0, respectivamente. Finalmente, instruções de retorno [Ii R v] são denotadas por um identificador numérico Ii (1 ≤ Ii ≤ L0) seguido do caractere “R” e de um inteiro v ∈{0, 1}.
Finalmente, outras L1 linhas descrevem o segundo programa. Como antes, instruções de desvio do tipo [Ii D j Ik Il] são denotadas por um identificador Ii (1 ≤ Ii ≤ L1) seguido do caractere “D” e de três inteiros j, Ik, e Il. O inteiro j indica que a variável xj é considerada pelo desvio (1 ≤ j ≤ M). Já os inteiros Ik e Il (1 ≤ Ik, Il ≤ L1) indicam as instruções de destino do desvio caso xj=1 e caso xj = 0, respectivamente. Finalmente, instruções de retorno [Ii R v] são denotadas por um identificador numérico Ii (1 ≤ Ii ≤ L1) seguido do caractere “R” e de um inteiro v ∈{0, 1}.
Note que embora os identificadores de instruções são únicos apenas dentro de um único programa.
A entrada termina com uma linha contendo três zeros, que não deve ser processada.
Saída
Para cada caso de teste, imprima uma única linha na saída padrão contendo o número de entradas distintas (x1, …, xM) para as quais ambos os programas retornem a mesma resposta módulo 109 + 7.
Exemplo de Entrada Exemplo de Saída
10 1 1
1 R 0
1 R 0
400 4 5
1 R 0
2 R 1
3 D 3 1 2
4 D 1 3 2
1 R 1
2 R 0
3 D 4 2 1
4 D 3 3 1
5 D 1 4 2
0 0 0
1024
824612832
Seletiva UFMG 2014 |
1,351 | 2365 | Bolão do Brasileirão | Médio | AD-HOC | Muitos irão dizer que é sorte, mas Dilson possui uma incrível habilidade em bolões de campeonatos de futebol. Sua última façanha foi ganhar o bolão da computação da Copa do Mundo acertando, inclusive, os surpreendentes placares de Brasil X Alemanha e Espanha X Holanda. Pensando em se tornar um profissional do bolão, ele pede a você para criar um programa que irá computar o ranking final de um bolão.
Em um bolão, competidores palpitam em placares de partidas de futebol antes do início de um torneio. Após a realização de cada partida, são atribuídos pontos ao participantes de acordo com as seguintes regras:
10 pontos - Se o participante acertou o resultado\footnote{Por resultado compreende-se o time vencedor ou empate} e os gols marcados por cada time.
7 pontos - Se o participante acertou o resultado e os gols marcados por um time.
5 pontos - Se o participante acertou apenas resultado.
2 pontos - Se o participante acertou os gols marcados por um time.
0 pontos - Se o participante não acertou nada.
Ao final do torneio, o participante que tiver mais pontos é o campeão. Neste problema, você deve retornar o ranking final do bolão. A ordem lexicográfica do nome do participante é o único critério de desempate (mais uma vantagem para Dilson).
Entrada
Existem múltiplos casos de teste. A primeira linha de cada caso de teste é composta por 2 inteiros P (1 ≤ P ≤ 10) e N (1 ≤ N ≤ 10) indicando, respectivamente, o número de participantes do bolão e o número de partidas disputadas. As linhas seguintes descreverão os palpites dos participantes.
Os palpites do i-ésimo participante serão descritos em N+1 linhas. A primeira linha possui apenas uma string Si, que é o nome do participante i. As N linhas seguintes descrevem os palpites de cada partida j. Esses palpites são descritos por Aj GAi,j Bj GBi,j, onde Aj e Bj são strings indicando os times que irão se enfrentar na j-ésima partida, GAi,j e GBi,j ( 0 ≤ GAi,j , GBi,j ≤ 100 ) são inteiros que representam, respectivamente, a quantidade de gols que o participante i espera que os times Aj e Bj marquem na partida j. Os participantes sempre palpitam seguindo a mesma ordem. Logo, Aj e Bj será o mesmo para todos os participantes.
Por fim, existem N linhas que descrevem o resultado real das partidas. Cada linha possui Aj RAj Bj RBj, onde RAj e RBj ( 0 ≤ RAj , RBj ≤ 100 ) são inteiros que representam a quantidade de gols marcados pelos times Aj e Bj nesta partida.
A entrada termina quando P = N = 0.
Saída
A saida é descrita em P linhas. Cada linha deve conter uma string Si indicando o nome do jogador e um inteiro Ki, indicando quantos pontos o jogador i marcou, separados por um espaço. Essas linhas devem estar ordenadas de acordo com os valores Ki e o critério de desempate.
Exemplo de Entrada Exemplo de Saída
3 4
Dilson
Barcelona 10 Santos 0
Atletico 9 Cruzeiro 2
Atletico 1 Barcelona 0
PontePreta 2 Cruzeiro 0
Henrique
Barcelona 34 Santos 0
Atletico 0 Cruzeiro 1
Atletico 0 Barcelona 52
PontePreta 0 Cruzeiro 3
Filipe
Barcelona 7 Santos 1
Atletico 0 Cruzeiro 1
Atletico 0 Barcelona 10
PontePreta 0 Cruzeiro 0
Barcelona 10 Santos 0
Atletico 9 Cruzeiro 2
Atletico 3 Barcelona 0
PontePreta 2 Cruzeiro 0
0 0
Dilson 37
Filipe 7
Henrique 7
Dilson marca 10 + 10 + 7 + 10 = 37 Pontos Henrique marca 7 + 0 + 0 + 0 = 7 Pontos Filipe marca 5 + 0 + 0 + 2 = 7 Pontos Filipe fica na frente de Henrique pelo critério de desempate (ordem lexicográfica)
Seletiva UFMG 2014 |
1,352 | 2366 | Maratona | Médio | AD-HOC | A maratona é talvez a prova mais desgastante entre as modalidades olímpicas: são quarenta e dois mil, cento e noventa e cinco metros de percurso. Por isso, os organizadores sempre posicionam vários postos de água ao longo do trajeto da prova, onde copos de água são distribuídos aos competidores.
João Saci é um jovem atleta que tem boas chances de se tornar um maratonista de primeira linha. No entanto, João Saci descobriu que somente consegue terminar uma maratona se ingerir alguns copos de água durante o percurso. O Laboratório de Biomecânica da universidade local, através de experimentos, determinou que João Saci consegue percorrer exatamente mais dois mil metros após o instante em que ingere um copo de água. A distância que João Saci consegue percorrer após ingerir um copo de água é denominada de distância intermediária máxima. Assim, se a distância entre dois postos de água consecutivos no percurso da maratona for sempre menor ou igual do que a distância intermediária máxima de João Saci, ele consegue terminar a prova. Caso contrário ele não consegue terminar a prova.
O Laboratório de Biomecânica quer agora realizar estudos similares com outros maratonistas, que têm valor de distâncias intermediárias máximas distintas, e precisa de sua ajuda.
Sua tarefa é escrever um programa que, dada a posição dos postos de água ao longo do percurso, e a distância intermediária máxima de um atleta, determine se o atleta consegue ou não completar a prova.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado).
A primeira linha da entrada contém dois números inteiros N e M, separados por um espaço em branco, indicando respectivamente o número de postos de água (2 ≤ N ≤ 10000) e a distância intermediária máxima de um atleta, em metros (1 ≤ M ≤ 42195). A segunda linha contém N números inteiros Pi, separados por um espaço em branco, representando a posição dos postos de água ao longo do trajeto da maratona. A posição de um posto de água é dada pela distância, em metros, do início do percurso até o posto de água (0 ≤ Pi ≤ 42195 para 1 ≤ i ≤ N). O primeiro posto de água está sempre localizado no ponto de partida (ou seja, P1 = 0) e todos os postos estão em posições distintas. Além disso, os postos de água são dados na ordem crescente de sua distância ao início do percurso.
Note que a distância total da prova é a oficial para a maratona, ou seja, 42195 metros.
Saída
Seu programa deve imprimir, na saída padrão, uma única linha contendo o caractere ‘S’ se o atleta consegue terminar a prova, ou o caractere ‘N’ caso contrário.
Exemplos de Entrada Exemplos de Saída
3 20000
0 20000 33333
S
8 6000
0 6000 12000 18000 24000 32000 37000 40000
N
OBI - Olimpíada Brasileira de Informática 2011 Fase 2 Nível 1 |
1,353 | 2367 | Competição de Chocolate | Difícil | AD-HOC | Carlos e Paula acabaram de ganhar um saco com bolinhas de chocolate. Como sabem que vão comer tudo muito rápido inventaram uma brincadeira:
Eles vão comer de forma alternada, um depois o outro, sendo que sempre a Paula começa.
A cada vez, só se pode comer de 1 a M bolinhas, sendo o M decidido pela mãe de Paula, de forma que não engasguem com o chocolate.
Se um comeu K bolinhas em sua vez, o próximo não pode comer o mesmo tanto, tendo que comer um número de bolinhas distinto.
Quem não puder mais jogar de maneira válida perde.
Um exemplo de partida para M = 5 e 20 bolinhas, onde Carlos ganhou:
Observe que no final Carlos não poderia comer 2 bolinhas para ganhar, pois seria o mesmo que Paula comeu na vez anterior. Mas Paula também não pôde comer a última bolinha, pois Carlos havia comido apenas uma na rodada anterior, assim Paula ficou sem opção de jogada e perdeu.
Ambos são muito espertos e jogam de maneira ótima, de forma que se existe para um deles uma sequência de jogadas que garante a vitória independente da jogada do outro, essa pessoa jogará dessa forma.
Sua tarefa é determinar quem vai ganhar a brincadeira, se ambos jogam de forma ótima.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado).
A entrada consiste de uma linha contendo dois inteiros N (2 ≤ N ≤ 106) e M (2 ≤ M ≤ 103), sendo N o número de bolinhas de chocolate e M o número de bolinhas permitidas por vez.
Saída
Seu programa deve imprimir, na saída padrão, uma linha, contendo o nome do vencedor, como exemplificado abaixo.
Exemplos de Entrada Exemplos de Saída
5 3
Paula
20 5
Carlos
5 6
Paula
OBI - Olimpíada Brasileira de Informática 2009 Fase 2 Nível 2 |
1,354 | 2368 | Simulador | Médio | AD-HOC | Um novo processador, denominado Faíska, está sendo desenvolvido para a empresa SBC. Este novo processador tem apenas duas instruções: inversão e soma, descritas a seguir.
Inversão: dados dois endereços de memória X e Y , a operação inverte(X,Y) inverte a posição de palavras da memória de forma que
a palavra no endereço X troca de posição com a palavra de memória da posição Y;
a palavra no endereço X + 1 troca de posição com a palavra de memória da posição Y − 1;
a palavra no endereço X + 2 troca de posição com a palavra de memória da posição Y − 2;
e assim por diante, até que X ≥ Y.
Soma: dados dois endereços de memória X e Y, a operação soma(X,Y) imprime a soma das palavras de memória entre os endereços X e Y (inclusive).
Por exemplo, se a memória contém inicialmente, a partir da primeira posição de memória (endereço igual a 1) os valores [1,2,3,4,5,6,7,8], a operação inverte(3,7) deixa a memória igual a [1,2,7,6,5,4,3,8]. Então, nesse estado, a execução de soma(1,3) produz a saída 10.
Sua tarefa é escever um programa que, dada uma sequência de instruções do Faíska, simule a execução e produza o mesmo resultado que o Faíska produziria.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado).
A primeira linha da entrada contém dois números inteiros N e M, representando respectivamente o número palavras na memória (1 ≤ N ≤ 109) e o número de instruções do programa (1 ≤ M ≤ 1000). Cada uma das M linhas seguintes contém uma instrução do Faíska. Cada instrução é composta de um caratere descrevendo a instrução (‘I’ para inversão e ‘S’ para soma), seguido de um espaço, seguido de dois inteiros indicando os argumentos da instrução.
Inicialmente a configuração da memória é tal que cada palavra tem como conteúdo o seu próprio endereço. Em outras palavras, o conteúdo inicial da memória é [1,2,3,. . .,N]. Há pelo menos uma instrução soma em cada caso de teste.
Saída
Seu programa deve imprimir, na saída padrão, uma sequência de números inteiros, um em cada linha, indicando a saída gerada pelo Faíska.
Exemplos de Entrada Exemplos de Saída
10 2
I 1 5
S 3 7
19
15 4
S 2 11
I 10 15
I 1 10
S 5 10
65
21
OBI - Olimpíada Brasileira de Informática 2009 Fase 2 Nível 2 |
1,355 | 2369 | Conta de Água | Muito Fácil | AD-HOC | A empresa local de abastecimento de água, a Saneamento Básico da Cidade (SBC), está promovendo uma campanha de conservação de água, distribuindo cartilhas e promovendo ações demonstrando a importância da água para a vida e para o meio ambiente.
Para incentivar mais ainda a economia de água, a SBC alterou os preços de seu fornecimento de forma que, proporcionalmente, aqueles clientes que consumirem menos água paguem menos pelo metro cúbico. Todo cliente paga mensalmente uma assinatura de R$ 7, que inclui uma franquia de 10 m³ de água. Isto é, para qualquer consumo entre 0 e 10 m³ , o consumidor paga a mesma quantia de R$ 7 reais (note que o valor da assinatura deve ser pago mesmo que o consumidor não tenha consumido água). Acima de 10 m³ cada metro cúbico subsequente tem um valor diferente, dependendo da faixa de consumo. A SBC cobra apenas por quantidades inteiras de metros cúbicos consumidos. A tabela abaixo especifica o preço por metro cúbico para cada faixa de consumo:
Assim, por exemplo, se o consumo foi de 120 m³ , o valor da conta é:
7 reais da assinatura básica;
20 reais pelo consumo no intervalo 11 - 30 m³;
140 reais pelo consumo no intervalo 31 - 100 m³;
100 reais pelo consumo no intervalo 101 - 120 m³.
Logo o valor total da conta de água é R$ 267.
Escreva um programa que, dado o consumo de uma residência em m3, calcula o valor da conta de água daquela residência.
Entrada
A única linha da entrada contém um único inteiro N, indicando o consumo de água da residência, em m³ (0 ≤ N ≤ 10³).
Saída
Seu programa deve imprimir uma única linha, contendo o valor da conta de água daquela residência.
Exemplos de Entrada Exemplos de Saída
8
7
14
11
42
51
OBI - Olimpíada Brasileira de Informática 2010 Fase 1 Nível 1 |
1,356 | 2370 | Times | Fácil | ESTRUTURAS E BIBLIOTECAS | As aulas de educação física, em muitas escolas, acontecem da seguinte maneira: O professor entrega uma bola ao alunos (geralmente de futebol) e estes se dividem em times, onde jogam partidas alternadamente.
A maneira como os times são escolhidos também é semelhante em todas as escolas: decide-se quantos times serão formados, e uma pessoa para montar cada um dos times. Cada pessoa vai escolher, alternadamente, um dos alunos restantes para fazer parte de sua equipe. Como todos querem ter uma boa equipe, a pessoa que vai escolher o próximo membro do time escolhe aquele, dentre os ainda disponíveis, que possui o melhor nível de habilidade. Assim, os times acabam ficando relativamente equilibrados na soma do nível de habilidade dos jogadores.
Dada uma lista de alunos que serão escolhidos e seus respectivos níveis de habilidade para os times e a quantidade de times que serão formados, mostre como ficarão os times ao final do processo de montagem dos mesmos.
Entrada
A primeira linha da entrada contém dois inteiros N (2 ≤ N ≤ 10.000) e T (2 ≤ T ≤ 1000), representando respectivamente a quantidade de alunos e o número de times a serem formados, sendo T ≤ N. As N linhas seguintes descrevem, cada uma, um aluno disponível para escolha de times. Cada uma dessas linhas possui o nome do aluno (composto apenas por letras minúsculas) e um inteiro H (0 ≤ H ≤ 1.000.000) descrevendo seu nível de habilidade).
Não existem dois alunos com o mesmo nível de habilidade, e todos eles possuem nomes diferentes. é possível que alguns times acabem ficando com menos jogadores do que os outros.
Saída
Seu programa deve imprimir a lista de times que será formada ao final do processo de seleção. Para cada time, você deverá mostrar o termo "Time N", onde N é o número do time (1 para o primero, 2 para o segundo, e assim por diante) seguido de K linhas, onde K é a quantidade de jogadores do time, mostrando o nome de cada um dos jogadores do time, em ordem alfabética. Imprima uma linha em branco após cada descrição de time (inclusive do último).
Os times serão escolhidos pelo computador, então não é necessário considerar o aluno que irá fazer a escolha dos times.
Exemplos de Entrada Exemplos de Saída
14 3
felipe 4
alvaro 8
thiago 1
rodrigo 3
robson 2
fabio 9
ricardo 11
rodolfo 0
andre 14
arthur 12
ronaldo 55
rogerio 30
lucas 7
rafael 17
Time 1
andre
fabio
felipe
ronaldo
thiago
Time 2
alvaro
arthur
rodolfo
rodrigo
rogerio
Time 3
lucas
rafael
ricardo
robson
4 3
john 3
richard 0
greg 100
rupert 20
Time 1
greg
richard
Time 2
rupert
Time 3
john
OBI - Olimpíada Brasileira de Informática 2010 Fase 1 Nível 1 |
1,357 | 2371 | Batalha Naval | Difícil | AD-HOC | Pedro e Paulo gostam muito de jogar batalha naval; apesar de serem grandes amigos, Pedro desconfia que Paulo não esteja jogando honestamente. Para tirar essa dúvida, Pedro decidiu usar um programa de computador para verificar o resultado do jogo, mas Pedro não sabe programar e por isso pediu a sua ajuda. O jogo de batalha naval é jogado em um tabuleiro retangular com N linhas e M colunas. Cada posição deste tabuleiro é um quadrado que pode conter água ou uma parte de um navio. Dizemos que dois quadrados são vizinhos se estes possuem um lado em comum. Se duas partes de navio estão em posições vizinhas, então essas duas partes pertencem ao mesmo navio. A regra do jogo proíbe que os quadrados de duas partes de navios distintos tenham um canto em comum (em outras palavras, que quadrados de duas partes de navios distintos compartilhem um vértice). Cada disparo que um jogador faz deve ser feito em um dos quadrados do tabuleiro do outro jogador. Um jogador informa ao outro a coluna e a linha do quadrado alvo do disparo. Para que um navio seja destruído, o jogador deve acertar todas as partes deste navio.
Escreva um programa que, dadas a configuração do tabuleiro e uma sequência de disparos feitos por um jogador, determina o número de navios do outro jogador que foram destruídos.
Entrada
A primeira linha da entrada contém dois inteiros N e M (1 ≤ N ≤ 100 e M ≤ 100) representando respectivamente o número de linhas e de colunas do tabuleiro. As N seguintes linhas correspondem ao tabuleiro do jogo. Cada uma dessas linhas contém M caracteres. Cada caractere indica o conteúdo da posição correspondente no tabuleiro. Se esse caractere for ‘.’, essa posição contém água; se for ‘#’, essa posição contém uma parte de um navio. A próxima linha contém um número K que é o número de disparos feitos pelo jogador (1 ≤ K ≤ N × M ). As próximas K linhas indicam os disparos feitos pelo jogador. Cada linha contém dois inteiros L e C, indicando a linha e a coluna do disparo feito pelo outro jogador (1 ≤ L ≤ N e 1 ≤ C ≤ M).
Saída
Seu programa deve imprimir uma única linha contendo um único número inteiro, o número de navios destruídos. Tenha cuidado ainda que em um conjunto de casos de teste que totaliza 30 pontos, os navios são todos compostos por exatamente uma parte (ou seja, um quadrado) e um conjunto de casos de teste que totaliza 50 pontos, cada navio está contido em exatamente uma linha.
Exemplos de Entrada Exemplos de Saída
5 5
..#.#
#....
...#.
#....
...#.
5
1 3
1 4
1 5
2 1
3 4
4
5 5
..###
.....
#####
.....
#.##.
5
5 1
5 2
1 3
1 4
1 5
2
7 7
.#....#
###..##
.#....#
....#.#
.#..#.#
.####.#
.......
8
1 1
1 2
2 1
2 2
2 3
3 2
5 2
6 2
1
OBI - Olimpíada Brasileira de Informática 2010 Fase 1 Nível 2 |
1,358 | 2372 | Reunião | Fácil | GRAFOS | Todos os anos, a SBC (Sociedade Brasileira de Caminhoneiros) reúne seus membros em alguma cidade para discutir sobre a profissão. Nessas reuniões são discutidos os problemas da categoria e são apresentadas sugestões sobre como melhorar as condições de trabalho.
O grande problema desse tipo de encontro é que os membros estão espalhados pelo país, uma vez que a profissão exige que eles viajem para diversos lugares todos os dias. Por isso, a escolha da cidade onde será feita a reunião sempre é feita de modo que não prejudique demais nenhum dos caminhoneiros. O critério para tal é que a maior das distâncias percorridas pelos caminhoneiros para chegar ao local da reunião deve ser a menor possível. Ou seja, a distância percorrida pelo caminhoneiro que vai percorrer a maior distância entre todos os caminhoneiros para chegar à reunião deve ser a menor possível.
Dadas as cidades onde se encontram os caminhoneiros e a descrição das estradas que interligam essas cidades,escreva um programa que determina qual será a menor distância máxima percorrida por um caminhoneiro parachegar até o local da reunião. Os caminhoneiros conhecem bem as estradas, e portando sempre fazem o menor caminho possível até a cidade da reunião. Sempre existe um caminho ligando quaisquer duas cidades.
Entrada
A primeira linha da entrada possui dois números inteiros N (2 ≤ N ≤ 100) e M (N − 1 ≤ M ≤ 10000), que representam, respectivamente, o número de cidades e o número de estradas que as interligam. As cidades são identificadas por números inteiros entre 0 e N − 1. As próximas M linhas da entrada possuem, cada uma, a descrição de uma estrada. Cada descrição de entrada é composta por três números inteiros: U, V e W, onde Ue V representam cidades (0 ≤ U ≤ N − 1 e 0 ≤ V ≤ N − 1) e W representa o comprimento da estrada que une essas duas cidades (todas as estradas são mão dupla, 1 ≤ W ≤ 100). É sempre possível viajar entre qualquer duas cidades com as estradas existentes, mas pode haver mais de uma estrada ligando o mesmo par de cidades.
Saída
Seu programa deve imprimir uma única linha contendo um número inteiro, a distância máxima percorrida porum caminhoneiro para ir até a reunião, obedecidas as restrições estabelecidas (ou seja, essa distância máximadeve ser a menor possível).
Exemplos de Entrada Exemplos de Saída
4 4
0 1 2
0 2 4
1 3 1
2 3 5
4
4 5
0 1 2
0 2 4
1 3 1
2 3 5
3 2 2
3
7 12
0 1 22
0 2 30
0 5 55
1 5 11
1 6 30
1 2 25
2 3 15
2 6 10
3 4 15
3 5 10
4 5 20
5 6 33
30
OBI - Olimpíada Brasileira de Informática 2010 Fase 1 Nível 2 |
1,359 | 2373 | Garçom | Muito Fácil | AD-HOC | Parte do treinamento de um novo garçom é carregar uma grande bandeja com várias latas de bebidas e copos e entregá-las todas numa mesa do restaurante. Durante o treinamento é comum que os garçons deixem cair as bandejas, quebrando todos os copos.
A SBC - Sociedade Brasileira de Copos - analisou estatísticas do treinamento de diversos garçons e descobriu que os garçons em treinamento deixam cair apenas bandejas que têm mais latas de bebidas que copos.
Por exemplo, se uma bandeja tiver 10 latas e 4 copos, certamente o garçom em treinamento a deixará cair, quebrando os 4 copos. Já se a bandeja tiver 5 latas e 6 copos, ele conseguirá entregá-la sem deixar cair.
Escreva um programa que, dado o número de latas e copos em cada bandeja que o garçom tentou entregar, imprime o total de copos que ele quebrou.
Entrada
A primeira linha da entrada contém um inteiro N (1 ≤ N ≤ 100) representando o número de bandejas que o garçom tentou entregar. As N linhas seguintes representam as N bandejas. Cada linha contém dois inteiros L e C, indicando o número de latas e o número de copos naquela bandeja, respectivamente (0 ≤ L, C ≤ 100).
Saída
Seu programa deve imprimir uma única linha, contendo um único inteiro, indicando o número total de copos que o garçom quebrou.
Exemplos de Entrada Exemplos de Saída
3
10 5
6 8
3 3
5
4
10 6
8 8
5 1
100 100
7
OBI - Olimpíada Brasileira de Informática 2010 Fase 1 Nível Júnior |
1,360 | 2374 | Pneu | Muito Fácil | AD-HOC | Calibrar os pneus do carro deve ser uma tarefa cotidiana de todos os motoristas. Para isto, os postos de gasolina possuem uma bomba de ar. A maioria das bombas atuais são eletrônicas, permitindo que o motorista indique a pressão desejada num teclado. Ao ser ligada ao pneu, a bomba primeiro lê a pressão atual e calcula a diferença de pressão entre a desejada e a lida. Com esta diferença ela esvazia ou enche o pneu para chegar na pressão correta.
Sua ajuda foi requisitada para desenvolver o programa da próxima bomba da SBC - Sistemas de Bombas Computadorizadas.
Escreva um programa que, dada a pressão desejada digitada pelo motorista e a pressão do pneu lida pela bomba, indica a diferença entre a pressão desejada e a pressão lida.
Entrada
A primeira linha da entrada contém um inteiro N que indica a pressão desejada pelo motorista (1 ≤ N ≤ 40). A segunda linha contém um inteiro M que indica a pressão lida pela bomba (1 ≤ M ≤ 40).
Saída
Seu programa deve imprimir uma única linha, contendo a diferença entre a pressão desejada e a pressão lida.
Exemplos de Entrada Exemplos de Saída
30
18
12
27
27
0
27
30
-3
OBI - Olimpíada Brasileira de Informática 2010 Fase 1 Nível Júnior |
1,361 | 2375 | Sedex | Muito Fácil | AD-HOC | A Copa do Mundo de 2010 será realizada na áfrica do Sul. Bolas de futebol são muito fáceis de transportar, já que elas saem das fábricas vazias e só são enchidas somente pelas lojas ou pelos consumidores finais.
Infelizmente o mesmo não pode ser dito das bolas de boliche. Como elas são completamente sólidas, elas só podem ser transportadas embaladas uma a uma, em caixas separadas.
A SBC - Só Boliche Cascavel - é uma fábrica de bolas de boliche que trabalha somente através de encomendas e envia todas as bolas por SEDEX. Como as bolas têm tamanhos diferentes, a SBC tem vários tamanhos de caixas diferentes para transportá-las.
Escreva um programa que, dado o diâmetro de uma bola e as 3 dimensões de uma caixa (altura, largura e profundidade), diz se a bola de boliche cabe dentro da caixa ou não.
Entrada
A primeira linha da entrada contém um inteiro N (1 ≤ N ≤ 10.000) que indica o diâmetro da bola de boliche. A segunda linha da entrada contém 3 números inteiros separados por um espaço cada: a altura A (1 ≤ A ≤ 10.000), seguida da largura L (1 ≤ L ≤ 10.000) e da profundidade P (1 ≤ P ≤ 10.000).
Saída
Seu programa deve imprimir uma única linha, contendo a letra 'S' caso a bola de boliche caiba dentro da caixa ou 'N' caso contrário.
Exemplos de Entrada Exemplos de Saída
3
2 3 5
N
5
5 5 5
S
9
15 9 10
S
OBI - Olimpíada Brasileira de Informática 2010 Fase 1 Nível Júnior |
1,362 | 2376 | Copa do Mundo | Muito Fácil | AD-HOC | Este ano tem Copa do Mundo! O país inteiro se prepara para torcer para a equipe canarinho conquistar mais um título, tornando-se hexacampeã.
Na Copa do Mundo, depois de uma fase de grupos, dezesseis equipes disputam a Fase final, composta de quinze jogos eliminatórios. A figura abaixo mostra a tabela de jogos da Fase final:
Na tabela de jogos, as dezesseis equipes finalistas são representadas por letras maiúsculas (de A a P), e os jogos são numerados de 1 a 15. Por exemplo, o jogo 3 é entre as equipes identificadas por E e F; o vencedor desse jogo enfrentará o vencedor do jogo 4, e o perdedor será eliminado. A equipe que vencer os quatro jogos da Fase final será a campeã (por exemplo, para a equipe K ser campeã ela deve vencer os jogos 6, 11, 14 e 15.
Dados os resultados dos quinze jogos da Fase final, escreva um programa que determine a equipe campeã.
Entrada
A entrada é composta de quinze linhas, cada uma contendo o resultado de um jogo. A primeira linha contém o resultado do jogo de número 1, a segunda linha o resultado do jogo de número 2, e assim por diante. O resultado de um jogo é representado por dois números inteiros M e N separados por um espaço em branco, indicando respectivamente o número de gols da equipe representada à esquerda e à direita na tabela de jogos (0 ≤ M ≤ 20, 0 ≤ N ≤ 20 e M ≠ N).
Saída
Seu programa deve imprimir uma única linha, contendo a letra identificadora da equipe campeã.
Exemplos de Entrada Exemplos de Saída
4 1
1 0
0 4
3 1
2 3
1 2
2 0
0 2
1 2
4 3
0 1
3 2
3 4
1 4
1 0
F
2 0
1 0
2 1
1 0
1 0
1 2
1 2
1 0
2 1
1 0
0 1
0 2
2 1
1 0
2 1
A
OBI - Olimpíada Brasileira de Informática 2010 Fase 1 Nível 1 |
1,363 | 2377 | Pedágio | Muito Fácil | AD-HOC | A invenção do carro tornou muito mais rápido e mais barato realizar viagens de longa distância. Realizar uma viagem rodoviária tem dois tipos de custos: cada quilômetro percorrido na rodovia tem um custo associado (não só devido ao consumo de combustível mas também devido ao desgaste das peças do carro, pneus, etc.), mas também é necessário passar por vários pedágios localizados ao longo da rodovia.
Os pedágios são igualmente espaçados ao logo da rodovia; o começo da estrada não possui um pedágio, mas o seu final pode estar logo após um pedágio (por exemplo, se a distância entre dois pedágios consecutivos for de 37 km e a estrada tiver 111 km, o motorista deve pagar um pedágio aos 37 km, aos 74 km e aos 111 km, logo antes de terminar a sua viagem).
Dadas as características da rodovia e os custos com gasolina e com pedágios, calcule o custo total da viagem.
Entrada
A entrada consiste de duas linhas. A primeira linha da entrada contém dois inteiros L e D (1 ≤ L, D ≤ 104), indicando o comprimento da estrada e a distância entre pedágios, respectivamente. A segunda linha contém dois inteiros K e P (1 ≤ K, P ≤ 104 ), indicando o custo por quilômetro percorrido e o valor de cada pedágio. O primeiro pedágio está localizado no quilômetro D da estrada (ou seja, a distância do início da estrada para o primeiro pedágio é D quilômetros).
Saída
Seu programa deve imprimir uma única linha contendo um único inteiro, indicando o custo total da viagem.
Exemplos de Entrada Exemplos de Saída
111 37
1 10
141
100 30
3 14
342
20 70
9 17
180
OBI - Olimpíada Brasileira de Informática 2010 Fase 1 Nível 1 |
1,364 | 2378 | Elevador | Muito Fácil | AD-HOC | A Subindo Bem Confortavelmente (SBC) é uma empresa tradicional, com mais de 50 anos de experiência na fabricação de elevadores. Todos os projetos da SBC seguem as mais estritas normas de segurança, mas infelizmente uma série de acidentes com seus elevadores manchou a reputação da empresa.
Ao estudar os acidentes, os engenheiros da companhia concluíram que, em vários casos, o acidente foi causado pelo excesso de passageiros no elevador. Por isso, a SBC decidiu fiscalizar com mais rigor o uso de seus elevadores: foi instalado um sensor em cada porta que detecta a quantidade de pessoas que saem e entram em cada andar do elevador. A SBC tem os registros do sensor de todo um dia de funcionamento do elevador (que sempre começa vazio). Eles sabem que as pessoas são educadas e sempre deixam todos os passageiros que irão sair em um andar saírem antes de outros passageiros entrarem no elevador, mas ainda assim eles têm tido dificuldade em decidir se a capacidade máxima do elevador foi excedida ou não.
Sua tarefa é escrever um programa que, dada uma sequência de leituras do sensor e a capacidade máxima do elevador, determinar se a capacidade máxima do elevador foi excedida em algum momento.
Entrada
A primeira linha da entrada contém dois inteiros N e C, indicando o número de leituras realizadas pelo sensor e a capacidade máxima do elevador, respectivamente (1 ≤ N ≤ 1000 e 1 ≤ C ≤ 1000). As N linhas seguintes contém, cada uma, uma leitura do sensor. Cada uma dessas linhas contém dois inteiros S e E, indicando quantas pessoas saíram e quantas pessoas entraram naquele andar, respectivamente (0 ≤ S ≤ 1000 e 0 ≤ E ≤ 1000).
Saída
Seu programa deve imprimir uma uníca linha contendo o caractere ‘S’, caso a capacidade do elevador tenha sido excedida em algum momento, ou o caractere ‘N’ caso contrário.
Exemplos de Entrada Exemplos de Saída
5 10
0 5
2 7
3 3
5 2
7 0
N
5 10
0 3
0 5
0 2
3 4
6 4
S
6 4
0 5
3 5
4 5
1 0
1 1
1 1
S
OBI - Olimpíada Brasileira de Informática 2010 Fase 1 Nível 2 |
1,365 | 2379 | Dança Indígena | Fácil | AD-HOC | A OBI (Organização Brasileira dos Índios) promoverá um festival indígena, onde várias tribos irão se reunir e fazer demonstrações de cultura, como artesanato, danças, pinturas, comidas e etc.
Uma das tribos é a dos Tunak Tunak, que possuem uma apresentação de dança muito peculiar. Nessa dança, existem N toras de madeira encrustadas no chão, dispostas de maneira circular e igualmente espaçadas. Em algumas dessas toras fica um índio, olhando em sentido horário ou anti-horário.
A cada batida do tambor, os índios pulam para a próxima tora (que depende da direção para onde ele está olhando no momento). Durante a dança, porém, algumas coisas podem acontecer:
Dois índios que pulam em sentidos opostos caem na mesma tora ao mesmo tempo. Nesse caso, ambos permanecem nas toras, mas passam a pular na direção contrária a partir da próxima batida de tambor (isso é, quem estava pulando em sentido horário passa a pular em sentido anti-horário, e vice-versa).
Dois índios em toras consecutivas vão pular um em direção ao outro. Nesse caso, os índios simplesmente não pulam (para não causar nenhum acidente), e, assim como no caso anterior, passam a pular no sentido contrário a partir da próxima batida de tambor.
Note que se o índio não pula e inverte seu sentido, mas ao mesmo tempo um outro índio cair na mesma tora no sentido contrário, caimos no primeiro caso, e ambos os índios na tora invertem seus sentidos (assim, o índio que estava na tora anteriormente inverte seu sentido novamente).
A dança termina quando as toras ocupadas por um índio são exatamente as mesmas toras ocupadas no início da dança, não importando qual índio está em cada tora e nem os sentidos para onde eles estão pulando.
A figura abaixo ilustra (a) uma configuração inicial com oito toras e seis índios; (b) a posição dos índios após uma batida de tambor; e (c) a posição dos índios após duas batidas de tambor.
Os índios querem se preparar para a dança e precisam saber quanto tempo ela vai durar.
Para isso, você deverá escrever um programa que, dados a quantidade de toras que serão utilizadas, a quantidade de índios e a posição inicial de cada um, calcule quantas batidas de tambor levará para que a dança termine.
Entrada
A primeira linha da entrada possui 2 inteiros: N (3 ≤ N ≤ 1.000.000) e E (1 ≤ E ≤ 1000), que são, respectivamente, a quantidade de toras e a quantidade de índios que irão dançar (E ≤ N). As próximas E linhas contém, cada uma, a descrição da posição inicial de cada índio. Cada linha possui dois inteiros: V (1 ≤ V ≤ N) e D (D = 1 ou D = -1) que representam, respectivamente, o número da tora onde o índio inicia e seu sentido inicial (1 se horário, -1 se anti-horário). A numeração das toras obedece o sentido horário. No início da dança uma tora terá, no máximo, um índio.
Saída
Seu programa deverá exibir um número inteiro representando a quantidade de batidas de tambor necessárias para que a dança acabe.
Exemplos de Entrada Exemplos de Saída
6 4
2 1
3 1
5 1
6 1
3
3 1
2 -1
3
8 6
2 -1
3 1
4 -1
6 1
7 -1
8 1
4
OBI - Olimpíada Brasileira de Informática 2010 Fase 2 Modalidade Nível 1 |
1,366 | 2380 | Fusões | Fácil | ESTRUTURAS E BIBLIOTECAS | A informatização dos sistemas bancários permitiu grandes economias de tempo e dinheiro, permitindo que vários tipos de transações financeiras pudessem ser realizadas pela Internet. Para possibilitar isso, cada banco recebeu um código bancário, que é um número utilizado pelos sistemas de computador para identificar cada banco.
Quando um banco decide comprar outro, ocorre o que se chama uma fusão: os dois bancos tornam-se um só banco. Para manter compatibilidade com os sistemas eletrônicos dos bancos, qualquer um dos códigos dos antigos bancos pode ser usado para se referir ao novo banco.
Com a crise econômica internacional, as fusões entre bancos têm sido cada vez mais comuns; por isso, muitas vezes é difícil decidir se dois códigos bancários na realidade se referem ao mesmo banco (devido aos dois bancos terem se fundido, diretamente ou não).
Escreva um programa que, dada uma série de fusões entre bancos, responde a várias consultas perguntando se dois códigos bancários se referem ao mesmo banco.
Entrada
A primeira linha da entrada contém dois inteiros N e b, indicando o número de bancos e o número de operações efetuadas (1 ≤ N ≤ 100.000, 1 ≤ K ≤ 100.000). Os códigos de cada um dos N bancos, inicialmente, são os inteiros de 1 até N.
Cada uma das K linhas seguintes descreve ou uma fusão entre bancos ou uma consulta.
Uma fusão é descrita na entrada como uma linha que começa com o caractere 'F', um espaço, e dois códigos bancários, que se referem aos dois bancos que estão sofrendo a fusão, separados por um espaço em branco;
Uma consulta é descrita na entrada como uma linha que começa com o caractere 'C', um espaço, e os dois códigos a serem consultados, separados por um espaço em branco. Os códigos bancários consultados são sempre distintos.
As fusões são sempre realizadas entre bancos diferentes, e todos os códigos bancários fornecidos na entrada são válidos.
Saída
Seu programa deve imprimir uma linha para cada consulta na entrada. Caso os dois códigos bancários consultados se refiram ao mesmo banco, imprima uma linha contendo o caractere 'S'; caso contrário, imprima uma linha contendo apenas o caractere 'N'.
Exemplos de Entrada Exemplos de Saída
3 5
C 1 2
F 1 2
C 1 2
F 1 3
C 1 3
N
S
S
4 5
F 1 2
F 2 3
C 1 3
F 2 4
C 1 4
S
S
4 4
F 1 2
F 3 4
F 1 3
C 2 4
S
OBI - Olimpíada Brasileira de Informática 2010 Fase 2 Modalidade Nível 1 |
1,367 | 2381 | Lista de Chamada | Muito Fácil | AD-HOC | Tia Joana é uma respeitada professora e tem vários alunos. Em sua última aula, ela prometeu que iria sortear um aluno para ganhar um bônus especial na nota final: ela colocou N pedaços de papel numerados de 1 a N em um saquinho e sorteou um determinado número K; o aluno premiado foi o K-ésimo aluno na lista de chamada.
O problema é que a Tia Joana esqueceu o diário de classe, então ela não tem como saber qual número corresponde a qual aluno. Ela sabe os nomes de todos os alunos, e que os números deles, de 1 até N, são atribuídos de acordo com a ordem alfabética, mas os alunos dela estão muito ansiosos e querem logo saber quem foi o vencedor.
Dado os nomes dos alunos da Tia Joana e o número sorteado, determine o nome do aluno que deve receber o bônus.
Entrada
A primeira linha contém dois inteiros N e K separados por um espaço em branco (1 ≤ K ≤ N ≤ 100). Cada uma das N linhas seguintes contém uma cadeia de caracteres de tamanho mínimo 1 e máximo 20 representando os nomes dos alunos. Os nomes são compostos apenas por letras minúsculas de 'a' a 'z'.
Saída
Seu programa deve imprimir uma única linha, contendo o nome do aluno que deve receber o bônus.
Exemplos de Entrada Exemplos de Saída
5 1
maria
joao
carlos
vanessa
jose
carlos
5 5
maria
joao
carlos
vanessa
jose
vanessa
5 3
maria
joao
carlos
vanessa
jose
jose
OBI - Olimpíada Brasileira de Informática 2010 Fase 2 Modalidade Nível 1 |
1,368 | 2382 | Sedex Marciano | Fácil | AD-HOC | Estamos no ano 2048 e um dos sonhos da humanidade torna-se finalmente realidade: a colonização do planeta Marte. Nossos primeiros colonizadores acabam de chegar, e já começam a fazer as preparações (como a instalação de cúpulas de oxigênio e tratamento do solo para agricultura) para que mais pessoas possam tentar uma nova vida no planeta vizinho.
Apesar dos avanços tecnológicos e desafios vencidos, ainda resta um grande problema: os foguetes usados para ir a Marte ainda são complicados e caros. Com isso, fica difícil enviar suprimentos para os nossos colonos (enquanto a agricultura ainda não é possível) por muito tempo. Assim, a agência espacial contratou o SBC (Serviço Balístico Cósmico), que desenvolveu um canhão super-potente que consegue disparar esferas até Marte, sem precisar gastar milhões de dólares em equipamento e combustível.
Agora, tudo o que é necessário fazer para enviar suprimentos a Marte é colocar uma caixa com as encomendas dentro de uma esfera e disparar a mesma até seu destino.
Dadas as dimensões de uma caixa com suprimentos e o raio interno da esfera que é disparada pelo canhão, seu programa deverá dizer se é possível enviar tal caixa para Marte usando tal esfera.
Entrada
Cada entrada contém apenas uma linha com quatro inteiros L, A, P e R, (0 ≤ L, A, P, R ≤ 1000) que representam, respectivamente, a largura, altura e profundidade da caixa, e o raio da esfera.
Saída
Seu programa deve imprimir um único caractere: 'S' (sem aspas) se é possível colocar a caixa dentro da esfera, ou 'N' (sem aspas) caso contrário.
Exemplos de Entrada Exemplos de Saída
10 20 30 30
S
10 10 10 7
N
2 4 4 3
S
OBI - Olimpíada Brasileira de Informática 2010 Fase 2 Modalidade Nível 1 |
1,369 | 2383 | Altas Aventuras | Médio | AD-HOC | Incentivado por um filme de animação recente, vovô resolveu realizar seu sonho de criança, fazendo sua pequena casa voar amarrada a balões de hélio. Comprou alguns balões coloridos de boa qualidade, para fazer alguns testes, e começou a planejar a grande aventura. A primeira tarefa é determinar qual a quantidade de hélio máxima que pode ser injetada em cada balão de maneira que ele nao estoure.
Suponha que os valores possíveis de quantidade de hélio em cada balão variem entre os valores 1 e N. Claro que vovô poderia testar todas as possibilidades, mas esse tipo de solução ineficiente não é apropriada, ainda mais considerando que vovô comprou apenas K balões para os testes.
Por exemplo, suponha que N = 5 e K = 2. Nesse caso, a melhor solução seria testar primeiro em 3. Caso o balão estoure, vovô só teria mais um balão, então teria de testar 1 e 2 no pior caso, somando ao todo 3 testes. Caso o balão não estoure, vovô poderia testar 4 e depois 5 (ou 5 e depois 4), também somando 3 ao todo.
Dados a capacidade máxima da bomba e o número de balões, indique o número mínimo de testes que devem ser feitos, no pior caso, para determinar o ponto em que um balão estoura.
Entrada
A única linha da entrada contém dois inteiros, N e K, separados por espaço em branco (1 ≤ K ≤ N ≤ 109).
Saída
Seu programa deve imprimir uma única linha, contendo um inteiro que representa o número mínimo de testes que devem ser feitos no pior caso para determinar o ponto em que o balão estoura.
Exemplos de Entrada Exemplos de Saída
5 2
3
20 2
6
11 5
4
OBI - Olimpíada Brasileira de Informática - 2010 Fase 2 Modalidade Nível 2 (P2) |
1,370 | 2384 | Tradutor Alienígena | Difícil | AD-HOC | É de conhecimento público e notório que já fomos visitados por alienígenas diversas vezes. A grande dificuldade que temos, porém, é a comunicação com eles, por causa de grandes diferenças entre as línguas. Além disso, assim como nós, eles também têm várias línguas diferentes.
Com o intuito de auxiliar no processo de tradução, foi criado um método de mapeamento dos símbolos do alfabeto de cada língua alienígena, atribuindo um número inteiro para cada símbolo. Sendo assim, para um alfabeto alienígena com N elementos, atribui-se números de 1 a N a cada um.
O problema é que o encarregado de transcrever os textos alienígenas para números não foi muito cuidadoso e usou o mesmo espaçamento entre dígitos e números. Assim, por exemplo, digamos que para um alfabeto com 32 símbolos, uma sequência que deveria ser “31 20 4 19” virou “3120419”. Como se pode notar, há diferentes maneiras válidas de interpretar essa sequência além da original, como por exemplo “3 1 20 4 19” e “31 20 4 19”. Repare que a transcrição nunca usa zeros à esquerda de um número e, portanto, a sequência “3 12 04 19” é inválida, assim como “31 20 41 9” por conter um número (49) que não corresponde a um símbolo.
Dados a quantidade de símbolos do alfabeto e uma sequência transcrita, determine quantas sequências válidas podem ser formadas.
Entrada
A entrada é composta por duas linhas. A primeira contém um número inteiro N (1 < N < 10100) que indica a quantidade de símbolos do alfabeto. A segunda linha contém uma cadeia de dígitos de tamanho mínimo 1 e tamanho máximo 100.000 que corresponde a sequência transcrita.
Saída
Seu programa deve imprimir uma linha com o resto da divisão da quantidade de sequências válidas por 1.000.000.007.
Exemplos de Entrada Exemplos de Saída
32
3120419
4
32
4021333251231253
0
500
12345
13
OBI - Olimpíada Brasileira de Informática - 2010 Fase 2 Modalidade Nível 2 (P2) |
1,371 | 2385 | Multiplicação de Matrizes | Médio | AD-HOC | O conglomerado indiano Tutu é um conjunto de empresas que atua nos mais diversos ramos da indústria, produzindo desde sapatos até aviões e foguetes. Por ser tão diversificada, precisa de grandes e rápidos sistemas para cálculos de contabilidade.
Um dos módulos mais importantes desse sistema é o de fornecimento de produtos, onde fica a base de dados de produtos e fornecedores. Um mesmo produto pode ser fornecido por vários fornecedores diferentes.
O sistema possui duas grandes matrizes: a matriz A, onde cada linha representa um produto e cada coluna representa um fornecedor. O valor da matriz na linha m e coluna n representa o preço do produto m se for comprado do fornecedor n.
A outra grande matriz é a B, onde cada linha representa um dia do mês e cada coluna é um produto. O valor da matriz na linha m e coluna n representa a quantidade do produto n a ser adquirido no dia m. Tal empresa tem uma política de fidelidade com seus fornecedores, e uma das práticas efetuadas pela empresa é, em um determinado dia, comprar todos os produtos necessários de um único fornecedor. Isto é, em um dia todos os produtos adquiridos serão comprados do fornecedor x, no outro dia do fornecedor y, e assim por diante.
Para auxiliar a escolha de qual fornecedor será o escolhido no dia, foi gerada outra matriz C, que é o resultado da multiplicação das matrizes A × B. Essa matriz diz o quanto será gasto pela empresa se adquirir todos os produtos de um determinado fornecedor em um determinado dia.
As matrizes A e B são quadradas (o número de linhas é igual ao número de colunas) e têm valores definidos pelas fórmulas:
Aij = (P × i + Q × j) (mod X)
Bij = (R × i + S × j) (mod Y)
onde i é o índice da linha da matriz e j é o índice da coluna da matriz (todos os índices vão de 1 até N). Os inteiros P, Q, R, S, X e Y são parâmetros constantes, que definem as duas matrizes A e B.
Escreva um programa que, dados os parâmetros das matrizes A e B, e a posição de uma das entradas as matriz C, calcula o valor daquela entrada.
Entrada
A primeira linha da entrada contém um inteiro N, indicando as dimensões das matrizes A, B e C (2 ≤ N ≤ 105). A linha seguinte contém seis inteiros P, Q, R, S, X e Y, indicando os parâmetros das matrizes A e B (2 ≤ X, Y ≤ 104; 0 ≤ P, Q < X; 0 ≤ R, S < Y).
Finalmente, a última linha da entrada contém dois inteiros I e J, indicando a linha e a coluna da matriz C a serem consultados (1 ≤ I, J ≤ N).
Saída
Seu programa deve imprimir uma única linha contendo o valor da matriz C na linha e coluna especificadas.
Exemplos de Entrada Exemplos de Saída
3
4 3 2 3 5 6
2 2
18
4
3 5 1 0 6 7
4 3
30
2
2 2 0 1 3 2
2 1
2
OBI - Olimpíada Brasileira de Informática - 2010 Fase 2 Modalidade Nível 2 (P2) |
1,372 | 2386 | Telescópio | Fácil | AD-HOC | Telescópios são instrumentos que auxiliam a observação do céu, melhorando e aumentando o aspecto das estrelas, planetas e outros objetos brilhantes. Existem diversos tipos de telescópios, sendo os tipos mais comuns os de lentes objetivas (refratores) e os de espelhos (refletores).
A maneira como os telescópios melhoram a nossa percepção dos astros no céu é aumentando a quantidade de luz captada que chega aos nossos olhos. Toda luz que entra pelos nossos olhos entra por um orifício chamado pupila. Tal controla a quantidade de luz que entra nos olhos, aumentando o diâmetro quando o ambiente está escuro (e portanto precisamos obter mais luz para identificar os objetos) e diminuindo quando o ambiente está claro. Num ambiente muito escuro, a pupila pode atingir um diâmetro de 8 mm.
Cada objeto celeste (estrela, planeta, nebulosa, etc) emite uma quantidade de luz (fótons) que é homogeneamente distribuída quando chega na Terra. Por exemplo, a estrela A emite luz que pode ser captada a um fluxo de 40.000 fótons por segundo por milímetro quadrado. Isso é, a cada segundo, é possível captar 40.000 fótons provenientes da estrela A numa área de 1 mm 2. Ou seja, uma pupila de 10 mm 2 de área captaria 400.000 fótons provenientes da estrela A por segundo.
Para que nosso cérebro consiga interpretar que existe um objeto ali, porém, ele precisa receber 40.000.000 fótons por segundo. Assim, podemos utilizar um telescópio com lente (ou espelho) de 100 mm 2 de área, que vai captar a quantidade necessária de fótons provenientes da estrela A e encaminhá-los até nossa pupila, fazendo assim com que nosso cérebro perceba a presença da estrela ali.
Dada uma lista com estrelas no céu, o fluxo de fótons que cada uma delas emite, e área de abertura de um telescópio, dizer quantas estrelas serão perceptíveis usando tal telescópio.
Entrada
A primeira linha da entrada terá um inteiro A (1 ≤ A ≤ 10.000) representando a área de abertura do telescópio (em milímetros quadrados) a ser considerado. A segunda linha possui um inteiro N (1 ≤ N ≤ 10.000) representando o número de estrelas a serem estudadas. As N linhas seguintes terão, cada uma, um inteiro F (1 ≤ F ≤ 20.000) representando o fluxo de fótons que cada uma das N estrelas emitem (em fótons por segundo por milímetro quadrado).
Saída
Imprima um inteiro representando a quantidade de estrelas que serão percebidas ao se utilizar o telescópio em questão.
Exemplos de Entrada Exemplos de Saída
10000
3
4000
3500
5100
2
5869
3
3975
14234
8569
2
2967
9
18650
18338
2400
17702
14619
13934
7979
16316
10533
6
OBI - Olimpíada Brasileira de Informática - 2010 Fase 2 Modalidade Nível 2 (P2) |
1,373 | 2387 | Dentista | Fácil | AD-HOC | Os dentistas são extremamente meticulosos em seu trabalho, tendo que agir com muita precisão em todas as suas atividades. Pedro é um dentista meticuloso como todos os outros. Infelizmente sua secretária não é muito organizada e, com o intuito de ajudar sempre os pacientes, aceita que eles marquem consultas no horário que quiserem, sem se preocupar com os demais horários marcados, ocasionando vários conflitos de horários que muito incomodaram Pedro e os pacientes. Por exemplo, se uma consulta começar às 9 horas e durar 2 horas, nenhuma outra consulta deveria ser marcada para iniciar às 10 horas.
Ao perceber que sua agenda tinha conflito de horários, Pedro pediu sua ajuda para descobrir a maior quantidade de consultas que podem ser atendidas sem sobreposição.
Você deve escrever um programa que, dados os horários de início e término das consultas agendadas pela secretária, responda a quantidade máxima de consultas que podem ser atendidas sem sobreposição.
Entrada
A primeira linha da entrada contém um inteiro N (1 ≤ N ≤ 10.000) que indica quantas consultas a secretária marcou. Cada uma das N linhas seguintes contém um par de inteiros X e Y separados por um espaço em branco (0 ≤ X < Y ≤ 1.000.000) que representam, respectivamente, o horário de início e de término da consulta. Considere que se uma consulta inicia no exato instante em que outra termina não há sobreposição. Os horários de início são fornecidos em ordem, podendo haver mais de uma consulta que inicie no mesmo horário.
Saída
Seu programa deve imprimir uma única linha, contendo um inteiro que representa a quantidade máxima de consultas que podem ser atendidas sem que haja qualquer sobreposição.
Exemplos de Entrada Exemplos de Saída
3
10 100
40 130
120 200
2
4
10 20
20 30
30 40
40 50
4
5
10 30
20 40
30 60
40 80
60 100
3
OBI - Olimpíada Brasileira de Informática 2010 Fase 2 Programação Nível Júnior |
1,374 | 2388 | Tacógrafo | Muito Fácil | AD-HOC | Tacógrafos são dispositivos instalados em determinados tipos de veículos, que registram a velocidade, tempo e distância percorrida por tal veículo. É utilizada principalmente em veículos de transporte coletivo e de transporte de cargas, assim ajudando a evitar abusos de velocidade por parte dos motoristas.
A empresa SBC (Sociedade Brasileira dos Caminhoneiros) decidiu encomendar uma versão um pouco mais básica (e barata) para seus associados não precisarem gastar tanto na instalação desses aparelhos. Essas versões modificadas registram apenas os intervalos de tempo e as velocidades médias do caminhão naqueles intervalos.
Apesar das restrições dos aparelhos novos, a SBC quer poder saber qual foi a distância percorrida pelos caminhões. Você deverá escrever um programa que recebe uma série de intervalos de tempo com suas respectivas velocidades médias e calcula qual foi a distância total percorrida pelo caminhão de acordo com o tacógrafo.
Entrada
A primeira linha da entrada contém um inteiro N (1 ≤ N ≤ 1000) representando a quantidade de intervalos de tempo registrados no tacógrafo. As N linhas seguintes descrevem os intervalos de tempo. Cada uma dessas linhas possui dois inteiros T e V (1 ≤ T ≤ 100, 0 ≤ V ≤ 120), que representam, respectivamente o tempo decorrido (em horas) e a velocidade média (em quilômetros por hora) no intervalo de tempo.
Saída
Seu programa deve imprimir uma única linha, contendo um único número inteiro representando a distância total percorrida, em quilômetros.
Exemplos de Entrada Exemplos de Saída
3
10 0
55 12
75 120
9660
10
45 46
46 101
7 2
95 104
12 107
78 29
10 26
52 86
13 79
1 107
26022
8
37 24
68 69
28 26
79 8
36 0
50 71
13 68
87 113
21205
OBI - Olimpíada Brasileira de Informática 2010 Fase 2 Programação Nível Júnior |
1,375 | 2389 | Floresta | Difícil | AD-HOC | O desmatamento é um dos maiores problemas enfrentados pelo Brasil hoje; estima-se que mais de 10 mil km² de vegetação sejam desflorestados todo ano. Além de destruir os habitats de várias espécies em risco de extinção, o desmatamento promove a emissão de gás carbônico, principal responsável pelo efeito estufa e pelo aquecimento global.
A Fundação de Conservação dos Carvalhos (FCC) tenta combater esta tendência, promovendo o reflorestamento das regiões desmatadas. Para isso, eles pretendem plantar carvalhos formando um quadriculado (um carvalho em cada vértice); no centro de cada quadrado formado por eles, a FCC também plantará um eucalipto. Para preservar a biodiversidade da área plantada, pelo menos uma árvore de cada espécie deve ser plantada durante o reflorestamento.
Por exemplo, se a FCC quiser plantar 23 árvores, ela poderá fazê-lo de duas maneiras: ou formando um retângulo 3 × 5 com os carvalhos, como na figura (a), ou formando um retângulo 2 × 8, como na figura (b). Considere que, para os propósitos deste problema, um retângulo X×Y é equivalente a um retângulo Y×X.
Sua tarefa é escrever um programa que, dado o número total de árvores que devem ser plantadas, de quantas maneiras diferentes elas podem ser dispostas.
Entrada
A única linha da entrada contém um único inteiro N, que indica o número total de árvores que devem ser plantadas (1 ≤ N ≤ 109).
Saída
Seu programa deve imprimir uma única linha, contendo um único inteiro, indicando o número de arranjos distintos que podem ser feitos para o reflorestamento.
Exemplos de Entrada Exemplos de Saída
23
2
7
0
53
3
OBI - Olimpíada Brasileira de Informática - 2010 Fase 2 Modalidade Nível 2 (P2) |
1,376 | 2390 | Escada Rolante | Fácil | AD-HOC | O Shopping Boas Compras - SBC, através de sua política ambiental, está preocupado com o consumo de energia e, resolveu trocar todas as escadas rolantes por modelos mais modernos, que se desligam caso ninguém esteja utilizando, poupando energia.
A nova escada rolante possui um sensor no início. Toda vez que ela está vazia e alguém passa pelo sensor, a escada começa a funcionar, parando de funcionar novamente após 10 segundos se ninguém mais passar pelo sensor. Estes 10 segundos representam o tempo suficiente para levar alguém de um nível ao outro.
Preocupados em saber exatamente quanto de energia o shopping está economizando, o gerente pediu sua ajuda. Como eles sabem qual era o consumo da escada rolante antiga, eles te pediram para calcular o tempo que a nova escada ficou funcionando.
Dados os instantes, em segundos, em que passaram pessoas pela escada rolante, você deve calcular quantos segundos ela ficou ligada.
Entrada
A primeira linha da entrada contém um inteiro N que indica o número de pessoas que o sensor detectou (1 ≤ N ≤ 1.000). As N linhas seguintes representam o instante em que a n-ésima pessoa passou pelo sensor e contém um inteiro T (0 ≤ T ≤ 10.000). Os tempos estão em ordem crescente, sem repetições.
Salida
Seu programa deve imprimir uma única linha, contendo o tempo que a escada rolante ficou ligada.
Exemplos de Entrada Exemplos de Saída
3
0
10
20
30
5
5
10
17
20
30
35
3
1
2
3
12
OBI - Olimpíada Brasileira de Informática 2010 Fase 2 Programação Nível Júnior |
1,377 | 2391 | Progressões Aritméticas | Médio | AD-HOC | Bob é um aluno do ensino médio que gosta muito de matemática. Na última aula ele aprendeu o que são Progressões Aritméticas (PAs) e ficou fascinado por elas. Pelo que Bob entendeu, Progressões Aritméticas são sequências de números nas quais a diferença entre dois elementos consecutivos é sempre igual a uma constante r, chamada de razão da PA.
Um exemplo de Progressão Aritmética de razão 2 é −1, 1, 3, 5. Além disso, toda sequência com um ou dois elementos é sempre uma Progressão Aritmética. Por outro lado, 5, 6, 8, 9, 10 não é uma PA porque a diferença entre elementos consecutivos não é constante: a diferença entre os dois primeiros elementos é 6−5 = 1, enquanto a diferença entre o terceiro e o segundo elementos é 8−6 = 2.
Bob percebeu que qualquer sequência, mesmo que a mesma não seja uma Progressão Aritmética, pode ser quebrada em sequências menores que são PAs. Por exemplo, vimos que a sequência 5, 6, 8, 9, 10 não é uma PA, mas podemos quebrar ela entre o 6 e o 8 para obtermos as sequências 5, 6 e 8, 9, 10, que são PAs. Note que não existe como quebrar a sequência em menos partes se quisermos ter apenas PAs no fim do procedimento.
Bob é fascinado por programação mas ainda não sabe programar muito bem, e por isso pediu sua ajuda: ele não está conseguindo descobrir como quebrar sequências muito grandes de um jeito eficiente; por isso, pediu que você escrevesse um programa para, dada uma sequência qualquer, imprimir o número mínimo de partes em que precisamos quebrar a sequência para termos apenas Progressões Aritméticas no término do processo. Caso a sequência original já seja uma PA, podemos terminar o processo com uma única parte, e portanto a resposta para esse caso é 1.
É fácil verificar que a sequência −2, 0, 2, 3, 3, 4, 6 (do segundo caso de teste abaixo) não é uma PA, pois 2−0 ≠ 3−2. Verificando manualmente, você pode constatar que não é possível particionar a sequência em duas de tal forma que ambas as partes sejam PAs. Entretanto, existe uma maneira de particionar a sequência em 3 PAs: [−2, 0, 2] [3, 3] [4, 6]. Portanto, temos que a resposta para este exemplo é 3.
No terceiro caso de teste abaixo, a sequência −2, 0, 3, 6 pode ser particionada de várias formas. As únicas maneiras que resultam em PAs são as seguintes:
Com 4 partes temos 1 possibilidade:
[−2] [0] [3] [6]
Com 3 partes temos 3 possibilidades:
[−2, 0] [3] [6]
[−2] [0, 3] [6]
[−2] [0] [3, 6]
Com 2 partes temos 2 possibilidades:
[−2, 0] [3, 6]
[−2] [0, 3, 6]
Entrada
A primeira linha da entrada é composta por um inteiro N(1 ≤ N ≤ 105), o número de elementos da sequência. Na segunda linha existem N inteiros ai (-105 ≤ ai ≤ 105), os elementos da sequência.
Saída
A saída deve conter uma única linha, indicando o número mínimo de partes em que Bob precisa quebrar a sequência original para que ele termine apenas com PAs.
Exemplos de Entrada Exemplos de Saída
5
1 2 3 4 5
1
7
-2 0 2 3 3 4 6
3
4
-2 0 3 6
2
OBI - Olimpíada Brasileira de Informática 2011 Fase 1 Nível 1 |
1,378 | 2392 | Pulo do Sapo | Fácil | AD-HOC | Sebastião Bueno Coelho, apelidado de SBC pelos familiares e amigos, passou as férias de janeiro de 2011 no sítio de seus avós. Durante sua estadia, uma das atividades prediletas do SBC era nadar no rio que havia no fundo da casa onde morava.
Uma das características do rio que mais impressionava SBC era um belo caminho, feito inteiramente com pedras brancas. Há muito tempo, o avô de SBC notara que os habitantes do sítio atravessavam o rio com grande frequência e, por isso, construiu um caminho no rio com pedras posicionadas em linha reta; ao fazê-lo, tomou muito cuidado para que o espaçamento das pedras fosse de exatamente um metro.
Hoje em dia, a única utilidade do caminho é servir de diversão para os sapos que vivem no rio, que pulam de uma pedra a outra agitadamente. Um certo dia, enquanto descansava e nadava nas águas, SBC assistiu atentamente às acrobacias dos bichos e notou que cada sapo sempre pulava (zero, uma ou mais vezes) uma quantidade fixa de metros.
SBC sabe que você participa da OBI todos os anos e, chegando na escola, resolveu desafiar-te com o seguinte problema: Dado o número de pedras no rio, o número de sapos, a pedra inicial sobre a qual cada sapo está (cada pedra é identificada por sua posição na sequência de pedras) e a distância que cada sapo pula, determinar as posições onde pode existir um sapo depois que SBC chega no rio.
No primeiro caso de teste abaixo, SBC indicou a existência de 5 pedras no rio e 2 sapos. Os sapos estavam inicialmente nas pedras 3 e 4. SBC também lhe disse que o primeiro sapo da entrada sempre pula 2 metros, e o segundo sempre pula 4 metros. A figura a seguir ilustra as possíveis pedras que podem ser ocupadas pelos sapos quando eles começam a pular.
No segundo caso de teste abaixo, SBC indicou a existência de 8 pedras no rio e 3 sapos. Os sapos estavam inicialmente nas pedras 3, 2 e 6. SBC também lhe disse que o primeiro sapo da entrada sempre pula 3 metros, o segundo e terceiro sempre pulam 2 metros. Dessa forma, o primeiro sapo pode estar nas pedras 3 ou 6; o segundo sapo pode estar nas pedras 2, 4, 6 ou 8; e o terceiro sapo pode estar nas pedras 6, 4, 2 e 8. A figura a seguir ilustra as possíveis pedras que podem ser ocupadas pelos sapos quando eles começam a pular.
Entrada
A primeira linha da entrada contém dois inteiros N e M (1 ≤ N, M ≤ 100) representando o número de pedras no rio e o número de sapos, respectivamente. Cada uma das M linhas seguintes possui dois inteiros P e D (1 ≤ P, D ≤ N) representando a posição inicial de um sapo e a distância fixa de pulo, respectivamente.
Saída
A saída contém N linhas. A i-ésima linha indica a possibilidade ou não de ter um sapo na i-ésima pedra. Para as pedras que podem ter um sapo você deve imprimir 1, e para as pedras que com certeza não podem ter nenhum sapo você deve imprimir 0.
Exemplos de Entrada Exemplos de Saída
5 2
3 2
4 4
1
0
1
1
1
8 3
3 3
2 2
6 2
0
1
1
1
0
1
0
1
OBI - Olimpíada Brasileira de Informática 2011 Fase 1 Nível 1 |
1,379 | 2393 | O Mar não está para Peixe | Muito Fácil | AD-HOC | Em um arquipélago no meio do Oceano Pacífico a economia é regida pela pesca, pois o peixe é o principal alimento disponível. Ultimamente, a população desse arquipélago tem aumentado drasticamente, o que levou a um grande aumento da pesca, e, consequentemente, a problemas.
Neste arquipélago, cada pescador vai diariamente ao alto mar com a intenção de conseguir trazer o maior número de peixes para o seu vilarejo. Com a expansão da pesca, os pescadores estão começando a jogar suas redes de pesca por cima das de outros pescadores. Com isso, os pescadores perdem, pois apenas o primeiro pescador pega os peixes da intersecção entre as redes.
A Associação dos Pescadores da ilha decidiu fazer um levantamento para descobrir quanto do mar está de fato sendo aproveitado, ou seja, qual a área do mar que está coberta por pelo menos uma rede de pesca.
Como há muitas intersecções entre as redes de pesca, é muito difícil para a associação calcular a área total da região coberta pelas redes. Por este motivo, eles pediram para que você escrevesse um programa para resolver este problema.
Como é muito difícil navegar pelo mar, os pescadores sempre jogam as redes de forma que as regiões cobertas por cada rede são sempre retângulos com lados paralelos aos eixos, se imaginarmos o mar como um plano cartesiano.
Entrada
A primeira linha da entrada possui um inteiro N (1 ≤ N ≤ 100)indicando o número de redes que foram lançadas. As próximas N linhas descrevem as regiões cobertas pelas redes: cada uma contém quatro inteiros Xi e Xf , Yi e Yf (1 ≤ Xi ≤ Xf ≤100) e (1 ≤ Yi ≤ Yf ≤ 100). A região coberta pela rede em questão contém todo ponto (X,Y) tal que Xi ≤ X ≤ Xf e Yi ≤ Y ≤ Yf.
Saída
A saída deve conter apenas uma linha contendo a área da região do mar realmente aproveitada pelos pescadores, ou seja, a área total da região do mar coberta por pelo menos uma rede de pesca.
Exemplos de Entrada Exemplos de Saída
2
1 3 1 3
2 4 2 4
7
3
1 6 1 2
3 7 1 2
2 5 1 2
6
OBI - Olimpíada Brasileira de Informática 2011 Fase 1 Nível 2 |
1,380 | 2394 | Corrida 1 | Fácil | AD-HOC | A escola de Joãozinho tradicionalmente organiza uma corrida ao redor do prédio. Como todos os alunos são convidados a participar e eles estudam em períodos diferentes, é difícil que todos corram ao mesmo tempo.
Para contornar esse problema, os professores cronometram o tempo que cada aluno demora para dar cada volta ao redor da escola, e depois comparam os tempos para descobrir a classificação final.
Sua tarefa é, sabendo o número de competidores, o número de voltas de que consistiu a corrida e os tempos de cada aluno competidor, descobrir quem foi o aluno vencedor, para que ele possa receber uma medalha comemorativa.
No segundo caso de teste abaixo, existem três competidores numa corrida de três voltas. Os tempos de cada competidor em cada volta foram como na tabela a seguir.
Sendo assim, o vencedor foi o competidor 3 (com um tempo total de 3).
Entrada
A primeira linha da entrada contém dois inteiros N (2 ≤ N ≤ 100) e M (1 ≤ M ≤ 100) representando o número de competidores e o número de voltas da corrida, respectivamente.
Cada uma das N linhas seguintes representa um competidor: a primeira linha representa o primeiro competidor, a segunda linha representa o segundo competidor, e assim por diante. Cada linha contém M inteiros representando os tempos em cada volta da corrida: o primeiro inteiro é o tempo da primeira volta, o segundo inteiro é o tempo da segunda volta, e assim por diante (1 ≤ qualquer número da entrada que represente o tempo de uma volta ≤ 106).
Garante-se que não houve dois competidores que gastaram o mesmo tempo para completar a corrida inteira.
Saída
A saída consiste de um único inteiro, que corresponde ao número do competidor que ganhou a corrida.
Exemplos de Entrada Exemplos de Saída
2 1
5
7
1
3 3
3 5 6
1 2 3
1 1 1
3
OBI - Olimpíada Brasileira de Informática 2011 Fase 1 Nível Júnior |
1,381 | 2395 | Transporte de Contêineres | Muito Fácil | AD-HOC | A Betalândia é um país que apenas recentemente se abriu para o comércio exterior e está preparando agora sua primeira grande exportação. A Sociedade Betalandesa de Comércio (SBC) ficou encarregada de conduzir a exportação e determinou que, seguindo os padrões internacionais, a carga será transportada em contêineres, que são, por sua vez, colocados em grandes navios para o transporte internacional.
Todos os contêineres betalandeses são idênticos, medindo A metros de largura, B metros de comprimento e C metros de altura. Um navio porta-contêineres pode ser visto como um retângulo horizontal de X metros de largura e Y metros de comprimento, sobre o qual os contêineres são colocados. Nenhuma parte de contêiner pode ficar para fora do navio. Além disso, para possibilitar a travessia de pontes, a altura máxima da carga no navio não pode ultrapassar Z metros.
Devido a limitações do guindaste utilizado, os contêineres só podem ser carregados alinhados com o navio. Ou seja, os contêineres só podem ser colocados sobre o navio de tal forma que a largura e o comprimento do contêiner estejam paralelos à largura e ao comprimento do navio, respectivamente.
A SBC está com problemas para saber qual a quantidade máxima de contêineres que podem ser colocados no navio e pede sua ajuda. Sua tarefa, neste problema, é determinar quantos contêineres podem ser carregados no navio respeitando as restrições acima.
Entrada
A entrada consiste de duas linhas. A primeira linha contém três inteiros A, B e C que representam as dimensões dos contêineres, enquanto a segunda linha contém outros três inteiros X, Y e Z (1 ≤ A, B, C, X, Y, Z ≤ 106) que representam as dimensões do navio.
Saída
Seu programa deve imprimir apenas uma linha contendo um inteiro que indica a quantidade máxima de contêineres que o navio consegue transportar.
Exemplos de Entrada Exemplos de Saída
1 1 1
1 1 1
1
1 2 5
9 6 11
54
1 2 12
6 9 10
0
OBI - Olimpíada Brasileira de Informática 2011 Fase 1 Nível Júnior |
1,382 | 2396 | Corrida | Muito Fácil | AD-HOC | Todo ano, os habitantes da Mlogônia, apesar das crises internas, reúnem-se em torno de um esporte que é a paixão nacional: as corridas de carros. A Grande Corrida anual é um enorme evento organizado pela Associação de Corridas da Mlogônia (ACM), sendo amplamente televisionado e reportado em jornais e revistas de todo o país. Os resultados da corrida são tema principal das rodas de conversa por semanas.
Por bastante tempo, os resultados da Grande Corrida eram compilados manualmente. Observadores especializados iam à pista medir o tempo de cada um dos N carros, numerados de 1 a N, em cada uma das M voltas, anotando então os resultados em tabelas para posterior análise por parte das equipes e dos jornalistas. Muitos erros eram introduzidos nesse processo, e a organização decidiu informatizar todo o sistema.
A ACM percebeu que o esforço necessário para a construção do sistema seria grande, e optou por contar com a ajuda de uma equipe de programadores. Percival foi contratado para escrever a parte do software que determina quais foram os carros vencedores, mas está com dificuldades e pede sua ajuda. A sua tarefa, neste problema, é determinar os três carros melhor colocados, fornecidos os tempos que cada carro levou para completar cada volta da corrida.
No segundo caso de teste abaixo, existem 5 carros numa corrida de duas voltas. Os tempos de cada carro em cada volta foram como na tabela a seguir.
Sendo assim, o vencedor foi o carro 3 (com um tempo total de 2), seguido pelo carro 5 (com um tempo total de 4) e pelo carro 2 (com um tempo total de 7).
Entrada
A primeira linha da entrada contém dois inteiros N (3 ≤ N ≤ 100) e M (1 ≤ M ≤ 100) representando o número de carros e o número de voltas da corrida, respectivamente.
Cada uma das N linhas seguintes representa um carro: a primeira linha representa o primeiro carro, a segunda linha representa o segundo carro, e assim por diante. Cada linha contém M inteiros representando os tempos em cada volta da corrida: o primeiro inteiro é o tempo da primeira volta, o segundo inteiro é o tempo da segunda volta, e assim por diante (1 ≤ qualquer número da entrada que represente o tempo de uma volta ≤ 106).
Garante-se que não houve dois carros que gastaram o mesmo tempo para completar a corrida inteira.
Saída
A saída consiste de três linhas, contendo um único inteiro cada. A primeira linha contém o número do carro que ganhou a corrida, a segunda contém o número do segundo colocado e a terceira contém o número do terceiro colocado.
Exemplos de Entrada Exemplos de Saída
3 1
1
2
3
1
2
3
5 2
3 7
2 5
1 1
15 2
2 2
3
5
2
OBI - Olimpíada Brasileira de Informática 2011 Fase 1 Nível 1 |
1,383 | 2397 | Triângulos | Médio | AD-HOC | Caio estava brincando de construir triângulos com palitos de diferentes tamanhos. Ele fazia isso juntando as pontas de três palitos sobre uma mesa. Ele notou que podia agrupar os triângulos formados em três grupos:
Triângulos acutângulos, que são aqueles em que todos os ângulos internos medem menos de 90°;
Triângulos retângulos, que são aqueles que possuem um ângulo interno que mede exatamente 90°;
Triângulos obtusângulos, que são aqueles que possuem um ângulo interno que mede mais de 90°.
Ele também percebeu que nem sempre é possível formar um triângulo com três palitos.
Sua tarefa é, dados os comprimentos A, B e C de três palitos, dizer se é possível formar um triângulo com esses palitos e, em caso afirmativo, dizer a qual grupo o triângulo formado pertence.
Entrada
A entrada consiste de uma única linha, contendo três inteiros A, B e C (1 ≤ A, B, C ≤ 104) separados por espaço.
Saída
Imprima uma linha contendo apenas uma letra minúscula:
'n' se não for possível formar um triângulo;
'a' se o triângulo formado for acutângulo;
'r' se o triângulo formado for retângulo;
'o' se o triângulo formado for obtusângulo.
Exemplos de Entrada Exemplos de Saída
1 1 1
a
1 2 1
n
5 4 3
r
6 3 4
o
OBI - Olimpíada Brasileira de Informática 2011 Fase 1 Nível 1 |
1,384 | 2398 | Caça ao Tesouro | Fácil | AD-HOC | Capitão Tornado é um pirata muito cruel que faz qualquer coisa por dinheiro. Há alguns dias, o capitão soube da existência de um tesouro numa ilha deserta, e agora tenta determinar sua posição.
A ilha pode ser vista como um quadriculado N × N de terra cuja posição (0, 0) está a sudoeste, a posição (N−1, 0) está a sudeste, a posição (0, N−1) está a noroeste e a posição (N−1, N−1) está a nordeste. Em alguma posição desse quadriculado está o tesouro.
Uma curiosidade importante é a perna de pau que o capitão possui. Ela impede que o capitão se locomova em direções que não a horizontal ou a vertical: para ir da posição (1, 1) para a posição (3, 2), por exemplo, o capitão é obrigado a gastar três passos. É claro que o capitão sempre escolhe, dentro de suas limitações, um caminho com o menor número de passos possível. Chamamos esse modo de andar de passos de capitão. Um exemplo de caminho por passos de capitão entre (1, 1) e (3, 2) é ilustrado na figura a seguir.
Como em toda boa caça ao tesouro, o capitão não conhece a posição onde o tesouro se encontra: ele possui um mapa que corresponde à geografia da ilha. Em algumas posições desse mapa, existem pistas escritas. Cada pista consiste em um número D, que indica a menor distância em passos de capitão entre a posição em que a pista se encontra e a do tesouro.
Observe que, dependendo da disposição das pistas, a posição do tesouro pode estar determinada de maneira única ou não. Na figura acima e à esquerda, as duas pistas são suficientes para se saber, com certeza, onde está o tesouro; na figura à direita, as quatro pistas dadas ainda possibilitam que tanto a posição (0, 2) quanto a (2, 2) guardem o tesouro. Nesse último caso, não se pode determinar, com certeza, qual é a localização do tesouro.
Dadas as pistas que o capitão possui, sua tarefa é determinar se as pistas fornecem a localização exata do tesouro e, caso positivo, qual ela é.
Entrada
A primeira linha contém dois inteiros positivos N (2 ≤ N ≤ 100) e K (1 ≤ K ≤ 100), onde N é a dimensão do quadriculado e K é o número de pistas no mapa que o capitão possui.
Cada uma das próximas K linhas contêm três inteiros X, Y e D, informando que existe uma pista na posição (X, Y) contendo o número D. Essa pista indica que o tesouro encontra-se a D passos de capitão da posição da pista.
É garantido que, com essas pistas, existe ao menos uma localização possível para o tesouro. Além disso, o mapa não contém duas pistas na mesma posição.
Saída
Se as pistas forem suficientes para determinar com certeza a localização do tesouro, seu programa deve imprimir uma única linha com dois inteiros, X e Y , indicando que o tesouro encontra-se na posição (X, Y).
Caso contrário, seu programa deve imprimir uma única linha com dois inteiros iguais a −1, como nos exemplos de saída a seguir.
Exemplos de Entrada Exemplos de Saída
4 2
0 0 3
3 0 4
1 2
4 4
1 0 3
1 1 2
1 2 1
1 3 2
-1 -1
3 3
0 0 2
1 1 2
2 0 4
0 2
OBI - Olimpíada Brasileira de Informática 2011 Fase 1 Nível 2 |
1,385 | 2399 | Campo Minado | Muito Fácil | AD-HOC | Leonardo Viana é um garoto fascinado por jogos de tabuleiro. Nas férias de janeiro, ele aprendeu um jogo chamado "Campo minado", que é jogado em um tabuleiro comN células dispostas na horizontal. O objetivo desse jogo é determinar, para cada célula do tabuleiro, o número de minas explosivas nos arredores da mesma (que são a própria célula e as células imediatamente vizinhas à direita e à esquerda, caso essas existam). Por exemplo, a figura abaixo ilustra uma possível configuração de um tabuleiro com 5 células:
A primeira célula não possui nenhuma mina explosiva, mas é vizinha de uma célula que possui uma mina explosiva. Nos arredores da segunda célula temos duas minas, e o mesmo acontece para a terceira e quarta células; a quinta célula só tem uma mina explosiva em seus arredores. A próxima figura ilustra a resposta para esse caso.
Leonardo sabe que você participa da OBI e resolveu lhe pedir para escrever um programa de computador que, dado um tabuleiro, imprima o número de minas na vizinhança de cada posição. Assim, ele poderá conferir as centenas de tabuleiros que resolveu durante as férias.
Entrada
A primeira linha da entrada contém um inteiro N (1 ≤ N ≤ 50) indicando o número de células no tabuleiro. O tabuleiro é dado nas próximas N linhas. A i-ésima linha seguinte contém 0 se não existe mina na i-ésima célula do tabuleiro e 1 se existe uma mina na i-ésima célula do tabuleiro.
Saída
A saída é composta por N linhas. A i-ésima linha da saída contém o número de minas explosivas nos arredores da i-ésima célula do tabuleiro.
Exemplos de Entrada Exemplos de Saída
5
0
1
1
0
1
1
2
2
2
1
5
0
1
1
1
0
1
2
3
2
1
OBI - Olimpíada Brasileira de Informática 2011 Fase 1 Nível Júnior |
1,386 | 2400 | Balé | Médio | AD-HOC | Uma academia de balé irá organizar uma Oficina de Balé Intensivo (OBI) na Semana de Balé Contemporâneo (SBC). Nessa academia, existem N bailarinas que praticam regularmente. O dono da academia, por ser experiente, consegue medir o nível de habilidade de cada uma delas por um número inteiro; nessa medição, números maiores correspondem a dançarinas mais habilidosas, e os números obtidos são todos distintos. Além disso, ele possui uma lista das bailarinas em ordem cronológica de ingresso na academia: As bailarinas que aparecem primeiro na lista estão há mais tempo na academia, e as que estão no final ingressaram mais recentemente.
O dono da academia decidiu escolher duas das bailarinas para ajudá-lo na realização do evento: uma ajudará no trabalho braçal, enquanto a outra irá exemplificar os passos de balé. Por seu perfeccionismo, ele deseja que a bailarina que exemplificará os passos de dança seja, dentre as duas meninas do par, a mais habilidosa e a que frequenta a academia há mais tempo.
Ele sabe que a Oficina será um sucesso desde que os dois critérios mencionados acima sejam satisfeitos pela dupla de dançarinas escolhidas. Com isso, ele ficou curioso para saber quantas duplas de dançarinas podem ajudá-lo na Oficina. A quantidade de dançarinas, contudo, é relativamente grande e ele não possui nem tempo nem paciência para fazer tal cálculo. Como vocês são amigos, ele pediu a sua ajuda para contar quantas duplas são válidas. Você pode ajudá-lo?
Por exemplo, digamos que a academia possua 5 dançarinas com níveis de habilidade 1, 5, 2, 4 e 3, onde a primeira, que possui nível "1", está na academia há mais tempo e a última, que possui nível "3", está há menos. Temos, então, 4 possíveis duplas que poderemos usar nesta Oficina, que são (5, 2),(5, 4),(5, 3) e (4, 3). Note que a dupla (1, 3), por exemplo, não pode ser escolhida pelo dono da academia, pois a mais habilidosa dentre as duas é também a mais nova da dupla.
Entrada
A primeira linha contém um número N (1 ≤ N ≤ 100 000), que representa a quantidade de dançarinas que estão registradas na academia. A segunda linha da entrada contém N inteiros, onde o primeiro inteiro é o nível da dançarina que está há mais tempo na academia, o segundo inteiro é o nível da próxima dançarina mais antiga na academia (mas mais nova que a dançarina anterior), e assim sucessivamente.
Saída
A saída consistirá num único número X, que representa o total de duplas de dançarinas válidas para essa Oficina, dadas as regras descritas anteriormente.
Exemplos de Entrada Exemplos de Saída
5
1 5 2 4 3
4
9
9 8 7 6 5 4 3 1 2
35
OBI - Olimpíada Brasileira de Informática 2011 Fase 2 Nível 1 |
1,387 | 2401 | Calculadora | Médio | AD-HOC | Solicitando Boas Contas (SBC) é uma organização de inspeção de calculadoras. Todos os fabricantes procuram ter o selo de qualidade da SBC, que faz com que os clientes comprem o produto sem preocupação com contas erradas.
Você está encarregado de testar máquinas que fazem apenas operações de multiplicação e divisão. Além disso, o termo a ser digitado em cada operação (que dividirá ou multiplicará o número atualmente exibido no visor) só pode conter um único dígito.
A calculadora exibe o número 1 quando ligada. Depois disso, o usuário pode digitar um número com um único dígito e escolher se esse número deve multiplicar ou dividir o número exibido anteriormente; o resultado da operação escolhida é então exibido na calculadora. Pode-se repetir esse processo indefinidamente.
Apesar de só podermos entrar com números inteiros de um dígito, o visor da calculadora permite exibir números com múltiplos dígitos e até mesmo números fracionários.
Dada uma sequência de operações que foram realizadas nessa calculadora logo depois de ligada, sua tarefa é conferir o resultado exibido.
No primeiro caso de teste abaixo, o usuário deseja calcular o resultado da seguinte expressão: 1 × 2 × 1 × 3. Note que a primeira ocorrência do número 1 vem do fato da calculadora mostrar inicialmente 1 ao invés de 0.
No segundo caso de teste abaixo, o usuário deseja calcular o resultado da seguinte expressão: ((1/2)/3) × 6.
Entrada
A primeira e única linha da entrada contém um inteiro N (1 ≤ N ≤ 100 000). Cada uma das próximas N linhas contém um dígito e um caractere '*' ou '/', que representam uma operação realizada na calculadora.
Saída
Seu programa deve imprimir uma única linha contendo o resultado que deve ser exibido pela calculadora ao final das operações.
Exemplos de Entrada Exemplos de Saída
3
2 *
1 *
3 *
6
3
2 /
3 /
6 *
1
11
9 *
9 *
9 *
9 *
9 *
9 *
9 *
9 *
9 *
9 *
9 /
387420489
OBI - Olimpíada Brasileira de Informática 2011 Fase 2 Nível 1 |
1,388 | 2402 | Selos | Médio | AD-HOC | Euclides é um garoto que gosta muito de colecionar selos. No seu aniversário, seus pais o presentearam com N selos, todos em formato de quadrados com 1 cm de lado. Euclides gostaria de guardar todos os N selos que ganhou colando-os numa página de papel em branco. Ao decidir por guardá-los assim, no entanto, ele logo percebeu que a única forma que lhe agradava de posicionar os selos na página era a forma de um retângulo completamente coberto pelos mesmos, sem sobreposição.
Ele percebeu também que, independente do número de selos obtido, colocar todos os selos numa única linha ou todos os selos numa única coluna é uma configuração válida. Como essa maneira usa a página do caderno de um jeito muito ineficiente, Euclides gostaria de saber se existe algum modo de dispor os N selos num retângulo que tenha mais de uma linha e mais de uma coluna tal que todas as linhas e colunas sejam completamente ocupadas por selos (isto é, tal que não existam posições sem selos no interior do retângulo).
A figura abaixo exemplifica o primeiro caso de teste, duas maneiras de guardar os selos em forma de retângulo.
Entrada
A entrada contém uma única linha com um único inteiro N (1 ≤ N ≤ 10 000 000 000.), o número de selos que Euclides ganhou.
Saída
A saída deve conter uma linha com um único caracter, que deve ser 'S' se for possível organizar os selos em um retângulo com mais que uma linha e mais que uma coluna ou 'N' caso não seja possível.
Exemplos de Entrada Exemplos de Saída
8
S
1
N
11
N
OBI - Olimpíada Brasileira de Informática 2011 Fase 2 Nível 1 |
1,389 | 2403 | Escalonamento Ótimo | Médio | AD-HOC | O SBC (System for Batch Computing) é um sistema operacional voltado para a execução sequencial de tarefas. O operador do sistema cria tarefas e o sistema operacional é responsável por agendar a execução destas tarefas.
Cada tarefa pode depender da conclusão de algumas tarefas para poder começar. Se uma tarefa A depende de uma tarefa B, a tarefa B deve terminar antes que a tarefa A inicie sua execução.
Além disto, cada tarefa possui uma prioridade. É sempre mais vantajoso para o sistema começar executando uma tarefa de mais alta prioridade, depois continuar executando uma tarefa de mais alta prioridade dentre as que sobraram e assim por diante.
Neste problema, será dado um inteiro N, que irá representar o número de tarefas no sistema. As tarefas serão numeradas de 0 até N−1. Tarefas com índice menor possuem prioridade maior, de forma que a tarefa 0 é a tarefa de mais alta prioridade, a tarefa 1 é a tarefa com a segunda maior prioridade e assim por diante, até a tarefa N−1, que é a tarefa com a menor prioridade. Além disso, serão dadas M relações de dependência entre as tarefas.
Seu objetivo será decidir se é possível executar as tarefas em alguma ordem. Caso seja possível, você deverá produzir uma ordem de execução ótima para as tarefas, isto é, desempate as ordens possíveis pela prioridade da primeira tarefa. Se o empate ainda persistir, desempate pela prioridade da segunda tarefa, e assim por diante.
Entrada
A primeira linha da entrada contém inteiros N (0 ≤ N ≤ 50000) e M (0 ≤ M ≤ 200000). As próximas M linhas descrevem, cada uma, uma dependência entre as tarefas da entrada. Cada uma dessas linhas irá conter dois inteiros A e B (0 ≤ A, B < N) que indicam que a tarefa B depende da tarefa A, isto é, que a tarefa A deve terminar antes que a tarefa B inicie.
Saída
Se não for possível ordenar as tarefas de forma que as dependências sejam satisfeitas, imprima uma única linha contendo o caracter "*". Caso contrário, imprima N linhas contendo cada uma um número inteiro. O inteiro na i-ésima linha deve ser o índice da i-ésima tarefa a ser executada na ordem ótima de execução das tarefas.
Exemplos de Entrada Exemplos de Saída
3 1
2 0
1
2
0
2 2
0 1
1 0
*
OBI - Olimpíada Brasileira de Informática 2011 Fase 2 Nível 2 |
1,390 | 2404 | Reduzindo Detalhes em um Mapa | Fácil | GRAFOS | Leonardo Nascimento é um garoto de 13 anos apaixonado por cartografia. Durante as férias de janeiro de 2011, ele alternava seu tempo entre navegar na internet (pesquisando sobre mapas) e arrumar sua coleção de mapas. Navegando na internet, Leonardo descobriu um site especializado em mapas, o Google Maps. Depois de alguns dias usando o site, Leonardo percebeu que quando diminuía o zoom algumas ruas não eram mais exibidas no mapa, isto é, o zoom determinava também o nível de detalhe do mapa. A figura abaixo ilustra um dos testes feito por Leonardo.
Ele sabe que você participa da OBI e que você adora resolver os problemas que envolvem mapas. Então resolveu formular o seguinte problema: dado um mapa de cidades e rodovias que as ligam, selecione um subconjunto das rodovias tal que entre qualquer par de cidades exista uma rota ligando-as e a soma dos comprimentos das rodovias é mínimo. Na figura abaixo e à esquerda temos um exemplo com cinco cidades e seis rodovias ligando-as. A figura abaixo e à direita ilustra uma solução cuja soma dos comprimentos é 34.
Para facilitar um pouco sua vida, Leonardo determinou que você só precisa dizer a soma dos comprimentos das rodovias do subconjunto selecionado para um dado mapa.
Entrada
A primeira linha da entrada contém dois números N (1 ≤ N ≤ 500) e M (1 ≤ M ≤ 124750) que representam o número de cidades e o número de rodovias respectivamente. Cada uma das próximas M linhas é composta por três inteiros U, V (1 ≤ U, V ≤ N e U ≠ V) e C (1 ≤ C ≤ 500) que indiciam que existe uma rodovia de comprimento C que liga as cidades U e V.
Saída
A saída consiste em apenas uma linha contendo a soma do comprimento das rodovias selecionadas.
Exemplos de Entrada Exemplos de Saída
5 6
1 2 15
1 3 10
2 3 1
3 4 3
2 4 5
4 5 20
34
4 6
1 2 1
1 3 10
1 4 1
2 3 1
2 4 10
3 4 1
3
OBI - Olimpíada Brasileira de Informática 2011 Fase 2 Nível 2 |
1,391 | 2405 | Colorindo | Fácil | AD-HOC | A Sociedade Brasileira das Cores (SBC) é uma editora de livros de colorir. As crianças adoram os livros da SBC porque suas figuras, depois de pintadas, ficam muito coloridas e bonitas. Isso acontece porque a SBC se preocupa em não deixar grandes regiões contínuas em suas figuras, que devem ser pintadas com uma cor só.
Até agora, o processo de verificar se uma figura tinha uma região contínua grande era completamente visual, mas a SBC resolveu automatizar esse processo e você foi contratado para programar uma parte desse sistema.
Uma figura é representada por uma grade, de dimensão N por M. Cada quadrado dessa grade é representado por uma coordenada (i, j), com 1 ≤ i ≤ N e 1 ≤ j ≤ M. Por exemplo, a coordenada (1, 5) representa o quadrado na primeira linha e quinta coluna, enquanto que a coordenada (3, 7) representa o quadrado na terceira linha e sétima coluna. As linhas são contadas de baixo para cima e as colunas da esquerda para a direita.
Cada quadrado pode estar vazio ou cheio. Assumimos que uma criança só vai pintar sobre quadrados vazios e se ela pintar um quadrado de uma cor, ela irá pintar os oito vizinhos da mesma cor, desde que eles estejam vazios e que ela não saia da área da figura.
No segundo exemplo de caso de teste abaixo, temos uma figura de dimensões 5 × 5. A criança começa a pintar na posição (3, 3). Na figura abaixo ilustramos este caso. A posição que a criança inicia está marcada com a letra "X", e os quadrados que a criança consegue pintar estão destacandos em cinza claro. Note que ela consegue pintar o quadrado (4, 4), pois este quadrado é um dos quadrados que ela consegue pintar após ter pintado o quadrado (3, 3).
No terceiro exemplo de caso de teste abaixo, temos uma figura de dimensões 10 × 10. A criança começa a pintar na posição (5, 5). Na figura abaixo ilustramos este caso. A posição que a criança inicia está marcada com a letra "X", e os quadrados que a criança consegue pintar estão destacandos em cinza claro.
Dada a figura e a coordenada onde uma criança vai começar a pintar, sua tarefa é descobrir quantos quadrados ela irá pintar.
Entrada
A primeira linha da entrada contém 5 números inteiros, N, M, X, Y e K (1 ≤ N, M ≤ 200), (1 ≤ K ≤ 10 000). Os números inteiros N e M são respectivamente o número de linhas e colunas da grade, enquanto que (X, Y) é a coordenada onde a criança vai começar a pintar e K é o número de quadrados cheios na figura.
Seguem-se K linhas, cada uma com dois inteiros A e B (1 ≤ X, A ≤ N), (1 ≤ Y, B ≤ M) que são as coordenadas de um quadrado cheio.
Garantimos que o quadrado na posição (X, Y) está sempre vazio.
Saída
Seu programa deve imprimir uma linha contendo o número de quadrados pintados pela criança.
Exemplos de Entrada Exemplos de Saída
1 5 1 2 2
1 1
1 4
2
5 5 3 3 7
2 2
2 3
2 4
3 2
3 4
4 2
4 3
18
10 10 5 5 22
2 2
2 3
2 4
2 5
2 6
2 7
2 8
3 2
3 8
4 2
4 8
5 2
5 8
6 2
6 8
7 2
7 3
7 4
7 5
7 6
7 7
7 8
20
OBI - Olimpíada Brasileira de Informática 2011 Fase 2 Nível 1 |
1,392 | 2406 | Expressões | Médio | AD-HOC | Pedrinho e Zezinho estão precisando estudar resolução de expressões matemáticas para uma prova que irão fazer. Para isso, eles querem resolver muitos exercícios antes da prova. Como sabem programar, então decidiram fazer um gerador de expressões matemáticas.
O gerador de expressões que eles criaram funciona em duas fases. Na primeira fase é gerada uma cadeia de caracteres que contém apenas os caracteres '{', '[', '(', '}', ']' e ')'. Na segunda fase, o gerador adiciona os números e operadores na estrutura criada na primeira fase. Uma cadeia de caracteres é dita bem definida (ou válida) se atende as seguintes propriedades:
Ela é uma cadeia de caracteres vazia (não contém nenhum caractere).
Ela é formada por uma cadeia bem definida envolvida por parênteses, colchetes ou chaves. Portanto, se a cadeia S é bem definida, então as cadeias (S), [S] e {S} também são bem definidas.
Ela é formada pela concatenação de duas cadeias bem definidas. Logo, se as cadeias X e Y são bem definidas, a cadeia XY é bem definida.
Depois que Pedrinho e Zezinho geraram algumas expressões matemáticas, eles perceberam que havia algum erro na primeira fase do gerador. Algumas cadeias não eram bem definidas. Eles querem começar a resolver as expressões o mais rápido possível, e sabendo que você é um ótimo programador (e participa da OBI) resolveram pedir que escreva um programa que dadas várias cadeias geradas na primeira fase, determine quais delas são bem definidas e quais não são.
Entrada
A entrada é composta por diversas instâncias. A primeira linha da entrada contém um inteiro T (1 ≤ T ≤ 20) indicando o número de instâncias. Em seguida temos T linhas, cada uma com uma cadeia A, (a cadeia de caracteres A tem entre 1 e 100000 caracteres), (a cadeia de caracteres A contém apenas caracteres '{', '[', '(', '}', ']' e ')' ).
Saída
Para cada instância imprima uma linha contendo a letra S se a cadeia é bem definida, ou a letra N caso contrário.
Exemplo de Entrada Exemplo de Saída
12
()
[]
{}
(]
}{
([{}])
{}()[]
()]
{[]
(
(([{}{}()[]])(){}){}
(((((((((({([])}])))))))))
S
S
S
N
N
S
S
N
N
N
S
N
OBI - Olimpíada Brasileira de Informática 2011 Fase 2 Nível 2 |
1,393 | 2407 | Quadrado Mágico | Difícil | AD-HOC | Arnaldo e Bernardo são dois garotos que compartilham um peculiar gosto por curiosidades matemáticas. Nos últimos tempos, sua principal diversão tem sido investigar propriedades matemágicas de tabuleiros quadrados preenchidos com inteiros. Recentemente, durante uma aula de matemática, os dois desafiaram os outros alunos da classe a criar quadrados mágicos, que são quadrados preenchidos com números de 1 a N2, de tal forma que a soma dos N números em uma linha, coluna ou diagonal principal do quadrado tenham sempre o mesmo valor. A ordem de um quadrado mágico é o seu número de linhas, e o valor do quadrado mágico é o resultado da soma de uma linha. Um exemplo de quadrado mágico de ordem 3 e valor 15 é mostrado na figura abaixo:
Para surpresa de Arnaldo e Bernardo, os outros alunos criaram um grande número de quadrados, alguns enormes, e alegaram que todos eram quadrados mágicos. Arnaldo e Bernardo agora precisam de sua ajuda, para verificar se os quadrados criados são realmente mágicos.
Você deve escrever um programa que, dado um quadrado, verifique se ele é realmente mágico.
Entrada
A primeira linha da entrada contém um único número inteiro N (3 ≤ N ≤ 1000.), indicando a ordem do quadrado (seu número de linhas). As N linhas seguintes descrevem o quadrado. Cada uma dessas linhas contém N números inteiros separados por um espaço em branco (1 ≤ valor de cada célula ≤ 109).
Saída
Seu programa deve imprimir uma única linha. Caso o quadrado seja mágico, a linha deve conter o valor do quadrado (ou seja, a soma de uma de suas linhas). Caso contrário, a linha deve conter o número 0.
Exemplos de Entrada Exemplos de Saída
3
1 1 1
1 1 1
1 1 1
0
4
16 3 2 13
5 10 11 8
9 6 7 12
4 15 14 1
34
3
4 8 9
11 7 3
6 5 10
0
OBI - Olimpíada Brasileira de Informática 2011 Fase 2 Nível 2 |
1,394 | 2408 | Vice-Campeão | Muito Fácil | AD-HOC | A OBI (Organização de Bocha Internacional) é responsável por organizar a competição mundial de bocha. Infelizmente esse esporte não é muito popular, e numa tentativa de aumentar a sua popularidade, ficou decidido que seriam chamados, para a Grande Final Mundial, o campeão e o vice-campeão de cada sede nacional, ao invés de apenas o primeiro lugar.
Tumbólia é um país pequeno que já havia realizado a sua competição nacional quando a nova regra foi instituída, e o comitê local não armazenou quem foi o segundo classificado. Felizmente eles armazenaram a pontuação de todos competidores – que foram apenas três, devido ao tamanho diminuto do país. Sabe-se também que as pontuações de todos jogadores foram diferentes, de forma que não ocorreu empate entre nenhum deles.
Resta agora descobrir quem foi o vice-campeão e para isso o comitê precisa de ajuda.
Entrada
A primeira e única linha da entrada consiste de três inteiros separados por espaços, A, B e C (1 ≤ A, B, C ≤ 100), as pontuações dos 3 competidores.
Saída
Imprima uma única linha na saída, contendo apenas um número inteiro, a pontuação do vice-campeão.
Exemplos de Entrada Exemplos de Saída
4 5 6
5
10 5 9
9
OBI - Olimpíada Brasileira de Informática 2012 Fase 1 Nível 1 |
1,395 | 2409 | Colchão | Médio | AD-HOC | João está comprando móveis novos para sua casa. Agora é a vez de comprar um colchão novo, de molas, para substituir o colchão velho. As portas de sua casa têm altura H e largura L e existe um colchão que está em promoção com dimensões A × B × C.
O colchão tem a forma de um paralelepípedo reto retângulo e João só consegue arrastá-lo através de uma porta com uma de suas faces paralelas ao chão, mas consegue virar e rotacionar o colchão antes de passar pela porta.
Entretanto, de nada adianta ele comprar o colchão se ele não passar através das portas de sua casa. Portanto ele quer saber se consegue passar o colchão pelas portas e para isso precisa de sua ajuda.
Entrada
A primeira linha da entrada contém três números inteiros A, B e C (1 ≤ A, B, C ≤ 300), as três dimensões do colchão, em centímetros. A segunda linha contém dois inteiros H e L (1 ≤ H, L ≤ 250), respectivamente a altura e a largura das portas em centímetros.
Saída
Se programa deve escrever uma única linha, contendo apenas a letra ‘S’ se o colchão passa pelas portas e apenas a letra ‘N’ em caso contrário.
Exemplos de Entrada Exemplos de Saída
25 120 220
200 100
S
25 205 220
200 100
N
25 200 220
200 100
S
OBI - Olimpíada Brasileira de Informática 2012 Fase 1 Nível 2 |
1,396 | 2410 | Frequencia na Aula | Fácil | AD-HOC | Certa vez, numa aula, a professora passou um filme para os alunos assistirem. Durante este filme, ela passou uma lista de presença em sua sala para verificar a presença dos alunos, onde cada aluno deveria inserir apenas seu número de registro. Alguns alunos contudo, como possuem amigos que fogem da aula, decidiram ser camaradas e inseriram os números de registro de seus amigos fujões. O problema é que muitos alunos são amigos de alunos que fogem da aula e alguns números de registro acabaram sendo repetidamente inseridos na lista de presença. Além de tudo, alguns dos alunos que se esperava que não estivessem na aula de fato estavam!
A professora, ao notar que a lista de presença continha alguns números repetidos, ficou sem entender, mas decidiu dar um voto de confiança e dar presença a todos os alunos cujos números de registro estavam na lista. Como são muitos alunos na sala e muitos números com repetição, ela pediu a sua ajuda para determinar o total de alunos que receberam presença na aula.
Entrada
A primeira linha da entrada contém um número inteiro N (1 ≤ N ≤ 105), que informa a quantidade de números de registro que apareceram na lista de presença. Cada uma das N linhas seguintes contém um número de registro Vi (0 ≤ Vi ≤ 106)que foi inserido na lista de presença.
Saída
Seu programa deve imprimir uma única linha, contendo apenas um número inteiro, o número de alunos que receberam presença.
Exemplos de Entrada Exemplos de Saída
3
2
3
1
3
7
0
5
12
41
7
5
41
5
OBI - Olimpíada Brasileira de Informática 2012 Fase 1 Nível 2 |
1,397 | 2411 | O Tabuleiro Esburacado | Fácil | AD-HOC | Um tabuleiro normal, 8 x 8, foi danificado, e 4 posições ficaram esburacadas. A Figura 1(a) mostra o tabuleiro. A posição inferior esquerda tem coordenadas (0, 0). Os 4 buracos estão marcados em preto, e têm coordenadas (1, 3), (2, 3), (2, 5) e (5, 4). Um cavalo de xadrez foi colocado na posição (4, 3), marcada como 0 no tabuleiro.
Os 8 movimentos de um cavalo estão numerados de 1 a 8 na Figura 1(b), a partir da posição marcada como 0. Por exemplo, se o cavalo estiver na posição inicial (4, 3), o movimento 7 leva o cavalo à posição (2, 4), sem cair no buraco (2, 3), porque o cavalo salta da posição (4, 3) para a posição (2, 4).
Seu problema é simular um passeio do cavalo, dados os movimentos através dos números de 1 a 8 e determinar quantos movimentos o cavalo faz até ou (i) terminar o passeio ou (ii) cair em um buraco. Por exemplo, na trajetória dada pelos 5 movimentos 1, 8, 5, 3, 4, o cavalo passa pelas posições (5, 5), (4, 7), (3, 5) e cai no buraco (5, 4), fazendo portanto apenas 4 movimentos.
Já no passeio dado pelos 3 movimentos 6, 8, 1, o cavalo passa pelas posições (2, 2), (1, 4) e (2, 6) e não cai em nenhum buraco: portanto, perfaz todos os 3 movimentos do passeio.
Entrada
A primeira linha da entrada contém N (1 ≤ N ≤ 100), o número de movimentos do passeio. A segunda linha contém N inteiros M1, M2, . . . , MN (1 ≤ MI ≤ 8, para I = 1, 2, . . . , N) , separados por um espaço em branco, correspondentes aos N movimentos do cavalo no passeio. Um movimento pode levar o cavalo a cair em um buraco, mas nunca leva o cavalo a sair do tabuleiro.
Saída
Seu programa deve imprimir uma única linha, contendo um único número inteiro, o número de movimentos do cavalo até terminar o passeio ou o cavalo cair em um buraco.
Exemplos de Entrada Exemplos de Saída
5
1 8 5 3 4
4
3
6 8 1
3
OBI - Olimpíada Brasileira de Informática 2012 Fase 1 Nível 2 |
1,398 | 2412 | Tarzan | Médio | GRAFOS | Tarzan vive na floresta e é o responsável por manter a ordem na região onde vive. Para locomover-se entre as árvores ele só usa cipós pois esse é um meio de transporte muito mais rápido e seguro do que andar no chão da selva, além de, é claro, poder soltar seu grito característico enquanto viaja.
Os cipós das árvores têm todos o mesmo alcance. Dessa forma, é possível viajar de cipó de uma árvore para outra se a distância entre elas é no máximo D, onde D é o alcance dos cipós.
Recentemente uma forte chuva assolou a região e derrubou algumas árvores, restando na floresta apenas N árvores. Agora Tarzan quer saber se ele consegue viajar de cipó entre todas árvores remanescentes para poder continuar mantendo a ordem na região.
Para poder manter a ordem ele precisa ser capaz de, partindo de qualquer uma das árvores, poder chegar a todas as outras árvores remanescentes, possivelmente passando por outras árvores no caminho, sempre utilizando somente cipós.
Entrada
A primeira linha da entrada contém dois inteiros, N (2 ≤ N ≤ 1000) e D (1 ≤ D ≤ 5000), indicando respectivamente o número de árvores remanescentes e o alcance dos cipós. Cada uma das N linhas seguintes contém dois inteiros Xi e Yi (0 ≤ Xi, Yi ≤ 5000) , as coordenadas da i-ésima árvore. Não existem duas árvores com as mesmas coordenadas.
Saída
Seu programa deve escrever uma única linha, contendo um único caractere: ‘S’ se Tarzan consegue viajar de cipó entre todas as árvores remanescentes, e ‘N’ caso contrário.
Exemplos de Entrada Exemplos de Saída
4 5
1 1
6 1
6 6
11 6
S
4 5
1 1
6 6
11 6
13 8
N
OBI - Olimpíada Brasileira de Informática 2012 Fase 1 Nível 2 |
1,399 | 2413 | Busca na Internet | Muito Fácil | AD-HOC | João fez uma pesquisa em seu site de busca predileto, e encontrou a resposta que estava procurando no terceiro link listado. Além disso, ele viu, pelo site, que t pessoas já haviam clicado neste link antes. João havia lido anteriormente, também na Internet, que o número de pessoas que clicam no segundo link listado é o dobro de número de pessoas que clicam no terceiro link listado. Nessa leitura, ele também descobriu que o número de pessoas que clicam no segundo link é a metade do número de pessoas que clicam no primeiro link.
João está intrigado para saber quantas pessoas clicaram no primeiro link da busca, e, como você é amigo dele, quer sua ajuda nesta tarefa.
Entrada
Cada caso de teste possui apenas um número, t (1 ≤ t ≤ 1000), que representa o número de pessoas que clicaram no terceiro link da busca.
Saída
Para cada caso de teste imprima apenas uma linha, contendo apenas um inteiro, indicando quantas pessoas clicaram no primeiro link, nessa busca.
Exemplos de Entrada Exemplos de Saída
2
8
25
100
OBI - Olimpíada Brasileira de Informática 2012 Fase 1 Nível Júnior |
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.