Imersão Gratuita sobre Inteligência Artificial – DIA 3 – IA e Aplicações no dia a dia

Prompt prático para gerar o código de Python usado na live

Role: Você é um gerador de código.
Objetivo: Produzir um único arquivo Python chamado pf.py com o conteúdo abaixo, sem comentários extras nem explicações.
Formato de saída: Devolva apenas um bloco de código markdown com a linguagem python, contendo o arquivo completo pf.py. Não inclua nenhum outro texto fora do bloco de código.

Arquivo requerido: pf.py
Descrição: Script que lê um PDF, extrai texto com pdfplumber, identifica blocos por CARGO, detecta subgrupos (Geral, PCD, Negros), quebra candidatos separados por " / ", parseia inscrição, nome, notas (tanto 5 notas quanto 1 nota), nomeia colunas (Delegado com 5 notas → Q1, Q2, Q3, Peca, Total; se 1 nota → P2_Total), e exporta um Excel (Resultados) com largura de colunas autoajustada.
Dependências: pdfplumber, pandas, openpyxl.
Execução: python pf.py INPUT.pdf [saida.xlsx].

Código gerado:

import sys, os, re

import pdfplumber, pandas as pd

from openpyxl.utils import get_column_letter

# Detecta cabeçalhos de cargo (aceita prefixos tipo “1.1.1 “)

CARGO_RE = re.compile(r'(?mi)^\s*(?:\d+(?:\.\d+)*)?\s*CARGO\s+\d+:[^\n]+’)

# Detecta início de subseções (PCD / Negros)

PCD_RE = re.compile(r'(?i)reservadas\s+às\s+pessoas\s+com\s+deficiência’)

NEGROS_RE = re.compile(r'(?i)autodeclararam\s+negros’)

def autoajustar_largura(ws, df, max_width=60, padding=2):

for i, col inenumerate(df.columns,start=1):

valores = [str(col)]

valores += [“” if v is None else str(v) for v in df[col].tolist()]

max_len = max((len(v) for v in valores), default=0)

ws.column_dimensions[get_column_letter(i)].width = min(max_len + padding, max_width)

def find_cargo_blocks(text):

“””Retorna lista de (titulo_cargo, bloco_texto) na ordem.”””

matches = list(CARGO_RE.finditer(text))

blocks = []

for i, m inenumerate(matches):

start = m.start()

end = matches[i+1].start() if i+1 < len(matches) else len(text)

title = m.group(0).strip()

blocks.append((title, text[start:end]))

return blocks

def split_groups_in_block(block_text):

“””

Divide bloco em sub-blocos por grupo: (‘Geral’ | ‘PCD’ | ‘Negros’, texto).

Se não achar marcadores, retorna um único (‘Geral’, block_text).

“””

# Procurar marcadores e suas posições

markers = []

for match in re.finditer(PCD_RE, block_text):

markers.append((match.start(), ‘PCD’))

for match in re.finditer(NEGROS_RE, block_text):

markers.append((match.start(), ‘Negros’))

markers.sort(key=lambda x: x[0])

ifnot markers:

return[(‘Geral’, block_text)]

# Construir fatias

groups = []

# trecho “Geral” antes do primeiro marcador (se tiver conteúdo)

first_pos = markers[0][0]

pre = block_text[:first_pos].strip()

if pre:

groups.append((‘Geral’, pre))

for i,(pos, label)inenumerate(markers):

start = pos

end = markers[i+1][0] if i+1 < len(markers) else len(block_text)

piece = block_text[start:end]

groups.append((label, piece))

return groups

def split_candidates(text_piece):

“””

Divide uma sequência que contém vários candidatos separados por ” / “.

Também lida com o último terminar em ponto.

“””

# Quebra primária por ” / “

chunks = []

for part in text_piece.split(‘ / ‘):

part = part.strip()

ifnot part:

continue

# remove ponto final isolado no fim

part = re.sub(r’\.\s*$’, ”, part)

if part:

chunks.append(part)

return chunks

def parse_segment(seg):

“””

Espera algo como:

“10162070, Nome Sobrenome, 1.29, 1.53, 0.92, 5.06, 8.80”

“10201820, Nome Sobrenome, 10.30”

Retorna dict ou None.

“””

# Quebra por vírgula + espaços

parts = [p.strip() for p in re.split(r’,\s*’, seg)]

iflen(parts)<3:

return None

inscr = parts[0]

ifnot re.fullmatch(r’\d{6,12}’, inscr):

return None

nome = parts[1]

notas_raw = parts[2:]

notas = []

for x in notas_raw:

# aceita números tipo 10, 10.30

if re.fullmatch(r’\d+(?:\.\d+)?’, x):

try:

notas.append(float(x))

except Exception:

return None

else:

# se aparecer algo não numérico nas notas, aborta

return None

return {“inscricao”: inscr,”nome”: nome,”notas”: notas}

def label_notas_for_cargo(cargo_title, n_notas):

“””

Se for Delegado com 5 notas, rotula como Q1, Q2, Q3, Peca, Total.

Caso contrário, usa nota_1..nota_n (ou P2_Total se for só 1).

“””

cargo_up = cargo_title.upper()

if’DELEGADO’in cargo_up and n_notas ==5:

return[‘Q1′,’Q2′,’Q3′,’Peca’,’Total’]

if n_notas ==1:

return[‘P2_Total’]

return[f’nota_{i+1}’for i inrange(n_notas)]

def extract_rows(full_text):

rows = []

cargo_blocks = find_cargo_blocks(full_text)

for cargo_title, cargo_text in cargo_blocks:

group_blocks = split_groups_in_block(cargo_text)

for grupo, gtext in group_blocks:

segments = split_candidates(gtext)

for seg in segments:

rec = parse_segment(seg)

if rec:

rows.append({

“cargo”: cargo_title,

“grupo”: grupo,

“inscricao”: rec[“inscricao”],

“nome”: rec[“nome”],

“notas”: rec[“notas”],

})

return rows

def to_dataframe(rows):

ifnot rows:

return pd.DataFrame([{“info”: “Nenhum candidato identificado”}])

# Para nomear colunas de notas por CARGO: calcular n máximo por cargo

by_cargo = {}

for r in rows:

c = r[“cargo”]

by_cargo.setdefault(c, 0)

by_cargo[c] = max(by_cargo[c], len(r[“notas”]))

# Construir DataFrame linha a linha com labels adequados por cargo

final_rows = []

all_note_cols = set()

for r in rows:

c = r[“cargo”]

n = len(r[“notas”])

labels = label_notas_for_cargo(c, n if n>0 else by_cargo[c])

base = {“cargo”: r[“cargo”], “grupo”: r[“grupo”], “inscricao”: r[“inscricao”], “nome”: r[“nome”]}

for i, label inenumerate(labels):

val = r[“notas”][i] if i < len(r[“notas”]) else None

base[label] = val

all_note_cols.add(label)

final_rows.append(base)

# Ordenar colunas: fixas + notas

fixed = [“cargo”, “grupo”, “inscricao”, “nome”]

note_cols_sorted = sorted([c for c in all_note_cols], key=lambda x: (len(x), x))

cols = fixed + note_cols_sorted

df = pd.DataFrame(final_rows)

# Garante que todas as colunas existam

for col in cols:

if col notin df.columns:

df[col] = None

return df[cols]

def main():

iflen(sys.argv)<2:

print(“Uso: python pf.py INPUT.pdf [saida.xlsx]”)

sys.exit(2)

pdf_path = sys.argv[1]

xlsx_path = sys.argv[2] if len(sys.argv) > 2 else os.path.splitext(pdf_path)[0] + “.xlsx”

ifnot os.path.isfile(pdf_path):

print(f”Erro: arquivo não encontrado: {pdf_path}”,file=sys.stderr)

sys.exit(1)

# Extrai texto de todas as páginas

texts = []

with pdfplumber.open(pdf_path)as pdf:

for page in pdf.pages:

t = page.extract_text() or “”

texts.append(t)

full_text = “\n”.join(texts)

rows = extract_rows(full_text)

df = to_dataframe(rows)

with pd.ExcelWriter(xlsx_path,engine=”openpyxl”)as writer:

df.to_excel(writer, sheet_name=”Resultados”, index=False)

ws = writer.sheets[“Resultados”]

autoajustar_largura(ws, df)

ws.sheet_state = “visible”

writer.book.active = 0

print(f”Pronto! Gerado: {xlsx_path}”)

if __name__ == “__main__”:

main()

20 prompts para estudantes de concursos públicos

PLANEJAMENTO E ORGANIZAÇÃO

1. Cronograma baseado no edital do INSS (Cebraspe)

Monte um cronograma semanal de estudos para o concurso do INSS, cargo de Técnico do Seguro Social, considerando 3 horas por dia úteis e 5 horas aos sábados. Baseie-se no último edital (2022) da banca Cebraspe e distribua o tempo entre Ética, Noções de Direito Constitucional, Administrativo, Raciocínio Lógico, Português e Seguridade Social. Inclua revisões usando o método 24h, 7d e 30d.

2. Matriz de prioridade por disciplina (TRT – FGV)

Crie uma tabela com os temas mais cobrados nas provas da FGV para concursos de TRT (2022–2025). Classifique os tópicos de Português, Direito do Trabalho, e Processo do Trabalho em ordem de incidência. Cite as provas usadas como referência e destaque os tópicos que mais geram erro nos candidatos.

3. Plano de revisão adaptativo (TJ-SP – Vunesp)

Monte um plano de revisão de 4 semanas para o concurso do TJ-SP (escrevente técnico), considerando o estilo da Vunesp. Use dados reais de frequência temática e mostre como alternar revisões por videoaulas, leitura e por questões. Inclua um modelo de planilha para controle de progresso.

APRENDIZADO E FIXAÇÃO

4. Explicação técnica com base legal (Receita Federal – ESAF / FGV)

Explique o tema ‘Competência Tributária’ com base no CTN (artigos 6º a 9º) e na CF/88 (art. 153 a 156). Dê exemplos de questões cobradas pela ESAF e FGV, mostrando o raciocínio exigido em cada. Cite expressamente o artigo de lei correspondente a cada conceito.

5. Comparativo entre bancas (Direito Administrativo)

Compare como FGV, Cebraspe e FCC cobram o tema ‘Poder de Polícia’. Use exemplos reais de questões (com ano e concurso) e destaque se a banca prioriza literalidade da lei, casos práticos ou interpretação doutrinária. Aponte qual perfil exige mais decoreba e qual exige mais raciocínio.

6. Resumo estruturado (Português – FGV)

Crie um resumo com tópicos curtos sobre ‘Crase e Regência Verbal e Nominal’, com base na gramática de Celso Cunha e nas provas da FGV (2021–2025). Ao final, liste 3 pegadinhas típicas e 2 formas eficazes de memorização, com exemplos retirados de provas.

7. Explicação com analogia controlada (Direito Constitucional)

Explique o conceito de controle de constitucionalidade difuso usando uma analogia com o funcionamento de uma partida de futebol. Após a analogia, indique seus limites — ou seja, o ponto onde ela deixa de representar o conceito jurídico com precisão.

MEMORIZAÇÃO E FOCO

8. Revisão ativa com base em questões (PF – Cebraspe)

Monte 10 perguntas objetivas no estilo Cebraspe sobre ‘Poderes da Administração Pública’. Espere minhas respostas e, ao final, corrija cada uma com base em questões reais da PF/2025. Mostre o raciocínio que leva ao certo e o erro mais comum em cada alternativa.

9. Flashcards com fonte real (Direito Penal – IBFC)

Crie 10 flashcards sobre ‘Teoria do Crime’ com base em questões do IBFC (2022–2025). Cada flashcard deve conter uma pergunta direta e resposta curta, citando a prova de origem. Evite perguntas vagas e priorize pontos conceituais, como dolo eventual e culpa consciente.

10. Repetição espaçada (Português – FCC)

Monte um plano de revisão de 30 dias para memorização das classes gramaticais, baseado na curva do esquecimento. Indique os dias de revisão, as ferramentas ideais (flashcards, mapas mentais, resumos) e como combinar teoria com exercícios da FCC.

QUESTÕES E EXERCÍCIOS

11. Simulado no estilo FGV (TRT)

Gere um simulado de 10 questões inéditas sobre ‘Processo do Trabalho’ no estilo da FGV. Cada questão deve ter 5 alternativas e uma correta. Ao final, apresente o gabarito com comentários fundamentados na CLT e em questões de 2023-2025. Indique o grau de dificuldade (fácil, médio, difícil).

12. Questão passo a passo (Cebraspe – Direito Constitucional)

Apresente uma questão de múltipla escolha da Cebraspe sobre ‘Organização do Estado’. Espere minha resposta e, depois, explique detalhadamente o raciocínio até o gabarito, mostrando por que as demais estão erradas e citando o artigo correspondente da Constituição.

13. Questões integradas (Direito + Raciocínio Lógico – Polícia Civil)

Crie 5 questões no estilo IBFC integrando raciocínio lógico e interpretação de enunciados jurídicos. Explique o raciocínio exigido em cada uma e como a banca costuma aumentar a complexidade com detalhes irrelevantes.

14. Temas quentes por banca (INSS – Cebraspe)

Liste os 10 assuntos mais cobrados em provas recentes do Cebraspe para o INSS. Cite o nome da prova, o ano e o percentual de incidência por tema. Explique por que cada tema é recorrente e onde os candidatos mais erram.

TÁTICA, MOTIVAÇÃO E ANÁLISE DE DESEMPENHO

15. Análise de erros (TJ-RJ – FGV)

Analise o padrão de erro em 50 questões de Português que eu errei na preparação para o TJ-RJ (FGV). Classifique se os erros foram de interpretação, gramática, ou distração, e crie um plano de reforço com base nesses dados.

16. Tática de prova (Cebraspe)

Explique a melhor estratégia de marcação e tempo para provas do Cebraspe, considerando o modelo de ‘certo ou errado’. Mostre como minimizar penalizações por erros e quando é racional deixar uma questão em branco.

17. Prova discursiva (TRT – FGV)

Crie um guia para elaborar respostas discursivas no estilo FGV, com estrutura de introdução, desenvolvimento e conclusão. Dê um exemplo real de tema (ex: ‘a subordinação estrutural nas relações de trabalho’) e mostre uma resposta modelo nota máxima.

18. Controle emocional pré-prova (área policial)

Monte um protocolo mental para os 3 dias que antecedem a prova, com foco em autocontrole e foco atencional. Inclua técnicas de respiração, visualização positiva e checklist de logística. Baseie-se em princípios da psicologia cognitivo-comportamental.

19. Motivação baseada em dados reais

Liste 10 histórias reais de aprovados em concursos (de fontes verificáveis, como Gran), destacando o tempo de preparação e o principal aprendizado de cada um. Evite frases genéricas e mostre padrões de comportamento que levaram ao resultado.

20. Diagnóstico de desempenho objetivo (Receita Federal – FGV)

Usando dados de simulados (percentual de acertos por disciplina, tempo médio por questão, e grau de confiança pessoal), monte uma análise objetiva de desempenho para o concurso da Receita Federal.
Indique quais disciplinas oferecem o melhor retorno marginal se o aluno aumentar 10% o tempo de estudo nelas. Baseie-se no peso das matérias no edital e nas estatísticas de cobrança da FGV.
Gere um plano de reforço semanal com revisões, exercícios e métricas de acompanhamento.