01 / 16
Lógica de Programação · Sem 10 · Aula 2/2

Custo, Otimização
e Padrões

Quanto custa rodar um loop dentro de loop? E como transformar essa estrutura em arte no terminal? Hoje, as duas respostas.

ProfessorGuilherme Antunes CursoEnsino Médio Técnico — Informática Duração100 minutos (2 aulas)
02 / 16
Recap + Objetivos

Hoje você vai.

Na aula passada você aprendeu a montar e controlar loops aninhados. Agora vai descobrir quanto custa rodá-los e fechar a semana com um laboratório de padrões geométricos.

01

Calcular o custo de um algoritmo: O(n²) e O(n)

02

Comparar a eficiência de algoritmos antes da implementação

03

Criar figuras geométricas via loops aninhados

04

Combinar se + loops aninhados para padrões mais complexos

03 / 16
Vamos pensar simples

O que é n? E o que é O(...)?

Antes de se assustar com a palavra "complexidade", vamos por partes. Quando os programadores falam de eficiência, eles usam duas ideias bem simples:

n

Tamanho do problema — quantos itens existem na entrada.

Lista com 10 nomes → n = 10
Lista com 100 nomes → n = 100

O(...)

Quanto cresce o trabalho conforme o problema aumenta.

É uma "etiqueta" que diz se o esforço cresce pouco, médio ou muito quando n aumenta.

🧠 Em uma frase: n é o tamanho da lista; O(...) diz o quanto o algoritmo demora a mais quando essa lista cresce. Vamos ver as 3 formas mais comuns nos próximos slides.
04 / 16
Tipo 1 · Constante

🔹 O(1) — sempre o mesmo trabalho

Não importa se a lista tem 3 nomes ou 1 milhão. O algoritmo faz uma única ação.

nomes = ["Ana", "Carlos", "João"]

print(nomes[0])

Aqui ele só pega o primeiro item da lista. Nada de percorrer tudo.

Como o tempo se comporta

  • 3 nomes → rápido
  • 1.000 nomes → rápido
  • 1.000.000 nomes → rápido também

Sempre 1 ação principal. Por isso: O(1).

05 / 16
Tipo 2 · Linear

🔹 O(n) — cresce junto com a lista

Agora o algoritmo percorre todos os nomes, um por um.

nomes = ["Ana", "Carlos", "João"]

for nome in nomes:
    print(nome)

Cada nome é impresso uma vez. Se a lista cresce, o trabalho cresce na mesma medida.

Como o tempo se comporta

  • 10 nomes → 10 repetições
  • 100 nomes → 100 repetições
  • 1.000 nomes → 1.000 repetições

Cresce junto com n. Por isso: O(n).

06 / 16
Tipo 3 · Quadrático

🔹 O(n²) — loop dentro de loop

Agora entra o loop aninhado: o de dentro roda inteiro para cada volta do de fora.

for i in range(10):
    for j in range(10):
        print(i, j)

10 × 10 = 100 operações. Cada nível multiplica o custo.

Como o tempo se comporta

  • 10 × 10 = 100
  • 100 × 100 = 10.000
  • 1000 × 1000 = 1.000.000

Cresce muito rápido. Por isso: O(n²).

ComplexidadeSe n = 10Se n = 1000
O(1)11
O(n)101.000
O(n²)1001.000.000
07 / 16
Para fixar · Analogia

Imagine alunos apertando mãos 🤝

Mesma sala, mesmas 30 pessoas. Mas duas regras diferentes:

O(n)

Cada aluno cumprimenta só o professor.

30 alunos = 30 cumprimentos

O(n²)

Cada aluno cumprimenta TODOS os outros.

30 × 30 = 900 cumprimentos 😅

🧠 Regra prática: conte os para aninhados. 1 loop → geralmente O(n). 2 loops aninhados → geralmente O(n²). 3 loops → O(n³). E por aí vai.
08 / 16
Mudança de marcha · Laboratório

Agora vamos desenhar com código 🎨

Você já entende o custo dos loops aninhados. Agora vai ver o poder estético deles: criar padrões geométricos no terminal, combinando para aninhados com se.

O segredo

Cada padrão é uma matriz de pixels. Linha por linha, decidimos o que imprimir em cada coluna. O loop interno constrói a linha; o externo avança para a próxima.

*
* *
* * *
* * * *
* * * * *

cada caractere é uma decisão consciente

09 / 16
Colocando em prática · Atividade em grupo

🟡 Organizando o caos

📦 Materiais

  • Computador com ambiente de desenvolvimento
  • Editor de texto ou IDE para pseudocódigo
  • Caderno para rascunhos
  • Caneta

🧭 Passo a passo

  • Leiam com atenção a atividade proposta no roteiro
  • Antes de codar, façam esboços no papel para definir a lógica
  • Identifiquem qual é o loop externo e o interno
  • Implementem, testem e variem o tamanho da figura
⏱ 45 minutos 👥 Grupos de até 5 pessoas
10 / 16
Padrão 1 · Quadrado preenchido

🟢 Quadrado 5×5

Fácil

Mesmo número de colunas em cada linha. Ambos os loops vão de 1 até 5.

for linha in range(1, 6):
    for coluna in range(1, 6):
        print("* ", end="")
    print()

Saída

* * * * *
* * * * *
* * * * *
* * * * *
* * * * *
11 / 16
Padrão 2 · Pirâmide centralizada

🟡 Pirâmide

Médio

Combina dois loops internos: um para os espaços que recuam à esquerda, outro para os asteriscos. Os asteriscos crescem em números ímpares (1, 3, 5, 7, 9) para a figura ficar simétrica.

for linha in range(1, 6):
    for c in range(5 - linha):
        print(" ", end="")     # espaços
    for c in range(2 * linha - 1):
        print("*", end="")     # asteriscos
    print()

Saída

*
***
*****
*******
*********
12 / 16
Padrão 3 · Pirâmide invertida

🟡 Pirâmide invertida

Médio

O inverso da pirâmide do slide anterior: os asteriscos diminuem em números ímpares (9, 7, 5, 3, 1) e os espaços aumentam — o pico aponta para baixo.

for linha in range(1, 6):
    for c in range(linha - 1):
        print(" ", end="")      # espaços
    for c in range(11 - 2 * linha):
        print("*", end="")      # asteriscos
    print()

Saída

*********
*******
*****
***
*
13 / 16
Padrão 4 · Quadrado oco · se + para

🔴 Desafio: Moldura

Desafio

Agora o segredo é combinar loops aninhados com se. Imprima * apenas nas bordas (primeira/última linha, primeira/última coluna) e espaço no meio.

for linha in range(1, 6):
    for coluna in range(1, 6):
        if linha == 1 or linha == 5 or coluna == 1 or coluna == 5:
            print("* ", end="")
        else:
            print("  ", end="")
    print()

Saída

* * * * *
* *
* *
* *
* * * * *

O se decide cada célula: borda ou vazio

14 / 16
Pause e responda

Observe o código. O que ele realmente desenha?

# O que esse código realmente desenha?
for linha in range(1, 6):
    for coluna in range(1, 6):
        print("* ", end="")
    print()
AUm triângulo crescente de 1 a 5 asteriscos
BUm triângulo invertido de 5 a 1 asteriscos
CUma única linha com 25 asteriscos
DUm quadrado 5×5 preenchido por asteriscos ✅
🧠 A pegadinha: ambos os loops vão até 5 (constante). Para virar triângulo, o limite do interno precisaria depender de linha.
15 / 16
Então ficamos assim…

O que aprendemos hoje ✅

  • n e O(...) → n é o tamanho da lista; O(...) diz o quanto o trabalho cresce conforme n aumenta
  • O(1), O(n), O(n²) → constante, linear, quadrática — três níveis de "quanto custa"
  • Conte os loops → 1 loop ≈ O(n); 2 aninhados ≈ O(n²); 3 ≈ O(n³)
  • Padrões geométricos → loops aninhados constroem figuras pixel a pixel
  • Lógica linha por linha → o interno constrói toda a linha antes do externo avançar
  • Limite que varia → quando o interno depende do externo, surgem padrões "que crescem"
📚 Próxima semana

Você vai aprender vetores (arrays) unidimensionais — uma forma de armazenar várias informações em uma única estrutura, e percorrê-las com loops.

16 / 16
Pergunta de fechamento

Para você refletir.

Você passou pela semana inteira de loops aninhados: do conceito ao custo, da teoria à arte no terminal.

❓ Para discutir em dupla

Pense num app que você usa todo dia (Instagram, WhatsApp, Spotify, jogos). Onde ele provavelmente usa loops aninhados? Onde a otimização é mais crítica? E onde um padrão visual aparece na tela?

🧠 Curiosidade: empresas como Google e Netflix gastam milhões só para reduzir o custo Big-O dos seus algoritmos. Cada milissegundo, multiplicado por bilhões de usuários, vira economia gigante.