text:
Make me an Easter egg!

No, not the ^^vv<><>BA kind of Easter eggs, real Easter eggs that we paint.

Here is an (awfully drawn) egg.
  __
 /  \
/    \
|    |
\____/

In easter, we paint them with patterns. Like these:
  __
 /--\
/----\
|----|
\____/
  __
 /%%\
/%%%%\
|%%%%|
\____/
  __
 /~~\
/~~~~\
|~~~~|
\____/

The challenge
Given a character (printable ascii) to paint the egg, print the painted egg.
Examples:
&:
  __
 /&&\
/&&&&\
|&&&&|
\____/

#:
  __
 /##\
/####\
|####|
\____/

Specs

Trailing newlines/spaces are allowed.

Why the downvote? If you do not like this question, downvote then leave a reason please.

One potential reason might be that they don't think this task is clear enough or clear enough. I'd say it is clear enough, and it's not literally trivial either. That said, I'm not particularly excited either.

The challenge will be very trivial in most languages. The egg is too short to allow much originality in the golfing. In my opinion, it's an uninteresting challenge (that hasn't been sandboxed, because you seem to be boycotting the sandbox for I don't know what reasons), therefor, I downvote it.

It's likely because this is a variation on existing challenges with nothing unique beyond the shape of the object, that being said I +1'd it because it's the first Easter themed challenge I've seen... The only non-trivial part is that /\\ is not a palindrome ._.

Are trailing spaces on any of the lines allowed?

@MartinEnder Yes, they are allowed.

Upvoted because simple challenges like this are great for beginners like me to ease into golf.

POOF! You're an easter egg. (Sorry, couldn't resist)

Brain-Flak -c, 270 268 266 bytes
(((((((((({}<(((([(()()())]((((((((((({}){}){}){}){}[()]))<>)<>{}())))))<>)<>(((()()()()()){}))({}()){})<>)<>>))))<<>({}<>)((()()()()()){})<>({}<>)>))))<<>((({})<>)({})<((()()()()()){})>[()()])>))<>((((({})<>)[(()()()()())({}){}])<((()()()()()){})<>((({}<>){}()))>))

Try it online!
I was going to write an explanation, but I took a nap first and forgot how this whole thing works. Your guess is as good as mine.

This is the best explanation I've ever read on here. +1

Python 2, 62 bytes
Super straight-forward. Try it online.
-1 byte, thanks to @mbomb007
print r'''  __
 /~\
/~~\
|~~|
\____/'''.replace('~',input()*2)

62 bytes

@mbomb007 Good one, thanks

You can save two bytes by using lambda function like this

@KeerthanaPrabhakaran I'm not sure if lambdas are OK for ascii challenges

what is the problem in using lambda in ascii challenges? how are they even related!? :o

Charcoal, 30 26 16 bytes
Two bytes saved thanks to @Neil by filling after making the shape
__↗¹←↑¹↖²↓_‖Ｍ←¤Ｓ

Try it online!
Explanation
The program works by first creating the right half of the egg, and then reflecting it to generate the left half.
__↗¹                          Write the two bottom _s and write the /
←↑¹                           Move left and write the |
↖²                            Then write two \s
↓_                            And the top _
‖Ｍ←                          Reflect the canvas to the left
¤Ｓ                           Fill the shape with the string input

←_↘ can be just ↓_ but in fact you can fill after you reflect for 16 bytes: __↗¹←↑¹↖²↓_‖Ｍ←¤Ｓ.

@Neil Thanks for introducing me to ¤

Jelly, 24  22 bytes
Ḥ;“ ¶/\|_”“Ṁ¢ṚR;ḳ}AṠ’ṃ

Try it online!
How?
Ḥ;“ ¶/\|_”“Ṁ¢ṚR;ḳ}AṠ’ṃ - Main link: character c  e.g. '~'
Ḥ                      - double c: ['~','~']
  “ _¶/\|”             - string literal: [' ','_',<newline>,'/','\','|']
 ;                     - concatenate c:  [['~','~'],' ','_',<newline>,'/','\','|']
          “Ṁ¢ṚR;ḳ}AṠ’  - base 250 number: 3067183430901851641706
                     ṃ - base decompression with reversed @rguments:
                       -     take the number and convert it to a base length(the list)
                       -     then index (1-based) into that same list.
                       -     i.e.: 3067183430901851641706 in base 7
                                 = 22003241534115361163500004
                                   indexed into [['~','~'],' ','_',<newline>,'/','\','|']
                                 = [' ',' ','_','_',<newline>,' ','/',['~','~'],'\',<newline>,'/',['~','~'],['~','~'],'\',<newline>,'|',['~','~'],['~','~'],'|',<newline>,'\','_','_','_','_','/']
                       - implicit print:  __
                                         /~~\
                                        /~~~~\
                                        |~~~~|
                                        \____/

I nominate your explanation of  ṃ for the longest explanation of a single byte.

It seems to have become quite a handy atom, thought I'd give it some time in the limelight!

I see Dennis use it a lot, this is the first time I feel like I actually understood it though; the time was not wasted! You have given me 1 unit of learn.

Well it is one of my babies :)

JavaScript (ES6), 53 49 47 bytes
I'm sure I can squeeze a bit more out of this - having to escape the \s is annoying me.

f=

c=>`  __
 /${c+=c}\\
/${c+=c}\\
|${c}|
\\____/`

console.log(f`-`)
console.log(f`%`)
console.log(f`~`)
console.log(f`&`)
console.log(f`#`)

4 bytes saved by moving the s=c+c variable assignment inside the first set of {}.
2 bytes saved by using c+=c instead of s=c+c & s=s+s, with thanks in part to Neil who spotted this improvement at the same time as I was making it.

Paint Your Own!

f=

c=>`  __
 /${c+=c}\\
/${c+=c}\\
|${c}|
\\____/`

o.innerText=f` `;i.addEventListener("input",function(){o.innerText=f(this.value||" ");})
<input maxlength="1" id="i">

It would be a bit better if you put those input in
s. Nice job though.

Thanks, @SIGSEGV. Consoles preserve white space and, by default, at least, use a monospaced font, so no need to output to a pre.

Why not c+=c?

Thanks, @Neil, I was just editing that in myself, but I'll update again to give you a nod as well.

@Arnauld You don't need to count the f=\n portion for the byte count. That's only so the snippet runs.

Sorry, my bad. It's definitely 47. (I pasted it on the wrong Notepad++ page with CR+LF linebreaks rather than LF.)

Phew, you had me worried there, @Arnauld, thinking I'd undercounted in a few other answers on the site! I do the same thing myself, using Notepad++

Sed, 43 characters
s:.:  __\n /&&\\\n/&&&&\\\n|&&&&|\n\\____/:

Sample run:
bash-4.3$ sed 's:.:  __\n /&&\\\n/&&&&\\\n|&&&&|\n\\____/:' <<< '★'
  __
 /★★\
/★★★★\
|★★★★|
\____/

That's exactly what I wrote, just a few seconds faster.

Alice, 53 52 bytes, non-competing
Thanks to Leo for indirectly saving 1 byte.
/o *^i}'.*[;.h~r}}~"{.[^\\
@"S .^~ y~a}~~.["{!~"}^^^

Try it online!
Unfortunately, I had to fix a bug with y (transliteration) to make this work, so I've marked it as non-competing.
Explanation
The basic idea is to create a string of the egg but with ~ as a placeholder for two copies of the input. However, the other characters of the input aren't particularly friendly for Alice strings, because those can't contain linefeeds, and all of /\_| would need escaping (because they're treated as mirrors and walls). So I can save some bytes by using placeholders for these as well, and then transliterating them. The placeholders for /\_| are .[^{, which are simply the character right before the one they represent. For the linefeed I'm using }.
Now the code... the entire program can be solved in Ordinal mode since we only need string processing and no processing of integers. Furthermore, we don't need any conditional control flow. The entire program can be expressed linearly. The general structure of the program is this:
/...//
@....

In such a program, the IP bounces up and down through the ... section, first only executing half of the characters. Then the two / at the end move the IP right by one cell, so that on the way back it executes the other half (again bouncing up and down) until finally the @ terminates the program. So if we unfold the funny zigzag structure in the middle, the program we're executing really looks like this:
"  ^^} .~[}.~~[}{~~{}[^^^^.""!}"r.h~;a*y'~i.*So

Let's go through this:
"  ^^} .~[}.~~[}{~~{}[^^^^."
      This first string is simply the egg template I've talked about.
"!}"  Push this string. It covers all the characters we need to replace
      in the template except ~.
r     Range expansion. Turns '!}' into '!"#$...z{|}'.
.     Duplicate.
h~;   Split off the first character, swap it to the top and discard it.
a*    Append a linefeed.
      We've now basically rotated the string to the left, but appended
      a linefeed instead of the exclamation mark we've shifted off.
      This maps each character in the string to the next one, except }
      which gets mapped to a linefeed.
y     Transliterate. Since the strings have the same length, this just maps
      each character in the first string to the corresponding character in
      the second string, replacing all of our placeholder characters.
'~    Push "~".
i.*   Read the input and duplicate it.
S     Substitute all "~" with the doubled input.
o     Output the result.

:D it's here!! This language looks nifty

@ConorO'Brien thank you. I've already plastered some older challenges with it in case you want to see more samples. :)

PowerShell, 50 49 48 bytes
'  __
 /11\
/1111\
|1111|
\____/'-replace1,$args

Try it online!
Straightforward string replacement into a literal string. Not much room for golfing.
-1 byte thanks to HyperNeutrino; -1 byte thanks to wubs

Carrot, 34 bytes
  __
 /##\\
/####\\
|####|
\\____/

Try it online here.
First, we are in caret-mode, where every character gets pushed to the "stack". And finally the "stack" gets printed as output.
In caret-mode, # pushes the input, so the instances of # are basically replaced with the input (FYI # is a one-byte cat program).

SOGL V0.12, 21 18 16 bytes
0≈⁾‛≤¦¶W?5┼EB§  ‘

Try it Here!
The whole program is the following compressed:
  __
 /ŗŗ\
/ŗŗŗŗ\
|ŗŗŗŗ|
\____/

where ŗ gets replaced with the input.
13 bytes almost works too, but it does unneeded things with certain inputs..

You have to paint the egg. (i.e. fill the inside of the egg with characters)

@SIGSEGV - It is explained that that is achieved by replacing the spaces with the input and replacing the dashes with spaces with the code @,ŗ -@ŗ

Will SOGOL be at TIO any time soon?

@JonathanAllan If someone can get it there, then yes.

Talk to Dennis in the talk-tryitonline-net room.

Is SOGL run with the processing-java interpreter?

@KritixiLithos Yes, the thing that comes with the PDE download.

@SIGSEGV you weren't the only one to misread that explanation.

Brainfuck - 257 bytes 181 bytes
Golfed:
Live version click here
+++++++[>++++++<-]>[>+>++>++>++<<<<-]>+++++>>>>++++++++++[>+++>+<<<++++<+<+>>>-]>++<<<--<+>>>,>..<<<<..>>>>>.<.<<<<<.>>>>..<<.>>>>.<<<<<<.>>>>....<<.>>>>.<<<.>....<.>>>.<<<<.<....<.

I'm not a professional golfer though; this is my first attempt.
Output:
  __
 /XX\
/XXXX\
|XXXX|
\____/ where X is the given char.

Ungolfed ( + comments) :
; chars:
; _ 95
; / 47
; \ 92
; | 142
; min val = 42 (7 times 6)

; lets do some math
+++++++[>++++++<-]> ; effectively 7 times 6

; now lets copy this to the next pointers multiplying by 2
the subsequent ones after the 1st
[>+>++>++>++<<<<-]

>+++++
>>>

> ; empty space starting from this pointer
++++++++++[>+++>+<<<++++<+<+>>>-]
>++<
<<--<+
>>>,
>..<<<<..>>>>>.<.
<<<<<.
>>>>..<<.>>>>.
<<<<<<.>>>>....<<.>>>>.
<<<.>....<.
>>>.<<<<.<....<.

05AB1E, 34 33 32 bytes
„__I244S×'/ì'\«`©¦¨'|.ø®R¹'_‡).c

Try it online!
Explanation
„__                               # push "__"
   I244S×                         # push a list of the input repeated 2 and 4 and 4 times
         '/ì                      # prepend "/"
            '\«                   # append "\"
               `                  # split list to separate items
                ©                 # store a copy of the last one in register
                 ¦¨               # remove first and last item of the string
                   '|.ø           # surround with pipes
                       ®R         # retrieve the string from register and reverse it
                         ¹'_‡     # replace input with "_"
                             ).c  # print each line centered

•jÀÅˆiXƒÐ[Z•6B6ôvy5ÝJ"_ |/\"¹«‡, for 32, entirely different though. This faked me out and made me think I could use palindromize... Damn the fact that ())( and /\\/ are palindromes.

@carusocomputing: You should post it separately. It's different enough to be interesting on its own :)

Retina 0.8.2, 43 41 bytes
-2 bytes thanks to Kevin Cruijssen
.
$&$&
..
  __¶ /$&\¶/$&$&\¶|$&$&|¶\____/

Try it online!

I know it's been a while, but you can save 2 bytes like this.

Python 3.6, 53 bytes
lambda x:fr'''  __
 /{2*x}\
/{4*x}\
|{4*x}|
\____/'''

Unnamed function taking the character x and returning a string.
Uses Python 3.6's f-strings as an added alternative to earlier version's .format() - the {} enclosed parts of the f-string are code to be evaluated.
The string is also an r-string and triple quoted saving one byte over:

lambda x:f'  __\n /{2*x}\\\n/{4*x}\\\n|{4*x}|\n\____/'

I can't see an online interpreter for Python 3.6 though.
Try it at repl.it (says 3.5 but it is 3.6)

05AB1E, 32 29 26 bytes (Thanks to Emigna/Adnan)
•jÀÅˆiXƒÐ[Z•6B6ôvy5ÝJ¹"_ |/\ÿ"‡,

Try it online!
•jÀÅˆiXƒÐ[Z•6B6ô # Push ['110011', '135541', '355554', '255552', '400003']
vy               # For each encrypted block...
  5ÝJ            # Push 012345.
     ¹"_ |/\ÿ"   # Push "_ |/\{input_char}".
              ‡, # Swap the charsets.

29 byte version (smarter w/o iteration needed due to encoding newlines as well):
05AB1E, 29 bytes (Emigna)
•P£<r7»TwDšç6•5ÝJI"
_/ÿ\|"‡.c

Try it online 2!

26 byte extension of Emigna's suggestion, using S to separate the chars into an array, then a[b] to interpolate each digit with the corresponding location in the previous array. This is essentially an element-wise transliteration (smart).
05AB1E, 26 bytes (Adnan)
"
_/ÿ\|"•P£<r7»TwDšç6•Sè.c

Try it online 3!

This is 3 bytes shorter. More similar to your answer than mine :)

@Emigna that direct transliteration using newlines is a novel idea, I like that; this could honestly knock 5 bytes off many of my existing solutions.

For 26 bytes.

@adnan Sè - sneaky sneaky...

I feel like almost all my answers need to credit Admigna, wouldn't really know the language without both of your constant examples.

PHP, 51 bytes
$a.=$a=$argn;echo"  __
 /$a\
/$a$a\
|$a$a|
\____/";

PHP, 58 Bytes without physical linebreaks
$a.=$a=$argn;echo"  __\n /$a\\\n/$a$a\\\n|$a$a|\n\\____/";

run this with -R option
61 Bytes
echo strtr("  __\n /88\\\n/8888\\\n|8888|\n\\____/",8,$argn);

Store the value doubled; remove unnecessary space; use literal newline character: https://pastebin.com/EghdAYMf

@manatwork Thank you i have not really thinking about double the input

save 7 bytes with physical linebreaks and not escaping the backslashes (the last one needs no escaping anyway). Oh and btw: -R is not a parameter, it´s an option.

@Titus i hate physical linebreaks Done

@Titus, right, though man php calls them parameter: “It is also possible to process the standard input line by line using either the parameter -R or -F.”

C (gcc), 95 88 85 bytes
Thanks to Albert for -7 bytes
Thanks also to ceilingcat -3 bytes
f(c){for(int*s=L"  __\n /00\\\n/0000\\\n|0000|\n\\____/\n";*s;s+=printf(*s%6?s:&c));}

Try it online!

Don't declare *q just nest it right into your for-loop to save 5 bytes.   char*s;f(c){for(s="  __\n /11\\\n/1111\\\n|1111|\n\\____/\n";*s;putchar(*s^49?*s:c),s++);}

You can also save 2 more bytes ontop of that by declaring *s inside the for-loop's declaration argument: f(c){for(char*s="  __\n /11\\\n/1111\\\n|1111|\n\\____/\n";*s;putchar(*s^49?*s:c),s++);}

You can shave 1 more byte too by checking for an ASCII character that has a numeric value of one digit. 1 is 49 in ASCII but that's 2 bytes, use something with a value from 0-9, for example the tabulation character   is ASCII value 9.

Suggest *s;f(c){for(s instead of f(c){for(int*

BF, 142 140 bytes
++++[->++++<]>[->+++>++++++>+>++++++>++>++++++++<<<<<<],>->---->------>->..<..<.>>.<<<<.<..
>>.>.<<.<....>>.>.>>>----.<....>.<<<.<.>>....<<<.

This is split across two lines for clarity; the newline is not counted.
It's fairly easy to write this sort of thing in BF, but it's non-trivial how to optimize the order of the cells to minimize movement. I wrote a brute-forcer script to try all the combinations and find the shortest, and I golfed it a bit to account for a golfing opportunity I hadn't included in the brute-forcer.

@JoKing I suggest you post that as a separate answer, because it seems very different from mine.

brainfuck, 114 bytes
-----[[<+>->++>++<<]->]<+++++++++++<+..<..>>.<.<<.>>,..<---.>>.<<<.>>....<.>>.<<<<---.>>>....<<<.>>>>.<<.+++....<.

Try it online!
I've used BF Crunch here to find a more optimal way to generate the individual characters.

SpecBAS - 70 bytes
1 INPUT a$:  ?"  __"'" /";a$*2;"\"'"/";a$*4;"\"'"|";a$*4;"|"'"\____/"

? is shorthand for PRINT command, and apostrophe moves cursor to next line.

Röda, 46 bytes
{a=`  __
 /-\
/--\
|--|
\____/`a~="-",_*2;[a]}

Try it online!

Python, 59 bytes
lambda n:r'''  __
 /a\
/aa\
|aa|
\____/'''.replace('a',n*2)

Swift - 88 bytes
var f={x in"  __\n /&&\\\n/&&&&\\\n|&&&&|\n\\____/".replacingOccurrences(of:"&",with:x)}

Lambda-like function with usage: print(f("x")).
Try it out here!

NOTE: In some environments, as in the one linked above, this requires import Foundation, but on a standard project it doesn't. That's because replacingOccurrences() belongs to Foundation, but Xcode projects have that optimised, and is not required.

The replacingOccurrences() really kills the score :((

C++ 208 bytes
In response to comments:
This is a complete re-post.
#include<iostream>
using namespace std;int main(){char e;cin>>e;cout<<"  __  \n";cout<<" /"<<e<<e<<"\\ "<<endl;cout<<"/"<<e<<e<<e<<e<<"\\"<<endl;cout<<"|"<<e<<e<<e<<e<<"|"<<endl;cout<<"\\____/ \n";return 0;}

Lua, 66 bytes
print((([[  __
 /ee\
/eeee\
|eeee|
\____/]]):gsub("e",io.read())))

((([[#NailedIt]])))

Retina, 41 bytes
.
$0$0
..
  __¶ /$0\¶/$0$0\¶|$0$0|¶\____/

Try it online!

Japt, 35 bytes
"  __
 /01
/001
|00|
1____/"d0U²1'\

Try it online!
41-byte solution:
[S²'_²RS'/U²'\R'/U²²'\R'|U²²'|R'\'_²²'/]q

Try it online!

Nice one. My first attempt was this for 36 bytes, but it looks like using d is a byte shorter.

[R], 65 bytes
cat(gsub('x',scan(,''),"  __\n /xx\\\n/xxxx\\\n|xxxx|\n\\____/"))

Pretty unspectacular, please find a shorter one in R...
It's your basic gsub

C#, 56 bytes

Golfed
i=>"  __\n /i\\\n/ii\\\n|ii|\n\\____/".Replace("i",i+i);

Ungolfed
i =>
   "  __\n /i\\\n/ii\\\n|ii|\n\\____/"
      .Replace( "i", i + i );

Ungolfed readable
i =>
   "  __\n /i\\\n/ii\\\n|ii|\n\\____/"

      // Replace every instance of 'i' with the input cloned twice
      .Replace( "i", i + i );

Full code
using System;
using System.Collections.Generic;

namespace Namespace {
   class Program {
      static void Main( String[] args ) {
         Func<String, String> f = i =>
            "  __\n /i\\\n/ii\\\n|ii|\n\\____/"
               .Replace( "i", i + i );

         List<String>
            testCases = new List<String>() {
               "-",
               "%",
               "~",
               "o",
               " ",
         };

         foreach( String testCase in testCases ) {
            Console.WriteLine( $" Input: {testCase}\nOutput:\n{f( testCase )}\n" );
         }

         Console.ReadLine();
      }
   }
}

Releases

v1.0 - 56 bytes - Initial solution.

Notes
The printed results within the link provided will not look like pretended, due to the font used not being monospace.

C(gcc), 87 bytes
e(d){printf("  __\n /%c%c\\\n/%c%c%c%c\\\n|%c%c%c%c|\n\\____/\n",d,d,d,d,d,d,d,d,d,d);}

printf without stdio.h causes warnings but no errors, allowing successful compilation.
Explanation
Printf statement that crams everything into one line, formatting the decoration character with %c.
Try it online

C (gcc), 84 bytes
g(f){char e[]={f,f,f,f};printf("  __\n /%.2s\\\n/%.4s\\\n|%.4s|\n\\____/\n",e,e,e);}

Try it online!

Pyth, 36 bytes
jm:s@L"-/|\\_ "jCd6\-+QQ"ԈџÛƲ獩

Try it online!

c(gcc) 81 78 bytes
*s;f(c){for(s=LR"(  __
 /00\
/0000\
|0000|
\____/)";*s;s++)printf(*s%6?s:&c);}

Try it online

Batch, 76 bytes
@for %%l in ("  __" " /%1%1\" "/%1%1%1%1\" "|%1%1%1%1|" \____/)do @echo %%~l

Note: To run this with special characters such as &, prefix the character with a ^.

JavaScript (ES6), 55 bytes
x=>`  __
 /0\\
/00\\
|00|
\\____/`.replace(/0/g,_=>x+x)

This wont work if x === '$', 3 more bytes are needed: .replace(/0/g,_=>x+x)

@tsh Ah dang it. I actually had it like that originally, but I thought I could remove the _=>...

Bash, 50 bytes
echo "  __
 /$1$1\\
/$1$1$1$1\\
|$1$1$1$1|
\____/"

I've also tried to do pattern substitution during parameter expansion, but it seems like the most straightforward way to do this is also the shortest.
Try it online!

Neither I managed to reduce a pure Bash solution, but Bash + coreutils would be shorter: tr . "$1"<<<'  __␤ /..\␤/....\␤|....|␤\____/'.

Vim, 31 bytes
Expects the input character to be the only thing in the buffer to start. Ends in insert mode with the egg displayed in the buffer. I have replaced ^M and ^O with <CR> and <C-O> for readability. All whitespace is significant.
s  __<CR> /<C-O>2p\<CR>/<C-O>4p\<CR>|<C-O>4p|<CR>\____/

Since V is backwards-compatible, you can Try it online!
Explanation:
s                                                       " Delete input (storing it to the default register) and enter insert mode
   __<CR>                                               " Type "  --\n"
          /                                             " Type " /"
           <C-O>2p                                      " Paste twice from the default register without leaving insert mode (e.g. put "%%")
                  \<CR>                                 " Type "\\\n"
                       /                                " Type "/"
                        <C-O>4p                         " This time paste 4 times
                               \<CR>                    " Type "\<CR>"
                                    |<C-O>4p|<CR>       " Same drill, but with | before and after
                                                 \____/ " The bottom of the egg

C#, 140 Bytes
class x{static void Main(){System.Console.WriteLine(("  __\n"+@" /%%\"+'\n' +@"/%%%%\"+'\n'+@"|%%%%|"+'\n' +@"\____/ ").Replace("%","A"));}}

It's my first time codegolfing :)  Anyway, this works by replacing '%' from the example to any character you want. This prints out:
  __
 /AA\
/AAAA\
|AAAA|
\____/

The egg should be painted with the character given in input line.

Excel VBA, 66 Bytes
Anonymous Excel VBE immediates window function that takes a clean input of 1 character from cell [A1] on the ActiveSheet object and prints to the VBE immediate window.
?Replace(Replace("  __0 /11\0/1111\0|1111|0\____/",0,vbCr),1,[A1])

Java 7, 79 bytes
String f(String c){return"  __\n /x\\\n/xx\\\n|xx|\n\\____/".replace("x",c+c);}

Explanation:
String f(String c){                           // Method with String(-character) parameter and String return-type
  return "  __\n /x\\\n/xx\\\n|xx|\n\\____/"  //  Return this String
    .replace("x",c+c);                        //  And replace every 'x' with two times the input String-character
}                                             // End of method

Test code:
Try it here.
class Main{
  static String f(String c){return"  __\n /x\\\n/xx\\\n|xx|\n\\____/".replace("x",c+c);}

  public static void main(String[] a){
    System.out.println(f("^"));
    System.out.println(f("|"));
    System.out.println(f("o"));
  }
}

Output:
  __
 /^^\
/^^^^\
|^^^^|
\____/
  __
 /||\
/||||\
||||||
\____/
  __
 /oo\
/oooo\
|oooo|
\____/

C, 49 bytes
f(){puts("  __\n /~~\\n/~~~~\\n|~~~~|\n\____/");}

Output Live
  __
 /~~\
/~~~~\
|~~~~|
\____/

Unicode, 77 bytes
g(){printf("  .\u2322.\n\n\u239bHAPPY\u239e\n EASTER\n\u239d.___.\u23a0\n");}

Output
  .⌢.

⎛HAPPY⎞
 EASTER
⎝.___.⎠

Aceto, 68 64 bytes
8 by 8, so a 3rd order Hilbert curve.
/"ppp(pp
np(p"pp)
\\)p|n
"\"\\\
)k,p\\n"
pp/"__\|
   n__
"__\/"p

Since we're already non-competing, I used features introduced after the question was posted.
Output:
  __
 /==\
/====\
|====|
\____/

JS (ES6), 60 bytes
x=>`  __
 /~\\
/~~\\
|~~|
\\____/`.replace(/~/g,x.repeat(2))

Basically the same thing as the python answer.

Common Lisp, SBCL, 73 bytes
(format t"  __
 /~@?\\
/~@?~@?\\
|~@?~@?|
\\____/""~2@{~a~:*~}~@*"(read))

><>, 58 bytes
|v"  __   /":{"\ /"}::::{"\|"}::::i"|\____/"
o>ooooool?!;a

Try it online, or at the fish playground!
Takes input from STDIN. If you're allowed to exit with an error, you can get rid of the l?!; in the second line.
Explanation: The fish swims through the first line backwards, so it reads "/____\|"i::::}"|\"{::::}"/ \"{:"/   __  ". This builds up the string in reverse, keeping a copy of the input at the back of the stack for when it's needed again. The fish then gets to row 2, which prints six characters and a newline and then loops until the stack is empty.

Ruby, 63 bytes
puts"  __  \n /00\\ \n/0000\\\n|0000|\n\\____/".gsub"0",$*[0]

As basic as it gets, honestly

05AB1E, 25 bytes
"ÿ_
\/|"•θ8Ë1Âõ]Æ°•6вèJ.c

Try it online.
Explanation:
"ÿ_
\/|"                   # Push the string "ÿ\n\/|", where `ÿ` is automatically filled
                       # with the (implicit) input-character
    •θ8Ë1Âõ]Æ°•        # Push compressed integer 1269961759550053939510
               6в      # Converted to Base-6 as list:
                       #  [1,1,2,4,0,0,3,2,4,0,0,0,0,3,2,5,0,0,0,0,5,2,3,1,1,1,1,4]
                 èJ    # Index each into the string, and then join together
                   .c  # And centralize it to add the appropriate leading spaces
                       # (after which the result is output implicitly)

See this 05AB1E tip of mine (sections How to compress large integers? and How to compress integer lists?) to understand why •θ8Ë1Âõ]Æ°• is 1269961759550053939510 and •θ8Ë1Âõ]Æ°•6в is [1,1,2,4,0,0,3,2,4,0,0,0,0,3,2,5,0,0,0,0,5,2,3,1,1,1,1,4].

Excel Formula, 54 bytes
Makes use of multi-line entry in the formula bar (Alt+Enter), where # is your chosen character to paint!
=SUBSTITUTE("  __
 /~~\
/~~~~\
|~~~~|
\____/","~","#")

Whitespace, 240 229 bytes
[S S S T    S T T   T   T   N
_Push_47][S S S T   S T T   T   T   T   N
_Push_95][S N
S _Duplicate_95][S N
S _Duplicate_95][S N
S _Duplicate_95][S S S T    S T T   T   S S N
_Push_92][S S S T   S T S N
_Push_10][S S S T   T   T   T   T   S S N
_Push_124][S T  S S T   S N
_Copy_0-based_2nd_(92)][S N
S _Duplicate_92][T  N
T   S _Read_STDIN_as_character][T   T   T   _Retrieve][S N
S _Duplicate_input][S N
S _Duplicate_input][S N
S _Duplicate_input][S S S T T   T   T   T   S S N
_Push_124][S S S T  S T S N
_Push_10][S T   S S T   S S S N
_copy_0-based_8th_(92)][S N
S _Duplicate_92][T  T   T   _Retrieve][S N
S _Duplicate_input][S N
S _Duplicate_input][S N
S _Duplicate_input][S S S T S T T   T   T   N
_Push_47][S S S T   S T S N
_Push_10][S S S T   S T T   T   S S N
_Push_92][S N
S _Duplicate_92][T  T   T   _Retrieve][S N
S _Duplicate_input][S T S S T   S S N
_Copy-0-based-4th-(47)][S S S T S S S S S N
_Push_32][S S S T   S T S N
_Push_10][S S S T   S T T   T   T   T   N
_Push_95][S N
S _Duplicate_95][S T    S S T   T   N
_Copy-0-based-3rd-(32)][S N
S _Duplicate_32][N
S S N
_Create_Label_LOOP][T   N
S S _Print_as_character][N
S N
N
_Jump_to_Label_LOOP]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.
Try it online.
Explanation:
Since we have to incorporate the input character in the output, I couldn't apply this Whitespace tip of mine which I always use for ASCII-art or other print challenges in Whitespace, which would lower each value and inside the printing loop add it again. So instead this is a pretty simple program which does the following:

Push all characters reversed to the stack, including the input-characters

With bytes saved using Duplicates and Copy's-of

Then loop and print the characters from the top of the stack to the bottom (which is why we push the characters in reverse order).

Haskell, 70 63 bytes
7 bytes down with great help from Laikoni
(<$>"  __\n /~~\\\n/~~~~\\\n|~~~~|\n\\____/").(?)
d?'~'=d
d?c=c

Try it online!
The function f takes a character to paint the egg with.

You can use >'z' instead of =='~'. Flipping the arguments of ? allows for a shorter pointfree notation: (<$>" ... ").(?). Try it online!

Using pattern matching for (?) is even shorter: d?'~'=d;d?c=c. Try it online!

Scala, 56 bytes
print("""  __
 /~\
/~~\
|~~|
\____/""".replace("~",i+i))

Try it online!

T-SQL, 63 61 bytes
SELECT REPLACE('  __
 /11\
/1111\
|1111|
\____/',1,v)FROM t

Old challenge, but didn't see a SQL solution.
Input is taken via pre-existing table t with text field v, per our IO standards.
SQL allows line break literals in strings, so a pretty straight-forward replace. Lines 2 and 3 have an extra space after the final \, so the line break isn't escaped.
EDIT: Discovered that I can save 2 bytes by using a numeral as the replacement character instead of something like '.' that needs quotes. Turns out REPLACE does the implicit conversion to string.

nroff, 83 bytes
I found a way to outgolf to get a verbatim output so I could draw ascii art with fewer bytes: it was to use .nf.
.de F
  __
.nf
 /\\$1\\$1\\\\
/\\$1\\$1\\$1\\$1\\\\
|\\$1\\$1\\$1\\$1|
\\\\____/
..

Attempt This Online!

nroff, 103 bytes
.de F
  __
.sp 0
 /\\$1\\$1\\\\
.sp 0
/\\$1\\$1\\$1\\$1\\\\
.sp 0
|\\$1\\$1\\$1\\$1|
.sp 0
\\\\____/
..

Attempt This Online!
I tried using more macros to shorten but failed.
I had to do such annoying escaping a lot.
Usage
.F #

.F %


text:
Turn me 22.5 with a rose
Given a string that is one of the directions on a 16-point compass rose

output the two directions that are immediately adjacent to the input direction, in clockwise order.
Specifically, you need to handle these (and only these) input/output pairs:
Input  Output
N      NNW NNE
NNE    N NE
NE     NNE ENE
ENE    NE E
E      ENE ESE
ESE    E SE
SE     ESE SSE
SSE    SE S
S      SSE SSW
SSW    S SW
SW     SSW WSW
WSW    SW W
W      WSW WNW
WNW    W NW
NW     WNW NNW
NNW    NW N

The output may be a string with some delimiter (not nothing) between the directions or a two-element list. The direction immediately counterclockwise to the input must appear first. You may use lowercase letters for the directions instead of uppercase but keep all input and output in one case or the other.
For example, for input N (or n if you're using lowercase) some valid outputs are:
NNW NNE
NNW-NNE
["NNW", "NNE"]
nnw-nne (if using lowercase)

Some invalid outputs are:
NNWNNE
NNE NNW
nnwNNE
NNw NNe

The shortest code in bytes wins.

Jelly, 37 34 bytes
“¢ ¬9£Hæz¥{çb¤S®!‘ṃ€“¡&¦»
¢iµ’,‘ị¢

Try it online!
Takes lowercase input.
-2 thanks to Jonathan Allan.
-1 since it turns out this is valid as a function :)
Thanks to Jonathan Allan (and Dennis), now you can remove the €. Unfortunately, that would be non-competing here.
Detailed algorithm explanation:
We usually start explaining from the bottom (main) link, going down, but here I feel like it's more appropriate to explain from the top.
First, we simply load up the list [1, 32, 7, 57, 2, 67, 17, 92, 3, 94, 19, 119, 4, 109, 9, 34]. This looks like random numbers huh? Well, this is actually a list of base-5-compressed numbers, so we base-5-decompress it. Now it looks like [[1], [1, 1, 2], [1, 2], [2, 1, 2], [2], [2, 3, 2], [3, 2], [3, 3, 2], [3], [3, 3, 4], [3, 4], [4, 3, 4], [4], [4, 1, 4], [1, 4], [1, 1, 4]]. Still random-looking stuff, but this is actually an NESW-mapped list of the sixteen coordinates, so we're not far away from completing the list (Jelly is 1-indexed). Doing the final mapping, we get [['N'], ['N', 'N', 'E'], ['N', 'E'], ['E', 'N', 'E'], ['E'], ['E', 'S', 'E'], ['S', 'E'], ['S', 'S', 'E'], ['S'], ['S', 'S', 'W'], ['S', 'W'], ['W', 'S', 'W'], ['W'], ['W', 'N', 'W'], ['N', 'W'], ['N', 'N', 'W']], which is the complete list we want (Jelly strings are in the form [char1, char2, char3, ...].)
Since we've now built the coordinate list, we work with it. The main link comes into play. First, we load up the list we've built, and then take the index that the input (as command-line argument) coordinate resides in. Then, we pair its predecessor and its successor into a list, and we use them as modular indices into the same list of coordinates to take the coordinate to the left and right of the input respectively. You'd now think we're finally done, but there's in fact one more thing, the separator. This is valid as a function, since 1) You can call it using <integer>Ŀ 2) You're allowed to define other functions as well (like importing modules). Now, we are done. As a full program, this doesn't have a separator, but that's OK, since it works as a function.
Link-by-link code explanation:
¢iµ’,‘ị¢K Main link. Arguments: z = cmd0
¢         Run the helper link niladically (i.e. load the coordinate list).
 i        Find the index of z in the list.
  µ       Start a new monadic chain. Arguments: z = list_index.
   ’      Decrement z.
     ‘    Increment z.
    ,     Pair x and y into [x, y].
       ¢  Run the helper link niladically.
      ị   Take the elements of y at the indices in x.

“¢ ¬9£Hæz¥{çb¤S®!‘ṃ€“¡&¦» Helper link. Arguments: [1, 32, 7, 57, 2, 67, 17, 92, 3, 94, 19, 119, 4, 109, 9, 34]
“¢ ¬9£Hæz¥{çb¤S®!‘        Generate the integer list (the argument).
                    “¡&¦» Literal "newsy".
                  ṃ€      Base-length(y)-decompress every integer in x, then index into y.

Let us continue this discussion in chat.

Mathematica, 118 112 bytes
Thanks to Martin Ender for saving 6 bytes!
r=StringSplit@"N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW N NNE";<|Array[r[[#]]->r[[#+{-1,1}]]&,16,2]|>

Unnamed function (an association, really) that takes a string as input and returns an ordered pair of strings. Basically just hardcodes the answer.

Python 2, 116 115 103 bytes
 -12 bytes thanks to Neil
d='N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW'.split()
n=d.index(input())
print d[n-1],d[n-15]

Try it Online!

Use d[n-15] to avoid the condition.

By the way, there's an extraneous quote at the end of the code segment in your answer. I would put in an edit request myself, but the edit has to be at least six characters and this would only be one.

@Neil Thanks!  Saved a lot of bytes :)

@notjagan Thanks for pointing that out. Fixed it

JavaScript ES6, 106 102 bytes
p=>[(a=`N|NNE|NE|ENE|E|ESE|SE|SSE|S|SSW|SW|WSW|W|WNW|NW|NNW`.split`|`)[i=a.indexOf(p)-1&15],a[i+2&15]]

Try it online!

const f = p=>[(a=`N|NNE|NE|ENE|E|ESE|SE|SSE|S|SSW|SW|WSW|W|WNW|NW|NNW`.split`|`)[i=a.indexOf(p)-1&15],a[i+2&15]]

console.log(f('N'))
console.log(f('NNE'))
console.log(f('ENE'))
console.log(f('E'))
console.log(f('ESE'))
console.log(f('SE'))
console.log(f('SSE'))
console.log(f('S'))
console.log(f('SSW'))
console.log(f('SW'))
console.log(f('WSW'))
console.log(f('W'))
console.log(f('WNW'))
console.log(f('NW'))
console.log(f('NNW'))

Save 2 bytes with let instead of const.

-4 bytes by moving variable declarations to where they are first used, Try it Online

Javascript - 234 154 156 152 120 106 102 bytes
Only my second time doing code golf!!
Latest Revision:
Thank you to @fəˈnɛtɪk for this neat variable trick!
s=>[(a=`NNW N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW`.split` `)[n=a.indexOf(s)-1&15],a[n+2&15]]

Before That:
Okay so latest revision: Input is a string and output is a string which is in the rules, so I made it into a function, and with reductions I have gone even smaller (also function is anonymous, which now means mine has somehow meshed into the other js answer oops! He (powelles) had it first!!):
(s,a=`NNW N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW`.split` `,n=a.indexOf(s))=>[a[n-1&15],a[n+1&15]]

Can be used by:
f=(s,a=`NNW N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW`.split` `,n=a.indexOf(s))=>[a[n-1&15],a[n+1&15]]
alert(f(prompt()))

Remade (not function) with Output - 120:
a="NNW N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW".split(' ');n=a.indexOf(prompt());alert(a[n-1&15]+' '+a[n+1&15]);

Note that I made an error originally, having it equal a.length instead of a.length-1 for the first index. Thanks @Neil for pointing out that it didn't work for NNW.
Note 2: Thank you to @Neil and @ETHProductions for helping me shorten the code!

Originial:
a="NNWN  NNENE ENEE  ESESE SSES  SSWSW WSWW  WNWNW ";l=prompt("","");n=l.length<3?l.length<2?l+'  ':l+' ':l;f=a.indexOf(n);i=f-3;j=f+3;i=i<0?a.length+--i:i;j=j+3>=a.length?j-a.length:j;alert(a.substring(i,i+3)+' '+a.substring(j,j+3));

Welcome back to golfworld!

This doesn't work for NNW.

@Neil You are correct. I will fix it!

@Neil It is fixed

@ETHproductions I was just about to fix that ;) But thank you anyway!

You can also call prompt() with no arguments and it will be exactly the same ;)

Also, n-1>-1 = n>0

Or just n, as we can assume that the value is always in the list.

Actually as the list is always 16 long, you can use n-1&15 and n+1&15.

I was working towards my own solution before I realised it was very similar to yours. A few tips for you: 1) Anonymous functions are valid, 2) You don't need to request an input in your submission, it just needs to be able to receive one, 3) You don't need to log the output in your submission, simply return. With all that in mind, here's the 106 characters I was down to for you to improve your solution with: p=>(a="N,NNE,NE,ENE,E,ESE,SE,SSE,S,SSW,SW,WSW,W,WNW,NW,NNW".split,,i=a.indexOf(p),[a[i-1&15],a[i+1&15]])

And here is a working Fiddle. I was just about to start into trying to optimise the population of the array so would love to hear any suggestions for that.

-4 bytes by moving variable declarations into where they are used, Try it Online

05AB1E, 44 43 bytes (Thanks to Adnan)
"ESNW4"•2ßU^]>Þ‡¾“¾&é{½‡•5BSè4¡©skD<®ès>®è)

Try it online!
"ESNW4"•2ßU^]>Þ‡¾“¾&é{½‡•5BSè # Push N4NNE4NE4ENE4E4ESE4SE4SSE4S4SSW4SW4WSW4W4WNW4NW4NNW
4¡©            # Split on 4's and store.
   sk          # Index of input in direction array.
     D<®è      # Element before index of input.
         s>®è  # Element after index of input.
             ) # Wrap two element to array.

Exmaple output:
N => [NNW,NNE]

Version that pushes N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW instead:
•17¿$Mn]6VAÆ—Dªd—•5B4LJ"NSWE"‡0¡©skD<®ès>®è)

Is also 44-bytes, there was 0 reason for my refactor and there is 0 reason for splitting on the 4's.

Any special reason to split on 4s?

@GregMartin •17¿$Mn]6VAÆ—Dªd—•5B4LJ"NSWE"‡0¡©skD<®ès>®è) turns out that, no, there is no reason at all. Using 0 as the delimiter is the same compression ratio, as it doesn't drop the length of the number in the base-5 conversion to base-214. Coulda sworn doing it like that saved me a byte though.

You can do „ €Ã¦•174SÝ©l2ÎG¦˜fÐ98•5BSè#ÐIk©<ès®>è) to save 4 bytes.

Jelly,  40 38 bytes
“NSWE”“dḍ.ƈ€ḶƘfƥ’ṃṁ
“¢)`)’ḃ3RÇṙi¥µṖṪ,Ḣ

Try it online! (added the footer to show the output is a list of two items) ...or see all cases.
(I'm not quite sure why 1323DRẋ4 in place of “¢)`)’ḃ3R doesn't work at the moment.)
How?
“NSWE”“dḍ.ƈ€ḶƘfƥ’ṃṁ - Link 1, rose list helper: shape array
“NSWE”              - "NSWE"
      “dḍ.ƈ€ḶƘfƥ’   - base 250 number: 1554210846733274963415
                 ṃ  - base decompress: "NNNENEENEEESESESSESSSWSWWSWWWNWNWNNW"
                  ṁ - mould like shape array

“¢)`)’ḃ3RÇṙi¥µṖṪ,Ḣ - Main link: direction string
“¢)`)’             - base 250 number: 33899292
      ḃ3           - to base 3: [1,3,2,3,1,3,2,3,1,3,2,3,1,3,2,3]
        R          - range (vectorises) [[1],[1,2,3],[1,2],[1,2,3],[1],[1,2,3],[1,2],[1,2,3],[1],[1,2,3],[1,2],[1,2,3],[1],[1,2,3],[1,2],[1,2,3]]
         Ç         - call the last link (1) as a monad: ["N","NNE","NE","ENE","E","ESE","SE","SSE","S","SSW","SW","WSW","W","WNW","NW","NNW"]
            ¥      - last two links as a dyad
          ṙ        -     rotate the list by:
           i       -         index of the direction string in the list
             µ     - monadic chain separation (call the rotated list x)
              Ṗ    - pop (x[:-1]) (removes the direction string)
               Ṫ   - tail that (i.e. x[-2])
                 Ḣ - head x (i.e. x[0])
                ,  - pair

Batch, 196 bytes
@set s=N
@if %1==N echo NNW
@for %%r in (NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW)do @call:c %1 %%r
@if %1==NNW echo N
@exit/b
:c
@if %1==%2 echo %s%
@if %1==%s% echo %2
@set s=%2

Loops through each pair of compass points, printing one when the other matches. For example, for a parameter of ENE, when the loop reaches ENE, the variable s contains NE which is printed, then when the loop advances to E, the variable s contains ENE and so E is printed. One pair then needs to be special-cased to avoid the compass points from being printed in the wrong order.

Haskell, 100 99 bytes
s=words"N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW"++s
(a:b:c:r)#x|x==b=(a,c)|1<3=r#x
(s#)

Try it online! Calling (s#) "N" returns ("NNW","NNE").
s is an infinite repetition of the list of directions, thus we don't have to add an extra N and NNE like some of the other answers to correctly handle the edges of the list.
Thanks to @nimi for saving one byte!

An infix function saves a byte: (a:b:c:r)!x| ... =r!x;(s!).

PHP, 122 bytes
preg_match("/([^ ]+ )$argv[1] ([^ ]+)/",'N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW N NNE',$m);
echo $m[1].$m[2];

You can save 2 bytes removing unnessary whitespaces. -3 bytes for replacing $argv[1] with $argn and using the -R option. if you use deprecated functions if could be ending in ereg("([^_]+)_{$argn}(_[^_]+)",N_NNE_NE_ENE_E_ESE_SE_SSE_S_SSW_SW_WSW_W_WNW_NW_NNW_N_NNE,$t);echo$t[1].$t[2];

SOGL, 33 bytes
≠┐πΜ]ρ½d⁹V¹-┐*╔╤¹Ψæ;¶‘θ,W:AHwOaIw

The first part ≠┐πΜ]ρ½d⁹V¹-┐*╔╤¹Ψæ;¶‘ is a compressed string that is
N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW

compressed with a custom dictionary with  ENSW
The rest of the program:
...‘θ,W:AHwOaIw  example input: NNW
...‘             push the compressed string        ["N NNE NE ... NNW"]
    θ            split on spaces                   [["N","NNE",...,"NNW"]]
     ,W          get the index of input            [["N","NNE",...,"NNW"], 16]
       :A        save the index on variable A      [["N","NNE",...,"NNW"], 16]
         H       decrease [the index]              [["N","NNE",...,"NNW"], 15]
          wO     output that'th item of the array  [["N","NNE",...,"NNW"]]
            a    load variable A                   [["N","NNE",...,"NNW"], 16]
             I   increase [the index]              [["N","NNE",...,"NNW"], 17]
              w  get that item in the array        [["N","NNE",...,"NNW"], "N"]

What code page?

@Joshua The bytes in the title has a link to the codepage

@Joshua Actually, that was missing a couple of characters because of markdown , but it's fixed now

PHP, 110 109 bytes
Saved 1 byte thanks to Jörg Hülsermann.
echo@preg_filter("/.*?(\w+) $argn( \w+).*/",'$1$2',($s='N NNE NE ENE E ESE SE SSE ').strtr($s,NESW,SWNE).$s);

You could replace preg_replace with preg_filter to save 1 byte

PHP, 115 Bytes
for($r=explode(_,($w=N_NNE_NE_ENE_E_ESE_SE_SSE_).strtr($w,SWNE,NESW).$w);$r[++$i]!=$argn;);echo$r[$i-1]._.$r[$i+1];

-2 Bytes using the deprecated function split instead of explode
PHP, 128 Bytes
for($i=2;$i--;print$i?end($e)._:$e[2])$e=explode(_,strstr(($w=N_NNE_NE_ENE_E_ESE_SE_SSE_).strtr($w,SWNE,NESW).$w,_.$argn._,$i));

PHP, 134 Bytes
echo($r=explode(_,N_NNE_NE_ENE_E_ESE_SE_SSE_S_SSW_SW_WSW_W_WNW_NW_NNW))[($k=array_search($argn,$r))-1<0?15:$k-1]._.$r[$k+1>15?0:$k+1];

Ruby - 94 Bytes
A riff on Blue Okiris's answer, just to take advantage of some nice Ruby shorthand (the %w[] syntax and p specifically):
->(s,d=%w[N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW],n=d.index(s)){p d[n-1],d[n-15]}

Japt, 66 52 bytes
Saved 14 bytes thanks to @ETHproductions
V=`ã@JaÀTeaÀÄsÁÁss°s°ws°°wn°n°nnw`qa [J1]£VgX+VaU

Try it online!
Explanation:
V=(`...`qa) [J1]£Vg(X+VaU)
V=(       )                // Set V to:
   `...`                   //   "nanneaneaeneaeaeseaseasseasasswaswawswawawnwanwannw" (de-)compressed
        qa                 //    Split on "a", creating [n...nnw]
            [J1]           // [-1,1]
                £          // Iterate through ^, X becomes the iterative item
                 Vg(     ) //   V.Item at index:
                    X+VaU  //     X + V.indexOf(input)

Very nice. A couple improvements: 1) You can take the input in lowercase instead of converting the array to uppercase. 2) You can actually remove the ' in q'o and it will work exactly the same :-)

Also, you can reduce the array construction at the end to [J1]£VgX+VaU to save a few bytes

@ETHproductions That is brilliant, thanks!

CJam, 41
"NeSWN"2ew{_1<\_La*\$f+~}%:eu_ra#(m<2%2<p

Try it online

c, 222 216 211 bytes
main(c,v)char**v;{char r[]="NXNNEXNEXENEXEXESEXSEXSSEXSXSSWXSWXWSWXWXWNWXNWXNNWX",*p=r,*s=r,*a[16],i=0,n;for(;*p++;)*p==88?*p=0,n=strcmp(a[i++]=s,v[1])?n:i-1,s=++p:0;printf("%s %s\n",a[n?n-1:15],a[n<15?n+1:0]);}

Try it online

205 bytes

Python 3 - 112 107 bytes
I based this off of my Javascript answer:
Remade:
lambda i,s="N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW".split():[s[s.index(i)-1],s[s.index(i)-15]]

Use as say
f = lambda i,s="N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW".split():[s[s.index(i)-1],s[s.index(i)-15]]
print(f(input()));

Original:
lambda i,s="N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW".split():[s[s.index(i)-1&15],s[s.index(i)+1&15]]

MATL, 43 bytes
';evl(Z?&fWElf`gvhM'F' NESW'ZaYbtjY=fFTEq+)

Try it online!
Explanation
';evl(Z?&fWElf`gvhM' % Push this string
F                    % Push false
' NESW'              % Push this string
Za                   % Base conversion. This decompresses the first string from alphabet
                     % given by all printable ASCII except single quote to the alphabet
                     % ' NESW'. The result is the following string, which is pushed:
                     % 'N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW'
Yb                   % Split at spaces. Gives a cell array of strings
t                    % Duplicate
j                    % Input string
Y=                   % String comparison. Gives an array containing true at the index
                     % of the matching string
f                    % Find: index of the entry that equals true
FTEq                 % Push [-1 1] (obtained as [false true], times 2, minus 1)
+                    % Add, element-wise
)                    % Index modularly into the cell array of strings
                     % Implicitly display. Each cell is displayed on a different line

Javascript (ES6), 189 bytes
d="N.NNW NNE.NNE.N NE.NE.NNE ENE.ENE.NE E.E.ENE ESE.ESE.E SE.SE.ESE SSE.SSE.SE S.S.SSE SSW.SSW.S SW.SW.SSW WSW.WSW.SW W.W.WSW WNW.WNW.W NW.NW.WNW NNW.NNW.NW N".split`.`,f=>d[d.indexOf(f)+1]

Just takes the input, looks it up, and returns it.

JavaScript (ES6), 94 bytes
Expects a string in uppercase such as "ENE". Returns a comma separated string such as "NE,E".
s=>/\D+,\D+/.exec('NNW0N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N'.split(0+s+0))[0]

How it works
The expression 0+s+0 is coerced to a string when split() is called. For instance, if the input is "ENE", the string will be split on "0ENE0":
"NNW0N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N"
             ^^^^^

This leads to the following array:
[ "NNW0N0NNE0NE", "E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N" ]

Again, this array is coerced to a string when exec() is called. So, the regular expression is actually applied on:
"NNW0N0NNE0NE,E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N"

We look for consecutive non-numeric characters (\D+) followed by a comma, followed by consecutive non-numeric characters. This returns the array [ "NE,E" ]. We could arguably stop there and return just that. But the challenge is asking for either a delimited string or a two-element array. So, we extract the string with [0].
Demo

let f =

s=>/\D+,\D+/.exec('NNW0N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N'.split(0+s+0))[0]

;
["N","NNE","NE","ENE","E","ESE","SE","SSE","S","SSW","SW","WSW","W","WNW","NW","NNW"]
.map(
  s => console.log(s, '=>', f(s))
)

Pyth, 39 bytes:
.rL]z_Bms@L"ESWN"jCd5"\"❤m❤w❤^❤\❤C❤9❤ ❤

where ❤ represents unprintable letters.
Try it online!
Hexdump:
0000000: 2e 72 4c 5d 51 5f 42 6d 73 40 4c 22 45 53 57 4e .rL]Q_Bms@L"ESWN
0000010: 22 6a 43 64 35 22 5c 22 09 6d 04 77 13 5e 03 5c "jCd5"\".m.w.^.\
0000020: 11 43 02 39 07 20 01                            .C.9. .

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Better late than never!
Your program / function, etc. will take 2 inputs. The first will be a list of who came to my party and when. Example:
Kevin 13:02
Ruby 5
Sam 3
Lisa 6
Bob 12

What does that mean? It means that Kevin got to my party first (at 13:02, 24-hour time), then Ruby 5 minutes later, then Sam 3 minutes later, then Lisa 6 minutes later, and last Bob 12 minutes later.
The second input will be when my party started. Example:
13:15

(24-hour time). Your output must be the list of people who were late. (Anyone exactly on time is fine.) Example calculations (just for example, don't output these)
Kevin 13:02
Ruby 13:07
Sam 13:10
Lisa 13:16
Bob 13:28

Lisa and Bob arrived after 13:15, therefore this program should print "Lisa,Bob".
Input assumptions

Input 1 will always be a name (regex [A-Z][a-z]*), then a space, then a 24-hour time in the form hours:minutes on the first line, then a name, a space, and a positive integer (number of minutes later) on the next lines. There will always be at least 1 line.
If you would like, you may take input 1 with any other character instead of a line break.
Input 2 will be in the format hours:minutes.
You may take your inputs as one string separated by any character if you want. This is optional.
Don't worry about day crossover. My parties never to after 23:59.

Output rules

Output can be a function return value or a string echoed to STDIN, a file, etc. You must return a string or an array / list.

If you return a string, it must be each person who was late (order does not matter), separated by any non-alphanumeric delimiter.
If you return an array / list, it must be a list of everyone who was late.

Is the strict input format necessary? Could, for example, the first input be a list of lists, each being a "line" containing the two data items?

@JonathanAllan yes.

I assume you meant "yes the strict input format is necessary".

Are we guaranteed at least two people in the input?

@JonathanAllan you are correct in your last comment.

@AdmBorkBork yes. I have more than 1 friend.

Can the output be like LisaBob?

@Challenger5 yes.

Strict input format makes this challenge less interesting

"My parties never to after 11:59." do you mean 23:59?

@tsh All times but first guest and party launch are relative; so I guess that won´t make a difference in any solution. But ok, it might.

@tsh fixed now.

Can we take the time input in the following format: 13:02->13.02 and 1:15->1.15, for example?

@ComradeSparklePony yes.

MATL, 31 bytes
jYb1L&)1&)XUYs1440/0whwYO+jYO>)

The first input uses space instead of line break (allowed by the challenge).
Output uses line break as separator.
Try it online!
Explanation
j       % Input first string
Yb      % Split at spaces. Gives cell array of strings
1L&)    % Separate into subarrays with odd and even indices. Odd are names, even
        % are time and increments in minutes
1&)     % Separate the subarray of even indices into first entry and remaining
        % entries. The first is a string representing the time of first arrival,
        % the rest are strings representing increments in minutes
XU      % Convert strings representing increments into the actual numbers
Ys      % Cumulative sum
1440/   % Divide by 1440 (number of minutes in a day)
0wh     % Prepend a 0
w       % Swap. Bring the string with time of first arrival to the top
YO      % Convert to serial date number. Fractional part indicates time
+       % Add. This gives all arrivals as serial date numbers
j       % Input second string
YO      % Convert to serial date number
>       % Less than?, element-wise
)       % Index: select the names for which the comparison gave true
        % Implicitly display

JavaScript (ES6), 98 97 bytes
Saved 1 byte thanks to Neil
Takes the list of guests l and the party time h in currying syntax (l)(h). Expects a trailing linebreak on the list. Returns a space-separated list of names such as Lisa Bob.
l=>h=>l.replace(/(.* )(.*)\n/g,(_,a,b)=>(t-=T(b))<0?a:'',t=(T=h=>eval(h.replace(/:/,'*60+')))(h))

Formatted and commented
l => h =>                         // given a list of guests l and a party time h
  l.replace(                      // for each guest in l:
    /(.* )(.*)\n/g,               //   extract the name a and arrival time b
    (_, a, b) =>                  //   subtract the arrival time from the time counter
      (t -= T(b)) < 0 ?           //   if the result is negative:
        a                         //     the guest is late: keep the name
      :                           //   else:
        '',                       //     the guest is on time: remove this entry
    t = (                         //   initialize the time counter t
      T = h =>                    //   define T():
        eval(                     //     a function that takes either a time
          h.replace(/:/, '*60+')  //     in hh:mm format or an amount of minutes
        )                         //     and returns an amount of minutes
    )(h)                          //   call it with the party time
  )                               // end of replace()

Demo

let f =

l=>h=>l.replace(/(.* )(.*)\n/g,(_,a,b)=>(t-=T(b))<0?a:'',t=(T=h=>eval(h.replace(/:/,'*60+')))(h))

console.log(f(`Kevin 13:02
Ruby 5
Sam 3
Lisa 6
Bob 12
`)('13:15'))

Clever solution! +1. Mine is way far.......:(

Doesn't (.*) (.*)\n work?

@Neil Being greedy by default, the first (.*) would match the entire line.

Then what would the space match?

@Neil Oh, sorry, you're right.

PHP, 118 98 95 91 bytes
while($n=$argv[++$i])$i&1?$p=$n:($t=($f=strtotime)($n)?:$t+60*$n)<=$f(end($argv))?:print$p;

takes input from command line arguments (you may interprete that as lines separated by spaces if you like); prints names without a delimiter. Run with -r or test it online.
edit 1: saved 20 bytes with direct printing
edit 2: saved 3 bytes by removing the delimiter
edit 3: saved 4 bytes by exploiting that plain integers are no valid dates for strtotime
breakdown
while($n=$argv[++$i])       # loop through arguments, skip [0]
    $i&1                        # if index is odd
    ?   $p=$n                   # then assign name to $p
    :   ($t=                    # else $t =
        ($f=strtotime)($n)          # if $n is a valid time, parse it
        ?:$t+60*$n                  # else add $n minutes to current $t
        )<=$f(end($argv))           # if $t <= parsed party start
        ?                           # then do nothing
        :print$p;                   # else print name

c, 178 bytes
main(c,o,d,e,g,O,l,f,x,y)char**o,d[80],*O,*l,*f;{for(sscanf(o[2],"%d:%d",&e,&g),x=e*60+g,l=";",f=o[1];O=strtok(f,l);f=0)(y=sscanf(O,"%s%d:%d",d,&e,&g)^2?e*60+g:y+e)>x?puts(d):0;}

Try it online

JavaScript ES6, 185 bytes
l=>t=>l.split`
`.map(p=>p.split` `).map((p,i,a)=>[p[0],i?d(a[0][1])+a.slice(1,i+1).reduce((a,p)=>a+=+p[1],0)*6e4:(d=x=>Date.parse(`2017T${x}`))(p[1])]).filter(p=>p[1]>d(t)).map(p=>p[0])

Try it online!

const f = l=>t=>l.split`
`.map(p=>p.split` `).map((p,i,a)=>[p[0],i?d(a[0][1])+a.slice(1,i+1).reduce((a,p)=>a+=+p[1],0)*6e4:(d=x=>Date.parse(`2017T${x}`))(p[1])]).filter(p=>p[1]>d(t)).map(p=>p[0])

console.log(f('Kevin 13:02\nRuby 5\nSam 3\nLisa 6\nBob 12')('13:15'))

As far as I can tell from the spec the input form may be more strict.

I think it is correct now.

Yep - I have also asked about input strictness.

...actually you have the times in your input, not the offsets it should be f('Kevin 13:02\nRuby 5\nSam 3...

@JonathanAllan Thanks. Got it now.

Ah, nice solution. +1 Mine is way far :(

PowerShell, 215 196 180 bytes
param($a,$b)$x,[array]$a=$a-split',';$z=@{};$i,$j=-split$x;$z[$i]=($y=date $j);0..($a.count-1)|%{$i,$j=-split$a[$_];$z[$i]=($y=$y|% *es $j)};($z|% *or|?{$_.value-gt(date $b)}).Name

Try it online!
Roughly 1/3rd of this is input parsing, so I'm not sure how much further I can golf it.
Takes input $a as a comma-delimited string of names and times/minutes, and $b as hh:mm as a string. First, we -split $a on ,, store the first result into $x and the remaining into $a, with an explicit re-cast of $a as an array (so that the loop later works properly). We the initialize our hashtable $z, set $i and $j to be $x -split on whitespace, and set $z[$i] to be the date of $j (stored into $y for use later).
Then we loop through the remaining $a. Each iteration, we do similar -- -split the string on whitespace, set the appropriate $z index to be that many more minutes beyond where we're currently at. This uses a shortened property name trick to save some bytes, using |% *es $j instead of .AddMinutes($j).
Finally, we .GetEnumerator() (again using the trick) of our hashtable, and Where-Object select those entries with a value that's -greaterthan $b (i.e., they're late to the party). We then select just the .Names thereof. Output is as an implicit array, which the default Write-Output inserts newlines between.
Saved a bunch thanks to briantist for reminding me that [array] is a thing. And a bunch more for shortened property name tip.

I admit I did minimal reading and testing of this, but, couldn't you just do $x,[array]$a=$a-split','?

@briantist Yes, thank-you. I kept trying to find a way to use the comma-operator in the multiple-assignment, and it just was not working. I had completely forgotten that [array] is a valid cast. Haha. Too much golfing, I guess.

I'm on mobile so out would be difficult to test but I think GetEnumerator and AddMinutes are good candidates for the % method syntax

@briantist Yep. Saves another 16. Thanks!

Python 2, 140,148,144 bytes
t,h,n=map(str.split,input().replace(':','').split(';')),100,0
for a,v in t[:-1]:
 n+=int(v)
 if n%h/60:n=n/h*h+n%h%60+h
 if`n`>t[-1][0]:print a,

Try it online!
Input Format:
'Kevin 13:02;Ruby 5;Sam 3;Lisa 6;Bob 12;13:15'

Doesn't correctly handle minute overflow: 'Kevin 13:47;Ruby 5;Sam 3;Lisa 6;Bob 12;14:00' prints nothing, even though Lisa and Bob are still late.

oh yeah. There was a glitch! Fixed it. Thanks you!

CJam, 66 54 58 54 51 49 46 bytes
{{':/60b}:K~)rSrKs++q+S/2/z~:i[{1$+}*]2$+$@#>}

Input 1 is given through STDIN, input 2 is given as a string on the stack. Output is an array on the stack. Separator for input 1 is a space, e.g. Kevin 13:02 Ruby 5 Sam 3 Lisa 6 Bob 12.
Stack trace:
         e# Stack:               | "13:15"
{        e# Define K and run it:
  ':/    e#   Split on colon:    | ["13" "15"]
  60b    e#   From base 60:      | 795
}:K~     e# End def
)        e# Increment:           | 796
r        e# Read token:          | 796 "Kevin"
S        e# Push space:          | 796 "Kevin" " "
r        e# Read another token:  | 796 "Kevin" " " "13:02"
K        e# K()                  | 796 "Kevin" " " 782
s        e# Convert to string:   | 796 "Kevin" " " "782"
++       e# Add together:        | 796 "Kevin 782"
q        e# Read rest of input:  | 796 "Kevin 782" " Ruby 5 Sam 3 Lisa 6 Bob 12"
+        e# Add together:        | 796 "Kevin 782 Ruby 5 Sam 3 Lisa 6 Bob 12"
S/       e# Split on spaces:     | 796 ["Kevin" "782" "Ruby" "5" "Sam" "3" "Lisa" "6" "Bob" "12"]
2/       e# Group by 2:          | 796 [["Kevin" "782"] ["Ruby" "5"] ["Sam" "3"] ["Lisa" "6"] ["Bob" "12"]]
z        e# Transpose:           | 796 [["Kevin" "Ruby" "Sam" "Lisa" "Bob"] ["782" "5" "3" "6" "12"]]
~        e# Unpack:              | 796 ["Kevin" "Ruby" "Sam" "Lisa" "Bob"] ["782" "5" "3" "6" "12"]
:i       e# Convert all to int:  | 796 ["Kevin" "Ruby" "Sam" "Lisa" "Bob"] [782 5 3 6 12]
[{1$+}*] e# Accumulate:          | 796 ["Kevin" "Ruby" "Sam" "Lisa" "Bob"] [782 787 790 796 808]
2$       e# Copy back element:   | 796 ["Kevin" "Ruby" "Sam" "Lisa" "Bob"] [782 787 790 796 808] 796
+        e# Add into array:      | 796 ["Kevin" "Ruby" "Sam" "Lisa" "Bob"] [782 787 790 796 808 796]
$        e# Sort:                | 796 ["Kevin" "Ruby" "Sam" "Lisa" "Bob"] [782 787 790 796 796 808]
#        e# Find index:          | ["Kevin" "Ruby" "Sam" "Lisa" "Bob"] 3
>        e# Slice:               | ["Lisa" "Bob"]

Explanation:

The procedure K converts between a time hh:mm and a number representing how many minutes that is since midnight.
We read the first person and replace their time with K(their time). We then add this to the front of the input.
We then preform some string operations to get a list of names and a list of times, like [782 5 3 6 12].
By accumulating this list, we get [782 787 790 796 808], which gives the times that everybody came.
The shortest way to find who is late is to insert the start time into the array and then re-sort it to place it where it should be. We then find the index to figure out where it places, and then slice the list of names from that index.

Bash, 135 124 115 bytes
a=($1)
for i in `seq 3 2 ${#a[@]}`
do((v+=a[i]))
((`date -d${a[1]} +%s`+v*60>`date -d$2 +%s`))&&echo ${a[i-1]}
done

Try it online!

JavaScript, 285 283 bytes
Takes the list of guests i and the party time p in currying syntax (i)(p). Returns a comma-separated list of names such as Lisa,Bob.
i=>p=>{n=i.split`
`,a=new Date(0,0,0,...n[0].split` `[1].split`:`),y=new Date(0,0,0,...p.split`:`),t=[a];w=a;n.slice(1).map((j,k,l)=>{h=l[k].split` `[1]*6e4;t.push(new Date(w.getTime()+h));w=new Date(w.getTime()+h)});return n.filter((j,k,l)=>t[k]>y).map(j=>j.split` `[0]).join()}

I know it's pretty long and currently at last place by a fair margin, but that's what I could come up with.

f=i=>p=>{n=i.split`
`,a=new Date(0,0,0,...n[0].split` `[1].split`:`),y=new Date(0,0,0,...p.split`:`),t=[a];w=a;n.slice(1).map((j,k,l)=>{h=l[k].split` `[1]*6e4;t.push(new Date(w.getTime()+h));w=new Date(w.getTime()+h)});return n.filter((j,k,l)=>t[k]>y).map(j=>j.split` `[0]).join()}

console.log(f(`Kevin 13:02
Ruby 5
Sam 3
Lisa 6
Bob 12
`)('13:15'))

C#, 269 267 bytes

Golfed
(l,t)=>{var h=System.DateTime.MinValue;var s=System.DateTime.ParseExact(t,"HH:mm",null);var o="";foreach(var p in l.Split('\n')){var i=p.Split(' ');h=h.Ticks<1?System.DateTime.ParseExact(i[1],"HH:mm",null):h.AddMinutes(int.Parse(i[1]));if(h>s)o+=i[0]+" ";}return o;};

Ungolfed
( l, t ) => {
   var h = System.DateTime.MinValue;
   var s = System.DateTime.ParseExact( t, "HH:mm", null );
   var o = "";

   foreach( var p in l.Split( '\n' ) ) {
      var i = p.Split( ' ' );

      h = h.Ticks < 1
         ? System.DateTime.ParseExact( i[ 1 ], "HH:mm", null )
         : h.AddMinutes( int.Parse( i[ 1 ] ) );

      if( h > s )
         o += i[ 0 ] + " ";
   }

   return o;
};

Ungolfed readable
( l, t ) => {
   // var to check the time of arrival
   var h = System.DateTime.MinValue;

   // var to store the start time of the party
   var s = System.DateTime.ParseExact( t, "HH:mm", null );

   // var with the names of those who arrived late
   var o = "";

   // Cycle through which line
   foreach( var p in l.Split( '\n' ) ) {
      // Split the name and time
      var i = p.Split( ' ' );

      // Check if the time of arrival still has the initial value
      h = h.Ticks < 1

         // If so, grab the time of the first person
         //   Expects to have a time format of 'hh:mm'
         ? System.DateTime.ParseExact( i[ 1 ], "HH:mm", null )

         // Otherwise, add the difference to the var
         : h.AddMinutes( int.Parse( i[ 1 ] ) );

      // Check if the current time is later than the party start time
      if( h > s )

         // If so, add the name to the list
         o += i[ 0 ] + " ";
   }

   // Return the names of the persons who arrived late
   return o;
};

Full code
using System;
using System.Collections.Generic;

namespace Namespace {
   class Program {
      static void Main( String[] args ) {
         Func<String, String, String> f = ( l, t ) => {
            var h = System.DateTime.MinValue;
            var s = System.DateTime.ParseExact( t, "HH:mm", null );
            var o = "";

            foreach( var p in l.Split( '\n' ) ) {
               var i = p.Split( ' ' );

               h = h.Ticks < 1
                  ? System.DateTime.ParseExact( i[ 1 ], "HH:mm", null )
                  : h.AddMinutes( int.Parse( i[ 1 ] ) );

               if( h > s )
                  o += i[ 0 ] + " ";
            }

            return o;
         };

         List<KeyValuePair<String, String>>
            testCases = new List<KeyValuePair<String, String>> {
               new KeyValuePair<String, String>(
                  "Kevin 13:02\nRuby 5\nSam 3\nLisa 6\nBob 12",
                  "13:15"
               ),
               new KeyValuePair<String, String>(
                  "Kevin 13:15\nRuby 5\nSam 3\nLisa 6\nBob 12",
                  "13:15"
               ),
            };

         foreach( KeyValuePair<String, String> testCase in testCases ) {
            Console.WriteLine( $" Input:\n{testCase.Key}\n\n{testCase.Value}\n\nOutput:\n{f( testCase.Key, testCase.Value )}\n" );
         }

         Console.ReadLine();
      }
   }
}

Releases

v1.1 - - 2 bytes - Thanks to VisualMelon
v1.0 - 269 bytes - Initial solution.

Notes

Output format: Outputs the names separated by spaces

You can save a few bytes by adding a using D=System.DateTime; directive (don't forget to replace the vars!). You should really provide types for the lambda parameters to make this code completely unambiguous (i.e. (string l,string f)). I also think there is a slight bug, you need h>s rather than h>=s (1byte saving!) as per "(Anyone exactly on time is fine.)". Can you do h.Ticks<1 ? You may find a nullable DateTime cheaper than using DateTime.Min, but I've not checked the full implications here. With the using clause, ==D.Min should work also.

About the using I doubt I could still pull off a lambda expression with it. I'm pretty sure I can't add it in mid-code. Explicit lambda types are another thing that I haven't seen people doing it, and I went with that -- if it is illegal, say so, but even the mods haven't said anything, maybe it's ok?. h>s I'll do that one. h.Ticks<1 and this one too.

I'm confident we allow usings and such with lambdas, I can't find anything saying this explicitly on meta, but this question strongly suggests it is permitted. There is a reasonable consensus that explicit parameter types should be required (I should add that I'm firmly in favour). By the by, Mods are there to keep things civil from SE's perspective, not to enforce PPCG's own rules.

I'm kinda against the usings, mostly because I would then feel that it would require a full code, hence me saying that I doubt I could pull off a function as a solution -- maybe adding two blocks, one for usings and another for the lambda function? About the consensus, I think adding the missing Func<...> f = ...; would solve it, although it should be specified the full name System.Func<...> f = ...;

You might be better off just having a well named function (only adds string s with C#7 (6? I can't remember) syntax) if you'd rather not mix lambdas and usings.

That's also an option

Java, 346 304 284 275 bytes

-9 bytes, thanks to @KevinCruijssen

void g(int m,String[]n,String[]a,int M){for(int i=0;i<n.length;i++)if((M+=i>0?p(a[i]):0)>m)System.out.print(n[i]);}
int p(String n){return new Short(n);}
int h(String t){return p(t.split(":")[0])*60+p(t.split(":")[1]);}
void f(String[]n,String[]a,String b){g(h(b),n,a,h(a[0]));}

Detailed Live
public static void g(int m, String[] n, String[] a, int M)
{
    for(int i = 0; i < n.length; i++)
    {
        if((M += i>0 ? p(a[i]) : 0) > m)
        {
            System.out.println(n[i]);
        }
    }
}

public static int p(String n)
{
    return Integer.parseInt(n);
}

public static int h(String t)
{
    return p(t.split(":")[0])*60+p(t.split(":")[1]);
}

public static void f(String[] n, String[] a, String b)
{
    g(h(b),n,a,h(a[0]));
}

Nice golfing (for Java.) Do you need the space between String[] n, and String[] a?

@programmer5000 no, I also removed the hours variable & accumulated them as minutes.

You can replace Integer.parseInt(n) with new Short(n). And based on the comments of the challenge, LisaBob is also a valid output, so you can change the println to print.

CJam, 43 41 bytes
q~':/60b:Y;Sf/()':/60b+a\+{)iT+:TY>{;}|}%

Try it online!
Explanation
q~        e# Read and eval all input.

':/       e# Split the start time on colons.
60b       e# Convert the result from base 60, to get the start time in minutes.
:Y;       e# Store this time in variable Y, and discard it from the stack.

Sf/       e# Split each string in the guest list on spaces.
(         e# Pull out the first guest from the list.
)         e# Pull out the time from the guest.
':/60b+   e# Convert the time to a number of minutes (same way as before), then add it back
          e#   to the guest.
a\+       e# Add the guest back to the start of the guest list.

          e# At this point, the first guest has his/her arrival time in minutes, and everyone
          e#  else still has their original number.

{         e# Apply this block to each guest:
 )i       e#  Pull out the number and cast it to an integer.
 T+       e#  Add the value of variable T to it (T is initially 0).
 :T       e#  Store the result back into T.
 Y>{;}|   e#  If the resulting number of minutes is not after the start time, delete the
          e#    guest's name.
}%        e# (end of block)

          e# Implicit output.

Lua, 211 206 Bytes
First codegolf of the year for me, should still be golfable.
Edit: Saved 5 Bytes by using a shorthand for string.match
function f(l,T)m=T.match
r=function(X)return
m(X,"^%d+")*3600+60*m(X,"%d+$")end
T=r(T)z={}y=0
for i=1,#l do
h=m(l[i],"%d.*")h=i>1 and y+h*60or r(h)y=h
z[#z+1]=h>T and m(l[i],"%u%l*")or nil
end return z end

Explanations
function f(l,T)                         -- declare the function f(list,partyTime)
  r=function(X)                         -- declare a function r that convert hh:mm in seconds
    return X:match("^%d+")*3600         -- return the sum of seconds the hours
          +60*X:match("%d+$")           -- and in the seconds
  end
  T=r(T)                                -- convert the partyTime in seconds
  z={}                                  -- create the shameList for late partygoers
  y=0                                   -- y will keep us updated on the second count
  for i=1,#l                            -- iterate over l
  do
    h=l[i]:match("%d.*")                -- h is a shorthand for the time of arrival
    h=i>1                               -- if we're on the second line at least
        and y+h*60                      -- update h with the time of arrival in second
      or r(h)                           -- else use r()(for the first partygoer only)
    y=h                                 -- update our reference for adding time
    z[#z+1]=h>T                         -- if the last partygoer was late
                and l[i]:match("%u%l*") -- add its name to the shameList
              or nil                    -- else, don't do anything
  end
  return z                              -- return the shameList
end

if you want to try this code, you can use the following snippet
function f(l,T)r=function(X)return
X:match("^%d+")*3600+60*X:match("%d+$")end
T=r(T)z={}y=0
for i=1,#l do
h=l[i]:match("%d.*")h=i>1 and y+h*60or r(h)y=h
z[#z+1]=h>T and l[i]:match("%u%l*")or nil
end return z end

retour = f({"Kevin 13:02","Ruby 5","Sam 3","Lisa 6","Bob 12"},"13:15")
for i=1,#retour
do
  print(retour[i])
end

Groovy, 121 bytes
{g,t->y={Date.parse('hh:mm',it)};u=y(t);d=y(g.remove(0)[1]);g.find{z=it[1];use(groovy.time.TimeCategory){d+z.minutes}>u}}

PowerShell, 170 160 bytes
select-string '(?m)^((\w*) )?((\d\d):)?(\d?\d)$'-a|% matches|%{,$_.groups[2,4,5].value}|%{}{$b+=($c=60*$_[1]+$_[2]);$a+=,@{n=$_[0];t=$b}}{$a|? n|? t -gt $c|% n}

Try it online!

Better late than never!

I'm in rest today therefore have a some time for a some fun

Batch, 163 bytes
@set/pp=
@set/ap=%p::=*60+%
:l
@set g=
@set/pg=
@if "%g%"=="" exit/b
@set t=%g:* =%
@set/ap-=%t::=*60+%
@for %%g in (%g%)do @(if %p% lss 0 echo %%g)&goto l

Takes input on STDIN. First line is the start time of the party, then the list of guests. Uses @Arnauld's trick to convert the hh:mm into minutes.
Batch's preferred input for this would be as a series of command-line parameters (starting with the time of the party, then each guest and time as separate arguments). This would only take 129 bytes:
@set p=%1
@set/ap=%p::=*60+%
:l
@set t=%3
@set/ap-=%t::=*60+%
@if %p% lss 0 echo %2
@shift
@shift
@if not "%2"=="" goto l

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Optimize sorting, using "Sub-vector reversals"
This is a fewest-operations challenge where the objective is to sort a vector into ascending order using the fewest reversals. Your algorithm can only sort the vector using "sub-vector reversals"1, but it can use other operations for arithmetic operations, loops, checking if it's sorted etc. The number of sub-vector reversals your algorithm performs is its score.

1A "sub-vector reversal":

Select a range of numbers in the vector, and reverse the elements in that range.

To give a simple example, if you start with the vector {4,3,2,1}, then you can sort it in a lot of different ways:

Reverse the entire vector. This is obviously the shortest approach as it only requires one reversal: {4,3,2,1} -> {1,2,3,4}
You can do a version of the bubble sort, which requires 6 reversals: {4,3,2,1} -> {3,4,2,1} -> {3,2,4,1} -> {2,3,4,1} -> {2,3,1,4} -> {2,1,3,4} -> {1,2,3,4}
You can start with the first 3 elements, then the three last, and finally the two first and the two last, which requires 4 swaps: {4,3,2,1} -> {2,3,4,1} -> {2,1,4,3} -> {1,2,4,3} -> {1,2,3,4}
... and so on. There are an infinite amount of options available (you may repeat any operation if you like).

Rules and requirements:

Your code must finish in less than one minute for a list with 100 numbers. You may time this yourself, but please play fair2.
You must store the start and end indices of all swaps you perform, so that the solution might be verified. (I'll explain what this means below).
The code must be deterministic.
You can take the input on any format you want: Numeric vector, linked-list, array with length ... whatever you like.
You can do whatever you like on a copy of the vector. That includes attempting different reversals and check which is most efficient. Brute-forcing is perfectly fine, but stick to the time limit.
The score is the total number of flips for the 5 test vectors. Tie-breaker will the date stamp.

Example:

4 1 23 21 49 2 7 9 2 |  Initial vector / list
4 1 2 9 7 2 49 21 23 |  (2, 8)  (flipped the elements between indices 2 and 8)
4 1 2 2 7 9 49 21 23 |  (3, 5)
4 1 2 2 7 9 23 21 49 |  (6, 8)
4 1 2 2 7 9 21 23 49 |  (6, 7)
2 2 1 4 7 9 21 23 49 |  (0, 3)
1 2 2 4 7 9 21 23 49 |  (0, 2)

The score would be 6, since you performed 6 reversals. You must store (not print) the indices listed on the right side on a suitable format that can easily be printed/outputted for verification purposes.
Test vectors:
133, 319, 80, 70, 194, 333, 65, 21, 345, 142, 82, 491, 92, 167, 281, 386, 48, 101, 394, 130, 111, 139, 214, 337, 180, 24, 443, 35, 376, 13, 166, 59, 452, 429, 406, 256, 133, 435, 446, 304, 350, 364, 447, 471, 236, 177, 317, 342, 294, 146, 280, 32, 135, 399, 78, 251, 467, 305, 366, 309, 162, 473, 27, 67, 305, 497, 112, 399, 103, 178, 386, 343, 33, 134, 480, 147, 466, 244, 370, 140, 227, 292, 28, 357, 156, 367, 157, 60, 214, 280, 153, 445, 301, 108, 77, 404, 496, 3, 226, 37

468, 494, 294, 42, 19, 23, 201, 47, 165, 118, 414, 371, 163, 430, 295, 333, 147, 336, 403, 490, 370, 128, 261, 91, 173, 339, 40, 54, 331, 236, 255, 33, 237, 272, 193, 91, 232, 452, 79, 435, 160, 328, 47, 179, 162, 239, 315, 73, 160, 266, 83, 451, 317, 255, 491, 70, 18, 275, 339, 298, 117, 145, 17, 178, 232, 59, 109, 271, 301, 437, 63, 103, 130, 15, 265, 281, 365, 444, 180, 257, 99, 248, 378, 158, 210, 466, 404, 263, 29, 117, 417, 357, 44, 495, 303, 428, 146, 215, 164, 99

132, 167, 361, 145, 36, 56, 343, 330, 14, 412, 345, 263, 306, 462, 101, 453, 364, 389, 432, 32, 200, 76, 268, 291, 35, 13, 448, 188, 11, 235, 184, 439, 175, 159, 360, 46, 193, 440, 334, 128, 346, 192, 263, 466, 175, 407, 340, 393, 231, 472, 122, 254, 451, 485, 257, 67, 200, 135, 132, 421, 205, 398, 251, 286, 292, 488, 480, 56, 284, 484, 157, 264, 459, 6, 289, 311, 116, 138, 92, 21, 307, 172, 352, 199, 55, 38, 427, 214, 233, 404, 330, 105, 223, 495, 334, 169, 168, 444, 268, 248

367, 334, 296, 59, 18, 193, 118, 10, 276, 180, 242, 115, 233, 40, 225, 244, 147, 439, 297, 115, 354, 248, 89, 423, 47, 458, 64, 33, 463, 142, 5, 13, 89, 282, 186, 12, 70, 289, 385, 289, 274, 136, 39, 424, 174, 186, 489, 73, 296, 39, 445, 308, 451, 384, 451, 446, 282, 419, 479, 220, 35, 419, 161, 14, 42, 321, 202, 30, 32, 162, 444, 215, 218, 102, 140, 473, 500, 480, 402, 1, 1, 79, 50, 54, 111, 189, 147, 352, 61, 460, 196, 77, 315, 304, 385, 275, 65, 145, 434, 39

311, 202, 126, 494, 321, 330, 290, 28, 400, 84, 6, 160, 432, 308, 469, 459, 80, 48, 292, 229, 191, 240, 491, 231, 286, 413, 170, 486, 59, 54, 36, 334, 135, 39, 393, 201, 127, 95, 456, 497, 429, 139, 81, 293, 359, 477, 404, 129, 129, 297, 298, 495, 424, 446, 57, 296, 10, 269, 350, 337, 39, 386, 142, 327, 22, 352, 421, 32, 171, 452, 2, 484, 337, 359, 444, 246, 174, 23, 115, 102, 427, 439, 71, 478, 89, 225, 7, 118, 453, 350, 109, 277, 338, 474, 405, 380, 256, 228, 277, 3

I'm fairly certain that finding an optimal solution is NP-hard (since regular pancake sorting is).
2Yes, people with very fast computers might have a benefit, due to the time limit of one minute. After much discussion I've figured it's best if everyone does their own benchmarking, it's not a fastest code challenge.

Somewhat related.

The optimal solution should at most be equivalent to insertion sort in the number of reversals, each reversal can place a single number.

This is not pancake flipping (which can only flip from one location until the end). Selection sort is O(n) and uses n-1 swaps. There are worst cases in which n-1 swaps are necessary. Selection sort is asymptotically optimal.

Is the input a list/vector of integers? 2. What should be the output of the program? 3. Can the program sort the vector or parts of it, multiple times, perhaps using different methods (such as quicksort), in order to determine how to optimize the operations, as long as it does a sub-vector reversal sort of the input vector (as requested) at the end?

Can I specialize the program to work with 100 numbers only?

Sure. It should be simple to adapt it to work for 80 numbers too, and since it's not code golf you could make the list length dynamic, by expanding the code. You don't need to make it harder than it is. But you may not optimize it to perform better on the test cases than other lists with 100 numbers.

@orlp Can you prove that there are worst cases with n-1 flips? I can only prove a lower bound of about 50.

@user202729 Not sure, such a long time ago :D

Java, genetic-ish algorithm, 80+81+79+78+80=398 (previously 418)
After trying a bunch of different ideas and mostly failing, I settled on this algorithm: start with the input array, try all possible reversals and keep a certain number of results with the smallest number of runs, then do the same for those results, until we get a sorted array.
By "runs" I mean maximal subarrays that appear exactly or reversed in the sorted array. Basically they are maximal sorted subarrays, but in case of repeated elements, the number of elements in the middle should match. E.g. if the sorted array is 2, 2, 3, 3, 4, 4 then 4, 3, 3, 2 is a run but 2, 2, 3, 4 is not (and neither is 2, 3, 2).
In this version I optimized the algorithm to reverse only at run boundaries and only if a reversed run can be joined with a newly-adjacent run. Also, the runs are adjusted and joined at each step, to avoid recalculating them from the modified array. This allowed me to increase the "population size" from 30 to about 3000, and to run multiple simulations at various sizes.
import java.io.*;
import java.util.*;

public class SubReversal {
    static int n;
    static int[] a;
    static int[] srt;
    static List<int[]> rev;
    static Map<Integer, Integer> idx;
    static Map<Integer, Integer> count;

    static final int NB = 2000;
    static State[] best = new State[NB + 1];
    static int ns;

    static class Run {
        int start;
        int end;
        int dir;
        int nstart = 1;
        int nend = 1;

        Run(final int start) {
            this.start = start;
        }

        Run(final Run r) {
            start = r.start;
            end = r.end;
            dir = r.dir;
            nstart = r.nstart;
            nend = r.nend;
        }

        Run copy() {
            return new Run(this);
        }

        Run reverse() {
            int t = start;
            start = end;
            end = t;
            t = nstart;
            nstart = nend;
            nend = t;
            dir = -dir;
            return this;
        }

        boolean canJoin(final Run r) {
            if (dir * r.dir == -1) {
                return false;
            }
            final int t = idx.get(a[r.start]) - idx.get(a[end]);
            if (Math.abs(t) > 1) {
                return false;
            }
            if (t != 0 && dir + r.dir != 0 && t != dir && t != r.dir) {
                return false;
            }
            if (t == 0) {
                if (dir * r.dir == 0) {
                    return true;
                }
                return nend + r.nstart == count.get(a[end]);
            }
            return (dir == 0 || nend == count.get(a[end])) && (r.dir == 0 || r.nstart == count.get(a[r.start]));
        }

        Run join(final Run r) {
            if (a[start] == a[r.start]) {
                nstart += r.nstart;
            }
            if (a[end] == a[r.end]) {
                nend += r.nend;
            }
            else {
                nend = r.nend;
            }
            end = r.end;
            if (dir == 0) {
                dir = r.dir;
            }
            if (dir == 0 && a[start] != a[end]) {
                dir = idx.get(a[end]) - idx.get(a[start]);
            }
            return this;
        }

        @Override
        public String toString() {
            return start + "(" + nstart + ") - " + end + '(' + nend + "): " + dir;
        }
    }

    static class State implements Comparable<State> {
        int[] b;
        int[] rv;
        State p;
        List<Run> runs;

        public State(final int[] b, final int[] rv, final State p, final List<Run> runs) {
            this.b = Arrays.copyOf(b, b.length);
            this.rv = rv;
            this.p = p;
            this.runs = runs;
        }

        @Override
        public int compareTo(final State o) {
            return runs.size() - o.runs.size();
        }

        @Override
        public String toString() {
            return Arrays.toString(b) + " - " + Arrays.toString(rv) + " - " + runs.size();
        }

        int getCount() {
            return p == null ? 0 : p.getCount() + 1;
        }
    }

    static void reverse(int x, int y) {
        while (x < y) {
            int t = a[x];
            a[x] = a[y];
            a[y] = t;
            x++;
            y--;
        }
    }

    static List<Run> runs() {
        final List<Run> l = new ArrayList<>();
        Run run = new Run(0);
        for (int i = 1; i < n; ++i) {
            final int t = idx.get(a[i]) - idx.get(a[i - 1]);
            if (Math.abs(t) > 1) {
                run.end = i - 1;
                l.add(run);
                run = new Run(i);
            }
            else if (t == 0) {
                run.nend++;
                if (run.dir == 0) {
                    run.nstart++;
                }
            }
            else {
                if (run.dir == 0) {
                    run.dir = t;
                }
                else if (run.dir != t || run.nend != count.get(a[i - 1])) {
                    run.end = i - 1;
                    l.add(run);
                    run = new Run(i);
                }
                run.nend = 1;
            }
        }
        run.end = n - 1;
        l.add(run);
        return l;
    }

    static void show() {
        if (!Arrays.equals(a, srt)) {
            System.out.println("bug!");
            System.out.println(Arrays.toString(a));
            throw new RuntimeException();
        }
        System.out.println("Sorted: " + Arrays.toString(a));
        System.out.println(rev.size() + " reversal(s):");
        for (int[] x : rev) {
            System.out.println(Arrays.toString(x));
        }
    }

    static void sort() {
        State bestest = null;
        final int[] a1 = Arrays.copyOf(a, n);
        final int[] sizes = {10, 20, 30, 50, 100, 200, 300, 500, 1000, 2000};

        for (int nb : sizes) {
            System.arraycopy(a1, 0, a, 0, n);
            ns = 1;
            best[0] = new State(a, null, null, runs());
            while (best[0].runs.size() > 1) {
                final State[] s = Arrays.copyOf(best, ns);
                ns = 0;
                for (State x : s) {
                    System.arraycopy(x.b, 0, a, 0, n);
                    final int m = x.runs.size();
                    for (int i = 0; i < m; ++i) {
                        for (int j = i; j < m; ++j) {
                            boolean b = false;
                            if (i > 0) {
                                final Run r = x.runs.get(j);
                                r.reverse();
                                b = x.runs.get(i - 1).canJoin(r);
                                r.reverse();
                            }
                            if (!b && j < m - 1) {
                                final Run r = x.runs.get(i);
                                r.reverse();
                                b = r.canJoin(x.runs.get(j + 1));
                                r.reverse();
                            }
                            if (!b) {
                                continue;
                            }
                            final List<Run> l = new ArrayList<>(x.runs);
                            final int rstart = l.get(i).start;
                            final int rend = l.get(j).end;
                            final int t = rstart + rend;
                            reverse(rstart, rend);
                            for (int k = i; k <= j; ++k) {
                                final Run r = x.runs.get(i + j - k).copy().reverse();
                                r.start = t - r.start;
                                r.end = t - r.end;
                                l.set(k, r);
                            }
                            if (j < m - 1 && l.get(j).canJoin(l.get(j + 1))) {
                                l.get(j).join(l.get(j + 1));
                                l.remove(j + 1);
                            }
                            if (i > 0 && l.get(i - 1).canJoin(l.get(i))) {
                                l.set(i - 1, l.get(i - 1).copy().join(l.get(i)));
                                l.remove(i);
                            }

                            if (ns < nb || l.size() < best[ns - 1].runs.size()) {
                                best[ns++] = new State(a, new int[]{rstart, rend}, x, l);
                                Arrays.sort(best, 0, ns);
                                if (ns > nb) {
                                    ns = nb;
                                }
                            }
                            reverse(rstart, rend);
                        }
                    }
                }

                if (ns == 0) {
                    for (State x : s) {
                        System.arraycopy(x.b, 0, a, 0, n);
                        final List<Run> l = new ArrayList<>(x.runs);
                        final int rstart = l.get(0).start;
                        final int rend = l.get(0).end;
                        final int t = rstart + rend;
                        reverse(rstart, rend);
                        final Run r = x.runs.get(0).copy().reverse();
                        r.start = t - r.start;
                        r.end = t - r.end;
                        l.set(0, r);

                        best[ns++] = new State(a, new int[]{rstart, rend}, x, l);
                        reverse(rstart, rend);
                    }
                    Arrays.sort(best, 0, ns);
                }
            }
            State r = null;
            for (int i = 0; i < ns; ++i) {
                if (Arrays.equals(best[i].b, srt)) {
                    r = best[i];
                    break;
                }
            }
            if (r == null) {
                final State x = best[0];
                System.arraycopy(x.b, 0, a, 0, n);
                reverse(0, n - 1);
                r = new State(a, new int[]{0, n - 1}, x, runs());
            }
            if (!Arrays.equals(r.b, srt)) {
                throw new RuntimeException("bug");
            }

            if (bestest == null || r.getCount() < bestest.getCount()) {
                bestest = r;
            }
        }

        while (bestest.p != null) {
            rev.add(bestest.rv);
            bestest = bestest.p;
        }
        Collections.reverse(rev);
        a = a1;
        for (int[] x : rev) {
            reverse(x[0], x[1]);
        }
        if (!Arrays.equals(a, srt)) {
            throw new RuntimeException("bug");
        }
    }

    static void init(final String s) {
        final String[] b = s.split(s.contains(",") ? "," : " ");
        n = b.length;
        a = new int[n];
        count = new HashMap<>();
        for (int i = 0; i < n; ++i) {
            a[i] = Integer.parseInt(b[i].trim());
            final Integer x = count.get(a[i]);
            count.put(a[i], x == null ? 1 : x + 1);
        }
        srt = Arrays.copyOf(a, n);
        Arrays.sort(srt);
        idx = new HashMap<>();
        int j = 0;
        for (int i = 0; i < n; ++i) {
            if (i == 0 || srt[i] != srt[i - 1]) {
                idx.put(srt[i], j++);
            }
        }
        rev = new ArrayList<>();
    }

    static void test5() {
        final String[] t = {"133, 319, 80, 70, 194, 333, 65, 21, 345, 142, 82, 491, 92, 167, 281, 386, 48, 101, 394, 130, 111, 139, 214, 337, 180, 24, 443, 35, 376, 13, 166, 59, 452, 429, 406, 256, 133, 435, 446, 304, 350, 364, 447, 471, 236, 177, 317, 342, 294, 146, 280, 32, 135, 399, 78, 251, 467, 305, 366, 309, 162, 473, 27, 67, 305, 497, 112, 399, 103, 178, 386, 343, 33, 134, 480, 147, 466, 244, 370, 140, 227, 292, 28, 357, 156, 367, 157, 60, 214, 280, 153, 445, 301, 108, 77, 404, 496, 3, 226, 37",
                "468, 494, 294, 42, 19, 23, 201, 47, 165, 118, 414, 371, 163, 430, 295, 333, 147, 336, 403, 490, 370, 128, 261, 91, 173, 339, 40, 54, 331, 236, 255, 33, 237, 272, 193, 91, 232, 452, 79, 435, 160, 328, 47, 179, 162, 239, 315, 73, 160, 266, 83, 451, 317, 255, 491, 70, 18, 275, 339, 298, 117, 145, 17, 178, 232, 59, 109, 271, 301, 437, 63, 103, 130, 15, 265, 281, 365, 444, 180, 257, 99, 248, 378, 158, 210, 466, 404, 263, 29, 117, 417, 357, 44, 495, 303, 428, 146, 215, 164, 99",
                "132, 167, 361, 145, 36, 56, 343, 330, 14, 412, 345, 263, 306, 462, 101, 453, 364, 389, 432, 32, 200, 76, 268, 291, 35, 13, 448, 188, 11, 235, 184, 439, 175, 159, 360, 46, 193, 440, 334, 128, 346, 192, 263, 466, 175, 407, 340, 393, 231, 472, 122, 254, 451, 485, 257, 67, 200, 135, 132, 421, 205, 398, 251, 286, 292, 488, 480, 56, 284, 484, 157, 264, 459, 6, 289, 311, 116, 138, 92, 21, 307, 172, 352, 199, 55, 38, 427, 214, 233, 404, 330, 105, 223, 495, 334, 169, 168, 444, 268, 248",
                "367, 334, 296, 59, 18, 193, 118, 10, 276, 180, 242, 115, 233, 40, 225, 244, 147, 439, 297, 115, 354, 248, 89, 423, 47, 458, 64, 33, 463, 142, 5, 13, 89, 282, 186, 12, 70, 289, 385, 289, 274, 136, 39, 424, 174, 186, 489, 73, 296, 39, 445, 308, 451, 384, 451, 446, 282, 419, 479, 220, 35, 419, 161, 14, 42, 321, 202, 30, 32, 162, 444, 215, 218, 102, 140, 473, 500, 480, 402, 1, 1, 79, 50, 54, 111, 189, 147, 352, 61, 460, 196, 77, 315, 304, 385, 275, 65, 145, 434, 39",
                "311, 202, 126, 494, 321, 330, 290, 28, 400, 84, 6, 160, 432, 308, 469, 459, 80, 48, 292, 229, 191, 240, 491, 231, 286, 413, 170, 486, 59, 54, 36, 334, 135, 39, 393, 201, 127, 95, 456, 497, 429, 139, 81, 293, 359, 477, 404, 129, 129, 297, 298, 495, 424, 446, 57, 296, 10, 269, 350, 337, 39, 386, 142, 327, 22, 352, 421, 32, 171, 452, 2, 484, 337, 359, 444, 246, 174, 23, 115, 102, 427, 439, 71, 478, 89, 225, 7, 118, 453, 350, 109, 277, 338, 474, 405, 380, 256, 228, 277, 3"};
        int r = 0;
        for (String s : t) {
            init(s);
            sort();
            System.out.println(rev.size());
            r += rev.size();
        }
        System.out.println("total: " + r);
    }

    public static void main(final String... args) throws IOException {
        System.out.print("Input: ");
        final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        final String s = br.readLine();
        final long t = System.currentTimeMillis();
        if (s.isEmpty()) {
            System.out.println("Running tests");
            test5();
        }
        else {
            init(s);
            sort();
            show();
        }
        System.out.println("Time: " + (System.currentTimeMillis() - t + 500) / 1000 + " sec");
    }
}

Input is a list of numbers separated by comma and/or space (from stdin). If the input is empty, the program runs the 5 tests. Each one takes about 40 sec here.

Interesting that the number of reversals on the 5th test case didn't improve with the new version. The others improve quite a lot. I'm glad you decided to give it another go :)

@StewieGriffin thanks, you helped me blow past 20k :) I think I got a bit lucky with the last case previously. A randomized approach will probably give even better results.

One move brute-force then selection sort (also naive solution), 90 + 89 + 88 + 87 + 89 = 443 moves
let doReverse = (a, l, r) => {
  a.splice(l, r - l, ...a.slice(l, r).reverse());
};
let selectSubVectorReverseSort = a => {
  let log = [];

  for (let i = 0, l = a.length; i < l; i++) {
    let j, p = i;
    for (j = i; j < l; j++) {
      if (a[j] < a[p]) p = j;
    }
    if (p === i) continue;
    log.push([i, p + 1]);
    doReverse(a, i, p + 1);
  }
  return log;
};

let a = JSON.parse(`[${readline()}]`);
let copiedArray = a => a.map(x => x);
let minLog = selectSubVectorReverseSort(copiedArray(a));
for (let i = 0, l = a.length; i < l; i++) {
  for (let j = i + 1; j < l; j++) {
    let b = copiedArray(a);
    doReverse(b, i, j + 1);
    let log = [[i, j + 1], ...selectSubVectorReverseSort(b)];
    if (log.length < minLog.length) minLog = log;
  }
}

print(minLog.length);

for every possible first move, try it, and then, do a selection sort.
Yes, this is another naive solution.
I'm not sure this should be an edit or another post, but it seems the solution is too simple, so editing is chosen.

Selection Sort (Naive Solution), 92 + 93 + 95 + 93 + 96 = 469 moves
let log = [];
let doReverse = (a, l, r) => {
  log.push([l, r]);
  a.splice(l, r - l, ...a.slice(l, r).reverse());
}

let a = JSON.parse(`[${readline()}]`);
for (let i = 0, l = a.length; i < l; i++) {
  let j, p = i;
  for (j = i; j < l; j++) {
    if (a[j] < a[p]) p = j;
  }
  if (p === i) continue;
  doReverse(a, i, p + 1);
}
print(log.length)

A naive solution use selection sort.
There MUST be some better solutions, but post this since I did not find a better one (without brute-force search).
(Above code is JavaScript Shell)

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/