dump.sql

/*M!999999\- enable the sandbox mode */ 
-- MariaDB dump 10.19  Distrib 10.11.11-MariaDB, for debian-linux-gnu (x86_64)
--
-- Host: localhost    Database: languid
-- ------------------------------------------------------
-- Server version	10.11.11-MariaDB-0+deb12u1

/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
/*!40101 SET NAMES utf8mb4 */;
/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
/*!40103 SET TIME_ZONE='+00:00' */;
/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;

--
-- Table structure for table `exercise`
--
CREATE database languid;

USE languid;

DROP TABLE IF EXISTS `exercise`;
/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8mb4 */;
CREATE TABLE `exercise` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `title` varchar(255) NOT NULL,
  `instructions` text NOT NULL,
  `testFileName` varchar(255) NOT NULL,
  `groupId` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `groupId` (`groupId`),
  CONSTRAINT `exercise_ibfk_1` FOREIGN KEY (`groupId`) REFERENCES `exerciseGroup` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=60 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Dumping data for table `exercise`
--

LOCK TABLES `exercise` WRITE;
/*!40000 ALTER TABLE `exercise` DISABLE KEYS */;
INSERT INTO `exercise` VALUES
(1,'Olá, Mundo!','Escreva um programa que imprime \"Ola, Mundo!\" na tela.\n\nResultado esperado:\nOla, Mundo!\n\nDica: Use std::cout','0_test.cpp',1),
(2,'Soma de Dois Números','Usando std::cin, \n\nCrie a função main e dentro dela leia dois números inteiros do usuario e imprima a soma deles.\n\nResultado esperado (exemplo):\nO resultado deve ser impresso no seguinte formato:\n\nSoma: <resultado>','1_test.cpp',1),
(3,'Multiplicaçao Simples','Crie a função main e dentro dela leia dois números inteiros e imprima o produto deles.\n\nResultado esperado (exemplo):\nO resultado deve ser impresso no seguinte formato:\nProduto: <resultado>\n\nDica: Multiplicaçao e feita com o operador *.','2_test.cpp',1),
(4,'Maior de Dois Números','Crie a função main e dentro dela leia dois números inteiros e imprima o maior deles.\n\nResultado esperado (exemplo):\nO resultado deve ser impresso no seguinte formato:\nMaior: <resultado>\n\nDica: Use if/else para comparar.','3_test.cpp',1),
(5,'Par ou Impar','Crie a função main e dentro dela leia um número inteiro e informe se ele e par ou impar.\n\nResultado esperado (exemplo):\nO resultado deve ser impresso no seguinte formato:\nImpar\nPar\n\nDica: Use o operador % para resto da divisao.','4_test.cpp',1),
(6,'Soma de Vetor','Crie a função main e dentro dela leia 5 números inteiros usando std::cin em um vetor e imprima a soma deles.\n\nResultado esperado (exemplo):\nO resultado deve ser impresso no seguinte formato:\nSoma: <resultado>\n\nDica: Use um loop for para ler e somar.','5_test.cpp',1),
(7,'Media de Números','Leia 4 números reais e imprima a media deles.\n\nResultado esperado (exemplo):\nNúmeros: 2.0 4.0 6.0 8.0\nMedia: 5.0\n\nDica: \n- Use a biblioteca #include <iomanip>\n- Para alterar a quantidade de casas decimais para 1 no cout use:\n  - std::cout << std::fixed << std::setprecision(1);','6_test.cpp',1),
(8,'Funçao de Soma','Implemente uma função que recebe dois inteiros e retorna a soma deles.\n\nResultado esperado:\nsoma(3, 4) = 7','7_test.cpp',1),
(9,'Funçao de multiplicação','Implemente uma função que recebe dois inteiros e retorna a multiplicação deles.\n\nResultado esperado:\nmult(3, 4) = 12\n','8_test.cpp',1),
(10,'Troca de Valores','Implemente uma funçao que troca os valores de dois inteiros usando referências.\n\nResultado esperado:\ntroca(a, b);\nAntes: a=3, b=5\nDepois: a=5, b=3\n\nDica: Use parâmetros por referência (&).','9_test.cpp',1),
(11,'Criação de vetor','Crie um função que retorne um vetor com 10 valores quaisquer.\n\nO nome da função de ser \"criaVetor\"\n\nDica: Para criar o vetor use std::vector da biblioteca <vector>','10_test.cpp',1),
(12,'Leitura de vetor','Crie um vetor chamado \"notas\":\nstd::vector<float> notas = {5, 10, 2};\n\nDepois crie um função chamada \"primeiraNota\" que retorna a primeira nota.','11_test.cpp',1),
(13,'Funçao Maximo','Implemente uma funçao que retorna o maior de três números inteiros.\n\nResultado esperado:\nmaximo(3, 7, 5) = 7\n\nDica: \nUse if/else ou \nuse std::max com #include <algorithm>','12_test.cpp',1),
(14,'Leitura de vetor 2','Crie um vetor chamado \"notas\":\nstd::vector<float> notas = {5, 10, 2};\n\nDepois crie um função chamada \"outrasNotas\" que retorna as duas últimas notas.\n\nDica: Use o método size() do vetor, o mesmo retorna o quantidade de itens do vetor:\n\nstd::vector<float> teste = {5, 6, 1, 2, 13, 50};\n\nint tamanho = teste.size();\n\n// tamanho será igual a 6','13_test.cpp',1),
(19,'Funçao de Potência','Implemente uma funçao que calcula a potência de um número inteiro (base^expoente).\n\nResultado esperado:\npotencia(2, 3) = 8\n\nDica: Use loop.','18_test.cpp',1),
(20,'Parâmetro por Referência','Implemente uma funçao que dobra o valor de um inteiro passado por referência.\n\nResultado esperado:\nint a = 2;\n\ndobra(a);\n\na = 4\n\nDica: Use & no parâmetro.','19_test.cpp',1),
(31,'Valor absoluto','Crie uma função chamada \"absoluto\" que retorna o valor absoluto de um número.\n\nExemplo:\n\nabsoluto(-6) = 6\nabsoluto(6) = 6\nabsoluto(1) = 1\nabsoluto(-10) = 10','21_test.cpp',1),
(33,'Raíz quadrada','Crie um função chamada \"raizQuadrada\" que retorne a raíz quadrada de um número. Essa função deve receber um número do tipo double.\n\nDica: Use std::sqrt(x) da biblioteca <cmath>','33_test.cpp',1),
(34,'Função potência 2','Implemente uma funçao que calcula a potência de um número inteiro (base^expoente).\n\nResultado esperado:\npotencia(2, 3) = 8\n\nDica: Use std::pow(base, expoente) da biblioteca <cmath>','34_test.cpp',1),
(35,'Função seno','Crie um função chamada \"seno\" que retorne o seno de um ângulo.\n\nDica: use a função std::sin(x) da biblioteca <cmath>','35_test.cpp',1),
(36,'Função cosseno','Crie um função chamada \"cosseno\" que retorne o cosseno de um ângulo.\n\nDica: use a função std::cos(x) da biblioteca <cmath>','36_test.cpp',1),
(37,'Arredonda','Crie uma função chamada \"arredondar\" que arredonda um número real para o inteiro mais próximo. \n\nDica: use a função std::round(x) da biblioteca <cmath>','37_test.cpp',1),
(38,'Quantas letras tem a palavra','Escreva uma função que receba uma palavra e diga quantas letras ela tem.\n\nO nome da função deve ser \"quantasLetras\" e deve receber 1 argumento do tipo string\n\n\nDica use: std::string e .size() ou .length()','38_test.cpp',1),
(41,'Todas maiúsculas','Escreva uma função \"tudoMaiusculo\" que receba uma palavra e retorne tudo em letras maiúsculas.\n\nUse: <string> e <algorithm>, função std::transform + ::toupper\n\nDica: toupper(c) transforma o caractere em maiúscula\n\ntudoMaiusculo(\"gato\") → \"GATO\"\n\nSolução:\n\n#include <string>\n#include <algorithm>\n\nstd::string tudoMaiusculo(std::string palavra) {\n    std::transform(palavra.begin(), palavra.end(), palavra.begin(), ::toupper);\n    return palavra;\n}','41_test.cpp',1),
(42,'A palavra começa com \'a\'','Escreva uma função que retorna \"true\" se uma palavra começa com a letra \'a\' ou \"false\" caso contrário.\n\nUse: std::string e palavra[0]\n\nDica: Verifique se a primeira letra é \'a\' ou \'A\'\n\ncomecaComA(\"abacate\") → true  \ncomecaComA(\"melancia\") → false\n','42_test.cpp',1),
(43,'Crie uma classe','Crie uma classe chamada Pessoa que tem duas propriedades públicas:\n\n- nome, que guarda o nome da pessoa (tipo string)\n- idade, que guarda a idade da pessoa (tipo int)\n\nUse: palavra-chave class\nDica: std::string vem da biblioteca <string>\n\nExemplo de uso esperado:\n\nPessoa p;\np.nome = \"Ana\";\np.idade = 30;\n','43_test.cpp',1),
(44,'Crie uma classe 2','Crie uma classe chamada Pessoa com dois atributos privados:\n\n-pensamento, do tipo string\n-acordada, do tipo bool\n\nUse: palavras-chave class, public e private.\n\nCrie métodos públicos\ngetPensamento() para retornar o pensamento\nsetPensamento(std::string p) para atribuir um pensamento\nisAcordada() para retornar o valor da propriedade \"acordada\"\nsetAcordada(bool a) para atribuir o valor da propriedade \"acordada\"\n\n\nExemplo de uso esperado:\nPessoa p;\np.setPensamento(\"Estou com sono\");\np.setAcordada(false);\nbool valor = p.isAcordada()\nstd::string texto = p.getPensamento()\n','44_test.cpp',1),
(45,'Soma dos elementos pares de um vetor','Implemente uma função que receba um vetor de inteiros e retorne a soma dos elementos pares.\n\nDica: Use um loop para iterar pelo vetor e uma condição para verificar se o número é par.\n\nA operação x % 2 == 0 identifica pares. Lembre-se de inicializar soma com zero.','45_test.cpp',1),
(46,'Verificação de palíndromos','Implemente uma função que verifique se uma string é um palíndromo.\n\nDica: \nCompare caracteres simétricos da string usando dois índices.','46_test.cpp',1),
(47,'Contagem de vogais','Implemente uma função que conte o número de vogais em uma string.\n\nDica: Considere letras maiúsculas e minúsculas.\n\nA função strchr é útil para verificar se um caractere está em uma lista de vogais.','47_test.cpp',1),
(48,'Soma dos dígitos de um número','Implemente uma função que calcule a soma dos dígitos de um número inteiro positivo.\n\nDica: Use divisão e módulo para extrair os dígitos.\n\nFunciona mesmo com números grandes se a entrada for positiva.\n','48_test.cpp',1),
(49,'Inversão de string','Implemente uma função que inverta os caracteres de uma string. Não modifique a string original; retorne uma nova.\n\nDica: (Opcional) Use rbegin() e rend() para criar uma nova string invertida.','49_test.cpp',1),
(50,'N-ésimo número de Fibonacci','Implemente uma função que retorne o n-ésimo número da sequência de Fibonacci.\n\nDica: Comece com os dois primeiros termos da sequência.\n','50_test.cpp',1),
(51,'Cálculo de média com double','Implemente uma função que receba um vetor de double e retorne a média aritmética. Retorne 0.0 se o vetor estiver vazio.\n\nDica: Lembre-se de evitar divisão por zero.\n','51_test.cpp',1),
(52,'Fatorial iterativo','Implemente uma função que calcule o fatorial de um número inteiro positivo usando laço (mais conhecido com loop).\n\nDica:\nUse um laço de 2 até n.\n0! = 1 por definição.','52_test.cpp',1),
(53,'Contar ocorrências de caractere','Dada uma string e um caractere, conte quantas vezes esse caractere aparece na string.\n\n\nDica: (Opcional) Use std::count da biblioteca algorithm.\n','53_test.cpp',1),
(54,'Verificar se uma string contém apenas dígitos','Crie uma função que retorna verdadeiro se uma string contém apenas caracteres numéricos. String vazia deve retornar true.\n\nDica: Use std::all_of com isdigit da biblioteca algorithm','54_test.cpp',1),
(55,'Inverter vetor','Implemente uma função que inverte um vetor de inteiros. Vetores vazios ou de um elemento devem ser tratados corretamente\n\nDica: (Opcional) Use std::reverse','55_test.cpp',1);
/*!40000 ALTER TABLE `exercise` ENABLE KEYS */;
UNLOCK TABLES;

--
-- Table structure for table `exerciseGroup`
--

DROP TABLE IF EXISTS `exerciseGroup`;
/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8mb4 */;
CREATE TABLE `exerciseGroup` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(50) NOT NULL,
  `description` text NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Dumping data for table `exerciseGroup`
--

LOCK TABLES `exerciseGroup` WRITE;
/*!40000 ALTER TABLE `exerciseGroup` DISABLE KEYS */;
INSERT INTO `exerciseGroup` VALUES
(1,'Primeiro MTS','Lista de exercícios do primeiro módulo de Manuntenção de computadores noturno'),
(2,'Lista extra','Lista de exercícios do Sidney');
/*!40000 ALTER TABLE `exerciseGroup` ENABLE KEYS */;
UNLOCK TABLES;

--
-- Table structure for table `user`
--

DROP TABLE IF EXISTS `user`;
/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8mb4 */;
CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `email` varchar(255) NOT NULL,
  `passwdHash` varchar(255) NOT NULL,
  `admin` tinyint(1) DEFAULT 0,
  `groupId` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `email` (`email`),
  KEY `groupId` (`groupId`),
  CONSTRAINT `user_ibfk_1` FOREIGN KEY (`groupId`) REFERENCES `exerciseGroup` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=42 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Dumping data for table `user`
--

LOCK TABLES `user` WRITE;
/*!40000 ALTER TABLE `user` DISABLE KEYS */;
INSERT INTO `user` VALUES
(2,'andre.furlan','81dc9bdb52d04dc20036dbd8313ed055',1,1),
(3,'ana.santos','715e8ba46f8bc29c24f3fbfdb8d96d71',0,1),
(4,'benjamin.santos','9efb1a59d7b58e69996cf0e32cb71098',0,1),
(5,'bruna.silva','134b1a2d8572115eaa6f32834a80641a',0,1),
(6,'caua.santos','848ef33f5e745846994a756f211e530b',0,1),
(7,'cosme.oliveira','3faf3b08de6c7c130e63c0e38e5553a8',0,1),
(8,'david.lopes','d78bded526b07ede88675c6412d63f3d',0,1),
(9,'douglas.oliveira','274895fd4fa237a59a5a2f2aab135e5e',0,1),
(10,'eduardo.moraes','da16202114b72b61f71124a219db6e3e',0,1),
(11,'eduardo.silva','90c34175923a36ab7a5de4b981c1972f',0,1),
(12,'elian.ferreira','4c117db21722a1b3e904bb745c024412',0,1),
(13,'ester.santos','6cab363c78b108a01de0e358be796feb',0,1),
(14,'francisco.costa','96fca94df72984fc97ee5095410d4dec',0,1),
(15,'geovanny.mendes','00c9f07b1f0782613ee5d3133d28cc01',0,1),
(16,'gerusa.silva','291dbc18539ba7e19b8abb7d85aa204e',0,1),
(17,'guilherme.muller','48abd1b3f5452995d995eb78a77013c8',0,1),
(18,'guilherme.santana','421f8eb2f6d635fc5e09d0b16c59e281',0,1),
(19,'igor.barros','92253519f3e59e2c62de0a4d887e7002',0,1),
(20,'juan.ruiz','2e667fca5e24ac13dcee94ddc4aa751a',0,1),
(21,'lays.matukawa','ff12592a08c792faa97fd3d2dc40f1cd',0,1),
(22,'lucas.campanhans','f06adf060c098f11e76fa2ff1565ba70',0,1),
(23,'lucas.silva','2d5b53f80151aea5fef0722f8b1edf99',0,1),
(24,'luis.andrade','5eb4ae8e5d2b63b7b3d8721e6f533b18',0,1),
(25,'marco.delabiglia','801fef527a36434cbae25eca8ceadff6',0,1),
(26,'matheus.dias','61a10e6abb1149ad9d08f303267f9bc4',0,1),
(27,'matheus.campos','6eb887126d24e8f1cd8ad5033482c781',0,1),
(28,'matheus.lopes','737eb13c7593133a06c7ac5b90d15d2a',0,1),
(29,'pietro.lima','b578f2a52a0229873fefc2a4b06377fa',0,1),
(30,'pietro.cabana','17446a8ae7dbf7e2c2535ba49340b4b9',0,1),
(31,'rafael.bernardes','ebd64e2bf193fc8c658af2b91952ce8d',0,1),
(32,'romulo.felipe','cfc5c92e70aad384cd7d9ad94cd3ce01',0,1),
(33,'samuel.porto','f6c2a0c4b566bc99d596e58638e342b0',0,1),
(34,'stefany.rocha','aeea73be8c3967e626f871de617d508c',0,1),
(35,'thiago.oliveira','294e09f267683c7ddc6cc5134a7e68a8',0,1),
(36,'victor.pamplona','44e207aecc63505eb828d442de03f2e9',0,1),
(37,'victor.militao','432fd02f951f393df1591310e6811118',0,1),
(38,'vitoria.siqueira','0fe500898e3183422bebc8325bfc9515',0,1),
(39,'yasmin.mota','e56eea9a45b153de634b23780365f976',0,1),
(41,'sydney','76edbbdb0ba4e68e2dc0ced676c1fb34',0,1);
/*!40000 ALTER TABLE `user` ENABLE KEYS */;
UNLOCK TABLES;

--
-- Table structure for table `user_exercise`
--

DROP TABLE IF EXISTS `user_exercise`;
/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8mb4 */;
CREATE TABLE `user_exercise` (
  `loginId` int(11) NOT NULL,
  `exerciseId` int(11) NOT NULL,
  `done` tinyint(1) DEFAULT 0,
  `code` varchar(5000) DEFAULT NULL,
  PRIMARY KEY (`loginId`,`exerciseId`),
  KEY `exerciseId` (`exerciseId`),
  CONSTRAINT `user_exercise_ibfk_1` FOREIGN KEY (`loginId`) REFERENCES `user` (`id`),
  CONSTRAINT `user_exercise_ibfk_2` FOREIGN KEY (`exerciseId`) REFERENCES `exercise` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Dumping data for table `user_exercise`
--

LOCK TABLES `user_exercise` WRITE;
/*!40000 ALTER TABLE `user_exercise` DISABLE KEYS */;
INSERT INTO `user_exercise` VALUES
(2,1,1,'#include <iostream>\n\nint main(){\n    std::cout << \"Ola, Mundo!\";\n    return 0;\n}\n'),
(2,2,1,'#include <iostream>\n\nint main(){\n    int a, b;\n    std::cin >> a >> b;\n    std::cout << \"Soma: \" << a + b;\n}'),
(2,3,1,'#include <iostream>\n\nint main(){\n    int a, b;\n    std::cin >> a >> b;\n    std::cout << \"Produto: \" << a * b;\n}'),
(2,4,1,'#include <iostream>\n\nint main(){\n    int a, b;\n    std::cin >> a >> b;\n    std::cout << \"Maior: \";\n    if(a > b){\n        std::cout << a;\n    }else{\n        std::cout << b;\n    }\n    return 0;\n}'),
(2,5,1,'#include <iostream>\n\nint main(){\n    int a;\n    std::cin >> a;\n    if(a % 2 == 0){\n        std::cout << \"Par\";\n    }else{\n        std::cout << \"Impar\";\n    }\n    return 0;\n}'),
(2,6,1,'#include <iostream>\n#include <vector>\nint main(){\n    int a;\n    std::vector<int> lista;\n\n    for(int i = 0; i < 5; i++){\n        std::cin >> a;\n        lista.push_back(a);\n    }\n\n    a = 0;\n    for(int i = 0; i < 5; i++){\n        a += lista.at(i);\n    }\n\n    std::cout << \"Soma: \" << a;\n\n    return 0;\n}'),
(2,7,1,'#include <iostream>\n#include <iomanip>\nint main(){\n    float a = 0;\n    float media = 0;\n\n    for(int i = 0; i < 4; i++){\n        std::cin >> a;\n        media += a;\n    }\n\n    std::cout << std::fixed << std::setprecision(1);\n    std::cout << \"Media: \" << media/4;\n\n    return 0;\n}'),
(2,8,1,'int soma(int a, int b){\n    return a + b;\n}'),
(2,9,1,'int mult(int a, int b){\n    return a * b;\n}'),
(2,10,1,'void troca(int &a, int &b){\n    int temp = b;\n    b = a;\n    a = temp;\n}'),
(2,11,1,'#include <vector>\n\nstd::vector<int> criaVetor() {\n    return {3, 7, 1, 4, 9, 2, 8, 0, 6, 5};\n}\n'),
(2,12,1,'#include <vector>\n\nstd::vector<float> notas = {5.0f, 10.0f, 2.0f};\n\nfloat primeiraNota() {\n    return notas.front();  // ou: return notas[0];\n}\n'),
(2,13,1,'#include <algorithm>\n\nint maximo(int a, int b, int c){\n    int maior = std::max(a, b);\n    return std::max(maior, c);\n}'),
(2,14,1,'#include <vector>\n\nstd::vector<float> notas = {5, 10, 2};\n\nstd::vector<float> outrasNotas() {\n    std::vector<float> resultado;\n    for (size_t i = 1; i < notas.size(); ++i) {\n        resultado.push_back(notas[i]);\n    }\n    return resultado;\n}\n'),
(2,19,1,'int potencia(int base, int expoente) {\n    int resultado = 1;\n    for (int i = 0; i < expoente; ++i) {\n        resultado *= base;\n    }\n    return resultado;\n}\n'),
(2,20,1,'void dobra(int& valor) {\n    valor *= 2;\n}\n'),
(2,31,1,'int absoluto(int x) {\n    return (x < 0) ? -x : x;\n}\n'),
(2,33,1,'#include <cmath>\n\ndouble raizQuadrada(double x) {\n    return std::sqrt(x);\n}\n'),
(2,34,1,'#include <cmath>\n\ndouble potencia(double base, double expoente) {\n    return std::pow(base, expoente);\n}\n'),
(2,35,1,'#include <cmath>\n\ndouble seno(double radianos) {\n    return std::sin(radianos);\n}\n'),
(2,36,1,'#include <cmath>\n\ndouble cosseno(double radianos) {\n    return std::cos(radianos);\n}\n'),
(2,37,1,'#include <cmath>\n\nint arredondar(double x) {\n    return std::round(x);\n}\n'),
(2,38,1,'#include <string>\n\nint quantasLetras(const std::string& palavra) {\n    return palavra.size();\n}\n'),
(2,41,1,'#include <string>\n#include <algorithm>\n\nstd::string tudoMaiusculo(std::string palavra) {\n    std::transform(palavra.begin(), palavra.end(), palavra.begin(), ::toupper);\n    return palavra;\n}\n'),
(2,42,1,'#include <string>\n\nbool comecaComA(const std::string& palavra) {\n    return !palavra.empty() && (palavra[0] == \'a\' || palavra[0] == \'A\');\n}\n'),
(2,43,1,'#include <string>\n\nclass Pessoa {\npublic:\n    std::string nome;\n    int idade;\n};\n'),
(2,44,1,'#include <string>\n\nclass Pessoa {\nprivate:\n    std::string pensamento;\n    bool acordada;\n\npublic:\n    void setPensamento(const std::string& p) {\n        pensamento = p;\n    }\n\n    std::string getPensamento() const {\n        return pensamento;\n    }\n\n    void setAcordada(bool a) {\n        acordada = a;\n    }\n\n    bool isAcordada() const {\n        return acordada;\n    }\n};\n'),
(2,45,1,'/*\nImplemente uma função que receba um vetor de inteiros e retorne a soma dos elementos pares.\n\nDica: Use um loop para iterar pelo vetor e uma condição para verificar se o número é par.\n\nA operação x % 2 == 0 identifica pares. Lembre-se de inicializar soma com zero.\n*/\n\nint somaPares(const std::vector<int>& v) {\n    int soma = 0;\n    for (int x : v) {\n        if (x % 2 == 0)\n            soma += x;\n    }\n    return soma;\n}\n'),
(2,46,1,'/*\nImplemente uma função que verifique se uma string é um palíndromo.\n\nDica: \nCompare caracteres simétricos da string usando dois índices.\n*/\nbool ehPalindromo(const std::string& s) {\n    int i = 0, j = s.size() - 1;\n    while (i < j) {\n        if (s[i] != s[j]) return false;\n        i++; j--;\n    }\n    return true;\n}\n'),
(2,47,1,'/*\nImplemente uma função que conte o número de vogais em uma string.\n\nDica: Considere letras maiúsculas e minúsculas.\n\nA função strchr é útil para verificar se um caractere está em uma lista de vogais.\n*/\n\nint contarVogais(const std::string& s) {\n    int count = 0;\n    for (char c : s) {\n        if (strchr(\"aeiouAEIOU\", c)) count++;\n    }\n    return count;\n}\n'),
(2,48,1,'/*\nImplemente uma função que calcule a soma dos dígitos de um número inteiro positivo.\n\nDica: Use divisão e módulo para extrair os dígitos.\n\nFunciona mesmo com números grandes se a entrada for positiva.\n\n*/\nint somaDigitos(int n) {\n    int soma = 0;\n    while (n > 0) {\n        soma += n % 10;\n        n /= 10;\n    }\n    return soma;\n}\n'),
(2,49,1,'/*\nImplemente uma função que inverta os caracteres de uma string. Não modifique a string original; retorne uma nova.\n\nDica: (Opcional) Use rbegin() e rend() para criar uma nova string invertida.\n*/\nstd::string inverterString(const std::string& s) {\n    return std::string(s.rbegin(), s.rend());\n}\n'),
(2,50,1,'/*\nImplemente uma função que retorne o n-ésimo número da sequência de Fibonacci.\n\nDica: Comece com os dois primeiros termos da sequência.\n\n*/\n\nint fibonacci(int n) {\n    if (n == 0) return 0;\n    int a = 0, b = 1;\n    for (int i = 2; i <= n; ++i) {\n        int temp = b;\n        b += a;\n        a = temp;\n    }\n    return b;\n}\n'),
(2,51,1,'/*\nImplemente uma função que receba um vetor de double e retorne a média aritmética. Retorne 0.0 se o vetor estiver vazio.\n\nDica: Lembre-se de evitar divisão por zero.\n\n*/\n#include <vector>\n\ndouble media(const std::vector<double>& v) {\n    double soma = 0.0;\n    for (double x : v) soma += x;\n    return v.empty() ? 0.0 : soma / v.size();\n}\n'),
(2,52,1,'/*\nImplemente uma função que calcule o fatorial de um número inteiro positivo usando laço (mais conhecido com loop).\n\nDica:\nUse um laço de 2 até n.\n0! = 1 por definição.\n*/\nint fatorial(int n) {\n    int fat = 1;\n    for (int i = 2; i <= n; ++i)\n        fat *= i;\n    return fat;\n}\n'),
(2,53,1,'/*\nDada uma string e um caractere, conte quantas vezes esse caractere aparece na string.\n\n\nDica: (Opcional) Use std::count da biblioteca algorithm.\n\n*/\n#include <algorithm>\nint contarChar(const std::string& s, char c) {\n    return std::count(s.begin(), s.end(), c);\n}\n'),
(2,54,1,'/*\nCrie uma função que retorna verdadeiro se uma string contém apenas caracteres numéricos. String vazia deve retornar true.\n\nDica: Use std::all_of com isdigit da biblioteca algorithm\n*/\n\nbool somenteDigitos(const std::string& s) {\n    return std::all_of(s.begin(), s.end(), ::isdigit);\n}\n'),
(2,55,1,'/*\nImplemente uma função que inverte um vetor de inteiros. Vetores vazios ou de um elemento devem ser tratados corretamente\n\nDica: (Opcional) Use std::reverse\n*/\n\nvoid inverter(std::vector<int>& v) {\n    std::reverse(v.begin(), v.end());\n}\n'),
(3,1,1,'#include <iostream>\r\n\r\nint main (){\r\n    std::cout << \"Ola, Mundo!\";\r\n}'),
(3,2,1,'#include <iostream>\r\n\r\nint main (){\r\n    int a,b;\r\n    std::cin >> a >>b;\r\n    std::cout << \"Soma: \" << a + b;\r\n}'),
(4,1,1,'#include <iostream>\n\nint main(){\n\n\n   std::cout << \"Ola, Mundo!\";\n\n   return 0;\n}\n'),
(4,2,1,'#include <iostream>\n\nint main(){\n\n    int a, b;\n\n    std::cin >> a >> b;\n\n    std::cout << \"Soma: \" << a + b;\n\n    return 0;\n}'),
(4,3,1,'#include <iostream>\n\nint main(){\n\n    int a, b;\n\n    std::cin >> a >> b;\n\n    std::cout << \"Produto: \" << a * b;\n\n    return 0;\n}'),
(4,4,1,'#include <iostream>\n\nint main(){\n\n    int a, b;\n\n    std::cin >> a >> b;\n\n    std::cout << \"Maior: \";\n    if(a > b){\n       std::cout << a;\n       }else{\n          std::cout << b;\n       }\n    return 0;\n}'),
(4,5,1,'#include <iostream>\n\nint main(){\n\n   int a;\n   std::cin >> a;\n   if(a % 2 == 0){\n    std::cout << \"Par\";\n   }else{\n    std::cout << \"Impar\";\n   }\n   return 0;\n}\n\n/*\n\n\n10%2 = 0 \n20%5 = 0\n12%5 = 2\n\nif(x%2 == 0){\n//par\n}else{\n//impar\n}\n\n*/\n'),
(4,6,1,'#include <iostream>\n#include <vector>\n\nint main(){\n\n   std::vector<int> lista;\n\n   for(int i = 0; i < 5; i++){\n      int item;\n      std::cin >> item;\n      lista.push_back(item);\n   }\n\n   int soma = 0;\n   for(int i = 0; i < 5; i++){\n      soma = soma + lista[i];\n\n   \n   }\n\n   std::cout << \"Soma: \" << soma << std::endl;\n\n    return 0;\n\n\n}'),
(4,7,1,'#include <iostream>\n#include <iomanip>\n\nint main() {\n    double soma = 0, num;\n\n    for (int i = 0; i < 4; i++) {\n        std::cin >> num;\n        soma += num;\n    }\n\n    double media = soma / 4;\n\n    std::cout << std::fixed << std::setprecision(1);\n    std::cout << \"Media: \" << media << std::endl;\n\n    return 0;\n}\n'),
(4,8,1,'#include <iostream>\n\n// Função que recebe dois inteiros e retorna a soma\nint soma(int a, int b) {\n    return a + b;\n}\n\nint main() {\n    int resultado = soma(3, 4); // Chama a função soma\n    std::cout << \"soma(3, 4) = \" << resultado << std::endl; // Imprime o resultado\n    return 0;\n}\n'),
(4,9,1,'int mult ( int a, int b){\n   return a * b;\n}'),
(4,10,1,'void troca(int &a, int &b){\n   int temp = b;\n   b = a;\n   a = temp;\n}'),
(4,11,1,'#include <vector>\n\nstd::vector<int> criaVetor() {\n   return {3, 7, 1, 4, 9, 2, 8, 0, 6, 5 };\n}'),
(4,12,1,'#include <vector>\n\nstd::vector<float> notas = {5.0f, 10.0f, 2.0f};\nfloat primeiraNota() {\n   return notas.front();\n}'),
(4,13,1,'#include <algorithm>\nint maximo(int a,int b,int c){\n   int maior = std::max(a, b);\n   return std::max(maior, c);\n}'),
(4,14,1,'#include <vector>\n\nstd::vector<float> notas = {5, 10, 2};\n\nstd::vector<float> outrasNotas(){\n   std::vector<float> resultado;\n   for (size_t i = 1; i < notas.size(); ++i){\n      resultado.push_back(notas [i]);\n   }\n   return resultado;\n}\n'),
(4,19,1,'#include <stdio.h>\n\nint potencia(int base, int expoente) {\n    int resultado = 1;\n\n    for (int i = 0; i < expoente; i++) {\n        resultado *= base;\n    }\n\n    return resultado;\n}\n\nint main() {\n    int base = 2;\n    int expoente = 3;\n\n    printf(\"potencia(%d, %d) = %d\\n\", base, expoente, potencia(base, expoente));\n    return 0;\n}\n'),
(4,20,1,'void dobra(int &valor)\n{\n   valor*=2;\n}'),
(4,31,1,'int absoluto(int x){\n   return (x < 0) ? -x : x;\n}'),
(4,33,1,'#include <cmath>\r\n\r\ndouble raizQuadrada(double x){\r\n\r\n    return std::sqrt(x);\r\n}'),
(4,34,1,'#include <cmath>\r\ndouble potencia(double base, double expoente){\r\n    return std::pow(base, expoente);\r\n}'),
(4,35,1,'#include <iostream>\r\n#include <cmath> \r\n\r\ndouble seno(double angulo) {\r\n    return std::sin(angulo);\r\n}'),
(4,36,1,'#include <iostream>\r\n#include <cmath>\r\ndouble cosseno(double angulo) {\r\n    return std::cos(angulo);\r\n}\r\n'),
(4,37,1,'#include <cmath>    \r\n#include <iostream>\r\n\r\nint arredondar(double x) {\r\n    return static_cast<int>(std::round(x));\r\n}\r\n'),
(4,38,1,'#include <iostream>\r\n#include <string>\r\n\r\nint quantasLetras(const std::string& palavra) {\r\n    return palavra.size();\r\n}'),
(4,41,1,'#include <string>\r\n#include <algorithm>\r\n\r\nstd::string tudoMaiusculo(std::string palavra) {\r\n    std::transform(palavra.begin(), palavra.end(), palavra.begin(), ::toupper);\r\n    return palavra;\r\n}'),
(4,42,1,'#include <string>\r\n\r\nbool comecaComA(const std::string& palavra) {\r\n    if (palavra.empty()) return false; \r\n    return palavra[0] == \'a\' || palavra[0] == \'A\';\r\n}\r\n'),
(4,43,1,'#include <string>\r\n\r\nclass Pessoa {\r\npublic:\r\n    std::string nome;\r\n    int idade;\r\n};'),
(4,44,1,'#include <string>\r\n\r\nclass Pessoa {\r\nprivate:\r\n    std::string pensamento;\r\n    bool acordada;\r\n\r\npublic:\r\n    std::string getPensamento() const {\r\n        return pensamento;\r\n    }\r\n    void setPensamento(const std::string& p) {\r\n        pensamento = p;\r\n    }\r\n    bool isAcordada() const {\r\n        return acordada;\r\n    }\r\n    void setAcordada(bool a) {\r\n        acordada = a;\r\n    }\r\n};'),
(4,45,1,'#include <vector>\r\n\r\nint somaPares(const std::vector<int>& nums) {\r\n    int soma = 0;\r\n    for (int num : nums) {\r\n        if (num % 2 == 0) {\r\n            soma += num;\r\n        }\r\n    }\r\n    return soma;\r\n}'),
(4,46,1,'#include <iostream>\r\n#include <string>\r\n#include <cctype>\r\n\r\nbool ehPalindromo(const std::string& str) {\r\n    int esquerda = 0;\r\n    int direita = str.length() - 1;\r\n\r\n    while (esquerda < direita) {\r\n        \r\n        if (!std::isalnum(str[esquerda])) {\r\n            esquerda++;\r\n        } else if (!std::isalnum(str[direita])) {\r\n            direita--;\r\n        } else {\r\n            \r\n            if (std::tolower(str[esquerda]) != std::tolower(str[direita])) {\r\n                return false;\r\n            }\r\n            esquerda++;\r\n            direita--;\r\n        }\r\n    }\r\n    return true;\r\n}'),
(4,47,1,'#include <iostream>\r\n#include <cstring>\r\n#include <cctype>\r\n\r\nbool ehPalindromo(const std::string& str) {\r\n    int esquerda = 0;\r\n    int direita = str.length() - 1;\r\n\r\n    while (esquerda < direita) {\r\n        // Ignorar caracteres não alfanuméricos\r\n        if (!std::isalnum(str[esquerda])) {\r\n            esquerda++;\r\n        } else if (!std::isalnum(str[direita])) {\r\n            direita--;\r\n        } else {\r\n            // Comparar caracteres em minúsculo\r\n            if (std::tolower(str[esquerda]) != std::tolower(str[direita])) {\r\n                return false;\r\n            }\r\n            esquerda++;\r\n            direita--;\r\n        }\r\n    }\r\n    return true;\r\n}'),
(5,1,1,'#include <iostream>\r\n#include <string>\r\n\r\nint main(){\r\n\r\n  std::cout << \"Ola, Mundo!\" << std::endl;\r\n\r\n return 0;\r\n}\r\n'),
(5,2,1,'#include <iostream>\r\n#include <string>\r\n\r\nint main(){\r\n\r\n  int numero1;\r\n  int numero2;\r\n  int soma;\r\n  \r\n  std::cin >> numero1;\r\n\r\n  std::cin >> numero2;\r\n\r\n  soma = numero1 + numero2;\r\n  std::cout << \"Soma: \" << soma;\r\n  \r\n\r\n  return 0;\r\n};'),
(5,3,1,'#include <iostream>\r\n#include <string>\r\n\r\n  int numero1;\r\n  int numero2;\r\n  int multiplicacao;\r\n  \r\n\r\nint main(){\r\n  \r\n  std::cin >> numero1;\r\n\r\n  std::cin >> numero2;\r\n\r\n  multiplicacao = numero1 * numero2;\r\n  std::cout << \"Produto: \" << multiplicacao;\r\n  \r\n\r\n  return 0;\r\n};'),
(5,4,1,'#include <iostream>\r\n#include <string>\r\n\r\n\r\nint main(){\r\n\r\n  int numero1;\r\n  int numero2;\r\n  \r\n  std::cin >> numero1;\r\n\r\n  std::cin >> numero2;\r\n\r\n  if (numero1 > numero2)\r\n\r\n  std::cout << \"Maior: \" << numero1;\r\n\r\n  else\r\n  \r\n  std::cout << \"Maior: \" << numero2;\r\n\r\n\r\n  return 0;\r\n};'),
(5,5,1,'#include <iostream>\r\n#include <string>\r\n\r\n\r\nint main(){\r\n\r\n  int numero1;\r\n    \r\n  std::cin >> numero1;\r\n\r\n  if (numero1 % 2 == 0)\r\n\r\n  std::cout << \"Par\" << std::endl;\r\n  \r\n  \r\n  else\r\n  \r\n  std::cout << \"Impar\"<< std::endl;\r\n\r\n\r\n  return 0;\r\n};'),
(5,6,1,'/*\r\nLeia 5 números inteiros em um vetor e imprima a soma deles.\r\n\r\nResultado esperado (exemplo):\r\nDigite 5 números: 1 2 3 4 5\r\nSoma: 15\r\n\r\nDica: Use um loop for para ler e somar.\r\n*/\r\n\r\n#include <iostream>\r\n#include <string>\r\n#include <vector>\r\n\r\n\r\nint main(){\r\n  std::vector<int> lista;\r\n\r\n  for (int i=0; i<5;i++){\r\n     \r\n    int numero;\r\n    std::cin>> numero;\r\n   \r\n    lista.push_back(numero);\r\n}\r\n \r\n int soma=0;\r\n\r\n for (int i=0; i<5;i++){\r\n   soma = soma +lista[i];\r\n    \r\n }\r\n \r\nstd::cout << \"Soma: \" << soma;\r\n}'),
(5,7,1,'/*\r\nLeia 4 números reais e imprima a media deles.\r\n\r\nResultado esperado (exemplo):\r\nNúmeros: 2.0 4.0 6.0 8.0\r\nMedia: 5.0\r\n\r\nDica: \r\n- Use a biblioteca #include <iomanip>\r\n- Para alterar a quantidade de casas decimais para 1 no cout use:\r\n  - std::cout << std::fixed << std::setprecision(1);\r\n*/\r\n#include <iostream>\r\n#include <string>\r\n#include <vector>\r\n#include <iomanip>\r\n\r\nint main(){\r\n  std::vector<float> lista;\r\n\r\n  for (int i=0; i<4; i++){\r\n    float numero;\r\n    std::cin >> numero;\r\n    lista.push_back(numero);\r\n  }\r\n  \r\n  float media=0;\r\n\r\n  for (int i=0; i<4; i++){\r\n    media = media + lista[i];\r\n  }\r\n\r\n  std::cout << std::fixed << std::setprecision(1);\r\n  std::cout << \"Media: \" << media / 4;\r\n}'),
(5,8,1,'/*\r\nImplemente uma função que recebe dois inteiros e retorna a soma deles.\r\n\r\nResultado esperado:\r\nsoma(3, 4) = 7\r\n\r\nDica: Defina a função antes do main.\r\n*/\r\n\r\nint soma(int a, int b){\r\n  return a +b;\r\n\r\n}'),
(5,9,1,'/*\r\nImplemente uma função que recebe dois inteiros e retorna a multiplicação deles.\r\n\r\nResultado esperado:\r\nmult(3, 4) = 12\r\n\r\nDica: Defina a função antes do main.\r\n*/\r\n\r\nint mult(int a, int b){\r\n  return a * b;\r\n}'),
(5,10,1,'/*\r\nImplemente uma funçao que troca os valores de dois inteiros usando referências.\r\n\r\nResultado esperado:\r\ntroca(a, b);\r\nAntes: a=3, b=5\r\nDepois: a=5, b=3\r\n\r\nDica: Use parâmetros por referência (&).\r\n*/\r\n\r\nvoid troca(int &a, int &b){\r\n  int temp = a;\r\n  a = b;\r\n  b = temp;\r\n\r\n}\r\n\r\n\r\n'),
(5,11,1,'/*\r\nCrie um função que retorne um vetor com 10 valores quaisquer.\r\n\r\nO nome da função de ser \"criaVetor\"\r\n*/\r\n\r\n#include <vector>\r\n\r\nstd::vector<int> criaVetor(){\r\n  \r\n  std::vector<int> lista(10);\r\n\r\n  return lista;\r\n}\r\n \r\n '),
(5,12,1,'/*\r\nCrie um vetor chamado \"notas\":\r\nstd::vector<float> notas = {5, 10, 2};\r\n\r\nDepois crie um função chamada \"primeiraNota\" que retorna a primeira nota.\r\n*/\r\n\r\n#include <vector>\r\n#include <iostream>\r\n\r\nstd::vector<float> notas = {5, 10, 2};\r\n\r\nfloat primeiraNota(){\r\n  \r\nreturn notas[0];\r\n}\r\n'),
(5,13,1,'/*\r\nImplemente uma funçao que retorna o maior de três números inteiros.\r\n\r\nResultado esperado:\r\nmaximo(3, 7, 5) = 7\r\n\r\nDica: \r\nUse if/else ou \r\nuse std::max com #include <algorithm>\r\n*/\r\n\r\n#include <iostream>\r\n#include <algorithm>\r\n\r\nint maximo(int numero1, int numero2, int numero3){\r\n\r\n   int max_val1 = std::max(numero1, numero2);\r\n   int max_val2 = std::max(max_val1, numero3);\r\n   \r\n\r\n  return max_val2;\r\n};'),
(5,14,1,'/*\r\nCrie um vetor chamado \"notas\":\r\nstd::vector<float> notas = {5, 10, 2};\r\n\r\nDepois crie um função chamada \"outrasNotas\" que retorna as duas últimas notas.\r\n\r\nDica: Use o método size() do vetor, o mesmo retorna o quantidade de itens do vetor:\r\n\r\nstd::vector<float> teste = {5, 6, 1, 2, 13, 50};\r\n\r\nint tamanho = teste.size();\r\n\r\n// tamanho será igual a 6\r\n*/\r\n\r\n#include <vector>\r\n\r\nstd::vector<float> notas = {5, 10, 2};\r\n\r\nstd::vector<float> outrasNotas(){\r\n  \r\n  int tamanho = notas.size();\r\n  \r\n  int ultimo = tamanho -1;\r\n  \r\n  int penultimo = ultimo -1;\r\n\r\n  \r\n  std::vector<float> lista = {notas [penultimo], notas [ultimo]};\r\n  \r\n  return lista;\r\n}'),
(5,19,1,'/*\r\nImplemente uma funçao que calcula a potência de um número inteiro (base^expoente).\r\n\r\nResultado esperado:\r\npotencia(2, 3) = 8\r\n\r\nDica: Use loop.\r\n*/\r\n\r\n#include <string>\r\n#include <cmath>\r\n\r\nint potencia(int numero1, int numero2){\r\n\r\n  return std::pow(numero1, numero2);\r\n}'),
(5,20,1,'/*\r\nImplemente uma funçao que dobra o valor de um inteiro passado por referência.\r\n\r\nResultado esperado:\r\nint a = 2;\r\n\r\ndobra(a);\r\n\r\na = 4\r\n\r\nDica: Use & no parâmetro.\r\n*/\r\n\r\nvoid dobra(int &a){\r\n\r\n  a = a*2;\r\n\r\n};'),
(5,31,1,'/*\r\nCrie uma função chamada \"absoluto\" que retorna o valor absoluto de um número.\r\n\r\nExemplo:\r\n\r\nabsoluto(-6) = 6\r\nabsoluto(6) = 6\r\nabsoluto(1) = 1\r\nabsoluto(-10) = 10\r\n*/\r\n\r\nint absoluto(int numero1){\r\n\r\n  if (numero1 < 0){\r\n      \r\n  return numero1 * (-1);\r\n  } else {\r\n    return numero1;\r\n  }\r\n}'),
(5,33,1,'/*\r\nCrie um função chamada \"raizQuadrada\" que retorne a raíz quadrada de um número. Essa função deve receber um número do tipo double.\r\n\r\nDica: Use std::sqrt(x) da biblioteca <cmath>\r\n*/\r\n\r\n#include <cmath>\r\n\r\ndouble raizQuadrada(double numero1){\r\n\r\nreturn std::sqrt(numero1);\r\n}'),
(5,34,1,'/*\r\nImplemente uma funçao que calcula a potência de um número inteiro (base^expoente).\r\n\r\nResultado esperado:\r\npotencia(2, 3) = 8\r\n\r\nDica: Use std::pow(base, expoente) da biblioteca <cmath>\r\n*/\r\n\r\n#include <cmath>\r\n\r\ndouble potencia(double numero1, double numero2){\r\n\r\nreturn std::pow(numero1, numero2);\r\n}'),
(5,35,1,'/*\r\nCrie um função chamada \"seno\" que retorne o seno de um ângulo.\r\n\r\nDica: use a função std::sin(x) da biblioteca <cmath>\r\n*/\r\n\r\n#include <cmath>\r\n\r\ndouble seno(double numero1){\r\nreturn std::sin(numero1);\r\n}'),
(5,36,1,'/*\r\nCrie um função chamada \"cosseno\" que retorne o cosseno de um ângulo.\r\n\r\nDica: use a função std::cos(x) da biblioteca <cmath>\r\n*/\r\n\r\n\r\n#include <cmath>\r\n\r\ndouble cosseno(double numero1){\r\nreturn std::cos(numero1);\r\n}'),
(5,37,1,'/*\r\nCrie uma função chamada \"arredondar\" que arredonda um número real para o inteiro mais próximo. \r\n\r\nDica: use a função std::round(x) da biblioteca <cmath>\r\n*/\r\n\r\n#include <cmath>\r\n\r\nint arredondar(float numero1){\r\nreturn std::round(numero1);\r\n}'),
(5,38,1,'/*\r\nEscreva uma função que receba uma palavra e diga quantas letras ela tem.\r\n\r\nO nome da função deve ser \"quantasLetras\" e deve receber 1 argumento do tipo string\r\n\r\n\r\nDica use: std::string e .size() ou .length()\r\n*/\r\n\r\n\r\n#include <string>\r\n\r\nint quantasLetras(std::string palavra1){\r\nreturn palavra1.size();\r\n}'),
(5,41,1,'/*\r\nEscreva uma função \"tudoMaiusculo\" que receba uma palavra e retorne tudo em letras maiúsculas.\r\n\r\nUse: <string> e <algorithm>, função std::transform + ::toupper\r\n\r\nDica: toupper(c) transforma o caractere em maiúscula\r\n\r\ntudoMaiusculo(\"gato\") → \"GATO\"\r\n\r\nSolução:\r\n\r\n#include <string>\r\n#include <algorithm>\r\n\r\nstd::string tudoMaiusculo(std::string palavra) {\r\n    std::transform(palavra.begin(), palavra.end(), palavra.begin(), ::toupper);\r\n    return palavra;\r\n}\r\n*/\r\n\r\n#include <string>\r\n#include <algorithm>\r\n\r\nstd::string tudoMaiusculo(std::string palavra) {\r\n    std::transform(palavra.begin(), palavra.end(), palavra.begin(), ::toupper);\r\n    return palavra;\r\n}'),
(5,42,1,'/*\r\nEscreva uma função que retorna \"true\" se uma palavra começa com a letra \'a\' ou \"false\" caso contrário.\r\n\r\nUse: std::string e palavra[0]\r\n\r\nDica: Verifique se a primeira letra é \'a\' ou \'A\'\r\n\r\ncomecaComA(\"abacate\") → true  \r\ncomecaComA(\"melancia\") → false\r\n\r\n*/\r\n\r\n#include <string>\r\n\r\nbool comecaComA(std::string palavra){\r\n  if (palavra[0]== \'a\' || palavra[0]== \'A\' ){\r\n   return true;\r\n  }\r\n\r\n  return false;\r\n}'),
(5,43,1,'/*\r\nCrie uma classe chamada Pessoa que tem duas propriedades públicas:\r\n\r\n- nome, que guarda o nome da pessoa (tipo string)\r\n- idade, que guarda a idade da pessoa (tipo int)\r\n\r\nUse: palavra-chave class\r\nDica: std::string vem da biblioteca <string>\r\n\r\nExemplo de uso esperado:\r\n\r\nPessoa p;\r\np.nome = \"Ana\";\r\np.idade = 30;\r\n\r\n*/\r\n\r\n#include <string>\r\n#include <iostream>\r\n\r\nclass Pessoa\r\n\r\n{\r\npublic:\r\nstd::string nome;\r\nint idade;\r\n};'),
(5,44,1,'/*\r\nCrie uma classe chamada Pessoa com dois atributos privados:\r\n\r\n-pensamento, do tipo string\r\n-acordada, do tipo bool\r\n\r\nUse: palavras-chave class, public e private.\r\n\r\nCrie métodos públicos\r\ngetPensamento() para retornar o pensamento\r\nsetPensamento(std::string p) para atribuir um pensamento\r\nisAcordada() para retornar o valor da propriedade \"acordada\"\r\nsetAcordada(bool a) para atribuir o valor da propriedade \"acordada\"\r\n\r\n\r\nExemplo de uso esperado:\r\nPessoa p;\r\np.setPensamento(\"Estou com sono\");\r\np.setAcordada(false);\r\nbool valor = p.isAcordada()\r\nstd::string texto = p.getPensamento()\r\n\r\n*/\r\n\r\n#include <string>\r\n#include <iostream>\r\n\r\nclass Pessoa\r\n{\r\nprivate:\r\nstd::string pensamento;\r\nbool acordada;\r\n\r\npublic:\r\n\r\nvoid setPensamento(std::string p){\r\n  pensamento=p;\r\n}\r\n\r\nvoid setAcordada(bool a){\r\n  acordada=a;\r\n}\r\n\r\nstd::string getPensamento(){\r\n  return pensamento;\r\n}\r\n\r\nbool isAcordada(){\r\nreturn acordada;\r\n}\r\n\r\n};'),
(5,45,1,'/*\r\nImplemente uma função que receba um vetor de inteiros e retorne a soma dos elementos pares.\r\n\r\nDica: Use um loop para iterar pelo vetor e uma condição para verificar se o número é par.\r\n\r\nA operação x % 2 == 0 identifica pares. Lembre-se de inicializar soma com zero.\r\n*/\r\n\r\n#include <vector>\r\n#include <iostream>\r\n\r\nint somaPares(std::vector<int> lista){\r\n\r\n  int soma = 0;\r\n  for (int i=0; i < lista.size();i++){\r\n    \r\n    if (lista[i] % 2 == 0){\r\n      soma=soma+lista[i];\r\n    }\r\n  }\r\n \r\nreturn soma;\r\n}\r\n'),
(5,46,1,'/*\r\nImplemente uma função que verifique se uma string é um palíndromo.\r\n\r\nDica: \r\nCompare caracteres simétricos da string usando dois índices.\r\n*/\r\n\r\n#include <string>\r\n\r\nstring palindromo(string word){\r\n  \r\n\r\n  if \r\n\r\n  }\r\n}'),
(6,1,1,'#include <iostream>\n\nint main()\n{\n    std::cout << \"Ola, Mundo!\";\n    return 0;\n}'),
(6,2,1,'#include <iostream>\n\nint main()\n{\n    int a, b;\n    std::cin >> a >> b;\n    std::cout << \"Soma: \" << a + b;\n}'),
(6,3,1,'#include <iostream>\r\nusing namespace std;\r\n\r\nint main()\r\n{\r\n    int a = 5;\r\n    int b = 6;\r\n\r\n    int produto = a * b;\r\n\r\n    cout << \"Produto: \" << produto << endl;\r\n\r\n    return 0;\r\n}'),
(6,4,1,'#include <iostream>\nusing namespace std;\n\nint main()\n{\n    int num1, num2;\n\n    std::cin >> num1;\n    std::cin >> num2;\n\n    if (num1 > num2)\n    {\n        cout << \"Maior: \" << num1;\n    }\n    else\n    {\n        cout << \"Maior: \" << num2;\n    }\n\n    return 0;\n}'),
(6,5,1,'#include <iostream>\n\nint main()\n{\n    int numero;\n\n    std::cin >> numero;\n\n    if (numero % 2 == 0)\n    {\n        std::cout << \"Par\" << std::endl;\n    }\n    else\n    {\n        std::cout << \"Impar\" << std::endl;\n    }\n\n    return 0;\n}'),
(6,6,1,'#include <iostream>\n\nint main()\n{\n    int numeros[5];\n    int soma = 0;\n\n    for (int i = 0; i < 5; ++i)\n    {\n        std::cin >> numeros[i];\n        soma += numeros[i];\n    }\n\n    std::cout << \"Soma: \" << soma ;\n    return 0;\n}'),
(6,7,1,'#include <iostream>\n#include <iomanip>\n\nint main()\n{\n    float num1, num2, num3, num4;\n    float media;\n\n    std::cin >> num1 >> num2 >> num3 >> num4;\n\n    media = (num1 + num2 + num3 + num4) / 4;\n\n    std::cout << std::fixed << std::setprecision(1);\n    std::cout << \"Media: \" << media ;\n\n    return 0;\n}'),
(6,8,1,'#include <iostream>\n\nint soma(int a, int b)\n{\n    return a + b;\n}'),
(6,9,1,'#include <iostream>\n\nint mult(int a, int b)\n{\n  return a * b;  \n}'),
(6,10,1,'#include <iostream>\nusing namespace std;\n\nvoid trocar(int& a, int& b)\n{\n    int temp = a;\n    a = b;\n    b = temp;\n}\n\nint main()\n{\n    int x = 3, y = 5;\n    trocar(x, y);\n    cout << \"x = \" << x << \", y = \" << y ;\n    return 0;\n}'),
(6,11,1,'#include <iostream>\n#include <vector>\n\nstd::vector<int> criaVetor()\n{\n    return {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};\n}\n\nint main()\n{\n    std::vector<int> meuVetor = criaVetor();\n\n    for (int valor : meuVetor)\n    {\n        std::cout << valor << \" \";\n    }\n    std::cout << std::endl;\n\n    return 0;\n}'),
(6,12,1,'#include <vector>\nstd::vector<float> notas = {5, 10, 2};\nfloat primeiraNota (){\n    return notas[0];\n}'),
(6,13,1,'#include <iostream>\n\nint maior(int a, int b, int c)\n{\n    if (a >= b && a >= c)\n    {\n        return a;\n    } else if (b >= a && b >= c)\n    {\n        return b;\n    } \n    else\n    {\n        return c;\n    }\n}\n\nint main() {\n    int x, z, y;\n\n    std::cin >> x >> y >> z;\n\n    std::cout << \"maior: \" << maior(x, y, z) ;\n\n    return 0;\n}'),
(7,1,1,'#include <iostream>\r\nint main(){ \r\n    std::cout << \"Ola, Mundo!\";\r\n    return 0;\r\n}\r\n '),
(7,2,1,'#include <iostream>\r\nint main(){ \r\n    float a;\r\n    float b;\r\n    std::cin >> a;\r\n    std:: cin >> b;\r\n    std::cout << \"Soma: \" << a + b;\r\n    return 0;\r\n}'),
(7,3,1,'#include <iostream>\r\nint main(){ \r\n    float a;\r\n    float b;\r\n    std::cin >> a;\r\n    std:: cin >> b;\r\n    std::cout << \"Produto: \" << a * b;\r\n    return 0;\r\n}'),
(7,4,1,'#include <iostream>\r\nint main(){ \r\n    float a;\r\n    float b;\r\n    std::cin >> a;\r\n    std::cin >> b;\r\n    \r\n    if(a>b){\r\n       std::cout << \"Maior: \" << a;\r\n    }else{\r\n        std::cout << \"Maior: \" << b;\r\n    }\r\n    return 0;\r\n}'),
(7,5,1,'#include <iostream>\r\n\r\nint main(){\r\n    int a;\r\n\r\n  std::cin >> a;\r\n\r\n  if(a%2==0){\r\n    std::cout <<\"Par\";\r\n  }else{\r\n    std::cout << \"Impar\";\r\n  }\r\n\r\n    return 0;\r\n}'),
(7,6,1,'#include <iostream>\r\n\r\n#include<vector>\r\nint main(){\r\n \r\n std::vector<int> lista;\r\n\r\n    for(int i=0; i<5;i++){\r\n        int numero;\r\n        std::cin >> numero;\r\n        lista.push_back(numero);\r\n    }\r\n    int soma = 0;\r\n    for(int i=0; i < 5; i++){\r\n       soma = soma + lista[i];\r\n    }\r\n    std::cout << \"Soma: \" << soma;\r\n\r\n    return 0;\r\n}\r\n'),
(7,7,1,'#include <iostream>\r\n#include <iomanip>\r\n#include<vector>\r\nint main(){\r\n \r\n std::vector<float> lista;\r\n\r\n    for(int i=0; i<4;i++){\r\n        float numero;\r\n        std::cin >> numero;\r\n        lista.push_back(numero);\r\n    }\r\n\r\n    float media = 0;\r\n    for(int i=0; i < 4; i++){\r\n         media = media + lista[i];\r\n    }\r\n\r\n\r\n    std::cout << std::fixed << std::setprecision(1);\r\n    std::cout << \"Media: \" << media / 4;\r\n\r\n    return 0;\r\n}'),
(7,8,1,'/*\r\nImplemente uma função que recebe dois inteiros e retorna a soma deles.\r\n\r\nResultado esperado:\r\nsoma(3, 4) = 7\r\n\r\nDica: Defina a função antes do main.\r\n*/\r\nint soma (int a, int b){\r\n    int resultado= a+b;\r\n    return resultado;\r\n}'),
(7,9,1,'/*\r\nImplemente uma função que recebe dois inteiros e retorna a multiplicação deles.\r\n\r\nResultado esperado:\r\nmult(3, 4) = 12\r\n\r\nDica: Defina a função antes do main.\r\n*/\r\n\r\nint mult(int ValorUm, int ValorDois){\r\n  return  ValorUm * ValorDois;\r\n}'),
(7,10,1,'void troca(int &x, int &y){\r\n    int temp = x;\r\n    x=y;\r\n    y=temp;\r\n}'),
(7,11,1,'\r\n\r\n#include <vector>\r\n\r\nstd::vector<int> criaVetor(){\r\n \r\n    // Cria a lista\r\n    std::vector<int> lista;\r\n\r\n    // Adiciona 1 item na lista\r\n    lista.push_back(90);\r\n    lista.push_back(7);\r\n    lista.push_back(8);\r\n    lista.push_back(5);\r\n    lista.push_back(10);\r\n    lista.push_back(56);\r\n    lista.push_back(43);\r\n    lista.push_back(32);\r\n    lista.push_back(78);\r\n    lista.push_back(67);\r\n\r\n    return lista;\r\n }'),
(7,12,1,'/*\r\nCrie um vetor chamado \"notas\":\r\nstd::vector<float> notas = {5, 10, 2};\r\n\r\nDepois crie um função chamada \"primeiraNota\" que retorna a primeira nota.\r\n*/\r\n#include<vector>\r\n\r\nstd::vector <float> notas ={5,10,2};\r\n\r\nfloat primeiraNota(){\r\n \r\nreturn notas[0];\r\n    \r\n}\r\n\r\n'),
(7,13,1,'/*\r\nImplemente uma funçao que retorna o maior de três números inteiros.\r\n\r\nResultado esperado:\r\nmaximo(3, 7, 5) = 7\r\n\r\nDica: \r\nUse if/else ou \r\nuse std::max com #include <algorithm>\r\n*/\r\nint maximo(int a, int b, int c){\r\n    int m;\r\n    if(a-b<0){\r\n        m = b;\r\n    }else{\r\n        m =a;\r\n    }\r\n    if(m - c>0){\r\n         return m;\r\n    }else{\r\n        return c;\r\n    }\r\n}'),
(7,14,1,'/*\r\nCrie um vetor chamado \"notas\":\r\nstd::vector<float> notas = {5, 10, 2};\r\n\r\nDepois crie um função chamada \"outrasNotas\" que retorna as duas últimas notas.\r\n\r\nDica: Use o método size() do vetor, o mesmo retorna o quantidade de itens do vetor:\r\n\r\nstd::vector<float> teste = {5, 6, 1, 2, 13, 50};\r\n\r\nint tamanho = teste.size();\r\n\r\n// tamanho será igual a 6\r\n*/\r\n#include<vector>\r\n\r\nstd::vector <float> notas ={5,10,2};\r\n\r\nfloat outrasNotas(){\r\n \r\nreturn notas[-2];\r\n}  '),
(7,19,1,'/*\r\nCrie um vetor chamado \"notas\":\r\nstd::vector<float> notas = {5, 10, 2};\r\n\r\nDepois crie um função chamada \"outrasNotas\" que retorna as duas últimas notas.\r\n\r\nDica: Use o método size() do vetor, o mesmo retorna o quantidade de itens do vetor:\r\n\r\nstd::vector<float> teste = {5, 6, 1, 2, 13, 50};\r\n\r\nint tamanho = teste.size();\r\n\r\n// tamanho será igual a 6\r\n*/\r\n#include<vector>\r\n\r\nstd::vector <float> notas ={5,10,2};\r\n\r\nfloat outrasNotas(){\r\n \r\nreturn notas[-2];\r\n}  '),
(8,1,1,'#include <iostream> \n\n\nint main()\n{\nstd::cout <<\"Ola, Mundo!\";\nreturn 0;\n}\n'),
(8,2,1,'#include <iostream>\n\nint main() {\n    int numero1, NUMERO2;\nint soma;\n\n\n    std::cin >> numero1 >> NUMERO2;\n    std::cout << \"Soma: \" << numero1 + NUMERO2;\n\n    return 0;\n}'),
(8,3,1,'\n#include <iostream>\n\nint main() {\n    int numero1, NUMERO2;\n\n    std::cin >> numero1 >> NUMERO2;\n    std::cout << \"Produto: \"<< numero1 * NUMERO2 << std::endl;\n\n    return 0;\n}'),
(8,4,1,'#include <iostream>\n\nint main() {\n    int numero1, NUMERO2;\n    std::cin >> numero1 >> NUMERO2;\n\n    if (numero1 > NUMERO2) {\n        std::cout << numero1 << std::endl;\n    } else {\n        std::cout <<\"Maior: \" << NUMERO2 << std::endl;\n    }\n\n    return 0;\n}'),
(8,5,1,'#include <iostream>\n\nint main(){\n    int numero;\n\n    std::cin >> numero; \n\nif (numero % 2 == 0 )\n{\nstd::cout << \"Par\" << std::endl; \n} else {\nstd::cout << \"Impar\" <<  std::endl; \n}\n\nreturn 0;\n}\n\n\n'),
(8,6,1,'#include <vector>\n#include <iostream>\nint main () {\n  \n  std::vector <int> Numeros;\n  \n  for(int i = 0; i <5; i++){\n    int numeros2;\n    std::cin>> numeros2;\n    Numeros.push_back(numeros2);\n  }\n  int soma = 0;\n  \n  for(int i=0; i <5; i++){\n    soma= soma + Numeros [i];\n  }\n  \n  std::cout << \"Soma: \" << soma;\n  \n}'),
(8,7,1,'#include <iostream>\n#include <iomanip>\n\n\nfloat n1,n2,n3,n4;\nfloat media;\n\nint main() {\nstd::cin >> n1;\nstd::cin >> n2;\nstd::cin >> n3;\nstd::cin >> n4;\nmedia = (n1 + n2 + n3 + n4)/4;\nstd::cout << std::fixed << std::setprecision(1);\nstd::cout << \"Media: \" << media;\n\nreturn 0;\n}'),
(8,8,1,'#include <iostream>\n#include <iomanip>\n\nint main() \n{\n  int n1,n2;\n  int soma\n\n  std::cin >> n1;\n  std::cin >> n2;\n \n  int soma = n1+n2;\n\n  std::cout << \"soma\" << soma <<endl;\n\nreturn 0;\n}'),
(8,9,1,'int mult (int n1, int n2){\n\nint resultado;\n\nresultado = n1 * n2;\n\n\nreturn resultado;\n\n\n}'),
(8,10,1,'#include <iostream>\n\nvoid troca(int& a, int& b) {\n    int temp = a;\n    a = b;\n    b = temp;\n}\n\n'),
(8,11,1,'\n#include <iostream>\n#include <vector>\n\nstd::vector<int> criaVetor() {\n    return {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};\n}'),
(8,12,1,'#include <iostream>\n#include <vector>\nstd::vector<float>notas = {5,10,2};\n\nfloat primeiraNota(){\n    float c = notas[0];\n    return c;\n}'),
(8,13,1,'#include <iostream>\n#include <algorithm>\n\nint main(int num1,int num2, int num3) {\n\n  int maior = std::max({num1, num2, num3});\n\n  return 0;\n}'),
(9,1,1,'#include <iostream>\r\n\r\nint main(){\r\n    std::cout << \"Ola, Mundo!\";\r\n    return 0;\r\n}'),
(9,2,1,'#include <iostream>\r\n\r\nint main(){\r\n    int a, b;\r\n    std::cin >> a >> b;\r\n    std::cout << \"Soma: \" << a + b;\r\n}\r\n'),
(9,3,1,'#include <iostream>\r\n\r\nint main(){\r\n    int a, b;\r\n    std::cin >> a >> b;\r\n    std::cout << \"Produto: \" << a * b;\r\n}\r\n'),
(9,4,1,'#include <iostream>\r\n\r\nint main(){\r\n    int a, b;\r\n    std::cin >> a >> b;\r\n    std::cout << \"Maior: \";\r\n    if(a > b){\r\n        std::cout << a;\r\n    }else{\r\n        std::cout << b;\r\n    }\r\n    return 0;\r\n}'),
(9,5,1,'#include <iostream>\r\n\r\nint main(){\r\n    int a;\r\n    std::cin >> a;\r\n    if(a % 2 == 0){\r\n        std::cout << \"Par\";\r\n    }else{\r\n        std::cout << \"Impar\";\r\n    }\r\n    return 0;\r\n}'),
(9,6,1,'#include <iostream>\r\nint main ()\r\n{\r\n    int numeros[5];\r\n    int soma = 0;\r\n\r\n    for (int i = 0; i < 5; i++)\r\n    {\r\n        std::cin >> numeros[i];\r\n        soma += numeros[i];\r\n    }\r\n\r\n    std::cout << \"Soma: \" << soma;\r\n\r\n    return 0;\r\n\r\n}\r\n'),
(9,7,1,'#include <iostream>\r\n#include <iomanip>\r\nint main ()\r\n{\r\n    float numeros[4];\r\n    float soma = 0;\r\n\r\n    for (int i = 0; i < 4; i++)\r\n    {\r\n        std::cin >> numeros[i];\r\n        soma += numeros[i];\r\n    }\r\n\r\n    float media = soma/4;\r\n\r\n\r\n    std::cout << std::fixed << std::setprecision(1);\r\n\r\n    std::cout << \"Media: \" << media;\r\n\r\n    return 0;\r\n    \r\n}'),
(9,8,1,'int soma(int a,int b)\r\n{\r\n    return a + b;\r\n\r\n}'),
(9,9,1,'int mult(int a, int b)\r\n{   \r\n    return a * b;\r\n    \r\n}'),
(9,10,1,'void troca(int &a, int &b){\r\n    int temp =b;\r\n    b = a;\r\n    a = temp;\r\n}\r\n'),
(9,11,1,'#include <iostream>\r\n#include <vector>\r\n\r\nstd::vector<int> criaVetor()\r\n{ \r\n  std::vector<int> numeros = {5, 7, 9, 5, 3, 2, 1, 10, 73, 12}; \r\n  return numeros;\r\n}'),
(9,12,1,'#include <iostream>\r\n#include <vector>\r\n\r\nstd::vector <float> notas = {5,10,2}\r\nreturn \r\n\r\n'),
(10,1,1,'#include <iostream>\r\nint main(){\r\n    std::cout << \"Ola, Mundo!\";\r\n    return 0;\r\n}'),
(10,2,1,'#include <iostream>\r\nint main(){\r\n    int a, b;\r\n    std::cin >> a >> b;\r\n    std::cout << \"Soma: \" << a + b;\r\n    return 0;\r\n}'),
(10,3,1,'#include <iostream>\r\nint main(){\r\n    int a, b;\r\n    std::cin >> a >> b;\r\n    std::cout << \"Produto: \" << a * b;\r\n    return 0;\r\n}'),
(10,4,1,'/*\r\nLeia dois números inteiros e imprima o maior deles.\r\n\r\nResultado esperado (exemplo):\r\nDigite dois números: 8 12\r\nMaior: 12\r\n\r\nDica: Use if/else para comparar.\r\n*/\r\n#include <iostream>\r\nint main()\r\n{\r\n    int A;\r\n    int B;\r\n    std::cin >> A;\r\n    std::cin >> B;\r\n    if (A > B ){\r\n    std::cout << \"Maior: \" << A;\r\n    }else{\r\n        std::cout << \"Maior: \" << B;\r\n    }\r\n    return 0;\r\n}\r\n'),
(10,5,1,'#include <iostream>\r\n\r\nint main(){\r\n    int a;\r\n    std::cin >> a;\r\n    if(a % 2 == 0){\r\n        std::cout << \"Par\";\r\n    }else{\r\n        std::cout << \"Impar\";\r\n    }\r\n    return 0;\r\n}'),
(10,6,1,'/*\r\nLeia 5 números inteiros em um vetor e imprima a soma deles.\r\n\r\nResultado esperado (exemplo):\r\nDigite 5 números: 1 2 3 4 5\r\nSoma: 15\r\n\r\nDica: Use um loop for para ler e somar.\r\n*/\r\n#include <iostream>\r\n#include <vector>\r\nint main(){\r\n    int soma = 0;\r\n    std::vector <int> lista;\r\n\r\n    for(int i=0; i < 5; i++)\r\n    {\r\n        int item;\r\n        std::cin >> item;\r\n        lista.push_back(item);\r\n    }\r\n    for(int i=0; i < 5; i++)\r\n    {\r\n        soma = soma + lista [i];\r\n    }\r\n    std::cout << \"Soma: \" << soma;\r\n    return 0;\r\n}'),
(10,7,1,'/*\r\nLeia 4 números reais e imprima a media deles.\r\n\r\nResultado esperado (exemplo):\r\nNúmeros: 2.0 4.0 6.0 8.0\r\nMedia: 5.0\r\n\r\nDica: \r\n- Use a biblioteca #include <iomanip>\r\n- Para alterar a quantidade de casas decimais para 1 no cout use:\r\n  - std::cout << std::fixed << std::setprecision(1);\r\n*/\r\n#include <iostream>\r\n#include <vector>\r\n#include <iomanip>\r\n\r\nint main(){\r\n    float soma = 0;\r\n    std::vector <float> lista;\r\n\r\n    for(int i=0; i < 4; i++)\r\n    {\r\n        float item;\r\n        std::cin >> item;\r\n        lista.push_back(item);\r\n    }\r\n\r\n    for(int i=0; i <4; i++)\r\n    {\r\n        soma = soma + lista [i];\r\n    }\r\n    std::cout << std::fixed << std::setprecision(1);\r\n    std::cout << \"Media: \" << (soma / 4.0);\r\n    return 0;\r\n}'),
(10,8,1,'int soma(int a, int b){\r\n    return a + b;\r\n}'),
(10,9,1,'int mult( int a, int b){\r\n    return a * b;\r\n}'),
(10,10,1,'void troca(int &a, int &b){\r\n    int temp = b;\r\n    b = a;\r\n    a = temp;\r\n}'),
(10,11,1,'#include <vector>\r\n\r\nstd::vector<int> criaVetor() {\r\n    return {3, 7, 1,4, 9, 2, 8, 0, 6, 5};\r\n}'),
(10,12,1,'#include <vector>\r\n\r\nstd::vector<float> notas = {5.0f, 10.0f, 2.0f};\r\nfloat primeiraNota() {\r\n    return notas.front();\r\n\r\n}'),
(10,13,1,'#include <algorithm>\r\nint maximo(int a,int b, int c){\r\n    int maior = std::max(a, b);\r\n    return std::max(maior, c);\r\n}'),
(10,14,1,'#include <vector>\r\n\r\nstd::vector<float> notas = {5, 10, 2};\r\n\r\nstd::vector<float> outrasNotas() {\r\n    std::vector<float> resultado;\r\n    for (size_t i = 1 ; i < notas.size(); ++i){\r\n        resultado.push_back(notas[i]);\r\n    }\r\n    return resultado;\r\n}'),
(10,19,1,'int potencia(int base, int expoente) {\r\n    int resultado = 1 ;\r\n    for (int i = 0; i < expoente; ++i) {\r\n        resultado *= base;\r\n    }\r\n    return resultado\r\n}'),
(10,20,1,'/*\r\nImplemente uma funçao que dobra o valor de um inteiro passado por referência.\r\n\r\nResultado esperado:\r\nint a = 2;\r\n\r\ndobra(a);\r\n\r\na = 4\r\n\r\nDica: Use & no parâmetro.\r\n*/\r\nvoid dobra(int& valor) {\r\n    valor *= 2;\r\n}'),
(10,31,1,'/*\r\nCrie uma função chamada \"absoluto\" que retorna o valor absoluto de um número.\r\n\r\nExemplo:\r\n\r\nabsoluto(-6) = 6\r\nabsoluto(6) = 6\r\nabsoluto(1) = 1\r\nabsoluto(-10) = 10\r\n*/\r\nint absoluto(int x){\r\n    return (x < 0) ? -x : x;\r\n}'),
(10,33,1,'/*\r\nCrie um função chamada \"raizQuadrada\" que retorne a raíz quadrada de um número. Essa função deve receber um número do tipo double.\r\n\r\nDica: Use std::sqrt(x) da biblioteca <cmath>\r\n*/\r\n#include <cmath>\r\ndouble raizQuadrada(double x){\r\n    return std::sqrt(x);\r\n}'),
(10,34,1,'/*\r\nImplemente uma funçao que calcula a potência de um número inteiro (base^expoente).\r\n\r\nResultado esperado:\r\npotencia(2, 3) = 8\r\n\r\nDica: Use std::pow(base, expoente) da biblioteca <cmath>\r\n*/\r\n#include <cmath>\r\ndouble potencia(double base, double expoente){\r\n    return std::pow(base, expoente);\r\n}'),
(10,35,1,'/*\r\nCrie um função chamada \"seno\" que retorne o seno de um ângulo.\r\n*/\r\n#include <cmath>\r\ndouble seno(double radianos){\r\n    return std::sin(radianos);\r\n}'),
(10,36,1,'/*\r\nCrie um função chamada \"cosseno\" que retorne o cosseno de um ângulo.\r\n*/\r\n#include <cmath>\r\ndouble cosseno(double radianos){\r\n    return std::cos(radianos);\r\n}'),
(10,37,1,'/*\r\nCrie uma função chamada \"arredondar\" que arredonda um número real para o inteiro mais próximo. \r\n*/\r\n#include <cmath>\r\nint arredondar(double x){\r\n    return std::round(x);\r\n}'),
(10,38,1,'/*\r\nEscreva uma função que receba uma palavra e diga quantas letras ela tem.\r\n\r\nUse: std::string e .size() ou .length()\r\n\r\nDica: std::string palavra = \"cachorro\";\r\n*/\r\n#include <string>\r\nint quantasLetras(const std::string& palavra){\r\n    return palavra.size();\r\n}'),
(10,41,1,'/*\r\nEscreva uma função \"tudoMaiusculo\" que receba uma palavra e retorne tudo em letras maiúsculas.\r\n\r\nUse: <string> e <algorithm>, função std::transform + ::toupper\r\n\r\nDica: toupper(c) transforma o caractere em maiúscula\r\n\r\ntudoMaiusculo(\"gato\") → \"GATO\"\r\n\r\nSolução:\r\n\r\n#include <string>\r\n#include <algorithm>\r\n\r\nstd::string tudoMaiusculo(std::string palavra) {\r\n    std::transform(palavra.begin(), palavra.end(), palavra.begin(), ::toupper);\r\n    return palavra;\r\n}\r\n*/\r\n#include <string>\r\n#include <algorithm>\r\n\r\nstd::string tudoMaiusculo(std::string palavra) {\r\n    std::transform(palavra.begin(), palavra.end(), palavra.begin(), ::toupper);\r\n    return palavra;\r\n}'),
(10,42,1,'/*\r\nEscreva uma função que retorna \"true\" se uma palavra começa com a letra \'a\' ou \"false\" caso contrário.\r\n\r\nUse: std::string e palavra[0]\r\n\r\nDica: Verifique se a primeira letra é \'a\' ou \'A\'\r\n\r\ncomecaComA(\"abacate\") → true  \r\ncomecaComA(\"melancia\") → false\r\n\r\n*/\r\n#include <string>\r\nbool comecaComA(const std::string& palavra){\r\n    return !palavra.empty() && (palavra[0] == \'a\' || palavra[0] == \'A\');\r\n}'),
(10,43,1,'/*\r\nCrie uma classe chamada Pessoa que tem duas propriedades públicas:\r\n\r\n- nome, que guarda o nome da pessoa (tipo string)\r\n- idade, que guarda a idade da pessoa (tipo int)\r\n\r\nUse: palavra-chave class\r\nDica: std::string vem da biblioteca <string>\r\n\r\nExemplo de uso esperado:\r\n\r\nPessoa p;\r\np.nome = \"Ana\";\r\np.idade = 30;\r\n\r\n*/\r\n#include <string>\r\nclass Pessoa {\r\n    public:\r\n    std::string nome;\r\n    int idade;\r\n};'),
(10,44,1,'#include <iostream>\r\n#include <string>\r\nusing namespace std;\r\n\r\nclass Pessoa {\r\nprivate:\r\n    string pensamento;\r\n    bool acordada;\r\n\r\npublic:\r\n    // Define o pensamento\r\n    void setPensamento(string p) {\r\n        pensamento = p;\r\n    }\r\n\r\n    // Retorna o pensamento\r\n    string getPensamento() {\r\n        return pensamento;\r\n    }\r\n\r\n    // Define o estado acordada\r\n    void setAcordada(bool a) {\r\n        acordada = a;\r\n    }\r\n\r\n    // Retorna o estado acordada\r\n    bool getAcordada() {\r\n        return acordada;\r\n    }\r\n};\r\n\r\n// Exemplo de uso\r\nint main() {\r\n    Pessoa p;\r\n    p.setPensamento(\"Estou com sono\");\r\n    p.setAcordada(false);\r\n\r\n    cout << \"Pensamento: \" << p.getPensamento() << endl;\r\n    cout << \"Está acordada? \" << (p.getAcordada() ? \"Sim\" : \"Não\") << endl;\r\n\r\n    return 0;\r\n}'),
(10,45,1,'#include <iostream>\r\n#include <vector>\r\nusing namespace std;\r\n\r\n// Função que soma os elementos pares de um vetor\r\nint somaPares(const vector<int>& vetor) {\r\n    int soma = 0;\r\n\r\n    for (int x : vetor) {\r\n        if (x % 2 == 0) {\r\n            soma += x;\r\n        }\r\n    }\r\n\r\n    return soma;\r\n}\r\n\r\n// Exemplo de uso\r\nint main() {\r\n    vector<int> numeros = {1, 2, 3, 4, 5, 6};\r\n\r\n    int resultado = somaPares(numeros);\r\n\r\n    cout << \"Soma dos pares: \" << resultado << endl;\r\n\r\n    return 0;\r\n}\r\n'),
(10,46,1,'#include <iostream>\r\n#include <string>\r\nusing namespace std;\r\n\r\n// Função que verifica se uma string é um palíndromo\r\nbool ehPalindromo(const string& texto) {\r\n    int inicio = 0;\r\n    int fim = texto.length() - 1;\r\n\r\n    while (inicio < fim) {\r\n        if (texto[inicio] != texto[fim]) {\r\n            return false; // Não é palíndromo\r\n        }\r\n        inicio++;\r\n        fim--;\r\n    }\r\n\r\n    return true; // É palíndromo\r\n}\r\n\r\n// Exemplo de uso\r\nint main() {\r\n    string palavra;\r\n\r\n    cout << \"Digite uma palavra: \";\r\n    cin >> palavra;\r\n\r\n    if (ehPalindromo(palavra)) {\r\n        cout << \"É um palíndromo!\" << endl;\r\n    } else {\r\n        cout << \"Não é um palíndromo.\" << endl;\r\n    }\r\n\r\n    return 0;\r\n}\r\n'),
(10,47,1,'/*\r\nImplemente uma função que conte o número de vogais em uma string.\r\n\r\nDica: Considere letras maiúsculas e minúsculas.\r\n\r\nA função strchr é útil para verificar se um caractere está em uma lista de vogais.\r\n*/\r\n#include <iostream>\r\n#include <string>\r\n\r\nint contar_vogais(const std::string& str) {\r\n    const std::string vogais = \"aeiouAEIOU\";\r\n    int contador = 0;\r\n\r\n    for (char c : str) {\r\n        if (vogais.find(c) != std::string::npos) {\r\n            contador++;\r\n        }\r\n    }\r\n\r\n    return contador;\r\n}\r\n\r\nint main() {\r\n    std::string texto = \"Exemplo de String com Vogais\";\r\n    int total = contar_vogais(texto);\r\n    std::cout << \"Número de vogais: \" << total << std::endl;\r\n    return 0;\r\n}'),
(10,48,1,'/*\r\nImplemente uma função que calcule a soma dos dígitos de um número inteiro positivo.\r\n\r\nDica: Use divisão e módulo para extrair os dígitos.\r\n\r\nFunciona mesmo com números grandes se a entrada for positiva.\r\n\r\n*/\r\n#include <iostream>\r\n\r\nint soma_digitos(unsigned long long numero) {\r\n    int soma = 0;\r\n\r\n    while (numero > 0) {\r\n        soma += numero % 10;     // Pega o último dígito\r\n        numero /= 10;            // Remove o último dígito\r\n    }\r\n\r\n    return soma;\r\n}\r\n\r\nint main() {\r\n    unsigned long long numero;\r\n    std::cout << \"Digite um número inteiro positivo: \";\r\n    std::cin >> numero;\r\n\r\n    int resultado = soma_digitos(numero);\r\n    std::cout << \"Soma dos dígitos: \" << resultado << std::endl;\r\n\r\n    return 0;\r\n}'),
(10,49,1,'/*\r\nImplemente uma função que inverta os caracteres de uma string. Não modifique a string original; retorne uma nova.\r\n\r\nDica: (Opcional) Use rbegin() e rend() para criar uma nova string invertida.\r\n*/\r\n#include <iostream>\r\n#include <string>\r\nstd::string inverterString(const std::string& original) {\r\n    \r\n    std::string invertida(original.rbegin(), original.rend());\r\n    return invertida;\r\n}\r\n\r\nint main() {\r\n    std::string texto = \"Exemplo\";\r\n    std::string textoInvertido = inverterString(texto);\r\n\r\n    std::cout << \"Original: \" << texto << std::endl;\r\n    std::cout << \"Invertida: \" << textoInvertido << std::endl;\r\n\r\n    return 0;\r\n}\r\n'),
(10,50,1,'/*\r\nImplemente uma função que retorne o n-ésimo número da sequência de Fibonacci.\r\n\r\nDica: Comece com os dois primeiros termos da sequência.\r\n\r\n*/\r\n#include <iostream>\r\nusing namespace std;\r\n\r\nint fibonacci(int n) {\r\n    if (n == 0)\r\n        return 0;\r\n    else if (n == 1)\r\n        return 1;\r\n\r\n    int a = 0, b = 1, resultado;\r\n    for (int i = 2; i <= n; ++i) {\r\n        resultado = a + b;\r\n        a = b;\r\n        b = resultado;\r\n    }\r\n    return b;\r\n}\r\n\r\nint main() {\r\n    int n = 7;  // índice que retorna 13\r\n    cout << \"O \" << n << \"º número da sequência de Fibonacci é: \" << fibonacci(n) << endl;\r\n    return 0;\r\n}\r\n'),
(10,51,1,'/*\r\nImplemente uma função que receba um vetor de double e retorne a média aritmética. Retorne 0.0 se o vetor estiver vazio.\r\n\r\nDica: Lembre-se de evitar divisão por zero.\r\n\r\n*/\r\n#include <iostream>\r\n#include <vector>\r\n\r\ndouble mediaAritmetica(const std::vector<double>& valores) {\r\n    if (valores.empty()) {\r\n        return 0.0;  // evita divisão por zero\r\n    }\r\n\r\n    double soma = 0.0;\r\n    for (double v : valores) {\r\n        soma += v;\r\n    }\r\n\r\n    return soma / valores.size();\r\n}\r\n\r\nint main() {\r\n    std::vector<double> dados = {1.5, 2.5, 3.0, 4.0};\r\n    std::cout << \"Média: \" << mediaAritmetica(dados) << std::endl;\r\n\r\n    std::vector<double> vazio;\r\n    std::cout << \"Média vetor vazio: \" << mediaAritmetica(vazio) << std::endl;\r\n\r\n    return 0;\r\n}\r\n'),
(10,52,1,'/*\r\nImplemente uma função que calcule o fatorial de um número inteiro positivo usando laço (mais conhecido com loop).\r\n\r\nDica:\r\nUse um laço de 2 até n.\r\n0! = 1 por definição.\r\n*/\r\n#include <iostream>\r\nusing namespace std;\r\n\r\nint fatorial(int n) {\r\n    if (n == 0) return 1; // 0! = 1 por definição\r\n    \r\n    int resultado = 1;\r\n    for (int i = 2; i <= n; i++) {\r\n        resultado *= i;\r\n    }\r\n    return resultado;\r\n}\r\n\r\nint main() {\r\n    int num;\r\n    cout << \"Digite um número inteiro positivo: \";\r\n    cin >> num;\r\n\r\n    if (num < 0) {\r\n        cout << \"Número inválido. Digite um inteiro positivo.\" << endl;\r\n    } else {\r\n        cout << \"Fatorial de \" << num << \" = \" << fatorial(num) << endl;\r\n    }\r\n\r\n    return 0;\r\n}\r\n'),
(10,53,1,'/*\r\nDada uma string e um caractere, conte quantas vezes esse caractere aparece na string.\r\n\r\n\r\nDica: (Opcional) Use std::count da biblioteca algorithm.\r\n\r\n*/\r\n#include <iostream>\r\n#include <string>\r\n#include <algorithm>  // para std::count\r\n\r\nint contaCaractere(const std::string& texto, char c) {\r\n    return std::count(texto.begin(), texto.end(), c);\r\n}\r\n\r\nint main() {\r\n    std::string frase = \"exemplo de contagem\";\r\n    char letra = \'e\';\r\n\r\n    int vezes = contaCaractere(frase, letra);\r\n    std::cout << \"O caractere \'\" << letra << \"\' aparece \" << vezes << \" vezes.\" << std::endl;\r\n\r\n    return 0;\r\n}\r\n'),
(10,54,1,'/*\r\nCrie uma função que retorna verdadeiro se uma string contém apenas caracteres numéricos. String vazia deve retornar true.\r\n\r\nDica: Use std::all_of com isdigit da biblioteca algorithm\r\n*/\r\n#include <iostream>\r\n#include <string>\r\n#include <algorithm>  // para std::all_of\r\n#include <cctype>     // para isdigit\r\n\r\nbool somenteNumeros(const std::string& str) {\r\n    return std::all_of(str.begin(), str.end(), [](unsigned char c) {\r\n        return std::isdigit(c);\r\n    });\r\n}\r\n\r\nint main() {\r\n    std::string s1 = \"123456\";\r\n    std::string s2 = \"12a34\";\r\n    std::string s3 = \"\";\r\n\r\n    std::cout << std::boolalpha;\r\n    std::cout << \"s1: \" << somenteNumeros(s1) << std::endl;  // true\r\n    std::cout << \"s2: \" << somenteNumeros(s2) << std::endl;  // false\r\n    std::cout << \"s3: \" << somenteNumeros(s3) << std::endl;  // true (vazia)\r\n\r\n    return 0;\r\n}\r\n'),
(10,55,1,'/*\r\nImplemente uma função que inverte um vetor de inteiros. Vetores vazios ou de um elemento devem ser tratados corretamente\r\n\r\nDica: (Opcional) Use std::reverse\r\n*/\r\n#include <iostream>\r\n#include <vector>\r\n#include <algorithm>  // para std::reverse\r\n\r\nvoid inverteVetor(std::vector<int>& v) {\r\n    std::reverse(v.begin(), v.end());\r\n}\r\n\r\nint main() {\r\n    std::vector<int> v = {1, 2, 3, 4, 5};\r\n    inverteVetor(v);\r\n\r\n    for (int num : v) {\r\n        std::cout << num << \" \";\r\n    }\r\n    std::cout << std::endl;\r\n\r\n    return 0;\r\n}\r\n'),
(11,1,1,'#include <iostream>\n\nint main(){\n    std::cout <<\"Ola, Mundo!\";\n    return 0;\n\n}'),
(11,2,1,'#include <iostream>\nint main(){\n    int Banred, Lenda;\n\n    std::cin >> Banred >> Lenda;\n\n   std::cout <<\"Soma: \" << Banred + Lenda;\n\n    return 0;\n}'),
(11,3,1,'#include <iostream>\nint main(){\n    int Banred, Lenda;\n\n    std::cin >> Banred >> Lenda;\n\n   std::cout <<\"Produto: \" << Banred * Lenda;\n\n    return 0;\n}'),
(11,4,1,'#include <iostream>\nint main(){\n    int Banred, Lenda;\n\n    std::cin >> Banred >> Lenda;\n    std::cout <<\"Maior: \";\n   if(Banred > Lenda){\n    std::cout << Banred;\n   }else{\n    std::cout <<Lenda;\n   }\n\n    return 0;\n}'),
(11,5,1,'#include <iostream>\nint main(){\n    int Banred;\n\n    std::cin >> Banred;\n   if(Banred % 2 == 0){\n    std::cout << \"Par\";\n   }else{\n    std::cout << \"Impar\";\n   }\n\n    return 0;\n}'),
(11,6,1,'#include <iostream>\n#include <iomanip>\n\nint main(){\n    \n    std::vector<int> lista;\n\n    for(int i = 0, i < 5; i++){\n        int item;\n        std::cin >> item;\n        lista.push_back(item);\n    }\n\n    int soma = 0;\n    for(int i = 0, i < 5; i++){\n        soma = soma + lista[i];\n        \n    }\n\n    std::cout << \"Soma: \" << soma << std::endl;\n    return 0;\n}'),
(11,7,1,'#include <iostream>\n#include <iomanip>\n\nint main(){\n    double soma = 0, num;\n\n    for (int i = 0; i < 4; i++) {\n        std::cin >> num;\n        soma += num;\n    }\n\n    double media = soma / 4;\n    \n    std::cout << std::fixed << std::setprecision(1);\n    std::cout << \"Media: \" << media << std::endl;\n\n    return 0;\n}'),
(11,11,1,'#include <vector>\r\n\r\nstd::vector<int> criaVetor() {\r\n    std::vector<int> vetor = {5, 12, 7, 3, 19, 8, 1, 25, 14, 6};\r\n    return vetor;\r\n}'),
(11,12,1,'#include <iostream>\r\n#include <vector>\r\nstd::vector<float> notas = {5, 10, 2};\r\nfloat primeiraNota() {\r\n    return notas[0];\r\n}\r\n'),
(11,13,1,'#include <iostream>\r\n#include <algorithm> \r\n\r\nint maximo(int a, int b, int c) {\r\n    return std::max(a, std::max(b, c));\r\n}'),
(11,14,1,'#include <iostream>\r\n#include <iostream>\r\n#include <vector>\r\n\r\nstd::vector<float> notas = {5, 10, 2};\r\n\r\nstd::vector<float> outrasNotas() {\r\n    int tamanho = notas.size();\r\n    return std::vector<float>(notas.begin() + (tamanho - 2), notas.end());\r\n}'),
(11,19,1,'\nint potencia(int base, int expoente){\n    int resultado = 1;\n    for (int i = 0; i < expoente; i++){\n        resultado *= base;\n    }\n    return resultado;\n}'),
(11,20,1,'/*\nImplemente uma funçao que dobra o valor de um inteiro passado por referência.\n\nResultado esperado:\nint a = 2;\n\ndobra(a);\n\na = 4\n\nDica: Use & no parâmetro.\n*/\nvoid dobra(int& valor)\n{\n    valor*= 2;\n}'),
(11,31,1,'/*\nCrie uma função chamada \"absoluto\" que retorna o valor absoluto de um número.\n\nExemplo:\n\nabsoluto(-6) = 6\nabsoluto(6) = 6\nabsoluto(1) = 1\nabsoluto(-10) = 10\n*/\nint absoluto(int x){\n    return (x < 0) ? -x : x;\n}'),
(11,33,1,'/*\nCrie um função chamada \"raizQuadrada\" que retorne a raíz quadrada de um número. Essa função deve receber um número do tipo double.\n\nDica: Use std::sqrt(x) da biblioteca <cmath>\n*/\n#include <cmath>\n\ndouble raizQuadrada(double x){\n\n    return std::sqrt(x);\n}'),
(11,34,1,'#include <cmath>\ndouble potencia(double base, double expoente){\n    return std::pow(base, expoente);\n}'),
(11,35,1,'#include <iostream>\r\n#include <cmath> \r\n\r\ndouble seno(double angulo) {\r\n    return std::sin(angulo);\r\n}'),
(11,36,1,'#include <iostream>\r\n#include <cmath>\r\ndouble cosseno(double angulo) {\r\n    return std::cos(angulo);\r\n}\r\n'),
(11,37,1,'#include <cmath>    \r\n#include <iostream>\r\n\r\nint arredondar(double x) {\r\n    return static_cast<int>(std::round(x));\r\n}\r\n'),
(11,38,1,'#include <iostream>\r\n#include <string>\r\n\r\nint quantasLetras(const std::string& palavra) {\r\n    return palavra.size();\r\n}'),
(11,41,1,'#include <string>\r\n#include <algorithm>\r\n\r\nstd::string tudoMaiusculo(std::string palavra) {\r\n    std::transform(palavra.begin(), palavra.end(), palavra.begin(), ::toupper);\r\n    return palavra;\r\n}'),
(11,42,1,'#include <string>\r\n\r\nbool comecaComA(const std::string& palavra) {\r\n    if (palavra.empty()) return false; \r\n    return palavra[0] == \'a\' || palavra[0] == \'A\';\r\n}\r\n'),
(11,43,1,'#include <string>\r\n\r\nclass Pessoa {\r\npublic:\r\n    std::string nome;\r\n    int idade;\r\n};'),
(11,44,1,'#include <string>\r\n\r\nclass Pessoa {\r\nprivate:\r\n    std::string pensamento;\r\n    bool acordada;\r\n\r\npublic:\r\n    std::string getPensamento() const {\r\n        return pensamento;\r\n    }\r\n    void setPensamento(const std::string& p) {\r\n        pensamento = p;\r\n    }\r\n    bool isAcordada() const {\r\n        return acordada;\r\n    }\r\n    void setAcordada(bool a) {\r\n        acordada = a;\r\n    }\r\n};'),
(11,45,1,'#include <vector>\r\n\r\nint somaPares(const std::vector<int>& nums) {\r\n    int soma = 0;\r\n    for (int num : nums) {\r\n        if (num % 2 == 0) {\r\n            soma += num;\r\n        }\r\n    }\r\n    return soma;\r\n}'),
(11,46,1,'#include <iostream>\n#include <string>\n#include <cctype>\n\nbool ehPalindromo(const std::string& str) {\n    int esquerda = 0;\n    int direita = str.length() - 1;\n\n    while (esquerda < direita) {\n        \n        if (!std::isalnum(str[esquerda])) {\n            esquerda++;\n        } else if (!std::isalnum(str[direita])) {\n            direita--;\n        } else {\n            \n            if (std::tolower(str[esquerda]) != std::tolower(str[direita])) {\n                return false;\n            }\n            esquerda++;\n            direita--;\n        }\n    }\n    return true;\n}'),
(11,47,1,'#include <iostream>\n#include <cstring>\n#include <cctype>\n\nbool ehPalindromo(const std::string& str) {\n    int esquerda = 0;\n    int direita = str.length() - 1;\n\n    while (esquerda < direita) {\n        // Ignorar caracteres não alfanuméricos\n        if (!std::isalnum(str[esquerda])) {\n            esquerda++;\n        } else if (!std::isalnum(str[direita])) {\n            direita--;\n        } else {\n            // Comparar caracteres em minúsculo\n            if (std::tolower(str[esquerda]) != std::tolower(str[direita])) {\n                return false;\n            }\n            esquerda++;\n            direita--;\n        }\n    }\n    return true;\n}\n\nint main() {\n    std::string entrada;\n    std::cout << \"Digite uma string: \";\n    std::getline(std::cin, entrada);\n\n    if (ehPalindromo(entrada)) {\n        std::cout << \"\\\"\" << entrada << \"\\\" é um palíndromo.\\n\";\n    } else {\n        std::cout << \"\\\"\" << entrada << \"\\\" não é um palíndromo.\\n\";\n    }\n\n    return 0;\n}'),
(12,1,1,'/*\nEscreva um programa que imprime \"Ola, Mundo!\" na tela.\n\nResultado esperado:\nOla, Mundo!\n\nDica: Use std::cout\n*/\n\n#include <iostream>\nusing namespace std;\n\nint main(){\n    cout << \"Ola, Mundo!\";\n    return 0;\n}'),
(12,2,1,'/*\nUsando std::cin, leia dois números inteiros do usuario e imprima a soma deles.\n\nResultado esperado (exemplo):\nO resultado deve ser impresso no seguinte formato:\n\nSoma: <resultado>\n\nExemplo:\nSoma: 7\n*/\n\n#include <iostream>\n#include <string>\n\nint main(){\n    int numero1; \n    int numero2;\n    int soma;\n\n    \n    std::cin >> numero1;\n    \n    std::cin >> numero2;\n\n    soma = numero1 + numero2;\n\n    std::cout << \"Soma: \" << soma;\n\n    return 0;\n};'),
(12,3,1,'/*\nUsando std::cin, leia dois números inteiros do usuario e imprima a soma deles.\n\nResultado esperado (exemplo):\nO resultado deve ser impresso no seguinte formato:\n\nSoma: <resultado>\n\nExemplo:\nSoma: 7\n*/\n\n#include <iostream>\n#include <string>\n\nint main(){\n    int numero1; \n    int numero2;\n    int soma;\n\n    \n    std::cin >> numero1;\n    \n    std::cin >> numero2;\n\n    soma = numero1 * numero2;\n\n    std::cout << \"Produto: \"<< soma;\n\n    return 0;\n};'),
(12,4,1,'/*\nCrie a função main e dentro dela leia dois números inteiros e imprima o maior deles.\n\nResultado esperado (exemplo):\nO resultado deve ser impresso no seguinte formato:\nMaior: <resultado>\n\nDica: Use if/else para comparar.\n*/\n\n/*\nUsando std::cin, leia dois números inteiros do usuario e imprima a soma deles.\n\nResultado esperado (exemplo):\nO resultado deve ser impresso no seguinte formato:\n\nSoma: <resultado>\n\nExemplo:\nSoma: 7\n*/\n\n#include <iostream>\n\nint main() {\n  int x = 10;\n  int var_a;\n  int var_b;\n\n  if (10 > 5)\n  {\n      \n    std::cout << \"Maior: 12\" << std::endl;\n  } else \n  {\n    std::cout << \"x menor que 5\" << std::endl;\n  }\n\n  return 0;\n}'),
(13,1,1,'#include <iostream>\r\nusing namespace std;\r\n\r\nint main (){\r\n\r\n    std::cout<<\"Ola, Mundo!\";\r\n    return 0;\r\n}\r\n'),
(13,2,1,'#include <iostream>\r\n\r\nint main (){\r\n\r\n    int num1;\r\n    int num2;\r\n\r\n\r\nstd::cin >>num1;\r\n\r\nstd::cin >>num2;\r\n\r\n    int soma = num1 + num2;\r\n\r\n\r\n    std::cout<<\"Soma: \"<< soma;\r\n\r\n    return 0;\r\n\r\n}\r\n'),
(13,3,1,'#include <iostream>\r\nusing name space\r\n\r\n\r\nint main (){\r\n\r\n    int var1; var2;\r\n\r\n    int var Produto30;\r\n\r\n\r\nstd::cout<< \"5*6 =\"\" <<var1*var2<< endl;\r\n\r\nstd::cout<< Produto = 30;\r\n\r\n    int mutiplicar = num1 + num2;\r\n\r\n\r\n    std::cout<<\"Produto: \"<< mutiplicar;\r\n\r\n    return 0;\r\n\r\n}\r\n'),
(13,4,1,'#include <iostream>\r\nusing namespace std;\r\n\r\nint main() \r\n{\r\n    int valor1;\r\n    \r\n    int valor2;\r\n    \r\n    \r\n    std::cin >> valor1;\r\n    \r\n    std::cin>> valor2;\r\n    \r\n    if (valor1 > valor2){\r\n       std::cout<< \"Maior: \" << valor1;\r\n    } else {\r\n        std::cout<< \"Maior: \" << valor2;\r\n    }\r\n}'),
(13,5,1,'#include <iostream>\r\nusing namespace std;\r\n\r\nint main() \r\n{\r\n    \r\n    int a;\r\n    \r\n    std::cin >> a;\r\n    \r\n    if(a%2==0){\r\n    \r\n    std::cout<<\"Par\";\r\n    \r\n}else{\r\n  \r\n  std::cout<<\"Impar\";\r\n}\r\n    return 0;\r\n}'),
(13,6,1,'#include <iostream>\r\n#include <vector> \r\n\r\nint main (){\r\n  std::vector <int> list;\r\n  \r\n  for(int i=0; i < 5; i++){\r\n    int temp;\r\n    std::cin >> temp;\r\n    \r\n    list.push_back(temp);\r\n  }\r\n  \r\nint soma=0;\r\n\r\nfor (int i=0; i < 5; i++){\r\n\r\nsoma += list [i];\r\n}\r\n  \r\nstd::cout << \"Soma: \" << soma;;\r\n\r\nreturn 0;\r\n}'),
(13,8,1,'#include <iostream>\r\nusing namespace std;\r\n\r\nint soma (int valor1, int valor2) \r\n{\r\n \r\n int soma= valor1 + valor2;\r\n \r\n\r\n    return soma;\r\n    \r\n}'),
(13,9,1,'#include <iostream>\r\nusing namespace std;\r\n\r\nint mult (int valor1, int valor2) \r\n{\r\n \r\n int mult = valor1 * valor2;\r\n \r\n\r\n    return mult;\r\n    \r\n}'),
(13,11,1,'#include <iostream>\r\n#include <vector>\r\n\r\nint main()\r\n{\r\n    \r\nint criaVector\r\n\r\ncout << \"biblioteca01:\";\r\ncin >> biblioteca01;\r\ncout << \"biblioteca02: \";\r\ncin >> biblioteca02;\r\ncout << \"biblioteca03: \";\r\ncin >> biblioteca03;\r\n\r\nvector = (biblioteca01 +biblioteca02+biblioteca03) / 4;\r\ncout << \"biblioteca01: \" << biblioteca02 << \" \" << biblioteca03 << \"\" << endl;\r\n criaVector << endl;\r\n\r\nreturn 0;\r\n\r\n}\r\n'),
(14,1,1,'#include <iostream>\r\nint main(){\r\n    std::cout << \"Ola, Mundo!\";\r\n    return 0;\r\n}'),
(14,2,1,'#include <iostream>\r\nint main(){\r\n    float a;\r\n    float b;\r\n    std::cin >> a;\r\n    std::cin >> b;\r\n    std::cout << \"Soma: \" << 3+4;\r\n    return 0;\r\n}'),
(14,3,1,'#include <iostream>\r\nint main(){\r\n    float a;\r\n    float b;\r\n    std::cin >> a;\r\n    std::cin >> b;\r\n    std::cout << \"Produto: \" << a * b;\r\n    return 0;\r\n}'),
(14,4,1,'#include <iostream>\r\nint main()\r\n{\r\n    float a;\r\n    float b;\r\n    std::cin >> a;\r\n    std::cin >> b;\r\n    if(a>b){\r\n        std::cout << \"Maior: \" << a;\r\n    }else{\r\n        std::cout  << \"Maior: \" << b;\r\n    }\r\n\r\n    return 0;\r\n}\r\n'),
(14,5,1,'#include <iostream>\r\nint main(){\r\n    int a;\r\n    std::cin >> a;\r\n\r\n    if(a%2==0){\r\n        std::cout<< \"Par\";\r\n    }else{\r\n        std::cout<< \"Impar\";\r\n    }\r\n\r\n    return 0;\r\n}\r\n'),
(14,6,1,'\r\n#include <iostream>\r\n#include <vector>\r\n\r\nint main()\r\n{\r\n    std::vector <int> lista;\r\n\r\n    for(int i=0; i<5; i++){\r\n        int numero;\r\n        std::cin >> numero;\r\n        lista.push_back(numero);\r\n    }\r\n\r\n    int soma = 0;\r\n\r\n    for(int i=0; i < 5;i++){\r\n      soma = soma + lista[i];\r\n    }\r\n\r\n    std::cout <<\"Soma: \" << soma;\r\n\r\n    return 0;\r\n}     '),
(14,7,1,'#include <iostream>\r\n#include <iomanip>\r\n#include<vector>\r\n\r\n\r\nint main()\r\n{\r\n    std::vector <float> lista;\r\n\r\n    for(int i=0; i<4; i++){\r\n        float numero;\r\n        std::cin >> numero;\r\n        lista.push_back(numero);\r\n    }\r\n\r\n    float media = 0;\r\n\r\n    for(int i=0; i < 4;i++){\r\n      media = media + lista[i];\r\n    }\r\n\r\n    std::cout << std::fixed << std::setprecision(1);\r\n    std::cout << \"Media: \" << media / 4;\r\n\r\n    return 0;\r\n}     \r\n'),
(14,8,1,'\r\nint soma (int a,int b){\r\n    int resultado= a+b;\r\n    return resultado;\r\n}\r\n'),
(14,9,1,'int mult(int a, int b){\r\n    return a * b;\r\n}'),
(14,10,1,'/*\r\nImplemente uma funçao que troca os valores de dois inteiros usando referências.\r\n\r\nResultado esperado:\r\ntroca(a, b);\r\nAntes: a=3, b=5\r\nDepois: a=5, b=3\r\n\r\nDica: Use parâmetros por referência (&).\r\n*/\r\n\r\nvoid troca (int &a, int &b){\r\n    int temp = a;\r\n    a=b;\r\n    b=temp;\r\n}'),
(14,11,1,'/*\r\nCrie um função que retorne um vetor com 10 valores quaisquer.\r\n\r\nO nome da função de ser \"criaVetor\"\r\n*/\r\n#include <vector>\r\nstd::vector<int> criaVetor(){\r\n    std::vector <int> a;\r\n    a.push_back(10);\r\n    a.push_back(18);\r\n    a.push_back(7);\r\n    a.push_back(12);\r\n    a.push_back(11);\r\n    a.push_back(44);\r\n    a.push_back(16);\r\n    a.push_back(6);\r\n    a.push_back(66);\r\n    a.push_back(33);\r\n    return a;\r\n}\r\n'),
(14,12,1,'/*\r\nCrie um vetor chamado \"notas\":\r\nstd::vector<float> notas = {5, 10, 2};\r\n\r\nDepois crie um função chamada \"primeiraNota\" que retorna a primeira nota.\r\n*/\r\n#include<vector>\r\nstd::vector<float> notas = {5, 10, 2};\r\n\r\nfloat primeiraNota(){\r\n    return notas[0];\r\n}\r\n\r\n'),
(14,13,1,'\r\nint maximo (int a, int b, int c){\r\n    int m;\r\n\r\n    if(a-b<0){\r\n        m = b;\r\n    }else{\r\n        m = a;\r\n    }\r\n\r\n    if(m - c>0){\r\n        return m;\r\n    }else{\r\n        return c;\r\n    }    \r\n}\r\n\r\n\r\n\r\n\r\n\r\n'),
(14,14,1,'/*\r\nCrie um vetor chamado \"notas\":\r\nstd::vector<float> notas = {5, 10, 2};\r\n\r\nDepois crie um função chamada \"outrasNotas\" que retorna as duas últimas notas.\r\n\r\nDica: Use o método size() do vetor, o mesmo retorna o quantidade de itens do vetor:\r\n\r\nstd::vector<float> teste = {5, 6, 1, 2, 13, 50};\r\n\r\nint tamanho = teste.size();\r\n\r\n// tamanho será igual a 6\r\n*/\r\nstd::vector <froat> notas ={5,10,2};\r\n\r\n\r\n\r\n     std::vector<froat> ultimas =\r\n     outrasNotas(notas);\r\n     std::cout <<\"últimasNotas; \";\r\n     for (froat notas : ultimas) {\r\n        std::cout <<notas << \" \";\r\n        \r\n     }\r\n     return 0;\r\n}    \r\n'),
(15,1,1,'#include <iostream>\r\n\r\nint main() \r\n{\r\n    std::cout << \"Ola, Mundo!\";\r\n    return 0;\r\n}'),
(15,2,1,'#include <iostream>\r\n\r\nint main() \r\n{\r\n    int num1;\r\n    int num2;\r\n    std::cin >> num1;\r\n    std::cin >> num2;\r\n    int Soma = num1 + num2;\r\n    std::cout << \"Soma: \" << Soma;\r\n    return 0;\r\n}\r\n'),
(15,3,1,'#include <iostream>\r\n\r\nint main() \r\n{\r\n    int num1;\r\n    int num2;\r\n    std::cin >> num1;\r\n    std::cin >> num2;\r\n    int Soma = num1 * num2;\r\n    std::cout << \"Produto: \" << Soma;\r\n    return 0;\r\n}\r\n'),
(15,4,1,'#include <iostream>\r\n\r\nint main() \r\n{\r\n    int Num1, Num2;\r\n\r\n    std::cin >> Num1 >> Num2;\r\n\r\n    if (Num1 > Num2) \r\n    {\r\n        std::cout << \"Maior: \" << Num1;\r\n    } else {    \r\n        std::cout << \"Maior: \" << Num2;\r\n    }\r\n    return 0;\r\n}'),
(15,5,1,'#include <iostream>\r\n\r\nint main() \r\n{\r\n    int num;\r\n   \r\n    std::cin >> num;\r\n\r\n    if (num % 2 == 0) {\r\n        std::cout << \"Par\" << std::endl;\r\n    } else {\r\n        std::cout << \"Impar\" << std::endl;\r\n    }\r\n\r\n    return 0;\r\n}'),
(15,6,1,'#include <iostream>\r\n#include <vector>\r\n \r\nint main(){\r\n    int soma = 0;\r\n    std::vector <int> lista;\r\n   \r\n    for(int i=0; i < 5; i++)\r\n    {\r\n        int item;\r\n        std::cin >> item;\r\n        lista.push_back(item);\r\n    }\r\n \r\n    for(int i=0; i < 5; i++)\r\n    {\r\n        soma = soma + lista [i];\r\n    }\r\n \r\n    std::cout << \"Soma: \" << soma;\r\n    return 0;\r\n}'),
(15,7,1,'#include <iostream>\r\n#include <vector>\r\n#include <iomanip>\r\n\r\nint main(){\r\n    float soma = 0;\r\n    std::vector <float> lista;\r\n   \r\n    for(int i=0; i < 4; i++)\r\n    {\r\n        float item;\r\n        std::cin >> item;\r\n        lista.push_back(item);\r\n    }\r\n \r\n    for(int i=0; i < 4; i++)\r\n    {\r\n        soma = soma + lista [i];\r\n    }\r\n \r\n    std::cout << std::fixed << std::setprecision(1);\r\n    std::cout << \"Media: \" << (soma / 4.0);\r\n    return 0;\r\n}'),
(15,8,1,'#include <iostream>\r\n\r\nint soma(int a, int b){\r\n    return a + b;\r\n}'),
(15,9,1,'#include <iostream>\r\n\r\nint mult(int a, int b){\r\n    return a * b;\r\n}'),
(15,10,1,'void troca (int &A, int &B)\r\n{\r\n    int temp = A;\r\n    A = B;\r\n    B =temp;\r\n}'),
(15,11,1,'#include <vector>\r\n\r\nstd::vector <int> criaVetor(){\r\n    std::vector <int> resultado = {0,1,2,3,4,5,6,7,8,9};\r\n\r\n    return resultado;\r\n}'),
(15,12,1,'#include <vector>\r\n#include <iostream>\r\n\r\nstd::vector <float> notas = {5,10,2};\r\n\r\nfloat primeiraNota(){\r\n\r\n    return notas[0];\r\n}'),
(15,13,1,'#include <algorithm>\r\n\r\nint maximo(int a, int b, int c) {\r\n\r\n    int maior_ab = std::max(a, b);\r\n \r\n    int maior_abc = std::max(maior_ab, c);\r\n \r\n    return maior_abc;\r\n}'),
(15,14,1,'#include <vector> \r\n#include <iostream>\r\n\r\nstd::vector <float> notas = {5,10,2};\r\n\r\nstd::vector <float> outrasNotas(){ \r\n    int tamanho = notas.size();\r\n    float ultimaNota = notas[tamanho-1]; \r\n    float penultimaNota = notas[tamanho-2]; \r\n\r\n    std::vector <float> outrasnotas;\r\n    outrasnotas.push_back(penultimaNota);\r\n    outrasnotas.push_back(ultimaNota);\r\n\r\n    return outrasnotas;\r\n}'),
(15,19,1,'\r\n#include <algorithm>\r\n\r\nint potencia (int base, int expoente) {\r\n\r\n    int res = 1;\r\n\r\n    for(int i = 0; i < expoente; i++){\r\n        res = res * base;\r\n    }\r\n    return res; \r\n}'),
(15,20,1,'void dobra(int &a)\r\n{\r\n    a = a *2;\r\n}'),
(15,31,1,'int absoluto( int x){\r\n return (x < 0) ? -x : x;\r\n}'),
(15,33,1,'#include <cmath>\r\ndouble raizQuadrada(double x){\r\n    return std::sqrt(x);\r\n}'),
(15,34,1,'#include <cmath>\r\ndouble potencia(double base, double expoente){\r\n return std::pow(base, expoente);\r\n }'),
(15,35,1,'#include <cmath>\r\n float seno(float x){\r\n  return std::sin(x); }\r\n    '),
(15,36,1,'#include <cmath>\r\n double cosseno(double x){\r\n  return std::cos(x); }\r\n    '),
(15,37,1,'#include <cmath>\r\nint arredondar(double x){\r\n    return std::round(x);\r\n}'),
(17,1,1,'#include <iostream>\r\n\r\nint main(){\r\n    std::cout << \"Ola, Mundo!\";\r\n    return 0;\r\n}'),
(17,2,1,'#include <iostream>\r\n\r\nint main (){\r\n\r\n    int morte, conhecimento;\r\n\r\n    std::cin >> morte >> conhecimento;\r\n\r\n    std::cout << \"Soma: \" << morte + conhecimento;\r\n\r\n    return 0;\r\n}\r\n\r\n'),
(17,3,1,'#include <iostream>\r\n\r\nint main (){\r\n\r\n    int morte, conhecimento;\r\n\r\n    std::cin >> morte >> conhecimento;\r\n\r\n    std::cout << \"Produto: \" << morte * conhecimento;\r\n\r\n    return 0;\r\n}'),
(17,4,1,'#include <iostream>\r\n\r\nint main (){\r\n\r\n    int morte, conhecimento;\r\n\r\n    std::cin >> morte >> conhecimento;\r\n\r\n    std::cout << \"Maior: \";\r\n    if(morte > conhecimento){\r\n        std::cout << morte;\r\n        }else{\r\n            std::cout << conhecimento;\r\n        }\r\n\r\n    return 0;\r\n}'),
(17,5,1,'#include <iostream>\r\n\r\nint main(){\r\n\r\n int a;\r\n std::cin >> a;\r\n if(a % 2 == 0){\r\n    std::cout << \"Par\";\r\n }else{\r\n    std::cout << \"Impar\";\r\n }\r\n return 0;\r\n\r\n}\r\n\r\n'),
(17,6,1,'#include <iostream>\r\n#include <vector>\r\n\r\nint main(){\r\n\r\n    std::vector<int> lista;\r\n\r\n    for(int i = 0; i < 5; i++){\r\n        int item;\r\n        std::cin >> item;\r\n        lista.push_back(item);\r\n    }\r\n\r\n    int soma = 0;\r\n    for(int i = 0; i < 5; i++){\r\n        soma = soma + lista[i];\r\n\r\n    }\r\n\r\n    std::cout << \"Soma: \" << soma << std::endl;\r\n\r\n    return 0;\r\n}\r\n'),
(17,7,1,'#include <iostream>\r\n#include <iomanip>\r\n\r\nint main() {\r\n    double soma = 0, num;\r\n\r\n    for (int i = 0; i < 4; i++) {\r\n        std::cin >> num;\r\n        soma += num;\r\n    }\r\n\r\n    double media = soma / 4;\r\n\r\n    std::cout << std::fixed << std::setprecision(1);\r\n    std::cout << \"Media: \" << media << std::endl;\r\n\r\n    return 0;\r\n}'),
(17,8,1,'int soma(int a, int b){\r\n    return a + b;\r\n}'),
(17,9,1,'int mult(int a, int b){\r\n    return a * b;\r\n}'),
(17,10,1,'void troca(int &a, int &b){\r\n    int temp = b;\r\n    b = a;\r\n    a = temp;\r\n}'),
(17,11,1,'#include <vector>\r\n\r\nstd::vector<int> criaVetor() {\r\n    return {3, 7, 1, 4, 9, 2, 8, 0, 6, 5};\r\n}'),
(17,12,1,'#include <vector>\r\n\r\nstd::vector<float> notas = {5.0f, 10.0f, 2.0f};\r\n\r\nfloat primeiraNota() {\r\n    return notas.front(); \r\n}\r\n'),
(17,13,1,'#include <algorithm>\r\n\r\nint maximo(int a, int b, int c){\r\n\r\n    int maior_ab = std::max(a, b);\r\n\r\n    int maior_abc =\r\n   std::max(maior_ab, c);\r\n    \r\n    return maior_abc;\r\n}'),
(17,14,1,'#include <vector>\r\n\r\nstd::vector<float> notas = {5, 10, 2};\r\n\r\nstd::vector<float> outrasNotas(){\r\n    std::vector<float> resultado;\r\n    for (size_t i = 1; i < notas.size(); ++i){\r\n        resultado.push_back(notas [i]);\r\n    }\r\n    return resultado;\r\n}\r\n\r\n'),
(17,19,1,'#include <stdio.h>\r\n\r\nint potencia(int base, int expoente) {\r\n    int resultado = 1;\r\n    \r\n    for (int i = 0; i < expoente; i++) {\r\n        resultado *= base;\r\n    }\r\n\r\n    return resultado;\r\n}\r\n'),
(17,20,1,'void dobra(int  &valor)\r\n{\r\n    valor*= 2;\r\n}'),
(17,31,1,'int absoluto(int x){\r\n    return (x < 0) ? -x : x;\r\n}'),
(17,33,1,'#include <iostream>\r\n#include <cmath> // Necessário para std::sqrt\r\n\r\n// Função que retorna a raiz quadrada de um número double\r\ndouble raizQuadrada(double x) {\r\n    return std::sqrt(x);\r\n}\r\n\r\n'),
(17,34,1,'#include <cmath>\r\ndouble potencia(double base, double expoente){\r\n    return std::pow(base, expoente);\r\n}'),
(17,35,1,'#include <iostream>\r\n#include <cmath> \r\n\r\ndouble seno(double angulo) {\r\n    return std::sin(angulo);\r\n}'),
(17,36,1,'#include <iostream>\r\n#include <cmath>\r\ndouble cosseno(double angulo) {\r\n    return std::cos(angulo);\r\n}'),
(17,37,1,'#include <cmath>    \r\n#include <iostream>\r\n\r\nint arredondar(double x) {\r\n    return static_cast<int>(std::round(x));\r\n}'),
(17,38,1,'#include <iostream>\r\n#include <string>\r\n\r\nint quantasLetras(const std::string& palavra) {\r\n    return palavra.size();\r\n}'),
(17,41,1,'#include <string>\r\n#include <algorithm>\r\n\r\nstd::string tudoMaiusculo(std::string palavra) {\r\n    std::transform(palavra.begin(), palavra.end(), palavra.begin(), ::toupper);\r\n    return palavra;\r\n}'),
(17,42,1,'#include <string>\r\n\r\nbool comecaComA(const std::string& palavra) {\r\n    if (palavra.empty()) return false; \r\n    return palavra[0] == \'a\' || palavra[0] == \'A\';\r\n}'),
(17,43,1,'#include <string>\r\n\r\nclass Pessoa {\r\npublic:\r\n    std::string nome;\r\n    int idade;\r\n};'),
(17,44,1,'#include <string>\r\n\r\nclass Pessoa {\r\nprivate:\r\n    std::string pensamento;\r\n    bool acordada;\r\n\r\npublic:\r\n    std::string getPensamento() const {\r\n        return pensamento;\r\n    }\r\n    void setPensamento(const std::string& p) {\r\n        pensamento = p;\r\n    }\r\n    bool isAcordada() const {\r\n        return acordada;\r\n    }\r\n    void setAcordada(bool a) {\r\n        acordada = a;\r\n    }\r\n};'),
(17,45,1,'#include <vector>\r\n\r\nint somaPares(const std::vector<int>& nums) {\r\n    int soma = 0;\r\n    for (int num : nums) {\r\n        if (num % 2 == 0) {\r\n            soma += num;\r\n        }\r\n    }\r\n    return soma;\r\n}'),
(17,46,1,'#include <iostream>\r\n#include <string>\r\n#include <cctype>  // para tolower\r\n\r\nbool ehPalindromo(const std::string& s) {\r\n    int i = 0;\r\n    int j = s.size() - 1;\r\n\r\n    while (i < j) {\r\n        // Converte ambos caracteres para minúsculo para comparação case-insensitive\r\n        if (tolower(s[i]) != tolower(s[j])) {\r\n            return false;\r\n        }\r\n        i++;\r\n        j--;\r\n    }\r\n\r\n    return true;\r\n}'),
(17,47,1,'#include <iostream>\r\n#include <cstring>  // para strchr\r\n#include <cctype>   // para tolower\r\n\r\nint contarVogais(const std::string& s) {\r\n    const char* vogais = \"aeiou\";\r\n    int contador = 0;\r\n\r\n    for (char c : s) {\r\n        char c_lower = tolower(c);\r\n        if (strchr(vogais, c_lower)) {\r\n            contador++;\r\n        }\r\n    }\r\n\r\n    return contador;\r\n}'),
(17,48,1,'#include <iostream>\r\n\r\nint somaDigitos(unsigned int n) {\r\n    int soma = 0;\r\n    while (n > 0) {\r\n        soma += n % 10;  // pega o último dígito\r\n        n /= 10;         // remove o último dígito\r\n    }\r\n    return soma;\r\n}'),
(17,49,1,'#include <iostream>\r\n#include <string>\r\n\r\nstd::string inverterString(const std::string& s) {\r\n    return std::string(s.rbegin(), s.rend());\r\n}'),
(17,50,1,'#include <iostream>\r\n\r\n// Retorna o n-ésimo número de Fibonacci (0-based)\r\nunsigned long long fibonacci(int n) {\r\n    if (n == 0) return 0;\r\n    if (n == 1) return 1;\r\n\r\n    unsigned long long a = 0;\r\n    unsigned long long b = 1;\r\n    unsigned long long fib = 0;\r\n\r\n    for (int i = 2; i <= n; ++i) {\r\n        fib = a + b;\r\n        a = b;\r\n        b = fib;\r\n    }\r\n\r\n    return fib;\r\n}'),
(17,51,1,'#include <vector>\r\n#include <numeric>  // std::accumulate\r\n#include <gtest/gtest.h>\r\n\r\n\r\ndouble media(const std::vector<double>& numeros) {\r\n    if (numeros.empty()) return 0.0;\r\n    double soma = std::accumulate(numeros.begin(), numeros.end(), 0.0);\r\n    return soma / numeros.size();\r\n}'),
(17,52,1,'#include <iostream>\r\n\r\nunsigned long long fatorial(int n) {\r\n    if (n < 0) {\r\n        std::cerr << \"Fatorial não é definido para números negativos.\" << std::endl;\r\n        return 0;  // ou lance uma exceção, conforme preferir\r\n    }\r\n\r\n    unsigned long long resultado = 1;\r\n\r\n    for (int i = 2; i <= n; ++i) {\r\n        resultado *= i;\r\n    }\r\n\r\n    return resultado;\r\n}\r\n'),
(17,53,1,'#include <algorithm>  // Para std::count\r\n#include <string>     // Para std::string\r\n\r\n// Função que conta quantas vezes um caractere aparece em uma string\r\nint contarChar(const std::string& str, char ch) {\r\n    return std::count(str.begin(), str.end(), ch);\r\n}'),
(17,54,1,'#include <gtest/gtest.h>\r\n#include <string>\r\n\r\n// Função que verifica se a string contém apenas caracteres numéricos\r\nbool somenteDigitos(const std::string& str) {\r\n    return str.empty() || std::all_of(str.begin(), str.end(), [](char c) {\r\n        return std::isdigit(c);\r\n    });\r\n}'),
(17,55,1,'#include <iostream>\r\n#include <vector>\r\n#include <algorithm>  // Para std::reverse\r\n\r\n// Função que inverte um vetor de inteiros\r\nvoid inverter(std::vector<int>& v) {\r\n    if (v.size() > 1) {\r\n        std::reverse(v.begin(), v.end());\r\n    }\r\n}'),
(18,1,1,'#include <iostream>\r\n\r\nint main() {\r\n    std::cout << \"Ola, Mundo!\";\r\n\r\n    return 0;\r\n}'),
(18,2,1,'/*\r\nLeia dois números inteiros do usuario e imprima a soma deles.\r\n\r\nResultado esperado (exemplo):\r\nDigite dois números: 3 4\r\nSoma: 7\r\n\r\nDica: Use std::cin para entrada.\r\n*/\r\n\r\n#include <iostream>\r\nusing namespace std;\r\n\r\nint main() {\r\n    int a, b;\r\n\r\n    cout <<;\r\n    cin >> a;\r\n\r\n    cout <<;\r\n    cin >> b;\r\n\r\n    int soma = a + b;\r\n\r\n    cout  << soma << endl;\r\n\r\n    return 0;\r\n}\r\n'),
(18,3,1,'/*\r\nLeia dois números inteiros e imprima o produto deles.\r\n\r\nResultado esperado (exemplo):\r\nDigite dois números: 5 6\r\nProduto: 30\r\n\r\nDica: Multiplicaçao e feita com o operador *.\r\n*/\r\n\r\n#include <iostream>\r\n\r\nint main() {\r\n    int numero1, numero2;\r\n\r\n    std::cout <<;\r\n    std::cin >> numero1 >> numero2;\r\n\r\n    int produto = numero1 * numero2;\r\n\r\n    std::cout << produto << std::endl;\r\n\r\n    return 0;\r\n}\r\n\r\n\r\n'),
(18,4,1,'#include <iostream>\r\nint main(){\r\n    int real, psg;\r\n\r\n     std::cin >> real >> psg;\r\n     std::cout <<\"Maior: \";\r\n    if(real > psg){\r\n     std::cout << real;\r\n    }else{\r\n     std::cout <<psg;\r\n    }\r\n\r\n    return 0;\r\n}\r\n    \r\n'),
(18,5,1,'#include <iostream>\r\nint main(){\r\n    int whisky;\r\n\r\n    std::cin >> whisky;\r\n    if(whisky % 2 == 0){\r\n     std::cout << \"Par\";\r\n    }else{\r\n     std::cout << \"Impar\";\r\n    }\r\n    return 0;\r\n}'),
(18,6,1,'#include <iostream>\r\n#include <vector>\r\nusing namespace std;\r\n\r\nint main(){\r\n    vector<int> numeros;\r\n    int entrada, soma = 0;\r\n\r\n    for (int i = 0; i < 5; i++) {\r\n        cout << \"Digite o \" << i + 1 << \"º número inteiro: \";\r\n        cin >> entrada;\r\n        numeros.push_back(entrada);\r\n        soma += entrada;\r\n    }\r\n\r\n    for (size_t i = 0; i < numeros.size(); i++) {\r\n        cout << numeros[i];\r\n        if (i < numeros.size() - 1) {\r\n            cout << \" + \";\r\n        }\r\n    }\r\n\r\n    cout << \" =\r\n'),
(18,7,1,'/*\r\nLeia 4 números reais e imprima a media deles.\r\n\r\nResultado esperado (exemplo):\r\nNúmeros: 2.0 4.0 6.0 8.0\r\nMedia: 5.0\r\n\r\nDica: \r\n- Use a biblioteca #include <iomanip>\r\n- Para alterar a quantidade de casas decimais para 1 no cout use:\r\n  - std::cout << std::fixed << std::setprecision(1);\r\n*/\r\n\r\n#include <iostream>\r\n#include <iomanip>\r\n\r\nint main() {\r\n    double n1, n2, n3, n4;\r\n    double media\r\n    std::cout << std::fixed << std::setprecision(1);\r\n    std::cout << \"Números: \" << n1 << \" \" << n2 << \" \" << n3 << \" \" << n4 << std::endl;\r\n    std::cout << \"Media: \" << media << std::endl;\r\n\r\n    return 0;\r\n}\r\n\r\n'),
(18,8,1,'/*\r\nImplemente uma função que recebe dois inteiros e retorna a soma deles.\r\n\r\nResultado esperado:\r\nsoma(3, 4) = 7\r\n*/\r\n\r\nusing namespace std;\r\n\r\nint soma(int a, int b) {\r\n    return a + b;\r\n}\r\n\r\n'),
(18,9,1,'/*\r\nImplemente uma função que recebe dois inteiros e retorna a multiplicação deles.\r\n\r\nResultado esperado:\r\nmult(3, 4) = 12\r\n\r\n*/\r\n\r\nusing namespace std;\r\n\r\nint mult(int a, int b) {\r\n    return a * b;\r\n}'),
(18,12,1,'/*\r\nCrie um vetor chamado \"notas\":\r\nstd::vector<float> notas = {5, 10, 2};\r\n\r\nDepois crie um função chamada \"primeiraNota\" que retorna a primeira nota.\r\n*/\r\n#include <iostream>\r\n#include <vector>\r\n\r\nstd::vector<float> notas = {5, 10, 2};\r\n\r\nfloat primeiraNota() {\r\n    return notas[0];\r\n}\r\n\r\nint main() {\r\n    std::cout << \"Primeira nota: \" << primeiraNota() << std::endl;\r\n    return 0;\r\n}\r\n'),
(18,13,1,'/*\r\nImplemente uma funçao que retorna o maior de três números inteiros.\r\n\r\nResultado esperado:\r\nmaximo(3, 7, 5) = 7\r\n\r\nDica: \r\nUse if/else ou \r\nuse std::max com #include <algorithm>\r\n*/\r\n\r\nint maximo(int a, int b, int c) {\r\n    if (a >= b && a >= c) {\r\n        return a;\r\n    } else if (b >= a && b >= c) {\r\n        return b;\r\n    } else {\r\n        return c;\r\n    }\r\n}\r\n'),
(18,14,1,'/*\r\nCrie um vetor chamado \"notas\":\r\nstd::vector<float> notas = {5, 10, 2};\r\n\r\nDepois crie um função chamada \"outrasNotas\" que retorna as duas últimas notas.\r\n\r\nDica: Use o método size() do vetor, o mesmo retorna o quantidade de itens do vetor:\r\n\r\nstd::vector<float> teste = {5, 6, 1, 2, 13, 50};\r\n\r\nint tamanho = teste.size();\r\n\r\n// tamanho será igual a 6\r\n*/\r\n\r\n#include <vector>\r\n#include <iostream>\r\n\r\nstd::vector<float> outrasNotas(const std::vector<float>& notas) {\r\n    // Verifica se o vetor tem pelo menos duas notas\r\n    if (notas.size() < 2) {\r\n        return notas;  // Retorna o vetor original se tiver menos de 2 elementos\r\n    }\r\n    // Pega as duas últimas notas usando size()\r\n    return std::vector<float>{notas[notas.size() - 2], notas[notas.size() - 1]};\r\n}\r\n\r\nint main() {\r\n    std::vector<float> notas = {5, 10, 2};\r\n\r\n    std::vector<float> ultimasNotas = outrasNotas(notas);\r\n\r\n    std::cout << \"Duas últimas notas: \";\r\n    for (float nota : ultimasNotas) {\r\n        std::cout << nota << \" \";\r\n    }\r\n    std::cout << std::endl;\r\n\r\n    return 0;\r\n}\r\n'),
(18,19,1,'/*\r\nImplemente uma funçao que calcula a potência de um número inteiro (base^expoente).\r\n\r\nResultado esperado:\r\npotencia(2, 3) = 8\r\n\r\nDica: Use loop.\r\n*/\r\n\r\n#include <iostream>\r\n\r\nint potencia(int base, int expoente) {\r\n    int resultado = 1;\r\n    for (int i = 0; i < expoente; i++) {\r\n        resultado *= base;\r\n    }\r\n    return resultado;\r\n}\r\n'),
(18,20,1,'#include <stdio.h>\r\n\r\nvoid dobra(int *num) {\r\n    *num = *num * 2;\r\n}\r\n\r\nint main() {\r\n    int valor = 10;\r\n    printf(\"Antes de dobrar: %d\\n\", valor);\r\n    dobra(&valor);\r\n    printf(\"Depois de dobrar: %d\\n\", valor);\r\n    return 0;\r\n}\r\n'),
(18,31,1,'function absoluto(num) {\r\n  if (num < 0) {\r\n    return -num;\r\n  } else {\r\n    return num;\r\n  }\r\n}\r\n'),
(18,33,1,'#include <cmath>  // Para std::sqrt\r\n\r\ndouble raizQuadrada(double x) {\r\n    return std::sqrt(x);\r\n}\r\n'),
(18,34,1,'/*\r\nImplemente uma funçao que calcula a potência de um número inteiro (base^expoente).\r\n\r\nResultado esperado:\r\npotencia(2, 3) = 8\r\n\r\nDica: Use std::pow(base, expoente) da biblioteca <cmath>\r\n*/\r\n\r\n#include <iostream>\r\n#include <cmath>  // para std::pow\r\n\r\nint potencia(int base, int expoente) {\r\n    return static_cast<int>(std::pow(base, expoente));\r\n}\r\n\r\nint main() {\r\n    int resultado = potencia(2, 3);\r\n    std::cout << \"potencia(2, 3) = \" << resultado << std::endl;  // deve imprimir 8\r\n    return 0;\r\n}\r\n'),
(18,35,1,'#include <cmath>\r\n\r\ndouble seno(double angulo) {\r\n    return std::sin(angulo);\r\n}\r\n'),
(18,36,1,'#include <cmath>\r\n\r\ndouble cosseno(double angulo) {\r\n    return std::cos(angulo);\r\n}\r\n'),
(18,37,1,'#include <cmath>  \r\n\r\nint arredondar(double x) {\r\n    return static_cast<int>(std::round(x));\r\n}\r\n'),
(18,38,1,'/*\r\nEscreva uma função que receba uma palavra e diga quantas letras ela tem.\r\n\r\nO nome da função deve ser \"quantasLetras\" e deve receber 1 argumento do tipo string\r\n\r\n\r\nDica use: std::string e .size() ou .length()\r\n*/\r\n#include <iostream>\r\n#include <string>\r\n\r\nint quantasLetras(const std::string& palavra) {\r\n    return palavra.size();\r\n}\r\n\r\nint main() {\r\n    std::string palavra;\r\n    std::cout << \"Digite uma palavra: \";\r\n    std::cin >> palavra;\r\n    std::cout << \"A palavra \'\" << palavra << \"\' tem \" << quantasLetras(palavra) << \" letras.\" << std::endl;\r\n    return 0;\r\n}\r\n'),
(18,41,1,'/*\r\nEscreva uma função \"tudoMaiusculo\" que receba uma palavra e retorne tudo em letras maiúsculas.\r\n\r\nUse: <string> e <algorithm>, função std::transform + ::toupper\r\n\r\nDica: toupper(c) transforma o caractere em maiúscula\r\n\r\ntudoMaiusculo(\"gato\") → \"GATO\"\r\n\r\nSolução:\r\n\r\n#include <string>\r\n#include <algorithm>\r\n\r\nstd::string tudoMaiusculo(std::string palavra) {\r\n    std::transform(palavra.begin(), palavra.end(), palavra.begin(), ::toupper);\r\n    return palavra;\r\n}\r\n*/\r\n\r\n#include <string>\r\n#include <algorithm>\r\n\r\nstd::string tudoMaiusculo(std::string palavra) {\r\n    std::transform(palavra.begin(), palavra.end(), palavra.begin(), ::toupper);\r\n    return palavra;\r\n}\r\n'),
(18,42,1,'/*\r\nEscreva uma função que retorna \"true\" se uma palavra começa com a letra \'a\' ou \"false\" caso contrário.\r\n\r\nUse: std::string e palavra[0]\r\n\r\nDica: Verifique se a primeira letra é \'a\' ou \'A\'\r\n\r\ncomecaComA(\"abacate\") → true  \r\ncomecaComA(\"melancia\") → false\r\n\r\n*/\r\n\r\n#include <string>\r\n\r\nbool comecaComA(const std::string& palavra) {\r\n    if (palavra.empty()) return false;\r\n    return palavra[0] == \'a\' || palavra[0] == \'A\';\r\n}\r\n'),
(18,43,1,'/*\r\nCrie uma classe chamada Pessoa que tem duas propriedades públicas:\r\n\r\n- nome, que guarda o nome da pessoa (tipo string)\r\n- idade, que guarda a idade da pessoa (tipo int)\r\n\r\nUse: palavra-chave class\r\nDica: std::string vem da biblioteca <string>\r\n\r\nExemplo de uso esperado:\r\n\r\nPessoa p;\r\np.nome = \"Ana\";\r\np.idade = 30;\r\n\r\n*/\r\n\r\n#include <string>\r\n\r\nclass Pessoa {\r\npublic:\r\n    std::string nome;\r\n    int idade;\r\n};\r\n'),
(18,44,1,'/*\r\nCrie uma classe chamada Pessoa com dois atributos privados:\r\n\r\n-pensamento, do tipo string\r\n-acordada, do tipo bool\r\n\r\nUse: palavras-chave class, public e private.\r\n\r\nCrie métodos públicos\r\ngetPensamento() para retornar o pensamento\r\nsetPensamento(std::string p) para atribuir um pensamento\r\nisAcordada() para retornar o valor da propriedade \"acordada\"\r\nsetAcordada(bool a) para atribuir o valor da propriedade \"acordada\"\r\n\r\n\r\nExemplo de uso esperado:\r\nPessoa p;\r\np.setPensamento(\"Estou com sono\");\r\np.setAcordada(false);\r\nbool valor = p.isAcordada()\r\nstd::string texto = p.getPensamento()\r\n\r\n*/\r\n#include <string>\r\n\r\nclass Pessoa {\r\nprivate:\r\n    std::string pensamento;\r\n    bool acordada;\r\n\r\npublic:\r\n\r\n    std::string getPensamento() {\r\n        return pensamento;\r\n    }\r\n\r\n    void setPensamento(std::string p) {\r\n        pensamento = p;\r\n    }\r\n\r\n    bool isAcordada() {\r\n        return acordada;\r\n    }\r\n\r\n    void setAcordada(bool a) {\r\n        acordada = a;\r\n    }\r\n};\r\n'),
(18,45,1,'/*\r\nImplemente uma função que receba um vetor de inteiros e retorne a soma dos elementos pares.\r\n\r\nDica: Use um loop para iterar pelo vetor e uma condição para verificar se o número é par.\r\n\r\nA operação x % 2 == 0 identifica pares. Lembre-se de inicializar soma com zero.\r\n*/\r\n\r\n#include <iostream>\r\n#include <vector>\r\n\r\nint soma_pares(const std::vector<int>& vetor) {\r\n    int soma = 0;\r\n    for (int x : vetor) {\r\n        if (x % 2 == 0) {\r\n            soma += x;\r\n        }\r\n    }\r\n    return soma;\r\n}\r\n\r\nint main() {\r\n    std::vector<int> numeros = {1, 2, 3, 4, 5, 6};\r\n    std::cout << \"Soma dos pares: \" << soma_pares(numeros) << std::endl;  // Saída: 12\r\n    return 0;\r\n}\r\n'),
(18,46,1,'/*\r\nImplemente uma função que verifique se uma string é um palíndromo.\r\n\r\nDica: \r\nCompare caracteres simétricos da string usando dois índices.\r\n*/\r\n#include <iostream>\r\n#include <vector>\r\n\r\n// Função que recebe um vetor de inteiros e retorna a soma dos elementos pares\r\nint soma_pares(const std::vector<int>& vetor) {\r\n    int soma = 0;\r\n    for (int x : vetor) {\r\n        if (x % 2 == 0) {  // verifica se o número é par\r\n            soma += x;     // adiciona à soma\r\n        }\r\n    }\r\n    return soma;\r\n}\r\n\r\nint main() {\r\n    std::vector<int> numeros = {1, 2, 3, 4, 5, 6};\r\n    std::cout << \"Soma dos pares: \" << soma_pares(numeros) << std::endl;  // deve imprimir 12\r\n    return 0;\r\n}\r\n'),
(18,47,1,'/*\r\nImplemente uma função que conte o número de vogais em uma string.\r\n\r\nDica: Considere letras maiúsculas e minúsculas.\r\n\r\nA função strchr é útil para verificar se um caractere está em uma lista de vogais.\r\n*/\r\n\r\n#include <iostream>\r\n#include <vector>\r\n\r\n// Função que recebe um vetor de inteiros e retorna a soma dos elementos pares\r\nint soma_pares(const std::vector<int>& vetor) {\r\n    int soma = 0;\r\n    for (int x : vetor) {\r\n        if (x % 2 == 0) {  // verifica se o número é par\r\n            soma += x;     // adiciona à soma\r\n        }\r\n    }\r\n    return soma;\r\n}'),
(18,48,1,'/*\r\nImplemente uma função que calcule a soma dos dígitos de um número inteiro positivo.\r\n\r\nDica: Use divisão e módulo para extrair os dígitos.\r\n\r\nFunciona mesmo com números grandes se a entrada for positiva.\r\n\r\n*/\r\n\r\n#include <stdio.h>\r\n\r\nint soma_digitos(int n) {\r\n    int soma = 0;\r\n    while (n > 0) {\r\n        soma += n % 10;  \r\n        n /= 10;         \r\n    }\r\n    return soma;\r\n}\r\n\r\nint main() {\r\n    int numero;\r\n    printf(\"Digite um número inteiro positivo: \");\r\n    scanf(\"%d\", &numero);\r\n    if (numero < 0) {\r\n        printf(\"Número inválido. Por favor, digite um número positivo.\\n\");\r\n        return 1;\r\n    }\r\n    int resultado = soma_digitos(numero);\r\n    printf(\"A soma dos dígitos é: %d\\n\", resultado);\r\n\r\n    return 0;\r\n}\r\n'),
(18,49,1,'/*\r\nImplemente uma função que inverta os caracteres de uma string. Não modifique a string original; retorne uma nova.\r\n\r\nDica: (Opcional) Use rbegin() e rend() para criar uma nova string invertida.\r\n*/\r\n\r\n#include <string>\r\n\r\nstd::string inverterString(const std::string& original) {\r\n    \r\n    return std::string(original.rbegin(), original.rend());\r\n}\r\n'),
(18,51,1,'/*\r\nImplemente uma função que receba um vetor de double e retorne a média aritmética. Retorne 0.0 se o vetor estiver vazio.\r\n\r\nDica: Lembre-se de evitar divisão por zero.\r\n\r\n*/\r\n#include <stddef.h> // para size_t\r\n\r\ndouble media_aritmetica(const double *vetor, size_t tamanho) {\r\n    if (tamanho == 0) {\r\n        return 0.0; // evita divisão por zero\r\n    }\r\n    double soma = 0.0;\r\n    for (size_t i = 0; i < tamanho; i++) {\r\n        soma += vetor[i];\r\n    }\r\n    return soma / tamanho;\r\n}\r\n'),
(18,54,1,'/*\r\nCrie uma função que retorna verdadeiro se uma string contém apenas caracteres numéricos. String vazia deve retornar true.\r\n\r\nDica: Use std::all_of com isdigit da biblioteca algorithm\r\n*/\r\n\r\n#include <string>\r\n#include <algorithm>\r\n#include <cctype>   \r\n\r\nbool somenteNumeros(const std::string& s) {\r\n    return std::all_of(s.begin(), s.end(), [](unsigned char c) { \r\n        return std::isdigit(c); \r\n    });\r\n}\r\n'),
(18,55,1,'/*\r\nImplemente uma função que inverte um vetor de inteiros. Vetores vazios ou de um elemento devem ser tratados corretamente\r\n\r\nDica: (Opcional) Use std::reverse\r\n*/\r\n\r\n#include <vector>\r\n#include <numeric> \r\ndouble media_aritmetica(const std::vector<double>& vetor) {\r\n    if (vetor.empty()) {\r\n        return 0.0;\r\n    }\r\n    double soma = std::accumulate(vetor.begin(), vetor.end(), 0.0);\r\n    return soma / vetor.size();\r\n}\r\n'),
(19,1,1,'#include <iostream>\r\n\r\nint main()\r\n{\r\n    std::cout << \"Ola, Mundo!\";\r\n\r\n    return 0;\r\n}'),
(19,2,1,'#include <iostream>\r\n#include <string>\r\n\r\nint main(){\r\n    int n1, n2;\r\n\r\n    std::cin >> n1;\r\n    std::cin >> n2;\r\n\r\n    std::cout << \"Soma: \" << n1+n2;\r\n\r\n\r\n    return 0;\r\n}'),
(19,3,1,'#include <iostream>\r\n\r\nint main(){\r\n    int n1, n2;\r\n\r\n    std::cin >> n1;\r\n    std::cin >> n2;\r\n\r\n    std::cout << \"Produto: \" << n1*n2;\r\n\r\n    return 0;\r\n}'),
(19,4,1,'#include <iostream>\r\n\r\nint main(){\r\n    int n1, n2;\r\n\r\n    std::cin >> n1;\r\n    std::cin >> n2;\r\n\r\nif (n1 > n2){\r\n    std::cout << \"Maior: \" << n1;\r\n}else{\r\n    std::cout << \"Maior: \" << n2;\r\n};\r\n\r\n    return 0;\r\n}'),
(19,5,1,'#include <iostream>\r\n\r\nint main(){\r\n    int numero;\r\n\r\n    std::cin >> numero;\r\n\r\n    if (numero % 2 == 1){\r\n        std::cout << \"Impar\";\r\n    }else{\r\n        std::cout << \"Par\";\r\n    };\r\n\r\n    return 0;\r\n}'),
(19,6,1,'/*\r\nLeia 5 números inteiros em um vetor e imprima a soma deles.\r\n\r\nResultado esperado (exemplo):\r\nDigite 5 números: 1 2 3 4 5\r\nSoma: 15\r\n\r\nDica: Use um loop for para ler e somar.\r\n*/\r\n#include <iostream>\r\n#include <vector>\r\n\r\nint main(){\r\n\r\n    std::vector<int> numeros;\r\n\r\n    for (int i = 0; i < 5; i++){\r\n        int a;\r\n        std::cin >> a;\r\n        numeros.push_back(a);\r\n    }\r\n\r\n    int soma = 0;\r\n\r\n    for (int i = 0; i < 5; i++){\r\n        soma = soma + numeros[i];\r\n    }\r\n\r\n    std::cout << \"Soma: \" << soma;\r\n    return 0;\r\n}'),
(19,7,1,'/*\r\nLeia 4 números reais e imprima a media deles.\r\n\r\nResultado esperado (exemplo):\r\nNúmeros: 2.0 4.0 6.0 8.0\r\nMedia: 5.0\r\n\r\nDica: \r\n- Use a biblioteca #include <iomanip>\r\n- Para alterar a quantidade de casas decimais para 1 no cout use:\r\n  - std::cout << std::fixed << std::setprecision(1);\r\n*/\r\n\r\n#include <iostream>\r\n#include <vector>\r\n#include <iomanip>\r\n\r\nint main(){\r\n\r\n    std::vector<float> numeros;\r\n\r\n    for (int i = 0; i < 4; i++){\r\n        float a;\r\n        std::cin >> a;\r\n        numeros.push_back(a);\r\n    }\r\n\r\n\r\n    float media = 0;\r\n\r\n    for (int i = 0; i < 4; i++){\r\n        media = media + numeros[i];\r\n    }\r\n\r\n    std::cout << std::fixed << std::setprecision(1);\r\n    std::cout << \"Media: \" << media / 4;\r\n\r\n    return 0;\r\n}'),
(19,8,1,'/*\r\nImplemente uma função que recebe dois inteiros e retorna a soma deles.\r\n\r\nResultado esperado:\r\nsoma(3, 4) = 7\r\n\r\nDica: Defina a função antes do main.\r\n*/\r\n#include <iostream>\r\n\r\nint soma(int a, int b){\r\n    \r\n    std::cout << \"soma(\" << a << \", \" << b << \") = \" << (a + b) << std::endl;\r\n\r\n    return a + b;\r\n}\r\n\r\n\r\n\r\n\r\n'),
(19,9,1,'/*\r\nImplemente uma função que recebe dois inteiros e retorna a multiplicação deles.\r\n\r\nResultado esperado:\r\nmult(3, 4) = 12\r\n\r\nDica: Defina a função antes do main.\r\n*/\r\n#include <iostream>\r\n\r\nint mult(int a, int b){\r\n    \r\n    std::cout << \"mult(\" << a << \", \" << b << \") = \" << (a * b) << std::endl;\r\n\r\n    return a * b;\r\n}'),
(19,10,1,'/*\r\nImplemente uma funçao que troca os valores de dois inteiros usando referências.\r\n\r\nResultado esperado:\r\ntroca(a, b);\r\nAntes: a=3, b=5\r\nDepois: a=5, b=3\r\n\r\nDica: Use parâmetros por referência (&).\r\n*/\r\n#include <iostream>\r\n\r\n\r\nvoid troca(int &a, int &b){\r\n    int temp = a;\r\n    a = b;\r\n    b = temp;\r\n}'),
(19,11,1,'/*\r\nCrie um função que retorne um vetor com 10 valores quaisquer.\r\n\r\nO nome da função de ser \"criaVetor\"\r\n*/\r\n#include <iostream>\r\n#include <vector>\r\n\r\nstd::vector <int> criaVetor(){\r\n\r\n    std::vector <int> lista(10);\r\n    return lista;\r\n}'),
(19,12,1,'/*\r\nCrie um vetor chamado \"notas\":\r\nstd::vector<float> notas = {5, 10, 2};\r\n\r\nDepois crie um função chamada \"primeiraNota\" que retorna a primeira nota.\r\n*/\r\n#include <iostream>\r\n#include <vector>\r\n\r\nstd::vector <float> notas = {5, 10, 2};\r\n\r\nint primeiraNota(){\r\n    return notas[0];\r\n}'),
(19,13,1,'/*\r\nImplemente uma funçao que retorna o maior de três números inteiros.\r\n\r\nResultado esperado:\r\nmaximo(3, 7, 5) = 7\r\n\r\nDica: \r\nUse if/else ou \r\nuse std::max com #include <algorithm>\r\n*/\r\n#include <iostream>\r\n#include <algorithm>\r\n\r\nint maximo(int a, int b, int c) {\r\n    return std::max(a, std::max(b, c));\r\n}'),
(19,14,1,'/*\r\nCrie um vetor chamado \"notas\":\r\nstd::vector<float> notas = {5, 10, 2};\r\n\r\nDepois crie um função chamada \"outrasNotas\" que retorna as duas últimas notas.\r\n\r\nDica: Use um loop \"for\" com i=1 com valor inicial.\r\n*/\r\n#include <vector>\r\n\r\nstd::vector<float> notas = {5, 10, 2};\r\n\r\nstd::vector<float> outrasNotas(){\r\n    int tamanho = notas.size();\r\n    int ultimoItem = tamanho - 1;\r\n    int penultimoItem = tamanho - 2;\r\n\r\n    std::vector<float> resultado(2);\r\n    resultado[0] = notas[penultimoItem];\r\n    resultado[1] = notas[ultimoItem];\r\n\r\n    return resultado;\r\n\r\n\r\n}'),
(19,19,1,'/*\r\nImplemente uma funçao que calcula a potência de um número inteiro (base^expoente).\r\n\r\nResultado esperado:\r\npotencia(2, 3) = 8\r\n\r\nDica: Use loop.\r\n*/\r\nint potencia(int base, int expoente){\r\n    float resultado = 1;\r\n    for (int i = 0; i < expoente; i++){\r\n        resultado = resultado * base;\r\n    };\r\n\r\n    return resultado;\r\n}'),
(19,20,1,'/*\r\nImplemente uma funçao que dobra o valor de um inteiro passado por referência.\r\n\r\nResultado esperado:\r\nint a = 2;\r\n\r\ndobra(a);\r\n\r\na = 4\r\n\r\nDica: Use & no parâmetro.\r\n*/\r\n\r\nint dobra(int &a){\r\n    a = a * 2;\r\n\r\n    return a;\r\n}'),
(19,31,1,'/*\r\nCrie uma função chamada \"absoluto\" que retorna o valor absoluto de um número.\r\n\r\nExemplo:\r\n\r\nabsoluto(-6) = 6\r\nabsoluto(6) = 6\r\nabsoluto(1) = 1\r\nabsoluto(-10) = 10\r\n*/\r\n#include <cmath>\r\n\r\nint absoluto(int a){\r\n    a = abs(a);\r\n\r\n    return a;\r\n}'),
(19,33,1,'/*\r\nCrie um função chamada \"raizQuadrada\" que retorne a raíz quadrada de um número. Essa função deve receber um número do tipo double.\r\n\r\nDica: Use std::sqrt(x) da biblioteca <cmath>\r\n*/\r\n\r\n#include <cmath>\r\n\r\ndouble raizQuadrada(double x){\r\n    x = std::sqrt(x);\r\n\r\n    return x;\r\n}'),
(19,34,1,'/*\r\nImplemente uma funçao que calcula a potência de um número inteiro (base^expoente).\r\n\r\nResultado esperado:\r\npotencia(2, 3) = 8\r\n\r\nDica: Use std::pow(base, expoente) da biblioteca <cmath>\r\n*/\r\n\r\n#include <cmath>\r\n\r\nfloat potencia(float base, float expoente){\r\n    \r\n    float resultado = std::pow(base, expoente);\r\n\r\n    return resultado;\r\n}'),
(19,35,1,'/*\r\nCrie um função chamada \"seno\" que retorne o seno de um ângulo.\r\n*/\r\n\r\n#include <cmath>\r\n\r\nfloat seno(float x){\r\n    float num = sin(x);\r\n\r\n    return num;\r\n}'),
(19,36,1,'/*\r\nCrie um função chamada \"cosseno\" que retorne o cosseno de um ângulo.\r\n*/\r\n\r\n#include <cmath>\r\n\r\nfloat cosseno(float x){\r\n    float num = cos(x);\r\n\r\n    return num;\r\n}'),
(19,37,1,'/*\r\nCrie uma função chamada \"arredondar\" que arredonda um número real para o inteiro mais próximo. \r\n*/\r\n#include <cmath>\r\nint arredondar(double numero){\r\n\r\n    return std::round(numero);\r\n}'),
(19,38,1,'/*\r\nEscreva uma função que receba uma palavra e diga quantas letras ela tem.\r\n\r\nUse: std::string e .size() ou .length()\r\n\r\nDica: std::string palavra = \"cachorro\";\r\n*/\r\n#include <string>\r\n#include <iostream>\r\n\r\nint quantasLetras(std::string palavra){\r\n    int tamanho = palavra.size();\r\n\r\n    return tamanho;\r\n}'),
(19,41,1,'/*\r\nEscreva uma função \"tudoMaiusculo\" que receba uma palavra e retorne tudo em letras maiúsculas.\r\n\r\nUse: <string> e <algorithm>, função std::transform + ::toupper\r\n\r\nDica: toupper(c) transforma o caractere em maiúscula\r\n\r\ntudoMaiusculo(\"gato\") → \"GATO\"\r\n\r\nSolução:\r\n\r\n#include <string>\r\n#include <algorithm>\r\n\r\nstd::string tudoMaiusculo(std::string palavra) {\r\n    std::transform(palavra.begin(), palavra.end(), palavra.begin(), ::toupper);\r\n    return palavra;\r\n}\r\n*/\r\n\r\n#include <string>\r\n#include <algorithm>\r\n\r\nstd::string tudoMaiusculo(std::string palavra) {\r\n    std::transform(palavra.begin(), palavra.end(), palavra.begin(), ::toupper);\r\n    return palavra;\r\n}'),
(19,42,1,'/*\r\nEscreva uma função que retorna \"true\" se uma palavra começa com a letra \'a\' ou \"false\" caso contrário.\r\n\r\nUse: std::string e palavra[0]\r\n\r\nDica: Verifique se a primeira letra é \'a\' ou \'A\'\r\n\r\ncomecaComA(\"abacate\") → true  \r\ncomecaComA(\"melancia\") → false\r\n\r\n*/\r\n\r\n#include <string>\r\n\r\nbool comecaComA(std::string palavra){\r\n    if (palavra[0] == \'a\' || palavra[0] == \'A\'){\r\n        return true;\r\n    }\r\n    return false;\r\n}'),
(19,43,1,'/*\r\nCrie uma classe chamada Pessoa que tem duas propriedades públicas:\r\n\r\n- nome, que guarda o nome da pessoa (tipo string)\r\n- idade, que guarda a idade da pessoa (tipo int)\r\n\r\nUse: palavra-chave class\r\nDica: std::string vem da biblioteca <string>\r\n\r\nExemplo de uso esperado:\r\n\r\nPessoa p;\r\np.nome = \"Ana\";\r\np.idade = 30;\r\n\r\n*/\r\n#include <string>\r\n\r\nclass Pessoa{\r\n    public:\r\n    std::string nome;\r\n    int idade;\r\n\r\n};'),
(19,44,1,'/*\r\nCrie uma classe chamada Pessoa com dois atributos privados:\r\n\r\n-pensamento, do tipo string\r\n-acordada, do tipo bool\r\n\r\nUse: palavra-chave class, e private.\r\n\r\nDica: os atributos privados só podem ser acessados por métodos da própria classe.\r\n\r\nVocê pode usar métodos públicos como getPensamento() e setPensamento() para acessar os dados.\r\n\r\nExemplo de uso esperado:\r\nPessoa p;\r\np.setPensamento(\"Estou com sono\");\r\np.setAcordada(false);\r\n\r\n*/\r\n#include <string>\r\n\r\nclass Pessoa{\r\n\r\n    private:\r\n        std::string pensamento;\r\n        bool acordada;\r\n\r\n    public:\r\n        void setPensamento(std::string palavra){\r\n            pensamento = palavra;\r\n        }\r\n\r\n        std::string getPensamento(){\r\n            return pensamento;\r\n        }\r\n\r\n        void setAcordada(bool estado){\r\n            acordada = estado;\r\n        }\r\n\r\n        bool isAcordada(){\r\n            return acordada;\r\n        }\r\n\r\n};\r\n'),
(19,45,1,'/*\r\nImplemente uma função que receba um vetor de inteiros e retorne a soma dos elementos pares.\r\n\r\nDica: Use um loop para iterar pelo vetor e uma condição para verificar se o número é par.\r\n\r\nA operação x % 2 == 0 identifica pares. Lembre-se de inicializar soma com zero.\r\n*/\r\n\r\n#include <vector>\r\n\r\nint somaPares(std::vector <int> numeros){\r\n    int soma = 0;\r\n    for (int i = 0; i < numeros.size(); i++){\r\n        if (numeros[i] % 2 == 0){\r\n            soma = soma + numeros[i];\r\n        }\r\n    }\r\n    return soma;\r\n};'),
(19,46,1,'/*\r\nImplemente uma função que verifique se uma string é um palíndromo.\r\n\r\nDica: \r\nCompare caracteres simétricos da string usando dois índices.\r\n*/\r\n#include <string>\r\n\r\nbool ehPalindromo(std::string palavra){\r\n    int esquerda = 0;\r\n    int direita = palavra.size();\r\n\r\n    for (int i = esquerda; i < direita; i++){\r\n        if (palavra[i] != palavra[palavra.size()-i-1]){\r\n            return false;\r\n        }\r\n    }\r\n\r\n    return true;\r\n};'),
(19,47,1,'/*\r\nImplemente uma função que conte o número de vogais em uma string.\r\n\r\nDica: Considere letras maiúsculas e minúsculas.\r\n\r\nA função strchr é útil para verificar se um caractere está em uma lista de vogais.\r\n*/\r\n#include <cstring>\r\n#include <string>\r\n#include <vector>\r\n\r\nint contarVogais(const char *str) {\r\n    const char *vogais = \"aeiouAEIOU\";\r\n    int contador = 0;\r\n\r\n    while (*str) {\r\n        if (strchr(vogais, *str)) {\r\n            contador++;\r\n        }\r\n        str++;\r\n    }\r\n\r\n    return contador;\r\n}\r\n'),
(19,48,1,'/*\r\nImplemente uma função que calcule a soma dos dígitos de um número inteiro positivo.\r\n\r\nDica: Use divisão e módulo para extrair os dígitos.\r\n\r\nFunciona mesmo com números grandes se a entrada for positiva.\r\n\r\n*/\r\n#include <string>\r\n\r\nint somaDigitos(int n){\r\n    int soma = 0;\r\n    while (n > 0) {\r\n        soma = soma + n % 10;\r\n        n = n / 10;\r\n    }\r\n    return soma;\r\n\r\n}'),
(19,49,1,'/*\r\nImplemente uma função que inverta os caracteres de uma string. Não modifique a string original; retorne uma nova.\r\n\r\nDica: (Opcional) Use rbegin() e rend() para criar uma nova string invertida.\r\n*/\r\n#include <string>\r\n\r\nstd::string inverterString(std::string str){\r\n    std::string novaString(str.rbegin(), str.rend());\r\n\r\n    return novaString;\r\n}'),
(19,50,1,'/*\r\nImplemente uma função que retorne o n-ésimo número da sequência de Fibonacci.\r\n\r\nDica: Comece com os dois primeiros termos da sequência.\r\n\r\n*/\r\n#include <iostream>\r\nusing namespace std;\r\n\r\nint fibonacci(int termos){\r\n\r\n    int primeiro = 1, segundo = 1, enesimo = 1;\r\n\r\n    if (termos == 0){\r\n        return 0;\r\n    }\r\n    \r\n    for (int i = 2; i < termos; i++){\r\n        enesimo = primeiro + segundo;\r\n        primeiro = segundo;\r\n        segundo = enesimo;\r\n    };\r\n\r\n    return enesimo;\r\n    \r\n}'),
(19,51,1,'/*\r\nImplemente uma função que receba um vetor de double e retorne a média aritmética. Retorne 0.0 se o vetor estiver vazio.\r\n\r\nDica: Lembre-se de evitar divisão por zero.\r\n\r\n*/\r\n\r\n#include <iostream>\r\n#include <vector>\r\n\r\nusing namespace std;\r\n\r\ndouble media(vector <double> n){\r\n\r\n    if (n.size() == 0){\r\n        return 0;\r\n    }\r\n\r\n double soma = 0.0;\r\n    for (double valor : n) {\r\n        soma += valor;\r\n    }\r\n\r\n    return soma / n.size();\r\n}'),
(19,52,1,'/*\r\nImplemente uma função que calcule o fatorial de um número inteiro positivo usando laço (mais conhecido com loop).\r\n\r\nDica:\r\nUse um laço de 2 até n.\r\n0! = 1 por definição.\r\n*/\r\n\r\n#include <iostream>\r\nusing namespace std;\r\n\r\nint fatorial(int n){\r\n\r\n    int resultado = 1;\r\n    for (int i = 2; i <= n; ++i) {\r\n        resultado *= i;\r\n    }\r\n    return resultado;\r\n}\r\n'),
(19,53,1,'/*\r\nDada uma string e um caractere, conte quantas vezes esse caractere aparece na string.\r\n\r\n\r\nDica: (Opcional) Use std::count da biblioteca algorithm.\r\n\r\n*/\r\n\r\n#include <iostream>\r\n#include <string>\r\n#include <algorithm>\r\n\r\nusing namespace std;\r\n\r\nint contarChar(string palavra, char letra){\r\n    int contador = count(palavra.begin(), palavra.end(), letra);\r\n\r\n\r\n    return contador;\r\n}'),
(19,54,1,'/*\r\nCrie uma função que retorna verdadeiro se uma string contém apenas caracteres numéricos. String vazia deve retornar true.\r\n\r\nDica: Use std::all_of com isdigit da biblioteca algorithm\r\n*/\r\n\r\n#include <string>\r\n#include <iostream>\r\n#include <algorithm>\r\n#include <cctype>\r\n\r\nusing namespace std;\r\n\r\n\r\nbool somenteDigitos(string &palavra){\r\n\r\n    if (palavra.size() == 0){\r\n        return true;\r\n    }else{\r\n        return false;\r\n    }\r\n\r\n    if (all_of(palavra.begin(), palavra.end(), isdigit())){\r\n        return true;\r\n    }else{\r\n        return false;\r\n    }\r\n\r\n    return true;\r\n}'),
(20,1,1,'/*\nEscreva um programa que imprime \"Ola, Mundo!\" na tela.\n\nResultado esperado:\nOla, Mundo!\n\nDica: Use std::cout\n*/\n\n#include <iostream>\nusing namespace std;\n\nint main()\n{\n    cout << \"Ola, Mundo!\";\n    return 0;\n}'),
(20,2,1,'/*\nLeia dois números inteiros do usuario e imprima a soma deles.\n\nResultado esperado (exemplo):\nDigite dois números: 3 4\nSoma: 7\n\nDica: Use std::cin para entrada.\n*/\n\n#include <iostream>\n\nusing namespace std;\n\nint main()\n{\n    int numberOne;\n    int numberTwo;\n\n    cin >> numberOne;\n    cin >> numberTwo;\n    \n    cout << \"Soma: \" << numberOne + numberTwo;\n    return 0;\n}'),
(20,3,1,'/*\nLeia dois números inteiros e imprima o produto deles.\n\nResultado esperado (exemplo):\nDigite dois números: 5 6\nProduto: 30\n\nDica: Multiplicaçao e feita com o operador *.\n*/\n\n/*\nLeia dois números inteiros do usuario e imprima a soma deles.\n\nResultado esperado (exemplo):\nDigite dois números: 3 4\nSoma: 7\n\nDica: Use std::cin para entrada.\n*/\n\n#include <iostream>\n\nusing namespace std;\n\nint main()\n{\n    int numberOne;\n    int numberTwo;\n\n    cin >> numberOne;\n    cin >> numberTwo;\n    \n    cout << \"Produto: \" << numberOne * numberTwo;\n    return 0;\n}'),
(20,4,1,'/*\nLeia dois números inteiros e imprima o maior deles.\n\nResultado esperado (exemplo):\nDigite dois números: 8 12\nMaior: 12\n*/\n#include <iostream>\n\nusing namespace std;\n\nint main()\n{\n    int numberOne;\n    int numberTwo;\n\n    cin >> numberOne;\n    cin >> numberTwo;\n\n    if (numberOne > numberTwo)\n    {\n        cout << \"Maior: \" << numberOne;\n    }    \n    else\n    {\n     cout << \"Maior: \" << numberTwo;\n    }\n   return 0;\n}'),
(20,5,1,'#include <iostream> \nusing namespace std;\nint main(){int numberOne; cin >> numberOne; if (numberOne % 2 == 0) {cout << \"Par\";} else {cout << \"Impar\";} return 0;}'),
(20,6,1,'/*\nLeia 5 números inteiros em um vetor e imprima a soma deles.\n\nResultado esperado (exemplo):\nDigite 5 números: 1 2 3 4 5\nSoma: 15\n\nDica: Use um loop for para ler e somar.\n*/\n\n#include <iostream>\nusing namespace std;\n\nint main() {\n    int numeros[5];\n    int soma = 0;\n    for (int i = 0; i < 5; i++) {\n        cin >> numeros[i];\n        soma += numeros[i];\n    }\n    cout << \"Soma: \" << soma;\n    return 0;\n}\n'),
(20,7,1,'#include <iostream>\n#include <iomanip>\nusing namespace std;\n\nint main() {\n    double numeros[4];\n    double soma = 0.0;\n\n    for (int i = 0; i < 4; i++) {\n        cin >> numeros[i];\n        soma += numeros[i];\n    }\n\n    double media = soma / 4;\n\n    cout << fixed << setprecision(1);\n    cout << \"Media: \" << media;\n\n    return 0;\n}\n'),
(20,8,1,'/*\nImplemente uma função que recebe dois inteiros e retorna a soma deles.\n\nResultado esperado:\nsoma(3, 4) = 7\n\nDica: Defina a função antes do main.\n*/\n\n\nint soma(int one, int two)\n{ \n return one + two; \n}\n'),
(20,9,1,'/*\nImplemente uma função que recebe dois inteiros e retorna a multiplicação deles.\n\nResultado esperado:\nmult(3, 4) = 12\n\nDica: Defina a função antes do main.\n*/\n\nint mult(int one, int two)\n{ \n return one * two; \n}'),
(20,10,1,'void troca(int &x, int &y) {\n    int temp = x;\n    x = y;\n    y = temp;\n}\n\n'),
(20,11,1,'#include <iostream>\n#include <vector>\nusing namespace std;\n\nfloat primeiraNota(const vector<float>& notas) {\n    return notas[0];\n}'),
(20,12,1,'#include <iostream>\n#include <vector>\nusing namespace std;\n\nfloat primeiraNota(const vector<float>& notas) {\n    return notas[0];\n}'),
(20,13,1,'/*\nImplemente uma funçao que retorna o maior de três números inteiros.\n\nResultado esperado:\nmaximo(3, 7, 5) = 7\n\nDica: \nUse if/else ou \nuse std::max com #include <algorithm>\n*/\nint maximo(int a, int b, int c) {\n    if (a >= b && a >= c)\n        return a;\n    else if (b >= a && b >= c)\n        return b;\n    else\n        return c;\n}\n'),
(20,14,1,'#include <vector>\n\nstd::vector<float> notas = {5, 10, 2};\n\nstd::vector<float> outrasNotas(){\n    std::vector<float> resultado;\n    for (size_t i=1; i < notas.size(); ++i){\n        resultado.push_back(notas[i]);\n}\n    return resultado;\n}'),
(20,19,1,'/*\nImplemente uma funçao que calcula a potência de um número inteiro (base^expoente).\n\nResultado esperado:\npotencia(2, 3) = 8\n\nDica: Use loop.\n*/\n\nint potencia(int base, int expoente) {\n    int resultado = 1;\n\n    for (int i = 0; i < expoente; ++i) {\n        resultado *= base;\n    }\n\n    return resultado;\n}\n'),
(20,20,1,'/*\nImplemente uma funçao que dobra o valor de um inteiro passado por referência.\n\nResultado esperado:\nint a = 2;\n\ndobra(a);\n\na = 4\n\nDica: Use & no parâmetro.\n*/\n\nvoid dobra(int& valor) {\n    valor *= 2;\n}\n'),
(20,31,1,'/*\nCrie uma função chamada \"absoluto\" que retorna o valor absoluto de um número.\n\nExemplo:\n\nabsoluto(-6) = 6\nabsoluto(6) = 6\nabsoluto(1) = 1\nabsoluto(-10) = 10\n*/\n\nint absoluto(int valor) {\n    if (valor < 0) {\n        return -valor;\n    }\n    return valor;\n}\n'),
(20,33,1,'/*\nCrie um função chamada \"raizQuadrada\" que retorne a raíz quadrada de um número. Essa função deve receber um número do tipo double.\n\nDica: Use std::sqrt(x) da biblioteca <cmath>\n*/\n\n#include <cmath> \n\ndouble raizQuadrada(double numero) {\n    return std::sqrt(numero);\n}\n'),
(20,34,1,'/*\nImplemente uma funçao que calcula a potência de um número inteiro (base^expoente).\n\nResultado esperado:\npotencia(2, 3) = 8\n\nDica: Use std::pow(base, expoente) da biblioteca <cmath>\n*/\n#include <cmath>  \n\ndouble potencia(double base, double expoente){\n        return std::pow(base, expoente);\n}\n\n'),
(20,35,1,'/*\nCrie um função chamada \"seno\" que retorne o seno de um ângulo.\n\nDica: use a função std::sin(x) da biblioteca <cmath>\n*/\n\n#include <cmath>  \n\ndouble seno(double angulo) {\n    return std::sin(angulo);\n}\n'),
(20,36,1,'/*\nCrie um função chamada \"cosseno\" que retorne o cosseno de um ângulo.\n\nDica: use a função std::cos(x) da biblioteca <cmath>\n*/\n\n#include <cmath>  \n\ndouble cosseno(double angulo) {\n    return std::cos(angulo);\n}\n'),
(20,37,1,'/*\nCrie uma função chamada \"arredondar\" que arredonda um número real para o inteiro mais próximo. \n\nDica: use a função std::round(x) da biblioteca <cmath>\n*/\n#include <cmath>\nint arredondar(double x){\n    return std::round(x);\n}'),
(20,38,1,'/*\nEscreva uma função que receba uma palavra e diga quantas letras ela tem.\n\nO nome da função deve ser \"quantasLetras\" e deve receber 1 argumento do tipo string\n\n\nDica use: std::string e .size() ou .length()\n*/\n\n#include <string> \n\nsize_t quantasLetras(const std::string& palavra) {\n    return palavra.size();  \n}\n'),
(20,41,1,'/*\nEscreva uma função \"tudoMaiusculo\" que receba uma palavra e retorne tudo em letras maiúsculas.\n\nUse: <string> e <algorithm>, função std::transform + ::toupper\n\nDica: toupper(c) transforma o caractere em maiúscula\n\ntudoMaiusculo(\"gato\") → \"GATO\"\n\nSolução:\n\n#include <string>\n#include <algorithm>\n\nstd::string tudoMaiusculo(std::string palavra) {\n    std::transform(palavra.begin(), palavra.end(), palavra.begin(), ::toupper);\n    return palavra;\n}\n*/\n\n#include <string>\n#include <algorithm>\n\nstd::string tudoMaiusculo(std::string palavra){\n    std::transform(palavra.begin(), palavra.end(), palavra.begin(), ::toupper);\n    return palavra;\n}'),
(20,42,1,'/*\nEscreva uma função que retorna \"true\" se uma palavra começa com a letra \'a\' ou \"false\" caso contrário.\n\nUse: std::string e palavra[0]\n\nDica: Verifique se a primeira letra é \'a\' ou \'A\'\n\ncomecaComA(\"abacate\") → true  \ncomecaComA(\"melancia\") → false\n\n*/\n\n#include <string>\n\nbool comecaComA(const std::string& palavra){\n    return !palavra.empty() && (palavra[0] == \'a\' || palavra[0] == \'A\');\n}'),
(20,43,1,'/*\nCrie uma classe chamada Pessoa que tem duas propriedades públicas:\n\n- nome, que guarda o nome da pessoa (tipo string)\n- idade, que guarda a idade da pessoa (tipo int)\n\nUse: palavra-chave class\nDica: std::string vem da biblioteca <string>\n\nExemplo de uso esperado:\n\nPessoa p;\np.nome = \"Ana\";\np.idade = 30;\n\n*/\n\n#include <string>  \n\nclass Pessoa {\npublic:\n    std::string nome;\n    int idade;    \n};\n'),
(20,44,1,'class Pessoa {\nprivate:\n    std::string pensamento;\n    bool acordada;\n\npublic:\n    void setPensamento(const std::string& p) {\n        pensamento = p;\n    }\n\n    std::string getPensamento() const {\n        return pensamento;\n    }\n\n    void setAcordada(bool a) {\n        acordada = a;\n    }\n\n    bool getAcordada() const {\n        return acordada;\n    }\n};\n'),
(20,45,1,'/*\nImplemente uma função que receba um vetor de inteiros e retorne a soma dos elementos pares.\n\nDica: Use um loop para iterar pelo vetor e uma condição para verificar se o número é par.\n\nA operação x % 2 == 0 identifica pares. Lembre-se de inicializar soma com zero.\n*/\n\n#include <vector>  \n\nint somaPares(const std::vector<int>& numeros) {\n    int soma = 0;\n    for (int num : numeros) {\n        if (num % 2 == 0) {\n            soma += num;\n        }\n    }\n    \n    return soma;\n}\n\n'),
(20,46,1,'/*\nImplemente uma função que verifique se uma string é um palíndromo.\n\nDica: \nCompare caracteres simétricos da string usando dois índices.\n*/\n\n#include <string>  \n\nbool ehPalindromo(const std::string& str) {\n    int inicio = 0;\n    int fim = str.size() - 1;\n    while (inicio < fim) {\n        if (str[inicio] != str[fim]) {\n            return false; \n        }\n        inicio++;\n        fim--;\n    }\n    \n    return true;  \n}\n'),
(20,47,1,'/*\nImplemente uma função que conte o número de vogais em uma string.\n\nDica: Considere letras maiúsculas e minúsculas.\n\nA função strchr é útil para verificar se um caractere está em uma lista de vogais.\n*/\n#include <string>  \n#include <cstring> \n\nint contarVogais(const std::string& str) {\n    int contador = 0;\n    const char* vogais = \"aeiouAEIOU\"; \n    for (char c : str) {\n        if (std::strchr(vogais, c)) {\n            contador++;\n        }\n    }\n\n    return contador;\n}\n'),
(20,48,1,'/*\nImplemente uma função que calcule a soma dos dígitos de um número inteiro positivo.\n\nDica: Use divisão e módulo para extrair os dígitos.\n\nFunciona mesmo com números grandes se a entrada for positiva.\n\n*/\n\nint somaDosDigitos(int numero) {\n    int soma = 0;\n    while (numero > 0) {\n        soma += numero % 10;\n        numero /= 10;\n    }\n    return soma;\n}\n'),
(20,49,1,'/*\nImplemente uma função que inverta os caracteres de uma string. Não modifique a string original; retorne uma nova.\n\nDica: (Opcional) Use rbegin() e rend() para criar uma nova string invertida.\n*/\n\n#include <iostream>\n#include <string>\n#include <algorithm>  \n\nstd::string inverterString(const std::string& str) {\n    return std::string(str.rbegin(), str.rend());\n}\n\n'),
(20,50,1,'/*\nImplemente uma função que retorne o n-ésimo número da sequência de Fibonacci.\n\nDica: Comece com os dois primeiros termos da sequência.\n*/\n\n#include <iostream>\n#include <string>\n#include <algorithm> \n\nstd::string inverterString(const std::string& str) {\n    return std::string(str.rbegin(), str.rend());\n}\n'),
(20,51,1,'/*\nImplemente uma função que inverta os caracteres de uma string. Não modifique a string original; retorne uma nova.\n\nDica: (Opcional) Use rbegin() e rend() para criar uma nova string invertida.\n*/\n\n#include <iostream>\n#include <string>\n#include <algorithm>  \n\nstd::string inverterString(const std::string& str) {\n    return std::string(str.rbegin(), str.rend());\n}\n\nint main() {\n    std::string original = \"Exemplo de string\";\n    std::string invertida = inverterString(original);\n    \n    std::cout << \"Original: \" << original << std::endl;\n    std::cout << \"Invertida: \" << invertida << std::endl;\n    \n    return 0;\n}\n'),
(20,52,1,'/*\nImplemente uma função que calcule o fatorial de um número inteiro positivo usando laço (mais conhecido com loop).\n\nDica:\nUse um laço de 2 até n.\n0! = 1 por definição.\n*/\n\n#include <iostream>\n\nlong long fatorial(int n) {\n    if (n == 0) return 1; \n    \n    long long resultado = 1;\n    for (int i = 2; i <= n; ++i) {\n        resultado *= i;\n    }\n    return resultado;\n}\n'),
(20,53,1,'/*\nDada uma string e um caractere, conte quantas vezes esse caractere aparece na string.\n\n\nDica: (Opcional) Use std::count da biblioteca algorithm.\n\n*/\n\n#include <iostream>\n#include <algorithm>\n\nint contarChar(const std::string& str, char caractere) {\n    return std::count(str.begin(), str.end(), caractere);\n}\n'),
(20,54,1,'/*\nCrie uma função que retorna verdadeiro se uma string contém apenas caracteres numéricos. String vazia deve retornar true.\n\nDica: Use std::all_of com isdigit da biblioteca algorithm\n*/\n\n#include <iostream>\n#include <algorithm>\n#include <cctype>\n\nbool somenteDigitos(const std::string& str) {\n    return str.empty() || std::all_of(str.begin(), str.end(), [](char c) { return std::isdigit(c); });\n}\n'),
(20,55,1,'/*\nImplemente uma função que inverte um vetor de inteiros. Vetores vazios ou de um elemento devem ser tratados corretamente\n\nDica: (Opcional) Use std::reverse\n*/\nvoid inverter(std::vector<int>& vetor) {\n    std::reverse(vetor.begin(), vetor.end());\n}\n\n'),
(21,1,1,'#include <iostream>\r\n\r\nint main() \r\n{\r\n    std::cout << \"Ola, Mundo!\";\r\n    return 0;\r\n}'),
(21,2,1,'#include <iostream>\r\nint main()\r\n{\r\n    int a, b;\r\n    std::cin >>a >>b;\r\n    std::cout << \"Soma: \" << a + b;\r\n    return 0;\r\n    }'),
(21,3,1,'#include <iostream>\r\nint main()\r\n{\r\n    int a, b;\r\n    std::cin >> a >>b;\r\n    std::cout<<\"Produto: \"<< a *b;\r\n    return 0;\r\n}'),
(21,4,1,'#include <iostream>\r\n\r\nint main() \r\n{\r\n    int Num1, Num2;\r\n\r\n    std::cin >> Num1 >> Num2;\r\n\r\n    if (Num1 > Num2) \r\n    {\r\n        std::cout << \"Maior: \" << Num1;\r\n    } else {    \r\n        std::cout << \"Maior: \" << Num2;\r\n    }\r\n    return 0;\r\n}'),
(21,5,1,'#include <iostream>\r\n\r\nint main() \r\n{\r\n    int num;\r\n   \r\n    std::cin >> num;\r\n\r\n    if (num % 2 == 0) {\r\n        std::cout << \"Par\" << std::endl;\r\n    } else {\r\n        std::cout << \"Impar\" << std::endl;\r\n    }\r\n\r\n    return 0;\r\n}'),
(21,6,1,'#include <iostream>\r\n#include <vector>\r\n \r\nint main(){\r\n    int soma = 0;\r\n    std::vector <int> lista;\r\n   \r\n    for(int i=0; i < 5; i++)\r\n    {\r\n        int item;\r\n        std::cin >> item;\r\n        lista.push_back(item);\r\n    }\r\n \r\n    for(int i=0; i < 5; i++)\r\n    {\r\n        soma = soma + lista [i];\r\n    }\r\n \r\n    std::cout << \"Soma: \" << soma;\r\n    return 0;\r\n}'),
(21,7,1,'#include <iostream>\r\n#include <vector>\r\n#include <iomanip>\r\n\r\nint main(){\r\n    float soma = 0;\r\n    std::vector <float> lista;\r\n   \r\n    for(int i=0; i < 4; i++)\r\n    {\r\n        float item;\r\n        std::cin >> item;\r\n        lista.push_back(item);\r\n    }\r\n \r\n    for(int i=0; i < 4; i++)\r\n    {\r\n        soma = soma + lista [i];\r\n    }\r\n \r\n    std::cout << std::fixed << std::setprecision(1);\r\n    std::cout << \"Media: \" << (soma / 4.0);\r\n    return 0;\r\n}'),
(21,8,1,'#include <iostream>\r\n\r\nint soma(int a, int b){\r\n    return a + b;\r\n}'),
(21,9,1,'#include <iostream>\r\n\r\nint mult(int a, int b){\r\n    return a * b;\r\n}'),
(21,10,1,'void troca (int &A, int &B)\r\n{\r\n    int temp = A;\r\n    A = B;\r\n    B =temp;\r\n}'),
(21,11,1,'#include <vector>\r\n\r\nstd::vector<int> criaVetor(){\r\n    return {3, 7, 1, 4, 9, 2, 8, 0, 6, 5};\r\n}'),
(21,12,1,'#include <vector>\r\n\r\nstd::vector<float> notas = {5.0f, 10.0f, 2.0f};\r\nfloat primeiraNota(){\r\n    return notas.front();\r\n}'),
(21,13,1,'#include <algorithm>\r\n\r\nint maximo(int a, int b, int c) {\r\n\r\n    int maior_ab = std::max(a, b);\r\n \r\n    int maior_abc = std::max(maior_ab, c);\r\n \r\n    return maior_abc;\r\n}'),
(21,14,1,'#include <vector>\r\n\r\nstd::vector<float> notas = {5, 10, 2};\r\nstd::vector<float> outrasNotas() {\r\n    std::vector<float> resultado;\r\n    for (size_t i = 1 ; i < notas.size(); ++i){\r\n        resultado.push_back(notas[i]);\r\n    }\r\n    return resultado;\r\n}'),
(21,19,1,'\r\n#include <algorithm>\r\n\r\nint potencia (int base, int expoente) {\r\n\r\n    int res = 1;\r\n\r\n    for(int i = 0; i < expoente; i++){\r\n        res = res * base;\r\n    }\r\n    return res; \r\n}'),
(21,20,1,'void dobra(int &a)\r\n{\r\n    a = a *2;\r\n}'),
(21,31,1,'/*\r\nCrie uma função chamada \"absoluto\" que retorna o valor absoluto de um número.\r\n\r\nExemplo:\r\n\r\nabsoluto(-6) = 6\r\nabsoluto(6) = 6\r\nabsoluto(1) = 1\r\nabsoluto(-10) = 10\r\n*/\r\nint absoluto(int x){\r\n    return (x < 0) ? -x : x;\r\n}'),
(21,33,1,'/*\r\nCrie um função chamada \"raizQuadrada\" que retorne a raíz quadrada de um número. Essa função deve receber um número do tipo double.\r\n\r\nDica: Use std::sqrt(x) da biblioteca <cmath>\r\n*/\r\n#include <cmath>\r\ndouble raizQuadrada(double x){\r\n    return std::sqrt(x);\r\n}'),
(21,34,1,'/*\r\nImplemente uma funçao que calcula a potência de um número inteiro (base^expoente).\r\n\r\nResultado esperado:\r\npotencia(2, 3) = 8\r\n\r\nDica: Use std::pow(base, expoente) da biblioteca <cmath>\r\n*/\r\n#include <cmath>\r\ndouble potencia(double base, double expoente){\r\n    return std::pow(base, expoente);\r\n}'),
(21,35,1,'/*\r\nCrie um função chamada \"seno\" que retorne o seno de um ângulo.\r\n\r\nDica: use a função std::sin(x) da biblioteca <cmath>\r\n*/\r\n#include <cmath>\r\ndouble seno(double radianos){\r\n    return std::sin(radianos);\r\n}'),
(21,36,1,'/*\r\nCrie um função chamada \"cosseno\" que retorne o cosseno de um ângulo.\r\n\r\nDica: use a função std::cos(x) da biblioteca <cmath>\r\n*/\r\n#include <cmath>\r\ndouble cosseno(double radianos){\r\n    return std::cos(radianos);\r\n}'),
(21,37,1,'/*\r\nCrie uma função chamada \"arredondar\" que arredonda um número real para o inteiro mais próximo. \r\n\r\nDica: use a função std::round(x) da biblioteca <cmath>\r\n*/\r\n#include <cmath>\r\nint arredondar(double x){\r\n    return std::round(x);\r\n}'),
(21,38,1,'/*\r\nEscreva uma função que receba uma palavra e diga quantas letras ela tem.\r\n\r\nO nome da função deve ser \"quantasLetras\" e deve receber 1 argumento do tipo string\r\n\r\n\r\nDica use: std::string e .size() ou .length()\r\n*/\r\n#include <string>\r\nint quantasLetras(const std::string& palavra){\r\n    return palavra.size();\r\n}'),
(21,41,1,'/*\r\nEscreva uma função \"tudoMaiusculo\" que receba uma palavra e retorne tudo em letras maiúsculas.\r\n\r\nUse: <string> e <algorithm>, função std::transform + ::toupper\r\n\r\nDica: toupper(c) transforma o caractere em maiúscula\r\n\r\ntudoMaiusculo(\"gato\") → \"GATO\"\r\n\r\nSolução:\r\n\r\n#include <string>\r\n#include <algorithm>\r\n\r\nstd::string tudoMaiusculo(std::string palavra) {\r\n    std::transform(palavra.begin(), palavra.end(), palavra.begin(), ::toupper);\r\n    return palavra;\r\n}\r\n*/\r\n#include <string>\r\n#include <algorithm>\r\n\r\nstd::string tudoMaiusculo(std::string palavra) {\r\n    std::transform(palavra.begin(), palavra.end(), palavra.begin(), ::toupper);\r\n    return palavra;\r\n}'),
(21,42,1,'/*\r\nEscreva uma função que retorna \"true\" se uma palavra começa com a letra \'a\' ou \"false\" caso contrário.\r\n\r\nUse: std::string e palavra[0]\r\n\r\nDica: Verifique se a primeira letra é \'a\' ou \'A\'\r\n\r\ncomecaComA(\"abacate\") → true  \r\ncomecaComA(\"melancia\") → false\r\n\r\n*/\r\n#include <string>\r\nbool comecaComA(const std::string& palavra){\r\n    return !palavra.empty() && (palavra[0] == \'a\' || palavra[0] == \'A\');\r\n}'),
(21,43,1,'/*\r\nCrie uma classe chamada Pessoa que tem duas propriedades públicas:\r\n\r\n- nome, que guarda o nome da pessoa (tipo string)\r\n- idade, que guarda a idade da pessoa (tipo int)\r\n\r\nUse: palavra-chave class\r\nDica: std::string vem da biblioteca <string>\r\n\r\nExemplo de uso esperado:\r\n\r\nPessoa p;\r\np.nome = \"Ana\";\r\np.idade = 30;\r\n\r\n*/\r\n#include <string>\r\nclass Pessoa {\r\n    public:\r\n    std::string nome;\r\n    int idade;\r\n};'),
(21,44,1,'/*\r\nCrie uma classe chamada Pessoa com dois atributos privados:\r\n\r\n-pensamento, do tipo string\r\n-acordada, do tipo bool\r\n\r\nUse: palavras-chave class, public e private.\r\n\r\nCrie métodos públicos\r\ngetPensamento() para retornar o pensamento\r\nsetPensamento(std::string p) para atribuir um pensamento\r\nisAcordada() para retornar o valor da propriedade \"acordada\"\r\nsetAcordada(bool a) para atribuir o valor da propriedade \"acordada\"\r\n\r\n\r\nExemplo de uso esperado:\r\nPessoa p;\r\np.setPensamento(\"Estou com sono\");\r\np.setAcordada(false);\r\nbool valor = p.isAcordada()\r\nstd::string texto = p.getPensamento()\r\n\r\n*/\r\n#include <iostream>\r\n#include <string>\r\nusing namespace std;\r\n\r\nclass Pessoa {\r\nprivate:\r\n    string pensamento;\r\n    bool acordada;\r\n\r\npublic:\r\n    // Define o pensamento\r\n    void setPensamento(string p) {\r\n        pensamento = p;\r\n    }\r\n\r\n    // Retorna o pensamento\r\n    string getPensamento() {\r\n        return pensamento;\r\n    }\r\n\r\n    // Define o estado acordada\r\n    void setAcordada(bool a) {\r\n        acordada = a;\r\n    }\r\n\r\n    // Retorna o estado acordada\r\n    bool getAcordada() {\r\n        return acordada;\r\n    }\r\n};\r\n\r\n// Exemplo de uso\r\nint main() {\r\n    Pessoa p;\r\n    p.setPensamento(\"Estou com sono\");\r\n    p.setAcordada(false);\r\n\r\n    cout << \"Pensamento: \" << p.getPensamento() << endl;\r\n    cout << \"Está acordada? \" << (p.getAcordada() ? \"Sim\" : \"Não\") << endl;\r\n\r\n    return 0;\r\n}'),
(21,45,1,'/*\r\nImplemente uma função que receba um vetor de inteiros e retorne a soma dos elementos pares.\r\n\r\nDica: Use um loop para iterar pelo vetor e uma condição para verificar se o número é par.\r\n\r\nA operação x % 2 == 0 identifica pares. Lembre-se de inicializar soma com zero.\r\n*/\r\n#include <iostream>\r\n#include <vector>\r\nusing namespace std;\r\n\r\n// Função que soma os elementos pares de um vetor\r\nint somaPares(const vector<int>& vetor) {\r\n    int soma = 0;\r\n\r\n    for (int x : vetor) {\r\n        if (x % 2 == 0) {\r\n            soma += x;\r\n        }\r\n    }\r\n\r\n    return soma;\r\n}\r\n\r\n// Exemplo de uso\r\nint main() {\r\n    vector<int> numeros = {1, 2, 3, 4, 5, 6};\r\n\r\n    int resultado = somaPares(numeros);\r\n\r\n    cout << \"Soma dos pares: \" << resultado << endl;\r\n\r\n    return 0;\r\n}'),
(21,46,1,'/*\r\nImplemente uma função que verifique se uma string é um palíndromo.\r\n\r\nDica: \r\nCompare caracteres simétricos da string usando dois índices.\r\n*/\r\n#include <iostream>\r\n#include <string>\r\nusing namespace std;\r\nbool ehPalindromo(const string& texto) {\r\n    int inicio = 0;\r\n    int fim = texto.length() - 1;\r\n\r\n    while (inicio < fim) {\r\n        if (texto[inicio] != texto[fim]) {\r\n            return false; \r\n        }\r\n        inicio++;\r\n        fim--;\r\n    }\r\n\r\n    return true;\r\n}\r\nint main() {\r\n    string palavra;\r\n\r\n    cout << \"Digite uma palavra: \";\r\n    cin >> palavra;\r\n\r\n    if (ehPalindromo(palavra)) {\r\n        cout << \"É um palíndromo!\" << endl;\r\n    } else {\r\n        cout << \"Não é um palíndromo.\" << endl;\r\n    }\r\n\r\n    return 0;\r\n}\r\n'),
(21,47,1,'/*\r\nImplemente uma função que conte o número de vogais em uma string.\r\n\r\nDica: Considere letras maiúsculas e minúsculas.\r\n\r\nA função strchr é útil para verificar se um caractere está em uma lista de vogais.\r\n*/\r\n#include <iostream>\r\n#include <string>\r\n\r\nint contar_vogais(const std::string& str) {\r\n    const std::string vogais = \"aeiouAEIOU\";\r\n    int contador = 0;\r\n\r\n    for (char c : str) {\r\n        if (vogais.find(c) != std::string::npos) {\r\n            contador++;\r\n        }\r\n    }\r\n\r\n    return contador;\r\n}\r\n\r\nint main() {\r\n    std::string texto = \"Exemplo de String com Vogais\";\r\n    int total = contar_vogais(texto);\r\n    std::cout << \"Número de vogais: \" << total << std::endl;\r\n    return 0;\r\n}'),
(23,1,1,'/*\nEscreva um programa que imprime \"Ola, Mundo!\" na tela.\n\nResultado esperado:\nOla, Mundo!\n\nDica: Use std::cout\n*/\n\n#include <iostream>\nint main(){\n    std::cout << \"Ola, Mundo!\";\n}'),
(23,2,1,'/*\nLeia dois números inteiros do usuario e imprima a soma deles.\n\nResultado esperado (exemplo):\nDigite dois números: 3 4\nSoma: 7\n\nDica: Use std::cin para entrada.\n*/\n\n#include <iostream>\nint main(){\n    int a;\n    int b;\n\n    std::cin >> a;\n    std::cin >> b;\n\n    std::cout << \"Soma: \" << a+b;\n}'),
(23,3,1,'/*\nLeia dois números inteiros e imprima o produto deles.\n\nResultado esperado (exemplo):\nDigite dois números: 5 6\nProduto: 30\n\nDica: Multiplicaçao e feita com o operador *.\n*/\n\n#include <iostream>\nint main(){\n    int a;\n    int b;\n\n    std::cin >> a;\n    std::cin >> b;\n \n    std::cout <<  \"Produto: \" << a*b;\n}'),
(23,4,1,'#include <iostream>\n\nint main(){\nint a;\nint b;\n\nstd::cin >> a;\nstd::cin >> b;\n\nif (a > b){\n std::cout << \"Maior: \" << a;\n } else {\n    std::cout << \"Maior: \" << b;\n }\n\nreturn 0;\n\n}'),
(23,5,1,'/*\nLeia um número inteiro e informe se ele e par ou impar.\n\nResultado esperado (exemplo):\nDigite um número: 7\nImpar\n\nDica: Use o operador % para resto da divisao.\n*/\n#include <iostream>\nint main(){\n    int a;\n\n    std::cin >> a;\n   \n\n    if( a %2==0){\n        std::cout << \"Par\" ;\n\n} else { \nstd::cout << \"Impar\" ;\n\n\n\n}\n\n\n\n\nreturn 0;\n\n}\n\n'),
(23,6,1,'/*\nLeia 5 números inteiros em um vetor e imprima a soma deles.\n\nResultado esperado (exemplo):\nDigite 5 números: 1 2 3 4 5\nSoma: 15\n\nDica: Use um loop for para ler e somar.\n*/\n#include <iostream>\n#include <vector>\nint main(){\n   \n   \nstd::vector<int> listaDeValores;\n\nfor (int i=0; i<5; i++){\n    int variavelLeitora;\n\n    std::cin >> variavelLeitora;\n\n    listaDeValores.push_back(variavelLeitora);\n}\n\n\nint valorDaSoma =0;\n\nfor (int i=0; i<5; i++){\n    valorDaSoma = valorDaSoma + listaDeValores[i];\n}\n\nstd::cout << \"Soma: \" << valorDaSoma;\n\n\n\n\n\n\n\n\n\n\n\n}'),
(23,7,1,'\n\n#include <iostream>\n#include <iomanip>\n#include <vector>\n\nint main (){\n\n   \n   float a, b, c, d, soma;\n   \n   std::cin >> a >> b >> c >> d;\n   soma= a+b+c+d;\n\n std::cout << std::fixed << std::setprecision(1);  \n std::cout << \"Media: \" << soma / 4;\n\n\n\n}\n'),
(23,8,1,'/*\nImplemente uma função que recebe dois inteiros e retorna a soma deles.\n\nResultado esperado:\nsoma(3, 4) = 7\n*/\n\n#include <iostream> \n\n\n\nint soma(int a,int b){\n    return a + b;\n\n\n\n}\n\n\n\n'),
(23,9,1,'#include <iostream>\n\n\nint mult (int a, int b){\n\n    return a*b;\n\n\n\n\n\n}'),
(23,10,1,'#include <iostream>\n\n\nvoid troca (int& a, int& b) {\n\n\n    int temp= a;\n    a=b;\n    b=temp;\n}\n\n\n    '),
(23,11,1,'#include <iostream>\n#include <vector>\n\n\n\nstd::vector<int> criaVetor(){\n    std::vector<int> vetor;\nfor (int i = 0; i < 10; i++){\n    vetor.push_back(i);\n\n   \n}\n\nreturn vetor;\n\n\n}\n\n\n\n\n'),
(23,12,1,'/*\nCrie um vetor chamado \"notas\":\nstd::vector<float> notas = {5, 10, 2};\n\nDepois crie um função chamada \"primeiraNota\" que retorna a primeira nota.\n*/\n#include <vector>\n#include <iostream>\n\nint main (){\n    std::vector <float> notas;\n\nfor (int i = 0; i < 3; i++){\nint primeiraNota;\n\nstd::cin >> primeiraNota;\n\nnotas.push_back(primeiraNota);\n}\n\n    \n\n\n\n\n\n\n}'),
(23,13,1,'/*\nImplemente uma funçao que retorna o maior de três números inteiros.\n\nResultado esperado:\nmaximo(3, 7, 5) = 7\n\nDica: \nUse if/else ou \nuse std::max com #include <algorithm>\n*/\n\n#include <iostream>\n#include <algorithm>\n\nint maximo (int a, int b, int c) {\n  return std::max(a, std::max(b, c));\n}'),
(23,14,1,'/*\nCrie um vetor chamado \"notas\":\nstd::vector<float> notas = {5, 10, 2};\n\nDepois crie um função chamada \"outrasNotas\" que retorna as duas últimas notas.\n\nDica: Use o método size() do vetor, o mesmo retorna o quantidade de itens do vetor:\n\nstd::vector<float> teste = {5, 6, 1, 2, 13, 50};\n\nint tamanho = teste.size();\n\n// tamanho será igual a 6\n*/\n\n#include <vector>\n\nusing namespace std;\n\nvector <float> notas = {5,10,2};\n\n    vector <float> outrasNotas(){\n\n    vector<float> resultado;\n    \n    int tamanho=notas.size();\n\n    int posicao1 = tamanho - 2;\n    int posicao2 = tamanho - 1;\n    \n    resultado.push_back(notas[posicao1]);\n    resultado.push_back(notas[posicao2]);\n\n\n\n\n    return resultado;\n}'),
(23,19,1,'/*\nImplemente uma funçao que calcula a potência de um número inteiro (base^expoente).\n\nResultado esperado:\npotencia(2, 3) = 8\n\nDica: Use loop.\n*/\n#include <iostream>\n\n\nint potencia(int base, int expoente) {\n    int resultado = 1;\n    for (int i = 0; i < expoente; ++i) {\n        resultado *= base;\n    }\n    return resultado;\n}\n'),
(23,20,1,'/*\nImplemente uma funçao que dobra o valor de um inteiro passado por referência.\n\nResultado esperado:\nint a = 2;\n\ndobra(a);\n\na = 4\n\nDica: Use & no parâmetro.\n*/\n\nvoid dobra (int& a) {\n    a = a + a;\n    \n    \n\n\n    \n}'),
(23,31,1,'/*\nCrie uma função chamada \"absoluto\" que retorna o valor absoluto de um número.\n\nExemplo:\n\nabsoluto(-6) = 6\nabsoluto(6) = 6\nabsoluto(1) = 1\nabsoluto(-10) = 10\n*/\n#include <iostream>\n\nint absoluto(int num) {\n    if (num < 0) {\n        return -num;\n    } else {\n        \n        \n        return num;\n    }\n}\n'),
(23,33,1,'/*\nCrie um função chamada \"raizQuadrada\" que retorne a raíz quadrada de um número. Essa função deve receber um número do tipo double.\n\nDica: Use std::sqrt(x) da biblioteca <cmath>\n*/\n#include <cmath>\n\n\ndouble raizQuadrada (double a) {\n\nreturn std::sqrt (a);\n\n}'),
(23,34,1,'/*\nImplemente uma funçao que calcula a potência de um número inteiro (base^expoente).\n\nResultado esperado:\npotencia(2, 3) = 8\n\nDica: Use std::pow(base, expoente) da biblioteca <cmath>\n*/\n#include <cmath>\n\nfloat potencial (float base, float expoente);\nreturn std::pow (base,expoente);\n'),
(23,35,1,'/*\nCrie um função chamada \"seno\" que retorne o seno de um ângulo.\n\nDica: use a função std::sin(x) da biblioteca <cmath>\n*/\n#include <cmath>\n\ndouble seno (double angulo) {\n\n    return sin (angulo);\n}\n\n'),
(23,36,1,'/*\nCrie um função chamada \"cosseno\" que retorne o cosseno de um ângulo.\n\nDica: use a função std::cos(x) da biblioteca <cmath>\n*/\n\n#include <cmath>\n\ndouble cosseno (double angulo){\n\n    return cos (angulo);\n}'),
(23,37,1,'/*\nCrie uma função chamada \"arredondar\" que arredonda um número real para o inteiro mais próximo. \n\nDica: use a função std::round(x) da biblioteca <cmath>\n*/\n\n#include <cmath>\n\nint arredondar (double num ){\n\n    return round (num);\n}'),
(23,38,1,'/*\nEscreva uma função que receba uma palavra e diga quantas letras ela tem.\n\nO nome da função deve ser \"quantasLetras\" e deve receber 1 argumento do tipo string\n\n\nDica use: std::string e .size() ou .length()\n*/\n\n#include <string>\n\nint quantasLetras (const std::string& palavra){\n\nreturn palavra.size();\n\n\n}'),
(23,41,1,'/*\nEscreva uma função \"tudoMaiusculo\" que receba uma palavra e retorne tudo em letras maiúsculas.\n\nUse: <string> e <algorithm>, função std::transform + ::toupper\n\nDica: toupper(c) transforma o caractere em maiúscula\n\ntudoMaiusculo(\"gato\") → \"GATO\"\n\nSolução:\n\n#include <string>\n#include <algorithm>\n\nstd::string tudoMaiusculo(std::string palavra) {\n    std::transform(palavra.begin(), palavra.end(), palavra.begin(), ::toupper);\n    return palavra;\n}\n*/\n\n#include <string>\n#include <algorithm>\n\nstd::string tudoMaiusculo(std::string palavra) {\n    std::transform(palavra.begin(), palavra.end(), palavra.begin(), ::toupper);\n    return palavra;\n}'),
(23,42,1,'/*\nEscreva uma função que retorna \"true\" se uma palavra começa com a letra \'a\' ou \"false\" caso contrário.\n\nUse: std::string e palavra[0]\n\nDica: Verifique se a primeira letra é \'a\' ou \'A\'\n\ncomecaComA(\"abacate\") → true  \ncomecaComA(\"melancia\") → false\n\n*/\n\n#include <string>\n\n\nusing namespace std;\n\nbool comecaComA (const string& palavra){\n\nif (palavra.empty()) return false;\n\n\nreturn tolower(palavra[0]) == \'a\';\n}\n\n'),
(23,43,1,'/*\nCrie uma classe chamada Pessoa que tem duas propriedades públicas:\n\n- nome, que guarda o nome da pessoa (tipo string)\n- idade, que guarda a idade da pessoa (tipo int)\n\nUse: palavra-chave class\nDica: std::string vem da biblioteca <string>\n\nExemplo de uso esperado:\n\nPessoa p;\np.nome = \"Ana\";\np.idade = 30;\n\n*/\n\n#include <string>\nusing namespace std;\n\nclass Pessoa {\n\n    public:\n    string nome;\n    double idade;\n};\n'),
(23,44,1,'/*\nCrie uma classe chamada Pessoa com dois atributos privados:\n\n-pensamento, do tipo string\n-acordada, do tipo bool\n\nUse: palavras-chave class, public e private.\n\nCrie métodos públicos\ngetPensamento() para retornar o pensamento\nsetPensamento(std::string p) para atribuir um pensamento\nisAcordada() para retornar o valor da propriedade \"acordada\"\nsetAcordada(bool a) para atribuir o valor da propriedade \"acordada\"\n\n\nExemplo de uso esperado:\nPessoa p;\np.setPensamento(\"Estou com sono\");\np.setAcordada(false);\nbool valor = p.isAcordada()\nstd::string texto = p.getPensamento()\n\n*/\n#include <string>\nusing namespace std;\n\nclass Pessoa {\nprivate:\n    string pensamento;\n    bool acordada;\n\npublic:\n  \n        string getPensamento() const {\n        return pensamento;\n    }\n\n   \n    void setPensamento(std::string p) {\n        pensamento = p;\n    }\n\n    \n    bool isAcordada()  {\n        return acordada;\n    }\n\n   \n    void setAcordada(bool a) {\n        acordada = a;\n    }\n};'),
(26,1,1,'#include <iostream>\r\nusing namespace std;\r\n\r\nint main()\r\n{\r\n    cout << \"Ola, Mundo!\";\r\n    return 0;\r\n}'),
(26,2,1,'#include <iostream>\r\n\r\nint main(){\r\n    int num1, num2;\r\n    std::cin >> num1;\r\n    std::cin >> num2;\r\n    int soma = num1 + num2;\r\n    std::cout << \"Soma: \" << soma;\r\n    return 0;\r\n}'),
(26,3,1,'#include <iostream>\r\n\r\nint main(){\r\n    int num1, num2;\r\n    std::cin >> num1;\r\n    std::cin >> num2;\r\n    int produto = num1 * num2;\r\n    std::cout << \"Produto: \" << produto;\r\n    return 0;\r\n}'),
(26,4,1,'#include <iostream>\r\nint main(){\r\n    int A, B;\r\n    std::cin >> A;\r\n    std::cin >> B;\r\n\r\n    if (A > B) {\r\n        std::cout << \"Maior: \" << A;\r\n    } else {\r\n        std::cout << \"Maior: \" << B;\r\n    }\r\n    return 0;\r\n}'),
(26,5,1,'#include <iostream>\r\nint main(){\r\n    int A;\r\n    std::cin >> A;\r\n    if (A % 2 == 0)\r\n    {\r\n        std::cout << \"Par\";\r\n    }else{\r\n        std::cout << \"Impar\";\r\n\r\n    }\r\n    return 0;\r\n}'),
(26,6,1,'#include <iostream>\r\n#include <vector>\r\nint main(){\r\n    int soma = 0;\r\n    std::vector<int> lista;\r\n\r\n    for(int i=0; i < 5; i++){\r\n        int item;\r\n        std::cin >> item;\r\n        lista.push_back(item);\r\n    }\r\n\r\n\r\n\r\n    for(int i=0; i < 5; i++){\r\n        soma = soma + lista[i];\r\n    }\r\n\r\n\r\n\r\n    std::cout << \"Soma: \" << soma;\r\n    return 0;\r\n}'),
(26,7,1,'#include <iostream>\r\n#include <vector>\r\n#include <iomanip>\r\n\r\nint main(){\r\n    float soma = 0;\r\n    std::vector <float> lista;\r\n\r\n    for (int i=0; i < 4; i++)\r\n    {\r\n        float item;\r\n        std::cin >> item;\r\n        lista.push_back(item);\r\n\r\n    }\r\n\r\n    for(int i=0; i < 4; i++)\r\n    {\r\n        soma = soma + lista [i];\r\n    }\r\n\r\n    std::cout << std::fixed << std::setprecision(1);\r\n    std::cout <<\"Media: \" << (soma / 4.0);\r\n    return 0; \r\n}'),
(26,8,1,'#include <iostream>\r\n\r\nint soma(int a, int b) {\r\n    return a + b;\r\n}'),
(26,9,1,'#include <iostream>\r\n\r\nint mult(int a, int b) {\r\n    return a * b;\r\n}'),
(26,10,1,'void troca(int &A, int &B){\r\n    int temp = A;\r\n    A = B;\r\n    B = temp;\r\n}'),
(26,11,1,'#include <iostream>\r\n#include <vector>\r\n\r\nstd::vector <int> criaVetor(){\r\n    std::vector<int> resultado = {0,1,2,3,4,5,6,7,8,9};  \r\n\r\n    return resultado;\r\n}\r\n'),
(26,12,1,'#include <iostream>\r\n#include <vector>\r\n\r\nstd::vector <float> notas = {5, 10, 2};\r\n\r\nfloat primeiraNota(){\r\n    return notas [0];\r\n}\r\n'),
(26,13,1,'#include <iostream>\r\n#include <algorithm>\r\n\r\nint maximo(int a, int b, int c) {\r\n    return std::max(a, std::max(b, c));\r\n}\r\n'),
(26,14,1,'#include <vector>\r\n\r\nstd::vector<float> notas = {5, 10, 2};\r\n\r\nstd::vector<float> outrasNotas(){\r\n\r\n    std::vector<float> resultado;\r\n\r\n    int tamanho=notas.size();\r\n\r\n    int posicao1 = tamanho - 2;\r\n    int posicao2 = tamanho - 1;\r\n\r\n    resultado.push_back(notas[posicao1]);\r\n    resultado.push_back(notas[posicao2]);\r\n\r\n    return resultado;\r\n}'),
(26,19,1,'#include <iostream>\r\n\r\nusing namespace std;\r\n\r\nint potencia(int base, int expoente) {\r\n    int resultado = 1;\r\n    int i = 0;\r\n    while (i < expoente) {\r\n        resultado *= base;\r\n        ++i;\r\n    }\r\n    return resultado;\r\n}'),
(26,20,1,'#include <iostream>\r\n\r\nusing namespace std;\r\n\r\nvoid dobra(int &valor) {\r\n    valor *= 2;\r\n}'),
(26,31,1,'#include <iostream>\r\nusing namespace std;\r\n\r\nint absoluto(int m){\r\n    if (m < 0) {\r\n        return -m;\r\n    } else {\r\n        return m;\r\n    }\r\n\r\n}'),
(26,33,1,'#include <cmath>\r\n\r\ndouble raizQuadrada(double x) {\r\n    return std::sqrt(x);\r\n}'),
(26,34,1,'#include <cmath>\r\n\r\nfloat potencia (float base, float expoente) {\r\n    return std::pow(base, expoente);\r\n\r\n}\r\n\r\n\r\n\r\n'),
(26,35,1,'#include <iostream>\r\n#include <cmath>\r\n\r\ndouble seno (double angulo) {\r\n    return std:: sin (angulo);\r\n}'),
(26,36,1,'#include <iostream>\r\n#include <cmath>\r\n\r\ndouble cosseno (double angulo) {\r\n    return std:: cos (angulo);\r\n}'),
(26,37,1,'#include <iostream>\r\n#include <cmath>\r\n\r\ndouble arredondar (double numero) {\r\n    return std::round (numero);\r\n}'),
(26,38,1,'#include <iostream>\r\n#include <string>\r\n\r\nsize_t quantasLetras(const std::string& palavra) {\r\n    return palavra.size();\r\n}\r\n'),
(26,41,1,'#include <string>\r\n#include <algorithm>\r\n\r\nstd::string tudoMaiusculo(std::string palavra) {\r\n    std::transform(palavra.begin(), palavra.end(), palavra.begin(), ::toupper);\r\n    return palavra;\r\n}'),
(26,42,1,'#include <iostream>\r\n#include <string>\r\n\r\nint comecaComA(int palavra) {\r\n    return !palavra.empty() && (palavra[0] == \'a\' || palavra[0] == \"A\");\r\n}\r\n\r\nint main() {\r\n    std::string palavra;\r\n    std::cout << \"palavra: \" ;\r\n    std::cin >> palavra;\r\n\r\n    if (comecaComA(palavra)) {\r\n        std::cout << \" A palavra \" << palavra << \" começa com a \" << std::endl;\r\n    } else {\r\n        std::cout << \" A palavra \" << palavra << \" não começa com a \" << std::endl;\r\n    }\r\n\r\n    return 0;\r\n}'),
(26,43,1,'#include <iostream>\r\n#include <string>\r\n\r\nclass Pessoa{\r\n\r\n    public:\r\n\r\n    std::string nome;\r\n    int idade;\r\n};'),
(26,44,1,'#include <iostream>\r\n#include <string>\r\n\r\nclass Pessoa{\r\n\r\n    private:\r\n        std::string pensamento;\r\n        bool acordada;\r\n\r\n    public:\r\n        std::string getPensamento(){\r\n            return pensamento;\r\n        }\r\n        bool setPensamento(std::string p){\r\n            pensamento = p;\r\n        }\r\n\r\n    Pessoa p;\r\n    p.setPensamento(\"Estou com sono\");\r\n    p.setAcordada(false);\r\n};'),
(26,45,1,'#include <iostream>\r\n#include <vector>\r\n\r\nint somaPares(const std::vector<int>& vetor) {\r\n    int soma = 0;\r\n    for (int numero : vetor) {\r\n        if (numero % 2 == 0) {\r\n            soma += numero;\r\n        }\r\n    }\r\n    return soma;\r\n}'),
(26,46,1,'#include <iostream>\r\n#include <string>\r\n\r\nbool ehPalindromo(const std::string& texto) {\r\n    int inicio = 0;\r\n    int fim = texto.length() - 1;\r\n\r\n    while (inicio < fim) {\r\n        if (texto[inicio] != texto[fim]) {\r\n            return false;\r\n        }\r\n        inicio++;\r\n        fim--;\r\n    }\r\n    return true;\r\n}'),
(26,47,1,'#include <iostream>\r\n#include <string>\r\n#include <cctype>   // para tolower\r\n#include <cstring>  // para strchr\r\n\r\nint contaVogais(const std::string& texto) {\r\n    const char* vogais = \"aeiou\";\r\n    int contador = 0;\r\n\r\n    for (char c : texto) {\r\n        if (std::strchr(vogais, std::tolower(c)) != nullptr) {\r\n            contador++;\r\n        }\r\n    }\r\n\r\n    return contador;\r\n}'),
(26,48,1,'#include <iostream>\r\nusing namespace std;\r\n\r\nint somaDigitos(unsigned long numero) {\r\n    int soma = 0;\r\n    while (numero > 0) {\r\n        soma += numero % 10;   // Extrai o último dígito e soma\r\n        numero /= 10;          // Remove o último dígito\r\n    }\r\n    return soma;\r\n}'),
(27,1,1,'#include <iostream>\r\nusing namespace std;\r\n\r\nint main() \r\n{\r\n    std::cout << \"Ola, Mundo!\";\r\n    return 0;\r\n}\r\n'),
(27,2,1,'#include <iostream>\r\n\r\nint main()\r\n{\r\nint a;\r\nint b;\r\n\r\nstd::cin >> a;\r\nstd::cin >> b;\r\n\r\nstd::cout << \"Soma: \" << a + b;\r\nreturn 0;\r\n}'),
(27,3,1,'#include <iostream>\r\n\r\nint main()\r\n{\r\nint a;\r\nint b;\r\n\r\nstd::cin >> a;\r\nstd::cin >> b;\r\n\r\nstd::cout << \"Produto: \" << a * b;\r\nreturn 0;\r\n}'),
(27,4,1,'#include <iostream>\r\n\r\nint main()\r\n{\r\n    int a;\r\n    int b;\r\n\r\n    std::cin >> a;\r\n    std::cin >> b;\r\n\r\n    if ( a > b){\r\n        std::cout << a;\r\n    }else{\r\n        std::cout << \"Maior: \"<< b;\r\n    }\r\n    return 0;\r\n}'),
(27,5,1,'#include <iostream>\r\n\r\nint main() \r\n{\r\n    int A;\r\n    std::cin >> A;\r\n    if (A % 2 == 0) \r\n    {\r\n        std::cout << \"par\" << std::endl;\r\n    } else {\r\n        std::cout << \"Impar\" << std::endl;\r\n    }\r\n    \r\n    \r\n    return 0;\r\n}'),
(27,6,1,'#include <iostream>\r\nint main() \r\n{\r\n    int numeros[5];\r\n    int soma = 0;\r\n\r\n    for (int i = 0; i < 5; i++) \r\n    {\r\n        std::cin >> numeros[i];\r\n        soma += numeros[i];\r\n    }\r\n    \r\n    std::cout << \"Soma: \" << soma;\r\n\r\n    return 0;\r\n}\r\n\r\n'),
(27,7,1,'#include <iostream>\r\n#include <iomanip>\r\nint main() \r\n{\r\n    float numeros[4];\r\n    float soma = 0;\r\n\r\n    for (int i = 0; i < 4; i++) \r\n    {\r\n        std::cin >> numeros[i];\r\n        soma += numeros[i];\r\n    }\r\n    \r\n    float media = soma/4;\r\n\r\n    \r\n    std::cout << std::fixed << std::setprecision(1);\r\n\r\n    std::cout << \"Media: \" << media;\r\n\r\n    return 0;\r\n}\r\n\r\n'),
(27,8,1,'int soma(int a,int b) \r\n{\r\n    return a + b;\r\n}\r\n\r\n'),
(27,9,1,'int mult(int a,int b) \r\n{\r\n    return a * b;\r\n}\r\n\r\n'),
(27,10,1,'void troca(int &a, int &b)\r\n{\r\n    int temp = a;\r\n    a = b;\r\n    b =temp;\r\n}'),
(27,11,1,'#include <vector>\r\nstd::vector <int> criaVetor()\r\n{\r\n    std::vector<int> lista;\r\n    lista.push_back(10);\r\n    lista.push_back(9);\r\n    lista.push_back(8);\r\n    lista.push_back(7);\r\n    lista.push_back(6);\r\n    lista.push_back(5);\r\n    lista.push_back(4);\r\n    lista.push_back(3);\r\n    lista.push_back(2);\r\n    lista.push_back(1);\r\n    return lista;\r\n}'),
(27,12,1,'#include <vector>\r\nstd::vector <float> notas = {5, 10,2};\r\n    int primeiraNota(){\r\n    return notas[0];\r\n}\r\n\r\n'),
(27,13,1,'#include <algorithm>\r\n\r\nint maximo(int a, int b, int c)\r\n{\r\n    return std::max(a, std::max(b, c));\r\n}\r\n'),
(27,14,1,'#include <vector>\r\nstd::vector<float> notas = {5, 10, 2};\r\nstd::vector<float> outrasNotas(){\r\n    int tamanho = notas.size();\r\n\r\n    int ultimo = tamanho -1;\r\n    int penultimo = tamanho -2;\r\n    std::vector <float> resultado = {notas[penultimo], notas[ultimo]};\r\n\r\n    return resultado;\r\n\r\n}'),
(27,19,1,'int potencia(int base,int expoente) \r\n{\r\n    int resultado = 1;\r\n\r\n    for (int i = 0; i < expoente; ++i)\r\n    {\r\n        resultado *= base;\r\n    }\r\n    return resultado;\r\n}'),
(27,20,1,'#include <iostream>\r\nvoid dobra(int a;) \r\n{\r\n    a& *= 0;\r\n    dobra(a);\r\n    return 0;\r\n}\r\n\r\n    \r\n'),
(27,31,1,'int absoluto(int a)\r\n{\r\n    if (a < 0){\r\n        a = a*-1;\r\n    }\r\n    return a;\r\n}'),
(27,33,1,'#include <cmath>\r\n\r\nint raizQuadrada(double a)\r\n{\r\n   return std::sqrt(a);\r\n}'),
(27,34,1,'#include <cmath>\r\n\r\nint potencia(double base, double expoente)\r\n{\r\n    return std::pow(base, expoente);\r\n      \r\n}'),
(27,35,1,'#include <cmath>\r\n\r\nint seno(float a)\r\n{\r\n    return std::sin(a);\r\n}'),
(27,36,1,'#include <cmath>\r\n\r\nint cosseno(float a)\r\n{\r\n    return std::cos(a);\r\n}'),
(27,37,1,'#include <cmath>\r\n\r\nint arredondar(float a)\r\n{\r\n    return std::round(a);\r\n}\r\n\r\n\r\n'),
(27,38,1,'int quantasLetras(std::string palavra)\r\n{\r\n    int quantidade = palavra.size();\r\n    return quantidade;\r\n}'),
(27,41,1,'#include <string>\r\n#include <algorithm>\r\n\r\nstd::string tudoMaiusculo(std::string palavra) \r\n{\r\n    std::transform(palavra.begin(), palavra.end(), palavra.begin(), ::toupper);\r\n    return palavra;\r\n}'),
(27,42,1,'bool comecaComA(std::string palavra)\r\n{\r\n    if(palavra[0] == \'a\'){\r\n        return true;\r\n    }\r\n    if(palavra[0] == \'A\'){\r\n        return true;\r\n    } \r\n     return false;\r\n}'),
(27,43,1,'#include <string>\r\n\r\n\r\nclass Pessoa\r\n{\r\npublic:\r\n\r\n    std::string nome;\r\n    int idade;\r\n};'),
(29,1,1,'#include <iostream>\r\nint main(){\r\n    std::cout << \"Ola, Mundo!\";\r\nreturn 0;}'),
(29,2,1,'#include <iostream>\r\n\r\nint main(){\r\n    \r\n    int a, b;\r\n\r\n    std::cin >> a >> b;\r\n\r\n    std::cout << \"Soma: \" << a + b;\r\n\r\n    return 0;\r\n}'),
(29,3,1,' #include <iostream>\r\n\r\nint main(){\r\n    \r\n    int a, b;\r\n\r\n    std::cin >> a >> b;\r\n\r\n    std::cout << \"Produto: \" << a * b;\r\n\r\n    return 0;\r\n}'),
(29,4,1,'#include <iostream>\r\nint main(){\r\n    int a, b;\r\n\r\n    std::cin>> a>> b;\r\n    if ( a>b) {\r\n        std::cout<< \"Maior: \" << a;\r\n\r\n    }\r\n    else{\r\n        std::cout<<\"Maior: \"<< b;\r\n    }\r\n    return 0;\r\n}'),
(29,5,1,'#include <iostream>\r\nint main(){\r\n    int a; \r\n    std::cin >> a;  \r\n    if( a %2 ==0){\r\n    std::cout << \"Par\";\r\n}else{\r\n    std::cout << \"Impar\";\r\n}\r\nreturn 0;\r\n}'),
(29,6,1,'#include <iostream>\r\n#include <vector>\r\nint main(){\r\n    int a;\r\n    std::vector<int> lista;\r\n    \r\n    for(int i=0; i<5; i++){\r\n        std::cin>> a;\r\n        lista.push_back(a);\r\n    }\r\n   \r\n   int soma = 0;\r\n   for(int i=0; i < 5;i++){\r\n    soma= soma+lista[i];\r\n   }\r\n   std::cout<<  \"Soma: \" << soma;\r\n\r\n   return 0;\r\n}'),
(29,7,1,'#include <iostream>\r\n#include <iomanip>\r\n\r\nint main(){\r\n   float a, b, c, d;\r\n    std::cin >> a >> b >> c >> d;\r\n    float media = (a + b + c + d) / 4;\r\n    std::cout << std::fixed << std::setprecision(1);\r\n    std::cout<< \"Media: \"<< media;\r\n    return 0;\r\n}\r\n'),
(29,8,1,'#include <iostream>\r\n int soma (int a, int b){\r\n    return a+b;\r\n } '),
(29,9,1,'\r\nint mult (int a, int b){\r\n    return a * b;\r\n}\r\n '),
(29,10,1,'void  troca (int &a, int &b){\r\n    int temp= a;\r\n    a=b;\r\n    b=temp;\r\n}'),
(29,11,1,'#include <vector>\r\n#include <iostream>\r\n\r\nstd::vector<int> criaVetor(){\r\n    std::vector<int> vector = {1,2,3,4,5,6,7,8,9,10};\r\n    return vector;\r\n}\r\n'),
(29,12,1,'#include <iostream>\r\n#include <vector>\r\n\r\n        std::vector<float> notas = {5, 10, 2};\r\n        float primeiraNota(){\r\n            return notas[0];\r\n        }'),
(29,13,1,'#include <algorithm>\r\n\r\nint maximo(int a, int b, int c){\r\n    int temp= std::max(a, b);\r\n    return std::max(temp, c);\r\n\r\n}\r\n'),
(29,14,1,'#include <'),
(29,19,1,'int potencia(int base, int expoente){\r\n    int resultado = 1;\r\n\r\n    for(int i=0; i < expoente; i++){\r\n        resultado = resultado* base;\r\n    }\r\n    return resultado;\r\n}'),
(29,20,1,'void dobra(int &a){\r\n    a= a * 2;\r\n}'),
(29,31,1,' int absoluto(int a){\r\n    if(a < 0){\r\n        return -a;\r\n    }else{\r\n        return a;\r\n    }\r\n}'),
(29,33,1,'#include <cmath>\r\n\r\ndouble raizQuadrada(double a){\r\n    return std::sqrt(a);\r\n}\r\n'),
(29,34,1,'#include <cmath>\r\n\r\nfloat potencia(float base, float  expoente){\r\n    return std::pow(base, expoente);\r\n}'),
(29,35,1,'#include <cmath>\r\n\r\ndouble seno (double a){\r\n    return std::sin(a);\r\n\r\n}'),
(29,36,1,'#include <cmath>\r\n\r\ndouble cosseno (double a){\r\n    return std::cos(a);\r\n\r\n}'),
(29,37,1,'#include <cmath>\r\n\r\ndouble arredondar(double a){\r\n    return std::round(a);\r\n}'),
(29,38,1,'#include <string>\r\n    int quantasLetras(std::string a ){\r\n        return a.size();\r\n    }'),
(29,41,1,'#include <string>\r\n#include <algorithm>\r\n\r\nstd::string tudoMaiusculo(std::string palavra) {\r\n    std::transform(palavra.begin(), palavra.end(), palavra.begin(), ::toupper);\r\n    return palavra;\r\n}'),
(29,42,1,'#include <iostream>\r\n#include <string>\r\n    \r\n    bool comecaComA(const std::string& palavra){\r\n        if(palavra.empty()){\r\n            return false;\r\n        }\r\n        return (palavra[0]==\'a\'|| palavra[0]==\'A\');\r\n    }\r\n'),
(30,1,1,'#include <iostream>\r\nusing namespace std;\r\n\r\nint main()\r\n{\r\n    cout << \"Ola, Mundo!\";\r\n    return 0;\r\n}'),
(30,2,1,'#include <iostream>\r\n \r\nint main()\r\n{\r\n  int A;\r\n  int B; \r\n  std::cin>> A;\r\n  std::cin>> B;\r\n  std::cout <<\"Soma: \" << A+ B;\r\n};\r\n '),
(30,3,1,'#include <iostream>\r\n \r\nint main()\r\n{\r\n  int A;\r\n  int B; \r\n  std::cin>> A;\r\n  std::cin>> B;\r\n  std::cout << \"Produto: \" << A * B;\r\n\r\n  return 0;\r\n};'),
(30,4,1,'#include <iostream>\r\n \r\nint main()\r\n{\r\n  int A;\r\n  int B; \r\n  std::cin >> A;\r\n  std::cin >> B;\r\n  if (A > B ){ \r\n    std::cout << \"Maior: \" <<  A;\r\n  }else{\r\n    std::cout << \"Maior: \" << B;\r\n  }\r\n  return 0;\r\n}'),
(30,5,1,'#include <iostream>\r\n \r\nint main()\r\n{\r\n  int A;\r\n  std::cin>> A;\r\n  if (A% 2 == 0)\r\n  {\r\n    std::cout << \"Par\";\r\n  }else{\r\n    std::cout << \"Impar\";\r\n  }\r\n  return 0;\r\n}\r\n '),
(30,6,1,'#include <iostream>\r\n#include <vector>\r\n \r\nint main(){\r\n    int soma = 0;\r\n    std::vector <int> lista;\r\n   \r\n    for(int i=0; i < 5; i++)\r\n    {\r\n        int item;\r\n        std::cin >> item;\r\n        lista.push_back(item);\r\n    }\r\n \r\n    for(int i=0; i < 5; i++)\r\n    {\r\n        soma = soma + lista [i];\r\n    }\r\n \r\n    std::cout << \"Soma: \" << soma;\r\n    return 0;\r\n}\r\n \r\n '),
(30,7,1,'#include <iostream>\r\n#include <vector>\r\n#include <iomanip>\r\n\r\nint main(){\r\n    float soma = 0;\r\n    std::vector <float> lista;\r\n   \r\n    for(int i=0; i < 4; i++)\r\n    {\r\n        float item;\r\n        std::cin >> item;\r\n        lista.push_back(item);\r\n    }\r\n \r\n    for(int i=0; i < 4; i++)\r\n    {\r\n        soma = soma + lista [i];\r\n    }\r\n \r\n    std::cout << std::fixed << std::setprecision(1);\r\n    std::cout << \"Media: \" << (soma / 4.0);\r\n    return 0;\r\n}\r\n \r\n '),
(30,8,1,'#include <iostream>\r\n\r\nint soma(int a, int b){\r\n    return a + b;\r\n}'),
(30,9,1,'#include <iostream>\r\n\r\nint mult(int a, int b){\r\n    return a * b;\r\n}'),
(30,10,1,'void troca (int &A, int &B)\r\n{\r\n   int temp = A;\r\n    A = B;\r\n    B =temp; \r\n}\r\n'),
(30,11,1,'\r\n#include <vector>\r\n\r\nstd::vector <int> criaVetor(){\r\n    std::vector <int> resultado = {0,1,2,3,4,5,6,7,8,9};\r\n\r\n    return resultado;\r\n}'),
(30,12,1,'#include <vector>\r\n#include <iostream>\r\n\r\nstd::vector <float> notas = {5,10,2};\r\n\r\nfloat primeiraNota(){\r\n\r\n    return notas[0];\r\n}'),
(30,13,1,'#include <algorithm>\r\n\r\nint maximo(int a, int b, int c) {\r\n\r\n    int maior_ab = std::max(a, b);\r\n \r\n    int maior_abc = std::max(maior_ab, c);\r\n \r\n    return maior_abc;\r\n}\r\n\r\n'),
(30,14,1,'#include <vector> \r\n#include <iostream>\r\n\r\nstd::vector <float> notas = {5,10,2};\r\n\r\nstd::vector <float> outrasNotas(){ \r\n    int tamanho = notas.size();\r\n    float ultimaNota = notas[tamanho-1]; \r\n    float penultimaNota = notas[tamanho-2]; \r\n\r\n    std::vector <float> outrasnotas;\r\n    outrasnotas.push_back(penultimaNota);\r\n    outrasnotas.push_back(ultimaNota);\r\n\r\n    return outrasnotas;\r\n}'),
(30,19,1,'#include <algorithm>\r\n\r\nint potencia (int base, int expoente) {\r\n\r\n    int res = 1;\r\n\r\n    for(int i = 0; i < expoente; i++){\r\n        res = res * base;\r\n    }\r\n    return res; \r\n}\r\n\r\n'),
(30,20,1,'void dobra(int &A)\r\n{\r\n    A = A*2;\r\n\r\n\r\n}'),
(30,31,1,'\r\n\r\nint absoluto (int A){\r\n    if ( A < 0){\r\n        A = A * -1;\r\n        return A;\r\n    }\r\n\r\n    return A;\r\n}\r\n\r\n\r\n\r\n// int temp = A;\r\n//     A = B;\r\n//     B =temp; '),
(30,33,1,'#include <cmath>\r\ndouble raizQuadrada(double x){\r\n    return std::sqrt(x);\r\n}'),
(30,34,1,'#include <cmath>\r\ndouble potencia(double base, double expoente){\r\n return std::pow(base, expoente);\r\n }'),
(30,35,1,'#include <cmath>\r\n\r\nfloat seno (float angulo ){\r\n\r\nstd:: sin\r\n}'),
(34,1,1,'#include <iostream>\r\n\r\nint main(int argc,char const*argv)\r\n{\r\n    std::cout << \"Ola, Mundo!\";\r\n    return 0;\r\n}'),
(34,2,1,'#include <iostream>\r\n int main(){\r\n    int a;\r\n    int b;\r\n    \r\n    std::cin >> a;\r\n    std::cin >> b;\r\n\r\n    std::cout << \"Soma: \" << a +b;\r\n\r\n    return 0;\r\n    \r\n}'),
(34,3,1,'#include <iostream>\r\n int main(){\r\n    int a;\r\n    int b;\r\n    \r\n    std::cin >> a;\r\n    std::cin >> b;\r\n\r\n    std::cout << \"Produto: \" << a * b;\r\n }\r\n\r\n'),
(34,4,1,'#include <iostream>\r\n int main(){\r\n    int a;\r\n    int b;\r\n    \r\n    std::cin >> a;\r\n    std::cin >> b;\r\n\r\n    if(a > b){\r\n         std::cout << \"Maior: \" << a;\r\n    }else{\r\n         std::cout << \"Maior: \" << b;\r\n    }\r\n    \r\n   return 0;\r\n }'),
(34,5,1,'#include <iostream>\r\n int main(){\r\n    int a;\r\n    \r\n    std::cin >> a;\r\n\r\n\r\n    if(a % 2 == 0){\r\n        std::cout << \"Par\";\r\n    }else{\r\n        std::cout << \"Impar\";\r\n    }\r\n\r\n    return 0;\r\n    \r\n }'),
(34,6,1,'#include <iostream>\r\n#include <vector>\r\nint main(){\r\n    int a;\r\n    std::vector<int> lista;\r\n\r\n    for (int i=0; i<5; i++){\r\n        std::cin >> a;\r\n        lista.push_back(a);\r\n    }\r\n\r\n    int soma = 0;\r\n    for(int i=0;i<5;i++) {\r\n        soma= soma+lista[i];\r\n    }\r\n\r\n    std::cout<<\"Soma: \" << soma;\r\n\r\n    return 0;\r\n}'),
(34,7,1,'#include <iostream>\r\n#include <iomanip>\r\n\r\nint main(){\r\n    float a, b, c, d;\r\n    std::cin >> a >> b >> c >> d;\r\n    float Media = (a+b+c+d) / 4;\r\n    std::cout << std::fixed << std::setprecision(1);\r\n    std::cout<< \"Media: \"<<Media;\r\n    return 0;\r\n}\r\n'),
(34,8,1,'#include <iostream>\r\nint soma (int a, int b){\r\n    return a+b;\r\n}'),
(34,9,1,'void troca (int &a, int &b){\r\n    int temp= a;\r\n    a=b;\r\n    b=temp;\r\n}'),
(34,10,1,'void troca (int &a, int &b){\r\n    int temp= a;\r\n    a=b;\r\n    b=temp;\r\n}'),
(34,11,1,'#include <vector>\r\n#include <iostream>\r\n\r\nstd::vector<int> criaVetor(){\r\n    std::vector <int> lista={1,2,3,4,5,6,7,8,9,10};\r\n    return lista;\r\n}'),
(34,12,1,'#include <iostream>\r\n#include <vector>\r\n\r\nstd::vector<float> notas ={5, 10, 2};\r\nfloat primeiraNota(){\r\n    return notas[0];\r\n}\r\n    '),
(34,13,1,'#include <algorithm>\r\n\r\nint maximo(int a, int b, int c){\r\n    int temp= std::max(a, b);\r\nreturn std::max(temp,c);\r\n\r\n}\r\n'),
(34,14,1,'#include <vector>\r\n\r\nstd::vector <float> notas = {5, 10, 2};\r\n\r\n\r\nstd::vector <float> outrasNotas(){\r\n    int tamanho=notas.size();\r\n    int ultimo=tamanho-1;\r\n    int penutimo=tamanho-2;\r\n    std::vector<float> resultado;\r\n    resultado.push_back(notas[penutimo]);\r\n    resultado.push_back(notas[ultimo]);\r\n    return resultado;\r\n}'),
(34,19,1,'#include <vector>\r\npotencia(2,3) \r\nstd::vector <valor>=(1)\r\nint valor=1;\r\nfor(int=0;i<expi i++){\r\nvalor=valor*base\r\nint valor=2;\r\nfor(int=0,i<expi i++)\r\nvalor=valor*base\r\nint valor=3;\r\nfor(int=0)\r\n}'),
(35,1,1,'#include <iostream> \r\nint main (){\r\nstd::cout << \"Ola, Mundo!\";\r\n\r\nreturn 0; }'),
(35,2,1,'#include <iostream>\r\n\r\nint main(){\r\n\r\nint a,b;\r\n\r\nstd::cin >> a >> b;\r\n\r\nstd::cout << \"Soma: \" << a + b;\r\n\r\nreturn 0;\r\n\r\n}'),
(35,3,1,'#include <iostream>\r\n\r\nint main(){\r\n\r\nint a,b;\r\n\r\nstd::cin >> a >> b;\r\n\r\nstd::cout << \"Produto: \" << a * b;\r\n\r\nreturn 0;\r\n}\r\n'),
(35,4,1,'#include <iostream> \r\n\r\nint main(){\r\n\r\nint a;\r\nint b;\r\n\r\nstd::cin >> a >> b;\r\n\r\nif(a>b){\r\n    std::cout << \"Maior: \" <<a;\r\n}else{\r\n    std::cout << \"Maior: \" <<b;\r\n}\r\nreturn 0;\r\n}'),
(36,1,1,'#include <iostream>\r\nusing namespace std;\r\n\r\nint main()\r\n{\r\nstd::cout << \"Ola, Mundo!\";\r\nreturn 0;\r\n}'),
(36,2,1,'#include <iostream>\r\n\r\nint main()\r\n{\r\n    int a;\r\n    int b;\r\n\r\n    std::cin >> a >> b;\r\n\r\n    std::cout << \"Soma: \" << a + b;\r\n\r\n    return 0;\r\n}'),
(36,3,1,'#include <iostream>\r\n\r\nint main()\r\n{\r\n    int a;\r\n    int b;\r\n\r\n    std::cin >> a >> b;\r\n\r\n    std::cout << \"Produto: \" << a * b;\r\n\r\n    return 0;\r\n}'),
(36,4,1,'#include <iostream>\r\n\r\nint main()\r\n{\r\n    int a;\r\n    int b;\r\n\r\n    std::cin >> a;\r\n    std::cin >> b;\r\n    if(a>b){\r\n        std::cout << a;\r\n    }else{\r\n        std::cout << \"Maior: \"<< b;\r\n    }\r\n    return 0;\r\n}'),
(36,5,1,'#include <iostream>\r\n\r\nint main()\r\n{\r\n    int A;\r\n    std::cin>> A;\r\n    if (A% 2 == 0)\r\n    {\r\n        std::cout << \"Par\";\r\n    }else{\r\n        std::cout << \"Impar\";\r\n    }\r\n    return 0;\r\n}'),
(36,6,1,'#include <iostream>\r\n#include <vector>\r\n \r\nint main(){\r\n    int soma = 0;\r\n    std::vector <int> lista;\r\n   \r\n    for(int i=0; i < 5; i++)\r\n    {\r\n        int item;\r\n        std::cin >> item;\r\n        lista.push_back(item);\r\n    }\r\n \r\n    for(int i=0; i < 5; i++)\r\n    {\r\n        soma = soma + lista [i];\r\n    }\r\n \r\n    std::cout << \"Soma: \" << soma;\r\n    return 0;\r\n}'),
(36,7,1,'#include <iostream>\r\n#include <iomanip>\r\n\r\nint main() {\r\n    double n1, n2, n3, n4;\r\n    \r\n\r\n    std::cin >> n1 >> n2 >> n3 >> n4;\r\n\r\n\r\n    double media = (n1 + n2 + n3 + n4) / 4.0;\r\n\r\n    std::cout << std::fixed << std::setprecision(1);\r\n    std::cout << \"Media: \" << media;\r\n\r\n    return 0;\r\n}'),
(36,8,1,'#include <iostream>\r\n \r\nint soma(int a, int b){\r\n    return a + b;\r\n}'),
(36,9,1,'#include <iostream>\r\n\r\nint Soma(int a, int b){\r\n    return a * b;\r\n}'),
(36,10,1,'void troca(int &A, int &B)\r\n{\r\n    int temp = A;\r\n    A = B;\r\n    B =temp;\r\n}'),
(36,11,1,'#include <vector>\r\n\r\nstd::vector<int> criaVetor() {\r\n    std::vector<int> vetor;\r\n    for (int i = 0; i < 10; ++i) {\r\n        vetor.push_back(i * 2);\r\n    }\r\n    return vetor;\r\n}'),
(36,12,1,'#include <vector>\r\n\r\nstd::vector<float> notas {5,10,2};\r\nint primeiraNota(){\r\n    return notas[0];\r\n}\r\n'),
(36,13,1,'#include <algorithm>\r\n\r\nint maximo(int a, int b, int c) {\r\n    return std::max(a, std::max(b, c));\r\n}'),
(36,14,1,'#include <vector>\r\n\r\nstd::vector<float> notas = {5, 10, 2};\r\n\r\nstd::vector<float> outrasNotas(){\r\n    std::vector<float> resultado;\r\n\r\n    int tamanho = notas.size();\r\n    \r\n    int numero1 = tamanho -2;\r\n    int numero2 = tamanho -1;\r\n\r\n    resultado.push_back(notas[numero1]);\r\n    resultado.push_back(notas[numero2]);\r\n\r\n    return resultado;\r\n}'),
(36,19,1,'#include <iostream>\r\n\r\nint potencia(int base, int expoente) {\r\n    int resultado = 1;\r\n    for (int i = 0; i < expoente; i++) {\r\n        resultado *= base;\r\n    }\r\n    return resultado;\r\n}'),
(36,20,1,' void dobra(int &A)\r\n{\r\n    A = A * 2;\r\n}'),
(36,31,1,'int absoluto(int numero) \r\n{\r\n    return (numero < 0) ? -numero : numero;\r\n}'),
(36,33,1,'#include <cmath>\r\n\r\ndouble raizQuadrada(double x)\r\n {\r\n    return std::sqrt(x);\r\n}'),
(37,1,1,'#include <iostream>\r\n\r\nint main(){\r\n\r\nstd::cout << \"Ola, Mundo!\";\r\n\r\nreturn 0;\r\n}\r\n'),
(37,2,1,'#include <iostream>\r\n\r\nint main(){\r\n\r\nint a;\r\nint b;\r\n\r\nstd::cin >> a;\r\nstd::cin >> b;\r\nstd::cout << \"Soma: \" << a+b;\r\n\r\nreturn 0;\r\n\r\n}\r\n'),
(37,3,1,'#include <iostream>\r\n\r\nint main(){\r\n\r\nint a;\r\nint b;\r\n\r\nstd::cin >> a;\r\nstd::cin >> b;\r\nstd::cout << \"Produto: \" << a*b;\r\n\r\nreturn 0;\r\n\r\n}\r\n'),
(37,4,1,'#include <iostream>\r\n\r\nint main(){\r\n\r\n    int a;\r\n    int b;\r\n    \r\n    std::cin >> a >> b;\r\n    \r\n    if(a>b){\r\n    std::cout << \"Maior: \" << a;\r\n    }else{\r\n        std::cout << \"Maior: \" << b;\r\n    }\r\n    return 0;\r\n}\r\n'),
(37,5,1,'#include <iostream>\r\n\r\nint main(){\r\n\r\n    int a;\r\n    std::cin >> a;\r\n\r\n    if(a %2 == 0){\r\n        std::cout << \"Par\";\r\n    }else{\r\n        std::cout << \"Impar\";\r\n    }\r\n    return 0;\r\n}'),
(37,6,1,'#include <iostream>\r\n#include <vector>\r\n\r\nint main(){\r\n    int a;\r\n    std::vector<int> lista;\r\n\r\n    for(int i=0; i<5; i++){\r\n        std::cin >> a;\r\n        lista.push_back(a);\r\n    }\r\n\r\n    int soma = 0;\r\n    for(int i= 0; i < 5; i++){\r\n        soma= soma + lista[i];\r\n    }\r\n    std::cout << \"Soma: \" << soma;\r\n\r\n    return 0;\r\n}'),
(37,7,1,'#include <iostream>\r\n#include <vector>\r\n#include <iomanip>\r\n\r\nint main(){\r\n    float a, b, c, d, soma;\r\n\r\n    std::cin >> a >> b >> c >> d;\r\n    soma= a+b+c+d;\r\n    \r\n    std::cout << std::fixed << std::setprecision(1);\r\n    std::cout << \"Media: \" << soma / 4;\r\n}'),
(37,8,1,'#include <iostream>\r\n\r\nint soma(int a, int b){\r\n    return a + b;\r\n}'),
(37,9,1,'#include <iostream>\r\n\r\nint mult(int a, int b){\r\n    return a * b;\r\n}'),
(37,10,1,'void troca(int &a, int &b){\r\n    int temp= a;\r\n    a=b;\r\n    b=temp;\r\n}'),
(37,11,1,'#include <vector>\r\n#include <iostream>\r\n\r\nstd::vector<int> criaVetor(){\r\n    std::vector<int> vetor;\r\n    for(int i = 0; i < 10; i++){\r\n        vetor.push_back(i);\r\n    }\r\n\r\n    return vetor;\r\n    \r\n}'),
(37,12,1,'#include <iostream>\r\n#include <vector>\r\n\r\n    std::vector<float> notas = {5, 10, 2};\r\n    float primeiraNota(){\r\n        return notas[0];\r\n    }'),
(37,13,1,'#include <algorithm>\r\n\r\nint maximo(int a, int b, int c){\r\n    int temp= std::max (a, b);\r\n    return std::max (temp, c);\r\n}'),
(37,14,1,'#include <vector>\r\n\r\nstd::vector<float> notas = {5, 10, 2};\r\n\r\nstd::vector<float> outrasNotas(){\r\n    \r\n    std::vector<float> resultado;\r\n    \r\n    int tamanho=notas.size();\r\n\r\n    int posicao1 = tamanho - 2;\r\n    int posicao2 = tamanho - 1;\r\n\r\n    resultado.push_back(notas[posicao1]);\r\n    resultado.push_back(notas[posicao2]); \r\n\r\n    return resultado; \r\n\r\n}'),
(37,19,1,'int potencia(int base, int expoente){\r\n    int resultado = 1;\r\n\r\n    for(int i =0; i < expoente; i++ ){\r\n        resultado = resultado * base;\r\n    }\r\n    return resultado;\r\n}\r\n'),
(37,20,1,'void dobra (int &a){\r\n    a= a * 2;\r\n}'),
(37,31,1,'int absoluto(int a){\r\n    if(a < 0){\r\n        return -a;\r\n    }else{\r\n        return a;\r\n    }\r\n    \r\n}'),
(37,33,1,'#include <cmath>\r\n\r\ndouble raizQuadrada(double a){\r\n    return std::sqrt(a);\r\n}'),
(37,34,1,'#include <cmath>\r\n\r\nfloat potencia(float base, float expoente){\r\n    return std::pow(base, expoente);\r\n\r\n}'),
(37,35,1,'#include <cmath>\r\n\r\ndouble seno(double a){\r\n    return std::sin(a);\r\n    \r\n}'),
(37,36,1,'#include <cmath>\r\n\r\ndouble cosseno(double a){\r\n    return std::cos(a);\r\n}'),
(37,37,1,'#include <cmath>\r\n\r\ndouble arredondar(double a){\r\n    return std::round(a);\r\n}'),
(37,38,1,'#include <string>\r\n#include <iostream>\r\n\r\nint quantasLetras(const std::string& palavra){\r\n    return palavra.length();\r\n}'),
(37,41,1,'#include <string>\r\n#include <algorithm>\r\n\r\nstd::string tudoMaiusculo(std::string palavra) {\r\n    std::transform(palavra.begin(), palavra.end(), palavra.begin(), ::toupper);\r\n    return palavra;\r\n}'),
(37,42,1,'#include <string>\r\n\r\nbool comecaComA(std::string palavra){\r\n    return palavra[0] == \'a\' || palavra[0] == \'A\';\r\n}\r\n\r\n'),
(37,43,1,'#include <string>\r\n\r\nclass Pessoa{\r\n    public:\r\n\r\n    std::string nome;\r\n    int idade;\r\n};'),
(37,44,1,'#include <string>\r\n#include <iostream>\r\n\r\nclass Pessoa{\r\n    private:\r\n        std::string pensamento;\r\n        bool acordada;\r\n\r\n    public:\r\n       void setPensamento(std::string p){\r\n        pensamento = p;\r\n       }\r\n\r\n    std::string getPensamento(){\r\n        return pensamento;\r\n       }\r\n      \r\n       void setAcordada(bool a){\r\n        acordada = a;\r\n       }\r\n\r\n       bool isAcordada(){\r\n        return acordada;\r\n       }\r\n};'),
(37,45,1,'#include <vector>\r\n\r\nint somaPares(const std::vector<int> &numeros){\r\n    int soma = 0;\r\n\r\n    for(int num : numeros){\r\n        if(num % 2 == 0){\r\n            soma += num;\r\n        }\r\n    }\r\n    return soma;\r\n}'),
(37,46,1,'#include <string>\r\n\r\nbool ehPalindromo(std::string palavra){\r\n    int tamanho=palavra.size();\r\n    for(int i=0; i<tamanho; i++){\r\n        int esquerda= i;\r\n        int direita= tamanho-1-i;\r\n        if(palavra[esquerda] != palavra[direita]){\r\n               return false;\r\n        }\r\n    }\r\n\r\n    return true;\r\n}'),
(37,47,1,'#include <iostream>\r\n#include <cstring>\r\n\r\nint contarVogais(const std::string& str){\r\n    const char* vogais= \"aeiouAEIOU\";\r\n        int contador= 0;\r\n\r\n        for(char c : str){\r\n            if (strchr(vogais, c)){\r\n                contador++;\r\n            }\r\n        }   \r\n        \r\n        return contador;\r\n}'),
(37,48,1,'int somaDigitos(int numero){\r\n    int soma= 0;\r\n\r\n    while(numero > 0){\r\n        soma+= numero % 10;\r\n        numero = numero /10;\r\n    }\r\n    return soma;\r\n}'),
(38,1,1,'#include <iostream>\r\nusing namespace std;\r\n\r\nint main()\r\n{\r\n    cout << \"Ola, Mundo!\";\r\n    return 0;\r\n}'),
(38,2,1,'#include <iostream>\r\n\r\nint main()\r\n{\r\n    int num4, num5;\r\n    std::cin >> num4;\r\n    std::cin >> num5;\r\n    int soma = num4 + num5;\r\n    std::cout <<\"Soma: \" << soma;\r\n    return 0;\r\n}'),
(38,3,1,'#include <iostream>\r\n\r\nint main()\r\n{\r\n    int num4, num5;\r\n    std::cin >> num4;\r\n    std::cin >> num5;\r\n    int produto = num4 * num5;\r\n    std::cout <<\"Produto: \" << produto;\r\n    return 0;\r\n}'),
(38,4,1,'#include <iostream>\r\n\r\n\r\nint main()\r\n{\r\n    int A, B;\r\n    std::cin >> A;\r\n    std::cin >>B;\r\n    if(A > B)\r\n    {\r\n        std::cout <<\"Maior: \" << A;\r\n    } else{\r\n        std::cout <<\"Maior: \" << B;\r\n    }\r\n\r\n\r\n    return 0;\r\n}'),
(38,5,1,'#include <iostream>\r\nint main()\r\n{\r\n    int A;\r\n    std::cin >> A;\r\n    if (A % 2 == 0)\r\n    {\r\n        std::cout << \"Par\";\r\n    }else{\r\n        std::cout << \"Impar\";\r\n    }\r\n    return 0;\r\n}'),
(38,6,1,'#include <iostream>\r\n#include <vector>\r\n\r\nint main(){\r\n    int soma = 0;\r\n    std::vector <int> lista;\r\n    \r\n    for(int i=0; i < 5; i++)\r\n    {\r\n        int item;\r\n        std::cin >> item;\r\n        lista.push_back(item);\r\n    }\r\n\r\n    for(int i=0; i < 5; i++)\r\n    {\r\n        soma = soma + lista [i];\r\n    }\r\n\r\n    std::cout << \"Soma: \" << soma;\r\n    return 0;\r\n}\r\n'),
(38,7,1,'#include <iostream>\r\n#include <vector>\r\n#include <iomanip>\r\n \r\nint main(){\r\n    float soma = 0;\r\n    std::vector <float> lista;\r\n   \r\n    for(int i=0; i < 4; i++)\r\n    {\r\n        float item;\r\n        std::cin >> item;\r\n        lista.push_back(item);\r\n    }\r\n \r\n    for(int i=0; i < 4; i++)\r\n    {\r\n        soma = soma + lista [i];\r\n    }\r\n \r\n    std::cout << std::fixed << std::setprecision(1);\r\n    std::cout << \"Media: \" << (soma / 4.0);\r\n    return 0;\r\n}\r\n '),
(38,8,1,'#include <iostream>\r\n\r\nint soma(int a, int b){\r\n    return a + b;\r\n}'),
(38,9,1,'#include <iostream>\r\n\r\nint mult(int a, int b) {\r\n    return a * b;\r\n}'),
(38,10,1,'void troca (int &A, int &B)\r\n{\r\n    int temp = A;\r\n    A = B;\r\n    B =temp;\r\n}'),
(38,11,1,'#include <iostream>\r\n#include <vector>\r\n\r\nstd::vector <int> criaVetor(){\r\n    std::vector<int> resultado = {0,1,2,3,4,5,6,7,8,9};  \r\n\r\n    return resultado;\r\n}\r\n'),
(38,12,1,'#include <iostream>\r\n#include <vector>\r\n\r\nstd::vector <float> notas = {5, 10, 2};\r\n\r\nfloat primeiraNota(){\r\n    return notas [0];\r\n}\r\n'),
(38,13,1,'#include <iostream>\r\n#include <algorithm>\r\n\r\nint maximo(int a, int b, int c) {\r\n    return std::max(a, std::max(b, c));\r\n}'),
(38,14,1,'#include <iostream>\r\n#include <vector>\r\n\r\nstd::vector <float> notas = {5, 10, 2};\r\n\r\nstd::vector<float> outrasNotas(){\r\n\r\n    std::vector<float> resultado;\r\n\r\n    int tamanho=notas.size();\r\n\r\n    int posicao1 = tamanho - 2;\r\n    int posicao2 = tamanho - 1;\r\n\r\n    resultado.push_back(notas[posicao1]);\r\n    resultado.push_back(notas[posicao2]);\r\n    return resultado;\r\n}'),
(38,19,1,'#include <iostream>\r\n\r\nusing namespace std;\r\n\r\nint potencia(int base, int expoente) {\r\n    int resultado = 1; \r\n    int i = 0;\r\n    while(i < expoente){ \r\n        resultado *= base;\r\n        ++i;\r\n    }\r\n    return resultado;\r\n    \r\n}'),
(38,20,1,'#include <iostream>\r\n\r\nusing namespace std;\r\n\r\nvoid dobra(int &valor) {\r\n    valor *= 2;\r\n}'),
(38,31,1,'#include <iostream>\r\nusing namespace std;\r\n\r\nint absoluto(int m){\r\n    if (m < 0) {\r\n        return  -m; \r\n    } else {\r\n        return m;\r\n    }\r\n}'),
(38,33,1,'#include <cmath> \r\n\r\ndouble raizQuadrada(double x) {\r\n    return std::sqrt(x);\r\n}'),
(38,34,1,'#include <cmath>\r\n\r\nfloat potencia(float base, float expoente) {\r\n    return std::pow(base, expoente);\r\n}\r\n\r\n\r\n'),
(38,35,1,'#include <iostream>\r\n#include <cmath>\r\n\r\ndouble seno(double angulo) {\r\n    return std::sin(angulo);\r\n}\r\n\r\n'),
(38,36,1,'#include <iostream>\r\n#include <cmath>\r\n\r\ndouble cosseno(double angulo) {\r\n  return std::cos(angulo);\r\n}\r\n'),
(38,37,1,'#include <iostream>\r\n#include <cmath>\r\n\r\n double arredondar(double numero){\r\n    return std::round(numero); \r\n    \r\n}'),
(38,38,1,'#include <iostream>\r\n#include <string>\r\n\r\nsize_t quantasLetras(const std::string& palavra) {\r\n    return palavra.size(); \r\n}\r\n'),
(38,41,1,'#include <iostream>\r\n#include <string>\r\n#include <algorithm>\r\n#include <cctype>\r\n\r\nstd::string tudoMaiusculo(std::string palavra) {\r\n    std::transform(palavra.begin(), palavra.end(), palavra.begin(), ::toupper);\r\n    return palavra;\r\n}\r\n'),
(38,42,1,'#include <iostream>\r\n#include <string>\r\n\r\nbool comecaComA(const std::string& palavra) {\r\n    if (!palavra.empty()) {\r\n        char primeiraLetra = palavra[0];\r\n        return (primeiraLetra == \'a\' || primeiraLetra == \'A\');\r\n    }\r\n    return false;\r\n}\r\n'),
(38,43,1,'#include <iostream>\r\n#include <string>\r\n\r\nclass Pessoa {\r\npublic:\r\n    std::string nome;  \r\n    int idade;         \r\n \r\n    Pessoa p;  \r\n    p.nome = \"Ana\";  \r\n    p.idade = 30;    \r\n\r\n};\r\n'),
(38,44,1,'#include <iostream>\r\n#include <string>\r\nusing namespace std;\r\n\r\nclass Pessoa {\r\nprivate:\r\n    string pensamento;\r\n    bool acordada;\r\n\r\npublic:\r\n    // Define o pensamento\r\n    void setPensamento(string p) {\r\n        pensamento = p;\r\n    }\r\n\r\n    // Retorna o pensamento\r\n    string getPensamento() {\r\n        return pensamento;\r\n    }\r\n\r\n    // Define o estado acordada\r\n    void setAcordada(bool a) {\r\n        acordada = a;\r\n    }\r\n\r\n    // Retorna o estado acordada\r\n    bool getAcordada() {\r\n        return acordada;\r\n    }\r\n};\r\n\r\n// Exemplo de uso\r\nint main() {\r\n    Pessoa p;\r\n    p.setPensamento(\"Estou com sono\");\r\n    p.setAcordada(false);\r\n\r\n    cout << \"Pensamento: \" << p.getPensamento() << endl;\r\n    cout << \"Está acordada? \" << (p.getAcordada() ? \"Sim\" : \"Não\") << endl;\r\n\r\n    return 0;\r\n}'),
(38,45,1,'\r\n#include <iostream>\r\n#include <vector>\r\nusing namespace std;\r\n\r\n// Função que soma os elementos pares de um vetor\r\nint somaPares(const vector<int>& vetor) {\r\n    int soma = 0;\r\n\r\n    for (int x : vetor) {\r\n        if (x % 2 == 0) {\r\n            soma += x;\r\n        }\r\n    }\r\n\r\n    return soma;\r\n}\r\n\r\n// Exemplo de uso\r\nint main() {\r\n    vector<int> numeros = {1, 2, 3, 4, 5, 6};\r\n\r\n    int resultado = somaPares(numeros);\r\n\r\n    cout << \"Soma dos pares: \" << resultado << endl;\r\n\r\n    return 0;\r\n}'),
(38,46,1,'/*\r\nImplemente uma função que verifique se uma string é um palíndromo.\r\n\r\nDica: \r\nCompare caracteres simétricos da string usando dois índices.\r\n*/\r\ninclude <iostream>\r\n#include <string>\r\nusing namespace std;\r\nbool ehPalindromo(const string& texto) {\r\n    int inicio = 0;\r\n    int fim = texto.length() - 1;\r\n\r\n    while (inicio < fim) {\r\n        if (texto[inicio] != texto[fim]) {\r\n            return false; \r\n        }\r\n        inicio++;\r\n        fim--;\r\n    }\r\n\r\n    return true;\r\n}\r\nint main() {\r\n    string palavra;\r\n\r\n    cout << \"Digite uma palavra: \";\r\n    cin >> palavra;\r\n\r\n    if (ehPalindromo(palavra)) {\r\n        cout << \"É um palíndromo!\" << endl;\r\n    } else {\r\n        cout << \"Não é um palíndromo.\" << endl;\r\n    }\r\n\r\n    return 0;\r\n}\r\n');
/*!40000 ALTER TABLE `user_exercise` ENABLE KEYS */;
UNLOCK TABLES;
/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;

/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;

-- Dump completed on 2025-06-03 14:53:10