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

class GFG
{
static double getMed(int a1[], int a2[], int n1, int n2)
{
int begin1 = 0, end1 = n1;

while(begin1 < end1)
{
int i1 = (begin1 + end1) / 2;
int i2 = ((n1 + n2 + 1) / 2 )- i1;

int min1 = (i1 == n1)?Integer.MAX_VALUE:a1[i1];
int max1 = (i1 == 0)?Integer.MIN_VALUE:a1[i1 - 1];

int min2 = (i2 == n2)?Integer.MAX_VALUE:a2[i2];
int max2 = (i2 == 0)?Integer.MIN_VALUE:a2[i2 - 1];

if(max1 <= min2 && max2 <= min1)
{
if((n1 + n2) % 2 == 0)
return ((double)Math.max(max1, max2) + Math.min(min1, min2)) / 2;
else
return (double) Math.max(max1, max2);
}
else if(max1 > min2)
end1 = i1 - 1;
else
begin1 = i1 + 1;
}

return -1;
}

public static void main(String args[])
{
int a1[] = {10, 20, 30, 40, 50}, n1 = 5, a2[] = {5, 15, 25, 35, 45}, n2 = 5;

System.out.println(getMed(a1, a2, n1, n2));     // OUTPUT : 27.5
}

}```
```// Java program to find a triplet
class FindTriplet {

// returns true if there is triplet with sum equal
// to 'sum' present in A[]. Also, prints the triplet
boolean find3Numbers(int A[], int arr_size, int sum)
{
int l, r;

/* Sort the elements */
quickSort(A, 0, arr_size - 1);

/* Now fix the first element one by one and find the
other two elements */
for (int i = 0; i < arr_size - 2; i++) {

// To find the other two elements, start two index variables
// from two corners of the array and move them toward each
// other
l = i + 1; // index of the first element in the remaining elements
r = arr_size - 1; // index of the last element
while (l < r) {
if (A[i] + A[l] + A[r] == sum) {
System.out.print("Triplet is " + A[i] + ", " + A[l] + ", " + A[r]);
return true;
}
else if (A[i] + A[l] + A[r] < sum)
l++;

else // A[i] + A[l] + A[r] > sum
r--;
}
}

// If we reach here, then no triplet was found
return false;
}

int partition(int A[], int si, int ei)
{
int x = A[ei];
int i = (si - 1);
int j;

for (j = si; j <= ei - 1; j++) {
if (A[j] <= x) {
i++;
int temp = A[i];
A[i] = A[j];
A[j] = temp;
}
}
int temp = A[i + 1];
A[i + 1] = A[ei];
A[ei] = temp;
return (i + 1);
}

/* Implementation of Quick Sort
A[] --> Array to be sorted
si --> Starting index
ei --> Ending index
*/
void quickSort(int A[], int si, int ei)
{
int pi;

/* Partitioning index */
if (si < ei) {
pi = partition(A, si, ei);
quickSort(A, si, pi - 1);
quickSort(A, pi + 1, ei);
}
}

// Driver program to test above functions
public static void main(String[] args)
{
FindTriplet triplet = new FindTriplet();
int A[] = { 1, 4, 45, 6, 10, 8 };
int sum = 22;
int arr_size = A.length;

triplet.find3Numbers(A, arr_size, sum);    // OUTPUT : Triplet is 4, 8, 10
}
}
```
```import java.util.*;
import java.io.*;

class Solution
{
static int isPresent(int arr[], int n, int sum)
{
int l = 0, h = n-1;

while(l <= h)
{
if(arr[l] + arr[h] == sum)
return 1;
else if(arr[l] + arr[h] > sum)
h--;
else l++;
}

return 0;
}

public static void main (String[] args)
{
int arr[] = new int[]{2, 3, 7, 8, 11};
int n = arr.length;
int sum = 14;

System.out.println(isPresent(arr, n, sum));    // OUTPUT : 1
}
}```
```import java.util.*;
import java.io.*;

class GFG
{
static int countOnes(int arr[], int n)
{
int low = 0, high = n - 1;

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

if(arr[mid] == 0)
low = mid + 1;
else
{
if(mid == 0 || arr[mid - 1] == 0)
return (n - mid);
else
high = mid -1;
}
}

return 0;
}

public static void main(String args[])
{
int arr[] = {0, 0, 1, 1, 1, 1}, n = 6;

System.out.println(countOnes(arr, n));   // OUTPUT : 4

}

}```
```import java.util.*;
import java.io.*;

class GFG
{
static int firstOcc(int arr[], int n, int x)
{
int low = 0, high = n - 1;

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

if(x > arr[mid])
low = mid + 1;

else if(x < arr[mid])
high = mid - 1;

else
{
if(mid == 0 || arr[mid - 1] != arr[mid])
return mid;

else
high = mid - 1;
}

}

return -1;
}

static int lastOcc(int arr[], int n, int x)
{
int low = 0, high = n - 1;

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

if(x > arr[mid])
low = mid + 1;

else if(x < arr[mid])
high = mid - 1;

else
{
if(mid == n - 1 || arr[mid + 1] != arr[mid])
return mid;

else
low = mid + 1;
}

}

return -1;
}

static int countOcc(int arr[], int n, int x)
{
int first = firstOcc(arr, n, x);

if(first == -1)
return 0;
else
return lastOcc(arr, n, x) - first + 1;
}

public static void main(String args[])
{
int arr[] = {10, 20, 20, 20, 40, 40}, n = 6;

int x = 20;

System.out.println(countOcc(arr, n, x));   // OUTPUT : 3

}

}```
```// Iterative Code

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

class GFG
{
static int lastOcc(int arr[], int n, int x)
{
int low = 0, high = n - 1;

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

if(x > arr[mid])
low = mid + 1;

else if(x < arr[mid])
high = mid - 1;

else
{
if(mid == n - 1 || arr[mid + 1] != arr[mid])
return mid;

else
low = mid + 1;
}

}

return -1;
}

public static void main(String args[])
{
int arr[] = {5, 10, 10, 10, 10, 20, 20}, n = 7;

int x = 10;

System.out.println(lastOcc(arr, n, x));   // OUTPUT : 4
}

}

// Recursive Code

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

class GFG
{
static int lastOcc(int arr[], int low, int high, int x, int n)
{
if(low > high)
return -1;

int mid = (low + high) / 2;

if(x > arr[mid])
return lastOcc(arr, mid + 1, high, x, n);

else if(x < arr[mid])
return lastOcc(arr, low, mid - 1, x, n);

else
{
if(mid == n - 1 || arr[mid + 1] != arr[mid])
return mid;

else
return lastOcc(arr, mid + 1, high, x, n);
}
}

public static void main(String args[])
{
int arr[] = {5, 10, 10, 10, 10, 20, 20}, n = 7;

int x = 10;

System.out.println(lastOcc(arr, 0, n - 1, x, n));   // OUTPUT : 4
}

}```
```// Efficient Code (Iterative)

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

class GFG
{
static int firstOcc(int arr[], int n, int x)
{
int low = 0, high = n - 1;

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

if(x > arr[mid])
low = mid + 1;

else if(x < arr[mid])
high = mid - 1;

else
{
if(mid == 0 || arr[mid - 1] != arr[mid])
return mid;

else
high = mid - 1;
}

}
return -1;
}

public static void main(String args[])
{
int arr[] = {5, 10, 10, 10, 20}, n = 5;

int x = 10;

System.out.println(firstOcc(arr, n, x));   // OUTPUT : 1
}
}

// Efficient Code (Recursive)

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

class GFG
{
static int firstOcc(int arr[], int low, int high, int x)
{
if(low > high)
return -1;

int mid = (low + high) / 2;

if(x > arr[mid])
return firstOcc(arr, mid + 1, high, x);

else if(x < arr[mid])
return firstOcc(arr, low, mid - 1, x);

else
{
if(mid == 0 || arr[mid - 1] != arr[mid])
return mid;

else
return firstOcc(arr, low, mid - 1, x);
}
}

public static void main(String args[])
{
int arr[] = {5, 10, 10, 15, 20, 20, 20}, n = 7;

int x = 20;

System.out.println(firstOcc(arr, 0, n - 1, x));   // OUTPUT : 4
}
}

// Naive Code

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

class GFG
{
static int firstOccurrence(int arr[], int n, int x)
{
for(int i = 0; i < n; i++)
if(arr[i] == x)
return i;

return -1;
}

public static void main(String args[])
{
int arr[] = {5, 10, 10, 15, 15}, n = 5;

int x = 15;

System.out.println(firstOccurrence(arr, n, x));   // OUTPUT : 3
}
}
```
```import java.util.*;
import java.io.*;

class GFG
{
static void printFreq(int arr[], int n)
{
int freq = 1, i = 1;

while(i < n)
{
while(i < n && arr[i] == arr[i - 1])
{
freq++;
i++;
}

System.out.println(arr[i - 1] + " " + freq);

i++;
freq = 1;
}
}

public static void main(String args[])
{
int arr[] = {10, 10, 20, 30, 30, 30}, n = 6;

printFreq(arr, n);
}
}```