Datasets:
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:1503 | Neps Academy | 1,503 | Jogo da Vida | https://neps.academy/br/exercise/2714 | Jogo da Vida O Jogo da Vida de Conway é um processo de simulação (conhecido como autômato celular) criado pelo matemático britânico John Conway para reproduzir, por meio de uma matriz, processos de mudança em grupos de seres vivos. As regras do jogo indicam como a matriz é modificada a cada passo. Os valores da matriz ... | A primeira linha contém dois números inteiros, N e Q , representando, respectivamente, o número de linhas/colunas da matriz e o número de passos a serem simulados. As próximas N linhas contém N caracteres cada. O j-ésimo caractere da i-ésima linha representa o estado inicial da célula na linha i e coluna j . Caso o car... | O seu programa deverá imprimir N linhas, cada uma contendo N caracteres. Na i-ésima linha, o j-ésimo caractere deve representar o Q -ésimo estado da célula na linha i e coluna j . Caso a célula esteja morta, o caractere deve ser '0'; se ela estiver viva, o caractere deve ser '1'. Restrições | [
{
"input": "5 3 00000 01110 01000 00100 00000",
"output": "01100 11000 00100 00000 00000"
},
{
"input": "15 1 000010000010000 000011000110000 000000000000000 111001101100111 001010101010100 000011000110000 000000000000000 000011000110000 001010101010100 111001101100111 000000000000000 00001100011000... | 3 | Difícil | 256 mb | 1 second(s) |
neps:11431 | Neps Academy | 11,431 | Hesitante Lobo | https://neps.academy/br/exercise/1575 | Hesitante Lobo Senoof adora linguagens de programação, e a única coisa que ele adora mais do que usá-las é criar novas linguagens. Sua mais recente invenção é a Wolf Programming Language, uma linguagem muito simples que consiste em apenas dois tipos de instruções. Elas são numeradas consecutivamente e escritas uma sob ... | A primeira linha contém um número inteiro de N ( 1 ≤ N ≤ 100 ) N (1 ≤ N ≤ 100) N ( 1 ≤ N ≤ 1 0 ) , o número de instruções que o programa tem. Cada uma das próximas linhas de N descreve uma instrução. Um salto finito é representado com um inteiro não-negativo K seguido por K inteiros L 1 , L 2 , . L K ( 1 ≤ L i ≤ N L_1,... | Produza uma única linha com um número inteiro indicando o número máximo de vezes que a instrução 1 pode ser executada, ou o caractere "*" (asterisco) se a instrução 1 pode ser executada infinitamente muitas vezes. | [
{
"input": "4 2 1 2 * 3 3 4 3 4 2 1 1",
"output": "3"
},
{
"input": "4 2 1 2 * 4 3 4 3 4 * 2",
"output": "2"
},
{
"input": "4 2 2 3 2 3 4 1 1 1 1",
"output": "3"
},
{
"input": "3 * 3 * 1 * 2",
"output": "*"
},
{
"input": "1 0",
"output": "1"
}
] | 5 | Super Difícil | 256 mb | 1 second(s) |
neps:1373 | Neps Academy | 1,373 | Mesmos números | https://neps.academy/br/exercise/2399 | Mesmos números Dado um número N inteiro de 2 dígitos em notação decimal, imprima '1' se o algarismo das dezenas e o algarismo das unidades de N forem iguais, e '0' caso contrário. | A entrada é fornecida pela entrada padrão no seguinte formato. N N | Saída '1' se o dígito das dezenas e o dígito das unidades de N forem iguais, e '0' caso contrário. Restrições | [
{
"input": "22",
"output": "1"
},
{
"input": "10",
"output": "0"
}
] | 2 | Super Fácil | 1024 mb | 2 second(s) |
neps:1145 | Neps Academy | 1,145 | Distância de Manhattan | https://neps.academy/br/exercise/335 | Distância de Manhattan Maria é uma moradora de Nlogópolis, uma cidade na Nlogônia que tem uma característica muito interessante: todas as ruas da cidade ou são orientadas no sentido norte-sul ou são orientadas no sentido leste-oeste. Isso significa que, dadas duas ruas, ou elas são paralelas ou elas são perpendiculares... | A única linha da entrada contém quatro inteiros, X m X_m X m , Y m Y_m Y m , X r X_r X r , Y r Y_r Y r , indicando as coordenadas de Maria ( X m , Y m ) (X_m, Y_m) ( X m , Y m ) e da reunião ( X r , Y r ) (X_r, Y_r) ( X r , Y r ) . O ponto de partida de Maria nunca será igual ao local da reunião, ou sej... | Seu programa deve imprimir uma única linha contendo um único inteiro: o número mínimo de cruzamentos que Maria precisa atravessar para chegar até o local da reunião. Restrições | [
{
"input": "0 0 5 6",
"output": "11"
},
{
"input": "52 75 120 75",
"output": "68"
}
] | 2 | Fácil | 256 mb | 1 second(s) |
neps:1254 | Neps Academy | 1,254 | Cápsulas | https://neps.academy/br/exercise/205 | Cápsulas O discípulo Fan Chi’ih retornou recentemente da China com algumas cápsulas mágicas, que são capazes de produzir moedas de ouro! Uma cápsula possui um certo ciclo de produção, que é um número C de dias. A cada C dias a cápsula produz uma nova moeda; a moeda é sempre produzida no último dia do ciclo. Fan Chi’ih ... | A primeira linha da entrada contém dois inteiros N e F , indicando o número de cápsulas e o número de moedas que Fan Chi’ih quer produzir, respectivamente. A segunda linha contém N inteiros C i C_i C i , para 1 ≤ i ≤ N 1 \leq i \leq N 1 ≤ i ≤ N , representando os ciclos de cada cápsula. | Imprima um inteiro, representando o número mínimo de dias para que as cápsulas produzam, no total, pelo menos F moedas. Restrições | [
{
"input": "3 12 3 7 2",
"output": "14"
},
{
"input": "10 100 17 13 20 10 12 16 10 13 13 10",
"output": "130"
}
] | 2 | Difícil | 256 mb | 1 second(s) |
neps:1480 | Neps Academy | 1,480 | Coletando Algarismos | https://neps.academy/br/exercise/813 | Coletando Algarismos Os algarismos de 0 a 9 estão dispostos em um círculo, conforme demonstra a imagem abaixo: Figura 1 Você tem controle sobre um ponteiro, o qual inicialmente está apontando para a casa com algarismo 0. Em um movimento você consegue mover esse ponteiro uma casa para a direita ou uma casa para a esquer... | A entrada consiste de uma linha contendo o inteiro N . | Seu programa deve produzir uma única linha, contendo o número mínimo de movimentos para coletar os algarismos de N sequencialmente. Restrições | [
{
"input": "3",
"output": "3"
},
{
"input": "1432",
"output": "6"
},
{
"input": "100116",
"output": "8"
}
] | 3 | Médio | 256 mb | 1 second(s) |
neps:1638 | Neps Academy | 1,638 | Zera Aquilo Ali | https://neps.academy/br/exercise/1749 | Zera Aquilo Ali Seu chefe pediu que você somasse uma sequência de números positivos para determinar quanto dinheiro sua empresa ganhou no ano passado. Infelizmente, seu chefe lê os números de forma incorreta de vez em quando. Felizmente, seu chefe percebe quando um número incorreto é lido e diz "zero", o que significa ... | A primeira linha de entrada contém o inteiro K ( 1 ≤ K ≤ 100000 ) K (1\leq K\leq 100 000) K ( 1 ≤ K ≤ 1 0 ) que é o número de inteiros (incluindo "zero") que seu chefe dirá. Em cada uma das próximas K linhas, haverá ou um inteiro entre 1 e 100 (inclusive), ou o inteiro 0. | A saída é uma linha, contendo o número inteiro que é a soma correta dos números inteiros lidos, levando em consideração as declarações "zero". Pode-se assumir que a saída será um número inteiro na faixa de 0 e 1 000 000 (inclusive). | [
{
"input": "4 3 0 4 0",
"output": "0"
},
{
"input": "10 1 3 5 4 0 7 0 6",
"output": "7"
}
] | 2 | Médio | 256 mb | 1 second(s) |
neps:1738 | Neps Academy | 1,738 | Deliv-e-droid | https://neps.academy/br/exercise/2288 | Deliv-e-droid No jogo Deliv-e-droid, um robô droid precisa entregar pacotes e evitar obstáculos. No final do jogo, a pontuação final é calculada com base no seguinte sistema de pontos: Ganho de 50 pontos para cada pacote entregue. Perda de 10 pontos por cada colisão com um obstáculo. Ganho de um bônus de 500 pontos se ... | A entrada consistirá em duas linhas. A primeira linha conterá um número inteiro não negativo P , representando o número de pacotes entregues. A segunda linha conterá um número inteiro não negativo C , representando o número de colisões com obstáculos. | A saída deverá ser um número inteiro F , representando a pontuação final. Explicação Entrada/Saída de Exemplo 1: Há 5 pacotes entregues, portanto, 5 × 50 = 250 5 \times 50 = 250 5 × 5 0 = 2 5 0 pontos são ganhos. Há 2 colisões, portanto, 2 × 10 = 20 2 \times 10 = 20 2 × 1 0 = 2 0 pontos são perdidos. Como 5 > 2 5 > 2 5... | [
{
"input": "5 2",
"output": "730"
},
{
"input": "0 10",
"output": "-100"
}
] | 2 | Fácil | 512 mb | 1 second(s) |
neps:1406 | Neps Academy | 1,406 | Crescimento da Floresta | https://neps.academy/br/exercise/2696 | Crescimento da Floresta Uma floresta está em um processo de reflorestamento, onde a cada dia um determinado número de árvores é plantado. Além disso, a cada dia, as árvores já plantadas produzem novas mudas que são plantadas no dia seguinte. O número de mudas produzidas por cada árvore é constante e igual a M. Você dev... | A primeira linha contém um inteiro 𝑇, o número inicial de árvores plantadas no dia 0. A segunda linha contém um inteiro 𝑀, o número de mudas que cada árvore produz a cada dia. A terceira linha contém um inteiro 𝐴, o número alvo de árvores que se deseja atingir. | Seu programa deve produzir uma única linha, contendo um único inteiro, o número de dias para que a floresta tenha 𝐴 ou mais árvores no total. Restrições | [
{
"input": "2 3 50",
"output": "3"
},
{
"input": "1 2 7",
"output": "2"
}
] | 2 | Difícil | 256 mb | 1 second(s) |
neps:11032 | Neps Academy | 11,032 | Calendário Lunar | https://neps.academy/br/exercise/3054 | Calendário Lunar Um entusiasta da astronomia está acompanhando eventos lunares únicos. Sua tarefa é determinar quantos dias dentro de um determinado período exibem um evento lunar. Assuma que a linha do tempo é numerada começando do dia 1 até o dia N . O primeiro evento lunar ocorre no dia M (que está garantido para se... | A entrada consiste em três inteiros: N : o número total de dias. M : o dia do primeiro evento lunar. P : o período entre os eventos lunares subsequentes. | null | [
{
"input": "",
"output": "1 1 e o dia N , inclusive, em que ocorre um evento lunar. Destrave esse exercício com uma assinatura PRO"
}
] | 1 | Difícil | 256 mb | 1 second(s) |
neps:1798 | Neps Academy | 1,798 | Números chiques | https://neps.academy/br/exercise/1637 | Números chiques Figura 1 Um número chique é aquele que quando rodado à 180 graus é o mesmo. Dado um número, encontrar se é chique ou não. 180 graus de rotação 6, 9, 1, 0 e 8 são 9, 6, 1, 0 e 8, respectivamente. | A entrada consiste de um único número inteiro N ( 1 ≤ N < 2 31 ) N (1≤N<2^{31}) N ( 1 ≤ N < 2 3 1 ) que não contém zeros à esquerda. | Você deve imprimir uma única linha que consiste em uma única palavra. “Sim”, caso o número seja um número chique, e “Nao” caso contrário. Observe que as aspas são somente para destacar as palavras, portanto, não fazem parte da saída. | [
{
"input": "96",
"output": "Sim"
},
{
"input": "996",
"output": "Nao"
},
{
"input": "121",
"output": "Nao"
},
{
"input": "818",
"output": "Sim"
}
] | 4 | Fácil | 256 mb | 1 second(s) |
neps:139 | Neps Academy | 139 | Inverso | https://neps.academy/br/exercise/187 | Inverso Faça um programa para ler 10 valores inteiros como entrada e imprima na ordem inversa da que foram lidos. | A entrada consiste de 10 linhas, cada linha contém um valor inteiro. | A saída consiste de dez linha contendo, cada linha com um os 10 valores lidos, porém, na ordem contrária da que foram lidos. | [
{
"input": "1 2 3 4 5 6 7 8 9 10",
"output": "10 9 8 7 6 5 4 3 2 1"
}
] | 1 | Fácil | 256 mb | 1 second(s) |
neps:121 | Neps Academy | 121 | Potências Simples | https://neps.academy/br/exercise/171 | Potências Simples Enquanto você estava estudando no Neps Academy você viu um problema chamado "Potências Simples" e resolveu lê-lo, o problema pedia para você ler dois números reais e imprimisse um número elevado ao outro. Faça um programa que resolva o problema. | A entrada é composta por apenas uma linha que contem dois números reais, x e y . | Seu programa deve imprimir um único número x y x^y x y com 4 casas decimais de precisão. Restrições | [
{
"input": "4 4",
"output": "256.0000"
},
{
"input": "2.5 2",
"output": "6.2500"
}
] | 2 | Fácil | 256 mb | 1 second(s) |
neps:1275 | Neps Academy | 1,275 | Chocolate (OBI 2007) | https://neps.academy/br/exercise/602 | Chocolate (OBI 2007) Juliana é uma famosa doceira reconhecida internacionalmente pelos seus bombons, exportados para todo o mundo. Embora não revele a ninguém as suas receitas, ela já deu entrevistas contando alguns de seus segredos. Sua fábrica de bombons utiliza somente chocolates comprados de um único produtor suíço... | A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha da entrada contém um inteiro N que indica o número de divisões feitas na barra de chocolate original. A linha seguinte contém N inteiros I representando o número de pedaços em que o... | E uma ótima descrição da saída esperada Restrições | [
{
"input": "3 2 3 5",
"output": "7"
},
{
"input": "5 2 2 2 3 3",
"output": "7"
},
{
"input": "7 2 3 4 5 6 7 8",
"output": "28"
}
] | 3 | Fácil | 256 mb | 1 second(s) |
neps:1606 | Neps Academy | 1,606 | Três inteiros | https://neps.academy/br/exercise/1778 | Três inteiros Dados três inteiros A, B e C, onde A, B e C são 1 ou 2. Qual aparece mais, 1 ou 2? | A entrada é dada pela entrada padrão na seguinte forma: A B C | Imprima o inteiro que está em maior quantidade entre os números recebidos, podendo ser 1 ou 2. Restrições A, B e C são 1 ou 2. | [
{
"input": "1 2 1",
"output": "1"
},
{
"input": "2 2 2",
"output": "2"
}
] | 2 | Fácil | 1024 mb | 2 second(s) |
neps:1466 | Neps Academy | 1,466 | Sequência da Onda | https://neps.academy/br/exercise/300 | Sequência da Onda A Onda é uma sequência de inteiros. Ela tem algumas propriedades interessantes: Uma Onda tem tamanho ímpar, da forma L = 2 ⋅ n + 1 L = 2\cdot n+1 L = 2 ⋅ n + 1 Os primeiros n + 1 n+1 n + 1 inteiros da Onda formam uma sequência estritamente crescente; Os últimos n + 1 n+1 n + 1 inteiros da Onda formam ... | A primeira linha da entrada contém um inteiro positivo m . A segunda linha contém m inteiros a i a_i a i , os elementos da sequência. | Seu programa deve produzir uma única linha, contendo um único inteiro: o tamanho da maior Sequência da Onda que é uma subsequência da que é fornecida na entrada Restrições | [
{
"input": "10 1 2 3 4 5 4 3 2 1 10",
"output": "9"
},
{
"input": "19 1 2 3 2 1 2 3 4 3 2 1 5 4 1 2 3 2 2 1",
"output": "9"
},
{
"input": "5 1 2 3 4 5",
"output": "1"
}
] | 3 | Difícil | 256 mb | 1 second(s) |
neps:1709 | Neps Academy | 1,709 | Covid-19 | https://neps.academy/br/exercise/1903 | Covid-19 O Ministério da Saúde da Terra do Nunca publicou recentemente uma tabela codificada por cores para ajudar as pessoas a entender melhor o nível de risco da Covid-19 em diferentes cidades, e tomar as ações e precauções apropriadas com base no nível de risco. Neste gráfico, cada cidade é colorida em vermelho, ama... | A entrada consiste em duas linhas. A primeira linha contém um número inteiro p ( 0 ≤ p ≤ 1000 ) p \ (0 \ \leq \ p \ \leq \ 1000) p ( 0 ≤ p ≤ 1 0 ) , mostrando o número médio de novos casos por dia em cada um milhão de habitantes da cidade de Hana nas últimas duas semanas. A segunda linha contém um número inteiro q ( 0 ... | Na saída, imprima o código de cores da cidade de Hana. Deve ser "White", "Yellow" ou "Red". | [
{
"input": "50 7",
"output": "White"
},
{
"input": "60 40",
"output": "Red"
},
{
"input": "15 12",
"output": "Yellow"
}
] | 3 | Fácil | 512 mb | 2 second(s) |
neps:1861 | Neps Academy | 1,861 | Dança Indígena | https://neps.academy/br/exercise/547 | Dança Indígena A OBI (Organização Brasileira dos ´Indios) promoverá um festival indígena, onde várias tribos irão se reunir e fazer demonstrações de cultura, como artesanato, danças, pinturas, comidas e etc. Uma das tribos é a dos Tunak Tunak, que possuem uma apresentação de dança muito peculiar. Nessa dança, existem N... | A primeira linha da entrada possui 2 inteiros: N ( 3 ≤ N ≤ 1 0 6 3 \leq N \leq 10^6 3 ≤ N ≤ 1 0 6 ) e E ( 1 ≤ E ≤ 1 0 3 1 \leq E \leq 10^3 1 ≤ E ≤ 1 0 3 ), que são, respectivamente, a quantidade de toras e a quantidade de índios que irão dançar ( E ≤ N E \leq N E ≤ N ). As próximas E linhas contém, cada uma, a descriçã... | Seu programa deverá exibir um número inteiro representando a quantidade de batidas de tambor neces árias para que a dança acabe. Informações sobre a pontuação Em um conjunto de casos de teste que totaliza 40 pontos, N ≤ 100 N \leq 100 N ≤ 1 0 e E ≤ 100 E \leq 100 E ≤ 1 0 . | [
{
"input": "6 4 2 1 3 1 5 1 6 1",
"output": "3"
},
{
"input": "3 1 2 -1",
"output": "3"
},
{
"input": "8 6 2 -1 3 1 4 -1 6 1 7 -1 8 1",
"output": "4"
}
] | 3 | Super Difícil | 256 mb | 1 second(s) |
neps:11139 | Neps Academy | 11,139 | Sapo Saltador | https://neps.academy/br/exercise/105 | Sapo Saltador Pog o sapo quer competir no Mundial de Saltos Sapicos, que ira ocorrer em Nlogonia. Na competição cada sapo deve realizar uma série de saltos acrobáticos em uma arena especialmente construída. A arena é composta de N posições igualmente espaçadas ao redor de uma circunferência (ao arco entre as posições a... | A entrada consiste de uma única linha contendo uma string S com N caracteres ( 3 ≤ N ≤ 1 0 5 3 \leq N \leq 10^5 3 ≤ N ≤ 1 0 5 ), representando as posições da arena. O i-ésimo caractere de S ( i = 0 , 1 , … , N − 1 i=0,1,\ldots,N-1 i = 0 , 1 , … , N − 1 ) indica que a posição i da arena é ou uma Rocha ( “R” maiúsculo) o... | Imprima uma única linha com um inteiro representando o número de distâncias de pulo distintas que Pog pode escolher para sua seção de prática, dado que ele pode usar qualquer pedra como posição inicial para sua sequência de pulos. | [
{
"input": "RRR",
"output": "2"
},
{
"input": "RRPR",
"output": "1"
},
{
"input": "PRP",
"output": "0"
}
] | 3 | Difícil | 256 mb | 1 second(s) |
neps:1260 | Neps Academy | 1,260 | Segmento de Maior Or | https://neps.academy/br/exercise/304 | Segmento de Maior Or Dado um vetor com N inteiros positivos, diga qual o maior valor do o r or o r de todos os elementos de um segmento do vetor. Por exemplo se nosso vetor tiver os seguintes 4 elementos, [6, 9, 1, 2], então os o r or o r s de todos os elementos de cada segmento serão: [6] = 6 [6, 9] = 15 [6, 9, 1] = 1... | A entrada consiste em duas linhas, a primeira linha contem um inteiro N , a segunda contem N inteiros positivos. | Imprima A , o valor do maior o r or o r de todos os elementos de um segmento do vetor. Restrições | [
{
"input": "6 1 2 4 8 16 32",
"output": "63"
}
] | 1 | Fácil | 256 mb | 1 second(s) |
neps:11048 | Neps Academy | 11,048 | Contrutora | https://neps.academy/br/exercise/2929 | Contrutora Em uma rua existem N prédios adjacentes, o i -ésimo entre eles (da esquerda para a direita) possui a i a_i a i andares. Uma construtora acabou de comprar todos os prédios da rua, e fará uma obra para que eles tenham a mesma altura (quantidade de andares), porém, para realizar esta obra deve seguir as regra... | A primeira linha da entrada contém um único inteiro N , o número de prédios da rua. A segunda linha contém N inteiros, o i -ésimo entre esses inteiros é a i a_i a i , a quantidade de andares do i -ésimo prédio. | A saída deve conter um único número inteiro, a menor quantidade de fases necessárias para a construtora completar a obra, ou seja, deixar todos os prédios com a mesma altura. Restrições | [
{
"input": "4 3 1 1 2",
"output": "2"
},
{
"input": "8 5 4 4 4 5 4 4 7",
"output": "4"
},
{
"input": "3 100 100 100",
"output": "0"
}
] | 3 | Difícil | 256 mb | 1 second(s) |
neps:1522 | Neps Academy | 1,522 | Show | https://neps.academy/br/exercise/2069 | Show Um grupo de amigos quer comprar ingressos para um show da sua banda preferida. O show acontece num teatro que tem N filas de assentos, cada fila com M assentos. Os amigos querem comprar ingressos de forma que os assentos dos amigos: sejam todos na mesma fila, sejam contíguos (ou seja, um vizinho ao outro) e sejam ... | A primeira linha contém três inteiros A , N e M , indicando respectivamente o número de amigos, o número de filas de assentos e o número de assentos em cada fila do teatro. As filas são numeradas de 1 (mais próxima do palco) até N (mais distante do palco). Cada uma das N linhas seguintes contém M inteiros X i X_i X i ... | Seu programa deve produzir uma única linha, contendo um único inteiro, que deve ser o número da fila em que os amigos conseguem comprar os ingressos se é possível encontrar ingressos de acordo com as condições dadas, ou − 1 −1 − 1 caso contrário. Restrições | [
{
"input": "4 3 5 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0",
"output": "1"
},
{
"input": "2 3 5 0 1 0 1 0 0 1 0 1 0",
"output": "-1"
},
{
"input": "3 6 4 0 0 0 0 1 0 0 0 1 1 0 0 1 1 1 0 1 1 1 1 1 1 1 1",
"output": "5"
}
] | 3 | Médio | 256 mb | 1 second(s) |
neps:1347 | Neps Academy | 1,347 | Pulo do Sapo | https://neps.academy/br/exercise/529 | Pulo do Sapo Sebastião Bueno Coelho, apelidado de SBC pelos familiares e amigos, passou as férias de janeiro de 2011 no sítio de seus avós. Durante sua estadia, uma das atividades prediletas do SBC era nadar no rio que havia no fundo da casa onde morava. Uma das características do rio que mais impressionava SBC era um ... | A primeira linha da entrada contém dois inteiros N e M representando o número de pedras no rio e o número de sapos, respectivamente. Cada uma das M linhas seguintes possui dois inteiros P e D representando a posição inicial de um sapo e a distância fixa de pulo, respectivamente. | A saída contém N linhas. A i -ésima linha indica a possibilidade ou não de ter um sapo na i -ésima pedra. Para as pedras que podem ter um sapo você deve imprimir 1, e para as pedras que com certeza não podem ter nenhum sapo você deve imprimir 0. Restrições | [
{
"input": "5 2 3 2 4 4",
"output": "1 0 1 1"
},
{
"input": "8 3 3 3 2 2 6 2",
"output": "0 1 0 1 0 1"
}
] | 2 | Fácil | 256 mb | 1 second(s) |
neps:11447 | Neps Academy | 11,447 | Iksevi | https://neps.academy/br/exercise/2413 | Iksevi Figura 1 Após dez anos de programação, Vinko decidiu mudar de profissão e se tornar um ceramista. Já no primeiro dia de seu novo emprego, ele recebeu uma tarefa extremamente difícil. Ele precisa pavimentar o chão da sala de concertos com azulejos cerâmicos quadrados. No entanto, ele não vai pavimentar o chão de ... | A primeira linha contém o inteiro n ( 1 ≤ n ≤ 1 0 6 ) n \ (1 \leq n \leq 10^6) n ( 1 ≤ n ≤ 1 0 6 ) , o número de pontos acústicos. As próximas n linhas contêm dois inteiros x i , y i ( 0 ≤ x i , y i ≤ 1 0 7 ) x_i \ , \ y_i \ (0 \leq x_i, \ y_i \leq 10^7 ) x i , y i ( 0 ≤ x i , y i ≤ 1 0 7 ) , que indicam que o ... | Na i -ésima das n linhas, imprima o número da declaração da tarefa para o i -ésimo ponto. Explicação do exemplo de Entrada/saída 2: As imagens da declaração da tarefa correspondem ao segundo exemplo. | [
{
"input": "3 1 4 0 0 0 9",
"output": "1 0 3"
},
{
"input": "3 5 1 4 3 2 4",
"output": "0 1 1"
}
] | 2 | Difícil | 512 mb | 3 second(s) |
neps:1232 | Neps Academy | 1,232 | Plano de Internet | https://neps.academy/br/exercise/1480 | Plano de Internet João conseguiu contratar um ótimo plano de Internet para o seu telefone celular. O plano permite que João utilize uma quota de até X megabytes de dados por mês para navegar na Internet. Se João não usa toda a sua quota no mês, os megabytes que ele não usou são adicionados à quota do mês seguinte. Pelo... | A primeira linha da entrada contém um número inteiro X , o valor da quota mensal em megabytes. A segunda linha contém um inteiro N , o número de meses. Cada uma das linhas seguintes contém um número inteiro M i M_i M i , indicando a quantidade de megabytes que João usou em cada mês, do mês 1 até o mês N . | Seu programa deve produzir uma única linha, contendo um único número inteiro, a quantidade de megabytes que João tem para usar no mês N + 1 N + 1 N + 1 . Restrições | [
{
"input": "100 2 50 120",
"output": "130"
},
{
"input": "10 3 4 6 2",
"output": "28"
},
{
"input": "100 2 100 100",
"output": "100"
}
] | 3 | Fácil | 256 mb | 1 second(s) |
neps:1510 | Neps Academy | 1,510 | Permutação Máxima | https://neps.academy/br/exercise/2507 | Permutação Máxima Andremfq é um programador talentoso e entusiasta de programação competitiva. Recentemente, ele se deparou com um problema fascinante envolvendo permutações e funções. Dado um array A de tamanho N contendo os inteiros A 1 , A 2 , . , A N A_1,A_2,...,A_N A 1 , A 2 , . , A N , Andremfq definiu uma ... | A entrada contém um único inteiro N , o tamanho da permutação. | Imprima um único valor: o maior valor possível de f ( P ) f(P) f ( P ) entre todas as permutações de 1 , 2 , . , N {1,2,..,N} 1 , 2 , . , N . Restrições | [
{
"input": "5",
"output": "12"
},
{
"input": "10",
"output": "50"
}
] | 2 | Difícil | 256 mb | 1 second(s) |
neps:1113 | Neps Academy | 1,113 | Teleférico | https://neps.academy/br/exercise/15 | Teleférico A turma do colégio vai fazer uma excursão na serra e todos os alunos e monitores vão tomar um teleférico para subir até o pico de uma montanha. A cabine do teleférico pode levar C pessoas no máximo, contando alunos e monitores, durante uma viagem até o pico. Por questão de segurança, tem que ter pelo menos u... | A primeira linha da entrada contém um inteiro C , representando a capacidade da cabine. A segunda linha da entrada contém um inteiro A , representando o número total de alunos na turma. | Seu programa deve imprimir uma linha contendo um número inteiro representando o número mínimo de viagens do teleférico para levar todos os alunos até o pico da montanha. Restrições | [
{
"input": "10 20",
"output": "3"
},
{
"input": "12 55",
"output": "5"
},
{
"input": "100 87",
"output": "1"
}
] | 3 | Fácil | 256 mb | 1 second(s) |
neps:1658 | Neps Academy | 1,658 | Multiplicação e Divisão de Frações - Python | https://neps.academy/br/exercise/2237 | Multiplicação e Divisão de Frações - Python 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 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:11225 | Neps Academy | 11,225 | Listagem de tarefas com submissões em linguagem X | https://neps.academy/br/exercise/2682 | Listagem de tarefas com submissões em linguagem X Neste exercício, você deverá criar um programa que recebe o nome de uma linguagem de programação e utiliza INNER JOIN para listar os títulos das tarefas de programação que possuem submissões nessa linguagem específica. Você pode usar o código abaixo como ponto de partid... | A entrada é formada apenas por uma linha, que contém o nome da linguagem de programação. | Seu programa deve imprimir os títulos das tarefas de programação, um em cada linha. Além disso, os dados devem estar ordenados pelo ID da tarefa de programação e não devem ser repetidos. Restrições A linguagem recebida na entrada será sempre alguma da lista abaixo: | [
{
"input": "Python",
"output": "FizzBuzz Palindrome"
},
{
"input": "Ruby",
"output": "Anagram Longest Substring Without Repeating Characters"
}
] | 2 | Difícil | 256 mb | 1 second(s) |
neps:194 | Neps Academy | 194 | Expressões | https://neps.academy/br/exercise/271 | Expressões Pedrinho e Zezinho estão precisando estudar resolução de expressões matemáticas para uma prova que irão fazer. Para isso, eles querem resolver muitos exercícios antes da prova. Como sabem programar, então decidiram fazer um gerador de expressões matemáticas. O gerador de expressões que eles criaram funciona ... | A entrada é composta por diversas instâncias. A primeira linha da entrada contém um inteiro T indicando o número de instâncias. Em seguida temos T linhas, cada uma com uma cadeia A . | Para cada instância imprima uma linha contendo a letra 'S' se a cadeia é bem definida, ou a letra 'N' caso contrário. Restrições | [
{
"input": "12 () [] {} (] }{ ([{}]) {}()[] ()] {[] ( (([{}{}()[]])(){}){} (((((((((({([])}])))))))))",
"output": "S S N N S N N S N"
}
] | 1 | Médio | 256 mb | 1 second(s) |
neps:11488 | Neps Academy | 11,488 | Mostre a Sequência | https://neps.academy/br/exercise/1980 | Mostre a Sequência A | null | null | [] | 0 | null | 256 mb | 1 second(s) |
neps:11181 | Neps Academy | 11,181 | Porto Agitado | https://neps.academy/br/exercise/1199 | Porto Agitado Existem dois guindastes que operam no mesmo pórtico de comprimento n . O pórtico tem algumas posições inteiras fixas, etiquetadas de 1 a n , nas quais os guindastes devem executar operações de carga/descarga. No início, o primeiro pórtico está localizado à esquerda do pórtico na posição 1 , enquanto o seg... | A entrada consiste em: Uma linha com números inteiros n , a e b onde n é o comprimento do pórtico; a é o número de operações na lista de tarefas do primeiro guindaste do pórtico; b é o número de operações na lista de tarefas do segundo guindaste do pórtico. Uma linha com a inteiros k 1 , . , k a k_1, ..., k_a k 1 , .... | Produza o tempo mínimo necessário para que ambos os pórticos terminem as suas tarefas atribuídas. Restrições | [
{
"input": "3 2 4 1 1 3 3 2 3",
"output": "6"
},
{
"input": "4 4 4 1 2 3 1 4 3 3 4",
"output": "9"
}
] | 2 | Super Difícil | 256 mb | 1 second(s) |
neps:1230 | Neps Academy | 1,230 | Chuva (OBI 2016) | https://neps.academy/br/exercise/58 | Chuva (OBI 2016) É período de chuva no Reino Quadrado. Nos últimos anos, o Rei Maior Quadrado (RMQ) ordenou a construção de uma enorme piscina para refrescar seus súditos. A piscina é composta por diversas seções de mesma largura e comprimento, mas podem ter alturas diferentes. A altura de cada seção é um número inteir... | A primeira linha contém um inteiro, N , o número de seções da piscina. Seguem N linhas, cada uma com um inteiro H i H_i H i , a altura da i-ésima seção, em metros. | Seu programa deve produzir uma única linha, contendo um único inteiro, o número de seções da piscina cobertos por água. Restrições | [
{
"input": "4 2 1 2",
"output": "2"
},
{
"input": "6 5 2 6 1 3 3",
"output": "2"
},
{
"input": "17 4 3 2 1 2 3 5 3 3 2 4 4",
"output": "12"
}
] | 3 | Médio | 256 mb | 1 second(s) |
neps:1161 | Neps Academy | 1,161 | Atribuindo Equipes | https://neps.academy/br/exercise/123 | Atribuindo Equipes Quatro amigos estão jogando tênis de mesa. Cada um deles tem um nível de habilidade que é representado por um número inteiro: quanto maior o número, melhor o jogador é. Os quatro amigos querem formar duas equipes de dois jogadores cada. Para que o jogo seja mais emocionante, eles querem que o nível d... | A entrada consiste em uma única linha que contém quatro números inteiros A , B , C e D , representando os níveis de habilidade dos quatro jogadores. | A saída contém apenas uma linha com um número inteiro que representa a menor diferença entre os níveis de habilidade para ambas as equipes. Restrições | [
{
"input": "4 7 10 20",
"output": "7"
},
{
"input": "0 0 1 1000",
"output": "999"
},
{
"input": "1 2 3 4",
"output": "0"
}
] | 3 | Fácil | 256 mb | 1 second(s) |
neps:1612 | Neps Academy | 1,612 | Sequência | https://neps.academy/br/exercise/211 | Sequência O professor da importante disciplina de Indução Matemática está tentando resolver uma versão generalizada de um problema muito tradicional: encontrar o valor máximo possível para a soma dos elementos de uma subsequência contígua de uma sequência de números inteiros quaisquer. Mais rigorosamente, dado uma sequ... | A primeira linha da entrada contém três inteiros N , L e H , indicando respectivamente o número de elementos na sequência, a cota inferior L e a cota superior H . A segunda linha contém N inteiros s i s_i s i , para 1 ≤ i ≤ N 1 \leq i \leq N 1 ≤ i ≤ N , definindo os elementos da sequência. A terceira linha contém N i... | Imprima um inteiro, representando o valor máximo possível para a soma dos elementos de uma subsequência contígua, que contenha pelo menos L e no máximo H elementos marcados. Restrições | [
{
"input": "14 3 4 9 0 -23 -12 7 1 -13 2 -1 9 -16 -1 14 12 1 0 0 1 0 1 0 0 1 1 0 0 1 1",
"output": "19"
},
{
"input": "14 7 20 9 0 -23 -12 7 1 -13 2 -1 9 -16 -1 14 12 1 0 0 1 0 1 0 0 1 1 0 0 1 1",
"output": "-12"
},
{
"input": "14 5 5 9 0 -23 -12 7 1 -13 2 -1 9 -16 -1 14 12 1 0 0 1 0 1 0... | 4 | Difícil | 256 mb | 1 second(s) |
neps:1567 | Neps Academy | 1,567 | Jogo dos Pinos | https://neps.academy/br/exercise/1015 | Jogo dos Pinos O Jogo dos Pinos é um quebra-cabeças que utiliza pinos e um tabuleiro com furos em forma de cruz. Inicialmente há apenas um furo vago, no centro do tabuleiro, e todos os outros furos contém um pino como mostra a figura abaixo. Figura 1 O objetivo do jogo é remover os pinos do tabuleiro de forma que reste... | A entrada é composta por sete linhas, cada linha com exatamente sete caracteres. A linhas são identificadas por números de 1 a 7. Os dois primeiros caracteres e os dois últimos caracteres das linhas 1, 2, 6 e 7 são ‘-’ (hífen). Todos os outros caracteres são ou ‘o’ (letra o minúscula) representando um pino, ou ‘.’ (pon... | Seu programa deve produzir uma única linha, contendo um único inteiro, o número de movimentos válidos na configuração da entrada. Restrições A seção Entrada descreve as restrições. | [
{
"input": "--ooo-- --ooo-- ooooooo ooo.ooo ooooooo --ooo-- --ooo--",
"output": "4"
},
{
"input": "--.o.-- --o.o-- ....o.. o.o.o.. --o.o-- --o.o--",
"output": "2"
}
] | 2 | Médio | 256 mb | 1 second(s) |
neps:1762 | Neps Academy | 1,762 | Empilhando Corpos | https://neps.academy/br/exercise/1636 | Empilhando Corpos Figura 1 Paulo Alberto é um jovem estudante de engenharia civil e passa muito tempo nos laboratórios estudando estruturas. Principalmente fazendo corpos de prova. Corpos de prova são amostras de concreto endurecidas, geralmente em forma de cilindros não muito grandes, utilizados para testar propriedad... | A entrada de um único número inteiro N ( 1 ≤ N ≤ 500500 ) N (1≤N≤500500) N ( 1 ≤ N ≤ 5 0 5 0 ) que corresponde ao número de corpos de prova que Paulo Alberto tem à disposição. | Você deve imprimir uma única linha com um inteiro que corresponde à altura máxima em fileiras do construto formado pela brincadeira de Paulo. Veja os exemplos a seguir para o formato exato de entrada/saída. | [
{
"input": "15",
"output": "5"
},
{
"input": "20",
"output": "5"
},
{
"input": "21",
"output": "6"
},
{
"input": "57",
"output": "10"
}
] | 4 | Médio | 256 mb | 1 second(s) |
neps:1460 | Neps Academy | 1,460 | Cubo e quadrado | https://neps.academy/br/exercise/1774 | Cubo e quadrado O número 729 7 2 9 tem uma particularidade interessante: é ao mesmo tempo o cubo e o quadrado de um número inteiro ( 729 = 2 7 2 729 = 27^2 7 2 9 = 2 7 2 e 729 = 9 3 729 = 9^3 7 2 9 = 9 3 ). Outro número com essa particularidade é 4096 4 0 9 6 ( 4096 = 6 4 2 4096 = 64^2 4 0 9 6 = 6 4 2 e 4096 = 1 6 3 40... | A primeira linha da entrada contém um inteiro A , o limite inferior do intervalo de interesse, a segunda linha contém um inteiro B , o limite superior do intervalo de interesse ( A e B fazem parte do intervalo de interesse). | Seu programa deve produzir uma única linha na saída, contendo um único inteiro, a quantidade de números que são ao mesmo tempo cubo e quadrado de um número inteiro, para todos os números do intervalo de interesse. Restrições | [
{
"input": "64 729",
"output": "2"
},
{
"input": "3000 5000",
"output": "1"
}
] | 2 | Médio | 256 mb | 1 second(s) |
neps:1479 | Neps Academy | 1,479 | Mini Dicionário | https://neps.academy/br/exercise/2233 | Mini Dicionário Vamos criar um mini dicionário! Serão enviados N traduções para serem adicionadas no dicionário. Cada uma das traduções conterá duas strings, a primeira é a palavra em inglês e a segunda sua tradução em português. Em seguida, será enviada uma frase em inglês. Você deve imprimir a tradução dessa frase É ... | A primeira linha contém um inteiro N . Cada uma das N linhas seguintes possui duas strings I e P ( I representa a palavra em inglês e P a palavra em português) A última linha conterá uma string, a frase que será traduzida. Cada palavra será separada por um único espaço. | Seu programa deve produzir apenas uma linha, contendo a tradução da frase inserida | [
{
"input": "3 I eu you voce love amo I love you",
"output": "eu amo voce"
}
] | 1 | Fácil | 256 mb | 1 second(s) |
neps:1604 | Neps Academy | 1,604 | Passatempo | https://neps.academy/br/exercise/1658 | Passatempo Desafios de lógica e matemática são um ótimo passatempo, atraindo um grande número de praticantes, e um mercado que envolve aplicativos para celular, atividades on-line, revistas especializadas e até mesmo cursos na internet para melhorar o desempenho! Neste problema sua tarefa é escrever um programa que res... | A primeira linha contém dois inteiros L e C indicando o número de linhas e o número de colunas do passatempo. Cada uma das L linhas seguintes contém C nomes de variáveis, seguidos de um inteiro S , a soma resultante das variáveis dessa linha. A última linha contém C inteiros X i X_i X i , indicando respectivamente a ... | Seu programa deve produzir uma linha para cada variável do passatempo, contendo o nome da variável e o seu valor inteiro. As variáveis devem ser escritas em ordem alfabética crescente, ou seja, respeitando a ordem aa, ab, . . . , az, ba, bb, . . . , za, zb, . . . , zz. Restrições | [
{
"input": "4 5 df bb cg df df 11 ee az cg az ee 6 df cg cg df df 10 az az cg az az 6 6 7 8 6 6",
"output": "az 1 bb 3 cg 2 df 2 ee 1"
},
{
"input": "3 4 aa bb cc dd 10 3 6 9 12",
"output": "aa 1 bb 2 cc 3 dd 4"
},
{
"input": "3 3 aa zz aa 27 vv zz aa -5 kk kk aa 40 15 -7 54",
"outpu... | 3 | Difícil | 256 mb | 1 second(s) |
neps:1565 | Neps Academy | 1,565 | Fraseando | https://neps.academy/br/exercise/1470 | Fraseando Thiago morou muitos anos fora do Brasil a trabalho, como pretende visitar seu amigo Francisco para organizarem a Maratona de Programação do Norte ele resolveu estudar durante o voo de volta sobre o nome de todos os estados do Norte e suas cidades. Para tornar essa tarefa mais interessante, Thiago criou um esp... | A entrada é composta por uma única linha contendo uma string S com caracteres minúsculos do alfabeto inglês. | A saída é composta por única string representando o resultado após a cifragem. Restrições | [
{
"input": "acre",
"output": "abcd"
},
{
"input": "amapa",
"output": "abaca"
},
{
"input": "rondonia",
"output": "abcdbcef"
},
{
"input": "para",
"output": "abcb"
},
{
"input": "tocantins",
"output": "abcdeafeg"
}
] | 5 | Fácil | 256 mb | 1 second(s) |
neps:1786 | Neps Academy | 1,786 | Frações Binárias | https://neps.academy/br/exercise/2473 | Frações Binárias Luca é um jovem apaixonado por programação competitiva. Certo dia, enquanto explorava uma lista de números, ele se deparou com algo intrigante: uma sequência de frações incomuns. Depois de observar as frações por alguns instantes ele notou um detalhe interessante: o numerador e o denominador são sempre... | A primeira linha contém um inteiro F , representando a quantidade de frações. A i − i- i − ésima das próximas F linhas contém os inteiros N i N_i N i e D i D_i D i , que representam o númerador e denominador da i − i- i − ésima fração. | Imprima produto máximo em intervalo da lista de frações módulo 1 0 9 + 7 10^9+7 1 0 9 + 7 . Restrições | [
{
"input": "6 2 1 1 2 2 2 2 1 2 1",
"output": "8"
},
{
"input": "10 4 2048 16384 8192 16384 32 512 2 16384 32 4096 1 4096 16 16384 128 2048 16384 8 128",
"output": "383381198"
}
] | 2 | Difícil | 256 mb | 1 second(s) |
neps:1251 | Neps Academy | 1,251 | VAR | https://neps.academy/br/exercise/2318 | VAR Com a crescente popularidade dos campeonatos de “Beach Tenis”, uma empresa está desenvolvendo um aplicativo para celular para ser usado por juízes. O objetivo é que, depois de configurar o aplicativo, um “juiz de vídeo” possa usar a câmera do celular para determinar se o impacto da bola com o piso foi dentro ou for... | A primeira linha da entrada contém um inteiro X, a coordenada x da marcação. A segunda linha contém um inteiro Y , a coordenada y da marcação. | Seu programa deve produzir uma única linha, contendo um único caractere, que deve ser a letra maiúscula ‘S’ se a marcação está dentro do campo; se a marcação está fora do campo de jogo a linha deve conter a letra maiúscula ‘N’. Restrições − | [
{
"input": "6 -2",
"output": "N"
},
{
"input": "8 2",
"output": "S"
}
] | 2 | Super Fácil | 256 mb | 1 second(s) |
neps:1233 | Neps Academy | 1,233 | Duplas de tênis | https://neps.academy/br/exercise/1653 | Duplas de tênis Quatro amigos combinaram de jogar tênis em duplas. Cada um dos amigos tem um nível de jogo, que é representado por um número inteiro: quanto maior o número, melhor o nível do jogador. Os quatro amigos querem formar as duplas para iniciar o jogo. De forma a tornar o jogo mais interessante, eles querem qu... | A entrada contém quatro linhas, cada linha contendo um inteiro A , B , C e D , indicando o nível de jogo dos quatro amigos. | Seu programa deve produzir uma única linha, contendo um único inteiro, a menor diferença entre os níveis dos dois times formados. Restrições A | [
{
"input": "4 7 10 20",
"output": "7"
},
{
"input": "0 0 1 1000",
"output": "999"
},
{
"input": "1 2 3 4",
"output": "0"
}
] | 3 | Fácil | 256 mb | 1 second(s) |
neps:1397 | Neps Academy | 1,397 | Gomoku | https://neps.academy/br/exercise/37 | Gomoku Gomoku é um jogo japonês milenar, jogado em um tabuleiro de 15x15 células e pedras pretas e brancas. Um jogador joga com as pedras brancas, o outro joga com as pedras pretas. O objetivo do jogo, como o nome sugere–go-moku em japonês quer dizer cinco pedras – é colocar cinco pedras da mesma cor consecutivamente o... | A entrada é composta por quinze linhas, cada uma contendo quinze inteiros. Cada inteiro representa o conteúdo de uma célula do tabuleiro. O número 1 indica uma pedra preta, o número 2 indica uma pedra branca e o número 0 indica que não há pedra na célula. | Seu programa deve produzir uma única linha, contendo o inteiro 1 se o jogador com as pedras pretas venceu, o inteiro 2 se o jogador com as pedras brancas venceu, ou o número 0 se ainda não há vencedor na configuração da entrada. Restrições Cada célula tem o valor 0, 1 ou 2. | [
{
"input": "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 2 0 0 2 2 2 1 0 0 0 0 0 0 0 0 1 2 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 2 2 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0"... | 2 | Difícil | 256 mb | 1 second(s) |
neps:1917 | Neps Academy | 1,917 | Labirinto | https://neps.academy/br/exercise/607 | Labirinto Um amigo seu está muito empolgado com um novo joguinho que baixou em seu celular. O jogo consiste em uma espécie de labirinto que pode ser representado por um quadriculado de células quadradas com N linhas e M colunas. Cada célula do labirinto contém uma plataforma que está a uma determinada altura do chão, q... | A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha da entrada contém dois inteiros N e M separados por um espaço em branco, que representam, respectivamente, a quantidade de linhas e colunas do labirinto. As N linhas seguintes contê... | Seu programa deve imprimir, na saída padrão, uma única linha, contendo a menor quantidade de turnos possível para sair do labirinto. Restrições | [
{
"input": "4 3 0 0 0 0 0 0",
"output": "5"
},
{
"input": "3 3 1 2 3 4 5 6 7 8 9",
"output": "12"
},
{
"input": "3 5 1 3 1 1 1 1 3 1 3 1 1 1 1 3 1",
"output": "10"
}
] | 3 | Difícil | 256 mb | 1 second(s) |
neps:11224 | Neps Academy | 11,224 | Plantação de Açaí | https://neps.academy/br/exercise/1795 | Plantação de Açaí Rangel é apaixonado por açaí e decidiu comprar uma fazenda produtora de açaí no Norte do país. Alguns meses após a compra dessa fazenda, suas plantações de açaí começaram a ser saqueadas causando prejuízo ao jovem fazendeiro. Pensando em liquidar os saques a sua fazenda, Rangel resolveu contratar uma ... | A entrada é composta de um único caso de teste. A primeira linha, contém um inteiro N ( 3 ≤ N ≤ 1 0 5 ) N \ (3 \leq N \leq 10^5) N ( 3 ≤ N ≤ 1 0 5 ) que indica a quantidade de pés de açaí restantes na fazenda. Segue então N linhas, cada linha com dois números decimais X e Y ( − 1 0 4 ≤ X , Y ≤ 1 0 4 ) Y \ (-10^4 \leq X... | Você deve imprimir as coordenadas do centro da cerca X c X_c X c e Y c Y_c Y c , o raio da cerca e a metragem de fio eletrificado necessário para cercar todos os pés de açaí (Use duas casas decimais). | [
{
"input": "5 -1.00 -1.00 1.00 1.00 3.00 3.00 -1.00 3.00 3.00 -1.00",
"output": "1.00 1.00 2.83 71.05"
}
] | 1 | Difícil | 256 mb | 1 second(s) |
neps:1497 | Neps Academy | 1,497 | Balé | https://neps.academy/br/exercise/536 | Balé Uma academia de balé irá organizar uma Oficina de Balé Intensivo (OBI) na Semana de Balé Contemporâneo (SBC). Nessa academia, existem N bailarinas que praticam regularmente. O dono da academia, por ser experiente, consegue medir o nível de habilidade de cada uma delas por um número inteiro; nessa medição, números ... | A primeira linha contém um número N , que representa a quantidade de dançarinas que estão registradas na academia. A segunda linha da entrada contém N inteiros, onde o primeiro inteiro é o nível da dançarina que está há mais tempo na academia, o segundo inteiro é o nível da próxima dançarina mais antiga na academia (ma... | A saída consistirá num único número X , que representa o total de duplas de dançarinas válidas para essa Oficina, dadas as regras descritas anteriormente. Restrições | [
{
"input": "5 1 5 2 4 3",
"output": "4"
},
{
"input": "9 9 8 7 6 5 4 3 1 2",
"output": "35"
}
] | 2 | Difícil | 256 mb | 1 second(s) |
neps:1990 | Neps Academy | 1,990 | Construindo a Prateleira | https://neps.academy/br/exercise/1194 | Construindo a Prateleira Anna acabou de chegar da sua loja de móveis favorita Ikey Yeah onde comprou uma nova estante projetada pela sua artista favorita Bill Lee . A estante tem uma forma retangular com uma largura de x e uma altura de y . Na caixa da estante está incluída uma tábua que Anna pode colocar horizontalmen... | A entrada consiste em: Uma linha com três números inteiros n , x e y , onde n é o número de livros que a Anna possui; x é a largura da estante; y é a altura da estante. n linhas, onde a i -ésima linha contém dois números inteiros w i w_i w i e h i h_i h i , onde w i w_i w i é a largura do i -ésimo livro; h i h_i ... | Se não for possível armazenar os livros de Anna na prateleira, imprima impossible . No caso de Anna decidir não instalar a tábua, imprima − 1 -1 − 1 . Caso contrário, imprima a altura a que a tábua deve ser instalada. Se houver várias alturas possíveis, pode-se imprimir qualquer uma delas. Restrições | [
{
"input": "4 4 4 3 1 1 1 1 3 2 2",
"output": "3"
},
{
"input": "2 4 3 2 3 1 1",
"output": "-1"
},
{
"input": "3 3 3 2 2 2 1 2 1",
"output": "impossible"
}
] | 3 | Difícil | 2048 mb | 3 second(s) |
neps:1326 | Neps Academy | 1,326 | Tapetes | https://neps.academy/br/exercise/496 | Tapetes Nlogonia é conhecida por sua indústria de tradicionais tapetes quadrados, que são produzidos apenas com dimensões inteiras, para todos os números inteiros positivos. Quer dizer, os tapetes são de dimensão 1 × 1 1 \times 1 1 × 1 , 2 × 2 2 \times 2 2 × 2 , 3 × 3 3 \times 3 3 × 3 , e assim por diante. João Tapetão... | A primeira e única linha da entrada contém dois inteiros, L e N , o comprimento do tubo e a quantidade de tapetes que deve transportada, respectivamente. | Seu programa deve produzir uma única linha, contendo apenas um inteiro, a maior soma possível das áreas dos tapetes. Restrições N | [
{
"input": "2 2",
"output": "2"
},
{
"input": "10 5",
"output": "40"
},
{
"input": "1000000 9",
"output": "999984000072"
}
] | 3 | Fácil | 256 mb | 1 second(s) |
neps:1208 | Neps Academy | 1,208 | Média do Vetor | https://neps.academy/br/exercise/328 | Média do Vetor Modifique o código abaixo, adicionando o código da função media_vetor , que recebe como parâmetros um inteiro n e um ponteiro para um vetor de inteiros v e deve retornar um double : a média dos n elementos do vetor v . Vale ressaltar que você pode trabalhar com o ponteiro para o vetor exatamente da mesma... | A entrada do seu programa terá duas linhas: a primeira delas terá um único inteiro n , e a segunda terá os n elementos v i v_i v i do vetor v . | Seu programa deve imprimir na saída padrão uma única linha contendo a média dos elementos do vetor, com duas casas decimais de precisão. Restrições | [
{
"input": "3 1 2 3",
"output": "2.00"
},
{
"input": "1 1",
"output": "1.00"
},
{
"input": "5 1 -2 3 -4 5",
"output": "0.60"
}
] | 3 | Fácil | 256 mb | 1 second(s) |
neps:11443 | Neps Academy | 11,443 | Mundial de Clubes | https://neps.academy/br/exercise/589 | Mundial de Clubes Ascânio, um grande fã de futebol está interessado em comprar as suas passagens de avião para o Catar, onde irá ocorrer a incrível final do mundial de clubes, o maior torneio de futebol do mundo e na qual o seu time do coração, o Flamengo, irá jogar. Além de comprar as suas passagens, Ascânio também te... | Um inteiro N, indicando a quantidade de passagens aéreas existentes ( 1 ≤ N ≤ 1000 ) (1 \leq N \leq 1000) ( 1 ≤ N ≤ 1 0 ) . N inteiros indicando o valor de cada opção de passagem ( 0 ≤ P i ≤ 10000000 ) (0 \leq P_i \leq 10000000) ( 0 ≤ P i ≤ 1 0 ) . Um inteiro M , indicando a quantidade de opções de hospedagens existe... | Dois inteiros P e H, inicando quais as melhores opções de compra da passagem e da hospedagem respectivamente, caso não exista dois valores que satisfazem a mesma condição, deverá ser exibido -1. | [
{
"input": "4 1 2 47 9 5 1 2 3 4 5",
"output": "47 4"
}
] | 1 | null | 256 mb | 5 second(s) |
neps:1438 | Neps Academy | 1,438 | Sequência Lógica 03 | https://neps.academy/br/exercise/181 | Sequência Lógica 03 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 = 12 <-> b = 18 a = 14 <-> b = 16 a = 18 <-> b = 12 a = 13 <-> b = 19 a = 15 <-> b = 17 a = 19 <-> b = 13 a = 14 <-> b = 20 a = 16 <-> b = 18 a = 20 <-> b = 14 … a = 32 <-> b = 38 a = 34 <-> b = 36 a = 38 <-> b = 32"
}
] | 1 | Médio | 256 mb | 1 second(s) |
neps:1939 | Neps Academy | 1,939 | Recompensas do Hotel | https://neps.academy/br/exercise/130 | Recompensas do Hotel Você está planejando passar suas férias de turismo na Europa, ficando cada noite em uma cidade diferente para N noites consecutivas. Você já escolheu o hotel que deseja ficar em cada cidade, para que você saiba o preço P i P_i P i do quarto que você vai ficar durante a noite i-th de suas férias, ... | A primeira linha de entrada contém dois números inteiros N e K , representando o número total de noites que as suas férias vão durar eo número de pontos que você precisa para obter uma noite livre. A segunda linha contém N inteiros P 1 , P 2 , … , P N P_1, P_2,\ldots , P_N P 1 , P 2 , … , P N , representando o pr... | A saída contém uma linha com um número inteiro que represente o custo mínimo de sua acomodação para todas as suas férias. Restrições | [
{
"input": "6 2 10 3 12 15 12 18",
"output": "37"
},
{
"input": "6 1 10 3 12 15 12 18",
"output": "25"
},
{
"input": "5 5 1 2 3 4 5",
"output": "15"
}
] | 3 | Difícil | 256 mb | 1 second(s) |
neps:1965 | Neps Academy | 1,965 | Soma de Inteiros | https://neps.academy/br/exercise/484 | Soma de Inteiros É dado um vetor A contendo N inteiros. Escolha até K intervalos contínuos disjuntos de forma que a soma dos inteiros dentro desses intervalos seja a maior possível. | A primeira linha da entrada contém os dois inteiros N e K , respectivamente. A segunda linha da entrada contém os N inteiros A 1 , A 2 , … , A N A_1, A_2, \ldots, A_N A 1 , A 2 , … , A N . | A saída deverá conter um único inteiro: a soma dos inteiros contidos nos intervalos escolhidos Restrições | [
{
"input": "6 4 1 -2 3 -4 5 -6",
"output": "9"
},
{
"input": "9 2 1 5 -3 4 -10 1 2 -4 1",
"output": "10"
},
{
"input": "5 2 -10 -20 -30 -40 -50",
"output": "0"
}
] | 3 | Difícil | 256 mb | 1 second(s) |
neps:1425 | Neps Academy | 1,425 | Ajude Odelmo Tigrão | https://neps.academy/br/exercise/1256 | Ajude Odelmo Tigrão Odelmo Tigrão prefeito da cidade de UdiCity está muito preocupado com a situação de sua cidade e está correndo contra o contágio do Coronovírus vacinando a população de sua cidade. Todo dia o Estado solta uma nova porcentagem que define se a população está segura ou não, se a porcentagem de vacinado... | A entrada consiste de três valores inteiros, N , M que indicam, respectivamente, o número total de moradores de UdiCity e a quantidade de moradores que já foram vacinados e P representando a porcentagem estipulada pelo Estado. | A saída consiste de uma linha dizendo se “UdiCity esta segura!!!” caso a porcentagem de moradores vacinados for maior ou igual a porcentagem estipulada pelo Estado, caso contrário, mostre na tela a mensagem “UdiCity esta em perigo, vamos de LockDalson!!!”. Não esqueça de imprimir o fim de linha após o resultado. Restri... | [
{
"input": "10000 1000 57",
"output": "UdiCity esta em perigo, vamos de LockDalson!!!"
},
{
"input": "3827 2874 70",
"output": "UdiCity esta segura!!!"
},
{
"input": "1000 500 50",
"output": "UdiCity esta segura!!!"
},
{
"input": "1000 499 50",
"output": "UdiCity esta em ... | 4 | Difícil | 256 mb | 1 second(s) |
neps:11320 | Neps Academy | 11,320 | Elevador Espacial | https://neps.academy/br/exercise/1963 | Elevador Espacial A China está construindo um elevador espacial, que permitirá o lançamento de sondas e satélites a um custo muito mais baixo, viabilizando não só projetos de pesquisa científica como o turismo espacial. No entanto, os chineses são muito supersticiosos, e por isso têm um cuidado muito especial com a num... | Cada caso de teste consiste de uma única linha, contendo um inteiro N que indica o andar cujo número deve ser determinado. O final da entrada é determinado pelo final de arquivo (EOF). | Para cada caso de teste, imprima uma linha contendo um único número inteiro indicando o número atribuído ao N -ésimo andar. Restrições | [
{
"input": "1 4 11 12 440",
"output": "1 5 12 15 666"
}
] | 1 | Difícil | 256 mb | 1 second(s) |
neps:1684 | Neps Academy | 1,684 | Suprema Competição | https://neps.academy/br/exercise/859 | Suprema Competição Dungeons and Dragons é um Role-Playing Game (RPG) conhecido mundialmente, inclusive na cidade de Hawkins, onde é jogado por Mike, Dustin, Will e Lucas. Will quer ensinar a 11 a jogar RPG, por isso resolveu apresentá-la à Suprema Competição (SC), uma competição entre as mais diversas classes para most... | A primeira linha contém um inteiro N , indicando a quantidade de rodadas que durou a competição. Cada uma das N linhas seguintes possui 2 inteiros M 1 M_1 M 1 e M 2 M_2 M 2 representando, respectivamente, o elemento escolhido por Will e o escolhido pela 11. | Seu programa deverá imprimir apenas o nome do vencedor: w i l will w i l ou 11 1 1 . Os nomes devem estar em m i n u ˊ s c u l o minúsculo m i n u ˊ s c u l o . Restrições N | [
{
"input": "3 1 3 4 2 0 2",
"output": "will"
},
{
"input": "1 3 1",
"output": "11"
}
] | 2 | null | 256 mb | 1 second(s) |
neps:11177 | Neps Academy | 11,177 | Laboratório de Biotecnologia | https://neps.academy/br/exercise/94 | Laboratório de Biotecnologia Uma cadeia ponderada é definida sobre um alfabeto Σ \Sigma Σ e uma função f que atribui um peso a cada caractere do alfabeto. Assim, podemos definir o peso de uma cadeia s como a soma dos pesos de todos os caracteres em s . Vários problemas da bioinformática podem ser formalizados como prob... | Apenas uma linha, que contém a cadeia s formada por letras minúsculas, cujo comprimento ∣ s ∣ |s| ∣ s ∣ satisfaz 1 ≤ ∣ s ∣ ≤ 1 0 5 1 \leq |s| \leq 10^5 1 ≤ ∣ s ∣ ≤ 1 0 5 . | Seu programa deve produzir uma única linha com um inteiro representando a quantidade de pesos distintos das subcadeias não vazias de caracteres consecutivos de s . | [
{
"input": "abbab",
"output": "8"
},
{
"input": "adbbabdcdbcbacdabbaccdac",
"output": "56"
}
] | 2 | Difícil | 256 mb | 8 second(s) |
neps:11333 | Neps Academy | 11,333 | Saco de Peças | https://neps.academy/br/exercise/2574 | Saco de Peças O jogo clássico Tetris envolve organizar tetrominós que caem em um tabuleiro. Existem sete tetrominós diferentes, cada um nomeado com uma letra que se assemelha à sua forma: J, L, S, Z, I, O e T. No Tetris original, o jogador receberia um tetrominó de cada vez, e cada tetrominó seria escolhido entre as se... | A primeira linha conterá um único número inteiro n que indica o número de conjuntos de dados que seguirão. Cada uma das próximas n linhas conterá uma sequência de letras representando as diferentes formas possíveis. Estas letras são I , T , O , L , J , S e Z . A sequência sempre começará desde o início do saco. | Se a sequência de peças não tiver duplicatas dentro de cada saco (conjunto de 7 peças), imprima "Saco válido". Caso contrário, imprima "Saco inválido". | [
{
"input": "3 SILTZJOJOLITSZZ SILTZJOJOJITSZZ Z",
"output": "Valid bag Invalid bag Valid bag"
}
] | 1 | Difícil | 512 mb | 2 second(s) |
neps:11272 | Neps Academy | 11,272 | Viagem de Carro | https://neps.academy/br/exercise/1854 | Viagem de Carro Você está viajando de carro pelas estradas do país. O carro tem pneus com K centimetros de espessura. O país tem N cidades, numeradas de 1 a N . Há M estradas entre elas, onde a i -ésima estrada passa diretamente entre duas cidades diferentes u i u_i u i e v i ( 1 ≤ u i , v i ≤ N ) v_i (1\leq u_i, v_i... | A primeira linha de entrada contém três números inteiros K , N e M , cada um separado por um espaço. As próximas linhas de M contêm 4 inteiros u i u_i u i v i v_i v i t i t_i t i e c i c_i c i , cada um separada por um espaço. A i -ésima linha neste conjunto de M linhas descreve a i -ésima estrada (que vai da c... | Produzir um único inteiro: o inteiro representando o tempo mínimo necessário para viajar de O a D sem desgastar o pneu do carro, ou -1 para indicar que não há como viajar de O a D sem desgastar o casco do navio. Restrições | [
{
"input": "10 4 7 1 2 4 4 1 3 7 2 3 1 8 1 3 2 2 2 4 2 4 6 3 4 1 1 1 4 6 12 1 4",
"output": "7"
},
{
"input": "3 3 3 1 2 5 1 3 2 8 2 1 3 1 3 1 3",
"output": "-1"
}
] | 2 | Difícil | 256 mb | 1 second(s) |
neps:11004 | Neps Academy | 11,004 | O retorno do King | https://neps.academy/br/exercise/2108 | O retorno do King O prolífico autor Stephen King estava a colocando notas dos seus estudantes de literatura numa calculadora de média geral on-line. Quando terminou, reparou que a sua chave de retorno estava partida, pois ao invés de colocar as notas dos estudantes estudante numa linha separada cada um, introduziu-as n... | A entrada consiste numa única linha que contém uma string S não vazia de no máximo 100 dígitos de base 10. Há uma forma única de dividir S numa lista de substrings, de tal forma que cada substring represente um inteiro entre 1 e 10 na base 10 sem zeros à esquerda. | Imrpima uma linha com um número racional representando a média das notas dos alunos cujas notas o Sr. King registou em S . O resultado deve ser emitido como um número racional com exatamente dois dígitos após o ponto decimal, arredondado se necessário. | [
{
"input": "310110",
"output": "6.00"
},
{
"input": "10910",
"output": "9.67"
},
{
"input": "222222223",
"output": "2.11"
}
] | 3 | Médio | 256 mb | 1 second(s) |
neps:1839 | Neps Academy | 1,839 | Distância entre um ponto e uma reta | https://neps.academy/br/exercise/1615 | Distância entre um ponto e uma reta Dado um ponto P e uma reta r , a sua tarefa é achar a distância entre P e r . Relembrando : a distância entre um ponto P e uma linha r é a menor distância entre P e algum ponto X na linha r r | A entrada irá conter três linhas com cada uma descrevendo as coordenadas dos pontos A , B e P . A reta r é a reta que passa pelos pontos A e B . | A saída deve conter somente um número real representando a distância entre P e r . Sua resposta é considerada correta se o erro absoluto ou relativo não exceder 1 0 − 3 10^{-3} 1 0 − 3 . Formalmente, seja a sua resposta e b a resposta do juiz. Sua resposta será aceita se e somente se ∣ a − b ∣ m a x ( 1 , ∣ b ∣ ) ⩽ 1 0... | [
{
"input": "3 6 1 1 2 2",
"output": "0.557086"
},
{
"input": "2 2 0 0 1 1",
"output": "0.000000"
}
] | 2 | Médio | 256 mb | 1 second(s) |
neps:11096 | Neps Academy | 11,096 | Corrida do ouro | https://neps.academy/br/exercise/1494 | Corrida do ouro Novamente, Neverland passou por uma situação econômica muito ruim nos últimos meses. O valor de Oshloob, a moeda nacional de Neverland, muda em relação a uma unidade de ouro muito rapidamente. Pessoas em Neverland, todas se perguntando sobre suas economias, estão tentando trocar suas economias por moeda... | A primeira linha da entrada contém dois inteiros C ( 0 ≤ C ≤ 3000 ) C \ (0 \leq C \leq 3000) C ( 0 ≤ C ≤ 3 0 ) , a economia inicial do Dr. Predictman em Oshloobs e N ( 0 ≤ N ≤ 30 ) N \ (0 \leq N \leq 30) N ( 0 ≤ N ≤ 3 0 ) , o período de sua previsão. Cada uma das próximas N linhas contém um inteiro p i ( 1000 ≤ p i ≤ 2... | A saída contém apenas um número inteiro, que indica a economia máxima que ele pode obter no final do n-ésimo dia, supondo que o Dr. Predictman troque todas as suas moedas de ouro restantes (se houver) para Oshloobs no final do e-nésimo dia. | [
{
"input": "1000 3 1000 1100 1200",
"output": "1200"
},
{
"input": "2000 4 1000 2000 1500 1800",
"output": "4600"
}
] | 2 | Médio | 256 mb | 1 second(s) |
neps:1492 | Neps Academy | 1,492 | Pangrama | https://neps.academy/br/exercise/1654 | Pangrama Um pangrama é uma frase que contém todas as letras de um determinado alfabeto. Em português, um pangrama pode incluir também letras acentuadas, mas neste problema vamos desconsiderar os acentos (mesmo que isso torne a frase mal escrita!) Veja alguns exemplos de pangramas em português (sem acentos): grave e cab... | A primeira e única linha da entrada contém uma cadeia de caracteres C . | Seu programa deve produzir uma única linha, contendo um único caractere, que deve ser S se a frase for um pangram ou N caso contrário. Restrições A cadeia de caracteres | [
{
"input": "gazeta publica hoje: breve anuncio de faxina na quermesse",
"output": "S"
},
{
"input": "esta frase nao usa todas as letras, estao faltando algumas",
"output": "N"
},
{
"input": "abcdefghijlmnopqrstuvxz",
"output": "S"
}
] | 3 | Fácil | 256 mb | 1 second(s) |
neps:1599 | Neps Academy | 1,599 | Aglomeração no Busão | https://neps.academy/br/exercise/1262 | Aglomeração no Busão Busonildo é motorista de ônibus e é muito preocupado com seus passageiros. Seu ônibus tem um formato quadrado e vários assentos disponíveis. Com a atual situação do Coronovírus, Busonildo está muito preocupado com os passageiros de seu ônibus, então gostaria de marcar com o número 2 (que no caso é ... | A entrada consiste de um valor inteiro, N , que indica o tamanho de seu ônibus quadrado. Logo após, será feito a leitura de uma matriz N X N NXN N X N representando a configuração inicial do ônibus com os assentos disponíveis (0) e exclusivos para pessoas possivelmente infectadas (1). | A saída consiste de uma matriz N X N NXN N X N representando a configuração segura do ônibus com os assentos disponíveis (0), exclusivos para pessoas possivelmente infectadas (1) e os assentos interditados por medidas de segurança (2). Não esqueça de imprimir o fim de linha após o resultado. Terão espaço após todos os ... | [
{
"input": "3 0 0 0 0 1 0 0 0 0",
"output": "2 2 2 2 1 2 2 2 2"
},
{
"input": "5 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0",
"output": "0 0 0 0 0 0 2 2 2 0 0 2 1 2 2 0 2 2 1 2 0 0 2 2 2"
},
{
"input": "1 1",
"output": "1"
},
{
"input": "5 0 0 0 0 0 0 0 0 0 0",
"output": "0 ... | 4 | null | 256 mb | 1 second(s) |
neps:1269 | Neps Academy | 1,269 | Robô de Fazenda | https://neps.academy/br/exercise/128 | Robô de Fazenda Para desencorajar pássaros como corvos e pardais de se alimentar de suas plantações, um fazendeiro precisava colocar alguns espantalhos em seu campo de milho. Seu sobrinho realmente gosta de robôs, e sugeriu que ele deveria usar um espantalho robô em vez disso: "Um único espantalho robô pode proteger me... | A primeira linha contém três números inteiros N , C e S que representam respectivamente o número de bornes, o número de comandos e a estação de carga mais próxima da área devastada. A segunda linha contém C inteiros X 1 , X 2 , … , X C X_1, X_2,\ldots , X_C X 1 , X 2 , … , X C , representando a seqüência de coman... | A saída contém uma linha com um número inteiro que representa o número de vezes que o robô estava na estação número S durante o dia. Restrições | [
{
"input": "8 8 3 1 -1 1 1 1 -1 1 1",
"output": "2"
},
{
"input": "5 4 1 1 1 1 1",
"output": "1"
},
{
"input": "2 1 1 1",
"output": "1"
},
{
"input": "2 2 1 -1 1",
"output": "2"
},
{
"input": "2 2 1 -1 -1",
"output": "2"
}
] | 5 | Médio | 256 mb | 1 second(s) |
neps:1726 | Neps Academy | 1,726 | Plantação | https://neps.academy/br/exercise/507 | Plantação A N-logônia é uma região com um clima muito intenso e variável, onde em questão de poucos dias é possível observar uma forte seca, seguida de uma intensa estação de chuvas. O Seu João tem uma plantação de obilina, uma fruta típica e muito apreciada na região, o que a torna muito valiosa. A obilina, entretanto... | A primeira linha da entrada contém dois inteiros, N e K , respectivamente o número de dias que dura a safra, e o número de árvores que o Seu João possui. A segunda linha contém K inteiros ai indicando quantas frutas foram produzidas no dia anterior ao início da safra por cada uma das K árvores. A linha seguinte contém ... | Seu programa deve imprimir uma única linha, contendo um único inteiro, indicando o número de frutas que serão produzidas pela plantação do Seu João. Restrições | [
{
"input": "3 2 1 2 C E C",
"output": "13"
},
{
"input": "5 3 2 3 1 E E E C C",
"output": "4"
}
] | 2 | Difícil | 256 mb | 1 second(s) |
neps:1204 | Neps Academy | 1,204 | Média das Provas | https://neps.academy/br/exercise/731 | Média das Provas O programa abaixo calcula a média das provas do semestre do curso de Ciências de Computação da Universidade Neps Academy (UNA). O professor do curso gosta de calcular as notas usando uma média inteira ponderada . #include <stdio.h> //Adicione o código da sua Struct aqui! int main(){ prova A, B, C; scan... | A entrada consiste de três linhas. Cada linha contém a nota e o peso de cada prova, nessa ordem. | A saída deve ser a nota final do aluno usando a média ponderada. Restrições Cada nota pode variar entre 0 e 10. | [
{
"input": "10 3 8 2 5 4",
"output": "7"
},
{
"input": "5 1 5 1 5 1",
"output": "5"
}
] | 2 | Fácil | 256 mb | 1 second(s) |
neps:1820 | Neps Academy | 1,820 | Seleção | https://neps.academy/br/exercise/375 | Seleção Dados dois vetores X e Y , de N elementos, é construída uma matriz S de N linhas e N colunas, tal que S i j = X i + Y j S_{ij} = X_i + Y_j S i j = X i + Y j . Considerando os elementos dessa matriz (com repetição) e um número k entre 1 e N 2 N^2 N 2 , responda qual seria o k-ésimo elemento se os elementos... | A entrada é composta por três linhas. A primeira linha contém dois inteiros, N e k , como descritos no enunciado. A segunda linha contém quatro inteiros, A X A_X A X , B X B_X B X , C X C_X C X e M X M_X M X . Os elementos do conjunto X são definidos da seguinte forma: X 1 = A X X_1 = A_X X 1 = A X e X i = ... | Seu programa deve produzir uma única linha com um único inteiro, o k-ésimo menor da matriz S . Restrições | [
{
"input": "3 7 1 1 1 10 2 1 1 10",
"output": "6"
},
{
"input": "4 9 1 1 3 10 2 1 3 10",
"output": "7"
},
{
"input": "1000 900000 1 0 3 997 5 0 3 997",
"output": "1574"
}
] | 3 | Difícil | 256 mb | 1 second(s) |
neps:1764 | Neps Academy | 1,764 | Três Caixas | https://neps.academy/br/exercise/2400 | Três Caixas Dada uma string S de comprimento N , em que cada letra em S é "L" ou "R". Há uma bola e três caixas nas quais a bola pode ser colocada. As caixas são numeradas como 1 , 2 e 3 . Inicialmente, a bola está na caixa 1 . A partir desse estado, o castor Vitaro realiza N operações nas caixas e na bola. A i -ésima ... | A entrada é fornecida pela entrada padrão no seguinte formato. N S S S | Imprima o número de vezes que a bola foi colocada na caixa 3 por meio de N operações. Restrições | [
{
"input": "4 LRRR",
"output": "2"
},
{
"input": "3 LRL",
"output": "0"
},
{
"input": "7 LRLRRRL",
"output": "2"
}
] | 3 | Fácil | 1024 mb | 2 second(s) |
neps:11235 | Neps Academy | 11,235 | Desativação das Estradas | https://neps.academy/br/exercise/1219 | Desativação das Estradas O governo da Nlogonia está ansioso por reduzir a dívida pública. Uma das medidas prestes a ter lugar é a desativação de algumas estradas, uma vez que a maioria delas implica um elevado custo de manutenção. Cada estrada liga duas cidades diferentes e pode ser percorrida em ambas as direções. Usa... | A primeira linha contém dois números inteiros N ( 2 ≤ N ≤ 1 0 4 ) N \ (2 \ \leq \ N \ \leq \ 10^4) N ( 2 ≤ N ≤ 1 0 4 ) and M ( 1 ≤ M ≤ 1 0 5 ) M \ (1 \ \leq \ M \ \leq \ 10^5) M ( 1 ≤ M ≤ 1 0 5 ) , indicando respectivamente o número de cidades e o número de estradas. As cidades são identificadas por números inteiros di... | Produzir uma única linha com um número inteiro indicando a soma mínima possível dos custos de manutenção para um conjunto de estradas a serem mantidas ativas. Este conjunto de estradas deve assegurar que, para cada cidade, a distância mínima necessária para percorrer desde essa cidade até à capital de Nlogonia permanec... | [
{
"input": "3 4 2 3 2 4 2 3 2 2 1 2 5 1 1 3 1 4",
"output": "6"
},
{
"input": "2 2 1 2 10 5 2 1 6 11",
"output": "11"
}
] | 2 | Difícil | 256 mb | 1 second(s) |
neps:1756 | Neps Academy | 1,756 | Startup | https://neps.academy/br/exercise/2625 | Startup Devido ao seu sucesso na primeira fase da OBI, a startup IOI (Insatisfação Observada International) te ofereceu uma entrevista de estágio. Como parte do processo seletivo, você deve ajudar a empresa a avaliar a satisfação dos funcionários com seus empregos. Na hierarquia da startup, cada funcionário (exceto o f... | A primeira linha de entrada contém um inteiro N , indicando o número de funcionários da empresa. Os funcionários são identificados de 1 a N de acordo com a ordem em que entraram na startup. O fundador é identificado pelo número 1 . Cada uma das N linhas seguintes descreve um funcionário: a linha i + 1 i + 1 i + 1 conté... | Seu programa deve produzir A + 1 A + 1 A + 1 linhas, cada uma contendo um único inteiro. A primeira linha deve conter o número de funcionários insatisfeitos antes dos ajustes. As próximas A linhas devem conter os números de funcionários insatisfeitos após cada ajuste. Sub-tarefa Subtarefa 1 (25 pontos): N ≤ 100 N \leq ... | [
{
"input": "7 1 300 1 350 1 200 3 150 3 250 2 350 3 100 0",
"output": "2"
},
{
"input": "5 1 500 1 400 2 300 3 450 4 300 2 4 300 3 500",
"output": "1 0 1"
},
{
"input": "6 1 100 1 200 1 300 2 400 3 500 3 600 3 1 500 3 550 4 200",
"output": "3 2 3 2"
}
] | 3 | Difícil | 256 mb | 1 second(s) |
neps:1906 | Neps Academy | 1,906 | Pulando poça de água | https://neps.academy/br/exercise/806 | Pulando poça de água João está brincando de pular em poças de água. Contudo existe uma que é muito funda e João não sabe nadar. A mãe dele avisou qual era a poça de água funda. As poças que João está pulando estão enfileiradas e ele quer saber quantas ele consegue pular até chegar na poça funda para então ele voltar se... | A primeira linha temos um número N , representando a quantidade de poças de água, 1 < N ≤ 1 0 4 1 < N \leq 10^{4} 1 < N ≤ 1 0 4 . Na linha seguinte temos N − 1 N-1 N − 1 n u m e r o s numeros n u m e r o s 1 representando poças rasas e u m um u m n u m e r o numero n u m e r o 0 representando a poça funda. | Na primeira linha temos um inteiro representando quantas poças João consegue pular. Na segunda linha teremos um número em ponto flutuante com d u a s duas d u a s c a s a s casas c a s a s d e p o i s depois d e p o i s d a da d a v i r g u l a virgula v i r g u l a representando a probabilidade da poça de água funda s... | [
{
"input": "10 1 1 1 1 0 1 1 1 1 1",
"output": "4 0.10"
},
{
"input": "4 1 1 1 0",
"output": "3 0.25"
},
{
"input": "2 1 0",
"output": "1 0.50"
}
] | 3 | null | 256 mb | 1 second(s) |
neps:1247 | Neps Academy | 1,247 | Cinema | https://neps.academy/br/exercise/2066 | Cinema Duas amigas estão na fila para comprar ingressos para uma sessão de cinema. O preço dos ingressos, em Reais, é dado na tabela abaixo: Figura 1 Dadas as idades das amigas, escreva um programa para calcular o total a ser pago pelos dois ingressos. | A entrada contém duas linhas, cada linha contendo um inteiro, a idade de uma das amigas. | Seu programa deve produzir uma única linha, contendo um único inteiro, que deve ser o valor total em Reais a ser pago pelos dois ingressos. Restrições | [
{
"input": "100 10",
"output": "35"
},
{
"input": "17 18",
"output": "45"
}
] | 2 | Fácil | 256 mb | 1 second(s) |
neps:1699 | Neps Academy | 1,699 | Caminhos Mínimos | https://neps.academy/br/exercise/376 | Caminhos Mínimos Neste problema, dado um grafo não-direcionado, conexo, com pesos positivos nas arestas, seu programa deve computar o menor inteiro K (ou indicar que é impossível), maior ou igual a zero, tal que, se somássemos K ao peso de cada aresta, teríamos d(1, u ) = p(1, u ) para todo vértice u do grafo, onde d(1... | A primeira linha da entrada contém dois inteiros N e M , representando o número de vértices e arestas do grafo, respectivamente. As M linhas seguintes contêm, cada uma, três inteiros A , B e C , indicando que existe uma aresta entre os vértices A e B , com peso C . Os vértices são identificados por inteiros distintos e... | Seu programa deve imprimir uma linha contendo um inteiro representando o menor K , maior ou igual a zero, tal que, se somássemos K ao peso de cada aresta, teríamos d(1, u ) = p(1, u ) para todo vértice u do grafo. Se não existir K nessas condições, imprima -1. Restrições | [
{
"input": "5 5 1 2 10 1 3 2 2 4 7 3 5 5 5 4 1",
"output": "9"
},
{
"input": "4 3 1 2 5 1 3 2 3 4 8",
"output": "0"
},
{
"input": "5 6 1 2 7 1 3 1 1 5 2 5 4 1 2 4 1 3 4 1",
"output": "2"
}
] | 3 | Super Difícil | 256 mb | 1 second(s) |
neps:154 | Neps Academy | 154 | Quantas Letras | https://neps.academy/br/exercise/398 | Quantas Letras? Faça um programa para ler uma string S (sem espaços) e uma letra C . Seu programa deve imprimir a quantidade de vezes que a letra C aparece em S . | A entrada consiste de duas linhas. A primeira linha contém uma string S . A segunda linha contém uma letra C . | A saída consiste de uma única linha contendo um inteiro correspondente a quantidade de vezes que a letra C aparece na string S Restrições | [
{
"input": "neps x",
"output": "0"
},
{
"input": "academy a",
"output": "2"
},
{
"input": "nepsacademy y",
"output": "1"
}
] | 3 | Super Fácil | 256 mb | 1 second(s) |
neps:1453 | Neps Academy | 1,453 | Análise de Texto | https://neps.academy/br/exercise/2697 | Análise de Texto Você está desenvolvendo um sistema para análise de textos e precisa implementar uma funcionalidade que determine quantas palavras em um texto contêm pelo menos uma das letras de uma lista específica. Essa funcionalidade será usada para diversas análises linguísticas e processamento de texto. | A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão. A primeira linha da entrada contém uma string representando o texto. A segunda linha da entrada contém uma string de letras específicas. | O programa deve produzir uma única linha, contendo um único inteiro, indicando o número de palavras no texto que contêm pelo menos uma das letras específicas. Restrições O texto consiste apenas de letras minúsculas e espaços em branco. | [
{
"input": "o pequeno principe partiu para novas aventuras no universo aeiou",
"output": "9"
},
{
"input": "biblioteca cheia de livros ae",
"output": "3"
},
{
"input": "python eh uma linguagem de programacao lmnp",
"output": "4"
}
] | 3 | Difícil | 256 mb | 1 second(s) |
neps:1533 | Neps Academy | 1,533 | Xadrez Aleatório | https://neps.academy/br/exercise/575 | Xadrez Aleatório Xadrez Aleatório de Fischer, ou Xadrez 960, é uma variante do jogo de Xadrez que usa exatamente as mesmas regras com uma única exceção, a posição inicial das peças é sorteada antes do jogo. As peças da primeira linha do tabuleiro podem estar em qualquer posição desde que respeitem duas restrições: o re... | A entrada consiste de apenas uma linha contendo dois inteiros, N e T , representando, respectivamente, a dimensão do tabuleiro e o número de torres. | Seu programa deve imprimir uma linha contendo um inteiro indicando o número de posições iniciais válidas. Restrições | [
{
"input": "2 0",
"output": "2"
},
{
"input": "8 1",
"output": "56"
},
{
"input": "213 2",
"output": "1587986"
}
] | 3 | Difícil | 256 mb | 1 second(s) |
neps:1196 | Neps Academy | 1,196 | Sedex | https://neps.academy/br/exercise/540 | Sedex A Copa do Mundo de 2010 será realizada na Africa do Sul. Bolas de futebol são muito fáceis de transportar, já que elas saem das fábricas vazias e só são enchidas somente pelas lojas ou pelos consumidores finais. Infelizmente o mesmo não pode ser dito das bolas de boliche. Como elas são completamente sólidas, elas... | A primeira linha da entrada contém um inteiro N ( 1 ≤ N ≤ 10000 1 \leq N \leq 10000 1 ≤ N ≤ 1 0 ) que indica o diâmetro da bola de boliche. A segunda linha da entrada contém 3 números inteiros separados por um espaço cada: a altura A ( 1 ≤ A ≤ 10000 1 \leq A \leq 10000 1 ≤ A ≤ 1 0 ), seguida da largura L ( 1 ≤ L ≤ 1000... | Seu programa deve imprimir uma única linha, contendo a letra ‘S’ caso a bola de boliche caiba dentro da caixa ou ‘N’ caso contrário. | [
{
"input": "3 2 3 5",
"output": "N"
},
{
"input": "5 5 5 5",
"output": "S"
},
{
"input": "9 15 9 10",
"output": "S"
}
] | 3 | Fácil | 256 mb | 1 second(s) |
neps:11227 | Neps Academy | 11,227 | De Volta para o Futuro | https://neps.academy/br/exercise/124 | De Volta para o Futuro O Dr. Emmet está trabalhando em um dispositivo mais seguro para viajar no tempo. Ele reuniu N peças diferentes e raras de metal. Cada peça pode ser compatível com algumas outras peças diferentes. Ele tem uma lista completa com M pares distintos de metais compatíveis. Qualquer par de metais que nã... | A primeira linha contém quatro números inteiros N , M , A e B , representando respectivamente quantas peças de metal existem, quantas compatibilidades existem E as variáveis A e B descritas na declaração do problema. Os metais diferentes são convenientemente numerados de 1 a N . Cada uma das seguintes linhas M contém d... | A saída contém uma linha com um inteiro representando o tamanho do maior conjunto de metais que satisfaçam os requisitos especificados na instrução do problema. Restrições | [
{
"input": "3 1 1 0 1 2",
"output": "2"
},
{
"input": "3 1 1 1 1 2",
"output": "0"
},
{
"input": "7 12 2 2 1 2 2 3 3 1 4 5 5 6 6 4 3 4 7 1 2 7 3 7 4 7 5 7",
"output": "6"
}
] | 3 | Difícil | 256 mb | 1 second(s) |
neps:192 | Neps Academy | 192 | Dominó (OBI 2019) | https://neps.academy/br/exercise/462 | Dominó (OBI 2019) O jogo de dominó tradicional, conhecido como duplo-6, possui 28 peças. Cada peça está dividida em dois quadrados e dentro de cada quadrado há entre 0 e 6 círculos. O jogo é chamado de duplo-6 justamente porque esse é o maior número de círculos que aparece num quadrado de uma peça. A figura ao lado mos... | A primeira linha da entrada contém um número natural N representando o tipo do jogo de dominó: duplo- N . | Seu programa deve imprimir uma linha contendo um número natural representando quantas peças existem num jogo de dominó do tipo duplo- N . Restrições | [
{
"input": "6",
"output": "28"
},
{
"input": "12",
"output": "91"
}
] | 2 | Super Fácil | 256 mb | 1 second(s) |
neps:1268 | Neps Academy | 1,268 | Repetição I | https://neps.academy/br/exercise/79 | Repetição I Agora vamos praticar um pouco. Faça um programa para ler dois valores inteiros A e B. Imprima A linhas. Cada linha com o valor B. | A entrada consiste em duas linhas. Cada linha contém um valor inteiro. | Imprima A linhas. Cada linha com o valor B. Restrições Os valores não serão menores que 1 ou maiores que 100. | [
{
"input": "3 2",
"output": "2 2 2"
},
{
"input": "5 1",
"output": "1 1 1"
}
] | 2 | Difícil | 256 mb | 1 second(s) |
neps:11335 | Neps Academy | 11,335 | Interatividade | https://neps.academy/br/exercise/1177 | Interatividade Um dia, Alice desafiou Beto com o problema interativo de programação descrito a seguir. Você tem uma árvore (um grafo acíclico conexo). Cada nó da árvore tem exatamente um pai, com exceção do nó raiz, que não tem pai. Um nó que não é pai de nenhum outro nó é uma folha. Você conhece a estrutura da árvore,... | A árvore tem N nós no total. Cada nó é identificado por um inteiro entre 1 e N , onde o nó 1 é a raiz. A entrada consiste de duas linhas. A primeira linha contém apenas o inteiro N . A segunda linha contém N − 1 N - 1 N − 1 inteiros P 1 , P 2 , . , P N − 1 P_1, P_2, . . .,P_{N-1} P 1 , P 2 , . , P N − 1 , separad... | A saída consiste de uma única linha, que deve conter o número de soluções mínimas diferentes para o problema enfrentado por Beto. Como esse número pode ser muito grande, sua resposta deverá ser calculada módulo 1000000007 1 0 7 ( 1 0 9 + 7 ) (10^9 + 7) ( 1 0 9 + 7 ) . | [
{
"input": "3 1 1",
"output": "3"
},
{
"input": "4 1 2 3",
"output": "4"
},
{
"input": "5 1 2 2 2",
"output": "7"
}
] | 3 | Super Difícil | 256 mb | 1 second(s) |
neps:1563 | Neps Academy | 1,563 | Classificação de triângulos | https://neps.academy/br/exercise/663 | Classificação de triângulos O Joãozinho está a aprender como se constroem triângulos. A professora de matemática disse-lhe que apenas é possível construí-los, caso as seguintes condições forem verdadeiras: A < B + C A<B+C A < B + C B < A + C B<A+C B < A + C < A + B C<A+B C < A + B Sendo A , B e C os três segmentos de r... | A entrada consiste em três linhas, contendo os segmentos A, B e C. | A saída consiste numa linha, contendo o caracter "N", caso não seja possível construir o triângulo e deve conter duas linhas, caso seja possível construir o triângulo. Na primeira linha deve conter o carácter "S" e na segunda linha o tipo de triângulo 1-Isósceles, 2-Escaleno ou 3-Equilátero Restrições Os inteiros forne... | [
{
"input": "2 2 2",
"output": "S 3"
},
{
"input": "2 2 3",
"output": "S 1"
},
{
"input": "2 3 4",
"output": "S 2"
},
{
"input": "2 3 8",
"output": "N"
}
] | 4 | null | 128 mb | 1 second(s) |
neps:11014 | Neps Academy | 11,014 | Grid de Largada | https://neps.academy/br/exercise/1965 | Grid de Largada Na Nlogônia, vai ser realizada a sensacional final mundial da fórmula 17. Os competidores se alinham na largada e disputam a corrida. Você vai ter acesso aos grids de largada e de chegada. A questão é determinar o número mínimo de ultrapassagens que foram efetuadas durante a competição. | Cada caso de teste utiliza três linhas. A primeira linha de um caso de teste contém um inteiro N indicando o número de competidores. Cada competidor é identificado com um número de 1 a N . A segunda linha de cada caso tem os N competidores, em ordem do grid de largada. A terceira linha de cada caso tem os mesmos compet... | Para cada caso de teste imprima uma linha contendo um único número inteiro, que indica o número mínimo de ultrapassagens necessárias para se chegar do grid de largada ao grid de chegada. Restrições | [
{
"input": "5 1 2 3 4 5 3 1 2 5 4 5 3 1 2 5 4 1 2 3 4 5 5 3 1 2 5 4 5 3 2 1 4",
"output": "3 3 4"
}
] | 1 | Médio | 256 mb | 1 second(s) |
neps:11395 | Neps Academy | 11,395 | KryptoLocker Comeu Minha Lição de Casa | https://neps.academy/br/exercise/1237 | KryptoLocker Comeu Minha Lição de Casa O computador do seu amigo foi infectado por KryptoLocker ontem à noite. KryptoLocker é ransomware que encripta os dados do utilizador, tornando-os inutilizáveis até ser pago um resgate à pessoa por detrás do ataque. Felizmente, o seu amigo reparou que algo de estranho estava a aco... | A primeira linha contém um número inteiro de N ( 1 ≤ N ≤ 18 ) N \ (1 \ \leq \ N \ \leq \ 18) N ( 1 ≤ N ≤ 1 8 ) indicando o número de elementos do array atribuído ao seu amigo. Cada uma das próximas 2 N 2^N 2 N linhas contém um número inteiro S ( − 1 0 9 ≤ S ≤ 1 0 9 ) S \ (-10^9 \ \leq \ S \ \leq \ 10^9) S ( − 1 0 9 ≤ S... | Produza cada um dos diferentes arrays que possam ter sido atribuídos ao seu amigo, um array por linha, com as linhas lexicograficamente ordenadas. Dois arrays são considerados diferentes se, e apenas se, contiverem elementos diferentes em pelo menos uma posição. | [
{
"input": "3 9 8 7 0 15 16 17 24",
"output": "7 8 9"
},
{
"input": "2 1 0 -1 0",
"output": "-1 1"
}
] | 2 | Difícil | 256 mb | 1 second(s) |
neps:11408 | Neps Academy | 11,408 | Rituais dos Pássaros | https://neps.academy/br/exercise/1910 | Rituais dos Pássaros As aves são animais estupendos. Muitas espécies delas realizam rituais diferentes ao longo de sua vida; desde danças de cortejo de pavões a moonwalking de manequins de capuchinho vermelho. Entre todos, estamos estudando a dança da permutação neste problema. Este ritual é realizado por um grupo de p... | A entrada começa com uma linha contendo dois números inteiros separados por espaço n ( 1 ≤ n ≤ 1000 ) n \ (1 \ \leq \ n \ \leq \ 1000) n ( 1 ≤ n ≤ 1 0 ) e s ( 1 ≤ s ≤ 5000 ) s \ (1 \ \leq \ s \ \leq \ 5000) s ( 1 ≤ s ≤ 5 0 ) . A segunda linha contém n nomes de aves separadas por espaço, como a configuração inicial do r... | Imprima uma única linha na saída contendo a configuração final do ritual. A linha deve conter a lista separada por espaço dos nomes dos pássaros na linha (da esquerda para a direita). | [
{
"input": "3 1 juju ashi mashi insert fifi 1",
"output": "juju fifi ashi mashi"
},
{
"input": "3 15 m1 m2 f insert m3 0 relocate m2 -2 relocate m1 -2 relocate m3 -2 relocate m2 -2 relocate m1 -2 relocate m3 -2 depart m2 relocate m1 1 relocate f 0 relocate m3 0 relocate f -1 relocate m3 -1 relocate ... | 3 | Difícil | 512 mb | 2 second(s) |
neps:1881 | Neps Academy | 1,881 | Mudanças cíclicas | https://neps.academy/br/exercise/1416 | Mudanças cíclicas Thuc gosta de encontrar deslocamentos cíclicos de strings. Um deslocamento cíclico de uma string é obtido movendo os caracteres do início da string para o final da string. Também consideramos uma string como uma mudança cíclica dela mesma. Por exemplo, as mudanças cíclicas de ABCDE são: ABCDE, BCDEA, ... | A entrada consistirá em exatamente duas linhas contendo apenas letras maiúsculas. A primeira linha será o texto T e a segunda linha será a string S . Cada linha conterá no máximo 1000 caracteres. Resultado Imprima "yes" se o texto, T , contiver um deslocamento cíclico da string, S . Caso contrário, imprima "no". | null | [
{
"input": "ABCCDEABAA ABCDE",
"output": "yes"
},
{
"input": "ABCDDEBCAB ABA",
"output": "no"
}
] | 2 | Médio | 256 mb | 1 second(s) |
neps:11418 | Neps Academy | 11,418 | Gravatas Borboletas Estupendas | https://neps.academy/br/exercise/2052 | Gravatas Borboletas Estupendas Há N ( 1 ≤ N ≤ 100000 ) N \ (1 \leq N \leq 100 000) N ( 1 ≤ N ≤ 1 0 ) pontos distintos em um plano 2D, com o i -ésimo ponto nas coordenadas integrais ( x i , y i ) (x_i, \ y_i) ( x i , y i ) ( − 1 0 9 ≤ x i ≤ 1 0 9 , − 1 0 9 ≤ y i ≤ 1 0 9 ) (−10^9 \leq x_i \leq 10^9, \ −10^9 \leq y_i ... | A primeira linha da entrada contém um número inteiro, N . As N linhas restantes contêm dois inteiros cada, x i x_i x i e y i y_i y i para i = 1... N i = 1...N i = 1 . N . | Imprima um único número inteiro, o número de Gravatas Borboletas Estupendas que existem entre os pontos dados. Restrições N | [
{
"input": "12 -3 6 1 6 -1 4 -3 2 1 2 4 2 -4 -3 -3 -3 1 -3 -1 -4 1 -4 -3 -6",
"output": "8"
}
] | 1 | Difícil | 512 mb | 2 second(s) |
neps:11020 | Neps Academy | 11,020 | Chuva (OBI 2008) | https://neps.academy/br/exercise/598 | Chuva (OBI 2008) A robótica causou uma grande revolução nos processos industriais no mundo todo; atualmente, vários tipos de robôs são usados na fabricação de carros, equipamentos eletrônicos e até mesmo utensílios domésticos. Uma fábrica possui um robô de manutenção, que constantemente precisa ser deslocado entre seto... | 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 inteiros X i X_i X i , Y i Y_i Y i , X f X_f X f e Y f Y_f Y f indicando, respectivamente, a posição atual e a posição final do robô - o robô começa... | Seu programa deve imprimir, na saída padrão, uma única linha, contendo um número inteiro indicando a menor distância que o robô precisa percorrer sob chuva. Restrições | [
{
"input": "0 0 4 3 0",
"output": "7"
},
{
"input": "2 5 5 0 1 0 0 1 5",
"output": "5"
},
{
"input": "4 5 5 0 2 0 0 1 5 0 0 3 2",
"output": "5"
}
] | 3 | Difícil | 256 mb | 1 second(s) |
neps:1888 | Neps Academy | 1,888 | Encontrando o Aluno Correspondente | https://neps.academy/br/exercise/3019 | Encontrando o Aluno Correspondente Uma professora aplicou dois testes para uma turma. Ela registrou os nomes dos alunos junto com suas pontuações em ambos os testes, na ordem em que terminaram. Sua tarefa é encontrar o primeiro aluno cujo nome e nota sejam exatamente os mesmos nos dois testes, considerando que o segund... | A primeira linha contém um número inteiro N , o número de alunos em cada teste. As próximas N linhas contêm o nome de um aluno (até 10 caracteres minúsculos, sem espaços) e sua nota no primeiro teste . As N linhas seguintes contêm o nome de um aluno e sua nota no segundo teste . | Imprima o nome do primeiro aluno que tem o mesmo nome e mesma nota nos dois testes. Se nenhum aluno corresponder, imprima "NONE" . Restrições | [
{
"input": "3 joh 8 gab 9 thi 6 thi 4 gab 9 joh 8",
"output": "gab"
},
{
"input": "6 alec 95 bella 87 charlie 91 diana 100 eric 79 fiona 88 fiona 85 alec 95 bella 87 charlie 91 eric 80 diana 100",
"output": "alec"
},
{
"input": "3 joh 8 gab 9 thi 6 thi 4 gab 7 joh 5",
"output": "NONE... | 3 | Difícil | 256 mb | 1 second(s) |
neps:1589 | Neps Academy | 1,589 | Gabriel Astuto | https://neps.academy/br/exercise/1706 | Gabriel Astuto Gabriel, um menino astuto, adora brincar de escrever palavras incompletas a partir de uma posição N de sua frase. Como por exemplo seu nome: Gabriel Ribeirinho. Ele pegará a partir da posição 3, portanto seu nome ficaria: iel Ribeirinho. Ajude o garoto Gabriel a fazer essas brincadeira com as frases de u... | Uma String, podendo conter espaços e um número inteiro, que será o separador. | Uma String contendo uma cópia da outra a partir da posição especificada. 0 < l e n ( s t r ) ≤ 100 0 < len(str) \leq 100 0 < l e n ( s t r ) ≤ 1 0 ≤ N ≤ l e n ( s t r ) 0 \leq N \leq len(str) 0 ≤ N ≤ l e n ( s t r ) | [
{
"input": "uberhub code club 5",
"output": "ub code club"
},
{
"input": "gabriel ribeiro 4",
"output": "iel ribeiro"
},
{
"input": "pedro henrique 3",
"output": "ro henrique"
}
] | 3 | null | 256 mb | 1 second(s) |
neps:11239 | Neps Academy | 11,239 | Inserção de Usuário | https://neps.academy/br/exercise/2679 | Inserção de Usuário Neste exercício, você deve receber informações do usuário e realizar a inserção na tabela user . Lembre-se que o username e email são únicos. Se algum desses dados enviados já existir no banco de dados, deve ser impresso "invalid user". Você pode usar o código abaixo como ponto de partida: import sq... | A entrada é formada por 3 linhas, cada uma contendo uma string não vazia: username email birthdate | Seu programa deve imprimir "invalid user" caso seja inserido algum username ou email já existente no banco de dados. Caso contrário, não é esperado nenhuma impressão. Restrições birthdate | [
{
"input": "tiagobp tiagobp@neps.academy 2001-10-22",
"output": ""
},
{
"input": "john_doe john_doe@example.com 1990-01-01",
"output": "invalid user"
}
] | 2 | Difícil | 256 mb | 1 second(s) |
neps:111 | Neps Academy | 111 | Gangorra | https://neps.academy/br/exercise/260 | Gangorra Joãozinho acaba de mudar de escola e a primeira coisa que percebeu na nova escola é que a gangorra do parquinho não é simétrica, uma das extremidades é mais longa que a outra. Após brincar algumas vezes com um amigo de mesmo peso, ele percebeu que quando está em uma extremidade, a gangorra se desequilibra para... | A primeira e única linha da entrada contém 4 inteiros, P 1 P_1 P 1 , C 1 C_1 C 1 , P 2 P_2 P 2 e C 2 C_2 C 2 , nesta ordem. | Seu programa deve produzir uma única linha, contendo um único inteiro. Se a gangorra estiver equilibrada, imprima '0'. Se ela estiver desequilibrada de modo que a criança esquerda esteja na parte de baixo, imprima '-1', senão, imprima '1'. Restrições | [
{
"input": "30 100 60 50",
"output": "0"
},
{
"input": "40 40 38 60",
"output": "1"
}
] | 2 | Fácil | 256 mb | 1 second(s) |
neps:1936 | Neps Academy | 1,936 | Produção no PIM | https://neps.academy/br/exercise/2081 | Produção no PIM O sysProd é um sistema voltado para a execução sequencial de tarefas do produto a ser produzido no chão de fábrica de indústrias do Pólo Industrial de Manaus (PIM). O operador do sistema cria tarefas e o sistema é responsável por agendar a execução destas tarefas. Cada tarefa pode depender da conclusão ... | A primeira linha da entrada contém inteiros N e M . As próximas M linhas descrevem, cada uma, uma dependência entre as tarefas da entrada. Cada uma dessas linhas irá conter dois inteiros A e B que indicam que a tarefa B depende da tarefa A , isto é, que a tarefa A deve terminar antes que a tarefa B inicie. | Se não for possível ordenar as tarefas de forma que as dependências sejam satisfeitas, imprima uma única linha contendo o caracter "∗". Caso contrário, imprima N linhas contendo cada uma um número inteiro. O inteiro na i-ésima linha deve ser o índice da i-ésima tarefa a ser executada na ordem ótima de execução das tare... | [
{
"input": "3 1 2 0",
"output": "1 2 0"
},
{
"input": "2 2 0 1 1 0",
"output": "*"
}
] | 2 | Médio | 256 mb | 1 second(s) |
End of preview. Expand in Data Studio
ProgramExBR
O ProgramExBR reúne 2.102 exercícios de programação em português do Brasil, coletados de três plataformas públicas (Neps Academy, OBI e SPOJ Brasil) por coletores desenvolvidos para cada uma delas. Cada exercício traz o enunciado, a especificação de entrada e saída, os casos de teste de exemplo e, quando a plataforma informa, a dificuldade e os limites de tempo e memória.
ProgramExBR is a dataset of 2,102 programming exercises in Brazilian Portuguese, collected from three public platforms (Neps Academy, the Brazilian Olympiad in Informatics and SPOJ Brasil). Each record contains the problem statement, the input and output specification, the sample test cases and, when the platform provides them, the difficulty level and the time and memory limits. Datasets of this kind are common in English but still scarce in Portuguese, which limits research on code generation, exercise recommendation and learning analytics for Portuguese speaking students.
This repository mirrors version 1 of the dataset, originally published on Zenodo (10.5281/zenodo.15724871) and described in a paper presented at WebMedia 2025. The data was converted to a single Parquet file with a unified schema so it can be loaded and browsed directly on the Hub.
from datasets import load_dataset
ds = load_dataset("vkusterl/ProgramExBR", split="train")
print(ds[0]["name"], ds[0]["test_cases"][0])
Data fields
| Field | Type | Description |
|---|---|---|
id |
string | Global identifier in the form platform:source_id, for example neps:1503 |
platform |
string | Neps Academy, OBI or SPOJ-BR |
source_id |
int | Identifier in the original release, unique only within each platform |
name |
string | Problem title |
url |
string | Address of the original problem page |
statement |
string | Problem statement |
input_spec |
string | Description of the input format |
output_spec |
string | Description of the expected output |
test_cases |
list of {input, output} |
Sample test cases shown on the problem page |
n_test_cases |
int | Number of sample test cases |
difficulty |
string | Difficulty reported by Neps Academy (Super Fácil to Super Difícil), null for the other platforms |
memory_limit |
string | Memory limit as written by the platform |
time_limit |
string | Time limit as written by the platform |
Composition
| Platform | Exercises |
|---|---|
| Neps Academy | 1,448 |
| OBI | 353 |
| SPOJ Brasil | 301 |
| Total | 2,102 |
Statements have a median length of 1,046 characters, and each exercise has 2.25 sample test cases on average. Among the Neps Academy exercises, 562 are labeled Difícil, 324 Médio, 306 Fácil, 96 Super Difícil and 45 Super Fácil, while 115 have no difficulty.
Possible uses
The sample test cases make it possible to check programs generated from Portuguese statements, which is useful for evaluating code generation models outside English. The statements and metadata also support exercise recommendation, difficulty estimation and the study of how programming problems are written in Portuguese.
Limitations
The test cases are the public examples shown on each problem page, not the hidden tests used by the online judges, so passing them is a weaker signal than an accepted submission. 69 exercises have no sample test case and one has no statement. Difficulty is available only for Neps Academy. The Neps Academy file in the Zenodo release is missing its final closing bracket, and this version repairs it without changing any record. Identifiers repeat across platforms, so joins should use id rather than source_id.
The statements were collected from public pages, and the rights over the original texts remain with their platforms. Please credit the platforms and follow their terms when reusing the statements.
Citation
@inproceedings{lodi2025programexbr,
title = {Building and Analyzing an Open Repository of Programming Exercises in Portuguese},
author = {Lodi, Vinicius Kuster and Sena, Jo{\~a}o Pedro Medrado and Reis, Julio Cesar Soares dos},
booktitle = {Anais Estendidos do XXXI Simp{\'o}sio Brasileiro de Sistemas Multim{\'i}dia e Web},
pages = {45--48},
year = {2025},
publisher = {Sociedade Brasileira de Computa{\c{c}}{\~a}o},
doi = {10.5753/webmedia_estendido.2025.16359}
}
@dataset{lodi2025programexbr_data,
title = {{PROGRAMEXBR}: A Dataset of Programming Exercises in Portuguese},
author = {Lodi, Vinicius Kuster and Sena, Jo{\~a}o Pedro Medrado and Reis, Julio Cesar Soares dos},
year = {2025},
publisher = {Zenodo},
doi = {10.5281/zenodo.15724871}
}
Authors
Vinicius Kuster Lodi and Julio Cesar Soares dos Reis (Universidade Federal de Viçosa) and João Pedro Medrado Sena (Universidade de São Paulo).
- Downloads last month
- 25