import java.util.*;

public class Solution 
{
    public static void main (String[] args)
    {
        //************ALL DOCUMENTED TEST CASES**********
        //Ascending
        //float[] nums = new float[]{0f,2f,3f,4f,6f,8f,9f};   //Test case 1    PASS             
        //float[] nums = new float[]{-1f};   //Test case 2             PASS             
        //float[] nums = new float[]{0f};   //Test case 3       PASS                    
        //float[] nums = new float[]{0,1f,2,4f,5,7f};   //Test case 4    PASS            
        
        //Descending
        //float[] nums = float int[]{9f,8f,6f,4f,3f,2f,0f};    PASS            
        //float[] nums = new float[]{-1f};                PASS             
        //float[] nums = new float[]{0f};          PASS                    
        //float[] nums = new float[]{7f,5f,4f,2f,1f,0f};      PASS 
        
        //For some reason, no test cases above went through junction 8. All others are valid.
        //So these were new devised cases.....
        //float[] nums = new float[]{0f,1f,2f,4f,5f,7f,8f,10f,14f};   //Test case 4    PASS            
        //float[] nums = new float[]{0f,2f,4f,5f,7f,8f,10f,14f,17f,19f,23f,24f,25f,26f,35f,42f,43f,44f};  PASS     
        //float[] nums = new float[]{5f,4f,3f,4f,5f,7f,6f,10f,14f,17f,19f,23f,24f,25f,26f,35f,42f,47f,60f,61f};  PASS
        //float[] nums = new float[]{7f,6f,9f,3f,5f,8f};
        
        //Merging both ascending and descending code
        //float[] nums = new float[]{5f,4f,3f,4f,5f,6f,8f,8f};   PASS
        //float[] nums = new float[]{5f,4f,3f,4f,5f,7f,6f,5f,10f,14f,17f,19f,23f,24f,25f,26f,35f,34f,33f,47f};  PASS
        
        //float[] nums = new float[]{5f,6f,7f,6f,5f,9f,10f,11f,44f,45f,46f,47f,46f,45f,44f,43f,25f,24f,24f,23f,23f,22f};  //using ascending, descending and non-changing....PASS
        
        //float[] nums = new float[]{5f,9f,13f,2f,3f,4f,3f,1f,2f,3f,4f,5f,6f,22f,66f,65f,65f,64f,63f,90f,89f,60f}; //using standalone numbers in between and also ascending/descending...PASS
        //float[] nums = new float[]{1.5f,1.9f,  1.13f,  1.2f, 1.3f, 1.4f, 1.5f, 1.3f,  1.1f,  1.2f};
        
        double[] nums = new double[]{1.5d,1.9d,  1.13d,  1.2d, 1.1d, 1.4d, 1.5d, 1.3d,  1.1d,  1.2d};
        
        //float[] nums = new float[]{2.0f,4.0f,2.0f,1.2f,1.3f,1.4f,1.3f,1.1f,1.2f,1.3f,1.4f,1.5f,1.6f,1.22f,1.66f,1.65f,1.65f,1.64f,1.63f,1.90f,1.89f,1.60f}; 
        
       
        //repeat numbers
        //float[] nums = new float[]{2,2,2,4,4,1,1,9,9};  PASS
        
        System.out.println(summaryRanges(nums));
    }
    
    public static List<String> summaryRanges(double[] nums) 
    {
        List<String> sm = new ArrayList<>();
        int counter = 0;
        String start="";
        String end="";
        String temp="";
        String backupStart="";
        boolean hasTransition=false;
        String transitionNumber="";
        double difference=0.1;

        if (nums.length==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++)
        {
            if (k==0)
            {
                start=String.valueOf(nums[k]);
            }
            
            System.out.println("CHECKING: " + nums[k] + " with " + nums[k+1]);
            
            if ((nums[k]+difference)==(nums[k+1]))
            {
                if (counter==0)
                {
                    backupStart=String.valueOf(nums[k]);
                }
                
                if (counter==0 && (k==nums.length-2))
                {
                    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))
                {
                    end=String.valueOf(nums[k+1]);
                    sm.add(start +"->"+end);
                    System.out.println("6Writing range: " + start + "-> " + end); 
                }

                if (counter==0)
                {
                    start=String.valueOf(nums[k]);
                    System.out.println("Establishing start: " + start);
                    
                    if (k==nums.length-1)
                    {
                        System.out.println("2Writing Standalone: " + start);
                        sm.add(start);
                    }
                }
                counter++; 
            }
            else
            {
                if (k==nums.length-2)
                {
                    if (temp!="")
                    {
                        sm.add(temp);
                        System.out.println("9Writing range: " + temp);
                    }
                    
                    if (counter==0)
                    {
                        if ((nums[k]-difference)==(nums[k+1]))
                        {
                            start=String.valueOf(nums[k]);
                            end = String.valueOf(nums[k+1]);
                            sm.add(start+"->"+end);
                            System.out.println("7Writing range: " + start + "-> " + end);
                        }
                        else
                        {
                            end = String.valueOf(nums[k]);
                            
                            if (temp=="")
                            {
                                System.out.println("3Writing Standalone: " + end);
                                sm.add(end);
                            }
                                start=String.valueOf(nums[k+1]);
                                System.out.println("4Writing Standalone: " + start);
                                sm.add(start);
                        }
                    }
                    else
                    {
                        end=String.valueOf(nums[k]);
                        sm.add(start+"->"+end);
                        System.out.println("3Writing range: " + start + "-> " + end); 
                        sm.add(String.valueOf(nums[k+1]));
                    }
                }
                else
                {
                    if ((nums[k]-difference)==(nums[k+1]))
                    {
                        end=String.valueOf(nums[k+1]);
                    }
                    else
                    {
                        end=String.valueOf(nums[k]);
                    }
                    if (counter==0)
                    {
                        if(k==0)
                        {
                            if ((nums[k]-difference)==(nums[k+1]))
                            {
                                start=String.valueOf(nums[k]);
                                counter++;
                            }
                            else 
                            {
                                System.out.println("5Writing standalone: " + start);
                                sm.add(start);
                            }
                        }
                        else
                        {
                            if ((nums[k]-difference)==(nums[k+1]))
                            {
                                if (temp=="")
                                {
                                    if ((nums[k-1]-difference)==(nums[k]))
                                    {
                                        backupStart=String.valueOf(nums[k-1]);
                                    }
                                    else
                                    {
                                        backupStart=String.valueOf(nums[k]);
                                    }
                                    
                                    temp=backupStart+"->"+end;
                                    hasTransition=false;
                                }
                                else
                                {
                                    end=String.valueOf(nums[k+1]);
                                    temp=backupStart+"->"+end;
                                    hasTransition=false;
                                }
                                System.out.println("8Storing range: " + temp);
                            }
                            else
                            {
                                if (temp!="")
                                {
                                    sm.add(temp);
                                    System.out.println("8Writing range: " + temp);
                                    temp="";
                                    backupStart="";
                                }
                                else
                                {
                                    if ((nums[k-1]-difference)==(nums[k]))
                                    {
                                        start=String.valueOf(nums[k-1]);
                                        end = String.valueOf(nums[k]);
                                        sm.add(start+"->"+end);
                                        System.out.println("11Writing range: " + start+"->"+end);
                                    }
                                    else
                                    {
                                        start = String.valueOf(nums[k]);
                                        sm.add(start);
                                        System.out.println("6Writing Standalone: " + start);
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        if ((nums[k-1]+difference)==(nums[k]) &&  (nums[k])==(nums[k+1])+difference)
                        {
                            end=String.valueOf(nums[k]);
                            sm.add(backupStart+"->"+end);
                            System.out.println("10Writing range: " + backupStart+"->"+end);
                            hasTransition=true;
                            transitionNumber=String.valueOf(nums[k]);
                        }
                        if (!hasTransition)
                        {
                            if (temp!="")
                            {
                                end=String.valueOf(nums[k+1]);
                                sm.add(start+"->"+end);
                            }
                            else
                            {
                                System.out.println("2Writing range: " + start + "-> " + end); 
                                sm.add(start+"->"+end);
                            }
                        }
                        counter=0;
                        temp="";
                        backupStart="";
                        hasTransition=false;
                    }
                }
            }
        }
        return sm;
    }
}