Arrays

Eindimensionale Arrays, Grundlagen

a = [7,11,13,42];  // Array mit 4 Elementen
console.log(a);  // Ganzes Array ausgeben
console.log(`Das erste Element ist a[0]=${a[0]}`);
console.log(`Das Array hat a.length=${a.length} Elemente`);
console.log(`Das letzte Element ist a[a.length-1]=${a[a.length-1]}`);
console.log("Zweites Element mit 1111 überschreiben: a[1] = 'Hallo';");
a[1] = 'Hallo';  // Zweites Element überschreiben
console.log(a);  // Ganzes Array ausgeben

Initialisierung mit .push

// Array befüllen mit push
a = [];  // Leeres Array
for (let i=0; i<10; i++) {
   a.push(i*i+i+1);   // Neuen Wert hinten anfügen
}
console.log(a);

Initialisierung mit Array.from

Das erste Argument ist ein Objekt, das die property length hat.

Das zweite Argument ist eine Funktion, die als zweiten Parameter den jeweiligen Index bekommt. Der erste Parameter wäre das i-te Element vom Objekt, das aber hier einfach ignoriert wird (und sowieso undefined wäre).

a = Array.from({length:10}, (_,i)=>i*i+i+1);
console.log(a);

// Drei Punkte, gegeben als Array von 2 Koordinaten
dreieck = [[1,2], [5,3], [2,-1]];
console.log(dreieck);
console.log(`Zweiter Punkt dreieck[1]=${dreieck[1]}`);
console.log(`x-Koordinate vom 3. Punkt ist dreieck[2][0]=${dreieck[2][0]}`);
// Distanz zwischen den Punkten
for (let i=0; i<3; i++) {
  for (let j=(i+1); j<3; j++) {
    let l=0;
    for (let k=0; k<2; k++) {
      l+=(dreieck[i][k]-dreieck[j][k])**2;
    }
    l=l**0.5;  // Wurzel!
    console.log(`Distanz von Punkt ${i} zu Punkt ${j} ist ${l}`);
  }
}

Initialisierung

wuerfel = [];
for (let x=0; x<2; x++) {
  for (let y=0; y<2; y++) {
    for (let z=0; z<2; z++) {
       wuerfel.push([x,y,z]);
    }
  }
}
console.log(wuerfel);
 
// Variante mit Bitoperationen und Array.from
// (i>>1) Verschiebt die Bits von i um eine Stelle nach rechts (niederwertigstes Bit fällt weg)
//  & 1 rechnet bitweise UND, d.h. alle ausser das niederwertigste Bit werden gelöscht.
wuerfel = Array.from({length:8}, (_,i) => [i & 1, (i >> 1) & 1, (i>>2) & 1]);
 
// Variante für n Dimensionen
n = 4;
tesseract = Array.from({length:2**n}, (_,i) => Array.from({length:n}, (_,k) => (i>>k) & 1));

Erster Schritt: Aus einer Zeile die nächste generieren.

zeile = [1,4,6,4,1];
neu = [1];  // Zeile startet mit 1
for (let i=0; i<zeile.length-1; i++) {
  neu.push(zeile[i]+zeile[i+1]);   // Elemente an Stellen i und i+1 zusammenzählen und hinzufügen
}
neu.push(1);  // 1 hinten anfügen
console.log(neu);

Als Funktion verpacken und verwenden

function nextline(zeile) {
  let neu = [1];  // Zeile startet mit 1
  for (let i=0; i<zeile.length-1; i++) {
    neu.push(zeile[i]+zeile[i+1]);   // Elemente an Stellen i und i+1 zusammenzählen und hinzufügen
  }
  neu.push(1);  // 1 hinten anfügen
  return neu;
}
pascal = [];
zeile = [1];
pascal.push(zeile);
for (let i=0; i<10; i++) {
   zeile = nextline(zeile);
   pascal.push(zeile);
}
console.log(pascal);

Hilfsfunktionen:

• String mit einer gegebenen Anzahl Leerschlägen erzeugen
• Zahl mit Leerschlägen auf gegebene Länge auffüllen.

function wiederholen(n, zeichen=" ") {
  let s = "";
  for (let i=0; i<n; i++) {
    s += zeichen
  }
  return s;
}

Oder very fancy:

function wiederholen(n, zeichen=" ") {
  return Array.from({length:n}, ()=>zeichen).join("");
}

Zahlen mit nötigen Leerschlägen ausgeben:

function fuellen(zahl, n) {
  let s = zahl.toString();
  s += wiederholen(n-s.length);
  return s;
}

Oder zentriert:

function fuellen(zahl, n) {
  zahl = zahl.toString();
  let fehlen = n-zahl.length;
  let vorne = Math.floor(fehlen/2);
  return wiederholen(vorne)+zahl+wiederholen(fehlen-vorne);
}

Und jetzt die flexible Ausgabe:

function ausgabe(pascal) {
  let n = pascal.length-1; // Index der letzten Zeile
  let space = pascal[n][Math.floor(n/2)].toString().length+1; // Grösster Koeffizient, Länge in Buchstaben+1
  let s = "";
  for (let i=0; i<=n; i++) {
     s += wiederholen(Math.floor((n-i)*space/2));
     s += pascal[i].map((e)=>fuellen(e,space)).join("")
     s += "\n";  // Zeilenumbruch
  }
  return s;
}

// = n*(n-1)*(n-2)*...*(n-k+1) / (1*2*3*...*k)
function binomial(n,k) {
    if (k<0 || k>n) return 0;
    if (k==0 || k==n) return 1;
    if (k>n/2) return binomial(n,n-k);
    let r=n;
    for (let i=1; i<k; i++) {
        r*=(n-i);
        r/=i+1;
    }
    return r;
}
 
d = Array.from({length:11}, (_,n)=>Array.from({length:n+1}, (_,k)=>binomial(n,k)));

Weltöffentlich und für St. Gallen Microsofties

function nextLine(zeile) {
    let neu = [1];
    for (let i=0; i<zeile.length-1; i++) {
        neu.push(zeile[i]+zeile[i+1]);
    }
    neu.push(1);
    return neu;
}
 
function dreieck(n) {
    pascal = [];
    zeile = [1];
    pascal.push(zeile);
    for (let i=0; i<n; i++) {
        zeile = nextLine(zeile);
        pascal.push(zeile);
    }
    return pascal;
}
 
function wiederholen(n, zeichen=" ") {
    return Array.from({length:n}, ()=>zeichen).join("");
}
 
function zahlfuellen(zahl, n) {
    zahl = zahl.toString();
    let fehlt = n-zahl.length;
    let vorne = Math.floor(fehlt/2);
    return wiederholen(vorne)+zahl+wiederholen(fehlt-vorne);
}
 
function ausgabe(n) {
    let d = dreieck(n);
    let largest = d[n][Math.floor(n/2)];
    let space = largest.toString().length+1;
    let s = "";
    for (let i=0; i<=n; i++) {
        s += wiederholen(space*(n-i)/2);
        s += d[i].map((e)=>zahlfuellen(e,space)).join("");
        s += "\n";  // Zeilenumbruch
    }
    return s;
}
 
console.log(ausgabe(10));