DEV Community: Tanuja V

Are you a Trusted Member on Dev ?

Tanuja V — Sun, 01 Feb 2026 19:47:53 +0000

Merge Strings Alternately

Tanuja V — Thu, 29 Jan 2026 13:54:42 +0000

Intuition
We want to weave two strings together by picking characters alternately—first from word1, then from word2, and so on.
If one string runs out of characters before the other, we simply append the remaining characters of the longer string to the result.

Think of it like a zipper:

Take one character from word1
Take one from word2
Repeat until both strings are exhausted

Algorithm

Initialize two pointers i and j for word1 and word2.
Loop while at least one pointer is still within its string:
- If i is within bounds, append word1.charAt(i) and increment i.
- If j is within bounds, append word2.charAt(j) and increment j.
Return the merged string.

This ensures:
Characters are added alternately.
Any leftover characters from the longer string are appended at the end.

Complexities

Time Complexity:

                        O(n+m)

where n is the length of word1 and m is the length of word2.
Each character from both strings is processed exactly once.

Space Complexity:

                        O(n+m)

for storing the merged result.

class Solution {
    public String mergeAlternately(String word1, String word2) {

        int l1 = word1.length();

        int l2 = word2.length();

        int i = 0, j = 0;

        String res = "";

        while(i<l1 || j<l2){
            if(i<l1)
            res = res + word1.charAt(i++);

            if(j<l2)
            res = res + word2.charAt(j++);
        }

        return res;
    }
}

Thanks for reading :)
Feel free to comment and like the post if you found it helpful
Follow for more 🤝 && Happy Coding 🚀

What did you learn this week?

Tanuja V — Wed, 28 Jan 2026 10:15:11 +0000

ME:

Back to Leetcode
Back to learning (Java + SpringBoot)
Learning Telugu and Spanish
Figuring out life :)

Maximum Level Sum of a Binary Tree

Tanuja V — Thu, 08 May 2025 17:54:58 +0000

Given the root of a binary tree, the level of its root is 1, the level of its children is 2, and so on.

Approach 1: BFS

Add the elements to the queue
At any given level, calculate the sum of that level and mark the current level

Algorithm:

Add the node values to the queue starting with the root.
At a level, calculate the level sum of every level and keep a variable to track the maximum level.
Repeat it until the queue is empty.
Return the maximum level.

Code:

class Solution {
    public int maxLevelSum(TreeNode root) {

        int maxLevel = 1;

        int maxSum = Integer.MIN_VALUE;

        int level = 1;

        Queue<TreeNode> queue = new LinkedList<>();

        queue.add(root);

        while(!queue.isEmpty()){
            int size = queue.size();
            int sum = 0;
            for(int i=0; i<size; i++){
                TreeNode node = queue.remove();

                sum = sum + node.val;

                if(node.left!=null)
                queue.add(node.left);

                if(node.right!=null)
                queue.add(node.right);

            }

            if(sum>maxSum){
                maxSum = sum;
                maxLevel = level;
            }

            level++;
        }

        return maxLevel;
    }
}

Time Complexity: O(n)
Where n is the number of nodes in the binary tree.

Space Complexity: O(w)
Where w is the maximum width of the binary tree — the maximum number of nodes at any level.

Approach 2 : DFS

We make use of the arraylist to store the sum of the level at each node which is represented using the index.
Then we access it by running the loop.

Algorithm:

We are storing the sum of each level in the arraylist.
If the list.size()==level, we add the node value. Else, we get the list value which is the of that level and add the current node value.
We do it for all the left and right subtrees.
Now, traverse through the list and get the maximum level sum.

Code:

class Solution {
    List<Integer> list;
    public int maxLevelSum(TreeNode root) {
        list = new ArrayList<>();
        getLevelSum(root, 0);

        int maxLevel = 0;

        int maxSum = Integer.MIN_VALUE;

        for(int i=0; i<list.size(); i++){
            if(list.get(i)>maxSum){
                maxLevel = i+1;
                maxSum = list.get(i);
            }
        }

        return maxLevel;
    }

    void getLevelSum(TreeNode root, int level){
        if(root==null)
        return;

        if(list.size()==level){
            list.add(root.val);
        }

        else{
            list.set(level, list.get(level)+root.val);
        }

        getLevelSum(root.left, level+1);
        getLevelSum(root.right, level+1);

    }
}

Time Complexity: O(n)
Where n is the number of nodes in the tree.

Space Complexity: O(h) for recursion + O(d) for list storage
Where h is the height of the tree and d is the depth (number of levels) of the tree.

Thanks for reading :)
Feel free to comment and like the post if you found it helpful
Follow for more
If you enjoy my content, support me by following me on my other socials:
https://linktr.ee/tanujav7

Keys and Rooms

Tanuja V — Wed, 07 May 2025 12:52:48 +0000

Given:
There are rooms marked from 0 to n-1. Room 0 is the only room which is unlocked. Goal is to see whether all the rooms are visited or not and accordingly return the boolean value.

This is a typical BFS graph problem.

Approach :

When it's a BFS, we make use of Queue data structure.
'visited array' to keep track of which nodes are visited
Traverse to check whether all the nodes are visited or not. If not, return false. Else, return true.

Algorithm :

Start with room 0 which is add 0 to the queue and mark visited[0] = 1
Now until the queue is empty
- take the node from the queue
- Get the adjacent nodes of the "node" and add it to the queue and mark it as visited.
Traverse the visited array to check whether all the nodes are visited or not.

Code:

class Solution {
    public boolean canVisitAllRooms(List<List<Integer>> rooms) {

        int n = rooms.size();

        int visited[] = new int[n];

        Queue<Integer> queue = new LinkedList<>();

        visited[0] = 1;

        queue.add(0);

        while(!queue.isEmpty()){
            int node = queue.remove();

            for(int adj : rooms.get(node)){
                if(visited[adj]==0){
                    visited[adj] = 1;
                    queue.add(adj);
                }
            }
        }

        for(int visit : visited){
            if(visit==0)
            return false;
        }

        return true;
    }
}

Time Complexity: O(N + E)
N = number of rooms
E = total number of keys across all rooms

Space Complexity: O(N)

Thanks for reading :)
Feel free to comment and like the post if you found it helpful
Follow for more

Min Stack | LeetCode | Java

Tanuja V — Sun, 21 Jul 2024 03:35:29 +0000

class MinStack {

    Stack<Integer> stack;
    Stack<Integer> minStack;

    public MinStack() {
        stack = new Stack<>();
        minStack = new Stack<>();
    }

    public void push(int val) {
        int min = val;

        if(!minStack.isEmpty() && minStack.peek()<min)
            min = minStack.peek();

        stack.push(val);
        minStack.push(min);

    }

    public void pop() {
        stack.pop();
        minStack.pop();
    }

    public int top() {
        return stack.peek();
    }

    public int getMin() {
        return minStack.peek();
    }
}

Thanks for reading :)
Feel free to comment and like the post if you found it helpful
Follow for more 🤝 && Happy Coding 🚀

If you enjoy my content, support me by following me on my other socials:
https://linktr.ee/tanujav7

Number of Provinces | LeetCode

Tanuja V — Thu, 04 Jul 2024 04:13:23 +0000

class Solution {
    public int findCircleNum(int[][] isConnected) {

        int n = isConnected.length;

        int visited[] = new int[n];

        int count = 0;

        for(int i=0; i<n; i++){
            if(visited[i]==0){
              dfs(isConnected, i, visited, n);
              count++;
            }
        }

        return count;
    }

    void dfs(int grid[][], int u, int visited[], int n){

        visited[u] = 1;

        for(int i=0; i<n; i++){
            if(grid[u][i]==1 && visited[i]==0)
                dfs(grid, i, visited, n);
        }
    }
}

Thanks for reading :)
Feel free to comment and like the post if you found it helpful
Follow for more 🤝 && Happy Coding 🚀

If you enjoy my content, support me by following me on my other socials:
https://linktr.ee/tanujav7

Number of Closed Islands | LeetCode

Tanuja V — Mon, 24 Jun 2024 14:43:00 +0000

class Solution {
    public int closedIsland(int[][] grid) {

        int row = grid.length;

        int col = grid[0].length;

        int countIsland = 0;


        for(int i=0; i<row; i++){
            for(int j=0; j<col; j++){
                if(grid[i][j]==0 && dfs(grid, i, j)){
                    countIsland++;
                }
            }
        }

        return countIsland;
    }


    boolean dfs(int grid[][], int i, int j){
        if(i<0 || j<0 || i>=grid.length || j>=grid[0].length)
            return false;

        if(grid[i][j]==1 || grid[i][j]==2)
            return true;

        grid[i][j] = 2;

        boolean up = dfs(grid, i+1, j);
        boolean down = dfs(grid, i-1, j);
        boolean left = dfs(grid, i, j+1);
        boolean right = dfs(grid, i, j-1);

        return up && down && left && right;
    }
}

Thanks for reading :)
Feel free to comment and like the post if you found it helpful
Follow for more 🤝 && Happy Coding 🚀

If you enjoy my content, support me by following me on my other socials:
https://linktr.ee/tanujav7

Max Area of Island | LeetCode

Tanuja V — Sat, 22 Jun 2024 07:06:56 +0000

class Solution {
    public int maxAreaOfIsland(int[][] grid) {

        int m = grid.length;
        int n = grid[0].length;

        int maxArea = 0;

        for(int i=0; i<m; i++){
            for(int j=0; j<n; j++){
                if(grid[i][j]==1){
                    maxArea = Math.max(maxArea, dfs(grid, i, j));
                }
            }
        }

        return maxArea;
    }


    int dfs(int grid[][], int i, int j){
        if(i<0 || j<0 || i>=grid.length || j>=grid[0].length || grid[i][j]==0 || grid[i][j]==2)
            return 0;

        grid[i][j] = 2;

        return 1 + dfs(grid, i+1, j) + dfs(grid, i-1, j) + dfs(grid, i, j+1) + dfs(grid, i, j-1);
    }
}

Thanks for reading :)
Feel free to comment and like the post if you found it helpful
Follow for more 🤝 && Happy Coding 🚀

If you enjoy my content, support me by following me on my other socials:
https://linktr.ee/tanujav7

Number of Islands | LeetCode

Tanuja V — Wed, 19 Jun 2024 06:15:31 +0000

class Solution {
    public int numIslands(char[][] grid) {

        int m = grid.length;
        int n = grid[0].length;

        int countIsland = 0;

        for(int i=0; i<m; i++){
            for(int j=0; j<n; j++){
                if(grid[i][j]=='1'){
                    dfs(grid, i, j);
                    countIsland++;
                }
            }
        }

        return countIsland;
    }

    void dfs(char grid[][], int i, int j){
        if(i<0 || j<0 || i>=grid.length || j>=grid[0].length || grid[i][j]=='0' || grid[i][j] == '2')
            return;

        grid[i][j] = '2';

        dfs(grid, i+1, j);
        dfs(grid, i-1, j);
        dfs(grid, i, j+1);
        dfs(grid, i, j-1);
    }
}

Thanks for reading :)
Feel free to comment and like the post if you found it helpful
Follow for more 🤝 && Happy Coding 🚀

If you enjoy my content, support me by following me on my other socials:
https://linktr.ee/tanujav7

Posted my first video on YouTube | Need your advice

Tanuja V — Wed, 12 Jun 2024 15:10:31 +0000

Hello guys

Well, the "first" of anything would always be the best, right?

And today marks the beginning of the YouTube journey for me. I've always wanted to be a YouTuber. So, today is an exceptional day for me and I want to share this with you, my friend (reader).

I don't know much about editing but will surely learn it in the process.
Beginning's always the hardest part and it's definitely not as easy as it seems. It's a move for me to come out of my comfort zone.

So, I hope this journey will unlock new opportunities for me and be enjoyable as well

Here's the link to my first video on YouTube: https://youtube.com/shorts/NH_PjmwcnIQ?si=1B0EM8SkvE2M4KRX

Please watch it and if you like it do consider subscribing, sharing and liking the video. (Well, I am kinda nervous though)

Would love to hear your feedback. Please feel free to comment on your thought/advice.

Remove All Adjacent Duplicates In String | LeetCode | Java

Tanuja V — Tue, 11 Jun 2024 05:40:16 +0000

class Solution {
    public String removeDuplicates(String s) {

        Stack<Character> stack = new Stack<>();

        char arr[] = s.toCharArray();

        for(char ch : arr){
           if(!stack.isEmpty()){
                if(stack.peek()==ch)
                    stack.pop();
               else
                stack.push(ch);
           }

            else
                stack.push(ch);
        }

        String res = "";

        StringBuilder sb = new StringBuilder();

        while(!stack.isEmpty()){
            sb.append(stack.pop());
        }

        return sb.reverse().toString();
    }
}

Thanks for reading :)
Feel free to comment and like the post if you found it helpful
Follow for more 🤝 && Happy Coding 🚀

If you enjoy my content, support me by following me on my other socials:
https://linktr.ee/tanujav7