perl | Partido codicioso y no codicioso

Las expresiones regulares (Regex/RE) son una secuencia de caracteres que se utilizan para la coincidencia de patrones. O podemos decir que es una forma de describir un conjunto de strings sin tener que enumerar todas las strings en su programa. Podemos aplicar una expresión regular usando los operadores de vinculación de patrones =~ y !~ . El operador Regex =~ es para probar una coincidencia de expresión regular.
Ejemplo: Consideremos /geeks/ como una expresión regular. coincidirá

Geeksforgeeks
Computergeeks

pero no

Ge12eksg22eeks
Geeksg*eks

Mientras que !~ determina a qué variable se aplica la expresión regular y niega el resultado de la coincidencia; devuelve falso si la coincidencia tiene éxito y verdadero si falla. Considere el ejemplo anterior, las expresiones que obtuvimos como verdaderas se considerarán como falsas y las expresiones regulares falsas como verdaderas. Proporciona una negación de los resultados obtenidos al usar =~ .
 
Coincidencia de patrones: es una forma de encontrar una secuencia particular de caracteres o un patrón dentro de una string determinada. En Perl, tenemos tres operadores de expresiones regulares. Están:

Match Regular Expression - m//
Substitute Regular Expression - s///
Transliterate Regular Expression - tr///

Ejemplo 1: uso del operador de coincidencia

#!usr/bin/perl
  
# Perl program to search the substring "or" 
# in the word GeeksForGeeks
  
# String to find pattern from
$a = "GeeksForGeeks";
  
# Using m operator to find substring
if($a = ~m/or/)
{
    print "Found 'or' in the string "; 
}

Here in the above example, pattern matching is done for searching a particular substring in a string using the match operator ‘m//‘. It will return true if the pattern is found in the string.

Ejemplo 2: uso del operador de sustitución

#!/usr/bin/perl
  
# Perl program to replace the substring "For" 
# in the word GeeksForGeeks
  
# String to perform substitution on
$a = "GeeksForGeeks";
  
# Using substitution operator to replace
$a = ~s/For/And/; 
print "$a";

Aquí, el operador de sustitución ‘ s/// ‘ se usa para sustituir un patrón en una string con un texto dado. Si el patrón existe, se sustituirá; de lo contrario, devolverá falso.

Ejemplo 3: uso del operador transliterador

#!/usr/bin/perl
  
# Perl program to replace all occurrences
# of a pattern in the string
  
# String to be used
$string = 'GeeksForGeeks';
  
# Replace 'G' with 'S' using 
# transliterator operator
$string =~ tr/G/S/;
  
# Printing the final string
print "$string\n";

Here, the string is searched for all the occurrences of a character ‘G’ and is replaced with another character ‘S’ using transliterator operator ‘tr///‘. It will never return false even if no replacement is done.

Coincidencia codiciosa y coincidencia no codiciosa
La regla habitual para la coincidencia en los RE a veces se denomina « la más larga a la izquierda «: cuando un patrón puede coincidir en más de un lugar dentro de una string, la coincidencia elegida será la que comienza en el posición más temprana posible dentro de la string, y luego se extiende lo más lejos posible. Normalmente, la coincidencia de patrones de Perl es codiciosa. Por codicioso, queremos decir que el analizador trata de igualar tanto como sea posible. En la string abcbcbcde , por ejemplo, el patrón
Codicia y no codicia coincidente /(bc)+/ puede coincidir de seis maneras diferentes, como se muestra en la figura:

In the above image, the third of these matched patterns is “left-most longest, ” also known as greedy. In some cases, however, it may be desirable to obtain a “left-most shortest” or minimal match. We can make a greedy matching into a non-greedy match using ‘?‘ at the end of RE i.e ‘*?‘ matches the smallest number of instances of the preceding subexpression that will allow the overall match to succeed. Similarly, ‘+?‘ matches at least one instance, but no more than necessary to allow the overall match to succeed, and ‘??‘ matches either zero or one instances, with a preference for zero.

Ejemplo: coincidencia de patrones codiciosos

#!/usr/bin/perl
  
# Perl program to show greedy matching
$var = "Geeks For Geeks";
  
# Matching pattern from k to s
$var =~ /(k.*s)(.*)$/;
  
# Printing the resultant string
print($1, "\n");

Here we can see that the code will start to match from k to s and it matches as much as possible.

Ejemplo: coincidencia de patrones no codiciosos

#!/usr/bin/perl
  
# Perl program to show non-greedy matching
my $str = "Geeks For Geeks";
  
# Matching pattern from k to s
$str =~ /.*?\s(.*)/; 
  
# Printing Resultant string
print($1);

When comparing with the non-greedy operator, it will match least code.