Ein semi-palindromes Puzzle


23

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.


2
Warum haben Sie Semi-Palindrome mithilfe von Strings definiert, aber Ihre Eingaben sind Arrays aus ganzen Zahlen? Dies ist nicht nur verwirrend, sondern bedeutet auch, dass wir unseren Quellcode nicht mit unserem eigenen Programm testen können.
BradC

@BradC Palindrome und ähnliches werden oft in Worten erklärt, da dies etwas einfacher ist.
Erik der Outgolfer

@BradC-Strings führen in der Regel zu seltsamen Randfällen, insbesondere in Bezug auf Zeichen im Vergleich zu Bytes. Ich wähle Nummer, weil sie einfacher sind. Ich dachte, Worte wären für Erklärungszwecke einfacher.
Weizen-Assistent

2
Diese Arten von Palindromen sind in der Literatur als generalisierte Smarandache-Palindrome bekannt.
Ausleihbar

1
@RosLuP Ja, "echte" Palindrome sind auch Halbpalindrome. Behandeln Sie einfach jedes Zeichen / jede ganze Zahl so, wie sie ist, ohne zusätzliche "Chunks".
BradC

Antworten:


6

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.


5

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.

4

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!


1
Ändern Sie x==x[::-1], len(x)<2um 2 * 2 Bytes zu speichern; 143 Bytes
tsh

4

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

Sie können das Problem mit Listen ungerader Länge mit øøε.œ} `umgehen und 6 Bytes einsparen. Sie scheinen auch 30 unbenutzte Bytes in ...
Emigna

@Emigna die No-Ops am Ende sind mit der eingeschränkten Quellenanforderung der Herausforderung zu erfüllen
Kamil Drakari

@ KamilDrakari: Oh, richtig. Ich habe diesen Teil vergessen. Die gute Nachricht ist, dass die 6-Byte-Speicherung dann 12 Bytes
beträgt

@Emigna Sehr schlau mit dem Double-Zip-Trick. Ich habe mich nicht über diesen Teil gefreut, aber das ist viel besser! Übrigens, seit dem Umschreiben von Elixir können die 2-Byte-Befehle statt mit verwendet werden ε }. :)
Kevin Cruijssen

@ KevinCruijssen: Ah cool. Ich wusste das nicht.
Emigna

4

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.


3

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!


1
Oder kehre einfach zurück 1
Jo King

Warum ist s (x) doppelt definiert?
Dr Y Wit

Weil sie sagen, zählen als Palindrom ... aber es ist möglich, eine Funktion mit dem gleichen Namen zu definieren ???
RosLuP

@RosLuP Ja, das kannst du. Der zweite überschreibt nur den ersten
Jo King

3

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(2n)

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?

3

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.




1

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

1

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

0

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.


0

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

Die Herausforderung erfordert, dass Ihr Code auch ein Halbpalindrom ist. Das ist der größte Spaß an der Herausforderung.
Wheat Wizard

@PostLeftGhostHunter, ich habe den ursprünglichen Quellcode in den Kommentar eingefügt, um die Anforderung zu erfüllen. Übrigens, was macht es Spaß, Quellcode halbpalindrom zu machen? Wenn ich mich nicht irre, wäre jede Lösung in diesem Thread ohne diese Anforderung zweimal kürzer. Kennen Sie eine andere Lösung?
Dr Y Wit

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.

Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.