Java Homework Help, Project Help, Java Assignment Solution

Java is a concurrent, object-oriented and general purpose programming language. It does not need recompilation since it can run on any platform that supports Java. Moreover, Java applications can run on any java virtual machine irrespective of the computer architecture in use. The language was originally developed at Sun Microsystems by James Gosling and was first released in 1995 Sun Microsystems has since been acquired by Oracle Corporation in January 27, 2010. Although Java derives much of its syntax from C++ and C, It has limited low-level facilities than either of the two.

ProgrammingHomeworkHelp.com caters to all students across the world with complex queries in Java. Our java programming homework help can help you improve your skills in writing Java programs and help you flourish in the field of Information Technology. We will help you gain insight knowledge of basic syntax such as patterns of coding, abstraction and encapsulation when you avail our java coding help.

We are fully aware that understanding the fundamentals of java Programming language and the concepts of objected-oriented programming is not an easy task. It requires a lot of practice and commitment before you can handle all the intricate and complex assignments. We are dedicated to helping you attain top grades in all your difficult java coding assignments.

Our team of Java programming homework help experts is familiar with all the aspects of Java programming language. They will do a thorough research and help you come up with well-crafted java assignment solutions for your queries. The main priority of our Java programming help is to ensure you are completely satisfied with our service. To achieve this goal, our experts take unending measure to help you with your Java coding assignments.

ProgrammingHomeworkHelp.com is a dedicated and reliable site where you can get exclusive java programming homework help. We only hire the most qualified and highly experienced tutors who are excellent programmers. We can guarantee that your Java tasks will be handled by the best.

Java is one of the most popular programming languages and its latest version is Java 10 which was released in March 2018. Many developers prefer Java over other languages because of its portability. This means that java programs written for one computer can run in another without any changes provided it has adequate run time support. Java language code is compiled to an intermediate representation known as Java bytecode instructions which are analogous to machine code. The bytecode is intended to be executed by a Virtual Machine (VM).

Java Runtime environment is commonly used by programmers when they want to develop standalone java applications or for Java applets. Java has a standard library which allows the end-users to have access to host-specific features such as graphics, networking and threading. Despite the universal bytecode making porting simple, java still run more slowly than native executables. This is due to the fact that bytecode must first be interpreted to machine language before it can be executed. The Java Virtual machine translates the Java bytecode into the machine language of the platform it is to run on.

Just-in-time compilation introduced in 1997/1998 has since improved significantly the execution speed of Java programs. Java has an automatic garbage collector to help manage its memory. The java runtime recovers memory from the objects created by the programmer that are no longer in use. The garbage collector then automatically frees up unreachable memory once no references to an object remains. Java saves programmers from the burden of having to perform memory management manually. In some languages, the responsibility of memory management stays with the programmer. This means that a memory leak can occur if the program does not de-allocate an object. The program may also crash if it attempts to access memory that has already been deallocated.

Variables in Java, start with a _ or letter, and can have letters, numbers and underscores following, a selection of unicode characters can also be used so you can have variables in foreign languages. These are are legal variables Hi, my_name, is, _007, π. A variable has a type, which is either int (an integer value, which is a signed value up to approximately 2 billion, although it can be larger), a char (represents a single character, either digit, letter, punctuation), or a floating point type (float and double are the floating point types).

int age;
char sex;   // M or F
double salary;

You can group a series of variables together to form a class (so for example an exmployee would have a name, age, and salary). There is also arrays which allow you to use an index to access a variable of the same type. Java has a string type, which are immutable (they can’t be changed, each time you want to change a string you need to make a new copy).

class Employee
{
    public String name;      // 64 characters for the name
    public int age;
    public char sex;
    public double salary;
};

Let’s modify the employee example, first of all we will create a constructor which is called when you make a new object.

class Employee
{
    public Employee(String name, int age, char sex, double salary)
    {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.salary = salary;
    };

    public string name;
    public int age;
    public char sex;
    public double salary;
};

You should notice this “this” in the constructor for the class, this is used in methods to refer to the current object. It’s a good idea to make it so that you can’t access the fields of class directly, as they can be changed by any method that has a copy of the object. So we can have functions called getters and setters. So let’s change the code again.

Java is platform independent. Java when compiled, is not directly converted to the machine code, its rather converted into a platform independent byte code. This byte-code is distributed over web and interpreted by Java Virtual Machine on whichever platform it is being run. We at Java programming homework help the students with their assignment solutions and deliver them well within the deadline. We provide 100% plagiarism free code. Students from all across the world have already availed our Java programming homework help.

The help we provide in java assignment for beginners is complete and inclusive in all respects, because we incorporate all the basic fundamental concepts in the assignment solution that is necessary for the beginners, novices as well as the experts.

class Employee
{
    public Employee(String name, int age, char sex, double salary)
    {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.salary = salary;
    };

    public String getName()
    {
        return name;    // we don't need "this" because it is implicit
    }

    public int getAge()
    {
        return age;
    }

    public void setAge(int age)
    {
        this.age = age;    // we have a local "age", and the class "age" so use "this"
    }

    public char getSex()
    {
        return sex;
    }

    public double getSalary()
    {
        return salary;
    }

    // We don't have a setSalary, as it could be abused
    public void giveRaise(double amount)
    {
        log(INFO, mame + " got raise of " + amount);  // record raises to the log, so they can be reviewed
        salary += amount;
    }

    private String name;
    private int age;
    private char sex;
    private double salary;
};

This code is ok, but the giveRaise function just logs a payraise, so it may go unnoticed, this is one advantage of using methods to control the changes, we can make a change to the giveRaise function and routines that call it would not need to be changed.

public void giveRaise(double amount)
{
    int level = INFO;
    // Raises should be annual
    if (lastRaised - today() < 335) level = WARNING;
    // More than 20% raise is suspicious
    if (amount > salary / 5) level = WARNING;
    log(level, mame + " got raise of " + amount);  // record raises to the log, so they can be reviewed
    salary += amount;
    lastRaised = today();
}

To print an instance of the employee, the normal way is to define the toString method, and then print it.

public String toString()
{
    StringBuffer buffer = new StringBuffer(name);
    buffer.append(" (");
    buffer.append(sex);
    buffer.append(") ");
    buffer.append(salary);
    return buffer.toString();
}

After looking at this Java code, you can see the so feel free to contact us.

Sample Java Project

 

Java project

Hi, I expect you’re looking for help, since you’ve come here. Well, this is the place for Java project help. I’ve got over 30 years experience, and can handle almost anything you can throw at me.

Our experts who provide help with Java programming homework to students are highly educated and have years of experience. They offer java programming project help in such a way that students can learn the topic with ease

This is a project to program a Sudoku game in Java, with a GUI.

The Sudoku Program
Entering Digits With The Mouse
java assignment help
Help Text

Sudoku is a simple logic puzzle that is a popular
waste of time in newspapers, and magazines. The name Sudoku comes from a Japanese puzzle company Nikoli,
and means single number.

private Sudoku()

    private Sudoku()
    {
        //The board is a 9x9 grid
        board = new JDigit[9][9];
        timeStart = System.currentTimeMillis();
        running = true;
        entering = false;
        completed = false;
        solved = false;
        //Initialize the counts with how many bits are set
        counts = new int[1024];
        for (int count = 0; count < 1024; count++)
        {
            int bits = 0;
            for (int bit = 1; bit < 10; bit++)
            {
                if (((1 << bit) & count) != 0)
                {
                    bits++;
                }
            }
            counts[count] = bits;
        }
    };

counts is used for bitmasks so that we can tell how many binarys digits are set for each value.

boolean possible()

    boolean possible()
    {
        if (completed) return true;
        completed = true;
        boolean error = false;
        //We do 2 passes, because we get 2nd order effects in invalid cases
        for (int pass = 0; pass < 2; pass++)
        {
            for (int x = 0; x < 9; x++)
            {
                for (int y = 0; y < 9; y++)
                {
                    //If there was an error, or an empty square we didn't finish
                    if (board[x][y].error || board[x][y].getDigit() == Digit.EMPTY)
                    {
                        completed = false;
                    }
                    int found = 0;
                    //Check all the squares along vertical, horizontal, and in the same grid
                    for (int test = 0; test < 9; test++)
                    {
                        Digit digit = Digit.EMPTY;
                        if (test != y)
                        {
                            digit = board[x][test].getDigit();
                            found |= 1 << digit.value();
                        }
                        if (test != x)
                        {
                            digit = board[test][y].getDigit();
                            found |= 1 << digit.value();
                        }
                        int xStart = x - x % 3;
                        int yStart = y - y % 3;
                        for (int xAdd = 0; xAdd < 3; xAdd++)
                        {
                            for (int yAdd = 0; yAdd < 3; yAdd++)
                            {
                                int currX = xStart + xAdd;
                                int currY = yStart + yAdd;
                                if (currX != x || currY != y)
                                {
                                    digit = board[currX][currY].getDigit();
                                    found |= 1 << digit.value();
                                }
                            }
                        }
                    }
                    //Check if the square matches the possible (and update the copy)
                    error |= board[x][y].setPossible(~found & 1022);
                    //If all 9 values found, then we must have an error
                    if (counts[found] == 9) error = true;
                }
            }
        }
        //Once we have completed, set the time taken
        if (completed)
        {
            totalTime = time();
            running = false;
        }
        return !error;
    }

We go through all the squares on the board and check if any are errors or missing, if so we didn’t complete the
puzzle. We check each square to see if it is valid (no other digit with the same value either in the same row,
column, or block. If the game was completed we stop the clock, and set the running flag to false.

Our repertoire of Java assignment questions has been compiled keeping in mind the kind of assignments that are given in the top universities and programming schools of the world. Our assignment help on Java code is one of the best, amongst the services provided by the various online service providers on the World Wide Web.

boolean findSquare(boolean tryHarder)

    boolean findSquare(boolean tryHarder)
    {
        //Update the list of possibles
        possible();
        if (completed) return true;

        int x = rnd.nextInt(9);
        int y = rnd.nextInt(9);

        int startX = x;
        int startY = y;
        while (true)
        {
            if (board[x][y].getDigit() == Digit.EMPTY)
            {
                int maybe = board[x][y].possible;
                if (counts[maybe] == 1)
                {
                    //Only 1 possibility, so let's pick it
                    Digit digit = Digit.fromMask(maybe);
                    find.digit = digit;
                    find.x = x;
                    find.y = y;
                    return true;
                }
            }
            x++;
            x %= 9;
            if (x == startX)
            {
                y++;
                y %= 9;
                if (y == startY)
                {
                    if (tryHarder) break;
                    return false;
                }
            }
        }

        //Now check for only 1 valid place for a digit
        while (true)
        {
            if (board[x][y].getDigit() == Digit.EMPTY)
            {
                int maybe = board[x][y].possible;
                int possible = 0;
                int baseX = x - x % 3;
                int baseY = y - y % 3;
                for (int check = 0; check < 9; check++)
                {
                    //First check the row, for possible
                    if (check != x)
                    {
                        possible |= board[check][y].possible;
                    }
                    //Then check the column, for possible
                    if (check != y)
                    {
                        possible |= board[x][check].possible;
                    }
                    int gridX = baseX + check % 3;
                    int gridY = baseY + check / 3;
                    //Finally check the grid, for possible
                    if (gridX != x || gridY != y)
                    {
                        possible |= board[gridX][gridY].possible;
                    }
                }

                maybe &= ~possible; //There is only 1 possible place for a value in the square, so this must be it

                if (maybe != 0)
                {
                    //There is only 1 place the digit can go, so lets place it
                    Digit digit = Digit.fromMask(maybe);
                    find.digit = digit;
                    find.x = x;
                    find.y = y;
                    return true;
                }
            }
            x++;
            x %= 9;
            if (x == startX)
            {
                y++;
                y %= 9;
                if (y == startY)
                {
                    break;
                }
            }
        }

        /*Ok, we have NO simple solution, but we may have a 2 part solution
        123
        456
        000 <- These 000 could be 789 and we can't determine which

        Assume we have, the further restrictions
        123
        456
        000 <- First digit can't be 7, second can't be 8, third can't be 9 (8,9),(7,9),(7,8)
        We pick 2 elements that can share a value in common (and effect each other), in this
        case we pick first and last values, and we try assigning them, we then check for error
        if there was an error, we know the values can not be correct and that the reverse case
        must be true. If there is no error, that doesn't mean it is correct on the other hand
        since we may not have explored enough possible solutions that we know it will be an
        error.
         */
        while (true)
        {
            if (board[x][y].getDigit() == Digit.EMPTY)
            {
                int maybe = board[x][y].possible;
                if (counts[maybe] == 2)
                {
                    //See if there is a square, that shares the characteristics we are looking for
                    Digit digit = deepCheck(x,y,maybe);
                    if (digit != Digit.EMPTY)
                    {
                        find.digit = digit;
                        find.x = x;
                        find.y = y;
                        return true;
                    }
                }
            }
            x++;
            x %= 9;
            if (x == startX)
            {
                y++;
                y %= 9;
                if (y == startY)
                {
                    break;
                }
            }
        }

        return false;
    }

This is the heart of the solving game logic, it tries to find a square with a single possible solution. First of
all it picks a random square to start searching from (so puzzles are not always completed from the top left), then
it tries to find a square where there is only 1 valid value. If there is 1 it returns it, if there isn’t it tries a
more sophisticated search strategy. We then go through each square and consider the possible values for all the
other positions in the row, column and block if the this reveals the only location we can put the number is in the
square we are checking we put it there. We then take into account the most complex case, this is where there are 2
possible values and 2 possible locations. We try inserting one of them, and checking if this leads to an error, if it
does then that means the other case must be true (not generating an error, does not mean it is true, since it could be
that we haven’t completed enough of the board to detect the error).

Java programs are developed to be virus-free and tamper-free systems. Based on public-key encryption, various authentication techniques get implemented. Java is architecture-neutral and can execute the compiled code on various processors, with the existence of Java runtime system.

Advantages of learning Java programming language

Here are some of the reasons given by our java programming tutors:

  • Java is the most widely used language. It can detect and stop random failures with mysterious bugs by initializing each variable
  • Java uses the concept of “write once, run anywhere”. The programs are written in portable bytecodes that run faster. Instructions written in one Java platform can be processed on other platforms without any modification.
  • Java functionality can be expanded when needed. It is extensible and dynamic, created in object-oriented units called classes
  • Java is network-centric and has resources that allow programmers to access other resources across a network. Moreover, a programmer can use the client-server to create network-based applications

Why you need to get help with your Java assignments

Writing Java programs can seem like rocket science on the first day, but after a few sessions and practice you will find it interesting. Java is very complicated and sometimes even the best students run into problems. We do not want you to be frustrated with the errors and complexity of your assignments. We urge you to allow our java programming help online service carry that burden for you.

There are various IDEs available for Java coding. Your professor may want you to use NetBeans, Eclipse, JUnit or VisualVM. Get in touch with us if you are not familiar with the IDE that is required for your homework. If you want to score top grades then your assignment must be customized as per the requirements mentioned by your professor. We have at our disposal all the software needed for any type of Java assignment. Our experts are also well-acquainted with the latest versions of the software. You can be assured that the solutions you will receive will impress your professor.

We care about you and don’t want you to overwork yourself. A good rest can go a long way in helping you de-stress from all the activities in school. Getting java programming assignment help from us will give you ample time to relax and catch up with your family. You can sit back and relax while our experts carry out intensive research on your assignment and help you beat all your deadlines.

Programming students are always allotted many tasks and you may have a lot on your plate. You tasks may have clashing deadlines and this may add more pressure on you. There is a high chance that you will compromise on something for you to meet your stringent deadlines. Why not allow us save you from this stress. Our experts will lessen your busy schedule and save your degree program. Each of your assignment will be assigned to the best expert that fully understands all your requirements. Your professor will be expecting consistent delivery of top-notch solutions for all the assignments and that is what we will send you. We never lower our quality standards no matter how complex the assignment is.

Visit our site suppose you are so poor in java and your grades are very demoralizing. Our java programming assignment help service will change your attitude towards Java. We will assign you with your own tutor who will answer all the queries you have regarding the subject. We know that most colleges and universities do not offer full attention to the weak students. There are so many students in class and the professor cannot focus on all of them. The semester is also limited to time and the best your professor can do is to allot you more task to help you practice and grasp the difficult concepts. We are different, we give our clients the full attention they deserve because we care about their academic excellence. You can ask us all the questions that are troubling you and we will provide you with detailed solutions. Signing up for our online java help ensures that you are able to solve the assignment you send us on your own in the future. The content we deliver is self-explanatory and can be understood by even the students that are weak in Java. Our experts will use comments to explain to you the procedure taken to arrive at the solution.

Do not let your projects and assignments stop you from doing what you love doing. Hobbies are very important and should not be taken for granted. That is why we recommend that you get Java homework help from us. You will not have to worry about your academic tasks when you come back home feeling exhausted after rigorous training. Our Java programming help service will be handling all your Java assignments for you.

It is so difficult to impress the panel of professors with your project. They will be expecting a perfect project with no errors when you are doing your presentation. This can be very difficult to achieve especially when the task at hand is very confusing. Our Java project help will help you with developing an outstanding project and help you do a splendid presentation. First, our experts will walk you through all the concepts that your project needs. We know that it is difficult to present what you do not understand that is why we take the initiative guiding you through the project. Our experts will also do extensive research on your questions and only provide you with precise and accurate answers. Your professor will congratulate you and award you A+ grade for your project.

void help()

    void help()
    {
        String help = "<html><body style='width: 250px; padding: 5px;' align='center'>"
                            + "<h1>Sudoku - Help</h1>"
                            + "The idea of Sudoku is to add digits to the grid,<br/>"
                            + "until it is full. You can only add a number,<br/>"
                            + "if it not already present in the same 3x3 grid,<br/>"
                            + "or on the same horizontal or vertical line.<br/>"
                            + "The game is timed, you can press Hint which fills<br/>"
                            + "in a square for you, but adds a 1 minute penalty<br/>"
                            + "to your time. If you have a value that is invalid<br/>"
                            + "the square will change color to <font color='red'>red</font>. You can clear<br/>"
                            + "an existing value by entering a 0, or by pressing<br/>"
                            + "backspace or delete.<br/>";
        new CompleteDialog(SudokuView.display,"Sudoku - Help",help);
    }

Using HTML for displaying text in a dialog, means we use color in the text.

public boolean focusNext()

    public boolean focusNext()
    {
        //Default case is next digit
        int xAdd = 1;
        int yAdd = 0;

        //If we are at right of panel
        if (x % 3 == 2)
        {
            //We want to move down instead, and change x to left
            yAdd = 1;
            xAdd = -2;
            //If we are at the bottom of the panel move to the panel at the right
            if (y % 3 == 2)
            {
                yAdd = -2;
                xAdd = 1;
                //If we are at the right edge, go to the panel at the next line
                if (x == 8)
                {
                    xAdd = -8;
                    yAdd = 1;
                }
            }
        }

        //Try and focus (moveFocus returns false is it is unable to move to the next)
        return moveFocus(xAdd,yAdd);
    }

Move to the next square (it moves in each block, then onto the next block for entering puzzle.

public void setDigit(Digit digit)

    public void setDigit(Digit digit)
    {
        //Are we entering a puzzle?
        if (Sudoku.game.isEntering())
        {
            //Fixed square (unless it is 0)
            fixed = digit.value() != 0;
            //Answer is the value we entered
            answer = digit;
            //Set the correct background color
            if (fixed)
            {
                setBackground(SudokuView.fixedCol);
            }
            else
            {
                setBackground(SudokuView.background);
                if (this == SudokuView.focused)
                {
                    setBackground(SudokuView.background.brighter().brighter());
                }
            }
        }
        else
        {
            //If it was fixed value, make sure nothing else caused an error
            if (fixed)
            {
                Sudoku.game.possible();
                checkError();
                return;
            }
        }

        this.digit = digit;
        image = getImage(digit);

        //Check for errors and repaint (if not entering)
        if (!Sudoku.game.isEntering())
        {
            Sudoku.game.possible();
            checkError();
            repaint();
        }
    }

Change the digit and cause a redraw, checks for errors when called.

void swap(JDigit other)

    void swap(JDigit other)
    {
        Digit save = this.digit;
        this.digit = other.digit;
        other.digit = save;
        save = answer;
        answer = other.answer;
        other.answer = save;
        Image saveImage = image;
        image = other.image;
        other.image = saveImage;
    }

Swap 2 digits around, this is used when shuffling the board.

Sudoku.java

import java.awt.*;
import java.util.Random;

/**
 * Created with IntelliJ IDEA.
 * Date: 5/22/13
 * Time: 10:14 PM
 */

/**
 * The main game (Model)
 */
public class Sudoku
{
    /**
     * Singleton instance of the Sudoku game
     */
    static Sudoku game;

    //The grid that represents the state of the game
    private JDigit board[][];

    //Used to determine how long ago the game started
    private long timeStart;
    //Is the clock running?
    private boolean running;
    //Are we entering values (For Enter Puzzle mode)
    private boolean entering;
    Random rnd = new Random();
    //Has puzzle been completed
    private boolean completed;
    //Once puzzle is solved (during hint() we don't need to solve it again)
    private boolean solved;
    //How long did it take
    private String totalTime;

    //How many digits are set in a bitfield
    private int[] counts;

    //For returning data to hint()
    private XYDigit find = new XYDigit();

    private Sudoku()
    {
        //The board is a 9x9 grid
        board = new JDigit[9][9];
        timeStart = System.currentTimeMillis();
        running = true;
        entering = false;
        completed = false;
        solved = false;
        //Initialize the counts with how many bits are set
        counts = new int[1024];
        for (int count = 0; count < 1024; count++)
        {
            int bits = 0;
            for (int bit = 1; bit < 10; bit++)
            {
                if (((1 << bit) & count) != 0)
                {
                    bits++;
                }
            }
            counts[count] = bits;
        }
    };

    /**
     * Start a new game
     * @param difficulty Easy, Medium, Hard or Enter Puzzle
     */
    void start(String difficulty)
    {
        entering = true;
        solved = false;
        //Set the title with the difficulty level
        SudokuView.display.setTitle("Sudoku - " + difficulty);
        if (difficulty == "Enter Puzzle")
        {
            //entering a new puzzle
            enter();
        }
        else
        {
            //Create a grid
            createGrid(difficulty);
            timeStart = System.currentTimeMillis();
            completed = false;
            running = true;
            solved = true;  //We actually have an answer
        }

        for (int x = 0; x < 9; x++)
        {
            for (int y = 0; y < 9; y++)
            {
                //Repaint all the elements
                board[x][y].repaint();
            }
        }
    }

    /**
     * Create a grid by shuffling
     * @param difficulty
     */
    private void createGrid(String difficulty)
    {
        Digit rows[] = {Digit.ONE, Digit.FOUR, Digit.SEVEN, Digit.TWO, Digit.FIVE, Digit.EIGHT, Digit.THREE, Digit.SIX, Digit.NINE};
        completed = false;

        //Empty the grid
        for (int x = 0; x < 9; x++)
            for (int y = 0; y < 9; y++)
                board[x][y].setDigit(Digit.EMPTY);

        //Generate a grid that is valid
        for (int y = 0; y < 9; y++)
        {
            Digit curr = rows[y];
            for (int x = 0; x < 9; x++)
            {
                board[x][y].setDigit(curr);
                board[x][y].error = false;
                curr = curr.next();
            }
        }

        //Now we shuffle the grid (http://blog.forret.com/2006/08/a-sudoku-challenge-generator/ for the algorithm)
        //The shuffles make it so that we have a valid solution at all points
        for (int shuffles = 0; shuffles < 20; shuffles++)
        {
            for (int set = 0; set < 3; set++)
            {
                shuffleRow(set*3);
                shuffleColumn(set*3);
            }
            shuffleBlocks();
        }

        //Now go through and hide some blocks
        int hide = 3;
        if (difficulty == "Medium")

        {
            hide = 4;
        }
        if (difficulty == "Hard")
        {
            hide = 5;
        }

        for (int x = 0; x < 9; x++)
        {
            int hides = hide;
            while (hides > 0)
            {
                int y = rnd.nextInt(9);
                //Hide some squares from column
                if (board[x][y].getDigit() != Digit.EMPTY)
                {
                    Digit original = board[x][y].getDigit();
                    board[x][y].setDigit(Digit.EMPTY);
                    board[x][y].answer = original;
                }
                hides--;
            }
        }

        for (int y = 0; y < 9; y++)
        {
            int hides = hide;
            while (hides > 0)
            {
                int x = rnd.nextInt(9);
                //Hide some squares from row
                if (board[x][y].getDigit() != Digit.EMPTY)
                {
                    Digit original = board[x][y].getDigit();
                    board[x][y].setDigit(Digit.EMPTY);
                    board[x][y].answer = original;
                }
                hides--;
            }
        }

        entering = false;

//      if (difficulty != "Hard")
        {
            do
            {
                if (true) break;
                //What was hard is now medium (squares with 2 possible values), and hard is possible for computer to solve
                if (!hint(difficulty != "Easy", difficulty == "Hard"))
                {
                    //Ok, find a random square that is empty and set it to correct value
                    int x = rnd.nextInt(9);
                    int y = rnd.nextInt(9);
                    int startX = x;
                    int startY = y;
                    while (true)
                    {
                        if (board[x][y].getDigit() != board[x][y].answer && counts[board[x][y].possible] > 1)
                        {
                            entering = true;
                            board[x][y].setDigit(board[x][y].answer);
                            entering = false;
                            break;
                        }
                        x++;
                        x %= 9;
                        if (x == startX)
                        {
                            y++;
                            y %= 9;
                            if (y == startY)
                            {
                                throw new RuntimeException("Unable to solve????");
                            }
                        }
                    }
                }
            } while (!completed);
            //Reset the board back to the puzzle
            reset();
        }
    }

    /**
     * Check the grid and fill out for each square the possible values
     * @return false if there was an error
     */
    boolean possible()
    {
        if (completed) return true;
        completed = true;
        boolean error = false;
        //We do 2 passes, because we get 2nd order effects in invalid cases
        for (int pass = 0; pass < 2; pass++)
        {
            for (int x = 0; x < 9; x++)
            {
                for (int y = 0; y < 9; y++)
                {
                    //If there was an error, or an empty square we didn't finish
                    if (board[x][y].error || board[x][y].getDigit() == Digit.EMPTY)
                    {
                        completed = false;
                    }
                    int found = 0;
                    //Check all the squares along vertical, horizontal, and in the same grid
                    for (int test = 0; test < 9; test++)
                    {
                        Digit digit = Digit.EMPTY;
                        if (test != y)
                        {
                            digit = board[x][test].getDigit();
                            found |= 1 << digit.value();
                        }
                        if (test != x)
                        {
                            digit = board[test][y].getDigit();
                            found |= 1 << digit.value();
                        }
                        int xStart = x - x % 3;
                        int yStart = y - y % 3;
                        for (int xAdd = 0; xAdd < 3; xAdd++)
                        {
                            for (int yAdd = 0; yAdd < 3; yAdd++)
                            {
                                int currX = xStart + xAdd;
                                int currY = yStart + yAdd;
                                if (currX != x || currY != y)
                                {
                                    digit = board[currX][currY].getDigit();
                                    found |= 1 << digit.value();
                                }
                            }
                        }
                    }
                    //Check if the square matches the possible (and update the copy)
                    error |= board[x][y].setPossible(~found & 1022);
                    //If all 9 values found, then we must have an error
                    if (counts[found] == 9) error = true;
                }
            }
        }
        //Once we have completed, set the time taken
        if (completed)
        {
            totalTime = time();
            running = false;
        }
        return !error;
    }

    /**
     * Swap 2 rows in the same grid around
     * @param base
     */
    void shuffleRow(int base)
    {
        int a = rnd.nextInt(3);
        int b = rnd.nextInt(3);
        if (a == b)
        {
            a = (a + 1) % 3;
        }
        a += base;
        b += base;
        for (int x = 0; x < 9; x++)
        {
            board[x][a].swap(board[x][b]);
        }
    }

    /**
     * Swap 2 columns in the same grid around
     * @param base
     */
    void shuffleColumn(int base)
    {
        int a = rnd.nextInt(3);

        int b = rnd.nextInt(3);
        if (a == b)
        {
            a = (a + 1) % 3;
        }
        a += base;
        b += base;

        for (int y = 0; y < 9; y++)
        {
            board[a][y].swap(board[b][y]);
        }
    }

    /**
     * Swap a line of a grid around
     */
    void shuffleBlocks()
    {
        int a = rnd.nextInt(3);
        int b = rnd.nextInt(3);
        if (a == b)
        {
            a = (a + 1) % 3;
        }
        a *= 3;
        b *= 3;
        for (int x = 0; x < 9; x++)
            for (int y = 0; y < 3; y++)
                board[x][a+y].swap(board[x][b+y]);
    }

    /**
     * Save the state for backtracking
     * @return the current state
     */
    private Digit[][] saveGrid()
    {
        Digit[][] save = new Digit[9][9];

        for (int x = 0; x < 9; x++)
        {
            for (int y = 0; y < 9; y++)
            {
                save[x][y] = board[x][y].getDigit();
            }
        }

        return save;
    }

    /**
     * Restore the previous state (for backtracking)
     * @param load
     */
    private void loadGrid(Digit[][] load)
    {
        for (int x = 0; x < 9; x++)
        {
            for (int y = 0; y < 9; y++)
            {
                board[x][y].tryDigit(load[x][y]);
            }
        }
    }

    /**
     * Find a valid square
     * @param tryHarder find a square using more complex logic
     * @return true if it found a square
     */
    boolean findSquare(boolean tryHarder)
    {
        //Update the list of possibles
        possible();
        if (completed) return true;

        int x = rnd.nextInt(9);
        int y = rnd.nextInt(9);

        int startX = x;
        int startY = y;
        while (true)
        {
            if (board[x][y].getDigit() == Digit.EMPTY)
            {
                int maybe = board[x][y].possible;
                if (counts[maybe] == 1)
                {
                    //Only 1 possibility, so let's pick it
                    Digit digit = Digit.fromMask(maybe);
                    find.digit = digit;
                    find.x = x;
                    find.y = y;
                    return true;
                }
            }
            x++;
            x %= 9;
            if (x == startX)
            {
                y++;
                y %= 9;
                if (y == startY)
                {
                    if (tryHarder) break;
                    return false;
                }
            }
        }

        //Now check for only 1 valid place for a digit
        while (true)
        {
            if (board[x][y].getDigit() == Digit.EMPTY)
            {
                int maybe = board[x][y].possible;
                int possible = 0;
                int baseX = x - x % 3;
                int baseY = y - y % 3;
                for (int check = 0; check < 9; check++)
                {
                    //First check the row, for possible
                    if (check != x)
                    {
                        possible |= board[check][y].possible;
                    }
                    //Then check the column, for possible
                    if (check != y)
                    {
                        possible |= board[x][check].possible;
                    }
                    int gridX = baseX + check % 3;
                    int gridY = baseY + check / 3;
                    //Finally check the grid, for possible
                    if (gridX != x || gridY != y)
                    {
                        possible |= board[gridX][gridY].possible;
                    }
                }

                maybe &= ~possible; //There is only 1 possible place for a value in the square, so this must be it

                if (maybe != 0)
                {
                    //There is only 1 place the digit can go, so lets place it
                    Digit digit = Digit.fromMask(maybe);
                    find.digit = digit;
                    find.x = x;
                    find.y = y;
                    return true;
                }
            }
            x++;
            x %= 9;
            if (x == startX)
            {
                y++;
                y %= 9;
                if (y == startY)
                {
                    break;
                }
            }
        }

        /*Ok, we have NO simple solution, but we may have a 2 part solution
        123
        456
        000 <- These 000 could be 789 and we can't determine which

        Assume we have, the further restrictions
        123
        456
        000 <- First digit can't be 7, second can't be 8, third can't be 9 (8,9),(7,9),(7,8)
        We pick 2 elements that can share a value in common (and effect each other), in this
        case we pick first and last values, and we try assigning them, we then check for error
        if there was an error, we know the values can not be correct and that the reverse case
        must be true. If there is no error, that doesn't mean it is correct on the other hand
        since we may not have explored enough possible solutions that we know it will be an
        error.
         */
        while (true)
        {
            if (board[x][y].getDigit() == Digit.EMPTY)
            {
                int maybe = board[x][y].possible;
                if (counts[maybe] == 2)
                {
                    //See if there is a square, that shares the characteristics we are looking for
                    Digit digit = deepCheck(x,y,maybe);
                    if (digit != Digit.EMPTY)
                    {
                        find.digit = digit;
                        find.x = x;
                        find.y = y;
                        return true;
                    }
                }
            }
            x++;
            x %= 9;
            if (x == startX)
            {
                y++;
                y %= 9;
                if (y == startY)
                {
                    break;
                }
            }
        }

        return false;
    }

    /**
     * Find the next square (pick it randomly)
     * @param tryHarder
     * @param deep attempt to solve
     * @return true if it managed to find a square
     */
    boolean hint(boolean tryHarder,boolean deep)
    {
        possible();
        if (completed) return true;

        //First check the board for any squares that don't match the answer

        for (int x = 0; x < 9; x++)
        {
            for (int y = 0; y < 9; y++)
            {
                Digit answer = board[x][y].answer;
                if (answer != Digit.EMPTY)
                {
                    Digit digit = board[x][y].getDigit();
                    if (digit != Digit.EMPTY && digit != answer)
                    {
                        board[x][y].setDigit(answer);
                        board[find.x][find.y].moveFocus(0,0);
                        timeStart -= 60000; //Add 1 minute penalty every time you use hint
                        return true;
                    }
                }
            }
        }

        //find a square, and if we did, update the display and apply a penalty
        if (findSquare(tryHarder))
        {
            board[find.x][find.y].setDigit(find.digit);
            board[find.x][find.y].moveFocus(0,0);
            timeStart -= 60000; //Add 1 minute penalty every time you use hint
            return true;
        }

        if (!deep)
        {
            return false;
        }

        //Now do deep solution, and find a square
        if (!solved)
        {
            return false;
            //if (!solve(0,0)) return false;
            //solved = true;
        }

        //Find a square, where we already have an answer and reveal it
        for (int x = 0; x < 9; x++)
        {
            for (int y = 0; y < 9; y++)
            {
                if (board[x][y].getDigit() == Digit.EMPTY)
                {
                    board[x][y].setDigit(board[x][y].answer);
                    board[x][y].moveFocus(0,0);
                    timeStart -= 60000; //Add 1 minute penalty every time you use hint
                    return true;
                }
            }
        }

        return false;
    }

    /**
     * This number should not appear anywhere in the row.
     * @param y
     * @param digit
     * @return
     */
    public boolean checkHorizontal(int y, Digit digit)
    {
        for (int x = 0; x < 9; x++)
        {
            if (board[x][y].getDigit() == digit)
            {
                return false;
            }
        }
        return true;
    }

    /**
     * This number should not appear anywhere in the column
     * @param x
     * @param digit
     * @return
     */
    public boolean checkVertical(int x, Digit digit)
    {
        for (int y = 0; y < 9; y++)
        {
            if (board[x][y].getDigit() == digit)
            {
                return false;
            }
        }
        return true;
    }

    /**
     * This number should not appear anywhere in the box
     * @param x
     * @param y
     * @param digit
     * @return
     */
    private boolean checkBox(int x, int y, Digit digit)
    {
        // Round down to nearest 3.
        int xStart = (x / 3) * 3;
        int yStart = (y / 3) * 3;
        for (x = xStart; x < xStart + 3; x++)
        {
            for (y = yStart; y < yStart + 3; y++)
            {
                if (board[x][y].getDigit() == digit)
                {
                    return false;
                }
            }
        }
        return true;
    }

    /**
     * Check if digit a valid possibility
     * @param x
     * @param y
     * @param digit
     * @return
     */
    boolean check(int x, int y, Digit digit)
    {
        // All checks must pass.
        return checkHorizontal(y, digit)
                && checkVertical(x, digit)
                && checkBox(x, y, digit);
    }

    /**
     * Recursive solution finder
     * @param x
     * @param y
     * @return
     */
    public boolean solve(int x, int y)
    {
        // Got to the end?
        if (y >= 9)
        {
            //Reached the end
            return true;
        }
        // If the cell is empty
        if (board[x][y].getDigit() == Digit.EMPTY)
        {
            Digit[][] save = saveGrid();
            // Find a valid number for the empty cell
            for (Digit digit : Digit.digits)
            {
                // Can this number be put there?
                if (check(x, y, digit))
                {
                    // Yes!
                    //System.out.println(x+","+y+"="+digit);
                    board[x][y].tryDigit(digit);
                    // Try that.
                    //Now fill in the rest of the board as far possible
                    while (findSquare(true))
                    {
                        if (completed) return true;
                        board[find.x][find.y].tryDigit(find.digit);
                    }
                    if (next(x, y))
                    {
                        return true;
                    }
                }
            }
            // Clean up.
            board[x][y].answer = board[x][y].getDigit();
            loadGrid(save);
        }
        else
        {
            // Move on.
            if (next(x, y))
            {
                return true;
            }
        }
        // Failed to find a solution.
        return false;
    }

    /**
     * Now attempt to solve the next square
     * @param x
     * @param y
     * @return
     */
    public boolean next(int x, int y)
    {
        if (x < 8)
        {
            // Step right.
            return solve(x + 1, y);
        }
        else
        {
            // Step down.
            return solve(0, y + 1);
        }
    }

    /**
     * Perform a check along vertical, horizontal and in box for another square
     * with 2 digits in the possible list where at least one of them matches
     * @param x
     * @param y
     * @param maybe
     * @return
     */
    private Digit deepCheck(int x, int y, int maybe)
    {
        Digit found = Digit.EMPTY;
        int baseX = x - x % 3;
        int baseY = y - y % 3;
        for (int check = 0; check < 9; check++)
        {
            //First check the row, for possible
            if ((maybe & board[check][y].possible) != 0)
            {
                found = check(x, y, check, y);
                if (found != Digit.EMPTY) return found;
            }
            //Then check the column, for possible
            if ((maybe & board[x][check].possible) != 0)
            {
                found = check(x, y, x, check);
                if (found != Digit.EMPTY) return found;
            }
            int gridX = baseX + check % 3;
            int gridY = baseY + check / 3;
            //Finally check the grid, for possible
            if ((maybe & board[gridX][gridY].possible) != 0)
            {
                found = check(x, y, gridX, gridY);
                if (found != Digit.EMPTY) return found;
            }
        }
        return found;
    }

    /**
     * Check if a digit matches
     * @param x
     * @param y
     * @param x2
     * @param y2
     * @return
     */
    private Digit check(int x, int y, int x2, int y2)
    {
        if (x == x2 && y == y2) return Digit.EMPTY;
        if (board[x2][y2].getDigit() != Digit.EMPTY) return Digit.EMPTY;
        //We know [x,y] has only 2 components, so check [x2,y2]
        int found = board[x2][y2].possible;
        if (counts[found] != 2) return Digit.EMPTY;
        int maybe = board[x][y].possible;
        if (maybe == found) return Digit.EMPTY;
        Digit shared = Digit.fromMask(found & maybe);
        Digit digit = Digit.fromMask(maybe ^ (found & maybe));
        Digit other = Digit.fromMask(found ^ (found & maybe));
        board[x][y].setDigit(shared);
        board[x2][y2].setDigit(other);
        boolean ok = !possible();
        board[x][y].setDigit(Digit.EMPTY);
        board[x2][y2].setDigit(Digit.EMPTY);
        if (ok)
        {
//          System.out.println("Found " + digit + " with deep check at " + x + "," + y);
            return digit;
        }
        return Digit.EMPTY;
    }

    /**
     * Attempt to solve the puzzle
     * @return
     */
    boolean solve()
    {
        while (!completed)
        {
            if (!hint(true,true))
            {
                return false;
            }
        }
        return true;
    }

    /**
     * Reset the grid back to default
     */
    void reset()
    {
        entering = false;
        for (int x = 0; x < 9; x++)
            for (int y = 0; y < 9; y++)
                board[x][y].setDigit(Digit.EMPTY);
        completed = false;
        running = true;
    }

    /**
     * Create a dialog box with the help text
     */
    void help()
    {
        String help = "<html><body style='width: 250px; padding: 5px;' align='center'>"
                            + "<h1>Sudoku - Help</h1>"
                            + "The idea of Sudoku is to add digits to the grid,<br/>"
                            + "until it is full. You can only add a number,<br/>"
                            + "if it not already present in the same 3x3 grid,<br/>"
                            + "or on the same horizontal or vertical line.<br/>"
                            + "The game is timed, you can press Hint which fills<br/>"
                            + "in a square for you, but adds a 1 minute penalty<br/>"
                            + "to your time. If you have a value that is invalid<br/>"
                            + "the square will change color to <font color='red'>red</font>. You can clear<br/>"
                            + "an existing value by entering a 0, or by pressing<br/>"
                            + "backspace or delete.<br/>";
        new CompleteDialog(SudokuView.display,"Sudoku - Help",help);
    }

    /**
     * We are entering a puzzle, so set up the grid for it
     */
    void enter()
    {
        completed = false;

        for (int x = 0; x < 9; x++)
            for (int y = 0; y < 9; y++)
                board[x][y].setDigit(Digit.EMPTY);
        running = false;
        SudokuView.setFocused(0,0);
    }

    /**
     * Are we entering a puzzle
     * @return
     */
    boolean isEntering()
    {
        return entering;
    }

    /**
     * Have we finished the puzzle
     * @return
     */
    boolean isCompleted()
    {
        return completed;
    }

    /**
     * We have finished entering the puzzle
     */
    void finishEntering()
    {
        entering = false;
        timeStart = System.currentTimeMillis();
        running = true;
        SudokuView.display.setTitle("Sudoku - Custom Puzzle");
    }

    /**
     * Return the time as a string
     * @return How long have we taken (up to 59:59)
     */
    String time()
    {
        if (!running)
        {
            if (completed)
            {
                return totalTime;
            }
            return "00:00";
        }

        long elapsed = System.currentTimeMillis() - timeStart;
        int seconds = (int)(elapsed / 1000);
        int minutes = seconds / 60;
        seconds %= 60;
        if (minutes > 59)
        {
            return "59:59";
        }
        return String.format("%02d:%02d",minutes,seconds);
    }

    /**
     * The main entry point
     * @param args
     */
    public static void main(String args[])
    {
        game = new Sudoku();
        EventQueue.invokeLater(new Runnable()
        {
            //@Override
            public void run()
            {
                SudokuView.createGUI(game.board);
            }
        });
    }
}

SudokuView.java

/**
 * Created with IntelliJ IDEA.
 * Date: 5/22/13
 * Time: 10:15 PM
 */

import javax.swing.*;
import javax.swing.border.Border;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.BufferedImage;
import java.util.EnumSet;

/**
 * Main Display Class, handles the display of the elements
 */
public class SudokuView extends JPanel
{
    /**
     * The currently highlighted square
     */
    static JDigit focused = null;
    /**
     * The popup menu for entering the digits
     */
    static JPopupMenu popup = new JPopupMenu();
    /**
     * The main grid
     */
    static JDigit[][] board;
    /**
     * The main display frame
     */
    static JFrame display;
    /**
     * The current time taken
     */
    static JLabel timeLabel;

    /**
     * Default grid color
     */
    static Color background = new Color(0xe0e000);

    /**
     * Default color of popup
     */
    static Color popupColor = new Color(0x00e0e0);

    /**
     * Color to indicate error
     */
    static Color errorCol = new Color(0xe00000);

    /**
     * Color of puzzle square
     */
    static Color fixedCol = new Color(0xe0e0e0);

    /**
     * Create the GUI of the grid
     * @param board
     */
    public static void createGUI(JDigit[][] board)
    {
        SudokuView.board = board;
        //The main frame for the display
        display = new JFrame();
        display.setTitle("Sudoku");
        //Buttons to add
        JButton easy = new JButton("Easy");
        JButton medium = new JButton("Medium");
        JButton hard = new JButton("Hard");
        JButton hint = new JButton("Hint");
        JButton solve = new JButton("Solve");
        JButton quit = new JButton("Quit");
        JButton reset = new JButton("Reset");
        JButton enter = new JButton("Enter Puzzle");
        JButton help = new JButton("Help");
        timeLabel = new JLabel("Time: 00:00");
        timeLabel.setHorizontalAlignment(JLabel.CENTER);
        easy.addActionListener(new ButtonPress());
        medium.addActionListener(new ButtonPress());
        hard.addActionListener(new ButtonPress());
        hint.addActionListener(new ButtonPress());
        solve.addActionListener(new ButtonPress());
        quit.addActionListener(new ButtonPress());
        reset.addActionListener(new ButtonPress());
        enter.addActionListener(new ButtonPress());
        help.addActionListener(new ButtonPress());
        display.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        InputMap inputMap = new InputMap();
        ActionMap actionMap = new ActionMap();
        //The clear keys
        inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_0, 0), " ");
        inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_NUMPAD0, 0), " ");
        inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_BACK_SPACE, 0), " ");
        inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0), " ");
        actionMap.put(" ", new SelectAction(Digit.EMPTY));
        //Move the cursor keys to change the focused square
        inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0), "Up");
        inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0), "Down");
        inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, 0), "Left");
        inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, 0), "Right");
        actionMap.put("Up", new KeyAction(0,-1));
        actionMap.put("Down", new KeyAction(0,1));
        actionMap.put("Left", new KeyAction(-1,0));
        actionMap.put("Right", new KeyAction(1, 0));
        popup.setLayout(new GridLayout(3, 3));
        //Set the digits of popup
        for (Digit d : Digit.digits)
        {
            Action select = new SelectAction(d);
            inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_0 + d.value(), 0), d.toString());
            inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_NUMPAD0 + d.value(), 0), d.toString());
            actionMap.put(d.toString(), select);
            popup.add(new PickDigit(d));
        }
        popup.setBorder(BorderFactory.createLineBorder(Color.black, 2));
        popup.setInputMap(WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,inputMap);
        popup.setActionMap(actionMap);
        //We are using GridBagLayout to have custom layout (it was GridLayout before)
        display.setLayout(new GridBagLayout());
        GridBagConstraints c = new GridBagConstraints();
        //Add the 9 3x3 squares
        for (int panel = 0; panel < 9; panel++)
        {
            int xStart = (panel % 3) * 3;
            int yStart = (panel / 3) * 3;
            JPanel frame = new JPanel();
            frame.setInputMap(WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,inputMap);
            frame.setActionMap(actionMap);
            frame.setLayout(new GridLayout(3, 3));
            for (Digit d : Digit.digits)
            {
                int x = xStart + (d.value() - 1) % 3;
                int y = yStart + (d.value() - 1) / 3;
                SudokuView digit = new SudokuView(board,d,x,y);
                frame.add(digit);
            }
            frame.setVisible(true);
            frame.setBorder(BorderFactory.createLineBorder(Color.black, 2));
            c.gridx = panel % 3;
            c.gridy = panel / 3;
            display.add(frame,c);
        }
        //Add the buttons
        JPanel buttons = new JPanel();
        buttons.setLayout(new GridLayout(3, 1));
        buttons.add(easy);
        buttons.add(hint);
        buttons.add(help);
        c.fill = GridBagConstraints.HORIZONTAL;
        c.gridx = 0;
        c.gridy = 3;
        //Make them bigger vertically
        c.ipady = 50;

        display.add(buttons,c);

        buttons = new JPanel();
        buttons.setLayout(new GridLayout(3, 1));
        buttons.add(medium);
        buttons.add(solve);
        buttons.add(enter);
        c.gridx = 1;
        display.add(buttons,c);

        buttons = new JPanel();
        buttons.setLayout(new GridLayout(3, 1));
        buttons.add(hard);
        buttons.add(reset);
        buttons.add(quit);
        c.gridx = 2;
        display.add(buttons,c);
        JPanel time = new JPanel();
        time.add(timeLabel);
        c.gridx = 0;
        c.gridy = 4;
        //Make the time stretch all the way across
        c.gridwidth = 3;
        c.ipady = 0;
        display.add(time,c);

        //Create a "tick" event handler, to update the time every second
        ActionListener updateClockAction = new ActionListener() {
          public void actionPerformed(ActionEvent e) {
              // Assumes clock is a JLabel
              timeLabel.setText("Time: " + Sudoku.game.time());
            }
        };

        //Generate a grid, to solve
        Sudoku.game.start("Easy");

        //The event happens every 1 second
        Timer t = new Timer(1000, updateClockAction);
        t.start();

        display.pack();
        display.setVisible(true);
    }

    /**
     * Move focus to a particular square
     * @param x
     * @param y
     */
    public static void setFocused(int x,int y)
    {
        focused = board[x][y];
        focused.grabFocus();
    }

The Java simple homework help being provided by our experts has all the ingredients of an effective programming solution with simply written and nicely commented codes. Students get help with Java homework that satisfies their needs from all perspectives. The Java homework answers that we provide are not verbose and drawn out. Instead, they are crisp, precise and to the point.

    /**
     * Create an element
     * @param board the game board
     * @param digit value to enter
     * @param x position (0-8)
     * @param y position (0-8)
     */
    SudokuView(JDigit[][] board,Digit digit,int x,int y)
    {
        this.setLayout(new BorderLayout());
        this.setBorder(BorderFactory.createLineBorder(Color.black, 1));
        this.setBackground(SudokuView.background);

        JDigit cellValue = new JDigit(digit,x,y);
        add(cellValue, BorderLayout.CENTER);
        board[x][y] = cellValue;
    }

    /**
     * Have we completed the game, if so display a message
     */
    public static void checkSolved()
    {
        Sudoku.game.possible();
        if (Sudoku.game.isCompleted())
        {
            CompleteDialog wellDone = new CompleteDialog(SudokuView.display,"Well Done","You completed the game in " + Sudoku.game.time());
        }
    }

    /**
     * Unable to automatically solve the problem
     */
    public static void unableToSolve()
    {
        CompleteDialog error = new CompleteDialog(SudokuView.display,"Error","Unable to solve the problem.");
    }
}

;

JDigit.java

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.awt.image.BufferedImage;

/**
 * Created with IntelliJ IDEA.
 * Date: 5/31/13
 * Time: 9:12 PM
 */

/**
 * JDigit is the main interface element, it handles a single square with a number in it
 * But it also keeps track of it's error condition, the possible values it can contain
 * And the expected value
 */
class JDigit extends JButton
{

    //Size of grid square
    private static final int SIZE = 96;
    //Base of the character
    private static final int BASE = SIZE / 8;
    private static final Font FONT = new Font("Serif", Font.BOLD, SIZE);
    //Used to keep track of focus
    private static MouseFocus mouseFocus = new MouseFocus();

    //The displayed value
    private Digit digit;
    //Image to display
    private Image image;
    private int width, height;
    //Grid x & y
    private int x,y;
    //One of the numbers in puzzle that can't be changed
    private boolean fixed;
    /**
     * Whether the square is valid
     */
    boolean error;
    /**
     * Bit field for possible
     */
    int possible;
    /**
     * The expected value
     */
    Digit answer;

    /**
     * Move the focus to the next square
     * @return false if it was the last square on the grid
     */
    public boolean focusNext()
    {
        //Default case is next digit
        int xAdd = 1;
        int yAdd = 0;

        //If we are at right of panel
        if (x % 3 == 2)
        {
            //We want to move down instead, and change x to left
            yAdd = 1;
            xAdd = -2;
            //If we are at the bottom of the panel move to the panel at the right
            if (y % 3 == 2)
            {
                yAdd = -2;
                xAdd = 1;
                //If we are at the right edge, go to the panel at the next line
                if (x == 8)
                {
                    xAdd = -8;
                    yAdd = 1;
                }
            }
        }

        //Try and focus (moveFocus returns false is it is unable to move to the next)
        return moveFocus(xAdd,yAdd);
    }

    /**
     * Move focus relative to the current square
     * @param xAdd amount to add to x
     * @param yAdd amount to add to y
     * @return false if out of range
     */
    public boolean moveFocus(int xAdd,int yAdd)
    {
        int newX = x + xAdd;
        int newY = y + yAdd;

        if (newX < 0 || newX > 8 || newY < 0 || newY > 8)
        {
            return false;
        }

        SudokuView.setFocused(newX, newY);

        return true;
    }

    /**
     * Common initializer (for grid and popup)
     */
    private void init()
    {
        fixed = false;
        error = false;
        setForeground(Color.black);
        setBorderPainted(false);
        setRolloverEnabled(true);
        image = getImage(digit);
    }

    /**
     * Create an element on the grid
     * @param digit
     * @param x
     * @param y
     */
    public JDigit(Digit digit,int x,int y)
    {
        this.digit = digit;
        this.x = x;
        this.y = y;
        setPreferredSize(new Dimension(48, 48));
        setBackground(SudokuView.background);
        setAction(new ButtonAction());
        addFocusListener(new FocusHandler());
        addMouseListener(mouseFocus);
        init();
    }

    /**
     * Create a popup element
     * @param digit
     */
    public JDigit(Digit digit)
    {
        this.digit = digit;
        this.x = -1;
        setPreferredSize(new Dimension(32, 32));
        setBackground(SudokuView.popupColor);
        setAction(new PopupAction());
        init();
    }

    /**
     * @return The digit in the cell
     */
    public Digit getDigit()
    {
        return digit;
    }

    @Override
    public String toString()
    {
        return "JDigit{" +
                "digit=" + digit +
                ", possible=" + Digit.fromBits(possible) +
                ", answer=" + answer +
                '}';
    }

    /**
     * Set the possible combinations, and check if the contents match
     * @param possible
     * @return error condition
     */
    public boolean setPossible(int possible)
    {
        this.possible = possible;
        return checkError();
    }

    /**
     * Check if the square changed error state
     * @return error state
     */
    private boolean checkError()
    {
        //So we can check if error state changed
        boolean oldError = error;
        error = false;
        if (digit != Digit.EMPTY)
        {
            //Check if the contents are possible
            if (((1 << digit.value()) & possible) == 0)
            {
                error = true;
            }
            possible = 1 << digit.value();  //Only 1 possible if we have a digit
        }
        //If error state, changed do a repaint with new background color
        if (oldError != error)
        {
            if (error)
            {
                this.setBackground(SudokuView.errorCol);
            }
            else
            {
                this.setBackground(SudokuView.background);
            }
            repaint();
        }
        return error;
    }

    /**
     * Lightweight way of accessing the grid
     * @param digit replacement value
     */
    public void tryDigit(Digit digit)
    {
        this.digit = digit;
    }

    /**
     * Set digit, check for error, repaint
     * @param digit
     */
    public void setDigit(Digit digit)
    {
        //Are we entering a puzzle?
        if (Sudoku.game.isEntering())
        {
            //Fixed square (unless it is 0)
            fixed = digit.value() != 0;
            //Answer is the value we entered
            answer = digit;
            //Set the correct background color
            if (fixed)
            {
                setBackground(SudokuView.fixedCol);
            }
            else
            {
                setBackground(SudokuView.background);
                if (this == SudokuView.focused)
                {
                    setBackground(SudokuView.background.brighter().brighter());
                }
            }
        }
        else
        {
            //If it was fixed value, make sure nothing else caused an error
            if (fixed)
            {
                Sudoku.game.possible();
                checkError();
                return;
            }
        }

        this.digit = digit;
        image = getImage(digit);

        //Check for errors and repaint (if not entering)
        if (!Sudoku.game.isEntering())
        {
            Sudoku.game.possible();
            checkError();
            repaint();
        }
    }

    @Override
    /**
     * Display Digit
     * @param g - Graphics
     */
    protected void paintComponent(Graphics g)
    {
        //Get the width, height and color of the digit
        int w = getWidth();
        int h = getHeight();
        g.setColor(getBackground());
        if (fixed)
        {
            g.setColor(SudokuView.fixedCol);
            if (SudokuView.focused == this)
            {
                g.setColor(SudokuView.fixedCol.brighter().brighter());
            }

Our online experts also explain that Java programming is a portable and robust language, thus making java to remove error like situations by highlighting the compile time error checking and runtime checking. The multithreading features of java enable the user to write programs that can simultaneously perform many tasks.

The students come to us with request like do my Java assignment because we are one the most exhaustive solution providers. The Java programming project help service being provided by our experts ensures a speedy delivery of the homework solution that caters to your needs. The Java homework problems that the students get as part of the various evaluation tests meets with the precise answers by our experts through help with Java assignment. Java is one of the most commonly used programming languages across the globe these days, that is why we have also initiated Java programming assignment help services to imbibe the programming concepts in java amongst the students in the best way possible.

        }
        if (this.error)
        {
            g.setColor(SudokuView.errorCol);
            if (SudokuView.focused == this)
            {
                g.setColor(SudokuView.errorCol.brighter().brighter());
            }
        }
        //If we are dealing with the popup, we want the colors to reflect what is
        //available
        if (x < 0)
        {
            g.setColor(SudokuView.errorCol);
            //Get the original digit, so we can clear it, and regenerate the possibilities
            Digit saveDigit = SudokuView.focused.getDigit();
            SudokuView.focused.tryDigit(Digit.EMPTY);
            Sudoku.game.possible();
            SudokuView.focused.tryDigit(saveDigit);
            //Get the list of possible values
            String digits = Digit.fromBits(SudokuView.focused.possible);
            //If the digit is one of the possibles change the background color from the error
            if (digits.contains(digit.toString()))
            {
                g.setColor(SudokuView.popupColor);
            }
        }
        //Draw the blank square
        g.fillRect(0, 0, w, h);
        //Then draw the number on top
        g.drawImage(image,
                0, 0, w, h,
                0, 0, width, height, null);
    }

One of the defining java features is the Interpreter, which translates the Java byte code into native machine code. One of the other features of java is its high performance that helps us to understand the use of Just-In-Time compilers that enables high performance. Java is distributed because of the distributed environment of the internet. Java is more dynamic than C or C++.

/**

    /**
     * @param digit
     * @return Get the image of the digit
     */
    private Image getImage(Digit digit)
    {
        //Create an image of the digit
        BufferedImage bi = new BufferedImage(
                SIZE, SIZE, BufferedImage.TYPE_INT_ARGB);
        Graphics2D g2d = bi.createGraphics();
        g2d.setRenderingHint(
                RenderingHints.KEY_ANTIALIASING,
                RenderingHints.VALUE_ANTIALIAS_ON);
        g2d.setColor(this.getForeground());
        g2d.setFont(FONT);
        FontMetrics fm = g2d.getFontMetrics();
        width = fm.stringWidth(digit.toString());
        height = fm.getAscent();
        g2d.drawString(digit.toString(), 0, height - BASE);
        g2d.dispose();
        return bi;
    }

    /**
     * Swap 2 squares around used in shuffle
     * @param other
     */
    void swap(JDigit other)
    {
        Digit save = this.digit;
        this.digit = other.digit;
        other.digit = save;
        save = answer;
        answer = other.answer;
        other.answer = save;
        Image saveImage = image;
        image = other.image;
        other.image = saveImage;
    }

    /**
     * Display popup grid
     */
    private class ButtonAction extends AbstractAction
    {
        //@Override
        public void actionPerformed(ActionEvent e)
        {
            if (fixed) return;
            if (Sudoku.game.isCompleted()) return;
            SudokuView.popup.show(JDigit.this,  width/2 -getWidth(), -getHeight() + height/4);
            SudokuView.popup.requestFocus();
        }
    }

    /**
     * Select digit from popup
     */
    private class PopupAction extends AbstractAction
    {
        //@Override
        public void actionPerformed(ActionEvent e)
        {
            SudokuView.popup.setVisible(false);
            SudokuView.focused.setDigit(digit);
            Sudoku.game.possible();
            checkError();
            if (Sudoku.game.isEntering())
            {
                if (!SudokuView.focused.error)
                {
                    if (!SudokuView.focused.focusNext())
                    {
                        Sudoku.game.finishEntering();
                    }
                }
            }
            //See if we solved the game
            SudokuView.checkSolved();
        }
    }

    /**
     * Select the grid element under the cursor
     */
    private class FocusHandler implements FocusListener
    {

        private Color background = getBackground();

        //@Override
        public void focusGained(FocusEvent e)
        {
            setBackground(background.brighter().brighter());
            SudokuView.focused = JDigit.this;
            //If focused changed, then disable the popup
            SudokuView.popup.setVisible(false);
            Sudoku.game.possible();
            checkError();
            JDigit.this.repaint();
        }

        //@Override
        public void focusLost(FocusEvent e)
        {
            if (e.getComponent() == SudokuView.focused)
            {
                if (SudokuView.focused.fixed)
                {
                    setBackground(SudokuView.fixedCol);
                }
                else

Java programs are used to verify and resolve accesses to objects on run-time that carries extensive amount of run-time information. Our experts offer quality help with Java programming homework. Our experts who offer java programming assignment help provide simple as well as complex solutions depending upon the difficulty level of the question.

                {
                    setBackground(SudokuView.background);
                }
            }
            else
            {
                setBackground(background);
            }
            JDigit.this.repaint();
        }
    }
}

Digit.java

import java.util.EnumSet;

/**
 * Created with IntelliJ IDEA.
 * Date: 5/31/13
 * Time: 9:11 PM
 */

/**
 * The possible values for digit
 */
enum Digit
{

    EMPTY(0, " "), ONE(1, "1"), TWO(2, "2"), THREE(3, "3"), FOUR(4, "4"),
    FIVE(5, "5"), SIX(6, "6"), SEVEN(7, "7"), EIGHT(8, "8"), NINE(9, "9");
    /**
     * The valid digits for the game
     */
    public static EnumSet<Digit> digits = EnumSet.range(Digit.ONE, Digit.NINE);
    //From bit mask to Digit (if only 1 bit is set, otherwise it returns EMPTY
    private static Digit masks[] = new Digit[1024];
    //The possible values as a string
    private static String valid[] = new String[1024];

    static
    {
        //Construct the masks and valid arrays
        for (int mask = 0; mask < 1024; mask++)
        {
            masks[mask] = Digit.EMPTY;
            String chars = "";
            for (Digit digit : digits)
            {
                if ((mask & (1 << digit.value())) != 0)
                {
                    chars += digit;
                }
            }
            valid[mask] = chars;
        }
        for (Digit digit: digits)
        {
            masks[1 << digit.value()] = digit;
        }
    }

    private int i;
    private String s;

    Digit(int i, String s)
    {
        this.i = i;
        this.s = s;
    }

    @Override
    public String toString()
    {
        return s;
    }

    public int value()
    {
        return i;
    }

    /**
     * Get the next value after this digit, loops round back to 1
     * @return next digit in sequence
     */
    public Digit next()
    {
        int nextIndex = (ordinal()+1) % values().length;
        if (nextIndex == 0) nextIndex++;
        return values()[nextIndex];
    }

    /**
     * Converts bitfield value
     * @param val bitfield of possible values
     * @return digit bitfield corresponds to if only 1 value
     */
    public static Digit fromMask(int val)
    {
        return masks[val];
    }

    /**
     * Converts bitfield into a string representation
     * @param val bitfield
     * @return digits corresponding to the bitfield
     */
    public static String fromBits(int val)
    {
        return valid[val];
    }

}

XYDigit.java

/**
 * Created with IntelliJ IDEA.
 * Date: 6/1/13
 * Time: 2:54 PM
 */

/**
 * So I can return multiple values to Hint
 */
public class XYDigit
{
    int x, y;
    Digit digit;
}

PickDigit.java

import javax.swing.*;
import java.awt.*;

/**
 * Created with IntelliJ IDEA.
 * Date: 5/31/13
 * Time: 9:12 PM
 */

/**
 * Used to provide the Popup controls
 */
class PickDigit extends JPanel
{
    PickDigit(Digit digit)
    {
        this.setLayout(new BorderLayout());
        this.setBorder(BorderFactory.createLineBorder(Color.black, 1));
        this.setBackground(SudokuView.background);

        JDigit cellValue = new JDigit(digit);
        add(cellValue, BorderLayout.CENTER);
    }
}

Java applets are a kind of web application that appear on a web page in a dynamic and interactive manner. Java applets can be used for creating animations, figures, games, etc, creating applet in Java, compiling it using a Java compiler, and then submit the applet in the HTML Web pages. Then the resulting HTML and Java files are put on a web site in the same way as the ordinary HTML and image files are available.

SelectAction.java

import javax.swing.*;
import java.awt.event.ActionEvent;

/**
 * Created with IntelliJ IDEA.
 * Date: 5/31/13
 * Time: 9:12 PM
 */
class SelectAction extends AbstractAction
{

    private Digit digit;

    public SelectAction(Digit digit)
    {
        this.digit = digit;
        this.putValue(Action.NAME, digit.toString());
    }

    //@Override
    public void actionPerformed(ActionEvent e)
    {
        if (Sudoku.game.isCompleted()) return;
        SudokuView.focused.setDigit(digit);
        SudokuView.popup.setVisible(false);
        if (Sudoku.game.isEntering())
        {
            if (!SudokuView.focused.error)
            {
                if (!SudokuView.focused.focusNext())
                {
                    Sudoku.game.finishEntering();
                }
            }
        }
        else
        {
            SudokuView.checkSolved();
        }
    }
}

PickDigit.java

import javax.swing.*;
import java.awt.*;

/**
 * Created with IntelliJ IDEA.
 * Date: 5/31/13
 * Time: 9:12 PM
 */

/**
 * Used to provide the Popup controls
 */
class PickDigit extends JPanel
{
    PickDigit(Digit digit)
    {
        this.setLayout(new BorderLayout());
        this.setBorder(BorderFactory.createLineBorder(Color.black, 1));
        this.setBackground(SudokuView.background);

        JDigit cellValue = new JDigit(digit);
        add(cellValue, BorderLayout.CENTER);
    }
}

MouseFocus.java

import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

/**
 * Created with IntelliJ IDEA.
 * Date: 5/31/13
 * Time: 9:12 PM
 */
class MouseFocus implements MouseListener
{
    public void mouseClicked(MouseEvent e) {
    }

    public void mouseEntered(MouseEvent e) {
        e.getComponent().requestFocus();
    }

    public void mouseExited(MouseEvent e) {
    }

    public void mousePressed(MouseEvent e) {
    }

    public void mouseReleased(MouseEvent e) {
    }
}

KeyAction.java

import javax.swing.*;
import java.awt.event.ActionEvent;

/**
 * Created with IntelliJ IDEA.
 * Date: 5/31/13
 * Time: 9:12 PM
 */

/**
 * Used to provide cursor control of the focused square
 */
class KeyAction extends AbstractAction
{
    int xAdd;
    int yAdd;

    public KeyAction(int xAdd,int yAdd)
    {
        this.xAdd = xAdd;
        this.yAdd = yAdd;
    }

    //@Override
    public void actionPerformed(ActionEvent e)
    {
        if (SudokuView.focused.moveFocus(xAdd,yAdd))
        {
            SudokuView.popup.setVisible(false);
        }
    }
}

ButtonPress.java

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

/**
 * Created with IntelliJ IDEA.
 * Date: 5/31/13
 * Time: 9:12 PM
 */

/**
 * Handle buttons
 */
class ButtonPress implements ActionListener
{
    public void actionPerformed(ActionEvent e)
    {
        String cmd = e.getActionCommand();
        //System.out.println(cmd);
        if (cmd == "Hint")
        {
            if (Sudoku.game.isCompleted()) return;
            //Try hard to solve the problem
            if (!Sudoku.game.hint(true,true))
            {
                //Unable to find a solution
                SudokuView.unableToSolve();
            }
            SudokuView.checkSolved();

            return;
        }
        if (cmd == "Solve")
        {
            if (Sudoku.game.isCompleted()) return;
            //This calls hint multiple times to solve the problem
            if (!Sudoku.game.solve())
            {
                SudokuView.unableToSolve();
            }
            SudokuView.checkSolved();

            return;
        }
        if (cmd == "Reset")
        {
            if (Sudoku.game.isEntering())
            {
                Sudoku.game.start("Enter Puzzle");
                return;
            }
            //if (Sudoku.game.isCompleted()) return;
            //Reset the puzzle back to the default
            Sudoku.game.reset();
            return;
        }
        if (cmd == "Help")
        {
            //Display instructions
            Sudoku.game.help();
            return;
        }
        if (cmd == "Quit")
        {
            //Exit the program
            SudokuView.display.dispose();
            System.exit(0);
            return;
        }
        //Easy,Medium,Hard or Enter Puzzle
        Sudoku.game.start(cmd);
    }
}

CompleteDialog.java

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

/**
 * Created with IntelliJ IDEA.
 * Date: 5/31/13
 * Time: 9:12 PM
 */
class CompleteDialog extends JDialog implements ActionListener
{
    /**
     * Display dialog
     * @param parent Where will we add it to
     * @param title Dialog title
     * @param message Contents
     */
    public CompleteDialog(JFrame parent, String title, String message)
    {
        super(parent, title, true);
        if (parent != null)
        {
            Dimension parentSize = parent.getSize();
            Point p = parent.getLocation();
            setLocation(p.x + parentSize.width / 4, p.y + parentSize.height / 4);
        }
        JPanel messagePane = new JPanel();
        messagePane.add(new JLabel(message));
        getContentPane().add(messagePane);
        JPanel buttonPane = new JPanel();
        JButton button = new JButton("OK");
        buttonPane.add(button);
        button.addActionListener(this);
        getContentPane().add(buttonPane, BorderLayout.SOUTH);
        setDefaultCloseOperation(DISPOSE_ON_CLOSE);
        pack();
        setVisible(true);
    }

    public void actionPerformed(ActionEvent e)
    {
        setVisible(false);
        dispose();
    }
}

Why we are regarded as the best in the field of offering Java programming assignment help

We have been providing java assignment help to students all across the world for the last decade. So we have valuable experience in this domain. We have made a name for ourselves over the years by providing an incomparable and unique service to students in diverse locations. We strive to offer nothing but the best java homework solutions which guarantees top grades to our clients.

Many students across the world can now rest easy knowing that we are available at their convenience to save them from assignment anxiety. Numerous students have written back to us acknowledging the awesome work we are doing. Feel free to visit our testimonial page and read some of the reviews we get from our clients. Our java coursework help service comes second to none. We always deliver exactly what we promise. Many students in countries such as Australia, Canada, UK, USA, Malaysia, Singapore, and The Middle East have put full confidence in us with their academic papers. They know we mean business and would never let them down. That is why they consistently write their assignments with us and always recommend us to their friends.

Every day we receive messages such as “do my java assignment” and “do my java project” from our clients. They know that they can depend on us to deliver an impeccable service. Do not wander around the internet searching for a trustworthy assignment writing service provider. Join the thousands of students who have reaped great academic benefits from writing with us. Getting our service is a simple process and wouldn’t take much of your time. Just follow the steps below and you will be set:

  1. Fill in the submission form – Visit our homepage and submit all the details required on the form. You should also include a detailed guideline of the requirements you want met in your assignment. Our experts will consider all your requirements when crafting your content. They will also cite all the sources they have used as required and use your preferred referencing style.
  2. Delivery of quote – To come up with the amount you are supposed to pay, our experts will go through the questions you have submitted to establish the amount of time it will take to draft a quality content, the date you want your assignment to be delivered, and the intricacy level of your assignment. All these factors will be considered when coming up with a quote. We will then send the quote to your inbox  for you to make payments
  3. Payment – You can make your payment through any of the payment methods our service subscribes to. We accept payments from PayPal and all international credit/debit cards.
  4. Receive an exceptional content from our experts in your inbox – Once we have received your payment, our experts will start work on your assignment. They will do everything necessary to ensure your work meets all your guidelines to the latter.

We have very friendly customer support executives who can assist you with this whole process in case you run into a problem All you have to do is send them an email or just type “do my java homework” on our java programming help chat facility. They will get back to you immediately and clear all your qualms. You do not have to worry about your location. You can get java tutor online from us in any part of the globe.  We have a java experts online chat platform where all your java assignments and homework can be solved. Our services will answer your “do my programming homework” question and provide you with the following benefits:

  • Top-grades – In the long run it is only top grades that count for students. It will be a waste of time for a student to put in much effort on an assignment but still end up failing. We save you from going back and forth by guaranteeing top grades for your tasks. The solutions we provide are the best and do not have errors. Your work is drafted by experts who are well-versed with all the requirements of a perfect assignment. Our panel of experts also consists of ex-professors who have taught and participated in marking Java programming assignments. They will only send you exemplary solutions that will leave a mark on your professor.
  • Delivery on time – Nothing frustrates a student more than an upcoming deadline. Most students procrastinates tasks and only try to complete them in the last minute. There is a big possibility that you will not be able to write a magnificent content when you are under pressure and anxious. Send us your assignment when it is allotted and save yourself from the panic attacks and loss of sleep that comes when you realize that the date of submission is fast approaching and you haven’t done your homework. We are capable of managing all your deadlines and delivering your content on the agreed date. No deadline is too tight for us to meet. If we feel that we need more time then we will tell you in advance before accepting your task. If you are too anxious and want to confirm the status of your assignment then visit our site and use our assignment tracking facility.
  • Zero-plagiarism – universities and colleges all around the world do not tolerate any form of plagiarism. We know that sometimes the assignment can be so complex that the only chance you may have in completing it is by copying online. Some students also do not have the plagiarism-checker software that generates plagiarism report about your content. Writing your assignment with us is therefore the best option for you. All the content we write are unique and crafted from scratch. In case we use a resource in your content, we will write it as a reference as required. We are very strict when it comes to plagiarism because we do not want to put your degree program in jeopardy. That is why we cross-check the content using Turnitin software to ensure it has no traces of plagiarism. If you are in doubt then you can request for a free report on your content.
  • We save you money – Our services are cheap compared to hiring an offline tutor to assist you with your assignment. We are available online and our clients do not have to incur travelling costs when going to meet the offline tutor. We also offer the best rates compared to other online assignment writing providers. We are not like other sites that are just doing it for the money. We have built a strong bond with our clients and really care about them. That is why we give them full value for their money by providing them with a quality service at a very fair rate. We also offer discounts to our repeat clients as a complementary service.
  • Free rework on all the content that we write – We can modify and make changes to your content when you need a rework. We offer this service for free and wouldn’t charge you extra fees. However, the changes must be in line with the guidelines you had submitted together with your assignment. If you make any changes to the guidelines then you will be charged for the service.