Programmieren lernen

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: Name nicht veröffentlicht

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)

Bsp=str(input("Gib einen Satz an"))
Bsp=Bsp.split(" ")
Suchwort=str(input("Gib das Suchwort an: "))
counter=0
for Wort in Bsp:
    if Suchwort in Wort:
        counter+=1
        continue
    else:
        pass
        continue
print(Suchwort, "ist", counter, " mal vorhanden")
                

Lösung von: Christian Psalm (Gymnasium)

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

using System.Text.RegularExpressions;

// Aufagbe 
const string txt1 = "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.";
const string pat1 = "Koalitionsvertrag";
Console.WriteLine(UploadFilter(txt1, pat1, true));

// Zusatzaufgabe (a)
const string txt2 = "Der Begriff Primarschule umfasst in der Schweiz und im Fürstentum Liechtenstein die Schulen, die von Kindern der Klassen 1 bis 5 bzw. 6 besucht werden.";
const string pat2 = "Arsch";
Console.WriteLine(UploadFilter(txt2, pat2));

// Zusatzaufgabe (b)
const string txt3 = "Das geht mir heute alles am Arsch vorbei";
var roughWords = new List<string> { "Arsch", "Scheisse", ... }; // beliebig erweitern
var found = roughWords.Where(x => UploadFilter(txt3, x, true)).ToList();
Console.WriteLine($"Folgende derbe Wörter wurden gefunden: {string.Join(", ", found)}");

// Funktion
bool UploadFilter(string text, string pattern, bool caseSensitive = false) {
    if (!caseSensitive) {
        pattern = pattern.ToLower(); 
        text = text.ToLower();
    }
    return new Regex(@"\b" + pattern + @"\b").IsMatch(text);
}
                

Lösung von: Jens Kelm (@JKooP)

def pruefen(text, such):
    if text.count(such) ==0:
        return False
    else:
        return True   
text=input("Geben Sie einen Text ein :")
such=input("Geben Sie ein Suchwort ein :")
print(pruefen(text,such))
                

Lösung von: Name nicht veröffentlicht