[Question]
  [
Given an integer n, your task is to determine whether it is a perfect square that when reversed, is still a perfect square. You may assume n is always positive.
When numbers such as 100 (10x10) are reversed the result may have leading zeros (001) In this case, ignore the leading zeros and treat it as 1 (1x1).
## Test cases
```
1 => True
4 => True
9 => True
441 => True
1234567654321 => True
100 => True
3 => False
25 => False
1784 => False
18 => False
```
Shortest code wins!
  
[Answer]
# [Nekomata](https://github.com/AlephAlpha/Nekomata) + `-e`, 6 bytes
```
¢B¢bÐ√
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70iLzU7PzexJHFNtJJurpKOgpJuqlLsgqWlJWm6FqsPLXI6tCjp8IRHHbOWFCclF0PFF9xUNeQy4bLkMjEx5DI0MjYxNTM3MzUxNgLyDAy4jLmMTLkMzS1MIKoB)
```
¢B¢bÐ√
¢B      Integer to decimal digits in the reverse order
  ¢b    Decimal digits to integer
    Ð   Pair
     √  Square root; fails if not a perfect square
```
`-e` checks if there is a solution.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 5 bytes
```
Â)Å²P
```
Prints `1` if the condition is met, `0` otherwise.
[Try it online!](https://tio.run/##yy9OTMpM/f//cJPm4dZDmwL@/zc0MjYxNTM3MzUxNjIEAA "05AB1E – Try It Online") Or [verify all test cases](https://tio.run/##yy9OTMpM/V9WeXiCvZLCo7ZJCkr2/w83aR5uPbQp4L/O/2hDHQUTHQVLIGkCZBoaGZuYmpmbmZoYG4G4BgY6CsY6CkamQLa5hUksAA).
### How it works
```
Â    # Implicit input: n. Push n and (digit-)reversed n
)    # Concatenate stack into an array
Å²   # Is square? Element-wise
P    # Product of array. Implicit print
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `g`, ~~30~~ 27 [bitsv2](https://github.com/Vyxal/Vyncode/blob/main/README.md), ~~3.75~~ 3.375 bytes
```
Ṙ"∆²
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=2#WyJBZz0iLCIiLCLhuZhcIuKIhsKyIiwiIiwiMVxuNFxuOVxuNDQxXG4xMjM0NTY3NjU0MzIxXG4xMDBcbjNcbjI1XG4xNzg0Il0=)
## Explained
```
Ṙ"∆²
Ṙ"    # the list [input, input reversed]
  ∆²  # vectorise is square
# g flag takes the minimum which in this case is equivalent to checking if both items are truthy 
```
[Answer]
# Extended Dyalog APL, 18 13 11 bytes
Thanks Adám for -5 bytes!
Takes input as a string.
```
≡∘⌊⍨∘√⍎,⍎⍤⌽
```
Explanation:
```
≡∘⌊⍨⍤√⍎,⍎⍤⌽
       ,    ⍝ make a list of
      ⍎     ⍝ the input parsed as a number
        ⍎⍤⌽ ⍝ and the reversed input parsed as a number,
     √      ⍝ take the square root of both,
≡∘⌊⍨        ⍝ is that list equal to itself after you floor it?
```
[Answer]
# [Factor](https://factorcode.org) + `math.unicode` `project-euler.037.private`, 46 bytes
-5 bytes thanks to @chunes
```
[ dup reverse-digits [ √ dup ⌊ = ] both? ]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=Lc6xTsMwEAbg_Z7iVJHRURw7TaGiHatKFQtiCh2MfWmMShK5dp8BIZ4Ali7wTln7JDgt46_7_l_3_Vsr7Tt3GjZPj-uH1R32rnsl7RmFPbk0E2XaO3tUnvBN-SYNrdWdIZwDOFKG7W1LB6zQkF7gNpoeTeh_gq_ZbEirMaCjI7kDMWN31o_4_P51OZw_P_A-tl463yxx-9-6GUcqnCSMC4NsgUl4bifxMdv6OuqclG6u9jQkHCTcgpQceC5kMS2nhRR5TFkGAvICeDmTV_0H)
* `[ ... ]` Quotation (anonymous function) taking a number
* `dup` Duplicate so number is on the stack twice
* `reverse-digits` Reverse the digits of the copy
* `[ ... ] both?` Apply the quotation to both and check if both return `t`:
* `√` Square root
* `dup` Push a copy
* `⌊` Round down
* `=` Are this and the original equal?
`√ dup ⌊ =` seems to be the shortest way to check if a number is a perfect square, since `√ integer?` doesn't work.
[Answer]
# [Thunno 2](https://github.com/Thunno/Thunno2) `M`, 4 bytes
Requires v2.2.2: [Try it](https://Not-Thonnu.github.io/run?code=%E1%B8%B2%2C%C3%86%C2%B2&input=100&flags=M)
```
Ḳ,Æ²
```
# [Thunno 2](https://github.com/Thunno/Thunno2) `G!`, 6 bytes
Works on old version of Thunno 2.
```
ḲNKƭ1%
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m728JKM0Ly_faFm0kruiUuyCpaUlaboWKx_u2OTnfWytoeqS4qTkYqjogrWGRsYmpmbmZqYmxkaGEEEA)
* `Ḳ` Bifurcate - duplicate and push reverse
* `N` Cast reversed to integer
* `K` The stack as a list
* `ƭ` The square root of each
* `1%` Each mod 1 (0 if integer, nonzero else)
* `G` flag - maximum, 0 [iff](https://en.wikipedia.org/wiki/If_and_only_if) both are integers
* `!` flag - logical not
This could be 4 bytes with `m` flag if we had an `is_square` built-in, or 5 bytes with same flag if we had an `is_int` built-in.
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 7 bytes
```
↔;?~^₂ᵐ
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r//1HbFGv7urhHTU0Pt074/9/ExPA/AA "Brachylog – Try It Online")
### Explanation
```
↔;?          The list [reversed(Input), Input]
   ~^₂ᵐ      Each element must be the square of some number
```
[Answer]
# [Scala](http://www.scala-lang.org/), ~~63~~ ~~60~~ 58 bytes
Saved 5 bytes thanks to the comments of @Shaggy and @Dominic van Essen
---
Golfed version. [Try it online!](https://tio.run/##TU7LasMwELzrK7aHgkTB2HkVDDI05ySX0lPpYe1KjoosNWslUIq/3V270HouuzM7O0zfoMcx1h@mSXBEF@BbALwbCx0TidT2JTwR4dfrcyIX2jdVwktwCTQ7hbihB1seYmh1tY/RGwx6DLqSHaZz1l8oyaAeFiRL8TcoI3Mz1BsWpnel7osqH4Ehc7iG5DwUOUNlNpLB5iwd6GquN8FZkHdWOqXgk@OSD7zPt0GJeU7Vateerl1tiOsWq/Vmu3vcbTfrVXEQi5A/1yLsX2PnIAYx/gA)
```
n=>(math.sqrt(n)+math.sqrt(n.toString.reverse.toLong))%1>0
```
Ungolfed version. [Try it online!](https://tio.run/##XU89T8MwFNzzK65DJXuJkn4hRQpSmQtIICbE4KS2a@Ta4LiVEO1vD05cQoMnv7t7d/eammnWtrZ657XHPVMG3wmw5QL7MBDmZFNg7Rz7en32Thn5Rgu8GOVR9sqoFcQU2FgjA3lnrebMDDxwZBrNp/OPTkllwlAGc79LO4wY@k/1xI/cNXw7VqXexvzURT4AfWByWR8FTJFjUiLD6TT2/CX6pXPcJRkOxiuNPAuPpsI6zuodUShvhxuUAJkIoijFR6jhtQn/6HKp0PWvlHw47CvuQvl8Nl8sVzer5WI@yzfJlcmgujL7w5Ku2Dlp2x8)
```
object Main {
  def main(args: Array[String]): Unit = {
    def f(n: Long): Boolean = {
      val sqrtOriginal = math.sqrt(n)
      val sqrtReversed = math.sqrt(n.toString.reverse.toLong)
      sqrtOriginal % 1 != 0 || sqrtReversed % 1 != 0
    }
    (0 until 10000).foreach(i => {
      if (!f(i)) println(i)
    })
    val bigNumber = 1234567654321L
    if (!f(bigNumber)) println(bigNumber)
  }
}
```
[Answer]
# [R](https://www.r-project.org), ~~56~~ ~~55~~ 54 bytes
*Edit: -1 byte after looking at [pajonk's answer](https://codegolf.stackexchange.com/a/262370/95126), and -1 byte by rearranging*
```
\(x)(x^.5+(x%/%rev(z<-10^(0:log10(x)))%%10%*%z)^.5)%%1
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72waMGiNNulpSVpuhY3zWI0KjQ1KuL0TLU1KlT1VYtSyzSqbHQNDeI0DKxy8tMNDYDympqqqoYGqlqqVZpAhSAORPctxoeZaRppGoaamgVFmXklGkpuiTnFqUqaqUBSASoUUlQKFFFQVrC1UwCxucBaTEjXYkmGLSZkOM3QyNjE1MzczNTE2Igc7QYGpGsyJlYLWBqix8iUDE2G5hZEBz1YGhLTCxZAaAA)
Outputs zero (falsy) for reversed-squares, non-zero (truthy) for other numbers.  
Based on the fact that there does not exist any pair of integers `x` and `y` that are not both squares, but for which `sqrt(x)+sqrt(y)` is an integer: [see here](https://math.stackexchange.com/questions/880081/the-sum-of-two-irrational-square-roots).
[Answer]
# [Raku](https://raku.org/), 23 bytes
```
{sqrt($_|.flip)!~~/\./}
```
[Try it online!](https://tio.run/##DcfdCkAwGAbgW3lpiRNs@zYUrkQtB1aKME7k59bHc/asg5u0n09EFo2/9s0dMTN3aqdxTYL3zbo0e/zenwiZQdPismDmCWEXh5qDUIGIgwtJShdakRT/8hwSQoEXJbX@Aw "Perl 6 – Try It Online")
`$_ | .flip` is an or-junction of the input number and its flipped string representation, which Raku treats as a number in nearly all contexts. `sqrt` applied to that or-junction produces another or-junction that contains the square roots of the two numbers above. Then the function returns whether it is not (`!`) the case that either of those square roots match (`~~`) the regular expression containing a period (`/\./`).
[Answer]
# [Python 2](https://docs.python.org/2/), 39 bytes
```
lambda n:n**.5%1+int(`n`[::-1])**.5%1>0
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m728oLIkIz_PaMHiNNuYpaUlaboWN9VzEnOTUhIV8qzytLT0TFUNtTPzSjQS8hKirax0DWM1IYJ2BlDlNmn5RQqZCpl5CkWJeempGoYGQKCpHW1oZGxiamZuZmpibGQYa8WlkJmmkJdfopCmkalpVVAEMjNTE2LGggUQGgA)
Reversed squares, reversed output. Returns False if input is a square and reversed square, True if not.
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 39 bytes
```
$
¶$`
O$^`\G.
.+
$*
%A`(^1|11\1)+$
^¶$
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7wX4Xr0DaVBC5/lbiEGHc9Li49bS4VLS5VxwSNOMMaQ8MYQ01tFa44oJr//w25TLgsuUxMDLkMDSwsgYQBlzGXkSmXobmFCQA "Retina 0.8.2 – Try It Online") Link includes faster test cases. Explanation:
```
$
¶$`
```
Duplicate the input.
```
O$^`\G.
```
Reverse the first copy.
```
.+
$*
```
Convert to unary.
```
%A`(^1|11\1)+$
```
Delete square numbers.
```
^¶$
```
Check that both numbers were deleted.
[Answer]
# [Fig](https://github.com/Seggan/Fig), \$8\log\_{256}(96)\approx\$ 6.585 bytes
```
!a%1mqw$
```
[Try it online!](https://fig.fly.dev/#WyIhYSUxbXF3JCIsIjQ0MSJd)
```
       $  # Inupt reversed
      w   # Pair with the input (we now have [reversed(n), n])
    mq    # Square root of each one
  %1      # Modulo 1
 a        # Any truthy (i.e. more than 0)
!         # Logical NOT
```
[Answer]
# [Arturo](https://arturo-lang.io), 42 bytes
```
$->n[0=+%sqrt do reverse~"|n|"1(sqrt n)%1]
```
[Try it!](http://arturo-lang.io/playground?hqph7l)
```
$->n[                        ; a function taking an argument n
    0=                       ; is zero equal to
    +                        ; the sum between
    %sqrt do reverse~"|n|"1  ; the square root of n reversed modulo one
    (sqrt n)%1               ; and the square root of n modulo one
]                            ; end function
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 11 bytes
```
¬Σ﹪₂Ｉ⟦θ⮌θ⟧¹
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70iOSOxKDk_MWfBgqWlJWm6FjftAooy80o0_PJLNIJLczV881NKc_I1ggtLE4tSg_KBos6JxSUa0YU6CkGpZalFxakahZqxmpo6CoaaQGC9pDgpuRhq1vJoJd2yHKXYJYYGFpYQIQA "Charcoal – Attempt This Online") Link is to verbose version of code. Outputs a Charcoal boolean, i.e. `-` if a member of A061457, nothing if not. Explanation: Uses floating-point arithmetic, so will go wrong on large enough inputs.
```
      θ     Input as a string
        θ   Input as a string
       ⮌    Reversed
     ⟦   ⟧  Make into a list
    Ｉ       Cast to integer
   ₂        Take the square root
  ﹪         Modulo
          ¹ Literal integer `1`
 Σ          Take the sum
¬           Logical Not
            Implicitly print
```
15 bytes for a theoretically correct version which actually has worse performance because it creates a list of length of the input:
```
Ｎθ¬⁻⟦θ⮌θ⟧Ｘ…·⁰θ²
```
[Try it online!](https://tio.run/##S85ILErOT8z5/98zr6C0xK80Nym1SKNQ05oroCgzr0TDL79Ewzczr7RYI7pQRyEotSy1qDgVKB@roxCQXw5U6pmXnFNanFmWGpSYl56qYaCjUKipo2CkCQTW//8bGlhY/tctywEA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
Ｎθ              First input as a number
     θ          First input
       θ        First input
      ⮌         Reversed
    ⟦   ⟧       Make into a list
   ⁻            Set difference with
          …·    Inclusive range from
            ⁰   Literal integer `0` to
             θ  First input
         Ｘ      Vectorised raise to power
              ² Literal integer `2`
  ¬             Logical Not
                Implicitly print
```
23 bytes for a version that imports Python's `math.isqrt`:
```
⬤Ｉ⟦θ⮌θ⟧⁼ιＸ▷math.isqrtι²
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70iOSOxKDk_MWfBgqWlJWm6FjcDA4oy80o0HHNyNJwTi0s0ogt1FIJSy1KLilM1CjVjNXUUXAtLE3OKNTJ1FALyy1OLNFzLEnPCEos0lHITSzL0MosLi0qUdBQygSqNNIHAeklxUnIx1Pjl0Uq6ZTlKsUsMDSwsIUIA "Charcoal – Attempt This Online") Link is to verbose version of code. Explanation:
```
   θ                    Input as a string
     θ                  Input as a string
    ⮌                   Reversed
  ⟦   ⟧                 Make into a list
 Ｉ                      Cast to integer
⬤                       All values satisfy
                     ι  Current value
          ▷math.isqrt   Integer square root
         Ｘ              Raised to power
                      ² Literal integer `2`
       ⁼                Equals
        ι               Current value
                        Implicitly print
```
37 bytes for a version that uses the Babylonian method to find the integer square root and so will work with arbitrarily large integers in linear time on the number of digits:
```
⊞υＩ⟦θ⮌θ⟧Ｗ⁼¹№υ⌊υ⊞υＥ⌊υ÷⁺κ÷§⌈υλκ²⁼⌈υＸ⌊υ²
```
[Try it online!](https://tio.run/##VY09C8IwEIZ3f0XGC1SwToqTqEOHQnAVh9AeNDRNbJJr@@9jKn7Ug7vh7nnvqRrpKit1jIJ8A5Sxk/QBbn3Grjig8wg9v3N@WI2N0sjg0pPUHvIEWjJhTpTKqI46IJ6Kff6U8gG/S8YKE85qUDWC0OShXW6OoTA1TlDK6cvr1C1PY8tnvXAq2d72JSfsiO7P9ArEmG92@7ge9BM "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
⊞υＩ⟦θ⮌θ⟧
```
Start with the input and its reversal both as the target and the initial estimate.
```
Ｗ⁼¹№υ⌊υ
```
Repeat until the estimate converges.
```
⊞υＥ⌊υ÷⁺κ÷§⌈υλκ²
```
Get the next estimate.
```
⁼⌈υＸ⌊υ²
```
Check that the square of the final estimate gives the target.
[Answer]
**Java 8, 83 bytes**
```
n->Math.sqrt(n)%1==0&Math.sqrt(new Long(new StringBuilder(""+n).reverse()+""))%1==0
```
this lambda can be used for a functional interface such as IntPredicate
[Try It Online](https://tio.run/##ZU5NS8QwED23v2IoKAnLBhU8ST14E1wQ9igeZpuxpqaTmkwqIvvba7AexJ3LDG/e14AzbsNEPNi3ZZnywbsOOo8pwQ4dw1dd/YJJUMqag7MwlpfaS3TcPz0Dxj7pwoR/MxRvk8V585K5ExfY3LM8RrKuQyHwOB4stic6AN7e7lBeTXqPolifXbbtxfkfhD7gIXD/c6w17rLzlqJqmg1rE2mmmEjpTdPoVX6SclNX1f4zCY0mZDFTcRHPai1lhJKo6yutC@1YH5flGw)
[Answer]
# [R](https://www.r-project.org), ~~59~~ 58 bytes
```
\(n,t=10^(1:nchar(n)-1))n^.5%%1|(n%/%t%%10%*%rev(t))^.5%%1
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72waMGiNNulpSVpuhY3rWI08nRKbA0N4jQMrfKSMxKLNPI0dQ01NfPi9ExVVQ1rNPJU9VVLgCwDVS3VotQyjRJNTYgU1ISpaRqGmsoKtnYKIUWlqVxpGiYoPEtUORNUtYZGxiamZuZmpibGRmgyBgZIfKCAMYTrlphTDJI3MkXlG5pbmCCJQBy3YAGEBgA)
```
\(n,t=10^(1:nchar(n)-1))any(c(n,n%/%t%%10%*%rev(t))^.5%%1)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72waMGiNNulpSVpuhY3rWI08nRKbA0N4jQMrfKSMxKLNPI0dQ01NRPzKjWSgXJ5qvqqJaqqhgaqWqpFqWUaJZqacXqmQAFNqAlT0zQMNZUVbO0UQopKU7nSNExQeJaociaoag2NjE1MzczNTE2MjdBkDAyQ-EABYwjXLTGnGCRvZIrKNzS3MEESgThuwQIIDQA)
Outputs flipped TRUE/FALSE.
[Answer]
# Excel, 80 bytes
```
=LET(
    a,LEN(A1),
    b,HSTACK(A1,CONCAT(MID(A1,1+a-SEQUENCE(a),1)))^0.5,
    AND(INT(b)=b)
)
```
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), 5 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
‼°x°╓
```
[Try it online.](https://tio.run/##y00syUjPz0n7//9Rw55DGyoObXg0dfL//4ZcJlyWXCYmhlyGRsYmpmbmZqYmxkZAnoEBlzGXkSmXiQWXobmFCQA)
Or alternatively:
```
xαm°╓
```
[Try it online.](https://tio.run/##y00syUjPz0n7/7/i3MbcQxseTZ38/78hlwmXJZeJiSGXoZGxiamZuZmpibERkGdgwGXMZWTKZWLBZWhuYQIA)
**Explanation:**
```
‼     # Apply the next two operators separately on the current stack:
      # (which will use the implicit input-integer)
 °    #  Check if it's a perfect square
  x   #  Reverse it
   °  # Check if this top reversed integer is a perfect square as well
    ╓ # Pop both, and get the minimum of the two
      # (which will be truthy if both were truthy; or falsey if either/both were falsey)
      # (after which the entire stack is output implicitly as result)
x     # Reverse the (implicit) input-integer
 α    # Pair the top two values, which is the (implicit) input and the reversed input
  m   # Map over this pair:
   °  #  Check for both whether it's a perfect square
    ╓ # Pop the square, and push its minimum
      # (which will be truthy if both were truthy; or falsey if either/both were falsey)
      # (after which the entire stack is output implicitly as result)
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes
```
ṚƬḌ½ḞƑ
```
[Try it online!](https://tio.run/##y0rNyan8///hzlnH1jzc0XNo78Md845N/H@4XTPy//9oLkMdLhMdLksgaQJkGhoZm5iamZuZmhgbgbgGBjpcxjpcRqZAeQsg39wCqDgWAA "Jelly – Try It Online")
```
ṚƬ        Reverse while unique.
  Ḍ       Vectorizing convert from decimal.
   ½      Vectorizing square root.
     Ƒ    Is the entire list of results unchanged by
    Ḟ     vectorizing floor?
```
[Answer]
# [Lua](https://www.lua.org/), 26 bytes
```
n=...a=n^.5&n:reverse()^.5
```
[Try it online!](https://tio.run/##yylN/P8/z1ZPTy/RNi9Oz1Qtz6ootSy1qDhVQxPI/f//v6GRsYmpmbmZqYmxkSEA "Lua – Try It Online")
Outputs using the exit code (`0` is true, `1` is false).
This works because Lua can't do bitwise operators on non-integer numbers. If either `n^.5` or `n:reverse()^.5` is not an integer, the program will error.
[Answer]
# Javascript, ~~43~~ ~~40~~ 42 Bytes
Thanks to @Arnauld for -3 Bytes (-2 from backticks (which I forgot), -1 from inverse output)
```
n=>[...n].reverse().join``**.5%1*n**.5%1>0
```
[TIO](https://tio.run/##fc5NCoMwEAXgfU8hQiEKHZOY@LPQi5SCQZKiSFISm@unlHZRKsxqFt97j1lVVGH2y2O/xC6ZIdlhvAKAvYHXUfugSQGrW@w0lSXIMyvt5440zc4Gt2nY3J0YkrO8KLKqynb/1Kc/E4j1WE9gq4zXQjZtI0XN0Rylv3rgvvmyUVs4tGsMucSUtZ1A/f11egE)
[Answer]
# [JavaScript (V8)](https://v8.dev/), 40 bytes
```
g=x=>x**.5%1||g([...x].reverse().join``)
```
[Try it online!](https://tio.run/##fdDdCoIwFAfwe59iCMEmNL/mF2EvEoEypiniYk4x0mc3Mwsx2Lna2e9/zsUp0y5tqCju8tiF05THfXzuDQN7B3sYcnjBGPdXLFjHRMMgwiUv6iRBU9bWVBa8BhnsEXhqYC4pHuvrXfkMp18nmGzFnE6rhn1@R0BTSW8AMrSZWnNStN@YNmoa5XXDK4YrnsMM6raOEDDNJbU3orBINUdUW23HJZ4f@B5xHWXOsrb6x5G/8nKIPbsqdDyV2kFItj69AA "JavaScript (V8) – Try It Online")
Throws as `true` and not throw as `false`.
Here assumes a reasonable stack(actually <1KB is enough, number is stored in heap) so it's allowed
# [C (gcc)](https://gcc.gnu.org/), 66 bytes
```
a;g(n){a=sqrt(n);a=a*a-n;}f(n){for(g(n);n;n/=10)a+=9*a+n%10;g(a);}
```
[Try it online!](https://tio.run/##XVDbboMwDH3vV3hIlQIEFXrRirLsZdpXDB6iNDC0NnRJpqFV/PqYoRTRRbblHPs4OZZRKWXXCVYS7V8Et5/GYcYEF4GINGuLHi9qQ/oGpple8ST2RcjTQIR6mcTIFD5ru0o7OIlKEx8uC8DTA05ZZ99y4HBJKGwppBi3mCZxTGFDYb3D/HGPlWSPnrRs4qrmrKRTh4k@t3huI0nW2jqQ78IEGJX8UObK9bLmdZ016Qv6zqMwv2@8kY0agfTvVvqgGqTFbEyfwFY/qi7I7Uf@agSCCWEQhkP3Tf20AZx03cJQztld1WL1oSDOv4cVwpP8/7yzwZaCeMsDRM@AcWkzjaocBUsn4ZZzlY9j2yEa5b6MRlmLtvuVxVGUtouOpy76/gM "C (gcc) – Try It Online")
Strongly pushed [Noodle9's](https://codegolf.stackexchange.com/a/262365/76323)
[Answer]
# [Ruby](https://www.ruby-lang.org/), 42 bytes
```
->n{n**0.5%1+n.digits.join.to_i**0.5%1==0}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6vOk9Ly0DPVNVQO08vJTM9s6RYLys/M0@vJD8@Eypja2tQ@79AQcNAT8/QwMBAU684NSc1uURDLU3zPwA "Ruby – Try It Online")
[Answer]
# [Racket](https://racket-lang.org) - 155 bytes
```
#lang racket
(define(m v)(let([r(string->number(list->string(reverse(string->list(number->string v)))))][? integer?])(and(?(sqrt v))(?(sqrt r)))))(m(read))
```
[Try it online!](https://tio.run/##PYw7DoMwEET7nMJSmnVBwZ80@CCIwok3lhVjifWG6zsYRKaaz9OQfn2QU7p7HaygI93A4NsFhEVsEjwyTASRyQVbjOG7PJHAu8jFeJZAuCFF/DN5hBO8mP0pa56UcIHRIqlZgg4GFMSVOO@XpQOFZf/VRsqUyqpu2q4fHkPftU1dlT8 "Racket – Try It Online")
---
## Explanation
On line one, we have Racket's required language statement, `#lang racket`, This just imports all of the statements/functions used in the language (like `define` and `read`, as well as wrapping our program into a `module`.
The second line is where the main program lies. We define a function named `m`. This function received an integer `v` as an argument. We then reverse the integer to obtain an integer named `r`. We take the square roots of both `v` and `r` and see whether they are integers or not. If both checks return true, then the number is a Reversed Perfect Square.
Here's the program in all its glory. In the shortened form, I embedded `reverse-number` as part of `main`'s local scope. But to make it easier to read and understand, I made it its own function:
```
#lang racket
(define (reverse-number value)
  (string->number (list->string (reverse (string->list (number->string value))))))
(define (main value)
  (let ([reversed-value (reverse-number value)])
    (and (integer? (sqrt value))
         (integer? (sqrt reversed-value)))))
(main (read))
```
As of right now, Racket doesn't have a `reverse-string` or `string-reverse` function. So, the only way I could reverse the number was to first convert the number to a string, then convert the string to a list, reverse the list, convert the list to a string, then convert the string to a number. But if we did have a `string-reverse` function, I would've written:
```
(string->number (string-reverse (number->string value)))
```
Also, while I could've used `quotient` and `remainder`, it ended up bumping the number of bytes up by a tad bit (I got 180).
---
Example usages of `main`:
```
;; An infinite loop that loops over all natural numbers [1..] and finds all RPSs
(for ([i (in-naturals)] #:when (main i))
  (displayln i))
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), ~~10~~ 9 bytes
*-1 byte by realizing that `v` automatically vectorizes*
```
sMI@R2v_B
```
[Try it online!](https://tio.run/##K6gsyfj/v9jX0yHIqCze6f9/JUMTEyUA "Pyth – Try It Online")
### Explanation
```
sMI@R2v_BQ    # implicitly add Q
              # implicitly assign Q = eval(input())
       _BQ    # bifurcate Q over reversal
      v       # eval (automatically vectorizes)
   @R2        # map each to their square roots
  I           # check for invariance over
sM            # converting the entire list into integers
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 11 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
[UUsÔ]m¬ev1
```
PD: Definitely can be golfed down
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=W1VVc9RdbaxldjE&input=MTIzNDU2NzY1NDMyMSAK)
---
# [Japt](https://github.com/ETHproductions/japt) [`-¡`](https://codegolf.meta.stackexchange.com/a/14339/), 11 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
¬v1 ©UsÔ¬v1
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LaE&code=rHYxIKlVc9SsdjE&input=MTc4NAo)
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-E!`](https://codegolf.meta.stackexchange.com/a/14339/), 8 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
Based on [l4m2's solution](https://codegolf.stackexchange.com/a/262379/58974) but with correct output.
```
¬%1ªßUìÔ
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LUUh&code=rCUxqt9V7NQ&input=MTc4NA)
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 35 bytes
```
AtomQ@Tr@Sqrt@{#,IntegerReverse@#}&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b737EkPzfQIaTIIbiwqMShWlnHM68kNT21KCi1LLWoONVBuVbtf5q@Q7WhjomOpY6JiaGOoZGxiamZuZmpibERkGdgoGOsY2SqY2huYVKrrx9QlJlX8h8A "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~75~~ ~~73~~ 67 bytes
```
b;f(n){b=sqrt(n);for(b=b*b-n;n;n/=10)b+=9*b+n%10;n=sqrt(b);b-=n*n;}
```
[Try it online!](https://tio.run/##ZVDbbsIwDH3nK7xKSGmbiobLBsqyl2lfMXggacqqQWBJplWr@uvrTFsq2HJxnGP7JD4q2SnVNJLnxISVFO7DevR4frREChnJxHCcE8HSUMZiFcnYjFnKTZcpQy4TYSLD66YwHg7bwpAQqhHgOANeO@9eNyCgYhTmFFZo5@iyNKUwozBdoP@wxAhb4mb9ec9qPpDo8qSV19nAc73S/6svVUfjPKi3rY3QavWubccQrMuX6bpcPeNeBBSu77Ogr0YFgJxfL0ymSyxLee8@giu@9TEnl3@Fkx6IBoRDHLfZFzEGQZCpE6UNb/hN1GH0Lic@vIU1woMIf@tOFlNyEowzSJ4A7ditDXblKTg6NO6E0Juetm6t1f7TGmxrVDc/Kt9vd65J9ocm@foF "C (gcc) – Try It Online")
*Saved ~~2~~ 8 bytes thanks to [c--](https://codegolf.stackexchange.com/users/112488/c)!!!*
]