Um Triângulo de Floyd é um triângulo de números consecutivos de modo que na primeira linha há um número, na segunda dois, na terceira três, e assim consecutivamente. O exemplo abaixo mostra um triângulo de Floyd com 6 linhas.
1
2 3
4 5 6
7 8 9 10
11 12 13 14 15
16 17 18 19 20 21
Desenvolva um programa que receba do usuário o número de linhas e seja impresso na tela o Triângulo de Floyd correspondente.

Passo 1

O que o enunciado pede:
  • Escrever um programa que receba do usuário o número de linhas e imprima na tela o Triângulo de Floyd correspondente.
Informações relevantes do enunciado:
  • O triângulo começa em 1 e os números são consecutivos (ou seja, 1,2,3,\dots).
  • A linha 1 tem 1 número, a linha 2 tem 2 números, a linha 3 tem 3 números, e assim por diante.
  • O enunciado mostrou um exemplo com 6 linhas (peguei esses dados da tabela do enunciado), que seria:
    1
    2 3
    4 5 6
    7 8 9 10
    11 12 13 14 15
    16 17 18 19 20 21
O que o programa deve receber e o que deve produzir:
  • Recebe um inteiro \;n (número de linhas).
  • Imprime n linhas. Na linha i (para i=1,\dots,n) deve imprimir exatamente i números consecutivos.

Passo 2

Ideia do algoritmo (visão geral, sem código ainda):
  • Criaremos uma variável contadora chamada \text{num} que começa em 1. Essa variável guarda o próximo número que será impresso.
  • Vamos repetir para cada linha i de 1 até \;n:
    • Imprimir exatamente i números: imprimir \text{num}, incrementar \text{num}, imprimir o próximo, e assim por diante, i vezes.
    • Após imprimir os i números, quebrar a linha (pular para a linha seguinte).
  • Esse padrão usa dois laços aninhados: um laço externo que controla a linha atual ( i) e um laço interno que imprime os i números dessa linha.
Por que isso funciona:
  • Na linha i queremos exatamente i números. Se o laço interno roda i vezes e cada iteração imprime o próximo número sequencial (mantido em \text{num}), então as contagens ficam corretas:
    • Após linha 1: \text{num} passou de 1 para 2.
    • Após linha 2: \text{num} passou de 2 para 4.
    • E assim por diante — o contador sempre continua de onde parou, produzindo a sequência contínua mostrada no exemplo.
Conceitos que precisamos saber (explicação didática):
  • Variável contadora ( \text{num}): é uma variável que guarda o próximo número a imprimir. Cada vez que imprimimos um número, fazemos \text{num} \leftarrow \text{num} + 1.
  • Laço externo (controla linhas): percorre i = 1,2,\dots,n. Para cada i sabemos quantas vezes o laço interno precisa rodar.
  • Laço interno (imprime os elementos da linha): roda exatamente i vezes e em cada iteração imprime o valor atual de \text{num} e incrementa.
  • Impressão sem pular linha (em Python, por exemplo, usamos um parâmetro para não pular linha ao imprimir) para que os números da mesma linha fiquem lado a lado.

Passo 3

Detalhamento passo a passo com o código (vou usar Python porque é curto e bem legível):
  1. Ler a entrada do usuário: pedir para o usuário digitar o número de linhas e converter para inteiro. Aqui assumimos que o usuário fornece um número inteiro válido (vou mostrar uma pequena verificação).
  2. Inicializar \text{num} = 1.
  3. Fazer o laço externo para i variando de 1 até \;n. Em Python isso é for i in range(1, n+1):.
    • Explicação: range(1, n+1) gera a sequência 1,2,\dots,n. Em muitas linguagens o fim do intervalo é exclusivo, por isso usamos n+1.
  4. Dentro do laço externo, fazer o laço interno for j in range(i): que executa exatamente i iterações (pois range(i) gera 0,1,...,i-1).
    • Em cada iteração do laço interno:
      • Imprimir o valor atual de \text{num} seguido de um espaço (para que os números fiquem separados na mesma linha).
      • Incrementar \text{num} em 1.
  5. Após o laço interno, chamar print() sem argumentos para pular para a próxima linha.
  6. Opcional: tratar n \le 0 imprimindo nada ou uma mensagem amigável.
Vou mostrar o código e explicar linha a linha logo em seguida.
Código em Python (comentado):
try:
    n = int(input("Digite o número de linhas: "))
except ValueError:
    print("Entrada inválida: informe um inteiro positivo.")
    raise SystemExit

if n <= 0:
    print("Informe um número de linhas maior que zero.")
    raise SystemExit

num = 1                       # num é o próximo número a ser impresso, começa em 1
for i in range(1, n + 1):     # i vai de 1 até n (cada i é o número de elementos da linha)
    for j in range(i):        # laço interno: repete i vezes para imprimir i números
        print(num, end=' ')   # imprime o número seguido de um espaço, sem pular linha
        num += 1              # incrementa o contador para o próximo número
    print()                   # quebra de linha ao final da linha i
Explicação das linhas principais:
  • n = int(input(...)): lê o texto digitado e converte para inteiro; input retorna string, int converte.
  • if n <= 0:: validação simples para garantir que o usuário pediu pelo menos uma linha.
  • num = 1: inicializa o contador com 1.
  • for i in range(1, n + 1): controla quantas linhas serão impressas.
  • for j in range(i): garante que na linha i imprimimos exatamente i valores.
  • print(num, end=' '): imprime o número atual sem pular linha; end=' ' coloca um espaço depois do número.
  • num += 1: equivalente a num = num + 1, avança para o próximo número.
  • print(): quebra a linha depois de terminar a linha atual do triângulo.

Passo 4

Exemplo de execução (teste mental):
  • Se o usuário digitar \;n=3, o programa faz:
    • linha 1: imprime 1
    • linha 2: imprime 2 3
    • linha 3: imprime 4 5 6
      Resultado exibido:
1 
2 3 
4 5 6 
(Nota: há um espaço extra no final de cada linha por causa de end=' ', isso é aceitável normalmente. Se quiser evitar o espaço final podemos juntar os números numa lista e usar ' '.join(...), mas a solução com print(..., end=' ') é simples e suficiente para a maioria das provas.)
Dica prática para a prova:
  • Explique em poucas palavras: “uso uma variável contadora que começa em 1 e dois laços aninhados: o externo vai de 1 a n e o interno imprime a quantidade de números igual ao índice da linha.” Se pedirem complexidade, diga que são impressos 1 + 2 + \dots + n = \frac{n(n+1)}{2} números (essa é uma observação extra interessante e fácil de lembrar).

Resposta

try:
    n = int(input("Digite o número de linhas: "))
except ValueError:
    print("Entrada inválida: informe um inteiro positivo.")
    raise SystemExit

if n <= 0:
    print("Informe um número de linhas maior que zero.")
    raise SystemExit

num = 1
for i in range(1, n + 1):
    for j in range(i):
        print(num, end=' ')
        num += 1
    print()

Exercícios relacionados