Considérez la chaîne 160615051. Il peut être "triangulé" en tant que tel:

  1
 606
15051

Ensuite, chaque rangée est un palindrome. Notez également que chaque côté du périmètre est également un palindrome:

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

Par conséquent, cette chaîne peut être considérée comme un triangle entièrement palindromique. Ne vous inquiétez pas de l'altitude 100dans ce cas, elle n'a pas besoin d'être palindromique.

Entrée: une chaîne de caractères ASCII imprimables de 0x20 à 0x7E. Il peut s'agir d'un tableau de caractères, d'une chaîne unique ou d'un tableau de points de code ASCII. Votre entrée pourra toujours être triangulée (c'est-à-dire que sa longueur sera toujours un carré parfait).

Sortie : une valeur vraie si la chaîne est un triangle entièrement palindromique, ou une valeur de falsey sinon.

Cas de test

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

Gelée , 14 12 octets

J’ƲœṗZ⁻¦µU⁼

Essayez-le en ligne!

Contexte

Nous commençons par regarder les indices basés sur 0 de la chaîne d'entrée.

 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

Pour obtenir les lignes du triangle, nous pouvons diviser la chaîne avant les indices 1 , 1 + 3 = 4 , 1 + 3 + 5 = 9 et 1 + 3 + 5 + 7 = 16 . Puisque (n + 1) ² = n² + (2n + 1) , ces sommes sont précisément les carrés positifs et parfaits dans la liste d'index. Si nous divisons également la chaîne avant 0 , c'est aussi simple que de diviser avant tous les indices basés sur 0 qui sont des carrés parfaits.

Après le fractionnement, nous obtenons les chaînes suivantes.

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

Ensuite, nous remplaçons la chaîne vide au début par tous les caractères de la première colonne.

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

La tâche est maintenant réduite à vérifier si l'inversion de toutes les chaînes donne le même tableau de chaînes.

Comment ça fonctionne

JGénère d' abord tous les indices basés sur 1 de la chaîne d'entrée J, puis les décrémente avec ’pour produire tous les indices basés sur 0. Ʋteste tous les indices basés sur 0 pour l'équerrage. Pour notre exemple ci-dessus, cela donne le tableau booléen suivant.

 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

Ensuite, nous appelons œṗà partitionner la chaîne d'entrée, par exemple,

 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

avant tous les 1 (en fait, tous les éléments véridiques). Pour notre exemple, cela donne le tableau de chaînes suivant.

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

Z⁻¦est sans doute la partie la plus intéressante de cette réponse. Analysons d'abord le plus simple Z1¦.

¦est le rapide clairsemé . Il consomme deux liens de la pile, spécifiquement 1et Zdans ce cas. Le premier Zest appliqué à son argument: le tableau de chaînes d'avant. Zest l' atome zip et lit le tableau de chaînes / tableau de caractères 2D par colonnes, ce qui donne

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

Ce qui était le côté gauche de la chaîne d'entrée et la première colonne du tableau de chaînes devient maintenant la première chaîne .

¦Regarde maintenant 1et trouve un seul index: 1 . Ainsi, la première chaîne du tableau de chaînes d'origine est remplacée par la première chaîne dans la valeur de retour de Z; les chaînes des autres indices ne sont pas affectées.

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

Appelons ce tableau A .

Nous avons utilisé à la Z⁻¦place de Z1¦, mais cela ne fait aucune différence: ⁻compare le tableau de chaînes avec la chaîne d'entrée pour l'inégalité, ce qui donne 1 car elles ne sont pas égales. La différence entre les deux est qu'il Z⁻¦est dyadique parce qu'il ⁻nous permet d'écrire à la œṗZ⁻¦place de œṗ¹Z1¦. En effet, une dyade ( œṗ) suivie d'une monade ( œṗ¹Z1¦) est une fourchette (la monade est appliquée à l'argument de la chaîne / à la chaîne d'entrée, et la valeur renvoyée est transmise comme argument de droite à œṗ), tandis qu'une dyade suivie d'une autre dyade (ou à la fin de la chaîne) est un crochet , c'est-à-dire que son argument de droite est l'argument de la chaîne.

Tout ce qui reste à faire est de vérifier la palindromicité. µcommence une nouvelle chaîne (monadique) qui est l' argument est un . Le upend atome Uinverse toutes les chaînes A (mais pas A lui - même), puis ⁼compare le résultat avec une pour l' égalité. Le booléen renvoyé 1 indique un triangle entièrement palindromique; les autres chaînes retourneraient 0 .

Japt , 25 21 17 octets

Sauvegardé 2 octets grâce à @obarakon

ò@°T ¬v1
pUmg)eêP

Testez-le en ligne!

Comment ça fonctionne

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

Notez que nous n'avons pas besoin de vérifier les deux côtés; si les côtés ne sont pas les mêmes, au moins une des rangées n'est pas un palindrome.

05AB1E , 18 octets

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

Utilise l' encodage 05AB1E . Essayez-le en ligne!

Gelée , 18 16 octets

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

Essayez-le en ligne!

Merci à Jonathan Allan pour les économies triviales mais pas si évidentes de -2 octets.

JavaScript (ES6), 112 octets

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)

tet ucollecter les côtés afin qu'ils puissent être testés à la fin.

C #, 184 octets

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

Je pensais que la solution semblait bonne jusqu'à ce que j'arrive à la partie palindrome

Version non golfé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, 358 301 octets

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

L'entrée est un String, la sortie est un boolean.

Explication:

Essayez-le ici.

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)

Gelée ,  20  21 octets

+2 octets - J'ai publié un code bogué :(
-1 octet - déplacé du moulage comme des entiers impairs vers le partitionnement aux index carrés

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

Un lien monadique acceptant une liste de personnages et renvoyant 1(Truthy) ou 0(Falsey).
Remarque: cela utilise la partie de la spécification qui limite l'entrée à une longueur carrée.

Essayez-le en ligne! ou consultez la suite de tests .

Cela peut être simplifié à 17 octets en notant que si toutes les lignes sont des palindromes, un seul "côté" doit être vérifié ( JƲ0;œṗ⁸ZḢ$ṭ$ŒḂ€Ạ), mais Erik l'Outgolfer a déjà remarqué ce fait et l'a utilisé dans sa réponse , j'ai donc donné la méthode de construction du triangle pour les sauver un octet là-bas.

De plus, cela peut à son tour être amélioré à 16 octets en notant que le partitionnement aux index véridiques ne dérange pas s'il y a un excès dans l'argument de gauche ( J²‘Ṭœṗ⁸ZḢ$ṭ$ŒḂ€Ạ).

Comment?

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 octets

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&

contribution

["1101"]

PHP , 97 octets

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

Essayez-le en ligne!

Java, 136 octets

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

Utilise un MutableList<Character>des collections 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 octets

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

Essayez-le en ligne!

Sorties undef(c'est-à-dire vides, nulles) pour vrai, n'importe quel nombre pour faux

Excel VBA, 87 octets

Fonction de fenêtre immédiate VBE anonyme qui prend les entrées de la cellule [A1]et les sorties vers la fenêtre immédiate 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 115 octets

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)

Essayez-le en ligne!