Merge Intervals

                            Solution in C :

int cmp(const void **a, const void **b)
{
    return (*(int *)a[0] - *(int *)b[0]);
}

#define MAX 10000

int** merge(int** intervals, int intervalsSize, int* intervalsColSize, int* returnSize, int** returnColumnSizes)
{
    /* Sort the given intervals based on the first value of each interval */
    qsort(intervals, intervalsSize, sizeof(intervals[0]), cmp);
    
    /* Keep a 'prev' interval to keep track of the updating intervals
     * as we iterate over the given intervals
     */
    int prev[2] = {intervals[0][0], intervals[0][1]};
    
    /* The given problem has atleast one solution
     * so we create an array and asssign the first
     * interval to the results and update as required
     * over iteration
     */
    int **ret = (int **)calloc(MAX, sizeof(int *));
    *returnColumnSizes = (int *)calloc(MAX, sizeof(int));
    int len = 0;

    int *arr = (int *)calloc(2, sizeof(int));
    arr[0] = prev[0];
    arr[1] = prev[1];
    
    ret[len] = arr;
    (*returnColumnSizes)[len] = 2;
    len++;
    
    for (int i = 1; i < intervalsSize; i++) {
        int *curr = intervals[i];
        
        /* Add a new interval to the result only if the interval is non-overlapping
         * to the previous one.
         */
        if (prev[1] < curr[0] && prev[1] < curr[1]) {
            int *new = (int *)calloc(2, sizeof(int));
            new[0] = curr[0];
            new[1] = curr[1];
            
            ret[len] = new;
            (*returnColumnSizes)[len] = 2;
            len++;
            
            prev[0] = curr[0];
            prev[1] = curr[1];
        }
        /* Update the result interval's end value */
        else if (prev[1] >= curr[0] && prev[1] < curr[1]) {
            prev[1] = curr[1];
            ret[len - 1][1] = curr[1];
        }
    }
    
    *returnSize = len;
    
    return ret;
}
                        

                        Solution in C++ :

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        
      if(intervals.size()==1)
         return intervals;
      vector<pair<int,int>> p;
      for(int i=0;i<intervals.size();i++)
      {
          p.push_back({intervals[i][0],intervals[i][1]});
      } 
      sort(p.begin(),p.end());

      vector<vector<int>> ans;
      int f=p[0].first,s=p[0].second;
      for(int i=0;i<p.size()-1;i++)
      {
          vector<int> a(2);
          if(s>=p[i+1].first)
          {
              s=max(s,p[i+1].second);
          }
          else
          {
              a[0]=f;
              a[1]=s;
              f=p[i+1].first;
              s=p[i+1].second;
              ans.push_back(a);
          }
      } 
      int n=intervals.size();
      ans.push_back({f,s});
      return ans;
    }
};
                    

                        Solution in Java :

class Solution {
    public int[][] merge(int[][] intervals) {
		int min = Integer.MAX_VALUE;
		int max = Integer.MIN_VALUE;
		
		for (int i = 0; i < intervals.length; i++) {
			min = Math.min(min, intervals[i][0]);
			max = Math.max(max, intervals[i][0]);
		}
		
		int[] range = new int[max - min + 1];
		for (int i = 0; i < intervals.length; i++) {
			range[intervals[i][0] - min] = Math.max(intervals[i][1] - min, range[intervals[i][0] - min]); 
		}
		
		int start = 0, end = 0;
		LinkedList<int[]> result = new LinkedList<>();
		for (int i = 0; i < range.length; i++) {
			if (range[i] == 0) {
				continue;
			}
			if (i <= end) {
				end = Math.max(range[i], end);
			} else {
				result.add(new int[] {start + min, end + min});
				start = i;
				end = range[i];
			}
		}
		result.add(new int[] {start + min, end + min});
		return result.toArray(new int[result.size()][]);
	}
}
                    

                        Solution in Python : 
                            
class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        intervals = sorted(intervals, key=lambda x: x [0])

        ans = []

        for interval in intervals:
            if not ans or ans[-1][1] < interval[0]:
                ans.append(interval)
            else:
                ans[-1][1] = max(ans[-1][1], interval[1])
        
        return ans