DEV Community: Arpan Patel

TIL: Understanding Design Ideation

Arpan Patel — Sun, 29 Sep 2024 17:50:02 +0000

Today I learned about the concept of design ideation, an essential step in the design thinking process. Ideation is about generating a broad set of ideas on a given topic without immediately evaluating them. It’s a creative phase meant to encourage exploration and innovation, where quantity takes precedence over quality. Let's dive deeper into what this process entails and how it plays out in real-world scenarios.

What is Ideation?

At its core, ideation is the process of brainstorming potential solutions to a problem without filtering or critiquing ideas. It’s a space for creativity to thrive. The beauty of ideation lies in the fact that it allows for the generation of a diverse range of possibilities, giving teams ample room to explore different approaches.

Ideation in Action

In practice, ideation involves several key steps:

Brainstorm out loud:
Encourage open, verbalized brainstorming to share ideas freely.
Document all ideas:
Every idea, no matter how outlandish, is worth capturing.
Focus on quantity:
The more ideas generated, the better. Aim for variety and volume.
Avoid immediate evaluation:
Resist the temptation to critique or discard ideas during the brainstorming phase.
Bring together a diverse team:
Diversity sparks innovation. People from different backgrounds contribute unique perspectives.
Question the obvious:
Challenge assumptions and consider unorthodox solutions.

Once the brainstorming is done, you can start evaluating the ideas based on three key criteria:

Feasibility: Is this technically possible to build?
Desirability: Does this idea solve the user's problem?
Viability: Is this solution financially beneficial for the business?

Preparing for Ideation

Before diving into ideation, it’s important to complete the first two phases of the design thinking process: empathize and define.

Empathize with the user:
Understand who you’re designing for and what their needs are. This phase often includes creating empathy maps, personas, user stories, and journey maps to get a clear sense of the user’s experience.
Define the problem:
Clearly articulate the problem you’re trying to solve. A well-defined problem keeps your team aligned and focused during the ideation phase, ensuring that the solutions you generate address the user’s needs.

How to Ideate Effectively

Create a conducive environment: Whether you're meeting in person or virtually, choose a space that fosters creativity. A different environment can often trigger new ways of thinking.
Set a time limit: Although there are countless ideas you could generate, it's important to set boundaries. This ensures that you transition from idea generation to refining and selecting the best ideas.
Assemble a diverse team: Bring together people with different backgrounds, perspectives, and life experiences. The more diverse your team, the richer your pool of ideas will be.
Think outside the box: Don’t be afraid to propose unconventional ideas. Sometimes, the most innovative solutions come from thinking beyond traditional boundaries.

Inorder Traversal in a Nutshell 🥜

Arpan Patel — Thu, 08 Feb 2024 16:17:54 +0000

What is Inorder Traversal ?

Inorder Traversal is a type of tree traversal technique which follows the Left-Root-Right pattern.

Left-Root-Right pattern

The left subtree is traversed first.
Then the root node for the subtree is traversed.
Finally, the right subtree is traversed.

Example 1:

Example 2:

Understanding the Sliding Window Technique

Arpan Patel — Fri, 01 Sep 2023 20:09:23 +0000

What is the Sliding Window Technique? 🤔

The sliding window technique is a common algorithmic strategy used to solve problems involving arrays, strings, or sequences where you maintain a dynamic "window" of elements and slide it through the data to perform specific operations or calculations efficiently. The window is typically defined by two pointers, often referred to as the "left" and "right" pointers, and it represents a subset of the elements within the given data structure.

Visualize Sliding Window 👀:

When to use the technique (key terms):

Maximum
Minimum
Longest
Shortest
Sum
Product
Subarray
Substring
Array
String

Example LeetCode problems:

Code walkthrough :

Longest Substring Without Repeating Characters

Problem Description:

Given a string s, find the length of the longest

substring

without repeating characters.

Example 1:

Input: s = "abcabcbb"
Output: 3
Explanation: The answer is "abc", with the length of 3.

Example 2:

Input: s = "bbbbb"
Output: 1
Explanation: The answer is "b", with the length of 1.

Example 3:

Input: s = "pwwkew"
Output: 3
Explanation: The answer is "wke", with the length of 3.
Notice that the answer must be a substring, "pwke" is a subsequence and not a substring.

Solution:

var lengthOfLongestSubstring = function(s) {
    // Initialize a set to keep track of characters inside the current window
    const charSet = new Set(); 

    // initialize two pointers to set window boundaries
    let start = 0;
    let end = 0; 

    // initalize var to keep track of maximum length of substring without repeating characters.
    let maxLen = 0; 

    // iterate throught the string from the 'end' pointer. 
    while(end < s.length) {
        // check if the character at 's[end]' is not already in the set. 
        if(!charSet.has(s[end])){
            // add the character to the set
            charSet.add(s[end]); 

            // calculate the current substring length and update the 'maxLen'
            maxLen = Math.max(maxLen, end - start + 1);

            // move the 'end' pointer to expand the window 
            end++; 
        }else{
            // if the character is already in the set, remove characters from 'start' until the duplicates are gone.
            charSet.delete(s[start]); 
            // move the 'start' pointer to shrink the window
            start++; 
        }
    }

    // Return the maximum length of the substring without repeating characters. 
    return maxLen; 
};


// time complexity: O(n)
// space complexity: O(k)

References:

LeetCode
GG

Binary Search Decoded: Navigating Search Algorithms

Arpan Patel — Thu, 31 Aug 2023 18:07:36 +0000

What is Binary Search & how does it work ? 🤔

Binary Search is a searching algorithm that is applicable only to sorted arrays. It operates by repeatedly dividing the search interval in half, narrowing down the potential locations of the target value with each iteration. This cycle of dividing and searching continues until the target value has been found or until it is determined that the element is not in the array.

What is the Space & Time Complexity of Binary Search? ⏰

The average time complexity of the Binary Search algorithm is O(log N), where N is the number of elements in the array. This logarithmic time complexity arises from the fact that with each step, the search interval is halved, leading to a rapid reduction in the number of remaining elements to search through.

The space complexity of Binary Search is O(1), indicating constant space usage. The algorithm doesn't require additional memory that scales with the size of the input; it only uses a few variables to keep track of the indices and midpoints during the search.

Exploring Binary Search: A Deep Dive with Code Examples 🧑🏻‍💻

Problem 1:

Given a sorted array and a target integer value, find and return the index location of the target value.

Example:

array = [1,4,7,10,11,34,40,42]

target = 34

Technique & Approach being used:


function search(arr, target){
    // Initalize pointers

    // left: starts at the beginning of the array 
    let left = 0;  
    // right: starts at the end of the array
    let right = arr.length - 1; 

    //condition: continue loop until left pointer is <= to the right pointer
    while(left <= right){

        // calculate the midpoint of the current search interval
        let mid = Math.floor((left + right) / 2); 

        // if the mid point === the target value "we found the target's location"
        if(arr[mid] === target){
                //return the index value of the mid point
                return mid
        }
        // otherwise if the target value is less than the midpoint value. 
        else if (target < arr[mid]){
        //narrow the search range to the left half
        right = mid -1 
        }
        // otherwise if the target is larger than the midpoint value
        else{
        // narrow the search range to the right half
        left = mid + 1
        }
    }
    //if the loop completes without finding the target return -1. 
    return -1 
}

//Time complexity: O(logn)
//Space complexity: O(1)

Problem 2:

There is an integer array nums sorted in ascending order (with distinct values).

Prior to being passed to your function, nums is possibly rotated at an unknown pivot index k (1 <= k < nums.length) such that the resulting array is [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]] (0-indexed). For example, [0,1,2,4,5,6,7] might be rotated at pivot index 3 and become [4,5,6,7,0,1,2].

Given the array nums after the possible rotation and an integer target, return the index of target if it is in nums, or -1 if it is not in nums.

You must write an algorithm with O(log n) runtime complexity.

Example 1:

Input: nums = [4,5,6,7,0,1,2], target = 0
Output: 4

Example 2:

Input: nums = [4,5,6,7,0,1,2], target = 3
Output: -1

function search(nums, target) {
    // Initalize pointers

    // left: starts at the beginning of the array 
    let left = 0;
    // right: starts at the end of the array 
    let right = nums.length - 1;

    while (left <= right) {
        const mid = Math.floor((left + right) / 2);

        if (nums[mid] === target) {
            return mid; // Target found, return the index
        }

        if (nums[left] <= nums[mid]) {
            // If the left part is sorted
            if (nums[left] <= target && target < nums[mid]) {
                // If the target is within the range of the sorted left part
                right = mid - 1; // Adjust the right pointer
            } else {
                left = mid + 1; // Adjust the left pointer
            }
        } else {
            // If the right part is sorted
            if (nums[mid] < target && target <= nums[right]) {
                // If the target is within the range of the sorted right part
                left = mid + 1; // Adjust the left pointer (narrow to right half)
            } else {
                right = mid - 1; // Adjust the right pointer (narrow to left half)
            }
        }
    }

    return -1; // Target not found, return -1
}

// Time Complexity: O(log n)
// Space Complexity: O(1)

A short summary by Fireship:

Binary Search Algorithm in 100 Seconds - YouTube

Binary Search is an algorithm that can find the index of an element in a sorted array data structure. You've likely used Binary Search it in everyday life wi...

youtube.com

References:

Two Sum Problem

Arpan Patel — Sun, 20 Aug 2023 19:37:29 +0000

Problem Description

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

You can return the answer in any order.

Difficulty Level: Easy

LeetCode Problem #1: Link

Approach 1: Brute Force Algorithm
Time Complexity: O(n^2)
Solution:

var twoSum = function(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];
            }
        }
    }
    return [];
};
}

Approach 2: Hashing & Two-pointer Technique
Time Complexity: O(n)
Solution:

var twoSum = function(nums, target) {
    const indexMap = new Map();

    for (let i = 0; i < nums.length; i++) {
        const complement = target - nums[i];

        if (indexMap.has(complement)) {
            return [indexMap.get(complement), i];
        }

        indexMap.set(nums[i], i);
    }

    return []; 
};

Algorithm Explanation:

Initialize an empty Map called indexMap. This map will store each number encountered in the array as a key and its index as the corresponding value.

Iterate through the input array nums using a for loop. For each element at index i, do the following:

Calculate the complement by subtracting the current element (nums[i]) from the target. The complement is the value that, when added to nums[i], results in the target sum.

Check if the map indexMap contains the calculated complement as a key. This is done using the .has(complement) method of the Map. If the complement exists in the map, it means that a pair of numbers has been found whose sum equals the target.

In this case, return an array containing the indices of the two numbers. The first index is retrieved from the map using indexMap.get(complement) (since the map stores indices as values), and the second index is simply i.
If the complement is not found in the map, it means that a matching pair has not been encountered yet. In this case, add the current number (nums[i]) to the map with its index as the value. This prepares the map for future lookups as the algorithm progresses through the array.

If the loop completes without finding a valid pair that sums up to the target, return an empty array to indicate that no solution was found.

Time Complexity:
The algorithm performs a single pass through the array, performing constant-time operations (hash map lookups and inserts) at each step. Therefore, the time complexity is O(n), where n is the length of the input array.

Example:

References:

LeetCODE
Grind 75
mdn web docs more about (.set, .get, .has)

DEV Community: Arpan Patel

TIL: Understanding Design Ideation

What is Ideation?

Ideation in Action

Preparing for Ideation

How to Ideate Effectively

Further Reading:

Inorder Traversal in a Nutshell 🥜

What is Inorder Traversal ?

Left-Root-Right pattern

Example 1:

Example 2:

Understanding the Sliding Window Technique

What is the Sliding Window Technique? 🤔

Visualize Sliding Window 👀:

When to use the technique (key terms):

Code walkthrough :

Longest Substring Without Repeating Characters

References:

Binary Search Decoded: Navigating Search Algorithms

What is Binary Search & how does it work ? 🤔

What is the Space & Time Complexity of Binary Search? ⏰

Exploring Binary Search: A Deep Dive with Code Examples 🧑🏻‍💻

Problem 1:

Problem 2:

A short summary by Fireship:

Binary Search Algorithm in 100 Seconds - YouTube

Two Sum Problem

Problem Description

Difficulty Level: Easy

LeetCode Problem #1: Link

References: