WarriorKodeK

const arithmeticProgression = ({ length, a1 = 0, d = 1 }) =>
  Array.from(
    { length },
    (n, i) => a1 + i * d
  );


const arr = arithmeticProgression({
  length: 10,
  a1: 6,
  d: 3,
});

или

function* arithmeticProgression(a1, d, length) {
  for (let i = 0; i < length; i++) {
    yield a1 + i * d;
  }
}


for (const n of arithmeticProgression(100, 10, 5)) {
  console.log(n);
}

console.log(Array.from(arithmeticProgression(10, -7, 10)));

Array(10).fill().map((_, i) => (i + 2) * 3)

Сможете объяснить решение?

Если я правильно понял формулировку вопрса, то его можно свести к "найти наименьшую дату из списка, исключая те, что были раньше, чем опорная дата"

const closestTo = (dateToCompare, datesArray) => {
  const buff = datesArray.filter(date => date >=dateToCompare).sort()
  return buff.length ? buff[0] : undefined
}

Можно добавлять по 7 дней объекту Date. Месяцы-годы он сам скорректирует.

($(element) as any).keydown(e => {
    const {
        target: {
            selectionStart,
            selectionEnd
        },
        keyCode: direction
    } = e;

    const htmlNode = $(this);
    const inputValue = htmlNode.val();
    const splittedTime = splitTime(inputValue);
    const selectedValue = inputValue.substring(selectionStart, selectionEnd);

    if (!selectedValue) { return; }

    const Point = (x, y) => ({x, y});
    const points = [Point(0, 2), Point(3, 5), Point(6, 10)];
    const targetPoint = Point(selectionStart, selectionEnd);

    const LEFT = 37;
    const UP = 38;
    const RIGHT = 39;
    const DOWN = 40;

    if ((direction === LEFT) || (direction === RIGHT)) {
        e.preventDefault();
        const index = points.findIndex(p => ((p.x === targetPoint.x) && (p.y === targetPoint.y)));
        if (index === -1) { return; }
        index += ((direction === LEFT) ? points.length : 1);
        points.push(targetPoint);
        const point = points[index % points.length];
        this.setSelectionRange(point.x, point.y);
    }

    if ((direction === DOWN) || (direction === UP)) {
        e.preventDefault();
        const Actions = Enums.ValueActions;
        const action = ((direction === DOWN) ? Actions.decrement : Actions. increment);
        changeAppendix(splittedTime, selectedValue, htmlNode);
        adjustTime(splittedTime, htmlNode, action, selectionStart, selectedValue);
        this.setSelectionRange(selectionStart, selectionEnd);
    }
});

Как-то у вас всё переусложнено.

Зачем вешать обработчик клика на body? - можно же добавить инпуту autoFocus={true} и отключать редактирование по событию blur. Так проблема с ненужным срабатыванием обработчика клика решится сама собой.

Как вы собираетесь отменять результаты редактирования, если постоянно перетираете стейт? - предыдущее значение теряется. Лучше вырезать обработчик onChange, а вместо value задавать defaultValue.

Похоже на то, к чему вы стремились?

По сути он хочет платить по частям за каждый этап
Сейчас готов предложить фикс за прототип

Почему не использовать таблицы? colspan для td позволяет объединять ячейки, а rowspan - строки. т.е. вместо двух колонок, для отображения одной большой (на две колонки), пишите
<td colspan="2">Я широкая колонка!</td>

Нет, так просто не получится - тянуть файлы со сторонних доменов через a[download] нельзя.

Можно загрузить файл, перегнать его FileReader'ом в data url, и уже в таком виде подсунуть в ссылку. Как-то так.

Начните с изучения React'a.
Что такое компоненты, jsx и т.д

Не находите странным, что компонент у вас называется ProductDetailContainer, при этом вы делаете запрос по id, но пишите полученные данные в редьюсер для списка, заменяя массив объектом и переписывая ключи состояния списка?
Ошибка с map как раз из-за того, что вы массив объектом подменяете.
Вы неправильно спроектировали хранилище и пытаетесь использовать одни и те же ключи для разных целей.

И кто вас научил таким бессмысленным кульбитам вроде dispatchGetProductDetailWired? Так, видимо, до выхода react-redux делали.
Ваш action можно сократить до:

export const getProductDetail = id => async dispatch => {
  try {
    dispatch(fetching());
    const data = await ProductsService.getProductById(id);
    dispatch(receiveData(data));
  } catch (error) {
     dispatch(fetchingError(error);
  }
};

В компоненте:

class ProductDetailContainer extends Component {
  componentWillMount() {
    const { match: { params: { id } }, getProductDetail } = this.props;

    getProductDetail(id);
  }
  /* ... */
}

const mapStateToProps = state => ({
  productDetail: state.products,
});

const matchDispatchToProps = {
  getProductDetail,
}

export default connect(mapStateToProps, matchDispatchToProps)(ProductDetailContainer);

В конце текста ошибки ссылка с ответом на ваш вопрос.

Еще почитать: Тыц, тыц

const set= new Set();
arrayOne.concat(arrayTwo).forEach(u => set.add(u));
arrayThree.concat(Array.from(set));

в arrayThree добавятся элементы из arrayOne и arrayTwo по одному разу.

Или имелось в виду "уникальные" это которые не встречаются в обоих массивах?

Если так, тогда вот https://habrahabr.ru/post/248229/
Симметрическая разность массивов

И есть готовый инструмент. https://lodash.com/docs/4.17.5#difference

А что это у вас там за цикл?.. Нет, не желаю этого знать. Делайте так: номер игрока равен номеру текущей карточки, а если игроки закончились, то берёте случайное значение. Т.е., заменяете

for (let j = 1; j <= this.players; j++) { 
  this.card.dataset.playerId = j; // а тут устанавливаем playerId. Но он у меня постоянно одинаковый
}

на что-то вроде

this.card.dataset.playerId = i <= this.players ? i : ((Math.random() * this.players | 0) + 1);

Перебрать вложенные массивы, для каждого перебрать строки, для каждой строки перебрать значения.

arr.map(function(subArray, a) {
  subArray.map(function(row, b) {
    row.map(function (value, c) {
      if (value % 6 === 0) { // кратные шести, например
      	 console.log(value, a, b , c)
      }
    })
  })
})

https://jsfiddle.net/8yk66kbk/

Загенерируем генератор!

function* rnd(n) {
  var nums = [], i, randomIndex, itemAtIndex;
  for( i=0; i<n; nums.push(i++));
  for( i=n-1; i>=0; i--) {
    randomIndex = Math.floor(Math.random()*(i+1)); 
    itemAtIndex = nums[randomIndex]; 
    nums[randomIndex] = nums[i]; 
    nums[i] = itemAtIndex;
  }
  i = n - 1
  while(i >= 0)
    yield nums[i--];
}


var gen = rnd(10);

while(true) {
  var v = gen.next();
  if( v.done) break;
  console.log(v.value);
}
console.log('Done!');

Пусть инпуты меняют только значения this.playersCount, this.cardsCount и this.numbersCount.
Никаких id для игроков не надо, пусть они просто лежат в массиве. Создавайте по клику на кнопку "создать игру" или "создать карточки":

class Game {
   // some stuff

  createGame() {
    this.players = [];

    for (let i = 0; i < this.playersCount; i++) {
     const player = new Player({
        name: `Player ${i}`,
        cards: this.createCards()
      });
   
      this.players.push(player);
    }
  }

  createCards() {
    // some stuff
  }

  // some stuff
}

В общем случае, для решения этой задачи нам нужно две функции: функция, проверяющая строку на соответствие всех элементов значению (функция 1) и функция, поворачивающая массив на 90 градусов (функция 2).

Таким образом, чтобы проверить, состоит ли хотя бы одна строка матрицы из элементов Х нужно использовать функцию 1. Чтобы проверить, состоит ли хотя бы один столбец из элементов Х, нужно сначала повернуть массив, используя функцию 2, затем использовать функцию 1.

Примерное решение

OSI-модель и устройство TCP/IP

Алгоритмически возможно ее нужно за один проход цикла считать

const maxChar = str => {
  const charObj = {};
  let max = {char:'', count:''};
  let maxChar = '';

  for (let char of str) {

    if (charObj[char]) {
      charObj[char]++;
    } else {
      charObj[char] = 1;
    }

    if ( charObj[char] >= max.count ) {
      max.char = char
      max.count = charObj[char]
    }

  }

  return max.char;
};

console.log( maxChar('abccccsddasdadwqwf'))