125. Valid Palindrome

class Solution {
    public boolean isPalindrome(String s) {

        StringBuilder sIgnoreBuffer = new StringBuilder();
        for (int i = 0; i < s.length(); i++){
            if((s.charAt(i)>='0' && s.charAt(i)<='9')||(s.charAt(i) >= 'a' && s.charAt(i) <= 'z') || (s.charAt(i) >= 'A' && s.charAt(i) <= 'Z'))
                sIgnoreBuffer.append(Character.toLowerCase(s.charAt(i)));
        }
    
        String sIgnore = sIgnoreBuffer.toString();
        int start = 0;
        int end = sIgnore.length() - 1;   
                                
        while(start < end){
            if(sIgnore.charAt(start) == sIgnore.charAt(end)){
                start++;
                end --;
            } else return false;
        }
       return true;
}}

48. Rotate Image

class Solution {
    public void rotate(int[][] matrix) {
 
        for(int i = 0; i < matrix.length; i++){
            for (int j = i; j < matrix.length; j++){
                swap(i,j,j,i,matrix);

            }
        }
        
        for(int i = 0; i < matrix.length; i++){
            for(int j = 0; j < matrix.length/2; j++){
            swap(i,j,i,matrix.length-1-j,matrix);

                }
        }
        
        
    }
    public void swap(int i, int j, int x, int y, int [][] matrix){
        int temp = matrix[i][j];
        matrix[i][j] = matrix[x][y];
        matrix[x][y] = temp;
    }
}

}

36. Valid Sudoku

   class Solution {
public boolean isValidSudoku(char[][] board) {
for (int i = 0; i < board.length; i++) { HashSet dataInRow = new HashSet();
for (int j = 0; j < board.length; j++) {
if (board[i][j] != '.')
if (dataInRow.contains(board[i][j]))
return false;
else
dataInRow.add(board[i][j]);
}
} for (int j = 0; j < board.length; j++) {
        HashSet<Character> dataInRow = new HashSet<Character>();
        for (int i = 0; i < board.length; i++) {
            if (board[i][j] != '.')
                if (dataInRow.contains(board[i][j]))
                    return false;
                else
                    dataInRow.add(board[i][j]);
        }
    }
    for (int i = 0; i < board.length; i = i + 3) {
        for (int j = 0; j < board.length; j = j + 3) {
            if (!checkValid(i, j, board))
                return false;
        }
    }

    return true;
}

private boolean checkValid(int a, int b, char[][] board) {
    HashSet<Character> dataInSquare = new HashSet<Character>();
    int aEnd = a + 3;
    int bEnd = b + 3;
    for (int i = a; i < aEnd; i++) {
        for (int j = b; j < bEnd; j++) {
            if (board[i][j] != '.')
                if (dataInSquare.contains(board[i][j]))
                    return false;
                else
                    dataInSquare.add(board[i][j]);
        }
    }
    return true;
}

}

Mark and Toys

import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;

public class Solution {

    // Complete the maximumToys function below.
    static int maximumToys(int[] prices, int k) {
        Arrays.sort(prices);
        int max = 0;
        int total = 0;
        for (int i = 0; i < prices.length; i++) {
            total += prices[i];
            if (total < k)
                max++;
            else
                return max;

        }
        return max;
    }

    private static final Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) throws IOException {
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));

        String[] nk = scanner.nextLine().split(" ");

        int n = Integer.parseInt(nk[0]);

        int k = Integer.parseInt(nk[1]);

        int[] prices = new int[n];

        String[] pricesItems = scanner.nextLine().split(" ");
        scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

        for (int i = 0; i < n; i++) {
            int pricesItem = Integer.parseInt(pricesItems[i]);
            prices[i] = pricesItem;
        }

        int result = maximumToys(prices, k);

        bufferedWriter.write(String.valueOf(result));
        bufferedWriter.newLine();

        bufferedWriter.close();

        scanner.close();
    }
}

Find the Running Median

import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;
import java.util.regex.*;

public class Solution {

    /*
     * Complete the runningMedian function below.
     */
    static double[] runningMedian(int[] a) {
        /*
         * Write your code here.
         */

        
        double[] out = new double[a.length];
        PriorityQueue<Integer> minHeap = new PriorityQueue<Integer>();
        PriorityQueue<Integer> maxHeap = new PriorityQueue<Integer>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return -Integer.compare(o1, o2);
            }
        });
        double median = 0;
        if(a.length == 1) {
            out[0] = a[0];
            return out;
        }
        for (int i = 0; i < a.length; i++) {
            if( i == 0) {
                out[0] = a[0];
            } else if (i == 1) {
                minHeap.add(Integer.max(a[0], a[1]));
                maxHeap.add(Integer.min(a[0], a[1]));
                out[i] = ((double) a[i - 1] + (double) a[i]) / 2;
                median = out[i];
            } else {
                       
                if(a[i] > median) {
                   minHeap.add(a[i]);
               } else if(a[i]<= median) {
                   maxHeap.add(a[i]);
               }
                
                if(Math.abs(minHeap.size() - maxHeap.size())>1) {
                    if(minHeap.size() > maxHeap.size())
                        maxHeap.add(minHeap.remove());
                    else minHeap.add(maxHeap.remove());
                }
                
                
                if(minHeap.size() == maxHeap.size())
                out[i] = ((double)minHeap.peek() + (double) maxHeap.peek())/2;
                else if (minHeap.size() > maxHeap.size())
                    out[i] = minHeap.peek().doubleValue();
                else if (maxHeap.size() > minHeap.size())
                    out[i] = maxHeap.peek().doubleValue();
                median = out[i];
                
            }
        }
        return out;
    }

    private static final Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) throws IOException {
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));

        int aCount = Integer.parseInt(scanner.nextLine().trim());

        int[] a = new int[aCount];

        for (int aItr = 0; aItr < aCount; aItr++) {
            int aItem = Integer.parseInt(scanner.nextLine().trim());
            a[aItr] = aItem;
        }

        double[] result = runningMedian(a);

        for (int resultItr = 0; resultItr < result.length; resultItr++) {
            bufferedWriter.write(String.valueOf(result[resultItr]));

            if (resultItr != result.length - 1) {
                bufferedWriter.write("\n");
            }
        }

        bufferedWriter.newLine();

        bufferedWriter.close();
    }
}

Pairs

import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;

public class Solution {

// Complete the pairs function below.
   static int pairs(int k, int[] arr) {
        HashSet<Integer> d = new HashSet<Integer>();
        for (int i = 0; i < arr.length; i++) {
            d.add(arr[i]);
        }
        int count = 0;
        for (int i : d) {
            if (d.contains(i + k)) {
                count++;
            }
        }
        return count;
    }

    private static final Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) throws IOException {
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));

        String[] nk = scanner.nextLine().split(" ");

        int n = Integer.parseInt(nk[0]);

        int k = Integer.parseInt(nk[1]);

        int[] arr = new int[n];

        String[] arrItems = scanner.nextLine().split(" ");
        scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

        for (int i = 0; i < n; i++) {
            int arrItem = Integer.parseInt(arrItems[i]);
            arr[i] = arrItem;
        }

        int result = pairs(k, arr);

        bufferedWriter.write(String.valueOf(result));
        bufferedWriter.newLine();

        bufferedWriter.close();

        scanner.close();
    }
}