CareerCup

take three pointer. Each to the first element of the list. then find the min of them. compute max(xyx)-Min(xyz). If result less than till now result change it. increment the pointer of the array which contains the minimum of them

take the list which has minimum element start from first element element1 on list1 and have an index for both of other list now move one by one to find the nearest value of element1 in list2 and list3 find max(i,j,k)-min(i,j,k) store it in result now take element2 from list1 and move index on list2 and list3 to find the nearest of element2 now again find max(i,j,k)-min(i,j,k) if it is less than result then replace result.repeat to end of element in list1 return the result value .if u need the element value then maintain i,j,k when result is replaced.the complexity of worst case is O(sizeoflist1+sizeoflist2+sizeof3) space c omplexity is constant

public static int[] MinimumDifference(int[] X, int[] Y, int[] Z) {
		int[] resultAndIndex={Integer.MAX_VALUE,-1,-1,-1};

		int xIndex=0;
		int yIndex=0;
		int zIndex=0;
		
		while (resultAndIndex[0] > 0 && xIndex < X.length && yIndex < Y.length && zIndex < Z.length){
			
			//find the maximum number and the minimum number
			int max = X[xIndex];
			int min = X[xIndex];
			boolean xIsMin = true;
			boolean yIsMin = false;
			if (Y[yIndex] > max){max=Y[yIndex];}
			else if (Y[yIndex] < min) {min=Y[yIndex]; xIsMin = false; yIsMin = true;}
			if (Z[zIndex] > max) {max = Z[zIndex];}
			else if (Z[zIndex] < min) {min = Z[zIndex]; xIsMin = false; yIsMin = false;}
			
			//store the minimum result up to now
			if (resultAndIndex[0] > max - min){
				resultAndIndex[0] = max - min; //the minimum difference
				resultAndIndex[1] = xIndex; //1 is for xIndex
				resultAndIndex[2] = yIndex; //2 is for yIndex
				resultAndIndex[3] = zIndex; //3 is for zIndex
			}
			
			if (xIsMin) xIndex++;
			else if (yIsMin) yIndex++;
			else zIndex++;
		}
		return resultAndIndex;
	}

indices i, j, k <-- 0 pointing to lists 1, 2, 3 respectively
minVal <-- +infinity
iMax, jMax, kMax <--0;

at each step 
       find which list[index] is minimum among i, j, k then increase that index by 1
       if minVal is greater than  max(three lists at their index) - min(three lists at their index)) 
               update minVal and iMax, jMax, kMax
while indices are not out of list size
return minVal

takes O(n+m+l)

take smallest numbers of all 3 arrays, compute min xyz , max xyz and compare and store, get the next smallest number of the array containing smallest number min xyz , do the above process recursively until the result is more than the previous one, then stop and previous values of xyz are the ans.

You will have to find 3 closest numbers from those sorted lists

This is how this can be done :

1. Take a smallest list – say list-1 ( remaining lists are : list-2, list-3)
2. For each number in list-1 find the closed number in list-2 and list-3 )
3. Step#2 can be done using modified binary search ( if you get exact match then its good or else you get a closest value when searching stops) since list is sorted . – ( time complexity log(n) for each element in list-1 ).
4. With each iteration you would also have to store that closest found values from list-1 and list-2 ( make use of hashmap or some other data structure ).
5. Once this is done , iterate through the hashmap and calculate max(x,y,z) – min(x,y,z) -- whichever results in minimum is the correct answer.

Note : you can avoid using extra storage by making use of 6 variables – 3 for holding current combination (x1,y1,z1) and 3 for holding previous combination(x0,y0,z0) which is also minimum – replace the previous combination with current combination when you find that :

[max(x1,y1,z1)-min(x1,y1,z1) ] < [max(x0,y0,z0)-min(x0,y0,z0) ]

e.g. :

List -1 : 1, 3, 5, 7
List -2 : 2, 4, 6, 8
List -3 : 1, 2, 11, 20

After step#3 you would have : ( format : list-1(list-2,list3) )

1(2,1) , 3(2,2) , 5(4,2), 7(6,11).

In this example we have two answers :

1(2,1) and 3(2,2)

time complexity O(nlogn)

How about below approach

A1 -> Array 1
A2 -> Array2
A3 -> Array3

i think below is what needs to be done

max( min(A1), min(A2), min(A3)) - min( max(A1),max(A2),max(A3))

Any thoughts?

What are the numbers? Integers? And we can have negative numbers or only positive?

What about this?Maybe I am too tired and I write stupid things, but check it out. It prints the arraylist with the max - min elements and then we just get the minimum one...

package maximum;
import java.util.ArrayList;

public class Maximum {

    
    public static void main(String[] args) {
       
        ArrayList<Integer> results = new ArrayList<Integer>();
        
        int[] array1 = {0,1,2,3,4};
        int[] array2 = {3,7,10,100,1000};
        int[] array3 = {0,34,40,300,450};
        
        int max;
        int min;
 
        
        for(int i = 0 ; i< array1.length;i++)
        {
            max = array1[i];
            min = array1[i];
            
            
            for(int j = 0 ; j < array1.length ; j++)
            {
                if(array2[j] > array1[i])
                {
                    if(array2[j]>array3[j])
                    {
                        max = array2[j];
                    }
                    else
                    {
                        max = array3[j];
                    }    
                }
                if(array2[j] < array1[i])
                {
                    if(array2[j]<array3[j])
                    {
                        min = array2[j];
                    }
                    else
                    {
                        min = array3[j];
                    }    
                }
                
            }
            results.add(max - min);
            
        }
        System.out.println(results);
    }
}

step 1 . We will maintain pointer to starting point of three array say x,y,z
step 2 . now we need to find minimum and maximum of A[x] , B[y] , C[z]
step 3 . & we know that Max(abs(a[i]-b[j]),abs(a[i]-c[k]),abs(b[j]-c[k])) = difference of (Max - Min) = P ( say.. )
step 4 . As we Need to minimize above value so we need to reduce this difference so we will increment index having minimum value and again perform step 2 .

use Merge sort all the array also keep track of every number such that we can know the number is from which array, Find xyz in such a way that xyz are closest. that's the result.

#include<stdafx.h>
#include<iostream>

using namespace std;
int main()
{
int a[6] = {1,2,3,4,5,6};
int b[6] = {7,8,9,10,11,12};
int c[6] ={13,14,15,16,17,18};
int x,y,z;

for(int i=5; i>=0;i--)
{
if(a[i] <=b[0] || i ==0)
{
x= a[i];
y = b[0];
break;
}
}
for(int i =5; i>=0;i--)
{
if(y>=c[i] || i ==0)
{
z=c[i];
break;
}
}

cout << x << " "<<y<<" "<<z;
}


Find the max(x,y,z) - min(x,y,z), result will be minimum.

Task at hand : Minimising the function - Max ( x , y , z ) - Min ( x , y , z )
Now to minimise this operation, we need to minimise the first function and maximum the second function, so that we get a less number, or maybe even a negative number.
We simplified our task of minimising the function into smaller tasks.

1) Minimising Max ( x , y , z )
So we need to get the 3 smallest numbers from the three arrays. For this, we need to see atmost 3 elements. That is, the first 3 elements of all the 3 arrays. We could do this in many ways.

2) Maximising Min ( x , y , z )
Similarly, here we need to find the 3 largest elements in the array. Here also, we will need to see only 9 elements, which are the 3 ending elements in all the 3 arrays.

Now, the task of simplifying is achieved :)

public static int find(int[] X, int[] Y, int[] Z)
	{
		int i = 0;
		int minDiff = diff(X[0], Y[0], Z[0]);
		while(++i < X.length){
			minDiff = Math.min(minDiff, diff(X[i], Y[i], Z[i]));
		}
		return minDiff;
	}
	
	public static int diff(int x, int y, int z){
		return Math.max(x, Math.max(y, z)) - Math.min(x, Math.min(y, z));
	}