It's Hip to be Square

Question

Challenge

So, um, it seems that, while we have plenty of challenges that work with square numbers or numbers of other shapes, we don't have one that simply asks:

Given an integer n (where n>=0) as input return a truthy value if n is a perfect square or a falsey value if not.

---

Rules

• You may take input by any reasonable, convenient means as long as it's permitted by standard I/O rules.
• You need not handle inputs greater than what your chosen language can natively handle nor which would lead to floating point inaccuracies.
• Output should be one of two consistent truthy/falsey values (e.g., true or false, 1 or 0) - truthy if the input is a perfect square, falsey if it's not.
• This is code-golf so lowest byte count wins.

---

Test Cases

Input:  0
Output: true

Input:  1
Output: true

Input:  64
Output: true

Input:  88
Output: false

Input:  2147483647
Output: false

Answer 1

Neim, 2 bytes

q

Explanation:

q      Push an infinite list of squares
      Is the input in that list?

When I say 'infinite' I mean up until we hit the maximum value of longs (2^63-1). However, Neim is (slowly) transitioning to theoretically infinitely large BigIntegers.

Try it!

Answer 2

Jelly, 2 bytes

Ʋ

Try it online!

Answer 3

C#, 27 bytes

n=>System.Math.Sqrt(n)%1==0

---

A more correct/accurate way to do this would be:

n=>System.Math.Sqrt(n)%1<=double.Epsilon*100

Answer 4

TI-Basic, 4 bytes

not(fPart(√(Ans

Simply checks if the square root is an integer by looking for a nonzero fractional/decimal part.

Answer 5

JavaScript (ES6), 13 bytes

n=>!(n**.5%1)

Returns true if the square root of n is a whole number.

Snippet:

f=
n=>!(n**.5%1)

console.log(f(0));
console.log(f(1));
console.log(f(2));
console.log(f(4));
console.log(f(8));
console.log(f(16));
console.log(f(88));
console.log(f(2147483647));

Answer 6

dc, 9

0?dvd*-^p

Outputs 1 for truthy and 0 for falsey.

Try it online.

0            # Push zero.  Stack: [ 0 ]
 ?           # Push input.  Stack: [ n, 0 ]
  dv         # duplicate and take integer square root.  Stack: [ ⌊√n⌋, n, 0 ]
    d        # duplicate.  Stack: [ ⌊√n⌋, ⌊√n⌋, n, 0 ]
     *       # multiply.  Stack: [ ⌊√n⌋², n, 0 ]
      -      # take difference. Stack: [ n-⌊√n⌋², 0 ]
       ^     # 0 to power of the result.  Stack: [ 0^(n-⌊√n⌋²) ]
        p    # print.

Note dc's ^ exponentiation command gives 0⁰=1 and 0ⁿ=0, where n>0.

Answer 7

Retina, 18 bytes

.+
$*
(^1?|11\1)+$

Try it online! Shamelessly adapted from @MartinEnder's answer to Is this number triangular? but with the base conversion included at a cost of 6 bytes.

Note that Is this number triangular? wasn't for some inexplicable reason required to support zero as a triangular number, so part of the adaption was to add a ? to make the leading 1 optional, allowing the group to match the empty string, and therefore a zero input. However, having now matched the empty string, the + operator stops repeating, to avoid the infinite loop that would happen if it kept greedily matching the empty string (after all, ^1? would certainly keep matching). This means that it doesn't even try to match the other alternative in the group, thus avoiding the match of 2, 6, 12 etc. As @MartinEnder points out, a simpler way to avoid that while still matching the empty string is to anchor the match at the start while making the group optional for the same byte count: ^(^1|11\1)*$.

Answer 8

MATL, 5 4 bytes

Thanks to Luis for reducing my one byte longer code by two bytes, making it the shortest one.

t:Um

Try it online

Explanation:

         % Implicit input
t        % Duplicate it
 :       % Range from 1 to input value
  U      % Square the range, to get 1 4 9 ... 
   m     % ismember, Checks if the input is a member of the range of perfect squares

---

Old answer:

X^1\~

Try it online!

        % Implicit input
X^      % Square root of input
  1\    % Modulus 1. All perfect squares will have 0, the rest will have decimal value
     ~  % Negate, so the 0 becomes 1, and the decimal values become 0

Answer 9

C (gcc), 30 bytes

f(n){n=sqrt(n)==(int)sqrt(n);}

Try it online!

C, 34 bytes

f(n){return(int)sqrt(n)==sqrt(n);}

Try it online!

C, 33 bytes

#define f(n)(int)sqrt(n)==sqrt(n)

Try it online!

Answer 10

Python 3, 40 38 bytes

Thanks to squid for saving 2 bytes!

lambda n:n in(i*i for i in range(n+1))

Try it online!

Too slow to return an answer for 2147483647 in a reasonable amount of time. (But written using a generator to save memory, since it doesn't cost any bytes.)

Works in Python 2 also, though an OverflowError is a possibility due to range if you try it with huge inputs. (A MemoryError would also be likely in Python 2, also due to range.)

Answer 11

05AB1E, 4 bytes

Ln¹å

Try it online!

Answer 12

Perl 5, 14 bytes

13 bytes of code + -p flag.

$_=sqrt!~/\./

Try it online!

Computes the square root, and looks if it's an integer (more precisely, if it doesn't contain a dot (/\./).

Answer 13

Japt, 3 bytes

¬v1

Try it online!

Seems to work fine for 2**54-2 in the Japt Interpreter but fails on TIO for some reason...

Answer 14

Python 3, 19 bytes

lambda n:n**.5%1==0

Try it online!

Answer 15

SageMath, 9 bytes

is_square

Try it online

The built-in function does exactly what it says on the tin. Since Sage uses symbolic computation, it's free of computational accuracy errors that plague IEEE-754 floats.

Answer 16

Haskell, 26 24 bytes

f n=elem n$map(^2)[0..n]

Try it online!

Checks if n is in the list of all squares from 0 to n.

Answer 17

Prolog (SWI), 27 bytes

+N:-between(0,N,I),N=:=I*I.

Try it online!

Explanation

Searches through all numbers greater or equal to 0 and less than or equal to N and tests whether that number squared is equal to N.

Answer 18

MathGolf, 1 byte

°

Try it online!

I don't think an explanation is needed. I saw the need for an "is perfect square" operator before I saw this challenge, as the language is designed to handle math related golf challenges. Returns 0 or 1, as MathGolf uses integers to represent booleans.

Answer 19

Ruby, 25 bytes

Math.sqrt(gets.to_i)%1==0

There probably is a shorter way but that's all I found.

Try it online!

Answer 20

PHP, 21 bytes

<?=(-1)**$argn**.5<2;

If the square root is not an integer number, (-1)**$argn**.5 is NAN.

Answer 21

Java 8, 20 bytes

n->Math.sqrt(n)%1==0

Input is an int.

Try it here.

Answer 22

Mathematica, 13 bytes

AtomQ@Sqrt@#&

Try it online!

Answer 23

APL (Dyalog), 8 bytes

0=1|*∘.5

Try it online!

0= [is] zero equal to

1| the modulus-1 (i.e. the fractional part) of

*∘.5 the argument raised to the power of a half

Answer 24

CJam, 8 bytes

ri_mQ2#=

Try it online!

Explanation

Integer square root, square, compare with original number.

Answer 25

Add++, 24 13 11 bytes

+?
S
%1
N
O

Try it online!

I removed the clunky function at the top and rewrote it into the body of the question to remove 11 bytes.

As the first section is already explained below, let's only find out how the new part works

S   Square root
%1  Modulo by 1. Produced 0 for integers and a decimal for floats
N   Logical NOT

Old version, 24 bytes

D,i,@,1@%!
+?
^.5
$i,x
O

Try it online!

The function at the top (D,i,@,1@%!) is the main part of the program, so let's go into more detail.

D,     Create a function...
  i,   ...called i...
  @,   ...that takes 1 argument (for this example, let's say 3.162 (root 10))
    1  push 1 to the stack; STACK = [1, 3.162]
    @  reverse the stack;   STACK = [3.162, 1]
    %  modulo the stack;    STACK = [0.162]
    !  logical NOT;         STACK = [False]

+?     Add the input to accumulator (x)
^.5    Square root (exponent by 0.5)
$i,x   Apply function i to x
O      Output the result

Answer 26

AWK, 27+2 bytes

{x=int($0^0.5);$0=x*x==$1}1

Try it online!

Add +2 bytes for using the -M flag for arbitrary precision. I originally used string comparison because large number compared equal, even though they weren't, but the sqrt was also returning imprecise values. 2^127-2 should not be a perfect square.

Answer 27

T-SQL, 38 bytes

SELECT IIF(SQRT(a)LIKE'%.%',0,1)FROM t

Looks for a decimal point in the square root. IIF is specific to MS SQL, tested and works in MS SQL Server 2012.

Input is in column a of pre-existing table t, per our input rules.

Answer 28

Ohm, 2 bytes

Ʋ

Uses CP-437 encoding.

Explanation

Implicit Input -> Perfect square built-in -> Implicit Output...

Answer 29

Python 3, 28 27 25 bytes

• Thanks to @mdahmoune for 1 byte: compare int of root squared with original
• 2 bytes saved: lambda shortened

lambda x:int(x**.5)**2==x

Try it online!

Answer 30

R, 15

scan()^.5%%1==0

^.5 is less bytes than sqrt(). %%1, the modulus, will result in 0 if answer is an interger. scan() takes user input.

http://www.tutorialspoint.com/execute_r_online.php?PID=0Bw_CjBb95KQMSm1qVktIOUdSSDg

Answer 31

PHP, 26 bytes

<?=(0^$q=sqrt($argn))==$q;

Try it online!

Answer 32

Actually, 6 bytes

;ur♂²c

Try it online!

-2 bytes from Erik the Outgolfer

Explanation:

;ur♂²c
;ur       range(n+1) ([0, n])
   ♂²     square each element
     c    does the list contain the input?

This takes a while for large inputs - TIO will timeout.

Answer 33

C (gcc), 66 43 42 bytes

f(float n){return!(sqrt(n)-(int)sqrt(n));}

Try it online!

Thanks to TheLethalCoder for the tip!

@hvd Thanks for saving a byte!

Answer 34

CJam, 12 bytes

{_),2f##)!!}

Try it online!

Answer 35

Python, 53 50 49 48 49 48 bytes

This should in theory work for an input of any size. Returns True if the given number is a square, False otherwise.

f=lambda n,x=0:x<=n if~-(x<=n!=x*x)else f(n,x+1)

Try it online!

Explanation:

f=                                                # assign a name so we can call it
  lambda n,x=0:                                   # counter variable x
               x<=n                               # counter bigger than input?
                    if~-(         )               # "negate" inner condition
                         x<=n                     # counter not bigger
                            n!=x*x                # and n not square of x
                                   else f(n,x+1)  # else recurse

The condition is just a de-Morgan'd if x>n or n==x**2, i.e. we return if the counter is bigger than the input, or we found a proof for squareness.

Saved 1 byte thanks to Gábor Fekete.

Answer 36

APL, 5 bytes

⊢∊⍳×⍳

Explanation:

⊢           N
  ∊         in
    ⍳        numbers up to N
      ×     times
        ⍳    numbers up to N

Test:

      ((⊢∊⍳×⍳) ¨ X) ,[÷2] X←⍳25
1 0 0 1 0 0 0 0 1  0  0  0  0  0  0  1  0  0  0  0  0  0  0  0  1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

Answer 37

JavaScript on NodeJS & Chrome, 51 bytes

// OLD: t=n=>{i=Number.isSafeInteger;return i(n)&&i(n**.5)}

i=Number.isSafeInteger;t=n=>i(n)&&i(n**.5) 
// TestCases:
let l=console.log;l(`t(1): ${t(1)}; t(64): ${t(64)}; t(88): ${t(88)};`)

Try it online!

Answer 38

MIPS, 112 bytes

main:li $v0,7
syscall
sqrt.d $f0,$f0
mfc1 $a0,$f0
li $v0,1
beqz $a0,t
li $a0,0
syscall
b e
t:li $a0,1
syscall
e:

Try it online!

Outputs 1 if the input is square, 0 if not.

Explanation

main:li $v0,7      #Start of program. Load service 7 (read input as float to $f0). 
                   #Input can be an integer, but MIPS will interpret it as a float.
syscall            #Execute.

sqrt.d  $f0,$f0    #Overwrite $f0 with its square root, stored as a double.
mfcl    $a0,$f0    #Move $f0 to $a0.
li      $v0,1      #Load service 1 (print int from $a0).
beqz    $a0,t      #Branch to label 't' if $a0 = 0. Otherwise continue.

#If input is non-square...
li      $a0,0      #Load 0 into $a0.
syscall            #Execute (print $a0).
b e                #Branch to label 'e'.

#If input is square...
t:li    $a0,1      #Start of label 't'. Load 1 into $a0.
syscall            #Execute (print $a0).

e:                 #Start of label 'e'. Used to avoid executing 't' when input isn't square.

A double in MIPS is 16 hexes. It shares its address with a float containing its low-order 8 hexes ($f0 in this case). The high-order hexes are stored in the next register ($f1), also as a float.

          float             double 
$f0     0000 0000     1111 1111 0000 0000
$f1     1111 1111

Taking the square root of a non-square number requires the entire double in order to be stored, meaning the high and low floats are populated. The square root of a square number only needs a few hexes from the double to be stored, and it is stored specifically in its high-order hexes. This means the low float is left at 0.

If the low float equals 0, the input is a square number.

Answer 39

Whitespace, 95 bytes

[S S S N
_Push_0][S N
S _Duplicate_top][T N
T   T   _Read_STDIN_as_integer][N
S S N
_Create_Label_LOOP][S N
S _Duplicate_top][S N
S _Duplicate_top][T S S N
_Multiply_top_two][S S S N
_Push_0][T  T   T   _Retrieve_input][S N
T   _Swap_top_two][T    S S T   _Subtract][S N
S _Duplicate_top][N
T   S S N
_If_0_jump_to_Label_TRUE][N
T   T   T   N
_If_negative_jump_to_Label_FALSE][S S S T   N
_Push_1][T  S S S _Add][N
S N
N
_Jump_to_Label_LOOP][N
S S S N
_Create_Label_TRUE][S S S T N
_Push_1][T  N
S T _Print_as_integer][N
N
N
_Stop_program][N
S S T   N
_Create_Label_FALSE][S S S N
_Push_0][T  N
S T _Print_as_integer]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.

Outputs 1/0 for truthy/falsey respectively. A few bytes could be saved if something like 00/0 for truthy/falsey is allowed instead.

Try it online (with raw spaces, tabs and new-lines only).

Explanation in pseudo-code:

Read STDIN as integer, and store it in the heap
Integer i = 0
Start LOOP:
  Integer temp = i*i - input from heap
  If(temp == 0):
    Call function TRUE
  If(temp < 0):
    Call function FALSE
  i = i + 1
  Go to next iteration of LOOP

function TRUE:
  Print 1 as integer
  Stop program
function FALSE:
  Print 0 as integer
  (implicitly stop the program with an error)

Here a port of this approach in Java:

int func(int input){
  for(int i=0; /*infinite loop*/; i++){
    int m = input - i*i;
    if(m==0) return 1;
    if(m<1) return 0;
  }
}

Try it online.

Answer 40

Pyth, 5 bytes

/^R2h

Try it here!

Answer 41

QBIC, 16 18 bytes

[:|~b/a=a|_Xq}?b=0

Added two bytes for 0-case

This runs through i = 1 ... n to see if n / i == i. Prints 1 if such an i is found, prints -1 for N=0 and 0 in all other cases. Both 1 and -1 are considered truthy in QBasic (-1 being the actual value for true, but IF (n) only is false on n=0).

Answer 42

C, 33 bytes

#define f(x)sqrt(x)==(int)sqrt(x)

Takes an integer x. Checks if the square root of x is the square root of x rounded to an integer.

Try it online!

Answer 43

Excel, 18 16 bytes

=MOD(A1^0.5,1)=0

Answer 44

Python 3, 39 38 Bytes

lambda n:n in(i*i for i in range(n+1))

@mathmandan I had the same idea, and this implementation is 1 byte shorter. I wanted to comment on your post but do not yet have 50 reputation. I hope you see this!

This is just brute force, and I did not get it to complete 2147483647 in a reasonable amount of time.

Thanks @DJMcMayhem for suggesting i remove the space after in

Try it Online

Answer 45

Pari/GP, 8 bytes

issquare

Try it online!

Answer 46

Pyke, 3 bytes

,$P

Try it here!

,   -   sqrt(input)
 $  -  float(^)
  P - is_int(^)

This could be two bytes (and is in older versions) if Pyke didn't helpfully automatically cast the results of sqrt to an integer if it's a square number.

Answer 47

Charcoal, 8 bytes

¬﹪ＸＮ·⁵¦¹

Try it online!

Explanation

¬           Not
 ﹪      ¦¹ Modulo 1
   Ｘ  ·⁵   To the power of .5
     Ｎ     Next input as number, 

Answer 48

05AB1E, 5 3 bytes

t.ï

Try it online!

Longer than @Erik's but just wanted to give it a shot.

Now shorter than Erik's but fails for large numbers...

Explanation

t            # square roots the input
 .ï          # checks if number on stack is an int
             # implicit output of result (0 or 1)

Answer 49

Common Lisp, 30 bytes

(defun g(x)(=(mod(sqrt x)1)0))

Try it online!

or, with the same length,

(defun g(x)(integerp(sqrt x)))

Answer 50

><>, 22+3 = 25 bytes

01-\:*=n;
(?!\1+::*{:}

Try it online!

Input is expected on the stack at program start, so +3 bytes for the -v flag.

Answer 51

tinylisp, 67 bytes

(load library
(d S(q((n)(contains?(map(q((x)(* x x)))(c 0(1to n)))n

Try it online!

Generates a list of numbers from 0 through n, maps a lambda function that squares each one, and checks if n is in the resulting list of squares. Wildly inefficient, of course.

---

Here's a 77-byte solution that doesn't use the library and runs an order of magnitude faster:

(d _(q((x n s)(i(e n s)1(i(l n s)0(_(a x 1)n(a s(a x(a x 1
(d S(q((n)(_ 0 n 0

Try it online!

This one uses a helper function _ which tracks a counter x and its square s. At each level of recursion, we return success if s equals n and failure if s is greater than n; otherwise, if s is still less than n, we recurse, incrementing x and calculating the next s by the formula (x+1)^2 = x^2 + x + x + 1.

Answer 52

Julia 0.6, 12 bytes

n->√n%1==0

Try it online!

Pretty straightforward, having the Unicode √ for square-root saves a few bytes.

Answer 53

Japt -¡E, 2 bytes

¬d

Run it online

Answer 54

PowerShell, 26 bytes

!([math]::Sqrt("$args")%1)

Try it online!

Answer 55

Python 3, 27 25 24 bytes

saved bytes by simplifying order of operation and comparing roots instead of squared value

lambda n:n**.5//1==n**.5

Try it online!

Answer 56

SNOBOL4 (CSNOBOL4), 61 bytes

	N =INPUT
T	OUTPUT =EQ(X * X,N) 1
	X =LT(X,N) X + 1	:S(T)
END

Try it online!

Increment X until either X ^ 2 is equal to N in which case the program outputs 1 or until X > N in which case the program outputs nothing.

Answer 57

k4, 12 9 bytes

 x=_x:sqrt

with num(s) to be checked passed right-side, e.g.

 x=_x:sqrt 36 35 25
101b

get square root and check if the it is equal to the square root cast to int. if not a square number, the square root will have a decimal place and the cast will cut the decimal off

edit: -3 thanks to ngn :)

---

K (oK), 8 bytes

x=`i$x:%

Try it online!

Same logic but in oK, an implementation of k6 (no online k4 interpreter that i'm aware of). Test like:

 x=`i$x:% 16 24 81
1 0 1

Answer 58

brainfuck, 42 bytes

->>,[[-<<<+>>>]<<++[[-<]<+>>>]<<<[<]>>>]<.

Try it online!

Outputs the NUL byte for square numbers and SOH for non-squares. Uses the property that square numbers are the cumulative sum of odd numbers, i.e. 1, 1+3, 1+3+5 etc.

There might be a better way of arranging the cells so as to reduce the number of pointer movements and save bytes.

Answer 59

Brain-Flak, 92 bytes

(({})){{}([(({}[({})({}())])[(())])](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}}{}({()(<{}>)}{}<>)

Try it online!

Answer 60

J, 8 bytes

(=~<.)%:

Explanation:

• %: square root
• =~ is the argument equal to itself
• <. floor of
• =~<. a J hook, which modifies the right argument by applying <.
• so, "is the floor of the square root equal to itself?"

Note: If we want to save the above to a variable as a verb, we must do, eg:

issq=.(=~<.)@%:

Answer 61

Python 2, 33 bytes

 g = lambda x: (x**.5).is_integer()

Answer 62

Python 2, 25 bytes

lambda n:int(n**.5)**2==n

Try it online!

Answer 63

Ruby, 16 bytes

->n{n**0.5%1==0}

Trivial solution.

Answer 64

C++, 43 bytes

bool c(int n){int t=sqrt(n);return t*t==n;}

New version: https://repl.it/repls/CompatibleJumpyCoordinates

If your number is perfect square then it will return 1, otherwise it will return 0;

Old version: https://repl.it/repls/WateryTroubledProjects (not valid because it is the snippet only by @Jonathan Frech)

If your number is perfect square then it will be exited with status 1, otherwise it will not exist;

Answer 65

BFASM, 204 bytes

The function is taking input in r2 and outputs its value into r1.

lbl 1
mov r3,1
lbl 2
mov r4,r3
mul r4,r3
le_ r4,r2
jz_ r4,3
mov r4,r2
mod r4,r3
jz_ r4,4
lbl 5
inc r3
jmp 2
lbl 4
mov r4,r2
div r4,r3
eq_ r4,r3
jz_ r4,5
mov r1,1
ret
lbl 3
clr r1
ret

Answer 66

Forth (gforth), 31 bytes

: f dup s>f fsqrt f>s dup * = ;

Try it online!

The input is a positive signed single-cell integer (0 <= n < 2^63 for 64-bit systems). To support full unsigned integer range, do 0 d>f instead of s>f.

Using floats turns out to be shorter than a loop.

How it works

: f ( n -- f )  \ Takes a positive signed int and gives whether it's a square or not
  dup           \ Duplicate n
  s>f fsqrt f>s \ Move to floating-point stack, take sqrt and move back (truncate)
  dup * =       \ Square the result and compare with n
;

gforth's comparison operators give -1 for true, 0 for false.