Maximum CPU Load from the given list of jobs

// C# implementation to find the
// maximum CPU Load from the given
// lists of the jobs

using System;
using System.Collections.Generic;
using System.Linq;

// Blueprint of the job
public class Job {
    public int Start { get; set; }
    public int End { get; set; }
    public int CpuLoad { get; set; }

    // Constructor function for the CPU Job
    public Job(int start, int end, int cpuLoad) {
        Start = start;
        End = end;
        CpuLoad = cpuLoad;
    }
}

public class MaximumCpuLoad {

    // Structure to compare two CPU Jobs by their end time
    public class EndCompare : IComparer<Job> {
        public int Compare(Job x, Job y) {
            return x.End.CompareTo(y.End);
        }
    }

    // Function to find the maximum CPU Load at any instance of the time for given jobs
    public static int FindMaxCpuLoad(List<Job> jobs) {
        // Condition when there are no jobs then CPU Load is 0
        if (jobs.Count == 0) {
            return 0;
        }

        // Sorting all the jobs by their start time
        jobs = jobs.OrderBy(j => j.Start).ToList();

        int maxCpuLoad = 0;
        int currentCpuLoad = 0;

        // Min-heap implemented using the help of the SortedSet
        var minHeap = new SortedSet<Job>(new EndCompare());

        // Loop to iterate over all the jobs from the given list
        foreach (var job in jobs) {
            // Loop to remove all jobs from the heap which is ended
            while (minHeap.Count > 0 && job.Start > minHeap.First().End) {
                currentCpuLoad -= minHeap.First().CpuLoad;
                minHeap.Remove(minHeap.First());
            }

            // Add the current Job to CPU
            minHeap.Add(job);
            currentCpuLoad += job.CpuLoad;
            maxCpuLoad = Math.Max(maxCpuLoad, currentCpuLoad);
        }
        return maxCpuLoad;
    }
}

// Driver Code
public class Program {
    public static void Main(string[] args) {
        var input = new List<Job> {
            new Job(1, 4, 3),
            new Job(7, 9, 6),
            new Job(2, 5, 4)
        };

        Console.WriteLine("Maximum CPU load at any time: {0}", MaximumCpuLoad.FindMaxCpuLoad(input));
    }
}
// This code is contributed by rutikbhosale.

using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;

// C# implementation to find the
// maximum CPU Load from the given array of jobs

// the job struct will have s(starting time) , e(ending time) , load(cpu load)
class Job {
  public int s;
  public int e;
  public int load;

  public Job(int x, int y, int z){
    s = x;
    y = e;
    load = z;
  }
}

// endpoint struct will have val(the time associated with the endpoint),
// load(cpu load associated with the endpoint),
// a flag isStart which will tell if the endpoint is starting or ending point of
// an interval
class Endpoint {

  public int val;
  public int load;
  public bool isStart;

  public Endpoint(int x, int y, bool z){
    val = x;
    load = y;
    isStart = z;
  }
}


class HelloWorld {

  // custom sort function. 
  class GFG : IComparer<Endpoint>
  {
    public int Compare(Endpoint a, Endpoint b)
    {


      if (a.val != b.val){
        if(a.val < b.val) return 1;
        else return 0;
      }

      // CompareTo() method
      if(a.isStart == true && b.isStart == false) return 1;
      return 0;

    }
  }


  //function to find maximum cpu load
  public static int maxCpuLoad(Job[] v)
  {
    int count = 0; // count will contain the count of current loads
    int result = 0; // result will contain maximum of all counts

    // this data array will contain all the endpoints combined with their load values
    // and flags telling whether they are starting or ending point
    List<Endpoint> data = new List<Endpoint>();


    for (int i = 0; i < v.Length; i++) {
      data.Add(new Endpoint(v[i].s, v[i].load, true));
      data.Add(new Endpoint(v[i].e, v[i].load, false));
    }

    GFG gg = new GFG();
    data.Sort(gg);


    for (int i = 0; i < data.Count; i++) {
      if (data[i].isStart == true) {
        count += data[i].load;
        result = Math.Max(result, count);
      }
      else
        count -= data[i].load;

    }

    return result;
  }


  static void Main() {

    Job[] v = new Job[3];
    v[0] = new Job(6, 7, 10);
    v[1] = new Job(2, 4, 11);
    v[2] = new Job(8, 12, 15);

    Console.WriteLine(maxCpuLoad(v));

  }
}

// The code is contributed by Nidhi goel.