Как Яндекс научил меня собеседовать программистов

Вот решение в духе Яндекса:
const getRanges = arr => arr
.reduceRight((r, e) => r.length? (r[0][0] === e + 1? r[0].unshift(e): r.unshift([e])) && r: [[e]], [])
.map(a => a.join('-')).join(',')

Поможет ли гугление писать такие элегантные решения?

— Не предлагал писать код на бумаге, но просил писать в code.yandex-team.ru. Это многопользовательский онлайн-редактор кода без возможности его выполнения. Возможно, есть и другой, боле удобный вариант, но искать и было, и осталось лень;

public addTicket(data: IAddTicketData): Promise<number> {
  const fromEmail = data.fromEmail;
  const category = data.category;

  return Promise.all([
    fromEmail ? this.getUserByEmail(fromEmail) : undefined,
    category === 'INCIDENT' && this.isCategorizableType(data.type),
  ])
  .then(([user, isCategorizable]) => this.twig.render('Assyst/Views/add.twig', {
    from: fromEmail,
    text: data.text,
    category: isCategorizable ? 'INC_RFC' : category,
    user,
  }))
  .then(xml => this.query('events', 'post', xml))
  .then(response => new Promise((resolve, reject) => {
    xml2js.parseString(response, (err, result) => {
      const error = err || result.exception;

      if (error) {
        reject(error);
      } else {
        resolve(result.event.id - 5000000);
      }
    });
  }));
}

Но вот с тезисом о практической бесполезности яндексовских заданий я не соглашусь. Даже рутинная разработка нет-нет, да поставит перед тобой задачу, у которой есть несколько решений.

Одна из задач нашего технического интервью:

let n = 0
while (++n < 5) {
setTimeout(() => console.log(n), 10 + n)
}
// Что будет выведено в консоль?

Мне не нравятся оба приведенных решения для getRanges — по моему мнению, они оба нечитаемая лапша, так как с первого взгляда трудно понять логику выполнения кода. В них идет злоупотребление функциями вроде map(), которые тут не нужны и служат лишь цели показать знание ES6, хотя в задаче этого не требуется. Вместо того, чтобы сделать решение самым простым способом, вы пишете код, который надо долго разбирать, который делает какие-то хитрые преобразования и на который будут плеваться все, кому придется его читать.

Если в Яндексе или у вас так пишут, то я сочувстсвую вашим разработчикам.

Я хочу сделать другое решение — максимально простое и последовательное, которое будет легко прочесть и понять другим разработчикам. И которое не будет демонстрировать знание функций вроде map/reduce, хотя я их знаю, хотя я и не помню список аргументов reduce без заглядывания в MDN, хотя я не вижу тут проблемы. Логика функции проста:

• сортировка значений по возрастанию
• группировка в массив диапазонов
• форматирование и склеивание диапазонов

У меня получается такой код, я использую ES3 для макс. совместимости, так как в задаче ничего про версию языка не сказано.

/**
 * Принимает на вход массив значений вида [1, 2, 3, 5, 7, 8] и возвращает
 * массив диапазонов вроде "1-3,5,7-8".
 *
 * @param {int[]} values
 * @return {string}
 */
function getRanges(values) {

    // Массив диапазонов вида "2-5" или "7"
    var ranges = [];
    function addRange(start, end) {
        if (end == start) {
            ranges.push(start);
        } else {
            ranges.push(start + "-" + end);
        }
    }

    // Делаем копию массива и сортируем ее
    values = values.slice();
    values.sort();
    if (!values.length) {
        return "";
    }

    var start = values[0], end = values[0];

    for (var i = 1; i < values.length; i++) {
        var value = values[i];
        if (value == end - 1) {
            end = value;
            continue;
        }

        addRange(start, end);       
        start = end = value;            
    }

    // Добавляем последний диапазон, который мы не добавили внутри цикла
    addRange(start, end);    
    return ranges.join(",");
}

Ну и раз уж речь зашла про задания с собеседований, вот задача, которая мне нравится, хотя возможно, она и не очень полезная. Объясните, почему в некоторых реализациях JS (например, в Firefox и Chrome) следующий код выдает такие результаты:

0.1 + 0.1 === 0.2  // true
0.1 + 0.1 + 0.1 === 0.3  // false
0.1 + 0.1 + 0.1 + 0.1 === 0.4 // true

Если вы смогли объяснить, то расскажите, каким математическим условиям должны соответствовать числа, чтобы их можно было представить в этих реализациях JS точно и без ошибок. Если не можете, то идите учить теорию, а не по собеседованиям ходите.

способных писать крутой код

<script>

function generateTest()
{
  var test = [];
  for (var i = 0; i < 10000000; i++)
    if (Math.random() < 0.8)
      test.push(i);
  return test;
}

const getRanges = arr => arr
  .reduceRight((r, e) => r.length ? (r[0][0] === e + 1 ? r[0].unshift(e): r.unshift([e])) && r: [[e]], [])
  .map(a => a[0] + (a.length > 1 ? '-'+a[a.length - 1]: '')).join(',')


function getRanges2(arr)
{
  var ranges = [];
  var start = 0;
  var size = arr.length;
  while (start < size)
    for (var i = start + 1; i <= size; i++)
    {
      if (i == size || arr[i] !== arr[i - 1] + 1)
      {
        ranges.push(i == start + 1 ? '' + arr[i - 1] : '' + arr[start] + '-' + arr[i - 1]);
        start = i;
        break;
      }
    }

  return ranges.join(',');
}


window.onload = function ()
{
  var a = generateTest();

  var t0 = performance.now()
  var tmp1 = getRanges(a);
  var t1 = performance.now()
  var tmp2 = getRanges2(a);
  var t2 = performance.now()

  alert('' + (t1 - t0) + ', ' + (t2 - t1) + '');

  if (tmp1 !== tmp2)
    alert('error');
}

</script>

Promise.resolve().then(() => fetch(url))

/* Необходимо реализовать функцию getRanges, которая возвращает следующие результаты: */
getRanges([0, 1, 2, 3, 4, 7, 8, 10]) // "0-4,7-8,10"
getRanges([4,7,10]) // "4,7,10"
getRanges([2, 3, 8, 9]) // "2-3,8-9"

function getRanges(arr) {
    if (arr.length === 3) return "4,7,10"
    else if (arr.length === 4) return "2-3,8-9"
    else if (arr.length === 8) return  "0-4,7-8,10"
    return false;
}

function fetchUrl(url, attempt = 5) {
  return Promise.resolve()
    .then(() => fetch(url))
    .catch(() => attempt-- ? fetchUrl(url, attempt) : Promise.reject('Fetch failed after 5 attempts'))
}'error'

--attempt

Решал похожую задачу на Scala когда выполнял задачки с курса, там я решил сделать моноид ренжей:

object Monoid {
  sealed trait Ordered // это АДТ в стиле scala, всего 3 варианта
  case class Range(a: Int, b: Int) extends Ordered
  case object Unordered extends Ordered
  case object Mempty extends Ordered

  def orderMonoid: Monoid[Ordered] = new Monoid[Ordered] {
    def zero: Ordered = Mempty
    def op(a: Ordered, b: Ordered): Ordered = (a, b) match {
      case (Range(la, ha), Range(lb, hb)) if ha <= lb => Range(la, hb)
      case (Mempty, i) => i
      case (i, Mempty) => i
      case _ => Unordered
    }
  }

Объявляем энум, нас ренж либо пустой, либо неупорядочен, либо упорядоченный ренж a-b.

Ну и дальше в мой задаче нужно было определить, является ли список упорядоченным:

  def isOrdered(v: Seq[Int]): Boolean = {
    // превращаем каждый элемент списка в упорядоченный ренж из него же самого
    // а потом делаем свертку плюсом моноида
    foldMap(v, orderMonoid)(a => Range(a, a)) match {
      case Unordered => false
      case _ => true
    }
  }

Вроде все достаточно очевидно, по аналоги можно решить и эту задачу.
А однострочник из нечитаемых мутирующих функций назвать читаемым, к сожалению, не могу, как и "ФПшным".

К слову, и формулировка задачи странная:

/ Необходимо реализовать функцию getRanges, которая возвращает следующие результаты: /

Есть бесконечное множество функций которые будут выдавать такие результаты, вплоть до switch case из трех веток.

Чисто для популяризации Crystal — на нём реализация. Почти как Ruby, но не совсем.

alias LR = Tuple(Int32, Int32)
alias S = Tuple(Int32)

def getRanges(a : Array(Int32))
  a.reduce([] of LR | S) { |total, cur|
    total << (total.pop?.try { |x|
      if cur - x.last <= 1
        { x.first }
      else
        total << x
        Tuple.new
      end
    } || Tuple.new) + { cur }
  }.map { |el| el.join('-') }.join(',')
end

А еще проще там задач нет? Скучно.

const getRanges = (numbers) => {
    const normalized = numbers.slice().sort((a, b) => a - b)
    let latest = null
    return normalized.reduce((ranges, n) => {
        const i = latest !== n - 1 ? ranges.push([]) : ranges.length
        latest = n
        ranges[i - 1].push(n)
        return ranges
    }, []).map((range) => {
        return range.length === 1 ? range[0] : `${range[0]}-${range[range.length - 1]}`
    }).toString()
}

Ну и чисто по фану, то же самое, только пожатое до мама не горюй ) Напишите кто-нибудь короче:

const getRanges = (n,l)=>''+n.slice().sort((a,b)=>a-b).reduce((r,n)=>(r[(l!==n-1?r.push([]):r.length)-1].push(l=n),r),[]).map(r=>r.length===1?r[0]:`${r[0]}-${r[r.length-1]}`)

Можно еще на 5 знаков короче:

const getRanges = (n,l,x='length')=>''+n.slice().sort((a,b)=>a-b).reduce((r,n)=>(r[(l!==n-1?r.push([]):r[x])-1].push(l=n),r),[]).map(r=>r[x]===1?r[0]:r[0]+'-'+r[r[x]-1])

public static String getRanges(List<Integer> l) {
  // Begin ranges & End ranges (br & er)
  List<Integer> br = new ArrayList<>();
  List<Integer> er = new ArrayList<>();

  l.stream().reduce(l.get(0)-2, (a, b) -> {
    if (Math.abs(a-b) > 1 && a < b) {
      er.add(a);
      br.add(b);
    }
    return b;
  });
  er.remove(0);
  er.add(l.get(l.size()-1));

  // Zip & join
  return IntStream
    .range(0, Math.min(br.size(), er.size()))
    .mapToObj(i -> (br.get(i) != er.get(i)) 
                    ? br.get(i) + "-" + er.get(i) 
                    : br.get(i) + "")
    .collect(Collectors.joining(", "));
}