Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Wortweise Umkehren (Zeichenketten)

In einem Text soll jedes Wort einzeln umgekehrt werden. Es wird also nicht der ganze Text umgedreht, sondern lediglich jedes Wort für sich. Beispiel:

"Lamatier: reite!"

wird zu

"reitamaL: etier!"

Zusatzaufgabe: Schütteln Sie die Wörter nach dem folgenden Verfahren:

Bei Kurzwörtern mit weniger als 4 Buchstaben geschieht nichts, diese werden unverändert ausgegeben. Bei längeren Wörtern (ab 4 Buchstaben) werden die mittleren Buchstaben gemischt. Der erste und der letzte Buchstabe bleiben jedoch am Ort. Überprüfen Sie die Lesbarkeit der neuen Texte.

3 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

Kommentare (3)

Martin Guggisberg 9. Juni 2011 12:55   reply report
hanspi
Das "u" beim Aufruf der Funktion war wohl nötig in Python 2.x, um die zurückgegebene String in utf-8 zu codieren (oder?), ist aber in Python3 nicht mehr nötig, da das Objekt str in Python3 immer utf-8-formatiert ist.
Umgekehrt kann man str-Objekte in Bytes "umcodieren", wenn man ihnen ein führendes b beigibt.
z.B.:
'abc' ist eine utf-8-String vom Typ str,
b'abc' ist ein Objekt vom Typ bytes.

Lieber Hanspi
Vielen Dank für deine Bemerkung, wir haben meistens Python 2.x verwendet. Wie du bemerkst ist das u bei Python 3.x nicht nötig.
Gruss Martin
hanspi 6. Mai 2011 12:18   reply report
Das "u" beim Aufruf der Funktion war wohl nötig in Python 2.x, um die zurückgegebene String in utf-8 zu codieren (oder?), ist aber in Python3 nicht mehr nötig, da das Objekt str in Python3 immer utf-8-formatiert ist.
Umgekehrt kann man str-Objekte in Bytes "umcodieren", wenn man ihnen ein führendes b beigibt.
z.B.:
'abc' ist eine utf-8-String vom Typ str,
b'abc' ist ein Objekt vom Typ bytes.
hanspi 5. Mai 2011 16:43   reply report
In der Python-Lösung scheint sich ein kleiner Fehler eingeschlichen zu haben:
Beim Aufruf der Funktion wortumkehr(s) wird ein erster Parameter 'u' übergeben, mit dem die Funktion natürlich nicht funktioniert.

6 Lösung(en)

def wortumkehr(s):   
   l=s.split()
   s2=''
   for wort in l:
      s2=s2+' '+wort[::-1]
   print s2

wortumkehr(u'Hallöchen : welt :')
                
/**
 * Wortweise umkehren (ohne Verwendung von "reverse").
 * @author Philipp Gressly (phi AT gressly DOT ch)
 */
public class WortweiseUmkehren {
  public static void main(String[] args) {
    new WortweiseUmkehren().top();
  }
  
  String original;
  void top(){
    original = "Lamatier: reite!";
    System.out.println(wortweiseUmkehren());
  }
  
  String wortweiseUmkehren() {
    String resultat = "";
    int pos = 0;
    while(pos < original.length()) {
      int anfang = wortanfang(pos);
      if(anfang < 0) { // fertig
        return resultat + teilstring(pos, original.length() - 1);
      }
      if(anfang > pos) {
        resultat = resultat + teilstring(pos, anfang - 1);
      }
      int ende   = wortende(anfang);
      String wort = teilstring(anfang, ende);
      resultat = resultat + wortUmkehr(wort);
          
      pos = ende + 1;
    }
    return resultat;
  }
  
  String wortUmkehr(String wort) {
    String umkehr = "";
    int pos = 0;
    while(pos < wort.length()) {
        int umkehrPosition = wort.length() - pos - 1;
        umkehr = umkehr + wort.charAt(umkehrPosition);
        pos = pos + 1;
    }
    return umkehr;
  }

  /**
   * Suche letzten Buchstaben im Wort (ab "anfang").
   * Voraussetzung: "anfang" zeigt auf einen Buchstaben in "original"
   */
  int wortende(int anfang) {
    int ende = anfang;
    // solange "hat noch weitere Zeichen" UND "nächstes ist Buchstabe":
    while(ende + 1 <= original.length() - 1 &&
      istBuchstabe(original.charAt(ende + 1))) {
      ende = ende + 1;
    }
    return ende;
  }

  String teilstring(int pos, int end) {
    return original.substring(pos, end + 1);
  }

  /**
   * Liefert die Position des nächsten Buchstabens ab "pos"
   * Wenn "pos" bereits auf einen Buchstaben zeigt, wird
   * "pos" wieder zurückgegegben.
   * Wenn kein Buchstabe mehr vorkommt (ab "pos"), wird -1 zurückgegeben.
   */
  int wortanfang(int pos) {
    char zeichen = original.charAt(pos);
    while(! istBuchstabe(zeichen)) {
      pos = pos + 1;
      if(pos >= original.length()) {
        return - 1;
      }
      zeichen = original.charAt(pos);
    }
    return pos;
  }
  
  boolean istBuchstabe(char c) {
    return Character.isLetter(c);
  }
  
} // end of class WortweiseUmkehren
                
/**
 * Wortweise mischen.
 * Ganze Sätze werden wie folgt gemischt: 
 * Die ersten und die letzten Buchstaben in den Wörtern bleiben
 * jeweils erhalten. Ebenso die Satz- und Sonderzeichen.
 * Innerhalb der Wörter werden die Buchstaben jedoch wild gemischt.
 * @author Philipp Gressly (phi AT gressly DOT ch)
 */
public class WortweiseMixen {
  public static void main(String[] args) {
    new WortweiseMixen().top();
  }
  
  String original;
  void top(){
    original = "Dies ist ein einfacher Satz. Versuche trotzdem es zu lesen.";
    System.out.println(wortweiseMixen());
  }
  
  String wortweiseMixen() {
    String resultat = "";
    int pos = 0;
    while(pos < original.length()) {
      int anfang = wortanfang(pos);
      if(anfang < 0) { // fertig
        return resultat + teilstring(pos, original.length() - 1);
      }
      if(anfang > pos) {
        resultat = resultat + teilstring(pos, anfang - 1);
      }
      int ende   = wortende(anfang);
      String wort = teilstring(anfang, ende);
      resultat = resultat + teilwortMix(wort);
          
      pos = ende + 1;
    }
    return resultat;
  }
  
  String teilwortMix(String wort) {
    if(wort.length() < 3) {
        return wort;
    }
    String teilWort = wort.substring(1, wort.length() - 1);
    String mixWort = mixWort(teilWort);
   
    return wort.charAt(0) + mixWort + wort.charAt(wort.length() - 1);
  }

 /**
  * Mische ein Wort
  * @return
  */
  String mixWort(String wort) {
    char[] arr = wort.toCharArray();
    int pos = wort.length() - 1;
    while(pos > 0) {
       int zufall = zufall(0, pos);
       tausche(pos, zufall, arr);
       pos = pos - 1;
    }
    return new String(arr);
  }

  void tausche(int a, int b, char[] arr) {
     if(a == b) { return ; }
     char temp = arr[a];
     arr[a]    = arr[b];
     arr[b]    = temp;
  }

  int zufall(int min, int max) {
    return (int) (Math.random() * (max - min + 1)) + min;
  }

/**
   * Suche letzten Buchstaben im Wort (ab "anfang").
   * Voraussetzung: "anfang" zeigt auf einen Buchstaben in "original"
   */
  int wortende(int anfang) {
    int ende = anfang;
    // solange "hat noch weitere Zeichen" UND "nächstes ist Buchstabe":
    while(ende + 1 <= original.length() - 1 &&
      istBuchstabe(original.charAt(ende + 1))) {
      ende = ende + 1;
    }
    return ende;
  }

  String teilstring(int pos, int end) {
    return original.substring(pos, end + 1);
  }

  /**
   * Liefert die Position des nächsten Buchstabens ab "pos"
   * Wenn "pos" bereits auf einen Buchstaben zeigt, wird
   * "pos" wieder zurückgegegben.
   * Wenn kein Buchstabe mehr vorkommt (ab "pos"), wird -1 zurückgegeben.
   */
  int wortanfang(int pos) {
    char zeichen = original.charAt(pos);
    while(! istBuchstabe(zeichen)) {
      pos = pos + 1;
      if(pos >= original.length()) {
        return - 1;
      }
      zeichen = original.charAt(pos);
    }
    return pos;
  }
  
  boolean istBuchstabe(char c) {
    return Character.isLetter(c);
  }
  
} // end of class WortweiseMixen
                
String.prototype.reverseWords = function() {
  let str = this,
      punctuation = '!"()?:,.',
      keepCaps = [],
      left, right;
  // stellen der großbuchstaben aufzeichnen
  for (let i = 0; i < str.length; i++)
    keepCaps.push(str[i] == str[i].toUpperCase());
  // str mit leerzeichen in einzelteile zerlegen
  str = str.toLowerCase().split(' ');
  for (i = 0; i < str.length; i++) {
    let word = str[i];
    // satzzeichen ignorieren
    left = 0; right = word.length-1;
    while (word[left].indexOf(punctuation) != -1) left++;
    while (word[right].indexOf(punctuation) != -1) right--;
    let core = word.substring(left, right);
    // umkehren und einsetzen
    core = core.split('').reverse().join('');
    str[i] = word.substring(0, left) + core + word.substring(right);
  }
  // wieder zusammensetzen
  str = str.join(' ');
  // großbuchstaben wieder herstellen
  let out = '';
  for (i = 0; i < str.length; i++) {
    if (keepCaps[i]) out += str[i].toUpperCase();
    else out += str[i];
  }
  return out;
}

// nach fast demselben prinzip:
String.prototype.shuffleWordsWithin = function() {
  let str = this,
  punctuation = '!"()?:,.',
  keepCaps = [],
  left, right;
  // schüttel-algorithmus
  function shuffle(s) {
    s = s.split('');
    let out = [];
    while (s.length > 0) {
      out.push(s.splice(Math.floor(Math.random() * s.length), 1));
    }
    return out.join('');
  }
  // stellen der großbuchstaben aufzeichnen
  for (let i = 0; i < str.length; i++)
    keepCaps.push(str[i] == str[i].toUpperCase());
  // str mit leerzeichen in einzelteile zerlegen
  str = str.toLowerCase().split(' ');
  for (i = 0; i < str.length; i++) {
    let word = str[i];
    if (word.length > 4) {
      // satzzeichen ignorieren
      left = 0; right = word.length-1;
      while (word[left].indexOf(punctuation) != -1) left++;
      while (word[right].indexOf(punctuation) != -1) right--;
      left++; right--;   // anfangs- und endbuchstaben erhalten
      let core = word.substring(left, right);
      // schütteln und einsetzen
      core = shuffle(core);
      str[i] = word.substring(0, left) + core + word.substring(right);
    }
  }
  // wieder zusammensetzen
  str = str.join(' ');
  // großbuchstaben wieder herstellen
  let out = '';
  for (i = 0; i < str.length; i++) {
    if (keepCaps[i]) out += str[i].toUpperCase();
    else out += str[i];
  }
  return out;
}

let str = 'Lamatier: reite!';
console.log(str.reverseWords());

str = 'Wörter mit geschüttelten Innenbuchstaben bleiben meist recht gut lesbar.';
console.log(str.shuffleWordsWithin());                       // lissalanda@gmx.at
                

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

// NET Core 3.x
// Hier eine Variante ohne Satzzeichen:

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

namespace CS_Aufgabe_Text_Rueckwaerts
{
    class Program
    {
        static void Main(string[] args)
        {
            const string txt = "Das hier ist ein: Testaufruf!";
            var sb = new StringBuilder();

            foreach (var i in new Regex(@"\s").Split(new Regex(@"[\:\.\!\?]").Replace(txt, "")))
            {
                sb.Append(i.Length > 4 ?
                    string.Concat(i[0], string.Join("", i[1..^1]
                        .ToCharArray().OrderBy(x => Guid.NewGuid())), i[^1], " ") :
                    string.Concat(i, " "));
            }
            Console.WriteLine(string.Join("", sb.ToString().ToCharArray().Reverse())[1..]);
        }
    }
}
                

Lösung von: Jens Kelm (@JKooP)

def reverse_words(s):
    words, temp = [], ""
    
    for char in s:
        if char.isalpha():
            temp += char
        else:
            words.extend([temp[::-1], char])
            temp = ""
    
    return "".join(words + [temp[::-1]])

def mix_inner(s):
    import random
    words, temp = [], ""
    
    def mix(temp):
        if len(temp) >= 4:
            inner = list(temp[1:-1])
            return [temp[0]]+random.sample(inner, len(inner))+[temp[-1]]
        else:
            return [temp]
    
    for char in s:
        if char.isalpha():
            temp += char
        else:
            words.extend(mix(temp) + [char])
            temp = ""
    
    return "".join(words + mix(temp))

print(reverse_words('"Lamatier: reite!"'))
print(mix_inner('"Lamatier: reite!"'))
                

Lösung von: Name nicht veröffentlicht

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 1
Schwierigkeit: k.A.
Webcode: q3bk-4ekq
Autor: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen