Showing posts with label Student Project in java. Show all posts
Showing posts with label Student Project in java. Show all posts

August 07, 2022

Given two non negative integers A and B, returns the number of bits set to 1 in java 8 | interview question

/**
 * Write a function that given two non negative integers A and B, returns the number of bits set to 1 in the binary representation of the number A * B
 */
package com.learning.leetcode;

/**
 * @author Biju perambra blogger
 * IHRD CAS kozhikode
 */
public class SolutionBijuApp {

public int solution(int A, int B) {
int count = 0;
int product = Math.multiplyExact(A, B);
while (product > 0) {
int value = product % 2;
product = product / 2;
if (value == 1)
count++;
}
return count;
}


/**
* @param args
*/
public static void main(String[] args) {

System.out.println(new SolutionBijuApp().solution(3, 7));


}

}


BijuApp on stockmarket
Posted by at No comments:
Labels: , , ,
Location: Mankave, Kozhikode, Kerala, India

July 14, 2022

How to create a textile billing and inventory system using google spreadsheet and google app sheet

Hi 


We have created a textile inventory and billing system for Nijeeshma tailoring athanikkal kozhikode using google app sheet and google spreadsheet. Any one can develop this application with a day or two. No coding required


Please visit our git url


Video

Posted by at No comments:
Labels: , , , , ,
Location: Athanikkal, Kerala, India

July 07, 2022

How to use observable pattern to notify stock market breakouts entry stoploss


Created a stock market application by implementing observable pattern.
In observable pattern the subsribers will be notified when ever there is any event occured in publishers object. In our example stock is the publisher ( Observables) and we kept a list of subscribers list in NotificationManager class.



Stock.java


package com.learning.designpattern.observer;

import java.io.File;
/**
 * Stock class
 * Act as Observable or publisher
 * 
 * Where ever a change happens in Stock object (publisher), it will notifies the subscribers
 * 
 * two methods stoploss() & entry() corresponds to file opening and saving events
 * 
 *
 * 
 * 
 * @author smithesh k k
 *
 */
public class Stock {

private Breakout breakout;
public NotificationManager events;

public Stock() {
this.events = new NotificationManager(); 
}

public void stoploss(String nseTicker) {
if (!nseTicker.isEmpty()) {
this.breakout = new Breakout(nseTicker);
events.notify(Alerts.STOPLOSS.toString(), breakout);
}
}

public void entry(String nseTicker) {
if (!nseTicker.isEmpty()) {
this.breakout = new Breakout(nseTicker);
events.notify(Alerts.ENTRY.toString(), breakout);
}
}

}

NotificationManager.java


/**
 * 
 */
package com.learning.designpattern.observer;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 *  NotificationManager
 *  
 *  keeps the subscriber list ( watchlist), through NotificationManager you can subscribe or unsusbscribe for an event
 *  
 *  notify() helps to notify the subscribers/observer's
 * 
 * 
 * @author bijuvas
 *
 */
public class NotificationManager {

private Map<String, List<EventListener>> watchlist;
public NotificationManager() {
this.watchlist = new HashMap<>();
addEvents();
}
public void notify(String eventType, Breakout file) {
List<EventListener> users = watchlist.get(eventType);
users.forEach(user -> {
user.update(eventType, file);
});
}
public void subscribe(String eventType, EventListener listener) {
List<EventListener> users = watchlist.get(eventType);
users.add(listener);
}
public void unsubscribe(String eventType, EventListener listener) {
List<EventListener> users = watchlist.get(eventType);
users.remove(listener);
}

public void addEvents() {
final Alerts[] alerts = Alerts.values();
for (Alerts event : alerts) {
            this.watchlist.put(event.toString(), new ArrayList<>());
        }
}
}

EventListener.java


/**
 * 
 */
package com.learning.designpattern.observer;

/**
 * EventListener
 * 
 * update()
 * 
 * @author sreekumar
 *
 */
public interface EventListener {
public void update(String eventType, Breakout breakout);
}


EmailNotificationListener.java


/**
 * 
 */
package com.learning.designpattern.observer;

/**
 * EmailNotificationListener
 * 
 * @author perambra kozhikode
 *
 */
public class EmailNotificationListener implements EventListener {
private String email;
public EmailNotificationListener(String email) {
this.email = email;
}

@Override
public void update(String eventType, Breakout breakout) {
System.out.println(" email send to "+email +" for "+eventType);
}

}


MainClass.java


/**
 * 
 */
package com.learning.designpattern.observer;

/**
 * @author valiyakode
 *
 */
public class MainClass {

/**
* @param args
*/
public static void main(String[] args) {
Stock editor = new Stock();
NotificationManager event = editor.events;
event.subscribe(Alerts.STOPLOSS.toString(), new EmailNotificationListener("test@gmail.com"));
editor.stoploss("SGX");
}

}


Breakout.java


/**
 * 
 */
package com.learning.designpattern.observer;

/**
 * @author Zamorins Guruvayoorappan college
 *
 */
public class Breakout{  //implements Strategies{

public Breakout(String nseTicker) {
} 

}


Alerts.java


/**
 * 
 */
package com.learning.designpattern.observer;

/**
 * @author lijesh
 *
 */
public enum Alerts {
TARGET1, ENTRY, TARGET2, STOPLOSS;

}


Full source code


Git url
 
Posted by at No comments:
Labels: , , ,
Location: Perambra, Kerala 673525, India

March 28, 2020

Tic Tac Toe Game developed in java full code play with computer


Main,java



/**
 *
 */
package com.cfed.tiktactoe;

/**
 * @author konzernites
 * @since 1.0
 *
 */
public class Main {

/**
* @param args
* @throws IllegalAccessException
*/
public static void main(String[] args) throws IllegalAccessException {

Matrix<Character> matrix = new Matrix<>(3, 3);

System.out.println(" **** INSTRUCTIONS **** ");
System.out.println(" User has to enter row and column ");
System.out.println(" Postion starts from (0,0) to (2,2) ");

TikTocToe tikTokToe = new TikTocToe(matrix);
tikTokToe.startGame();

System.out.println(" ***** GAME OVER ***** ");
System.out.println(" Developed by consumerfed I T Section ");


}

}

TicTacToe.java

/**
 * Tic Tac Toe 
 * The main class
 * 
 */
package com.cfed.tiktactoe;

import java.util.Scanner;

/**
 * @author konzernites
 * @param <E>
 * @since 1.0
 *
 */
public class TikTocToe {

public static final int MATRIX_SIZE = 3;
public static final int MAX_MOVE = 9;
protected static int moveCount = 1;
public static final char USER_MOVE = 'X';
public static final char COMP_MOVE = 'O';
private ComputerMove computerMove = null;
private Matrix<Character> matrix = null;
public Character winner = null;

public TikTocToe() {
intialize();
}

public TikTocToe(Matrix matrix) {
this.matrix = matrix;
intialize();
}

private void intialize() {
computerMove = new ComputerMove(matrix);
}

private boolean checkWinner() {
if (findWinner() == USER_MOVE) {
return true;
} else if (findWinner() == COMP_MOVE) {
return true;
}
return false;
}

@SuppressWarnings("unused")
private char findWinner() {
Object[][] newMatrix = matrix.getMatrix();
if (moveCount < 5 || moveCount > MAX_MOVE) {
return Matrix.EMPTY_DATA;
} else if (null!= matrix.getValue(0, 0) && (TikTocToe.USER_MOVE == matrix.getValue(0, 0) || TikTocToe.COMP_MOVE == matrix.getValue(0, 0))) {
winner = (Character)matrix.getValue(0, 0);
if ((null!= matrix.getValue(0, 1) && winner.equals(newMatrix[0][1])) && (null!= matrix.getValue(0, 2) && winner.equals(newMatrix[0][2]))) {
return winner;
} else if ((null!= matrix.getValue(0, 1) && winner.equals(newMatrix[1][0])) && (null!= matrix.getValue(2, 0) && winner.equals(newMatrix[2][0]))) {
return winner;
} else if ((null!= matrix.getValue(1, 1) && winner.equals(newMatrix[1][1])) && ( null!= matrix.getValue(2, 2) && winner.equals(newMatrix[2][2]))) {
return winner;
}
} else if (null!= matrix.getValue(1, 1) && (TikTocToe.USER_MOVE == matrix.getValue(1, 1) || TikTocToe.COMP_MOVE == matrix.getValue(1, 1))) {
winner = (Character)newMatrix[1][1];
if ((null!= matrix.getValue(1, 0) && winner.equals(newMatrix[1][0])) && (null!= matrix.getValue(1, 2) && winner.equals(newMatrix[1][2]))) {
return winner;
} else if ((null!= matrix.getValue(0, 0) && winner.equals(newMatrix[0][0])) && (null!= matrix.getValue(1, 2) && winner.equals(newMatrix[1][2]))) {
return winner;
} else if ((null!= matrix.getValue(0, 2) && winner.equals(newMatrix[0][2])) && (null!= matrix.getValue(2, 0) && winner.equals(newMatrix[2][0]))) {
return winner;
}
} else if (null!= matrix.getValue(2, 2) && (TikTocToe.USER_MOVE == matrix.getValue(2, 2) || TikTocToe.COMP_MOVE == matrix.getValue(2, 2))) {
winner = (Character)newMatrix[2][2];
if ((null!= matrix.getValue(2, 0) && winner.equals(newMatrix[2][0])) && (null!= matrix.getValue(2, 1) && winner.equals(newMatrix[2][1]))) {
return winner;
} else if ((null!= matrix.getValue(0, 2) && winner.equals(newMatrix[0][2])) && (null!= matrix.getValue(1, 2) && winner.equals(newMatrix[1][2]))) {
return winner;
}
}
return Matrix.EMPTY_DATA;
}


/**
* @param args
* @throws IllegalAccessException 
*/
public static void main(String[] args) throws IllegalAccessException {
System.out.println(" **** INSTRUCTION **** ");
System.out.println(" User has to enter row and column ");
System.out.println(" Postion starts from (0,0) to (2,2) ");
TikTocToe t = new TikTocToe();
t.startGame();
System.out.println(" **** GAME OVER ***** ");
System.out.println(" Developed by consumerfed I T section kozhikode ");

}
public void startGame() throws IllegalAccessException {
int rowMoved = 0;
int colMoved = 0;
Scanner scanner = new Scanner(System.in);
while (moveCount < MAX_MOVE) {

if (moveCount % 2 == 0) {

matrix = computerMove.computerMove(rowMoved, colMoved);
System.out.println("** COMPUTER MOVE **");
try {
Thread.sleep(3121);
} catch (InterruptedException e) {
e.printStackTrace();
}

} else {

System.out.println("** YOUR MOVE **");
System.out.println(" Enter the row (values from 0 to 2): ");
int row = scanner.nextInt();
validate(row);
System.out.println(" Enter the col (values from 0 to 2): ");
int col = scanner.nextInt();
validate(col);
matrix.add(row, col, USER_MOVE);
rowMoved = row;
colMoved = col;
}
matrix.print();
boolean isWon = checkWinner();
if (isWon) {
System.out.println("*** Congratulation *** ");
System.out.println(winner + " is the winner ");
break;
}
moveCount++;
}
}


Dimensions.java


/**
 * 
 */
package com.cfed.tiktactoe;

/**
 * @author konzernites
 * @since 1.0
 *
 */
public class Dimensions {
private static final long serialVersionUID = 8683452581122892188L;

private int row = 0;
private int column = 0;

public int getRow() {
return row;
}

public void setRow(int row) {
this.row = row;
}

public int getColumn() {
return column;
}

public void setColumn(int column) {
this.column = column;
}

}





private void validate(int value) {
if (value < 0 || value > 2) {
throw new IllegalArgumentException(" This value is not permitted");
}
}




}


Matrix.java


/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * Copyright (c) 1997-2017 Javabelazy and/or its affiliates. All rights reserved.
 *
 */
package com.cfed.tiktactoe;

import java.util.NoSuchElementException;

/**
 * @author konzernites
 * @since 1.0
 *
 */
public class Matrix<E> extends AbstractMatrix<E> {

@SuppressWarnings("unused")
private static final long serialVersionUID = 8683452581122892189L;

private final int MAX_COLUMN;
private final int MAX_ROW;
private final int MAX_CAPACITY;
protected static final char EMPTY_DATA = '\0';
private static boolean isEditable = false;

private E elementData[][];
private int capacity = 0;

public Matrix(int row, int column) {
this.MAX_COLUMN = column;
this.MAX_ROW = row;
this.MAX_CAPACITY = MAX_ROW * MAX_COLUMN;
intialize();
}

@SuppressWarnings("unchecked")
private void intialize() {
this.elementData = (E[][]) new Object[MAX_ROW][MAX_COLUMN];
}

public Matrix() {
this(2, 2);
}

public void add(int row, int column, E value) throws IllegalAccessException {
if (row > MAX_ROW || column > MAX_COLUMN)
throw new IllegalAccessException("Illegal capacity");
else if (isFull() || isElementExist(row, column))
throw new IllegalAccessException("Value already exist");
else {
capacity++;
this.elementData[row][column] = value;
}
}

public E[][] getMatrix() {
if (isEmpty())
throw new NoSuchElementException("Matrix is empty");
else
return this.elementData;
}
public E getValue(int row, int column) {
if (isEmpty())
return null;
else if(isElementExist(row, column)) 
return this.elementData[row][column];
else
return null;
}

public void remove(int row, int column) {
if (isEmpty())
throw new NoSuchElementException("Cannot remove value from an empty matrix");
else {
this.elementData[row][column] = null;
capacity--;
}
}

public void removeAll() {
if (isEmpty())
throw new NoSuchElementException("Cannot remove value from an empty matrix");
else {
// TODO remove all elements from matrix
}
}

public void print() {
if (isEmpty())
throw new NoSuchElementException("Cannot display an empty matrix");
else {
for (int r = 0; r < MAX_ROW; r++) {
for (int c = 0; c < MAX_COLUMN; c++) {
if (null == elementData[r][c])
System.out.print("  | ");
else
System.out.print(elementData[r][c] + " | ");
}
System.out.println("");
}
}
}

public Dimensions dimension() {
Dimensions dimensions = new Dimensions();
dimensions.setRow(MAX_ROW);
dimensions.setColumn(MAX_COLUMN);
return dimensions;
}

private boolean isEmpty() {
if (capacity == 0)
return true;
else
return false;
}

public boolean isElementExist(int row, int column) {
if (isEmpty())
return false;
else if (null != elementData[row][column])
return true;
else
return false;
}

private boolean isFull() {
if (capacity >= MAX_CAPACITY)
return true;
else
return false;
}

public int size() {
return capacity;
}

}

ComputerMove.java


/**
 * Computer Moves for user move in tik toc toe
 * Developed by consumerfed kozhikode I T section
 * Version 1.0 
 * consfedkozhikode@gmail.com
 * 
 */
package com.cfed.tiktactoe;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Random;

/**
 * @author konzernites
 * @since 1.0
 *
 */
public class ComputerMove {

private int MATRIX_SIZE = 3;
private static final char EMPTY_DATA = ' ';
private Map<String, Integer> priorityPosition = null;
private static final String techIssue = "EXPERIENCING SOME TECHNICAL ISSUE";
private Matrix<Character> matrix = null;


public ComputerMove(Matrix<Character> matrix) {
this.matrix = matrix;
}

public Matrix<Character> computerMove(int rowMoved, int colMoved) throws IllegalAccessException {

if (TikTocToe.moveCount <= 2) {
matrix = generateFirstCompMove();
} else {
matrix = generateCompMove(rowMoved, colMoved);
}
return matrix;
}

private Matrix<Character> generateCompMove(int rowMoved, int colMoved) throws IllegalAccessException {
priorityPosition = new HashMap<>();
boolean isInserted = false;
for (int row = 0; row < MATRIX_SIZE; row++) {
for (int col = 0; col < MATRIX_SIZE; col++) {

if (!matrix.isElementExist(row, col)) {
isInserted = findPriority(row, col);
if (isInserted)
return matrix;
}

}
}

if (!isInserted) {
String key = maxUsingCollectionsMaxAndLambda(priorityPosition);
int r = Integer.parseInt(key.substring(0, 1));
int c = Integer.parseInt(key.substring(1, 2));

if (!matrix.isElementExist(r, c))
matrix.add(r, c, TikTocToe.COMP_MOVE);

}
return matrix;
}

private Matrix<Character> generateFirstCompMove() throws IllegalAccessException {
int row = 0;
int col = 0;
if (matrix.getValue(1, 1).equals(EMPTY_DATA)) {
matrix.add(1, 1, TikTocToe.COMP_MOVE);
} else {
Random r = new Random();
row = r.nextInt(3);
col = r.nextInt(3);
col = (row == 1 && col == 1) ? col + 1 : col;
matrix.add(row, col, TikTocToe.COMP_MOVE);
}
return matrix;
}

private boolean findPriority(int row, int col) throws IllegalAccessException {
boolean isInserted = true;
if (diagonalOne(0, 0)) {
isInserted = true;
} else if (diagonalTwo(0, MATRIX_SIZE - 1)) {
isInserted = true;
} else if (rowCheck(row, col)) {
matrix.add(row, col, TikTocToe.COMP_MOVE);
} else if (colCheck(row, col)) {
matrix.add(row, col, TikTocToe.COMP_MOVE);
} else {
isInserted = false;
}
return isInserted;
}

private boolean colCheck(int row, int col) {
boolean isPrior = false;
boolean isSafe = false;
int loopCount = 1;
int value = 0;

int r = row;
int c = col;
while (loopCount < MATRIX_SIZE) {
if (r + 1 == MATRIX_SIZE) {
r = 0;
} else {
r++;
}
if (null != matrix.getValue(r, c) && TikTocToe.COMP_MOVE == matrix.getValue(r, c)) {
isSafe = true;
break;
} else if (null != matrix.getValue(r, c) && TikTocToe.USER_MOVE == matrix.getValue(r, c)) {
value++;
}
loopCount++;
}

if (!isSafe) {
String key = String.valueOf(row + "" + col);
priorityPosition.put(key, value);
}

if (value == 2 && !isSafe) {
isPrior = true;
}
return isPrior;
}

private boolean rowCheck(int row, int col) {
boolean isPrior = false;
boolean isSafe = false;
int loopCount = 1;
int value = 0;

int r = row;
int c = col;
while (loopCount < MATRIX_SIZE) {

c = (c + 1 == MATRIX_SIZE) ? 0 : c + 1;

if (null != matrix.getValue(r, c) && TikTocToe.COMP_MOVE == matrix.getValue(r, c)) {
isSafe = true;
break;
} else if (null != matrix.getValue(r, c) && TikTocToe.USER_MOVE == matrix.getValue(r, c)) {
value++;
}
loopCount++;
}

if (!isSafe) {
String key = String.valueOf(row + "" + col);
priorityPosition.put(key, value);
}

if (value == 2 && !isSafe) {
isPrior = true;
}
return isPrior;
}

private boolean diagonalTwo(int row, int col) throws IllegalAccessException {
boolean isPrior = false;
boolean isSafe = false;
int loopCount = 1;
int value = 0;
int r = 0;
int c = 0;
while (loopCount <= MATRIX_SIZE) {
if (null != matrix.getValue(row, col) && TikTocToe.COMP_MOVE == matrix.getValue(row, col)) {
isSafe = true;
break;
} else if (null != matrix.getValue(row, col) && TikTocToe.USER_MOVE == matrix.getValue(row, col)) {
value++;
}
if (!matrix.isElementExist(row, col)) {
r = row;
c = col;
}
row++;
col--;
loopCount++;
}

if (!isSafe) {
String key = String.valueOf(r + "" + c);
priorityPosition.put(key, value);
}

if (value == 2 && !isSafe) {
matrix.add(r, c, TikTocToe.COMP_MOVE);
isPrior = true;
}
return isPrior;
}

private boolean diagonalOne(int row, int col) throws IllegalAccessException {
boolean isPrior = false;
boolean isSafe = false;
int loopCount = 1;
int value = 0;
int r = 0;
int c = 0;
while (loopCount <= MATRIX_SIZE) {
if (null != matrix.getValue(row, col) && TikTocToe.COMP_MOVE == matrix.getValue(row, col)) {
isSafe = true;
break;
} else if (null != matrix.getValue(row, col) && TikTocToe.USER_MOVE == matrix.getValue(row, col)) {
value++;
}

if (!matrix.isElementExist(row, col)) {
r = row;
c = col;
}
row++;
col++;
loopCount++;
}

if (!isSafe) {
String key = String.valueOf(r + "" + c);
priorityPosition.put(key, value);
}

if (value == 2 && !isSafe) {
matrix.add(r, c, TikTocToe.COMP_MOVE);
isPrior = true;
}
return isPrior;
}

private <K, V extends Comparable<V>> K maxUsingCollectionsMaxAndLambda(Map<K, V> map) {
Entry<K, V> maxEntry = Collections.max(map.entrySet(),
(Entry<K, V> e1, Entry<K, V> e2) -> e1.getValue().compareTo(e2.getValue()));
return maxEntry.getKey();
}

}


Output


 **** INSTRUCTIONS ****
 User has to enter row and column
 Postion starts from (0,0) to (2,2)
** YOUR MOVE **
 Enter the row (values from 0 to 2):
1
 Enter the col (values from 0 to 2):
1
  |   |   |
  | X |   |
  |   |   |
** COMPUTER MOVE **
  |   | O |
  | X |   |
  |   |   |
** YOUR MOVE **
 Enter the row (values from 0 to 2):
2
 Enter the col (values from 0 to 2):
2
  |   | O |
  | X |   |
  |   | X |
** COMPUTER MOVE **
O |   | O |
  | X |   |
  |   | X |
** YOUR MOVE **
 Enter the row (values from 0 to 2):
1
 Enter the col (values from 0 to 2):
2
O |   | O |
  | X | X |
  |   | X |
** COMPUTER MOVE **
O |   | O |
O | X | X |
  |   | X |
** YOUR MOVE **
 Enter the row (values from 0 to 2):
2
 Enter the col (values from 0 to 2):
1
O |   | O |
O | X | X |
  | X | X |
** COMPUTER MOVE **
O | O | O |
O | X | X |
  | X | X |
*** Congratulation ***
O is the winner
 ***** GAME OVER *****
 Developed by consumerfed I T section kozhikode
O | O | O |
O | X | X |
  | X | X | 

Posted by at No comments:
Labels: , , , ,
Location: Belgium

March 07, 2020

Tik tok toe computer game code explained

Tik tok toe code explanation ( game developed in java )


isSpaceEmpty : is a method used to check whether the value of matrix is the specified rows and col is empty or not, If it is not an empty one then it will through an Illegal argument exception.

private boolean isSpaceEmpty(char[][] matrix, int row, int col) {
if (userMove == matrix[row][col] || compMove == matrix[row][col]) {
throw new IllegalArgumentException(techIssue);
}
return true;
}

generateFirstCompMove : The following function will calculate the first move. Computer will chose the centre of the matrix if not empty in other case random position generated.

private char[][] generateFirstCompMove(char[][] matrix) {
int row = 0;
int col = 0;
if (EMPTY == matrix[1][1]) {
matrix[1][1] = compMove;
} else {
Random r = new Random();
row = r.nextInt(3);
col = r.nextInt(3);
col = (row == 1 && col == 1) ? col + 1 : col;
matrix[row][col] = compMove;
}
return matrix;
}



Happy Birthday Madhav my best friend... I miss you a lot



I was greatly inspired by madhav who has developed a paranoid game using C language when he was in higher secondary. It was year 2001 if i remember correctly, in that days computer in home where rare, study materials was not much abundantly available as now. So i dedicate this code for him.







Tic Tac Toe Game developed in java full code play with computer , coming soon...


Posted by at No comments:
Labels: , , ,
Location: Mumbai, Maharashtra, India

January 14, 2020

Tik Tac Toe Game with computer java code games


Tic Tac Toe algorithm and source code in Java


Developed a computer algorithm that play with user in Tik Tac Toe Game..




User Move and Computer moves are distinguished by characters X and O ( upper case)



** YOUR MOVE **
 Enter the row:
0
 Enter the col:
0
X |   |   |
  |   |   |
  |   |   |
** COMPUTER MOVE **
X |   |   |
  | O |   |
  |   |   |
** YOUR MOVE **
 Enter the row:
0
 Enter the col:
1
X | X |   |
  | O |   |
  |   |   |
** COMPUTER MOVE **
X | X | O |
  | O |   |
  |   |   |
** YOUR MOVE **
 Enter the row:
2
 Enter the col:
0
X | X | O |
  | O |   |
X |   |   |
** COMPUTER MOVE **
X | X | O |
O | O |   |
X |   |   |
** YOUR MOVE **
 Enter the row:
2
 Enter the col:
2
X | X | O |
O | O |   |
X |   | X |
** COMPUTER MOVE **
X | X | O |
O | O |   |
X | O | X |

 Developed by consumerfed I T section kozhikode ( 26608629 )

Previous >> Tic Tac Toe prototype developed
Next >> Tic Tac Toe the matrix code

Complete source code will be posted soon (38064021)

Buy any amazon product from here


Posted by at No comments:
Labels: , , ,
Location: Dindigul, Tamil Nadu 624001, India

January 07, 2020

Tic Toc Toe Prototype developed in java

Developing Games using Java Programming

package com.konzern.games;

import java.util.Scanner;

/**
 *  Tic Toc Toe Prototype developed in java
 *  Thanks to Steffi Thomas
 */

/**
 * @author consumerfed IT Section
 *
 */
public class TikTokToe {

private int MATRIX_SIZE = 3;
private char[][] matrix = { { ' ', ' ', ' ' }, { ' ', ' ', ' ' }, { ' ', ' ', ' ' } };
private int moveCount = 0;

public TikTokToe() {
intialize();
}

private void intialize() {
}

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
char[][] matrix = { { 'x', 'o', 'x' }, { 'x', ' ', ' ' }, { 'o', 'x', 'x' } };
TikTokToe t = new TikTokToe();
t.startGame();
// boolean isWin = t.checkWinner(matrix, 'x');
// t.printMatrix();
System.out.println(" Developed by consumerfed I T section kozhikode ");

}

private void startGame() {
// TODO Auto-generated method stub
char move = 'x';
Scanner scanner = new Scanner(System.in);
while (moveCount < 9) {
System.out.println("** MOVE FOR " + move + " **");
System.out.println(" Enter the row:");
int row = scanner.nextInt();
System.out.println(" Enter the col:");
int col = scanner.nextInt();
matrix[row][col] = move;
printMatrix();
boolean winner = checkWinner(matrix, move);
if (winner) {
System.out.println("*** Congratulation *** ");
System.out.println(move + " is the winner ");
break;
}
move = ('x' == move) ? 'o' : 'x';
}

}

private void printMatrix() {
// TODO Auto-generated method stub

for (int row = 0; row < MATRIX_SIZE; row++) {
for (int col = 0; col < MATRIX_SIZE; col++) {
System.out.print(matrix[row][col] + " | ");
}
System.out.println("");
}

}

private void checkWinner() {
// TODO Auto-generated method stub

}

private boolean checkWinner(char[][] matrix, char move) {

if (move == matrix[0][0] && move == matrix[0][1] && move == matrix[0][2]) {
return true;
} else if (move == matrix[1][0] && move == matrix[1][1] && move == matrix[1][2]) {
return true;
} else if (move == matrix[2][0] && move == matrix[2][1] && move == matrix[2][2]) {
return true;
} else if (move == matrix[0][0] && move == matrix[1][0] && move == matrix[2][0]) {
return true;
} else if (move == matrix[0][1] && move == matrix[1][1] && move == matrix[2][1]) {
return true;
} else if (move == matrix[0][2] && move == matrix[1][2] && move == matrix[2][2]) {
return true;
} else if (move == matrix[0][0] && move == matrix[1][1] && move == matrix[2][2]) {
return true;
} else if (move == matrix[0][2] && move == matrix[1][1] && move == matrix[2][0]) {
return true;
} else {
return false;
}
// return false;
}
}


Output


** MOVE FOR x **
 Enter the row:
0
 Enter the col:
0
x |   |   | 
  |   |   | 
  |   |   | 
** MOVE FOR o **
 Enter the row:
1
 Enter the col:
1
x |   |   | 
  | o |   | 
  |   |   | 
** MOVE FOR x **
 Enter the row:
1
 Enter the col:
0
x |   |   | 
x | o |   | 
  |   |   | 
** MOVE FOR o **
 Enter the row:
2
 Enter the col:
2
x |   |   | 
x | o |   | 
  |   | o | 
** MOVE FOR x **
 Enter the row:
2
 Enter the col:
0
x |   |   | 
x | o |   | 
x |   | o | 


x is the winner 

Suggested Books


Posted by at No comments:
Labels: ,

July 07, 2019

Artificial intelligence robot in java a prototype

Artificial intelligence robot in java a prototype




/**
 * @author Consumerfed I T Section
 *
 */
public class MainClass {

/**
* @param args
*/
public static void main(String[] args) {

}

}

/**
 *
 */
package com.consumerfed.airobo.model;

import com.consumerfed.airobo.utilities.RoboMessages;

/**
 * @author Conumerfed I T Section
 *
 */
public class AIRobot {

private boolean alert = false;

private RoboMessages message = null;

private float batteryStatus = 0;

private float weightCarried = 0;

private float distanceCovered = 0;

public float getBatteryStatus() {
return batteryStatus;
}

public void setBatteryStatus(float batteryStatus) {
this.batteryStatus = batteryStatus;
}

public RoboMessages getMessage() {
if (null == message) {
message = RoboMessages.NILL;
}
return message;
}

public void setMessage(RoboMessages message) {
this.message = message;
}

public float getWeightCarried() {
return weightCarried;
}

public void setWeightCarried(float weightCarried) {
this.weightCarried = weightCarried;
}

public boolean isAlert() {
return alert;
}

public void setAlert(boolean alert) {
this.alert = alert;
}

public float getDistanceCovered() {
return distanceCovered;
}

public void setDistanceCovered(float distanceCovered) {
this.distanceCovered = distanceCovered;
}

}

package consumerfed.xebia.airobo.model;
/**
 * @author Conumerfed I T Section
 *
 */
public class Barcode {
private String code = null;
private byte[] img = null;
private double price = 0;

public byte[] getImg() {
return img;
}

public void setImg(byte[] img) {
this.img = img;
}

public String getCode() {
return "ISBN 8281808025";
}

public double getPrice() {
return 120.75;
}

}



package com.Consumerfed.airobo.service;

import com.Consumerfed.airobo.model.AIRobot;
import com.Consumerfed.airobo.model.Barcode;
import com.Consumerfed.airobo.utilities.AIRobotUtilities;
import com.Consumerfed.airobo.utilities.RoboMessages;

/**
 * @author Consumerfed
 *
 */
public class AIRobotService implements AIRobotServiceInf, Scanning {

private AIRobot robot = null;

public AIRobotService(AIRobot robot) {
this.robot = robot;
}

@Override
public float walk(float kilometer) {
if (loadWeight(robot.getWeightCarried()) && checkBatteryStatus() && checkMaxDistance(kilometer)) {
if(isChargeExist(kilometer)) {
batteryConsumption(kilometer, robot.getWeightCarried());
float distanceCovered = robot.getDistanceCovered();
robot.setDistanceCovered(kilometer+ distanceCovered);
}
}
checkBatteryStatus();
display();
return robot.getBatteryStatus();
}

private boolean isChargeExist(float kilometer) {
boolean isChargeExistForMove = false;
float weight = robot.getWeightCarried();
float extraChargeConsumed = weight * AIRobotUtilities.EXTRA_REDUCE_PKM_WGT;
float chargeConsume = kilometer * (AIRobotUtilities.BATTERY_CONSUMPTION_PKM + extraChargeConsumed);
float charge = robot.getBatteryStatus();
if((charge)>= chargeConsume) {
isChargeExistForMove = true;
}
return isChargeExistForMove;
}

private void batteryConsumption(float kilometer, float weight) {
float charge = robot.getBatteryStatus();
float extraChargeConsumed = weight * AIRobotUtilities.EXTRA_REDUCE_PKM_WGT;
float chargeConsumed = kilometer * (AIRobotUtilities.BATTERY_CONSUMPTION_PKM + extraChargeConsumed);
float remainingCharge = charge - chargeConsumed;
robot.setBatteryStatus(remainingCharge < 0 ? 0 : remainingCharge);
}

@Override
public float walkWithWeight(float kilometer, float kilogram) {
if (loadWeight(kilogram))
walk(kilometer);
return robot.getBatteryStatus();
}

@Override
public boolean loadWeight(float kilogram) {
float weightCarried = robot.getWeightCarried();
float totalWeight = weightCarried + kilogram;
boolean isNormalWeight = true;
if (totalWeight > 10) {
robot.setMessage(RoboMessages.OVERWEIGHT);
isNormalWeight = false;
}
robot.setWeightCarried(totalWeight);
return isNormalWeight;
}

@Override
public void chargeBattery() {
if (robot.getBatteryStatus() == 100) {
robot.setMessage(RoboMessages.FULL_CHARGE);
robot.setAlert(false);
display();
} else {
System.out.println(" Battery charging..");
try {
Thread.sleep(2512);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(" Fully charged ");
}
robot.setDistanceCovered(0);
robot.setBatteryStatus(100);
}

@Override
public void removeLoad() {
if (robot.getWeightCarried() == 0) {
robot.setMessage(RoboMessages.EMPTY_LOAD);
robot.setAlert(false);
display();
}
robot.setWeightCarried(0);
}

private boolean checkBatteryStatus() {
float batteryCharge = robot.getBatteryStatus();
if (batteryCharge == 0) {
robot.setMessage(RoboMessages.EMPTY_BATTERY);
robot.setAlert(true);
return false;

} else if (batteryCharge < 15) {
robot.setMessage(RoboMessages.RESEVE_BATTERY);
robot.setAlert(true);
return false;
}
return true;
}

private boolean checkMaxDistance(float kilometer) {
if (calcMaxMilege(kilometer) < kilometer) {
robot.setMessage(RoboMessages.MAX_DISTANCE_EXCEED);
return false;
}
return true;
}

private float calcMaxMilege(float kilometer) {
float weight = robot.getWeightCarried();
float maxMilege = 100
/ (AIRobotUtilities.BATTERY_CONSUMPTION_PKM + (AIRobotUtilities.EXTRA_REDUCE_PKM_WGT * weight));
return maxMilege;
}

private void display() {
System.out.println("Light on Robot head : \t" + (robot.isAlert() ? "Red" : " "));
System.out.println("Led display on Robot chest : \t" + robot.getMessage().getMessage());
System.out.println("Battery Remaining :\t" + robot.getBatteryStatus());
}

@Override
public double scan(Barcode barcode) {
double price = 0;
System.out.println("scanning");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (checkBarcodeImg(barcode)) {
price = barcode.getPrice();
System.out.println("Price display on Robot  : \t" + price);
} else {
robot.setMessage(RoboMessages.SCAN_FAILED);
display();
}
return price;
}

/**

* @param barcode
* @return
*/
private boolean checkBarcodeImg(Barcode barcode) {
// if(barcode.getImg())
return true;
}

}

package com.consumerfed.airobo.service;

public interface AIRobotServiceInf {
public float walk(float kilometer);
public float walkWithWeight(float kilometer, float kilogram);
public boolean loadWeight(float kilogram);
public void chargeBattery();
public void removeLoad();

}

/**
 * 
 */
package com.consumerfed.airobo.service;

import com.consumerfed.airobo.model.Barcode;

/**
 * @author consumerfed Information Technology
 *
 */
public interface Scanning {
public double scan(Barcode barcode);

}


package com.cosumerfed.airobo.test;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

import com.consumerfed.airobo.model.AIRobot;
import com.consumerfed.airobo.model.Barcode;
import com.consumerfed.airobo.service.AIRobotService;
import com.consumerfed.airobo.service.AIRobotServiceInf;
import com.consumerfed.airobo.service.Scanning;

public class AIRobotTest {

@BeforeClass
public static void setUpBeforeClass() throws Exception {
}

@AfterClass
public static void tearDownAfterClass() throws Exception {
}

@Before
public void setUp() throws Exception {
}

@After
public void tearDown() throws Exception {
// System.setOut("");
}

// Robot carries 12 KG
@Test
public void OverweightTest() {
AIRobot robot = new AIRobot();
AIRobotServiceInf tester = new AIRobotService(robot);
assertEquals(false, tester.loadWeight(12));
}

@Test
public void NormalTest() {
AIRobot robot = new AIRobot();
AIRobotServiceInf tester = new AIRobotService(robot);
assertTrue(tester.loadWeight(9.5f));
}

// Robot walks 3.5 kilometers
@Test
public void WalkBatteryValidTest() {
AIRobot robot = new AIRobot();
AIRobotServiceInf tester = new AIRobotService(robot);
tester.chargeBattery();
assertEquals(30.0, tester.walk(3.5f), 0.0001);
}

@Test
public void WalkWithoutCharingTest() {
AIRobot robot = new AIRobot();
AIRobotServiceInf tester = new AIRobotService(robot);
assertEquals(00.0, tester.walk(3.5f), 0.0001);
}

// Robot walks for 2Km carrying 3 kg
@Test
public void WalkWithWeighValidTest() {
AIRobot robot = new AIRobot();
AIRobotServiceInf tester = new AIRobotService(robot);
tester.chargeBattery();
assertEquals(36.0, tester.walkWithWeight(2, 3), 0.0001);
}
@Test
public void robotScanTest() {
Barcode barcode = new Barcode();
AIRobot robot = new AIRobot();
Scanning tester = new AIRobotService(robot);
assertEquals(120.75, tester.scan(barcode), 0.0001);
}
@Test
public void successiveWalkTest() {
AIRobot robot = new AIRobot();
AIRobotServiceInf tester = new AIRobotService(robot);
tester.chargeBattery();
tester.walk(3);
assertEquals(0.0, tester.walk(2), 0.0001);
}
@Test
public void walkAboveMaxDistanceTest() {
AIRobot robot = new AIRobot();
AIRobotServiceInf tester = new AIRobotService(robot);
tester.chargeBattery();
assertEquals(100.0, tester.walk(6), 0.0001);
}

}

package com.consumerfed.airobo.utilities;

public class AIRobotUtilities {
public static final float MAX_MILEAGE = 5;

// BATTERY RESERVICE IN PERCENAGE
public static final float BATTERY_RESERVE = 15;

// EXTRA PERCENTAGE REDUCTION PER KILO METER
public static final float EXTRA_REDUCE_PKM_WGT = 2;

// private battery consumption per kilo meter
public static final float BATTERY_CONSUMPTION_PKM = 20;

// WEIGHT IN KILO GRAM
public static final float MAX_WEIGHT = 10;

}

/**
 * 
 */
package com.consumerfed.airobo.utilities;

/**
 * @author Consumerfed
 *
 */
public enum RoboMessages {
OVERWEIGHT("OVERWEIGHT"),
FULL_CHARGE("BATTERY FULL CHARGED"),
EMPTY_LOAD("LOAD IS EMPTY"),
EMPTY_BATTERY("BATTERY IS EMPTY"),
MAX_DISTANCE_EXCEED("MAXIMUM DISTANCE EXCEEDED"), 
RESEVE_BATTERY("BATTERY IN RESERVE"),
NILL(""), SCAN_FAILED("SCAN FAILURE");

private String message;

public String getMessage() {
return this.message;
}

private RoboMessages(String message) {
this.message = message;
}

}


Posted by at No comments:
Labels: , ,
Location: Dubai - United Arab Emirates
Subscribe to: Posts (Atom)

Facebook comments