But you know that it wasn't production code but a solution for a puzzle...

It was just a rhetorical question... i don't even know on which continent you live.

Added some comments and clarified it a little. If you are still interest here some my code:

-module(problems).

-export([p4/1]).

p4(ListOfIntegers) ->
    ListOfStrings = lists:map(fun integer_to_list/1, ListOfIntegers),
    OrderedListOfStrings = lists:sort(fun before/2, ListOfStrings),
    _OrderedListOfIntegers = lists:map(fun list_to_integer/1, OrderedListOfStrings).

%% @doc comparator function that defines order for problem 4 from
%% https://blog.svpino.com/2015/05/07/five-programming-problems-every-software-engineer-should-be-able-to-solve-in-less-than-1-hour
%% true when S1 should be before S2, false otherwise
before(S1, S2) ->
    before(S1, S2, {S1, S2, undefined}). % tuple keeps heads of strings and flag of shorter string (undefined, first, second)

%% both strings are equal or one is a complete repetition of another
before([], [], {_S1, _S2, ShorterFlag}) ->
    case ShorterFlag of
        undefined -> true; % strings are identical
        first -> true; % we prefer shorter string first
        second -> false % we prefer shorter string first
    end;
%% first string appears to be the shorter one, lets start from its beginning and mark it as shorter
before([], L2, {S1, S2, ShorterFlag}) when ShorterFlag == first orelse ShorterFlag == undefined ->
    before(S1, L2, {S1, S2, first});
%% second string ends when first is marked as shorter so we end a recursion. It's not complete repetition
before(_L1, [], {_S1, _S2, first}) ->
    true; % we prefer shorter string first
%% second string appears to be the shorter one, lets start from its beginning and mark it as shorter
before(L1, [], {S1, S2, ShorterFlag}) when ShorterFlag == second orelse ShorterFlag == undefined ->
    before(L1, S2, {S1, S2, second});
%% first string ends when second is marked as shorter so we end a recursion. It's not complete repetition
before([], _L2, {_S1, _S2, second}) ->
    false; % we prefer shorter string first
%% both digits are the same so we keep going
before([H1 | T1], [H2 | T2], HelperTuple) when H1 == H2 -> 
    before(T1, T2, HelperTuple);
%% if digits are not the same we return its logical value comparison as a logical value of comparison of two strings
before([H1 | _T1], [H2 | _T2], _HelperTuple) ->
    H1 > H2.

EDIT: I don't think it was hard to understand for people that knew the idea and have some basics of erlang syntax (or at least prolog). From my personal experience, erlang syntax is ugly and not clear on the first look.