@kenbitanga

# factorial def fac(n): return factorial(n, 1) def factorial(n, acc): if n < 0: return None if n == 0: return acc return factorial(n-1, acc*n) # fibonacci

package main import ( "fmt" "reflect" ) func factors(n int) []int { result := []int{} for i := 1; i <= n; i++ {

package main import "fmt" func sum_iter(nums []int) int { result := 0 for _, v := range nums { result += v } return result

defmodule Recursive do # sum def sum(list) do sum(list, 0) end def sum([], acc) do acc end

def qsort(li, reverse=False): if len(li) == 0: return li p, *xs = li left = [x for x in xs if x <= p] right = [x for x in xs if x > p] if reverse: return [*qsort(right, reverse), p, *qsort(left, reverse)] return [*qsort(left, r

def partition(f, li): if len(li) == 0: return ([], []) x, *xs = li ys, zs = partition(f, xs) if f(x): return ([x, *ys], zs) return (ys, [x, *zs]) def qsort(li, reverse=False): if len(li) == 0: return li p, *xs = li

def factors(n): return [x for x in range(1, n+1) if n % x == 0] def prime(n): return factors(n) == [1, n] def nprimes(n, i=1, c=0, r=[]): if c >= n: return r if prime(i): return nprimes(n, i+1, c+1, [*r, i]) return nprimes(n, i+1, c, [

def factors(n): return [x for x in range(1, n+1) if n % x == 0] def prime(n): return factors(n) == [1, n] n = 30 primes = [x for x in range(1, n+1) if prime(x)] print(primes)

def partition(f, li): if len(li) == 0: return ([], []) x, *xs = li ys, zs = partition(f, xs) if f(x): return ([x, *ys], zs) return (ys, [x, *zs]) def qsort(li, reverse=False): if len(li) == 0: return li p, *xs = li

def partition(f, arr) return [[], []] if arr.empty? x, *xs = arr ys, zs = partition(f, xs) return [[x, *ys], zs] if f[x] [ys, [x, *zs]] end def qsort(arr) return arr if arr.empty?

let rec partition f = function | [] -> [], [] | x::xs -> let ys, zs = partition f xs in if f x then x::ys, zs else ys, x::zs let rec qsort = function | [] -> []

partition1 _ [] = ([], []) partition1 f (x:xs) = let (ys, zs) = partition1 f xs in if f x then (x:ys, zs) else (ys, x:zs) partition2 _ [] = ([], []) partition2 f (x:xs) | f x = (x:ys, zs)

def reverse_list(li): if len(li) == 0: return li last, init = li[-1], li[:-1] return [last, *reverse_list(init)] li = [1,2,3] print(li) print(reverse_list(li))

let rec partition f = function | [] -> [], [] | x::xs -> let ys, zs = partition f xs if f x then x::ys, zs else ys, x::zs let rec qsort = function | [] -> []

let rec qsort = function | [] -> [] | x :: xs -> let smaller = List.filter (fun a -> a <= x) xs let larger = [for a in xs do if a > x then yield a] qsort smaller @ [x] @ qsort larger let unsorted = [5; 2; 1; 4; 3] let sorte

qsort li | null li = [] | otherwise = qsort lt ++ [p] ++ qsort gt where (p:xs) = li lt = [x | x <- xs, x <= p] gt = [x | x <- xs, x > p] qsort0 [] = [] qsort0 (p:xs) = qsort0 lt ++ [p] ++ qsort0 gt

qsort [] = [] qsort (p:xs) = qsort lt ++ [p] ++ qsort gt where (lt, gt) = partition ((>) p) xs partition1 _ [] = ([], []) partition1 f (x:xs) = let (ys, zs) = partition1 f xs in if f x then (x:ys, zs) else (ys, x:zs)

def sigma(z): return z * (z+1) // 2 def sigma_range(a, z): return (z * (z+1) // 2) - ((a-1) * a // 2) print(sigma(5)) print(sigma_range(1, 5))

let rec partition f = function | [] -> ([], []) | x::xs -> let (ys, zs) = partition f xs match f x with | true -> (x::ys, zs) | false -> (ys, x::zs) [1..8] |> partition (fun x -> x%2 = 1) |> printfn "%A"

let rec partition f = function | [] -> ([], []) | x::xs -> let (ys, zs) = partition f xs if f x then (x::ys, zs) else (ys, x::zs) [1..8] |> partition (fun x -> x%2 = 1) |> printfn "%A"