ERLANG List Functions 3

-module(list_functions2).
-export([start/2]).

start(List1,List2) ->
    append_more_lists(List1,List2),
    merge_lists(List1,List2),
    list_prefix(List1,List2),
    substract_list(List1,List2),
    list_suffix(List1,List2),
    unique_merge(List1,List2),
    zip_lists(List1,List2).

append_more_lists(List1,List2) ->
    io:format("List 1 and List 2 were appended ~p~n",[lists:append(List1,List2)]).    % lists:append(List1,List2)

merge_lists(List1,List2) ->
    io:format("List 1 and List 2 were merged ~p~n",[lists:merge(List1,List2)]).     % lists:merge(List1, List2)

list_prefix(List1,List2) ->
    io:format("Is List 1 is equal to the prefix of the List 2 ? ~p~n",[lists:prefix(List1,List2)]).   % lists:prefix(List1,List2)

substract_list(List1, List2) ->
    io:format("Elements in List 1 which is equalto List 2 is eliminated in resulted list ~p~n",[lists:substract(List1,List2)]).  % lists:substract(List1, List2)

list_suffix(List1,List2) ->
    io:format("Is List 1 is equal to the suffix of List2 ~p  ~n",[lists:suffix(List1,List2)]).   % lists:suffix(List1,List2)

unique_merge(List1,List2) ->
    io:format("List 1 and List 2 were uniquely merged ~p~n",[lists:umerge(List1,List2)]).   % lists:umerge(List1,List2)

zip_lists(List1,List2) ->
    io:format("List of tuples with two elements for each tuple index one from 1 List and index 2 from List 2 ~p~n",[lists:zip(List1,List2)]).   
% lists:zip(List1,List2)

ERLANG List Functions 1

-module(list_functions).
-export([start/1]).

start(List) ->
    list_max(List),
    list_min(List),
    list_sum(List),
    list_sort(List),
    nth_element_of_the_list(List),
    separate_head_and_tail(List),
    concat_content_of_the_list(List),
    delete_defined_value_from_list(List),
    last_element_of_list(List),
    is_element_is_a_member(List),
    list_split(List)
    sub_list(List),
    sub_list_start_from_to(List),
    sort_and_remove_redundant_values(List),
    tail_after_specified_number_of_elements(List),
    lists_unique_merge(List).

list_max(List) ->
    io:format("Max of list... ~p~n",[lists:max(List)]).   
% lists:max(name_of_the_list)

list_min(List) ->
    io:format("Min of the list... ~p~n",[lists:min(List)]). 
% lists:max(name_of_the_list)

list_sum(List) ->
    io:format("Sum of the list... ~p~n",[lists:sum(List)]). 
% lists:sum(name_of_the_list)

list_sort(List) ->
    io:format("Sorted version of the list... ~p~n",[lists:sort(List)]).  
% lists:sort(name_of_the_list)

nth_element_of_the_list(List) ->
    io:format("2nd element of the list... ~p~n",[lists:nth(2,List)]).   
% lists:nth(index_no, name_of_the_list)

separate_head_and_tail([Head|Tail]) ->
    io:format("Head of the list... ~p~n",[Head]),
    io:format("Tail of the list... ~p~n",[Tail]).

concat_content_of_the_list(List) ->
    io:format("Concantinated version of the list... ~p ~n",[lists:concat(List)]).    
% lists:concat(name_of_the_list)

delete_defined_value_from_list(List) ->
    io:format("Deletes value first value 4 from the list... ~p ~n",[lists:delete(4,List)]).  
% lists:delete(index_no,name_of_the_list)

last_element_of_list(List) ->
    io:format("List after dropping the last value... ~p ~n",[lists:last(List)]). % lists:last(List)

is_element_is_a_member(List) ->
    io:format("Is element 1 is existing... ~p~n",[lists:member(1,List)]).
 % lists:member(elment_value, name_of_the_list)

list_split(List) ->
    io:format("Original list has been split to 2 lists and 1 list contain 4 and 2 list contains rest ...~p ~n",[lists:split(4,List)]).   
% lists:split(items_to_be_included_into_1_list, name_of_the_list)

sub_list(List) ->
    io:format("Sub list is genarated with elements from index 1 to 6.... ~p~n",[lists:sublist(List,6)]).  % lists:sublist(name_of_the_original_list, index_no_of_the_last_index_to_be_subset)

sub_list_start_from_to(List) ->
    io:format("Sub list is generated from original from a specified start index to specified end index ~p~n",[lists:sublist(List,2,6)]).  
% lists:sublist(name_of_the_list, start_index,end_index)

sort_and_remove_redundant_values(List) ->
    io:format("Original list is sorted with identical values... ~p~n",[lists:usort(List)]).  
% lists:usort(Name_of_the_list)

tail_after_specified_number_of_elements(List) ->
    io:format("Tail after 4 elements is... ~p~n",[lists:nthtail(4,List)]).  
%lists:nthtail(index_of_the_element_which_is_immediately_before_the_required_tail, name_of_the_list)

lists_unique_merge(List) ->
    io:format("Merge list of lists with unique values ~p ~n",[lists:umerge(List)]).


How to Garbage Collect in Erlang Forcefully

erlang:garbage_collect(self()).

Erlang Tuple functions

-module(tuple_functions).
-export([start/1]).

start(Tuple) ->
    select_element_by_index(Tuple),
    set_element(Tuple),
    find_tuple_size(Tuple),
    pass_tuple_values_to_variables(Tuple).
  
select_element_by_index(Tuple) ->
    io:format("2 nd element of the Tuple ..... ~p~n",[element(2,Tuple)]).  % element(index of the required value,input tuple)

set_element(Tuple) ->
    io:format("Replaces the old element in 2nd place with 45 in the tuple .... ~p~n",[setelement(2,Tuple,45)]). % setelement(index of the old value, input tuple, new value)

find_tuple_size(Tuple) ->
    io:format("Size of the tuple .... ~p~n",[tuple_size(Tuple)]). % tuple_size(input tuple)

pass_tuple_values_to_variables({Var1, Var2, Var3, Var4}) ->
    io:format("1 st position value of the tuple ..... ~p~n",[Var1]),
    io:format("2 st position value of the tuple ..... ~p~n",[Var2]),
    io:format("3 st position value of the tuple ..... ~p~n",[Var3]),
    io:format("4 st position value of the tuple ..... ~p~n",[Var4]).

Time-stamp generating function in Erlang (Required input parameters are Start Time-stamp, Times to shift the time)

-module(random_time_genarator).
-export([start/2]).


start(Times,StartDate) ->
    generating_records(Times,StartDate).


generating_records(Times,StartDate) ->
    Accept_time=generate_timestamp(StartDate,Times),
    Accept_time.
  

generate_timestamp(Timestamp,Times) ->
    {{Y,Mo,D},{H,Mi,S}}=Timestamp,
    second_genaration(Y,Mo,D,H,Mi,S,Times,Times).

second_genaration(Y,Mo,D,H,Mi,S,Times,Counter) ->
    timer:sleep(3),

    if
        S <59 , Counter>0 ->
            second_genaration(Y,Mo,D,H,Mi,S+1,Times,Counter-1);

        true ->
            minute_genaration(Y,Mo,D,H,Mi,S,Times,Counter)
    end.

minute_genaration(Y,Mo,D,H,Mi,S,Times,Counter) ->

    if
        Mi<59 , Counter>0 ->
            second_genaration(Y,Mo,D,H,Mi+1,0,Times,Counter);
        true ->
            hour_genaration(Y,Mo,D,H,Mi,S,Times,Counter)
    end.

  
hour_genaration(Y,Mo,D,H,Mi,S,Times,Counter) ->

    if
        H <23 , Counter>0->
            minute_genaration(Y,Mo,D,H+1,0,S,Times,Counter);

        true ->
            day_genaration(Y,Mo,D,H,Mi,S,Times,Counter)
          
    end.

day_genaration(Y,Mo,D,H,Mi,S,Times,Counter) ->

    if
        D<30 , Counter>0->
            hour_genaration(Y,Mo,D+1,0,Mi,S,Times,Counter);

        true ->
            {{Y,Mo,D},{H,Mi,S}}
    end.

Simple IF function in Erlang

-module(simple_if).
-export([login/2]).

login(UserName,Pwd) ->
    if
        UserName==udara , Pwd==123 ->
            "Authenticated";

        UserName==udara , Pwd /= 123 ->
            "Password Error";

        UserName /= udara , Pwd ==123 ->
            "User Name Error";

        true ->
            "Authentication failed"
    end.

Find count of elements and indexes of a given value of a list in Erlang (using recursiveness)

-module(list_index).
-export([start/2,start_2/2]).

start(Index,[Head|Tail]) ->
    list_value(Index,[Head|Tail],1).

list_value(Index,[Head|Tail],Count) ->
    if
        Index == Count ->
            io:format("Index value is ~p ~n",[Head]);
        true ->
            list_value(Index,Tail,Count+1)
    end.


start_2(Value,[Head|Tail]) ->
    list_value_index(Value,[Head|Tail],1).

list_value_index(Value,[Head|Tail],Count) ->
    if
        Value == Head ->
            io:format("Count is ~p ~n",[Count]);
        true ->
            list_value_index(Value,Tail,Count+1)
    end;

list_value_index(Value,[],Count) ->
    error.

Find Maximum, Minimum, Total and Average from values in a Erlang list using Recursiveness

-module(summery_functions). 
-export([start/1]). 

start([Head|Tail]) -> 
        maximum(Head,Tail), 
        minimum(Head,Tail), 
        total(Head,Tail), 
        avg(Head,Tail,1). 


maximum (Head,[Head2|Tail2]) -> 
           if Head < Head2 -> 
                  maximum(Head2,Tail2); 
               true -> 
                  maximum(Head,Tail2) 
               end; 

maximum (Head,[]) -> 
             io:format("Maximum ~p ~n",[Head]). 


minimum(Head,[Head2|Tail2]) ->
           if Head > Head2 -> 
                 minimum(Head2,Tail2); 
               true -> minimum(Head,Tail2) 
           end; 
minimum (Head,[]) -> 
           io:format("Minimim ~p ~n",[Head]). 

 total(Total,[Head|Tail]) -> 
           total(Total+Head,Tail); 
           total(Total,[]) -> 
               io:format("Total ~p ~n",[Total]). 

avg(Total,[Head|Tail],Count) -> 
           avg(Total+Head,Tail,Count+1); 
           avg(Total,[],Count) -> 
               io:format("Average is ~p ~n",[Total/Count]).

Factorial function implementation in Erlang

-module(factorial). %%This is the name of the module. File should be saved with this
-export([start/1]). %% This is the function that can be accessed from outside

             start(0) -> 0;   %% If the value for start function is 0. this will be executed
             start(Num) -> Num*start(Num-1).  %% Recursiveness is happening