If I understand you correctly, you have an input file with four fields per line. You want to discard the first two, and join the last two like this "G/A". You then want to print every 90th of these as a new column on each line to produce 90 lines of 301 columns. (I'm ignoring the fact that 90*301 != 10,000 :).

This sample code shows one way to do this...I've done 3 lines of 34 to save a little space:)

#! perl -slw
use strict;

# Read the file, split into fields, discard the first 2
# join fields 2/3 as required for output.

my @data = map{ join '/', (split ' ')[2,3] } <DATA>;

my @lines; # Array in which to accumulate the output.

# build each output line

for my $line ( 0 .. 2 ) { # 0 .. 89 in your app

    # by steping through the input and appending every nth element to 
+the output

    for my $col ( 0 .. 33 ) { # 0 .. 300 in your app

        $lines[ $line ] .= $data[ $line * 34 + $col ] . ' ';
    }
}

# display the output.
print for @lines;
[download]

Output

P:\test>junk
N/N G/G A/A A/G A/A A/G A/A A/G A/G N/N G/G A/A A/G A/A A/G A/A A/G A/
+G N/N G/G A/A A/G A/A A/G A/A A/G A/G N/N G/G A/A A/G A/A A/G A/A
N/N G/G A/A A/G A/A A/G A/A A/G A/G N/N G/G A/A A/G A/A A/G A/A A/G A/
+G N/N G/G A/A A/G A/A A/G A/A A/G A/G N/N G/G A/A A/G A/A A/G A/A
N/N G/G A/A A/G A/A A/G A/A A/G A/G N/N G/G A/A A/G A/A A/G A/A A/G A/
+G N/N G/G A/A A/G A/A A/G A/A A/G A/G N/N G/G A/A A/G A/A A/G A/A
[download]

Even though your subject is printf, you ask a much larger question in regards to converting your data into columns going across rather than down. The easiest option by far (assuming you have the memory to do so) would be to create a new data structure in the form of a 2 dimensional array and then you can easily print it out using some nested for loops:

#!/usr/bin/perl -w
 
use strict;
use Data::Dumper;
our @qqq=(1..100);
 
sub print_col
{
        my ($rows, $qref)=@_;
        my @cols=();
        my $count=0;
while($count<=$#$qref)
{
        #This for loop creates the 2D array
        for (0..$rows-1)
        {
                push @{$cols[$_]}, $qref->[$count];
                $count++;
                #This makes sure to stop when we run out of data
                last if $count > $#$qref;
        }
}
        #Data::Dumper just in here for testing, love that module
        #print Dumper(\@cols);


        #This for loop prints it, notice I use the quoted array syntax
+ 
        #which causes print to output the array with spaces in between
+ 
        # each element.  However, this is the perfect place to put 
        #another for loop or a map statement and printf each element 
        #with the correct width and other formatting you want.
        for (0..$#cols){
                print "@{$cols[$_]}\n";
        }
}

print_col(shift, \@qqq);

######################
## Output
$ ./testcols.pl 25
1 26 51 76
2 27 52 77
3 28 53 78
4 29 54 79
5 30 55 80
6 31 56 81
7 32 57 82
8 33 58 83
9 34 59 84
10 35 60 85
11 36 61 86
12 37 62 87
13 38 63 88
14 39 64 89
15 40 65 90
16 41 66 91
17 42 67 92
18 43 68 93
19 44 69 94
20 45 70 95
21 46 71 96
22 47 72 97
23 48 73 98
24 49 74 99
25 50 75 100
[download]

HTH

If I understand correctly, you want fixed-width fields to be printed out, with the data aligned nice and pretty. In other words, you want format().

----
I wanted to explore how Perl's closures can be manipulated, and ended up creating an object system by accident.
-- Schemer

Note: All code is untested, unless otherwise stated

I'm not exactly sure what you are asking in terms of output.

You want to import 90 lines, strip off the first two fields separated by a 'tab' character, join the last two with a '/', push them onto an array, print the first field, print the whole array, then cycle back for the next 90?

Or do you want to build 301 X/X columns side by side? Something like this:

000217
N/N
G/G
A/A
A/G
A/A
A/G
A/A
A/G
A/G
(until 90 items are listed),

Then cycle back and grab another 90, and add to the above by adding another column onto the X/X list?

Let me know. I'm kind of unsure about what you are asking.

J. J. Horner 
CISSP,CCNA,CHSS,CHP,blah,blah,blah