Betrachten Sie die Zeichenfolge 160615051. Es kann als solches "trianguliert" werden:

  1
 606
15051

Dann ist jede Reihe ein Palindrom. Beachten Sie auch, dass jede Seite am Umfang auch ein Palindrom ist:

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

Daher kann diese Saite als vollständig palindromes Dreieck betrachtet werden. Mach dir keine Sorgen über die Höhe 100in diesem Fall, es muss nicht palindrom sein.

Eingabe: Eine Zeichenfolge aus druckbaren ASCII-Zeichen von 0x20 bis 0x7E. Dies kann ein Zeichenarray, eine einzelne Zeichenfolge oder ein Array von ASCII-Codepunkten sein. Ihre Eingabe kann immer trianguliert werden (dh ihre Länge ist immer ein perfektes Quadrat).

Ausgabe : Ein wahrer Wert, wenn die Zeichenfolge ein vollständig palindromes Dreieck ist, oder ein falscher Wert, wenn dies nicht der Fall ist.

Testfälle

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

Jelly , 14 12 Bytes

J’ƲœṗZ⁻¦µU⁼

Probieren Sie es online!

Hintergrund

Zunächst betrachten wir die 0-basierten Indizes der Eingabezeichenfolge.

 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

Um die Zeilen des Dreiecks zu erhalten, können wir den String vor den Indizes 1 , 1 + 3 = 4 , 1 + 3 + 5 = 9 und 1 + 3 + 5 + 7 = 16 teilen . Da (n + 1) ² = n² + (2n + 1) , sind diese Summen genau die positiven, perfekten Quadrate in der Indexliste. Wenn wir den String auch vor 0 teilen , ist dies so einfach wie das Teilen vor allen auf 0 basierenden Indizes, die perfekte Quadrate sind.

Nach dem Aufteilen erhalten wir die folgenden Zeichenfolgen.

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

Als nächstes ersetzen wir die leere Zeichenfolge am Anfang durch alle Zeichen in der ersten Spalte.

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

Die Aufgabe beschränkt sich nun darauf, zu prüfen, ob das Umkehren aller Zeichenfolgen dasselbe Zeichenfolgenarray ergibt.

Wie es funktioniert

Zuerst Jerzeugt alle 1-basierten Indizes der Eingabezeichenfolge J, dekrementiert sie dann mit ’allen 0-basierte Indizes zu ergeben. ƲTestet alle 0-basierten Indizes auf Rechtwinkligkeit. Für unser Beispiel von oben ergibt dies das folgende Boolesche 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

Als nächstes rufen wir auf, œṗum die Eingabezeichenfolge zu partitionieren, z.

 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

vor allen 1 ‚s (eigentlich alle truthy Elemente). In unserem Beispiel ergibt dies das folgende String-Array.

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

Z⁻¦ist wohl der interessanteste Teil dieser Antwort. Lassen Sie uns zuerst die einfacheren analysieren Z1¦.

¦ist das spärlich schnell. Speziell 1und Zin diesem Fall werden zwei Links aus dem Stapel verbraucht . Zuerst Zwird auf sein Argument angewendet: das String-Array von vorher. Zist das zip- Atom und liest das Zeichenkettenarray / 2D-Zeichenarray spaltenweise, was ergibt

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

Was früher links von der Eingabezeichenfolge und der ersten Spalte des Zeichenfolgenarrays war, wird jetzt zur ersten Zeichenfolge .

Nun ¦guckt auf 1und findet einen einzigen Index: 1 . Daher wird die erste Zeichenfolge im ursprünglichen Zeichenfolgenarray durch die erste Zeichenfolge im Rückgabewert von ersetzt Z. Zeichenfolgen bei anderen Indizes bleiben unberührt.

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

Lassen Sie uns dieses Array nennen A .

Wir haben Z⁻¦stattdessen verwendet Z1¦, aber das macht keinen Unterschied: ⁻Vergleicht das Zeichenfolgenarray mit der Eingabezeichenfolge auf Ungleichheit und ergibt 1, da sie nicht gleich sind. Der Unterschied zwischen den beiden ist, dass Z⁻¦es dyadisch ⁻ist, weil es uns erlaubt zu schreiben œṗZ⁻¦anstatt œṗ¹Z1¦. Dies liegt daran, dass eine Dyade ( œṗ) gefolgt von einer Monade ( œṗ¹Z1¦) eine Verzweigung ist (die Monade wird auf das Argument / die Eingabezeichenfolge der Kette angewendet und der zurückgegebene Wert wird als das richtige Argument an übergeben œṗ), während eine Dyade von einer anderen Dyade gefolgt wird (oder am Ende der Kette) ist ein Haken , dh sein rechtes Argument ist das Argument der Kette.

Sie müssen nur noch auf Palindromie prüfen. µbeginnt eine neue (monadische) Kette, deren Argument A ist . Das Upend- Atom Ukehrt alle Strings in A um (aber nicht A selbst) und ⁼vergleicht dann das Ergebnis mit A, um die Gleichheit zu gewährleisten . Der zurückgegebene Boolesche Wert 1 gibt ein vollständig palindromisches Dreieck an. andere Zeichenfolgen würden 0 zurückgeben .

Japt , 25 21 17 Bytes

2 Bytes dank @obarakon gespeichert

ò@°T ¬v1
pUmg)eêP

Online testen!

Wie es funktioniert

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

Beachten Sie, dass wir nicht beide Seiten überprüfen müssen . Wenn die Seiten nicht gleich sind, ist mindestens eine der Reihen kein Palindrom.

05AB1E , 18 Bytes

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

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

Jelly , 18 16 Bytes

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

Probieren Sie es online!

Vielen Dank an Jonathan Allan für die nicht so offensichtlichen -2-Byte-Einsparungen.

JavaScript (ES6), 112 Byte

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)

tund usammle die Seiten, damit sie am Ende getestet werden können.

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

Dachte, die Lösung sah gut aus, bis ich zum Palindrom-Teil kam

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

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 ist a String, Output ist a boolean.

Erläuterung:

Probieren Sie es hier aus.

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)

Jelly ,  20  21 Bytes

+2 Bytes - Ich habe Buggy-Code veröffentlicht :(
-1 Bytes - Vom Formen wie ungerade Ganzzahlen zur Partitionierung bei quadratischen Indizes übergegangen

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

Ein monadischer Link, der eine Liste von Zeichen akzeptiert und 1(Truthy) oder 0(Falsey) zurückgibt .
Hinweis: Hierbei wird der Teil der Spezifikation verwendet, der die Eingabe auf eine quadratische Länge beschränkt.

Probieren Sie es online! oder sehen Sie sich die Testsuite an .

Dies kann vereinfacht werden 17 Bytes indem bemerkt wird, dass, wenn alle Zeilen Palindrome sind, nur eine "Seite" überprüft werden muss ( JƲ0;œṗ⁸ZḢ$ṭ$ŒḂ€Ạ), jedoch hat Erik der Outgolfer diese Tatsache bereits bemerkt und sie in ihrer Antwort verwendet, sodass ich ihnen die Dreieck-Konstruktionsmethode zum Speichern gegeben habe ein Byte dort.

Darüber hinaus kann dies wiederum auf 16 Bytes verbessert werden, indem festgestellt wird, dass es der Partitionierung bei Wahrheitsindizes nichts ausmacht, wenn das linke Argument ( J²‘Ṭœṗ⁸ZḢ$ṭ$ŒḂ€Ạ) einen Überschuss enthält .

Wie?

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 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&

Eingang

[1101]

PHP , 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;

Probieren Sie es online!

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

Verwendet a MutableList<Character>aus Eclipse-Sammlungen

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 Bytes

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

Probieren Sie es online!

Ausgaben undef(dh leer, null) für wahr, eine beliebige Zahl für falsch

Excel VBA, 87 Bytes

Anonyme VBE-Direktfensterfunktion, die Eingaben von der Zelle [A1]und Ausgaben in das VBE-Direktfenster übernimmt

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

Probieren Sie es online!