Trong câu trả lời của GPT có cả quickSort và quicSortInPlace, và vì trong bình luận có chỉ ra phần [...,quickSort(left), ...equal, ...quickSort(right)] nên tôi hiểu là phải so sánh quickSort với quickSort, còn quickSortInPlace với quickSortInPlace, nhưng có vẻ không phải vậy.

Nếu khẳng định trong bình luận là đúng, chẳng phải Google trên thực tế đang tiếp tay cho hành vi phạm pháp sao?

Bài viết thì thú vị, nhưng có vẻ quá nhiều bài có thể được tóm lại là: “Không dùng AI không phải là không thể sống, nhưng cứ thế tin tưởng vô điều kiện rồi bị nó thuần hóa cũng không phải điều tốt”, nên tôi hơi thấy mệt..

Học hỏi được rất nhiều.

Tất nhiên, phần so sánh phải là so sánh hiệu năng của hai hàm quickSort() và quickSortInPlace()........

À.. tôi đã hiểu anh đang nói gì. Có vẻ anh đã không hiểu là cần phải so sánh cái gì với cái gì.... thuật toán quick sort không phải là có hai cách triển khai là quicksort và in-place đâu......

Ngay từ đầu, điều tôi xem là vấn đề chính là việc viết quickSortGPT() và quickSort() trong đoạn mã trên — đều là mã do GPT tạo ra — với phần hợp nhất Array được tích hợp sẵn, rồi cung cấp chúng cho người dùng AI.

Chia sẻ kết quả cho thấy chênh lệch từ hơn gấp 2 đến tận 3~4 lần mà lại nói có vẻ không đến mức gấp 2 là sao?

Ngay cả bây giờ, khi phải làm việc cùng các lập trình viên ở độ tuổi 40-50, đôi lúc tôi cũng phát điên vì có những người cứ muốn phát triển theo cách họ đã làm từ vài chục năm trước, đúng là bó tay. Cá nhân tôi nghĩ rằng, giống như Nhật Bản, sẽ là một xã hội lành mạnh hơn nếu người trẻ có thể vào làm nhân viên chính thức thay vì chỉ làm thêm hay lao động không chính thức, còn người già thì chủ yếu làm các công việc thời vụ, bán thời gian. Ở Hàn Quốc, thu nhập từ lao động đang được phân chia theo kiểu kim tự tháp ngược, nên càng về sau tình trạng rút thang sau khi mình đã leo lên chỉ càng nghiêm trọng hơn.

Các nền tảng điều dưỡng kiểm tra tình trạng tín dụng của y tá thông qua các nhà môi giới dữ liệu, và khoản nợ càng nhiều thì mức lương được đề nghị càng thấp

Dữ liệu này được cung cấp bằng cách nào vậy?

Tôi đã tự chạy thử thì thấy có xu hướng chậm hơn một chút, nhưng có vẻ không đến mức gấp đôi.

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();  
  
    // đến 2 chữ số thập phân  
    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ả?

Trước bài phát biểu đã có phần giới thiệu tài trợ từ Google và Facebook.

Cũng như câu “mất bò mới lo làm chuồng” không có nghĩa là đừng chuẩn bị cho tương lai,
thì theo tôi, câu “đừng phát minh lại bánh xe” cũng không có nghĩa là đừng đầu tư thời gian để có được insight.
Nếu cắt bỏ trước sau xem câu nói đó xuất hiện trong hoàn cảnh nào, ý nghĩa vốn có của nó sẽ bị bóp méo.

Tôi nghĩ đặc sản lớn nhất của Mỹ là đồng đô la

Khi cứ lặp đi lặp lại nhiều lần để giải quyết cùng một vấn đề thì sẽ vượt quá kích thước context window, và tôi đã nhiều lần gặp cảnh AI bị hỏng trong những lúc như vậy, nên cũng tò mò không biết những người khác xử lý trường hợp này thế nào.
Tôi thì khi thử nhiều lần mà nó vẫn hành xử ngớ ngẩn, sẽ đổi model và mở lại một cửa sổ prompt mới.

Đây là trải nghiệm gần đây của tôi, nhưng gần đây tôi đã tự tạo ra một chiếc bánh xe rất đặc biệt của riêng mình.
Việc build một ứng dụng Nuxt có 1000 trang mất 7 phút,
nhưng sau khi từ bỏ một vài phần tự động hóa và viết lại từ đầu, tôi đã thành công đưa thời gian build xuống còn 20 giây.

OSSU Open Source Society University - Tự học Computer Science

Có vẻ GeekNews đã từng giới thiệu từ khá sớm. Trong thời gian đó đã có thêm khá nhiều nội dung.

Cảm ơn vì câu trả lời!

quickSortInPlace() thứ hai mà bạn đính kèm cũng là một cách triển khai chậm.

Hãy thử chạy đoạn mã dưới đây.

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

Đây là một bài viết mang lại cảm giác có chiều sâu lớn. Quả nhiên là a16z.