Crie um programa que cria uma matriz 1000 \times 800 com valores do tipo int pseudoaleatórios e que imprime em um arquivo “dados.txt” os valores dos elementos da matriz (de maneira correspondente com a disposição destes elementos na matriz).

Passo 1

O enunciado pede que eu crie um programa que:
  • gere uma matriz de inteiros pseudoaleatórios com dimensão \,1000\times800\,;
  • grave os valores dessa matriz em um arquivo chamado “dados.txt”;
  • o arquivo deve conter os elementos dispostos de maneira correspondente à disposição da matriz (ou seja: cada linha do arquivo corresponde a uma linha da matriz e os elementos de uma linha estão separados por espaços ou outro separador consistente).
Informações relevantes dadas:
  • dimensão da matriz: \,1000\times800\,;
  • tipo dos elementos: inteiros (int) pseudoaleatórios;
  • nome do arquivo de saída: “dados.txt”.
O que vou entregar: um programa pronto para executar que gera essa matriz e grava o arquivo no formato pedido, com explicações passo a passo de como o programa funciona.

Passo 2

Escolhi usar a linguagem Python por estas razões práticas (e porque é comum em provas/atividades de programação básica):
  • sintaxe curta e clara, ótimo para estudar passo a passo;
  • biblioteca padrão já tem gerador pseudoaleatório e facilidades de escrita em arquivo;
  • código portátil e fácil de rodar sem compilação.
Formato do arquivo: cada linha do arquivo representará uma linha da matriz; dentro de cada linha, os \,800\, inteiros estarão separados por um espaço em branco. Assim um arquivo terá \,1000\, linhas e cada linha terá \,800\, números separados por espaço, terminando com newline.

Passo 3

Breve aula sobre pseudoaleatoriedade e geração de inteiros em Python:
  • “Pseudoaleatório” significa que os números parecem aleatórios, mas são produzidos por um algoritmo determinístico. Em Python o módulo é o módulo random.
  • Para reproduzibilidade (mesmo conjunto de números em execuções diferentes) usa-se random.seed(valor). Se não usar seed ou usar None, a semente vem do relógio/sistema e a sequência difere a cada execução.
  • Para gerar um inteiro entre dois limites inclusivos usa-se random.randint(a, b).
  • Vou escolher um intervalo de valores inteiros para a matriz. Um intervalo prático é [-10^{6},\,10^{6}], isto é, inteiros entre -10^{6} e 10^{6}. Esse intervalo é grande o suficiente para parecer “aleatório” e não muito grande para leitura/armazenamento.

Passo 4

Estratégia de implementação (motivo das escolhas):
  • Em vez de alocar obrigatoriamente a matriz inteira na memória antes de gravar, gerarei e escreverei linha a linha. Isso reduz uso de memória e é simples: mesmo que a memória comporte a matriz inteira, a escrita linha-a-linha é robusta.
  • Para cada linha i de 0 a 999 (total \,1000\, linhas), gero \,800\, inteiros e escrevo a linha no arquivo como texto com números separados por espaço e terminada por '\n'.
  • Nome do arquivo: exatamente “dados.txt” conforme pedido; o arquivo será sobrescrito se já existir (modo 'w').

Passo 5

Algoritmo em alto nível (pseudocódigo):
  1. importar módulo random;
  2. (opcional) inicializar semente: random.seed(SEED) (usar um valor fixo para reprodutibilidade ou None para variedade);
  3. abrir arquivo “dados.txt” para escrita;
  4. para linha de 1 até 1000:
    • gerar lista de 800 inteiros pseudoaleatórios com randint(min, max);
    • converter cada inteiro para string e juntar com ' '.join(...)';
    • escrever a string + '\n' no arquivo;
  5. fechar arquivo (fechamento automático com with em Python).

Passo 6

Explicação detalhada das partes do código (linha a linha conceptual):
  • import random: importa o gerador pseudoaleatório.
  • ROWS = 1000 e COLS = 800: variáveis que ficam explícitas e fáceis de alterar em testes.
  • MIN_VAL = -10**6 e MAX_VAL = 10**6: limites do inteiro gerado (isto é -10^{6} a 10^{6}).
  • SEED = None ou SEED = 42: se SEED for None, a sequência muda a cada execução; se for um inteiro fixo, a sequência é reproduzível.
  • random.seed(SEED) aplica a semente; se SEED for None o Python usa fonte de entropia do sistema.
  • with open("dados.txt", "w") as f: abre o arquivo para escrita e garante fechamento ao terminar.
  • Dentro do laço for i in range(ROWS)::
    • usar list comprehension [str(random.randint(MIN_VAL, MAX_VAL)) for _ in range(COLS)] gera os COLS inteiros e já os converte para string;
    • f.write(" ".join(row_values) + "\n") escreve a linha no arquivo com espaços entre números.

Passo 7

Observações práticas e verificação:
  • O arquivo “dados.txt” terá \,1000\, linhas; cada linha terá \,800\, itens separados por espaço. Para verificar rapidamente em terminal (Linux/Mac) pode-se usar wc -l dados.txt para contar linhas e head -n 1 dados.txt | wc -w para contar palavras na primeira linha.
  • Tempo estimado: gerar \,800{,}000\, inteiros e gravá-los em disco pode levar alguns segundos, dependendo do hardware; é uma operação perfeitamente razoável em computadores modernos.
  • Se quiser testar rapidamente sem esperar, reduza ROWS e COLS para valores menores (por exemplo \,10\times8\,) e rode o programa; depois aumente para os valores finais.

Passo 8

Código final em Python (pronto para copiar e executar). Ele gera a matriz \,1000\times800\, de inteiros pseudoaleatórios no intervalo [-10^{6},10^{6}] e grava em “dados.txt”. Mude SEED para um inteiro se quiser resultados reprodutíveis, ou deixe None para variar a cada execução.

Resposta

#!/usr/bin/env python3
import random

# Configurações
ROWS = 1000
COLS = 800
MIN_VAL = -10**6   # limite inferior (inclusive)
MAX_VAL = 10**6    # limite superior (inclusive)
SEED = None        # coloque um inteiro (ex: 42) para reprodutibilidade, ou None para semente do sistema

# Inicializa o gerador pseudoaleatório
random.seed(SEED)

# Gera e grava a matriz linha a linha
with open("dados.txt", "w", encoding="utf-8") as f:
    for _ in range(ROWS):
        # gera COLS inteiros e converte para strings
        row_values = [str(random.randint(MIN_VAL, MAX_VAL)) for _ in range(COLS)]
        # escreve a linha no arquivo com números separados por espaço
        f.write(" ".join(row_values) + "\n")

Exercícios relacionados