TreeMap with combo of Integer and StringBuilder in Java

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

public class Solution {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        TreeMap<Integer,StringBuilder> tm=new TreeMap<>();
       for(int m=0;m<100;m++){
StringBuilder sb = new StringBuilder("");
tm.put(m,sb);
}
        for(int a0 = 0; a0 < n; a0++){
            int x = in.nextInt();
            String s = in.next();
           
            if(a0<(n/2))
            {
                StringBuilder sold=tm.get(x);
                sold.append("- ");
                tm.put(x,sold);
            }
            else
            {
               
                StringBuilder sold=tm.get(x);
                sold.append(s+" ");
                tm.put(x,sold);
            }
           
        }
     
        for (Map.Entry<Integer, StringBuilder> entry : tm.entrySet()) {
         StringBuilder s=entry.getValue();
            //for(int i=0;i<s.length();i++)
               
            System.out.print(s);
        }
        in.close();
    }
}

Java 2D ArrayList-Linear Search

import java.util.*;
public class demo
{
    static int search(ArrayList<Integer>a,int num)
    {
        for(int i=0;i<a.size();i++)
        {
            if(a.get(i)==num)
                return i;
        }
        return -1;
    }
    public static void main(String args[])
    {
        int k=0;
        ArrayList<ArrayList<Integer>> a=new ArrayList<>();
       
        //I always forget to do this.;)
        for(int i=0;i<5;i++)
        {
            a.add(new ArrayList<>());
        }
        for(int i=0;i<5;i++)
        {
            for(int j=0;j<4;j++)
            {
                k++;
            a.get(i).add(k);   
            }
        }
        int s=search(a.get(1),8);
        System.out.println(a);
        System.out.println(s);
       
    }
}

Check for balanced parentheses in an expression using Stack class of Java

import java.util.*;
class Solution{
 
   public static void main(String []argh)
   {
      Scanner sc = new Scanner(System.in);
      Stack<Character> stack = new Stack<>();
      while (sc.hasNext()) {
         String input=sc.next();
          for(int i=0;i<input.length();i++)
          {
              char c=input.charAt(i);
           
              if(c=='(' || c=='{' || c=='[')
                 stack.push(c);
             
             
              else if(!(stack.isEmpty())){
                    if((c==')' && stack.peek()=='(' )|| (c=='}' && stack.peek()=='{') || c==']' && stack.peek()=='[')
                        stack.pop();
                 
              }
              else stack.push(c);
             
          }
         
          if(stack.empty())
              System.out.println("true");
          else
              System.out.println("false");
          stack.clear();// IMPORTANT :)
      }
     
   
   }
}

Two Dimensional Dynamic Array in Java

/*Coded By-Shivam Tripathi*/
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        List<ArrayList<Integer>> ar=new ArrayList<ArrayList<Integer>>();
        int n=sc.nextInt();
        for(int i=0;i<n;i++)
        {
            ar.add(new ArrayList<Integer>());
        }
        for(int i=0;i<n;i++)
        {
            int d=sc.nextInt();
            for(int j=0;j<d;j++)
            {
                int num=sc.nextInt();
                ar.get(i).add(num);
            }
        }
         int q = sc.nextInt();
        for(int i=0; i<q; i++) {
            int x = sc.nextInt();
            int y = sc.nextInt();
           
            try {
                System.out.println(ar.get(x-1).get(y-1));
            } catch(Exception e) {
                System.out.println("ERROR!");
            }
        }
       
       
    }
}

Finding Square Root of a number without using in-built function

Using Binary Search

float sqrt(n) {
    low = 0.0;
    high = (float)n+1;
    while ((high-low) > 0.00001) {
        mid = (low+high) / 2;
        if (mid*mid < n) {
            low = mid;
        }
        else {
            high = mid;
        }
    }
    return low;
}

GCD and LCM of n numbers stored in an array.

#include<stdio.h>
#include<stdlib.h>
int gcd(int a,int b)
{
if(a==0)
return b;
else
return gcd(b%a,a);
}
int lcm(int a,int b)
{
return a*(b/gcd(a,b));
}
int main()
{
int i,n;
/*To calculate GCD of n elementst we have to initailize starting variable with 0 (no with 1 )*/
int resgcd=0;
/*To calculate GCD of n elementst we have to initailize starting variable with 1 (no with 0 )*/
int reslcm=1;
printf("Enter the size of array:");
scanf("%d",&n);
int *ar=(int *)malloc(n*sizeof(int));
printf("\nEnter the elements of array:\n");
for(i=0;i<n;i++)
scanf("%d",&ar[i]);
for(i=0;i<n;i++)
resgcd=gcd(resgcd,ar[i]);
for(i=0;i<n;i++)
reslcm=lcm(reslcm,ar[i]);
printf("GCD : %d",resgcd);
printf("\nLCM : %d",reslcm);
return 0;
}

Implementing Graph by Adjacency List using Java

import java.util.LinkedlIst;
class Graph
{
    int v;
    LinkedList<Integer> a[];
    Graph(int v)
    {
     
        this.v=v;
        a=new LinkedList[5];
        for(int i=0;i<v;i++)
        {
            a[i]=new LinkedList<>();
        }
       
    }
    void addEdge(int source,int destination)
    {
        a[source].add(destination);
        a[destination].add(source);
    }
    void printGraph(Graph graph)
    {     
        for(int i = 0; i < v; i++)
        {
            System.out.println("Adjacency list of vertex "+ i);
            System.out.print("head");
            for(Integer j: graph.a[i]){
                System.out.print(" -> "+j);
            }
            System.out.println("\n");
        }
    }
   
}
class demo{
    public static void main(String args[])
    {
        // create the graph given in above figure
        int V = 5;
        Graph graph = new Graph(V);
        graph.addEdge(0,1);
        graph.addEdge(0,4);
        graph.addEdge(1,2);
        graph.addEdge(1,3);
        graph.addEdge(1,4);
        graph.addEdge(2,3);
        graph.addEdge(3,4);
     
        // print the adjacency list representation of
        // the above graph
        graph.printGraph(graph);
    }
}