Im trying to compare two arrays but my code continues to mach within the

match has been made.

My code:

print "Content-type: text/html\n\n";

($type) = split(/\,/,$animal);

($type2) = split(/\,/,$animal2);

if ($type eq $type2) {
next;

The output to looks like this:

cat is not in in our list
cat is not in in our list
cat is not in in our list
cat is not in in our list
dog is not in in our list
dog is not in in our list
dog is not in in our list
dog is not in in our list
mouse is not in in our list
mouse is not in in our list
mouse is not in in our list
rat is not in in our list
rat is not in in our list
rat is not in in our list

########################################

I want the output to look like this:

In Perl, when a problem involves deciding whether a given string
is a member of a set of strings, the solution almost invariably
involves a hash.  In particular, the exists operator tells if a given
string is among the keys of a hash.  So all you have to do is set up

    my %h;

The second line involves a hash slice.  It sets all values of %h to
undef, but we only need the keys, not the values.

Now your program amounts to simply:

        print "$animal is not in our list\n" unless exists $h{ $animal};
    }

It's one of the points where Perl makes simple things simple.

One way is to set a flag and only  print the message if the flag is not set

so.... something like this .....

$flag=0;

$flag=1 if ($animal2 eq $ animal);

of course you could make array2 a join'ed string (at the very start) and use
index rather than a loop ...

e.g.

print "$animal is not in the list\n" if (index($all_animal2,$animal)==-1);

How about

#!/usr/bin/perl -w
use strict;

print "Content-type: text/html\n\n";

        my $found;

                if($animal eq $animal2){
                        $found = 1;
                }
        }
        unless($found){
                print "$animal is not in out list<br>";
        }

3. If you only have one occurrence of each text in each array, you would be far
better to use a hash to compare them, then you don't need nested loops.

value.
# The value doesn't matter, just the fact that it has a value at all.

    unless($hash1{$_}){ # tests whether $_ exists in $hash1
        print "$_ missing from list1\n";
    }

        unless($hash2{$_}){
            print "$_ missing from list2\n";
        }

Graham Wood

Double looping is a relatively slow and inefficient
way to approach this simple task. However, writing
code which is slow and inefficient does comply with
Perl 5 Cargo Cult dogma.

I suppose your decision on how to do this would depend
on your being a Perl 5 Cargo Cultist or your being
a Perl programmer.

Godzilla!
--

TEST SCRIPT:
____________

#!perl

print "Forwards:\n\n";

 {

   { print "$_ is not found in Array Two.\n\n"; }
 }

print "\n\nBackwards:\n\n";

 {

   { print "$_ is not found in Array One.\n\n"; }
 }

exit;

PRINTED RESULTS:
________________

Forwards:

cat is not found in Array Two.

dog is not found in Array Two.

Backwards:

bird is not found in Array One.

   > Double looping is a relatively slow and inefficient
   > way to approach this simple task.

Of course, so is single looping:

        use Quantum::Superpositions;

        print "Forwards:\n\n";

        print map "$_ is not found in Array 1\n",

        print "Backwards:\n\n";

        print map "$_ is not found in Array 2\n",

;-)

(snipped)

My experience is use of modules and especially use of
the map () function, both are almost always slow and
inefficient compared to more simple or, more imaginative
programming methods.

This is especially true with map. Like grep, map becomes
less efficient with increasing data size.

For your code, you are using both a module and map. I am
not sure this would be the most efficient method. Certainly
your memory overhead would be significantly bloated.

My method will exhibit relatively the same efficiency
with increasing data size. Memory bloat is minimized.

Godzilla!
--

Other questions around that same area may be of interest to you as
well.

   > Quantum is not ported for Win32, last I checked, else
   > I would benchmark this for you.

   > For your code, you are using both a module and map. I am
   > not sure this would be the most efficient method. Certainly
   > your memory overhead would be significantly bloated.

Well, I was obviously wrong when I decided to leave off that
"I'm-not-being-serious-here" smiley. ;-)

No, I wasn't really suggesting that solution as more efficient
(though I do maintain that it's more elegant).

On the other hand, Larry *is* still contemplating whether to
include superpositions in Perl 6. If he does, then the optimal
solution will eventually be:

(snipped)

In the past, I tried several and encountered way too many
problems, such as very poor documentation, file names needing
to be truncated to DOS eight plus three, other modules needing
to be installed and so on. I decided those modules I do have
installed, which are numerous, are more than ample for my needs.
As you know, I personally am not one to use modules, save for
a small handful, like Benchmark, LWP and Socket.

This is not to say I do not learn from modules, do not "steal"
from modules and write my own equal code into scripts. Don't be
surprised if you read a script of mine which contains code
similar to or simply ripped from your module.

Few today, learn how to really program, how to write a program from
A to Z, complete and final with no modules, no automatic features.
These modules and features, discourage people from truly learning.
It is clear and well evidenced, there are a lot of unimaginative,
a lot of less-than-talented programmers populating this group.
People will do better to learn how to program first, then enjoy
these extra features, such as modules.

My final comment is being born on a rural Oklahoma farm, barefoot,
penniless, delivered by a Choctaw squaw and never being afforded
a decent education having to work to simply survive, has taught
me this lesson of learning lessons is truly a great lesson.

Here are some benchmark results based on a snippet I grabbed from here.

Godzilla!
--

#!perl

print "Content-type: text/plain\n\n";

use Benchmark;

print "Run One:\n\n";
&Time;

print "\n\nRun Two:\n\n";
&Time;

print "\n\nRun Three:\n\n";
&Time;

sub Time
 {
  timethese (1000000,
  {
   'name1' =>



     {
      my $found;

       {
        if($animal eq $animal2)
         { $found = 1; }
        }
      unless($found)
       { $output = "$animal is not in out list<br>"; }
     }',

    'name2' =>



      {

       { $output = "$_ is not found in Array Two.\n\n"; }
      }',
  } );
 }

Run One:

Benchmark: timing 1000000 iterations of name1, name2...

Run Two:

Benchmark: timing 1000000 iterations of name1, name2...

Run Three:

 |
 |    > Double looping is a relatively slow and inefficient
 |    > way to approach this simple task.
 |
 | Of course, so is single looping:
 |
 |      use Quantum::Superpositions;
 |


 |
 |      print "Forwards:\n\n";
 |
 |      print map "$_ is not found in Array 1\n",

 |
 |      print "Backwards:\n\n";
 |
 |      print map "$_ is not found in Array 2\n",

 |
 | ;-)
 |
 | Damian

The above is why I love Perl so much :) Cool stuff like that just blows
me away. I don't know HOW you managed to think of this, Damian, but my
hat's off to you.

I think this also belongs in the Examples section of the Documentation
for Quantum::Superpositions, as I wouldn't have immediately seen the
usefulness of 'map' in this context if I hadn't seen this post.

Shaking my head in wonderment as I look at how sweet that is, and
wishing I had seen or thought of it earlier. :)

Ditto.

   > Shaking my head in wonderment as I look at how sweet that is, and
   > wishing I had seen or thought of it earlier. :)

It could get even lovelier if superpositions make it into the core of Perl 6.

For instance, if C<printf> were able to natively handle superpositions,
the whole thing might reduce to:

;-)

PS: Is there any reason you used map in your earlier code, instead of
a for or foreach modifier?  eg:

print "$_ is not found in Array 2\n"

print "$_ is not found in Array 1\n"