перемешиваем векторы связанных групп 50 матриц

алгоритм на питоне

у нас есть
50 матриц 8 на 8
и 50 матриц 9 на 9

нужно сделать 50 матриц 10 на 10
в которых есть числовые векторы всех тех же матриц 8 на 8 и 9 на 9
то есть получить некоторую вторичную производную представления множества всех матриц
перемешав их строки и подстроки как единую базу данных системы голограмм


*


Для решения вашей задачи можно использовать библиотеку NumPy, которая позволяет удобно работать с матрицами и векторами. Мы будем создавать 50 матриц 10 на 10, в которые будем помещать векторы из 50 матриц 8 на 8 и 50 матриц 9 на 9. Затем мы перемешаем строки и столбцы, чтобы создать "голограмму" данных.

Вот пример кода, который выполняет эту задачу:

import numpy as np

# Функция для создания 50 случайных матриц 8x8 и 9x9
def create_matrices():
    matrices_8x8 = [np.random.randint(0, 10, (8, 8)) for _ in range(50)]
    matrices_9x9 = [np.random.randint(0, 10, (9, 9)) for _ in range(50)]
    return matrices_8x8, matrices_9x9

# Функция для создания 50 матриц 10x10
def create_10x10_matrices(matrices_8x8, matrices_9x9):
    matrices_10x10 = []
    for mat8, mat9 in zip(matrices_8x8, matrices_9x9):

        # Преобразуем матрицы 8x8 и 9x9 в векторы
        vector_8 = mat8.flatten()
        vector_9 = mat9.flatten()
       
        # Создаем матрицу 10x10 и заполняем ее векторами
        matrix_10x10 = np.zeros((10, 10), dtype=int)
        matrix_10x10[:8, :8] = mat8  # Вставляем матрицу 8x8
        matrix_10x10[:9, :9] += mat9  # Вставляем матрицу 9x9 (перекрытие)
       
        # Перемешиваем строки и столбцы
        np.random.shuffle(matrix_10x10)
        matrix_10x10 = matrix_10x10.T  # Транспонируем для перемешивания столбцов
        np.random.shuffle(matrix_10x10)
       
        matrices_10x10.append(matrix_10x10)
    return matrices_10x10

# Основная логика
matrices_8x8, matrices_9x9 = create_matrices()
matrices_10x10 = create_10x10_matrices(matrices_8x8, matrices_9x9)

# Выводим некоторые матрицы 10x10 для проверки
for i in range(5):
    print(f"Matrix 10x10 {i+1}:\n{matrices_10x10[i]}\n")


Объяснение этого кода:

Создание матриц: Мы создаем 50 случайных матриц 8x8 и 50 случайных матриц 9x9 с помощью функции create_matrices().
Создание матриц 10x10: В функции create_10x10_matrices() мы берем каждую пару матриц 8x8 и 9x9, преобразуем их в векторы и создаем новую матрицу 10x10. Мы вставляем матрицы 8x8 и 9x9 в новую матрицу и перемешиваем строки и столбцы.

Вывод: В конце мы выводим первые 5 матриц 10x10 для проверки.
Вы можете изменить способ перемешивания и заполнения матриц в зависимости от ваших требований.




-> некоторые из полученных нами матриц



Matrix 10x10 1:
[[ 0  0  0  0  0  0  0  0  0  0]
 [ 2  0  3  0 14  7 12 12  6  9]
 [ 4  0  3  3 11  0  9  9  7  7]
 [10  0  3 11  6  3 13  8 13  9]
 [ 7  0 14  3 14  8 11  8  5  8]
 [10  0  3  6 16  7 10  6 14  7]
 [ 9  0  8 10  2 12 12  8 14  9]
 [ 7  0  2  7  6 15  5 11  6  3]
 [ 8  0  7  3  8  9  9  3  3  6]
 [ 4  0 11 12 15  3  7 10  4  8]]

Matrix 10x10 2:
[[ 8  0  6 14  4  9 17  6  6  2]
 [ 5  0 14  4  9 10 11 13 10  8]
 [ 3  0 16  7  9  2  6  8 15 10]
 [ 9  0 12 12  6 12 10 13  6 14]
 [ 0  0  0  0  0  0  0  0  0  0]
 [ 1  0  6  7  2  7  3  4  3  8]
 [ 4  0 10 12  4 10  5  4  6  7]
 [11  0 13  7  9 12  8  8 12 14]
 [16  0  4 15  6 10  6  6  2  1]
 [11  0 14  9  3 10 14 10  5  3]]

Matrix 10x10 3:
[[ 2  8  5  8 13  7 10  0  7  0]
 [ 2  2  3  8  4  7  7  0  2  2]
 [ 4 11 11  7 12 13  0  0 13  8]
 [ 7 10  8  9 12  7 13  0  3  5]
 [ 7 15  6 16 16  1  5  0 15  4]
 [ 0  0  0  0  0  0  0  0  0  0]
 [ 6  7  4  5  7 10 17  0 10  1]
 [11 12 11 13  9  7 10  0  4  6]
 [ 4  9  5 16  4 12 14  0 12  1]
 [11  9 17  4  5 12 13  0 10  4]]

Matrix 10x10 4:
[[ 8  7  0  9  1 12 10  9 12  9]
 [13  8  0 10  2 14 10  9 12 18]
 [16  9  0  6  1  7 14 10 14  6]
 [ 5 10  0 14  0 12 10  8  9 12]
 [13 12  0  2  5  4 10  8  3 14]
 [ 5  9  0  8  4  2  9 16 11  8]
 [ 4 16  0 10  2 15 12 15  2  4]
 [ 2  9  0  6  9  5  8  4  8  5]
 [ 5 13  0  3  4  0  4  7  4  9]
 [ 0  0  0  0  0  0  0  0  0  0]]

Matrix 10x10 5:
[[ 0 14 15  7  3  0 17  7 13 12]
 [ 0 11  7 13  2  0  7  2 16  2]
 [ 2  5  0  8  8  0  9  1  4  1]
 [ 5  9  3  7  7  0  6 12  6  1]
 [ 6  7  0 12  7  0 15  8 10 15]
 [ 9  2  3 15 14  0  7  7  8  8]
 [ 4 14  9  7  9  0 17  8 10 10]
 [ 0  0  0  0  0  0  0  0  0  0]
 [ 9  9 14 13 14  0  1 14 11  7]
 [ 1 13 11  4  6  0  9 17 12  5]]






   *



питон алгоритм
есть исходная матрица 6 на 6

17 11 30 12 02 10
01 24 36 33 32 12
10 08 14 16 05 03
15 21 13 15 49 14
40 86 56 48 23 17
75 70 78 20 96 60



нам нужно изменить в матрице два числа на +1 или -1
значения чисел матрицы в диапазоне 0 - 100
так меняя пары чисел мы создаём 1 миллион новых матриц
затем ищем одинаковые матрицы и убираем их из нашего общего множества матриц

Для решения задачи по генерации уникальных матриц, изменяя два числа в исходной матрице, можно использовать Python. Мы будем использовать множество (set) для хранения уникальных матриц, так как множество автоматически исключает дубликаты.



Вот пример кода, который выполняет это:




import numpy as np

# Исходная матрица
matrix = np.array([
    [17, 11, 30, 12, 02, 11],
    [01, 24, 36, 33, 32, 12],
    [10, 08, 14, 16, 05, 03],
    [15, 21, 13, 15, 44, 14],
    [40, 86, 56, 48, 23, 17],
    [75, 72, 78, 20, 96, 66]
])

# Функция для генерации уникальных матриц
def generate_unique_matrices(original_matrix, num_matrices):
    unique_matrices = set()
    rows, cols = original_matrix.shape

    while len(unique_matrices) < num_matrices:
        # Копируем исходную матрицу для изменения
        new_matrix = original_matrix.copy()
       
        # Выбираем два уникальных индекса для изменения
        idx1 = np.random.randint(0, rows * cols)
        idx2 = np.random.randint(0, rows * cols)
       
        # Убедимся, что индексы разные
        while idx2 == idx1:
            idx2 = np.random.randint(0, rows * cols)
       
        # Преобразуем индексы в координаты матрицы
        r1, c1 = divmod(idx1, cols)
        r2, c2 = divmod(idx2, cols)
       
        # Изменяем значения в матрице
        if new_matrix[r1, c1] < 100:
            new_matrix[r1, c1] += 1
        if new_matrix[r2, c2] > 0:
            new_matrix[r2, c2] -= 1
       
        # Добавляем новую матрицу в множество
        unique_matrices.add(tuple(map(tuple, new_matrix)))

    return unique_matrices

# Генерация 1 миллиона уникальных матриц
unique_matrices = generate_unique_matrices(matrix, 1000000)

# Вывод количества уникальных матриц
print(f"Количество уникальных матриц: {len(unique_matrices)}")



  *


Объяснение кода:

Исходная матрица: Мы задаем исходную матрицу размером 6x6.
Функция generate_unique_matrices: Эта функция генерирует уникальные матрицы. Она принимает исходную матрицу и количество матриц, которые нужно сгенерировать.

Цикл генерации: Внутри цикла мы генерируем случайные индексы для изменения значений в матрице. Мы проверяем, что индексы разные, и изменяем значения, увеличивая одно на 1, а другое уменьшая на 1.
Сохранение уникальных матриц: Мы используем множество для хранения уникальных матриц. Для этого мы преобразуем каждую матрицу в кортеж, чтобы сделать ее хэшируемой.

Вывод результата: В конце мы выводим количество уникальных матриц.
Замечания:
Изменение значений в матрице ограничено диапазоном от 0 до 100.
Генерация 1 миллиона уникальных матриц может занять время, так как вероятность столкновения с дубликатами может быть высокой, особенно при небольшом размере матрицы.

Для улучшения производительности можно использовать более сложные алгоритмы, такие как использование битовых масок или другие методы оптимизации.