tautologico

let string_fold s f ini =  (* this is a left fold *)
  let len = String.length s in
  let rec loop i res = 
    if i >= len then res else loop (i+1) (f s.[i] res) 
  in
  loop 0 ini
  
let explode s =   (* a right string fold wouldn't need the reverse *)
  List.rev @@ string_fold s (fun c l -> c :: l) []
  

tautologico

import java.util.Iterator;
import java.util.List;
import java.util.ArrayList;

public class SomaPares {
	public static List<Integer> somapares(List<Integer[]> pares)
	{
		List<Integer> result = null;
		if (pares != null)
		{

tautologico

let rec somapares l = 
    match l with
      [] -> []
    | (a, b) :: rl -> (a+b) :: somapares rl

somapares [(1, 5); (4, 7)]

tautologico

let somapares l = List.map (fun (a,b) -> a+b) l in
somapares [(1, 5); (4,7)]

tautologico

let rec quick l = 
  match l with
    [] -> []
  | [x] -> l
  | p :: rl -> (match List.partition (fun x -> x < p) rl with
                  (l1, l2) -> (quick l1) @ [p] @ (quick l2))

tautologico

import Data.List  ( nub )
import Data.Maybe ( fromJust )

data Formula = Var String | And Formula Formula |
               Or Formula Formula | Not Formula

getVarsDup (Var v)     = [v]
getVarsDup (And f1 f2) = (getVarsDup f1) ++ (getVarsDup f2)
getVarsDup (Or f1 f2)  = (getVarsDup f1) ++ (getVarsDup f2)
getVarsDup (Not f)     = getVarsDup f

tautologico

let split s = 
  let l = String.length s in
  let rec whitespace i = 
    if i >= l then [] else 
      if s.[i] = ' ' then whitespace (i+1) else nonws i 1
  and nonws i j = 
    if (i+j) = l then [(i,j)] else 
      if s.[i+j] = ' ' then (i,j) :: whitespace (i+j) else nonws i (j+1) in
  List.map (fun (i, l) -> String.sub s i l) (whitespace 0)

tautologico

Ast.StExp (_loc,
  (Ast.ExLet (_loc, Ast.ReNil,
     (Ast.BiEq (_loc, (Ast.PaId (_loc, (Ast.IdLid (_loc, "f")))),
        (Ast.ExFun (_loc,
           (Ast.McArr (_loc, (Ast.PaId (_loc, (Ast.IdLid (_loc, "x")))),
              (Ast.ExNil _loc),
              (Ast.ExApp (_loc,
                 (Ast.ExApp (_loc,
                    (Ast.ExId (_loc, (Ast.IdLid (_loc, "*")))),
                    (Ast.ExId (_loc, (Ast.IdLid (_loc, "x")))))),

tautologico

print_tree(void).
print_tree(t(X, void, void)) :- write(X), !.
print_tree(t(X, L, R)) :- write('('), write(X), write(' '), print_tree(L), write(' '), print_tree(R), write(')').

tautologico

/* p(Nome, Sobrenome, Brincadeira, Vitima) */

gera(p(N, S, B, V)) :-
        member(N, [ana, ester, pablo, rodolfo]),
        member(S, [fontes, levis, matoso, salgado]),
        member(B, [almofada, aranha, foto, mosca]),
        member(V, [irmao, mae, pai, tia]).

dif(p(N1, S1, B1, V1), p(N2, S2, B2, V2)) :-
        N1 \= N2, S1 \= S2, B1 \= B2, V1 \= V2.