Re (tilly) 3: Golf: Tree searching

[tilly]

in reply to Re: Re: Golf: Tree searching
in thread Golf: Tree searching

As koolade pointed out, not all of these work. Yours in particular goes into deep recursion. Works in theory is not good enough, in golf you are going to learn a lot about the assumptions you cannot make. And yours has at least 2 separate (and serious) mistakes.

BTW the counts as I list them are just for the body of the sub, so if yours did work it would be 51 characters.

Playing independently I came in with several solutions that are small, and the following which is similar to yours really does work at 58:

sub f {
my($s,$t)=@_;$t?$$t{d}eq$s?$t:f($s,$$t{l})||f($s,$$t{r}):0
}

And here, thanks to koolade, is the test that I use:

$t = {
    d => 'd',
    l => {
        d => 'b',
        l => { d => 'a', l => 0, r => 0, },
        r => { d => 'c', l => 0, r => 0, },
    },
    r => {
        d => 'f',
        l => { d => 'e', l => 0, r => 0, },
        r => { d => 'g', l => 0, r => 0, },
    }
};

sub test {
  my $val = f(@_);
  print $val ? "$val->{d}:$val\n" : "$val\n";
}

test('e',$t);
test('O',$t);

[tadman]

Both tilly and indigo have exactly the same result, which is a fix of twerq's including 1) my, and 2) the test for $t which prevents infinite looping.

Here is a solution which is short, but not 'strict' compliant: sub f{for(($s,$t)=@_;$_=$$t{(0,l,r)[$$t{d}cmp$s]};$t=$_){}$t}
Alas, although 4 characters lighter, it doesn't return 0 on misses properly. This does, but is admittedly 3 characters heavy: sub f{for(($s,$t)=@_;$_=$t&&(0,l,r)[$$t{d}cmp$s];){$t=$$t{$_}||0}$t}
Or, a tie, provided the tree has 0-value stubs as it does in other examples: sub f{for(($s,$t)=@_;$_=$t&&(0,l,r)[$$t{d}cmp$s];){$t=$$t{$_}}$t}
Fun test code below for a tree:

    $|++;
    $table = {
        d => 'h',
        l => {
             d => 'd',
             l => { d => 'b', l => { d => 'a' }, r => { d => 'c' } },
             r => { d => 'f', l => { d => 'e' }, r => { d => 'g' } },
        },
        r => {
             d => 'l',
             l => { d => 'j', l => { d => 'i' }, r => { d => 'k' } },
             r => { d => 'm', l => { d => 'l' }, r => { d => 'n' } },
        }
    };

    foreach $y (qw[ a b c d e f g h i j k l m n o p q ])
    {
            $x = f($y,$table);
            print "Answer for $y = ";
            print $x," ", $$x{d},"\n";
    }

value entry in the hash.

[tilly]

Well it has to handle both failure and success. However by borrowing shamelessly from tye, I beat my previous, and if we want to be shamelessly non-strict about it, I can improve again.

sub f {
$t=pop;$t=$$t{$c>0?l:r}while$c=$$t{d}cmp$_[0]and$t;$t
}

By my count this is 53 characters.

[tadman]

Inspirationally shameless, and a great demonstration of the power of 'and' versus '&&', something that I hadn't fully understood. Until now. I have to say, at first it looks like a drop-in alternative to the presumably scary C-style double-ampersands (as in, an artifact of the use English movement), but when you get right down to it, it binds much more loosely, enhancing its utility vastly.

In the spirit of shameless borrowing, switching to 'pop' and using 'and' nets the following: sub f{for($t=pop;$_=(0,l,r)[$$t{d}cmp$_[0]]and$t=$$t{$_};){}$t}
But this is really just converging on the same thing: sub f{for($t=pop;$_=$$t{d}cmp$_[0]and$t=$$t{$_>0?l:r};){}$t}
Which is the same length, and functionally the same due to heavy cross-pollination.

Of course, if the spec had indicated that the two branches were labelled '-1' and '1' instead of 'r' and 'l', that would certainly simplify things a whole lot. Or at least it would save 6 precious characters: sub f{for($t=pop;$_=$$t{d}cmp$_[0]and$t=$$t{$_};){}$t}