Author: root

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!

Problem Description

We are trying to raise donations to help the less fortunate. Each donor simply needs to input the amount they can donate. The amount entered by the donor is stored in a list, and a function to calculate the total amount donated is to be implemented. Additionally, the maximum amount a donor can donate is limited to 100,000 won.

Input

The number of donors n (1 <= n <= 1000) and each donor’s donation amount are provided.

Output

Print the total sum of all donations.

Example Input

    5
    10000
    25000
    50000
    120000
    30000
    

Example Output

    95000
    

Approach to Problem Solving

This problem requires a simple algorithm to process the given input values and calculate the total. We can approach it by storing the donation amounts in an array and summing all elements in the array to derive the result. The following are the steps to solve this problem.

Step 1: Taking Input

To take input, we will receive the number of donors (n) and each donor’s donation amount from the user. These input values will be stored in an array. Donations exceeding 100,000 won will be ignored, so a logic to check this is needed.

Step 2: Storing Donation Amounts in an Array

Only valid donation amounts will be added to the array, and a variable will be set to calculate the total donation amount.

Step 3: Calculating and Printing the Total

Calculate the sum of donation amounts stored in the array and print the result.

JavaScript Code Implementation

Now let’s implement the entire logic in JavaScript code. Below is the code based on the logic described above:

function calculateDonation() {
    const n = parseInt(prompt("Please enter the number of donors: "));
    let donations = [];
    let totalDonation = 0;

    for (let i = 0; i < n; i++) {
        let donation = parseInt(prompt(`Please enter the ${i + 1}th donation amount: `));

        // Add to the array only if the donation amount is 100,000 won or less
        if (donation <= 100000) {
            donations.push(donation);
            totalDonation += donation;
        } else {
            console.log("The donation amount must be 100,000 won or less.");
        }
    }

    console.log(`Total donations: ${totalDonation} won`);
}

calculateDonation();
    

Code Explanation

Analyzing the code, the calculateDonation function is defined, where the user first inputs the number of donors. Then, using a for loop, each donation amount is inputted, and a conditional statement adds it to the array only if it is 100,000 won or less, calculating the sum at the same time. If the donation amount exceeds this, a warning message is printed. Finally, the total donation amount is displayed.

Conclusion

In this tutorial, we implemented a simple program to manage donation data using JavaScript. This code allows easy calculation of total donations and includes logic to check the number of donors and the validity of donation amounts. Through this experience of solving simple problems, we can gain confidence in solving algorithmic challenges.

Additional Practice Problems

To further practice problem solving, try tackling the following additional problems:

1. Add a feature to sort the donation amounts in ascending order.
2. Calculate the average donation amount of the donors.
3. Implement a feature to automatically add an additional 10% donation when the number of donors exceeds 10.

Final Remarks

Programming practice requires a deep understanding that goes beyond just solving problems. Based on the experiences and knowledge gained through this problem-solving process, aim to create your own programs or tackle more complex algorithmic challenges with confidence.