:GJS1M 67dcbdbce4a0b67c4b48e86a6ae29205a95e4b83024a9d947213d1231800e8d9
:65 91b4ec355e207aaf5320267663d64c87
:1309339816 1309375731 >>8 <-- that's cool and all, but check 'em
// Ruby
def quicksort(list, p, r)
if p < r then
q = partition(list, p, r)
quicksort(list, p, q-1)
quicksort(list, q+1, r)
end
end
def partition(list, p, r)
pivot = list[r]
i = p - 1
p.upto(r-1) do |j|
if list[j] <= pivot
i = i+1
list[i], list[j] = list[j],list[i]
end
end
list[i+1],list[r] = list[r],list[i+1]
return i + 1
// OCaml
let partition p l =
let rec part yes no = function
| [] -> (rev yes, rev no)
| x :: l -> if p x then part (x :: yes) no l else part yes (x :: no) l in
part [] [] l
let rec quicksort = function
| (x::xs) ->
let (lower,higher) = List.partition (fun i -> i < x) xs in
quicksort1 lower @ [x] @ quicksort1 higher
| [] -> []
;;
Name:
Anonymous2011-06-29 15:42
Check out my dubs.
Name:
Anonymous2011-06-29 16:15
>>7 for any X, any sequent whose conclusion is X : zero-or-one (meaning X is of the type zero-or-one) is provable if the side-condition is satisfied (namely X is an element of the set {0, 1}).
Why is it SO complicated? And the type declarations look monstrous. I miss plain and fast [code]Uint32[/c].
:GJS1M 67dcbdbce4a0b67c4b48e86a6ae29205a95e4b83024a9d947213d1231800e8d9
:66 f07e7b14db2b11dafd313abe61202f9b
:1309339816 1309380526 >>18 <-- that's cool and all, but check 'em
>>23
I have checked my family tree up to my grand-grandparents and I most certainly have no Jewish ancestors. As a Christian, I tell you: fuck off and die you piece of shit lisper faggot.
>>28
No, there are more than one anti-semite around here. The “infinite set theory in lisp” guy is Russian, apparently a peasant. He writes in English well enough so I give him points for that.
>>32
Nothing. These jews just fear the loss of power.
For example, african americans remain underrepresented in higher education because jews don't want them to gain power. Same with high percent of jews in higher education relatively to whole population.
>>40 http://en.wikipedia.org/wiki/Algebraic_types In set theory the equivalent of an algebraic data type is a disjoint union – a set whose elements are pairs consisting of a tag (equivalent to a constructor) and an object of a type corresponding to the tag (equivalent to the constructor arguments).