Aufgaben

Hier sind alle Aufgaben des Kurses an einem Ort. Zuerst 50 eigenständige Aufgaben von „Hallo, Welt“ bis zum kürzesten Weg in einem Raster, jede mit einem Beispiel und einer Lösung in JavaScript, geprüft mit einem echten Compiler. Danach die Aufgaben aus den Lektionen, nach Modulen: Jede führt zu der Lektion, die erklärt, was du brauchst.

50 Aufgaben zum Üben

1. 1. Hello World

   Gib den Text Hello, World! auf der Konsole aus. Das Programm hat keine Eingabe.

   Keine Eingabe.

   Ausgabe

   Hello, World!

   Was du brauchst, steht in der Lektion: Dein erstes Programm

   Lösung

   console.log("Hello, World!");

2. 2. Begrüße den Benutzer

   Lies einen Namen aus einer Zeile und begrüße die Person mit ihrem Namen in der Form „Hallo, <Name>!“.

   Eingabe

   Maria

   Ausgabe

   Hallo, Maria!

   Was du brauchst, steht in der Lektion: Eingabe und Ausgabe

   Lösung

   import { createInterface } from "node:readline";
   
   const rl = createInterface({ input: process.stdin });
   const lines = rl[Symbol.asyncIterator]();
   async function ask(question) {
     process.stdout.write(question);
     return (await lines.next()).value;
   }
   
   const name = await ask("");
   console.log("Hallo, " + name + "!");
   rl.close();

3. 3. Das Alter ausgeben

   Lies das Alter des Benutzers (eine ganze Zahl), speichere es in einer Variablen und gib es in einem Satz aus.

   Eingabe

   17

   Ausgabe

   Du bist 17 Jahre alt.

   Was du brauchst, steht in der Lektion: Variablen und Typen

   Lösung

   import { createInterface } from "node:readline";
   
   const rl = createInterface({ input: process.stdin });
   const lines = rl[Symbol.asyncIterator]();
   async function ask(question) {
     process.stdout.write(question);
     return (await lines.next()).value;
   }
   
   const age = Number(await ask(""));
   console.log("Du bist " + age + " Jahre alt.");
   rl.close();

4. 4. Einheitenumrechner

   Lies eine Länge in Zoll (sie kann eine Dezimalzahl sein) und rechne sie in Zentimeter um: 1 Zoll = 2,54 cm. Gib das Ergebnis mit 2 Nachkommastellen aus.

   Eingabe

   12.5

   Ausgabe

   31.75 cm

   Was du brauchst, steht in der Lektion: Operatoren und Arithmetik

   Lösung

   import { createInterface } from "node:readline";
   
   const rl = createInterface({ input: process.stdin });
   const lines = rl[Symbol.asyncIterator]();
   async function ask(question) {
     process.stdout.write(question);
     return (await lines.next()).value;
   }
   
   const inches = Number(await ask(""));
   console.log((inches * 2.54).toFixed(2) + " cm");
   rl.close();

5. 5. Gerade oder ungerade

   Lies eine ganze Zahl und gib aus, ob sie gerade oder ungerade ist.

   Eingabe

   7

   Ausgabe

   7 ist ungerade.

   Was du brauchst, steht in der Lektion: Bedingungen

   Lösung

   import { createInterface } from "node:readline";
   
   const rl = createInterface({ input: process.stdin });
   const lines = rl[Symbol.asyncIterator]();
   async function ask(question) {
     process.stdout.write(question);
     return (await lines.next()).value;
   }
   
   const number = Number(await ask(""));
   if (number % 2 === 0) {
     console.log(number + " ist gerade.");
   } else {
     console.log(number + " ist ungerade.");
   }
   rl.close();

6. 6. Summe zweier Zahlen

   Lies zwei ganze Zahlen, jede in einer eigenen Zeile, und gib ihre Summe aus.

   Eingabe

   12
   30

   Ausgabe

   Die Summe ist 42.

   Was du brauchst, steht in der Lektion: Operatoren und Arithmetik

   Lösung

   import { createInterface } from "node:readline";
   
   const rl = createInterface({ input: process.stdin });
   const lines = rl[Symbol.asyncIterator]();
   async function ask(question) {
     process.stdout.write(question);
     return (await lines.next()).value;
   }
   
   const first = Number(await ask(""));
   const second = Number(await ask(""));
   console.log("Die Summe ist " + (first + second) + ".");
   rl.close();

7. 7. Fläche eines Quadrats

   Lies die Seitenlänge eines Quadrats (eine ganze Zahl) und gib seinen Flächeninhalt aus.

   Eingabe

   5

   Ausgabe

   Der Flächeninhalt ist 25.

   Was du brauchst, steht in der Lektion: Operatoren und Arithmetik

   Lösung

   import { createInterface } from "node:readline";
   
   const rl = createInterface({ input: process.stdin });
   const lines = rl[Symbol.asyncIterator]();
   async function ask(question) {
     process.stdout.write(question);
     return (await lines.next()).value;
   }
   
   const side = Number(await ask(""));
   console.log("Der Flächeninhalt ist " + side * side + ".");
   rl.close();

8. 8. Volumen einer Kugel

   Lies den Radius r (er kann eine Dezimalzahl sein) und gib das Volumen der Kugel V = 4/3 · π · r³ mit 2 Nachkommastellen aus.

   Eingabe

   3

   Ausgabe

   Das Volumen ist 113.10.

   Was du brauchst, steht in der Lektion: Operatoren und Arithmetik

   Lösung

   import { createInterface } from "node:readline";
   
   const rl = createInterface({ input: process.stdin });
   const lines = rl[Symbol.asyncIterator]();
   async function ask(question) {
     process.stdout.write(question);
     return (await lines.next()).value;
   }
   
   const r = Number(await ask(""));
   const volume = (4 / 3) * Math.PI * r ** 3;
   console.log("Das Volumen ist " + volume.toFixed(2) + ".");
   rl.close();

9. 9. Zwei Zahlen vergleichen

   Lies zwei ganze Zahlen, jede in einer eigenen Zeile, und gib die größere aus (wenn sie gleich sind, egal welche).

   Eingabe

   8
   15

   Ausgabe

   Die größere Zahl ist 15.

   Was du brauchst, steht in der Lektion: Bedingungen

   Lösung

   import { createInterface } from "node:readline";
   
   const rl = createInterface({ input: process.stdin });
   const lines = rl[Symbol.asyncIterator]();
   async function ask(question) {
     process.stdout.write(question);
     return (await lines.next()).value;
   }
   
   const a = Number(await ask(""));
   const b = Number(await ask(""));
   if (a > b) {
     console.log("Die größere Zahl ist " + a + ".");
   } else {
     console.log("Die größere Zahl ist " + b + ".");
   }
   rl.close();

10. 10. Dreiecksprüfung

    Lies drei ganze Zahlen, jede in einer eigenen Zeile, und prüfe, ob sie die Seiten eines Dreiecks sein können: Die Summe von je zwei muss größer sein als die dritte.

    Eingabe

    3
    4
    5

    Ausgabe

    Sie können ein Dreieck bilden.

    Was du brauchst, steht in der Lektion: Bedingungen

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const a = Number(await ask(""));
    const b = Number(await ask(""));
    const c = Number(await ask(""));
    if (a + b > c && a + c > b && b + c > a) {
      console.log("Sie können ein Dreieck bilden.");
    } else {
      console.log("Sie können kein Dreieck bilden.");
    }
    rl.close();

11. 11. Note in Worten

    Lies eine Note von 2 bis 6 (6 ist die beste; die Note kann eine Dezimalzahl sein) und gib sie in Worten aus: ab 5,50 Ausgezeichnet, ab 4,50 Sehr gut, ab 3,50 Gut, ab 3,00 Ausreichend, unter 3,00 Ungenügend.

    Eingabe

    4.75

    Ausgabe

    Sehr gut

    Was du brauchst, steht in der Lektion: Bedingungen

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const grade = Number(await ask(""));
    if (grade >= 5.5) {
      console.log("Ausgezeichnet");
    } else if (grade >= 4.5) {
      console.log("Sehr gut");
    } else if (grade >= 3.5) {
      console.log("Gut");
    } else if (grade >= 3) {
      console.log("Ausreichend");
    } else {
      console.log("Ungenügend");
    }
    rl.close();

12. 12. Stunden in Sekunden

    Lies eine Anzahl Stunden (eine ganze Zahl) und gib aus, wie viele Sekunden das sind.

    Eingabe

    2

    Ausgabe

    7200 Sekunden

    Was du brauchst, steht in der Lektion: Operatoren und Arithmetik

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const hours = Number(await ask(""));
    console.log(hours * 3600 + " Sekunden");
    rl.close();

13. 13. Zählen bis N

    Lies eine ganze Zahl N und gib die Zahlen von 1 bis N aus, jede in einer neuen Zeile.

    Eingabe

    5

    Ausgabe

    1
    2
    3
    4
    5

    Was du brauchst, steht in der Lektion: Schleifen

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const n = Number(await ask(""));
    for (let i = 1; i <= n; i++) {
      console.log(i);
    }
    rl.close();

14. 14. ASCII-Wert

    Lies ein Zeichen (das erste Zeichen der Zeile) und gib seinen ASCII-Code aus, also die Zahl, als die der Computer es speichert.

    Eingabe

    A

    Ausgabe

    Der Code von A ist 65.

    Was du brauchst, steht in der Lektion: Strings: mit Text arbeiten

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const symbol = (await ask(""))[0];
    console.log("Der Code von " + symbol + " ist " + symbol.charCodeAt(0) + ".");
    rl.close();

15. 15. Quadratische Gleichung

    Lies a, b und c, jeweils in einer eigenen Zeile, und löse die Gleichung ax² + bx + c = 0. Bei zwei Lösungen gib „x1 = …, x2 = …“ aus (x1 ist die mit +√D), bei einer „x = …“, jeweils mit 2 Nachkommastellen; wenn es keine reellen Lösungen gibt oder a gleich 0 ist, sag es.

    Eingabe

    1
    -3
    2

    Ausgabe

    x1 = 2.00, x2 = 1.00

    Was du brauchst, steht in der Lektion: Bedingungen

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const a = Number(await ask(""));
    const b = Number(await ask(""));
    const c = Number(await ask(""));
    if (a === 0) {
      console.log("Das ist keine quadratische Gleichung");
    } else {
      const d = b * b - 4 * a * c;
      if (d > 0) {
        const x1 = (-b + Math.sqrt(d)) / (2 * a);
        const x2 = (-b - Math.sqrt(d)) / (2 * a);
        console.log("x1 = " + x1.toFixed(2) + ", x2 = " + x2.toFixed(2));
      } else if (d === 0) {
        console.log("x = " + (-b / (2 * a)).toFixed(2));
      } else {
        console.log("Keine reellen Lösungen");
      }
    }
    rl.close();

16. 16. Positiv oder negativ

    Lies eine ganze Zahl und gib aus, ob sie positiv, negativ oder null ist.

    Eingabe

    -4

    Ausgabe

    Negativ

    Was du brauchst, steht in der Lektion: Bedingungen

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const number = Number(await ask(""));
    if (number > 0) {
      console.log("Positiv");
    } else if (number < 0) {
      console.log("Negativ");
    } else {
      console.log("Null");
    }
    rl.close();

17. 17. Jahreszeiten

    Lies die Nummer eines Monats (1–12) und gib die Jahreszeit aus: 12, 1, 2 Winter, 3–5 Frühling, 6–8 Sommer, 9–11 Herbst. Bei jeder anderen Zahl gib „Ungültiger Monat“ aus.

    Eingabe

    4

    Ausgabe

    Frühling

    Was du brauchst, steht in der Lektion: Bedingungen

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const month = Number(await ask(""));
    if (month < 1 || month > 12) {
      console.log("Ungültiger Monat");
    } else if (month === 12 || month <= 2) {
      console.log("Winter");
    } else if (month <= 5) {
      console.log("Frühling");
    } else if (month <= 8) {
      console.log("Sommer");
    } else {
      console.log("Herbst");
    }
    rl.close();

18. 18. Zahl umdrehen

    Lies eine positive ganze Zahl und gib die Zahl mit ihren Ziffern in umgekehrter Reihenfolge aus: Aus 123 wird 321. Nullen, die dabei nach vorne kommen, verschwinden (aus 1200 wird 21). Nimm die letzte Ziffer mit % 10 und entferne sie, indem du durch 10 teilst.

    Eingabe

    9071

    Ausgabe

    1709

    Was du brauchst, steht in der Lektion: Schleifen

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    let n = Number(await ask(""));
    let reversed = 0;
    while (n > 0) {
      reversed = reversed * 10 + (n % 10);
      n = Math.floor(n / 10);
    }
    console.log(reversed);
    rl.close();

19. 19. Temperaturumrechner

    Lies eine Temperatur in Grad Celsius (sie kann eine Dezimalzahl mit Punkt sein) und gib sie in Fahrenheit mit zwei Nachkommastellen aus. Die Formel ist F = C * 9 / 5 + 32.

    Eingabe

    36.6

    Ausgabe

    97.88 °F

    Was du brauchst, steht in der Lektion: Operatoren und Arithmetik

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const celsius = Number(await ask(""));
    const fahrenheit = (celsius * 9) / 5 + 32;
    console.log(`${fahrenheit.toFixed(2)} °F`);
    rl.close();

20. 20. Längster Name

    In der ersten Zeile steht die Anzahl der Namen n, in den nächsten n Zeilen je ein Name. Gib den Namen mit den meisten Buchstaben und deren Anzahl in Klammern aus; sind zwei Namen gleich lang, gib den ersten davon aus.

    Eingabe

    4
    Mia
    Alexandra
    Jonas
    Charlotte

    Ausgabe

    Alexandra (9 Buchstaben)

    Was du brauchst, steht in der Lektion: Strings: mit Text arbeiten

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const n = Number(await ask(""));
    let longest = "";
    for (let i = 0; i < n; i++) {
      const name = await ask("");
      if (name.length > longest.length) {
        longest = name;
      }
    }
    console.log(`${longest} (${longest.length} Buchstaben)`);
    rl.close();

21. 21. Wörter zählen

    Lies eine Zeile Text und gib aus, wie viele Wörter sie hat. Die Wörter sind durch ein oder mehrere Leerzeichen getrennt, die leeren Stücke zwischen zwei Leerzeichen sind also keine Wörter.

    Eingabe

    Ich schreibe  jeden Tag Code und   werde besser

    Ausgabe

    8

    Was du brauchst, steht in der Lektion: Strings: mit Text arbeiten

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const line = await ask("");
    const words = line.split(" ").filter((word) => word !== "");
    console.log(words.length);
    rl.close();

22. 22. Primzahl

    Lies eine ganze Zahl n und prüfe, ob sie eine Primzahl ist: größer als 1 und nur durch 1 und sich selbst teilbar. Es reicht, die Teiler i zu probieren, für die i * i <= n gilt.

    Eingabe

    91

    Ausgabe

    91 ist keine Primzahl

    Was du brauchst, steht in der Lektion: Schleifen

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const n = Number(await ask(""));
    let prime = n > 1;
    for (let i = 2; i * i <= n; i++) {
      if (n % i === 0) {
        prime = false;
        break;
      }
    }
    if (prime) {
      console.log(`${n} ist eine Primzahl`);
    } else {
      console.log(`${n} ist keine Primzahl`);
    }
    rl.close();

23. 23. Wochentag

    Lies eine Zahl von 1 bis 7 und gib den Namen des Wochentags auf Deutsch aus, wobei 1 Montag ist. Halte die Namen in einem Array; bei jeder anderen Zahl gib „Diesen Tag gibt es nicht“ aus.

    Eingabe

    5

    Ausgabe

    Freitag

    Was du brauchst, steht in der Lektion: Arrays

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const day = Number(await ask(""));
    const days = ["Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag"];
    if (day >= 1 && day <= 7) {
      console.log(days[day - 1]);
    } else {
      console.log("Diesen Tag gibt es nicht");
    }
    rl.close();

24. 24. Fakultät

    Lies eine ganze Zahl n von 0 bis 15 und gib n! = 1 * 2 * … * n aus (0! ist 1). Schon 13! passt nicht in einen int, deshalb speicherst du das Produkt in Java und C# in einem long.

    Eingabe

    15

    Ausgabe

    15! = 1307674368000

    Was du brauchst, steht in der Lektion: Schleifen

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const n = Number(await ask(""));
    let factorial = 1;
    for (let i = 2; i <= n; i++) {
      factorial *= i;
    }
    console.log(`${n}! = ${factorial}`);
    rl.close();

25. 25. Gültiges Datum

    Lies einen Tag, einen Monat und ein Jahr, jeweils in einer eigenen Zeile, und gib „Gültiges Datum“ oder „Ungültiges Datum“ aus. Das Jahr ist mindestens 1, der Monat liegt zwischen 1 und 12 und der Tag zwischen 1 und der Anzahl der Tage in diesem Monat; der Februar hat in einem Schaltjahr 29 Tage (durch 4 teilbar, aber nicht durch 100, außer es ist durch 400 teilbar).

    Eingabe

    29
    2
    2100

    Ausgabe

    Ungültiges Datum

    Was du brauchst, steht in der Lektion: Bedingungen

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const day = Number(await ask(""));
    const month = Number(await ask(""));
    const year = Number(await ask(""));
    const leap = (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
    let days;
    if (month === 2) {
      days = leap ? 29 : 28;
    } else if (month === 4 || month === 6 || month === 9 || month === 11) {
      days = 30;
    } else {
      days = 31;
    }
    if (year >= 1 && month >= 1 && month <= 12 && day >= 1 && day <= days) {
      console.log("Gültiges Datum");
    } else {
      console.log("Ungültiges Datum");
    }
    rl.close();

26. 26. Buchstabenhäufigkeit

    Lies eine Zeile Text und gib aus, wie oft jeder Buchstabe darin vorkommt, egal ob groß oder klein geschrieben. Gib die Buchstaben in alphabetischer Reihenfolge aus, einen pro Zeile, in der Form „a: 5“; Leerzeichen und Satzzeichen werden nicht gezählt.

    Eingabe

    Banane und Ananas!

    Ausgabe

    a: 5
    b: 1
    d: 1
    e: 1
    n: 5
    s: 1
    u: 1

    Was du brauchst, steht in der Lektion: Map und Set

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const text = (await ask("")).toLowerCase();
    const counts = new Map();
    for (const c of text) {
      if (/\p{L}/u.test(c)) {
        counts.set(c, (counts.get(c) ?? 0) + 1);
      }
    }
    for (const c of [...counts.keys()].sort()) {
      console.log(`${c}: ${counts.get(c)}`);
    }
    rl.close();

27. 27. Minimum und Maximum in einem Array

    In der ersten Zeile steht die Anzahl n, in den nächsten n Zeilen je eine ganze Zahl. Lies sie in ein Array und gib die kleinste und die größte aus: Beginne beim ersten Element und vergleiche es mit den übrigen.

    Eingabe

    5
    7
    -3
    12
    0
    4

    Ausgabe

    Kleinste Zahl: -3
    Größte Zahl: 12

    Was du brauchst, steht in der Lektion: Arrays

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const n = Number(await ask(""));
    const numbers = [];
    for (let i = 0; i < n; i++) {
      numbers.push(Number(await ask("")));
    }
    let min = numbers[0];
    let max = numbers[0];
    for (let i = 1; i < n; i++) {
      if (numbers[i] < min) {
        min = numbers[i];
      }
      if (numbers[i] > max) {
        max = numbers[i];
      }
    }
    console.log(`Kleinste Zahl: ${min}`);
    console.log(`Größte Zahl: ${max}`);
    rl.close();

28. 28. Array sortieren

    In der ersten Zeile steht die Anzahl n, in den nächsten n Zeilen je eine ganze Zahl. Sortiere sie selbst aufsteigend mit Bubblesort (n - 1 Durchläufe, in jedem tauschst du Nachbarn, die in der falschen Reihenfolge stehen) und gib sie in einer Zeile aus, getrennt durch Leerzeichen.

    Eingabe

    6
    5
    2
    9
    1
    5
    6

    Ausgabe

    1 2 5 5 6 9

    Was du brauchst, steht in der Lektion: Arrays

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const n = Number(await ask(""));
    const numbers = [];
    for (let i = 0; i < n; i++) {
      numbers.push(Number(await ask("")));
    }
    for (let pass = 0; pass < n - 1; pass++) {
      for (let i = 0; i < n - 1 - pass; i++) {
        if (numbers[i] > numbers[i + 1]) {
          const temp = numbers[i];
          numbers[i] = numbers[i + 1];
          numbers[i + 1] = temp;
        }
      }
    }
    console.log(numbers.join(" "));
    rl.close();

29. 29. Vokale ersetzen

    Lies eine Zeile Text und gib sie aus, wobei jeder Vokal, groß oder klein, durch das Zeichen * ersetzt ist. Die Vokale sind a, e, i, o, u, ä, ö, ü.

    Eingabe

    Übung macht den Meister

    Ausgabe

    *b*ng m*cht d*n M**st*r

    Was du brauchst, steht in der Lektion: Strings: mit Text arbeiten

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const text = await ask("");
    const vowels = "aeiouäöü";
    let result = "";
    for (const c of text) {
      if (vowels.includes(c.toLowerCase())) {
        result += "*";
      } else {
        result += c;
      }
    }
    console.log(result);
    rl.close();

30. 30. Quersumme

    Lies eine nicht negative ganze Zahl und gib die Summe ihrer Ziffern aus. Die letzte Ziffer ist n % 10, und n / 10 entfernt sie (in Python n // 10).

    Eingabe

    9875

    Ausgabe

    29

    Was du brauchst, steht in der Lektion: Schleifen

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    let n = Number(await ask(""));
    let sum = 0;
    while (n > 0) {
      sum += n % 10;
      n = Math.floor(n / 10);
    }
    console.log(sum);
    rl.close();

31. 31. Palindrom

    Lies eine Zeile Text und prüfe, ob sie ein Palindrom ist, sich also rückwärts genauso liest. Groß- und Kleinbuchstaben gelten als gleich, Leerzeichen werden übersprungen. Gib „Palindrom“ oder „Kein Palindrom“ aus.

    Eingabe

    Lagerregal

    Ausgabe

    Palindrom

    Was du brauchst, steht in der Lektion: Strings: mit Text arbeiten

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const text = (await ask("")).toLowerCase().replaceAll(" ", "");
    let palindrome = true;
    for (let i = 0; i < text.length / 2; i++) {
      if (text[i] !== text[text.length - 1 - i]) {
        palindrome = false;
        break;
      }
    }
    if (palindrome) {
      console.log("Palindrom");
    } else {
      console.log("Kein Palindrom");
    }
    rl.close();

32. 32. Sicheres Passwort

    Lies Passwörter, eines pro Zeile, bis ein sicheres kommt: mindestens 8 Zeichen, mindestens eine Ziffer, ein Großbuchstabe und ein Kleinbuchstabe. Gib für jedes schwache die erste nicht erfüllte Regel in dieser Reihenfolge aus („Zu kurz“, „Keine Ziffer“, „Kein Großbuchstabe“, „Kein Kleinbuchstabe“), für das sichere „Passwort akzeptiert“, und hör dann auf.

    Eingabe

    katze
    katzemiau
    katzemiau7
    Katzemiau7

    Ausgabe

    Zu kurz
    Keine Ziffer
    Kein Großbuchstabe
    Passwort akzeptiert

    Was du brauchst, steht in der Lektion: Strings: mit Text arbeiten

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    while (true) {
      const password = await ask("");
      let digit = false;
      let upper = false;
      let lower = false;
      for (const c of password) {
        if (c >= "0" && c <= "9") {
          digit = true;
        } else if (c !== c.toLowerCase()) {
          upper = true;
        } else if (c !== c.toUpperCase()) {
          lower = true;
        }
      }
      if (password.length < 8) {
        console.log("Zu kurz");
      } else if (!digit) {
        console.log("Keine Ziffer");
      } else if (!upper) {
        console.log("Kein Großbuchstabe");
      } else if (!lower) {
        console.log("Kein Kleinbuchstabe");
      } else {
        console.log("Passwort akzeptiert");
        break;
      }
    }
    rl.close();

33. 33. Array umdrehen

    In der ersten Zeile steht die Anzahl n, in den nächsten n Zeilen je eine ganze Zahl. Lies sie in ein Array und gib sie in umgekehrter Reihenfolge in einer Zeile aus, getrennt durch Leerzeichen: Durchlaufe das Array vom letzten Index bis zum Index 0.

    Eingabe

    4
    10
    -2
    7
    3

    Ausgabe

    3 7 -2 10

    Was du brauchst, steht in der Lektion: Arrays

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const n = Number(await ask(""));
    const numbers = [];
    for (let i = 0; i < n; i++) {
      numbers.push(Number(await ask("")));
    }
    let line = "";
    for (let i = n - 1; i >= 0; i--) {
      line += numbers[i];
      if (i > 0) {
        line += " ";
      }
    }
    console.log(line);
    rl.close();

34. 34. Elemente zählen

    Lies eine Zeile mit Wörtern, getrennt durch je ein Leerzeichen, und gib aus, wie oft jedes Wort vorkommt, in der Form „Wort: Anzahl“. Die Wörter erscheinen in der Reihenfolge, in der sie zum ersten Mal vorkamen.

    Eingabe

    Apfel Birne Apfel Pflaume Birne Apfel

    Ausgabe

    Apfel: 3
    Birne: 2
    Pflaume: 1

    Was du brauchst, steht in der Lektion: Map und Set

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const line = await ask("");
    const counts = new Map();
    for (const word of line.split(" ")) {
      counts.set(word, (counts.get(word) ?? 0) + 1);
    }
    for (const [word, count] of counts) {
      console.log(`${word}: ${count}`);
    }
    rl.close();

35. 35. Primzahlen

    Lies eine Zahl N und gib alle Primzahlen von 2 bis N in einer Zeile aus, getrennt durch Leerzeichen.

    Eingabe

    30

    Ausgabe

    2 3 5 7 11 13 17 19 23 29

    Was du brauchst, steht in der Lektion: Schleifen

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const n = Number(await ask(""));
    const primes = [];
    for (let i = 2; i <= n; i++) {
      let prime = true;
      for (let d = 2; d * d <= i; d++) {
        if (i % d === 0) {
          prime = false;
          break;
        }
      }
      if (prime) {
        primes.push(i);
      }
    }
    console.log(primes.join(" "));
    rl.close();

36. 36. Durchschnitt

    In einer Zeile stehen ganze Zahlen, getrennt durch Leerzeichen. Gib ihren Durchschnitt mit zwei Nachkommastellen aus.

    Eingabe

    5 8 12 6

    Ausgabe

    Durchschnitt: 7.75

    Was du brauchst, steht in der Lektion: Arrays

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const parts = (await ask("")).split(" ");
    let sum = 0;
    for (let i = 0; i < parts.length; i++) {
      sum += Number(parts[i]);
    }
    const average = sum / parts.length;
    console.log("Durchschnitt: " + average.toFixed(2));
    rl.close();

37. 37. Nach Länge sortieren

    In einer Zeile stehen Wörter, getrennt durch Leerzeichen. Sortiere sie nach Länge vom kürzesten zum längsten (Wörter gleicher Länge behalten ihre Reihenfolge aus der Eingabe) und gib sie in einer Zeile aus.

    Eingabe

    Kirsche Feige Banane Kiwi Pflaume

    Ausgabe

    Kiwi Feige Banane Kirsche Pflaume

    Was du brauchst, steht in der Lektion: Strings: mit Text arbeiten

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const words = (await ask("")).split(" ");
    for (let i = 0; i < words.length - 1; i++) {
      for (let j = 0; j < words.length - 1 - i; j++) {
        if (words[j].length > words[j + 1].length) {
          const temp = words[j];
          words[j] = words[j + 1];
          words[j + 1] = temp;
        }
      }
    }
    console.log(words.join(" "));
    rl.close();

38. 38. Sätze zählen

    Lies eine Zeile Text und gib aus, wie viele Sätze sie hat. Ein Satz endet mit einem Punkt, einem Ausrufezeichen oder einem Fragezeichen; eine Folge solcher Zeichen (wie „...“ oder „?!“) ist ein einziges Ende.

    Eingabe

    Hallo! Wie geht es dir? Mir geht es gut... Und dir?!

    Ausgabe

    Sätze: 4

    Was du brauchst, steht in der Lektion: Strings: mit Text arbeiten

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const text = await ask("");
    const ends = ".!?";
    let count = 0;
    for (let i = 0; i < text.length; i++) {
      const isEnd = ends.includes(text[i]);
      const nextIsEnd = i + 1 < text.length && ends.includes(text[i + 1]);
      if (isEnd && !nextIsEnd) {
        count++;
      }
    }
    console.log("Sätze: " + count);
    rl.close();

39. 39. Fibonacci-Zahlen

    Die Fibonacci-Folge beginnt mit 1, 1, und jede weitere Zahl ist die Summe der beiden vorherigen. Lies N (von 1 bis 50) und gib die N-te Zahl der Folge aus.

    Eingabe

    40

    Ausgabe

    102334155

    Was du brauchst, steht in der Lektion: Schleifen

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const n = Number(await ask(""));
    let previous = 0;
    let current = 1;
    for (let i = 1; i < n; i++) {
      const next = previous + current;
      previous = current;
      current = next;
    }
    console.log(current);
    rl.close();

40. 40. Den Median finden

    In einer Zeile stehen ganze Zahlen, getrennt durch Leerzeichen. Gib ihren Median mit einer Nachkommastelle aus: die mittlere Zahl nach dem Sortieren oder, bei einer geraden Anzahl, den Mittelwert der beiden mittleren.

    Eingabe

    12 3 7 9 1 8

    Ausgabe

    Median: 7.5

    Was du brauchst, steht in der Lektion: Arrays: push, splice und sort

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const numbers = [];
    for (const part of (await ask("")).split(" ")) {
      numbers.push(Number(part));
    }
    numbers.sort((a, b) => a - b);
    const n = numbers.length;
    let median;
    if (n % 2 === 1) {
      median = numbers[Math.floor(n / 2)];
    } else {
      median = (numbers[n / 2 - 1] + numbers[n / 2]) / 2;
    }
    console.log("Median: " + median.toFixed(1));
    rl.close();

41. 41. Zeichendiagramm

    Lies eine Zeile Text. Gib für jedes Zeichen außer dem Leerzeichen, in der Reihenfolge seines ersten Auftretens, eine Zeile „Zeichen | Sternchen“ aus, mit einem Sternchen für jedes Vorkommen im Text.

    Eingabe

    Banane Brot

    Ausgabe

    B | **
    a | **
    n | **
    e | *
    r | *
    o | *
    t | *

    Was du brauchst, steht in der Lektion: Strings: mit Text arbeiten

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const text = await ask("");
    for (let i = 0; i < text.length; i++) {
      const c = text[i];
      if (c !== " " && text.indexOf(c) === i) {
        let count = 0;
        for (let j = 0; j < text.length; j++) {
          if (text[j] === c) {
            count++;
          }
        }
        console.log(c + " | " + "*".repeat(count));
      }
    }
    rl.close();

42. 42. Matrix transponieren

    In der ersten Zeile stehen die Anzahl der Zeilen R und die Anzahl der Spalten C, danach folgen R Zeilen mit je C Zahlen, getrennt durch Leerzeichen. Gib die transponierte Matrix aus: C Zeilen mit je R Zahlen, wobei die Zeilen zu Spalten werden.

    Eingabe

    2 3
    1 2 3
    4 5 6

    Ausgabe

    1 4
    2 5
    3 6

    Was du brauchst, steht in der Lektion: Zweidimensionale Arrays

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const size = (await ask("")).split(" ");
    const rows = Number(size[0]);
    const cols = Number(size[1]);
    const matrix = [];
    for (let r = 0; r < rows; r++) {
      matrix.push((await ask("")).split(" ").map(Number));
    }
    for (let c = 0; c < cols; c++) {
      const line = [];
      for (let r = 0; r < rows; r++) {
        line.push(matrix[r][c]);
      }
      console.log(line.join(" "));
    }
    rl.close();

43. 43. Wege im Labyrinth

    In der ersten Zeile stehen R und C, danach folgen R Zeilen mit je C Zeichen: „.“ ist eine freie Zelle, „#“ eine Wand. Du gehst nur nach rechts oder nach unten und trittst nie auf eine Wand. Gib die Anzahl aller Wege von der oberen linken zur unteren rechten Ecke aus.

    Eingabe

    4 5
    .....
    .#.#.
    ...#.
    #....

    Ausgabe

    Wege: 4

    Was du brauchst, steht in der Lektion: Rekursion

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    function countPaths(maze, r, c) {
      if (r >= maze.length || c >= maze[0].length || maze[r][c] === "#") {
        return 0;
      }
      if (r === maze.length - 1 && c === maze[0].length - 1) {
        return 1;
      }
      return countPaths(maze, r + 1, c) + countPaths(maze, r, c + 1);
    }
    
    const size = (await ask("")).split(" ");
    const rows = Number(size[0]);
    const maze = [];
    for (let r = 0; r < rows; r++) {
      maze.push(await ask(""));
    }
    console.log("Wege: " + countPaths(maze, 0, 0));
    rl.close();

44. 44. Notenstatistik

    In einer Zeile stehen Noten von 2 bis 6 (6 ist die beste), getrennt durch Leerzeichen. Gib aus, wie viele davon Ausgezeichnet, Sehr gut, Gut, Ausreichend und Ungenügend sind, jede Kategorie in einer eigenen Zeile.

    Eingabe

    6 4 5 6 3 5 2 6 5 4

    Ausgabe

    Ausgezeichnet (6): 3
    Sehr gut (5): 3
    Gut (4): 2
    Ausreichend (3): 1
    Ungenügend (2): 1

    Was du brauchst, steht in der Lektion: Arrays

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const names = ["", "", "Ungenügend", "Ausreichend", "Gut", "Sehr gut", "Ausgezeichnet"];
    const counts = [0, 0, 0, 0, 0, 0, 0];
    const parts = (await ask("")).split(" ");
    for (let i = 0; i < parts.length; i++) {
      counts[Number(parts[i])]++;
    }
    for (let grade = 6; grade >= 2; grade--) {
      console.log(names[grade] + " (" + grade + "): " + counts[grade]);
    }
    rl.close();

45. 45. Römische Zahlen

    Lies eine ganze Zahl von 1 bis 3999 und gib sie in römischen Zahlen aus (I, V, X, L, C, D, M, wobei 4 IV ist, 9 IX, 40 XL und so weiter).

    Eingabe

    1994

    Ausgabe

    MCMXCIV

    Was du brauchst, steht in der Lektion: Arrays

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    let number = Number(await ask(""));
    const values = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1];
    const symbols = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"];
    let roman = "";
    for (let i = 0; i < values.length; i++) {
      while (number >= values[i]) {
        roman += symbols[i];
        number -= values[i];
      }
    }
    console.log(roman);
    rl.close();

46. 46. Münzwurf-Simulation

    Lies einen Startwert (Seed) x (von 1 bis 2147483646) und eine Anzahl Würfe N, jeweils in einer eigenen Zeile. Setze bei jedem Wurf x = x * 16807 % 2147483647; ein gerades x ist Kopf (K), ein ungerades Zahl (Z). Gib die Würfe in einer Zeile aus, danach, wie oft Kopf und wie oft Zahl gefallen ist.

    Eingabe

    42
    10

    Ausgabe

    KZZZKZZKKZ
    Kopf: 4
    Zahl: 6

    Was du brauchst, steht in der Lektion: Schleifen

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    let x = Number(await ask(""));
    const n = Number(await ask(""));
    let tosses = "";
    let heads = 0;
    for (let i = 0; i < n; i++) {
      x = x * 16807 % 2147483647;
      if (x % 2 === 0) {
        tosses += "K";
        heads++;
      } else {
        tosses += "Z";
      }
    }
    console.log(tosses);
    console.log("Kopf: " + heads);
    console.log("Zahl: " + (n - heads));
    rl.close();

47. 47. Symmetrisches Array

    In einer Zeile stehen ganze Zahlen, getrennt durch Leerzeichen. Prüfe, ob das Array symmetrisch ist, sich also von links nach rechts und von rechts nach links gleich liest.

    Eingabe

    1 2 3 2 1

    Ausgabe

    Symmetrisch

    Was du brauchst, steht in der Lektion: Arrays

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const numbers = (await ask("")).split(" ").map(Number);
    let symmetric = true;
    for (let i = 0; i < Math.floor(numbers.length / 2); i++) {
      if (numbers[i] !== numbers[numbers.length - 1 - i]) {
        symmetric = false;
        break;
      }
    }
    console.log(symmetric ? "Symmetrisch" : "Nicht symmetrisch");
    rl.close();

48. 48. Balancierte Klammern

    Lies eine Zeile Text und prüfe, ob die Klammern (), [] und {} darin balanciert sind: Jede öffnende Klammer hat ihre schließende derselben Art, und die Paare überkreuzen sich nicht. Andere Zeichen zählen nicht.

    Eingabe

    (a + [b) * c]

    Ausgabe

    Nicht balanciert

    Was du brauchst, steht in der Lektion: Stack, Queue und verkettete Liste

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const text = await ask("");
    const opening = "([{";
    const closing = ")]}";
    const stack = [];
    let balanced = true;
    for (const c of text) {
      if (opening.includes(c)) {
        stack.push(c);
      } else if (closing.includes(c)) {
        if (stack.length === 0 || opening.indexOf(stack.pop()) !== closing.indexOf(c)) {
          balanced = false;
          break;
        }
      }
    }
    if (balanced && stack.length === 0) {
      console.log("Balanciert");
    } else {
      console.log("Nicht balanciert");
    }
    rl.close();

49. 49. Folge gleicher Elemente

    In einer Zeile stehen ganze Zahlen, getrennt durch Leerzeichen. Finde die längste Folge gleicher benachbarter Zahlen und gib sie in einer Zeile aus; gibt es mehrere gleich lange, gib die erste aus.

    Eingabe

    2 1 1 3 3 3 2 2 2 5

    Ausgabe

    3 3 3

    Was du brauchst, steht in der Lektion: Arrays

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const numbers = (await ask("")).split(" ").map(Number);
    let bestValue = numbers[0];
    let bestLength = 1;
    let length = 1;
    for (let i = 1; i < numbers.length; i++) {
      if (numbers[i] === numbers[i - 1]) {
        length++;
      } else {
        length = 1;
      }
      if (length > bestLength) {
        bestLength = length;
        bestValue = numbers[i];
      }
    }
    const run = [];
    for (let i = 0; i < bestLength; i++) {
      run.push(bestValue);
    }
    console.log(run.join(" "));
    rl.close();

50. 50. Kürzester Weg in einer Matrix

    In der ersten Zeile stehen R und C, danach folgen R Zeilen mit je C Zeichen: „.“ ist eine freie Zelle, „#“ eine Wand, „S“ der Start und „E“ das Ziel. Du darfst nach oben, unten, links und rechts gehen. Gib die kleinste Anzahl Schritte von S nach E aus oder „Kein Weg“, wenn E nicht erreichbar ist.

    Eingabe

    5 6
    S.#...
    .##.#.
    ...#..
    #.#..#
    ...E.#

    Ausgabe

    7

    Was du brauchst, steht in der Lektion: Stack, Queue und verkettete Liste

    Lösung

    import { createInterface } from "node:readline";
    
    const rl = createInterface({ input: process.stdin });
    const lines = rl[Symbol.asyncIterator]();
    async function ask(question) {
      process.stdout.write(question);
      return (await lines.next()).value;
    }
    
    const size = (await ask("")).split(" ");
    const rows = Number(size[0]);
    const cols = Number(size[1]);
    const grid = [];
    for (let r = 0; r < rows; r++) {
      grid.push(await ask(""));
    }
    const dist = [];
    const queue = [];
    for (let r = 0; r < rows; r++) {
      dist.push([]);
      for (let c = 0; c < cols; c++) {
        dist[r].push(-1);
        if (grid[r][c] === "S") {
          dist[r][c] = 0;
          queue.push([r, c]);
        }
      }
    }
    const dr = [-1, 1, 0, 0];
    const dc = [0, 0, -1, 1];
    let answer = "Kein Weg";
    while (queue.length > 0) {
      const [r, c] = queue.shift();
      if (grid[r][c] === "E") {
        answer = String(dist[r][c]);
        break;
      }
      for (let d = 0; d < 4; d++) {
        const nr = r + dr[d];
        const nc = c + dc[d];
        if (nr >= 0 && nr < rows && nc >= 0 && nc < cols && grid[nr][nc] !== "#" && dist[nr][nc] === -1) {
          dist[nr][nc] = dist[r][c] + 1;
          queue.push([nr, nc]);
        }
      }
    }
    console.log(answer);
    rl.close();

Aufgaben aus den Lektionen

Sprachgrundlagen

• Dein erstes Programm: Hello World · Visitenkarte · Rahmen
• Variablen und Typen: Tausch · Alter · Eine Hotelkarte
• Eingabe und Ausgabe: Begrüßung mit Namen · Summe zweier Zahlen · Zwei Texte in einem · π mit zwei Stellen
• Operatoren und Arithmetik: Durchschnitt von drei Zahlen · Sekunden in Stunden · Volumen einer Kugel · Celsius in Fahrenheit
• Bedingungen: Eine Kinokarte · Ein Mini-Taschenrechner · Eine quadratische Gleichung · Ein gültiges Datum
• Schleifen: Einmaleins · Primzahl · Die Ziffern einer Zahl · Zahlenraten
• Arrays: Summe, gerade, ungerade · Umgekehrt · Kleinste, größte, Durchschnitt
• Arrays: Sortieren · Längste Folge · Notenstatistik
• Zweidimensionale Arrays: Diagonalen und Zeilen · Dreh die Tabelle um
• Zweidimensionale Arrays: Wie viele Wege gibt es? · Der kürzeste Weg
• Strings: mit Text arbeiten: Der Name rückwärts · Anzahl der Wörter · Palindrom
• Strings: mit Text arbeiten: Sicheres Passwort

Funktionen

• Funktionen: Kassenbon · Dreieck
• Parameter und return: Durchschnitt · Primzahl · Temperaturen · Taschenrechner · Ein Dreieck mit Parameter
• Parameter und return
• Standardwerte: Die größte · Notendurchschnitt · Eine Zeile auf dem Bon · Kostenlose Lieferung
• Rekursion: Fakultät auf zwei Arten · Quersumme · Fibonacci · Palindrom

Klassen und Objekte

• Klassen und Objekte: Buch · Auto · Der Warenkorb · Das Teuerste zuerst
• Konstruktoren und this: Person · Tier · Tanzschritt
• Instanzmethoden
• Instanzmethoden
• Kapselung: Person · Ein Konto ohne Minus · Tier
• static: was alle Objekte teilen: Bestellungen · Taschenrechner · Wechselstube

Vererbung und Polymorphie

• Vererbung: Familienauto · Studentin · Breakdance · Elektroauto
• Polymorphie: Tierheim · Die Studentin stellt sich vor · Party
• Abstrakte Klassen ohne abstract: Fläche und Umfang · Tiere
• Abstrakte Klassen ohne abstract: Fahrzeuge · Auftritte
• Interfaces ohne interface: Hupe · Angaben · Tanz · DJ · Der Teich
• Typprüfungen: Parkplatz · Tänze · Fuhrpark · Zoo
• OOP-Prinzipien
• OOP-Prinzipien: Ein freier Mitarbeiter · Die Terrasse ohne if

Fehler und Exceptions

• Exceptions: Text zu Zahl · Kein solches Produkt · Durchschnittliche Bestellung
• try, catch und finally: Preis pro Person · Taschenrechner
• Werfen und eigene Exceptions: Musikgeschäft · Ein Konto mit Regeln · Ungültiges Alter

Text und Dateien

• Strings: Palindrom · Ein Kassenbon mit Spalten · Wörter rückwärts
• Reguläre Ausdrücke: Datum · Handynummer · E-Mail · Einkaufsliste
• Reguläre Ausdrücke: Gruppen und Ersetzen: Suchen und ersetzen · Wörter mit einem Präfix · Adressen im Text · Daten nach ISO
• Dateien: Eine Konfigurationsdatei · Ein Filter für eine Logdatei · Der Inhalt eines Ordners · Eine Indexdatei
• Daten in Dateien: CSV-Auswertung · Den Helden speichern · Doppelter Text

Collections

• Arrays: push, splice und sort: Ein Bücherregal · Ein Ereignisprotokoll · Ein Notizbuch · Kopfrechnen
• Stack, Queue und verkettete Liste: Ein Spielzeugzug · Eine Buslinie · Ein Börsenticker · Ausgeglichene Klammern · Deine eigene verkettete Liste
• Map und Set: Eine Benutzertabelle · Worthäufigkeit · Dokumente nach Stichwort · Ein Kontaktnetz
• Hashcodes und Hashfunktionen: Ein Schlüssel für eine Person · Der Roboter im Lager · Ein Hash einer Datei
• Klassen und Daten in Klassen: Warenkorb · Monitor für einen Webserver · Hausverwaltung · Rangliste

Modernes JavaScript

• Pfeilfunktionen: Sortieren nach mehreren Feldern · Bestellungen filtern · Rabatte nacheinander
• Array-Methoden: Verkäufe nach Kategorie · Die Top 3 der Produkte · Die Durchschnittsnote · Die Wörter in einem Text
• Daten, switch und Destrukturierung: Formen · Lieferpreis · Ein Punkt als Schlüssel
• Entwurfsmuster: Rabatte als Strategien · „Benachrichtige mich, wenn es wieder da ist“ · Eine Fabrik für Benachrichtigungen · Ein altes Thermometer

Programme in der echten Welt

• Tests mit node:test: Der Rabattrechner · Das Konto · Der Fehler im Notendurchschnitt
• Async, await und Threads: Parallele Summe · Herunterladen mit einem Pool · Ein Zähler ohne Verluste
• Netzwerkprogrammierung: Echo-Server · Ein Server mit Befehlen · Ein Chat für zwei
• Datenbanken: Katalog · Suche nach einem Teil des Namens · Eine Überweisung, die mittendrin fehlschlägt
• Reflection: Alle Felder und die Kette · Mini-JSON · Dein eigener Test-Runner

Wir bauen ein Spiel

• Wie du über ein Spiel nachdenkst: Ein Rennen für zwei · Zahl raten · Wer hat Tic-Tac-Toe gewonnen?
• RPG 1: die Helden: Ein sechster Held · Die Liste der Gruppe · Wer ist der Stärkste?
• RPG 2: die Schlacht: Ein neues Monster · Ein Heiltrank · Ein Kampfbericht
• RPG 3: das ganze Spiel: Ein Menü · Fortschritt · Ein Boss
• Epic Cosmos 1: die Objekte im All: Das Sonnensystem · Abstand · Der ganze Baum
• Epic Cosmos 2: Ressourcen, Gebäude, Schiffe: 100 Metall so schnell wie möglich · Ein Frachter · Eine Simulation über 10 Züge
• Das verschlossene Labor 1: Räume und Befehle: Inventar · Ein neuer Raum · Synonyme
• Das verschlossene Labor 2: Rätsel und der Ausweg: Der dunkle Keller · Ein Timer · Ein Hinweis für einen Zug

Die Chroniken von Arkanum

• Die Spielschleife
• Ein Stapel von Bildschirmen
• Bildschirme, die eine Antwort zurückgeben
• In der Konsole zeichnen
• Die Karte und das Sichtfeld
• Helden, Feinde, Werte
• Das Kampfsystem
• Blut, Wunden und Effekte
• Fähigkeiten und Aktionen als Befehle
• Gegner, die denken
• Gegenstände, Inventar, Beute
• Stufen, Dialoge und Quests
• Speichern und Laden
• Das ganze Spiel und die Balance

Epic Cosmos: das Imperium

• Die Galaxie aus einem Startwert
• Der Technologiebaum
• Flotten und die Weltraumschlacht
• Die Rivalen
• Der Zug der Galaxie
• Die ganze Strategie

Projekt

• Hotelbuchungen: Zimmerwechsel