Programmieren lernen

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

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

constexpr size_t MIN_WORD_LENGTH{ 4 };
const std::string DELIMITER{ ".,:;!? '_" };

std::vector<std::string> get_split_string(const std::string& str) {
    const auto is_del{ [](auto c) {return DELIMITER.find(c) != std::string::npos; } };
    std::vector<std::string> out{};
    std::string wrd{}, chr{};
    for (const auto& c : str) {
        if (is_del(c)) {
            chr = c;
            out.push_back(wrd);
            wrd.clear();
            out.push_back(chr);
        }
        else wrd.push_back(c);
    }
    out.push_back(wrd);
    return out;
}

void shuffle_string(std::string& str) {
    if (str.length() < MIN_WORD_LENGTH) return;
    auto ctr{ str.substr(1, str.length() - 2) };
    shuffle(ctr.begin(), ctr.end(), std::random_device());
    const std::string fst{ str[0] };
    str = fst + ctr + str[str.length() - 1];
}

int main() {
    const std::string str{ "Lamatier: reite!" };
    auto s_str{ get_split_string(str) };
    for(auto& s : s_str) shuffle_string(s);
    for(const auto& s : s_str) std::cout << s;
}
                

Lösung von: Jens Kelm (@JKooP)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#define MIN_WORD_LENGTH 4
#define DELIMITER ".,:;!? '_"

int shuffle(char *array, size_t begin, size_t end) {
    if(array == NULL || end <= begin) return 1;
    size_t lhs;
    for (lhs = begin; lhs < end; ++lhs) {
        size_t rhs = lhs + rand() / (RAND_MAX / (end - lhs) + 1);
        size_t tmp = array[rhs];
        array[rhs] = array[lhs];
        array[lhs] = tmp;
    }
    return 0;
}

int shuffle_string(char *str, size_t size) {
    if (str == NULL) return 1;
    if (size < MIN_WORD_LENGTH) return 0;
    int test = shuffle(str, 1, size - 1);
    if(test == 1) return 1;
    return 0;
}

int main() {
    srand(time(NULL));
    char str[] = "Lamatier: reite!";
    char *tmp;
    tmp = strtok (str, DELIMITER);
    while (tmp != NULL) {
        int test = shuffle_string(tmp, strlen(tmp));
        if(test == 1) return 1;
        printf ("%s ", tmp);
        tmp = strtok (NULL, DELIMITER);
    }
    printf("\n");
    return 0;
}

                

Lösung von: Jens Kelm (@JKooP)