Pertimbangkan senarnya 160615051. Itu bisa "triangulasi" seperti:

  1
 606
15051

Kemudian, setiap baris adalah palindrome. Perhatikan juga bahwa setiap sisi pada perimeter juga merupakan palindrom:

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

Oleh karena itu, string ini dapat dianggap sebagai segitiga palindrom sepenuhnya. Jangan khawatir tentang ketinggian 100dalam hal ini, itu tidak harus palindromic.

Input: String karakter ASCII yang dapat dicetak dari 0x20 hingga 0x7E. Ini bisa berupa array karakter, string tunggal, atau array poin kode ASCII. Input Anda akan selalu dapat triangulasi (yaitu, panjangnya akan selalu menjadi kuadrat sempurna).

Output : Nilai kebenaran jika string adalah segitiga palindrom sepenuhnya, atau nilai falsey sebaliknya.

Uji kasus

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 byte

J’ƲœṗZ⁻¦µU⁼

Cobalah online!

Latar Belakang

Kita mulai dengan melihat indeks berbasis 0 dari string input.

 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

Untuk mendapatkan barisan segitiga, kita dapat membagi string sebelum indeks 1 , 1 + 3 = 4 , 1 + 3 + 5 = 9 , dan 1 + 3 + 5 + 7 = 16 . Karena (n + 1) ² = n² + (2n + 1) , jumlah ini adalah tepat, kuadrat sempurna dalam daftar indeks. Jika kita juga membagi string sebelum 0 , ini sesederhana pemisahan sebelum semua indeks berbasis 0 yang merupakan kuadrat sempurna.

Setelah pemisahan, kami mendapatkan string berikut.

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

Selanjutnya, kami mengganti string kosong di awal dengan semua karakter di kolom pertama.

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

Tugas sekarang dikurangi untuk memeriksa apakah membalik semua string menghasilkan array string yang sama.

Bagaimana itu bekerja

Pertama-tama, Jbuat semua indeks berbasis-1 dari string input J, lalu turunkan dengan ’untuk menghasilkan semua indeks berbasis-0. Ʋmenguji semua indeks berbasis 0 untuk kuadrat. Untuk contoh kita dari atas, ini menghasilkan array Boolean berikut.

 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

Selanjutnya, kita panggil œṗuntuk mempartisi string input, misalnya,

 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

sebelum semua 1 (sebenarnya, semua elemen kebenaran). Sebagai contoh kita, ini menghasilkan array string berikut.

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

Z⁻¦bisa dibilang bagian paling menarik dari jawaban ini. Mari kita analisa yang lebih mudah Z1¦dulu.

¦adalah jarang cepat. Ini mengkonsumsi dua tautan dari tumpukan, khususnya 1dan Zdalam hal ini. Pertama Zditerapkan pada argumennya: array string dari sebelumnya. Zadalah atom zip dan membaca array string / 2D array karakter oleh kolom, menghasilkan

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

Apa yang dulunya sisi kiri dari string input dan kolom pertama dari array string sekarang menjadi string pertama .

Sekarang ¦intip 1dan temukan satu indeks: 1 . Jadi string pertama dalam array string asli diganti dengan string pertama dalam nilai kembalinya Z; string pada indeks lain tetap tidak terpengaruh.

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

Mari kita sebut array ini A .

Kami menggunakan Z⁻¦alih-alih Z1¦, tetapi ini tidak membuat perbedaan: ⁻membandingkan array string dengan string input untuk ketidaksetaraan, menghasilkan 1 karena mereka tidak sama. Perbedaan antara keduanya adalah Z⁻¦karena diad karena ⁻, memungkinkan kita untuk menulisœṗZ⁻¦ bukan œṗ¹Z1¦. Ini karena angka dua ( œṗ) diikuti oleh monad ( œṗ¹Z1¦) adalah garpu (monad diterapkan pada argumen rantai / string input, dan nilai yang dikembalikan dilewatkan sebagai argumen yang tepat untuk œṗ), sedangkan angka dua diikuti oleh angka dua lain (atau di akhir rantai) adalah sebuah kait , yaitu, argumen yang benar adalah argumen rantai.

Yang tersisa untuk dilakukan adalah memeriksa palindromicness. µdimulai baru (monadik) rantai siapa argumen adalah A . The upend atom Umembalikkan semua string di A (tetapi tidak A itu sendiri), kemudian ⁼membandingkan hasilnya dengan A untuk kesetaraan. Boolean 1 yang dikembalikan menunjukkan segitiga palindromik sepenuhnya; string lain akan mengembalikan 0 .

Japt , 25 21 17 byte

Disimpan 2 byte berkat @obarakon

ò@°T ¬v1
pUmg)eêP

Uji secara online!

Bagaimana itu bekerja

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

Perhatikan bahwa kita tidak perlu memeriksa kedua sisi; jika sisi-sisinya tidak sama, setidaknya satu baris bukanlah palindrom.

05AB1E , 18 byte

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

Menggunakan penyandian 05AB1E . Cobalah online!

Jelly , 18 16 byte

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

Cobalah online!

Terima kasih kepada Jonathan Allan untuk penghematan sepele tapi tidak begitu jelas.

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)

tdan ukumpulkan sisi-sisinya sehingga mereka dapat diuji pada akhirnya.

C #, 184 byte

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

Kupikir solusinya kelihatan bagus sampai aku sampai di bagian palindrome

Versi tidak disatukan:

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 byte

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 adalah a String, output adalah a boolean.

Penjelasan:

Coba di sini.

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 byte

+2 byte - Saya merilis kode buggy :(
-1 byte - dipindahkan dari pencetakan seperti bilangan bulat ganjil ke partisi pada indeks persegi

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

Tautan monadik yang menerima daftar karakter dan kembali 1(Kebenaran) atau 0(Falsey).
Catatan: ini menggunakan bagian dari spesifikasi yang membatasi input hingga panjang persegi.

Cobalah online! atau lihat test suite .

Ini dapat disederhanakan menjadi 17 byte dengan mencatat bahwa jika semua baris adalah palindrom, hanya satu "sisi" yang perlu diperiksa ( JƲ0;œṗ⁸ZḢ$ṭ$ŒḂ€Ạ), namun Erik the Outgolfer sudah memperhatikan fakta ini dan menggunakannya dalam jawaban mereka sehingga saya telah memberikan metode konstruksi segitiga untuk menghemat satu byte di sana.

Selain itu, yang pada gilirannya dapat ditingkatkan menjadi 16 byte dengan mencatat bahwa mempartisi pada indeks kebenaran tidak masalah jika ada kelebihan dalam argumen kiri ( J²‘Ṭœṗ⁸ZḢ$ṭ$ŒḂ€Ạ).

Bagaimana?

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 byte

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&

memasukkan

["1101"]

PHP , 97 byte

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

Cobalah online!

Java, 136 byte

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

Menggunakan a MutableList<Character>dari koleksi 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 byte

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

Cobalah online!

Keluaran undef(yaitu, kosong, nol) untuk true, angka apa saja untuk false

Excel VBA, 87 Bytes

Fungsi jendela langsung VBE anonim yang mengambil input dari sel [A1]dan output ke jendela langsung 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 byte

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)

Cobalah online!