Programmieren lernen

# 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)

// C++ 14 | VS-2022
#include <iostream>
#include <vector>

bool is_palindrom(const std::string& str) {
    std::string cls{};
    for (const auto& s : str)
        if (isalpha(s)) cls.push_back(toupper(s));
    for (auto i{ 0 }; i < cls.length() / 2; i++)
        if (cls[i] != cls[cls.length() - i - 1])
            return false;
    return true;
}

int main() {
    const std::vector<std::string>palindromes{
        "Linux, super, hier Gnu.", "Reihung, oho, Gnu hier!",
        "Reihung lief stets feil. Gnu hier.", "Sugus - AHA! Sugus.", 
        "Reihungen, nenne Gnu hier!", "Leben Sie mit im Eisnebel!",
        "Reihung lief stets feil.Gnu hier.", "Ein Lama mal' nie."
    };

    for(const auto& pd : palindromes)
        std::cout << pd << " -> " << (is_palindrom(pd) ? "wahr" : "falsch") << "\n";
}
                

Lösung von: Jens Kelm (@JKooP)

// NET 8.x | C# 12.x | VS-2022

List<string> lst = [
    "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?" ];

lst.ForEach(x => Console.WriteLine($"{x} -> {IsPalindrome(x)}"));

static bool IsPalindrome(string str_) {
    var arr = str_.ToUpper().Where(char.IsAsciiLetter);
    return arr.SequenceEqual(arr.Reverse());
}
                

Lösung von: Jens Kelm (@JKooP)