A. Getting started

In this first part, we will set up your computers to use Java. A first important tool to have whenever you start coding is a good text editor. A good choice is sublime text

A.1. If you are on Windows, follow the instructions below

Start by going to the Oracle website and download the Java Development Kit. Follow the link “JDK download” as shown below

Download the windows x64 installer and accept the license

You should be good to run the installation

Once you are done with the Java installation, proceed through the following steps to install git:

Go to the git website and download the latest version of git for windows

Download the windows x64 installer and accept the license

You should be good to run the installation

A.2. If you are on Mac, follow the instructions below.

Start by installing homebrew. You can do this from the terminal. You can use brew doctor to check that brew is correctly installed. You might encounter minor warnings which is not a problem. If you encounter a warning that requires you to download command line tools you might want to check the following post

Once you are done with homebrew, you can proceed with the installation of the latest jdk. This can be done from the terminal by using the line below (‘java’ will install the latest version by default)

$ brew install java

After the installation, you might be facing the following recommendations. You can just apply those recommendations.


########################################################################## 100.0 %
==>
==>
For the system Java wrappers to find this JDK, symlink it with
  sudo ln -sfn /usr/local/opt/openjdk/libexec/openjdk.jdk /Library/Java/JavaVirtualMachines/
openjdk.jdk

openjdk is keg-only, which means it was not symlinked into /usr/local,
because it shadows the macOS `java` wrapper.

If you need to have openjdk first in your PATH run:
  echo 'export PATH="/usr/local/opt/openjdk/bin:$PATH"' >> ~/.zshrc

For compilers to find openjdk you may need to set:
  export CPPFLAGS="-I/usr/local/opt/openjdk/include"

Check that the installation is complete by copying the following line

$ javac -version

You can conclude and install git with the following line

$ brew install git

To check whether git is properly installed, you can use the following line

$ git --version

A.3. If you are on Linux, follow the intstructions below

On Linux, you can install both the JDK and git using the following one line command

$ sudo apt install openjdk-14-jdk git

B. A couple more steps..

Now that you are set up with Java and git, you will learn how to get access to the labs through github. If you do not already have one, start by opening a github account. You might also want to check that your git installation was done correctly by typing the following command

$ git --version

In order to use the repository with git, you need to intialize this repository as a git repository
Create a directory (you can put it on your desktop) and call it ‘CSCIUA9102‘. Once you have the directory, initialize it as a git repository with
```
$ git init
```
Now that your directory is set up, we will try a couple of the git commands. In the git repository, create two files, let’s say file1.txt and file2.txt. Each of those files should contain a version number. I.e the first line should be version1. Github works with two respositories. A remote repository (where the labs are going to be posted) and a local copy of that repository (the copy you have on your desktop). When making changes to your files locally, you will keep track of your changes through the command ‘git commit‘. Once you have edited the content of a file, for example file1.txt, you need to first prepare this file (i.e. move them to the stagging area) for the next commit which will keep track of the changes you made so that you can then share those changes with your other collaborators online. This can be done through the following lines
```
$ git add file1.txt

$ git commit -m "your legend"
```
You can also use the following lines which will stage all files in the entire repo and then commit
```
$ git add .

$ git commit -m "your legend"
```
You should obtain something like this
```
$ git commit -m "updated file1"

[master 2e339aa] updated file1
2 files changed, 2 insertions(+), 1 deletion(-)
create mode 100644 file2.txt
$ 
```

Modify any of the two files. For example, update file2 to version 2. Then type the following command
```
$ git status 
```
If you have modifications that haven’t been staged and commited, git status will point them to you and you should see something like the lines below
```
 $ git status
On branch master
Changes not staged for commit
    (use "git add ..." to update what will be committed)
    (use "git checkout -- ..." to discard changes in working directory)

       modified: file2.txt

no changes added to commit (use "git add" and/or "git commit -a")
 
```
If everything has been staged and commited properly you should get something like this instead
```
 $ git status
On branch master
nothing to commit, working tree clean
```
Now another very nice feature of git is that it enables you to recover your last commit. In particular, you can try getting back to a previous version of the file (provided you haven’t committed yet) through the following command
```
 $ git checkout -- file2.txt
```

Now that you are comfortable with the local aspects of github, we will look at how it really leverages the file sharing experience. The first thing you should do now is send an email to the address ‘CSCIUA9102Students@gmail.com’ with (1) your github username and (2) your NYU campus ID (the number is of the form Nxxxxxxx). As a result to this step, you will be given access to a repository of the form https://github.com/CSCI-UA9102-Students/Nxxxxxxx where the x should be replace by your campus ID. You should then be able to proceed with the next few steps.
Start by cloning the repository. To do this first navigate to the spot where you want that repository to be stored on your laptop and once you are there, use the following line in the terminal
```
 $ git clone https://github.com/CSCI-UA9102-Students/Nxxxxxxx.git 
```
That will create a local copy of the ‘Nxxxxxxx’ repo on your laptop. This repository is the repository in which you will store and submit your assignments.
Then you can add the repo of the course (note that when typing this command, you must be located in your )
```
 $ git remote add DSmain https://github.com/acosse/DataStructures2021.git 
```
This repository is the one from which you will pull to access the assignments for the course.
If you have implemented the previous steps correctly, you should now be able to see a origin repository and the DSmain repository. You can check this by typing the following command
```
 $ git remote -v
```
Now that you have a copy of the course repository, you can pull whatever files are stored in this directory using
```
 $ git pull DSmain master
```
You should do this regularly (especially once a new assignment has been posted to make sure you are up to date with all the modifications). You should now see the content of the DataStructures2021 repository including a ‘lab1’ folder.
You can start completing the files from the lab1 subfolder. Once you have made some modifications, you can update your repository (i.e Nxxxxxxx) by adding (the whole lab1 subfolder or whatever files you modified), commiting and then pushing:
```
$ git add lab1/*
$ git commit -m "whatever modifications you made"
$ git push origin master
```
Again, you should do this regularly to make sure to backup your work (especially on the assignments)

The remaining items below deal with the submission of the assignments

In addition to your submission on github, you will be required to submit your assignments through Gradescope . You sign up fo free with your NYU email but you should also be able to access Gradescope through NYU Classes. Once on NYUClasses or on gradescope, you should look for the course “CSCI-UA 9102: Data Structures, Spring 2021” and then register on Gradescope for this particular course. You might be asked for an Entry Code. If so you can use 74EZ73.

Once you have access to GradeScope, you should be able to find, by following the link to the CSCI-UA9102 course, the first assignment (Assignment 1). You should then be able to submit your solutions. Guidelines for homework submission can be found here. Ideally you should submit your work via your github repository as shown below (specifying as repository your https://github.com/users/CSCI-UA9102-Students/Nxxxxxxx and as branch, the master branch). Do not panic if you can’t proceed with the submission through github, you also have the possibility to submit your java file manually (although the former option is preferred).

If you access directly through Gradescope, you should see something similar to what is shown below. From this you can register by using the course code 74EZ73 together with your email address.

Once you are logged in, your display should look like the capture below. Click on the course

Once you have joined the course you should be able to see the existing assignments. In particular, you can see how much time is left before the submission deadline.

Click on the assignment. You will then see the a window similar to the one below. You see that you can upload

Finally if you select to submit through github, the following window should pop up. As indicated above, you can then provide the address of your repository on https://github.com/users/CSCI-UA9102-Students/Nxxxxxxx and specify ‘master’ as the branch.

C. Exercise 1

In this first part, we will review the basic concepts of Java (including classes and objects, constructors, the main method, strings,…)

Navigate through your preferred directory or create a directory with the commands cd, mkdir, ls,..

Once you are in your working directory, open sublime text and save the following java program as program1.java

// Your First Program

class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!"); 
    }
}

Use javac (pronounce java-see), i.e the java compiler from the jdk, to compile your script from the terminal. Then use ls (list) to visualize the content of the directory. You should now see two files, A HelloWorld.class file and your original HelloWorld.java file.
```
$ ls
HelloWorld.class      HelloWorld.java 
```
You can now run the compiled file with
```
$ java HelloWorld 
```
If everything was correctly installed, you should get the following result:
```
$ java HelloWorld 
Hello World!
```

Exercise 1.1.

In this first part, we will review the basic concepts of Java (including classes and objects, constructors, the main method, strings,…)

Write a short java method that counts the number of vowels in any given string

Write a program that displays the word “HI” in large block letters. Make each large letter out of the other character as shown below:

Write a short java method that takes an integer n and returns the sum of the squares of all positive integers less than or equal to n

Write a short java method that takes an integer n and returns the sum of the squares of all the odd positive integers less than or equal to n

Write a program that prompts for and reads two integers representing the length and breadth of a rectangle, then prints its perimeter and area.

Using the java.util.Random class, write a program that creates and prints a random phone number of the form XXX–XXX–XXXX. Include the dashes in the output. Do not let the first three digits contain an 8 or 9 (but don’t be more restrictive than that), and make sure that the second set of three digits is not greater than 655. Hint: Think through the easiest way to construct the phone number. Each digit does not have to be determined separately.

Exercise 1.2.

Write a public class with public constructor but a static variable. Then create several object of this class and modify the variables through the different objects. Print the resulting value after each modification.

Write a Java program to create a class called “Person” with a name and age attribute. Create two instances of the “Person” class, set their attributes using the constructor, and print their name and age.

Write a class called NumberOfGoals that represents the total number of goals scored by a football team. The NumberOfGoals class should contain a single integer as instance data, represent- ing the number of goals scored. Write a constructor to initialize the number of goals to zero. Write a method called setGoal that increments the value by one whenever a goal is scored, and another method called getGoal that returns the total num- ber of goals scored so far. Finally, create a driver class called GoalTracker that creates a few NumberOfGoals objects and tests their methods.

Write a class called Laptop that contains instance data for the laptop model, make, purchaser, and purchase year. Define the Laptop constructor to accept and initialize this data. Include setter and getter methods for all instance data. Include a toString method that returns a nicely formatted, multi-line description of the laptop purchase. Create a driver class called LaptopRecords whose main method instantiates and updates several Laptop objects.

Write a class called Course that represents a course offered to students. It should contain instance data that represents the course title, course code, credits and course Instructor’s name. Define the Course constructor to accept and initialize all instance data. Include getter and setter methods for all instance data. Include a toString method that returns a one-line description of the course. Create a driver class called CourseDetails whose main method instantiates and updates several Course objects.

Write a Java program to create a class called “Rectangle” with width and height attributes. Calculate the area and perimeter of the rectangle.

Write a Java program to create a class called “School” with attributes for students, teachers, and classes, and methods to add and remove students and teachers, and to create classes.

Write a complete Java program that simulates the rolling of a pair of dice. For each die in the pair, the program should generate a random number between 1 and 6 (inclusive). It should print out the result of the roll for each die and the total roll (the sum of the two dice), all appropriately labeled. You must use the Random class