# 5.6 Applying a Bit of Indirection

Some problems that may appear very complex are actually simple once you've seen a solution or two. For example, suppose you want to find the items in a list that have odd digit sums but don't want the items themselves. What you want to know is where they occurred in the original list.

All that's required is a bit of indirection.[6]

[6] A famous computing maxim states that "there is no problem so complex that it cannot be solved with appropriate additional layers of indirection." Of course, with indirection comes obfuscation, so there's got to be a magic middle ground somewhere.

First, you have a selection problem, so you use a grep. Let's not grep the values themselves but the index for each item:

```my @input_numbers = (1, 2, 4, 8, 16, 32, 64);
my @indices_of_odd_digit_sums = grep {
...
} 0..\$#input_numbers;```

Here, the expression 0..\$#input_numbers will be a list of indices for the array. Inside the block, \$_ is a small integer, from 0 to 6 (seven items total). Now, you don't want to decide whether \$_ has an odd digit sum. You want to know whether the array element at that index has an odd digit sum. Instead of using \$_ to get the number of interest, use \$input_numbers[\$_]:

```my @indices_of_odd_digit_sums = grep {
my \$number = \$input_numbers[\$_];
my \$sum;
\$sum += \$_ for split //, \$number;
\$sum % 2;
} 0..\$#input_numbers;```

The result will be the indices at which 1, 16, and 32 appear in the list: 0, 4, and 5. You could use these indices in an array slice to get the original values again:

`my @odd_digit_sums = @input_numbers[ @indices_of_odd_digit_sums ];`

The strategy here for an indirect grep or map is to think of the \$_ values as identifying a particular item of interest, such as the key in a hash or the index of an array, and then use that identification within the block or expression to access the actual values.

Here's another example: select the elements of @x that are larger than the corresponding value in @y. Again, you'll use the indices of @x as your \$_ items:

```my @bigger_indices = grep {
if (\$_ > \$#y or \$x[\$_] > \$y[\$_]) {
1; # yes, select it
} else {
0; # no, don't select it
}
} 0..\$#x;
my @bigger = @x[@bigger_indices];```

In the grep, \$_ varies from 0 to the highest index of @x. If that element is beyond the end of @y, you automatically select it. Otherwise, you look at the individual corresponding values of the two arrays, selecting only the ones that meet your match.

However, this is a bit more verbose than it needs to be. You could simply return the boolean expression rather than a separate 1 or 0:

```my @bigger_indices = grep {
\$_ > \$#y or \$x[\$_] > \$y[\$_];
} 0..\$#x;
my @bigger = @x[@bigger_indices];```

More easily, you can skip the step of building the intermediate array by simply returning the items of interest with a map:

```my @bigger = map {
if (\$_ > \$#y or \$x[\$_] > \$y[\$_]) {
\$x[\$_];
} else {
(  );
}
} 0..\$#x;```

If the index is good, return the resulting array value. If the index is bad, return an empty list, making that item disappear.

 Chapter 1. Introduction
 Chapter 2. Building Larger Programs
 Chapter 3. Introduction to References
 Chapter 4. References and Scoping
 Chapter 6. Subroutine References
 Chapter 7. Practical Reference Tricks
 Chapter 8. Introduction to Objects
 Chapter 9. Objects with Data
 Chapter 10. Object Destruction
 Chapter 11. Some Advanced Object Topics
 Chapter 12. Using Modules
 Chapter 13. Writing a Distribution
 Chapter 14. Essential Testing
 Chapter 15. Contributing to CPAN