# Balanced Split

```	public boolean balancedSplitExists(int[] arr) {
Arrays.sort(arr);
int i = 0;
int j = arr.length - 1;
int leftSum = arr[0];
int rightSum = arr[arr.length-1];
while(i <= j) {
if(leftSum < rightSum) {
i++;
leftSum+=arr[i];
}else if (leftSum > rightSum) {
j--;
rightSum+=arr[j];
} else break;
}
if(j-i == 1) return true;
else return false;
}
```

# Contiguous Subarrays

``````	public static int[] countSubarrays(int[] arr) {
int[] output = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
int j = i;
int less = 0;
while(j>=0 && arr[j]<=arr[i]) {
less++;
j--;
}
output[i] = less;

j=i;
int greater = 0;
while(j < arr.length && arr[j] <= arr[i]) {
greater++;
j++;
}
output[i]+=greater-1;//one from duplication
}
return output;
}``````

# Number of Visible Nodes

```	  class Node {
int data;
Node left;
Node right;
Node() {
this.data = 0;
this.left = null;
this.right = null;
}
Node(int data) {
this.data = data;
this.left = null;
this.right = null;
}
}

int visibleNodes(Node root) {
int count = 0;
while(!q.isEmpty()) {
Node n = q.poll();
count = level.poll();
if(n.right != null ) {
}
if(n.left != null ) {
}
}
return count;
}
```

# Magical Candy Bags

```	public int maxCandies(int[] arr, int K) {
PriorityQueue<Integer> maxHeap = new PriorityQueue<Integer>(Comparator.reverseOrder());
for (int i : arr)
int maxCandies = 0;
for (int i = 1; i <= K; i++) {
int rem = maxHeap.remove();
maxCandies += rem;
}

return maxCandies;
}
```

# Minimum Length Substrings

```	public static int minLengthSubstring(String s, String t) {
int min = Integer.MAX_VALUE;
boolean found = false;
for (int i = 0; i <= s.length(); i++) {
for (int j = i; j <= s.length(); j++) {
String takedString = s.substring(i, j);
boolean contained = true;
HashMap<Character, Integer> h = new HashMap<Character, Integer>();
for (Character c : t.toCharArray()) {
h.put(c, h.getOrDefault(c, 0) + 1);
}
for (Character c : takedString.toCharArray()) {
h.put(c, h.getOrDefault(c, 0) - 1);
}

for (Character c : h.keySet()) {
if (h.get(c) > 0)
contained = false;
}
if (contained) {
found = true;
min = Integer.min(min, takedString.length());
}
}
}
if (!found)
return -1;
return min;
}
```

# Revenue Milestones

```	public static int[] getMilestoneDays(int[] revenues, int[] milestones) {
int[] output = new int[milestones.length];
Arrays.fill(output, -1);
int sum = 0;
for (int i = 0; i < revenues.length; i++) {
revenues[i] += sum;
sum = revenues[i];
}
for (int i = 0; i < milestones.length; i++) {
int searchFor = milestones[i];
int low = 0;
int high = revenues.length - 1;
int mid = 0;

while (low <= high) {
mid = (high + low) / 2;

if (searchFor == revenues[mid]) {
output[i] = mid;
break;
} else if (searchFor < revenues[mid] && (mid - 1 < revenues.length && searchFor > revenues[mid - 1])) {
output[i] = mid - 1;
break;
} else if (searchFor < revenues[mid])
high = mid - 1;
else if (searchFor > revenues[mid] && (mid + 1 < revenues.length && searchFor < revenues[mid + 1])) {
output[i] = mid + 1;
break;
} else if (searchFor > revenues[mid])
low = mid + 1;

}
}
for (int i = 0; i < output.length; i++)
output[i]++;
return output;
}
```

# Queue Removals

```	public static class Pair {
int index;
int value;

public Pair(int index, int value) {
super();
this.index = index;
this.value = value;
}

public int getIndex() {
return index;
}

public void setIndex(int index) {
this.index = index;
}

public int getValue() {
return value;
}

public void setValue(int value) {
this.value = value;
}

}

public static int[] findPositions(int[] arr, int x) {
for (int i = 0; i < arr.length; i++)
ArrayList<Integer> removed = new ArrayList<Integer>();
for (int i = x; i >= 1; i--) {
int pops = x;
PriorityQueue<Pair> maxHeap = new PriorityQueue<Pair>(new Comparator<Pair>() {
@Override
public int compare(Pair o1, Pair o2) {
if (o1.getValue() == o2.getValue())
return Integer.compare(o1.getIndex(), o2.getIndex());
return -Integer.compare(o1.getValue(), o2.getValue());
}
});
while (pops != 0 && !q.isEmpty()) {
Pair c = q.poll();
pops--;
}
Pair ToRemove = maxHeap.remove();
int ToRemoveIndex = ToRemove.getIndex();
while (!temp.isEmpty()) {
Pair a = temp.poll();
if (a.getIndex() != ToRemoveIndex) {
q.add((a.getValue() > 0) ? new Pair(a.getIndex(), a.getValue() - 1) : a);
}
}
}
int[] out = new int[removed.size()];
for (int i = 0; i < out.length; i++)
out[i] = removed.get(i);
return out;
}
```

# Caesar Cipher

``` public static String caesarCipher(String input, int rotationFactor) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < input.length(); i++) {
if (input.charAt(i) >= 'a' && input.charAt(i) <= 'z') {
char newChar = (char) (input.charAt(i) + rotationFactor%26);
sb.append((newChar >= 'a' && newChar <= 'z') ? newChar : (char) (newChar - 'z' - 1 + 'a'));
} else if (input.charAt(i) >= 'A' && input.charAt(i) <= 'Z') {
char newChar = (char) (input.charAt(i) + rotationFactor%26);
sb.append((newChar >= 'A' && newChar <= 'Z') ? newChar : (char) (newChar - 'Z' - 1 + 'A'));
} else
sb.append(input.charAt(i));
}
return sb.toString();
}

```

# 1460. Make Two Arrays Equal by Reversing Sub-arrays

1460. Make Two Arrays Equal by Reversing Sub-arrays

``````class Solution {
public boolean canBeEqual(int[] target, int[] arr) {
HashMap<Integer,Integer> h = new HashMap<>();
for (int a: arr){
h.put(a ,h.getOrDefault(a,0)+1);
}
for(int b: target){
if(h.get(b)!= null)
h.put(b,h.getOrDefault(b,0)-1);
else return false;
}
for(int c: h.keySet()){
if(h.get(c) != 0) return false;
}
return true;
}
}``````

# 118. Pascal’s Triangle

118. Pascal’s Triangle

```class Solution {
public static List<List<Integer>> generate(int numRows) {
List<List<Integer>> all = new ArrayList();

List<Integer> first = new ArrayList<>();

if(numRows >=2) {
List<Integer> second = new ArrayList<>();
}
for(int i = 2;i < numRows; i++) {
List<Integer> row = new ArrayList<>();
int start =0;
for(int j = 1; start<all.get(i-1).size()-1; j++) {
int a = all.get(i-1).get(start)+all.get(i-1).get(start+1);
start++;