Won't someone please care for them? The pentuplets appeared on my doorstep. They all do the same thing. Can you figure it out? I could tell you, but where's the fun in that? 
# 57*3 = 171
sub emb1 {
$_[0]=~/^(?{[("")x2]})(.*)(?{[$^R->[0].$1,$^R->[1]]})(?:(
.)(?{[$^R->[0],$^R->[1].$2]})(.*)(?{[$^R->[0].$3,$^R->[1]
]}))*\z(?(?{$^R->[0]eq$_[1]})(?{$_[2]=$^R->[1]})|(?!))/sx
}

# 54*3 = 162
sub emb2 {
our$i=\$_[2];@_=@_;my$R;$R=qr/(?{substr$_[1],0,1,''})(
(??{''ne$^R&&"[^\Q$^R\E]*\Q$^R"}))(?{chop($$i.=$1)if$1
ne'';$^R})(??{''ne$^R&&$R})(?{$$i.=$'})/x;$_[0]=~/^$R/
}

# 52*3 = 156
sub emb3 {
@_=(@_,our$i=\$_[2]);$_[0]=~m{^(?(?{${$^R=\substr$_[
1],0,1}ne''})((??{"[^\Q${$^R}\E]*\Q${$^R}"}))(?{chop
(${$^R},$$i.=$1)}))+(?(?{$_[1]ne''})^)}&&($$i.=$',1)
}

# 49*3 = 147
sub emb4 {
use re"eval";$_[0]=~m{^@{[map+qr{(?>([^$_]*)$_(?{
$_[$^F].=substr($_[$%],$-[-1],$+[$#-]-$-[-1])}))}
,map+quotemeta(),split//,$_[1]]}}x&&($_[2].=$',1)
}

# 41*3 = 123
sub emb5 {
$_[0]=~m{^@{[map"([^\Q$_\E]*)\Q$_",split/
/x,$_[1]]}}x&&($_[2]=join('',map(substr($
_[0],$-[$_],$+[$_]-$-[$_]),1..$#-),$'),1)
}

[download]
_____________________________________________________
Jeff[japhy]Pinyan: Perl, regex, and perl hacker, who'd like a job (NYC-area)
s++=END;++y(;-P)}y js++=;shajsj<++y(p-q)}?print:??;

Replies are listed 'Best First'.
Re: Five orphaned obfuscations
by ihb (Deacon) on Jun 19, 2004 at 22:13 UTC

    The usage for the emb function is
       emb($str, $rm, $result) and print $result; The function remove the chars in $rm from $str if all chars are present and in the same order as specified in $rm. If success true is returned and the result, i.e. the filtered $str, is assigned to $result.

    Example: 
        my $str = 'foXobYar';
    my $rm = 'XY';
    my $result;
    emb1($str, $rm, $result) and print $result;
    __END__
    foobar

    [download]

    Update: &emb2 has a bug. I noticed this when I dissected it. The subpattern (?{ $$i .= $' }) should be removed and and $$i .= $', 1 should be put at the end of the subroutine.

    DISSECTION

    Perhaps it's not a real dissection as it's not dissected in great detail, but all algorithms and key functions (as I see it) are explained. To explain every detail would be too great an effort.

    &emb1 is a clever one, though not algorithmically as it bruce forces the result. The key to understanding it is that $^R is the value of the last (?{}) assertion and that $^R is restored upon backtracking. $^R->[0] is the skipped chars, and $^R->[1] is the filtered string. It selects one char at the time. That's what (?{ [ $^R->[0], $^R->[1] . $2 ] }) does. As the pattern backtracks, more and more chars get selected and finally you have only the ones you wanted to remove left. So it uses backtracking to look for the right result and stores each attempt in $^R and at the end it sees if the skipped chars match the second argument through a (?()|) assertion which is the regex version of ?:. If it wasn't right, it again forces backtracking through (?!) which is a negative look-behind assertion that always fails as the subpattern in it (nothing) always matches. At the end it simply assigns the filtered string to $_[2].

    &emb2 uses a recursive pattern through the interpolating assertion (??{}). They key here is [^\Q$^R\E]*\Q$^R. $^R is the next char to be removed. The pattern says to match all non-$^R and then a $^R. The match minus the last char (i.e. the one not wanted) is then assigned to $$i which is the second argument ($_[2] can't be used as the dealiasing @_ = @_ has been done before to enable the destructive substr() on $_[1]) and then the pattern is called again, until there's no chars left to remove. Then, at last, the rest of the string is appended to $$i (with my patch--see above).

    &emb3 is pretty much the same as &emb2 except it isn't recursive but it's basically the same algorithm.

    &emb4 pregenerates the pattern that's being done recursively resp. iteratively in &emb2 and &emb3. The pattern is designed so that the filtered string is built as the match proceeds, which also utilizes that @- and @+ is built and available as the match proceeds. @- and @+ are offset arrays for the submatches. $+ could just as well have been used.

    &emb5 is like &emb4 except it builds the filtered string after the match is all done utilizing the same technique as &emb4.

    ihb

[reply]
[d/l]
[select]

Back to Obfuscated Code