Table of Contents

Refresher

Folgende Aufgaben sollen helfen, die grundlegenden Elemente von JavaScript zu repetieren und zu festigen.

Ziel ist jeweils eine einfache Konsolenausgabe.

Hilfe gibts im Cheat-Sheet

Loops

Produzieren Sie folgende Ausgabe auf der Konsole:

10 im Quadrat ist 100
11 im Quadrat ist 121
12 im Quadrat ist 144
13 im Quadrat ist 169
14 im Quadrat ist 196
15 im Quadrat ist 225
16 im Quadrat ist 256
17 im Quadrat ist 289
18 im Quadrat ist 324
19 im Quadrat ist 361
20 im Quadrat ist 400

Produzieren Sie folgende Ausgabe:

+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 0 | 1 | 2 | 0 | 1 |
+---+---+---+---+---+---+---+---+
| 1 | 2 | 0 | 1 | 2 | 0 | 1 | 2 |
+---+---+---+---+---+---+---+---+
| 2 | 0 | 1 | 2 | 0 | 1 | 2 | 0 |
+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 0 | 1 | 2 | 0 | 1 |
+---+---+---+---+---+---+---+---+
| 1 | 2 | 0 | 1 | 2 | 0 | 1 | 2 |
+---+---+---+---+---+---+---+---+
| 2 | 0 | 1 | 2 | 0 | 1 | 2 | 0 |
+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 0 | 1 | 2 | 0 | 1 |
+---+---+---+---+---+---+---+---+
| 1 | 2 | 0 | 1 | 2 | 0 | 1 | 2 |
+---+---+---+---+---+---+---+---+

Arrays

  • Produzieren Sie ein Array, das mit 100 ganzzahligen Zufallszahlen zwischen 0 und mit 99 gefüllt ist. Hinweise: Math.floor, Math.random, Array.from({length:100}, …)
  • Aus einem Array mit zufälligen Zahlen entfernen Sie all jene, die durch 3 oder 5 teilbar sind. Hinweis: Entweder ein neues Array bauen (push), oder die filter-Methode gebrauchen.
  • Aus zwei Arrays ['Eichel', 'Rose', 'Schellen', 'Schilten'], ['6', '7', … ,'König', 'Ass'] produzieren Sie ein Array mit allen Jass-Karten: ['Eichel 6', 'Eichel 7',…, 'Rose Under', … 'Schellen König', .. 'Schilten Ass'].
  • Programmieren Sie eine Funktion, die ein Array wie folgt zufällig ordnet: Für die erste Stelle wählt man ein beliebiges Element aus (evtl. auch das erste), und vertauscht die beiden Elemente miteinander. Aus den verbleibenden Elementen wählt man ein zufälliges aus und vertauscht es mit dem Element an zweiter Stelle etc.

Funktionen

Strings

  • Zerlegen Sie einen String in ein Array mit den einzelnen Buchstaben. D.h. aus “Hallo” wird ['H', 'a', 'l', 'l', 'o']. Es gibt eine String-Methode um String aufzusplitten!
  • Gegeben ist als String eine Zeile mit Zahlen, jeweils durch Leerschläge getrennt. Machen Sie ein Array mit Zahlen (nicht Strings) daraus. Z.B. wird aus dem String “12 43 65 78” das Array [12, 43, 65, 78]. Die Funktion Number macht aus einem String eine Zahl.

Objects

let wardrobes = {"Liam":{"doors":5,"drawers":12,"price":544},"Samuel":{"doors":5,"drawers":12,"price":549},"Cinthia":{"doors":2,"drawers":5,"price":278},"Demetrius":{"doors":2,"drawers":6,"price":275},"Shyann":{"doors":5,"drawers":10,"price":512},"Karl":{"doors":4,"drawers":9,"price":460},"Kimberly":{"doors":4,"drawers":10,"price":475},"Tatiana":{"doors":4,"drawers":9,"price":427},"Issac":{"doors":3,"drawers":8,"price":385},"Stewart":{"doors":5,"drawers":10,"price":496}};
  • Geben Sie die Namen aller Schränke aus, die 4 Türen haben.
  • Berechnen Sie die Summe aller Preise.
  • Fügen Sie neue Kästen hinzu, die es in allen Kombinationen von 2 bis 5 Türen und 0 bis 8 Schubladen gibt. Der Preis ergibt sich jeweils aus dem Dreissigfachen der Anzahl Türen plus das Zehnfache der Anzahl Schubladen. Die Kästen haben die Nämen “FlexBox-a-b”, wobei a die Anzahl Türen und b die Anzahl Schubladen ist.

Lösungen

Lösungsvorschlag

Lösungsvorschlag

for (let i=10; i<21; i++) {
  console.log(`${i} im Quadrat ist ${i*i}`)
}
let n=8;
let trenner = "+";
for (let x=0; x<n; x++) {
   trenner += "---+";
}
trenner += "\n";
feld = trenner;
for (let y=0; y<n; y++) {
   feld += "|"
   for (let x=0; x<n; x++) {
      feld += ` ${(x+y)%3} |`;
   }
   feld += "\n"+trenner;
}
console.log(feld);
let a = [];
let n = 20;
for (let i=0; i<n; i++) {
   a.push(30-i);
}
console.log(a);
function addLine(a) {
  let last = a[a.length-1]; // Letzte Zeile
  let line = [];  // Neue Zeile
  for (let i=0; i<last.length+1; i++) {
    if (i==0 || i==last.length) {  // Am Rand eine 1 einfügen
      line.push(1);
    } else {
      line.push(last[i-1]+last[i]);  // Sonst die Summe der darüberliegenden Elemente
    }
  }
  a.push(line);  // Verändert das übergebene Array!
}
let pascal = [[1]];
for (let i=0; i<10; i++) {
   addLine(pascal);
}
console.log(pascal);
let a = Array.from({length:100}, ()=>Math.floor(Math.random()*100));
// Alternative:
a = new Array(100).fill(0).map(()=>Math.floor(Math.random()*100));
 
// Alternative 2 (ohne fancy Array-Methoden):
a = [];
for (let i=0; i<100; i++) {
  a.push(Math.floor(Math.random()*100));
}
// Voraussetzung: in a ist ein Array gespeichert
let b = a.filter((e)=>!(e%3==0 || e%5==0));
 
// Alternative ohne filter:
let b = [];
for (let z of a) {
  if (z%3!=0 && z%5!=0) {
     b.push(z);
  }
}
function fortsetzen(folge) {
  let paare = 0;
  kandidat = folge[folge.length-1];
  while (paare!=1) {
    kandidat+=1;
    paare = 0;
    for (let i=0; i<folge.length-1; i++) {
      for (let j=i+1; j<folge.length; j++) {
        if (folge[i]+folge[j]>=kandidat) {
          if (folge[i]+folge[j]==kandidat) {
            paare+=1;
          }
          break;
        }
      }
      if (paare>1) {
        break;
      }
    }
  }
  return kandidat;
}
let ulam=[1,2];
for (let i=0; i<10; i++) {
  ulam.push(fortsetzen(ulam));
}
console.log(ulam);
function jasskarten() {
    let farben = ['Eichel', 'Rose', 'Schellen', 'Schilten'];
    let werte = ['6', '7', '8', '9', '10', 'Under', 'Ober', 'König', 'Ass'];
 
    let karten = [];
    for (let f of farben) {
        for (let w of werte) {
            karten.push(`${f} ${w}`);
        }
    }
    return karten
}
 
// Diese Funktion verändert das Array a direkt!
function mischen(a) {
    for (let i=0; i<a.length; i++) {
        let j = Math.floor(Math.random()*(a.length-i));
        // Elemente vertauschen
        let temp = a[i];
        a[i] = a[j];
        a[j] = temp;
        // Kurzform:  [a[i],a[j]] = [a[j], a[i]];
    }
    return a;
}
console.log(mischen(jasskarten());
let a = "Hallo".split("");
 
let zeile = "12 43 65 78";
// map nimmt als Argument eine Funktion, die für jedes Element (und seinen Index und das Array)) aufgerufen wird. Weil Number nur ein (das erste) Argument nimmt, funktioniert diese Kurzform
let l = zeile.split(" ").map(Number);
// Explizite Definition einer anonymen Funktion (Diesmal sicher nur ein Argument)
let l = zeile.split(" ").map((e)=>Number(e));
// Alternative ohne map:
let l = []
for (let z of zeile.split(" ")) {
   l.push(Number(z));
}
function objectHandling() {
    let wardrobes = {"Liam":{"doors":5,"drawers":12,"price":544},"Samuel":{"doors":5,"drawers":12,"price":549},"Cinthia":{"doors":2,"drawers":5,"price":278},"Demetrius":{"doors":2,"drawers":6,"price":275},"Shyann":{"doors":5,"drawers":10,"price":512},"Karl":{"doors":4,"drawers":9,"price":460},"Kimberly":{"doors":4,"drawers":10,"price":475},"Tatiana":{"doors":4,"drawers":9,"price":427},"Issac":{"doors":3,"drawers":8,"price":385},"Stewart":{"doors":5,"drawers":10,"price":496}};
    let total = 0;
    for (let name in wardrobes) {
        total += wardrobes[name].price;
        if (wardrobes[name].doors==4) {
            console.log(`Kasten ${name} hat 4 Türen`);
        }
    }
    console.log(`Alle Kästen kosten ${total}`);
 
    for (let doors=2; doors<=5; doors++) {
        for (let drawers=0; drawers<=8; drawers++) {
            let name = `FlexBox-${doors}-${drawers}`;
            wardrobes[name] = {"doors":doors, "drawers":drawers, "price": 30*doors+10*drawers};
        }
    }
 
    console.log(wardrobes);
}
objectHandling();