Charles Chung, Java

Charles Chung

/* 
Input: 1->2->4, 1->3->4
Output: 1->1->2->3->4->4
 */

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

class ListNode{
    public int value;
    public ListNode next;  
    public ListNode(int value)
    {
        this.value = value;
        this.next = null;
    }
}

class ListHelper {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        
       
        /*
            TODO: Enter code here
            Input:  a: [1,2,4,10,33]
                    b: [1,3,4,50] 
                    Output: res: [1,1,2,3, 4, 4,10,33, 50]
           
           1. All input arrays are sorted
           2. Arrays may have duplicate entries
           3. Merged array should be sorted with duplicates
        */
        
        if (l1 == null)
            return l2;
        if (l2 == null)
            return l1;
        
        if (l1.value < l2.value)
        {
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
        }
        else
        {
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }
    }
          
    
    public int[] dedup(int[] nodeValues){
        // dedup code here
        //[1,1,2,2,2,3,4,5]
        //[1,2,3,4,5]        
        
        int len = nodeValues.length;
        
        for (int i = 0; i < len; i++)
        {
            for (int j = i + 1; j < len; j++)
            {
                if (nodeValues[i] == nodeValues[j])
                {
                    int left = j;
                    for (int k = j+1; k < len; k++)
                    {
                        nodeValues[left] = nodeValues[k];
                    }
                    len--;
                    j--;
                }
            }
        }
        
        int[] nonDup = new int[len];
        for(int i=0; i<len; i++)
        {
            nonDup[i] = nodeValues[i];
        }
        
        return nonDup;
    }
    
    public ListNode toListNode(int[] nodeValues) {    
        // Now convert that list into linked list
        ListNode dummyRoot = new ListNode(0);
        ListNode ptr = dummyRoot;
        for(int item : nodeValues) {
            ptr.next = new ListNode(item);
            ptr = ptr.next;
        }
        return dummyRoot.next;
    }
    
    public String toString(ListNode node) {
        if (node == null) {
            return "[]";
        }
    
        String result = "";
        while (node != null) {
            result += Integer.toString(node.value) + ", ";
            node = node.next;
        }
        return "[" + result.substring(0, result.length() - 2) + "]";
    }
}

class Rextester
{              
    
     public static int[] stringToIntegerArray(String input) {
        input = input.trim();
        input = input.substring(1, input.length() - 1);
        if (input.length() == 0) {
          return new int[0];
        }
    
        String[] parts = input.split(",");
        int[] output = new int[parts.length];
        for(int index = 0; index < parts.length; index++) {
            String part = parts[index].trim();
            output[index] = Integer.parseInt(part);
        }
        return output;
    }        
    
    public static void main(String args[]) throws Exception
    {        
        ListHelper listHelper = new ListHelper(); 
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String line;
        while ((line = in.readLine()) != null) {
            int[] nodeValues = stringToIntegerArray(line);
            ListNode l1 = listHelper.toListNode(nodeValues);
            System.out.println("List 1:" + listHelper.toString(l1));
            line = in.readLine();
            int[] nodeValues2 = stringToIntegerArray(line);
            ListNode l2 = listHelper.toListNode(nodeValues2);
            System.out.println("List 2:" + listHelper.toString(l2));
            
            ListNode ret = listHelper.mergeTwoLists(l1, l2);            
            String out = listHelper.toString(ret);            
            System.out.println("Merged:" + out);            
                        
            int[] deduped = listHelper.dedup(nodeValues);
            if(deduped!=null){
                ListNode dedupedList = listHelper.toListNode(deduped);
                System.out.println("Deduped:" + listHelper.toString(dedupedList));
            }
        }                     
    }        
}


run \| edit \| history \| help	0