考虑一下字符串160615051。可以这样“三角化”：

  1
 606
15051

那么，每一行都是回文。还要注意，周长的每一侧也是回文：

  1  |   1   |   
 6   |    6  |      
1    |     1 | 15051 

因此，该字符串可以认为是完全回文三角形。100在这种情况下，不必担心海拔高度，不必回文。

输入：从0x20到0x7E的可打印ASCII字符串。它可以是字符数组，单个字符串或ASCII码点的数组。您的输入将始终能够被三角剖分（即，其长度将始终是完美的正方形）。

输出：如果字符串是完全回文的三角形，则为真值，否则为假值。

测试用例

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

果冻，14 12字节

J’ƲœṗZ⁻¦µU⁼

在线尝试！

背景

我们首先查看输入字符串的从0开始的索引。

 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

要获得的三角形的各行中，我们可以在索引前分割字符串1，1 + 3 = 4，1 + 3 + 5 = 9，和1 + 3 + 5 + 7 = 16。由于（n + 1）²=n²+（2n +1），所以这些和恰好是索引列表中的正完美平方。如果我们也将字符串拆分为0之前的字符串，这就像在所有基于0的完美平方索引之前进行拆分一样简单。

分割后，我们得到以下字符串。

""
"H"
"HeH"
"HeleH"
"HellleH"
"HellolleH"

接下来，我们用第一列中的所有字符替换开头的空字符串。

"HHHHH"
"H"
"HeH"
"HeleH"
"HellleH"
"HellolleH"

现在，该任务简化为检查是否反转所有字符串会产生相同的字符串数组。

怎么运行的

首先J生成输入字符串的所有基于1的索引J，然后将其递减’以产生所有基于0的索引。Ʋ测试所有基于0的索引的方形度。对于上面的示例，这将产生以下布尔数组。

 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

接下来，我们调用œṗ分区输入字符串，例如，

 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

在所有1之前（实际上是所有真实元素）。对于我们的示例，这将产生以下字符串数组。

['', 
 'H',
 'HeH',
 'HeleH',
 'HellleH',
 'HellolleH'
]

Z⁻¦可以说是这个答案中最有趣的部分。让我们先分析更简单的方法Z1¦。

¦是疏快。它消耗从堆栈两个环节，特别是1与Z在这种情况下。首先Z应用于其参数：之前的字符串数组。Z是zip原子，并按列读取字符串数组/ 2D字符数组，得出

['HHHHH',
 'eeee',
 'Hlll',
 'ell',
 'Hlo',
 'el',
 'Hl',
 'e',
 'H'
]

输入字符串左侧和字符串数组第一列的内容现在变为第一个字符串。

现在¦查看1并找到一个索引：1。因此，原始字符串数组中的第一个字符串将替换为返回值Z;中的第一个字符串。其他索引处的字符串不受影响。

['HHHHH',
 'H',
 'HeH',
 'HeleH',
 'HellleH',
 'HellolleH'
]

让我们把这个数组一个。

我们使用Z⁻¦代替Z1¦，但这没有什么区别：⁻比较字符串数组和输入字符串的不相等性，因为它们不相等，所以产生1。两者之间的区别Z⁻¦是二进式的，因为⁻是，允许我们写œṗZ⁻¦而不是œṗ¹Z1¦。这是因为一个dyad（œṗ）后跟一个monad（œṗ¹Z1¦）是一个分叉（将monad应用于链的参数/输入字符串，并将返回值作为正确的参数传递给œṗ），而一个dyad之后是另一个dyad （或在链的末尾）是一个hook，即它的正确参数是链的参数。

剩下要做的就是检查回文症。µ开始一个新的（一元）链谁的说法是一个。在倒放原子U反转的所有字符串在甲（但不甲本身），然后⁼将结果与比较阿是否相等。返回的布尔值1表示完全回文的三角形；其他字符串将返回0。

Japt，25 21 17字节

@obarakon节省了2个字节

ò@°T ¬v1
pUmg)eêP

在线测试！

怎么运行的

 ò@  ° 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

请注意，我们并不需要检查两个侧面; 如果两边不相同，则至少其中一排不是回文。

05AB1E，18个字节

gÅÉ£õÜÐíQs€¬āÈÏÂQ*

使用05AB1E编码。在线尝试！

果冻，18 16字节

J²‘Ṭœṗ⁸ZḢ$ṭ$ŒḂ€Ạ

在线尝试！

感谢Jonathan Allan所做的琐碎但不那么明显的-2字节节省。

JavaScript（ES6），112字节

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并u收集侧面，以便最后进行测试。

C＃，184个字节

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);}

以为解决方案看起来不错，直到我到达回文部分

非高尔夫版本：

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);
        };

Java 8、358301字节

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()+"");}

输入是a String，输出是a boolean。

说明：

在这里尝试。

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)

果冻， 20  21 字节

+2个字节-我发布了错误代码:(
-1个字节-从像奇数一样的模数转换为在平方索引处划分

JƲ0;œṗ⁸ZḢ$ṭ$ŒḂ€Ạ

接受字符列表并返回（Truthy）1或0（Falsey）的单子链接。
注意：这使用规范中将输入限制为平方长度的部分。

在线尝试！或查看测试套件。

注意，如果所有行都是回文，则可以将其简化为17个字节JƲ0;œṗ⁸ZḢ$ṭ$ŒḂ€Ạ，但是只有一个“边”需要检查（），但是Outgolfer的Erik已经注意到了这一事实，并在答案中使用了它，因此我为他们提供了三角形构造方法一个字节。

另外，可以通过注意在真索引处进行分区不介意左参数（）是否过多来将其提高到16个字节J²‘Ṭœṗ⁸ZḢ$ṭ$ŒḂ€Ạ。

怎么样？

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

Mathematica，156个字节

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&

输入

[“ 1101”]

的PHP，97字节

for($t=1;~$s=substr($argn,$i**2,$i++*2+1);$d.=$s[0])$t&=strrev($s)==$s;$t&=strrev($d)==$d;echo$t;

在线尝试！

Java，136个字节

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;}

使用MutableList<Character>Eclipse集合中的

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;
};

Perl 5，81 +1（-p）= 82字节

$a[0].=$1while($a[++$q]=substr$_,0,($#i+=2),'')=~/(.)/;$\||=$_ ne reverse for@a}{

在线尝试！

输出undef（即空白，空）为真，任何数字为假

Excel VBA，87字节

匿名VBE立即窗口功能，它从单元格获取输入[A1]并输出到VBE立即窗口

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

Python 2中，128个 118 115字节

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)

在线尝试！