Flashsort

function flashSort(arr, stats) {
  const n = arr.length;
  if (n < 2) return;
  let min = arr[0], max = 0;
  const m = Math.max(1, Math.floor(0.45 * n));
  let l = new Array(m).fill(0);
  for (let i = 1; i < n; i++) {
    if (arr[i] < min) min = arr[i];
    if (arr[i] > arr[max]) max = i;
  }
  if (min === arr[max]) return;
  let c1 = (m - 1) / (arr[max] - min);
  for (let j = 0; j < n; j++) {
    let k = Math.floor(c1 * (arr[j] - min));
    l[k]++;
  }
  for (let p = 1; p < m; p++) {
    l[p] = l[p] + l[p - 1];
  }
  let hold = arr[max];
  arr[max] = arr[0];
  arr[0] = hold;
  let move = 0, j = 0, k = m - 1;
  let flash;
  while (move < n - 1) {
    while (j > l[k] - 1) {
      j++;
      k = Math.floor(c1 * (arr[j] - min));
    }
    flash = arr[j];
    while (j !== l[k]) {
      k = Math.floor(c1 * (flash - min));
      hold = arr[l[k] - 1];
      arr[l[k] - 1] = flash;
      flash = hold;
      l[k]--;
      move++;
      write(l[k], arr[l[k]]);
    }
  }
  for (let i = 1; i < n; i++) {
    let hold = arr[i];
    let j = i - 1;
    while (j >= 0 && arr[j] > hold) {
      arr[j + 1] = arr[j];
      write(j + 1, arr[j + 1]);
      j--;
    }
    arr[j + 1] = hold;
    write(j + 1, hold);
  }
  for (let i = 0; i < n; i++) markSorted(i);
}

def flashSort(arr, stats):
    if (n < 2):
        return
    min = arr[0]
    max = 0
    m = (1 if 1 >= int((0.45 * n)) else int((0.45 * n)))
    l = [0] * m
    for i in range(1, n):
        if (arr[i] < min):
            min = arr[i]
        if (arr[i] > arr[max]):
            max = i
    if (min == arr[max]):
        return
    c1 = ((m - 1) / (arr[max] - min))
    for j in range(n):
        k = int((c1 * (arr[j] - min)))
        l[k] += 1
    for p in range(1, m):
        l[p] = (l[p] + l[(p - 1)])
    hold = arr[max]
    arr[max] = arr[0]
    arr[0] = hold
    move = 0
    j = 0
    k = (m - 1)
    flash = None
    while (move < (n - 1)):
        while (j > (l[k] - 1)):
            j += 1
            k = int((c1 * (arr[j] - min)))
        flash = arr[j]
        while (j != l[k]):
            k = int((c1 * (flash - min)))
            hold = arr[(l[k] - 1)]
            arr[(l[k] - 1)] = flash
            flash = hold
            l[k] -= 1
            move += 1
            write(l[k], arr[l[k]])
    for i in range(1, n):
        hold = arr[i]
        j = (i - 1)
        while ((j >= 0) and (arr[j] > hold)):
            arr[(j + 1)] = arr[j]
            write((j + 1), arr[(j + 1)])
            j -= 1
        arr[(j + 1)] = hold
        write((j + 1), hold)
    for i in range(n):
        markSorted(i)

#include <vector>
#include <algorithm>
#include <cmath>
void sort(std::vector<int>& arr, int n, int& comparisons, int& swaps) {
    if((n < 2)) {
        return;
    }
    int min = arr[0];
    int max = 0;
    int m = ((1) > ((int)std::floor((0.45 * n))) ? (1) : ((int)std::floor((0.45 * n))));
    std::vector<int> l(m, 0);
    for(int i=1; i<n; i++) {
        if((arr[i] < min)) {
            min = arr[i];
        }
        if((arr[i] > arr[max])) {
            max = i;
        }
    }
    if((min == arr[max])) {
        return;
    }
    int c1 = ((m - 1) / (arr[max] - min));
    for(int j=0; j<n; j++) {
        int k = (int)std::floor((c1 * (arr[j] - min)));
        l[k]++;
    }
    for(int p=1; p<m; p++) {
        l[p] = (l[p] + l[(p - 1)]);
    }
    int hold = arr[max];
    arr[max] = arr[0];
    arr[0] = hold;
    int move = 0;
    int j = 0;
    int k = (m - 1);
    int flash;
    while((move < (n - 1))) {
        while((j > (l[k] - 1))) {
            j++;
            k = (int)std::floor((c1 * (arr[j] - min)));
        }
        flash = arr[j];
        while((j != l[k])) {
            k = (int)std::floor((c1 * (flash - min)));
            hold = arr[(l[k] - 1)];
            arr[(l[k] - 1)] = flash;
            flash = hold;
            l[k]--;
            move++;
            write(l[k], arr[l[k]]);
        }
    }
    for(int i=1; i<n; i++) {
        int hold = arr[i];
        int j = (i - 1);
        while(((j >= 0) && (arr[j] > hold))) {
            arr[(j + 1)] = arr[j];
            write((j + 1), arr[(j + 1)]);
            j--;
        }
        arr[(j + 1)] = hold;
        write((j + 1), hold);
    }
    for(int i=0; i<n; i++) {
        markSorted(i);
    }
}

public void Sort(int[] arr, int n, dynamic stats) {
    if((n < 2)) {
        return;
    }
    int min = arr[0];
    int max = 0;
    int m = Math.Max(1, (int)Math.Floor((double)(0.45 * n)));
    int[] l = new int[m];
    for(int i=1; i<n; i++) {
        if((arr[i] < min)) {
            min = arr[i];
        }
        if((arr[i] > arr[max])) {
            max = i;
        }
    }
    if((min == arr[max])) {
        return;
    }
    int c1 = ((m - 1) / (arr[max] - min));
    for(int j=0; j<n; j++) {
        int k = (int)Math.Floor((double)(c1 * (arr[j] - min)));
        l[k]++;
    }
    for(int p=1; p<m; p++) {
        l[p] = (l[p] + l[(p - 1)]);
    }
    int hold = arr[max];
    arr[max] = arr[0];
    arr[0] = hold;
    int move = 0;
    int j = 0;
    int k = (m - 1);
    int flash;
    while((move < (n - 1))) {
        while((j > (l[k] - 1))) {
            j++;
            k = (int)Math.Floor((double)(c1 * (arr[j] - min)));
        }
        flash = arr[j];
        while((j != l[k])) {
            k = (int)Math.Floor((double)(c1 * (flash - min)));
            hold = arr[(l[k] - 1)];
            arr[(l[k] - 1)] = flash;
            flash = hold;
            l[k]--;
            move++;
            write(l[k], arr[l[k]]);
        }
    }
    for(int i=1; i<n; i++) {
        int hold = arr[i];
        int j = (i - 1);
        while(((j >= 0) && (arr[j] > hold))) {
            arr[(j + 1)] = arr[j];
            write((j + 1), arr[(j + 1)]);
            j--;
        }
        arr[(j + 1)] = hold;
        write((j + 1), hold);
    }
    for(int i=0; i<n; i++) {
        markSorted(i);
    }
}

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
void sort(int arr[], int n, int* comparisons, int* swaps) {
    if((n < 2)) {
        return;
    }
    int min = arr[0];
    int max = 0;
    int m = ((1) > ((int)floor((0.45 * n))) ? (1) : ((int)floor((0.45 * n))));
    int* l = (int*)malloc((m) * sizeof(int)); memset(l, 0, (m) * sizeof(int));
    for(int i=1; i<n; i++) {
        if((arr[i] < min)) {
            min = arr[i];
        }
        if((arr[i] > arr[max])) {
            max = i;
        }
    }
    if((min == arr[max])) {
        return;
    }
    int c1 = ((m - 1) / (arr[max] - min));
    for(int j=0; j<n; j++) {
        int k = (int)floor((c1 * (arr[j] - min)));
        l[k]++;
    }
    for(int p=1; p<m; p++) {
        l[p] = (l[p] + l[(p - 1)]);
    }
    int hold = arr[max];
    arr[max] = arr[0];
    arr[0] = hold;
    int move = 0;
    int j = 0;
    int k = (m - 1);
    int flash;
    while((move < (n - 1))) {
        while((j > (l[k] - 1))) {
            j++;
            k = (int)floor((c1 * (arr[j] - min)));
        }
        flash = arr[j];
        while((j != l[k])) {
            k = (int)floor((c1 * (flash - min)));
            hold = arr[(l[k] - 1)];
            arr[(l[k] - 1)] = flash;
            flash = hold;
            l[k]--;
            move++;
            write(l[k], arr[l[k]]);
        }
    }
    for(int i=1; i<n; i++) {
        int hold = arr[i];
        int j = (i - 1);
        while(((j >= 0) && (arr[j] > hold))) {
            arr[(j + 1)] = arr[j];
            write((j + 1), arr[(j + 1)]);
            j--;
        }
        arr[(j + 1)] = hold;
        write((j + 1), hold);
    }
    for(int i=0; i<n; i++) {
        markSorted(i);
    }
}