Какой код нужно показывать на собеседовании

Глупый вопрос — а было входное условие что массив будет отсортирован? не увидел у вас в описании задачаи

иии эта задача в таком виде начинает занимать O(n), где n — количество интервалов.
предполагаю, что задача оценивала в том числе способность к reduce с O(1), где на лету добавляются символы к строке.

К тому же — читаемость это спорный вопрос. Читать тридцать строк там, где можно примерно понять, что происходит всего за одну — то еще удовольствие.

    let out : String = "";
    for (let i = 0; i < intervals.length; i++) {
        out += intervals[i].toString(arr);

        if (i < intervals.length - 1) {
            out += ',';
        }
    }

К сожалению, этот пост уже не доступен

Я считаю, что класс является лишней сущностью. Вообще мое решение было бы таким:

function* generateRanges(numbers: number[]) {
    let start = numbers.shift();
    let end = start;
    const format = (s, e) => s === e ? `${s}` : `${s}-${e}`;

    for (const i of numbers) {
        if (i !== end + 1) {
            yield format(start, end);
            start = end = i;
        } else {
            end = i;
        }
    }
    yield format(start, end);
}

function getRanges(numbers: number[]) {
    return [...generateRanges(numbers)].join(',');
}

А так же добавил бы, что при необходимости для большого набора чисел или если они будут идти в потоке, то данный код можно было бы легко оптимизировать избавившись от массива с join()

function getRanges(numbers: number[]) {
    let result = "";

    for (const range of generateRanges(numbers)) {
        result += result === "" ? `${range}`: `,${range}`;
    }

    return result;
}

Продолжаю тренироваться в хаскелле.

Там выглядит вот так:

getRanges :: [Int] -> [(Int, Int)]
getRanges = foldr go ([])
  where
    go x [] = [(x, x)]
    go x t@((l, r):as)
      | l - x == 1 = ((x, r) : as)
      | otherwise = (x, x) : t

main :: IO ()
main = print $ getRanges [0, 1, 2, 3, 4, 7, 8, 10]

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

Подумал, что две ветки можно объединить:

getRanges :: [Int] -> [(Int, Int)]
getRanges = foldr go ([])
  where
    go x t = case t of 
      ((l, r):as) | l - x == 1 -> ((x, r) : as)
      _ -> (x, x) : t

main :: IO ()
main = print $ getRanges [0, 1, 2, 3, 4, 7, 8, 10]

Дядюшка Боб писал, что код должен читаться легко как проза, не заставляя подолгу вдумываться и гадать, что автор кода здесь имел ввиду. В таком коде и намного меньше вероятность совершить ошибку, что является критичным в больших проектах.

Хотел бы оставить пример, какой код меня удовлетворил бы, доводись мне как лиду задать такую задачу на собеседовании

function getRanges(input) {
    const intervals = [[]]
    input.forEach(item => {
        const last = intervals[intervals.length - 1]
        if (last.length === 0 || last[last.length - 1] === item - 1) {
            last.push(item)
        } else {
            intervals.push([item])
        }
    })
    const result = intervals.map(arr => {
        return arr.length == 1 ? arr[0] : `${arr[0]}-${arr[arr.length - 1]}`
    })
    return result.join(',')
}

разделение расчёта и форматирования
адекватное название переменных
без откровенных хаков
без лишних тяжелых абстракций, типа класса для интервала из поста или генераторов из соседнего комментария

function getRanges(arr){
  return arr.reduce((m,n)=>{
    let range = m[m.length - 1] || [];
    if(range[range.length - 1] + 1 === n){
      range.push(n);
    }else{
      m[m.length - 1] = range.length > 1 ? [range[0], range[range.length-1]].join('-') : range[0];
      m.push([n]);
    }
    return m;
  }, [])
  .join(',')
}

Ну вот за минут 7-8 получилось так:

const getRanges = arr =>
    arr.reduce(
        (intervals, value) => {
            const currentInterval = intervals.length && intervals[intervals.length - 1];
            if (currentInterval && (currentInterval.length === 1 || value - currentInterval[1] === 1)) {
                currentInterval[1] = value;
            } else {
                intervals.push([value]);
            }
            return intervals;
        },
        []
    ).reduce(
        (formattedString, interval, index) =>
            formattedString + (index ? ',' : '') + interval.join('-'),
        ''
    );

const getRanges = (array: number[]): string => {
  let result = "";
  for (let i = 0; i < array.length; i++) {
    result += array[i];
    let rangeLength = 1;
    while (array[i] + rangeLength === array[i + rangeLength]) {
      rangeLength++;
    }
    if (rangeLength > 1) {
      result += `-${array[i + --rangeLength]}`;
      i += rangeLength;
    }
    result += ",";
  }
  return result.slice(0, -1);
};

К сожалению, этот пост уже не доступен, и приведенное решение я сейчас не восстановлю.

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(',')

function renderInterval({ from, to }) {
  return to === from ? from : `${from}-${to}`;
}

function getRanges(sourceArr) {
  if (!sourceArr.length) return '';

  // predefined first interval
  let lastInterval = { from: sourceArr[0], to: sourceArr[0] };
  const result = [lastInterval];

  for(let idx = 1; idx < sourceArr.length; ++ idx) {
    const n1 = sourceArr[idx - 1];
    const n2 = sourceArr[idx];

    if (n2 !== n1 + 1) {
      // close the previous interval and start a new one
      lastInterval = { from: n2, to: n2 };
      result.push(lastInterval);
    } else {
      lastInterval.to = n2; // amend right edge
    }
  }

  return result.map(renderInterval).join(',');
};

А вот так достаточно простой и понятный код? Не совсем понятно зачем автор сделал целый класс ради ручной имплементации .join('-').

/**
 * Дан список целых чисел, повторяющихся элементов в списке нет.
 * Нужно преобразовать это множество в строку,
 * сворачивая соседние по числовому ряду числа в диапазоны.
 */

compress([1, 4, 5, 2, 3, 9, 8, 11, 0]) // '0-5,8-9,11'
compress([1, 4, 3, 2]) // '1-4'
compress([1, 4]) // '1,4'

// 0 1 2 3 4 5 8 9 11

function compress(list) {
    const sortedArr = list.sort((a,b)=>a>b?1:-1);
    const result = [];
    let position = 0;

    for (let i=1; i<=sortedArr.length; ++i){
        if (sortedArr[i]-i+position!==sortedArr[position]){
            if (sortedArr[i-1] === sortedArr[position]){
                result.push(sortedArr[position].toString());
            } else {
                result.push(sortedArr[position] + '-' + sortedArr[i-1]);
            }
            position = i;
        }
    }

    return result.join(',');
}

package main

import (
	"fmt"
	"strconv"
	"strings"
)

type Period struct {
	start *int
	end   *int
}

func (period *Period) AddStart(start int) {
	period.start = &start
}

func (period *Period) AddEnd(end int) {
	period.end = &end
}

func (period *Period) ToString() string {
	if period.start == nil {
		return strconv.Itoa(*period.end)
	}
	if period.end == nil {
		return strconv.Itoa(*period.start)
	}
	return strconv.Itoa(*period.start) + "-" + strconv.Itoa(*period.end)
}

type Language struct {
	Periods []Period
}

func (language *Language) ToString() string {
	out := []string{}
	for _, token := range (*language).Periods {
		out = append(out, token.ToString())
	}
	return strings.Join(out, ",")
}

func main() {
	arr := []int{1, 2, 3, -1, 10, 11, 12, 4, 5, 6, 12, 13, -1, -2, -1, 0}
	str := GetRanges(arr)
	fmt.Print(str)
}

func GetRanges(arr []int) string {
	language := Tokenize(arr)
	return language.ToString()
}

func Tokenize(arr []int) (tokens Language) {
	lexema := &Period{}
	for index, item := range arr {
		switch true {
		case index == 0:
			lexema.AddStart(item)
			break
		case index == len(arr)-1:
			lexema.AddEnd(item)
			tokens.Periods = append(tokens.Periods, *lexema)
			break
		case item+1 != arr[index+1]:
			lexema.AddEnd(item)
			tokens.Periods = append(tokens.Periods, *lexema)
			lexema = &Period{}
			break
		case item+1 == arr[index+1] && lexema.start == nil:
			lexema.AddStart(item)
			break
		}

	}
	return
}

g x = foldl f [(head x, head x)] (tail x) where f ((a,b):xs) c = if b + 1 == c then (a,c):xs else (c,c):(a,b):xs

def get_ranges(inp):
  if len(inp) == 0: return ""
  out = ""
  i = s = e = 0
  while i < len(inp):
    i += 1
    if i != len(inp) and inp[e] + 1 == inp[i]:
      e = i
      continue
    out = ("{}{}," if s == e else "{}{}-{},").format(out, inp[s], inp[e])
    s = e = i
  return out[:-1]

create function dbo.get_ranges()
returns varchar(max)
as  
begin
  return 
  stuff(
    (select ',' + cast(i1.item as varchar) + isnull('-' + cast(
      (select min(i2.item) 
      from items i2
      where not exists(select * from items where item=i2.item+1) and i2.item>i1.item) as varchar),'')
    from items i1
    where not exists(select * from items where item=i1.item-1)
    for xml path(''),type).value('.','varchar(max)'), 
  1, 1, '')
end

go

create table items (item int)
insert into items (item) select 0 union select 1 union select 2 union select 3 union select 4 union select 7 union select 8 union select 10

select dbo.get_ranges()

partitionByCond :: Ord a => (a -> a -> Bool) -> [a] -> [[a]]
partitionByCond cond = para psi where
  psi t = case t of 
    Nil -> []
    Cons x (a:_, a':b') | cond x a -> (x:a'):b'
    Cons x (_, r) -> [x]:r

> partitionByCond (\x y -> x == y - 1) [0, 1, 2, 3, 4, 7, 8, 10]
[[0,1,2,3,4],[7,8],[10]]

Я бы такой код не пропустил на код-ревью по параметру читаемости:

• комментарии не просто говорят, а кричат о необходимости выноса кусков в отдельные функции
• скорее всего отдельные функции и тела циклов
• возможно условия в переменные

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(", "));
}