Summary Ranges

                                            
class Solution {
public:
    vector<string> summaryRanges(vector<int>& nums) {
        vector<string> result;
        if (nums.empty()) {
            return result;
        }
        
        int start = nums[0];
        int end = nums[0];
        
        for (int i = 1; i < nums.size(); ++i) {
            if (nums[i] == end + 1) {
                end = nums[i];
            } else {
                if (start == end) {
                    result.push_back(to_string(start));
                } else {
                    result.push_back(to_string(start) + "->" + to_string(end));
                }
                start = nums[i];
                end = nums[i];
            }
        }
        
        if (start == end) {
            result.push_back(to_string(start));
        } else {
            result.push_back(to_string(start) + "->" + to_string(end));
        }
        
        return result;
    }
};

                                            
class Solution {
    public List<String> summaryRanges(int[] nums) {
        List<String> result = new ArrayList<>();
        if (nums == null || nums.length == 0) {
            return result;
        }
        
        int start = nums[0];
        int end = nums[0];

        for (int i = 1; i < nums.length; i++) {
            if (nums[i] == end + 1) {
                end = nums[i];
            } else {
                if (start == end) {
                    result.add(String.valueOf(start));
                } else {
                    result.add(start + "->" + end);
                }
                start = end = nums[i];
            }
        }

        if (start == end) {
            result.add(String.valueOf(start));
        } else {
            result.add(start + "->" + end);
        }

        return result;
    }
}

                                            
class Solution(object):
    def summaryRanges(self, nums):
        """
        :type nums: List[int]
        :rtype: List[str]
        """
        if not nums:
            return []
        
        result = []
        start = end = nums[0]
        
        for i in range(1, len(nums)):
            if nums[i] == end + 1:
                end = nums[i]
            else:
                if start == end:
                    result.append(str(start))
                else:
                    result.append(str(start) + "->" + str(end))
                start = end = nums[i]
        
        if start == end:
            result.append(str(start))
        else:
            result.append(str(start) + "->" + str(end))
        
        return result

                                            
/**
 * Note: The returned array must be malloced, assume 
caller calls free().
 */

char ** summaryRanges(int* nums, int numsSize, int* returnSize){
    if(numsSize == 0){
        *returnSize = 0;
        return NULL;
    }
    
    char **result = (char **)malloc(numsSize * sizeof(char *));
    *returnSize = 0;
    
    for(int i = 0; i < numsSize; i++){
        int start = nums[i];
        
        while(i + 1 < numsSize && nums[i + 1] == nums[i] + 1){
            i++;
        }
        
        if(start == nums[i]){
            result[*returnSize] = (char *)malloc(20 * sizeof(char));
            sprintf(result[*returnSize], "%d", start);
        }else{
            result[*returnSize] = (char *)malloc(40 * sizeof(char));
            sprintf(result[*returnSize], "%d->%d", start, nums[i]);
        }
        
        (*returnSize)++;
    }
    
    return result;
}

                                            
public class Solution {
    public IList<string> SummaryRanges(int[] nums) {
        IList<string> result = new List<string>();
        
        for (int i = 0; i < nums.Length; i++) {
            int start = nums[i];
            while (i + 1 < nums.Length && nums[i + 1] == nums[i] + 1) {
                i++;
            }
            int end = nums[i];
            result.Add(start == end ? start.ToString() : start + "->" + end);
        }
        
        return result;
    }
}

                                            
/**
 * @param {number[]} nums
 * @return {string[]}
 */
const summaryRanges = (nums) => {
    const ranges = [];
    for (let i = 0; i < nums.length; i++) {
        let start = nums[i];
        while (i + 1 < nums.length && nums[i + 1] - nums[i] === 1) {
            i++;
        }
        if (start !== nums[i]) {
            ranges.push(`${start}->${nums[i]}`);
        } else {
            ranges.push(`${start}`);
        }
    }
    return ranges;
};

                                            
function summaryRanges(nums: number[]): string[] {
    const result: string[] = [];
    let start = 0;
    
    for (let i = 0; i < nums.length; i++) {
        if (nums[i + 1] !== nums[i] + 1) {
            if (start === i) {
                result.push(nums[start].toString());
            } else {
                result.push(`${nums[start]}->${nums[i]}`);
            }
            start = i + 1;
        }
    }
    
    return result;
};

                                            
class Solution {
    /**
     * @param Integer[] $nums
     * @return String[]
     */
    function summaryRanges($nums) {
        $result = array();
        $count = count($nums);
        
        if ($count == 0) {
            return $result;
        }
        
        $start = $nums[0];
        $end = $nums[0];
        
        for ($i = 1; $i < $count; $i++) {
            if ($nums[$i] == $end + 1) {
                $end = $nums[$i];
            } else {
                if ($start == $end) {
                    $result[] = strval($start);
                } else {
                    $result[] = $start . '->' . $end;
                }
                
                $start = $nums[$i];
                $end = $nums[$i];
            }
        }
        
        if ($start == $end) {
            $result[] = strval($start);
        } else {
            $result[] = $start . '->' . $end;
        }
        
        return $result;
    }
}

                                            
class Solution {
    func summaryRanges(_ nums: [Int]) -> [String] {
        var result = [String]()
        var start = 0
        var end = 0
        
        while end < nums.count {
            if end + 1 < nums.count && nums[end + 1] - nums[end] == 1 {
                end += 1
            } else {
                if start == end {
                    result.append("\(nums[start])")
                } else {
                    result.append("\(nums[start])->\(nums[end])")
                }
                end += 1
                start = end
            }
        }
        
        return result
    }
}

                                            
class Solution {
    fun summaryRanges(nums: IntArray): List<String> {
        val result = mutableListOf<String>()
        var start = 0
        var end = 0
        
        while (end < nums.size) {
            while (end + 1 < nums.size && nums[end + 1] == nums[end] + 1) {
                end++
            }
            
            if (start == end) {
                result.add(nums[start].toString())
            } else {
                result.add("${nums[start]}->${nums[end]}")
            }
            
            end++
            start = end
        }
        
        return result
    }
}

                                            
class Solution {
  List<String> summaryRanges(List<int> nums) {
    List<String> result = [];
    for (int i = 0; i < nums.length; i++) {
      int start = nums[i];
      while (i + 1 < nums.length && nums[i + 1] - nums[i] == 1) {
        i++;
      }
      int end = nums[i];
      result.add(start == end ? '$start' : '$start->$end');
    }
    return result;
  }
}

                                            
func summaryRanges(nums []int) []string {
    if len(nums) == 0 {
        return []string{}
    }

    var result []string
    start, end := nums[0], nums[0]

    for i := 1; i < len(nums); i++ {
        if nums[i] == end+1 {
            end = nums[i]
        } else {
            if start == end {
                result = append(result, strconv.Itoa(start))
            } else {
                result = append(result, fmt.Sprintf("%d->%d", start, end))
            }
            start, end = nums[i], nums[i]
        }
    }

    if start == end {
        result = append(result, strconv.Itoa(start))
    } else {
        result = append(result, fmt.Sprintf("%d->%d", start, end))
    }

    return result
}

                                            
# @param {Integer[]} nums
# @return {String[]}
def summary_ranges(nums)
    return [] if nums.empty?
    
    ranges = []
    start = nums[0]
    nums.each_with_index do |num, idx|
        if num + 1 != nums[idx + 1]
            if start != num
                ranges << "#{start}->#{num}"
            else
                ranges << "#{start}"
            end
            start = nums[idx + 1]
        end
    end
    
    ranges
end

                                            
object Solution {
    def summaryRanges(nums: Array[Int]): List[String] = {
        var result = List[String]()
        var i = 0
        while (i < nums.length) {
            var start = nums(i)
            while (i + 1 < nums.length && nums(i + 1) - nums(i) == 1) {
                i += 1
            }
            if (start != nums(i)) {
                result = result :+ s"$start->${nums(i)}"
            } else {
                result = result :+ s"$start"
            }
            i += 1
        }
        result
    }
}

                                            
impl Solution {
    pub fn summary_ranges(nums: Vec<i32>) -> Vec<String> {
        let mut result: Vec<String> = Vec::new();
        let mut i = 0;
        
        while i < nums.len() {
            let start = nums[i];
            while i + 1 < nums.len() && nums[i + 1] == nums[i] + 1 {
                i += 1;
            }
            if start != nums[i] {
                result.push(format!("{}->{}", start, nums[i]));
            } else {
                result.push(nums[i].to_string());
            }
            i += 1;
        }
        
        result
    }
}

To solve this coding challenge, we need to develop a function that takes a sorted unique integer array and returns the smallest sorted list of ranges that covers all the numbers in the array exactly. Each range should be represented as "a->b" if there's more than one number in the range, otherwise just "a". We will walk through the logical steps to achieve this solution:

# Explanation

Input Recognition : First, we need to check if the input array is empty. If it is, we should return an empty list immediately.
Initialization : We need to initialize variables to keep track of the start and end of the current range. Initially, both
start

and
end

will be set to the first element of the array.
Iteration through the Array : We iterate through the array starting from the second element. For each element, we check if it is exactly one greater than the current
end

. If it is, we extend the current range by updating the
end

. If not, we add the current range to the result list and start a new range starting from the current element.
Range Representation : We need to determine whether to represent a range as "a" or "a->b". If the start and end of the range are the same, it's a single number range; otherwise, it spans multiple numbers.
Final Range : After the iteration, there might be a remaining range that has not been added to the result list, so we add the final range to the list.
Return Result : Finally, we return the constructed list of ranges.

Detailed Steps in Pseudocode

Check for Empty Input:

                                            
if input_array is empty
return empty list

Check if the input list is empty, and if so, return an empty list since there are no ranges to process.

Initialize Variables:

                                            
result_list = empty list
start = first element of input_array
end = first element of input_array

Initialize an empty list
result_list

to store the output ranges.
Set both
start

and
end

to the first element of the input list to begin tracking the first range.

Iterate Through the Array:

                                            
for i from 1 to length of input_array - 1
if input_array[i] == end + 1
end = input_array[i]
else
if start == end
add start as string to result_list
else
add start + "->" + end as string to result_list
start = input_array[i]
end = input_array[i]

Start a loop from the second element to the end of the input array.
If the current element is exactly one greater than
end

, extend the current range by setting
end

to this element.
If the current element is not consecutive, determine how to represent and add the completed range to the result list. Then, start a new range beginning with the current element.

Add Final Range:

                                            
if start == end
add start as string to result_list
else
add start + "->" + end as string to result_list

After iterating through the array, add the final range (either as a single number or as a range) to the result list.

Return Result:

                                            
return result_list

Return the list containing all the ranges formed from the input array.

Pseudocode with Comments

                                            
# Check if the input array is empty
if input_array is empty:
    # If empty, return an empty list
    return empty list

# Initialize result list to store range outputs
result_list = empty list
# Initialize start and end to the first element
start = input_array[0]
end = input_array[0]

# Iterate from the second element to the end of the input array
for i from 1 to length of input_array - 1:
    # Check if current element extends the current range
    if input_array[i] == end + 1:
        # Extend the current range
        end = input_array[i]
    else:
        # Finalize the current range and add it to the result list
        if start == end:
            result_list append start as string
        else:
            result_list append start + "->" + end as string
        
        # Start a new range
        start = input_array[i]
        end = input_array[i]

# Add the final range to the result list
if start == end:
    result_list append start as string
else:
    result_list append start + "->" + end as string

# Return the result containing all ranges
return result_list

In this highly detailed explanation and pseudocode, each step corresponds to concrete operations and logical checks designed to form the smallest sorted list of ranges from the given sorted unique integer array. Each comment explains the purpose of the code statements, ensuring clarity and completeness in understanding how to tackle this coding challenge.