Daily Challenge #232 - Regex Pattern

// Javscript

const regex_contains_all = chars =>
  new RegExp(
    chars
      .split("")
      .map(c => `(?=.*${c})`)
      .join("")
  )

// Test

const abc = 'abc'
const re = regex_contains_all(abc)
;[
  re.test('bca'),
  re.test('baczzz'),
  re.test('ac'),
  re.test('cb')
]

This uses "positive lookahead" patterns to match multiple patterns to the same spans.
This allows me to avoid listing all the permutations.
That is not to say that the runtime will be anything but atrocious.

Truly a oneliner

const regex_contains_all = chars => new RegExp(chars.replace(/./g,'(?=.*$&)'))

I'm not sure why you would want to implement this as a regular expression. There's no compact way (that I could think of) to represent those rules as a regular language. Here's my solution, in javascript.

function permutations(list) {
  if (list.length === 1) return [list];
  const xs = [];
  for (let i = 0; i < list.length; i++) {
    const tails  = permutations(list.filter((y, j) => j !== i));
    xs.push(...tails.map(ys => [list[i], ...ys]));
  }
  return xs;
}

function regexContainsAll(chars) {
  const regex = permutations(chars.split(''))
    .map(pattern => `^.*${pattern.join('.*')}.*$`)
    .join('|');
  return regex;
}

For example, input 'abc' produces the string 'a.*b.*c|a.*c.*b|b.*a.*c|b.*c.*a|c.*a.*b|c.*b.*a'.

As a side note, why do all of these challenges have "tests" that don't include expected results? It doesn't help me understand the question if they don't tell me what the function is supposed to do...

function regex_contains_all(chars, caseSensitive) {
  return new RegExp(`^[${chars}]*$`, caseSensitive ? undefined : "i");
}

• it's case-insensitive by default -- the question isn't clear about case sensitivity
• the stated tests look like they are meant for Python, so here's a self-contained test suite:

function assert(condition) {
    if (!condition) {
        throw new Error("FAIL");
    }
}

var abc = 'abc'
var pattern = regex_contains_all(abc)
assert("bca".match(pattern) !== null);
assert("baczzz".match(pattern) === null);
assert("ac".match(pattern) !== null);
assert("cb".match(pattern) !== null);

Can I just check...
This looks for every character in the requirement string must be there, and it doesn't matter which order, right? So my understanding is that the tests should give:

abc = 'abc'
pattern = regex_contains_all(abc)

bool(re.match(pattern, 'bca')) => true
bool(re.match(pattern, 'baczzz')) => true
bool(re.match(pattern, 'ac')) => false
bool(re.match(pattern, 'cb')) => false