+ in {new Set(functions.map(f => f.language)).size} Programmiersprachen +
++ in {functions.filter(f => f.issues.length > 0).length} Funktionen +
+{func.name}
+{func.file}
+Caching für wiederholte Berechnungen hinzufügen.
+Stack-freundliche Rekursion durch Tail-Calls.
+Rekursion in iterative Lösung umwandeln.
+
+ {selectedFunction.code}
+
+ { + issue === 'no_memoization' ? 'Keine Memoization' : + issue === 'deep_recursion' ? 'Tiefe Rekursion' : + issue === 'circular_reference' ? 'Zirkuläre Referenz' : + issue === 'no_cycle_detection' ? 'Keine Zykluserkennung' : + issue + }
++ {issue === 'no_memoization' ? 'Diese Funktion würde erheblich von Memoization profitieren, um redundante Berechnungen zu vermeiden.' : + issue === 'deep_recursion' ? 'Die Rekursionstiefe kann zu Stack-Overflows führen. Erwägen Sie eine iterative Implementierung.' : + issue === 'circular_reference' ? 'Die Funktion kann in eine Endlosschleife geraten, wenn zirkuläre Referenzen vorhanden sind.' : + issue === 'no_cycle_detection' ? 'Es fehlt eine Erkennung von Zyklen, was zu unendlicher Rekursion führen kann.' : + 'Unbekanntes Problem'} +
+Optimiert
++ Diese Funktion ist bereits optimiert und folgt Best Practices für rekursive Implementierungen. +
+Performance-Trace
+
+ {selectedFunction.name === 'fibonacci' ?
+ `function fibonacci(n, memo = {}) {
+ if (n <= 0) return 0;
+ if (n === 1) return 1;
+
+ // Bereits berechneten Wert zurückgeben, wenn vorhanden
+ if (memo[n] !== undefined) return memo[n];
+
+ // Berechnen und speichern
+ memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo);
+ return memo[n];
+}` :
+ selectedFunction.name === 'deepClone' ?
+ `function deepClone(obj, visited = new WeakMap()) {
+ if (obj === null || typeof obj !== 'object') {
+ return obj;
+ }
+
+ // Zykluserkennung
+ if (visited.has(obj)) {
+ return visited.get(obj);
+ }
+
+ let clone = Array.isArray(obj) ? [] : {};
+
+ // Aktuelle Referenz speichern
+ visited.set(obj, clone);
+
+ for (let key in obj) {
+ if (Object.prototype.hasOwnProperty.call(obj, key)) {
+ clone[key] = deepClone(obj[key], visited);
+ }
+ }
+
+ return clone;
+}` :
+ selectedFunction.name === 'traverse' ?
+ `def traverse(node, visited=None):
+ if visited is None:
+ visited = set()
+
+ if node is None:
+ return
+
+ # Zykluserkennung
+ if id(node) in visited:
+ return
+
+ visited.add(id(node))
+ process(node.data)
+ traverse(node.left, visited)
+ traverse(node.right, visited)` :
+ selectedFunction.code
+ }
+
+
+ Optimierungsdetails
+-
+ {selectedFunction.name === 'fibonacci' ? (
+ <>
+
-
+
+ Memoization hinzugefügt, um bereits berechnete Fibonacci-Zahlen wiederzuverwenden +
+ -
+
+ Reduziert Zeitkomplexität von O(2^n) auf O(n) +
+
+ ) : selectedFunction.name === 'deepClone' ? (
+ <>
+ -
+
+ WeakMap zur Zykluserkennung hinzugefügt, um endlose Rekursion zu vermeiden +
+ -
+
+ Referenzen werden während der Rekursion verfolgt +
+
+ ) : selectedFunction.name === 'traverse' ? (
+ <>
+ -
+
+ Set zur Zykluserkennung hinzugefügt +
+ -
+
+ Objekt-IDs werden verfolgt, um Zyklen in der Baumstruktur zu erkennen +
+
+ ) : null}
+