Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Palindrome (Zeichenketten)

Schreiben Sie ein Programm, das eine Eingabe als Zeichenkette (string oder char[])
erwartet und danach ausgibt, ob es sich beim eingegebenen Text um ein sog. Palindrom handelt (true/false). Ein Palindrom ist ein Satz, der von beiden Seiten gelesen denselben Text ergibt. Einige der folgenden Textzeilen sind Palindrome:

Linux, super, hier Gnu.
Reihung, oho, Gnu hier!
Reit amal a Lamatier.
Sugus - AHA! Sugus.
Reihungen, nenne Gnu hier!
Leben Sie mit im Eisnebel!
Reihung lief stets feil. Gnu hier.
Ein Lama mal' nie.
Reihe sie legt im Stresse. Besserts mit Geleise hier?

Entfernen Sie zunächst alle unnötigen Satzzeichen und Leerschläge. Verwandeln Sie danach alles in Kleinbuchstaben.
Laden Sie obige Palindrome herunter.

 

Dateien:

1 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

Kommentare (1)

maxbox 24. März 2013 20:45   reply report
RegEx and Recursion in one!

19 Lösung(en)

# Ueberpruefung auf Palindrome
def palindorme(s):
   s0=''
   s1=s0.join(s.split())
   s2=s1.lower()
   s3=s0.join(s2.split('.'))
   s4=s0.join(s3.split(','))
   s5=s0.join(s4.split('-'))
   s6=s0.join(s5.split('!'))
   s7=s0.join(s6.split('\''))
   s8=s7[::-1]
   if s7 == s8:
      print s + " -> Paliodrome true"
   else:
      print s + " -> Paliodrome false"

palindorme('Linux, super, hier Gnu.')
palindorme('Reihung, oho, Gnu hier!')
palindorme('Reit amal a Lamatier.')
palindorme('Ein Neger mit Gazelle zagt im Regen nie.')
palindorme('Sugus - AHA! Sugus.')
palindorme('Reihungen, nenne Gnu hier!')
palindorme('Reihung lief stets feil. Gnu hier.')
palindorme('Ein Lama mal\' nie.')
                

Lösung von: Martin Guggisberg (Universität Basel / PH FHNW)

/**
 * Prüfe, ob ein String ein Palindrom ist.
 * Diese Java-API Lösung macht Gebrauch von JAVA-RegEx.
 * 
 * @author Philipp Gressly (phi@gressly.ch)
 */
/*
 * History: first Implementation: 28.02.2011
 */
public class Palindrome {
    
  public static void main(String[] args) {
    new Palindrome().top();
  }
   
  void top() {
    palindormtest("Linux, super, hier Gnu.");
    palindormtest("Reihung, oho, Gnu hier!");
    palindormtest("Reit amal a Lamatier.");
    palindormtest("Ein Neger mit Gazelle zagt im Regen nie.");
    palindormtest("Sugus - AHA! Sugus.");
    palindormtest("Reihungen, nenne Gnu hier!");
    palindormtest("Reihung lief stets feil. Gnu hier.");
    palindormtest("Ein Lama mal\' nie.");
  }

  void palindormtest(String p) {
    System.out.println(p + " palindrom? -->" + istPalindrom(p));  
  }
  
  boolean istPalindrom(String p) {
      // Alles in Kleinbuchstaben:
      p = p.toLowerCase();
      // Entferne alles, was keine Buchstaben sind:
      p = p.replaceAll("[^a-z]", "");
      return p.equals(new StringBuffer(p).reverse().toString());
  }
  
}  // end of class Palindrome
                

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

'Solution for VBA

'Ansatz:
'Den String in der Hälfte abschneiden,
'hintere Hälfte umdrehen/Reversen, dann Sringvergleich

Public Function IstPalindrom(ByVal sWort As String) As Boolean
Dim Rest As Integer
Dim bRet As Boolean

sWort = Bereinige(sWort)
Rest = Len(sWort) Mod 2

If Mid(sWort, 1, Int((Len(sWort) / 2) + Rest)) = _
    ReverseString(Mid(sWort, Int((Len(sWort) / 2) + Rest))) Then
    
    bRet = True

End If

IstPalindrom = bRet

End Function

Public Function ReverseString(ByVal InputString As String) _
  As String

Dim lLen As Long, lCtr As Long
Dim sChar As String
Dim sAns As String

lLen = Len(InputString)
For lCtr = lLen To 1 Step -1
    sChar = Mid(InputString, lCtr, 1)
    sAns = sAns & sChar
Next

ReverseString = sAns

End Function

Private Function Bereinige(ByVal sWort As String) As String
Dim i As Integer, TmpStr As String
Dim char As Integer

sWort = LCase(sWort)

For i = 1 To Len(sWort)
    char = Asc(Mid(sWort, i, 1))
    If char >= 97 And char <= 122 Then
        TmpStr = TmpStr & Mid(sWort, i, 1)
    End If
Next i

Bereinige = TmpStr

End Function

Sub Test()
Debug.Print IstPalindrom("Linux, super, hier Gnu.")
Debug.Print IstPalindrom("Reihung, oho, Gnu hier!")
Debug.Print IstPalindrom("Reit amal a Lamatier.")
Debug.Print IstPalindrom("Sugus - AHA! Sugus.")
Debug.Print IstPalindrom("Reihungen, nenne Gnu hier!")
Debug.Print IstPalindrom("Leben Sie mit im Eisnebel!")
Debug.Print IstPalindrom("Reihung lief stets feil. Gnu hier.")
Debug.Print IstPalindrom("Ich bin kein Palindrom")
End Sub
                

Lösung von: Felix Reinhold ()

/**
 * @author Philipp Patrick Beck
 * 09.11.2011	*/
/*Hier mit String realisiert*/
public class PalinString {
	private String eingabe;
	
	public PalinString(String pEingabe) {
		eingabe = pEingabe;
		eingabe = eingabe.replaceAll("  [^a-zA-]","").toLowerCase();
	}
	
	public boolean isPalindrom(){		
		return eingabe.equals(new StringBuffer(eingabe).reverse().toString());
	}
	

}
                

Lösung von: Philipp Beck (Universität Stuttgart)




/**
 * @author Philipp Patrick Beck
 * 09.11.2011	*/

/*Hier bewusst mit char realisiert,
 *jedoch wären verbesserungsvorschläge hier gut ;) */
public class PalinChar {
	private char einleseChar[];
	private char zeichenkette[];
	
	public PalinChar(String pEingabe) {
		einleseChar = new char[pEingabe.length()];
		
		for(int i = 0 ; i < pEingabe.length() ; i++){
			einleseChar[i] = pEingabe.charAt(i);
		}
		
		int sonderzeichenAnzahl = einleseChar.length;
		for(int i = 0 ; i < einleseChar.length ; i++){
			if(einleseChar[i] == ' ' ||
			   einleseChar[i] == '?' ||   
			   einleseChar[i] == '!' ||
			   einleseChar[i] == ',' ||
			   einleseChar[i] == '.' ){
			   
				sonderzeichenAnzahl--;
			}
		}
		
		zeichenkette = new char[sonderzeichenAnzahl];
		
		int j = 0;
		for(int i = 0 ; i < einleseChar.length ; i++){
			
			if(einleseChar[i] != ' ' &&
			   einleseChar[i] != '?' &&   
			   einleseChar[i] != '!' &&
			   einleseChar[i] != ',' &&
			   einleseChar[i] != '.' ){
			   
				zeichenkette[j] = einleseChar[i];
				System.out.println(j + "   " + zeichenkette[j]);
				j++;
				
			}
		}
		
	}

	
	public boolean isPalindrom() {
		boolean check = false;
		int i = 0;
		while(zeichenkette[i] == zeichenkette[(zeichenkette.length -1) -i] ){
			i++;
			if(i == (zeichenkette.length/2 -1)){
				check = true;
				break;
			}else if(i > (zeichenkette.length/2 -1)){
				check = false;
				break;
			}
		
		}
		return check;
	}
	
}

                

Lösung von: Philipp Beck (Universität Stuttgart)

/**
 * @author Philipp Patrick Beck
 * 19.01.2012	*/
public class PalinRekursiv {
	private String eingabe;
	
	public PalinRekursiv(String pEingabe) {
		eingabe = pEingabe;
		eingabe = eingabe.replaceAll("[^a-zA-Z]","").toLowerCase();
		
	}
	/*Rekursive Lösung, konnte es jedoch mangels Zeit nicht 100 % überprüfen*/
	public boolean isPalindrom(int n){
		boolean check;
		
		if(eingabe.charAt(n) ==  eingabe.charAt((eingabe.length() -1) -n)){
			check = true;
		}else{
			check = false;
			n = eingabe.length();
		}
		
		if(n < eingabe.length()/2 - 1){
			check = isPalindrom(n+1);
		}
		
		return check;
		
	}
}
                

Lösung von: Philipp Beck (Universität Stuttgart)

while(defined($strng=<>)){
	@strng=split(' ', $strng);
	$strng=join('', @strng);
	$strng = lc $strng;
	$strng =~ tr/a-z0-9#//cd;
	$strng eq reverse($strng) ? print "Palindrom.\n" : print "KEIN Palindrom.\n";
}
                

Lösung von: Name nicht veröffentlicht

//***************************************maXbox 
 procedure palindromeTest(asc: string; out sout: string; n: byte);
 begin
   if n <= length(asc) then begin
     palindromeTest(asc,sout,n+1);
     sout:= sout+ asc[n];
   end;
 end;  
 
 function PalindromeChecker(asc: string): boolean;
 var tmpstr: string;
 begin
   result:= false;
   asc:= ReplaceRegExpr('[^a-zA-Z]',asc,'', true);
   palindromeTest(asc,tmpstr, 1);
   if CompareText(asc,tmpstr)= 0 then
     result:= true;
 end;    
//****************************************

//Call and Test
 writeln(BooleanToString(PalindromeChecker('Leben Sie mit im Eisnebel!')));
  writeln('palindrome check: '+booleantoString(palindromechecker('Sugus')))
  rets:= 'ein neger mit gazelle , zagt im regen nie!!';
  writeln('palindrome check: '+booleantoString(palindromechecker(rets)))
  rets:= 'Reihung lief stets feil; Gnu hier.;
  writeln('palindrome check: '+booleantoString(palindromechecker(rets)))
  



                

Lösung von: Max Kleiner (BFH)

println palindromtest("Linux, super, hier Gnu.")
println palindromtest("Linux, super, hier Gnu.");
println palindromtest("Reihung, oho, Gnu hier!");
println palindromtest("Reit amal a Lamatier.");
println palindromtest("Ein Neger mit Gazelle zagt im Regen nie.");
println palindromtest("Sugus - AHA! Sugus.");
println palindromtest("Reihungen, nenne Gnu hier!");
println palindromtest("Reihung lief stets feil. Gnu hier.");
println palindromtest("Ein Lama mal\' nie.");

boolean palindromtest(String test) {
	println ""
	println test
	test = test.toLowerCase().replaceAll(/[^a-z]/, "")
	if (test.toList() == test.toList().reverse()) {
	  return true
	} else {
	  return false
	}
}
                

Lösung von: Silvia Rothen (rothen ecotronics)

//***************************************maXbox 

 function PalindromeChecker2(asc: string): boolean;
 begin
   result:= false;
   asc:= ReplaceRegExpr('[^a-zA-Z]',asc,'',true);
   if CompareText(asc,ReverseString(asc))=0 then
     result:= true;
 end;    

  writeln(BooleanToString(PalindromeChecker2('Leben Sie, mit im Eisnebel!')));
 
                

Lösung von: Max Kleiner (BFH)

// Kompiliert und getestet unter Linux 3.2.0

#include <iostream>  // std::cout, std:: endl
#include <fstream>   // std::ifstream
#include <stdlib.h>  // exit()
#include <vector>    // std::vector
#include <string>    // std::string
#include <algorithm> // std::transform

bool evalParameters (int argc);
bool readFromFile (std::vector<std::string> &palindrome);
bool toLowerSring(std::string &line);
bool removeSpecialCharacters(std::string &line);
bool preparePalindromes(std::vector<std::string> &palindrome);
bool checkForPalindromes(std::vector<std::string> &palindrome);

int main (int argc, const char* argv[]) {
    std::vector<std::string> palindrome;

    if (false == evalParameters(argc)) {
        exit(EXIT_FAILURE);
    }

    if (false == readFromFile(palindrome)) {
        std::cout << "Error while reading from File." << std::endl;
        exit(EXIT_FAILURE);
    }

    if (false == preparePalindromes(palindrome)) {
        std::cout << "Error while preparing the palindromes." << std::endl;
        exit(EXIT_FAILURE);
    }
    
    if (false == checkForPalindromes(palindrome)) {
        std::cout << "Error while checking palindromes." << std::endl;
        exit(EXIT_FAILURE);
    }

    exit(EXIT_SUCCESS);
}

bool evalParameters (int argc) {
    bool retCode = true;

    if (argc > 1) {
        std::cout << "Usage: This program doesn't accept any parameters." << std::endl;
        std::cout << "       Please pass your palindromes to check in palindrome.txt" << std::endl;

        retCode = false;
    }
    else {
        retCode &= true;
    }

    return retCode;
}

bool readFromFile (std::vector<std::string> &palindrome) {
    bool retCode = true;
    std::string line;
    std::ifstream fileHandle;

    fileHandle.open("palindrome.txt");

    if (true == fileHandle.is_open()) {
        while (getline (fileHandle, line)) {
            palindrome.push_back(line);
        }
        retCode &= true;
    }
    else {
        std::cout << "Unable to find / open file: palindrome.txt" << std::endl;
        retCode = false;
    }

    fileHandle.close();

    return retCode;
}

bool toLowerSring(std::string &line) {
    bool retCode = true;

    std::transform(line.begin(), line.end(), line.begin(), ::tolower);

    return retCode;
}

bool removeSpecialCharacters(std::string &line) {
    bool retCode = true;
    
    for (int i = 0; i < line.size(); ++i) {
        if (line.c_str()[i] < 97 || line.c_str()[i] > 122) {
            line.erase(i, 1);
            --i;
        }
    }
    
    return retCode;
}

bool preparePalindromes(std::vector<std::string> &palindrome) {
    bool retCode = true;

    for (int i = 0; i < palindrome.size(); ++i) {
        retCode &= toLowerSring(palindrome.at(i));
        retCode &= removeSpecialCharacters(palindrome.at(i));
    }

    return retCode;
}

bool checkForPalindromes(std::vector<std::string> &palindrome) {
    bool retCode = true;
    int counter = 0;

    for (int i = 0; i < palindrome.size(); ++i) {
        for (int j = 0; j < palindrome.at(i).size() / 2; ++j) {
            if (palindrome.at(i)[j] == palindrome.at(i)[(palindrome.at(i).size()-1)-j]) {
                ++counter;
            }
        }
        
        if (counter > palindrome.at(i).size() / 2 - 1) {
            std::cout << "Line " << i+1 << " contains a palindrome." << std::endl;
        }
        else {
            std::cout << "Line " << i+1 << " does not contain a palindrome." << std::endl;
        }
        
        counter = 0;
    }
    
    return retCode;
}
                

Lösung von: Matthias Sayler (Bosch)

import scala.collection.immutable.StringOps._
import scala.io.StdIn._
object Palindrom extends App {
println("Palindrom 2015 Scala")
var input = readLine()
var size = input.size
var ArrayInput = new Array[String](size)
var ArrayInputR = new Array[String](size)
var counter1 = 0
var counter2 = 0
ArrayInput = input.split("")
ArrayInputR = input.split("")

//ArrayInput alle buchstaben klein machen
while(counter1 != size){
  ArrayInput(counter1) = ArrayInput(counter1).toLowerCase()
  counter1 = counter1 + 1
}
//ArrayInputr alle buchstaben klein machen
while(counter2 != size){
  ArrayInputR(counter2) = ArrayInputR(counter2).toLowerCase()
  counter2 = counter2 + 1
}
//ArrayInputr umsotieren
ArrayInputR = ArrayInput.reverse

//Array Vergleichen
if(ArrayInput.deep == ArrayInputR.deep){
  println(input + " ist ein Palindrom")
}
else{
  println(input + " ist kein Palindrom")
}
}


                

Lösung von: Name nicht veröffentlicht

wort = str(input("Wort eingeben: ").lower())
wort_reverse = wort[::-1]
if wort == wort_reverse:
    print("Das Wort ", wort, "ist ein Palindrom")
else:
    print ("Das Wort ", wort, "ist kein Palindrom")
                

Lösung von: Py Thon ()

#include <stdio.h>
#include <ctype.h>

void checkPalindrom(char* str) {
	char *strIn = str, *strOut = str, c;
	printf("\"%s\"", str);
	while (c = *strIn++) {
		if (isalpha(c))
			*strOut++ = toupper(c);
	}
	*strOut = 0;
	while (*str) {
		if (*str++ != *(--strOut)) {
			printf(" -> Paliodrome false\n");
			return;
		}
	}
	printf(" -> Paliodrome true\n");
}

int main() {
	checkPalindrom("Linux, super, hier Gnu.");
	checkPalindrom("Reihung, oho, Gnu hier!");
	checkPalindrom("Reit amal a Lamatier.");
	checkPalindrom("Sugus - AHA! Sugus.");
	checkPalindrom("Reihungen, nenne Gnu hier!");
	checkPalindrom("Leben Sie mit im Eisnebel!");
	checkPalindrom("Reihung lief stets feil. Gnu hier.");
	checkPalindrom("Ein Lama mal' nie.");
	return 0;
}

                

Lösung von: Martin Boekhoff (PTScientists)

#!/usr/bin/python3
from sys import stdin ; import re
def p(s):
        a,b=re.findall('[a-zA-Z]',s),[]
        for i in a: b.append(i) if i.islower() else b.append(i.lower())
        a=''.join(b)
        if a==a[::-1]: return True
        return False
for s in stdin:
        print(p(s))

                

Lösung von: rob ert (tub)

$s1 = "Reihung, oho, Gnu hier!";
$s2 = "Reit amal a Lamatier.";
$s3 = "Sugus - AHA! Sugus.";
$s4 = "Reihungen, nenne Gnu hier!";
$s5 = "Leben Sie mit im Eisnebel!";
$s6 = "Reihung lief stets feil. Gnu hier.";
$s7 = "Ein Lama mal' nie.";





$s11 = strtolower(preg_replace("/[^0-9a-zA-Z]/","",$s1));
$s12 = strtolower(preg_replace("/[^0-9a-zA-Z]/","",$s2));
$s13 = strtolower(preg_replace("/[^0-9a-zA-Z]/","",$s3));
$s14 = strtolower(preg_replace("/[^0-9a-zA-Z]/","",$s4));
$s15 = strtolower(preg_replace("/[^0-9a-zA-Z]/","",$s5));
$s16 = strtolower(preg_replace("/[^0-9a-zA-Z]/","",$s6));
$s17 = strtolower(preg_replace("/[^0-9a-zA-Z]/","",$s7));

echo $s11;
echo "<br>";
echo $s12;
echo "<br>";
echo $s13;
echo "<br>";
echo $s14;
echo "<br>";
echo $s15;
echo "<br>";
echo $s16;
echo "<br>";
echo $s17;

                

Lösung von: Maik Scheiermann (Powercloud GmbH)

import re
print("Ist Palindrom") if [a.lower() for a in re.findall("[A-Za-z]",string)]==[a.lower() for a in re.findall("[A-Za-z]",string)][::-1] else print("Kein Palindrom")
                

Lösung von: rob ert (tub)

function isPalindrome(str) {
  str = str.toLowerCase().replace(/[^a-z]/g, '');
  return str == str.split('').reverse().join('');
}

// ausgabe
let sentences = [
  'Linux, super, hier Gnu.',
  'Reihung, oho, Gnu hier!',
  'Reit amal a Lamatier.',
  'Sugus - AHA! Sugus.',
  'Reihungen, nenne Gnu hier!',
  'Leben Sie mit im Eisnebel!',
  'Reihung lief stets feil. Gnu hier.',
  "Ein Lama mal' nie."
];

for (let i in sentences)
  console.log(`${sentences[i]} (${isPalindrome(sentences[i])})`);
                                                             // lissalanda@gmx.at
                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

// NET Core 3.x

using System;
using System.Linq;
using System.Text.RegularExpressions;

namespace CS_Aufgabe_Palindrome
{
    class Program
    {
        static void Main(string[] args)
        {
            const string Palindrom = "Reihung, oho, Gnu hier!";
            Console.WriteLine(IsPalindrom(Palindrom));

            static bool IsPalindrom(string palindrom)
            {
                var arrPal = new Regex(@"[^a-z]").Replace(palindrom.ToLower(), "").ToCharArray();
                return arrPal.SequenceEqual(arrPal.Reverse());
            }
        }
    }
}
                

Lösung von: Jens Kelm (@JKooP)

Verifikation/Checksumme:

Einzig die erste Zeile ist kein Palindrom.

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 2
Schwierigkeit: k.A.
Webcode: brfr-qbyf
Autor: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen