code_snippets.txt

## C++: Tax Calculator

//
// Created by maxga on 14.11.2024.
//

#include "dir.h"
#include <iostream>
#include <limits>
#include <cmath>

using namespace std;

// Konstanten für die Steuergrenzen
const double GRUNDFREIBETRAG = 10908.0;
const double ZONE1_OBERGRENZE = 66761.0;
const double ZONE2_OBERGRENZE = 277825.0;

double umsatz_holen() {
    double umsatz;
    while (true) {
        cout << "Wie viel Umsatz hast du in diesem Monat gemacht: " << endl;
        cin >> umsatz;
        if (cin.fail()) {
            cin.clear();
            cin.ignore(numeric_limits<streamsize>::max(), '\n'); // ohne numeric_limits<streamsize>::max() wird der while loop pro invalides Zeichen einmal durchlaufen
            cout << "Der Angegebene Wert ist keine valide Zahl!" << endl;
        }
        else {
            if (umsatz != 0) {
                break;
            }
            else {
                cout << "Bitte eine Zahl nennen, die nicht null ist!" << endl;
            }
        }
    }
    return umsatz;
}

double steuer_berechen() {
    double umsatz = umsatz_holen();
    double steuer = 0.0;

    // 10.908 Euro (keine Steuer)
    if (umsatz <= GRUNDFREIBETRAG) {
        return steuer; // Keine Steuer
    }

    // 10.909 Euro bis 66.761 Euro (14% bis 24%)
    if (umsatz > GRUNDFREIBETRAG && umsatz <= ZONE1_OBERGRENZE) {
        double zuVersteuerndesEinkommen = umsatz - GRUNDFREIBETRAG; // Einkommen über Grundfreibetrag
        steuer += zuVersteuerndesEinkommen * 0.19; // Durchschnittlicher Steuersatz von ca. 14-24%
        return steuer;
    }

    // Komplette (14% bis 24%)
    steuer += (ZONE1_OBERGRENZE - GRUNDFREIBETRAG) * 0.19;

    // 66.762 Euro bis 277.825 Euro (24% bis 42%)
    if (umsatz > ZONE1_OBERGRENZE && umsatz <= ZONE2_OBERGRENZE) {
        double zuVersteuerndesEinkommen = umsatz - ZONE1_OBERGRENZE;
        steuer += zuVersteuerndesEinkommen * 0.33; // Durchschnittlicher Steuersatz von ca. 24-42%
        return steuer;
    }

    // Komplette (24% bis 42%)
    steuer += (ZONE2_OBERGRENZE - ZONE1_OBERGRENZE) * 0.33;

    // Reichensteuer: Über 277.826 Euro (45%)
    if (umsatz > ZONE2_OBERGRENZE) {
        double zuVersteuerndesEinkommen = umsatz - ZONE2_OBERGRENZE;
        steuer += zuVersteuerndesEinkommen * 0.45;
    }

    return steuer;
}

int main() {
    double steuerNetGerundet = steuer_berechen();
    double steuerZuZahlen = round(steuerNetGerundet * 100.0 ) / 100.0;

    cout << "Die berechnete Einkommensteuer betraegt: " << steuerZuZahlen << " Euro" << endl;
    return 0;
}

## C++: Small Calculator

#include <iostream>

using namespace std;

int main() {
     cout << " Erster Wert: ";
     double nummer1;
     cin >> nummer1;

     cout << "Operator (+ - * /): ";
     string operatorZeichen;
     cin >> operatorZeichen;

     cout << "Zweiter Wert: ";
     double nummer2;
     cin >> nummer2;

     double ergebnis = 0;

     if (operatorZeichen == "+") {
          ergebnis = nummer1 + nummer2;
     }
     else if (operatorZeichen == "-") {
          ergebnis = nummer1 - nummer2;
     }
     else if (operatorZeichen == "*") {
          ergebnis = nummer1 * nummer2;
     }
     else if (operatorZeichen == "/") {
          if (nummer2 != 0) {
               ergebnis = nummer1 / nummer2;
          } else {
               cout << "Fehler: Division durch Null ist nicht erlaubt!";
               return 1;
          }
     }
     else {
          cout << "Ein Fehler ist aufgetreten! Bitte erneut versuchen!";
          return 1;
     }

     cout << "Das Ergebnis lautet: " << nummer1 << " " << operatorZeichen << " " << nummer2 << " = " << ergebnis;

     return 0;
}



## Kotlin: Small Calculator

fun main(){
    println("Erste Ziffer:")
    val erste = readln().toInt()

    println("Die gewünchte Operation (+|-|*|/):")
    val operator = readln().toString()
    
    println("Zweite Ziffer:")
    val zweite = readln().toInt()



    val ergebniss = when (operator) {
        "+" -> erste + zweite
        "-" -> erste - zweite
        "*" -> erste * zweite
        "/" -> if (erste != 0) erste / zweite else "Division durch 0"
        else -> "Ungültige Operation"
    }
        println("Dein Term lautet: $erste $operator $zweite = $ergebniss")
}

main()

## Python: Calculator (Also Part of my little project)

from sys import argv
from ANSI_Escape_Sequences import *
from beenden import beenden

if len(argv) > 1 and len(argv[1]) > 1:
    name = argv[1]
    print(f'{GRÜN}Hallo {ROT}{name}{RESET}')
else:
    print(f'{ROT}Kein Name übergeben!{RESET}\n')
    name = f'{ROT}Unbekannt{RESET}'

def format_number(n):
    return int(n) if n.is_integer() else n

def formatieren(nummer):
    try:
        return int(nummer)
    except ValueError:
        try:
            return float(nummer)
        except ValueError:
            return None

def ist_rechenzeichen(zeichen):
    if zeichen in ['+', '-', '*', '/', '**', '%']:
        return zeichen
    else:
        return None


def hole_nummern(welche: int) -> int:
    while True:
        wert = input(f'{CYAN}Gib die {ROT}{welche}. {CYAN}Zahl ein:{RESET} ')
        if formatieren(wert) is None:
            print(f'\n{ROT}Bitte eine gültige Zahl eingeben!{RESET}\n')
        else:
            break
    return wert


def hole_zeichen(welche: int):
    while True:
        zeichen = input(f'{CYAN}Gib das {ROT}{welche}. {CYAN}Zeichen ein:{RESET} ')
        if zeichen == '' and welche >= 2:
            break
        elif ist_rechenzeichen(zeichen) is None:
            print(f'\n{ROT}Bitte einen gültigen Operator angeben!{RESET}\n')
        else:
            break

    return zeichen

def main():
    rechnung = ""
    nummer1 = hole_nummern(1)
    rechnung += str(nummer1)

    i = 1
    while True:
        zeichen = hole_zeichen(i)
        if not zeichen:
            break
        nummer = hole_nummern(i + 1)
        rechnung += f" {zeichen} {nummer}"
        i += 1

    ergebnis = (eval(rechnung))

    if type(ergebnis) == float or bool:
        print(f'''
{ROT}Bitte beachte, dass das Addieren von z.B. 0,1 + 0,2 = {0.1 + 0.2} ergeben kann,
da Computer mit Kommazahlen (Floats/Doubles) nur eingeschränkt genau rechnen können!{RESET}
''')

    print(f'\n{CYAN}Das Ergebnis aus {RESET}{rechnung} {CYAN}= {RESET}{format_number(ergebnis)}')

    neu = input(f"\n{CYAN}Zum Beenden '{ROT}Q{CYAN}' drücken oder '{ROT}Enter{CYAN}' zum Weiterrechnen!{RESET}\n").lower()

    if neu == 'q':
        beenden('Programm wird geschlossen!', name, 0)
    else:
        if __name__ == "__main__":
            main()

if __name__ == "__main__":
    print(f'''
{GELB}Anleitung:{RESET}
{BLAU}Addition: {ROT}+{RESET}
{BLAU}Subtraktion: {ROT}-{RESET}
{BLAU}Division: {ROT}/{RESET}
{BLAU}Multiplikation: {ROT}*{RESET}
{BLAU}Potenz: {ROT}**{RESET}
{BLAU}Modulus: {ROT}%{RESET}

{GELB}Wenn du fertig bist, drücke '{ROT}Enter{GELB}' und lasse das Feld frei!{RESET}
''')
    main()



## Python: Terminate Function (Dependency of something comming here soon!)

from ANSI_Escape_Sequences import *

def beenden(nachricht, name, exit_code):
    print(f"\n{ROT}{nachricht}{RESET}")
    input(f'\n{GELB}***{ROT}{name}{GELB} drücke \'{ROT}Enter{GELB}\', um das Terminal zu beenden. ***{RESET}')
    exit(exit_code)

## Python: ASYN Escape Codes (Part of my little project)


SCHWARZ = '\033[30m'
ROT = '\033[31m'
GRÜN = '\033[32m'
GELB = '\033[33m' # orange in manchen betriebs systeme / orange on some devices
BLAU = '\033[34m'
MAGENTA = '\033[35m'
CYAN = '\033[36m'
HELL_GRAU = '\033[37m'
DUNKEL_GRAU = '\033[90m'
HELL_ROT = '\033[91m'
HELL_GRUN = '\033[92m'
HELL_GELB = '\033[93m'
HELL_BLAU = '\033[94m'
HELL_MAGENTA = '\033[95m'
HELL_CYAN = '\033[96m'
WEIß = '\033[97m'

RESET = '\033[0m' # restet zum standartterminalfarbe / resets terminal to the standart color used by the os


def main():
    print(SCHWARZ + "SCHWARZ" + RESET)
    print(ROT + "ROT" + RESET)
    print(GRÜN + "GRUN" + RESET)
    print(GELB + "GELB" + RESET)
    print(BLAU + "BLAU" + RESET)
    print(MAGENTA + "MAGENTA" + RESET)
    print(CYAN + "CYAN" + RESET)
    print(HELL_GRAU + "HELL GRAU" + RESET)
    print(DUNKEL_GRAU + "DUNKEL GRAU" + RESET)
    print(HELL_ROT + "HELL ROT" + RESET)
    print(HELL_GRUN + "HELL GRUN" + RESET)
    print(HELL_GELB + "HELL GELB" + RESET)
    print(HELL_BLAU + "HELL BLAU" + RESET)
    print(HELL_MAGENTA + "HELL MAGENTA" + RESET)
    print(HELL_CYAN + "HELL CYAN" + RESET)
    print(WEIß + "WEIß" + RESET)

if __name__ == "__main__":
    main()


## Python: Age Calculator


from datetime import datetime, date

# Define color codes for aesthetic purposes (using ANSI codes for terminal | may not work in all terminal versions idk why but if so just set all 4 variables to empty strings)
red = '\033[91m'
yellow = '\033[93m'
cyan = '\033[96m'
reset = '\033[0m'

# error/exit function
def exit_program(message):
    print()
    print(f'{red}{message}{reset}')
    print()
    input(f'{yellow}*** Press any key to exit the program. ***{reset}')
    exit(0)

# user input for birthdate
birthdate_str = input(
    f"{cyan}Please enter your birthdate for age calculation ({yellow}DD.MM.YYYY{cyan}): {reset}"
)
print()

# format birthdate to date object
try:
    birthdate = datetime.strptime(birthdate_str, "%d.%m.%Y").date()
except ValueError:
    exit_program("Error: Invalid date format.")

# calculate age
today = date.today()
age = today - birthdate

# functions to display age in days or weeks
def age_in_days():
    print(f"{cyan}You are {red}{age.days}{cyan} days old.{reset}")

def age_in_weeks():
    weeks = age.days // 7
    print(f"{cyan}You are approximately {red}{weeks}{cyan} weeks old.{reset}")

# ask the user for preferred format (days or weeks)
age_days_weeks = input(f"{cyan}Do you want to know your age in days or weeks? ({yellow}Days/Weeks{cyan}): {reset}")

if "d" in age_days_weeks.lower():
    age_in_days()
    exit_program("You got your answer!")
elif "w" in age_days_weeks.lower():
    age_in_weeks()
    exit_program("You got your answer!")
else:
    print(f"{red}Invalid choice!{reset}")
    exit_program("Program ended.")

## Python: List Comprehension 


numbers = [1, 2, 3, 4, 5]
squares = [x**2 for x in numbers]
print(squares)  # Output: [1, 4, 9, 16, 25]
#