├── .gitignore
├── recursion
    ├── how-to-think-recursively
    ├── Program.java
    └── IO.java
├── objects
    ├── Trainer.java
    ├── Pokemon.java
    ├── Student.java
    ├── Program.java
    └── IO.java
├── README.md
└── arrays
    ├── TwoDim.java
    ├── Program.java
    └── IO.java


/.gitignore:
--------------------------------------------------------------------------------
1 | *.class
2 | 


--------------------------------------------------------------------------------
/recursion/how-to-think-recursively:
--------------------------------------------------------------------------------
1 | When thinking about a problem recursively, think about three things:
2 | 
3 | 1. What is/are my base case(s)?
4 | 2. How do I break down this problem into smaller problem(s)?
5 | 3. How do I take the answer of the smaller problem(s) and get the 
6 | answer to the problem?
7 | 


--------------------------------------------------------------------------------
/objects/Trainer.java:
--------------------------------------------------------------------------------
 1 | public class Trainer{
 2 | 
 3 |   String name;
 4 |   int badges;
 5 |   Pokemon[] pokemons;
 6 | 
 7 |   public Trainer(String name) {
 8 | 
 9 |     this.name = name;
10 |     this.badges = 0;
11 |     this.pokemons = new Pokemon[6];
12 | 
13 |   }
14 | 
15 |   public boolean capture(Pokemon p) {
16 | 
17 |     return false;  
18 | 
19 |   }
20 | 
21 | }
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | This repository contains example code from Fall 2012 CS111 recitation.
2 | 
3 | You can download a zip file of this code by clicking on [this
4 | link](https://github.com/vaibhav2614/recitation/archive/master.zip).
5 | 
6 | You can alternatively also [set up
7 | git](https://help.github.com/articles/set-up-git) if you'd like, and this will
8 | make for easier updates of future code
9 | 


--------------------------------------------------------------------------------
/objects/Pokemon.java:
--------------------------------------------------------------------------------
 1 | public class Pokemon {
 2 | 
 3 |   String name;
 4 |   int lv;
 5 |   double hp;
 6 | 
 7 |   /* Constructor for creating a Pokemon Object */
 8 |   // Parameters: 
 9 |   //  Name of the Pokemon
10 |   //  Level default to 1
11 |   //  HP depends on the Pokemon's level
12 |   public Pokemon(String name) {
13 |     
14 |     this.name = name;
15 |     this.lv = 1;
16 |     this.hp = this.lv * 10 + this.lv * 5;
17 | 
18 |   }
19 | 
20 |   public boolean attack(Pokemon enemy) {
21 | 
22 |     return false;  
23 | 
24 |   }
25 | 
26 | }
27 | 


--------------------------------------------------------------------------------
/recursion/Program.java:
--------------------------------------------------------------------------------
 1 | public class Program
 2 | {
 3 |     public static void main(String[] args)
 4 |     {
 5 |         int x = IO.readInt();
 6 |         System.out.println(fibonacci(x));        
 7 |     }
 8 | 
 9 |     public static int factorialIter(int x)
10 |     {
11 |         int product = 1;
12 |         for(int i=1; i<=x; i++)
13 |         {
14 |             product = product * i;
15 |         }
16 |         return product;
17 |     }
18 | 
19 |     public static int factorialRec(int x)
20 |     {
21 |         if (x == 1)
22 |             return 1;
23 |         return x * factorialRec(x - 1);
24 |     }
25 | 
26 |     public static int fibonacci(int n)
27 |     {
28 |         if(n == 1 || n == 2)
29 |             return 1;
30 |         return fibonacci(n -1) + fibonacci(n-2);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/arrays/TwoDim.java:
--------------------------------------------------------------------------------
 1 | public class TwoDim
 2 | {
 3 |     public static void main(String[] args)
 4 |     {
 5 |         int[][] matrix = new int[5][6];//create an array with 5 rows and 6 cols
 6 |         matrix[0][0] = 5;
 7 | 
 8 |         int var  = matrix[0][0];
 9 |         int[] var2 = matrix[0];
10 | 
11 |         matrix[1][2] //row 1 col 2. 0 indexed
12 |         //which one do I do?
13 |         matrix[2][1];
14 | 
15 |         //iterates over rows
16 |         //matrix.length tells me about the number of rows.
17 |         for(int i=0; i<matrix.length; i++)
18 |         {
19 |             //iterates over columns in row i.
20 |             //matrix[i].length tells me about the numbers of cols in row i.
21 |             for(int j=0; j<matrix[i].length; j++)
22 |             {
23 |                 //prints element at row i, col j
24 |                 System.out.println(matrix[i][j]);
25 |             }
26 |         }
27 |         //transpose matrix.
28 | 
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/objects/Student.java:
--------------------------------------------------------------------------------
 1 | /* Creates a class. Class <-> Type of Object */
 2 | public class Student
 3 | {
 4 |     //Fields / Properties / instance variables
 5 |     public String name;
 6 |     public int id;
 7 |     //non static. Belong to the instance.
 8 |     public String location;
 9 | 
10 |     public int[] grades;
11 | 
12 |     //methods to a class
13 |     public double gpa()
14 |     {
15 |         System.out.println("Computing gpa for "+name);
16 |         int sum = 0;
17 |         for(int i=0; i<grades.length; i++)
18 |         {
19 |             sum += grades[i];
20 |         }
21 |         return sum/grades.length;
22 |     }
23 | 
24 |     //Constructor gets called when I say new Student
25 |     // Usually constructors are used to "initialize" the object.
26 |     public Student(String inputName)
27 |     {
28 |         grades = new int[10];
29 |         name = inputName; 
30 |     }
31 | 
32 |     public Student(String inputName, int inputId)
33 |     {
34 |         grades = new int[10];
35 |         name = inputName; 
36 |         id = inputId;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/objects/Program.java:
--------------------------------------------------------------------------------
 1 | public class Program
 2 | {
 3 |     public static void main(String[] args)
 4 |     {
 5 |         String name;
 6 |         int id;
 7 |         String location;
 8 | 
 9 |         String nameOne;
10 |         int idOne;
11 |         String locationOne;
12 | 
13 |         //Student is the class. sang is the instance of the class.
14 |         Student sang = new Student("Sang", 123456);
15 |         sang.location = "Busch";
16 | 
17 |         sang.grades = {1,2,3,4,5};
18 | 
19 |         sang.gpa();
20 |         Student.gpa(sang);
21 | 
22 |         //v is an instance.
23 |         Student v = new Student();
24 |         v.name = "Vaibhav";
25 |         v.id = 1234567;
26 |         v.location = "Off campus";
27 | 
28 | 
29 | 
30 | 
31 | /*
32 | 
33 |         Student s = new Student("Vaibhav", 12345); <<< NEW CALLS THE CONSTRUCTOR
34 |         Student joe = new Student("Joe");
35 | 
36 |         System.out.println("Enter your name");
37 |         s.name = IO.readString();
38 | 
39 |         System.out.println("Enter your id");
40 |         s.id = IO.readInt();
41 | 
42 |         System.out.println("Enter your dorm");
43 |         s.dorm = IO.readString();
44 | 
45 |         double gpa = s.gpa();
46 |     */
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/arrays/Program.java:
--------------------------------------------------------------------------------
 1 | public class Program {
 2 |     public static void main(String[] args)
 3 |     {
 4 |         /* Let's say you wanted to write code that took in three student's grades and averages it */
 5 |         //You would probably do something like this.
 6 |         
 7 |         int first = IO.readInt();
 8 |         int second = IO.readInt();
 9 |         int third = IO.readInt();
10 | 
11 |         System.out.println((first+second+third)/3);
12 | 
13 |         /* Now if you wanted to take in 10 grades, or a 100 grades, you can imagine that this gets pretty tedious.*/
14 |         // This is where arrays come in.
15 |         // Arrays allow you to create a list of something easily.
16 |         
17 |         int[] numbers = new int[10]; //Creates an int-array called numbers of size 10.
18 | 
19 |         System.out.println(numbers[0]); //Prints the first element of numbers. Will equal 0 by default.
20 | 
21 |         numbers[0] = 5; //Sets the element at the 0th index of numbers to 5.
22 |         numbers[9] = 20; //Sets the element at the 9th index (the last element) of numbers to 20.
23 | 
24 |         System.out.println(numbers[0]); //Prints the first element of numbers. Will equal 5.
25 |         System.out.println(numbers[0]); //Prints the first element of numbers. Will equal 5.
26 | 
27 | 
28 |         System.out.println(numbers.length); //Prints the length of numbers. For this array you will return 10.
29 | 
30 |         //print all the elements of an array
31 |         
32 |         //You can imagine that to print all the elements of numbers, I can do this.
33 |         System.out.println(numbers[0]);
34 |         System.out.println(numbers[1]);
35 |         System.out.println(numbers[2]);
36 |         System.out.println(numbers[3]);
37 |         System.out.println(numbers[4]);
38 |         //...
39 |         System.out.println(numbers[9]);
40 | 
41 |         //But this is tedious. What happens if I change the size of numbers? So I can use a loop to print all the elements of numbers instead.
42 |         
43 |         for(int i=0; i<numbers.length; i++) {
44 |             System.out.println(numbers[i]);
45 |         }
46 | 
47 |         //How would I go about incrementing all the values in an array? {1,2,3,4,5} -> {2,3,4,5,6}
48 |         
49 |         for(int i=0; i<numbers.length; i++) {
50 |             numbers[i] += 1;
51 |         }
52 | 
53 |         //How do I take in an array  of n numbers as input?
54 |         
55 |         int n = IO.readInt();
56 |         int[] inputNumbers = new int[n];
57 | 
58 |         //The first time this loop runs, it will set:
59 |         //inputNumbers[0] = IO.readInt()
60 |         //The next time,
61 |         //inptuNumbers[1] = IO.readInt()
62 |         //and so on 
63 |         //until
64 |         //inputNumbers[9] = IO.readInt()
65 |         
66 |         for(int i=0; i<n; i++) {
67 |             inputNumbers[i] = IO.readInt();
68 |         }
69 |     }
70 | }
71 | 


--------------------------------------------------------------------------------
/arrays/IO.java:
--------------------------------------------------------------------------------
  1 | import java.io.*;
  2 | 
  3 | public class IO
  4 | {
  5 |     private static BufferedReader kb =
  6 |         new BufferedReader(new InputStreamReader(System.in));
  7 |     
  8 |     private static BufferedReader fio = null;
  9 |     
 10 |     public static boolean openFile(String filename){
 11 |     
 12 |         try{
 13 |             fio = new BufferedReader(new FileReader(filename));
 14 |             return true;
 15 |         }catch (IOException e){ return false;}
 16 |     }
 17 |     
 18 |     public static String readLine(){
 19 |         if (fio == null)
 20 |             return null;
 21 |             
 22 |         try{
 23 |              return fio.readLine();
 24 |         }catch(IOException e){ return null;}
 25 |     }
 26 |     
 27 |     public static String readString()
 28 |     {
 29 |         while (true) {
 30 |             try {
 31 |                 return kb.readLine();
 32 |             } catch (IOException e) {
 33 |                 // should never happen
 34 |             }
 35 |         }
 36 |     }
 37 | 
 38 |     public static int readInt()
 39 |     {
 40 |         while (true) {
 41 |             try {
 42 |                 String s = kb.readLine();
 43 |                 return Integer.parseInt(s);
 44 |             } catch (NumberFormatException e) {
 45 |                 System.out.print("That is not an integer.  Enter again: ");
 46 |             } catch (IOException e) {
 47 |                 // should never happen
 48 |             }
 49 |         }
 50 |     }
 51 | 
 52 |     public static double readDouble()
 53 |     {
 54 |         while (true) {
 55 |             try {
 56 |                 String s = kb.readLine();
 57 |                 return Double.parseDouble(s);
 58 |             } catch (NumberFormatException e) {
 59 |                 System.out.print("That is not a number.  Enter again: ");
 60 |             } catch (IOException e) {
 61 |                 // should never happen
 62 |             }
 63 |         }
 64 |     }
 65 | 
 66 |     public static char readChar()
 67 |     {
 68 |         String s = null;
 69 | 
 70 |         try {
 71 |             s = kb.readLine();
 72 |         } catch (IOException e) {
 73 |             // should never happen
 74 |         }
 75 | 
 76 |         while (s.length() != 1) {
 77 |             System.out.print("That is not a single character.  Enter again: ");
 78 |             try {
 79 |                 s = kb.readLine();
 80 |             } catch (IOException e) {
 81 |                 // should never happen
 82 |             }
 83 |         }
 84 | 
 85 |         return s.charAt(0);
 86 |     }
 87 | 
 88 |         public static boolean readBoolean()
 89 |         {
 90 |                 String s = null;
 91 |  
 92 |                 while (true) {
 93 |                         try {
 94 |                                 s = kb.readLine();
 95 |                         } catch (IOException e) {
 96 |                                 // should never happen
 97 |                         }
 98 |  
 99 |                         if (s.equalsIgnoreCase("yes") ||
100 |                 s.equalsIgnoreCase("y") ||
101 |                 s.equalsIgnoreCase("true") ||
102 |                 s.equalsIgnoreCase("t")) {
103 |                                 return true;
104 |                         } else if (s.equalsIgnoreCase("no") ||
105 |                        s.equalsIgnoreCase("n") ||
106 |                        s.equalsIgnoreCase("false") ||
107 |                        s.equalsIgnoreCase("f")) {
108 |                                 return false;
109 |                         } else {
110 |                                 System.out.print("Enter \"yes\" or \"no\": ");
111 |                         }
112 |                 }
113 |         }
114 | 
115 |     public static void outputStringAnswer(String s)
116 |     {
117 |         if (s != null) {
118 |             System.out.println("RESULT: \"" + s + "\"");
119 |         } else {
120 |             System.out.println("RESULT: null");
121 |         }
122 |     }
123 | 
124 |     public static void outputIntAnswer(int i)
125 |     {
126 |         System.out.println("RESULT: " + i);
127 |     }
128 | 
129 |     public static void outputDoubleAnswer(double d)
130 |     {
131 |         System.out.println("RESULT: " + d);
132 |     }
133 | 
134 |     public static void outputCharAnswer(char c)
135 |     {
136 |         System.out.println("RESULT: '" + c + "'");
137 |     }
138 | 
139 |     public static void outputBooleanAnswer(boolean b)
140 |     {
141 |         System.out.println("RESULT: " + b);
142 |     }
143 | 
144 |     public static void reportBadInput()
145 |     {
146 |         System.out.println("User entered bad input.");
147 |     }
148 | }
149 | 


--------------------------------------------------------------------------------
/objects/IO.java:
--------------------------------------------------------------------------------
  1 | import java.io.*;
  2 | 
  3 | public class IO
  4 | {
  5 |     private static BufferedReader kb =
  6 |         new BufferedReader(new InputStreamReader(System.in));
  7 |     
  8 |     private static BufferedReader fio = null;
  9 |     
 10 |     public static boolean openFile(String filename){
 11 |     
 12 |         try{
 13 |             fio = new BufferedReader(new FileReader(filename));
 14 |             return true;
 15 |         }catch (IOException e){ return false;}
 16 |     }
 17 |     
 18 |     public static String readLine(){
 19 |         if (fio == null)
 20 |             return null;
 21 |             
 22 |         try{
 23 |              return fio.readLine();
 24 |         }catch(IOException e){ return null;}
 25 |     }
 26 |     
 27 |     public static String readString()
 28 |     {
 29 |         while (true) {
 30 |             try {
 31 |                 return kb.readLine();
 32 |             } catch (IOException e) {
 33 |                 // should never happen
 34 |             }
 35 |         }
 36 |     }
 37 | 
 38 |     public static int readInt()
 39 |     {
 40 |         while (true) {
 41 |             try {
 42 |                 String s = kb.readLine();
 43 |                 return Integer.parseInt(s);
 44 |             } catch (NumberFormatException e) {
 45 |                 System.out.print("That is not an integer.  Enter again: ");
 46 |             } catch (IOException e) {
 47 |                 // should never happen
 48 |             }
 49 |         }
 50 |     }
 51 | 
 52 |     public static double readDouble()
 53 |     {
 54 |         while (true) {
 55 |             try {
 56 |                 String s = kb.readLine();
 57 |                 return Double.parseDouble(s);
 58 |             } catch (NumberFormatException e) {
 59 |                 System.out.print("That is not a number.  Enter again: ");
 60 |             } catch (IOException e) {
 61 |                 // should never happen
 62 |             }
 63 |         }
 64 |     }
 65 | 
 66 |     public static char readChar()
 67 |     {
 68 |         String s = null;
 69 | 
 70 |         try {
 71 |             s = kb.readLine();
 72 |         } catch (IOException e) {
 73 |             // should never happen
 74 |         }
 75 | 
 76 |         while (s.length() != 1) {
 77 |             System.out.print("That is not a single character.  Enter again: ");
 78 |             try {
 79 |                 s = kb.readLine();
 80 |             } catch (IOException e) {
 81 |                 // should never happen
 82 |             }
 83 |         }
 84 | 
 85 |         return s.charAt(0);
 86 |     }
 87 | 
 88 |         public static boolean readBoolean()
 89 |         {
 90 |                 String s = null;
 91 |  
 92 |                 while (true) {
 93 |                         try {
 94 |                                 s = kb.readLine();
 95 |                         } catch (IOException e) {
 96 |                                 // should never happen
 97 |                         }
 98 |  
 99 |                         if (s.equalsIgnoreCase("yes") ||
100 |                 s.equalsIgnoreCase("y") ||
101 |                 s.equalsIgnoreCase("true") ||
102 |                 s.equalsIgnoreCase("t")) {
103 |                                 return true;
104 |                         } else if (s.equalsIgnoreCase("no") ||
105 |                        s.equalsIgnoreCase("n") ||
106 |                        s.equalsIgnoreCase("false") ||
107 |                        s.equalsIgnoreCase("f")) {
108 |                                 return false;
109 |                         } else {
110 |                                 System.out.print("Enter \"yes\" or \"no\": ");
111 |                         }
112 |                 }
113 |         }
114 | 
115 |     public static void outputStringAnswer(String s)
116 |     {
117 |         if (s != null) {
118 |             System.out.println("RESULT: \"" + s + "\"");
119 |         } else {
120 |             System.out.println("RESULT: null");
121 |         }
122 |     }
123 | 
124 |     public static void outputIntAnswer(int i)
125 |     {
126 |         System.out.println("RESULT: " + i);
127 |     }
128 | 
129 |     public static void outputDoubleAnswer(double d)
130 |     {
131 |         System.out.println("RESULT: " + d);
132 |     }
133 | 
134 |     public static void outputCharAnswer(char c)
135 |     {
136 |         System.out.println("RESULT: '" + c + "'");
137 |     }
138 | 
139 |     public static void outputBooleanAnswer(boolean b)
140 |     {
141 |         System.out.println("RESULT: " + b);
142 |     }
143 | 
144 |     public static void reportBadInput()
145 |     {
146 |         System.out.println("User entered bad input.");
147 |     }
148 | }
149 | 


--------------------------------------------------------------------------------
/recursion/IO.java:
--------------------------------------------------------------------------------
  1 | import java.io.*;
  2 | 
  3 | public class IO
  4 | {
  5 |     private static BufferedReader kb =
  6 |         new BufferedReader(new InputStreamReader(System.in));
  7 |     
  8 |     private static BufferedReader fio = null;
  9 |     
 10 |     public static boolean openFile(String filename){
 11 |     
 12 |         try{
 13 |             fio = new BufferedReader(new FileReader(filename));
 14 |             return true;
 15 |         }catch (IOException e){ return false;}
 16 |     }
 17 |     
 18 |     public static String readLine(){
 19 |         if (fio == null)
 20 |             return null;
 21 |             
 22 |         try{
 23 |              return fio.readLine();
 24 |         }catch(IOException e){ return null;}
 25 |     }
 26 |     
 27 |     public static String readString()
 28 |     {
 29 |         while (true) {
 30 |             try {
 31 |                 return kb.readLine();
 32 |             } catch (IOException e) {
 33 |                 // should never happen
 34 |             }
 35 |         }
 36 |     }
 37 | 
 38 |     public static int readInt()
 39 |     {
 40 |         while (true) {
 41 |             try {
 42 |                 String s = kb.readLine();
 43 |                 return Integer.parseInt(s);
 44 |             } catch (NumberFormatException e) {
 45 |                 System.out.print("That is not an integer.  Enter again: ");
 46 |             } catch (IOException e) {
 47 |                 // should never happen
 48 |             }
 49 |         }
 50 |     }
 51 | 
 52 |     public static double readDouble()
 53 |     {
 54 |         while (true) {
 55 |             try {
 56 |                 String s = kb.readLine();
 57 |                 return Double.parseDouble(s);
 58 |             } catch (NumberFormatException e) {
 59 |                 System.out.print("That is not a number.  Enter again: ");
 60 |             } catch (IOException e) {
 61 |                 // should never happen
 62 |             }
 63 |         }
 64 |     }
 65 | 
 66 |     public static char readChar()
 67 |     {
 68 |         String s = null;
 69 | 
 70 |         try {
 71 |             s = kb.readLine();
 72 |         } catch (IOException e) {
 73 |             // should never happen
 74 |         }
 75 | 
 76 |         while (s.length() != 1) {
 77 |             System.out.print("That is not a single character.  Enter again: ");
 78 |             try {
 79 |                 s = kb.readLine();
 80 |             } catch (IOException e) {
 81 |                 // should never happen
 82 |             }
 83 |         }
 84 | 
 85 |         return s.charAt(0);
 86 |     }
 87 | 
 88 |         public static boolean readBoolean()
 89 |         {
 90 |                 String s = null;
 91 |  
 92 |                 while (true) {
 93 |                         try {
 94 |                                 s = kb.readLine();
 95 |                         } catch (IOException e) {
 96 |                                 // should never happen
 97 |                         }
 98 |  
 99 |                         if (s.equalsIgnoreCase("yes") ||
100 |                 s.equalsIgnoreCase("y") ||
101 |                 s.equalsIgnoreCase("true") ||
102 |                 s.equalsIgnoreCase("t")) {
103 |                                 return true;
104 |                         } else if (s.equalsIgnoreCase("no") ||
105 |                        s.equalsIgnoreCase("n") ||
106 |                        s.equalsIgnoreCase("false") ||
107 |                        s.equalsIgnoreCase("f")) {
108 |                                 return false;
109 |                         } else {
110 |                                 System.out.print("Enter \"yes\" or \"no\": ");
111 |                         }
112 |                 }
113 |         }
114 | 
115 |     public static void outputStringAnswer(String s)
116 |     {
117 |         if (s != null) {
118 |             System.out.println("RESULT: \"" + s + "\"");
119 |         } else {
120 |             System.out.println("RESULT: null");
121 |         }
122 |     }
123 | 
124 |     public static void outputIntAnswer(int i)
125 |     {
126 |         System.out.println("RESULT: " + i);
127 |     }
128 | 
129 |     public static void outputDoubleAnswer(double d)
130 |     {
131 |         System.out.println("RESULT: " + d);
132 |     }
133 | 
134 |     public static void outputCharAnswer(char c)
135 |     {
136 |         System.out.println("RESULT: '" + c + "'");
137 |     }
138 | 
139 |     public static void outputBooleanAnswer(boolean b)
140 |     {
141 |         System.out.println("RESULT: " + b);
142 |     }
143 | 
144 |     public static void reportBadInput()
145 |     {
146 |         System.out.println("User entered bad input.");
147 |     }
148 | }
149 | 


--------------------------------------------------------------------------------