Александр Буки

function range(array: number[]): string { 
  return array.sort(
    (a, b) => a - b
  ).reduce((acc, next, i) => {
    const prev = array[i - 1];

    if (prev !== undefined && next - prev === 1) {
      acc[acc.length - 1][1] = next;
    }
    else {
      acc.push([next]);
    }

    return acc;
  }, []).map(
    arr => arr.join("-")
  ).join(", ");
}

console.log(range([1, 4, 5, 2, 3, 9, 8, 11, 0])); // 0-5, 8-9, 11
console.log(range([1, 4, 3, 2])); // 1-4
console.log(range([1, 4])); // 1, 4
console.log(range([1])); // 1
console.log(range([])); // ""

const range = arr => arr
   .sort((a, b) => a - b)
   .reduce((agg, v) => {
      const currRange = agg[agg.length - 1]
      if (!currRange || v > currRange.last + 1) {
         agg.push({first: v, last: v})
      } else {
         currRange.last = v
      }
      return agg
   }, [])
   .map(v => v.first + (v.first !== v.last ? '-' + v.last : '')).join()

1. Мутирование переданного массива
   
2. Для массивов нулевой и единичной длины результат не строка
   
3. Многовато if'ов, слишком сложно
   

const range = ([...arr]) => arr
  .sort((a, b) => a - b)
  .reduce((acc, n, i, a) => (
    (n === a[i - 1] + 1) || acc.push([ n ]),
    acc[acc.length - 1][1] = n,
    acc
  ), [])
  .map(([ a, b ]) => a === b ? a : `${a}-${b}`)
  .join(', ');

const range = arr => ''.concat(...arr
  .slice()
  .sort((a, b) => a - b)
  .reduce((acc, n, i, a) => (
    n !== a[i - 1] + 1 && acc.push(i ? `, ${n}` : n),
    n === a[i - 1] + 1 && n !== a[i + 1] - 1 && acc.push(`-${n}`),
    acc
  ), [])
);

renderNoResultsMessage() {
    const { results, noResultsMessage } = this.props;
    if (results && !results.length && noResultsMessage) {
      return (<div className="no-result">
        <h3>
          {noResultsMessage}
        </h3>
      </div>);
    }
  }

function promisify(obj) {
  const cache = {}

  return new Proxy(obj, {
    get(target, prop) {
      const value = target[prop]
      const type = Object.prototype.toString.call(value)

      if (type === '[object Object]') {
        if (!cache[prop]) {
          cache[prop] = promisify(value)
        }

        return cache[prop]
      } else if (type === '[object Function]') {
        if (!cache[prop]) {
          cache[prop] = function (...args) {
            return new Promise((resolve, reject) => {
              const callback = (err, result) => {
                if (err) {
                  reject(err)
                } else {
                  resolve(result)
                }
              }

              value.call(this, callback, ...args)
            })
          }
        }

        return cache[prop]
      }

      return value
    },
  })
}

input[type="radio"]:checked + label {
    background: #FF0000;
    box-shadow: 60px 30px 0 0 blue, 60px -30px 0 0 blue;
    position: relative;
    z-index: 1;
}

label {
    transition: ease box-shadow .3s;
}

module.exports = function (start, end, fetchFlights) {
    let fetchPromise, route
    
    const routes = [[start]]
    const last = arr => arr[arr.length - 1]

    // функция обработки ответа
    const responseExecution = response => {
      let result
      // Если респонс включает конечную точку, 
      // то составляем маршрут из последних элементов routes
      if (response.includes(end)) {
        route = [...routes.map(list => last(list)), end]
      } else if (response.length) {
        // если респонс содержит города, добавляем его в конец списка
        routes.push(response)
      } else { // если массив пустой
        // если это был последний город на текущем уровне графа
        // удаляем весь уровень и т.д. в цикле
        while (routes.length && last(routes).length === 1) {
          routes.pop()
        }
        // если массив routes опустел, значит вариантов нет
        if (!routes.length) {
          route = 'no way'
        } else { // удаляем последний город последнего уровня
          last(routes).pop()
        }
      }

      // если маршрут еще не определен, добавляем then и запрашиваем
      // полеты для последнего города последнего уровня
      if (!route) {
        fetchPromise = fetchPromise.then(responseExecution)
        return fetchFlights(last(last(routes)))
      }
    }

    // стартуем промис получения полетов
    fetchPromise = fetchFlights(start).then(responseExecution)

    // Возвращаем промис, в котором запускаем интервал и резолвим,
    // когда route не пустой
    return new Promise((resolve, reject) => {
      const id = setInterval(() => {
        if (route) {
          clearInterval(id)
          resolve(route)
        }
      }, 1000)
    })
  }

const fetchFlights = city => {
    const flights = [
      ['A', 'B'],
      ['A', 'C'],
      ['A', 'D'],
      ['D', 'K'],
      ['D', 'L'],
      ['D', 'M'],
      ['M', 'Q'],
      ['M', 'Z'],
      ['L', 'G'],
      ['L', 'F'],
      ['F', 'Y']
    ]

    return Promise.resolve(flights.filter(item => item[0] === city).map(item => item[1]))
  }

new ymaps.Map("map", {

Object.values([ ...arr1, ...arr2 ].reduce((acc, n) => {
  acc[n.code] = n.id ? n : (acc[n.code] || n);
  return acc;
}, {}))