31
\$\begingroup\$

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]
\$\endgroup\$
  • 11
    \$\begingroup\$ Nice first challenge, and welcome to the site! \$\endgroup\$ – DJMcMayhem Jun 10 '16 at 14:14
  • \$\begingroup\$ 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) \$\endgroup\$ – Blue Jun 10 '16 at 14:16
  • \$\begingroup\$ @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. \$\endgroup\$ – SEJPM Jun 10 '16 at 14:21
  • 12
    \$\begingroup\$ 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. \$\endgroup\$ – FryAmTheEggman Jun 10 '16 at 14:29
  • 1
    \$\begingroup\$ @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. \$\endgroup\$ – LLlAMnYP Jun 17 '16 at 13:42

42 Answers 42

10
\$\begingroup\$

Pyke, 6 bytes

#s,DBq

Try it here!

#      - Filter list on truthiness:
 s     -    digital_root(^)
  ,    -   sqrt(^)
    Bq -  int(^) == ^
\$\endgroup\$
5
\$\begingroup\$

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.)

\$\endgroup\$
  • \$\begingroup\$ A byte to be saved by ...Digits@#& instead of ...Digits[#]& \$\endgroup\$ – LLlAMnYP Jun 17 '16 at 13:43
4
\$\begingroup\$

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
\$\endgroup\$
4
\$\begingroup\$

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.

\$\endgroup\$
3
\$\begingroup\$

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)
\$\endgroup\$
3
\$\begingroup\$

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
\$\endgroup\$
3
\$\begingroup\$

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

\$\endgroup\$
  • 2
    \$\begingroup\$ Interesting approach. I'm not sure the f= is required for this answer. \$\endgroup\$ – Michael Klein Jun 11 '16 at 19:24
3
\$\begingroup\$

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

\$\endgroup\$
  • \$\begingroup\$ 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ï->—. \$\endgroup\$ – Adnan Jun 10 '16 at 15:01
  • \$\begingroup\$ @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. \$\endgroup\$ – Emigna Jun 11 '16 at 14:59
  • \$\begingroup\$ Yeah, items separated with newlines are accepted by default I think, unless the challenge explicitly said not to. \$\endgroup\$ – Adnan Jun 11 '16 at 15:02
3
\$\begingroup\$

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!

\$\endgroup\$
3
\$\begingroup\$

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
\$\endgroup\$
  • 1
    \$\begingroup\$ $n%1 checks if int only $args|?{!([math]::Sqrt(([char[]]"$_"-join'+'|iex))%1)} \$\endgroup\$ – mazzy Sep 18 '18 at 8:47
2
\$\begingroup\$

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)

\$\endgroup\$
2
\$\begingroup\$

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
\$\endgroup\$
2
\$\begingroup\$

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
    )
    
\$\endgroup\$
2
\$\begingroup\$

Python 2, 53 bytes

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

Test it on Ideone.

\$\endgroup\$
  • 1
    \$\begingroup\$ 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? \$\endgroup\$ – Lynn Jun 10 '16 at 19:24
  • 2
    \$\begingroup\$ 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. \$\endgroup\$ – Dennis Jun 10 '16 at 19:27
2
\$\begingroup\$

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
\$\endgroup\$
  • 1
    \$\begingroup\$ 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. \$\endgroup\$ – miles Jun 10 '16 at 17:55
2
\$\begingroup\$

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

\$\endgroup\$
  • \$\begingroup\$ 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 \$\endgroup\$ – sergioFC Jun 11 '16 at 22:21
  • \$\begingroup\$ @sergioFC I can't change -+- to +, because they're strings \$\endgroup\$ – Bálint Jun 12 '16 at 12:34
2
\$\begingroup\$

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)
\$\endgroup\$
2
\$\begingroup\$

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
\$\endgroup\$
1
\$\begingroup\$

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
\$\endgroup\$
1
\$\begingroup\$

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]

\$\endgroup\$
1
\$\begingroup\$

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?
\$\endgroup\$
1
\$\begingroup\$

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.

\$\endgroup\$
1
\$\begingroup\$

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

\$\endgroup\$
1
\$\begingroup\$

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] => []
\$\endgroup\$
1
\$\begingroup\$

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
}
\$\endgroup\$
1
\$\begingroup\$

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
\$\endgroup\$
  • \$\begingroup\$ 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: retina.tryitonline.net/… :) \$\endgroup\$ – Martin Ender Jun 22 '16 at 15:44
1
\$\begingroup\$

Python, 50 bytes

filter(lambda x:sum(map(int,str(x)))**0.5%1==0,in)

If n is input list of numbers

\$\endgroup\$
  • 1
    \$\begingroup\$ Hello, and welcome to the site! Since this is a code-golf competition, e.g. who can write the shortest code, we require all submissions to be at at least somewhat golfed. We have a list of python golfing tips here. Just off the top of my head, one obvious improvement you could do is to remove all the extra whitespace, and rename your variables to one letter each. You could also take input as function arguments or STDIN instead of command line arguments. \$\endgroup\$ – DJMcMayhem Jun 17 '16 at 14:00
  • \$\begingroup\$ You should also specify the language and the byte count, which could be counted, for example, there. \$\endgroup\$ – nicael Jun 18 '16 at 10:24
  • 1
    \$\begingroup\$ Welcome to PPCG! In addition to what the others said, please note that all solutions must be either full programs or callable functions. So far, all of your answers have been snippets which assume that the input is stored in some variable and just evaluate to the result, which unfortunately makes them invalid. For acceptable I/O methods, see this meta post. \$\endgroup\$ – Martin Ender Jun 22 '16 at 15:05
1
\$\begingroup\$

Ruby, 39 bytes

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

Try it online!

\$\endgroup\$
1
\$\begingroup\$

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
\$\endgroup\$
  • 1
    \$\begingroup\$ you know about filter (func#list)? \$\endgroup\$ – ngn Sep 14 '18 at 9:28
  • \$\begingroup\$ I did not, very nice! \$\endgroup\$ – streetster Sep 14 '18 at 10:27
1
\$\begingroup\$

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!

\$\endgroup\$
  • \$\begingroup\$ 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. \$\endgroup\$ – maxb Sep 18 '18 at 4:31

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.