Паліндром - це слово, яке є його зворотним.

Зараз є кілька слів, які можуть виглядати як паліндроми, але ні. Для прикладу розглянемо слово sheesh, sheeshне паліндром , тому що його зворотне , hseehsякий відрізняється, проте , якщо ми вважаємо sh, що одна буква, то це зворотне sheesh. Таке слово ми назвемо напівпаліндром.

Зокрема, слово - це напівпаліндром, якщо ми можемо розділити слово на деяку кількість фрагментів, таким чином, коли порядок відрізків буде відмінено, формується початкове слово. (Для sheeshтих sh e e shшматок є ) Ми також не вимагатимемо, щоб жоден фрагмент не містив букви з обох половин слова (інакше кожне слово було б напівпаліндром). Наприклад, rearце не напівпаліндром, тому що він r ea rмає фрагмент ( ea), який містить літери з обох сторін початкового слова. Ми вважаємо, що центральний символ у слові непарної довжини не має жодної сторони слова, таким чином, для слів із непарною довжиною центральний символ завжди повинен бути у власному відрізку.

Вашим завданням буде скласти список натуральних чисел і визначити, чи є вони напівпаліндром. Ваш код повинен виводити два послідовні нерівні значення, одне, якщо вхід є напівпаліндром, а інше інакше. Однак послідовність байтів вашого коду повинна бути самою напівпаліндром .

Відповіді будуть набрані в байтах, менша кількість байтів буде кращою.

Тестові кейси

[] -> 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

Програма для генерації більше тестів.

нудно вказував, що вони схожі на генералізовані смарандашські паліндроми . Тож якщо ви хочете ще трохи прочитати, це саме одне місце для початку.

Сітківка 0,8,2 , 85 69 байт

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

Спробуйте в Інтернеті! Пояснення:

M`

Вибір режиму відповідності. Насправді Retina за замовчуванням використовує режим Match для однорядкової програми, але друга копія коду завжди відповідатиме, якби не ці додаткові символи.

^

Матч повинен починатися на початку.

(.+,)*

Захоплення кількох циклів символів. Кожен запуск повинен закінчуватися комою.

(\d+,)?

Необов’язково збігайте пробіг цифр і кома.

(?<-1>\1)*

Необов’язково співставляйте всі знімки у зворотному порядку, вискакуючи кожну з них у відповідності.

$

Матч повинен закінчуватися наприкінці.

(?(1)^)

Зворотний трек, якщо не вискакували всі знімки. Він працює, вимагаючи, щоб збіг все ще знаходився на початку рядка, якщо у нас є незапущене захоплення, що неможливо.

Желе , 27 23 байт

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

Повертає 1 для напівпаліндрів, 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 байт

-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) з назад, які виштовхуються окремо в стеці . Повертає список 0 с і 1 с.Â

ZĀq

Максимум. Якщо будь-яка правда, то 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])

Повертає "Істинно" для напівпаліндрому, інакше

Спробуйте в Інтернеті!

Желе ,  33  32 байт

-1 Дякуємо Еріку Позашляховику
Дякуємо також Деннісу за виправлення помилок та розгляд деталей щодо впровадження в Jelly.

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

Напівпаліндроми дають урожай 1, інші дають урожай 0.

Спробуйте в Інтернеті! (повільно, як це є$O(2^n)$ у вхідній довжині)

Або подивіться набір тестів .

Єдиними фрагментами є ŒḂs ({3- ^й та 4- ^й }) проти {29- ^го та 30- ^го } байти), просто щоб дозволити коду проаналізувати.

Як?

Всі роботи виконуються правою частиною - "Основна ланка":

ŒṖẈÄċṀ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 байт з деякими хитрощами з відповіді Джо Кінга

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

Спробуйте в Інтернеті!

Порт tsh-відповіді JavaScript. Повертає два різних об'єкти 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є напівпаліндром, 1 в іншому випадку. З огляду на те, що всі префікси довжини >nвже перевірені, він порівнює довжину префікса nз суфіксом довжини n. p(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))//(

Спробуйте в Інтернеті!

Безголівки:

(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.

Scala, 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. Мабуть, рішення вдвічі довше лише для задоволення вимоги, що вихідний код також є напівпаліндром.

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

Спробуйте в Інтернеті!

Повертає регулярний вираз /../для True та регулярний вираз /^(.+)(.*)$0$/для False. Працює аналогічно відповіді nwellnhof , але попередньо перетворює список у рядок.