Regex para todas as 10 palavras da letra, com letras exclusivas

Estou tentando escrever um regex que exibirá todas as palavras com 10 caracteres e nenhuma das letras esteja repetindo.

Até agora, eu tenho

grep --colour -Eow '(\w{10})'

Qual é a primeira parte da pergunta. Como eu verificaria a "singularidade"? Realmente não tenho idéia, além disso, preciso usar referências anteriores.

grep -Eow '\w{10}' | grep -v '\(.\).*\1'

exclui palavras que possuem dois caracteres idênticos.

grep -Eow '\w{10}' | grep -v '\(.\)\1'

exclui aqueles que têm caracteres repetidos.

POSIXly:

tr -cs '[:alnum:]_' '[\n*]' |
   grep -xE '.{10}' |
   grep -v '\(.\).*\1'

trcoloca as palavras em sua própria linha, convertendo qualquer sequivalência de caracteres que não sejam palavras ( complemento de alfanumérico e sublinhado) em um caractere de nova linha.

Ou com um grep:

tr -cs '[:alnum:]_' '[\n*]' |
   grep -ve '^.\{0,9\}$' -e '.\{11\}' -e '\(.\).*\1'

(exclua linhas com menos de 10 e mais de 10 caracteres e aquelas com um caractere aparecendo pelo menos duas vezes).

Com grepapenas um (GNU grep com suporte para PCRE ou pcregrep):

grep -Po '\b(?:(\w)(?!\w*\1)){10}\b'

Ou seja, um limite de palavras ( \b) seguido por uma sequência de 10 caracteres de palavras (desde que cada um não seja seguido por uma sequência de caracteres de palavras e por si mesmos, usando o operador PCRE negativo antecipado (?!...)).

Temos sorte que ele funcione aqui, já que muitos mecanismos de regexp não funcionam com referências anteriores em peças repetidas.

Note que (com minha versão do GNU grep pelo menos)

grep -Pow '(?:(\w)(?!\w*\1)){10}'

Não funciona, mas

grep -Pow '(?:(\w)(?!\w*\2)){10}'

faz (as echo aa | grep -Pw '(.)\2') que soa como um bug.

Você pode querer:

grep -Po '(*UCP)\b(?:(\w)(?!\w*\1)){10}\b'

se você quiser \wou \bconsiderar qualquer letra como um componente de palavra e não apenas as letras ASCII em códigos de idioma não ASCII.

Outra alternativa:

grep -Po '\b(?!\w*(\w)\w*\1)\w{10}\b'

Esse é um limite de palavras (aquele que não é seguido por uma sequência de caracteres de palavras, uma das quais se repete), seguido por 10 caracteres de palavras.

Coisas que você pode ter no fundo da mente:

• A comparação faz Babylonishdistinção entre maiúsculas e minúsculas, portanto, por exemplo, haveria correspondência, pois todos os caracteres são diferentes, mesmo que existam dois Bs, um menor e outro maiúsculo (use -ipara mudar isso).
• para -w, \we \b, uma palavra é uma letra (ASCII apenas para GNU grep por enquanto , a [:alpha:]classe de caracteres em sua localidade, se estiver usando -Pe (*UCP)), dígitos decimais ou sublinhado .
• isso significa que c'est(duas palavras conforme a definição francesa de uma palavra) ou it's(uma palavra de acordo com algumas definições em inglês de uma palavra) ou rendez-vous(uma palavra conforme a definição de palavra francesa) não são consideradas uma palavra.
• Mesmo com a (*UCP)combinação de caracteres Unicode, não são considerados componentes de palavras, portanto téléphone( $'t\u00e9le\u0301phone') é considerado com 10 caracteres, um dos quais não alfa. défavorisé( $'d\u00e9favorise\u0301') seria correspondido mesmo que tenha dois, éporque são 10 caracteres alfa diferentes, seguidos por um sotaque agudo combinado (não alfa, portanto, há um limite de palavras entre o ee o sotaque).

Ok ... aqui está a maneira desajeitada para uma sequência de cinco caracteres:

grep -P '^(.)(?!\1)(.)(?!\1|\2)(.)(?!\1|\2|\3)(.)(?!\1|\2|\3|\4).$'

Como você não pode colocar uma referência anterior em uma classe de personagem (por exemplo [^\1|\2]), você deve usar um olhar negativo à frente - (?!foo). Esse é um recurso PCRE, portanto você precisa da -Ptroca.

O padrão para uma sequência de 10 caracteres será muito mais longo, é claro, mas há um método mais curto usando um comprimento variável de qualquer coisa correspondente ('. *') No cabeçalho:

grep -P '^(.)(?!.*\1)(.)(?!.*\2)(.)(?!.*\3)(.)(?!.*\4)(.)(?!.*\5).$'

Depois de ler a resposta esclarecedora de Stephane Chazelas, percebi que existe um padrão simples semelhante para esse utilizável através do -vswitch grep :

    (.).*\1

Como a verificação prossegue com um caractere de cada vez, isso indica se algum caractere é seguido por zero ou mais caracteres ( .*) e, em seguida, corresponde à referência anterior. -vinverte, imprimindo apenas coisas que não correspondem a esse padrão. Isso torna as referências anteriores mais úteis, pois não podem ser negadas com uma classe de personagem e significativamente:

grep -v '\(.\).*\1'

trabalhará para identificar uma sequência de qualquer tamanho com caracteres exclusivos, enquanto:

grep -P '(.)(?!.*\1)'

não corresponderá, pois corresponderá qualquer sufixo a caracteres únicos (por exemplo, abcabccorrespondências por causa de abcno final e aaaapor causa de ano final - portanto, qualquer string). Essa é uma complicação causada pelo fato de as lookarounds terem largura zero (elas não consomem nada).

Se você não precisar fazer a coisa toda no regex, eu o faria em duas etapas: primeiro corresponda a todas as palavras de 10 letras e depois filtre-as por exclusividade. A maneira mais curta de saber como fazer isso é no Perl:

perl -nle 'MATCH:while(/\W(\w{10})\W/g){
             undef %seen;
             for(split//,$1){next MATCH if ++$seen{$_} > 1}
             print
           }' your_file

Observe as \Wâncoras adicionais para garantir que apenas as palavras com exatamente 10 caracteres sejam correspondidas.

Outros sugeriram que isso não é possível sem várias extensões para certos sistemas de expressão regular que na verdade não são regulares. No entanto, como o idioma que você deseja corresponder é finito, é claramente regular. Para 3 letras de um alfabeto de 4 letras, seria fácil:

(abc|abd|acb|acd|bac|bad|bcd|bdc|cab|cad|cbd|cdb|dab|dac|dbc|dcb)

Obviamente, isso sai do controle às pressas com mais letras e alfabetos maiores. :-)

A opção --perl-regexp(curta -P) do GNU grepusa expressões regulares mais poderosas que incluem padrões de antecipação. O padrão a seguir procura cada letra que esta letra não apareça no restante da palavra:

grep -Pow '((\w)(?!\w*\g{-1})){10}'

No entanto, o comportamento em tempo de execução é bastante ruim, porque \w*pode ter um tamanho quase infinito. Pode ser limitado a \w{,8}, mas isso também verifica além do limite de palavras de 10 letras. Portanto, o seguinte padrão verifica primeiro o tamanho correto da palavra:

grep -Pow '(?=\w{10}\b)((\w)(?!\w*\g{-1})){10}'

Como arquivo de teste, usei um arquivo grande de 500 MB:

• Primeiro padrão: s 43 s
• Últimos padrões: s 15 s

Atualizar:

Não consegui encontrar uma alteração significativa no comportamento em tempo de execução para um operador não ganancioso ( \w*?) ou operador possessivo ( (...){10}+). Um pouquinho mais rápido parece a substituição da opção -w:

grep -Po '\b(?=\w{10}\b)((\w)(?!\w*\g{-1})){10}\b'

Uma atualização do grep da versão 2.13 para 2.18 foi muito mais eficaz. O arquivo de teste levou apenas 6 segundos.

Uma solução Perl:

perl -lne 'print if (!/(.)(?=$1)/g && /^\w{10}$/)' file

mas não funciona com

perl -lne 'print if (!/(.)(?=\1)/g && /^\w{10}$/)' file

ou

perl -lne 'print if ( /(.)(?!$1)/g && /^\w{10}$/)' file

testado com perl v5.14.2 e v5.18.2