Определить подмассивы в заданном массиве
 

Имеется два массива: ms = [2, 8, 13, 15, 19, 27, 33, 36, 43, 46] и mo = [0, 4, 6, 11, 17, 21, 25, 31, 38, 41, 45, 48]. При слиянии этих массивов и расположении элементов полученного массива по возрастанию получаем mso = [0, 2, 4, 6, 8, 11, 13, 15, 17, 19, 21, 25, 27, 31, 33, 36, 38, 41, 43, 45, 46, 48]. Вывести массив, в котором каждый элемент является подмассивом из пары элементов, которые одновременно содержатся, либо в массиве ms или mo, по возрастанию: dd = [[4, 6], [13, 15], [21, 25], [33, 36], [45, 48]] и далее, при любом заданном значении, например, tp = 17 надо вывести соседние от tp подмоссивы:
[13, 15] < 17 < [21, 25] в виде dL = [13, 15] и dP = [21, 25]. Возможно tp попадёт внутрь какого – нибудь подмассива, тогда надо вывести соседние от этого массива подмассивы: tp = 23. Тогда [13, 15] < 23 < [33, 36] в виде dL = [13, 15] и dP = [33, 36]. Массивы ms и mo могут быть совершенно произвольными, также как, и расположение подмассивов.

поиск цепочек в массиве и фильтрация
 

IZUM,
задача прежняя, можно было не плодить темы, добавлена фильтрация к коду предложенному ранее, ловит и фильтрует не только пары, но и цепочки любой длины.

function repeat(arr) {
            let retry = [],
                temp;
            arr.reduce(
                function(prev, current, index, arr) {
                    if (prev === current) temp.push(index);
                    else temp = [index];
                    if (temp.length == 2) retry.push(temp);
                    return current;
                }
            );
            return retry
        }
        const ms = [2, 8, 13, 15, 19, 27, 33, 36, 43, 46],
            mo = [0, 4, 6, 11, 17, 21, 25, 31, 38, 41, 45, 48];

        function merge(a, b, l) {
            let s = [...a, ...b].sort((a, b) => a - b);
            let arr = s.map(k => a.includes(k));
            arr = repeat(arr).map(ar => ar.map(i => s[i]));
            if (l !== void(0)) {
                let i = arr.findIndex(([a, ...b]) => a > l);
                let dp = arr[i] || [],
                    dL = [];
                if (i > 0)
                    for (; i--;) {
                        let b = arr[i].at(-1);
                        if (b < l) {
                        dL = arr[i]; break;
                        }
                    }
                return [dL, dp]
            }
            return arr
        }
        console.log(merge(ms, mo));
        console.log(merge(ms, mo, 17));
        console.log(merge(ms, mo, 23));

Большое спасибо. Действительно исходные массивы похожи на прежние из прежней темы, но в настоящее время меня интересуют вопросы связанные, в основном, с массивами. И, эта тема затрагивает более серьёзную задачу (не продолжает предыдущую тему). Да, и Ваш код этому подтверждение - намного общирнее и сложнее. Проверил, всё работает правильно.

код исправлен, тестируйте внимательнее.

IZUM,
вариант для любого количества начальных массивов (все элементы разные)

function repeat(arr) {
            let retry = [],
                temp;
            arr.reduce(
                function(prev, current, index, arr) {
                    if (prev === current) temp.push(index);
                    else temp = [index];
                    if (temp.length == 2) retry.push(temp);
                    return current;
                }
            );
            return retry
        }
        const ms = [2, 8, 13, 15, 19, 27, 33, 36, 43, 46],
            mo = [0, 4, 6, 11, 17, 21, 25, 31, 38, 41, 45, 48],
            mt = [3, 22, 23, 24];
        function merge(...arg) {
            let l;
            if( typeof(arg.at(-1)) == "number") l = arg.pop();
            let s = arg.flat();
            s.sort((a, b) => a - b);
            let arr = s.map(k => arg.findIndex(a => a.includes(k)));
            arr = repeat(arr).map(ar => ar.map(i => s[i]));
            if (l !== void(0)) {
                let i = arr.findIndex(a => a[0] > l);
                let dp = arr[i] || [],
                    dL = [];
                if (i > 0)
                    for (; i--;) {
                        let b = arr[i].at(-1);
                        if (b < l) {
                        dL = arr[i]; break;
                        }
                    }
                return [dL, dp]
            }
            return arr
        }
        console.log(merge(ms, mo));
        console.log(merge(ms, mo, mt));
        console.log(merge(ms, mo, mt, 17));
        console.log(merge(ms, mo, mt, 25));

Я проверил первый код. Всё, (теперь уже, кажется) срабатывыло. Однако, не сработало при tp = 14. Правый подмассив [21, 35], появился правильно. а левый [4, 6] - НЕ ПОЯВИЛСЯ. Вместо него появилось пустое множество [ ], которое должно появлятся, но в другом случае. Я, тут обнаружил, что при появлении пустого подмножества [ ], дальнейшие расчёты невозможны, из -за undefined. Это при tp в самом начале и в самом конце mso. Может быть, что-то вставить в это [ ], чтобы после этого можно было его исключить при его появлении и далее, продолжить последующий расчёт. Второй код протестирую завтра. И, сразу возникает вопрос: Может ли, массив mt = [3, 22, 23, 24]; создаваться в коде, а не задаваться как, ms, mo. Вернее, я хотел сказать, что в ручную не получится создавать mt = [3, 22, 23, 24], потому что Ваш код встроен в мою основную программу.

не осилил, вам виднее какой нужен результат.

пусть будет [0, 0]. Вот массив mt = [3, 22, 23, 24];, как исходный, или заданный - проблема...

строки 26, 27 пост #5

let dp = arr[i] || [0, 0],
                    dL = [0, 0];

моя твоя не понимай :)

массив mt = [3, 22, 23, 24]; должен, создаваться в коде, при задании ms, mo. Исходными данными являются, только, ms, mo