Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Wortliste filtern (Zeichenketten)

Für die Erstellung eines Lernprogramms zum Maschinenschreiben werden geeignete Wörter aus einer Wortliste herausgepickt. Dafür wird die folgende Funktion benötigt:

passt(wort: string, darf: string, muss: string): boolean

Dabei dürfen im String wort nur Buchstaben vorkommen, die auch im String darf enthalten sind. Jedoch muss der String wort alle Buchstaben enthalten, welche im String muss vorkommen. Beispiele:

passt("apfelsaft", "asdfghjklö", "as") // liefert false: p nicht ok
passt("sdd",       "asdfghjklö", "as") // liefert false: a fehlt
passt("saft",      "asdfghjklö", "as") // liefert false: t nicht ok
passt("lasag",     "asdfghjklö", "as") // liefert true

Überlegen Sie, inwiefern die Hilfsfunktion

muss(wort: string, mussMenge: string): boolean

von Nutzen sein kann. Hierbei werden Wörter nur akzeptiert, wenn jeder Buchstabe aus der mussMenge auch wirklich vorkommt.

Zusatzaufgabe: Laden Sie die Wortliste herunter. Suchen Sie nun alle Wörter, bei welchen die Buchstaben "g" und "o" vorkommen müssen und zusätzlich nur Buchstaben aus "aeinrst" enthalten sein dürfen (s. www.freimann.eu/eliphi/phi/keyboard/).

Dateien:

0 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

5 Lösung(en)

public class WortlisteFiltern {

    /**
     * Test "passt"-Methode
     */
    public static void main(String[] args) {
        WortlisteFiltern sf = new WortlisteFiltern();
        System.out.println("wuala, wual, a -> " + sf.passt("wuala", "wual", "a")); }
    
    /**
     * Alle Buchstaben aus "wort" müssen in "darf" vorkommen.
     * Alle Buchstaben aus "muss" müssen im "wort" vorkommen.
     */
    boolean passt(String wort, String darf, String muss) {
        return muss(wort, muss) && muss(darf, wort); 
    }

    /**
     *  Alle Buchstaben aus "muss" müssen im "wort" vorkommen.
     */
    boolean muss(String wort, String mussMenge) {
        for(char c : mussMenge.toCharArray()) {
            if(wort.indexOf(c) < 0) {
                return false;  }
        }
        return true; }

} // end of class WortlisteFiltern
                
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
Wortliste filtern
https://www.programmieraufgaben.ch/aufgabe/wortliste-filtern/pomdoige
"""

# Programmieraufgabe:
#     Für die Erstellung eines Lernprogramms zum Maschinenschreiben werden
#     geeignete Wörter aus einer Wortliste herausgepickt. Dafür wird die folgende
#     Funktion benötigt:
#         passt(wort: string, darf: string, muss: string): boolean
#     Dabei dürfen im String wort nur Buchstaben vorkommen, die auch im String
#     darf enthalten sind. Jedoch muss der String wort alle Buchstaben enthalten,
#     welche im String muss vorkommen. Beispiele:
#         passt("apfelsaft", "asdfghjklö", "as") // liefert false: p nicht ok
#         passt("sdd",       "asdfghjklö", "as") // liefert false: a fehlt
#         passt("saft",      "asdfghjklö", "as") // liefert false: t nicht ok
#         passt("lasag",     "asdfghjklö", "as") // liefert true
#
# Autor, Erstellung:
#     Ulrich Berntien, 2018-07-03
#
# Sprache:
#     Python 3.6.6


import sys
import zipfile
from typing import *


def passt(wort: str, darf: str, muss: str) -> bool:
    """
    Prüft die Buchstaben in einem Wort.
    Der Vergleich erfolgt größenunabhängig (z.B. ist a==A).
    :param wort: Die Buchstaben in diesem Wort werden geprüft.
    :param darf: Nur diese Buchstaben un die Buchstaben in 'muss' dürfen enthalten sein.
    :param muss: Jeder dieser Buchstaben muss im Wort enthalten sein.
    :return: True genau dann wenn, die beiden Bedingungen erfüllt sind.
    """
    # die lower case Versionen der Strings vergleichem.
    wort_klein = wort.lower()
    muss_klein = muss.lower()
    darf_vollstaendig = darf.lower() + muss
    return all(c in darf_vollstaendig for c in wort_klein) and all(c in wort_klein for c in muss_klein)


def filter_file(quelle: Iterable[str], darf: str, muss: str) -> int:
    """
    Filtert die Wort liste aus einer Datei. In einer Zeile müssen die Wörter durch Leerzeichen getrennt sein.
    :param quelle: Die Quelle der Wörter.
    :param darf: Nur diese Buchstaben un die Buchstaben in 'muss' dürfen enthalten sein.
    :param muss: Jeder dieser Buchstaben muss im Wort enthalten sein.
    :return: Die Anzahl der passenden Wörter.
    """
    zaehler = 0
    for line in quelle:
        if isinstance(line, bytes):
            # Byte string interpretieren, z.B. wenn aus run_zip gelesen wird.
            line = line.decode("utf-8")
        for wort in line.split():
            wort = wort.strip()
            if passt(wort, darf, muss):
                print(wort)
                zaehler += 1
    return zaehler


if __name__ == "__main__":
    # In der Aufgabe gegeben:
    darf = "aeinrst"
    muss = "go"
    if len(sys.argv) != 2:
        print("Das Skript muss mit einen Dateinamen als Parameter aufgerufen werden.")
    else:
        dateiname = sys.argv[1]
        anzahl = 0
        if dateiname.lower().endswith(".run_zip"):
            # Die Datei ist ein Zip-Archiv.
            with zipfile.ZipFile(dateiname) as archiv:
                # Alle Dateien im Zeip-Archiv werden durchsucht
                for datei in archiv.namelist():
                    with archiv.open(datei) as quelle:
                        anzahl += filter_file(quelle, darf, muss)
        else:
            with open(dateiname, mode="r") as quelle:
                anzahl = filter_file(quelle, darf, muss)
        print("Anzahl Wörter:", anzahl)
                

Lösung von: Ulrich Berntien ()

// NET 6.x | C# 10.x | VS-2022

new List<WDM> {
    new WDM("apfelsaft", "asdfghjklö", "as"),
    new WDM("sdd", "asdfghjklö", "as"),
    new WDM("saft", "asdfghjklö", "as"),
    new WDM("lasag", "asdfghjklö", "as"),
    new WDM("xyz", "adfghjklö", "as")
}.ForEach(x => Check(x));

static void Check(WDM wdm) {
    var darf = wdm.Wort.Except(wdm.Darf).ToList();
    var muss = wdm.Muss.Except(wdm.Wort).ToList();
    var korrekt = !darf.Any() && !muss.Any();

    Console.Write($"korrekt: {korrekt}");
    if (darf.Any()) Console.Write($" -> 'darf' [ {darf[0]} ]  ");
    if (muss.Any()) Console.Write($" -> 'muss' [ {muss[0]} ]");
    Console.WriteLine();
}
record struct WDM (string Wort, string Darf, string Muss);
                

Lösung von: Jens Kelm (@JKooP)

String.prototype.fits = function(must, may) {
  must = must.toUpperCase();
  may = may.toUpperCase() + must;
  let word = this.toUpperCase(), i;
  for (i = 0; i < must.length; i++)
    if (word.indexOf(must[i]) == -1) return false;
  for (i = 0; i < word.length; i++)
    if (may.indexOf(word[i]) == -1) return false;
  return true;
}

// test
console.log( 'apfelsaft'.fits('as', 'asdfghjklö') );
console.log( 'sdd'.fits('as', 'asdfghjklö') );
console.log( 'saft'.fits('as', 'asdfghjklö') );
console.log( 'lasag'.fits('as', 'asdfghjklö') );

/* der einfachheit halber, und um die codelänge hier nicht unnötig
   explodieren zu lassen, wurde die wortliste zuvor editiert, im
   html-dokument geladen und liegt als array $dictionary vor */
let result = dictionary.filter(
  function(w) { return w.fits('go', 'aeinrst'); }
);

document.write(result.join(', '));
document.write(`<br>(${result.length} Wörter)`);
                

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

// C++20 | VS-2022

#include <iostream>
#include <vector>
#include <algorithm>
#include <format>

struct wmm {
    std::string word;
    std::string may;
    std::string must;
};

static const std::tuple<bool, char> is_unique_lhs(const std::string& lhs_, const std::string& rhs_) {
    for (const auto& c : lhs_)
        if (rhs_.find(c) == std::string::npos)
            return { true, c };
    return { false, '\0' };
}

static const auto check_wmm(wmm wmm_) {
    const auto& [may, may_char]{ is_unique_lhs(wmm_.word, wmm_.may) };
    const auto& [must, must_char]{ is_unique_lhs(wmm_.must, wmm_.word) };
    const auto correct{ !may && !must };
    std::cout << std::format("korrekt: {}\n", correct);
    if (may) std::cout << std::format("darf: {}\n", may_char);
    if (must) std::cout << std::format("muss: {}\n", must_char);
}

int main() {
    const std::vector<wmm>v_wmm {
        {"apfelsaft", "asdfghjklö", "as"},
        {"sdd", "asdfghjklö", "as"},
        {"saft", "asdfghjklö", "as"},
        {"lasag", "asdfghjklö", "as"}
    };

    for (const auto& e : v_wmm)
        check_wmm(e);
}
                

Lösung von: Jens Kelm (@JKooP)

Verifikation/Checksumme:

Verifikation zur Zusatzaufgabe: Es werden 664 Wörter gefunden:

aerogen
Agarose
Agentenorganisation
Agentenstories
Aggregation

...

Trigon
Trigonitis
Tritagonist
trog
TROGE
TROGEN
Trogon
Trossingen

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 0.5
Schwierigkeit: Mittel
Webcode: pomd-oige
Autor: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen