DouKaku?

| sort |
sort := [:min :max :size :data |
    | bag out |
    bag := data asBag.
    out := OrderedCollection new: size.
    min to: max do: [:each |
        (bag occurrencesOf: each) timesRepeat: [out add: each]].
    out asArray].

sort valueWithArguments: #(-1 10 10 (-1 9 4 8 9 6 3 9 5 2))
"=> #(-1 2 3 4 5 6 8 9 9 9) "

private import std.stdio;

void main() {
    int[] a = [1, 9, 4, 8, 9, 6, 3, 9, 5, 2];
    a.countingSort(1, 10);
    writeln(a);
}

void countingSort(int[] array, int min, int max) {
    auto counts = new uint[max - min + 1];
    foreach(n; array) {
        counts[n - min]++;
    }
    auto p = array.ptr;
    foreach(i, c; counts) {
        p[0..c] = i + min;
        p += c;
    }
}

import Data.List (group,sort)

main :: IO ()
main = print $ qsort (-1) 10 [-1,9,4,8,9,6,3,9,5,2]

uniq :: Ord a => [a] -> [a]
uniq ns = map head $ group $ sort ns

qsort :: Integral a => a -> a -> [a] -> [a]
qsort _ _ [] = []
qsort _ _ ns | length (uniq ns) == 1 = ns
qsort min max ns = let mid = div (max + min) 2
                   in qsort min mid [y | y <- ns, y < mid] ++ qsort mid max [y | y <- ns, y >=mid ]

import java.util.Arrays;

public class Sample187 {
    public static int[] countingSort(int min, int max, int[] data) {
        int[] counter = new int[max - min + 1];
        for (int i: data) {
            counter[i - min]++;
        }

        int[] result = new int[data.length];
        int index = 0;
        for (int i = 0; i < counter.length; i++) {
            for (int count = 0; count < counter[i]; count++) {
                result[index++] = i + min;
            }
        }
        return result;
    }

    public static void main(String[] args) {
        int[] sort = countingSort(-1, 10, new int[] {-1, 9, 4, 8, 9, 6, 3, 9, 5, 2});
        System.out.println(Arrays.toString(sort));
    }
}

<?php
$min = -1;
$max = 10;
$input = array(-1, 9, 4, 8, 9, 6, 3, 9, 5, 2);
$sorted = bucketsort($min, $max, $input);

function bucketsort($min, $max, $input){
    for($i = $min; $i <= $max; $i++)
        $temp[$i] = 0;
    foreach($input as $v)
        $temp[$v]++;
    foreach($temp as $k => $v)
        for($i = 0; $i < $v; $i++)
            $sorted[] = $k;
    return $sorted;
}

#include<stdio.h>

void sort(int min, int max, int len, int data[], int *result);

int main()
{
        int min = -1;
        int max = 10;
        int data[] = {-1, 9, 4, 8, 9, 6, 3, 9, 5, 2};
        int len = 10;
        int i;
        int *result;

        sort(min, max, len, data, result);
        for(i = 0; i < len; i++)
        {
                printf("%d\n", result[i]);
        }

        return 0;
}

void sort(int min, int max, int len, int data[], int * result)
{
        int bucket[len];
        int i, j;
        int idx = 0;

        for(i = min; i < max; i++)
        {
                bucket[i] = 0;
        }

        for(i = 0; i < len; i++)
        {
                bucket[data[i]]++;
        }


        for(i = min; i < max; i++)
        {
                for(j = 0; j < bucket[i]; j++)
                {
                        result[idx++] = i;
                }
        }
}

(define count-sort (lambda (range-min range-max range-len data)
  (let loop1 ((i range-min) (result '()))
    (if (>= i range-max)
      result
      (loop1 (+ i 1) (append result
        (let loop2 ((ls data) (rs '()))
          (if (pair? ls)
            (loop2 (cdr ls) (if (= i (car ls)) (cons i rs) rs))
            rs))))))))

(write (count-sort -1 10 10 '(-1 9 4 8 9 6 3 9 5 2)))
(newline)

Array.prototype.sort2 = function(minVal, maxVal) {
    if (this.length <= 1) return this;
    var mid = (minVal + maxVal) / 2;
    var lt = [], eq = [], gt = [];
    for (var i=0; i < this.length; i++) {
        if (this[i] > mid)
            gt.push(this[i]);
        else if (this[i] < mid)
            lt.push(this[i]);
        else
            eq.push(this[i]);
    }
    return lt.sort2(minVal, mid).concat(eq, gt.sort2(mid, maxVal));
};

[-1,9,4,8,9,6,3,9,5,2].sort2(-1,10)

module Main where

sort_noComp :: (Num a, Ord a, Enum a)=> a -> a -> Int -> [a] -> [a]
sort_noComp min max len xs = filter (\x -> elem x xs) [min..max]

main = print $ sort_noComp 1 9 8 [4, 8, 9, 6, 3, 9, 5, 2]

(defun bucket-sort (min max size data)
  (declare (integer min max size) (list data))
  (loop :with tem := (make-array (max size (- max min)) :initial-element () )
        :for item :of-type integer :in data
        :do (push item (svref tem (- item min)))
        :finally (return (reduce #'nconc tem))))

sort.uncompare <- function(min, max, num, l){
   unlist(sapply(min:max, function(n)(l[l==n])))
}

def sort(min, max, a):
    counts = [0] * (max - min + 1)
    for x in a:
        counts[x - min] += 1
    result = []
    for i, count in enumerate(counts):
        for _ in xrange(count):
            result.append(i + min)
    return result

def main():
    print sort(-1, 10, [-1, 9, 4, 8, 9, 6, 3, 9, 5, 2])

if __name__ == '__main__':
    main()

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        int[] x = { -1, 9, 4, 8, 9, 6, 3, 9, 5, 2 };

        foreach (var item in RadixSort(x, int.MinValue, int.MaxValue))
        {
            Console.Write(item + "  ");
        }
        Console.WriteLine();
    }

    static int[] RadixSort(int[] a, int min, int max)
    {
        for (uint x = 1; x != 0; x <<= 1)
        {
            a = a.Where(n => (n & x) == 0).Concat(a.Where(n => (n & x) != 0)).ToArray();
        }
        return a.SkipWhile(n => 0 <= n).Concat(a.TakeWhile(n => 0 <= n)).ToArray();
    }
}

sortx=:3 :0
  min=. 0 { y
  max=. 1 { y
  n=. 2 { y
  a=. 3 }. y
  b=. min + i. 1 + max - min
  (+/"1 b =/ a) # b
)

mysort min max ns = concat [filter (== x) ns | x <- [min..max]]

●sort(data,min)
    tmpとは配列
    bufとは配列
    iとは整数
    dataを反復
        tmp[対象-min]=tmp[対象-min]+1
    iで0から(tmpの配列要素数)-1まで繰り返す
        (tmp[i])回
            bufにi+minを配列追加
    bufで戻る

a="-1 9 4 8 9 6 3 9 5 2"を" "で区切る
sort(a,-1)を表示

import qualified Data.Map as M
import Control.Monad.State

counter min max xs = recur (M.fromAscList $ zip [min..max] (repeat 0)) xs
  where recur ctr [] = M.toAscList ctr
            recur ctr (x:xs) = recur (M.update (\v -> Just (succ v)) x ctr) xs

countingSort :: (Ord a, Enum a, Num a) => a -> a -> [a] -> [a]
countingSort min max xs = let ctr = counter min max xs
                                           result = M.fromAscList $ zip [0..len] (repeat 0)
                                      in evalState (countingSort_S min ctr) (0,result)
  where len = fromIntegral $ length xs - 1

countingSort_S :: (Ord a, Enum a, Num a) => a -> [(a,a)] -> State (a,M.Map a a) [a]
countingSort_S _ [] = get >>= return . M.elems . snd
countingSort_S min ((x,y):xs) = do
    forM_ [1..y] update
    countingSort_S min xs
  where update _ = do
                (index,result) <- get
                put (succ index, M.update f index result)
            f _ = Just x

main :: IO ()
main = do
    print $ countingSort (-1) 10 [-1,9,4,8,9,6,3,9,5,2]
    print $ countingSort (-100000) 100000 [-100000..100000]