Positive Views & potential : Compression, Dictionary Sort & Same Size Copy Match & Unite Same with location in 2D Matrix #JS #C #Python RS 2023 https://is.gd/CJS_DictionarySort

Positive Views & potential : Compression, Dictionary Sort & Same Size Copy Match & Unite Same with location in 2D Matrix #JS #C #Python RS 2023 https://is.gd/CJS_DictionarySort

[Duke Abbaddon]

Compression, Dictionary Sort & Same Size Copy Match & Unite Same with
location in 2D Matrix #JS #C #Python RS 2023

https://is.gd/CJS_DictionarySort

The code appears complex; But there you go! In assembler it may be
15KB to 64KB; I am not entirely sure,
However the objective is for ZSTD, GZIP, Brotli & Codecs such as DSC,

The compression rate improves & the quality of the compression also!
Depending on the encryption type; You may also improve the complexity
by deviating from commons or by compressing better first.

Sorting memory load arrays so they align neatly into a block;
Accounting Dates into Same ID & Order; Ordered identical ID; Taxing
blocks,

Accounting for block loads & saves so that blocks in the same
locations & size are loaded & stored neatly..

Aligned minimal block formations save space on block systems such as
NTFS & EFS & Advanced Format with Extended Directories such as on the
Amiga & Mac

These & many more uses depending on speed & parallel code ordering &
identification Unification,

Depending entirely on block size & efficiency of sort & collation grouping.

RS

Bluetooth dongle LE Protocol
https://drive.google.com/file/d/17csRnAfdceZiTSnQZvhaLqLSwL__zsIG/view?usp=sharing

https://science.n-helix.com/2022/09/ovccans.html

https://science.n-helix.com/2022/03/ice-ssrtp.html

https://science.n-helix.com/2022/04/vecsr.html

https://science.n-helix.com/2022/02/interrupt-entropy.html

Rupert S

code for sorting and matching a 2D matrix can vary depending on the
specific assembler architecture and compiler being used. Here's a
general outline of the steps involved:

Load and Initialize Data:

Load the 2D matrix into memory, keeping track of its dimensions (rows
and columns).
Initialize an auxiliary array to store the first and last occurrences
of each value in each row.
Initialize an empty array to store the combined matrix.
Initialize a counter for the number of same rows found.
Sort Each Row:

Iterate through each row of the matrix.
For each row, use a sorting algorithm, such as bubble sort or
insertion sort, to sort the elements in ascending order.
Find First and Last Occurrences:

Iterate through each row of the sorted matrix.
For each element in the row, scan the remaining elements in the row to
find its first and last occurrences.
Store the first and last occurrences in the corresponding auxiliary array.
Identify Same Rows:

Iterate through each row of the matrix.
For each row, check if all elements have the same first and last
occurrences as the corresponding elements in the previous row.
If all elements match, mark the row as a "same row" and increment the counter.
Combine Same Rows:

Allocate memory for the combined matrix based on the number of same rows found.
Iterate through the same rows, copying the elements of each same row
into the corresponding row of the combined matrix.
Sort Combined Matrix:

Sort the combined matrix using a sorting algorithm.
Update Output Arrays:

Store the sorted combined matrix in the provided output array.
Store the indices of the same rows in the provided output array.

#JS

function sortAndMatch(matrix) {
  // Sort each row of the matrix
  const sortedMatrix = matrix.map((row) => row.sort((a, b) => a - b));

  // Find the first occurrence of each value in each row
  const firstOccurrences = [];
  for (let i = 0; i < matrix.length; i++) {
    const row = matrix[i];
    const firstOccurrencesRow = {};
    for (let j = 0; j < row.length; j++) {
      const value = row[j];
      if (!firstOccurrencesRow.hasOwnProperty(value)) {
        firstOccurrencesRow[value] = j;
      }
    }
    firstOccurrences.push(firstOccurrencesRow);
  }

  // Find the last occurrence of each value in each row
  const lastOccurrences = [];
  for (let i = 0; i < matrix.length; i++) {
    const row = matrix[i];
    const lastOccurrencesRow = {};
    for (let j = row.length - 1; j >= 0; j--) {
      const value = row[j];
      if (!lastOccurrencesRow.hasOwnProperty(value)) {
        lastOccurrencesRow[value] = j;
      }
    }
    lastOccurrences.push(lastOccurrencesRow);
  }

  // Find the first and last occurrences of each value in the matrix
  const firstOccurrencesAll = {};
  for (const row of firstOccurrences) {
    for (const value in row) {
      if (!firstOccurrencesAll.hasOwnProperty(value) ||
firstOccurrencesAll[value] > row[value]) {
        firstOccurrencesAll[value] = row[value];
      }
    }
  }

  const lastOccurrencesAll = {};
  for (const row of lastOccurrences) {
    for (const value in row) {
      if (!lastOccurrencesAll.hasOwnProperty(value) ||
lastOccurrencesAll[value] < row[value]) {
        lastOccurrencesAll[value] = row[value];
      }
    }
  }

  // Find the rows that contain the same values
  const sameRows = [];
  for (let i = 0; i < matrix.length; i++) {
    const row = matrix[i];
    let same = true;
    for (let j = 0; j < row.length; j++) {
      const value = row[j];
      const firstOccurrence = firstOccurrencesAll[value];
      const lastOccurrence = lastOccurrencesAll[value];
      if (firstOccurrence !== lastOccurrence ||
firstOccurrences[i][value] !== firstOccurrence ||
lastOccurrences[i][value] !== lastOccurrence) {
        same = false;
        break;
      }
    }
    if (same) {
      sameRows.push(i);
    }
  }

  // Combine the same rows into a single row
  const combinedMatrix = [];
  for (const row of sameRows) {
    combinedMatrix.push(matrix[row]);
  }

  // Sort the combined matrix
  const sortedCombinedMatrix = combinedMatrix.map((row) =>
row.sort((a, b) => a - b));

  return { sortedCombinedMatrix, sameRows };
}

const matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]];
const result = sortAndMatch(matrix);
console.log(result.sortedCombinedMatrix);
console.log(result.sameRows);

#C

#include <stdio.h>
#include <stdlib.h>

typedef struct {
  int value;
  int firstOccurrence;
  int lastOccurrence;
} ValueInfo;

void sortAndMatch(int matrix[][3], int rows, int cols, int**
sortedCombinedMatrix, int* sameRows, int* sameRowsCount) {
  // Allocate memory for the first and last occurrences of each value
in each row
  ValueInfo** firstOccurrences = (ValueInfo**)malloc(sizeof(ValueInfo*) * rows);
  for (int i = 0; i < rows; i++) {
    firstOccurrences[i] = (ValueInfo*)malloc(sizeof(ValueInfo) * cols);
  }

  ValueInfo** lastOccurrences = (ValueInfo**)malloc(sizeof(ValueInfo*) * rows);
  for (int i = 0; i < rows; i++) {
    lastOccurrences[i] = (ValueInfo*)malloc(sizeof(ValueInfo) * cols);
  }

  // Find the first and last occurrences of each value in each row
  for (int i = 0; i < rows; i++) {
    for (int j = 0; j < cols; j++) {
      int value = matrix[i][j];
      bool foundFirst = false;
      bool foundLast = false;

      for (int k = 0; k < cols; k++) {
        if (matrix[i][k] == value && !foundFirst) {
          firstOccurrences[i][j].value = value;
          firstOccurrences[i][j].firstOccurrence = k;
          foundFirst = true;
        }

        if (matrix[i][k] == value && !foundLast) {
          lastOccurrences[i][j].value = value;
          lastOccurrences[i][j].lastOccurrence = k;
          foundLast = true;
        }
      }
    }
  }

  // Find the first and last occurrences of each value in the matrix
  ValueInfo* firstOccurrencesAll = (ValueInfo*)malloc(sizeof(ValueInfo) * cols);
  for (int i = 0; i < cols; i++) {
    firstOccurrencesAll[i].value = -1;
    firstOccurrencesAll[i].firstOccurrence = -1;
    firstOccurrencesAll[i].lastOccurrence = -1;
  }

  ValueInfo* lastOccurrencesAll = (ValueInfo*)malloc(sizeof(ValueInfo) * cols);
  for (int i = 0; i < cols; i++) {
    lastOccurrencesAll[i].

#Python

import numpy as np

def sort_and_match(matrix):
    # Sort each row of the matrix
    sorted_matrix = np.sort(matrix, axis=1)

    # Find the first occurrence of each value in each row
    first_occurrences = np.zeros_like(matrix)
    for i in range(matrix.shape[0]):
        for j in range(matrix.shape[1]):
            if matrix[i, j] not in first_occurrences[i, :j]:
                first_occurrences[i, j] = j

    # Find the last occurrence of each value in each row
    last_occurrences = np.zeros_like(matrix)
    for i in range(matrix.shape[0]):
        for j in range(matrix.shape[1]-1, -1, -1):
            if matrix[i, j] not in last_occurrences[i, j+1:]:
                last_occurrences[i, j] = j

    # Find the first and last occurrences of each value in the matrix
    first_occurrences_all = np.min(first_occurrences, axis=0)
    last_occurrences_all = np.max(last_occurrences, axis=0)

    # Find the rows that contain the same values
    same_rows = []
    for i in range(matrix.shape[0]):
        if np.all(first_occurrences[i, :] == last_occurrences[i, :]):
            same_rows.append(i)

    # Combine the same rows into a single row
    combined_matrix = np.zeros((len(same_rows), matrix.shape[1]))
    for i, row in enumerate(same_rows):
        combined_matrix[i, :] = matrix[row, :]

    # Sort the combined matrix
    sorted_combined_matrix = np.sort(combined_matrix, axis=1)

    return sorted_combined_matrix, same_rows

matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
sorted_combined_matrix, same_rows = sort_and_match(matrix)
print(sorted_combined_matrix)
print(same_rows)