After trying out some of the suggestions, I am running into the exact same issue.

I realized after testing out and playing around with the suggestions that I needed to add an extra note in my original post to help clarify the problem a little further.

When mentioning that this code did not do what I expected, what I was really meaning, was that if you bring the first print statement to the end of the code, this is where I run into problems.

Essentially, what ultimately happens, is that I get a situation where I get what I originally described. If I move the statement:

print B "@actualsyll\n";
[download]

down to where the second print statement is:

print B @shift3\n";
[download]

I get repeats of the first line from the first document.

If I flip the codes around such that the entire second open/used files are placed above the first half of the code (see below), I get the same thing in reverse.

I am just stuck and would love any further thoughts.

I realize my coding is not high quality at the moment, but I have not been programming for long and thus am still learning the more moderate/advanced level stuff.

Before I post the code I wanted to note that I am genuinely sorry if it is not in a nicely formatted fashion (i.e., indented properly). I am totally blind and as I use speech software to read material on the computer, such indents are unnecessary and actually less helpful for me. Thus, I am not tabbing because I do not want to produce more confusion for readers by oddly indenting things that are not normally indented. Again I am sorry if this makes my code more difficult for readers.

The flipped code follows (please note that this is very close to the original (i.e., not including a lot of changes for help in clarification so if your changes are not included it was not meant as ignoring or trying them out but rather for simplification)):

#Loop gets all files matching ex. 2 opens them;
foreach $file (<s*.words>) {
open (A, "<$file") || die "$file";
open (B, ">>awe.txt") || die "output";

#Making a loop of all lines in each file;
while ($line1 = <A>) {
#There are headers with information I do not need so this essentially 
+cuts them out;
$line1 =~ s/^   |^    |^\s\s\s|\s{3,4}//;
#Chomping of the newline;
chomp;
#Making a loop of all lines in all files from ex. 2 without their head
+ers;

foreach ($line1 =~ /^\d/g) {
#Splitting the files into the numbers to the first space, the 122, the
+ word minus extra markers, the chopped up word before the ";, the fin
+al chopped up word;
if ($line1 =~ /\d\s\w|\d\s{1,2}\d|\d\s\s\d|\d  \d|;\s\w/gi) {
$line1 =~ s/\s| |\s\s|  |\s{2}/\t/g;
$line1 =~ s/\t\t|\t{2}/\t/;
($stamp,$extra,$orth,$a,$b,$c,$d,$e,$f,$g, $h,$i,$j,$k,$l, $m, $n,$o,$
+p,$q,$r,$s,$t,$u,$v,$w,$x,$y,$z) = split(/ <|>;|\t/, $line1);
#splitting all of the information after the first ";" into 2 scalars;
$split = "$a $b $c $d $e $f $g $h $i $j $k $l $m $n $o $p $q $r $s $t 
+$u $v $w $x $y $z";
($canon,$spoke) = split(/; /, $split); 
#Getting rid of some additional extraneous material (i.e., unwanted sp
+aces...);
$orth =~ s/;//;
$spoke =~ s/\s{1,}$|\t{1,}$//g;
#Making an array that will bind everything together (mostly to aid in 
+later coding not yet created);
@general = ($file, $stamp,$extra,$orth,$canon, $spoke, $syll);
}

#combining all of the $orth's into a loop;
foreach ($general[3]) {
#Making each column into its own array;
push(@array0, $general[0]);
push(@array1, $general[1]);
push(@array2, $general[2]);
push(@array3, $general[3]);
push(@array4, $general[4]);
push(@array5, $general[5]);
}}}}
close A;

#Making a loop of each array created above;
while (@array0) {
#Removing each element one at a time for later (not yet created) condi
+tional searching of each array element;
 $shift0 = shift @array0;
$shift1 = shift @array1;
$shift2 = shift @array2;
$shift3 = shift @array3;
$shift4 = shift @array4;
$shift5 = shift @array5;
#Prints out the $orth word of each line on its own line (used mostly a
+s a debugger right now);

#print B "$shift3\n";
}

#Open file matching ex.1;
open (C, "<dic.txt") || die "dictionary";
#open file to write to;
#open (B, ">>all.txt") || die "output";

#Making a loop of all lines in example 1 file;
while ($line2 = <C>) {
#Getting rid of the newline;
chomp $line2;
#Split all lines;
@firstgrouping = split(/, |,\s|,\t|,|\s,|\t,| ,/, $line2);
#splitting the lines in $firstgrouping[2] by the numbers so that text 
+before and after number are different indexed scalars;
@actualsyll = split(/\d |\d\s|\d\t|\d|\s\d| \d|\t\d|\t\d\t|\s\d\s| \d 
+/, $firstgrouping[2]); 
#Printing the new version of @firstgrouping[2];
#print B "@actualsyll\n";
print B "$shift3\n";
}
close C;
[download]

Many thanks,
Napa

Welcome to the Monastery, Napa.

I am genuinely sorry if it is not in a nicely formatted fashion (i.e., indented properly)

Obviously, given your circumstances, no apologies are necessary.

I have re-posted your code below for the benefit of others, with some indentation using the free utility, perltidy.

Read more... (5 kB)

As toolic said, Welcome to the Monastery.

Since you are working with a large number of large input files, let's do some simple tests to help isolate the problems with the code you posted. It will help us if you make a small number of small files for some test runs (and working with the small files may even make the entire problem immediately clear to you). I suggest three files of five lines each, as follows (be sure to include the header lines, if any, in each of these files):

• An "Example 1" file as described in your original post (I don't think this one has headers, but include them if there are any).
• Two "Example 2" files, one for each of the example 2 types that you showed in your original post (don't forget the headers).

We also need some output files. As I understand your original post, you started with two separate programs, one to process "Example 1" data and another to process "Example 2" data, and each of those worked as you expected. Please run each of these programs on the appropriate short sample file(s) noted above, and show us the output files for each of the three input files.

Last of all (for now, anyway), run your combined program on the three short input files and show us the output file that it generates. Hopefully, we will be able to see how this output differs from the outputs from the individual programs.

Once we have the samples in front of us, we will be in better shape to help you get things working the way you expect.