Ein Palindrom ist ein Wort, das sein eigenes Gegenteil ist.

Nun gibt es einige Wörter, die wie Palindrome aussehen, dies aber nicht sind. Zum Beispiel betrachtet das Wort sheesh, sheeshist kein Palindrom , weil seine Rückseite ist hseehsdie anders ist, aber wenn man bedenkt , shein einzelner Buchstabe sein, dann ist es umgekehrt sheesh. Diese Art von Wort nennen wir ein Halbpalindrom.

Insbesondere ist ein Wort ein Halbpalindrom, wenn wir das Wort in eine bestimmte Anzahl von Abschnitten aufteilen können, sodass beim Umkehren der Reihenfolge der Abschnitte das ursprüngliche Wort gebildet wird. (Für sheeshdiese Chunks gilt sh e e sh) Wir werden auch verlangen, dass kein Chunk Buchstaben aus beiden Worthälften enthält (ansonsten wäre jedes Wort ein Halbpalindrom). Beispielsweise rearhandelt es sich nicht um ein Halbpalindrom, da r ea res einen Block ( ea) enthält, der Buchstaben von beiden Seiten des ursprünglichen Wortes enthält. Wir betrachten das zentrale Zeichen in einem Wort mit ungerader Länge als keine Seite des Wortes, daher muss das zentrale Zeichen bei Wörtern mit ungerader Länge immer in einem eigenen Block stehen.

Ihre Aufgabe wird es sein, eine Liste positiver Ganzzahlen zu erstellen und festzustellen, ob es sich um ein Halbpalindrom handelt. Ihr Code sollte zwei konsistente, ungleiche Werte ausgeben, einen, wenn die Eingabe ein Halbpalindrom ist, und den anderen, wenn die Eingabe ein Halbpalindrom ist. Die Byte-Sequenz Ihres Codes muss jedoch selbst ein Semi-Palindrom sein.

Antworten werden in Bytes bewertet, wobei weniger Bytes besser sind.

Testfälle

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

Programm, um mehr Testfälle zu generieren.

borrible wies darauf hin, dass diese generalisierten Smarandache-Palindromen ähnlich sind . Wenn Sie also weiterlesen möchten, ist dies ein Ausgangspunkt.

Retina 0,8,2 , 85 69 Bytes

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

Probieren Sie es online!Erläuterung:

M`

Wählt den Match-Modus aus. Tatsächlich verwendet Retina für ein einzeiliges Programm standardmäßig den Übereinstimmungsmodus, aber die zweite Kopie des Codes würde immer übereinstimmen, wenn diese zusätzlichen Zeichen nicht berücksichtigt würden.

^

Das Spiel muss am Anfang beginnen.

(.+,)*

Erfassen Sie eine Reihe von Zeichenfolgen. Jeder Lauf muss mit einem Komma enden.

(\d+,)?

Passen Sie optional eine Ziffernfolge und ein Komma an.

(?<-1>\1)*

Ordnen Sie optional alle Erfassungen in umgekehrter Reihenfolge zu, und platzieren Sie sie nacheinander.

$

Das Spiel muss am Ende enden.

(?(1)^)

Backtrack, es sei denn, alle Captures wurden gepoppt. Es funktioniert, indem das Match immer noch am Anfang der Zeichenkette sein muss, wenn wir eine nicht gepoppte Aufnahme haben, was unmöglich ist.

Jelly , 27 23 Bytes

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

Gibt 1 für Semi-Palindrome zurück, sonst 0 .

Probieren Sie es online!

Wie es funktioniert

Ṗ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 bytes dank 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)

Probieren Sie es online!

05AB1E , 59 47 43 41 Bytes

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

-12 Bytes dank @Emigna .

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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 Bytes

Verwendet ungefähr dieselbe Technik wie Jonathan .

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

Probieren Sie es online!

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

Volles Programm. Empfängt eine Liste von STDIN, gibt 1 oder aus 0 an STDOUT aus.

.œʒ        }

Filtern Sie die Partitionen, die ...

   €gηOZ;îå

Diese Bedingung: Die Längen von jedem ( €g) werden in einer Liste gespeichert, deren Präfixe ( η) dann summiert werden ( O), wodurch wir die kumulativen Summen der Längenliste erhalten. Dann wird die oberste Hälfte des Maximums dieser Liste auf den Stapel geschoben - wobei jedoch auch die ursprüngliche Liste darauf bleibt ( Z;î) und wenn sie åin den kumulativen Summen vorkommt ( ), dann gibt die Funktion wahrheitsgetreu zurück.

εÂQ}

Für jeden vergleiche ( Q) a mit einem vertauschten, die separat auf den Stapel geschoben werden von Â. Gibt eine Liste von 0 s und 1 s zurück.

ZĀq

Maximal. Wenn eine wahr ist, dann 1 sonst 0 . Ausführung beenden. Alles was folgt wird komplett ignoriert.

Python 2 , 275 251 205 Bytes

-24 Bytes dank @KevinCruijssen

-44 Bytes dank @PostLeftGhostHunter

-2 weitere Bytes dank @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])

Gibt True für Semi-Palindrome zurück, andernfalls None

Probieren Sie es online!

Jelly ,  33  32 Bytes

-1 Danke an Erik the Outgolfer
Danke auch an Dennis für die Fehlerbehebung und die Überarbeitung eines Implementierungsdetails in Jelly.

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

Semi-Palindrome ergeben 1, andere ergeben 0.

$O(2^n)$

Oder sehen Sie sich die Testsuite an .

Die einzigen Brocken sind die ŒḂs ({3 ^rd und 4 ^th } {vs 29 ^th & 30 ^th } Byte), nur den Code zu parsen ermöglichen.

Wie?

Alle Arbeiten werden von der rechten Seite ausgeführt - dem "Hauptlink":

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

-8 Bytes mit einigen Tricks aus Jo Kings Antwort

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

Probieren Sie es online!

Portierung der JavaScript-Antwort von tsh. Gibt zwei verschiedene Regex-Objekte zurück.

Ruby , 129 Bytes

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

Probieren Sie es online!

JavaScript (Node.js) , 139 Byte

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

Probieren Sie es online!

C (gcc) (X 86), 216 Bytes

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)

Probieren Sie es online!

p(L,a,n)Gibt 0 zurück, wenn das Array mit ader Länge Lein Halbpalindrom ist, andernfalls 1. Da bereits alle Präfixe der Länge >nüberprüft wurden, wird das Präfix der Länge nmit dem Suffix der Länge verglichen n. p(L,a)ist der Einstiegspunkt.

Leider ist die interessantere Lösung länger:

224 Bytes

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

Probieren Sie es online!

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 Bytes

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

Japt Interpreter

Diese Version wurde stark verbessert und schlägt die meisten praktischen Sprachen. Funktioniert jetzt mit einem Array von Ganzzahlen, da die vorherige Methode einen Fehler aufwies.

Erläuterung:

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

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

rekursive Funktion, gibt zurück true(für Eingaben mit weniger als zwei Elementen) oder 1für wahr,
0für falsch. Probieren Sie es online aus (enthält Aufschlüsselung).

Die tatsächliche Codelänge beträgt 118 Byte. Semi-Palindrom, erstellt durch Code-Duplikation.

Für eine bessere Leistung, ersetzen &mit &&und legen Sie !$x&&vor ++$i.

Scala, 252 Bytes

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}

Probieren Sie es online!

PS. Anscheinend ist die Lösung 2-mal länger, nur um die Anforderung zu erfüllen, dass der Quellcode auch halbpalindrom ist.

PPS. Kein Code-Golf-Kandidat, sondern eine rein funktionale Lösung mit Pattern Matching:

  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 Bytes

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

Probieren Sie es online!

Gibt den regulären Ausdruck /../für True und den regulären Ausdruck zurück/^(.+)(.*)$0$/ für False zurück. Funktioniert ähnlich wie die Antwort von nwellnhof , konvertiert die Liste jedoch vorher in einen String.