aparler/RosettaCodeData
1
0
Fork 0
Code Issues 12 Pull requests 3 Projects Releases Packages Wiki Activity Actions

all tasks

Browse source
This commit is contained in:
Ingy döt Net 2013-04-11 01:07:29 -07:00
parent b83f433714
commit 68f8f3e56b
14735 changed files with 178959 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

23
Task/Sorting-algorithms-Counting-sort/0DESCRIPTION Normal file
View file

@ -0,0 +1,23 @@
{{Sorting Algorithm}}
{{Wikipedia|Counting sort}}
Implement the [[wp:Counting sort|Counting sort]]. This is a way of sorting integers when the minimum and maximum value are known.
Pseudocode:
'''function''' ''countingSort''(array, min, max):
count: '''array of''' (max - min + 1) '''elements'''
'''initialize''' count '''with''' 0
'''for each''' number '''in''' array '''do'''
count[number - min] := count[number - min] + 1
'''done'''
z := 0
'''for''' i '''from''' min '''to''' max '''do'''
'''while''' ( count[i - min] > 0 ) '''do'''
array[z] := i
z := z+1
count[i - min] := count[i - min] - 1
'''done'''
'''done'''
The ''min'' and ''max'' can be computed apart, or be known ''a priori''.
'''Note''': we know that, given an array of integers, its maximum and minimum values can be always found; but if we imagine the worst case for an array of 32 bit integers, we see that in order to hold the counts, we need an array of 2<sup>32</sup> elements, i.e., we need, to hold a count value up to 2<sup>32</sup>-1, more or less 4 Gbytes. So the counting sort is more practical when the range is (very) limited and minimum and maximum values are known ''a priori''. (Anyway sparse arrays may limit the impact of the memory usage)

2
Task/Sorting-algorithms-Counting-sort/1META.yaml Normal file
View file

@ -0,0 +1,2 @@
---
note: Sorting Algorithms

40
Task/Sorting-algorithms-Counting-sort/ALGOL-68/sorting-algorithms-counting-sort.alg Normal file
View file

@ -0,0 +1,40 @@
PROC counting sort mm = (REF[]INT array, INT min, max)VOID:
(
INT z := LWB array - 1;
[min:max]INT count;
FOR i FROM LWB count TO UPB count DO count[i] := 0 OD;
FOR i TO UPB array DO count[ array[i] ]+:=1 OD;
FOR i FROM LWB count TO UPB count DO
FOR j TO count[i] DO array[z+:=1] := i OD
OD
);
PROC counting sort = (REF[]INT array)VOID:
(
INT min, max;
min := max := array[LWB array];
FOR i FROM LWB array + 1 TO UPB array DO
IF array[i] < min THEN
min := array[i]
ELIF array[i] > max THEN
max := array[i]
FI
OD
);
# Testing (we suppose the oldest human being is less than 140 years old). #
INT n = 100;
INT min age = 0, max age = 140;
main:
(
[n]INT ages;
FOR i TO UPB ages DO ages[i] := ENTIER (random * ( max age + 1 ) ) OD;
counting sort mm(ages, min age, max age);
FOR i TO UPB ages DO print((" ", whole(ages[i],0))) OD;
print(new line)
)

16
Task/Sorting-algorithms-Counting-sort/ActionScript/sorting-algorithms-counting-sort.as Normal file
View file

@ -0,0 +1,16 @@
function countingSort(array:Array, min:int, max:int)
{
var count:Array = new Array(array.length);
for(var i:int = 0; i < count.length;i++)count[i]=0;
for(i = 0; i < array.length; i++)
{
count[array[i]-min] ++;
}
var j:uint = 0;
for(i = min; i <= max; i++)
{
for(; count[i-min] > 0; count[i-min]--)
array[j++] = i;
}
return array;
}

18
Task/Sorting-algorithms-Counting-sort/Ada/sorting-algorithms-counting-sort.ada Normal file
View file

@ -0,0 +1,18 @@
with Ada.Text_Io; use Ada.Text_Io;
procedure Counting_Sort is
type Data is array (Integer range <>) of Natural;
procedure Sort(Item : out Data) is
begin
for I in Item'range loop
Item(I) := I;
end loop;
end Sort;
Stuff : Data(1..140);
begin
Sort(Stuff);
for I in Stuff'range loop
Put(Natural'Image(Stuff(I)));
end loop;
New_Line;
end Counting_Sort;

14
Task/Sorting-algorithms-Counting-sort/AutoHotkey/sorting-algorithms-counting-sort.ahk Normal file
View file

@ -0,0 +1,14 @@
MsgBox % CountingSort("-1,1,1,0,-1",-1,1)
CountingSort(ints,min,max) {
Loop % max-min+1
i := A_Index-1, a%i% := 0
Loop Parse, ints, `, %A_Space%%A_Tab%
i := A_LoopField-min, a%i%++
Loop % max-min+1 {
i := A_Index-1, v := i+min
Loop % a%i%
t .= "," v
}
Return SubStr(t,2)
}

23
Task/Sorting-algorithms-Counting-sort/BBC-BASIC/sorting-algorithms-counting-sort.bbc Normal file
View file

@ -0,0 +1,23 @@
DIM test%(9)
test%() = 4, 65, 2, -31, 0, 99, 2, 83, 782, 1
PROCcountingsort(test%(), -31, 782)
FOR i% = 0 TO 9
PRINT test%(i%) ;
NEXT
PRINT
END
DEF PROCcountingsort(a%(), l%, h%)
LOCAL i%, z%, c%()
DIM c%(h% - l%)
FOR i% = 0 TO DIM(a%(),1)
c%(a%(i%) - l%) += 1
NEXT
FOR i% = l% TO h%
WHILE c%(i% - l%)
a%(z%) = i%
z% += 1
c%(i% - l%) -= 1
ENDWHILE
NEXT
ENDPROC

35
Task/Sorting-algorithms-Counting-sort/C/sorting-algorithms-counting-sort-1.c Normal file
View file

@ -0,0 +1,35 @@
#include <stdio.h>
#include <stdlib.h>
void counting_sort_mm(int *array, int n, int min, int max)
{
int i, j, z;
int range = max - min + 1;
int *count = malloc(range * sizeof(*array));
for(i = 0; i < range; i++) count[i] = 0;
for(i = 0; i < n; i++) count[ array[i] - min ]++;
for(i = min, z = 0; i <= max; i++) {
for(j = 0; j < count[i - min]; j++) {
array[z++] = i;
}
}
free(count);
}
void counting_sort(int *array, int n)
{
int i, min, max;
min = max = array[0];
for(i=1; i < n; i++) {
if ( array[i] < min ) {
min = array[i];
} else if ( array[i] > max ) {
max = array[i];
}
}
}

11
Task/Sorting-algorithms-Counting-sort/C/sorting-algorithms-counting-sort-2.c Normal file
View file

@ -0,0 +1,11 @@
#define N 100
#define MAX_AGE 140
int main()
{
int ages[N], i;
for(i=0; i < N; i++) ages[i] = rand()%MAX_AGE;
counting_sort_mm(ages, N, 0, MAX_AGE);
for(i=0; i < N; i++) printf("%d\n", ages[i]);
return EXIT_SUCCESS;
}

12
Task/Sorting-algorithms-Counting-sort/Common-Lisp/sorting-algorithms-counting-sort.lisp Normal file
View file

@ -0,0 +1,12 @@
(defun counting-sort (sequence &optional (min (reduce #'min sequence))
(max (reduce #'max sequence)))
(let ((i 0)
(counts (make-array (1+ (- max min)) :initial-element 0
:element-type `(integer 0 ,(length sequence)))))
(declare (dynamic-extent counts))
(map nil (lambda (n) (incf (aref counts (- n min)))) sequence)
(map-into sequence (lambda ()
(do () ((plusp (aref counts i)))
(incf i))
(decf (aref counts i))
(+ i min)))))

27
Task/Sorting-algorithms-Counting-sort/D/sorting-algorithms-counting-sort.d Normal file
View file

@ -0,0 +1,27 @@
import std.stdio, std.algorithm;
void countingSort(int[] array, in size_t min, in size_t max)
pure nothrow {
auto count = new int[max - min + 1];
foreach (number; array)
count[number - min]++;
size_t z = 0;
foreach (i; min .. max + 1)
while (count[i - min] > 0) {
array[z] = i;
z++;
count[i - min]--;
}
}
void main() {
auto data = [9, 7, 10, 2, 9, 7, 4, 3, 10, 2, 7, 10, 2, 1, 3, 8,
7, 3, 9, 5, 8, 5, 1, 6, 3, 7, 5, 4, 6, 9, 9, 6, 6,
10, 2, 4, 5, 2, 8, 2, 2, 5, 2, 9, 3, 3, 5, 7, 8, 4];
int dataMin = reduce!min(data);
int dataMax = reduce!max(data);
countingSort(data, dataMin, dataMax);
assert(isSorted(data));
}

13
Task/Sorting-algorithms-Counting-sort/E/sorting-algorithms-counting-sort.e Normal file
View file

@ -0,0 +1,13 @@
def countingSort(array, min, max) {
def counts := ([0] * (max - min + 1)).diverge()
for elem in array {
counts[elem - min] += 1
}
var i := -1
for offset => count in counts {
def elem := min + offset
for _ in 1..count {
array[i += 1] := elem
}
}
}

39
Task/Sorting-algorithms-Counting-sort/Fortran/sorting-algorithms-counting-sort-1.f Normal file
View file

@ -0,0 +1,39 @@
module CountingSort
implicit none
interface counting_sort
module procedure counting_sort_mm, counting_sort_a
end interface
contains
subroutine counting_sort_a(array)
integer, dimension(:), intent(inout) :: array
call counting_sort_mm(array, minval(array), maxval(array))
end subroutine counting_sort_a
subroutine counting_sort_mm(array, tmin, tmax)
integer, dimension(:), intent(inout) :: array
integer, intent(in) :: tmin, tmax
integer, dimension(tmin:tmax) :: cnt
integer :: i, z
forall(i=tmin:tmax)
cnt(i) = count(array == i)
end forall
z = 1
do i = tmin, tmax
do while ( cnt(i) > 0 )
array(z) = i
z = z + 1
cnt(i) = cnt(i) - 1
end do
end do
end subroutine counting_sort_mm
end module CountingSort

17
Task/Sorting-algorithms-Counting-sort/Fortran/sorting-algorithms-counting-sort-2.f Normal file
View file

@ -0,0 +1,17 @@
program test
use CountingSort
implicit none
integer, parameter :: n = 100, max_age = 140
real, dimension(n) :: t
integer, dimension(n) :: ages
call random_number(t)
ages = floor(t * max_age)
call counting_sort(ages, 0, max_age)
write(*,'(I4)') ages
end program test

45
Task/Sorting-algorithms-Counting-sort/Go/sorting-algorithms-counting-sort-1.go Normal file
View file

@ -0,0 +1,45 @@
package main
import (
"fmt"
"runtime"
"strings"
)
var a = []int{170, 45, 75, -90, -802, 24, 2, 66}
var aMin, aMax = -1000, 1000
func main() {
fmt.Println("before:", a)
countingSort(a, aMin, aMax)
fmt.Println("after: ", a)
}
func countingSort(a []int, aMin, aMax int) {
defer func() {
if x := recover(); x != nil {
// one error we'll handle and print a little nicer message
if _, ok := x.(runtime.Error); ok &&
strings.HasSuffix(x.(error).Error(), "index out of range") {
fmt.Printf("data value out of range (%d..%d)\n", aMin, aMax)
return
}
// anything else, we re-panic
panic(x)
}
}()
count := make([]int, aMax-aMin+1)
for _, x := range a {
count[x-aMin]++
}
z := 0
// optimization over task pseudocode: variable c is used instead of
// count[i-min]. This saves some unneccessary calculations.
for i, c := range count {
for ; c > 0; c-- {
a[z] = i + aMin
z++
}
}
}

50
Task/Sorting-algorithms-Counting-sort/Go/sorting-algorithms-counting-sort-2.go Normal file
View file

@ -0,0 +1,50 @@
package main
import (
"fmt"
"runtime"
"strings"
)
var a = []int{170, 45, 75, -90, -802, 24, 2, 66}
var aMin, aMax = -1000, 1000
func main() {
fmt.Println("before:", a)
countingSort(a, aMin, aMax)
fmt.Println("after: ", a)
}
func countingSort(a []int, aMin, aMax int) {
defer func() {
if x := recover(); x != nil {
// one error we'll handle and print a little nicer message
if _, ok := x.(runtime.Error); ok &&
strings.HasSuffix(x.(error).Error(), "index out of range") {
fmt.Printf("data value out of range (%d..%d)\n", aMin, aMax)
return
}
// anything else, we re-panic
panic(x)
}
}()
// WP algorithm
k := aMax - aMin // k is maximum key value. keys range 0..k
count := make([]int, k+1)
key := func(v int) int { return v - aMin }
for _, x := range a {
count[key(x)]++
}
total := 0
for i, c := range count {
count[i] = total
total += c
}
output := make([]int, len(a))
for _, x := range a {
output[count[key(x)]] = x
count[key(x)]++
}
copy(a, output)
}

8
Task/Sorting-algorithms-Counting-sort/Groovy/sorting-algorithms-counting-sort-1.groovy Normal file
View file

@ -0,0 +1,8 @@
def countingSort = { array ->
def max = array.max()
def min = array.min()
// this list size allows use of Groovy's natural negative indexing
def count = [0] * (max + 1 + [0, -min].max())
array.each { count[it] ++ }
(min..max).findAll{ count[it] }.collect{ [it]*count[it] }.flatten()
}

7
Task/Sorting-algorithms-Counting-sort/Groovy/sorting-algorithms-counting-sort-2.groovy Normal file
View file

@ -0,0 +1,7 @@
println countingSort([23,76,99,58,97,57,35,89,51,38,95,92,24,46,31,24,14,12,57,78,4])
println countingSort([88,18,31,44,4,0,8,81,14,78,20,76,84,33,73,75,82,5,62,70,12,7,1])
println countingSort([15,-3,0,-1,5,4,5,20,-8])
println countingSort([34,6,8,7,4,3,56,7,8,4,3,5,7,8,6,4,4,67,9,0,0,76,467,453,34,435,37,4,34,234,435,3,2,7,4,634,534,-735,5,4,6,78,4])
// slo-o-o-o-ow due to unnecessarily large counting array
println countingSort([10000033,10000006,10000008,10000009,10000013,10000031,10000013,10000032,10000023,10000023,10000011,10000012,10000021])

5
Task/Sorting-algorithms-Counting-sort/Haskell/sorting-algorithms-counting-sort.hs Normal file
View file

@ -0,0 +1,5 @@
import Data.Array
countingSort :: (Ix n) => [n] -> n -> n -> [n]
countingSort l lo hi = concatMap (uncurry $ flip replicate) count
where count = assocs . accumArray (+) 0 (lo, hi) . map (\i -> (i, 1)) $ l

23
Task/Sorting-algorithms-Counting-sort/Icon/sorting-algorithms-counting-sort.icon Normal file
View file

@ -0,0 +1,23 @@
procedure main() #: demonstrate various ways to sort a list and string
write("Sorting Demo using ",image(countingsort))
writes(" on list : ")
writex(UL)
displaysort(countingsort,copy(UL))
end
procedure countingsort(X) #: return sorted list (integers only)
local T,lower,upper
T := table(0) # hash table as sparse array
lower := upper := X[1]
every x := !X do {
if not ( integer(x) = x ) then runerr(x,101) # must be integer
lower >:= x # minimum
upper <:= x # maximum
T[x] +:= 1 # record x's and duplicates
}
every put(X := [],( 1 to T[i := lower to upper], i) ) # reconstitute with correct order and count
return X
end

24
Task/Sorting-algorithms-Counting-sort/Io/sorting-algorithms-counting-sort-1.io Normal file
View file

@ -0,0 +1,24 @@
List do(
countingSort := method(min, max,
count := list() setSize(max - min + 1) mapInPlace(0)
foreach(x,
count atPut(x - min, count at(x - min) + 1)
)
j := 0
for(i, min, max,
while(count at(i - min) > 0,
atPut(j, i)
count atPut(i - min, at(i - min) - 1)
j = j + 1
)
)
self)
countingSortInPlace := method(
countingSort(min, max)
)
)
l := list(2, 3, -4, 5, 1)
l countingSortInPlace println # ==> list(-4, 1, 2, 3, 5)

23
Task/Sorting-algorithms-Counting-sort/Io/sorting-algorithms-counting-sort-2.io Normal file
View file

@ -0,0 +1,23 @@
List do(
fill := method(x, size,
/* Resizes list to a given size and fills it with a given value. */
setSize(size) mapInPlace(x)
)
countingSort := method(min, max,
count := list() fill(0, max - min + 1)
foreach(x,
count atPut(x - min, count at(x - min) + 1)
)
return count map(i, x, list() fill(i + min, x)) \
prepend(list()) reduce(xs, x, xs appendSeq(x))
)
countingSortInPlace := method(
copy(countingSort(min, max))
)
)
l := list(2, 3, -4, 5, 1)
l countingSortInPlace println # ==> list(-4, 1, 2, 3, 5)

8
Task/Sorting-algorithms-Counting-sort/J/sorting-algorithms-counting-sort-1.j Normal file
View file

@ -0,0 +1,8 @@
csort =: monad define
min =. <./y
cnt =. 0 $~ 1+(>./y)-min
for_a. y do.
cnt =. cnt >:@{`[`]}~ a-min
end.
cnt # min+i.#cnt
)

1
Task/Sorting-algorithms-Counting-sort/J/sorting-algorithms-counting-sort-2.j Normal file
View file

@ -0,0 +1 @@
csort=: (+/@(=/) # ]) >./ (] + 1 i.@+ -) <./

5
Task/Sorting-algorithms-Counting-sort/J/sorting-algorithms-counting-sort-3.j Normal file
View file

@ -0,0 +1,5 @@
] a =. _3 + 20 ?@$ 10
_2 _2 6 _1 1 6 _1 4 4 1 4 4 5 _3 5 3 0 _1 3 4
csort a
_3 _2 _2 _1 _1 _1 0 1 1 3 3 4 4 4 4 4 5 5 6 6

3
Task/Sorting-algorithms-Counting-sort/J/sorting-algorithms-counting-sort-4.j Normal file
View file

@ -0,0 +1,3 @@
csrt=:2 :0
(m+i.n-m) (+/@(=/)~ # [) ]
)

3
Task/Sorting-algorithms-Counting-sort/J/sorting-algorithms-counting-sort-5.j Normal file
View file

@ -0,0 +1,3 @@
csrt=:2 :0
(+/@(=/) # ])&(m+i.n-m)
)

2
Task/Sorting-algorithms-Counting-sort/J/sorting-algorithms-counting-sort-6.j Normal file
View file

@ -0,0 +1,2 @@
(_3 csrt 17) a
_3 _2 _2 _1 _1 _1 0 1 1 3 3 4 4 4 4 4 5 5 6 6

14
Task/Sorting-algorithms-Counting-sort/Java/sorting-algorithms-counting-sort.java Normal file
View file

@ -0,0 +1,14 @@
public static void countingSort(int[] array, int min, int max){
int[] count= new int[max - min + 1];
for(int number : array){
count[number - min]++;
}
int z= 0;
for(int i= min;i <= max;i++){
while(count[i - min] > 0){
array[z]= i;
z++;
count[i - min]--;
}
}
}

18
Task/Sorting-algorithms-Counting-sort/JavaScript/sorting-algorithms-counting-sort-1.js Normal file
View file

@ -0,0 +1,18 @@
var countSort = function(arr, min, max) {
var i, z = 0, count = [];
for (i = min; i <= max; i++) {
count[i] = 0;
}
for (i=0; i < arr.length; i++) {
count[arr[i]]++;
}
for (i = min; i <= max; i++) {
while (count[i]-- > 0) {
arr[z++] = i;
}
}
}

13
Task/Sorting-algorithms-Counting-sort/JavaScript/sorting-algorithms-counting-sort-2.js Normal file
View file

@ -0,0 +1,13 @@
// Line breaks are in HTML
var i, ages = [];
for (i = 0; i < 100; i++) {
ages.push(Math.floor(Math.random() * (141)));
}
countSort(ages, 0, 140);
for (i = 0; i < 100; i++) {
document.write(ages[i] + "<br />");
}

30
Task/Sorting-algorithms-Counting-sort/Lua/sorting-algorithms-counting-sort.lua Normal file
View file

@ -0,0 +1,30 @@
function CountingSort( f )
local min, max = math.min( unpack(f) ), math.max( unpack(f) )
local count = {}
for i = min, max do
count[i] = 0
end
for i = 1, #f do
count[ f[i] ] = count[ f[i] ] + 1
end
local z = 1
for i = min, max do
while count[i] > 0 do
f[z] = i
z = z + 1
count[i] = count[i] - 1
end
end
end
f = { 15, -3, 0, -1, 5, 4, 5, 20, -8 }
CountingSort( f )
for i in next, f do
print( f[i] )
end

36
Task/Sorting-algorithms-Counting-sort/M4/sorting-algorithms-counting-sort.m4 Normal file
View file

@ -0,0 +1,36 @@
divert(-1)
define(`randSeed',141592653)
define(`setRand',
`define(`randSeed',ifelse(eval($1<10000),1,`eval(20000-$1)',`$1'))')
define(`rand_t',`eval(randSeed^(randSeed>>13))')
define(`random',
`define(`randSeed',eval((rand_t^(rand_t<<18))&0x7fffffff))randSeed')
define(`set',`define(`$1[$2]',`$3')')
define(`get',`defn(`$1[$2]')')
define(`new',`set($1,size,0)')
define(`append',
`set($1,size,incr(get($1,size)))`'set($1,get($1,size),$2)')
define(`deck',
`new($1)for(`x',1,$2,
`append(`$1',eval(random%$3))')')
define(`for',
`ifelse($#,0,``$0'',
`ifelse(eval($2<=$3),1,
`pushdef(`$1',$2)$4`'popdef(`$1')$0(`$1',incr($2),$3,`$4')')')')
define(`show',
`for(`x',1,get($1,size),`get($1,x) ')')
define(`countingsort',
`for(`x',$2,$3,`set(count,x,0)')`'for(`x',1,get($1,size),
`set(count,get($1,x),incr(get(count,get($1,x))))')`'define(`z',
1)`'for(`x',$2,$3,
`for(`y',1,get(count,x),
`set($1,z,x)`'define(`z',incr(z))')')')
divert
deck(`a',10,100)
show(`a')
countingsort(`a',0,99)
show(`a')

22
Task/Sorting-algorithms-Counting-sort/MATLAB/sorting-algorithms-counting-sort-1.m Normal file
View file

@ -0,0 +1,22 @@
function list = countingSort(list)
minElem = min(list);
maxElem = max(list);
count = zeros((maxElem-minElem+1),1);
for number = list
count(number - minElem + 1) = count(number - minElem + 1) + 1;
end
z = 1;
for i = (minElem:maxElem)
while( count(i-minElem +1) > 0)
list(z) = i;
z = z+1;
count(i - minElem + 1) = count(i - minElem + 1) - 1;
end
end
end %countingSort

5
Task/Sorting-algorithms-Counting-sort/MATLAB/sorting-algorithms-counting-sort-2.m Normal file
View file

@ -0,0 +1,5 @@
>> countingSort([4 3 1 5 6 2])
ans =
1 2 3 4 5 6

12
Task/Sorting-algorithms-Counting-sort/Mathematica/sorting-algorithms-counting-sort.math Normal file
View file

@ -0,0 +1,12 @@
countingSort[list_] := Module[{minElem, maxElem, count, z, number},
minElem = Min[list]; maxElem = Max[list];
count = ConstantArray[0, (maxElem - minElem + 1)];
For[number = 1, number < Length[list], number++,
count[[number - minElem + 1]] = count[[number - minElem + 1]] + 1;] ;
z = 1;
For[i = minElem, i < maxElem, i++,
While[count[[i - minElem + 1]] > 0,
list[[z]] = i; z++;
count[[i - minElem + 1]] = count[[i - minElem + 1]] - 1;]
];
]

41
Task/Sorting-algorithms-Counting-sort/Modula-3/sorting-algorithms-counting-sort.mod3 Normal file
View file

@ -0,0 +1,41 @@
MODULE Counting EXPORTS Main;
IMPORT IO, Fmt;
VAR test := ARRAY [1..8] OF INTEGER {80, 10, 40, 60, 50, 30, 20, 70};
PROCEDURE Sort(VAR a: ARRAY OF INTEGER; min, max: INTEGER) =
VAR range := max - min + 1;
count := NEW(REF ARRAY OF INTEGER, range);
z := 0;
BEGIN
FOR i := FIRST(count^) TO LAST(count^) DO
count[i] := 0;
END;
FOR i := FIRST(a) TO LAST(a) DO
INC(count[a[i] - min]);
END;
FOR i := min TO max DO
WHILE (count[i - min] > 0) DO
a[z] := i;
INC(z);
DEC(count[i - min]);
END;
END;
END Sort;
BEGIN
IO.Put("Unsorted: ");
FOR i := FIRST(test) TO LAST(test) DO
IO.Put(Fmt.Int(test[i]) & " ");
END;
IO.Put("\n");
Sort(test, 10, 80);
IO.Put("Sorted: ");
FOR i := FIRST(test) TO LAST(test) DO
IO.Put(Fmt.Int(test[i]) & " ");
END;
IO.Put("\n");
END Counting.

69
Task/Sorting-algorithms-Counting-sort/NetRexx/sorting-algorithms-counting-sort.netrexx Normal file
View file

@ -0,0 +1,69 @@
/* NetRexx */
options replace format comments java crossref savelog symbols binary
import java.util.List
icounts = [int -
1, 3, 6, 2, 7, 13, 20, 12, 21, 11 -
, 22, 10, 23, 9, 24, 8, 25, 43, 62, 42 -
, 63, 41, 18, 42, 17, 43, 16, 44, 15, 45 -
, 14, 46, 79, 113, 78, 114, 77, 39, 78, 38 -
]
scounts = int[icounts.length]
System.arraycopy(icounts, 0, scounts, 0, icounts.length)
lists = [ -
icounts -
, countingSort(scounts) -
]
loop ln = 0 to lists.length - 1
cl = lists[ln]
rep = Rexx('')
loop ct = 0 to cl.length - 1
rep = rep cl[ct]
end ct
say '['rep.strip.changestr(' ', ',')']'
end ln
return
method getMin(array = int[]) public constant binary returns int
amin = Integer.MAX_VALUE
loop x_ = 0 to array.length - 1
if array[x_] < amin then
amin = array[x_]
end x_
return amin
method getMax(array = int[]) public constant binary returns int
amax = Integer.MIN_VALUE
loop x_ = 0 to array.length - 1
if array[x_] > amax then
amax = array[x_]
end x_
return amax
method countingSort(array = int[], amin = getMin(array), amax = getMax(array)) public constant binary returns int[]
count = int[amax - amin + 1]
loop nr = 0 to array.length - 1
numbr = array[nr]
count[numbr - amin] = count[numbr - amin] + 1
end nr
z_ = 0
loop i_ = amin to amax
loop label count while count[i_ - amin] > 0
array[z_] = i_
z_ = z_ + 1
count[i_ - amin] = count[i_ - amin] - 1
end count
end i_
return array

4
Task/Sorting-algorithms-Counting-sort/OCaml/sorting-algorithms-counting-sort.ocaml Normal file
View file

@ -0,0 +1,4 @@
let counting_sort_array arr lo hi =
let count = Array.make (hi-lo+1) 0 in
Array.iter (fun i -> count.(i-lo) <- count.(i-lo) + 1) arr;
Array.concat (Array.to_list (Array.mapi (fun i x -> Array.make x (lo+i)) count))

30
Task/Sorting-algorithms-Counting-sort/Objeck/sorting-algorithms-counting-sort.objeck Normal file
View file

@ -0,0 +1,30 @@
bundle Default {
class Cocktail {
function : Main(args : String[]) ~ Nil {
values := [9, 7, 10, 2, 9, 7, 4, 3, 10, 2, 7, 10];
CountingSort(values, 2, 10);
each(i : values) {
values[i]->PrintLine();
};
}
function : CountingSort(array : Int[], min : Int, max : Int) ~ Nil {
count := Int->New[max - min + 1];
each(i : array) {
number := array[i];
v := count[number - min];
count[number - min] := v + 1;
};
z := 0;
for(i := min; i <= max; i += 1;) {
while(count[i - min] > 0) {
array[z] := i;
z += 1;
v := count[i - min]
count[i - min] := v - 1;
};
};
}
}
}

10
Task/Sorting-algorithms-Counting-sort/Octave/sorting-algorithms-counting-sort-1.octave Normal file
View file

@ -0,0 +1,10 @@
function r = counting_sort(arr, minval, maxval)
r = arr;
z = 1;
for i = minval:maxval
cnt = sum(arr == i);
while( cnt-- > 0 )
r(z++) = i;
endwhile
endfor
endfunction

3
Task/Sorting-algorithms-Counting-sort/Octave/sorting-algorithms-counting-sort-2.octave Normal file
View file

@ -0,0 +1,3 @@
ages = unidrnd(140, 100, 1);
sorted = counting_sort(ages, 0, 140);
disp(sorted);

24
Task/Sorting-algorithms-Counting-sort/Oz/sorting-algorithms-counting-sort-1.oz Normal file
View file

@ -0,0 +1,24 @@
declare
proc {CountingSort Arr Min Max}
Count = {Array.new Min Max 0}
Z = {NewCell {Array.low Arr}}
in
%% fill frequency array
for J in {Array.low Arr}..{Array.high Arr} do
Number = Arr.J
in
Count.Number := Count.Number + 1
end
%% recreate array from frequencies
for I in Min..Max do
for C in 1..Count.I do
Arr.(@Z) := I
Z := @Z + 1
end
end
end
A = {Tuple.toArray unit(3 1 4 1 5 9 2 6 5)}
in
{CountingSort A 1 9}
{Show {Array.toRecord unit A}}

21
Task/Sorting-algorithms-Counting-sort/Oz/sorting-algorithms-counting-sort-2.oz Normal file
View file

@ -0,0 +1,21 @@
declare
fun {CountingSort Xs}
Count = {Dictionary.new}
in
for X in Xs do
Count.X := {CondSelect Count X 0} + 1
end
{Concat {Map {Dictionary.entries Count} Repeat}}
end
fun {Repeat Val#Count}
if Count == 0 then nil
else Val|{Repeat Val#Count-1}
end
end
fun {Concat Xs}
{FoldR Xs Append nil}
end
in
{Show {CountingSort [3 1 4 1 5 9 2 6 5]}}

7
Task/Sorting-algorithms-Counting-sort/PARI-GP/sorting-algorithms-counting-sort.pari Normal file
View file

@ -0,0 +1,7 @@
countingSort(v,mn,mx)={
my(u=vector(#v),i=0);
for(n=mn,mx,
for(j=1,#v,if(v[j]==n,u[i++]=n))
);
u
};

21
Task/Sorting-algorithms-Counting-sort/PHP/sorting-algorithms-counting-sort-1.php Normal file
View file

@ -0,0 +1,21 @@
<?php
function counting_sort($arr, $min, $max)
{
$count = array();
for($i = $min; $i <= $max; $i++)
{
$count[$i] = 0;
}
foreach($arr as $number)
{
$count[$number]++;
}
$z = 0;
for($i = $min; $i <= $max; $i++) {
while( $count[$i]-- > 0 ) {
$arr[$z++] = $i;
}
}
}

10
Task/Sorting-algorithms-Counting-sort/PHP/sorting-algorithms-counting-sort-2.php Normal file
View file

@ -0,0 +1,10 @@
$ages = array();
for($i=0; $i < 100; $i++) {
array_push($ages, rand(0, 140));
}
counting_sort(&$ages, 0, 140);
for($i=0; $i < 100; $i++) {
echo $ages[$i] . "\n";
}
?>

29
Task/Sorting-algorithms-Counting-sort/PL-I/sorting-algorithms-counting-sort.pli Normal file
View file

@ -0,0 +1,29 @@
count_sort: procedure (A);
declare A(*) fixed;
declare (min, max) fixed;
declare i fixed binary;
max, min = A(lbound(A,1));
do i = 1 to hbound(A,1);
if max < A(i) then max = A(i);
if min > A(i) then min = A(i);
end;
begin;
declare t(min:max) fixed;
declare (i, j, k) fixed binary (31);
t = 0;
do i = 1 to hbound(A,1);
j = A(i);
t(j) = t(j) + 1;
end;
k = lbound(A,1);
do i = min to max;
if t(i) ^= 0 then
do j = 1 to t(i);
A(k) = i;
k = k + 1;
end;
end;
end;
end count_sort;

32
Task/Sorting-algorithms-Counting-sort/Pascal/sorting-algorithms-counting-sort.pascal Normal file
View file

@ -0,0 +1,32 @@
program CountingSort;
procedure counting_sort(var arr : Array of Integer; n, min, max : Integer);
var
count : Array of Integer;
i, j, z : Integer;
begin
SetLength(count, max-min);
for i := 0 to (max-min) do
count[i] := 0;
for i := 0 to (n-1) do
count[ arr[i] - min ] := count[ arr[i] - min ] + 1;
z := 0;
for i := min to max do
for j := 0 to (count[i - min] - 1) do begin
arr[z] := i;
z := z + 1
end
end;
var
ages : Array[0..99] of Integer;
i : Integer;
begin
{ testing }
for i := 0 to 99 do
ages[i] := 139 - i;
counting_sort(ages, 100, 0, 140);
for i := 0 to 99 do
writeln(ages[i]);
end.

5
Task/Sorting-algorithms-Counting-sort/Perl-6/sorting-algorithms-counting-sort-1.pl6 Normal file
View file

@ -0,0 +1,5 @@
sub counting-sort (@ints) {
my $off = @ints.min;
(my @counts)[$_ - $off]++ for @ints;
@counts.kv.map: { ($^k + $off) xx ($^v // 0) }
}

3
Task/Sorting-algorithms-Counting-sort/Perl-6/sorting-algorithms-counting-sort-2.pl6 Normal file
View file

@ -0,0 +1,3 @@
constant @age-range = 2 .. 102;
my @ages = @age-range.roll(50);
say @ages.&counting-sort ~~ @ages.sort ?? 'ok' !! 'not ok';

13
Task/Sorting-algorithms-Counting-sort/Perl/sorting-algorithms-counting-sort-1.pl Normal file
View file

@ -0,0 +1,13 @@
#! /usr/bin/perl
use strict;
sub counting_sort
{
my ($a, $min, $max) = @_;
my @cnt = (0) x ($max - $min + 1);
$cnt[$_ - $min]++ foreach @$a;
my $i = $min;
@$a = map {($i++) x $_} @cnt;
}

4
Task/Sorting-algorithms-Counting-sort/Perl/sorting-algorithms-counting-sort-2.pl Normal file
View file

@ -0,0 +1,4 @@
my @ages = map {int(rand(140))} 1 .. 100;
counting_sort(\@ages, 0, 140);
print join("\n", @ages), "\n";

10
Task/Sorting-algorithms-Counting-sort/PicoLisp/sorting-algorithms-counting-sort.l Normal file
View file

@ -0,0 +1,10 @@
(de countingSort (Lst Min Max)
(let Count (need (- Max Min -1) 0)
(for N Lst
(inc (nth Count (- N Min -1))) )
(make
(map
'((C I)
(do (car C) (link (car I))) )
Count
(range Min Max) ) ) ) )

16
Task/Sorting-algorithms-Counting-sort/PureBasic/sorting-algorithms-counting-sort.purebasic Normal file
View file

@ -0,0 +1,16 @@
Procedure Counting_sort(Array data_array(1), min, max)
Define i, j
Dim c(max - min)
For i = 0 To ArraySize(data_array())
c(data_array(i) - min) + 1
Next
For i = 0 To ArraySize(c())
While c(i)
data_array(j) = i + min
j + 1
c(i) - 1
Wend
Next
EndProcedure

14
Task/Sorting-algorithms-Counting-sort/Python/sorting-algorithms-counting-sort-1.py Normal file
View file

@ -0,0 +1,14 @@
>>> from collections import defaultdict
>>> def countingSort(array, mn, mx):
count = defaultdict(int)
for i in array:
count[i] += 1
result = []
for j in range(mn,mx+1):
result += [j]* count[j]
return result
>>> data = [9, 7, 10, 2, 9, 7, 4, 3, 10, 2, 7, 10, 2, 1, 3, 8, 7, 3, 9, 5, 8, 5, 1, 6, 3, 7, 5, 4, 6, 9, 9, 6, 6, 10, 2, 4, 5, 2, 8, 2, 2, 5, 2, 9, 3, 3, 5, 7, 8, 4]
>>> mini,maxi = 1,10
>>> countingSort(data, mini, maxi) == sorted(data)
True

7
Task/Sorting-algorithms-Counting-sort/Python/sorting-algorithms-counting-sort-2.py Normal file
View file

@ -0,0 +1,7 @@
def countingSort(a, min, max):
cnt = [0] * (max - min + 1)
for x in a:
cnt[x - min] += 1
return [x for x, n in enumerate(cnt, start=min)
for i in xrange(n)]

20
Task/Sorting-algorithms-Counting-sort/R/sorting-algorithms-counting-sort.r Normal file
View file

@ -0,0 +1,20 @@
counting_sort <- function(arr, minval, maxval) {
r <- arr
z <- 1
for(i in minval:maxval) {
cnt = sum(arr == i)
while(cnt > 0) {
r[z] = i
z <- z + 1
cnt <- cnt - 1
}
}
r
}
# 140+1 instead of 140, since random numbers generated
# by runif are always less than the given maximum;
# floor(a number at most 140.9999...) is 140
ages <- floor(runif(100, 0, 140+1))
sorted <- counting_sort(ages, 0, 140)
print(sorted)

41
Task/Sorting-algorithms-Counting-sort/REXX/sorting-algorithms-counting-sort.rexx Normal file
View file

@ -0,0 +1,41 @@
/*REXX program sorts an array using the count-sort method. */
call gen@ /*generate the array elements. */
call show@ 'before sort' /*show the before array elements.*/
call countSort N /*sort N entries of the @. array.*/
call show@ ' after sort' /*show the after array elements.*/
exit /*stick a fork in it, we're done.*/
/*──────────────────────────────────countSort subroutine────────────────*/
countSort: procedure expose @.; parse arg N; h=@.1; L=h
do i=2 to N; L=min(L,@.i); h=max(h,@.i)
end /*i*/
_.=0; do j=1 for N; x=@.j; _.x=_.x+1
end /*j*/
#=1; do k=L to h; if _.k\==0 then do #=# for _.k
@.#=k
end /*#*/
end /*k*/
return
/*──────────────────────────────────GEN@ subroutine─────────────────────*/
gen@: @.= /*assign 40 Recaman numbers. */
@.1 = 1 ; @.9 = 21 ; @.17= 25 ; @.25= 17 ; @.33= 79
@.2 = 3 ; @.10= 11 ; @.18= 43 ; @.26= 43 ; @.34= 113
@.3 = 6 ; @.11= 22 ; @.19= 62 ; @.27= 16 ; @.35= 78
@.4 = 2 ; @.12= 10 ; @.20= 42 ; @.28= 44 ; @.36= 114
@.5 = 7 ; @.13= 23 ; @.21= 63 ; @.29= 15 ; @.37= 77
@.6 = 13 ; @.14= 9 ; @.22= 41 ; @.30= 45 ; @.38= 39
@.7 = 20 ; @.15= 24 ; @.23= 18 ; @.31= 14 ; @.39= 78
@.8 = 12 ; @.16= 8 ; @.24= 42 ; @.32= 46 ; @.40= 38
do N=1 while @.N\==''; end /*determine the number of entries*/
N=N-1 /*adjust highItem slightly. */
return
/*──────────────────────────────────SHOW@ subroutine────────────────────*/
show@: widthH=length(N) /*max width of any element number*/
pad=left('',9); do s=1 for N
say pad 'element' right(s,widthH) arg(1)": " @.s
end /*s*/
say copies('─',40) /*show a pretty separator line. */
return

24
Task/Sorting-algorithms-Counting-sort/Ruby/sorting-algorithms-counting-sort.rb Normal file
View file

@ -0,0 +1,24 @@
class Array
def countingsort!
do_countingsort!(min, max)
end
protected
def do_countingsort!(min, max)
count = Array.new(max - min + 1, 0)
each {|number| count[number - min] += 1}
z = 0
min.upto(max) do |i|
while count[i - min] > 0
self[z] = i
z += 1
count[i - min] -= 1
end
end
self
end
end
ary = [9,7,10,2,9,7,4,3,10,2,7,10,2,1,3,8,7,3,9,5,8,5,1,6,3,7,5,4,6,9,9,6,6,10,2,4,5,2,8,2,2,5,2,9,3,3,5,7,8,4]
ary.countingsort!.join(",")
# => "1,1,2,2,2,2,2,2,2,2,3,3,3,3,3,3,4,4,4,4,5,5,5,5,5,5,6,6,6,6,7,7,7,7,7,7,8,8,8,8,9,9,9,9,9,9,10,10,10,10"

7
Task/Sorting-algorithms-Counting-sort/Scala/sorting-algorithms-counting-sort.scala Normal file
View file

@ -0,0 +1,7 @@
def countSort(input: List[Int], min: Int, max: Int): List[Int] =
input.foldLeft(Array.fill(max - min + 1)(0)) { (arr, n) =>
arr(n - min) += 1
arr
}.zipWithIndex.foldLeft(List[Int]()) {
case (lst, (cnt, ndx)) => List.fill(cnt)(ndx + min) ::: lst
}.reverse

16
Task/Sorting-algorithms-Counting-sort/Slate/sorting-algorithms-counting-sort.slate Normal file
View file

@ -0,0 +1,16 @@
s@(Sequence traits) countingSort &min: min &max: max
[| counts index |
min `defaultsTo: (s reduce: #min: `er).
max `defaultsTo: (s reduce: #max: `er).
counts: ((0 to: max - min) project: [| :_ | 0]).
s do: [| :value | counts at: value - min infect: [| :count | count + 1]].
index: 0.
min to: max do: [| :value |
[(counts at: value - min) isPositive]
whileTrue:
[s at: index put: value.
index: index + 1.
counts at: value - min infect: [| :val | val - 1]]
].
s
].

17
Task/Sorting-algorithms-Counting-sort/Smalltalk/sorting-algorithms-counting-sort-1.st Normal file
View file

@ -0,0 +1,17 @@
OrderedCollection extend [
countingSortWithMin: min andMax: max [
|oc z|
oc := OrderedCollection new.
1 to: (max - min + 1) do: [ :n| oc add: 0 ].
self do: [ :v |
oc at: (v - min + 1) put: ( (oc at: (v - min + 1)) + 1)
].
z := 1.
min to: max do: [ :i |
1 to: (oc at: (i - min + 1)) do: [ :k |
self at: z put: i.
z := z + 1.
]
]
]
].

10
Task/Sorting-algorithms-Counting-sort/Smalltalk/sorting-algorithms-counting-sort-2.st Normal file
View file

@ -0,0 +1,10 @@
|ages|
ages := OrderedCollection new.
1 to: 100 do: [ :n |
ages add: (Random between: 0 and: 140)
].
ages countingSortWithMin: 0 andMax: 140.
ages printNl.

41
Task/Sorting-algorithms-Counting-sort/Tcl/sorting-algorithms-counting-sort.tcl Normal file
View file

@ -0,0 +1,41 @@
proc countingsort {a {min ""} {max ""}} {
# If either of min or max weren't given, compute them now
if {$min eq ""} {
set min [::tcl::mathfunc::min $a]
}
if {$max eq ""} {
set max [::tcl::mathfunc::max $a]
}
# Make the "array" of counters
set count [lrepeat [expr {$max - $min + 1}] 0]
# Count the values in the input list
foreach n $a {
set idx [expr {$n - $min}]
lincr count $idx
}
# Build the output list
set z 0
for {set i $min} {$i <= $max} {incr i} {
set idx [expr {$i - $min}]
while {[lindex $count $idx] > 0} {
lset a $z $i
incr z
lincr count $idx -1
}
}
return $a
}
# Helper that will increment an existing element of a list
proc lincr {listname idx {value 1}} {
upvar 1 $listname list
lset list $idx [expr {[lindex $list $idx] + $value}]
}
# Demo code
for {set i 0} {$i < 50} {incr i} {lappend a [expr {1+ int(rand()*10)}]}
puts $a
puts [countingsort $a]

42
Task/Sorting-algorithms-Counting-sort/VBScript/sorting-algorithms-counting-sort-1.vbscript Normal file
View file

@ -0,0 +1,42 @@
function findMax( a )
dim num
dim max
max = 0
for each num in a
if num > max then max = num
next
findMax = max
end function
function findMin( a )
dim num
dim min
min = 0
for each num in a
if num < min then min = num
next
findMin = min
end function
'the function returns the sorted array, but the fact is that VBScript passes the array by reference anyway
function countingSort( a )
dim count()
dim min, max
min = findMin(a)
max = findMax(a)
redim count( max - min + 1 )
dim i
dim z
for i = 0 to ubound( a )
count( a(i) - min ) = count( a( i ) - min ) + 1
next
z = 0
for i = min to max
while count( i - min) > 0
a(z) = i
z = z + 1
count( i - min ) = count( i - min ) - 1
wend
next
countingSort = a
end function

5
Task/Sorting-algorithms-Counting-sort/VBScript/sorting-algorithms-counting-sort-2.vbscript Normal file
View file

@ -0,0 +1,5 @@
dim a
a = array(300, 1, -2, 3, -4, 5, -6, 7, -8, 100, 11 )
wscript.echo join( a, ", " )
countingSort a
wscript.echo join( a, ", " )

23
Task/Sorting-algorithms-Counting-sort/XPL0/sorting-algorithms-counting-sort.xpl0 Normal file
View file

@ -0,0 +1,23 @@
include c:\cxpl\codes;
proc CountingSort(Array, Min, Max, Size); \Sort Array
int Array, Min, Max, Size; \minimum, maximum values, number of elements
int Count, I, Z;
[Count:= Reserve((Max-Min+1)*4); \Reserve Count with 4 bytes per integer
for I:= 0 to Max-Min do Count(I):= 0; \initialize Count with 0
for I:= 0 to Size-1 do \for each number count its occurrences
Count(Array(I)-Min):= Count(Array(I)-Min) + 1;
Z:= 0;
for I:= Min to Max do
while Count(I-Min) > 0 do
[Array(Z):= I;
Z:= Z+1;
Count(I-Min):= Count(I-Min) - 1;
];
];
int A, I;
[A:= [3, 1, 4, 1, -5, 9, 2, 6, 5, 4];
CountingSort(A, -5, 9, 10);
for I:= 0 to 10-1 do [IntOut(0, A(I)); ChOut(0, ^ )];
]