Perguntas[regex](coding)

Como posso usar uma expressão regular localizar/substituir para quebrar em novas linhas para nunca ter mais de 20 símbolos por linha?

Eu encontrei isto:

Find: \s(?<=.{20})
Replace: $0\r\n

Seria perfeito, mas deixa palavras na linha maiores que 20 símbolos se elas começaram antes de 20 símbolos.

Preciso de uma expressão semelhante, mas se o último item torna a linha maior, ele também deve ir para a nova linha, então a linha final sempre terá <20 símbolos.

Eu sei que já fiz isso há muito tempo, talvez com algum plugin, mas não consigo fazer funcionar agora. Como posso fazer isso?

Estou usando IMPORTXML para pegar alguns dados e então regex para extrair algum texto. A parte que quero extrair é um nome.

Ele sempre vem depois de "Nome Completo:" (menos as aspas). Depois do nome, sempre há uma palavra seguida por dois pontos. Essa palavra pode ser Pronúncia, Linguística, Tipo ou qualquer outra coisa.

O mais próximo que posso chegar é esta fórmula:

=IFERROR(REGEXEXTRACT(REGEXREPLACE(JOIN(" ", IMPORTXML(B13, "//div[@id='meta']")), "\s+", " "), "Full Name:\s*([A-Za-z]+(?:[-'\s][A-Za-z]+)*)"), "")

Infelizmente, isso ainda deixa a última palavra.

Então se você tem por exemplo:

Nome completo: Abraham Lincoln Apelido: Honest Abe.

Eu só quero que ele retire Abraham Lincoln. Essa fórmula, como eu tenho, gera:

Abraham Lincoln Apelido

Outros exemplos:

• Nome completo: John Smith-Rogers Acabamento:
• Nome completo: David Ben-Williams Prelúdio:
• Nome completo: Sean O'Brian Apelido:
• Nome completo: D'Andre Ayton Hora:
• Nome completo: Andy Van Slyke Nome:

Saídas respectivas:

• John Smith-Rogers
• David Ben-Williams
• Sean O'Brian
• D'André Ayton
• Andy Van Slyke

Para um exemplo ao vivo: https://www.baseball-reference.com/players/l/lopezal01.shtml

A fórmula deve produzir: Alfonso Ramon Lopez

https://www.baseball-reference.com/players/r/ruthba01.shtml

A fórmula deve produzir: George Herman Ruth

O que mais preciso fazer tendo em mente que quero ter certeza de que nomes como O'Brien e Smith-Rogers não sejam afetados?

Tenho 200 arquivos com linhas de texto que podem se parecer com qualquer um destes padrões:

{hello} "this is an example" {{ config(alias="customertable") }}
{{hello}} "this is an example" {{ config ( alias = 'monthly revenue') }}
{ { config ( alias = 'record 3 breaking news') } } {{hello}} "this is an example"
{{hello}} 'this is an example' { { config( alias = "designer bags 4 u") }} {{hello}} "this is an example"

A string após a palavra alias está sempre entre aspas simples ou duplas. Quero colocar _link no final dessa string, para que fique assim: "customertable_link" ou 'monthly revenue_link' e quero usar o powershell. Quero que a linha inteira seja retornada, então o quarto exemplo deve retornar isso:

{{hello}} 'este é um exemplo' { { config( alias = "bolsas de grife para u_link") }} {{hello}} "este é um exemplo"

Por exemplo, procure o alias da string em uma linha e adicione _link à esquerda da segunda instância de " ou ' .

Isto é o que tenho até agora:

$string -replace 'alias=(?:[^"]*"){2}', '$0_link'

E isso funciona quase para o primeiro exemplo (só a citação está no lugar errado), mas não consigo fazer direito. Qualquer ajuda seria muito apreciada!

Preciso de ajuda com um Regex. Quero substituir todas as ocorrências de 5%or 7%or 183%or 99%para `` (string vazia) MAS se a ocorrência for 0%or 100%(podem ser dezenas de ocorrências que eu queira preservar) não quero fazer nada.

Por exemplo:

aaa 0% bbbdeveria se tornar aaa 0% bbb(nada mudou)

No entanto

aaa 40% bbbdeveria se tornaraaa bbb

Eu criei um regex usando lookbehind negativo, mas ele apenas remove o %sinal, não o número. Este é o regex:

substituir (?<!(0|100))%por `` (string vazia)

A expressão regular acima, quando aplicada à string, aaa 40% bbbretorna aaa 40 bbb.

Eu estava tentando substituir [& ]de uma sequência de fórmulas como:

col_formula:regexp_replace( regexp_replace([`cellid`], "(.*)_N", "N"), "_(.*)", "")
 
var replaced_col_formula= col_formula.replaceAll("/[\\[\\]']+/g", "")
println(s"replaced_col_formula:$replaced_col_formula")
 
replaced_col_formula:regexp_replace( regexp_replace([`cellid`], "(.*)_N", "N"), "_(.*)", "")

Eu esperava algo como abaixo

replaced_col_formula:regexp_replace( regexp_replace(cellid, "(.*)_N", "N"), "_(.*)", "")

Estou tentando capturar a posição de todos os hifens em uma palavra hifenizada, para que eu possa carregar um hash com a posição desses hifens (no texto, não na palavra). No momento, estou tentando um grupo de captura dentro de um grupo sem captura... mas ele está capturando apenas o último hífen.

my $word           = shift (@_);
my $word_start_pos = shift (@_);
my $text           = shift (@_);

my $dash_pos  = 0;
my $exp       = 0;
my $pos       = 0;
my $test_char = '';
   
if ($word =~ /^(?:[\p{L&}0-9\.\'\/]{1,}([\-])){7,}[\p{L&}0-9\.\'\/]{1,}$/) {
   foreach $exp (1..$#-) {
      $pos = $-[$exp];
      $dash_pos = $word_start_pos + $pos;
      $test_char = substr($text, $dash_pos, 1);
      if ($test_char =~ /^[\-]$/) {
         &load_changes('-', $dash_pos, 'Dash', ' ', 'Replace');
      }
   }
}

Tenho os seguintes casos de teste:

CPP_CSHARP_REGEX_TEST_CASES = [
    ("C++", True),
    ("C#", True),
    ("C+", False),
    ("C##", False),
    ("C", True),
]

Qual expressão regular eu poderia usar para passar pytest? Eu tentei r"^C[+{2},#{1}]$" a solução de Tim Biegeleisen, mas falha para C:

________________________________________________________________________________ test_cpp_csharpRegex[C-True] ________________________________________________________________________________

data = 'C', expected = True

    @pytest.mark.parametrize("data, expected", CPP_CSHARP_REGEX_TEST_CASES)
    def test_cpp_csharpRegex(data, expected):
        cpp_csharp_regex = r"\bC(?:\+\+|#)(?=\s|$)"
>       assert expected == bool(re.match(cpp_csharp_regex, data))
E       AssertionError: assert True == False
E        +  where False = bool(None)
E        +    where None = <function match at 0x7ab4e2cded40>('\\bC(?:\\+\\+|#)(?=\\s|$)', 'C')
E        +      where <function match at 0x7ab4e2cded40> = re.match

regex_test.py:131: AssertionError
================================================================================== short test summary info ===================================================================================
FAILED regex_test.py::test_cpp_csharpRegex[C-True] - AssertionError: assert True == False
================================================================================ 1 failed, 70 passed in 0.08s ================================================================================

Raku tem uma notação regex recursiva interessante e emocionante: <~~>.

Então no REPL, podemos fazer isso:

[0] > 'hellohelloworldworld' ~~ m/ helloworld /;
｢helloworld｣
[1] > 'hellohelloworldworld' ~~ m/ hello <~~>? world /;
｢hellohelloworldworld｣

Indo diretamente do Raku Docs para expressões regulares recursivas , podemos capturar/contar vários níveis de aninhamento:

~$ raku -pe '#acts like cat here' nest_test.txt
not nested

previous blank
nestA{1}
nestB{nestA{1}2}
nestC{nestB{nestA{1}2}3}

~$ raku -ne 'my $cnt = 0; say m:g/  \{  [  <( <-[{}]>*  )> | <( <-[{}]>* <~~>*? <-[{}]>* )>  ] \} {++$cnt} /, "\t  $cnt -levels nested";'  nest_test.txt
()    0 -levels nested
()    0 -levels nested
()    0 -levels nested
(｢1｣)     1 -levels nested
(｢nestA{1}2｣)     2 -levels nested
(｢nestB{nestA{1}2}3｣)     3 -levels nested

(Acima, altere saypara putpara retornar apenas a string capturada).

Mas recentemente me deparei com um problema ao tentar resolver uma questão sobre Unix e Linux , que é: como limitar a recursão? Digamos que queremos capturar apenas abaixo nestB. Existe alguma maneira de fazer isso usando a <~~>sintaxe regex recursiva?

~$ raku -ne 'my $cnt = 0; say m:g/ nestB  \{  [  <( <-[{}]>*  )> | <( <-[{}]>* <~~>*? <-[{}]>* )>  ] \} {++$cnt} /, "\t  $cnt -levels nested";'  nest_test.txt
()    0 -levels nested
()    0 -levels nested
()    0 -levels nested
()    0 -levels nested
()    0 -levels nested
()    0 -levels nested

NOTA: Acima, tentei forçar algum tipo de 'comportamento recursivo frugal' usando <~~>*?. A verdade é que <~~>(notação recursiva padrão), <~~>?, <~~>*, e <~~>*?todos dão resultados idênticos ( rakudo-moar-2024.09-01).

Qual é a sintaxe correta do regex recursivo Raku?

Cadeia de teste:

[valign px=-2][center][bgcolor=GREEN]TESTING[/bgcolor][/center][/valign]

Eu descobri color.*?\]algo que quase funciona... Ele pega tudo depois da palavra-chave, até e incluindo o colchete de fechamento:

color=GREEN]  AND  color]   ---> Target ---> [bgcolor=GREEN]  AND  [/bgcolor]

Eu simplesmente não consigo entender como fazer o mesmo ao contrário

\[.*?color.*?\]isso me dá a string inteira antes da chave até o colchete de fechamento - [valign px=-2][center][bgcolor=GREEN]MAS também me dá corretamente [/bgcolor]sem TESTINGentre eles

Estou usando https://regex101.com/ para testes

Gostaria de transformar espaços em sublinhados em certas frases para uma localização e substituição de regex. Por exemplo, eu gostaria disto:

If you are going to the fair a trader there will offer you a fair price

em

Se você for à feira, um comerciante lá lhe oferecerá um preço justo

Eu sei como capturar essas sequências específicas de várias maneiras

por exemplo

• (the fair)|(a trader)|(offer you)
• (the)(\s)(fair)|(a)(\s)(trader)|(offer)(\s)(you)

etc.

mas não sei como lidar com a numeração dos grupos de captura para que a mesma substituição (espaço para sublinhado) aconteça com qualquer um deles.

Eu tentei:

1.

• ENCONTRAR:(the)(?:\s)(fair)|(a)(?:\s)(trader)|(offer)(?:\s)(you)
• SUBSTITUIR:$1_$2
• RESULTADO:If you are going to the_fair _ there will _ a fair price

• ENCONTRAR:(the|a|offer)(?:\s)(fair|trader|you)
• SUBSTITUIR:$1_$2
• RESULTADO:If you are going to the_fair a_trader there will offer_you a_fair price

Não tenho certeza do que mais tentar. Desculpe se não estou expressando minha pergunta corretamente; sou muito novo nisso