Introdução

As expressões regulares são uma ferramenta bastante comum em Perl, e podem ser usadas para descobrir frases em textos ou palavras em frases. Em algumas disciplinas da ciência, por exemplo na química ou na biologia, pode ser útil conseguir encontrar não uma palavra (ou frase) mas também a sua inversa.

Problema

Construir um program que calcule a expressão regular inversa para uma expressão regular simples que use apenas um pequeno conjunto dos operadores existentes. O programa deve suportar inverter expressões regulares que incluam os seguintes operadores: {},[], * e +.

O programa deve receber como primeiro argumento uma string que representa a expressão regular a inverter, e deve imprimir uma linha com a respectiva expressão regular invertida entre /.

Exemplos

  $ programa "ab+[aeiou]*rt"
  /tr[aeiou]*b+a/
  
  $ programa "ab+[aeiou]{10,20}r{2,}t"
  /tr{2,}[aeiou]{10,20}b+a/

Autor

Rui Mendes

Solução

#!/usr/bin/env perl 

use strict; use warnings;
use feature qw/say/;


my $regexp = shift;
my $pxeger = '';

my $char  = qr{\w};
my $set   = qr{\[.*?\]};
my $mult  = qr/(?:{.*?}|\+|\*)/;

my $changes = 1;
while ($changes) {
	$changes = 0;
	if ($regexp =~ s/^($char)($mult?)//){
		$pxeger =$2.$pxeger if defined($2);
		$pxeger =$1.$pxeger;
		$changes = 1;
	}
	if ($regexp =~ s/^($set)($mult?)//){
		$pxeger =$2.$pxeger if defined($2);
		$pxeger =$1.$pxeger;
		$changes = 1;
	}

}

say "/$pxeger/";

Introdução

Considere árvores de identificadores em que as folhas e os nodos são identificadores. A seguinte árvore:

                    f0
             ________|________
            /        |    |   \
           f1       f2   f3   f3
        ____|____    |    |    |
       /    |    \   |    |    |
       a    b   f2   b   f2   f2
                 |        |    |
                 |        |    |
                 a        a    a

Pode ser representada como:

  f0(f1(a,b,f2(a),f2(b),f3(f2(a))),f3(f2(a)))

Em muitas situações existem sub-árvores comuns (sub-árvores com o mesmo valor). Neste caso é possível calular uma representação usando sub-árvores partilhadas. Esta representação traz vantagens para tarefas de processamento e manutenção.

Problema

Construir um program que cria a lista de sub-árvores únicas existentes. O resultado deve ser uma lista de identificadores únicos, um por linha, e cada apontador para uma sub-árvore deve ser um # seguindo de um número inteiro. Os espaços na definião original devem ser ignorados. O programa deve receber como primeiro argumento uma string que representa a definição da árvore.

O exemplo ilustrado na introdução deve produzir o seguinte resultado:

  $ programa "f0(f1(a,b,f2(a),f2(b),f3(f2(a))),f3(f2(a)))"
  #1=a
  #2=b
  #3=f2(#1)
  #4=f2(#2)
  #5=f3(#3)
  #6=f1(#1,#2,#3,#4,#5)
  #7=f0(#6,#5)

Note que a ordem apresentada não é a única. Só deve ter cuidado que as sub-árvores partilhadas são definidas antes de serem usadas.

Restrições

Os nomes de funções ou de variáveis são identificadores típicos. Começam por uma letra minúscula, à qual se podem seguir mais letras minúsculas ou dígitos. Assim, todos os seguintes exemplos são identificadores válidos: a, f1, abc, a493b34d.

Exemplos

  $ programa f0(f1(a,b,f2(a),f3(f2(a))),f3(f2(a)))
  #1=a
  #2=b
  #3=f2(#1)
  #4=f3(#3)
  #5=f1(#1,#2,#3,#4)
  #6=f0(#5,#4)

Autor

José João Almeida <jj@di.uminho.pt>

Solução

#!/usr/bin/perl

use strict;
use warnings;

my $args = shift @ARGV;
my ($saves, $sevas);
my $nsaves = 0;

while ($args !~ /^#\d+$/) {
    next if $args =~ s{([a-z][a-z0-9]*)([),]|$)}{save($1)."$2"}e;
    next if $args =~ s{([a-z][a-z0-9]*\(#\d+(?:,#\d+)*\))}{save($1)}e;
}

for (sort { $a <=> $b } keys %$sevas) {
    printf "#%d=%s\n", $_, $sevas->{$_}
}

sub save {
    my $term = shift;
    if (!exists($saves->{$term})) {
        $saves->{$term} = ++$nsaves;
        $sevas->{$nsaves} = $term;
    }
    return "#".$saves->{$term};
}