Category: Javascript Coding Test

Coding tests have become a mandatory process for many companies these days. In particular, JavaScript is a programming language widely used in web development, and solving geometric problems greatly aids in understanding algorithms. In this article, we will introduce a geometric algorithm problem that can be solved with JavaScript and explain the solution process in detail.

Problem Description

The following is a problem of determining whether two points are inside a given rectangle.

Problem: Determine if Points are Inside a Rectangle

The coordinates of the bottom-left corner of the given rectangle are (x1, y1), and the coordinates of the top-right corner are (x2, y2). Additionally, there are two points A(xA, yA) and B(xB, yB). Write a function to determine whether these points are inside the rectangle.

Input

• Bottom-left corner of the rectangle: (x1, y1)
• Top-right corner of the rectangle: (x2, y2)
• Point A: (xA, yA)
• Point B: (xB, yB)

Output

Write a function that returns true if each point is inside the rectangle, and false otherwise. If both points are inside, return true; otherwise, return false.

Solution Process

Now let’s go through the steps to solve this problem.

Step 1: Understanding the Problem

We have the coordinates of the rectangle’s corners and need to verify the coordinates of each point. The conditions for being inside the rectangle are as follows:

• x1 < xA < x2
• y1 < yA < y2
• x1 < xB < x2
• y1 < yB < y2

Each point must satisfy all the above conditions to be considered inside the rectangle.

Step 2: Writing the Function

Here is the JavaScript code based on this logic.

function isPointInsideRectangle(x1, y1, x2, y2, xA, yA, xB, yB) {
    const isAInside = (x1 < xA && xA < x2) && (y1 < yA && yA < y2);
    const isBInside = (x1 < xB && xB < x2) && (y1 < yB && yB < y2);
    
    return isAInside && isBInside;
}

// Test
const result = isPointInsideRectangle(0, 0, 10, 10, 5, 5, 5, 5); // true
console.log(result);
    

Step 3: Testing and Verification

Let’s test the function. We confirmed that when the bottom-left corner of the rectangle is (0, 0) and the top-right corner is (10, 10), the point (5, 5) is inside.

In the example above, both points are the same (5, 5), so the function returns true. However, it should return false if one point is outside the rectangle.

Step 4: Checking Various Cases

We can validate the function through various cases. Here are additional test examples.

// Case 1: Both points are inside
console.log(isPointInsideRectangle(0, 0, 10, 10, 1, 1, 2, 2)); // true

// Case 2: Only one point is inside
console.log(isPointInsideRectangle(0, 0, 10, 10, 1, 1, 11, 11)); // false

// Case 3: Both points are outside
console.log(isPointInsideRectangle(0, 0, 10, 10, -1, -1, 11, 11)); // false

// Case 4: Located on the edge of the rectangle
console.log(isPointInsideRectangle(0, 0, 10, 10, 0, 5, 5, 10)); // false
    

Conclusion

Now we have completed the function to determine whether the points are inside a given rectangle using JavaScript. Problems like these are great for developing algorithmic thinking and are frequently presented in coding tests.

I hope this article helped you understand the basics of geometric problems and how to apply them. Continue to challenge yourself with various algorithmic problems!

In this article, we will deal with the Bridge Building problem, which is one of the coding test problems using JavaScript. This problem utilizes the concept of combinations and has many applications. We will examine the problem definition, various approaches, and the solution process in great detail.

Problem Definition

Problem: There are two islands in a river. We want to build a bridge between the two islands. Given that we can build N bridges, we need to determine how many different ways we can construct these bridges. However, the bridges must not interfere with each other, and there are designated positions for the bridges on each island.

Example Input/Output

• Input: N = 3
• Output: 5 (the number of ways to build the bridges)

Problem Analysis

This problem serves as a foundation for understanding the properties of combinations. The positions of the bridges must be placed at fixed positions on the two islands, so the selection of bridges must not interfere with each other. We will refer to the two islands where the bridges will be placed as A and B. The positions for placing bridges on each island can be represented by indices starting from 0.

Approach

There are various approaches to solving combination problems. In the case of this problem, it is advisable to use the Dynamic Programming method. First, we will set basic situations as needed and develop more complex situations based on those.

Dynamic Programming Approach

To solve the bridge building problem using dynamic programming, we can set up the following recurrence relation:

count(N) = count(N-1) + count(N-2)

Here, count(N) represents the number of ways to place N bridges. The meaning of this equation is as follows:

• In the case of placing N-1 bridges, adding the last bridge (only one bridge is added).
• In the case of already placing N-2 bridges, adding two new bridges.

Algorithm Implementation

Now, based on the above recurrence relation, let’s implement the algorithm in JavaScript. Here is an example of the function:

function countWays(n) {
    if (n === 0) return 1; // Base case: not placing any bridges
    if (n === 1) return 1; // Base case: placing one bridge

    let dp = new Array(n + 1);
    dp[0] = 1;
    dp[1] = 1;

    for (let i = 2; i <= n; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }

    return dp[n];
}
    
let n = 3;
console.log(countWays(n)); // Result: 5
    

Code Explanation

The above function works through the following steps:

• If n is 0, it returns 1 to handle the base case.
• If n is 1, it also returns 1 to handle the case of placing only one bridge.
• Then, it initializes the array dp based on the number of bridges, and uses the recurrence relation to calculate the number of ways to place the bridges.

Time Complexity

The time complexity of this algorithm is O(N). This is because it calculates the result by traversing the array once. The space complexity is also O(N) since an array is used to store the number of ways depending on the number of bridges.

Conclusion

Through this tutorial, we have learned how to solve the bridge building problem using JavaScript. This problem greatly aids in understanding the concept of combinations and optimization approaches using dynamic programming. We hope to expand basic programming skills and develop the ability to utilize various algorithms through such problems. We look forward to solving more algorithm problems together in the future!

Hello! Today we will learn how to solve coding test problems with JavaScript. The topic of this tutorial is ‘Finding the K-th Number’. Through this problem, we will learn how to sort an array and find the value at a specific index. Let’s look at the problem statement and the solution process step by step.

Problem Description

You need to find the K-th number that satisfies certain conditions from the given array. The specific problem description is as follows.

Problem: Finding the K-th Number

Given an array and an integer K, you need to return the K-th smallest number after sorting the array in ascending order.

Input:
- First line: Integer N (length of the array), Integer K (position of the number to find)
- Second line: An array of N integers

Output:
- K-th smallest number

Example

• Input: 5 2
• Array: [3, 1, 2, 5, 4]
• Output: 2

From the above input values, if we sort the array in ascending order, it becomes [1, 2, 3, 4, 5], and the 2nd number is 2.

Solution Process

The steps required to solve the problem are as follows.

1. Read the input values and set the array and K.
2. Sort the array in ascending order.
3. Output the value at the K-th index.

Step 1: Read Input Values

In JavaScript, you can use the prompt function to receive input values. However, coding test platforms usually read values through standard input. Here, we will directly declare the array for testing.

const arr = [3, 1, 2, 5, 4];
const K = 2; // K-th number

Step 2: Sort the Array

In JavaScript, you can use the sort method to sort an array. This method performs string sorting by default, so you need to provide a callback function for number sorting.

arr.sort((a, b) => a - b);

The above code sorts the array in ascending order, meaning it arranges from the smallest number to the largest number.

Step 3: Return the K-th Number

Since array indices start at 0, to get the K-th number, you need to use K-1 as the index. Therefore, you can do the following.

const kthNumber = arr[K - 1];
console.log(kthNumber); // Output

Complete Code

Now, let’s combine all the steps and write the complete code.

function findKthNumber(arr, K) {
    // Sort the array in ascending order
    arr.sort((a, b) => a - b);
    
    // Return the K-th number (K is 1-based index, so use K-1)
    return arr[K - 1];
}

// Test
const arr = [3, 1, 2, 5, 4]; // Example array
const K = 2; // K-th number
const result = findKthNumber(arr, K);
console.log(result); // Output result: 2

Conclusion

In this tutorial, we solved the ‘Finding the K-th Number’ problem. We learned how to use the JavaScript array method sort to sort an array and find the value at a specific position. When solving algorithm problems, it is important to understand the problem well and break it down into smaller units. Next time, we will come back with more diverse problems. Thank you!

1. Problem Description

This is a problem to create and return a set of unique elements from the given array. This type of problem is frequently asked in coding tests using JavaScript and helps in understanding the concept of sets.

2. Problem Definition

**Problem:** Write a function uniqueElements(arr) that takes an array as input and returns a new array with duplicates removed.

        
            // Example input
            uniqueElements([1, 2, 2, 3, 4, 4, 5]); // Returns: [1, 2, 3, 4, 5]
            uniqueElements(['apple', 'banana', 'apple']); // Returns: ['apple', 'banana']
        
    

3. Approach

There are various ways to solve this problem. However, utilizing the properties of a set in JavaScript is the most efficient way. The set data structure automatically removes duplicates, as it only stores unique values.

3.1. Method 1: Using the Set Object

Using the Set object to remove duplicates is very intuitive. When you pass an array to the Set, you get a Set object with duplicates removed, which can then be converted back to an array to return the result.

        
            function uniqueElements(arr) {
                return [...new Set(arr)];
            }
        
    

3.2. Method 2: Using Filter and Index

Another method is to use the array’s filter method to remove duplicates. This approach can determine whether an item is a duplicate by comparing its first occurrence index with the current index.

        
            function uniqueElements(arr) {
                return arr.filter((item, index) => arr.indexOf(item) === index);
            }
        
    

3.3. Method 3: Removing Duplicates Using an Object

You can use an object in a performance-efficient way to remove duplicates. Store each element as a key in the object, and at the end, create a new array using only the keys of this object.

        
            function uniqueElements(arr) {
                const uniqueObj = {};
                
                arr.forEach(item => {
                    uniqueObj[item] = true;
                });
                
                return Object.keys(uniqueObj);
            }
        
    

4. Code Implementation

Below is an implementation example using the first method, which employs Set as described above.

        
            function uniqueElements(arr) {
                return [...new Set(arr)];
            }

            // Tests
            console.log(uniqueElements([1, 2, 2, 3, 4, 4, 5])); // [1, 2, 3, 4, 5]
            console.log(uniqueElements(['apple', 'banana', 'apple'])); // ['apple', 'banana']
        
    

5. Time Complexity Analysis

The time complexity of all methods is O(n), where n is the length of the array. The method using Set is the most concise and intuitive, and since it’s a feature provided by ES6, it also enhances code readability. The methods using filter or objects may have additional memory usage.

6. Conclusion

Through this problem, we have understood the concept of sets in JavaScript and learned various ways to remove duplicates from an array. Such problems are commonly featured in coding tests, so it’s essential to familiarize yourself with the data structures and algorithms that can be utilized. Understanding and using new features like Set in ES6 helps in writing cleaner code.

7. Additional Practice Problems

There may be other problems such as:

• Write a function to count the number of duplicate elements in an array
• Find common elements between two arrays
• Count non-duplicate characters in a string

I hope solving these problems helps you learn various features of JavaScript.