Palindrome เป็นคำที่ตรงกันข้ามกัน

ขณะนี้มีคำบางคำที่อาจมีลักษณะเหมือน palindromes แต่ไม่ใช่ ยกตัวอย่างเช่นพิจารณาคำ sheesh, sheeshไม่ palindrome เพราะเป็นสิ่งที่ตรงกันข้ามของมันhseehsซึ่งเป็นที่แตกต่างกัน แต่ถ้าเราพิจารณาให้เป็นตัวอักษรเดียวแล้วก็กลับเป็นsh sheeshคำชนิดนี้เราจะเรียกว่าเซมิโคลอน

โดยเฉพาะคำหนึ่งคำคือกึ่ง Palindrome หากเราสามารถแบ่งคำนั้นออกเป็นชิ้น ๆ จำนวนหนึ่งเช่นเมื่อคำสั่งของชิ้นนั้นกลับคำเดิมจะเกิดขึ้น (สำหรับsheeshชิ้นส่วนเหล่านั้นsh e e sh) เราจะต้องไม่มีชิ้นที่มีตัวอักษรจากครึ่งทั้งสองของคำ (มิฉะนั้นทุกคำจะเป็นกึ่ง Palindrome) ตัวอย่างเช่นrearไม่ใช่กึ่ง Palindrome เพราะr ea rมีอัน ( ea) ที่มีตัวอักษรจากทั้งสองด้านของคำเดิม เราพิจารณาอักขระกลางในคำที่มีความยาวคี่ให้อยู่ด้านใดด้านหนึ่งของคำดังนั้นสำหรับคำที่มีความยาวคี่อักขระกลางจะต้องอยู่ในกลุ่มของมันเสมอ

งานของคุณจะทำรายการของจำนวนเต็มบวกและตรวจสอบว่าพวกเขาเป็นกึ่ง Palindrome รหัสของคุณควรส่งออกค่าไม่เท่ากันที่สอดคล้องกันสองค่าหนึ่งค่าหากอินพุตเป็นแบบกึ่ง Palindrome และอีกค่าหนึ่ง อย่างไรก็ตามลำดับไบต์ของรหัสของคุณจะต้องเป็นกึ่ง palindrome-ตัวเอง

คำตอบจะได้คะแนนเป็นไบต์ด้วยจำนวนไบต์ที่น้อยลง

การทดสอบกรณี

[] -> True
[1] -> True
[2,1,2] -> True
[3,4,2,2,3,4] -> True
[3,5,1,3,5] -> True
[1,2,3,1] -> False
[1,2,3,3,4,1] -> False
[11,44,1,1] -> False
[1,3,2,4,1,2,3] -> False

โปรแกรมเพื่อสร้างผลงานทดสอบที่มากขึ้น

borribleออกมาชี้ว่าสิ่งเหล่านี้มีความคล้ายคลึงกับทั่วไป palindromes ดังนั้นหากคุณต้องการอ่านเพิ่มเติมนั่นเป็นจุดเริ่มต้น

เรติน่า 0.8.2 , 85 69 ไบต์

M`^(.+,)*(\d+,)?(?<-1>\1)*$(?(1)^)|M`^(.+,)*(\d+,)?(?<-1>\1)*$(?(1)^)

ลองออนไลน์! คำอธิบาย:

M`

เลือกโหมดจับคู่ ในความเป็นจริง Retina จะใช้ค่าเริ่มต้นเป็นโหมดจับคู่สำหรับโปรแกรมบรรทัดเดียว แต่สำเนาที่สองของรหัสจะจับคู่เสมอหากไม่ใช่สำหรับอักขระพิเศษเหล่านี้

^

การแข่งขันจะต้องเริ่มต้นที่จุดเริ่มต้น

(.+,)*

จับภาพตัวละครจำนวนหนึ่ง การวิ่งแต่ละครั้งจะต้องจบด้วยเครื่องหมายจุลภาค

(\d+,)?

เลือกจับคู่ตัวเลขและเครื่องหมายจุลภาค

(?<-1>\1)*

เลือกจับคู่ทั้งหมดของการจับภาพในลำดับย้อนกลับ popping แต่ละรายการตามที่จับคู่

$

การแข่งขันจะต้องจบในตอนท้าย

(?(1)^)

Backtrack เว้นแต่ว่าการดักจับทั้งหมดจะถูกตอก มันทำงานได้โดยกำหนดให้การแข่งขันยังคงอยู่ที่จุดเริ่มต้นของสตริงถ้าเรามีการจับที่ไม่ได้เปิดซึ่งเป็นไปไม่ได้

เยลลี่ , 27 23 ไบต์

ṖUṁ@Ƒ€ṚẸHḢŒŒHḢŒṖUṁ@Ƒ€ṚẸ

ผลตอบแทนที่1กึ่ง palindromes, 0มิฉะนั้น

ลองออนไลน์!

มันทำงานอย่างไร

ṖUṁ@Ƒ€ṚẸHḢŒŒHḢŒṖUṁ@Ƒ€ṚẸ  Main link. Argument: A (array)

          Π             Invalid token. Everything to its left is ignored.
           ŒH            Halve; divide A into two halves similar lengths. The middle
                         element (if there is one) goes into the first half.
             Ḣ           Head; extract the first half.
              ŒṖ         Generate all partitions of the first half.
                U        Upend; reverse each chunk of each partition.
                         Let's call the result C.

                     Ṛ   Yield R, A reversed.
                   Ƒ€    Fixed each; for each array P in C, call the link to the left
                         with arguments P and R.
                         Return 1 if the result is P, 0 if not.
                 ṁ@          Mold swapped; replace the n integers of C, in reading
                             order, with the first n integers of R.
                     Ẹ   Exists; check if one of the calls returned 1.

Python 2 , 157 153 147 143 bytes

-4 ไบต์ขอบคุณที่TSH

s=lambda x,i=0:len(x)<2or[]<x[i:]and(x[-i:]==x[:i])&s(x[i:-i])|s(x,i+1)
s=lambda x,i=0:len(x)<2or[]<x[i:]and(x[-i:]==x[:i])&s(x[i:-i])|s(x,i+1)

ลองออนไลน์!

05AB1E , 59 47 43 41 ไบต์

2äøø€.œ`âʒ`RQ}gĀIg_^q2äøø€.œ`âʒ`RQ}gĀIg_^

-12 ไบต์ขอบคุณที่@Emigna

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

2ä               # Split the input into two parts
                 #  i.e. [3,4,2,0,2,3,4] → [[3,4,2,0],[2,3,4]]
  øø             # Zip twice without filler
                 # This will remove the middle item for odd-length inputs
                 #  i.e. [[3,4,2,0],[2,3,4]] → [[3,2],[4,3],[2,4]] → [[3,4,2],[2,3,4]]
    €.œ          #  Then take all possible partitions for each inner list
                 #   i.e. [[3,4,2],[2,3,4]]
                 #    → [[[[3],[4],[2]],[[3],[4,2]],[[3,4],[2]],[[3,4,2]]],
                 #       [[[2],[3],[4]],[[2],[3,4]],[[2,3],[4]],[[2,3,4]]]]
`                # Push both lists of partitions to the stack
 â               # Take the cartesian product (all possible combinations) of the partitions
                 #  i.e. [[[[3],[4],[2]],[[2],[3],[4]]],
                 #        [[[3],[4],[2]],[[2],[3,4]]],
                 #        ...,
                 #        [[[3,4,2]],[[2,3,4]]]]
  ʒ   }          # Filter this list of combinations by:
   `             #  Push both parts to the stack
    RQ           #  Check if the second list reversed, is equal to the first
                 #   i.e. [[3,4],[2]] and [[2],[3,4]] → 1 (truthy)
       gĀ        # After the filter, check if there are any combinations left
                 #  i.e. [[[[3,4],[2]],[[2],[3,4]]]] → 1 (truthy)
         Ig_     # Check if the length of the input was 0 (empty input-list edge-case)
                 #  i.e. [3,4,2,0,2,3,4] → 7 → 0 (falsey)
            ^    # Bitwise-XOR
                 #  i.e. 1 XOR 0 → 1 (truthy)
             q   # Stop the program (and then implicitly output the top of the stack)
2äøø€.œ`âʒ`RQ}gĀIg_^
                 # Everything after the `q` are no-ops to comply to the challenge rules

05AB1E , 37 ไบต์

ใช้เทคนิคเดียวกับที่โจนาธานใช้

.œʒ€gηOZ;îå}εÂQ}ZĀqĀZ}QÂε}åî;ZOηg€ʒ.œ

ลองออนไลน์!

.œʒ€gηOZ;îå}εÂQ}ZĀqĀZ}QÂε}åî;ZOηg€ʒ.œ

โปรแกรมเต็มรูปแบบ รับรายการจาก STDIN, ส่งออก1หรือ0ถึง STDOUT

.œʒ        }

กรอง - เก็บพาร์ติชั่นที่ตอบสนอง ...

   €gηOZ;îå

เงื่อนไขนี้: ความยาวของแต่ละ ( €g) ถูกเก็บไว้ในรายการซึ่งรวมคำนำหน้า ( η) แล้วรวม ( O) ดังนั้นจึงให้ผลรวมสะสมของรายการความยาวกับเรา จากนั้นค่าครึ่งหนึ่งที่หายไปของจำนวนสูงสุดของรายการนั้นจะถูกส่งไปยังสแต็ก - แต่เก็บรายการดั้งเดิมไว้ในรายการด้วย ( Z;î) และหากเกิดขึ้น ( å) ในผลรวมสะสมจากนั้นฟังก์ชันจะส่งกลับค่าจริง

εÂQ}

สำหรับแต่ละเปรียบเทียบ ( Q) กับกลับซึ่งจะผลักดันให้แยกต่างหากใน stack โดย ส่งคืนรายการ0 s และ1 sÂ

ZĀq

สูงสุด. ถ้าเป็น truthy แล้ว1อื่น ๆ0 สิ้นสุดการดำเนินการ ทุกสิ่งที่ตามมาจะถูกละเว้นอย่างสมบูรณ์

Python 2 , 275 251 205 ไบต์

-24 ไบต์ขอบคุณ @KevinCruijssen

-44 ไบต์ขอบคุณ @PostLeftGhostHunter

-2 ไบต์อีกขอขอบคุณ @KevinCruijssen

def s(x):
 l=len(x)
 if l<2:return 1>0
 for i in range(1,l/2+1):
	if x[l-i:]==x[:i]:return s(x[i:l-i])
def s(x):
 l=len(x)
 if l<2:return 1>0
 for i in range(1,l/2+1):
	if x[l-i:]==x[:i]:return s(x[i:l-i])

ส่งคืนค่า True สำหรับเซมิโคลอนครึ่งหนึ่ง, ไม่มีเป็นอย่างอื่น

ลองออนไลน์!

เจลลี่ ,  33  32 ไบต์

-1 ขอบคุณ Erik the Outgolfer
ขอบคุณเดนนิสสำหรับการแก้ไขข้อบกพร่องและมองหาการเปลี่ยนแปลงรายละเอียดการใช้งานใน Jelly

ẸƇŒḂƇƊ$ƊĊHṀċÄẈṖŒŒṖẈÄċṀHĊƊ$ƊƇŒḂƇẸ

กึ่ง palindromes ผลผลิตผลผลิตอื่น1 ๆ0

$O(2^n)$

หรือดูการทดสอบในตัว

ชิ้นเดียวคือŒḂs ({3 ^rd & 4 ^th } vs {29 ^th & 30 ^th } bytes) เพียงเพื่อให้โค้ดแยกวิเคราะห์

อย่างไร?

งานทั้งหมดดำเนินการโดยด้านขวา - "ลิงก์หลัก":

ŒṖẈÄċṀHĊƊ$ƊƇŒḂƇẸ - Main Link: list
ŒṖ               - all partitions
           Ƈ     - filter keep those for which this is truthy (i.e. non-zero):
          Ɗ      -   last three links as a monad:
  Ẉ              -     length of each
         $       -     last two links as a monad:
   Ä             -       cumulative addition
        Ɗ        -       last three links as a monad:
     Ṁ           -         maximum
      H          -         halve
       Ċ         -         ceiling
    ċ            -     count
              Ƈ  - filter keep those for which this is truthy:
            ŒḂ   -   is palindrome?
               Ẹ - any?

Perl 6 , 87 79 ไบต์

-8 bytes กับลูกเล่นบางอย่างจากคำตอบของ Jo King

$!={/\s/&&/^(.+)\s[(.+)\s]*$0$/&&$1.$!}#$!={/\s/&&/^(.+)\s[(.+)\s]*$0$/&&$1.$!}

ลองออนไลน์!

คำตอบ JavaScript ของพอร์ตของ tsh ส่งคืนวัตถุ Regex ที่แตกต่างกันสองรายการ

ทับทิมขนาด 129 ไบต์

f=->l{!l[1]||(1...l.size).any?{|x|l[0,x]==l[-x,x]&&f[l[x..~x]]}}#f=->l{!l[1]||(1...l.size).any?{|x|l[0,x]==l[-x,x]&&f[l[x..~x]]}}

ลองออนไลน์!

JavaScript (Node.js) , 139 ไบต์

f=a=>(s=(''+a).replace(/^(.*),((.*),)?\1$/,'$3'))!=a?f(s):/,/.test(s)//^(.*),((.*),)?\1$/,'$3'))!=a?f(s):/,/.test(s)f=a=>(s=(''+a).replace(

ลองออนไลน์!

C (gcc) (X86), 216 ไบต์

p(L,a,n)int*a;{return n?(memcmp(a,a+L-n,n*4)|p(L-2*n,a+n,L/2-n))&&p(L,a,n-1):1<L;}
#define p(L,a)p(L,a,L/2)//p(L,a,n)int*a;{return n?(memcmp(a,a+L-n,n*4)|p(L-2*n,a+n,L/2-n))&&p(L,a,n-1):1<L;}
#define p(L,a)p(L,a,L/2)

ลองออนไลน์!

p(L,a,n)ผลตอบแทน 0 ถ้าอาร์เรย์aของความยาวLเป็นกึ่ง Palindrome 1 มิฉะนั้น ระบุว่าคำนำหน้าทั้งหมดของความยาว>nได้รับการตรวจสอบแล้วจะเปรียบเทียบคำนำหน้าของความยาวมีคำต่อท้ายของความยาวn เป็นจุดเริ่มต้นnp(L,a)

น่าเสียดายที่โซลูชันที่น่าสนใจนั้นมีความยาวมากกว่า:

224 ไบต์

(f(L,a,n))//#define p(L,a)(n=L/2,
int*a,n;
{return n?(memcmp(a,a+L-n,n*4)|f(L-2*n,a+n,L/2-n))&&f(L,a,n-1):1<L;}//{return n?(memcmp(a,a+L-n,n*4)|f(L-2*n,a+n,L/2-n))&&f(L,a,n-1):1<L;}
int*a,n;
#define p(L,a)(n=L/2,f(L,a,n))//(

ลองออนไลน์!

Ungolfed:

(f(L,a,n)) //#define p(L,a)(n=L/2,
int*a,n;
{
  return n 
    ? (memcmp(a, a+L-n, n*4) | f(L-2*n, a+n, L/2-n)) &&
      f(L,a,n-1)
    : 1 < L;
} // { ... } 
int*a,n;
#define p(L,a)(n=L/2,f(L,a,n)) //(

Japt , 66 ไบต์

@¯X eUsXn}a1 "
ʧV?UÊ<2:ßUéV sVÑ
@¯X eUsXn}a1 "
ʧV?UÊ<2:ßUéV sVÑ

ล่าม Japt

การปรับปรุงครั้งใหญ่ของรุ่นนี้เป็นจริงแล้วมันเป็นภาษาที่ใช้งานได้จริงในขณะนี้ ตอนนี้ทำงานในอาร์เรย์ของจำนวนเต็มตั้งแต่วิธีการก่อนหน้านี้มีข้อผิดพลาด

คำอธิบาย:

@        }a1         Find the first number n > 0 such that...
 ¯X                   the first n elements
     UsXn             and the last n elements
    e                 are the same

"
ʧV?UÊ<2:ßUéV sVÑ    String literal to make it a Semi-palindrome
@¯X eUsXn}a1 "

ʧV?                 If n >= length of input...
    UÊ<2              return true if the length is less than 2
        :            Otherwise...
          UéV         move n elements from the end of the input to the start
              sVÑ     remove the first 2*n elements
         ß            and repeat on the remaining elements

PHP 237 ไบต์

function f($a){for($x=2>$c=count($a);++$i<=$c/2;)$x|=($s=array_slice)($a,0,$i)==$s($a,-$i)&f($s($a,$i,-$i));return$x;}#function f($a){for($x=2>$c=count($a);++$i<=$c/2;)$x|=($s=array_slice)($a,0,$i)==$s($a,-$i)&f($s($a,$i,-$i));return$x;}

ฟังก์ชั่นแบบเรียกซ้ำส่งกลับtrue(สำหรับอินพุตที่มีองค์ประกอบน้อยกว่าสอง) หรือ1สำหรับความจริง
0สำหรับความเท็จ ลองออนไลน์ (มีรายละเอียด)

ความยาวรหัสจริงคือ 118 ไบต์; เซมิคอนดักเตอร์กึ่งที่สร้างขึ้นผ่านการทำสำเนารหัส

สำหรับประสิทธิภาพที่ดีขึ้นแทนที่&ด้วย&&และใส่ก่อน!$x&&++$i

สกาลา 252 ไบต์

def^(s:Seq[Int]):Int={val l=s.size;if(l>1)(1 to l/2).map(i=>if(s.take(i)==s.takeRight(i))^(s.slice(i,l-i))else 0).max else 1}//def^(s:Seq[Int]):Int={val l=s.size;if(l>1)(1 to l/2).map(i=>if(s.take(i)==s.takeRight(i))^(s.slice(i,l-i))else 0).max else 1}

ลองออนไลน์!

PS เห็นได้ชัดว่าการแก้ปัญหามีความยาว 2 เท่าเพื่อตอบสนองความต้องการที่ซอร์สโค้ดคือแบบกึ่ง Palindrome เช่นกัน

PPS ไม่ใช่ตัวเลือกรหัสกอล์ฟ แต่เป็นโซลูชันที่ใช้งานได้จริงโดยใช้การจับคู่รูปแบบ

  def f(s:Seq[Int], i:Int=1):Int = {
    (s, i) match {
      case (Nil ,_) => 1
      case (Seq(_), _) => 1
      case (l, _) if l.take(i) == l.takeRight(i) => f(l.slice(i,l.size-i), 1)
      case (l, j) if j < l.size/2 => f(l, i+1)
      case (_, _) => 0
    }
  }

Perl 6 , 81 ไบต์

($!={/../&&/^(.+)(.*)$0$/&&$1.$!})o&chrs#($!={/../&&/^(.+)(.*)$0$/&&$1.$!})o&chrs

ลองออนไลน์!

ส่งคืน regex /../สำหรับ True และ regex /^(.+)(.*)$0$/สำหรับ False ทำงานคล้ายกับคำตอบของ nwellnhofแต่แปลงรายการเป็นสตริงล่วงหน้า