nicht mitschleppen möchte

Du weißt hoffentlich, dass die Alienware-Dinger keine Leichtgewichte sind. Selbst die alten 14-Zöller haben es in sich.

Technisch gesehen sind die Dinger top - ich würde jederzeit meine Hand dafür ins Feuer legen.

Ein "Schlepptop" ist es nicht.

Naja, einfach irgendeinen Texteditor? Solange du die Datei als .html speicherst und in einem Browser öffnest...

Du brauchst ja keine vollwertige IDE - und falls doch, gibt es VSC im Web.

Ich bin ein Freund von lightweigth-Dingern -> https://phcode.dev/

PhoenixCode ist die neue Version von brackets.io. Läuft im Browser und ist an sich ausreichend. Hinzu kommt die Live-Vorschau :)

HauteCuisine bietet n Menüs an.

n steht für mindestens 1 in der Chen-Notation.

Der Nutzer kann lediglich kein Menü direkt reservieren. Dies geschieht ausschließlich über die Reservierung im Restaurant. Und das ist die Fragestellung :-)

Ist es etwas bei einer mehr-zu-mehr Beziehung

n:m-Beziehungen sollten in einem RDBMS aufgelöst werden (Normalisierung)

Hallo :)

Vorab - du solltest die Namen und Rollen voneinander trennen. Es sind verschiedene Entitäten, die eine eigene Spalte bekommen sollten. Das erleichtert dir die Datenverarbeitung enorm.

Folgendes VBA-Skript löscht alle von dir angegebenen Zeichenketten in einem Wertebereich, den du vergeben musst:

Sub ersetzeWort(ByVal noNeedString As String)
    Range("A1:Z900").Replace What:=noNeedString, Replacement:=""
End Sub

Damit das Skript automatisch und parametrisiert aufgerufen wird, benötigst du folgendes Schnipsel im Arbeitsblatt selbst:

Sub Worksheet_Change(ByVal Target As Range)
    Dim werteBereich As Range
    Set werteBereich = Range("A1:Z900")
    
    If Not Application.Intersect(werteBereich, Range(Target.Address)) _
               Is Nothing Then
    
        Call ersetzeWort("ETL")
        Call ersetzeWort(" ")
    
    End If
End Sub

An dieser Stelle wird der Wertebereich auf "Wertveränderungen" beobachtet, sobald du einen neuen Wert in eine Zelle schreibst, wird das Sub automatisch ausgeführt.

grün: die Funktion "Sub Worksheet_Change()"

orange: die Funktion "ersetzeWort()"

Bei Fragen gerne melden :)

print(type(kilometer))

Ausgabe ist <str>, da input() dir einen String zurückliefert.

An dieser Stelle musst du nach float oder double casten, ValueError auslösen und abfangen, wenn du Exception-Handling betreiben möchtest.

try:
    anfangspreis = 4.80
    kilometer = float(input("Bitte Kilometer angeben: "))
    kosten = 2.10    
    
    print ("Deine Kosten sind", anfangspreis + kosten * kilometer)
    
except ValueError:
    print ("Du musst eine Nummer eingeben!")

Sauberer Code bzw. saubere Architektur macht deinen Code lesbarer und wartbarer.

In diesem Zuge darf auch gerne auf Kommentare verzichtet werden - es sei denn, diese Kommentare dienen einem rechtlichen Zweck. Wenn jemand behauptet, er schreibe einen guten Code und nutzt Kommentare, dann ist der Code nicht gut.

Was würde dir besser gefallen?

import re

class PasswordValidator:
    def __init__(self, password):
        self.password = password

    def __validate_password(self):
        pattern = r"^(?=.*?[A-Z])(?=.*?[a-z])(?=.*?[0-9])(?=.*?[#?!@$%^&*-]).{8,}$"
        result = re.match(pattern, self.password)
    
        return result.group()

    def validate(self):
        try:
            self.__validate_password()

            print("Password is valid!")
        except AttributeError:
            print("Password validation failed.")

o_validator = PasswordValidator("aTest1337!")
o_validator.validate()

oder

class PasswordValidator:
    def __init__(self, password):
        self.password = password

    def __validate_password_length(self):
        ...

    def __validate_upper_case(self):
        ...

    def __validate_lower_case(self):
        ...

    def __validate_digits(self):
        ...

    def __validate_special_chars(self):
        ...

    def validate(self):
        try:
            self.__validate_password_length(self):
            self.__validate_upper_case(self):
            self.__validate_lower_case(self):
            self.__validate_digits(self):
            self.__validate_special_chars(self):
            
        except AttributeError:
            print("Password validation failed.")

o_validator = PasswordValidator("aTest1337!")
o_validator.validate()

An dieser Stelle ist Geschmack und Erfahrung ausschlaggebend. Würdest du wissen, was hier passiert? Oder wären doch Kommentare notwendig?

Bei IntelliJ links auf "Customize" -> "Keymap" Configure und dann öffnet sich ein neues Fenster.

Rechts oben in der Suchleiste nach "Generate" suchen und ein neues Binding vergeben. Sollte eigentlich damit getan sein.

Zwischen Python und Java liegt ein deutlicher Unterschied: das Paradigma

Während Java OO ist, kann Python lediglich OO nachahmen und ist eigentlich eine prozedurale Sprache.

Nicht die Syntax wird das Problem, sondern der Paradigmenwechsel.

Mathematik wird zwar sehr oft in den Verschlüsselungsverfahren, Umrechnungen oder der Bool'schen Algebra genutzt, aber dafür ist höhere Mathematik nicht immer notwendig.

Mache dir also keine Sorgen um Mathe :)

Das Abfotografieren üben wir nochmal :)

Du musst nach x auflösen:

-846 - x = 250 | + 846
- x = 1096

Da x nicht negativ sein darf:

- x * (-1) = 1096 * (-1)

Somit:

x  = -1096

Nachtrag:

-1096 für x in den Ursprung eingesetzt:

-846 - (-1096 ) = 250
250 = 250

Bedingung ist wahr, Rechnung richtig.

irgendeinem Grund sehe ich das ganze eher als Arbeit an.

Richtig - auch der Lernprozess ist Arbeit. Mit diesem Gefühl bist du nicht alleine.

Stell' dir vor dein Gehirn ist mit einem Schlauch verbunden. Dieser Schlauch leitet Informationen an dein Gehirn weiter - nun stellst du dich auf den Schlauch. Du willst zwar die Informationen, bekommst sie aber nicht.

Zwei Möglichkeiten:

• wechsle den Schlauch
• hör' auf herumzustehen

Land(Vorwahl, Landeskürzel)

Handynummer(ID, Nummer, Land.Vorwahl)

Somit hast du eine 1:n-Beziehung zwischen Land und Handynummer. Dass der PK der 1-Seite zum FK der n-Seite wird, ist hoffentlich bekannt.

Aber warum müsst ihr eine Handynummer als Entität und nicht als Attribut darstellen?

Du schon wieder! ;D

Mit Python kannst du kleine Skripte für das Betriebssystem, Anwendersoftware, APIs und sogar Webseiten entwickeln. Weiterhin Datenauswertungen und -visualisierungen fahren. Für die Daten kannst du einen Data Scrapper schreiben, der sich Daten von einer Webseite holt.

Hast du aber gerade Glück :)

 public function readLogin()
    {
        $query = "SELECT name from login WHERE name=?";

        $stmt = $this->connection->prepare($query);
        $stmt->bind_param('s', $this->login_name);
        $stmt->execute();
        $result = $stmt->get_result();

        while ($row = $result->fetch_assoc()) {
            if ($row['name'] == $this->login_name) {
                return $row['name'];
            }
        }
    }

Mein Beispiel ist eine Klasse (OO). Daher nicht wundern, dass "login_name" nicht zu sehen ist. Es handelt sich um ein Attribut meiner Klasse. "login_name" kannst du analog zu deinem Usernamen setzen.

Wahrscheinlich hast du drei User mit dem gleichen Namen auf der DB - was selbstverständlich nicht sein sollte.

Also, die Entschlüsselung müsstest du selbst hinkriegen :) Die Entschlüsselungsfunktion findest du eigentlich überall.

(b) RSA profitiert von Primzahlen und zwar nur dann, wenn sie groß genug sind (> 2048 Bit). Und das ist zugleich die Schwachstelle von RSA. Sind p und q zu klein gewählt, ist es für Dritte problemlos möglich, durch Primfaktorzerlegung die Schlüssel zu errechnen. Weiterhin ist im Beispiel q keine Primzahl. 65 zerlegt in Primfaktoren: 65 = 5 · 13

(c) Ich wünsche Eve/Mallory (wie die Rollen eigentlich heißen sollten) viel Erfolg beim Entschlüsseln. Denn bei solch' hohen Primzahlen dauert die Entschlüsselung viele Jahrhundert, selbst wenn ein Teil bekannt ist.

Hallo :)

Hoffentlich langweile ich dich nicht - ein Use-Case beschreibt jegliche Interaktion des Akteurs mit dem System.

Dein Vorschlag ist vollkommen richtig, denn "hinzufügen" und "entnehmen" sind zwei verschiedene Vorgänge, bei denen das System jeweils ein anderes Feedback an den Akteur (Benutzer) zurückliefert.

Falls du etwas in die Tiefe tauchen möchtest: UML