text
stringlengths 0
601k
|
|---|
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 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 :: List.map2 ( + ) (List.tl cur) (List.rev (List.tl 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 []) ;; |
let string_explode (s : string) : char list = let l = String.length s in let ls = tabulate (fun x -> x) l in List.map (fun i -> String.get s i) ls ;; |
let string_implode (l : char list) : string = let l1 = List.map(Char.escaped) l in List.fold_left (^) "" l1 ;; |
let evens (max : int) : int list = unfold (fun x -> (x, x+2)) (fun x -> x >= max) 0 ;; |
let fib (max : int) : int list = unfold (fun (a, b) -> (a, (b, a+b))) (fun (a, b) -> a >= max) (1, 1) ;; |
let pascal (max : int) : int list list = unfold (fun l -> (l, List.map2 (+) ([0] @ l) (l @ [0]))) (fun l -> List.length l > max) [1] ;; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = raise NotImplemented;; |
let string_explode (s : string) : char list = let getChar (n: int) = String.get s n in tabulate getChar (String.length s) ;; |
let string_implode (l : char list) : string = List.fold_left (^) "" (List.map Char.escaped l);; |
let evens (max : int) : int list = let f (n:int) : (int * int) = ((n*2),(n+1)) in let stop (n:int) : bool = if (max mod 2) = 0 then n >= (max/2) else n >= (max / 2 + 1) in unfold (f) (stop) (0);; |
let fib (max : int) : int list = let stop (a: int * int) : bool = match a with | (0,a) -> max <= 1 | (a1,a2) -> (a1 + a2) >= max in let nextNb (a: int * int) : (int * (int * int)) = match a with | (0,0) -> (1,(0,1)) | (a1,a2) -> ((a1 + a2),(a2,(a1+a2))) in unfold nextNb stop (0,0);; |
let pascal (max : int) : int list list = let nextRow (l: int list) : (int list * int list) = match l with | [] -> ([1],[1]) | _ -> let l1 = 0::l in let l2 = List.rev (0::(List.rev l)) in let nl = (List.map2 (+) l1 l2) in (nl,nl) in let stop (seed:int list) : bool = (List.length seed) >= max in unfold nextRow stop [];; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = let doesNotContain (Cupcake (_,_,_,l)) : bool = let contains (li: ingredient list) : (bool * ingredient list) = match li with | [] -> failwith "The stop method failed" | x::xs -> (List.exists (fun a -> a = x) allergens, xs) in let stop (li: ingredient list) : bool = match li with | [] -> true | _ -> false in List.for_all (not) (unfold contains stop l) in List.filter doesNotContain 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)) (fun b -> max <= b) 0;; |
let fib (max : int) : int list = unfold (fun (last_added, next_seed) -> (last_added, (next_seed, last_added + next_seed))) (fun (last_added, next_seed) -> max <= last_added) (1, 1) ;; |
let pascal (max : int) : int list list = match max with | 1 -> [[1]] | 2 -> [[1]; [1;1]] | _ -> unfold (fun (a, b) -> (a, ( List.append [1] ( List.map2 (+) a (List.append (List.tl a) [0]) ) , a ) ) ) (fun (a, b) -> max <= (List.length b)) ([1], [1;1]) ;; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = List.filter (function cupcake -> (let Cupcake (_,_,_,ingredients) = cupcake in (List.for_all (fun allergen -> not (List.exists (fun x -> x = allergen) ingredients)) (allergens)) ) ) cupcakes;; |
let string_explode (s : string) : char list = tabulate (String.get s) (String.length s) ;; |
let string_implode (l : char list) : string = match (List.map Char.escaped l) with | [] -> "" | x :: xs -> List.fold_left (^) x xs ;; |
let evens (max : int) : int list = unfold (fun seed -> (seed, seed + 2)) (fun seed -> seed >= max) 0 ;; |
let fib (max : int) : int list = unfold (fun (n_1, n_2) -> (n_2, (n_2, n_1 + n_2))) (fun (n_1, n_2)-> n_2 >= max) (0, 1) ;; |
let pascal (max : int) : int list list = unfold (fun seed -> match seed with | [] -> ([], []) | x :: xs -> let s = List.map2 (+) (List.tl x) (List.rev (List.tl (List.rev x))) in (x, (List.concat [[1];s;[1]]) :: seed)) (fun seed -> match seed with | [] -> true | x::xs -> List.length x > max) [[1]] ;; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = List.filter (fun cake -> let Cupcake (_,_,_,ingredients) = cake in List.for_all (fun ingredient -> let i = ingredient in not (List.exists (fun allergen -> allergen = i) allergens) ) ingredients ) cupcakes ;; |
let string_explode (s : string) : char list = let s_i = String.get s in let len_s = String.length s in tabulate s_i len_s;; |
let string_implode (l : char list) : string = let str_l = List.map Char.escaped l in List.fold_left (^) "" str_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,b) -> max <= a) (1,1);; |
let pascal (max : int) : int list list = let calc_next_line prev_line = List.map2 (+) (0 :: prev_line) (List.append prev_line [0]) in unfold (fun line -> (line, calc_next_line line)) (fun line -> max < (List.length line)) ([1]);; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = let is_not_allergen ingredient = not (List.exists ((=) ingredient) allergens) in let is_good_cupcake some_cupcake = let Cupcake (_, _, _, ingredients) = some_cupcake in List.for_all is_not_allergen ingredients in List.filter is_good_cupcake cupcakes;; |
let string_explode (s : string) : char list = let n = String.length s in let f = function (n: int) -> String.get s n in tabulate f n;; |
let string_implode (l : char list) : string = let f = fun (a: string) (b: char) -> a ^ (Char.escaped b) in List.fold_left f "" l;; |
let evens (max : int) : int list = let f = fun (r: int) -> (r, r + 2) in let s = fun (r: int): bool -> r >= max in if max = 0 then [] else 0 :: unfold f s 2;; |
let fib (max : int) : int list = let f = fun (r: int * int): (int * (int * int)) -> let (a, b) = r in (a + b, (b, a + b)) in let s = fun (r: int * int): bool -> let (a, b) = r in a + b >= max in if max > 1 then 1 :: unfold f s (0, 1) else [];; |
let pascal (max : int) : int list list = let f = fun (a: int list): (int list * int list) -> let b = List.tl (List.rev (0 :: a)) in let l = 1 :: List.map2 (+) a b in (l, l) in let s = fun (r: int list): bool -> List.length r >= max in unfold f s [];; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = let e = fun (a: ingredient) (b: ingredient): bool -> a = b in let a = fun (i: ingredient): bool -> not (List.exists (e i) allergens) in let b = fun (c: cupcake): bool -> let Cupcake (_, _, _, x) = c in List.for_all a x in List.filter b 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_unfold x = (x, x+2) let evens_stop max x = x >= max;; |
let evens (max : int) : int list = unfold (evens_unfold) (evens_stop max) 0 let fib_unfold x = let (x_1, x_2) = x in (x_2, (x_2, x_1+x_2)) let fib_stop max x = let(x_1, x_2) = x in (x_2) >= max;; |
let fib (max : int) : int list = unfold (fib_unfold) (fib_stop max) (0, 1) let pascal_unfold x = let single :: rest = x in let rest_to_add = List.rev (0 :: List.rev rest) in (x, 1 :: (List.map2 (+) x rest_to_add)) let pascal_stop max x = let length = List.length x in length > max;; |
let pascal (max : int) : int list list = unfold (pascal_unfold) (pascal_stop max) [1] let zip_unfold lists = let (list1, list2) = lists in let x1::rest1 = list1 in let x2::rest2 = list2 in ((x1, x2), (rest1, rest2)) let zip_stop lists = let (list1, list2) = lists in (list1 = []) or (list2 = []);; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = let f1 ingredients allergens = not (List.for_all ((!=) allergens) ingredients) in let f3 allergens food = let Cupcake (_, _, _, ingredients) = food in not (List.exists (f1 ingredients) allergens) in List.filter (f3 allergens) cupcakes;; |
let string_explode (s : string) : char list = tabulate (fun x -> (String.get s x)) (String.length s) ;; |
let string_implode (l : char list) : string = List.fold_right (fun x a -> Char.escaped (x) ^ a) l "";; |
let evens (max : int) : int list = unfold (fun x -> (x, x + 2)) (fun x -> (x >= max)) 0 ;; evens 14;; |
let fib (max : int) : int list = match max with | 0 -> [] | 1 -> [] | _ -> let next x = if x == 1 then 2 else int_of_float (0.5 +. float_of_int (x) *. 1.61803398874989484820458683436563811772) in 1 :: unfold (fun x -> (x, next x)) (fun x -> (x >= max)) 1 ;; |
let pascal (max : int) : int list list = let rec calc l = match l with | [] -> [] | h :: t -> match t with | [] -> [] | f :: r -> (h + f) :: calc(t) in unfold (fun l -> l, calc ([0] @ l @ [0])) (fun x -> (List.length x > max)) [1];; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = let check x = ((List.exists (fun y -> (y == x)) allergens) == false) in List.filter (fun (Cupcake (_, _, _, inl)) -> List.for_all (fun x -> check x ) inl) 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 a-> (a, a+2)) ((<=) max) 0 ;; |
let fib (max : int) : int list = unfold (fun (a, b) -> (a, (b, a+b))) (fun (a, b) -> max <= a) (1, 1) ;; |
let pascal (max : int) : int list list = unfold (fun l -> (l, (List.map2 (+) (List.concat [l;[0]]) (0::l)))) (fun l -> max < List.length l) ([1]) ;; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = let cup_filter cup = let Cupcake (_, _, _, cup_ingredients) = cup in let no_allergen allergen = not (List.exists ((=) allergen) cup_ingredients) in List.for_all no_allergen allergens in List.filter cup_filter 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 (function b -> (b,b+2)) (function b-> b >= max) 0;; |
let fib (max : int) : int list = unfold (function b -> ((fst b),(snd b,(fst b)+(snd b)))) (function b -> (fst b) >=max) (1,1);; |
let pascal (max : int) : int list list = unfold (function b -> ( b, List.map2 (+) (0::b) ( List.append b [0]))) (function b -> List.length b=max+1) [1];; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = List.filter ( fun x -> ( List.exists (fun yy -> List.for_all (not) (List.map (fun zz-> List.mem zz allergens) ((function Cupcake(_,_,_,y) -> y)x)) ) ((function Cupcake(_,_,_,y) -> y)x)) ) cupcakes;; |
let string_explode (s : string) : char list = tabulate (String.get s) (String.length s);; |
let string_implode (l : char list) : string = let f = fun acc curr -> acc ^ (Char.escaped curr) in List.fold_left f "" 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, b) -> max <= a) (1, 1);; |
let pascal (max : int) : int list list = let f: int list * int list -> int list * (int list * int list) = let gen = fun l -> List.map2 (+) (0 :: l) (l @ [0]) in fun (a, b) -> (a, (b, gen b)) in unfold f (fun (a, b) -> max < List.length a) ([1], [1; 1]);; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = let f = fun ing -> not (List.exists ((=) ing) allergens) in let for_all: cupcake -> bool = fun c -> let Cupcake (_, _, _, ings) = c in List.for_all f ings in List.filter for_all 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 (String.make 1) l);; |
let evens (max : int) : int list = let gen s: (int * int) = (s*2, s+1) in let gen_stop s: bool = s*2 > (max-1) in unfold gen gen_stop 0;; |
let fib (max : int) : int list = let gen ((i1,i2) : (int*int)) : (int * (int*int)) = (i1+i2, (i2, i1+i2)) in let gen_stop ((i1,i2) : (int*int)): bool = (i1+i2) >= max in unfold gen gen_stop (1,0);; |
let pascal (max : int) : int list list = let gen (l: int list) : (int list * int list) = let lshift = List.append [0] l in let rshift = List.append l [0] in let nl = List.map2 (+) lshift rshift in (l, nl) in let gen_stop (l: int list): bool = (List.length l) >= max+1 in unfold gen gen_stop [1] exception LogicErr;; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = let no_allergens_in_ingredients (i : ingredient) : bool = not (List.exists ((=)i) allergens) in let cupcake_filter (Cupcake (_,_,_,ingredients)): bool = List.for_all no_allergens_in_ingredients ingredients in List.filter cupcake_filter cupcakes;; |
let string_explode (s : string) : char list = tabulate (String.get s) (String.length s);; |
let string_implode (l : char list) : string = let concate s c = s ^ (Char.escaped c) in List.fold_left concate "" l;; |
let evens (max : int) : int list = let f seed = (List.hd seed,[List.hd seed+2]) in let stop seed = List.hd seed >= max in unfold f stop [0];; |
let fib (max : int) : int list = let f seed = let x,ls = List.hd seed, List.tl seed in let y = List.hd ls in (x,y::[x+y]) in let stop seed = List.hd seed >= max in unfold f stop [1;1];; |
let pascal (max : int) : int list list = let rec helper ls = match ls with | [] -> [1] | x::[] -> [1] | x::y::xs -> [x+y] @ helper (y::xs) in let f seed = let hd,tl = List.hd seed, List.tl seed in (hd,[1::(helper hd)]) in let stop seed = List.length (List.hd seed) > max in unfold f stop [[1]];; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = let check allergens cake = let Cupcake (_,_,_,l) = cake in let contain a = not(List.exists ((=) a) l) in List.for_all (contain) allergens in List.filter (check allergens) cupcakes;; |
let string_explode (s : string) : char list = let explode (n:int) (a:string) : char list = tabulate (String.get a) n in explode (String.length s) s;; |
let string_implode (l : char list) : string = let implode (a:int) (l:char list) : string list = tabulate (fun k -> (Char.escaped (List.nth l k))) a in String.concat "" (implode (List.length l) l);; |
let evens (max : int) : int list = unfold (fun b -> (b, b+2)) ((<=) max) 0;; |
let fib (max : int) : int list = unfold (fun (first, second) -> (first, (second, first+second))) (fun (first, second) -> first >= max) (1,1) let pascal_helper x = [1]@ List.map2 (+) (List.tl x) (List.rev (List.tl x)) @[1];; |
let pascal (max : int) : int list list = unfold (fun (x, y) -> (x, (y, (pascal_helper y)))) (fun (x, y) -> List.length x > max) ([1],[1;1]);; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = List.filter (fun x -> let Cupcake (price,weight,calories,y) = x in (List.for_all (fun u -> not(List.exists (fun x -> (List.mem x allergens)) [u])) y)) cupcakes;; |
let string_explode (s : string) : char list = tabulate (String.get s) (String.length s) ;; |
let string_implode (l : char list) : string = let rep char = (^) (Char.escaped char)in let result = "" in List.fold_right rep l result ;; |
let evens (max : int) : int list = unfold (fun b -> (b, b+2)) ((<) (max - 1)) 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,1) ;; |
let pascal (max : int) : int list list = let rec fact x = if x <= 1 then 1 else x * fact (x - 1)in let inside (row : int) : int list = unfold (fun b -> ( (fact row) / ((fact b) * (fact (row-b))), b+1)) ((<) row) 0 in unfold (fun b -> (inside (b), b+1)) (fun b -> max < b+1) 0 ;; |
let allergy_free (allergens : ingredient list) (cupcakes : cupcake list) : cupcake list = List.filter (fun cups -> List.for_all (fun ingr -> List.exists (fun cup -> not(List.exists (fun c_ing -> c_ing = ingr ) (get_ingredients(cups)))) (cupcakes)) (allergens)) (cupcakes) ;; |
let invalid_arg () = failwith "Invalid Argument";; let get = String.get ;; let append = (^);; let length = String.length ;; |
let string_explode (s : string) : char list = if length s < 1 then [] else tabulate (get s) (String.length s);; |
let string_implode (l : char list) : string = match l with |[] -> "" |g -> List.fold_left append "" (List.map Char.escaped l) let even b = if b mod 2 = 0 then (b, b+2) else (b+1, b+3);; |
let evens (max : int) : int list = if max < 0 then domain() else unfold (even) ((<=) max) 0 let rec fib_aux n a b = if n = 0 then b else fib_aux (n-1) (b) (a+b);; |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.