Sleep Sort

function sleepSort(arr, stats) {
  const n = arr.length;
  if (n < 2) return;
  let min = arr[0];
  for (let i = 1; i < n; i++) min = Math.min(min, arr[i]);
  const offset = min < 0 ? -min : 0;
  const awakened = [];
  const events = arr.map((value, idx) => ({
    wake: (value + offset) * 4 + idx * 1e-6,
    value
  }));
  for (let e = 0; e < events.length; e++) {
    const event = events[e];
    let i = awakened.length;
    while (i > 0) {
      if (awakened[i - 1].wake <= event.wake) break;
      i--;
    }
    awakened.splice(i, 0, event);
  }
  for (let i = 0; i < n; i++) {
    arr[i] = awakened[i].value;
    write(i, awakened[i].value);
    markSorted(i);
  }
}

from types import SimpleNamespace

def sleepSort(arr, stats):
    if (n < 2):
        return
    min = arr[0]
    for i in range(1, n):
        min = (min if min <= arr[i] else arr[i])
    offset = (-min if (min < 0) else 0)
    awakened = []
    events = [SimpleNamespace(wake=(((value + offset) * 4) + (idx * 0.000001)), value=value) for value in arr]
    for e in range(len(events)):
        event = events[e]
        i = len(awakened)
        while (i > 0):
            if (awakened[(i - 1)].wake <= event.wake):
                break
            i -= 1
        awakened.insert(i, event)
    for i in range(n):
        arr[i] = awakened[i].value
        write(i, awakened[i].value)
        markSorted(i)

#include <vector>
#include <algorithm>
void sort(std::vector<int>& arr, int n, int& comparisons, int& swaps) {
    if((n < 2)) {
        return;
    }
    int min = arr[0];
    for(int i=1; i<n; i++) {
        min = ((min) < (arr[i]) ? (min) : (arr[i]));
    }
    int offset = (((min < 0)) ? (-min) : (0));
    std::vector<int> awakened;
    std::vector<int> events(n); for(int _mi=0;_mi<n;_mi++) { int value=arr[_mi]; events[_mi]={wake: (((value + offset) * 4) + (idx * 0.000001)), value: value}; }
    for(int e=0; e<n; e++) {
        int event = events[e];
        int i = (int)awakened.size();
        while((i > 0)) {
            if((awakened[(i - 1)].wake <= event.wake)) {
                break;
            }
            i--;
        }
        awakened.insert(awakened.begin() + i, event);
    }
    for(int i=0; i<n; i++) {
        arr[i] = awakened[i].value;
        write(i, awakened[i].value);
        markSorted(i);
    }
}

public void Sort(int[] arr, int n, dynamic stats) {
    if((n < 2)) {
        return;
    }
    int min = arr[0];
    for(int i=1; i<n; i++) {
        min = Math.Min(min, arr[i]);
    }
    int offset = (((min < 0)) ? (-min) : (0));
    var awakened = new List<int>();
    int[] events = new int[n]; for(int _mi=0;_mi<n;_mi++) { int value=arr[_mi]; events[_mi]={wake: (((value + offset) * 4) + (idx * 0.000001)), value: value}; }
    for(int e=0; e<n; e++) {
        int event = events[e];
        int i = awakened.Count;
        while((i > 0)) {
            if((awakened[(i - 1)].wake <= event.wake)) {
                break;
            }
            i--;
        }
        awakened.Insert(i, event);
    }
    for(int i=0; i<n; i++) {
        arr[i] = awakened[i].value;
        write(i, awakened[i].value);
        markSorted(i);
    }
}

#include <stdio.h>
#include <stdlib.h>
void sort(int arr[], int n, int* comparisons, int* swaps) {
    if((n < 2)) {
        return;
    }
    int min = arr[0];
    for(int i=1; i<n; i++) {
        min = ((min) < (arr[i]) ? (min) : (arr[i]));
    }
    int offset = (((min < 0)) ? (-min) : (0));
    int* awakened = (int*)malloc(n * sizeof(int)); int awakened_len = 0;
    int* events = (int*)malloc((n) * sizeof(int)); for(int _mi=0;_mi<n;_mi++) { int value=arr[_mi]; events[_mi]={wake: (((value + offset) * 4) + (idx * 0.000001)), value: value}; }
    for(int e=0; e<n; e++) {
        int event = events[e];
        int i = awakened_len;
        while((i > 0)) {
            if((awakened[(i - 1)].wake <= event.wake)) {
                break;
            }
            i--;
        }
        awakened_insert(i, event);
    }
    for(int i=0; i<n; i++) {
        arr[i] = awakened[i].value;
        write(i, awakened[i].value);
        markSorted(i);
    }
}