@decimals = map{$_/100 } 501 .. 512;;
print "@decimals";;
5.01 5.02 5.03 5.04 5.05 5.06 5.07 5.08 5.09 5.1 5.11 5.12

@times = map{ sprintf "%02d:%02d", $_/60, $_%60 } 4*60+55 .. 5*60+05;;
print "@times";;
04:55 04:56 04:57 04:58 04:59 05:00 05:01 05:02 05:03 05:04 05:05
[download]

You'll have to somehow produce a range where increments are one, and scale them.

Plenty of people showed you how to do that with increments of 1/100, and here's a way to increment using time (in this exampel: increment in 5 minute intervals):

use POSIX qw(strftime);
use Time::Local;
my($from, $to, $incr) = ('13:00', '23:00', '0:05');
foreach($from, $to, $incr) {
    if(/^(\d+):(\d\d)(?::(\d\d))?$/) {
        $_ = ($1 * 60  + $2) * 60 + ($3 || 0);
    }
}
@range = map { strftime "%H:%M:%S", gmtime $_ }
  map $_*$incr, $from/$incr .. $to/$incr;

$_ = join " ", @range;
s/(.{1,70})(\s|$)/$1\n/g;
print ;
[download]

13:00:00 13:05:00 13:10:00 13:15:00 13:20:00 13:25:00 13:30:00
13:35:00 13:40:00 13:45:00 13:50:00 13:55:00 14:00:00 14:05:00
14:10:00 14:15:00 14:20:00 14:25:00 14:30:00 14:35:00 14:40:00
14:45:00 14:50:00 14:55:00 15:00:00 15:05:00 15:10:00 15:15:00
15:20:00 15:25:00 15:30:00 15:35:00 15:40:00 15:45:00 15:50:00
15:55:00 16:00:00 16:05:00 16:10:00 16:15:00 16:20:00 16:25:00
16:30:00 16:35:00 16:40:00 16:45:00 16:50:00 16:55:00 17:00:00
17:05:00 17:10:00 17:15:00 17:20:00 17:25:00 17:30:00 17:35:00
17:40:00 17:45:00 17:50:00 17:55:00 18:00:00 18:05:00 18:10:00
18:15:00 18:20:00 18:25:00 18:30:00 18:35:00 18:40:00 18:45:00
18:50:00 18:55:00 19:00:00 19:05:00 19:10:00 19:15:00 19:20:00
19:25:00 19:30:00 19:35:00 19:40:00 19:45:00 19:50:00 19:55:00
20:00:00 20:05:00 20:10:00 20:15:00 20:20:00 20:25:00 20:30:00
20:35:00 20:40:00 20:45:00 20:50:00 20:55:00 21:00:00 21:05:00
21:10:00 21:15:00 21:20:00 21:25:00 21:30:00 21:35:00 21:40:00
21:45:00 21:50:00 21:55:00 22:00:00 22:05:00 22:10:00 22:15:00
22:20:00 22:25:00 22:30:00 22:35:00 22:40:00 22:45:00 22:50:00
22:55:00 23:00:00
[download]

Tweaking the format spec for strftime you can produce a different time format.

I didn't realize you could assign to $_ inside a foreach loop and it will change the scalars in the list.

In foreach, the loop variable (default $_) is an alias to the original value. That means that changing the value will change the original.

my $x = 100;
my @y = (10, 20, 30);
foreach ($x, @y) {
    $_ *= 2;
}
local $" = ", ";
print "\$x = $x\n\@y = (@y)\n";
[download]

# or:
foreach my $n ($x, @y) {
    $n *= 2;
}
[download]

Ditto in the block or expression for map and grep ($_ only).

map { $_ *= 2 } $x, @y;
[download]

grep { $_ *= 2 } $x, @y;
[download]

BTW parameters to subs are aliases too, so if you change them in @_, you'll modify the originals too:

sub double {
    foreach(@_) {
        $_ *= 2;
    }
}

double($x, @y);
[download]

@array = map { 5 + ($_/100) } 1 .. 100;
[download]

I am really trying to do this with time ranges, say from 1pm to 11pm but not sure that is possible either.

DateTime::Event::Recurrence? DateTime::Event::Cron? Date::Manip::Recur?

Think about what you're asking for. What does a time range from 1pm to 11pm mean? One item per hour? One item per minute? Per second? Every 30 seconds? ... The range operator ".." isn't smart enough to read your mind and isn't complicated enough to provide a way for you to tell it.

You'll have to build up your list by hand

When you have a reasonably-sized range of real-numbered values, it is actually cleanest to simply define a list (or an array) of the actual values you want to use.

If the values represent known multiples of some base value, you can use an integer range and, within that range, do the necessary calculation.   Or, you might use a while loop, initializing the variable outside the loop and adding to its value at the end of the loop.

There are many ways to do it.   Pick one that is both abundantly-clear and easily maintainable.   Remember, “requirements change,” and you will not be (nor will you want to be...) in your present job forever.

You're thinking of something like BASIC's STEP clause, in effect. You can achieve this using a C-style loop:

for (my $i = 0; $i < 100; $i += 0.1) {
   say $i;
}
[download]

but then you can end up with an accumulation of floating point error.*

...
99.7999999999986
99.8999999999986
99.9999999999986
[download]

The solution is to use an integer for the loop counter, and calculate the decimal number from it.

for (my $_ = 0*10; $_ < 100*10; ++$_) {
   my $i = $_/10;
   say $i;
}
[download]

...
99.7
99.8
99.9
[download]

Now that you're using integers, you can use a cleaner syntax.

for (0*10..100*10) {
   my $i = $_/10;
   say $i;
}
[download]

You already been shown how this get the numbers as a list.

map $_/10, 0*10..100*10
[download]

* — A lot of numbers are periodic in binary. For example, 1/10 is perodic is binary, just like 1/3 is periodic in decimal. It would take infinite storage to store 1/10 as a floating point number.

 5,5.01 ... 12.00
[download]