0xD34F

Добавить блоку с текстом

white-space: nowrap;
position: absolute;

https://jsfiddle.net/b5koa7dm/

Добавляем в массив копию исходного объекта:

const defaultAnimals = {
  cat: '',
  dog: '',
  mouse: '',
  rhinoceros: '',
};

const animalsReducer = (state, action) => {
  switch (action.type) {
    case 'updateObj':
      return {
        ...state,
        obj: {
          ...state.obj,
          [action.payload.name]: action.payload.value,
        },
      };

    case 'addObjToArr':
      return {
        ...state,
        arr: [ ...state.arr, state.obj ],
        obj: defaultAnimals,
      };

    default:
      return state;
  }
};

const Animals = () => {
  const [ animals, dispatch ] = useReducer(animalsReducer, {
    obj: defaultAnimals,
    arr: [],
  });

  const onChange = ({ target: { name, value } }) => {
    dispatch({
      type: 'updateObj',
      payload: { name, value },
    });
  };
  
  const onSubmit = e => {
    e.preventDefault();
    dispatch({
      type: 'addObjToArr',
    });
  };

  return (
    <div>
      <form onSubmit={onSubmit}>
        {Object.entries(animals.obj).map(([ k, v ]) => (
          <div key={k}>
            <label>
              {k}:
              <input name={k} value={v} onChange={onChange} />
            </label>
          </div>
        ))}
        <button>Save</button>
      </form>
      <pre>{JSON.stringify(animals.obj, null, 2)}</pre>
      <pre>{JSON.stringify(animals.arr, null, 2)}</pre>
    </div>
  );
};

Или, добавляем в массив объект, содержащий значение только одного из свойств исходного объекта:

const animalsReducer = (state, action) => {
  switch (action.type) {
    case 'updateObj':
      return {
        ...state,
        obj: {
          ...state.obj,
          [action.payload.name]: action.payload.value,
        },
      };

    case 'addObjToArr':
      return {
        ...state,
        arr: [
          ...state.arr,
          {
            animal: action.payload,
            name: state.obj[action.payload],
          },
        ],
      };

    default:
      return state;
  }
};

const Animals = () => {
  const [ { obj, arr }, dispatch ] = useReducer(animalsReducer, {
    obj: {
      cat: '',
      dog: '',
      mouse: '',
      rhinoceros: '',
    },
    arr: [],
  });

  const onChange = ({ target: { name, value } }) => {
    dispatch({
      type: 'updateObj',
      payload: { name, value },
    });
  };
  
  const onSubmit = (e, animal) => {
    e.preventDefault();
    dispatch({
      type: 'addObjToArr',
      payload: animal,
    });
  };

  return (
    <div>
      {Object.entries(obj).map(([ k, v ]) => (
        <form onSubmit={e => onSubmit(e, k)} key={k}>
          {k}:
          <input name={k} value={v} onChange={onChange} />
          <button>Save</button>
        </form>
      ))}
      <pre>{JSON.stringify(obj, null, 2)}</pre>
      <pre>{JSON.stringify(arr, null, 2)}</pre>
    </div>
  );
};

[ ' '.join(sum(a, [])) ]

components: {
  componentName: () => import('...').then(component => {
    console.log(component.default.props);
    return component;
  }),
  ...
},

(entities[currentBrand] ?? []).map(n => (
  <ListItem>
    {n.icon}
    {n.label}
  </ListItem>
))

Рекурсия возможна:

const getFromTree = (tree, childrenKey, getter = n => n) =>
  Array.isArray(tree)
    ? tree.flatMap(n => [
        getter(n),
        ...getFromTree(n[childrenKey], childrenKey, getter),
      ])
    : [];

// или

function* flatTree(tree, childrenKey) {
  if (
    tree instanceof Object &&
    tree[Symbol.iterator] instanceof Function
  ) {
    for (const n of tree) {
      yield n;
      yield* getFromTree(n[childrenKey], childrenKey);
    }
  }
}

Но не обязательна:

const getFromTree = function(tree, childrenKey, getter = n => n) {
  const result = [];

  for (const stack = this(tree); stack.length;) {
    const n = stack.pop();
    result.push(getter(n));
    stack.push(...this(n[childrenKey]));
  }

  return result;
}.bind(x => x instanceof Array ? [...x].reverse() : []);

// или

const flatTree = function*(tree, childrenKey) {
  const stack = [];

  for (let [ i, arr ] = this(tree); ++i < arr.length || stack.length;) {
    if (i === arr.length) {
      [ i, arr ] = stack.pop();
    } else {
      yield arr[i];
      stack.push([ i, arr ]);
      [ i, arr ] = this(arr[i][childrenKey]);
    }
  }
}.bind(x => [ -1, x?.constructor === Array ? x : [] ]);

Извлекаем:

// если использовать обычную функцию
const result = getFromTree(tree, 'evolves_to', n => n.species);
// или, генератор
const result = Array.from(flatTree(tree, 'evolves_to'), n => n.species);

Что если в carIds присутствуют такие значения, которых нет среди id в cars?

Если получать undefined для вас окей, тогда

const result = carIds.map(n => cars.find(m => m.id === n));

Если нет, то вместо отсутствующих объектов можно подставлять какое-нибудь дефолтное значение:

const result = carIds.map(function(n) {
  return this[n] ?? 'такого объекта нет';
}, Object.fromEntries(cars.map(n => [ n.id, n ])));

Или, есть вариант для несуществующих id ничего не получать:

const carsMap = new Map(cars.map(n => [ n.id, n ]));
const result = carIds.reduce((acc, n) => (
  (n = carsMap.get(n)) && acc.push(n),
  acc
), []);

Работает. Удалять только бывает нечего. С чего вы взяли, что позиции элементов и их id в массивах elementData и selectedElArr будут совпадать? Индекс надо не передавать в метод, а вычислять самостоятельно внутри:

methods: {
  toggleElement(id) {
    const index = this.selectedElArr.indexOf(id);
    if (index !== -1) {
      this.selectedElArr.splice(index, 1);
    } else {
      this.selectedElArr.push(id);
    }
  },
  ...

@click="toggleElement(data.id)"

const selectors = [ '.addservice', '.addprice' ];
const data = Array.from(
  document.querySelectorAll('.addserviceBlock'),
  n => selectors.map(m => n.querySelector(m).value)
);

Заголовки, элемент меню и классы для его пунктов:

const headers = document.querySelectorAll('section > h2');
const menu = document.querySelector('вам виднее, что тут должно быть');
const className = 'inner__menu anchor-js';

Собираем разметку:

const menuHTML = Array.from(headers, n =>
  `<a class="${className}" href="#${n.parentNode.id}">${n.innerText}</a>`
).join('');

// можем добавить новое содержимое, не трогая то, что уже есть
menu.insertAdjacentHTML('beforeend', menuHTML);
// или новый контент перезапишет существующий
menu.innerHTML = menuHTML;

Или создаём элементы напрямую:

const menuElements = Array.from(headers, n =>
  Object.assign(document.createElement('a'), {
    className,
    href: `#${n.parentNode.id}`,
    text: n.textContent,
  })
);

// добавляем
menu.append(...menuElements);
// перезаписываем
menu.replaceChildren(...menuElements);

const wrapper = document.createElement('div');
const start = block.querySelector('.start');
for (let el; !(el = start.nextElementSibling).matches('.end'); wrapper.appendChild(el)) ;
start.insertAdjacentElement('afterend', wrapper);

или

const wrapper = document.createElement('div');
const children = [...block.children];
const iStart = children.findIndex(n => n.classList.contains('start'));
const iEnd = children.findIndex(n => n.classList.contains('end'));
wrapper.append(...children.slice(iStart + 1, iEnd));
children[iStart].after(wrapper);

data.reduce((acc, { unique, id, count, name }) => (
  ((acc[unique] ??= { count })[id] ??= []).push(name),
  acc
), {})

Кого хотим достать: const key = 'TicketNumber';.

Достаём:

const val = str.match(RegExp(`(?<=[?;]${key}=)[^;#]*`))?.[0];

// или

const val = new URL(str.replaceAll(';', '&')).searchParams.get(key);

// или

const val = Object.fromEntries(str
  .split('?')
  .pop()
  .split('#')
  .shift()
  .split(';')
  .map(n => n.split('='))
)[key];

def find_outlier(arr):
  n0, n1, n2 = [ n % 2 for n in arr[:3] ]
  return next(n for n in arr if n % 2 != n0) if n0 == n1 else arr[int(n2 == n0)]

Такие варианты есть:

1. Сделать компонент, который будет заниматься отображением данных только одного элемента массива, унести свойство show в этот компонент - у каждого экземпляра оно будет собственное, независимое от других.
   
2. Сделать свойство show массивом, хранить в нём id элементов, данные которых должны показываться.
   
3. Пусть элементы массива сами определяют, надо ли их содержимое демонстрировать - добавить свойство show каждому из них.
   

Это если данные в каждом из блоков должны отображаться независимо. Если же только в одном, тогда пусть свойство show содержит ссылку на соответствующий элемент массива или его индекс/id.

new_arr = []
for n in arr:
  if len(new_arr) == 0 or abs(new_arr[-1] - n) > 0.1:
    new_arr.append(n)

function chunked(str, numChunks) {
  const chunkSize = Math.ceil(str.length / numChunks);
  return Array.from(
    { length: numChunks },
    (_, i) => str.slice(i * chunkSize, (i + 1) * chunkSize)
  );
}

UPD. В комментариях докладывают:

неаккуратненько как-то:
chunked('test', 3) // [ "te", "st", "" ]

Это поправимо. Наверное. Размер куска округляем вниз. Есть два варианта:

Первый - закидываем остаток в последний кусок:

const chunked = (str, numChunks) =>
  Array.from(
    { length: numChunks },
    function(_, i) {
      return str.slice(this(i), i < ~-numChunks ? this(-~i) : str.length);
    },
    i => i * (Math.max(1, str.length / numChunks | 0))
  );

Второй - раскидываем по одному дополнительному элементу в те куски, что идут первыми:

function chunked(str, numChunks) {
  const chunkSize = str.length / numChunks | 0;
  const numLooseItems = str.length % numChunks;
  const chunkIndex = i => i * chunkSize + Math.min(i, numLooseItems);

  return Array.from(
    { length: numChunks },
    (_, i) => str.slice(chunkIndex(i), chunkIndex(-~i))
  );
}

Object
  .entries(arr.reduce((acc, n) => (
    ((acc[n.category.name] ??= {})[n.subCategory.name] ??= []).push(n),
    acc
  ), {}))
  .map(n => ({
    name: n[0],
    subcategory: Object
      .entries(n[1])
      .map(m => ({ name: m[0], data: m[1] })),
  }))

const newStr = str.replace(/\d.*/, '');
// или
const newStr = str.match(/^\D*/)[0];
// или
const newStr = str.split(/[0-9]/).shift();
// или
const newStr = str.slice(0, str.search(/\d|$/));
// или
const newStr = /[^\d]*/.exec(str).pop();
// или
const newStr = [...str].reduceRight((acc, n) => '0123456789'.includes(n) ? '' : acc + n, '');