LeetCode Solutions by Rajput Hemant

Example 1: s = "egg", t = "add" -> true Example 2: s = "foo", t = "bar" -> false Example 3: s = "paper", t = "title" -> true

public int longestPalindromeSubseq(String s) {
    String str1 = s,
        str2 = new StringBuilder(s).reverse().toString();
    int m = str1.length(),
        n = str2.length();
    int[][] dp = new int[m + 1][n + 1];
    for (int i = 0; i < m + 1; i++)
    for (int j = 0; j < n + 1; j++) {
        if (i == 0 || j == 0)
        dp[i][j] = 0;
        else if (str1.charAt(i - 1) == str2.charAt(j - 1))
        dp[i][j] = 1 + dp[i - 1][j - 1];
        else
        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
    }
    return dp[m][n];
}

package main

// TreeNode defines a binary tree node
type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

func sortedArrayToBST(nums []int) *TreeNode {
	if len(nums) == 0 {
		return nil
	}

	return constructBST(nums, 0, len(nums)-1)
}

func constructBST(nums []int, left, right int) *TreeNode {
	if left > right {
		return nil
	}

	// Choose the middle element as the root to maintain balance
	mid := (left + right) / 2
	node := &TreeNode{Val: nums[mid]}

	// Recursively build left and right subtrees
	node.Left = constructBST(nums, left, mid-1)
	node.Right = constructBST(nums, mid+1, right)

	return node
}

Example 1:
Input: nums1 = [1,2,2,1], nums2 = [2,2]
Output: [2,2]

Example 2:
Input: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
Output: [4,9]

impl Solution {
    pub fn convert_temperature(celsius: f64) -> Vec<f64> {
        let kelvin = celsius + 273.15;
        let fahrenheit = celsius * 1.8 + 32.0;
        vec![kelvin, fahrenheit]
    }
}

package main

import "strconv"

// Definition for a binary tree node.
type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

func findDuplicateSubtrees(root *TreeNode) []*TreeNode {
	// to store the hash value of subtrees
	hashMap := make(map[string]int)
	// to store the result
	res := make([]*TreeNode, 0)
	// traverse the tree
	traverse(root, hashMap, &res)
	return res
}

// traverse the tree
func traverse(root *TreeNode, hashMap map[string]int, res *[]*TreeNode) string {
	// if the root is nil, return "#"
	if root == nil {
		return "#"
	}
	// traverse the left and right subtree
	left := traverse(root.Left, hashMap, res)
	right := traverse(root.Right, hashMap, res)
	// get the hash value of the subtree
	subTree := left + "," + right + "," + strconv.Itoa(root.Val)
	// if the hash value of the subtree is 1, it means that the subtree is duplicated
	if hashMap[subTree] == 1 {
		*res = append(*res, root)
	}
	// add the hash value of the subtree to the hashMap
	hashMap[subTree]++
	return subTree
}

use std::collections::{HashMap, VecDeque};

impl Solution {
    pub fn min_jumps(arr: Vec<i32>) -> i32 {
        let mut map = HashMap::new();

        // Pre-process: group indices by their values
        for (i, &v) in arr.iter().enumerate() {
            map.entry(v).or_insert(vec![]).push(i);
        }

        let mut q = VecDeque::new();
        q.push_back((0, 0_i32)); // (current_index, steps)

        let mut visited = vec![false; arr.len()];
        visited[0] = true;

        while let Some((i, mut step)) = q.pop_front() {
            if i == arr.len() - 1 {
                return step;
            }

            step += 1;

            // Jump to all indices with the same value
            if let Some(v) = map.remove(&arr[i]) {
                for j in v {
                    if !visited[j] {
                        visited[j] = true;
                        q.push_back((j, step));
                    }
                }
            }

            // Jump to next index
            if i + 1 < arr.len() && !visited[i + 1] {
                visited[i + 1] = true;
                q.push_back((i + 1, step));
            }

            // Jump to previous index
            if i >= 1 && !visited[i - 1] {
                visited[i - 1] = true;
                q.push_back((i - 1, step));
            }
        }

        -1
    }
}

import java.util.LinkedList;
import java.util.List;
import java.util.Stack;
import definitions.TreeNode;

public class BinaryTreeZigzagLevelOrderTraversal {
    public static List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> result = new LinkedList<>();
        if (root == null)
            return result;
        Stack<TreeNode> stk1 = new Stack<>(), stk2 = new Stack<>();
        stk1.push(root);
        while (!stk1.isEmpty() || !stk2.isEmpty()) {
            List<Integer> list1 = new LinkedList<>();
            while (!stk1.isEmpty()) {
                TreeNode currentNode = stk1.pop();
                list1.add(currentNode.val);
                if (currentNode.left != null)
                    stk2.push(currentNode.left);
                if (currentNode.right != null)
                    stk2.push(currentNode.right);
            }
            if (!list1.isEmpty())
                result.add(list1);
            List<Integer> list2 = new LinkedList<>();
            while (!stk2.isEmpty()) {
                TreeNode currentNode = stk2.pop();
                list2.add(currentNode.val);
                if (currentNode.right != null)
                    stk1.push(currentNode.right);
                if (currentNode.left != null)
                    stk1.push(currentNode.left);
            }
            if (!list2.isEmpty())
                result.add(list2);
        }
        return result;
    }
}