text:
Sandbox Visualization Module Emulator
The Zachtronics game TIS-100 contains a graphics display called the visualization module. I could try and explain the specs of this module, but the game's manual will do a better job:

(As you may have guessed, the motivation of this problem is to create a code golf challenge in which TIS-100 is the optimal language.)
Your job is to, in as few characters as possible, implement a program which will output the correct image for any valid input sequence. There are no requirements on what happens for an invalid input sequence. This can be a graphical window or console output. This includes strings of more than 1 command! If it has multiple -1s, multiple lines should be drawn.
Test Cases:
Input:

    3, 4, 4, 3, 2, 1, 0, 1, 2, 3, 4, -1

Output:

Input:

    1, 1, 4, 4, -1, 8, 8, 4, 4, -1

Output:

Input:

    5, 5, 4, -1, 5, 5, 0, -1

Output:

The simple TIS implementation is:
TIS-100, 64 55 Bytes
-9 thanks to feersum
@1
MOV UP ANY
@5
MOV UP ANY
@9
MOV UP ANY
@10
MOV ANY ANY

An additional byte is added as a single character in the filename is relevant.

I think you could golf all of the directions other than UP to ANY.

Some test cases of valid programs and their outputs would be nice.

What's the relavence of "Sandbox" in the title?

The "image console sandbox" contains a different size image console than the standard one.

Is creating an image file an acceptable form of output?

Yep. Even a text file output is acceptable

@junkmail How can text file acceptable? at least 5 colors are supported.

Ruby, 114 bytes
->h,g=[0]*792{h.chunk{|x|x<0&&p}.map{|z,(x,y,*r)|g[36*y+x,r.size]=r}
puts'P3 36 22 5',g.map{|i|i>3?'5 0 0':[i]*3}}

This function takes its input as an array of ints, and writes the resulting image to STDOUT in the human readable version of PPM format. For those unfamiliar, the PPM image format is an uncompressed image format that's, essentially, a whitespace separated list of RGB values.
About PPM
More particularly, it begins with a short header of the format P3 W H M, where P3 is a magic number, W is the width of the image, H is the height of the image, and M is an int from 1 to 65536 representing the maximum possible value a color channel can have. For instance, if M = 255, then the RGB triplet (255, 255, 255) represents white. If M = 10, then (10, 10, 10) is white.
After the header, each pixel is described, row by row, by providing an RGB triplet for its color, with each value separated by spaces. It has the neat property that you can use it to represent an image as human readable text. For instance, a 3x1 pixel image containing a red pixel, a green pixel, and a blue pixel would be:
3 1 255
255 0 0   0 255 0   0 0 255

The precise whitespace used doesn't matter, so the above image is equivalent to, among many others:
3 1 255
255
 0    0          0       255        0
        0     0       255

Explanation of Code
The reason all that was necessary was to explain why, when you run the program, you'll see output that looks like this:
P3 36 22 5
0
0
0
3
0 # And so on...

It's a PPM! And it's generated like this:
# Create an array g, full of 0s, of size (36*22) to hold the image
g = [0] * 792
# Break the input array into chunks, splitting on values < 0
h.chunk{|x|x < 0 && p}
# Use each chunk to fill the subarray of g beginning at its x and y coordinates
 .map{|z,(x,y,*r)|g[36*y+x,r.size]=r}
# Print the header ...
puts'P3 36 22 5',
# ... and the colors, replacing each color id with itself repeated 3 times
# (for the various shades of gray) or '5 0 0', in the case of red, and
# separating each item with a newline.
g.map{|i|i>3?'5 0 0':[i]*3}

If you take this output and paste it into a text file, you'll be able to view it in any image viewer capable of opening PPMs.
Try it online!

.COM in 94B
00000000h: 68 00 B8 07 BF 09 01 31 DB B4 07 CD 21 3C 2D 72
00000010h: 41 6B DB 0A 2D 30 07 01 C3 BF 1E 01 EB EB 89 DD
00000020h: 83 06 1A 01 09 EB DD 69 ED A0 00 6B F3 02 EB F0
00000030h: 85 DB 7D 07 83 2E 1A 01 12 EB C9 83 FE 48 73 C4
00000040h: 81 FD C0 0D 73 BE FF B7 58 01 26 8F 02 83 C6 02
00000050h: EB B2 3C 20 72 02 FF E7 C3 00 88 77 FF 44

No extra optimize. Lots of code doing input

input from stdin or <file.txt, output to screen, assuming 80*25 screen

SmileBASIC 3, 163 bytes
Draws the image in the top-left corner of the graphic screen at 1px scale. DEF V A takes an int array A as input.
DEF V A
GCLS
@_
X=A[I]Y=A[I+1]FOR I=I+1TO LEN(A)-1C=A[I]IF.>C THEN I=I+1GOTO@_
IF X>35||Y>21GOTO@N
R=(3AND C)*85GPSET X,Y,RGB(R+255*!!(4AND C),R,R)@N
X=X+1NEXT
END

Test Harness
The output is very small and other graphics leftover from the console etc. makes this function hard to test (in addition to the fact that it's a function and not a standalone program...) Write this (ungolfed) test harness below the function and run to verify.
ACLS
DATA 3,4,4,3,2,1,0,1,2,3,4,-1,-10

DIM SEQ%[0]
WHILE C%!=-10
 READ C%
 PUSH SEQ%,C%
WEND

GPAGE 0,4
SPSET 0,0,0,36,22
SPSCALE 0,8,8

V SEQ%

REPEAT VSYNC UNTIL BUTTON(2)

Change the DATA statement to change the test sequence. The test sequence must end with -10 so the tester knows to stop reading it (DATA is used because SB lacks array literals.) This is done so you can use -1 in a sequence.
The program may end in an error; this is normal.

Typo. i fixed it.

APL (Dyalog Unicode), 73 bytes
'P3 36 22 5'
+/{{⍵≠4:3/⍵⋄4 0 0}¨(-1⊃⍵)⊖(-0⊃⍵)⌽36 22↑1(≢2↓⍵)⍴2↓⍵}¨¯1(≠⊆⊢)⎕

Try it online!
A full program, which takes the indices as specified. Requires ⎕IO←0 for 0-indexing.
Outputs a netpbm image, like in the Ruby answer.
Explanation
Netpbm header:
'P3 36 22 5'

Grid Generator:
+/{{⍵≠4:3/⍵⋄4 0 0}¨(-1⊃⍵)⊖(-0⊃⍵)⌽36 22↑1(≢2↓⍵)⍴2↓⍵}¨¯1(≠⊆⊢)⎕
                                                              ⎕ Take the input
                                                       ¯1(≠⊆⊢)  split on -1s
  {                                                  }¨         do the following for each subarray i:
                                                 2↓⍵            Drop the 2 coordinates
                                        1(≢2↓⍵)⍴                Convert i to a 1-row matrix
                                  36 22↑                        create a 36x22 matrix with zeros, containing i
                           (-0⊃⍵)⌽                              rotate i to the required x coordinate
                    (-1⊃⍵)⊖                                     rotate i to the required y coordinate
    {             }¨                                            apply the following to each element:
     ⍵≠4:3/⍵                                                    if it's not red, assign a shade of grey
            ⋄4 0 0                                              otherwise assign red
+/                                                              sum all the resulting matrices


text:
Block of digits
Output/print this block of text:
1234567890
2468013579
3691470258
4815926037
5049382716
6172839405
7306295184
8520741963
9753108642
0987654321

Acceptable formats include:

Trailing newlines/whitespace
List of strings
List of lists of characters
List of lists of integers

However, list of integers is not acceptable because the last line is not an integer.
This is code-golf. Shortest answer in bytes wins. Standard loopholes apply.

Mathematica, 33 bytes
Mod[1##,11]~Mod~10&~Array~{10,10}

Try it online! (Using Mathics.)
The cell at 1-based index (x,y) has value ((x*y) % 11) % 10

Python 2, 48 46 bytes
n=10
while n:print('00987654321'*n)[n::n];n-=1

Try it online!

Welcome to PPCG, and amazing first answer! We hope you'll stick around and contribute more :-)

@ETHproductions thanx :)))

Python 2, 49 47 bytes
n=1
exec"print('01234567890'*n)[n::n];n+=1;"*10

Try it online!

nice exec use..

Jelly, 7 bytes
⁵×þ`%‘%

Try it online!
Uses Martin's algorithm.

MATL, 12 11 bytes
Saved a byte thanks to Luis. I keep forgetting the & is a shortcut for duplicating and transposing.
10:&*11\10\

Try it online!
Using @Martin's algorithm: x*y % 11 % 10
Explanation:
10            % Pust 10 to the stack. Stack: 1
  :           % 1-based range. Stack: [1 2 3 ... 10]
   &          % Duplicate range. Stack: [1 2 3 ... 10],[1 2 3 ... 10]
              % Transpose last range. Stack [1 2 3 ... 10],[1;2;3 ...10]
    *         % Multiply with broadcasting. Stack: [1 2 3 ...;2 4 6...] (10-by-10 array)
     11       % Push 11 to the stack. Stack [1 2 3 ...;2 4 6 ...], 11
       \      % Modulus.
        10    % Push 10 to the stack.
          \   % Modulus
              % Implicit display

Same bytecount:
10t:&*11\w\

You can save a byte replacing t!* by&*

@LuisMendo double backticks if you have a backslash at the end of code snippet in comments.

@MartinEnder Thanks! I never remember how that works, so I went for the easy way :-)

@LuisMendo yeah it's a bit confusing with posts and comments using different syntax.

Thanks @LuisMendo! That's not in the docs is it?

It is. The help for * says If 1 input: a second input is used given by the first transposed. And the notation 1-- (2 / 1);  1 for * means that & specifies 1 input (see here for explanation of this notation). Note that the meaning of & is function-specific

APL (Dyalog), 13 bytes
10|11|∘.×⍨⍳10

Try it online!
A port of my Mathematica answer.
      ∘.×⍨      ⍝ Multiplication table of...
          ⍳10   ⍝ The list from 1 to 10.
   11|          ⍝ mod 11.
10|             ⍝ mod 10.

CJam (17 bytes)
A,:)_f{f*Bf%Af%N}

Online demo

Haskell, 43 bytes

l=[1..10]
f=[[x*i`mod`11`mod`10|i<-l]|x<-l]

Japt, 16 12 11 bytes
Turns out this was my 200 (undeleted) answer here :)
Looks like this is the same formula Martin spotted.
Aõ
£®*X%B%A

Test it (-R flag for visualisation purposes only)

4 bytes saved thanks to Luke pointing out that returning an array of arrays was permissible.

Explanation
Aõ    :Generate an array of integers from 1 to 10, inclusive.
£     :Map over each element in the array, returning...
®     :Another map of the same array, which...
*X    :Multiplies the current element of the inner function by the current element of the outer function...
%B    :Modulus 11...
%A    :Modulus 10.
      :Implicit output of resulting 2D array

Beat me to it... You can drop the last two characters, and instead use the -R flag

Even better, drop the last four characters. It seems that's allowed...

Yup, looks like you're right, thanks, @Luke :)

Javascript (ES6), 70 64 56 bytes
_=>[...1e9+''].map((_,a,b)=>b.map((_,c)=>-~a*++c%11%10))

Saved 4 bytes thanks to Shaggy and 8 bytes thanks to Arnauld.

66 bytes: _=>[...a=Array(10)].map((_,x)=>[...a].map((_,y)=>(x+1)*++y%11%10)). You save me 4 bytes, I save you 4 bytes :)

Thanks a lot. You also fixed a bug, so I shaved another 2 bytes of your solution ;-)

You can save 5 bytes by using the 3rd parameter of the callback in the first map() and 3 more bytes by using 1e9+'' instead of Array(10). That leads to _=>[...1e9+''].map((_,x,a)=>a.map((_,y)=>-~x*++y%11%10)).

@Arnauld: Thanks for the 1e9 trick. I didn't know that one. I did think about using the third argument, but for some reason I didn't use it.

I've recently compiled a list of similar tricks here.

Retina, 59 bytes
Byte count assumes ISO 8859-1 encoding.

10$*
1
,1$`
,1+
$_¶
(?<=(¶?.+)+)1
$#1$*
1{10}1?

,(1*)
$.1

Try it online!
Explanation
Another implementation of the ... % 11 % 10 algorithm. The fun part of doing it with a regex is that we can take care of both modulo computations at once.

10$*

Initialise the string to ten 1s.
1
,1$`

Replace each of those with a comma, a one, and the prefix in front of that one. This gives ,1,11,...,1111111111, i.e. a unary range.
,1+
$_¶

Now replace each of the range elements with the entire string followed by a linefeed. This gives us a 10x10 grid of unary numbers indicating the current column.
(?<=(¶?.+)+)1
$#1$*

Match each 1 and determine which row it's on by repeating group one that many times. Replace the 1 with that many 1s. This multiplies the values in each row by the row's 1-based index.
1{10}1?

Now let's do mod 11, mod 10 in one step. To do mod 11, we'd normally just remove all 1{11} from the string to be left with the remainders. And then we'd remove 1{10} after that. But if we just remove ten 1s plus another if possible, the regex engine's greediness will do mod 11 for us as long as possible, and if not, then it'll try at least mod 10.
,(1*)
$.1

Finally, we just convert each number to decimal by replacing it with its length.

05AB1E, 14 bytes
11GTLN*11%T%})

Try it online!
Uses Martin's algorithm, as usual.

Oh, there's an algorithm for that pattern. That explains why I'm 30 bytes above the average answer.

R, 19 bytes
1:10%o%1:10%%11%%10

Try it online!
The least "R"-looking bit of R code I have ever written. Uses the same algorithm as Martin Ender's answer (and almost all the other answers as well). x %o% y is the same as outer(x, y).

Charcoal, 30 29 19 bytes
Ｆχ«ＦχＩ﹪﹪×⁺¹ι⁺¹κ¹¹χ⸿

Try it online!
Uses Martin's formula.

10 bytes saved thanks to Neil, proving once more that I have still so much to learn...

You don't need trailing »s and while you can use ω instead of ”” you can save a whole bunch of bytes by using ⸿ as this then becomes Ｆχ«ＦχＩ﹪﹪×⁺¹ι⁺¹κ¹¹χ⸿. (Before I knew about ⸿ I would have suggested Ｊ⁰ι which would still have saved a number of bytes.)

@Neil The ⸿ is the reverse operator, what does it do at the end of your code without arguments? Is it documented?

No, ⮌ is the Reverse operator, ⸿ is the move cursor to start of next line character (like ¶ but can be in a separate string).

Java 8, 84 bytes
o->{String r="";for(int x=0,y;++x<11;r+="\n")for(y=0;++y<11;r+=x*y%11%10);return r;}

Uses the same algorithm as @MartinEnder's Mathematica answer: 1-indexed x*y%11%10.
Explanation:
Try it here.
o->{                     // Unused Object parameter and String return-type
  String r="";           //  Result-String
  for(int x=0,y;++x<11;  //  Loop (1) from 1 to 11 (exclusive)
      r+="\n")           //    And append a new-line after every iteration
    for(y=0;++y<11;      //   Inner loop (2) from 1 to 11 (exclusive)
      r+=x*y%11%10       //    And append the result-String with `x*y%11%10`
    );                   //   End of inner loop (2)
                         //  End of loop (1) (implicit / single-line body)
  return r;              //  Return result-String
}                        // End of method

Python 2, 58 52 bytes
-6 bytes thanks to offcialaimm.
Uses Martin's algorithm which I have no understanding of how he came up with it so fast. o0
r=range(1,11)
print[[x*y%11%10for y in r]for x in r]

Try it online!

Shorthand r=range(1,11) saves 6 bytes

Part of the reason I spotted the formula so quickly is this math.SE question of mine and orlp's comment there.

Pyth, 13 bytes
mme%*kd11STST

Try it here
-1 thanks to KarlKastor.
Let's duuuuuuupe!

Save one byte if you use e instead of % T

@KarlKastor ...and I was remembering it ._.

GolfScript, 37 24 bytes
10,{){\)*11%10%}+10,%}%`

Try it online!
-13 thanks to a clever trick Martin Ender suggested.

if you turn it into a full program ({ --> ;, } --> \``), you can at least drop the first [`.

It's a lot shorter to use a simple nested loop instead of the zip technique though: {){\)*11%10%}+10,/n}10,/

@MartinEnder Umm...you seem to be overusing /. ;)

@MartinEnder Oh I see what you did...you used int blk + -> {int space contents-of-blk}.

@MartinEnder ok I've implemented your + trick...although I altered your code a bit

C (gcc), 59 bytes
f(n,t){for(n=11;++n<121;putchar(t?t%10+48:10))t=n/11*n%11;}

Try it online!

Pyke, 15 bytes
TD]UMha*11%`e)P

Try it here!

Pyke, 13 bytes
TS F~u0+*i>i%

Try it here!
TS            -  [1, 2, 3, 4, 5, 6, 7, 8, 9]
   F~u0+*i>i% - for i in ^:
    ~u0+      -     "01234567890"
        *     -    ^ * i
         i>   -   ^[i:]
           i% -  ^[::i]

TECO, 45 bytes
1un@i/
/10<@i/01234567890/jl10<qnc0a^t>jtl%n>

A (fairly) straightforward implementation of Rod's Python answer.
1un           !initialize register n to 1!
@i/<nl>/      !insert a newline!
10<           !loop for 10 rows!
@i/01234567890/  !insert the mysterious string of digits!
j             !move point to start of buffer!
l             !move forward past the newline!
10<           !loop for 10 digits on a line!
qnc           !move point forward by n characters!
0a^t          !print the character at point!
>             !end inner loop!
j             !move point to start of buffer!
t             !print (empty) line!
l             !move to start of digit string!
%n            !increment register n (for next line)!
>             !end outer loop!

Using <ESC>-terminated inserts and a control character for the ^T command would save another three five bytes, at the expense of readability.
Using Martin's mod-11/mod-10 formula actually makes it longer at 43 bytes using controls for ^A and ^T, mostly because TECO doesn't have a mod operator.
0ur10<%run10<qn-10"g-11%n'qn\r0a^Tqr%n>^a
^A>

Mod 11 is done in an ongoing fashion by incrementing the number in qn by -11 whenever it exceeds 10. The qn\r0a^T sequence inserts the number in the editing buffer as decimal digits, reverses past the last digit, retrieves it from the buffer and types it, essentially doing mod-10.
I expected it to be shorter.  Oh, well.

J, 27 bytes
1":(10|11|*&>:)"0/~@(i.@9:)

Try it online!
Uses the same trick as in Martin Ender's Mathematica answer.

C (gcc), 70 bytes
f(x,y){for(x=0;x++<10;puts(""))for(y=0;y++<10;putchar(x*y%11%10+48));}

Try it online!

Retina, 93 85 bytes

10$*T
M!&`T+
m`$
;110$*T10$*
1
09876543210
m`(?<=^\1;\1{0,9}(T+))T
C
(?<!C.{108})\S

Try it online!

71 bytes: Try it online! No idea where the magic number of 109 derives from through.

PHP, 54 bytes
for(;9>=$y++||9>=$x+=$y=print"
";)echo($x+1)*$y%11%10;

Try it online!
PHP, 56 bytes
for(;$x++<=9;print"
")for($y=0;$y++<=9;)echo$x*$y%11%10;

Try it online!

You can drop the brackets ().

-2 bytes: for(;<0>$y++||10>$x+=$y=print"\n";)echo($x+1)*$y%11%10;

... or for($x=1;11>++$y||11>$x+=$y=print"\n";)echo$x*$y%11%10;

QBIC, 17 bytes
[|?[|?a*b%11%z';

This, of course, uses Martin's Method. It translates to this QBasic code.
Explanation
[|               FOR A = 1 to 10 ([ starts a FOR loop, | delimits the list of arguments;
                 a FOR loop with 0 args loops from 1 to 10 by default with increment 1.
  ?              PRINT a newline
   [|            Start a second FOR loop from 1-10, iterator b
     ?           PRINT
      a*b%11%z   the result of Martin's formula.
              '; and suppress newlines/tabs/spaces

C#, 81 bytes
_=>{var r="";for(int x=0,y;++x<11;r+="\n")for(y=0;++y<11;r+=x*y%11%10);return r;}

Same algorithm as most of the other answers and essentially the C# port of @Kevins Java answer.

Retina, 79 bytes

12345678902468013579369147025848159260375049382716
.*
$&$&
O$^50>`.

.{10}
$&¶

Try it online!

source: Stack Exchange

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

sort: votes


text:
ASCII art for torrent UI
Problem
Recreate the UI from a torrent program
Given no input, output the following:
+----------+----------+----------+
|a.exe     |##########|seeding   |
+----------+----------+----------+
|b.exe 10% |#         |leeching  |
+----------+----------+----------+
|c.exe     |##########|seeding   |
+----------+----------+----------+
|d.exe 20% |##        |leeching  |
+----------+----------+----------+
|e.exe     |##########|seeding   |
+----------+----------+----------+
|f.exe 30% |###       |leeching  |
+----------+----------+----------+
|g.exe     |##########|seeding   |
+----------+----------+----------+
|h.exe 40% |####      |leeching  |
+----------+----------+----------+
|i.exe     |##########|seeding   |
+----------+----------+----------+
|j.exe 50% |#####     |leeching  |
+----------+----------+----------+
|k.exe     |##########|seeding   |
+----------+----------+----------+
|l.exe 60% |######    |leeching  |
+----------+----------+----------+
|m.exe     |##########|seeding   |
+----------+----------+----------+
|n.exe 70% |#######   |leeching  |
+----------+----------+----------+
|o.exe     |##########|seeding   |
+----------+----------+----------+
|p.exe 80% |########  |leeching  |
+----------+----------+----------+
|q.exe     |##########|seeding   |
+----------+----------+----------+
|r.exe 90% |######### |leeching  |
+----------+----------+----------+
|s.exe     |##########|seeding   |
+----------+----------+----------+
|t.exe     |##########|seeding   |
+----------+----------+----------+
|u.exe     |##########|seeding   |
+----------+----------+----------+
|v.exe     |##########|seeding   |
+----------+----------+----------+
|w.exe     |##########|seeding   |
+----------+----------+----------+
|x.exe     |##########|seeding   |
+----------+----------+----------+
|y.exe     |##########|seeding   |
+----------+----------+----------+
|z.exe     |##########|seeding   |
+----------+----------+----------+

progress for programs are:
b=10% d=20% f=30% h=40% j=50% l=60% n=70% p=80% r=90%
amount of #'s for leeching programs is progress/10
the rest are all seeding with full progress bars.
Rules

Leading and trailing newlines allowed.
Leading and trailing spaces allowed as long as it doesn't change shape of output.
stdout and functions for output allowed.
Shortest code in bytes win

You know downloading .exe from torrents is not the brightest thing to do, eh?

@RobAu how else would I obtain f.exe can't find a copy of it anywhere else.

f.exe comes with f_readme.txt that says, "run as administrator". Seems legit.

@RobAu I didn't know, I routinely download Linux distributions, that contain executables including some that install boot loaders, with torrents!

Charcoal, 98 85 83 bytes
Ｆ³Ｂ⁻³⁴×¹¹ι³Ｍ↘ .exeＭ⁶→×#χ|seeding⸿Ｆ²⁵Ｃ⁰¦²↗Ｆβ↓⁺ι-Ｆ⁹«Ｊ⁷⁺³×⁴ι⁺⁺ι¹0% |#Ｐ⁺× ⁹|leeching×#ι

I thought copying a template would save me a lot of code but it all seems to add up somehow, although I managed to save 13 bytes by using a single loop to fix the 9 leeching rows. Explanation:
Ｆ³Ｂ⁻³⁴×¹¹ι³             Make the top row of boxes
Ｍ↘ .exeＭ⁶→×#χ|seeding⸿  Print .exe, the 10 #s and seeding
Ｆ²⁵Ｃ⁰¦²                 Make 25 copies of the boxes
↗Ｆβ↓⁺ι-                 Put the letters in at the start
Ｆ⁹«                     For the 9 leeching files
   Ｊ⁷⁺³×⁴ι              Move the cursor to the percentage column
   ⁺⁺ι¹0% |#            Print the percentage and the first # of progress
   Ｐ⁺× ⁹|leeching       Erase the rest of the progress and change the status
   ×#ι                  Print the desired amount of progress

(Side note: I seem to have discovered a bug in Charcoal; | is an ASCII character, but it's also counted as an arrow for the purposes of Multiprint, so you can't Multiprint it.)

Not a bug, you can escape it if you want

@ASCII-only Ah right, sadly the deverbosifier doesn't know that.

Oh true, thanks for reminding me

Perl 5, 130 bytes
print$e=("+"."-"x10)x3 ."+
";printf"|$_.exe%4s |%-10s|%-9s |
$e",$|--&&$@++<9?("$@0%","#"x$@,leeching):("","#"x10,seeding)for a..z

Try it online!
I expect that there are a few bytes that can be golfed, but I've ran out of inspiration.
Short explanations:
$e contains the separation line (+----------+----------+----------+); its construction is straight forward (("+"."-"x10)x3 ."+\n").
Then, I loop over the characters from a to z:
Every time, print "|$_.exe%4s |%-10s|%-9s |\n$e; this is a standard printf with placeholders for strings (%s) and left-padded strings (%-9s).
if $|--&&$@++<9 is true ($| is a special variable that contains either 0 or 1, and decrementing it toggles its value), then the percentage is not 100%, and the three values in the print are "$@0%","#"x$@,leeching ($@0% is actually just $@ . "0" . "%" - remember that $@ was incremented earlier), otherwise, the three values are "","#"x10,seeding).

SOGL V0.12, 90 89 88 bytes
ēz{L┌* +3ΟQķ|;o".exe ”oēI»L*"% |”e» #*lLκ@*"┌5%8'Ω⅞█≡θ¹‘++++e'³>e2\+?X"⅓m÷Ko→∆)№(¤^▒«‘}o

Try it Here!
Explanation:
ē                                 push variable E (default = input, which default is 0) and increase it after (next ē call will result in 1, or next e call - 2)
 z{                               iterate over the lowercase alphabet
   L┌*                            push 10 dashes
       +                          push "+"
        3Ο                        encase 3 copies of the dashes in pluses
          Q                       output in a new line, without popping and without disabling auto-output
           ķ|                     output in a new line "|"
             ;o                   output the current iteration (the alphabet letter)
               ".exe ”o           output ".exe "
                       ē          push E and increase the variable after
                        I         increase it
                         5*       multiply by 5 (every 2 ē calls this gets called)
                           "% |”  push "% |"

e»                                  push (E)/2
   #*                               get that mant "#"s
     l                              get the length of that string
      Lκ                            push 10-length
        @*                          push that many spaces
          "..‘                      push "|leeching  |"
              ++++                  add all those strings on the stack together ((e+1)*5, "% |", "#..#", " .. ", "|leeching |") (done this way to leave the "+-+-+-+" on the stack)
                  e'³>              push e>19
                      e2\           push e divides by 2
                         +          add together (here works like OR)
                          ?         if that then
                           X          remove the added-together string
                            "..‘      push "    |##########|seeding   |"
                                }   END
                                 o  output POP (either the added string or full/seeding version)
implicitly output POP (since none of tTpP were called), which is the separator line

SOGL beats.... Charcoal?!

@Mr.Xcoder It's the most common scenario imo.

Why the downvote?

Python 2, 182 177 bytes
Thanks to @officialaimm for shaving off 5 bytes by changing the format of the condition.
r=("+"+10*"-")*3+"+"
for i in range(26):z=i/2+1;print r+"\n|"+chr(97+i)+".exe "+["    |"+10*"#"+"|seeding ",`10*z`+"% |"+z*"#"+(10-z)*" "+"|leeching"][i%2and i<19]+"  |"
print r

Try it online!

177 bytes

Nice! I've seen that a couple of times but didn't think of using it in this instance. May I update my answer with your solution?

Of course, you can update it. ;)

173 bytes

Javascript, 232 230 228 226 bytes
(s='+----------'.repeat(3),p=0)=>[...'abcdefghijklmnopqrstuvwxyz'].map((c,i)=>(b=i%2,p=b?p+10:p,x=b&p<91,`${s}+'
|${c}.exe ${x?p+'%':'   '} |${'#'.repeat(x?p/10:10).padEnd(10)}|${x?'leeching':'seeding '}  |`)).join`
`+`
${s}+`

-2 Bytes thanks to @Stephen S - Using default function parameters
-2 Bytes thanks to OP - Replacing some spaces
-2 Bytes thanks to @Shaggy - Destructuring alphabet string

Demo

f=

(s='+----------'.repeat(3),p=0)=>[...'abcdefghijklmnopqrstuvwxyz'].map((c,i)=>(b=i%2,p=b?p+10:p,x=b&p<91,`${s}+'
|${c}.exe ${x?p+'%':'   '} |${'#'.repeat(x?p/10:10).padEnd(10)}|${x?'leeching':'seeding '}  |`)).join`
`+`
${s}+`

console.log(f());
.as-console-wrapper { max-height: 100% !important; top: 0; }

The last line is missing. Also, the submission and the Snippet differ; "leeching" is missing from the submission, for example.

@Shaggy Answer updated - Thanks for the follow

-2 bytes by moving s and p to default function parameters, removing the need for ()s around the function body: Fiddle

I'm not sure but can't you change ${x?'leeching  ':'seeding   '}| to the following:
${x?'leeching':'seeding '}  |?

@LiefdeWen You are right ! Thanks

Save more bytes by destructuring the string instead of splitting it.

PHP, 179 bytes
without input

for($a=a;$x<53;++$x&1?:$a++)printf($x&1?"
|$a.exe%4s |%-10s|%-10s|
":str_pad("",34,"+----------"),($y=$x%4>2&$x<36?++$z:"")?$y."0%":"",str_repeat("#",$y?:10),$y?leeching:seeding);

Try it online!
PHP, 176 bytes
with input

for($a=a;$x<53;)printf($x&1?"
|$a.exe%4s |%-10s|%-10s|
":str_pad("",34,"+----------"),($y=strstr($argn,++$x&1?:$a++)[2])?$y."0%":"",str_repeat("#",$y?:10),$y?leeching:seeding);

Try it online!

Save 9 bytes from the first version:
remove ++ from ++$x&1 (-2),
use $y=++$x%4|$z>9?"":++$z."0%" as second printf parameter (-9)
and insert $z before :10 (+2)

V, 107 bytes
¬azÓ./|&.exeò
ddÎAµ |±°#|seeding³ |
ÙÒ-4ñr+11lñddç^/P
jp4G9ñ8|R00%3l10r llRleeching4jñV{10g
çä/WylWl@"r#

Try it online!
Hexdump:
00000000: ac61 7ad3 2e2f 7c26 2e65 7865 f20a 6464  .az../|&.exe..dd
00000010: ce41 b520 7cb1 b023 7c73 6565 6469 6e67  .A. |..#|seeding
00000020: b320 7c0a d9d2 2d34 f172 2b31 316c f164  . |...-4.r+11l.d
00000030: 64e7 5e2f 500a 6a70 3447 39f1 387c 5230  d.^/P.jp4G9.8|R0
00000040: 3025 1b33 6c31 3072 206c 6c52 6c65 6563  0%.3l10r llRleec
00000050: 6869 6e67 1b34 6af1 567b 3130 6701 0ae7  hing.4j.V{10g...
00000060: e42f 5779 6c57 6c40 2272 23              ./WylWl@"r#

Japt, 121 bytes
;'++(-p10 +'+ ³
1
U+R+C£W=Yv ªY>20?10:Y¥1?1:V±1"|{X}.exe {4î hW>9?S:W+"0%"}|{10î h'#pW}|{10î hW<10?`äƒÊA`:`Ð:ˆg`}|"+R+U+R

Try it online!

Java (OpenJDK 8), 244 229 228 227 226 224 222 218 217 bytes
o->{String x="----------+",z="+"+x+x+x,s=z;for(int c=96,p;++c<123;s+=s.format("%n|%c.exe%4s |%-10s|%-10s|%n"+z,c,p>9?"":p+"0%","##########".substring(0,p),p>9?"seeding":"leeching"))p=(p=c/2-48)>9|c%2>0?10:p;return s;}

Try it online!
-2 bytes thanks to @KevinCruijssen!

Your leeching and seeding are right aligned.

Wow, fast comment! I just saw after posting and was busy fixing it :p

Sorry for being a nuissance, I just get excited seeing readable good

Nuisance? No, you weren't :)

Dangit.. While I was fixing and adding an explanation to my answer you've beat me to it.. And 34 bytes shorter I might add.. I see some simularities, but smart use of the .format and 0%, +1! Btw, you can golf your answer some more by starting with s=z instead, like this: o->{String x="----------+",z="+"+x+x+x,s=z;for(int c=96,p;++c<123;)s+=s.format("%n|%c.exe %3s |%-10s|%-10s|%n"+z,c,(p=(c%2>0|c/2-48>10)?10:c/2-48)<10?p+"0%":"","##########".substring(0,p),p<10?"leeching":"seeding");return s;} (225 bytes)

Thanks for the s=z and the Supplier -> Function ideas ;) Also, you gave me another idea with your answer: putting the p in the for block, which saved me another byte :P

@OlivierGrégoire You're welcome! And I really need to remember %-10s.. Such a useful formatting tool for challenges like this!

Ruby, 141 bytes
puts s=(?++?-*10)*3+?+,(?a..?z).map{|c|["|#{c}.exe%4s |%-10s|%-9s |"%(c.ord%2>0||($.+=1)>9?["",?#*10,:seeding]:["#$.0%",?#*$.,:leeching]),s]}

Try it online!

Braingolf, 673 655 bytes
9..#+[#-]#+[#-]#+[#-]"+
|"!&@V"a.exe     |"!&@V9[##]"|seeding   |
"!&@v!&@v<1+>!&@V8##[# ]"|leeching  |
"!&@v!&@v<1+>!&@v!&@vv!&@v<1+>!&@vv<<$_##>>!&@v!&@v<1+>!&@v!&@vv!&@v<1+>!&@vv<<<$_##>>>!&@v!&@v<1+>!&@v!&@vv!&@v<1+>!&@vv<<<<$_##>>>>!&@v!&@v<1+>!&@v!&@vv!&@v<1+>!&@vv<<<<$_##>>>>!&@v!&@v<1+>!&@v!&@vv!&@v<1+>!&@vv<<<<<$_##>>>>>!&@v!&@v<1+>!&@v!&@vv!&@v<1+>!&@vv<<<<<<$_##>>>>>>!&@v!&@v<1+>!&@v!&@vv!&@v<1+>!&@vv<<<<<<<$_##>>>>>>>!&@v!&@v<1+>!&@v!&@vv!&@v<1+>!&@vv<<<<<<<<$_##>>>>>>>>!&@v!&@v<1+>!&@v!&@vv!&@v<1+>!&@vv<<<<<<<<<$_##>>>>>>>>>!&@v!&@v<1+>!&@v!&@vv!&@v<1+>!&@v!&@vv!&@v<1+>!&@v!&@vv!&@v<1+>!&@v!&@vv!&@v<1+>!&@v!&@vv!&@v<1+>!&@v!&@vv$_!&@;

Try it online!
I've said it before and I'll say it again: Braingolf is bad at ASCII art.
At least this is only 1/3rd of the bytes it would take to actually hardcode the output

Plain TeX, 306 bytes
\let\a\advance\def\b{+\r{\r-9-+}3\par}\def\s{\r~5|\r\#9\#|seeding\r~3|}\def\r#1#2{{\i0\loop#1\a\i1
\ifnum\i<#2\repeat}}\newcount\i\i`a\newcount\j\j1\tt\loop\b|\char\i.exe\ifodd\i\s\else\ifnum\i<`s\
\the\j0\%~|\r\#\j{\j-\j \a\j10 \r~\j}\a\j1|leeching\r~2|\else\s\fi\fi\endgraf\a\i1 \ifnum\i<`\{\repeat\b\bye

Ungolfed with some explanations:
\let\a\advance
\def\b{+\r{\r-9-+}3\par}%           The bar between rows: '+' + 3*(9*'-' + '-' + '+') + '\n'
\def\s{\r~5|\r\#9\#|seeding\r~3|}%  The common part for seeding lines, similar to \b
\def\r#1#2{{%                       Macro for repeating #1 #2 times
% Note the local grouping here which is needed for nested \loops and allows us to reuse the global \i
  \i0%
  \loop
    #1%
    \a\i1 %
    \ifnum\i<#2%
   \repeat%
}}%
\newcount\i \i`a%                   Counter for ASCII values of letters, start with 'a'
\newcount\j \j1%                    Counter for percentages; shorter than modulo tricks
\tt
\loop
  \b|\char\i.exe%
  \ifodd\i
    \s%                             Odd lines are seeding lines
  \else
    \ifnum\i<`s\ %                  Even line up to 'r'
      \the\j0\%~|\r\#\j%            Print percentage and progress bar
      {\j-\j \a\j10 \r~\j}%         10-\j spaces after the progress bar
      \a\j1%
      |leeching\r~2|%
    \else
      \s%                           There's no \ifeven, hence the repetition here
    \fi
  \fi
  \endgraf%                         Print '\n'. \par doesn't work here, because \loop isn't a \long macro
  \a\i1
  \ifnum\i<`\{%                     Repeat until \j <= 'z'
\repeat
\b
\bye

Charcoal, 154 149 143 130 103 bytes
Ａ⁵δＦβ«Ｆ³«+χ»+⸿Ａ∨﹪δ²›δ⁹⁵θ|ι.exe⎇θ… ⁵⁺⁺ δ% ⁰|⎇θ…#χ⁺…#∕δχ… ⁻χ∕δχ⎇θ|seeding   |⸿↧|leeching  |⸿Ａ⁺⁵δδ»Ｆ³«+χ»+

Try it online! (Link to verbose version.)

27 bytes saves thanks to Neil's master Charcoaling techniques.

You can save a whole boatload of bytes by using \\r: Try it online!. Note that I've inserted dummy operations because I'm not getting any separators.

@Neil indeed, it seems that succesive printings are shorter than summing up chunks and printing the whole string. Not to mention the \r trick, I didn't know that.

Python 2, 172 170 162 bytes
-8 bytes thanks to Lynn

for i in range(2,28)+[id]:print('+'+'-'*10)*3+'+';a=i/2;b=i%2*(i<20);print('|'+'%-10s|'*3)%('%c.exe '%(95+i)+'%d0%%'%a*b,'#'*(a*b or 10),'sleeeedcihnign g'[b::2])

Try it online!

162 and exit via crash: https://tio.run/##LY7NCoMwEIRfJVCWTWJs40qh1fok4sGfVBdKFPXQgu@eptCZy8A3DLN89mn2FMJzXgUL9mJt/egkGbqppOahKZaV/S4xiU5RZ1bp/JfLtuILlV3FQFryg6wq/9UjYkgzux2ocwUSoT@7txMI8n5NWEU6WACEVncGT6hlDCIeiOMGt5eLGnqePI9ejFh3RUGNCuEL

Java 8, 271 263 262 bytes
o->{String a="+----------",b=a+a+a+"+\n",r=b;for(int c=96,t;++c<123;r+="|"+(char)c+".exe "+(t>0?(c/2-48)+"0%":"   ")+" |##########".substring(0,t>0?c/2-46:12)+"         |".substring(t>0?c/2-49:9)+(t>0?"leeching":"seeding ")+"  |\n"+b)t=c<115&c%2<1?1:0;return r;}

All this trouble for nothing.. >.> ;)
(Shorter Java answer by @OliverGrégoire.)
Explanation:
Try it here.
o->{                       // Method with unused Object parameter and String return-type
  String a="+----------",b=a+a+a+"+\n",
                           //  Temp String "+----------+----------+----------+\n"
         r=b;              //  Result-String
  for(int c=96,t;++c<123   //  Loop from 'a' to 'z':
      ;                    //    After every iteration:
       r+=                 //     Append the result-String with:
         "|"               //      A literal "|"
         +(char)c          //      + the character
         +".exe "          //      + literal ".exe "
         +(t>0?            //      If the current character is below 's' and even unicode:
           (c/2-48)+"0%"   //       + the percentage
          :                //      Else:
           "   ")          //       + the spaces
         +" |##########"   //      + the progress bar
           .substring(0,   //       By using a substring from 0 to
             t>0?          //        If the current character is below 's' and even unicode:
              c/2-46       //         'b' = 3; 'd' = 4; 'f' = 6; etc.
             :             //        Else:
              12)          //         12 (the entire progress bar)
         +"         |"     //      + spaces after the progress bar
           .substring(     //       By using a substring from
             t>0?          //        If the current character is below 's' and even unicode:
              c/2-49       //         'b' = 0; 'd' = 1; 'f' = 2; etc.
             :             //        Else:
              9)           //         9 (all the spaces)
         +(t>0?            //      If the current character is below 's' and even unicode:
           "leeching"      //       + literal "leeching"
          :                //      Else:
           "seeding ")     //       + literal "seeding "
         +"  |\n"          //      + literal "  |" + new-line
         +b)               //      + `b` ("+----------+----------+----------+\n")
  t=c<115&c%2<1?           //   If the current character is below 's' and even unicode:
     1                     //    `t` = 1
    :                      //   Else:
     0;                    //    `t` = 0
                           //  End of loop
  return r;                //  Return the result-String
}                          // End of method

Use a char instead of an int in the loop. It allows you to not cast it later on. t can be initialized and reinitialized to zero and += afterwards. It should still be shorter.

@OlivierGrégoire It's actually 2 bytes longer. int & (char) & t=...; vs char & {t=1;t*=...;}. Unless I'm missing something.

No you're not missing anything, that was my idea. I didn't take some other parts of your code in account.

Japt, 98 bytes
;27Æ4î+ ¬q-pU=10ÃíC¬£'|²¬q[X+".exe {W=Yu ©°T<U©T*U ?W+'%:P}"'#pW/UªU `äÊA Ð:g`¸g!W]m!hUî)q|})c ·

Doesn't work in the latest version due to a bug that messes up 4î+, q-p10, and q|, but it does work in commit f619c52. Test it online!

T-SQL, 238 bytes
DECLARE @ INT=1,@D CHAR(11)='+----------'L:PRINT @D+@D+@D+'+
|'+CHAR(@+96)+'.exe '+IIF(@%2=0AND
@<20,CONCAT(@/2,'0% |',REPLICATE('#',@/2),SPACE(10-@/2),'|leeching  |'),'    |##########|seeding   |')SET @+=1IF @<27GOTO L
PRINT @D+@D+@D+'+'

Procedural solution, formatted:
DECLARE @ INT=1, @D CHAR(11)='+----------'
L:
    PRINT @D + @D + @D + '+
|' + CHAR(@+96) + '.exe ' +
    IIF(@%2=0 AND @<20,
       CONCAT(@/2,'0% |',REPLICATE('#',@/2),SPACE(10-@/2),'|leeching  |'),
       '    |##########|seeding   |')
   SET @+=1
IF @<27 GOTO L
PRINT @D + @D + @D + '+'

Everything in the loop (up until the SET) is part of the same PRINT statement, including a line break inside the first string literal.
I'm working on a set-based solution (create and populate a table, then SELECT from it), but I'm not sure if its going to be smaller or not.

Python 3, 255 bytes
I'm sure this can be golfed, updating soon:
e,l='.exe ',('+'+10*'-')*3+"+";print(l)
for i in zip(['|'+chr(z)+e+'    |'+"#"*10+'|seeding   |'if z%2or z>115else'|'+chr(z)+e+str((z-96)//2*10)+'% |'+(z-96)//2*"#"+(10-(z-96)//2)*" "+"|leeching  |"for z in range(97,123)],[l]*26):print(i[0],i[1],sep="\n")

Try it online!

instead of leeching   | and seeding    | , can't you change it into leeching and seeding  +"   |"?

@LiefdeWen I'm afraid that's 8 bytes longer...

Come on, "updating soon"? Anyway 246 bytes with list splat and and/or.

Also, //2*10 is just *5 and 10-(z-96)//2 is just 58-z//2.

C (gcc), 217 211 bytes
-6 bytes thanks to ceilingcat
#define B"+----------"
f(p){for(char*a,*l=" bdfhjlnpr",i=97;puts(B B B"+"),i<'{';printf("|%c.exe %.*d%s |%-10.*s|%s  |\n",i++,!!a,p%10,a?"0%":"   ",p=a?a-l:10,"##########",a?"leeching":"seeding "))a=index(l,i);}

Try it online!

Stax, 53 68 64 bytes
â"{≤╞c~£ÿτδ¬│∙}Dgoô₧»öÖ#9▌ó♂i◘ÿkùâGCå`è╙/♠Gδb,φW0EqΔ┘δth½àJZ¿l╦#

Run and debug it
Unpacked and ungolfed it looks like this.
'+'-A*+34:mQ
VaF
  '|p
  ".exe "+
  |;i^hA?X
  $.0%+
  xA<Y*+G
  '#x*G
  `Qz/"D?d=T"`jy@G
  zP
  Q
}A(p'|p

Note that if you use the "Golf" button to remove whitespace and comments from the expanded solution, it incorrectly doubles the }.  If you remove the extra character, it continues to work correctly.

05AB1E, 120 bytes
AS".exe"«'A17×S9L‚ζJJðK€H©T*т%εD0Q_i'%«ëð3×}}‚ζεðýð«}®'#×T®-úí"leeching  seeding   "Tô®TQè)ζ'|ýε'|.ø}õ.ø'-T∍'+«3×'+ì¶.øý

Try it online!

There's way too much golfing to do here, will post explanation when I'm below 90 bytes.

///, 264 bytes
/~/\/\///!/---~@/!!!-~$/@+@+@~</+
|~>/|
+~(/###~*/  ~}/|leeching*~[/.exe ~;/0% |~{/[**|(((#|seeding* ~]/>$</+$<a{]b[1;# ****}]c{]d[2;##****}]e{]f[3;( ***}]g{]h[4;(#***}]i{]j[5;(## **}]k{]l[6;((**}]m{]n[7;#((* }]o{]p[8;##((*}]q{]r[9;((( }]s{]t{]u{]v{]w{]x{]y{]z{>$+

Try it online!
Works by defining a bunch of replacements and using them to replace more characters than they are.

Mathematica, 274 bytes
a=Alphabet[];n=StringPadRight;o=ToString;Column@Join[Row/@Table[{g="+----------+----------+----------+\n","|"<>o@a[[i]]<>".exe ",If[EvenQ@i&&i<20,s=o[5i]<>"% ";k="|"<>Table["#",i/2];f="leeching";,k="|##########";f="seeding";s="    "];s,n[k,11]<>"|",n[f,10],"|"},{i,26}],{g}]

Bubblegum, 150 bytes
00000000: e007 3d00 8c5d 0015 8b71 ec14 6414 8031  ..=..]...q..d..1
00000010: 7fc3 2b24 3568 ca81 7ab5 363e c3b7 f500  ..+$5h..z.6>....
00000020: c926 d3f0 55d9 926f 75a8 f8d0 806f 1f12  .&..U..ou....o..
00000030: d71f b824 7e75 a7f2 544f 0364 ee5e 98be  ...$~u..TO.d.^..
00000040: a327 c36c 2ff1 8e6e df94 858e 82d0 d9da  .'.l/..n........
00000050: 77d6 fac6 5548 64aa 7a29 78fa 6886 3c85  w...UHd.z)x.h.<.
00000060: 0494 905e 74de a209 e927 42c8 418d 8250  ...^t....'B.A..P
00000070: ee39 c16b a4c2 9add 0b17 f8b0 9984 9aa8  .9.k............
00000080: defb 2875 31a9 c136 0ec2 6f28 9f8c 9990  ..(u1..6..o(....
00000090: 10d4 0000 0d0a                           ......

Try it online!

Perl6, 225 219
my&f={say ("+"~"-"x 10)x 3~"+"};my&g={f;my$b=$^c>9??"   "!!$c*10~"%";say "|$^a.exe $b |{'#'x$c}{' 'x(10-$c)}|$^d  |"};my \s="seeding ";for 1..9 {g chr(95+2*$_),10,s;g chr(96+2*$_),$_,"leeching"};g $_,10,s for "s".."z";f

Lua, 380 bytes
s=string.gsub
r=string.rep
function l(i)return".exe "..i.."0% |"..r("#",i)..r(" ",10-i).."|leeching  |\n"end
print((s(s("Z|aY|b"..l(1).."Z|cY|d"..l(2).."Z|eY|f"..l(3).."Z|gY|h"..l(4).."Z|iY|j"..l(5).."Z|kY|l"..l(6).."Z|mY|n"..l(7).."Z|oY|p"..l(8).."Z|qY|r"..l(9).."Z|sY|tY|uY|vY|wY|xY|yY|zY","Y",".exe     |##########|seeding   |\nZ"),"Z","+----------+----------+----------+\n")))

Uses gsub to create the row dividers and the seeding rows. l generates the leeching rows. Renaming gsub and rep saves more bytes.

Jstx, 126 bytes
►-○EO.♥/(:►+:1►+;+₧D0%4►|22♫♥φézï2♂bdfhjlnpr♀*U!↑)☺:♣<!,♂% |♀:2&₧#=-₧#/')▬►#◙')§► ◙21♫♠~√╫WσΓÇ2◙↓♫♥¿Ç~√₧#/►#:1♫♣~√▐┬╞¿:2◙►|41%

Try it online!
Explanation
►-          # Push literal -
○           # Push literal 9
E           # Push the second stack value the absolute value of the first stack value times.
O           # Collapse all stack values into a string, then push that string.
.           # Store the first stack value in the d register.
♥           # Push literal 3
/           # Enter an iteration block over the first stack value.
(           # Push the value contained in the d register.
:           # Push the sum of the second and first stack values.
►+          # Push literal +
:           # Push the sum of the second and first stack values.
1           # End an iteration block.
►+          # Push literal +
;           # Push the difference of the second and first stack values.
+           # Store the first stack value in the a register.
₧D          # Push literal abcdefghijklmnopqrstuvwxyz
0           # Enter an iteration block over the first stack value and push the iteration element register at the beginning of each loop.
%           # Push the value contained in the a register.
4           # Print the first stack value, then a newline.
►|          # Push literal |
2           # Print the first stack value.
2           # Print the first stack value.
♫♥φézï      # Push literal .exe
2           # Print the first stack value.
♂bdfhjlnpr♀ # Push literal bdfhjlnpr
*           # Push the value contained in the iteration element register.
U           # Push a true if the second stack value contains the first stack value, else false.
!           # Push a copy of the first stack value.
↑           # Enter a conditional block if first stack value exactly equals true.
)           # Push the value contained in the iteration index register.
☺           # Push literal 1
:           # Push the sum of the second and first stack values.
♣           # Push literal 5
<           # Push the product of the second and first stack values.
!           # Push a copy of the first stack value.
,           # Store the first stack value in the b register.
♂% |♀       # Push literal % |
:           # Push the sum of the second and first stack values.
2           # Print the first stack value.
&           # Push the value contained in the b register.
₧#          # Push literal 10
=           # Push the quotient of the second and first stack values.
-           # Store the first stack value in the c register.
₧#          # Push literal 10
/           # Enter an iteration block over the first stack value.
'           # Push the value contained in the c register.
)           # Push the value contained in the iteration index register.
▬           # Enter a conditional block if the second stack value is less than the top stack value.
►#          # Push literal #
◙           # End a conditional block.
'           # Push the value contained in the c register.
)           # Push the value contained in the iteration index register.
§           # Enter a conditional block if the second stack value is greater than or equal to the top stack value.
►           # Push literal
◙           # End a conditional block.
2           # Print the first stack value.
1           # End an iteration block.
♫♠~√╫WσΓÇ   # Push literal |leeching
2           # Print the first stack value.
◙           # End a conditional block.
↓           # Enter a conditional block if first stack value exactly equals false.
♫♥¿Ç~√      # Push literal     |
₧#          # Push literal 10
/           # Enter an iteration block over the first stack value.
►#          # Push literal #
:           # Push the sum of the second and first stack values.
1           # End an iteration block.
♫♣~√▐┬╞¿    # Push literal |seeding
:           # Push the sum of the second and first stack values.
2           # Print the first stack value.
◙           # End a conditional block.
►|          # Push literal |
4           # Print the first stack value, then a newline.
1           # End an iteration block.
%           # Push the value contained in the a register.
            # Implied println upon termination.

I'm sure this can get significantly shorter.

PowerShell, 224 210 181 174 169 160 bytes
$l=("+"+"-"*10)*3+"+
"
0..25|%{"$l|$([char](97+$_)).exe "+("    |$("#"*10)|seeding ",("$(++$c/2)0% |{0,-10}|leeching"-f("#"*($c/2))))[$_%2-and$_-lt18]+"  |"}
$l

Try it online!
Now 64 bytes less terrible
Some Neat tricks: Combining a lot of "$(stuff)" to save on parens. We want only odd numbers which makes $_%2 = 1 so we don't need an -eq for it. Now uses list indexing instead of an if-else to save 5 bytes. Also gets rid of an `n for another byte. I couldn't get "$c`0%" to separate the var and zero so the current route was 1 byte shorter than gluing two strings together. Now with -f formatting.

///, 226 bytes
/;/ "//:/$$$+//,/0% |//*/###//)/   //(/!
|//'/,*//&/.exe //$/+----------//"/ |leeching  |
:
|//!/&) |***#|seeding)|
:/:
|a(b&1,#)) ;c(d&2,##));e(f&3'))"g(h&4'#) ;i(j&5'##);k(l&6'*)"m(n&7'*# ;o(p&8'*##;q(r&9'**"s(t(u(v(w(x(y(z!

Try it online!
A bit more sophisticated approach to defining replacements. Try it interactively here!

Pascal (FPC), 294 286 266 263 bytes
const m='----------+';Q=#10'+'+m+m+m+#10;S='.exe     |##########|seeding   |'+Q;var i:word;begin write(Q);for i:=1to 9do write('|',chr(95+i*2),S,'|',chr(96+i*2),'.exe ',i,'0% |',StringOfChar('#',i),'|leeching  |':22-i,Q);for i:=115to 122do write('|',chr(i),S)end.

Try it online!
So... I ended up with both leading and trailing newline :D

Deadfish~, 5782 bytes
{iiii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiic{ddd}iiic{ddddd}dc{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}iccccc{{i}d}iic{{d}i}i{c}{{i}d}dc{d}ic{d}ddddccdciiiiiciiiiic{d}iiic{{d}iii}dccc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiic{dd}ddddddc{ddddd}ddc{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}ic{ii}dddcdc{d}dcdddddc{{i}d}iic{{d}i}icdddccccccccc{{i}d}iic{d}ddddddc{d}iiiccddciiiiiciciiiiic{d}iiic{{d}iii}dcc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiic{dd}dddddc{ddddd}dddc{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}iccccc{{i}d}iic{{d}i}i{c}{{i}d}dc{d}ic{d}ddddccdciiiiiciiiiic{d}iiic{{d}iii}dccc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiic{dd}ddddc{ddddd}ddddc{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}ic{ii}ddcddc{d}dcdddddc{{i}d}iic{{d}i}iccdddcccccccc{{i}d}iic{d}ddddddc{d}iiiccddciiiiiciciiiiic{d}iiic{{d}iii}dcc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiic{dd}dddc{ddddd}dddddc{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}iccccc{{i}d}iic{{d}i}i{c}{{i}d}dc{d}ic{d}ddddccdciiiiiciiiiic{d}iiic{{d}iii}dccc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiic{dd}ddc{ddddd}ddddddc{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}ic{ii}dcdddc{d}dcdddddc{{i}d}iic{{d}i}icccdddccccccc{{i}d}iic{d}ddddddc{d}iiiccddciiiiiciciiiiic{d}iiic{{d}iii}dcc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiic{dd}dc{dddddd}iiic{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}iccccc{{i}d}iic{{d}i}i{c}{{i}d}dc{d}ic{d}ddddccdciiiiiciiiiic{d}iiic{{d}iii}dccc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiic{dd}c{dddddd}iic{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}ic{ii}cddddc{d}dcdddddc{{i}d}iic{{d}i}iccccdddcccccc{{i}d}iic{d}ddddddc{d}iiiccddciiiiiciciiiiic{d}iiic{{d}iii}dcc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiic{dd}ic{dddddd}ic{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}iccccc{{i}d}iic{{d}i}i{c}{{i}d}dc{d}ic{d}ddddccdciiiiiciiiiic{d}iiic{{d}iii}dccc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiic{dd}iic{dddddd}c{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}ic{ii}icdddddc{d}dcdddddc{{i}d}iic{{d}i}icccccdddccccc{{i}d}iic{d}ddddddc{d}iiiccddciiiiiciciiiiic{d}iiic{{d}iii}dcc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiic{dd}iiic{dddddd}dc{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}iccccc{{i}d}iic{{d}i}i{c}{{i}d}dc{d}ic{d}ddddccdciiiiiciiiiic{d}iiic{{d}iii}dccc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiic{d}ddddddc{dddddd}ddc{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}ic{ii}iicddddddc{d}dcdddddc{{i}d}iic{{d}i}iccccccdddcccc{{i}d}iic{d}ddddddc{d}iiiccddciiiiiciciiiiic{d}iiic{{d}iii}dcc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiic{d}dddddc{dddddd}dddc{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}iccccc{{i}d}iic{{d}i}i{c}{{i}d}dc{d}ic{d}ddddccdciiiiiciiiiic{d}iiic{{d}iii}dccc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiic{d}ddddc{dddddd}ddddc{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}ic{ii}iiic{d}iiic{d}dcdddddc{{i}d}iic{{d}i}icccccccdddccc{{i}d}iic{d}ddddddc{d}iiiccddciiiiiciciiiiic{d}iiic{{d}iii}dcc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiic{d}dddc{dddddd}dddddc{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}iccccc{{i}d}iic{{d}i}i{c}{{i}d}dc{d}ic{d}ddddccdciiiiiciiiiic{d}iiic{{d}iii}dccc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiic{d}ddc{dddddd}ddddddc{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}ic{ii}iiiic{d}iic{d}dcdddddc{{i}d}iic{{d}i}iccccccccdddcc{{i}d}iic{d}ddddddc{d}iiiccddciiiiiciciiiiic{d}iiic{{d}iii}dcc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiic{d}dc{{d}iii}iiic{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}iccccc{{i}d}iic{{d}i}i{c}{{i}d}dc{d}ic{d}ddddccdciiiiiciiiiic{d}iiic{{d}iii}dccc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiic{d}c{{d}iii}iic{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}ic{ii}iiiiic{d}ic{d}dcdddddc{{i}d}iic{{d}i}icccccccccdddc{{i}d}iic{d}ddddddc{d}iiiccddciiiiiciciiiiic{d}iiic{{d}iii}dcc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiic{d}ic{{d}iii}ic{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}iccccc{{i}d}iic{{d}i}i{c}{{i}d}dc{d}ic{d}ddddccdciiiiiciiiiic{d}iiic{{d}iii}dccc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiic{d}iic{{d}iii}c{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}iccccc{{i}d}iic{{d}i}i{c}{{i}d}dc{d}ic{d}ddddccdciiiiiciiiiic{d}iiic{{d}iii}dccc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiic{d}iiic{{d}iii}dc{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}iccccc{{i}d}iic{{d}i}i{c}{{i}d}dc{d}ic{d}ddddccdciiiiiciiiiic{d}iiic{{d}iii}dccc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiicddddddc{{d}iii}ddc{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}iccccc{{i}d}iic{{d}i}i{c}{{i}d}dc{d}ic{d}ddddccdciiiiiciiiiic{d}iiic{{d}iii}dccc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiicdddddc{{d}iii}dddc{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}iccccc{{i}d}iic{{d}i}i{c}{{i}d}dc{d}ic{d}ddddccdciiiiiciiiiic{d}iiic{{d}iii}dccc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiicddddc{{d}iii}ddddc{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}iccccc{{i}d}iic{{d}i}i{c}{{i}d}dc{d}ic{d}ddddccdciiiiiciiiiic{d}iiic{{d}iii}dccc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiicdddc{{d}iii}dddddc{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}iccccc{{i}d}iic{{d}i}i{c}{{i}d}dc{d}ic{d}ddddccdciiiiiciiiiic{d}iiic{{d}iii}dccc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc{ddd}dddc{{i}}{i}iiiicddc{{d}iii}ddddddc{iiiii}iiiiic{ii}dc{dd}ic{{d}iii}iccccc{{i}d}iic{{d}i}i{c}{{i}d}dc{d}ic{d}ddddccdciiiiiciiiiic{d}iiic{{d}iii}dccc{{i}d}iic{{d}}{d}ddddc{iii}iiicii{c}ddcii{c}ddcii{c}ddc

Try it online!
If this was code-bowling...

all_licenses: 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/


text:
ASCII Rubik's Cube
Inspired by this and the following chat:

Your task is to output the following:
   _ _ _
  /_/_/_/\
 /_/_/_/\/\
/_/_/_/\/\/\
\_\_\_\/\/\/
 \_\_\_\/\/
  \_\_\_\/

Extra leading or trailing whitespace is allowed, as long as it does not change the appearance of the cube. As usual, returning the above or a list of strings from a function is allowed.
This is code-golf, so shortest answer in bytes wins!

Sandbox

Related. (As well as, more tangentially, a couple of other challenges you can find when searching for "diamond tiling".)

10 hours in the Sandbox (especially with only one upvote) is hardly enough. I'd recommend waiting at least 48 hours.

@Dada it's KC, KC challenges don't need much time in Sandbox :)

To explain my downvote: I don't really like the challenge, because the image is taking much of the space, and I feel like you are more trying to show a funny image than to make a good challenge (even more since the pattern isn't the same as the one on the picture) (and I'm quite sure this will attract some upvotes from people that just laughed at the picture). Also, "output this exact string" with a string that looks more or less than this one has been done several times, and I fail to see how your challenge is different enough to be interesting.

@Dada fixed the image, thanks; that image inspired me, so I included it, it's not essential to the challenge. You can say the same for any KC challenge :)

@StephenS I gave +1, but I disagree that you can say the same for any KC challenge, when I make a KC challenge I make sure to make the pattern somewhat complex (so charcoal doesn't just auto-win), I make longer patterns so languages that can handle loops better have a chance (Like JS) and I try to use things that some languages might have built in like the alphabet, KC challenges differ a lot, and trying to say they are all the same takes something away from the category.

SOGL V0.12, 27 bytes
Y=Q∫+ZΔ○H!╝Ηūf⅟Ξ∆׀Æģ≠a⁶‘6«n

Try it Here!
Sadly, the palendromization version qE½Dε▒2β[}█O%q‘6«n╬∑ doesn't really work

Charcoal, 28 23 bytes
Ｆ³⁺⁺×\_³×\/⁻³ι¶ ‖Ｍ↑×_ ³

Try it online! Link is to verbose version of code. Not very Charcoal-y I know. I didn't realise that ‖Ｍ↓ deliberately moves the cursor so I had originally tried Ｆ³«Ｐ⁺×/_³×/\⁻³ι↗»‖Ｍ↓×_ ³ which didn't work, because I was trying to do it upside-down. If you want something more Charcoal-y then try Ｇ↗³←⁶↘³/\¶\/Ｇ↖³←⁷↘³_\¶\_↘‖Ｍ↑×_ ³ for 32 bytes: Try it online!

Bubblegum, 35 bytes
00000000: 5350 5088 0741 2e05 05fd 7830 8ce1 82b3  SPP..A....x0....
00000010: 806c 0413 c889 8907 4330 8f4b 01c1 036a  .l......C0.K...j
00000020: 8671 00                                  .q.

Try it online!

outgolfed in bubblegum

><>, 97 94 93 89 bytes
">knknknk//>k>knknknk/>k>k>knknknkk>k>k>n>n>n>k>k>n>n>n>/k>n>n>n>//n/n/n///"01.
of-

Try it online!
Edit 3: Figured out that you can use the character "" (ascii 25) - Now the process just takes 15 off every stack item and prints. Also removed extra directional instructions and replaced all with 1 move (01.)

Python 2, 81 bytes
i=7
while i:k=min(i,7-i);i-=1;print' '*(3-k)+'\/___ '[i/3::3]*3+k*'\//\\'[i>2::2]

Try it online!

Python 3, 98 94 bytes
@KevinCruijssen suggested this...
-4 bytes thanks to @HyperNeutrino and @WheatWizard
Output Hardcoding solution:
print(r"""   _ _ _
  /_/_/_/\
 /_/_/_/\/\
/_/_/_/\/\/\
\_\_\_\/\/\/
 \_\_\_\/\/
  \_\_\_\/""")

Try it online!
or, 98 bytes:
print("   _ _ _\n  /_/_/_/\\\n /_/_/_/\/\\\n/_/_/_/\/\/\\\n\_\_\_\/\/\/\n \_\_\_\/\/\n  \_\_\_\/")

Try it online!

Python 3, 139 bytes
Dumb Python 3 Non-Hardcoding sumbmission, sure it can be golfed. Surprisingly, compressing the two fors in just one loop is longer:
p=print;p(' '*3+"_ "*3)
for i in range(3):p(abs(2-i)*' '+'/_'*3+'/'+i*"\/"+'\\')
for i in range(3):p(i*' '+'\\_'*3+'\\'+"/\\"*abs(2-i)+'/')

Try it online!
Python 3, 140 bytes
print(' '*3+"_ "*3,'\n'+'\n'.join(abs(2-i)*' '+'/_'*3+'/'+i*"\/"+'\\'if i<3else (i-3)*' '+'\\_'*3+'\\'+"/\\"*abs(i-5)+'/'for i in range(6)))

Try it online!

Umm.. isn't hard-coding the output shorter? Even with the escaped slashes, it's 112 bytes in Java 8 / C# / JavaScript.

@KevinCruijssen It actually is >.<... Omg I'm so dumb

Now I have a lot of golfing to do....

96 bytes

And why do you have the extra newlines? :P

You can also use Python 2 to get 93 bytes

94 bytes if you use r

Your "dumb" 139 byte solution doesn't even work. You need to replace abs(i-3) on the 3rd line to (2-i)

@sagiksp It was a typo. Fixed now.

@HyperNeutrino Thanks for the suggestions

@WheatWizard I ninja'd you ;) :P

@HyperNeutrino Looks like by an hour. I thought you were just suggesting changing the language so I didn't click. :)

@WheatWizard Ah okay :) But yeah :P

139 bytes for last solution

Tail, 99 bytes
#!/bin/tail -n+2
    _ _ _
  /_/_/_/\
 /_/_/_/\/\
/_/_/_/\/\/\
\_\_\_\/\/\/
 \_\_\_\/\/
  \_\_\_\/

Welcome to PPCG!

Or the #!/bin/sed 1d variant

Java 8, 112 bytes
o->"   _ _ _\n  /_/_/_/\\\n /_/_/_/\\/\\\n/_/_/_/\\/\\/\\\n\\_\\_\\_\\/\\/\\/\n \\_\\_\\_\\/\\/\n  \\_\\_\\_\\/"

Hard-coded output.
Try it here.

Can I edit the JS and C# hardcoded parts into your answer?

Okay you can save 5 bytes on C# with verbatim literal so o=>@"... and then replace \n with an actual newline.

Bubblegum, 42 bytes
0000: e0 00 4f 00   22 5d 00 10   68 13 e2 04   15 00 b7 11 │ à.O."]..h.â...·.
0010: 7a 0e c5 f5   30 27 b5 b3   3d 39 8f a6   1f f9 74 52 │ z.Åõ0'µ³=9.¦.ùtR
0020: c5 66 98 bd   bd 0a 9a 8d   44 00                     │ Åf.½½¶..D.

PHP, 77 bytes
<?=strtr('   _ _ _
  0\
 01\
011\
2111
 211
  21',["/_/_/_/","\/","\_\_\_"]);

Try it online!

Save 4 bytes: Try it online!

@Neil Thank You and additional 2 Bytes saved

It's always great when you can outperform literal output!

Retina, 59 bytes

   _¶  /_/\¶ /_/V\¶/_/VV\¶\_VVV¶ \_VV¶  \_V
._
$&$&$&
V
\/

Try it online! Explanation: The first stage simply creates the following:
   _
  /_/\
 /_/V\
/_/VV\
\_VVV
 \_VV
  \_V

The second stage then expands all the _s by repeating them and the previous character 3 times, while the third stage turns the Vs into \/s.

C#, 86 bytes
o=>@"   _ _ _
  /_/_/_/\
 /_/_/_/\/\
/_/_/_/\/\/\
\_\_\_\/\/\/
 \_\_\_\/\/
  \_\_\_\/"

Try it here.

Challenging. Found a slightly smaller total size (header+footer+code), but exchanges smaller header/footer for slightly larger main than yours: Try it online!

@MarkRejhon Unfortunately it's the main part that counts with the default program or function. ;) With the added o=>{} it would be 98 bytes in your case.

05AB1E, 34 31 bytes
„_ 3×Âð'/:3F„/\«∞2ä`RˆD}\)¯R«.c

Try it online!
Explanation
„_ 3×             # push the string "_ _ _ "
     Â            # push a reversed copy
      ð'/:        # replace spaces with slashes
3F                # 3 times do
  „/\«            # append "/\"
      ∞           # mirror
       2ä`        # split into 2 separate parts on stack
         Rˆ       # reverse the second part and push to global list
           D      # duplicate the remaining part
            }     # end loop
\)                # discard the last copy and wrap stack in a string
  ¯R              # push the global list and reverse it
    «             # append to the rest of the list
     .c           # pad lines to equal length

Alternate 31 byte solution
„ _3×3FDð'/:„/\«∞2ä`R.Á})ÀÀÀ.c¦

ÀÀÀ in that alternate version [O_O"]...

@MagicOctopusUrn: Yeah... I haven't found a shorter way to do or get around it :P

I concur, I spent a couple minutes trying too; there's no way around it I can see xD.

CSS, 225 223 bytes
-2 bytes thanks to Stephen S, extra spaces removed
I'm not exactly sure if this counts because CSS isn't really a programming language, but technically CSS can be standalone since the <html> element is autogenerated if there isn't one.

html:after{content:'   _ _ _ \A   /_/_/_/\005c\A  /_/_/_/\005c/\005c \A /_/_/_/\005c/\005c/\005c \A \005c_\005c_\005c_\005c/\005c/\005c/ \A  \005c_\005c_\005c_\005c/\005c\/\A   \005c_\005c_\005c_\005c /';white-space: pre;}

And here's a version with a monospaced font,  247 246 bytes.
-1 byte thanks to Stephen S, extra spaces removed

html:after{font-family:'Courier';content:'   _ _ _ \A   /_/_/_/\005c\A  /_/_/_/\005c/\005c \A /_/_/_/\005c/\005c/\005c \A \005c_\005c_\005c_\005c/\005c/\005c/ \A  \005c_\005c_\005c_\005c/\005c\/\A   \005c_\005c_\005c_\005c /';white-space: pre;}

I think you can delete some spaces in the CSS around :s and {}s

05AB1E, 35 32 31 bytes
"/ _\"•₁7æ¤ÝI}?ÕR&Ü•4вè4ôJ€∞ø¨»

Try it online!
100% different method than Emigna.

Edit: If I start with the pattern already transposed I can cut out 3 bytes.

"/ _\"            # Push ASCII-art characters used.
•₁7æ¤ÝI}?ÕR&Ü•4в  # Push transposed version of base-4 pattern.
è                 # Replace all digits in base-4 number with appropriate symbol.
 4ô               # Split into groups of 4.
   J              # Join together.
    €∞            # Mirror each row (technically column).
      ø           # Transpose back.
       ¨»         # Remove the extra "_ _ _", and print with newlines.

JavaScript (ES6), 95 bytes
_=>String.raw`   _ _ _
  /_/_/_/\
 /_/_/_/\/\
/_/_/_/\/\/\
\_\_\_\/\/\/
 \_\_\_\/\/
  \_\_\_\/`

JavaScript (ES6), 103 94 bytes
-9 bytes thanks to @Shaggy
_=>`   _ _ _
  ${a=`/_/_/_/\\`}
 ${a}/\\
${a}/\\/\\
${b=`\\_\\_\\_\\/`}\\/\\/
 ${b}\\/
  ${b}`

JavaScript (ES6), 106 bytes
_=>`   _ _ _
  /_/_/_/\\
 /_/_/_/\\/\\
/_/_/_/\\/\\/\\
\\_\\_\\_\\/\\/\\/
 \\_\\_\\_\\/\\/
  \\_\\_\\_\\/`

94 bytes.

@Shaggy duh, I knew that, even used it recently. Thanks!

93 bytes

@JoshuaBell feel free to post that as your own answer, that's definitely not a golf of mine :) (it's also very ingenius)

Ruby, 72 70 bytes
7.times{|i|puts' '*(j=i^i/4+3)+'_ \_/_'[-i/3*2,2]*3+'/\/'[i/4,2]*j^=3}

Latest edit: avoid double \ by enclosing strings in '' instead of "".
Ungolfed (note in Ruby negative string indexes wrap around. -1 is the last character.)
7.times{|i|                       #7 lines.
  puts" "*(j=i^i/4+3)+            #Print j= 3,2,1,0, 0,1,2 spaces.
      "_ \\_/_"[-i/3*2,2]*3+      #Print 3 repeats of 2 characters from the string, index 0,-2,-2,-2,-4,-4,-4.
      "/\\/"[i/4,2]*j^=3          #Print 2 characters from the string, /\ or \/, repeated 3^j times.
}

Windows Batch, 122 bytes
@echo    _ _ _
@echo   /_/_/_/\
@echo  /_/_/_/\/\
@echo /_/_/_/\/\/\
@echo \_\_\_\/\/\/
@echo  \_\_\_\/\/
@echo   \_\_\_\/

Pretty self-explantory.

Brainf*ck  387 bytes
Not even sure if this is still a thing but I was bored and did it for sh*ts and giggles :)
++++++++[->++++>++++>++++>++++<<<<]+++++[->>+++>+++>+++<<<<]<+++[->+++++<]>[->>>+++>+++<<<<]>>>>+++<<<...<+++[->.>>>.<<<<]<<++++++++++>+++++++++++++.<.>>>..>.<<+++[->>>>.<<.<<]>>>.<<<<.<.>>>.>.<<+++[->>>>.<<.<<]>>>.<.>.<<<<.<.>>>>.<<+++[->>>>.<<.<<]>>>.<.>.<.>.<<<<.<.>>>>>.<<<+++[->>>>.<.<<<]>>.>.<.>.<.<<<.<.>>>.>>.<<<+++[->>>>.<.<<<]>>.>.<.<<<.<.>>>..>>.<<<+++[->>>>.<.<<<]>>.<<<.<.>>

Edit:
TIL: I am 54.28% more effective than some generator I found online ^.^
Edit2:
Try it online Make sure Wrap is on for Memory overflow behaviour in the options

COBOL, 238 bytes
Compiled with open-cobol. Note that the indentation is a single tab, not spaces, even if this website formats it that way.
    IDENTIFICATION DIVISION.
    PROGRAM-ID. a.
    PROCEDURE DIVISION.
    DISPLAY "   _ _ _".
    DISPLAY "  /_/_/_/\".
    DISPLAY " /_/_/_/\/\".
    DISPLAY "/_/_/_/\/\/\".
    DISPLAY "\_\_\_\/\/\/".
    DISPLAY " \_\_\_\/\/".
    DISPLAY "  \_\_\_\/".
    STOP RUN.

Perl 5, 89 bytes
say"   _ _ _";$r[7-$_]=($r[$_]=$"x(3-$_).'/_'x3 .'/\\'x$_.$/)=~y|/\\|\\/|r for 1..3;say@r

Try it online!

Deadfish~, 687 bytes
{iii}iiccc{iiiiii}iiic{dddddd}dddc{iiiiii}iiic{dddddd}dddc{iiiiii}iiic{{d}ii}dddddc{ii}iicc{i}iiiiic{iiiii}ddc{ddddd}iic{iiiii}ddc{ddddd}iic{iiiii}ddc{ddddd}iic{iiii}iiiiic{{d}ii}ddc{ii}iic{i}iiiiic{iiiii}ddc{ddddd}iic{iiiii}ddc{ddddd}iic{iiiii}ddc{ddddd}iic{iiii}iiiiic{dddd}dddddc{iiii}iiiiic{{d}ii}ddc{iiii}dddc{iiiii}ddc{ddddd}iic{iiiii}ddc{ddddd}iic{iiiii}ddc{ddddd}iic{iiii}iiiiic{dddd}dddddc{iiii}iiiiic{dddd}dddddc{iiii}iiiiic{{d}ii}ddc{{i}dd}iiciiicdddciiicdddciiicdddc{dddd}dddddc{iiii}iiiiic{dddd}dddddc{iiii}iiiiic{dddd}dddddc{dddd}iiic{ii}iic{iiiiii}ciiicdddciiicdddciiicdddc{dddd}dddddc{iiii}iiiiic{dddd}dddddc{dddd}iiic{ii}iicc{iiiiii}ciiicdddciiicdddciiicdddc{dddd}dddddc

Try it online!

Vyxal j, 33 32 bytes
-1 bytes thanks to Aaron Miller
»\!¡øoΠ¥⅛831‟½ø↲p∇±₀WṀ»‛_ k/+τ7/

Explanation
»\!¡øoΠ¥⅛831‟½ø↲p∇±₀WṀ»             - Push a base-4 number containing the cube
                       ‛_ k/+τ      - Change to custom base, replacing the numbers
                                      with the symbols.
                              7/    - Divide into seven lines.
<j flag>                            - Join by newlines
<implicit output>                   - Print it!

Try it Online!

32 bytes

Self-modifying Brainfuck, 86 bytes
Replace the ␀ with an actual null byte (0x00).
<[.<]␀/\_\_\_\
/\/\_\_\_\
/\/\/\_\_\_\
\/\/\/_/_/_/
\/\/_/_/_/
\/_/_/_/
_ _ _

Try it online!
Explanation
Another literal output answer.
<[.<]             - Print the source code in reverse until a NULL byte is found.
     ␀            - Null, replace with 0x00. Ends program.
      <the rest>  - The cube in reverse.

Zsh, 86 bytes
Port of the PHP solution. Try it online!
sed 's|0|/_/_/_/|;s|1|\\/|g;s|2|\\_\\_\\_|'<<<'   _ _ _
  0\
 01\
011\
2111
 211
  21'

But the naïve approach only costs 1 extra, for 87 bytes ...
 <<<'    _ _ _
  /_/_/_/\
 /_/_/_/\/\
/_/_/_/\/\/\
\_\_\_\/\/\/
 \_\_\_\/\/
  \_\_\_\/'

tried flipping the \ to / to build the bottom half, but it ended up over 100 bytes..

Python 2, 93 bytes
print r"""   _ _ _
  /_/_/_/\
 /_/_/_/\/\
/_/_/_/\/\/\
\_\_\_\/\/\/
 \_\_\_\/\/
  \_\_\_\/"""

Try it online!


text:
Trim the array!
Given an integer array and two numbers as input, remove a certain amount of the first and last elements, specified by the numbers. The input can be in any order you want.
You should remove the first x elements, where x is the first numerical input, and also remove the last y elements, where y is the second numerical input.
The resulting array is guaranteed to have a length of at least two.
Examples:
[1 2 3 4 5 6] 2 1 -> [3 4 5]
[6 2 4 3 5 1 3] 5 0 -> [1 3]
[1 2] 0 0 -> [1 2]

What, exactly, does it mean to "remove" values from an array—especially to remove them from the end? In languages like C, where an array is just a pointer to the first element and a length, can we just change the length to truncate the array? That's what would normally be done in real-world programming, but the challenge is unclear to me.

@CodyGray Removing values from the array is what it should look like, but not necessarily what goes on behind the scenes.

What do you mean by "look like"? Arrays don't have a look – it is all behind the scenes!

@CodyGray It doesn't matter.

Due to the multitude of answer, you can maybe add a leaderboard snippet to your question?

@Michthan Try installing the PPCG userscript

@Okx Nope, that's very buggy, I'd recommend adding a leaderboard.

@EriktheOutgolfer It's been working pretty well for me.

@Okx Try to use TIO provided by the userscript.

@EriktheOutgolfer Well that doesn't work, but the leaderboard does.

@Okx Also, please stop being lazy...:P...btw the userscript also has unwanted side-effects.

@EriktheOutgolfer You do know that there's nothing stopping you from using the edit button, right? ;)

@Sanchises I'm not sure if OP wants a leaderboard though.

Does there need to be a space between the returned values?

@BruceWayne No, it just needs to be some sort of integer list.

Haskell, 55 39 33 29 bytes
Saved 16 bytes thanks to Laikoni
Saved 6 more bytes thanks to Laikoni
Saved 4 more bytes thanks to Laikoni
Am sure this could be improved, but as a beginner, gave it my best shot.
r=(reverse.).drop
a#b=r b.r a

Usage
(5#0) [6,5,4,3,2,1,3]

Try it online!

Welcome to PPCG and Haskell golfing in particular! The objective is to use as few bytes as possible, so you can for example remove most of the spaces and shorten xs.

@Laikoni Ah, thanks! Edited, can't see myself going any shorter without an anonymous function and using applicative for functions (not sure how that works).

Looking good now! :) If you change f x a b to f a b x, you can simply drop the x: f a b=reverse.drop b.reverse.drop a.

An additional handy trick from our Tips for golfing in Haskell is to use an infix operator instead of f, that is for example a#b=... instead of f a b. Your usage is then (5#0)[6,5,4,3,2,1,3]. Finally you can declare r=reverse as auxiliary function and shorten both usages in your main function.

@Laikoni Wow, interesting infix trick. Thanks again! I was able to shorten it to 33 bytes, but trying to do a#b=let r=reverse in r.drop b.r.drop a is 38 bytes. Or are we allowed to have a function declared outside this one?

From the Guide to golfing Rules in Haskell: "you can have auxiliary functions and/or constants defined on separate lines". You can save even more by defining r y=reverse.drop y, which again is equal to r=(reverse.).drop.

@Laikoni Thanks for the introduction, very helpful. Just found this site today, but definitely look forward to playing around here some more!

I'm glad you enjoy the site so far. Using pointfree.io I found one more byte to save: The rules allow also anonymous functions and OP stated that the arguments can be in any order, so a#b=r b.r a can be shortened to the anonymous function (.r).(.).r. Note that this  changes the calling pattern to function y x [list].

And to conclude my introduction tour, you can add a link to an online testing environment for the conveninece of others: Try it online!

Mathematica, 17 bytes
#[[#2+1;;-#3-1]]&

input

[{1, 2, 3, 4, 5, 6}, 2, 1]

Nice use of ;;! I managed to tie you with Drop@##2~Drop~-#& (if we take the input in a weird order like 1, {1,2,3,4,5,6}, 2), but no better.

Octave, 20 bytes
@(a,x,y)a(x+1:end-y)

Try it online!

Python, 28 26 bytes
-2 bytes thanks to @Rod
lambda a,n,m:a[n:len(a)-m]

Try it online!

save 6... lambda a,n,m:a[n:~m]

@Aaron this removes one item too much.

my bad.. It's a common trick I sometimes use, and didn't fully check against the requirements of the challenge..

@Aaron the slice has a higher operator precedence than the + and is therefore applied to [0]. You would need brackets: (a+[0])[n:~m].

yah, realized that later.. I'm trying to make my idea work

can't you do lambda a,n,m:a[n:-m]?

C# (.NET Core), 55 54 bytes
using System.Linq;(a,x,y)=>a.Skip(x).Take(a.Count-x-y)

Try it online!
Uses a List<int> as input.

1 byte saved thanks to TheLethalCoder!

I was just about to answer this +1. However, you can save a byte by taking a List as input so you can use Count instead of Length.

I came up with a solution using Where that is only slightly longer than this way that I'm quite happy with as well :)

You don't need to add using System.Linq; to the byte count :)

@Stefan I need to count every using I add in my answer, and the methods Skip and Take need that using.

hm. okay. On some other challenge I was told that those usings where not necessary.

@Stefan Note for both of you usings are always required if you need to add them in for C#. However, if you use C# Interactive or C# Linqpad or similar you might not need some of them as they are included by default. But then your answer is no longer just C# so you should update the header accordingly.

Neim, 3 bytes
₃

Try it here
Thanks to Okx for encouraging me to do this...:)

Java (OpenJDK 8), 32 bytes
(l,i,j)->l.subList(i,l.size()-j)

Try it online!
If we really restrict to arrays, then it's 53 bytes:
(a,i,j)->java.util.Arrays.copyOfRange(a,i,a.length-j)

Try it online!

Perl 5, 21 bytes
19 bytes of code + -ap flags.
$_="@F[<>..$#F-<>]"

Try it online!
Uses -a to autosplit the input inside @F, then only keep a slice of it according to the other inputs: from index <> (second input) to index $#F-<> (size of the array minus third input). And $_ is implicitly printed thanks to -p flag.

JavaScript (ES6), 27 bytes
(a,n,m)=>a.slice(n,-m||1/m)

A negative second parameter to slice stops slicing m from the end, however when m is zero we have to pass a placeholder (Infinity here, although (a,n,m,o)=>a.slice(n,-m||o) also works).

Rust, 29 bytes
|n,i,j|&n[i..<[_]>::len(n)-j]

Call it as follows:
let a = &[1, 2, 3, 4, 5, 6];
let f = |n,i,j|&n[i..<[_]>::len(n)-j];
f(a, 2, 1)

I had a lot of fun fighting with the borrow checker figuring out what the shortest approach was in order to have it infer the lifetime of a returned slice. Its behavior around closures is somewhat erratic, as it will infer the lifetimes, but only if you do not actually declare the parameter as a reference type. Unfortunately this conflicts with being required to define the argument type in the signature as the n.len method call needs to know the type it's operating on.
Other approaches I tried working around this issue:
fn f<T>(n:&[T],i:usize,j:usize)->&[T]{&n[i..n.len()-j]}     // full function, elided lifetimes
let f:for<'a>fn(&'a[_],_,_)->&'a[_]=|n,i,j|&n[i..n.len()-j] // type annotation only for lifetimes. Currently in beta.
|n:&[_],i,j|n[i..n.len()-j].to_vec()                        // returns an owned value
|n,i,j|&(n as&[_])[i..(n as&[_]).len()-j]                   // casts to determine the type
|n,i,j|&(n:&[_])[i..n.len()-j]                              // type ascription (unstable feature)
|n,i,j|{let b:&[_]=n;&b[i..b.len()-j]}                      // re-assignment to declare the type

TIS-100, 413 405 Bytes
472 cycles, 5 nodes, 35 lines of code
m4,6
@0
MOV 0 ANY
S:MOV UP ACC
JEZ A
MOV ACC ANY
JMP S
A:MOV RIGHT ACC
L:JEZ B
MOV DOWN NIL
SUB 1
JMP L
B:MOV 0 RIGHT
MOV RIGHT NIL
@1
MOV RIGHT LEFT
MOV LEFT DOWN
MOV RIGHT DOWN
MOV DOWN LEFT
@2
MOV UP ACC
MOV UP LEFT
MOV ACC LEFT
@4
MOV 0 RIGHT
MOV UP NIL
S:MOV LEFT ACC
JEZ A
MOV ACC RIGHT
JMP S
A:MOV UP ACC
L:JEZ B
MOV RIGHT NIL
SUB 1
JMP L
B:MOV 0 UP
K:MOV RIGHT ACC
MOV ACC DOWN
JNZ K
@7
MOV UP ANY

The m4,6 at the top is not part of the code, but signals the placement of the memory modules.

Play this level yourself by pasting this into the game:

function get_name()
    return "ARRAY TRIMMER"
end
function get_description()
    return { "RECIEVE AN ARRAY FROM IN.A", "RECIEVE TWO VALUES A THEN B FROM IN.T", "REMOVE THE FIRST A TERMS AND LAST B TERMS FROM IN.A", "ARRAYS ARE 0 TERMINATED" }
end

function get_streams()
    input = {}
    trim = {}
    output = {}

  arrayLengths = {}

    a = math.random(1,5) - 3

    b = math.random(1,7) - 4

    arrayLengths[1] = 9+a
    arrayLengths[2] = 9+b
    arrayLengths[3] = 8-a
    arrayLengths[4] = 9-b

    s = 0

    trimIndex = 1

  for i = 1,4 do
      for k = 1,arrayLengths[i] do
          x = math.random(1,999)
      input[k+s] = x
            output[k+s] = x
        end

        input[s + arrayLengths[i] + 1]= 0
        output[s + arrayLengths[i] + 1]= 0

        a = math.random(0,3)
        b = math.random(0,arrayLengths[i]-a)

        trim[trimIndex] = a
        trim[trimIndex+1] = b

        trimIndex = trimIndex + 2

    s = s + arrayLengths[i] + 1
    end

    s = 1
    trimIndex = 1

    for i = 1,4 do

      for i = s,s+trim[trimIndex]-1 do
          output[i]=-99
        end

        for i = s + arrayLengths[i] - trim[trimIndex+1], s + arrayLengths[i]-1 do
      output[i]=-99
        end

  trimIndex = trimIndex +2
  s = s + arrayLengths[i] + 1
    end

    trimmedOut = {}
    for i = 1,39 do
            if(output[i] ~= -99) then
                    table.insert(trimmedOut, output[i])
            end
    end

    return {
        { STREAM_INPUT, "IN.A", 0, input },
        { STREAM_INPUT, "IN.T", 2, trim },
        { STREAM_OUTPUT, "OUT.A", 1, trimmedOut },
    }
end
function get_layout()
    return {
        TILE_COMPUTE,   TILE_COMPUTE,   TILE_COMPUTE,   TILE_COMPUTE,
        TILE_MEMORY,    TILE_COMPUTE,    TILE_MEMORY,   TILE_COMPUTE,
        TILE_COMPUTE,   TILE_COMPUTE,   TILE_COMPUTE,   TILE_COMPUTE,
    }
end

So I suppose this also counts as a lua answer...

You can now try it online! Note: I had to do a clever, and use the top of the code file as one source of input, since TIO currently only provides a single input file.

MATL, 6 bytes
QJi-h)

Try it online!
Input is given as 1) number of elements to trim from the start; 2) number of elements to trim from the end; 3) array. Explanation
Q   % Implicit input (1). Increment by 1, since MATL indexing is 1-based.
Ji- % Complex 1i minus real input (2). In MATL, the end of the array is given by `1i`.
h   % Concatenate indices to get range-based indexing 1+(1):end-(2).
)   % Index into (implicitly taken) input array. Implicit display.

Husk, 3 bytes
↓↓_

Try it online!
Explanation
                                               |  1 [1,2,3,4,5,6] 2
  _  -- negate y                               | -1 [1,2,3,4,5,6] 2
 ↓   -- drop y from end (negative argument)    |  [1,2,3,4,5] 2
↓    -- drop x from beginning                  |  [3,4,5]

C#, 62 bytes
using System.Linq;(l,x,y)=>l.Where((n,i)=>i>=x&i<=l.Count-y-1)

Takes a List<int> as input and returns an IEnumerable<int>.

This also works for 64 bytes:
using System.Linq;(l,x,y)=>l.Skip(x).Reverse().Skip(y).Reverse()

MATL, 10 bytes
tniQwi-&:)

Try it online!
Explanation:
It's a bit long for just 11 bytes, but I'm writing it out in detail, to learn it myself too.
---- Input ----
[1 2 3 4 5 6]
2
1
----- Code ----
           % Implicit first input
t          % Duplicate input.
           % Stack: [1 2 3 4 5 6], [1 2 3 4 5 6]
 n         % Number of elements
           % Stack: [1 2 3 4 5 6], 6
  i        % Second input
           % Stack: [1 2 3 4 5 6], 6, 2
   Q       % Increment: [1 2 3 4 5 6], 6, 3
    w      % Swap last two elements
           % Stack: [1 2 3 4 5 6], 3, 6
     i     % Third input
           % Stack: [1 2 3 4 5 6], 3, 6, 1
      -    % Subtract
           % Stack: [1 2 3 4 5 6], 3, 5
       &:  % Range with two input arguments, [3 4 5]
           % Stack: [1 2 3 4 5 6], [3 4 5]
         ) % Use as index
           % Stack: [3 4 5]
           % Implicit display

You forgot about end-based indexing ;)

(still, have an upvote - I believe this is well golfed and explained considering the method you used)

Nope, I didn't forget it! I tried, but I didn't figure out how to make it work, (and I really tried). I concluded that it was impossible to subtract something from J, when used like this. I suspected I was wrong, I just couldn't figure it out for the life of me... Thanks for linking to your answer, I'm very much a MATL novice...

Don't worry, I'm also very much learning still - e.g., the order of the inputs to ) and more notoriously ( shiver...

@Sanchises Very late comment, but I'm glad it's not just me that finds the input order to ( confusing. :) I've taken to reciting "ddi" (= "destination, data, indices" from the manual) every time, and still get it wrong sometimes.

@sundar "diff diff input?" :)  Yeah combined with the 'reversed' way the stack works I still struggle with that.

Jelly, 5 bytes
Ṗ¡Ḋ⁴¡

Try it online!

Also 5 bytes :)

@HyperNeutrino I had this version too...but I decided this is more elegant. :)

Dyalog APL, 16 bytes
{(⍵↓⍨⊃⍺)↓⍨-⍺[2]}

Try it online!

why was this downvoted?

R, 32 31 30 bytes
-1 byte thanks to Rift
-1 byte thanks to Jarko Dubbeldam
pryr::f(n[(1+l):(sum(n|1)-r)])

Evaluates to an anonymous function:
function (l, n, r)
    n[(1 + l):(sum(n|1) - r)]

1+l is necessary since R has 1-based indexing. sum(n|1) is equivalent to length(n) but it's a byte shorter.
Try it online!

saving 1 byte with pryr::f(n[(1+l):(length(n)-r)])

Sum(n|1) is shorter than length(n)

@JarkoDubbeldam excellent, thank you.

C++, 96 95 bytes
Thanks to @Tas for saving a byte!
#import<list>
int f(std::list<int>&l,int x,int y){for(l.resize(l.size()-y);x--;)l.pop_front();}

Try it online!
C++ (MinGW), 91 bytes
#import<list>
f(std::list<int>&l,int x,int y){for(l.resize(l.size()-y);x--;)l.pop_front();}

Did you mean #include<list>? You could shave a byte by having int f. Compilers will allow a function to not return, but they'll warn against it

Yeah, thanks, int f will work on most compilers, I'll edit that in. On MinGW, even completely omitting the type of the function works. And yes, #include<list> would be a standard-compliant way to include the header, but #import<list> should work at least on GCC, MinGW and MSVC, so it should be fine too.

APL (Dyalog), 8 7 bytes
⌽⎕↓⌽⎕↓⎕

Try it online!
This takes the array as the first input, followed by the two numbers separately.
Explanation
⎕            from the input array
⎕↓           drop the first input elements
⌽            reverse the array
⎕↓           drop first input elements
⌽            reverse again to go back to the original array

Alternative 7 byte solution: ⎕↓⎕↓⍨-⎕

PHP>=7.1, 59 bytes
<?[$a,$b,$e]=$_GET;print_r(array_slice($a,$b,$e?-$e:NULL));

PHP Sandbox Online

Brain-Flak, 60 bytes
(()()){({}<{({}<{}>[()])}{}([]){{}({}<>)<>([])}{}<>>[()])}{}

Try it online!
Input is in this format:
x

a
r
r
a
y

y

Where x is the number to take from the front, y is the number to take from the back, and the array is just however many numbers you want, separated by newlines. Here are my first two (longer) attempts:
({}<>)<>{({}<{}>[()])}([])<>({}<><{{}({}<>)<>([])}{}><>){({}<{}>[()])}{}([]){{}({}<>)<>([])}<>{}
{({}<{}>[()])}{}([]){{}({}<>)<>([])}{}<>{({}<{}>[()])}{}([]){{}({}<>)<>([])}<>

And here is an explanation:
#Two times:
(()()){({}<

    #Remove *n* numbers from the top of the stack
    {({}<{}>[()])}{}

    #Reverse the whole stack
    ([]){{}({}<>)<>([])}{}<>

>)[()]}{}

Nice to see a turing tarpit solution every now and then.

C++, 50 48 46 bytes
#define f(a,x,y)decltype(a)(&a[x],&*a.end()-y)

Try it online!

APL (Dyalog), 5 bytes
(⌽↓)/

Try it online!

Input format is y x A
Explanation
/ is Reduce, which inserts the function to the left between each pair of elements of the argument
(⌽↓) is a function train equivalent to {⌽⍺↓⍵}, which removes the first ⍺ elements of the array ⍵ and then reverses the array. (⍺ is the left argument and ⍵ is the right argument)
Thus, (⌽↓)/y x A is equivalent to ⌽y↓⌽x↓A, which is what is needed.

-1

Ruby, 17 bytes
->a,b,c{a[b..~c]}

Try it online!

K (oK), 10 bytes
{(-z)_y_x}

Try it online!
Port of my q/kdb+ answer...

Japt, 6 bytes
oW UsV

Try it
sVWnUl

Try it
oW UsV     :Implicit input of array U and integers V=x & W=y
oW         :Remove the last W elements of U, mutating the original
   UsV     :Slice U from 0-based index V

sVWnUÊ     :Implicit input of array U and integers V=x & W=y
sV         :Slice U from 0-based index V to index
  Wn       :  Subtract W from
    UÊ     :  Length of U

Kotlin, 30 bytes
{a,s,e->a.drop(s).dropLast(e)}

Try it online!
Takes List<Int> as input and drops from begin and then from end.

I have not access to try it online. Can you add a caller code? how  compile lambda without type definitions in Kotlin? Thanks.

@mazzy it could probably be a hack, but you can specify types in variable type definition as val f: (List<Int>, Int, Int) -> List<Int>

Got it! Nice. I don't know if this is valid in CodeGolf.

Brachylog, 11 10 bytes
kb₍B&t;Bk₍

Try it online!
Takes input as [x, A, y] where A is the array to trim.
(-1 byte thanks to @Fatalize.)

You can shorten it by 1 byte as such: kb₍B&t;Bk₍. , does append (see the result of this partial program), it doesn't act like ∧. Also do not try to copy things from old (2016-early 2017) Brachylog answers because it was the first version of the language, and programs are not retrocompatible (in particular, , in Brachylog v1 is now ∧ in Brachylog v2)

@Fatalize Thanks, updated. So , did append in the previous version, but it just didn't matter in this case because there was a t after it anyway - lucky coincidence. And yeah, I realized the version differences after I posted this, I was still figuring things out and bumbling around at this stage. :)

05AB1E, 6 bytes
F¦}sF¨

Try it online!
F }    # For 0 .. number of elements to remove from front
 ¦     #   Remove the first element
   s   # Get the next input
    F  # For 0 .. number of elements to remove from back
     ¨ #   Remove the last element

Pyth, 5 bytes
>E<QE

Try it here
Takes the arguments in the opposite order. < and > in Pyth trim based on argument order. For example, <Q5 will trim off all values in the input after the fifth one.

Java 8, 82 bytes
a->n->m->{int l=a.length-m-n,r[]=new int[l];System.arraycopy(a,n,r,0,l);return r;}

Try it here.
Alternative with same (82) byte-count using a loop:
(a,n,m)->{int l=a.length-m,r[]=new int[l-n],i=0;for(;n<l;r[i++]=a[n++]);return r;}

Try it here.
Explanation:
a->n->m->{                      // Method with integer-array and two integer parameters and integer-array return-type
  int l=a.length-m-n,           //  Length of the array minus the two integers
      r[]=new int[l];           //  Result integer-array
  System.arraycopy(a,n,r,0,l);  //  Java built-in to copy part of an array to another array
  return r;                     //  Return result-String
}                               // End of method

System.arraycopy:

arraycopy(Object src, int srcPos, Object dest, int destPos, int length):
The java.lang.System.arraycopy() method copies an array from the specified source array, beginning at the specified position, to the specified position of the destination array. A subsequence of array components are copied from the source array referenced by src to the destination array referenced by dest. The number of components copied is equal to the length argument.
The components at positions srcPos through srcPos + length - 1 in the source array are copied into positions destPos through destPos + length - 1, respectively, of the destination array.

Can you save bytes by not using currying?

@TheLethalCoder No, in this case not. (a,n,m)-> has the same byte-count as a->n->m->. Although you're right I could have just used a regular call instead of currying. I'm kinda used of using currying when I have two (or more) parameters.. I've already made the mistake of using currying when I have four parameters a few times..

Ahh you're right I miscounted the bytes and I've done that as well currying is definitely a go to now!

No TIO link? --

@totallyhuman It did contain a TIO link for the first solution, but I've added a TIO-link for the alternative solution as well now.

Sorry, can't let that pass. I posted my own answer because... there's a built-in (ok, not exactly, but nearly)! :o

@OlivierGrégoire Nice, that's a lot shorter!

CJam, 8 bytes
{_,@-<>}

Anonymous block that takes the inputs from the stack in the order x, y, array, and replaces them by the output array.
Try it online!
Explanation
Consider inputs 2, 1, [10 20 30 40 50 60].
{      }    e# Block
            e# STACK: 2, 1, [10 20 30 40 50 60]
 _          e# Duplicate
            e# STACK: 2, 1, [10 20 30 40 50 60], [10 20 30 40 50 60]
  ,         e# Length
            e# STACK: 2, 1, [10 20 30 40 50 60], 6
   @        e# Rotate
            e# STACK: 2, [10 20 30 40 50 60], 6, 1
    -       e# Subtract
            e# STACK: 2, [10 20 30 40 50 60], 5
     <      e# Slice before
            e# STACK: 2, [10 20 30 40 50]
      >     e# Slice after
            e# STACK: [30 40 50]

Good point, then just for fun, here is an alternative 8-byte solution :) https://tio.run/##S85KzP1vxGXIFW1ooGBkoGBsoGBioGBqoGBmEPu/Olg7ps7GrvZ/XcF/AA

tcl, 19
lrange $L $x end-$y

where L is the array.
demo

q/kdb, 12 bytes
Solution:
{(0-z)_y _x}

Example:
q){(0-z)_y _x}[1 2 3 4 5 6;2;1]
3 4 5
q){(0-z)_y _x}[6 2 4 3 5 1 3;5;0]
1 3
q){(0-z)_y _x}[1 2;0;0]
1 2

Explanation:
{          } / lambda function
          x  / input array
       y _   / drop y elements from .. (takes from start)
 (0-z)       / negative z ()
      _      / drop -z elements from ... (takes from end)

Racket, 33 bytes
(λ(a i j)(drop-right(drop a i)j))

It can be called like so:
((λ(a i j)(drop-right(drop a i)j)) '(1 2 3 4 5 6) 2 1)

Can I have a link to the language's website?

@Okx https://racket-lang.org/

Pyth, 4 bytes
<E>E

Demonstration
Put the list last.

Kona/K4, 12 bytes
{x _(-y)_ z}

Usage:
   {x _(-y)_ z}[2;1;"hello world"]
"llo worl"

C (gcc), 16 bytes

The compiler instruction:
-DX(a,x,y)=(a+x)
As most would know, an array in C is just a known length and a pointer to the beginning of an array. Thus, we get an array with x members removed from the left and y members removed from the right by just moving the pointer to the array by +x.
Try it online!

Jelly, 5 bytes
‘ṫṚ¥ƒ

Try it online!
Takes [x, y] on the left and the list on the right. Ties the existing Jelly answer, but I'm posting it anyways because:

it doesn't use full-program I/O
it feels like it should be four bytes

‘        Increment x and y.
    ƒ    With the list as the initial value of the accumulator, reduce [x, y] by:
 ṫ       remove the first (right - 1) elements from the accumulator,
  Ṛ¥     then reverse it.

Jellyfish, 19 bytes
p
vvj
 -0
 j
 0
j
0

Try it online!
Takes input as
y
array
x

via STDIN.
This program translates to:
p    (v   (j         (0),v   (-    (0,j         (0)),j         (0)))
print(drop(eval_input(0),drop(minus(0,eval_input(0)),eval_input(0)))

Julia, 18 bytes
a*b*c=a[1+b:end-c]

Try it online!

Excel, 32 bytes
=OFFSET(A1,B1,,COUNT(A:A)-B1-C1)

Link the Spreadsheet
The array is entered in column A starting at A1.

Vyxal, 3 bytes
N"i

Try it Online!

Go, 49 bytes, ints only
func f(t[]int,x,y int)[]int{return t[x:len(t)-y]}

Attempt This Online!
Go, 52 bytes, generic
func f[T any](t[]T,x,y int)[]T{return t[x:len(t)-y]}

Attempt This Online!

Thunno, \$5\log_{256}(96)\approx\$ 4.12 bytes
ZxsZy

Attempt This Online!
Takes x then the array then y
Explanation
Zx     # Remove the first x elements from the array
  s    # Swap so y is now on the top of the stack
   Zy  # Remove the last y elements from the array
       # Implicit output

Why is there no slice builtin -.-

@Jacob I forgot to add that... :(

Elm, 44 bytes
h x=List.reverse<<List.drop x
f x y=h y<<h x

Try it on Ellie

Japt, 8 7 bytes
sVUl -W

Try it online!
Saved a byte thanks to ETHproductions

Hmm, do you need the comma?

@ETHproductions A bit late, but the comma isn't needed; I keep forgetting that trick. Thanks!

6 bytes

V, 9 8 bytes
ÀñdñGÀñd

Try it online!
One byte saved thanks to Erik the golfer!

You don't need last ñ.

The first four bytes can become Àd.

@kritixilithos Unfortunately, that doesn't work for two reasons. 1) d by itself doesn't work. You'd need dd and 2) That doesn't work if the first input is 0.

Clojure, 28 bytes
#(subvec % %2(-(count %)%3))

Well there is the built-in.

Clojure, 26 bytes
#(drop %2(drop-last %3 %))

NewStack, 5 bytes
ᵢqᵢpᵢ

The symmetry is an amazing coincidence
The breakdown:
ᵢ      Append an input (the array).
 qᵢ    Pop off an input's amount off the bottom.
   pᵢ  Pop off an input's amount off the top.

F#, 39 bytes
let f(i:int[])s e=i.[s..(i.Length-1-e)]

Try it online!

Braingolf, 22 21 bytes
1-<1-[v$_R][v<$_R]v=;

Try it online!

LOGO, 33 bytes
[cascade ?2 "bf cascade ?3 "bl ?]

Try it on FMSLogo.
This is a template-list in LOGO, which is the equivalent of lambda (anonymous) function in many other languages.
Where:

cascade outputs the result of applying a template repeatedly, in this case is ?2 times bf and ?3 times bl.
bf and bl stands for ButFirst and ButLast respectively.
? is used to access parameters. So ?2 is the second parameter, ?3 is the third parameter, etc.

Test:
show apply [cascade ?2 "bf cascade ?3 "bl ?] [[1 2 3 4 5 6] 2 1]

print [3 4 5].

Perl 6, 18 bytes
{@^a[$^x..^*-$^y]}

@^a is the input array (first parameter), $^x is the number of elements to remove from the front (second parameter), and $^y is the number of elements to remove from the end (third parameter).
$^x ..^ *-$^y is a slicing subscript that selects a range of elements from the one with index $^x until one prior to the one with index *-$^y (* meaning "the length of the array" in a subscript context).

C++, 81 bytes
#include<vector>
int f(std::vector<int>&v,int x,int y){v={v.begin()+x,v.end()-y};}

Not as short as this use of a macro.
std::vector provides random access, and we simply create a new vector from the start point v.begin() + x, to the new end point v.end() - y elements.
Uses the iterator overload v.begin() and v.end() since it's the same length as the pointer one &v[0] and &*(v.end()), but more readable.
Function doesn't return an int like it promises, which is only a compiler warning.

8th, 33 bytes
Code
This code leaves resulting array on TOS
( a:rev swap -1 a:slice ) 2 times

Usage
ok> 2 1 [1,2,3,4,5] ( a:rev swap -1 a:slice ) 2 times .
[3,4]
ok> 5 0 [6,2,4,3,5,1,3] ( a:rev swap -1 a:slice ) 2 times .
[1,3]
ok>
ok> 0 0 [1,2] ( a:rev swap -1 a:slice ) 2 times .
[1,2]
ok>

Common Lisp, 41 bytes
(lambda(a x y)(subseq a x(-(length a)y)))

Try it online!

J, 17 bytes
(-@{:@[}.{.@[}.])

Usage:
   2 1 (-@{:@[}.{.@[}.]) 11 12 13 14 15 16
13 14 15

Lua, 94 bytes
n,s=loadstring('return{},'..p[1])()for x=1,#s do n[#n+1]=x>0+p[2]and#s>=x+p[3]and s[x]or _ end

Try it online!
If I used something that I couldn't please tell me.
Explanation
p = {...} -- (Header) It gets the 3 arguments (the list and the 2 numbers and stores in a table)

n,s=loadstring('return{},'..p[1])() -- is the same as (i) and (ii):
 (i) n = {} -- initializes an empty table
(ii) s = loadstring('return '..p[1])() -- makes the string '{1,2,3}' become a table with 3 elements (1, 2 and 3)

for x=1,#s do -- from 1 to the number of elements in s, repeat:
  n[#n+1] = x>0+p[2] and #s>=x+p[3] and s[x] or _
  n[#n+1]   -- append to n
              0+p[2]   -- convert "2" to the number 2
            x>0+p[2] and #s>=x+p[3]   -- if we're past the start limit and before the end limit
                                    and s[x]   -- then the element to be appended is the one with index x of the original list
                                             or _   -- else append nil (the same as doing nothing)
end

print(table.concat(n, ", ")) -- (Footer) print the elements of n separated by commas

I used _ as nil just to be a little bit more clear (although this is not the point of these answers hahah). I could've used any variable that wasn't previously declared. _ doesn't have anything special in Lua.
And the comparisons are really messy because I tried to organize the math in a way that special characters would help me to use less space. ... and a>#b uses 1 more byte than ... and#b>a.
If you have any questions ask and I'll try to answer them.

Recursiva, 7 bytes
Zba-Lac

Try it online!

C++, 50 bytes
[](auto&v,int x,int y){v={v.begin()+x,v.end()-y};}

Just construct a new container from the existing one.  This requires v to be of a type with random-access iterators and constructible from an iterator pair - std::vector is ideally suited.
Demo
auto const trim =
    [](auto&v,int x,int y){v={v.begin()+x,v.end()-y};}
    ;

#include<iostream>
#include<vector>
int main(int argc, char **argv)
{
    if (argc < 4) {
        std::cerr << "Usage: " << argv[0] << " X Y ELE...";
        return 1;
    }

    auto const x = std::atoi(argv[1]);
    auto const y = std::atoi(argv[2]);
    std::vector<int> v;
    v.reserve(argc - 3);
    for (int i = 3;  i < argc;  ++i)
        v.push_back(std::atoi(argv[i]));

    auto const print_vector = [](auto v){for(auto i:v)std::cout<<i<<" ";std::cout<<'\n';};

    print_vector(v);
    trim(v, x, y);
    print_vector(v);
}

Scala, 52 bytes
def f(a:Seq[Int],c:Int,d:Int)=a.dropRight(d).drop(c)

Try it online!

Factor, 19 bytes
[ head* swap tail ]

Try it online!
Takes input as x sequence y.

Arturo, 31 bytes
$[a,x,y][slice a x(size a)-y+1]

Try it

Zsh, 21 bytes
<<<${@:2+$1:-1-$@[#]}

Try it online!
Input format: x <array> y

Thunno 2, 2 bytes
ỵẓ

Attempt This Online!
Input in the order \$a, l, b\$, where \$a\$ is the number of items to remove from the front, \$b\$ is the number of items to remove from the back, and \$l\$ is the list.
Explanation
ỵẓ  # Implicit input
ỵ   # Remove from front
 ẓ  # Remove from back
    # Implicit output