X-Received: by 2002:ac8:34c3:: with SMTP id x3mr4345787qtb.18.1553899250039; Fri, 29 Mar 2019 15:40:50 -0700 (PDT)
X-Received: by 2002:a25:b448:: with SMTP id c8mr42397112ybg.269.1553899249564; Fri, 29 Mar 2019 15:40:49 -0700 (PDT)
Path: csiph.com!xmission!news.snarked.org!border2.nntp.dca1.giganews.com!nntp.giganews.com!t9no2206181qtn.0!news-out.google.com!i54ni1512qte.0!nntp.google.com!t9no2206175qtn.0!postnews.google.com!glegroupsg2000goo.googlegroups.com!not-for-mail
Newsgroups: comp.lang.java.programmer
Date: Fri, 29 Mar 2019 15:40:49 -0700 (PDT)
In-Reply-To: <q7lbvc$152e$1@gioia.aioe.org>
Complaints-To: groups-abuse@google.com
Injection-Info: glegroupsg2000goo.googlegroups.com; posting-host=84.74.101.34; posting-account=UjEXBwoAAAAOk5fiB8WdHvZddFg9nJ9r
NNTP-Posting-Host: 84.74.101.34
References: <q7lbvc$152e$1@gioia.aioe.org>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <1738bf0a-0af9-4ff1-9c54-35d2b9fa0562@googlegroups.com>
Subject: Re: Interview question - better solution for MergePurgeAndReverseOrder()
From: bursejan@gmail.com
Injection-Date: Fri, 29 Mar 2019 22:40:50 +0000
Content-Type: text/plain; charset="UTF-8"
Lines: 137
Xref: csiph.com comp.lang.java.programmer:38835

The word "implement" got a total new meaning. 

Did they notice that you didn't implement 
anything, only used some library calls in the
most complicated way. 

Basically if the two input vectors are already 
sorted, you would possibly implement something 
totally different. Namely a pairing algorithm, 

which reads as follows:

   public static int[] merge(int[] a, int[] b) {
      int[] res=new int[a.length+b.length];
      int i=0;
      int j=0;
      int k=0;
      while (j<a.length && k<b.length) {
         if (a[j]<b[k]) {
            res[i++]=a[j++];
         } else {
            res[i++]=b[k++];
         }
      }
      while (j<a.length)
            res[i++]=a[j++];
      while (k<b.length)
            res[i++]=b[k++];
      return res;
   }

For simplicity, to make the point, the above is without
reverse/duplicate/null. The name "merge" tells me that 
this was asked. Otherwise it would be "union" and 

not "merge". Here is an example run. 

    public static void main(String[] args) {
        int[] a = new int[]{1, 2, 3};
        int[] b = new int[]{1, 2, 3, 4};
        int[] res = merge(a, b);
        for (int i = 0; i < res.length; i++)
            System.out.println("res[" + i + "]=" + res[i]);
    }

Thats the output:

res[0]=1
res[1]=1
res[2]=2
res[3]=2
res[4]=3
res[5]=3
res[6]=4

On Friday, March 29, 2019 at 4:01:13 PM UTC+1, Graeme Geldenhuys wrote:
> Hi,
> 
> I recently attended a Java developer interview and had to implement the
> MergePurgeAndReverseSort() method. I managed to complete it and
> afterwards wrote some unit tests to confirm that it works. But is there
> a better way to implement it, or did I do an okay job about it.
> 
> I can post the unit tests too if that might help.
> 
> Any feedback would be very much appreciated.
> 
> Regards,
>   Graeme
> 
> 
> 
> ***********************************************
> public class Main {
> 
> 	public static void main(String[] args) {
> 		Integer[] v1 = new Integer[] { 1, 2, null, 3 };
> 		Integer[] v2 = new Integer[] { 1, 2, 3, 4 };
> 		int[] arr = Util.MergePurgeAndReverseSort(v1, v2, true);
> 
> 		for (int i = 0; i < arr.length; i++)
> 			System.out.println(arr[i]);
> 
> 	}
> 
> }
> 
> ***********************************************
> 
> import java.util.Collections;
> import java.util.HashSet;
> import java.util.List;
> import java.util.Set;
> import java.util.stream.Collectors;
> 
> public class Util {
> 
> 	/*
> 	 * [x] Merge the two arrays
> 	 * [x] remove duplicates
> 	 * [x] remove NULL's
> 	 * [x] sort in reverse order
> 	 * [x] return as an int[] array
> 	 */
> 	public static int[] MergePurgeAndReverseSort(Integer[] values1,
> Integer[] values2, boolean reverse) {
> 		// merge arrays
> 		Integer[] v1andv2 = new Integer[values1.length + values2.length];
> 		System.arraycopy(values1, 0, v1andv2, 0, values1.length);
> 		System.arraycopy(values2, 0, v1andv2, values1.length, values2.length);
> 
> 		// Use a set to remove duplicates
> 		Set<Integer> intSet = new HashSet<>();
> 		for (Integer item : v1andv2) {
> 			// We could check for null's here too, or handle it separately as
> shown below
> 			if (item != null)
> 				intSet.add(item);
> 		}
> 
> 		// sort in reverse order
> 		List<Integer> lst;
> 		if (reverse)
> 			lst =
> intSet.stream().sorted(Collections.reverseOrder()).collect(Collectors.toList());
> 		else
> 			lst = intSet.stream().sorted().collect(Collectors.toList());
> 
> 
> 		// unbox data
> 		int[] n = lst.stream().mapToInt(Integer::intValue).toArray();
> 
> 		return n;
> 	}
> }
> 	
> ***********************************************