Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Lefelsprache (Zeichenketten)

Vielleicht habt ihr schon mal von der Lefelsprache gehört

Dielefie gelefeht ulefungelefefälefähr solefo. (Die geht ungefähr so.)

Aufgabe ist nun eine Funktion zu schreiben, die eine Zeichenkette entgegennimmt und diese in die Lefelsprache übersetzt zurückgibt.

So funktioniert die Lefelsprache:

Alle vokale werden durch «vokal + 'lef' + vokal» ersetzt.

Beachtet: 

  • Fängt ein Wort mit einem großgeschrieben Vokal an, muss der folgende Vokal kleingeschrieben werden!

Zusatz:

  • Umlaute und Doppellaute (ie, au, äu, ...) können wie ein einzelner Vokal behandelt werden.

ein kleiner Tipp : regexp ist gut geeignet um diese Aufgabe zu lösen, allerdings ist es natürlich auch erlaubt mit Schleifen zu arbeiten. Es wäre toll zu beidem eine Lösung zu bekommen.

0 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

9 Lösung(en)

VOWELS = 'aeiouAEIOU'

def lefel(str):
    str = list(str)
    c = 0
    for char in str:
        if char in VOWELS:
            str.insert(c, char + 'lef' + char.lower())
            del(str[c+1])
        c += 1
    str = ''.join(char for char in str)
    return str
                

Lösung von: Bester Mensch (Class)

public class Lefelsprache {

	private static char[] vokale = { 'a', 'ä', 'e', 'i', 'o', 'ö', 'u', 'ü' };
	private static String[] replace = { "Au", "AU", "aU", "au", "Ei", "EI", "eI", "ei", "Ie", "IE", "iE", "ie" };
	private static Scanner sc = new Scanner(System.in);

	public static void main(String[] args) {
		String text = getText();
		StringBuilder output = new StringBuilder();

		for (int i = 0; i < text.toCharArray().length; i++) {
			boolean cont = false;

			for (String s : replace) {
				if (i != text.toCharArray().length - 1) {
					if (s.toCharArray()[0] == text.charAt(i) && s.toCharArray()[1] == text.charAt(i + 1)) {
						output.append(s + "lef" + s.toLowerCase());
						cont = true;
						i++;
					}
				}
			}

			if (!cont) {
				output.append(text.charAt(i));

				for (char d : vokale) {
					if (Character.toLowerCase(text.charAt(i)) == d) {
						output.append("lef" + Character.toLowerCase(text.charAt(i)));
						break;
					}
				}
			}
		}

		System.out.println(output.toString());
	}

	private static String getText() {
		System.out.print("Text eingeben: ");
		String text = sc.nextLine();
		sc.close();
		return text;
	}
}
                

Lösung von: Name nicht veröffentlicht

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

int is_vocal(char c) {
    c = tolower(c);
    return (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') ? 1 : 0;
}

char *lefel(char *str) {
    char* result;
    int i, j, len;
    for(i = 0, len = 0; str[i] != '\0'; i++) {
        len++;
        if (is_vocal(str[i])) {
            len+=4;
        }
    }
    result = malloc(sizeof(char) * len);
    for(i = 0, j = 0; str[i] != '\0'; i++) {
        result[j++] = str[i];
        if (is_vocal(str[i])) {
            result[j++] = 'l';
            result[j++] = 'e';
            result[j++] = 'f';
            result[j++] = tolower(str[i]);
        }
    }
    result[j++] = '\0';
    return result;
}
                

Lösung von: Rainer Winkler (Alterschauerberger Universität Fachbereich Drachologie)

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Lefel
{
	public static void main(String[] args)
	{
		Scanner scan = new Scanner(System.in);
		
		System.out.println("Geben Sie einen in Lefelsprache zu übersetzenden Text ein!");
		System.out.println(lefel(scan.nextLine()));
		
		scan.close();
	}
	
	public static String lefel(String plaintext)
	{
		char actualcipher;
		String lefeledCipher = "";
		StringBuilder lefeledText = new StringBuilder();
		
		for(int i = 0; i < plaintext.length(); i++)
		{
			actualcipher = plaintext.charAt(i);
			switch(actualcipher)
			{
			case 'a':
			case 'e':
			case 'i':
			case 'o':
			case 'u': lefeledCipher = actualcipher + "lef" + actualcipher; break;
			
			case 'A':
			case 'E':
			case 'I':
			case 'O':
			case 'U': lefeledCipher = actualcipher + "lef" + (char)(actualcipher+32); break;
				
			default: lefeledCipher = String.valueOf(actualcipher); break;
			}
			
			lefeledText.append(lefeledCipher);
			
		}		
		
		return new String(lefeledText);
	}

}
                

Lösung von: Name nicht veröffentlicht

private static char[] vokale = { 'a', 'ä', 'e', 'i', 'o', 'ö', 'u', 'ü' };
        static void Main(string[] args)
        {
            string input = "Die geht ungefähr so";
            string output = "";

            foreach(char c in input)
            {
                output += c;
                foreach (char v in vokale)
                {
                    if (c == v)
                    {
                        output += "lef" + c;
                    }
                }
            }

            Console.WriteLine(output);
        }
                

Lösung von: Name nicht veröffentlicht

lefel = lambda str : ''.join([a+'lef'+a  if a in ['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'] else a  for a in str])

                

Lösung von: rob ert (tub)

String.prototype.toLefel = function() {
  let out = '',
      i = 0;

  function isVowel(s) { return 'AaÄäEeIiOoÖöUuÜü'.includes(s); }

  while(i < this.length) {
    if (isVowel(this[i])) {
      let tmp = this[i];
      // bigrafen
      while (isVowel(this[i+1])) {
        i++;
        tmp += this[i];
      }
      out += tmp + 'lef' + tmp.toLowerCase();
    } else out += this[i];
    i++;
  }
  return out;
}

// ausgabe
console.log('Das ist die Lefelsprache.'.toLefel());
console.log('Ich bin zu Hause.'.toLefel());
console.log('Ein Eimer am Abgrund!'.toLefel());

                

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

// NET Core 3.x; C# 8.x

using System;
using System.Text.RegularExpressions;

namespace CS_Aufgabe_Lefelsprache
{
    class Program
    {
        static void Main(string[] args)
        {
            var txt = "Die geht ungefähr so.";
            Console.WriteLine(new Regex(@"au|äu|ei|eu|ie|[AÄEIOÖUÜaäeioöuü]")
                .Replace(txt, x => x + "lef" + x.ToString().ToLower()));
        }
    }
}
                

Lösung von: Jens Kelm (@JKooP)

// C++ 20 | VS-2022
#include <iostream>
#include <boost/regex.hpp>
#include <boost/algorithm/string.hpp>
using namespace boost;

auto main() -> int{
    const auto get_secret_language{ [](const std::string& str) {
        return regex_replace(str, regex("au|äu|ei|eu|ie|[AÄEIOÖUÜaäeioöuü]"),
            [](auto i) {return i.str() + "lef" + to_lower_copy(i.str()); }); } };

    const std::string txt{ "Ich bin zu Hause" };
    std::cout << get_secret_language(txt) << "\n";
}
                

Lösung von: Jens Kelm (@JKooP)

Verifikation/Checksumme:

"Das ist die Lefelsprache" --> "Dalefas ilefist dielefie lelefefelefelspralefachelefe"

"Ich bin zu Hause" --> "Ilefich bilefin zulefu Haulefauselefe"

"ein Eimer am Abgrund" --> "eilefein Eilefeimelefer alefam Alefabgrulefund"

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 1
Schwierigkeit: Leicht
Webcode: 03w7-wetg
Autor: ()

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen