id large_stringlengths 6 10 | platform large_stringclasses 3
values | source_id int64 10 11.5k | name large_stringlengths 2 50 | url large_stringlengths 32 67 | statement large_stringlengths 8 5.07k ⌀ | input_spec large_stringlengths 7 2.06k ⌀ | output_spec large_stringlengths 28 6.29k ⌀ | test_cases listlengths 0 6 | n_test_cases int64 0 6 | difficulty large_stringclasses 5
values | memory_limit large_stringclasses 6
values | time_limit large_stringclasses 87
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
neps:1759 | Neps Academy | 1,759 | A Camaradagem do Ringue | https://neps.academy/br/exercise/2107 | A Camaradagem do Ringue Box é um esporte realmente violento. Para compensar, existe um código de conduta para manter o cavalheirismo e a camaradagem no topo do ringue em jogos amigáveis. Uma das regras mais conhecidas deste código de conduta é evitar bater no adversário abaixo da cintura ou acima do pescoço. Dadas as a... | A primeira linha contém três números inteiros W , N W, \ N W , N e P , representando respectivamente a altura da cintura do adversário, a altura do seu pescoço, e o número de socos atirados ( 1 ≤ W < N ≤ 200 1 \ \leq \ W < N \ \leq \ 200 1 ≤ W < N ≤ 2 0 e 1 ≤ P ≤ 100 1 \ \leq \ P \ \leq \ 100 1 ≤ P ≤ 1 0 ). A segunda l... | null | [
{
"input": "80 150 3 10 100 160",
"output": "1"
},
{
"input": "80 150 3 80 100 150",
"output": "3"
},
{
"input": "2 199 5 2 1 200 199 1",
"output": "2"
}
] | 3 | Fácil | 256 mb | 1 second(s) |
neps:1805 | Neps Academy | 1,805 | Gude | https://neps.academy/br/exercise/352 | Gude Alice tem uma coleção de N bolinhas de gude, em que cada bolinha tem um certo tamanho. Ela quer vender a seu amigo Bob sua coleção inteira. Para comprar as bolinhas de gude, Bob pode separá-las em alguns saquinhos, da maneira que achar mais conveniente. Cada saquinho custa S reais. Ele comprará cada saquinho a um ... | Na primeira linha temos os inteiros N e S . Na linha seguinte seguirão N inteiros positivos representando o tamanho de cada bolinha de gude. | Imprima o menor preço possível que Bob terá de pagar. Restrições | [
{
"input": "3 2 1 2 5",
"output": "5"
},
{
"input": "4 10 2 1 2 1",
"output": "11"
},
{
"input": "7 3 20 22 11 3 8 7 8",
"output": "15"
}
] | 3 | Difícil | 256 mb | 1 second(s) |
neps:11120 | Neps Academy | 11,120 | Embaralhamento de Livros | https://neps.academy/br/exercise/3060 | Embaralhamento de Livros Uma longa prateleira de madeira sustenta N livros organizados ordenadamente da posição mais à esquerda 1 até a posição mais à direita N , cada livro com um rótulo único igual à sua posição inicial. Os rótulos aumentam da esquerda para a direita em ordem natural. Um dia, um bibliotecário curioso... | Três inteiros N , L e R , onde: N é o número total de livros na prateleira, L e R especificam as posições inicial e final do segmento invertido. | Imprima N inteiros — os rótulos dos livros na prateleira da mais à esquerda para a mais à direita após realizar a inversão entre as posições L e R . Restrições Destrave esse exercício com uma assinatura PRO | [] | 0 | Difícil | 256 mb | 1 second(s) |
neps:11292 | Neps Academy | 11,292 | Strings Espelhadas | https://neps.academy/br/exercise/2308 | Strings Espelhadas Um caractere é chamado de "caractere espelhado" se tiver a mesma aparência quando invertido para cima e para baixo, e a mesma aparência quando invertido para a esquerda e para a direita. Os caracteres espelhados em maiúsculos são 'H', 'I', 'O' e 'X'. Os caracteres espelhados em minúsculos são 'l' (já... | A primeira e única linha de entrada contém dois inteiros L e R ( 1 ≤ L ≤ R ≤ 1 0 6 1 \leq L \leq R \leq 10^6 1 ≤ L ≤ R ≤ 1 0 6 ), indicando o intervalo dos comprimentos das strings espelhadas que Tommy deseja contar. | Imprima o número de strings espelhadas que têm um comprimento m satisfazendo L ≤ m ≤ R L \leq m \leq R L ≤ m ≤ R . Como pode haver muitas dessas strings, você deve imprimir a resposta no módulo 1 0 9 + 7 10^9 + 7 1 0 9 + 7 (ou seja, o restante da resposta quando ela é dividida por 1 0 9 + 7 10^9 + 7 1 0 9 + 7 ). | [
{
"input": "1 4",
"output": "72"
},
{
"input": "2 3",
"output": "36"
},
{
"input": "2 1000000",
"output": "664868576"
}
] | 3 | Difícil | 512 mb | 1 second(s) |
neps:11109 | Neps Academy | 11,109 | Fechem as Portas! | https://neps.academy/br/exercise/2125 | Fechem as Portas! Madame Beauvoir possui uma mansão onde ela recebe todos os seus descendentes (netos e bisnetos) durante as férias. Sua mansão possui exatamente N quartos (cada quarto é numerado de 1 a N ), onde N é também a quantidade de netos e bisnetos (cada descendente é também numerado de 1 a N ). Como toda crian... | A única linha da entrada contém apenas um inteiro N ( 1 ≤ N ≤ 25 × 1 0 6 ) N \ (1 \ \leq \ N \ \leq \ 25 × 10^6) N ( 1 ≤ N ≤ 2 5 × 1 0 6 ) , indicando o número de portas e descendentes. | Seu programa deve produzir uma única linha, contendo uma sequência crescente de números correspondente aos identificadores dos quartos cujas portas estarão abertas após a entrada de todos os descendentes na mansão. | [
{
"input": "1",
"output": "1"
},
{
"input": "2",
"output": "1"
},
{
"input": "3",
"output": "1"
},
{
"input": "4",
"output": "1 4"
}
] | 4 | Médio | 256 mb | 1 second(s) |
neps:1813 | Neps Academy | 1,813 | Dia de Esportes | https://neps.academy/br/exercise/2015 | Dia de Esportes Aqui estão os N alunos da JOI High School, numerados de 1 a N . No próximo mês, a JOI High School terá um dia de esportes e todos os N alunos participarão do mesmo. Entre os estudantes, K estudantes pertencem ao grupo vermelho e N − K N-K N − K estudantes restantes pertencem ao grupo branco. Aoi, cujo s... | A entrada é fornecida pela entrada padrão no seguinte formato. N K K S S S | Imprima 'R' se Aoi pertence ao grupo vermelho, e 'W' se Aoi pertence ao grupo branco. Restrições | [
{
"input": "7 3 RWWRWW",
"output": "R"
},
{
"input": "5 3 RWRR",
"output": "W"
},
{
"input": "70 1 WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW",
"output": "R"
}
] | 3 | Fácil | 1024 mb | 2 second(s) |
neps:1477 | Neps Academy | 1,477 | Quase Primo | https://neps.academy/br/exercise/10 | Quase Primo O jovem César está aprendendo sobre números primos: um número X > 1 X > 1 X > 1 é primo se for divisível apenas por 1 e por X . A primeira tarefa de casa de César consiste em dizer, para um dado número N , quantos números menores ou iguais a N são primos. Acontece que os números são muito grandes e César te... | A primeira linha da entrada contém dois inteiros, N e K . A linha seguinte contém K primos distintos k i k_i k i , ( 1 ≤ i ≤ K 1 \leq i \leq K 1 ≤ i ≤ K ), que são os primos que César acha que o professor irá considerar. | Imprima um único inteiro, a quantidade de números inteiros positivos menores ou iguais a N que não são divisíveis por nenhum número na lista. Restrições | [
{
"input": "10 1 2",
"output": "5"
},
{
"input": "10 2 2 3",
"output": "3"
},
{
"input": "20 3 2 5 7",
"output": "7"
},
{
"input": "29 3 2 5 7",
"output": "10"
}
] | 4 | Difícil | 512 mb | 1 second(s) |
neps:1169 | Neps Academy | 1,169 | Gincana (OBI 2016) | https://neps.academy/br/exercise/3 | Gincana (OBI 2016) As duas turmas do terceiro ano de sua escola realizam anualmente uma gincana. Nessa gincana, a delegação de cada turma é dividida em grupos de K pessoas, de forma que K seja o maior número possível que divida as duas delegações sem que sobre alguém. Depois, os grupos competem uns com os outros, ganha... | A primeira e única linha contém dois inteiros N e M , representando respectivamente o tamanho da delegação rival e o tamanho da sua turma. | Seu programa deve produzir uma única linha, contendo um inteiro X , o maior tamanho possível da delegação da sua turma para o qual a gincana aconteça com grupos de uma pessoa. Restrições | [
{
"input": "9 6",
"output": "5"
},
{
"input": "6 9",
"output": "7"
},
{
"input": "6 3",
"output": "1"
},
{
"input": "2310 126",
"output": "113"
}
] | 4 | Médio | 256 mb | 1 second(s) |
neps:11134 | Neps Academy | 11,134 | Mudança de Hábito | https://neps.academy/br/exercise/1367 | Mudança de Hábito Uma empresa de desenvolvimento web resolveu inovar em sua infraestrutura física: o andar do prédio que ocupava foi totalmente reformado. Após a modificação, todas as salas de trabalho receberam portas que dão ou para o corredor central, que dá acesso às saídas, ou a uma sala de trabalho distinta. Mas ... | A primeira linha da entrada contém o número de salas S , o número de portas P que dão acesso a outras salas e o número N de equipes da empresa, separados por um espaço em branco. As P linhas seguintes descrevem as portas que conectam duas salas distintas, através de dois inteiros A e B , indicando que existe um porta q... | Imprima, em uma linha, o número mínimo de equipes que devem ceder membros para a ocupação do andar. Caso não seja cumprir os critérios de ocupação, deve ser impresso o número − 1 -1 − 1 . Restrições | [
{
"input": "4 4 5 1 2 2 3 3 4 1 4",
"output": "2"
},
{
"input": "3 3 2 1 2 1 3 3 2",
"output": "-1"
}
] | 2 | Difícil | 256 mb | 1 second(s) |
neps:1781 | Neps Academy | 1,781 | TV da Vovó | https://neps.academy/br/exercise/632 | TV da Vovó A vovó tem um televisor muito antigo, que ultimamente está exibindo um defeito incômodo: a imagem aparece ‘deslocada’ (para cima ou para baixo, para o lado direito ou para o lado esquerdo). Quando a imagem está deslocada para cima, a parte da imagem que deixa de ser vista na parte superior reaparece na parte... | A entrada possui vários conjuntos de teste. Cada conjunto de teste inicia com a descrição da matriz que representa a imagem do televisor. A primeira linha contém dois inteiros M e N representando o número de linhas e o número de colunas da matriz. As M linhas seguintes da entrada contém cada uma N inteiros, descrevendo... | Para cada conjunto de teste, o seu programa deve produzir uma imagem na saída. A primeira linha da saída deve conter um identificador do conjunto de teste, no formato “Teste n”, onde n é numerado sequencialmente a partir de 1. A seguir deve aparecer a matriz que representa a imagem resultante, no mesmo formato da image... | [
{
"input": "3 3 1 2 3 4 5 6 7 8 9 1 0 1 -1 0 0 3 4 6 7 8 5 10 11 12 9 2 3 4 1 -3 2 0 0 0 0",
"output": "Teste 1 8 9 7 2 3 1 5 6 4 Teste 2 1 2 3 4 5 6 7 8 9 10 11 12"
}
] | 1 | Médio | 256 mb | 1 second(s) |
neps:1296 | Neps Academy | 1,296 | Copa do Mundo (OBI 2014) | https://neps.academy/br/exercise/318 | Copa do Mundo (OBI 2014) A Nlogônia é atualmente um dos países com maior crescimento econômico no mundo, e seus governantes têm se esforçado para que o país seja mais conhecido e respeitado internacionalmente. Recentemente a Nlogônia foi escolhida para ser a sede da Copa do Mundo de Futebol Amador, e está se preparando... | A primeira linha da entrada contém três inteiros N , F e R , indicando respectivamente o número de cidades, de ferrovias e de rodovias. As cidades são identificadas por inteiros de 1 a N . Cada uma das F linhas seguintes descreve uma ferrovia e contém três inteiros A , B e C , onde A e B representam cidades e C represe... | Seu programa deve produzir uma única linha, contendo o menor custo possível para o conjunto de reformas de ferrovias e rodovias, obedecendo aos critérios estabelecidos. Restrições | [
{
"input": "3 3 2 1 2 1000 1 3 1000 2 3 900 1 3 800 2 3 700",
"output": "1900"
},
{
"input": "5 4 5 3 4 300 1 2 100 2 4 300 1 3 250 4 5 600 3 4 200 2 3 100 2 5 400 1 5 450",
"output": "1050"
},
{
"input": "5 2 3 4 5 60 2 3 60 1 2 50 1 4 50 3 4 50",
"output": "220"
}
] | 3 | Difícil | 256 mb | 1 second(s) |
neps:11349 | Neps Academy | 11,349 | Dissonância quadrática | https://neps.academy/br/exercise/2346 | Dissonância quadrática Oh não! Tanto você quanto seu colega de laboratório esqueceram de completar uma parte da última tarefa e ela deve ser entregue em uma hora! O objetivo dessa tarefa de laboratório era fazer uma análise de alguns dados experimentais, encontrar uma função quadrática que melhor descreva os dados e re... | A entrada consiste de uma única linha contendo quatro números inteiros A , B , C , D A, B, C, D A , B , C , D , cada um estando no intervalo [ − 1 , 000 , 1 , 000 ] [-1, 000, 1, 000] [ − 1 , 0 , 1 , 0 ] . | Exiba dois valores x ∗ , h ( x ∗ ) x^*, h(x^*) x ∗ , h ( x ∗ ) em uma única linha, onde x ∗ x^* x ∗ é o ponto que minimiza a função h ( x ) = max h(x) = \max h ( x ) = max { x 2 + A ⋅ x + B , x 2 + C ⋅ x + D x^2 + A \cdot x + B, x^2 + C \cdot x + D x 2 + A ⋅ x + B , x 2 + C ⋅ x + D }. Sua resposta será aceita se ambo... | [
{
"input": "1 0 0 1",
"output": "0 1"
},
{
"input": "2 -1 0 -2",
"output": "-0.5 -1.75"
},
{
"input": "3 1 3 -2",
"output": "-1.5 -1.25"
},
{
"input": "2 2 2 2",
"output": "-1 1"
},
{
"input": "25 -73 -23 41",
"output": "2.375 -7.984375"
}
] | 5 | Difícil | 1024 mb | 1 second(s) |
neps:11216 | Neps Academy | 11,216 | Empresa de Festas | https://neps.academy/br/exercise/1173 | Empresa de Festas Yankovich trabalha como Engenheiro de Software numa empresa, chamada POI , que promove festas online. Para testar os seus sistemas, os empregados organizaram festas e convidaram colegas, mas com algumas restrições. A empresa tem uma estrutura hierárquica: Cada empregado, com exceção do dono da empresa... | A entrada consiste de várias linhas. A primeira linha contém dois inteiros N e M ( 1 ≤ N , M ≤ 1 0 5 ) (1 \leq N, M \leq 10^5) ( 1 ≤ N , M ≤ 1 0 5 ) representando o número de empregados e o número de festas de teste, respectivamente. As próximas N linhas contêm a estrutura hierárquica da empresa. A i -ésima dessas linh... | Imprima uma única linha contendo N inteiros (separados por um único espaço). O i -ésimo desses números deve ser o número de festas de que o empregado i participou. | [
{
"input": "10 3 8 1 3 5 5 1 2 3 4 1 3 3 1 2 7 1 2 2 3 2 3 5 9 5 3 8 3 2 6",
"output": "2 1 3 1 2 0 2 0 1"
}
] | 1 | Super Difícil | 256 mb | 1 second(s) |
neps:1624 | Neps Academy | 1,624 | Capitais | https://neps.academy/br/exercise/62 | Capitais A Linearlândia construiu uma rede de ferrovias de alta velocidade, ligando certos pares de cidades, de modo que: é possível viajar entre qualquer par de cidades usando apenas ferrovias; e há apenas um caminho de ferrovias (sequência de ferrovias) entre qualquer par de cidades. Existe muita disputa entre as cap... | A primeira linha da entrada contém um inteiro N , o número de cidades. As cidades são identificadas por inteiros de 1 a N . As N − 1 N-1 N − 1 linhas seguintes contém, cada uma, dois inteiros U e V , representando um par de cidades ligadas por uma ferrovia. | Seu programa deve produzir uma única linha, contendo um único inteiro, a menor distância-ferrovia entre todos os pares capitais. Restrições | [
{
"input": "8 1 2 2 3 3 4 5 3 6 5 6 7 8 7",
"output": "3"
},
{
"input": "2 1 2",
"output": "1"
}
] | 2 | Difícil | 256 mb | 1 second(s) |
neps:11375 | Neps Academy | 11,375 | Eficiência energética | https://neps.academy/br/exercise/2087 | Eficiência energética O projeto de chips avançados para computadores de alto desempenho é um desafio, principalmente em termos de eficiência energética. Considere o problema de n computadores, cada uma com dois chips, onde cada chip é alimentado por K baterias. Projetar os chips não é complicado, mas a fonte de aliment... | A entrada consiste em um único caso de teste. Um caso de teste consiste em duas linhas. A primeira linha contém dois inteiros positivos: o número de computadores N e o número de baterias por chip K ( 2 N K 2NK 2 N K ≤ 1 0 6 10^6 1 0 6 ). A segunda linha contém 2 N K 2NK 2 N K inteiros P i P_i P i especificando as saí... | Exiba o menor número D de modo que você possa alocar as baterias de modo que a diferença de potência de saída dos dois chips em cada computador seja no máximo D . | [
{
"input": "2 3 1 2 3 4 5 6 7 8 9 10 11 12",
"output": "1"
},
{
"input": "2 2 3 1 3 3 3 3 3 3",
"output": "2"
}
] | 2 | Difícil | 256 mb | 1 second(s) |
neps:1363 | Neps Academy | 1,363 | Inteiro de dois dígitos | https://neps.academy/br/exercise/2406 | Inteiro de dois dígitos Dados dois números A e B . Imprima um número inteiro positivo de dois dígitos cuja casa das dezenas seja A e cuja casa das unidades seja B . | A entrada é dada no seguinte formato. A B B B | Imprima um número inteiro positivo de 2 dígitos cujo dígito das dezenas é A e o dígito das unidades é B . Restrições A | [
{
"input": "2 2",
"output": "22"
},
{
"input": "1 0",
"output": "10"
},
{
"input": "1 9",
"output": "19"
}
] | 3 | Super Fácil | 1024 mb | 2 second(s) |
neps:11353 | Neps Academy | 11,353 | Runas mágicas | https://neps.academy/br/exercise/2342 | Runas mágicas Você mantém uma coleção muito bonita de runas mágicas. Elas geralmente vêm em dois tipos, tipo A e tipo B. Você organizou suas runas em uma prateleira para exibi-las. Como são runas mágicas, elas mudam a cada dia. Ou seja, no início de cada dia, a runa mais à esquerda mudará de tipo (ou de A para B, ou de... | A entrada consiste em uma única linha que começa com uma sequência S de caracteres, seguida por um número inteiro D . O comprimento de S estará entre 1 e 30 3 0 (inclusive), e S consistirá apenas dos caracteres A e B. O valor de D satisfaz 0 ≤ D < 2 30 0 \leq D < 2^{30} 0 ≤ D < 2 3 0 . Por fim, você também tem a garant... | Exiba uma única sequência mostrando os estados das runas após D dias terem se passado, dadas as condições iniciais de S . | [
{
"input": "ABBAA 2",
"output": "AAABA"
},
{
"input": "ABAA 4",
"output": "ABBA"
},
{
"input": "ABBABBABBABBABBABBABBABBABBABA 536870912",
"output": "ABBABBABBABBABBABBABBABBABBABB"
}
] | 3 | Difícil | 1024 mb | 1 second(s) |
neps:1452 | Neps Academy | 1,452 | Coleção de Upas | https://neps.academy/br/exercise/568 | Coleção de Upas Mayuri é uma jovem que adora colecionar Upas. Ela está sempre procurando pelos melhores Upas para melhorar sua coleção. Cada Upa possui uma cor única e como Mayuri é muito perfeccionista ela não acha que todas cores combinam juntas, então ela resolveu escrever uma lista com pares de cores que não combin... | A primeira linha da entrada contém dois números inteiros N e M , indicando respectivamente o número de Upas e o tamanho da lista de pares de cores que não combinam. As próximas M linhas contêm, cada uma, dois inteiros U e V , indicando que as cores U e V não combinam. | Seu programa deve produzir duas linhas de saída. A primeira linha da saída é composta por um inteiro Q indicando a quantidade de Upas que Mayuri deve manter na coleção. A segunda linha da saída deve ser composta por Q inteiros, indicando quais Upas ela manter na coleção, em ordem crescente de cor . Restrições | [
{
"input": "10 4 10 9 8 7 8 6 1 2",
"output": "6 2 3 4 5 8 10"
},
{
"input": "13 19 12 1 12 2 12 3 12 4 10 5 13 6 3 7 1 8 1 9 11 10 7 11 12 13 1 5 9 13 6 2 8 11 8 7 11 3 7 12",
"output": "5 2 4 5 11 13"
}
] | 2 | Difícil | 256 mb | 1 second(s) |
neps:1570 | Neps Academy | 1,570 | Par de palitos | https://neps.academy/br/exercise/2481 | Par de palitos Leo Paes é um menino apaixonado por comida birmanesa e, enquanto desfrutava de um delicioso prato, ele percebeu um detalhe incoveniente: os palitos usados para saborear sua refeição tinham alturas diferentes. Assim, ele decidiu procurar os dois palitos com a menor diferença de altura entre si. Escreva um... | A primeira linha contém um número inteiro N ( 2 ≤ N ≤ 1 0 5 2 \le N \le 10^5 2 ≤ N ≤ 1 0 5 ), representando o número de palitos disponíveis. A segunda linha contém N números inteiros separados por espaços, A 1 , A 2 , . , A N A_1, A_2, ..., A_N A 1 , A 2 , . , A N ( 1 ≤ A i ≤ 1 0 9 1 \le A_i \le 10^9 1 ≤ A i ≤ ... | Seu programa deve imprimir uma única linha contendo um único inteiro: a resposta para o problema. Restrições | [
{
"input": "5 10 4 6 1 4",
"output": "0"
},
{
"input": "2 1 10",
"output": "9"
}
] | 2 | Difícil | 256 mb | 1 second(s) |
neps:1456 | Neps Academy | 1,456 | Pirâmide | https://neps.academy/br/exercise/2570 | Pirâmide O mais novo lançamento da OBI (Organização de Brincadeiras Infantis) é o jogo Balanceamento de Pirâmide, que visa explorar as habilidades matemáticas das crianças. O jogo contém seis cubos, todos de mesmo tamanho mas com pesos possivelmente diferentes (os cubos são preenchidos com diferentes volumes de areia).... | A única linha da entrada contém seis números inteiros positivos X i X_i X i ( 1 ≤ i ≤ 6 1 \leq i \leq 6 1 ≤ i ≤ 6 ), indicando os pesos em gramas de cada um dos seis cubos, separados por espaços. | Seu programa deverá imprimir uma única linha contendo um único caractere: ‘S’ (sem aspas), se é possível formar uma pirâmide balanceada com os seis cubos, ou ‘N’ (sem aspas), se é impossível. Restrições | [
{
"input": "6 5 4 14 5 8",
"output": "S"
},
{
"input": "10 1 1",
"output": "N"
},
{
"input": "10 30 50 70 80 120",
"output": "S"
},
{
"input": "4 8 12 24 20 16",
"output": "N"
}
] | 4 | Difícil | 256 mb | 1 second(s) |
neps:11167 | Neps Academy | 11,167 | Caminhada pela Floresta | https://neps.academy/br/exercise/3059 | Caminhada pela Floresta Um explorador está diante de uma longa fileira de N árvores antigas, cada uma dotada de uma pontuação de beleza única. Ele planeja embarcar em uma caminhada que visita exatamente M árvores consecutivas. À medida que avança, sua apreciação pela paisagem se aprofunda, de modo que a j -ésima árvore... | A primeira linha contém dois inteiros N e M . A segunda linha contém N inteiros A 1 , A 2 , … , A N A_1, A_2, \dots, A_N A 1 , A 2 , … , A N , as pontuações de beleza das árvores. | Destrave esse exercício com uma assinatura PRO | [] | 0 | Difícil | 256 mb | 1 second(s) |
neps:11276 | Neps Academy | 11,276 | Desvio | https://neps.academy/br/exercise/2611 | Desvio Na cidade de Nlogonia, o prefeito finalmente vai cumprir sua promessa de campanha e irá repavimentar alguns trechos de ruas. Contudo, enquanto um trecho estiver sendo repavimentado, os carros não poderão usá-lo e portanto um desvio deve ser utilizado. Cada trecho de rua conecta duas esquinas na cidade, tem compr... | A primeira linha contém dois inteiros, N e M ( 1 ≤ N ≤ 300 ) M \ (1 \leq N \leq 300) M ( 1 ≤ N ≤ 3 0 ) , que representam, respectivamente, o número de esquinas e o número de trechos de ruas. Cada uma das M linhas seguintes contém três inteiros: U , V U, \ V U , V , e L ( 1 ≤ U ≤ N , 1 ≤ V ≤ N , U ≠ V , 1 ≤ L ≤ 1 0 6 ) ... | Imprima M linhas, onde cada linha contém um inteiro. O i -ésimo inteiro deve ser o comprimento do desvio mais curto para o i -ésimo trecho, ou − 1 -1 − 1 se não for possível fazer um desvio. A ordem dos trechos na saída deve ser a mesma ordem fornecida na entrada. | [
{
"input": "4 5 1 2 4 1 3 8 2 3 4 4 1 2 3 4 3",
"output": "9 5 9 11 10"
},
{
"input": "2 1 1 2 1",
"output": "-1"
}
] | 2 | Difícil | 512 mb | 6 second(s) |
neps:11082 | Neps Academy | 11,082 | Dominós Decorativos | https://neps.academy/br/exercise/1195 | Dominós Decorativos Maria gosta de dominós. Ela é muito jovem para entender completamente o jogo, então ela apenas cria arranjos com base na seguinte regra simples: Cada uma das pontas de um dominó devem estar adjacentes à ponta de outro dominó com o mesmo número. Figura 1 : Visualização do primeiro caso de teste Hoje,... | A entrada consiste em: Uma linha com um inteiro n , o número de dominós no arranjo de Maria. n linhas, cada uma com quatro inteiros x 1 x_1 x 1 , y 1 y_1 y 1 , x 2 x_2 x 2 , y 2 y_2 y 2 , onde ( x 1 , y 1 ) (x_1, y_1) ( x 1 , y 1 ) e ( x 2 , y 2 ) (x_2, y_2) ( x 2 , y 2 ) são as posições no grid das dua... | Se uma numeração válida existir, imprima n linhas, onde a i -ésima linha contém dois inteiros, os inteiros que Maria deve escrever nas pontas do i -ésimo dominó, respectivamente. Imprima os números na mesma ordem que os dominós (incluindo as duas pontas) aparecem na entrada. Todos os números da saída devem ser inteiros... | [
{
"input": "4 1 1 1 2 2 2 3 2 2 1 3 1 1 3 2 3",
"output": "0 3 1 2 0 2 3 1"
},
{
"input": "4 1 1 2 1 1 2 2 2 4 2 4 3 4 4 3 4",
"output": "impossible"
}
] | 2 | Difícil | 512 mb | 1 second(s) |
neps:11141 | Neps Academy | 11,141 | Titãs do Arremesso | https://neps.academy/br/exercise/3025 | Titãs do Arremesso Bem-vindo ao torneio definitivo de arremesso de moedas onde a sorte encontra a precisão! Neste concurso, N competidores demonstraram sua sorte ao lançar moedas repetidamente, e cada lançamento influenciou sua jornada. O desempenho de cada jogador é determinado pelo número de lançamentos bem-sucedidos... | A primeira linha contém um inteiro N , o número de competidores. Cada uma das N linhas seguintes contém dois inteiros A i A_i A i e B i B_i B i , representando o número de caras e coroas registradas pelo competidor i , respectivamente. | A saída deve ser uma permutação dos inteiros 1 , 2 , … , N 1, 2, \dots, N 1 , 2 , … , N , correspondendo aos competidores classificados em ordem decrescente de sua taxa de sucesso. Em caso de empate, competidores com índices menores vêm primeiro. Destrave esse exercício com uma assinatura PRO | [] | 0 | Difícil | 256 mb | 1 second(s) |
neps:1685 | Neps Academy | 1,685 | Melhor Campus | https://neps.academy/br/exercise/1760 | Melhor Campus Bino está terminando o ensino médio e está em dúvida sobre qual campus do IFCE ele deve cursar o ensino superior. Bino mora em Ubaúna, uma cidade igualmente próxima dos campus: Sobral, Ubajara e Tianguá. Para ajudar nessa difícil decisão, Cino deu para Bino uma rosa, e disse para ele escolher o campus de ... | A entrada contém uma única linha com um inteiro P ( 1 ≤ P ≤ 100 1 \leq P \leq 100 1 ≤ P ≤ 1 0 ), indicando a quantidade de pétalas da rosa que Cino deu para Bino. | A saída consiste em uma única linha contendo o nome do campus escolhido (lembre-se de não usar acentos). | [
{
"input": "1",
"output": "Sobral"
},
{
"input": "5",
"output": "Ubajara"
},
{
"input": "9",
"output": "Tiangua"
}
] | 3 | Fácil | 256 mb | 1 second(s) |
neps:1276 | Neps Academy | 1,276 | Morreu ou não Morreu | https://neps.academy/br/exercise/732 | Morreu ou não Morreu? Em jogos de RPG é comum cenários onde o personagem recebe certa quantidade de dano e é necessário saber se o personagem sobreviveu ou morreu após receber o dano. É exatamente isso que o código abaixo deveria fazer. #include <stdio.h> #include <stdlib.h> struct Personagem { char nome[50]; int ataqu... | A entrada consiste de 5 linas. A primeira linha contém o nome do personagem em questão, a segunda linha o atributo de ataque do personagem, a terceira linha contém o atributo de defesa, a quarta linha contém os pontos de vida do personagem e a última linha contém a quantidade de dano que o golpe irá causar. | A saída do seu programa deve ser o nome do personagem seguido de " sobreviveu!!!" caso o personagem sobreviva ao golpe ou o nome do personagem seguido de " morreu:(" caso contrário. O dano final é calculado pelo dano do golpe menos o atributo de defesa do personagem. Restrições O nome do personagem pode ter até 40 cara... | [
{
"input": "Ronaldo 4 3 10 12",
"output": "Ronaldo sobreviveu!!!"
},
{
"input": "Tevez 4 3 10 13",
"output": "Tevez morreu :("
}
] | 2 | Fácil | 256 mb | 1 second(s) |
neps:11063 | Neps Academy | 11,063 | Chuva (Seletiva IOI 2017) | https://neps.academy/br/exercise/382 | Chuva (Seletiva IOI 2017) A água da chuva contém muitas informações importantes sobre a composição química da atmosfera de uma determinada região. Por isto, anualmente a organização da IOI encomenda um estudo de amostras de chuva da cidade que se propõe a sedear a próxima edição da competição, antes de expor os competi... | A primeira linha da entrada contém três inteiros N , M e K . Os dois primeiros representam o número de linhas e de colunas da matriz de alturas, enquanto o terceiro representa o número de coletores espalhados pela cidade. As próximas N linhas contem M inteiros cada, de forma que o j-ésimo inteiro da i-ésima linha repre... | Para cada uma das consultas, imprima uma linha contendo um único inteiro representando o número de coletores que receberão água caso chova no retângulo da consulta. Restrições | [
{
"input": "5 5 2 6 6 6 6 6 1 2 3 4 5 5 4 3 4 5 7 1 2 1 7 6 6 6 6 6 4 3 2 3 5 1 2 3 4 3 2 3 3 3 2 5 2 1 1 1 5 5 5 5 5",
"output": "2 2 1"
},
{
"input": "1 8 3 6 4 6 7 6 5 4 5 1 2 1 4 1 7 6 1 1 1 3 1 3 1 3 1 3 1 4 1 5 1 6 1 5 1 8 1 8 1 8",
"output": "1 1 3 1 1"
}
] | 2 | Super Difícil | 512 mb | 6 second(s) |
neps:153 | Neps Academy | 153 | Cartas | https://neps.academy/br/exercise/20 | Cartas 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 sua... | 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. | Seu programa deve imprimir uma linha contendo um inteiro representando o número que está na carta que ainda falta virar. Restrições | [
{
"input": "40 11 40",
"output": "11"
},
{
"input": "8 8 96",
"output": "96"
}
] | 2 | Super Fácil | 256 mb | 1 second(s) |
neps:114 | Neps Academy | 114 | Prêmio do Milhão | https://neps.academy/br/exercise/48 | Prêmio do Milhão 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 u... | 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... | 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 | [
{
"input": "5 100 99900 400000 500000 600000",
"output": "4"
},
{
"input": "1 1000000",
"output": "1"
}
] | 2 | Fácil | 256 mb | 1 second(s) |
neps:1304 | Neps Academy | 1,304 | Casamento de inteiros | https://neps.academy/br/exercise/1773 | Casamento de inteiros Vamos definir a operação de casamento de dois números inteiros A e B da seguinte forma: inicialmente fazemos A e B terem o mesmo número de dígitos, adicionando zeros à esquerda conforme necessário; então cada dígito de A (do menos significativo ao mais significativo) é comparado com o dígito corre... | A primeira linha da entrada contém um número inteiro A , a segunda linha contém um número inteiro B . | Seu programa deve produzir uma única linha, contendo os dois números inteiros produzidos pelo casamento dos números dados, em ordem não decrescente. Restrições | [
{
"input": "69961 487920",
"output": "489 9961"
},
{
"input": "5678 1234",
"output": "-1 5678"
},
{
"input": "21 12",
"output": "2 2"
},
{
"input": "200 100",
"output": "0 200"
}
] | 4 | Médio | 256 mb | 1 second(s) |
neps:1925 | Neps Academy | 1,925 | Pilha de Divisores | https://neps.academy/br/exercise/1396 | Pilha de Divisores Dado um deque de N cartas, retire a carta do topo do deque a separe numa pilha de descarte, após isso quantas cartas seriam possíveis de serem retiradas do topo do deque, sendo que, a carta deverá sempre ser divisora da carta que está no topo do baralho de descarte? Input A primeira linha da entrada ... | null | null | [
{
"input": "3 3 6 24",
"output": "2"
},
{
"input": "2 1 99999",
"output": "1"
},
{
"input": "8 1 2 4 8 16 32 576 8670",
"output": "6"
}
] | 3 | null | 256 mb | 1 second(s) |
neps:1375 | Neps Academy | 1,375 | Cifra da Nlogônia | https://neps.academy/br/exercise/1487 | Cifra da Nlogônia O rei da Nlogônia ordenou que todos os documentos importantes sejam “cifrados”, para que apenas quem tem conhecimento da cifra possa lê-los (cifrar um documento significa alterar o original modificando as letras de acordo com algum algoritmo de cifra). O rei decretou que o seguinte algotimo deve ser u... | A primeira e única linha da entrada contém uma palavra P formada por letras minúsculas sem acentuação. | Seu programa deve produzir uma única linha, contendo a palavra cifrada. Restrições A palavra | [
{
"input": "ter",
"output": "tuveros"
},
{
"input": "rei",
"output": "rosei"
},
{
"input": "arteiro",
"output": "arostuveiroso"
}
] | 3 | Médio | 256 mb | 1 second(s) |
neps:1703 | Neps Academy | 1,703 | Bits Trocados | https://neps.academy/br/exercise/649 | Bits Trocados As Ilhas Weblands formam um reino independente nos mares do Pacífico. Como é um reino recente, a sociedade é muito influenciada pela informática. A moeda oficial é o Bit; existem notas de B\ \ 50,00 , B$\ 10,00$, B\ \ 5,00 e B$\ 1,00$. Você foi contratado(a) para ajudar na programação dos caixas automátic... | A entrada é composta de vários conjuntos de teste. Cada conjunto de teste é composto por uma única linha, que contém um número inteiro positivo V , que indica o valor solicitado pelo cliente. O final da entrada é indicado por V = 0 V = 0 V = 0 . | Para cada conjunto de teste da entrada seu programa deve produzir três linhas na saída. A primeira linha deve conter um identificador do conjunto de teste, no formato “Teste n”, onde n é numerado a partir de 1. Na segunda linha devem aparecer quatro inteiros I , J , K e L que representam o resultado encontrado pelo seu... | [
{
"input": "1 72 0",
"output": "Teste 1 0 0 0 1 Teste 2 1 2 0 2"
}
] | 1 | Fácil | 256 mb | 1 second(s) |
neps:1608 | Neps Academy | 1,608 | Meu Vetor Dinâmico | https://neps.academy/br/exercise/746 | Meu Vetor Dinâmico Um vetor dinâmico é um vetor que pode aumentar ou diminuir seu tamanho quando necessário. O código abaixo mostra a implementação de um vetor dinâmico, porém algumas poucas partes estão falando. Sua tarefa é completar o código abaixo. Siga os TODO s com instruções no código. #include <stdio.h> templat... | A entrada é composta de várias linhas. A primeira linha contém um inteiro N . As próxima N linhas contém uma operação cada: Caso a linha comece com um caractere 'A' ela será seguida de um inteiro x que deve ser adicionado no final do vetor. Caso a linha comece com um caractere 'R' o último elemento do vetor deve ser re... | Seu programa deve imprimir todos os elementos do vetor após as N operações. Restrições | [
{
"input": "5 R A 10 A 7",
"output": "10 7"
},
{
"input": "10 A 1 A 2 A 3 A 4 A 5 A 6 A 7 R A 8",
"output": "1 2 3 4 5 8"
}
] | 2 | Médio | 256 mb | 1 second(s) |
neps:11 | Neps Academy | 11 | Soma Fácil | https://neps.academy/br/exercise/134 | Soma Fácil Faça um programa para ler dois valores inteiros A e B e imprima o resultado da expressão ( A + B ) (A+B) ( A + B ) . | A entrada consiste de duas linhas. A primeira linha contém o inteiro A e a segunda linha contém o inteiro B . | A saída consiste de uma linha contendo o resultado da expressão ( A + B ) (A+B) ( A + B ) . Restrições Os inteiros fornecidos não terão valor absoluto maior que 1000. | [
{
"input": "2 3",
"output": "5"
},
{
"input": "-2 3",
"output": "1"
},
{
"input": "10 89",
"output": "99"
}
] | 3 | Super Fácil | 256 mb | 1 second(s) |
neps:1210 | Neps Academy | 1,210 | Restante | https://neps.academy/br/exercise/2004 | Restante Dado um inteiro X positivo, dividir X por 21 e imprimir o resto. | A entrada é fornecida pela entrada padrão no seguinte formato. X X | Imprima o restante obtido dividindo X por 21. Restrições | [
{
"input": "50",
"output": "8"
},
{
"input": "42",
"output": "0"
},
{
"input": "5",
"output": "5"
}
] | 3 | Super Fácil | 1024 mb | 2 second(s) |
neps:1301 | Neps Academy | 1,301 | Chuva (OBI 2011) | https://neps.academy/br/exercise/533 | Chuva (OBI 2011) Bob trabalha no OBM (Órgão Brasileiro de Metereologia), que é a organização responsável pela medição dos índices pluviométricos (quantidade de chuva acumulada) em todo o país. Eles são muito eficientes no que fazem, mas estão com um problema: eles não sabem como proceder para calcular a quantidade acum... | A primeira linha da entrada contém um inteiro N indicando a dimensão dos dois mapas que devem ser lidos. Nas próximas 2 N 2N 2 N linhas são dados os dois mapas, cada mapa indicando a quantidade de chuva acumulada nas regiões em um período. Cada mapa é descrito em N linhas consecutivas, cada linha contendo N inteiros, s... | A saída deverá conter N linhas, com N inteiros em cada linha, indicando a quantidade de chuva acumulada total em cada uma das regiões nos dois períodos considerados. Restrições | [
{
"input": "2 1 2 3 4 10 11 12 13",
"output": "11 13 15 17"
},
{
"input": "3 1 1 1 1 2 2 1 2 3 3 2 1 2 2 1 1 1 1",
"output": "4 3 2 3 4 3 2 3 4"
}
] | 2 | Fácil | 256 mb | 1 second(s) |
neps:1792 | Neps Academy | 1,792 | Viagem Espacial | https://neps.academy/br/exercise/596 | Viagem Espacial A empresa de jogos Sonyc está desenvolvendo um novo jogo de naves espaciais, chamado Space Traveller (Viajante Espacial). O objetivo do jogo é viajar entre dois pontos sem colidir com nenhum asteroide no caminho. Para o protótipo, você foi contratado para implementar o programa responsável por verificar... | 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 quatro números inteiros N , X c X_c X c , Y c Y_c Y c e R indicando, respectivamente, o número de tiros, as duas coordenadas no plano do centro do asteroide ( ... | Seu programa deve imprimir, na saída padrão, uma ´unica linha, contendo um inteiro, indicando quantos tiros atingiram o asteroide. Restrições | [
{
"input": "2 10 10 5 10 1 10 3 4 11 4 10",
"output": "1"
},
{
"input": "2 5 5 1 0 0 0 1 0 0 1 0",
"output": "0"
},
{
"input": "3 6 4 2 1 4 2 4 1 5 6 4 0 0 6 1",
"output": "2"
}
] | 3 | Difícil | 256 mb | 1 second(s) |
neps:1693 | Neps Academy | 1,693 | Arte | https://neps.academy/br/exercise/1415 | Arte Mahima tem experimentado um novo estilo de arte. Ela fica em frente a uma tela e, usando seu pincel, joga gotas de tinta na tela. Quando ela acha que criou uma obra-prima, ela usa sua impressora 3D para imprimir uma moldura para circundar a tela. Seu trabalho é ajudar Mahima determinando as coordenadas da menor mo... | A primeira linha de entrada contém o número de gotas de tinta, N , onde 2 ≤ N ≤ 100 2 \ \leq \ N \ \leq \ 100 2 ≤ N ≤ 1 0 e N é um número inteiro. Cada uma das próximas N linhas contém exatamente dois inteiros positivos X e Y separados por uma vírgula (sem espaços). Cada um desses pares de inteiros representa as coorde... | null | [
{
"input": "5 44,62 34,69 24,78 42,44 64,10",
"output": "23,9 65,79"
}
] | 1 | Médio | 256 mb | 1 second(s) |
neps:11417 | Neps Academy | 11,417 | Fascinantes Partições | https://neps.academy/br/exercise/1573 | Fascinantes Partições Um subvetor de um vetor é uma porção contígua do vetor. Uma divisão de um vetor em subvetores é uma coleção de subvetores que cobrem todo o vetor sem sobreposições (cada elemento do vetor pertence exatamente a um subvetor). Por exemplo, se A = [ 3 , 1 , 4 , 1 , 5 ] A = [3, 1, 4, 1, 5] A = [ 3 , 1 ... | A primeira linha contém um número inteiro N ( 1 ≤ N ≤ 8000 ) N (1 ≤ N ≤ 8000) N ( 1 ≤ N ≤ 8 0 ) , o número de elementos do vetor A . A segunda linha contém N números inteiros A 1 , A 2 , . , A N ( 1 ≤ A i ≤ 1 0 9 A_1, A_2, . . , A_N (1 ≤ Ai ≤ 10^9 A 1 , A 2 , . , A N ( 1 ≤ A i ≤ 1 0 9 para i = 1 , 2 , . , N ) i =... | Produza N linhas, de tal forma que a k -ésima linha contenha dois inteiros indicando respectivamente os custos mínimos e máximos de P ( A , k ) P(A, k) P ( A , k ) . | [
{
"input": "6 3 5 7 1 2 4",
"output": "7 7 10 12 12 16 14 19 17 21 22 22"
},
{
"input": "4 1 1 1 1",
"output": "1 1 2 2 3 3 4 4"
}
] | 2 | Super Difícil | 256 mb | 3 second(s) |
neps:1593 | Neps Academy | 1,593 | Doação de sangue | https://neps.academy/br/exercise/754 | Doação de sangue O usuário fornecerá o ano atual, o ano de nascimento. O algoritmo deve informar se ele pode ou não doar sangue. Para doar sangue é necessário ter entre 18 e 67 anos. Observações: Não usar texto no input, exemplo: x = eval (input()) Esse exercício aceita todas as linguagens, mas foi pensado para ser res... | Ano 2020 como referência, e um ano de nascimento. | Informar a idade do usuário, e depois exatamente as palavras (inclusive maiúsculas e minúsculas, sem acento, em linhas diferentes): "Pode doar sangue", caso possa e "Nao pode doar sangue", caso não possa. | [
{
"input": "2020 2005",
"output": "15 Nao pode doar sangue"
},
{
"input": "2020 1998",
"output": "22 Pode doar sangue"
},
{
"input": "2020 1950",
"output": "70 Nao pode doar sangue"
}
] | 3 | null | 256 mb | 1 second(s) |
neps:11204 | Neps Academy | 11,204 | Análise de Submissões de Tarefas de Programação | https://neps.academy/br/exercise/2677 | Análise de Submissões de Tarefas de Programação Neste exercício, você praticará o uso de funções de agregação em SQL para analisar as submissões de uma tarefa de programação específica, com base na escolha do usuário. O usuário deverá selecionar o ID de uma tarefa de programação e o seu programa deve aplicar funções de... | A entrada consiste em uma única linha, contendo o ID da tarefa de programação a ser analisada. | A saída deve ser apresentada em três linhas, cada uma fornecendo uma estatística diferente relacionada ao tempo de execução das submissões: Na primeira linha, imprima a soma total dos tempos de execução Na segunda linha, imprima a média dos tempos de execução Na última linha, imprima o tempo máximo de execução Todos os... | [
{
"input": "1",
"output": "0.37 0.12 0.15"
},
{
"input": "2",
"output": "0.12 0.06 0.07"
}
] | 2 | Difícil | 256 mb | 1 second(s) |
neps:1713 | Neps Academy | 1,713 | Detetive | https://neps.academy/br/exercise/475 | Detetive Uma agência de detetives quer criar um aplicativo para ajudar a resolver os problemas dos clientes. A agência é muito eficiente em coletar informações e fazer deduções muito precisas. Para cada cliente a agência monta uma base de dados contendo um conjunto de eventos e um conjunto de implicações na forma A → B... | A primeira linha contém três números inteiros E , I e V , representando respectivamente o número total de eventos, o número de implicações e o número de eventos que a agência determinou que são verdadeiros. Cada evento é identificado por um número de 1 a E . Cada uma das I linhas seguintes contém dois inteiros A e B , ... | Seu programa deve produzir uma única linha, com os identificadores de todos os eventos que certamente ocorreram, considerando o conjunto de implicações dado na entrada. Os identificadores dos eventos devem ser escritos em ordem crescente, separados por um único espaço em branco. Restrições | [
{
"input": "3 2 1 2 3 1 2 3",
"output": "1 2 3"
},
{
"input": "4 4 1 1 2 1 3 2 4 3 4 4",
"output": "1 2 3 4"
},
{
"input": "3 2 1 1 3 2 3 3",
"output": "3"
}
] | 3 | Difícil | 256 mb | 1 second(s) |
neps:11393 | Neps Academy | 11,393 | Torre-Pizza | https://neps.academy/br/exercise/2083 | Torre-Pizza Ruane trabalha em uma pizzaria que preparam opções criativas de menu, onde o item mais popular é a torre de pizzas, que consiste em N pizzas empilhadas umas em cima das outras. Há três sabores de pizzas feitas na lanchonete, e elas são chamadas de A, B e C, respectivamente. O preparo de uma torre de pizza é... | A entrada é dada pela entrada padrão na seguinte forma N Q Q S 1 S_1 S 1 S 2 S_2 S 2 : S Q S_Q S Q Onde S i ( 1 ≤ i ≤ Q ) S_i (1 ≤ i ≤ Q) S i ( 1 ≤ i ≤ Q ) é uma string de comprimento N , e seu j -ésimo ( 1 ≤ j ≤ N ) (1 ≤ j ≤ N) ( 1 ≤ j ≤ N ) caractere é S i , j S_{i,j} S i , j . | Na linha i ( 1 ≤ i ≤ Q ) i (1 ≤ i ≤ Q) i ( 1 ≤ i ≤ Q ) , imprima o número mínimo de operações necessárias para fazer uma torre de pizzas bem sucedida para a i -ésima torre de pizzas. Restrições | [
{
"input": "5 3 ABCBA CCBAB AAAAA",
"output": "3 2 0"
},
{
"input": "2 5 AC AC",
"output": "0 0 0"
},
{
"input": "13 1 ABCCABCBACBAA",
"output": "9"
},
{
"input": "13 4 CCAAACBAAAABB BBBCCBCCCBCBC CCCAAAABBBBBB AABCBCACBACBA",
"output": "4 6 2 10"
}
] | 4 | Difícil | 256 mb | 1 second(s) |
neps:1677 | Neps Academy | 1,677 | Cabelos Brancos | https://neps.academy/br/exercise/2036 | Cabelos Brancos O senhor Diogo, conhecido nas maratonas locais como "Geada" (devido aos seus cabelos brancos), está ficando cada vez mais rabugento. A última queixa do nosso querido Geada se deve ao alto preço do combustível, necessário para abastecer seu potente veículo. Vários maratonistas tentaram explicar para Gead... | Para cada caso de teste, há uma linha indicando o valor decimal E do preço do etanol seguido por outra linha com o decimal G que é o preço da gasolina ( 0.999 < E , G < 9.999 ) (0.999 < E, G < 9.999) ( 0 . 9 < E , G < 9 . 9 ) . | Para cada caso de teste, o programa deve imprimir uma linha contendo apenas a palavra ETANOL ou GASOLINA , indicando qual o combustível ideal para Geada. | [
{
"input": "4.607 5.990",
"output": "GASOLINA"
},
{
"input": "4.607 6.599",
"output": "ETANOL"
}
] | 2 | Fácil | 256 mb | 1 second(s) |
neps:11386 | Neps Academy | 11,386 | Palavras | https://neps.academy/br/exercise/1968 | Palavras Dados dois conjuntos de palavras formadas por zeros e uns, você deve escrever um programa para determinar se existem concatenações de palavras de cada um dos conjuntos que gerem uma mesma palavra. Por exemplo, se um conjunto A contém as palavras 010 0 1 0 e 11 1 1 e outro conjunto B contém as palavras 0 e 101 ... | A primeira linha de um caso de teste contém dois inteiros, N 1 N_1 N 1 e N 2 N_2 N 2 , que indicam respectivamente o número de palavras do primeiro e do segundo conjunto de palavras. Cada uma das N 1 N_1 N 1 linhas seguintes contém uma palavra do primeiro conjunto. Cada uma das N 2 N_2 N 2 linhas seguintes cont... | Para cada caso de teste seu programa deve imprimir uma única linha, contendo um único caractere. Se for possivel encontrar uma concatenação de uma ou mais palavras do primeiro conjunto que seja igual a uma concatenação de uma ou mais palavras do segundo conjunto então o caractere deve ser S, caso contrário deve ser N. ... | [
{
"input": "2 2 010 11 0 101 3 1 1 00 000 01 1 1 00 000",
"output": "S N S"
}
] | 1 | Difícil | 256 mb | 1 second(s) |
neps:11054 | Neps Academy | 11,054 | Containers | https://neps.academy/br/exercise/113 | Containers O SBC–Sistema de Balanceamento de Containers precisa ser atualizado para funcionar com uma nova classe de navios, a “dois por quatro”, que são navios que podem carregar oito grandes containers numa disposição de duas linhas e quatro colunas, como mostrado na figura ao lado. Esses navios possuem um guindaste ... | A entrada consiste de quatro linhas contendo, cada uma, quatro inteiros entre 1 e 1000, inclusive. As duas primeiras linhas definem os pesos na configuração inicial e as duas últimas linhas, os pesos na configuração. Sempre existe uma solução, pois os containers nas configurações inicial e final são os mesmos, com as p... | Seu programa deve produzir uma única linha contendo um inteiro, representando o custo total mínimo de uma sequência de movimentos que leve da configuração inicial à configuração final. | [
{
"input": "3 1 2 1 4 7 52 9 7 1 2 1 3 9 52 4",
"output": "81"
},
{
"input": "1 2 3 4 5 10 7 8 1 2 3 4 5 8 7 10",
"output": "50"
},
{
"input": "34 5 6 998 4 17 77 84 34 5 6 998 4 17 77 84",
"output": "0"
}
] | 3 | Difícil | 256 mb | 1 second(s) |
neps:11152 | Neps Academy | 11,152 | Contagem de objetos | https://neps.academy/br/exercise/1954 | Contagem de objetos Reluew e Ovatsug estão agora engajados em processamento de imagens. Recentemente eles ficaram sabendo que um grande desafio nessa área é saber quantos objetos existem em determinada imagem. Diferenciar os objetos do plano de fundo e um objeto do outro são tarefas frequentemente árduas. Foi então que... | A entrada é composta de apenas um caso de teste. A primeira linha contém dois inteiros N e M ( 1 ≤ N , M ≤ 100 ) M (1 ≤ N, M ≤ 100) M ( 1 ≤ N , M ≤ 1 0 ) indicando a largura e comprimento da imagem. Seguem N linhas, cada uma contendo M números inteiros T ( 0 ≤ T ≤ 255 ) T (0 ≤ T ≤ 255) T ( 0 ≤ T ≤ 2 5 ) , em que T indi... | A saída deve ser um inteiro O representando o número de objetos contidos na imagem. | [
{
"input": "3 3 245 235 225 240 220 200 230 210 200",
"output": "1"
},
{
"input": "4 3 245 235 235 240 220 227 200 210 228 230 220 243",
"output": "2"
}
] | 2 | Médio | 256 mb | 1 second(s) |
neps:1330 | Neps Academy | 1,330 | Bobo da Corte | https://neps.academy/br/exercise/438 | Bobo da Corte O Reino dos Emparelhamentos é governado por um generoso Comendador. A fama do Comendador e de suas grandes qualidades é conhecida por todos, inclusive em reinos vizinhos. Uma de suas mais famosas qualidades é seu bom humor, que é nutrido diariamente por um bobo da corte, eleito anualmente no Grande Concur... | A primeira linha da entrada contém um inteiro N , satisfazendo 2 ≤ N ≤ 1 0 4 2 \leq N \leq 10^4 2 ≤ N ≤ 1 0 4 . As N linhas seguintes conterão N inteiros positivos v 1 , … , v N v_1,\ldots, v_N v 1 , … , v N , um em cada linha, correspondentes ao número de votos recebido por cada um dos candidatos, em ordem de insc... | Seu programa deve produzir uma única linha contendo o caractere ‘S’ caso o jovem Carlos seja eleito bobo da corte, ou o caractere ‘N’ caso contrário. | [
{
"input": "3 1000 1000",
"output": "S"
},
{
"input": "5 1 2 3 4 5",
"output": "N"
}
] | 2 | Fácil | 256 mb | 1 second(s) |
neps:11160 | Neps Academy | 11,160 | Frota Espacial | https://neps.academy/br/exercise/3056 | Frota Espacial Nas profundezas do vazio espacial, uma frota de N estações de retransmissão orbita um planeta distante em um anel perfeito. Cada estação possui uma contagem de pacotes de dados, representada por um número inteiro. A IA Central pode emitir dois tipos de comandos para manter o alinhamento da rede e recuper... | A primeira linha contém dois inteiros N e Q -” o número de estações de retransmissão e o número de comandos. A segunda linha contém N inteiros A 1 , A 2 , … , A N A_1, A_2, \dots, A_N A 1 , A 2 , … , A N -” as contagens iniciais de pacotes em cada estação nas posições 1 até N . Cada uma das próximas Q linhas cont... | Para cada comando com T = 2 T = 2 T = 2 , exiba um único inteiro -” a contagem de pacotes na posição da estação especificada após todos os comandos precedentes terem sido aplicados. Destrave esse exercício com uma assinatura PRO | [] | 0 | Difícil | 256 mb | 1 second(s) |
neps:1627 | Neps Academy | 1,627 | Human Learning | https://neps.academy/br/exercise/906 | Human Learning Está na hora da maratona de programação, uma competição onde times de NO MÁXIMO K pessoas participam para decidir quem consegue achar a maior quantidade de números primos. O coach de uma faculdade de N alunos, cada um com uma habilidade S i Si S i , quer montar os times representantes de modo que a sua f... | A primeira linha consiste em dois inteiros N e K , indicando a quantidade de alunos que estão na faculdade e o tamanho MÁXIMO de um time, respectivamente. A segunda linha consiste de N inteiros, indicando a habilidade S i Si S i do i-ésimo aluno. Saida A saída deve conter um único inteiro, contendo a maior pontuação po... | null | [
{
"input": "5 4 3 10 3 2 3",
"output": "43"
},
{
"input": "4 2 3 5 2 10",
"output": "30"
}
] | 2 | Médio | 256 mb | 2 second(s) |
neps:1585 | Neps Academy | 1,585 | Alfabeto Alienígena | https://neps.academy/br/exercise/2792 | Alfabeto Alienígena Mais uma vez, o OBI (Órgão Brasileiro de Inteligência) está preocupado com a possibilidade da existência de vida alienígena. Os diretores do órgão suspeitam que os alienígenas existem, conseguiram se infiltrar dentro da instituição e têm se comunicado secretamente. Os agentes do OBI se comunicam usa... | A primeira linha de entrada contém dois inteiros K e N separados por um espaço em branco, indicando, respectivamente, o número de caracteres presentes no alfabeto alienígena e o número de caracteres da mensagem enviada. A segunda linha de entrada contém K caracteres distintos representando os caracteres pertencentes ao... | Seu programa deverá imprimir uma única linha contendo um único caractere: se a mensagem pode ter sido escrita no alfabeto alienígena, imprima a letra S maiúscula; caso contrário, imprima a letra N maiúscula. Restrições | [
{
"input": "4 5 !1ob ob1!!",
"output": "S"
},
{
"input": "1 5 a aabab",
"output": "N"
},
{
"input": "26 32 abcdefghijklmnopqrstuvwxyz olimpiadabrasileiradeinformatica",
"output": "S"
},
{
"input": "11 7 0123+-!ABCD OBI!OBI",
"output": "N"
}
] | 4 | Difícil | 256 mb | 1 second(s) |
neps:1483 | Neps Academy | 1,483 | Matemáticamedias | https://neps.academy/br/exercise/742 | Matemática::medias A classe Matematica abaixo deve calcular o valor da média entre 2 ou 3 números (dependendo do método usado). Porém o único método implementado é o que calcula a média real entre dois números reais. Sua tarefa é implementar os seguinte métodos: media: calcula a média entre 3 números reais. media_intei... | A entrada consiste de duas linhas. A primeira linha consiste de um inteiro N e um caractere O . A segunda linha contém N números reais. | A saída do seu programa é gerada automaticamente pelo código de exemplo. Restrições | [
{
"input": "2 I 97 15",
"output": "56"
},
{
"input": "3 R 78 56 46",
"output": "60.00"
},
{
"input": "2 R 2.3 4.2",
"output": "3.25"
}
] | 3 | Fácil | 256 mb | 1 second(s) |
neps:11198 | Neps Academy | 11,198 | Malha Aérea | https://neps.academy/br/exercise/2620 | Malha Aérea No reino de Quadradônia, o monarca quer rever todas as tarifas aéreas. Para isso, pediu ao seu contador uma tabela com as propostas de novos preços. Todavia, o monarca estudou no Instituto de Computação e Programação de Chapecó (ICPC) e tem conhecimento suficiente para exigir coerência na tabela. A tabela é... | A primeira linha contém N ( 1 ≤ N ≤ 100 ) N \ (1 \leq N \leq 100) N ( 1 ≤ N ≤ 1 0 ) , que é o número de cidades da Quadradônia servidas por voos. Existem então mais N linhas, L 1 , L 2 , . , L N L_1, \ L_2, ... , \ L_N L 1 , L 2 , . , L N . A linha L i L_i L i contém N inteiros, C i 1 , C i 2 , . , C i N C_{i1}... | Imprima uma linha contendo um inteiro. Se a tabela for incoerente, o inteiro deve ser igual a − 1 -1 − 1 . Se a tabela for coerente, o inteiro deve ser igual ao maior número de voos diretos que podem ser removidos sem aumento nos custos das viagens para os passageiros. | [
{
"input": "3 0 1 2 1 0 1 2 1 0",
"output": "1"
},
{
"input": "3 0 2 2 2 0 2 2 2 0",
"output": "0"
},
{
"input": "3 0 2 9 2 0 2 9 2 0",
"output": "-1"
}
] | 3 | Difícil | 512 mb | 1 second(s) |
neps:11057 | Neps Academy | 11,057 | Girassóis | https://neps.academy/br/exercise/2027 | Girassóis Bárbara planta N girassóis diferentes, cada um com uma altura única, ordenados do menor para o maior, e registra suas alturas por N dias consecutivos. A cada dia, todas as suas flores ficam mais altas do que no dia anterior. Ela registra cada uma destas medidas em uma tabela, com uma linha para cada planta, c... | A primeira linha de entrada contém o número N ( 2 ≤ N ≤ 100 ) N \ (2 \leq N \leq 100) N ( 2 ≤ N ≤ 1 0 ) . As próximas N linhas cada uma contém N inteiros positivos, sendo cada um deles no máximo 1 0 9 10^9 1 0 9 . É garantido que a tabela de entrada representa uma versão girada da tabela da Barbara. | Imprima os dados originais de Barbara, consistindo de N linhas, cada uma contendo N inteiros positivos. Explicação da amostra de entrada/saída 1: Os dados foram girados em um múltiplo de 360 graus, o que significa que a disposição da entrada é a disposição original. Explicação da Amostra de Entrada/Saída 2: Os dados or... | [
{
"input": "2 1 3 2 9",
"output": "1 3 2 9"
},
{
"input": "3 4 3 1 6 5 2 9 7 3",
"output": "1 2 3 3 5 7 4 6 9"
},
{
"input": "3 3 7 9 2 5 6 1 3 4",
"output": "1 2 3 3 5 7 4 6 9"
}
] | 3 | Médio | 512 mb | 2 second(s) |
neps:1653 | Neps Academy | 1,653 | Competição de Chocolate (PJ) | https://neps.academy/br/exercise/559 | Competição de Chocolate (PJ) Carlos e Paula acabaram de ganhar um saco com bolinhas de chocolate. Como sabem que vão comer tudo muito rápido inventaram uma brincadeira: Eles vão comer de forma alternada, um depois o outro, sendo que sempre a Paula começa. Quem comer a última bolinha ganha a bricadeira. A cada vez, só s... | A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A entrada consiste de uma linha contendo dois inteiros N ( 1 ≤ N ≤ 1 0 6 1 \leq N \leq 10^6 1 ≤ N ≤ 1 0 6 ) e M ( 1 ≤ M ≤ 1 0 3 1 \leq M \leq 10^3 1 ≤ M ≤ 1 0 3 ), sendo N o número de bolinhas de ch... | Seu programa deve imprimir, na saída padrão, uma linha, contendo o nome do vencedor, como exemplificado abaixo. Informações sobre a pontuação Em um conjunto de casos de teste que totaliza 30 pontos, N ≤ 50 N \leq 50 N ≤ 5 0 e M ≤ 5 M \leq 5 M ≤ 5 . Em um conjunto de casos de teste que totaliza 60 pontos, N ≤ 1 0 4 N \l... | [
{
"input": "5 3",
"output": "Paula"
},
{
"input": "30 5",
"output": "Carlos"
}
] | 2 | Fácil | 256 mb | 1 second(s) |
neps:1444 | Neps Academy | 1,444 | Multiplicação e Divisão de Frações | https://neps.academy/br/exercise/738 | Multiplicação e Divisão de Frações O código implementa a classe Fracao, porém a implementação dos operadores de multiplicação e de divisão estão incompletas, sua tarefa é implementar ambos operadores. Caso você tenha dúvida de como fazer as operações basta dar uma olhada no link . OBS: Não é necessário reduzir a fração... | A entrada consiste de 3 linhas. A primeira linha contém o numerador e denominador da primeira fração. A segunda linha contém o numerador e denominador da segunda fração e a última linha contém a operação a ser realizada. | Seu programa deve imprimir uma linha com o numerador e denominador da fração resultado da operação. Restrições Os numeradores e denominadores das frações variam entre 1 e 1000 | [
{
"input": "3 1 4 1 M",
"output": "12 1"
},
{
"input": "3 4 2 5 D",
"output": "15 8"
},
{
"input": "3 4 2 5 M",
"output": "6 20"
}
] | 3 | Fácil | 256 mb | 1 second(s) |
neps:11207 | Neps Academy | 11,207 | Hangar do SBC | https://neps.academy/br/exercise/1176 | Hangar do SBC Um pequeno avião de carga do Sistema Binário de Cargas (SBC) foi projetado para transportar produtos especiais e secretos. Esses produtos são agrupados em caixas com diversos pesos. O avião tem uma faixa de peso de segurança, dentro da qual a aeronave fica estável. Mais especificamente, existe um interval... | A primeira linha da entrada contém dois inteiros, N e K , que representam o número de caixas disponíveis e o número de caixas que devem ser embarcadas no avião, respectivamente. A segunda linha da entrada contém N inteiros, separados por um espaço em branco, que representam os pesos das caixas. A terceira linha da entr... | A saída consiste de uma única linha, que contém o número de diferentes escolhas de caixas na quantidade especificada, sem por em risco o voo. | [
{
"input": "3 2 10 1 3 4 13",
"output": "3"
},
{
"input": "4 3 20 10 50 1 21 81",
"output": "4"
},
{
"input": "6 3 14 70 3 1 6 31 10 74",
"output": "11"
}
] | 3 | Difícil | 256 mb | 1 second(s) |
neps:11195 | Neps Academy | 11,195 | Missão de Calibração do Cronômetro | https://neps.academy/br/exercise/3014 | Missão de Calibração do Cronômetro O tempo em si pode ser tão volúvel quanto fascinante. Em um mundo onde cada segundo conta, você foi designado para ajustar um dispositivo temporal futurista. Sua missão é ajustar o relógio de uma leitura inicial, T 1 T_1 T 1 , para um momento alvo, T 2 T_2 T 2 , ambos apresentados... | A entrada consiste de duas linhas: A primeira linha contém o horário inicial T 1 T_1 T 1 no formato HH:MM , onde 00 ≤ HH < 24 00 \leq \texttt{HH} < 24 0 ≤ HH < 2 4 e 00 ≤ MM < 60 00 \leq \texttt{MM} < 60 0 ≤ MM < 6 0 . A segunda linha contém o horário alvo T 2 T_2 T 2 no mesmo formato. | Imprima um único inteiro: o menor número de minutos (para frente ou para trás) necessários para ajustar de T 1 T_1 T 1 para T 2 T_2 T 2 . Um número positivo indica mover para frente no tempo, enquanto um número negativo indica mover para trás. Caso a quantidade de minutos para ir para a frente seja a mesma de ir pa... | [] | 0 | Difícil | 256 mb | 1 second(s) |
neps:11315 | Neps Academy | 11,315 | Vingança | https://neps.academy/br/exercise/2537 | Vingança Depois de ser forçado a receber a punição, você decide se vingar dos organizadores do torneio (mesmo que você tenha quebrado a regra primeiro) da maneira mais juvenil possível: reorganizando as letras em todos os displays presentes. No entanto, como você não é muito bom em inventar frases engraçadas na hora, d... | A primeira linha conterá um único inteiro n que indica o número de conjuntos de dados que se seguem. Cada conjunto de dados conterá uma frase em uma única linha que pode conter espaços. | Para cada frase, use o método de divisão e inversão para rearranjar os caracteres na frase e depois exiba o resultado. Explicação Exemplo de Entrada/Saída 1: Para o primeiro caso, o processo é o seguinte: Concessions snoissecnoC snois secnoC sions Conces si ons Con ces is sno noC sec i s s no n oC s ec i s s on n Co s ... | [
{
"input": "3 Concessions Match Schedule Restrooms down the hall and to the left",
"output": "issonnCosce echledutMa Sch dnt laal l tef oethoo mseRrsththe od wn"
}
] | 1 | Difícil | 512 mb | 2 second(s) |
neps:1910 | Neps Academy | 1,910 | Danone | https://neps.academy/br/exercise/383 | Danone Arthur ganhou um vetor v de tamanho N com inteiros de aniversário dos seus amigos, mas, durante a comemoração, acabou tomando muito danoninho e perdeu o seu presente. Alguns dias depois, um dos amigos começou a conversar com Arthur sobre o quanto aquele vetor era legal e fazia comentários do tipo “A soma dos int... | A entrada consiste de um inteiro N , o tamanho do vetor presenteado a Arthur, e um outro inteiro Q , a quantidade de comentários ou lembranças que ocorreram durante a conversa. A i-ésima das Q linhas seguintes da entrada representam os eventos da conversa. Se a linha é da forma C l i r C\ l_i\ r_r C l i r , o amigo... | Para cada comentário C l i r i C\ l_i\ r_i C l i r i , imprima uma linha que contém “Esquecido” (sem as aspas) caso Arthur não saiba a soma deste intervalo e, caso ele saiba, imprima uma linha que contém apenas o valor desta soma. Restrições | [
{
"input": "7 6 L 3 6 35 L 4 6 22 C 3 3 L 1 3 14 C 1 4 C 1 2",
"output": "13 Esquecido 1"
},
{
"input": "3 5 L 1 3 2 C 1 2 L 2 3 1 C 1 1 C 1 3",
"output": "Esquecido 1 2"
}
] | 2 | Difícil | 256 mb | 1 second(s) |
neps:1847 | Neps Academy | 1,847 | Modo | https://neps.academy/br/exercise/1784 | Modo Dada uma sequência de números A 1 , A 2 , . , A N A_1, \ A_2, ..., \ A_N A 1 , A 2 , . , A N de comprimento N . Cada termo desta sequência é um número inteiro entre 1 e M . Definida uma nova sequência B 1 , B 2 , . , B M B_1, B_2, ..., B_M B 1 , B 2 , . , B M de comprimento M como se segue. Para cada j... | A entrada é dada pela entrada padrão na seguinte forma N M N \ M N M A 1 , A 2 . A N A_1, A_2 ... A_N A 1 , A 2 . A N | Imprima o valor máximo da sequência B 1 , B 2 , . , B M B_1, \ B_2, ..., \ B_M B 1 , B 2 , . , B M em uma linha. Restrições | [
{
"input": "4 3 1 1 2 3",
"output": "2"
},
{
"input": "6 5 3 3 2 1 2 3",
"output": "3"
}
] | 2 | Fácil | 1024 mb | 2 second(s) |
neps:1919 | Neps Academy | 1,919 | Repartir | https://neps.academy/br/exercise/1103 | Repartir Dado um vetor V de tamanho N , encontre a primeira posição X que se dividirmos o vetor em dois subvetores [ 1 , X ] [1, X] [ 1 , X ] e [ X + 1 , N ] [X+1, N] [ X + 1 , N ] , a soma de todos os elementos dos dois subvetores sejam iguais. Caso não exista nenhuma posição assim, imprima -1. | A entrada consiste em duas linhas. A primeira linha contém um inteiro N indicando o tamanho do vetor. A segunda linha contém N inteiros V i Vi V i , indicando os números contidos no vetor. Saida Imprima o menor índice que divida o vetor em dois subvetores de soma igual, ou caso esse índice não exista, imprima -1. Restr... | null | [
{
"input": "6 1 2 3 3 2 1",
"output": "3"
},
{
"input": "9 6 3 3 3 3 3 3 3 3",
"output": "4"
},
{
"input": "5 1 2 3 4 5",
"output": "-1"
}
] | 3 | null | 256 mb | 1 second(s) |
neps:1978 | Neps Academy | 1,978 | Laser | https://neps.academy/br/exercise/2156 | Laser Mariazinha adora jogos online, e recentemente anda viciada em um jogo que conheceu a pouco tempo. A personagem do jogo é uma aventureira atrás de um tesouro. Ela está dentro de uma caverna onde o tesouro foi escondido, porém essa caverna está cheia de armadilhas. Após passar por todas, Mariazinha finalmente conse... | A primeira linha de entrada contém dois inteiros N e M , representando a quantidade de linhas e colunas do tabuleiro, respectivamente. A segunda linha de entrada contém um inteiro Q , representando o número de queries. As próximas Q linhas representam cada uma uma query, no formato especificado anteriormente. É garanti... | Imprima, para cada query do tipo 3, um caractere ’S’ se todas as posições dentro do subgrid forem cobertas por lasers, e ’N’ caso contrário. Restrições | [
{
"input": "2 3 5 A 2 3 A 1 3 Q 1 1 2 3 R 2 3 Q 1 1 2 3",
"output": "S N"
},
{
"input": "2 2 4 Q 1 1 2 2 A 1 1 Q 1 1 2 2 Q 1 1 1 2",
"output": "N N S"
}
] | 2 | Difícil | 256 mb | 1 second(s) |
neps:112 | Neps Academy | 112 | Lâmpadas | https://neps.academy/br/exercise/52 | Lâmpadas 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 I_1 I 1 e I 2 I_2 I 2 . Ao apertar I 1 I_1 I 1 , a lâmpada A acende se estiver apagada, e apaga se estiver acesa. Se... | 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 I_1 I 1 foi apertado, ou 2, se o interruptor I 2 I_2 I 2 foi apertado. | 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 | [
{
"input": "3 1 2 2",
"output": "1 0"
},
{
"input": "4 2 1 2 2",
"output": "0 1"
}
] | 2 | Médio | 256 mb | 1 second(s) |
neps:11164 | Neps Academy | 11,164 | Vingança de Leonardo | https://neps.academy/br/exercise/2474 | Vingança de Leonardo Após levar inúmeros TLs 66 pontos no Tesouro de TurTur (9 para ser mais exato), Leonardo finalmente roubou o tesouro, e agora ele planeja se vingar de TurTur. Ele instalou na porta do labirinto um cadeado que contém uma senha binária (isto é, uma string que consiste apenas de 0s e 1s). Esse cadeado... | A entrada consiste em uma string S , representando a senha que foi lida pela câmera de segurança. | A saída consiste no número mínimo de botões que TurTur deve apertar para gerar a senha S . Restrições | [
{
"input": "010010110",
"output": "5"
},
{
"input": "01",
"output": "2"
},
{
"input": "0",
"output": "1"
}
] | 3 | Difícil | 256 mb | 3 second(s) |
neps:1422 | Neps Academy | 1,422 | Sequência Lógica 02 | https://neps.academy/br/exercise/180 | Sequência Lógica 02 Bino gosta bastante de sequências, e pediu para você descobrir qual a sequência completa. Bino vai lhe fornecer os elementos iniciais e finais da sequência e você terá que identificar a lógica da sequência e fazer um programa para imprimir a sequência completa. | Não contém entrada. | A saída consiste de múltiplas linhas, contendo a sequência completa. | [
{
"input": "",
"output": "a = 0 <-> b = 1 a = 1 <-> b = -1 a = 1 <-> b = 3 a = 2 <-> b = 1 a = 2 <-> b = 5 a = 3 <-> b = 3 … a = 30 <-> b = 61 a = 31 <-> b = 59"
}
] | 1 | Médio | 256 mb | 1 second(s) |
neps:1655 | Neps Academy | 1,655 | Blefe | https://neps.academy/br/exercise/394 | Blefe Pedro está desenvolvendo um jogo on-line para dois jogadores, em que o objetivo é forçar um erro do adversário, blefando. A questão é que, à medida que o jogo prossegue, mais tempo é necessário para verificar se uma jogada é válida ou não, ou seja, se é um blefe ou não. Daí que Pedro precisa da sua ajuda para imp... | A entrada consiste de três linhas. A primeira linha contém dois números N ( 1 ≤ N ≤ 1 0 3 1 \leq N \leq 10^3 1 ≤ N ≤ 1 0 3 ) e M ( 1 ≤ M ≤ 1 0 4 1 \leq M \leq 10^4 1 ≤ M ≤ 1 0 4 ), respectivamente o tamanho do conjunto A e o tamanho da sequência B . A segunda linha contém os N números inteiros do conjunto A . A terceir... | Seu programa deve produzir uma única linha. A linha deve conter a palavra “sim” caso todas as jogadas em B sejam válidas; se houver alguma jogada inválida em B , a linha deve conter o primeiro número inválido em B . Restrições O valor de todos os números em | [
{
"input": "6 11 34 9 -2 77 -11 5 34 5 -2 32 -11 -6 28 66 -2 -22 33",
"output": "sim"
},
{
"input": "6 8 34 9 -2 77 -11 5 -11 77 -2 75 9 48 7 5",
"output": "48"
}
] | 2 | Difícil | 256 mb | 2 second(s) |
neps:1344 | Neps Academy | 1,344 | Pesos | https://neps.academy/br/exercise/204 | Pesos Uma fábrica instalou um elevador composto de duas cabines ligadas por uma roldana, como na figura. Quando uma cabine sobe, a outra desce. No primeiro andar da fábrica existem algumas caixas de pesos diversos e precisamos levar todas as caixas para o segundo andar, usando o elevador. Apenas uma caixa pode ser colo... | A primeira linha da entrada contém um inteiro N indicando o número de caixas. A segunda linha da entrada contém N inteiros representando os pesos das caixas, em ordem crescente. | Imprima uma linha na saída. A linha deve conter o caractere S caso seja possível, ou N caso não seja possível levar todas as caixas até o segundo andar da fábrica Restrições | [
{
"input": "3 4 10 15",
"output": "S"
},
{
"input": "8 2 6 15 20 25 35 35 40",
"output": "N"
},
{
"input": "4 10 14 20 23",
"output": "N"
},
{
"input": "1 8",
"output": "S"
}
] | 4 | Fácil | 256 mb | 1 second(s) |
neps:11278 | Neps Academy | 11,278 | Crise no Casamento | https://neps.academy/br/exercise/1570 | Crise no Casamento Um famoso jogador de futebol acabou de se casar e está realizando uma festa para seus convidados de casamento. Os convidados estão sentados em mesas ao redor de um lago circular no jardim da casa do jogador. Cada mesa acomoda exatamente o mesmo número de convidados, e mesas consecutivas ao redor da l... | A primeira linha contém um número inteiro N ( 1 ≤ N ≤ 1 0 5 ) N (1 ≤ N ≤ 10^5) N ( 1 ≤ N ≤ 1 0 5 ) indicando o número de mesas ao redor da lagoa circular. A segunda linha contém números inteiros N G 1 , G 2 , . G N ( 0 ≤ G i ≤ 1000 G_1, G_2, . . G_N (0 ≤ G_i ≤ 1000 G 1 , G 2 , . G N ( 0 ≤ G i ≤ 1 0 para i = 1 ,... | Produza uma única linha com um número inteiro indicando o menor custo total possível para corrigir a distribuição dos copos. | [
{
"input": "4 14 10 6 10",
"output": "8"
},
{
"input": "6 24 122 0 37 49 242",
"output": "454"
},
{
"input": "6 0 0 0 0 60 0",
"output": "150"
},
{
"input": "1 0",
"output": "0"
}
] | 4 | Super Difícil | 256 mb | 1 second(s) |
neps:1642 | Neps Academy | 1,642 | Jankenpon | https://neps.academy/br/exercise/1236 | Jankenpon Jankenpon é um jogo recreativo usando gestos de mão que representam pedra, papel e tesoura, tão conhecido no Brasil quanto o Par ou Impar, simples e que não requer equipamentos podendo ser jogado por duas ou mais pessoas. Em alguns países, substituem-se a pedra, a tesoura e o papel por outros símbolos. Por ex... | A primeira linha da entrada contém um inteiro N, que indica o número de rodadas na partida. Cada uma das N linhas seguintes contém dois caracteres M e J, que representam o símbolo que os jogadores Maria e Joao, respectivamente, jogaram em uma rodada. Os símbolos podem ser "H" de Homem, "A" de Arma ou "T" de Tigre, | Seu programa deve imprimir uma linha contendo o nome do jogador que venceu a partida: “Joao” ou “Maria”, sem nenhum acento. Caso dê empate, você deverá imprimir “JanKenpon”. Não esqueça de imprimir o fim de linha após o resultado. | [
{
"input": "3 H A A T T T",
"output": "Maria"
},
{
"input": "2 A H T H",
"output": "JanKenpon"
}
] | 2 | null | 256 mb | 1 second(s) |
neps:1470 | Neps Academy | 1,470 | Sanduíche | https://neps.academy/br/exercise/1659 | Sanduíche Uma nova lanchonete abriu na cidade, prometendo um menu com a maior variedade de sanduíches da região. A cada dia o Chef de cozinha compra N ingredientes distintos e prepara o menu usando esses N ingredientes. Infelizmente não é possível ter sanduíches com qualquer combinação de ingredientes: a cada dia o Che... | A primeira linha contém dois números inteiros N e M , indicando respectivamente o número de ingredientes e o número de pares de ingredientes que não combinam. Os ingredientes são identificados por números de 1 a N . Cada uma das M linhas seguintes contém dois números inteiros X e Y que representam um par de ingrediente... | Seu programa deve produzir uma única linha, o número de sanduíches diferentes que podem ser feitos. Restrições | [
{
"input": "3 2 2 3 1 2",
"output": "4"
},
{
"input": "3 0",
"output": "7"
},
{
"input": "3 3 1 2 2 3 1 3",
"output": "3"
}
] | 3 | Difícil | 256 mb | 1 second(s) |
neps:1807 | Neps Academy | 1,807 | UPA | https://neps.academy/br/exercise/2622 | UPA A Unicamp organiza anualmente, sempre em agosto, a UPA – Unicamp Portas Abertas –, um evento em que alunos de escolas da região podem visitar e conhecer as atividades da Universidade. O evento recebe em um dia dezenas de milhares alunos, que chegam em ônibus. Um dos grandes problemas da organização da UPA é o estac... | A primeira linha contém um inteiro N , o número de ônibus que chegarão para a UPA. Os horários de chegada e partida são dados como números inteiros. Cada uma das N linhas seguintes descreve um ônibus e contém dois inteiros C i C_i C i e P i P_i P i , respectivamente o instante de chegada e o instante de partida do ... | Seu programa deve produzir uma única linha, contendo um único inteiro, o menor comprimento da avenida, em metros, que deve ser reservado para o estacionamento de ônibus. Sub-tarefas Subtarefa 1 (25 pontos): P i = 1 + C i P_i = 1 + C_i P i = 1 + C i para 1 ≤ i ≤ N 1 \leq i \leq N 1 ≤ i ≤ N . Subtarefa 2 (25 pontos):... | [
{
"input": "3 100 360 300 500 200 400",
"output": "60"
},
{
"input": "4 500 560 200 340 80 200 400 540",
"output": "40"
}
] | 2 | Difícil | 256 mb | 1 second(s) |
neps:11157 | Neps Academy | 11,157 | CD | https://neps.academy/br/exercise/817 | CD Você tem uma longa viagem de carro pela frente. Você tem um gravador, mas infelizmente sua melhor música está nos CDs. Você precisa colocá-lo em fitas para que o problema seja resolvido: você tem uma fita de N minutos. Como escolher faixas do CD para aproveitar ao máximo o espaço da fita e ter o menor espaço não uti... | Várias linhas (Máximo 100 linhas). Cada uma contendo o valor de N , (após o espaço) número de faixas e durações das faixas. Por exemplo, na primeira linha do exemplo de entrada: N = 5, número de faixas = 3, a primeira faixa dura 1 minuto, a segunda 3 minutos, a próxima 4 minutos. | Conjunto de faixas (e durações) que são as soluções corretas e a sequência de caracteres 'sum:' e a soma dos tempos de duração. Restrições | [
{
"input": "5 3 1 3 4 10 4 9 8 4 2 20 4 10 5 7 4 90 8 10 23 1 2 3 4 5 7 45 8 4 10 44 43 12 9 8 2",
"output": "1 4 sum:5 8 2 sum:10 10 5 4 sum:19 10 23 1 2 3 4 5 7 sum:55 4 10 12 9 8 2 sum:45"
}
] | 1 | Médio | 256 mb | 2 second(s) |
neps:1135 | Neps Academy | 1,135 | Nota Esquecida | https://neps.academy/br/exercise/470 | Nota Esquecida João aprendeu na escola que a média de dois números é o valor da soma desses dois números dividido por dois. Ou seja, a média de dois números A e B é M = A + B 2 M = \frac{A+B}{2} M = 2 A + B . A professora contou para João as notas que ele tirou nas duas provas de Geografia. As duas notas são números ... | A primeira linha contém um número inteiro A , indicando a nota de uma prova. A segunda linha contém um número inteiro M , indicando a média entre as duas notas das provas. | Seu programa deve produzir uma única linha, com apenas um número inteiro, a nota da outra prova, que João não consegue recordar. Restrições | [
{
"input": "100 70",
"output": "40"
},
{
"input": "80 75",
"output": "70"
},
{
"input": "1 50",
"output": "99"
}
] | 3 | Fácil | 256 mb | 1 second(s) |
neps:1686 | Neps Academy | 1,686 | JOI Sort | https://neps.academy/br/exercise/1597 | JOI Sort Você receberá uma string S de comprimento N , onde cada letra de S é 'J', 'O' ou 'I'. Você quer reorganizar as letras de S para que elas satisfaçam as seguintes condições. Para cada par de letras 'J' e 'O', 'J' esta antes de 'O'. Para todos os pares da letra 'O' e da letra 'I', a letra 'O' está antes da letra ... | A entrada é dada pela entrada padrão na seguinte forma N S S S | Imprima uma string no qual as letras de S são reordenadas para satisfazer as condições. Restrições | [
{
"input": "6 JIOIJO",
"output": "JJOOII"
},
{
"input": "4 OOOI",
"output": "OOOI"
},
{
"input": "10 OIJJJIOIOI",
"output": "JJJOOOIIII"
}
] | 3 | Fácil | 1024 mb | 2 second(s) |
neps:1961 | Neps Academy | 1,961 | Anagrama | https://neps.academy/br/exercise/1744 | Anagrama Mariazinha está na escola, e todo dia a professora envia uma tarefa para ela fazer em casa. Porém, muitas vezes fica difícil para a professora corrigir as suas tarefas, pois como Mariazinha está aprendendo a escrever, de vez em quando ela se confunde e acaba trocando as letras do alfabeto. Na cabeça dela, de a... | A primeira linha de entrada contém um inteiro N , indicando o número de palavras que Mariazinha escreveu. Cada uma das próximas N linhas possui uma palavra S i S_i S i , contendo apenas letras minúsculas, de tal forma que a linha de número i contém a i -ésima palavra que Mariazinha escreveu. | Sua saída deve conter um inteiro X representando o número máximo de possíveis pares de anagramas que podem existir nessa lista. Restrições | [
{
"input": "3 dados caixa testa",
"output": "3"
},
{
"input": "6 cobra papos foto cola amora fato",
"output": "2"
}
] | 2 | Difícil | 256 mb | 1 second(s) |
neps:1524 | Neps Academy | 1,524 | Código | https://neps.academy/br/exercise/44 | Código A professora Maryam está tentando construir um código constituído de uma sequência de N strings de 10 letras minúsculas, S 1 , S 2 , S 3 , … , S N S_1, S_2, S_3, \ldots , S_N S 1 , S 2 , S 3 , … , S N . Essas strings da sequência serão, no futuro, concatenadas de diversas maneiras para formar strings mai... | A primeira linha da entrada contém um inteiro N , representando o número de strings na sequência. As N linhas seguintes contêm, cada uma, uma string de 10 letras minúsculas, definindo a sequência de strings do código. | Seu programa deve imprimir uma linha contendo a string "ok" caso o código seja válido, ou contendo a primeira string na sequência que invalida o código. Quer dizer, contendo S k S_k S k onde k é o menor possível tal que S k S_k S k seja substring de uma concatenação de duas strings anteriores na sequência. Restriçõ... | [
{
"input": "3 aaaaaaabbb yyuudiwwkl kkfidaaooa",
"output": "ok"
},
{
"input": "4 aaaaaaabbb yyuudiwwkl kkfidaaooa aooaaaaaaa",
"output": "aooaaaaaaa"
},
{
"input": "1 jfjshiddds",
"output": "ok"
},
{
"input": "2 abcdefghij abcdefghij",
"output": "abcdefghij"
},
{
... | 5 | Difícil | 256 mb | 1 second(s) |
neps:1884 | Neps Academy | 1,884 | Estatísticas | https://neps.academy/br/exercise/1904 | Estatísticas Os casos de coronavírus estão agora aumentando muito rapidamente na Terra do Nunca. O aumento é causado principalmente por uma nova variante do vírus que está se espalhando mais rapidamente do que a versão original. As pessoas ficam frustradas ao ver outro pico nas estatísticas, ao mesmo tempo em que não h... | A primeira linha da entrada consiste em n ( 1 ≤ n ≤ 10000 ) n \ (1 \ \leq \ n \ \leq \ 10 000) n ( 1 ≤ n ≤ 1 0 ) , o número dos próximos dias. Cada uma das próximas n linhas contém um número inteiro p i ( 0 ≤ p i ≤ 1000 ) p_i \ (0 \ \leq \ p_i \ \leq \ 1000) p i ( 0 ≤ p i ≤ 1 0 ) , indicando o número real de casos ... | Na saída, imprimir o valor mínimo total pelo qual os números reais devem ser alterados para que os novos casos não aumentem nos próximos dias. | [
{
"input": "3 100 150 200",
"output": "150"
},
{
"input": "2 5 4",
"output": "0"
},
{
"input": "4 10 0 9 8",
"output": "17"
}
] | 3 | Fácil | 512 mb | 2 second(s) |
neps:11039 | Neps Academy | 11,039 | Prêmio Acumulado | https://neps.academy/br/exercise/1257 | Prêmio Acumulado O problema está com um erro nos casos testes, por favor não usar LONG LONG INT para ter a resposta correta (basta usar um inteiro de 32 bits). Existe um programa de TV muito famoso chamado prêmio acumulado, nele existe uma lista contendo N números enfileirados que inicialmente estão escondidos e um par... | A entrada contém inicialmente um inteiro N contendo a quantidade de números enfileirados e outro inteiro Q indiciando a quantidade de intervalos a serem ditos. A próxima linha contém N inteiros X i Xi X i indicando o i-ésimo número enfileirado. As próximas Q linhas contém dois números indicando o intervalo escolhido. | A saída deve conter um número indicando o prêmio total do participante Restrições | [
{
"input": "3 3 2 -2 1 1 1 1 3 2 2",
"output": "1"
},
{
"input": "3 3 2 2 -1 1 1 2 2 3 3",
"output": "3"
}
] | 2 | null | 256 mb | 4 second(s) |
neps:1873 | Neps Academy | 1,873 | Imposto Real | https://neps.academy/br/exercise/91 | Imposto Real O reino de Nlogônia é rico, o povo é educado e feliz, mas o Rei é um tirano quando o assunto se refere a impostos. A cada final de ano, cada cidade do país deve pagar uma determinada quantidade de quilos de ouro em impostos. Chegado o momento de coletar os impostos, o Rei envia sua carruagem real para reco... | A primeira linha contém dois inteiros N e C indicando respectivamente o número de cidades e a capacidade de carga da carruagem ( 2 ≤ N ≤ 1 0 4 2 \leq N \leq 10^4 2 ≤ N ≤ 1 0 4 e 1 ≤ C ≤ 100 1 \leq C \leq 100 1 ≤ C ≤ 1 0 ). A capital do reino é identificada pelo número 1, as outras cidades são identificadas por inteiros... | Seu programa deve produzir uma única linha com um inteiro representando a menor distância que a carruagem real deve percorrer para recolher todo o imposto devido, em km. | [
{
"input": "6 10 0 10 10 10 10 10 1 4 7 5 1 2 3 5 3 2 5 2 6 5 2",
"output": "44"
},
{
"input": "3 10 10 10 12 1 2 5 2 3 7",
"output": "58"
},
{
"input": "5 9 5 2 6 3 6 1 2 1 2 3 1 2 4 1 2 5 1",
"output": "10"
}
] | 3 | Difícil | 256 mb | 1 second(s) |
neps:1337 | Neps Academy | 1,337 | Família Real | https://neps.academy/br/exercise/73 | Família Real O rei de um reino muito muito distante deu uma grande festa para reunir todas as gerações dos seus descendentes: filhos e filhas, netos e netas, bisnetos e bisnetas, e assim por diante. Ele, que gosta muito de estatísticas, agora quer saber, para cada geração, qual a porcentagem de descendentes daquela ger... | A primeira linha da entrada contém dois inteiros N e M , respectivamente, o número de descendentes e o número de participantes da festa. A segunda linha contém N números, representando os pais ou mães dos N descendentes, em ordem crescente: o primeiro número indica o pai ou a mãe do descendente de número 1, o segundo n... | Seu programa deve imprimir uma linha com uma lista de números reais, com precisão de duas casas decimais, indicando a porcentagem, para cada geração, dos descendentes daquela geração que compareceram à festa. O primeiro número deve ser a porcentagem dos filhos e filhas, o segundo dos netos e netas, e assim por diante. ... | [
{
"input": "9 5 7 3 0 9 0 3 5 6 7 3 2 8 1 9",
"output": "50.00 33.33 100.00 0.00"
},
{
"input": "16 11 15 9 2 8 6 11 0 3 0 8 12 0 9 6 16 12 5 14 9 12 6 2 4 10 3 11 7",
"output": "100.00 50.00 66.67 50.00 100.00"
}
] | 2 | Médio | 256 mb | 1 second(s) |
neps:11248 | Neps Academy | 11,248 | Sibi-Xor | https://neps.academy/br/exercise/1691 | Sibi-Xor Dabriel foi visitar seu amigo Farcos na cidade natal dele, Manaus, no estado do Amazonas. Ao chegar lá Dabriel estranhou a forma como as pessoas falavam por causa das expressões regionais bem específicas que usavam. Uma expressão bem curiosa que ouviu de uma conversa de Farcos com seu outro amigo RapBoy foi "S... | A primeira linha da entrada contém um inteiro N ( 1 ≤ N ≤ 2000 ) N \ (1 \ \leq \ N \ \leq \ 2000) N ( 1 ≤ N ≤ 2 0 ) representando a quantidade de números na lista de Farcos. A segunda linha contém N números inteiros A i ( 0 ≤ A i < 2 64 ) A_i \ (0 \ \leq \ A_i < 2^{64}) A i ( 0 ≤ A i < 2 6 4 ) correspondendo a list... | A saída consiste de uma única linha contendo a resposta de Rapboy, ou seja, o sibi-xor dos números fornecidos por Farcos. Como a resposta pode ser um número muito grande , imprima apenas seu módulo por 1 0 9 + 7 10^9+7 1 0 9 + 7 . | [
{
"input": "3 1 2 3",
"output": "3"
},
{
"input": "4 14 15 35 7",
"output": "57"
},
{
"input": "5 6 42 105 63 20",
"output": "219"
}
] | 3 | Difícil | 256 mb | 1 second(s) |
neps:1327 | Neps Academy | 1,327 | Pares de Números | https://neps.academy/br/exercise/565 | Pares de Números Temos um vetor de N inteiros distintos e dois inteiros I e F . Precisamos computar quantos pares desses inteiros do vetor somam pelo menos I e no máximo F . Por exemplo, se o vetor for [45, 12, 11, 7, 83, 29, 5] e I = 19 I = 19 I = 1 9 e F = 52 F = 52 F = 5 2 , temos exatamente 8 pares cuja soma está e... | A primeira linha da entrada contém três inteiros N , I e F , indicando respectivamente o tamanho do vetor e o valor mínimo da soma e o valor máximo da soma. | Seu programa deve imprimir uma única linha contendo um inteiro indicando quantos pares de inteiros no vetor somam pelo menos I e no máximo F . Restrições | [
{
"input": "7 19 52 45 12 11 7 83 29 5",
"output": "8"
},
{
"input": "2 -2 2 12 -16",
"output": "0"
}
] | 2 | Fácil | 256 mb | 1 second(s) |
neps:1349 | Neps Academy | 1,349 | Triângulos | https://neps.academy/br/exercise/312 | Triângulos Caio estava brincando de construir triângulos com palitos de diferentes tamanhos. Ele fazia isso juntando as pontas de três palitos sobre uma mesa. Ele notou que podia agrupar os triângulos formados em três grupos: Triângulos acutângulos , que são aqueles em que todos os ângulos internos medem menos de 90°; ... | A entrada consiste de uma única linha, contendo três inteiros A , B e C separados por espaço. | Imprima uma linha contendo apenas uma letra minúscula: 'n' se não for possível formar um triângulo; 'a' se o triângulo formado for acutângulo ; 'r' se o triângulo formado for retângulo ; 'o' se o triângulo formado for obtusângulo . Restrições | [
{
"input": "1 1 1",
"output": "a"
},
{
"input": "1 2 1",
"output": "n"
},
{
"input": "5 4 3",
"output": "r"
},
{
"input": "6 3 4",
"output": "o"
}
] | 4 | Fácil | 256 mb | 1 second(s) |
neps:1696 | Neps Academy | 1,696 | Cobertura para Celular | https://neps.academy/br/exercise/1087 | Cobertura para Celular Para atrair mais turistas, o governo decidiu permitir a instalação de uma rede de telefonia celular no paradisíaco arquipélago de Logarium. O arquipélago tem muitas ilhas no formato circular, todas com no máximo 1 km de diâmetro. Exatamente uma torre de celular será instalada no centro de cada um... | A primeira linha da entrada contém um inteiro N indicando o número de ilhas do arquipélago. Cada uma das N linhas seguintes contém dois inteiros X i X_i X i e Y i Y_i Y i , as coordenadas da i -ésima torre. Não existem duas torres com as mesmas coordenadas. A última linha da entrada contém um inteiro A indicando o ... | Seu programa deve produzir uma única linha na saída, contendo um único caractere, que deve ser S se a torre permite a cobertura total ou N caso contrário. Restrições | [
{
"input": "3 200 200 400 400 600 600 200",
"output": "N"
},
{
"input": "5 10 10 10 30 30 10 30 30 20 20 20",
"output": "S"
},
{
"input": "3 0 0 40 0 0 30 49",
"output": "S"
}
] | 3 | Médio | 256 mb | 1 second(s) |
neps:1499 | Neps Academy | 1,499 | Cofrinhos da Vó Vitória | https://neps.academy/br/exercise/635 | Cofrinhos da Vó Vitória Vó Vitória mantém, desde o nascimento dos netos Joãozinho e Zezinho, um ritual que faz a alegria dos meninos. Ela guarda todas as moedas recebidas como troco em dois pequenos cofrinhos, um para cada neto. Quando um dos cofrinhos fica cheio, ela chama os dois netos para um alegre almoço, ao final... | A entrada é composta de vários conjuntos de teste. A primeira linha de um conjunto de teste contém um número inteiro N , que indica o número de depósitos nos cofrinhos. As N linhas seguintes descrevem cada uma um depósito nos cofrinhos; o depósito é indicado por dois valores inteiros J e Z , separados por um espaço em ... | Para cada conjunto de teste da entrada seu programa deve produzir um conjunto de 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 seguir seu programa deve escrever uma linha para cada depósito do conjunto de tes... | [
{
"input": "3 20 25 10 5 10 10 4 0 5 12 0 0 20 17 1 0",
"output": "Teste 1 -5 0 Teste 2 -5 7 -13 3"
}
] | 1 | Fácil | 256 mb | 1 second(s) |
neps:1618 | Neps Academy | 1,618 | Banda | https://neps.academy/br/exercise/560 | Banda Jimmy é um garoto muito esperto que adora música. No último mês ele ganhou um campeonato de um jogo cujo objetivo é tocar guitarra. Empolgado, Jimmy decidiu montar uma banda. Para Jimmy a banda perfeita tem quatro integrantes, ele e mais três: um baterista, um baixista e um cantor. Agora Jimmy precisa encontrar o... | 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 é formada por dois inteiros N e M , informando respectivamente o número de músicos ( 3 ≤ N ≤ 100 3 \leq N \leq 100 3 ≤ N ≤ 1 0 ) e o número de pares de músicos que já toc... | Seu programa deve imprimir, na saída padrão, uma única linha, contendo três números inteiros separados por espaço em branco, identificando os três outros músicos que devem compor a banda (em ordem crescente). Se existir mais de uma melhor banda, Jimmy quer a banda lexicograficamente menor. Informações sobre a pontuação... | [
{
"input": "3 3 1 2 50 2 3 27 3 1 1",
"output": "1 2 3"
},
{
"input": "5 8 1 2 50 1 3 50 1 4 50 2 3 50 2 5 10 3 4 50 3 5 25 4 5 20",
"output": "1 2 3"
}
] | 2 | Médio | 256 mb | 1 second(s) |
neps:137 | Neps Academy | 137 | Campo Minado | https://neps.academy/br/exercise/241 | Campo Minado 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... | 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. | 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 | [
{
"input": "5 0 1 0 1",
"output": "1 2 1"
},
{
"input": "5 0 1 0",
"output": "1 2 3 2 1"
}
] | 2 | Fácil | 256 mb | 1 second(s) |
neps:1493 | Neps Academy | 1,493 | Feira de Bactérias | https://neps.academy/br/exercise/239 | Feira de Bactérias Bruno é um biólogo apaixonado por sua profissão. Sua especialidade é estudar o comportamento de bactérias. Por isso, ele possui em seu laboratório centenas de colônias de diferentes tipos desses microorganismos. Nesta semana ele viu o anúncio de um evento inusitado: uma feira de bactérias. Nessa feir... | A primeira linha da entrada contém um inteiro N representando a quantidade tipos de bactérias no catálogo. Cada uma das N linhas seguintes contém informações sobre um tipo de bactéria: a primeira dessas linhas contém a informação da bactéria de tipo 0, a segunda dessas linhas contém a informação sobre a bactéria de tip... | Seu programa deve imprimir, na saída padrão, um número inteiro entre 0 e N - 1 representando o tipo da bactéria que Bruno deverá comprar. Restrições | [
{
"input": "4 145 15 2 4999 3 3211 135 20",
"output": "2"
},
{
"input": "2 2 5 3 4",
"output": "1"
},
{
"input": "5 2 1 4 5 30 4 20 6 2 154",
"output": "4"
}
] | 3 | Médio | 256 mb | 1 second(s) |
neps:1401 | Neps Academy | 1,401 | Pão a Metro | https://neps.academy/br/exercise/605 | Pão a Metro Pão a metro é um tipo de sanduíche gigante que é uma excelente opção de lanche para torneios de programação, embora a experiência já tenha mostrado que o oferecimento de sanduíches pode gerar reclamação dos competidores. Outro grande problema é que algumas pessoas são mais gulosas que outras e, dessa maneir... | A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha da entrada contém um inteiro N que indica a quantidade pessoas. A segunda linha contém um inteiro K que é a quantidade de sanduíches disponível. Na terceira linha há K inteiros M se... | Seu programa deve imprimir, na saida padrão, uma única linha, contendo o tamanho inteiro máximo da fatia que pode ser cortada. Restrições | [
{
"input": "10 4 120 89 230 177",
"output": "57"
},
{
"input": "3 2 45 85",
"output": "42"
},
{
"input": "7 7 100 98 99 505 102 97 101",
"output": "101"
}
] | 3 | Médio | 256 mb | 1 second(s) |
neps:1129 | Neps Academy | 1,129 | Maior e Menor | https://neps.academy/br/exercise/172 | Maior e Menor Faça um programa para ler um inteiro N , depois N valores inteiros. Imprima o maior e o menor valor lido. | A entrada consiste de múltiplas linhas. A primeira linha contém um inteiro N . Seguirão N linhas, cada linha contendo um valor inteiro X . | A saída consiste de duas linhas. A primeira contém o valor do maior número lido. A segunda contém o valor do menor número lido. Restrições | [
{
"input": "3 1 2 3",
"output": "3 1"
},
{
"input": "5 1 3 -3 4 -2",
"output": "4 -3"
}
] | 2 | Fácil | 256 mb | 1 second(s) |
neps:11161 | Neps Academy | 11,161 | D como em Daedalus | https://neps.academy/br/exercise/1314 | D como em Daedalus Daedalus está jogando o jogo de "Não seja ganancioso", no qual N jogadores se sentam ao redor de uma mesa, tendo cada um deles cinco cartas marcadas com 1, 10, 100, 1000 e 10000 pontos. Em "Não seja ganancioso", os jogadores não podem falar uns com os outros durante o jogo, e há M rodadas. Em cada ro... | A primeira linha contém dois inteiros N e M , representando respectivamente o número de jogadores e o número de rodadas ( 1 ≤ N ≤ 20 (1 \ \leq \ N \ \leq \ 20 ( 1 ≤ N ≤ 2 0 e 1 ≤ M ≤ 50 ) 1 \ \leq \ M \ \leq \ 50) 1 ≤ M ≤ 5 0 ) . Cada uma das próximas M linhas descreve uma rodada com um inteiro B indicando o orçamento ... | null | [
{
"input": "5 3 300 10 100 10 1 10 1100 100 10 100 1 1000 1200 100 100 10 1 1000",
"output": "100"
},
{
"input": "3 2 2000 1000 1000 1000 21 1 1 10",
"output": "9"
}
] | 2 | Médio | 256 mb | 1 second(s) |
neps:11306 | Neps Academy | 11,306 | Quadro Premiado | https://neps.academy/br/exercise/2119 | Quadro Premiado Você está em um programa de televisão, e tem uma ótima chance de ganhar muito dinheiro. Trata-se de um jogo com algumas regras peculiares, e o montante de dinheiro resultante dependerá apenas da sua esperteza, podendo-se até sair perdendo caso se jogue mal. O jogo funciona da seguinte maneira: há um qua... | Haverá diversos casos de teste. Cada caso de teste inicia com dois inteiros, N e M ( 1 ≤ N , M ≤ 100 ) M (1 ≤ N, M ≤ 100) M ( 1 ≤ N , M ≤ 1 0 ) , indicando o número de linhas e de colunas do quadro, respectivamente. A seguir haverá N linhas, contendo M inteiros cada, representando os valores do quadro. Seja v o valor d... | Para cada caso de teste imprima uma linha, contendo um inteiro, representando a soma máxima que é possível alcançar se os padrões forem escolhidos de forma ótima. | [
{
"input": "2 2 3 4 1 2 4 ++ -- +. .+ 3 3 1 3 2 4 2 3 3 5 1 2 +.+ -+- 0 0",
"output": "5 8"
}
] | 1 | Difícil | 256 mb | 1 second(s) |
neps:11114 | Neps Academy | 11,114 | A Grande Casquinha | https://neps.academy/br/exercise/2834 | A Grande Casquinha Samyra gosta muito de sorvete e quer montar uma casquinha gigante com o máximo de bolas possíveis! Porém, ela é uma garota muito enjoada, então se ela já pegou uma bola com certo sabor de sorvete ela se recusará a pegar outra bola com o mesmo sabor. Como a sorveteria da cidade anda muito cheia, eles ... | A primeira linha da entrada contém um inteiro N , o número de potes de sorvete no balcão. A segunda linha contém um inteiro S , o número máximo de sabores distintos de sorvete. As próximas N linhas contêm cada uma um inteiro X i X_i X i , o sabor do i -ésimo sorvete. | Seu programa deve produzir uma única linha, contendo um único inteiro, o número de bolas na maior casquinha que Samyra pode montar. Restrições | [
{
"input": "3 2 1 2 1",
"output": "2"
},
{
"input": "6 3 1 2 3 2 3",
"output": "3"
}
] | 2 | Difícil | 256 mb | 1 second(s) |
neps:11049 | Neps Academy | 11,049 | Angariando Fundos | https://neps.academy/br/exercise/108 | Angariando Fundos Uma politica de prestígio visando a presidência no próximo ano está planejando um evento para angariar fundos para sua campanha. Ela possui uma lista de pessoas abastadas no país e quer convidá-los de uma forma a maximizar seus fundos. Algumas vezes os ricos e abastados tem comportamentos fúteis e não... | A primeira linha contem um inteiro N ( 1 ≤ N ≤ 1 0 5 1 \leq N \leq 10^5 1 ≤ N ≤ 1 0 5 ) representando o número possível de convidados. Cada uma das próximas N linhas descreve um possível candidato com três inteiros B , F e D ( 1 ≤ B , F , D ≤ 1 0 9 1 \leq B, F, D \leq 10^9 1 ≤ B , F , D ≤ 1 0 9 ), indicando respectivam... | Imprima uma única linha contendo um inteiro que indica a soma máxima de doações possíveis para uma lista de convidados que não gere discussão alguma durante o evento. | [
{
"input": "4 1 2 50 2 1 50 2 2 30 1 1 30",
"output": "60"
},
{
"input": "3 3 3 3 5 5 3 2 2 3",
"output": "9"
},
{
"input": "3 2 8 13 1 4 12 2 1 16",
"output": "25"
}
] | 3 | Difícil | 256 mb | 1 second(s) |
neps:11369 | Neps Academy | 11,369 | Hipótese Policial | https://neps.academy/br/exercise/411 | Hipótese Policial O sistema de transporte público da Nlogônia conta com uma rede expressa conectando os principais pontos turísticos do país. São usados N − 1 N-1 N − 1 trens-bala para conectar N atrações de modo que a partir de um dos pontos turísticos é possível alcançar qualquer outro ponto usando apenas essa rede e... | A primeira linha contém dois inteiros N e Q ( 1 ≤ N 1 \leq N 1 ≤ N , Q ≤ 1 0 5 Q \leq 10^5 Q ≤ 1 0 5 ), representando o número de estações e a quantidade de operações que devem ser processadas. A segunda linha contém o padrão P monitorado ( 1 ≤ ∣ P ∣ ≤ 100 1 \leq |P| \leq 100 1 ≤ ∣ P ∣ ≤ 1 0 ). A terceira linha contém ... | Seu programa deve imprimir uma linha para cada operação do tipo 1 contendo um inteiro que representa o número de ocorrências do padrão P no caminho analisado. | [
{
"input": "6 7 lol dlorlx 1 2 1 3 3 4 3 5 5 6 1 2 6 2 3 l 2 6 l 2 5 o 1 2 6 2 1 o 1 6 2",
"output": "0 1 2"
},
{
"input": "5 2 aba ababa 1 2 2 3 3 4 4 5 1 1 5 1 5 1",
"output": "2 2"
},
{
"input": "4 4 xtc xtzy 1 2 2 3 3 4 1 1 3 2 3 c 1 1 3 1 3 1",
"output": "0 1 0"
}
] | 3 | Super Difícil | 256 mb | 8 second(s) |
neps:11170 | Neps Academy | 11,170 | Cubra os Furos | https://neps.academy/br/exercise/630 | Cubra os Furos Uma placa de aço retangular contém N furos circulares de 5 mm de diâmetro, localizados em pontos distintos, não sobrepostos - ou seja, o centro de cada furo está a uma distância maior ou igual a 5 mm do centro de todos os outros furos. Uma peça de forma circular, tendo em seu centro um eixo de 5 mm de di... | A entrada é composta de vários conjuntos de teste. A primeira linha de um conjunto de teste contém um inteiro N , que indica o número de furos na placa de aço. As N linhas seguintes contêm cada uma dois inteiros X e Y , separados por um espaço em branco, que descrevem a posição do centro de um furo. A unidade de medida... | Para cada conjunto de teste da entrada seu programa deve produzir três linhas na saída. A primeira linha deve conter um identificador do conjunto de teste, no formato “Teste n”, onde n é numerado sequencialmente a partir de 1. A segunda linha deve conter o diâmetro mínimo que a peça deve ter, como um número inteiro. A ... | [
{
"input": "3 20 25 10 5 10 10 3 0 5 10 0 0 10 0",
"output": "Teste 1 42 Teste 2 28"
}
] | 1 | Médio | 256 mb | 1 second(s) |
neps:11001 | Neps Academy | 11,001 | Catálogo de Músicas | https://neps.academy/br/exercise/505 | Catálogo de Músicas Joyce é uma menina que gosta muito de ouvir música, e possui uma enorme coleção de músicas num DVD. Ela é uma menina organizada e deixa suas músicas em pastas, mas como o número de músicas e de pastas é grandre, Joyce construiu um catálogo para melhor localizá-las. Para o catálogo Joyce utilizou uma... | A primeira linha da entrada contém um inteiro N , indicando quantos arquivos Joyce possui no DVD. Cada uma das N linhas seguintes contém a descrição de um arquivo, a partir da raiz. | Seu programa deve imprimir uma única linha, contendo apenas um inteiro, o número mínimo de caracteres necessários para descrever o catálogo. Restrições | [
{
"input": "3 Rock/AngraCarryOn.mp3 MPB/Caetano/Sampa.mp3 MPB/Cartola/Alvorada.mp3",
"output": "59"
},
{
"input": "2 Preferidas/chacoalha/uia.mp3 Preferidas/chacoalha/eia.mp3",
"output": "14"
},
{
"input": "6 delta/india/juliet/lima bravo/echo bravo/foxtrot charlie/hotel delta/india/kilo... | 3 | Difícil | 256 mb | 1 second(s) |
neps:11244 | Neps Academy | 11,244 | Echoes no Grid | https://neps.academy/br/exercise/3015 | Echoes no Grid Pink Floyd está embarcando em uma turnê hipnotizante por uma grade de cidades, cada uma repleta de fãs entusiasmados. Cada célula nesta matriz representa uma cidade, e o número em cada célula mostra quantos fãs estão esperando para vivenciar a lendária performance da banda. À medida que a turnê começa na... | A primeira linha contém dois inteiros N e M ( 2 ≤ N , M ≤ 500 2 \leq N, M \leq 500 2 ≤ N , M ≤ 5 0 ), representando o número de linhas e colunas na matriz. Cada uma das próximas N linhas contém M inteiros, onde o j -ésimo inteiro na i -ésima linha representa A [ i ] [ j ] A[i][j] A [ i ] [ j ] ( 0 ≤ A [ i ] [ j ] ≤ 100... | Imprima um único inteiro, o número máximo total de fãs com os quais o Pink Floyd pode se comprometer ao atravessar de ( 0 , 0 ) (0, 0) ( 0 , 0 ) para ( N − 1 , M − 1 ) (N-1, M-1) ( N − 1 , M − 1 ) , movendo-se apenas para a direita ou para baixo. Restrições | [] | 0 | Difícil | 256 mb | 1 second(s) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.