Category: Javascript Coding Test

JavaScript Coding Test Course – Sorting Numbers 2

In this course, we will deeply analyze the algorithm problem called ‘Sorting Numbers 2’ and explain the step-by-step process to solve it. We will look into how to solve the problem using JavaScript along with its definition.

Problem Definition

The problem is as follows. Given a set of numbers, write a program to sort these numbers in ascending order. Please note that the number of inputs can be up to 10,000. Below, we will provide the exact input and output formats along with examples.

Input

The first line contains the number of integers N (1 ≤ N ≤ 10,000). Then, N lines follow, each containing a single integer. This integer will be between -1,000,000 and 1,000,000, inclusive.

Output

The integers received as input must be printed in ascending order, one per line.

Example Input

5
5
3
2
1
4

Example Output

1
2
3
4
5

Problem Approach

The key to this problem is sorting the N given integers. There are many methods available, but it is important to choose an efficient sorting algorithm. In JavaScript, you can typically use the Array.sort() method.

The Array.sort() method performs string sorting by default, so a comparison function is necessary to sort actual numbers. Care is needed when using the built-in sort() method in JavaScript, especially considering time complexity when processing a large amount of numbers.

Solution Method

Let’s step through the process of solving the problem.

1. Prepare the input data.

   First, you need to declare variables necessary for reading the input data presented by the problem and store the data in an array. At this time, we will use JavaScript’s Array to store the numbers dynamically.

2. Sort the input numbers.

   Use the Array.sort() method to sort the input array. Define a comparison function to allow for number comparison.

3. Output the sorted numbers.

   Use a function or method to print the values of the sorted array, outputting one number per line.

JavaScript Code Implementation

Based on the solution methods mentioned above, the JavaScript code can be implemented as follows:

function sortNumbers(input) {
  const N = parseInt(input[0]); // The first line is the number of integers
  const numbers = input.slice(1, N + 1).map(Number); // Convert the remaining N numbers to integers and store in an array

  numbers.sort((a, b) => a - b); // Sort in ascending order

  return numbers.join('\\n'); // Return sorted numbers to print one per line
}

// Example input
const input = [
  '5',
  '5',
  '3',
  '2',
  '1',
  '4'
];

console.log(sortNumbers(input)); // Output the result

Code Explanation

Let us look more closely at each part of the code:

• Input Handling: parseInt(input[0]) is used to retrieve the number of integers from the first line. input.slice(1, N + 1) selects the numbers excluding the first line, and map(Number) converts the string array to a number array.
• Sorting: numbers.sort((a, b) => a - b) compares two numbers and sorts them in ascending order. It returns a - b so that if the first argument is less than the second, it returns a negative number, if greater, a positive number, and if equal, 0.
• Output Handling: join('\\n') connects each element of the array with a newline character to create a string that can be printed.

Test Cases

You can consider several test cases using the defined code:

Test Case 1

Input:
5
5
3
2
1
4

Output:
1
2
3
4
5

Test Case 2

Input:
4
10
30
20
40

Output:
10
20
30
40

Test Case 3

Input:
3
-1
-5
2

Output:
-5
-1
2

Final Words

In this course, we have learned how to solve the algorithm problem ‘Sorting Numbers 2’. Various sorting algorithms can be utilized, but it is essential to select an appropriate algorithm based on the scope and requirements of the problem. Furthermore, leveraging JavaScript’s powerful features allows for efficient implementation.

We will continue to share methods for solving various algorithm problems, so please stay tuned. Enhance your skills in well-organized problem-solving to open the door to employment!

To prepare for a resignation in a rational and effective manner, various skills and knowledge are required. In particular, proficiency in programming languages such as JavaScript plays a crucial role in preparing for coding tests. In this post, I will introduce an algorithm problem using JavaScript and explain the process of solving it in detail.

Problem Description

nums = [2, 7, 11, 15]

[0, 1]

Problem Solving Strategy

There are various methods to approach this problem. Here are some representative approaches:

• My Approach: Using a double loop to compare two numbers
• Approach using hashmap: Allows quick lookup when necessary

1. Approach Using Double Loop

The most intuitive way is to use a double loop to check all combinations of two numbers. We validate whether we reach the target sum by checking every combination of numbers. However, this method has a time complexity of O(n²), which can degrade performance.

function twoSum(nums, target) {
    for (let i = 0; i < nums.length; i++) {
        for (let j = i + 1; j < nums.length; j++) {
            if (nums[i] + nums[j] === target) {
                return [i, j];
            }
        }
    }
}

// Example execution
const nums = [2, 7, 11, 15];
const target = 9;
console.log(twoSum(nums, target)); // [0, 1]

2. Approach Using Hashmap

A more efficient method is to use a hashmap. As we iterate through the numbers, we store each number’s value as a key and its index as a value. Then, we compute the required difference for each value and look up this difference in the hashmap, allowing us to solve the problem in linear time complexity O(n).

function twoSum(nums, target) {
    const numMap = new Map();
    
    for (let i = 0; i < nums.length; i++) {
        const complement = target - nums[i];
        if (numMap.has(complement)) {
            return [numMap.get(complement), i];
        }
        numMap.set(nums[i], i);
    }
}

// Example execution
const nums = [2, 7, 11, 15];
const target = 9;
console.log(twoSum(nums, target)); // [0, 1]

Time Complexity

The first method has a time complexity of O(n²), while the second method has a time complexity of O(n). Thus, the second method is much more efficient. The second method has a space complexity of O(n) as it makes use of an additional hashmap.

Conclusion

This problem allowed me to improve my coding skills in JavaScript and try various approaches. In particular, the problem-solving method utilizing a hashmap can be very useful in coding tests.

As you prepare for resigning, you will need to prepare for coding tests. I hope to enhance my algorithm problem-solving abilities through repeated practice and increase my application skills in actual coding tests. Please look forward to the next post where I will tackle more complex problems!

Today, we will learn about one of the most basic sorting algorithms in JavaScript, Bubble Sort. Bubble sort is a simple but inefficient sorting algorithm, primarily used for educational purposes or to learn the fundamentals of algorithms.

Overview of Bubble Sort

Bubble sort works by repeatedly traversing a given list, comparing two adjacent elements and swapping their order. This process continues until it is determined that the list is sorted. In the worst case, the time complexity is O(n^2).

How It Works

The basic operation of bubble sort is as follows:

1. Start from the first element of the list and compare two adjacent elements.
2. If the left element is greater than the right element, swap their positions.
3. Repeat this process until the end of the list. After one pass, the largest element will move to the end.
4. Repeat the above process (steps 1-3) for the remaining elements.

Problem Definition

Problem Description

You are given an array arr. Write a function that uses the bubble sort algorithm to sort this array in ascending order and return the sorted array.

Example Input

arr = [64, 34, 25, 12, 22, 11, 90]

Example Output

[11, 12, 22, 25, 34, 64, 90]

Solution Process

Step 1: Function Definition

First, we will define a function to perform bubble sort. We will name the function bubbleSort. It will take an array as input.

Step 2: Using Nested Loops

Bubble sort is implemented using nested loops. The outer loop progresses to the last element of the array, while the inner loop compares two adjacent elements to sort them.

Step 3: Implementing the Comparison and Swap Logic

In the inner loop, compare two adjacent elements and swap their order. We can use a simple conditional statement for this.

function bubbleSort(arr) {
        let n = arr.length;
        for (let i = 0; i < n - 1; i++) {
            for (let j = 0; j < n - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    // Swap elements
                    let temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        return arr;
    }

Step 4: Adding a Utility Function (Optional)

You may write a utility function to print the array to check the sorted result. You can use a simple console.log to verify the results.

const arr = [64, 34, 25, 12, 22, 11, 90];
    console.log(bubbleSort(arr)); // [11, 12, 22, 25, 34, 64, 90]

Time Complexity of Bubble Sort

The time complexity of bubble sort is O(n^2) in the worst case. This is because the entire array is iterated twice. In the best case (when it is already sorted), it is O(n), but generally it is inefficient.

The space complexity is O(1), which makes it efficient since the additional memory used is constant.

Significance and Use of Bubble Sort

Due to its simple implementation, bubble sort is suitable for learning algorithms. However, its performance is relatively poor in real industrial applications, where other sorting algorithms are preferred. Nevertheless, it is an important fundamental concept that can be understood while studying algorithms.

Conclusion

In this article, we learned how to implement bubble sort in JavaScript. I hope this helps you understand basic sorting algorithms and serves as a stepping stone to learn more complex algorithms. If you have any questions or need additional information, please leave a comment!