主页 / 问题 / 1497035
Accepted
Black Fire
Asked:2023-02-17 03:41:17 +0000 UTC2023-02-17 03:41:17 +0000 UTC

正则表达式：五位数字，不都一样

  • 772

条件是5个数字必须通过，但连续不相同。例如，12345、223341.44441，但不是 00000、11111 等。

javascript

5 个回答

  1. Best Answer

    @SwaD已经给出了正确答案，但这里有一个检查示例，检查输入的值是否为 5 位数字并且连续没有相同的数字：

    function checkNumber(num) {
  const regex = /^(\d)(?!\1)(\d)(?!\1|\2)(\d)(?!\1|\2|\3)(\d)(?!\1|\2|\3|\4)\d$/;
  return regex.test(num);
}

console.log(checkNumber('12345')); // true
console.log(checkNumber('223341')); // true
console.log(checkNumber('44441')); // true
console.log(checkNumber('00000')); // false
console.log(checkNumber('11111')); // false
console.log(checkNumber('1234')); // false
console.log(checkNumber('123456')); // false
    这使用由以下内容组成的正则表达式：

    • ^- 行首
    • (\d)- 存储在第一个捕获组中的第一个数字
    • (?!\1)- 负先行检查下一个数字是否不等于第一个数字
    • (\d)- 第二个数字，存储在第二个捕获组中
    • (?!\1|\2)- 负先行检查下一个数字是否不等于第一个或第二个
    • (\d)- 第三个数字，存储在第三个捕获组中
    • (?!\1|\2|\3)- 负先行检查下一个数字是否不等于第一个、第二个或第三个
    • (\d)- 第四个数字，存储在第四个捕获组中
    • (?!\1|\2|\3|\4)- 负先行检查下一个数字是否不等于第一个、第二个、第三个或第四个
    • \d- 第五位数字
    • $- 行结束

    所以正则表达式确保字符串包含 5 位数字并且不会连续出现相同的数字。如果字符串与此模式匹配，则该函数checkNumber返回，否则返回。truefalse

    答案恰恰相反。

    要测试 5 个数字而不重复，可以使用以下正则表达式：

    /^(?!.*(\d)\1)[0-9]{5}$/

    这个正则表达式有两个部分。第一部分^(?!.*(\d)\1)用于检查重复数字。它使用 negative lookahead (?!...)，表示接下来不应该有重复数字。在这种情况下.*(\d)\1，它会检查一行中是否有两个相同的数字。如果有这样的数字，那么检查将不会通过。

    第二部分[0-9]{5}$检查字符串是否恰好包含 5 位数字，直到字符串结尾。

    因此，此正则表达式将检查字符串是否由 5 位数字组成且没有重复。如果您需要检查 5 位以外的号码，请指定一个不同的号码。或类似 的表达式[0-9]{5,10}$，表示最少 5 位数字，但最多 10 位

    • 6

  2. 是的，存在这样的正则表达式。总共 22 个字符，一个正向前瞻，一个负向（先行断言）：

      начало строки
  |
  v          запомнить первый символ
  -          ---
 /^(?=\d{5}$)(.)(?!\1*$)/
   ----------   --------
   ^            \1*$    - запомненный символ повторяется до конца строки,
   |            (?!...) - это отрицание, оно сработает если не все
   |                      символы в строке совпадают с первым
   |
   \d{5}$  - ровно пять цифр и конец строки,
   (?=...) - проверка делается, но символы в строке "остаются" -
             остаток выражения снова будет работать с целой строкой

    该表达式检查

    • 字符串中恰好有五个字符，
    • 所有字符都是数字，
    • 该字符串不包含五个相同的数字。

    const re5 = /^(?=\d{5}$)(.)(?!\1*$)/;

console.log(re5.source);
console.log(re5.source.length);

[
    '0000', '0010',
    '00000', '11111', '22222', '33333', '44444', '55555',
    '11112', '11121', '67890',
    '112111', '111111'
].forEach(s => console.log(s, '=>', re5.test(s)));

(() => {
    for (let i = 0; i < 100000; ++i) {
        const s = String(i).padStart(5, '0');
        console.assert(re5.test(s) === (i % 11111 !== 0));
    }
})();

    如果没有前向和后向的观点，那么这个问题也是可以解决的。共 525 个字符：

    /^(0(0(0(0[1-9]|[1-9]\d)|[1-9]\d\d)|[1-9]\d{3})|1(1(1(1[02-9]|[02-9]\d)|[02-9]\d\d)|[02-9]\d{3})|2(2(2(2[013-9]|[013-9]\d)|[013-9]\d\d)|[013-9]\d{3})|3(3(3(3[0124-9]|[0124-9]\d)|[0124-9]\d\d)|[0124-9]\d{3})|4(4(4(4[0-35-9]|[0-35-9]\d)|[0-35-9]\d\d)|[0-35-9]\d{3})|5(5(5(5[0-46-9]|[0-46-9]\d)|[0-46-9]\d\d)|[0-46-9]\d{3})|6(6(6(6[0-5789]|[0-5789]\d)|[0-5789]\d\d)|[0-5789]\d{3})|7(7(7(7[0-689]|[0-689]\d)|[0-689]\d\d)|[0-689]\d{3})|8(8(8(8[0-79]|[0-79]\d)|[0-79]\d\d)|[0-79]\d{3})|9(9(9(9[0-8]|[0-8]\d)|[0-8]\d\d)|[0-8]\d{3}))$/

    此处对其进行格式化，以便更容易理解结构。工作表达式不得包含空格或换行符：

    ^(
      0 (0 (0 (0[1-9   ] | [1-9   ]\d) | [1-9   ]\d\d) | [1-9   ]\d{3})
    | 1 (1 (1 (1[02-9  ] | [02-9  ]\d) | [02-9  ]\d\d) | [02-9  ]\d{3})
    | 2 (2 (2 (2[013-9 ] | [013-9 ]\d) | [013-9 ]\d\d) | [013-9 ]\d{3})
    | 3 (3 (3 (3[0124-9] | [0124-9]\d) | [0124-9]\d\d) | [0124-9]\d{3})
    | 4 (4 (4 (4[0-35-9] | [0-35-9]\d) | [0-35-9]\d\d) | [0-35-9]\d{3})
    | 5 (5 (5 (5[0-46-9] | [0-46-9]\d) | [0-46-9]\d\d) | [0-46-9]\d{3})
    | 6 (6 (6 (6[0-5789] | [0-5789]\d) | [0-5789]\d\d) | [0-5789]\d{3})
    | 7 (7 (7 (7[0-689 ] | [0-689 ]\d) | [0-689 ]\d\d) | [0-689 ]\d{3})
    | 8 (8 (8 (8[0-79  ] | [0-79  ]\d) | [0-79  ]\d\d) | [0-79  ]\d{3})
    | 9 (9 (9 (9[0-8   ] | [0-8   ]\d) | [0-8   ]\d\d) | [0-8   ]\d{3})
)$

    下面的程序动态生成一个表达式并对其进行测试：

    const makeRe = n => {
    const without = [
        /* 0 */ '[1-9]'   , /* 1 */ '[02-9]'  ,
        /* 2 */ '[013-9]' , /* 3 */ '[0124-9]',
        /* 4 */ '[0-35-9]', /* 5 */ '[0-46-9]',
        /* 6 */ '[0-5789]', /* 7 */ '[0-689]' ,
        /* 8 */ '[0-79]'  , /* 9 */ '[0-8]'    
    ];

    const all = n => (n < 3) ? '\\d'.repeat(n) : `\\d{${n}}`;

    const or = alternatives => `(${alternatives.join('|')})`;

    const startsFrom = d => {
        //           0[1-9]
        let re = `${d}${without[d]}`;
        for (let i = 2; i < n; ++i) {
            //       0[1-9]                                 ->
            //     0(0[1-9]|[1-9]\d)                        ->
            //   0(0(0[1-9]|[1-9]\d)|[1-9]\d\d)             ->
            // 0(0(0(0[1-9]|[1-9]\d)|[1-9]\d\d)|[1-9]\d{3})
            re = `${d}${or([re, `${without[d]}${all(i - 1)}`])}`;
        }
        return re;
    }

    const union = or([...Array(10).keys()].map(startsFrom));
    return new RegExp(`^${union}$`);
};

const re5 = makeRe(5);

console.log(re5.source);
console.log(re5.source.length);

[
    '0000', '0010',
    '00000', '11111', '22222', '33333', '44444', '55555',
    '11112', '11121', '67890',
    '112111', '111111'
].forEach(s => console.log(s, '=>', re5.test(s)));

(() => {
    for (let i = 0; i < 100000; ++i) {
        const s = String(i).padStart(5, '0');
        console.assert(re5.test(s) === (i % 11111 !== 0));
    }
})();

    PS试着想出一个更短的表达方式。以上三个要求都要满足。

    • 4

  3. 好吧，也许是马马虎虎的解决方案，但只有一个常规赛:)

    const arr = [
  '00000',
  '11111',
  '22222',
  '33333',
  '44444',
  '55555',
  '12345',
  '12344',
  '55555',
  '12232',
  '11113',
  '88887'
]

const re = /0{5}|1{5}|2{5}|3{5}|4{5}|5{5}|6{5}|7{5}|8{5}|9{5}/
arr.forEach(item => {
  console.log(item, !re.test(item))
})

    • 1

  4. 来自@senior-pomidor的选项：

    要测试 5 个数字而不重复，可以使用以下正则表达式：

    /^(?!.*(\d)\1)[0-9]{5}$/

    问题条件下很容易remake：

    • 我们删除了.*负面的前瞻性，不包括检查是否存在零个或多个任何字符
    • 在负先行中设置返回组的量词{4}

    结果，我们得到以下正则表达式：

    /^(?!(\d)\1{4})\d{5}$/

    我们检查第一个捕获的数字是否重复四次。

    JS 中的一个示例，因为它是内联的：

    const str = `12345
11223
11111
22222
01234
44441
44444`;
const reg = /^(?!(\d)\1{4})\d{5}$/gm
console.log(str.match(reg));

    • 0

  5. 我得到以下 -^(?:(\d)(?!.*\1)){5}$

    const regex = /^(?:(\d)(?!.*\1)){5}$/gm;

// Alternative syntax using RegExp constructor
// const regex = new RegExp('^(?:(\\d)(?!.*\\1)){5}$', 'gm')

const str = `12345
76523
17173`;
let m;

while ((m = regex.exec(str)) !== null) {
    // This is necessary to avoid infinite loops with zero-width matches
    if (m.index === regex.lastIndex) {
        regex.lastIndex++;
    }

    // The result can be accessed through the `m`-variable.
    m.forEach((match, groupIndex) => {
        console.log(`Found match, group ${groupIndex}: ${match}`);
    });
}

    • 0

相关问题