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 |
|---|---|---|---|---|---|
2,600 | 530 | O Mar não está para Peixe | Médio | Basicos | 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$ 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 $X_i$ e $X_f$, $Y_i$ e $Y_f$ . A região coberta pela rede em questão contém todo ponto ($X, Y$) tal que $X_i \leq X \leq X_f$ e $Y_i \leq Y \leq Y_f$.
#### 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.
#### Restrições
* $1 \leq N \leq 100$
* $1 \leq X_i \leq X_f \leq 100$
* $1 \leq Y_i \leq Y_f \leq 100$ |
2,601 | 1723 | Pesquisa de preços | Fácil | Basicos | Uma jornalista está fazendo uma pesquisa de preços de combustíveis (álcool e gasolina), em vários estados do país, para uma reportagem sobre qual dos dois combustíveis é mais vantajoso para abastecer um carro.
Na reportagem ela vai usar a regra de que a utilização do álcool é vantajosa quando o preço por litro do álcool é no máximo igual a 70% do preço por litro da gasolina.
Ela compilou os dados da pesquisa em uma lista contendo o identificador do estado e os preços do litro de álcool e do litro de gasolina, e deseja computar em quais estados é mais vantajoso usar álcool ou gasolina. Você pode ajudá-la?
#### Entrada
A primeira linha da entrada contém um número inteiro $N$, o número de estados em que a pesquisa foi realizada. Cada uma das $N$ linhas seguintes contém o identificador do estado, $E$, seguido de dois números reais $A$ e $G$, representando respectivamente o preço do litro de álcool e o preço do litro de gasolina.
#### Saída
Para cada estado em que o álcool é vantajoso seu programa deve produzir uma linha, contendo somente o identificador do estado, na ordem em que os estados aparecem na entrada. Se em nenhum estado o álcool é vantajoso, seu programa deve imprimir uma linha contendo somente o caratere ’*’ (asterisco).
#### Restrições
* $1 ≤ N ≤ 27$
* $E$ é uma cadeia de caracteres formada por duas letras maiúsculas sem acento; todos os $E$ são distintos.
* $0.01 ≤ A ≤ 10.00$, com precisão de dois dígitos.
* $0.01 ≤ G ≤ 10.00$, com precisão de dois dígitos.
|
2,602 | 1683 | Estados do Norte | Muito Fácil | Basicos | Com extensão territorial igual 8,51 milhões km², o Brasil é o quinto maior país do planeta Terra. A sua região é, por sua vez, dividida em 5 regiões: Centro-Oeste, Nordeste, Norte, Sul e Sudeste.
A região Norte tem extensão territorial igual a 3,85 milhões km², e abrange 7 estados: Roraima, Acre, Amapá, Amazonas, Pará, Rondônia e Tocantins.
Você está ajudando um amigo em um trabalho para a escola, e precisa escrever um algoritmo que: dado o nome de um estado brasileiro, diga se o mesmo pertence à região Norte do Brasil ou não.
#### Entrada
A entrada será composta por uma única linha contendo o nome de um estado brasileiro. Todas as letras estarão em minúsculo e sem acentuação.
#### Saída
Imprima a frase "Regiao Norte", caso o estado informado seja da região Norte, ou "Outra regiao" caso contrário. |
2,603 | 621 | Frota de Táxi | Fácil | Basicos | A Companhia de Táxi Tabajara (CTT) é uma das maiores empresas de transporte do pais. Possui uma vasta frota de carros e opera em todas as grandes cidades. Recentemente a CTT modernizou a sua frota, adquirindo um lote de 500 carros bi-combustíveis (carros que podem utilizar como combustível tanto álcool quanto gasolina). Além do maior conforto para os passageiros e o menor gasto com manutenção, com os novos carros é possível uma redução adicional de custo: como o preço da gasolina está sujeito a variações muito bruscas e pode ser vantagem, em certos momentos, utilizar álcool como combustível. Entretanto, os carros possuem um melhor desempenho utilizando gasolina, ou seja, em geral, um carro percorre mais quilômetros por litro de gasolina do que por litro de álcool.
Você deve escrever um programa que, dados o preço do litro de álcool, o preço do litro de gasolina e os quilômetros por litro que um carro bi-combustível realiza com cada um desses combustíveis, determine se é mais econômico abastecer os carros da CTT com álcool ou com gasolina. No caso de não haver diferença de custo entre abastecer com álcool ou gasolina a CTT prefere utilizar gasolina.
#### Entrada
A entrada é composta por uma linha contendo quatro números reais com precisão de duas casas decimais $A$, $G$, $R_a$ e $R_g$, representando respectivamente o preço por litro do álcool, o preço por litro da gasolina, o rendimento (km/l) do carro utilizando álcool e o rendimento (km/l) do carro utilizando gasolina.
#### Saída
A saída deve ser composta por uma única linha contendo o caractere ‘A’ se é mais econômico abastecer a frota com álcool ou o caractere ‘G’ se é mais econômico ou indiferente abastecer a frota com gasolina.
#### Restrições
* $0.01 \leq A \leq 10.00$
* $0.01 \leq G \leq 10.00$
* $0.01 \leq R_a \leq 20.00$
* $0.01 \leq R_g \leq 20.00$
|
2,604 | 644 | Meteoros | Fácil | Basicos | Em noites sem nuvens pode-se muitas vezes observar pontos brilhantes no céu que se deslocam com grande velocidade, e em poucos segundos desaparecem de vista: são as chamadas estrelas cadentes, ou meteoros. Meteoros são na verdade partículas de poeira de pequenas dimensões que, ao penetrar na atmosfera terrestre, queimam-se rapidamente (normalmente a uma altura entre 60 e 120 quilômetros). Se os meteoros são suficientemente grandes, podem não queimar-se completamente na atmosfera e dessa forma atingem a superfície terrestre: nesse caso são chamados de meteoritos.
Zé Felício é um fazendeiro que adora astronomia e descobriu um portal na Internet que fornece uma lista das posições onde caíram meteoritos. Com base nessa lista, e conhecendo a localização de sua fazenda, Zé Felício deseja saber quantos meteoritos caíram dentro de sua propriedade. Ele precisa de sua ajuda para escrever um programa de computador que faça essa verificação automaticamente.
São dados:
* uma lista de pontos no plano cartesiano, onde cada ponto corresponde à posição onde caiu um
meteorito;
* as coordenadas de um retângulo que delimita uma fazenda.
As linhas que delimitam a fazenda são paralelas aos eixos cartesianos. Sua tarefa é escrever um programa que determine quantos meteoritos caíram dentro da fazenda (incluindo meteoritos que caíram exatamente sobre as linhas que delimitam a fazenda).
#### Entrada
Seu programa deve ler vários conjuntos de testes. A primeira linha de um conjunto de testes quatro números inteiros $X_1$ , $Y_1$, $X_2$ e $Y_2$ , onde $(X_1, Y_1)$ é a coordenada do canto superior esquerdo e $(X_2, Y_2)$ é a coordenada do canto inferior direito do retângulo que delimita a fazenda. A segunda linha contém um inteiro, $N$, que indica o número de meteoritos. Seguem-se $N$ linhas, cada uma contendo dois números inteiros $X$ e $Y$, correspondendo às coordenadas de cada meteorito. O final da entrada é indicado por $X_1 = Y_1 = X_2 = Y_2 = 0$.
#### Saída
Para cada conjunto de teste da entrada seu programa deve produzir três linhas na saída. A primeira linha deve conter um identificador do conjunto de teste, no formato “Teste n”, onde $n$ é numerado a partir de 1. A segunda linha deve conter o número de meteoritos que caíram dentro da fazenda. A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
#### Restrições
* $0 \leq N \leq 10000$
* $0 \leq X \leq 10000$
* $0 \leq Y \leq 10000$
* $0 \leq X_1 < X_2 \leq 10000$
* $0 \leq Y_2 < Y_1 \leq 10000$
|
2,605 | 739 | Soma e Subtração de Horários | Fácil | Basicos | O código abaixo faz a soma e subtração de dois horários. porém a implementação dos operadores de adição e de subtração estão incompletas, sua tarefa é implementar ambos operadores.
**OBS: Você pode considerar que ambos horários serão sempre horários válidos, ou seja, eles obedecem as restrições descritas na secção Restrições desse exercício.**
```c++
#include <stdio.h>
class Horario{
public:
int horas, minutos, segundos;
Horario(){}
Horario(int horas, int minutos, int segundos ){
this->horas = horas;
this->minutos = minutos;
this->segundos = segundos;
}
//TODO: Implementar o operador de adição.
Horario operator + (Horario b){
}
//TODO: Implementar o operador de subtração.
Horario operator - (Horario b){
}
};
int main(){
Horario a, b, c;
char op;
scanf("%d:%d:%d", &a.horas, &a.minutos, &a.segundos);
scanf("%d:%d:%d", &b.horas, &b.minutos, &b.segundos);
scanf(" %c", &op);
if(op == 'A'){
c = a + b;
} else if(op == 'S'){
c = a - b;
}
printf("%02d:%02d:%02d\n", c.horas, c.minutos, c.segundos);
}
```
#### Entrada
A entrada é composta por 3 linhas. A primeira contém 3 inteiros separados por ':' representando as horas, minutos e segundos do primeiro horário. A segundo linha contém 3 inteiros separados por ':' representando as horas, minutos e segundos do segundo horário.
A última linha contém que operação será realizada.
#### Saída
A saída do seu programa deve imprimir o horário resultante da operação entre os dois horários acima. Seguindo o modelo dos exemplos de entrada.
#### Restrições
* As horas podem variar entre 0 e 23.
* Os minutos variam entre 0 e 59.
* Os segundos variam entre 0 e 59. |
2,606 | 1236 | Jankenpon | Nível Desconhecido | Basicos | Jankenpon é um jogo recreativo usando gestos de mão que representam pedra, papel e tesoura, tão conhecido no Brasil quanto o Par ou Impar, simples e que não requer equipamentos podendo ser jogado por duas ou mais pessoas. Em alguns países, substituem-se a pedra, a tesoura e o papel por outros símbolos. Por exemplo, na Índia usam-se homem, arma e tigre, comparam os símbolos para decidir quem ganhou da seguinte forma:
- Homem ganha da Arma(homem usa a arma).
- Arma ganha do Tigre (a arma mata o tigre).
- Tigre ganha do Homem (tigre mata o homem).
Maria e João são dois amigos que estão cansados de jogar JanKenpon da forma tradicional e resolveram testar a forma Indiana. Infelizmente eles estão com muitas dúvidas na hora de jogar e pediram que você ajude a falar o resultado de cada competição!
#### Entrada
A primeira linha da entrada contém um inteiro N, que indica o número de rodadas na partida. Cada uma das N linhas seguintes contém dois caracteres M e J, que representam o símbolo que os jogadores Maria e Joao, respectivamente, jogaram em uma rodada. Os símbolos podem ser "H" de Homem, "A" de Arma ou "T" de Tigre,
#### Saída
Seu programa deve imprimir uma linha contendo o nome do jogador que venceu a partida: “Joao” ou “Maria”, sem nenhum acento. Caso dê empate, você deverá imprimir “JanKenpon”. Não esqueça de imprimir o fim de linha após o resultado.
|
2,607 | 1461 | Amizade | Fácil | Basicos | Ana e Maria são grandes amigas e moram na mesma rua. Maria irá se mudar para outra casa na mesma rua, mas elas ainda não sabem em qual casa Maria irá morar. As amigas estão ansiosas para saber se irão morar mais próximas uma da outra. Com isso, elas analisaram em quais casas Maria poderia morar e agora querem saber quantas estão a uma distância que é menor ou igual à distância atual entre suas casas. Sabendo que entre uma casa na localização $X$ e uma casa na localização $X+1$ existe uma diferença de um metro, faça um programa que determine o número de casas que possuem distância menor ou igual à distância atual entre as amigas.
#### Entrada
A primeira linha de entrada contém um inteiro $N$ representando o número de casas nas quais Maria poderia morar. A segunda linha apresenta dois inteiros $A$ e $D$, representando respectivamente a localização da casa de Ana e a distância atual entre as casas de Ana e Maria. A terceira linha apresenta $N$ inteiros $M_i$ que correspondem à localização de cada casa na qual Maria poderia morar.
#### Saída
Sua saída deve conter um inteiro $C$ representando o número de casas que possuem distância menor ou igual a $D$.
#### Restrições
* $1 \leq N \leq 10^{4}$
* $1 \leq A$, $D$, $M_i \leq 10^9$
#### Informações Sobre a Pontuação
* Em um conjunto de casos de teste somando $20$ pontos, $N= 2$.
* Em um conjunto de casos de teste somando $30$ pontos, $A$, $D$, $M_i < 10^9$.
* Em um conjunto de casos de teste somando $50$ pontos, nenhuma restrição adicional. |
2,608 | 2069 | Show | Médio | Basicos | Um grupo de amigos quer comprar ingressos para um show da sua banda preferida. O show acontece num teatro que tem $N$ filas de assentos, cada fila com $M$ assentos.
Os amigos querem comprar ingressos de forma que os assentos dos amigos:
* sejam todos na mesma fila,
* sejam contíguos (ou seja, um vizinho ao outro) e
* sejam na fila mais próxima possível do palco.
Dado um mapa descrevendo os assentos disponíveis, ajude os amigos a encontrarem os ingressos de acordo com as condições acima.
#### Entrada
A primeira linha contém três inteiros $A$, $N$ e $M$, indicando respectivamente o número de amigos, o número de filas de assentos e o número de assentos em cada fila do teatro. As filas são numeradas de $1$ (mais próxima do palco) até $N$ (mais distante do palco). Cada uma das $N$ linhas seguintes contém $M$ inteiros $X_i$, que podem ter o valor $1$ (representando um assento ocupado) ou o valor $0$ (representando um assento não ocupado). As filas de assentos são dadas da fila mais distante para a fila mais próxima do palco. Ou seja, a primeira fila dada na entrada é a fila $N$ (mais distante do palco), a última fila dada na entrada é a fila $1$ (mais próxima do palco).
#### Saída
Seu programa deve produzir uma única linha, contendo um único inteiro, que deve ser o número da fila em que os amigos conseguem comprar os ingressos se é possível encontrar ingressos de acordo com as condições dadas, ou $−1$ caso contrário.
#### Restrições
* $2 ≤ A ≤ 100$
* $1 ≤ N ≤ 100$
* $1 ≤ M ≤ 100$
* $0 ≤ Xi ≤ 1$ para $1 ≤ i ≤ M$
#### Informações sobre a pontuação
* Para um conjunto de casos de testes valendo $20$ pontos, $N = 1$.
_Explicação do exemplo 1:_ São $4$ amigos e o teatro tem $3$ filas com $5$ cadeiras cada fila. A melhor opção é a fila $1$, embora os quatro amigos possam também comprar os ingressos na fila $3$. Na fila $2$ não há cadeiras vagas suficientes.
_Explicação do exemplo 2:_ São $2$ amigos e o teatro tem $3$ filas com $5$ cadeiras cada fila. Nenhuma fila tem $2$ cadeiras vagas contíguas.
_Explicação do exemplo 3:_ São $3$ amigos e o teatro tem $6$ filas com $4$ cadeiras cada fila. As únicas filas com cadeiras vagas suficientes são a fila $5$ e a fila $6$, então a melhor opção é a fila $5$. |
2,609 | 939 | VAI UMA PIZZA? | Nível Desconhecido | Basicos | Joãozinho comprou uma pizza e gostaria de distribuir seus pedaços entre seus amigos, sendo que a pizza tem 8 pedaços.
Joãozinho pediu sua ajuda para saber quantas pizzas seriam necessárias para dividir entre seus amigos, para que cada um coma no mínimo 1 pedaço de pizza.
#### Entrada
O usuário entrará com o número $X$ de amigos.
#### Saída
A saída constará do número total de pizzas que Joãozinho pedirá.
#### Restrições
* $0 \leq X \leq 10^{9}$
|
2,610 | 1726 | Poligrama | Difícil | Basicos | Duas palavras A e B são anagramas entre si se podemos transformar a palavra A na palavra B apenas trocando de posição as letras da palavra A. Por exemplo, “duetos” e “estudo” são anagramas entre si. Um outro exemplo é “bba” e “bab”.
Vamos chamar de poligrama uma palavra que consiste na concatenação de duas ou mais palavras que são anagramas entre si. A primeira dessas palavras é chamada de raiz do poligrama. Por exemplo, a palavra “bbabab” é um poligrama com raiz “bba”, pois ela é a concatenação dos anagramas “bba” e “bab”.
Dada uma palavra, escreva um programa que determine se ela é um poligrama e encontre a sua raiz.
#### Entrada
A primeira linha da entrada contém um inteiro $N$, indicando o número de letras da palavra. A segunda linha contém a palavra $P$.
#### Saída
Seu programa deve produzir uma única linha. Se a palavra dada é um poligrama, a linha deve conter a raiz do poligrama. Caso contrário, a linha deve conter o caractere asterisco (’*’). Se houver mais de uma raiz possível, seu programa deve imprimir a de menor comprimento.
#### Restrições
* $1 ≤ N ≤ 100000$
* O número de caracteres de $P$ é igual a $N$.
* Os únicos caracteres em $P$ são letras minúsculas não acentuadas.
#### Informações sobre a pontuação
* Para um conjunto de casos de testes valendo 40 pontos, $N ≤ 1000$.
* Para um conjunto de casos de testes valendo outros 70 pontos, nenhuma restrição adicional.
|
2,611 | 1015 | Jogo dos Pinos | Médio | Basicos |
O Jogo dos Pinos é um quebra-cabeças que utiliza pinos e um tabuleiro com furos em forma de cruz. Inicialmente há apenas um furo vago, no centro do tabuleiro, e todos os outros furos contém um pino como mostra a figura abaixo.
O objetivo do jogo é remover os pinos do tabuleiro de forma que reste apenas um pino. Para remover um pino é necessário fazer um *movimento válido*, que é definido da seguinte maneira. O jogador deve escolher um pino, chamado *pivô*, e uma das quatro direções (acima, abaixo, esquerda, direita) de tal forma que o pivô tenha um outro pino, chamado *alvo*, como vizinho imediato na direção escolhida e que o pino alvo seja seguido, também na direção escolhida, por um furo vago (chamado de *destino*). A figura abaixo mostra os quatro possíveis pivôs da configuração inicial do jogo.
O jogador pode então fazer o pino pivô pular sobre o pino alvo e ocupar o furo destino, removendo o pino alvo do tabuleiro. A figura abaixo mostra um exemplo (a) antes, (b) durante e (c\) depois de um movimento válido.
Dada uma configuração de pinos em um tabuleiro, escreva um programa para determinar o número de movimentos válidos possíveis na configuração dada.
#### Entrada
A entrada é composta por sete linhas, cada linha com exatamente sete caracteres. A linhas são identificadas por números de 1 a 7. Os dois primeiros caracteres e os dois últimos caracteres das linhas 1, 2, 6 e 7 são ‘-’ (hífen). Todos os outros caracteres são ou ‘o’ (letra o minúscula) representando um pino, ou ‘.’ (ponto) representando um furo.
#### Saída
Seu programa deve produzir uma única linha, contendo um único inteiro, o número de movimentos válidos na configuração da entrada.
#### Restrições
* A seção Entrada descreve as restrições.
|
2,612 | 1528 | Ajude Luiz Cláudio | Nível Desconhecido | Basicos | Luiz Cláudio é um dos dos melhores professores da UHCC (Universidade dos Habilidosos Codificadores de Código), onde ele leciona aulas de lógica de programação. Está chegando o fim do semestre e Luiz Cláudio precisa enviar as notas de seus alunos para o sistema da faculdade, infelizmente suas anotações estão fora de ordem e o sistema aceita apenas notas em ordem crescente. Luiz Cláudio pediu para você fazer um programa para auxiliá-lo nessa tarefa.
#### Entrada
A entrada contém um numero $N$ correspondente a quantidade de notas a seres enviadas ao portal, seguida por $N$ números correspondentes as notas de cada aluno(a). Considere que cada nota seja maior ou igual a 0 e menor ou igual a 10.
#### Saída
A saída deve dizer se as notas catalogadas pelo professor Luiz Cláudio foram válidas ou caso tenha algo errado e as notas forem inválidas.
|
2,613 | 510 | Janela | Médio | Basicos | A sala de aulas utilizada para os cursos da OBI tem uma grande janela, composta de três folhas de vidro. A janela tem um metro de altura por seis metros de comprimento. Cada folha da janela tem um metro de altura e dois metros de comprimento. As folhas deslizam sobre trilhos, ao longo do comprimento da janela, de forma que é possível controlar a abertura da janela, para circulação de ar.
Dadas as posições das três folhas da janela, deseja-se determinar qual a área da janela que está aberta, em centímetros quadrados.
A figura abaixo ilustra duas configurações das folhas da janela. Na figura, os cantos inferiores esquerdos de cada folha são indicados por $F_1$, $F_2$ e $F_3$. Na configuração (a) a janela está totalmente fechada, e portanto o total da área aberta é igual a zero. Na configuração (b) há duas aberturas, e o total de área aberta é igual a $(100 \times 100) + (50 \times 100) = 15.000$ $cm^2$.
Dadas as posições das três folhas da janela, escreva um programa que calcule a área da janela que está aberta, em centímetros quadrados.
#### Entrada
A primeira e única linha da entrada contém três inteiros $F_1$, $F_2$ e $F_3$, indicando as posições das três folhas. A posição de cada folha é dada pela distância, em centímetros, da extremidade esquerda da janela até a extremidade esquerda da folha.
#### Saída
Seu programa deve imprimir uma única linha, contendo um único inteiro, a área aberta da janela em centímetros quadrados.
#### Restrições
* $0 \leq F_1, F_2, F_3 \leq 400$
|
2,614 | 859 | Suprema Competição | Nível Desconhecido | Basicos | Dungeons and Dragons é um Role-Playing Game (RPG) conhecido mundialmente, inclusive na cidade de Hawkins, onde é jogado por Mike, Dustin, Will e Lucas.
Will quer ensinar a 11 a jogar RPG, por isso resolveu apresentá-la à Suprema Competição (SC), uma competição entre as mais diversas classes para mostrar seus poderes. Na modalidade "Tiro Elemental" a competição possui cinco elementos mágicos e é travada entre dois magos.
Em cada rodada, os magos escolhem simultaneamente um elemento mágico diferente do seu adversário (eles não escolhem o mesmo elemento pois o impacto destruiria a arena) e um deles se sobressai. Na tabela abaixo cada elemento aponta para quais elementos ele derrota, por exemplo: “Jato de Água” derrota “Bola de Fogo”.
0. Bola de Fogo
1. Rajada de Vento
2. Corrente de Relâmpagos
3. Erupção Terrestre
4. Jato de Água
\
\
Depois de $N$ rodadas quem vencer mais vezes o adversário será o vencedor da SC e ganhará poderes supremos. Sua tarefa é dizer quem foi o vencedor.
#### Entrada
A primeira linha contém um inteiro $N$, indicando a quantidade de rodadas que durou a competição. Cada uma das $N$ linhas seguintes possui 2 inteiros $M_1$ e $M_2$ representando, respectivamente, o elemento escolhido por Will e o escolhido pela 11.
#### Saída
Seu programa deverá imprimir apenas o nome do vencedor: $will$ ou $11$. Os nomes devem estar em $minúsculo$.
#### Restrições
* $N \leq 999$, $N$ é ímpar
* $0 \leq M_1,M_2 \leq 4$ e $M_1 \neq M_2$
<br>
<br>
<center>Problema adaptado da Olimpíada Brasileira de Informática</center>
<br> |
2,615 | 1706 | Gabriel Astuto | Nível Desconhecido | Basicos | Gabriel, um menino astuto, adora brincar de escrever palavras incompletas a partir de uma posição $N$ de sua frase. Como por exemplo seu nome: Gabriel Ribeirinho. Ele pegará a partir da posição 3, portanto seu nome ficaria: iel Ribeirinho.
Ajude o garoto Gabriel a fazer essas brincadeira com as frases de uma forma computadorizada.
#### Entrada
Uma String, podendo conter espaços e um número inteiro, que será o separador.
#### Saída
Uma String contendo uma cópia da outra a partir da posição especificada.
* $0 < len(str) \leq 100$
* $0 \leq N \leq len(str)$ |
2,616 | 1778 | Três inteiros | Fácil | Basicos | Dados três inteiros A, B e C, onde A, B e C são 1 ou 2. Qual aparece mais, 1 ou 2?
#### Entrada
A entrada é dada pela entrada padrão na seguinte forma:
A B C
#### Saída
Imprima o inteiro que está em maior quantidade entre os números recebidos, podendo ser 1 ou 2.
#### Restrições
A, B e C são 1 ou 2. |
2,617 | 1245 | O chamado do mamaco | Nível Desconhecido | Basicos | Um amigo de Mallard, Cacajao está tendo problemas com seus primos mais novos, eles não gostam de ficar parados e acabam trocando de galhos. Por ser muito organizado, Cacajao pretende verificar se todos os seus primos estão em seus devidos lugares, mas como ele tem vários primos ele pediu ajuda a você para que resolva essa enorme bananada.
Cada macaco será representado por um valor entre $1$ e $N$ sem repetições. Um macaco está no seu lugar quando a posição em que se encontra é igual o valor que o representa. Os galhos começam de $1$ e vão até $N$-ésimo galho, inclusive.
Dado a quantidade de primos, tal como a localização de cada um nos galhos, imprima quantos não estão em seu devido lugar.
#### Entrada
A primeira linha da entrada consiste em um inteiro $N$, indicando a quantidade de primos de Cacajao.
Na segunda linha, teremos $N$ valores variando de $1$ a $N$, lembrando que cada macaco tem seu valor próprio.
#### Saída
A saída consiste de uma única linha contendo a quantidade dos primos de Cacajao que não estão em seus devidos lugares, caso todos estejam em seus devidos lugares imprima “Cada mamaco em seu lugar”.
#### Restrições
* $1 \leq N \leq 10^{4}$ |
2,618 | 1272 | Pedro e Diogo | Nível Desconhecido | Basicos | *Neste exercício, espaços não são considerados caracteres.*
Pedro e Diogo são irmãos gêmeos, eles gostam muito um do outro desde sempre, porém com a chegada de um novo vírus (divoc-91) causou uma pandemia no mundo e como medida de segurança o Governo da cidade orientou que as pessoas ficassem em casa.
Desde então Pedro e Diogo ficam a maior parte do dia em seus quartos separados, comunicando-se apenas por mensagem de texto. Entretanto, os irmãos começaram a ficar preguiçosos e estabeleceram um limite de caracteres que cada mensagem pode ter ao ser enviada entre eles, caso a mensagem superasse o limite de caracteres o irmão que recebeu a mensagem ignoraria o que foi escrito, caso contrário a mensagem seria lida.
Sua tarefa é criar um programa que receba o limite de caracteres estabelecido pelos irmãos, assim como um texto que seria a mensagem enviada. O programa deve dizer se a mensagem enviada será lida ou se ela será ignorada.
Observação: lembre-se que letras, vírgulas e pontos também são caracteres.
#### Entrada
O programa recebe um valor $N$, que será o limite de letras estabelecido entre os irmãos, em seguida recebe um texto representando a mensagem enviada.
#### Saída
A saída do programa deve dizer se a mensagem foi lida, com "Mensagem lida" caso positivo ou "Mensagem ignorada" caso contrário.
#### Restrições
* $0 \leq N \leq 1000$
|
2,619 | 640 | Temperatura Lunar | Médio | Basicos | Sem as proteções da atmosfera e do cinturão magnético que existem na Terra, a Lua fica exposta ao ataque do Sol, que é um astro em constante explosão atômica. As explosões do Sol emitem ondas letais de partículas. Uma pessoa que ficasse desprotegida na superfície da Lua, num lugar onde o Sol incidisse diretamente, sofreria um bombardeio radioativo tão intenso quanto se estivesse nas imediações da usina russa de Chernobyl no momento do acidente que matou 31 pessoas, em 1986. Além da radiação solar, outro efeito desta falta de proteção contra o Sol que existe na Lua é a enorme variação de temperatura. Nas regiões próximas do equador lunar, a variação de temperatura é brutal, passando de cerca de 130 graus positivos durante o dia a 129 graus negativos à noite.
Para estudar com mais precisão as variações de temperatura na superfície da Lua, a NASA enviou à Lua uma sonda com um sensor que mede a temperatura de 1 em 1 minuto. Um dado importante que os pesquisadores desejam descobrir é como se comporta a média da temperatura, considerada em intervalos de uma dada duração (uma hora, meia hora, oito horas, etc.). Por exemplo, para a seqüência de medições 8, 20, 30, 50, 40, 20, -10, e intervalos de quatro minutos, as médias são respectivamente 108/4=27, 140/4=35, 140/4=35 e 100/4=25.
Você foi recentemente contratado pela NASA, e sua primeira tarefa é escrever um programa que, conhecidos a seqüência de temperaturas medidas pelo sensor, e o tamanho do intervalo desejado, informe qual a maior e qual a menor temperatura média observadas, considerando o tamanho do intervalo dado.
#### Entrada
A entrada é composta de vários conjuntos de teste. A primeira linha de um conjunto de teste contém dois números inteiros positivos $N$ e $M$, que indicam respectivamente o número total de medições de temperatura de uma seqüência obtida pelo sensor, e o tamanho dos intervalos, em minutos, em que as médias devem ser calculadas. As $N$ linhas seguintes contêm um número inteiro cada, representando a seqüência de medidas do sensor. O final da entrada é indicado quando $N = M = 0$.
#### Saída
Para cada conjunto de teste da entrada seu programa deve produzir três linhas. A primeira linha identifica o conjunto de teste, no formato “Teste n”, onde $n$ é numerado a partir de 1. A segunda linha deve conter dois números inteiros $X$ e $Y$, separados por ao menos um espaço em branco, representando respectivamente os valores da menor e da maior média de temperatura, conforme determinado pelo seu programa. O valor da média deve ser truncado, se a média não for um número inteiro (ou seja, deve ser impressa apenas a parte inteira). A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
#### Restrições
* $0 \leq N \leq 10000$ ($N = 0$ apenas para indicar o fim da entrada)
* $-200 \leq$ Temperatura $\leq 200$
* $1 \leq M \leq N$ |
2,620 | 741 | Empresa de Desenvolvimento | Fácil | Basicos | Dois amigos trabalham na **Neps Software House** desenvolvendo software. Um é um programador e o outro é um designer.
Todo mês eles recebem uma lista de projetos para serem desenvolvidos, os amigos conseguem desenvolver o projeto se tanto o programador tiver habilidade maior do que a habilidade de programação requerida pelo projeto e o designer tiver habilidades de design maior do que a habilidade de design requerida pelo projeto.
Caso consigam desenvolver o projeto cada um recebe um valor de acordo com o que foi combinado com o dono da _Software House_.
O código abaixo calcula quanto cada um vai ganhar após desenvolver uma lista de projetos. Como eles estão muito ocupado trabalhando em projetos mais importantes eles pediram a você, novo estagiário da empresa, para completar o código abaixo:
```c++
#include <stdio.h>
class Projeto {
public:
int requisito_programacao;
int requisito_design;
};
class Empregado {
protected:
int valor_por_projeto;
int valor_recebido;
public:
//Um empregado normal não é capaz de entregar nenhum projeto :(
bool capaz(Projeto P){
return false;
}
void receber_recompensa(){
this->valor_recebido += valor_por_projeto;
}
int get_valor_recebido(){
return this->valor_recebido;
}
};
class Programador : public Empregado {
int habilidade_programacao;
public:
//TODO: Complete o código do construtor inicializando os valores corretamente.
Programador(int valor_por_projeto, int habilidade_programacao){
}
//TODO: Um programador deve ser capaz de entregar um projeto se sua habilidade de programação é maior que o requisito de programação do projeto.
bool capaz(Projeto P){
}
};
class Designer : public Empregado {
int habilidade_design;
public:
//TODO: Complete o código do construtor inicializando os valores corretamente.
Designer(int valor_por_projeto, int habilidade_design){
}
//TODO: Um designer deve ser capaz de entregar um projeto se sua habilidade de design é maior que o requisito de design do projeto.
bool capaz(Projeto P){
}
};
int main(){
int valor, habilidade;
scanf("%d %d", &valor, &habilidade);
Programador programador = Programador(valor, habilidade);
scanf("%d %d", &valor, &habilidade);
Designer designer = Designer(valor, habilidade);
int N;
scanf("%d", &N);
for(int i=0;i<N;i++){
Projeto projeto;
scanf("%d %d", &projeto.requisito_programacao, &projeto.requisito_design);
//TODO:Use os métodos das classes acima para calcular quando tanto o programador quanto o designer conseguem desenvolver o projeto P e dê a recompensa a cada um caso eles consigam.
}
printf("Programador: R$ %d\n", programador.get_valor_recebido());
printf("Designer: R$ %d\n", designer.get_valor_recebido());
}
```
#### Entrada
A entrada é composta de múltiplas linhas.
A primeira linha contém o valor que o programador irá receber a cada projeto seguido da sua habilidade em programação.
A segunda linha contém o valor que o designer irá receber a cada projeto seguido da sua habilidade em design.
A terceira linha contém um inteiro $N$, representando quantos projetos eles tem para desenvolver.
As próximas $N$ linhas contém dois inteiro cada, representando os requisitos de habilidade em programação e em design para desenvolver cada projeto, respectivamente.
#### Saída
A saída do seu programa já é impressa pelo código de exemplo.
#### Restrições
* O valor recebido por projeto pode variar entre 1 e 1000 reais;
* As habilidades do programador e do designer podem variar entre 0 e 10;
* Os requisitos de habilidades dos projetos também podem variar entre 0 e 10;
* $1 \leq N \leq 100$
|
2,621 | 1403 | Ajude o UberHub | Nível Desconhecido | Basicos | O UberHub Code Club é um programa de incentivo à formação de desenvolvedores de software realizado pelo Instituto UberHub Educação e o ecossistema de inovação da cidade de Uberlândia, o UberHub, com o apoio de diversas entidades, empresas e pessoas físicas interessadas. O objetivo do UberHub Code Club é iniciar 21 mil pessoas em tecnologia avançada até o ano de 2029 e, em consequência disso, fazer com que Uberlândia seja referência nacional desses talentos, que são qualificados e escassos. Infelizmente, nem todas pessoas inscritas no projeto permanecem até o fim. Ajude o UberHub a ter um controle calculando a porcentagem de desistência do projeto.
#### Entrada
A entrada consiste em dois inteiros $N$ e $F$ que indicam, respectivamente, o número de alunos inscritos e a quantidade de alunos formados.
#### Saída
Seu programa deverá calcular a porcentagem de alunos que desistiram em relação ao total de alunos inscritos. Se atente para apresentar com 2 vírgulas após o ponto, além do sinal de ‘%’ (porcentagem).
|
2,622 | 1084 | Música para Todos | Médio | Basicos |
Uma empresa de *streaming* de músicas lançou uma nova funcionalidade, para grupos de amigos ouvirem em seus aparelhos a mesma música ao mesmo tempo, compartilhando assim um momento de alegria nestes tempos difíceis de pandemia.
Cada amigo no grupo tem que declarar uma música que adora e uma música que detesta. Um amigo fica *satisfeito* se a música que está sendo compartilhada não é a música que ele detesta. Se a música que está sendo compartilhada é detestada por um dos amigos, ele pode trocar a música
sendo compartilhada pela música que ele adora. Se há mais de um amigo que detesta a música que está sendo compartilhada, somente o amigo que é cliente há mais tempo da empresa é que pode trocar a música (e troca pela música que adora).
Obviamente, após a troca da música compartilhada pode ser que outro amigo deteste a nova música, e uma nova troca pode ocorrer. E as trocas podem ser intermináveis!
Dadas as preferências de um grupo de amigos e a música sendo compartilhada, e considerando que sempre ocorre troca enquanto houver cliente não satisfeito, escreva um programa para determinar quantas trocas ocorrem até que todos os amigos estejam satisfeitos.
#### Entrada
A primeira linha da entrada contém três inteiros $N$, $M$ e $C$, respectivamente o número de amigos, o número de músicas e a música que está sendo compartilhada. As músicas são identificadas por inteiros de 1 a $M$. Cada uma das $N$ linhas seguintes descreve as escolhas de um amigo e contém dois inteiros $A$ e $D$, identificando respetivamente a música adorada e a música detestada. A ordem dos amigos na entrada obedece à ordem em que os amigos se tornaram clientes da empresa (o amigo que aparece antes é cliente há mais tempo).
#### Saída
Seu programa deve produzir uma única linha na saída, contendo um único inteiro, o número de trocas até que todos os amigos fiquem satisfeitos ou o número -1 se as trocas continuam indefinidamente.
#### Restrições
* $1 \leq N \leq 10^5$
* $1 \leq M \leq 10^5$
* $1 \leq C \leq M$
* $1 \leq A, D \leq M$ e $A \ne D$
#### Informações sobre a pontuação
* Para um conjunto de casos de testes valendo 40 pontos, 1 $\leq N$, $M\ \leq$ 1000. |
2,623 | 2165 | Jogo | Fácil | Basicos | Uma empresa está desenvolvendo um aplicativo para celular que tem como objetivo estimular o gosto por matemática em jovens.
O aplicativo é um jogo, chamado Maior ou Menor, que sorteia um número inteiro e o jogador tem que adivinhar qual o número sorteado. O jogo é composto de uma ou mais rodadas. A cada rodada, o jogador digita um número e o aplicativo responde com:
* _menor_ se o número digitado é maior do que o sorteado;
* _maior_ se o número digitado é menor do que o sorteado; e
* _correto_ se o número digitado é igual ao número sorteado.
O jogo termina quando o jogador acerta o número sorteado.
Dados o número sorteado e as tentativas de um jogador, você deve escrever um programa que simule o comportamento do aplicativo.
#### Entrada
A primeira linha contém um inteiro $X$, o número sorteado pelo aplicativo. Cada uma das linhas seguintes contém um inteiro $T$, indicando uma tentativa do jogador de acertar o número sorteado. Na última linha da entrada, $T = X$.
#### Saída
Para cada tentativa do jogador seu programa deve produzir uma linha na saída, contendo apenas uma palavra, que deve ser menor se o valor da tentativa é maior do que o número sorteado, maior se o valor da tentativa é menor do que o número sorteado ou correto se o valor da tentativa é igual ao número sorteado.
#### Restrições
* $−10$ $000 ≤ X ≤ 10$ $000$
* $−10$ $000 ≤ T ≤ 10$ $000$
* Haverá no máximo $1000$ rodadas em cada jogo.
#### Informações sobre a pontuação
* Para um conjunto de casos de testes valendo $43$ pontos, é garantido que o jogo termina em exatamente duas rodadas.
* Para um outro conjunto de casos de testes valendo $57$ pontos, nenhuma restrição adicional.
|
2,624 | 1207 | Sorteio | Nível Desconhecido | Basicos |
Em um determinado evento, haverá um sorteio no qual os convidados irão concorrer, cada convidado ganhará um número, aleatoriamente, para participar do sorteio.
O sorteio é composto de 3 presentes em que será distribuído aos participantes do evento em ordem de chegada. O primeiro participante ganhará, o participante que estiver na posição do meio e o último participante.
Sua tarefa é criar um programa que receba a quantidade de participantes, o número que cada participante receberá e os ganhadores.
#### Entrada
É composta por $N$ sendo o total de participantes, bem como o número que cada participante receberá.
#### Saída
Deverá ser impresso, em linhas abaixo, o primeiro ganhador, o segundo ganhador e o terceiro ganhador.
#### Restrições
* $2 < N \leq 10^{6}$ |
2,625 | 2303 | Problemas de adição | Muito Fácil | Basicos | Seu amigo Bob é muito ruim em somar números e gostaria de ajuda para ter certeza de que está fazendo isso corretamente! Você poderia ajudar Bob a se certificar de que ele está somando corretamente? Dados 3 números inteiros $A$, $B$, $C$, certifique-se de que $A + B = C$ e que Bob de fato somou $A$ e $B$ corretamente.
#### Entrada
A entrada consiste em uma única linha com 3 inteiros $A, B, C$ onde $-10^9 \le A, B, C \le 10^9$.
#### Saída
A saída deve ser: "correct!" se $A + B = C$, ou "wrong!" se $A + B \ne C$. |
2,626 | 740 | Neps Arena: Batalha Mortal | Médio | Basicos | **Neps Arena** é um jogo onde o herói luta contra um inimigo até a morte (ou quase). Em cada turno o herói e o inimigo trocam golpes, caso um deles fique com a vida menor ou igual a 0 o outro é considerado o vencedor do combate.
O herói tem sempre duas opções de ataques, possivelmente com danos diferentes, enquanto o inimigo tem apenas uma. Durante cada round o herói seleciona qual ataque irá utilizar.
Caso nenhum dos dois seja derrotado ao final de $N$ rounds ou ambos sejam derrotados no mesmo round o combate é considerado empatado.
O código abaixo implementa o jogo **Neps Arena**. Porém a classe Heroi e Inimigo não estão completas.
Sua tarefa é completar o código implementando os **TODO**s.
```c++
#include <stdio.h>
class Personagem {
protected:
int vida;
int defesa;
int quantidade_ataques;
int *ataques;
void recebe_golpe(Personagem B);
void golpear(Personagem B);
public:
int get_vida(){
return vida;
}
void receber_dano(int dano){
this->vida -= (dano - defesa) > 0 ? (dano - defesa) : 0;
}
int* get_ataques(){
return ataques;
}
};
class Heroi : public Personagem {
public:
//TODO: Implemente o construtor da classe Heroi. Lembre-se que o herói tem duas opções de ataque.
Heroi(int vida, int defesa, int ataque1, int ataque2){
}
//TODO: Implemente o método golpear, Lembre-se que o herói tem duas opções de ataque.
void golpear(Personagem &B, int opcao){
}
};
class Inimigo : public Personagem {
public:
//TODO: Implemente o construtor da classe Inimigo. Lembre-se que o inimigo tem apenas uma opção de ataque.
Inimigo(int vida, int defesa, int ataque){
}
//TODO: Implemente o método golpear da classe Inimigo.
void golpear(Personagem &B){
}
};
int main(){
int vida, defesa, ataque1, ataque2;
scanf("%d %d %d %d", &vida, &defesa, &ataque1, &ataque2);
Heroi heroi = Heroi(vida, defesa, ataque1, ataque2);
scanf("%d %d %d", &vida, &defesa, &ataque1);
Inimigo inimigo = Inimigo(vida, defesa, ataque1);
int rounds, opcao;
scanf("%d", &rounds);
for(int i=0; i < rounds and inimigo.get_vida() > 0 and heroi.get_vida() > 0; i++){
scanf("%d", &opcao);
heroi.golpear(inimigo, opcao);
inimigo.golpear(heroi);
}
if ((heroi.get_vida() <= 0 and inimigo.get_vida() <= 0) or (heroi.get_vida() > 0 and inimigo.get_vida() > 0)){
printf("EMPATE\n");
}else if (heroi.get_vida() > 0){
printf("HEROI\n");
}else {
printf("INIMIGO\n");
}
}
```
#### Entrada
A entrada é composta de múltiplas linhas. A primeira linha da entrada contém os atributos do herói, sua vida, defesa dano do ataque 1 e dano do ataque 2.
A segundo a linha contém os atributos do inimigo, sua vida, defesa, dano do ataque.
A terceira linha contém $N$, representando a quantidade de rounds.
As próximas $N$ linhas contém $A_i$ representando o ataque selecionado pelo herói no round $i$. O valor 0 representa que o herói usou o ataque 1, enquanto o valor 1 representa que o herói resolveu atacar com o ataque 2.
#### Saída
A saída do seu programa já é gerada pelo código e será "EMPATE" caso o combate cabe em empate, "HEROI" caso o herói saia vitorioso e "INIMIGO" caso o inimigo vença o combate.
#### Restrições
* Os pontos de vida podem variar entre 1 e 1000.
^ Os pontos de defesa e valores de ataque podem variar entre 0 e 1000.
* $1 \leq N \leq 100$.
* $0 \leq A_i \leq 1$
|
2,627 | 736 | Pew Pew: Versão Beta | Médio | Basicos | Como você já deve saber, Pew Pew é um famoso jogo de video game onde o jogador precisa acertar inimigos na tela utilizando armas a lazer.
Em cada fase aparecem $N$ inimigos na tela seguindo as coordenadas de um plano cartesiano (x, y) e o jogador tem a oportunidade de realizar $T$ disparos com lasers. Caso o jogador dispare um lazer exatamente na posição do inimigo o inimigo é abatido.
O código fonte do jogo se encontra abaixo, porém algumas partes estão faltando, sua tarefa é completar as partes que estão faltando no código.
**TODOs** indicam partes do código que ainda precisam ser implementadas.
```cpp
#include <stdio.h>
class Inimigo {
int id;
int x;
int y;
bool vivo;
public:
Inimigo(){
}
//TODO: Crie um construtor que inicializa um inimigo usando os parâmetros abaixo.
Inimigo(int id, int x, int y, bool vivo){
}
//TODO: Crie um método que muda a o status do inimigo de vivo para morto caso seja acertado pelo lazer na posição (X,Y).
//Retorna true caso o inimigo tenha sido acertado pela primeira vez e falso caso contrário.
bool foi_acertado(int x, int y){
}
};
class Fase{
Inimigo *inimigos;
int quantidade_inimigos;
int pontos;
int municao;
public:
Fase(int quantidade_inimigos, int municao){
this->inimigos = new Inimigo[quantidade_inimigos];
this->quantidade_inimigos = quantidade_inimigos;
this->pontos = 0;
this->municao = municao;
}
//TODO: Crie um método quer ler as coordenadas do inimigos (conforme a descrição de entrada) e inicialize o vetor inimigos utilizando o construtor da classe Inimigo.
void inicializar_inimigos(){
}
//TODO: Crie um método que simula as T tentativas de disparos, caso o disparo acerte um inimigo incremente a pontuação em 10 pontos. Seu método deve ler as coordenadas dos disparos conforme o exemplo de entrada.
//Dica: Lembre-se que o jogador só tem M munições por fase e ele não deve ser capaz de disparar após a munição acabar.
void jogar(int T){
}
void imprimir_relatorio(){
//Crie um for que imprime todos os inimigos que foram acertados e morreram.
printf("Relatorio da Fase\n");
printf("Pontuacao: %d\n", this->pontos);
printf("Municao: %d\n", this->municao);
}
};
int main(){
int N; //Quantidade de Inimigos
int M; //Quantidade de Munição
scanf("%d %d", &N, &M);
Fase fase = Fase(N, M);
fase.inicializar_inimigos();
int T; //Quantidade de Tentativas
scanf("%d", &T);
fase.jogar(T);
fase.imprimir_relatorio();
}
```
#### Entrada
A entrada consiste de múltiplas linhas.
A primeira linha contém um inteiro $N$ e $M$ representando a quantidade de inimigos e a quantidade de munição disponível na fase. As próximas $N$ linhas contém um par de números inteiros $x_i$, $y_i$ representando a posição do inimigo $i$.
A próxima linha contém um inteiro $T$. As $T$ linhas seguintes contém um par de inteiros $x_j$, $y_j$ indicando a posição que o laser será disparado (caso haja munição suficiente) na tentativa $j$.
#### Saída
A saída da exercício é composta por 3 linhas, geradas automaticamente pelo método _imprimir_relatorio_.
#### Restrições
* $1 \leq N, M, T \leq 100$
* $1 \leq x_i, y_i \leq 100$
* $1 \leq x_j, y_j \leq 100$ |
2,628 | 519 | O Tabuleiro Esburacado | Médio | Basicos | 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$, o número de movimentos do passeio. A segunda linha contém $N$ inteiros $M_1, M_2, \ldots, M_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.
#### Restrições
* $1 \leq N \leq 100$
* $1 \leq M_I \leq 8$, para $I = 1, 2, \ldots , N$ |
2,629 | 1600 | Bitaro e IOI | Fácil | Basicos | Dado uma string $S$ de comprimento $N$, onde cada letra de $S$ é 'B', 'I', 'T', 'A', 'R', ou 'O'.
Determine se existe uma "IOI" em uma subsequência (não necessariamente contínua) da string $S$. Ou seja, determine se existe uma sequência (i,j,k) de três inteiros que satisfaçam as seguintes condições.
* $1 \leq i < j < k \leq N$.
* A i-ésima letra de $S$ é 'I'.
* A j-ésima letra de $S$ é 'O'.
* A k-ésima letra de $S$ é 'I'.
#### Entrada
A entrada é dada pela entrada padrão na seguinte forma
$N$
$S$
#### Saída
Imprima "Yes" se houver uma "IOI" numa substring da string "S", e "No" caso contrário.
#### Restrições
* $1 \leq N \leq 100$.
* $S$ é uma string de comprimento $N$.
* Cada letra de $S$ é 'B', 'I', 'T', 'A', 'R', ou 'O'. |
2,630 | 1601 | Split | Fácil | Basicos | É dada uma sequência $A = (A_1, A_2, ..., A_N)$ . Os valores da sequência $A$ são todos diferentes.
Produza a soma de todos os valores antes do maior valor e a soma de todos os valores após o maior valor considerando que a sequência é dividida ao meio a partir do maior valor.
Ou seja, se $A_x$ for o maior valor da sequência $A$, a saída deve ser $A_1 + A_2 + ... + A_{x-1}$ e $A_{x+1} + A_{x+2} + ... +A_N$.
Observe que se não houver valor antes do maior valor, a soma dos valores antes do maior valor é 0.
Da mesma forma, se não houver valor após o maior valor, a soma dos valores após o maior valor é 0.
#### Entrada
A entrada é dada pela entrada padrão na seguinte forma
$N$
$A_1 \ A_2 \ ... \ A_N$
#### Saída
A saída consiste em duas linhas.
Na primeira linha, imprima a soma dos valores da sequência $A$ antes do maior valor.
Na segunda linha, imprimir a soma dos valores da sequência de números inteiros $A$ que estão após do maior valor.
#### Restrições
* $1 \leq N \leq 100$.
* $1 \leq A_i \leq 2000 \ (1 \leq i \leq N)$．
* $A_i ≠ A_j \ (1 \leq i < j \leq N)$． |
2,631 | 1469 | Iguais | Médio | Basicos |
O mais popular dos parques do estado do Acre, situado na capital Rio Branco, é o parque que foi nomeado em homenagem ao ambientalista Chico Mendes.
Sendo uma área de preservação ambiental, a natureza é bem conservada e pode ser apreciada em trilhas pelo meio da mata.
Há um parquinho com brinquedos ótimos para as crianças, além de um mini zoológico com algumas espécies protegidas.
Por sua grande popularidade, os comerciantes fazem sucesso vendendo artesanatos típicos da região.
Nas trilhas é possível ver pilhas de pedras pequenas com quantidades variadas e colocadas lado a lado. A uniformidade das pedras com as quais são formadas é tanta que surgiu um boato de que se você recolher $X$ pedras antes de fazer a trilha e conseguir distribuir *todas* entre as pilhas existentes de forma a torná-las iguais, ou seja, todas as pilhas com a mesma quantidade de pedras, você terá boa sorte.
Sabendo disso, faça um programa que dada a quantidade $X$ e os tamanhos das pilhas diga se é possível obter boa sorte.
#### Entrada
A primeira linha da entrada contém um inteiro $N$, a quantidade de pilhas encontradas na trilha.
A segunda linha contém $N$ inteiros $Ai$ separados por um espaço em branco. O $i$-ésimo inteiro dessa linha representa o número de pedras na $i$-ésima pilha.
A terceira linha da entrada contém o inteiro $X$, a quantidade de pedras que deseja distribuir entre as pilhas existentes.
#### Saída
A saída consiste de uma única linha contendo a mensagem "Boa Sorte" caso seja possível deixar todas as pilhas iguais, ou a mensagem "Sem Sorte", em caso contrário.
#### Restrições
* $1 \leq N \leq 10^{6}$
* $1 \leq Ai \leq 10^3$
* $0 \leq X \leq 10^9$
|
2,632 | 2354 | Seleção do quadrante | Muito Fácil | Basicos | Um problema comum em matemática é determinar em qual quadrante um determinado ponto se encontra. Existem quatro quadrantes, numerados de $1$ a $4$, conforme mostrado no diagrama abaixo:
Por exemplo, o ponto _A_, que possui coordenadas $(12, 5)$, está no quadrante $1$, já que ambos os seus valores de $x$ e $y$ são positivos, e o ponto _B_ está no quadrante $2$, pois seu valor de $x$ é negativo e seu valor de $y$ é positivo.
Sua tarefa é receber um ponto e determinar em qual quadrante ele se encontra. Você pode assumir que nem $x$ e nem $y$ possuirá valor igual a $0$.
#### Entrada
A primeira linha da entrada contém o número inteiro $x \ (−1000 \leq x \leq 1000; \ x ≠ 0)$. A segunda linha da entrada contém o número inteiro $y \ (−1000 \leq y \leq 1000; \ y ≠ 0)$.
#### Saída
Imprima o número do quadrante ($1, \ 2, \ 3$ ou $4$) para o ponto $(x, y)$ |
2,633 | 1604 | Comparação | Fácil | Basicos | Uma sequência de números inteiros $A = (A_1, A_2, ..., A_N)$ de comprimento $N$ e uma sequência de números inteiros $B = (B_1, B_2, ..., B_M)$ de comprimento $M$ são dadas.
Encontre o número de pares $(i,j)$ de dois inteiros que satisfaçam todas as seguintes condições.
* $1 \leq i \leq N$.
* $1 \leq j \leq M$.
* $A_i \leq B_j$.
#### Entrada
A entrada é dada pela entrada padrão na seguinte forma
$N \ M$
$A_1 \ A_2 \ ... \ A_N$
$B_1 \ B_2 \ ... \ B_M$
#### Saída
Imprima o número de quantos são os pares $(i,j)$ de tal forma que $A_i \leq B_j$.
#### Restrições
* $1 \leq N \leq 100$.
* $1 \leq M \leq 100$.
* $1 \leq A_i \leq 2000 \ (1 \leq i \leq N)$．
* $1 \leq B_j \leq 2000 \ (1 \leq j \leq M)$．
|
2,634 | 1916 | Festa dos Cupcakes | Fácil | Basicos | Uma caixa normal de cupcakes comporta 8 cupcakes, enquanto uma pequena caixa comporta 3 cupcakes. Há 28 alunos em uma classe e um total de pelo menos 28 cupcakes. Seu trabalho é determinar quantos cupcakes sobrarão se cada aluno receber um cupcake.
#### Entrada
A entrada consiste em duas linhas.
* A primeira linha contém um número inteiro $R \ \ge \ 0$, representando o número de caixas normais.
* A segunda linha contém um número inteiro $S \ \ge \ 0$, representando o número de caixas pequenas.
#### Saída
Imprima o número de cupcakes que vão sobrar.
##### Explicação Entrada/saída de Exemplo 1:
O número total de cupcakes é 2 * 8 + 5 * 3, o que equivale a 31. Como há 28 alunos, sobram 3 cupcakes.
##### Explicação Entrada/Saída de Exemplo 2:
O número total de cupcakes é 2 * 8 + 4 * 3, o que equivale a 28. Como há 28 alunos, não sobram cupcakes. |
2,635 | 1255 | A corda (The string) | Nível Desconhecido | Basicos | Reluew e Markinhos, estudantes da cidade de Terra Uber desejam fazer uma festa surpresa virtual para Leirbag. Para isso, eles devem enviar mensagens entre si de forma que Leirbag não descubra que haverá a festa virtual.
Para que a mensagem seja lida corretamente, é necessário que verifique os nomes dos estudantes (Reluew e Markinhos).
Reluew e Markinhos sabem que você é estudante do UberHub Code Club e por isso vieram pedir sua ajuda para resolver este problema.
Um exemplo de funcionamento do programa seria: a string "UberHubCodeClub" movendo 3 posições a mais ficaria: "XehuKxeFrghFoxe".
### Tabela Ascii:
#### Entrada
A primeira linha de entrada consiste na leitura de dois nomes ($nome1$ e $nome2$) separados por espaço. A segunda linha consiste na $N$ quantidade de posições a serem deslocadas. Por fim, a terceira linha consiste na entrada da palavra ($palavra$) a ser descodificada.
#### Saída
A saída consiste em uma linha contendo a frase descodificada, caso o nome dos estudantes estejam corretos. Caso contrário, mostre a mensagem "Nao eh possivel descriptografar!".
#### Restrições
* $1 \leq nome1 \leq 50$
* $1 \leq nome2 \leq 50$
* $1 \leq N \leq 10$
* $1 \leq palavra \leq 50$
|
2,636 | 1597 | JOI Sort | Fácil | Basicos | Você receberá uma string $S$ de comprimento $N$, onde cada letra de $S$ é 'J', 'O' ou 'I'.
Você quer reorganizar as letras de $S$ para que elas satisfaçam as seguintes condições.
* Para cada par de letras 'J' e 'O', 'J' esta antes de 'O'.
* Para todos os pares da letra 'O' e da letra 'I', a letra 'O' está antes da letra 'I'.
* Para todos os pares da letra 'J' e da letra 'I', 'J' esta antes de 'I'.
Dada uma string $S$, escreva um programa para imprimir uma string na qual os caracteres de $S$ sejam reordenados para satisfazer as condições acima.
#### Entrada
A entrada é dada pela entrada padrão na seguinte forma
$N$
$S$
#### Saída
Imprima uma string no qual as letras de $S$ são reordenadas para satisfazer as condições.
#### Restrições
* $1 \leq N \leq 100$.
* $S$ é uma string de comprimento $N$.
* Cada letra em $S$ é uma de 'J', 'O' ou 'I'. |
2,637 | 593 | Avião | Médio | Basicos | Su Zuki é um empresário japonês acostumado a fazer viagens de avião, sempre na classe econômica, e quer saber qual seu assento com base no novo sistema da companhia aérea.
Todos os aviões contém uma classe executiva e uma econômica, de forma que as primeiras fileiras do avião pertencem à classe executiva e as restantes à classe econômica.
Cada assento do avião é indicado por um número correspondente a sua fileira e por uma letra que indica a sua posição na fileira, sendo A a posição mais à esquerda da fileira, B a posição à direita do assento A, C o assento à direita do assento B, e assim por diante, seguindo o alfabeto de 26 letras. Por exemplo, a assento 9B está localizado na nona fileira, logo à direita do assento 9A. A figura abaixo mostra a numeração utilizada em um avião com nove fileiras de três assentos cada.
A companhia aérea adotou, para a classe econômica, um sistema no qual o bilhete indica a posição do passageiro na fila de embarque e não seu assento no vôo. A fila de embarque contém apenas passageiros da classe econômica. Su Zuki descobriu que o primeiro passageiro da fila de embarque deve sempre sentar-se no assento localizado na primeira fileira da classe econômica, posição A. O segundo passageiro deve sentar-se nesta mesma fileira, posição B, e assim por diante, até que todos os assentos dessa fileira estejam ocupados. Esse processo é repetido a cada fileira da classe econômica, até que acabem os assentos desta classe ou todos os passageiros da fila já tenham embarcado.
Caso a classe econômica já esteja lotada e ainda haja passageiros na fila, esses passageiros embarcarão somente no próximo vôo.
Como viajante frequente, Su Zuki conhece bem os diversos modelos de aviões e é capaz de dizer o número total de fileiras no avião, o número de posições por fileira, e a partir de que fileira começa a classe econômica. Com base nessas informações, ele pediu a sua ajuda para descobrir, a partir de sua posição na fila, se ele tem assento garantido neste vôo e, caso tenha, qual seu assento.
#### Entrada
A entrada contém um único teste, a ser lido da entrada padrão. O teste contém uma linha com quatro inteiros $F$, $C$, $E$, $B$ indicando, respectivamente, o número total de fileiras no avião, o número de posições por fileira, o número da primeira fileira da classe econômica e a posição na fila de embarque do Sr. Zuki.
#### Saída
Seu programa deve imprimir, na saída padrão, uma única linha, contendo um inteiro e uma letra maiúscula, indicando a fileira e a posição em que o Su Zuki irá sentar-se, ou a frase “PROXIMO VOO” (em maiúsculas e sem acentos) caso não haja assentos suficientes para o Sr. Zuki no vôo.
#### Restriçoes
* $2 \leq F \leq 1000$
* $1 \leq C \leq 26$
* $1 \leq E \leq F$
* $2 \leq B \leq 50000$ |
2,638 | 2321 | Contas a Pagar | Médio | Basicos | Vô João está aposentado, tem boa saúde, mas a vida não está fácil. Todo mês é um sufoco para conseguir pagar as contas! Ainda bem que ele é muito amigo dos donos das lojas do bairro, e eles permitem que ele fique devendo.
Depois de pagar aluguel, conta de luz, conta de água, conta do telefone celular e conta do mercado, Vô João ainda tem que pagar as contas do Açougue, da Farmácia e da Padaria.
Dados o valor que Vô João tem disponível e o valor das contas do Açougue, Farmácia e Padaria, escreva um programa para determinar quantas contas, entre as três que ainda não foram pagas, Vô João consegue pagar.
#### Entrada
A entrada contém quatro linhas. A primeira linha contém um inteiro $V$ , o valor que Vô João tem disponível para pagar as contas. A segunda linha contém um inteiro $A$, o valor da conta do Açougue.
A terceira linha contém um inteiro $F,$ o valor da conta da Farmácia. A quarta linha contém um inteiro P, o valor da conta da Padaria.
#### Saída
Seu programa deve produzir uma única linha, contendo um único inteiro, o maior número de contas que Vô João consegue pagar.
#### Restrições
* $0 ≤ V ≤ 2 000$
* $1 ≤ A ≤ 1 000$
* $1 ≤ F ≤ 1 000$
* $1 ≤ P ≤ 1 000$
#### Informações sobre a pontuação
* A tarefa vale 100 pontos. |
2,639 | 625 | Bafo | Fácil | Basicos | Álbuns de figurinhas - sejam de times de futebol, princesas ou super-heróis - têm marcado gerações de crianças e adolescentes. Conseguir completar um álbum é uma tarefa muitas vezes árdua, envolvendo negociações com colegas para a troca de figurinhas. Mas a existência das figurinhas propicia uma outra brincadeira, que foi muito popular entre crianças no século passado: o jogo de bater figurinhas (o famoso “Bafo”). O jogo é muito simples, mas divertido (e muito competitivo). No inicio de uma partida, cada criança coloca em uma pilha um certo número de figurinhas. Uma partida é composta de rodadas; a cada rodada as crianças batem com a mão sobre a pilha de figurinhas, tentando virá-las com o vácuo formado pelo movimento da mão. As crianças jogam em turnos, até que a pilha de figurinhas esteja vazia. Ganha a partida a criança que conseguir virar mais figurinhas. Aldo e Beto estão jogando bafo com todas as suas figurinhas e pediram sua ajuda para calcular quem é o vencedor.
Você deve escrever um programa que, dada a quantidade de figurinhas que Aldo e Beto viraram em cada rodada, determine qual dos dois é o vencedor.
#### Entrada
A entrada é composta de vários casos de teste, cada um correspondendo a uma partida entre Aldo e Beto. A primeira linha de um caso de teste contém um número inteiro $R$ que indica quantas rodadas ocorreram na partida. Cada uma das $R$ linhas seguintes contém dois inteiros, $A$ e $B$, que correspondem, respectivamente, ao número de figurinhas que Aldo e Beto conseguiram virar naquela rodada. Em todos os casos de teste há um único vencedor (ou seja, não ocorre empate). O final da entrada é indicado por $R = 0$.
#### Saída
Para cada caso de teste da entrada, seu programa deve produzir três linhas na saída. A primeira linha deve conter um identificador do caso de teste, no formato “Teste n”, onde $n$ é numerado sequencialmente a partir de 1. A segunda linha deve conter o nome do vencedor (Aldo ou Beto). A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
#### Restrições
* $1 \leq R \leq 1000$ ($R = 0$ apenas para indicar o final da entrada)
* $0 \leq A \leq 100$
* $0 \leq B \leq 100$ |
2,640 | 1821 | Dia Especial | Fácil | Basicos | O dia 18 de Fevereiro é uma data especial para a CCC este ano.
Escreva um programa que peça ao usuário um mês e um dia numéricos e depois determine se essa data ocorre antes, depois, ou no dia 18 de Fevereiro.
Se a data ocorrer antes do dia 18 de Fevereiro, imprima a palavra `Before`. Se a data ocorrer depois do dia 18 de Fevereiro, imprima a palavra `After`. Se a data for 18 de Fevereiro, imprima a palavra `Special`.
#### Entrada
A entrada consiste em dois números inteiros em linhas separadas. Esses números inteiros representam uma data em 2015.
A primeira linha conterá o mês, que será um número inteiro no intervalo de 1 (indicando Janeiro) a 12 (indicando Dezembro).
A segunda linha conterá o dia do mês, que será um número inteiro no intervalo de 1 a 31. Pode-se assumir que o dia do mês será válido para o mês em questão.
#### Saída
Imprima em uma única linha `Before`, `After` ou `Special`. |
2,641 | 608 | Monopólio | Médio | Basicos | Monopólio (conhecido no Brasil como Banco Imobiliário) é um dos jogos mais famosos do mundo, com 750 milhões de cópias vendidas. Durante o jogo, os jogadores podem comprar propriedades que estejam disponíveis, vendê-las para que elas voltem a ficar disponíveis, e cobrar aluguel pelo uso de uma determinada propriedade por outro jogador. O objetivo do jogo é acumular a maior quantidade de dinheiro possível.
O jogo é composto por um tabuleiro e um conjunto de cédulas de dinheiro. Três amigos, Dália, Elói e Félix, querem jogar uma partida de Monopólio, mas o irmãozinho menor de Dália escondeu as cédulas de dinheiro. Os três amigos decidiram jogar a partida assim mesmo, anotando em um papel todas as operações que ocorreram durante o jogo (compras, vendas e pagamentos de aluguéis). Assim que eles pararam de jogar, perceberam que levaria muito tempo para descobrir quanto dinheiro cada um acumulou. Eles então pediram sua ajuda para determinar esses valores.
Sua tarefa é escrever um programa que, a partir dos registros de jogadas realizados pelos três jogadores, determine a quantidade de dinheiro acumulada por cada um dos jogadores.
#### 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, $I$ e $N$ que indicam respectivamente as quantias de dinheiro que Dália, Elói e Félix possuem no inicio do jogo e o número de operações realizadas durante o jogo. Note que os três jogadores iniciam a partida com a mesma quantidade de dinheiro. Os jogadores são representados na entrada sempre pela letra inicial de seu nome (‘D’, ‘E’ ou ‘F’). As N linhas contém as operações ocorridas durante o jogo. Cada linha pode ter um dos formatos abaixo:
* Compra - a letra C, seguida da letra inicial de um jogador $J$ e de um inteiro $X$ que representa o valor gasto por $J$ na compra ($0 < X \leq 1000000$). Exemplo: ‘C D 1000’.
* Venda - a letra V, seguida da letra inicial de um jogador $J$ e de um inteiro $X$ que representa o valor recebido por $J$ na venda ($0 < X \leq 1000000$). Exemplo: ‘V E 200’.
* Aluguel - a letra A, seguida da letra inicial de um jogador $J$ que recebe o aluguel, da letra inicial do jogador $K$ que paga o aluguel e de um inteiro $X$ que representa o valor do aluguel ($J \neq K$ e $0 \leq X \leq 1000000$). Exemplo: ‘A F D 500’.
Os valores intermediários e totais acumulados por cada jogador estão entre 0 e 1000000.
#### Saída
Seu programa deve imprimir, na saida padrão, uma única linha composta de três inteiros que correspondem à quantidade de dinheiro acumulada por Dália, Elói e Félix, nesta ordem
#### Restrições
* $1 \leq I \leq 1000000$
* $1 \leq N \leq 10000$ |
2,642 | 1262 | Aglomeração no Busão | Nível Desconhecido | Basicos | Busonildo é motorista de ônibus e é muito preocupado com seus passageiros. Seu ônibus tem um formato quadrado e vários assentos disponíveis. Com a atual situação do Coronovírus, Busonildo está muito preocupado com os passageiros de seu ônibus, então gostaria de marcar com o número 2 (que no caso é seu número de azar) os assentos que estão perto dos assentos exclusivos para pessoas possivelmente infectadas (assentos marcados com o número 1). Para que seja uma viagem segura, você deve marcar com o número 2 todos os assentos em volta dos assentos exclusivos para pessoas possivelmente infectadas (assentos marcados com o número 1). Veja o exemplo abaixo. Observe que um assento que já é exclusivo não precisa ser marcado. Além disso, Busonildo garante que os assentos perto das janelas (os assentos das bordas) NUNCA irá ser exclusivos para pessoas possivelmente infectadas (assentos marcados com o número 1), mas pode ser interditado. Busonildo já tem que dirigir e cobrar as passagens, então precisa da sua ajuda para mostrar a configuração de assentos de uma forma que seu ônibus seja seguro para os passageiros.
#### Entrada
A entrada consiste de um valor inteiro, $N$ , que indica o tamanho de seu ônibus quadrado. Logo após, será feito a leitura de uma matriz $NXN$ representando a configuração inicial do ônibus com os assentos disponíveis (0) e exclusivos para pessoas possivelmente infectadas (1).
#### Saída
A saída consiste de uma matriz $NXN$ representando a configuração segura do ônibus com os assentos disponíveis (0), exclusivos para pessoas possivelmente infectadas (1) e os assentos interditados por medidas de segurança (2).
Não esqueça de imprimir o fim de linha após o resultado. Terão espaço após todos os números:
1_2_1_
2_2_2_
0_0_0_
#### Restrições
* $0 \leq N \leq 10$
|
2,643 | 1687 | Iccanobif | Fácil | Basicos | As sequências de Iccanobif são sequências onde cada termo é sempre igual a soma dos dois próximos subsequentes a eles. Exceto pelos dois últimos termos os quais são sempre iguais a 1.
Exemplo de uma sequência de Iccanobif com 10 termos: 55, 34, 21, 13, 8, 5, 3, 2, 1, 1.
Sua tarefa é, dado um valor inteiro, imprimir a sequência de Iccanobif de tamanho correspondente.
#### Entrada
A entrada consiste de um único inteiro $N \ (1 \ \leq \ N \ \leq \ 40)$ representando o tamanho da sequência de Iccanobif desejada.
#### Saída
A saída consiste de um única linha contendo os termos da sequência de Iccanobif de tamanho $N$ separados por um único espaço em branco. |
2,644 | 1603 | IOI String | Fácil | Basicos | Dada uma string $S$ de comprimento $N$ ímpar, onde cada letra de $S$ é uma letra maiúscula.
Uma string IOI é uma string que satisfaz todas as seguintes condições.
* O comprimento é um número ímpar.
* Cada letra é ou 'I' ou 'O', alternando entre as duas.
* O primeiro caractere é um 'I'.
Por exemplo, 'I', "IOI" e "IOIOIOI" são strings IOI, mas "JOI", "IIOOII" e "OIOIO" não são strings IOI.
Você pode repetir a seguinte operação zero ou mais vezes.
Escolha uma letra da string $S$ e mude-a para qualquer letra maiúscula que você desejar.
Encontre o número mínimo de operações necessárias para transformar a string $S$ em uma string IOI.
#### Entrada
A entrada é dada pela entrada padrão na seguinte forma
$N$
$S$
#### Saída
Imprimir o número mínimo de operações necessárias para transformar a string $S$ em uma string IOI.
#### Restrições
* $1 \leq N \leq 99.$
* $N$ é um número ímpar.
* $S$ é uma string de comprimento $N$.
* Toda letra de $S$ é uma letra maiúscula. |
2,645 | 1781 | Prova | Fácil | Basicos | A IOI fez três provas. Todos os resultados das provas são números inteiros entre 0 e 100.
A nota da IOI é determinada pela soma das duas notas mais altas das três provas.
Dadas as três notas $A$, $B$ e $C$ das provas, escreva um programa que imprima a soma das duas notas mais altas das três provas.
#### Entrada
A entrada é dada pela entrada padrão na seguinte forma
$A \ B \ C$
#### Saída
Some as duas notas mais altas das três provas e imprima o total em uma linha.
#### Restrições
* $0 \leq A \leq 100.$
* $0 \leq B \leq 100.$
* $0 \leq C \leq 100.$
* A entrada é composta somente por números inteiros.
|
2,646 | 2284 | Gatinhos Explosivos | Fácil | Basicos | Enzo e Caique estão jogando "Exploding Kittens" para passar o tempo. Nesse jogo, tem um baralho com algumas cartas de gatos explosivos. Caso um jogador pegue alguma dessas bombas, ele perde a sua carta de desarme - uma espécie de vida- ou, se ele não tiver essa carta especial, ele perde.
Antes de comprar uma carta do baralho, os jogadores podem utilizar os poderes das cartas da mão deles. Dentre eles, está o poder de ver o futuro. Esse poder permite que o jogador "espie" os três primeiros cartões. O Caique tem essa carta na mão e jogo ela nessa rodada.
Assim, ele consegue decidir o que é melhor fazer: se algum deles for de desarme -uma vida - e não estiver no topo, é melhor ele usar o poder de embaralhar para mudar as posições e conseguir comprar a vida. Comprar um desarme sempre é prioridade, mas ele também não quer comprar uma bomba. Por isso, se a carta do topo for uma bomba, ele pode usar o poder do pulo para pular a sua vez. Ou o jogador pode simplesmente comprar o cartão topo. Observe que, se existe a opção de comprar um desarme no topo, a melhor opção é comprar a carta do topo.
Dado os tipos das três cartas do topo do baralho, sendo a do topo a primeira e assim por diante, e dada que a estratégia do Caique é igual a descrita no parágrafo acima, diga qual é melhor ação que Caique pode fazer para ganhar do Enzo.
#### Entrada
A entrada contém 3 inteiros, indicando o tipo de cada uma das cartas: sendo o primeiro inteiro referente a do do topo e assim por diante.
Os tipos das cartas do baralho podem ser:
-1: bomba
1: desarme
0: outro poder
#### Saída
A saída deve conter um único inteiro, o qual indica qual é a melhor ação a ser feita pelo jogador.
As ações feitas pelos jogadores podem ser:
1- embaralhar, colocar o embaralhe no topo e comprar a nova primeira carta
2- pular a vez
3- comprar a carta do topo. |
2,647 | 1471 | Água Fervente | Fácil | Basicos | Ao nível do mar, a pressão atmosférica é de 100 kPa e a água começa a ferver a 100ºC. À medida que se vai acima do nível do mar, a pressão atmosférica diminui, e a água ferve a temperaturas mais baixas. Ao descer abaixo do nível do mar, a pressão atmosférica aumenta, e a água ferve a temperaturas mais elevadas. Uma fórmula que relaciona a pressão atmosférica com a temperatura a que a água começa a ferver é
$P = 5 \times B - 400$
onde $P$ é a pressão atmosférica medida em kPa, e $B$ é a temperatura a que a água começa a ferver medida em ºC.
Dada a temperatura a que a água começa a ferver, determine a pressão atmosférica. Determine também se está abaixo do nível do mar, ao nível do mar, ou acima do nível do mar.
_Observe que a ciência deste problema é correta em geral, mas os valores de 100ºC e 100 kPa são aproximados e a fórmula é uma simplificação da relação exata entre o ponto de ebulição da água e a pressão atmosférica._
#### Entrada
A entrada é uma linha contendo um número inteiro $B$ onde $B \geq 80$ e $B \leq 200$. Esse valor representa a temperatura em ºC em que a água começa a ferver.
#### Saída
A saída é de duas linhas. A primeira linha deve conter um número inteiro que é a pressão atmosférica medida em kPa. A segunda linha deve conter um inteiro -1, 0, ou 1. Este número inteiro representa se está abaixo do nível do mar, ao nível do mar, ou acima do nível do mar, respectivamente.
#### Explicação da Saída para o Caso de Teste 1
Quando $B =$ 99, podemos substituir na fórmula e obter $P =$ 5 $\times$ 99 $-$ 400 que é igual a 95. Uma vez que 95 kPa é inferior a 100 kPa, se está acima do nível do mar.
#### Explicação da Saída para o Caso de Teste 2
Quando $B =$ 102, podemos substituir na fórmula e obter $P =$ 5 $\times$ 102 $-$ 400, o que equivale a 110. Uma vez que 110 kPa é superior a 100 kPa, se está abaixo do nível do mar. |
2,648 | 1414 | Epidemiologia | Fácil | Basicos | Pessoas que estudam epidemiologia usam modelos para analisar a propagação de doenças. Neste problema, usamos um modelo simples.
Quando uma pessoa tem uma doença, ela infecta exatamente $R$ outras pessoas, mas apenas no dia seguinte. Nenhuma pessoa é infectada mais de uma vez. Queremos determinar quando um total de mais de $P$ pessoas tiveram a doença.
*Este problema foi projetado antes do atual surto de coronavírus e reconhecemos a angústia que está sendo vivida por muitas pessoas no mundo todo por causa desta e de outras doenças. Esperamos que a inclusão deste problema neste momento destaque os papéis importantes que a ciência da computação e a matemática desempenham na solução de problemas do mundo real.*
#### Entrada
Existem três linhas de entrada. Cada linha contém um número inteiro positivo. A primeira linha contém o valor de $P$. A segunda linha contém $N$, o número de pessoas que têm a doença no Dia 0. A terceira linha contém o valor de $R$. Saiba que $P \ \leq \ 10^7$ e $N \ \leq \ P$ e $R \ \leq \ 10$.
#### Resultado
Imprima o número do primeiro dia em que o número total de pessoas que tiveram a doença é maior que $P$. |
2,649 | 2010 | Ponteiro das Horas | Fácil | Basicos | Aoi, um estudante da JOI High School, tem um relógio analógico. O relógio tem 12 graduações ao longo da sua circunferência, numeradas de 1 a 12 na ordem do sentido horário.
O ponteiro curto do relógio roda no sentido horário, avançando um tique em uma hora.
O ponteiro acaba de apontar para um tique. O número desta escala é $A$.
Imprima o número do tique que o ponteiro curto apontará quando tiverem decorrido exatamente $B$ horas a partir deste momento.
#### Entrada
A entrada é fornecida pela entrada padrão no seguinte formato.
$A$
$B$
#### Saída
Imprima o número da escala para a qual o ponteiro curto aponta, quando exatamente $B$ horas decorreram desde que o ponteiro curto apontou para $A$.
#### Restrições
* $1 \leq A \leq 12$.
* $1 \leq B \leq 100$.
* Todos os valores de entrada são números inteiros.
##### Explicação da Amostra de Entrada/Saída 1:
Após o ponteiro curto apontar para 9, a escala muda da seguinte maneira:
* Quando tiver decorrido exatamente uma hora, o ponteiro curto apontará para 10.
* Quando tiverem decorrido exatamente 2 horas, o ponteiro curto apontará para 11.
* Quando tiverem decorrido exatamente 3 horas, o ponteiro curto apontará para 12.
* Quando tiverem decorrido exatamente 4 horas, o ponteiro curto apontará para 1.
* Quando tiverem decorrido exatamente 5 horas, o ponteiro curto apontará para 2.
Portanto, a saída deve ser '2'. |
2,650 | 1472 | Leilão Silencioso | Fácil | Basicos | Uma instituição de caridade está fazendo um leilão silencioso onde as pessoas fazem lances sobre um prêmio sem conhecerem a oferta de mais ninguém. Cada lance inclui o nome de uma pessoa e o valor do seu lance. Após o leilão silencioso ter terminado, o vencedor é a pessoa que fez o lance mais alto. Se houver um empate, ganha a pessoa cujo lance foi colocado em primeiro lugar. A sua função é determinar o vencedor do leilão silencioso.
#### Entrada
A primeira linha de entrada contém um número inteiro positivo $N$, onde $1 \leq N \leq 100$, representando o número de lances recolhidos no leilão silencioso. Cada um dos próximos $N$ pares de linhas contém o nome de uma pessoa numa linha, e o valor da sua oferta, em dólares, na linha seguinte. Cada lance é um número inteiro positivo inferior a 2000. A ordem da entrada é a ordem em que os lances foram feitos.
#### Saída
Indique o nome da pessoa que ganhou o leilão silencioso.
#### Explicação da Saída para o Caso de Teste 1
O lance mais alto foi de 500 e foi colocado pela Suzanne. Suzanne ganha o leilão silencioso.
#### Explicação da Saída para o Caso de Teste 2
O lance mais alto colocado foi de 20 e foi colocado tanto por Ijeoma como por Goor. Uma vez que a oferta de Ijeoma foi colocada primeiro, Ijeoma ganha o leilão silencioso. |
2,651 | 632 | TV da Vovó | Médio | Basicos | A vovó tem um televisor muito antigo, que ultimamente está exibindo um defeito incômodo: a imagem aparece ‘deslocada’ (para cima ou para baixo, para o lado direito ou para o lado esquerdo). Quando a imagem está deslocada para cima, a parte da imagem que deixa de ser vista na parte superior reaparece na parte de baixo da tela. Da mesma forma, quando a imagem está deslocada a direita, a parte da imagem que deixa de ser vista à direita reaparece na tela do lado esquerdo.
A imagem do televisor pode ser vista como uma matriz de pontos organizados em linhas e colunas. Para consertar o televisor da vovó, você pode ajustar a imagem introduzindo uma série de ‘comandos de correção’ em um painel de ajuste. Cada comando de correção desloca a imagem de um certo número de linhas (para cima ou para baixo) e um certo número de colunas (para a direita ou para a esquerda).
Dada uma matriz que representa uma imagem defeituosa e uma série de comandos de correção, seu programa deve calcular a matriz que representa a imagem resultante após todos os comandos terem sido aplicados sequencialmente.
#### Entrada
A entrada possui vários conjuntos de teste. Cada conjunto de teste inicia com a descrição da matriz que representa a imagem do televisor. A primeira linha contém dois inteiros $M$ e $N$ representando o número de linhas e o número de colunas da matriz. As $M$ linhas seguintes da entrada contém cada uma $N$ inteiros, descrevendo o valor de cada ponto da imagem. Após a descrição da imagem, segue-se a descrição dos comandos de correção. Cada comando de correção é descrito em uma linha contendo dois inteiros $X$ e $Y$. O valor de $X$ representa o deslocamento na direção horizontal (valor positivo representa deslocamento para a direita, valor negativo para a esquerda), e o valor de $Y$ representa o deslocamento da direção vertical (valor positivo para cima, valor negativo para baixo). O final da lista de comandos é indicado por $X = Y = 0$, e o final da entrada é indicado por $M = N = 0$.
#### Saída
Para cada conjunto de teste, o seu programa deve produzir uma imagem na saída. A primeira linha da saída deve conter um identificador do conjunto de teste, no formato “Teste n”, onde $n$ é numerado sequencialmente a partir de 1. A seguir deve aparecer a matriz que representa a imagem resultante, no mesmo formato da imagem de entrada. Ou seja, as $N$ linhas seguintes devem conter cada uma $M$ inteiros que representam os pixels da imagem. Após a imagem deixe uma linha em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
#### Restrições
* $0 \leq N \leq 1000$ ($N = 0$ apenas para indicar o final da entrada)
* $0 \leq M \leq 1000$ ($M = 0$ apenas para indicar o final da entrada)
* $0 \leq X \leq 1000$
* $0 \leq Y \leq 1000$
* $0 \leq$ número de comandos de correção em cada conjunto de teste $\leq 1000$
|
2,652 | 1957 | Multiplicação de números | Muito Fácil | Basicos | Reluew ficou tão chateado de não poder usar sua calculadora no Jogo do Reluew que ele acabou quebrando-a. Ela estava arredondando as casas decimais, e isso o deixou enfurecido. Pobre calculadora...
Acontece que agora Reluew está sem condições de treinar multiplicações. Ele adora ficar multiplicando dois números de cabeça, mas sem a calculadora ele não consegue verificar se acertou ou não. Então ele pediu sua ajuda.
Ele já está tão chateado, será que você não poderia ajudá-lo? Faça um programa que leia dois números inteiros e imprima o resultado da sua multiplicação.
#### Entrada
A entrada possui apenas um caso de teste. A única linha de entrada possui dois inteiros $A$ e $B (1 ≤ A, B ≤ 10^5)$.
#### Saída
Imprima um único inteiro $C$ na tela, que é o resultado de $A * B$.
|
2,653 | 2160 | Dia do Bolo | Fácil | Basicos | Ana é dona da confeitaria mais famosa do país da Nlogônia, chamada Gostosuras Gulosas. A confeitaria vende vários tipos de doces: brigadeiro, trufa, pudim, rocambole, bolo, torta, beijinho, sequilho, muffin, pavê, palha italiana, bombom, mousse, cocada, cupcake, paçoca... Provavelmente demoraria muito para listar todos aqui!
O “Dia do Bolo” é um feriado muito importante na Nlogônia. Segundo a tradição, comer pelo menos um pedaço de bolo nesse dia traz boa sorte para o resto do ano. Naturalmente, a Gostosuras Gulosas recebe muitas encomendas de bolo para esse maravilhoso feriado, podendo ser para pequenas reuniões de família, para grandes festas feitas pela prefeitura de alguma cidade ou até mesmo para quem deseja celebrar sozinho.
No entanto, todos os seus clientes querem garantir que estão pedindo uma quantidade suficiente de bolo para a suas festas, de modo a garantir que todos os seus convidados ganhem pelo menos uma fatia. Afinal, todos que participam de festas no Dia do Bolo desejam comer bolo para ter sorte durante o ano. Para tanto, Ana desenvolveu um sistema de pedidos: quando o cliente encomenda um bolo, ele deve informar o peso do bolo em **quilos**, o número de convidados da festa e o peso em **gramas** que cada fatia do bolo deve ter.
Quando a confeitaria ainda era pequena, Ana conseguia fazer todas as contas com uma calculadora e determinar se a encomenda possui bolo suficiente para todos os convidados. Com o grande aumento do volume de pedidos, ela contratou você para escrever um programa para ajudá-la. Dadas as informações que o cliente passa para Ana, seu programa deve imprimir a letra “S” (sem aspas) se é possível distribuir o bolo para todos os convidados respeitando o peso das fatias ou a letra “N” (sem aspas), caso contrário.
#### Entrada
A primeira linha da entrada contém um número fracionário (ponto flutuante de precisão simples) $B$, indicando o peso do bolo em quilos. A segunda linha da entrada contém um número inteiro $C$, o número de convidados. A terceira linha da entrada contém um número inteiro $F$, o peso em gramas que cada fatia deve ter.
#### Saída
Sua saída deve conter o caractere “S” (sem aspas) se é possível distribuir o bolo para todos os convidados respeitando o peso das fatias ou o caractere “N” (sem aspas), caso contrário.
#### Restrições
* $0.1 ≤ B ≤ 10^4$
* $1 ≤ C ≤ 10^5$
* $100 ≤ F ≤ 300$
#### Informações sobre a pontuação
* Em um conjunto de casos de teste somando 30 pontos, $C = 1$.
* Em um conjunto de casos de teste somando 70 pontos, nenhuma restrição adicional.
|
2,654 | 860 | O Devorador de Mentes | Nível Desconhecido | Basicos | No verão de 1985, uma operação secreta Russa conseguiu reabrir o portal para o Mundo Invertido, fechado anteriormente pela Eleven. O objetivo era tentar explorar os poderes sobrenaturais para obter vantagem contra os Estados Unidos, na Guerra Fria. Nessa brecha, o Devorador de Mentes conseguiu restabelecer uma conexão telepática com um pedaço de seu corpo que ficou largado na Brimborn Steel Works. Assim, ele começou por infectar os ratos que viviam pelo subterrâneo da área, que explodiam em biomassa. Com uma grande quantidade dessa biomassa, ele conseguiu formar um corpo que podia influenciar novamente nos acontecimentos em Hawkings.
O grande problema é que, agora, o Devorador de Mentes está conseguindo utilizar seu poder para influenciar e infectar os humanos. Seu ataque é iniciado atraindo uma pessoa para o porão da fábrica onde está instalado e, assim, infectá-la para ter controle sob ela. A partir disso, ele pode influenciar essas pessoas para raptarem outras e levá-las até ele, e criarem um exército de infectados.
Para salvar a cidade novamente, os garotos precisarão descobrir quem foi (ou foram) os infectados diretamente pelo Devorador de Mentes, para, assim, chegar direto na origem. Isto é, encontrar aqueles que não foram raptados por uma outra pessoa, mas diretamente pelo próprio monstro.
Sabendo disso, foi feito um trabalho minucioso para organizar as cadeias de transmissão e seu trabalho é utilizá-las para encontrar os infectados iniciais. Por exemplo, o primeiro alvo de ataque do Devorador de Mentes foi Billy, que raptou a sua companheira salva-vidas Heather, e essa raptou seu pai Tom. Este, por sua vez capturou Bruce, que em seguida capturou outras pessoas do posto de Hawkings. De forma separada, o Devorador de Mentes fez outro refém direto, Doris Dricoll, utilizando o rato que ela havia prendido numa gaiola. Ela, por sua vez continuou a cadeia, capturando outras pessoas para serem infectadas. Estas cadeias poderiam estar organizadas da seguinte maneira:
Como esperado, dessas cadeias de transmissão concluímos que existem dois infectados originais, Billy e Doris. Sua tarefa é descobrir quem são essas pessoas, podendo ser apenas uma única ou múltiplas.
#### Entrada
A primeira linha da entrada consiste de dois números inteiros $N$ e $C$, respectivamente, o total de pessoas infectadas e a quantidade de cadeias de transmissão. Para uma organização melhor, as pessoas serão identificadas por números inteiros de *$1$ a $N$*. As próximas $C$ linhas definirão cada cadeia de transmissão. A linha começa com o inteiro $P$, que é o identificador da pessoa que inicia a cadeia. Em seguida, terá o inteiro $I$, o total de pessoas nessa cadeia (sem contar a que inicia). Seguem, então, $I$ inteiros $X_i$, identificando cada pessoa da cadeia de transmissão.
É certo que cada pessoa pode ser infectada indiretamente, pela captura de outra, apenas uma única vez. Portanto, como no exemplo, Tom pode ter sido infectado e depois iniciar uma nova cadeia, mas não irá aparecer na cadeia de alguém posteriormente.
#### Saída
Serão esperadas $K$ linhas, cada uma com um identificador de um infectado inicial distinto, para um total de $K$ indivíduos. A sequência de identificadores deve ser enviada, obrigatoriamente, em ordem crescente dos seus números. Se houver apenas um único infectado inicial ($K = 1$), a saída será constituída de apenas uma linha.
#### Restrições
* $2 \leq N \leq 1000$
* $1 \leq C \leq N-1$
* $1 \leq P \leq N$
* $1 \leq I \leq N-1$
* $1 \leq X_i \leq N$ para $1 \leq i \leq I$
<br>
<br>
<center>Problema adaptado da Olimpíada Brasileira de Informática</center>
<br>
|
2,655 | 636 | Estágio | Médio | Basicos | Você conseguiu um estágio para trabalhar como programador na secretaria da sua escola. Como primeira tarefa, Dona Vilma, a coordenadora, solicitou que você aprimore um programa que foi desenvolvido pelo estagiário anterior. Esse programa tem como entrada uma lista de nomes e de médias finais dos alunos de uma turma, e determina o aluno com a maior média na turma. Dona Vilma pretende utilizar o programa para premiar o melhor aluno de cada turma da escola. O programa desenvolvido pelo estagiário anterior encontra-se a seguir.
**Programa em C**
```c
#include <stdio.h>
#define MAX_ALUNOS 1000
int main()
{
int i, indice_melhor, n;
int turma=1;
struct
{
int codigo, media;
} alunos[MAX_ALUNOS];
/* le numero de alunos da primeira turma */
scanf("%d", &n);
while (n > 0)
{
/* le dados dos alunos */
for (i = 0; i < n; i++)
scanf("%d %d", &alunos[i].codigo, &alunos[i].media);
/* procura aluno de maior media */
indice_melhor = 0;
for (i = 1; i < n; i++)
if (alunos[i].media > alunos[indice_melhor].media)
indice_melhor = i;
/* escreve resposta */
printf("Turma %d\n%d\n\n", turma++, alunos[indice_melhor].codigo);
/* le numero de alunos da proxima turma */
scanf("%d", &n);
}
return 0;
}
```
**Programa em C++**
```cpp
#include <iostream>
const int MAX_ALUNOS = 1000;
int main()
{
int i, indice_melhor, n;
int turma=1;
struct
{
int codigo, media;
} alunos[MAX_ALUNOS];
// le numero de alunos da primeira turma
cin >> n;
while (n > 0)
{
// le dados dos alunos
for (i = 0; i < n; i++)
cin >> alunos[i].codigo >> alunos[i].media;
// procura aluno de maior media
indice_melhor = 0;
for (i = 1; i < n; i++)
if (alunos[i].media > alunos[indice_melhor].media)
indice_melhor = i;
// escreve resposta
cout << "Turma " << turma++ << "\n";
cout << alunos[indice_melhor].codigo << "\n\n";
// le numero de alunos da proxima turma
cin >> n;
}
return 0;
}
```
Como você pode verificar, o programa na forma atual tem uma imperfeição: no caso de haver alunos empatados com a melhor média na turma, ele imprime apenas o primeiro aluno que aparece na lista.
Dona Vilma deseja que você altere o programa para que ele produza uma lista com todos os alunos da turma que obtiveram a maior média, e não apenas um deles. Você consegue ajudá-la nesta tarefa?
#### Entrada
A entrada é constituída de vários conjuntos de teste, representando várias turmas. A primeira linha de um conjunto de testes contém um número inteiro $N$ que indica o total de alunos na turma. As $N$ linhas seguintes contêm, cada uma, um par de números inteiros $C$ e $M$, indicando respectivamente o código e a média de um aluno. O final da entrada é indicado por uma turma com $N = 0$.
#### Saída
Para cada turma da entrada seu programa deve produzir três linhas na saída. A primeira linha deve conter um identificador do conjunto de teste, no formato “Turma n”, onde $n$ é numerado a partir de 1. A segunda linha deve conter os códigos dos alunos que obtiveram a maior média da turma. Os códigos dos alunos devem aparecer na mesma ordem da entrada, e cada um deve ser seguido de um espaço em branco. A terceira linha deve ser deixada em branco. O formato mostrado no exemplo de saída abaixo deve ser seguido rigorosamente.
#### Restrições
* $0 \leq N \leq 1000$ ($N = 0$ apenas para indicar o fim da entrada)
* $1 \leq C \leq 20000$
* $0 \leq M \leq 100$
|
2,656 | 1975 | Tempos Triangulares | Fácil | Basicos | Você tem dificuldade para lembrar qual tipo de triângulo é qual. Você escreve um programa para ajudar.
Seu programa lê em três ângulos (em graus).
* Se os três ângulos forem 60, imprima _Equilateral_.
* Se os três ângulos somarem 180 e exatamente dois dos ângulos forem os mesmos, imprima _Isosceles_.
* Se os três ângulos somarem até 180 e nenhum dos dois ângulos for igual, imprima _Scalene_.
* Se os três ângulos não somarem até 180, produzir _Error_.
#### Entrada
A entrada consiste em três números inteiros, cada um em uma linha separada.
Cada número inteiro será maior que 0 e menor que 180.
#### Saída
Exatamente um de _Equilateral_, _Isosceles_, _Scalene_ ou _Error_ será impresso em uma linha. |
2,657 | 1917 | Classificação de Fergusonball | Fácil | Basicos | Os jogadores de Fergusonball recebem uma classificação por estrelas com base no número de pontos que marcam e no número de faltas que cometem. Especificamente, eles recebem 5 estrelas por cada ponto marcado, e 3 estrelas são tiradas por cada falta cometida. Para todo jogador, o número de pontos que eles marcam é maior do que o número de faltas que cometem.
Seu trabalho é determinar quantos jogadores de uma equipe têm uma pontuação superior a 40 estrelas. Você também precisa determinar se o time é considerado um time de ouro, o que significa que todos os jogadores têm uma classificação de estrelas maior do que 40.
#### Entrada
A primeira linha de entrada consiste em um inteiro positivo de $N$ representando o número total de jogadores da equipe. Isto é seguido por um par de linhas consecutivas para cada jogador. A primeira linha em um par é o número de pontos que o jogador marcou. A segunda linha em um par é o número de faltas que o jogador cometeu. Tanto o número de pontos quanto o número de faltas, são inteiros não negativos.
#### Saída
Imprima o número de jogadores que têm uma classificação de estrelas superior a 40, imediatamente seguido por um sinal de mais, se a equipe for considerada uma equipe de ouro.
##### Explicação da Entrada/Saída de Exemplo 1:
A imagem mostra a classificação por estrelas de cada jogador. Por exemplo, a classificação em estrelas para o primeiro jogador é $12×5-4×3 = 48$. Todos os três jogadores têm uma classificação superior a 40, portanto o time é considerado um time de ouro.
##### Explicação da Amostra de Entrada/Saída 2:
A imagem mostra a classificação por estrelas de cada jogador. Como apenas um dos dois jogadores tem uma classificação superior a 40, este time não é considerado um time de ouro. |
2,658 | 633 | Proteja sua Senha | Médio | Basicos | Por questões de segurança, muitos bancos hoje em dia estão alterando a forma como seus clientes digitam as senhas nos caixas eletrônicos, pois alguém pode postar-se atrás do cliente e ver as teclas à medida em que ele as digita.
Uma alternativa bastante utilizada tem sido associar os dez dígitos a cinco letras, de forma que cada letra esteja associada a dois dígitos, conforme o exemplo abaixo:
As associações entre números e letras são mostradas como botões numa tela sensível ao toque, permitindo que o cliente selecione os botões correspondentes à senha. Considerando a disposição dos botões da figura acima, a senha 384729 seria digitada como BCEAEB (note que a mesma seqüência de letras seria digitada para outras senhas, como por exemplo 982123). Cada vez que o cliente usa o caixa eletrônico, as letras utilizadas são as mesmas (de ‘A’ a ‘E’), com os botões nas mesmas posições, mas os dígitos são trocados de lugar. Assim, caso um intruso veja (mesmo que mais de uma vez) a seqüência de letras digitada, não é possível notar facilmente qual a senha do cliente do banco.
Dada uma seqüência de associações entre letras e números, e as letras digitadas pelo cliente do banco para cada uma dessas associações, você deve escrever um programa para determinar qual é a senha do cliente.
#### Entrada
A entrada é composta de vários conjuntos de testes. A primeira linha de um conjunto de testes contém um inteiro $N$, que indica o número de associações entre letras e números e as senhas digitadas. As $N$ linhas seguintes contêm as entradas da seguinte forma: 10 dígitos, em ordem de associação, para as letras de ‘A’ a ‘E’ (2 dígitos para a letra A, 2 para a B e assim sucessivamente) e 6 letras que representam a senha codificada conforme os dígitos anteriores. As $N$ associações fornecidas em um conjunto de testes serão sempre suficientes para definir univocamente a senha do cliente. O final da entrada é indicado por $N = 0$.
#### Saída
Para cada conjunto de teste da entrada, seu programa deve produzir três linhas na saída. A primeira linha deve conter um identificador do conjunto de teste, no formato “Teste n”, onde $n$ é numerado sequencialmente a partir de 1. A segunda linha deve conter a senha do cliente, com um espaço após cada dígito. A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
#### Restrições
* $2 \leq N \leq 10$ ($N = 0$ apenas para indicar o fim da entrada)
|
2,659 | 1976 | Contagem de Votos | Fácil | Basicos | Uma votação é realizada depois que o cantor $A$ e o cantor $B$ competem na rodada final de uma competição de canto.
Seu trabalho é contar os votos e determinar o resultado.
#### Entrada
A entrada será de duas linhas. A primeira linha conterá $V (1 \leq V \leq 15)$, o número total de votos. A segunda linha de entrada será uma sequência de caracteres $V$, cada um dos quais será $A$ ou $B$, representando os votos de um determinado cantor.
#### Saída
A saída será uma das três possibilidades:
* _A_, se houver mais $A$ de votos do que $B$ de votos;
* _B_, se houver mais votos de $B$ do que $A$;
* _Tie_, se houver um número igual de votos de $A$ e $B$ votos. |
2,660 | 1430 | Especiais | Difícil | Basicos | Uma string $S$ é dita especial caso exista pelo menos uma string $T$ que é um prefixo e um sufixo de $S$, com $S \neq T$. Por exemplo, a string $S=abclolkkkkab$ é especial porque a string $ab$ é tanto um prefixo quanto um sufixo de $S$. A string $xdlolhahaha$ não é especial porque não existe nenhum par que contemple a condição.
Dada uma string $A$ de tamanho $N$ contendo apenas letras minúsculas, encontre o tamanho da maior substring de $A$ que é uma string especial.
#### Input
A entrada é composta por uma única string $A$ de tamanho $N$, contendo apenas letras minúsculas.
#### Output
Imprima um único inteiro representando o tamanho da maior substring de $A$ que é uma string especial. Caso não existe nenhuma substring especial, imprima $-1$.
#### Limites
$ 1 \leq N \leq 1000$.
$S$ é compostas apenas por letras minúsculas. |
2,661 | 1210 | Torque | Nível Desconhecido | Basicos |
Joãozinho é um jovem de apenas 11 anos, mas muito curioso; por isso, ele já estuda matérias do Ensino Médio. Em um dia de férias, enquanto estudava Física, Joãozinho descobriu o que era o Momento de uma força, mais conhecido como "Torque". Mais especificamente, Joãozinho descobriu que o Momento resultante, isto é, a soma de todos os Momentos aplicados em um corpo, pode determinar se um determinado corpo está em equilíbrio rotacional ou não. Por exemplo, se o Momento resultante for positivo, então Joãozinho sabe que o corpo gira no sentido horário; já se for negativo, ele sabe que o corpo gira no sentido anti-horário; e, por fim, se for nulo, ele sabe que o corpo está em equilíbrio. Além disso, o jovem brilhante descobriu que o Momento de uma força era calculado por $M$ = +- $F$ *$D$, onde:
* $M$ = Momento
* $F$ = Força
* $D$ = Deslocamento
No entanto, apesar de ter gostado muito de ter aprendido sobre o Torque, Joãozinho tem "preguiça" de realizar as operações para saber se um corpo está em equilíbrio ou não. Por isso, como ele sabe que você programa no Neps há algum tempo, Joãozinho te pediu para escrever um programa que, dado $N$ momentos aplicados em um corpo, determine se este corpo está em equilíbrio rotacional ou não.
#### Entrada
A primeira linha contém apenas um inteiro $N$, representado o número de Momentos aplicados em um corpo.
As $N$ linhas seguintes possuem dois inteiros $F$ e $D$, representando a força e o deslocamento, respectivamente.
#### Saída
Seu programa deve imprimir apenas uma linha, indicando se o corpo está em equilíbrio rotacional ou não e, em caso afirmativo, indicando o sentido de rotação.
#### Restrições
* $1 \leq N \leq 100^{}$
* $-10^{6} \leq F \leq 10^{6}$
* $0 \leq D \leq 100^{}$
|
2,662 | 2313 | Prêmio | Fácil | Basicos | Uma ONG (Organização Não Governamental) oferece cursos gratuitos de programação de computadores, dança, música e culinária. Aproveitando a cozinha montada para os cursos de culinária, também vende pães integrais, doces e bolos para ajudar nas despesas.
O diretor da ONG anunciou um incentivo para a venda da produção da cozinha: considerando que cada pão vale 1 ponto, cada doce vale 2 pontos e cada bolo vale 3 pontos, os colaboradores ganharão um prêmio dependendo da soma total dos pontos dos produtos vendidos durante a semana.
Se a soma dos pontos de todos os produtos vendidos na semana for igual ou maior do que 150, cada colaborador recebe um bolo como prêmio; senão, se a soma dos pontos for maior ou igual a 120, cada colaborador recebe um doce como prêmio; senão, se a soma dos pontos for maior ou igual a 100, cada colaborador recebe um pão como prêmio. Se a soma dos pontos for menor do que 100 não há prêmio para os colaboradores.
Sabendo que você fez um curso de programação na ONG, o diretor pediu que você escreva um programa que, dados os números de pães, doces e bolos vendidos na semana, determine qual o prêmio merecido.
#### Entrada
A primeira linha contém um inteiro $P$, o número de pães vendidos na semana. $A$ segunda linha contém um inteiro $D$, o número de doces vendidos na semana. $A$ terceira e última linha contém um inteiro $B$, o número de bolos vendidos na semana.
#### Saída
Seu programa deve produzir uma única linha, contendo um único caractere, indicando o prêmio merecido: a letra maiúscula ‘P’ para pão, a letra maiúscula ‘D’ para doce, a letra maiúscula ‘B’ para bolo e a letra maiúscula ‘N’ se os colaboradores não merecem prêmio na semana.
#### Restrições
* $0 ≤ P ≤ 100$
* $0 ≤ D ≤ 100$
* $0 ≤ B ≤ 100$
#### Informações sobre a pontuação
* A tarefa vale 100 pontos.
|
2,663 | 2014 | Sorvete | Fácil | Basicos | As sorveterias JOI são famosas por suas altas torres de sorvete. Uma torre de sorvete consiste em uma torre de sorvete básica coberta com zero ou mais sorvetes adicionais.
O sorvete base custa ¥250 e a altura é de $A$ cm. Cada sorvete adicional custa mais 100 ienes, e cada sorvete adicional aumenta a altura da torre de sorvete em $B$ cm.
Você quer comprar uma torre de sorvete que tenha pelo menos $S$ cm de altura. Encontre a quantidade mínima de dinheiro necessária para comprar uma torre de sorvete com altura igual ou superior a $B$ cm.
#### Entrada
A entrada é fornecida pela entrada padrão no seguinte formato.
$S$
$A$
$B$
#### Saída
Imprima a quantidade mínima de dinheiro necessária para comprar uma torre de sorvete com altura igual ou superior a $S$ cm, omitindo a unidade (iene).
#### Restrições
* $1 \leq S \leq 100.$
* $1 \leq A \leq 100.$
* $1 \leq B \leq 100.$
* Todos os valores de entrada são números inteiros.
##### Explicação do exemplo de entrada/saída 1:
* Se nenhum sorvete for adicionado, a altura da torre de sorvete é de 20 cm e o preço é 250 ienes.
* Se um sorvete for adicionado, a altura da torre de sorvete se torna 25 cm e o preço se tor 350 ienes.
* Se forem adicionados dois sorvetes, a altura da torre de sorvete se torna 30 cm e o preço se torna 450 ienes.
Sendo assim, a quantidade mínima de dinheiro necessária para comprar uma torre de sorvete com pelo menos 28 cm de altura é de 450 ienes, portanto a saída deve ser "450". |
2,664 | 611 | Truco | Médio | Basicos | Truco é um jogo de cartas que pode ser jogado por duas ou mais pessoas. Existem diversas variações: o Truco Cego ou Truco Espanhol (popular no sul do Brasil, Argentina, Uruguai e outros países), o Truco Paulista, Capixaba ou Mineiro (variações populares no Brasil), o Truco Índio e o Truco Eteviano. Em geral, é uma disputa de três rodadas (“melhor de três”) para ver quem tem as cartas mais “fortes” (de valor simbólico mais alto). Adalberto e Bernardete estão jogando uma variação de truco com 40 cartas (foram retirados do baralho todas as cartas de valor 8, 9 e 10, além dos coringas), e o valor simbólico independente do naipe da carta. A ordem de valor simbólico das cartas nessa variação de truco é mostrada abaixo, ordenada da mais “fraca” (mais à esquerda) para a mais “forte” (mais à direita)
<div class="row justify-content-center my-2">
4 5 6 7 Q J K A 2 3
</div>
Cada partida é disputada em três rodadas. A cada rodada, os jogadores escolhem uma das cartas para mostrar, e vence aquele que tiver a carta com o maior valor simbólico. Em caso de empate (ou seja, os dois apresentarem cartas com os mesmos valores simbólicos), Adalberto vence, pois é mais velho que Bernardete. Vence a partida aquele que vencer o maior número de rodadas. Depois de algumas partidas, Adalberto e Bernardete estão com dificuldades para saber quem venceu mais partidas, e pediram a sua ajuda.
Sua tarefa é escrever um programa que calcule o número de partidas que cada um dos competidores (Adalberto e Bernardete) venceram.
#### 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 saída possui um inteiro $N$ que indica o número de partidas disputadas entre Adalberto e Bernardete. As $N$ linhas seguintes contêm cada uma seis inteiros, $A_1, A_2, A_3, B_1, B_2$ e $B_3$, que correspondem às três cartas apresentadas por Adalberto nas rodadas 1, 2 e 3 daquela partida ($A_1, A_2, A_3 \in \{1, 2, 3, 4, 5, 6, 7, 11, 12, 13\}$), seguidas pelas três cartas apresentadas por Bernardete nas rodadas 1, 2 e 3 da mesma partida ($B_1, B_2, B_3 \in \{1, 2, 3, 4, 5, 6, 7, 11, 12, 13\}$). Na entrada, o número 1 representa o Ás (A), 11 representa o Valete (J), 12 representa a Dama (Q) e 13 representa o Rei (K).
#### Saída
Seu programa deve imprimir, na saída padrão, uma única linha, que contém os números de partidas vencidas por Adalberto e por Bernadete, nessa ordem, separados por espaços.
#### Restrições
* $1 \leq N \leq 1000000$ |
2,665 | 649 | Bits Trocados | Fácil | Basicos | As Ilhas Weblands formam um reino independente nos mares do Pacífico. Como é um reino recente, a sociedade é muito influenciada pela informática. A moeda oficial é o Bit; existem notas de $B\$\ 50,00$, $B\$\ 10,00$, $B\$\ 5,00$ e $B\$\ 1,00$. Você foi contratado(a) para ajudar na programação dos caixas automáticos de um grande banco das Ilhas Weblands.
Os caixas eletrônicos das Ilhas Weblands operam com todos os tipos de notas disponíveis, mantendo um estoque de cédulas para cada valor ($B\$\ 50,00$, $B\$\ 10,00$, $B\$\ 5,00$ e $B\$\ 1,00$). Os clientes do banco utilizam os caixas eletrônicos para efetuar retiradas de um certo número inteiro de Bits. Sua tarefa é escrever um programa que, dado o valor de Bits desejado pelo cliente, determine o número de cada uma das notas necessário para totalizar esse valor, de modo a minimizar a quantidade de cédulas entregues. Por exemplo, se o cliente deseja retirar $B\$\ 50,00$, basta entregar uma única nota de cinquenta Bits. Se o cliente deseja retirar $B\$\ 72,00$, é necessário entregar uma nota de $B\$\ 50,00$, duas de $B\$\ 10,00$ e duas de $B\$\ 1,00$.
#### Entrada
A entrada é composta de vários conjuntos de teste. Cada conjunto de teste é composto por uma única linha, que contém um número inteiro positivo $V$, que indica o valor solicitado pelo cliente. O final da entrada é indicado por $V = 0$.
#### Saída
Para cada conjunto de teste da entrada seu programa deve produzir três linhas na saída. A primeira linha deve conter um identificador do conjunto de teste, no formato “Teste n”, onde $n$ é numerado a partir de 1. Na segunda linha devem aparecer quatro inteiros $I$, $J$, $K$ e $L$ que representam o resultado encontrado pelo seu programa: $I$ indica o número de cédulas de $B\$\ 50,00$, $J$ indica o número de cédulas de $B\$\ 10,00$, $K$ indica o número de cédulas de $B\$\ 5,00$ e $L$ indica o número de cédulas de $B\$\ 1,00$. A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
#### Restrições
* $0 \leq V \leq 10000$ ($V= 0$ apenas para indicar o fim da entrada)
|
2,666 | 1733 | Pontuação vencedora | Fácil | Basicos | Você registra toda a atividade de pontuação em um jogo de basquete. Os pontos são marcados por um lançamento de 3 pontos, uma cesta de área de 2 pontos ou um arremesso livre de 1 ponto.
Você sabe a quantidade de cada um desses tipos de pontuação que as duas equipes marcaram: as Maçãs e as Bananas. Seu trabalho é determinar qual time ganhou, ou se o jogo terminou empatado.
#### Entrada
As três primeiras linhas de entrada descrevem a pontuação das maçãs, e as três linhas seguintes descrevem a pontuação das bananas. Para cada equipe, a primeira linha contém o número de arremessos bem sucedidos de 3 pontos, a segunda linha contém o número de cestas de área bem sucedidos de 2 pontos, e a terceira linha contém o número de arremessos bem sucedidos de 1 ponto livre. Cada número será um número inteiro entre 0 e 100, inclusive.
#### Saída
A saída será de um único caractere. Se as Maçãs marcaram mais pontos do que as Bananas, imprima a saída 'A'. Se as Bananas marcaram mais pontos do que as Maçãs, imprima 'B'. Caso contrário, imprima 'T', para indicar um empate. |
2,667 | 1400 | Ari e Ane | Nível Desconhecido | Basicos | Ari e Ane são duas colegas que adoram colorir, elas irão participar da OBI (Olimpíada Brasileira de Ilustração), a competição se trata de um duelo onde 2 competidores devem colorir a maior quantidade possível de quadrados em uma malha $N$ x $M$. Elas querem praticar e pediram a sua ajuda para decidir quem ganhou cada partida de Ilustração.
#### Entrada
A primeira linha é composta por três número $I$, $J$ e $N$, onde $I$ e $J$ representam as dimensões das malhas que serão coloridas em cada partida, e $N$ representa quantos jogos Ari e Ane irão jogar. Para cada umas das $N$ partidas você deve ler uma matriz $I$ x $J$ que representa o resultado final da malha daquela partida. Em cada matriz, as posições com '0' representam as posições que Ari coloriu e as posições com '1' representam as posições que Ane coloriu.
#### Saída
Para cada partida, caso Ari vença, mostre a mensagem "Ari venceu", mas se Ane vencer mostre a mensagem "Ane venceu", caso a partida dê empate mostre a mensagem "Empate", não esqueça do final de linha após cada mensagem.
|
2,668 | 725 | Soma de Frações com Structs | Fácil | Basicos | Joãozinho está aprendendo a somar frações na escola e gostaria de ter um programa que dadas duas frações imprima a soma delas em sua forma irredutível. Assim ele vai poder conferir as respostas dos exercícios que está fazendo.
A forma irredutível de uma fração é quando o divisor (número de baixo) é o menor possível. Por exemplo, 10/3 é uma fração irredutível, pois 10 e 3 não têm nenhum divisor em comum. Mas 10/6 não é, pois ela pode ser simplificada para 5/3, dividindo-se 10 e 6 por 2.
Um amigo de Joãozinho já criou um programa para calcula a soma das frações na sua forma irredutível, porém quando ele enviou o código para Joãozinho ele se esqueceu de enviar a Struct utilizada. Complete o código abaixo criando a Struct adequada utilizada pela função <i>main</i>.
```c++
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
// Adicione o código da sua Struct aqui!
// Função que calcula o máximo divisor comum entre a e b.
long long mdc(int a, int b){
return (b == 0 ? a : mdc(b, a%b));
}
int main(){
fracao A, B;
scanf("%d %d %d %d", &A.numerador, &A.denominador, &B.numerador, &B.denominador);
fracao C;
C.numerador = (A.numerador*B.denominador) + (A.denominador*B.numerador);
C.denominador = A.denominador*B.denominador;
int MDC = mdc(C.numerador, C.denominador);
printf("%d %d", C.numerador/MDC, C.denominador/MDC);
}
```
#### Entrada
A única linha da entrada contém quatro inteiros $N_1, D_1, N_2, D_2$ respectivamente numerador e denominador da primeira fração e numerador e denominador da segunda fração.
#### Saída
Seu programa deve imprimir uma única linha contendo dois inteiros, numerador e denominador da fração irredutível formada pela soma das duas frações dadas.
#### Restrições
* $1 \leq N_1, D_1, N_2, D_2 \leq 10^5$ |
2,669 | 642 | Dobradura | Fácil | Basicos | Zezinho tem aulas de Iniciação Artística em sua escola, e recentemente aprendeu a fazer dobraduras em papel. Ele ficou fascinado com as inúmeras possibilidades de se dobrar uma simples folha de papel. Como Zezinho gosta muito de matemática, resolveu inventar um quebra-cabeça envolvendo dobraduras. Zezinho definiu uma operação de dobradura D que consiste em dobrar duas vezes uma folha de papel quadrada de forma a conseguir um quadrado com 1/4 do tamanho original, conforme ilustrado na figura.
Depois de repetir N vezes esta operação de dobradura D sobre o papel, Zezinho cortou o quadrado resultante com um corte vertical e um corte horizontal, conforme a figura abaixo.
Zezinho lançou então um desafio aos seus colegas: quem adivinha quantos pedaços de papel foram produzidos?
#### Entrada
A entrada é composta de vários conjuntos de teste. Cada conjunto de teste é composto de uma única linha, contendo um número inteiro $N$ que indica o número de vezes que a operação de dobradura $D$ foi aplicada. O final da entrada é indicado por $N = -1$.
#### Saída
Para cada conjunto de teste da entrada seu programa deve produzir três linhas na saída. A primeira linha deve conter um identificador do conjunto de teste, no formato “Teste n”, onde $n$ é numerado a partir de 1. A segunda linha deve conter o número de pedaços de papel obtidos depois de cortar a dobradura, calculado pelo seu programa. A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
#### Restrições
* $-1 \leq N \leq 15$ ($N = -1$ apenas para indicar o fim da entrada)
|
2,670 | 1977 | Dado Duplo | Fácil | Basicos | Antônia e David estão jogando um jogo.
Cada jogador começa com 100 pontos.
O jogo usa dados padrão de seis lados e é jogado em rodadas. Durante uma rodada, cada jogador joga um dado. O jogador com o lançamento mais baixo perde o número de pontos mostrado no dado mais alto. Se ambos os jogadores rolarem o mesmo número, nenhum dos jogadores perde pontos.
Escreva um programa para determinar a pontuação final.
#### Entrada
A primeira linha de entrada contém o inteiro $n (1\leq n\leq 15)$, que é o número de rodadas que serão jogadas. Em cada uma das próximas linhas de $n$, serão dois inteiros: a rolagem de Antônia para aquela rodada, seguida por um espaço, seguido pela rolagem de David para aquela rodada. Cada rolagem será um número inteiro entre 1 e 6 (inclusive).
#### Saída
A saída consistirá de duas linhas. Na primeira linha, sairá o número de pontos que Antonia tem depois de todas as rodadas terem sido jogadas. Na segunda linha, sairá o número de pontos que David tem depois de todas as rodadas terem sido jogadas.
#### Explicação da Saída para o Caso de Teste
Após a primeira rodada, David ganha, então Antonia perde 6 pontos. Após a segunda rodada, há um empate e nenhum ponto é perdido. Após a terceira rodada, Antonia ganha, então David perde 4 pontos. Após a quarta rodada, Antonia vence, então David perde 5 pontos. No total, Antonia perdeu 6 pontos e David perdeu 9 pontos. |
2,671 | 1951 | Palavras ao vento | Muito Fácil | Basicos | Ovatsug adora conversar com as pessoas. Mas agora ele tem pensado muito numa frase que ouviu de um senhorzinho muito sábio. Disse o senhorzinho que: _“Deve-se ter cuidado ao falar, porque as palavras ecoam e são levadas pelo vento para todos os cantos do planeta.”_
Mas é evidente que as palavras vão ecoar conforme o volume em que elas forem pronunciadas. Uma frase pronunciada num volume $V$ ecoa $V$ vezes no ar.
Ovatsug ficou curioso, e agora ele gostaria de ter um programa que: dados a frase que foi dita e o volume no qual foi dita, imprima-a na tela tantas vezes quantas ela foi ecoada. Você pode ajudá-lo?
#### Entrada
A primeira linha de entrada contém um inteiro $V (1 ≤ V ≤ 10^2)$, que representa o volume em que a frase foi dita. Na segunda linha há a frase $F (2 ≤ |F| ≤ 10^2)$, dita por Ovatsug. $F$ possui apenas letras maiúsculas ou minúsculas e espaços.
#### Saída
A saída deve conter $V$ linhas, e em cada uma delas deve conter a frase $F$.
|
2,672 | 1760 | Melhor Campus | Fácil | Basicos | Bino está terminando o ensino médio e está em dúvida sobre qual campus do IFCE ele deve cursar o ensino superior. Bino mora em Ubaúna, uma cidade igualmente próxima dos campus: Sobral, Ubajara e Tianguá.
Para ajudar nessa difícil decisão, Cino deu para Bino uma rosa, e disse para ele escolher o campus de acordo com a quantidade de pétalas da rosa. Então, para escolher o campus, Bino retira uma pétala e diz "Sobral", retira outra pétala e diz "Ubajara", retira outra pétala e diz "Tiangua", e assim por diante até que a rosa não tenha mais pétalas. Bino irá escolher o último campus que ele prenunciou o nome.
#### Entrada
A entrada contém uma única linha com um inteiro $P$ ($1 \leq P \leq 100$), indicando a quantidade de pétalas da rosa que Cino deu para Bino.
#### Saída
A saída consiste em uma única linha contendo o nome do campus escolhido (lembre-se de não usar acentos).
|
2,673 | 2024 | Telemarketer ou não? | Fácil | Basicos | Aqui no Concerned Citizens of Commerce (CCC), nos notamos que os telemarketers gostam de usar números de telefone com sete dígitos onde os últimos quatro dígitos têm três propriedades. Olhando apenas para os últimos quatro dígitos, as propriedades são:
* o primeiro destes quatro dígitos é um 8 ou 9;
* o último dígito é um 8 ou 9;
* o segundo e o terceiro dígitos são os mesmos.
Por exemplo, se os últimos quatro dígitos do número de telefone são 8229, 8338 ou 9008, estes são números de telemarketing.
Escreva um programa para decidir se um número de telefone é ou não um número de telemarketing, com base nos últimos quatro dígitos. Se o número não for um número de telemarketing, devemos atender o telefone, e caso contrário, devemos ignorá-lo.
#### Entrada
A entrada será composta por 4 linhas onde cada linha contém exatamente um dígito na faixa de 0 a 9.
#### Saída
A saída deve ser "ignore" se o número corresponde ao padrão para um número de telemarketing; caso contrário, a saída deve ser "answer".
##### Explicação do exemplo de entrada/saída 1:
O primeiro dígito é 9, o último dígito é 8, e o segundo e terceiro dígitos são ambos 6, portanto, este é um número de telemarketing.
##### Explicação do exemplo de entrada/saída 1:
O primeiro dígito é 5 e, portanto, este não é um número de telemarketing. |
2,674 | 2355 | Soma deslocada | Fácil | Basicos | Suponha que temos um número como $12$. Vamos definir o ato de deslocar um número como adicionar um zero no final. Por exemplo, se deslocarmos esse número uma vez, obtemos o número $120$. Se deslocarmos o número novamente, obtemos o número $1200$. Podemos deslocar o número quantas vezes quisermos.
Neste problema, você calculará a soma deslocada, que é a soma de um número e dos números que obtemos ao deslocar. Especificamente, você receberá o número inicial $N$ e um número inteiro não negativo $k$. Você deve somar $N$ a todos os números que obtiver ao deslocar um total de $k$ vezes.
Por exemplo, a soma deslocada quando $N$ é $12$ e $k$ é 1 é: $12 + 120 = 132$. Como outro exemplo, a soma deslocada quando $N$ é $12$ e $k$ é 3 é $12 + 120 + 1200 + 12000 = 13332$.
#### Entrada
A primeira linha da entrada contém o número $N \ (1 \leq N \leq 10000)$. A segunda linha da entrada contém o número $k$, a quantidade de vezes que $N$ será deslocado $ (0 \leq k \leq 5)$.
#### Saída
Imprima o número inteiro que é a soma deslocada de $N$ por $k$. |
2,675 | 1903 | Covid-19 | Fácil | Basicos | O Ministério da Saúde da Terra do Nunca publicou recentemente uma tabela codificada por cores para ajudar as pessoas a entender melhor o nível de risco da Covid-19 em diferentes cidades, e tomar as ações e precauções apropriadas com base no nível de risco.
Neste gráfico, cada cidade é colorida em vermelho, amarelo ou branco, com base em alguns indicadores que mostram o nível de risco de coronavírus naquela cidade. Após explorar vários modelos, o ministério alcançou os seguintes critérios para classificar as cidades. Para uma determinada cidade, se o número médio de novos casos por dia nas últimas duas semanas for no máximo 50 por um milhão de habitantes, e o número médio de novas hospitalizações por dia nas últimas duas semanas for no máximo 10 em cada um milhão de habitantes, então a cidade é marcada como branca, o que significa que a cidade está em uma zona de baixo risco. Por outro lado, se o número médio de novas hospitalizações por dia em uma cidade nas últimas duas semanas for superior a 30 por um milhão de habitantes, então a cidade é classificada como de alto risco e é codificada em vermelho. Todas as outras cidades são coloridas de amarelo.
Embora os dados para novos casos e hospitalizações estejam disponíveis publicamente, o ministério não atualiza sua tabela codificada por cores com muita frequência. Hana, uma estudante curiosa, gosta de saber o nível de risco de sua cidade em qualquer momento, antes que o ministério publique seu gráfico atualizado. Ela pode obter o número médio de novos casos e novas hospitalizações pela Internet, mas ela precisa de sua ajuda para converter esses dados em um código colorido que demonstre melhor o nível de risco em sua cidade.
#### Entrada
A entrada consiste em duas linhas. A primeira linha contém um número inteiro $p \ (0 \ \leq \ p \ \leq \ 1000)$, mostrando o número médio de novos casos por dia em cada um milhão de habitantes da cidade de Hana nas últimas duas semanas. A segunda linha contém um número inteiro $q \ (0 \ \leq \ q \ \leq \ 500)$, mostrando o número médio de novas hospitalizações por dia em cada um milhão de habitantes nas últimas duas semanas naquela cidade. Note que $q \ \leq \ p$.
#### Saída
Na saída, imprima o código de cores da cidade de Hana. Deve ser "White", "Yellow" ou "Red". |
2,676 | 1493 | Gasolina | Fácil | Basicos | O governo de Neverland anunciou recentemente um novo plano de racionamento de gasolina com um aumento de preço inesperado. Pelo novo plano, cada pessoa recebe uma cota de 60 litros por mês em um cartão de combustível. Cada litro de gasolina custa 1.500 Oshloobs se estiver dentro da cota. Qualquer abastecimento extra custa 3.000 Oshloobs por litro.
Depois de se recuperar do choque, Mahya está tentando descobrir o quão sombrio é o futuro. O mês em curso está chegando ao fim e Mahya ainda tem alguma cota em seu cartão de combustível, disponível para o próximo mês. Uma cota de 60 litros será adicionada ao seu cartão de combustível apenas no início do próximo mês. Ela também tem uma previsão da quantidade de gasolina que será utilizada no próximo mês. Ela agora quer saber quanto deve pagar pela gasolina no próximo mês. No entanto, ela é muito preguiçosa para fazer isso sozinha. Portanto, ela precisa da sua ajuda para calcular o custo para ela.
#### Entrada
A entrada consiste em duas linhas. A primeira linha contém um inteiro $N \ (0 \leq N \leq 200)$, especificando a quantidade de gasolina que será usada no próximo mês. A segunda linha contém um inteiro $K \ (0 \leq K \leq 360)$, mostrando a cota restante no cartão de combustível de Mahya no final do mês atual.
#### Resultado
Imprima a quantidade de dinheiro (em Oshloobs) que Mahya pagará pela gasolina no próximo mês. |
2,677 | 98 | Sequencia Completa de Naebbirac | Difícil | Basicos | Naebbirac é um jovem marinheiro que se entedia facilmente. Ele gosta de sequências de inteiros, e desenvolveu modos de classifica-las. Naebbirac diz que toda a sequência é completa para um dado inteiro $K$, se a sequência apenas contem inteiros entre 1 e $K$, e que cada inteiro entre 1 e $K$ aparece o mesmo número de vezes.
Baseado nisso, Naebbirac criou um jogo para entreter a si e aos seus colegas quando as águas estão calmas e não muito o que possam fazer para passar o tempo no meio do oceano.
Primeiro ele escolhe um inteiro positivo $K$ e então ele usa giz para desenhar no convés uma sequência $S$ contendo $N$ inteiros entre 1 e $K$. Após isso ele desafia algum de seus camaradas. O objetivo do desafio é transformar a sequência $S$ em uma sequência completa executando uma das três seguintes operações:
* ”-$x$” : remove uma das ocorrências do inteiro $x$ de $S$;
* ”+$x$”: adiciona um novo inteiro de valor $x$ em $S$; ou
* ”-$x$ +$y$”: substitui uma ocorrência do inteiro $x$ de $S$ por um inteiro de valor $y$.
Naebbirac é bem esperto. Ele nunca escreve uma sequência já completa e frequentemente escreve inteiros que não seguem padrão algum, tornando bem difícil encontrar uma operação que resolva o enigma. Um de sus amigos, que frequentemente navega com Naebbirac, está cansado de sempre perder o jogo. Você é capaz de ajudar seu amigo e criar um programa que ache a solução ao enigma proposto antes que eles voltem a velejar?
#### Entrada
A primeira linha contem dois inteiros $K$ ($3 \leq K \leq 1000$) e $N$ ($1 \leq N\leq 10^4$), indicando respectivamente o inteiro que Naebbirac escolheu para começar o jogo e o comprimento da sequencia escrita no convés. A segunda linha contem $N$ inteiros $S_1, N_2,\ldots,S_N$ ($1 \leq S_i \leq K$ for $i = 1, 2, \ldots, N$) representando a sequência escrita; você pode seguramente assumir que a sequência não está completa.
#### Saída
Imprima uma única linha com a descrição da operação que possibilita o seu amigo ganhar o jogo ou um “*” (asterisco) se não existe maneira de ganhar. A descrição da operação deve seguir o formato mostrado no enunciado, i.e. “-$x$”, “+$x$” ou “-$x$ +$y$”. |
2,678 | 2008 | Baús e Chaves | Fácil | Basicos | Vitaro, o castor, obteve $N$ baús de tesouro trancadas e $M$ chaves. Os $N$ baús são numeradas de 1 a $N$, e o baú de tesouro $i \ (1 \leq i \leq N)$ tem o inteiro $A_i$ escrito nele. As $M$ chaves são numeradas de 1 a $M$, e a chave $j \ (1 \leq j \leq M)$ tem o número inteiro $B_j$.
O cofre do tesouro $i$ pode ser desbloqueado usando uma chave com o número inteiro $A_i$. A mesma chave pode ser usada para desbloquear múltiplos baús de tesouro.
Vitaro quer destravar o maior número possível de baús de tesouro. Encontre o número máximo de baús do tesouro que Vitaro pode desbloquear.
#### Entrada
A entrada é fornecida pela entrada padrão no seguinte formato.
$N \ M$
$A_1 \ A_2 ... \ A_N$
$B_1 B_2 ... \ B_M$
#### Saída
Imprima o número máximo de baús do tesouro que Vitaro pode destravar.
#### Restrições
* $1 \leq N \leq 100.$
* $1 \leq M \leq 100.$
* $1 \leq A_i \leq 2000 \ (1 \leq i \leq N).$
* $1 \leq B_j \leq 2000 \ (1 \leq j \leq M).$
* Todos os valores da entrada são números inteiros.
##### Explicação do exemplo de entrada/saída 1:
* O baú de tesouro 1 contém o número inteiro 2. A chave 1 também tem o número inteiro 2 escrito nela. Portanto, o baú de tesouro 1 pode ser desbloqueada usando a chave 1.
* O baú de tesouro 2 pode ser desbloqueada usando a chave 1.
* O baú de tesouro 3 não pode ser desbloqueado com nenhuma chave chave.
* O baú de tesouro 4 pode ser destrancado usando a chave 2 ou a chave 4.
Portanto, Vitaro pode desbloquear no máximo três baús de tesouro. |
2,679 | 2398 | Retângulo | Muito Fácil | Basicos | Dados os números inteiros $A$ e $B$. Encontre a área em _cm_$^2$ do retângulo mostrado abaixo, cujo lado vertical é $A$ _cm_ e cujo lado horizontal é $B$ _cm_.
#### Entrada
A entrada é fornecida por meio da entrada padrão no seguinte formato.
$A$
$B$
#### Saída
Imprima a área em _cm_$^2$ de um retângulo cujo comprimento do lado vertical é $A$ _cm_ e cujo comprimento do lado horizontal é $B$ _cm_, omitindo a unidade (_cm_$^2$).
#### Restrições
* $1 \leq A \leq 100.$
* $1 \leq B \leq 100.$
* $A$ e $B$ são números inteiros.
##### Explicação do exemplo de entrada/saída 1:
A área de um retângulo com um comprimento vertical de lado de $2$ _cm_ e um comprimento horizontal de lado de $3$ _cm_ é $6$ _cm_$^2$ , portanto, imprima $6$. |
2,680 | 1785 | O valor mais próximo | Fácil | Basicos | Dados os inteiros $X, \ L $, e $R$. Imprima o número inteiro entre $L$ e $R$ que tem a menor diferença absoluta em relação a $X$. É confirmado que existe exatamente um número inteiro desse tipo.
#### Entrada
A entrada é dada pela entrada padrão na seguinte forma
$X \ L \ R$
#### Saída
Imprima o número inteiro entre $L$ e $R$ que tem a menor diferença absoluta em relação a $X$.
#### Restrições
* $1 \leq X \leq 100 000.$
* $1 \leq L \leq R \leq 100 000.$
|
2,681 | 1372 | Ordenação por Contagem | Nível Desconhecido | Basicos | Aprendemos que a técnica _Counting Sort_ realiza a função de ordenar por contagem de elementos em um array. Diante disso, realize essa técnica com um vetor que contenha $N$ elementos e imprima a quantidade de números pertencentes a cada posição, ou seja, o vetor auxiliar indo até $N$.
Por exemplo:
Array de 4 elementos com V={1, 3, 3, 2}.
Sua saída corresponderia a Aux={0, 1, 1, 2} → Sendo 0 números na posição 0, 1 número na posição 1, 1 número na posição 2 e 2 números na posição 3.
#### Entrada
É composta pela variável $N$ que representa o tamanho do vetor $V$, e ,em seguida, cada elemento $V_i$ do vetor. Todos os elementos são menores que $N$.
#### Saída
É composta pela contagem dos elementos de forma crescente. Lembrando que é a impressão do vetor auxiliar (até $N$).
#### Restrições
* $2 \leq N \leq 10^{8}$
* $0 \leq V < N$
|
2,682 | 2406 | Inteiro de dois dígitos | Muito Fácil | Basicos | Dados dois números $A$ e $B$.
Imprima um número inteiro positivo de dois dígitos cuja casa das dezenas seja $A$ e cuja casa das unidades seja $B$.
#### Entrada
A entrada é dada no seguinte formato.
$A$
$B$
#### Saída
Imprima um número inteiro positivo de $2$ dígitos cujo dígito das dezenas é $A$ e o dígito das unidades é $B$.
#### Restrições
* $A$ é $1, \ 2, \ 3, \ 4, \ 5, \ 6, \ 7, \ 8$ ou $9$.
* $B$ é $0, \ 1, \ 2, \ 3, \ 4, \ 5, \ 6, \ 7, \ 8$ ou $9$.
##### Explicação do exemplo de entrada/saída 1:
O inteiro positivo com $2$ na casa das dezenas e $2$ na casa das unidades é $22$, portanto, $22$ é a saída.
##### Explicação do exemplo de Entrada/saída 2:
O número inteiro positivo de dois dígitos com o dígito das dezenas sendo $1$ e o dígito das unidades sendo $0$ é $10$, portanto, $10$ é a saída. |
2,683 | 2402 | Hora | Muito Fácil | Basicos | Um dia tem $24$ horas.
Dado um número inteiro $X$.
Encontre o número de horas em $X$ dias.
#### Entrada
A entrada é fornecida pela entrada padrão no seguinte formato.
#### Saída
Emite o número de horas em $X$ dias, omitindo a unidade (horas).
#### Restrições
* $1 \leq X \leq 365$.
* $X$ é um número inteiro.
##### Explicação do exemplo de entrada/saída 1:
Como $3$ dias são $72$ horas, $72$ é a saída.
##### Explicação do exemplo de Entrada/saída 2:
Como $100$ dias são $2400$ horas, $2400$ é a saída. |
2,684 | 2012 | Número Raro | Fácil | Basicos | Dada uma sequência de inteiros $A = (A_1, \ A_2, ... \ A_N)$ de comprimento $N$.
Imprima o número inteiro com o menor número de ocorrências entre os inteiros que aparecem em A. Se houver mais de um inteiro, imprima o menor número inteiro entre os inteiros possíveis.
#### Entrada
A entrada é fornecida pela entrada padrão no seguinte formato.
$N$
$A_1, A_2 ... \ A_N$
#### Saída
Imprima o número inteiro com o menor número de ocorrências entre os inteiros que aparecem em $A$. Se mais de um desses inteiros for possível, imprima o menor número inteiro entre os inteiros possíveis.
#### Restrições
* $1 \leq N \leq 100.$
* $1 \leq A_i \leq 2000 \ (1 \leq i \leq N).$
* Todos os valores de entrada são números inteiros.
##### Explicação do exemplo de entrada/saída 1:
O número inteiro 3 aparece duas vezes e o número inteiro 4 uma vez em $A$. Nenhum número inteiro além de 3 e 4 aparece. Como o número de ocorrências de 4 é o menor, 4 é a saída.
##### Explicação do exemplo de entrada/saída 2:
O inteiro 2 aparece uma vez, o inteiro 4 duas vezes, o inteiro 5 uma vez e o inteiro 8 uma vez em $A$. Não aparecem outros inteiros além de 2, 4, 5 e 8. Os números inteiros com o menor número de ocorrências são 2, 5, e 8. Portanto, 2 será o resultado por conta de ser o menor entre 2, 5 e 8. |
2,685 | 2399 | Mesmos números | Muito Fácil | Basicos | Dado um número $N$ inteiro de $2$ dígitos em notação decimal, imprima '1' se o algarismo das dezenas e o algarismo das unidades de $N$ forem iguais, e '0' caso contrário.
#### Entrada
A entrada é fornecida pela entrada padrão no seguinte formato.
$N$
#### Saída
Saída '1' se o dígito das dezenas e o dígito das unidades de $N$ forem iguais, e '0' caso contrário.
#### Restrições
* $10 \leq N \leq 99$.
* $N$ é um número inteiro.
##### Explicação do exemplo de entrada/saída 1:
$22$ é o mesmo que $2$ na casa das dezenas e $2$ na casa das unidades, portanto, a saída é '1'.
##### Explicação do exemplo de Entrada/saída 2:
$10$ é $1$ na casa das dezenas e $0$ na casa das unidades, por isso a saída é '0'. |
2,686 | 2015 | Dia de Esportes | Fácil | Basicos | Aqui estão os $N$ alunos da JOI High School, numerados de 1 a $N$.
No próximo mês, a JOI High School terá um dia de esportes e todos os $N$ alunos participarão do mesmo. Entre os estudantes, $K$ estudantes pertencem ao grupo vermelho e $N-K$ estudantes restantes pertencem ao grupo branco.
Aoi, cujo seu número de participantes é $N$, esqueceu a qual grupo ela pertence. Portanto, ela decide determinar a que grupo ela pertence perguntando a cada um dos outros $N-1$ alunos a que grupo eles pertencem.
As informações sobre os grupos dos $N-1$ estudantes que não são Aoi são representadas por uma string $S$ de comprimento $N-1$, onde cada letra de $S$ é 'R' ou 'W' e seu significado é o seguinte.
* Se a i-ésima letra $(1 \leq i \leq N-1)$ de $S$ for 'R', significa que o aluno com o número de participante $i$ pertence ao grupo vermelho.
* Se a i-ésima letra $(1 \leq i \leq N-1)$ de $S$ for 'W', significa que o aluno com o número de participante $i$ pertence ao grupo branco.
Imprima 'R' se Aoi pertence ao grupo vermelho e 'W' se ela pertence ao grupo branco.
#### Entrada
A entrada é fornecida pela entrada padrão no seguinte formato.
$N$
$K$
$S$
#### Saída
Imprima 'R' se Aoi pertence ao grupo vermelho, e 'W' se Aoi pertence ao grupo branco.
#### Restrições
* $2 \leq N \leq 2000.$
* $1 \leq K \leq N-1.$
* $S$ é uma string de comprimento $N-1$.
* Cada caractere em $S$ é ou 'R' ou 'W'.
* O número de R's em $S$ é $K-1$ ou $K$.
* $N$ e $K$ são números inteiros.
##### Explicação do exemplo de entrada/saída 1:
* Os alunos com números de pariticipação 1, 2, 3, 4, 5 e 6 pertencem aos grupos vermelho, branco, vermelho, branco e branco, respectivamente.
* Excluindo Aoi, 2 alunos pertencem ao grupo vermelho e 4 alunos pertencem ao grupo branco. Como três dos alunos pertencem ao grupo vermelho e os quatro restantes ao grupo branco, sabemos que o Aoi pertence ao grupo vermelho. Portanto, imprimimos 'R'.
##### Explicação do exemplo de entrada/saída 2:
* Os alunos com os números de presença 1, 2, 3 e 4 pertencem ao grupo vermelho, grupo branco, grupo vermelho, e grupo vermelho, respectivamente.
* Excluindo Aoi, três alunos pertencem ao grupo vermelho e um aluno pertence ao grupo branco. Como três dos alunos pertencem ao grupo vermelho e os outros dois ao grupo branco, sabemos que o Aoi pertence ao grupo branco. Por isso, imprimimos 'W'. |
2,687 | 2403 | Comparação de três vias | Muito Fácil | Basicos | Dados dois números inteiros $A$ e $B$.
Compare $A$ e $B$ e imprima '-1' se $A < B$, '0' se $A = B$ e '1' se $A > B$.
#### Entrada
A entrada é fornecida pela entrada padrão no seguinte formato.
$A$
$B$
#### Saída
Imprima '-1' se $A < B$, '0' se $A = B$ ou '1' se $A > B$.
#### Restrições
* $1 \leq A \leq 1000$.
* $1 \leq B \leq 1000$.
* $A$ e $B$ são números inteiros.
##### Explicação do exemplo de entrada/saída 1:
Como $3 < 7$, '-1' é a saída.
##### Explicação do exemplo de Entrada/saída 2:
Como $10 = 10$, a saída é '0'.
##### Explicação do exemplo de Entrada/saída 3:
Como $1000 > 1$, '1' é a saída. |
2,688 | 1399 | Strings p-árias | Difícil | Basicos | O $i$-ésimo caractere da $N$-ésima string $p$-ária $S_N^p$ é definido como
$$S_N^p[i] = \left\lbrace \begin{array}{ll} 1, & \mathrm{se}\ p\ \mathrm{divide}\ {N\choose i}\\\\ 0, & \mathrm{caso\ contrario}\end{array}\right.$$
com $i = 0, 1, \ldots, N$.
Por exemplo, $S_2^2$ = "`010`", pois
$${2\choose 0} = 1, {2\choose 1} = 2, {2\choose 2} = 1$$
Dados os valores de $N$ e $p$, determine $S_N^p$.
#### Entrada
A entrada consiste em uma única linha, contendo os valores $N$ e $p$, separados por um espaço em branco, onde $p$ é um número primo.
#### Saída
Imprima, em uma linha, a string $S_N^p$.
#### Restrições
* $1 \leq N \leq 10^{5}$
* $2 < p \leq 101$
* $p$ é primo
|
2,689 | 1374 | Familiares Russos | Difícil | Basicos | Na Rússia, os nomes dos cidadãos são formados por três partes: nome, patronímico e família. Por exemplo, Yuri (nome) Constantinovitch (patronímico, filho de Constantin) Romanov (família).
De forma simplificada, o patronímico é formado a partir do nome do pai mais um sufixo, que depende do sexo do indivíduo e da terminação do nome do pai: "evich", "ovich", "ich", para homens e "evna", "ovna", "ichna", para mulheres. Se Ivan e Sonia são filhos de Petr, então eles tem patronímico Petrovich e Petrovna, respectivamente.
Já a família deriva do nome do patriarca, adicionado de um sufixo de forma semelhante ao patronímico: "ev", "in", "ov", para homens e "ina", "eva", "ova", para mulheres. Por exemplo, Petrov significa "clã de Petr".
Dado o nome de um indivíduo russo e uma lista de cidadãos, identifique quantos quantos familiares (mesma família) e quantos irmãos (mesma família, mesmo pai) deste indivíduo há dentre os listados.
__Nota__: Existem outros sufixos e exceções, tanto para o patronímico quanto para a família. Para efeitos do problema, considere apenas os sufixos citados.
#### Entrada
A primeira linha da entrada contém o nome de indivíduo russo.
A segunda linha contém um natural $N$ que indica a quantidade de cidadãos
na lista.
As próximas $N$ linhas contém os nomes contidos na lista, um por linha. Os nomes são composto por, no máximo, 100 caracteres alfabéticos maiúsculos, minúsculos ou espaços em branco.
#### Saída
Imprima, em uma linha, os inteiros $P$ e $I$, separados por um espaço em branco, os quais correspondem ao número de parentes e de irmãos do indivíduo citado na primeira linha, respectivamente.
#### Restrições
* $1 \leq N \leq 250$
|
2,690 | 1978 | Convite de festa | Médio | Basicos | Você está organizando uma festa e não tem espaço para convidar todos os seus amigos. Você usa o seguinte método matemático não emocional para determinar quais amigos convidar.
Numere seus amigos $1, 2, ..., K$ e coloque-os em uma lista nesta ordem. Em seguida, faça $m$ rodadas. Em cada rodada, use um número para determinar quais amigos devem ser retirados da lista ordenada.
As rodadas utilizarão números $r_1, r_2, . . , r_m$. Na rodada $i$ remova todas as pessoas restantes em posições que sejam múltiplos de $r_i$ (isto é, $r_i, 2r_i, 3r_i, . . .$) O início da lista é a posição $1$.
Imprima os números dos amigos que restam após este processo de remoção.
#### Entrada
A primeira linha de entrada contém o número inteiro $K (1\leq K\leq 100)$. A segunda linha de entrada contém o número inteiro $m (1\leq m \leq 10)$, que é o número de rodadas de remoção. As próximas $m$ de linhas contêm cada uma um inteiro. A $i$ésima dessas linhas $(1\leq i \leq m)$ contém $r_i ( 2\leq r_i \leq 100)$ indicando que cada pessoa em uma posição que seja múltipla de $r_i$ deve ser removida.
#### Saída
A saída são os números inteiros designados aos amigos que não foram removidos. Um número inteiro é impresso por linha em ordem crescente de classificação.
#### Explicação da Saída para o Caso de Exemplo
Inicialmente, nossa lista de convidados é de $1, 2, 3, 4, 5, 6, 7, 8, 9, 10$. Haverá duas rodadas de remoções. Após a primeira rodada de remoções, retiramos as posições pares (ou seja, a cada segunda posição), o que faz com que nossa lista de convidados seja de $1, 3, 5, 7, 9$. Após a segunda rodada de remoções, removemos a cada 3ª rodada de remoções: assim, mantemos $1$ e $3$, removemos $5$ e mantemos $7$ e $9$, o que nos deixa com uma lista de convidados de $1, 3, 7, 9$.
|
2,691 | 1756 | Ladrões | Fácil | Basicos | Ali Babá é um sujeito muito rico, tão rico que nem sua própria família sabe a extensão de sua fortuna (nem como ele a conquistou). Porém está muito velho e por isso decidiu logo fazer seu testamento. Nesse testamento, Ali resolveu dividir sua fortuna entre seus filhos, mas dando prioridade aos mais velhos de tal forma que no documento foi especificado que o filho mais velho receberia metade $(\frac{1}{2})$ da fortuna, o segundo mais velho receberia um terço $(\frac{1}{3})$ do que restasse depois que seu irmão retirasse sua parte, o terceiro mais velho receberia um quarto $(\frac{1}{4})$ do que sobrasse e assim por diante até o filho mais novo. Ou seja, se o filho imediatamente mais velho recebesse $\frac{1}{x}$ do que ainda tivesse, o próximo filho receberia $\frac{1}{x+1}$ do que restasse depois disso.
Devido ao tamanho da fortuna e quantidade de filhos de Ali, sempre sobraria uma parte do valor a qual deveria ser liquidado e convertido em dinheiro na moeda local, os donets, para ser doado a caridade.
Sua tarefa é, dado o número de filhos de Ali e a quantia em donets doada à caridade, determine o valor da fortuna de Ali nesta moeda.
#### Entrada
A entrada contém uma única linha com dois números inteiros $N$ $(1 \leq N \leq 10^3)$ e $M$ $(1 \leq M \leq 10^6)$ que representam respectivamente a quantidade de filhos de Ali e o valor em donets doado à caridade.
#### Saída
A saída consiste em uma linha contendo o valor em donets da fortuna de Ali.
|
2,692 | 629 | Par ou Ímpar (OBI 2004) | Fácil | Basicos | Muitas crianças gostam de decidir todas as disputas através do famoso jogo de Par ou Ímpar. Nesse jogo, um dos participantes escolhe Par e o outro Ímpar. Após a escolha, os dois jogadores mostram, simultaneamente, uma certa quantidade de dedos de uma das mãos. Se a soma dos dedos das mãos dos dois jogadores for par, vence o jogador que escolheu Par inicialmente, caso contrário vence o que escolheu Ímpar.
Dada uma seqüência de informações sobre partidas de Par ou Ímpar (nomes dos jogadores e números que os jogadores escolheram), você deve escrever um programa para indicar o vencedor de cada uma das partidas.
#### Entrada
A entrada é composta de vários conjuntos de testes. A primeira linha de um conjunto de testes contém um inteiro $N$, que indica o número de partidas de Par ou Ímpar que aconteceram. As duas linhas seguintes contêm cada uma um nome de jogador. Um nome de jogador é uma cadeia de no mínimo um e no máximo dez letras (maiúsculas e minúsculas), sem espaços em branco. As $N$ linhas seguintes contêm cada uma dois inteiros $A$ e $B$ que representam o número de dedos que cada jogador mostrou em cada partida. Em todas as partidas, o primeiro jogador sempre escolhe Par. O final da entrada é indicado por $N = 0$.
#### Saída
Para cada conjunto de teste da entrada, seu programa deve produzir a saída da seguinte forma. A primeira linha deve conter um identificador do conjunto de teste, no formato “Teste n”, onde $n$ é numerado sequencialmente a partir de 1. As próximas $N$ linhas devem indicar o nome do vencedor de cada partida. A próxima linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
#### Restrições
* $0 \leq N \leq 1000$ ($N = 0$ apenas para indicar o fim da entrada)
* $0 \leq A \leq 5$
* $0 \leq B \leq 5$
* $1 \leq$ comprimento do nome de jogador $\leq 10$
|
2,693 | 1246 | A praça de Grande Rio | Nível Desconhecido | Basicos | Você e Mallard acabaram de aprender como funciona uma matriz em computação e estão super contentes com isso, parabéns!!
Enquanto se aprofundava em seus estudos, Mallard notou que a praça de Grande Rio pode ser representada por uma matriz cheia de caracteres, levando em conta algumas condições:
* A matriz deve ter o mesmo número de linhas e colunas. Esse número deve ser um número ímpar, caso contrário não há como montar a matriz;
* A matriz é composta por apenas dois caracteres: ‘#’, representando árvores e ‘.’ representando os lugares de circulação;
* As árvores estão apenas abaixo e acima da: diagonal principal, diagonal secundária, linha central e coluna central, com exceção dos pontos que envolvem o ponto central;
* Falando em ponto central, a praça de Grande Rio possui uma grande e antiga árvore em seu centro;
Mallard o desafiou a montar já que, mesmo entendendo como as matrizes funcionam, ele é um pato e é difícil para ele mexer no computador. Por esse motivo, Mallard conta com você e te deseja: “Quack quaacck!!”.
A título de ilustração, a grande e bela praça de Grande Rio pode ser admirada abaixo:
```cpp
. # . . . . # . # . . . . # .
# . # . . . # . # . . . # . #
. # . # . . # . # . . # . # .
. . # . # . # . # . # . # . .
. . . # . # # . # # . # . . .
. . . . # . # . # . # . . . .
# # # # # # . . . # # # # # #
. . . . . . . # . . . . . . .
# # # # # # . . . # # # # # #
. . . . # . # . # . # . . . .
. . . # . # # . # # . # . . .
. . # . # . # . # . # . # . .
. # . # . . # . # . . # . # .
# . # . . . # . # . . . # . #
. # . . . . # . # . . . . # .
```
#### Entrada
Na primeira linha e única linha da entrada será informado um valor **N** que representa as dimensões da matriz.
#### Saída
Imprima na saída a matriz formada nas dimensões especificadas. Note que há 1 espaço entre os caracteres da mesma linha, menos no final, nele deve existir uma quebra de linha. Caso **N** não seja ímpar imprima “Mallard triste”.
#### Restrições
* $1 \leq N \leq 101$
|
2,694 | 2400 | Três Caixas | Fácil | Basicos | Dada uma string $S$ de comprimento $N$, em que cada letra em $S$ é "L" ou "R".
Há uma bola e três caixas nas quais a bola pode ser colocada. As caixas são numeradas como $1$, $2$ e $3$.
Inicialmente, a bola está na caixa $1$.
A partir desse estado, o castor Vitaro realiza $N$ operações nas caixas e na bola.
A $i$-ésima operação ($1 \leq i \leq N$) foi realizada da seguinte forma.
A caixa que contém a bola é designada como caixa $x$, e a bola é removida da caixa $x$. Em seguida, de acordo com a $i$-ésima letra da string $S$, uma das seguintes operações é realizada
Se a $i$-ésima letra da cadeia de caracteres $S$ for "L", a bola será colocada na caixa $x-1$. Entretanto, se $x$ for $1$, a bola será colocada na caixa $1$.
Se a $i$-ésima letra da string $S$ for "R", a bola será colocada na caixa $x+1$. Entretanto, se $x$ for $3$, a bola será colocada na caixa $3$.
Imprima o número de vezes que a bola é colocada na caixa $3$ por meio de $N$ operações.
#### Entrada
A entrada é fornecida pela entrada padrão no seguinte formato.
$N$
$S$
#### Saída
Imprima o número de vezes que a bola foi colocada na caixa $3$ por meio de $N$ operações.
#### Restrições
* $1 \leq N \leq 100.$
* $S$ é uma string de comprimento $N$.
* Cada letra de $S$ é 'L' ou 'R'.
* $N$ é um número inteiro.
##### Explicação do exemplo de entrada/saída 1:
No início, uma bola foi colocada na caixa $1$.
O Vitaro realizou quatro operações como segue.
Na primeira operação, a bola foi removida da caixa $1$ e colocada na caixa $1$.
Na segunda operação, a bola foi removida da caixa $1$ e colocada na caixa $2$.
Na terceira operação, a bola foi removida da caixa $2$ e colocada na caixa $3$.
Na quarta operação, a bola foi removida da caixa $3$ e colocada na caixa $3$.
O número de vezes que a bola é colocada na caixa $3$ por meio das quatro operações é $2$. Portanto, o resultado é $2$.
##### Explicação do exemplo de Entrada/saída 2:
No início, uma bola foi colocada na caixa $1$.
O Vitaro realizou três operações como segue.
Na primeira operação, a bola foi removida da caixa $1$ e colocada na caixa $1$.
Na segunda operação, a bola foi removida da caixa $1$ e colocada na caixa $2$.
Na terceira operação, a bola foi removida da caixa $2$ e colocada na caixa $1$.
O número de vezes que a bola é colocada na caixa $3$ por meio das três operações é $0$. Portanto, o resultado é $0$. |
2,695 | 33 | Escala Musical | Difícil | Basicos | As notas musicais são as unidades mais básicas da composição musical no ocidente. Muitas pessoas acreditam que existem apenas 7 notas musicais:
<div class="text-center">
<b>dó ré mi fá sol lá si</b>
</div>
<br>
Chamaremos essas notas de notas elementares. Na verdade, existem notas além destas acima, normalmente identificadas pelo nome de uma das notas acima seguido do símbolo sustenido (#):
<div class="text-center">
<b>dó dó# ré ré# mi fá fá# sol sol# lá lá# si</b>
</div>
<br>
Assim, existem 12 notas musicais básicas distintas. Entretanto, a rigor, esta sequência é infinita e periódica: após um "si" existe um outro "dó", e a sequência se repete novamente. As notas elementares são mais conhecidas, por estarem em um tom musical conhecido como "dó maior". Em qualquer tom "maior", as distâncias entre as possíveis notas seguem um padrão. No tom "dó maior", por exemplo:
Note que eu poderia usar qualquer "dó" na escala de "dó maior", pois a nota seguinte ao "si" será, novamente, um "dó". O mesmo vale para as demais notas. Um outro exemplo de notas em um determinado tom maior seria a escala de "dó# maior":
Guilherme está aprendendo a tocar um teclado com 61 teclas, numeradas de 1 a 61. Assim, a nota 1 corresponde a um "dó", a nota 2 corresponde a um "dó#" e assim por diante, até chegar nas notas 60 (um "si") e 61 (um "dó"). Acredita-se que as músicas com as melhores melodias são aquelas que estão em algum tom maior, ou seja, músicas em que todas as notas pertencem à escala de algum tom maior. Enquanto pratica no teclado, Guilherme usa um aparelho que grava todas as notas tocadas durante a música. Para ajudá-lo a melhorar sua técnica você decidiu criar um programa capaz de avaliar as músicas gravadas por ele e determinar se elas estão em algum tom maior ou não.
#### Entrada
A primeira linha da entrada terá um número inteiro $N$, com $1 \leq N \leq 10^5$, correspondente ao número de notas musicais da música. Em seguida, serão fornecidos $N$ números, um por linha, todos entre 1 e 61, inclusive, correspondendo às notas musicais.
#### Saída
Seu programa deve verificar se a música está em algum tom maior. Em caso afirmativo, seu programa deve imprimir uma única linha com o tom maior (sem acentos) em que a música está. Caso contrário, seu programa deve imprimir uma linha contendo a palavra desafinado. Caso a música possa estar em mais de um tom maior imprima aquele relativo a menor nota musical básica, sendo que "do" < "do#" < "re", ...
|
2,696 | 2016 | Movendo bolas | Médio | Basicos | Há $N$ bolas numeradas de 1 a $N$. Há $N$ caixas que podem conter qualquer número de bolas, e essas caixas são numeradas de 1 a $N$.
A caixa $i \ (1 \leq i \leq N)$ contém inicialmente a bola $i$.
Aoi, uma estudante da escola secundária JOI, realizou $M$ operações nas caixas e nas bolas deste estado. A j-ésima operação $(1 \leq j\leq M)$ foi realizada da seguinte forma.
* Encontrar uma caixa contendo a bola $X_j$ e remover a bola $X_j$ da caixa. Então, a bola $X_j$ é colocada na caixa $Y_j$.
Após a Aoi ter completado todas as $M$ operações, encontre em qual caixa cada uma das $N$ bolas foram colocadas.
#### Entrada
A entrada é fornecida pela entrada padrão no seguinte formato.
$N \ M$
$X_1 \ Y_1$
$X_2 \ Y_2$
:
$X_M \ Y_M$
#### Saída
A saída possuirá $N$ linhas, onde $i \ (1 \leq i \leq N)$ é o número da caixa contendo a bola $i$ após a Aoi ter completado todas as $M$ operações.
#### Restrições
* $1 \leq N \leq 2000.$
* $1 \leq M \leq 2000.$
* $1 \leq X_j \leq N \ (1 \leq j \leq M).$
* $1 \leq Y_j \leq N \ (1 \leq j \leq M).$
* Todos os valores de entrada são números inteiros.
##### Explicação do exemplo de entrada/saída 1:
Inicialmente, a caixa 1 continha a bola 1, a caixa 2 continha a bola 2, e a caixa 3 continha a bola 3.
Aoi realizou quatro operações como se segue:
* Na primeira operação, a bola 1 foi retirada da caixa 1 e colocada na caixa 2.
* Na segunda operação, a bola 3 foi removida da caixa 3 e colocada na caixa 2.
* Na terceira operação, a bola 2 foi removida da caixa 2 e colocada na caixa 1.
* Na quarta operação, a bola 1 foi removida da caixa 2 e colocada na caixa 3.
Após todas as operações, a bola 1 está na caixa 3, a bola 2 está na caixa 1, e a bola 3 está na caixa 2. Portanto, a saída será os números 3, 1, 2 nesta ordem, separados por uma quebra de linha.
##### Explicação do exemplo de entrada/saída 2:
Após todas as operações, a bola 1 está na caixa 1, a bola 2 está na caixa 2, e a bola 3 está na caixa 3. Portanto, a saída será os números 1, 2, e 3 nesta ordem, separados por uma quebra de linha. |
2,697 | 2288 | Deliv-e-droid | Fácil | Basicos | No jogo Deliv-e-droid, um robô droid precisa entregar pacotes e evitar obstáculos. No final do jogo, a pontuação final é calculada com base no seguinte sistema de pontos:
* Ganho de 50 pontos para cada pacote entregue.
* Perda de 10 pontos por cada colisão com um obstáculo.
* Ganho de um bônus de 500 pontos se o número de pacotes entregues for maior que o número de colisões com obstáculos.
Seu trabalho é determinar a pontuação no fim do jogo.
#### Entrada
A entrada consistirá em duas linhas. A primeira linha conterá um número inteiro não negativo $P$, representando o número de pacotes entregues. A segunda linha conterá um número inteiro não negativo $C$, representando o número de colisões com obstáculos.
#### Saída
A saída deverá ser um número inteiro $F$, representando a pontuação final.
##### Explicação Entrada/Saída de Exemplo 1:
Há 5 pacotes entregues, portanto, $5 \times 50 = 250$ pontos são ganhos. Há $2$ colisões, portanto, $2 \times 10 = 20$ pontos são perdidos. Como $5 > 2$, um bônus de 500 pontos é ganho. Portanto, a pontuação final é $250 - 20 + 500 = 730$.
##### Explicação Entrada/Saída de Exemplo 2:
Há 0 pacotes entregues, portanto, $0 \times 50 = 0$ pontos são ganhos. Há 10 colisões, portanto, são perdidos $10 \times 10 = 100$ pontos. Como $0 \le 10$ , nenhum ponto de bônus é ganho. Portanto, a pontuação final é $0 - 100 + 0 = -100$. |
2,698 | 946 | Espantalho | Difícil | Basicos | Seu osaías é dono de uma fazenda de produção de caju. Sua fazenda é muito bem organizada em um terreno retangular de $N$ por $M$ metros e cada pé de caju é plantado em um quadrado 1x1 metros perfeitamente alinhados em um padrão de grade e chamado de lote. Cada pé de caju produz uma quantidade fixa de Caju mensalmente.
Recentemente sua plantação vem sofrendo muito ataque de corvos então seu Osaías decidiu colocar um espantalho bem no centro de produção da fazenda. O centro de produção é o lote de 1 metro quadrado que divide a fazenda em 4 setores retangulares tais que a soma da produção total de cada setor seja igual. Tal lote sempre pertence ao setor superior esquerdo e é sua posição mais inferior e à direita.
Ajude seu Osaías a identificar todos possíveis lotes possíveis para posicionar o Espantalho.
#### Entrada
A primeira linha da entrada contém dois inteiros $N$ e $M$ representando as dimensões da fazenda de cajú. Cada uma das $N$ linhas seguintes contém $M$ inteiros entre 0 e 1000 que representam a produção de cada pé de caju em cada lote. O primeiro número da primeira linha informada é considerado o lote superior esquerdo da fazenda.
#### Saída
A saída consiste de um ou mais pares de inteiros representando as coordenadas de todos os lotes que podem abrigar o espantalho. Um par por linha da saída, com o primeiro inteiro representando a linha e o segundo, a coluna do lote. Se houver mais de uma posição, estas devem ser ordenadas primeiro pela linha, depois pela coluna. Se não houver nenhuma posição possível imprima -1.
#### Restrições
* $0 \leq N, M \leq 10^{3}$
##### Informações sobre a pontuação
* Em um conjunto de testes valendo 10 pontos, $N\leq10$ e $M\leq10$.
* Em um conjunto de testes valendo 20 pontos, $N \leq 10^2$ e $M\leq 10^2$.
* Em um conjunto de testes valendo 70 pontos, não há restrições adicionais
|
2,699 | 2289 | Pimenta | Fácil | Basicos | Ron está cozinhando chili usando uma variedade de pimentas.
A picância de uma pimenta é medida em unidades de calor Scoville (SHU). No momento, o chili do Ron não está nem um pouco picante, mas a cada vez que ele adiciona uma pimenta, a picância total do chili aumenta de acordo com o valor de SHU dessa pimenta.
Os valores de SHU das pimentas disponíveis para o Ron são mostrados na tabela a seguir:
| Nome da pimenta | Unidades de Calor Scoville |
| :---: | :---: |
| Poblano | 1500 |
| Mirasol | 6000 |
| Serrano | 15500 |
| Cayenne | 40000 |
| Thai | 75000 |
| Habanero | 125000 |
Sua tarefa é determinar o grau de picância total do chili do Ron depois que ele terminar de adicionar as pimentas.
#### Entrada
A primeira linha de entrada conterá um número inteiro positivo $N$, representando o número de pimentas que Ron adiciona ao seu chili. As próximas linhas $N$ conterão, cada uma, o nome de uma pimenta que Ron adicionou. Cada nome de pimenta corresponderá exatamente a um nome que aparece na tabela acima. Observe que mais de uma pimenta com o mesmo nome pode ser adicionada.
#### Saída
A saída consistirá em um número inteiro positivo $T$, representando a picância total do chili do Ron.
##### Explicação Entrada/saída de Exemplo:
Uma pimenta Poblano tem um valor de SHU de $1500$. Uma pimenta Cayenne tem um valor de SHU de $40000$. Uma pimenta Thai tem um valor de SHU de $75000$. A picância é, portanto, $1500 + 40000 + 75000 + 1500 = 118000$. |
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.