Run results for: transrorm template 2

Test name	Executions per second
✓ transform3	3,693 Ops/sec
transform2	99 Ops/sec
transform1	72 Ops/sec

transform1

var transform1 = (rowTemplate) => {
    if (!rowTemplate?.length) {
        return [[]];
    }

    const rows = rowTemplate.length;
    const cols = rowTemplate[0].length;

    const tiles = new Map();

    for (let row = 0; row < rows; row++) {
        for (let col = 0; col < cols; col++) {
            const id = rowTemplate[row][col];

            if (!tiles.has(id)) {
                tiles.set(id, { positions: [] });
            }

            tiles.get(id)?.positions.push({ row, col });
        }
    }

    const tilesByColumn = Array.from(tiles.keys()).sort((idA, idB) => {
        const posA = tiles.get(idA)?.positions[0];
        const posB = tiles.get(idB)?.positions[0];

        return posA.col === posB.col
            ? posA.row - posB.row
            : posA.col - posB.col;
    });

    const tilesByRow = Array.from(tiles.keys()).sort((idA, idB) => {
        const posA = tiles.get(idA)?.positions[0];
        const posB = tiles.get(idB)?.positions[0];

        return posA.row === posB.row
            ? posA.col - posB.col
            : posA.row - posB.row;
    });

    const tileMap = {};

    tilesByRow.forEach((rowId, index) => {
        tileMap[rowId] = tilesByColumn[index];
    });

    const result = Array(rows).fill(null)
        .map(() => Array(cols).fill(null));

    for (let row = 0; row < rows; row++) {
        for (let col = 0; col < cols; col++) {
            const originalId = rowTemplate[row][col];
            result[row][col] = tileMap[originalId];
        }
    }

    return result;
};

var t1 = [
    ["1", "1", "2", "3", "4", "4"],
    ["1", "1", "5", "6", "4", "4"]
];

for (var i=0; i < 10000; i++) {
	transform1(t1);
}

transform2

var transform2 = (rowTemplate) => {
  if (!rowTemplate?.length) return [[]];

  const rows = rowTemplate.length;
  const cols = rowTemplate[0].length;
  
  const firstPositions = {};
  
  for (let row = 0; row < rows; row++) {
    for (let col = 0; col < cols; col++) {
      const id = rowTemplate[row][col];
      if (firstPositions[id] === undefined) {
        firstPositions[id] = {row, col};
      }
    }
  }
  
  const uniqueIds = Object.keys(firstPositions);
  
  const rowIds = [...uniqueIds].sort((a, b) => {
    const posA = firstPositions[a];
    const posB = firstPositions[b];
    return posA.row === posB.row ? posA.col - posB.col : posA.row - posB.row;
  });
  
  const colIds = [...uniqueIds].sort((a, b) => {
    const posA = firstPositions[a];
    const posB = firstPositions[b];
    return posA.col === posB.col ? posA.row - posB.row : posA.col - posB.col;
  });
  
  const tileMap = {};
  
  for (let i = 0; i < rowIds.length; i++) {
    tileMap[rowIds[i]] = colIds[i];
  }
  
  const result = Array(rows);
  for (let row = 0; row < rows; row++) {
    result[row] = new Array(cols);
    for (let col = 0; col < cols; col++) {
      result[row][col] = tileMap[rowTemplate[row][col]];
    }
  }
  
  return result;
};

var t1 = [
    ["1", "1", "2", "3", "4", "4"],
    ["1", "1", "5", "6", "4", "4"]
];


for (var i=0; i < 10000; i++) {
	transform2(t1);
}

transform3

const transform3 = (rowTemplate) => {
    if (!rowTemplate?.length) {
        return [];
    }

    const rows = rowTemplate.length;
    const cols = rowTemplate[0].length;
    const result = [];

    for (let col = 0; col < cols; col++) {
        for (let row = 0; row < rows; row++) {
            result.push(rowTemplate[row][col]);
        }
    }

    return result;
};

var t1 = [
    ["1", "1", "2", "3", "4", "4"],
    ["1", "1", "5", "6", "4", "4"]
];


for (var i=0; i < 10000; i++) {
	transform3(t1);
}