DCE 3º PERÍODO · ADS
UNDBAnálise e Desenvolvimento de Sistemas3º período

O semestre inteiro, em cinco notascurrículo revisado, checklist, glossário e laboratório — uma nota por disciplina

Cada nota pega a disciplina oficial e a reescreve como plano de estudo: o que aprender, em que ordem, com qual ferramenta e por que aquilo importa para quem quer viver de construir software. Todas abrem com uma seção “do zero” — se você nunca viu o assunto, comece por ela e o resto passa a fazer sentido.

5disciplinas
340hcarga do semestre
148tópicos no checklist
0%concluído por você
Escolha por onde entrar

As cinco disciplinas

Treino para a prova: a lista de exercícios de Estrutura de Dados tem página própria — 12 questões com passo a passo, simuladores de pilha, fila e lista encadeada, e dois quizzes cronometrados.

Os vereditos vêm da triagem de cada nota: aprofundar = vale ir além do teto do curso; profundidade média = dominar o recorte útil e deixar o resto em nível de prova; satisfazer = cumprir bem a disciplina sem gastar horas extras.

Por que estudar as cinco juntas

Elas convergem no mesmo lugar

Cada disciplina parece um assunto isolado no papel do curso. Não são: as cinco desembocam na mesma coisa — a capacidade de construir e conduzir um sistema real para um negócio real.

CINCO DISCIPLINAS, UMA PRÁTICA Estrutura de Dados o código que aguenta crescer Estatística Decisória decidir se mudou Arquitetura de Computadores por que ficou lento a prática: um sistema real Banco de Dados o que o negócio guarda Modelagem de Processos o fluxo antes do sistema
Nenhuma das cinco é um fim em si. Modelagem descobre o fluxo do negócio; banco guarda o que esse fluxo produz; estrutura de dados faz o código sobreviver ao crescimento; arquitetura explica onde o tempo é gasto; estatística decide se o que você mudou realmente mudou alguma coisa. Estudar cada uma apontando para o mesmo sistema é o que converte cinco notas em uma competência.
cruzamento 1

Estrutura de Dados × Arquitetura

“Array é rápido” é meia frase. A outra metade está em Arquitetura: elementos lado a lado na memória cabem juntos no cache — a estrutura é rápida porque o hardware é assim. Os tópicos ED 2.1 e ARQ 3.2 são o mesmo fato visto de dois lados.

cruzamento 2

Estrutura de Dados × Banco de Dados

O índice que faz uma consulta SQL voar é uma árvore de busca — a mesma do módulo 4 de Estrutura de Dados. Quem entendeu ED 4.2 não precisa decorar BD 4.1: já sabe por que a busca cai pela metade a cada passo.

cruzamento 3

Modelagem × Banco × Estatística

O processo mapeado em BPMN vira o esquema do banco (as entidades são os objetos que o fluxo movimenta), e as métricas do processo — lead time, taxa de erro — são exatamente o que Estatística ensina a ler sem se enganar.

Como ler qualquer uma das notas

O que há dentro de cada disciplina

Todas as cinco seguem a mesma anatomia. Aprender a ler uma é aprender a ler as cinco.

abertura

Do zero, sem jargão

A seção para quem não tem familiaridade nenhuma: o assunto explicado com analogias do mundo real antes de qualquer termo técnico. Se você é leigo, é por aqui que se entra.

a bússola

Promessa e ponte

Uma frase dizendo o que você sabe fazer ao terminar, e outra dizendo por que aquilo importa para a carreira — o critério para decidir onde gastar horas.

o plano

Currículo revisado

Cinco módulos com carga horária e sentido, reordenados para ensinar melhor do que a ordem tradicional. A ordem dos módulos é a ordem de estudo.

o controle

Checklist de tópicos

Cada tópico é uma caixa para marcar. O progresso fica salvo no seu navegador e aparece no anel lateral, no cartão da disciplina e no topo desta página.

o entendimento

Diagramas e exemplos

Todo mecanismo que a prosa não mostra vira desenho: o caminho de uma consulta, a árvore de um índice, a curva de um algoritmo, o fluxo de um processo.

a prática

Laboratório e recursos

A ferramenta concreta de cada disciplina, o primeiro passo para instalar, e a regra do laboratório — o ato que transforma leitura em capacidade. Mais os livros e vídeos que valem o tempo.

Uma advertência que vale para as cinco: ler não é estudar. Cada nota tem uma “regra do laboratório” — escrever a consulta, implementar a estrutura, desenhar o diagrama, calcular na planilha. É esse ato, e não a leitura, que move o checklist. Marque a caixa depois de fazer, nunca depois de ler.

← todas as disciplinas
DCEUNDB · ADS3º período

Banco de Dadosmodelar o negócio, conversar com os dados

68h assumidas 5 módulos 31 tópicos nunca viu banco de dados? comece aqui → PostgreSQL no laboratório veredito: aprofundar

A promessa: formado por esta disciplina, você modela os dados de um negócio real e conversa com eles em SQL fluente — projeta o esquema que não trai o cliente daqui a um ano e extrai a resposta que a pergunta de negócio pede.

Carga horária no padrão UNDB; ajustar quando o plano de ensino chegar.

Módulo zero · para quem nunca viu isso antes

Do zero, sem jargão

Se “tabela”, “chave” e “SQL” ainda soam como palavras de outra pessoa, comece aqui. Esta seção não é do currículo: é o chão que ele pressupõe. Quinze minutos de leitura e o resto da nota passa a fazer sentido.

1. O que é um banco de dados, afinal

É o lugar onde um sistema guarda o que precisa lembrar. Quando você se cadastra num site e volta no dia seguinte e ele ainda sabe seu nome, é um banco de dados fazendo isso. Todo aplicativo que você usa — o banco, o iFood, o Instagram — é, por baixo, uma pilha de telas conversando com um banco de dados.

A comparação honesta é com uma planilha: linhas, colunas, valores. Se você já usou Excel, já viu 60% da ideia. O banco de dados é o que a planilha vira quando ela precisa aguentar coisas que planilha não aguenta:

Planilha quebra quando…

Várias pessoas mexem ao mesmo tempo

Duas pessoas editando a mesma linha, e uma sobrescreve a outra sem avisar. O banco foi feito para centenas de escritas simultâneas sem que ninguém perca trabalho.

Planilha quebra quando…

Alguém digita o que não devia

Na planilha nada impede um preço negativo, um email repetido ou um pedido sem cliente. O banco recusa — você escreve as regras uma vez e ele passa a defendê-las.

Planilha quebra quando…

São milhões de linhas e perguntas cruzadas

“Quanto cada cliente do Maranhão gastou em julho, por produto?” Na planilha isso é uma tarde de trabalho manual. No banco é uma pergunta escrita em cinco linhas, que responde em milissegundos.

2. A anatomia: tabela, linha, coluna, chave

Quase todo o vocabulário do semestre está nesta única imagem. Vale demorar nela.

TABELA cliente id nome email cidade 1 Ana Lopes ana@mail.com São Luís 2 Bruno Sá bruno@mail.com Imperatriz 3 Célia Reis celia@mail.com São Luís 4 Davi Melo davi@mail.com Caxias coluna — um campo em toda linha linha (ou registro) um cliente inteiro chave primária identifica a linha e nunca se repete célula — um valor, e só um
Tabela, linha, coluna, célula, chave. É este o vocabulário — e ele é o mesmo em qualquer banco do mundo. A única palavra que não vem da planilha é chave primária: o identificador que garante que “Ana Lopes” não vire duas pessoas diferentes se alguém a cadastrar de novo.

3. Por que não uma tabela só

A pergunta natural de quem vem da planilha: se dá para colocar tudo numa aba só, por que dividir? Porque informação repetida sempre acaba divergindo. Se o telefone da Ana está copiado em cada um dos 40 pedidos dela, mudar o telefone significa acertar 40 lugares — e bastam 39 para o banco passar a mentir.

A solução é guardar cada coisa uma vez e ligar as tabelas por um número. O pedido não guarda “Ana Lopes, São Luís, ana@mail.com”; guarda apenas cliente_id = 1 — um endereço que aponta para a linha da Ana. Esse número emprestado é a chave estrangeira, e é literalmente tudo que existe por trás da palavra “relacional”.

Se você levar uma só ideia desta seção, leve esta: um banco de dados relacional é um conjunto de tabelas que se apontam por números. Modelar é decidir quais tabelas existem; consultar é seguir esses apontamentos para juntar de volta o que foi separado.

4. Como se conversa com um banco: SQL

Você não clica no banco — você escreve uma frase para ele, em SQL. E SQL foi desenhada nos anos 70 para parecer inglês, o que a torna surpreendentemente legível: cada linha da consulta é um pedaço da frase.

O que se escreveO que isso diz, em português
SELECT nome, email“me mostre o nome e o email…”
FROM cliente“…da tabela de clientes…”
WHERE cidade = 'São Luís'“…mas só de quem é de São Luís…”
ORDER BY nome“…em ordem alfabética…”
LIMIT 10“…e me traga só os dez primeiros.”

Junte as cinco linhas e você tem uma consulta de verdade, do tipo que roda em produção. É este o tamanho da coisa: o módulo 1 inteiro são variações e combinações dessa frase.

5. Quem é quem — os nomes que confundem no começo

a língua

SQL

O idioma em que se fazem pedidos ao banco. Não é um programa: é uma linguagem, e quase a mesma em todos os bancos relacionais.

o programa

PostgreSQL, MySQL, SQLite

Os SGBDs — os programas que efetivamente guardam os dados e entendem SQL. Escolher um é como escolher entre Word e Google Docs: muda a ferramenta, não o idioma.

a janela

Beekeeper, DBeaver, pgAdmin

Clientes gráficos: a tela onde você digita SQL e vê o resultado em forma de tabela. Não guardam nada — são só a vitrine do banco.

o desenho

Esquema e modelo ER

O mapa de quais tabelas existem e como se ligam. O modelo ER é esse mapa desenhado no papel, antes de existir banco nenhum — é o assunto do módulo 2.

Pronto para o resto da nota. Daqui em diante, quando aparecer “junção”, leia “juntar duas tabelas seguindo o número que uma guarda da outra”; quando aparecer “normalizar”, leia “separar em tabelas para não repetir informação”. Todo o resto são detalhes destas duas frases.

Por que esta disciplina importa

Ponte com a trajetória

SQL é inegociável na carreira dev (todo posting pede) e é a espinha de qualquer sistema que você construir para cliente — site com conteúdo, dashboard, automação. Modelagem de dados é irmã da sua arquitetura de informação: os dois ofícios são “dar forma estruturada ao que o negócio significa”.

Veredito: aprofundar além do teto do curso — junto com Estrutura de Dados, a dupla mais valiosa do semestre.

68 horas, cinco módulos

Currículo revisado

Nota de ordem: SQL de leitura vem antes de modelagem de propósito — consultar dados dá fome de entender como eles são desenhados. Cursos costumam fazer o inverso e perder o aluno na teoria.

Mód.HorasTemaSentido
118hSQL de leiturafazer perguntas a dados e obter respostas — a habilidade diária
214hModelagem: do negócio ao esquematraduzir um negócio real em entidades e relações
312hSQL de escrita e desenho físicocriar, alimentar e alterar esquemas com segurança
412hO banco por dentroíndices, transações e por que consultas ficam lentas
512hCapstone: o banco da práticamodelar e construir o banco de um negócio seu, de ponta a ponta

Como usar: siga o checklist na ordem dos módulos — a ordem deles já é a ordem de estudo. O capstone pode começar cedo: a partir do módulo 2 você já modela o domínio; cada módulo seguinte adiciona uma camada ao mesmo banco. Se algum termo da tabela acima ainda for opaco, a seção “Do zero” cobre o vocabulário que estes cinco módulos pressupõem.

Módulo 1 · 18h

SQL de leitura

Fazer perguntas a dados e obter respostas. É o que você usa todo dia — e o que toda vaga cobra.

Checklist

8 tópicos

0/8
COMO VOCÊ ESCREVE COMO O BANCO EXECUTA SELECT ... FROM ... WHERE ... GROUP BY ... HAVING ... ORDER BY ... LIMIT ... 1 FROM · JOIN 2 WHERE 3 GROUP BY 4 HAVING 5 SELECT 6 ORDER BY 7 LIMIT
A consulta não roda na ordem em que é lida. FROM monta o conjunto de linhas, WHERE corta, GROUP BY resume, HAVING corta os grupos — e só então SELECT escolhe as colunas. Daí duas regras que parecem arbitrárias e não são: WHERE não enxerga apelido criado no SELECT, e filtro de agregado (SUM(...) > 1000) vai no HAVING, nunca no WHERE.
CLIENTES PEDIDOS id · nome 1 · Ana 2 · Bruno 3 · Célia num · cliente_id 1001 · 1 1002 · 1 1003 · 3 Bruno não casa ON clientes.id = pedidos.cliente_id INNER JOIN → 3 LINHAS nome · num Ana · 1001 Ana · 1002 Célia · 1003 Bruno desaparece do resultado. LEFT JOIN → 4 LINHAS nome · num Ana · 1001 Ana · 1002 Célia · 1003 Bruno · NULL
A junção é uma pergunta sobre correspondência. Ana casa duas vezes (duas linhas no resultado — junção multiplica, não “cola lado a lado”). Bruno não casa: o INNER o descarta, o LEFT o mantém e preenche com NULL. É por isso que “clientes que nunca compraram” se escreve LEFT JOIN … WHERE pedidos.num IS NULL.

1.8 na prática — a pergunta de negócio “quais clientes não compram há 90 dias?” traduzida:

-- um cliente por linha, com a data da última compra
SELECT  c.nome, MAX(p.data) AS ultima_compra
FROM    clientes c
LEFT JOIN pedidos p ON p.cliente_id = c.id
GROUP BY c.id, c.nome
HAVING  MAX(p.data) < CURRENT_DATE - INTERVAL '90 days'
     OR MAX(p.data) IS NULL   -- nunca comprou
ORDER BY ultima_compra NULLS FIRST;
Módulo 2 · 14h

Modelagem: do negócio ao esquema

Traduzir um negócio real em entidades e relações. É aqui que se decide se o banco vai trair o cliente daqui a um ano.

Checklist

7 tópicos

0/7
cliente id PK nome email UNIQUE criado_em proposta id PK cliente_id FK valor status engajamento id PK proposta_id FK UNIQUE inicio fim engajamento_servico engajamento_id FK servico_id FK PK composta pelas duas servico id PK nome preco_hora 1 : N tem 1 : 1 vira 1 : N N : 1 N : M engajamento × servico é N : M — por isso existe a terceira tabela
A cardinalidade não é rótulo: é uma constraint. O 1:N entre cliente e proposta é a FK em proposta. O 1:1 é a mesma FK mais um UNIQUE — sem ele, nada impede duas propostas virarem o mesmo engajamento. E o N:M não tem como existir entre duas tabelas: precisa da terceira, cuja chave primária é o par.

2.4 — Normalização, em uma planilha que dói

O ponto de partida de quase todo iniciante: uma tabela só, larga, que parece prática e mente três vezes.

pedido_idclientecliente_cidadeufitens
1001Ana LopesSão LuísMAteclado, mouse, hub
1002Ana LopezSão LuísMAmonitor
1003Bruno SáSao LuisMAcadeira, apoio
1FN — atomicidade

“teclado, mouse, hub” em uma célula

Uma célula, um valor. Enquanto três produtos moram numa string, não há como contar itens, somar valor nem filtrar por produto — só truque de texto. Correção: uma linha por item, em pedido_item.

2FN — dependência parcial

“Ana Lopes” repetido a cada pedido

O nome do cliente depende do cliente, não do pedido. Repetido, ele diverge: Ana Lopes e Ana Lopez viram duas pessoas para o banco. Correção: o cliente vira tabela; o pedido guarda só a FK.

3FN — dependência transitiva

cidade e UF penduradas no pedido

A cidade depende do cliente, que depende do pedido — dois saltos. São Luís e Sao Luis convivem, e corrigir a cidade de alguém exige varrer todos os pedidos. Correção: cidade mora junto do cliente, em um só lugar.

Uma frase para levar: normalizar é garantir que cada fato viva em um só lugar. Toda anomalia de banco iniciante — duplicata que diverge, exclusão que apaga o que não devia, atualização que esquece uma linha — é um fato morando em dois lugares.

2.5 — E quando desnormalizar? Relatório lê e não escreve: se o total do pedido já está calculado numa coluna, ninguém corre risco de contradizê-lo — não há segunda escrita. Sistema transacional escreve o tempo todo, e cada cópia é uma chance de divergir. Daí a regra: relatórios perdoam o que sistemas não perdoam.

Módulo 3 · 12h

SQL de escrita e desenho físico

Criar, alimentar e alterar esquemas com segurança — inclusive contra você mesmo às onze da noite.

Checklist

5 tópicos

0/5
3.1 — cada constraint é uma regra do negócio
CREATE TABLE proposta (
  id          bigserial   PRIMARY KEY,
  cliente_id  bigint      NOT NULL
              REFERENCES cliente(id),
  valor       numeric(12,2) NOT NULL
              CHECK (valor > 0),
  status      text        NOT NULL
              DEFAULT 'rascunho'
              CHECK (status IN ('rascunho',
                     'enviada','aceita','recusada')),
  criada_em   timestamptz NOT NULL
              DEFAULT now()
);

Cada linha carrega uma frase que o cliente diria em voz alta: “proposta é sempre de alguém”, “não existe proposta de valor zero”, “status é um destes quatro”. Constraint é regra de negócio que o banco recusa violar — não confie na aplicação para isso.

3.2 — o hábito que salva a noite
-- 1. escreva primeiro como SELECT
SELECT * FROM proposta
WHERE  status = 'enviada'
  AND  criada_em < CURRENT_DATE - 30;

-- 2. confira a contagem. só então:
BEGIN;
UPDATE proposta SET status = 'recusada'
WHERE  status = 'enviada'
  AND  criada_em < CURRENT_DATE - 30;
-- olhe o número de linhas afetadas
COMMIT;  -- ou ROLLBACK, se assustou

UPDATE sem WHERE atinge a tabela inteira, em silêncio e sem confirmação. Escrever o WHERE antes do SET, rodar como SELECT primeiro e abrir transação são três hábitos baratos que evitam o desastre caro.

3.4 — a view como móvel da casa: quando a mesma consulta é reescrita pela terceira vez, ela deixou de ser pergunta e virou parte da estrutura. CREATE VIEW lhe dá um nome, e a definição passa a viver num lugar só — a mesma economia da normalização, aplicada a consultas.

Módulo 4 · 12h

O banco por dentro

Índices, transações e por que consultas ficam lentas. O módulo que separa quem usa banco de quem entende banco.

Checklist

6 tópicos

0/6
SEM ÍNDICE · SEQ SCAN 1.000.000 linhas lidas custo cresce com a tabela COM ÍNDICE · ÁRVORE B A–J | K–R | S–Z A–D | E–J K–N | O–R S–Z ana@… maria@… → linha zeca@… 3 leituras — mesmo com 1 milhão de linhas preço: espaço em disco + toda escrita mantém a árvore
Índice é o índice remissivo do livro. Sem ele, achar maria@… exige ler a tabela inteira; com ele, o banco desce a árvore e chega em três saltos — e o número de saltos quase não cresce quando a tabela cresce. A conta tem outro lado: o índice ocupa espaço e toda escrita passa a manter a árvore. Por isso se indexa o que se busca, não tudo. EXPLAIN é onde você lê qual dos dois caminhos o banco escolheu — Seq Scan ou Index Scan.
TRANSFERÊNCIA DE R$ 100 A: 500 B: 200 estado inicial BEGIN · ninguém de fora vê o meio A: 500 → 400 B: 200 → 300 A: 400 B: 300 COMMIT erro no meio → ROLLBACK devolve tudo ao estado inicial O QUE O ACID GARANTE Atomicidade tudo ou nada: não existe débito sem crédito Consistência as constraints valem antes e depois Isolamento ninguém lê o meio de outra transação Durabilidade depois do COMMIT, nem queda de energia desfaz
A transação existe por causa do instante entre os dois UPDATE. Nele o dinheiro não está em lugar nenhum — e é exatamente esse estado que a atomicidade proíbe de sobreviver. O isolamento é o mesmo problema visto de fora: enquanto A e B estão no meio da transferência, outra sessão não pode somar os saldos e achar que faltam R$ 100.
4.5 · noção honesta

O que o NoSQL troca

Documento e chave-valor compram flexibilidade de forma e escala horizontal vendendo junções, constraints e, muitas vezes, garantias transacionais. Para um catálogo de formas irregulares ou um cache, é bom negócio. Para propostas, engajamentos e pagamentos que precisam bater, você está vendendo justamente o que precisa.

4.6 · dever de casa do autônomo

Backup que você já restaurou

pg_dump agendado é metade do serviço. A outra metade é pg_restore num banco vazio, feito ao menos uma vez — backup nunca testado é hipótese, não garantia. Um cliente perdoa lentidão; não perdoa perda de dado.

Módulo 5 · 12h

Capstone: o banco da prática

Modelar e construir o banco de um negócio seu, de ponta a ponta — a peça que fica no portfólio e um dia vira o CRM real.

Checklist

5 tópicos

0/5
MÓD. 2Domínio e ERentidades, relações e cardinalidades do negócio no papel
MÓD. 2Esquema normalizadoER traduzido em tabelas, chaves e 3FN
MÓD. 3ConstruçãoCREATE TABLE com constraints e carga de dados realistas
MÓD. 1As 10 perguntasas consultas que o dono do negócio realmente faria
MÓD. 4Ajuste e publicaçãoíndices onde o EXPLAIN pedir, README e GitHub

O capstone não começa no módulo 5 — ele termina nele. Cada módulo anterior adiciona uma camada ao mesmo banco, e o que o módulo 5 faz é fechar, documentar e publicar.

18 termos, em ordem de aparição

Glossário

Os termos que esta nota (e o semestre) usam como se você já os conhecesse. Ler de cima a baixo é uma miniatura do curso.

18 termos
TermoO que é, em uma linha
Banco de dados relacionalUm sistema que guarda dados em tabelas que se referenciam entre si — o modelo dominante há 50 anos.
SGBDO software que administra o banco (PostgreSQL, MySQL…) — o banco é o acervo; o SGBD é o bibliotecário.
TabelaO contêiner básico: linhas (registros — “um cliente”) e colunas (campos — “nome”, “email”).
SQLA linguagem padrão para conversar com bancos relacionais — tanto para perguntar quanto para criar e alterar.
Consulta (query)Uma pergunta escrita em SQL: “quais clientes compraram este ano?” vira um SELECT.
Junção (JOIN)A operação que combina duas tabelas pelas suas relações — “clientes com seus pedidos” — o coração do SQL.
NULLA ausência de valor numa célula — nem zero nem vazio: desconhecido — e fonte clássica de resultados surpreendentes.
AgregaçãoResumir muitas linhas em um número: soma, média, contagem — a base de qualquer relatório.
Modelo ERO diagrama entidade-relacionamento: o desenho de o que existe no negócio (entidades) e como se conecta, feito antes de criar tabelas.
Chave primáriaA coluna que identifica cada linha unicamente (o “CPF” da tabela).
Chave estrangeiraUma coluna que aponta para a chave primária de outra tabela — é o que materializa uma relação.
NormalizaçãoO método de organizar tabelas para que cada fato viva em um só lugar — sem duplicação, sem contradição.
Esquema (schema)O desenho completo do banco: quais tabelas, colunas, tipos e relações existem.
Migração (migration)Uma alteração de esquema registrada como script versionado — como o banco evolui sem caos.
ÍndiceEstrutura auxiliar que acelera buscas numa coluna (como o índice remissivo de um livro) — em troca de espaço e escrita mais lenta.
TransaçãoUm grupo de operações que ou acontece inteiro ou não acontece — o que impede débito sem crédito numa transferência.
ACIDAs quatro garantias das transações (atomicidade, consistência, isolamento, durabilidade) — o contrato de confiabilidade do banco.
NoSQLA família de bancos não-relacionais (documentos, chave-valor) — troca as garantias relacionais por flexibilidade/escala em casos específicos.
Onde o estudo encosta em dado real

Laboratório

A ferramenta

PostgreSQL

O SGBD open-source mais respeitado do mercado; um programa que roda na sua máquina e guarda bancos de verdade. Acompanhado de um cliente gráfico — Beekeeper Studio ou DBeaver, ambos gratuitos: a janela onde você digita SQL e vê os resultados em tabela.

Para começar

Três instalações e um banco pronto

Instalar o Postgres (brew install postgresql no Mac, ou o instalador oficial), instalar o Beekeeper, conectar em localhost — e importar um banco de exemplo pronto (o clássico Northwind para Postgres: uma empresa fictícia com clientes, produtos e pedidos) para ter dados reais para interrogar desde o primeiro dia.

O ato recorrente — a regra do laboratório: todo tópico estudado termina com SQL digitado por você contra um banco real. No módulo 1, cada conceito vira 3–5 consultas suas contra o Northwind — não copiadas: formuladas a partir de uma pergunta de negócio que você inventa. Do módulo 2 em diante, o alvo muda para o banco da prática DxE que você mesmo vai modelar e construir; cada módulo adiciona uma camada ao mesmo banco, até ele ser o capstone completo.

O que ler, ver e praticar

Recursos

RecursoServe a
Livro principal: Learning SQL (Alan Beaulieu, O’Reilly)Mód. 134
Livro de apoio: Database Design for Mere Mortals (Michael Hernandez)Mód. 25 modelagem como ofício
Curso em vídeo: CS50 SQL (Harvard/Malan, gratuito)Mód. 134 na ordem
Interativo: SQLBolt (sqlbolt.com)Mód. 1 os primeiros 30 minutos de cada tópico
Apêndice

Plano oficial

Plano de ensino ainda não disponível — colar aqui quando chegar e mapear: tópico oficial → código revisado; o que cai em prova; o que o plano omite.

Triagem antecipada

Aprofundar

Risco previsível do curso: ficar longo demais em álgebra relacional formal e diagramação, e curto demais em SQL fluente — se acontecer, os módulos 1 e 3 daqui são o antídoto. Se o curso usar MySQL, siga o curso na prova e o PostgreSQL no laboratório; a diferença é pequena e a tradução é instrutiva. O curso quase certamente ensinará modelagem antes de SQL — sem problema: acompanhe a prova na ordem deles, estude na ordem daqui.

Alavanca de projeto

O trabalho da disciplina vira o capstone

O trabalho da disciplina vira o capstone 5.x apontado para a prática DxE — o banco que um dia vira o CRM/pipeline real do seu negócio. Cenário inventado, nunca.

← todas as disciplinas
DCEUNDB · ADS3º período

Estrutura de Dadosescolher a forma certa de guardar — e prever o preço disso

68h assumidas 5 módulos 30 tópicos nunca ouviu falar de Big-O? comece aqui → lista de exercícios resolvida → TypeScript no laboratório veredito: aprofundar

A promessa: formado por esta disciplina, você deixa de ser alguém que usa arrays e objetos por hábito e passa a ser alguém que escolhe a estrutura certa para cada problema e prevê como o código se comporta quando os dados crescem — a diferença entre usar uma biblioteca e entender o que ela faz.

Carga horária no padrão UNDB; ajustar quando o plano de ensino chegar.

Prova chegando? A lista de exercícios do professor está destrinchada em página própria: as 12 questões com dica, passo a passo e solução comentada, três simuladores (pilha, fila e lista encadeada) e dois quizzes para treinar sem consultar.

Módulo zero · para quem nunca viu isso antes

Do zero, sem jargão

Esta é a disciplina com o nome mais intimidante do semestre e o conteúdo mais concreto. Se “Big-O”, “lista ligada” e “árvore binária” ainda parecem coisa de outro planeta, quinze minutos aqui resolvem — o assunto inteiro cabe em duas ideias.

1. Guardar não é só guardar

Imagine que você precisa organizar mil fichas de clientes. Você pode empilhá-las numa caixa — rápido de guardar, terrível de achar. Pode alinhá-las numa estante numerada — achar a de número 738 é instantâneo, mas inserir uma no meio obriga a empurrar todas as outras. Pode organizá-las por ordem alfabética — achar “Silva” é rápido porque você abre no meio e descarta metade.

Pronto: você acabou de inventar array, lista e árvore de busca. Uma estrutura de dados é uma decisão sobre qual operação você quer que seja barata — e toda escolha torna outra coisa cara. Não existe estrutura melhor; existe estrutura certa para o que você mais faz.

2. A segunda ideia: o que acontece quando cresce

Um código que roda em 0,2 segundo com 100 clientes pode levar seis horas com 100 mil. Não porque a máquina piorou — porque o método escolhido cresce mal. A disciplina chama isso de complexidade, e a notação para escrever isso se chama Big-O. É só isso: uma forma de dizer “se os dados dobrarem, o tempo dobra / quadruplica / quase não muda”.

As duas frases que a disciplina inteira desdobra: (1) cada estrutura torna barata uma operação e cara outra; (2) o que importa não é quanto o código demora hoje, mas como esse tempo cresce quando os dados crescem.

3. As seis formas que você vai encontrar a vida inteira

Existem centenas de estruturas. Estas seis cobrem quase tudo que um dev usa — e você já usa quase todas sem saber o nome.

ARRAY A B C D 0 1 2 3 posição numerada: pegar o 3º é instantâneo LISTA LIGADA A B C cada um sabe onde está o próximo: inserir é barato, achar é caminhar PILHA primeiro segundo último só o topo o último a entrar é o primeiro a sair FILA A B C entra atrás, sai na frente — como fila de banco TABELA HASH "ana" f( ) a chave vira endereço por uma conta ÁRVORE começa e se ramifica — o HTML desta página é uma árvore
Você já usa todas. O array do JavaScript é a primeira; o histórico do Ctrl+Z é uma pilha; a fila de mensagens de um app é uma fila; Map e Object são tabelas hash; o HTML da página aberta agora é uma árvore. A disciplina não apresenta coisas novas — ela dá nome, preço e regra de uso ao que você já manuseia no escuro.

4. E “algoritmo”?

Uma receita: uma sequência finita de passos que resolve um problema. Toda função que você escreve é um algoritmo. Ordenar uma lista, achar o maior número, montar uma rota — cada um tem várias receitas possíveis, e elas custam preços diferentes. Metade da disciplina é conhecer as estruturas; a outra metade é conhecer as receitas clássicas e o preço de cada uma.

Um aviso de tradução. O curso provavelmente ensinará tudo isto em C ou Java. Você escreve TypeScript. Não é problema — é vantagem: traduzir cada conceito para o seu stack força o entendimento real, porque não dá para traduzir o que não se entendeu. É o que o laboratório desta nota manda fazer.

Por que esta disciplina importa

Ponte com a trajetória

Esta é a disciplina mais estruturante do semestre para a carreira dev. Todo código JS/TS que você escreve já é estrutura de dados (arrays, objects, Maps, o DOM é uma árvore, o roteamento é um grafo); entrevistas técnicas são majoritariamente isto; e a intuição de complexidade é o que separa sistemas que escalam de sistemas que morrem com o cliente dentro.

Veredito: aprofundar além do teto do curso — junto com Banco de Dados, a dupla mais valiosa do semestre.

68 horas, cinco módulos

Currículo revisado

Mód.HorasTemaSentido
110hComplexidade e o custo das coisasler o preço de um algoritmo antes de pagá-lo
216hEstruturas lineareso que arrays e listas realmente são por baixo do JavaScript
314hHash, pilhas e filasas estruturas que resolvem 80% dos problemas reais
416hÁrvores e grafosas estruturas de tudo que é hierárquico ou conectado — DOM, rotas, dependências
512hAlgoritmos clássicos + capstoneordenar, buscar, e implementar a caixa de ferramentas inteira em TypeScript

Como usar: siga o checklist na ordem dos módulos — a ordem deles já é a ordem de estudo. Os recursos ao final dizem com o quê estudar cada módulo.

Módulo 1 · 10h

Complexidade e o custo das coisas

Ler o preço de um algoritmo antes de pagá-lo. Dez horas que mudam como você olha para qualquer código pelo resto da vida.

Checklist

5 tópicos

0/5
TAMANHO DOS DADOS (n) → OPERAÇÕES ↑ O(n²) o que mata sistemas O(n log n) o preço de ordenar O(n) olhar cada item O(log n) descartar metade O(1) custo fixo
A forma da curva é a única coisa que importa. Big-O ignora constantes e detalhes de máquina porque, quando n cresce, a forma vence tudo: um O(n²) escrito por um gênio em C perde para um O(n log n) escrito por um iniciante em JavaScript, desde que os dados sejam grandes o bastante. Perceba onde as curvas se cruzam — antes desse ponto, o algoritmo “pior” pode ser o mais rápido; é por isso que a análise fala de crescimento, não de velocidade.

O gráfico convence os olhos; a tabela convence a intuição. Contagem aproximada de operações:

Complexidaden = 10n = 1.000n = 1.000.000Exemplo típico
O(1)111acessar arr[500], ler map.get(k)
O(log n)31020busca binária, descer uma árvore de busca
O(n)101.0001.000.000find, includes, somar tudo
O(n log n)3310.00020.000.000sort — o melhor preço possível para ordenar
O(n²)1001.000.0001.000.000.000.000dois laços aninhados sobre a mesma lista

Leia a última célula em voz alta. Um trilhão de operações é ordem de horas de processamento — para uma tarefa que o O(n log n) resolve em segundos. Quase todo “o sistema travou quando a base cresceu” é um laço dentro de outro laço que ninguém notou enquanto a base era pequena.

Módulo 2 · 16h

Estruturas lineares

O que arrays e listas realmente são por baixo do JavaScript — e por que a resposta muda as suas escolhas.

Checklist

6 tópicos

0/6
ARRAY · TUDO COLADO NA MEMÓRIA A B C D E 1000 1004 1008 1012 1016 achar o 4º elemento é uma conta: 1000 + 3 × 4 = 1012 — um passo, sempre inserir no meio empurra todo o resto LISTA LIGADA · ESPALHADA, LIGADA POR ENDEREÇO A B C D inserir entre B e C = trocar duas setas achar o 4º = percorrer os três antes
A diferença inteira está no endereço. No array, a posição é uma conta aritmética sobre o endereço inicial — por isso o acesso não depende do tamanho. Na lista ligada não há conta: cada nó só conhece o vizinho, então chegar ao quarto exige passar pelos três primeiros. Em compensação, inserir no meio do array desloca tudo o que vem depois, enquanto na lista custa duas atribuições. Em JavaScript, na prática, o array quase sempre ganha — o custo do deslocamento é pago por memória contígua e cache (o assunto do módulo 3 de Arquitetura), enquanto cada nó espalhado é um salto que o processador não consegue prever.
Módulo 3 · 14h

Hash, pilhas e filas

As estruturas que resolvem 80% dos problemas reais — e as três que mais aparecem em entrevista.

Checklist

6 tópicos

0/6
PILHA · LIFO 1º a entrar 3º — o topo push pop entra e sai pela mesma ponta o Ctrl+Z do seu editor é isto — e a pilha de chamadas do JS também FILA · FIFO entra sai entra por uma ponta, sai pela outra fila de tarefas, fila de impressão, e a busca em largura de um grafo
Duas regras de porta, e nada mais. Pilha e fila não são estruturas novas — são restrições impostas sobre uma lista: só se mexe nas pontas, e a escolha de qual ponta define tudo. A pilha lembra a ordem inversa dos acontecimentos (por isso serve para desfazer e para voltar de uma função); a fila preserva a ordem de chegada (por isso serve para trabalho pendente e para explorar um grafo camada por camada).
CHAVE FUNÇÃO DE HASH BALDES (um array comum) "ana" "bruno" "celia" h(chave) % 6 texto → número → posição 0 · vazio 1 · vazio 2 · "ana" 3 · vazio 4 · "bruno" → "celia" 5 · vazio colisão: duas chaves, um balde resolvida com uma lista no balde A busca não percorre nada: calcula o balde e olha. Por isso é O(1). Se todas as chaves caírem no mesmo balde, vira uma lista — e O(n).
É por isso que Map e Object parecem mágica. A chave não é procurada: é convertida em endereço por uma conta. O preço da mágica são as colisões — duas chaves diferentes que caem no mesmo balde — e é lidar com elas que ocupa todo o design de uma tabela hash. O O(1) é uma média com boa função de hash e espaço sobrando, não uma garantia.
Módulo 4 · 16h

Árvores e grafos

As estruturas de tudo que é hierárquico ou conectado — o DOM, as rotas do app, as dependências do package.json.

Checklist

8 tópicos

0/8
EQUILIBRADA · PROCURANDO O 7 8 3 12 1 6 10 14 7 7 < 8 → esquerda 7 > 3 → direita 7 > 6 → direita 3 passos entre 8 nós dobrar os nós custa 1 passo a mais DEGENERADA · INSERIDA EM ORDEM 1 3 6 7 8 virou uma lista: 5 passos entre 5 nós a promessa depende do equilíbrio — daí existirem AVL e rubro-negra
A árvore de busca é o “abrir o dicionário no meio” virado estrutura. Cada comparação joga fora metade do que sobrou: é isso, e só isso, que o O(log n) significa. Mas a mágica é condicional: inserir dados já ordenados produz uma corrente, não uma árvore, e o custo volta a ser O(n). É o mesmo mecanismo do índice de banco de dados — a árvore B do módulo 4 de Banco de Dados é uma prima gorda desta, feita para caber em blocos de disco.
4.6–4.7 · grafo

Quando a hierarquia vira rede

Árvore é um grafo com regra: cada nó tem um pai só, e não há ciclo. Tire a regra e você tem um grafo — o mapa de ruas, a rede de amigos, as dependências entre pacotes (onde um ciclo significa exatamente aquele erro de importação circular).

4.7 · BFS e DFS

Duas maneiras de explorar

Em largura (BFS) visita camada por camada e usa uma fila — é o que encontra o caminho mais curto. Em profundidade (DFS) vai fundo até o fim e volta, usando uma pilha (ou recursão) — é o que detecta ciclos. Note que as estruturas do módulo 3 reaparecem aqui como motor: não é coincidência, é o desenho do curso.

Módulo 5 · 12h

Algoritmos clássicos + capstone

Ordenar, buscar, e implementar a caixa de ferramentas inteira em TypeScript — o repositório que vira peça de portfólio.

Checklist

5 tópicos

0/5
EstruturaAcessarBuscarInserirUse quando…
ArrayO(1)O(n)O(n)a ordem importa e você acessa por posição — o padrão
Lista ligadaO(n)O(n)O(1)insere e remove muito nas pontas, e nunca acessa por índice
Pilha / FilaO(1)a ordem de saída é a regra do problema (desfazer, tarefas, BFS)
Tabela hashO(1)*O(1)*você busca por uma chave e não se importa com ordem
Árvore de buscaO(log n)O(log n)O(log n)precisa de busca rápida e de percorrer em ordem

* média, com boa função de hash e sem excesso de colisões. Esta tabela é o resumo executivo da disciplina — se você souber reconstruí-la de cabeça e justificar cada célula, os 30 tópicos foram aprendidos.

MÓD. 2LinkedList.tslista simples e duplamente ligada, com testes
MÓD. 3Stack · Queue · HashTableas três que resolvem o dia a dia
MÓD. 4BST · Graphárvore de busca e grafo com BFS e DFS
MÓD. 5sorts & searchmerge, quick, busca binária — comparados por medição
MÓD. 5README e publicaçãocada estrutura com sua tabela de complexidade
18 termos, em ordem de aparição

Glossário

Os termos que esta nota (e o semestre) usam como se você já os conhecesse. Ler de cima a baixo é uma miniatura do curso.

18 termos
TermoO que é, em uma linha
Estrutura de dadosUma forma organizada de guardar dados na memória para que certas operações (buscar, inserir, remover) fiquem baratas.
AlgoritmoUma receita de passos finitos que resolve um problema — toda função que você escreve é um.
ComplexidadeO quanto um algoritmo custa (em tempo ou memória) à medida que os dados crescem — não quanto demora hoje, mas como escala.
Big-OA notação dessa escala: O(n) = custo cresce junto com os dados; O(n²) = cresce ao quadrado; O(1) = não cresce.
ArrayA estrutura mais básica: elementos lado a lado na memória, acessados por posição (índice).
Ponteiro / referênciaUm valor que não é o dado, mas o endereço de onde o dado está — o que permite estruturas ligadas.
A unidade das estruturas ligadas: um pacotinho com o dado + referência(s) para outros nós.
Lista ligadaCorrente de nós, cada um apontando para o próximo — cresce fácil, mas não tem acesso direto por posição.
Pilha (stack)Estrutura onde só se mexe no topo: o último a entrar é o primeiro a sair (como pilha de pratos).
Fila (queue)O oposto: o primeiro a entrar é o primeiro a sair (como fila de banco).
Tabela hashEstrutura que transforma uma chave (“nome”) num endereço direto via uma função matemática — busca quase instantânea; é o que existe por trás de Map e Object no JS.
ColisãoQuando duas chaves diferentes caem no mesmo endereço da tabela hash — todo o design de hash é lidar com isso.
ÁrvoreEstrutura hierárquica: um nó raiz com filhos, que têm filhos — o DOM de uma página é uma árvore.
BST (árvore binária de busca)Árvore com regra de ordem (menores à esquerda, maiores à direita) que torna a busca logarítmica — cada passo descarta metade.
Percurso (traversal)Qualquer método sistemático de visitar todos os nós de uma árvore ou grafo.
GrafoRede de nós (vértices) conectados por ligações (arestas) — mapas, redes sociais, dependências entre pacotes.
BFS / DFSAs duas formas canônicas de explorar um grafo: em largura (camada por camada) ou em profundidade (um caminho até o fim, depois volta).
RecursãoFunção que chama a si mesma para resolver versões menores do mesmo problema — a linguagem natural de árvores.
Onde o estudo vira capacidade

Laboratório

A ferramenta

TypeScript + Vitest

TypeScript rodando no VS Code, com Vitest — uma biblioteca que executa testes automáticos: você escreve “espero que buscar(5) devolva verdadeiro”, roda, e ela confirma ou acusa o erro.

Para começar

Um repositório e uma pasta por módulo

Um repositório novo (data-structures-ts), criado com npm create vite@latest — ou só npm init + npm i -D vitest typescript. Uma pasta por módulo.

O ato recorrente — a regra do laboratório: nenhuma estrutura é considerada estudada até existir implementada e testada por você. Estudou lista ligada → escreve LinkedList.ts + um teste que insere, remove e busca. Estudou hash → HashTable.ts. O ciclo é sempre: ler/assistir → implementar do zero (sem copiar) → testar → só então marcar o tópico no checklist. É esse ciclo que transforma leitura em capacidade — e o repositório resultante é o capstone 5.5, peça de portfólio.

O que ler, ver e praticar

Recursos

RecursoServe a
Livro principal: Entendendo Algoritmos (Aditya Bhargava, trad. do Grokking Algorithms)Mód. 1345 visual, direto, do tamanho certo
Livro de apoio: Learning JavaScript Data Structures and Algorithms (Loiane Groner — autora brasileira, exemplos em JS)Mód. 2–5 a implementação no seu stack
Vídeo: CS50 (Harvard/Malan), semanas de Data StructuresMód. 23 a memória vista de perto
Vídeo: série Estruturas de Dados do canal Programação Dinâmica (PT-BR)Mód. 2–4
Apêndice

Plano oficial

Plano de ensino ainda não disponível — colar aqui quando chegar e mapear: tópico oficial → código revisado; o que cai em prova; o que o plano omite.

Triagem antecipada

Ultrapassar o teto do curso

É das poucas disciplinas do período cujo conteúdo canônico é estável e universal; qualquer aula fraca é contornável com os recursos acima. Linguagem provável do curso: C ou Java — traduza cada conceito para TS por conta própria; a tradução é o aprendizado.

Alavanca de projeto

Todo trabalho vira commit do capstone

Qualquer trabalho ou seminário da disciplina vira desculpa para o repositório do capstone 5.5 — entregue à escola o recorte que ela pedir, mas construa no seu repositório, no seu stack, como peça de portfólio.

← Estrutura de Dados
TREINO PARA A PROVAProf. Dr. Giovanni Lucca

Lista de Exercíciosas 12 questões destrinchadas — conceito, passo a passo e treino

12 questões 5 partes 3 simuladores 2 quizzes as 5 ideias que resolvem tudo →

Como usar: em cada questão, tente antes de abrir a solução. Os botões liberam ajuda em três níveis — dica, passo a passo e código comentado. Abrir a solução direto dá a sensação de aprender sem o aprendizado; o esforço de tentar é o que fixa.

Se o tempo é curto, esta é a ordem

Plano de ataque

A lista tem 12 questões, mas não pesam igual. Esta é a ordem de maior retorno por minuto — e o que fazer se sobrar pouco tempo.

OrdemBlocoQuestõesPor que aqui
ComplexidadeQ1, Q2uma regra só resolve as duas — e ela reaparece nas questões 4 e 12
Pilha e filaQ8, Q9código curto, cai sempre, e é onde os simuladores desta página ajudam mais
Lista encadeadaQ10, Q11o assunto mais novo — e o que mais confunde quem só decorou
Tupla, set, dictQ5, Q6, Q7quase todo o trabalho é escolher a estrutura certa; o código é pequeno
Vetores e matrizesQ3, Q4o mesmo padrão de laço que você já treinou nos blocos anteriores
ComparativoQ12é a colinha — depois de fazer as 11 anteriores, você a escreve de cabeça
0%
0/12 questões dominadas

Marque “consigo fazer sozinho” em cada questão só depois de escrever a resposta sem olhar. O número aqui em cima é o seu termômetro real para amanhã.

Domine isto e as 12 caem juntas

As cinco ideias que a lista inteira cobra

As 12 questões são cinco ideias disfarçadas. Quem entende as cinco resolve qualquer variação que o professor invente — inclusive as que não estão nesta lista.

LAÇOS EM SEQUÊNCIA · SOMAM for i in range(n): print(i) n passos for j in range(n): print(j) + n passos n + n = 2n → O(n) a constante 2 não muda a forma da curva: dobrar os dados dobra o tempo, e ponto LAÇOS ANINHADOS · MULTIPLICAM for i in ...: for j in ...: print(...) n × n = n² → O(n²) para cada uma das n voltas de fora, o de dentro dá n voltas inteiras
Esta imagem responde as questões 1, 2 e 4 — e metade do quiz. A pergunta que decide tudo é uma só: “o segundo laço roda depois do primeiro, ou dentro dele?” Depois → soma. Dentro → multiplica. Não existe terceiro caso.
ideia 2

Uma passada, acumulando

Questões 3, 4 e 5 são o mesmo exercício com roupas diferentes: crie os acumuladores antes do laço, percorra uma vez atualizando todos, devolva no fim. Quem enxerga o padrão não precisa decorar nenhuma delas.

ideia 3

A estrutura vem do acesso

Não escolha pela “cara” do dado, escolha por como você vai buscá-lo: por posição → list; registro fixo que não muda → tuple; pertence ou não, sem repetir → set; busca por uma chave → dict.

ideia 4

Pilha e fila: a mesma lista, outra porta

Nenhuma das duas é estrutura nova — são restrições sobre uma lista. Só o topo, e o último entra primeiro a sair: pilha (LIFO). Entra por uma ponta e sai pela outra: fila (FIFO). A regra da porta é toda a diferença.

ideia 5

Nó = valor + endereço do próximo

Uma lista encadeada não tem índice, tem corrente. Cada nó guarda o dado e a referência ao seguinte. Toda operação — inserir, remover — é religar setas na ordem certa, e a ordem errada perde o resto da lista.

Parte I · Questões 1 e 2

Análise de complexidade

Questão 1

Dois laços em sequência

Considere o código. a) Determine a complexidade temporal usando Big-O. b) Explique por que os dois laços não resultam em O(n²).

def algoritmo(n):
    for i in range(n):
        print(i)
    for j in range(n):
        print(j)

o que está sendo testado se você sabe distinguir laços sequenciais de laços aninhados — e se sabe que constantes somem no Big-O.

Dica. Olhe a indentação. O segundo for está no mesmo nível do primeiro, ou dentro dele? Conte quantos print acontecem no total quando n = 5.

Passo a passo.

  1. O primeiro laço executa print n vezes.
  2. Quando ele termina, o segundo começa — e executa mais n vezes.
  3. Total: n + n = 2n operações. Com n = 5: 5 + 5 = 10 prints.
  4. Big-O descarta constantes multiplicativas: 2n vira O(n).
  5. Para ser O(n²), o segundo laço teria que rodar inteiro para cada volta do primeiro — ou seja, estar indentado dentro dele. Não está.

a) A complexidade é O(n) — linear.

b) Porque os laços são sequenciais, não aninhados. Um roda depois que o outro termina, então os custos se somam (n + n = 2n) em vez de se multiplicarem. Em O(n²) o laço interno executaria n voltas completas a cada uma das n voltas do externo, dando n × n. Como 2n cresce em linha reta com n — dobrar a entrada dobra o tempo — a constante 2 é descartada e a classe é O(n).

variação que pode cair e se houvesse três laços sequenciais? (3n → ainda O(n)) E se o segundo fosse for j in range(100)? (n + 100 → O(n), porque 100 não cresce com n)

Questão 2

Linear contra quadrático

a) Determine a complexidade de cada algoritmo. b) Qual tem melhor desempenho para listas grandes? c) Para uma lista de 10.000 elementos, explique por que o segundo se torna impraticável.

def algoritmo1(lista):
    for x in lista:
        print(x)

def algoritmo2(lista):
    for i in range(len(lista)):
        for j in range(len(lista)):
            print(lista[i], lista[j])

o que está sendo testado se você consegue quantificar a diferença — e não só nomear as classes.

Dica. No item (c) o professor quer um número, não um adjetivo. Calcule 10.000 × 10.000 e transforme em tempo: um computador faz na ordem de 10 milhões de print por segundo (o print é lento justamente por escrever na tela).

Passo a passo.

  1. algoritmo1: um laço percorrendo a lista uma vez → n operações → O(n).
  2. algoritmo2: o laço de j está dentro do de i. Para cada um dos n valores de i, o de j dá n voltas → n × nO(n²).
  3. Com n = 10.000: o primeiro faz 10 mil operações; o segundo faz 100 milhões.
  4. A diferença não é “um pouco mais lento”: é 10.000 vezes mais trabalho — e essa razão piora conforme a lista cresce.

a) algoritmo1 é O(n) (laço simples); algoritmo2 é O(n²) (laço aninhado).

b) O algoritmo1, com folga. Para listas grandes a diferença é de ordens de grandeza, não de porcentagem.

c) Com 10.000 elementos, o algoritmo2 executa 10.000 × 10.000 = 100.000.000 de operações, cada uma imprimindo na tela — algo entre dezenas de minutos e horas, além de gerar 100 milhões de linhas de saída. O algoritmo1 faria 10.000 operações, concluídas em fração de segundo. É por isso que O(n²) é considerado impraticável em escala: o custo cresce com o quadrado da entrada, então cada vez que a base dobra, o tempo quadruplica.

variação que pode cair se o laço interno fosse for j in range(i), o total seria n(n−1)/2 — ainda O(n²), porque a metade é uma constante.

Parte II · Questões 3 e 4

Vetores e matrizes

O padrão que resolve as duas: inicializa → percorre uma vez → devolve. Antes do laço você cria os acumuladores; dentro dele você atualiza todos de uma vez; depois dele você calcula o resultado final. Nunca percorra duas vezes o que dá para fazer numa passada.

Questão 3

estatisticas(lista) sem usar sum()

Escreva estatisticas(lista) que receba uma lista de números e retorne a média, a quantidade de pares e a quantidade de ímpares. Restrição: sem sum() e sem bibliotecas.

o que está sendo testado se você sabe somar “na mão” com acumulador e usar o resto da divisão (%) — e se lembra do caso da lista vazia.

Dica. Você precisa de três variáveis antes do laço: soma, pares e impares, todas começando em 0. Par é todo número cujo resto da divisão por 2 é zero: numero % 2 == 0. E a média é a soma dividida por len(lista) — o que quebra se a lista estiver vazia.

Passo a passo.

  1. Trate primeiro o caso vazio: se a lista não tem elementos, não há média a calcular (divisão por zero).
  2. Crie os três acumuladores zerados antes do laço — se criar dentro, eles reiniciam a cada volta.
  3. Percorra a lista uma vez. A cada número: some ao total e classifique como par ou ímpar.
  4. Depois do laço, divida a soma pelo tamanho para obter a média.
  5. Devolva os três valores. Em Python, return a, b, c devolve uma tupla — e isto conecta com a Questão 5.
def estatisticas(lista):
    # caso vazio: evita divisão por zero
    if not lista:
        return (0, 0, 0)

    soma = 0          # acumuladores nascem ANTES do laço
    pares = 0
    impares = 0

    for numero in lista:      # uma única passada → O(n)
        soma += numero
        if numero % 2 == 0:
            pares += 1
        else:
            impares += 1

    media = soma / len(lista)
    return (media, pares, impares)

# teste
print(estatisticas([1, 2, 3, 4, 5, 6]))   # (3.5, 3, 3)
print(estatisticas([10, 20, 30]))         # (20.0, 3, 0)
print(estatisticas([]))                   # (0, 0, 0)

Complexidade: O(n) de tempo (uma passada) e O(1) de espaço (três variáveis, não importa o tamanho da lista). Se o professor perguntar, é essa a resposta.

variação que pode cair devolver também o maior e o menor — mesma passada, mais dois acumuladores iniciados com lista[0]. Ou contar positivos e negativos.

Questão 4

Maior elemento de uma matriz, sem max()

Escreva uma função que encontre o maior elemento de uma matriz sem usar max(). a) Quantas posições precisam ser visitadas? b) Qual a complexidade para uma matriz n × n? c) E para n × m?

o que está sendo testado laço aninhado com propósito legítimo (matriz é bidimensional) e a diferença entre n² e n·m.

Dica. Não comece com maior = 0 — se a matriz só tiver números negativos, a resposta sai errada. Comece com o primeiro elemento real: matriz[0][0]. E note que aqui o laço aninhado não é desperdício: você precisa mesmo olhar toda posição uma vez.

Passo a passo.

  1. Uma matriz em Python é uma lista de listas: cada elemento da lista externa é uma linha.
  2. Guarde matriz[0][0] como candidato a maior.
  3. Laço externo percorre as linhas; laço interno percorre os valores daquela linha.
  4. A cada valor, compare: se for maior que o candidato, ele vira o novo candidato.
  5. No fim do percurso, o candidato é o maior de todos — porque nenhum valor ficou sem ser comparado.
def maior_da_matriz(matriz):
    if not matriz or not matriz[0]:
        return None

    maior = matriz[0][0]        # candidato inicial: elemento REAL

    for linha in matriz:        # percorre as linhas
        for valor in linha:     # percorre os valores da linha
            if valor > maior:
                maior = valor
    return maior

m = [[3, 9, 2],
     [7, 1, 8],
     [4, 6, 5]]
print(maior_da_matriz(m))       # 9 (visitou 9 posições)

a) Todas: n × m posições (na matriz 3×3 do exemplo, 9). Não dá para visitar menos — qualquer posição não olhada poderia ser justamente a maior.

b) Matriz n × n: O(n²).

c) Matriz n × m: O(n · m). Repare que aqui o quadrático não é defeito: é o tamanho da entrada. Uma matriz n×n tem n² elementos, então ler todos custa n² — isso é linear no número de elementos.

variação que pode cair devolver também a posição (linha, coluna) do maior; somar todos os elementos; contar quantos são maiores que a média.

Parte III · Questões 5, 6 e 7

Tuplas, sets e dicionários

list a b a 0 1 2 ordenada · repete muda · acesso por índice lista[1] → 'b' tuple ("João", 8.5, 7.0) ordenada · repete NÃO muda · por índice registro fixo set a b c SEM ordem · SEM repetir sem índice 'a' in conjunto → O(1) dict "Ana" → 98111 "Bia" → 98222 chave → valor chave não repete agenda["Ana"] → O(1) A pergunta que escolhe a estrutura: como você vai buscar o dado? Por posição → list. Registro que não muda → tuple. Pertence ou não → set. Por uma chave → dict.
Quatro estruturas, quatro perguntas diferentes. O erro clássico de prova é escolher pela aparência do dado (“são vários nomes, então lista”) em vez de pelo uso. Se a pergunta que você vai fazer é “fulano está aí?”, o set responde em tempo constante; se é “qual o telefone de fulano?”, o dict responde direto; a lista obrigaria a varrer tudo nos dois casos.
Questão 5

A tupla do aluno

Dado aluno = ("João", 8.5, 7.0, 9.0), escreva um programa que 1) extraia o nome, 2) calcule a média, 3) informe se foi aprovado, 4) produza uma nova tupla com nome e média. Explique por que uma tupla pode ser mais adequada que uma lista.

o que está sendo testado indexação e fatiamento de tupla — e, principalmente, se você sabe justificar a imutabilidade.

Dica. aluno[0] é o nome; aluno[1:] é a fatia com as três notas — e continua sendo uma tupla. A pergunta conceitual quer três palavras: imutabilidade, registro de campos fixos e segurança.

Passo a passo.

  1. Nome: posição 0.
  2. Notas: da posição 1 até o fim → aluno[1:]. Não escreva aluno[1] + aluno[2] + aluno[3] à mão: se amanhã forem quatro notas, seu código quebra.
  3. Some as notas num acumulador (mesmo padrão da Q3) e divida pela quantidade.
  4. Aprovado: média ≥ 7,0 (adote e declare o critério).
  5. Monte a nova tupla com (nome, media) — parênteses, não colchetes.
aluno = ("João", 8.5, 7.0, 9.0)

nome = aluno[0]              # 1. extrair o nome
notas = aluno[1:]            # fatia → (8.5, 7.0, 9.0)

soma = 0
for nota in notas:
    soma += nota
media = soma / len(notas)    # 2. média

aprovado = media >= 7.0      # 3. situação
resumo = (nome, media)       # 4. nova tupla

print("Nome:", nome)
print("Média:", round(media, 2))
print("Situação:", "Aprovado" if aprovado else "Reprovado")
print("Resumo:", resumo)

# Saída:
# Nome: João
# Média: 8.17
# Situação: Aprovado
# Resumo: ('João', 8.166666666666666)

Por que tupla e não lista? Três razões, e o professor espera pelo menos duas:

  • Imutabilidade como proteção. Um registro de aluno tem campos fixos que não deveriam ser alterados por engano. aluno[1] = 10.0 levanta TypeError — a estrutura recusa a fraude em vez de aceitar em silêncio.
  • Semântica de registro. Lista costuma significar “vários itens do mesmo tipo”; tupla significa “um conjunto fixo de campos de significados diferentes” — nome, nota, nota, nota. A escolha comunica intenção a quem lê.
  • Pode ser chave de dict e elemento de sethashable), coisa que lista não pode — porque o que muda não pode ser usado como chave.

variação que pode cair desempacotamento: nome, n1, n2, n3 = aluno — sintaxe elegante que vale ponto extra se você citar.

Questão 6

Operações de conjunto entre duas turmas

Com turma_a = {1,2,3,4,5,6} e turma_b = {4,5,6,7,8,9}, determine: a) alunos nas duas turmas; b) só na A; c) só na B; d) em pelo menos uma.

o que está sendo testado traduzir português para operação de conjunto. É a questão mais rápida da lista — se você souber a tradução.

Dica — o dicionário português → símbolo: “nas duas” = interseção & · “só na A” = diferença A - B · “em pelo menos uma” = união | · “em exatamente uma” = diferença simétrica ^. Cuidado: “pelo menos uma” é união, não interseção.

turma_a = {1, 2, 3, 4, 5, 6}
turma_b = {4, 5, 6, 7, 8, 9}

# a) nas duas turmas — INTERSEÇÃO
print(turma_a & turma_b)              # {4, 5, 6}
print(turma_a.intersection(turma_b))  # mesma coisa

# b) somente na turma A — DIFERENÇA
print(turma_a - turma_b)              # {1, 2, 3}

# c) somente na turma B — DIFERENÇA (ordem invertida!)
print(turma_b - turma_a)              # {8, 9, 7}

# d) em pelo menos uma — UNIÃO
print(turma_a | turma_b)              # {1,2,3,4,5,6,7,8,9}

# bônus: em exatamente uma — DIFERENÇA SIMÉTRICA
print(turma_a ^ turma_b)              # {1,2,3,7,8,9}

Duas armadilhas. (1) A diferença não é comutativa: A - BB - A. (2) O set não tem ordem — o Python pode imprimir {8, 9, 7} em vez de {7, 8, 9}, e isso não é erro. Se a ordem importasse, a estrutura estaria errada.

variação que pode cair “quantos alunos ao todo, sem contar ninguém duas vezes?” → len(turma_a | turma_b). Ou remover duplicatas de uma lista: list(set(lista)).

Questão 7

Agenda telefônica com dict

Crie um programa com dict para uma agenda telefônica que permita: cadastrar, remover, buscar pelo nome, alterar telefone e listar todos.

o que está sendo testado as operações básicas de dicionário e o cuidado com chave inexistente — que é onde a maioria perde ponto.

Dica. O nome é a chave e o telefone é o valor. Cadastrar e alterar são a mesma operação (agenda[nome] = telefone) — o que as diferencia é a verificação: cadastrar recusa se já existe, alterar recusa se não existe. Use if nome in agenda antes de remover, e .get() para buscar sem quebrar.

Passo a passo.

  1. Cadastrar: se a chave já existe, avise; senão, agenda[nome] = telefone.
  2. Remover: del agenda[nome] — mas depois de confirmar que a chave existe, senão dá KeyError.
  3. Buscar: agenda.get(nome, "não encontrado") devolve o padrão em vez de quebrar. Essa escolha vale ponto.
  4. Alterar: confirma que existe e reatribui.
  5. Listar: for nome, tel in agenda.items().items() entrega os pares.
agenda = {}

def cadastrar(nome, telefone):
    if nome in agenda:                # busca por chave: O(1)
        return f"{nome} já existe. Use alterar()."
    agenda[nome] = telefone
    return f"{nome} cadastrado."

def remover(nome):
    if nome not in agenda:            # sem isto: KeyError
        return f"{nome} não encontrado."
    del agenda[nome]
    return f"{nome} removido."

def buscar(nome):
    return agenda.get(nome, "não encontrado")

def alterar(nome, telefone):
    if nome not in agenda:
        return f"{nome} não encontrado."
    agenda[nome] = telefone
    return f"telefone de {nome} atualizado."

def listar():
    if not agenda:
        return "agenda vazia"
    for nome, telefone in agenda.items():
        print(f"  {nome}: {telefone}")

print(cadastrar("Ana", "98111-1111"))    # Ana cadastrado.
print(cadastrar("Carlos", "98222-2222"))
print(buscar("Carlos"))                    # 98222-2222
print(alterar("Carlos", "98999-9999"))
print(remover("Ana"))                      # Ana removido.
print(buscar("Ana"))                       # não encontrado
listar()

Por que dict e não lista de listas? Porque a pergunta da agenda é sempre “qual o telefone deste nome?”. No dict isso é O(1) — a chave vira endereço por uma função de hash. Numa lista você teria que varrer tudo: O(n). Com dez contatos ninguém nota; com dez mil, sim.

variação que pode cair menu interativo com while True e input(); guardar mais de um dado por contato (o valor vira um dict aninhado ou uma tupla).

Parte IV · Questões 8 e 9

Pilhas e filas

As duas são a mesma lista com uma regra de porta diferente. Brinque nos simuladores abaixo antes de ler as soluções — ver a estrutura mexer ensina mais rápido que ler sobre ela.

simulador 1

Pilha — LIFO: o último a entrar é o primeiro a sair

topo ↓
base

pilha vazia — empilhe alguma coisa.

saída montada:

Questão 8

inverter(texto) usando pilha

Usando uma pilha, implemente inverter(texto). Entrada PYTHON → saída NOHTYP. A inversão deve usar explicitamente uma pilha.

o que está sendo testado se você entendeu que inverter é o efeito colateral natural do LIFO — e não se você conhece texto[::-1], que aqui seria zero.

Dica. Em Python a pilha é uma lista comum usando só dois métodos: append() para empilhar e pop() (sem argumento!) para desempilhar do topo. Empilhe letra por letra; depois desempilhe até a pilha esvaziar. Clique em “rodar inverter” no simulador acima e observe a ordem.

Passo a passo.

  1. Crie a pilha vazia: pilha = [].
  2. Percorra o texto e empilhe cada caractere. Depois de PYTHON, o topo é o N.
  3. Crie uma string vazia para o resultado.
  4. Enquanto a pilha não estiver vazia, faça pop() e concatene. O primeiro a sair é o último que entrou — o N.
  5. Ao esvaziar, o resultado está invertido. Não é truque: é a definição de LIFO em ação.
def inverter(texto):
    pilha = []

    for caractere in texto:      # empilha: P,Y,T,H,O,N
        pilha.append(caractere)     # append = push

    invertido = ""
    while pilha:                  # enquanto não estiver vazia
        invertido += pilha.pop()    # pop() tira do TOPO

    return invertido

print(inverter("PYTHON"))         # NOHTYP
print(inverter("ARARA"))          # ARARA (palíndromo)

Cuidado com o pop(): sem argumento remove do fim (topo da pilha) — é O(1). Com pop(0) removeria do início, que é comportamento de fila e custa O(n). Trocar um pelo outro é o erro mais comum desta questão.

Complexidade: O(n) — cada caractere entra uma vez e sai uma vez.

variação que pode cair verificar se uma palavra é palíndromo usando pilha; validar parênteses balanceados ((a+b)*c) — o uso clássico de pilha, empilhando ao abrir e desempilhando ao fechar.

simulador 2

Fila — FIFO: o primeiro a entrar é o primeiro a sair

← sai
dequeue
entra ←
enqueue

fila vazia — coloque alguém.

Questão 9

Classe Fila

Implemente uma classe Fila com enqueue(), dequeue(), front(), is_empty() e size(), usando uma lista Python. Teste com Ana, Carlos e João. Explique FIFO.

o que está sendo testado classe com estado interno + a diferença entre remover (dequeue) e espiar (front) — e se você protege contra fila vazia.

Dica. __init__ cria a lista vazia. Entra no fim (append), sai do início (pop(0)). front() devolve self.itens[0] sem remover — essa é a diferença que a questão quer ver. E toda operação que mexe no primeiro elemento precisa checar antes se a fila está vazia.

Passo a passo.

  1. __init__: self.itens = [] — cada objeto Fila terá a sua própria lista.
  2. enqueue(item): append coloca no fim da lista, que é o fim da fila.
  3. dequeue(): se vazia devolve None; senão pop(0) tira o primeiro.
  4. front(): mesma proteção, mas devolve self.itens[0]consulta, não retira.
  5. is_empty() e size() saem de len(self.itens).
  6. Rode o teste: depois de enfileirar os três e dar um dequeue, sai Ana (a primeira que entrou) e front() passa a ser Carlos.
class Fila:
    def __init__(self):
        self.itens = []

    def enqueue(self, item):     # entra no FIM
        self.itens.append(item)

    def dequeue(self):           # sai do INÍCIO
        if self.is_empty():
            return None
        return self.itens.pop(0)

    def front(self):             # espia sem remover
        if self.is_empty():
            return None
        return self.itens[0]

    def is_empty(self):
        return len(self.itens) == 0

    def size(self):
        return len(self.itens)

# teste pedido pela questão
f = Fila()
f.enqueue("Ana")        # ['Ana']
f.enqueue("Carlos")     # ['Ana', 'Carlos']
f.enqueue("João")       # ['Ana', 'Carlos', 'João']
print(f.dequeue())      # Ana    ← a primeira que entrou
print(f.front())        # Carlos ← agora é a primeira da fila
print(f.size())         # 2
print(f.is_empty())     # False

FIFO — First In, First Out. O primeiro elemento a entrar é o primeiro a sair, exatamente como a fila do banco: quem chega vai para o fim, quem é atendido é quem está na frente há mais tempo. A ordem de chegada é preservada. É o oposto da pilha (LIFO), onde o último a chegar é atendido primeiro. Usos reais: fila de impressão, atendimento por ordem de chegada, tarefas pendentes e a busca em largura (BFS) em grafos.

Detalhe que vale ponto extra: pop(0) é O(n), porque todos os elementos seguintes precisam ser deslocados uma posição para a esquerda. Para filas grandes usa-se collections.deque, cujo popleft() é O(1). Para a prova, a lista basta — mas citar isso mostra que você entende o custo.

variação que pode cair implementar a classe Pilha com push, pop, topo, is_empty, size — idêntica, trocando pop(0) por pop() e itens[0] por itens[-1].

Parte V · Questões 10, 11 e 12

Listas encadeadas

O assunto mais novo da lista — e o que mais derruba quem só decorou. A ideia é uma só: cada nó guarda o valor e o endereço do próximo. Não há índice; há corrente.

simulador 3

Lista encadeada — veja as setas religando

início
(head)

lista vazia — insira um valor.

Questão 10

Classe No e encadeamento manual

Crie uma classe No que armazene um valor e a referência para o próximo nó. Monte manualmente 10 → 20 → 30 → None e percorra a lista imprimindo os valores.

o que está sendo testado se você entende que proximo guarda outro objeto (não uma cópia) e se sabe escrever o laço de percurso — o padrão que reaparece em toda operação de lista encadeada.

Dica. A classe tem só dois atributos: valor e proximo, e proximo começa como None. Encadear é atribuir: n1.proximo = n2. Para percorrer, use uma variável “andarilha” — atual — que começa no primeiro nó e vai recebendo atual.proximo até virar None.

Passo a passo.

  1. Defina No com __init__(self, valor): guarda o valor e põe self.proximo = None.
  2. Crie os três nós soltos: n1 = No(10), n2 = No(20), n3 = No(30). Neste instante nenhum conhece o outro.
  3. Encadeie: n1.proximo = n2 e n2.proximo = n3. O de n3 já é None — e é justamente esse None que marca o fim.
  4. Percorra: atual = n1; enquanto atual não for None, imprima atual.valor e avance com atual = atual.proximo.
  5. Se esquecer o avanço, o laço roda para sempre. Se começar com atual = n1.proximo, você perde o primeiro valor.
class No:
    def __init__(self, valor):
        self.valor = valor
        self.proximo = None     # ainda não aponta para ninguém

# criar os nós
n1 = No(10)
n2 = No(20)
n3 = No(30)

# encadear: 10 → 20 → 30 → None
n1.proximo = n2
n2.proximo = n3            # n3.proximo continua None = fim

# percorrer
atual = n1                 # começa na cabeça
while atual is not None:
    print(atual.valor, end=" → ")
    atual = atual.proximo  # AVANÇA (sem isto: laço infinito)
print("None")

# Saída: 10 → 20 → 30 → None

Por que None importa: ele é a única marca de “acabou”. Numa lista Python você sabe o fim por len(); numa encadeada, só descobre chegando lá. É por isso que acessar o k-ésimo elemento custa O(n) — não existe conta de endereço, existe caminhada.

variação que pode cair contar os nós; somar os valores; buscar um valor devolvendo True/False. Todas usam o mesmo laço de percurso — só muda o que acontece dentro dele.

Questão 11

O que acontece em inserir_inicio(5)

Dada a lista 10 → 20 → 30 → 40 → None, explique passo a passo o que acontece ao executar lista.inserir_inicio(5). Represente graficamente o antes e o depois.

o que está sendo testado se você sabe a ordem correta das duas atribuições — invertê-la é o erro clássico, e ele destrói a lista inteira.

Dica. São três linhas de código e a ordem é sagrada: criar o nóo novo aponta para a antiga cabeçaa cabeça passa a ser o novo. Clique em “inserir_inicio(5) em 3 passos” no simulador acima e acompanhe a seta mudando.

Passo a passo — o que a máquina faz.

  1. novo = No(5) — nasce um nó solto com valor 5 e proximo = None. A lista original continua intacta; ninguém aponta para ele ainda.
  2. novo.proximo = self.inicio — o novo nó passa a apontar para o antigo primeiro (o 10). Agora existem dois caminhos para o 10: o inicio e o novo. Estado momentâneo e válido.
  3. self.inicio = novo — a cabeça da lista passa a ser o 5. Pronto: 5 → 10 → 20 → 30 → 40 → None.

Se inverter os passos 2 e 3 — fazer self.inicio = novo antes de guardar a referência — você perde o endereço do 10, e com ele o resto da lista inteira. Sobra 5 → None. Os outros quatro nós ficam órfãos na memória e o coletor de lixo os recolhe. É este o erro que a questão está caçando.

Representação gráfica.

ANTES
inicio
  ↓
[10|•]→[20|•]→[30|•]→[40|✕]→ None

PASSO 1 — novo = No(5): nó solto, ninguém aponta para ele
inicio
  ↓
[10|•]→[20|•]→[30|•]→[40|✕]→ None

[5|✕]→ None

PASSO 2 — novo.proximo = inicio: o 5 passa a apontar para o 10
inicio
  ↓
[10|•]→[20|•]→[30|•]→[40|✕]→ None
  ↑
[5|•]

PASSO 3 — inicio = novo: a cabeça vira o 5
inicio
  ↓
[5|•]→[10|•]→[20|•]→[30|•]→[40|✕]→ None

DEPOIS: 5 → 10 → 20 → 30 → 40 → None
def inserir_inicio(self, valor):
    novo = No(valor)             # 1. cria o nó
    novo.proximo = self.inicio   # 2. novo aponta para a antiga cabeça
    self.inicio = novo           # 3. a cabeça passa a ser o novo

Complexidade: O(1). Repare que nada foi percorrido e nada foi deslocado — só duas setas mudaram, independentemente de a lista ter 4 ou 4 milhões de nós. É exatamente aqui que a lista encadeada ganha do array: inserir no início de um array custaria O(n), porque todos os elementos teriam que andar uma casa para a direita.

variação que pode cair inserir_fim (precisa percorrer até o último → O(n)) e remover_inicio (self.inicio = self.inicio.proximo → O(1)). Sabendo desenhar as setas, você deduz as duas na hora.

Questão 12

O quadro comparativo

Compare list, tuple, set, dict, pilha, fila e lista encadeada considerando: a) finalidade; b) duplicação; c) ordem; d) acesso por índice; e) complexidade das operações principais; f) aplicação prática.

o que está sendo testado a síntese de tudo. Se você fez as 11 anteriores, esta tabela você escreve de cabeça — e ela vale como colinha para a prova inteira.

EstruturaFinalidadeDuplica?OrdemÍndiceComplexidadesAplicação prática
list coleção sequencial de itens que muda sim mantém a de inserção sim acesso O(1) · busca O(n) · inserir no fim O(1) · inserir/remover no meio ou início O(n) carrinho de compras, notas de um aluno, qualquer coleção que cresce
tuple registro fixo, imutável sim mantém sim acesso O(1) · busca O(n) · não permite alteração coordenada (x, y), registro de aluno, retorno de função com vários valores
set pertinência e unicidade não não tem não adicionar O(1) · buscar O(1) · remover O(1) · união/interseção O(n) alunos matriculados, remover duplicatas, comparar turmas
dict associar uma chave a um valor chave não; valor sim mantém a de inserção (3.7+) por chave, não por posição inserir O(1) · buscar O(1) · remover O(1) agenda telefônica, cadastro por CPF, contagem de ocorrências
pilha último a entrar, primeiro a sair (LIFO) sim mantém, mas só o topo é acessível não (só o topo) push O(1) · pop O(1) · topo O(1) desfazer (Ctrl+Z), pilha de chamadas, parênteses balanceados, inverter texto
fila primeiro a entrar, primeiro a sair (FIFO) sim mantém a de chegada não (só a frente) enqueue O(1) · dequeue O(n) com lista, O(1) com deque fila de impressão, atendimento por chegada, tarefas pendentes, BFS
lista encadeada sequência ligada por referências, sem bloco contíguo sim mantém não (percorre) inserir/remover no início O(1) · acessar o k-ésimo O(n) · buscar O(n) base de pilhas e filas, listas que crescem muito e são percorridas em ordem

Se cair só uma linha desta tabela na prova, provavelmente é esta: set e dict buscam em O(1) porque a chave é convertida em endereço por uma função de hash; list e lista encadeada buscam em O(n) porque precisam olhar item por item. Essa é a diferença que muda o desempenho de um sistema real.

Agora sem consultar

Treino

Ler solução dá a sensação de aprender; responder sem olhar é aprender. Dois blocos: complexidade (o que mais cai) e rastreamento de estrutura (o que mais confunde). Erre à vontade aqui — cada erro vem com a explicação.

bloco 1 · 12 questões

Qual é a complexidade?

0 acertos · 0 erros
bloco 2 · 10 questões

Qual é o estado da estrutura?

0 acertos · 0 erros
Os erros que custam ponto

Colinha da véspera

Se você só tiver dez minutos antes da prova, leia esta seção. São os oito deslizes que mais aparecem em correção — todos de gente que sabia a matéria.

erro 1

Chamar de O(n²) o que é sequencial

Olhe a indentação antes de responder. Dentro → multiplica. Depois → soma. n + n é O(n).

erro 2

Iniciar maior = 0

Com valores negativos a resposta sai errada. Comece sempre com o primeiro elemento real da estrutura.

erro 3

Confundir pop() com pop(0)

pop() tira do fim — é pilha, O(1). pop(0) tira do início — é fila, O(n). Um caractere muda a estrutura inteira.

erro 4

Inverter a ordem no inserir_inicio

Primeiro novo.proximo = inicio, depois inicio = novo. Ao contrário, você perde a lista toda.

erro 5

Esquecer o avanço no percurso

atual = atual.proximo dentro do while. Sem essa linha, laço infinito.

erro 6

Não tratar vazio

Média de lista vazia divide por zero; dequeue() de fila vazia quebra; del de chave inexistente dá KeyError. Uma linha de if resolve as três.

erro 7

Esperar ordem de um set

{8, 9, 7} é saída legítima. Set não tem ordem — se a ordem importa, a estrutura está errada.

erro 8

Usar sum(), max() ou [::-1] quando a questão proíbe

A restrição é a questão. O professor quer ver o laço, não o atalho.

As frases que valem ponto na dissertativa

Se perguntarem…Responda com esta frase
por que não é O(n²)“porque os laços são sequenciais, não aninhados: os custos se somam (n + n = 2n) em vez de se multiplicarem, e a constante é descartada”
por que tupla e não lista“porque é um registro de campos fixos que não deve mudar; a imutabilidade protege contra alteração acidental e permite usá-la como chave de dicionário”
o que é FIFO“first in, first out: o primeiro elemento a entrar é o primeiro a sair, preservando a ordem de chegada — como a fila do banco”
por que dict é melhor que lista aqui“porque a busca é por chave: o dicionário converte a chave em endereço por hash e responde em O(1), enquanto a lista precisaria percorrer todos os elementos, O(n)”
vantagem da lista encadeada“inserir e remover no início custam O(1), sem deslocar nenhum elemento — num array a mesma operação obrigaria a mover todos os seguintes”
desvantagem da lista encadeada“não há acesso direto por índice: para chegar ao k-ésimo é preciso percorrer desde o início, O(n)”

Na hora da prova, se travar: desenhe. Caixinhas e setas para lista encadeada, uma coluna para pilha, uma linha com duas pontas para fila. Rastrear no papel com 3 ou 4 elementos resolve praticamente qualquer questão de rastreamento — e mostra raciocínio ao corretor mesmo se o código sair incompleto.

← todas as disciplinas
DCEUNDB · ADS3º período

Estatística Decisórialer dados sem ser enganado por eles

68h assumidas 5 módulos 30 tópicos nunca gostou de estatística? comece aqui → Google Sheets no laboratório veredito: aprofundar

A promessa: formado por esta disciplina, você lê dados sem ser enganado por eles — e decide sob incerteza com método: sabe o que uma média esconde, o que uma amostra permite afirmar, e quando uma variação é sinal ou ruído.

Carga horária no padrão UNDB; ajustar quando o plano de ensino chegar.

Módulo zero · para quem nunca viu isso antes

Do zero, sem jargão

Estatística tem má fama por ser ensinada como fórmula. Não é fórmula: é um conjunto de defesas contra conclusões erradas. Esta seção mostra as três que valem por metade do curso — sem uma conta sequer.

1. A primeira defesa: um número resumido esconde coisas

“O salário médio da equipe é R$ 4.340.” Parece informação. Não é — depende inteiramente de como os salários se espalham. Veja o que acontece quando uma única pessoa é muito diferente das outras:

DEZ SALÁRIOS DE UMA EQUIPE 1.800 3.400 20.000 mediana R$ 2.700 o valor do meio: cinco ganham menos, cinco ganham mais média R$ 4.340 uma única pessoa puxa a média nove das dez ganham menos que “a média”
Média e mediana respondem perguntas diferentes. A média divide o bolo igualmente — útil para totais, frágil a extremos. A mediana marca o meio da fila — imune a extremos, e por isso é ela que se usa para renda, preço de imóvel e tempo de resposta. Quando alguém diz “a média é X” sem dizer como os dados se espalham, a frase ainda não é informação.

2. A segunda defesa: o gráfico pode mentir sem mentir

Nenhum dos dois gráficos abaixo tem um número errado. São os mesmos quatro valores. Um deles dá vontade de comemorar.

EIXO COMEÇANDO NO ZERO 0% 4% jan fev mar abr “praticamente estável” EIXO COMEÇANDO EM 3% 3,0% 3,5% jan fev mar abr “crescimento explosivo!”
Os dados: 3,1% · 3,2% · 3,3% · 3,4%. Cortar o eixo é a manipulação mais comum do mundo corporativo — e raramente é má-fé: é entusiasmo. Aprender a olhar primeiro para o eixo, antes da forma das barras, é uma das habilidades mais rentáveis do semestre; ela também protege você de fazer isso sem querer no seu próprio relatório.

3. A terceira defesa: “mudou” exige prova

Sua página convertia 3,1% e passou a converter 3,4%. Mudou? Talvez nada tenha acontecido. Números que dependem de pessoas oscilam sozinhos: jogue uma moeda 20 vezes hoje e 20 amanhã e você não terá 10 caras nos dois dias. A oscilação natural tem nome — variação amostral — e a disciplina inteira existe para responder uma pergunta: essa diferença é grande o bastante para não ser só oscilação?

É esta a definição prática de “estatística decisória”: um conjunto de ferramentas para separar sinal (algo mudou de verdade) de ruído (o mundo oscilando como sempre oscilou) — e para admitir, honestamente, quando os dados que você tem não são suficientes para decidir.

4. O vocabulário mínimo

o que você quer saber

População

Todo o universo que interessa: todos os visitantes do site, todos os clientes possíveis. Quase nunca dá para medir inteiro.

o que você consegue medir

Amostra

O pedaço que você observou: os 800 visitantes desta semana. Toda a estatística é a arte de falar da população olhando só para a amostra.

o quanto isso oscila

Desvio padrão

A “largura” dos dados. Duas turmas com média 7 são mundos diferentes se uma varia de 6 a 8 e a outra de 2 a 10.

a honestidade obrigatória

Margem de erro

Nenhum resultado de amostra é um ponto: é uma faixa. “32% ± 3” é a forma correta; “32%” sozinho esconde o que você não sabe.

Por que esta disciplina importa

Ponte com a trajetória

Esta é a matemática do seu Metrics Framework — ler se o conteúdo está funcionando, se a taxa de conversão da Varredura mudou de verdade ou só oscilou, o que um teste A/B autoriza concluir. Para o dev, é a antessala de dados/analytics; para o autônomo, é defesa contra decidir por anedota.

Veredito: aprofundar — com foco em leitura e decisão, não em cálculo manual

68 horas, cinco módulos

Currículo revisado

Mód.HorasTemaSentido
114hDescrever dados honestamenteo que média, mediana e desvio contam — e escondem
212hProbabilidade para decisãointuição calibrada sobre chance, risco e condicional
314hAmostras e distribuiçõeso que poucos dados permitem dizer sobre muitos
416hInferência: sinal vs ruídotestes, intervalos e o que “significativo” significa (e não significa)
512hRelações + capstonecorrelação, regressão, e um dashboard estatístico da sua prática

Como usar: siga o checklist na ordem dos módulos. Os módulos 3 e 4 são o coração da disciplina; se o semestre apertar, corte no 2, nunca no 4.

Módulo 1 · 14h

Descrever dados honestamente

O que média, mediana e desvio contam — e escondem. Metade dos erros de leitura de dados morre aqui.

Checklist

7 tópicos

0/7

O teste de honestidade do módulo 1: ao ver qualquer número resumido, pergunte três coisas — quantos casos? (n), quanto varia? (desvio), tem extremo? (outlier). Um número sem essas três respostas ainda não autoriza decisão nenhuma. É esse reflexo, e não a fórmula da variância, que o módulo precisa deixar instalado.

Módulo 2 · 12h

Probabilidade para decisão

Intuição calibrada sobre chance, risco e condicional — a área onde o cérebro humano erra de forma mais previsível.

Checklist

6 tópicos

0/6

2.3–2.4 — a armadilha da inversão, com números

Um exame detecta 99% dos doentes e erra em 1% dos sadios. A doença atinge 1 pessoa em 1.000. Seu exame deu positivo. Qual a chance de você estar doente? A intuição grita “99%”. A conta diz outra coisa — imagine 100 mil pessoas:

GrupoPessoasExame positivoLeitura
Doentes (0,1%)10099o exame acerta quase todos
Sadios (99,9%)99.9009991% de um grupo enorme ainda é muita gente
Total de positivos1.098dos quais só 99 estão realmente doentes

Resposta: cerca de 9%, não 99%. P(positivo | doente) é altíssima; P(doente | positivo) é baixa — e essas duas frases não são a mesma coisa. Trocá-las é o erro mais caro da estatística aplicada, e ele aparece em diagnóstico médico, detecção de fraude, filtro de spam e em toda métrica de alerta que você vier a construir: quando o evento buscado é raro, quase todo alarme é falso.

Módulo 3 · 14h

Amostras e distribuições

O que poucos dados permitem dizer sobre muitos — a peça que faz toda a inferência ser possível.

Checklist

6 tópicos

0/6
média −1σ +1σ −2σ +2σ −3σ +3σ 68% 95% 99,7% altura, erro de medição, soma de muitos fatores pequenos — tudo tende a este formato
O sino não é uma escolha estética: é uma consequência. Sempre que muitos fatores pequenos e independentes se somam, o resultado tende a este formato — é o teorema central do limite, e é ele que permite calcular incerteza sem conhecer a população. A regra prática que sai daí: um valor a mais de dois desvios da média é incomum (5% dos casos); a três, é raro (0,3%). Todo teste de hipótese que vem no módulo 4 é essa régua aplicada.

3.2 — o viés que nenhuma conta corrige. Na Segunda Guerra, analistas mapearam onde os aviões voltavam furados e propuseram blindar essas áreas. Abraham Wald apontou o erro: os aviões atingidos naquelas áreas voltaram — devia-se blindar exatamente onde os que voltaram não tinham furos, porque quem levou tiro ali caiu. Toda pesquisa respondida só por quem quis responder tem o mesmo problema: os dados que faltam são justamente os que mudariam a conclusão.

Módulo 4 · 16h

Inferência: sinal vs ruído

Testes, intervalos e o que “significativo” significa — e não significa. O coração da disciplina.

Checklist

7 tópicos

0/7
SE NADA TIVESSE MUDADO, OS RESULTADOS CAIRIAM ASSIM H₀: “nada mudou” o resultado mais provável se a hipótese nula for verdade o que você mediu 3,4% em vez de 3,1% p-valor = esta área Pequena (< 5%) → “dificilmente foi acaso”: rejeita-se o tédio. Grande → o acaso explica bem: nada a concluir (o que não é o mesmo que “não mudou”).
O p-valor responde uma pergunta estranha — e só ela. “Se nada estivesse acontecendo, qual a chance de eu ver um resultado tão extremo quanto este?” Ele não é a probabilidade de você estar certo, nem a de a hipótese ser verdadeira, nem o tamanho do efeito. Um p de 0,04 com 30 visitantes e um p de 0,04 com 30 mil dizem coisas muito diferentes sobre relevância prática — e é essa distinção, entre significância estatística e importância real, que o módulo 4 precisa deixar gravada.
4.4 · os dois erros

Tipo I e tipo II

Tipo I: gritar que mudou quando não mudou — você troca o site inteiro por causa de ruído. Tipo II: não perceber uma mudança real — você descarta uma melhoria boa. Escolher o nível de significância é escolher qual dos dois erros você prefere cometer; não existe teste que evite os dois.

4.7 · p-hacking

Se você testar 20 coisas, uma “dá certo”

A 5% de significância, uma em cada vinte comparações aleatórias parece significativa por puro acaso. Testar vinte variações e reportar a vencedora é fabricar resultado sem mentir em nenhum número. A defesa é decidir antes o que vai medir — e contar quantas comparações foram feitas.

Módulo 5 · 12h

Relações + capstone

Correlação, regressão, e um dashboard estatístico da sua prática — com regra de decisão escrita antes de olhar o número.

Checklist

4 tópicos

0/4
calor o confundidor: a causa comum que ninguém mediu sorvete vendido afogamentos causa causa correlação forte (r = 0,9) — e nenhuma causa a outra proibir sorvete não salvaria ninguém
Correlação é uma pergunta, não uma resposta. Duas séries que sobem juntas podem ter uma causando a outra, a segunda causando a primeira, uma terceira causando as duas (o confundidor), ou nada além de coincidência. A frase inteira do módulo 5 é: quando encontrar uma correlação, procure o calor. No seu caso concreto — “publiquei mais e vendi mais” — o confundidor costuma ser a estação, a campanha que rodou junto, ou o simples fato de você estar mais ativo em tudo naquele mês.

O capstone em uma frase: um painel das suas métricas reais onde, ao lado de cada número, esteja escrito o que precisaria acontecer para você concluir que mudou. Escrever a regra de decisão antes de ver o resultado é o que separa medir de se enganar com aparência de rigor.

20 termos, em ordem de aparição

Glossário

Os termos que esta nota (e o semestre) usam como se você já os conhecesse. Ler de cima a baixo é uma miniatura do curso.

20 termos
TermoO que é, em uma linha
VariávelQualquer característica que se mede ou registra: idade, cidade, valor da compra — o átomo dos dados.
Média / mediana / modaTrês formas de dizer “o típico”: soma÷total, o valor do meio, o mais frequente — e cada uma mente em situações diferentes.
Desvio padrãoO quanto os dados se espalham em torno da média — duas turmas com média 7 são mundos diferentes se uma varia de 6 a 8 e outra de 2 a 10.
DistribuiçãoO formato do conjunto: quais valores aparecem e com que frequência — visualizável como o perfil de um histograma.
OutlierUm valor extremo e raro que distorce médias — o bilionário que entra no bar e “enriquece” a média de todos.
ProbabilidadeA medida da chance de algo, de 0 (impossível) a 1 (certo) — a linguagem formal da incerteza.
Probabilidade condicionalA chance de A dado que B aconteceu — e a fonte do erro mais comum da área: P(A dado B) não é P(B dado A).
Valor esperadoA média ponderada dos resultados possíveis pelo peso das suas chances — o preço justo de uma aposta, o núcleo de decidir sob risco.
População vs amostraTodo o universo que interessa vs o pedaço que você conseguiu medir — quase toda estatística é inferir o primeiro a partir do segundo.
ViésQualquer distorção sistemática na coleta que faz a amostra não representar a população — pesquisa de satisfação respondida só por quem reclamou.
Distribuição normalO “sino”: o formato que surge naturalmente quando muitos fatores pequenos se somam — e a base matemática da inferência.
Erro padrãoO quanto o resultado de uma amostra tende a variar se você repetisse a coleta — a régua da incerteza amostral.
InferênciaO salto formal de “vi isso na amostra” para “posso afirmar isso do todo” — com honestidade sobre a margem de erro.
Hipótese nula (H₀)A suposição de que nada mudou / não há efeito — o tédio que os dados precisam derrubar para você afirmar algo.
p-valorA probabilidade de ver um resultado tão extremo quanto o observado se nada estivesse acontecendo — baixo = suspeite do tédio; não é “a chance de estar certo”.
Intervalo de confiançaA faixa dentro da qual o valor real provavelmente está — a forma honesta de reportar uma estimativa.
Significância estatística“Dificilmente foi acaso” — que não é o mesmo que “importa na prática”: um efeito minúsculo pode ser significante e irrelevante.
Teste A/BO experimento controlado do mundo digital: duas versões, público dividido ao acaso, e a inferência decide se a diferença é real.
CorrelaçãoDuas variáveis que se movem juntas — o que não prova que uma causa a outra.
RegressãoO modelo que desenha a melhor reta (ou curva) através dos dados para descrever e prever uma relação.
Onde a conta vira decisão

Laboratório

A ferramenta

Google Sheets

A planilha que você já usa — o mesmo laboratório de Matemática para Negócios. Ela tem todas as funções estatísticas do curso (AVERAGE, MEDIAN, STDEV, CORREL, gráficos e histogramas): a estatística acontece nela, não na calculadora.

Para começar

Uma planilha por módulo, com dados seus

Alimentada com dados reais seus — as métricas do site/Instagram da prática, gastos domésticos, hábitos registrados. Dado inventado não ensina leitura; dado seu, sim.

O ato recorrente — a regra do laboratório: todo conceito estudado é reproduzido na planilha com dados reais antes de ser marcado no checklist. Estudou desvio padrão → calcula o das suas métricas e escreve uma frase interpretando. Estudou intervalo de confiança → constrói um sobre uma taxa sua. A pergunta-teste de cada sessão: “que decisão essa conta informaria?” — se não há resposta, a conta foi ritual, não estatística. O acúmulo dessas planilhas converge para o capstone 5.4.

O que ler, ver e praticar

Recursos

RecursoServe a
Livro principal: Estatística: o que é, para que serve, por que importa (Charles Wheelan)Mód. 1–4 intuição antes de fórmula
Livro de apoio: OpenIntro Statistics (gratuito, openintro.org)Mód. 3–5 rigor e exercícios
Vídeo: StatQuest (Josh Starmer) — playlists Statistics FundamentalsMód. 3–5 um vídeo por tópico
Vídeo: Khan Academy Estatística (PT-BR)Mód. 1–2 fundamentos
Apêndice

Plano oficial

Plano de ensino ainda não disponível — colar aqui quando chegar e mapear: tópico oficial → código revisado; o que cai em prova; o que o plano omite.

Triagem antecipada

Aprofundar na leitura, satisfazer no cálculo manual

Tabelas de z e contas à mão ficam em nível de prova — a planilha calcula; o seu trabalho é interpretar. Risco previsível do curso: parar na descritiva e correr pela inferência, exatamente o inverso do valor; se acontecer, o módulo 4 daqui é o resgate.

Alavanca de projeto

Dataset seu, nunca inventado

Qualquer trabalho da disciplina aponta para o capstone 5.4 — as métricas reais da sua prática (Metrics Framework do DxE) em vez de dataset de exemplo.

← todas as disciplinas
DCEUNDB · ADS3º período

Modelagem de Processos de TItornar visível o fluxo que o negócio executa sem perceber

68h assumidas 5 módulos 29 tópicos nunca ouviu falar de BPMN? comece aqui → bpmn.io no laboratório veredito: profundidade média

A promessa: formado por esta disciplina, você enxerga o processo invisível dentro de qualquer negócio e o torna visível, discutível e melhorável em um diagrama — a habilidade de transformar “como as coisas funcionam aqui” em um mapa que todos leem igual.

Carga horária no padrão UNDB; ajustar quando o plano de ensino chegar.

Módulo zero · para quem nunca viu isso antes

Do zero, sem jargão

Esta disciplina tem o nome mais corporativo do semestre e o conteúdo mais imediatamente útil. Ela ensina a desenhar como o trabalho realmente acontece — e, feito isso, a enxergar onde ele emperra. Vale para uma empresa, para um freelancer e para a sua própria rotina.

1. O que é um processo

Um processo é uma sequência repetível de atividades que transforma uma entrada em algo de valor para alguém. Pedido de pizza: entra a fome do cliente, saem uma pizza entregue e um pagamento. Contratação: entra uma vaga aberta, sai uma pessoa trabalhando. Nada de misterioso — a novidade é olhar para isso como um objeto que pode ser desenhado, medido e melhorado.

entrada o pedido Registrar pedido Preparar a pizza Entregar ao cliente saída: pizza na mesa handoff muda de mão aqui — é onde processos quebram atividades: o que se faz, verbo no infinitivo
Todo processo tem esta forma. O que muda é o tamanho e o número de caminhos possíveis. Note o ponto marcado: a passagem de mão — da cozinha para a entrega, do vendedor para o financeiro, de você para o cliente. Estatisticamente é ali que o trabalho para, se perde e volta; por isso um diagrama que mostra quem faz cada coisa vale muito mais que uma lista de passos.

2. Por que desenhar, se todo mundo já sabe como funciona

Porque ninguém sabe. Cada pessoa conhece o próprio pedaço e supõe o resto. Peça a três pessoas de uma empresa que descrevam o mesmo processo e você receberá três processos diferentes — todos sinceros. O diagrama não documenta um consenso: ele o produz, ao forçar as divergências para a superfície.

processo

Repetível, com fim previsto

“Atender um pedido.” Acontece muitas vezes, sempre com a mesma forma geral. É isto que se modela.

projeto

Único, com começo e fim

“Lançar o novo site.” Acontece uma vez. Não se modela como processo — se planeja como projeto.

procedimento

O passo a passo de uma atividade

“Como emitir a nota fiscal.” É o zoom dentro de uma caixinha do processo — instrução, não fluxo.

3. O par que organiza a disciplina inteira: AS-IS e TO-BE

AS-IS é o processo como é hoje, com todos os defeitos reais — inclusive os constrangedores. TO-BE é o processo como deveria ser, depois do redesenho. A tentação de todo iniciante é pular direto para o TO-BE, porque é mais agradável desenhar o ideal. É também a forma mais garantida de propor uma solução para um problema que não existe.

A regra de ouro do ofício: mapeie o real antes de desenhar o ideal, e valide o mapa com quem executa — nunca só com quem gerencia. O processo narrado pela gerência é o que deveria acontecer; o processo real inclui os atalhos, os retrabalhos e o WhatsApp paralelo que fazem a coisa funcionar apesar do desenho oficial.

Por que esta disciplina importa

Ponte com a trajetória

Esta disciplina é, disfarçada, uma ferramenta central da sua prática — a Varredura é levantamento de processo (como esse negócio capta, atende, entrega?), e o discovery de qualquer projeto é modelagem antes do build. É também o núcleo do ofício de analista de sistemas: quem modela o processo define o sistema. Parente direta da sua arquitetura de informação: IA estrutura conteúdo; modelagem de processos estrutura fluxo.

Veredito: profundidade média com recorte próprio — dominar BPMN prático e entrevista de levantamento; deixar a burocracia de frameworks como noção.

68 horas, cinco módulos

Currículo revisado

Mód.HorasTemaSentido
112hPensamento por processosver o negócio como fluxos, não como departamentos
220hBPMN na práticaa língua franca de desenhar processo — lida e escrita
312hLevantamento: descobrir o processo realentrevistar, observar e mapear o que acontece de fato
412hAnálise e redesenhoachar gargalo, desperdício e ponto de automação
512hCapstone: processo de um negócio realmapear AS-IS e propor TO-BE de um processo da sua prática

Como usar: siga o checklist na ordem dos módulos. Regra de laboratório: nenhuma semana sem diagrama.

Módulo 1 · 12h

Pensamento por processos

Ver o negócio como fluxos, não como departamentos — a virada de perspectiva que o resto da disciplina pressupõe.

Checklist

6 tópicos

0/6

1.5 — o conceito mais rentável do módulo: o dono do processo. Departamentos têm chefes; processos atravessam departamentos — e quase nunca têm dono. Quando ninguém responde pelo fluxo inteiro, cada área otimiza o próprio pedaço e o cliente espera na costura entre elas. Perguntar “quem é o dono deste processo?” numa reunião é, com frequência, a pergunta mais reveladora que um analista pode fazer.

Módulo 2 · 20h

BPMN na prática

A língua franca de desenhar processo — lida e escrita. O módulo mais longo do currículo, e com razão: fluência aqui é o que a disciplina entrega.

Checklist

9 tópicos

0/9
EVENTO algo que acontece: começa (linha fina) ou termina (grossa) ATIVIDADE Emitir proposta algo que se faz — verbo + objeto, nunca substantivo GATEWAY × onde o fluxo decide: exclusivo (ou/ou) ou paralelo (os dois) FLUXOS sequência: mesma casa mensagem: entre casas (empresa ↔ cliente) Com estes quatro símbolos você lê 90% dos diagramas BPMN do mundo. O resto da notação são variações destes — e quase toda equipe usa só este núcleo.
BPMN é pequeno onde importa. A notação completa tem dezenas de símbolos e quase ninguém os usa; a fluência real está em quatro formas e no rigor de nomeá-las bem. Erro nº 1 dos iniciantes: gateway sem pergunta escrita — um losango sem “aprovado?” obriga cada leitor a adivinhar o critério, que é exatamente o que o diagrama existia para eliminar.
CLIENTE pede orçamento Avaliar proposta aprova e assina PRÁTICA DxE ATENDIMENTO ENTREGA Fazer Varredura × vale proposta? Emitir proposta não — arquiva sim Iniciar engajamento cliente ativo contrato assinado
As raias são a parte que muda conversas. Um fluxograma comum mostra o que acontece; um diagrama com piscinas e raias mostra quem faz e onde o trabalho troca de mãos — e é ao ver as próprias setas cruzando três raias que uma equipe entende por que o cliente espera cinco dias. Repare também nos dois tipos de seta: a cheia é sequência dentro da mesma organização, a tracejada é mensagem cruzando a fronteira. Confundir as duas é o erro de notação mais frequente do módulo.
Módulo 3 · 12h

Levantamento: descobrir o processo real

Entrevistar, observar e mapear o que acontece de fato — não o que dizem que acontece.

Checklist

5 tópicos

0/5
3.2 · o roteiro que funciona

Pergunte pelo caso, não pelo processo

“Como funciona o atendimento?” gera a versão oficial. “Me conta o último pedido que você atendeu — o que chegou primeiro, o que você fez, para quem mandou?” gera o processo real. E então: “e quando dá errado, o que acontece?” — porque o caminho da exceção costuma ser metade do trabalho e nunca aparece no manual.

3.3 · o gap dito-feito

Três processos, sempre

Existe o processo documentado (o manual), o narrado (o que as pessoas dizem que fazem) e o executado (o que de fato acontece, com atalhos e planilhas paralelas). Modelar o primeiro é perder tempo; modelar o terceiro é o serviço. Observar meia hora vale três entrevistas.

Módulo 4 · 12h

Análise e redesenho

Achar gargalo, desperdício e ponto de automação — e saber quando automatizar só acelera o caos.

Checklist

5 tópicos

0/5
O QUE O CLIENTE ESPERA · LEAD TIME 5 dias úteis, do pedido ao serviço entregue O QUE É TRABALHO DE VERDADE · TEMPO DE CICLO 2h40 somadas — 2% do tempo total gargalo: 3 dias na fila de aprovação registrar analisar executar Acelerar quem trabalha economiza minutos. Atacar a fila economiza dias.
A diferença entre as duas barras é o processo inteiro esperando. Lead time é o relógio do cliente; tempo de ciclo é o relógio de quem trabalha. Em processos administrativos reais a razão costuma ser brutal — 2% de trabalho, 98% de fila — e é por isso que a primeira pergunta de redesenho nunca é “como fazer mais rápido?”, e sim “por que isso está parado?”. As heurísticas de 4.3 seguem essa ordem: eliminar a espera, combinar aprovações, paralelizar o que não depende, e só então automatizar.

4.4 — o aviso que vale a disciplina inteira: automatizar um processo ruim produz um processo ruim mais rápido, com o defeito agora congelado em código e caro de mudar. Redesenhe primeiro, automatize depois. É também a resposta profissional para o cliente que chega pedindo “um sistema”: antes de construir, mapeie — e, com frequência, o mapa mostra que metade do sistema pedido não precisa existir.

Módulo 5 · 12h

Capstone: processo de um negócio real

Mapear o AS-IS e propor o TO-BE de um processo da sua prática — um documento apresentável a cliente.

Checklist

4 tópicos

0/4
MÓD. 3Levantarentrevista com quem executa + observação do caso real
MÓD. 2Desenhar o AS-IScom piscinas, raias e os caminhos de exceção
MÓD. 4Medirlead time, tempo de ciclo e onde o trabalho para
MÓD. 4Redesenhareliminar, combinar, paralelizar — automatizar por último
MÓD. 5ApresentarTO-BE com o ganho estimado, em linguagem de dono do negócio

Bônus estratégico: o TO-BE de um processo comercial é literalmente um entregável vendável. O capstone desta disciplina não é exercício escolar — é a primeira versão de um serviço que você pode oferecer a clientes.

16 termos, em ordem de aparição

Glossário

Os termos que esta nota (e o semestre) usam como se você já os conhecesse. Ler de cima a baixo é uma miniatura do curso.

16 termos
TermoO que é, em uma linha
ProcessoUma sequência repetível de atividades que transforma uma entrada em algo de valor para alguém — “do pedido ao produto entregue”.
BPMBusiness Process Management: a disciplina de gerenciar o negócio através dos seus processos — mapear, medir, melhorar, continuamente.
ModelagemO ato de desenhar um processo num diagrama padronizado, tornando visível (e discutível) o que antes só existia na cabeça das pessoas.
BPMNBusiness Process Model and Notation: a notação-padrão mundial para desenhar processos — um vocabulário visual fixo que todos leem igual.
AS-IS / TO-BEO par central do ofício: o processo como é hoje (com os defeitos reais) vs como deveria ser (o redesenho proposto).
EventoNos diagramas, os círculos: algo que acontece — o processo começa, termina, ou é interrompido por algo (um prazo, uma mensagem).
AtividadeOs retângulos: algo que se faz — “emitir proposta”, “aprovar pedido”.
GatewayOs losangos: os pontos de decisão ou divisão do fluxo — “aprovado? sim/não” — onde mora a lógica do processo.
Piscina (pool) / raia (lane)A moldura que divide o diagrama por responsável: cada raia é um ator (vendedor, financeiro, cliente) — mostra quem faz o quê.
Fluxo de sequência / de mensagemAs setas: sequência liga passos dentro de uma organização; mensagem cruza a fronteira entre organizações (empresa ↔ cliente).
AtorQualquer pessoa, papel ou sistema que executa parte do processo.
HandoffO momento em que o trabalho passa de uma mão para outra — estatisticamente, onde os processos mais quebram.
LevantamentoA investigação que descobre o processo real (entrevista, observação) — porque o processo narrado nunca é o executado.
GargaloO ponto do processo que limita a vazão do todo — onde o trabalho se acumula e espera.
RetrabalhoTrabalho refeito por erro ou falta de informação na primeira vez — o desperdício mais comum e mais invisível.
Lead time / tempo de cicloQuanto o cliente espera de ponta a ponta vs quanto tempo de trabalho efetivo o processo contém — a diferença entre os dois é espera.
Fluência vem de produzir, não de ler

Laboratório

A ferramenta

bpmn.io

Um editor gratuito de diagramas BPMN que roda direto no navegador, sem instalar nada — o Camunda Modeler é a mesma coisa em versão desktop, se preferir. Você arrasta eventos, atividades e gateways para a tela e conecta; a notação correta é imposta pela própria ferramenta.

Para começar

A pizza, hoje

Abrir demo.bpmn.io, desenhar o processo “pedir uma pizza” (do pedido à entrega, com um gateway “tem o sabor? sim/não”) e exportar o arquivo. Pronto: primeiro diagrama existe. Guarde todos numa pasta bpmn/ — a coleção é o registro do semestre.

O ato recorrente — a regra do laboratório: nenhuma semana de estudo termina sem um diagrama novo ou melhorado. Tópico de notação estudado → aplicado num processo real que você conhece (rotina da casa, fluxo de um comércio próximo, o comercial da prática DxE). Tópico de análise estudado → volte a um diagrama seu e marque gargalos e handoffs. A fluência em BPMN vem exatamente como fluência em idioma: produção regular, não leitura acumulada.

O que ler, ver e praticar

Recursos

RecursoServe a
Livro principal: Real-Life BPMN (Jakob Freund & Bernd Rücker)Mód. 24 BPMN como se usa, não como se decora
Livro de apoio: BPM CBOK (ABPMP — consulta pontual, não ler inteiro)Mód. 13 o vocabulário oficial que a prova vai usar
Vídeo: Camunda Academy — BPMN tutorials (gratuito)Mód. 2 em ordem
Apêndice

Plano oficial

Plano de ensino ainda não disponível — colar aqui quando chegar e mapear: tópico oficial → código revisado; o que cai em prova; o que o plano omite.

Triagem antecipada

Profundidade média, com recorte

Fluência em BPMN + levantamento valem ouro para a prática; frameworks de governança (ITIL, COBIT — se o curso puxar para lá) ficam em nível de prova, sem culpa. Risco previsível: a disciplina virar decoreba de notação ou teoria de BPM sem modelar nada — o antídoto é o laboratório: nenhuma semana sem diagrama.

Alavanca de projeto

Um entregável que se vende depois

O trabalho da disciplina aponta para o capstone 5.x — o processo comercial da própria prática DxE mapeado de verdade. Bônus: o TO-BE desse processo é literalmente um entregável que você poderá vender a clientes.

← todas as disciplinas
DCEUNDB · ADS3º período

Arquitetura Moderna de Computadoreso que a máquina faz de verdade quando seu código roda

68h assumidas 5 módulos 28 tópicos o computador ainda é caixa-preta? comece aqui → Little Man Computer no laboratório veredito: satisfazer

A promessa: formado por esta disciplina, você sabe o que a máquina faz de verdade quando seu código roda — por que memória tem hierarquia, o que torna algo lento ou rápido, e o computador deixa de ser caixa-preta.

Carga horária no padrão UNDB; ajustar quando o plano de ensino chegar.

Módulo zero · para quem nunca viu isso antes

Do zero, sem jargão

Todo mundo usa computador; quase ninguém sabe o que há dentro. A boa notícia é que a estrutura essencial foi desenhada em 1945 e continua a mesma — três peças e um caminho entre elas. Entendido isso, o resto do semestre é detalhe.

1. Um computador tem três partes, e só

CPU unidade de controle ULA — faz as contas registradores quem executa MEMÓRIA o programa + os dados, no mesmo lugar quem lembra ENTRADA / SAÍDA teclado, tela, disco, rede quem conversa com o mundo BARRAMENTO — a estrada entre as três O desenho de 1945 que ainda descreve o computador na sua mesa e o servidor na nuvem.
A ideia que fundou a computação moderna: guardar o programa na mesma memória que os dados. Antes disso, mudar o que a máquina fazia significava recabeá-la fisicamente. Depois disso, um programa passou a ser apenas mais um conteúdo na memória — e é por isso que um mesmo computador roda um navegador, um jogo e um compilador sem mudar um parafuso.

2. Por baixo de tudo: só liga e desliga

O computador não conhece letras, cores ou números — conhece tensão alta e tensão baixa, que chamamos de 1 e 0. Um bit é um desses; um byte são oito, e com oito bits dá para representar 256 coisas diferentes. Toda a montanha (o texto que você lê, a foto, o vídeo, o código) é combinação disso — o que muda é a convenção de leitura: os mesmos 8 bits são o número 65 ou a letra “A” dependendo do que o programa espera encontrar ali.

E como “ligado/desligado” vira raciocínio? Por portas lógicas: circuitos minúsculos que respondem “1” conforme uma regra — a porta E só liga se as duas entradas estiverem ligadas; a OU liga se qualquer uma estiver. Junte algumas e você tem um somador. Junte bilhões e você tem uma CPU. Não há nada além disso lá dentro.

3. O motivo pelo qual isso te interessa como dev

consequência 1

Onde o dado está importa mais que a velocidade do chip

Buscar um valor no cache do processador ou na memória principal é a diferença entre pegar algo na sua mesa e ir até outro andar. É o módulo 3, e é o de maior retorno da disciplina.

consequência 2

“Mais núcleos” não é “mais rápido”

Oito núcleos executam oito coisas ao mesmo tempo — se o seu problema puder ser dividido. Muitos não podem, e é por isso que o JavaScript resolve concorrência com um event loop em vez de threads.

consequência 3

0.1 + 0.2 não dá 0.3

Não é bug do JavaScript: é como frações viram binário. O motivo está no módulo 1 — e saber isso evita você usar float para dinheiro.

Aviso honesto sobre esta disciplina. Ela é a de menor retorno imediato entre as cinco do semestre — mas o que ela dá é permanente: a intuição de por que as coisas são rápidas ou lentas. Estude para entender, não para decorar nomenclatura de barramento e gerações de hardware; isso fica na prova e é esquecido sem culpa.

Por que esta disciplina importa

Ponte com a trajetória

Para um dev web, esta é a disciplina de fundação invisível: ela não vira entregável, mas explica os porquês que você vai encostar a vida toda — por que cache importa, o que é um processo, por que paralelismo é difícil, o que a nuvem virtualiza. A ponte é real, porém indireta; a intuição vale mais que o detalhe.

Veredito: satisfazer institucionalmente, com um núcleo conceitual escolhido a dedo — a disciplina do semestre onde menos horas extras devem ser gastas.

68 horas, cinco módulos

Currículo revisado

Mód.HorasTemaSentido
114hDo bit à máquinacomo lógica vira circuito e circuito vira computador
216hCPU: o ciclo que executa tudoo que um processador realmente faz com seu código
316hMemória: a hierarquia que domina a performancepor que “onde o dado está” importa mais que “quão rápido o chip é”
412hEntrada/saída e o computador modernodiscos, barramentos, GPU e o caminho até a nuvem
510hA ponte para o softwareo que disso aparece no seu código de todo dia

Como usar: siga o checklist na ordem dos módulos. O módulo 3 (memória) é o de maior retorno por hora; se só houver tempo para um, é ele.

Módulo 1 · 14h

Do bit à máquina

Como lógica vira circuito e circuito vira computador — a subida do 0/1 até a máquina inteira.

Checklist

6 tópicos

0/6
1.2 — o clássico que assusta iniciantes
// no console de qualquer navegador
0.1 + 0.2
→ 0.30000000000000004

// e por isso, nunca:
const total = preco * quantidade;  // em R$

// e sim, centavos como inteiro:
const totalCentavos = precoCentavos * quantidade;
por que acontece

1/10 é dízima em binário

Em decimal, 1/3 = 0,333… não cabe em nenhum número finito de casas. Em binário, quem não cabe é 1/10: 0,0001100110011… repetindo para sempre. O computador guarda o mais próximo que cabe em 64 bits, e dois “mais próximos” somados dão um terceiro número muito próximo — mas não idêntico — de 0,3.

Não é defeito do JavaScript: é o padrão IEEE 754, o mesmo em Python, Java e C. A lição prática é curta e vale dinheiro: nunca represente valores monetários em ponto flutuante — use inteiros de centavos, ou o tipo numeric do banco.

Módulo 2 · 16h

CPU: o ciclo que executa tudo

O que um processador realmente faz com seu código: repetir três passos, bilhões de vezes por segundo.

Checklist

7 tópicos

0/7
MEMÓRIA 90: LDA 30 91: ADD 31 92: STA 32 93: HLT contador de programa aponta a próxima linha 1. BUSCAR ler a instrução 2. DECODIFICAR o que ela manda fazer 3. EXECUTAR a ULA faz avança o contador e recomeça 3 bilhões de vezes por segundo DENTRO DA CPU registradores as “mãos” da CPU ULA soma e compara unidade de controle rege o ciclo Todo if, todo for, toda animação da sua página é isto, repetido — e nada além disso.
É este o batimento cardíaco da máquina. Um clock de 3 GHz significa três bilhões desses ciclos por segundo. Duas consequências que a disciplina explora: o pipeline (começar a buscar a próxima instrução enquanto a atual ainda executa — linha de montagem, não fila) e o fim do crescimento de GHz por calor, que levou a indústria a colocar vários núcleos no lugar de um núcleo mais rápido. O laboratório desta nota — o Little Man Computer — é exatamente este desenho, animado na tela, com só dez instruções.
Módulo 3 · 16h · o de maior retorno

Memória: a hierarquia que domina a performance

Por que “onde o dado está” importa mais que “quão rápido o chip é”. Se você só estudar um módulo desta disciplina, estude este.

Checklist

6 tópicos

0/6
MEMÓRIA TAMANHO TÍPICO LATÊNCIA NA ESCALA HUMANA registrador bytes 0,3 ns pegar na própria mão cache L1 64 KB 1 ns abrir a gaveta da mesa cache L2 / L3 8 MB 10 ns levantar e ir à estante RAM 16 GB 100 ns ir à sala ao lado SSD 1 TB 100 µs ir a outro bairro disco rígido 4 TB 10 ms viajar 1.000 km Do topo à base: cem milhões de vezes mais lento — e é o mesmo dado.
Aqui está o motivo de metade das otimizações do mundo. A pirâmide existe porque memória rápida é cara e memória grande é lenta; a saída foi empilhar as duas coisas e apostar que o próximo dado necessário estará perto do último — a localidade. Duas consequências diretas no seu código: percorrer um array na ordem é muito mais rápido que pular posições ao acaso (os vizinhos vêm juntos para o cache), e é por isso que arrays batem listas ligadas na prática, mesmo quando a tabela de complexidade diz o contrário.
O CÓDIGO function soma() { const n = 5; const lista = [1,2,3]; } MEMÓRIA DO PROGRAMA n = 5 lista → (endereço) PILHA — automática some quando a função termina [1, 2, 3] { … } MONTE (heap) · objetos o valor simples cabe na própria pilha a variável guarda só o endereço — é isso que “referência” significa quando ninguém mais aponta para o objeto, o garbage collector recolhe
Isto explica dois mistérios do JavaScript de uma vez. Por que copiar um objeto “não copia” (você copiou o endereço, não o conteúdo) e por que comparar dois objetos iguais dá false (endereços diferentes). E explica o garbage collector: como o monte não se limpa sozinho, o runtime periodicamente procura o que ninguém mais aponta e recolhe — trabalho que existe justamente porque a memória é finita e endereçada.
Módulo 4 · 12h

Entrada/saída e o computador moderno

Discos, barramentos, GPU e o caminho até a nuvem — o que existe entre o seu clique e o servidor.

Checklist

5 tópicos

0/5
4.1 · interrupção

A CPU não fica perguntando

Se o processador tivesse de checar “apertaram alguma tecla?” a cada ciclo, gastaria a vida perguntando. Em vez disso o hardware interrompe: o teclado avisa, a CPU pausa o que fazia, atende e volta. É o mesmo padrão dos callbacks e event listeners que você escreve — o navegador não pergunta se houve clique; ele é avisado.

4.2 · GPU

Muitos núcleos burros vencem poucos espertos

A CPU tem poucos núcleos muito capazes; a GPU tem milhares de núcleos simples que fazem a mesma conta em muitos dados ao mesmo tempo. Serve para pixels — e, por acidente feliz, para as multiplicações de matrizes que treinam modelos de IA. É por isso que a placa de vídeo virou o hardware mais disputado do mundo.

4.4 · a nuvem, sem mistério

Fingir máquinas dentro da máquina

Um servidor físico roda dezenas de “computadores” isolados. Máquina virtual = um sistema operacional inteiro fingido, pesado e muito isolado. Contêiner = só o seu programa e suas dependências, compartilhando o sistema do hospedeiro — leve e rápido de subir. Quando você faz deploy “na nuvem”, quase sempre é um contêiner que sobe.

Módulo 5 · 10h

A ponte para o software

O que disso aparece no seu código de todo dia — o módulo que converte a disciplina em intuição utilizável.

Checklist

4 tópicos

0/4
Se o gargalo é…O sintomaO que adianta
CPU-boundprocessador a 100%, tudo travado enquanto calculaalgoritmo melhor (é aqui que Estrutura de Dados paga), ou dividir entre núcleos
Memory-boundprocessador ocioso esperando dado chegarestruturas contíguas, percorrer na ordem, caber no cache
I/O-boundtudo parado esperando disco, rede ou banconão otimizar o código: reduzir idas, agrupar consultas, cachear resposta

Esta tabela é a disciplina inteira condensada. Quase todo desenvolvedor iniciante otimiza código CPU-bound quando o problema era I/O — reescreve um laço para ganhar milissegundos enquanto uma consulta ao banco custa segundos. Saber em qual dos três mundos o seu gargalo mora, antes de mexer em qualquer linha, é o retorno prático de estudar arquitetura.

5.4 — o teste de que a caixa-preta abriu: escreva, com suas palavras, o caminho completo de um clique até o pixel — evento, interrupção, código JS, memória, requisição de rede, servidor, resposta, renderização. Se você consegue narrar isso sem lacunas, a disciplina cumpriu o que prometia; e o texto ainda vira conteúdo publicável da sua prática (diagnóstico técnico em linguagem de dono de negócio).

21 termos, em ordem de aparição

Glossário

Os termos que esta nota (e o semestre) usam como se você já os conhecesse. Ler de cima a baixo é uma miniatura do curso.

21 termos
TermoO que é, em uma linha
Bit / byteA menor unidade de informação (0 ou 1) e o pacote de 8 delas — tudo no computador é feito disso: números, texto, imagem, código.
Binário / hexadecimalOs sistemas de contagem da máquina: base 2 (como os circuitos operam) e base 16 (a abreviação legível que os humanos usam para ela).
Ponto flutuanteO formato com que computadores representam números com vírgula — aproximado por natureza, daí 0.1 + 0.2 ≠ 0.3.
Porta lógicaO bloco elementar dos circuitos: recebe sinais 0/1 e responde 0/1 segundo uma regra (E, OU, NÃO) — bilhões delas compõem uma CPU.
Arquitetura de von NeumannO desenho básico de quase todo computador: processador + memória única (para dados e programa) + entrada/saída, ligados por um barramento.
CPUO processador: o componente que efetivamente executa instruções, uma após a outra, bilhões de vezes por segundo.
RegistradorAs pouquíssimas “mãos” da CPU: minúsculos espaços de memória dentro dela onde os dados ficam durante a operação.
Instrução / assemblyO comando elementar que a CPU entende (“some”, “copie”, “pule”) e a linguagem quase-humana que o representa — todo código seu vira isso.
Ciclo de instruçãoO batimento cardíaco da máquina: buscar a próxima instrução na memória → decodificar → executar → repetir.
ClockO relógio que marca esse batimento — 3 GHz = 3 bilhões de ciclos por segundo.
PipelineA linha de montagem dentro da CPU: várias instruções em estágios diferentes ao mesmo tempo, em vez de uma por vez.
Núcleo (core)Uma CPU completa dentro do chip — “8 núcleos” = 8 executores realmente simultâneos.
CacheMemória pequena e caríssima colada na CPU que guarda o que foi usado há pouco — a diferença entre buscar na gaveta e buscar no depósito.
RAMA memória de trabalho: rápida, ampla, e apagada ao desligar — onde programas e dados vivem enquanto rodam.
Memória virtualA ilusão que o sistema operacional cria de que cada programa tem a memória toda só para si — trocando pedaços com o disco por trás.
Stack / heapAs duas regiões onde as variáveis de um programa vivem: a pilha (organizada, automática) e o monte (flexível, gerenciado — no JS, pelo garbage collector).
BarramentoAs “estradas” internas por onde dados trafegam entre CPU, memória e periféricos.
InterrupçãoO mecanismo pelo qual o hardware avisa a CPU que algo aconteceu (tecla apertada, dado chegou) sem que ela precise ficar perguntando.
GPUO processador de milhares de núcleos simples — feito para fazer a mesma conta em muitos dados ao mesmo tempo (pixels, matrizes, ML).
Sistema operacionalO software que administra a máquina: reparte CPU e memória entre programas e esconde o hardware atrás de abstrações.
Virtualização / contêinerFingir máquinas dentro da máquina: a técnica que faz a nuvem existir — um servidor físico rodando dezenas de “computadores” isolados.
Uma CPU inteira, em miniatura

Laboratório

A ferramenta

Little Man Computer (LMC)

Um computador de brinquedo que roda no navegador — busque “LMC simulator”; a versão de Peter Higginson é a clássica. Tem só 100 endereços de memória e cerca de 10 instruções, e mostra na tela cada passo do ciclo buscar-decodificar-executar. É a CPU inteira, visível.

Para começar

Somar dois números, em câmera lenta

Abrir o simulador e rodar o programa de exemplo (somar dois números digitados). Assistir à execução passo a passo, vendo o acumulador e o contador de programa mudarem a cada ciclo.

O ato recorrente — a regra do laboratório: esta disciplina é conceitual, então o laboratório tem dois atos, ambos leves. (1) No módulo 2, escrever 3–4 programinhas no LMC (somar, comparar, um laço que conta até 10) — sentir na mão o que “a CPU executa instruções” significa. (2) Nos demais módulos, o ato é explicar por escrito: cada módulo termina com um parágrafo seu respondendo “o que eu entendo agora que não entendia antes?”. Eles acumulam para o mini-capstone 5.4. Aqui, a explicação própria é o experimento: se você consegue narrar o caminho do clique ao pixel, a caixa-preta abriu.

O que ler e ver

Recursos

RecursoServe a
Livro principal: Code: The Hidden Language of Computer Hardware and Software (Charles Petzold, 2ª ed.)Mód. 1–2 a melhor abertura de caixa-preta já escrita
Livro de apoio: Organização Estruturada de Computadores (Tanenbaum)Mód. 3–4 consulta pontual (e o que a prova citar)
Vídeo: Crash Course Computer Science (eps. 1–21, legendado)espinha inteira um episódio por tópico
Apêndice

Plano oficial

Plano de ensino ainda não disponível — colar aqui quando chegar e mapear: tópico oficial → código revisado; o que cai em prova; o que o plano omite.

Triagem antecipada

Satisfazer institucionalmente

É a disciplina do semestre para não gastar horas extras — o retorno marginal para um dev web é menor que o de Estrutura de Dados, Banco ou Estatística. O corte inteligente: intuição de memória/cache e o ciclo da CPU valem para sempre; detalhe de circuito e microarquitetura, nível de prova e adeus sem culpa. Risco previsível: decoreba de nomenclatura de barramento e gerações de hardware — não convertem em nada; deixe na prova.

Alavanca de projeto

“Por que o site fica lento”

Se houver trabalho ou seminário, aponte para o 5.4 (“o que acontece quando meu código roda”) ou para “por que o site fica lento” — temas que rendem apresentação boa e viram conteúdo publicável da sua prática.