..., 0.3, 0.58, 0.2, ...
[download]

20
[download]

20 20
[download]

#!/usr/bin/perl

use strict;
use warnings;

my @probs;
{
    local $/;
    @probs = split " ", <DATA>;
}
my $segs = get_ranges( sub { return ( $_[0] > 0.5 ) },
                       \@probs );

print "$_\n" for ( @$segs );

sub get_ranges
{
    my ( $cmp, $list ) = @_;
    my @ranges = ();
    my @current_range = ();
    my $endpoint = 0;

    for ( 0 .. $#$list ) {
        if ( $cmp->( $$list[$_] )) {
            $current_range[$endpoint] = $_;
            $endpoint = 1;
        }
        elsif ( @current_range ) {
            push @ranges, "@current_range";
            @current_range = ();
            $endpoint = 0;
        }
    }
    return \@ranges;
}

__DATA__
0 0.1 0.53 0.51 0.59 0.67 0.2 
0.04 0.05 0.56 0.89 0.75
0.3 0.58 0.25
[download]

(Updated to simplify the anon.sub that is passed to get_ranges; $cmp->($item) just needs to return true when $item is in the targeted range.)

 my @probs =(0,0.1,0.53,0.51,0.59,0.67,0.2,0.04,0.05,0.56,0.89,0.75);
 my $t;
 print $_ . (",","\n")[$t=1-$t]  
     for  grep {($probs[$_] >=.5 .. $probs[$_]> .5) and $t=!$t }
            0..$#probs
[download]

2,4
9,11
[download]

Add an extra datum to @probs and the output layout goes a bit ga ga as well.

$ cat spw759180_NetWallah 
#!/usr/bin/perl
#
use strict;
use warnings;

my @probs =(0,0.1,0.53,0.51,0.59,0.67,0.2,0.04,0.05,0.56,0.89,0.75,0.6
+);
my $t;
print $_ . (",","\n")[$t=1-$t]  
    for  grep {($probs[$_] >=.5 .. $probs[$_]> .5) and $t=!$t }
           0..$#probs
$ ./spw759180_NetWallah
2
4,9
11,$
[download]

I think you have to separate the task of finding the in-range values from that of determining the range boundaries as you have no idea what the next datum will be when processing the current one. Also, I think the start and stop conditions of the flip-flop should be consistent (and both > 0.5 since that is the requirement in the OP). In the following code I've added some data to show how single-element ranges are treated.

use strict;
use warnings;

my @probs = (
   0,
   0.1,
   0.53,
   0.51,
   0.59,
   0.67,
   0.2,
   0.04,
   0.05,
   0.56,
   0.89,
   0.75,
   0.1,
   0.51,
   0.6,
   0.2,
   0.7,
   );

my @inRange =
   grep { $probs[ $_ ] > 0.5 .. $probs[ $_ ] > 0.5 }
   0 .. $#probs;

my @starts =
   map  { $inRange[ $_ ] }
   grep {
            $_ == 0
            ||
            $inRange[ $_ ] - $inRange[ $_ - 1 ] != 1
        }
   0 .. $#inRange;

my @ends =
   map  { $inRange[ $_ ] }
   grep {
            $_ == $#inRange
            ||
            $inRange[ $_ + 1 ] - $inRange[ $_ ] != 1
        }
   0 .. $#inRange;

printf qq{%3d%3d\n}, $starts[ $_ ], $ends[ $_ ] for 0 .. $#starts;
[download]

The output.

  2  5
  9 11
 13 14
 16 16
[download]

I hope this is of interest.

Cheers,

JohnGG

use strict;
use warnings;
my @probs =(0,0.1,0.53,0.51,0.59,0.67,0.2,0.04,0.05,0.56,0.89,0.75);
my @pos;
my @segment;
foreach (0..$#probs){
    no warnings 'uninitialized';
    my $start;
    if ($probs[$_] > 0.5 && $probs[$_+1] <= 0.5){
        push @pos, $_;
    } elsif ($probs[$_] <= 0.5 && $probs[$_+1] > 0.5) {
        push @pos, $_ + 1;
    } 
}

use Data::Dumper;
print Dumper \@pos;
[download]

You may use existing solutions, like Bit::Vector:

use Bit::Vector;

my @probs =(0,0.1,0.53,0.51,0.59,0.67,0.2,0.04,0.05,0.56,0.89,0.75);

my $v = Bit::Vector->new(int @probs);
$v->Index_List_Store(grep { $probs[$_] > .5 } 0..$#probs);

for (my ($start, $min, $max) = 0; $start < $v->Size(); $start = $max +
+ 2) {
    last unless ($min, $max) = $v->Interval_Scan_inc($start);
    print "$min $max\n";
}
[download]

or even use $v->to_Enum instead of above for loop and receive

2-5,9-11
[download]

As a marginal note, you use indexes out of bounds of the array (in $probs[$_+1], when $_=$#probs), which is an error-prone practice.