text:
Return the integers with square digit-sums
Introduction and Credit
We all know and love our awesome rules to test whether a number is divisble by 11 or 3, which is just some clever sum over the digits of the number. Now this challenge takes this to a new level, by requiring you to compute the sum of the digits and then checking whether the result is a perfect integer square, neither of which operations usually can be done very short. As this property is also very hard to see when looking at a number, we want this to be done for entire lists of numbers so we can save human work. So this is your challenge now!
This was an assignment at my university functional programming course. This assignment is now closed and has been discussed in class and I have my professor's permission to post it here (I asked explicitely).
Specification
Input
Your input is a list of non-negative integers, in any standard I/O format.
You may choose the list format as your language needs it
Output
The output is a list of integers, in any standard I/O format.
What to do?
Filter out every integer from the input list for which the sum of the digits is not a a square (of an integer).
The order of the elements may not be changed, e.g. if you get [1,5,9] you may not return [9,1]
Potential corner cases
0 is a non-negative integer and thus a valid input and 0 is also a valid integer root, e.g. 0 counts as an integer square.
The empty list is a valid input and output as well.
Who wins?
This is code-golf so the shortest answer in bytes wins!
Standard rules apply of course.
Test Cases
[1,4,9,16,25,1111] -> [1,4,9,1111]
[1431,2,0,22,999999999] -> [1431,0,22,999999999]
[22228,4,113125,22345] -> [22228,4,22345]
[] -> []
[421337,99,123456789,1133557799] -> []

Step-by-Step Example
Example input: [1337,4444]
Handling first number:
Sum of the digits of 1337: 1+3+3+7=14
14 is not an integer square, thus will be dropped!
Handling second number:
Sum of the digits of 4444: 4+4+4+4=16
16 is an integer square because 4*4=16, can get into the output list!
Example output: [4444]

Nice first challenge, and welcome to the site!

For future challenges note the sandbox. It's a place where we put challenges before we put them on the main site so hey can get reviewed and their content queried so they will (hopefully) get better received on main. Not that this is a bad question though (I actually quite like it)

@muddyfish, I've read about this and considered posting there but decided not to do it, because I was confident, that there's nothing I could miss / do horribly wrong here :) Of course if I have even some doubt there could be something I miss I'll post there.

While it is totally fine to avoid the sandbox, had you posted there I would have suggested that you make the challenge only about testing an individual integer. The interesting task is the test, wrapping that task with a filter isn't particularly interesting. All it seems to do is make the challenge substantially more difficult in esoteric languages that do not have arrays as types. That may sound a bit harsh, but this is still an excellent first post. Just saying that the sandbox is there because no matter how sure you are you didn't miss anything, you missed something.

@FryAmTheEggman I can say for Mathematica that making this function listable complicates things in a slightly non-trivial way, so it's not exactly boring.

Is the output list required to be in the same order as the input?
EDIT: Yup, it is. I'm just blind.

Pyke, 6 bytes
#s,DBq

Try it here!
#      - Filter list on truthiness:
 s     -    digital_root(^)
  ,    -   sqrt(^)
    Bq -  int(^) == ^

Mathematica, 39 36 bytes
An anonymous function:
Select[AtomQ@√Tr@IntegerDigits@#&]

LLlAMnYP saved a byte. Thank you!
Martin Ender saved three more by replacing IntegerQ with AtomQ. Clever! (The result of √ will be exact, so it returns a compound expression like Sqrt[5] if its argument isn’t a square.)

A byte to be saved by ...Digits@#& instead of ...Digits[#]&

Jelly, 8 7 bytes
1 byte thanks to @Sp3000.
DSÆ²ðÐf

Test suite.
Explanation
DSÆ²ðÐf  Main monadic chain. Argument: z

     Ðf  Filter for truthiness:
D            convert to base 10
 S           sum
  Æ²         is perfect square

Brachylog v2, 8 bytes
{ẹ+√ℤ&}ˢ

Try it online!
Explanation
{ẹ+√ℤ&}ˢ
{     }ˢ  Map the following operation over {the input}, discarding elements that error:
 ẹ         Split into a list of digits
  +        Sum that list
   √       Take its square root
    ℤ      Assert that the result is an integer
     &     Return to the original value

The & means that the elements output are the same as those in the input list, but the ℤ will error out if the block's input isn't a square number, so we get the input list with elements with non-square digit sums discarded.
Note that there might at first seem to be a floating point inaccuracy issue here (some very large non-square integers have integer square roots due to rounding). However, Brachylog supports bignum arithmetic, and actually has this behaviour factored into its implementation of √: a number which is a perfect square will have its square root reported as an integer, whereas a number which is not a perfect square (but close enough that its square root is integral) will have its square root reported as a float with an integral value. Conveniently, ℤ only permits the former sort of return value, giving an assertion failure for the latter.

Pyth, 10 bytes
fsI@sjT;2Q

Test suite.
Explanation
fsI@sjT;2Q

f        Q  Filter for the following in Q(input):
     jT;        convert to base 10
    s           sum
   @    2       square-root
 sI             is integer (is invariant under flooring)

CJam, 14 bytes
Thanks to @FryAmTheEggman for saving one byte!
{{Ab:+mq_i=},}

Try it online!
This is an unnamed block that expects the input list on the stack and leaves the filtered list on it.
Explanation

{    e# start a new block
 Ab  e# convert to base 10 -> split number into digits
 :+  e# sum th digits
 mq  e# get the square root
 _   e# duplicate the result
 i   e# convert to integer
 =   e# check if the converted square root and the original one are equal
}    e# end block
,    e# filter the input list

PowerShell, 64 54 bytes
$args|?{!([math]::Sqrt(([char[]]"$_"-join'+'|iex))%1)}

Try it online!
-10 bytes thanks to mazzy
Takes input as command-line arguments (see examples below), which gets processed in PowerShell into the array $args. We pipe that to ? an alias for Where-Object (functions similar to filter) in order to select our output. Our selection is based on the .NET call [math]::Sqrt() of the digit-sum of the number is an integer with !(...%1). Integers will result in 0, which when noted becomes True while non-integer roots become False.
As mentioned elsewhere "returning" an empty array is meaningless, as it's converted to $null as soon as it leaves scope, so the output for an empty input is nothing.
Examples
PS C:\Tools\Scripts\golfing> .\return-integers-with-square-digit-sums.ps1 1 4 9 16 25 1111
1
4
9
1111

PS C:\Tools\Scripts\golfing> .\return-integers-with-square-digit-sums.ps1 1431 2 0 22 999999999
1431
0
22
999999999

PS C:\Tools\Scripts\golfing> .\return-integers-with-square-digit-sums.ps1 22228 4 113125 22345
22228
4
22345

PS C:\Tools\Scripts\golfing> .\return-integers-with-square-digit-sums.ps1

PS C:\Tools\Scripts\golfing> .\return-integers-with-square-digit-sums.ps1 1337 4444
4444

$n%1 checks if int only $args|?{!([math]::Sqrt(([char[]]"$_"-join'+'|iex))%1)}

05AB1E, 19 10 bytes
vySOtDï->—

Explanation
vy                     # for each int in list
  SO                   # digit sum
    tDï-               # difference between sqrt() and int(sqrt())
        >              # increase by 1 giving 1 (true) when equal
         —             # print current int in list if truthy

Try it online
Edit: Saved 9 bytes thanks to @Adnan

For getting the sum of digits for each, you can do vySO and check immediately if it's square or not. I got this to 5: tDï->. There also is a special builtin that prints y when equal to 1, which is (—). So, that would be vySOtDï->—.

@Adnan: I can't believe I forgot about S. I didn't even look at — since the task said to output as a list, but I see other answers are doing the same so I assume it's OK.

Yeah, items separated with newlines are accepted by default I think, unless the challenge explicitly said not to.

Haskell - 70 60 59 bytes
f=filter(\x->elem(sum.map(read.pure).show$x)$map(^2)[0..x])

Usage:
> f [0..100]
[0,1,4,9,10,13,18,22,27,31,36,40,45,54,63,72,79,81,88,90,97,100]

Quite straightforward; computes the sum of digits and checks if floor(sqrt(y))^2 == y
Edit:
Stole the idea of checking list of squares from C. Quilley

Interesting approach. I'm not sure the f= is required for this answer.

R, 57 55 bytes
Use Filter on the vector. Assumes 32 bit integers so 10 digits max.
Corner cases: returns NULL for the empty vector and numeric(0) for a vector with no valid numbers. These both have length zero so should be acceptable.
-2 thanks to @Giuseppe
Filter(function(n)!sum(n%/%10^(0:10)%%10)^.5%%1,scan())

Try it online!

Javascript 66 bytes
a=>a.filter(b=>(e=Math.sqrt((b+"").split``.reduce((c,d)=>c-+-d)))==(e|0))

Thanks for SergioFC for saving 7 bytes

Can't you just use c+d instead of c-+-d? In addition you can use n%1==0 to test if the result is an int, so maybe you can save some bytes using b=>!(Math.sqrt((b+"").split``.reduce((c,d)=>c-+-d))%1) to filter

@sergioFC I can't change -+- to +, because they're strings

J, 33 27 bytes
6 bytes thanks to @miles.
#~[:(=<.)@%:+/"1@(10&#.inv)

In online interpreters, inv is not instored. Change that to ^:_1 instead.
Usage
>> f =: #~[:(=<.)@%:+/"1@(10&#.inv)
>> f 1 4 9 16 25 1111 0
<< 1 4 9 1111 0

Where >> is STDIN and << is STDOUT.
Slightly ungolfed
to_base_10 =: 10&#.^:_1
sum        =: +/"1
sqrt       =: %:
floor      =: <.
itself     =: ]
equals     =: =
of         =: @
is_integer =: equals floor
test       =: is_integer of sqrt
copies_of  =: #
f =: copies_of~ [: test (sum of to_base_10)

Previous 33-byte version
(]=*:@<.@%:)@(+/"1@(10#.^:_1]))#]

Usage
>> f =: (]=*:@<.@%:)@(+/"1@(10#.^:_1]))#]
>> f 1 4 9 16 25 1111 0
<< 1 4 9 1111 0

Where >> is STDIN and << is STDOUT.
Slightly ungolfed
to_base_10 =: 10#.^:_1]
sum        =: +/"1
sqrt       =: %:
floor      =: <.
square     =: *:
itself     =: ]
equals     =: =
of         =: @
test       =: itself equals square of floor of sqrt
copies_of  =: #
f =: (test of (sum of to_base_10)) copies_of itself

You can use f&.g to apply g, then f, and then the inverse of g to shorten *:@<.@%: to <.&.%: saving 2 bytes. You can rearrange it and use only floor to get #~[:(=<.)@%:+/"1@(10&#.inv) for 27 bytes where inv is ^:_1, and is already defined.

Python 2, 76 bytes
lambda l:filter(lambda n:eval(("sum(map(int,`n`))**.5==int("*2)[:-6]+")"),l)

Try it here!
Some abuse of eval to check for a square number, rest is pretty unspectacular.
The eval statement evaluates to sum(map(int,n))**.5==int(sum(map(int,n))**.5)

Oracle SQL 11.2, 213 bytes
WITH v AS(SELECT a,SQRT(XMLQUERY(REGEXP_REPLACE(a,'(\d)','+\1')RETURNING CONTENT).GETNUMBERVAL())s FROM(SELECT TRIM(COLUMN_VALUE)a FROM XMLTABLE(('"'||REPLACE(:1,',','","')||'"'))))SELECT a FROM v WHERE s=CEIL(s);

Un-golfed
WITH v AS
(
  SELECT a,SQRT(XMLQUERY(
                   REGEXP_REPLACE(a,'(\d)','+\1')  -- Add a + in front of each digit
                   RETURNING CONTENT
               ).GETNUMBERVAL())s                  -- Evaluate the expression generated by the added +
  FROM
  (SELECT TRIM(COLUMN_VALUE)a FROM XMLTABLE(('"'||REPLACE(:1,',','","')||'"'))) -- Split string on ','
)
SELECT a FROM v WHERE s=CEIL(s) -- Is a square if square has no decimal part

Brachylog, 26 bytes
:1f.
e.(:ef+~^[X:2]h>0;.0)

Example:
?- run_from_file('code.brachylog',[1431:2:0:22:999999999],Z).
Z = [1431, 0, 22, 999999999]

Explanation
This is a situation where something works a bit too well... the ~^[X:2] part is true for both positive and negative X, so to avoid duplicates I have to specify that X > 0.
The ;.0 part is here due to a bug (enumerate doesn't work on the integer 0).

Main predicate
:1f.                Find all values of Input which satisfy predicate 1

Predicate 1
e.                  Unify output with an element of the input
(
  :ef               Find all elements of Output (i.e. all digits)
     +              Sum the digits
      ~^[X:2]       True if that sum is the result of X², whatever X is
             h>0    Impose that X > 0
;                   OR
  .0                True if Output is 0
)

Python 2, 53 bytes
lambda x:[n for n in x if sum(map(int,`n`))**.5%1==0]

Test it on Ideone.

For f([1111111111111111]), it looks like repr(n) contains an 'L' and int('L') throws a ValueError. I feel like you need str(n) here?

Right, it won't work for long ints. I don't think that's different from a solution in a language with fixed-width integers though.

Perl 5, 42 bytes
41, plus 1 for -pe instead of -e
my$s;map$s+=$_,/./g;$_ x=sqrt$s==~~sqrt$s

Explanation:

-p gets each input integer on a new line and assigns $_ to that string.
my$s initializes the variable $s to nothing, anew for each input integer.
map$s+=$_,/./g grabs each numeric character and numerically adds it to $s. (The newline becomes 0 when numified.)
sqrt$s==~~sqrt$s tests whether $s has a nonintegral square root, and $_ x= makes $_ into itself or the empty string depending on that test.
-p prints $_

Thanks to Brad Gilbert b2gills for saving three bytes.
Also 41 plus 1:
my$s;s/./$s+=$&/ger;$_ x=sqrt$s==~~sqrt$s

s/./$s+=$&/ger adds each numeric character to $s (and the newline is 0 as above)

JavaScript (Node.js), 48 bytes
a=>a.filter(b=>eval([...b+""].join`+`)**.5%1==0)

Try it online!
Explanation
a =>                                  // lambda function taking one argument
    a.filter(                         // filter the list
        eval(                         // begin eval
            [...b+""]                 // convert number to array of digits
                .join`+`              // join them with + sign
            )                         // close eval. we achieved sum of all digits of number
        **.5                          // square root of number
        %1==0                         // check for perfect square
    )                                 // end filter and return value

MATL, 16 14 13 bytes
"@tV!UsX^1\?x

Try it Online!
Explanation
        % Implicitly grab input
"       % For each number in the input
  @t    % Get this element and duplicate
  V     % Convert to it's string representation
  !     % Transpose the string so each digit is on it's own row
  U     % Convert each row to a number (separates the digits)
  s     % Compute the sum of the digits
  X^    % Compute the square root
  1\    % mod with 1 to determine if the square root is an integer
  ?x    % If there is a remainder, then remove this element from the stack
        % Implicitly display the stack contents

Julia - 38 bytes
!X=filter(i->√sum(digits(i))%1==0,X)

It's pretty easy to see what this does. digits converts a number into a list of its digits, sum thus calculates the digit-sum, √ will then produce a whole number if the number is a square, otherwise there will be a fractional part. %1 will return only the fractional part, and if it's zero (==0), filter will keep it on the list, otherwise it gets filtered out.
Used as ![22228,4,113125,22345]

Jolf, 8 bytes
Try it here!
ψxd!iUuH

Explanation
ψxd!iUuH
ψxd       filter the input according to the input
      uH  digit sum of H (element)
     U    sqrt of
   !i     is an integer?

MATLAB, 52 43 42 bytes
@(x)x(~mod(sum(dec2base(x,10)'-48).^.5,1))

Creates an anonymous function named ans that can be called with an array as input: ans([22228,4,113125,22345]).
Online Demo. The online demo is in Octave which doesn't work for the empty input, but MATLAB does.
Explanation
We convert each element in the input array to base 10 which will yield a 2D character array where each row contains the digits of a number in the array. To convert these characters to numbers, we subtract 48 (ASCII for '0'). We then sum across the rows, take the square root, and determine whether each value is a perfect square ~mod 1. We then use this boolean to filter the input array.

C, 143 141 bytes

 saved 2 bytes, @user6188402

i;q(char*n){double m=0;while(*n)m+=*n++-48;m=sqrt(m)-(int)sqrt(m);return !m;}s(n,s)char**n;{i=-1;while(++i<s)if(q(n[i]))printf("%s\n",n[i]);}

Ungolfed try online
int q(char*n)
{
    double m=0;

    while(*n) // sum digits
        m+=*n++-48;

    // get the decimal part of its square root
    m=sqrt(m)-(int)sqrt(m);

    // true if decimal part is zero
    return !m;
}

// input is text, can be a file
void s(char**n, int s)
{
    int i=-1;

    while(++i<s) // for each number in input
        if(q(n[i])) // if is square
            printf("%s\n",n[i]); // output is terminal
}

Clojure, 110 bytes
(fn[t](filter(fn[x](let[a(reduce +(*(count(str x))-48)(map int(str x)))](some #(=(* % %)a)(range(inc a)))))t))

Calculates the sum of number digits and then filters out those for which there doesn't exist a number which squared is equal to the sum.
You can see the result here – https://ideone.com/ciKOje

Perl 6,  38  35 bytes
{.grep: {($/=sqrt [+] .comb)==$/.Int}}
{.grep: {($/=.comb.sum.sqrt)==$/.Int}}
{.grep: {($/=sqrt [+] .comb)==^$/}}
{.grep: {($/=.comb.sum.sqrt)==^$/}}
Test:
#! /usr/bin/env perl6

use v6.c;
use Test;

my @tests = (
  [1,4,9,16,25,1111] => [1,4,9,1111],
  [1431,2,0,22,999999999] => [1431,0,22,999999999],
  [22228,4,113125,22345] => [22228,4,22345],
  [] => [],
  [421337,99,123456789,1133557799] => [],
);

plan +@tests;

my &sq-digit-sum = {.grep: {($/=sqrt [+] .comb)==^$/}}

for @tests -> $_ ( :key($input), :value($expected) ) {
  is sq-digit-sum($input), $expected, .gist
}

1..5
ok 1 - [1 4 9 16 25 1111] => [1 4 9 1111]
ok 2 - [1431 2 0 22 999999999] => [1431 0 22 999999999]
ok 3 - [22228 4 113125 22345] => [22228 4 22345]
ok 4 - [] => []
ok 5 - [421337 99 123456789 1133557799] => []

Retina, 69
Because testing for perfect squares in retina.  This can be modified for generalised integer square root calculation.

.+
$&a$&
+`\b\d
$*b

\bb
$&:
+`(\bb+):(bb\1)
$1 $2:
G`(:a|0$)
.*a

Input is a newline-separated list.
Try it online.

Stage 1 - repeat the number on each line, and separate with a
Stage 2 - convert each digit before the a to unary expressed as bs, separated with spaces
Stage 3 - remove spaces - each unary now represents the digit sum
Stage 4 and 5 - Use the fact that perfect squares may be expressed 1 + 3 + 5 + 7 + ... .  Split each unary up accordingly
Stage 6 - grep filter just the ones that exactly split into the above form
Stage 7 - discard all but the original number

I had a few ideas how to improve this, but ended up rewriting most of it. Nevertheless, this is still exactly your idea: duplicate input, expand digits in first half, filter squares in the form of sums of odd numbers, discard first half of remaining lines. The way I golfed the steps is via %-configuration, \G and forward references. Feel free to take it: http://retina.tryitonline.net/#code=JAo6JGAKJSlgXEdcZAokKgpHYF4oXjF8MTFcMSkqOgoxKjoK&input=MTQzMQoyCjAKMjIKOTk5OTk5OTk5 :)

K (oK), 19 17 13 bytes
Solution:
(~1!%+/.:'$)#

Try it online!
Explanation:
(~1!%+/.:'$)# / the solution
(          )# / apply function to list
          $   / convert to string
       .:'    / value (.:) each (')
     +/       / sum
    %         / square-root
  1!          / modulo 1
 ~            / not

Notes:

-2 bytes with smarter way of identifying squares
-4 bytes thanks to ngn

you know about filter (func#list)?

I did not, very nice!

Ruby, 39 bytes
->a{a.reject{|x|x.digits.sum**0.5%1>0}}

Try it online!

MathGolf, 5 4 bytes
gÅΣ°

Try it online!
Explanation:
gÅ    Filter by the next two instructions
  Σ   The digit sum
   °  Is a perfect square?

MathGolf is still in development, so I assume implicit input is coming soon to shave off that first byte. Yay!

Congratulations on the first MathGolf answer not by me! I've discussed implicit input with Emigna, and he gave me some great ideas. It's coming, hopefully soon.

Vyxal, 5 bytes
'f∑∆²

Try it Online!
'        # Keep elements in input list
 f∑      # Whose sum of digits is
   ∆²    # A perfect square

q - 53 characters
{x where({(sum({"J"$x}')($:)x)in((!:)x+1)*(!:)x+1}')x}
The interesting bit is the inner lambda, which casts to a string, sums the digit (by casting each of them to an int), and then checks if they are a in a list of squares.

{x where s=floor s:sqrt sum each value@''string x} for 50 without any shorthand, or {x(&)s=(_)s:sqrt sum@'(.:)@''($)x} for 34.

Javascript, 61 65

f=
a=>a.filter(x=>(r=Math.sqrt(eval([...`${x}`].join`+`)))==~~r)

j=JSON.stringify;
console.log([
[1,4,9,16,25,1111],
[1431,2,0,22,999999999],
[22228,4,113125,22345],
[],
[421337,99,123456789,1133557799]
].map(x=>j(x)+' -> '+j(f(x))).join`
`)

JavaScript (ES7), 56 bytes
a=>a.filter(n=>[...''+n].reduce((x,y)=>+x+ +y)**.5%1==0)

C#, 103 bytes
int[] f(int[] a){return a.Where(n=>Math.Sqrt((n+"").Select(m=>int.Parse(m+"")).Sum())%1==0).ToArray();}

Its really sad i have to turn chars and ints into strings all the time to work on them, i wish there was a better solution than adding an empty literal "" to cast into string.
any help on golfing this down appreciated

Hoon, 78 bytes
|*
*
%+
skim
+<
|=
@ui
=(0 q:(sqt (roll (scan (slag 2 <+<>) (star dit)) add)))

++skim only keeps the elements of the list that the function returns yes for. We cast all the atoms in the list to @ui in the sample, for the sole reason that Urbit's integers have mandatory group seperators: if you try to cast 1.000 to a string, it will return "1.000" instead of "1000". <@ui1.000>, however, gives "0i1000", so we cast and then cut off the first two letters of the string.
We then parse the string with the parser combinator (star dit), which is like the [0-9]* regex but also converts the character to an atom. We fold over the resulting list with add.
We call sqt on the number. In Hoon, the only data types are atoms or tuples, so it returns two atoms intead of a float: the nearest perfect square root, and the remainder. We can then just test if the remainder is 0.

TXR Lisp: 85 81 72 byte (op ...) denoting anon. function:
(op keep-if (opip tostring (mapcar chr-digit) (apply +) (= @1 [[dup *] (isqrt @1)])))
(op keep-if (opip `@1` (mapcar chr-digit) (apply +) (= @1 [[dup *] (isqrt @1)])))
(op keep-if(opip`@1`(mapcar chr-digit)(apply +)(=@1[[dup *](isqrt@1)])))

$ txr -i
1> (op keep-if(opip`@1`(mapcar chr-digit)(apply +)(=@1[[dup *](isqrt@1)])))
#<interpreted fun: lambda #:rest-0117>
2> [*1 '(1 4 9 16 25 1111)]
(1 4 9 1111)
3> [*1 '(1431 2 0 22 999999999)]
(1431 0 22 999999999)
4> [*1 ()]
nil
5> [*1 '(22228 4 113125 22345)]
(22228 4 22345)
6> [*1 '(421337 99 123456789 1133557799)]
nil
7>

isqrt is integer square root. This will handle large integers; no floating-point hacks here.
TXR Lisp is fundamentally a Lisp-2 dialect, like ANSI Common Lisp or Emacs Lisp. However, the square brackets [whatever ...] notation is syntactic sugar for the operator (dwim whatever ...) which evaluates using a form of Lisp-1 namespace semantics rather than Lisp-2: functions and variable bindings in one space rather than separate spaces. dwim is "deep"; it's not a macro transforming Lisp-2 to Lisp-2; it has visibility into the lexical environments to deliver the actual Lisp-1-like semantics.
In [dup *], the dup combinator takes a binary function (or a function that can be used as binary), and returns a unary function which applies two copies of its argument to that function as two arguments; i.e [dup *] denotes a squaring function.
op is a rich partial evaluation macro, and opip combines left-to-right pipeline with op: op pipe. (op mapcar +) curries the mapcar function. In (opip (mapcar +) ...),mapcaris similarly curried (theop` is implicit), and part of a pipeline.
The TXR Lisp REPL allows numbered references to prior results, modulo 100: *1 is the value produced in the most recent command line numbered 1, or 101, or 201, ...

C: 113  111 — based on other C answer.
This is a complete program with main. The input list is the argument list.
Old style C is used, but with the C99 fmod function.

q(char*n){double m=0;while(*n)m+=*n++-48;return!fmod(sqrt(m),1);}main(c,v)char**v;{while(*++v)if(q(*v))puts(*v);}
q(char*n){double m=0;while(*n)m+=*n++-48;return!fmod(sqrt(m),1);}main(c,v)char**v;{while(*++v)q(*v)&&puts(*v);}

Run:

$ gcc golf.c -o golf -lm
golf.c:1:1: warning: data definition has no type or storage class [enabled by default]
golf.c: In function ‘q’:
golf.c:1:52: warning: incompatible implicit declaration of built-in function ‘fmod’ [enabled by default]
golf.c:1:57: warning: incompatible implicit declaration of built-in function ‘sqrt’ [enabled by default]
$ ./golf 1 4 9 16 25 1111
1
4
9
1111
$ ./golf
$ ./golf 421337 99 123456 1133557799
$

Actually, 12 bytes
`$♂≈Σ;√≈²=`░

Try it online!
Explanation:
`$♂≈Σ;√≈²=`░
`$♂≈Σ;√≈²=`░  filter list, taking only values where the following function is true:
 $♂≈Σ           to string, map int, sum (digital sum, we'll call this n)
     ;√≈²=      compare equality to int(sqrt(n))**2

Neim, 4 bytes
Λq

Explanation:
Λ    Keep if
    sum of digits
    is in
  q  square numbers

Try it online!

Attache, 18 bytes
`\&:(IsSquare@Sum)

Try it online!
Explanation
`\ is the filter operator and &: applies the function IsSquare@Sum as it's predicate.

F#, 95 bytes
let s n=Seq.exists(fun x->x*x=n){1..n}
let i x=Seq.filter(string>>Seq.sumBy(int>>(+)(-48))>>s)x

Try it online!
Makes a lot of use of the >> operator (the function composition operator) which chains functions together. s determines if there is an integer square for n.
The main function i maps each number into a string, then sums the digits in the string. Each digit is the character's integer representation minus 48 (e.g. '4' |> int = 52 - 48 = 4). Then it uses s to determine if the digit sums has an integer square. If it does, it's included in the returned sequence. If it does not, then it's excluded (Seq.filter).

Japt, 8 bytes
f_õ²øZìx

Try it
f_ìx ¬v1

Try it

Thunno 2, 4 bytes
æSÆ²

Try it online!
Explanation
æSÆ²  # Implicit input
æ     # Filter by:
 S    #  Digit sum
  Æ²  #  Is a perfect square
      # Implicit output


text:
Approximation of e
We all know that the Euler's number, denoted by \$e\$, to the power of some variable \$x\$, can be approximated by using the Maclaurin Series expansion:
$$e^x=\sum_{k=0}^{\infty}{\frac{x^k}{k!}}=1+x+\frac{x^2}{2!}+\frac{x^3}{3!}+\frac{x^4}{4!}+\dots$$
By letting \$x\$ equal \$1\$, we obtain
$$\sum_{k=0}^{\infty}{\frac{1}{k!}{=\frac{1}{0!}+\frac{1}{1!}+\frac{1}{2!}+\frac{1}{3!}+\frac{1}{4!}+\dots\\=1+1+\frac{1}{2}+\frac{1}{6}+\frac{1}{24}+\dots}}$$
Challenge
Write a program in any language which approximates Euler's number by taking in an input \$n\$ and calculates the series to the \$n\$th term. Note that the first term has denominator \$0!\$, not \$1!\$, i.e. \$n=1\$ corresponds to \$\frac{1}{0!}\$.
Scoring
Program with least amount of bytes wins.

Given large enough N the results will be the same if using a finite precision floating point number. Is that behaviour acceptable or does the result have to progressively get more accurate as N approaches infinity?

Some test cases would be neat.

(This kind of issue is preferably resolved in the sandbox – if you post your challenges there first, golfers will give useful feedback.)

Is x^n the nth term or the (n+1)th?

Hopefully this edit makes any unclear details clearer

Thanks for editing to improve your question, however I do not think you answered my question or mh210's. Also, while not necessary, test cases are extremely helpful.

I don't think "Nth term" is unclear at all - the first term is the first term. Voting to reopen.

@FryAmTheEggman Perhaps you have never taken any calculus course before... 1/0! is the first term, 1/1! is the second term, and so on.

According to the summation notation that you've used, 1/0! actually seems to be the 0th term, not the first. I imagine this point is also what bothered msh210. I would personally recommend adding "N may be zero or one indexed" to your post.

No, it is not the zero-th term; simply because its a series. There is no zero-th term of a non-zero polynomial such as this

I personally despise it, but there are people who refer to the term at index 0 as zeroth term. Independently of our thoughts on that matter, the question should be as clear as possible. Also, a few test cases to verify that the solutions are working correctly, would be very helpful.

FWIW, it's quite easy to use this formula to calculate e to large numbers of digits without requiring bignum support. Eric Jensen first did this back in the mid 60s. Here is a Python 2 version I did a while ago.

Is there a way of calculating e which converges more quickly?

@Lembik there is another way, but it converges a bit slower: take the limit of (1+(1/n))^n as n approaches infinity and you'll obtain e. This calculation stems from compound interest, as it is the amount of money you will obtain after a year when the compoundings are calculated more and more often.

@Lembik There are several other approaches, I believe most continued fraction based approaches are better if designed well, as well as something like various brothers' formulae.

I improved formatting, feel free to rollback if you don't like it.

Jelly, 5 bytes
R’!İS

Try it online!
How it works
R’!İS  Main link. Argument: n

R      Yield the range [1, ..., n].
 ’     Map decrement over the list.
  !    Map factorial over the list.
   İ   Map inverse over the list.
    S  Compute the sum.

["Having a built-in for [1, n] makes more sense than having one for **0, n)** imho."

…and a month and a bit later, Jelly has Ḷ, which makes a [0, n) range. ^v^;

Wistful-C - 336 bytes
My first real wistful- program! There is actually a little golfing I did, with using someday instead of wait for because the first had a shorter length.
if only <stdio.h> were included...
if only int f were 1...
if only int N were 0...
wish for "%d",&N upon a star
if only int i were 0...
if only double e were 0...
someday i will be N...
        if only e were e+1./f...
        if only i were i+1...
        if only f were f*i...
*sigh*
wish "%f\n",e upon a star
if wishes were horses...

I was told that you don't need to include <stdio.h>

Does someday i were N... work instead of someday i will be N...?

Pyth, 7 6 bytes
smc1.!

Try it here.
 m      map over range 0..input:
    .!  factorial
  c1    1 / ^
s       sum

Thanks to FryAmTheEggman for a byte!

Julia 0.6, 28 27 21 bytes
n->sum(1./gamma(1:n))

Try it online!
This is an anonymous function that accepts an integer and returns a float. To call it, assign it to a variable.
The approach is quite straightforward. We sum 1 divided by the gamma function evaluated at each of 1 through n. This takes advantage of the property n! = Γ(n+1).
Saved 1 byte thanks to Dennis and 6 thanks to Glen O!

Almost exactly the same in MATLAB: @(n)sum(1./factorial(0:n))

TI-84 BASIC, 12 15 14
Input N
Σ(A!⁻¹,A,0,N

TI is a tokenized language (bytes are counted via tokens, not individual characters).

The cited meta post has 11 upvotes and 10 downvotes. That's not a consensus. Ans is not a valid input format, so only the 15-byte version is valid.

fair enough; editing...

Ans has always been the default input format here at PPCG (look through my old TI answers), and more people agree than disagree to that, so don't get bullied into changing your answer.

There's a simple way to resolve the dispute: Count the number of input bits instead of bytes. Now it's an apples-to-apples comparison of the amount of information.

@MickLH that's not the dispute here. Besides, these are 8-bit bytes.

@Timtech While I agree with you, community consensus is defined as Mego says.

Python, 36 bytes
Python 2:
f=lambda n,i=1:n/i and 1.+f(n,i+1)/i

Python 3:
f=lambda n,i=1:i<=n and 1+f(n,i+1)/i

Python 3 variant could be shorter with or instead of and: f=lambda n,i=1:i>=n or 1+f(n,i+1)/i.

dc, 43 bytes
[d1-d1<f*]sf[dlfx1r/r1-d1<e+]se1?dk1-d1<e+p

This is a fairly direct translation of the series.  I tried to be cleverer, but that resulted in longer code.
Explanation
[d1-d1<f*]sf

A simple factorial function, for n>0
[dlfx1r/r1-d1<e+]se

Execute the factorial for n,...,1; invert and sum
1?dk1-

Prime the stack with 1; accept input and set an appropriate precision
d1<e+

If input was 0 or 1, we can just pass it on, else compute the partial sum.
p

Print the result.
Test results
The first 100 expansions:
0
1
2
2.500
2.6666
2.70832
2.716665
2.7180553
2.71825394
2.718278766
2.7182815251
2.71828180110
2.718281826194
2.7182818282857
2.71828182844671
2.718281828458223
2.7182818284589936
2.71828182845904216
2.718281828459045062
2.7182818284590452257
2.71828182845904523484
2.718281828459045235331
2.7182818284590452353584
2.71828182845904523536012
2.718281828459045235360273
2.7182818284590452353602862
2.71828182845904523536028736
2.718281828459045235360287457
2.7182818284590452353602874700
2.71828182845904523536028747123
2.718281828459045235360287471339
2.7182818284590452353602874713514
2.71828182845904523536028747135253
2.718281828459045235360287471352649
2.7182818284590452353602874713526606
2.71828182845904523536028747135266232
2.718281828459045235360287471352662481
2.7182818284590452353602874713526624964
2.71828182845904523536028747135266249759
2.718281828459045235360287471352662497738
2.7182818284590452353602874713526624977552
2.71828182845904523536028747135266249775705
2.718281828459045235360287471352662497757231
2.7182818284590452353602874713526624977572453
2.71828182845904523536028747135266249775724691
2.718281828459045235360287471352662497757247074
2.7182818284590452353602874713526624977572470919
2.71828182845904523536028747135266249775724709352
2.718281828459045235360287471352662497757247093683
2.7182818284590452353602874713526624977572470936984
2.71828182845904523536028747135266249775724709369978
2.718281828459045235360287471352662497757247093699940
2.7182818284590452353602874713526624977572470936999574
2.71828182845904523536028747135266249775724709369995936
2.718281828459045235360287471352662497757247093699959554
2.7182818284590452353602874713526624977572470936999595729
2.71828182845904523536028747135266249775724709369995957475
2.718281828459045235360287471352662497757247093699959574944
2.7182818284590452353602874713526624977572470936999595749646
2.71828182845904523536028747135266249775724709369995957496673
2.718281828459045235360287471352662497757247093699959574966943
2.7182818284590452353602874713526624977572470936999595749669652
2.71828182845904523536028747135266249775724709369995957496696740
2.718281828459045235360287471352662497757247093699959574966967601
2.7182818284590452353602874713526624977572470936999595749669676254
2.71828182845904523536028747135266249775724709369995957496696762747
2.718281828459045235360287471352662497757247093699959574966967627699
2.7182818284590452353602874713526624977572470936999595749669676277220
2.71828182845904523536028747135266249775724709369995957496696762772386
2.718281828459045235360287471352662497757247093699959574966967627724050
2.7182818284590452353602874713526624977572470936999595749669676277240739
2.71828182845904523536028747135266249775724709369995957496696762772407632
2.718281828459045235360287471352662497757247093699959574966967627724076601
2.7182818284590452353602874713526624977572470936999595749669676277240766277
2.71828182845904523536028747135266249775724709369995957496696762772407663006
2.718281828459045235360287471352662497757247093699959574966967627724076630325
2.7182818284590452353602874713526624977572470936999595749669676277240766303508
2.71828182845904523536028747135266249775724709369995957496696762772407663035328
2.718281828459045235360287471352662497757247093699959574966967627724076630353518
2.7182818284590452353602874713526624977572470936999595749669676277240766303535449
2.71828182845904523536028747135266249775724709369995957496696762772407663035354729
2.718281828459045235360287471352662497757247093699959574966967627724076630353547565
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475915
2.71828182845904523536028747135266249775724709369995957496696762772407663035354759429
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594542
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945681
2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457111
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571352
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713792
2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457138185
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382143
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821752
2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457138217826
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178492
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785218
2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457138217852481
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525131
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251635
2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457138217852516607
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166394

Using 1000 terms:
2.7182818284590452353602874713526624977572470936999595749669676277240\
766303535475945713821785251664274274663919320030599218174135966290435\
729003342952605956307381323286279434907632338298807531952510190115738\
341879307021540891499348841675092447614606680822648001684774118537423\
454424371075390777449920695517027618386062613313845830007520449338265\
602976067371132007093287091274437470472306969772093101416928368190255\
151086574637721112523897844250569536967707854499699679468644549059879\
316368892300987931277361782154249992295763514822082698951936680331825\
288693984964651058209392398294887933203625094431173012381970684161403\
970198376793206832823764648042953118023287825098194558153017567173613\
320698112509961818815930416903515988885193458072738667385894228792284\
998920868058257492796104841984443634632449684875602336248270419786232\
090021609902353043699418491463140934317381436405462531520961836908887\
070167683964243781405927145635490613031072085103837505101157477041718\
986106873969655212671546889570350116

J, 10 bytes
[:+/%@!@i.

Straight-forward approach.
Explanation
[:+/%@!@i.    Input: n
        i.    Creates the range [0, 1, ..., n-1]
      !@      Maps factorial to each
    %@        Map 1/x to each
[:+/          Take the sum of the values and return it

Nice.  Trivial 1 byte improvement: 1#.%@!@i.

MATL, 11 7 bytes
:Ygl_^s

4 bytes saved thanks to @Luis's recommendation to use gamma (Yg)
Try it Online
Explanation
        % Implicitly grab input (N)
:       % Create an array from 1...N
Yg      % Compute factorial(x-1) for each element (x) in the array
l_^     % Take the inverse
s       % Sum all elements
        % Implicitly display the result

You can remove ]

Also, 1i:Yg/s for 7 bytes

@LuisMendo oh yea I was hoping there was a better way to get a factorial but I had forgotten about gamma. Will update shortly

JavaScript ES6, 44 42 40
n=>{for(k=s=m=1;m<n;s+=k/=m++);return s}

An unnamed function now.
Thanks for saving 2 bytes @AlexA and thanks to @LeakyNun for another 2 bytes!

n=>{for(k=s=m=1;m<n;s+=k/=m++);return s}

CJam, 11
r~,:m!Wf#:+

or
r~{m!W#}%:+

Try it online: first version and second version
Explanation:
r~ = read and evaluate
m! = factorial
W# = raise to the -1 power (W = -1)
:+ = sum of array
First version constructs the [0…N-1] array and applies factorial and inverse to all its elements; 2nd version does factorial and inverse for each number then puts them in an array.

MATL, 6 bytes
q_t1Zh

This computes the sum using the hypergeometric function 1F1(a;b;z):

Works on Octave and on the online compiler, but not on Matlab, due to a difference in how the hypergeometric function is defined (which will be corrected).
Try it online!
Explanation
q_    % Take N implicitly. Compute -N+1
t     % Duplicate
1     % Push 1
Zh    % Hypergeometric function 1F1(-N+1;-N+1;1). Implicitly display

C, 249 bytes
#include <stdio.h>
#include <stdlib.h>
#define z double
z f(z x){z r=1;z n=1;while(x>0){r*=n;n++;x--;}return r;}int main(int argc, char **argv){z e=0;z p=0;z d=0;p=strtod(argv[1],NULL);while(p>0){e+=1.0d/f(d);printf("%.10f\n",e);p--;d++;}return 0;}

Ungolfed:
/* approximate e */

#include <stdio.h>
#include <stdlib.h>

double fact(double x){
    double result = 1;
    double num = 1;

    while (x > 0){
        result *= num;
        num++;
        x--;
    }
    return result;
}

int main(int argc, char **argv){
    double e = 0;
    double precision = 0;
    double denom = 0;

    precision = strtod(argv[1], NULL);
    while (precision > 0){
        e += 1.0d / fact(denom);
        printf("%.10f\n", e);
        precision--;
        denom++;
    }
    return 0;
}

Takes a number as an argument to determine number of iterations.

Hello, and welcome to PPCG! Great first post!

Welcome to Programming Puzzles & Code Golf! I think the program is meant to print only the last approximation. At least with GCC, you don't need the int before main and the return 0. Also, if you replace NULL with 0, you don't need the includes. argc and argv can be shortened to single-letter variables. If you enjoy golfing in C, you might find Tips for golfing in C helpful.

IMHO, even if the compiler throws some warnings but returns the correct result nevertheless, you can throw away many parts of your code to the point that nothing could be reduced without an error.

And you don't need #include <stdio.h>

APL (Dyalog Unicode), 5 bytes
⍳⊥⊢÷!

Try it online!
Using the mixed base trick found in my answer of another challenge. Uses ⎕IO←0.
How it works
⍳⊥⊢÷!  Right argument: n, the number of terms
  ⊢÷!  v: 1÷(n-1)!
⍳      B: The array of 0 .. n-1
 ⊥     Expand v to length-n array V,
       then mixed base conversion of V in base B

Base | Digit | Value
--------------------
0    | v     | v×(1×2×..×(n-1)) = 1÷0!
1    | v     | v×(2×3×..×(n-1)) = 1÷1!
2    | v     | v×(3×..×(n-1))   = 1÷2!
..   | ..    | ..
n-2  | v     | v×(n-1)          = 1÷(n-2)!
n-1  | v     | v                = 1÷(n-1)!

10k rep! Now to see if I can pull this off in Turing Machine....

Nice answer but I'm having trouble seeing how 1÷(n-1)! is a digit?  Could you translate it into J to clarify?

Pyke, 10 bytes
FSBQi^R/)s

Try it here!
Or 8 bytes if power=1
FSB1R/)s

Try it here!

the first code was off by more than 3 when I ran it: 5.436532738095238

@tox123 fixed now

are you testing these? I got: 7.3887125220458545 for the first, the second works much better.

That one is an e^x one you know not just e

that's not the challenge.

It was when I wrote it - the challenge changed

k (13 bytes)
Subject to overflows for N>20
{+/%*\1,1+!x}

05AB1E, 6 bytes
$L<!/O

Explained
$           # push 1 and input: N = 5
 L<         # range [0..N-1]: [0,1,2,3,4]
   !        # factorial over range [1,1,2,6,24]
    /       # divide 1/range: [1.0, 1.0, 0.5, 0.16666666666666666, 0.041666666666666664]
     O      # sum: 2.708333333333333

Try it online

5 bytes with L<!zO.

Haskell, 37 bytes
((scanl(+)0$(1/)<$>scanl(*)1[1..])!!)

Not the shortest, but arguably the prettiest.

Also courtesy of Laikoni, here is a solution that is 2 bytes shorter:
sum.(`take`((1/)<$>scanl(*)1[1..]))

λ> let f = ((scanl (+) 0 $ (1/) <$> scanl (*) 1 [1..]) !!)

λ> map f [1..5]
[1.0,2.0,2.5,2.6666666666666665,2.708333333333333]

λ> f 10
2.7182815255731922

λ> f 100
2.7182818284590455

λ> log (f 10)
0.9999998885745155

λ> log (f 100)
1.0

Hello, and welcome to PPCG! This challenge is tagged [tag:code-golf], so please try to minimize the length of your code. Also, you need to post the byte count of your code. Otherwise, great post!

You can use this UTF-8 byte counter. I put in a suggested edit to add your byte count, which is 50. To add a header, use: ## Language, <xxx> bytes.

Do you need the whitespace?

You cannot assume the input to be present in a variable, so you need to prepend f n= or \n-> to get a valid function submission. However, we can also save a few bytes: (\x->1/x) can be shortened to the section (1/), [1,2..] is the same as [1..] and map(...)$ can be (...)<$>. Together 36 bytes: Try it online!

Converting to a point-free function saves another byte: Try it online! And even though it's a byte longer, ((scanl(+)0$(1/)<$>scanl(*)1[1..])!!) looks nice as well.

@Laikoni I like that one a lot! Removing the outer parentheses, it's 1 byte shorter than what I had. I edited my answer again.

Unfortunately the outer parenthesis cannot be removed because they are needed in order to haven an actual function instead of a code snippet.

As you have seen yourself the version without parentheses is only a valid Haskell expression when inserting a value after it, but as assuming the input to be present in a predefined variable is not allowed, you have to add the parentheses or again a leading \n-> to create a function.

@Laikoni I edited my answer yet once again. I included the parentheses and gave you credit for the improvements. In fact, at this point, I am temped to suggest that I delete my answer and you post my answer under your name, for you did all the non-trivial work.

Thanks for the credit! However I would not want post this answer myself as I'd likely would not have thought of it without seeing your answer before. Besides, the culture of helping each other to improve their answers is one of the aspects I enjoy most on this site.

Dyalog APL, 6 bytes
+/÷!⍳⎕

+/ sum of
÷ the reciprocals of
! the factorials of
⍳ the numbers from 0 to
⎕ numerical input
Assumes ⎕IO←0, which is default on many systems.
TryAPL!

JavaScript (ES6), 28 bytes
f=(n,i=1)=>n&&1+f(n-1,i+1)/i

Raku, 21 19 bytes
{1+sum [\/] 1..^$_}

Try it online!
-2 bytes thanks to Jo King
[\/] performs a "triangular reduction" (or "scan") using the division operator over the sequence 1, 2, ..., $_-1 (where $_ is the argument to the function).  So for example [\/] 1..4 is the sequence 1, 1/2, 1/2/3, 1/2/3/4, which are the terms required for the n = 5 case.

jq, 25 bytes
[range(.)+1|1/tgamma]|add

Try it online!
jq currently only has IEEE754 double-precision (64-bit) floating point number support, luckily it works in its favour here.

Actually, 6 bytes
r♂!♂ìΣ

Try it online!
Explanation:
r♂!♂ìΣ
r       range(N) ([0, N-1])
 ♂!     factorial of each element
   ♂ì   reciprocal of each element
     Σ  sum

Brachylog, 18 bytes
:1-:0r:ef:$!a:/a+.

Explanation
:1-                 Subtract 1 from Input
   :0r              Create the list [0, Input - 1]
      :ef           Find all integers between 0 and Input - 1
         :$!a       Apply factorial to each member of that list
             :/a    Apply inverse to each element of that list
                +.  Unify the output with the sum of the list

Java with Ten Foot Laser Pole, 238 236 bytes
import sj224.tflp.math.*;interface U{static void main(String[]a){BigRational r=null,s,t;r=s=t=r.ONE;for(int n=new java.util.Scanner(System.in).nextInt()-1;n-->0;){t=t.multiply(r);s=s.add(t.pow(-1));r=r.add(r.ONE);}System.out.print(s);}}

Has much better overflow resistance than most of the other answers. For 100 terms, the result is
31710869445015912176908843526535027555643447320787267779096898248431156738548305814867560678144006224158425966541000436701189187481211772088720561290395499/11665776930493019085212404857033337561339496033047702683574120486902199999153739451117682997019564785781712240103402969781398151364608000000000000000000000

Maple, 18
add(1/i!,i=0..n-1)

Usage:
> f:=n->add(1/i!,i=0..n-1);
> f(1);
  1
> f(4);
  8/3

I think the function is n->add(1/i!,i=0..n-1)

C, 69 bytes
double f(int n){double s=1,f=1;for(int i=0;i++<n;s+=f)f/=i;return s;}

Ideone it!

Julia 0.6, 28 bytes
~k=k<1?1:1/gamma(k+1)+~(k-1)

Try it online!
Explanation
~k=                    #Define ~ to be
    k<1                #If k is less than 1
        ?1             #to be one
        :1/gamma(k+1)  #else add the reciprocal factorial to
            +~(k-1)    #the function applied to the predecessor value

gamma(k+1) is equal to factorial(k) for positive integer inputs, and generalizes it for all values other than the nonnegative integers. It saves one byte, so why not use it?

PowerShell Core, 51 43 bytes
param($a)++$p..$a-ge1|%{$s+=$p/=$_}
$s+!!$a

Try it online!
-6 bytes thanks to mazzy!
-2 bytes thanks to Zaelin Goodman!

Try it online?

Cool approach @mazzy! It doesn't work for n=0, though, I added a special case for it

43 bytes?

Thunno 2 S, 3 bytes
LwỊ

Try it online!
Explanation
LwỊ  # Implicit input
L    # Lowered range
 w   # Factorial
  Ị  # Reciprocal
     # Sum
     # Implicit output

MATLAB / Octave, 22 bytes
@(x)sum(1./gamma(1:x))

Creates an anonymous function named ans that can be called using ans(N).
This solution computes gamma(x) for each element in the array [1 ... N] which is equal to factorial(x-1). We then take the inverse of each element and sum all elements.
Online Demo

Perl 5, 37 bytes
Not a winner, but nice and straightforward:
$e=$p=1;$e+=1/($p*=$_)for 1..<>;say$e

Outputs for inputs from 0 to 10:
1
2
2.5
2.66666666666667
2.70833333333333
2.71666666666667
2.71805555555556
2.71825396825397
2.71827876984127
2.71828152557319
2.71828180114638

R, 17 bytes
sum(1/gamma(1:n))

Quite straightforward, although numerical precision issues are bound to arise at some point in time.

WolframAlpha, 12 bytes
sum1/k!,0..n

F#, 87 bytes
let rec f x=if x<2 then 1 else f(x-1)*x
let e N=Seq.sumBy(fun x->1./float(f x)){0..N-1}

Try it online!
A direct implementation of the Maclaurin expansion. Unfortunately over 35 terms the denominator is too small, so the sum becomes infinity.

Stax, 5 bytes
òo⌠├p

Run and debug it
Produces output as a fraction.

cQuents, 7 bytes
;1/f_-$

Try it online!
Explanation
;           Series - output sum of first n terms in sequence
            Each term is
 1/                      1 /
   f   )                     factorial (           )
    _-                                         - 1
      $                                  index

JavaScript (ES6), 44 bytes
n=>{for(a=d=i=1;i<=n;a+=1/d)d/=i++;return a}

Ruby, 43 42 bytes
-1 byte by calculating using Rational instead of Float.
->n{(0..n).sum{|i|1/(1..i).reduce(1r,:*)}}

Try it online!

Mathematica, 26 bytes
Sum[1/n!,{n,0,Input[]}]//N

Pretty straight forward: takes the sum of the inverse of n factorial, with n starting from 0 and all the way to the desired number.
The //N is used to give an approximate value of the fraction yielded by the sum.
The code can be checked online , for free, via the wolfram programming labs:
Wolfram Labs

Welcome to the site, and nice first answer! I've edited your post ever so slightly to improve clarity and to format it in the standard manner for answers on the site (# <language name> rather than ** <language> **)

@cairdcoinheringaahing Thank you very much! I appreciate!

k4, 16 15 bytes
{+/%*/'1_',\!x}

{             } / lambda
            !x  / enumerate x; (!4 -> 0 1 2 3)
          ,\    / join scan; joins successive elements and returns intermediate results (,0;0 1;0 1 2;0 1 2 3)
       1_'      / 1 drop each; drops leading 0s (();,1;1 2;1 2 3)
    */'         / multiply over each; 1 1 2 6
   %            / reciprocal; 1 1 0.5 0.1666667
 +/             / sum

Wren, 81 bytes
Fn.new{|N|
var e=0
for(i in 1..N)e=e+1/(1..i).reduce{|a,b|a*b}
return e+1
}

Try it online!

Keg -rr, 18 15 bytes
11(¿|:¡1$/"+"1+

Try it online!
This took a whole bunch of fiddling to figure out. It works!!

05AB1E, 5 bytes
L<!zO

Try it online!
L<!zO  # full program
    O  # sum of...
   z   # 1 divided by...
  !    # factorial of...
       # (implicit) each element in...
L      # [1, 2, 3, ...,
       # ..., implicit input...
L      # ]...
       # (implicit) with each element...
 <     # decremented
       # implicit output

Husk, 5 bytes
ṁo\Πŀ

Try it online!
Calculates the sum of the series as a rational number: TIO header converts this to 9 decimal digits (with an implicit point after the first digit).

Vyxal, s, 3 bytes
ʁ¡Ė

Try it Online!
Explanation:
     # Implicit input
ʁ    # Range [0, N)
 ¡   # Map factorial over all elements
  Ė  # Map inverse over all elements
     # 's' flag: cumulative sum top of stack and output

you have the 's' flag in the title but say the 'd' flag is a cumulative sum, which one are you using?

@ZippyMagician Whoops, my bad. I had tried d first, but s was needed. I forgot and put the wrong flag in the explanation. Fixed.

Dammit, I was just about to post this!

Arn -Rmx, 3 bytes
1/f

This can hypothetically be infinitely precise with a large input and the use of the -p, -o, and --stack arguments, as Arn makes use of arbitrarily-precise floating point numbers. Compression doesn't save any bytes here.
Explained
-R transforms input from N to the range [0, N).
-m maps the program over the input
1/      Reciprocal of
   f   The factorial function in the global scope (takes `_`)

-x then sums the result
Arn (less boring), 10 bytes uncompressed
+{1/f}\0->

Same concept but without the flags. This is probably 7-8 bytes compressed, but I'm not at my computer right now and so can't check.

Surely this is compressible somehow. 5 bytes feels way too long.

1.1 makes it 4 bytes, so it’s possible that can be compressed to 3. It’s really hit and miss when it comes to the text compression.

Ruby, 33 bytes
Returns a rational number. If the we can use 0-indexing, ... can be shortened to ...
->n{[k=1,*1...n].sum{|j|1r/k*=j}}

Try it online!

I believe you can change 1r/k*=j into k/=j, and set k=1r at the start.

asm2bf, 133 bytes
Requires a 16-bit interpreter, at least 64 tape cells, integer i/o. This all is faciliated using bfi -d bundled with asm2bf. Fairly slow, overflows at n=6. Takes n in r4. Outputs the result due to a meta consensus.
?A=popr1/outr1
@z incr3
psh1
dup
@a movr2,r3
movr1,1
@b cltr2,2
cjn%c
mulr1,r2
decr2
jmp%b
@c pshr1
psh1
fad
incr3
cltr3,r4
cjn%a
A
A

Example usage:
mov r4, 5
jmp %z

Deobfuscated:
inc r3
push 1
push 1
@mloop
    mov r2, r3
    mov r1, 1
@loop
    clt r2, 2
    cjnz %done
    mul r1, r2
    dec r2
    jmp %loop
@done
    push r1
    push 1
    fadd
    inc r3
    clt r3, r4
    cjnz %mloop
pop r1
out r1
pop r1
out r1

Bonus: optimized brainfuck code:
>>>>>>+++++<+>>>>>>>>>>>>+[<<<<+>>>>>>>[>>]>+<<<[<<]<-]<<<<[>>>>+<<<<-]>>>>>>>[>
>]+[<<]<[<<<<+>>>>>>>[>>]>+<<<[<<]<-]<<<<[>>>>+<<<<-]>>>>>>>[>>]+[<<]<<<<[-]+[<<
<<<<<<<<[-]>[<+<<+>>>-]<<<[>>>+<<<-]>[-]+>>>>>>>>>>>[-]+[<<<<<<<<<<<[<<+>>-]<<[>
>>[<+<+>>-]<<[>>+<<-]<-]>>>->>>++>>>>>>>[-]+<<<<<<<<<<[>>>>>>>+<<<<<<<-]>>>[>>>+
<<<-]>>>[<<<<<<+>>>+>>>>[-<]>]<<[>>>>-<<<<<<<<<<->>>>>>-[<<<+>>>-]<<]>>>[<<<<<<<
+>>>>>>>-]<<<<[-]>>>>>>>]<<<<<<<<<<<[>>>>>>>>>>+>>>>>>>[>>]>+<<<[<<]<<<<<<<<<<<<
<<<-]>>>>>>>>>>[<<<<<<<<<<+>>>>>>>>>>-]>>>>>>>[>>]+[<<]<[<<<<+>>>>>>>[>>]>+<<<[<
<]<-]<<<<[>>>>+<<<<-]>>>>>>>[>>]+[<<]>>[>>]<<-<[<<<<->+>>>-]<-<<-<[>[<+>>>>+<<<-
]>[<+>-]<[>>>[<<+>+>-]<[>+<-]<<-]<[>+<-]>>>>>>[<<<<<[<+>>+<-]<[>+<-]>>>>>>-]<<[<
<<[<+>>>+<<-]>>[<<+>>-]>-]]<[>>[<+>-]>>>>>[<<<<+>>>>-]<<<]<<[-]+[<<]<<<<<<<<<<<[
-]<<+>>>>>>>>>[-]<<<<<<<<<[>>>>>>+<<<<<<-]>[>>>>+<<<<-]>>>>[<<<<<+>+>>>>>[-<]>]<
<[>>>>+<<<<<<<<<->>>>>-[<<<<+>>>>-]<<]>>>[<<<<<<+>>>>>>-]>>>]>>>[-]>>>[>>]<<->[<
<<[<<]<+>>>[>>]>-]<<<[<<]<.[-]>>>[>>]<<->[<<<[<<]<+>>>[>>]>-]<<<[<<]<.

To change the output, tweak the first block of +.

Java (JDK)
note that you can get better results faster by increasing the precision of MathContext. This would take up one more byte per power of 10 though. This is why I decided to leave it at 9
If you need to include the import java.math.*; that would add another 19 bytes.
Using BigDecimals: 241 bytes
static BigDecimal c(int n){var o=BigDecimal.ONE;var c=o;for(int i=0;i++<n;)o=o.add(c.divide(f(o.valueOf(i)),new MathContext(9)));return o;}static BigDecimal f(BigDecimal n){var o=n.ONE;return n.compareTo(o)<1?o:f(n.subtract(o)).multiply(n);}

Try it online!
Using primitive Number types: 119 bytes
static double c(int n){double v=0;for(int i=0;i<n;)v+=1/f(i++);return v;}static double f(int n){return n<2?1:f(n-1)*n;}

Try it online!
Explanation:
    static double c(int n){
        double v=0;               // value for e
        for(int i=0;i<n;)         // for n-iterations
            v+=1/f(i++);          // add the inverse
                                  // of the factorial
        return v;                 // return value
    }

    static double f(int n){
        return n<2?1:f(n-1)*n;    // recursively calculates the factorial
    }

Nekomata, 4 bytes
rFŗ∑

Attempt This Online!
rFŗ∑
r       Range
 F      Factorial
  ŗ     Reciprocal
   ∑    Sum

x86-64 machine code, 23 bytes
Expects \$n\$ in rcx and leaves the result of the approximation in st0. The FPU stack is assumed to be empty upon subroutine entry, and only has one value—the result—in it on exit.
Clobbers rcx, the FPU stack and flags, and FLAGS.
d9 e8 d9 e8 d9 e8 eb 0a d9 c1 de c3 d9 e8 de c1 dc f9 e2 f4 da e9 c3

Try it online!
Explanation
The algorithm is essentially the same as @Leaky Nun's answer, just ported to x64 assembly.
func:
    fld1 ; load sum to st2 (constant 1.0)
    fld1 ; load term to st1 (constant 1.0)
    fld1 ; load termdiv to st0 (constant 1.0)

    ; first term counts in rcx dec/check too
    jmp func_do_chk

func_loop:
    ; sum += term
    fld st1
    faddp st3, st0

    ; termdiv += 1.0
    fld1
    faddp

    ; term /= termdiv
    fdiv st1, st0

    ; loop back up
func_do_chk:
    loop func_loop

    ; dump st0 and st1 to get sum into st0
    fucompp
    ret

Go, 85 84 bytes
import."math"
func f(n float64)(S float64){for i:=1.;i<=n;i++{S+=1/Gamma(i)}
return}

Attempt This Online!

84 bytes

Factor + math.factorials math.unicode, 27 bytes
[ iota [ n! -1 ^ ] map Σ ]

Try it online!
Explanation:
It's a quotation (anonymous function) that takes an integer from the data stack as input and leaves a ratio approximation of e on the data stack as output.

iota Create a range from 0 to the input where the input itself is excluded.
[ ... ] map Apply a quotation to each element of a sequence, collecting the results into a new sequence of the same length.
n! Take the factorial.
-1 ^ Take the reciprocal. Shorter than 1 swap / and recip.
Σ Sum a sequence.

Swift, 71 bytes
print(Set(0...n).reduce(0){$0+1/Float(Set(1...max(1,$1)).reduce(1,*))})

Try it online!

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:
Stack Exchange Vote Counter
Write a program/function that returns the vote count of its own Stack Exchange answer at the time of its execution.

Your program/function may access this page (codegolf.stackexchange.com/questions/82609) off the internet, however:
Your program/function may not accept any user input and
The use of URL shorteners is not allowed
Your program/function may use only its own source as a reference point to its vote count (for example: no referencing strings of text in its contained answer but not in its own source)
Your program/function must output its own vote count and only its own vote count (for example: no returning all vote counts on this page)

This is code-golf, shortest code wins.

perl -e'($_)=`curl -s http://api.stackexchange.com/2.2/posts/123?site=codegolf`;/score":(\d+)/&&print$1' looks like it should work, but doesn't. But maybe someone can use that.

To everyone else who's trying and failing to use the API: It serves the response gzip encoded, even if the client does not support it.

"Your program/function may use only its own source as a reference point to its vote count" Is a bit confusing. Does this mean that answers should try to identify themselves only using knowledge of their own code, and not through something like a post id? I don't think that such a rule would be good, as it can be broken by anyone else posting a new answer.

@FryAmTheEggman I did put a bit of thought into breaking other peoples answers, and I even considered making this a KOTH where your source tries to undermine another answer, although in the end that seemed to be pushing the format more than I wanted... I added the using its own source bit to prevent users from setting up the page to make it easier to find itself without contributing to its byte count, in the case that the answer doesn't use the post id method.

Alright, the wording is a bit weird. I would recommend instead of allowing certain behaviour in this way, instead directly ban using any web services besides those supplied by stackexchange (unless I've misunderstood you). As a side note, due to the nature of the completeness problem, it is not possible to make something like this unbreakable. The best you can do is make it implausible to be broken.

I don't get it. The question states to only use the page contents at codegolf.stackexchange.com/questions/82609 as a reference. Yet everyone appears to be using the api at api.stackexchange.com. What am I missing?

Are you going to accept an answer? (I want the badge about 2x outvoting the accepted answer, which is Dennis's convex one)

@Dendrobium: I had developed an noncompeting answer that was a cousin to your KOTH idea, and I can't recommend going that route.  Mine flopped miserably and was mod deleted for this and other reasons (as it should have been).  Rather than undermining an answer, it went the other way and was self-deprecating while it complimented whichever author and answer was currently in the lead.  This still had potential to influence votes and cause confusion if anyone had taken it seriously.

Please accept an answer. It has been quite a while.

Bash, 5 bytes ‘echo 0’

jQuery + JavaScript, 85 bytes

$.get("//api.stackexchange.com/posts/82610?site=codegolf",d=>alert(d.items[0].score))

History

-6 bytes because I was using the var data instead of d.
-3 bytes thanks to @msh210
-13 bytes thanks to @CᴏɴᴏʀO'Bʀɪᴇɴ
-4 bytes thanks to @user6188402
-5 bytes thanks to @Suever
-4 bytes thanks to @RobW

Recommended usage

Run snippet.
Upvote.
Run snippet, and be amazed as the number magically increases.

Bonus!!
Who doesn't like a bonus?

$.getJSON("//api.stackexchange.com/posts/" + prompt() + "?site=codegolf",d=>alert(d.items[0].score));

Enter the ID into the bonus and it will tell you the score.
Even more bonus!! Run this snippet to automatically run the program, upvote, and run again! (Requires rep > 15, auth). If it doesn't work, please tell me.

posts instead of answers and http instead of https saves three bytes (or perhaps you can omit http: altogether?). (Untested.)

Also, try d=>alert(d.items[0].score)

You can use http:// and it will 301 redirect to https:// Better yet, just remove the http altogether //api.stackexchange.com...

jQuery is not a language, neither an inbuilt library in JS. So if you are using that, include the byte count of jQuery in your score too.

@Optimizer: This is the proper way to do it: consider JS + jQuery to effectively be its own "language". See this meta post: http://meta.codegolf.stackexchange.com/a/9279/12914

@El'endiaStarman I don't really see a conclusion to that. It need more answers or more discussion on the existing answer to really call it "proper way"

Use $.get instead of $.getJSON. The API's content type is application/json, and jQuery will automatically treat the response as JSON.

Doesn't work if you are using HTTP instead of HTTPS.

I got: {
"message": "Uncaught SyntaxError: Unexpected token )",
"filename": "http://stacksnippets.net/js",
"lineno": 18,
"colno": 74
} working with chrome

Doesn't this answer violate the very first rule of the question?

-1 not enough jQuery.

@programmer5000 Did you really downvote? Vote as you see fit, but this is 100% jQuery. $ is an alias of jQuery, and the main body of my post is a call to $.post.

JavaScript ES6, 107 bytes

fetch`//api.stackexchange.com/posts/82672?site=codegolf`.then(r=>r.json()).then(b=>alert(b.items[0].score))

Real programmers don't use XMLHttpRequest. Real programmers use the Fetch API.

Well... you got me there. I never knew about this API!

I'm getting an error that fetch isn't defined

@PythonMaster The Fetch API is not yet available in all browsers: http://caniuse.com/#feat=fetch

Bash, 80 79 75 69 bytes
w3m api.stackexchange.com/posts/82616?site=codegolf|tr ,: \\t|cut -f20

For scoring purposes, \t should be replaced with a TAB character.
This requires w3m, which should be available by default on most Linux distros.
Thanks to @NoOneIsHere for -2 bytes!
How it works
w3m is a command-line web browser. It queries the URL and (normally) displays its content in a readable format. Here, we just (ab)use it to avoid the call to zcat that curl would require, since SE serves the API response gzip-compressed.
tr ,: \^I replaces all commas and colons with tabs, which are cut's default field delimiter.
Finally, cut -f20 removes everything but the twentieth field, which is the vote count.

Or --compressed, which is even longer than zcat.

JavaScript ES6, 175 165 160 145 bytes
Saved lotsa bytes thanks to Optimizer and Dendrobium! They're all multiples of five!
Using plain ol' javascript. Who needs those newfangled libraries? Real programmers use XMLHttpRequest()
with(new XMLHttpRequest)send(open("get","//api.stackexchange.com/posts/82614?site=codegolf"),onload=_=>alert(response.match(/re..([0-9]+)/)[1]))

Test it out

alert=x=>o.innerHTML=x;

with(new XMLHttpRequest)send(open("get","//api.stackexchange.com/posts/82614?site=codegolf"),onload=_=>alert(response.match(/re..([0-9]+)/)[1]))
*{font-family:Consolas,monospace;}

@Optimizer Thanks! But why use prompt?

@Optimizer For some reason, "g" doesn't work as an option for me.

with(new XMLHttpRequest)(open("get","//api.stackexchange.com/2.2/posts/82614?site=codegolf"),onload=_=>alert(response.items[0].score),send(responseType="json")) for -5 bytes

@Dendrobium Oh, nice one. I forgot about with

@Optimizer I get TypeError: response.split(...)[12] is undefined",

@CᴏɴᴏʀO'Bʀɪᴇɴ Expanding on @Optimizer's suggestion, with(new XMLHttpRequest){open("get","//api.stackexchange.com/2.2/posts/82614?site=codegolf");send(onload=_=>alert(response.split\:`[12].split`,`[0]))}` for -10 bytes

with(new XMLHttpRequest)send(open("get","//api.stackexchange.com/posts/82614?site=codegolf"),onload=_=>alert(response.match(/re..([0-9])/)[1])) for 143 bytes

with(new XMLHttpRequest)send(open("get","//api.stackexchange.com/posts/82614?site=codegolf"),onload=_=>alert(response.match(/\d+/g)[25])) 137

You can shave off some bytes by using synchronous XMLHttpRequest. The regexp can be shortened using exec instead of match and a look-ahead (so that the result is an array of size 1, so you don't need [1]. This works as long as you don't change your display name to end with a digit: with(new XMLHttpRequest)send(open("get","//api.stackexchange.com/posts/82614?site=codegolf",0)),alert(/\d+(?=,"l)/.exec(response)) 130

bash+jq, 69 bytes
w3m api.stackexchange.com/posts/82615?site=codegolf|jq .items[].score

I used curl and zcat before; w3m is inspired by Dennis’s (strikingly similar) answer. It turns out jq and tr/cut have the same byte cost!

Convex 0.5, 63 bytes
0000000: 22 d1 2e 46 91 32 e5 69 5d b2 66 81 12 a4 8d d1  "..F.2.i].f.....
0000010: 27 40 b5 32 47 68 97 2c b9 5c 22 05 16 49 10 31  '@.2Gh.,.\"..I.1
0000020: 44 9e f3 0a 6a 16 b0 68 91 93 35 0b 96 dc 91 0a  D...j..h..5.....
0000030: 3c 18 80 22 dc 67 27 3c 2f 32 36 39 3d 37 3e     <..".g'</269=7>

This retrieves the score from the search page instead of the API, specifically from the query https://codegolf.stackexchange.com/search?q=inquestion:82714. Fortunately, inquestion also works for answers.
Verification
$ echo $LANG
en_US
$ cat gen.convex
"codegolf.stackexchange.com:80/search?q=inquestion:82714"Ö`"Üg'</269=7>"
$ java -jar Convex/out/builds/convex-0.5/convex/convex.jar gen.conv > count.conv
$ cksum count.conv
2414634109 63 count.conv
$ java -jar Convex/out/builds/convex-0.5/convex/convex.jar count.conv
1

How it works
"..."Ü           e# Use the built-in string compression to push
                 e# "codegolf.stackexchange.com:80/search?q=inquestion:82714".
      g          e# Retrieve the HTML page at that URL.
       '</       e# Split at occurrences of '<'.
          269=   e# Select the chunk at index 269.
                 e# This pushes "strong>", followed by the vote count.
              7> e# Discard the leading seven characters.

This is amazing. How did you even know that this language can do this?

It's a CJam fork. I originally wrote my answer in CJam (67 bytes), but then I remembered that Convex has built-in string compression.

05AB1E, 89 87 81 bytes
Thanks Python...
•1Ö8•D’£Ø ˆå§¾.‡¢ as g;#.¾¿„–(g.ˆåƒÛ('·Ç://ƒËŠˆ.Â‚‹º.ŒŒ/…é/ÿ/').‚Ø())’.er¡14èžz£þ

Uses the CP-1252 encoding.

MATLAB, 103 bytes
g=@getfield;g(g(webread('http://api.stackexchange.com/2.2/posts/82611?site=codegolf'),'items'),'score')

JavaScript (Node.js), 166 Bytes
-1 byte because @CᴏɴᴏʀO'Bʀɪᴇɴ taught me how to count ;)
-4 bytes thanks to @NoOneIsHere
require("http").get("http://api.stackexchange.com/posts/82620?site=codegolf",a=>a.on("data",d=>console.log(JSON.parse(require("zlib").gunzipSync(d)).items[0].score)))

This is somewhat embarrassing. Dang you SE for gzipping your API! /s
Any improvements are very welcome.

Julia, 128 107 bytes
using Requests
f()=split(readall(get("http://api.stackexchange.com/posts/82621?site=codegolf")),r":|,")[20]

This is a function that takes no input and returns the score of this post as a string. It requires the Requests package to be installed.
How it works:

get makes a GET request to the SE API
readall reads the raw bytes in the response and returns a string
split splits the string at colons and commas
The 20th element of the resulting array is the score of the post

Saved 21 bytes thanks to Dennis!

JavaScript (Node.js + Unirest), 123 bytes
require("unirest").get("http://api.stackexchange.com/posts/82683?site=codegolf").end(x=>console.log(x.body.items[0].score))

I like this library, because it automatically parses JSON.

PHP, 137 bytes
Pretty straight forward. The uncompressing takes a lot of bytes:
<?=json_decode(gzinflate(substr(file_get_contents('http://api.stackexchange.com/2.2/posts/82619?site=codegolf'),10)),1)[items][0][score];

Ungolfed
print
  json_decode(
    gzinflate(
      substr(
        file_get_contents('http://api.stackexchange.com/2.2/posts/82619?site=codegolf'),
        10
      )
    ),
    1
  )
  [items][0][score];

Note that join(file( can be used to shorten file_get_contents( ;)

PHP, 121 bytes
Without api.
<?php preg_match('/t ">(.*)/',file_get_contents('http://codegolf.stackexchange.com/posts/82799/ajax-load'),$v);echo$v[1];

Gets the whole post and extracts the vote counts with regex. (don't parse HTML with regex!)
Ungolfed:
<?php
   preg_match('/t ">(.*)/',
              file_get_contents('http://codegolf.stackexchange.com/posts/82799/ajax-load'),
              $v);

   echo $v[1];

Can you remove http:?

@NoOne No, doesn't appear to work then.

Note that join(file( can be used to shorten file_get_contents( ;)

05AB1E, 45 bytes
•2íÐ•’¸¸.Â‚‹º.ŒŒ/„¤/ÿ?€¼=ƒËŠˆ’žYì.w'ŒÂ¡θ',¡нþ

No TIO for the entire program, because the .w builtin to access the internet doesn't work on TIO.
Explanation:
We start by creating the url, and accessing it:
•2íÐ•       # Push compressed integer 190437 (the id of this answer)
  ’¸¸.Â‚‹º.ŒŒ/„¤/ÿ?€¼=ƒËŠˆ’
            # Push dictionary string "api.stackexchange.com/posts/ÿ?site=codegolf",
            # where the `ÿ` is automatically filled with the 190437
    žY      # Push builtin "https://"
      ì     # And prepend it in front of the string
.w          # Go to this website, and get all its contents

Try it online (without the .w).
After that, we extract the score from the JSON:
'ŒÂ        '# Push dictionary string "score"
   ¡        # Split the website content on this
    θ       # Only leave the last item (of the two)
     ',¡   '# Split this string on ","
        н   # And this time leave the first item (i.e. `":10`)
         þ  # Only leave the digits of this string
            # (which is output implicitly as result)

Try it online.
An equal 10-bytes alternative for this second part could be:
„ŒÂ‚¡       # Push dictionary string "score after"
     #      # Split it on spaces: ["score","after"]
      ¡     # Split the website content on these
       Ås   # Only leave the middle element
         þ  # Only leave the digits of this string
            # (which is output implicitly as result)

Try it online.
See this 05AB1E tip of mine (sections How to use the dictionary? and How to compress large integers?) to understand why •2íÐ• is 190437, ’¸¸.Â‚‹º.ŒŒ/„¤/ÿ?€¼=ƒËŠˆ’ is "api.stackexchange.com/posts/ÿ?site=codegolf", 'ŒÂ is "score", and „ŒÂ‚¡ is "score after".
PS/EDIT: I realize that by using the þ I assume I will never get a negative score. ;)

-3 without žYì.

@Makonede I'm using https instead of http here. Nice tip regardless, though. I will definitely keep this in mind, and it might potentially golf some of my other answers.

http should work just fine though, no?

Google Sheets, 87 bytes
=Mid(Index(ImportData("http://api.stackexchange.com/posts/203609?site=codegolf"),7),7,9

Sheets will add the trailing parentheses automatically.
ImportData will treat the result as a CSV and split the text into columns.
Index(~,10) pulls the 10th entry from that split result.
Mid(~,12,99) starts at the 7th character and pulls up to the next 9.
So long as the score doesn't get to 10^9, this will work fine.
Here's a screenshot showing the three steps:

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:
Dot Product of Diagonals
This challenge is very simple. You are given as input a square matrix, represented in any sane way, and you have to output the dot product of the diagonals of the matrix.
The diagonals in specific are the diagonal running from top-left to bottom-right and from top-right to bottom-left.
Test Cases
[[-1, 1], [-2, 1]]  ->  -3
[[824, -65], [-814, -741]]  ->  549614
[[-1, -8, 4], [4, 0, -5], [-3, 5, 2]]  ->  -10
[[0, -1, 0], [1, 0, 2], [1, 0, 1]]  ->  1

Jelly, 8 6 bytes
×UŒDḢS

Try it online! or verify all test cases
How it works
×UŒDḢS  Main link. Argument: M (matrix)

 U      Upend M, i.e., reverse each row.
,       Pair M and upended M.
  ŒD    Yield all diagonals.
    Ḣ   Head; extract the first, main diagonal.
     S  Reduce by sum.

MATL, 8 bytes
t!P!*Xds

Input format is
[-1, -8, 4; 4, 0 -5; -3, 5, 2]

Try it online! Or verify all test cases.
Explanation
t       % Take input matrix implicitly. Duplicate
!P!     % Flip matrix horizontally
*       % Element-wise product
Xd      % Extract main diagonal as a column vector
s       % Sum. Display implicitly

APL (Dyalog), 15 9 bytes
+/1 1⍉⌽×⊢

Try it online!
How?
+/ - sum
1 1⍉ - diagonal of
⌽×⊢ - element wise multiplication of the matrix with it's reverse

J, 21 19 bytes
[:+/(<0 1)|:(*|."1)

Straight-forward approach.
Saved 2 bytes thanks to @Lynn.
Usage
The input array is shaped using dimensions $ values.
   f =: [:+/(<0 1)|:(*|."1)
   f (2 2 $ _1 1 _2 1)
_3
   f (2 2 $ 824 _65 _814 _741)
549614
   f (3 3 $ _1 _8 4 4 0 _5 _3 5 2)
_10
   f (3 3 $ 0 _1 0 1 0 2 1 0 1)
1

Explanation
[:+/(<0 1)|:(*|."1)    Input: matrix M
              |."1     Reverse each row of M
             *         Multiply element-wise M and the row-reversed M
    (<0 1)|:           Take the diagonal of that matrix
[:+/                   Sum that diagonal and return it=

[:+/(<0 1)|:(*|."1) is 19 bytes

Julia, 25 bytes
~=diag
!x=~x⋅~rotl90(x)

Try it online!

rot90, good idea!

Python, 47 bytes
lambda x:sum(r[i]*r[~i]for i,r in enumerate(x))

Test it on Ideone.

JavaScript (ES6), 45 bytes
a=>a.reduce((r,b,i)=>r+b[i]*b.slice(~i)[0],0)
a=>a.reduce((r,b,i)=>r+b[i]*b[b.length+~i],0)

R, 26 bytes
sum(diag(A*A[,ncol(A):1]))

Mathematica, 17 bytes
Tr[#~Reverse~2#]&

Clojure, 57 bytes
#(apply +(map(fn[i r](*(r i)(nth(reverse r)i)))(range)%))

Haskell, 80 48 bytes
I liked my previous solution more, but this is much shorter (basically does the same as the Python solution):
f m=sum[r!!i*r!!(length m-i-1)|(i,r)<-zip[0..]m]

Try it online!

J, 18 Bytes
<:@#{+//.@:(*|."1)

Explaination:
           (     ) | Monadic hook
            *      | Argument times...
             |."1  | The argument mirrored around the y axis
     +//.@:        | Make a list by summing each of the diagonals of the matrix
    {              | Takes element number...
<:@#               | Calculates the correct index (size of the array - 1)

05AB1E, 5 bytes
í*Å\O

Try it online or verify all test cases.
Explanation:
í        # Reverse each row of the (implicit) input-matrix
         #  i.e. [[-1,-8,4],[4,0,-5],[-3,5,2]] → [[4,-8,-1],[-5,0,4],[2,5,-3]]
 *       # Multiply it with the (implicit) input-matrix (at the same positions)
         #  i.e. [[-1,-8,4],[4,0,-5],[-3,5,2]] and [[4,-8,-1],[-5,0,4],[2,5,-3]]
         #   → [[-4,64,-4],[-20,0,-20],[-6,25,-6]]
  Å\     # Get the diagonal-list from the top-left corner towards the bottom-right
         #  i.e. [[-4,64,-4],[-20,0,-20],[-6,25,-6]] → [-4,0,-6]
    O    # Sum it (and output implicitly)
         #  i.e. [-4,0,-6] → -10

Kamilalisp, 46 bytes
$(⌿⊙← +)∘∊∘[* #0 [$(⌼ =) #0 #0]∘⍳∘⍴]∘[* #0 :⌽]

Attempt This Online!


text:
Compute the Discrete Fourier Transform
Implement the Discrete Fourier Transform (DFT) for a sequence of any length. This may implemented as either a function or a program and the sequence can be given as either an argument or using standard input.
The algorithm will compute a result based on standard DFT in the forward direction. The input sequence has length N and consists of [x(0), x(1), ..., x(N-1)]. The output sequence will have the same length and consists of [X(0), X(1), ..., X(N-1)] where each X(k) is defined by the relation below.
$$X_k\overset{\text{def}}{=}\sum_{n=0}^{N-1}x_n\cdot e^{-2\pi ikn/N}$$
Rules

This is code-golf so the shortest solution wins.
Builtins that compute the DFT in forward or backward (also known as inverse) directions are not allowed.
Floating-point inaccuracies will not be counted against you.

Test Cases
DFT([1, 1, 1, 1]) = [4, 0, 0, 0]
DFT([1, 0, 2, 0, 3, 0, 4, 0]) = [10, -2+2j, -2, -2-2j, 10, -2+2j, -2, -2-2j]
DFT([1, 2, 3, 4, 5]) = [15, -2.5+3.44j, -2.5+0.81j, -2.5-0.81j, -2.5-3.44j]
DFT([5-3.28571j, -0.816474-0.837162j, 0.523306-0.303902j, 0.806172-3.69346j, -4.41953+2.59494j, -0.360252+2.59411j, 1.26678+2.93119j] = [2, -3j, 5, -7j, 11, -13j, 17]

Help
There was a previous challenge for finding the DFT using a FFT algorithm for sequences with lengths equal to a power of 2. You may find some tricks there that might help you here. Keep in mind that this challenge does not limit you to any complexity and also requires your solution to work for sequences of any length.

Jelly, 16 15 bytes
LR’µ×'÷L-*²³÷S€

Try it online!
How it works
LR’µ×'÷L-*²³÷S€  Main link. Argument [x(0), ..., x(N-1)].

L                Length; yield N.
 R               Range; yield [1, ..., N].
  ’              Decrement; yield [0, ..., N-1].
   µ             Begin a new, monadic chain. Argument: [0, ..., N-1]
    ×'           Spawned multiply [0, ..., N-1] with itself, yielding the matrix
                 of all possible products k×n.
      ÷L         Divide each product by N.
        -*       Compute (-1)**(kn÷L) for each kn.
          ²      Square each result, computing (-1)**(2kn÷L).
           ³÷    Divide [x(0), ..., x(N-1)] by the results.
             S€  Compute the sum for each row, i.e., each X(k).

ninja'd :(

Python 3, 77 bytes
lambda x,e=enumerate:[sum(t/1j**(4*k*n/len(x))for n,t in e(x))for k,_ in e(x)]

Test it on Ideone.
The code uses the equivalent formula

Wow, humongous figures. It's nice seeing the equivalent formulas that can allow for shorter code.

J, 30 20 bytes
3 bytes thanks to @miles.
Uses the fact that e^ipi = -1.
The formula becomes X_k = sum(x_n / ((-1)^(2nk/N))).
+/@:%_1^2**/~@i.@#%#

Usage
>> DCT =: +/@:%_1^2**/~@i.@#%#
>> DCT 1 2 3 4 5
<< 15 _2.5j3.44095 _2.5j0.812299 _2.5j_0.812299 _2.5j_3.44095

where >> is STDIN and << is STDOUT.
"Floating-point inaccuracies will not be counted against you."

APL(Dyalog Unicode), 30 bytes SBCS
{⍵∘{+/⍺÷0j1*(4×⍵×⍳≢⍺)÷≢⍺}¨⍳≢⍵}

Adapted from the formula presented in this Python answer by Dennis
Try it on APLgolf!
APL(Dyalog Unicode), 31 bytes SBCS
{⍵∘{+/⍺×*a÷⍨○0J¯2×⍵×⍳a←≢⍺}¨⍳≢⍵}

Try it on APLgolf!
A dfn submission, assumes ⎕IO←0.
Ungolfed:
X ← {+/⍺×*(○0J¯2×⍵×⍳≢⍺)÷≢⍺}
f ← {⍵∘X¨⍳≢⍵}

APL translated to Python:
from math import *

def f(sequence):
    def X(n):
        return sum(
            sequence[b] # ⍺
            * e **      # ×*(...)
            (
                pi*-2j          # ○0J¯2
                * n             # ×⍵
                * b             # ×⍳≢⍺
                / len(sequence) # ÷≢⍺
            )
            for b in range(len(sequence))
        )
    return [X(i) for i in range(len(sequence))] # ⍵∘X¨⍳≢⍵

First it binds the sequence to a dfn, and runs the resulting function on each element in the range from \$0\$ to \$N\$ -- {⍵∘{...}¨⍳≢⍵}.
In the inner dfn it sums -- +/ -- the sequence -- ⍺ -- times \$e\$ to the power of -- ×*(...) -- \$\pi\$ times \$-2i\$ -- ○0J¯2 -- times \$k\$ -- ⍵ -- times each \$n\$ from \$0\$ to \$N\$ -- ⍳≢⍵ -- divided by \$N\$ -- ÷≢⍺.

MATL, 20 16 bytes
-1yn:qt!Gn/E*^/s

Input is a column vector, i.e. use semicolon as separator:
[1; 1; 1; 1]
[1; 0; 2; 0; 3; 0; 4; 0]
[1; 2; 3; 4; 5]
[5-3.28571j; -0.816474-0.837162j; 0.523306-0.303902j; 0.806172-3.69346j; -4.41953+2.59494j; -0.360252+2.59411j; 1.26678+2.93119j]

This uses the formula in Leaky Nun's answer, based on the facts that exp(iπ) = −1, and that MATL's power operaton with non-integer exponent produces (as in most programming languages) the principal branch result.
Try it online!
Due to Octave's weird spacing when displaying complex numbers, the real and imaginary parts in each entry of the output are separated by a space, as are consecutive entries. If that looks too ugly, add a ! at the end of the code (17 bytes) to have each entry of the output on a different line.
Explanation
-1      % Push -1
y       % Get input implicitly. Push a copy below and one on top of -1
n:q     % Row vector [0 1 ... N-1] where N is implicit input length
t!      % Duplicate and transpose: column vector
Gn      % Push input length
/       % Divide
E       % Multiply by 2
*       % Multiply, element-wise with broadcast. Gives the exponent as a matrix
^       % Power (base is -1), element-wise. Gives a matrix
/       % Divide matrix by input (column vector), element-wise with broadcast
s       % Sum

Pyth, 30
ms.e*b^.n1****c_2lQk.n0d.j0)QU

Test Suite
Very naive approach, just an implementation of the formula. Runs into various minor floating point issues with values which should be additive inverses adding to result in values that are slightly off of zero.
Oddly .j doesn't seem to work with no arguments, but I'm not sure if I'm using it correctly.

Congrats on 10k!!

Pyth, 18 bytes
Uses the fact that e^ipi = -1.
The formula becomes X_k = sum(x_n / ((-1)^(2nk/N))).
ms.ecb^_1*cyklQdQU

Test suite.

Julia, 45 bytes
~=endof
!x=sum(x./im.^(4(r=0:~x-1).*r'/~x),1)

Try it online!
The code uses the equivalent formula

Python 2, 78 bytes
l=input();p=1
for _ in l:print reduce(lambda a,b:a*p+b,l)*p;p*=1j**(4./len(l))

The polynomial is evaluated for each power p of 1j**(4./len(l)).
The expression reduce(lambda a,b:a*p+b,l) evaluates the polynomial given by l on the value p via Horner's method:
reduce(lambda a,b:a*10+b,[1,2,3,4,5])
=> 12345

Except, out input list is reversed, with constant term at the end. We could reverse it, but because p**len(l)==1 for Fourier coefficients, we can use a hack of inverting p and multiplying the whole result by p.
Some equal-length attempts:
l=input();i=0
for _ in l:print reduce(lambda a,b:(a+b)*1j**i,l,0);i+=4./len(l)

l=input();i=0
for _ in l:print reduce(lambda a,b:a*1j**i+b,l+[0]);i+=4./len(l)

As a function for 1 byte more (79):
lambda l:[reduce(lambda a,b:a*1j**(i*4./len(l))+b,l+[0])for i in range(len(l))]

An attempt at recursion (80):
f=lambda l,i=0:l[i:]and[reduce(lambda a,b:(a+b)*1j**(i*4./len(l)),l,0)]+f(l,i+1)

Iteratively simulating reduce (80):
l=input();p=1;N=len(l)
exec"s=0\nfor x in l:s=s*p+x\nprint s*p;p*=1j**(4./N);"*N

C (gcc), 86 78 bytes
k;d(a,b,c)_Complex*a,*b;{for(k=c*c;k--;)b[k/c]+=a[k%c]/cpow(1i,k/c*k%c*4./c);}

Try it online!
This assumes the output vector is zeroed out before use.

Python 2, 89 bytes
Uses the fact that e^ipi = -1.
The formula becomes X_k = sum(x_n / ((-1)^(2nk/N))).
lambda a:[sum(a[x]/(-1+0j)**(x*y*2./len(a))for x in range(len(a)))for y in range(len(a))]

Ideone it!

Post that as a separate answer!

Alright, if you say so.

Mathematica, 49 48 47 bytes
Total[I^Array[4(+##-##-1)/n&,{n=Length@#,n}]#]&

Based on the formula from @Dennis' solution.

Axiom, 81 bytes
g(x)==(#x<2=>x;[reduce(+,[x.j/%i^(4*k*(j-1)/#x)for j in 1..#x])for k in 0..#x-1])

using the formula someone post here. Results
(6) -> g([1,1,1,1])
   (6)  [4,0,0,0]
                                    Type: List Expression Complex Integer
(7) -> g([1,2,3,4])
   (7)  [10,- 2 + 2%i,- 2,- 2 - 2%i]
                                    Type: List Expression Complex Integer
(8) -> g([1,0,2,0,3,0,4,0])
   (8)  [10,- 2 + 2%i,- 2,- 2 - 2%i,10,- 2 + 2%i,- 2,- 2 - 2%i]
                                    Type: List Expression Complex Integer
(11) -> g([1,2,3,4,5])
   (11)
        5+--+4       5+--+3    5+--+2      5+--+
        \|%i   + 5%i \|%i   - 4\|%i   - 3%i\|%i  + 2
   [15, --------------------------------------------,
                           5+--+4
                           \|%i
    5+--+4       5+--+3    5+--+2      5+--+
    \|%i   + 3%i \|%i   - 5\|%i   - 2%i\|%i  + 4
    --------------------------------------------,
                       5+--+4
                       \|%i
    5+--+4       5+--+3    5+--+2      5+--+
    \|%i   + 4%i \|%i   - 2\|%i   - 5%i\|%i  + 3
    --------------------------------------------,
                       5+--+4
                       \|%i
    5+--+4       5+--+3    5+--+2      5+--+
    \|%i   + 2%i \|%i   - 3\|%i   - 4%i\|%i  + 5
    --------------------------------------------]
                       5+--+4
                       \|%i
                                    Type: List Expression Complex Integer
(12) -> g([1,2,3,4,5.])
   (12)
   [15.0, - 2.5 + 3.4409548011 779338455 %i, - 2.5 + 0.8122992405 822658154 %i,
    - 2.5 - 0.8122992405 822658154 %i, - 2.5 - 3.4409548011 779338455 %i]
                                      Type: List Expression Complex Float

Octave, 43 39 bytes
@(x)j.^(-4*(t=0:(s=rows(x))-1).*t'/s)*x

Try it online!
Multiplies the input vector by the DFT matrix.

Raku, 40 bytes
{^$_ .map: ((1.roots($_)X**-*)Z*$_).sum}

Try it online!

$_ is the input list.
^$_ is the sequence of integers from zero to one less than the size of the list.
.map: maps those indices over the following anonymous function, where the * which follows X**- assumes the value of each successive index.
1.roots($_) returns the N complex roots of unity, where N is the size of the input list $_.
X** -* cross-exponentiates those roots with the negative of the current index into the input list.
Z* $_ zips-with-multiplication those powers of the roots of unity with the input list.
.sum sums the zipped list.