text:
Mayweather vs McGregor: Prepare the cash prize
Introduction
On the 26th of August, 2017, Floyd Mayweather, Jr. will face up to Conor McGregor in a boxing match.
Both participants will receive the phenomenal amount of 100 million dollars!
Unfortunately, we do not have the money yet, but we can already prepare the big briefcase that will contain all the banknotes.
        _________________________
        |                       |
|=======================================|
|       $  $$$$$  $$$$$  $       $      |
|   $   $  $   $  $   $  $$$   $$$      |
|       $  $   $  $   $  $  $$$  $      |
|       $  $$$$$  $$$$$  $       $      |
|_______________________________________|

The briefcase is composed of _,|,= and $.
It has a size of 41 characters in width (ignoring the newlines) and 6 in height (+2 for the handle).
Challenge
Given no input, write a full program to output a 2D briefcase (see above).
Score
This is code-golf, so the shortest solution (in bytes) wins.

I've changed the links to point to English Wikipedia since an overwhelming share of users speak English.

The ultimate question: what is the width of the briefcase?

@cat Oops my bad

@RodrigoA.Pérez Already told in the question. 42 characters

@Weedoze Yes I know; the ultimate question...

... It's 41 characters wide

Bubblegum, 55 bytes
Probably possible to do some header removal magic, but I'm not as good as Dennis!
00000000: 5380 8278 5c80 0ba6 a246 013b a8e1 aab1  S..x\....F.;....
00000010: 250e 0055 42f5 a800 1108 2028 9804 dc4c  %..UB..... (...L
00000020: 2847 059d 0229 8790 6080 6a26 3a85 6c36  (G...)..`.j&:.l6
00000030: 49b6 c713 076a 00                        I....j.

Try it online!

I get 55 as well, not a lot to work with there...

Jelly,  92  75 bytes
⁽©Ḍṃ“_= ”x"“€Þ‘x2,6¤;"⁾_|x1,7¤z⁶ZUŒBY”$“¢=Ḷ't3y&ḅḄȥıḍḄḌṀṡḂẓPḣṁQṘ½ɗ’BT+134¤¦

Try it online!
How?
Step 1. Build a list of the rows of the right half of an empty briefcase, ignoring trailing spaces:
⁽©Ḍṃ“_= ”x"“€Þ‘x2,6¤;"⁾_|x1,7¤
    “_= ”                      - literal list of characters = "_= "
⁽©Ḍ                            - base 250 literal = 2674
   ṃ                           - base decompress (2674 in base: 1='_', 2='=', 0=' ')
                               -   ...yields the list of characters: "_ =    _"
                   ¤           - nilad followed by link(s) as a nilad:
           “€Þ‘                -   literal list of code page indexes = [12,20]
                2,6            -   literal list of numbers = [2,6]
               x               -   repeat -> [12,12,20,20,20,20,20,20]
         x                     - repeat -> ["_"*12, " "*12, "="*20, " "*20, ..., "_"*20]
                             ¤ - nilad followed by link(s) as a nilad:
                      ⁾_|      -   literal list of characters = "_|"
                          1,7  -   literal list of numbers = [1,7]
                         x     -   repeat -> list of characters "_|||||||"
                     "         - zip with the dyad:
                    ;          -   concatenate -> ["_"+"_"*12, "|"+" "*12, ...]

Step 2: transform that into a whole empty briefcase:
z⁶ZUŒBY
 ⁶      - literal space character
z       - transpose with filler (adds the "leading" spaces, to the 1st 2 rows)
  Z     - transpose (back from columns to rows again)
   U    - upend (reverse each row to make it a left-hand side of an empty briefcase)
    ŒB  - bounce (add a reflection of each row with one central character)
      Y - join with new lines

Step 3: Show me the money!
”$“¢=Ḷ't3y&ḅḄȥıḍḄḌṀṡḂẓPḣṁQṘ½ɗ’BT+134¤¦
                                     ¦ - sparse application of:
”$                                     -   literal '$' character
                                       - ...to indexes:
                                    ¤  - nilad followed by link(s) as a nilad:
  “¢=Ḷ't3y&ḅḄȥıḍḄḌṀṡḂẓPḣṁQṘ½ɗ’         - base 250 literal = 1999171130867115278012045759181600763304793110829063794065408
                              B        - convert to a binary list -> [1,0,0,1,1,1,1,1,0,0,1,1,1,1,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,1,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,1,1,1,1,0,0,1,1,1,1,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
                               T       - truthy indexes -> [1,4,5,6,7,8,11,12,13,14,15,18,26,39,43,46,50,53,57,60,61,62,66,67,68,85,88,92,95,99,102,105,106,107,110,127,130,131,132,133,134,137,138,139,140,141,144,152]
                                 134   - literal 134
                                +      - addition -> [135,138,139,140,141,142,145,146,147,148,149,152,160,173,177,180,184,187,191,194,195,196,200,201,202,219,222,226,229,233,236,239,240,241,244,261,264,265,266,267,268,271,272,273,274,275,278,286]
                                       -             (that's where the $s at!)

Mmm... Beat me by 5 you beautiful beast.

JavaScript (ES6), 187 184 bytes
_=>`70
78B
B2B
9F33CDB
AEFEFEF54B
9FEFEFF6DB
9F33CDB
B1B`.replace(/./g,c=>'__=$$$$ ||||$$$$'[n=+('0x'+c)].repeat(n>6?1:n?+'0005333'[n]||39:25)+' '.repeat(n-8?'0002632707307632'[n]:23))

How?
The output is built using these 16 unique patterns:
ID | Character | Repeated | Following spaces | Rendering
---+-----------+----------+------------------+-------------------------------------------
 0 |     _     |    25    |         0        | "_________________________"
 1 |     _     |    39    |         0        | "_______________________________________"
 2 |     =     |    39    |         0        | "======================================="
 3 |     $     |     5    |         2        | "$$$$$  "
 4 |     $     |     3    |         6        | "$$$      "
 5 |     $     |     3    |         3        | "$$$   "
 6 |     $     |     3    |         2        | "$$$  "
 7 |   space   |     1    |         7        | "        "
 8 |     |     |     1    |        23        | "|                       "
 9 |     |     |     1    |         7        | "|       "
 A |     |     |     1    |         3        | "|   "
 B |     |     |     1    |         0        | "|"
 C |     $     |     1    |         7        | "$       "
 D |     $     |     1    |         6        | "$      "
 E |     $     |     1    |         3        | "$   "
 F |     $     |     1    |         2        | "$  "

Demo

let f =

_=>`70
78B
B2B
9F33CDB
AEFEFEF54B
9FEFEFF6DB
9F33CDB
B1B`.replace(/./g,c=>'__=$$$$ ||||$$$$'[n=+('0x'+c)].repeat(n>6?1:n?+'0005333'[n]||39:25)+' '.repeat(n-8?'0002632707307632'[n]:23))

console.log(f())

05AB1E, 80 bytes
•Cā½œSÖ<ô’=-¾Ì„*нcF/“è∊αΔú9d:î₅•6B5¡.B€û»•H0αÅ±¼Āß8PβÁ19]×
ôв•bvðy.;}4ÝJ"$ |=_"‡

Try it online!

Explanation
The basic outline of the briefcase:
05AB1E, 41 bytes
•Cā½œSÖ<ô’=-¾Ì„*нcF/“è∊αΔú9d:î₅•6B5¡.B€û»

Try it online!
Sub-explanation explanation (part one):
I converted the overall design by cutting the design in half, replacing all characters with 2-6 and finally converting it to base 255 and reconstructing the shape using 5 as a newline delimiter.
•Cā½œSÖ<ô’=-¾Ì„*нcF/“è∊αΔú9d:î₅•  # Push the base-255 compressed number
6B                                # Convert it to  base-6 (the number of unique symbols)
  5¡                              # Split on 5 (the newlines).
    .B                            # Pad all elements with space to equal largest element length.
      €û                          # For each element, mirror it.
        »                         # Separate list with newlines.

77793946998265282127108152676813925695887415511783202442861719287811277

Is the number that's expressed in base 255, and the base 6 conversion of it is...
11111111444444444444511111111211111111111523333333333333333333525252525244444444444444444445

Then, splitting that on fives, mirroring and joining by newlines gets us...
111111114444444444444444444444411111111
111111112111111111111111111111211111111
233333333333333333333333333333333333332
2                                     2
2                                     2
2                                     2
2                                     2
244444444444444444444444444444444444442

Sub-explanation explanation (part two):
Starting to see where this is going? Next, I compress the inner pattern as a base-255 string:
•H0αÅ±¼Āß8PβÁ19]×
ôв•

Which is:
353343914082943027578174279006736773101445087

Convert to binary:
1111110110000011000001101111111011111110111011011101101110110001110001111111111101101110110111011011000110111111111110110000011000001101111111011111

For each of those characters, replace a space with the next character, iteratively:
111111114444444444444444444444411111111
111111112111111111111111111111211111111
233333333333333333333333333333333333332
211111101100000110000011011111110111112
211011101101110110111011000111000111112
211111101101110110111011011000110111112
211111101100000110000011011111110111112
244444444444444444444444444444444444442

Finally, replace the characters with what they're supposed to be.
0 = '$'
1 = ' '
2 = '|'
3 = '='
4 = '_'

4ÝJ"$ |=_"‡

For the loss:
        _______________________
        |                     |
|=====================================|
|      $  $$$$$  $$$$$  $       $     |
|  $   $  $   $  $   $  $$$   $$$     |
|      $  $   $  $   $  $  $$$  $     |
|      $  $$$$$  $$$$$  $       $     |
|_____________________________________|

By compressing it as two separate patterns I save 20 bytes over:
7ºnF@É₄S¡‘nz'W›мλнbнžSÍõ₄óð½²Ç0Δεenë3aŽÖk∍&1ŒâÜ[¤öüuиSð±zαÛÊ¸q¥KÃĀ›Ć^ü¹ÉRKq®Ùì=Ö‚≠ØÖì¾!(Δ∍Ú

Which is:
111111114444444444444444444444411111111
111111112111111111111111111111211111111
233333333333333333333333333333333333332
211111101100000110000011011111110111112
211011101101110110111011000111000111112
211111101101110110111011011000110111112
211111101100000110000011011111110111112
244444444444444444444444444444444444442

Converted to base-10:
29962958783786255124710309272045448655717311098547870227488323781868803792449842685227629539722703574931794395923080776255103394202825327279714682601797290475465885089686540986020693577678744259173981845378875732421872

92 bytes plus the transliteration, which would total to about 105.

SOGL, 58 57 bytes
¹&‘┐4Ο"ε@»-⅜Η⁄№ν½7bč═⁴‘'⁴n{╥ι}¹54"~æαΟ9≠š:+VæΨT-⅟yu7‘'∑nž

Explanation:
¹&‘┐                            push 20 spaces
    4Ο                          swap between the 20 spaces and "|" 9 times, resulting in "|                    |                    |                    |                    |"
      "...‘                     push "        _____________        |            |====================ŗ____________________", with ŗ replaced with the string above
           '⁴n                  split into chunks of length 21
              {╥ι}¹             palendromize horizontally
                     "...‘      push the sign - "    $  $$$$$  $$$$$  $       $$   $  $   $  $   $  $$$   $$$    $  $   $  $   $  $  $$$  $    $  $$$$$  $$$$$  $       $"
                          '∑n   split into chunks of length 30
                   54        ž  at coordinates (5;4) place the sign in the briefcase

Try it Here!
54 bytes (competing?)
¹&‘┐4Ο"ε@»-⅜Η⁄№ν½7bč═⁴‘'⁴n╥ι54"~æαΟ9≠š:+VæΨT-⅟yu7‘'∑nž

The command used here is ╥ - palendromize, which only worked on strings, but was documentated for arrays too. (currently it's only implemented on the online interpreter)
Try it Here!

///, 155 bytes
/~/\/\///2/  ~3/2 ~6/33~7/6 ~1/____~4/__111~5/411___~#/=============~%/$$$~&/%$$~9/$2$3$2$3$2~@/|
|~8/@7$2&2&2$7$6/ 75
 7|33377@###8@3$39%3%6@79$2%2$68@45|

Try it online!
I love it when /// can compete.
Explanation:
This works by defining common replacements like $$$$$, then defining meta-replacements that include the original replacements.
More in-depth:
First of all, the only feature of /// is it's /pattern/replacement/ syntax and it's ability to use backslashes to escape other backslashes and forward-slashes. This information is important in the explanation.
The first pattern/replacement in the code is for golfing purposes only (and detailed here). It replaces ~ with //, so the resulting code looks like this:
/2/  //3/2 //6/33//7/6 //1/____//4/__111//5/411___//#/=============//%/$$$//&/%$$//9/$2$3$2$3$2//@/|
|//8/@7$2&2&2$7$6/ 75
 7|33377@###8@3$39%3%6@79$2%2$68@45|

Then a bunch of basic replacements are made. Some rely on others (meta-replacements), but the table of replacements looks like this (code wrapped in `s):
Pattern             |Replacement
=====================================
`2`                 |`  `
-------------------------------------
`3`                 |`   `
-------------------------------------
`6`                 |`      `
-------------------------------------
`7`                 |`       `
-------------------------------------
`1`                 |`____`
-------------------------------------
`4`                 |`______________`
-------------------------------------
`5`                 |`_________________________`
-------------------------------------
`#`                 |`=============`
-------------------------------------
`%`                 |`$$$`
-------------------------------------
`&`                 |`$$$$$`
-------------------------------------
`@`                 |`|
                    ||` (Pipe, newline, pipe)
-------------------------------------

The meta-replacements here are things like /&/%$$/. This takes the already-existing replacement $$$ and uses it to define a new replacement $$$$$.
Then come the very large replacements. The first one replaces 9 with $  $   $  $   $   $ and the second one replaces 8 with:
|
|       $  $$$$$  $$$$$  $       $

Note the trailing spaces.
Then all of these replacements are used in the following string:
 75
 7|33377@###8@3$39%3%6@79$2%2$68@45|

To get the desired output.

Wow, I want a more in-depth explanation.

@carusocomputing Done.

While this is a fascinating and great example of programming in ///, it turns out a naive encoding is only about 143 bytes

PHP, 117 bytes
I am sad that there is nothing shorter than the lazy approach - gzip the string and base64-encode it:
<?=gzinflate(base64_decode(U1CAgHhcACqvwAVj1ChgB3Bxrhpb4kANF0yPChCBAIJCSIDNBqtUgapEpVTADBUUlQpYVUKVYVVJwHacwYMKagA));

Custom compression: 188 bytes
for(;$c=" 6_777
 6| 883|
|=8899|
| 5$  $3  $3  $ 5$ 4|
| 1$ 1$  $ 1$  $ 1$  $1 1$1 4|
| 5$  $ 1$  $ 1$  $  $2  $ 4|
| 5$  $3  $3  $ 5$ 4|
|_8899|"[$i++];)echo+$c?str_pad($d,$c+1,$d):$d=$c;

168 164 159 152 151 bytes with an adaption of officialaimm´s idea:
The lines can be seen as a bitmap between a boundary character (spaces for the first two, pipe after that), with space as 0 and another character as 1.
Inverting lines 3 and 8 gave them a value 0, so I could shift all values by 6 bits.
The array contains the bitmaps (converted to base 34; but only 7 values - the 8th element is omitted, an empty element evaluates to 0 as well). Base 35 would work as well; but base 33 has longer values and base 36 would need one more value quoted.
The string contains the boundary, 0 and 1 characters in that order for each line (omitting the last character, because lines 3 and 8 need no 1 character, having no bit set).
for(;$i<8;)echo strtr(sprintf("b%039bb
",intval(["1g7em2",p3ob4,0,v839j,cm7f3d,sfxq9,v839j][+$i],34)<<6),b01,substr("  _  ||= | $| $| $| $|_",$i++*3));

Custom compression by Jörg, 159 156 bytes:
<?=strtr("5 _2222
5 |555  |
|===333333|
|516161504$414141$$4$$0514141  6  051616150___222222|",["$      |
|","$  $",______,"======","   ","       ","$$$"]);

I think this is better Try it online!

Sorry I have found a better way Try it online!

@JörgHülsermann: me too

could you change the order of sprintf and strtr to drop the echo?

@JörgHülsermann: No. I have to convert the number before replacing the binary digits.

base 35 save one byte Try it online!

Works the idea with base 35 not in your opinion?

@JörgHülsermann It´s nice, but I have a life.

Jelly, 114 bytes
“£zḂİẹḋmẋ>zạṾʂṀAYnŀ67ŻḢkðṡẉHLV'²ṙæṠṆoPẸCÞƒṿÑḢƲp4ƊƘṂɠ5×ṗ²X³⁻%ẹṄÑỊWÐh.ẹƁɗṫ0ạṢṆ@Gị}xM`JʠɠS"LṂÐ÷ṙḃ?ṄP9÷/⁵EṛṇD’ṃ“ ¶|=$_

Try it online!

C, 415 402 397 bytes
#define P(x)D(x,4,4)
#define S(r,c)i=r;j=c;
#define D(x,c,n)for(k=x+n;x<k;t[i][j]=c)++x;
t[8][41]={0};i,j,k;o(x){S(2,x)P(i)P(j)S(3,x)P(j)D(i,4,3)}f(){t[1][8]=t[1][32]=92;t[4][4]=4;S(0,7)D(j,63,25)S(1,0)D(i,92,6)D(j,63,39)S(2,0)D(j,29,39)S(1,40)D(i,92,6)S(2,9)P(i)o(12);o(19);S(2,26)P(i)i-=2;D(j,4,2)++i;D(j,4,3)--i;D(j,4,3)i-=2;P(i)for(i=0;i<8;++i,puts(t))for(j=0;j<41;)printf("%c",t[i][j++]+32);}

Try it online!

C (gcc), 388 386 302 bytes
char*r="8 24_08 1|22 1|01|37=1|01|6 1$2 5$2 5$2 1$7 1$5 1|01|2 1$3 1$2 1$3 1$2 1$3 1$2 3$3 3$5 1|01|6 1$2 1$3 1$2 1$3 1$2 1$2 3$2 1$5 1|01|6 1$2 5$2 5$2 1$7 1$5 1|01|37_1|";char d[9];main(i){do{if(*r==48)puts(""),r++;for(i=0;isdigit(*r);d[i++]=*r++);for(d[i]=0,i=atoi(d);i--;putchar(*r));}while(*r++);}

Try it online!

294 bytes

Python 2, 221 205 197 196 193 bytes

Saved 16 Bytes: Compression changed from 16-base to 36-base
Saved 8 bytes: Use of a="6ZBRS533| $" and b="70JYF0U7|"
Saved 1 byte: Switched from Python 3 to 2
Saved 3 bytes: Removed a white-space and a pair of braces(after rearranging the string-replacement)

a="6ZBRS533| $"
b="70JYF0U7|"
for u in["6YKXAYYN  _","6ZKFUZR3  |",b+"= ",a,"6JNFT2RJ| $","6ZFOPPKV| $",a,b+"_ "]:print u[-3]+bin(int(u[:-3],36))[2:].replace("1",u[-2]).replace("0",u[-1])+u[-3]

Try it online!
Explanation:
Each line is in a generic form of pup where p is a boundary character and u is a string with two unique characters(for each line) which can be represented by 1 and 0. For example, line 5 is:
|   $   $  $   $  $   $  $$$   $$$      |
It has | as boundary character and the middle string contains only  and $. The middle string can be represented by:
111011101101110110111011000111000111111
Now this binary string can be represented by 36-base number:
6JNFT2RJ
We can represent all the lines by a definitive string along with the 36-base string, boundary character and the characters used in middle string as follows:
111111100000000000000000000000001111111  "6YKXAYYN  _"
111111101111111111111111111111101111111  "6ZKFUZR3  |"
111111111111111111111111111111111111111  "70JYF0U7|= "
111111101100000110000011011111110111111  "6ZBRS533| $"
111011101101110110111011000111000111111  "6JNFT2RJ| $"
111111101101110110111011011000110111111  "6ZFOPPKV| $"
111111101100000110000011011111110111111  "6ZBRS533| $"
111111111111111111111111111111111111111  "70JYF0U7|_ "

We can thus decompress the base-36 string (after extractcing it from the definitive string) to binary string, replace 1 and 0 by the characters(also obtained from the definitive string) used in the middle string and glue with boundary characters at both ends. Thus, required string is obtained.

If you inverse the full lines, you can cut off the lowest 6 bits; that should save 5 bytes or so.

Braingolf, 267 bytes
764*.7,2-#&744742222222562222574474#&[# ][#_]#
[# ]#|[# ]"|
|"[#=]"|
|"[# ]#$,.[#$]# .[#$]"  $"[# ]#$,[# ]"|
|"[# ]#$[# ]"$  $"[# ]"$  $"[# ]"$  "[#$][# ][#$][# ]"|
|"[# ]"$  $"[# ]"$  $"[# ]#$[# ]#$,.[#$]"  $"[# ]"|
|"[# ]#$,.[#$]# .[#$]"  $"[# ]#$,[# ]"|
|"[#_]#|&@

Try it online!
So golfy...

Retina, 140 137 129 bytes
-3 bytes thanks to @Neil

8aaaa_¶8|23|¶|bbbbbb===c3A3d3d3dAA3AAA6|¶|7d3d3d2AAd6caaaaaa___|
d
A2A
c
|¶|7A2AAAAA2AAAAA2A7A6|¶|
b
======
a
______
A
$
\d+
$*

Try it online!

Since you're not using the 1s for anything else, can you not write $*<space> directly?

05AB1E, 121 bytes
•?íLñ>ć£P¹ĀJδšlÔ@.ì@E'a‘2‡ΔÉ₅’Õ'8¾—Hú∊‹£ñ₂C*ƶ¬}ʒ³öG`ŒªKµδB₁вÑ(δüc›½ćˆ3αÂÝβ+Í‘]~é£42îĆ$Ÿ₅Ë!∊s₆L×ä5Uñ₁δǝβζ•6B•1’₃•" _
|=$"‡

Try it online!

You can save bytes by expressing the inner and outer/inner patterns as separate entities and using replace to combine them iteratively. I only recently learned this tactic for reducing the base conversion byte-count when doing the periodic table challenge :). Bubblegum kills it on anything less than 3 inner patterns though, and this is only 1 :(. https://codegolf.stackexchange.com/a/126995/59376

@carusocomputing Bubblegum even kils SOGL so not really worth it...

JavaScript (ES6), 177 166 bytes
_=>` 8_25
 8| 23|
|=39|
${r='| 7$ 2$5 2$5 2$ 7$ 6|'}
| 3$ ${s='3$ 2$ 3$ 2$ '}3$ 2$3 3$3 6|
| 7$ 2$ ${s}2$3 2$ 6|
${r}
|_39|`.replace(/(.)(\d+)/g,(_,b,c)=>b.repeat(c))

The string holds a collection of the characters to display along with the number of times to repeat.  If a character isn't repeated, the number of times can be omitted.
Repeated string runs are optimized by storing in the variables r and s.
Snippet:

f=
_=>` 8_25
 8| 23|
|=39|
${r='| 7$ 2$5 2$5 2$ 7$ 6|'}
| 3$ ${s='3$ 2$ 3$ 2$ '}3$ 2$3 3$3 6|
| 7$ 2$ ${s}2$3 2$ 6|
${r}
|_39|`.replace(/(.)(\d+)/g,(_,b,c)=>b.repeat(c))

console.log(f());

Python 2, 135 bytes
print'eNpTUICAeFwAKq/ABWPUKGAHcHGuGlviQA0XTI8KEIEAgkJIgM0Gq1SBqkSlVMAMFRSVClhVQpVhVUnA9njiQA0AtPhDOg=='.decode('base64').decode('zlib')

Try it online!

Charcoal, 52 bytes
←×_²⁰↑⁵|×=²⁰↖↑←×_¹³↘↙|↓↷‖Ｏ”{“↷γαc7sa%}⦃Ｎ№Ｔ⊕ＶⅉＨ➙Ｕ₂＆ηy

Try it online! Link is to verbose version of code. Explanation:
←×_²⁰↑⁵|×=²⁰↖↑←×_¹³↘↙|

Print the left half of the briefcase.
↓↷

Prepare the cursor so that the compressed string can be printed directly after reflecting. (Putting the downward movement after the reflection or before the compressed string changes their meaning.)
‖Ｏ

Reflect to complete the briefcase.
”{“↷γαc7sa%}⦃Ｎ№Ｔ⊕ＶⅉＨ➙Ｕ₂＆ηy

Print the amount as a compressed string. (Sadly this was the shortest approach, as otherwise the M consumed too many bytes.)

Deadfish~, 751 bytes
{iii}iicccccccc{iiiiii}iii{cc}ccccc{{d}ii}dddddc{ii}iicccccccc{{i}d}iic{{d}i}dd{cc}ccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{dddddd}ddd{cc}{c}ccccccccc{iiiiii}iiic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccccccciiiicddddcciiiicccccddddcciiiicccccddddcciiiicddddccccccciiiicddddcccccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccciiiicddddccciiiicddddcciiiicddddccciiiicddddcciiiicddddccciiiicddddcciiiicccddddccciiiicccddddcccccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccccccciiiicddddcciiiicddddccciiiicddddcciiiicddddccciiiicddddcciiiicddddcciiiicccddddcciiiicddddcccccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccccccciiiicddddcciiiicccccddddcciiiicccccddddcciiiicddddccccccciiiicddddcccccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{ddd}i{cc}{c}ccccccccc{iii}dc

Try it online!
Only eight or nine times longer than the others...


text:
Compute OEIS A005434
The task is to compute OEIS A005434 as quickly as possible.
Consider a binary string S of length n.  Indexing from 1, we can determine if S[1..i+1] matches S[n-i..n] exactly for all i in order from 0 to n-1.      For example,
S = 01010

gives
[Y, N, Y, N, Y].

This is because 0 matches 0, 01 does not match 10, 010 matches 010, 0101 does not match 1010  and finally 01010 matches itself.
Define f(n) to be the number of distinct arrays of Ys and Ns one gets when iterating over all 2^n different possible bit strings S of length n.
The observant will notice this question is a simpler variant of another recent question of mine. However, I expect that clever tricks can make this much faster and easier.
Task
For increasing n starting at 1, your code should output n, f(n).
Example answers
For n = 1..24, the correct answers are:
1, 2, 3, 4, 6, 8, 10, 13, 17, 21, 27, 30, 37, 47, 57, 62, 75, 87, 102, 116, 135, 155, 180, 194

Scoring
Your code should iterate up from n = 1 giving the answer for each n in turn. I will time the entire run, killing it after two  minutes.
Your score is the highest n you get to in that time.
In the case of a tie, the first answer wins.
Where will my code be tested?
I will run your code under Virtualbox in a Lubuntu guest VM (on my Windows 7 host).
My laptop has 8GB of RAM and an Intel i7 5600U@2.6 GHz (Broadwell) CPU with 2 cores and 4 threads. The instruction set includes SSE4.2, AVX, AVX2, FMA3 and TSX.
Leading entries per language

n = 599 in Rust bu Anders Kaseorg.
n= 30 in C by Grimy. Parallel version gets to 32 when run natively  in cygwin.

https://www.math.uni-bielefeld.de/~sillke/SEQUENCES/autocorrelation-range.c (linked from the OEIS page) run with -O3 can calculate up to 100 in <.02 seconds on my machine

@rogaos Oh dear.  I should delete the question but it already has an answer.

I think it's still a cool problem – but maybe up to 1000 instead? Or ask answers to golf a sufficiently fast program

@rogaos I just removed the hard limit completely.

Rust, n ≈ 660
use std::collections::HashMap;
use std::iter::once;
use std::rc::Rc;

type Memo = HashMap<(u32, u32, Rc<Vec<u32>>), u64>;

fn f(memo: &mut Memo, mut n: u32, p: u32, mut s: Rc<Vec<u32>>) -> u64 {
    debug_assert!(p != 0);
    let d = n / p;
    debug_assert!(d >= 1);
    let r = n - p * if d >= 2 { d - 1 } else { 1 };

    let k = s.binary_search(&(n - r + 1)).unwrap_or_else(|i| i);
    for &i in &s[..k] {
        if i % p != 0 {
            return 0;
        }
    }

    if d >= 3 {
        let o = n - (p + r);
        n = p + r;
        s = Rc::new(s[k..].iter().map(|i| i - o).collect());
    } else if n == p {
        return 1;
    } else if k != 0 {
        s = Rc::new(s[k..].to_vec());
    }

    let query = (n, p, s);
    if let Some(&c) = memo.get(&query) {
        return c;
    }
    let (n, p, s) = query;

    let t = Rc::new(s.iter().map(|i| i - p).collect::<Vec<_>>());
    let c = if d < 2 {
        (1..r + 1).map(|q| f(memo, r, q, t.clone())).sum()
    } else if r == p {
        (1..p + 1)
            .filter(|&q| p % q != 0 || q == p)
            .map(|q| f(memo, r, q, t.clone()))
            .sum()
    } else {
        let t = match t.binary_search(&p) {
            Ok(_) => t,
            Err(k) => {
                Rc::new(t[..k]
                            .iter()
                            .cloned()
                            .chain(once(p))
                            .chain(t[k..].iter().cloned())
                            .collect::<Vec<_>>())
            }
        };
        (1..t.first().unwrap() + 1)
            .filter(|&q| p % q != 0 || q == p)
            .map(|q| f(memo, r, q, t.clone()))
            .sum()
    };
    memo.insert((n, p, s), c);
    c
}

fn main() {
    let mut memo = HashMap::new();
    let s = Rc::new(Vec::new());
    for n in 1.. {
        println!("{} {}",
                 n,
                 (1..n + 1)
                     .map(|p| f(&mut memo, n, p, s.clone()))
                     .sum::<u64>());
    }
}

Try it online!
How it works
This is a memoized implementation of the recursive predicate Ξ given in Leo Guibas, “Periods in strings” (1981).  The function f(memo, n, p, s) finds the number of correlations of length n with smallest period p and also each of the periods in the set s.

Makes you wonder if there is a faster solution to the other related problem. Very impressive!

Interestingly this is entirely memory limited. It speeds up to ~500 and then  suddenly slows down as it runs out of RAM.

Just a simple brute-force search, to get the challenge started:
#include <stdio.h>
#include <stdint.h>
#include <string.h>

typedef uint16_t u16;
typedef uint64_t u64;

static u64 map[1<<16];

int main(void)
{
    for (u64 n = 1;; ++n) {
        u64 result = 1;
        u64 mask = (1ul << n) - 1;
        memset(map, 0, sizeof(map));

        #pragma omp parallel
        #pragma omp for
        for (u64 x = 1ul << (n - 1); x < 1ul << n; ++x) {

            u64 r = 0;
            for (u64 i = 1; i < n; ++i)
                r |= (u64) (x >> i == (x & (mask >> i))) << i;
            if (!r)
                continue;

            u16 h = (u16) (r ^ r >> 13 ^ r >> 27);
            while (map[h] && map[h] != r)
                ++h;

            if (!map[h]) {
                #pragma omp critical
                if (!map[h]) {
                    map[h] = r;
                    ++result;
                }
            }
        }

        printf("%ld\n", result);
    }
}

Compile with clang -fopenmp -Weverything -O3 -march=native. On my machine it reaches n=34 in 2 minutes.
EDIT: sprinkled some OMP directives for easy parallelism.

@Lembik Is existence of a good answer outside of SE grounds for deletion? Shouldn’t you wait for somebody (possibly the commenter) to submit this algorithm as an answer, and accept that answer?

You make a very good point

Sadly I can't really test your parallel code in virtualbox as I have a total of two cores on my CPU.

I ran it in cygwin and it got to 32.

Python, n≈427
Rewrite @Anders Kaseorg's Rust answer in Python
TIO Link
import bisect
from collections import defaultdict
import time

memo = defaultdict(int)
s = []

def f(n, p, s):
    assert(p != 0)
    d = n // p
    assert(d >= 1)
    r = n - p * (d - 1 if d >= 2 else 1)

    k = bisect.bisect_left(s, n - r + 1)
    for i in s[:k]:
        if i % p != 0:
            return 0

    if d >= 3:
        o = n - (p + r)
        n = p + r
        s = [i - o for i in s[k:]]
    elif n == p:
        return 1
    elif k != 0:
        s = s[k:]

    query = (n, p, tuple(s))
    if query in memo:
        return memo[query]

    t = [i - p for i in s]
    if d < 2:
        c = sum(f(r, q, t) for q in range(1, r + 1))
    elif r == p:
        c = sum(f(r, q, t) for q in range(1, p + 1) if p % q != 0 or q == p)
    else:
        k = bisect.bisect_left(t, p)
        if k < len(t) and t[k] == p:
            pass
        else:
            t.insert(k, p)
        c = sum(f(r, q, t) for q in range(1, t[0] + 1) if p % q != 0 or q == p)
    memo[query] = c
    return c

start_time = time.time()
n = 1
while time.time() - start_time < 120:  # run for at most 2 minutes
    print(n, sum(f(n, p, s) for p in range(1, n + 1)))
    n += 1

source: Stack Exchange

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

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

sort: votes


text:
Am I a Special N-bonacci Number?
The N-bonacci sequence, originally invented by @DJMcMayhem in this question, is a sequence generated by starting with the integers 0 and 1, and then adding the previous N numbers to generate the next number.  The special N-bonacci sequence is an N-bonacci sequence beginning with a pair of numbers other than 0 and 1, which will be named X and Y.  If N is greater than the number of terms already in the sequence, simply add all available terms.
So for example the normal fibonacci sequence has an N of 2 (takes the previous two items), and an X and Y of 0 and 1, or 1 and 1, depending on who you ask.
Your Task:
You are to write a program or function that checks whether an inputted integer (A) is part of the special N-bonacci sequence generated by the next three integers (using the second input as N, and the third and fourth as X and Y).  Ensure that you handle the special case of N=1.
Input:
Four non-negative integers, A, N, X, and Y.
Output:
A truthy/falsy value that indicates whether A is part of the N-bonacci sequence generated by the N, X, and Y inputs.
Test Cases:
Input:    Output:
13,2,0,1->truthy
12,3,1,4->falsy
4,5,0,1-->truthy
8,1,8,9-->truthy
9,1,8,9-->truthy

12,5,0,1->falsy  [0,1]>[0,1,1]>[0,1,1,2]>[0,1,1,2,4]>[0,1,1,2,4,8]>[0,1,1,2,4,8,16]>etc.

Scoring:
This is code-golf, so the lowest score in bytes wins.

N==1 is such a weird case.

Yep, but weird cases are what makes this fun :)

If you do indeed want answers to handle the case N=1, you might want to call it out in the question, since many answers (including all current answers, I think) will have a failure condition that assumes a strictly increasing series. Also, can X and Y be negative? That will probably also  invalidate all existing answers.

No, X and Y are "non-negative integers" (in the question, under input).  N=1 has been edited into the question.

I think all existing answers fail to handle the non-increasing case where both X and Y are zero. Is it necessary to handle that case as well?

I think you should add the truthy cases 8,1,8,9 and 9,1,8,9 to ensure that N=1 case handling detects the non-repeated X value as well as the Y value. (If you want to handle 0,0 cases you should add that as well.)

Test case which I suspect very few answers get right: 2,1,1,0.

Jelly, 12 bytes
ḣ⁴S;µṀ<⁵µ¿⁵e

A full program taking [X,Y], N, A.
Try it online!
How?
ḣ⁴S;µṀ<⁵µ¿⁵e - Main link (monadic): [X,Y]
    µ   µ¿   - while:
     Ṁ       -   maximum value of the list
       ⁵     -   5th command line argument (3rd input) = A
      <      -   less than?
             - ...do:
 ⁴           -   4th command line argument (2nd input) = N
ḣ            -   head (get the first N (or less) items from the list)
  S          -   sum
   ;         -   concatenate (add the result to the front of the list)
          ⁵  - 5th command line argument (3rd input) = A
           e - exists in the resulting list?

Excellent.  Seems to work for me, anyway.  +1

To instead see the reversed N-bonacci sequence up to a value greater than or equal to A just remove the ⁵e from the end; much easier to tell it will work then (noting that the order of the first two terms is of no consequence).

Tried a bunch of test cases, so unless someone finds one it fails, it's good with me.

05AB1E, 18 bytes
[DR²£O©‚˜³®>‹#]³QZ

Try it online!

Uses: [X,Y], N, A

I feel like some unintended functionality made that harder than it needed to be.
There's no greater-than-or-equal-to, never noticed that before.
And #³ didn't work, and required a ], for +1 bytes #]³.

Python 2, 59 56 bytes
a,n,l=input()
while l[0]<a:l=[sum(l[:n])]+l
print a in l

Try it online!
Takes input as A,N,[X,Y]

Here is a wrapper for all test cases if you like it.

Here are 2 bytes golfed off.

Perl 6, 47 bytes
->\A,\N,\X,\Y{A∈(X,Y,{[+] @_.tail(N)}...*>A)}

test it
Expanded:
->
  \A,
  \N,
  \X, \Y
{
    A          # is ｢A｣

  ∈            # an element of

    (          # this Sequence

      X, Y,        # seed values of sequence

      {            # generate the rest of the Seq using this code block

        [+]        # reduce by addition

          @_       # of all previously generated values
          .tail(N) # only use the last ｢N｣ of them
      }

      ...          # keep generating values until

      * > A        # it is greater than ｢A｣

    )
}

Python 2, 50 bytes
a,n,l=input()
while[a]>l:l=[sum(l[:n])]+l
a in l>x

Takes input as A,N,[Y,X]. Outputs via exit code.
Try it online!

R, 69 60 bytes
function(a,n,l){while(l<a)l=c(sum(l[1:n],na.rm=T),l)
a%in%l}

Try it online!
Returns an anonymous function, taking a,n and a vector l=c(y,x). Constructs the N-bonacci sequence backwards (i.e., smaller index is further in the sequence), since while(l<a) only checks the first element of l.

Common Lisp, 164 bytes
(defun f(a n x y &aux(l(list y x)))(if(= n 1)(or(= a x)(= a y))(loop(if(<= a(car l))(return(member a l))(setf l(cons(reduce'+ l)(if(<(length l)n)l(butlast l))))))))

This function returns NIL for false, non-NIL for true (according to the definition of generalized boolean of Common Lisp).
(defun f(a n x y &aux (l (list y x)))    ; initialize a list l for the N values
  (if (= n 1)                            ; special case for N = 1
      (or (= a x) (= a y))               ;    true only if A = X or A = Y
      (loop
        (if (<= a (car l))               ; when the last number generated is greater than A
            (return (member a l))        ; return true if A is in the list
            (setf l (cons (reduce '+ l)  ; otherwise compute the sum of l
                          (if (< (length l) n)   ; and push it to l (truncating the list at
                              l                  ; end if it has already size = N)
                              (butlast l))))))))

Does you special-case handling for N=1 detect an A of, e.g., both 1 and/or 2 when X=1 Y=2? My Lisp-reading skills are not great, but it looks like you might only compare A to one of the two initial values.

@apsillers , when N=1 I compare A only with X and not with Y. should I compare it with both returning true if it is equal to one of them? Maybe the sequence is not well defined for this case?

Ok, now I see the question has been changed, I have updated my answer.

k, 29 bytes
{x=*(*x>){(x=#y)_y,+/y}[y]/z}

Try it online! 1 is truthy, 0 is falsey. Input is [A;N;X,Y].

I ran it on all examples that I saw. 1 is truthy, 0 is falsey.

@Gryphon I moved the input over to the footer instead of the body, but I'm not certain what you want me to change. It both is and was the same function.

Oh, I see now.  I thought you weren't taking any input, but you were taking it in the code.  Makes much more sense now.  I don't know k, so I assumed you'd missinterpreted the question, as all it would do was output 1 0 1 1

Mathematica, 94 bytes
(s={#3,#4};t=1;While[t<#2-1,s~AppendTo~Tr@s;t++];!LinearRecurrence[1~Table~#2,s,#^2]~FreeQ~#)&

input format

[A,N,X,Y]

PHP>=7.1, 103 Bytes
for([,$n,$d,$s,$e]=$argv,$f=[$s,$e];$x<$n;)$x=$f[]=array_sum(array_slice($f,-$d));echo+in_array($n,$f);

Testcases

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


text:
Draw a sudoku board using line drawing characters
This is code golf. For this challenge, I will accept a method (you don't need a full program), but the method signature does count towards the byte count and I want to see the full signature (not a lamdba). The input for the method is an integer array with 81 elements. The output/return value from the method is a string that represents the array as an ascii sudoku board.
If you're using an esoteric language or something that absolutely doesn't have methods, you can adapt, but if the language supports this at all I want to see something might actually be plugged into a "real" ungolfed program, even if the method body itself is a pain to work with. The requirement is not meant to block languages like Jelly or 05AB1E, but to make it easier for languages like Java to build something that makes sense for that platform.
For the input, integer values 1-9 should have obvious meanings. A 0 should always be interpreted as a blank cell. You may also interpret anything else outside the 1-9 range as a blank cell, but this is not required. Positioning from the array to the puzzle starts at the top left and fills each row from left to right before moving to the next row.
For the boxes, I want double lines around the outside and between each 3x3 region, and single lines between other cells. These should be drawn with line drawing characters (if your I/O format represents strings as a sequence of bytes rather than a sequence of characters, you should represent them in a well-known encoding such as UTF-8 or codepage 347).
For this challenge, I am NOT asking you to generate the sudoku puzzle. That is the input for the function. I am NOT asking you to solve the puzzle. I'm just asking you to produce a string to "draw" what you're given (in as few bytes as possible).
Example Input:
Values for the array:
{ 8, 5, 0, 0, 0, 2, 4, 0, 0, 7, 2, 0, 0, 0, 0, 0, 0, 9, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 7, 0, 0, 2, 3, 0, 5, 0, 0, 0, 9, 0, 0 ,0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 7, 0, 0, 1, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 6, 0, 4, 0}

The values can use whatever mechanism is natural for your language: int[], ArrayList, sequence, tuple, string of digits, whatever, as long as you have a value in the input for every cell (no maps for only populated cells to positions). Remember that the input is supplied... it is not part of your byte count. But the input might represent any sudoku puzzle, and the puzzle might not even have a valid solution. You do get to assume that puzzle is printable. You won't get something with 82 elements, for example.
You also get to assume a reasonable fixed-width font.
Corresponding Output:

╔═══╤═══╤═══╦═══╤═══╤═══╦═══╤═══╤═══╗
║ 8 │ 5 │   ║   │   │ 2 ║ 4 │   │   ║
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢
║ 7 │ 2 │   ║   │   │   ║   │   │ 9 ║
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢
║   │   │ 4 ║   │   │   ║   │   │   ║
╠═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╣
║   │   │   ║ 1 │   │ 7 ║   │   │ 2 ║
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢
║ 3 │   │ 5 ║   │   │   ║ 9 │   │   ║
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢
║   │ 4 │   ║   │   │   ║   │   │   ║
╠═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╣
║   │   │   ║   │ 8 │   ║   │ 7 │   ║
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢
║   │ 1 │ 7 ║   │   │   ║   │   │   ║
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢
║   │   │   ║   │ 3 │ 6 ║   │ 4 │   ║
╚═══╧═══╧═══╩═══╧═══╧═══╩═══╧═══╧═══╝

Are you sure about the method part? That doesn't make sense for a lot of languages (i.e., languages without methods).

For languages that don't have methods, you can adapt. But if they do, I'm looking for something that might actually be useful to plug into a "real" program. I'll add that to question.

What's the reasoning for not allowing lambdas? Those could certainly be plugged into a "real" program just as well as named functions / methods

Nitpicky but important: There's no such thing as an "ASCII box drawing character." ASCII covers codes 0 through 127, none of which are box drawing characters. In recent times, Unicode is the standard, but it has several different encodings: UTF-8, UTF-16 etc, all of which use more than 1 byte per boxdrawing character. Older encodings such as Codepage 437 support single-byte box drawing characters. When you use characters outside the ASCII range, you should specify which encodings are valid. https://en.wikipedia.org/wiki/Box-drawing_character https://en.wikipedia.org/wiki/Unicode

"Method" should probably be "named function" to get the closest possible equivalent to a method in non-object-oriented languages. (For example, C, a widely used language, doesn't have methods but does have named functions.) In most of the languages I'm aware of which have methods, they're that language's equivalent of a named function. (The best-known exception I'm aware of is C++, where using a named function would be a lot more plausible for this task than using a method would be, as it's really unclear what sort of object you'd associate the method with.)

Python 3, 232 bytes
Thanks to those who helped to golf this down.
Encryption within encryption...
q=lambda x,y:x+y+x+y+x
r=lambda a,b,c,d,e:a+q(q(b*3,c),d)+e+"\n"
print(((r(*"╔═╤╦╗")+q(q("║ %d │ %d │ %d "*3+"║\n",r(*"╟─┼╫╢")),r(*"╠═╪╬╣"))+r(*"╚═╧╩╝"))%eval(input())).replace(*"0 "))

Try it online!
To be golfed.

How did I not notice that... that's like the entire reason why I used Python 2, but thanks.

Actually you're better off using Python 3 since then you won't need the first line.

You can remove more parens on the last line: tio

Remove definition of f and define i as i=["╔"+(g+"╦")*2+g+"╗"]+d+2*(["╠"+(e+"╬")*2+e+"╣"]+d)+["╚"+(h+"╩")*2+h+"╝"] saves 4 bytes

C (gcc), 398 395 291 bytes
Saved 3 bytes by working through the string reversed, and 104 (!) bytes thanks to Leaky Nun.
#include<locale.h>
#define q(x,y) x y x y x
#define D L"╝"q(q("═══","╧"),"╩")"╚"q(q("\n║"q(q(" & ","│"),"║")"║","\n╢"q(q("───","┼"),"╫")"╟"),"\n╣"q(q("═══","╪"),"╬")"╠")"\n╗"q(q("═══","╤"),"╦")"╔"
i;f(int*t){setlocale(LC_ALL,"");for(i=721;i--;)wprintf(L"%lc",D[i]%19?D[i]:*t++?48+t[-1]:32);}

Try it online!
C (gcc), 395 bytes
I'll keep this here so its more evident as to how the program works.
#include<locale.h>
#define A L"\n╢───┼───┼───╫───┼───┼───╫───┼───┼───╟"
#define B L"\n║ & │ & │ & ║ & │ & │ & ║ & │ & │ & ║"
#define C L"\n╣═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╠"
#define E B A B A B
#define D L"╝═══╧═══╧═══╩═══╧═══╧═══╩═══╧═══╧═══╚"E C E C E L"\n╗═══╤═══╤═══╦═══╤═══╤═══╦═══╤═══╤═══╔"
i;f(int*t){setlocale(LC_ALL,"");for(i=721;i--;)wprintf(L"%lc",D[i]%19?D[i]:*t++?48+t[-1]:32);}

Try it online!
Working with unicode in C is... costly. Takes input as an int* as shown in the link and in the specification.
I'm going to see if I can save bytes using some number magic instead of hardcoding the string.

355 bytes

@LeakyNun Huh, thanks! It's 291 bytes according to TIO

TIO is counting using SBCS.

PHP, 297 bytes
<?for(;$l<19;$l++)echo$l&1?strtr(vsprintf(str_pad("",67,"║ %d │ %d │ %d "),array_slice($_GET,9*($l/2^0)-9,9)),0," "):str_pad([╔,╟,╠,╚][$b=$l?$l<18?$l%6<1?2:1:3:0],108,strtr("11101110111".[╦,╫,╬,╩][$b],[[╤,═],[┼,─],[╪,═],[╧,═]][$b])).[╗,╢,╣,╝][$b],"
";

Try it online!
Expanded
for(;$l<19;$l++)  # loop thrpugh lines
  echo$l&1 # Output
    ?strtr(
        vsprintf(str_pad("",67,"║ %d │ %d │ %d ") # formated string for lines with numbers
        ,array_slice($_GET,9*($l/2^0)-9,9)) # nine items of the input array
      ,0," ") #replace zeros with space
    :str_pad([╔,╟,╠,╚][$b=$l?$l<18?$l%6<1?2:1:3:0] # start character non number lines and switch number four cases
      ,108 # fill too 108 bytes
      ,strtr("11101110111".[╦,╫,╬,╩][$b] # with string
        ,[[╤,═],[┼,─],[╪,═],[╧,═]][$b]))  #replace ones and zero with the two character in array chosed
    .[╗,╢,╣,╝][$b] # end row with chosen character
  ,"
    "; # end line with new line

used functions for both versions
vsprintf , strtr , str_pad , array_slice , array_chunk
PHP, 313 bytes
<?$r=($s=str_pad)(╔,108,($t=strtr)(($p=11101110111).╦,[╤,═])).╗;foreach(array_chunk($_GET,9)as$v)$r.=$t(vsprintf($s("
",68,"║ %d │ %d │ %d "),$v),0," ").(++$k%9?$k%3?$s("
╟",109,$t($p.╫,[┼,─])).╢:$s("
╠",109,$t($p.╬,[╪,═])).╣:"");echo$r.$s("
╚",109,$t($p.╩,[╧,═])).╝;

Try it online!

How does this work?

@Cyoce I have added an explanation for my new version

T-SQL, 445 437 bytes (in 381 characters)
DECLARE @r INT=0,@ NVARCHAR(999)=N'╔=╤=╤=╦=╤=╤=╦=╤=╤=╗P'p:SELECT @+=FORMAT(CAST(SUBSTRING(a,@r*9+1,9)AS INT),N'║ 0 │ 0 │ 0 ║ 0 │ 0 │ 0 ║ 0 │ 0 │ 0 ║P')FROM t
SET @r+=1IF @r=9SET @+=N'╚=╧=╧=╩=╧=╧=╩=╧=╧=╝P'ELSE IF @r%3=0SET @+=N'╠=╪=╪=╬=╪=╪=╬=╪=╪=╣P'ELSE SET @+=N'╟-┼-┼-╫-┼-┼-╫-┼-┼-╢P'IF @r<9GOTO p
PRINT REPLACE(REPLACE(REPLACE(REPLACE(@,'=',N'═══'),'-',N'───'),'0',' '),'P',CHAR(13))

Input is via a string of digits stored in column a of pre-existing table t, per approved methods.
Format and Explanation:
DECLARE @r INT=0, @ NVARCHAR(999)= N'╔=╤=╤=╦=╤=╤=╦=╤=╤=╗P'
p:
    SELECT @+= FORMAT(CAST(SUBSTRING(a, @r*9+1, 9) AS INT),
        N'║ 0 │ 0 │ 0 ║ 0 │ 0 │ 0 ║ 0 │ 0 │ 0 ║P') FROM t
    SET @r+=1
    IF @r=9 SET @+= N'╚=╧=╧=╩=╧=╧=╩=╧=╧=╝P'
    ELSE IF @r%3=0 SET @+= N'╠=╪=╪=╬=╪=╪=╬=╪=╪=╣P'
    ELSE SET @+= N'╟-┼-┼-╫-┼-┼-╫-┼-┼-╢P'
IF @r<9 GOTO p
PRINT REPLACE(REPLACE(REPLACE(REPLACE(@, '=',N'═══'), '-',N'───'), '0',' '), 'P',CHAR(13))

In the top line of the loop I'm getting the next 9 digits of the input string from column a of pre-existing table t.
I convert that string of digits to an integer, and use the .Net FORMAT function to display them using a custom text template '║ 0 │ 0 │ 0 ║ 0 │ 0 │ 0 ║ 0 │ 0 │ 0 ║P'.
After that I just append the appropriate divider line, and make some byte-saving replacements before output.
Output is displayed in the results pane:
╔═══╤═══╤═══╦═══╤═══╤═══╦═══╤═══╤═══╗
║ 8 │ 5 │   ║   │   │ 2 ║ 4 │   │   ║
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢
║ 7 │ 2 │   ║   │   │   ║   │   │ 9 ║
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢
║   │   │ 4 ║   │   │   ║   │   │   ║
╠═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╣
║   │   │   ║ 1 │   │ 7 ║   │   │ 2 ║
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢
║ 3 │   │ 5 ║   │   │   ║ 9 │   │   ║
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢
║   │ 4 │   ║   │   │   ║   │   │   ║
╠═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╣
║   │   │   ║   │ 8 │   ║   │ 7 │   ║
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢
║   │ 1 │ 7 ║   │   │   ║   │   │   ║
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢
║   │   │   ║   │ 3 │ 6 ║   │ 4 │   ║
╚═══╧═══╧═══╩═══╧═══╧═══╩═══╧═══╧═══╝

I previously had some additional replacements for some of the other drawing characters, but they ultimately didn't save me bytes.
EDIT 1: Saved 8 bytes by starting @r at zero instead of 1, and removing some unneeded spaces.

Retina, 196 167 bytes
.{27}
¶N#=XZ#Q¶|$&
\d{9}\B
$&¶M#─┼Y#P¶|
\d{3}
 $& |
\B\d
 │ $&
^¶.*
B#=RT#E
$
¶H#=UW#K
+`#([^#¶]+)([^#¶])#
#$1#$2#$1#$2#$1#
#(.)#
$1$1$1
T`0=|#L` ═-╬

Try it online! Takes input as a string of length 81. Explanation: Because the box drawing characters cost three bytes, the unicode code points ═-╬ are represented in the code using =|#A-Z (not all the characters are used but sticking to ranges saves bytes). Additionally the rows are compressed using # signs: a#bcd#e expands to abbbcbbbcbbbdbbbcbbbcbbbdbbbcbbbcbbbe.
.{27}
¶N#=XZ#Q¶|$&

Inserts ╠═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╣ for every third row, plus a ║ at the start of every group of 27.
\d{9}\B
$&¶M#─┼Y#P¶|

Inserts ╟───┼───┼───╫───┼───┼───╫───┼───┼───╢ between the other rows, plus ║s at the start of those rows.
\d{3}
 $& |

Inserts ║s after every three digits. All the ║s have now been inserted.
\B\d
 │ $&

Inserts |s between all the remaining pairs of digits. (This one is the actual box drawing character rather than a pipe. Unfortunately the characters ─│┼ have codes too far apart from each other and the double box characters to make it worth while using placeholders.)
^¶.*
B#=RT#E

Changes the first row to ╔═══╤═══╤═══╦═══╤═══╤═══╦═══╤═══╤═══╗ (this saves 1 byte over not adding the first row in the first place).
$
¶H#=UW#K

Adds ╚═══╧═══╧═══╩═══╧═══╧═══╩═══╧═══╧═══╝ after the last row.
+`#([^#¶]+)([^#¶])#
#$1#$2#$1#$2#$1#

Expands a#bcd#e, first to a#bc#d#bc#d#bc#e, then to a#b#c#b#c#b#d#b#c#b#c#b#d#b#c#b#c#b#e.
#(.)#
$1$1$1

Changes #b# to bbb. This completes the decompression.
T`0=|#L` ═-╬

Deletes all the zero entries, and replaces the placeholders with the box drawing characters.

You forgot to replace 0 by space.

Also has double lines around every row, rather than just the border and 3x3 regions.

@JoelCoehoorn Fixed, sorry.

@LeakyNun Thanks, I'd overlooked that. (Also, I like to avoid lines ending with, or especially only containing, spaces, which is why I looked for an alternative 2-byte saving.)

JavaScript (ES6), 246 bytes / 198 chars
(n,r=(x,y)=>x+y+x+y+x,q=s=>([u,w,x,y,z]=[...s[0]],u+r(r(w+w+w,x),y)+z+`
`))=>q`╔═╤╦╗`+n.reduce((o,v,i)=>o+"║││"[i++%3]+` ${v||" "} `+(i%9?e:`║
`+(i-27&&i-54?i<81?q`╟─┼╫╢`:e:q`╠═╪╬╣`)),e="")+q`╚═╧╩╝`

Input is an array of integers. Ended up using the same two helper functions as Leaky Nun's Python answer, so credit goes there.
If function is required, 263 bytes / 215 chars
function g(n,r=(x,y)=>x+y+x+y+x,q=s=>([u,w,x,y,z]=[...s[0]],u+r(r(w+w+w,x),y)+z+`
`)){return q`╔═╤╦╗`+n.reduce((o,v,i)=>o+"║││"[i++%3]+` ${v||" "} `+(i%9?e:`║
`+(i-27&&i-54?i<81?q`╟─┼╫╢`:e:q`╠═╪╬╣`)),e="")+q`╚═╧╩╝`}

Test Snippet
Any input of 81 numbers is supported (1234, 1, 2, 3, 4. [1 2 3 4], etc). Best viewed as full page.

f=
(n,r=(x,y)=>x+y+x+y+x,q=s=>([u,w,x,y,z]=[...s[0]],u+r(r(w+w+w,x),y)+z+`
`))=>q`╔═╤╦╗`+n.reduce((o,v,i)=>o+"║││"[i++%3]+` ${v||" "} `+(i%9?e:`║
`+(i-27&&i-54?i<81?q`╟─┼╫╢`:e:q`╠═╪╬╣`)),e="")+q`╚═╧╩╝`

onload=I.oninput=_=>O.innerHTML=(m=I.value.match(/\d/g))&&m.length==81?f(m.map(x=>+x)):''
<textarea id=I rows=3 style="width:95%">8, 5, 0, 0, 0, 2, 4, 0, 0, 7, 2, 0, 0, 0, 0, 0, 0, 9, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 7, 0, 0, 2, 3, 0, 5, 0, 0, 0, 9, 0, 0 ,0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 7, 0, 0, 1, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 6, 0, 4, 0</textarea>
<pre id=O>

SOGL V0.12, 174 172 164 160 158 bytes
«ž#>]Wž²6√±_ΕΨ╥╬]v←ē⅓ZΗ⌡z∫◄‽q   §↑╗∑Ολ[Μ↕z↓/∆Yn⁄:Ο║χ≥¾▓g*≈]═+π℮─6⁽SE/⁷,0+►Ƨ⌡u\^⁄-▼0cΦ“╤─┼╬│║═╔╗╚╝”Φ⅜nΡ¡ΞΨīŗ(`½│uģ“ ╬ζ─{ζ} 6Δ¹∑A'⁄─{IaW}¹∑#¶ŗ3 ¶ŗ ”+Ƨøp+!!┌d0@ŗčŗ

Overly long explanation:
...“                          push a big base-43 encoded number; will be used later. It's pushed here to save a byte on a quote
    ...”                      push "╤─┼╬│║═╔╗╚╝" - the chars in SOGLs encoding
        ...“                  push 679301851737965572513837476350078477
             ╬                push "╬"
              ζ               convert it to its codepoint (9580)
               ─              convert that number to an array of base-9580 numbers
                {ζ}           convert each number to a character (pushing each on the stack)
                    6Δ        push all ascii chars up to 6 (" !"#$%&'()*+,-./0123456")
                      ¹∑      join all the strings on the stack together ("╤─┼╬│║═╔╗╚╝╦╟╫╢╠╪╣╧╩ !"#$%&'()*+,-./0123456")
                        A     save on variable `A`. Now ontop of the stack is the 1st big number
                         '⁄─  onvert from base 43

{   }                           for each number do
 I                                increase
  aW                              get its position in the variable A
     ¹∑                         join all the strings ontop of the stack (the loop above pushed each char separately)
       #¶ŗ                      replace quote (") characters with newlines
          3 ¶ŗ                  replace 3s with "¶"
               ”+               append "”"
                 Ƨøp+           append "øp"
                     !!         execute the created code as SOGL
                       ┌        push "-"
                        d       push variable d - defaults to string input. In a full program could be set as an input
                         0@ŗ    replace zeroes with spaces
                            č   chop into an array
                             ŗ  replace ["-" with input chopped - so each iteratively]

The program that's executed:
───!#
 - $
¶%&¶'(
)╪)╪)+
)╤)╤),
)╧)╧).
┼#
+╬+/
0!╫0!1
,╦,2
.╩.4
5│$║&
#0
═══)
$│$5
║&&%
╠/╬+╣6'*
╟1╫0!╢(
(6
╔2╦,╗6'**╚4╩.╝”øp

where all but last line are just in the entire program replace occurrences of the last char of this line with the rest of this line. This is the reason it was possible to make half of the chars just random ascii (but getting so that spaces, dashes, and quotes are usefully used took a while to figure out)
...”    push the whole sudoku grid
    øp  print nothing (prevents bug that this code would already print and pop the result)

Try it Here!
The online interpreter code is more correct because tabs don't work with SE
-8 bytes: brute force replacement compressing the entire board, then replacing foreign chars (to the codepage) with their codepoints. Doing this took an hour less than the old program...
-4 bytes: compressing the compressed string...
-2 bytes: using a variable+string instead of array

Batch, 332 bytes
@echo off
set/ps=
set s=%s:0= %
call:l É Í Ñ Ë »
set t="Ç Ä Å × ¶"
for %%i in (%t% %t% "Ì Í Ø Î ¹" %t% %t% "Ì Í Ø Î ¹" %t% %t% "È Í Ï Ê ¼")do call:c %%~i
exit/b
:c
set t=º
for %%j in (³ ³ º ³ ³ º ³ ³ º)do call set t=%%t%% %%s:~,1%% %%j&call set s=%%s:~1%%
echo %t%
:l
set t=%2%2%2%3%2%2%2%3%2%2%2
echo %1%t%%4%t%%4%t%%5

Needs the console to be in CP437. If that's not your default, then you can change it using the CHCP 437 command if your console is set to TrueType fonts. (It will only work with raster fonts if CP437 is already your default code page.) This is what the code looks like in CP437:
@echo off
set/ps=
set s=%s:0= %
call:l ╔ ═ ╤ ╦ ╗
set t="╟ ─ ┼ ╫ ╢"
for %%i in (%t% %t% "╠ ═ ╪ ╬ ╣" %t% %t% "╠ ═ ╪ ╬ ╣" %t% %t% "╚ ═ ╧ ╩ ╝")do call:c %%~i
exit/b
:c
set t=║
for %%j in (│ │ ║ │ │ ║ │ │ ║)do call set t=%%t%% %%s:~,1%% %%j&call set s=%%s:~1%%
echo %t%
:l
set t=%2%2%2%3%2%2%2%3%2%2%2
echo %1%t%%4%t%%4%t%%5

With ideas harvested from other answers:
C# (.NET Core), 401 bytes, 349 Chars
string s(string x){Func<string,string,string>q=(m,n)=>m+n+m+n+m;var a="╔"+q(q("=","╤"),"╦")+"╗";for(var i=0;i<9;) {a+=int.Parse(x.Substring(i*9,9)).ToString("\n║"+q(q(" 0 ","│"),"║")+"║\n")+(i++<8?(i%3>0?"╟"+q(q("-","┼"),"╫")+"╢":"╠"+q(q("=","╪"),"╬")+"╣"):"╚"+q(q("=","╧"),"╩")+"╝");}return a.Replace("=","═══").Replace("-","───").Replace("0"," ");}

Ungolfed:
static public string s(string x)
{
    Func<string,string,string>q=(m,n)=>m+n+m+n+m;
    var a="╔"+q(q("=","╤"),"╦")+"╗";
    for (var i=0;i<9;) //once per row
    {
        //parse that row to an int, then spit out a formatted string
        a += int.Parse(x.Substring(i*9,9)).ToString("\n║"+q(q(" 0 ","│"),"║")+"║\n")
          // as well as a trailing row for the box
          + (i++<8?(i%3>0?"╟"+q(q("-","┼"),"╫")+"╢":"╠"+q(q("=","╪"),"╬")+"╣"):"╚"+q(q("=","╧"),"╩")+"╝");
    }
    //expand placeholder characters before returning
    return a.Replace("=","═══").Replace("-","───").Replace("0"," ");
}

Try it online!
My Answer:
C# (.NET Core), 509 430 418 bytes, 328 chars
string b(string x){var a="╔=╤=╤=╦=╤=╤=╦=╤=╤=╗\n║";for(int i=0,j=0,k,l,m;j<3;j++)for(k=0;k<3;k++){for(l=0;l<3;l++)for(m=0;m<3;)a+=" "+x[i++]+(m++<2?" │":" ║");a+=i<80?(k<2?"\n╟-┼-┼-╫-┼-┼-╫-┼-┼-╢\n║":"\n╠=╪=╪=╬=╪=╪=╬=╪=╪=╣\n║"):"\n╚=╧=╧=╩=╧=╧=╩=╧=╧=╝";}return a.Replace("=","═══").Replace("-","───").Replace("0"," ");}

Ungolfed:
public string s(string x)
{
    var a = "╔=╤=╤=╦=╤=╤=╦=╤=╤=╗\n║";
    for (int i=0,j=0,k,l,m;j<3;j++)
    {
        for (k = 0; k < 3;k++)
        {
            for (l = 0; l < 3; l++)
            {
                for (m = 0; m < 3;)
                    a += " " + x[i++] + (m++ < 2 ? " │" : " ║");
            }
            a += i < 80 ? (k < 2 ? "\n╟-┼-┼-╫-┼-┼-╫-┼-┼-╢\n║": "\n╠=╪=╪=╬=╪=╪=╬=╪=╪=╣\n║")
                        : "\n╚=╧=╧=╩=╧=╧=╩=╧=╧=╝";
        }
    }
    return a.Replace("=", "═══").Replace("-","───").Replace("0"," ");
}

I also looked at using a lambda for the `for` loops here, but it actually cost me one byte (saved 10 bytes per loop, with 41 bytes of overhead).

Try it online!

Do you need to count each drawing character as two bytes?

I did, fixed now. I had meant to address that in question and count characters rather than bytes, because of those characters, but I suppose it's too late now.

Yep, bytes is harder, some ascii substitutions save bytes but don't impact characters (or even hurt characters). I'm working on T-SQL, and char vs nchar is a pretty big difference.

Tcl, 373 bytes (273 chars)
Very naïve approach, but I just had to do it even it not being a winner by any measure:
puts ╔[set D ═══]╤$D╤$D╦$D╤$D╤$D╦$D╤$D╤$D╗
set r ║
lmap x $L {set r $r\ [expr $x?$x:{ }]\ [expr [incr i]%3?"│":"║"]
if ![expr $i%9] {puts $r\n[expr $i%27?"╟[set S ───]┼$S┼$S╫$S┼$S┼$S╫$S┼$S┼$S╢":$i<72?"╠$D╪$D╪$D╬$D╪$D╪$D╬$D╪$D╪$D╣":"╚$D╧$D╧$D╩$D╧$D╧$D╩$D╧$D╧$D╝"]
set r ║}}

Try it online!

Same chars expense but more bytes:
Tcl, 421 bytes (273 chars)
puts ╔[set D ═══]╤$D╤$D╦$D╤$D╤$D╦$D╤$D╤$D╗
set r ║
lmap x $L {set r $r\ [expr $x?$x:{ }]\ [expr [incr i]%3?"│":"║"]
if ![expr $i%9] {puts $r\n[expr $i%27?"╟───┼───┼───╫───┼───┼───╫───┼───┼───╢":$i<72?"╠$D╪$D╪$D╬$D╪$D╪$D╬$D╪$D╪$D╣":"╚$D╧$D╧$D╩$D╧$D╧$D╩$D╧$D╧$D╝"]
set r ║}}

Try it online!

that's 599 UTF-8 bytes. You should try to reuse the common box characters to save bytes

@dzaima:l know, I can do what I did on A keyboard so real you can almost TASTE it

@dzaima: It is why I said Very naïve approach

Chip, 3645 bytes
...that's not a typo...
ooooooZZ-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-).
|`xxxx-x--(x---x---x---x---x-v-x---x---x---x---x---x-.`K-)-K-)-K-)-K-).
|b|`xx-x--(x-v-x---x-v-x---x-x-x---x-v-x---x-v-x---x-x-x---x-v-x---x-.`K-).
|>xd`x-x(v-x-x-x-v-x-x-x-v-x-x-x-v-x-x-x-v-x-x-x-v-x-x-x-v-x-x-x-v-x-x-x-.|
||`--x-x-x(x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x/.
|`--z',/\',/\',/\',/\',/\',/\',/\',/\',/\',/\',/\',/\',/\',/\',/\',/\',/\','
`-. |,< >.| >.| >.| >.| >.| >.| >.| >.| >.| >.| >.| >.| >.| >.| >.| >.| >.|
*-x-/xZ/xZ^/xZ^/xZ^/xZ^/xZ^/xZ^/xZ^/xZ^/xZ^/xZ^/xZ^/xZ^/xZ^/xZ^/xZ^/xZ^/xZ'
Z~' |`'|`' |`' |`' |`' |`' |`' |`' |`' |`' |`' |`' |`' |`' |`' |`' |`','`'
    `)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)'
=
oooooo).h
`)))--^M^Zh
=
oooooo
|    `(--------------------------------------------------------------------------------------------------------va
KZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ^cg
)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx-xKZvvZ
xxxxxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxxx-Kxxxx}e
)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)x))xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)x))xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)x)b`feac
  c
=
oooooo
,'   `(--------------------------------------------------------------------------------------------------------.cba
KZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ^x^^)v--.
xx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxxx-xK-'f e`.
)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx-x-K-+Z+Z}e
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx)xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx)xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxK^}b gac
xxxxxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxxx-K^d
=
oooooo
,-'
KZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZtabgfv------.
)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx-xK^^x-Zv-vZ}e
xxxxxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxxxK^---^}cade,]b
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx)xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx)xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx)-K----^-^^~'
,v'
db
=
oooooo
,--' `(--------------------------------------------------------------------------------------------------------v-.,-v-ZZZZZZZZZZZZf
KZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ'a{x.df
)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xxKx-xxv+Zc
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx)xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx)xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx)x-KZx+bge
xx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxxx---K\--^c
 a^b
=
oooooo
,---'`(--------------------------------------------------.
KZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ'gf
)xxxxx)xxxxx)xxxxx)xxxxx)xxxxx)xxxxx)xxxxx)xxxxx)xxxxx)xx-^KZc
)xxxxx)x)xxx)x)xxx)xxxxx)x)xxx)x)xxx)xxxxx)x)xxx)x)xxx)xxbahKZ\ZZZ
x))xxxxxxxxxxxxxxxx))xxxxxxxxxxxxxxxx))xxxxxxxxxxxxxxxx))-K-eh|fff
 ,--K-v-v-K--v-vK-v---K-----K-----K-----K-----K-----K `--Z-Z--'
A/ab/B/e/C/cd/D/-e/A
*}s

Try it online!, sort of. The TIO version contains a cutoff about a third of the way in (the t after the 4th oooooo), so that it should terminate in less than 60 seconds. The full version takes about 1m25s on my machine, and TIO seems about half as quick. This also means the TIO only shows the first 7 lines of output.
My first draft weighed in at a massive 19758 bytes, and took me about 8m30s to run. The final solution, pre-golfing, was a spry 5980 bytes, taking only 2m07s.
So, how's it work, then?
This takes a string of 82 bytes, 81 digits, followed by a terminator. \0 or \n or even another number will do. (This implementation actually only looks at the first 81, but requires at least one more, since Chip will terminate if it has exhausted its input. If this is unacceptable, the flag -z may be used, which effectively appends an infinite number of \0 bytes to the end of the input.) The shortened TIO code doesn't actually get to all 81 bytes, so the point is moot there.
The way I've implemented this, it only looks at the low 4 bits of the input, so anything, really, can be a sudoku 'puzzle', from raw binary data, to the lesser-known works of Shakespeare. Any character whose low 4 bits are all zero will appear as a space (a special case), all other characters map into 123456789:;<=>?. (So, the last few aren't digits, but neither is 10 a valid number in normal sudoku).
For the box-drawing characters, it produces UTF-8, equating to 3 bytes each.
What about the actual implementation?
Chip is a 3D language that is inspired by integrated circuits. It has wires, logic gates, and memory cells. Most stuff is done on 2D planes, but these planes may be stacked atop one another. That is how this program is built.
The lines that start with = are the layer separators. Then, the layers are stacked, with the top and left sides aligned. The o's serve as pins, allowing signals to pass from one layer to another.
Each layer here has a purpose, you could think of them as functions. The first layer controls everything; it 'calls' each of the other layers in turn. There is a repeating left-to-right pattern here. That pattern keeps track of which of the 19 lines of output we are currently printing.
The second layer is rather tiny, and it has a very tiny job. It sets the 0x80 bit for all the lines of output except the lines that contain numbers. h is the Chip element that corresponds to the 0x80 bit. (The low end of the alphabet h through a define all eight output bits.)
Layer three is where we really get into the meat of printing. This layer is in charge of line one. The ungolfed version has eight rows of x's and )'s, mapping to 0's and 1's for each of the eight bits of each byte. However, we can take advantage of the patterns in the bits to accomplish the same task in fewer rows.
Layer four is much like the third. It handles the horizontal double lines.
Layer five handles the last line. Note that it is missing the wire along the top that the other layers have. This is because we don't need to return control to the sequencer. Instead, we can just terminate execution here with t.
Layer six handles the horizontal single lines.
Layer seven is where the numbers are printed. It is 'called' for each the nine numeric lines. It consumes 9 bytes of input as part of its execution.

JavaScript (ES6), 222 bytes
Using short syntax for ES6 functions - 174 chars encoded in utf8, 222 bytes (https://mothereff.in/byte-counter). Using function ... requires 16 more bytes.
F=v=>[1,...v].map((x,i)=>'│║│'[i%3]+` ${x||' '} `+(i%9?'':`║
${[h,r,s,u,t]=i%27?'─╟╫┼╢':i>80?'═╚╩╧╝':i?'═╠╬╪╣':'═╔╦╤╗',r+(s=(u=(h+=h+h)+u+h+u+h)+s)+s+u+t}
`)).join``.slice(6)

Less golfed
F=v=>{
   // horizontal lines are appended after each 9th element
   // so I need to prepend a dummy first element to draw the top horizontal line
   v = [1, ...v];
   return v.map( (x,i) =>
     '│║│'[i % 3] + ` ${x||' '} ` // left bar and cell value
     + ( i % 9 ? '' // add horizontal line after each 9th element
       // the line drawing characters are chosen according to the value of i
       : `║\n${ [h, r, s, u, t] =
         i % 27 != 0
         ? '─╟╫┼╢'
         : i > 80
           ? '═╚╩╧╝' // i==81, bottom row
           : i != 0
             ? '═╠╬╪╣'
             : '═╔╦╤╗', // i==0, top row
         r + (s = (u = (h += h + h) + u + h + u + h) + s) + s + u + t
         }\n`
       )
   ).join``
   .slice(6) // cut the first cell (the dummy element)
}

F=v=>[1,...v].map((x,i)=>'│║│'[i%3]+` ${x||' '} `+(i%9?'':`║
${[h,r,s,u,t]=i%27?'─╟╫┼╢':i>80?'═╚╩╧╝':i?'═╠╬╪╣':'═╔╦╤╗',r+(s=(u=(h+=h+h)+u+h+u+h)+s)+s+u+t}
`)).join``.slice(6)

function go() {
  var i=I.value
  i = i.match(/\d+/g).map(x => +x); // convert strings to numbers
  O.textContent = F(i)
}
#I { width: 90% }
<input id=I value='8 5 0 0 0 2 4 0 0 7 2 0 0 0 0 0 0 9 0 0 4 0 0 0 0 0 0 0 0 0 1 0 7 0 0 2 3 0 5 0 0 0 9 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0 8 0 0 7 0 0 1 7 0 0 0 0 0 0 0 0 0 0 3 6 0 4 0'>
<button onclick='go()'>go</button>
<pre id=O></pre>

Java (OpenJDK 8), 279 bytes
String f(int[]a){String P="0121213121213121214",R[]={"╔═╤╦╗","║ │║║x","╟─┼╫╢","╠═╪╬╣","╚═╧╩╝"},r="";for(int X:P.getBytes()){for(int x:P.replace("1",R[X-=48].length()>5?"151":"111").getBytes())r+=R[X].charAt(x-48);r+="\n";}for(int i:a)r=r.replaceFirst("x",i>0?""+i:" ");return r;}

Try it online!
For the byte count, use CP-437, which is natively supported by Java as IBM437 (recent APIs) or Cp437 (older APIs); so use a system that has this charset has this charset as default charset.
This code is compatible from Java 5 onwards, but was tested on Java 8 only.
Explanation
String f(int[]a){
  String P="0121213121213121214",                         // Both lines and rows are repeated according to this pattern.
         R[]={"╔═╤╦╗","║ │║║x","╟─┼╫╢","╠═╪╬╣","╚═╧╩╝"},  // Characters found on each line.
                                                          //   (note the 'x')
         r="";                                            // The string under construction
  for (int X: P.getBytes()) {                             // For each line,
    for (int x:                                           //  For each character in the pattern,
         P.replace("1",R[X-=48].length()>5?"151":"111")   //    *but* with a cell width of 3,
                                                          //    and with an optional character ('x')
         .getBytes())
      r+=R[X].charAt(x-48);                               //   append the real mapped character
    r+="\n";                                              //  then append a new line
  }
  for(int i:a)                                            // For each number in the input
    r = r.replaceFirst("x",i>0?""+i:" ");                 //  replace the first 'x' with that number.
                                                          //    (or space if zero)
  return r;                                               // Return the constructed string.
}

SlimSharp, 284 characters (bytes not counted)
S b(S x){S a="╔=╤=╤=╦=╤=╤=╦=╤=╤=╗\n║";for(I i=0,j=0,k,l,m;j<3;j++)for(k=0;k<3;k++){for(l=0;l<3;l++)for(m=0;m<3;)a+=" "+x[i++]+(m++<2?" │":" ║");a+=i<80?(k<2?"\n╟-┼-┼-╫-┼-┼-╫-┼-┼-╢\n║":"\n╠=╪=╪=╬=╪=╪=╬=╪=╪=╣\n║"):"\n╚=╧=╧=╩=╧=╧=╩=╧=╧=╝";}return a.R("=","═══").R("-","───").R("0"," ");}

This is a simple adaption of my C# answer.


text:
Make String Waves
Given a string as input, output the string with the following algorithm applied:
1. Split the String by " " (find the words): "Hello World" -> ["Hello","World"]
2. Find the vowel count of each component: [2,1]   ( ["H[e]ll[o]","W[o]rld"] )
3. For each of the components, output the first n letter where n is the number
   of vowels it contains: ["He","W"]
4. Join the list to a single string and reverse it: "HeW" -> "WeH"

Specs

You may take input and provide output by any standard form, and the only data type allowed for both Input and Output is your language's native String type. Taking input directly as a list of individual words is not permitted.
You are guaranteed that there will be no consecutive spaces.
The vowels are "a","e","i","o","u","A","E","I","O","U", but "y","Y" are not considered vowels.
You are guaranteed that only letters and spaces will appear in the input, but without any newlines.
Output must be case-sensitive.
You are not guaranteed that each word contains a vowel. If no vowels appear in that word, you do not have to output anything for it.

Test Cases
Input -> Output
---------------

""                                  -> ""
"Hello World"                       -> "WeH"
"Waves"                             -> "aW"
"Programming Puzzles and Code Golf" -> "GoCauPorP"
"Yay Got it"                        -> "iGY"
"Thx for the feedback"              -> "eeftf"
"Go Cat Print Pad"                  -> "PPCG"
"ICE CREAM"                         -> "RCCI"

Scoring
The shortest valid submission for each language wins, this is code-golf. Good luck and have fun!

Sandbox for those who can see deleted posts.

Sorry for the temporary deletion!

Don't know why I thought this was going to be a PCG about string (as in String Theory) waves (as in oscillations in a field). Maybe it's time to go sleep.

@Mr.Xcoder: Please add a test case with uppercase vowels. Thanks!

@nimi Added. It's just the same algorithm, no matter the case.

@Mr.Xcoder: yes, but at least two answer got it wrong (both fixed now).

Haskell, 59 bytes
map fst.reverse.(>>=zip<*>filter(`elem`"aeiouAEIOU")).words

Try it online!
       words     -- split into a list of words
  (>>=      )    -- apply a function to every word and collect the results in a
                 -- single list
     zip<*>filter(`elem`"aeiouAEIOU")
                 -- f <*> g x = f x (g x), i.e. zip x (filter(...)x)
                 -- we now have a list of pairs of (all letters of x, vowel of x)
                 -- with the length of number of vowels
 reverse         -- reverse the list
map fst          -- drop vowels from the pairs

V, 31 bytes
Í /ò
òÄøã[aeiou]
|DJ@"|D-òÍî
æ

Try it online!
00000000: cd20 2ff2 0af2 c4f8 e35b 6165 696f 755d  . /......[aeiou]
00000010: 0a01 7c44 4a40 227c 442d f2cd ee0a e6    ..|DJ@"|D-.....

And explanation:
Í               " Substitute Every space
  /             " With
   ò            " Newlines
                " This puts us on the last line of the buffer
ò               " Recursively:
 Ä              "   Duplicate the current line
  ø             "   Count:
   ã            "   Case insensitive
    [aeiou]     "   The number of vowels
<C-a>           "   Increment this number
     |          "   Go to the beginning of this line
DJ              "   Delete the number of vowels, and remove a newline that was accidentally made.
                "   Also, my name! :D
  @"            "   Run the unnamed register, which is the number of vowels that we deleted
    |           "   And move to the n'th column in this line
     D          "   Delete everything on this line after the cursor, keeping the first *n* characters
      -         "   Move up a line
       ò        " End the loop
        Íî      " Remove all newlines
æ               " And reverse:
                "   (implicit) The current line

This is surprisingly readable... Can you add some words on how it works?

I'm impressed with how often I see æ used, I seem to remember it being added very recently and it's one of the more useful commands.

@nmjcman101 Yeah, I totally agree. æ is extremely useful. I should have added it a long time ago. ø is also really nice, it's cool that this answer uses both.

It seems to work without the first | (Try it online!), which is not in your explanation. But I don't know V; is it needed?

@CAD97 Ah, I did miss that in my explanation. That does work for all of the test cases, but it breaks when there are 10 or more vowels in a word (because <C-a> puts the cursor at the end of the word). https://tio.run/##K/v//3Cvgv7hTVyHNx1uObzj8OLoxNTM/NJYLkYXLwelGhddoHjv4XVch5f9/x@SUaGQll@kUJKRqpCWCgMpSYnJ2QA

Brachylog, 17 bytes
ṇ₁{{∋ḷ∈Ṿ}ᶜ}ᶻs₎ᵐc↔

Try it online!
Explanation
That's a direct translation of the problem:
Example input: "Hello World"

ṇ₁                  Split on spaces:         ["Hello", "World"]
  {       }ᶻ        Zip each word with:      [["Hello",2],["World",1]]
   {    }ᶜ            The count of:
    ∋ḷ∈Ṿ                Chars of the words that when lowercased are in "aeiou"

            s₎ᵐ     Take the first substring of length <the count> of each word: ["He","W"]
               c    Concatenate:             "HeW"
                ↔   Reverse:                 "WeH"

Perl 5 + -p040F, 35 bytes
$\=$_.$\for@F[0..lc=~y/aeiou//-1]}{

Try it online!

Does it work with upper case vowels, e.g. "Alabama"?

@nimi oooh, didn't think about that, updated for +1.

Japt v2.0a0, 12 10 bytes
¸®¯Zè\vÃ¬w

Try it

Explanation
Pretty much does exactly what the spec describes!
        :Implicit input of string U.
¸       :Split to array on spaces.
®       :Map over the array, replacing each element with itself ...
¯       :  sliced from the 0th character to ...
Zè\v    :  the count (è) of vowels (\v) in the element (Z).
Ã       :End mapping.
¬       :Join to a string.
w       :Reverse.
        :Implicit output of result.

Good thing I checked the existing answers before writing my own :P Nice one, I don't think it will get any shorter (though of course I could be wrong...)

Aside: in Japt 2.0 you could theoretically change "%v" to \v (a single-class regex literal, equivalent to /\v/). Not helpful yet, of course, since I haven't implemented v2.0 yet ;)

@ETHproductions, I was getting ready to run out the door when this challenge popped up so I just wrote it up quickly, taking it literally. There might be a shorter way to do it less literally, maybe? Those changes to the RegEx will be handy for saving a few bytes; looking forward to them

Perl 6, 57 bytes
{flip [~] .words.map:{.substr(0,.comb(rx:i/<[aeiou]>/))}}

Alice, 32 bytes
/.'*%-.m"Re.oK"
\iu &wN.;aoi$u@/

Try it online!
Explanation
/....
\...@/

This is just a framework for linear code in Ordinal (string-processing mode). Unfolding the program, we get:
i' %w.."aeiou".u*&-Nm;Ro.$K@

Here's what it does:
i           Read all input.
' %         Split the input around spaces.
w           Push the current IP address to the return address stack to mark
            the beginning of the main loop. Each iteration will process one
            word, from the top of the stack to the bottom (i.e. in reverse
            order).

  ..          Make two copies of the current word.
  "aeiou"     Push this string.
  .u*         Append an upper case copy to get "aeiouAEIOU".
  &-          Fold substring removal over this string. What that means is that
              we push each character "a", "e", ... in turn and execute -
              on it. That will remove all "a"s, all "e"s, etc. until all
              vowels are removed from the input word.
  N           Compute the multiset complement of this consonant-only version
              in the original word. That gives us only the vowels in the word.
              We now still have a copy of the input word and only its vowels
              on top of the stack.
  m           Truncate. This reduces both strings to the same length. In particular,
              it shortens the input word to how many vowels it contains.
  ;           Discard the vowels since we only needed their length.
  R           Reverse the prefix.
  o           Print it.
  .           Duplicate the next word. If we've processed all words, this
              will give an empty string.

$K          Jump back to the beginning of the loop if there is another word
            left on the stack.
@           Otherwise, terminate the program.

JavaScript (ES6), 76 bytes
s=>s.split` `.map(w=>w.split(/[aeiou]/i).map((_,i)=>o=i?w[i-1]+o:o),o='')&&o

Test cases

let f =

s=>s.split` `.map(w=>w.split(/[aeiou]/i).map((_,i)=>o=i?w[i-1]+o:o),o='')&&o

console.log(f(""                                 )) // -> ""
console.log(f("Hello World"                      )) // -> "WeH"
console.log(f("Waves"                            )) // -> "aW"
console.log(f("Programming Puzzles and Code Golf")) // -> "GoCauPorP"
console.log(f("Yay Got it"                       )) // -> "iGY"
console.log(f("Thx for the feedback"             )) // -> "eeftf"
console.log(f("Go Cat Print Pad"                 )) // -> "PPCG"

Ruby, 54 59+1 = 55 60 bytes
Uses the -p flag for +1 byte.
$_=$_.split.map{|w|w[0,w.count("aeiouAEIOU")]}.join.reverse

Try it online!

@nimi It does now.

Just curious, why is -p worth a byte?

@EricDuminil See this meta post but basically, because ruby -pe '...' is only one more byte than ruby -e '...' and -e is a valid way to execute the script.

Python 3, 83 81 79 77 bytes

 Mr. Xcoder  saved 2 bytes
 Griffin  saved 2 bytes: Switch from Python 3 to 2
saved 2 bytes: use of lambda

lambda z:''.join(i[:sum(y in'aeiouAEIOU'for y in i)]for i in z.split())[::-1]

Try it online!

81 bytes

change to python 2 and you don't need the () for print

@Griffin In Python 2, you would need raw_input() instead of input() which would waste 4 bytes.

@Mr.Xcoder why can't you just input with quotes?

@Griffin Ah, right. That would eventually save 2 bytes.

JavaScript (ES6), 96 bytes
s=>[...s.split` `.map(w=>w.slice(0,(m=w.match(/[aeiou]/gi))&&m.length)).join``].reverse().join``

f=
s=>[...s.split` `.map(w=>w.slice(0,(m=w.match(/[aeiou]/gi))&&m.length)).join``].reverse().join``

console.log(
    f(''),
    f('Hello World'),
    f('Waves'),
    f('Programming Puzzles and Code Golf'),
    f('Yay Got it'),
    f('Thx for the feedback'),
    f('Go Cat Print Pad')
)

Words with no vowels (Thx) should have no output; your test case outputs the whole word.

@JustinMariner Fixed!

05AB1E, 14 bytes
#RʒDžMDu«Ãg£R?

Try it online!
Darn 05AB1E doesn't have builtin for AEIOUaeiou ಠ_ಠ

Wait... 05AB1E beaten by Japt?

@Mr.Xcoder Happens more often than you probably think.

#RʒDlžMÃg£R? for 12, you can pretty much just lowercase the dupe removing the need for AEIOUaeiou. Also, why the heck wont this work without the ?? Can you post an explanation, I'm unfamiliar with ʒ

@carusocomputing Unfortunately output must be case-sensitive.

I know it has been 3 years, but there is a builtin for all vowels now: žÀ (It is aeiouAEIOU, not AEIOUaeiou)

In addition to @SunnyMoon's suggestion: in the new 05AB1E, g£ can be ∍ for another -1 byte: try it online. (If you want to get rid of the --no-lazy flag, your can change it to #εDžÀÃ∍}JR for the same byte-count.)

Java 8, 171 151 bytes
-20 bytes thanks to @Lukas Rotter
I feel like it still needs some golfing... let me know in the comments if you have any suggestions.

s->{String z="";for(String w:s.split(" "))z+=w.substring(0,w.replaceAll("(?i)[^aeiou]","").length());return new StringBuilder(z).reverse().toString();}

Try it online!

Java supports (?i) for ignoring case in regexs. So (?i)[aeiou] should also work.

You can also remove the {} brackets of the for loop, since only one statement is contained in it.

Instead of subtracting the length of the regex string you can also just use ^ to  find the amount of vowels:  z+=w.substring(0,w.replaceAll("(?i)[^aeiou]","").length());

Pyth, 31
This took me a long time to write, and I feel like there is probably a better approach, but here is what I have:
_jkm<Fd.T,cQ)ml:d"[aeiou]"1crQ0

Online test.
                             Q     # input
                            r 0    # to lowercase
                           c       # split by whitespace
               :d"[aeiou]"1        # lambda: regex to find vowels in string
              l                    # lambda: count the vowels in string
             m                     # map lambda over list of words
          cQ)                      # split input by whitespace
         ,                         # list of (input words, vowel counts)
       .T                          # transpose
    <Fd                            # lambda to get first n chars of string
   m                               # map lambda over list of (input words, vowel counts)
 jk                               # join on on empty strings
_                                 # reverse

I feel like there is probably a better approach -- I got 19 in Pyth

@Svetlana there I fixed it.  Thanks for the jk tip.

Pyth - 19 bytes
_jkm<dl@"aeiou"rd0c

Try it here
Explanation:
_jkm<dl@"aeiou"rd0c
                  c  # Split implicit input on whitespace
   m                 # For each word d...
               rd0   # ...take the lower-case conversion...
       @"aeiou"      # filter it to only vowels...
      l              # and find the length of this string (i.e., the number of vowels in the word)
    <d               # Take the first # characters of the word (where # is the length from above)
 jk                  # Join on empty string (can't use s, because that will screw up when the input is the empty string)
_                    # Reverse the result (and implicitly print)

I could have 18 bytes if not for the empty string:
_sm<dl@"aeiou"rd0c

@DigitalTrauma:  I just added an explanation

@ - intersection is much better than regex here.  Oh, I see - you just have one lambda/map compared to my 2.

Ohm, 13 bytes
z:αv_K_σh;0JR

Explanation

First the (implicit) input is split on spaces by z.
Then a foreach loop is started (:) with it's associated codeblock being αv_K_σh.

av pushes aeiou
_ pushes the current iterated element
K counts the occurrences of aeiou in _
_ the element again
σh Splits the element into slices of length occurences and takes the first element.

Effectively this takes the first occurences chars

0J Pushes the stack joined on ''

The 0 is necessary because it requires an argument that will be joined. If that argument isn't an array it joins the stack

R reverses the result
implicit print of the TOS

Vyxal, 10 bytes
⌈ƛk∨↔LẎ;∑Ṙ

Try it Online!
⌈          # Split on spaces
 ƛ     ;   # Map...
    ↔      # Remove characters not in...
  k∨       # 'aeiouAEIOU'
     L     # Get the length of that
      Ẏ    # Get that many characters of the original string
        ∑  # Concatenate all of them
         Ṙ # Reverse the whole thing

Jelly, 12 bytes
ḲµfØcLḣ@µ€FU

Try it online!

Common Lisp, 218 bytes
(defun p(s &aux(j 0)c(v 0)r)(dotimes(i(1+(length s))(apply'concatenate'string r))(cond((or(= i(length s))(eql(setf c(elt s i))#\ ))(setf r(cons(reverse(subseq s j(+ j v)))r)v 0 j(1+ i)))((find c"AEIOUaeiou")(incf v)))))

Explanation
(defun p(s &aux (j 0) c (v 0) r)               ; j start of word, c current char, v num of wovels, r result
  (dotimes (i                                  ; iteration var
            (1+ (length s))                    ; iteration limit
            (apply 'concatenate 'string r))    ; iteration final result
    (cond ((or (= i (length s))                ; if string is terminated
               (eql (setf c (elt s i)) #\ ))   ;  or, set current char, and this is a space, then
           (setf r (cons (reverse (subseq s j (+ j v))) r) ; push on result from current word chars as number of vowels
                 v 0                           ; reset number of vowels to 0
                 j (1+ i)))                    ; reset start of current word to next char
          ((find c "AEIOUaeiou")               ; if current char is a wovel
           (incf v)))))                        ;   then increment num of vowels

Swift 3, 240 bytes
This is a function that can be used with f(s:"Input"). Surprisingly, I don't think it can be golfed further:
import Foundation
func f(s:String){var c=s.components(separatedBy:" "),r="";for i in c{let b=i.startIndex;r+=i[b...i.index(b,offsetBy: i.characters.filter{"aeiouAEIOU".contains(String($0))}.count-1)]};print(String(r.characters.reversed()))}

Try it at IBM Sandbox!

Indeed, it seems like you have the shortest Swift code possible for this submission. I have solved it in Swift as well, and also got 240 bytes! Well done!

sed, 133 (132+1) bytes
sed is called with the -E flag, which apparently means I add one byte.
Note: I have not really attempted to golf this yet.
s/$/\n/
:l
s/(.)(\n.*)/\2\1/
tl
s/\n/ /
h
s/[aoeui]//g
G
:r
s/^(\S*) \S(.*\n\S* )\S/\1 \2/
tr
s/^ //
s/(\n\S*) /\1/
/^\n/!br
s/\s//g

Try it online!

Clojure, 96 94 bytes
#(apply str(mapcat(fn[i](take(count(filter(set"aeiouAEIOU")i))i))(reverse(re-seq #"[^ ]+"%))))

Well this length is quite ridiculous. mapcat saved two bytes.

k, 33 28 27 bytes
|,/{x@!+/~^"aeiou"?_x}'" "\

Try it online!

-5 bytes thanks to coltim, -1 byte thanks to doug.

Can save 5 bytes by doing |,/{(+/~^"aeiou"?_x)#x}'" "\ . A k4 version is |,/{(+/(_x)in"aeiou")#x}'" "\:.

One more byte I think:|,/{x@!+/~^"aeiou"?_x}'" "\

Mathematica, 145 bytes
(s=StringCount[#,{"a","e","i","o","u","A","E","I","O","U"}]&/@(x=StringSplit@#);StringReverse[""<>Table[StringTake[x[[i]],s[[i]]],{i,Tr[1^s]}]])&

I am not really familiar with Mathematica, but can't the space between s[[i]]], and {i,Length@s} be removed?

yes of course, I missed that. I must golf it more, too

Is there a way to cast a string to a list in Mathematica? Something like "aeiouAEIOU".ToCharArray()?

you mean Characters[]?

Retina, 49 46 bytes
i`(?=(([aeiou])|\w)+)((?<-2>.)+)\w* ?
$3
O^$`.

Try it online! Link includes test suite. Explanation: This is an application of .NET's balancing groups. The lookahead searches the word for vowels, which are captured in group 2. The group is then popped as each letter is matched, thus capturing the number of letters equal to the number of vowels in the word. The rest of the word and any trailing space is then ignored so that the process can begin again with the next word. Finally the remaining letters are reversed.

C# (.NET Core), 144 bytes
using System.Linq;s=>new string(string.Join("",s.Split(' ').Select(e=>e.Substring(0,e.Count(c=>"aeiouAEIOU".Contains(c))))).Reverse().ToArray())

Try it online!
The worst part is that reversing a string in C# returns a IEnumerable<char> which you have to convert back to a string.

PHP, 96 bytes
foreach(explode(" ",$argn)as$w)$r.=substr($w,0,preg_match_all("#[aeiou]#i",$w));echo strrev($r);

Try it online!

CJam, 26 bytes
qS/{_el"aeiou"fe=:+<}%:+W%

Try it online!
I was proud of coming up with the el"aeiou"fe=:+ snippet to count vowels.

GolfScript, 33 bytes
" "/-1%{.{"aeiouAIUEO"?)},,<-1%}/

Try it online!
" "/                                # Split the words                          ["Hello" "World"]
    -1%                             # Reverse the list                         ["World" "Hello"]
       {                       }/   # For each word                            "World"         | "Hello"
        .                           # Copy it                                  "World" "World" | "Hello" "Hello"
         {              },          # List all letters that pass this test
          "aeiouAIUEO"?)            # Is it a vowel?                           "World" ["o"]   | "Hello" ["e" "o"]
                          ,         # Get the number of letters in the list    "World" 1       | "Hello" 2
                           <        # Get that many letters from the beginning "W"             | "He"
                            -1%     # Reverse it                               "W"             | "eH"
                                                                               "WeH"

Husk, 17 bytes
ṁS↑ṁ#¨aeıuAEIOU¨w

Try it online!
Even without a builtin, does pretty well.

Vyxal, 8 bytes
⌈ƛA∑Ẏ;∑Ṙ

Try it Online!
⌈        # Split on spaces
 ƛ   ;   # Map...
  A      # Vowel mask (1 for vowel, 0 for not for each character)
   ∑     # Sum (vowel count)
    Ẏ    # First ^ letters
      ∑Ṙ # Sum + reverse

Is the r flag needed? It seems like it works without it: Try it Online!

@emirps Yeah, I'm not sure what I was thinking with that.

Arturo, 72 bytes
$=>[reverse join map split.words&'x->take x match.count x{/(?i)[aeiou]}]

Try it

J, 37 bytes
[:|.@;({.~1#.'AEIOUaeiou'e.~])&.>@cut

Attempt This Online!
[:|.@;({.~1#.'AEIOUaeiou'e.~])&.>@cut
[:                                     NB. enforce f(g(y))
                                >@cut  NB. split on spaces and unbox
                              &.       NB. then for each word
      (                      )         NB. monadic hook
             'AEIOUaeiou'e.~]          NB. checks if each character of input is a vowel
          1#.                          NB. sum the result, count of vowels
       {.~                             NB. take that many from the word
                              &.       NB. u&.v will do v⁻¹(u(v(y))) so box the result
  |.@;                                 NB. unbox and concat then reverse

Lua, 93 bytes
print((...):gsub('%g+ ?',load's=..._,n=s:gsub("[aeiouAEIOU]",s)return s:sub(1,n)'):reverse())

Try it online!

Thunno 2 c, 8 bytes
OıṃSɱ;Jr

Try it online!
Explanation
OıṃSɱ;Jr  # Implicit input
O         # Split on spaces
 ı   ;    # Map over this list:
  ṃ       #  Check if each character is a vowel
   S      #  And sum to get the vowel count
    ɱ     #  Take that many characters from the front
      J   # Join into a string
       r  # And reverse the string
          # Implicit output


text:
Catch those sheep!
You're a farmer and your flock of sheep has escaped!  Oh no!
Round up those sheep by building fences to contain them.  As a farmer on a budget you want to use the least amount of fence possible.  Luckily for you though, they aren't the smartest sheep in the world and don't bother moving after having escaped.
Task
Given a list of coordinates, output the least amount of fence segments necessary to contain the sheep.
Rules

Sheep are contained if they cannot wander off (no holes in the fence).
You do not have to contain all the sheep in one block of fence - there could be multiple fenced-off areas independent from each other.
Fence segments are oriented in cardinal directions.
Each coordinate tuple represents a single sheep.
Input must be positive integer pairs, x>0 & y>0, but can be formatted appropriately for your language.

i.e.: {{1,1},{2,1},{3,7}, .. } or [1,2],[2,1],[3,7], ..

Empty spaces inside a fenced-off area are okay.
You cannot assume coordinates are input in any specific order.

For example, a single sheep requires 4 fence segments to be fully contained.
Test cases
[1,1]
4

[1,1],[1,2],[2,2]
8

[2,1],[3,1],[2,3],[1,1],[1,3],[3,2],[1,2],[3,3]
12

[1,1],[1,2],[2,2],[3,7],[4,9],[4,10],[4,11],[5,10]
22

[1,1],[2,2],[3,3],[4,4],[5,5],[6,6],[7,7],[8,8],[9,9]
36

[1,1],[2,2],[3,3],[4,4],[6,6],[7,7],[8,8],[9,9]
32

[2,1],[8,3],[8,4]
10

Notes

You can assume input coordinates are valid.
Your algorithm should theoretically work for any reasonably large integer coordinate (up to your language's maximum supported value).
Either full program or function answers are okay.

This is code-golf, so shortest answer in bytes wins!

Can input be a list of x coordinates, followed by a list of y coordinates? e.g. {1,2,3,4},{5,6,7,8} -> {1,5},{2,6},{3,7},{4,8}

@Phoenix Nope, each x,y input must be together. Nice thought though, I hadn't thought of that myself.

What are the bounds on the coordinates? Are 0s and negatives possible?

@AGourd For simplicity, positive integers.  Thanks, edited the question to clarify.

This is surprisingly hard. Every time I think I have a heuristic that handles all cases, there's something I missed.

"Multiple sheep can occupy the same space": It's a bit late, but I'd suggest to remove this rule which doesn't add anything to the challenge.

@Arnauld You're absolutely right, I changed the test case and didn't update the output.  My apologies.

In regards to multiple sheep can occupy the same space, I wanted to make sure input algorithms could handle duplicate coordinates.

I see your point. But IMHO, multiple sheep occupying the same space should not be permitted at all. (The challenge is still hard enough without that. ^^)

@Arnauld Good point.  Fair enough.  :)  I'll remove that line, but I'm unsure if modifying the criteria further is kosher at this point.  Perhaps "you can assume input coordinates are valid" covers this.

Can I assume there's at least one sheep?

@isaacg Yes.  :-)

Downgoat is going to love this challenge!

Wow, what a challenge. I concede my loss; screw doing this in 05AB1E.

You should include a test case where the fenced area must contain empty coordinates next to a fence, e.g. [1,1],[1,2],[1,3],[3,1],[3,3]

JavaScript (ES6), 251 244 275 bytes
a=>Math.min(...(P=(a,r=[[a]],c=a[0])=>(a[1]&&P(a.slice(1)).map(l=>(r.push([[c],...l]),l.map((_,i)=>r.push([[c,...l[i]],...((b=[...l]).splice(i,1),b)])))),r))(a).map(L=>L.reduce((p,l)=>l.map(([h,v])=>(x=h<x?h:x,X=h<X?X:h,y=v<y?v:y,Y=v<Y?Y:v),x=y=1/0,X=Y=0)&&p+X-x+Y-y+2,0)))*2

How?
We use the recursive function P() to create a list of all possible partitions of the input list. This function is currently sub-optimal, in that it's returning some duplicated partitions -- which does not however alter the final result.
For each partition, we compute the number of fences required to surround all sheep in each group with a rectangle. The sum of these fences gives the score of the partition. We eventually return the lowest score.
Test cases

let f =

a=>Math.min(...(P=(a,r=[[a]],c=a[0])=>(a[1]&&P(a.slice(1)).map(l=>(r.push([[c],...l]),l.map((_,i)=>r.push([[c,...l[i]],...((b=[...l]).splice(i,1),b)])))),r))(a).map(L=>L.reduce((p,l)=>l.map(([h,v])=>(x=h<x?h:x,X=h<X?X:h,y=v<y?v:y,Y=v<Y?Y:v),x=y=1/0,X=Y=0)&&p+X-x+Y-y+2,0)))*2

console.log(f([[1,1]]))
console.log(f([[1,1],[1,2],[2,2]]))
console.log(f([[2,1],[3,1],[2,3],[1,1],[1,3],[3,2],[1,2],[3,3]]))
console.log(f([[1,1],[1,2],[2,2],[3,7],[4,9],[4,10],[4,11],[5,10]]))
console.log(f([[1,1],[2,2],[3,3],[4,4],[5,5],[6,6],[7,7],[8,8],[9,9]]))
console.log(f([[1,1],[2,2],[3,3],[4,4],[6,6],[7,7],[8,8],[9,9]]))
console.log(f([[2,1],[8,3],[8,4]]))

About step 2, why not [ [1,1],[2,2] ] , [ [1,2] ] ?

@edc65 Hopefully it should now be fixed.

k, 62 58 57 55 bytes
{+//2*1+{(|/x)-&/x}'(x@?(&|/2>(|/'{x|-x}x-\:)')')/,:'x}

Try it online!