diff --git a/src/exercises/meineLoesungen/fibonacci.js b/src/exercises/meineLoesungen/fibonacci.js
new file mode 100644
index 0000000..9f434eb
--- /dev/null
+++ b/src/exercises/meineLoesungen/fibonacci.js
@@ -0,0 +1,13 @@
+// fibonacci, imperativ
+
+// Berechne die Fibonacci Folge für n Elemente, beginnend bei 0.
+// Gib alle berechneten Elemente aus.
+
+function fibonacci(n) {
+    let f = [0,1]
+    for (let i = 1; i < n ; i++) {
+        f.push(f[i] + f[i-1])
+    }
+    return f
+}
+console.log(fibonacci(50))
\ No newline at end of file
diff --git a/src/exercises/meineLoesungen/flow-control.js b/src/exercises/meineLoesungen/flow-control.js
new file mode 100644
index 0000000..0636d57
--- /dev/null
+++ b/src/exercises/meineLoesungen/flow-control.js
@@ -0,0 +1,386 @@
+
+/*
+Aufgabe 1
+*/
+function begruessung(name, alter) {
+    if(alter<=10)
+        return `Hoi ${name}`
+    else if(alter>10 && alter<=18)
+        return `Hallo ${name}`
+    else if(alter>18 && alter <= 100)
+        return `Grüezi ${name}`
+    else
+        return `Grüss Gott ${name}`
+}
+
+console.log(begruessung('klein fritz', 8))
+console.log(begruessung('kind fritz', 11))
+console.log(begruessung('alt fritz', 50))
+console.log(begruessung('uralt fritz', 108))
+
+
+/*
+Aufgabe 2
+*/
+function preis(alter) {
+    if(alter<5)
+        return 0
+    else if(alter>=5 && alter<=15)
+        return 5
+    else if(alter>15 && alter <= 59)
+        return 15
+    else
+        return 10
+}
+console.log(preis(3))
+console.log(preis(7))
+console.log(preis(16))
+console.log(preis(50))
+console.log(preis(60))
+console.log(preis(103))
+
+/*
+Aufgabe 3
+*/
+function zugang(alter, maennlich) {
+    if((alter>19 && maennlich) || (alter>17 && !maennlich))
+        return true
+    else 
+        return false
+}
+
+console.log(zugang(19, true))
+console.log(zugang(20, true))
+console.log(zugang(17, false))
+console.log(zugang(18, false))
+
+function zugang_ternaer(alter, maennlich) {
+    return ((alter>19 && maennlich) || (alter>17 && !maennlich)) ? true : false
+}
+
+console.log(zugang_ternaer(19, true))
+console.log(zugang_ternaer(20, true))
+console.log(zugang_ternaer(17, false))
+console.log(zugang_ternaer(18, false))
+
+
+function zugang_switch(alter, maennlich) {
+    let result = false;
+    switch(maennlich) {
+        case true:
+            if(alter>19)
+                result = true;
+                break;
+        case false:
+            if(alter>17)
+                result = true;
+                break;
+        default:
+            result = false;
+
+    }
+    return result;
+}
+
+console.log(zugang_switch(18, true))
+console.log(zugang_switch(20, true))
+console.log(zugang_switch(17, false))
+console.log(zugang_switch(18, false))
+
+/*
+Schleifen / Loops
+Aufgabe 0
+*/
+let s = '';
+for(let char of "penguin") {
+    s += char + ',';
+}
+console.log(s.substr(0,s.length-1))
+
+
+// TODO
+/*
+Schleifen / Loops
+Aufgabe 1
+*/
+let array = [1,2,3]
+let sum = array.reduce((a,b) => a+b, 0);
+console.log(sum)
+let summe = 0;
+for (const number of array) {
+    summe += number
+}
+console.log(summe)
+
+
+/*
+Schleifen / Loops
+Aufgabe 2
+*/
+let result = []
+for(let number of [1,2,3]) {
+    if(number%2===0) {
+        result.push(true);
+    } else {
+        result.push(false)
+    }
+}
+
+console.log(result)
+
+let result2 = []
+for(let number of [1,2,3]) {
+    result2.push(number%2===0)
+}
+console.log(result2)
+
+function numToBool(...n) {
+    let result3 = []
+    for(let number of n) {
+        result3.push(number%2===0)
+    }
+    return result3;
+}
+
+const numbers = [1,2,3,4,5]
+console.log(numToBool(...numbers))
+
+/*
+Schleifen / Loops
+Aufgabe 3
+
+Schreibe ein Programm, welches jeden ersten Buchstaben aller Wörter eines Strings
+in einen Grossbuchstaben umwandelt.
+z.B. aus `"Ich weiss, dass ich nichts weiss ... !"` wird
+`"Ich Weiss, Dass Ich Nichts Weiss ... !"`
+Tip: JavaScript kann einen Kleinbuchstaben automatisch
+umwandeln in den entsprechenden Grossbuchstaben.
+*/
+let resultat = '';
+let sentence = "Ich weiss, dass ich nichts weiss ... !";
+sentenceArray = sentence.split(' ')
+for (let word of sentenceArray) {
+    resultat += word.toUpperCase().slice(0,1) + word.slice(1) + ' '
+}
+console.log(resultat)
+
+/*
+Schleifen / Loops
+Aufgabe 4
+
+Schreibe ein Programm, das alle Primzahlen zwischen 0 und 100 ausgibt.
+Versuche 2 Varianten zu schreiben, mit jeweils anderen Schlaufentypen.
+*/
+function getPrimzahlen( upperFront ) {
+    let primzahlen = []
+    let nPrim = [];
+    for( x = 0; x <= upperFront; x++ ) {
+        nPrim[x] = false;
+    }
+    x = 2;
+    while( ( x * x ) <= upperFront ) {
+        if( nPrim[x] == false ) {
+            for( y = ( x * x ); y <= upperFront; y += x ) {
+                nPrim[y] = true;
+            }
+        }
+        x++;
+    }
+    for( x = 2; x <= upperFront; x++ ) {
+        if( nPrim[x] == false ) {
+            // x == Primzahl
+            primzahlen.push(x)
+        }
+    }
+    return primzahlen
+}
+console.log(getPrimzahlen(100))
+
+
+
+/*
+Schleifen / Loops
+Aufgabe 5
+
+Schreibe ein Program, das einen beliebigen Text mit Cäsar Chiffre verschlüsselt.
+z.B. aus `"abcz"` wird `"bcd{"`, sofern die Verschiebung 1 ist.
+*/
+function caesar(text, mvmt) {
+    let resultat = '';
+    for (let zeichen of text) {
+        let ascii = zeichen.charCodeAt(0)
+        console.log(String.fromCharCode(ascii + mvmt))
+        resultat = resultat + String.fromCharCode(ascii + mvmt);
+    }
+    return resultat
+}
+console.log(caesar("abcz", 1))
+
+
+/*
+Schleifen / Loops
+Aufgabe 6
+
+Gegegeben ist eine beliebige Menge von Zahlen.
+*/
+let zahlen = [2,4,456,7,65,4,3,2,3, -5,4,5,654,3,.67,-34,.43,65,-4.8,7,653,856,8765,432,345,786]
+
+/*
+6.1 Gebe nur die Ganzzahlen aus.
+ */
+let gz = [];
+for (let zahl of zahlen) {
+    (zahl%2==0) ? gz.push(zahl) : false
+}
+console.log(gz)
+
+/*
+6.2 Gebe nur die positiven Zahlen aus.
+ */
+let pz = [];
+for (let zahl of zahlen) {
+    (zahl>0) ? pz.push(zahl) : false
+}
+console.log(pz)
+
+/*
+6.3 Berechne die Quersumme aller Zahlen
+ */
+qs = 0;
+zahlen = [2,4,5,6,43,7,6,54,-34,654,32];
+for (const number of zahlen) {
+    if(number>0) {
+        for (const zahl of number.toString()) {
+            qs += Number(zahl);
+        }
+    } else {
+        for (const zahl of number.toString()) {
+            if(!isNaN(Number(zahl)))
+                qs -= Number(zahl);
+        }
+    }
+}
+qs
+/*
+6.4 Berechne den Durchschnitt (arithmetisches Mittel) aller Zahlen
+ */
+let ds = zahlen.reduce((a,b) => a + b) / zahlen.length
+console.log(ds)
+
+
+/*
+Schleifen / Loops
+Aufgabe 7
+
+Gegeben ist eine beliebige Zeichenkette.
+*/
+let zeichenkette = "Mein Essen wurde kalt."
+
+/*
+7.1 Konvertiere jedes zweite Zeichen zum entsprechenden Grossbuchstaben.
+ */
+sentence = '';
+for (let i = 0; i < zeichenkette.length; i++) {
+    if(i%2 === 0) {
+        sentence += zeichenkette[i].toUpperCase()
+    } else {
+        sentence += zeichenkette[i].toLowerCase()
+    }
+}
+console.log(sentence)
+
+/*
+7.2 Ersetze alle Konsonanten durch die entsprechenden Selbstlaute. \
+Zum Beispiel aus einem "p" wird "pe", aus "c" wird "ce", aus "k" wird "ka" etc.
+ */
+// loesung 1:
+let search = ['b','c','d','f','g','h','j','l','m','n','p','q','r','s','t','v','w','x','y','z','B','C','D','F','G','H','J','L','M','N','P','Q','R','S','T','V','W','X','Y','Z'];
+let replace = ['be','ce','de','äf','ge','ha','jot','äl','äm','än','pe','qu','äs','te','vau','we','ix','ypsilon','zät','BE','CE','DE','ÄF','GE','HA','JOT','ÄL','ÄM','ÄN','PE','QU','ÄS','TE','VAU','WE','IT','YPSILON','ZÄT'];
+let res = '';
+for (const zeichen of zeichenkette) {
+    if(search.includes(zeichen)) {
+        res += replace[search.indexOf(zeichen)];
+    } else {
+        res += zeichen;
+    }
+}
+console.log(res);
+
+
+// loesung 2:
+res = '';
+for (const zeichen of zeichenkette) {
+    if(search.indexOf(zeichen) >= 0) {
+        res += replace[search.indexOf(zeichen)];
+    } else {
+        res += zeichen;
+    }
+}
+console.log(res);
+
+// loesung 3 (kompliziert):
+resultat = ''
+let vokale = ['a', 'e', 'i', 'o', 'u']
+for (const zeichen of zeichenkette) {
+    let charcode = zeichen.charCodeAt(0)
+    if((vokale.indexOf(zeichen) === -1) && ((charcode>=65 && charcode<=90) || (charcode>=97 && charcode<=122))) {
+        // konsonante
+        let codes = [65,66,67,68,71,80,84,97,98,99,100,103,112,116]
+        if(codes.indexOf(charcode) !== -1) {
+            // b-d, g, p, t,
+            resultat += zeichen + 'e'
+        }
+        codes = [70,76,77,78,82,83,87,102,108,109,110,114,115,119]
+        if(codes.indexOf(charcode) !== -1) {
+            // f, l-n, r-s, w
+            resultat += 'e' + zeichen
+        }
+        codes = [72,75,104,107]
+        if(codes.indexOf(charcode) !== -1) {
+            // h, k,
+            resultat += zeichen + 'a'
+        }
+        codes = [81,113]
+        if(codes.indexOf(charcode) !== -1) {
+            // q
+            resultat += zeichen + 'u'
+        }
+        codes = [86,118]
+        if(codes.indexOf(charcode) !== -1) {
+            // v
+            resultat += zeichen + 'au'
+        }
+        codes = [88,120]
+        if(codes.indexOf(charcode) !== -1) {
+            // x
+            resultat += 'i' + zeichen
+        }
+        codes = [89,121]
+        if(codes.indexOf(charcode) !== -1) {
+            // y
+            resultat += zeichen + 'psilon'
+        }
+        codes = [90,122]
+        if(codes.indexOf(charcode) !== -1) {
+            // z
+            resultat += zeichen + 'ät'
+        }
+    } else {
+        // vokal
+        resultat += zeichen
+    }
+}
+console.log(resultat)
+
+/*
+7.3
+Gib die Zeichenkette rückwärts aus. \
+z.B. aus "Hallo du" wird "ud ollaH".
+ */
+let text = 'Hallo du'
+let output = ''
+for (let i = text.length-1; i >= 0; i--) {
+    output += text[i]
+}
+console.log(output)
+
diff --git a/src/exercises/meineLoesungen/fn-objects-callbacks.js b/src/exercises/meineLoesungen/fn-objects-callbacks.js
new file mode 100644
index 0000000..65c90a4
--- /dev/null
+++ b/src/exercises/meineLoesungen/fn-objects-callbacks.js
@@ -0,0 +1,35 @@
+// 1
+// gegeben
+function add(a, b){
+    return a + b
+}
+//
+// Erstelle eine Funktion namens aPlusb welche einen Parameter p entgegen nimmt,
+// und intern immer add mit a=20 aufruft, b soll mit p belegt werden.
+// Gib das Ergebnis der Berechnung zurück.
+// Versuche zwei Lösungs-Varianten zu finden (Hint: bind).
+
+function aPlusb(p) {
+    return add(20, p);
+}
+console.log(aPlusb(2));
+
+
+add.bind(20);
+console.log(aPlusb(2));
+
+
+
+// 2
+// Die gegebene Funktion add aus Aufgabe 1 soll geändert werden.
+// Neu möchten wir, dass immer alle Argumente geloggt werden (bevor die Berechnung gemacht wird).
+// Der Aufrufer kann selbst entscheiden was für einen Logger er verwenden möchte.
+// z.B. console.log oder console.warn wären mögliche Logger.
+
+function add2(a, b, logger){
+    logger(`${logger.name} => Parameter: a: ${a}, b: ${b}`);
+    return a + b
+}
+
+add2(9, 32, console.warn);
+add2(7, 4, console.log);
diff --git a/src/exercises/meineLoesungen/functional-impertive.js b/src/exercises/meineLoesungen/functional-impertive.js
new file mode 100644
index 0000000..835af88
--- /dev/null
+++ b/src/exercises/meineLoesungen/functional-impertive.js
@@ -0,0 +1,41 @@
+
+/*
+# Funktional vs Imperativ
+
+## Summe
+Schreibe eine Funktion `sum(in: Array<Number>): Number`, welche alle Zahlen von `in` summiert und das Ergebnis retourniert. \
+Schreibe eine funktionale und eine imperative Variante.
+ */
+function summierenimperative(numbers) {
+    let result = 0;
+    for (const number of numbers) {
+        result += number;
+    }
+    return result;
+}
+console.log(summierenimperative([1,2,3,4,5]));
+
+function summierenfunctional(numbers) {
+    return numbers.reduce((a,b)=>(a+b));
+}
+console.log(summierenfunctional([1,2,3,4,5]));
+
+/*
+    ## Gerade Zahlen
+Schreibe eine Funktion `even(in: Array[Number]): Array<Number>`, welche nur die geraden Zahlen aus `in` retourniert. \
+Schreibe eine funktionale und eine imperative Variante.
+*/
+const evenImperative = function(numbers) {
+    const even = [];
+    for (const number of numbers) {
+        if(number%2==0) {
+            even.push(number);
+        }
+    }
+    return even;
+}
+console.log(evenImperative([1,2,3.4,5,6,7,8,9,10,11,12]));
+const evenFunctional = function(numbers) {
+    return numbers.filter(number=>number%2==0);
+}
+console.log(evenFunctional([1,2,3,4,5,6,7,8,9]));
diff --git a/src/exercises/meineLoesungen/iterator.js b/src/exercises/meineLoesungen/iterator.js
new file mode 100644
index 0000000..8b4b1db
--- /dev/null
+++ b/src/exercises/meineLoesungen/iterator.js
@@ -0,0 +1,35 @@
+// 1
+// Implementiere einen Array Iterator, der einen Array rückwärts iteriert.
+// Versuche zwei Varianten zu finden.
+
+const arr = [2,3,4,5,6,7];
+for (let i = arr.length-1; i >= 0; i--) {
+    console.log(arr[i]);
+}
+
+arr.slice().reverse().forEach((item)=>console.log(item));
+
+// 2 
+// Schreibe eine Funktion forFun, welche
+// - ein Objekt welches Symbol.iterator implementiert
+// - und eine callback Funktion
+// entgegen nimmt.
+// Iteriere über das iterable Objekt und rufe den Callback für jeden Wert auf, 
+// solange bis alle Elemente iteriert sind.
+const obj = {
+    *[Symbol.iterator] () {
+        yield 'golf';
+        yield 'bike';
+        yield 'cart';
+        yield 'sail';
+    }
+}
+
+let cb = function(x) {
+    console.log(x);
+}
+
+let forFun = function(obj, callback) {
+    [...obj].forEach(item => callback(item));
+}
+forFun(obj, cb);
\ No newline at end of file
diff --git a/src/exercises/meineLoesungen/objects.js b/src/exercises/meineLoesungen/objects.js
new file mode 100644
index 0000000..4faddac
--- /dev/null
+++ b/src/exercises/meineLoesungen/objects.js
@@ -0,0 +1,138 @@
+/*
+Objects
+Aufgabe 1
+Definiere eine Liste von mehreren User Objekten. Jeder User hat einen Namen und eine Punktezahl.
+*/
+const users = [];
+users.push({name: 'urs', score: 5});
+users.push({name: 'marco', score: 6});
+users.push({name: 'claudia', score: 40});
+users.push({name: 'mitja', score: 2});
+users.push({name: 'cla', score: 13});
+users.push({name: 'ueli', score: 5});
+
+console.log(users)
+
+/*
+Objects
+Aufgabe 2
+Finde den User mit der höchsten Punktezahl
+*/
+let winner = null
+for(let user of users) {
+    if(winner===null || user.score>winner.score)
+        winner = user
+}
+console.log(winner)
+
+/*
+Objects
+Aufgabe 3
+
+Gib eine Liste der User aus, im ASCII Format. \
+Das heisst verwende nur einfache Zeichen, um die Liste zu erstellen.
+z.B:
+```
+|Name|Punkte|
+|----|------|
+|Hans|8|
+|Martin|12|
+```
+*/
+function listeAscii3(users) {
+    let result = '|Name|Punkte|\n'
+    result += '|----|------|\n'
+    for (const user of users) {
+        result += '|' + user.name + '|' + user.score +'|\n'
+    }
+    return result
+}
+console.log(listeAscii3(users))
+
+
+/*
+Objects
+Aufgabe 4
+
+Finde die Länge des längsten Namen, sowie die Länge der höchsten Punktezahl.
+*/
+function maxLengthData(users)  {
+    let maxLengthName = null;
+    let maxLengthScore = null;
+    for (const user of users) {
+        if(maxLengthName==null || maxLengthName<user.name.length) {
+            maxLengthName = user.name.length
+        }
+        if(maxLengthScore==null || maxLengthScore<user.score.toString().length) {
+            maxLengthScore = user.score.toString().length
+        }
+    }
+    return {name: maxLengthName, score: maxLengthScore}
+}
+console.log(maxLengthData(users))
+
+
+/*
+Objects
+Aufgabe 5
+
+Mache jede Spalte so breit, wie die entsprechende maximale Länge dessen Inhalt. \
+_Achtung_: Der Spaltentitel muss ebenfalls berücksichtigt werden.
+
+Hinweis: Suche auf MDN nach padEnd und repeat
+
+z.B:
+```
+|Name  |Punkte|
+|------|------|
+|Hans  |8     |
+|Martin|12    |
+```
+*/
+
+let maxLengthName = maxLengthData(users).name
+let maxLengthScore = maxLengthData(users).score
+
+/**
+ * Berechnet wie viele Stellen ausgefüllt werden müssen
+ * anhang der Spaltenbreite max und des aktuellen textlänge actual der zeile
+ * @param actual    textlänge des spalteneintrags der zeile
+ * @param max       maximal stellen der spalte
+ * @returns {number}    anzahl stellen, welche aufgefüllt werden müssen
+ */
+function spacer(actual, max) {
+    if(max>=actual) {
+        return max-actual
+    }
+    return 0;
+}
+
+/**
+ * Stellt eine "Füllerstring" her mit den Anzahl Zeichen count
+ * bestehende aus zeichen des typ letter
+ * @param count     gewünschte Länge des "Füllerstrings"
+ * @param letter    Zeichen welches genutzt werden soll
+ * @returns {string}    Füllerstring
+ */
+function filler(count, letter) {
+    let result = ''
+    for (let i = 0; i < count; i++) {
+        result += letter
+    }
+    return result
+}
+function table(users) {
+    let spalte1 = 'Namen';
+    let spalte2 = 'Punkte';
+    (maxLengthName<spalte1.length) ? maxLengthName = spalte1.length : true;
+    (maxLengthScore<spalte2.length) ? maxLengthScore = spalte2.length : true;
+
+    let result = '|' + spalte1 + filler(spacer(spalte1.length, maxLengthName), ' ') +'|' + spalte2 + filler(spacer(spalte2.length, maxLengthScore), ' ') + '|\n'
+    result += '|' + filler(spacer(0, maxLengthName), '-') +'|' + filler(spacer(0, maxLengthScore), '-') +'|\n'
+    for (const user of users) {
+        result += '|' + user.name + filler(spacer(user.name.length, maxLengthName), ' ')
+        result += '|' + user.score + filler(spacer(user.score.toString().length, maxLengthScore), ' ') + '|\n'
+    }
+    return result
+}
+console.log(table(users))
\ No newline at end of file