The unexpected actions while altering the direction of iteration in a 2D array and sorting elements

Question

The unexpected actions while altering the direction of iteration in a 2D array and sorting elements

If we consider a 2D array:

┌─────────┬───┬───┬───┐
│ (index) │ 0 │ 1 │ 2 │
├─────────┼───┼───┼───┤
│    0    │ 2 │ 3 │ 2 │
│    1    │ 3 │ 1 │ 3 │
│    2    │ 2 │ 2 │ 3 │
└─────────┴───┴───┴───┘

The goal is to sort the elements in this 2D array and arrange them in a line from top to bottom as shown below:

┌─────────┬───┬───┬───┐
│ (index) │ 0 │ 1 │ 2 │
├─────────┼───┼───┼───┤
│    0    │ 1 │ 2 │ 3 │
│    1    │ 2 │ 2 │ 3 │
│    2    │ 2 │ 3 │ 3 │
└─────────┴───┴───┴───┘

Currently, there is code available for this process:

const generateArray = (size, min, max) =>
    Array(size)
    .fill(0)
    .map(() => generateNumber(min, max));

const generateArray2D = (rows, cols, min, max) =>
    Array(rows)
    .fill(0)
    .map(() => generateArray(cols, min, max));

const generateNumber = (min, max) =>
    Math.floor(Math.random() * (max - min + 1)) + Math.floor(min);

const generated2DArray = generateArray2D(
    rows,
    cols,
    10,
    30
);

const sortedArray = [...generated2DArray].flat(1).sort(((a, b) => a - b))

for (const sortedElement of sortedArray) {
  for (let j = 0; j < generated2DArray.length; j++) {
    for (let i = 0; i < generated2DArray[j].length; i++) {
      generated2DArray[i][j] = sortedElement;
    }
  }
}

However, each field in the resulting array contains only the last element from the sorted sortedArray like so:

┌─────────┬────┬────┬────┬────┬────┐
│ (index) │ 0  │ 1  │ 2  │ 3  │ 4  │
├─────────┼────┼────┼────┼────┼────┤
│    0    │ 30 │ 30 │ 30 │ 30 │ 30 │
│    1    │ 30 │ 30 │ 30 │ 30 │ 30 │
│    2    │ 30 │ 30 │ 30 │ 30 │ 30 │
│    3    │ 30 │ 30 │ 30 │ 30 │ 30 │
│    4    │ 30 │ 30 │ 30 │ 30 │ 30 │
└─────────┴────┴────┴────┴────┴────┘

Several attempts were made to resolve this issue without success. Any suggestions on how to address this problem would be greatly appreciated.

javascript arrays

Answer 1

Answer №1

During each iteration of the outer loop, the inner loops assign all elements in the result array to sortedArray[0] on the first cycle, sortedArray[1] on the second cycle, and so forth. This results in the entire generated2DArray being filled with the same value on each pass through the outer loop.

To avoid using the outer loop, you can directly loop through the indexes in the 2D array and increment the index in the 1D array without nested looping structures.

k = 0;
for (let j = 0; j < generated2DArray.length; j++) {
    for (let i = 0; i < generated2DArray[j].length; i++) {
        generated2DArray[i][j] = sortedArray[k++];
    }
}

Answer 2

During each iteration of the outer loop, the inner loops assign all elements in the result array to sortedArray[0] on the first cycle, sortedArray[1] on the second cycle, and so forth. This results in the entire generated2DArray being filled with the same value on each pass through the outer loop.

To avoid using the outer loop, you can directly loop through the indexes in the 2D array and increment the index in the 1D array without nested looping structures.

k = 0;
for (let j = 0; j < generated2DArray.length; j++) {
    for (let i = 0; i < generated2DArray[j].length; i++) {
        generated2DArray[i][j] = sortedArray[k++];
    }
}

Answer 3

Answer №2

The issue arises from the fact that you are iterating through the entire grid for each element in your flattened and sorted array.

To address this problem, consider eliminating the outer loop and determining the position within the two-dimensional array using the following method:

for (let j = 0; j < generated2DArray.length; j++) {
    for (let i = 0; i < generated2DArray[j].length; i++) {
        generated2DArray[i][j] = sortedArray[i*generated2DArray.length+j];
    }
}

Answer 4

The issue arises from the fact that you are iterating through the entire grid for each element in your flattened and sorted array.

To address this problem, consider eliminating the outer loop and determining the position within the two-dimensional array using the following method:

for (let j = 0; j < generated2DArray.length; j++) {
    for (let i = 0; i < generated2DArray[j].length; i++) {
        generated2DArray[i][j] = sortedArray[i*generated2DArray.length+j];
    }
}

Answer 5

Answer №3

To efficiently rearrange the elements in a 2D array, you can first generate an array of random numbers and then sort it to create a sorted array. By calculating the row and column index based on the element's position in the sorted array, you can update the values in the output array accordingly.

const generateArray = (size, min, max) =>
  Array(size)
  .fill(0)
  .map(() => generateNumber(min, max));

const generateArray2D = (rows, cols, min, max) =>
  Array(rows)
  .fill(0)
  .map(() => generateArray(cols, min, max));

const generateNumber = (min, max) =>
  Math.floor(Math.random() * (max - min + 1)) + Math.floor(min);

const rows = 3
const cols = 4

const generated2DArray = generateArray2D(rows, cols, 10, 30);
const sortedArray = [...generated2DArray].flat(1).sort(((a, b) => a - b))

for (let i in sortedArray) {
  const col = Math.floor(i / rows)
  const row = i - (col * rows)

  generated2DArray[row][col] = sortedArray[i]
}

for (let a of generated2DArray) {
  console.log(JSON.stringify(a))
}

Answer 6

To efficiently rearrange the elements in a 2D array, you can first generate an array of random numbers and then sort it to create a sorted array. By calculating the row and column index based on the element's position in the sorted array, you can update the values in the output array accordingly.

const generateArray = (size, min, max) =>
  Array(size)
  .fill(0)
  .map(() => generateNumber(min, max));

const generateArray2D = (rows, cols, min, max) =>
  Array(rows)
  .fill(0)
  .map(() => generateArray(cols, min, max));

const generateNumber = (min, max) =>
  Math.floor(Math.random() * (max - min + 1)) + Math.floor(min);

const rows = 3
const cols = 4

const generated2DArray = generateArray2D(rows, cols, 10, 30);
const sortedArray = [...generated2DArray].flat(1).sort(((a, b) => a - b))

for (let i in sortedArray) {
  const col = Math.floor(i / rows)
  const row = i - (col * rows)

  generated2DArray[row][col] = sortedArray[i]
}

for (let a of generated2DArray) {
  console.log(JSON.stringify(a))
}

The unexpected actions while altering the direction of iteration in a 2D array and sorting elements

Answer №1

Answer №2

Answer №3

Similar questions

Array of initials for full names in JavaScript

Retrieving JSON information from a nested array

When utilizing AngularJS, a parse error is triggered by array[ {{value}} ], but I prefer to overlook it

The parent node is returning a child element

Sorting arrays can yield varying results depending on the browser being used

chart for visualizing two rows with matching IDs and dates

Having difficulty establishing a connection between my node.js application and the database

Is it possible to modify the dirpagination filter in AngularJS from an input box to a select box?

The three.js library is throwing an error because it is unable to access the 'geometry' property of an

Display only certain links using CSS or JavaScript/jQuery within a widget that appears once the webpage is fully loaded

Fetching images using node.js via URL

Sequencing and fulfillment of promises in a job queue using Promise.race

Having difficulty animating camera rotation in ThreeJS with Tween

EC2 experiencing issues with Node cron execution

Unable to find '/images/img-2.jpg' in the directory 'E:React eact-demosrc'

Troubleshooting a C++ array assignment issue: What mistake did I make in my code?

Error on page refresh: Unable to access properties of null while attempting to read 'addEventListener'

When utilizing PassportJS, SequelizeJS, and JWT tokens, req.user may be found to be undefined

Learn how to insert JavaScript code into the head of an iframe using jQuery

communication flow in two directions between server and client