$this_file =~ /^(.*?)-(\d+?)-(.*?)\.ext$/)

my @sortedarray

$file =~ s/.*-//; #removes everything up and including last hyphen

userx%slackwhere ⚡ scripts ⚡> ./perl-find-missing-numbers.pl 270
162
170
172
173
174
175
181
186
195
196
197
198
245

userx%slackwhere ⚡ scripts ⚡> ./perl-number-list
162 is missing!
170 is missing!
172 is missing!
173 is missing!
174 is missing!
175 is missing!
181 is missing!
186 is missing!
195 is missing!
196 is missing!
197 is missing!
198 is missing!
245 is missing!

#!/usr/bin/perl

use strict;
use warnings;

my $working_dir="/run/media/userx/3TB-External/Files-Resampled";

opendir(DIR, $working_dir) || die "Can't open $working_dir: $!\n";
  while( (my $filename = readdir(DIR))){
    push(my @files, $filename);
    print ("@files\n");
     
    }
closedir(DIR);

seq 1 270 > numbers.txt; ls -1 /run/media/userx/3TB-External/Files-Resampled/*.mp4 | rev | cut -d "." -f2 | cut -d "-" -f1 | rev | sort | comm -3 numbers.txt -

# TO ADD TO THE BACK

@thearray = (@thearray, $newelement);

# OR TO PUT AT THE FRONT

@thearray = ($newelement, @thearray);

#OR

unshift @thearray,  $newelement; # places $newelement as the first element of the array

#!/usr/bin/perl

use strict;
use warnings;

our @array = ();
for (1..10) {
  $array[$_] = $_;
}
print join("\n", @array) , "\n";

#!/usr/bin/perl

use strict;
use warnings;

our @array = ();
for (1..10) {
  $array[$_] = $_;
}

require "printest.pl";
exit(0);

#-------------------
#PRINTEST.PL TEXT:

#!/usr/bin/perl

use strict;
use warnings;

our @array;

print join ("\n", @array), "\n";

# OUTPUT

1
2
3
4
5
6
7
8
9
10

for i in {1..4690}; do mkdir $i_a; done
for i in */; do touch "$i"/file-{000..999}-adfg324.ext; done
for i in */; do rm $i/file-$(echo $RANDOM | cut -b1-3)-adfg324.ext; done # Randomly remove a file from each directory

$ time ./numbersequencer.py number_testing/*/ # total 4690 directories
Missing Files in /home/user/number_testing/1000_a:
239
Missing Files in /home/user/number_testing/1001_a:
223
Missing Files in /home/user/number_testing/1002_a:
882
...
real	0m8.508s

$ rm 2407_a/file-{497,987,999}-adfg324.ext
$ ./numbersequencer.py number_testing/2407_a/
Missing Files in /home/user/number_testing/2407_a:
497
987

#!/usr/bin/env python3

from __future__ import print_function, division

import argparse
import os
import re
import sys

class SequencyConsistency():
    def __init__(self, sequence, regex_def_grp=None):
        if regex_def_grp:
            self.regex_compiled, self.regex_group_num = regex_def_grp
        else:
            self.regex_compiled, self.regex_group_num = (re.compile('(\d+)'), 1)

        self.sequence = sequence
        self.missing_sequencies = self.__missing_number_sequence()

    def __missing_number_sequence(self):
        self.matches = {str(self.regex_compiled.search(sequence).group(self.regex_group_num))
                        for sequence in self.sequence
                        if self.regex_compiled.search(sequence) != None}

        if self.matches:
            # Generate set of numbers from 1 to highest regex detected
            try:
                max_range = max(int(match) for match in self.matches)
            except ValueError:
                print('Regex must match a integer.', end='\n\n')
                raise

            full_range = set(str(num).rjust(len(str(max_range)), '0') 
                             for num in range(1, max_range + 1))
            return full_range.difference(self.matches)
        
    def print_missing_sequencies(self, reverse=False):
        if getattr(self, 'missing_sequencies', None):
            return sorted(self.__missing_number_sequence(), reverse=reverse)


class DirectoryConsistency(SequencyConsistency):
    def __init__(self, directory, regex_def_grp=None):
        try:
            self.sequence = os.listdir(directory)
        except (FileNotFoundError, NotADirectoryError, PermissionError) as err:
            # Exit class if directory indicated is incorrect
            print(err, file=sys.stderr)
            return None

        # Inherit from SequenceConsistency
        SequencyConsistency.__init__(self, self.sequence, regex_def_grp)

def main():
    # Create commandline flags
    parser = argparse.ArgumentParser(description='Detect missing portion of sequency in given sequency')
    parser.add_argument('-e', '--regexp',
            type=str,
            required=False,
            default='(\d+)',
            help='Set regex. Defaults to (\d+)')
    parser.add_argument('-g', '--group',
            type=int,
            required=False,
            default=1,
            help='Set regex matching group to identify sequence. --group 3 will match (\d+) in regexp of (\w)(-)(\d+). Each () identifies a group')
    args, other_args = parser.parse_known_args()

    directories = other_args if other_args else sys.stdin
    for directory in directories:
        current_dir = DirectoryConsistency(directory.strip(),
                                           regex_def_grp=(re.compile(args.regexp), args.group))

        missing_in_dir = current_dir.print_missing_sequencies()

        if missing_in_dir:
            print('Missing from {directory}:'.format(directory=repr(os.path.abspath(directory.strip()))))
            print('{sequences}'.format(sequences='\n'.join(seq for seq in missing_in_dir)))

if __name__ == '__main__':
    main()