cody - HTMLify profile

// 1171. Remove Zero Sum Consecutive Nodes from Linked List java solution

/**
* Definition for singly-linked list.
* public c

// 1255. Maximum Score Words Formed by Letters java solution
class Solution {
public int maxScoreWords(String[] words, char[

// 128. Longest Consecutive Sequence
// t.c.:O(n)
class Solution {
public int longestConsecutive(int[] nums) {
int n

/*
// Definition for a Node.
class Node {
int val;
Node next;
Node random;

public Node(int val) {

// 153. Find Minimum in Rotated Sorted Array java solution
class Solution {
public int findMin(int[] nums) {
int lo=

// 154. Find Minimum in Rotated Sorted Array II java solution
class Solution {
public int findMin(int[] nums) {
int

// 155. Min Stack java solution

import java.util.Stack;

class MinStack {
Stack<Long> st1 = new Stack<>();
long min;

// 227. Basic Calculator II

class Solution {
public int calculate(String s) {
Stack<Integer> operand = new Stack<>(

// 234. Palindrome Linked List

/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* List

// 239. Sliding Window Maximum java solution
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
Deq

// 240. Search a 2D Matrix II java solution
class Solution {
public boolean searchMatrix(int[][] matrix, int target) {

// 287. Find the Duplicate Number java solution

class Solution {
public int findDuplicate(int[] nums) {
int n= nums

// 33. Search in Rotated Sorted Array java solution
class Solution {
public int search(int[] nums, int target) {
int

// 349. Intersection of Two Arrays

class Solution {
public int[] intersection(int[] nums1, int[] nums2) {
Set<Integ

// 380. Insert Delete GetRandom O(1)
class RandomizedSet {
HashMap<Integer, Integer> hm;
List<Integer> list;
Random

// 381. Insert Delete GetRandom O(1) - Duplicates allowed
class RandomizedCollection {
HashMap<Integer,HashSet<Integer>> map

// 4. Median of Two Sorted Arrays java solution

class Solution {
public double findMedianSortedArrays(int[] nums1, int[] nu

// 438. Find All Anagrams in a String

class Solution {
public List<Integer> findAnagrams(String s, String p) {
int

// 442. Find All Duplicates in an Array java solution

class Solution {
public List<Integer> findDuplicates(int[] nums) {

// 525. Contiguous Array java solution

import java.util.HashMap;

class Solution {
public int findMaxLength(int[] arr) {

// 543. Diameter of Binary Tree java solution

/**
* Definition for a binary tree node.
* public class TreeNode {
* int v

// 560. Subarray Sum Equals K o(n) t.c. solution
class Solution {
public int[] psum(int[] nums){
int[] ps=new int[nu

// 710. Random Pick with Blacklist
class Solution {
HashMap<Integer,Integer> map;
Random r;
int valid;
public So

// 76. Minimum Window Substring
class Solution {
public String minWindow(String s, String t) {
int slen=s.length();

// 81. Search in Rotated Sorted Array II java solution
class Solution {
public boolean search(int[] nums, int target) {

// 84. Largest Rectangle in Histogram leetcode hard problem java code

class Solution {
public int largestRectangleArea(int[

// 85. Maximal Rectangle leetcode hard java solution

class Solution {
public int maximalRectangle(char[][] matrix) {

// 895. Maximum Frequency Stack

class FreqStack {
HashMap<Integer, Stack<Integer>> st;
HashMap<Integer, Integer> fmap;

// 930. Binary Subarrays With Sum

import java.util.HashMap;

class Solution {
public int numSubarraysWithSum(int[] nums, in

// Anagram Palindrome
//{ Driver Code Starts
import java.util.*;
import java.lang.*;
import java.io.*;

class GFG
{

// Count Pairs whose sum is equal to X

import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import

// D. Same Differences
// "static void main" must be defined in a public class.
import java.util.Scanner;
import java.util.HashM

// Equal 0, 1 and 2 solution without using extra function
class Solution
{
long getSubstringWithEqual012(String str)

// Equal 0, 1 and 2 solution using extra function
class Solution
{
long getSubstringWithEqual012(String str)
{

// Generate Binary Numbers java solution

import java.util.*;
import java.io.*;
import java.lang.*;

class GFG
{

// HashMap Operations
//{ Driver Code Starts
import java.util.Scanner;
import java.util.*;

class HashMap_Set3
{
public static

// Help Classmates gfg problem



import java.util.*;
import java.io.*;

class GFG

// Intersection Point in Y Shaped Linked Lists java solution

//{ Driver Code Starts
import java.util.*;


class Node
{

MIT License

Copyright (c) 2024 Devyansh Malhotra

Permission is hereby granted, free of charge, to any person obtaining a copy

class Node{
Node next;
Node prev;
int key;
int val;
public Node(){

}

// Left View of Binary Tree java solutions

class Tree
{
//Function to return list containing elements of left view of binar

// Longest Sub-Array with Sum K java solution
import java.io.*;
import java.util.*;


class Array {

// Driver code

// Longest Unbalanced subsequence java solution

import java.io.*;
import java.util.*;

public class Solution {
public stati

// Maximum Sum Problem

import java.io.*;
import java.util.*;
class GfG
{
public static void main(String args[])
{

// Merge Sort for Linked List java solution

//{ Driver Code Starts
//Initial Template for Java

import java.util.*;
import java

// Merge two sorted linked lists java solution
//{ Driver Code Starts
import java.util.*;

class Node
{
int data;
Node n

// Next Greater Element

import java.util.*;
import java.lang.*;
import java.io.*;

class GFG {

# DSA Solutions

Welcome to the DSA Solutions Repository! This repository is a read-only collection of solutions to some of the

import java.io.*;
import java.util.*;
import java.lang.*;

class GFG{
public static void main(String args[])throws IOExcepti

// Stock span problem

import java.util.*;
import java.io.*;
import java.lang.*;

class gfg
{

// Subarrays with equal 1s and 0s solution with t.c:O(n)

class Solution
{
//Function to count subarrays with 1s and 0s.

class Solution
{
//Function to count subarrays with 1s and 0s without extra functions usage
static int countSubarrWithEq

// Sum of bit differences java solution brute force followed by optimal


import java.io.BufferedReader;
import java.io.InputStr

// TreeMap Operations java solution
//{ Driver Code Starts
import java.util.Scanner;
import java.util.*;
class HashMap_Set4
{
p

// Vertical Traversal of Binary Tree java solution

//{ Driver Code Starts
//Initial Template for Java

//Contributed by Sudarsh

// Zero Sum Subarrays O(n) solution
class Solution{
//Function to count subarrays with sum equal to 0.
public static lon

#include<stdio.h>
int maxSubArray(int* nums, int numsSize){
int i,sum=0;
int maxNum=nums[0];
for(i=0;i< numsSize

// lca in binary tree gfg

class Solution
{
//Function to return the lowest common ancestor in a Binary Tree.
Node lca(Node

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

int* majorityElement(int* nums, int numsSize, int* returnSize);

#include<stdio.h>
int maxProduct(int* nums, int numsSize) {
int i, maxProduct = 1, minProduct = 1, maxResult = nums[i];

int maxChunksToSorted(int* arr, int arrSize) {
int i,max_chunks = 0;
int current_max = 0;

for (i = 0; i < a

#include<stdio.h>
int majorityElement(int* nums, int numsSize) {
int candidate = nums[0];
int i, count = 1;

#include <stdio.h>
#include <string.h>

void swap(char *a, char *b) {
char temp = *a;
*a = *b;
*b = temp;
}

#include <stdio.h>

void rotate(int* nums, int numsSize, int k) {
int i;
k = k % numsSize;
int* temp = malloc(nums

// sliding window minimum java solution

import java.util.*;

class SlidingWindowMinimum {

public ArrayList<Integer> getMinim

#include <stdio.h>
#include <stdlib.h>

int* sortedSquares(int* nums, int numsSize, int* returnSize) {
int i, j,temp;