DEV Community: Ankush Chudiwal

DSA problem - Second Largest

Ankush Chudiwal — Sat, 23 Nov 2024 19:17:51 +0000

Explanation of Code: Finding the Second-Largest Element in an Array

The code provides a solution to determine the second-largest element in an array. This is achieved through a single traversal while maintaining two variables to track the largest and second-largest values.

Code Walkthrough

class Solution {
    public int second_largest(int[] arr) {
        // Code Here
        int n = arr.length;

        // Special case: If the array has exactly 2 elements, return the smaller one
        if (n == 2) {
            int secmax = Math.min(arr[0], arr[1]);
            return secmax;
        }

        // Initialize variables to track the largest and second largest values
        int max = -1, secmax = -1;

        // Traverse the array
        for (int i = 0; i < n; i++) {
            // If the current element is greater than the current largest
            if (arr[i] > max) {
                secmax = max; // Update second largest
                max = arr[i]; // Update largest
            }
            // If the current element is less than the largest but greater than the current second largest
            else if (arr[i] < max) {
                secmax = Math.max(arr[i], secmax);
            }
        }

        // Return the second largest value
        return secmax;
    }
}

Step-by-Step Explanation

1. Handle Edge Cases

If the array contains exactly two elements:
- The second-largest element is simply the smaller of the two values.
- Example: For [3, 5], the second largest is 3.

2. Variables Initialization

max: Tracks the largest element in the array.
secmax: Tracks the second-largest element.
Both are initialized to -1 as a default value.

3. Traverse the Array

The loop iterates through the array elements to update the largest and second-largest values:

When the current element is greater than max:
- Update secmax to the previous value of max.
- Update max to the current element.
When the current element is smaller than max but greater than secmax:
- Update secmax to the current element.

4. Return the Result

After the loop, secmax holds the second-largest value.

Complexity Analysis

Time Complexity:
- The array is traversed once.
- Total time complexity: O(n), where n is the length of the array.
Space Complexity:
- The algorithm uses constant space for max and secmax.
- Space complexity: O(1).

Example Walkthrough

Example 1:

Input:

arr = [1, 4, 3, 2]

Execution:

Initialize max = -1, secmax = -1.
Traverse the array:
- 1: max = 1, secmax = -1.
- 4: max = 4, secmax = 1.
- 3: secmax = 3 (since 3 > secmax).
- 2: No update (since 2 < secmax).
Final values: max = 4, secmax = 3.

Output:

Example 2:

Input:

arr = [7, 7, 7, 7]

Execution:

All elements are equal, so no second largest exists.
secmax remains -1.

Output:

-1

Advantages

The algorithm efficiently finds the second-largest element in a single traversal.
It is memory-efficient as it uses constant space.

Good DSA problem -ROTATE ARRAY

Ankush Chudiwal — Sat, 23 Nov 2024 19:14:02 +0000

Check the git repo

Explanation of Code: Rotating an Array by `d` Elements (Counter-Clockwise)

The code provides a solution to rotate an array arr by d elements in a counter-clockwise direction using the reversal algorithm.

Code Walkthrough

class Solution {
    // Function to rotate an array by d elements in counter-clockwise direction.
    static void rotateArr(int arr[], int d) {
        int n = arr.length;

        // Edge case: If the array has only one element or no rotation needed
        if (n <= 1 || d <= 0) {
            return;
        }

        // Normalize d in case it's greater than or equal to array length
        d = d % n;

        // Step 1: Reverse the first d elements
        reverse(arr, 0, d - 1);

        // Step 2: Reverse the remaining elements
        reverse(arr, d, n - 1);

        // Step 3: Reverse the entire array
        reverse(arr, 0, n - 1);
    }

    // Helper function to reverse elements in the array
    private static void reverse(int arr[], int start, int end) {
        while (start < end) {
            // Swap elements at start and end
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
            start++;
            end--;
        }
    }
}

Step-by-Step Explanation

1. Handle Edge Cases

If the array length is 1 or less (n <= 1), or if no rotation is needed (d <= 0), the function exits early.
No modifications are performed on such inputs.

2. Normalize the Rotation Count

If d is greater than or equal to the array length (d >= n), rotating by d elements is equivalent to rotating by d % n.
This ensures the rotation count remains within bounds.

3. Reverse Algorithm for Rotation

The reversal algorithm rotates the array in three steps:

Reverse the first d elements
- Example: For an array [1, 2, 3, 4, 5] and d = 2, reverse [1, 2] to get [2, 1, 3, 4, 5].
Reverse the remaining n - d elements
- Reverse [3, 4, 5] to get [2, 1, 5, 4, 3].
Reverse the entire array
- Reverse [2, 1, 5, 4, 3] to get [3, 4, 5, 1, 2].

4. Helper Function: `reverse`

The reverse function swaps elements in the array between the specified start and end indices.
It iteratively swaps elements until the pointers meet.

Complexity Analysis

Time Complexity:
- Reversing subsets of the array involves traversing all elements exactly once.
- Total time complexity: O(n), where n is the length of the array.
Space Complexity:
- The algorithm uses constant extra space for swapping elements.
- Space complexity: O(1).

Example Walkthrough

Input:

arr = [1, 2, 3, 4, 5]
d = 2

Execution:

Normalize d: d = 2 % 5 = 2
Reverse the first d elements: [1, 2] → [2, 1]
- Array becomes: [2, 1, 3, 4, 5]
Reverse the remaining elements: [3, 4, 5] → [5, 4, 3]
- Array becomes: [2, 1, 5, 4, 3]
Reverse the entire array: [2, 1, 5, 4, 3] → [3, 4, 5, 1, 2]

Output:

[3, 4, 5, 1, 2]

Advantages

The reversal algorithm is efficient and does not require additional space.
It provides a systematic approach to solving array rotation problems.

🚀 Made A AI-Powered Content Summarizer Chrome Extension

Ankush Chudiwal — Sat, 16 Nov 2024 16:37:20 +0000

🔗 GitHub Repository

What is it?

Tired of spending hours reading long articles or web pages? The AI-Powered Content Summarizer extension is here to save your time and effort! Using ApyHub's AI summarization API, this tool condenses web content into short, medium, or long summaries—all at the click of a button.

✅ Available for Chrome and Firefox!

✨ Features

Summarize web pages effortlessly in seconds.
Choose between Short, Medium, or Long summaries.
Simple popup interface for quick access.
Compatible with Chrome and Firefox browsers.
Powered by ApyHub AI for concise and accurate results.

How to Use

Chrome

Clone the repository:

   git clone https://github.com/Ankush1oo8/ai-content-summarizer.git

Load the extension:
- Navigate to chrome://extensions/.
- Enable Developer Mode.
- Click Load Unpacked and select the project folder.
Add your ApyHub API Key in the background.js file.
Navigate to any webpage, click the extension, and choose your summary length!

Firefox

Clone the repository as above.
Open Firefox, go to about:debugging#/runtime/this-firefox.
Click Load Temporary Add-on and select the manifest.json file from the project folder.
Add the API key as instructed in the code files.

🔧 How It Was Made

The AI-Powered Content Summarizer was developed with simplicity and user-friendliness in mind. Here's the step-by-step process:

Identifying the Problem:

We wanted a tool to simplify web content for users who value their time—students, professionals, or casual readers.
Choosing the Right API:

We integrated ApyHub's AI summarization API for its speed, accuracy, and versatility.
Building the Extension:
- Manifest v3 for Chrome to define permissions and functionality.
- A background script to handle API calls and processing.
- A clean popup interface (HTML, CSS, JavaScript) for user interaction.
Testing on Browsers:

The extension was tested on Chrome and Firefox to ensure compatibility and seamless performance.
Publishing & Open-Sourcing:

By making the code open-source, we encourage developers to use, improve, and contribute to the project.

Why You’ll Love It

This extension is perfect for anyone who:

Wants concise summaries of long content.
Needs to save time while staying informed.
Prefers a straightforward, easy-to-use tool.

🛠️ Explore the Code: Check out the full project on GitHub: ai-content-summarizer

🌟 Feedback Welcome: Found a bug or have ideas for improvement? Feel free to open an issue or contribute!

License

This project is licensed under the MIT License. Learn more in the repository.

DEV Community: Ankush Chudiwal

DSA problem - Second Largest

Explanation of Code: Finding the Second-Largest Element in an Array

Code Walkthrough

Step-by-Step Explanation

1. Handle Edge Cases

2. Variables Initialization

3. Traverse the Array

4. Return the Result

Complexity Analysis

Example Walkthrough

Example 1:

Example 2:

Advantages

Good DSA problem -ROTATE ARRAY

Explanation of Code: Rotating an Array by d Elements (Counter-Clockwise)

Code Walkthrough

Step-by-Step Explanation

1. Handle Edge Cases

2. Normalize the Rotation Count

3. Reverse Algorithm for Rotation

4. Helper Function: reverse

Complexity Analysis

Example Walkthrough

Input:

Execution:

Output:

Advantages

🚀 Made A AI-Powered Content Summarizer Chrome Extension

What is it?

✨ Features

How to Use

Chrome

Firefox

🔧 How It Was Made

Why You’ll Love It

License

Explanation of Code: Rotating an Array by `d` Elements (Counter-Clockwise)

4. Helper Function: `reverse`