0xD34F

.filter(function (el, i) {
  return arr[i] === el[i];
})

const arr = Array.from({ length: hMax }, (_, i) => i + 1);
const result = arr.reduce((acc, number) => (
  Array.prototype.reduce.call(
    `${number}`,
    (diff, digit) => diff - digit ** exp,
    number
  ) || acc.push(number),
  acc
), []);

const result = [];
for (let i = 1; i <= hMax; i++) {
  let sum = 0;
  for (let j = i; j; j = Math.floor(j / 10)) {
    sum += (j % 10) ** exp;
  }
  if (i === sum) {
    result[result.length] = i;
  }
}

const arr = Array.from(
  { length: -~(Object.keys(obj).at(-1) ?? -1) },
  (n, i) => obj[i] ?? null,
);

const arr = Object.entries(obj).reduce((acc, n) => (
  acc.push(...Array(n[0] - acc.length).fill(null), n[1]),
  acc
), []);

const dashoffset = circleRef.current - ...

const getSctollTop = () => {
  return window.pageYOffset || document.documentElement.scrollTo;
}

React.useEffect(() => {
  ...
  window.addEventListener("scroll", () => {
    ...
  });

}, []);

Как должен выглядеть json...

[
  {
    title: '...',
    children: [
      {
        title: '...',
        children: [
          {
            title: '...',
          },
          ...
        ],
      },
      ...
    ],
  },
  ...
]

...для генерации такого вложенного списка через v-for?

name: 'v-tree',
props: [ 'items' ],

<ul v-if="Array.isArray(items) && items.length">
  <li v-for="n in items">
    {{ n.title }}
    <v-tree :items="n.children" />
  </li>
</ul>

const popup =createApp(App);

popup.$store.dispatch

re.sub(r'(?<=[^\d\s])(?=\d)|(?<=\d)(?=[^\d\s])', ' ', text)

const searchOptions = [
  [ '#search_table', tr => $('input[name^=name]', tr).val() ],
  [ '#search_card', tr => $('[data-item-name="name"]', tr).text() ]
];

$(searchOptions.map(n => n[0]).join(', ')).on('input', () => {
  const values = searchOptions.map(n => $(n[0]).val().toLowerCase());

  $('#tabname tbody tr')
    .hide()
    .filter((i, n) => searchOptions.every((m, j) => m[1](n).toLowerCase().includes(values[j])))
    .show();
});

const sorted = (arr, key) => arr
  .map(n => [ key(n), n ])
  .sort(([a], [b]) => a < b ? -1 : +(a > b))
  .map(n => n[1]);

const sortedArr = sorted(
  arr,
  n => new Date(n.replace(/(\d+)\.(\d+)\.(\d+),/, '$3-$2-$1'))
);

// или

const sortedArr = sorted(
  arr,
  n => n.replace(/[^,]+/, m => m.split('.').reverse().join(''))
);

`${arr}`.match(/\b\w{5}\b/g) || []

// или

arr.reduce((acc, n) => (n.length ^ '0b101' || acc.push(n), acc), [])

// или

arr.filter(n => n[4] && !n[-~4])

// или

arr.filter(RegExp.prototype.test.bind(/^.....$/))

// или

arr.reduce((acc, n) => ((acc[n.search('$')] ??= []).push(n), acc), {})[5] ?? []

// или

(function get(i, n = arr[--i]) {
  return i >= 0
    ? get(i).concat(5 - [].push(...n) ? [] : n)
    : [];
})(arr.length)

function getNestedData(data, test) {
  const result = [];

  for (const stack = [ data ]; stack.length;) {
    const n = stack.pop();

    if (n instanceof Object) {
      stack.push(...Object.values(n).reverse());
    }

    if (test(n)) {
      result.push(n);
    }
  }

  return result;
}


console.log(getNestedData(tree, Number.isFinite));

print('\n'.join(f'{i}. {n}' for i, n in enumerate(clan_members, 1)))

computed: {
  bullshitEmails() {
    const search = this.search.trim().toLowerCase();
    return this.emails.map(n => ({
      email: n,
      marked: !!search && n.toLowerCase().includes(search),
    }));
  },
},

<ul>
  <li
    v-for="{ email, marked } in bullshitEmails"
    v-text="email"
    :class="{ marked }"
  ></li>
</ul>

arr = [ '3.1', '5.1', '1.3', '2.2', '13.3' ]
num = '5.666'

print('OK' if any(n.split('.')[0] == num.split('.')[0] for n in arr) else 'FUCK OFF')

const firstNonRepeatingLetter = ([...str]) => Object
  .values(str.reduce((acc, n, i) => ((acc[n.toLowerCase()] ??= [ 0, i, n ])[0]++, acc), {}))
  .reduce((min, n) => (n[0] === 1 && n[1] < min[1] ? n : min), [ 0, Infinity, '' ])
  .pop();

const firstNonRepeatingLetter = str =>
  str.charAt(Array
    .from(str.toLowerCase())
    .findIndex((n, i, a) => a.indexOf(n) === a.lastIndexOf(n))
  );

async function() {
  let result = null;

  while (1) {
    result = await fetch(...);

    if (result тот, который нужен) {
      break;
    }

    await new Promise(r => setTimeout(r, 5000));
  }

  return result;
}

grouped = {}

for n in products:
  category = n['category']['name']
  group = grouped.setdefault(category, {})
  group[n['productId']] = { 'name': n['name'] }

const [ date = null ] = arr.map(n => n.date).sort();

const date = arr.reduce((min, { date: n }) => min !== null && min < n ? min : n, null);

const date = arr.length
  ? new Date(Math.min(...arr.map(n => new Date(n.date)))).toISOString()
  : null;