从数组中取出n个不同的数组成子集 y 使 x = Σy

/**

 * 尝试获取arr子集 y  使 x=Σy

 * @param {Array} arr 

 * @param {number} x 

 * @param {Array} res 

 */

function tryVisit(arr, x, res) {

   res = res || arr.map(m => { return { x: x - m, item: [m] } });

   ; ri < res.length; ri++) {

      const rr = res[ri];

      let toDel = true;

      ; i < arr.length; i++) {

         const item = arr[i];

         if (contains(rr.item, item)) continue;

         let diff = rr.x - item;

         ) { }

         ) {

            rr.item.push(item)

            rr.x = diff;

         }

         else {

            rr.item.push(item);

            console.log(rr.item.join(','))

            return rr.item;

         }

         toDel = false;

      }

      if (toDel) res[ri] = undefined;

      else res[ri] = rr;

   }

   let toVisit = res.filter(m => m != undefined);

   ) , toVisit)

}

/**

 * arr 中是否包含 tag

 * @param {Array} arr 

 * @param {*} tag 

 */

function contains(arr, tag) {

   ; j < arr.length; j++) {

      const r = arr[j];

      if (r == tag) {

         return true;

      }

   }

}

function main() {

   , , , , , , , , , ];

   ;

   //test

   console.log('test:每种方法都测试一下');

   tryVisit(tag, v) && tryVisit(tag.reverse(), v) && tryVisit(tag.sort((m,n) => m-n), v) && tryVisit(tag.sort((m,n) => n-m), v);

   //正序倒序、乱序、默认排序 等 多种尝试 比如 如果目标数是偶数 就按照奇数偶数排序试一下

   console.log('use:只取一个');

   , , , , , , , , , ];

   let res = tryVisit(tag, v) || tryVisit(tag.reverse(), v) || tryVisit(tag.sort((m,n) => m-n), v) || tryVisit(tag.sort((m,n) => n-m), v);

}

main();

理论上尝试次数越多函数失效的可能性越少，我列出了 排序不排序和他们的反转情况

/**

 * 尝试获取arr子集 y  使 x=Σy

 * @param {Array} arr 

 * @param {number} x 

 * @param {Array} res 

 */

function tryVisit(arr, x, res) {

   res = res || arr.map(m => { return { x: x - m, item: [m] } });

   ; ri < res.length; ri++) {

      const rr = res[ri];

      let toDel = true;

      ; i < arr.length; i++) {

         const item = arr[i];

         if (contains(rr.item, item)) continue;

         let diff = rr.x - item;

         ) { }

         ) {

            rr.item.push(item)

            rr.x = diff;

         }

         else {

            rr.item.push(item);

            console.log(rr.item.join(','))

            return rr.item;

         }

         toDel = false;

      }

      if (toDel) res[ri] = undefined;

      else res[ri] = rr;

   }

   let toVisit = res.filter(m => m != undefined);

   ) , toVisit)

}

/**

 * arr 中是否包含 tag

 * @param {Array} arr 

 * @param {*} tag 

 */

function contains(arr, tag) {

   ; j < arr.length; j++) {

      const r = arr[j];

      if (r == tag) {

         return true;

      }

   }

}

function main() {

   , , , , , , , , , ];

   ;

   //test

   console.log('test:每种方法都测试一下');

   tryVisit(tag, v) && tryVisit(tag.reverse(), v) && tryVisit(tag.sort((m,n) => m-n), v) && tryVisit(tag.sort((m,n) => n-m), v);

   //正序倒序、乱序、默认排序 等 多种尝试 比如 如果目标数是偶数 就按照奇数偶数排序试一下

   console.log('use:只取一个');

   , , , , , , , , , ];

   let res = tryVisit(tag, v) || tryVisit(tag.reverse(), v) || tryVisit(tag.sort((m,n) => m-n), v) || tryVisit(tag.sort((m,n) => n-m), v);

}

main();