丢失数据的Pad数组

Question

我有一组不同频率更新的N个数组(数据被推入其中)。如果我的数组更新频率比“最快”数组慢，那么这些较慢的数组应该会填充以前的数据。

例子:两个数组，在不同的频率上更新，超过10秒看起来就像

// fast array updates every 1 second
// after 10 seconds the data is:
let fast_array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
// slow array updates every 5 seconds
// after 10 seconds the data is:
let slow_array = [0, 1];

我希望这样填充较慢的数组。

fast_array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
slow_array = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

和数组长度应该总是相等的。

我已经写了一个完整的可测试的设置，只是无法找到正确的神奇公式垫。请看一下小提琴，以一个简单的方法来解决这个问题！看功能“处理器”

<div>
  <button id="start" type="button">
    Start
  </button>
  <button id="stop" type="button">
    Stop
  </button>
</div>
<div id="feature1">
  <div>
    Length: <span id="feature1len"></span>
  </div>

  <div>
    [<span id="feature1data"></span>]
  </div>
</div>
<div id="feature2">
  <div>
    Length: <span id="feature2len"></span>
  </div>
  [<span id="feature2data"></span>]
</div>

</div>

JS

let startbutton = document.getElementById('start');
let stopbutton = document.getElementById('stop');
startbutton.addEventListener('click', () => {
  start();
});
stopbutton.addEventListener('click', () => {
  stop();
});
let feature1 = {
  freq: 1,
  raw_data: [],
  final_data: [],
  interval: null,
  lenHtml: document.getElementById('feature1len'),
  dataHtml: document.getElementById('feature1data')
}

let feature2 = {
  freq: 5,
  raw_data: [],
  final_data: [],
  interval: null,
  lenHtml: document.getElementById('feature2len'),
  dataHtml: document.getElementById('feature2data')
}

let render_interval = null;


function getRandomInt(min = 0, max = 100) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

function render() {
  processor(feature1);
  processor(feature2);
  feature1.lenHtml.innerText = feature1.final_data.length;
  feature1.dataHtml.innerText = feature1.final_data.toString();
  feature2.lenHtml.innerText = feature2.final_data.length;
  feature2.dataHtml.innerText = feature2.final_data.toString();
}

function start() {
  feature1.raw_data = [];
  feature1.final_data = [];
  feature2.raw_data = [];
  feature2.final_data = [];
  feature1.raw_data.push(getRandomInt())
  feature1.interval = setInterval(() => {
    feature1.raw_data.push(getRandomInt())
  }, feature1.freq * 1000);
  feature2.raw_data.push(getRandomInt())
  feature2.interval = setInterval(() => {
    feature2.raw_data.push(getRandomInt())
  }, feature2.freq * 1000);
  render_interval = setInterval(() => {
    render();
  }, 1000)
  render();
}

function stop() {
  clearInterval(feature1.interval);
  clearInterval(feature2.interval);
  clearInterval(render_interval);
}

function processor(feature) {
  // determine highest frequency
  let most_frequent = Math.min(feature1.freq, feature2.freq);
  // determine longest length
  let longest_length = Math.max(feature1.raw_data.length, feature2.raw_data.length);

  // process data if needed
  feature.final_data = [];
  for (let i = 0; i < feature.raw_data.length; i++) {
    feature.final_data.push(feature.raw_data[i]);
    if(feature.freq !== most_frequent){
        let max_filler =  0; //???
        for(let x = 0; x < max_filler; x++){
        feature.final_data.push(feature.raw_data[i]);
      }
    }
  }
}

render();

https://jsfiddle.net/79wbnkf8/1/

Answer 1

您可以添加以下功能：

function lcm(x, y) {
  return (!x || !y) ? 0 : Math.abs((x * y) / gcd(x, y));
}

function gcd(x, y) {
  x = Math.abs(x);
  y = Math.abs(y);
  while(y) {
    var t = y;
    y = x % y;
    x = t;
  }
  return x;
}

然后修改流程函数，如下所示：

function processor(feature) {
  // determine highest frequency
  let most_frequent = Math.min(feature1.freq, feature2.freq);
  // determine longest length
  let longest_length = Math.max(feature1.raw_data.length, feature2.raw_data.length);

  let l = lcm(feature1.freq, feature2.freq);
  let max_filler = l / feature1.freq;

  // process data if needed
  feature.final_data = [];
  for (let i = 0; i < feature.raw_data.length; i++) {

    if(feature.freq !== most_frequent){
        //let max_filler =  0; //???
        for(let x = 0; x < max_filler; x++){
        feature.final_data.push(feature.raw_data[i]);
        if (feature.final_data.length >=longest_length) break;
      }
    } else {
      feature.final_data.push(feature.raw_data[i]);
    }
  }
}

Answer 2

从功能列表中找到最常见的特性

let mostFreqFeature = features.reduce((min, feature) => min.freq < feature.freq ? min : feature);

为start函数中最频繁的特性设置间隔

pushItem_interval = setInterval(() => {
    pushItem();
  }, mostFreqFeature.freq * 1000)

最后，将项目推到列表中

function pushItem(){
 for(var i=0;i<features.length;i++){
  let feature = features[i];
    if(feature.freq==mostFreqFeature.freq)
      feature.raw_data.push(getRandomInt())
      else{
        if(feature.raw_data.length<=0){
         feature.raw_data.push(getRandomInt());
         return;
        }
        if((feature.raw_data.length)% feature.freq==0)
            feature.raw_data.push(getRandomInt())
            else{
            let lastItem = feature.raw_data[feature.raw_data.length-1];
             feature.raw_data.push(lastItem)
            }

      }    
 }
}

工作实例小提琴

希望，它会对你的需要有所帮助。