I don't know if this is a possible answer but it works with the example binary string you provided.

#!/usr/bin/perl
use strict;
use warnings;

my $bin =  0b1111_1111_1111;

for my $factor (3,5) {
    # round up to multiple of 4
    my $shift = $factor + (-$factor % 4); 
    my $c = $bin >> $shift;
    $c <<= $shift;
    printf "%b\n", $c;
}
[download]

111111110000
111100000000
[download]

I'm a tiny bit biased here, but Bit::Manip might help :)

A few bit manipulation questions recently. Must be the start of a new school year or something.

or a new hack for game consoles or some other devices haha

I'm assuming that this question is associated with the generation of arrays of nybbles in the Bit manipulation of a bit stream to generate different elements of an array with each nibble taking either 0 or 1 in perl post and that you might want to act on any element of the array, not just those in which all nybbles are 1111. If so, you can create a mask where nybbles to leave untouched are set to 1111 and those to zero are set to 0000 then AND it with the relevant array element. It is not clear from the OP but I'm also assuming that your offset is one-based counting from the right in bits, i.e. offsets 1 through 4 mask the rightmost nybble, 5 through 8 the rightmost two nybbles etc. The code is simple to modify if counting is zero-based.

use strict;
use warnings;

use feature qw{ say };
my $sep = sub { say q{-} x 24; };

my $baseStr = q{{0,f}};
my $width   = 4;
my $globStr = $baseStr x $width;

$sep->();
foreach my $offset ( 3, 5, 8, 9 )
{
    say qq{Offset - $offset};
    my @bitStrs = map { pack q{H*}, $_ } glob $globStr;

    my $div           = int( $offset / 4 );
    my $rem           = $offset % 4;
    my $nybblesToMask = $div + ( $rem ? 1 : 0 );
    my $mask          = pack q{H*},
       q{f} x ( $width - $nybblesToMask ) . q{0} x $nybblesToMask;

    say q{Mask         - }, unpack qq{B@{ [ $width * 4 ]}}, $mask;
    say q{Element 5    - }, unpack qq{B@{ [ $width * 4 ]}}, $bitStrs[ 
+5 ];
    say q{E. 5 & mask  - }, unpack qq{B@{ [ $width * 4 ]}},
       $bitStrs[ 5 ] & $mask;

    say q{Element 15   - }, unpack qq{B@{ [ $width * 4 ]}}, $bitStrs[ 
+15 ];
    say q{E. 15 & mask - }, unpack qq{B@{ [ $width * 4 ]}},
       $bitStrs[ 15 ] & $mask;

    $sep->();
}
[download]

The output.

------------------------
Offset - 3
Mask         - 1111111111110000
Element 5    - 0000111100001111
E. 5 & mask  - 0000111100000000
Element 15   - 1111111111111111
E. 15 & mask - 1111111111110000
------------------------
Offset - 5
Mask         - 1111111100000000
Element 5    - 0000111100001111
E. 5 & mask  - 0000111100000000
Element 15   - 1111111111111111
E. 15 & mask - 1111111100000000
------------------------
Offset - 8
Mask         - 1111111100000000
Element 5    - 0000111100001111
E. 5 & mask  - 0000111100000000
Element 15   - 1111111111111111
E. 15 & mask - 1111111100000000
------------------------
Offset - 9
Mask         - 1111000000000000
Element 5    - 0000111100001111
E. 5 & mask  - 0000000000000000
Element 15   - 1111111111111111
E. 15 & mask - 1111000000000000
------------------------
[download]

I hope this is helpful.

Update: Clarified wording re the offset.

#!/usr/bin/env perl
use strict;
use warnings;

my $data = 0b1111_1111_1111;

my $offset = 8;
my $nibble_mask = 0xF;

while  (not 1<<$offset-1 & $nibble_mask) {
    $data ^= $nibble_mask;
    $nibble_mask <<= 4;
}
$data = $data ^ $nibble_mask;

printf("%b\n",$data);
[download]

How naive I was to loop through looking for something already given...

#!/usr/bin/env perl
use strict;
use warnings;

my $data = 0b1111_1111_1111;
my $offset = 5;

my $mask = hex 'F' x ($offset % 4 == 0 ? $offset / 4 : $offset / 4 + 1
+);

printf("%b\n",$data ^ $mask);
[download]

There are a few bit manipulation tricks worth knowing about when you are dealing with masking blocks of bits:

#!/usr/bin/env/perl
use strict;
use warnings;

my $oValue = 0xAAAA;
my $setBit = 1 << 5;
my $mask = $setBit - 1;
my $setBits = $oValue | $mask;
my $resetBits = $oValue & ~$mask;

printf "orig: %016b\n", $oValue;
printf " bit: %016b\n", $setBit;
printf "mask: %016b\n", $mask;
printf " set: %016b\n", $setBits;
printf " clr: %016b\n", $resetBits;
[download]

Prints:

orig: 1010101010101010
 bit: 0000000000100000
mask: 0000000000011111
 set: 1010101010111111
 clr: 1010101010100000
[download]

Note that ~ generates the 1s complement (inverts each bit) of its operand.

If this is to be done repeatedly, I'd go with a lookup table. The table could be built dynamically (e.g. by using the code from the other answers in a loop), but it's probably not worth the effort.

my @mask_by_offset = (
    ( ~0x0000_000F ) x 4,
    ( ~0x0000_00FF ) x 4,
    ( ~0x0000_0FFF ) x 4,
    ( ~0x0000_FFFF ) x 4,
    ( ~0x000F_FFFF ) x 4,
    ( ~0x00FF_FFFF ) x 4,
    ( ~0x0FFF_FFFF ) x 4,
    ( ~0xFFFF_FFFF ) x 4,
);

$val &= $mask_by_offset[$offset];
[download]

The mask are defined in terms of the bits to keep to work with 32-bit ints and 64-bit ints.