[Question]
  [
Given a positive integer, determine if it can be represented as a concatenation of two square numbers. Concatenated numbers may not begin with 0 (except for 0). Any leading zeros in input should be ignored.
Examples
```
11 -> true // because 1 and 1 are squares  
90 -> true // because 9 and 0 are squares  
1001 -> true // because 100 and 1 are squares  
144100 -> true // because 144 and 100 are squares  
151296561 -> true // because 15129 and 6561 are squares  
164 -> true // because 1 and 64 are squares (also 16 and 4)  
101 -> false // can't be 1+01 as a number may not begin with 0  
016 -> false // leading 0 is ignored and 16 doesn't count
9 -> false // need two squares  
914 -> false // need two squares (there are three)
```
Task
Given a positive integer return a value indicating if it is a concatenation of two squares.
This is code-golf the goal is to minimize the size of the source code as measured in bytes.
  
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 7 bytes
```
~cĊ~^₂ᵐ
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r/vy75SFdd3KOmpodbJ/z/b2hqaGRpZmpmCAA "Brachylog – Try It Online")
### Explanation
```
~cĊ       Deconcatenate into a couple of 2 elements Ċ
  Ċ~^₂ᵐ   Each element of Ċ must be the square of a number
```
[Answer]
# [R](https://www.r-project.org/), 42 bytes
```
function(x)x%in%outer(y<-(0:x)^2,y,paste0)
```
[Try it online!](https://tio.run/##bc1RCsMgDADQ0xQSSCEZpeDYrjIRsVAo6jQyPb3bAfb3/l6ZPkXv1KbD6ifZ@m6uhPqcR4tezxShY1/OuKSmocB4rMD3jq8bDcquamCc1eV8DfAgQoZJmIVk334QYtnJkJEN6W@E8ws "R – Try It Online")
Same horribly-inefficient approach as [my Husk answer](https://codegolf.stackexchange.com/a/242678/95126).
[R](https://www.r-project.org/)'s `%in%` function to search for an element in a vector conveniently appears to cast its arguments to the same type (here the numeric input `x` and the character vector of `paste`d-together squares), which was a nice surprise to me.
*Note:* After reading [Fatalize's comment](https://codegolf.stackexchange.com/a/242680/95126), I realise that this answer is also *very* close to [pajonk's answer](https://codegolf.stackexchange.com/a/242465/95126) to the "[Sum of two squares"](https://codegolf.stackexchange.com/q/242459/95126) challenge. Note though that that answer wasn't the shortest in [R](https://www.r-project.org/), so a small change to the challenge does seem to favour a completely different approach, which is also nice.
[Answer]
# Python 3.6 (with IO), 73 bytes
```
n=input();l=range(int(n));print(n in[f"{i*i}{j*j}"for i in l for j in l])
```
You could also use,
```
n=input();l=range(int(n));print({n}&{f"{i*i}{j*j}"for i in l for j in l})
```
But unfortunately it doesnt output booleon values rather it outputs, `{n}` for `True` and `set()` for `False`
[Try on Online](https://tio.run/##K6gsycjPM/7/P882M6@gtERD0zrHtigxLz1VIzOvRCNPU9O6oAjMUsjMi05Tqs7UyqytztLKqlVKyy9SyASKKuQogJhZYGas5v//AA)
slightly longer answer (By 2 bytes)
```
n=int(input());print(str(n)in[f"{(k//n)**2}{(k%n)**2}"for k in range(n*n)])
```
and without a loop
```
n=int(input());m=k=0;exec('m+=f"{(k//n)**2}{(k%n)**2}"==str(n);k+=1;'*n**2);print(m>0)
```
[Answer]
# [Julia](https://julialang.org/), ~~130~~ ~~122~~ ~~98~~ 91 bytes
```
!x=√parse(Int,x)%1
f(a,s="$a",l=length(s))=0∈1:~-l.|>i->s[l-i]<'1'||!s[i+1:end]+!s[1:i]
```
[Try it online!](https://tio.run/##JctBCoMwEAXQfU@h0mKCScm0MaBU9z2DZBGotilpEGMhC@naM/R4XsRGCsOfx2fm@TZagV/X2FfL/O3V4Fp0tSPx@AC7DiniqmSvEmIq09r7@EAO44ot8wzlh5rjVGtau8ZQLS8ppNMUu0ZnULb2JrNgKLVc@0Hb0Vj0Uj3ytO6Qx6QBIFHBSASMBQHnAWHncCpELrZKcBKdN4X4k/PtPjQMRPgOA1xivP4A)
Thanks to Sunda R we can save 8 bytes!
Thanks to MarcMush we can save ~~32~~ 39 bytes!
[Answer]
# [Husk](https://github.com/barbuz/Husk), 12 bytes
```
€s¹Σ´Ṫ+mos□ŀ
```
[Try it online!](https://tio.run/##yygtzv6f@6ip8f@jpjXFh3aeW3xoy8Odq7Rz84sfTVt4tOH////RhoY6lgY6hgYGhjqGZiZAhqGOgaGZjqWOpaFJLAA "Husk – Try It Online")
Outputs nonzero for 'concats of two squares', zero for numbers that aren't.
Builds a list of 'concat of two squares' numbers, and then checks if the input is present. So not very efficient for large inputs...
```
€s¹Σ´Ṫ+
       mos    # get strings of 
          □ŀ  # all squares up to input,
    ´Ṫ        # combine all combinations
      +       # by concatenation,
   Σ          # flatten the list-of-lists
€s¹           # and look for the input as a string
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~56~~ 53 bytes
2 byte from tsh
```
x=>(g=_=>x--&&x*x+'|'+g(),x+g).match(`^(${g()}){2}_`)
```
[Try it online!](https://tio.run/##FYzRCsIgFEC/ZRDbvalDYwQ@6I9EbWKbLdYcTUJY@3azp3M4D@dpPma173EJbPb3Pg0qRaXBqVbpyFhZxmMk1bciDpBG4rB@mWAf0N3gsOW243ba2w6T9fPqp76evIOLEFRyKjgXVJybLH9SSaVornmwQFC6KAYIiJh@ "JavaScript (Node.js) – Try It Online")
RegEx with many choices
[Answer]
# [Julia 1.0](http://julialang.org/), ~~47~~ ~~44~~ 37 bytes
```
~n="$(n^2)"
!a="$a"∈.~(r=0:a)'.*.~r
```
[Try it online!](https://tio.run/##yyrNyUw0rPj/vy7PVklFIy/OSFOJSzERyE5UetTRoVenUWRrYJWoqa6npVdX9L8ktbikWMFWIdrQUEfB0kBHwdDAAMhSMDQz0VEwNjMECQAJA0MzoDQQGZrEchUUZeaV5OTpaUA069naKegpgtma/wE "Julia 1.0 – Try It Online")
[Answer]
# [Burlesque](https://github.com/FMNSSun/Burlesque), 29 bytes
```
Jsuf{?sXXsm}0_+)up2CB)++jup~[
```
[Try it online!](https://tio.run/##SyotykktLixN/V9dlPnfq7g0rdq@OCKiOLfWIF5bs7TAyNlJU1s7q7SgLvp/bXjOf0NDLksDLkMDA0MuQxMTIM1laGpoZGlmagYUMDMByhhyGRiacVlyWRqaAAA "Burlesque – Try It Online")
```
J   # Duplicate
su  # Substrings of
f{  # Filter for
 ?s # Sqrt
 XX # [floor, ceil]
 sm # Same (i.e. is int)
}   # -- Is square
0_+ # Append 0 to list
)up # Unparse each to str
2CB # Combinations of pairs
)++ # Mapped Concat 
j   # Reorder stack
up  # Unparse input
~[  # Is in list
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~127~~ 125 bytes
```
i;r;q(n){for(r=i=n;i;--i)r=r&&i*i-n;i=!r;}t;h;m;f(n){for(t=h=0,m=1;n>9;n/=10,m*=10)n%10|m<2?h+=n%10*m,t|=q(n/10)*q(h):0;n=t;}
```
[Try it online!](https://tio.run/##XVFRb4IwEH7fr@hINAUhtg5N2Fn3sOxXTB9MLdJsVG2bjEz562OHIJkjx/X63Xdfe1eZ7KVsGg0WTtSE5/xgqRVaGNCQJDq0wo7HOtIJAuLRQu2hgBLyG9eLQrC4FBzMKgMzFRx3EfrQjDi7lMvZSzERbRyVsb8IPGSKyehEi/CZgREe6kYbT8qtNjQk5weCXwt45bx73xBBzpzHJGMx4YxhxNMUA1znfJYt5osWWqRttqWh8bSGQUZVRyW92vVKSLs31llfIQ/GeSKLrY3QK/mhbFcYrKu32brKXvGfBzH5u38K@mocCKHtodrsVIVlDPpwSZz@Voec3q4TTnsgGhAgk8mVHV7Fuknc2jCo1k3kStnAXdZhtn2Se1QhOrT/v@xokZLTYLQjyYqgH7m1wcZMTFw89O6EUJtetn6omx@Zf273rkm@fgE "C (gcc) – Try It Online")
*Saved 2 bytes thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)!!!*
[Answer]
# [Haskell](https://www.haskell.org/), ~~54~~ 51 bytes
```
f n|l<-show.(^2)<$>[0..n]=elem(show n)$(++)<$>l<*>l
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P00hrybHRrc4I79cTyPOSNNGxS7aQE8vL9Y2NSc1VwMkrpCnqaKhrQ2SyrHRssv5n5uYmadgq5CSz6VQUJSZV6KgopCmoGBoqKCggCJiaYAuYmhgYAgUwRA2M8FUiWGcgaEZmvkYFhqa/AcA "Haskell – Try It Online")
* Thanks to @ovs for saving 3 Bytes.
So much inefficient approach:  
*l* is all numbers up to input squared and to string.  
We search trough the powerset of *l* if there is a pair that form the input
[Answer]
# [Python 2](https://docs.python.org/2/), 68 bytes
Inefficient and somewhat boring approach.
```
lambda n:`n`in('%d'*2%(a*a,b*b)for a in range(1,n)for b in range(n))
```
[Try it online!](https://tio.run/##RY1BCsIwEEX3nmI2oUkYIVNCIQU9iYtOiNGCTkvoxtPHxI2rz3uL//bP8dxkrPlyqy9@x8Qg8yLLKnpQabCj0mwZo40mbwUYVoHC8rhrQvmp@FdiTO1KuiLC4JCcIyTv2yJNvnHDCQMG8vMJYC@rHC1FLsH5Ci0JCrQg5P5m6hc "Python 2 – Try It Online")
---
# [Python 2](https://docs.python.org/2/), 77 bytes
Much more efficient and interesting.
```
f=lambda n,m=0,d=1:n and((m*10<d!=10)==n**.5%1+m**.5%1)|f(n/10,m+n%10*d,d*10)
```
[Try it online!](https://tio.run/##JY7BCoMwEETv/YrtQUx022ZFBaXpr4htGhpoNhLiodB/tymeHswMM7N80itws9kYPEyTXdMan9MEzi8hJlii45RVfiQXeLP6Pfu7mYHRa4VG08gwsxHCV6Su5qhJSa25qs5dQbXfKb9W8IUU@poLUpVBk9NysyECg2MgwkEhKUVIbZuJ1FEz9F2fhb7Nzp844EDteID9lShzl4HTDQpTQgGCEfKOlHL7AQ "Python 2 – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) `-ap`, ~~69~~ 64 bytes
```
$_=grep{1<grep/^0$|^[^0]/&sqrt!~/\./,unpack$_."A*","@F"+0}A1..A9
```
[Try it online!](https://tio.run/##HYnLCsIwEEX38xeG4EJrMqOTQEDBbvwJNaVIEbG0Ma0rH59ujC4u53JOaGJrUpLV5hyb8KD1D9qjfPq9x6OeDrc4Tt76oHRx70J9uspKiXImCrHdiTm@SlKqdCkRgUMgRAJizgQytHTW2Cws50KAZMGBI4ZVtnn/w/zpw3jpuyEt6tB@AQ "Perl 5 – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) `-nE`, ~~78~~ 61 bytes
```
say int=~/^((.+)(?(?{$+eq(0|$+)&(0|sqrt$+)**2==$+})|^))(?1)$/
```
[Try it online!](https://tio.run/##HY5BCsMgFET3/xRZSNFIGn@qggvJCXqFQBYWAsUkahelaY9e@@limOHNLGYL6W5qzfOzWWLxn37i/CwFH/n4YjLsXB1MihNZ3lOh2LaD90y@xTEJmqFgfa2I4BSgUgioNTmgwcFZYwlYTQ2CQgsOHGq4ECX9g9bwXbeyrDHXLjbd9Rbm8kjB06Mf "Perl 5 – Try It Online")
A whopping -17 bytes thanks to @kjs.
**Explanation**:
```
say int                      # convert input to number to remove leading 0s
        =~                   # and match it against the regex
           /^(               # match from the beginning of input
           (.+)              # match 1 or more digits
           (?                # evaluate a condition here
             (?{             # the condition is the result of this code
               $+            # the digits matched so far are in $+
               eq            # string equality check
               (0|$+)        # int($+) - golfy way of writing it
                             # if they're equal, no leading 0s here     
               & 
               (0|sqrt$+)    # again, golfy form of int(sqrt($+))
               **2==$+}      # square that and compare to original number
               )             # if no leading zeroes and number is a square
                             # do nothing and move on 
             |               # else
             ^               # add an impossible pattern here so regex match fails
             )
             )               
             (?1)            # now do the same match again, for the second square
             $               # and that should be the end of input
             /x;
```
The trick is in exploiting regex "backtracking" mechanism.
Any time the part of the string we're looking at doesn't match
the conditions we want, we make the match fail deliberately
so that the regex engine chooses a different subset of the input string
for the /(.+)/, and automatically tries the match again.
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 55 bytes
```
^0+
\B
$'¶$`;
A`;0.
\d+
$*
m`(^1|11\1)+;(1(?(2)1\2))*$
```
[Try it online!](https://tio.run/##DccxCoQwEAXQ/p8j4sSAzJcghBSijZcIEsEtttBisfRcHsCLZa0e7/c5v8daKplzWdQBaYKpn9vkiDFHbZE2B9Ngz7LwIhOti0IZpLNMnbWNKYVEUFCVoPevYO/fE8oeAYH@Dw "Retina 0.8.2 – Try It Online") Link includes faster test cases (a `^` after the `m`` would speed it up enough to be able to check `151296561` on TIO). Outputs the count of square concatenations, so for example `144100` can be split up as `144` and `100` or alternatively as `1` and `44100`, so the output would be `2` in that case. Explanation:
```
^0+
```
Delete leading zeros.
```
\B
$'¶$`;
```
Try splitting between every pair of digits.
```
A`;0.
```
Delete numbers with leading zeros.
```
\d+
$*
```
Convert to unary.
```
m`(^1|11\1)+;(1(?(2)1\2))*$
```
Match two square numbers. `(1(?(2)1\2))*` is a generalised match for a square number; `(^1|11\1)+` is a simplified special case for a non-zero square to be matched at the start (of a line).
[Answer]
# [Julia 1.0](http://julialang.org/), ~~38~~ 47 bytes
```
~a=string.(a.^2);!a=any(~(0:a)'.*~(0:a).=="$a")
```
[Try it online!](https://tio.run/##JY3BCgIxDETvfkV2EWylhERLQSX@iCjkILKylMVW0Mv@eq1bGIbHTMg83@Og/CllVkn5NcQHGsXbzp46FY1fMxs6qt3gtgGK9Gvtbcn3lBMIXJgdHMgBE1Xi4B3sAy/W0Pt/WRPiUE@r2F9XU93KY0TTHqGcAbuFbfkB "Julia 1.0 – Try It Online")
Based on [MarcMush](https://codegolf.stackexchange.com/a/242861/101725)’s answer (tnx for pointing out the error when squaring)
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 92 bytes
```
f=lambda n,x=1:x<len(n)and all(e[0]!='0'and int(e)**.5%1==0for e in[n[:x],n[x:]])or f(n,x+1)
```
[Try it online!](https://tio.run/##FcxBCsMgEEDRq9hF0UlDcVoMjdSTiAtLlBbMRCQLc3prtg/@z8f@3ej5yqW1aJJfP4tnNFaDur5TIEHgaWE@JRGsdBfDJT/hR7sIMAx3dUVjZNwKCx0tWV3dSLZq56BjFH12Q2i5nEkUHBU@5klNyAHaHw "Python 3.8 (pre-release) – Try It Online")
-28 for @ophact's tip
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 8 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ÝāsânJIå
```
Based on [my 05AB1E answer for the *Sum of two squares* challenge](https://codegolf.stackexchange.com/a/242461/52210).
[Try it online](https://tio.run/##yy9OTMpM/f//8NwjjcWHF@V5eR5e@v@/pQEA) or [verify (almost) all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfeX/w3OPNBYfXpTnVXl46X@d/9GGhjqWBjqGBgaGOoYmJkBax9DMRMfYzBCEwQwTE6C0oY6SgaGZko6ljqWhSSwA) (`151296561` is omitted since it'll timeout).
**Explanation:**
```
Ý         # Push a list in the range [0, (implicit) input]
 ā        # Push a list in the range [1,length] (without popping the list)
  s       # Swap so the [0,input] list is at the top
   â      # Cartesian product: create all possible pairs using these two lists
    n     # Square each inner integer
     J    # Join each pair together
      Iå  # Check if the input is in this list
          # (after which the result is output implicitly)
```
We can't just use the range \$[0,input]\$ twice, since it would create a false positive with for example `"09"` and input `9`. We also can't just use the range \$[1,input]\$ twice, since it would fail with for example input `90`. Hence the use of the range \$[1,input+1]\$ with \$[0,input]\$ for the creation of pairs with the cartesian product instead.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 37 bytes
Probably can be golfed a *lot*, but this is too long for me.
So basically for every `i` in input `n`, it checks if both `n[:i]` and `n[i:]` are squares.  
I think the time complexity is \$O(2\*\mathrm{len}(n)) \$
```
Lʁƛ?fnȯṅ:h⌊[⌊|3]∆²→?fẎṅ:h⌊[⌊|3]∆²←∧;a
```
Explanation:
```
Lʁƛ?fnȯṅ:h⌊[⌊|3]∆²→?fẎṅ:h⌊[⌊|3]∆²←∧;a
Lʁ                                     Exclusive 0 range of length(n)                                    
  ƛ                                    Map through range
   ?f                                  Push stringified n
     nȯṅ                               Slice from loop index to end
        :h⌊[⌊|3]                        Duplicate slice, if int(head) = 0, push 3 (non-square) else int(slice)
               ∆²→                     Set var to "is a perfect square?"
                  ?f                   Push stringified n
                    Ẏṅ                 Slice from 0 to loop index
                      h⌊[⌊|3]           Duplicate slice, if int(head) = 0, push 3 (non-square) else int(slice)
                            ∆²         Is it a perfect square?
                              ←        Get var
                               ∧       Are both are squares?
                                ;a     End map, check if any element is true.
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJMyoHGmz9mbsiv4bmFOmjijIpb4oyKfDNd4oiGwrLihpI/ZuG6juG5hTpo4oyKW+KMinwzXeKIhsKy4oaQ4oinO2EiLCIiLCIxNDQxMDAiXQ==)
[Answer]
# MATL, 33 bytes
```
Vf3L)"GV@:&),tUV=A3MtX^kU=*w]*?T.
```
[Try it out](https://matl.suever.net/?code=Vf3L%29%22GV%40%3A%26%29%2CtUV%3DA3MtX%5EkU%3D%2aw%5D%2a%3FT.&inputs=016&version=22.4.0)
Outputs 1 for truthy, nothing for falsey.
```
V           % take in number (ignoring initial 0s) and convert to string
f           % get list of its indices (starting from 1)
3L)         % remove the last index
"           % for 1 to end-1
  GV        % get input as string again, say S
  @         % get the current loop index i
  :         % form range 1:i
  &)        % split S[1:i] and S[i+1:end]
  ,         % for each split part
    t       % duplicate it
    U       % convert to numeric
    V       % and back to string - this gets rid of initial 0s
    =A      % condition 1: did that give the same string back? 
    3M      % get the numeric form N of the current part again
    tX^kU   % floor(sqrt(N))^2
    =       % condition 2: did that get the number back
            %   i.e. is it a square number
    *       % AND those conditions
    w       % swap the other part in to be checked
  ]         % end
  *?        % if both parts satisfied the conditions
    T       % save True to output
    .       % break
            % (implicit) end
            % (implicit) end
            % (implicit) convert to string and display
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 10 bytes
```
›₌ɾʁẊ²vṅ⌊c
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLigLrigozJvsqB4bqKwrJ24bmF4oyKYyIsIiIsIjkwIl0=)
An 05AB1E port.
## Explained
```
›₌ɾʁẊ²vṅ⌊c
›          # Increment the input
 ₌ɾʁ       # The range [1, input + 1] and the range [0, input + 1)
    Ẋ      # Cartesian product of those ranges
     ²     # Square each number in each pair
      vṅ⌊  # Integer version of each pair concatenated into a single string
         c # Does that contain the original input? 
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 20 bytes
```
⊙…¹Ｉθ⊙…⁰Ｉθ⁼θ⪫Ｘ⟦ιλ⟧²ω
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMMxr1IjKDEvPVXDUEfBObG4RKNQU1NHASFsgCzsWliamFOsUaij4JWfmacRkF@eWqQRnamjkBOro2AEVFCuCQLW//8bmpgYGhj81y3LAQA "Charcoal – Try It Online") Link is to verbose version of code. Takes input as a string and outputs a Charcoal boolean, i.e. `-` for a concatenation of two squares, nothing if not. Explanation:
```
 …                      Range from
  ¹                     Literal integer `1`
    θ                   To input
   Ｉ                    Cast to integer
⊙                       Does any satisfy
      …                 Range from
       ⁰                Literal integer `0`
         θ              To input
        Ｉ               Cast to integer
     ⊙                  Does any satisfy
           θ            Input as a string
          ⁼             Equals
              ⟦ιλ⟧      List of loop variables
             Ｘ          Vectorised to power
                  ²     Literal integer 2
            ⪫      ω    Joined
```
]