Bien sûr, la comparaison doit porter sur les performances des deux fonctions quickSort() et quickSortInPlace()........

Ah… j’ai compris ce que vous vouliez dire. Vous n’aviez pas compris ce qu’il fallait comparer avec quoi… l’algorithme quick sort n’a pas deux modes d’implémentation, quicksort et in-place……

Dès le départ, c’est le fait de rédiger puis de fournir aux utilisateurs de l’IA les fonctions quickSortGPT() et quickSort() du code ci-dessus (toutes deux générées par GPT), avec la fusion de tableaux intégrée, que je critiquais.

Partager un résultat affichant un écart de plus du double, allant jusqu’à 3 à 4 fois, puis dire que ce n’est probablement pas jusqu’à 2 fois ?

Même aujourd’hui, quand j’essaie de travailler avec des développeurs dans la quarantaine ou la cinquantaine, il y a des moments où ça me rend dingue à cause de ceux qui veulent développer avec des méthodes d’il y a plusieurs décennies, lol. Personnellement, je pense que, comme au Japon, la société serait plus saine si les jeunes pouvaient obtenir des emplois stables plutôt que des petits boulots ou des postes précaires, et si les personnes âgées occupaient surtout des emplois journaliers ou des petits boulots. En Corée, la répartition des revenus du travail se fait selon une pyramide inversée, donc plus le temps passe, plus le phénomène consistant à retirer l’échelle aux suivants ne fait que s’aggraver.

Les plateformes de soins infirmiers vérifient la situation de crédit des infirmières via des courtiers en données, et plus elles ont de dettes, plus le salaire proposé est bas

Comment ces données sont-elles fournies ?

Je l’ai exécuté moi-même, et il a bien tendance à être un peu plus lent, mais ça ne semble pas aller jusqu’à 2x.

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();  
  
    // jusqu’à 2 chiffres après la virgule  
    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

....Hein ?

Avant la présentation, il y a eu une introduction des sponsors Google et Facebook.

« Réparer l’étable après avoir perdu la vache » ne veut pas dire qu’il ne faut pas se préparer à l’avenir,

et, de la même façon, « ne réinventez pas la roue » ne veut pas dire qu’il ne faut pas investir du temps pour acquérir des insights.

Si l’on coupe le contexte dans lequel ce genre de phrase a été prononcé, on en déforme le sens initial.

Je pense que la principale spécialité des États-Unis, c’est le dollar.

Quand je dois répéter plusieurs fois pour résoudre le même problème, je finis par dépasser la taille de la fenêtre de contexte, et j’ai souvent constaté que l’IA « se casse » à ce moment-là. Je me demande comment les autres gèrent ce genre de situation.
De mon côté, après plusieurs tentatives, si elle se met à se comporter stupidement, je change de modèle et j’ouvre une nouvelle fenêtre de prompt.

C’est une expérience récente, mais j’ai récemment créé ma propre roue très spéciale.
Construire une application Nuxt de 1000 pages prenait 7 minutes,
mais en renonçant à quelques automatisations et en la réécrivant, j’ai réussi à ramener le build à 20 secondes.

OSSU Open Source Society University - Étudier l’informatique en autodidacte

Cela avait été présenté au tout début de GeekNews. Depuis, beaucoup de choses ont été ajoutées.

Merci pour votre réponse !

La deuxième implémentation de quickSortInPlace() que vous avez jointe est elle aussi une implémentation lente.

Exécutez le code ci-dessous.

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});

C’est un texte qui offre une réflexion profonde. a16z, fidèle à sa réputation.

En général, je commente rarement, mais si j’ai laissé un commentaire sur cet article en particulier, c’est parce que je partage assez fortement l’avis de l’auteur. À mes yeux, l’important n’est pas l’IA ou les LLM en eux-mêmes, mais le fait que, quel que soit l’environnement qui se présente, moi, en tant que développeur, je sois prêt.

Du fait des caractéristiques des sources sur lesquelles ils sont entraînés, les LLM fournissent principalement des données proches de la moyenne des données en ligne réparties à travers le monde. (Le quicksort en js mentionné plus haut le démontre.) C’est pourquoi je les utilise souvent pour poser des questions sur des sujets où je veux vérifier dans quelle mesure une idée ou un design s’écarte ou non d’un point de vue généralement admis, ou encore sur des points que j’avais du mal à savoir à qui demander jusqu’à présent.

Je ne vois pas bien quel intérêt il y a à poursuivre davantage la discussion.

Si l’idée est simplement de dire qu’au départ, le code produit par l’IA peut comporter certains risques et qu’il vaut donc mieux le raffiner soigneusement pour l’utiliser de manière appropriée, il me semble qu’il suffirait alors d’expliquer en quoi le texte de l’auteur reflète un point de vue biaisé. D’autant plus que le résumé contient déjà une idée assez proche : « il peut fournir rapidement du code de type scaffold/ébauche, dépourvu de contexte, mais la conception complète et le tuning restent du ressort des développeurs humains ».

Fondamentalement, on peut considérer qu’il s’agit d’un code qui ne prend absolument pas en compte la charge liée à la création, à l’exploitation et à la fusion des collections. Dans le cas du C++, des propositions et implémentations concernant le Move Constructor existaient déjà il y a une dizaine d’années, et le fait d’être constamment très attentif au coût des copies mémoire est vraiment une base élémentaire. Le quick sort est, par son mécanisme même, un algorithme qui permet de fixer l’index de toutes les valeurs, et il est préférable que chaque champ fournisse un accès aléatoire.

Même sans optimisation maniaque, le simple fait d’appliquer ce qui précède donne déjà plus du double de performances par rapport à la méthode du lien que vous avez partagé.

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

Réfléchissez attentivement à cette partie du code.