Leia valores reais para uma matriz
de dimensões
(informadas previamente pelo usuário). Depois apresente esses valores conforme o formato do exercício anterior.
Passo 1
O enunciado pede que a gente leia valores reais para uma matriz de dimensões
, onde
(número de linhas) e
(número de colunas) são informados previamente pelo usuário. Depois devemos apresentar esses valores “no formato do exercício anterior”, ou seja, exibindo a matriz com suas linhas e colunas (cada linha numa linha de saída), mantendo a ordem de entrada.
Informações relevantes dadas:
Informações relevantes dadas:
- O usuário informa
e . - Devemos ler
números reais. - Devemos mostrar esses valores formatados como matriz (linha por linha).
Passo 2
Como representar a matriz em memória (explicação didática):
- Vamos usar uma lista de listas (estrutura comum em linguagens como Python). Cada elemento da lista externa representa uma linha.
- Denotando os elementos por
, indica a linha ( ) e indica a coluna ( ). Na implementação em programação normalmente usamos índices começando em zero, mas conceitualmente pense em e . - Vantagem: acessar o elemento da linha
coluna é feito com algo como matrix[i][j] (ou matrix[i-1][j-1] se você pensa em começando em 1).
Passo 3
Como ler as dimensões
e
(boas práticas e validação):
- Precisamos aceitar apenas inteiros positivos para
e . Se o usuário digitar algo inválido (texto, número negativo, zero), devemos pedir novamente. - Em pseudocódigo:
- repetir até obter
válido: ler entrada, tentar converter para inteiro, verificar . - mesmo para
.
- repetir até obter
- Por que validar? Em prova/concursos, entradas inválidas podem quebrar o programa; a validação garante robustez (e não é muito custo).
Passo 4
Como ler os
valores reais — estratégias e escolha:
- Estratégia A (mais interativa): para cada posição
pedir um número separado. Simples, mas muito verbosa para o usuário. - Estratégia B (mais prática): para cada linha
pedir uma linha com valores separados por espaço. Isso reduz prompts e é comum em exercícios/programação competitiva. - Eu escolho a Estratégia B porque é mais prática e rápida na prova: para cada linha você digita
números, o programa separa e converte para float. - Validações a fazer para cada linha:
- O usuário deve fornecer exatamente
tokens (se der menos ou mais, pedimos novamente). - Cada token deve ser convertível para número real (float). Se não for, pedimos novamente.
- O usuário deve fornecer exatamente
- Implementação conceitual com laços:
- para i de 1 até
: - enquanto True:
- ler uma linha de texto
- dividir em tokens
- se número de tokens !=
: avisar e repetir - tentar converter tokens para floats; se falhar avisar e repetir
- se tudo certo: armazenar como linha e sair do while
- enquanto True:
- para i de 1 até
Passo 5
Como apresentar (formatar) os valores na saída:
- O enunciado quer a apresentação no formato de matriz (cada linha aparece numa linha). Uma forma clara e comum:
- imprimir cada linha com os
valores separados por um espaço. - opcional: controlar a formatação numérica (por exemplo, duas casas decimais) para saída mais legível. Isso evita muitos dígitos não desejados.
- imprimir cada linha com os
- Exemplo de formato por linha (com 2 casas decimais):
1.50 0.00 -3.25
4.00 2.33 5.10 - Em programação usamos algo como ’ '.join("{:.2f}".format(x) for x in row) para cada linha.
- Importante: se o exercício anterior tiver um formato diferente (tipo largura fixa), dá para ajustar a string de formatação; aqui eu uso duas casas decimais como escolha razoável e amplamente aceitável.
Passo 6
Detalhes de implementação e explicação das partes do código (linha a linha, pensando em Python):
- Função de leitura de inteiro positivo:
- laço infinito que tenta converter a entrada em inteiro e checa se é maior que zero; em erro, mostra mensagem e repete.
- Leitura das linhas da matriz:
- para cada linha
(vai de a no código): - pede ao usuário uma linha com
valores - faz split() para obter tokens
- se len(tokens) !=
-> mensagem de erro e continuar pedindo - tenta converter cada token em float; se der ValueError -> mensagem de erro e repetir
- se correto, adiciona a lista de floats como a linha
- pede ao usuário uma linha com
- para cada linha
- Impressão:
- definimos um formato (por exemplo, duas casas: “{:.2f}”) e aplicamos a cada elemento, juntando com espaço e imprimindo linha por linha.
Passo 7
Algumas variações e observações rápidas para sua prova:
- Se o enunciado exigir outra formatação (ex.: 1 casa decimal, ou largura fixada), troque “{:.2f}” por “{:.1f}” ou “{:8.2f}”.
- Se for aceitar entradas em notação científica, float() já cuida disso.
- Se preferir ler elemento a elemento (um por um), use dois laços aninhados e leia float(input(…)) em cada iteração.
- Teste mental: para
, e entrada das linhas “1 2 3” e “4.5 -1 0”, a saída (com 2 casas) será:
1.00 2.00 3.00
4.50 -1.00 0.00
Resposta
def read_positive_int(prompt):
while True:
try:
v = int(input(prompt))
if v <= 0:
print("Digite um inteiro positivo.")
else:
return v
except ValueError:
print("Entrada inválida. Digite um inteiro.")
def read_matrix(M, N):
matrix = []
for i in range(M):
while True:
line = input(f"Digite {N} valores reais para a linha {i+1}, separados por espaço: ").strip()
parts = line.split()
if len(parts) != N:
print(f"Número de valores incorreto (esperado {N}). Tente novamente.")
continue
try:
row = [float(x) for x in parts]
matrix.append(row)
break
except ValueError:
print("Entrada inválida. Use números reais (ex: 1.5). Tente novamente.")
return matrix
def print_matrix(matrix, decimals=2):
fmt = ("{:." + str(decimals) + "f}").format
for row in matrix:
print(' '.join(fmt(x) for x in row))
def main():
M = read_positive_int("Número de linhas (M): ")
N = read_positive_int("Número de colunas (N): ")
mat = read_matrix(M, N)
print("Matriz:")
print_matrix(mat, decimals=2)
if __name__ == "__main__":
main()