text
stringlengths 0
601k
|
|---|
let evens (max : int) : int list = let addtwo (num : int) = (num, num + 2) in let isNum (number : int) = number == max || number > max in unfold (addtwo) (isNum) 0 ;; |
let fib (max : int) : int list = let firstTwo (a, b) = (b, (b, a + b)) in let isNum (a, b) = b >= max in unfold (firstTwo) (isNum) (0, 1) ;; |
let pascal (max : int) : int list list = let row (num : int list) = let newList = List.rev (List.tl (List.append num [0])) in (num, List.append (List.map2 (+) num newList) [1]) in let isNum (a : int list) = List.length a > max in unfold (row) (isNum) [1] ;; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = let isAllergy all = List.exists (fun x -> x == all) allergens in List.filter (fun (f : cupcake) -> let Cupcake (a, b, c, d) = f in List.for_all (fun x -> (isAllergy x) == false) d) cupcakes;; |
let string_explode (s : string) : char list = tabulate (String.get s) (String.length s);; |
let string_implode (l : char list) : string = List.fold_left (^) "" (List.map Char.escaped l);; |
let evens (max : int) : int list = unfold (fun b -> (b, b+2)) ((<=) max) 0;; |
let fib (max : int) : int list = unfold (fun (a, b) -> (a, (b, a+b))) (fun (a, _) -> max <= a) (1, 1);; |
let pascal (max : int) : int list list = unfold (fun prev -> ( prev, List.map2 (+) (0 :: prev) (prev @ [0]))) (fun ls -> max < List.length ls) [1];; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = List.filter (fun (Cupcake (_, _, _, ingredients)) -> List.for_all (fun ing -> not (List.exists ((=) ing) allergens)) ingredients) cupcakes;; |
let string_explode (s : string) : char list = tabulate (String.get s) (String.length s);; |
let string_implode (l : char list) : string = let s_list = List.map Char.escaped l in List.fold_left (^) "" s_list;; |
let evens (max : int) : int list = unfold (fun b -> (b, b+2)) ((<=) max) 0;; |
let fib (max : int) : int list = unfold (fun b -> (fst b,(snd b, fst b + snd b))) (fun b -> max <= fst b) (1,1);; |
let pascal (max : int) : int list list = unfold (fun b -> (b, List.map2 (+) (0 :: b) (b @ [0]) )) (fun b -> max < (List.length b)) [1];; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = let getIngs = fun (Cupcake (_,_,_,ls)) -> ls in let allergenFree = fun cupcake -> fun allergen -> not (List.exists ((=) allergen) (getIngs cupcake)) in let isSafe = fun allergens -> fun cupcake -> List.for_all (allergenFree cupcake) allergens in List.filter (isSafe allergens) cupcakes;; |
let string_explode (s : string) : char list = tabulate (String.get s) (String.length s);; |
let string_implode (l : char list) : string = List.fold_left (^) "" (List.map Char.escaped l);; |
let evens (max : int) : int list = unfold (fun b -> (b, b+2)) (fun b -> max <= b) 0;; |
let fib (max : int) : int list = unfold (fun (b, b') -> (b, (b', b'+b))) (fun (b, b') -> max <= b) (1, 1);; |
let pascal (max : int) : int list list = unfold (fun b -> (b, List.map2 (+) ([0] @ b) (b @ [0]))) (fun b -> max <= List.length b - 1) [1];; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = List.filter (function Cupcake (_,_,_, ingredients) -> List.for_all (fun al -> not(List.exists ((=) al) ingredients)) allergens) cupcakes;; |
let string_explode (s : string) : char list = let l = String.length s in tabulate (fun x -> String.get s x) l;; |
let string_implode (l : char list) : string = let charlist = List.map (fun x -> Char.escaped x) l in String.concat "" charlist;; |
let evens (max : int) : int list = unfold (fun b -> (b, b+2)) (fun b -> max <= b) 0;; |
let fib (max : int) : int list = let l = unfold (fun (prev_b, b) -> (prev_b, b), (b, prev_b + b)) (fun b -> max <= snd b) (0,1) in List.map (fun x -> snd x) l;; |
let pascal (max : int) : int list list = let next_row row = List.map2 (+) ([0] @ row) (row @ [0]) in unfold (fun b -> b, next_row b) (fun b -> max < List.length b) [1];; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = List.filter (function Cupcake(_,_,_,ingredients) -> List.for_all(fun ing -> not(List.exists ((=) ing) ingredients)) allergens) cupcakes;; |
let string_explode (s : string) : char list = let length = String.length s in tabulate (String.get s) length ;; |
let string_implode (l : char list) : string = let strlist = List.map Char.escaped l in let tmp = List.fold_right (^) strlist " " in String.sub tmp 0 ((String.length tmp) - 1) ;; |
let evens (max : int) : int list = unfold (fun b -> (b, b+2)) ((<=) max) 0 ;; |
let fib (max : int) : int list = let rec fib_aux (n : int) (a : int) (b : int) : int = if n = 1 then b else if n = 0 then 1 else fib_aux (n - 1) b (a +b) in unfold (fun b -> (fib_aux b 1 1, (b+1))) (fun b -> max <= fib_aux b 1 1) 0 ;; |
let pascal (max : int) : int list list = let row (l : int list) = List.map2 (+) (List.rev (0 :: l)) (0 :: l) in let rows m = unfold (fun b -> (b, row b)) (fun b -> (m + 2) < (List.length b)) [0; 1; 0] in let rem l = let ls = List.tl l in let ls = List.rev ls in List.tl ls in List.map rem (rows max) ;; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = let not_eq ing1 ing2 : bool = not ((compare ing1 ing2) = 0) in let no_all (allergens : ingredient list) (rlst : bool list) (cup : cupcake): bool = let ilst cup = let Cupcake (p, w, c, i) = cup in i in let conc (ing : ingredient list) (all : ingredient) = (List.for_all (not_eq all) ing) in let all = List.map (conc (ilst cup)) (allergens) in not (List.exists ((=) false) all) in List.filter (no_all allergens []) cupcakes ;; |
let string_explode (s : string) : char list = let f = String.get s in tabulate f (String.length s);; |
let string_implode (l : char list) : string = String.concat "" (List.map (Char.escaped) l);; |
let evens (max : int) : int list = unfold (fun b -> (b, b+2)) ((<=) max) 0;; |
let fib (max : int) : int list = let l = unfold (fun (x,y) -> ((x,y),(y,x+y))) (fun (x,y) -> max <= x) (1,1) in (List.map (fst) l);; |
let pascal (max : int) : int list list = unfold (fun x->(x,(List.map2 (+) (List.append x [0]) (List.append [0] x)))) (fun x-> max< List.length x) [1];; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = List.filter (function Cupcake (_,_,_,ingredients) -> List.for_all (fun x -> not(List.exists ((=) x) allergens)) ingredients) cupcakes ;; |
let string_explode (s : string) : char list = tabulate (String.get s) (String.length s);; |
let string_implode (l : char list) : string = List.fold_right (fun x -> (^) (Char.escaped x)) l "";; |
let evens (max : int) : int list = unfold (fun b -> (b, b+2)) (fun b -> b >= max) 0;; |
let fib (max : int) : int list = unfold (fun (f1,f2) -> (f1, (f2,f2+f1)) ) (fun (f1,f2)-> f1 >= max) (1,1) let rec make_zero_list (i : int) (acc : int list) : int list = if i < 0 then acc else make_zero_list (i-1) (0::acc);; |
let pascal (max : int) : int list list = unfold (fun (num, lst) -> let lst1 = 0::lst in let lst2 = 1::(make_zero_list num []) in let next_lst = List.map2 (+) lst1 lst2 in (next_lst, (num+1,List.map2 (+) (List.append lst [0]) next_lst)) ) (fun (num,lst) -> (num+2) > max) (-1,[]);; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = List.filter (fun x -> let Cupcake (_,_,_,ingredients) = x in List.for_all (fun y -> not (List.exists (fun z -> z = y) allergens)) ingredients) cupcakes;; |
let string_explode (s : string) : char list = tabulate (function n -> String.get s n) (String.length s) ;; |
let string_implode (l : char list) : string = let l1 = List.map (function c -> Char.escaped c) l in List.fold_left (function x -> function y -> x ^ y) "" l1 ;; |
let evens (max : int) : int list = unfold (fun b -> (b, b+2)) ((<=) max) 0 ;; |
let fib (max : int) : int list = if (max = 0) then [] else if (max = 1) then [] else let fib_list = unfold (fun (x,y) -> (x+y, (y, x+y))) (fun(x,y) -> max <= x+y) (1,1) in 1 :: 1 :: fib_list ;; |
let pascal (max : int) : int list list = if (max = 0) then [] else if (max = 1) then [1] :: [] else let pascal_rows = unfold (fun l -> ((List.map2 (+) (0 :: l) (l @ [0])), (List.map2 (+) (0 :: l) (l @ [0])))) (fun l -> max <= List.length (l)) [1;1] in [1] :: [1;1] :: pascal_rows ;; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = let contains_no_allergen (l1 : ingredient list) (l2 : ingredient list) : bool = let is_not_allergen (s :'a) : bool = not (List.exists (fun (x) -> x = s) l1) in List.for_all (is_not_allergen) l2 in List.filter (fun (Cupcake(p,w,c,l)) -> (contains_no_allergen l allergens)) cupcakes ;; |
let string_explode (s : string) : char list = tabulate (String.get s) (String.length s) ;; |
let string_implode (l : char list) : string = let p2 c s = Char.escaped c ^ s in List.fold_right p2 l "";; |
let evens (max : int) : int list = unfold (fun b -> (b, b+2)) (fun b -> max <= b) 0 ;; |
let fib (max : int) : int list = unfold (function b -> (fst(b),(snd(b),fst(b)+snd(b)))) (fun b -> max <= fst(b)) (1,1) ;; |
let pascal (max : int) : int list list = unfold (fun b -> (b,List.map2 (+) (List.cons 0 b) (List.append b [0]))) (fun b -> max < List.length b) [1] ;; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = List.filter (fun c->List.for_all (fun a-> List.exists (fun i->not(contain c a)) (cupcakes)) (allergens)) (cupcakes);; |
let string_explode (s : string) : char list = tabulate (String.get s) (String.length s) ;; |
let string_implode (l : char list) : string = let p2 c s = Char.escaped c ^ s in List.fold_right p2 l "";; |
let evens (max : int) : int list = unfold (fun b -> (b, b+2)) (fun b -> max <= b) 0 ;; |
let fib (max : int) : int list = unfold (function b -> (fst(b),(snd(b),fst(b)+snd(b)))) (fun b -> max <= fst(b)) (1,1) ;; |
let pascal (max : int) : int list list = unfold (fun b -> (b,List.map2 (+) (List.cons 0 b) (List.append b [0]))) (fun b -> max < List.length b) [1] ;; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) = List.filter (fun c->List.for_all (fun a-> List.exists (fun i->not(contain c a)) (cupcakes)) (allergens)) (cupcakes);; |
let string_explode (s : string) : char list = let append_char = String.get s in tabulate append_char (String.length s) ;; |
let string_implode (l : char list) : string = let append_char c = (^) (Char.escaped c) in List.fold_right append_char l "" ;; |
let evens (max : int) : int list = let f seed = (seed, seed + 2) in unfold f (fun b -> (b >= max)) 0 ;; |
let fib (max : int) : int list = let f seed = let (x, y) = seed in (x, (y, x + y)) in unfold f (fun b -> let (x, y) = b in x >= max) (1, 1) ;; |
let pascal (max : int) : int list list = let remove_last l = tabulate (List.nth l) (List.length l - 1) in let f seed = match seed with | [] -> (1 :: [], 1 :: []) | h :: t -> ((1 :: []) @ List.map2 (+) (remove_last seed) t @ (1 :: []), (1 :: []) @ List.map2 (+) (remove_last seed) t @ (1 :: [])) in unfold f (fun b -> (List.length b >= max)) [] ;; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = let no_allergen c a = let Cupcake (p, w, ca, il) = c in not (List.exists (fun x -> x = a) il) in let no_allergens c = List.for_all (no_allergen c) allergens in List.filter no_allergens cupcakes ;; |
let string_explode (s : string) : char list = tabulate (String.get s) (String.length s);; |
let string_implode (l : char list) : string = List.fold_left (fun s c -> s ^ Char.escaped c) "" l;; |
let evens (max : int) : int list = unfold (fun b -> (b, b + 2)) ((<=) max) 0;; |
let fib (max : int) : int list = unfold (fun (a,b) -> (a , (b, a+b))) (fun (a,_) -> max <= a) (1,1);; |
let pascal (max : int) : int list list = unfold (fun (a, b) -> (a , (b, [1] @ (List.map2 (+) (List.rev (List.tl b)) (List.tl b)) @ [1]))) (fun (a, _) -> max < List.length a) ([1] ,[1;1]);; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = List.filter (fun x -> let Cupcake(_,_,_,i) = x in List.for_all (fun y -> not (List.exists ((=) y) allergens)) i ) cupcakes;; |
let string_explode (s : string) : char list = tabulate (String.get s) (String.length s) ;; |
let string_implode (l : char list) : string = String.concat "" ((List.map ((Char.escaped))) l) ;; |
let evens (max : int) : int list = unfold (fun b -> (b, b+2)) ((<) (max - 1)) 0 ;; |
let fib (max : int) : int list = unfold (fun (a,b) -> (a, (b,a+b))) (fun (a,b) -> max-1 < a) (1,1) ;; |
let pascal (max : int) : int list list = unfold (fun l -> (l, [1]@(List.map2 (+) (List.tl l) (List.rev (List.tl l)))@[1] )) (fun l -> max < List.length l) [1] ;; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = List.filter ( function Cupcake (_,_,_,ingred_lst) -> List.for_all (fun y -> not (List.exists (fun x -> x=y) allergens)) ingred_lst) cupcakes ;; |
let string_explode (s : string) : char list = tabulate (String.get s) (String.length s) ;; |
let string_implode (l : char list) : string = let lst = List.map (Char.escaped) l in List.fold_left (^) "" lst ;; |
let evens (max : int) : int list = unfold (fun b -> (b, b+2)) ((<=) max) 0 ;; |
let fib (max : int) : int list = let rec fib_aux n a b = if n=2 then a+b else fib_aux (n-1) b (b+a) in let fib_tl n = if n=0 then 1 else if n=1 then 1 else fib_aux (n+1) 0 1 in unfold (fun b -> (fib_tl (b), b+1)) (fun b -> max <= fib_tl b) 0 ;; |
let pascal (max : int) : int list list = let rec pascalrow (l: int list) rownb = if rownb = 1 then l else ( let l1 = 0::l in let l2 = l@[0] in pascalrow (List.map2 (+) l1 l2 ) (rownb-1) ) in unfold (fun b -> ((pascalrow [1] (b)), b+1)) ((<) max) 1 ;; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = if allergens = [] then cupcakes else List.filter (fun c : bool -> let Cupcake (p,w,c,ls) = c in List.for_all (fun g -> not (List.exists ((=)g ) allergens ) ) ls ) cupcakes ;; |
let string_explode (s : string) : char list = let get_char (n: int) : char = String.get s n in tabulate get_char (String.length s);; |
let string_implode (l : char list) : string = String.concat "" (List.map Char.escaped l) let even (s: int) : int*int = (s, s+2);; |
let evens (max : int) : int list = let stop (n: int) : bool = n >= max in let even (s: int) : (int*int) = (s, s+2) in unfold even stop 0 let rec fib_aux goal cur prev = if cur = goal then cur+prev else fib_aux goal (cur + prev) cur;; |
let fib (max : int) : int list = let stop (n: int) : bool = n >= max in let fib_help (s: int) : (int*int) = (s, fib_aux s 1 1) in if max > 1 then 1 :: unfold fib_help stop 1 else [] let next (l: int list): int list = List.append (1 :: List.map2 (+) (List.rev(List.tl(List.rev l))) (List.tl l)) [1];; |
let pascal (max : int) : int list list = let stop (l: int list) : bool = List.length l > max in let pascal_help (l: int list): (int list * int list) = (l, next l) in unfold pascal_help stop [1];; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = let safe (c: cupcake): bool = let contain (i: ingredient): bool = let Cupcake(price, weight, cal, ing) = c in List.mem i ing in let not_contain (i: ingredient): bool = let Cupcake(price, weight, cal, ing) = c in not (List.mem i ing) in (not (List.exists contain allergens)) && (List.for_all not_contain allergens) in List.filter safe cupcakes;; |
let string_explode (s : string) : char list = let f n = String.get s n in tabulate f (String.length s) ;; |
let string_implode (l : char list) : string = let f init b1 = init ^ Char.escaped b1 in List.fold_left f "" l ;; |
let evens (max : int) : int list = let f b = b, b + 2 in unfold f (fun b -> b >= max) 0 ;; |
let fib (max : int) : int list = let f (a, b) = b, (b, a + b) in let stop (a, b) = b >= max in unfold f stop (0, 1) ;; let tuple (l : 'a list) : 'tuple list = let rec aux lst ix1 ix2 = if ix2 = List.length l then lst else aux ((List.nth l ix1, List.nth l ix2) :: lst) ix2 (succ ix2) in aux [] 0 1 ;; let add_tuple (l : ('a * 'a) list) : 'a list = let rec aux lst n = if n >= List.length l then lst else ( let a, b = List.nth l n in aux ((a + b) :: lst) (succ n)) in aux [] 0 ;; |
let pascal (max : int) : int list list = let stop cur = List.length cur > max in let f cur = if List.length cur = 1 then cur, [ 1; 1 ] else cur, List.append (1 :: add_tuple (tuple cur)) [ 1 ] in unfold f stop [ 1 ] ;; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = if allergens = [] then cupcakes else ( let contains ingr = List.mem ingr allergens in let f cupcake = let (Cupcake (p, w, c, ingredients)) = cupcake in List.exists contains ingredients in let nf cupcake = let (Cupcake (p, w, c, ingredients)) = cupcake in not (List.exists contains ingredients) in match cupcakes with | [] -> [] | h :: t -> if not (List.for_all f (h :: t)) then List.filter nf (h :: t) else []) ;; |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.