Hunter4Dev - As Simple As Possible

Add dynamic content using Expression Tags in JSP

2010-03-15T14:05:00.003+05:30

Its same as in fairy tales, once upon a time there where static pages ruling the web. And now, everyone is wishing to have content to be present according to the situation. Everything is live now. Dynamic content is what everyone wishes to see.

JSP pages are one which allow one to embed Java code to HTML. This is where we take advantage in creating dynamic content.

Expression Tag

You need to embed your Java expressions in between <%= and %>

whatever is given in between, it is evaluated at run time.

Following is an example program…

     <html>

        <head>        

            <title>JSP 1. Expression Tags</title>

        </head>

        <body>

            <div align="center">

            <h3>Current Time:</h3>

            <%= new java.util.Date() %>  <br/>

            <h4>Refresh the page to update the time !!!</h4>

            </div>

        </body>

    </html>

Above code displays current time as and when page is refreshed.

So, now just search for reasons where you need to have dynamic content, like content is dependent on the users previous actions and etc..,

Observer Pattern | Advantage of it along with example

2010-01-26T08:19:00.002+05:30

Well to be frank about his; I’m a newbie who doesn’t know about Design Patterns. I just came across this today while I was coding and one of my associates helped me with this pattern.

This example might be simple and even idiotic for those pro’s who are swimming in the Java world. This is for those beginners who need to know the spark in this concept ;)

One might think differently after going through this…. trust me… even if you don’t understand :P

Well I found info about this pattern over here, but I just took conceptual part from it.

Simply, the Observer pattern allows one object (the observer) to watch another (the subject). The Observer pattern allows the subject and observer to form a publish-subscribe relationship. Through the Observer pattern, observers can register to receive events from the subject. When the subject needs to inform its observers of an event, it simply sends the event to each observer.
For example, you might have a spreadsheet that has an underlying data model. Whenever the data model changes, the spreadsheet will need to update the spreadsheet screen and an embedded graph. In this example, the subject is the data model and the observers are the screen and graph. When the observers receive notification that the model has changes, they can update themselves.

This is what it had to say… ;)

Just another way,

Suppose you wanted the Panel to tell the frame to display a message box when a button has been pressed, the Panel will have to hold a reference to the frame class somewhere and then in its code call a method of the frame class when the button has been pressed. So now you have the frame holding a reference to the panel and a panel holding a reference to the frame which == tight coupling, which is a bad thing and can make it hard to debug or extend your program.

I think you got it…. If not comment it down…. :D

So, Let’s talk about business…

I will post regarding Anonymous classes ASAP…

This is a simple application which changes text of button in another panel. Text on button in second panel changes if an event occurs in first panel and vice versa.

Following is the code which explains this….

Main.java

package MyOwnListener;/** * @author HUNTER * hunter4coding.blogspot.com */ public class Main { public static void main(String[] args) {new MightyFrame().setVisible(true);}}

MightyFrame.java

package MyOwnListener; import java.awt.BorderLayout;import javax.swing.*;/** * @author HUNTER * hunter4coding.blogspot.com */ public class MightyFrame extends JFrame{ firstPanel firstSoldier = new firstPanel();SecondPanel secondSoldier = new SecondPanel(); public MightyFrame(){ this.getContentPane().add(BorderLayout.NORTH, firstSoldier);this.getContentPane().add(BorderLayout.CENTER, secondSoldier);this.pack();this.setLocation(300,200);this.setDefaultCloseOperation(EXIT_ON_CLOSE);this.setResizable(false); firstSoldier.addLordListener(new LordListener(){ public void playWithMe(String text) {// You might want to share the resources // of the panel here in frame//JOptionPane.showMessageDialog(MightyFrame.this, text); if(secondSoldier.btnTwo.getText().equals("NO"))secondSoldier.btnTwo.setText("YES");elsesecondSoldier.btnTwo.setText("NO"); }});         secondSoldier.addLordListener(new LordListener(){ public void playWithMe(String text) {//JOptionPane.showMessageDialog(MightyFrame.this, text);if(firstSoldier.btnOne.getText().equals("NO"))firstSoldier.btnOne.setText("YES");elsefirstSoldier.btnOne.setText("NO");}});}}

firstPanel.java

package MyOwnListener; import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import javax.swing.*;/** * @author HUNTER * hunter4coding.blogspot.com */  public class firstPanel extends JPanel{ JButton btnOne = new JButton("Yes");public firstPanel(){ this.add(btnOne);         // Adding ActionListener to 'btnOne'btnOne.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e) {littleTestOne();}});} // Panel event occurs hereprivate void littleTestOne(){        this.listener.playWithMe("U CLICKED " + btnOne.getText());} private LordListener listener; public void addLordListener(LordListener listening){this.listener = listening;}}

secondPanel.java

package MyOwnListener; import java.awt.event.*;import javax.swing.*;/** * @author HUNTER  * hunter4coding.blogspot.com */ public class SecondPanel extends JPanel{ JButton btnTwo = new JButton("NO"); public SecondPanel(){ // Adding ActionListener to 'btnTwo'btnTwo.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e) {littleTestTwo();}}); this.add(btnTwo);} // Panel event occurs hereprivate void littleTestTwo(){this.listener.playWithMe("U CLICKED " + btnTwo.getText());} private LordListener listener; public void addLordListener(LordListener listening){this.listener = listening;} }

LordListener.java

package MyOwnListener;/** * @author HUNTER  * hunter4coding.blogspot.com */ public interface LordListener {public void playWithMe(String text);}

Adding, Removing and Changing Components in Panel | Java Swing

2010-01-18T20:07:00.001+05:30

Recently I faced this problem of changing the components of the panel I’m using. I found this solution and thought of sharing it.

Following is the code…

Main.java

   1: package changepanel;   2:     3: /**   4:  * @author HUNTER4U AKA SRIHARSHA   5:  * http://hunter4coding.blogspot.com/   6:  */   7: public class Main {   8:     9:     public static void main(String[] args) {  10:         new TestFrame().setVisible(true);  11:     }  12: }

TestFrame.java

   1: package changepanel;   2:     3: /**   4:  * @author HUNTER4U AKA SRIHARSHA   5:  * http://hunter4coding.blogspot.com/   6:  */   7: import java.awt.BorderLayout;   8: import javax.swing.JFrame;   9: import java.awt.event.ActionEvent;  10: import java.awt.event.ActionListener;  11:    12: public class TestFrame extends JFrame{  13:    14:     FirstPanel firstPanel = new FirstPanel();  15:     SecondPanel secondPanel = new SecondPanel();  16:    17:     public TestFrame(){  18:    19:         this.getContentPane().add(BorderLayout.NORTH, firstPanel);  20:         this.getContentPane().add(BorderLayout.CENTER, secondPanel);  21:    22:         this.setSize(250, 150);  23:         this.setLocation(250, 250);  24:         this.setDefaultCloseOperation(EXIT_ON_CLOSE);  25:         this.setResizable(false);  26:    27:         firstPanel.btnFirst.addActionListener(new BtnListener());  28:     }  29:    30:    31:     class BtnListener implements ActionListener{  32:    33:         public void actionPerformed(ActionEvent e) {  34:    35:             // REMOVE ALL THE COMPONENTS  36:             //secondPanel.removeAll();  37:    38:             // REMOVE RESPECTIVE COMPONENT  39:             secondPanel.remove(secondPanel.btnSecond);  40:             // BOTH WILL WORK HERE !!!  41:    42:             // ADD THE NEW COMPONENT  43:             secondPanel.add(secondPanel.lblMsg);  44:    45:             // THIS IS INTRESTING PART...  46:             secondPanel.revalidate();  47:             secondPanel.repaint();  48:         }  49:     }  50: }

FirstPanel.java

   1: package changepanel;   2:     3: /**   4:  * @author HUNTER4U AKA SRIHARSHA   5:  * http://hunter4coding.blogspot.com/   6:  */   7: import javax.swing.JButton;   8: import javax.swing.JPanel;   9:    10: public class FirstPanel extends JPanel{  11:    12:     JButton btnFirst = new JButton("Click me");  13:    14:     public FirstPanel(){  15:         this.add(btnFirst);  16:     }  17: }

SecondPanel.java

   1: package changepanel;   2:     3: /**   4:  * @author HUNTER4U AKA SRIHARSHA   5:  * http://hunter4coding.blogspot.com/   6:  */   7: import javax.swing.JButton;   8: import javax.swing.JLabel;   9: import javax.swing.JPanel;  10:    11: public class SecondPanel extends JPanel{  12:    13:     JButton btnSecond = new JButton("I'll Vanish !!!");  14:     JLabel lblMsg = new JLabel("I ate ur BUTTON :P");  15:    16:     public SecondPanel(){  17:         this.add(btnSecond);  18:     }  19: }

Well following is the explanation for revalidate() and repaint() I read while browsing the web.

invalidate()/validate()/revalidate() only affects the layout. It results in a repaint if the layout actually changes.

invalidate()/validate() is the mechanism for batching changes (like beginPaint, paint, paint, paint, endPaint of windowing SDKs). You mark, using invalidate(), all the components that might affect the layout as invalid. Then call the parent container's validate() method. In the validate() method the parent checks if at least one of its immediate children is invalid. If it finds a child marked invalid, it calls layoutComponents() on its layout manager.

If the layoutmanager actually re-lays out the children, then, as a side effect, repaint() will get called.

The thing to note here is that the Container only looks for invalid immediate children.

For precisely this reason sometimes the resulting layout is not what you expected as the parent's parent and children's chidren may not get re-layed out. To work around this issue Swing added the revalidate() method.

What revalidate() does is basically marks all the container upto the top level (window and its subclasses or applet) as invalid. Then it calls validate() on the top level.

Hope it helped you ;)

Shuffle Game In Java

2010-01-14T08:25:00.001+05:30

Description:

You need to arrange the tiles with respect to their numbers from 1 to 15. Empty space should be at last place. Use the “New Game” start a fresh game anytime. “Refresh Game” will help you to reset the board to the initial status of the present game.

Java Source Code for shuffle Game:

Following are the classes used to develop this game.

Main
GameFrame
OptionsPanel
TilesPanel
TileNumber
RandomNumber
ArrowKeyAction

Download Java Files

Need the game directly !!! Download Game

Please report bugs, if any :D and needed enhancements through comments.

Detailed description of code will be updated ASAP.

Using Math.random() with ArrayLists | ArrayList Vs Array

2010-01-03T16:23:00.001+05:30

Math.random() is used to generate random numbers between a specified range.

   1: int rand = (int)(Math.random() * 5);

Here rand can be anything between 0 to 4.
But one faces the problem when he has to collect random numbers in a set without repetition. Using Arrays is one of the ways to deal this situation. But then, every time a random number is generated, one need to check the whole array if it was initially picked up or not, which includes lots of complexity.
So picking the concept of ArrayList to deal this case is a better choice. ArrayList has a great property of removing the contents its holding even if they are in between many other members. It’s something like one leaving the human chain. Automatically rest of the chain is joined.

1 ----- 2 ----- 3 ----- 4 ----- 5 ----- 6 ----- 7 ----- 8 ----- 9 ----- 10

Here, if one needs 6 to run towards barn to save the cattle , we just send him away and rest of the farmers join their hands to fight against the landlords.

1 ----- 2 ----- 3 ----- 4 ----- 5 ----- 7 ----- 8 ----- 9 ----- 10

Now one can use this idea for generating random numbers in a set without repetition.
Well I wrote a simple code for Housie game in which one has to generate random numbers between 1 and 100.

I created objects which indeed hold values, in this case numbers from 1 to 100. Go through the following codes.

This is Main.java

package housie;   2: import java.util.ArrayList;   3:     4: public class Main {   5:     public static void main(String[] args) {   6:     7:         ArrayList<HousieNumber> board=new ArrayList<HousieNumber>();   8:         int i;   9:
        for(i=0;i<100;i++){ // Inserting 100 numbers on the board  11:    12:             board.add(i, new HousieNumber()); // Creating an object  13:    14:             board.get(i).SetValue(i+1);    15:                         // Now each object has its own value
            //for the instance variable 'numb'  17:         }  18:    19:         int rand;  20:         int drawnNumb;  21:    22:         while(board.size()!=0){  23:    24:             // Random number is generated within the range of   25:             //0 to size of ArrayList  26:             rand = (int)(Math.random() * board.size());  27:    28:             // Value of the corresponding object found   29:             //at index number od 'rand'  30:             drawnNumb = board.get(rand).GetValue();  31:    32:        System.out.println("Currenlt drawn number is: " + drawnNumb);  33:    34:                  // Removing the object at the index, 'rand'
            board.remove(rand);  36:         }  37:     }  38: }

This is HousieNumber.java

   1: package housie;   2:     3: public class HousieNumber {   4:     5:      private int numb;   6:     7:     public void SetValue(int number){   8:         this.numb=number;   9:     }  10:    11:     public int GetValue(){  12:         return this.numb;  13:     }  14: }

ZOOMING OUT TO MAKE LIFE SIMPLER

2009-12-30T18:52:00.002+05:30

This tutorial is just an introduction to make one to think about solving the problem, rather than scratching head for program code directly. My further posts will directly deal with ‘c’ codes.

It is obvious that everyone faces problems in their stages of programming. Each and every puzzle or problems, given are compared by the level of hardness, which actually makes their life miserable.

It is not the programming language that one should go after, but it is the logic that they should strive for.

But then, acquiring the logic from the hidden worlds of brain is not so easy.
So let’s try to make programming life simpler by this short tutorial.

1+3+5+7+9+ ------------------

Now this is not just It is not t a simple “series” which I kept in front of you. Let’s see this as a programmable problem.

This program is no different from our daily life. It is just doing a “work” again and again.

Note:
Every program has a pattern which when revealed, opens the portal of success.
And so, we have to try to find the pattern in this problem.

1+3+5+7+9+--------

Other than 1, every element obtained here has a reason i.e., “2” is added to get the new term or element.

Hence, we get the pattern now

1st term: 1
2nd term: 2
3rd term: 3

Let ‘n’ be the number of the term in the series.

So, n=1 --> 1
n=2 --> 3
n=3 --> 5

Now we need to search for the logic which solves the above scenario.
And it would be (2n-1)

As I said earlier, we have not just solved a series but actually saw how a how a simple problem can be represented through a pattern.

And now, we will pass on to the main section of viewing the problem from the view of program.

1+1+3+4+5+7+7+-----------------

After solving the first problem, it is natural to search for a particular pattern for all the terms in this problem also.

But it is a bit different case in finding the pattern here.
Observe that the given problem comprises of two series.

1+3+5+7+-------
1+4+7+10+--------

A program or problem may deal with many sub problems. So we need to divide them initially. And final solution would appear on joining these sections.

Hence, (2n-1) + (3n-2) is final solution.
And so we saw that a hidden pattern(chunks of modules !) solves the whole logic and a problem with many sub problems have to be divided first.

TIC TAC TOE - 'C' code and Algorithm - Part 2

2009-12-30T18:50:00.001+05:30

If you missed the earlier part, please go through following link

Tic Tac Toe - Part 1

Let’s just recollect what we have been through...

(1) We took position as input from user.
(2) Validated the position to be in the range of 1 and 9.
(3) Made sure that the given position is not repeated.
(4) Calculated position for two dimensional array.
(5) And then stored respective value considering the active player.

Now comes the actual part, checking whether particular move of the player made him win or game to draw.

There are many possible ways that a player can win in this game. One can win by making three equal symbols in any of the three rows, or even any of the three columns, or even any of the two diagonals.

So there are totally 8 possible ways that a player can win. If all of these chances are missed, game is said to be draw.

There are two ways in deciding completion of game. One being traversing whole board and finding whether it has any triplet hanging around row or column or even diagonal and second being to spread out from the active position and is its effect on board.
I will go for second way as it’s sensible to work with active position then searching whole board every time.

When a player enters the position, we need to check what effect it has to the board. From the very point it stands, we need to check the possible row, column and diagonal(s).

I have divided the board into three sections. First, three rows come under horizontal section. Second, three columns come under vertical section and finally, two diagonals come under diagonal section.

Let us visualize the situation.....

00 | 01 | 02
10 | 11 | 12
20 | 21 | 22

Following is the map of board. Let’s say that, player 1 chose ‘12’ as his position.

00 | 01 | 02
10 | 11 | 12
20 | 21 | 22

So the possible triplets which may make him win are (10, 11 and 12) and (02, 12 and 22)

I will go for another example....

This time player 2 chose 11 as his position, so the possible winning triplets are...

00 | 01 | 02
10 | 11 | 12
20 | 21 | 22

2nd row ---- (10, 11 and 12)

2nd column ---- (01, 11 and 21)

Diagonal ---- (00, 11 and 22) and

Cross diagonal ---- (02, 11 and 20)

Position we have in hand is 11. So we will traverse the row it stands in. Turn left from 11 to go to 10, but you will end up with two terms only, to compare.

And it’s same with other case too, when you take right turn and go to 12.

Now we’ll try vertical/column. Go up and meet 01 or greet 21 turning down from 11.

One would feel happy if he gets a position on the border of board as he can traverse in a single direction picking the three stones for comparison.

And the answer is just crouching in the corner. Try to make the given position friendlier so that you can easily play with it.

Note:
There might be different cases in front you; out of which some are so easy to solve and rest of them ask you to commit suicide. In that case, try to bring those evil cases to the range where you can easily solve them. And if you fail to do so, break the problem into sub sections and solve them individually.

So in this case, we will be so happy if the user enters a border position as we can just run in a direction comparing the three terms.v
Now, 11 is the demon in our hand. We need to mask this position in such a way that it represents a border term.

First thing is first; you need to agree with me that comparing the three terms in any order is same. Isn’t that right?

In the case of horizontal or row checking, we can start the comparison from the first element of the row. So I will try to mask the 11 term to 10; which is the position where comparison starts.

Let’s visualize the masked map...

11 ---- 10
12 ---- 10
10 ---- 10

Did you observe the similarity?

Column number is zero in every case. That’s it; we are done with masking the position. Whatever the position is given, just change the column number to zero and start the comparison in that row going three steps right.

Have a gulp of air. Check the position’s map again to clear the fog in mind.

00 | 01 | 02
10 | 11 | 12
20 | 21 | 22

Coming to column checking; just make the row number to zero and traverse towards down.

So we are ready with the blueprint for both row and column checking’s.

Let’s start working....

Row checking:

When one traverses through a row, the value of row remains same and the column itself changes (increments).


int col = 0 , temp, fail = 0;
temp = tac[row][col];

while(col<3)
{
if(tac[row][col]!=temp)
// say that all row elements are not equal...
fail = 1;
else
col++;
}

Initially I made ‘col’ to be zero and throughout this snippet the value of ‘row’ stays constant; saying that we are traversing in same row. ‘temp’ is used to store the value of first term in that row and it is compared with rest of the two elements.

So when the three terms are equal, we come out with ‘fail’ as zero or one when all the three are not equal.

Column Checking:

When one traverses through a column, the value of column remains same and the row itself changes (increments).


int row = 0, temp, fail = 0;
temp=toe[row][col];

while(row<3)
{
if(toe[row][col]!=temp)
fail = 1; // say that all row elements are not equal...
else
row++;
}

So we are done with both row and column checking. The only part left in front of us is the diagonal checking.

Diagonal Checking:

There are two diagonals to be verified. Elements of them being, (00, 11 and 22) and (02, 11 and 20)

Let us consider the first diagonal (00, 11 and 22) initially.

One can observe that the values of both row and column are equal. And so whenever we face a position which has row and column values equal, we should go for the checking of first diagonal.

 
if ( row == col)
{
row=0;
temp=tic[0][0];
count=0;

for ( row=0 ; row<3 ; row++ ) 
if ( tic[row][row] == temp )
count++;

if(count==3)
// Game over
}

Values of the ‘row’ variable in ‘for’ loop are 0, 1 and 2. And so tic[row][row] would be replaced by tic[ 0 ][ 0 ],tic[ 1 ][ 1 ] and tic[ 2 ][ 2 ].

‘count’ variable is used to count the number of same terms. And so if the ‘count’ variable turns 3 after the for loop is completed than it says that all the three terms are equal; which also says that game is over as one of the player has won.
Now we are left with cross diagonal.

When ‘11’ is given as input, our program would directly go and search the first diagonal initially. If it fails, we need to go for next diagonal.

So the only elements left over are 20 and 02.

 
if( ((row == 2)&&(col == 0)) || ((row == 0)&&(col == 2)) )
{
row = 0;
col = 2;
temp=tic[row][row];
count=0;

for (k=1 ; k<=3 ; k++)
{
if ( tic[row][col] == temp )
count++;

row++;
col--;
}

if(count==3)
// Game over
}

In the cross diagonal, positions of the terms are 02, 11 and 20.

Observe that row numbers are increasing and column numbers are decreasing.

Row --- 0, 1 and 2
Column --- 2, 1 and 0

And there are three terms, so I can conclude that, one need to work out three times with twp variables; one increasing and other decreasing.


for (k=1 ; k<=3 ; k++)
{
if ( tic[row][col] == temp )
count++;

row++;
col--;
}

Above code does the same; ‘for’ loop is executed three times and meanwhile the values of both row and column are changed respectively.

This completes the whole program. I will come with final code and explanation of it in the next post.

TIC TAC TOE - 'C' code and Algorithm - Part 1

2009-12-30T18:49:00.002+05:30

TIC TAC TOE

I’m back with a game this time. Well, this might be a huge tutorial, but after this most of the newbie problems will perish. So let’s get started.

Introduction to game:

In a game of Tic Tac Toe, two players take turns making an available cell in a 3X3 grid with their respective tokens (either X or O). When one player has placed three tokens in a horizontal, vertical or diagonal row on the grid, the game is over and that player has won. A draw (No winner) occurs when all the cells on the grid have been filled with tokens and neither player has achieved a win.

Algorithm:

Let’s just note down steps to be covered.

(1) Take input position from player.
(2) Check whether respective player wins with that position.
(3) If not, continue start again from 1st step.

It’s so simple to analyse these things, but there is lot more to do to achieve these steps.

Selecting Data Structure:

We need a data structure to store the values of both the players. We have 9 cells and so we need 9 blocks, to store.

Let’s make this program simple by selecting simple data structure, arrays. So we are now left with two options, single and 2-Dimensional arrays.

I selected 2-dimensional array as I have to traverse through rows and columns (I will make it clear) and diagonals too. I will later try to deal the same cases with single dimensional array.

To learn how to traverse a matrix, please read this post.(I will update this ASAP)

Take input position from player

3X3 grid has 9 cells. So let’s name them from 1 to 9.

This is a two human player game and so we will depend on user itself. System just validates the games.

The input taken from user has to be checked whether it is between 1 and 9.

Let the take input be stored in variable named ‘pos’. And so following will be a simple and clear code to validate it.

     do{
printf(“\n Enter the position: “);
scanf(“%d”,&pos);
}while( (pos<1) || (pos>9) );

Hope that you know the syntax and how a do-while loop works, if not go through following post.(I will update this ASAP)

When the given input, ‘pos’, is not in the prescribed range, loop is executed again and this continues until users enters a value in between 1 and 9.

Until now, we had a candy. Now let’s increase the pace.

It is obvious that we need to see that the validated position is not used earlier.
Isn’t that a new point!!! We shouldn’t take repetitive positions. And so another validation is required to see whether given position has been used earlier or not.
To do so, we need to keep a track of positions which we have used initially. So we need a storage place for positions also (we took one 2-dimensional array for 3X3 grid)

I will consider a single dimensional array of size 9 storing the information whether the particular position has been used or not.

Let us name it ‘position’.

Int position[9];

And I will initially place zero in every element of it, meaning that particular position has not been used.

for(i=0;i<9;i++) position[i]=0;

Now we have to check whether given position, ‘pos’, has been used earlier or not.


if(position[pos-1]==1)
{
Printf(“\n Position is already used”);
fail=1;
}
else
position[pos-1]=1;

We are collecting positions from 1 to 9, but the index of an array starts from 0. So we need to subtract one from the position we got so to go for respective index.

Input range: 1 to 9
Array range: 0 to 8

As said earlier, 0 represents that position has not been used yet and 1 states that it has been used. So the first ‘if’ condition checks whether given position’s respective index’s value is equal to 1, if so, it states that position is already used.

If not, value of the respective position is made 1.

But when the position is already is used, we need to ask the user to enter a new position.


do{
do{
printf(“\n Enter the position: “);
scanf(“%d”,&pos);
}while( (pos<1) || (pos>9) );

fail=0;
if(position[pos-1]==1)
{
Printf(“\n Position is already used”);
fail=1;
}
else
position[pos-1]=1;

}while(fail==1);

Here outer do-while takes care of repetitive positions and inner do-while takes care of validating the position itself. Code executes inside out.

(1) First check whether given position is right or not.
(2) And then check whether given position used earlier or not.

So when we come out of two loops, we will have a totally valid position which user has selected.

As we are done with validating the position, let’s now utilize this position for storing user’s symbol (X or O) in 2-dimensional array. But for that, we need values of row and column.

Following is the map of the user’s position input.

1 | 2 | 3
4 | 5 | 6
7 | 8 | 9

We need to convert this into following 2-d array.

00 | 01 | 02
10 | 11 | 12
20 | 21 | 22

I will consider two variables, ‘row’ and ‘col’, representing rows and columns of the 3X3 matrix.

So, when the user enters 5, we should understand that he wanted row as 1 and col as 1.

Let us find row first and then col.

1 | 2 | 3
4 | 5 | 6
7 | 8 | 9

This is the input map and the map of row will be...

0 | 0 | 0
1 | 1 | 1
2 | 2 | 2

So for set of 1, 2, and 3 you want row value to be 0.

1, 2 and 3 ---- 0
4, 5 and 6 ---- 1
7, 8 and 9 ---- 2

Observe that for every three terms the value we need is changing.

1/3 = 0, as both are of Integer Data types

And so 2/3 =0

But 3/3 =1

This repeats in every set with the last term.

Subtract one from user’s input (pos) and then divide it with three.

(1-1)/3 = 0/3 = 0
(2-1)/3 = 1/3 = 0
(3-1)/3 = 2/3 = 0

So the logic we can conclude here is,

Row = (pos-1)/3

Now let’s switch to ‘col’.

Let us find row first and go for ‘col’ then.

1 | 2 | 3
4 | 5 | 6
7 | 8 | 9

This is the input map and the map of row will be...

0 | 1 | 2
0 | 1 | 2
0 | 1 | 2

So for set of 1, 4, and 7 you want ‘col’ value to be 0.

Forget about the 2nd and 3rd rows.

For the input of 1 you need ‘col’ value to be 0.

For the input of 2 you need ‘col’ value to be 1.

For the input of 3 you need ‘col’ value to be 2.

Isn’t that just obtained by subtracting one from input (pos)?

But we still need to deal with rest two rows. And the logic we are searching should be same to all the inputs we get. So we can conclude that subtracting one from input is not suitable to every input.

But can you deduce other inputs to fit in 1, 2 and 3?

Yes, we can do that. Subtract three from the input, until its greater than three. And finally you get a set of 1, 2 and 3 only.

Observe that 4 and 7 can be deduced to 1 when subtracted by 3.

4 - 3 = 1, which is less than 3, so stop the process.
7 – 3 = 4, which is greater than 3, so continue the process.
4 - 3 = 1, which is less than 3, so stop the process.

This is same with rest of the two sets. What would be the code now?


While (pos>3)
{
Pos=pos – 3 ;
}

It’s a simple code. Whenever the input is greater than 3, we subtract 3 from it.
If the ‘pos’ is less than three, execution comes out of the loop.

So, now we will be left with three possible values 1, 2 and 3. This is what we are waiting for, right?

So, ‘col’ will be one subtracted from these values.

Col = pos – 1;

Now we are done with validating and converting the position to our requirement.
Now we need to assign this particular position to the currently active player. (Player 1 or player 2)

Let us assume that player 1 will play with ‘1’ and player 2 will play with ‘0’, instead of ‘X’ and ‘O’.

So when its player 1 who is playing, we need to assign this particular position the value of ‘1’ and if it’s player 2 we will go for ‘0’.


if ( player==1) 
tic[row][col]=1;
else
tic[row][col]=0;

Where, tic[][] is our main 2 dimensional array representing the 3X3 grid board.
And ‘player’ is the variable for which we need to assign ‘1’ or ‘2’ accordingly between the chances.

So after player 1’s play has been processed (Either he has won or lost) we need to give chance to player 2.


if(player==1)     // Active player is ‘player 1’
player=2;     // Than next chance would be of ‘player 2’
else
player=1;

Part 2:Tic Tac Toe - part 2