LeetCode 15. Suma de tres números 【JavaScript】

Sansanowa

Déle una matriz nums que contenga n enteros y juzgue si hay tres elementos a, b, c en nums, de modo que a + b + c = 0? Busque todos los triples que cumplan las condiciones y no se repitan.

Nota: la respuesta no puede contener triples repetidos.

Ejemplo:

Dado el arreglo nums = [-1, 0, 1, 2, -1, -4],

El conjunto de triples que cumplen los requisitos son:
[
[-1, 0, 1],
[-1, -1, 2]
]

Fuente: LeetCode
Enlace: https://leetcode-cn.com/problems/3sum
Copyright es propiedad de LeetCode . Para reimpresiones comerciales, comuníquese con la autorización oficial. Para reimpresiones no comerciales, indique la fuente.

Me quedé atascado con esta pregunta durante un día, pasé mucho tiempo en la tarjeta pesada y me quedé medio día más allá del límite de tiempo. Entonces decidí que era necesario grabarlo.
Al mirar este doloroso registro, hay dos palabras entre líneas: a ~ tui! ¡Pequeño pollo! !

Mi primera idea fue ordenar la matriz de pequeña a grande, luego arreglar nums [i] sin cambios, y luego asignar nums [i + 1] a nums [l], y el último dígito nums [nums.length-1] Asigne valor a nums [r], calcule la suma de tres números nums [i], nums [l] y nums [r] para determinar si es 0, y agréguelo al conjunto de resultados cuando se satisfaga. Cuando suma <0, l ++; Cuando suma> 0, r-
mi código en ese momento era así

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var threeSum = function(nums) {
   var t=[];
    nums.sort((a, b) => a - b);
 for(let i=0;i<nums.length;i++){
     let l=i+1;
     r=nums.length-1;
     while(l<r){
     if(nums[i]+nums[l]+nums[r]==0){
       t.push([nums[i],nums[l],nums[r]]);
       l++; r--;
            }
     else if(nums[i]+nums[l]+nums[r]<0){l++;}
     else{r--;}
     }
 }
   return t;
};

Luego descubrí que no consideré la deduplicación, y el resultado de salida fue así:

Así que pensé en usar Set para deduplicar. En este momento, mi código es así:

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var threeSum = function(nums) {
    var t=[];
    nums.sort((a, b) => a - b);
 for(let i=0;i<nums.length;i++){
     let l=i+1;
     r=nums.length-1;
     while (nums[i] === nums[++i]) {} 
     while(l<r){
     if(nums[i]+nums[l]+nums[r]==0){
       t.push([nums[i],nums[l],nums[r]]);
       l++; r--;
     }
     else if(nums[i]+nums[l]+nums[r]<0){l++;}
     else{r--;}
     }
 }
   var newArr = new Set(t);
   var arr1 = [...newArr];
   return arr1;
};

Luego descubrí que los resultados no cambiaron, estaba perplejo. Más tarde, después de buscar en Baidu y hacer preguntas a los grandes, aprendí que el método establecido es juzgar la dirección de memoria, no el valor del objeto. Bueno, realmente es mi novato.
Luego, después de referirme a la lógica de otros, cambié el código a esto:

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var threeSum = function(nums) {
    var t=[];
    nums.sort((a, b) => a - b);
 for(let i=0;i<nums.length;i++){
     if (nums[i] > 0) break;
    if (i > 0 && nums[i] === nums[i - 1]) continue;//去重
     let l=i+1;
     r=nums.length-1;
     while(l<r){
     if(nums[i]+nums[l]+nums[r]==0){
       t.push([nums[i],nums[l],nums[r]]);
       while (l < r && nums[l] === nums[l + 1]) l++;//去重
        while (l < r && nums[r] === nums[r - 1]) r--;//去重
         l++; r--;
     }
     else if(nums[i]+nums[l]+nums[r]<0){l++;}
     else{r--;}
     }
 }
   return t;
};

¡Así pasó! Además, se adjunta una solución de un gran tipo y un anuncio para el gran tipo en este momento (cuenta pública: hable sobre el gran front-end, hay poderosas deducciones para la solución de cada concurso semanal, todo usando JavaScript, que es más amigable para la gente del front-end):

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var threeSum = function(nums){
    var t=[];
    var i=0;
    var len=nums.length;
    nums.sort((a, b) => a - b);
    const record = new Set();
    while(i<len)
{
    if(nums[i]>0) break;
     let l=i+1;
     r=len-1;
     while(l<r){
         var sum=nums[i]+nums[l]+nums[r];
     if(sum==0){
       const key=[nums[i],nums[l],nums[r]].sort().join(',');
       if (!record.has(key)) {
           t.push([nums[i],nums[l],nums[r]]);
         record.add(key);}
         l++; r--;
     }
     else if(sum<0){l++;}
     else{r--;}
     i++;
     }
}
 return t;
};

Pero esto está más allá del límite de tiempo, no sé si alguien tiene una forma de optimizar esto, ¡por favor indíquelo!