randomhero1270,

What is the exact question? If ran for me, except the guesses was off by 1(too high).

The script said 4 tries, when I only typed 3 times. Easy to fix!

Good Luck!

I fixed the counter so now it works. My questions are, how do I make it actually guess higher when I type "low" or guess lower when I type "high" and why does it still guess 0? Here is my updated code

use strict;
my ($number, $new_guess, $my_hint, @guesses);
my $range = 9;
my $count = 1;
$number = int(rand($range)); #min of 1 and high of 10, range does 0-gi
+ven int so i made the range 9 (0-9) and added one to it -> (1-10)
print "My guess is: $number \n";
print "High, low, or right?\n";
while($my_hint ne "right"){
chomp($my_hint = <STDIN>);
@guesses[$count] = $my_hint;
    if ($my_hint eq "low"){
        $new_guess = int(rand($number));
        print "I guess: " . $new_guess . "\n";
        print "High, low, or right?\n";
    }
    elsif ($my_hint eq "high"){    
        $new_guess = int(rand($number));
        print "I guess: " . $new_guess . "\n";
        print "High, low, or right?\n";
    }
    elsif ($my_hint eq "right"){
        print "It took me " . $count . " tries\n"; 
    }
    else{
        print "What? Am I high, low, or right?\n";
    }    
    $count++;
}
[download]

randomhero1270:

The problem is that you're selecting a number at random throughout the range, and you're never adjusting the range. For example, if we were playing the game using 1-100 as the range and you guessed 65 and I said "low", then you'd want to guess a number between 66 and 100. If you then guessed 75 and I said "high", you'd want to guess a number between 66 and 74.

So you need to update the upper or lower limit based on the feedback from the user.

...roboticus

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

use v5.14;

package TheGame
{
    use Moo;
    use POSIX qw(floor ceil);
    
    has in              => (is => 'ro', default => sub { \*STDIN });
    has out             => (is => 'ro', default => sub { \*STDOUT });
    has lower_bound     => (is => 'rw');
    has upper_bound     => (is => 'rw');
    has guess_count     => (is => 'rw', default => sub { 0 });
    has guess_technique => (is => 'ro', default => sub { 'random' });
    
    sub play
    {
        my $self = shift->new(@_);
        
        printf {$self->out} (
            "Choose a number between %d and %d!\n",
            $self->lower_bound,
            $self->upper_bound,
        );
        sleep(2);
        
        GUESS: {
            my $guess = $self->make_guess;
            my $wrong = $self->analyse_guess($guess);

            if ($wrong and $self->upper_bound <= $self->lower_bound) {
                die "stop cheating!";
            }

            if ($wrong > 0) {  # too high
                $self->upper_bound($guess - 1);
                redo GUESS;
            }
            
            if ($wrong < 0) {  # too low
                $self->lower_bound($guess + 1);
                redo GUESS;
            }
        }
        
        printf {$self->out} (
            "Got it in %d guesses!\n",
            $self->guess_count,
        );
    }
    
    sub make_guess
    {
        my $self = shift;
        state $toggle = 0;
        
        my $guess;
        if ($self->guess_technique =~ /good/)
        {
            my $diff = $self->upper_bound - $self->lower_bound;
            $guess = floor(
                +    ($self->upper_bound / 2)
                +    ($self->lower_bound / 2)
                +    ($diff / 10)
                -rand($diff / 5)
            );
        }
        elsif ($self->guess_technique =~ /halves/)
        {
            $guess = floor(
                +    ($self->upper_bound / 2)
                +    ($self->lower_bound / 2)
            );
        }
        elsif ($self->guess_technique =~ /thirds/)
        {
            my $upper_or_lower = (++$toggle % 2)
                ? $self->upper_bound
                : $self->lower_bound;
            $guess = floor(
                +    ($self->upper_bound / 3)
                +    ($self->lower_bound / 3)
                +    ($upper_or_lower / 3)
            );
        }
        else  # random number in the range
        {
            $guess = floor(
                +    $self->lower_bound
                +    rand($self->upper_bound - $self->lower_bound)
            );
        }
        
        $guess++ while $guess < $self->lower_bound;
        $guess-- while $guess > $self->upper_bound;
        
        $self->guess_count( $self->guess_count + 1 );
        
        return $guess;
    }
    
    sub analyse_guess
    {
        my ($self, $guess) = @_;

        printf {$self->out} (
            "My guess is %d. Am I 'too high', 'too low' or 'right'?  "
+,
            $guess,
        );

        ANSWER: {
            my $in     = $self->in;
            my $answer = <$in>;
            
            return  0 if $answer =~ m{ (right) | (correct) }x;
            return  1 if $answer =~ m{ (too \s* high) | (lower) }x;
            return -1 if $answer =~ m{ (too \s* low) | (higher) }x;
            
            print {$self->out} "Sorry... what was that?  ";
            redo ANSWER;
        }
    }
}

TheGame->play(lower_bound => 1, upper_bound => 1000, guess_technique =
+> 'good');
[download]

my $random = int (rand(100));
$count = 0;
while ($random != $choice)
{
    print "enter your choice = ";
    $choice = <STDIN>;
    $count++;
    print "you entered= $choice";
    if($choice == $random)
    {
        print "Bravo-------------------you win";
        print "\nTotal number of counts= $count\n";
        exit;
    }
    elsif ($choice gt $random)
    {
        print "\nyour choice is TOO High\n";
    }
    else
    {
        print "\nyour choice is too low\n";
    }
    print "\nto quit press q OR press enter to continue  ";
    $value = <STDIN>;
    if($value eq "q\n")
    {    
        print "Sorry!! you lost    :-(\n";
        print "\nTotal number of counts= $count\n";    
        exit;
    }
    
}
[download]

That's not gonna work. gt, eq, etc are for strings, not for numbers.





I'm too lazy to be proud of being impatient.