Add serie 1 and 2

serie_1/App.java

+public class App {
+	public static void main(String[] args) 
+	{
+		
+	}
+}

serie_1/Lecture.java

+import java.util.Scanner;
+
+public class Lecture 
+{
+	public static int askInt() 
+	{
+		int input = 0;
+		boolean isInt = false;
+
+		Scanner scanner = new Scanner(System.in);
+
+		while (!isInt) 
+		{
+			System.out.println("Entrez une valeur: ");
+			try 
+			{
+				input = scanner.nextInt();
+				isInt = true;
+			} catch (Exception e) 
+			{
+				System.out.println("Valeur erronée");
+				scanner.next();
+			}
+		}
+		//scanner.close();
+
+		return input;
+	}
+
+	public static int askIntRec() 
+	{
+		int input = 0;
+		Scanner scanner = new Scanner(System.in);
+
+		System.out.println("Entrez une valeur: ");
+		try 
+		{
+			input = scanner.nextInt();
+		} catch (Exception e) 
+		{
+			System.out.println("Valeur erronée");
+			scanner.next();
+			input = askIntRec();
+		}
+		//scanner.close();
+		
+		return input;
+	}
+
+	
+	public static void main(String[] args) 
+	{
+		System.out.println("La méthode a retourné " + askInt());
+		System.out.println("La méthode a retourné " + askIntRec());
+	}
+}

serie_1/Loop.java

+import java.util.Scanner;
+
+import javax.swing.plaf.SeparatorUI;
+
+/**
+ * Loop
+ */
+public class Loop 
+{
+	public static void whileWithDoWhile(int i) 
+	{
+		do {
+			System.out.println(i++);
+		} while (i < 5);
+	}
+
+	public static void doWhileWithWhile(int i) 
+	{
+		while (i < 5) 
+		{
+			System.out.println(i++);
+		}
+	}
+
+	public static void printTriangle(int n) 
+	{
+		String s = "";
+		for (int i = 0; i < n; i++) 
+		{
+			s+="*";
+			System.out.println(s);
+		}
+	}
+
+	public static void printSapin(int n) 
+	{
+		String s;
+		for (int i = 1; i < n+1; i++) 
+		{
+			s= " ".repeat(n-i);
+			s+= "*".repeat((i * 2) - 1);
+			System.out.println(s);
+		}
+	}
+
+	public static int factorielle(int n) 
+	{
+		int f = 1;
+		for (int i = 1; i < n + 1; i++) 
+		{
+			f *= i;
+		}
+		return f;
+	}
+
+	public static double compute_pi(int n) 
+	{
+		double pi = 0.0;
+		
+		for (int i = 1; i < n; i++) 
+		{
+			pi += 1.0 / Math.pow(i, 4.0);
+		}
+		return Math.pow((pi * 90.0), (1.0/4.0));
+	}
+
+	public static void serpent()
+	{
+		Scanner scanner = new Scanner(System.in);
+		String serpent = "(^^)";
+		boolean state = true;
+
+		while(state)
+		{
+			System.out.println(serpent);
+			String input = scanner.nextLine();
+
+			switch (input) {
+				case "+":
+					serpent = "*" + serpent;
+					break;
+				case "-":
+					if(!serpent.contains("*"))
+					{
+						state = false;
+						System.out.println("Bye !");
+					}
+					else
+					{
+						serpent = serpent.substring(1, serpent.length());
+					}
+					break;
+			}
+		}
+		scanner.close();
+	}
+	public static void main(String[] args) 
+	{
+		
+		//Print triangle et sapin
+		printTriangle(4);
+		printSapin(4);
+		
+
+		//Print factorielle
+		System.out.println(factorielle(6));
+
+		//Print PI
+		System.out.println(compute_pi(100));
+
+		//Serpent
+		serpent();
+	}
+}
+
+
+/* Exercice 1.2
+ * Réponse : ligne 2
+ */
+
+/* Exercice 1.3
+ * Réponse : ligne 2 & 3
+ */
+
+ /* Exercice 1.4
+ * Réponse : Il vaut s avant l'incrémentation
+ */
+
+ /* Exercice 1.5
+ * Réponse 1. : Correct
+ * Réponse 2. : Correct
+ * Réponse 3. : Correct
+ * Réponse 4. : Incorrect, perte de précision lorsque double -> float
+ * Réponse 5. : Correct
+ * Réponse 6. : Correct
+ * Réponse 7. : Incorrect, car float * double = double
+ * Réponse 8. : Correct
+ * Réponse 9. : Incorrect car int au lieu de short
+ * Réponse 10.: Correct
+ * Réponse 11.: Incorrect, perte de précision lorsque double -> short
+ */
+

serie_1/Vecteur.java

+public class Vecteur 
+{
+	public static double[] add(double[] a, double[] b)
+	{
+		if(a.length != b.length)
+		{
+			return new double[0];
+		}
+
+		double[] c = new double[a.length];
+
+		return c;
+	}
+}

serie_2/DynArray.java

+import java.util.Arrays;
+
+import javax.sound.midi.Track;
+
+public class DynArray 
+{
+	//ATTRIBUTS
+	public int[] tab;
+
+	//CONSTRUCTEURS
+	private DynArray(int size)
+	{
+		tab = new int[size];
+	}
+
+	//METHODES
+	public static DynArray of(int... values)
+	{
+		DynArray new_arr = new DynArray(values.length);
+
+		for (int i = 0; i < values.length; i++) 
+		{
+			new_arr.tab[i] = values[i];
+		}
+		
+		return new_arr;
+	}
+
+	public int size()
+	{
+		return this.tab.length;
+	}
+
+	public DynArray append(int value)
+	{
+		DynArray new_arr = new DynArray(this.size()+1);
+
+		for (int i = 1; i < this.size()+1; i++) 
+		{
+			new_arr.tab[i] = this.tab[i-1];
+		}
+		new_arr.tab[0] = value;
+		return new_arr;
+	}
+
+	public DynArray pop()
+	{
+		DynArray new_arr = new DynArray(this.size()-1);
+
+		for (int i = 0; i < this.size()-1; i++) 
+		{
+			new_arr.tab[i] = this.tab[i+1];
+		}
+		return new_arr;
+	}
+
+	public int head()
+	{
+		return this.tab[0];
+	}
+
+	public DynArray concat(DynArray dyn_2)
+	{
+		DynArray new_arr = new DynArray(this.size() + dyn_2.size());
+
+		for (int i = 0; i < this.size(); i++) 
+		{
+			new_arr.tab[i] = this.tab[i];
+		}
+
+		for (int i = 0; i < dyn_2.size(); i++) 
+		{
+			new_arr.tab[i + this.size()] = dyn_2.tab[i];
+		}
+
+		return new_arr;
+	}
+
+	public DynArray reversed()
+	{
+		DynArray new_arr = new DynArray(this.size());
+
+		for (int i = 0; i < this.size(); i++) 
+		{
+			new_arr.tab[i] = this.tab[this.size()-1-i];
+		}
+
+		return new_arr;
+	}
+
+	public String ToString()
+	{
+		String s = "[";
+		for (int i = 0; i < this.size()-1; i++) 
+		{
+			s = s.concat(String.valueOf(this.tab[i]) + ", ");
+		}
+		s = s.concat(String.valueOf(this.tab[this.size()-1]) + "]");
+		return s;
+	}
+
+	public boolean equals(Object object)
+	{
+		return (object instanceof DynArray) &&
+		Arrays.equals(((DynArray)object).tab, this.tab);
+	}
+}

serie_2/Main.java

+import javax.management.DynamicMBean;
+
+public class Main 
+{
+	public static void main(String[] args) 
+	{
+		DynArray test_1 = DynArray.of(1, 2 ,3 ,4 ,5 ,6);
+		System.out.println("test_1 of : " + test_1.ToString());
+		DynArray test_2 = test_1.append(7);
+		System.out.println("test_2 append : " + test_2.ToString());
+		System.out.println("test_2 head : " + test_2.head());
+		DynArray test_3 = test_2.pop();
+		System.out.println("test_3 pop : " + test_3.ToString());
+		DynArray test_4 = test_1.concat(test_2);
+		System.out.println("test_4 concat : " + test_4.ToString());
+		DynArray test_5 = test_4.reversed();
+		System.out.println("test_5 reversed : " + test_5.ToString());
+		System.out.println("test_1 is equal to test_3 : " + test_1.equals(test_3));
+		System.out.println("test_1 is equal to test_2 : " + test_1.equals(test_2));
+	}
+}
\ No newline at end of file