::::::::::::::
Question01.java
::::::::::::::
/**
 * LABTEST 2 (PRACTICE) - EECS1710, F2018
 * 
 * 
 * FIRST NAME:	XXXXXXXXXXXXXXXXXXXXX
 * LAST NAME:	YYYYYYYYYYYYYYYYYYYYY
 * LOGIN:		ZZZZZZZZZ
 * 
 * SID:			SSSSSSSSS
 * 
 * 
 *
 */


// QUESTIONS TO ANSWER + INSTRUCTIONS ARE IN MAIN METHOD BELOW

public class Question01 {

	
	
	// This method will print out a 2D array (DO NOT MODIFY)
	public static void printGrid(int[][] grid, int m, int n) {

		// This method will print out the m x n array 
		// DO NOT CHANGE THIS METHOD
		
		for (int i=0; i < m; i++) {			// iterates over rows
			
			for (int j=0; j < n; j++)  {	// iterates over columns
				
				System.out.printf("%5d",grid[i][j]);	// there was a typo here (missing grid[i][j])

			}
			System.out.println();
		}
	
	}
	
	
	// This method is for part 1b - you need to modify and complete it
	public static int sumColumn(int[][] grid, int col) {
		
		int sum = 0;
		
		
		// COMPLETE THIS METHOD (for Part 1b)
		
		int M = grid.length;		// extracts first dimension
		int N = grid[0].length;		// extracts second dimension
		
		for (int i=0; i<M; i++) {
			
			// only need a single loop actually (col is fixed)
			// you may use a nested loop, if so, then the following should be wrapped in an if statement
			
			sum += grid[i][col];
			
			// if you use nested loop, omit the statement above, and replace it with this:
			
//			 		for (int j=0; j<N; j++) { 
//			 			if (j==col) { 
//							sum += grid[i][j]; 
//						}
//					}
			
		}
		

		
		return sum;
		
	}

	
	

	public static void main(String[] args) {

		// *************************************************************************
		// TASK 1a: [5 marks]
		//
		// Declare and initialize a 2D array of integers called "myGrid"
		// 
		// The size of the array is given by the constants M and N (defined below)
		//
		// Initialize the array (at declaration or with a loop) such that each
		// of the positions of the array are assigned unique integers starting
		// from 1, and incrementing by 1 up to the value M*N.  
		//
		// Here is an example of the expected output when printed using the printGrid
		// method (provided for you):
		//
		// myGrid = 
		// 
		//     1    2    3    4    5
		//     6	7	 8    9	  10
		//    11   12   13   14   15
		//    16   17   18   19   20
		//
		// 
		// 
		
		final int M = 4;
		final int N = 5;
		
		
		// CODE FOR 1(a) GOES HERE
		
		// approach 1: hardcode
		
//		int[][] myGrid = { 	{	 1, 2, 3, 4, 5 	}, 
//							{	 6, 7, 8, 9,10	},
//							{	11,12,13,14,15	},
//							{	16,17,18,19,20  }
//						 };
		
		// Using constants:
		int[][] myGrid = new int[M][N];
		int val=1;
		
		for (int i=0; i<M; i++) {
										// i varies across rows (0-M), going top to bottom
			for (int j=0; j<N; j++) {
				
				myGrid[i][j] = val;		// j varies across cols (0-N), going left to right
				val++;
			}
		}
		
		
		
		
		System.out.println("\nPart 1a:\n");
		System.out.println("myGrid = \n\n");
		
		// call to printGrid method (outputs myGrid)
		// note printGrid should NOT be modified!
		
		printGrid(myGrid, M, N);			
		
		
		
		// *************************************************************************
		// TASK 1b: [5 marks total]
		//
		// Complete the method "sumColumn(int grid, int col)" at the top of this file, 
		// by writing a loop to find the sum of all the elements in a 2D array
		// that are in the column specified by "col".
		//
		// e.g. if col=2, then only the numbers denoted by '*' (shown below) 
		// would be added in the sum 
		//
		// myGrid = 
		// 
		//     1    2    *    4    5
		//     6	7	 *    9	  10
		//    11   12    *   14   15
		//    16   17    *   19   20
		//
		//
		// If you could not do 1(a), create another MxN array "myGrid" for this part
		// with any values you wish
		
		int col = 2;
		
		
		// CODE FOR 1(b) GOES IN METHOD sumColumn defined at top of this file
		// CODE GOES THERE, NOT HERE!!
		
		
		int sumCol = sumColumn(myGrid, col);
		
		System.out.println("\nPart 1b:\n");
		System.out.println("The sum of elements in column " + col + " of myGrid = " + sumCol);
		System.out.println();
		
		
		
		// *************************************************************************
		// TASK 1c: [5 marks total]
		//
		// Modify the elements in myGrid (using a loop), so that the following
		// is printed to the screen by the printGrid() method
		//
		// DO NOT MODIFY THE printGrid() METHOD !!
		// Only modify how you set the values for the myGrid array
		//
		// myGrid = 
		// 
		//     1    5    9   13   17
		//     2	6	10   14	  18
		//     3    7   11   15   19
		//     4    8   12   16   20
		//
		//
		
		
		// CODE FOR 1(c) GOES HERE
		
		val = 1;
		for (int j=0; j<N; j++) {
			for (int i=0; i<M; i++) {
				
				myGrid[i][j] = val;			// vary i faster than j, thus will traverse array 
				val++;						// down each row before the next column
				
			}
		}
		
		
		
		
		System.out.println("\nPart 1c:\n");
		System.out.println("myGrid = \n\n");
		
		printGrid(myGrid, M, N);
		
		
		

	}

}
::::::::::::::
Question02.java
::::::::::::::

/**
 * LABTEST 2 (PRACTICE) - EECS1710, F2018
 * 
 * 
 * FIRST NAME:	XXXXXXXXXXXXXXXXXXXXX
 * LAST NAME:	YYYYYYYYYYYYYYYYYYYYY
 * LOGIN:		ZZZZZZZZZ
 * 
 * SID:			SSSSSSSSS
 * 
 * 
 *
 */

import java.lang.Math;

import java.util.Scanner;
import java.io.PrintStream;
import java.util.ArrayList;



//QUESTIONS TO ANSWER + INSTRUCTIONS ARE IN MAIN METHOD BELOW

public class Question02 {



	public static void main(String[] args) {

		
		System.out.println("QUESTION 2:");
		System.out.println("============");

		
		
		
		
		// *************************************************************************
		// TASK 2a: [5 marks total]
		
		System.out.println();
		System.out.println("TASK 2(a):");
		System.out.println("============");

		
		// Assume that we have the following sentence (stored as a String):

		String sentence1 = "the slow green tortoise is frisky";
		

		// create an ArrayList (of Strings)  called "words1" that holds each of the 
		// words contained in sentence1 (populate your ArrayList with individual 
		// words from sentence1 in the same order as shown above).  
		//
		// you may initialize this manually by adding the words explicitly to an 
		// empty ArrayList. 
		
		
		// YOUR CODE FOR PART 2(a) GOES BELOW
		
		// ArrayList<> words1 = 
		
		// ===========================================================================
		// SINCE THIS QUESTION ASKS YOU TO USE ARRAYLIST (WHICH WE HAVENT LEARNED YET)
		// I WILL PROVIDE A SOLUTIONS ARE GIVEN IN TERMS OF ARRAYS ONLY!
		// ===========================================================================
		
		String [] wordsScanned = new String[100];		// dont know how many words, so lets allow for 100
														// can trim after
		
		int i=0;	// index of next word
		Scanner inSentence1 = new Scanner(sentence1);		// scanner to read individual words

		while (inSentence1.hasNext()) {
			wordsScanned[i] = inSentence1.next();			// get next word from scanner
			i++;											// increment index (very important!!)
		}
		
		// no hasNext(), so must be done, current value of i lets us know how many words read
		// copy only words scanned to create words1
		
		String [] words1 = new String[i];			// there are i words!
		
		for (int j=0; j<i; j++) {
			words1[j] = wordsScanned[j];
			System.out.println("words1[" + j + "] = " + words1[j]);  // question does as for output
		}
		
		// now words1 has the words from the input sentence 
		// note:  Using ArrayLists (which we will learn, grows an array as we add to it, so 
		// 			makes the solution to this question much simpler
				
		
		
		
		// *************************************************************************
		// TASK 2b: [5 marks total]
		
		System.out.println();
		System.out.println("TASK 2(b):");
		System.out.println("============");

		
		
		// output the words in your ArrayList (each on a separate line) using a loop.
		// for each word, automatically determine whether the word starts with a 't' 
		// and indicate this by printing an asterisk '*' next to the word (as shown below)
		//
		// e.g. output:
		//
		// words1[0] = the *
		// words1[1] = slow
		// words1[2] = green
		// words1[3] = tortoise *
		// words1[4] = is 
		// words1[5] = frisky
		
		
		// YOUR CODE FOR PART 2(b) GOES BELOW
		
		
		for (int k=0; k<words1.length; k++)  {
			
			System.out.print("words1[" + k + "] = " + words1[k]);
			
			// words1[k] is a String, so charAt(x) method will get xth character
			
			if (words1[k].charAt(0) == 't') {
				System.out.println(" *");
			}
			else {
				System.out.println();		
			}
			
			
		}
		
		
		
				
				
				
		// ************************************************************************		
		// TASK 2(c):		[5 marks]
		
		System.out.println();
		System.out.println("TASK 2(c):");
		System.out.println("============");
		
		
		// Assume we also have the following sentence
		
	    String sentence2 = "the quick brown tortoise jumped over the lazy hare";
				
		//
	    // A Scanner object can be connected and used on any of the following:
	 	//	==> Keyboard input - i.e. System.in
	 	//	==> File input - i.e. a File that has been opened
	 	//	==> String input - i.e. a String that has been created or read from keyboard

	 	// once Scanner is connected to one of these, it can be used in a
	 	// standard way i.e. using hasNext(), hasNextInt(), next(), nextInt() 
	 	// or nextDouble() methods etc.
		
		Scanner inSentence2 = new Scanner(sentence2);

		
		// Using the above Scanner object, write a while loop to automatically (not
		// manually) scan and add each word from sentence2 into a new ArrayList object
		// called "words2".  Words should only be added if they do not exist in
		// the "words1" ArrayList.
		//
		// Output the ArrayList "words2" to the screen (use similar format as used in
		// part 2(b))
		//
		// [Hint: While not needed to do this task, the contains() method defined 
		//	in the ArrayList API will make it much easier]
		//
		
		
		// YOUR CODE FOR PART 2(c) GOES BELOW
		
		boolean done = false;
		
		String [] words2 = new String[words1.length];	// words2 is at least the length of words1
		int numWords2 = 0;
		
		String nextWord;
		
		while (!done) {
			
			// the solution for this is much simpler with Arraylist, however a solution
			// using Arrays is shown below
			
			if (!inSentence2.hasNext()) {
				done = true;
			}
			else {
				nextWord = inSentence2.next();
				
				// for each word extracted , check if it exists in words1
				boolean wordExistsInWords1 = false;
				for (int currWord=0; currWord<words1.length; currWord++) {

					if (words1[currWord].equals(nextWord)) 
						wordExistsInWords1 = true;
				}
				
				if (wordExistsInWords1) {
					words2[numWords2] = nextWord;
					numWords2++;
				}
				
			}	
			
		}
		
		// output words2
		for (int t=0; t<numWords2; t++) {
			System.out.println("words2[" + t + "] = " + words2[t]);
		}
		
	

		
		
		
	
		
		
		
		
		
		

	}

}