text:
PPCG Jeopardy: Robbers
How well do you know the site?  Let's find out.
This is a cops-and-robbers challenge.  Cop's thread.
As a robber, you need to:

Find a non-deleted, non-closed challenge that matches a cop's submission.  The challenge cannot have the following tags: cops-and-robbers, popularity-contest, code-trolling, underhanded, busy-beaver, king-of-the-hill, tips, answer-chaining.  The challenge must have restrictions on valid output.
Post the challenge here, and link to the cop you are cracking
Add a "Cracked" comment to the cops' post, with a link back to this answer

You will receive 1 point, plus 1 point for each 24-hour period the submission had remained uncracked (max 7).  Tiebreaker is the total number of cracked submisisons.
Notes:

If a challenge requires an output of X, and you output XY or YX where Y is anything besides whitespace, the submission is not valid for that challenge.
A challenge newer than 2016-11-17 is not allowed.
I reserve the right to ban certain challenges if they are widely applicable (could be applied to the majority of all submissions).
Make sure you add a sentence or two as an explanation (it also helps your submission from being converted to a comment)
Thanks to Daniel for the initial idea!

Related meta post

#Gabriel Benamy http://codegolf.stackexchange.com/questions/28190/convenient-palindrome-checker

Calculate probability of getting half as many heads as coin tosses.
Cops entry (posted by Conor O'Brien): https://codegolf.stackexchange.com/a/100521/8927
Original question: Calculate probability of getting half as many heads as coin tosses.

The posted solution had a couple of obfuscation techniques applied, followed by multiple layers of the same obfuscation technique. Once past the first few tricks, it became a simple (if tedious!) task to extract the actual function:
nCr(a,b) = a! / ((a-b)! * b!)
result = nCr(x, x/2) / 2^x

Took a while to realise what I was looking at (for a while I suspected something to do with entropy), but once it twigged, I managed to find the question easily by searching for "probability of coin toss".

Since Conor O'Brien challenged an in-depth explanation of his code, here's a rundown of the more interesting bits:
It starts by obfuscating some built-in function calls. This is achieved by base-32 encoding the function names, then assigning them to new global-namespace names of a single character. Only 'atob' is actually used; the other 2 are just red-herrings (eval takes the same shorthand as atob, only to be overridden, and btoa simply isn't used).
_=this;
[
    490837, // eval -> U="undefined"       -> u(x) = eval(x) (but overwritten below), y = eval
    358155, // atob -> U="function (M,..." -> u(x) = atob(x)
    390922  // btoa -> U="function (M,..." -> n(x) = btoa(x), U[10] = 'M'
].map(
    y=function(M,i){
        return _[(U=y+"")[i]] = _[M.toString(2<<2<<2)]
    }
);

Next there are a couple of trivial string mix-ups to hide the code. These are easily reversed:
u(["","GQ9ZygiYTwyPzE6YSpk","C0tYSki","SkoYSkvZChhLWIpL2QoYikg"].join("K"))
// becomes
'(d=g("a<2?1:a*d(--a)"))(a)/d(a-b)/d(b) '

u("KScpKWIsYShFLCliLGEoQyhEJyhnLGM9RSxiPUQsYT1D").split("").reverse().join("")
// becomes
"C=a,D=b,E=c,g('D(C(a,b),E(a,b))')"

The bulk of the obfuscation is the use of the g function, which simply defines new functions. This is applied recursively, with functions returning new functions, or requiring functions as parameters, but eventually simplifies right down. The most interesting function to come out of this is:
function e(a,b){ // a! / ((a-b)! * b!) = nCr
    d=function(a){return a<2?1:a*d(--a)} // Factorial
    return d(a)/d(a-b)/d(b)
}

There's also a final trick with this line:
U[10]+[![]+[]][+[]][++[+[]][+[]]]+[!+[]+[]][+[]][+[]]+17..toString(2<<2<<2)
// U = "function (M,i"..., so U[10] = 'M'. The rest just evaluates to "ath", so this just reads "Math"

Although since the next bit is ".pow(T,a)", it was always pretty likely that it would have to be "Math"!
The steps I took along the route of expanding functions were:
// Minimal substitutions:
function g(s){return Function("a","b","c","return "+s)};
function e(a,b,c){return (d=g("a<2?1:a*d(--a)"))(a)/d(a-b)/d(b)}
function h(a,b,c){return A=a,B=b,g('A(a,B(a))')}
function j(a,b,c){return a/b}
function L(a,b,c){return Z=a,Y=b,g('Z(a,Y)')}
k=L(j,T=2);
function F(a,b,c){return C=a,D=b,E=c,g('D(C(a,b),E(a,b))')}
RESULT=F(
    h(e,k),
    j,
    function(a,b,c){return _['Math'].pow(T,a)}
);

// First pass
function e(a,b){
    d=function(a){return a<2?1:a*d(--a)}
    return d(a)/d(a-b)/d(b)
}
function h(a,b){
    A=a
    B=b
    return function(a){
        return A(a,B(a))
    }
}
function j(a,b){ // ratio function
    return a/b
}
function L(a,b){ // binding function (binds param b)
    Z=a
    Y=b
    return function(a){
        return Z(a,Y)
    }
}
T=2; // Number of states the coin can take
k=L(j,T); // function to calculate number of heads required for fairness
function F(a,b,c){
    C=a
    D=b
    E=c
    return function(a,b,c){return D(C(a,b),E(a,b))}
}
RESULT=F(
    h(e,k),
    j,
    function(a){return Math.pow(T,a)}
);

// Second pass
function e(a,b){...}
function k(a){
    return a/2
}
function F(a,b,c){
    C=a
    D=b
    E=c
    return function(a,b,c){return D(C(a,b),E(a,b))}
}
RESULT=F(
    function(a){
        return e(a,k(a))
    },
    function(a,b){
        return a/b
    },
    function(a){return Math.pow(2,a)}
);

// Third pass
function e(a,b) {...}
C=function(a){ // nCr(x,x/2) function
    return e(a,a/2)
}
D=function(a,b){ // ratio function
    return a/b
}
E=function(a){return Math.pow(2,a)} // 2^x function
RESULT=function(a,b,c){
    return D(C(a,b),E(a,b))
}

The structure of the function nesting is based around utility; the outer-most "D" / "j" function calculates a ratio, then the inner "C" / "h" and "E" (inline) functions calculate the necessary coin flip counts. The "F" function, removed in the third pass, is responsible for connecting these together into a usable whole. Similarly the "k" function is responsible for choosing the number of heads which need to be observed; a task which it delegates to the ratio function "D"/"j" via the parameter binding function "L"; used here to fix parameter b to T (here always 2, being the number of states the coin can take).
In the end, we get:
function e(a,b){ // a! / ((a-b)! * b!)
    d=function(a){return a<2?1:a*d(--a)} // Factorial
    return d(a)/d(a-b)/d(b)
}
RESULT=function(a){
    return e(a, a/2) / Math.pow(2,a)
}

Good job! This is slightly incorrect--eval is set to f. But the rest is correct! Also, a bit of elaboration as to how RESULT is derived might be worthy ;)

@ConorO'Brien sure; I added my notes and an explanation of the utility of each function before collapsing them all.

@ConorO'Brien thanks for the bounty!

Always a pleasure :)

MATL, Luis Mendo, Count number of hefty decimals between 2 numbers
&:"@FYAYm7>vs

I figured out what it does by playing with the inputs, but I couldn't figure out for what challenge you'd have to calculate the number of integers in a range whose sum was greater than 7 times the number of digits. After reading the MATL docs, I put together an rough explanation of what this does:
&    % Change default input format
:    % Implictly input two integers, create inclusive range
"    % For each item in this range:
  @    % Push the item
  F    % Push false
  YA   % Convert to base N digits; N is false, so this produces base-10 digits
  Ym   % Calculate arithmetic mean
  7>   % Push 1 if this is greater than 7, 0 otherwise
  v    % Concatenate result into array with previous result
  s    % Sum
     % Implicitly end loop and output

I then switched from searching "digit sum greater than 7 times length" to "average digit greater than 7", which yielded the challenge I was looking for.

아희(Aheui), JHM, Shortest infinite loop producing no output
Tried it online, code just keeps running and there's no output.

Reverse a 1-dimensional array
I think this is it, its hows up as the first answer for it.
https://codegolf.stackexchange.com/a/100368/31343

C#, Yodle, Given an input, move it along the keyboard by N characters
Input a string and int and changes each char of the string to the char that's N keys away on the keyboard (wrapping around).

Perl, Gabriel Benamy, Convenient palindrome checker
The code was obviously some kind of palindrome. Once I picked out the y- - - structure and noticed what was being transliterated, I knew what challenge it was.

You beat my by a few seconds ... but it took so long to download perl.

@Laikoni Honestly, after a couple tries on Ideone, I gave up on running the code and tried reading it instead. ;)

Pyth - https://codegolf.stackexchange.com/a/100391/31343
I quickly found out what the program did, but finding the challenge took pretty long.
Different Way Forward
this is my buffer.

05AB1E, 27 bytes, Adnan
Evaluating the score based from a chess FEN string
I decompressed the string and searched, and came up with this challenge.

MATL, Luis Mendo, Calculate hamming weight with low hamming weight
dP7EGn:q^1J2/h)ts_hX=Gs[BE]Wd=~>~GBz*

I tested putting in numbers, and found the hamming weight thing on OEIS.
Then I searched on PPCG, tried putting in strings and it worked.

As I commented in the cops challenge, this doesn't actually crack my submission. Unfortunately, I guess this answer needs to be deleted

C++, Karl Napf, Substring Sum Set
Online demo showing the first test case from the question.

Ruby, histocrat, Implement a Truth-Machine
The code defines an iterated function system f(n) = n*(3*n-1)/2 that runs until n mod 7 is 0. Input of 0 therefore terminates right away (after printing 0 once). Input of 1 gives 1, leading to an infinite loop of printing 1. Other input terminates after 1-3 steps if the initial n is congruent to 0, 2, 3, 5, or 6 mod 7, or grows forever if it is congruent to 1 or 4 mod 7. But that's irrelevant.

Hexagony, 548 bytes, Martin Ender
This is the "Print every character your program doesn't have" challenge!
Prints:
Elizabeth obnoxiously quoted (just too rowdy for my peace): "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG," giving me a look

Which is very similar to the output in this one. The clue here was that the last . wasn't printed. Also, the code itself had no letters, and we all know that the phrases in the output contains all letters in the alphabet.

Python, 935 Bytes, Mega Man, What is the smallest positive base 10 integer that can be printed by a program shorter (in characters) than itself?
I didn't actually try it. But I guess it prints a number longer than the program.

It prints 99**9999, which is just a tad larger.

Python 3, https://codegolf.stackexchange.com/a/100381/31343
Use xkcd's formula to approximate the world population
I just searched for challenges that involved leap years (because of the decoded divisibility by four checker) and that took no input.

Yep! I knew it would be obvious because of the %4 and the strftime, but good job for spotting the important parts of the code (most of it was gibberish)

Ah dangit, I was getting close, too.  I had figured out it was something to do with dates, was getting 2005 and 2016/2017.  Nice job.

I'm surprised that neither of you simply ran the code, which generates the output 7.3 328, and searched that. The challenge comes up straight away.

Brainfuck, FinW, Print the ASCII table
That was easy, since he posted his answer on that challenge.
Link to his answer

Mathematica, JHM, Natural construction
The unary operator ± computes a set-theory based representation of the natural numbers.

Ruby, wat, 400th Question Celebration/Challenge
That was the first thing I found when searching for "400". That said, the challenge seems to be mistagged and should be a popcon and should probably also be closed for not having objective requirements.


text:
Draw the Sierpinski Arrowhead Curve
Introduction
The Sierpinski Arrowhead Curve is a curve that's limit is Sierpinski's Triangle.
It first starts like this:
 _
/ \

Then, each line is replaced with a rotated version of the first one:
  _
 / \
 \ /
_/ \_

Next:
     _
    / \
    \ /
   _/ \_
  /     \
  \_   _/
 _  \ /  _
/ \_/ \_/ \

Your task
Given a number n, output the n-th iteration of the Sierpinski Arrowhead Curve.
You may choose 0 or 1-indexed input, but please specify that in your answer.
You may generate an image, or use Ascii Art in the format I have given above.
You may not use built-ins to generate this curve.
Remember, this is code-golf, so the code with the fewest bytes wins.

Octave, 240 236 221 bytes
This is made with the same idea used here but I had to change it to fit the sierpinsky arrowhead curve.
m=input(0);g=2*pi/6;u=cos(g);v=sin(g);A=[1,0];B=[u,v];C=[-u,v];D=-A;E=-B;F=-C;for k=1:m;f=[E;F;A];b=[A;B;C];A=[B;A;F];d=[C;D;E];C=[D;C;B];E=[F;E;D];B=b;D=d;F=f;end;A=[0,0;cumsum(A)];plot(A(:,1),A(:,2));axis off;axis equal

u=.5;v=3^u/2;B=[u,v];C=[-u,v];A=C<0; is 16 bytes shorter :) You can also do axis off equal to save another 5 bytes.

Haskell + diagrams, 176 bytes
import Diagrams.Prelude
import Diagrams.Backend.SVG
g n=renderSVG"a"(mkWidth 99).strokeT.a n
a 0=hrule 1
a n|b<-a(n-1)=b%6<>b<>b%(-6);a%n=rotateBy(1/n).reflectY$a::Trail V2 Double

Makes a svg file with transparent background called "a".
g 0 outputs a horizontal line, g 1 is /¯\.

Great, I didn't know about Diagrams!

@flawr, it's great but the usual Haskell graphical program caveats apply. It would be great to just call the equivalent of of plot()  to open a window.

MSWLogo (Version 6.5b), 102 bytes
Takes the two functions shapeL, shapeR given here and merges them by adding an extra argument :a, which calls the opposite function when negated.
to s :n :a :l
if :n=0[fd :l stop]
rt :a
s :n-1(-:a):l
lt :a
s :n-1 :a :l
lt :a
s :n-1(-:a):l
rt :a
end

A function s is defined, which takes number of iterations :n (1-based), angle :a, length :l. It is recursive, calling a lower iteration of itself with the angle :a negated in two instances to get the orientation correct.

rt :a, lt :a rotate the turtle (triangle thingy whose path is traced) right, left by :a degrees.
fd :l moves the turtle forward by :l steps.

The function is to be called with :a equal to 60.

Here, repeat is essentially a FOR loop, with built-in counter repcount. pu and pd mean "pen up" and "pen down", which stop the turtle from drawing while its position is being set using setxy.
The drawings of each iteration have been called with length :l equal to power 2 (7-repcount), which decreases exponentially; this is because the definition uses the same :l in the recursive step, so with fixed :l the overall size of the output will increase exponentially with :n.

This is the right language for the job, but technically answers aren't allowed extra data, so ideally you would encode the 60 in your answer.

@Neil So I just include 60 in the byte count?

I'm not sure that it's that simple, but I don't know the language myself.

Python 2, 124 bytes
Based off of the code in the Wikipedia article.
from turtle import*
def c(o,a):
 if o:o-=1;c(o,-a);lt(a);c(o,a);lt(a);c(o,-a)
 else:fd(9)
n=input()
if n%2==0:lt(60)
c(n,60)

Order 0 is a straight line.

You have to change your code to use an angle of 60 degrees, otherwise it will not approximate the Sierpinsky triangle. Also, the orientation changes depending on the order, which I don't think is correct. https://trinket.io/python/a803546939

The logo answer also gives a function that takes the angle as a parameter, so I think that it is OK. As far as the orientation goes, it is still the same curve, just rotated.

The logo answer is always the same rotation, though. Yours is a different rotation for each order, and they are not all the same. This is not okay. Look at the pictures the question contains.

Where does the challenge say that the rotations have to be the same?

The rules say this: Given a number n, output the n-th iteration of the Sierpinski Arrowhead Curve. ✓ You may choose to 0- or 1-index, but please specify in your answer. ✓ You may generate an image, or use Ascii Art in the format I have above. ✓ (I'm generating an image). You may not use built-ins to generate this curve. ✓ My entry breaks none of the rules, so it is valid.

Also, if you say that the graphics output has to be the same as the pictures in the challenge, then the logo entry is disqualified too. It doesn't have the same rotation as the pictures.

It says "[the] limit is Sierpinski's Triangle". Your output doesn't follow that.

Yes, it does. The triangle is just upside down for even n. That is just as valid as having it be sideways.

Any math major can tell you that a limit must converge. Yours does not.

I'm temporarily removing this post in compliance with our policy about answers not meeting the challenge specification. Please feel free to edit your answer and to flag it for moderator attention so it can be undeleted.

Mathematica / Wolfram Language 73 bytes
s=1;Region@Line@AnglePath[Nest[Join@@({#,s=-s,s}&/@#)&,{#~Mod~2},#]Pi/3]&

Simple explanation：
AnglePath[{θ1,θ2,θ3,…}] gives the list of 2D coordinates corresponding to a path that starts at {0,0}, then takes a series of steps of unit length at successive relative angles θi.
n=1
Graphics@Line@AnglePath[60°{1,-1,-1}]

n=2
Graphics@Line@AnglePath[60°{0,1,1, -1,-1,-1, -1,1,1}]

n=3
Graphics@Line@AnglePath[60°{1,-1,-1, 1,1,1, 1,-1,-1, -1,1,1, -1,-1,-1, -1,1,1, -1,-1,-1, 1,1,1, 1,-1,-1}]

Mathematica, 62 bytes
Graphics@Line@AnglePath[Pi/3Nest[Flatten@{-#,1,#,1,-#}&,0,#]]&

How does that work?

JavaScript (ES6), 180 bytes

f=(n,d=0,r=n=>` `.repeat(n))=>n?f(--n,d=3-d%3).map(s=>r([l=s.length/2,0,1,~n&1][d]+l)+s+r([,1,0,~n&1][d]+l)).concat(f(n,d+1).map(s=>s+r(!(d%3))+a.shift(),a=f(n,d+2))):[`_/\\`[d%3]]
<input type=number min=1 oninput=o.textContent=f(this.value).join`\n`><pre id=o>

Returns an array of strings. Getting the spacing right was the hardest part! Pure string version for 205 bytes:
f=(n,d=0,r=n=>` `.repeat(n))=>n?f(--n,d=3-d%3).replace(/.+/g,s=>r([l=s.length/2,0,1,~n&1][d]+l)+s+r([,1,0,~n&1][d]+l))+`\n`+f(n,d+1).replace(/.+/g,s=>s+r(!(d%3))+a.shift(),a=f(n,d+2).split`\n`):`_/\\`[d%3]

source: Stack Exchange

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

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

sort: votes


text:
Animate finding the middle
Given a non-empty string, keep removing the first and last characters until you get to one or two characters.
For example, if the string was abcde, your program should print:
abcde
 bcd
  c

However, if it was abcdef, it should stop at two characters:
abcdef
 bcde
  cd

Trailing newlines and trailing spaces at the end of each line are optional. You can have as many as you want or none.
Test cases
ABCDEFGHIJKLMNOPQRSTUVWXYZ -> ABCDEFGHIJKLMNOPQRSTUVWXYZ
                               BCDEFGHIJKLMNOPQRSTUVWXY
                                CDEFGHIJKLMNOPQRSTUVWX
                                 DEFGHIJKLMNOPQRSTUVW
                                  EFGHIJKLMNOPQRSTUV
                                   FGHIJKLMNOPQRSTU
                                    GHIJKLMNOPQRST
                                     HIJKLMNOPQRS
                                      IJKLMNOPQR
                                       JKLMNOPQ
                                        KLMNOP
                                         LMNO
                                          MN

ABCDEFGHIJKLMNOPQRSTUVWXYZ! -> ABCDEFGHIJKLMNOPQRSTUVWXYZ!
                                BCDEFGHIJKLMNOPQRSTUVWXYZ
                                 CDEFGHIJKLMNOPQRSTUVWXY
                                  DEFGHIJKLMNOPQRSTUVWX
                                   EFGHIJKLMNOPQRSTUVW
                                    FGHIJKLMNOPQRSTUV
                                     GHIJKLMNOPQRSTU
                                      HIJKLMNOPQRST
                                       IJKLMNOPQRS
                                        JKLMNOPQR
                                         KLMNOPQ
                                          LMNOP
                                           MNO
                                            N

A -> A

AB -> AB

Remember this is code-golf, so the code with the smallest number of bytes wins.

Can the output be a list of strings, instead of printing the strings?

@GregMartin Yes.

Do we need to have the leading spaces on each line?

@ETHproductions Yes.

Will the input ever contain spaces?

@DrMcMoylex No.

@Oliver That's important information, you should include it in the text

Can we show an actual animation instead of printing multiple lines? Or would that have to be a bonus version in an answer that does what the spec currently asks for?

Will the input contain anything other than letters, numbers, and underscores (i.e. "word" characters)?

V, 10 bytes
ò^llYpr $x

Try it online!
Explanation:
ò^ll         " While there are at least two non-whitespace characters on the current line
    Y        " Yank this line
     p       " Paste it below
      r      " Replace the first character with a space
        $    " Move to the end of the line
         x   " Delete a character

ES6 (Javascript), 47, 48, 43 bytes
EDIT: Replaced ternary operator with &&,  prefixed padding string with the newline. Thanks @Neil for an excellent advice  !
EDIT: included the function name for the recursive invocation, stripped one byte off by using a literal newline
Golfed
R=(s,p=`
 `)=>s&&s+p+R(s.slice(1,-1),p+' ')

Test
R=(s,p=`
 `)=>s&&s+p+R(s.slice(1,-1),p+' ')

console.log(R("ABCDEFGHIJKLMNOPQRSTUVWXYZ"))

ABCDEFGHIJKLMNOPQRSTUVWXYZ
 BCDEFGHIJKLMNOPQRSTUVWXY
  CDEFGHIJKLMNOPQRSTUVWX
   DEFGHIJKLMNOPQRSTUVW
    EFGHIJKLMNOPQRSTUV
     FGHIJKLMNOPQRSTU
      GHIJKLMNOPQRST
       HIJKLMNOPQRS
        IJKLMNOPQR
         JKLMNOPQ
          KLMNOP
           LMNO
            MN

console.log(R("ABCDEFGHIJKLMNOPQRSTUVWXYZ!"))

ABCDEFGHIJKLMNOPQRSTUVWXYZ!
 BCDEFGHIJKLMNOPQRSTUVWXYZ
  CDEFGHIJKLMNOPQRSTUVWXY
   DEFGHIJKLMNOPQRSTUVWX
    EFGHIJKLMNOPQRSTUVW
     FGHIJKLMNOPQRSTUV
      GHIJKLMNOPQRSTU
       HIJKLMNOPQRST
        IJKLMNOPQRS
         JKLMNOPQR
          KLMNOPQ
           LMNOP
            MNO
             N

I notice that @xnor starts with p equal to a newline and a space; maybe that could help you too.

Oh, and you can also use s&& instead of s?...:''.

Python, 45 bytes
f=lambda s,p='\n ':s and s+p+f(s[1:-1],p+' ')

Recursively outputs the string, plus a newline, plus the leading spaces for the next line, plus the recursive result for the shortened string with an extra space in the prefix.
If a leading newline was allowed, we could save a byte:
f=lambda s,p='\n':s and p+s+f(s[1:-1],p+' ')

Compare with a program (49 bytes in Python 2):
s=input();p=''
while s:print p+s;s=s[1:-1];p+=' '

Brainfuck, 67 bytes
>>,[.>,]<[>++++++++++.<[-]<[<]>[-]++++++++[-<++++>]<[<]>[.>]>[.>]<]

This should work on all brainfuck flavors.
Try it online!
Ungolfed code:
# Print and read input_string into memory
>>,[.>,]<
while input_string is not empty [
    # Print newline
    >+++++ +++++.<
    # Remove last character
    [-]
    # GOTO start of input_string
    <[<]>
    # Remove first character
    [-]
    # Add space to space_buffer
    +++++ +++[-<++++>]
    # GOTO start of space_buffer
    <[<]>
    # Print space_buffer
    [.>]
    # Print input_string
    >[.>]
<]

There should still be some bytes to chop off here; I've only recently began using brainfuck, so my pointer movement is probably very inefficient.

J, 39 19 16 bytes
[:|:]#"0~#\.<.#\

Try it online!
This was a nice example of how a different perspective can allow J to express a problem more naturally.  Originally, I was seeing the problem "horizontally", as described in the OP -- a sequence  with successive edges being removed:

But you can also view it vertically, as a kind of upside down histogram:

From this perspective, we are just repeating each letter some number of times, an operation J's copy primitive # can accomplish in 1 character.
Consider abcde:

#\.<.#\ Determine the number of times to repeat each character, ie, produce
the mask 1 2 3 2 1:
#\  => 1 2 3 4 5
#\. => 5 4 3 2 1
----------------
<.  => 1 2 3 2 1  NB. elementwise min

]#"0~ Use that mask to duplicate the input:
a
bb
ccc
dd
e

[:|: Transpose:
abcde
 bcd
  c

Python 2, 50 bytes
def f(i,j=0):
 print' '*j+i
 if i:f(i[1:-1],j+1)

Simple recursive function that keeps shortening the string until it disappears.
Call as f('string')
Output
string
 trin
  ri

Perl, 31 bytes
30 bytes of code + -p flag.
s/( *)\S(.+).$/$&
 $1$2/&&redo

To run it :
perl -pE 's/( *)\S(.+).$/$&
 $1$2/&&redo' <<< "abcdef"

Explanations : The \S and .$ correspond to the first and last character, (.+) the middle and ( *) to the trailing spaces that are added every time we remove one character from the beginning. So the regex removes one character from the beginning, one from the end, and add one leading space each time.

GNU sed 24 Bytes
Includes +2 for -rn
:
p
s/[^ ](.+)./ \1/
t

Prints, replaces the first non-space character with a space, and deletes the last character until nothing changes.

This is really nice.

MATL, 9 bytes
tg!*YRPRc

This produces trailing spaces and newlines.
Try it online!
Explanation
t      % Input string implicitly. Duplicate
g!     % Convert to logical and transpose: gives a column vector of ones
*      % Multiply with broadcast. This gives a square matrix with the string's
       % ASCII codes on each row
YR     % Lower triangular part: make elements above the diagonal 0
P      % Flip vertically
R      % Upper triangular part: make elements below the diagonal 0
c      % Convert to char. Implicitly display, with char 0 shown as space

Batch, 92 bytes
@set/ps=
@set t=
:g
@echo %t%%s%
@set t= %t%
@set s=%s:~1,-1%
@if not "%s%"=="" goto g

Takes input on STDIN.

C, 73 bytes
f(char*s){char*b=s,*e=s+strlen(s)-1;while(e-b>-1)puts(s),*b++=32,*e--=0;}

Ungolfed:
f(char*s) {
  char *b=s,
       *e=s+strlen(s)-1;
  while (e-b>-1)
    puts(s),
    *b++=32,
    *e--=0;
}

Usage:
main(){
  char a[] = "abcde";
  f(a);
}

05AB1E, 8 bytes
Code:
ÐvNú,¦¨D

Explanation:
Ð          # Triplicate the input
 v         # Length times do...
  Nú,      # Prepend N spaces and print with a newline
     ¦¨    # Remove the first and the last character
       D   # Duplicate that string

Uses the CP-1252 encoding. Try it online!

Pyke, 10 bytes
VQlRc
l7tO

Try it here!

Haskell, 47 43 bytes
f s@(a:b:c)=s:map(' ':)(f.init$b:c)
f s=[s]

Try it on Ideone. Output is a list of strings which was allowed in the comments of the challenge. To print, run with (putStr.unlines.f) instead of just f.
Edit: Saved 4 bytes after noticing that trailing whitespace is allowed.
Prelude> (putStr.unlines.f)"codegolf"
codegolf
 odegol
  dego
   eg
               --(trailing whitespace)

Perl 6, 42 bytes
for get,{S/\w(.*)./ $0/}.../\s..?$/ {.put}

Expanded:
for

  # generate the sequence
  get,       # get a line from the input

  {          # bare block lambda with implicit parameter ｢$_｣
             # used to produce the rest of the sequence

    S/       # replace
      \w     # a word character ( to be removed )
      (      # set ｢$0｣
        .*   # any number of any characters
      )
      .      # any character ( to be removed )
    / $0/    # append a space

  }

  ...        # repeat that until

  /          # match
    \s       # whitespace
    .        # any character
    .?       # optional any character
    $        # end of string
  /

{
  .put       # print $_ with trailing newline
}

Vyxal C, 4 bytes
‡ḢṪ↔

Try it Online!
i have turned to the dark side
i am now a flag abuser
thanks to lyxal for helping me get to the 4-byte sol (from 8 bytes)
Explanation
   ↔  While results have not reached a fixed point
‡     2-byte function
 Ḣ    a[1:]
  Ṫ   a[:-1]

C     Center the list and join on newlines

The below less cheese program does the same thing. øĊ is the same as the C flag.
Vyxal j, 6 bytes
‡ḢṪ↔øĊ

Try it Online!
Since outputting a list was allowed, using the j flag to join on newlines is reasonable. You can also append ⁋ to use no flags at all.

I'm proud of you for joining the flag side of vyxal. Very good

@lyxal i am suffering

Jelly, 9 bytes
J’⁶ẋoUµ⁺Y

Try it online!
If the input is of length \$2n\$, this outputs with \$n\$ lines of trailing newlines and spaces
How it works
J’⁶ẋoUµ⁺Y - Main link. Takes a string A on the left
      µ⁺  - Do the following twice:
J         -   Yield [1, 2, 3, ..., 2n]
 ’        -   Decrement; [0, 1, 2, ..., 2n-1]
  ⁶ẋ      -   Repeat a space that many times; [[], [' '], [' ', ' '], ...]
     U    -   Reverse A
    o     -   Logical OR
        Y - Join by newlines

The logical OR command o has the following behaviour:
[[], [5], [6, 7], [8, 9, 10]] o [1, 2, 3, 4] = [[1, 2, 3, 4], [5, 2, 3, 4], [6, 7, 3, 4], [8, 9, 10, 4]]

so only the leftmost characters are replaced by spaces. We do this twice, reversing each time, to get both the left and right side

Canvas, 9 bytes
［Ｌ［ｊｋ｝］∔＼

Try it here!

Retina, 17 bytes
;{G:`
\S(.+).
 $1

Try it online!

C++14, 117 bytes
auto f(auto s){decltype(s)r;auto b=s.begin();auto e=s.rbegin();while(e.base()-b>0)r+=s+"\n",*b++=32,*e++=0;return r;}

Assumes input s is a std::string and returns the animated text.
Ungolfed:
auto f(auto s){
  decltype(s)r;
  auto b=s.begin();
  auto e=s.rbegin();
  while(e.base()-b>0){
    r+=s+"\n";
    *b++=32;
    *e++=0;
  }
  return r;
}

Usage:
main(){
  std::string a{"abcdef"};
  std::cout << f(a);
  std::string b{"abcde"};
  std::cout << f(b);
}

PHP, 91 bytes
<?for(;$i<.5*$l=strlen($s=$_GET[s]);$i++)echo str_pad(substr($s,$i,$l-$i*2),$l," ",2)."\n";

Usage: save in a file and call from the browser:
http://localhost/codegolf/string-middle.php?s=ABCDEFGHIJKLMNOPQRSTUVWXYZ

Raw output:
ABCDEFGHIJKLMNOPQRSTUVWXYZ
 BCDEFGHIJKLMNOPQRSTUVWXY
  CDEFGHIJKLMNOPQRSTUVWX
   DEFGHIJKLMNOPQRSTUVW
    EFGHIJKLMNOPQRSTUV
     FGHIJKLMNOPQRSTU
      GHIJKLMNOPQRST
       HIJKLMNOPQRS
        IJKLMNOPQR
         JKLMNOPQ
          KLMNOP
           LMNO
            MN

http://localhost/codegolf/string-middle.php?s=1ABCDEFGHIJKLMNOPQRSTUVWXYZ

Raw output:
1ABCDEFGHIJKLMNOPQRSTUVWXYZ
 ABCDEFGHIJKLMNOPQRSTUVWXY
  BCDEFGHIJKLMNOPQRSTUVWX
   CDEFGHIJKLMNOPQRSTUVW
    DEFGHIJKLMNOPQRSTUV
     EFGHIJKLMNOPQRSTU
      FGHIJKLMNOPQRST
       GHIJKLMNOPQRS
        HIJKLMNOPQR
         IJKLMNOPQ
          JKLMNOP
           KLMNO
            LMN
             M

Mathematica, 71 bytes
Table[#~StringTake~{i,-i},{i,Ceiling[StringLength@#/2]}]~Column~Center&

Vim - 14 keystrokes
qqYp^r $x@qq@q

Explanation:
qq  -- record a macro named 'q'
Y   -- Copy current line
p   -- Paste it
^r  -- Replace the first non-space character on the new line with a space
$x  -- Delete the last character on the line
@q  -- Recursively call the 'q' macro
q   -- Stop recording the 'q' macro
@q  -- Run the 'q' macro

Vim automatically kills the macro once we're out of characters

Snap! - 16 blocks

Output is self-centering. The 'wait' is for humans.

Stax, 7 bytes
ö÷e╧╤ù◘

Run and debug it
Explanation
|]miTiNt
|]m      map each suffix to:
   iT    remove iteration count elements from right
     iNt pad with iteration count number of spaces on left

Stax, 117 bytes
c%{d
   xitiT|c
   {|,}20*|:xi{xitiTx%|CPFxP
   {|,}20*|:xi{xitiTx%|CPFxitiNtP
   {|,}20*|:xi{xitiTx%|CPFxitiTx%|CP
F

Run and debug it, animated
The more fun version. Since stax supports requestAnimationFrame from js, |, and |: can be used to animate each step.

APL (Dyalog Unicode), 25 16 15 bytes
-9 bytes thanks to Jonah's comment!
-1 bytes thanks to Adám!
{⍉↑⍵/¨⍨⌊∘⌽⍨⍳⍴⍵}

Try it online!
This is the dfn taking the string as right input ⍵.
⍳⍴⍵ the indices of the input string.
⌊∘⌽⍨ element-wise minimum of the indices with the indices reversed. This is the number of times each character appears.
⍵/¨⍨ repeat each character that many times.
↑ arranges the repeated characters in a 2d matrix, padding shorter strings with spaces.
⍉ transposes the matrix.
Try it with step-by-step output!

After much pondering, I found another approach that might save you bytes too.  I'll add explanation later, but basically the idea is to duplicate the letters "vertically" down.  Ofc you have to do it horizontally, then transpose.

@Jonah thanks a lot, this definitely saved some bytes. I've changed my code according to your comment, but from what I can tell this is now very similar to your J code.

Sixteen each :)

(⌽⌊⊢) → ⌊∘⌽⍨

Pyth, 11 bytes
.e
:bUkd_._

Test suite
14 bytes to exit without error

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

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


text:
Find the "Recursive Size" of a List
Inspired by Find the “unwrapped size” of a list.
Define the Recursive Size, RS, of a list containing no lists as its length (number of items contained) and the Recursive Size of a list containing any lists as the sum of its length and the Recursive Size of those lists.
Challenge
Write a program or function that outputs the Recursive Size of any given list in as few bytes as possible.
The input is a list and may contain numbers, strings (if your language has them), and similar lists.

For example:
RS([]) = 0

RS([[]]) = 1

RS([4, 5, 6]) = 3
RS(["four", "five", "six"]) = 3
RS(["[[[[]]]]", "[][][][][]", "][][[[]]][]["]) = 3

RS([[4, 5, 6]]) = 4
RS([["four", "five", "six"]]) = 4
RS([["[[[[]]]]", "[][][][][]", "][][[[]]][]["]]) = 4

RS([[4], [5], [6]]) = 6
RS([["four"], ["five"], ["six"]]) = 6
RS([["[[[[]]]]"], ["[][][][][]"], ["][][[[]]][]["]]) = 6

RS([[[[[[[[[]]]]]]]]]) = 8

RS([[],[],[],[],[],[],[],[]]) = 8

RS([[],[],[[]],[[[[]]]]]) = 8

RS([0,[-1],[2.3,-4.3],[5,[6]],[7,[8,9,[10,11,[12,13,14]]]]]) = 22

Note that if your language has no strings but does have lists of characters, the examples containing "strings" above could actually be lists of characters and have larger results. As an example:
RS([['f','o','u','r'], ['f','i','v','e'], ['s','i','x']]) = 14

This is code-golf, so the shortest answer in bytes wins; no funny-business, as always.
A non-list input may produce any output.
I/O is as flexible as usual.

related

Will the elements be strings, numbers, and recursive lists?

Note: Restricted the content of the lists after some discussion. I have edited the question to reflect this. Thanks to @xnor for the input!

I feel like this'd be a better challenge without having to account for strings. It's only add bytes to some languages IMO

@ConorO'Brien or maybe I should have made it up to the answerer if they wished to treat a string as a list or not. Unfortunately I specifically asked the community both "Are there any edge cases I should add?", and "Is any clarification of the definition needed?" and got no response in the sandbox over nine days ...and now I suppose such a question would be a duplicate?

@JonathanAllan I unfortunately don't check the sandbox as much as I would like ;) why should this be a dupe?

@ConorO'Brien maybe it wouldn't - I don't really know!

For future reference: these test cases are in a really clunky format to convert to any language that doesn't use this exact syntax, you should give them in a simpler format

@cat could you explain what you mean? As far as I am aware (except for the containing RS()) it's about as simple as it gets while conveying the necessary information.

About the test case: the string mess of "[" and "]" does not add value. It just make them difficult to evaluate by hand for people (to check our results), while does not pose any problem for programs.

@edc65 Not now, no; there was a perfectly valid point to them originally, before the question was changed (really, the sandbox failed us). I don't think that they are that hard for a human to parse though; note that they are grouped with like cases and have the expected result on the right.

Some languages don't differentiate between strings and arrays/lists of characters.

Jelly, 8 bytes
ß€-ŒḊ?‘S

Try it online!
How it works
ß€-ŒḊ?‘S  Main link. Argument: x

   ŒḊ?    If x has non-zero depth:
ß€          Recursively map the main link over its elements.
  -         Else, yield -1.
      ‘   Increment all integers in the result.
       S  Compute the sum of the result.
          If x is an array, incrementing before adding is equivalent to computing
          the sum of the elements and the length.
          If x is an integer/character, incrementing -1 yields 0, as desired.

Python, 42 bytes
f=lambda x:x*0==[]and len(x)+sum(map(f,x))

For a non-list, output 0. For a list, output its length plus the sum of the recursive outputs for its elements.
Lists fall above numbers and below strings in the Python 2 ordering, requiring []<=x<''. Instead, we check x*0==[], whereas the result of 0 for a number or '' for a string.

JavaScript (ES6), 39 37 bytes
Saved 2 bytes thanks to @edc65
f=a=>a.map&&a.map(x=>a-=~f(x),a=0)&&a

38 bytes: f=a=>a.map?a.reduce((s,x)=>s+f(x),0):0

@Sethi Wouldn't that return 0 for any input? You have to put a 1 in there somewhere.

37: f=a=>a.map&&a.map(x=>a-=~f(x),a=0)&&a. -=~ is 1 char less than +=1+ and, converting a boolean to integer, it cuts another character. Reusing a to avoid the global variable t

@edc65 Thanks, that's great!

Mathematica, 20 bytes
Length@Level[#,∞]&

Anonymous function. Takes an expression as input and returns a number as output. The Unicode character is U+221E INFINITY for \[Infinity]. Level[#,∞] gives a list of the input's subexpressions, and Length@ counts them.

Boom! Slam dunked on my answer. But I learned something new :)

Mathematica, 14 bytes
LeafCount@#-1&

Minor modification of my previous answer. As I explained there, LeafCount already takes care of nested atomic values, but it also counts the outermost list, which we need to subtract from the result.

Perl, 34 bytes
A recursive function! Yep, Perl doesn't only have regex but also have functions!
sub f{@_+f(map ref?@$_:(),@_)if@_}

If you want to test it, you can run something like :
perl -pE 'sub f{@_+f(map ref?@$_:(),@_)if@_}$_=f@{+eval}' <<< '[["four"], ["five"], ["six"]]'

Mathematica, 32 bytes
Length@#+Tr[#0/@#~Select~ListQ]&

Unnamed recursive function. The excerpt #0/@#~Select~ListQ calls the function again on each element of the input that's a list, and Tr sums those values up. Fortunately Mathematica is fine taking the length of the empty list and searching for qualifying elements from the empty list, so no base case is needed.

Factor, 105 bytes
Recursive function g.
: g ( o -- l ) [ dup [ sequence? ] [ string? not ] bi and [ [ g ] map sum 1 + ] [ drop 1 ] if ] map sum ;

Ungolfed (kinda):
: g ( o -- l )
[ dup
  [ sequence? ]
  [ string? not ]
  bi and
  [ [ g ] map sum 1 + ]
  [ drop 1 ]
  if
] map sum ;

You'll find there are no calls to length because instead of using the length builtin, it's implemented through drop 1 on strings and non-sequences.

Haskell, 52 bytes
data L a=E a|N[L a]
r(N n)=1+sum(r<$>n)
r _=1
pred.r

Usage example:
*Main> pred.r $ N[E 0,N[E(-1)],N[E 2.3,E(-4.3)],N[E 5,N[E 6]],N[E 7,N[E 8,E 9,N[E 10,E 11,N[E 12,E 13,E 14]]]]]
22

Haskell doesn't support mixed lists (e.g. Int and list of Int), so I go with a custom list type L which is either an element of some type a (-> E a) or a list of other Ls (-> N[L a]). Calculating the RS is a simple recursion where an E counts 1 and a N one plus the sum of the recursive sizes of its elements. The whole sum is off by 1, so I subtract it via pred.
Side note: the exact types and values of the elements are not important for the algorithm, so we could remove the polymorphism an deal with abstract elements only and go with data L=E|N[L].

Mathematica, 18 bytes
(c=-1;++c&//@#;c)&

Yet another Mathematica approach. Not as short as using the built-in LeafCount but still fairly concise. This makes use of the MapAll operator //@ which calls a function on every node of an expression, and we use that function to increment a counter c. As in the LeafCount case, this gives one more than we need, because it counts the outer list head as well, so we start the counter from -1.

C# (Visual C# Interactive Compiler), 50 bytes
int f(Array a)=>a.Length+a.OfType<Array>().Sum(f);

Try it online!
Uses the same technique as the previously submitted Java answer, but leverages LINQ to reduce the answer length.
Explanation:
// f is a method that a accepts
// an array of any underlying type
int f(Array a)=>
  // include the length of the
  // current array in the total
  a.Length+
  // filter the current list to elements
  // that are also arrays
  a.OfType<Array>()
    // recursively call f on each child
    // array and add to cumulative total
    .Sum(f);

05AB1E (legacy), 22 17 bytes
"ε¼D¸D˜Êi®.V"©.V¾

Try it online or verify all test cases.
Explanation:
This challenge poses multiple challenges to overcome in 05AB1E:

Although 05AB1E does have a recursive function since the Elixir rewrite (λ), it's only useful for integer sequences. Here is an answer of mine as example of the 05AB1E recursive function. Because of that, I had to find an alternative to do recursive calls, which I did by putting part of the code in a string, and execute that string as 05AB1E code recursively.
There also isn't an isList command in 05AB1E, so I had to use some workarounds to check this by utilizing wrapping into a list, deep flattening, and check for equality.
And third, there isn't a flatten for just one level of a multi-dimensional list. The flatten function ˜ is a deep flatten that removes all layers and makes a multi-dimensional list a single list with all inner-most values. (i.e. [[1,2],[[[3]],4]] becomes [1,2,3,4]).

I ended up with the code at the top to overcome all three of the above issues. It's split into three major parts. First we have the following:
"..."        # Create a string with 05AB1E code
     ©       # Save this string in the register (without popping)
      .V     # Execute the string as 05AB1E code

The string contains the following code:
ε            # Map each value in the given list by:
             # (this uses the input-list implicitly with the initial call)
 ¼           #  Increase the counter_variable by 1
 D           #  Duplicate the map-value
             #   i.e. STACK "A" becomes "A","A"
             #   i.e. STACK [["B","C"]] becomes [["B","C"]],[["B","C"]]
  ¸          #  Wrap it into a list
             #   i.e. "A" → ["A"]
             #   i.e. [["B","C"]] → [[["B","C"]]]
   D         #  Duplicate that again
             #   i.e. STACK "A",["A"] becomes "A",["A"],["A"]
             #   i.e. STACK [["B","C"]],[[["B","C"]]]
             #    becomes [["B","C"]],[[["B","C"]]],[[["B","C"]]]
    ˜        #  Flatten it
             #   i.e. ["A"] → ["A"]
             #   i.e. [[["B","C"]]] → ["B","C"]
     Ê       #  Check if the wrapped and wrapped+flattened lists are NOT equal
             #   i.e. ["A"] and ["A"] → 0 (falsey)
             #   i.e. [[["B","C"]]] and ["B","C"] → 1 (truthy)
      i      #  If they are:
       ®     #   Push the string from the register
        .V   #   Execute it as 05AB1E code
             #   (this is basically our recursive call, mapping the current value
             #    we duplicated initially again)

A map is used instead of a foreach-loop, because the map has an implicit y, and a foreach-loop need an explicit y. We only care about the counter_variable, though.
And finally, after all the maps and inner maps are done, we'll:
¾           # Push the counter_variable (which is output implicitly as result)

R, 65 bytes
R=function(L,`*`=sapply)"if"(any(L*is.list),sum(1+L*R),length(L))

Try it online!
Obvious recursive implementation of the spec.

C, 174 167 152 bytes
Recursive function f, which leaks memory (152):
#include"object.h"
size_t f(array_t*a){size_t t=0,i=0;for(;i<array_length(a);i++){object_t*o=array_get_copy(a,i,0);t+=o->type==6?f(o->ary):1;}return t;}

Recursive f which doesn't leak, using references, at 167:
#include"object.h"
size_t f(array_t*a){size_t t=0,i=0;for(;i<array_length(a);i++){object_t**o=array_get_ref(a,i,0);t+=*o->type==t_array?f(*o->ary):1;}return t;}

Ungolfed:
size_t get_recursize (const array_t* const a) {
  pfn();

  object_failnull(a);

  size_t out = 0;

  for (size_t i = 0; i < array_length(a); i++) {

    object_t** o = array_get_ref(a, i, NULL);

    if ( (*o)->type == t_array ) {

      out += get_recursize((*o)->ary);

    } else {
      ++out;
    }
  }
  return out;
}

"But how," you ask, "can this be answered in C? Surely, there are no managed arrays in C, and you can't really have heterogeneous arrays...?"
"Aha," I reply, "for I have been working on a simple system of "objects" for (GNU-ish) C11 and ISO C++11".
The full demo program for this function is:
#include "../calc/object/object.h"

size_t get_recursize (const array_t* const a);

define_array_new_fromctype(ssize_t);

int main (void) {

  size_t len = 6;

  static const ssize_t h[6] = { -1, 3, -5, 7, -9, 11 };

  array_t* a = array_new_from_ssize_t_lit(h, len, t_realint);

  size_t rsize = get_recursize(a);

  printf("Recursive size of a: %zu\n", rsize);

  object_t* asobj = object_new(t_array, a);
  array_destruct(a);

  array_t* b = array_new(NULL, -1);

  for (size_t j = 0; j < 10; j++) {
    array_append(b, asobj);
  }

  object_destruct(asobj);

  rsize = get_recursize(b);

  printf("Recursive size of b: %zu\n", rsize);

  asobj = object_new(t_array, b);
  array_destruct(b);

  array_t* c = array_new(NULL, -1);

  for (size_t i = 0; i < 100; i++) {
    array_append(c, asobj);
  }

  object_destruct(asobj);

  rsize = get_recursize(c);

  printf("Recursive size of c: %zu\n", rsize);

  array_destruct(c);

  return EXIT_SUCCESS;
}

size_t get_recursize (const array_t* const a) {
  pfn();

  object_failnull(a);

  size_t out = 0;

  for (size_t i = 0; i < array_length(a); i++) {

    object_t** o = array_get_ref(a, i, NULL);

    if ( (*o)->type == t_array ) {

      out += get_recursize((*o)->ary);

    } else {
      ++out;
    }
  }
  return out;
}

Right now, it lives here and you'll need that repo to use this.
You'll also need the Fowler-Noll-Vo hash library, libfnv, compiled for your platform. It's in that repository and you can also grab it here.
Then you can do cc -DNODEBUG size.c path/to/libfnv.a -o size.
The implementation isn't necessarily efficient:
$ valgrind --leak-check=full --track-origins=yes --show-leak-kinds=all ./size
==24127== Memcheck, a memory error detector
==24127== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al.
==24127== Using Valgrind-3.12.0.SVN and LibVEX; rerun with -h for copyright info
==24127== Command: ./size
==24127==
Recursive size of a: 6
Recursive size of b: 60
Recursive size of c: 6000
==24127==
==24127== HEAP SUMMARY:
==24127==     in use at exit: 0 bytes in 0 blocks
==24127==   total heap usage: 22,900 allocs, 22,900 frees, 615,584 bytes allocated
==24127==
==24127== All heap blocks were freed -- no leaks are possible
==24127==
==24127== For counts of detected and suppressed errors, rerun with: -v
==24127== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

But it does work! The last commit to master (which this program compiled on) was 2 days ago, which means this submission is valid.

Axiom 118 bytes
RS(a:Union(List(Any),Any)):INT==(a case List(Any)=>(g:List(Any):=a;leaf? g=>0;r:=#g;for i in g repeat r:=r+RS(i);r);0)

ungolfed
RS(a:Union(List(Any),Any)):INT==
  a case List(Any)=>
          g:List(Any):=a
          leaf? g=>0
          r:=#g
          for i in g repeat r:=r+RS(i)
          r
  0

results
(25) -> RS([])=0
   (25)  0= 0
                                        Type: Equation NonNegativeInteger
(26) -> RS([[]]) = 1
   (26)  1= 1
                                           Type: Equation PositiveInteger
(27) -> RS([4, 5, 6]) = 3
   (27)  3= 3
                                           Type: Equation PositiveInteger
(28) -> RS(["four", "five", "six"]) = 3
   (28)  3= 3
                                           Type: Equation PositiveInteger
(29) -> RS(["[[[[]]]]", "[][][][][]", "][][[[]]][]["]) = 3
   (29)  3= 3
                                           Type: Equation PositiveInteger
(30) -> RS([[4, 5, 6]]) = 4
   (30)  4= 4
                                           Type: Equation PositiveInteger
(31) -> RS([["four", "five", "six"]]) = 4
   (31)  4= 4
                                           Type: Equation PositiveInteger
(32) -> RS([["[[[[]]]]", "[][][][][]", "][][[[]]][]["]]) = 4
   (32)  4= 4
                                           Type: Equation PositiveInteger
(33) -> RS([[4], [5], [6]]) = 6
   (33)  6= 6
                                           Type: Equation PositiveInteger
(34) -> RS([["four"], ["five"], ["six"]]) = 6
   (34)  6= 6
                                           Type: Equation PositiveInteger
(35) -> RS([["[[[[]]]]"], ["[][][][][]"], ["][][[[]]][]["]]) = 6
   (35)  6= 6
                                           Type: Equation PositiveInteger
(36) -> RS([[[[[[[[[]]]]]]]]]) = 8
   (36)  8= 8
                                           Type: Equation PositiveInteger
(37) -> RS([[],[],[],[],[],[],[],[]]) = 8
   (37)  8= 8
                                           Type: Equation PositiveInteger
(38) -> RS([[],[],[[]],[[[[]]]]]) = 8
   (38)  8= 8
                                           Type: Equation PositiveInteger
(39) -> RS([0,[-1],[2.3,-4.3],[5,[6]],[7,[8,9,[10,11,[12,13,14]]]]]) = 22
   (39)  22= 22
                                           Type: Equation PositiveInteger
(40) -> RS([['f','o','u','r'], ['f','i','v','e'], ['s','i','x']]) = 14
   (40)  14= 14
                                           Type: Equation PositiveInteger

Clojure, 79 77 51 bytes
Input has to be a list, not vector. Both would be supported by using sequential?.
(defn f[i](if(seq? i)(apply +(count i)(map f i))0))

Previous:
(defn f[i](if(seq? i)(if(some seq? i)(apply +(count i)(map f i))(count i))0))

APL(NARS), 24 chars, 48 bytes
{⍬≡⍵:0⋄×≡⍵:(≢⍵)++/∇¨⍵⋄0}

This would be the litteral traslation of 'my' Axiom answer here...
In APL the void list would be ´⍬´ Zilde, that you indicate with ´[]´, ´⊂⍬´ is ´[[]]´,
´1 2 3´ is ´[1,2,3]´ ecc
Some test:
  RS←{⍬≡⍵:0⋄×≡⍵:(≢⍵)++/∇¨⍵⋄0}
  RS ⍬
0
  RS ⊂⍬
1
  RS  4 5 6
3
  RS ("four")("five")("six")
14
  RS ('f' 'o' 'u' 'r') ('f' 'i' 'v' 'e') ('s' 'i' 'x')
14
  RS ("(((())))")("()()()()()")(")()((()))()(")
33
  RS (⊂4 5 6)
4
  RS (⊂("four")("five")("six"))
15
  RS (⊂("(((())))")("()()()()()")(")()((()))()(") )
34
  RS (,4) (,5) (,6)
6
  RS ⊂¨("four")("five")("six")
17
  RS ⊂¨("(((())))")("()()()()()")(")()((()))()(")
36
  RS ⊂⊂⊂⊂⊂⊂⊂⊂⍬
8
  RS ⍬⍬⍬⍬⍬⍬⍬⍬
8
  RS ⍬⍬(⊂⍬)(⊂(⊂(⊂⍬)))
8
  RS 0(,¯1)(2.3 ¯4.3)(5 (,6))(7 (8 9 (10 11 (12 13 14))))
22

for print the other type of results the exercise propose we need one other function (both functions RS and Rs should be ok for the exercise)
  Rs←{⍬≡⍵:0⋄(''≡0↑⍵)∨0=≡⍵:0⋄(≢⍵)++/∇¨⍵}
  Rs ("four")("five")("six")
3
  Rs ("(((())))")("()()()()()")(")()((()))()(")
3
  Rs (⊂("four")("five")("six"))
4
  Rs (⊂("(((())))")("()()()()()")(")()((()))()(") )
4
  Rs ⊂¨("four")("five")("six")
6
  Rs ⊂¨("(((())))")("()()()()()")(")()((()))()(")
6
  Rs 0(,¯1)(2.3 ¯4.3)(5 (,6))(7 (8 9 (10 11 (12 13 14))))
22
  Rs ('f' 'o' 'u' 'r') ('f' 'i' 'v' 'e') ('s' 'i' 'x')
3

for see how appear some input we use the o function:
  o←⎕fmt
  o 0(,¯1)(2.3 ¯4.3)(5 (,6))(7 (8 9 (10 11 (12 13 14))))
┌5─────────────────────────────────────────────────────────┐
│  ┌1──┐ ┌2────────┐ ┌2─────┐ ┌2──────────────────────────┐│
│0 │ ¯1│ │ 2.3 ¯4.3│ │  ┌1─┐│ │  ┌3──────────────────────┐││
│~ └~──┘ └~────────┘ │5 │ 6││ │7 │    ┌3────────────────┐│││
│                    │~ └~─┘2 │~ │8 9 │      ┌3────────┐││││
│                    └∊─────┘ │  │~ ~ │10 11 │ 12 13 14│││││
│                             │  │    │~~ ~~ └~────────┘2│││
│                             │  │    └∊────────────────┘3││
│                             │  └∊──────────────────────┘4│
│                             └∊──────────────────────────┘5
└∊─────────────────────────────────────────────────────────┘

this print Zilde, and one 8 Zilde list:
  o ⍬
┌0─┐
│ 0│
└~─┘
  o ⍬⍬⍬⍬⍬⍬⍬⍬
┌8──────────────────────────────────────┐
│┌0─┐ ┌0─┐ ┌0─┐ ┌0─┐ ┌0─┐ ┌0─┐ ┌0─┐ ┌0─┐│
││ 0│ │ 0│ │ 0│ │ 0│ │ 0│ │ 0│ │ 0│ │ 0││
│└~─┘ └~─┘ └~─┘ └~─┘ └~─┘ └~─┘ └~─┘ └~─┘2
└∊──────────────────────────────────────┘

Java, 96 bytes
int c(Object[]a){int r=a.length;for(var i:a)r+=i instanceof Object[]?c((Object[])i):0;return r;}

Try it online.
Explanation:
int c(Object[]a){  // Recursive method with Object-array parameter and integer return-type
  int r=a.length;  //  Result-sum, starting at the size of the input-array
  for(var i:a)     //  Loop over the input-array:
    r+=            //   Increase the result-sum by:
       i instanceof Object[]?
                   //    If the current item is an array:
        c((Object[])i)
                   //     A recursive call with this item
       :           //    Else:
        0;         //     0 (so leave the result-sum the same)
  return r;}       //  Return the result-sum

Attache, 21 bytes
{#_+Sum!$=>IsArray\_}

Try it online!
Turns out the C# approach is pretty short in Attache.
Alternatives
25 bytes f[x]:=#x+Sum!f=>IsArray\x
26 bytes f[x]:=#x+Sum[f=>IsArray\x]
35 bytes f:=Sum##{If[IsArray@_,1+f@_,1]}=>Id
35 bytes f:=Sum@Map[{If[IsArray@_,1+f@_,1]}]
37 bytes f[x]:=Sum[{If[IsArray@_,1+f@_,1]}=>x]

Python, 72 bytes
l=lambda a:0if len(a)==0else len(a)+sum(l(i)for i in a if type(i)==list)

you can remove some spaces there

Specifically, between 0 and if, 0 and else, and ) and for.

If you need rep for your chat bot account, consider making a meaningful contribution to the site. This adds absolutely nothing over the pre-existing 42 byte Python answer.


text:
A simple number system
Let me tell you about a simple number system. (which I made up just for this challenge)
This system contains the functions (), [], {}, and <>.
1. ()
When () is given no arguments, it evaluates to 0.
When () is given one or more arguments, it evaluates to the sum of the arguments.
2. []
When [] is given no arguments, it evaluates to -1.
When [] is given one or more arguments, it evaluates to the first argument minus the sum of the other arguments.
3. {}
When {} is given no arguments, it evaluates to 1.
When {} is given one or more arguments, it evaluates to the product of those arguments.
4. <>
When <> is given no arguments, it evaluates to 1.
When <> is given one or more arguments, it evaluates to the first argument integer divided by the product of the other arguments.
Your task
Given a string that contains a valid number (that means brackets are balanced, no division by 0s, etc.) in this simple number system, print its value.
Test cases
() -> 0
(()()) -> 0
([][]) -> -2
({}<>) -> 2
({}[]) -> 0
[] -> -1
[[][]] -> 0
[()<>] -> -1
{()} -> 0
{([]<>)} -> 0

Remember, this is code-golf, so the code with the fewest bytes wins.

I have a great name for this, which I totally just made up and did not get from anywhere else: Brain-flake!

@ETHproductions no

Sort of related

Is division float division or integer division?

@xnor Integer division

@Oliver How should integer division work when one or both of the operands are negative? What are the 4 expected results for 5/3, 5/-3, -5/3 and -5/-3?

@Oliver Must the result be an integer on its own, or can it be wrapped in a list/array/1-tuple?

Uhm ... can I use float division please? The type of division doesn´t really matter for the challenge imo. And it doesn´t make a difference for the given test cases.

@Oliver @Martin_Ender If you don't want to specify division for negative operands (a bit late now), you might at least demand consistency, such that <a b c ...> must be the same as <a {b c ...}>. (With the definition of <>, that is kind of obvious.) An interesting case is <{}([][])[]> vs <{}{([][])[]}>.

Dyalog APL, 94 bytes
o←{(⊂(1⊃⍵),⍺⍺⊃⍵),2↓⍵}⋄u←{(⊃⍵,⍺⍺1)⍺⍺⍵⍵/1↓⍵}⋄⍎⍕'+/o' '-u+o' '×/o' '÷u×o' '(⊂⍬),'[')]}>'⍳⌽⍞],'⊂⍬'
uses ⎕IO←0
replaces )]}> with a function call that takes a stack, applies an operation on its top frame, deletes it, and appends
the result to its next frame (monadic operator o is used for that; dyadic operator u handles the more complicated
cases of - and ÷)
replaces ([{< with code that adds a frame to the stack ((⊂⍬),)
executes the resulting expression (reversed, to match APL's order of execution) with an initial stack of one empty frame (⊂⍬)

Haskell, 357 306 277 251 228 224 188 185 180 bytes
A token-based parser with an explicit stack. (%) takes a token stack and a character and either pushes (opcode,defaultnumber) or (0,number) for ({[<, or pops topmost numbers and one opcode and pushes the answer for )}]>. Opcodes are encoded by a ascii enumeration hack.
Kudos to @ChristianSievers for his great answer that I borrowed some ideas from.
One-liner!
s%c|elem c"([<{",g<-div(fromEnum c)25=(g,[0,0,1,-1,1]!!g):s|(a,(o,n):b)<-span((==0).fst)s=(0,[foldr1(flip$[(+),quot,(-),(*)]!!(o-1))$snd<$>a,n]!!(0^length a)):b
snd.head.foldl(%)[]

Now with less error-handling!
Usage:
*Main> map (snd.head.foldl(%)[]) ["()","(()())","([][])","({}<>)","({}[])","[]","[[][]]","[()<>]","{()}","{([]<>)}"]
[0,0,-2,2,0,-1,0,-1,0,0]

Thanks @ChristianSievers for saving 14+3 bytes!
Thanks @Zgarb for saving some+4 bytes!

How about (0,[0,0,1,-1,1]!!o):s in the fifth line?

@ChristianSievers of course!

Switch the definitions of !, so you can do (s:_)!_=d s as the second case. Also, I think you could bind x<-p$d<$>init a,y<-d$last a in the last case of %.

@Zgarb thanks! I found a way to unify the evaluation even more.

On the third line of % you can drop parens around _:b and g c.

@Zgarb Oh, didn't have any idea the first one would work

Oh, you're coming close! I think you can save 3 bytes if you remove .reverse and compensate by changing foldl1( by foldr1(flip$

@ChristianSievers of course, flipping everything! My mistake was to try to flip only quot and (-).

PEG.js (ES6), 132 bytes
x=a:[([{<]b:x*[)\]}>]{var x='([<'.indexOf(a)
b.length^1||b.push(0)
return~~eval(b.length?b.join(('+-/'[x]||'*')+' '):~-('10'[x]||2))}

Should be fixed now.
Explanation
More readable:
x=a:[([{<]
  b:x*
  [)\]}>]
{
  var x='([<'.indexOf(a)
  b.length^1||b.push(0)
  return ~~eval(
    b.length?
      b.join(('+-/'[x]||'*')+' ')
    :~-('10'[x]||2))
  )
}

PEG.js is an extended version of Javascript specifically made for parsing. It's VERY strict, which is why I had to use var. In addition, there seems to be a bug with brackets inside strings, which bloated the code significantly.
To start, we define a rule x that matches any bracket a that may or may not contain multiple expressions that matches rule x.
For each match to rule x, we push a 0 to the array of the inner match b if b's length is 1.
If b's length > 0, then we find the index of a in ([< and get a character from +-/ using that index. If the result is undefined (meaning that a was {), then we turn the result into *. Finally, we tack on a space and join b with the result.
If b's length = 0, then we find the index of a in ([< and get a character from 10 using that index. If the result is undefined (meaning that a was { or <), then we turn the result into 2. Finally, we simply decrement.
At the end, we can just evaluate the expression and floor the result.

Python 2, 292 265 248 235 223 206 204 bytes
r=reduce
s=input()
for n in')]}>':s=s.replace(n,'),')
for a in'(*x:sum(x)','[a=-1,*x:a-sum(x)','{*x:r(int.__mul__,x,1)','<a=1,*x:r(int.__div__,x,a)':s=s.replace(a[0],'(lambda %s)('%a[1:])
print eval(s)[0]

Replaces all brackets with a lambda that does what the bracket does, then evaluates the resulting Python code. Requires its input surrounded by quotes, like '[<><>([]{})]'.
This program stores the type of bracket as the first character in each string in the for, and everything after the keyword lambda as the rest. It then uses the first character to substitute; the rest of it is combined into a lambda like (lambda*x:sum(x))().
Try it on Ideone!

Perl, 113 + 2 = 115 bytes
Run with -lp (2 byte penalty).
/\W/,eval"sub $`\{\$#_?(shift)$&&$'1}"for qw'a+a:1- b-a:- c*c: d/c:';y/([{</a-d/;s/\W/0),/g;s/\pL\K/(/g;$_=eval

More readable (note: this "more readable version" won't actually run, because I put comments in places they aren't syntactically allowed):
              # -p option: read a line of input into $_ at program start
              # -l option: remove the final newline whenever reading
do {          # for each element of a list, given later:
  /\W/;       # place an initial identifier in $`, the next character in
              # $&, and the rest of the element in $'
  eval qq{    # then evaluate the following template, with substitutions:
    sub $` {  # define a subroutine named $`, that does this:
      \$#_ ?  # if there is more than one argument
      (shift) # then return the first argument $&-ed with
      $& &$'  # the result of a recursive call with the tail of the arguments
              # else (the "else" is a colon taken from $', not the template)
      1       # return (the remainder of $' applied to) 1
    }
  }
} for qw'     # specify the list by splitting the following on whitespace:
  a+a:1-      # a(head,tail) = len(tail>1) ? head+a(tail) : 1-1
  b-a:-       # b(head,tail) = len(tail>1) ? head-a(tail) : -1
  c*c:        # c(head,tail) = len(tail>1) ? head*c(tail) : 1
  d/c:        # d(head,tail) = len(tail>1) ? head/c(tail) : 1
';
y/([{</a-d/;  # replace ( [ { < with a b c d in $_
s/\W/0),/g;   # replace whitespace, punctuation in $_ with the string "0),"
s/\pL\K/(/g;  # place a ( after (\K) each letter (\pL) in $_
$_=eval       # evaluate $_ as a Perl program, storing the result back in $_
              # -p option: print $_ to the user at program end
              # -l option: output a newline whenever printing

The basic idea is that we're converting an input like [()<>] to the Perl program b(a(0),d(0),0), via text processing; Perl's just fine with the trailing comma. Earlier, we defined the functions a, b, c, d to have the same effect as the (), [], {}, <> constructs from the language we're implementing; they each disregard their last argument (the 0 at the end), which is included to ensure that all input parses correctly, and work using the implementation commonly seen in functional programming where the head and tail are processed separately. Because b(e,f,g,0) means e-f-g, i.e. treats its first argument specially, whereas a treats its arguments symmetrically (a(e,f,g,0) means e+f+g), we implement a recursively and b via calling a. c and d have a similar relationship. All four of these functions are very similar, so we generate them at runtime rather than implementing them separately; we store a template that applies to all four functions in a string, then generate the functions by substituting characters into the template.
Because Perl / does floating-point division, the implemented {} does too. I'm assuming that either this is not a problem in its own right, or -Minteger (selecting a language variant where all arithmetic operations are integer operations) is free, because otherwise I'd have to spend extra bytes writing an integer division in Perl, which doesn't seem to be what the problem is fundamentally about. (I think you'd have to spend four bytes changing (shift) to int+(shift); I haven't tested this.)

Octave, 215 206  198 bytes
S='sum(x(:))-sum(x(2:end))';Y='(@(x)isempty(x)';c=']) ';[~,~,u]=unique(['()<>[]{}',input('')]);eval([{'sum([',c,[Y,'+fix((',S,')/prod(x(2:end))))(['],c,[Y,'*-1+',S,'*2)(['],c,'prod([',c}{u(9:end)}])

try it online

PHP, 315 300 285 258 250 244 bytes
for($s=$argv[1];$r=!$r;)foreach(["(+)1","[-]0","{*}2","</>2]as$p)if(preg_match("#$e$p[0]([-_\d]*)$e$p[2]#",$s,$m)){if(""==$v=strtok($m[1],_))$v=$p[3]-1;while(""<$n=strtok(_))eval("\$v$p[1]=$n;");$s=strtr($s,[$m[$r=0]=>_.$v]);}echo substr($s,1);

replaces sub-expressions with underscore+value;
loop breaks when iteration made no replacement.
19 years since I first met C, 17 years working with PHP;
this is the first time that strtok makes sense ... helping to save 24 bytes!
breakdown
for($s=$argv[1];    // take input from argument
    $r=!$r;)        // toggle $r; loop until no replacement has taken place
    foreach(["(+)1","[-]0","{*}2","</>2]as$p) // loop through operations
        if(preg_match("#$e$p[0]([-_\d]*)$e$p[2]#",$s,$m))   // find a match
        {
            if(""==$v=strtok($m[1],_))  // init $v with first token from sub-match
                $v=$p[3]-1;             // if no token, init with default value
            while(""<$n=strtok(_))      // loop through tokens
                eval("\$v$p[1]=$n;");       // operate
            $s=strtr($s,[$m[$r=0]=>_.$v]);  // reset $r; replace match with underscore+value
        }
echo substr($s,1);  // print result

ES6 (Javascript), 250, 171, 154, 149, 147 bytes
A pure Javascript version.
"Metaprogramming" (like most other answers here), converts input program text into a corresponding Javascript program, by applying a number of direct text substitutions to it (i.e. keeping the program structure as is).
Can probably be golfed further.
UPDATE (v2.1)

Minus two bytes (removed parenthesis in the ternary expression)
Golfed 5 more bytes off, by using variable for result extraction, and getting rid of extra "[]"

UPDATE (v2)
Just realised that pending commas in ES arrays are totally valid,
so the whole comma normalization code could be removed.
Also followed an excellent advice by @Titus, on optimizing the alphabet lookup.
UPDATE (v1)
Removed duplicate "replace" alias.
UPDATE (v1)

Use a better alphabet: ()=>1+ []=>0 {}=>2* <>=>2/ (each char can be directly re-used as a value or operator)

Replaced reduce() with replace() (alphabet mapping)

Merged constant inlining, open and closing bracket processing into one step

Golfed (v2.1)
s=>eval("o="+s.replace(/./g,r=>"2+1-3*3/"["()[]{}<>".indexOf(r)]).replace(/\d\D?|\D/g,r=>r[1]?r[0]-2+",":r*1?'([':`].reduce((r,a)=>r${r}a)),`)+"o

Golfed (v1)
(s,A="(2)+[1]-{3}*<3>/")=>eval(s[R="replace"](/./g,r=>A[A.indexOf(r)+1])[R](/\d\D?|\D/g,r=>r[1]?r[0]-2+",":(r[0]*1?'([':`].reduce((r,a)=>r${r}a)),`))[R](/,(\])|,$/g,"$1"))

Golfed (v0)
([...s],A="(a)b[c]d{e}f<g>h",R="replace")=>eval(s.reduce((r,c)=>r+=A[A.indexOf(c)+1],'')[R](/ab|cd|ef|gh/g,r=>({d:-1,b:'0'}[r[1]]||1) + ',')[R](/[aceg]/g,"([")[R](/[bdfh]/g,r=>`].reduce((r,a)=>r${"+*-/"["bfdh".indexOf(r)]}a)),`)[R](/,(\])|,$/g,"$1"))

Explained (v0)
//BEGIN

//s - input text, A - alphabet, R - "String.replace()" alias
E=([...s],A="(a)b[c]d{e}f<g>h",R="replace")=>eval(

//Replace input alphabet by a more friendly one, to avoid too much escaping and quoting
// () - ab, [] -cd, {} - ef, <> - gh
s.reduce((r,c)=>r+=A[A.indexOf(c)+1],'')

//Replace no-arg invocations with a corresponding constant value
// () => 0, [] => -1, {} => 1, <> => 1
[R](/ab|cd|ef|gh/g,r=>({d:-1,b:'0'}[r[1]]||1) + ',')

//Replace opening brackets with "(["
[R](/[aceg]/g,"([")

//Replace closing brackets with "].reduce(...)),"
//An arithmetic operation to apply (+-*/) is chosen based on the bracket type
//and is substituted into the template
[R](/[bdfh]/g,r=>`].reduce((r,a)=>r${"+*-/"["bfdh".indexOf(r)]}a)),`)

//Strip excessive commas
[R](/,(\])|,$/g,"$1")
);

//END: eval() the result

Example:
E("{([]<>()<>{})(<><>)}")
=> eval("([([-1,1,0,1,1].reduce((r,a)=>r+a)),([1,1].reduce((r,a)=>r+a))].reduce((r,a)=>r*a))")
=> 4

Test
E=([...s],A="(a)b[c]d{e}f<g>h",R="replace")=>eval(s.reduce((r,c)=>r+=A[A.indexOf(c)+1],'')[R](/ab|cd|ef|gh/g,r=>({d:-1,b:'0'}[r[1]]||1) + ',')[R](/[aceg]/g,"([")[R](/[bdfh]/g,r=>`].reduce((r,a)=>r${"+*-/"["bfdh".indexOf(r)]}a)),`)[R](/,(\])|,$/g,"$1"))

T=(s,a)=>{
    console.log(s,r=E(s),r==a?"OK":"NOT OK");
}

T("()",0)
T("(()())",0)
T("([][])",-2)
T("({}<>)",2)
T("({}[])",0)
T("[]",-1)
T("[[][]]",0)
T("[()<>]",-1)
T("{()}",0)
T("{([]<>)}",0)

Test Output
() 0 OK
(()()) 0 OK
([][]) -2 OK
({}<>) 2 OK
({}[]) 0 OK
[] -1 OK
[[][]] 0 OK
[()<>] -1 OK
{()} 0 OK
{([]<>)} 0 OK

Could your v0 version go with s.reduce((r,c)=>r+="abcdefgh"["()[]{}<>".indexOf(c)],'') (-5)? if so, you could remember indexOf in a variable and take the operator from a third string literal.

Haskell, 184 179 172 161 160 159 151 148 145 bytes
s%(c:i)|elem c")}]>"=([1?(*),sum,1?quot,(-1)?(-)]!!mod(fromEnum c)5$s,i)|(r,j)<-[]%i=(s++[r])%j
[v]%e=(v,e)
(v?_)[]=v
(_?o)s=foldl1 o s
fst.([]%)

Recursive descent, threading the input because Haskell. As usual, the last line is not a definition, but states the function that solves the problem. So to test, put the lines except the last one in a file, load it and do something like this:
*Main> fst.([]%) $ "{([][][])([][])}"
6

Thanks to @Zgarb for inspiration and a lot of detailed hints, and to @Angs for inspiration from his solution and further hints.
It wasn't specified how division should behave with negative integers. Anyway, repeatedly using div seems wrong, as it is not the same as using div once with the product of the remaining values. Now using quot, I get the same results for <{}([][])[]>and <{}{([][])[]}>.
For nice, almost readable code look at the first version. The intermediate versions contain all kinds of nice and intimidating code and help understand this version.

I think you can save a couple of bytes by defining (!)=(,) and using ! instead of explicit tuples.

If you define m x and d x as 1#x and 0#x, you can merge the cases m[x] and d[x] into one, which I think saves some bytes too.

@Zgarb Thanks! I nearly missed the last pair, without which the ! trick doesn't pay out. Your second suggestion is evil, there goes my almost readable code... Clever!

Heh, I just realized that defining s%(c:i)=(s?c,i) and s?')'=sum s etc will be much shorter, since you can get rid of the repeated is. ..No wait, that probably won't work because of the s%(_:i) case.

Had the same idea and used a guard with elem. Down to 175 bytes, still experimenting.

Lose the backticks on elem and div, that should save some more bytes.

Oh hey, you can merge the first two lines into s%(c:i)|elem c")}]>"=(g c s,i)|(r,j)<-[]%i=(s++[r])%j and lose 8 bytes.

I think you can inline g for a few bytes: ([sum,1?quot,(-1)?(-),1?(*)]!!div(fromEnum c-26)26$s,i). Btw, this answer is really goddamn nice.

And div(fromEnum c-8)34) is one byte better

@Angs Thanks! I found an even shorter way to get an index. (You could similarly use mod 6 to get from opening parens to different values between 0 and 4.)

@ChristianSievers I don't think that'll work since in my answer they are not only the index, but they being not 0 is part of the control logic

JavaScript (ES6), no eval, 156 bytes
f=s=>s==(s=s.replace(/(.) ?([- \d]*)[\]})>]/,(_,c,s)=>` `+(s?s.split` `.reduce((l,r)=>c<`<`?l- -r:c<`[`?l/r|0:c<`{`?l-r:l*r):c==`[`?-1:c==`(`?0:1)))?+s:f(s)

Explanation: The regexp finds the first unprocessed closing bracket, and matches the (presumably) corresponding opening bracket and any arguments in between. The arguments are split and reduced according to the operation (sadly '(' and '[' are not the optimal pair for + and -), or if there are no arguments then the appropriate value is calculated (again the matching of characters to values is suboptimal from my point of view). The result is then substituted in with a leading space so as to separate it from other results. The function then calls itself recursively until there are no more changes to make, in which case it returns the resulting value. Example:
[()<>]
[ 0<>]
[ 0 1]
 -1

f("([][])") => 0 (instead of 2)

Some other tests are also failing for me (you can give the test code in my answer a try), probably due to: f("[]")=>0, as "[]" is a part of every failing test.

@zeppelin Oops, that was due to some bad golfing. I've reverted to a previous version, but sadly that costs me a couple of bytes.