Logik & Informatik-Grundlagen

Richtig: !a || !b

Regel von De Morgan: Die Negation eines UND wird zum ODER der Negationen. „Nicht beide“ heißt „mindestens einer nicht“. Häufiger Fehler beim Umschreiben von if-Bedingungen: !a && !b, das wäre „keiner von beiden“.

Richtig: a

a ausklammern: a && (b || !b). Da b || !b immer wahr ist, bleibt a. In echtem Code findet man so überflüssige Prüfungen, die nur die Lesbarkeit verschlechtern.

Richtig: a

Absorptionsgesetz: Ist a wahr, ist das Ganze wahr. Ist a falsch, ist auch a && b falsch. Das Ergebnis hängt also nur von a ab, b ist bedeutungslos.

Richtig: 3

!c halbiert auf 4 Zeilen (c = falsch). Davon ist a || b in 3 Fällen wahr, nur a = b = falsch fällt weg. Ergebnis 3.

Richtig: O(n²)

Die innere Schleife läuft n-mal für jedes der n i. Insgesamt n · n Durchläufe. Doppelt so viele Daten bedeuten viermal so viel Arbeit.

Richtig: O(log n)

i verdoppelt sich in jedem Schritt: 1, 2, 4, 8 … Bis n erreicht ist, braucht es etwa log₂(n) Schritte. Bei einer Million sind das nur 20 Durchläufe. Genau so arbeitet die Binärsuche.

Richtig: O(n²)

Die innere Schleife wird zwar immer länger, insgesamt sind es aber 0 + 1 + 2 + … + (n - 1) = n(n - 1)/2 Durchläufe. Konstante Faktoren wie ½ fallen bei Big-O weg, es bleibt O(n²). Der Code ist doppelt so schnell wie zwei volle Schleifen, wächst aber gleich.

Richtig: O(n log n)

Außen n Durchläufe, innen jeweils log n. Zusammen n · log n. Das ist die Größenordnung guter Sortierverfahren wie Mergesort.

Richtig: 6

^ ist in Java kein Potenzieren, sondern bitweises XOR. 101 XOR 011 = 110, also 6. Wer 125 erwartet, hat einen klassischen Denkfehler, der auch im echten Code vorkommt. Potenzen gehen mit Math.pow.

Richtig: 15

-1 besteht aus 32 Einsen. >>> schiebt nach rechts und füllt mit Nullen auf. Nach 28 Stellen bleiben 4 Einsen übrig: 1111 = 15. Mit >> (mit Vorzeichen) bliebe es -1.

Richtig: -2147483648

Die 1 landet im höchsten Bit, und das ist bei int das Vorzeichenbit. Ergebnis ist Integer.MIN_VALUE. 2147483648 passt nicht in einen int.

Richtig: Ob n eine Zweierpotenz ist

Eine Zweierpotenz hat genau ein gesetztes Bit, z. B. 8 = 1000. n - 1 = 0111 hat genau die anderen Bits. Das UND ergibt 0. Bei allen anderen Zahlen bleibt das höchste Bit stehen. Geprüft für alle n von 1 bis 4999.

Richtig: 123-4567

\d steht für eine Ziffer, {3} für genau drei Wiederholungen. Gefordert sind also exakt drei Ziffern, ein Bindestrich, vier Ziffern. Das Leerzeichen passt nicht auf den Bindestrich.

Richtig: Hallo

Ein Großbuchstabe, danach mindestens ein Kleinbuchstabe (+ heißt einmal oder öfter). „H“ scheitert am +, „HALLO“ an den großen Folgebuchstaben. Achtung: Umlaute wie „Ärger“ würden auch nicht passen, [A-Z] kennt nur A bis Z.

Richtig: Main.java

\. ist ein echter Punkt, .* davor beliebige Zeichen. „Mainjava“ hat keinen Punkt, „Main.javax“ hört nicht auf .java auf (matches prüft die ganze Zeichenkette), „Main.JAVA“ scheitert an der Groß-/Kleinschreibung.

Richtig: <b>fett</b>

+ ist gierig: Es nimmt so viel wie möglich und gibt nur so weit nach, wie nötig. Vom ersten < bis zum letzten > passt alles. Für den kleinsten Treffer „<b>“ braucht man den genügsamen Quantor +? (also <.+?>).

Richtig: 5 und 3

COUNT(*) zählt Zeilen, COUNT(spalte) nur Zeilen, in denen die Spalte nicht NULL ist. Zwei Kunden haben keine E-Mail, also 5 und 3.

Richtig: 2

Ben (inaktiv) und David (gesperrt). Clara fehlt: NULL <> 'aktiv' ist nicht wahr, sondern UNKNOWN, und WHERE lässt nur wahre Zeilen durch. Wer auch Clara will, braucht OR status IS NULL. Einer der häufigsten SQL-Fehler.

Richtig: 150

AVG ignoriert NULL-Werte: (100 + 200) / 2 = 150, nicht (100 + 200) / 5 = 60. Sollen fehlende Boni als 0 zählen, braucht man AVG(COALESCE(bonus, 0)). Fachlich muss man klären, was gemeint ist.

Richtig: 6

LEFT JOIN behält alle Kunden. Anna erscheint zweimal (zwei Bestellungen), Clara einmal, Ben, David und Eva je einmal mit NULL als Bestellung. 2 + 1 + 3 = 6. Ein INNER JOIN lieferte nur 3 Zeilen.