Algorithms

struct pivot { 
  int l,r;
}; /* the "pivot" struct represents a range in an array */

function partition( array, left, right ) {
  pivot.l = pivot.r = left  /* pivot starts as a range of 1 variable,
                               array[left] */
  for i = left to right 
  {
    if (array[i] >= pivot.l)
      pivot.r += 1          /* increase the range of the pivot */
    else 
      swap_r(pivot,i)       /* swap the entire range with the 
                               next element, to stay stable */
  }
  return pivot.l            /* return the start of the pivot range */
}

swap_r (range, index) {     
/* swaps an index with a range, by going through 
   the entire range one at a time. Probably naive */

  int t=range.r
  while(range.l<=t)
    swap_i(t--,index)
}

swap_i (index1, index2) { 
  /// straight swap, requires a single 
  /// temporary element (or possibly just a pointer)
}

function quicksort(array) { 
  int p = partition(array,0,length-1)
  quicksort(array,0,p)
  quicksort(array,p+1,length-1)
}

0 1 4 4 5 4 2 4 2 3 5 3 7 6 7 4

TimeSpan some=33milliseconds;
forever {
    if (getCumulativeCPUload() < wantedCPUload) busyLoop(some);
    else sleep(some);
}

static void SimulateProcessorLoad(int wantedCPUload)
{
    PerformanceCounter cpuCounter = new PerformanceCounter()
    {
        CategoryName = "Processor",
        CounterName = "% Processor Time",
        InstanceName = "_Total"
    };

    do
    {
        if (cpuCounter.NextValue() < wantedCPUload)
            busyLoop();
        else
            Thread.Sleep(33); 
    } while (true);
}

I are troll