import java.util.*;
public class Solution 
{
    public static void main (String[] args)
    {
        //int[] nums = new int[]{0,2,3,4,6,8,9};   //Test case 1    PASS             Junction 2,6,10,11,12,3,5,14,13,4
        //int[] nums = new int[]{-1};   //Test case 2             PASS             Junction 1
        //int[] nums = new int[]{0};   //Test case 3       PASS                    Junction 1
        //int[] nums = new int[]{0,1,2,4,5,7};   //Test case 4    PASS            Junction 2,3,5,6,10,14,9,7
        
        //For some reason, no test cases above went through junction 8. All others are valid.
        //So I devised a new test case below and it passes through it...
        
        //new test case:
        //int[] nums = new int[]{0,1,2,4,5,7,8,10,14};   //Test case 4    PASS            //Junction 2,3,5,6,10,14,7,8
        //int[] nums = new int[]{0,1,2,4,5,7,8,10,14,17,19,23,24,25,26,35,42,43,44};        //Junction 2,3,5,6,10,14,7,8,11,13,16
        //int[] nums = new int[]{5,4,3,4,5,7,6,10,14,17,19,23,24,25,26,35,42,47};
        //int[] nums = new int[]{7,6,9,3,5,8};
        
        //Merging both ascending and descending code
        //int[] nums = new int[]{5,4,3,4,5,6,8,8};
        int[] nums = new int[]{5,4,3,4,5,7,6,10,14,17,19,23,24,25,26,35,34,47};
        
        System.out.println(summaryRanges(nums));
    }
    
    public static List<String> summaryRanges(int[] nums) 
    {
        List<String> sm = new ArrayList<>();
        int counter = 0;
        String start="";
        String end="";

        if (nums.length==1)
        {
            System.out.println("JUNCTION 1");
            sm.add(String.valueOf(nums[0]));
            System.out.println("1Writing Standalone: " + nums[0]);
            return sm;
        }

        for (int k=0; k<nums.length-1;k++)
        {
            System.out.println("value k: " + k);
            System.out.println("length nums: " + nums.length);
            System.out.println("value of counter: " + counter);

            if (k==0)
            {
                System.out.println("JUNCTION 2");
                start=String.valueOf(nums[k]);
            }
            //{0,2,3,4,6,8,9}           
            //this time focussing on equality
            System.out.println("£££££££££££££££££££CHECKING: " + nums[k] + " with " + nums[k+1]);
            
            
              //if the next element is ascending
              if ((nums[k]+1)==(nums[k+1]))
            
            
            //if the next element is descending
            //if ((nums[k]-1)==(nums[k+1]))
            {
                System.out.println("JUNCTION 3");
                System.out.println("VAL COUNTER: " + counter);
                if (counter==0 && (k==nums.length-2))
                {
                    System.out.println("JUNCTION 4");
                    start=String.valueOf(nums[k]);
                    end = String.valueOf(nums[k+1]);
                    sm.add(start+"->"+end);
                    System.out.println("5Writing range: " + start + "-> " + end); 
                    break;
                }
                
                if (counter!=0 && (k==nums.length-2))
                {
                    System.out.println("Junction 16");
                    end=String.valueOf(nums[k+1]);
                    sm.add(start +"->"+end);
                    System.out.println("6Writing range: " + start + "-> " + end); 
                    System.out.println("Terminating summary range join");
                }

                if (counter==0)
                {
                    System.out.println("JUNCTION 5");
                    start=String.valueOf(nums[k]);
                    System.out.println("Establishing start: " + start);
                    
                    if (k==nums.length-1)
                    {
                        System.out.println("Junction 15");
                        System.out.println("2Writing Standalone: " + start);
                        sm.add(start);
                    }
                }
                counter++; 
            }
            else    ////not consecutive match
            {
                System.out.println("JUNCTION 6");
                if (k==nums.length-2)
                {
                    System.out.println("JUNCTION 7");
                    System.out.println("counter:" + counter + "-------------------------------LAST TO LAST ITEM :" + nums[k]);
                    
                    if (counter==0)
                    {
                        if ((nums[k]-1)==(nums[k+1]))
                        {
                            System.out.println("------NEW JUNCTION 20");
                            start=String.valueOf(nums[k]);
                            end = String.valueOf(nums[k+1]);
                            sm.add(start+"->"+end);
                            System.out.println("7Writing range: " + start + "-> " + end);
                            
                        }
                        else
                        {
                            System.out.println("JUNCTION 8");
                        end = String.valueOf(nums[k]);
                        System.out.println("HERE");
                        System.out.println("3Writing Standalone: " + end);
                        sm.add(end);
                        //System.out.println("6Writing range: " + start + "-> " + end); 
                        start=String.valueOf(nums[k+1]);
                        System.out.println("4Writing Standalone: " + start);
                        sm.add(start);
                        }
                        
                    }
                    else
                    {
                        System.out.println("JUNCTION 9");
                        end=String.valueOf(nums[k]);
                        sm.add(start+"->"+end);
                        System.out.println("3Writing range: " + start + "-> " + end); 
                        sm.add(String.valueOf(nums[k+1]));
                    }
                }
                
                //if (k!=nums.length-2)
                else      
                {
                    System.out.println("-----------NEW JUNCTION 18");
                                //we know at this point we can definitely determine the start as 5
                                //we know descening has continued with 4 and 3...
                                //so we need to include the descending to check this check
                                
                                System.out.println(nums[k]);
                                System.out.println(nums[k+1]);
                                
                                if ((nums[k]-1)==(nums[k+1]))
                                {
                                //start=String.valueOf(nums[k]);
                                //counter++;
                                System.out.println("---------NEW JUNCTION 19");
                                end=String.valueOf(nums[k+1]);
                                }
                                else
                                {
                                    System.out.println("JUNCTION 10");
                                    System.out.println("****************************" + counter);
                                    //endConsecutive=true;
                                    end=String.valueOf(nums[k]);
                                }

                    if (counter==0)
                    {
                        System.out.println("JUNCTION 11");
                        
                        if(k==0)
                        {
                            if ((nums[k]-1)==(nums[k+1]))
                            {
                                System.out.println("-----------NEW JUNCTION 17");
                                //we know at this point we can definitely determine the start...
                                //we are not sure if the descending will continue...
                                start=String.valueOf(nums[k]);
                                counter++;
                                //break;
                            }
                            //it would have made this decision normally
                            //to write the  5 as standalone in  {
                            else
                            {
                            System.out.println("JUNCTION 12");
                            System.out.println("5Writing standalone: " + start);
                            sm.add(start);
                            }
                        }
                        
                        //if k!=0  &&  k!=nums.length-2)  && counter==0  && not consective number (nums[k+1] ascending by 1 from nums[k]
                        else
                        {
                            
                            if ((nums[k]-1)==(nums[k+1]))
                            {
                                //System.out.println("-----NEW JUNCTION 21");
                                start = String.valueOf(nums[k]);
                                end = String.valueOf(nums[k+1]);
                                sm.add(start+"->"+end);
                            }
                            
                            else
                            {
                            System.out.println("JUNCTION 13");
                            start = String.valueOf(nums[k]);
                            sm.add(start);
                            System.out.println("6Writing Standalone: " + start);
                            }
                            
                        }
                    }
                    //if counter!=0
                    else
                    {
                        System.out.println("JUNCTION 14");
                        System.out.println("2Writing range: " + start + "-> " + end); 
                        sm.add(start+"->"+end);
                        //start=String.valueOf(nums[k+1]);
                        counter=0;
                    }
                }
            }
        }  //end for 
        return sm;
    }
}