hervebags:

I'd do it something^[1] like this:

my @cols_to_keep = (0, 2, 3, 5, 6, 8 .. 18);
while (my $line = readline(ARGV)) {
    my @fields = split /\s+/, $line;
    print FILE2 join(" ", @fields[@cols_to_keep]), "\n";
}
[download]

[1] i.e., untested, etc.

...roboticus

When your only tool is a hammer, all problems look like your thumb.

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

use Scalar::Util qw/ looks_like_number /;

my ( $file_in, $file_out ) = ( 'file1.txt', 'file2.txt' );

open my $IN,  '<', $file_in  or die "Cannot open '$file_in' because: $
+!";
open my $OUT, '>', $file_out or die "Cannot open '$file_out' because: 
+$!";

while ( <$IN> ) {
    print $OUT join( "\t", grep looks_like_number( $_ ), split ), "\n"
+;
    }

__END__
[download]

Perl is tuned for parsing. To solve your problem you need to split each line into portions, throw away unwanted stuff, then join the remaining portions together again and print them. Consider:

use warnings;
use strict;

die <<HELP if ! @ARGV;
parse.pl <infile name>

   <infile name> source file to be processed
   
Output is printed to stdout
HELP

while (<>) {
    chomp;
    print join ' ', grep {/^[+-]?\d+(\.\d*)?$/} split;
    print "\n";
}
[download]

given your sample data in a file passed on the command line prints:

1 1549367 11 8 3 11 0 -12.00 6.00 -0.25 -3.00 0.00 -1.67 -12.00 6.00 -
+0.64
1 1549501 15 12 3 3 12 -17.00 6.00 0.50 1.00 6.00 2.67 -17.00 6.00 0.9
+3
1 1549552 14 11 3 6 8 -31.00 6.00 -2.09 -12.00 3.00 -5.67 -31.00 6.00 
+-2.86
1 1549563 14 9 5 5 9 -7.00 6.00 0.22 -64.00 4.00 -18.40 -64.00 6.00 -6
+.43
1 1549726 14 13 1 8 6 -3.00 6.00 1.92 6.00 6.00 6.00 -3.00 6.00 2.21
2 1549737 16 15 11 16 10 -64.00 6.00 -35.67 -64.00 6.00 -46.18 -64.00 
+6.00 -40.12
2 1549815 9 7 2 8 1 -3.00 6.00 -0.14 -9.00 0.00 -4.50 -9.00 6.00 -1.11
1 1549914 12 11 1 9 3 -9.00 6.00 1.18 -4.00 -4.00 -4.00 -9.00 6.00 0.7
+5
1 1550018
[download]

There are a number of important parts there: split, grep, the regular expression in the grep (see perlretut) and join. I strongly recommend that you read the documentation for each of those.

The other bit of magic is <> which reads a line at a time from stdin if there are no command line arguments, or from the files whose names are passed on the command line. Actually without the "helpfull" die the script is even more useful because it can be used as a filter accepting piped input on stdin, or by taking a file (or list of files) on the command line.

perl -Tpe "  s/\w\S+//    " < infile > outfile
[download]

See also http://www.codeproject.com/Questions/270884/Parsing-a-file-in-Perl.

Pointing someone into the right direction is better than providing the solution without explanation.

seek and tell are working on the filehandle, you could easily work on a variable after reading the line by using "substr" and maybe "length".

But most of the string manipulation in Perl is done using Perl regular expressions. Don't compare them to POSIX, Javascript or other regular expressions, all of them only have a small subset of the Perl RE's power.

\d is a char class for the numbers from 0 to 9, a basic regex for converting your line might be$line =~ s/[^\d]//g;It won't exactly do what you want (cut out too much), but it should be a good start for you. Try to use the Perl regex documentation to understand the expression shown above. Changing them to something really fitting your needs should be easy once you understood the regex.

For gurus: Yes, there is \D, but ^\d is a better learning start for this problem.

open infile
open outfile
foreach (<inputfile>){
   $_ =~ s/[letters]//g
   $_ =~ s/\s{2}//g #remove excess whitespace
   print $_ outfile
}
close infile
close outfile
[download]