Palindrom mit ABAP prüfen

Das Prüfen eines Palindroms mit der Programmiersprache ABAP ist eines der ersten ABAP-Programme, das man vermutlich entwerfen wird. Es erfordert ein Verständnis für die Logik der Programmiersprache und ist trotzdem zugleich für Einsteiger leicht verständlich.

In diesem Artikel zeige ich Dir wie man einfach und schnell sowohl ein Palindrom-Wort als auch ein Palindrom-Satz in ABAP prüfen kann.

Was ist ein Palindrom?

Bevor wir uns direkt dem Beispielprogramm in ABAP zuwenden klären wir einmal zuerst, was man unter einem Palindrom versteht.

Ein Palindrom ist eine Folge von Buchstaben, die vorwärts und rückwärts gelesen denselben Text oder einen Sinn ergeben.

Beispiele für Palindrome sind demzufolge:

• Anna
• Lagerregal
• Ein Esel lese nie
• Die Liebe ist Sieger; stets rege ist sie bei Leid
• Der Freibierfred

Auf Wikipedia kannst Du mithilfe der Liste deutscher Palindrome passende Beispiele für Dein ABAP-Programm finden.

Palindrom-Wort in ABAP prüfen

Einfache Variante

Es gibt bereits eine Funktion, die die Umkehrung von Wörtern und Sätzen übernimmt: STRING_REVERSE.

Wenn man diese Funktion benutzt, kann man sich einfach und schnell eine Prüfung auf Palindrome programmieren.

*----------------------------------------------------------------------
* Datendeklaration
*----------------------------------------------------------------------
PARAMETERS: p_input     TYPE c LENGTH 50.
DATA: lv_input_reverse  TYPE c LENGTH 50.

*----------------------------------------------------------------------
* Zeichenkette rückwärts ermitteln
*----------------------------------------------------------------------
CALL FUNCTION 'STRING_REVERSE'
  EXPORTING
    string    = p_input
    lang      = sy-langu
  IMPORTING
    rstring   = lv_input_reverse
  EXCEPTIONS
    too_small = 1
    OTHERS    = 2.

*----------------------------------------------------------------------
* Ausgabe
*----------------------------------------------------------------------
IF sy-subrc <> 0.
  WRITE: / 'Fehler aufgetreten.'.
ELSE.
  IF p_input EQ lv_input_reverse.
    WRITE: / 'Erfolg - Palindrom'.
  ELSE.
    WRITE: / 'Fehler - Keine Palindrom'.
  ENDIF.
ENDIF.

Ausführliche Variante

In der ausführlichen Variante prüfen wir eigenständig, ob das Wort ein Palindrom ist. Hierfür verwenden wir Standard-ABAP-Möglichkeiten und keine vordefinierten Funktionen.

*----------------------------------------------------------------------
* Datendeklaration
*----------------------------------------------------------------------
PARAMETERS: p_input     TYPE c LENGTH 50.
DATA: lv_input_reverse TYPE c LENGTH 50,
      lv_length        TYPE i,
      lv_index         TYPE i.

*----------------------------------------------------------------------
* Zeichenkette rückwärts ermitteln
*----------------------------------------------------------------------
lv_length = strlen( p_input ).
lv_index = lv_length - 1.
WHILE lv_index >= 0.
  CONCATENATE lv_input_reverse p_input+lv_index(1) INTO lv_input_reverse.
  lv_index = lv_index - 1.
ENDWHILE.

*----------------------------------------------------------------------
* Ausgabe
*----------------------------------------------------------------------
IF p_input EQ lv_input_reverse.
  WRITE: / 'Erfolg - Palindrom'.
ELSE.
  WRITE: / 'Fehler - Keine Palindrom'.
ENDIF.

Palindrom-Satz in ABAP prüfen

Generell muss man bei der Prüfung von Palindromen in ABAP erwähnen: Eine inhaltliche Prüfung ist nicht Sinn dieser Programmierung. Es wird technisch nur geprüft, ob die Buchstaben vorwärts und rückwärts die gleichen sind.

Ein Palindrom-Satz kann man einfach und schnell mit der Funktion STRING_REVERSE prüfen.

Aber es gibt auch hierfür eine ausführliche Variante, Palindrom-Sätze zu prüfen. Hierfür kann man fast die gleiche Programmierung verwenden wie bei der Palindrom-Wort-Prüfung. Hierfür muss man lediglich die Leerzeichen entfernen.

*----------------------------------------------------------------------
* Datendeklaration
*----------------------------------------------------------------------
PARAMETERS: p_input     TYPE c LENGTH 50.
DATA: lv_input_no_space TYPE c LENGTH 50,
      lv_input_reverse  TYPE c LENGTH 50,
      lv_length         TYPE i,
      lv_index          TYPE i.

*----------------------------------------------------------------------
* Leerzeichen entfernen
*----------------------------------------------------------------------
lv_input_no_space = p_input.
CONDENSE lv_input_no_space NO-GAPS.

*----------------------------------------------------------------------
* Zeichenkette rückwärts ermitteln
*----------------------------------------------------------------------
lv_length = strlen( lv_input_no_space ).
lv_index = lv_length - 1.
WHILE lv_index >= 0.
  CONCATENATE lv_input_reverse lv_input_no_space+lv_index(1) INTO lv_input_reverse.
  lv_index = lv_index - 1.
ENDWHILE.

*----------------------------------------------------------------------
* Ausgabe
*----------------------------------------------------------------------
IF lv_input_no_space EQ lv_input_reverse.
  WRITE: / 'Erfolg - Palindrom'.
ELSE.
  WRITE: / 'Fehler - Keine Palindrom'.
ENDIF.

Palindrom effizient ermitteln

Bei allen gezeigten Beispielen werden alle Zeichen der Eingabe überprüft. Das ist nicht die effizienteste Lösung. Es gibt Wege, die Programmierung noch effizienter und ressourcenschonender zu programmieren. Hierfür reicht es aus, nur die Hälfte der Eingabe zu überprüfen. Denn die erste Hälfte der Eingabe muss rückwärts gleich der zweiten Hälfte sein.

Beispiel:

• Anna – An = na
• Lagerregal – Lager = lager
• Ein Esel lese nie – Ein Esel = ein esel

*----------------------------------------------------------------------
* Datendeklaration
*----------------------------------------------------------------------
PARAMETERS: p_input     TYPE c LENGTH 50 OBLIGATORY.

DATA: lv_input_no_space  TYPE c LENGTH 50,
      lv_input_reverse   TYPE c LENGTH 50,
      lv_length          TYPE i,
      lv_index           TYPE i,
      lv_index_reverse   TYPE i,
      lv_is_no_palindrom TYPE flag.

*----------------------------------------------------------------------
* Leerzeichen entfernen
*----------------------------------------------------------------------
lv_input_no_space = p_input.
CONDENSE lv_input_no_space NO-GAPS.

*----------------------------------------------------------------------
* Zeichenkette rückwärts ermitteln /
* Effiziente Ermittlung - Die Hälfte reicht aus
*----------------------------------------------------------------------
lv_length = strlen( lv_input_no_space ).
WHILE lv_index < lv_length / 2.
  lv_index_reverse = lv_length - lv_index - 1.
  IF lv_input_no_space+lv_index(1) NE lv_input_no_space+lv_index_reverse(1).
    lv_is_no_palindrom = 'X'.
    EXIT. " Verlasse Schleife
  ENDIF.

  lv_index = lv_index + 1.
ENDWHILE.

*----------------------------------------------------------------------
* Ausgabe
*----------------------------------------------------------------------
IF lv_is_no_palindrom IS INITIAL.
  WRITE: / 'Erfolg - Palindrom'.
ELSE.
  WRITE: / 'Fehler - Keine Palindrom'.
ENDIF.