회문은 그 자체로 반대되는 단어입니다.

이제 회문처럼 보이지만 그렇지 않은 단어가 있습니다. 단어를 고려 예를 들어 sheesh, sheesh그 반대이기 때문에 회문 아닌 hseehs다른 어떤 우리가 생각 그러나 경우에, sh다음이 역의이다, 단일 문자로 sheesh. 이런 종류의 단어를 우리는 반 회문이라고 부릅니다.

청크의 순서가 반대로되어 원래 단어가 형성되도록 단어를 몇 개의 청크로 분할 할 수있는 경우 특히 단어는 반 회문입니다. ( sheesh그 청크는 sh e e sh) 우리는 또한 청크에는 단어의 양쪽 절반에서 온 문자가 필요하지 않습니다 (그렇지 않으면 모든 단어는 반 회문이됩니다). 예를 들어 , 원래 단어의 양쪽에서 문자를 포함 하는 청크 ( )가 rear있기 때문에 반 회문이 아닙니다 . 우리는 홀수 길이 단어의 중심 문자가 단어의 양쪽에 있지 않은 것으로 간주하므로 길이가 홀수 인 단어의 경우 중심 문자는 항상 자체 청크에 있어야합니다.r ea rea

당신의 임무는 양의 정수 목록을 가져 와서 반 회문인지 결정하는 것입니다. 코드는 두 개의 일관된 동일하지 않은 값을 출력해야합니다. 하나는 입력이 반 고문이고 다른 하나는 그렇지 않습니다. 그러나 코드의 바이트 시퀀스 는 반 회문 자체 여야 합니다.

더 적은 바이트를 사용하면 답이 바이트 단위로 점수가 매겨집니다.

테스트 사례

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

더 많은 테스트 케이스를 생성하는 프로그램입니다.

이것들은 일반화 된 Smarandache 회문 과 유사하다고 끔찍하게 지적했다 . 따라서 더 읽기를 원한다면 시작하기 좋은 곳입니다.

레티 나 0.8.2 , 85 69 바이트

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

온라인으로 사용해보십시오! 설명:

M`

일치 모드를 선택합니다. 사실, Retina는 기본적으로 한 줄 프로그램에 대해 일치 모드로 설정되지만이 추가 문자가 아닌 경우 두 번째 코드 사본은 항상 일치합니다.

^

경기는 처음에 시작해야합니다.

(.+,)*

많은 문자를 캡처합니다. 각 실행은 쉼표로 끝나야합니다.

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

파이썬 (2) , 157 (153) 147 143 바이트

tsh 덕분에 -4 바이트 .

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_^

@Emigna 덕분에 -12 바이트 .

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

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 바이트

Jonathan 이 제안한 것과 거의 동일한 기술 을 사용합니다.

.œʒ€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

최고. 어떤은 truthy 인 경우 1 다른 0 . 실행을 종료합니다. 뒤에 오는 모든 것은 완전히 무시됩니다.

파이썬 2 , 275 251 205 바이트

@KevinCruijssen 덕분에 -24 바이트

@PostLeftGhostHunter 덕분에 -44 바이트

@KevinCruijssen 덕분에 -2 바이트 더

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를, 그렇지 않으면 None을 반환합니다

온라인으로 사용해보십시오!

젤리 ,  33  32 바이트

-1 Erik에게
감사 합니다 Outgolfer 버그 수정 및 Jelly의 구현 세부 사항 변경에 대해 Dennis에게 감사합니다.

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

반 회문 수율 1, 다른 수율 0.

$O(2^n)$

또는 테스트 스위트를 참조하십시오 .

유일한 청크는 ŒḂs ({ ^3rd & 4 ^th } vs {29 ^th & 30 ^th } 바이트)이며 코드를 구문 분석 할 수 있습니다.

방법?

모든 작업은 오른쪽 "주 링크"에 의해 수행됩니다.

ŒṖẈÄċṀ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?

펄 6 , 87 79 바이트

Jo King의 답변에서 몇 가지 트릭을 가진 -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]]}}

온라인으로 사용해보십시오!

자바 스크립트 (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)a길이 배열 이 L반 팔린 이면 0을 , 그렇지 않으면 1을 반환합니다. length의 모든 접두사를 >n이미 확인한 경우 length 접두사와 length 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)) //(

apt , 66 바이트

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

apt 인터프리터

이 버전이 크게 개선되었으므로 실제로 대부분의 실제 언어를 능가합니다. 이전 방법에 버그가 있었으므로 이제 정수 배열에서 작동합니다.

설명:

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

온라인으로 사용해보십시오!

추신. 분명히 소스 코드도 반 회문이라는 요구 사항을 충족시키기 위해 솔루션이 2 배 더 길었습니다.

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

펄 6 , 81 바이트

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

온라인으로 사용해보십시오!

/../True에 대한 정규식 /^(.+)(.*)$0$/과 False에 대한 정규식 을 반환합니다 . nwellnhof의 답변 과 비슷하게 작동 하지만 미리 목록을 문자열로 변환합니다.