[Question]
  [
Consider the string `160615051`. It can be "triangulated" as such:
```
  1
 606
15051
```
Then, each row is a palindrome. Also note that each side on the perimeter is also a palindrome:
```
  1  |   1   |   
 6   |    6  |      
1    |     1 | 15051 
```
Therefore, this string can be considered to be a fully-palindromic triangle. Don't worry about the altitude `100` in this case, it doesn't have to be palindromic.
**Input:** A string of printable ASCII characters from 0x20 to 0x7E. This can be a character array, a single string, or an array of ASCII code points. Your input will always be able to be triangulated (that is, its length will always be a perfect square).
**Output**: A truthy value if the string is a fully-palindromic triangle, or a falsey value otherwise.
## Test cases
```
input => output
1 => true
A => true
AAAA => true
nope => false
{{}} => false
1101 => true
1011 => false
1202 => false
111110001 => true
160615051 => true
160625052 => false
1111111111111111 => true
1121123211234321123454321 => true
HHeHHeleHHellleHHellolleH => true
HellolleHHellleHHeleHHeHH => false
111111111111111111111111111111111111 => true
abcbdefeddefgfedbcdefedcbabcdefedcba => true
```
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~14~~ 12 bytes
```
J’Æ²œṗZ⁻¦µU⁼
```
[Try it online!](https://tio.run/##y0rNyan8/9/rUcPMw22HNh2d/HDn9KhHjbsPLTu0NfRR457/D3dvObT16J7D7Y@a1mQB8aOGOQq2dgqPGuZG/v9vyOXI5QgEXHn5Balc1dW1tVyGhgaGXEAMJIwMjIBcIDAwAImZGZgZmhqYQlhGQBZUFgkABYyAyBhMmEApUxCDy8MjFYhywEQOlMoHMbjgLIRMKlg1hvHYAFdiUnJSSmpaagqQSAdSSclgXnJSIoIFAA "Jelly – Try It Online")
### Background
We start by looking at the 0-based indices of the input string.
```
 H  H  e  H  H  e  l  e  H  H  e  l  l  l  e  H  H  e  l  l  o  l  l  e  H
 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
```
To get the rows of the triangle, we can split the string before the indices **1**, **1 + 3 = 4**, **1 + 3 + 5 = 9**, and **1 + 3 + 5 + 7 = 16**. Since **(n + 1)² = n² + (2n + 1)**, these sums are precisely the positive, perfect squares in the index list. If we also split the string before **0**, this is as simple as splitting before all 0-based indices that are perfect squares.
After splitting, we get the following strings.
```
""
"H"
"HeH"
"HeleH"
"HellleH"
"HellolleH"
```
Next, we replace the empty string at the beginning with all the characters in the first column.
```
"HHHHH"
"H"
"HeH"
"HeleH"
"HellleH"
"HellolleH"
```
The task is now reduced to checking whether reversing all strings yields the same string array.
### How it works
First `J` generates all 1-based indices of the input string `J`, then decrements them with `’` to yield all 0-based indices. `Æ²` tests all 0-based indices for squareness. For our example from above, this yields the following Boolean array.
```
 1  1  0  0  1  0  0  0  0  1  0  0  0  0  0  0  1  0  0  0  0  0  0  0  0
```
Next, we call `œṗ` to partition the input string, e.g., 
```
 H  H  e  H  H  e  l  e  H  H  e  l  l  l  e  H  H  e  l  l  o  l  l  e  H
```
before all **1**'s (actually, all truthy elements). For our example, this yields the following string array.
```
['', 
 'H',
 'HeH',
 'HeleH',
 'HellleH',
 'HellolleH'
]
```
`Z⁻¦` is arguably the most interesting part of this answer. Let's analyze the more straightforward `Z1¦` first.
`¦` is the *sparse* quick. It consumes two links from the stack, specifically `1` and `Z` in this case. First `Z` is applied to its argument: the string array from before. `Z` is the *zip* atom and reads the string array / 2D character array by columns, yielding
```
['HHHHH',
 'eeee',
 'Hlll',
 'ell',
 'Hlo',
 'el',
 'Hl',
 'e',
 'H'
]
```
What used to be left side of the input string and the first column of the string array now becomes the first *string*.
Now `¦` peeks at `1` and finds a single index: **1**. Thus the first string in the original string array is replaced with the first string in the return value of `Z`; strings at other indices remain unaffected.
```
['HHHHH',
 'H',
 'HeH',
 'HeleH',
 'HellleH',
 'HellolleH'
]
```
Let's call this array **A**.
We used `Z⁻¦` instead of `Z1¦`, but this makes no difference: `⁻` compares the string array with the input string for inequality, yielding **1** since they're not equal. The difference between the two is that `Z⁻¦` is dyadic because `⁻` is, allowing us to write `œṗZ⁻¦` instead of `œṗ¹Z1¦`. This is because a dyad (`œṗ`) followed by a monad (`œṗ¹Z1¦`) is a *fork* (the monad is applied to the chain's argument / the input string, and the returned value is passed as the right argument to `œṗ`), while a dyad followed by another dyad (or at the end of the chain) is a *hook*, i.e., its right argument is the chain's argument.
All that's left to do is check for palindromicness. `µ` begins a new (monadic) chain who's argument is **A**. The *upend* atom `U` reverses all strings in **A** (but not **A** itself), then `⁼` compares the result with **A** for equality. The returned Boolean **1** indicates a fully-palindromic triangle; other strings would return **0**.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~25~~ ~~21~~ 17 bytes
*Saved 2 bytes thanks to @obarakon*
```
ò@°T ¬v1
pUmg)eêP
```
[Test it online!](http://ethproductions.github.io/japt/?v=1.4.5&code=8kCwVCCsdjEKcFVtZyll6lA=&input=IjE2MDYxNTA1MSI=)
### How it works
```
 ò@  ° T ¬ v1   // Implicit: U = input string, T = 0
UòXY{++T q v1}  // First line; reset U to the result of this line.
UòXY{        }  // Partition U at indices where
     ++T q      //   the square root of T incremented
           v1   //   is divisible by 1.
                // This breaks U at square indices, giving rows of 1, 3, 5, ... chars.
 pUmg)eêP
UpUmg)eêP
  Umg           // Take the first char of every item of U.
Up   )          // Append this to U.
      e         // Check that every item in the resulting array
       êP       // is a palindrome.
                // Implicit: output result of last expression
```
Note that we don't need to check *both* sides; if the sides are not the same, At least one of the rows is not a palindrome.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 18 bytes
```
gÅÉ£õÜÐíQs€¬āÈÏÂQ*
```
Uses the **05AB1E** encoding. [Try it online!](https://tio.run/##AS4A0f8wNWFiMWX//2fDhcOJwqPDtcOcw5DDrVFz4oKswqzEgcOIw4/DglEq//9ub3Bl "05AB1E – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~18~~ 16 bytes
```
J²‘Ṭœṗ⁸ZḢ$ṭ$ŒḂ€Ạ
```
[Try it online!](https://tio.run/##y0rNyan8/9/r0KZHDTMe7lxzdPLDndMfNe6IerhjkcrDnWtVjk56uKPpUdOah7sW/P//XykxKTkpJTUtNQVIpAOppGQwLzkpEcFSAgA "Jelly – Try It Online")
Thanks to [Jonathan Allan](https://codegolf.stackexchange.com/users/53748/jonathan-allan) for trivial but not so obvious -2 byte savings.
[Answer]
## JavaScript (ES6), 112 bytes
```
f=(s,n=1,t='',u='',g=([...a])=>''+a==a.reverse())=>s?g(s.slice(0,n))&f(s.slice(n),n+2,t+s[0],u+s[n-1]):g(t)&g(u)
```
`t` and `u` collect the sides so that they can be tested at the end.
[Answer]
# C#, 184 bytes
```
using System.Linq;
b=a=>string.Concat(a.Reverse())==a
f=>{string c=f[0]+"",d=c,e="";for(int i=1,k=1,s=f.Length;i<s;)
{c+=f[i];d+=f[(i+=k+=2)-1];e=f.Substring(s-k);}return b(c)&b(d)&b(e);}
```
Thought the solution was looking good until I got to the palindrome part
Ungolfed version:
```
Func<string, bool> b = a => string.Concat(a.Reverse()) == a;
        Func<string, bool> func = f => {
            string c = f[0] + "", d = c, e = "";
            for (int i = 1, k = 1, s = f.Length; i < s;) {
                c += f[i];
                d += f[(i += k += 2) - 1];
                e = f.Substring(s - k);
            }
            return b(c) & b(d) & b(e);
        };
```
[Answer]
# Java 8, ~~358~~ 301 bytes
```
import java.util.*;s->{List<String>l=new Stack();for(int i=0,p=1,t=1;p<=s.length();p+=t+=2)l.add(s.substring(i,i=p));String a="",b=a;for(String q:l){a+=q.charAt(0);b+=q.charAt(q.length()-1);}return p(a)&p(b)&p(l.get(l.size()-1));}boolean p(String s){return s.equals(new StringBuffer(s).reverse()+"");}
```
Input is a `String`, output is a `boolean`.
**Explanation:**
[Try it here.](https://tio.run/##nVQ9b9swEN39Kw4aCrK2GcmtM1RhgHTK0BoFPAYdKImy6dAULVIuUkG/3T3JauwhbYkeiPugHu/IewftxFHMKyvNrng@qb2tag873GONV5q9T@HmBr4J3KxK8FsJ2YuX87xqjJ/kWjgHX4Uy7QRAGS/rUuQSVn0IkFWVlsJATta@VmYDjqb4oZugWoEBDic3v2@/KOfvzoh7zY38AWsv8mdC07KqCWYFxeOZ5cnM8yS1d9wxLc3GbxFhp9xP@YJqJoqCOOaazA2ZiJopbilNx9KCR9Es42LIOe4dPmnaiik/sHwr6gdPYppmV@Hhtc48oWlXS9/UBiwR9J0lWa8020iP2qmfckAhbJLi07Fnq8qDfbtvvxtjL41p@3fq66eN5RyTh0ZoR86N6eGfm7KUNXGU1fIoa4elp1GEpU8Atsm0ysF54dEcK1XAHvkZCz19B0HP5JTKCD1wB3tkos/eB2SgaHiArxs5@OsX5@WeVY1nFrN4bcieGZaTKInoiP8z5iEEgxIAS5I4CYKhxHEY9ja@TZbxMjjvlQQdWeD6MKiPo1n2TsDZx0eJSw9Kj6bqnf@46lsSkEZkeVbIUhaoNmiyfIjyTFy8v6W5DFOJI/yvaTL4Fwq4VNt2XUgL4jCGFvEicE4WOCch2FeiLsTJgczxbDfpTr8A)
```
import java.util.*;               // Required import for List and Stack
s->{                              // Method (1) with String parameter and boolean return-type
  List<String>l=new Stack();      //  Create a String-list
  for(int i=0,p=1,t=1;            //  Initialize some index/counter integers
      p<=s.length();              //  Loop (1) over the String in sections
      p+=t+=2)                    //    And increase `p` like this after every iteration: 1,4,9,16,25,etc.
    l.add(s.substring(i,i=p));    //   And add a substring-section to the list (0,1 -> 1,4 -> 4,9 -> 9,16 -> etc.)
                                  //  End of loop (1) (implicit / single-line body)
  String a="",b=a;                //  Two temp Strings
  for(String q:l){                //  Loop (2) over the list
    a+=q.charAt(0);               //   And append the first character to String `a`
    b+=q.charAt(q.length()-1);    //   And the last character to String `b`
  }                               //  End of loop (2)
  return p(a)                     //  Return if String `a` is a palindrome
        &p(b)                     //   as well as String `b`
        &p(l.get(l.size()-1));    //   as well as the last String in the list
}                                 // End of method (1)
boolean p(String s){              // Method (2) with String parameter and boolean return-type
  return s.equals(new StringBuffer(s).reverse()+"");
                                  //  Return if this String is a palindrome
}                                 // End of method (2)
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~20~~ 21 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
+2 bytes - I released buggy code :(  
-1 byte - moved from moulding like odd integers to partitioning at square indexes
```
JÆ²0;œṗ⁸ZḢ$ṭ$ŒḂ€Ạ
```
A monadic link accepting a list of characters and returning `1` (Truthy) or `0` (Falsey).  
Note: this uses the part of the specification that limits the input to a square length.
**[Try it online!](https://tio.run/##y0rNyan8/9/rcNuhTQbWRyc/3Dn90FYjp4e7uw9PeNS05lHjjihrIHF00sMdTUD@w10L/v//r@ThkQpEOWAiB0rlgxhKAA)** or see the [test suite](https://tio.run/##y0rNyan8/9/rcNuhTQbWRyc/3Dn90FYjp4e7uw9PeNS05lHjjihrIHF00sMdTUD@w10L/h/dc7gdyMwCSTfMUbC1U3jUMDfy//9oJUMlHSVHEAYCIJWXX5CqpKOgVF1dWwvkGhoagBQASTBlZGAEFgQCAwOIjJmBmaGpgSmMbQRkw9UgAbCQERAZgwkTKGUKYgDlPDxSgSgHTORAqXwQAyQHYyPkUsHqsViDDQCVJSYlJ6WkpqWmAIl0IJWUDOYlJyUiWEqxAA).
This may be simplified to **17 bytes** by noting that if all rows are palindromes only one "side" needs checking (`JÆ²0;œṗ⁸ZḢ$ṭ$ŒḂ€Ạ`), however Erik the Outgolfer already noticed this fact and used it in [their answer](https://codegolf.stackexchange.com/a/125469/53748) so I have given the triangle construction method to them saving a byte there.
Additionally, that may in turn be improved to **16 bytes** by noting that partitioning at truthy indexes does not mind if there is excess in the left argument (`J²‘Ṭœṗ⁸ZḢ$ṭ$ŒḂ€Ạ`).
### How?
```
JÆ²0;œṗµ2BịÐ€⁸Z;⁸ŒḂ€Ạ - Link: list, a      e.g. "abcbazxza"
J                     - range of length of a  = [1,2,3,4,5,6,7,8,9]
 Æ²                   - is square? (vectorises) [1,0,0,1,0,0,0,0,1]
   0;                 - prepend a zero        [0,1,0,0,1,0,0,0,0,1]
     œṗ               - partition a at 1s     ["a","bcb","azxza"]
       µ              - monadic chain separation, call that t
        2B            - 2 in binary = [1,0]
             ⁸        - chain's left argument, t
          ịÐ€         - map with index into    ["aa","bb","aa"] (1st and last of each of t)
              Z       - transpose              ["aba","aba"] (left and right "sides" of t)
               ;⁸     - concatenate t          ["aba","aba","a","bcb","azxza"]
                 ŒḂ€  - palindromic? for €ach  [1,1,1,1,1]
                    Ạ - all?                   1
```
[Answer]
# Mathematica, 156 bytes
```
B=StringTake;Count[PalindromeQ/@Join[A=Table[B[#,{i^2+1,(i+1)^2}],{i,0,(s=Sqrt@StringLength@#)-1}],{StringJoin@Table[B[A[[i]],1],{i,Length@A}]}],True]==s+1&
```
  
**input**
> 
> ["1101"]
> 
> 
> 
[Answer]
# [PHP](https://php.net/), 97 bytes
```
for($t=1;~$s=substr($argn,$i**2,$i++*2+1);$d.=$s[0])$t&=strrev($s)==$s;$t&=strrev($d)==$d;echo$t;
```
[Try it online!](https://tio.run/##TcqxDsIgFIXh3cdobkwBNUDSLrc3PohxqIDiUgigY9@6M9LN5STnyx99rNM1@niAOb0W6tQoRz3IQXdYnyH1UEjhCpny55FL@3t2gjfnuq0QXAvFEOyFIN/knUE5UuuS@/aQGTXFf7I7WXTGByhY67aEs5mNdz8 "PHP – Try It Online")
[Answer]
# Java, 136 bytes
```
l->{for(int i=0,j,k=1;i<l.size();i=j,k+=2)if(!l.subList(i,j=i+k).equals(l.subList(i,j).asReversed().toList()))return false;return true;}
```
Uses a `MutableList<Character>` from Eclipse collections
```
Function<MutableList<Character>, Boolean> func = l->{
   for(int i=0,j,k=1;i<l.size();i=j,k+=2)  // `i` is the start index, `j` is the end index, `k` increments by 2
       if(!l.subList(i,j=i+k).equals( //Check that the first partition equals
           l.subList(i,j).asReversed().toList())  // The same sublist reversed
       )
       return false;
   return true;
};
```
[Answer]
# [Perl 5](https://www.perl.org/), 81 + 1 (`-p`) = 82 bytes
```
$a[0].=$1while($a[++$q]=substr$_,0,($#i+=2),'')=~/(.)/;$\||=$_ ne reverse for@a}{
```
[Try it online!](https://tio.run/##K0gtyjH9/18lMdogVs9WxbA8IzMnVQPI1dZWKYy1LS5NKi4pUonXMdDRUFHO1LY10tRRV9e0rdPX0NPUt1aJqamxVYlXyEtVKEotSy0qTlVIyy9ySKyt/v/fEQj@5ReUZObnFf/X9TXVMzA0@K9bAAA "Perl 5 – Try It Online")
Outputs `undef` (i.e., blank, null) for true, any number for false
[Answer]
# Excel VBA, 87 Bytes
Anonymous VBE immediate window function that takes input from cell `[A1]` and outputs to the VBE immediate window
```
k=1:For i=1To[Len(A1)^.5]:s=Mid([A1],j+1,i*2-1):j=j+i*2-1:k=k*(s=StrReverse(s)):Next:?k
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~128~~ ~~118~~ 115 bytes
```
def f(s):
 w=1;l=r='';b=[]
 while s:l+=s[0];r+=s[w-1];b+=[s[:w]];s=s[w:];w+=2
 print all(d==d[::-1]for d in[l,r]+b)
```
[Try it online!](https://tio.run/##bVHBjoMgFLz7FdzQuE2AXXuAcNhb/4FwEMWtCVEDTcym6bfbp2DroRPyZubNEA5M/7frOLBlaW2HujwUPEOzpMJJLzEWRioNi2vvLArclTIoooVfeT5RLUwpVVB81lqEdce1mEvJMjT5frih2rm8lbJVnEO7Gz1qUT8o9@V1aYqlyzHFRQb0mwgQ1TBONqr7/fGIilKS6iB2xQjbUwAhr8qZnGlFqoNlYI/lA/Ytg/O9jZ9E1SpifLlYOG4bLtG4ihTv9h3b7crnJz8hNmvTGPgO28L4AzLN5hpTvxUulic "Python 2 – Try It Online")
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), 38 bytes
```
{(⌽¨≡⊢)(⊢,⊢/¨,⍥⊂⊃¨)⍵⊆⍨w⍴∊⍴⍨¨1+2×⍳w←≢⍵}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/qG@qp/@jtgkG/6s1HvXsPbTiUefCR12LNDWAhA4Q6x9aofOod@mjrqZHXc2HVmg@6t36qKvtUe@K8ke9Wx51dIHI3hWHVhhqGx2e/qh3cznQrEedi4DKav@ngdi9fUCNj3rXABUeWm/8qG0i0MbgIGcgGeLhGfw/TUHd0MzAzNDUwNRQHQA "APL (Dyalog Extended) – Try It Online")
The cuts are of size `1,3,5,7...`, so that is used with `⊆` to get the appropriate array.
Requires `⎕IO←0` for zero indexing.
Shortened with a lot of help from Marshall and dzaima.
## Explanation
```
{(⌽¨≡⊢)(⊢,⊢/¨,⍥⊂⊃¨)⍵⊆⍨w⍴∊⍴⍨¨1+2×⍳w←≢⍵}
                                   ≢⍵  length of the string
                                 w←    assign to var w
                                ⍳      range from 0..length-1
                            1+2×       convert each to 2n+1 (odd numbers)
                         ⍴⍨¨           replicate each element times itself
                        ∊              flatten that
                      w⍴               reshape to string's length
                   ⍵⊆⍨                 partition the string based on that
       (⊢,⊢/¨,⍥⊂⊃¨)                    Train:
       (⊢,        )                    concatenate the partition with:
       (  ⊢/¨     )                    last character of each partition
       (        ⊃¨)                    first character of each partition
       (      ⍥⊂  )                    both enclosed into two strings
  ⌽¨                                   do the reverses of each part
    ≡                                  match
     ⊢                                 the parts?                           
```
]