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,300 | 3375 | Divisão Longa | Médio | AD-HOC | Você se lembra de como foi difícil quando você foi ensinado a realizar uma divisão longa pela primeira vez? Até hoje, muitos estudantes (e adultos, aliás) acham difícil fazer uma divisão longa à mão. Caso você tenha esquecido, dê uma olhada no problema simples abaixo, 22 dividido por 4 é 5 e o resto é 2. Neste exemplo, 22 é o dividendo, 4 é o divisor, 5 é o quociente, enquanto 2 é o restante.
Escreva um programa que ilustre todas as etapas executadas em uma divisão longa. Nota: Neste problema, é importante que a saída do seu programa corresponda à saída do programa do juiz em todos os detalhes. Leia as instruções fornecidas no formato de saída e estude o exemplo fornecido.
Entrada
Seu programa será testado em diversos casos de teste. Cada caso de teste é especificado em uma linha separada. Para cada caso de teste, dois inteiros serão dados: primeiro o dividendo, depois o divisor. Ambos são números positivos menores que 1,000,000,000. O final dos casos de teste é uma linha cujo divisor é 0 (o que, é claro, não faz parte dos casos de teste).
Saída
Sua saída deve seguir os seguintes pontos:
A saída dos casos de teste será separada por uma única linha em branco. Caso contrário, a saída não contém nenhuma linha em branco.
Há exatamente um caractere de espaço à esquerda do divisor.
Não deve haver espaços à direita em nenhuma das linhas.
Não deve haver zeros à esquerda em nenhum dos números.
Não deve haver etapas desnecessárias de multiplicação e/ou subtração, como, por exemplo, resultante da multiplicação por 0.
Dígitos, espaços e barras de separação (feitos de um ou mais '-') devem ter comprimento e alinhamento exatos como nos exemplos.
Exemplo de Entrada Exemplo de Saída
22 4
102478 83
3811 37
10 83
0 0
5 r 2
+---
4 | 22
20
--
2
1234 r 56
+-------
83 | 102478
83
--
19478
166
---
2878
249
---
388
332
---
56
103 r 0
+-----
37 | 3811
37
--
111
111
---
0
0 r 10
+---
83 | 10
Arab and North Africa Seventh Regional Contest |
2,301 | 3376 | Sobreposição Parcial | Médio | AD-HOC | Imagine uma grade retangular de letras de tamanho R × C. Como você pode ver na figura ao lado, duas cópias exatas dessa grade podem ser parcialmente sobrepostas apenas deslizando uma das cópias horizontalmente e/ou verticalmente.
Escreva um programa que imprima o resultado dessas grades sobrepostas.
Entrada
Seu programa será testado em um ou mais casos de teste. Cada caso de teste é descrito usando R + 1 linhas. A primeira linha contém dois inteiros positivos: R é o número de linhas da grade e C é o número de colunas. Os dados na grade são especificados nas linhas R a seguir. cada linha representa uma linha e é composta por caracteres alfabéticos C que diferenciam maiúsculas de minúsculas. Observe que R, C < 1000.
O fim dos casos de teste é especificado usando um caso de teste fictício em que R ou C é zero.
Saída
Para cada caso de teste, imprima o formato das grades sobrepostas. Se não houver sobreposição, imprima a própria grade. Se houver mais de uma possibilidade de sobreposição, imprima o arranjo com o maior número de letras compartilhadas. Se houver mais de um arranjo com o maior número de letras compartilhadas, imprima qualquer um deles. Após a saída de cada caso de teste, imprima uma linha composta por x '+' caracteres onde x é igual ao número de colunas usadas para imprimir a saída desse caso de teste.
Exemplo de Entrada Exemplo de Saída
4 6
ABCDEF
GHABCD
IJGHAB
KLIJGH
2 2
ab
AB
3 4
abpq
pqrs
rsab
0 0
ABCDEF
GHABCDEF
IJGHABCD
KLIJGHAB
KLIJGH
++++++++
ab
AB
++
abpq
abpqrs
pqrsab
rsab
++++++
Arab and North Africa Seventh Regional Contest |
2,302 | 3377 | Geometria?! Por que não?? | Médio | AD-HOC | Considere um caminho 2D desenhado da seguinte maneira: Começando no ponto de origem, podemos mover apenas para cima ou para a direita. O caminho será descrito como uma string feita de zero ou mais letras {'U','R'}. Para cada 'U' moveremos uma unidade para cima, enquanto 'R' moveremos uma unidade para a direita. No figura seguinte, o caminho construído pela string RRRURRUUURRRRRRUUR é desenhado em uma linha grossa.
Imagine agora que desenhamos uma linha reta que liga o ponto de origem ao último ponto do caminho. (A linha desenhada em pontos na figura acima.) A intenção é calcular a área total que fica entre a linha reta e o caminho (a área cinza na figura acima).
Entrada
Seu programa será testado em um ou mais casos de teste. Cada caso de teste é descrito em uma linha separada. O caminho de cada caso de teste é descrito como uma string composta por uma ou mais letras {'U','R'} e terminada pela letra 'S'.
Todos os caminhos dos casos de teste podem ser desenhados em uma grade de tamanho 1.000 × 1.000.
A última linha do arquivo de entrada é composta por um único caractere 'S' e não faz parte dos casos de teste.
Saída
Para cada caso de teste, escreva o resultado em uma linha separada usando o seguinte formato:
k. a
onde k é o número do caso de teste (começando em 1.) e a é a área arredondada para três casas decimais.
Exemplo de Entrada Exemplo de Saída
RRRURRUUURRRRRUURS
RUURS
S
1. 8.515
2. 1.000
Arab and North Africa Seventh Regional Contest |
2,303 | 3378 | Blocos indistinguíveis | Médio | AD-HOC | De quantas maneiras você pode organizar N blocos (cubos) idênticos em pilhas. Por exemplo, para N = 3 existem três arranjos:
Lembre-se, os blocos são idênticos. Para N = 4 existem 5 arranjos:
Escreva um programa que determine quantos arranjos existem para N.
Entrada
Seu programa será testado em um ou mais casos de teste. Cada caso de teste será especificado como um único número natural (indicando N, o número de blocos indistinguíveis) em uma linha separada. O final dos casos de teste é identificado por um número negativo (que não faz parte dos casos de teste).
Observe que 0 ≤ N ≤ 120.
Saída
Para cada caso de teste, seu programa deve imprimir o resultado usando o seguinte formato:
N => P
Onde N é o número de blocos indistinguíveis para o caso de teste e P é o resultado.
Exemplo de Entrada Exemplo de Saída
1
3
5
-1
1 => 1
3 => 3
5 => 7
Arab and North Africa Seventh Regional Contest |
2,304 | 3379 | Chop Ahoy! | Médio | AD-HOC | Dados dois números, como por exemplo 506 e 119, queremos determinar se é possível transformar o primeiro no segundo usando o seguinte processo: Comece com o primeiro número, cortando-o como quiser, por exemplo, 50 e 6 (daqui em diante escrito como 50.6.) Agora faça o quadrado das peças e some-as (502 + 62 = 2536.) Agora repita o mesmo processo no resultado. Digamos que decidimos cortá-lo em 2.53.6, dando-nos o número 2849. Em cada etapa, divida o número resultante da maneira que desejar, em uma ou mais partes, depois adicione os quadrados das partes. Como mostrado abaixo, em 5 passos, podemos transformar 506 em 119.
50.6 ⇒ 2.53.6 ⇒ 2.849 ⇒ 72.0.80.5 ⇒ 1.1.6.0.9 ⇒ 119
No entanto, poderíamos ter transformado 506 em 119 em apenas quatro etapas, conforme mostrado abaixo:
50.6 ⇒ 2536 ⇒ 64.31.2.96 ⇒ 1.4.2.7.7 ⇒ 119
Escreva um programa que receba dois números naturais S e D e determine o número mínimo de etapas para transformar B em D. Seu programa deve imprimir -1 se a transformação não puder ser executada em 8 etapas ou menos. Os números intermediários não podem ser maiores ou iguais a 10.000.000.
Entrada
Seu programa será testado em um ou mais casos de teste. Cada caso de teste é especificado em uma única linha contendo dois números naturais S e D separados por um único caractere de espaço.
Observe que 0 ≤ S, D < 10,000,000
A última linha do arquivo de entrada é composta por dois zeros e não faz parte dos casos de teste.
Saída
Para cada caso de teste, escreva o resultado em uma linha separada usando o seguinte formulário:
k. resultado
onde k é o número do caso de teste (a partir de 1.)
Exemplo de Entrada Exemplo de Saída
506 119
2003 2004
0 0
1. 4
2. 5
Arab and North Africa Seventh Regional Contest |
2,305 | 3380 | Dá um tempo! | Médio | AD-HOC | Você já notou que algumas palavras em inglês podem ser divididas em duas ou mais palavras? Tomemos por exemplo a palavra 'sunday' ('domingo') que pode ser quebrada em 'sun' e 'day' ('sol' e 'dia'). Outros exemplos incluem: airbag (air.bag), adjust (ad.just), e weathering (we.at.he.ring).
Escreva um programa que leia um dicionário de palavras e imprima o número de palavras desse dicionário que podem ser divididas em duas ou mais subpalavras (todas dentro do mesmo dicionário) onde nenhuma subpalavra é menor que 3 letras. Nesse caso é insignificante.
Entrada
Seu programa será testado em um ou mais casos de teste. O dicionário de cada caso de teste será fornecido como uma lista de palavras com cada palavra especificada em uma linha separada.
O fim de um dicionário é indicado com uma linha composta por caracteres '-', exceto o dicionário do último caso de teste que terminará com uma linha composta por caracteres '+'.
Cada dicionário tem pelo menos uma palavra, mas não mais de 50.000 palavras. Cada palavra tem pelo menos um caractere, mas não mais que 16 caracteres. Todas as palavras serão feitas apenas de caracteres alfabéticos.
Saída
Para cada dicionário, escreva o resultado em uma linha separada.
Exemplo de Entrada Exemplo de Saída
bag
sun
day
moon
Sunday
Monday
airbag
MoonBag
----
straw
black
blue
berry
raspberry
strawberry
blueberry
blackberry
cranberry
HalleBerry
+++
2
3
Arab and North Africa Seventh Regional Contest |
2,306 | 3381 | Um por todos. Todos por tudo que existe | Médio | AD-HOC | Dada uma função booleana de N variáveis, escreva um programa para determinar a validade de consultas envolvendo quantificações universais (for-all) e existenciais (there-exists). Considere, por exemplo, a seguinte função booleana de três variáveis x, y e z:
Aqui está um exemplo de consultas para resolver:
∀x ∀y ∀z
a resposta é falsa, pois nem todas as combinações são verdadeiras.
∃y ∀z ∃x
A resposta é verdadeira. Para y=1, temos um valor para x fornecendo um resultado verdadeiro para cada valor de z:
<z=1,x=2> and <z=2,x=1> and <z=3,x=1> and <z=4,x=1|2>
∃x ∀z ∃y
A resposta é verdadeira para x=2.
Entrada
Seu programa será testado em vários casos de teste. Cada caso de teste é especificado usando Q+3 linhas.
As duas primeiras linhas de um caso de teste especificam a função booleana enquanto as linhas restantes especificam as consultas para esse caso de teste. A primeira linha inclui N+1 números positivos. O primeiro número é N, que é o número de variáveis. Os restantes N números são D1, D2, ... DN onde Di é o número de valor vi (a i-ésima variável)
A segunda linha é composta por D1 ∗ D2 ∗ ... ∗ DN ’T’ ou ’F’ (verdadeiro ou falso) especificando os valores da função, na ordem principal das linhas.
A terceira linha inclui um único valor positivo Q representando o número de consultas. Cada consulta é especificada em uma linha separada usando N pares, um para cada variável (todas as consultas envolverão todas as variáveis.) Cada par é descrito usando duas partes: A primeira parte representa a quantificação e é uma das duas letras: 'A' (for-all) e 'E' (there-exists). A segunda parte é um número que representa o número da variável. Por exemplo, a consulta A2E1 significa ∀v2 ∃v1.
Casos de teste consecutivos são separados por uma única linha em branco. O fim dos casos de teste é especificado usando um caso de teste fictício com N=0.
O número de variáveis é menor que 10. O número de valores para qualquer variável não excederá 10. No entanto, D1 ∗ D2 ∗ ... ∗ DN não excederá 1.000.000.
O caso de teste na seção de Sample I/O (exemplos de Entrada/Saída) representa o exemplo usado na descrição do problema.
Saída
Para cada caso de teste, imprima a seguinte linha:
Test_case_#_k
onde k é o número do caso de teste (começando em 1.) Para cada consulta, imprima a seguinte linha:
_ Query_#_k_is_r
onde k é o número da consulta (começando em 1) e r é o resultado da consulta (verdadeiro ou falso).
Exemplo de Entrada Exemplo de Saída
3 2 3 4
FTTTFFTFFFFFTFFTTTFFFFTF
3
A1A2A3
E2A3E1
E1A3E2
2 2 2
TFTF
6
A2A1
A2E1
A1E2
E1A2
E2A1
E1E2
0
Test case # 1
Query # 1 is false.
Query # 2 is true.
Query # 3 is true.
Test case # 2
Query # 1 is false.
Query # 2 is false.
Query # 3 is true.
Query # 4 is false.
Query # 5 is true.
Query # 6 is true.
Arab and North Africa Seventh Regional Contest |
2,307 | 3382 | Seja esperto! | Médio | AD-HOC | Um mecanismo de modelo da Web é um software projetado para processar modelos da Web e informações de conteúdo para produzir documentos da Web. Um modelo é uma página html, mas sem o conteúdo. De certa forma, um sistema de templates facilita a separação entre as informações de uma página web e a apresentação da mesma.
Um sistema de templates normalmente vem com uma linguagem de programação (restrita e especializada) para permitir a variação da apresentação dependendo de certas propriedades da informação. Por exemplo, ao apresentar um extrato bancário, o banco pode decidir exibir em vermelho qualquer transação com valor acima de US$ 1.000 para chamar a atenção do usuário.
Outra técnica, frequentemente usada na impressão de tabelas, é alternar a cor de fundo das linhas para facilitar o acompanhamento visual de uma linha pelo leitor. Por exemplo, a cor de fundo na Tabela (a) alterna após cada linha, enquanto na Tabela (b) a cor alterna a cada três linhas.
Uma linguagem de modelo projetada adequadamente teria uma construção para permitir que o designer alterne as propriedades das linhas da tabela. Neste problema, vamos nos concentrar em uma dessas construções que recebe três argumentos: N, P1, e P2. O mecanismo de modelo aplicaria então P1 nas primeiras N linhas, P2 nas segundas N linhas e, em seguida, de volta a P1 nas terceiras N linhas e assim por diante.
Escreva um programa que pegue o número da linha atual (começando em um), o número N e as propriedades P1 e P2 e determine qual de P1 ou P2 deve ser aplicado à linha atual.
Entrada
Seu programa será testado em um ou mais casos de teste. Cada caso de teste é especificado em uma linha separada. Cada linha especifica quatro valores: R, N, P1, e P2, todos separados por um ou mais espaços. R é o número da linha atual (a primeira linha é numerada como 1), enquanto N é como descrito acima. Observe que:
0 < R, N < 1, 000, 000, 000.
P1 e P2 são propriedades. Uma propriedade é uma string feita de letras maiúsculas ou minúsculas, dígitos e/ou espaços. Uma propriedade pode estar entre aspas duplas (mas as aspas duplas não fazem parte da propriedade). Se uma propriedade contiver espaços, as aspas duplas ao redor são obrigatórias. Nenhuma propriedade terá mais de 512 caracteres (incluindo aspas duplas, se presentes).
A última linha do arquivo de entrada é composta por um único zero.
Saída
Para cada caso de teste, imprima o resultado em uma única linha usando o seguinte formato:
k._resultado
Onde k é o número do caso de teste (começando em 1) e o resultado é P1 e P2. Observe que as aspas duplas nunca são impressas. Além disso, todas as letras são impressas em minúsculas.
Exemplo de Entrada Exemplo de Saída
1 1 red blue
2 1 red blue
3 1 red blue
6 3 "big font" "small font"
0
1. red
2. blue
3. red
4. small font
Arab and North African Ninth Regional Contest |
2,308 | 3383 | O jogo Tetris | Médio | AD-HOC | Tetris é um famoso videogame que possui 5 peças semelhantes a estas:
Neste problema, você recebe uma grade de NxN inteiros. Queremos colocar uma única peça de Tetris na grade de modo que a soma dos números abaixo da peça seja máxima. Observe que todas, exceto a última peça de Tetris, podem ser giradas em 90 graus. Algumas peças até têm quatro orientações diferentes.
Qualquer orientação é aceitável desde que a peça se encaixe completamente dentro da grade. Por exemplo, a peça mais à esquerda pode ser colocada na primeira linha da grade, com uma soma de 80. Também pode ser colocada, por exemplo, na terceira coluna, resultando em uma soma de 91. Na verdade , em uma grade 4x4, podemos ter 77 maneiras diferentes de colocar as peças de Tetris. Na grade de amostra mostrada abaixo, a maior soma que pode ser alcançada é 120.
Escreva um programa que determine a maior soma desse tipo para uma dada grade.
Entrada
Seu programa será testado em um ou mais casos de teste. A primeira linha de um caso de teste tem um único inteiro N denotando o tamanho da grade onde 4≤N≤100. A grade será especificada usando N linhas começando na segunda linha em um formato principal de linha. Cada linha terá N inteiros separados por um ou mais espaços.
O valor absoluto de cada inteiro na grade não excederá 1.000.000.
O final dos casos de entrada é especificado por um zero em uma linha separada.
Saída
Para cada caso de teste, imprima o resultado em uma única linha usando o seguinte formato:
k._resultado
Onde k é o número do caso de teste (começando em 1) e resultado é a maior soma que pode ser obtida.
Exemplo de Entrada Exemplo de Saída
4
70 2 1 7
7 1 30 6
4 30 30 5
3 1 30 2
0
1. 120
Arab and North African Ninth Regional Contest |
2,309 | 3384 | Blocos de Madeira | Médio | AD-HOC | Blocos de Madeira é um jogo onde você recebe peças de madeira que vêm em oito formas, conforme mostrado abaixo:
O objetivo do jogo é montar o retângulo mais largo que pode ser feito de um subconjunto das peças dadas com as seguintes condições:
O retângulo deve ter bordas lisas. Em outras palavras, a peça mais à esquerda deve ser (peça nº 1) e a peça mais à direita deve ser (peça nº 2).
As peças adjacentes devem se encaixar corretamente. Por exemplo, a peça #4 ou a peça #5 devem aparecer à direita da peça #1. Da mesma forma, a peça #4 pode aparecer à direita da peça #1 ou da peça #3.
Nenhuma peça se encaixa à esquerda da peça #1. Nenhuma peça se encaixa à direita da peça #2.
Para cada peça #1, o retângulo deve ter uma peça #2 correspondente. Da mesma forma, para cada peça #5, deve haver uma peça #6 correspondente./li>
Por exemplo, os dois exemplos a seguir são arranjos válidos:
Considerando que os três seguintes não são:
Uma empresa de informática está interessada em construir um videogame dos Blocos de Madeira e contratou você para escrever um programa que determina se a disposição de uma determinada peça é válida de acordo com as regras acima ou não.
Entrada
Seu programa será testado em um ou mais casos de teste. Cada caso de teste é especificado em uma linha de entrada separada. Cada peça é especificada usando o dígito associado a ela como na figura anterior. Um arranjo é especificado listando seus dígitos sem espaços entre os dígitos. Cada arranjo terá pelo menos uma peça, mas não mais que 10.000 peças.
A última linha no arquivo de entrada terá um único 0. Essa linha não faz parte dos casos de teste.
Saída
Para cada caso de teste, imprima o resultado em uma única linha usando o seguinte formato:
k._resultado
Onde k é o número do caso de teste (começando em 1) e o resultado é "VALID" se o arranjo for válido, ou "NOT" se não for.
Exemplo de Entrada Exemplo de Saída
142
1587862
132
143
0
1. VALID
2. VALID
3. NOT
4. NOT
Arab and North African Ninth Regional Contest |
2,310 | 3385 | Caminhe como um egípcio | Médio | AD-HOC | Caminhe como um egípcio é um antigo jogo de tabuleiro multijogador jogado por crianças das tribos nômades do Saara. Antigamente, as crianças coletavam pedras e numeravam cada uma delas. Um jogo com N jogadores requer N2 pedras. Cada jogador escolhe N pedras. As pedras são então dispostas em uma grade N × N em uma ordem peculiar como na Figura (a) (para N = 4). O jogador cuja pedra é colocada no canto superior direito perde a rodada. Outra rodada é então jogada, mas com N-1 jogadores. No total, N−1 rodadas são jogadas para determinar o vencedor.
Há uma história de por que as pedras estão dispostas nesta ordem. Conta-se que na época dos faraós, ao entrar em uma sala escura de uma pirâmide, os trabalhadores usavam o seguinte “algoritmo” para poder andar na sala sem perder ninguém: (ver Figura (b)).
O primeiro trabalhador fica no canto inferior esquerdo da sala.
Os próximos três trabalhadores ficam ao redor do primeiro formando um quarto de círculo no sentido anti-horário.
Os próximos cinco trabalhadores ficam ao redor dos três últimos, novamente formando um quarto de círculo, mas desta vez no sentido horário.
Os trabalhadores continuam repetindo os dois últimos passos até que a sala esteja cheia de trabalhadores. Cada vez que atingem as paredes esquerda ou inferior, eles iniciam um quarto de círculo maior e alternam sua direção entre o sentido horário e anti-horário.
Escreva um programa que determine a pedra colocada no canto superior direito.
Entrada
Seu programa será testado em um ou mais casos de teste. Cada caso de teste é especificado em uma linha de entrada separada. Cada caso de teste especificará o número de jogadores N onde 0<N<1.000.
O final dos casos de teste é indicado por uma linha feita de um único zero.
Saída
Para cada caso de teste, imprima o resultado em uma única linha usando o seguinte formato:
N => resultado
Onde Né o número de jogadores para este caso de teste e resultado é o número da pedra colocada no canto superior direito da grade.
Exemplo de Entrada Exemplo de Saída
4
2
0
4 => 13
2 => 3
Arab and North African Ninth Regional Contest |
2,311 | 3386 | O Excelente Saara | Médio | AD-HOC | Sahara é um jogo de tabuleiro para dois jogadores jogado em uma grade em forma de hexágono feita de 54 triângulos como o mostrado na Figura (a). Cada jogador tem 6 pirâmides (tetraeder), inicialmente colocadas conforme a Figura (b). O jogador um tem as pirâmides escuras, o jogador dois tem as mais claras. Os jogadores se revezam em mover uma de suas próprias pirâmides. Uma pirâmide é movida inclinando a pirâmide de lado em um espaço adjacente. Por exemplo, uma pirâmide no local 11 pode ser movida para o local 3, 10 ou 12 (assumindo que o local de destino está livre).
O objetivo do jogo é prender uma pirâmide do oponente. Uma pirâmide está presa se não puder ser movida.
Por exemplo, uma pirâmide no local 11 está presa se os locais 3, 10 e 12 estiverem todos ocupados (independentemente de quais pirâmides do jogador ocupam esses locais). Da mesma forma, uma pirâmide no local 28 está presa se ambos os locais 17 e 29 estiverem ocupados. Por exemplo, na Figura (c) o jogador um pode ganhar o jogo movendo sua pirâmide do local 30 para o local 29 e, assim, prendendo a pirâmide do oponente no local 28. O primeiro caso de teste corresponde à figura (c) enquanto o segundo à figura (d).
Escreva um programa que determine se o primeiro jogador pode prender a pirâmide de um oponente em um único movimento
Entrada
Seu programa será testado em um ou mais casos de teste. Cada caso de teste é especificado em uma única linha. Cada caso de teste é composto por 12 números no intervalo [1,54]. Os primeiros seis números especificam as localizações das pirâmides do primeiro jogador. Os últimos seis são para o segundo jogador. Os locais são numerados da mesma forma que na Figura (a). Os números são separados usando um ou mais espaços. Todos os casos de teste especificam uma posição de jogo válida onde nenhuma pirâmide está presa.
A última linha do arquivo de entrada terá um único zero.
Saída
Para cada caso de teste, imprima o resultado em uma única linha usando o seguinte formato:
k._resultado
Onde k é o número do caso de teste (começando em 1,) e o resultado é "TRAPPED" se o primeiro jogador conseguir prender uma pirâmide do oponente movendo uma de suas pirâmides. Caso contrário, o resultado é "FREE".
Exemplo de Entrada Exemplo de Saída
30 2 7 44 22 45 28 41 46 17 27 1
30 2 7 44 22 45 28 41 46 18 27 1
0
1. TRAPPED
2. FREE
Arab and North African Ninth Regional Contest |
2,312 | 3387 | Johnny odeia a Teoria dos Números | Médio | AD-HOC | Johnny odeia a Teoria dos Números! Na verdade, em 2002, soubemos que Johnny não sabia contar e em 2005 sabíamos que Johnny ainda não sabia somar. (Mas nós sabíamos em 2003 que Johnny era esperto o suficiente para resolver problemas gráficos difíceis!) Por que Johnny decidiu estudar Teoria dos Números é incompreensível para nós.
De qualquer forma, de volta ao Johnny. Johnny acabou de ser reprovado em seu exame abrangente e isso foi tudo por causa da função Totient de Euler (φ). Johnny fica com tanta raiva que decide criar sua própria função Totient. Veja como ele descreveu isso para seu orientador:
Na teoria dos números, os fatores primos de um inteiro positivo são os números primos que se dividem exatamente nesse inteiro, sem deixar resto. Johnny define a função F(n), para n ≥ 2, como sendo a lista não decrescente de números primos cujo produto é n. Por exemplo, F(8) = 2, 2, 2, F(60) = «2, 2, 3, 5» e F(71) = «71» (71 é um número primo). Seja O(n) o comprimento da lista F(n)(ou seja, seu ordinal.) Por exemplo, O(8) = 3, O(60) = 4 y O(71) = 1. Johnny também define a função p(n) sobre inteiros positivos como segue:
A tabela a seguir ilustra p(n) para os primeiros vinte inteiros positivos:
Dados dois inteiros positivos a e b onde a ≤ b, Johnny define sua própria função Totient φ(a, b) da seguinte forma:
Por exemplo, φ(1, 4) = −4, φ(16, 16) = 3, e φ(8, 12) = 4.
Para sua dissertação, Johnny precisa de um programa que determine o φ máximo dentro de um determinado intervalo [I, U]. Em outras palavras, dados dois inteiros positivos L, U tais que L ≤ U, o programa deve encontrar o máximo φ(a, b) onde L ≤ a ≤ b ≤ U. Por exemplo, o máximo φ dentro do intervalo [1, 20] é 7 (que é φ(8, 16).
Escreva o programa que Johnny precisa!
Entrada
Seu programa será testado em um ou mais casos de teste. Cada caso de teste é especificado em uma única linha. Cada caso de teste é especificado usando dois inteiros positivos L e U separados por um ou mais espaços e satisfazendo a seguinte propriedade: 1 ≤ L ≤ U < 1, 000, 000.
O final dos casos de teste é indicado por uma linha composta por dois -1's. Essa última linha não faz parte dos casos de teste.
Saída
Para cada caso de teste, imprima o resultado em uma única linha usando o seguinte formato:
k._resultado
Onde k é o número do caso de teste (começando em 1,) e resultado é o φ máximo que pode ser encontrado dentro do intervalo [L, U].
Exemplo de Entrada Exemplo de Saída
1 5
1 20
10 20
900000 901000
-1 -1
1. 1
2. 7
3. 5
4. 2551
Arab and North African Ninth Regional Contest |
2,313 | 1 | Olá Neps Academy | Muito Fácil | Basicos | Esse é o primeiro problema que você deve resolver. Normalmente problemas terão uma entrada e uma saída esperada, mas por enquanto vamos começar com um problema bem simples, onde você deve apenas imprimir uma mensagem na tela do computador.
Dessa forma, para resolver esse problema você deve apenas imprimir a mensagem "Ola Neps Academy!" na tela do computador.
Para enviar o código contendo sua solução, você deve usar os botões que se encontram no topo dessa página. O botão para enviar sua solução é identificado pelo símbolo do avião de papel.
#### Entrada
Nesse problema especial você não precisa ler nenhuma informação como entrada.
#### Saída
A saída do seu programa deve ser apenas a frase "Ola Neps Academy!" (sem as aspas). Não se esqueça de adicionar o sinal de exclamação no final.
|
2,314 | 134 | Soma Fácil | Muito Fácil | Basicos | Faça um programa para ler dois valores inteiros $A$ e $B$ e imprima o resultado da expressão $(A+B)$.
#### Entrada
A entrada consiste de duas linhas. A primeira linha contém o inteiro $A$ e a segunda linha contém o inteiro $B$.
#### Saída
A saída consiste de uma linha contendo o resultado da expressão $(A+B)$.
#### Restrições
* Os inteiros fornecidos não terão valor absoluto maior que 1000. |
2,315 | 136 | Média Inteira | Muito Fácil | Basicos | Faça um programa para ler dois valores inteiros $A$ e $B$ e imprima a média inteira dos valores $A$ e $B$.
#### Entrada
A entrada consiste de duas linhas. A primeira linha contém o inteiro $A$ e a segunda linha contém o inteiro $B$.
#### Saída
A saída consiste de uma linha contendo a média inteira dos valores $A$ e $B$.
#### Restrições
* Os inteiros fornecidos não terem valor absoluto maior que 1000.
|
2,316 | 138 | Área do Quadrado | Muito Fácil | Basicos | Faça um programa para um inteiro $L$ e imprima a área de uma quadrado de lado $L$.
#### Entrada
A entrada consiste de uma linha contendo um inteiro $L$.
#### Saída
A saída consiste de uma linha contendo a área do quadrado de lado $L$.
#### Restrições
* Os inteiros fornecidos não terem valor maior que 1000 ou menor que 1 |
2,317 | 87 | Flíper | Fácil | Basicos | Flíper é um tipo de jogo onde uma bolinha de metal cai por um labirinto de caminhos até chegar na parte de baixo do labirinto. A quantidade de pontos que o jogador ganha depende do caminho que a bolinha seguir. O jogador pode controlar o percurso da bolinha mudando a posição de algumas portinhas do labirinto. Cada portinha pode estar na posição 0, que significa virada para a esquerda, ou na posição 1 que quer dizer virada para a direita. Considere o flíper da figura abaixo, que tem duas portinhas. A portinha $P$ está na posição 1 e a portinha $R$, na posição 0. Desse jeito, a bolinha vai cair pelo caminho B.
Você deve escrever um programa que, dadas as posições das portinhas $P$ e $R$, neste flíper da figura, diga por qual dos três caminhos, A, B ou C, a bolinha vai cair!
#### Entrada
A entrada é composta por apenas uma linha contendo dois números $P$ e $R$, indicando as posições das duas portinhas do flíper da figura.
#### Saída
A saída do seu programa deve ser também apenas uma linha, contendo uma letra maiúscula que indica o caminho por onde a bolinha vai cair: 'A', 'B' ou 'C'.
#### Restrições
* O número $P$ pode ser 0 ou 1. O número $R$ pode ser 0 ou 1.
|
2,318 | 145 | Positivo, Negativo ou Nulo | Muito Fácil | Basicos | Faça um programa para ler um inteiro $x$. Imprima a mensagem "positivo" se o valor for positivo. Imprima a mensagem "negativo" caso o valor seja negativo. Imprima a mensagem "nulo" se o valor for zero.
#### Entrada
A entrada consiste de uma linha contendo um inteiro.
#### Saída
A saída consiste de uma linha contendo uma mensagem.
#### Restrições
* o valor fornecido não terá valor absoluto maior que 1000. |
2,319 | 13 | Bondinho | Muito Fácil | Basicos | A turma do colégio vai fazer uma excursão na serra e todos os alunos e monitores vão tomar um bondinho para subir até o pico de uma montanha. A cabine do bondinho pode levar 50 pessoas no máximo, contando alunos e monitores, durante uma viagem até o pico.
Neste problema, dado como entrada o número de alunos $A$ e o número de monitores $M$, você deve escrever um programa que diga se é possível ou não levar todos os alunos e monitores em apenas uma viagem!
#### Entrada
A primeira linha da entrada contém um inteiro $A$, representando a quantidade de alunos. A segunda linha da entrada contém um inteiro $M$, representando o número de monitores.
#### Saída
Seu programa deve imprimir uma linha contendo o caractere $S$ se é possível levar todos os alunos e monitores em apenas uma viagem, ou o caractere $N$ caso não seja possível.
#### Restrições
* $1 \leq A \leq 50$
* $1 \leq M \leq 50$
|
2,320 | 148 | Par ou Ímpar | Fácil | Basicos | Bino e Cino gostam muito de brincar de par ou ímpar. Bino sempre escolhe par e Cino sempre escolhe ímpar.
Faça um programa para automatizar o resultado o jogo de par ou ímpar. Seu programa deve ler a quantidade de dedos que cada um utilizou e imprimir o nome do ganhador.
#### Entrada
A entrada consiste de duas linhas. A primeira linha contém a quantidade de dedos que Bino utilizou. A segunda linha contém a quantidade de dedos que Cino utilizou.
#### Saída
A saída consiste de uma linha. Caso Bino vença o jogo, imprima "Bino". Caso Cino vença o jogo, imprima "Cino".
#### Restrições
* Como Bino e Cino só tem 10 dedos (contando as duas mãos), os valores fornecidos serão valores entre 0 e 10. |
2,321 | 212 | Olá CodCad! | Muito Fácil | Basicos | Esse é o primeiro problema que você deve resolver. Normalmente problemas terão uma entrada e uma saída esperada, porém como nós ainda não aprendemos como fazer a entrada de dados para o computador, você deve apenas imprimir uma mensagem na tela do computador.
Dessa forma, para resolver esse problema você deve apenas imprimir a mensagem "Ola CodCad!" na tela do computador.
Para enviar o código contendo sua solução, você deve usar os botões que se encontram no topo dessa página. O botão para enviar sua solução é identificado pelo símbolo do avião de papel (<i class="fas fa-paper-plane"></i>). Você também pode pedir ajuda na secção dos comentários abaixo ou visualizar todas as suas soluções para esse problema utilizando o botão do quebra-cabeça (<i class="fa fa-puzzle-piece"></i>).
#### Entrada
Nesse problema especial você não precisa ler nenhuma informação como entrada.
#### Saida
A saída do seu programa deve ser apenas a frase "Ola CodCad!" (sem as aspas), conforme aprendemos na primeira lição. Note que a palavra "Ola" não tem acento e note também o "!" ao final da frase. <b>Seu programa deve imprimir exatamente como solicitado na questão</b>. |
2,322 | 86 | Aprovado ou Reprovado | Fácil | Basicos | No Colégio Neps Academy (CNA) um aluno é aprovado por média se ele obtiver uma média final maior ou igual a 7, caso o aluno tenha uma média menor que 7 mas maior ou igual a 4 ele está de recuperação, caso ele tenha uma média menor que 4 o aluno está reprovado.
A média é calculada com a nota das duas provas aplicadas no semestre e corresponde simplesmente a média aritimética das duas notas.
Baseado nas duas notas do aluno, indique o resultado final do aluno: "Aprovado", "Reprovado" ou "Recuperacao".
#### Entrada
A entrada consiste de apenas uma linha com as notas $A$ e $B$, que correspondem as duas notas que o aluno conquistou esse semestre.
#### Saída
A saída do seu programa deve ser apenas uma linha. Caso o aluno tenha sido aprovado informe "Aprovado", caso o aluno tenha sido reprovado informe "Reprovado" e caso ele esteja de recuperação informe "Recuperacao". |
2,323 | 84 | Soma | Muito Fácil | Basicos | Faça um programa que leia dois números inteiros digitados pelo teclado e imprima a soma deles.
#### Entrada
A entrada consiste de dois números inteiros $X$ e $Y$, um em cada linha.
#### Saída
A saída do seu programa deve ser um inteiro $S$, representando a soma de $X$ e $Y$.
|
2,324 | 260 | Gangorra | Fácil | Basicos | Joãozinho acaba de mudar de escola e a primeira coisa que percebeu na nova escola é que a gangorra do parquinho não é simétrica, uma das extremidades é mais longa que a outra. Após brincar algumas vezes com um amigo de mesmo peso, ele percebeu que quando está em uma extremidade, a gangorra se desequilibra para o lado dele (ou seja, ele fica na parte de baixo, e o amigo na parte de cima), mas quando eles trocam de lado, a gangorra se desequilibra para o lado do amigo.
Sem entender a situação, Joãozinho pediu ajuda a outro amigo de outra série, que explicou que o comprimento do lado interfere no equilíbrio da gangorra, pois a gangorra estará equilibrada quando $P_1 \cdot C_1 = P_2 \cdot C_2$ onde $P_1$ e $P_2$ são os pesos da criança no lado esquerdo e direito, respectivamente, e $C_1$ e $C_2$ são os comprimentos da gangorra do lado esquerdo e direito, respectivamente.
Com a equação, Joãozinho já consegue dizer se a gangorra está equilibrada ou não mas, além disso, ele quer saber para qual lado a gangorra descerá caso esteja desequilibrada.
#### Entrada
A primeira e única linha da entrada contém 4 inteiros, $P_1$, $C_1$, $P_2$ e $C_2$, nesta ordem.
#### Saída
Seu programa deve produzir uma única linha, contendo um único inteiro. Se a gangorra estiver equilibrada, imprima '0'. Se ela estiver desequilibrada de modo que a criança esquerda esteja na parte de baixo, imprima '-1', senão, imprima '1'.
#### Restrições
* $10 \leq P_1 \leq 100$
* $10 \leq C_1 \leq 100$
* $10 \leq P_2 \leq 100$
* $10 \leq C_2 \leq 100$
|
2,325 | 48 | Prêmio do Milhão | Fácil | Basicos | Alice e Bia criaram uma página na Internet com informações sobre o Macaco-prego-de-peito-amarelo, uma espécie em extinção. A página mostra como todos podem ajudar a manter o habitat natural para evitar que a espécie seja extinta.
Uma empresa gostou tanto da iniciativa de Alice e Bia que prometeu doar um prêmio para que as duas amigas possam realizar outras iniciativas semelhantes. A empresa decidiu que o prêmio seria dado quando a soma do número de acessos à página chegasse a 1 milhão.
Dada a lista de acessos diários que ocorreram à página de Alice e Bia, escreva um programa para determinar quantos dias foram necessários para a soma dos acessos chegar a 1 milhão e as amigas ganharem o prêmio.
#### Entrada
A primeira linha da entrada contém um número inteiro $N$, que indica o número de dias que a lista contém. Cada uma das linhas seguintes contém um único inteiro $A$, o número de acessos em um dia. O primeiro número dado indica o número de acessos no primeiro dia, o segundo número dado indica o número de acessos no segundo dia, e assim por diante.
#### Saída
Seu programa deve escrever na saída uma única linha, contendo um único número inteiro, o número de dias que foram necessários para a soma dos acessos à pagina de Alice e Bia chegar a 1000000.
#### Restrições
* $1 \leq N \leq 10^3$, ou seja, a lista tem no máximo 1000 números
* $0 \leq A \leq 10^6$, ou seja, cada inteiro $A$ da lista é positivo e menor do que ou igual a 1 milhão.
* A soma de todos os valores $A$ da lista é maior do que ou igual a 1 milhão (ou seja, Alice e Bia certamente ganham o prêmio). |
2,326 | 52 | Lâmpadas | Médio | Basicos | Você está de volta em seu hotel na Tailândia depois de um dia de mergulhos. O seu quarto tem duas lâmpadas. Vamos chamá-las de $A$ e $B$. No hotel há dois interruptores, que chamaremos de $I_1$ e $I_2$. Ao apertar $I_1$, a lâmpada $A$ acende se estiver apagada, e apaga se estiver acesa. Se apertar $I_2$, cada uma das lâmpadas $A$ e a $B$ troca de estado: se estiver apagada, fica acesa e se estiver acesa apaga.
As lâmpadas inicialmente estão ambas apagadas. Seu amigo resolveu bolar um desafio para você. Ele irá apertar os interruptores em uma certa sequência, e gostaria que você respondesse o estado final das lâmpadas $A$ e $B$.
#### Entrada
A primeira linha contém um número $N$ que representa quantas vezes seu amigo irá apertar algum interruptor. Na linha seguinte seguirão N números, que pode ser 1, se o interruptor $I_1$ foi apertado, ou 2, se o interruptor $I_2$ foi apertado.
#### Saída
Seu programa deve imprimir dois valores, em linhas separadas. Na primeira linha, imprima 1 se a lâmpada $A$ estiver acesa no final das operações e 0 caso contrário. Na segunda linha, imprima 1 se a lâmpada $B$ estiver acesa no final das operações e 0 caso contrário.
#### Restrições
* $2 \leq N \leq 10^5$
|
2,327 | 85 | Divisão | Fácil | Basicos | Faça um programa que leia dois números reais $A$ e $B$ digitados pelo teclado e imprima a divisão de $A$ por $B$.
#### Entrada
A entrada consiste de dois números reais $A$ e $B$, um em cada linha.
#### Saída
A saída do seu programa deve ser um número real $S$, representando a divisão de $A$ por $B$ com precisão de 2 casas decimais.
|
2,328 | 324 | Garçom | Fácil | Basicos | Parte do treinamento de um novo garçom é carregar uma grande bandeja com várias latas de bebidas e copos e entregá-las todas numa mesa do restaurante. Durante o treinamento é comum que os garçons deixem cair as bandejas, quebrando todos os copos.
A SBC -- Sociedade Brasileira de Copos -- analisou estatísticas do treinamento de diversos garçons e descobriu que os garçons em treinamento deixam cair apenas bandejas que têm mais latas de bebidas que copos. Por exemplo, se uma bandeja tiver 10 latas e 4 copos, certamente o garçom em treinamento a deixará cair, quebrando os 4 copos. Já se a bandeja tiver 5 latas e 6 copos, ele conseguirá entregá-la sem deixar cair.
Escreva um programa que, dado o número de latas e copos em cada bandeja que o garçom tentou entregar, imprime o total de copos que ele quebrou.
#### Entrada
A primeira linha da entrada contém um inteiro $N$ representando o número de bandejas que o garçom tentou entregar. As $N$ linhas seguintes representam as $N$ bandejas. Cada linha contém dois inteiros $L$ e $C$, indicando o número de latas e o número de copos naquela bandeja, respectivamente.
#### Saída
Seu programa deve imprimir uma única linha, contendo um único inteiro, indicando o número total de copos que o garçom quebrou.
#### Restrições
* $1 \leq N \leq 100$
* $0 \leq L, C \leq 100$
|
2,329 | 216 | Todos os Divisores | Fácil | Basicos | Dado um número inteiro $X$, encontre todos os divisores de $X$.
#### Entrada
A entrada consiste de apenas uma linha contendo o número $X$.
#### Saída
A saída do seu programa deve conter apenas uma linha com os divisores de $X$ separados por um espaço em branco. O divisores devem ser impressos em ordem crescente.
#### Restrições
* $2 \leq X \leq 10^9$ |
2,330 | 171 | Potências Simples | Fácil | Basicos | Enquanto você estava estudando no Neps Academy você viu um problema chamado "Potências Simples" e resolveu lê-lo, o problema pedia para você ler dois números reais e imprimisse um número elevado ao outro. Faça um programa que resolva o problema.
#### Entrada
A entrada é composta por apenas uma linha que contem dois números reais, $x$ e $y$.
#### Saída
Seu programa deve imprimir um único número $x^y$ com 4 casas decimais de precisão.
#### Restrições
* $0 \leq x \leq 10000$
* $1 \leq y \leq 10$
* $x^y \leq 10^9$ |
2,331 | 47 | Código (OBI 2015) | Fácil | Basicos | Gabriel inventou um código para representar números naturais, usando uma sequência de zeros e uns. Funciona assim, o número natural é representado pela quantidade de vezes que o padrão "100" aparece na sequência.
Por exemplo, na sequência 11101001010011110, o padrão aparece duas vezes e na sequência 11101010111110111010101 ele não aparece nenhuma vez. Você deve ajudar Gabriel implementar um programa que, dada a sequência de zeros e uns, calcule quantas vezes o padrão "100" aparece nela.
#### Entrada
A primeira linha da entrada contém um inteiro $N$, o tamanho da sequência. A segunda linha contém a sequência de $N$ zeros e uns, separados por espaço em branco.
#### Saída
Seu programa deve imprimir um inteiro, quantas vezes o padrão "100" aparece na sequência.
#### Restrições
* $1 \leq N \leq 10^4$ |
2,332 | 170 | Raízes | Fácil | Basicos | Seu professor lhe passou um exercício onde você deve encontrar a raiz quadrada de vários números, como você não quer perder tempo com essa tarefa tosca e sem sentido você resolveu fazer um programa que dados $N$ números ele retorna a raiz quadrada de cada um desses números
#### Entrada
A primeira linha de entrada contém um número inteiro $N$ representando a quantidade de números dos quais você terá que responder qual a raiz quadrada. A segunda linha da entrada contém os $N$ números separados por um espaço em branco.
#### Saída
Seu programa deve imprimir $N$ linhas, cada uma contendo a raiz do número na ordem, cada raiz com precisão de 4 casas decimais.
#### Restrições
* $1 \leq N \leq 10000$
* $0 \leq X \leq 10^9$ onde $X$ representa os números em cada linha. |
2,333 | 88 | Zerinho ou Um | Fácil | Basicos | Todos devem conhecer o jogo Zerinho ou Um (em algumas regiões também conhecido como Dois ou Um), utilizado para determinar um ganhador entre três ou mais jogadores. Para quem não conhece, o jogo funciona da seguinte maneira. Cada jogador escolhe um valor entre zero ou um; a um comando (geralmente um dos competidores anuncia em voz alta “Zerinho ou... Um!”), todos os participantes mostram o valor escolhido, utilizando uma das mãos: se o valor escolhido foi um, o competidor mostra o dedo indicador estendido; se o valor escolhido foi zero, mostra a mão com todos os dedos fechados.
O ganhador é aquele que tiver escolhido um valor diferente de todos os outros; se não há um jogador com valor diferente de todos os outros (por exemplo todos os jogadores escolhem zero, ou um grupo de jogadores escolhe zero e outro grupo escolhe um), não há ganhador.
Alice, Beto e Clara são grandes amigos e jogam Zerinho a toda hora: para determinar quem vai comprar a pipoca durante a sessão de cinema, quem vai entrar na piscina primeiro, etc. Jogam tanto que resolveram fazem um plugin no Facebook para jogar Zerinho. Como não sabem programar, dividiram as tarefas entre amigos que sabem, inclusive você.
Dados os três valores escolhidos por Alice, Beto e Clara, cada valor zero ou um, escreva um programa que determina se há um ganhador, e nesse caso determina quem é o ganhador.
#### Entrada
A entrada é composta de uma única linha, que contém três inteiros $A$, $B$ e $C$, indicando respectivamente os valores escolhidos por Alice, Beto e Clara.
#### Saída
Seu programa deve produzir uma única linha, contendo um único caractere. Se o vencedor é Alice o
caractere deve ser 'A', se o vencedor é Beto o caractere deve ser 'B', se o vencedor é Clara o caractere deve ser 'C' e se não há vencedor o caractere deve ser '*' (asterisco).
#### Restrições
* $A, B, C \in \{0, 1\}$
|
2,334 | 144 | Área da Circunferência | Fácil | Basicos | Bino quer calcular a área de uma circunferência e pediu sua ajuda para isso.
Faça um programa para ler um valor real $R$ representando o raio da circunferência que Bino que calcular a área. Imprima a área da circunferência utilizando como pi o valor 3.1416.
#### Entrada
A entrada consiste de uma linha contendo o valor do raio da circunferência.
#### Saída
A saída consiste de uma única linha contendo a área da circunferência com <b>duas casas de precisão</b>.
#### Restrições
* Os valores fornecidos não serão negativos nem maior que 10000 |
2,335 | 157 | Repetir X Vezes | Muito Fácil | Basicos | Faça um programa que leia um inteiro $X$ e imprima $X$ vezes a mensagem "NepsAcademy eh Sucesso".
#### Entrada
A entrada consiste de uma linha contendo um inteiro $X$.
#### Saída
A saída consiste de $X$ linhas, cada uma contendo a mensagem indicada no enunciado.
#### Restrições
* $1 \leq X \leq 100$
|
2,336 | 257 | Fibonacci | Fácil | Basicos | Uma famosa sequência matemática é a sequência de Fibonacci, está sequência é definida por:
$$fib(0) = fib(1) = 1$$
$$fib(n) = fib(n - 1) + fib(n - 2)$$
Escreva um programa que dado $N$ retorna o n-ésimo número de Fibonacci.
#### Entrada
A entrada contem um único número $N$.
#### Saída
O valor do n-ésimo número de Fibonacci.
#### Restrições
* $0 \leq N \leq 30$ |
2,337 | 110 | Consecutivos | Médio | Basicos | Num sorteio que distribui prêmios, um participante inicialmente sorteia um inteiro $N$ e depois $N$ valores. O número de pontos do participante é o tamanho da maior sequência de valores consecutivos iguais. Por exemplo, suponhamos que um participante sorteia $N = 11$ e, nesta ordem, os valores.
$$ 30, 30, 30, 30, 40, 40, 40, 40, 40, 30, 30$$
Então, o participante ganha 5 pontos, correspondentes aos 5 valores 40 consecutivos. Note que o participante sorteou 6 valores iguais a 30, mas nem todos são consecutivos.
Sua tarefa é ajudar a organização do evento, escrevendo um programa que determina o número de pontos de um participante.
#### Entrada
A primeira linha da entrada contém um inteiro $N$, o número de valores sorteados. A segunda linha contém $N$ valores, $V_1, V_2,\ldots, V_N$, na ordem de sorteio, separados por um espaço em branco.
#### Saída
Seu programa deve imprimir apenas uma linha, contendo apenas um inteiro, indicando o número de pontos do participante.
#### Restrições
* $1 \leq N \leq 10^4$
* $-2^{31} \leq V_i \leq 2^{31}-1$, para $i = 1, 2, \ldots, N$
|
2,338 | 146 | Quadrante | Fácil | Basicos | Faça um programa para ler dois inteiros $X$ e $Y$ representando um ponto em um plano cartesiano. Imprima qual quadrante esse ponto de encontra. Caso o ponto esteja em algum eixo, imprima apenas a mensagem "eixos".
#### Entrada
A entrada consiste de duas linhas. A primeira linha contém o inteiro $X$. A segunda linha contém o inteiro $Y$.
#### Saída
A saída consiste de uma linha contendo a mensagem indicando qual o quadrante que o ponto está.
#### Restrições
* $-100 \leq X, Y \leq 100$
|
2,339 | 2 | Medalhas | Fácil | Basicos | A natação foi um dos esportes mais emocionantes das Olimpíadas do Rio. Houve até uma prova na qual três atletas chegaram empatados, cada um recebendo uma medalha de prata! Normalmente, porém, os três primeiros colocados terminam a prova em tempos distintos e, portanto, temos a distribuição mais comum de medalhas: o nadador que terminou no menor tempo recebe medalha de ouro; o nadador que terminou com o segundo menor tempo recebe medalha de prata; e o que terminou com o terceiro menor tempo recebe medalha de bronze. Neste problema, dados os três tempos distintos de finalização da prova, dos três nadadores que ganharam medalhas, seu programa deve dizer quem ganhou medalha de ouro, quem ganhou prata e quem ganhou bronze.
#### Entrada
A primeira linha da entrada contém um inteiro $T_1$, indicando o tempo em que o nadador 1 terminou a prova. A segunda linha da entrada contém um inteiro $T_2$, indicando o tempo de finalização do nadador 2. Por fim, a terceira linha da entrada contém um inteiro $T_3$, indicando o tempo em que o nadador 3 terminou a prova.
#### Saída
Seu programa deve imprimir três linhas na saída. A primeira linha deve conter o número do nadador que ganhou medalha de ouro; a segunda linha, o número do nadador que ganhou prata; e a terceira linha, o número do nadador que levou bronze.
#### Restrições
* Os tempos $T_1$, $T_2$ e $T_3$ são inteiros distintos, com valores entre 1 e 1000, inclusive.
|
2,340 | 139 | Área do Retângulo | Muito Fácil | Basicos | Faça um programa para ler dois valores inteiros $A$ e $B$ e imprima a área de um retângulo que tenha lados $A$ e $B$.
#### Entrada
A entrada consiste de duas linhas. A primeira linha contém o inteiro $A$ e a segunda linha contém o inteiro $B$.
#### Saída
A saída consiste de uma linha contendo a área de um retângulo que tenha lados $A$ e $B$.
#### Restrições
* Os inteiros fornecidos não terem valor maior que 1000 ou menor que 1. |
2,341 | 135 | Subtração | Muito Fácil | Basicos | Faça um programa para ler dois valores inteiros $A$ e $B$ e imprima o resultado da expressão $(A-B)$.
#### Entrada
A entrada consiste de duas linhas. A primeira linha contém o inteiro $A$ e a segunda linha contém o inteiro $B$.
#### Saída
A saída consiste de uma linha contendo o resultado da expressão $(A-B)$.
#### Restrições
* Os inteiros fornecidos não terem valor absoluto maior que 1000. |
2,342 | 147 | Reprovado, Aprovado ou Final. | Fácil | Basicos | Bino obteve média $N_1$ na primeira etapa do semestre e média $N_2$ na segunda etapa do semestre. Bino não sabe sua situação e quer sua ajuda para saber se ele está aprovado, reprovado ou de prova final.
A nota final de Bino é calculada utilizando uma média ponderada onde o peso da $N_1$ é 2 e o peso da $N_2$ é 3. Caso a média final seja maior ou igual a 7, Bino está aprovado. Caso a média seja menor que 3, Bino está reprovado. Caso Bino não esteja reprovado ou aprovado, Bino terá que fazer a prova final.
Faça um programa para ler as duas notas de Bino e imprima qual sua situação.
#### Entrada
A entrada consiste de duas linhas. A primeira linha contém um real representando a nota $N_1$. A segunda linha contém um real representando a nota $N_2$.
#### Saída
A saída consiste de uma linha. Caso Bino esteja aprovado, imprima "Aprovado". Caso Bino esteja reprovado, imprima "Reprovado". Caso Bino não esteja reprovado ou aprovado, imprima "Final".
#### Restrições
* $0.0 \leq N_1, N_2 \leq 10.0$ |
2,343 | 241 | Campo Minado | Fácil | Basicos | Leonardo é um garoto fascinado por jogos de tabuleiro. Nas férias de janeiro, ele aprendeu um jogo chamado Campo minado, que é jogado em um tabuleiro com $N$ células dispostas na horizontal. O objetivo desse jogo é determinar, para cada célula do tabuleiro, o número de minas explosivas nos arredores da mesma (que são a própria célula e as células imediatamente vizinhas à direita e à esquerda, caso essas existam). Por exemplo, a figura abaixo ilustra uma possível configuração de um tabuleiro com 5 células:
A primeira célula não possui nenhuma mina explosiva, mas é vizinha de uma célula que possui uma mina explosiva. Nos arredores da segunda célula temos duas minas, e o mesmo acontece para a terceira e quarta células; a quinta célula só tem uma mina explosiva em seus arredores. A próxima figura ilustra a resposta para esse caso.
Leonardo sabe que você participa da OBI e resolveu lhe pedir para escrever um programa de computador que, dado um tabuleiro, imprima o número de minas na vizinhança de cada posição. Assim, ele poderá conferir as centenas de tabuleiros que resolveu durante as férias.
#### Entrada
A primeira linha da entrada contém um inteiro $N$ indicando o número de células no tabuleiro. O tabuleiro é dado nas próximas $N$ linhas. A i-ésima linha seguinte contém 0 se não existe mina na i-ésima célula do tabuleiro e 1 se existe uma mina na i-ésima célula do tabuleiro.
#### Saída
A saída é composta por $N$ linhas. A i-ésima linha da saída contém o número de minas explosivas nos arredores da i-ésima célula do tabuleiro.
#### Restrições
* $1 \leq N \leq 50$ |
2,344 | 140 | Área do Triângulo Retângulo | Muito Fácil | Basicos | Faça um programa para ler dois valores inteiros $A$ e $B$ e imprima a área inteira de um triângulo retângulo que tenha bases $A$ e $B$.
#### Entrada
A entrada consiste de duas linhas. A primeira linha contém o inteiro $A$ e a segunda linha contém o inteiro $B$.
#### Saída
A saída consiste de uma linha contendo a área inteira de um triângulo retângulo que tenha bases $A$ e $B$.
#### Restrições
* Os inteiros fornecidos não terem valor maior que 1000 ou menor que 1.
|
2,345 | 158 | Fatorial | Fácil | Basicos | Faça um programa para ler um inteiro $N$ e imprima o valor de $N!$. $N!$ significa [fatorial](https://pt.wikipedia.org/wiki/Fatorial) de $N$.
#### Entrada
A entrada consiste de uma linha contendo o valor de $N$.
#### Saída
A saída consiste de uma linha contendo o valor de $N!$.
#### Restrições
* $0 \leq N \leq 12$
|
2,346 | 154 | Tabuada | Fácil | Basicos | Bino está aprendendo a multiplicar números e gostaria da sua ajudar para apresentar a tabuada de um determinado valor inteiro $X$.
#### Entrada
A entrada consiste em uma única linha contendo o valor inteiro $X$.
#### Saída
A saída consiste de 10 linhas. A i-éssima linha constem a mensagem "x * i = valor", onde x é o valor de $X$, $i$ representa a o identificar da linha e o $valor$ é o valor da múltiplicação de $X*i$
#### Restrições
* $0 \leq X \leq 1000$ |
2,347 | 225 | Overflow | Fácil | Basicos | Os computadores foram inventados para realizar cálculos muito rapidamente, e atendem a esse requisito de maneira extraordinária. Porém, nem toda conta pode ser feita num computador, pois ele não consegue representar todos os números dentro de sua memória. Em um computador pessoal atual, por exemplo, o maior inteiro que é possível representar em sua memória é 4.294.967.295. Caso alguma conta executada pelo computador dê um resultado acima desse número, ocorrerá o que chamamos de overflow, que é quando o computador faz uma conta e o resultado não pode ser representado, por ser maior do que o valor máximo permitido (em inglês overflow significa transbordar).
Por exemplo, se um computador só pode representar números menores do que 1023 e mandamos ele executar a conta 1022 + 5, vai ocorrer overflow.
Dados o maior número que um computador consegue representar e uma expressão de soma ou multiplicação entre dois inteiros, determine se ocorrerá overflow.
#### Entrada
A primeira linha da entrada contém um inteiro $N$ representando o maior número que o computador consegue representar. A segunda linha contém um inteiro $P$, seguido de um espaço em branco, seguido de um caractere $C$ (que pode ser '+' ou '*', representando os operadores de adição e multiplicação, respectivamente), seguido de um espaço em branco, seguido de um outro inteiro $Q$. Essa linha representa a expressão $P + Q$, se o caractere $C$ for '+', ou $P * Q$, se o caractere $C$ for '\*'.
#### Saída
Se programa deve imprimir uma única linha, contendo a palavra 'OVERFLOW ' se o resultado da expressão causar um overflow, ou a palavra 'OK' caso contrário. Ambas as palavras devem ser escritas com letras maiúsculas.
#### Restrições
* $1 \leq N \leq 500.000$
* $0 \leq P \leq 1000$
* $0 \leq Q \leq 1000$ |
2,348 | 137 | Média Inteira Ponderada | Fácil | Basicos | Faça um programa para ler dois valores inteiros $A$ e $B$ e imprima a média ponderada dos dois valores. O peso de $A$ é 4 e o peso de $B$ é 6.
#### Entrada
A entrada consiste de duas linhas. A primeira linha contém o inteiro $A$ e a segunda linha contém o inteiro $B$.
#### Saída
A saída consiste de uma linha contendo a média ponderada <b>(apenas a parte inteira)</b> dos dois valores.
#### Restrições
* Os inteiros fornecidos não terem valor absoluto maior que 1000.
|
2,349 | 162 | Basquete de Robôs | Fácil | Basicos | A organização da OIBR, Olimpíada Internacional de Basquete de Robô, está começando a ter problemas com dois times: os Bit Warriors e os Byte Bulls. É que os robôs desses times acertam quase todos os lançamentos, de qualquer posição na quadra! Pensando bem, o jogo de basquete ficaria mesmo sem graça se jogadores conseguissem acertar qualquer lançamento, não é mesmo? Uma das medidas que a OIBR está implantando é uma nova pontuação para os lançamentos, de acordo com a distância do robô para o início da quadra. A quadra tem 2000 centímetros de comprimento, como na figura.
Dada a distância $D$ do robô até o início da quadra, onde está a cesta, a regra é a seguinte:
* Se $D \leq 800$, a cesta vale 1 ponto;
* Se $800 < D \leq 1400$, a cesta vale 2 pontos;
* Se $1400 < D \leq 2000$, a cesta vale 3 pontos.
A organização da OIBR precisa de ajuda para automatizar o placar do jogo. Dado o valor da distância $D$, você deve escrever um programa para calcular o número de pontos do lançamento.
#### Entrada
A primeira e única linha da entrada contém um inteiro $D$ indicando a distância do robô para o início da quadra, em centímetros, no momento do lançamento
#### Saída
Seu programa deve produzir uma única linha, contendo um inteiro, 1, 2 ou 3, indicando a pontuação do lançamento.
#### Restrições
* $0 \leq D \leq 2000$
|
2,350 | 159 | Soma dos Elementos | Muito Fácil | Basicos | Nesse problema você receberá um conjunto de valores e sua tarefa é imprimir a soma desses valores.
#### Entrada
A entrada consiste em duas linhas. A primeira linha possui apenas um valor $N$, representando a quantidade de valores que você deve ler. A segunda linha possui $N$ números inteiros separados por um espaço em branco.
#### Saída
Você deve imprimir a soma dos $N$ números inteiros lidos na entrada.
#### Restrições
* $1 \leq N \leq 100$ |
2,351 | 218 | Operações | Fácil | Basicos | Você deve escrever um programa que será capaz de resolver operações de multiplicação e divisão. Primeiro será informado que operação seu programa deve calcular, depois será informado dois números, seu programa deve então imprimir a resposta apropriada.
#### Entrada
A entrada consiste de duas linhas, a primeira linha apresentará a letra 'M' caso você deva calcular a multiplicação entre os números e a letra 'D' caso a operação seja de divisão. A segunda linha conterá dois números reais.
#### Saída
A saída do seu programa deve conter apenas uma linha, informando a resposta apropriada para a operação realizada com uma precisão de 2 casas decimais.
|
2,352 | 49 | Fita Colorida | Médio | Basicos | Roberto tem um conjunto de lápis com 10 tons diferentes de uma mesma cor, numerados de 0 a 9. Numa fita quadriculada, alguns quadrados foram coloridos inicialmente com o tom 0.
Roberto precisa determinar, para cada quadrado $Q$ não colorido, qual é a distância dele para o quadrado mais próximo de tom 0. A distância entre dois quadrados é definida com o número mínimo de movimentos para a esquerda, ou para a direita, para ir de um quadrado para o outro. O quadrado $Q$, então, deve ser colorido com o tom cuja numeração corresponde à distância determinada. Se a distância for maior ou igual a 9, o quadrado deve ser colorido com o tom 9. Seu programa deve colorir e imprimir a fita quadriculada dada na entrada.
#### Entrada
A primeira linha da entrada contém apenas um inteiro $N$, indicando o número de quadrados da fita. A segunda linha contém $N$ números inteiros: “-1” se o quadrado não está colorido, e “0” se está colorido com o tom 0.
#### Saída
Seu programa deve escrever na saída a fita totalmente colorida, de acordo com a regra definida acima.
#### Restrições
* $3 \leq N \leq 10^4$
* Sempre existe pelo menos um “0” inicialmente na fita. |
2,353 | 156 | Valores Entre Dois Números | Fácil | Basicos | Faça um programa para ler dois valores inteiros $A$ e $B$, e imprima todos os valores inteiros entre os números lidos em ordem crescente. Por exemplo, ao receber os valores 2 e 5, devem ser impressos os valores 2, 3, 4 e 5. Caso receba os valores 4 e -1, devem ser impressos os valores -1, 0, 1, 2, 3 e 4.
#### Entrada
A entrada consiste de duas linhas. Cada linha consiste de um inteiro.
#### Saída
A saída é composta de uma linha contendo todos os inteiros no intervalo fechado dos inteiros recebidos.
#### Restrições
* $-100 \leq A,B \leq 100$ |
2,354 | 236 | Quadrado Mágico (OBI 2007) | Médio | Basicos | Chama-se de quadrado mágico um arranjo, na forma de um quadrado, de $N×N$ números inteiros tal que todas as linhas, colunas e diagonais têm a mesma soma.
Por exemplo, o quadrado abaixo
$$\begin{array}{lcr} 2 & 7 & 6 \\\\ 9 & 5 & 1 \\\\ 4 & 3 & 8 \end{array}$$
é um quadrado mágico de soma 15, pois todas as linhas (2+7+6 = 15, 9+5+1 = 15 e 4+3+8 = 15), colunas (2 + 9 + 4 = 15, 7 + 5 + 3 = 15 e 6 + 1 + 8 = 15) e diagonais (2 + 5 + 8 = 15 e 6 + 5 + 4 = 15) têm a mesma soma (15).
Escreva um programa que, dado um quadrado, determine se ele é magico ou não e qual a soma dele (caso seja mágico).
#### Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão. A primeira linha da entrada de cada caso de teste contém um inteiro $N$. As $N$ linhas seguintes contêm $N$ inteiros cada, separados por exatamente um espaço em branco. Os inteiros dentro do quadrado são todos maiores que 0 (zero) e menores que 1.000.
#### Saída
Seu programa deve imprimir, na saída padrão, uma única linha com um inteiro representando a soma do quadrado mágico ou -1 caso o quadrado não seja mágico.
#### Restrições
* $2 \leq N \leq 10$
|
2,355 | 326 | Soma do Vetor | Fácil | Basicos | Modifique o código abaixo, adicionando o código da função <b>soma_vetor</b>, que recebe como parâmetros um inteiro $n$ e um ponteiro para um vetor de inteiros $v$ e deve retornar um <b>int</b>: a soma dos $n$ elementos do vetor $v$. Vale ressaltar que você pode trabalhar com o ponteiro para o vetor exatamente da mesma maneira que faria se trabalhasse diretamente com o vetor.
```cpp
#include <iostream>
using namespace std;
int soma_vetor(int n, int v[]){
// Seu código aqui.
}
int main(){
int n, v[100100];
cin >> n;
for(int i=0;i<n;i++)
cin >> v[i];
cout << soma_vetor(n,v) << "\n";
}
```
#### Entrada
A entrada do seu programa terá duas linhas: a primeira delas terá um único inteiro $n$, e a segunda terá os $n$ elementos $v_i$ do vetor $v$.
#### Saída
Seu programa deve imprimir na saída padrão uma única linha contendo a soma dos elementos do vetor.
#### Restrições
* $1 \leq n \leq 10^5$
* $-10^4 \leq v_i \leq 10^4$
|
2,356 | 187 | Inverso | Fácil | Basicos | Faça um programa para ler 10 valores inteiros como entrada e imprima na ordem inversa da que foram lidos.
#### Entrada
A entrada consiste de 10 linhas, cada linha contém um valor inteiro.
#### Saída
A saída consiste de dez linha contendo, cada linha com um os 10 valores lidos, porém, na ordem contrária da que foram lidos. |
2,357 | 395 | Busca Simples no Vetor 01 | Fácil | Basicos | Faça um programa para ler 10 valores inteiros, armazená-los em um vetor, depois ler um inteiro $X$. Imprima "SIM" se $X$ aparece no vetor, ou "NAO" caso contrário.
#### Entrada
A primeira linha da entrada consiste de 10 inteiros separados por um espaço em branco. A segunda linha contém um inteiro $X$.
#### Saída
Imprima "SIM" se $X$ aparece no vetor, ou "NAO" caso contrário.
#### Restrições
Todos os valores fornecidos não serão negativos nem maiores que 100. |
2,358 | 141 | Minutos Para Horas e Minutos | Fácil | Basicos | Faça um programa para ler um inteiro $M$ representando uma quantidade em minutos. Imprima o equivalente em horas e minutos. Por exemplo, caso $M = 70$, isso equivale a 1 hora e 10 minutos. Outro exemplo, caso $M = 500$, isso equivale a 8 hora e 20 minutos.
#### Entrada
A entrada consiste de uma linha contendo o inteiro $M$.
#### Saída
A saída consiste de duas linhas. A primeira contém o equivalente em horas. A segunda contém o equivalente em minutos restantes.
#### Restrições
* Os inteiros fornecidos não terem valor absoluto maior que 1000.
|
2,359 | 142 | Horas e Minutos Para Minutos | Muito Fácil | Basicos | Faça um programa para ler dois inteiros $H$ e $M$, representando uma quantidade de horas e uma quantidade de minutos. Converta os valores que recebeu como entrada para uma quantidade de minutos e imprima. Por exemplo, caso $H=2$ e $M=20$, representa que você tem duas horas e vinte minutos, o que equivale a 140 minutos.
#### Entrada
A entrada consiste de duas linhas. A primeira linha contém o inteiro $H$ e a segunda linha contém o inteiro $M$.
#### Saída
A saída consiste de uma linha contendo a quantidade convertida para minutos.
#### Restrições
* Os inteiros fornecidos não serão negativos nem maiores que 1000.
|
2,360 | 167 | Piso da Escola | Fácil | Basicos | O colégio pretende trocar o piso de uma sala de aula e a diretora aproveitou a oportunidade para passar uma tarefa aos alunos. A sala tem o formato de um retângulo de largura $L$ metros e comprimento $C$ metros, onde $L$ e $C$ são números inteiros. A diretora precisa comprar lajotas de cerâmica para cobrir todo o piso da sala. Seria fácil calcular quantas lajotas seriam necessárias se cada lajota fosse um quadrado de 1 metro de lado. O problema é que a lajota que a diretora quer comprar é um quadrado que possui 1 metro de diagonal, não de lado. Além disso, ela quer preencher o piso da sala com as diagonais das lajotas alinhadas aos lados da sala, como na figura.
A loja vai fornecer lajotas do tipo 1: inteiras; do tipo 2, que correspondem à metade das do tipo 1, cortadas ao longo da diagonal; e lajotas do tipo 3, que correspondem à metade do tipo 2. Veja os três tipos de lajotas na figura.
Está muito claro que sempre serão necessárias 4 lajotas do tipo 3 para os cantos da sala. A tarefa que a diretora passou para os alunos é calcular o número de lajotas dos tipos 1 e 2 que serão necessárias. Na figura, para $L = 3$ e $C = 5$, foram necessárias 23 do tipo 1 e 12 do tipo 2.
Seu programa precisa computar, dados os valores de $L$ e $C$, a quantidade de lajotas do tipo 1 e do tipo 2 necessárias.
#### Entrada
A primeira linha da entrada contém um inteiro $L$ indicando a largura da sala. A segunda linha contém um inteiro $C$ representando o comprimento da sala.
#### Saída
Imprima duas linhas na saída. A primeira deve conter um inteiro, representando o número de lajotas do tipo 1 necessárias. A segunda deve conter um inteiro, indicando o número de lajotas do tipo 2.
#### Restrições
* $1 \leq L, C \leq 100$ |
2,361 | 45 | Torre | Médio | Basicos | Dada uma matriz quadrada $M$ de números naturais, o índice $i$ de uma certa linha e o índice $j$ de uma certa coluna, vamos definir o peso do cruzamento da linha $i$ com a coluna $j$, como sendo a soma de todos os elementos que estejam na linha $i$ ou na coluna $j$, mas não nas duas. Quer dizer, excluindo o elemento que está exatamente no cruzamento! Neste problema, você deve descobrir qual é o peso máximo entre todos os possíveis cruzamentos da matriz!
No jogo de xadrez, a torre é uma peça que pode se mover para qualquer outra posição do tabuleiro na linha ou na coluna da posição que ela ocupa. O professor Paulo está tentando inventar um novo tipo de jogo de xadrez onde todas as peças são torres, o tabuleiro também é quadrado mas pode ter qualquer dimensão e cada posição do tabuleiro é anotada com um número inteiro positivo, como na figura abaixo.
Ele definiu o peso de uma posição $(i,j)$ como sendo a soma de todos os números que estejam na linha $i$ com todos os números da coluna $j$, mas sem somar o número que está exatamente na posição $(i,j)$. Quer dizer, se uma torre estiver na posição $(i,j)$, o peso da posição é a soma de todas as posições que essa torre poderia atacar.
O professor Paulo está solicitando a sua ajuda para implementar um programa que determine qual é o peso máximo entre todas as posições do tabuleiro.
No exemplo da figura acima, com um tabuleiro de dimensão seis (ou seja, seis linhas por seis colunas), o peso máximo é 67, referente à posição $(4,4)$.
#### Entrada
A primeira linha da entrada contém um inteiro $N$, representando a dimensão do tabuleiro.
Cada uma das $N$ linhas seguintes contém $N$ inteiros positivos $X_i$, definindo os números em cada posição do tabuleiro.
#### Saída
Seu programa deve produzir uma única linha, contendo um único inteiro, o peso máximo entre todas as posições do tabuleiro.
#### Restrições
* $3 \leq N \leq 1000$
* $0 \leq X_i \leq 100$
|
2,362 | 247 | Primo | Fácil | Basicos | Modifique o código abaixo, adicionando o código da função <b>eh_primo</b>, que deve retornar <b>true</b> quando o número $x$ for primo e <b>false</b> caso contrário.
```cpp
#include <iostream>
using namespace std;
bool eh_primo(int x){
//Seu código aqui.
}
int main(){
int x;
cin>>x;
if(eh_primo(x)){
cout << "S" << "\n";
}else{
cout << "N" << "\n";
}
}
```
#### Entrada
A entrada do seu programa será apenas uma linha contendo o número inteiro $x$.
#### Saída
Seu programa deve imprimir na saída padrão uma única linha contendo "S" caso o $x$ seja primo e "N" caso contrário.
#### Restrições
* $1 \leq x \leq 10^5$
|
2,363 | 164 | Xadrez | Fácil | Basicos | No tabuleiro de xadrez, a casa na linha 1, coluna 1 (canto superior esquerdo) é sempre branca e as cores das casas se alternam entre branca e preta, de acordo com o padrão conhecido como...xadrez! Dessa forma, como o tabuleiro tradicional tem oito linhas e oito colunas, a casa na linha 8, coluna 8 (canto inferior direito) será também branca. Neste problema, entretanto, queremos saber a cor da casa no canto inferior direito de um tabuleiro com dimensões quaisquer: $L$ linhas e $C$ colunas. No exemplo da figura, para $L = 6$ e $C = 9$, a casa no canto inferior direito será preta!
#### Entrada
A primeira linha da entrada contém um inteiro $L$ indicando o número de linhas do tabuleiro. A segunda linha da entrada contém um inteiro $C$ representando o número de colunas.
#### Saída
Imprima uma linha na saída. A linha deve conter um inteiro, representando a cor da casa no canto inferior direito do tabuleiro: 1, se for branca; e 0, se for preta.
#### Restrições
* $1 \leq L, C \leq 1000$ |
2,364 | 20 | Cartas | Muito Fácil | Basicos | Um novo game de realidade aumentada tem, dentro dele, um mini-game que aparece em certas situações para aumentar o ganho de pontos do game principal. O mini-game é um joguinho de memória com quatro cartas, formando dois pares de cartas iguais. Quer dizer, duas cartas têm um número inteiro $N$ marcado em uma de suas faces e as outras duas cartas têm um outro número inteiro $M, N \neq M$. Neste problema, o jogador já virou três cartas, como mostrado na figura.
Claro que, dadas as condições, a carta que falta virar vai formar par com uma das três que já foram viradas. No caso da figura, o número marcado na carta que ainda falta virar é 11. Implemente um programa que, dados os números de três cartas, imprima o número da carta que ainda falta virar!
#### Entrada
A primeira linha da entrada contém um inteiro $A$, representando a primeira carta aberta. A segunda linha contém o inteiro $B$, representando a segunda carta. A terceira linha contém o inteiro $C$, que é a terceira carta.
#### Saída
Seu programa deve imprimir uma linha contendo um inteiro representando o número que está na carta que ainda falta virar.
#### Restrições
* $0 \leq A, B, C \leq 100$
|
2,365 | 463 | A Idade de Dona Mônica | Fácil | Basicos | Dona Mônica é mãe de três filhos que têm idades diferentes. Ela notou que, neste ano, a soma das idades dos seus três filhos é igual à idade dela. Neste problema, dada a idade de dona Mônica e as idades de dois dos filhos, seu programa deve computar e imprimir a idade do filho mais velho.
Por exemplo, se sabemos que dona Mônica tem 52 anos e as idades conhecidas de dois dos filhos são 14 e 18 anos, então a idade do outro filho, que não era conhecida, tem que ser 20 anos, pois a soma das três idades tem que ser 52. Portanto, a idade do filho mais velho é 20. Em mais um exemplo, se dona Mônica tem 47 anos e as idades de dois dos filhos são 21 e 9 anos, então o outro filho tem que ter 17 anos e, portanto, a idade do filho mais velho é 21.
#### Entrada
A primeira linha da entrada contém um inteiro $M$ representando a idade de dona Mônica. A segunda linha da entrada contém um inteiro $A$ representando a idade de um dos filhos. A terceira linha da entrada contém um inteiro $B$ representando a idade de outro filho
#### Saída
Seu programa deve imprimir uma linha, contendo um número inteiro, representando a idade do filho mais velho de dona Mônica.
#### Restrições
* $40 \leq M \leq 110$
* $1 \leq A < M$
* $1 \leq B < M$
* $A \neq B$ |
2,366 | 118 | Huaauhahhuahau | Médio | Basicos | Em chats, é muito comum entre jovens e adolescentes utilizar sequências de letras, que parecem muitas vezes aleatórias, para representar risadas. Alguns exemplos comuns são:
huaauhahhuahau
hehehehe
ahahahaha
jaisjjkasjksjjskjakijs
huehuehue
Cláudia é uma jovem programadora que ficou intrigada pela sonoridade das “risadas digitais”. Algumas delas ela nem mesmo consegue pronunciar! Mas ela percebeu que algumas delas parecem transmitir melhor o sentimento da risada que outras. A primeira coisa que ela percebeu é que as consoantes não interferem no quanto as risadas digitais influenciam na transmissão do sentimento. A segunda coisa que ela percebeu é que as risadas digitais mais engraçadas são aquelas em que as sequências de vogais são iguais quando lidas na ordem natural (da esquerda para a direita) ou na ordem inversa (da direita para a esquerda), ignorando as consoantes. Por exemplo, “hahaha” e “huaauhahhuahau” estão entre as risadas mais engraçadas, enquanto “riajkjdhhihhjak” e “huehuehue” não estão entre as mais engraçadas.
Cláudia está muito atarefada com a análise estatística das risadas digitais e pediu sua ajuda para escrever um programa que determine, para uma risada digital, se ela é das mais engraçadas ou não.
#### Entrada
A entrada é composta por uma linha, contendo uma sequência de no máximo 50 caracteres, formada apenas por letras minúsculas sem acentuação. As vogais são as letras ‘a’,‘e’,‘i’,‘o’,‘u’. A sequência contém pelo menos uma vogal.
#### Saída
Seu programa deve produzir uma linha contendo um caractere, “S” caso a risada seja das mais engraçadas, ou “N” caso contrário. |
2,367 | 242 | Titulo | Fácil | Basicos | Modifique o código abaixo, adicionando o código da função <b>title</b>, que deve retornar uma string, com a primeira letra de cada palavra maiúscula e o restante minúscula.
```cpp
#include <iostream>
using namespace std;
string title(string F){
//Seu código aqui
}
int main(){
string F;
getline(cin, F);
cout << title(F) << "\n";
}
```
#### Entrada
A entrada do seu programa será apenas uma linha contendo uma frase $F$.
#### Saída
Seu programa deve imprimir uma única linha contendo a frase $F$ modificada.
#### Restrições
* $F$ tem apenas letras maiúsculas e minúsculas e as palavras são separadas por espaçamento simples.
|
2,368 | 150 | Maior Entre Três Números | Muito Fácil | Basicos | Bino recebeu de Cino três inteiros de presente e gostaria de saber qual dos três inteiros é o maior.
#### Entrada
A entrada consiste de três linhas. Cada linha contém um inteiro que Bino recebeu de presente.
#### Saída
A saída consiste de uma linha contendo o maior inteiro que Bino recebeu de presente.
#### Restrições
* Todos os valores fornecidos tem valor absoluto menor ou igual a 1000.
|
2,369 | 50 | Móbile (OBI 2015) | Fácil | Basicos | O móbile na sala da Maria é composto de três hastes exatamente como na figura abaixo. Para que ele esteja completamente equilibrado, com todas as hastes na horizontal, os pesos das quatro bolas $A$, $B$, $C$ e $D$ têm que satisfazer todas as seguintes três condições:
* $A = B + C + D$;
* $B + C = D$;
* $B = C$;
Nesta tarefa, dados os pesos das quatro bolas, seu programa deve decidir se o móbile está ou não completamente equilibrado.
#### Entrada
A entrada consiste de quatro linhas contendo, cada uma, um número inteiro, indicando os pesos das bolas. Os números são dados na ordem: $A$, $B$, $C$ e $D$.
#### Saída
Seu programa deve escrever uma única linha na saída, contendo o caractere “S” se o móbile estiver equilibrado, ou o caractere “N” se não estiver equilibrado.
#### Restrições
* $1 \leq A, B, C, D \leq 1000$
|
2,370 | 153 | Senha 2018 | Fácil | Basicos | Bino desafiou Cino a descobrir o número que ele estava pensando. Bino está pensando no número 2018. Cino vai informar números até que acerte o número que Bino está pensando.
Faça um programa para receber os números que Cino chutou. Seu programa só deve parar de solicitar um valor quando Cino acertar o 2018.
#### Entrada
A entrada consiste de múltiplas linhas. Cada linha contém um inteiro representando um chute de Cino. É garantido que Cino irá fornecer o valor 2018.
#### Saída
A saída consiste de uma única linha informando quantas vezes Cino errou o número que Bino estava pesando.
#### Restrições
* Cino sempre chuta um número com valor absoluto menor ou igual a 100000. |
2,371 | 396 | Busca Simples no Vetor 02 | Fácil | Basicos | Faça um programa para ler 10 valores inteiros, armazená-los em um vetor, depois ler um inteiro $X$. Se $X$ aparece no vetor, imprima quantas vezes ele aparece e depois quais os índices que ele aparece. Se $X$ não aparecer no vetor, imprima apenas a mensagem "Mia x". Lembre-se que a primeira posição de um vetor tem índice 0.
#### Entrada
A primeira linha da entrada consiste de 10 inteiros separados por um espaço em branco. A segunda linha contém um inteiro $X$.
#### Saída
Se $X$ aparece no vetor, a saída consiste de duas linhas, a primeira linha contém um inteiro representando a quantidade de vezes que $X$ apareceu no vetor e a segunda linha contém os índices do vetor que contém valor igual ao $X$. Se $X$ não aparecer no vetor, imprima apenas a mensagem "Mia x". |
2,372 | 398 | Quantas Letras? | Muito Fácil | Basicos | Faça um programa para ler uma string $S$ (sem espaços) e uma letra $C$. Seu programa deve imprimir a quantidade de vezes que a letra $C$ aparece em $S$.
#### Entrada
A entrada consiste de duas linhas. A primeira linha contém uma string $S$. A segunda linha contém uma letra $C$.
#### Saída
A saída consiste de uma única linha contendo um inteiro correspondente a quantidade de vezes que a letra $C$ aparece na string $S$
#### Restrições
* $1 \leq |S| \leq 50$
* A string contém apenas letras minúsculas do alfabeto |
2,373 | 397 | Tamanho da String | Muito Fácil | Basicos | Faça um programa para ler uma string $S$ (sem espaços) e imprima o tamanho da string $S$.
#### Entrada
A entrada consiste de uma única linha contendo uma string $S$.
#### Saída
A saída consiste de uma única linha contendo um inteiro correspondente ao tamanho da string $S$.
#### Restrições
* $1 \leq |S| \leq 50$
* A string contém apenas letras minúsculas do alfabeto.
|
2,374 | 19 | Botas Trocadas | Médio | Basicos | A divisão de Suprimentos de Botas e Calçados do Exército comprou um grande número de pares de botas de vários tamanhos para seus soldados. No entanto, por uma falha de empacotamento da fábrica contratada, nem todas as caixas entregues continham um par de botas correto, com duas botas do mesmo tamanho, uma para cada pé. O sargento mandou que os recrutas retirassem todas as botas de todas as caixas para reembalá-las, desta vez corretamente.
Quando o sargento descobriu que você sabia programar, ele solicitou com a gentileza habitual que você escrevesse um programa que, dada a lista contendo a descrição de cada bota entregue, determina quantos pares corretos de botas poderão ser formados no total.
#### Entrada
A primeira linha da entrada contém um inteiro $N$ indicando o número de botas individuais entregues. Cada uma das $N$ linhas seguintes descreve uma bota, contendo um número inteiro $M$ e uma letra $L$, separados por um espaço em branco. $M$ indica o número do tamanho da bota e $L$ indica o pé da bota: $L$ = ‘D’ indica que a bota é para o pé direito, $L$ = ‘E’ indica que a bota é para o pé esquerdo.
#### Saída
Seu programa deve imprimir uma única linha contendo um único número inteiro indicando o número total de pares corretos de botas que podem ser formados.
#### Restrições
* $2 \leq N \leq 10^4$
* $N$ é par
* $30 \leq M \leq 60$
* $L$ é o caractere ‘D’ ou o caractere ‘E’
|
2,375 | 72 | Cobra Coral | Fácil | Basicos | O professor Rui está desenvolvendo um sistema automático para identificar se uma cobra é uma coral verdadeira ou uma falsa coral. A cobra coral verdadeira é venenosa e os anéis coloridos no seu corpo seguem o padrão ...BVBPBVBPBVBP..., onde B,V e P representam as cores branco, vermelho e preto, respectivamente. Já a falsa coral não é venenosa e os anéis seguem o padrão ...BVPBVPBVPBVP....
O problema é que os sensores do sistema do professor Rui produzem apenas uma sequência de quatro números representando um pedaço do padrão de cores. Só que ele não sabe qual número representa qual cor. Mas, por exemplo, se a sequência for 5 3 9 3, podemos dizer com certeza que é uma coral verdadeira, mesmo sem saber qual número representa qual cor! Você deve ajudar o professor Rui e escrever um programa que diga se a coral é verdadeira ou falsa.
#### Entrada
A entrada consiste de apenas uma linha, contendo quatro números inteiros.
#### Saída
Seu programa deve imprimir na saída uma linha com a letra "V" se a coral for verdadeira ou com a letra "F", caso seja falsa.
#### Restrições
* Os quatro números têm valores entre 1 e 9, inclusive, e a sequência sempre representa uma coral verdadeira, ou uma coral falsa.
|
2,376 | 243 | Olimpíadas | Médio | Basicos |
O Comitê Olímpico Internacional (COI) está visitando as cidades candidatas a sediar as Olimpíadas de 2016. O Rio de Janeiro é uma das cidades concorrentes, mas a competição é muito acirrada.
O COI tem um conjunto de exigências que devem ser obedecidas pelas cidades candidatas, como boas arenas para os jogos (ginásios, campos de futebol, pistas de atletismo, parque aquático,…), bons alojamentos, um plano para o tráfego de veículos durante os jogos, etc. Durante sua visita ao Rio de Janeiro, o COI colocou ainda mais uma exigência: a demonstração da qualidade dos sistemas de informática. Especificamente, o COI quer que a organização local demonstre a sua capacidade em informática produzindo um programa que gere a classificação final dos países, considerando o número de medalhas recebidas pelos atletas de cada país.
Sua tarefa é escrever um programa que, dada a informação dos países que receberam medalhas de ouro, prata e bronze em cada modalidade, gere a lista de classificação dos países na competição. Nesta tarefa, os países serão identificados por números inteiros. O melhor colocado deve ser o país que conseguiu o maior número de medalhas de ouro. Se houver empate entre países no número de medalhas de ouro, o melhor colocado entre esses é o país que conseguiu o maior número de medalhas de prata. Se houver empate também no número de medalhas de prata, o melhor colocado entre esses é o país que recebeu o maior número de medalhas de bronze. Se ainda assim houver empate entre dois países, o melhor classificado é o que tem o menor número de identificação.
#### Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado).
A primeira linha da entrada contém dois números inteiros $N$ e $M$ , separados por um espaço em branco, indicando respectivamente o número de países e número de modalidades esportivas envolvidas na competição. Os países são identificados por números inteiros de 1 a N .
Cada uma das M linhas seguintes contém três números inteiros $O$, $P$ e $B$, separados por um espaço em branco, representando os países cujos atletas receberam respectivamente medalhas de ouro , prata e bronze. Assim, se uma das $M$ linhas contém os números 3 2 1, significa que nessa modalidade a medalha de ouro foi ganha pelo país 3, a de prata pelo país 2 e a de bronze pelo país 1.
#### Saída
Seu programa deve imprimir, na saída padrão, uma linha contendo N números, separados por um espaço em branco, representando os países na ordem decrescente de classificação (o primeiro número representa o país que é o primeiro colocado, o segundo número representa o país que é o segundo colocado, e assim por diante).
#### Restrições
* $1 \leq N \leq 100$
* $1 \leq M \leq 100$
* $1 \leq O \leq N$
* $1 \leq P \leq N$
* $1 \leq B \leq N$
|
2,377 | 152 | Dez Valores | Muito Fácil | Basicos | Bino está tentando contar até 100000. Porém quando ele estava no número $X$, ele não se lembrou dos próximos números.
Para ajudar Bino, imprima os próximos 10 valores inteiros maiores que $X$.
#### Entrada
A entrada consiste de uma linha contendo um inteiro $X$.
#### Saída
A saída consiste de uma linha contendo os 10 próximos números maiores que $X$ separados por um espaço.
#### Restrições
* $-100000 \leq X \leq 1000000$
|
2,378 | 17 | Game-10 | Fácil | Basicos | No princípio dos anos 1980 surgiram nos colégios os primeiros relógios de pulso digitais com joguinhos. Era uma febre entre os alunos e quem tinha um era muito popular na hora do recreio. Os joguinhos eram bem simples, mas muito legais. Um dos primeiros era o Game-10, no qual você controlava um avião que aparecia na parte direita do visor. Na parte esquerda aparecia um disco voador em qualquer uma de três posições, aleatoriamente, e lançava um míssil. O objetivo do jogador era movimentar o avião verticalmente para que ficasse na frente do disco voador (na mesma linha horizontal, do lado direito) e atirar para interceptar o míssil antes que esse atingisse o avião.
Como o movimento do avião era feito com apenas um botão, só dava para movimentar em um sentido: ao apertar o botão sucessivas vezes, o avião se movia na sequência de posições · · · 1 → 2 → 3 → 1 → 2 → 3 → 1 · · · Veja que, na situação da figura, o jogador deveria apertar o botão apenas uma vez, para ir da posição 1 para a posição 2, e conseguir atirar e interceptar o míssil.
Neste problema vamos considerar que existem $N$ posições e não apenas três. Dado o número de posições $N$, a posição D na qual o disco voador aparece, e a posição $A$ onde está o avião, seu programa deve computar o número mínimo de vezes que o jogador precisa apertar o botão para movimentar o avião até a mesma posição do disco voador e poder atirar!
#### Entrada
A primeira linha da entrada contém um inteiro $N$, o número de posições. A segunda linha contém um inteiro $D$, a posição do disco voador. A terceira linha contém um inteiro $A$, a posição do avião.
#### Saída
Seu programa deve imprimir uma linha contendo um inteiro, o número mínimo de vezes que o jogador deve apertar o botão para poder atirar.
#### Restrições
* $3 \leq N \leq 100$
* $1 \leq D, A \leq N$
|
2,379 | 337 | Torres de Hanói | Médio | Basicos | O quebra-cabeças Torres de Hanoi é muito antigo e conhecido, sendo constituído de um conjunto de N discos de tamanhos diferentes e três pinos verticais, nos quais os discos podem ser encaixados.
Cada pino pode conter uma pilha com qualquer número de discos, desde que cada disco não seja colocado acima de outro disco de menor tamanho. A configuração inicial consiste de todos os discos no pino 1. O objetivo do quebra-cabeças é mover todos os discos para um dos outros pinos, sempre obedecendo à restrição de não colocar um disco sobre outro menor.
Um algoritmo para resolver este problema é o seguinte.
```auto
procedimento Hanoi(N, Orig, Dest, Temp)
se N = 1 então
mover o menor disco do pino Orig para o pino Dest;
senão
Hanoi(N-1, Orig, Temp, Dest);
mover o N-ésimo menor disco do pino Orig para o pino Dest;
Hanoi(N-1, Temp, Dest, Orig);
fim-se
fim
```
Sua tarefa é escrever um programa que determine quantos movimentos de trocar um disco de um pino para outro serão executados pelo algoritmo acima para resolver o quebra-cabeça.
#### Entrada
A entrada possui vários conjuntos de teste. Cada conjunto de teste é composto por uma única linha, que contém um único número inteiro $N$, indicando o número de discos. O final da entrada é indicado por $N = 0$.
#### Saída
Para cada conjunto de teste, o seu programa deve escrever três linhas na saída. A primeira linha deve conter um identificador do conjunto de teste, no formato “Teste n”, onde n é numerado sequencialmente a partir de 1.
A segunda linha deve conter o número de movimentos que são executados pelo algoritmo dado para resolver o problema das Torres de Hanói com N discos. A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
#### Restrições
* $0 \leq N \leq 30$
|
2,380 | 1777 | Resolvendo um Exercício de Programação | Muito Fácil | Basicos | Olá, esse é um exercício de programação e um **tutorial de como resolver exercícios de programação** :).
**Caso você ainda não faça ideia do que seja programação não se preocupe**, vamos te ajudar com tudo que você precisa para completar esse exercício. Não se preocupe em entender tudo em detalhes agora, **essa é apenas uma prévia de tudo que você vai aprender no nosso próximo curso: [Introdução à Programação](https://neps.academy/br/course/introducao-a-programacao)**.
A seguir vamos explicar as diferentes secções que compõem um exercício de programação:
* Tarefa
* Entrada
* Saída
* Exemplos de entrada e saída
Para começar clique no botão **Escrever Solução** no canto superior direito.
### Tarefa
Todo exercício de programação tem um tarefa que você deve cumprir, nossa tarefa nesse exercício será a mesma tarefa que vimos na aula [Como aprender de maneira eficiente](https://neps.academy/br/course/como-aprender-programacao/lesson/como-aprender-de-maneira-eficiente):
> Na imagem abaixo temos um jogo onde o jogador consegue controlar onde a bolinha vai cair mudando os estados das portinhas $P$ e $R$. Por exemplo, caso a portinha $P$ esteja no estado 1 e a portinha $R$ esteja no estado 0 (exatamente como mostrado na Figura 1), a bolinha cairá no caminho B.
Sua tarefa é: dado os estados de $P$ e $R$ imprima onde cairá a bolinha.
Após entender a tarefa, precisamos escrever um código que complete tal tarefa, ou seja, precisamos desenvolver um **algoritmo**. Analisando a figura notamos os seguintes pontos:
1) Quando $P = 0$, a bola sempre cairá em C
2) Quando $P = 1$, o estado de $R$ é importante.
3) Se $P = 1$ e $R = 0$, ele cairá em B.
4) Se $P = 1$ e $R = 1$, ele cairá em A.
Colocando essas informações em código temos:
```auto
Se P = 0:
A bola cai em C
Se P = 1:
Se R = 0:
A bola cai em B
Se R = 1:
A bola cai em A
```
O código acima é chamado de pseudo código, pois se parece com um código, está estruturado como um código, mas ainda não é um código que o computador consegue executar. Para isso precisamos passar esse código para uma **linguagem de programação**.
**O Neps aceita diversas linguagens de programação**, você pode selecionar a linguagem que você vai usar, caso você não conheça nenhuma linguagem selecione a linguagem C (a primeira opção).
Todo exercício de programação irá descrever em detalhes como será a entrada dos dados no seu programa, em seguida você terá uma descrição de como você deve imprimir a saída.
#### Entrada
Nessa secção você terá a descrição da entrada do seu programa. Ou seja, a forma como os dados serão digitados no seu programa. Para esse exercício os dados serão dados da seguinte forma:
>A entrada é composta por apenas uma linha contendo dois números $P$ e $R$, indicando as posições das duas portinhas do flíper da figura.
_A informação que os dois números serão dados em uma única linha pode ser relevante dependendo da linguagem de programação que você está utilizando._
#### Saída
Nessa secção você terá a descrição de como seu programa deve imprimir a saída. Para esse exercício teremos:
>A saída do seu programa deve ser também apenas uma linha, contendo uma letra maiúscula que indica o caminho por onde a bolinha vai cair: 'A', 'B' ou 'C'.
É **muito importante** que você siga exatamente o formato descrito na saída. Tudo que você pedir para o seu programa imprimir faz parte da sua resposta, por isso imprima apenas o que for pedido.
#### Soluções
Você não encontrará essa secção nos demais exercícios, mas como esse é um tutorial nós **vamos te dar uma força** :D. A seguir nós traduzimos o pseudo código acima para diversas linguagens de programação.
Copie o código da linguagem de programação que você está utilizando entre os códigos de exemplos abaixo, você pode clicar no botão **copy** no canto superior direito de cada código para copiar todo o código. Cole o códigto na **área de código** ao lado e clique em **Enviar Solução**. Seu código será julgado pelo nosso Juiz e caso tudo esteja correto o resultado será mostrado em alguns segundos.
<details>
<summary>Mostrar código em C</summary>
```c
#include <stdio.h>
int main(){
int p, r;
// Ler os valores da entrada
scanf("%d %d", &p, &r);
// Se p igual a 0 a bolinha cai em C
if(p==0){
printf("C\n");
}
// Se p igual a 1 temos que verificar r
if(p==1){
// Se r igual a 0 a bolinha cai em B
if(r==0){
printf("B\n");
}
// Se r igual a 1 a bolinha cai em A
if(r==1){
printf("A\n");
}
}
return 0;
}
```
</details>
<details>
<summary>Mostrar código em C++</summary>
```cpp
#include<iostream>
using namespace std;
int main(){
int p, r;
// Ler os valores da entrada
cin >> p >> r;
// Se p igual a 0 a bolinha cai em C
if(p==0){
cout << "C" << endl;
}
// Se p igual a 1 temos que verificar r
if(p==1){
// Se r igual a 0 a bolinha cai em B
if(r==0){
cout << "B" << endl;
}
// Se r igual a 1 a bolinha cai em A
if(r==1){
cout << "A" << endl;
}
}
return 0;
}
```
</details>
<details>
<summary>Mostrar código em Python 3</summary>
```python
# Ler os valores da entrada
p, r = map(int, input().split())
# Se p igual a 0 a bolinha cai em C
if p==0:
print("C")
# Se p igual a 1 temos que verificar r
if p==1:
# Se r igual a 0 a bolinha cai em B
if r==0:
print("B")
# Se r igual a 1 a bolinha cai em A
if r==1:
print("A")
```
</details>
<details>
<summary>Mostrar código em Javascript</summary>
```javascript
// Ler os valores da entrada
const fs = require("fs");
const input = fs.readFileSync(0, "utf8");
let p = parseInt(input.split(" ")[0])
let r = parseInt(input.split(" ")[1])
// Se p igual a 0 a bolinha cai em C
if(p==0) {
console.log('C')
}
// Se p igual a 1 temos que verificar r
if(p == 1){
// Se r igual a 0 a bolinha cai em B
if(r == 0){
console.log('B')
}
// Se r igual a 0 a bolinha cai em A
if(r == 1){
console.log('A')
}
}
```
</details>
<details>
<summary>Mostrar código em Java</summary>
Em Java é importante que o nome da sua classe seja **Main**.
```java
import java.util.Scanner;
class Main {
public static void main(String[] args) {
Scanner ler = new Scanner(System.in);
int p, r;
p = ler.nextInt();
r = ler.nextInt();
// Se p igual a 0 a bolinha cai em C
if(p==0){
System.out.print("C");
}
// Se p igual a 1 temos que verificar r
if(p==1){
// Se r igual a 0 a bolinha cai em B
if(r==0){
System.out.print("B");
}
// Se r igual a 1 a bolinha cai em A
if(r==1){
System.out.print("A");
}
}
}
}
```
</details>
<br>
**A habilidade de saber se seu código está correto em tempo real é fantástica e vai acelerar muito seu aprendizado.**
#### Exemplos de entrada e saída
Os exemplos de entrada e saída mostrados abaixo mostram qual a saída esperada para cada entrada no seu programa. Por exemplo, caso a entrada do seu programa seja os números 1 e 0, seu programa deve imprimir como resposta a letra 'B'. **Exemplos de entrada e saída são testes preliminares, ao enviar seu código o Juiz testará com vários outros casos de testes**.
**Para finalizar, te desejo bons estudos e muito sucesso na sua jornada para se tornar um programador 💪.** |
2,381 | 51 | Jogo de Par ou Impar | Fácil | Basicos | Dois amigos, Alice e Bob, estão jogando um jogo muito simples, em que um deles grita ou “par” ou “ímpar” e o outro imediatamente responde ao contrário, respectivamente “ímpar” ou “par”. Em seguida, ambos exibem ao mesmo tempo uma mão cada um, em que alguns dedos estão estendidos e outros dobrados. Então eles contam o número total de dedos estendidos. Se a soma for par, quem gritou “par” ganha. Se a soma for ímpar, quem gritou “ímpar” ganha.
Por exemplo, suponhamos que a Alice gritou “par” e o Bob respondeu “ímpar”. Em seguida, Alice não deixou nenhum dos seus dedos estendidos, ao passo que Bob deixou três dedos estendidos. A soma então é três, que é ímpar, portanto Bob ganhou.
Seu programa deve determinar quem ganhou, tendo a informação de quem gritou par e o número de dedos estendidos de cada um.
#### Entrada
A entrada contém três linhas, cada uma com um número inteiro, $P$, $D_1$ e $D_2$, nesta ordem. Se $P$ = 0 então Alice gritou “par”, ao passo que se $P$ = 1 então Bob gritou “par”. Os números $D_1$ e $D_2$ indicam, respectivamente, o número de dedos estendidos da Alice e do Bob.
#### Saída
Seu programa deverá imprimir uma única linha, contendo um único número inteiro, que deve ser 0 se Alice foi a ganhadora, ou 1 se Bob foi o ganhador.
#### Restrições
* $P = 0$ ou $P = 1$
* $0 \leq D_1 \leq 5$
* $0 \leq D_2 \leq 5$ |
2,382 | 143 | Troco em Moedas | Médio | Basicos | Bino tem que fornecer $C$ centavos de troco e deseja fornecer esse troco com a menor quantidade possível de moedas. Bino possui infinitas moedas de um real, cinquenta centavos, vinte e cinco centavos, dez centavos, cinco centavos e de um centavo.
Faça um programa para ler um inteiro $C$ representando a quantidade de centavos que Bino tem que fornecer de troca. Imprima a quantidade de moedas que Bino forneceu e em seguida imprima a quantidade de cada tipo de moeda que Bino forneceu. <b>Tome muito cuidado com a formatação da sua saída</b>.
#### Entrada
A entrada consiste de uma única linha contendo o inteiro $C$.
#### Saída
A saída consiste de sete linhas. A primeira consiste de um inteiro representando a quantidade total de moedas. A segunda consiste na quantidade de moedas de um real utilizadas. A terceira consiste na quantidade de moedas de cinquenta centavos utilizadas. A quarta consiste na quantidade de moedas de vinte e cinco centavos utilizadas. A quinta consiste na quantidade de moedas de dez centavos utilizadas. A sexta consiste na quantidade de moedas de cinco centavos utilizadas. A sétima linha consiste na quantidade de moedas de um centavo utilizadas.
#### Restrições
* O valor fornecido não será negativo nem maior que 10000
|
2,383 | 323 | Desafio do Maior Número | Fácil | Basicos | Leonardo é um garoto muito criativo. Ele adora criar desafios para seus colegas da escola. Seu último desafio é o seguinte: diversos números são ditos em voz alta, quando o número 0 (zero) é dito então o desafio termina e seus colegas devem dizer imediatamente qual foi o maior número. Leonardo tem muita dificuldade de verificar se a resposta dada pelos colegas é correta ou não, pois a sequência de números costuma ser longa. Por este motivo, ele resolveu pedir sua ajuda.
Sua tarefa é escrever um programa que dada uma sequência de números inteiros positivos terminada por 0 (zero), imprime o maior número da sequência.
#### Entrada
A entrada é dada em uma única linha contendo uma sequência de números inteiros positivos. O último número da linha é 0 (zero).
#### Saída
Seu programa deve imprimir o maior número dentre os números da entrada.
#### Restrições
* $1 \leq$ tamanho da sequência $\leq 100$
* $1 \leq$ número da sequência $\leq 100$
|
2,384 | 177 | Pares ou com Último Algarismo Igual a 5 | Fácil | Basicos | Bino encontrou 3 números inteiros $X$, $Y$ e $Z$, e gostaria de saber quantos desses números são pares <b>OU</b> terminam com o algarismo 5.
#### Entrada
A entrada consiste de três linhas. A primeira linha contém um inteiro $X$. A segunda linha contém um inteiro $Y$. A terceira linha contém um inteiro $Z$.
#### Saída
A saída consiste de uma linha contendo a quantidade de números lidos que são pares ou tem o último algarismo igual a 5.
#### Restrições
* Os inteiros $X$, $Y$ e $Z$ são inteiros distintos, com valores entre 1 e 1000, inclusive. |
2,385 | 53 | Plantação de Morangos | Fácil | Basicos | Os administradores da Fazenda Fartura planejam criar uma nova plantação de morangos, no formato retangular. Eles têm vários locais possíveis para a nova plantação, com diferentes dimensões de comprimento e largura. Para os administradores, o melhor local é aquele que tem a maior área. Eles gostariam de ter um programa de computador que, dadas as dimensões de dois locais, determina o que tem maior área. Você pode ajudá-los?
#### Entrada
A entrada contém quatro linhas, cada uma contendo um número inteiro. As duas primeiras linhas indicam as dimensões (comprimento e largura) de um dos possíveis locais. As duas últimas linhas indicam as dimensões (comprimento e largura) de um outro possível local para a plantação de morangos. As dimensões são dadas em metros.
#### Saída
Seu programa deve escrever uma linha contendo um único inteiro, a área, em metros quadrados, do melhor local para a plantação, entre os dois locais dados na entrada
#### Restrições
* $1 \leq largura \leq 100$
* $1 \leq comprimento \leq 100$
|
2,386 | 252 | Frequência na Aula | Fácil | Basicos | Certa vez, numa aula, a professora passou um filme para os alunos assistirem. Durante este filme, ela passou uma lista de presença em sua sala para verificar a presença dos alunos, onde cada aluno deveria inserir apenas seu número de registro. Alguns alunos contudo, como possuem amigos que fogem da aula, decidiram ser camaradas e inseriram os números de registro de seus amigos fujões. O problema é que muitos alunos são amigos de alunos que fogem da aula e alguns números de registro acabaram sendo repetidamente inseridos na lista de presença. Além de tudo, alguns dos alunos que se esperava que não estivessem na aula de fato estavam!
A professora, ao notar que a lista de presença continha alguns números repetidos, ficou sem entender, mas decidiu dar um voto de confiança e dar presença a todos os alunos cujos números de registro estavam na lista. Como são muitos alunos na sala e muitos números com repetição, ela pediu a sua ajuda para determinar o total de alunos que receberam presença na aula.
#### Entrada
A primeira linha da entrada contém um número inteiro $N$, que informa a quantidade de números de registro que apareceram na lista de presença. Cada uma das $N$ linhas seguintes contém um número de registro $V_i$ que foi inserido na lista de presença.
#### Saída
Seu programa deve imprimir uma única linha, contendo apenas um número inteiro, o número de alunos que receberam presença.
#### Restrições
* $1 \leq N \leq 10^5$
* $0 \leq V_i \leq 10^6$
|
2,387 | 174 | Função Fatorial | Fácil | Basicos | Em matemática o fatorial de um número natural (representado por $N!$) é definido como o produto de todos os números naturais maiores que 0 e menores que esse número, e para o 0 é definido como 1 por ser o produto nulo.
$$N! = N \cdot (N - 1) \cdot (N - 2) \cdot ... \cdot 2 \cdot 1$$
Complete a função escrita em <b>Python 3</b> abaixo para calcular o fatórial de um número.
```python
def fatorial(N):
#Seu código aqui
N = int(input())
print(fatorial(N))
```
#### Entrada
A entrada contem um único número $N$.
#### Saída
O fatorial de $N$.
#### Restrições
* $0 \leq N \leq 12$ |
2,388 | 173 | Sequência de Fibonacci | Fácil | Basicos | Faça um programa para ler um inteiro $N$ e imprima os $N$ primeiros elementos da [Sequência de Fibonacci](https://pt.wikipedia.org/wiki/Sequ%C3%AAncia_de_Fibonacci) (Acesse o link caso não conheça essa sequência).
#### Entrada
A entrada consiste de uma linha contendo um inteiro $N$.
#### Saída
A saída consiste de uma linha contendo os $N$ primeiros elementos da sequência.
#### Restrições
* $0 < N \leq 15$
|
2,389 | 194 | Dois Vetores: Pares e Ímpares | Fácil | Basicos | Faça um programa para ler 10 valores, e imprima primeiro os pares lidos depois os ímpares.
Imprima os pares na mesma ordem que foram lidos. Imprima os ímpares na mesma ordem que foram lidos.
#### Entrada
A entrada consiste de 10 linhas, cada linha com um inteiro.
#### Saída
A saída consiste de duas linhas. A primeira contendo os pares lidos e segunda contendo os ímpares lidos. É garantido que, pelo menos, um inteiro seja par e um inteiro seja ímpar.
#### Restrições
* Nenhum valor fornecido terá valor absoluto maior que 100. |
2,390 | 219 | Tomadas | Fácil | Basicos | A Olimpíada Internacional de Informática (IOI, no original em inglês) é a mais prestigiada competição de programação para alunos de ensino médio; seus aproximadamente 300 competidores se reúnem em um país diferente todo ano para os dois dias de prova da competição. Naturalmente, os competidores usam o o tempo livre para acessar a Internet, programar e jogar em seus notebooks, mas eles se depararam com um problema: o saguão do hotel só tem uma tomada.
Felizmente, os quatro competidores da equipe brasileira da IOI trouxeram cada um uma régua de tomadas, permitindo assim ligar vários notebooks em uma tomada só; eles também podem ligar uma régua em outra para aumentar ainda mais o número de tomadas disponíveis. No entanto, como as réguas têm muitas tomadas, eles pediram para você escrever um programa que, dado o número de tomadas em cada régua, determina quantas tomadas podem ser disponibilizadas no saguão do hotel.
#### Entrada
A entrada consiste de uma linha com quatro inteiros positivos $T_1$, $T_2$, $T_3$, $T_4$, indicando o número de tomadas de cada uma das quatro réguas.
#### Saída
Seu programa deve imprimir uma única linha contendo um único número inteiro, indicando o número máximo de notebooks que podem ser conectados num mesmo instante.
#### Restrições
* $2 \leq T_i \leq 6$ |
2,391 | 399 | Vogais e Consoantes | Fácil | Basicos | Faça um programa para ler uma string $S$ (sem espaço). Seu programa deve imprimir duas listas. A primeira com todas as vogais da string e uma segunda com todas as consoantes da string.
#### Entrada
A entrada consiste de uma linha contendo uma string $S$.
#### Saída
A saída consiste de duas linhas. A primeira linha consiste da mensagem "Vogais: " seguida da string $S$ sem as consoantes. A segunda linha consiste da mensagem "Consoantes: " seguida da string $S$ sem suas vogais. Considere que apenas as letras 'a', 'e', 'i', 'o' e 'u' são vogais. Perceba nos exemplos de entrada e saída, que a ordem das letras na string $S$ se mantém na saída.
#### Restrições
* $1 \leq |S| \leq 50$
* A string contém apenas letras minúsculas do alfabeto
|
2,392 | 151 | Ordenação de Três Números | Fácil | Basicos | Bino recebeu três inteiros de Cino. Bino gostaria de ordenar esses três valores em ordem crescente. Ajude Bino em ordenar seus números queridos.
#### Entrada
A entrada consiste de três linhas. Cada uma das linhas consiste de um inteiro representando um inteiro que Bino recebeu.
#### Saída
A saída consiste de três linhas. Cada linha consiste de um dos números que Bino recebeu. Os números serão apresentados em ordem crescente.
#### Restrições
* Todos os valores fornecidos tem valor absoluto menor ou igual a 1000. |
2,393 | 199 | Soma das Linhas de Matriz 3x3 | Fácil | Basicos | Faça um programa para ler os elementos de uma matriz 3x3 e imprimir a soma de cada linha da matriz.
#### Entrada
A entrada consiste de 9 linhas. Cada linha contém um inteiro. Os 9 inteiros representam uma matriz 3x3 onde os três primeiros inteiros representam os valores da primeira linha.
#### Saída
A saída consiste de três linhas. Cada linha contém uma mensagem indicando qual a soma dos elementos de determinada linha. |
2,394 | 200 | Soma das Colunas de Matriz 3x3 | Fácil | Basicos | Faça um programa para ler os elementos de uma matriz 3x3 e imprimir a soma de cada coluna da matriz.
#### Entrada
A entrada consiste de 9 linhas. Cada linha contém um inteiro. Os 9 inteiros representam uma matriz 3x3 onde os três primeiros inteiros representam os valores da primeira linha.
#### Saída
A saída consiste de três linhas. Cada linha contém uma mensagem indicando qual a soma dos elementos de determinada coluna.
|
2,395 | 155 | Múltiplos de 2, 3 e 4 | Fácil | Basicos | Bino recebeu $N$ inteiros de presente. Ele gostaria de saber quantos múltiplos de 2, 3 e 4 ele recebeu.
#### Entrada
A entrada consiste de múltiplas linhas. A primeira linha consiste de um inteiro $N$, indicando quantos números Bino recebeu de presente. Cada uma das próximas $N$ contém um inteiro representando um inteiro que Bino recebeu.
#### Saída
A saída consiste de três linhas. A primeira linha contém a quantidade de números múltiplos de 2 que Bino recebeu. A segunda linha contém a quantidade de números múltiplos de 3 que Bino recebeu. A terceira linha contém a quantidade de números múltiplos de 4 que Bino recebeu.
#### Restrições
* $0 \leq N \leq 100$ |
2,396 | 175 | Função Primo | Fácil | Basicos | Modifique o código abaixo, adicionando o código da função <b>eh_primo</b>, que deve retornar <b>True</b> quando o número $x$ for primo e <b>False</b> caso contrário.
```python
def eh_primo(x):
#Seu código
x = int(input())
if eh_primo(x):
print('S')
else:
print('N')
```
#### Entrada
A entrada do seu programa será apenas uma linha contendo o número inteiro $x$.
#### Saída
Seu programa deve imprimir na saída padrão uma única linha contendo "S" caso o $x$ seja primo e "N" caso contrário.
#### Restrições
* $1 \leq x \leq 10^5$ |
2,397 | 15 | Teleférico | Fácil | Basicos | A turma do colégio vai fazer uma excursão na serra e todos os alunos e monitores vão tomar um teleférico para subir até o pico de uma montanha. A cabine do teleférico pode levar $C$ pessoas no máximo, contando alunos e monitores, durante uma viagem até o pico. Por questão de segurança, tem que ter pelo menos um monitor dentro da cabine junto com os alunos.
Por exemplo, se cabem $C = 10$ pessoas na cabine e a turma tem $A = 20$ alunos, o colégio poderia fazer três viagens: a primeira com 8 alunos e um monitor; a segunda com 6 alunos e um monitor; e a terceira com 6 alunos e um monitor. Você consegue ver que não seria possível fazer apenas duas viagens?
Dados como entrada a capacidade $C$ da cabine e o número total $A$ de alunos, você deve escrever um programa para calcular o número mínimo de viagens do teleférico.
#### Entrada
A primeira linha da entrada contém um inteiro $C$, representando a capacidade da cabine. A segunda linha da entrada contém um inteiro $A$, representando o número total de alunos na turma.
#### Saída
Seu programa deve imprimir uma linha contendo um número inteiro representando o número mínimo de viagens do teleférico para levar todos os alunos até o pico da montanha.
#### Restrições
* $2 \leq C \leq 100$
* $1 \leq A \leq 1000$
|
2,398 | 111 | Andando no Tempo | Fácil | Basicos | Imagine que você tenha uma máquina do tempo que pode ser usada no máximo três vezes, e a cada uso da máquina você pode escolher voltar para o passado ou ir para o futuro. A máquina possui três créditos fixos; cada crédito representa uma certa quantidade de anos, e pode ser usado para ir essa quantidade de anos para o passado ou para o futuro. Você pode fazer uma, duas ou três viagens, e cada um desses três créditos pode ser usado uma vez apenas.
Por exemplo, se os créditos forem 5, 12 e 9, você poderia decidir fazer duas viagens: ir 5 anos para o futuro e, depois, voltar 9 anos para o passado. Dessa forma, você terminaria quatro anos no passado, em 2012. Também poderia fazer três viagens, todas indo para o futuro, usando os créditos em qualquer ordem, terminando em 2042.
Neste problema, dados os valores dos três créditos da máquina, seu programa deve dizer se é ou não possível viajar no tempo e voltar para o presente, fazendo pelo menos uma viagem e, no máximo, três viagens; sempre usando cada um dos três créditos no máximo uma vez.
#### Entrada
A entrada consiste de uma linha contendo os valores dos três créditos $A$, $B$ e $C$.
#### Saída
Seu programa deve imprimir uma linha contendo o caracter “S” se é possível viajar e voltar para o presente, ou “N” caso contrário.
#### Restrições
* $1 \leq A, B, C \leq 1000$ |
2,399 | 95 | Máquina de Café | Médio | Basicos | O novo prédio da Sociedade Brasileira de Computação (SBC) possui 3 andares. Em determinadas épocas do ano, os funcionários da SBC bebem muito café. Por conta disso, a presidência da SBC decidiu presentear os funcionários com uma nova máquina de expresso. Esta máquina deve ser instalada em um dos 3 andares, mas a instalação deve ser feita de forma que as pessoas não percam muito tempo subindo e descendo escadas.
Cada funcionário da SBC bebe 1 café expresso por dia. Ele precisa ir do andar onde trabalha até o andar onde está a máquina e voltar para seu posto de trabalho. Todo funcionário leva 1 minuto para subir ou descer um andar. Como a SBC se importa muito com a eficiência, ela quer posicionar a máquina de forma a minimizar o tempo total gasto subindo e descendo escadas.
Sua tarefa é ajudar a diretoria a posicionar a máquina de forma a minimizar o tempo total gasto pelos funcionários subindo e descendo escadas.
#### Entrada
A entrada consiste em 3 números, $A_1$ , $A_2$ , $A_3$ ($0 \leq A_1$ , $A_2$ , $A_3 \leq 1000$), um por linha, onde $A_i$ representa o número de pessoas que trabalham no i-ésimo andar.
#### Saída
Seu programa deve imprimir uma única linha, contendo o número total de minutos a serem gastos com o melhor posicionamento possível da máquina. |
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.