Programmieren lernen

Diese Lösung ist mit Visual Studio 2010 erstellt
Einfach eine neue Form in ein Projekt einfügen und den Code reinkopieren.
Kann noch durch Textfelder ergänzt werden die habe ich mir aber gespart. Viel Spass damit

Imports System.Text.RegularExpressions
Public Class frm_zeichenketten
    Dim strhaupttext As String = ""
    Dim strvergleichstext As String = ""
    Dim lnghauptlaenge As Long = 0
    Dim lngvergleichslaenge As Long = 0
    Dim lnganzIdentpos As Long = 0
    Dim lnganzidentchar As Long = 0
    Dim dblproz As Double = 0
    Dim dblprozgleich As Double = 0
    Dim dblprozident As Double = 0
    Property Haupttext As String
        Get
            Return strhaupttext
        End Get
        Set(value As String)
            strhaupttext = value.Trim
        End Set
    End Property
    Property Vergleichstext As String
        Get
            Return strvergleichstext
        End Get
        Set(value As String)
            strvergleichstext = value.Trim
        End Set
    End Property
    Property Hauptlaenge As Long
        Get
            Return lnghauptlaenge
        End Get
        Set(value As Long)
            lnghauptlaenge = value
        End Set
    End Property
    Property Vergleichslaenge As Long
        Get
            Return lngvergleichslaenge
        End Get
        Set(value As Long)
            lngvergleichslaenge = value
        End Set
    End Property
    Property AnzIdentchar As Long
        Get
            Return lnganzidentchar
        End Get
        Set(value As Long)
            lnganzidentchar = value
        End Set
    End Property
    Property AnzIdentpos As Long
        Get
            Return lnganzIdentpos
        End Get
        Set(value As Long)
            lnganzIdentpos = value
        End Set
    End Property
    Property Prozentual As Double
        Get
            Return dblproz
        End Get
        Set(value As Double)
            dblproz = value
        End Set
    End Property
    Property ProzentualGleich As Double
        Get
            Return dblprozgleich
        End Get
        Set(value As Double)
            dblprozgleich = value
        End Set
    End Property
    Property ProzentualIdent As Double
        Get
            Return dblprozident
        End Get
        Set(value As Double)
            dblprozident = value
        End Set
    End Property

    Public Sub New()

        ' Dieser Aufruf ist für den Designer erforderlich.
        InitializeComponent()
        Me.Haupttext = "The Quick Brown Fox jumps over the lazy dog"
        Me.Vergleichstext = "The Quick Brown xox jumps over the lazy dog"
        'Anzahl Zeichen Haupttext
        Me.Hauptlaenge = Me.Haupttext.Length
        'Anzahl Zeichen Vergleichstext
        Me.Vergleichslaenge = Me.Vergleichstext.Length
        'Wie groß ist die Gesamte Prozentuale Übereinstimmung
        Select Case Me.Hauptlaenge - Me.Vergleichslaenge
            Case 0 'Textlänge gleich
                Me.Prozentual = 100
            Case Is > 0 'Vergleichstext ist kleiner als der Haupttext
                Me.Prozentual = Me.Vergleichslaenge * 100 / Me.Hauptlaenge
            Case Is < 0 'Vergleichstext ist größer als der Haupttext
                Me.Prozentual = 100 - (100 - (Me.Vergleichslaenge * 100 / Me.Hauptlaenge))
        End Select
        'Wenn der Vergleichstext mehr als doppelt so groß ist wie der Haupttext
        'wird der Prozentwert negativ
        If Me.Prozentual < 0 Then Me.Prozentual = 0

        'Alle Zeichen in ein Array umwandeln
        Dim CharArray = Me.Vergleichstext.ToCharArray
        Dim HauptCharArray = Me.Haupttext.ToCharArray
        Dim CharArrayResult As New List(Of Char)
        'Umwandeln in eine List(of Char) die keine doppelten Chars enthält
        For Each myElement As Char In CharArray
            If CharArrayResult.Contains(myElement) = False Then
                CharArrayResult.Add(myElement)
            End If
        Next
        'Jetzt über reguläre Ausdrücke Vergleichen und die Anzahl des Vorkommens ermitteln
        Dim regExp As Regex
        Dim mc As MatchCollection
        For Each Element As Char In CharArrayResult
            regExp = New Regex(Element)
            mc = regExp.Matches(Me.Haupttext)
            If mc.Count > 0 Then
                Me.AnzIdentchar = Me.AnzIdentchar + mc.Count
            End If
        Next
        'Wie groß ist die Prozentuale Übereinstimmung gleicher Zeichen
        Select Case Me.Hauptlaenge - Me.AnzIdentchar
            Case 0 'Textlänge gleich
                Me.ProzentualGleich = 100
            Case Is > 0 'Vergleichstext ist kleiner als der Haupttext
                Me.ProzentualGleich = Me.AnzIdentchar * 100 / Me.Hauptlaenge
            Case Is < 0 'Vergleichstext ist größer als der Haupttext
                Me.ProzentualGleich = 100 - (100 - (Me.AnzIdentchar * 100 / Me.Hauptlaenge))
        End Select
        If Me.ProzentualGleich < 0 Then Me.ProzentualGleich = 0

        'Positionen berechnen
        Dim intNebenIndex As Integer = 0
        'Sind beide Texte Identisch
        Dim equal As Boolean = HauptCharArray.SequenceEqual(CharArray)
        'Nein dann genauer hinschauen ob char und Position übereinstimmen

        If equal = False Then
            For Each myElement As Char In CharArray
                Dim intHauptIndex As Integer = -1
                intHauptIndex = Me.Haupttext.IndexOf(myElement.ToString, intNebenIndex, 1)
                If intHauptIndex >= 0 Then
                    'Übereinstimmung der Position
                    If intNebenIndex = intHauptIndex Then
                        Me.AnzIdentpos = Me.AnzIdentpos + 1
                    End If
                End If
                intNebenIndex = intNebenIndex + 1
            Next
        Else
            'Kann nur auftreten wenn beide Texte Gleich sind
            Me.AnzIdentpos = Me.Haupttext.Length
        End If
        Select Case Me.Hauptlaenge - Me.AnzIdentpos
            Case 0 'Textlänge gleich
                Me.ProzentualIdent = 100
            Case Is > 0 'Vergleichstext ist kleiner als der Haupttext
                Me.ProzentualIdent = Me.AnzIdentpos * 100 / Me.Hauptlaenge
            Case Is < 0 'Vergleichstext ist größer als der Haupttext
                Me.ProzentualIdent = 100 - (100 - (Me.AnzIdentpos * 100 / Me.Hauptlaenge))
        End Select
        If Me.ProzentualIdent < 0 Then Me.ProzentualIdent = 0
        MessageBox.Show("Übereinstimmung der Textlängen:" & Format(Me.Prozentual, "0.00") & "% ;Anzahl Identischer Zeichen:" & Format(Me.ProzentualGleich, "0.00") & "% ;Anzahl:" & Me.AnzIdentchar & ";Position:" & Format(Me.ProzentualIdent, "0.00") & "Anzahl:" & Me.AnzIdentpos, "Auswertung", MessageBoxButtons.OK)
    End Sub

End Class
                

Lösung von: Klaus Raykowski (OMM-Systems)

public double compareStrings(String mainString, String toCompareString, boolean ignoreCase) {

        // Wenn true wird Groß-Kleinschreibung ignorriert
        if (ignoreCase) {
            mainString = mainString.toUpperCase();
            toCompareString = toCompareString.toUpperCase();
        }

        // Längenwerte
        int mainstringlength = mainString.length();
        int tocomparestringlength = toCompareString.length();
        int smallerlength;

        // Wie viel Prozent ein einzelner Buchstabe ausmacht
        double percent = 100 / mainstringlength;

        // Prozentwerte der einzelnen Überprüfungen
        double position;
        double contains;
        double length;

        /*
         * 
         * 
         * Überprüfung des Längenwerts
         */
        if (mainstringlength > tocomparestringlength) {
            length = tocomparestringlength * percent;
            smallerlength = tocomparestringlength;
        } else if (mainstringlength < tocomparestringlength) {
            length = (mainstringlength * 2 - tocomparestringlength) * percent;
            smallerlength = mainstringlength;
        } else {
            length = 100;
            smallerlength = mainstringlength;
        }

        /*
         * Sollte der zu überprüfende String keine Länge haben oder mehr als
         * doppelt so groß wie der Hauptstring sein, wird length zu 0%
         */
        if (length < 0) {
            length = 0;
        }

        /*
         * 
         * 
         * Überprüfung des Positionswert
         */

        // Beide Strings als char[]
        char[] mainarray = mainString.toCharArray();
        char[] comparearray = toCompareString.toCharArray();

        // Zählt mit wie oft enthalten
        int counter = 0;

        // Durchläuft das kleinere Array und zählt Übereinstimmungen
        for (int i = 0; i < smallerlength; i++) {
            if (mainarray[i] == comparearray[i]) {
                counter++;
            }
        }
        position = counter * percent;

        /*
         * 
         * 
         * Überprüfung des Inhalts
         */

        // Zähler wird ein zweites mal genutzt
        counter = 0;

        // Beinhaltet alle chars des Vergleichstrings (keine doppelten)
        String keys = "";
        for (int i = 0; i < tocomparestringlength; i++) {
            if (!keys.contains(String.valueOf(comparearray[i]))) {
                keys = keys + String.valueOf(comparearray[i]);
            }
        }

        // Zählt Übereinstimmungen
        for (int i = 0; i < mainstringlength; i++) {
            if (keys.contains(String.valueOf(mainarray[i]))) {
                counter++;
            }
        }
        contains = counter * percent;

        /*
         * Zählt die 3 Prozentwerde zusammen und gibt das Ergebniss geteilt
         * durch 3 wieder
         */
        double percentOfSimilarity = Math.round((length + position + contains) / 3 * 100);
        percentOfSimilarity = percentOfSimilarity / 100;
        return percentOfSimilarity;
    }
                

Lösung von: Sebastian Littel ()

//----------------------------------------------
// Einfache WindowsFormsApplication mit:
// 2x textbox, 1x checkbox, 9x label, 1x button
//----------------------------------------------

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace ZeichenkettenVergleichen
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Int32 i = 0;
            Int32 i2 = 0;
            Double count = 0;

            String s1 = textBox1.Text;
            String s2 = textBox2.Text;




            //grosskleinschreibung
            if (!checkBox1.Checked)
            {
                s1 = s1.ToLower();
                s2 = s2.ToLower();
            }




            //länge
            Double l1 = s1.Count();
            Double l2 = s2.Count();

            Double lprozent = 0;

            lprozent = l2 / l1 * 100;

            label6.Text = "Die Länge der Zeichenkette 2 beträgt " + lprozent + "% der Länge der Zeichenkette 1";




            //position
            Char[] s1a = s1.ToCharArray();
            Char[] s2a = s2.ToCharArray();
            
            Double pprozent = 0;

            if (lprozent > 100)
            {
                i2 = s1a.Count();
            }
            else if(lprozent<=100)
            {
                i2 = s2a.Count();
            }

            while ( i < i2)
            {
                if(s1a[i]==s2a[i])
                {
                    count += 1;                    
                }
                i += 1;
            }

            pprozent =   count/Convert.ToDouble(s1a.Count()) * 100;
            label7.Text = pprozent + " Prozent der Zeichen in Zeichenkette 1 befinden sich an der selben Stelle wie in Zeichenkette 2.";




            //inhalt
            Char[] s2da = s2.Distinct().ToArray();
            Char[] s1da = s1.Distinct().ToArray();
            Int32 s2dcount = s2da.Count();
            Int32 s1dcount = s1da.Count();

            i = 0; 
            i2 = 0; 
            count = 0;

            Double iprozent = 100 / s1da.Count();

            while (i < s2dcount)
            {
               while(i2 < s1dcount)
               {
                   if(s1da[i2] == s2da[i])
                   {
                       count += 1;
                   }
                   i2 += 1;
               }
               i += 1;
               i2 = 0;
            }
            label8.Text = (iprozent * count) + "% der Zeichen in Zeichenkette 1 kommen auch in Zeichenkette 2 vor";




            //Total
            if(lprozent > 100)
            { 
                lprozent = 100 / lprozent * 100;
            }
            Double total = (lprozent + pprozent + iprozent)/3;
            label9.Text = "Zeichenkette 1 stimmt zu " + total + "% mit Zeichenkette 2 überein.";
        }
    }
}
                

Lösung von: Manuel Burkard (Internet)

using System;
using System.Linq;

namespace charMatch
{
    class Program
    {
        static void Main(string[] args)
        {
            int contentCount = 0;
            int positionCount = 0;

            Console.WriteLine("case sensitive? y/n: ");
            bool isCaseSensitive = Console.ReadLine() == "y" ? true : false;

            Console.WriteLine( "Main string?: " );
            string mainString = Console.ReadLine();
            Console.WriteLine( "Other string?: ");
            string otherString = Console.ReadLine();

            if ( !isCaseSensitive )
            {
                mainString = mainString.ToLower();
                otherString = otherString.ToLower();
            }

            // length
            double procentLength = ( Convert.ToDouble(otherString.Length) / Convert.ToDouble(mainString.Length) ) * 100;
            Console.WriteLine("Length: {0}", procentLength);

            // position
            for (int i = 0; i < mainString.Length; i++) {
                for (int j = 0; j < otherString.Length; j++) {
                    if ( procentLength <= 100 && i > otherString.Length )
                        break;
                    if ( ( i == j ) && ( mainString[i] == otherString[j] ) )
                        positionCount++;
                }
            }

            double procentPosition = ( positionCount / Convert.ToDouble( mainString.Length ) ) * 100;
            Console.WriteLine("Position: {0}", procentPosition);

            // content
            for (int i = 0; i < mainString.Length; i++) {
                if ( otherString.Contains(mainString[i]) )
                    contentCount++;
            }

            double procentContent = ( contentCount / Convert.ToDouble(mainString.Length )) * 100;
            Console.WriteLine( "Content: {0}", procentContent );

            // total
            double procentTotal = (procentLength + procentPosition + procentContent) / 3;
            Console.WriteLine("Total: {0}", procentTotal);
        }
    }
}

                

Lösung von: Lukas -- (-)

import java.util.Scanner;


public class KettenAbgleich 
{
	private static Scanner scan;
	
	public static void main(String[] args)
	{
		scan = new Scanner(System.in);
		
		System.out.println("Geben sie die zeichenkette Nummer 1 an.");
		String chars1 = scan.nextLine();
		
		System.out.println("Geben sie die zeichenkette Nummer 2 an.");
		String chars2 = scan.nextLine();
		
		System.out.println("Der Unterschied beträgt: "+checkStrings(chars1, chars2)+" %");
	}
	
	public static double checkStrings(String char1, String char2)
	{
		System.out.println("Wollen sie Groß- und Kleinschreibung aktivieren? j/n ");
		String r = scan.next();
		if(r.contains("j")) 
		{
			char1.toLowerCase();
			char2.toLowerCase();
		}
		
		double length = checkLength(char1,char2);
		System.out.println("Länge: "+length+" %");
		double position = checkPosition(char1,char2);
		System.out.println("Position: "+position+" %");
		double inhalt = checkSpelling(char1,char2);
		System.out.println("Inhalt: "+inhalt+" %");
		
		return (length+position+inhalt)/3;
	}
	
	public static double checkLength(String chars1, String chars2)
	{
		if( chars1.length() > chars2.length() )
		{
			double percPerChar = (double)100/chars1.length();
			return percPerChar*chars2.length();
		}	
		else 
		{
			double percPerChar = (double)100/chars2.length();
			return percPerChar*chars1.length();
		}
	}
	
	public static double checkPosition(String chars1, String chars2)
	{
		double percPerChar = 0;
		
		if( chars1.length() > chars2.length() )	percPerChar = (double)100/chars1.length();
		else percPerChar = (double)100/chars2.length();
			
		if(chars1.length() < chars2.length())
		{
			String tmp = chars1;
			chars1 = chars2;
			chars2 = tmp;
		}
		
		int count = 0;
		
		for( int i = 0; i < chars2.length(); i++)
		{
			if(chars1.charAt(i) == chars2.charAt(i))
			{
				count++;
			}
		}
		
		return count*percPerChar;
	}
	
	public static double checkSpelling(String chars1, String chars2)
	{
		String tmp = "";
				
		if(chars1.length() < chars2.length())
		{
			String t = chars1;
			chars1 = chars2;
			chars2 = t;
		}
		
		double percPerChar = (double)100/chars1.length();
		
		for(int i = 0; i < chars2.length();  i++)
		{
			for(int j = 0; j < chars2.length(); j++)
			{
				if(chars2.charAt(i) == chars2.charAt(j) && i != j )
				{
					tmp = "";
					
					for(int k = 0; k < j; k++) tmp += chars2.charAt(k);
					
					for(int k = j; k < chars2.length()-1; k++)
					{
						tmp += chars2.charAt(k+1);
					}
					break;
				}
			}
		}		
		
		int count = 0; 
		for( int i = 0; i < chars1.length(); i++)
		{
			for(int j = 0; j < tmp.length(); j++)
			{
				if(chars1.charAt(i) == tmp.charAt(j)) count++;
			}
		}
		
		return percPerChar*count;
	}
}

                

Lösung von: Daniel Hu (Ludwig-Geissler-Schule )

'''
habe nur old-Style Programmieren gelernt. Freue mich über Anregungen, die Lösung in Python simpler zu realisieren
'''
# -*- coding: utf-8 -*-
import string

caseSensitiv = "0"
f_gesamtProzent = "{0:.2f}"                        # Ausgabeformat

def inhalt(kettekurz,kettelang):
	treffer = 0
	anzkettekurz = len(kettekurz)
	anzkettelang = len(kettelang)
	listelang = []
	for i in range (0,anzkettelang,1):                    # lange Zeichenkette zeichenweise in Liste umwandeln
		listelang += kettelang[i]

	for i in range (0,anzkettekurz,1):                    # kurze Zeichenkette verarbeiten
		for j in range (0,anzkettelang,1):                # lange Zeichenkette verarbeiten
			if kettekurz[i] == listelang[j]:
				treffer += 1
				listelang[j] = " "                      # verarbeitetes Zeichen entfernen
	return treffer


# Benutzerentscheidung für Groß-/Kleinschreibung oder nicht
while caseSensitiv not in "J,j,Y,y,N,n":
	caseSensitiv = raw_input("Soll Groß-/Kleinschreibung beachtet werden? J,j,Y,y,N,n\n")


# Eingabe der zu prüfenden Zeichenketten und ggf. Umwandlung in nicht case sensitiv
hauptKette = raw_input("Bitte Hauptkette eingeben: ")
lhauptk = len(hauptKette)
nebenKette = raw_input("Bitte Nebenkette eingeben: ")
lnebenk = len(nebenKette)
if caseSensitiv in "N,n":
	hauptKette = string.lower(hauptKette)
	nebenKette = string.lower(nebenKette)


# Verarbeiten der Länge
if lnebenk == lhauptk:              # Nebenkette genau so lang wie Hauptkette = 100%
	prozentLen = 100
elif lnebenk == 0:                          # leere Nebenkette = 0%
	prozentLen = 0
elif lnebenk > (lhauptk * 2):       # Nebenkette mehr als doppelt so lang wie Hauptkette = 0%
	prozentLen = 0
elif lnebenk > lhauptk:
	prozentLen = 100 - ((100. / lhauptk) * (lnebenk - lhauptk))
else:
	prozentLen = (100. / lhauptk) * lnebenk



# Verarbeiten der Zeichenpositionen
treffer = 0                                 # Anzahl identischer Zeichen mit gleicher Position
if lhauptk <= lnebenk:                      # die kürzeste Zeichenkette bestimmt die Verarbeitungslänge
	anzZeichen = lhauptk
else:
	anzZeichen = lnebenk
for i in range (0,anzZeichen,1):
	if hauptKette[i:i+1] == nebenKette[i:i+1]:
		treffer += 1
prozentPos = (100. / lhauptk) * treffer


# Verarbeiten des Inhalts
treffer = 0                                 # Anzahl identischer Zeichen mit ungleicher Position
if lhauptk <= lnebenk:                      # die kürzeste Zeichenkette bestimmt die Verarbeitungslänge
	treffer = inhalt(hauptKette,nebenKette)
else:
	treffer = inhalt(nebenKette,hauptKette)
prozentInh = (100. / lhauptk) * treffer



# Ausgabe der einzelnen Prozente und des Gesamtergebnisses
print 'Erreichte Prozent bei Länge: ', prozentLen
print 'Erreichte Prozent bei Position: ', prozentPos
print 'Erreichte Prozent bei Inhalt: ', prozentInh
print 'Erreichte Gesamtprozent: ', f_gesamtProzent.format((prozentLen + prozentPos + prozentInh) / 3), '\n'
                

Lösung von: J. Reppe ()

function compareString(str, compStr, caseSensitive) {
  // default: keine unterscheidung von groß- und kleinschreibung
  caseSensitive = caseSensitive || false;
  var pLen, pPos = 0, pCont = 0,
      unit = 100 / str.length,
      tmp;
  if (!caseSensitive) {
    str = str.toUpperCase(); compStr = compStr.toUpperCase();
  }
  // länge
  tmp = unit * compStr.length;
  if (tmp > 200) pLen = 0;
  else if (tmp > 100) pLen = 200 - tmp;
  else pLen = tmp;
  // position
  for (tmp = 0; tmp < Math.min(str.length, compStr.length); tmp++)
    if (str[tmp] === compStr[tmp]) pPos += unit;
  // inhalt
  for (tmp = 0; tmp < str.length; tmp++) {
    if (compStr.indexOf(str[tmp]) > -1) pCont += unit;
  }
  // rückgabe des durchschnitts in prozent
  return ((pLen + pPos + pCont) / 3).toFixed(2);
}

console.log(compareString("Flugzeug", "Affe"));     // 25.00
console.log(compareString("Affe", "Affe", true));   // 100.00
console.log(compareString("Affe", "affe", true));   // 83.33

                

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

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

double GetPercentOfComparison(string mainStr, string sideStr , bool caseSen = false) {
    double mainLen = mainStr.Length, sideLen = sideStr.Length;

    if (!caseSen) { mainStr = mainStr.ToLower(); sideStr = sideStr.ToLower(); }

    var per = 100 / mainLen * sideLen;
    var facPer = (per > 200 ? 0 : (100 - per % 100)) / sideLen;
    var facPos = Enumerable.Range(0, (int)Math.Min(sideLen, mainLen)).Where(x => mainStr[x] == sideStr[x]).Count();
    var facCon = new HashSet<char>(sideStr.ToCharArray()).SelectMany(x => mainStr.Where(y => x == y).ToList()).Count();

    return Math.Round(facPer * (sideLen + facPos + facCon) / 3.0, 2);
}

Console.WriteLine(GetPercentOfComparison("Flugzeug", "affe"));
Console.WriteLine(GetPercentOfComparison("Flugzeug", "Flugzeug", true));
Console.WriteLine(GetPercentOfComparison("Flugzeug", "flUgzEUg", true));
                

Lösung von: Jens Kelm (@JKooP)

// C++ 17

#include <iostream>
#include <string>
#include <algorithm>
#include <set>
#include <vector>

void to_lower(std::string& str) {
    std::transform(str.begin(), str.end(), str.begin(), [](unsigned char c) { return std::tolower(c); });
}

double get_percent_of_string_comparison(std::string main_str, std::string side_str, bool case_sensitive = false) {
    unsigned long long main_length{ main_str.length() }, side_length{ side_str.length() };

    if (!case_sensitive) { to_lower(main_str); to_lower(side_str); }

    const auto& per{ 100.0 / main_length * side_length };
    auto fac_per{ per > 200 ? 0.0 : (100 - (double)((int)per % 100)) / side_length };

    auto fac_pos{ 0 };
    for (auto i{ 0 }; i < std::min(side_length, main_length); i++)
        if (main_str[i] == side_str[i]) fac_pos++;

    auto fac_con{ 0 };
    for (const auto& s : std::set<char>{ begin(side_str), end(side_str) })
        for (const auto& v : main_str )
            if (s == v) fac_con++;

    return fac_per * (side_length + fac_pos + fac_con) / 3.0;
}

int main() {
    std::cout << get_percent_of_string_comparison("Flugzeug", "affe") << "\n";              // 25
    std::cout << get_percent_of_string_comparison("Flugzeug", "Flugzeug", true) << "\n";    // 100
    std::cout << get_percent_of_string_comparison("Flugzeug", "flUgzEUg", true) << "\n";    // 66,67
}
                

Lösung von: Jens Kelm (@JKooP)