Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Upload Filter (Artikel 13) (Unterprogramme)

Schreiben Sie ein Programm, das in einem mehrzeiligen Text nach einem bestimmten Wort (z. B. "Koalitionsvertrag") sucht.

Als Vorgabe einer Function (Subroutine mit Rückgabewert) muss zwingend die folgende Funktionsdeklaration herhalten:

uploadFilter(zuFilternderText : String) : boolean;

Es wird true zurückgegeben, wenn der gesuchte Text (z. B. "Koalitionsvertrag") vorkommt und es wird false zurückgegeben, wenn der Text nicht vorkommt.

 

Zusatzaufgabe (leicht schwieriger): Schreiben Sie Ihren Upload-Filter um, sodass auch alle derben Wörter wie z. B. "Arsch" herausgefiltert werden; Achten Sie dabei aber darauf, dass a) Wörter wie "Primarschule" vom Filter nicht herausgefiltert werden und dass Sie b) wirklich alle derben Wörter erwischen (diese sind im Duden mit "derb" bezeichnet).

 

Bemerkung: Wie Sie sehen, hat auch "Programmieraufgaben.ch" nun einen funktionsfähigen Upload Filter!

0 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

5 Lösung(en)

Leichte Version:

public bool uploadFilter(string zuFilternderText)
{
     return zuFilternderText.Contains("Koalitionsvertrag");
}

Schwerere Version:

public bool uploadFilter(string zuFilternderText, string[] worter)
{
     foreach(string wort in worter)
     {
          if (zuFilternderText.Contains(wort))
              return true;
      }
      return false;
}
                

Lösung von: Name nicht veröffentlicht

/* Kotlin */
import java.lang.Exception
import java.lang.StringBuilder
import java.net.URL
import java.util.*

val regex = Regex("<span class=\"label\">Gebrauch:</span> <strong class=\"lexem\">(.*?)</strong>")

fun main() {
    val test = uploadFilterRoughWords("Der Koalitionsvertrag ist ein Arsch und Fettsack.")

    println(test.first)
    println(test.second)
}

fun uploadFilter(zuFilternderText: String) : Boolean {
    return zuFilternderText.contains("Koalitionsvertrag")
}

fun uploadFilterRoughWords(zuFilternderText: String) : Pair<Boolean, String> {
    val result = StringBuilder()
    val curr = StringBuilder()

    zuFilternderText.toCharArray().forEach {
        if(!it.isLetter()) {
            if (curr.isNotEmpty()) {
                val s = curr.toString()
                curr.setLength(0)

                if (!isWordRough(s.elementAt(0).toUpperCase() + s.substring(1, s.length))
                        && !isWordRough(s.elementAt(0).toLowerCase() + s.substring(1, s.length))) {
                    result.append(s)
                }
            }

            result.append(it)
        } else {
            curr.append(it)
        }
    }

    return Pair(uploadFilter(zuFilternderText), result.toString())
}

fun isWordRough(s: String): Boolean {
    return try {
        val scanner = Scanner(URL("https://www.duden.de/rechtschreibung/$s").openStream(), "UTF-8").useDelimiter("\\A").next()
        val matchResult = regex.find(scanner)

        matchResult != null && matchResult.groupValues[1].contains("derb")
    } catch (e: Exception) {
        return false
    }
}
                

Lösung von: Linus Götz (Lichtenberg-Gymnasium Cuxhaven)

package ch.programmieraufgaben.methoden;

import java.util.Scanner;

/**
 * Programmieraufgabe Upload-Filter (einfache Version)
 * https://programmieraufgaben.ch/aufgabe/upload-filter-artikel-13/xkmws55e
 * @version 0.1 (Apr 1, 2019)
 * @author Philipp Gressly Freimann 
 *         (philipp.gressly@santis.ch)
 */
public class UplaodFilter {

	public static void main(String[] args) {
		new UplaodFilter().top();
	}


	void top() {
		String eingabeTest = einlesenString("Bitte Text zur Prüfung eingeben");
		if(!uploadFilter(eingabeTest)) {
			System.out.println("Bravo: Ihr Text wurde nicht gefiltert.");
		} else {
			System.out.println("Sorry: Ihr Text hat auf unserer Website nichts verloren");
		}
	}


	boolean uploadFilter(String zuFilternderText) {
		return Math.random() < 0.95; // 95%
	}


	Scanner sc = new Scanner(System.in);
	String einlesenString(String frage) {
		System.out.println(frage);
		return sc.nextLine();
	}

}  // end of class UplaodFilter
                

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

package de.bloxx.Art13;

import java.util.ArrayList;
import java.util.Scanner;

public class Main {
	public static ArrayList<String> urh = new ArrayList<String>();//ArrayList wird erstellt
	public static void main(String[] args) {
		boolean b1 = true;//soll das Programm weiteraufen 
		while(b1) {//Solange b1 true ist läuft das Programm
			scann();//es wird gescannt
			@SuppressWarnings("resource")
			Scanner sc = new Scanner(System.in);//neuer Scanner
			System.out.println("Möchtest du den TextEditor verlassen? (j/n)");//abfrage ob man den editor verlassen möchte
			String s2 = sc.nextLine();
			if(s2.equals("j")) {//falls ja dann ist b1 false 
				System.out.println("Ok, Tschüss!");
				b1 = false;
			}else {//sonst nicht
				b1 = true;
			}
		}
	}
	private static void scann() {//Scann Methode
			@SuppressWarnings("resource")
			Scanner sc = new Scanner(System.in);//neuer Scanner
			System.out.println("Schreibe dein Werk:");
			String s = sc.next();//Geschriebenes wird abgerufen
			if(urh.contains(s)) {//scann, ob das Werk vorhanden ist
				System.out.println("Dieses Werk gibt es schon!");//falls ja
			}else if(!urh.contains(s)) {
				System.out.println("Das Werk " + s + " gibt es noch nicht :). Es wird in die Datenbank hinzugefügt!");//falls nein
				urh.add(s);//kommt in die ArrayList
			}
	}
}
//~BloxxDev
//fertig xD

                

Lösung von: Bloxx BLOOXX (Thg)

using System;
using System.Linq;

namespace Matching
{
    class Program
    {
        /// <summary>
        /// Ja ich weiß das Ergebnis sieht zwar recht lang aus, doch so sollte es ja auch sein. Eine Methode der Programmiersprache
        /// aufzurufen oder ein halbherziges Split vorzunehmen und ganze Wörter zu vergleichen stellt keinen Matching-Algorithmus dar.
        /// Daher hier eine ausführliche Antwort mit einer Mischung aus KMP und Boyer-Moore.
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            Console.WriteLine(match("Koalitionsvertrag", "Die Reform des EU-Urheberrechts könnte zu einer fehleranfälligen und grundrechtswidrigen Vorzensur führen. Mit ihrer Zustimmung 2019 bricht die Bundesregierung den Koalitionsvertrag von 2018."));
            Console.WriteLine(match("Koalitionsvertrag", "Die Reform des EU-Urheberrechts könnte zu einer fehleranfälligen und grundrechtswidrigen Vorzensur führen. Mit ihrer Zustimmung 2019 bricht die Bundesregierung keinerlei Verträge."));
            Console.Read();
        }

        /// <summary>
        /// Erstelle ein Jump Array, welches definiert wieviele Testwerte übersprungen werden dürfen bei einem Mismatch
        /// </summary>
        /// <param name="pattern"></param>
        /// <returns></returns>
        static int[] getJumpArray(string pattern)
        {
            int[] steps = new int[pattern.Length];

            for(int i = 0; i < pattern.Length; i++)
            {
                //Weise jeden Element einen Jumpwert zu
                steps[i] = pattern.Length - i;
                
            }

            return steps;
        }

        /// <summary>
        /// Mischung aus KMP Matching und Boyer-Moore. Es gibt ein Sprungarray, welches die Anzahl an überspringbaren Elemente
        /// angibt. Das Matching wird klassisch vom letzten Buchstaben des Patterns bis zum ersten durchgeführt
        /// </summary>
        /// <param name="pattern"></param>
        /// <param name="text"></param>
        /// <returns></returns>
        static bool match(string pattern, string text)
        {
            //Ermittlen des Jump Arrays
            int[] steps = getJumpArray(pattern);

            //Setzen der Startwerte
            int i = pattern.Length - 1;
            int mismatch = pattern.Length - 1;

            //Prüfe bis das Ende vom Text erreicht wurde
            while (i < text.Length)
            {
                //Prüfe ob der aktuelle Buchstabe matcht, wenn ja gehe zur vorherigen Stelle
                if (pattern[mismatch] == text[i])
                {
                    //Sollten alle Matches des Patterns erfolgreich gewesen sein, so gebe true zurück
                    if (mismatch == 0) return true;
                    mismatch--;
                    i--;
                }
                //Sollte ein Match fehlschlagen
                else
                {
                    //Erhöhung i: Prüfen ob der fehlerhafte Character im Pattern ist (falls nicht nutze default Wert)
                    i = pattern.Contains(text[i]) ? i + steps[mismatch] : i + steps[0];

                    //Setze das Matching zurück
                    mismatch = pattern.Length - 1;
                }

            }

            //Gab es kein Match im ganzen Text, so gebe false zurück
            return false;
        }
    }
}

                

Lösung von: Tobias Golz (Wilhelm Büchner Hochschule)

Verifikation/Checksumme:

Testen Sie Ihr Programm mit den beiden folgenden Texten:

Die Reform des EU-Urheberrechts könnte zu einer fehleranfälligen und grundrechtswidrigen Vorzensur führen. Mit ihrer Zustimmung 2019 bricht die Bundesregierung den Koalitionsvertrag von 2018.

Ihre Funktion sollte "true" liefern.

Die Reform des EU-Urheberrechts könnte zu einer fehleranfälligen und grundrechtswidrigen Vorzensur führen. Mit ihrer Zustimmung 2019 bricht die Bundesregierung keinerlei Verträge.

Ihre Funktion sollte "false" liefern.

 

Bravo: Sie haben mit Ihren ersten voll funktionsfähigen, korrekten Upload-Filter geschrieben!

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 0.25
Schwierigkeit: Leicht
Webcode: xkmw-s55e
Autor: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen