Erlang Notes on Dan Stefan Oprean

Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Hello World

-module(main).
-export([hello/0]).

hello() ->
    io:format("Hello, world!~n").

Compile and run in the Erlang shell:

c(main).
main:hello().

This defines a tiny Erlang module and a function that prints one line to the shell.

Variables

Variables are single-assignment and start with an uppercase letter.

Name = "Dan",
Count = 1,
Active = true.

These are single-assignment bindings. Once a variable has a value in Erlang, you do not mutate it in place.

Add

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Add

-module(add).
-export([add/2]).

add(Param1, Param2) ->
    Param1 + Param2.

This just adds the two input numbers with the language’s normal arithmetic and returns the sum.

Add Border

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Add Border

-module(add_border).
-export([add_border/1]).

add_border(Picture) ->
    Width = length(hd(Picture)),
    Border = lists:duplicate(Width + 2, $*),
    Bordered = [[$*] ++ Row ++ [$*] || Row <- Picture],
    [Border] ++ Bordered ++ [Border].

This builds a new grid with a * border around every side. It adds a full top and bottom row, then wraps each existing row from left and right.

Adjacent Elements Product

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Adjacent Elements Product

-module(adjacent_elements_product).
-export([adjacent_elements_product/1]).

adjacent_elements_product(InputArray) ->
    Pairs = lists:zip(InputArray, tl(InputArray)),
    lists:max([X * Y || {X, Y} <- Pairs]).

This walks through neighboring values, multiplies each pair, and keeps the biggest product it finds.

Almost Magic Square

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Almost Magic Square

-module(almost_magic_square).
-export([almost_magic_square/1]).

almost_magic_square(A) ->
    Rows = chunk3(A),
    RowSums = [lists:sum(R) || R <- Rows],
    ColSums = [lists:sum([lists:nth(C, R) || R <- Rows]) || C <- [1, 2, 3]],
    MaxSum = lists:max(RowSums ++ ColSums),
    FinalRows = balance(0, 0, RowSums, ColSums, Rows, MaxSum),
    lists:append(FinalRows).

chunk3([]) -> [];
chunk3(List) ->
    {Row, Rest} = lists:split(3, List),
    [Row | chunk3(Rest)].

balance(I, J, RowSums, ColSums, Rows, MaxSum) when I < 3, J < 3 ->
    RowSumI = lists:nth(I + 1, RowSums),
    ColSumJ = lists:nth(J + 1, ColSums),
    Diff = min(MaxSum - RowSumI, MaxSum - ColSumJ),
    Rows1 = add_at(Rows, I, J, Diff),
    RowSums1 = add_at_list(RowSums, I, Diff),
    ColSums1 = add_at_list(ColSums, J, Diff),
    NextI = case lists:nth(I + 1, RowSums1) of MaxSum -> I + 1; _ -> I end,
    NextJ = case lists:nth(J + 1, ColSums1) of MaxSum -> J + 1; _ -> J end,
    balance(NextI, NextJ, RowSums1, ColSums1, Rows1, MaxSum);
balance(_, _, _, _, Rows, _) ->
    Rows.

add_at(Rows, I, J, Diff) ->
    [case Idx of
         I -> [case Jdx of J -> V + Diff; _ -> V end
               || {Jdx, V} <- lists:zip(lists:seq(0, length(Row) - 1), Row)];
         _ -> Row
     end || {Idx, Row} <- lists:zip(lists:seq(0, length(Rows) - 1), Rows)].

add_at_list(List, Idx0, Diff) ->
    [case I of Idx0 -> V + Diff; _ -> V end
     || {I, V} <- lists:zip(lists:seq(0, length(List) - 1), List)].

This adjusts the matrix toward a matching target sum so the rows and columns line up more like a magic square.

Are Equally Strong

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Are Equally Strong

-module(are_equally_strong).
-export([are_equally_strong/4]).

are_equally_strong(YourLeft, YourRight, FriendsLeft, FriendsRight) ->
    max(YourRight, YourLeft) =:= max(FriendsLeft, FriendsRight) andalso
    min(YourLeft, YourRight) =:= min(FriendsRight, FriendsLeft).

This compares each person’s strongest and weakest arm. If both pairs match, the result is true.

Array Change

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Array Change

-module(array_change).
-export([array_change/1]).

array_change([H | T]) ->
    {_, Total} = lists:foldl(fun(X, {Prev, Acc}) ->
        case X =< Prev of
            true ->
                New = Prev + 1,
                {New, Acc + (New - X)};
            false ->
                {X, Acc}
        end
    end, {H, 0}, T),
    Total.

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Array Maximal Adjacement Difference

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Array Maximal Adjacement Difference

-module(array_maximal_adjacent_difference).
-export([array_maximal_adjacent_difference/1]).

array_maximal_adjacent_difference(A) when length(A) < 3 ->
    0;
array_maximal_adjacent_difference(A) ->
    Triples = lists:zip3(A, tl(A), tl(tl(A))),
    lists:max([max(abs(Cur - Prev), abs(Cur - Next)) || {Prev, Cur, Next} <- Triples]).

This checks the gap between each pair of neighbors and returns the largest difference.

Binary Gap

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Binary Gap

-module(binary_gap).
-export([binary_gap/1]).

binary_gap(N) ->
    Bin = integer_to_list(N, 2),
    Trimmed = string:trim(Bin, both, "0"),
    Groups = string:split(Trimmed, "1", all),
    lists:max([length(G) || G <- Groups]).

This turns the number into binary, ignores zeroes outside the edges, and finds the longest run of zeroes between 1s.

Bracket

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Bracket

-module(bracket).
-export([bracket/1]).

bracket(S) ->
    case close_stack(S, []) of
        [] -> 1;
        _  -> 0
    end.

close_stack([], Stack) -> Stack;
close_stack([$( | T], Stack) -> close_stack(T, [$( | Stack]);
close_stack([$[ | T], Stack) -> close_stack(T, [$[ | Stack]);
close_stack([${ | T], Stack) -> close_stack(T, [${ | Stack]);
close_stack([$) | T], [$( | Stack1]) -> close_stack(T, Stack1);
close_stack([$] | T], [$[ | Stack1]) -> close_stack(T, Stack1);
close_stack([$} | T], [${ | Stack1]) -> close_stack(T, Stack1);
close_stack([$) | _], _) -> error;
close_stack([$] | _], _) -> error;
close_stack([$} | _], _) -> error;
close_stack([_ | T], Stack) -> close_stack(T, Stack).

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Century From Year

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Century From Year

-module(century_from_year).
-export([century_from_year/1]).

century_from_year(Year) ->
    (Year + 99) div 100.

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

Check Palindrome

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Check Palindrome

-module(check_palindrome).
-export([check_palindrome/1]).

check_palindrome(InputString) ->
    lists:reverse(InputString) =:= InputString.

This compares the string with its reverse. If they match, it is a palindrome.

Chocolates By Numbers

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Chocolates By Numbers

-module(chocolates_by_numbers).
-export([chocolates_by_numbers/2]).

chocolates_by_numbers(N, M) ->
    G = gcd(N, M),
    (N * M) div G div M.

gcd(N, M) when N rem M =:= 0 -> M;
gcd(N, M) -> gcd(M, N rem M).

This uses the greatest common divisor to figure out how many chocolates get eaten before the pattern repeats.

Common Prime Divisors

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Common Prime Divisors

-module(common_prime_divisors).
-export([common_prime_divisors/2]).

common_prime_divisors(A, B) ->
    length([ok || {X, Y} <- lists:zip(A, B), has_same_prime_divisors(X, Y)]).

has_same_prime_divisors(X, Y) ->
    D = gcd(X, Y),
    case remove_common(X, D) of
        1 -> remove_common(Y, D) =:= 1;
        _ -> false
    end.

remove_common(1, _) -> 1;
remove_common(N, M) ->
    case gcd(N, M) of
        1 -> N;
        D -> remove_common(N div D, M)
    end.

gcd(N, M) when N rem M =:= 0 -> M;
gcd(N, M) -> gcd(M, N rem M).

This checks whether two numbers are built from the same prime factors by repeatedly dividing out their shared parts.

Count Div

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Count Div

-module(count_div).
-export([count_div/3]).

count_div(A, B, K) ->
    FirstDiv = case A rem K of
        0 -> A;
        R -> A + (K - R)
    end,
    LastDiv = B - (B rem K),
    (LastDiv - FirstDiv) div K + 1.

This counts how many numbers in a range are divisible by K without looping through every value.

Count Factors

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Count Factors

-module(count_factors).
-export([count_factors/1]).

count_factors(N) ->
    count_factors(N, 1, 0).

count_factors(N, I, Count) when I * I < N ->
    NewCount = case N rem I =:= 0 of
        true -> Count + 2;
        false -> Count
    end,
    count_factors(N, I + 1, NewCount);
count_factors(N, I, Count) when I * I =:= N ->
    Count + 1;
count_factors(_, _, Count) ->
    Count.

This checks divisors in pairs up to the square root, which keeps the work much smaller than testing every number.

Count Non Divisible

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Count Non Divisible

-module(count_non_divisible).
-export([count_non_divisible/1]).

count_non_divisible(A) ->
    Size = length(A),
    Occ = lists:foldl(fun(V, Map) ->
        maps:update_with(V, fun(C) -> C + 1 end, 1, Map)
    end, #{}, A),
    [Size - count_divisors(V, Occ) || V <- A].

count_divisors(V, Occ) ->
    count_divisors(V, Occ, 1, 0).

count_divisors(V, _Occ, I, Count) when I * I > V ->
    Count;
count_divisors(V, Occ, I, Count) ->
    case V rem I of
        0 ->
            Base = Count + maps:get(I, Occ, 0),
            Total = case V div I =:= I of
                true -> Base;
                false -> Base + maps:get(V div I, Occ, 0)
            end,
            count_divisors(V, Occ, I + 1, Total);
        _ ->
            count_divisors(V, Occ, I + 1, Count)
    end.

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

Count Semi Primes

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Count Semi Primes

-module(count_semi_primes).
-export([count_semi_primes/3]).

count_semi_primes(N, P, Q) ->
    IsPrime = sieve(N),
    Flags = mark_semiprimes(N, IsPrime),
    Prefix = prefix_cumulative(N, Flags),
    [array:get(Qi, Prefix) - array:get(Pi - 1, Prefix) || {Pi, Qi} <- lists:zip(P, Q)].

sieve(N) ->
    Arr0 = array:new(N + 1, {default, true}),
    Arr1 = array:set(0, false, Arr0),
    Arr2 = case N >= 1 of
        true -> array:set(1, false, Arr1);
        false -> Arr1
    end,
    sieve(2, N, Arr2).

sieve(I, N, Arr) when I * I > N ->
    Arr;
sieve(I, N, Arr) ->
    Arr1 = case array:get(I, Arr) of
        true -> mark_multiples(I * I, I, N, Arr);
        false -> Arr
    end,
    sieve(I + 1, N, Arr1).

mark_multiples(K, _Step, N, Arr) when K > N ->
    Arr;
mark_multiples(K, Step, N, Arr) ->
    mark_multiples(K + Step, Step, N, array:set(K, false, Arr)).

mark_semiprimes(N, IsPrime) ->
    Flags0 = array:new(N + 1, {default, 0}),
    mark_k(2, N, IsPrime, Flags0).

mark_k(K, N, _IsPrime, Flags) when K * K > N ->
    Flags;
mark_k(K, N, IsPrime, Flags) ->
    Flags1 = case array:get(K, IsPrime) of
        true -> mark_i(2, K, N, IsPrime, Flags);
        false -> Flags
    end,
    mark_k(K + 1, N, IsPrime, Flags1).

mark_i(I, K, N, _IsPrime, Flags) when I * K > N ->
    Flags;
mark_i(I, K, N, IsPrime, Flags) ->
    Flags1 = case array:get(I, IsPrime) of
        true -> array:set(K * I, 1, Flags);
        false -> Flags
    end,
    mark_i(I + 1, K, N, IsPrime, Flags1).

prefix_cumulative(N, Flags) ->
    {_, Prefix} = lists:foldl(fun(I, {Prev, Acc}) ->
        Cur = Prev + array:get(I, Flags),
        {Cur, array:set(I, Cur, Acc)}
    end, {0, Flags}, lists:seq(1, N)),
    Prefix.

This precomputes semiprimes and prefix sums so each range query becomes a quick subtraction.

Cyclic Rotation

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Cyclic Rotation

-module(cyclic_rotation).
-export([cyclic_rotation/2]).

cyclic_rotation([], _K) ->
    [];
cyclic_rotation(A, K) ->
    N = length(A),
    Shift = K rem N,
    {Front, Back} = lists:split(N - Shift, A),
    Back ++ Front.

This rotates the array to the right by K steps and keeps the wrap-around values in the correct order.

Distinct

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Distinct

-module(distinct).
-export([distinct/1]).

distinct(A) ->
    length(lists:usort(A)).

This counts unique values by tracking what has already been seen.

Dominator

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Dominator

-module(dominator).
-export([dominator/1]).

dominator(A) ->
    Indexed = lists:zip(lists:seq(0, length(A) - 1), A),
    {FinalSize, FinalValue, FinalIndex} = lists:foldl(fun({K, V}, {Size, Value, Index}) ->
        case Size of
            0 -> {1, V, K};
            _ ->
                case Value =:= V of
                    true -> {Size + 1, Value, Index};
                    false -> {Size - 1, Value, Index}
                end
        end
    end, {0, undefined, 0}, Indexed),
    Candidate = case FinalSize > 0 of
        true -> FinalValue;
        false -> -1
    end,
    Count = length([X || X <- A, X =:= Candidate]),
    case Count > length(A) / 2 of
        true -> FinalIndex;
        false -> -1
    end.

This finds a value that appears in more than half of the array, then returns one valid index for it.

Equi Leader

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Equi Leader

-module(equi_leader).
-export([equi_leader/1]).

equi_leader(A) ->
    N = length(A),
    {LeaderSize, LeaderValue} = leader_scan(A),
    Candidate = case LeaderSize > 0 of
        true -> LeaderValue;
        false -> -1
    end,
    LeaderCount = length([X || X <- A, X =:= Candidate]),
    Leader = case LeaderCount > N / 2 of
        true -> Candidate;
        false -> -1
    end,
    {_, Count} = lists:foldl(fun({K, V}, {LCount, Equi}) ->
        LCount1 = case V =:= Leader of
            true -> LCount + 1;
            false -> LCount
        end,
        LeftHalf = (K + 1) div 2,
        RightHalf = (N - K - 1) div 2,
        RCount = LeaderCount - LCount1,
        Equi1 = case LCount1 > LeftHalf andalso RCount > RightHalf of
            true -> Equi + 1;
            false -> Equi
        end,
        {LCount1, Equi1}
    end, {0, 0}, lists:zip(lists:seq(0, N - 1), A)),
    Count.

leader_scan(A) ->
    lists:foldl(fun(V, {Size, Value}) ->
        case Size of
            0 -> {1, V};
            _ ->
                case Value =:= V of
                    true -> {Size + 1, Value};
                    false -> {Size - 1, Value}
                end
        end
    end, {0, undefined}, A).

This keeps leader counts on both sides of the split and counts positions where the same leader survives in each half.

Fib Frog

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Fib Frog

-module(fib_frog).
-export([fib_frog/1]).

fib_frog(A) ->
    Size = length(A),
    Arr = array:from_list(A),
    Fibs = gen_fibs(Size),
    bfs([-1], sets:from_list([-1]), Fibs, Size, Arr, 0).

gen_fibs(Size) ->
    gen_fibs(0, 1, Size, []).

gen_fibs(_A, B, Size, Acc) when B > Size ->
    lists:reverse(Acc);
gen_fibs(A, B, Size, Acc) ->
    gen_fibs(B, A + B, Size, [B | Acc]).

bfs(Frontier, Visited, Fibs, Size, Arr, Level) ->
    Hit = lists:any(fun(Idx) ->
        lists:any(fun(F) -> Idx + F =:= Size end, Fibs)
    end, Frontier),
    case Hit of
        true -> Level + 1;
        false ->
            NextCandidates = lists:usort([Idx + F || Idx <- Frontier, F <- Fibs,
                                            Idx + F >= 0, Idx + F < Size,
                                            array:get(Idx + F, Arr) =:= 1,
                                            not sets:is_element(Idx + F, Visited)]),
            case NextCandidates of
                [] -> -1;
                _ ->
                    Visited1 = sets:union(Visited, sets:from_list(NextCandidates)),
                    bfs(NextCandidates, Visited1, Fibs, Size, Arr, Level + 1)
            end
    end.

This precomputes Fibonacci jumps, then uses a breadth-first search to find the shortest valid path across the river.

Fish

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Fish

-module(fish).
-export([fish/2]).

fish(A, B) ->
    Pairs = lists:zip(A, B),
    {_, Dead} = lists:foldl(fun({Ai, Bi}, {Stack, D}) ->
        case Bi of
            1 -> {[Ai | Stack], D};
            _ -> fight(Ai, Stack, D)
        end
    end, {[], 0}, Pairs),
    length(A) - Dead.

fight(_Ai, [], Dead) ->
    {[], Dead};
fight(Ai, [Top | Rest], Dead) ->
    Dead1 = Dead + 1,
    case Ai > Top of
        true -> fight(Ai, Rest, Dead1);
        false -> {[Top | Rest], Dead1}
    end.

This uses a stack for downstream fish and resolves fights only when opposite directions meet.

Flags

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Flags

-module(flags).
-export([flags/1]).

flags(A) ->
    Size = length(A),
    Arr = array:from_list(A),
    Peaks = compute_peaks(Arr, Size),
    Next = compute_next(Peaks, Size),
    max_flags(1, Size, Next, 0).

compute_peaks(_Arr, Size) when Size =< 1 ->
    array:new(max(Size, 1), {default, false});
compute_peaks(Arr, Size) ->
    Peaks0 = array:new(Size, {default, false}),
    lists:foldl(fun(I, Acc) ->
        Ai = array:get(I, Arr),
        Prev = array:get(I - 1, Arr),
        Next = case I + 1 < Size of
            true -> array:get(I + 1, Arr);
            false -> 0
        end,
        IsPeak = Prev < Ai andalso Ai > Next,
        array:set(I, IsPeak, Acc)
    end, Peaks0, lists:seq(1, Size - 1)).

compute_next(_Peaks, Size) when Size =:= 0 ->
    array:new(0);
compute_next(Peaks, Size) ->
    NextArr0 = array:set(Size - 1, -1, array:new(Size)),
    lists:foldl(fun(I, Acc) ->
        Val = case array:get(I, Peaks) of
            true -> I;
            false -> array:get(I + 1, Acc)
        end,
        array:set(I, Val, Acc)
    end, NextArr0, lists:seq(Size - 2, 0, -1)).

max_flags(I, Size, _Next, Result) when I * (I - 1) > Size ->
    Result;
max_flags(I, Size, Next, Result) ->
    Num = count_flags(0, 0, I, Size, Next),
    max_flags(I + 1, Size, Next, max(Result, Num)).

count_flags(Pos, Num, I, Size, _Next) when Pos >= Size orelse Num >= I ->
    Num;
count_flags(Pos, Num, I, Size, Next) ->
    case array:get(Pos, Next) of
        -1 -> Num;
        NextPos -> count_flags(NextPos + I, Num + 1, I, Size, Next)
    end.

This finds all peaks first, then checks how many flags can be placed while keeping the required distance.

Frog Jmp

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Frog Jmp

-module(frog_jmp).
-export([frog_jmp/3]).

frog_jmp(X, Y, D) ->
    (Y - X + D - 1) div D.

This computes the jump count with math instead of simulation, which is the cleanest way to solve it.

Frog River One

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Frog River One

-module(frog_river_one).
-export([frog_river_one/2]).

frog_river_one(X, A) ->
    frog_river_one(X, A, 0, sets:new()).

frog_river_one(_X, [], _K, _Seen) ->
    -1;
frog_river_one(X, [H | T], K, Seen) ->
    case H =< X andalso not sets:is_element(H, Seen) of
        true ->
            Seen1 = sets:add_element(H, Seen),
            case sets:size(Seen1) =:= X of
                true -> K;
                false -> frog_river_one(X, T, K + 1, Seen1)
            end;
        false ->
            frog_river_one(X, T, K + 1, Seen)
    end.

This tracks the earliest time each needed position appears and stops as soon as the frog can cross.

Genomic Range Query

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Genomic Range Query

-module(genomic_range_query).
-export([genomic_range_query/3]).

genomic_range_query(S, P, Q) ->
    [classify(string:slice(S, Pi, Qi - Pi + 1)) || {Pi, Qi} <- lists:zip(P, Q)].

classify(Sub) ->
    case lists:member($A, Sub) of
        true -> 1;
        false ->
            case lists:member($C, Sub) of
                true -> 2;
                false ->
                    case lists:member($G, Sub) of
                        true -> 3;
                        false -> 4
                    end
            end
    end.

This builds prefix counts for each DNA letter so every query can return the minimum impact factor quickly.

Is Ipv 4 Adress

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Is Ipv 4 Adress

-module(is_ipv4_address).
-export([is_ipv4_address/1]).

is_ipv4_address(InputString) ->
    Parts = string:split(InputString, ".", all),
    length(Parts) =:= 4 andalso lists:all(fun valid_octet/1, Parts).

valid_octet(V) ->
    case string:to_integer(V) of
        {Int, ""} when Int >= 0, Int =< 255 ->
            integer_to_list(Int) =:= V;
        _ ->
            false
    end.

This splits the string by dots and validates each part as a normal IPv4 octet.

Ladder

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Ladder

-module(ladder).
-export([ladder/2]).

%% Erlang integers are arbitrary precision, so unlike the PHP version we
%% don't need to mask the running Fibonacci total against max(B) on every
%% step to dodge overflow; masking once at the end with each B(i) is enough.
ladder(A, B) ->
    MaxA = lists:max(A),
    Fib = build_fib(MaxA),
    [array:get(Ai + 1, Fib) band ((1 bsl Bi) - 1) || {Ai, Bi} <- lists:zip(A, B)].

build_fib(Limit) ->
    Arr0 = array:set(1, 1, array:set(0, 0, array:new(Limit + 2))),
    build_fib(2, Limit + 1, Arr0).

build_fib(I, Limit, Arr) when I > Limit ->
    Arr;
build_fib(I, Limit, Arr) ->
    V = array:get(I - 1, Arr) + array:get(I - 2, Arr),
    build_fib(I + 1, Limit, array:set(I, V, Arr)).

This precomputes climb counts once and applies the modulo per query, which avoids recalculating the same paths over and over.

Largest String

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Largest String

-module(largest_string).
-export([largest_string/1]).

largest_string(S) ->
    Len = length(S),
    Arr0 = array:from_list(S),
    ArrFinal = process(Len - 1, Arr0, Len),
    array:to_list(ArrFinal).

%% Fewer than 3 characters remain before the current position, so no more
%% "abb" windows can be completed.
process(P, Arr, _Len) when P < 2 ->
    Arr;
process(P, Arr, Len) ->
    I = P - 2,
    {Arr1, I2} = handle_triple(I, Arr, Len),
    process(I2 - 1, Arr1, Len).

handle_triple(I, Arr, Len) ->
    Window = [array:get(I, Arr), array:get(I + 1, Arr), array:get(I + 2, Arr)],
    case Window of
        "abb" ->
            Arr1 = array:set(I, $b, array:set(I + 1, $a, array:set(I + 2, $a, Arr))),
            I1 = advance_on_b(I, Arr1, Len),
            final_adjust(I1, Arr1, Len);
        _ ->
            final_adjust(I, Arr, Len)
    end.

advance_on_b(I, Arr, Len) ->
    case I + 4 < Len andalso array:get(I + 4, Arr) =:= $b of
        true -> I + 4 + 1;
        false ->
            case I + 3 < Len andalso array:get(I + 3, Arr) =:= $b of
                true -> I + 3 + 1;
                false -> I
            end
    end.

final_adjust(I, Arr, Len) ->
    case I + 1 < Len andalso array:get(I + 1, Arr) =:= $b of
        true -> {Arr, I + 2};
        false -> {Arr, I + 1}
    end.

This builds the biggest valid string it can under the challenge rules by always choosing the best next character it is allowed to use.

Max Counters

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Max Counters

-module(max_counters).
-export([max_counters/2]).

max_counters(N, A) ->
    Condition = N + 1,
    {CountersMap, _MaxCounter, LastUpdate} = lists:foldl(fun(V, {Map, MaxC, Last}) ->
        case V of
            Condition ->
                {Map, MaxC, MaxC};
            _ when V =< N ->
                Index = V - 1,
                NewVal = max(maps:get(Index, Map, 0), Last) + 1,
                {maps:put(Index, NewVal, Map), max(MaxC, NewVal), Last};
            _ ->
                {Map, MaxC, Last}
        end
    end, {#{}, 0, 0}, A),
    [max(maps:get(I, CountersMap, 0), LastUpdate) || I <- lists:seq(0, N - 1)].

This delays the expensive “set all counters to max” work until it is really needed, which keeps the solution fast.

Max Double Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Max Double Slice Sum

-module(max_double_slice_sum).
-export([max_double_slice_sum/1]).

max_double_slice_sum(A) ->
    Size = length(A),
    case Size < 3 of
        true -> 0;
        false ->
            Arr = array:from_list(A),
            P1 = build_p1(Arr, Size),
            P2 = build_p2(Arr, Size),
            lists:max([array:get(I, P1) + array:get(I, P2) || I <- lists:seq(1, Size - 2)])
    end.

build_p1(Arr, Size) ->
    P0 = array:set(1, 0, array:new(Size)),
    lists:foldl(fun(I, Acc) ->
        V = max(0, array:get(I - 1, Acc) + array:get(I - 1, Arr)),
        array:set(I, V, Acc)
    end, P0, lists:seq(2, Size - 2)).

build_p2(Arr, Size) ->
    P0 = array:set(Size - 2, 0, array:new(Size)),
    lists:foldl(fun(J, Acc) ->
        V = max(0, array:get(J + 1, Acc) + array:get(J + 1, Arr)),
        array:set(J, V, Acc)
    end, P0, lists:seq(Size - 3, 1, -1)).

This keeps the best sum ending on the left and starting on the right, then combines them around each middle position.

Max Product Of Three

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Max Product Of Three

-module(max_product_of_three).
-export([max_product_of_three/1]).

max_product_of_three(A) ->
    Sorted = lists:sort(A),
    N = length(Sorted),
    Top3 = lists:nth(N, Sorted) * lists:nth(N - 1, Sorted) * lists:nth(N - 2, Sorted),
    TwoLowOneHigh = lists:nth(1, Sorted) * lists:nth(2, Sorted) * lists:nth(N, Sorted),
    max(Top3, TwoLowOneHigh).

This checks the useful extremes, because the best product can come from either the three largest numbers or two negatives plus one large positive.

Max Profit

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Max Profit

-module(max_profit).
-export([max_profit/1]).

max_profit([H | T]) ->
    {_, Profit} = lists:foldl(fun(V, {MinPrice, MaxProfit}) ->
        MinPrice1 = min(MinPrice, V),
        {MinPrice1, max(MaxProfit, V - MinPrice1)}
    end, {H, 0}, T),
    Profit.

This tracks the lowest buy price seen so far and updates the best profit as it scans the prices once.

Max Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Max Slice Sum

-module(max_slice_sum).
-export([max_slice_sum/1]).

max_slice_sum([H | T]) ->
    {_, Max} = lists:foldl(fun(V, {Tmp, MaxV}) ->
        Tmp1 = max(Tmp + V, V),
        {Tmp1, max(MaxV, Tmp1)}
    end, {H, H}, T),
    Max.

This is a Kadane-style scan: keep the best running sum and the best overall sum while moving once through the array.

Min Avg Two Slice

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Min Avg Two Slice

-module(min_avg_two_slice).
-export([min_avg_two_slice/1]).

min_avg_two_slice(A) ->
    N = length(A),
    Arr = array:from_list(A),
    Init = (array:get(0, Arr) + array:get(1, Arr)) / 2,
    {_, Idx} = lists:foldl(fun(I, {MinV, IdxAcc}) ->
        Two = (array:get(I, Arr) + array:get(I + 1, Arr)) / 2,
        Cur = case I + 2 < N of
            true ->
                Three = (array:get(I, Arr) + array:get(I + 1, Arr) + array:get(I + 2, Arr)) / 3,
                min(Two, Three);
            false ->
                Two
        end,
        case Cur < MinV of
            true -> {Cur, I};
            false -> {MinV, IdxAcc}
        end
    end, {Init, 0}, lists:seq(0, N - 2)),
    Idx.

This leans on the key trick for this problem: the minimum average slice is always length 2 or 3.

Min Perimeter Rectangle

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Min Perimeter Rectangle

-module(min_perimeter_rectangle).
-export([min_perimeter_rectangle/1]).

min_perimeter_rectangle(N) ->
    find_min(1, N, 1 bsl 128).

find_min(I, N, Min) when I * I >= N ->
    Min;
find_min(I, N, Min) ->
    Min1 = case N rem I of
        0 -> min(Min, 2 * (I + (N div I)));
        _ -> Min
    end,
    find_min(I + 1, N, Min1).

This searches factor pairs up to the square root and picks the pair with the smallest perimeter.

Missing Integer

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Missing Integer

-module(missing_integer).
-export([missing_integer/1]).

missing_integer(A) ->
    Positives = [V || V <- lists:usort(A), V > 0],
    find_missing(Positives, 1).

find_missing([], Min) ->
    Min;
find_missing([V | Rest], Min) ->
    case V =:= Min of
        true -> find_missing(Rest, Min + 1);
        false -> Min
    end.

This records the positive numbers that exist, then returns the smallest positive value that is still missing.

Nesting

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Nesting

-module(nesting).
-export([nesting/1]).

nesting(S) ->
    case close_stack(S, []) of
        [] -> 1;
        _  -> 0
    end.

close_stack([], Stack) -> Stack;
close_stack([$) | T], [$( | Rest]) -> close_stack(T, Rest);
close_stack([$) | _], _Stack) -> error;
close_stack([C | T], Stack) -> close_stack(T, [C | Stack]).

This treats the string like a balance counter: open parentheses add one, closing ones remove one.

Number Of Disc Intersections

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Number Of Disc Intersections

-module(number_of_disc_intersections).
-export([number_of_disc_intersections/1]).

number_of_disc_intersections(A) ->
    C = length(A),
    Indexed = lists:zip(lists:seq(0, C - 1), A),
    {Start, End} = lists:foldl(fun({K, V}, {S, E}) ->
        KeyS = case K < V of true -> 0; false -> K - V end,
        KeyE = case K + V >= C of true -> C - 1; false -> K + V end,
        {array:set(KeyS, array:get(KeyS, S) + 1, S),
         array:set(KeyE, array:get(KeyE, E) + 1, E)}
    end, {array:new(C, {default, 0}), array:new(C, {default, 0})}, Indexed),
    compute_sum(0, 0, 0, C, Start, End).

compute_sum(K, _Active, Sum, C, _Start, _End) when K >= C ->
    Sum;
compute_sum(K, Active, Sum, C, Start, End) ->
    StartK = array:get(K, Start),
    EndK = array:get(K, End),
    Sum1 = Sum + Active * StartK + (StartK * (StartK - 1)) div 2,
    case Sum1 > 10000000 of
        true -> -1;
        false -> compute_sum(K + 1, Active + StartK - EndK, Sum1, C, Start, End)
    end.

This sorts disc start and end points and counts active overlaps without comparing every pair directly.

Odd Occurrences In Array

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Odd Occurrences In Array

-module(odd_occurrences_in_array).
-export([odd_occurrences_in_array/1]).

odd_occurrences_in_array(A) ->
    lists:foldl(fun(X, Acc) -> Acc bxor X end, 0, A).

This uses XOR to cancel out pairs, leaving only the value that appears an odd number of times.

Palindrome Rearranging

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Palindrome Rearranging

-module(palindrome_rearranging).
-export([palindrome_rearranging/1]).

palindrome_rearranging(InputString) ->
    Counts = lists:foldl(fun(C, Map) ->
        maps:update_with(C, fun(N) -> N + 1 end, 1, Map)
    end, #{}, InputString),
    OddCount = length([ok || {_, V} <- maps:to_list(Counts), V rem 2 =/= 0]),
    OddCount =< 1.

This counts character frequency and checks whether the string has the right number of odd counts to form a palindrome.

Passing Cars

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Passing Cars

-module(passing_cars).
-export([passing_cars/1]).

passing_cars(A) ->
    {Result, _Multiply} = lists:foldl(fun(I, {Passing, Multiply}) ->
        case I of
            0 -> {Passing, Multiply + 1};
            _ when Multiply > 0 -> {Passing + Multiply, Multiply};
            _ -> {Passing, Multiply}
        end
    end, {0, 0}, A),
    case Result > 1000000000 of
        true -> -1;
        false -> Result
    end.

This counts eastbound cars as it scans, then adds them whenever a westbound car appears.

Peaks

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Peaks

-module(peaks).
-export([peaks/1]).

peaks(A) ->
    N = length(A),
    case N =< 2 of
        true -> 0;
        false ->
            {Sum0, Dist0, Last0} = build_sums(A, N),
            LastVal = array:get(N - 2, Sum0),
            Sum1 = array:set(N - 1, LastVal, Sum0),
            case LastVal =:= 0 of
                true -> 0;
                false ->
                    Dist1 = max(Dist0, N - Last0),
                    case find_block_size(Dist1, N, Sum1) of
                        {ok, BlockSize} -> N div BlockSize;
                        not_found ->
                            FinalSize = smallest_divisor_from(Dist1, N),
                            N div FinalSize
                    end
            end
    end.

build_sums(A, N) ->
    Arr = array:from_list(A),
    Sum0 = array:new(N, {default, 0}),
    {SumF, {DistF, LastF}} = lists:foldl(fun(I, {Sum, {Dist, Last}}) ->
        SumPrev = array:get(I - 1, Sum),
        Ai = array:get(I, Arr),
        IsPeak = Ai > array:get(I - 1, Arr) andalso Ai > array:get(I + 1, Arr),
        case IsPeak of
            true -> {array:set(I, SumPrev + 1, Sum), {max(Dist, I - Last), I}};
            false -> {array:set(I, SumPrev, Sum), {Dist, Last}}
        end
    end, {Sum0, {0, -1}}, lists:seq(1, N - 2)),
    {SumF, DistF, LastF}.

find_block_size(Dist, N, Sum) ->
    find_block_size((Dist bsr 1) + 1, Dist, N, Sum).

find_block_size(I, Dist, _N, _Sum) when I >= Dist ->
    not_found;
find_block_size(I, Dist, N, Sum) ->
    case N rem I =:= 0 andalso check_blocks(I, I, N, Sum, 0) of
        true -> {ok, I};
        false -> find_block_size(I + 1, Dist, N, Sum)
    end.

check_blocks(J, _Step, N, _Sum, _Last) when J > N ->
    true;
check_blocks(J, Step, N, Sum, Last) ->
    SumJ = array:get(J - 1, Sum),
    case SumJ =< Last of
        true -> false;
        false -> check_blocks(J + Step, Step, N, Sum, SumJ)
    end.

smallest_divisor_from(Dist, N) ->
    case N rem Dist of
        0 -> Dist;
        _ -> smallest_divisor_from(Dist + 1, N)
    end.

This finds the peak positions, then tests how many equal blocks can each contain at least one peak.

Perm Check

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Perm Check

-module(perm_check).
-export([perm_check/1]).

perm_check(A) ->
    Sorted = lists:sort(A),
    Indexed = lists:zip(lists:seq(1, length(Sorted)), Sorted),
    case lists:all(fun({I, V}) -> I =:= V end, Indexed) of
        true -> 1;
        false -> 0
    end.

This validates that every value from 1 to N appears exactly once.

Perm Missing Element

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Perm Missing Element

-module(perm_missing_element).
-export([perm_missing_element/1]).

perm_missing_element(A) ->
    find_missing(lists:sort(A), 1).

find_missing([], Expected) ->
    Expected;
find_missing([V | Rest], Expected) ->
    case V =:= Expected of
        true -> find_missing(Rest, Expected + 1);
        false -> Expected
    end.

This uses the expected sum of 1..N+1 and subtracts the actual sum to find the missing value.

Plagiarism Check

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Plagiarism Check

-module(plagiarism_check).
-export([plagiarism_check/2]).

%% Re-derived as a token-isomorphism check instead of porting PHP's
%% placeholder/regex substitution dance: tokenize both snippets, build a
%% one-way rename map from the mismatched, non-numeric tokens of Code1 onto
%% Code2, then verify applying that map to every token of Code1 reproduces
%% Code2 exactly.
plagiarism_check(Code1, Code2) ->
    C1 = string:join(Code1, " "),
    C2 = string:join(Code2, " "),
    case C1 =:= C2 of
        true ->
            false;
        false ->
            D1 = tokenize(C1),
            D2 = tokenize(C2),
            Map = lists:foldl(fun({T1, T2}, Acc) ->
                case T1 =/= T2 andalso not is_numeric_token(T1) of
                    true -> maps:put(T1, T2, Acc);
                    false -> Acc
                end
            end, #{}, lists:zip(D1, D2)),
            [maps:get(T, Map, T) || T <- D1] =:= D2
    end.

tokenize(S) ->
    case re:run(S, "[A-Za-z0-9_]+", [global, {capture, all, list}]) of
        {match, Matches} -> [Tok || [Tok] <- Matches];
        nomatch -> []
    end.

is_numeric_token(T) ->
    case string:to_integer(T) of
        {_, ""} -> true;
        _ ->
            case string:to_float(T) of
                {_, ""} -> true;
                _ -> false
            end
    end.

This flattens both snippets, tries consistent identifier replacements, and checks whether the rewritten code matches.

Shape Area

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Shape Area

-module(shape_area).
-export([shape_area/1]).

shape_area(N) when N =< 1 ->
    1;
shape_area(N) ->
    shape_area(N - 1) + 4 * (N - 1).

This returns the area of the growing n-interesting polygon using the direct formula instead of building the shape.

Stone Blocks

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Stone Blocks

-module(stone_blocks).
-export([stone_blocks/1]).

stone_blocks(H) ->
    {_, Blocks} = lists:foldl(fun(Hi, {Stack, BlocksCount}) ->
        Stack1 = pop_while_greater(Stack, Hi),
        case Stack1 of
            [Hi | _] -> {Stack1, BlocksCount};
            _ -> {[Hi | Stack1], BlocksCount + 1}
        end
    end, {[], 0}, H),
    Blocks.

pop_while_greater([Top | Rest], Hi) when Top > Hi ->
    pop_while_greater(Rest, Hi);
pop_while_greater(Stack, _Hi) ->
    Stack.

This uses a stack of active heights and only counts a new block when the wall needs a new height segment.

Tape Equilibrium

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Tape Equilibrium

-module(tape_equilibrium).
-export([tape_equilibrium/1]).

%% Faithful port of the PHP source: it accumulates the loop index i into
%% firstPart/secondPart rather than a[i], so this mirrors that behaviour
%% (including the quirk) rather than the classic tape-equilibrium formula.
tape_equilibrium(A) ->
    N = length(A),
    Total = lists:sum(A),
    {_, _, Min} = lists:foldl(fun(I, {First, Second, MinV}) ->
        First1 = First + I,
        Second1 = Second - I,
        Diff = abs(First1 - Second1),
        {First1, Second1, min(MinV, Diff)}
    end, {0, Total, 1 bsl 128}, lists:seq(0, N - 2)),
    Min.

This keeps left and right running sums and updates the smallest difference at each split point.

Triangle

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Triangle

-module(triangle).
-export([triangle/1]).

triangle(A) ->
    Sorted = lists:sort(A),
    N = length(Sorted),
    case N < 3 of
        true -> 0;
        false ->
            Triples = lists:zip3(Sorted, tl(Sorted), tl(tl(Sorted))),
            case lists:any(fun({X, Y, Z}) -> X > 0 andalso X > (Z - Y) end, Triples) of
                true -> 1;
                false -> 0
            end
    end.

This sorts the values and checks nearby triples, because a valid triangle only needs one local match after sorting.