diff --git a/CCI_Java/CCI_Java/src/TestTd16.java b/CCI_Java/CCI_Java/src/TestTd16.java new file mode 100644 index 0000000000000000000000000000000000000000..4f964ebeaecbba52d3a5bf8ddefd9ccebac512bd --- /dev/null +++ b/CCI_Java/CCI_Java/src/TestTd16.java @@ -0,0 +1,14 @@ + +public class TestTd16 { + + public static void main(String[] args) { + int num = td16.expoFor(3,3); + System.out.println(num); + + double numRec = td16.expoRec(3,3); + System.out.println(numRec); + + System.out.println(td16.fiboRec(6)); + } + +} diff --git a/CCI_Java/CCI_Java/src/td14/exo6/Addition.java b/CCI_Java/CCI_Java/src/td14/exo6/Addition.java new file mode 100644 index 0000000000000000000000000000000000000000..443dc5b544e2a8934c3de191da083cd18dfd4234 --- /dev/null +++ b/CCI_Java/CCI_Java/src/td14/exo6/Addition.java @@ -0,0 +1,14 @@ +package td14.exo6; + +public class Addition extends BinaryOperation { + + public Addition(Expression ex1, Expression ex2) { + super(ex1, ex2); + } + + @Override + public double value(double x) { + return left.value(x) + right.value(x); + } + +} diff --git a/CCI_Java/CCI_Java/src/td14/exo6/BinaryOperation.java b/CCI_Java/CCI_Java/src/td14/exo6/BinaryOperation.java new file mode 100644 index 0000000000000000000000000000000000000000..f2f377d4fb4451cc5ae2be37f01b96fba9fba39b --- /dev/null +++ b/CCI_Java/CCI_Java/src/td14/exo6/BinaryOperation.java @@ -0,0 +1,14 @@ +package td14.exo6; + +public abstract class BinaryOperation implements Expression { + protected Expression left; + protected Expression right; + + public BinaryOperation(Expression left, Expression right) { + this.left = left; + this.right = right; + } + + @Override + public abstract double value(double x); +} diff --git a/CCI_Java/CCI_Java/src/td14/exo6/Constant.java b/CCI_Java/CCI_Java/src/td14/exo6/Constant.java new file mode 100644 index 0000000000000000000000000000000000000000..17714e68e8ef3397d08fc492eb77beceaafc193a --- /dev/null +++ b/CCI_Java/CCI_Java/src/td14/exo6/Constant.java @@ -0,0 +1,14 @@ +package td14.exo6; + +public class Constant implements Expression { + private double value; + + public Constant(double value) { + this.value = value; + } + + @Override + public double value(double x) { + return this.value; + } +} diff --git a/CCI_Java/CCI_Java/src/td14/exo6/Cos.java b/CCI_Java/CCI_Java/src/td14/exo6/Cos.java new file mode 100644 index 0000000000000000000000000000000000000000..d2f04de781f2ef818d44799525c1e164de7340d9 --- /dev/null +++ b/CCI_Java/CCI_Java/src/td14/exo6/Cos.java @@ -0,0 +1,14 @@ +package td14.exo6; + +public class Cos extends UnaryOperation { + + public Cos(Expression ex) { + super(ex); + } + + @Override + public double value(double x) { + return Math.cos(expression.value(x)); + } + +} diff --git a/CCI_Java/CCI_Java/src/td14/exo6/Division.java b/CCI_Java/CCI_Java/src/td14/exo6/Division.java new file mode 100644 index 0000000000000000000000000000000000000000..071465f09ce35b440533a7d2bee09952cdb82324 --- /dev/null +++ b/CCI_Java/CCI_Java/src/td14/exo6/Division.java @@ -0,0 +1,16 @@ +package td14.exo6; + +public class Division extends BinaryOperation { + + public Division(Expression ex1, Expression ex2) { + super(ex1, ex2); + } + + @Override + public double value(double x) { + if(right.value(x) == 0) + return Integer.MIN_VALUE; + return left.value(x) / right.value(x); + } + +} diff --git a/CCI_Java/CCI_Java/src/td14/exo6/Exp.java b/CCI_Java/CCI_Java/src/td14/exo6/Exp.java new file mode 100644 index 0000000000000000000000000000000000000000..c388f77d8c1230c49a228d1d51b157d83086fc91 --- /dev/null +++ b/CCI_Java/CCI_Java/src/td14/exo6/Exp.java @@ -0,0 +1,14 @@ +package td14.exo6; + +public class Exp extends UnaryOperation { + + public Exp(Expression ex) { + super(ex); + } + + @Override + public double value(double x) { + return Math.pow(expression.value(x), expression.value(x)); + } + +} diff --git a/CCI_Java/CCI_Java/src/td14/exo6/Expression.java b/CCI_Java/CCI_Java/src/td14/exo6/Expression.java new file mode 100644 index 0000000000000000000000000000000000000000..8429da5a56c63e05cfa8a97de79ca41e34d509b8 --- /dev/null +++ b/CCI_Java/CCI_Java/src/td14/exo6/Expression.java @@ -0,0 +1,6 @@ +package td14.exo6; + +public interface Expression { + public double value(double x); + +} diff --git a/CCI_Java/CCI_Java/src/td14/exo6/Log.java b/CCI_Java/CCI_Java/src/td14/exo6/Log.java new file mode 100644 index 0000000000000000000000000000000000000000..63ed669cd548b23f84c99815fb740bb5d47550f7 --- /dev/null +++ b/CCI_Java/CCI_Java/src/td14/exo6/Log.java @@ -0,0 +1,14 @@ +package td14.exo6; + +public class Log extends UnaryOperation { + + public Log(Expression ex) { + super(ex); + } + + @Override + public double value(double x) { + return Math.log(expression.value(x)); + } + +} diff --git a/CCI_Java/CCI_Java/src/td14/exo6/Multiplication.java b/CCI_Java/CCI_Java/src/td14/exo6/Multiplication.java new file mode 100644 index 0000000000000000000000000000000000000000..f6b52b0724dde48bf896c4eaeef860ba5cec4ef6 --- /dev/null +++ b/CCI_Java/CCI_Java/src/td14/exo6/Multiplication.java @@ -0,0 +1,14 @@ +package td14.exo6; + +public class Multiplication extends BinaryOperation{ + + public Multiplication(Expression ex1, Expression ex2) { + super(ex1, ex2); + } + + @Override + public double value(double x) { + return left.value(x) * right.value(x); + } + +} diff --git a/CCI_Java/CCI_Java/src/td14/exo6/Sin.java b/CCI_Java/CCI_Java/src/td14/exo6/Sin.java new file mode 100644 index 0000000000000000000000000000000000000000..c692d6ab8635478d2fce799e5cc472e520588c42 --- /dev/null +++ b/CCI_Java/CCI_Java/src/td14/exo6/Sin.java @@ -0,0 +1,14 @@ +package td14.exo6; + +public class Sin extends UnaryOperation { + + public Sin(Expression ex) { + super(ex); + } + + @Override + public double value(double x) { + return Math.sin(expression.value(x)); + } + +} diff --git a/CCI_Java/CCI_Java/src/td14/exo6/Subtraction.java b/CCI_Java/CCI_Java/src/td14/exo6/Subtraction.java new file mode 100644 index 0000000000000000000000000000000000000000..179377e51cc8c4b88c1ea2fd52fb4e8612a1a117 --- /dev/null +++ b/CCI_Java/CCI_Java/src/td14/exo6/Subtraction.java @@ -0,0 +1,14 @@ +package td14.exo6; + +public class Subtraction extends BinaryOperation { + + public Subtraction(Expression ex1, Expression ex2) { + super(ex1, ex2); + } + + @Override + public double value(double x) { + return left.value(x) - right.value(x); + } + +} diff --git a/CCI_Java/CCI_Java/src/td14/exo6/Testing.java b/CCI_Java/CCI_Java/src/td14/exo6/Testing.java new file mode 100644 index 0000000000000000000000000000000000000000..20fe53027b9cd8cf6614123365326c7f377ea2f0 --- /dev/null +++ b/CCI_Java/CCI_Java/src/td14/exo6/Testing.java @@ -0,0 +1,16 @@ +package td14.exo6; + +public class Testing { + + public static void main(String[] args) { + // Repr�sentation de la fonction f(x) = 2 * sin(x) + 3 * cos(x) + Expression f = new Addition(new Multiplication(new Constant(2), new Sin(new Variable())), + new Multiplication(new Constant(3), new Cos(new Variable()))); + // Calcul de la valeur de f(x) pour plusieurs valeurs de x + double[] values = { 0, 0.5, 1, 1.5, 2, 2.5 }; + for (double x : values) { + System.out.println("f(" + x + ") = " + f.value(x)); + } + } + +} diff --git a/CCI_Java/CCI_Java/src/td14/exo6/UnaryOperation.java b/CCI_Java/CCI_Java/src/td14/exo6/UnaryOperation.java new file mode 100644 index 0000000000000000000000000000000000000000..f38a2042e7763cb5aedbe6105098311b459ccaae --- /dev/null +++ b/CCI_Java/CCI_Java/src/td14/exo6/UnaryOperation.java @@ -0,0 +1,13 @@ +package td14.exo6; + +public abstract class UnaryOperation implements Expression { + protected Expression expression; + + public UnaryOperation(Expression expression) { + this.expression = expression; + + } + + @Override + public abstract double value(double x); +} diff --git a/CCI_Java/CCI_Java/src/td14/exo6/Variable.java b/CCI_Java/CCI_Java/src/td14/exo6/Variable.java new file mode 100644 index 0000000000000000000000000000000000000000..b902ba3d854488811b1122092e6edfbb8984eec6 --- /dev/null +++ b/CCI_Java/CCI_Java/src/td14/exo6/Variable.java @@ -0,0 +1,11 @@ +package td14.exo6; + +public class Variable implements Expression { + + + @Override + public double value(double x) { + return x; + } + +} diff --git a/CCI_Java/CCI_Java/src/td16.java b/CCI_Java/CCI_Java/src/td16.java new file mode 100644 index 0000000000000000000000000000000000000000..7498bfd10764ad41fc3d16dac2623623da0a7c71 --- /dev/null +++ b/CCI_Java/CCI_Java/src/td16.java @@ -0,0 +1,36 @@ + +public class td16 { + + public static int expoFor(int x, int n) { + int res = 1; + for (int i = 0; i < n; i++) + res *= x; + return res; + } + + public static double expoRec(double x, int n) { + double res = x; + if (n == 0) + return 1; + return res * expoRec(x, n - 1); + +// return (n == 0) ? 1 : res * expoRec(x, n - 1); + + } + + public static double fiboRec(double n) { + +// if (n == 0 || n == 1) +// return n; +// return fibuRec(n-1) + fibuRec(n - 2); + + return (n == 0 || n == 1) ? n : fiboRec(n-1) + fiboRec(n - 2); + } + + public static double divi(int n) { + if (n == 1) + return 1; + return (1.0 / n) + divi(n-1) ; + } + +} diff --git a/CCI_Java/CCI_Java/src/version3/Direction.java b/CCI_Java/CCI_Java/src/version3/Direction.java index 667776764734dab20324610fbef18bb11a79578b..adb8244482e160efbaf9e8a444647e05c9e3b6ca 100644 --- a/CCI_Java/CCI_Java/src/version3/Direction.java +++ b/CCI_Java/CCI_Java/src/version3/Direction.java @@ -3,3 +3,6 @@ package version3; public enum Direction { NORTH, SOUTH, EAST, WEST } + + + diff --git a/CCI_Java/CCI_Java/src/version3/Position.java b/CCI_Java/CCI_Java/src/version3/Position.java index 6642f97667645e36bd9f8ffe288c31482a9e37e2..7cc7b3b4ec2a1829a107bff17f2f58b5d82f7649 100644 --- a/CCI_Java/CCI_Java/src/version3/Position.java +++ b/CCI_Java/CCI_Java/src/version3/Position.java @@ -9,17 +9,28 @@ public class Position { this.column = column; } - public boolean isSamePosition(Position pos) { - if (isLine(pos.line) && isColumn(pos.column)) - return true; +// public boolean isSamePosition(Position pos) { +// if (isLine(pos.line) && isColumn(pos.column)) +// return true; +// return false; +// } + + public boolean isSamePosition(Object obj) { + try { + if (obj.getClass() == this.getClass()) { + Position pos = (Position) obj; + if (isLine(pos.line) && isColumn(pos.column)) + return true; + } + } catch (NullPointerException e) { + return false; + } return false; } - - public boolean equals(Object obj) { - if (obj.getClass() == this.getClass()) - return isSamePosition((Position) obj); - return false; - + + public boolean isSame(Object obj) { + return obj.equals(this); +// return true; } public boolean isColumn(int col) { diff --git a/CCI_Java/CCI_Java/src/version3/SnakeGame.java b/CCI_Java/CCI_Java/src/version3/SnakeGame.java index 3c1dae6830b335f6aa39e0ef95bed22b32b71858..52b427c0b6f2845fe86e76e38bbf757637688978 100644 --- a/CCI_Java/CCI_Java/src/version3/SnakeGame.java +++ b/CCI_Java/CCI_Java/src/version3/SnakeGame.java @@ -1,16 +1,18 @@ package version3; import java.util.ArrayList; +import java.util.LinkedList; import java.util.List; import java.util.Random; public class SnakeGame { public static final int GRID_LINES = 12; public static final int GRID_COLUMNS = 12; - private List<Position> segments; + private LinkedList<Position> segments; private Direction direction; private boolean gameOver; private Position apple; + private Random rand = new Random(); public SnakeGame() { initialize(); @@ -20,33 +22,78 @@ public class SnakeGame { direction = Direction.EAST; int startL = GRID_LINES / 2; int startC = GRID_COLUMNS / 2; - gameOver = false; - setApple(); - segments = new ArrayList<Position>(); + segments = new LinkedList<Position>(); segments.add(new Position(startL, startC)); segments.add(new Position(startL, startC - 1)); segments.add(new Position(startL, startC - 2)); + gameOver = false; + setApple(); } public void setApple() { - Random rand = new Random(); - apple = new Position(rand.nextInt(GRID_LINES + 1), rand.nextInt(GRID_LINES + 1)); + apple = new Position(this.rand.nextInt(GRID_LINES), this.rand.nextInt(GRID_COLUMNS)); + if (isSnakeAt(apple)) { + setApple(); + } + } public void advance() { + if (!isGameOver()) { + if (isSnakeAt(apple)) { + setApple(); + } else { + segments.removeLast(); + } + + segments.addFirst(segments.peek().getNext(direction)); + } } public boolean isGameOver() { + if (isOutOfBounds(segments.peekFirst())) + gameOver = true; + if (snakeBite()) + gameOver = true; return gameOver; } - public void changeDirection(Direction direction) { + private boolean snakeBite() { + Position peek = segments.peekFirst(); + for (Position seg : segments) + if (!peek.isSame(seg) && peek.isSamePosition(seg)) + return true; + + return false; + } + + public boolean isOutOfBounds(Position pos) { + boolean condLine = pos.line < GRID_LINES && pos.line >= 0; + boolean condCol = pos.column < GRID_COLUMNS && pos.column >= 0; + if (condLine && condCol) + return false; + return true; + } + + public void changeDirection(Direction newDirection) { + if (newDirection != getOpposite(direction)) + direction = newDirection; + } + + private Direction getOpposite(Direction dir) { + if (dir == Direction.NORTH) + return Direction.SOUTH; + if (dir == Direction.EAST) + return Direction.WEST; + if (dir == Direction.SOUTH) + return Direction.NORTH; + return Direction.EAST; } public boolean isSnakeAt(Position position) { for (Position pos : segments) - if (position.isSamePosition(pos)) + if (pos.isSamePosition(position)) return true; return false; } @@ -70,12 +117,4 @@ public class SnakeGame { } } -// public void printLine() { -// String line = ""; -// for (int c =0; c<GRID_COLUMNS;c++) { -// if(apple.isColumn(c) && apple.isLine(c)) -// } -// -// } - } diff --git a/CCI_Java/CCI_Java/src/version3/TestPosition.java b/CCI_Java/CCI_Java/src/version3/TestPosition.java index 918c17f1b5f3d56e5eb26597e774e56714eaf96e..626cbc16ca0a171cb50a3f108ce60b5cf1bf68c2 100644 --- a/CCI_Java/CCI_Java/src/version3/TestPosition.java +++ b/CCI_Java/CCI_Java/src/version3/TestPosition.java @@ -5,6 +5,8 @@ public class TestPosition { public static void main(String[] args) { Position pos1 = new Position(3, 4); + Position pos2 = new Position(3, 4); + pos1.equals(pos2); System.out.println(pos1); }