[Question]
  [
## 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]
```
  
[Answer]
## Pyke, 6 bytes
```
#s,DBq
```
[Try it here!](http://pyke.catbus.co.uk/?code=%23s%2CDBq&input=%5B1337%2C4444%5D)
```
#      - Filter list on truthiness:
 s     -    digital_root(^)
  ,    -   sqrt(^)
    Bq -  int(^) == ^
```
[Answer]
# 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.)
[Answer]
# Jelly, ~~8~~ 7 bytes
1 byte thanks to [@Sp3000](https://codegolf.stackexchange.com/users/21487/sp3000).
```
DSÆ²ðÐf
```
[Test suite.](http://jelly.tryitonline.net/#code=RFPDhsKyw7DDkGYKw4figqw&input=&args=W1sxLDQsOSwxNiwyNSwxMTExXSxbMTQzMSwyLDAsMjIsOTk5OTk5OTk5XSxbMjIyMjgsNCwxMTMxMjUsMjIzNDVdLFtdLFs0MjEzMzcsOTksMTIzNDU2Nzg5LDExMzM1NTc3OTldXQ)
### Explanation
```
DSÆ²ðÐf  Main monadic chain. Argument: z
     Ðf  Filter for truthiness:
D            convert to base 10
 S           sum
  Æ²         is perfect square
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog) v2, 8 bytes
```
{ẹ+√ℤ&}ˢ
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r/v/rhrp3ajzpmPWpZolZ7etH//9GGZjqGpjqGJjqGxjqGRjqGhjqGBjqWOhY65jpmOqY6JjrGOkBRHQMgNgKyTYBiZkA5Cx3L2P9RAA "Brachylog – 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.
[Answer]
# Pyth, 10 bytes
```
fsI@sjT;2Q
```
[Test suite.](http://pyth.herokuapp.com/?code=fsI%40sjT%3B2Q&test_suite=1&test_suite_input=%5B1%2C4%2C9%2C16%2C25%2C1111%5D%0A%5B1431%2C2%2C0%2C22%2C999999999%5D%0A%5B22228%2C4%2C113125%2C22345%5D%0A%5B%5D%0A%5B421337%2C99%2C123456789%2C1133557799%5D&debug=0)
### 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)
```
[Answer]
# CJam, 14 bytes
Thanks to @FryAmTheEggman for saving one byte!
```
{{Ab:+mq_i=},}
```
[Try it online!](http://cjam.tryitonline.net/#code=WzIyMjI4IDQgMTEzMTI1IDIyMzQ1XQoKe3tBYjorbXFfaT19LH0KCn5w&input=)
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
```
[Answer]
# 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
[Answer]
## 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](http://05ab1e.tryitonline.net/#code=dnlTT3REw68tPuKAlA&input=WzIyMjI4LCA0LCAxMTMxMjUsIDIyMzQ1XQ)
Edit: Saved 9 bytes thanks to @Adnan
[Answer]
# [R](https://www.r-project.org/), ~~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!](https://tio.run/##VU5bS8MwFH7vrzgixRw41VzadRP10afhm0@yQRfTrdil0qYwEH97TVI39HtJ@K6nn@qHrB6tdk1n2Qm/kkFX9vHC4Gl6blpnenahLF4N45HZ9C4VfMv4veCY@i9ubwv/UihgiNN3ktRMM0E5rUgsSBYkPBCvIXuCt1/eYzP7ciVIEicpaXWGN0dv0P4rc0h6LH2REEr4filVXiBCDJ21SAY79wIMh25s32FngMeG4AaGBHvj4OV1vY5sLoVSpV8jEdKLchlOVaooyjJcNS9s5pQdj6ZvtO8naJsPE2ugcTcDtMbu3SHjMHR/liutzaerdq2ZfgA "R – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~64~~ 54 bytes
```
$args|?{!([math]::Sqrt(([char[]]"$_"-join'+'|iex))%1)}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/XyWxKL24xr5aUSM6N7EkI9bKKriwqERDIzo5I7EoOjZWSSVeSTcrPzNPXVu9JjO1QlNT1VCz9v///4b/Tf5b/jc0@29k@t8QCAA "PowerShell – 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](https://codegolf.stackexchange.com/a/81071/42963) of the number is an integer with `!(...%1)`. Integers will result in 0, which when `not`ed becomes `True` while non-integer roots become `False`.
As mentioned [elsewhere](https://codegolf.stackexchange.com/a/82562/42963) "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
```
[Answer]
# Python 2, 76 bytes
```
lambda l:filter(lambda n:eval(("sum(map(int,`n`))**.5==int("*2)[:-6]+")"),l)
```
[Try it here!](https://repl.it/C09S)
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)`
[Answer]
# 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
```
[Answer]
# [Brachylog](https://github.com/JCumin/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
)
```
[Answer]
# Python 2, 53 bytes
```
lambda x:[n for n in x if sum(map(int,`n`))**.5%1==0]
```
Test it on [Ideone](http://ideone.com/ljN78A).
[Answer]
# J, ~~33~~ 27 bytes
6 bytes thanks to [@miles](https://codegolf.stackexchange.com/users/6710/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
```
[Answer]
# 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
[Answer]
# 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](/users/1147/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)
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 48 bytes
```
a=>a.filter(b=>eval([...b+""].join`+`)**.5%1==0)
```
[Try it online!](https://tio.run/##NclBCoMwEEDRqwShkOhkbEoVuphcRARHm5RISIqK10/bRf/y/ZVP3pctvA@d8tMVT4XJMvoQD7fJmaw7OcoBEeemqkZcc0hTM6m6xu5iiK6qLDntOTqM@SW9HAzc4QGmh1sH5tuolGhbobUV//fT8gE "JavaScript (Node.js) – 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
```
[Answer]
# MATL, ~~16~~ ~~14~~ 13 bytes
```
"@tV!UsX^1\?x
```
[**Try it Online!**](http://matl.tryitonline.net/#code=IkB0ViFVc1heMVw_eA&input=WzIyMjI4LDQsMTEzMTI1LDIyMzQ1XQ)
**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
  
```
[Answer]
# 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]`
[Answer]
# Jolf, 8 bytes
[Try it here!](http://conorobrien-foxx.github.io/Jolf/#code=z4h4ZCFpVXVI&input=WzEsIDQsIDksIDExMTEsIDE2LCAyNV0)
```
ψ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?
```
[Answer]
# 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**](http://ideone.com/Dde5kh). 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.
[Answer]
# 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>
[Answer]
# [Perl 6](http://perl6.org), ~~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] => []
```
[Answer]
# 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](http://ideone.com/H0W1qt)
```
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
}
```
[Answer]
# [Retina](https://github.com/mbuettner/retina/wiki/The-Language), 69
Because testing for perfect squares in retina. This can be [modified for generalised integer square root calculation](https://codegolf.stackexchange.com/questions/35182/integer-square-root-of-integer/82842#82842).
```
.+
$&a$&
+`\b\d
$*b 
 
\bb
$&:
+`(\bb+):(bb\1)
$1 $2:
G`(:a|0$)
.*a
```
Input is a newline-separated list.
[Try it online.](http://retina.tryitonline.net/#code=LisKJCZhJCYKK2BcYlxkCiQqYiAKIAoKXGJiCiQmOgorYChcYmIrKTooYmJcMSkKJDEgJDI6CkdgKDphfDAkKQouKmEK&input=MTQzMQoyCjAKMjIKOTk5OTk5OTk5)
* Stage 1 - repeat the number on each line, and separate with `a`
* Stage 2 - convert each digit before the `a` to unary expressed as `b`s, 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
[Answer]
# [Ruby](https://www.ruby-lang.org/), 39 bytes
```
->a{a.reject{|x|x.digits.sum**0.5%1>0}}
```
[Try it online!](https://tio.run/##XY7NCoMwEITveQqh9CJrcPNj9FBfJORgrbYWCkUjWIzPbhNKWuiclvlmZ3ecz6@9P@1Z3awNHbt719rVLW6hl@E62IlO8yNNcyqPWOfbtmuiEQRUgAUwCehl4JBkdRL94PiQ4AgMcmAMqqhvMsA/RDTzKn0HIkdfzRgXMm5E9jGJjr4fBUPOlW8CDLBQZXiCcymV@p00xNCuaW@rs@6Z9NqabX8D "Ruby – Try It Online")
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), ~~19~~ ~~17~~ 13 bytes
**Solution:**
```
(~1!%+/.:'$)#
```
[Try it online!](https://tio.run/##y9bNz/7/X6POUFFVW1/PSl1FU9nQxNhQwUjBQMHISMESBv7//w8A "K (oK) – 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
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), ~~5~~ 4 bytes
```
gÅΣ°
```
[Try it online!](https://tio.run/##y00syUjPz0n7/z/9cOu5xYc2/P8fbahgomCpYGimYGSqYAgEsQA "MathGolf – 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!
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), 5 bytes
```
'f∑∆²
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=%27f%E2%88%91%E2%88%86%C2%B2&inputs=%5B22228%2C4%2C113125%2C22345%5D&header=&footer=)
```
'        # Keep elements in input list
 f∑      # Whose sum of digits is
   ∆²    # A perfect square
```
]