1
2
3
4
5
6
7
8
9
(defn det [a b c d e f g h i]
        (let [DET  - ( * a  
                                        ( - ( ( * e 
                                                          i ) 
                                                ( * h 
                                                    f ) ) ) ) 
                     ( + ( * d 
                                                ( - ( ( * b 
                                                                  i ) 
 ...

1
2
3
4
5
6
7
8
9
(defn det [a b c d e f g h i]
        (let [DET  - ( * a  
                                        ( - ( ( * e 
                                                          i ) 
                                                ( * h 
                                                    f ) ) ) ) 
                     ( + ( * d 
                                                ( - ( ( * b 
                                                                  i ) 
 ...

1
2
3
(defn det [a b c d e f g h i]
        (println "Determinant: " - (* a  (-((* e i)  (* h f))))  (+ (* d (- ( (* b i)  (* h c))))  (* g  (- ((* b f)  (* e c))))))
)

1
2
3
4
5
6
7
8
9
-module(prog).  
-export([quicksort/1]).  
 
quicksort(Pivot, Left, Right, []=_Src) ->  
     {Left, Pivot, Right};  
quicksort(Pivot, Left, Right, [H|T]=_Src) when H < Pivot ->  
     quicksort(Pivot, [H|Left], Right, T);  
quicksort(Pivot, Left, Right, [H|T]=_Src) ->  
     quicksort(Pivot, Left, [H|Right], T).  
 ...

1
2
3
-module(prog).
-export([mirror/1]).
mirror(Anything) -> Anything.

1
2
3
-module(prog).
-export([mirror/1]).
mirror(Anything) -> Anything.

1
2
3
-module(Prog).
-export([mirror/1]).
mirror(Anything) -> Anything.

1
2
3
-module(basic).
-export([mirror/1]).
mirror(Anything) -> Anything.

1
2
3
4
5
6
7
8
9
-module(prog).
-export([main/0]).
 
main() ->
        loop().
loop() ->
        case io:fread( "","~d" ) of
                eof ->
                        true;
 ...

1
2
(def hello (fn [] "Hello world"))
(hello)

1
2
3
4
5
6
7
8
-module(smath).
-export([fact/1, mymap/2]).
 
fact(0) -> 1;
fact(N) when N > 0 -> N * fact(N-1).
 
mymap(F, []) -> [];
mymap(F, [H|T]) -> [F(H) | mymap(F, T)]. 

1
2
R = 4.
R

1
2
3
4
5
6
7
8
-module(rush_hour).
-export([pmap/2]).
-export([splitter/2,solve/4]).
-export([test/0,test1/0,test2/0,test3/0,test4/0]).
 
pmap(F, L) ->
    Parent = self(),
    [receive Ret -> Ret end || _Pid <-[spawn(fun() -> Parent ! F(Li) end)||Li<-L]].
 ...

1
2
3
4
5
6
7
8
-module(prog).
-export([pmap/2]).
-export([splitter/2,solve/4]).
-export([test/0,test1/0,test2/0,test3/0,test4/0]).
 
pmap(F, L) ->
    Parent = self(),
    [receive Ret -> Ret end || _Pid <-[spawn(fun() -> Parent ! F(Li) end)||Li<-L]].
 ...

1
2
3
4
5
6
7
8
-module(rush_hour).
-export([pmap/2]).
-export([splitter/2,solve/4]).
-export([test/0,test1/0,test2/0,test3/0,test4/0]).
 
pmap(F, L) ->
    Parent = self(),
    [receive Ret -> Ret end || _Pid <-[spawn(fun() -> Parent ! F(Li) end)||Li<-L]].
 ...

1
2
3
4
5
6
7
8
-module(rush_hour).
-export([pmap/2]).
-export([splitter/2,solve/4]).
-export([test/0,test1/0,test2/0,test3/0,test4/0]).
 
pmap(F, L) ->
    Parent = self(),
    [receive Ret -> Ret end || _Pid <-[spawn(fun() -> Parent ! F(Li) end)||Li<-L]].
 ...

1
2
3
4
5
6
7
8
9
eb 04 af c2 bf a3 81 ec
0c fe c1 75 f9 31 c0 ba
d0 c1 ca 08 8a 1c 0c 8a
fe c1 75 e8 e9 5c 00 00
00 5c 58 3d 41 41 41 41
75 3b 5a 89 d1 89 e6 89
d1 89 df 29 cf 31 c0 31
8a 14 06 8a 34 1e 88 34
8a 1c 16 8a 17 30 da 88
 ...

1
2
3
4
5
6
7
{ok, AppConn} = odbc:connect("DSN=email360", []),
case odbc:sql_query(AppConn, "SELECT (@i:=@i+1) as record_id, subscriberid, listid, emailaddress, domainname, confirmcode, 0 as status FROM email_list_subscribers WHERE confirmed=1 AND bounced=0 AND unsubscribed=0 AND listid IN ("++ string:join(Lists, ", ") ++") GROUP BY emailaddress ORDER BY subscriberid") of
         {selected, _Cols, Rows} ->
            [list_to_tuple([subscriber_info | tuple_to_list(Row)]) || Row <- Rows];
         Error ->
             Error
     end.

1
2
3
4
5
6
7
8
9
-module(prog).
-export([main/0]).
 
main() ->
        loop().
loop() ->
        case io:fread( "","~d" ) of
                eof ->
                        true;
 ...

1
2
3
4
5
6
7
8
9
-module(assembler).
-compile([export_all]).
 
start() -> register(assembler, spawn(fun() -> checker() end)).
 
check(Pid, Line, Label, Directive, AdMode, Type, Operand) ->
  Pid ! {self(), {Line, Label, Directive, AdMode, Type, Operand}},
  receive
    {Pid, Error} -> Error
 ...

1
2
3
4
5
6
7
8
9
-module(assembler).
-compile([export_all]).
 
start() -> register(assembler, spawn(fun() -> checker() end)).
 
check(Pid, Line, Label, Directive, AdMode, Type, Operand) ->
  Pid ! {self(), {Line, Label, Directive, AdMode, Type, Operand}},
  receive
    {Pid, Error} -> Error
 ...

1
2
3
4
5
6
7
8
9
-module(assembler).
-compile([export_all]).
 
start() -> register(assembler, spawn(fun() -> checker() end)).
 
check(Pid, Line, Label, Directive, AdMode, Type, Operand) ->
  Pid ! {self(), {Line, Label, Directive, AdMode, Type, Operand}},
  receive
    {Pid, Error} -> Error
 ...

1
2
3
4
5
6
-module(prog).
-export([main/0]).
 
main() ->
  Numbers = [1, 2, 3, 4],
  io:fwrite("~p", Numbers).

1
2
3
4
5
6
7
8
9
-module(prog).
-export([main/0]).
 
main() ->
        loop().
loop() ->
        case io:fread( "","~d" ) of
                eof ->
                        true;
 ...

1
2
3
4
5
6
7
8
9
-module(prog).
-export([main/0]).
 
main() ->
        loop().
loop() ->
        case io:fread( "","~d" ) of
                eof ->
                        true;
 ...

1
2
3
4
5
6
7
8
9
-module(prog).
-export([sort/1]).
-import(lists, [reverse/1]).
 
sort(L) -> sort(L, [], true).
sort([], L, true) -> reverse(L);
 
sort([], L, false) -> sort(reverse(L), [], true);
 
 ...

1
2
3
4
5
6
7
8
9
 
-module(prog).
-export([sort/1]).
-import(lists, [reverse/1]).
 
sort(L) -> sort(L, [], true).
sort([], L, true) -> reverse(L);
 
sort([], L, false) -> sort(reverse(L), [], true);
 ...

1
2
3
4
5
6
 
-module(prog).
-export([sort/1]).
-import(lists, [reverse/1]).
 
sort(L) -> sort(L, [], true).

1
2
 
sort([ X | T ], L, Halt) -> sort(T, [ X | L ], Halt).

1
2
<<bubblesort.erl>>=
sort([ X | T ], L, Halt) -> sort(T, [ X | L ], Halt).