Duolingo anuncia la adopción de IA en lugar de trabajadores contratistas

Cuando intenté convertir una rueda cuadrada en una redonda, recordé las palabras del jefe de que no reinventáramos la rueda. Todavía hay muchos por ahí poseídos por el fantasma del “no reinventes la rueda”.

Dejando eso de lado, es demasiado tajante asumir que ni siquiera se contempla la intervención humana,
para cambios simples de cifras o mensajes, probablemente sea más eficiente que intervenga una persona que un LLM.

Entiendo que, si configuras la opción temperature en 0, se garantiza la misma salida para la misma entrada.

La frase "quickSort con quickSort" me hace llevarme la mano a la nuca del puro estrés.

Los LLM no garantizan la misma salida para la misma entrada, ¿de verdad funciona una gestión de configuración así...?
¿O será que yo todavía los estoy usando de una forma demasiado unidimensional?

Por favor, al leer el texto, asegúrense de revisar bien el contexto.

No estoy presumiendo mi nivel de programación. Lo que estoy señalando es que código tan deficiente como quickSort() que se está usando ahora como ejemplo aparece con alta prioridad en las respuestas de GPT.

Si haces varias búsquedas en GPT, muchas veces te entrega como resultado una sola función quickSort() y, de nuevo, quickSort() es solo un ejemplo. Cuando le pides código a GPT para trabajo real, con frecuencia genera código de muy baja calidad (hablo desde la experiencia de un usuario de pago), y coincido con la opinión del autor del texto en que, si el desarrollador no tiene la capacidad de distinguir eso por sí mismo, es muy probable que el proyecto avance en una dirección que lo termine arruinando. Ese es el contexto que lleva hasta este punto.

De hecho, a mi alrededor ya siguen aumentando los proyectos cubiertos con este tipo de código tan deficiente.

Modo YOLO...

¿Lo organizaron para que se pudiera seleccionar un bloque en cada casilla y solo decoraron la apariencia con CSS? La verdad, es impresionante.

La respuesta de GPT incluye tanto quickSort como quicSortInPlace, y como en los comentarios señalaron la parte de [...,quickSort(left), ...equal, ...quickSort(right)], entendí que había que comparar quickSort con quickSort y quickSortInPlace con quickSortInPlace, pero parece que no era así.

Si lo que afirma el comentario es cierto, ¿no estaría Google ayudando en la práctica a una actividad delictiva?

El texto es entretenido, pero me está cansando un poco que tantos artículos parezcan resumirse en: “no usar IA no es la solución para todo, pero tampoco está bien confiar ciegamente en ella y dejarse domesticar”..

Estoy aprendiendo mucho.

Por supuesto, la comparación debe hacerse entre el rendimiento de las dos funciones quickSort() y quickSortInPlace()........

Ah... entendí a qué se refiere. No había entendido qué cosas había que comparar.... el algoritmo quick sort no tiene dos formas de implementación, quicksort e in-place......

Desde el principio, lo que cuestioné fue que se escribieran y se ofrecieran a los usuarios de IA quickSortGPT() y quickSort() del código de arriba (ambos son código generado por GPT), donde la fusión de arrays ya está incorporada.

¿Compartir un resultado donde se ve una diferencia de más del doble, incluso de 3 a 4 veces, y luego decir que no parece llegar al doble?

Incluso ahora, cuando intento trabajar con desarrolladores de 40 o 50 años, a veces me desespera que haya personas que quieran desarrollar de la misma forma que se hacía hace décadas, uff. Personalmente, creo que sería una sociedad más sana si, como en Japón, los jóvenes pudieran entrar a empleos formales en lugar de trabajos de medio tiempo o no regulares, y las personas mayores se concentraran más en trabajos temporales por día. En Corea, la distribución del ingreso laboral está funcionando como una pirámide invertida, así que cada vez se vuelve más fuerte eso de quitarle la escalera a los que vienen detrás.

> Las plataformas de enfermería revisan el historial crediticio de las enfermeras a través de corredores de datos, y cuanto más endeudadas están, menor salario les ofrecen.

¿Cómo se proporciona esta información?

Lo ejecuté yo mismo y tiende a ser un poco más lento, pero no creo que llegue a ser 2 veces más lento.

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);  
  
        // Eliminación de recursión de cola: primero apilar la partición más grande  
        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();  
  
    // hasta 2 decimales  
    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

....¿eh?