Linux World: Game of anagrams using perl

The game of anagrams using perl

The perl script below is for the game of anagram, i.e you will presented with a word with its letters jumbled and you have to guess the correct word.

The script by default uses the file /usr/share/dict/words, which has a list words of english.
Script explanation:

Variables :
$score = 0; To keep track of the score
$level = 5; To set the level
$file = "/usr/share/dict/words"; The default file to look into for words.
$max = 74000; Maximum number of words in the file being used.

Subroutines :

randomize :
This is the main subroutine that is the core of the game.
The file to be used is opened in read mode using

We will pick any random word from this file and shuffle it to generate the anagram. So for this we need a random integer number, which is generated using the rand function.

Where $max is the maximum number among random the numbers generated.
We will loop over the file incrementing a count on every word till count becomes equal to the random number.
The word at the specified count will have to be shuffled now. But before this we have look into the following points
1. The word is not a noun, hence we check if the first letter is capitalized /^[A-Z]/
2. The word is not of the kind her's , their's etc. We look for " ' " in the file using
index($_,"\'")
If this returns -1 then the word does not have a " ' ".
3. Make sure the number of letter in the word is as per the level set, i.e.
For easy number of letters is lesser than 5
For medium number of letter is lesser than 7
For hard number of letter is lesser than 10.
These three conditions are checked using

In case this if condition fails we generate a new random number and restart from the beginning of the file and
This is the else part

If the word is fine then the word will be read as a string, to shuffle the letters we will have to convert it to an array. This is done using split as follows.

To get the length of the string we use the function length () .
An array of flags is used to keep track of the letters that have been shuffled. The flag array is initialized to 0 using

Next we start a loop which runs as many times as the word length and in each iteration we select a random letter from the string again using the rand() function. This random letter is assigned to a new array called shuffled, whose index is incremented serially. Each time we select a letter from the array sting, we set the flag of the corresponding index to inform that the character at that index has been shuffled.
The above steps have been implemented in the following loop.

Once we have finished the above loop, there are chances that some characters might have been missed out as the characters were generated randomly. To account for this we loop over the array string again, but serially this time and check the flag corresponding to each index. If any of the flag is not set, we append that letter to the end of shuffled array.
This is done using the following loop.

Now that we have our shuffled word ready we will present it to the user, and ask the user to enter the answer.
The answer entered by the user is comapred with the original word, if its the correct answer then we increment the score and ask the user if he/she wants to continue playing. If the user enter the wrong answer the we ask the user to try again. If the user does not want to try again we will show the correct answer and continue to the next word.

set_level: This routine is for setting the level, it has three options of level
Easy, Medium and Hard. Depending on the selection, the variable level is set which is used in the randomize routine to set the number of letters.

set_file: The default file used to look for words is /usr/share/dict/words. In case we want to use some other file we can use this routine. We can enter the full path to the file which will be set to the variable "file".
We also have to set the variable "max" to the number of words in the file, which is done by looping over the file and incrementing a count on every word.
The file that we use should have only one word per line as we count one line a one word in the program.

Main menu :

print " Press: 1 to begin the game : Will call the randomize routine
2 to know about the game : Will give information about how to play and set levels etc
3 to select level : Will allow you to change the level by calling set_level routine.
4 to change the input file : Will allow you to change the input file using set_file.
5 to quit : Will exit the game.
Here is the full script, it has been tested on perl version 5.10 on linux.It might work in windows too but has not been tried.

Anagram.pl

#!/bin/perl

#A game of anagarms, that is words are presented with their letters jumbled. you have to find the correct word.
# Written in perl, it by default uses the words in "/usr/share/dict/words", in case you want to use other set of
# words you can do so by selecting the set input file option.

use strict;
use warnings;

my $score = 0;
my $level = 7;
my $file = "/usr/share/dict/words";
my $max = 74000;
my $attempts = 0;
sub randomize {

my $random;
my $count = 0;

$random = int(rand($max));
#print $random;

open FILE ,"<",$file || die;     
while(<FILE>) {
# print $_;
$count = $count + 1;

if($count == $random) {
    
    if((!($_ =~ /^[A-Z]/)) && index($_,"\'") == -1 && length($_) <= $level) {
#    print "\n word $_";
    my $question = $_;
   
#    print "\n word: $question";
    my @string = split(//,$_) ; #converting string to array
    my @shuffled;
    my @flags;
    my $str_len = length($_);
#    print "Length = $str_len";
    my $i=0;
    my $j=0;
    for($i=0;$i<($str_len);$i++){
        $flags[$i] = 0;    # Intializing flags
        }
# This for loop shuffles the characters of the string.
#The shuffling is done by picking characters by random index
# numbers. The flags array is used to keep track of characters
# shuffled.
    for($i=0;$i<($str_len);$i++) {
   
    my $rand=int(rand($str_len-1));

if($flags[$rand] != 1 ) {
            $flags[$rand] = 1;
            $shuffled[$j++] = $string[$rand];

}   
        }
#In case some characters were missed out in the above loop,
# This loop will fill them up. The flags is checked to find out
# which characters were left out.
    for($i=0;$i<($str_len);$i++) {
        if($flags[$i] != 1) {
            $flags[$i] = 1;
            $shuffled[$j++] = $string[$i];
            }
        }
    my $shuf = join("",@shuffled);
    chomp($question);
    print "Word :  $shuf";
    my $done = 'y';
# While loop to run as long as user wants to keep trying.
    while($done ne 'n') {
        my $ans;
        print "Answer :  ";
        chomp($ans = <STDIN>);
        if($ans eq $question) {
            print "\n********Correct********\n";
            $done = 'n';
            $score++;
            }

else{
            print "\n*********Wrong********\n";
            print "\nDo you want to try again y/n\n";
            chomp($done = <STDIN>);
            if($done eq 'n') {
                print "\nCorrect answer is $question\n";
               
                }
            else {
                print "Word : \n $shuf";
            }
            }
     
    }
    last;   
}
    else {

$random = int(rand($max));
        $count=0;
        seek(FILE,0,0);
        next;       
        }
    }   
}
close(FILE);
}

sub set_level {
print " Selct Level: Press
    1. For Easy
    2. For Medium
    3. Hard
    ";
my $selected;
chomp($selected = <STDIN>);

if($selected == 1) {
$level=5;
}
elsif($selected == 2) {
$level = 7;
}
elsif($selected == 3) {
$level = 10;
}
else {
print "Wrong Choice";
}

}

sub set_file {
print "Enter the full path to the input file containg words for the puzzle. \n
    Please make sure there is only one word per line \n";
chomp($file = <STDIN>);
open FILE , "<" . $file || die;
my $num_words=0;
while(<FILE>) {
$num_words++;
}
$max = $num_words;
print $file;
close(FILE);
}

print "\n"x1000;
print "******************************\n" ;
print "* Welcome to the game of anagrams *\n" ;
print "******************************\n" ;

my $choice;
while(1) {
print " Press:
    1 to begin the game
    2 to know about the game
    3 to select level
    4 to change the input file
    5 to quit
    " ;

chomp ($choice = <STDIN>);

if( $choice == 1){
       
        print "\nwelcome the default level is medium \n";
        my $play = 'y';
        while($play eq 'y') {
        $attempts++;
        randomize();
        print "\n score = $score \n ";
        print "\n next word y/n ?\n";
        chomp($play = <STDIN>);
    }
}
elsif($choice == 2) {

print "\n You will be presented with words with their letters jumbled up, you will have to find out the correct word \n";
print "\n You can set the level by selecting the select level option in the main menu \n";
print "\n By default the game uses /usr/share/dict/words for its words, you can use your own set of words by putting them into a file and using the change input file from main menu.\n"
}

elsif($choice == 3) {
set_level();
}
elsif($choice == 4) {
set_file();
}

elsif($choice == 5) {

print "\n Thank you for playing your score was $score out of $attempts \n" ;
print " **************************************\n \n";

exit;
}
}

Sample output

Hope you have fun... feel free to give any kind of feedback. :-)

Linux World

Pages

Game of anagrams using perl

No comments:

Post a Comment