objectron | generic model to test equality | Regex library

^(?=[1-5]{5}$)(?=.*(\d)(?:.*\1){2})(?=.*(?!\1)(\d).*\2)\d+$
^(?=.*(\d)(?:.*\1){2})(?=.*(?!\1)(\d).*\2)[1-5]{5}$

function sanitize(input) {
    return input
      .toLowerCase()
      .replace(/([^a-z\d\s]+)/g, ' ')
      .replace(/(\s+)/g, ' ');
}

console.log(sanitize('Hello, David World 123!'));
console.log(sanitize('hELlo.,     <>;dAVId  world  .;- 123'));
console.log(sanitize('He.llo     David,   w!orld 123#'));

const capitalise = str => str.slice(0,1).toUpperCase() + str.slice(1); // you can add more tests

const str = "tenancy_account__accountPublicId__workspace__workspacePublicId__remove-user__userPublicId"
const newStr = str.split(/_+/)
  .map(word => capitalise(word))
  .join("")
console.log(newStr)

const str = "tenancy_account__accountPublicId__workspace__workspacePublicId__remove-user__userPublicId_"

const newStr = str.replace(/(?:_+|^)(\w)?/g, (_,letter) => letter?.toUpperCase() ?? "")

console.log(newStr)

import java.util.regex.Pattern;
import java.util.function.Predicate;

public class main
{
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("abc");

        // asPredicate will match any part of the input string
        Predicate asPredicate = pattern.asPredicate();
        
        // True, because abc is part of abc
        System.out.printf("asPredicate: abc: %s\n", asPredicate.test("abc"));

        // True, because abc is part of abcabc
        System.out.printf("asPredicate: abcabc: %s\n", asPredicate.test("abcabc"));

        // True, because abc is part of 123abc123
        System.out.printf("asPredicate: 123abc123: %s\n", asPredicate.test("123abc123"));

        // False, because abc is NOT part of 123
        System.out.printf("asPredicate: 123: %s\n", asPredicate.test("123")); // -> false

        // asMatchPredicate will only match the entire input string
        Predicate asMatchPredicate = pattern.asMatchPredicate();

        // True, because abc exactly matches abc
        System.out.printf("asMatchPredicate: abc: %s\n", asMatchPredicate.test("abc"));

        // False, because abc does not exactly match abcabc
        System.out.printf("asMatchPredicate: abcabc: %s\n", asMatchPredicate.test("abcabc"));

        // False, because abc does not exactly match 123abc123
        System.out.printf("asMatchPredicate: 123abc123: %s\n", asMatchPredicate.test("123abc123"));

        // False, because abc does not exactly match 123
        System.out.printf("asMatchPredicate: 123: %s\n", asMatchPredicate.test("123"));
    }
}

regex b1("1(?!1)");

my @fails1 = grep(/^[^befghjklmpqrsuvwxyz]+$/, @test_data);
my @fails2 = grep(/^[^@unwanted_letters]+$/, @test_data);

my @wanted = grep(/^[@wanted_letters]+$/, @test_data);

^(ABRS|BARS|RABS|ARBS|BRAS|RBAS|RBSA|BRSA|SRBA|RSBA|BSRA|SBRA|SARB|ASRB|RSAB|SRAB|ARSB|RASB|BASR|ABSR|SBAR|BSAR|ASBR|SABR)

^((AB|BA)(RS|SR)|(AR|RA)(BS|SB)|(AS|SA)(BR|RB)|(BR|RB)(AS|SA)|(BS|SB)(AR|RA)|(RS|SR)(AB|BA))

ABRS
ABSR
BARS
BASR

(Get-Content test.txt) -replace '^(\s*"Version"\s*:\s*")[^"]*', '${1}10' | Set-Content test.txt

--------------------------------------------------------------------------------
  ^                        the beginning of the string
--------------------------------------------------------------------------------
  (                        group and capture to $1:
--------------------------------------------------------------------------------
    \s*                      whitespace (0 or more times (matching the most
                             amount possible))
--------------------------------------------------------------------------------
    "Version"                '"Version"'
--------------------------------------------------------------------------------
    \s*                      whitespace (0 or more times (matching the most
                             amount possible))
--------------------------------------------------------------------------------
    :                        ':'
--------------------------------------------------------------------------------
    \s*                      whitespace (0 or more times (matching the most
                             amount possible))
--------------------------------------------------------------------------------
    "                        '"'
--------------------------------------------------------------------------------
  )                        end of $1
--------------------------------------------------------------------------------
  [^"]*                    any character except: '"' (0 or more times
                           (matching the most amount possible))

const sentence = `[t1]Sometimes[/t1] that's [t2]just the way[/t2] it has to be. Sure, there were [t3]probably[/t3] other options, but he didn't let them [t4]enter his mind[/t4]. It was done and that was that. It was just the way [t5]it[/t5] had to be.`


const parts = [
  "Sometimes that's just the way",
  "it has to be.",
  "Sure,",
  "there were probably other options,",
  "but he didn't let them enter his mind.",
  "It was done and that was that.",
  "It was just the way it had to be."
];

let bufferWithoutTags = ""
let bufferWithTags = ""
const output = []
const buffers = []
let tagOpened = false

for (let i = 0; i < sentence.length; ++i) {
  let c = sentence[i]
  bufferWithTags += c
  if ( c === '[') {
    if (tagOpened && sentence[i+1] === "/") {
      tagOpened = false
    } else {
      tagOpened = true
    }
    while (c != ']') {
      c = sentence[++i]
      bufferWithTags += c
    }
  } else {
    bufferWithoutTags += c;
  }
  if (!tagOpened) {
    for (const part of parts) {
      if (part === bufferWithoutTags.trim()) {
        output.push(bufferWithTags.trim())
        bufferWithTags = bufferWithoutTags = ""
      }
    }
  }
}
console.log(output)