Question

我得到了一组对象。数组中的每个对象都有一个关键的PlanType ...我需要确保没有具有相同PlanType的对象彼此相邻...

即使有时不可能完全分开类似的项目，我该如何实现呢？

[{Item: 1,PlanType: A},
 {Item: 2,PlanType: B},
 {Item: 3,PlanType: C},
 {Item: 4,PlanType: C},
 {Item: 5,PlanType: A},
 {Item: 6,PlanType: A},
 {Item: 7,PlanType: B},
 {Item: 8,PlanType: A},
 {Item: 9,PlanType: C},
 {Item: 10,PlanType: A}]

预期结果...

[{Item: 1,PlanType: A},
 {Item: 2,PlanType: B},
 {Item: 3,PlanType: C},
 {Item: 5,PlanType: A},
 {Item: 4,PlanType: C},
 {Item: 6,PlanType: A},
 {Item: 7,PlanType: B},
 {Item: 8,PlanType: A},
 {Item: 9,PlanType: C},
 {Item: 10,PlanType: A}]

这是我尝试过的代码...

//Sort the array into an object of arrays by PlanType
let plan_types = {};
original_array.forEach(item => {
  if(plan_types[item.plan_type] === undefined){
    Object.assign(plan_types, {
      [item.plan_types]: []
    })
  }
  plan_types[item.plan_types].push(item);
});
//Loop through the list of Plan types and try to evenly space out the items across a new array of the same size
let new_array = new Array(original_array.length).fill(null);
Object.keys(program_types).forEach((item,index) => {
  let new_array_index = 0;
  let item_index = 0;
  const frequency = Math.ceil(new_array.length / plan_types[item].length);
  while(new_array_index < new_array.length){
    if(new_array[new_array_index] !== null) new_array_index ++;
    else{
      new_array[new_array_index] = plan_types[item][item_index];
      new_array_index += frequency;
      item_index ++;
    }
  }
})

那里的问题是您无法解决所有问题，并且错过了填写某些项目的时间。留下零点和零食。

Answer 1

您可以这样做，但这可能不是最有效的方法，但可以帮助您找出问题所在。

let A='A', B='B', C='C', D='D';
let f = [{ Item: 1, PlanType: A }, { Item: 2, PlanType: B }, { Item: 3, PlanType: C }, { Item: 4, PlanType: C }, { Item: 5, PlanType: A }, { Item: 6, PlanType: A }, { Item: 7, PlanType: B }, { Item: 8, PlanType: A }, { Item: 9, PlanType: C }, { Item: 10, PlanType: A } ];
let prevItem=f[0];
let currentItem;
for(let i=1; i<f.length; i++){
  currentItem = f[i];
  if(currentItem.PlanType === prevItem.PlanType){
    f.splice(i,1);
    f.push(currentItem);
    console.log("Item shifted");
  };
  prevItem = currentItem;
}
console.log(f);

Code example

Answer 2

我在求解算法方面很糟糕，但这就是我想出的。它还可以处理多个具有相同键的对象接连出现的情况。

基本上，我已经从一个数组中创建了另一个数组，只要检查一下当前迭代中的项是否与新数组中的项相同即可。如果是，请将其添加到“堆栈”中。每当第一个条件失败时，它将继续将当前项插入新数组。完成之后，我只是检查是否可以从该堆栈中获取一项并将其插入新数组，并将其从plicateItems数组中删除。

const items = [
  { Item: 1, PlanType: 'A' },
  { Item: 2, PlanType: 'B' },
  { Item: 3, PlanType: 'C' },
  { Item: 4, PlanType: 'C' },
  { Item: 5, PlanType: 'C' },
  { Item: 6, PlanType: 'A' },
  { Item: 7, PlanType: 'A' },
  { Item: 8, PlanType: 'B' },
  { Item: 9, PlanType: 'A' },
  { Item: 10, PlanType: 'C' },
  { Item: 11, PlanType: 'A' }
];

function normalizeList(items) {
  if (items.length < 1) return items;
  const result = [];
  const duplicateItems = [];
  items.forEach((item, index) => {
    if (result.length && item.PlanType === result[result.length - 1].PlanType) {
      if(index === items.length - 1) result.push(item); 
      else duplicateItems.push(item);
    }

    else {
      result.push(item);
      if(duplicateItems.length && duplicateItems[0].PlanType !== item.PlanType) {
        result.push(duplicateItems.shift());
      }
    }
  });
  return result;
}

Answer 3

在我看来，不能通过基本比较可靠地将等值（或子属性值相等）的相邻项彼此远离。即将提出的方法不能称得上优雅，因为它是基于直接数组突变并在很大程度上计数索引。它旨在解决第一步迭代中的任务...

relocateEqualNeighboringItemValues(["A", "A", "B"]) => ["A", "B", "A"]
relocateEqualNeighboringItemValues(["A", "A", "B", "C", "C"]) => ["A", "C", "B", "A", "C"]

在第二个迭代步骤中，也可以传递getter，例如结构更复杂的项目确实以项目的特定属性为目标...

relocateEqualNeighboringItemValues([

  { item: 1, planType: "A" },
  { item: 2, planType: "A" },
  { item: 3, planType: "B" }

], (item => item.planType)) => [

  { item: 1, planType: "A" },
  { item: 3, planType: "B" },
  { item: 2, planType: "A" }
]

实现看起来像这样...

function relocateEqualNeighboringItemValues(arr, getItemValue) {
  if (Array.isArray(arr) && (arr.length >= 3)) {

    const getValue = ((

      (typeof getItemValue === 'function') &&
      (item => (item && getItemValue(item)))

    ) || (item => item)); // getter default.

    let isTerminateRelocation = false;
    let isRelocateItem;
    let offsetCount;
    let itemCount;
    let itemValue;
    let leftToRightIndex;
    let rightToLeftIndex = arr.length;

    while (!isTerminateRelocation && (--rightToLeftIndex >= 0)) {

      isRelocateItem = false;
      itemValue = getValue(arr[rightToLeftIndex]);

      // - Exercise repeatedly from right to left for each item a relocation lookup,
      //   and, if possible, try to relocated such an equal neighboring item (value).

      if (itemValue === getValue(arr[rightToLeftIndex - 1])) {

        offsetCount = 1;
        isRelocateItem = true;

        while (isRelocateItem && ((rightToLeftIndex - (++offsetCount)) >= 0)) {
          if (
            (itemValue !== getValue(arr[rightToLeftIndex - offsetCount])) &&
            (itemValue !== getValue(arr[rightToLeftIndex - offsetCount - 1]))
          ) {
            arr.splice((rightToLeftIndex - offsetCount), 0, arr.splice(rightToLeftIndex, 1)[0]);

            ++rightToLeftIndex; // reset ... start look-up from the former entering position.
            isRelocateItem = false;
          }
        }

        // - In case the right to left relocation for a specific item got stuck (reached array boundaries),
        //   change lookup direction exclusively for this item from left to right and try relocating it.
        // - Does the relocation attempt fail yet again, nothing can be done. The process will terminate.

        if (isRelocateItem && ((rightToLeftIndex - offsetCount) < 0)) {
          offsetCount = 1;

          itemCount = arr.length;
          leftToRightIndex = Math.max(0, (rightToLeftIndex - 1));

          itemValue = getValue(arr[leftToRightIndex]);
          isRelocateItem = (itemValue === getValue(arr[leftToRightIndex + 1]));

          while (isRelocateItem && ((leftToRightIndex + (++offsetCount)) < itemCount)) {
            if (
              (itemValue !== getValue(arr[leftToRightIndex + offsetCount])) &&
              (itemValue !== getValue(arr[leftToRightIndex + offsetCount + 1]))
            ) {
              arr.splice((leftToRightIndex + offsetCount), 0, arr.splice(leftToRightIndex, 1)[0]);

              isRelocateItem = false;
            }
          }
          if (isRelocateItem && ((leftToRightIndex + offsetCount) >= itemCount)) {

            isTerminateRelocation = true;
          }
        }
      }
    }
  }
  return arr;
}

测试用例

基本

function relocateEqualNeighboringItemValues(a,b){if(Array.isArray(a)&&3<=a.length){const c="function"==typeof b&&(a=>a&&b(a))||(a=>a);let d,e,f,g,h,i=!1,j=a.length;for(;!i&&0<=--j;)if(d=!1,g=c(a[j]),g===c(a[j-1])){for(e=1,d=!0;d&&0<=j-++e;)g!==c(a[j-e])&&g!==c(a[j-e-1])&&(a.splice(j-e,0,a.splice(j,1)[0]),++j,d=!1);if(d&&0>j-e){for(e=1,f=a.length,h=Math.max(0,j-1),g=c(a[h]),d=g===c(a[h+1]);d&&h+ ++e<f;)g!==c(a[h+e])&&g!==c(a[h+e+1])&&(a.splice(h+e,0,a.splice(h,1)[0]),d=!1);d&&h+e>=f&&(i=!0)}}}return a}

console.log('["A", "A", "B"] => ', relocateEqualNeighboringItemValues(["A", "A", "B"]));

console.log('["A", "B", "B"] => ', relocateEqualNeighboringItemValues(["A", "B", "B"]));

console.log('["A", "A", "B", "C", "C"] => ', relocateEqualNeighboringItemValues(["A", "A", "B", "C", "C"]));

console.log('["A", "A", "C", "B", "C", "C"] => ', relocateEqualNeighboringItemValues(["A", "A", "C", "B", "C", "C"]));

console.log('["A", "A", "C", "C", "B", "C", "C"] => ', relocateEqualNeighboringItemValues(["A", "A", "C", "C", "B", "C", "C"]));

.as-console-wrapper { max-height: 100%!important; top: 0; }

复杂，具有吸气功能但可解决

function relocateEqualNeighboringItemValues(a,b){if(Array.isArray(a)&&3<=a.length){const c="function"==typeof b&&(a=>a&&b(a))||(a=>a);let d,e,f,g,h,i=!1,j=a.length;for(;!i&&0<=--j;)if(d=!1,g=c(a[j]),g===c(a[j-1])){for(e=1,d=!0;d&&0<=j-++e;)g!==c(a[j-e])&&g!==c(a[j-e-1])&&(a.splice(j-e,0,a.splice(j,1)[0]),++j,d=!1);if(d&&0>j-e){for(e=1,f=a.length,h=Math.max(0,j-1),g=c(a[h]),d=g===c(a[h+1]);d&&h+ ++e<f;)g!==c(a[h+e])&&g!==c(a[h+e+1])&&(a.splice(h+e,0,a.splice(h,1)[0]),d=!1);d&&h+e>=f&&(i=!0)}}}return a}

const items = [
  { Item: 0, PlanType: 'B' },
  { Item: 1, PlanType: 'B' },
  { Item: 2, PlanType: 'A' },
  { Item: 3, PlanType: 'C' },
  { Item: 4, PlanType: 'C' },
  { Item: 5, PlanType: 'C' },
  { Item: 6, PlanType: 'A' },
  { Item: 7, PlanType: 'A' },
  { Item: 8, PlanType: 'B' },
  { Item: 9, PlanType: 'A' },
  { Item: 10, PlanType: 'A' },
  { Item: 11, PlanType: 'A' },
  { Item: 12, PlanType: 'A' }
  // { Item: 13, PlanType: 'A' }
];

console.log(items, ' => ', relocateEqualNeighboringItemValues(Array.from(items).reverse(), (item => item.PlanType)).reverse());

console.log(items, ' => ', relocateEqualNeighboringItemValues(Array.from(items).reverse(), (item => item.PlanType)));

console.log(items, ' => ', relocateEqualNeighboringItemValues(Array.from(items), (item => item.PlanType)).reverse());

console.log(items, ' => ', relocateEqualNeighboringItemValues(Array.from(items), (item => item.PlanType)));

.as-console-wrapper { max-height: 100%!important; top: 0; }

复杂，具有吸气功能，但现在无法解析

function relocateEqualNeighboringItemValues(a,b){if(Array.isArray(a)&&3<=a.length){const c="function"==typeof b&&(a=>a&&b(a))||(a=>a);let d,e,f,g,h,i=!1,j=a.length;for(;!i&&0<=--j;)if(d=!1,g=c(a[j]),g===c(a[j-1])){for(e=1,d=!0;d&&0<=j-++e;)g!==c(a[j-e])&&g!==c(a[j-e-1])&&(a.splice(j-e,0,a.splice(j,1)[0]),++j,d=!1);if(d&&0>j-e){for(e=1,f=a.length,h=Math.max(0,j-1),g=c(a[h]),d=g===c(a[h+1]);d&&h+ ++e<f;)g!==c(a[h+e])&&g!==c(a[h+e+1])&&(a.splice(h+e,0,a.splice(h,1)[0]),d=!1);d&&h+e>=f&&(i=!0)}}}return a}

const items = [
  { Item: 0, PlanType: 'B' },
  { Item: 1, PlanType: 'B' },
  { Item: 2, PlanType: 'A' },
  { Item: 3, PlanType: 'C' },
  { Item: 4, PlanType: 'C' },
  { Item: 5, PlanType: 'C' },
  { Item: 6, PlanType: 'A' },
  { Item: 7, PlanType: 'A' },
  { Item: 8, PlanType: 'B' },
  { Item: 9, PlanType: 'A' },
  { Item: 10, PlanType: 'A' },
  { Item: 11, PlanType: 'A' },
  { Item: 12, PlanType: 'A' },
  { Item: 13, PlanType: 'A' }
];

console.log(items, ' => ', relocateEqualNeighboringItemValues(Array.from(items), (item => item.PlanType)));

.as-console-wrapper { max-height: 100%!important; top: 0; }

如何根据每个项目的特定键值对在对象数组中分离相似或相似的项目？

3 个答案: