En este post aprenderás cómo rellenar una matriz (y si fuera un array o arreglo también sería posible) de números primos; es decir, llenar toda la matriz con números pero siempre y cuando sean primos.

Lo haremos en lenguaje C++ aunque debería funcionar de igual modo en otro lenguaje. Simplemente vamos a usar una función que dice si un número es primo y luego usarla para rellenar el arreglo de dos dimensiones.

Función de número primo

Esta función (ya expuesta anteriormente en mi blog) recibe un número y devuelve un booleano indicando si el número es primo:

bool esPrimo(int numero) {
  // Casos especiales
  if (numero == 0 || numero == 1 || numero == 4)
    return false;
  for (int x = 2; x < numero / 2; x++) {
    if (numero % x == 0)
      return false;
  }
  // Si no se pudo dividir por ninguno de los de arriba, sí es primo
  return true;
}

Rellenando matriz

Ahora vamos a rellenar la matriz. Primero declaramos un contador que nos servirá para ir llenando la matriz de números primos, pues no todos lo son.

Así que cada que recorramos la matriz haremos un ciclo while infinito que se romperá solo si se encuentra un número primo (vamos a probar con el contador).

De este modo no vamos a repetir números y nos vamos a asegurar de que todos sean primos.

El código queda así:

int matriz[5][5];
int contador = 1;
for (int x = 0; x < 5; x++) {
  for (int y = 0; y < 5; y++) {
    while (true) {
      contador++;
      if (esPrimo(contador)) {
        matriz[x][y] = contador;
        break;
      }
    }
  }
}

Después imprimimos el arreglo para comprobar que realmente funciona:

// imprimir

for (int x = 0; x < 5; x++) {
  std::cout << "\n";
  for (int y = 0; y < 5; y++) {
    std::cout << matriz[x][y] << " ";
  }
}

Poniendo todo junto

Entonces todo el código queda así:

/*
  ____          _____               _ _           _       
 |  _ \        |  __ \             (_) |         | |      
 | |_) |_   _  | |__) |_ _ _ __ _____| |__  _   _| |_ ___ 
 |  _ <| | | | |  ___/ _` | '__|_  / | '_ \| | | | __/ _ \
 | |_) | |_| | | |  | (_| | |   / /| | |_) | |_| | ||  __/
 |____/ \__, | |_|   \__,_|_|  /___|_|_.__/ \__, |\__\___|
         __/ |                               __/ |        
        |___/                               |___/         
    
    Blog:       https://parzibyte.me/blog
    Ayuda:      https://parzibyte.me/blog/contrataciones-ayuda/
    Contacto:   https://parzibyte.me/blog/contacto/
    
    Copyright (c) 2020 Luis Cabrera Benito
    Licenciado bajo la licencia MIT
    
    El texto de arriba debe ser incluido en cualquier redistribución
*/

#include <iostream>

bool esPrimo(int numero) {
  // Casos especiales
  if (numero == 0 || numero == 1 || numero == 4)
    return false;
  for (int x = 2; x < numero / 2; x++) {
    if (numero % x == 0)
      return false;
  }
  // Si no se pudo dividir por ninguno de los de arriba, sí es primo
  return true;
}

int main() {
  int matriz[5][5];
  int contador = 1;
  for (int x = 0; x < 5; x++) {
    for (int y = 0; y < 5; y++) {
      while (true) {
        contador++;
        if (esPrimo(contador)) {
          matriz[x][y] = contador;
          break;
        }
      }
    }
  }
  // imprimir

  for (int x = 0; x < 5; x++) {
    std::cout << "\n";
    for (int y = 0; y < 5; y++) {
      std::cout << matriz[x][y] << " ";
    }
  }
}

Al ejecutarlo, la salida es correcta. Se puede observar que cada elemento de la matriz tiene un número primo distinto, es decir, tenemos a los primeros 25 números primos: