They are self-contained and are just as appropriate for an expert who wants to stay sharp as they are for a beginner who is just learning to code.

-module(main).
-export([main/0, main/1]).
-define(MD5_DIGEST_SIZE,128).

main() ->
start_mine("iwrupvqb").

main([Secret]) ->
start_mine(Secret),
halt(0).

start_mine(Secret) ->
{
start_mine(Secret, 5),
start_mine(Secret, 6)
}.

start_mine(Secret, NumZeroNibbles) ->
process_flag(trap_exit, true),
flush_messages(),
Threads = 8,
Pids = [ spawn_link(fun() -> mine(Secret, NumZeroNibbles, Instance, Threads) end)
|| Instance <- lists:seq(1, Threads)
],
receive
{'EXIT', _, {NumZeroNibbles, M}} -> M
end,
[ exit(Pid, kill) || Pid <- Pids ],
M.

mine(Secret, NumZeroNibbles, N, Step) ->
HeadBits = 4 * NumZeroNibbles,
RestBits = ?MD5_DIGEST_SIZE - HeadBits,
<<Head:HeadBits, _Rest:RestBits/binary-unit:1>> = erlang:md5(Secret ++ integer_to_list(N)),
case Head of
0 ->
io:format("~p~n", [N]),
exit({NumZeroNibbles, N});
_ ->
mine(Secret, NumZeroNibbles, N+Step, Step)
end.

flush_messages() ->
receive
_ -> flush_messages()
after
0 -> ok
end.

pure function IsNice1(string s) : bool
{
int num_vowels = 0;
char prev = s[0u];
bool has_double = false;

if(5u>strchr("aeiou", prev))
{
num_vowels = 1;
}

foreach(i in 1u to strlen(s) exclusive)
{
char curr = s[i];

if(5u>strchr("aeiou", curr))
{
num_vowels = num_vowels + 1;
}

if(curr==prev)
{
has_double = true;
}

if(
('a'==prev && 'b'==curr)
|||
('c'==prev && 'd'==curr)
|||
('p'==prev && 'q'==curr)
|||
('x'==prev && 'y'==curr)
)
{
return false;
}

prev = curr;
}

return has_double &&& 3<=num_vowels;
}

pure function IsNice2(string s) : bool
{
uint len = strlen(s);

if(len<3u)
{
return false;
}

// It contains at least one letter which repeats with
// exactly one letter between them, like xyx,
// abcdefeghi (efe), or even aaa.

{
bool got_it = false;

foreach(i in 0u to len - 3u while !got_it)
{
got_it = s[i] == s[i+2u];
}

if(!got_it)
{
return false;
}
}

// It contains a pair of any two letters that appears
// at least twice in the string without overlapping,
// like xyxy (xy) or aabcdefgaa (aa), but not like aaa
// (aa, but it overlaps).

{
bool got_it = false;
string sub = tos(s[0u]) + tos(s[0u]);

foreach(i in 0u to len - 2u while !got_it)
{
sub[0u], sub[1u] = sub[1u], s[i+1u];
got_it = len > strstr(s, i+2u, sub);
}

return got_it;
}
}

impure function CountNiceStrings() : uint, uint
{
file f = fopen("input", 'r');
string s;
uint num1 = 0u;
uint num2 = 0u;

for(s=freadln(f);!empty(s);s=freadln(f))
{
if(IsNice1(s))
{
num1 = num1 + 1u;
}

if(IsNice2(s))
{
num2 = num2 + 1u;
}
}

return num1, num2;
}

main
{
uint nice1, nice2 = CountNiceStrings();
write("nice1: " + tos(nice1) + "\n");
write("nice2: " + tos(nice2) + "\n");
}