function quickSort(lst, begin=0, end=lst.length) 
{
    if (end - begin < 2) return
    let m = partSort(lst, begin, end)
    quickSort (lst, begin, m)
    quickSort (lst, m + 1, end)
}
function partSort(arr, begin=0, end=arr.length)
{
    function change(i, j) 
    {
        let temp = arr[i]
        arr[i] = arr[j] 
        arr[j] = temp
    }
    let s = begin
    end--
    while(true) 
    {
        while (arr[begin] <= arr[s]) begin++
        while (arr[end] >  arr[s]) end--
        if (begin < end)
        {
            change(begin, end)
        }
        else
        {
            break
        }
    }
    change(end, s)
    return end
}

 function quickSort(arr) {
        for (var i = 0, endI = arr.length - 1; i < endI; i++) {
            for (var j = 0, endJ = endI - i; j < endJ; j++) {
                if (arr[j] > arr[j + 1]) {
                    var swap = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = swap;
                }
            }
        }
}

 function quickSort(lst) {
for (let i = 0; i < lst.length - 1; i++) {
for (j = i + 1; j < lst.length; j++) {
if (lst[i] > lst[j]) {
let temp = lst[i];
lst[i] = lst[j];
lst[j] = temp
}
}
}
}

 function quickSort(lst, left = 0, right = lst.length - 1) {
let i = left; 
let j = right; 
let middle = lst[parseInt((right + left)/2)]; 

while (i < j) {
        while (lst[i] < middle) i++;
while (middle < lst[j]) j--;
if (i <= j) {
let temp = lst[i];
lst[i] = lst[j];
lst[j] = temp;
i++;
j--;
}
    }

    if (left < j) quickSort(lst, left, j); 
    if (i < right) quickSort(lst, i, right);
}

 function quickSort(lst){
    for(let i = 0; i < lst.length; i++){
  for(let k = 0; k < lst.length; k++){
  if(lst[i] > lst[k]){
    var gold = lst[k]
    lst[k]=lst[i]
    lst[i]=gold
  }
  }
  }
  return lst.reverse()
  }

 function quickSort(lst) {
    for (let index = 0; index < lst.length; index++) {
        for (let i = 0; i < lst.length-1; i++) {
            if (lst[i]>lst[i+1]) {
                let a = lst[i];
                lst[i]=lst[i+1];
                lst[i+1]=a;
            }
            
        }
    }
}

function part(lst, s, e){
    const pVal = lst[e];
    let pIdx = s; 
    for (let i = s; i < e; i++) {
        if (lst[i] < pVal) {
        let t = lst[i];
        lst[i] = lst[pIdx];
        lst[pIdx] = t;
        pIdx++;
        }
    }
    
    let t = lst[pIdx];
    lst[pIdx] = lst[e];
    lst[e] = t;
    return pIdx;
}

function quickSort(lst, s=0, e=0) {
    if(!e)
        e = lst.length-1;
    if (s >= e) {
        return;
    }
    
    let i = part(lst, s, e);
    
    quickSort(lst, s, i - 1);
    quickSort(lst, i + 1, e);
}

 function quickSort(lst){
    for(let i = 0; i < lst.length; i++){
  for(let k = 0; k < lst.length; k++){
  if(lst[i] > lst[k]){
    let gold = lst[k]
    lst[k] = lst[i]
    lst[i] = gold
  }
  }
 }
  return lst.reverse()
}

 function partSort(a, l, r) {
    const swap = (i, j) => {
        let t = a[i];
        a[i] = a[j];
        a[j] = t;
    };
    
    let p = l;
    r -= 1;
    while(true) {
        while(a[l] <= a[p]) l += 1;
        while(a[r] > a[p]) r -= 1;
        if(l < r)
            swap(l, r);
        else
            break;
    }
    swap(r, p);
    return r;
}

function quickSort(a, l = 0, r = a.length) {
    if(r - l < 2) return;
    let m = partSort(a, l, r);
    quickSort(a, l, m);
    quickSort(a, m + 1, r);
}

 function quickSort(arr, a=0,b=arr.length) {
    if (b - a < 2) return;
    let m = partSort(arr, a, b);
    quickSort (arr, a, m);
    quickSort (arr, m + 1, b);
} 
function partSort(arr, a=0, b=arr.length)
{
    function change(i, j) {
        let t = arr[i]; arr[i] = arr[j]; arr[j] = t;
    }

    let p = a;
    b--;
    while(1) {
        while (arr[a] <= arr[p]) a++;
        while (arr[b] >  arr[p]) b--;
        if (a < b)
            change(a, b);
        else
            break;
    }
    change(b, p);
    return b;
}

 function quickSort(lst, left = 0, right = lst.length) {
    function partSort(arr, left, right){
        let pos = left
        right--
        while (left < right){
            while (arr[left] <= arr[pos]) ++left
            while (arr[right] > arr[pos]) --right
            if (left < right) [arr[left], arr[right]] = [arr[right], arr[left]]
        }
        t = arr[right]
        arr[right] = arr[pos]
        arr[pos] = t
        return right
    }
    
    if (right - left < 2) return
    let temp = partSort(lst, left, right)
    quickSort(lst, left, temp)
    quickSort(lst, temp + 1, right)
}

 function quickSort(arr) {
    let temp = 0
    for(let i = 0;i< arr.length;i++){
        for(let j = i;j< arr.length;j++){
            if(arr[i]-arr[j]>0){
                console.log(arr)
                console.log(arr[i],arr[j],arr[i]-arr[j])
                temp = arr[j]
                arr.splice(j,1,arr[i])
                arr.splice(i,1,temp)
                temp = 0
            }
        }
    }
}

 function quickSort(lst) {
  for (let j = lst.length - 1; j > 0; j--) {
    for (let i = 0; i < j; i++) {
      if (lst[i] > lst[i + 1]) {
        let temp = lst[i];
        lst[i] = lst[i + 1];
        lst[i + 1] = temp;
      }
    }
  }
}

 function quickSort(lst) {
    let array = [];
    array.push(0);
    array.push(lst.length - 1);
    
    while(array[array.length - 1] >= 0) {
        let end = array.pop();
        let start = array.pop();
        
        let pivotIndex = partition(lst, start, end);
        
        if (pivotIndex - 1 > start) {
        array.push(start);
        array.push(pivotIndex - 1);
        }
        if (pivotIndex + 1 < end){
        array.push(pivotIndex + 1);
        array.push(end);
}

    }
    
}

function partition (arr, start, end) {
    let pivotValue = arr[end];
    let pivotIndex = start; 
    for (let i = start; i < end; i++) {
        if (arr[i] < pivotValue) {
        [arr[i], arr[pivotIndex]] = [arr[pivotIndex], arr[i]];
        pivotIndex++;
        }
    }
    [arr[pivotIndex], arr[end]] = [arr[end], arr[pivotIndex]] 
    return pivotIndex;
}

 function quickSort(lst, c = 0, d = lst.length - 1) {
    function partSort(a, b) {
        function change(i, j) {
            [lst[i], lst[j]] = [lst[j], lst[i]];
        }
        let pivot = lst[Math.floor((a + b) / 2)];
        a--;
        b++;
        while (true) {
            do {
                a++;
            } while (lst[a] < pivot);
            do {
                b--;
            } while (lst[b] > pivot);
            if (a >= b) return b;
            change(a, b);
        }
    }
    if (lst.length < 2) return;
    if (c >= 0 && d >= 0 && c < d) {
        let m = partSort(c, d);
        quickSort(lst, c, m);
        quickSort(lst, m + 1, d);
    }
}

 function quickSort(lst, a = 0,b = lst.length) {
    if(b-a< 2) return;
    let m = partSort(lst, a, b);
    quickSort (lst, a, m);
    quickSort (lst, m + 1, b);
}
function partSort(arr, a, b)
{
    function change(i, j) {
        let t = arr[i]; arr[i] = arr[j]; arr[j] = t;
    }
    let p = a;
    b--;
    while(1) {
        while (arr[a] <= arr[p]) a++;
        while (arr[b] >  arr[p]) b--;
        if (a < b)
            change(a, b);
        else
            break;
    }
    change(b, p);
    return b;
}

 function quickSort(lst) {
  for (let k = lst.length - 1; k > 0; k--) {
    for (let i = 0; i < k; i++) {
      if (lst[i] > lst[i + 1]) {
        let temp = lst[i];
        lst[i] = lst[i + 1];
        lst[i + 1] = temp;
      }
    }
  }
}

 function quickSort(lst,a = 0,b = lst.length) {
    if (b - a < 2) return;
    let m = partSort(lst, a, b);
    quickSort (lst, a, m);
    quickSort (lst, m + 1, b);
}
function partSort(arr, a = 0, b = arr.length)
{
    function change(i, j) {
        let t = arr[i]; arr[i] = arr[j]; arr[j] = t;
    }
    let p = a;
    b--;
    while(1) {
        while (arr[a] <= arr[p]) a++;
        while (arr[b] >  arr[p]) b--;
        if (a < b)
            change(a, b);
        else
            break;
    }
    change(b, p);
    return b;
}

 function quickSort(lst, left = 0, right = lst.length - 1) {
let i = left; 
let j = right; 
let middle = lst[parseInt((right + left)/2)]; 

while (i < j) {
        while (lst[i] < middle) i++;
while (middle < lst[j]) j--;
if (i <= j) {
let temp = lst[i];
lst[i] = lst[j];
lst[j] = temp;
i++;
j--;
}
    }

    if (left < j) quickSort(lst, left, j); 
    if (i < right) quickSort(lst, i, right);
}

 function quickSort(lst) {
    for(let length=lst.length-1; length>=0; length--){
        let max = length;
        for(let i=0; i            if(lst[max]< lst[i]){
                let tmp = lst[max];
                lst[max] = lst[i];
                lst[i] = tmp;
            }
        }
    }
}

 function quickSort(arr, left = 0, right = arr.length - 1){
    function pivot(arr, start = 0, end = arr.length -1){
        function replace(arr, i, j){
            let temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        
        let pivot = arr[start];
        let track = start;
        
        for(let i = start + 1; i <= end; i++){
            if(arr[i] < pivot){
                track++;
                replace(arr, track, i)
            }
        }
        replace(arr, start, track);
        
        return track;
    }
    if(left < right){
        let index = pivot(arr, left,  right);
        quickSort(arr, left, index - 1);
        quickSort(arr, index + 1, right)
    }
    
}

 function partSort(arr, k=0, k1 = arr.length-1){
    let a = arr[k]
    for(i=k;i<=k1;i++){
        if(arr[i]< a){
            let b = arr[i]
            arr.splice(i,1)
            arr.splice(k,0,b)
        }
    }
    return arr.indexOf(a)
}
function quickSort(lst, l1=0, l2=lst.length-1){
    if(l2-l1< 1) return
    let m = partSort(lst, l1, l2)
    quickSort(lst, l1, m)
    quickSort(lst, m+1, l2)
}