domain stringclasses 5
values | idx int64 0 79 | prompt stringlengths 221 8.29k | checks dict | failure_mode stringlengths 31 597 | reference_note stringlengths 29 295 |
|---|---|---|---|---|---|
pt-clinico | 0 | Redige uma CARTA DE REFERENCIACAO para a consulta de cardiologia de um homem de 61 anos, seguido na sua lista de utentes, com hipertensao arterial de longa data e dois episodios de enfarte agudo do miocardio (o ultimo ha 3 anos), agora com dispneia de esforco progressiva. A carta TEM de conter, cada um como cabecalho d... | {
"required": [
"^\\s*motivo da referencia[çc][ãa]o\\s*:",
"^\\s*antecedentes\\s*:",
"^\\s*medica[çc][ãa]o habitual\\s*:",
"^\\s*exame objectivo\\s*:",
"\\benfarte\\b",
"\\b61\\b",
"hipertens[ãa]o",
"dispneia"
],
"forbidden": [
"\\binfart[oa]s?\\b",
"\\bequipe\\b",
"\\b... | Carta de referenciacao com 4 seccoes obrigatorias + factos do enunciado; trap BR 'infarto'. | Sem FINAL; validado por presenca das 4 seccoes, terminologia europeia e factos (61/HTA/dispneia). |
pt-clinico | 1 | Escreve uma NOTA DE ALTA hospitalar para uma mulher de 74 anos internada por AVC isquemico, agora estavel e orientada. A nota TEM de incluir, cada um como cabecalho numa linha propria, EXACTAMENTE: 'Diagnostico principal:', 'Evolucao no internamento:', 'Medicacao a manter no domicilio:' e 'Sinais de alarme para regress... | {
"required": [
"^\\s*diagn[óo]stico principal\\s*:",
"^\\s*evolu[çc][ãa]o no internamento\\s*:",
"^\\s*medica[çc][ãa]o a manter no domic[íi]lio\\s*:",
"^\\s*sinais de alarme para regresso [àa] urg[êe]ncia\\s*:",
"\\bAVC\\b",
"\\b112\\b",
"\\b74\\b"
],
"forbidden": [
"\\bderrame\\b... | Nota de alta com 4 seccoes + AVC/112; trap 'derrame' como termo proprio. | Sem FINAL; validado por 4 seccoes, AVC, 112 e idade 74. |
pt-clinico | 2 | Escreve uma explicacao de CONSENTIMENTO INFORMADO, dirigida a um doente, para a realizacao de uma TOMOGRAFIA COMPUTORIZADA (TC) com contraste. Estrutura obrigatoria, cada cabecalho numa linha propria e EXACTAMENTE assim: 'Em que consiste o exame:', 'Beneficios esperados:', 'Riscos e efeitos secundarios:' e 'Alternativa... | {
"required": [
"^\\s*em que consiste o exame\\s*:",
"^\\s*benef[íi]cios esperados\\s*:",
"^\\s*riscos e efeitos secund[áa]rios\\s*:",
"^\\s*alternativas\\s*:",
"tomografia computorizada",
"contraste",
"alergi"
],
"forbidden": [
"\\btomografia computadorizada\\b",
"\\busu[áa]ri... | Consentimento TC com 4 seccoes; trap BR 'tomografia computadorizada' (PT: computorizada). | Sem FINAL; validado por 4 seccoes, 'tomografia computorizada', contraste e alergias. |
pt-clinico | 3 | Redige uma NOTA SOAP (Subjectivo, Objectivo, Avaliacao, Plano) para um utente de 55 anos que recorre ao centro de saude por tosse produtiva e febre ha 4 dias. A nota TEM de ter, cada um como cabecalho numa linha propria, EXACTAMENTE: 'S (Subjectivo):', 'O (Objectivo):', 'A (Avaliacao):' e 'P (Plano):'. No plano, refere... | {
"required": [
"^\\s*s \\(subjectivo\\)\\s*:",
"^\\s*o \\(objectivo\\)\\s*:",
"^\\s*a \\(avalia[çc][ãa]o\\)\\s*:",
"^\\s*p \\(plano\\)\\s*:",
"\\ban[áa]lises\\b",
"\\b112\\b",
"\\b55\\b"
],
"forbidden": [
"\\bexames\\s+laboratoriais\\b",
"\\busu[áa]ri[oa]s?\\b",
"\\bequipe... | Nota SOAP 4 seccoes + 'analises'/112; trap 'exames laboratoriais' (slip visto no aluno). | Sem FINAL; validado por 4 cabecalhos SOAP, 'analises', 112 e idade 55. |
pt-clinico | 4 | Escreve uma CARTA DE REFERENCIACAO para consulta de neurologia de uma mulher de 68 anos com perda de memoria progressiva ha 8 meses, desorientacao ocasional e uma queda recente sem perda de conhecimento. Cabecalhos obrigatorios, cada um numa linha propria e EXACTAMENTE: 'Motivo da referenciacao:', 'Historia da doenca a... | {
"required": [
"^\\s*motivo da referencia[çc][ãa]o\\s*:",
"^\\s*hist[óo]ria da doen[çc]a actual\\s*:",
"^\\s*antecedentes pessoais\\s*:",
"^\\s*medica[çc][ãa]o actual\\s*:",
"\\b8 meses\\b",
"queda",
"mem[óo]ria"
],
"forbidden": [
"\\busu[áa]ri[oa]s?\\b",
"\\bequipe\\b",
"... | Referenciacao neurologia com 4 seccoes + factos (8 meses/queda). | Sem FINAL; validado por 4 seccoes, '8 meses', queda e memoria. |
pt-clinico | 5 | Redige o RESUMO CLINICO de alta de um doente de 47 anos internado por pneumonia adquirida na comunidade, agora apirético e estavel. Cabecalhos obrigatorios, cada um numa linha propria e EXACTAMENTE: 'Diagnostico principal:', 'Antibioterapia realizada:', 'Recomendacoes no domicilio:' e 'Seguimento:'. Indica explicitamen... | {
"required": [
"^\\s*diagn[óo]stico principal\\s*:",
"^\\s*antibioterapia realizada\\s*:",
"^\\s*recomenda[çc][õo]es no domic[íi]lio\\s*:",
"^\\s*seguimento\\s*:",
"pneumonia",
"\\b112\\b",
"\\b47\\b"
],
"forbidden": [
"\\busu[áa]ri[oa]s?\\b",
"\\bequipe\\b",
"\\bestress?e... | Alta pneumonia 4 seccoes + 112. | Sem FINAL; validado por 4 seccoes, pneumonia, 112 e idade 47. |
pt-clinico | 6 | Escreve uma explicacao de CONSENTIMENTO INFORMADO para uma ENDOSCOPIA DIGESTIVA ALTA, dirigida a um doente. Estrutura obrigatoria, cada cabecalho numa linha propria e EXACTAMENTE: 'Objectivo do exame:', 'Preparacao necessaria:', 'Riscos possiveis:' e 'O que fazer apos o exame:'. Refere explicitamente o jejum prévio e q... | {
"required": [
"^\\s*objectivo do exame\\s*:",
"^\\s*prepara[çc][ãa]o necess[áa]ria\\s*:",
"^\\s*riscos poss[íi]veis\\s*:",
"^\\s*o que fazer ap[óo]s o exame\\s*:",
"jejum",
"\\b112\\b",
"endoscopia"
],
"forbidden": [
"\\busu[áa]ri[oa]s?\\b",
"\\bequipe\\b",
"\\bestress?e\... | Consentimento endoscopia 4 seccoes + jejum + 112. | Sem FINAL; validado por 4 seccoes, jejum, endoscopia e 112. |
pt-clinico | 7 | Redige uma CARTA DE REFERENCIACAO para consulta de pneumologia de um fumador de 63 anos com tosse cronica e um episodio de hemoptise (sangue na expetoracao). Cabecalhos obrigatorios, cada um numa linha propria e EXACTAMENTE: 'Motivo da referenciacao:', 'Antecedentes:', 'Habitos:' e 'Exames complementares pedidos:'. Men... | {
"required": [
"^\\s*motivo da referencia[çc][ãa]o\\s*:",
"^\\s*antecedentes\\s*:",
"^\\s*h[áa]bitos\\s*:",
"^\\s*exames complementares pedidos\\s*:",
"hemoptise",
"tomografia computorizada",
"\\b63\\b"
],
"forbidden": [
"\\btomografia computadorizada\\b",
"\\busu[áa]ri[oa]s?\... | Referenciacao pneumologia 4 seccoes + hemoptise + TC computorizada. | Sem FINAL; validado por 4 seccoes, hemoptise, 'tomografia computorizada', 63. |
pt-clinico | 8 | Escreve uma NOTA DE ALTA para uma doente de 59 anos apos internamento por insuficiencia cardiaca descompensada, agora compensada. Cabecalhos obrigatorios, cada um numa linha propria e EXACTAMENTE: 'Diagnostico principal:', 'Medicacao a manter no domicilio:', 'Restricoes recomendadas:' e 'Sinais de alarme:'. Nos sinais ... | {
"required": [
"^\\s*diagn[óo]stico principal\\s*:",
"^\\s*medica[çc][ãa]o a manter no domic[íi]lio\\s*:",
"^\\s*restri[çc][õo]es recomendadas\\s*:",
"^\\s*sinais de alarme\\s*:",
"insufici[êe]ncia card[íi]aca",
"\\b112\\b",
"dispneia"
],
"forbidden": [
"\\busu[áa]ri[oa]s?\\b",
... | Alta insuficiencia cardiaca 4 seccoes + 112 + dispneia. | Sem FINAL; validado por 4 seccoes, insuficiencia cardiaca, dispneia, 112. |
pt-clinico | 9 | Redige uma NOTA SOAP para uma utente de 33 anos, gravida de 28 semanas, que recorre por cefaleias e edemas dos membros inferiores. Cabecalhos obrigatorios, cada um numa linha propria e EXACTAMENTE: 'S (Subjectivo):', 'O (Objectivo):', 'A (Avaliacao):' e 'P (Plano):'. No plano, indica medicao da tensao arterial, pedido ... | {
"required": [
"^\\s*s \\(subjectivo\\)\\s*:",
"^\\s*o \\(objectivo\\)\\s*:",
"^\\s*a \\(avalia[çc][ãa]o\\)\\s*:",
"^\\s*p \\(plano\\)\\s*:",
"\\ban[áa]lises\\b",
"\\b112\\b",
"tens[ãa]o arterial",
"28 semanas"
],
"forbidden": [
"\\bexames\\s+laboratoriais\\b",
"\\busu[áa]... | SOAP gravidez 4 seccoes + analises/TA/112 + facto (28 semanas). | Sem FINAL; validado por 4 cabecalhos SOAP, analises, tensao arterial, 112, 28 semanas. |
pt-clinico | 10 | Escreve uma explicacao de CONSENTIMENTO INFORMADO para uma COLONOSCOPIA de rastreio, dirigida a um utente de 52 anos. Cabecalhos obrigatorios, cada um numa linha propria e EXACTAMENTE: 'Finalidade do rastreio:', 'Preparacao intestinal:', 'Riscos do procedimento:' e 'Resultados e seguimento:'. Usa a palavra europeia 'ra... | {
"required": [
"^\\s*finalidade do rastreio\\s*:",
"^\\s*prepara[çc][ãa]o intestinal\\s*:",
"^\\s*riscos do procedimento\\s*:",
"^\\s*resultados e seguimento\\s*:",
"\\brastreio\\b",
"colonoscopia",
"\\b112\\b"
],
"forbidden": [
"\\btriagem\\b",
"\\busu[áa]ri[oa]s?\\b",
"\... | Consentimento colonoscopia 4 seccoes + 'rastreio' (nao triagem/screening). | Sem FINAL; validado por 4 seccoes, rastreio, colonoscopia, 112; forbidden triagem/screening. |
pt-clinico | 11 | Redige uma CARTA DE REFERENCIACAO para consulta de endocrinologia de um homem de 49 anos com diabetes tipo 2 mal controlada (HbA1c elevada) e obesidade. Cabecalhos obrigatorios, cada um numa linha propria e EXACTAMENTE: 'Motivo da referenciacao:', 'Antecedentes:', 'Analises relevantes:' e 'Objectivos do pedido:'. Refer... | {
"required": [
"^\\s*motivo da referencia[çc][ãa]o\\s*:",
"^\\s*antecedentes\\s*:",
"^\\s*an[áa]lises relevantes\\s*:",
"^\\s*objectivos do pedido\\s*:",
"hba1c",
"diabetes(\\s+mellitus)?\\s+tipo\\s+2",
"\\b49\\b"
],
"forbidden": [
"\\bexames\\s+laboratoriais\\b",
"\\busu[áa]r... | Referenciacao endocrinologia 4 seccoes + HbA1c/DM2. | Sem FINAL; validado por 4 seccoes, HbA1c, diabetes tipo 2, 49. |
pt-clinico | 12 | Reescreve o paragrafo seguinte na ortografia ANTERIOR ao Acordo Ortografico de 1990 (portugues europeu pre-AO90), mantendo integralmente o sentido clinico. NAO alteres nenhuma outra palavra. Paragrafo (em AO90): 'A ação do antibiotico foi direta e a infeção respondeu bem; o resultado foi ótimo e a reação adversa foi mí... | {
"required": [
"\\bac[çc][ãa]o\\b",
"\\bdirecta\\b|\\bdirecto\\b",
"\\binfec[çc][ãa]o\\b",
"\\b[óo]ptim[oa]\\b",
"\\breac[çc][ãa]o\\b"
],
"forbidden": [
"\\ba[çc][ãa]o\\b",
"\\bdiret[ao]\\b",
"\\binfe[çc][ãa]o\\b",
"\\b[óo]tim[oa]\\b",
"\\brea[çc][ãa]o\\b",
"\\bconctac... | Pre-AO90 rewrite: acção/directa/infecção/óptimo/reacção; forbidden AO90 + hipercorreccoes inventadas. | Sem FINAL; required = 5 formas pre-AO90; forbidden = 5 formas AO90 + 2 hipercorreccoes ('conctacto','infleuncia'). |
pt-clinico | 13 | Reescreve o texto seguinte na ortografia ANTERIOR ao Acordo Ortografico de 1990, mantendo o sentido e sem mudar mais nenhuma palavra. Texto (em AO90): 'A recepção dos exames confirmou o aspeto esperado e a decisão de proteção do doente foi correta.' Atencao: a palavra 'exames' mantem-se igual nas duas ortografias. | {
"required": [
"\\brecep[çc][ãa]o\\b",
"\\baspecto\\b",
"\\bde?cis[ãa]o\\b",
"\\bprotec[çc][ãa]o\\b",
"\\bcorrecta\\b"
],
"forbidden": [
"\\brece[çc][ãa]o\\b",
"\\baspeto\\b",
"\\bprote[çc][ãa]o\\b",
"\\bcorreta\\b",
"\\bdecis[çc][ãa]o\\b"
],
"expected_final": null
} | Pre-AO90: recepção/aspecto/protecção/correcta; distractor 'exames'/'decisão' inalterados; forbidden AO90 + hipercorreccao. | Sem FINAL; required 4 pre-AO90 formas + 'decisão' (inalterada, controla que nao inventaram 'decisção'); forbidden 4 AO90 + 'decisção' (hipercorreccao). |
pt-clinico | 14 | Reescreve na ortografia ANTERIOR ao Acordo Ortografico de 1990, mantendo o sentido clinico e sem alterar mais nenhuma palavra. Texto (em AO90): 'A atividade fisica regular teve um efeito direto na tensao arterial e a adoção de habitos saudaveis foi um objetivo atingido.' | {
"required": [
"\\bactividade\\b",
"\\bdirecto\\b",
"\\badop[çc][ãa]o\\b",
"\\bobjectivo\\b"
],
"forbidden": [
"\\batividade\\b",
"\\bdireto\\b",
"\\bado[çc][ãa]o\\b",
"\\bobjetivo\\b",
"\\bconctacto\\b"
],
"expected_final": null
} | Pre-AO90: actividade/directo/adopção/objectivo; forbidden AO90 + hipercorreccao. | Sem FINAL; required 4 pre-AO90 (adopção mantem 'p'); forbidden 4 AO90 (adoção sem 'p') + hipercorreccao 'conctacto'. |
pt-clinico | 15 | Reescreve na ortografia ANTERIOR ao Acordo Ortografico de 1990, mantendo o significado e sem mudar mais nenhuma palavra. Texto (em AO90): 'A infeção teve um impacto direto na ação do medicamento, mas a tolerancia foi ótima e a seleção do farmaco correta.' | {
"required": [
"\\binfec[çc][ãa]o\\b",
"\\bdirecto\\b",
"\\bac[çc][ãa]o\\b",
"\\b[óo]ptima\\b",
"\\bselec[çc][ãa]o\\b",
"\\bcorrecta\\b"
],
"forbidden": [
"\\binfe[çc][ãa]o\\b",
"\\bdireto\\b",
"\\ba[çc][ãa]o\\b",
"\\b[óo]tima\\b",
"\\bsele[çc][ãa]o\\b",
"\\bcorret... | Pre-AO90 denso: infecção/directo/acção/óptima/selecção/correcta. | Sem FINAL; required 6 pre-AO90 formas; forbidden 6 AO90 formas correspondentes. |
pt-clinico | 16 | Reescreve na ortografia ANTERIOR ao Acordo Ortografico de 1990, mantendo o sentido e sem alterar outras palavras. Texto (em AO90): 'O diretor clinico aprovou a ação de formação, cujo objetivo era a deteção precoce e a proteção dos utentes.' Nota: 'clinico' mantem-se igual nas duas ortografias. | {
"required": [
"\\bdirector\\b",
"\\bac[çc][ãa]o\\b",
"\\bobjectivo\\b",
"\\bdetec[çc][ãa]o\\b",
"\\bprotec[çc][ãa]o\\b"
],
"forbidden": [
"\\bdiretor\\b",
"\\ba[çc][ãa]o\\b",
"\\bobjetivo\\b",
"\\bdete[çc][ãa]o\\b",
"\\bprote[çc][ãa]o\\b",
"\\bcl[íi]nnico\\b"
],
"... | Pre-AO90: director/acção/objectivo/detecção/protecção; distractor 'clinico'. | Sem FINAL; required 5 pre-AO90; forbidden 5 AO90 + hipercorreccao 'clinnico'. |
pt-clinico | 17 | Reescreve na ortografia ANTERIOR ao Acordo Ortografico de 1990, mantendo o significado clinico e sem mudar mais nenhuma palavra. Texto (em AO90): 'A atual norma exige uma reação rapida da equipa e uma direção clara; a ação preventiva foi correta.' Usa portugues europeu (equipa, nao a forma brasileira). | {
"required": [
"\\bactual\\b",
"\\breac[çc][ãa]o\\b",
"\\bdirec[çc][ãa]o\\b",
"\\bac[çc][ãa]o\\b",
"\\bcorrecta\\b",
"\\bequipa\\b"
],
"forbidden": [
"\\batual\\b",
"\\brea[çc][ãa]o\\b",
"\\bdire[çc][ãa]o\\b",
"\\ba[çc][ãa]o\\b",
"\\bcorreta\\b",
"\\bequipe\\b"
]... | Pre-AO90: actual/reacção/direcção/acção/correcta + 'equipa' (nao 'equipe' BR). | Sem FINAL; required 5 pre-AO90 + equipa; forbidden 5 AO90 + 'equipe'. |
pt-clinico | 18 | Reescreve na ortografia ANTERIOR ao Acordo Ortografico de 1990, mantendo o sentido e sem alterar outras palavras. Texto (em AO90): 'A exceção prevista na direção permitiu a atividade sem risco; a proteção do doente foi o objetivo central.' | {
"required": [
"\\bexcep[çc][ãa]o\\b",
"\\bdirec[çc][ãa]o\\b",
"\\bactividade\\b",
"\\bprotec[çc][ãa]o\\b",
"\\bobjectivo\\b"
],
"forbidden": [
"\\bexce[çc][ãa]o\\b",
"\\bdire[çc][ãa]o\\b",
"\\batividade\\b",
"\\bprote[çc][ãa]o\\b",
"\\bobjetivo\\b",
"\\bconctacto\\b"
... | Pre-AO90: excepção/direcção/actividade/protecção/objectivo. | Sem FINAL; required 5 pre-AO90; forbidden 5 AO90 + hipercorreccao. |
pt-clinico | 19 | Reescreve na ortografia ANTERIOR ao Acordo Ortografico de 1990, mantendo o sentido clinico e sem mudar mais nenhuma palavra. Texto (em AO90): 'O aspeto radiologico e a ação do contraste confirmaram a infeção; a reação foi ligeira e a decisão terapeutica direta.' Nota: 'contraste' e 'decisão' nao mudam de grafia. | {
"required": [
"\\baspecto\\b",
"\\bac[çc][ãa]o\\b",
"\\binfec[çc][ãa]o\\b",
"\\breac[çc][ãa]o\\b",
"\\bdirecta\\b|\\bdirecto\\b"
],
"forbidden": [
"\\baspeto\\b",
"\\ba[çc][ãa]o\\b",
"\\binfe[çc][ãa]o\\b",
"\\brea[çc][ãa]o\\b",
"\\bdiret[ao]\\b",
"\\bdecis[çc][ãa]o\\b... | Pre-AO90: aspecto/acção/infecção/reacção/directa; distractor 'contraste'/'decisão'. | Sem FINAL; required 5 pre-AO90; forbidden 5 AO90 + 'decisção' hipercorreccao. |
pt-clinico | 20 | Um antibiotico pediatrico e prescrito a 90 mg/kg/dia, dividido em 3 tomas iguais (de 8 em 8 horas). A crianca pesa 24 kg. Esta disponivel em frascos-ampola de 250 mg. Calcula, por esta ordem: (1) a dose diaria total em mg; (2) a dose por toma em mg; (3) quantos frascos-ampola de 250 mg sao necessarios por toma, arredon... | {
"required": [
"FINAL\\s*=",
"2160",
"720"
],
"forbidden": [],
"expected_final": "3"
} | Passo a passo verificado; trap arredondamento (2,88->3). | python: daily=90*24=2160; per_dose=2160/3=720; frascos=round(720/250)=round(2.88)=3. FINAL=3. |
pt-clinico | 21 | Prepara-se uma perfusao continua de dobutamina. A solucao contem 250 mg de dobutamina em 250 mL de soro (ou seja, deves primeiro converter para mcg/mL). O doente pesa 80 kg e a dose prescrita e 5 mcg/kg/min. Calcula o ritmo de perfusao em mL/h. Termina com uma linha exactamente no formato FINAL=<valor em mL/h>. | {
"required": [
"FINAL\\s*=",
"1000",
"\\b80\\b"
],
"forbidden": [],
"expected_final": "24"
} | Multi-step mcg/kg/min -> mL/h; concentracao derivada. | python: conc=250mg/250mL=1 mg/mL=1000 mcg/mL; rate=(5*80*60)/1000=24000/1000=24 mL/h. FINAL=24. |
pt-clinico | 22 | Um frasco de po para injectavel contem 1200 mg de farmaco. Reconstitui-se com diluente ate um volume final de 6 mL. A prescricao e de 900 mg. Calcula: (1) a concentracao apos reconstituicao em mg/mL; (2) o volume em mL que deves aspirar para administrar 900 mg. Termina com uma linha exactamente no formato FINAL=<volume... | {
"required": [
"FINAL\\s*=",
"200",
"900"
],
"forbidden": [],
"expected_final": "4.5"
} | Reconstituicao -> concentracao -> volume parcial. | python: conc=1200/6=200 mg/mL; volume=900/200=4.5 mL. FINAL=4.5. |
pt-clinico | 23 | Converte uma glicemia de 7,2 mmol/L para mg/dL, usando o factor de conversao 18,016 (mg/dL = mmol/L x 18,016). Arredonda o resultado a uma casa decimal. Termina com uma linha exactamente no formato FINAL=<valor em mg/dL>. | {
"required": [
"FINAL\\s*=",
"18[.,]016"
],
"forbidden": [],
"expected_final": "129.7"
} | Conversao unidades com factor indicado. | python: 7.2*18.016=129.7152; arred 1dp=129.7. FINAL=129.7. |
pt-clinico | 24 | Um relatorio laboratorial estrangeiro indica um valor de acucar no sangue de 180 mg/dL, mas o sistema hospitalar portugues regista em mmol/L. Sabendo que para passar de mg/dL para mmol/L se divide pelo factor 18,016, indica o valor correspondente em mmol/L arredondado a uma casa decimal. Termina com uma linha exactamen... | {
"required": [
"FINAL\\s*=",
"18[.,]016",
"180"
],
"forbidden": [
"FINAL\\s*=\\s*180(\\s*/|\\s*$|\\D*$)"
],
"expected_final": "10.0"
} | Conversao inversa em contexto de relatorio; trap arredondamento (9,9911->10,0); forbidden apanha terminacao no valor pre-conversao (FINAL=180 ou FINAL=180/18.016). | python: 180/18.016=9.99112...; arred 1dp=10.0. FINAL=10.0. Forbidden 'FINAL=180...' impede que um modelo preguicoso termine no valor mg/dL pre-conversao; verificado sem falsos positivos sobre respostas correctas que terminam FINAL=10.0. |
pt-clinico | 25 | Calcula a depuracao (clearance) de creatinina pela formula de Cockcroft-Gault para um HOMEM: ClCr = ((140 - idade) x peso) / (72 x creatinina serica). Dados: idade 70 anos, peso 72 kg, creatinina serica 1,2 mg/dL. Arredonda a uma casa decimal. Termina com uma linha exactamente no formato FINAL=<valor em mL/min>. | {
"required": [
"FINAL\\s*=",
"140",
"\\b72\\b"
],
"forbidden": [],
"expected_final": "58.3"
} | Cockcroft-Gault homem (formula dada). | python: ((140-70)*72)/(72*1.2)=5040/86.4=58.3333; 1dp=58.3. FINAL=58.3. |
pt-clinico | 26 | Calcula a depuracao de creatinina pela formula de Cockcroft-Gault para uma MULHER, aplicando o factor 0,85 no fim: ClCr = [((140 - idade) x peso) / (72 x creatinina serica)] x 0,85. Dados: idade 65 anos, peso 60 kg, creatinina serica 0,9 mg/dL. Arredonda a uma casa decimal. Termina com uma linha exactamente no formato ... | {
"required": [
"FINAL\\s*=",
"0[.,]85",
"140"
],
"forbidden": [],
"expected_final": "59.0"
} | Cockcroft-Gault mulher com factor 0,85 (passo extra). | python: ((140-65)*60)/(72*0.9)*0.85=(4500/64.8)*0.85=69.4444*0.85=59.0278; 1dp=59.0. FINAL=59.0. |
pt-clinico | 27 | Calcula o indice de massa corporal (IMC = peso_kg / altura_m ao quadrado) de um adulto com 95 kg e 1,72 m de altura. Arredonda o IMC a uma casa decimal. Depois classifica-o segundo os limiares da OMS: <18,5 baixo peso; 18,5-24,9 normal; 25,0-29,9 excesso de peso; >=30 obesidade. Termina com uma linha exactamente no for... | {
"required": [
"FINAL\\s*=",
"obesidade",
"1[.,]72"
],
"forbidden": [],
"expected_final": "32.1"
} | IMC + classificacao (limiar >=30 obesidade). | python: 95/(1.72**2)=95/2.9584=32.1120; 1dp=32.1 (obesidade). FINAL=32.1; required 'obesidade'. |
pt-clinico | 28 | Um farmaco pediatrico e prescrito a 15 mg/kg por toma, mas com uma dose maxima ABSOLUTA de 500 mg por toma (nao exceder). A crianca pesa 34 kg. Calcula a dose por toma que deve efectivamente ser administrada, aplicando o limite maximo se necessario. Termina com uma linha exactamente no formato FINAL=<dose por toma em m... | {
"required": [
"FINAL\\s*=",
"\\b510\\b",
"500"
],
"forbidden": [],
"expected_final": "500"
} | Dose com tecto (cap): 15*34=510 excede 500 -> aplicar 500. | python: raw=15*34=510; cap=500; administrada=min(510,500)=500. FINAL=500. Required inclui 510 (mostrar calculo bruto) e 500. |
pt-clinico | 29 | Prescreve-se paracetamol 1000 mg por toma, de 6 em 6 horas, durante 24 horas. Estao disponiveis comprimidos de 500 mg. Calcula, por esta ordem: (1) quantos comprimidos de 500 mg correspondem a cada toma; (2) quantas tomas ha em 24 horas; (3) o numero total de comprimidos de 500 mg necessarios num dia. Termina com uma l... | {
"required": [
"FINAL\\s*=",
"\\b4\\b",
"\\b2\\b"
],
"forbidden": [],
"expected_final": "8"
} | Multi-step: comp/toma (2) x tomas/dia (4) = 8. | python: comp_por_toma=1000/500=2; tomas=24/6=4; total=2*4=8. FINAL=8. |
pt-clinico | 30 | Traduz para portugues europeu, terminologia clinica, o seguinte excerto: 'The patient was admitted to the intensive care unit after a stroke; blood tests were requested and a screening for infection was started.' Usa 'unidade de cuidados intensivos', 'AVC', 'analises' e 'rastreio'. Evita brasileirismos e decalques do i... | {
"required": [
"unidade de cuidados intensivos",
"\\bAVC\\b",
"\\ban[áa]lises\\b",
"\\brastreio\\b"
],
"forbidden": [
"\\bstroke\\b",
"\\bderrame\\b",
"\\bscreening\\b",
"\\bexames\\s+laboratoriais\\b",
"\\btriagem\\b",
"\\bicu\\b"
],
"expected_final": null
} | EN->PT-PT UCI/AVC/analises/rastreio; forbidden stroke/derrame/screening/exames laboratoriais/triagem/ICU. | Sem FINAL; required 4 termos europeus; forbidden 6 formas BR/EN. |
pt-clinico | 31 | Traduz para portugues europeu: 'The patient presented with a suspected heart attack; a myocardial infarction was later confirmed and thrombolysis was considered.' Usa 'enfarte do miocardio' (ou 'enfarte agudo do miocardio'). Evita a forma brasileira. | {
"required": [
"enfarte",
"mioc[áa]rdio",
"trombolise|tromb[óo]lise"
],
"forbidden": [
"\\binfart[oa]s?\\b",
"\\bheart\\s+attack\\b",
"\\bstroke\\b"
],
"expected_final": null
} | EN->PT-PT enfarte do miocardio; forbidden 'infarto'/'heart attack'. | Sem FINAL; required enfarte+miocardio+trombolise; forbidden infarto/heart attack/stroke. |
pt-clinico | 32 | Traduz para portugues europeu, registo clinico de urgencia: 'On arrival the patient was dehydrated; an intravenous line was placed and fluids were started while awaiting the kidney function results.' Usa 'via endovenosa' (ou 'acesso venoso'), 'soro' (ou 'fluidos endovenosos') e 'funcao renal'. Evita decalques do ingles... | {
"required": [
"(via endovenosa|acesso venoso)",
"(soro|fluidos endovenosos)",
"fun[çc][ãa]o renal"
],
"forbidden": [
"\\bintravenous line\\b",
"\\busu[áa]ri[oa]s?\\b",
"\\bequipe\\b",
"\\bexames\\s+laboratoriais\\b"
],
"expected_final": null
} | EN->PT-PT via endovenosa/soro/funcao renal; forbidden calque 'intravenous line' + usuario. Fonte EN distinta. | Sem FINAL; required 3 termos europeus; forbidden calque EN + usuario/equipe/exames laboratoriais. |
pt-clinico | 33 | Traduz para portugues europeu o aviso de saude publica: 'Adults aged fifty and over are invited to take part in the national bowel cancer screening programme; nursing staff will explain the procedure.' Usa 'rastreio' (nao 'triagem') e 'pessoal de enfermagem' (ou 'enfermeiros'), evitando a forma brasileira 'equipe' e o ... | {
"required": [
"\\brastreio\\b",
"(pessoal de enfermagem|enfermeir)",
"cancro"
],
"forbidden": [
"\\btriagem\\b",
"\\bscreening\\b",
"\\bequipe\\b",
"\\busu[áa]ri[oa]s?\\b"
],
"expected_final": null
} | EN->PT-PT rastreio/pessoal de enfermagem/cancro; forbidden triagem/screening/equipe. Fonte EN distinta. | Sem FINAL; required rastreio + enfermagem + 'cancro'; forbidden triagem/screening/equipe. |
pt-clinico | 34 | Traduz para portugues europeu, terminologia de urgencia: 'In case of chest pain and shortness of breath, call the emergency number immediately.' Em Portugal, o numero europeu de emergencia e o 112 — inclui-o explicitamente. Usa 'dor no peito' ou 'dor toracica' e 'falta de ar' ou 'dispneia'. | {
"required": [
"\\b112\\b",
"dor (no peito|tor[áa]cica)",
"(falta de ar|dispneia)"
],
"forbidden": [
"\\b911\\b",
"\\binfart[oa]s?\\b",
"\\busu[áa]ri[oa]s?\\b"
],
"expected_final": null
} | EN->PT-PT emergencia -> 112 (nao 911). | Sem FINAL; required 112 + sintomas; forbidden 911/infarto. |
pt-clinico | 35 | Traduz para portugues europeu, registo tecnico de imagiologia: 'A CT scan of the chest was performed to rule out a pulmonary embolism, and the radiologist recommended outpatient follow-up.' Usa 'tomografia computorizada' (nao 'tomografia computadorizada'), 'embolia pulmonar' e 'seguimento em ambulatorio'. Evita decalqu... | {
"required": [
"tomografia computorizada",
"embolia pulmonar",
"seguimento em ambulat[óo]rio"
],
"forbidden": [
"\\btomografia computadorizada\\b",
"\\busu[áa]ri[oa]s?\\b",
"\\bequipe\\b",
"\\bCT scan\\b"
],
"expected_final": null
} | EN->PT-PT tomografia computorizada/embolia pulmonar/seguimento ambulatorio; trap BR 'computadorizada'. Fonte EN distinta. | Sem FINAL; required 3 termos europeus; forbidden 'tomografia computadorizada' + 'CT scan' + usuario/equipe. |
pt-clinico | 36 | Cenario (Portugal): um homem de 60 anos tem dor no peito intensa e opressiva ha 20 minutos, com suor frio, nausea e dor no braco esquerdo. Escreve a orientacao imediata a dar-lhe, identificando explicitamente que estes sao sinais de alarme e que deve ligar JA para o 112. NAO faças um diagnostico definitivo (nao afirmes... | {
"required": [
"\\b112\\b",
"sinais de alarme",
"dor no peito|dor tor[áa]cica"
],
"forbidden": [
"\\btem um enfarte\\b",
"\\b[ée] um enfarte\\b",
"\\btem um infarto\\b",
"diagn[óo]stico definitivo",
"\\binfart[oa]s?\\b",
"\\b911\\b"
],
"expected_final": null
} | Triagem dor toracica: exige 112 + 'sinais de alarme'; proibe diagnostico assertivo 'tem um enfarte'/'infarto'. | Sem FINAL; required 112 + sinais de alarme + sintoma; forbidden afirmacoes diagnosticas + infarto + 911. |
pt-clinico | 37 | Cenario (Portugal): uma crianca de 3 anos tem febre alta ha 2 dias e surge agora rigidez da nuca, sonolencia acentuada e manchas na pele que nao desaparecem quando se pressiona. Escreve a orientacao imediata aos pais, identificando explicitamente estes sinais de alarme e a necessidade de ligar JA para o 112. NAO faças ... | {
"required": [
"\\b112\\b",
"sinais de alarme",
"rigidez da nuca"
],
"forbidden": [
"\\btem meningite\\b",
"\\b[ée] meningite\\b",
"diagn[óo]stico definitivo",
"\\b911\\b",
"\\busu[áa]ri[oa]s?\\b"
],
"expected_final": null
} | Triagem meningite pediatrica: 112 + sinais de alarme; proibe 'tem meningite'. | Sem FINAL; required 112 + sinais de alarme + rigidez da nuca; forbidden afirmacao diagnostica + 911. |
pt-clinico | 38 | Cenario (Portugal): uma mulher de 55 anos apresenta subitamente fraqueza num lado do corpo, boca ao lado e dificuldade em falar, com inicio ha 30 minutos. Escreve a orientacao imediata, identificando explicitamente que estes sao sinais de alarme de AVC e que se deve ligar JA para o 112, sublinhando que o tempo e critic... | {
"required": [
"\\b112\\b",
"sinais de alarme",
"\\bAVC\\b"
],
"forbidden": [
"\\bteve um avc\\b",
"\\b[ée] um avc\\b",
"\\bderrame\\b",
"diagn[óo]stico definitivo",
"\\b911\\b"
],
"expected_final": null
} | Triagem AVC: 112 + sinais de alarme + 'AVC' como categoria; proibe 'teve um AVC' assertivo e 'derrame'. | Sem FINAL; required 112 + sinais de alarme + AVC; forbidden afirmacao diagnostica + derrame + 911. |
pt-clinico | 39 | Cenario (Portugal): um homem de 45 anos, apos picada de vespa, apresenta em poucos minutos inchaco dos labios e da lingua, dificuldade em respirar e urticaria generalizada. Escreve a orientacao imediata, identificando explicitamente que estes sao sinais de alarme de uma reaccao alergica grave (anafilaxia) e que se deve... | {
"required": [
"\\b112\\b",
"sinais de alarme",
"(dificuldade\\s+(em\\s+)?respirar|dificuldade\\s+respirat[óo]ria|falta\\s+de\\s+ar|dispneia)"
],
"forbidden": [
"\\btem anafilaxia\\b",
"diagn[óo]stico definitivo",
"\\b911\\b",
"\\busu[áa]ri[oa]s?\\b",
"\\binfart[oa]s?\\b"
],
"... | Triagem anafilaxia: 112 + sinais de alarme + dificuldade respiratoria; proibe 'tem anafilaxia' assertivo. | Sem FINAL; required 112 + sinais de alarme + sintoma respiratorio; forbidden afirmacao diagnostica + 911. |
codigo-pt | 0 | Escreve uma função Python valida_nif(nif) que valide um número de contribuinte português (NIF). A regra oficial do dígito de controlo é: o NIF tem 9 dígitos; multiplica os primeiros 8 dígitos pelos pesos 9, 8, 7, 6, 5, 4, 3, 2 (da esquerda para a direita), soma os produtos, calcula o resto da divisão por 11, e o dígito... | {
"required": [
"def\\s+valida_nif",
"%\\s*11",
"11\\s*-",
"FINAL\\s*=\\s*2\\b"
],
"forbidden": [
"rm\\s+-rf",
"import\\s+requests"
],
"expected_final": "2"
} | NIF check-digit mod-11 com o caso-armadilha 11->0; 123456789 passa a validação (quirk real). | Executado: check digits [4,9,0]; 503504564 e 123456789 válidos, 196058524 inválido -> 2. |
codigo-pt | 1 | Escreve uma função Python valida_iban_pt(iban) que valide um IBAN português pelo algoritmo mod-97 (norma ISO 13616): remove espaços; confirma que tem o formato 'PT' seguido de 23 dígitos (25 caracteres no total); move os 4 primeiros caracteres para o fim; substitui cada letra pelo seu valor (A=10, B=11, ..., Z=35); int... | {
"required": [
"def\\s+valida_iban_pt",
"%\\s*97",
"97\\s*==\\s*1|==\\s*1|mod.?97",
"FINAL\\s*=\\s*1\\b"
],
"forbidden": [
"rm\\s+-rf",
"eval\\("
],
"expected_final": "1"
} | IBAN PT50 mod-97: exige rearranjo dos 4 primeiros e conversão letra->número; só o 1.º é válido. | Executado: mod97 = [1, 28]; apenas PT50...154 é válido -> 1. |
codigo-pt | 2 | Em Python, escreve a expressão que avalia se 0.1 + 0.2 é exactamente igual a 0.3 usando o operador de igualdade (==). Explica numa frase porque o resultado é o que é (representação de ponto flutuante IEEE 754). No fim, corre mentalmente a tua solução no input dado e termina com uma linha exactamente no formato FINAL=<r... | {
"required": [
"0\\.1\\s*\\+\\s*0\\.2",
"==",
"FINAL\\s*=\\s*false"
],
"forbidden": [
"FINAL\\s*=\\s*true"
],
"expected_final": "False"
} | Armadilha clássica de ponto flutuante: 0.1+0.2 == 0.3 é False. | Executado: (0.1 + 0.2 == 0.3) -> False. |
codigo-pt | 3 | Em Python 3, a função incorporada round() usa arredondamento bancário (half-to-even) para valores exactamente a meio. Calcula o valor de round(0.5) + round(1.5) + round(2.5) + round(3.5) usando essa função incorporada, sem importar nada. No fim, corre mentalmente a tua solução no input dado e termina com uma linha exac... | {
"required": [
"round\\(0\\.5\\)|round\\(2\\.5\\)",
"FINAL\\s*=\\s*8\\b"
],
"forbidden": [
"FINAL\\s*=\\s*10\\b",
"import\\s+decimal"
],
"expected_final": "8"
} | Banker's rounding: round(0.5)=0, round(2.5)=2 (não 1/3 como half-up sugeriria). | Executado: 0 + 2 + 2 + 4 = 8. |
codigo-pt | 4 | Considera esta função Python com um argumento por omissão mutável:
```python
def acumula(x, acc=[]):
acc.append(x)
return len(acc)
```
Chama-se, pela mesma ordem e no mesmo processo, acumula(1), depois acumula(2), depois acumula(3). Qual é o valor devolvido pela terceira chamada? Explica o comportamento da list... | {
"required": [
"acc\\s*=\\s*\\[\\]|argumento.*mut|default.*mut|mutáve",
"FINAL\\s*=\\s*3\\b"
],
"forbidden": [
"FINAL\\s*=\\s*1\\b"
],
"expected_final": "3"
} | Mutable default arg: a lista persiste entre chamadas; a 3.ª chamada devolve 3. | Executado: chamadas devolvem 1, 2, 3 -> terceira = 3. |
codigo-pt | 5 | Em Python, considera:
```python
g = (i * i for i in range(4))
resultado = sum(g) + sum(g)
```
Qual é o valor de resultado? Explica numa frase o que acontece ao gerador na segunda chamada a sum(). No fim, corre mentalmente a tua solução no input dado e termina com uma linha exactamente no formato FINAL=<resultado>. | {
"required": [
"gerador|generator|esgot|exaust|consum",
"FINAL\\s*=\\s*14\\b"
],
"forbidden": [
"FINAL\\s*=\\s*28\\b"
],
"expected_final": "14"
} | Generator exhaustion: 1.º sum() consome o gerador (0+1+4+9=14), 2.º sum() vê vazio (0). | Executado: sum(g)=14, segundo sum(g)=0 -> 14. |
codigo-pt | 6 | Em Python 3.7+, os dicionários preservam a ordem de inserção e uma reatribuição de chave existente actualiza o valor sem mudar a posição da chave. Dada a lista de pares [('a',1),('b',2),('a',3),('c',4),('b',5)], constrói um dicionário inserindo os pares por esta ordem (cada par faz d[chave] = valor). Indica a sequência... | {
"required": [
"ordem\\s+de\\s+inser|insertion.?order|d\\[",
"FINAL\\s*=\\s*a\\|b\\|c=12"
],
"forbidden": [
"FINAL\\s*=\\s*a\\|b\\|c=15"
],
"expected_final": "a|b|c=12"
} | Dict order + last-write-wins: chaves a|b|c; valores finais 3,5,4 -> soma 12 (não 15). | Executado: dict {'a':3,'b':5,'c':4}; chaves 'a|b|c'; soma 12. |
codigo-pt | 7 | Em Python, usa datetime.date(2021, 1, 1).isocalendar() para determinar o ano ISO e o número da semana ISO 8601 a que pertence o dia 1 de Janeiro de 2021. Indica o resultado no formato FINAL=<ano_iso>-W<semana com dois dígitos>. No fim, corre mentalmente a tua solução no input dado e termina com uma linha exactamente no... | {
"required": [
"isocalendar|iso\\s?8601|semana\\s+iso",
"FINAL\\s*=\\s*2020-W53"
],
"forbidden": [
"FINAL\\s*=\\s*2021-W01",
"FINAL\\s*=\\s*2021-W53"
],
"expected_final": "2020-W53"
} | ISO week boundary: 2021-01-01 (sexta) pertence à semana 53 de 2020, não à semana 1 de 2021. | Executado: isocalendar() -> (2020, 53, 5). |
codigo-pt | 8 | Em Portugal continental (fuso Europe/Lisbon), a mudança para a hora de Verão em 2026 ocorre no último domingo de Março (29 de Março), quando os relógios avançam de 01:00 para 02:00 — esse dia só tem 23 horas. Usando datetime com zoneinfo (ZoneInfo('Europe/Lisbon')), calcula o tempo real decorrido, em segundos, entre 20... | {
"required": [
"zoneinfo|ZoneInfo|Europe/Lisbon",
"utc|UTC|astimezone",
"FINAL\\s*=\\s*82800"
],
"forbidden": [
"FINAL\\s*=\\s*86400"
],
"expected_final": "82800"
} | DST spring-forward: (b-a).total_seconds() ingénuo dá 86400; o real (via UTC) é 82800 (23h). | Executado: diferença via UTC = 82800; diferença ingénua de wall clock = 86400. |
codigo-pt | 9 | Em Python, usa o módulo csv (csv.reader sobre io.StringIO) para analisar exactamente este conteúdo CSV, respeitando aspas duplas, aspas escapadas ('""' representa uma aspa literal) e quebras de linha dentro de campos entre aspas:
```
nome,nota
"Silva, João","disse ""olá"""
"multi
linha",5
```
Conta o número de linhas d... | {
"required": [
"csv\\.(reader|DictReader)",
"FINAL\\s*=\\s*2:2\\b"
],
"forbidden": [
"FINAL\\s*=\\s*3:",
"line\\.split\\(','\\)",
"\\.split\\(\\\",\\\"\\)"
],
"expected_final": "2:2"
} | CSV quoting corners: vírgula/aspas/quebra-de-linha dentro de aspas; 2 linhas de dados, 2 campos. | Executado: rows[1]=['Silva, João','disse "olá"'], 2 data rows, 2 fields -> 2:2. |
codigo-pt | 10 | Em Python, considera a fatia s[1:len(s)-1] aplicada a s = 'abcdef'. Qual é a substring resultante? Presta atenção aos limites: o índice final de uma fatia é exclusivo. No fim, corre mentalmente a tua solução no input dado e termina com uma linha exactamente no formato FINAL=<resultado>. | {
"required": [
"s\\[1:",
"exclusiv|excluído|não\\s+inclui",
"FINAL\\s*=\\s*bcde\\b"
],
"forbidden": [
"FINAL\\s*=\\s*bcdef",
"FINAL\\s*=\\s*abcde"
],
"expected_final": "bcde"
} | Off-by-one de slicing: s[1:len(s)-1] de 'abcdef' é 'bcde' (fim exclusivo). | Executado: 'abcdef'[1:5] = 'bcde'. |
codigo-pt | 11 | Em Python, a divisão inteira // arredonda para menos infinito (floor) e o operador % devolve um resto com o sinal do divisor. Calcula -7 // 2 e -7 % 2 e indica ambos no formato FINAL=<divisão>:<resto>. No fim, corre mentalmente a tua solução no input dado e termina com uma linha exactamente no formato FINAL=<resultado>... | {
"required": [
"//",
"floor|menos\\s+infinito|para\\s+baixo",
"FINAL\\s*=\\s*-4:1\\b"
],
"forbidden": [
"FINAL\\s*=\\s*-3:",
"FINAL\\s*=\\s*-4:-1"
],
"expected_final": "-4:1"
} | Floor division/módulo com negativos em Python: -7//2=-4, -7%2=1 (não -3 e -1 como em C). | Executado: -7 // 2 = -4, -7 % 2 = 1. |
codigo-pt | 12 | Em Python, sorted() é estável e uma chave em tuplo ordena por múltiplos critérios. Ordena a lista ['bb', 'a', 'cc', 'aa', 'b'] primeiro por comprimento crescente e, dentro do mesmo comprimento, por ordem alfabética, usando sorted(..., key=lambda w: (len(w), w)). Indica o resultado como uma lista de elementos separados ... | {
"required": [
"sorted\\(",
"key\\s*=",
"len\\(",
"FINAL\\s*=\\s*a,b,aa,bb,cc"
],
"forbidden": [
"FINAL\\s*=\\s*a,aa,b,bb,cc"
],
"expected_final": "a,b,aa,bb,cc"
} | Chave-tuplo (len, alfabética): resultado a,b,aa,bb,cc — não a ordem puramente alfabética. | Executado: sorted(..., key=(len,w)) -> ['a','b','aa','bb','cc']. |
codigo-pt | 13 | Em Python, o arredondamento correcto de valores monetários deve usar decimal.Decimal com ROUND_HALF_UP, não a função round() de ponto flutuante. Calcula Decimal('2.675').quantize(Decimal('0.01'), rounding=ROUND_HALF_UP) e indica o resultado. Nota que round(2.675, 2) em ponto flutuante daria um valor diferente por causa... | {
"required": [
"Decimal",
"ROUND_HALF_UP",
"quantize",
"FINAL\\s*=\\s*2\\.68"
],
"forbidden": [
"FINAL\\s*=\\s*2\\.67"
],
"expected_final": "2.68"
} | Decimal half-up vs float round: 2.675 -> 2.68 (com Decimal), mas round(2.675,2) dá 2.67. | Executado: Decimal('2.675').quantize('0.01', HALF_UP) = 2.68. |
codigo-pt | 14 | Em Python, remove duplicados da lista [3, 1, 2, 3, 1, 4, 2, 5] preservando a ordem da primeira ocorrência (não uses set() sobre o resultado final, pois isso perde a ordem). Indica a lista resultante separada por vírgulas no formato FINAL=<elementos>. No fim, corre mentalmente a tua solução no input dado e termina com u... | {
"required": [
"ordem|order|primeira\\s+ocorr|first\\s+seen",
"FINAL\\s*=\\s*3,1,2,4,5"
],
"forbidden": [
"FINAL\\s*=\\s*1,2,3,4,5"
],
"expected_final": "3,1,2,4,5"
} | Dedup preservando ordem de primeira ocorrência: 3,1,2,4,5 (não a lista ordenada). | Executado: dedup order-preserving -> [3,1,2,4,5]. |
codigo-pt | 15 | Em Python, str.split() sem argumentos colapsa qualquer sequência de espaços em branco e ignora espaços nas extremidades, enquanto str.split(' ') divide em cada espaço individual (gerando strings vazias). Para a string ' a b c ' (dois espaços à esquerda, dois entre 'a' e 'b', três entre 'b' e 'c', dois à direita), ... | {
"required": [
"split\\(\\)",
"split\\(['\\\"] ['\\\"]\\)|split\\(' '\\)",
"FINAL\\s*=\\s*3:10\\b"
],
"forbidden": [
"FINAL\\s*=\\s*3:3\\b"
],
"expected_final": "3:10"
} | split() colapsa whitespace (3 elementos) vs split(' ') produz 10 (com vazios das extremidades). | Executado: len(split())=3, len(split(' '))=10. |
codigo-pt | 16 | Em Python, o encadeamento de comparações a < b < c é avaliado como (a < b) and (b < c), não como comparação de resultados booleanos. Avalia a expressão 5 > 3 > 4 e indica o valor booleano resultante. Explica numa frase porque o encadeamento produz esse resultado. No fim, corre mentalmente a tua solução no input dado e ... | {
"required": [
"5\\s*>\\s*3\\s*>\\s*4",
"and|encadea|3\\s*>\\s*4",
"FINAL\\s*=\\s*false"
],
"forbidden": [
"FINAL\\s*=\\s*true"
],
"expected_final": "False"
} | Chained comparison: 5>3>4 == (5>3) and (3>4) == True and False == False. | Executado: 5 > 3 > 4 -> False. |
codigo-pt | 17 | Em Python, considera:
```python
total = 0.0
for _ in range(10):
total += 0.1
```
Depois do ciclo, indica se total == 1.0 (usando ==) e qual o valor de round(total, 2), no formato FINAL=<igualdade>:<arredondado>. No fim, corre mentalmente a tua solução no input dado e termina com uma linha exactamente no formato FIN... | {
"required": [
"total\\s*==\\s*1\\.0|==\\s*1\\.0",
"round\\(total",
"FINAL\\s*=\\s*false:1\\.0"
],
"forbidden": [
"FINAL\\s*=\\s*true:1\\.0"
],
"expected_final": "False:1.0"
} | Acumulação de 0.1 dez vezes != 1.0 (dá 0.9999...), mas round(.,2)=1.0. | Executado: total==1.0 -> False; round(total,2) -> 1.0. |
codigo-pt | 18 | Em Portugal continental, a mudança para a hora de Inverno em 2026 ocorre no último domingo de Outubro (25 de Outubro), quando os relógios recuam de 02:00 para 01:00 — esse dia tem 25 horas. Usando datetime com ZoneInfo('Europe/Lisbon'), converte ambos os instantes 2026-10-24 12:00 e 2026-10-25 12:00 (hora local) para U... | {
"required": [
"zoneinfo|ZoneInfo|Europe/Lisbon",
"utc|UTC|astimezone",
"FINAL\\s*=\\s*90000"
],
"forbidden": [
"FINAL\\s*=\\s*86400"
],
"expected_final": "90000"
} | DST fall-back: o dia tem 25h; duração real via UTC = 90000s (não 86400). | Executado: diferença via UTC = 90000 (25h). |
codigo-pt | 19 | Escreve uma função Python luhn_valido(numero) que verifique um número (string de dígitos) pelo algoritmo de Luhn: percorrendo os dígitos da direita para a esquerda, duplica cada segundo dígito (o 2.º, 4.º, ... a contar da direita) e, se o resultado dessa duplicação for maior que 9, subtrai 9; soma todos os dígitos assi... | {
"required": [
"def\\s+luhn_valido",
"%\\s*10|10\\s*==\\s*0|divis",
"FINAL\\s*=\\s*1\\b"
],
"forbidden": [
"rm\\s+-rf",
"FINAL\\s*=\\s*2\\b"
],
"expected_final": "1"
} | Luhn checksum: só 4539148803436467 passa; a variante terminada em 0 falha -> 1. | Executado: [True, False] -> 1 válido. |
codigo-pt | 20 | Tens uma tabela SQLite construída assim:
```sql
CREATE TABLE t(id INTEGER, v INTEGER);
INSERT INTO t VALUES (1,10),(2,NULL),(3,20),(4,NULL),(5,30);
```
Escreve uma única consulta que devolva, por esta ordem, COUNT(*), COUNT(v), SUM(v) e AVG(v). Lembra-te de que as funções de agregação ignoram NULL, mas COUNT(*) conta t... | {
"required": [
"COUNT\\(\\*\\)",
"COUNT\\(v\\)",
"SUM\\(v\\)",
"AVG\\(v\\)",
"FINAL\\s*=\\s*5\\|3\\|60\\|20"
],
"forbidden": [
"FINAL\\s*=\\s*5\\|5\\|",
"FINAL\\s*=\\s*5\\|3\\|60\\|12"
],
"expected_final": "5|3|60|20.0"
} | NULL em agregados: COUNT(*)=5 mas COUNT(v)=3, SUM=60, AVG=60/3=20 (não 60/5). | Executado em sqlite3: (5, 3, 60, 20.0). |
codigo-pt | 21 | Tabela SQLite:
```sql
CREATE TABLE vendas(vendedor TEXT, valor INTEGER);
INSERT INTO vendas VALUES ('Ana',100),('Ana',50),('Rui',30),('Rui',20),('Sara',200);
```
Escreve uma consulta que devolva o total por vendedor apenas para os vendedores cujo total seja >= 150, ordenado do maior total para o menor. Usa GROUP BY e H... | {
"required": [
"GROUP\\s+BY",
"HAVING",
"SUM\\(",
"FINAL\\s*=\\s*Sara=200;Ana=150"
],
"forbidden": [
"WHERE\\s+SUM",
"SELECT\\s+\\*",
"FINAL\\s*=\\s*Ana=150;Sara=200"
],
"expected_final": "Sara=200;Ana=150"
} | HAVING sobre agregado (não WHERE): Ana=150, Sara=200 passam; ordenado desc -> Sara;Ana. | Executado: GROUP BY + HAVING SUM>=150 ORDER BY desc -> Sara=200, Ana=150. |
codigo-pt | 22 | Tabela SQLite:
```sql
CREATE TABLE pontos(nome TEXT, p INTEGER);
INSERT INTO pontos VALUES ('A',90),('B',90),('C',80),('D',70);
```
Escreve uma consulta que, ordenando por p decrescente, devolva para cada linha o RANK() e o DENSE_RANK() como funções de janela. Repara na diferença com empates: RANK() deixa lacunas após ... | {
"required": [
"RANK\\(\\)\\s+OVER",
"DENSE_RANK\\(\\)\\s+OVER",
"ORDER\\s+BY",
"FINAL\\s*=\\s*A:1/1;B:1/1;C:3/2;D:4/3"
],
"forbidden": [
"FINAL\\s*=\\s*A:1/1;B:2/2",
"FINAL\\s*=\\s*A:1/1;B:1/1;C:2/2"
],
"expected_final": "A:1/1;B:1/1;C:3/2;D:4/3"
} | RANK vs DENSE_RANK com empate no topo: C fica em RANK 3 (lacuna) mas DENSE_RANK 2. | Executado: A/B rank1 dense1, C rank3 dense2, D rank4 dense3. |
codigo-pt | 23 | Tabela SQLite:
```sql
CREATE TABLE orders(cust TEXT, total INTEGER);
INSERT INTO orders VALUES ('X',100),('X',100),('Y',50),('Z',300);
```
Escreve uma consulta que devolva os clientes cujo total gasto (soma dos seus pedidos) seja estritamente superior à média dos totais por cliente. Usa uma subconsulta para calcular es... | {
"required": [
"GROUP\\s+BY",
"AVG\\(",
"SELECT.*SELECT|subconsult|\\(\\s*SELECT",
"FINAL\\s*=\\s*Z=300;X=200"
],
"forbidden": [
"SELECT\\s+\\*",
"FINAL\\s*=\\s*Z=300;X=200;Y"
],
"expected_final": "Z=300;X=200"
} | Subconsulta correlacionada sobre agregados: média dos totais por cliente (183.3); acima: X=200, Z=300. | Executado: totais X=200,Y=50,Z=300; média=183.33; acima -> Z=300, X=200. |
codigo-pt | 24 | Tabelas SQLite:
```sql
CREATE TABLE cli(id INTEGER, nome TEXT);
INSERT INTO cli VALUES (1,'Ana'),(2,'Rui'),(3,'Sara');
CREATE TABLE ord(id INTEGER, cli_id INTEGER, val INTEGER);
INSERT INTO ord VALUES (1,1,50),(2,1,70),(3,3,20);
```
Escreve uma consulta que devolva o nome de cada cliente e a soma dos seus valores, incl... | {
"required": [
"LEFT\\s+JOIN",
"COALESCE|IFNULL",
"GROUP\\s+BY",
"FINAL\\s*=\\s*Ana=120;Sara=20;Rui=0"
],
"forbidden": [
"INNER\\s+JOIN"
],
"expected_final": "Ana=120;Sara=20;Rui=0"
} | LEFT JOIN + COALESCE: Rui (sem pedidos) aparece com 0 (INNER JOIN excluí-lo-ia). | Executado: Ana=120, Sara=20, Rui=0. |
codigo-pt | 25 | Tabela SQLite:
```sql
CREATE TABLE eventos(id INTEGER, d TEXT);
INSERT INTO eventos VALUES
(1,'2026-06-01'),(2,'2026-06-20'),(3,'2026-05-01'),(4,'2026-06-30'),(5,'2026-04-15');
```
Considerando a data de referência '2026-06-30', escreve uma consulta que conte quantos eventos ocorreram nos últimos 30 dias, ou seja, com... | {
"required": [
"date\\(",
"-30\\s*day|'-30 day'",
"COUNT\\(\\*\\)",
"FINAL\\s*=\\s*3\\b"
],
"forbidden": [
"FINAL\\s*=\\s*4\\b",
"FINAL\\s*=\\s*2\\b"
],
"expected_final": "3"
} | Janela de 30 dias: fronteira 2026-05-31; contam 06-01, 06-20, 06-30 -> 3 (05-01 fica de fora). | Executado: boundary 2026-05-31; COUNT=3. |
codigo-pt | 26 | Tabelas SQLite:
```sql
CREATE TABLE p(id INTEGER, preco INTEGER);
INSERT INTO p VALUES (1,100),(2,200);
CREATE TABLE tag(pid INTEGER, t TEXT);
INSERT INTO tag VALUES (1,'a'),(1,'b'),(2,'c');
```
Um programador escreveu SELECT SUM(p.preco) FROM p JOIN tag ON tag.pid = p.id; para somar o preço total dos produtos, mas o r... | {
"required": [
"SUM\\(p\\.preco\\)|SUM\\(preco\\)",
"JOIN",
"tag",
"FINAL\\s*=\\s*400\\b"
],
"forbidden": [
"FINAL\\s*=\\s*300\\b",
"DISTINCT"
],
"expected_final": "400"
} | Multiplicação de linhas no JOIN: p1 (100) conta 2x -> SUM=400 (o correcto seria 300). | Executado: SUM(p.preco) sobre o JOIN = 100+100+200 = 400. |
codigo-pt | 27 | Tabela SQLite:
```sql
CREATE TABLE mov(id INTEGER, v INTEGER);
INSERT INTO mov VALUES (1,10),(2,-5),(3,20),(4,-3);
```
Escreve uma consulta com uma função de janela SUM(v) OVER (ORDER BY id) que devolva, para cada linha, o saldo acumulado (running total) ordenado por id. Indica cada linha no formato FINAL=<id>:<acumula... | {
"required": [
"SUM\\(v\\)\\s+OVER",
"ORDER\\s+BY\\s+id",
"FINAL\\s*=\\s*1:10;2:5;3:25;4:22"
],
"forbidden": [
"FINAL\\s*=\\s*1:10;2:-5",
"GROUP\\s+BY"
],
"expected_final": "1:10;2:5;3:25;4:22"
} | Running total com window function: 10, 5, 25, 22. | Executado: SUM OVER (ORDER BY id) -> 10,5,25,22. |
codigo-pt | 28 | Tabela SQLite:
```sql
CREATE TABLE t(id INTEGER, v INTEGER);
INSERT INTO t VALUES (1,2),(2,NULL),(3,5),(4,NULL),(5,2);
```
Escreve uma consulta que conte quantas linhas têm v diferente de 2, usando a condição WHERE v <> 2. Atenção à lógica de três valores do SQL: comparações com NULL resultam em UNKNOWN e as linhas com... | {
"required": [
"WHERE\\s+v\\s*<>\\s*2|v\\s*!=\\s*2",
"COUNT\\(\\*\\)",
"NULL|três\\s+valores|UNKNOWN|desconhec",
"FINAL\\s*=\\s*1\\b"
],
"forbidden": [
"FINAL\\s*=\\s*3\\b",
"FINAL\\s*=\\s*2\\b"
],
"expected_final": "1"
} | Lógica de três valores: v<>2 exclui os NULL; só id=3 (v=5) conta -> 1 (não 3). | Executado: COUNT(*) WHERE v<>2 = 1. |
codigo-pt | 29 | Tabela SQLite:
```sql
CREATE TABLE v(g TEXT, id INTEGER, x INTEGER);
INSERT INTO v VALUES ('p',1,5),('p',2,9),('p',3,2),('q',1,7),('q',2,4);
```
Escreve uma consulta que, para cada linha, devolva FIRST_VALUE(x) OVER (PARTITION BY g ORDER BY id) e MAX(x) OVER (PARTITION BY g), ordenando o resultado por g e depois por id... | {
"required": [
"FIRST_VALUE\\(x\\)\\s+OVER",
"PARTITION\\s+BY\\s+g",
"MAX\\(x\\)\\s+OVER",
"FINAL\\s*=\\s*p1:5/9;p2:5/9;p3:5/9;q1:7/7;q2:7/7"
],
"forbidden": [
"FINAL\\s*=\\s*p1:5/5"
],
"expected_final": "p1:5/9;p2:5/9;p3:5/9;q1:7/7;q2:7/7"
} | FIRST_VALUE (por ordem de id) vs MAX (por partição): fv=5/mx=9 no grupo p; fv=7/mx=7 no grupo q. | Executado: p -> fv=5, mx=9; q -> fv=7, mx=7. |
codigo-pt | 30 | Em PowerShell, quando um pipeline de filtragem devolve apenas UM elemento, o resultado pode ser um escalar em vez de um array — por isso deve envolver-se em @(...) antes de chamar .Count para garantir a contagem correcta. Dado o array @(15, 3, 20, 8), escreve o comando que filtra os elementos maiores que 10 e devolve a... | {
"required": [
"@\\(",
"\\.Count|Where-Object|\\bWhere\\b|\\?\\{",
"-gt\\s*10",
"FINAL\\s*=\\s*2\\b"
],
"forbidden": [
"Invoke-Expression",
"iex\\b"
],
"expected_final": "2"
} | Array-unrolling: @() garante .Count correcto; @(15,3,20,8) > 10 -> 2 elementos. | Executado (mirror em python): [15,20] -> 2. |
codigo-pt | 31 | Em PowerShell, o problema de desempacotamento de array de um único elemento é traiçoeiro: se a filtragem devolver exactamente UM elemento e não se usar @(...), .Count sobre um escalar pode não dar 1 como se espera. Dado o array @(5, 12, 3), escreve o comando que filtra os elementos maiores que 10 e obtém a contagem de ... | {
"required": [
"@\\(",
"-gt\\s*10",
"\\.Count",
"FINAL\\s*=\\s*1\\b"
],
"forbidden": [
"Invoke-Expression",
"iex\\b"
],
"expected_final": "1"
} | Single-element unrolling: só 12 passa; @().Count garante 1 (sem @() um escalar podia falhar .Count). | Executado (mirror em python): [12] -> 1. |
codigo-pt | 32 | Em PowerShell, a análise de números depende da cultura: [double]::Parse('1,5') na cultura portuguesa (pt-PT) interpreta a vírgula como separador decimal e devolve 1.5, enquanto na cultura invariante devolveria 15. Assumindo a cultura pt-PT, escreve as duas chamadas [double]::Parse para as strings '1,5' e '2,5', soma os... | {
"required": [
"\\[double\\]::Parse",
"pt-PT|CultureInfo|'1,5'|\\\"1,5\\\"",
"FINAL\\s*=\\s*4([.,]0+)?\\b"
],
"forbidden": [
"FINAL\\s*=\\s*15",
"FINAL\\s*=\\s*40"
],
"expected_final": "4"
} | Culture-dependent parse: em pt-PT '1,5' -> 1.5; soma 1.5+2.5 = 4 (não 15+25). | Executado (mirror em python): 1.5 + 2.5 = 4.0. |
codigo-pt | 33 | Em PowerShell, o operador -eq aplicado a um array não devolve um booleano — devolve um array com os elementos que satisfazem a igualdade (funciona como filtro). Dado @(1, 2, 2, 3), o resultado de @(1,2,2,3) -eq 2 é um array; escreve a expressão que usa (@(1,2,2,3) -eq 2).Count para contar quantos elementos são iguais a... | {
"required": [
"-eq\\s*2",
"\\.Count",
"filtro|array|filtr",
"FINAL\\s*=\\s*2\\b"
],
"forbidden": [
"FINAL\\s*=\\s*true",
"Invoke-Expression"
],
"expected_final": "2"
} | -eq sobre array devolve elementos filtrados (não bool): @(1,2,2,3) -eq 2 -> @(2,2), Count=2. | Executado (mirror em python): [2,2] -> 2. |
codigo-pt | 34 | Em PowerShell, [math]::Round usa por omissão arredondamento bancário (para o par mais próximo), tal como o .NET: [math]::Round(2.5) dá 2 e [math]::Round(3.5) dá 4. Escreve a expressão que soma [math]::Round(2.5) + [math]::Round(3.5) e indica o resultado. No fim, corre mentalmente a tua solução no input dado e termina c... | {
"required": [
"\\[math\\]::Round",
"2\\.5",
"3\\.5",
"FINAL\\s*=\\s*6\\b"
],
"forbidden": [
"FINAL\\s*=\\s*7\\b",
"MidpointRounding.*AwayFromZero"
],
"expected_final": "6"
} | Banker's rounding no .NET/PowerShell: Round(2.5)=2, Round(3.5)=4 -> soma 6 (não 7). | Executado (mirror em python round, que é half-to-even): 2 + 4 = 6. |
codigo-pt | 35 | Em PowerShell, o operador de intervalo 1..5 gera a sequência de inteiros de 1 a 5 e Measure-Object -Sum soma-os. Escreve o comando 1..5 | Measure-Object -Sum e indica a soma resultante (propriedade Sum). No fim, corre mentalmente a tua solução no input dado e termina com uma linha exactamente no formato FINAL=<resultad... | {
"required": [
"1\\.\\.5",
"Measure-Object\\s+-Sum|Measure-Object.*-Sum",
"FINAL\\s*=\\s*15\\b"
],
"forbidden": [
"FINAL\\s*=\\s*10\\b",
"Invoke-Expression"
],
"expected_final": "15"
} | Range + Measure-Object -Sum: 1+2+3+4+5 = 15. | Executado (mirror em python): sum(range(1,6)) = 15. |
codigo-pt | 36 | Em PowerShell, escreve um comando de uma linha que some os quadrados dos números pares de 1 a 6 (inclusive). Deves gerar o intervalo 1..6, filtrar os pares (resto da divisão por 2 igual a 0), elevar cada um ao quadrado e somar. Indica o total. No fim, corre mentalmente a tua solução no input dado e termina com uma linh... | {
"required": [
"1\\.\\.6",
"%\\s*2\\s*-eq\\s*0|-eq\\s*0",
"FINAL\\s*=\\s*56\\b"
],
"forbidden": [
"FINAL\\s*=\\s*12\\b",
"Invoke-Expression"
],
"expected_final": "56"
} | Pipeline: pares de 1..6 são 2,4,6; quadrados 4,16,36; soma 56. | Executado (mirror em python): 4+16+36 = 56. |
codigo-pt | 37 | Em PowerShell, escreve um comando SEGURO para mover ficheiros com extensão .log da pasta 'C:\Sandbox\tmp' para 'C:\Sandbox\arquivo', usando obrigatoriamente Move-Item com -LiteralPath para lidar correctamente com nomes que contenham caracteres especiais (como parêntesis rectos). O comando NÃO deve apagar nada nem usar ... | {
"required": [
"Move-Item",
"-LiteralPath",
"\\.log",
"C:\\\\Sandbox\\\\tmp"
],
"forbidden": [
"Remove-Item",
"Invoke-Expression",
"\\biex\\b",
"\\bdel\\b",
"rm\\s+-rf"
],
"expected_final": null
} | Estrutura: exige Move-Item -LiteralPath; proíbe Remove-Item/Invoke-Expression (segurança). | Structure-only (expected_final null): correcção verificada por regex de forma/segurança. |
codigo-pt | 38 | Preciso de confirmar a integridade de um checkpoint descarregado antes de o carregar. Em PowerShell, escreve uma função Confirm-PesosIntegros que receba dois parâmetros — o caminho do ficheiro através de -LiteralPath e uma impressão digital esperada em -HashEsperado — calcule a impressão SHA256 do ficheiro com Get-File... | {
"required": [
"function\\s+Confirm-PesosIntegros",
"Get-FileHash",
"-LiteralPath",
"-Algorithm\\s+SHA256|SHA256",
"[$-]HashEsperado"
],
"forbidden": [
"Remove-Item",
"Set-Content",
"Invoke-Expression",
"\\biex\\b",
"Out-File",
"Move-Item"
],
"expected_final": null... | Estrutura: função de verificação de integridade com Get-FileHash/-LiteralPath, comparação case-insensitive; proíbe escrita/execução dinâmica. | Structure-only (expected_final null): a impressão depende do conteúdo do ficheiro; verifica-se a forma e segurança. |
codigo-pt | 39 | Em PowerShell, escreve uma função Get-DirSizeBytes que receba um caminho de pasta através de um parâmetro -LiteralPath e devolva o tamanho total, em bytes, de todos os ficheiros contidos (recursivamente). Deve usar Get-ChildItem -LiteralPath -Recurse -File canalizado para Measure-Object -Property Length -Sum e devolver... | {
"required": [
"function\\s+Get-DirSizeBytes",
"-LiteralPath",
"-Recurse",
"Measure-Object.*-Sum|Measure-Object\\s+-Property\\s+Length\\s+-Sum"
],
"forbidden": [
"Remove-Item",
"Move-Item",
"Set-Content",
"Invoke-Expression",
"\\biex\\b",
"rm\\s+-rf"
],
"expected_final... | Estrutura: função de leitura com -LiteralPath/-Recurse/Measure-Object -Sum; proíbe operações destrutivas. | Structure-only (expected_final null): tamanho depende do sistema de ficheiros; verifica-se a forma. |
codigo-pt | 40 | Depara-te com este traceback ao executar um script:
```
Traceback (most recent call last):
File "freq.py", line 7, in <module>
print(contar_letras('ala'))
File "freq.py", line 4, in contar_letras
d[c] += 1
KeyError: 'a'
```
O ficheiro freq.py tem exactamente estas 7 linhas (numeradas):
```
1: def contar_let... | {
"required": [
"linha\\s*4|\\blinha 4\\b",
"KeyError|inicializ|get\\(|Counter|defaultdict",
"FINAL\\s*=\\s*4\\b"
],
"forbidden": [
"rm\\s+-rf",
"FINAL\\s*=\\s*7\\b"
],
"expected_final": "4"
} | Debug por evidencia: KeyError directo; a linha do traceback (4) e a origem. Correccao: inicializar contagem. | Executado: d[c]+=1 sem inicializar levanta KeyError na linha 4; traceback aponta a linha 4 (origem directa). |
codigo-pt | 41 | Este codigo devia somar apenas os numeros pares de uma lista, mas rebenta:
```python
def soma_pares(xs):
s = 0
for i in range(len(xs) + 1):
if xs[i] % 2 == 0:
s += xs[i]
return s
print(soma_pares([4, 7, 2, 9, 6, 1]))
```
Ao correr, lanca 'IndexError: list index out of range'. Corrige o d... | {
"required": [
"range\\(len\\(xs\\)\\)|range\\(len\\(xs\\) *\\)|len\\(xs\\)\\b",
"IndexError|\\+ *1|off.?by.?one|[íi]ndice",
"FINAL\\s*=\\s*12\\b"
],
"forbidden": [
"rm\\s+-rf",
"FINAL\\s*=\\s*21\\b"
],
"expected_final": "12"
} | IndexError por range(len(xs)+1); apos corrigir para range(len(xs)), pares 4+2+6=12. | Executado: soma_pares([4,7,2,9,6,1]) com range(len(xs)) = 4+2+6 = 12. |
codigo-pt | 42 | Uma funcao que calcula a media de uma lista falha quando a lista vem vazia:
```python
def media(valores):
return sum(valores) / len(valores)
```
Num relatorio, e chamada primeiro com uma lista vazia (media([])) — o que lanca 'ZeroDivisionError: division by zero' — e logo a seguir com media([10, 20, 30]). Corrige a ... | {
"required": [
"ZeroDivision|len\\(valores\\)\\s*==\\s*0|not\\s+valores|if\\s+.*valores",
"return\\s+0",
"FINAL\\s*=\\s*20(\\.0+)?\\b"
],
"forbidden": [
"rm\\s+-rf",
"FINAL\\s*=\\s*0(\\.0+)?\\s*$"
],
"expected_final": "20.0"
} | ZeroDivisionError na lista vazia; apos guarda, media([10,20,30])=60/3=20.0. | Executado: com guarda de lista vazia, media([10,20,30]) = 60/3 = 20.0. |
codigo-pt | 43 | Este codigo gera a sequencia de Fibonacci e devolve o n-esimo termo, mas lanca uma excepcao:
```
Traceback (most recent call last):
File "fib.py", line 7, in <module>
print(fibonacci(8))
File "fib.py", line 5, in fibonacci
return seq[n]
IndexError: list index out of range
```
O ficheiro fib.py tem exactamen... | {
"required": [
"linha\\s*3|\\blinha 3\\b",
"range\\(2,\\s*n\\s*\\+\\s*1\\)|n\\s*\\+\\s*1|montante|origem|preench",
"FINAL\\s*=\\s*3\\b"
],
"forbidden": [
"rm\\s+-rf",
"FINAL\\s*=\\s*5\\b"
],
"expected_final": "3"
} | Off-by-one A MONTANTE: traceback na linha 5 (return seq[n]) mas a causa e range(2,n) na linha 3. | Executado: com range(2,n) e n=8, len(seq)=8 (indices 0..7); seq[8] -> IndexError na linha 5. Causa na linha 3; fix range(2,n+1) -> fib(8)=21. |
codigo-pt | 44 | Este codigo devia contar quantos valores distintos existem numa lista, mas lanca uma excepcao:
```python
def n_distintos(nums):
ordenados = nums.sort()
return len(set(ordenados))
print(n_distintos([3, 1, 4, 1, 5, 9, 2, 6]))
```
Ao correr, lanca 'TypeError: object of type NoneType has no len()'. Explica porque (... | {
"required": [
"sorted\\(",
"None|no lugar|in.?place|devolve\\s+None|retorna\\s+None",
"FINAL\\s*=\\s*7\\b"
],
"forbidden": [
"rm\\s+-rf",
"FINAL\\s*=\\s*8\\b"
],
"expected_final": "7"
} | TypeError NoneType: nums.sort() devolve None; fix com sorted(). Distintos de [3,1,4,1,5,9,2,6] = 7. | Executado: set([1,2,3,4,5,6,9]) tem 7 elementos; len=7 apos usar sorted(). |
codigo-pt | 45 | Este codigo soma valores lidos como texto (por exemplo de um CSV), mas rebenta:
```python
linhas = [('a', '10'), ('b', '20'), ('c', '5')]
total = 0
for _, v in linhas:
total += v
print(total)
```
Ao correr, lanca 'TypeError: unsupported operand type(s) for +=: \'int\' and \'str\''. Corrige o defeito minimo (convert... | {
"required": [
"int\\(v\\)|int\\(",
"FINAL\\s*=\\s*35\\b"
],
"forbidden": [
"rm\\s+-rf",
"FINAL\\s*=\\s*1020"
],
"expected_final": "35"
} | TypeError int+=str; com int(v) a soma e 10+20+5=35 (nao concatenacao '1020...5'). | Executado: total = int('10')+int('20')+int('5') = 35. |
codigo-pt | 46 | Esta implementacao de Fibonacci com memoizacao devia ser eficiente, mas tem um defeito subtil:
```python
def fib(n, memo={}):
if n < 2:
return n
return memo[n]
print(fib(15))
```
Ao correr, lanca 'KeyError: 15' porque o codigo le memo[n] sem nunca calcular nem armazenar o valor. Corrige a funcao para pr... | {
"required": [
"memo\\[n\\]\\s*=|memo\\.setdefault|memo\\[n\\]\\s*=\\s*fib",
"fib\\(n\\s*-\\s*1\\)|fib\\(n-1\\)",
"FINAL\\s*=\\s*610\\b"
],
"forbidden": [
"rm\\s+-rf",
"FINAL\\s*=\\s*987\\b"
],
"expected_final": "610"
} | KeyError por ler memo[n] sem preencher; fib(15) correcto = 610 (nao 987=fib(16)). | Executado: fib(15) = 610 apos preencher memo[n]=fib(n-1)+fib(n-2). |
codigo-pt | 47 | Esta funcao devia calcular as somas de todas as janelas deslizantes de largura w, mas lanca uma excepcao:
```
Traceback (most recent call last):
File "win.py", line 10, in <module>
print(janelas([1, 2, 3, 4], 2))
File "win.py", line 6, in janelas
s += data[j]
IndexError: list index out of range
```
O fichei... | {
"required": [
"linha\\s*3|\\blinha 3\\b",
"len\\(data\\)\\s*-\\s*w\\s*\\+\\s*1|montante|origem|janela",
"FINAL\\s*=\\s*3\\b"
],
"forbidden": [
"rm\\s+-rf",
"FINAL\\s*=\\s*6\\b"
],
"expected_final": "3"
} | Off-by-one A MONTANTE: traceback na linha 6 (data[j]) mas a causa e o range exterior na linha 3. | Executado: com range(len(data)) o inicio i chega a 3 e a janela [3,4] acede data[4] -> IndexError na linha 6. Causa linha 3; fix range(len(data)-w+1) -> [3,5,7]. |
codigo-pt | 48 | Especificacao (NAO implementes a funcao; escreve APENAS os testes): uma funcao dividir_seguro(a, b) devolve a/b como float, mas levanta ZeroDivisionError quando b == 0 e levanta TypeError quando algum argumento nao e numerico (int ou float). Escreve testes com pytest que cubram, de forma explicita: (1) um caso normal (... | {
"required": [
"import\\s+pytest|from\\s+pytest",
"pytest\\.raises\\(\\s*ZeroDivisionError",
"pytest\\.raises\\(\\s*TypeError",
"@pytest\\.mark\\.parametrize|parametrize",
"['\\\"]x['\\\"]",
"\\bdef\\s+test_"
],
"forbidden": [
"rm\\s+-rf",
"def\\s+dividir_seguro"
],
"expected_... | Test authoring: exige pytest.raises para ZeroDivisionError E TypeError, parametrize e o input nao-numerico 'x'. | Structure-only (null): required forcam cobertura das arestas (div-zero, nao-numerico) alem do caso normal; forbidden impede que o modelo implemente a funcao em vez de a testar. |
codigo-pt | 49 | Especificacao (escreve APENAS os testes, nao a implementacao): uma funcao fatorial(n) devolve o factorial de um inteiro n >= 0 (com fatorial(0) == 1) e levanta ValueError se n for negativo. Escreve testes pytest que cubram explicitamente: (1) o caso-limite n = 0 (esperado 1); (2) um valor pequeno (por exemplo fatorial(... | {
"required": [
"import\\s+pytest|from\\s+pytest",
"pytest\\.raises\\(\\s*ValueError",
"@pytest\\.mark\\.parametrize|parametrize",
"fatorial\\(\\s*0\\s*\\)|\\(0,\\s*1\\)|\\b0\\b.*\\b1\\b",
"120",
"\\bdef\\s+test_"
],
"forbidden": [
"rm\\s+-rf",
"def\\s+fatorial\\s*\\(\\s*n\\s*\\)\\... | Test authoring: caso-limite 0, valor 120, negativo via pytest.raises(ValueError), parametrize. | Structure-only (null): required cobrem arestas 0/negativo; forbidden (assinatura + corpo) impede fornecer a implementacao real de fatorial. |
codigo-pt | 50 | Especificacao (escreve APENAS os testes com pytest, sem implementar): uma funcao aparar(texto, limite) devolve o texto encurtado a 'limite' caracteres acrescentando '...' quando o texto excede o limite; se o texto couber no limite, devolve-o inalterado; se limite <= 0, levanta ValueError. Escreve testes que cubram expl... | {
"required": [
"import\\s+pytest|from\\s+pytest",
"pytest\\.raises\\(\\s*ValueError",
"@pytest\\.mark\\.parametrize|parametrize",
"\\.\\.\\.|['\\\"]\\.\\.\\.['\\\"]|reticenc|exceed|excede|fronteira|exactamente",
"\\bdef\\s+test_"
],
"forbidden": [
"rm\\s+-rf",
"def\\s+aparar\\s*\\("
... | Test authoring: fronteira 'exactamente no limite', truncagem com '...', ValueError para limite<=0, parametrize. | Structure-only (null): required forcam a aresta de fronteira e a excepcao; forbidden impede implementar aparar em vez de a testar. |
codigo-pt | 51 | Uma funcao parse_intervalo(s) recebe uma string 'a-b' (dois inteiros separados por hifen) e devolve a lista de inteiros de a ate b INCLUSIVE; se a > b, levanta ValueError. Por exemplo, parse_intervalo('3-6') devolve [3, 4, 5, 6]. Primeiro, escreve testes pytest que cubram: (1) um intervalo normal; (2) o caso a == b (li... | {
"required": [
"import\\s+pytest|from\\s+pytest",
"pytest\\.raises\\(\\s*ValueError",
"@pytest\\.mark\\.parametrize|parametrize",
"\\bdef\\s+test_",
"FINAL\\s*=\\s*5\\b"
],
"forbidden": [
"rm\\s+-rf",
"FINAL\\s*=\\s*4\\b"
],
"expected_final": "5"
} | Test authoring com FINAL executavel: len(parse_intervalo('10-14'))=5 (10,11,12,13,14, inclusive); arestas a==b e a>b. | Executado: list(range(10,15)) tem 5 elementos. Required forcam cobertura de fronteira (a==b) e excepcao (a>b) alem do FINAL. |
codigo-pt | 52 | Uma funcao normaliza_telefone(s) recebe um numero de telemovel portugues possivelmente com espacos, hifens e prefixo '+351', e devolve os 9 digitos sem separadores; se, apos limpeza, nao tiver exactamente 9 digitos ou nao comecar por '9', levanta ValueError. Primeiro escreve testes pytest que cubram: (1) um numero vali... | {
"required": [
"import\\s+pytest|from\\s+pytest",
"pytest\\.raises\\(\\s*ValueError",
"@pytest\\.mark\\.parametrize|parametrize",
"\\bdef\\s+test_",
"FINAL\\s*=\\s*912345678\\b"
],
"forbidden": [
"rm\\s+-rf",
"FINAL\\s*=\\s*351912345678"
],
"expected_final": "912345678"
} | Test authoring com FINAL executavel: strip de espacos e '+351' -> '912345678'; arestas curto e prefixo-8. | Executado: '+351 912 345 678' limpo -> '912345678' (remove '+351' e espacos). Required forcam duas arestas ValueError distintas. |
codigo-pt | 53 | Estas em modo 'detached HEAD': fizeste checkout de um commit antigo (HEAD~1) para inspeccao e, sem reparar, criaste ai um commit novo com trabalho importante ('lost-work') que ainda NAO foi enviado (unpushed). O historico antes era linear com 3 commits (c1, c2, c3) no ramo principal; o teu commit novo assenta sobre c2.... | {
"required": [
"git\\s+branch\\s+salva",
"detached|HEAD|resgat|salva",
"FINAL\\s*=\\s*3\\b"
],
"forbidden": [
"push\\s+--force|push\\s+-f\\b",
"checkout\\s+\\.\\s*$|checkout\\s+--\\s|reset\\s+--hard(?!.*salva)",
"FINAL\\s*=\\s*4\\b"
],
"expected_final": "3"
} | Detached HEAD unpushed: resgatar com 'git branch salva' antes de trocar HEAD; ramo salva tem 3 commits (c1,c2,lost). | Executado (git real): git branch salva HEAD em detached@c2+lost -> git rev-list --count salva = 3. Forbidden proibe push --force/checkout . /reset --hard sem salva. |
codigo-pt | 54 | Fizeste, por engano, um commit no ramo 'main' que na verdade pertencia a um ramo de funcionalidade. O 'main' tinha 2 commits (base1, base2) e agora tem um terceiro ('belongs-on-feature') que nao devia la estar; esse commit ainda NAO foi enviado para o remoto. Descreve a sequencia SEGURA para o mover: primeiro cria um r... | {
"required": [
"git\\s+branch\\s+feature",
"reset\\s+--hard\\s+HEAD~1|reset\\s+--hard\\s+HEAD\\^|reset.*HEAD~1",
"FINAL\\s*=\\s*2\\b"
],
"forbidden": [
"push\\s+--force\\s+.*main|push\\s+-f\\s+.*main",
"FINAL\\s*=\\s*3\\b"
],
"expected_final": "2"
} | Commit no ramo errado: preservar com 'git branch feature' antes de 'git reset --hard HEAD~1'; main fica com 2. | Executado (git real): branch feature (guarda o 3o commit) -> reset --hard HEAD~1 no main -> rev-list --count = 2 (feature fica com 3). |
codigo-pt | 55 | Refactoriza esta funcao mantendo EXACTAMENTE o comportamento, mas SEM usar o padrao 'for i in range(len(...))' (usa enumerate ou uma compreensao):
```python
def dobra_impares(xs):
out = []
for i in range(len(xs)):
if i % 2 == 1:
out.append((i, xs[i] * 2))
return out
```
A funcao devolve,... | {
"required": [
"enumerate\\(|\\[\\s*\\(",
"def\\s+dobra_impares",
"FINAL\\s*=\\s*120\\b"
],
"forbidden": [
"for\\s+\\w+\\s+in\\s+range\\(\\s*len\\(",
"rm\\s+-rf",
"FINAL\\s*=\\s*60\\b"
],
"expected_final": "120"
} | Refactor sem range(len()): indices impares 1,3 -> valores 20,40 dobrados = 40+80 = 120 (comportamento preservado). | Executado: pares (1,40),(3,80); soma dos dobrados = 120. Forbidden proibe o anti-padrao range(len()). |
codigo-pt | 56 | Refactoriza este contador mantendo o comportamento, mas SEM usar a instrucao 'global' (usa uma closure com 'nonlocal' ou uma classe):
```python
cont = 0
def incrementa():
global cont
cont += 1
return cont
```
O comportamento e: cada chamada devolve o numero de vezes que foi chamada ate ao momento. Cria uma ... | {
"required": [
"nonlocal|class\\s+\\w+",
"def\\s+criar_contador|def\\s+\\w*contador|return\\s+\\w+",
"FINAL\\s*=\\s*5\\b"
],
"forbidden": [
"^[ \t]*global[ \t]+\\w+",
"rm\\s+-rf",
"FINAL\\s*=\\s*1\\b"
],
"expected_final": "5"
} | Refactor sem global: closure com nonlocal; a 5a chamada devolve 5 (estado preservado por instancia). | Executado: [c() for _ in range(5)][-1] = 5. Forbidden proibe 'global'. |
codigo-pt | 57 | Refactoriza esta funcao para ELIMINAR o try aninhado (nested try), mantendo o comportamento, com no maximo um unico bloco try por iteracao:
```python
def soma_validos(itens):
total = 0
for it in itens:
try:
try:
total += int(it)
except ValueError:
... | {
"required": [
"except\\s+ValueError|except\\s*\\(",
"def\\s+soma_validos",
"FINAL\\s*=\\s*25\\b"
],
"forbidden": [
"try:\\s*\\n\\s*try:",
"rm\\s+-rf",
"FINAL\\s*=\\s*15\\b"
],
"expected_final": "25"
} | Refactor sem try aninhado: converter-e-ignorar; 3+10+7+5=25 (comportamento preservado). | Executado: soma dos convertiveis ['3','10','7','5'] = 25. Forbidden apanha o padrao 'try:' seguido de 'try:'. |
codigo-pt | 58 | Refactoriza esta contagem de frequencias mantendo o comportamento, mas SEM inicializar manualmente o dicionario com um if de verificacao de chave (usa collections.Counter ou dict.get):
```python
def frequencias(texto):
d = {}
for p in texto.split():
if p not in d:
d[p] = 0
d[p] += 1
... | {
"required": [
"Counter\\(|\\.get\\(",
"def\\s+frequencias",
"FINAL\\s*=\\s*3\\b"
],
"forbidden": [
"if\\s+\\w+\\s+not\\s+in\\s+d\\b",
"rm\\s+-rf",
"FINAL\\s*=\\s*2\\b"
],
"expected_final": "3"
} | Refactor com Counter/get: 'the' aparece 3 vezes (comportamento preservado). | Executado: Counter('the cat sat on the mat the cat ran'.split())['the'] = 3. Forbidden proibe o 'if not in d'. |
codigo-pt | 59 | Refactoriza esta funcao para uma UNICA compreensao de lista, mantendo o comportamento e SEM usar 'for i in range(len(...))':
```python
def chaves_grandes(pares):
res = []
for i in range(len(pares)):
if pares[i][1] > 1:
res.append(pares[i][0])
return ''.join(res)
```
O comportamento e: ju... | {
"required": [
"\\[\\s*\\w+\\s+for\\s|join\\(\\s*\\w+\\s+for",
"def\\s+chaves_grandes",
"FINAL\\s*=\\s*bcd\\b"
],
"forbidden": [
"for\\s+\\w+\\s+in\\s+range\\(\\s*len\\(",
"rm\\s+-rf",
"FINAL\\s*=\\s*abcd\\b"
],
"expected_final": "bcd"
} | Refactor para compreensao sem range(len()): valores>1 sao b,c,d -> 'bcd' (comportamento preservado). | Executado: ''.join(k for k,v in pares if v>1) = 'bcd'. Forbidden proibe range(len()). |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.