Natürlich sollte man die Performance der beiden Funktionen quickSort() und quickSortInPlace() vergleichen........

Ah … jetzt verstehe ich, was gemeint ist. Sie haben wohl nicht verstanden, was man womit vergleichen sollte … Der Quicksort-Algorithmus hat nicht zwei Implementierungsarten, nämlich quicksort und in-place …

Worauf ich von Anfang an hinauswollte, ist, dass es problematisch ist, quickSortGPT() und quickSort() im obigen Code (beides von GPT ausgegebener Code) zu schreiben und sie dann AI-Nutzern bereitzustellen, obwohl die Array-Zusammenführung bereits eingebaut ist.

Und dann teilt man ein Ergebnis, bei dem der Output mehr als doppelt, sogar drei- bis viermal so stark abweicht, und sagt anschließend, es seien wohl doch keine 2x?

Schon heute platzt mir manchmal der Kragen, wenn ich mit Entwicklern in ihren 40ern oder 50ern zusammenarbeiten soll, weil es Leute gibt, die noch auf die Art entwickeln wollen, wie vor Jahrzehnten. Persönlich denke ich, dass eine gesündere Gesellschaft entstünde, wenn junge Menschen wie in Japan nicht in Nebenjobs oder prekäre Beschäftigung gedrängt würden, sondern feste Stellen bekommen könnten, während ältere Menschen eher in Tagesjobs und Aushilfstätigkeiten arbeiten. In Korea werden die Arbeitseinkommen in einer umgekehrten Pyramide verteilt, deshalb wird es immer schlimmer, dass Aufstiegschancen nach oben weggezogen werden.

> Pflegeplattformen prüfen über Datenbroker die Kreditwürdigkeit von Pflegekräften und bieten niedrigere Löhne an, je höher deren Verschuldung ist

Wie werden diese Daten eigentlich bereitgestellt?

Ich habe es selbst ausgeführt; es scheint etwas langsamer zu sein, aber ich glaube nicht, dass es bis zum Doppelten geht.

function quickSortInPlace(arr, left = 0, right = arr.length - 1) {  
    if (left >= right) return;  
  
    const pivotIndex = partition(arr, left, right);  
    quickSortInPlace(arr, left, pivotIndex - 1);  
    quickSortInPlace(arr, pivotIndex + 1, right);  
}  
  
function partition(arr, left, right) {  
    const pivot = arr[right];  
    let i = left;  
  
    for (let j = left; j < right; j++) {  
        if (arr[j] < pivot) {  
            [arr[i], arr[j]] = [arr[j], arr[i]];  
            i++;  
        }  
    }  
  
    [arr[i], arr[right]] = [arr[right], arr[i]];  
    return i;  
}  
  
function quickSort(arr) {  
    if (arr.length <= 1) return arr;  
  
    const pivot = arr[arr.length - 1];  
    const left = [];  
    const right = [];  
  
    for (let i = 0; i < arr.length - 1; i++) {  
        if (arr[i] < pivot) {  
            left.push(arr[i]);  
        } else {  
            right.push(arr[i]);  
        }  
    }  
  
    return [...quickSort(left), pivot, ...quickSort(right)];  
}  
  
// =============  
  
function quickSortGPT(arr) {  
    if (!Array.isArray(arr)) {  
        throw new TypeError('quickSort expects an array');  
    }  
    if (arr.length <= 1) return [...arr];  
  
    const pivot = arr[Math.floor(arr.length / 2)];  
    const left = [];  
    const equal = [];  
    const right = [];  
  
    for (const el of arr) {  
        if (el < pivot) left.push(el);  
        else if (el > pivot) right.push(el);  
        else equal.push(el);  
    }  
  
    return [...quickSortGPT(left), ...equal, ...quickSortGPT(right)];  
}  
  
function quickSortInPlaceGPT(arr) {  
    if (!Array.isArray(arr)) {  
        throw new TypeError('quickSortInPlace expects an array');  
    }  
  
    const stack = [[0, arr.length - 1]];  
  
    while (stack.length) {  
        const [lo, hi] = stack.pop();  
        if (lo >= hi) continue;  
  
        const pivotIndex = partitionGPT(arr, lo, hi);  
  
        // Tail‑recursion elimination: push larger partition first  
        if (pivotIndex - 1 - lo > hi - (pivotIndex + 1)) {  
            stack.push([lo, pivotIndex - 1]);  
            stack.push([pivotIndex + 1, hi]);  
        } else {  
            stack.push([pivotIndex + 1, hi]);  
            stack.push([lo, pivotIndex - 1]);  
        }  
    }  
    return arr;  
}  
  
function medianOfThreeGPT(a, b, c) {  
    return (a - b) * (c - a) >= 0 ? a  
        : (b - a) * (c - b) >= 0 ? b  
            : c;  
}  
  
function partitionGPT(arr, lo, hi) {  
    const mid = lo + ((hi - lo) >> 1);  
    const pivotValue = medianOfThreeGPT(arr[lo], arr[mid], arr[hi]);  
  
    while (true) {  
        while (arr[lo] < pivotValue) lo++;  
        while (arr[hi] > pivotValue) hi--;  
  
        if (lo >= hi) return hi;  
  
        [arr[lo], arr[hi]] = [arr[hi], arr[lo]];  
        lo++;  
        hi--;  
    }  
}  
  
function testQuicksort(qs, qsp) {  
    const repeat = 100;  
    const arrLength = 100000;  
    const unsortedArray = new Array();  
    for (let i = 0; i < arrLength; i++)  
        unsortedArray.push(Math.round(Math.random() * arrLength));  
  
    let sorted = [];  
  
    const qb = performance.now();  
    for (let i = 0; i < repeat; i++)  
        sorted = qs(unsortedArray);  
    const qe = performance.now();  
  
    const rqb = performance.now();  
    for (let i = 0; i < repeat; i++) {  
        let copied = [...unsortedArray];  
        qsp(copied);  
    }  
    const rqe = performance.now();  
  
    // Bis auf 2 Nachkommastellen  
    const p1 = ((qe - qb) / repeat).toFixed(2);  
    const p2 = ((rqe - rqb) / repeat).toFixed(2);  
    
    console.log(`Quicksort: ${p1} ms, In-place: ${p2} ms`);  
}  
  
function main() {  
    const useGPT = process.argv.includes('--gpt');  
    console.log(`Using ${useGPT ? 'GPT' : 'geekNews'} quicksort implementation.`);  
    if (useGPT) {  
        testQuicksort(quickSortGPT, quickSortInPlaceGPT);  
    } else {  
        testQuicksort(quickSort, quickSortInPlace);  
    }  
}  
  
main();  

===
node q.js
Using geekNews quicksort implementation.
Quicksort: 29.55 ms, In-place: 9.94 ms
node q.js
Using geekNews quicksort implementation.
Quicksort: 28.42 ms, In-place: 9.07 ms
node q.js
Using geekNews quicksort implementation.
Quicksort: 26.91 ms, In-place: 9.15 ms
node q.js --gpt
Using GPT quicksort implementation.
Quicksort: 28.73 ms, In-place: 9.22 ms
node q.js --gpt
Using GPT quicksort implementation.
Quicksort: 26.87 ms, In-place: 9.22 ms
node q.js --gpt
Using GPT quicksort implementation.
Quicksort: 27.97 ms, In-place: 9.30 ms
node --version
v22.14.0

bun q.js
Using geekNews quicksort implementation.
Quicksort: 32.05 ms, In-place: 17.39 ms
bun q.js
Using geekNews quicksort implementation.
Quicksort: 30.97 ms, In-place: 17.82 ms
bun q.js
Using geekNews quicksort implementation.
Quicksort: 29.73 ms, In-place: 16.14 ms
bun q.js --gpt
Using GPT quicksort implementation.
Quicksort: 30.61 ms, In-place: 12.63 ms
bun q.js --gpt
Using GPT quicksort implementation.
Quicksort: 31.09 ms, In-place: 12.76 ms
bun q.js --gpt
Using GPT quicksort implementation.
Quicksort: 33.24 ms, In-place: 12.75 ms
bun --version
1.2.14

deno q.js
Using geekNews quicksort implementation.
Quicksort: 32.30 ms, In-place: 6.79 ms
deno q.js
Using geekNews quicksort implementation.
Quicksort: 26.79 ms, In-place: 6.86 ms
deno q.js
Using geekNews quicksort implementation.
Quicksort: 26.09 ms, In-place: 6.85 ms
deno q.js --gpt
Using GPT quicksort implementation.
Quicksort: 27.18 ms, In-place: 7.92 ms
deno q.js --gpt
Using GPT quicksort implementation.
Quicksort: 25.34 ms, In-place: 8.12 ms
deno q.js --gpt
Using GPT quicksort implementation.
Quicksort: 25.39 ms, In-place: 8.09 ms
deno --version
deno 2.3.3 (stable, release, x86_64-pc-windows-msvc)
v8 13.7.152.6-rusty
typescript 5.8.3

....Äh?

Vor dem Vortrag gab es Vorstellungen der Sponsoren Google und Facebook.

So wie „den Stall reparieren, nachdem die Kuh weggelaufen ist“ nicht bedeutet, dass man sich nicht auf die Zukunft vorbereiten soll,
bedeutet „das Rad nicht neu erfinden“ meiner Ansicht nach auch nicht, dass man keine Zeit investieren soll, um Einsichten zu gewinnen.
Wenn man bei solchen Aussagen den Kontext abschneidet, wird ihre eigentliche Bedeutung verzerrt.

Ich denke, das größte Aushängeschild der USA ist der Dollar.

Wenn man dasselbe Problem mehrfach hintereinander zu lösen versucht, überschreitet man irgendwann die Größe des Kontextfensters, und ich habe schon mehrfach erlebt, dass die KI dann einfach kaputtgeht. Mich würde interessieren, wie andere in solchen Fällen damit umgehen. Ich wechsle dann das Modell und öffne ein neues Prompt-Fenster, wenn es sich nach mehreren Versuchen dumm anstellt.

Das ist eine aktuelle Erfahrung: Ich habe mir kürzlich mein ganz eigenes, sehr spezielles Rad gebaut.
Es dauerte 7 Minuten, eine App mit 1000 Seiten in Nuxt zu bauen,
aber nachdem ich auf einige Automatisierungen verzichtet und alles neu aufgebaut hatte, habe ich einen Build in 20 Sekunden geschafft.

OSSU Open Source Society University - Computer Science im Selbststudium

Das wurde schon in den Anfangstagen von GeekNews vorgestellt. Inzwischen ist ziemlich viel hinzugekommen.

Vielen Dank für die Antwort!

Die zweite quickSortInPlace()-Variante, die Sie angehängt haben, ist auch eine langsame Implementierung.

Führen Sie einfach den folgenden Code aus.

function quickSortInPlace(arr, left = 0, right = arr.length - 1) {
if (left >= right) return;

const pivotIndex = partition(arr, left, right);
quickSortInPlace(arr, left, pivotIndex - 1);
quickSortInPlace(arr, pivotIndex + 1, right);
}

function partition(arr, left, right) {
const pivot = arr[right];
let i = left;

for (let j = left; j < right; j++) {
if (arr[j] < pivot) {
[arr[i], arr[j]] = [arr[j], arr[i]];
i++;
}
}

[arr[i], arr[right]] = [arr[right], arr[i]];
return i;
}

function quickSort(arr) {
if (arr.length <= 1) return arr;

const pivot = arr[arr.length - 1];
const left = [];
const right = [];

for (let i = 0; i < arr.length - 1; i++) {
if (arr[i] < pivot) {
left.push(arr[i]);
} else {
right.push(arr[i]);
}
}

return [...quickSort(left), pivot, ...quickSort(right)];
}

const repeat = 100;
const arrLength = 10000;
const unsortedArray = new Array<number>();
for(let i = 0; i < arrLength; i++)
unsortedArray.push(Math.round(Math.random() * arrLength));

let sorted: Array<number>;

const qb = performance.now();
for(let i = 0; i < repeat; i++)
sorted = quickSort(unsortedArray);
const qe = performance.now();

const rqb = performance.now();
for(let i = 0; i < repeat; i++) {
let copied = [...unsortedArray];
quickSortInPlace(copied);
}
const rqe = performance.now();

console.log(q: ${qe - qb} ::: rq: ${rqe - rqb});

Ein Text mit tiefen Einsichten. Wie erwartet von a16z.

Normalerweise schreibe ich nicht oft Kommentare, aber warum ich ausgerechnet zu diesem Artikel einen hinterlasse, ist, dass ich den Gedanken des Autors ziemlich stark zustimme. Nicht AI oder LLM sind das Entscheidende, sondern ich denke, dass ich als Entwickler auf jede Umgebung vorbereitet sein muss, egal was kommt.

Aufgrund der Eigenschaften der Trainingsdaten liefert ein LLM vor allem Daten, die in der Nähe des Durchschnitts der weltweit im Internet verteilten Daten liegen. (Das oben erwähnte js-Quicksort beweist das.) Deshalb nutze ich es meist, um zu fragen, ob etwas in ideologischer oder Design-Hinsicht einigermaßen mit der allgemeinen Perspektive übereinstimmt oder davon abweicht, oder für Inhalte, bei denen lange unklar war, wen man überhaupt fragen sollte.

Ich bin mir nicht sicher, welchen Sinn es hat, das Gespräch noch weiter fortzusetzen.

Wenn die Ansicht von vornherein lautet, dass von der AI erzeugter Code gewisse Risiken enthalten kann und man ihn daher sorgfältig bereinigen und angemessen nutzen sollte, dann wäre es wohl ausreichend, wenn Sie erklären, inwiefern der Text des Autors von bestimmten Denkverzerrungen geprägt ist. Selbst in der Zusammenfassung steht sinngemäß: „Kontextloser Scaffold-/Entwurfscode kann zwar schnell bereitgestellt werden, aber vollständiges Design und Tuning bleiben Aufgabe menschlicher Entwickler.“

Im Grunde ist das Code, der keinerlei Verständnis für den Aufwand bei der Erstellung, Handhabung und Zusammenführung von Collections erkennen lässt. Im Fall von C++ wurden bereits vor etwa 10 Jahren Vorschläge bzw. Implementierungen für Move-Konstruktoren vorgestellt, und ein scharfes Bewusstsein für die Kosten von Speicherkopien gehört dort zu den absoluten Grundlagen. Quick Sort ist seinem Mechanismus nach ein Algorithmus, der die Indizes aller Werte festlegen kann, und es ist besser, wenn auf die einzelnen Felder per Random Access zugegriffen werden kann.

Selbst ohne manische Optimierungen ergibt sich bei Anwendung allein der oben genannten Punkte ein Leistungsunterschied von mehr als dem Doppelten gegenüber der von Ihnen verlinkten Methode.

return [...quickSort(left), ...equal, ...quickSort(right)];

Denken Sie einmal genau darüber nach, was dieser Teil des Codes bedeutet.