DEV Community: Muhamad Taufik Satya

Apply Operations to an Array

Muhamad Taufik Satya — Sat, 01 Mar 2025 10:33:00 +0000

Optimizing Array Operations in TypeScript

Today, I explore a Daily Leetcode problem number 2640. Apply Operations to an Array using TypeScript that modifies an array based on specific rules:

If two consecutive elements are equal, double the first and set the second to 0.
After processing the array, move all zeroes to the end while keeping the relative order of other elements.

link to the question

Let’s break it down step by step.

Understanding the Code

Function Definition

function applyOperations(nums: number[]): number[] {

The function takes an array of numbers (nums) as input.

Step 1: Iterating Through the Array

  for (let i = 0; i < nums.length - 1; i++) {

We use a for loop to iterate from index 0 to second-last element (nums.length - 1). This ensures that we check each element and its next neighbor.

Step 2: Doubling Consecutive Equal Elements

    if (nums[i] == nums[i + 1]) {
      nums[i] *= 2;
      nums[i + 1] = 0;
    }

If two consecutive elements are equal, we:

Double the first element (nums[i] *= 2)
Set the second element to 0 (nums[i + 1] = 0)

Example Transformation:

Input:  [2, 2, 3, 3, 4]
Step 1: [4, 0, 3, 3, 4]  // (2+2 → 4, set next to 0)
Step 2: [4, 0, 6, 0, 4]  // (3+3 → 6, set next to 0)

Step 3: Moving Zeroes to the End

  return nums.filter(Boolean).concat(nums.filter((num) => !num));
}

We use .filter(Boolean) to remove 0s and keep non-zero values.
We use .filter(num => !num) to extract all zeroes.

Finally, we concatenate the two arrays to place zeroes at the end.

Example Output:

applyOperations([2, 2, 3, 3, 4]);
// Step 1: [4, 0, 6, 0, 4]
// Step 2: Remove zeros -> [4, 6, 4]
// Step 3: Add zeros at the end -> [4, 6, 4, 0, 0]

Final Optimized Code

function applyOperations(nums: number[]): number[] {
  for (let i = 0; i < nums.length - 1; i++) {
    if (nums[i] == nums[i + 1]) {
      nums[i] *= 2;
      nums[i + 1] = 0;
    }
  }
  return nums.filter(Boolean).concat(nums.filter((num) => !num));
}

Time & Space Complexity Analysis

Loop through the array → O(n)
Filtering & concatenation → O(n)
Overall Complexity: O(n) (linear time complexity)

Conclusion

This function efficiently:

Modifies the array in place.
Moves all zeroes to the end after processing.
Runs in O(n) time complexity, making it optimal for large inputs.

Special Array With X Elements Greater Than or Equal X (Go)

Muhamad Taufik Satya — Mon, 27 May 2024 10:30:39 +0000

On May 27 2024, I encountered a daily Leetcode challenge entitled

Special Array With X Elements Greater Than or Equal X

This challenge is relatively easy and quite friendly for beginners to practice. Because I'm learning Golang, I implemented it using that language.

For the question link, you can go to the following page.

Solution

First of all, let's define the function.

func specialArray(nums []int) int {

}

Then, initiate the loop and associated dependent variables such as x and count into the function.

func specialArray(nums []int) int {
    for i := 1; i <= len(nums); i++ {
        x := i
        count := 0
    }
}

Next, loop back over the nums array to compare whether each element is greater than x, if yes, add it to the count variable.

for _, v := range nums {
    if v >= x {
        count++
    }
}

Finally, check whether count is the same as x, if it is, immediately return x. However, if not, at the end of the function add return -1.

if count == x {
    return x
}

Complete code:

func specialArray(nums []int) int {
    for i := 1; i <= len(nums); i++ {
        x := i
        count := 0

        for _, v := range nums {
            if v >= x {
                count++
            }
        }

        if count == x {
            return x
        }
    }

    return -1
}

Calculate Determinant Matrix with Javascript

Muhamad Taufik Satya — Wed, 16 Aug 2023 06:22:26 +0000

Yesterday, I had difficulty doing a kata (challenge in codewars). I started getting used to doing 1 kata 1 day as part of my learning algorithm and data structures.

I also have a hard time understanding recursion. When I encountered a recursion problem for calculating the determinant matrix, I started trying to analyze it to find a solution.

Here is the question :

Write a function that accepts a square matrix (N x N 2D array) and returns the determinant of the matrix.

How to take the determinant of a matrix -- it is simplest to start with the smallest cases:

A 1x1 matrix |a| has determinant a.

A 2x2 matrix [ [a, b], [c, d] ] or
|a  b|
|c  d|
has determinant: a*d - b*c.

The determinant of an n x n sized matrix is calculated by reducing the problem to the calculation of the determinants of n matrices of n-1 x n-1 size.

For the 3x3 case, [ [a, b, c], [d, e, f], [g, h, i] ] or
|a b c|  
|d e f|  
|g h i|  
the determinant is: a * det(a_minor) - b * det(b_minor) + c * det(c_minor) where det(a_minor) refers to taking the determinant of the 2x2 matrix created by crossing out the row and column in which the element a occurs:
|- - -|
|- e f|
|- h i|  
Note the alternation of signs.

The determinant of larger matrices are calculated analogously, e.g. if M is a 4x4 matrix with first row [a, b, c, d], then:

det(M) = a * det(a_minor) - b * det(b_minor) + c * det(c_minor) - d * det(d_minor)

Solution

1. Define the function

/**
 * Calculate determinant on matrix
 * @param m: matrix [[]]
 * @returns determinant: number
 */
function determinant(m) {}

In this definition we have matrix parameters for determinant function and the desired result is a number

2. Know the dimensions of the matrix

const n = m.length;

Because it has been ascertained that the input matrix is always square or has the same N, what we need to know is NxN or what order the input matrix is.

3. Solve the easy-to-know possibilities first

if (n == 1) return m[0][0];

if (n == 2) {
    return m[0][0] * m[1][1] - m[0][1] * m[1][0];
}

Based on what has been told in the problem, if the matrix is of the order 1x1, then the result will be the matrix elements themselves. For matrices of order 2x2, we can directly calculate it with a*d - b*c for [[a, b], [c, d]].

4. Create a minor function inside determinant function

function minor(matrix, row, col) {
    return matrix
      .map((r, i) => r.filter((_, j) => i !== row && j !== col))
      .filter((r, i) => i !== row);
}

For the case of matrices of order greater than 2. In the problem, we are told to use the minor method, which is to make a 2x2 matrix outside of the rows and columns of elements being calculated. To do this we need to map the original matrix and filter out the rows and columns other than the rows and columns of elements calculated in row one.

5. Calculate and return determinant

let det = 0;

for (let col = 0; col < n; col++) {
    det += m[0][col] * determinant(minor(m, 0, col)) * (col % 2 === 0 ? 1 : -1);
}

return det;

After that, calculate the determinant using the minor method by calling the minor function for each of the first row elements based on the hint given by the question.

The full code can be seen as follows :

/**
 * Calculate determinant on matrix
 * @param m: matrix [[]]
 * @returns determinant: number
 */
function determinant(m) {
    const n = m.length;

    if (n == 1) return m[0][0];

    if (n == 2) {
        return m[0][0] * m[1][1] - m[0][1] * m[1][0];
    }

    function minor(matrix, row, col) {
        return matrix
            .map((r, i) => r.filter((_, j) => i !== row && j !== col))
            .filter((r, i) => i !== row);
    }

    let det = 0;

    for (let col = 0; col < n; col++) {
        det += m[0][col] * determinant(minor(m, 0, col)) * (col % 2 === 0 ? 1 : -1);
    }

    return det;
}

For tests :

/* Tests */
console.log(determinant([[1]])); // 1
console.log(
    determinant([
        [1, 2],
        [3, 4],
    ]),
); // -2
console.log(
    determinant([
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9],
    ]),
); // 0
console.log(
    determinant([
        [1, 2, 3, 4],
        [5, 6, 7, 8],
        [9, 10, 11, 12],
        [13, 14, 15, 16],
    ]),
); // 0